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

Diff Legend

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