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.49 by greg, Tue Aug 7 23:17:06 2018 UTC vs.
Revision 2.54 by greg, Thu Jan 13 00:26:09 2022 UTC

# Line 15 | Line 15 | static const char      RCSid[] = "$Id$";
15   #include  "paths.h"
16   #include  "view.h"
17  
18 –
19 – #define  FEQ(x,y)       (fabs((x)-(y)) <= FTINY)
20 – #define  VEQ(v,w)       (FEQ((v)[0],(w)[0]) && FEQ((v)[1],(w)[1]) \
21 –                                && FEQ((v)[2],(w)[2]))
22 –
18   VIEW  stdview = STDVIEW;                /* default view parameters */
19  
20   static gethfunc gethview;
# Line 68 | Line 63 | VIEW  *v
63                          return(ill_horiz);
64                  if (v->vert >= 180.0-FTINY)
65                          return(ill_vert);
66 <                v->hn2 = 2.0 * tan(v->horiz*(PI/180.0/2.0));
67 <                v->vn2 = 2.0 * tan(v->vert*(PI/180.0/2.0));
66 >                v->hn2 = 2.0 * tan(v->horiz*(PI/360.));
67 >                v->vn2 = 2.0 * tan(v->vert*(PI/360.));
68                  break;
69          case VT_CYL:                            /* cylindrical panorama */
70                  if (v->horiz > 360.0+FTINY)
# Line 77 | Line 72 | VIEW  *v
72                  if (v->vert >= 180.0-FTINY)
73                          return(ill_vert);
74                  v->hn2 = v->horiz * (PI/180.0);
75 <                v->vn2 = 2.0 * tan(v->vert*(PI/180.0/2.0));
75 >                v->vn2 = 2.0 * tan(v->vert*(PI/360.));
76                  break;
77          case VT_ANG:                            /* angular fisheye */
78                  if (v->horiz > 360.0+FTINY)
# Line 92 | Line 87 | VIEW  *v
87                          return(ill_horiz);
88                  if (v->vert > 180.0+FTINY)
89                          return(ill_vert);
90 <                v->hn2 = 2.0 * sin(v->horiz*(PI/180.0/2.0));
91 <                v->vn2 = 2.0 * sin(v->vert*(PI/180.0/2.0));
90 >                v->hn2 = 2.0 * sin(v->horiz*(PI/360.));
91 >                v->vn2 = 2.0 * sin(v->vert*(PI/360.));
92                  break;
93          case VT_PLS:                            /* planispheric fisheye */
94                  if (v->horiz >= 360.0-FTINY)
95                          return(ill_horiz);
96                  if (v->vert >= 360.0-FTINY)
97                          return(ill_vert);
98 <                v->hn2 = 2.*sin(v->horiz*(PI/180.0/2.0)) /
99 <                                (1.0 + cos(v->horiz*(PI/180.0/2.0)));
100 <                v->vn2 = 2.*sin(v->vert*(PI/180.0/2.0)) /
101 <                                (1.0 + cos(v->vert*(PI/180.0/2.0)));
98 >                v->hn2 = 2.*sin(v->horiz*(PI/360.)) /
99 >                                (1.0 + cos(v->horiz*(PI/360.)));
100 >                v->vn2 = 2.*sin(v->vert*(PI/360.)) /
101 >                                (1.0 + cos(v->vert*(PI/360.)));
102                  break;
103          default:
104                  return("unknown view type");
# Line 125 | Line 120 | VIEW  *v
120   }
121  
122  
123 + char *
124 + cropview(                       /* crop a view to the indicated bounds */
125 + VIEW *v,
126 + double x0,
127 + double y0,
128 + double x1,
129 + double y1
130 + )
131 + {
132 +        static char     ill_hemi[] = "illegal crop for hemispherical view";
133 +        double  d;
134 +                                        /* order crop extrema */
135 +        if (x0 > x1) { d=x0; x0=x1; x1=d; }
136 +        if (y0 > y1) { d=y0; y0=y1; y1=d; }
137 +
138 +        if ((x1-x0 <= FTINY) | (y1-y0 <= FTINY))
139 +                return("zero crop area");
140 +
141 +        d = x1 - x0;                    /* adjust horizontal size? */
142 +        if (!FABSEQ(d, 1.))
143 +                switch (v->type) {
144 +                case VT_PER:
145 +                        v->horiz = 360./PI*atan( d*tan(PI/360.*v->horiz) );
146 +                        break;
147 +                case VT_PAR:
148 +                case VT_ANG:
149 +                case VT_CYL:
150 +                        v->horiz *= d;
151 +                        break;
152 +                case VT_HEM:
153 +                        d *= sin(PI/360.*v->horiz);
154 +                        if (d > 1.)
155 +                                return(ill_hemi);
156 +                        v->horiz = 360./PI*asin( d );
157 +                        break;
158 +                case VT_PLS:
159 +                        d *= sin(PI/360.*v->horiz) /
160 +                                        (1. + cos(PI/360.*v->horiz));
161 +                        v->horiz = 360./PI*acos( (1. - d*d) / (1. + d*d) );
162 +                        break;
163 +                }
164 +
165 +        d = y1 - y0;                    /* adjust vertical size? */
166 +        if (!FABSEQ(d, 1.))
167 +                switch (v->type) {
168 +                case VT_PER:
169 +                case VT_CYL:
170 +                        v->vert = 360./PI*atan( d*tan(PI/360.*v->vert) );
171 +                        break;
172 +                case VT_PAR:
173 +                case VT_ANG:
174 +                        v->vert *= d;
175 +                        break;
176 +                case VT_HEM:
177 +                        d *= sin(PI/360.*v->vert);
178 +                        if (d > 1.)
179 +                                return(ill_hemi);
180 +                        v->vert = 360./PI*asin( d );
181 +                        break;
182 +                case VT_PLS:
183 +                        d *= sin(PI/360.*v->vert) /
184 +                                        (1. + cos(PI/360.*v->vert));
185 +                        v->vert = 360./PI*acos( (1. - d*d) / (1. + d*d) );
186 +                        break;
187 +                }
188 +                                        /* adjust offsets */
189 +        v->hoff = ((x0 + x1)*.5 - .5 + v->hoff) / (x1 - x0);
190 +        v->voff = ((y0 + y1)*.5 - .5 + v->voff) / (y1 - y0);
191 +
192 +        return(setview(v));             /* final error checks & set-up */
193 + }
194 +
195 +
196   void
197   normaspect(                             /* fix pixel aspect or resolution */
198   double  va,                     /* view aspect ratio */
# Line 272 | Line 340 | FVECT  p
340                  d = DOT(disp,v->hvec);
341                  d2 = DOT(disp,v->vdir);
342                  ip[0] = 180.0/PI * atan2(d,d2) / v->horiz + 0.5 - v->hoff;
343 <                d = d*d + d2*d2;
344 <                if (d <= FTINY*FTINY)
343 >                d2 = d*d + d2*d2;
344 >                if (d2 <= FTINY*FTINY)
345                          return(VL_BAD); /* at pole */
346 <                if ((v->vaft > FTINY) & (d >= v->vaft*v->vaft))
346 >                if ((v->vaft > FTINY) & (d2 >= v->vaft*v->vaft))
347                          rflags |= VL_BEYOND;
348 <                d = 1.0/sqrt(d);
348 >                d = 1.0/sqrt(d2);
349                  ip[1] = DOT(disp,v->vvec)*d/v->vn2 + 0.5 - v->voff;
350                  ip[2] = VLEN(disp);
351                  ip[2] *= (1.0 - v->vfore*d);
# Line 514 | Line 582 | VIEW  *vp
582                  sprintf(cp, " -vt%c", vp->type);
583                  cp += strlen(cp);
584          }
585 <        if (!VEQ(vp->vp,stdview.vp)) {
585 >        if (!VABSEQ(vp->vp,stdview.vp)) {
586                  sprintf(cp, " -vp %.6g %.6g %.6g",
587                                  vp->vp[0], vp->vp[1], vp->vp[2]);
588                  cp += strlen(cp);
589          }
590 <        if (!FEQ(vp->vdist,stdview.vdist) || !VEQ(vp->vdir,stdview.vdir)) {
590 >        if (!FABSEQ(vp->vdist,stdview.vdist) || !VABSEQ(vp->vdir,stdview.vdir)) {
591                  sprintf(cp, " -vd %.6g %.6g %.6g",
592                                  vp->vdir[0]*vp->vdist,
593                                  vp->vdir[1]*vp->vdist,
594                                  vp->vdir[2]*vp->vdist);
595                  cp += strlen(cp);
596          }
597 <        if (!VEQ(vp->vup,stdview.vup)) {
597 >        if (!VABSEQ(vp->vup,stdview.vup)) {
598                  sprintf(cp, " -vu %.6g %.6g %.6g",
599                                  vp->vup[0], vp->vup[1], vp->vup[2]);
600                  cp += strlen(cp);
601          }
602 <        if (!FEQ(vp->horiz,stdview.horiz)) {
602 >        if (!FABSEQ(vp->horiz,stdview.horiz)) {
603                  sprintf(cp, " -vh %.6g", vp->horiz);
604                  cp += strlen(cp);
605          }
606 <        if (!FEQ(vp->vert,stdview.vert)) {
606 >        if (!FABSEQ(vp->vert,stdview.vert)) {
607                  sprintf(cp, " -vv %.6g", vp->vert);
608                  cp += strlen(cp);
609          }
610 <        if (!FEQ(vp->vfore,stdview.vfore)) {
610 >        if (!FABSEQ(vp->vfore,stdview.vfore)) {
611                  sprintf(cp, " -vo %.6g", vp->vfore);
612                  cp += strlen(cp);
613          }
614 <        if (!FEQ(vp->vaft,stdview.vaft)) {
614 >        if (!FABSEQ(vp->vaft,stdview.vaft)) {
615                  sprintf(cp, " -va %.6g", vp->vaft);
616                  cp += strlen(cp);
617          }
618 <        if (!FEQ(vp->hoff,stdview.hoff)) {
618 >        if (!FABSEQ(vp->hoff,stdview.hoff)) {
619                  sprintf(cp, " -vs %.6g", vp->hoff);
620                  cp += strlen(cp);
621          }
622 <        if (!FEQ(vp->voff,stdview.voff)) {
622 >        if (!FABSEQ(vp->voff,stdview.voff)) {
623                  sprintf(cp, " -vl %.6g", vp->voff);
624                  cp += strlen(cp);
625          }
# Line 630 | Line 698 | RESOLU  *rp
698          if (rp != NULL && !fgetsresolu(rp, fp))
699                  mvs.ok = 0;
700  
701 <        fclose(fp);
701 >        if (fp != stdin)
702 >                fclose(fp);
703  
704          return(mvs.ok);
705   }

Diff Legend

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