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

Comparing src/common/xf.c (file contents):
Revision 1.4 by greg, Thu Oct 5 07:54:31 1989 UTC vs.
Revision 2.1 by greg, Tue Nov 12 16:54:14 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;
27 >        MAT4  xfmat, m4;
28 >        double  xfsca, dtmp;
29 >        int  i, icnt;
30  
31 <        setident4(retmat);
32 <        *retsca = 1.0;
31 >        setident4(ret->xfm);
32 >        ret->sca = 1.0;
33  
34 <        rept = 1;
34 >        icnt = 1;
35          setident4(xfmat);
36          xfsca = 1.0;
37  
# Line 43 | Line 42 | char  *av[];
42                  switch (av[i][1]) {
43          
44                  case 't':                       /* translate */
45 <                        checkarg("-t",3);
45 >                        checkarg(2,"fff");
46                          m4[3][0] = atof(av[++i]);
47                          m4[3][1] = atof(av[++i]);
48                          m4[3][2] = atof(av[++i]);
# Line 52 | Line 51 | char  *av[];
51                  case 'r':                       /* rotate */
52                          switch (av[i][2]) {
53                          case 'x':
54 <                                checkarg("-rx",1);
55 <                                theta = PI/180.0 * atof(av[++i]);
56 <                                m4[1][1] = m4[2][2] = cos(theta);
57 <                                m4[2][1] = -(m4[1][2] = sin(theta));
54 >                                checkarg(3,"f");
55 >                                dtmp = d2r(atof(av[++i]));
56 >                                m4[1][1] = m4[2][2] = cos(dtmp);
57 >                                m4[2][1] = -(m4[1][2] = sin(dtmp));
58                                  break;
59                          case 'y':
60 <                                checkarg("-ry",1);
61 <                                theta = PI/180.0 * atof(av[++i]);
62 <                                m4[0][0] = m4[2][2] = cos(theta);
63 <                                m4[0][2] = -(m4[2][0] = sin(theta));
60 >                                checkarg(3,"f");
61 >                                dtmp = d2r(atof(av[++i]));
62 >                                m4[0][0] = m4[2][2] = cos(dtmp);
63 >                                m4[0][2] = -(m4[2][0] = sin(dtmp));
64                                  break;
65                          case 'z':
66 <                                checkarg("-rz",1);
67 <                                theta = PI/180.0 * atof(av[++i]);
68 <                                m4[0][0] = m4[1][1] = cos(theta);
69 <                                m4[1][0] = -(m4[0][1] = sin(theta));
66 >                                checkarg(3,"f");
67 >                                dtmp = d2r(atof(av[++i]));
68 >                                m4[0][0] = m4[1][1] = cos(dtmp);
69 >                                m4[1][0] = -(m4[0][1] = sin(dtmp));
70                                  break;
71                          default:
72                                  return(i);
# Line 75 | Line 74 | char  *av[];
74                          break;
75  
76                  case 's':                       /* scale */
77 <                        checkarg("-s",1);
77 >                        checkarg(2,"f");
78 >                        dtmp = atof(av[i+1]);
79 >                        if (dtmp == 0.0) goto done;
80 >                        i++;
81                          xfsca *=
82                          m4[0][0] =
83                          m4[1][1] =
84 <                        m4[2][2] = atof(av[++i]);
84 >                        m4[2][2] = dtmp;
85                          break;
86  
87                  case 'm':                       /* mirror */
88                          switch (av[i][2]) {
89                          case 'x':
90 <                                checkarg("-mx",0);
90 >                                checkarg(3,"");
91                                  xfsca *=
92                                  m4[0][0] = -1.0;
93                                  break;
94                          case 'y':
95 <                                checkarg("-my",0);
95 >                                checkarg(3,"");
96                                  xfsca *=
97                                  m4[1][1] = -1.0;
98                                  break;
99                          case 'z':
100 <                                checkarg("-mz",0);
100 >                                checkarg(3,"");
101                                  xfsca *=
102                                  m4[2][2] = -1.0;
103                                  break;
# Line 105 | Line 107 | char  *av[];
107                          break;
108  
109                  case 'i':                       /* iterate */
110 <                        checkarg("-i",1);
111 <                        for (j = 0; j < rept; j++) {
112 <                                multmat4(retmat, retmat, xfmat);
113 <                                *retsca *= xfsca;
110 >                        checkarg(2,"i");
111 >                        while (icnt-- > 0) {
112 >                                multmat4(ret->xfm, ret->xfm, xfmat);
113 >                                ret->sca *= xfsca;
114                          }
115 <                        rept = atoi(av[++i]);
115 >                        icnt = atoi(av[++i]);
116                          setident4(xfmat);
117                          xfsca = 1.0;
118 <                        break;
118 >                        continue;
119  
120                  default:
121                          return(i);
# Line 122 | Line 124 | char  *av[];
124                  multmat4(xfmat, xfmat, m4);
125          }
126   done:
127 <        for (j = 0; j < rept; j++) {
128 <                multmat4(retmat, retmat, xfmat);
129 <                *retsca *= xfsca;
127 >        while (icnt-- > 0) {
128 >                multmat4(ret->xfm, ret->xfm, xfmat);
129 >                ret->sca *= xfsca;
130          }
131          return(i);
132   }
133  
134  
133 – #ifdef  INVXF
135   int
136 < invxf(retmat, retsca, ac, av)           /* invert transform specification */
137 < double  retmat[4][4];
137 < double  *retsca;
136 > invxf(ret, ac, av)              /* invert transform specification */
137 > register XF  *ret;
138   int  ac;
139   char  *av[];
140   {
141          double  atof(), sin(), cos();
142 <        double  xfmat[4][4], m4[4][4];
143 <        double  xfsca, theta;
144 <        int  i, j;
145 <        int  rept;
142 >        MAT4  xfmat, m4;
143 >        double  xfsca, dtmp;
144 >        int  i, icnt;
145  
146 <        setident4(retmat);
147 <        *retsca = 1.0;
146 >        setident4(ret->xfm);
147 >        ret->sca = 1.0;
148  
149 <        rept = 1;
149 >        icnt = 1;
150          setident4(xfmat);
151          xfsca = 1.0;
152  
# Line 158 | Line 157 | char  *av[];
157                  switch (av[i][1]) {
158          
159                  case 't':                       /* translate */
160 <                        checkarg("-t",3);
160 >                        checkarg(2,"fff");
161                          m4[3][0] = -atof(av[++i]);
162                          m4[3][1] = -atof(av[++i]);
163                          m4[3][2] = -atof(av[++i]);
# Line 167 | Line 166 | char  *av[];
166                  case 'r':                       /* rotate */
167                          switch (av[i][2]) {
168                          case 'x':
169 <                                checkarg("-rx",1);
170 <                                theta = -PI/180.0 * atof(av[++i]);
171 <                                m4[1][1] = m4[2][2] = cos(theta);
172 <                                m4[2][1] = -(m4[1][2] = sin(theta));
169 >                                checkarg(3,"f");
170 >                                dtmp = -d2r(atof(av[++i]));
171 >                                m4[1][1] = m4[2][2] = cos(dtmp);
172 >                                m4[2][1] = -(m4[1][2] = sin(dtmp));
173                                  break;
174                          case 'y':
175 <                                checkarg("-ry",1);
176 <                                theta = -PI/180.0 * atof(av[++i]);
177 <                                m4[0][0] = m4[2][2] = cos(theta);
178 <                                m4[0][2] = -(m4[2][0] = sin(theta));
175 >                                checkarg(3,"f");
176 >                                dtmp = -d2r(atof(av[++i]));
177 >                                m4[0][0] = m4[2][2] = cos(dtmp);
178 >                                m4[0][2] = -(m4[2][0] = sin(dtmp));
179                                  break;
180                          case 'z':
181 <                                checkarg("-rz",1);
182 <                                theta = -PI/180.0 * atof(av[++i]);
183 <                                m4[0][0] = m4[1][1] = cos(theta);
184 <                                m4[1][0] = -(m4[0][1] = sin(theta));
181 >                                checkarg(3,"f");
182 >                                dtmp = -d2r(atof(av[++i]));
183 >                                m4[0][0] = m4[1][1] = cos(dtmp);
184 >                                m4[1][0] = -(m4[0][1] = sin(dtmp));
185                                  break;
186                          default:
187                                  return(i);
# Line 190 | Line 189 | char  *av[];
189                          break;
190  
191                  case 's':                       /* scale */
192 <                        checkarg("-s",1);
193 <                        *xfsca *=
192 >                        checkarg(2,"f");
193 >                        dtmp = atof(av[i+1]);
194 >                        if (dtmp == 0.0) goto done;
195 >                        i++;
196 >                        xfsca *=
197                          m4[0][0] =
198                          m4[1][1] =
199 <                        m4[2][2] = 1.0 / atof(av[++i]);
199 >                        m4[2][2] = 1.0 / dtmp;
200                          break;
201  
202                  case 'm':                       /* mirror */
203                          switch (av[i][2]) {
204                          case 'x':
205 <                                checkarg("-mx",0);
206 <                                *xfsca *=
205 >                                checkarg(3,"");
206 >                                xfsca *=
207                                  m4[0][0] = -1.0;
208                                  break;
209                          case 'y':
210 <                                checkarg("-my",0);
211 <                                *xfsca *=
210 >                                checkarg(3,"");
211 >                                xfsca *=
212                                  m4[1][1] = -1.0;
213                                  break;
214                          case 'z':
215 <                                checkarg("-mz",0);
216 <                                *xfsca *=
215 >                                checkarg(3,"");
216 >                                xfsca *=
217                                  m4[2][2] = -1.0;
218                                  break;
219                          default:
# Line 220 | Line 222 | char  *av[];
222                          break;
223  
224                  case 'i':                       /* iterate */
225 <                        checkarg("-i",1);
226 <                        for (j = 0; j < rept; j++) {
227 <                                multmat4(retmat, xfmat, retmat);
228 <                                *retsca *= xfsca;
225 >                        checkarg(2,"i");
226 >                        while (icnt-- > 0) {
227 >                                multmat4(ret->xfm, xfmat, ret->xfm);
228 >                                ret->sca *= xfsca;
229                          }
230 <                        rept = atoi(av[++i]);
230 >                        icnt = atoi(av[++i]);
231                          setident4(xfmat);
232                          xfsca = 1.0;
233                          break;
# Line 237 | Line 239 | char  *av[];
239                  multmat4(xfmat, m4, xfmat);     /* left multiply */
240          }
241   done:
242 <        for (j = 0; j < rept; j++) {
243 <                multmat4(retmat, xfmat, retmat);
244 <                *retsca *= xfsca;
242 >        while (icnt-- > 0) {
243 >                multmat4(ret->xfm, xfmat, ret->xfm);
244 >                ret->sca *= xfsca;
245          }
246          return(i);
247   }
248 < #endif
248 >
249 >
250 > int
251 > fullxf(fx, ac, av)                      /* compute both forward and inverse */
252 > FULLXF  *fx;
253 > int  ac;
254 > char  *av[];
255 > {
256 >        xf(&fx->f, ac, av);
257 >        return(invxf(&fx->b, ac, av));
258 > }

Diff Legend

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