--- ray/src/util/ranimove2.c	2003/02/22 02:07:30	3.1
+++ ray/src/util/ranimove2.c	2016/04/18 22:39:13	3.10
@@ -1,71 +1,18 @@
 #ifndef lint
-static const char	RCSid[] = "$Id: ranimove2.c,v 3.1 2003/02/22 02:07:30 greg Exp $";
+static const char	RCSid[] = "$Id: ranimove2.c,v 3.10 2016/04/18 22:39:13 greg Exp $";
 #endif
 /*
  *  ranimove2.c
  *
- *  Frame refinement routines for ranimate(1).
+ *  Frame refinement routines for ranimove(1).
  *
  *  Created by Gregory Ward on Wed Jan 08 2003.
  */
 
-/* ====================================================================
- * 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
- * <http://www.lbl.gov/>.
- */
+#include "copyright.h"
 
+#include <string.h>
+
 #include "ranimove.h"
 #include "random.h"
 
@@ -74,16 +21,20 @@ static const char	RCSid[] = "$Id: ranimove2.c,v 3.1 20
 
 int	cerrzero;		/* is cerrmap all zeroes? */
 
+static int ppri_cmp(const void *pp1, const void *pp2);
+static int ray_refine(int	n);
+static long refine_rays(long	nrays);
 
+
 int
-refine_first()			/* initial refinement pass */
+refine_first(void)			/* initial refinement pass */
 {
 	int	*esamp = (int *)zprev;	/* OK to reuse */
 	int	hl_erri = errori(HL_ERR);
 	int	nextra = 0;
 	int	x, y, xp, yp;
 	int	neigh;
-	register int	n, np;
+	int	n, np;
 
 	if (sizeof(int) < sizeof(*zprev))
 		error(CONSISTENCY, "code error in refine_first");
@@ -91,7 +42,7 @@ refine_first()			/* initial refinement pass */
 		printf("\tFirst refinement pass...");
 		fflush(stdout);
 	}
-	bzero((void *)esamp, sizeof(int)*hres*vres);
+	memset((void *)esamp, '\0', sizeof(int)*hres*vres);
 	/*
 	 * In our initial pass, we look for lower error pixels from
 	 * the same objects in the previous frame, and copy them here.
@@ -104,10 +55,10 @@ refine_first()			/* initial refinement pass */
 		if (xmbuffer[n] == MO_UNK)
 			continue;
 		xp = x + xmbuffer[n];
-		if ((xp < 0 | xp >= hres))
+		if ((xp < 0) | (xp >= hres))
 			continue;
 		yp = y + ymbuffer[n];
-		if ((yp < 0 | yp >= vres))
+		if ((yp < 0) | (yp >= vres))
 			continue;
 		np = fndx(xp, yp);
 					/* make sure we hit same object */
