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.3 by greg, Fri Mar 24 17:10:43 1989 UTC vs.
Revision 2.7 by greg, Fri Jun 27 22:27:45 2003 UTC

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

Diff Legend

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