--- ray/src/common/fvect.c 2003/02/22 02:07:22 2.6
+++ ray/src/common/fvect.c 2014/12/08 23:51:12 2.21
@@ -1,99 +1,69 @@
#ifndef lint
-static const char RCSid[] = "$Id: fvect.c,v 2.6 2003/02/22 02:07:22 greg Exp $";
+static const char RCSid[] = "$Id: fvect.c,v 2.21 2014/12/08 23:51:12 greg Exp $";
#endif
/*
* fvect.c - routines for floating-point vector calculations
*/
-/* ====================================================================
- * 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"
+#define _USE_MATH_DEFINES
#include
#include "fvect.h"
+#include "random.h"
+double
+Acos(double x) /* insurance for touchy math library */
+{
+ if (x <= -1.+FTINY*FTINY)
+ return(M_PI);
+ if (x >= 1.-FTINY*FTINY)
+ return(.0);
+ return(acos(x));
+}
double
-fdot(v1, v2) /* return the dot product of two vectors */
-register FVECT v1, v2;
+Asin(double x) /* insurance for touchy math library */
{
+ if (x <= -1.+FTINY*FTINY)
+ return(-M_PI/2.);
+ if (x >= 1.-FTINY*FTINY)
+ return(M_PI/2);
+ return(asin(x));
+}
+
+double
+fdot( /* return the dot product of two vectors */
+const FVECT v1,
+const FVECT v2
+)
+{
return(DOT(v1,v2));
}
double
-dist2(p1, p2) /* return square of distance between points */
-register FVECT p1, p2;
+dist2( /* return square of distance between points */
+const FVECT p1,
+const FVECT p2
+)
{
FVECT delta;
- delta[0] = p2[0] - p1[0];
- delta[1] = p2[1] - p1[1];
- delta[2] = p2[2] - p1[2];
+ VSUB(delta, p2, p1);
return(DOT(delta, delta));
}
double
-dist2line(p, ep1, ep2) /* return square of distance to line */
-FVECT p; /* the point */
-FVECT ep1, ep2; /* points on the line */
+dist2line( /* return square of distance to line */
+const FVECT p, /* the point */
+const FVECT ep1,
+const FVECT ep2 /* points on the line */
+)
{
- register double d, d1, d2;
+ double d, d1, d2;
d = dist2(ep1, ep2);
d1 = dist2(ep1, p);
@@ -104,11 +74,13 @@ FVECT ep1, ep2; /* points on the line */
double
-dist2lseg(p, ep1, ep2) /* return square of distance to line segment */
-FVECT p; /* the point */
-FVECT ep1, ep2; /* the end points */
+dist2lseg( /* return square of distance to line segment */
+const FVECT p, /* the point */
+const FVECT ep1,
+const FVECT ep2 /* the end points */
+)
{
- register double d, d1, d2;
+ double d, d1, d2;
d = dist2(ep1, ep2);
d1 = dist2(ep1, p);
@@ -128,43 +100,54 @@ FVECT ep1, ep2; /* the end points */
void
-fcross(vres, v1, v2) /* vres = v1 X v2 */
-register FVECT vres, v1, v2;
+fcross( /* vres = v1 X v2 */
+FVECT vres,
+const FVECT v1,
+const FVECT v2
+)
{
- vres[0] = v1[1]*v2[2] - v1[2]*v2[1];
- vres[1] = v1[2]*v2[0] - v1[0]*v2[2];
- vres[2] = v1[0]*v2[1] - v1[1]*v2[0];
+ if ((vres == v1) | (vres == v2)) {
+ FVECT vtmp;
+ VCROSS(vtmp, v1, v2);
+ VCOPY(vres, vtmp);
+ return;
+ }
+ VCROSS(vres, v1, v2);
}
void
-fvsum(vres, v0, v1, f) /* vres = v0 + f*v1 */
-register FVECT vres, v0, v1;
-register double f;
+fvsum( /* vres = v0 + f*v1 */
+FVECT vres,
+const FVECT v0,
+const FVECT v1,
+double f
+)
{
- vres[0] = v0[0] + f*v1[0];
- vres[1] = v0[1] + f*v1[1];
- vres[2] = v0[2] + f*v1[2];
+ VSUM(vres, v0, v1, f);
}
double
-normalize(v) /* normalize a vector, return old magnitude */
-register FVECT v;
+normalize( /* normalize a vector, return old magnitude */
+FVECT v
+)
{
- register double len, d;
+ double len, d;
d = DOT(v, v);
- if (d <= 0.0)
+ if (d == 0.0)
return(0.0);
- if (d <= 1.0+FTINY && d >= 1.0-FTINY)
+ if ((d <= 1.0+FTINY) & (d >= 1.0-FTINY)) {
len = 0.5 + 0.5*d; /* first order approximation */
- else
+ d = 2.0 - len;
+ } else {
len = sqrt(d);
-
- v[0] *= d = 1.0/len;
+ d = 1.0/len;
+ }
+ v[0] *= d;
v[1] *= d;
v[2] *= d;
@@ -172,14 +155,66 @@ register FVECT v;
}
+int
+getperpendicular( /* choose random perpedicular direction */
+FVECT vp, /* returns normalized */
+const FVECT v /* input vector must be normalized */
+)
+{
+ FVECT v1;
+ int i;
+ /* randomize other coordinates */
+ v1[0] = 0.5 - frandom();
+ v1[1] = 0.5 - frandom();
+ v1[2] = 0.5 - frandom();
+ for (i = 3; i--; )
+ if ((-0.6 < v[i]) & (v[i] < 0.6))
+ break;
+ if (i < 0)
+ return(0);
+ v1[i] = 1.0;
+ fcross(vp, v1, v);
+ return(normalize(vp) > 0.0);
+}
+
+
+int
+closestapproach( /* closest approach of two rays */
+RREAL t[2], /* returned distances along each ray */
+const FVECT rorg0, /* first origin */
+const FVECT rdir0, /* first direction (normalized) */
+const FVECT rorg1, /* second origin */
+const FVECT rdir1 /* second direction (normalized) */
+)
+{
+ double dotprod = DOT(rdir0, rdir1);
+ double denom = 1. - dotprod*dotprod;
+ double o1o2_d1;
+ FVECT o0o1;
+
+ if (denom <= FTINY) { /* check if lines are parallel */
+ t[0] = t[1] = 0.0;
+ return(0);
+ }
+ VSUB(o0o1, rorg0, rorg1);
+ o1o2_d1 = DOT(o0o1, rdir1);
+ t[0] = (o1o2_d1*dotprod - DOT(o0o1,rdir0)) / denom;
+ t[1] = o1o2_d1 + t[0]*dotprod;
+ return(1);
+}
+
+
void
-spinvector(vres, vorig, vnorm, theta) /* rotate vector around normal */
-FVECT vres, vorig, vnorm;
-double theta;
+spinvector( /* rotate vector around normal */
+FVECT vres, /* returned vector (same magnitude as vorig) */
+const FVECT vorig, /* original vector */
+const FVECT vnorm, /* normalized vector for rotation */
+double theta /* right-hand radians */
+)
{
double sint, cost, normprod;
FVECT vperp;
- register int i;
+ int i;
if (theta == 0.0) {
if (vres != vorig)
@@ -189,7 +224,52 @@ double theta;
cost = cos(theta);
sint = sin(theta);
normprod = DOT(vorig, vnorm)*(1.-cost);
- fcross(vperp, vnorm, vorig);
+ VCROSS(vperp, vnorm, vorig);
for (i = 0; i < 3; i++)
vres[i] = vorig[i]*cost + vnorm[i]*normprod + vperp[i]*sint;
+}
+
+double
+geodesic( /* rotate vector on great circle towards target */
+FVECT vres, /* returned vector (same magnitude as vorig) */
+const FVECT vorig, /* original vector */
+const FVECT vtarg, /* vector we are rotating towards */
+double t, /* amount along arc directed towards vtarg */
+int meas /* distance measure (radians, absolute, relative) */
+)
+{
+ FVECT normtarg;
+ double volen, dotprod, sintr, cost;
+ int i;
+
+ VCOPY(normtarg, vtarg); /* in case vtarg==vres */
+ if (vres != vorig)
+ VCOPY(vres, vorig);
+ if (t == 0.0)
+ return(VLEN(vres)); /* no rotation requested */
+ if ((volen = normalize(vres)) == 0.0)
+ return(0.0);
+ if (normalize(normtarg) == 0.0)
+ return(0.0); /* target vector is zero */
+ dotprod = DOT(vres, normtarg);
+ /* check for colinear */
+ if (dotprod >= 1.0-FTINY*FTINY) {
+ if (meas != GEOD_REL)
+ return(0.0);
+ vres[0] *= volen; vres[1] *= volen; vres[2] *= volen;
+ return(volen);
+ }
+ if (dotprod <= -1.0+FTINY*FTINY)
+ return(0.0);
+ if (meas == GEOD_ABS)
+ t /= volen;
+ else if (meas == GEOD_REL)
+ t *= acos(dotprod);
+ cost = cos(t);
+ sintr = sin(t) / sqrt(1. - dotprod*dotprod);
+ for (i = 0; i < 3; i++)
+ vres[i] = volen*( cost*vres[i] +
+ sintr*(normtarg[i] - dotprod*vres[i]) );
+
+ return(volen); /* return vector length */
}