@@ -170,9 +121,15 @@ struct ConspSum {
 static double	pixel_deg;	/* base pixel frequency */
 static int	fhsiz, fvsiz;	/* foveal subimage size */
 
+static void clr_consp(struct ConspSum *cs);
+static void sum_consp(struct ConspSum *cdest, struct ConspSum *cs);
+static void est_consp(int x0, int y0, int x1, int y1, struct ConspSum *cs);
+static void subconspicuity(int x0, int y0, int x1, int y1, struct ConspSum *cs);
+
 static void
-clr_consp(cs)			/* initialize a conspicuity sum */
-register struct ConspSum	*cs;
+clr_consp(			/* initialize a conspicuity sum */
+	struct ConspSum	*cs
+)
 {
 	if (cs == NULL)
 		return;
@@ -185,10 +142,12 @@ register struct ConspSum	*cs;
 }
 
 static void
-sum_consp(cdest, cs)		/* sum in conspicuity result */
-register struct ConspSum	*cdest, *cs;
+sum_consp(		/* sum in conspicuity result */
+	struct ConspSum	*cdest,
+	struct ConspSum	*cs
+)
 {
-	if ((cdest == NULL | cs == NULL))
+	if ((cdest == NULL) | (cs == NULL))
 		return;
 	addcolor(cdest->vsum, cs->vsum);
 	addcolor(cdest->v2sum, cs->v2sum);
@@ -201,9 +160,13 @@ register struct ConspSum	*cdest, *cs;
 }
 
 static void
-est_consp(x0,y0,x1,y1, cs)	/* estimate error conspicuity & update */
-int	x0, y0, x1, y1;
-register struct ConspSum	*cs;
+est_consp(	/* estimate error conspicuity & update */
+	int	x0,
+	int	y0,
+	int	x1,
+	int	y1,
+	struct ConspSum	*cs
+)
 {
 	double	rad2, mtn2, cpd, vm, vr, csf, eest;
 						/* do we care? */
@@ -218,7 +181,7 @@ register struct ConspSum	*cs;
 	} else
 		eest = estimaterr(cs->vsum, cs->v2sum, cs->nsamp, cs->nsamp);
 	
-	if ((x0 == x1-1 & y0 == y1-1)) {	/* update pixel error */
+	if ((x0 == x1-1) & (y0 == y1-1)) {	/* update pixel error */
 		int	n = fndx(x0, y0);
 		int	ai;
 		int	ne;
@@ -270,32 +233,37 @@ register struct ConspSum	*cs;
 						/* worth the bother? */
 	if (eest <= .01)
 		return;
-						/* sum into map */
+						/* put into map */
 	for ( ; y0 < y1; y0++) {
 		float	*em0 = cerrmap + fndx(x0, y0);
-		register float	*emp = em0 + (x1-x0);
+		float	*emp = em0 + (x1-x0);
 		while (emp-- > em0)
-			*emp += eest;
+			if (eest > *emp)
+				*emp = eest;
 	}
 	cerrzero = 0;
 }
 
 static void
-subconspicuity(x0,y0,x1,y1, cs)	/* compute subportion of conspicuity */
-int	x0, y0, x1, y1;
-struct ConspSum	*cs;
+subconspicuity(	/* compute subportion of conspicuity */
+	int	x0,
+	int	y0,
+	int	x1,
+	int	y1,
+	struct ConspSum	*cs
+)
 {
 	struct ConspSum	mysum;
 	int	i;
 
-	if ((x0 >= x1 | y0 >= y1))
+	if ((x0 >= x1) | (y0 >= y1))
 		error(CONSISTENCY, "bad call to subconspicuity");
 
 	clr_consp(&mysum);			/* prepare sum */
 
-	if ((x0 == x1-1 & y0 == y1-1)) {	/* single pixel */
+	if ((x0 == x1-1) & (y0 == y1-1)) {	/* single pixel */
 		double	hls;
-		register int	n = fndx(x0, y0);
+		int	n = fndx(x0, y0);
 		if (sbuffer[n]) {
 			copycolor(mysum.vsum, cbuffer[n]);
 			copycolor(mysum.v2sum, val2map[n]);
@@ -343,13 +311,13 @@ struct ConspSum	*cs;
 }
 
 void
-conspicuity()			/* compute conspicuous error map */
+conspicuity(void)			/* compute conspicuous error map */
 {
 	int	fhres, fvres;
 	int	fx, fy;
 					/* reuse previous z-buffer */
 	cerrmap = (float *)zprev;
-	bzero((void *)cerrmap, sizeof(float)*hres*vres);
+	memset((void *)cerrmap, '\0', sizeof(float)*hres*vres);
 	cerrzero = 1;
 					/* compute base pixel frequency */
 	pixel_deg = .5*(hres/vw.horiz + vres/vw.vert);
@@ -383,8 +351,10 @@ static struct AmbSum {
 
 
 static int
-ppri_cmp(pp1, pp2)		/* pixel priority comparison */
-const void *pp1, *pp2;
+ppri_cmp(		/* pixel priority comparison */
+	const void *pp1,
+	const void *pp2
+)
 {
 	double	se1 = cerrmap[*(const int *)pp1];
 	double	se2 = cerrmap[*(const int *)pp2];
@@ -404,12 +374,11 @@ const void *pp1, *pp2;
 
 
 static int
-ray_refine(n)			/* refine the given pixel by tracing a ray */
-register int	n;
+ray_refine(			/* refine the given pixel by tracing a ray */
+	int	n
+)
 {
 	RAY	ir;
-	int	neigh[NSAMPOK];
-	int	nc;
 	COLOR	ctmp;
 	int	i;
 
@@ -427,7 +396,7 @@ register int	n;
 			return(-1);
 		if (nprocs > 1) {
 			int	rval;
-			rayorigin(&ir, NULL, PRIMARY, 1.0);
+			rayorigin(&ir, PRIMARY, NULL, NULL);
 			ir.rno = n;
 			rval = ray_pqueue(&ir);
 			if (!rval)
@@ -442,9 +411,9 @@ register int	n;
 		if (sbuffer[n] != 1)
 			error(CONSISTENCY, "bad code in ray_refine");
 		if (getambcolor(ctmp, obuffer[n]) &&
-				(colval(ctmp,RED) > 0.01 &
-				 colval(ctmp,GRN) > 0.01 &
-				 colval(ctmp,BLU) > 0.01)) {
+				(colval(ctmp,RED) > 0.01) &
+				(colval(ctmp,GRN) > 0.01) &
+				(colval(ctmp,BLU) > 0.01)) {
 			for (i = 0; i < 3; i++)
 				asump->diffsum[i] +=
 				    (colval(ir.rcol,i) - colval(cbuffer[n],i))
@@ -472,8 +441,9 @@ register int	n;
 
 
 static long
-refine_rays(nrays)		/* compute refinement rays */
-long	nrays;
+refine_rays(		/* compute refinement rays */
+	long	nrays
+)
 {
 	int	*pord;
 	int	ntodo;
@@ -481,7 +451,7 @@ long	nrays;
 	int	i;
 					/* skip if nothing significant */
 	if (ndtset && cerrzero)
-		return;
+		return(0);
 					/* initialize priority list */
 	pord = (int *)malloc(sizeof(int)*hres*vres);
 	for (i = hres*vres; i--; )
@@ -517,20 +487,21 @@ long	nrays;
 
 
 int
-refine_frame(pass)		/* refine current frame */
-int	pass;
+refine_frame(		/* refine current frame */
+	int	pass
+)
 {
 	static double	rtime_used = 0;
 	static long	ray_cnt = 0;
 	static double	ctime_used = 0;
 	static int	csp_cnt = 0;
-	int	timed = (fcur > fbeg | pass > 0 | quickstart);
+	int	timed = (fcur > fbeg) | (pass > 0) | (quickstart);
 	double	time_start, rtime_start, time_done;
 	struct AmbSum	myAmbSum;
 	long	rays_todo, nr;
-	register int	n;
+	int	n;
 					/* IBR refinement? */
-	if ((pass == 0 & fcur > fbeg))
+	if ((pass == 0) & (fcur > fbeg))
 		return(refine_first());
 					/* any time left? */
 	time_start = getTime();
@@ -607,7 +578,7 @@ if (pass == 1) {
 					/* compute refinement rays */
 	if (!silent) {
 		printf("\tRefinement pass %d...",
-				pass+1, rays_todo);
+				pass+1); /*, rays_todo); */
 		fflush(stdout);
 	}
 	if (asump != NULL)		/* flag low-quality samples */
@@ -617,7 +588,7 @@ if (pass == 1) {
 					/* trace those rays */
 	nr = refine_rays(rays_todo);
 	if (!silent)
-		printf("traced %d HQ rays\n", nr);
+		printf("traced %ld HQ rays\n", nr);
 	if (nr <= 0)
 		return(0);
 					/* update timing stats */
@@ -652,7 +623,7 @@ if (pass == 1) {
 	return(1);
 nomore:
 					/* make sure error map is updated */
-	if ((fcur == fbeg | pass > 1))
+	if ((fcur == fbeg) | (pass > 1))
 		comp_frame_error();
 	return(0);
 }