ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/xf.c
(Generate patch)

Comparing ray/src/common/xf.c (file contents):
Revision 1.4 by greg, Thu Oct 5 07:54:31 1989 UTC vs.
Revision 2.2 by greg, Thu Dec 19 14:45:41 1991 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1986 Regents of the University of California */
1 > /* Copyright (c) 1990 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 10 | Line 10 | static char SCCSid[] = "$SunId$ LBL";
10   *     1/28/86
11   */
12  
13 + #include  "standard.h"
14  
15 < #define  PI             3.14159265358979323846
15 > #define  d2r(a)         ((PI/180.)*(a))
16  
17 < #define  checkarg(a,n)  if (strcmp(av[i],a) || i+n >= ac) goto done
17 > #define  checkarg(a,l)  if (av[i][a] || badarg(ac-i-1,av+i+1,l)) goto done
18  
19  
20   int
21 < xf(retmat, retsca, ac, av)              /* get transform specification */
22 < double  retmat[4][4];
22 < double  *retsca;
21 > xf(ret, ac, av)                 /* get transform specification */
22 > register XF  *ret;
23   int  ac;
24   char  *av[];
25   {
26 <        double  atof(), sin(), cos();
27 <        double  xfmat[4][4], m4[4][4];
28 <        double  xfsca, theta;
29 <        int  i, j;
30 <        int  rept;
26 >        MAT4  xfmat, m4;
27 >        double  xfsca, dtmp;
28 >        int  i, icnt;
29  
30 <        setident4(retmat);
31 <        *retsca = 1.0;
30 >        setident4(ret->xfm);
31 >        ret->sca = 1.0;
32  
33 <        rept = 1;
33 >        icnt = 1;
34          setident4(xfmat);
35          xfsca = 1.0;
36  
# Line 43 | Line 41 | char  *av[];
41                  switch (av[i][1]) {
42          
43                  case 't':                       /* translate */
44 <                        checkarg("-t",3);
44 >                        checkarg(2,"fff");
45                          m4[3][0] = atof(av[++i]);
46                          m4[3][1] = atof(av[++i]);
47                          m4[3][2] = atof(av[++i]);
# Line 52 | Line 50 | char  *av[];
50                  case 'r':                       /* rotate */
51                          switch (av[i][2]) {
52                          case 'x':
53 <                                checkarg("-rx",1);
54 <                                theta = PI/180.0 * atof(av[++i]);
55 <                                m4[1][1] = m4[2][2] = cos(theta);
56 <                                m4[2][1] = -(m4[1][2] = sin(theta));
53 >                                checkarg(3,"f");
54 >                                dtmp = d2r(atof(av[++i]));
55 >                                m4[1][1] = m4[2][2] = cos(dtmp);
56 >                                m4[2][1] = -(m4[1][2] = sin(dtmp));
57                                  break;
58                          case 'y':
59 <                                checkarg("-ry",1);
60 <                                theta = PI/180.0 * atof(av[++i]);
61 <                                m4[0][0] = m4[2][2] = cos(theta);
62 <                                m4[0][2] = -(m4[2][0] = sin(theta));
59 >                                checkarg(3,"f");
60 >                                dtmp = d2r(atof(av[++i]));
61 >                                m4[0][0] = m4[2][2] = cos(dtmp);
62 >                                m4[0][2] = -(m4[2][0] = sin(dtmp));
63                                  break;
64                          case 'z':
65 <                                checkarg("-rz",1);
66 <                                theta = PI/180.0 * atof(av[++i]);
67 <                                m4[0][0] = m4[1][1] = cos(theta);
68 <                                m4[1][0] = -(m4[0][1] = sin(theta));
65 >                                checkarg(3,"f");
66 >                                dtmp = d2r(atof(av[++i]));
67 >                                m4[0][0] = m4[1][1] = cos(dtmp);
68 >                                m4[1][0] = -(m4[0][1] = sin(dtmp));
69                                  break;
70                          default:
71                                  return(i);
# Line 75 | Line 73 | char  *av[];
73                          break;
74  
75                  case 's':                       /* scale */
76 <                        checkarg("-s",1);
76 >                        checkarg(2,"f");
77 >                        dtmp = atof(av[i+1]);
78 >                        if (dtmp == 0.0) goto done;
79 >                        i++;
80                          xfsca *=
81                          m4[0][0] =
82                          m4[1][1] =
83 <                        m4[2][2] = atof(av[++i]);
83 >                        m4[2][2] = dtmp;
84                          break;
85  
86                  case 'm':                       /* mirror */
87                          switch (av[i][2]) {
88                          case 'x':
89 <                                checkarg("-mx",0);
89 >                                checkarg(3,"");
90                                  xfsca *=
91                                  m4[0][0] = -1.0;
92                                  break;
93                          case 'y':
94 <                                checkarg("-my",0);
94 >                                checkarg(3,"");
95                                  xfsca *=
96                                  m4[1][1] = -1.0;
97                                  break;
98                          case 'z':
99 <                                checkarg("-mz",0);
99 >                                checkarg(3,"");
100                                  xfsca *=
101                                  m4[2][2] = -1.0;
102                                  break;
# Line 105 | Line 106 | char  *av[];
106                          break;
107  
108                  case 'i':                       /* iterate */
109 <                        checkarg("-i",1);
110 <                        for (j = 0; j < rept; j++) {
111 <                                multmat4(retmat, retmat, xfmat);
112 <                                *retsca *= xfsca;
109 >                        checkarg(2,"i");
110 >                        while (icnt-- > 0) {
111 >                                multmat4(ret->xfm, ret->xfm, xfmat);
112 >                                ret->sca *= xfsca;
113                          }
114 <                        rept = atoi(av[++i]);
114 >                        icnt = atoi(av[++i]);
115                          setident4(xfmat);
116                          xfsca = 1.0;
117 <                        break;
117 >                        continue;
118  
119                  default:
120                          return(i);
# Line 122 | Line 123 | char  *av[];
123                  multmat4(xfmat, xfmat, m4);
124          }
125   done:
126 <        for (j = 0; j < rept; j++) {
127 <                multmat4(retmat, retmat, xfmat);
128 <                *retsca *= xfsca;
126 >        while (icnt-- > 0) {
127 >                multmat4(ret->xfm, ret->xfm, xfmat);
128 >                ret->sca *= xfsca;
129          }
130          return(i);
131   }
132  
133  
133 – #ifdef  INVXF
134   int
135 < invxf(retmat, retsca, ac, av)           /* invert transform specification */
136 < double  retmat[4][4];
137 < double  *retsca;
135 > invxf(ret, ac, av)              /* invert transform specification */
136 > register XF  *ret;
137   int  ac;
138   char  *av[];
139   {
140 <        double  atof(), sin(), cos();
141 <        double  xfmat[4][4], m4[4][4];
142 <        double  xfsca, theta;
144 <        int  i, j;
145 <        int  rept;
140 >        MAT4  xfmat, m4;
141 >        double  xfsca, dtmp;
142 >        int  i, icnt;
143  
144 <        setident4(retmat);
145 <        *retsca = 1.0;
144 >        setident4(ret->xfm);
145 >        ret->sca = 1.0;
146  
147 <        rept = 1;
147 >        icnt = 1;
148          setident4(xfmat);
149          xfsca = 1.0;
150  
# Line 158 | Line 155 | char  *av[];
155                  switch (av[i][1]) {
156          
157                  case 't':                       /* translate */
158 <                        checkarg("-t",3);
158 >                        checkarg(2,"fff");
159                          m4[3][0] = -atof(av[++i]);
160                          m4[3][1] = -atof(av[++i]);
161                          m4[3][2] = -atof(av[++i]);
# Line 167 | Line 164 | char  *av[];
164                  case 'r':                       /* rotate */
165                          switch (av[i][2]) {
166                          case 'x':
167 <                                checkarg("-rx",1);
168 <                                theta = -PI/180.0 * atof(av[++i]);
169 <                                m4[1][1] = m4[2][2] = cos(theta);
170 <                                m4[2][1] = -(m4[1][2] = sin(theta));
167 >                                checkarg(3,"f");
168 >                                dtmp = -d2r(atof(av[++i]));
169 >                                m4[1][1] = m4[2][2] = cos(dtmp);
170 >                                m4[2][1] = -(m4[1][2] = sin(dtmp));
171                                  break;
172                          case 'y':
173 <                                checkarg("-ry",1);
174 <                                theta = -PI/180.0 * atof(av[++i]);
175 <                                m4[0][0] = m4[2][2] = cos(theta);
176 <                                m4[0][2] = -(m4[2][0] = sin(theta));
173 >                                checkarg(3,"f");
174 >                                dtmp = -d2r(atof(av[++i]));
175 >                                m4[0][0] = m4[2][2] = cos(dtmp);
176 >                                m4[0][2] = -(m4[2][0] = sin(dtmp));
177                                  break;
178                          case 'z':
179 <                                checkarg("-rz",1);
180 <                                theta = -PI/180.0 * atof(av[++i]);
181 <                                m4[0][0] = m4[1][1] = cos(theta);
182 <                                m4[1][0] = -(m4[0][1] = sin(theta));
179 >                                checkarg(3,"f");
180 >                                dtmp = -d2r(atof(av[++i]));
181 >                                m4[0][0] = m4[1][1] = cos(dtmp);
182 >                                m4[1][0] = -(m4[0][1] = sin(dtmp));
183                                  break;
184                          default:
185                                  return(i);
# Line 190 | Line 187 | char  *av[];
187                          break;
188  
189                  case 's':                       /* scale */
190 <                        checkarg("-s",1);
191 <                        *xfsca *=
190 >                        checkarg(2,"f");
191 >                        dtmp = atof(av[i+1]);
192 >                        if (dtmp == 0.0) goto done;
193 >                        i++;
194 >                        xfsca *=
195                          m4[0][0] =
196                          m4[1][1] =
197 <                        m4[2][2] = 1.0 / atof(av[++i]);
197 >                        m4[2][2] = 1.0 / dtmp;
198                          break;
199  
200                  case 'm':                       /* mirror */
201                          switch (av[i][2]) {
202                          case 'x':
203 <                                checkarg("-mx",0);
204 <                                *xfsca *=
203 >                                checkarg(3,"");
204 >                                xfsca *=
205                                  m4[0][0] = -1.0;
206                                  break;
207                          case 'y':
208 <                                checkarg("-my",0);
209 <                                *xfsca *=
208 >                                checkarg(3,"");
209 >                                xfsca *=
210                                  m4[1][1] = -1.0;
211                                  break;
212                          case 'z':
213 <                                checkarg("-mz",0);
214 <                                *xfsca *=
213 >                                checkarg(3,"");
214 >                                xfsca *=
215                                  m4[2][2] = -1.0;
216                                  break;
217                          default:
# Line 220 | Line 220 | char  *av[];
220                          break;
221  
222                  case 'i':                       /* iterate */
223 <                        checkarg("-i",1);
224 <                        for (j = 0; j < rept; j++) {
225 <                                multmat4(retmat, xfmat, retmat);
226 <                                *retsca *= xfsca;
223 >                        checkarg(2,"i");
224 >                        while (icnt-- > 0) {
225 >                                multmat4(ret->xfm, xfmat, ret->xfm);
226 >                                ret->sca *= xfsca;
227                          }
228 <                        rept = atoi(av[++i]);
228 >                        icnt = atoi(av[++i]);
229                          setident4(xfmat);
230                          xfsca = 1.0;
231                          break;
# Line 237 | Line 237 | char  *av[];
237                  multmat4(xfmat, m4, xfmat);     /* left multiply */
238          }
239   done:
240 <        for (j = 0; j < rept; j++) {
241 <                multmat4(retmat, xfmat, retmat);
242 <                *retsca *= xfsca;
240 >        while (icnt-- > 0) {
241 >                multmat4(ret->xfm, xfmat, ret->xfm);
242 >                ret->sca *= xfsca;
243          }
244          return(i);
245   }
246 < #endif
246 >
247 >
248 > int
249 > fullxf(fx, ac, av)                      /* compute both forward and inverse */
250 > FULLXF  *fx;
251 > int  ac;
252 > char  *av[];
253 > {
254 >        xf(&fx->f, ac, av);
255 >        return(invxf(&fx->b, ac, av));
256 > }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines