--- ray/src/hd/rholo3.c	1999/02/02 16:13:24	3.30
+++ ray/src/hd/rholo3.c	2003/06/30 14:59:12	3.38
@@ -1,15 +1,14 @@
-/* Copyright (c) 1998 Silicon Graphics, Inc. */
-
 #ifndef lint
-static char SCCSid[] = "$SunId$ SGI";
+static const char	RCSid[] = "$Id: rholo3.c,v 3.38 2003/06/30 14:59:12 schorsch Exp $";
 #endif
-
 /*
  * Routines for tracking beam compuatations
  */
 
+#include <string.h>
+
 #include "rholo.h"
-#include <sys/types.h>
+#include "view.h"
 
 #ifndef NFRAG2CHUNK
 #define NFRAG2CHUNK	4096	/* number of fragments to start chunking */
@@ -91,12 +90,11 @@ register HDBEAMI	*hb;
 	if (b->nrm > n) {		/* (re)allocate packet holder */
 		n = b->nrm;
 		if (p == NULL) p = (PACKHEAD *)malloc(packsiz(n));
-		else p = (PACKHEAD *)realloc((char *)p, packsiz(n));
-		if (p == NULL)
-			error(SYSTEM, "out of memory in dispbeam");
+		else p = (PACKHEAD *)realloc((void *)p, packsiz(n));
+		CHECK(p==NULL, SYSTEM, "out of memory in dispbeam");
 	}
 					/* assign packet fields */
-	bcopy((char *)hdbray(b), (char *)packra(p), b->nrm*sizeof(RAYVAL));
+	memcpy((void *)packra(p), (void *)hdbray(b), b->nrm*sizeof(RAYVAL));
 	p->nr = p->nc = b->nrm;
 	for (p->hd = 0; hdlist[p->hd] != hb->h; p->hd++)
 		if (hdlist[p->hd] == NULL)
@@ -104,7 +102,7 @@ register HDBEAMI	*hb;
 	p->bi = hb->b;
 	disp_packet(p);			/* display it */
 	if (n >= 1024) {		/* free ridiculous packets */
-		free((char *)p);
+		free((void *)p);
 		p = NULL; n = 0;
 	}
 }
@@ -122,9 +120,9 @@ int	nents;
 					/* search for common members */
 	for (csm = clist+nents; csm-- > clist; )
 		csm->nc = -1;
