--- ray/src/common/image.c 2003/02/22 02:07:22 2.16
+++ ray/src/common/image.c 2013/04/03 00:35:09 2.40
@@ -1,5 +1,5 @@
#ifndef lint
-static const char RCSid[] = "$Id: image.c,v 2.16 2003/02/22 02:07:22 greg Exp $";
+static const char RCSid[] = "$Id: image.c,v 2.40 2013/04/03 00:35:09 greg Exp $";
#endif
/*
* image.c - routines for image generation.
@@ -7,68 +7,14 @@ static const char RCSid[] = "$Id: image.c,v 2.16 2003/
* External symbols declared in view.h
*/
-/* ====================================================================
- * The Radiance Software License, Version 1.0
- *
- * Copyright (c) 1990 - 2002 The Regents of the University of California,
- * through Lawrence Berkeley National Laboratory. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in
- * the documentation and/or other materials provided with the
- * distribution.
- *
- * 3. The end-user documentation included with the redistribution,
- * if any, must include the following acknowledgment:
- * "This product includes Radiance software
- * (http://radsite.lbl.gov/)
- * developed by the Lawrence Berkeley National Laboratory
- * (http://www.lbl.gov/)."
- * Alternately, this acknowledgment may appear in the software itself,
- * if and wherever such third-party acknowledgments normally appear.
- *
- * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
- * and "The Regents of the University of California" must
- * not be used to endorse or promote products derived from this
- * software without prior written permission. For written
- * permission, please contact radiance@radsite.lbl.gov.
- *
- * 5. Products derived from this software may not be called "Radiance",
- * nor may "Radiance" appear in their name, without prior written
- * permission of Lawrence Berkeley National Laboratory.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
- * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- * ====================================================================
- *
- * This software consists of voluntary contributions made by many
- * individuals on behalf of Lawrence Berkeley National Laboratory. For more
- * information on Lawrence Berkeley National Laboratory, please see
- * .
- */
+#include "copyright.h"
-#include "standard.h"
-
+#include
+#include "rtio.h"
+#include "rtmath.h"
+#include "paths.h"
#include "view.h"
-#include "paths.h"
#define FEQ(x,y) (fabs((x)-(y)) <= FTINY)
#define VEQ(v,w) (FEQ((v)[0],(w)[0]) && FEQ((v)[1],(w)[1]) \
@@ -76,18 +22,25 @@ static const char RCSid[] = "$Id: image.c,v 2.16 2003/
VIEW stdview = STDVIEW; /* default view parameters */
+static gethfunc gethview;
+
char *
-setview(v) /* set hvec and vvec, return message on error */
-register VIEW *v;
+setview( /* set hvec and vvec, return message on error */
+VIEW *v
+)
{
static char ill_horiz[] = "illegal horizontal view size";
static char ill_vert[] = "illegal vertical view size";
- if (v->vaft < -FTINY || (v->vaft > FTINY && v->vaft <= v->vfore))
+ if ((v->vfore < -FTINY) | (v->vaft < -FTINY) ||
+ (v->vaft > FTINY) & (v->vaft <= v->vfore))
return("illegal fore/aft clipping plane");
- if (normalize(v->vdir) == 0.0) /* normalize direction */
+ if (v->vdist <= FTINY)
+ return("illegal view distance");
+ v->vdist *= normalize(v->vdir); /* normalize direction */
+ if (v->vdist == 0.0)
return("zero view direction");
if (normalize(v->vup) == 0.0) /* normalize view up */
@@ -142,10 +95,20 @@ register VIEW *v;
v->hn2 = 2.0 * sin(v->horiz*(PI/180.0/2.0));
v->vn2 = 2.0 * sin(v->vert*(PI/180.0/2.0));
break;
+ case VT_PLS: /* planispheric fisheye */
+ if (v->horiz >= 360.0-FTINY)
+ return(ill_horiz);
+ if (v->vert >= 360.0-FTINY)
+ return(ill_vert);
+ v->hn2 = 2.*sin(v->horiz*(PI/180.0/2.0)) /
+ (1.0 + cos(v->horiz*(PI/180.0/2.0)));
+ v->vn2 = 2.*sin(v->vert*(PI/180.0/2.0)) /
+ (1.0 + cos(v->vert*(PI/180.0/2.0)));
+ break;
default:
return("unknown view type");
}
- if (v->type != VT_ANG) {
+ if (v->type != VT_ANG && v->type != VT_PLS) {
if (v->type != VT_CYL) {
v->hvec[0] *= v->hn2;
v->hvec[1] *= v->hn2;
@@ -163,10 +126,12 @@ register VIEW *v;
void
-normaspect(va, ap, xp, yp) /* fix pixel aspect or resolution */
-double va; /* view aspect ratio */
-double *ap; /* pixel aspect in (or out if 0) */
-int *xp, *yp; /* x and y resolution in (or out if *ap!=0) */
+normaspect( /* fix pixel aspect or resolution */
+double va, /* view aspect ratio */
+double *ap, /* pixel aspect in (or out if 0) */
+int *xp,
+int *yp /* x and y resolution in (or out if *ap!=0) */
+)
{
if (*ap <= FTINY)
*ap = va * *xp / *yp; /* compute pixel aspect */
@@ -178,10 +143,13 @@ int *xp, *yp; /* x and y resolution in (or out if *
double
-viewray(orig, direc, v, x, y) /* compute ray origin and direction */
-FVECT orig, direc;
-register VIEW *v;
-double x, y;
+viewray( /* compute ray origin and direction */
+FVECT orig,
+FVECT direc,
+VIEW *v,
+double x,
+double y
+)
{
double d, z;
@@ -202,9 +170,7 @@ double x, y;
direc[0] = v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
direc[1] = v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
direc[2] = v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
- orig[0] = v->vp[0] + v->vfore*direc[0];
- orig[1] = v->vp[1] + v->vfore*direc[1];
- orig[2] = v->vp[2] + v->vfore*direc[2];
+ VSUM(orig, v->vp, direc, v->vfore);
d = normalize(direc);
return(v->vaft > FTINY ? (v->vaft - v->vfore)*d : 0.0);
case VT_HEM: /* hemispherical fisheye */
@@ -215,9 +181,7 @@ double x, y;
direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
- orig[0] = v->vp[0] + v->vfore*direc[0];
- orig[1] = v->vp[1] + v->vfore*direc[1];
- orig[2] = v->vp[2] + v->vfore*direc[2];
+ VSUM(orig, v->vp, direc, v->vfore);
return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0);
case VT_CYL: /* cylindrical panorama */
d = x * v->horiz * (PI/180.0);
@@ -226,46 +190,53 @@ double x, y;
direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
- orig[0] = v->vp[0] + v->vfore*direc[0];
- orig[1] = v->vp[1] + v->vfore*direc[1];
- orig[2] = v->vp[2] + v->vfore*direc[2];
+ VSUM(orig, v->vp, direc, v->vfore);
d = normalize(direc);
return(v->vaft > FTINY ? (v->vaft - v->vfore)*d : 0.0);
case VT_ANG: /* angular fisheye */
- x *= v->horiz/180.0;
- y *= v->vert/180.0;
+ x *= (1.0/180.0)*v->horiz;
+ y *= (1.0/180.0)*v->vert;
d = x*x + y*y;
if (d > 1.0)
return(-1.0);
d = sqrt(d);
z = cos(PI*d);
- d = d <= FTINY ? PI : sqrt(1 - z*z)/d;
+ d = d <= FTINY ? PI : sqrt(1.0 - z*z)/d;
x *= d;
y *= d;
direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
- orig[0] = v->vp[0] + v->vfore*direc[0];
- orig[1] = v->vp[1] + v->vfore*direc[1];
- orig[2] = v->vp[2] + v->vfore*direc[2];
+ VSUM(orig, v->vp, direc, v->vfore);
return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0);
+ case VT_PLS: /* planispheric fisheye */
+ x *= sqrt(v->hn2);
+ y *= sqrt(v->vn2);
+ d = x*x + y*y;
+ z = (1. - d)/(1. + d);
+ x *= (1. + z);
+ y *= (1. + z);
+ direc[0] = z*v->vdir[0] + x*v->hvec[0] + y*v->vvec[0];
+ direc[1] = z*v->vdir[1] + x*v->hvec[1] + y*v->vvec[1];
+ direc[2] = z*v->vdir[2] + x*v->hvec[2] + y*v->vvec[2];
+ VSUM(orig, v->vp, direc, v->vfore);
+ return(v->vaft > FTINY ? v->vaft - v->vfore : 0.0);
}
return(-1.0);
}
void
-viewloc(ip, v, p) /* find image location for point */
-FVECT ip;
-register VIEW *v;
-FVECT p;
+viewloc( /* find image location for point */
+FVECT ip,
+VIEW *v,
+FVECT p
+)
{
double d, d2;
FVECT disp;
- disp[0] = p[0] - v->vp[0];
- disp[1] = p[1] - v->vp[1];
- disp[2] = p[2] - v->vp[2];
+ VSUB(disp, p, v->vp);
switch (v->type) {
case VT_PAR: /* parallel view */
@@ -314,10 +285,22 @@ FVECT p;
ip[0] += 180.0/v->horiz;
return;
}
- d = acos(d)/PI / sqrt(1.0 - d*d);
- ip[0] += DOT(disp,v->hvec)*d*180.0/v->horiz;
- ip[1] += DOT(disp,v->vvec)*d*180.0/v->vert;
+ d = (180.0/PI)*acos(d) / sqrt(1.0 - d*d);
+ ip[0] += DOT(disp,v->hvec)*d/v->horiz;
+ ip[1] += DOT(disp,v->vvec)*d/v->vert;
return;
+ case VT_PLS: /* planispheric fisheye */
+ ip[0] = 0.5 - v->hoff;
+ ip[1] = 0.5 - v->voff;
+ ip[2] = normalize(disp) - v->vfore;
+ d = DOT(disp,v->vdir);
+ if (d >= 1.0-FTINY)
+ return;
+ if (d <= -(1.0-FTINY))
+ return; /* really an error */
+ ip[0] += DOT(disp,v->hvec)/((1. + d)*sqrt(v->hn2));
+ ip[1] += DOT(disp,v->vvec)/((1. + d)*sqrt(v->vn2));
+ return;
}
ip[0] = DOT(disp,v->hvec)/v->hn2 + 0.5 - v->hoff;
ip[1] = DOT(disp,v->vvec)/v->vn2 + 0.5 - v->voff;
@@ -325,12 +308,14 @@ FVECT p;
void
-pix2loc(loc, rp, px, py) /* compute image location from pixel pos. */
-FLOAT loc[2];
-register RESOLU *rp;
-int px, py;
+pix2loc( /* compute image location from pixel pos. */
+RREAL loc[2],
+RESOLU *rp,
+int px,
+int py
+)
{
- register int x, y;
+ int x, y;
if (rp->rt & YMAJOR) {
x = px;
@@ -349,15 +334,18 @@ int px, py;
void
-loc2pix(pp, rp, lx, ly) /* compute pixel pos. from image location */
-int pp[2];
-register RESOLU *rp;
-double lx, ly;
+loc2pix( /* compute pixel pos. from image location */
+int pp[2],
+RESOLU *rp,
+double lx,
+double ly
+)
{
- register int x, y;
+ int x, y;
- x = lx * rp->xr;
- y = ly * rp->yr;
+ x = (int)(lx*rp->xr + .5 - (lx < 0.0));
+ y = (int)(ly*rp->yr + .5 - (ly < 0.0));
+
if (rp->rt & XDECR)
x = rp->xr-1 - x;
if (rp->rt & YDECR)
@@ -373,10 +361,11 @@ double lx, ly;
int
-getviewopt(v, ac, av) /* process view argument */
-register VIEW *v;
-int ac;
-register char *av[];
+getviewopt( /* process view argument */
+VIEW *v,
+int ac,
+char *av[]
+)
{
#define check(c,l) if ((av[0][c]&&av[0][c]!=' ') || \
badarg(ac-1,av+1,l)) return(-1)
@@ -401,6 +390,7 @@ register char *av[];
v->vdir[0] = atof(av[1]);
v->vdir[1] = atof(av[2]);
v->vdir[2] = atof(av[3]);
+ v->vdist = 1.;
return(3);
case 'u': /* up */
check(3,"fff");
@@ -440,24 +430,27 @@ register char *av[];
int
-sscanview(vp, s) /* get view parameters from string */
-VIEW *vp;
-register char *s;
+sscanview( /* get view parameters from string */
+VIEW *vp,
+char *s
+)
{
int ac;
char *av[4];
int na;
int nvopts = 0;
- if (*s != '-')
- s = sskip2(s,1);
+ while (isspace(*s))
+ if (!*s++)
+ return(0);
while (*s) {
ac = 0;
do {
- av[ac++] = s;
- while (*s && *s != ' ')
+ if (ac || *s == '-')
+ av[ac++] = s;
+ while (*s && !isspace(*s))
s++;
- while (*s == ' ')
+ while (isspace(*s))
s++;
} while (*s && ac < 4);
if ((na = getviewopt(vp, ac, av)) >= 0) {
@@ -472,13 +465,16 @@ register char *s;
void
-fprintview(vp, fp) /* write out view parameters */
-register VIEW *vp;
-FILE *fp;
+fprintview( /* write out view parameters */
+VIEW *vp,
+FILE *fp
+)
{
fprintf(fp, " -vt%c", vp->type);
fprintf(fp, " -vp %.6g %.6g %.6g", vp->vp[0], vp->vp[1], vp->vp[2]);
- fprintf(fp, " -vd %.6g %.6g %.6g", vp->vdir[0], vp->vdir[1], vp->vdir[2]);
+ fprintf(fp, " -vd %.6g %.6g %.6g", vp->vdir[0]*vp->vdist,
+ vp->vdir[1]*vp->vdist,
+ vp->vdir[2]*vp->vdist);
fprintf(fp, " -vu %.6g %.6g %.6g", vp->vup[0], vp->vup[1], vp->vup[2]);
fprintf(fp, " -vh %.6g -vv %.6g", vp->horiz, vp->vert);
fprintf(fp, " -vo %.6g -va %.6g", vp->vfore, vp->vaft);
@@ -487,12 +483,14 @@ FILE *fp;
char *
-viewopt(vp) /* translate to minimal view string */
-register VIEW *vp;
+viewopt( /* translate to minimal view string */
+VIEW *vp
+)
{
static char vwstr[128];
- register char *cp = vwstr;
+ char *cp = vwstr;
+ *cp = '\0';
if (vp->type != stdview.type) {
sprintf(cp, " -vt%c", vp->type);
cp += strlen(cp);
@@ -502,9 +500,11 @@ register VIEW *vp;
vp->vp[0], vp->vp[1], vp->vp[2]);
cp += strlen(cp);
}
- if (!VEQ(vp->vdir,stdview.vdir)) {
+ if (!FEQ(vp->vdist,stdview.vdist) || !VEQ(vp->vdir,stdview.vdir)) {
sprintf(cp, " -vd %.6g %.6g %.6g",
- vp->vdir[0], vp->vdir[1], vp->vdir[2]);
+ vp->vdir[0]*vp->vdist,
+ vp->vdir[1]*vp->vdist,
+ vp->vdir[2]*vp->vdist);
cp += strlen(cp);
}
if (!VEQ(vp->vup,stdview.vup)) {
@@ -541,13 +541,14 @@ register VIEW *vp;
int
-isview(s) /* is this a view string? */
-char *s;
+isview( /* is this a view string? */
+char *s
+)
{
- static char *altname[]={NULL,VIEWSTR,"rpict","rview","pinterp",NULL};
+ static char *altname[]={NULL,VIEWSTR,"rpict","rview","rvu","rpiece","pinterp",NULL};
extern char *progname;
- register char *cp;
- register char **an;
+ char *cp;
+ char **an;
/* add program name to list */
if (altname[0] == NULL) {
for (cp = progname; *cp; cp++)
@@ -576,21 +577,23 @@ struct myview {
static int
-gethview(s, v) /* get view from header */
-char *s;
-register struct myview *v;
+gethview( /* get view from header */
+ char *s,
+ void *v
+)
{
- if (isview(s) && sscanview(v->hv, s) > 0)
- v->ok++;
+ if (isview(s) && sscanview(((struct myview*)v)->hv, s) > 0)
+ ((struct myview*)v)->ok++;
return(0);
}
int
-viewfile(fname, vp, rp) /* get view from file */
-char *fname;
-VIEW *vp;
-RESOLU *rp;
+viewfile( /* get view from file */
+char *fname,
+VIEW *vp,
+RESOLU *rp
+)
{
struct myview mvs;
FILE *fp;
@@ -603,7 +606,7 @@ RESOLU *rp;
mvs.hv = vp;
mvs.ok = 0;
- getheader(fp, (int (*)(char *, char *))&gethview, (char *)&mvs);
+ getheader(fp, gethview, &mvs);
if (rp != NULL && !fgetsresolu(rp, fp))
mvs.ok = 0;