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.36 by greg, Wed Mar 2 17:24:55 2011 UTC vs.
Revision 2.47 by greg, Fri Apr 27 17:36:01 2018 UTC

# Line 33 | Line 33 | VIEW  *v
33          static char  ill_horiz[] = "illegal horizontal view size";
34          static char  ill_vert[] = "illegal vertical view size";
35          
36 <        if (v->vaft < -FTINY || (v->vaft > FTINY && v->vaft <= v->vfore))
36 >        if ((v->vfore < -FTINY) | (v->vaft < -FTINY) ||
37 >                        (v->vaft > FTINY) & (v->vaft <= v->vfore))
38                  return("illegal fore/aft clipping plane");
39  
40          if (v->vdist <= FTINY)
# Line 169 | 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];
173 <                orig[1] = v->vp[1] + v->vfore*direc[1];
174 <                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 182 | 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];
186 <                orig[1] = v->vp[1] + v->vfore*direc[1];
187 <                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 193 | 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];
197 <                orig[1] = v->vp[1] + v->vfore*direc[1];
198 <                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 212 | 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];
216 <                orig[1] = v->vp[1] + v->vfore*direc[1];
217 <                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);
214                  y *= sqrt(v->vn2);
215                  d = x*x + y*y;
216                  z = (1. - d)/(1. + d);
217 <                d = d <= FTINY*FTINY ? PI : sqrt((1.0 - z*z)/d);
218 <                x *= d;
226 <                y *= d;
217 >                x *= (1. + z);
218 >                y *= (1. + z);
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 < )
234 > )       /* Use VL_* flags to interpret return value */
235   {
236 +        int     rflags = VL_GOOD;
237          double  d, d2;
238          FVECT  disp;
239  
# Line 254 | Line 245 | FVECT  p
245                  break;
246          case VT_PER:                    /* perspective view */
247                  d = DOT(disp,v->vdir);
248 +                if ((v->vaft > FTINY) & (d >= v->vaft))
249 +                        rflags |= VL_BEYOND;
250                  ip[2] = VLEN(disp);
251 <                if (d < 0.0) {          /* fold pyramid */
251 >                if (d < -FTINY) {       /* fold pyramid */
252                          ip[2] = -ip[2];
253                          d = -d;
254 <                }
255 <                if (d > FTINY) {
256 <                        d = 1.0/d;
257 <                        disp[0] *= d;
258 <                        disp[1] *= d;
259 <                        disp[2] *= d;
260 <                }
254 >                } else if (d <= FTINY)
255 >                        return(VL_BAD); /* at infinite edge */
256 >                d = 1.0/d;
257 >                disp[0] *= d;
258 >                disp[1] *= d;
259 >                disp[2] *= d;
260 >                if (ip[2] < 0.0) d = -d;
261                  ip[2] *= (1.0 - v->vfore*d);
262                  break;
263          case VT_HEM:                    /* hemispherical fisheye */
# Line 279 | Line 272 | FVECT  p
272                  d = DOT(disp,v->hvec);
273                  d2 = DOT(disp,v->vdir);
274                  ip[0] = 180.0/PI * atan2(d,d2) / v->horiz + 0.5 - v->hoff;
275 <                d = 1.0/sqrt(d*d + d2*d2);
275 >                d = d*d + d2*d2;
276 >                if (d <= FTINY*FTINY)
277 >                        return(VL_BAD); /* at pole */
278 >                if ((v->vaft > FTINY) & (d >= v->vaft*v->vaft))
279 >                        rflags |= VL_BEYOND;
280 >                d = 1.0/sqrt(d);
281                  ip[1] = DOT(disp,v->vvec)*d/v->vn2 + 0.5 - v->voff;
282                  ip[2] = VLEN(disp);
283                  ip[2] *= (1.0 - v->vfore*d);
284 <                return;
284 >                goto gotall;
285          case VT_ANG:                    /* angular fisheye */
286                  ip[0] = 0.5 - v->hoff;
287                  ip[1] = 0.5 - v->voff;
288                  ip[2] = normalize(disp) - v->vfore;
289                  d = DOT(disp,v->vdir);
290                  if (d >= 1.0-FTINY)
291 <                        return;
291 >                        goto gotall;
292                  if (d <= -(1.0-FTINY)) {
293                          ip[0] += 180.0/v->horiz;
294 <                        return;
294 >                        goto gotall;
295                  }
296                  d = (180.0/PI)*acos(d) / sqrt(1.0 - d*d);
297                  ip[0] += DOT(disp,v->hvec)*d/v->horiz;
298                  ip[1] += DOT(disp,v->vvec)*d/v->vert;
299 <                return;
299 >                goto gotall;
300          case VT_PLS:                    /* planispheric fisheye */
301                  ip[0] = 0.5 - v->hoff;
302                  ip[1] = 0.5 - v->voff;
303                  ip[2] = normalize(disp) - v->vfore;
304                  d = DOT(disp,v->vdir);
305                  if (d >= 1.0-FTINY)
306 <                        return;
306 >                        goto gotall;
307                  if (d <= -(1.0-FTINY))
308 <                        return;         /* really an error */
309 <                d = sqrt(1.0 - d*d) / (1.0 + d);
310 <                ip[0] += DOT(disp,v->hvec)*d/sqrt(v->hn2);
311 <                ip[1] += DOT(disp,v->vvec)*d/sqrt(v->vn2);
312 <                return;
308 >                        return(VL_BAD);
309 >                ip[0] += DOT(disp,v->hvec)/((1. + d)*sqrt(v->hn2));
310 >                ip[1] += DOT(disp,v->vvec)/((1. + d)*sqrt(v->vn2));
311 >                goto gotall;
312 >        default:
313 >                return(VL_BAD);
314          }
315          ip[0] = DOT(disp,v->hvec)/v->hn2 + 0.5 - v->hoff;
316          ip[1] = DOT(disp,v->vvec)/v->vn2 + 0.5 - v->voff;
317 + gotall:                                 /* add appropriate return flags */
318 +        if (!(rflags & (VL_BEHIND|VL_BEYOND)))
319 +                rflags |= (ip[2] <= 0.0) ? VL_BEHIND :
320 +                                          VL_BEYOND * ((v->vaft > FTINY) &
321 +                                                (ip[2] >= v->vaft - v->vfore));
322 +        rflags |= VL_OUTSIDE*((0.0 >= ip[0]) | (ip[0] >= 1.0) |
323 +                                (0.0 >= ip[1]) | (ip[1] >= 1.0));
324 +        return(rflags);
325   }
326  
327  
# Line 354 | Line 361 | double  ly
361   {
362          int  x, y;
363  
364 <        x = (lx >= 0.0) ? (int)(lx * rp->xr) : -(int)(-lx * rp->xr);
365 <        y = (ly >= 0.0) ? (int)(ly * rp->yr) : -(int)(-ly * rp->yr);
364 >        x = (int)(lx*rp->xr + .5 - (lx < 0.0));
365 >        y = (int)(ly*rp->yr + .5 - (ly < 0.0));
366 >
367          if (rp->rt & XDECR)
368                  x = rp->xr-1 - x;
369          if (rp->rt & YDECR)

Diff Legend

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