-	qsort((char *)clist, nents, sizeof(PACKHEAD), beamidcmp);
+	qsort((void *)clist, nents, sizeof(PACKHEAD), beamidcmp);
 	for (i = 0; i < complen; i++) {
-		csm = (PACKHEAD *)bsearch((char *)(complist+i), (char *)clist,
+		csm = (PACKHEAD *)bsearch((void *)(complist+i), (void *)clist,
 				nents, sizeof(PACKHEAD), beamidcmp);
 		if (csm == NULL)
 			continue;
@@ -135,6 +133,11 @@ int	nents;
 			complist[i].nr += csm->nr;
 			csm->nr = 0;
 			break;
+		case BS_MAX:		/* maximum of counts */
+			if (csm->nr > complist[i].nr)
+				complist[i].nr = csm->nr;
+			csm->nr = 0;
+			break;
 		case BS_ADJ:		/* reset count */
 			complist[i].nr = csm->nr;
 			csm->nr = 0;
@@ -158,26 +161,27 @@ int	nents;
 	case BS_NEW:			/* new computation set */
 		listpos = 0; lastin = -1;
 		if (complen)		/* free old list */
-			free((char *)complist);
+			free((void *)complist);
 		complist = NULL;
 		if (!(complen = nents))
 			return;
 		complist = (PACKHEAD *)malloc(nents*sizeof(PACKHEAD));
 		if (complist == NULL)
 			goto memerr;
-		bcopy((char *)clist, (char *)complist, nents*sizeof(PACKHEAD));
+		memcpy((void *)complist, (void *)clist, nents*sizeof(PACKHEAD));
 		break;
 	case BS_ADD:			/* add to computation set */
+	case BS_MAX:			/* maximum of quantities */
 	case BS_ADJ:			/* adjust set quantities */
 		if (nents <= 0)
 			return;
 		sortcomplist();		/* sort updated list & new entries */
-		qsort((char *)clist, nents, sizeof(PACKHEAD), beamcmp);
+		qsort((void *)clist, nents, sizeof(PACKHEAD), beamcmp);
 					/* what can't we satisfy? */
 		for (i = nents, csm = clist; i-- && csm->nr > csm->nc; csm++)
 			;
 		n = csm - clist;
-		if (op == BS_ADJ) {	/* don't regenerate adjusted beams */
+		if (op != BS_ADD) {	/* don't regenerate adjusted beams */
 			for (++i; i-- && csm->nr > 0; csm++)
 				;
 			nents = csm - clist;
@@ -191,7 +195,7 @@ int	nents;
 						/* merge lists */
 			mergeclists(newlist, clist, n, complist, complen);
 			if (complen)
-				free((char *)complist);
+				free((void *)complist);
 			complist = newlist;
 			complen += n;
 		}
@@ -212,7 +216,7 @@ int	nents;
 		hbarr[i].b = clist[i].bi;
 	}
 	hdloadbeams(hbarr, nents, dispbeam);
-	free((char *)hbarr);
+	free((void *)hbarr);
 	if (hdfragflags&FF_READ) {
 		listpos = 0;
 		lastin = -1;		/* need to re-sort list */
@@ -256,28 +260,20 @@ int	bi;
 }
 
 
-init_global()			/* initialize global ray computation */
+ambient_list()			/* compute ambient beam list */
 {
-	long	wtotal = 0;
+	int32	wtotal, minrt;
 	double	frac;
 	int	i;
 	register int	j, k;
-					/* free old list and empty queue */
-	if (complen > 0) {
-		free((char *)complist);
-		done_packets(flush_queue());
-	}
-					/* reseed random number generator */
-	srandom(time(NULL));
-					/* allocate beam list */
+
 	complen = 0;
 	for (j = 0; hdlist[j] != NULL; j++)
 		complen += nbeams(hdlist[j]);
 	complist = (PACKHEAD *)malloc(complen*sizeof(PACKHEAD));
-	if (complist == NULL)
-		error(SYSTEM, "out of memory in init_global");
+	CHECK(complist==NULL, SYSTEM, "out of memory in ambient_list");
 					/* compute beam weights */
-	k = 0;
+	k = 0; wtotal = 0;
 	for (j = 0; hdlist[j] != NULL; j++) {
 		frac = 512. * VLEN(hdlist[j]->wg[0]) *
 				VLEN(hdlist[j]->wg[1]) *
@@ -290,15 +286,60 @@ init_global()			/* initialize global ray computation *
 			wtotal += complist[k++].nr;
 		}
 	}
-					/* adjust weights */
+					/* adjust sample weights */
 	if (vdef(DISKSPACE))
 		frac = 1024.*1024.*vflt(DISKSPACE) / (wtotal*sizeof(RAYVAL));
 	else
-		frac = 1024.*1024.*16384. / (wtotal*sizeof(RAYVAL));
-	while (k--)
-		complist[k].nr = frac*complist[k].nr + 0.5;
-	listpos = 0; lastin = -1;	/* perform initial sort */
-	sortcomplist();
+		frac = 1024.*1024.*2048. / (wtotal*sizeof(RAYVAL));
+	minrt = .02*frac*wtotal/complen + .5;	/* heuristic mimimum */
+	if (minrt > RPACKSIZ)
+		minrt = RPACKSIZ;
+	for (k = complen; k--; )
+		if ((complist[k].nr = frac*complist[k].nr + 0.5) < minrt)
+			complist[k].nr = minrt;
+	listpos = 0; lastin = -1;	/* flag initial sort */
+}
+
+
+view_list(fp)			/* assign beam priority from view list */
+FILE	*fp;
+{
+	double	pa = 1.;
+	VIEW	curview;
+	int	xr, yr;
+	char	*err;
+	BEAMLIST	blist;
+
+	copystruct(&curview, &stdview);
+	while (nextview(&curview, fp) != EOF) {
+		if ((err = setview(&curview)) != NULL) {
+			error(WARNING, err);
+			continue;
+		}
+		xr = yr = 1024;
+		normaspect(viewaspect(&curview), &pa, &xr, &yr);
+		viewbeams(&curview, xr, yr, &blist);
+		bundle_set(BS_MAX, blist.bl, blist.nb);
+		free((void *)blist.bl);
+	}
+}
+
+
+init_global()			/* initialize global ray computation */
+{
+	register int	k;
+					/* free old list and empty queue */
+	if (complen > 0) {
+		free((void *)complist);
+		done_packets(flush_queue());
+	}
+					/* reseed random number generator */
+	srandom(time(NULL));
+					/* allocate beam list */
+	if (readinp)
+		view_list(stdin);
+	else
+		ambient_list();
 					/* no view vicinity */
 	myeye.rng = 0;
 }
@@ -348,26 +389,25 @@ sortcomplist()			/* fix our list order */
 #endif
 		}
 	if (lastin < 0 || listpos*4 >= complen*3)
-		qsort((char *)complist, complen, sizeof(PACKHEAD), beamcmp);
+		qsort((void *)complist, complen, sizeof(PACKHEAD), beamcmp);
 	else if (listpos) {	/* else sort and merge sublist */
 		list2 = (PACKHEAD *)malloc(listpos*sizeof(PACKHEAD));
-		if (list2 == NULL)
-			error(SYSTEM, "out of memory in sortcomplist");
-		bcopy((char *)complist,(char *)list2,listpos*sizeof(PACKHEAD));
-		qsort((char *)list2, listpos, sizeof(PACKHEAD), beamcmp);
+		CHECK(list2==NULL, SYSTEM, "out of memory in sortcomplist");
+		memcpy((void *)list2,(void *)complist,listpos*sizeof(PACKHEAD));
+		qsort((void *)list2, listpos, sizeof(PACKHEAD), beamcmp);
 		mergeclists(complist, list2, listpos,
 				complist+listpos, complen-listpos);
-		free((char *)list2);
+		free((void *)list2);
 	}
 					/* drop satisfied requests */
 	for (i = complen; i-- && complist[i].nr <= complist[i].nc; )
 		;
 	if (i < 0) {
-		free((char *)complist);
+		free((void *)complist);
 		complist = NULL;
 		complen = 0;
 	} else if (i < complen-1) {
-		list2 = (PACKHEAD *)realloc((char *)complist,
+		list2 = (PACKHEAD *)realloc((void *)complist,
 				(i+1)*sizeof(PACKHEAD));
 		if (list2 != NULL)
 			complist = list2;