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

Comparing ray/src/common/image.c (file contents):
Revision 2.39 by greg, Sun Mar 24 19:40:26 2013 UTC vs.
Revision 2.43 by greg, Wed Jan 24 04:39:52 2018 UTC

# Line 170 | Line 170 | double  y
170                  direc[0] = v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
171                  direc[1] = v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
172                  direc[2] = v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
173 <                orig[0] = v->vp[0] + v->vfore*direc[0];
174 <                orig[1] = v->vp[1] + v->vfore*direc[1];
175 <                orig[2] = v->vp[2] + v->vfore*direc[2];
173 >                VSUM(orig, v->vp, direc, v->vfore);
174                  d = normalize(direc);
175                  return(v->vaft > FTINY ? (v->vaft - v->vfore)*d : 0.0);
176          case VT_HEM:                    /* hemispherical fisheye */
# Line 183 | Line 181 | double  y
181                  direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
182                  direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
183                  direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
184 <                orig[0] = v->vp[0] + v->vfore*direc[0];
187 <                orig[1] = v->vp[1] + v->vfore*direc[1];
188 <                orig[2] = v->vp[2] + v->vfore*direc[2];
184 >                VSUM(orig, v->vp, direc, v->vfore);
185                  return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0);
186          case VT_CYL:                    /* cylindrical panorama */
187                  d = x * v->horiz * (PI/180.0);
# Line 194 | Line 190 | double  y
190                  direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
191                  direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
192                  direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
193 <                orig[0] = v->vp[0] + v->vfore*direc[0];
198 <                orig[1] = v->vp[1] + v->vfore*direc[1];
199 <                orig[2] = v->vp[2] + v->vfore*direc[2];
193 >                VSUM(orig, v->vp, direc, v->vfore);
194                  d = normalize(direc);
195                  return(v->vaft > FTINY ? (v->vaft - v->vfore)*d : 0.0);
196          case VT_ANG:                    /* angular fisheye */
# Line 213 | Line 207 | double  y
207                  direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
208                  direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
209                  direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
210 <                orig[0] = v->vp[0] + v->vfore*direc[0];
217 <                orig[1] = v->vp[1] + v->vfore*direc[1];
218 <                orig[2] = v->vp[2] + v->vfore*direc[2];
210 >                VSUM(orig, v->vp, direc, v->vfore);
211                  return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0);
212          case VT_PLS:                    /* planispheric fisheye */
213                  x *= sqrt(v->hn2);
# Line 227 | Line 219 | double  y
219                  direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
220                  direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
221                  direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
222 <                orig[0] = v->vp[0] + v->vfore*direc[0];
231 <                orig[1] = v->vp[1] + v->vfore*direc[1];
232 <                orig[2] = v->vp[2] + v->vfore*direc[2];
222 >                VSUM(orig, v->vp, direc, v->vfore);
223                  return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0);
224          }
225          return(-1.0);
226   }
227  
228  
229 < void
229 > int
230   viewloc(                        /* find image location for point */
231   FVECT  ip,
232   VIEW  *v,
233   FVECT  p
234   )
235   {
236 +        int     rval;
237          double  d, d2;
238          FVECT  disp;
239  
# Line 255 | Line 246 | FVECT  p
246          case VT_PER:                    /* perspective view */
247                  d = DOT(disp,v->vdir);
248                  ip[2] = VLEN(disp);
249 <                if (d < 0.0) {          /* fold pyramid */
249 >                if (d < -FTINY) {       /* fold pyramid */
250                          ip[2] = -ip[2];
251                          d = -d;
252 <                }
253 <                if (d > FTINY) {
254 <                        d = 1.0/d;
255 <                        disp[0] *= d;
256 <                        disp[1] *= d;
257 <                        disp[2] *= d;
258 <                }
252 >                } else if (d <= FTINY)
253 >                        return(0);      /* at infinite edge */
254 >                d = 1.0/d;
255 >                disp[0] *= d;
256 >                disp[1] *= d;
257 >                disp[2] *= d;
258 >                if (ip[2] < 0.0) d = -d;
259                  ip[2] *= (1.0 - v->vfore*d);
260                  break;
261          case VT_HEM:                    /* hemispherical fisheye */
# Line 279 | Line 270 | FVECT  p
270                  d = DOT(disp,v->hvec);
271                  d2 = DOT(disp,v->vdir);
272                  ip[0] = 180.0/PI * atan2(d,d2) / v->horiz + 0.5 - v->hoff;
273 <                d = 1.0/sqrt(d*d + d2*d2);
273 >                d = d*d + d2*d2;
274 >                if (d <= FTINY*FTINY)
275 >                        return(0);      /* at pole */
276 >                d = 1.0/sqrt(d);
277                  ip[1] = DOT(disp,v->vvec)*d/v->vn2 + 0.5 - v->voff;
278                  ip[2] = VLEN(disp);
279                  ip[2] *= (1.0 - v->vfore*d);
280 <                return;
280 >                goto gotall;
281          case VT_ANG:                    /* angular fisheye */
282                  ip[0] = 0.5 - v->hoff;
283                  ip[1] = 0.5 - v->voff;
284                  ip[2] = normalize(disp) - v->vfore;
285                  d = DOT(disp,v->vdir);
286                  if (d >= 1.0-FTINY)
287 <                        return;
287 >                        goto gotall;
288                  if (d <= -(1.0-FTINY)) {
289                          ip[0] += 180.0/v->horiz;
290 <                        return;
290 >                        goto gotall;
291                  }
292                  d = (180.0/PI)*acos(d) / sqrt(1.0 - d*d);
293                  ip[0] += DOT(disp,v->hvec)*d/v->horiz;
294                  ip[1] += DOT(disp,v->vvec)*d/v->vert;
295 <                return;
295 >                goto gotall;
296          case VT_PLS:                    /* planispheric fisheye */
297                  ip[0] = 0.5 - v->hoff;
298                  ip[1] = 0.5 - v->voff;
299                  ip[2] = normalize(disp) - v->vfore;
300                  d = DOT(disp,v->vdir);
301                  if (d >= 1.0-FTINY)
302 <                        return;
302 >                        goto gotall;
303                  if (d <= -(1.0-FTINY))
304 <                        return;         /* really an error */
304 >                        return(0);
305                  ip[0] += DOT(disp,v->hvec)/((1. + d)*sqrt(v->hn2));
306                  ip[1] += DOT(disp,v->vvec)/((1. + d)*sqrt(v->vn2));
307 <                return;
307 >                goto gotall;
308          }
309          ip[0] = DOT(disp,v->hvec)/v->hn2 + 0.5 - v->hoff;
310          ip[1] = DOT(disp,v->vvec)/v->vn2 + 0.5 - v->voff;
311 + gotall:                                 /* return negative if behind */
312 +        rval = 1 - 2*(ip[2] <= 0.0);
313 +        if ((0.0 > ip[0]) | (ip[0] > 1.0) || (0.0 > ip[1]) | (ip[1] > 1.0))
314 +                return 2*rval;          /* +/-2 if outside frame */
315 +        return rval;
316   }
317  
318  

Diff Legend

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