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

Diff Legend

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