src/rt/rview.c

#ifndef lint
static const char       RCSid[] = "$Id: rview.c,v 2.27 2005/01/21 00:52:59 greg Exp $";
#endif
/*
 *  rview.c - routines and variables for interactive view generation.
 *
 *  External symbols declared in rpaint.h
 */

#include "copyright.h"

#include  <signal.h>
#include  <ctype.h>

#include  "ray.h"
#include  "rpaint.h"


CUBE  thescene;                         /* our scene */
OBJECT  nsceneobjs;                     /* number of objects in our scene */

int  dimlist[MAXDIM];                   /* sampling dimensions */
int  ndims = 0;                         /* number of sampling dimensions */
int  samplendx = 0;                     /* index for this sample */

extern void  ambnotify();
void  (*addobjnotify[])() = {ambnotify, NULL};

VIEW  ourview = STDVIEW;                /* viewing parameters */
int  hresolu, vresolu;                  /* image resolution */

void  (*trace)() = NULL;                /* trace call */

int  do_irrad = 0;                      /* compute irradiance? */

int  rand_samp = 0;                     /* pure Monte Carlo sampling? */

int  psample = 8;                       /* pixel sample size */
double  maxdiff = .15;                  /* max. sample difference */

double  exposure = 1.0;                 /* exposure for scene */

double  dstrsrc = 0.0;                  /* square source distribution */
double  shadthresh = .1;                /* shadow threshold */
double  shadcert = .25;                 /* shadow certainty */
int  directrelay = 0;                   /* number of source relays */
int  vspretest = 128;                   /* virtual source pretest density */
int  directvis = 1;                     /* sources visible? */
double  srcsizerat = 0.;                /* maximum ratio source size/dist. */

COLOR  cextinction = BLKCOLOR;          /* global extinction coefficient */
COLOR  salbedo = BLKCOLOR;              /* global scattering albedo */
double  seccg = 0.;                     /* global scattering eccentricity */
double  ssampdist = 0.;                 /* scatter sampling distance */

double  specthresh = .3;                /* specular sampling threshold */
double  specjitter = 1.;                /* specular sampling jitter */

int  backvis = 1;                       /* back face visibility */

int  maxdepth = 6;                      /* maximum recursion depth */
double  minweight = 1e-2;               /* minimum ray weight */

char  *ambfile = NULL;                  /* ambient file name */
COLOR  ambval = BLKCOLOR;               /* ambient value */
int  ambvwt = 0;                        /* initial weight for ambient value */
double  ambacc = 0.3;                   /* ambient accuracy */
int  ambres = 32;                       /* ambient resolution */
int  ambdiv = 256;                      /* ambient divisions */
int  ambssamp = 64;                     /* ambient super-samples */
int  ambounce = 0;                      /* ambient bounces */
char  *amblist[AMBLLEN];                /* ambient include/exclude list */
int  ambincl = -1;                      /* include == 1, exclude == 0 */

int  greyscale = 0;                     /* map colors to brightness? */
char  *dvcname = dev_default;           /* output device name */

struct driver  *dev = NULL;             /* driver functions */

char  rifname[128];                     /* rad input file name */

VIEW  oldview;                          /* previous view parameters */

PNODE  ptrunk;                          /* the base of our image */
RECT  pframe;                           /* current frame boundaries */
int  pdepth;                            /* image depth in current frame */

static char  *reserve_mem = NULL;       /* pre-allocated reserve memory */

#define RESERVE_AMT     32768           /* amount of memory to reserve */

#define  CTRL(c)        ((c)-'@')


void
quit(code)                      /* quit program */
int  code;
{
#ifdef MSTATS
        if (code == 2 && errno == ENOMEM)
                printmemstats(stderr);
#endif
        devclose();
        exit(code);
}


void
devopen(dname)                          /* open device driver */
char  *dname;
{
        extern char  *progname, *octname;
        char  *id;
        register int  i;

        id = octname!=NULL ? octname : progname;
                                                /* check device table */
        for (i = 0; devtable[i].name; i++)
                if (!strcmp(dname, devtable[i].name)) {
                        if ((dev = (*devtable[i].init)(dname, id)) == NULL) {
                                sprintf(errmsg, "cannot initialize %s", dname);
                                error(USER, errmsg);
                        } else
                                return;
                }
                                                /* not there, try exec */
        if ((dev = comm_init(dname, id)) == NULL) {
                sprintf(errmsg, "cannot start device \"%s\"", dname);
                error(USER, errmsg);
        }
}


void
devclose()                              /* close our device */
{
        if (dev != NULL)
                (*dev->close)();
        dev = NULL;
}


void
printdevices()                          /* print list of output devices */
{
        register int  i;

        for (i = 0; devtable[i].name; i++)
                printf("%-16s # %s\n", devtable[i].name, devtable[i].descrip);
}


void
rview()                         /* do a view */
{
        char  buf[32];

        devopen(dvcname);               /* open device */
        newimage();                     /* start image (calls fillreserves) */

        for ( ; ; ) {                   /* quit in command() */
                while (hresolu <= 1<<pdepth && vresolu <= 1<<pdepth)
                        command("done: ");
                while (reserve_mem == NULL)
                        command("out of memory: ");
                errno = 0;
                if (hresolu <= psample<<pdepth && vresolu <= psample<<pdepth) {
                        sprintf(buf, "%d sampling...\n", 1<<pdepth);
                        (*dev->comout)(buf);
                        rsample();
                } else {
                        sprintf(buf, "%d refining...\n", 1<<pdepth);
                        (*dev->comout)(buf);
                        refine(&ptrunk, 0, 0, hresolu, vresolu, pdepth+1);
                }
                if (errno == ENOMEM)            /* ran out of memory */
                        freereserves();
                else if (dev->inpready)         /* noticed some input */
                        command(": ");
                else                            /* finished this depth */
                        pdepth++;
        }
}


void
fillreserves()                  /* fill memory reserves */
{
        if (reserve_mem != NULL)
                return;
        reserve_mem = (char *)malloc(RESERVE_AMT);
}


void
freereserves()                  /* free memory reserves */
{
        if (reserve_mem == NULL)
                return;
        free(reserve_mem);
        reserve_mem = NULL;
}


void
command(prompt)                 /* get/execute command */
char  *prompt;
{
#define  badcom(s)      strncmp(s, inpbuf, args-inpbuf-1)
        char  inpbuf[256];
        char  *args;
again:
        (*dev->comin)(inpbuf, prompt);          /* get command + arguments */
        for (args = inpbuf; *args && *args != ' '; args++)
                ;
        if (*args) *args++ = '\0';
        else *++args = '\0';
        
        switch (inpbuf[0]) {
        case 'f':                               /* new frame (|focus|free) */
                if (badcom("frame")) {
                        if (badcom("focus")) {
                                if (badcom("free"))
                                        goto commerr;
                                free_objmem();
                                break;
                        }
                        getfocus(args);
                        break;
                }
                getframe(args);
                break;
        case 'v':                               /* view */
                if (badcom("view"))
                        goto commerr;
                getview(args);
                break;
        case 'l':                               /* last view */
                if (badcom("last"))
                        goto commerr;
                lastview(args);
                break;
        case 'V':                               /* save view */
                if (badcom("V"))
                        goto commerr;
                saveview(args);
                break;
        case 'L':                               /* load view */
                if (badcom("L"))
                        goto commerr;
                loadview(args);
                break;
        case 'e':                               /* exposure */
                if (badcom("exposure"))
                        goto commerr;
                getexposure(args);
                break;
        case 's':                               /* set a parameter */
                if (badcom("set")) {
#ifdef  SIGTSTP
                        if (!badcom("stop"))
                                goto dostop;
#endif
                        goto commerr;
                }
                setparam(args);
                break;
        case 'n':                               /* new picture */
                if (badcom("new"))
                        goto commerr;
                newimage();
                break;
        case 't':                               /* trace a ray */
                if (badcom("trace"))
                        goto commerr;
                traceray(args);
                break;
        case 'a':                               /* aim camera */
                if (badcom("aim"))
                        goto commerr;
                getaim(args);
                break;
        case 'm':                               /* move camera (or memstats) */
                if (badcom("move"))
#ifdef  MSTATS
                {
                        if (badcom("memory"))
                                goto commerr;
                        printmemstats(stderr);
                        break;
                }
#else
                        goto commerr;
#endif
                getmove(args);
                break;
        case 'r':                               /* rotate/repaint */
                if (badcom("rotate")) {
                        if (badcom("repaint")) {
                                if (badcom("redraw"))
                                        goto commerr;
                                redraw();
                                break;
                        }
                        getrepaint(args);
                        break;
                }
                getrotate(args);
                break;
        case 'p':                               /* pivot view */
                if (badcom("pivot")) {
                        if (badcom("pause"))
                                goto commerr;
                        goto again;
                }
                getpivot(args);
                break;
        case CTRL('R'):                         /* redraw */
                redraw();
                break;
        case 'w':                               /* write */
                if (badcom("write"))
                        goto commerr;
                writepict(args);
                break;
        case 'q':                               /* quit */
                if (badcom("quit"))
                        goto commerr;
                quit(0);
        case CTRL('C'):                         /* interrupt */
                goto again;
#ifdef  SIGTSTP
        case CTRL('Z'):;                        /* stop */
dostop:
                devclose();
                kill(0, SIGTSTP);
                /* pc stops here */
                devopen(dvcname);
                redraw();
                break;
#endif
        case '\0':                              /* continue */
                break;
        default:;
commerr:
                if (iscntrl(inpbuf[0]))
                        sprintf(errmsg, "^%c: unknown control",
                                        inpbuf[0]|0100);
                else
                        sprintf(errmsg, "%s: unknown command", inpbuf);
                error(COMMAND, errmsg);
                break;
        }
#undef  badcom
}


void
rsample()                       /* sample the image */
{
        int  xsiz, ysiz, y;
        RECT  r;
        PNODE  *p;
        register RECT  *rl;
        register PNODE  **pl;
        register int  x;
        /*
         *     We initialize the bottom row in the image at our current
         * resolution.  During sampling, we check super-pixels to the
         * right and above by calling bigdiff().  If there is a significant
         * difference, we subsample the super-pixels.  The testing process
         * includes initialization of the next row.
         */
        xsiz = (((long)(pframe.r-pframe.l)<<pdepth)+hresolu-1) / hresolu;
        ysiz = (((long)(pframe.u-pframe.d)<<pdepth)+vresolu-1) / vresolu;
        rl = (RECT *)malloc(xsiz*sizeof(RECT));
        if (rl == NULL)
                return;
        pl = (PNODE **)malloc(xsiz*sizeof(PNODE *));
        if (pl == NULL) {
                free((void *)rl);
                return;
        }
        /*
         * Initialize the bottom row.
         */
        rl[0].l = rl[0].d = 0;
        rl[0].r = hresolu; rl[0].u = vresolu;
        pl[0] = findrect(pframe.l, pframe.d, &ptrunk, rl, pdepth);
        for (x = 1; x < xsiz; x++) {
                rl[x].l = rl[x].d = 0;
                rl[x].r = hresolu; rl[x].u = vresolu;
                pl[x] = findrect(pframe.l+((x*hresolu)>>pdepth),
                                pframe.d, &ptrunk, rl+x, pdepth);
        }
                                                /* sample the image */
        for (y = 0; /* y < ysiz */ ; y++) {
                for (x = 0; x < xsiz-1; x++) {
                        if (dev->inpready || errno == ENOMEM)
                                goto escape;
                        /*
                         * Test super-pixel to the right.
                         */
                        if (pl[x] != pl[x+1] && bigdiff(pl[x]->v,
                                        pl[x+1]->v, maxdiff)) {
                                refine(pl[x], rl[x].l, rl[x].d,
                                                rl[x].r, rl[x].u, 1);
                                refine(pl[x+1], rl[x+1].l, rl[x+1].d,
                                                rl[x+1].r, rl[x+1].u, 1);
                        }
                }
                if (y >= ysiz-1)
                        break;
                for (x = 0; x < xsiz; x++) {
                        if (dev->inpready || errno == ENOMEM)
                                goto escape;
                        /*
                         * Find super-pixel at this position in next row.
                         */
                        r.l = r.d = 0;
                        r.r = hresolu; r.u = vresolu;
                        p = findrect(pframe.l+((x*hresolu)>>pdepth),
                                pframe.d+(((y+1)*vresolu)>>pdepth),
                                        &ptrunk, &r, pdepth);
                        /*
                         * Test super-pixel in next row.
                         */
                        if (pl[x] != p && bigdiff(pl[x]->v, p->v, maxdiff)) {
                                refine(pl[x], rl[x].l, rl[x].d,
                                                rl[x].r, rl[x].u, 1);
                                refine(p, r.l, r.d, r.r, r.u, 1);
                        }
                        /*
                         * Copy into super-pixel array.
                         */
                        rl[x].l = r.l; rl[x].d = r.d;
                        rl[x].r = r.r; rl[x].u = r.u;
                        pl[x] = p;
                }
        }
escape:
        free((void *)rl);
        free((void *)pl);
}


int
refine(p, xmin, ymin, xmax, ymax, pd)           /* refine a node */
register PNODE  *p;
int  xmin, ymin, xmax, ymax;
int  pd;
{
        int  growth;
        int  mx, my;
        int  i;

        if (dev->inpready)                      /* quit for input */
                return(0);

        if (pd <= 0)                            /* depth limit */
                return(0);

        mx = (xmin + xmax) >> 1;
        my = (ymin + ymax) >> 1;
        growth = 0;

        if (p->kid == NULL) {                   /* subdivide */

                if ((p->kid = newptree()) == NULL)
                        return(0);
                /*
                 *  The following paint order can leave a black pixel
                 *  if redraw() is called in (*dev->paintr)().
                 */
                if (p->x >= mx && p->y >= my)
                        pcopy(p, p->kid+UR);
                else
                        paint(p->kid+UR, mx, my, xmax, ymax);
                if (p->x < mx && p->y >= my)
                        pcopy(p, p->kid+UL);
                else
                        paint(p->kid+UL, xmin, my, mx, ymax);
                if (p->x >= mx && p->y < my)
                        pcopy(p, p->kid+DR);
                else
                        paint(p->kid+DR, mx, ymin, xmax, my);
                if (p->x < mx && p->y < my)
                        pcopy(p, p->kid+DL);
                else
                        paint(p->kid+DL, xmin, ymin, mx, my);

                growth++;
        }
                                                /* do children */
        if (mx > pframe.l) {
                if (my > pframe.d)
                        growth += refine(p->kid+DL, xmin, ymin, mx, my, pd-1);
                if (my < pframe.u)
                        growth += refine(p->kid+UL, xmin, my, mx, ymax, pd-1);
        }
        if (mx < pframe.r) {
                if (my > pframe.d)
                        growth += refine(p->kid+DR, mx, ymin, xmax, my, pd-1);
                if (my < pframe.u)
                        growth += refine(p->kid+UR, mx, my, xmax, ymax, pd-1);
        }
                                                /* recompute sum */
        if (growth) {
                setcolor(p->v, 0.0, 0.0, 0.0);
                for (i = 0; i < 4; i++)
                        addcolor(p->v, p->kid[i].v);
                scalecolor(p->v, 0.25);
        }
        return(growth);
}
Revision:	2.28
Committed:	Mon Jun 13 20:07:56 2005 UTC (18 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad3R7P2, rad3R7P1, rad3R8, rad3R9
Changes since 2.27:	+3 -1 lines
Log Message:	Added -R option for pure Monte Carlo rendering, replacing -DMC compile option
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.28	static const char RCSid[] = "$Id: rview.c,v 2.27 2005/01/21 00:52:59 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* rview.c - routines and variables for interactive view generation.
6			*
7	greg	2.18	* External symbols declared in rpaint.h
8			*/
9
10	greg	2.19	#include "copyright.h"
11	greg	1.1
12	schorsch	2.20	#include <signal.h>
13			#include <ctype.h>
14
15	greg	1.15	#include "ray.h"
16	greg	1.1	#include "rpaint.h"
17
18
19	greg	2.18	CUBE thescene; /* our scene */
20			OBJECT nsceneobjs; /* number of objects in our scene */
21	greg	1.15
22			int dimlist[MAXDIM]; /* sampling dimensions */
23			int ndims = 0; /* number of sampling dimensions */
24			int samplendx = 0; /* index for this sample */
25	greg	1.1
26	greg	2.18	extern void ambnotify();
27			void (*addobjnotify[])() = {ambnotify, NULL};
28
29			VIEW ourview = STDVIEW; /* viewing parameters */
30			int hresolu, vresolu; /* image resolution */
31
32			void (trace)() = NULL; / trace call */
33
34			int do_irrad = 0; /* compute irradiance? */
35
36	greg	2.28	int rand_samp = 0; /* pure Monte Carlo sampling? */
37
38	greg	1.1	int psample = 8; /* pixel sample size */
39	greg	2.8	double maxdiff = .15; /* max. sample difference */
40	greg	1.1
41	greg	2.8	double exposure = 1.0; /* exposure for scene */
42	greg	1.1
43	greg	2.8	double dstrsrc = 0.0; /* square source distribution */
44			double shadthresh = .1; /* shadow threshold */
45			double shadcert = .25; /* shadow certainty */
46	greg	1.16	int directrelay = 0; /* number of source relays */
47	greg	1.18	int vspretest = 128; /* virtual source pretest density */
48	greg	2.9	int directvis = 1; /* sources visible? */
49	greg	2.8	double srcsizerat = 0.; /* maximum ratio source size/dist. */
50	greg	2.15
51			COLOR cextinction = BLKCOLOR; /* global extinction coefficient */
52	greg	2.17	COLOR salbedo = BLKCOLOR; /* global scattering albedo */
53	greg	2.15	double seccg = 0.; /* global scattering eccentricity */
54			double ssampdist = 0.; /* scatter sampling distance */
55	greg	1.1
56	greg	2.8	double specthresh = .3; /* specular sampling threshold */
57			double specjitter = 1.; /* specular sampling jitter */
58	greg	2.5
59	greg	2.14	int backvis = 1; /* back face visibility */
60
61	greg	2.24	int maxdepth = 6; /* maximum recursion depth */
62	greg	2.8	double minweight = 1e-2; /* minimum ray weight */
63	greg	1.1
64	greg	2.18	char ambfile = NULL; / ambient file name */
65	greg	1.1	COLOR ambval = BLKCOLOR; /* ambient value */
66	greg	2.16	int ambvwt = 0; /* initial weight for ambient value */
67	greg	2.25	double ambacc = 0.3; /* ambient accuracy */
68	greg	2.24	int ambres = 32; /* ambient resolution */
69	greg	2.25	int ambdiv = 256; /* ambient divisions */
70			int ambssamp = 64; /* ambient super-samples */
71	greg	1.1	int ambounce = 0; /* ambient bounces */
72	greg	2.26	char amblist[AMBLLEN]; / ambient include/exclude list */
73	greg	1.1	int ambincl = -1; /* include == 1, exclude == 0 */
74
75			int greyscale = 0; /* map colors to brightness? */
76	greg	2.18	char dvcname = dev_default; / output device name */
77	greg	1.1
78			struct driver dev = NULL; / driver functions */
79
80	greg	2.11	char rifname[128]; /* rad input file name */
81
82	greg	1.1	VIEW oldview; /* previous view parameters */
83
84			PNODE ptrunk; /* the base of our image */
85			RECT pframe; /* current frame boundaries */
86			int pdepth; /* image depth in current frame */
87
88	greg	1.12	static char reserve_mem = NULL; / pre-allocated reserve memory */
89
90	greg	1.20	#define RESERVE_AMT 32768 /* amount of memory to reserve */
91	greg	1.12
92	greg	2.8	#define CTRL(c) ((c)-'@')
93	greg	1.1
94
95	greg	2.18	void
96	greg	1.1	quit(code) /* quit program */
97			int code;
98			{
99	greg	2.10	#ifdef MSTATS
100			if (code == 2 && errno == ENOMEM)
101			printmemstats(stderr);
102			#endif
103	greg	1.1	devclose();
104			exit(code);
105			}
106
107
108	greg	2.18	void
109	greg	1.1	devopen(dname) /* open device driver */
110			char *dname;
111			{
112	greg	1.6	extern char progname, octname;
113	greg	1.7	char *id;
114	greg	1.1	register int i;
115	greg	1.6
116	greg	1.7	id = octname!=NULL ? octname : progname;
117	greg	1.1	/* check device table */
118			for (i = 0; devtable[i].name; i++)
119	schorsch	2.23	if (!strcmp(dname, devtable[i].name)) {
120	greg	1.7	if ((dev = (*devtable[i].init)(dname, id)) == NULL) {
121	greg	1.1	sprintf(errmsg, "cannot initialize %s", dname);
122			error(USER, errmsg);
123			} else
124			return;
125	schorsch	2.23	}
126	greg	1.1	/* not there, try exec */
127	greg	1.7	if ((dev = comm_init(dname, id)) == NULL) {
128	greg	1.1	sprintf(errmsg, "cannot start device \"%s\"", dname);
129			error(USER, errmsg);
130			}
131			}
132
133
134	greg	2.18	void
135	greg	1.1	devclose() /* close our device */
136			{
137			if (dev != NULL)
138			(*dev->close)();
139			dev = NULL;
140			}
141
142
143	greg	2.18	void
144	greg	1.1	printdevices() /* print list of output devices */
145			{
146			register int i;
147
148			for (i = 0; devtable[i].name; i++)
149			printf("%-16s # %s\n", devtable[i].name, devtable[i].descrip);
150			}
151
152
153	greg	2.18	void
154	greg	1.1	rview() /* do a view */
155			{
156			char buf[32];
157
158	greg	2.18	devopen(dvcname); /* open device */
159	greg	1.14	newimage(); /* start image (calls fillreserves) */
160
161	greg	1.1	for ( ; ; ) { /* quit in command() */
162	greg	1.14	while (hresolu <= 1<<pdepth && vresolu <= 1<<pdepth)
163	greg	1.1	command("done: ");
164	greg	1.14	while (reserve_mem == NULL)
165			command("out of memory: ");
166			errno = 0;
167			if (hresolu <= psample<<pdepth && vresolu <= psample<<pdepth) {
168	greg	1.1	sprintf(buf, "%d sampling...\n", 1<<pdepth);
169			(*dev->comout)(buf);
170			rsample();
171			} else {
172			sprintf(buf, "%d refining...\n", 1<<pdepth);
173			(*dev->comout)(buf);
174	greg	1.9	refine(&ptrunk, 0, 0, hresolu, vresolu, pdepth+1);
175	greg	1.1	}
176	greg	1.14	if (errno == ENOMEM) /* ran out of memory */
177			freereserves();
178			else if (dev->inpready) /* noticed some input */
179	greg	1.1	command(": ");
180	greg	1.14	else /* finished this depth */
181	greg	1.1	pdepth++;
182			}
183			}
184
185
186	greg	2.18	void
187	greg	1.14	fillreserves() /* fill memory reserves */
188	greg	1.12	{
189			if (reserve_mem != NULL)
190	greg	1.14	return;
191	greg	2.18	reserve_mem = (char *)malloc(RESERVE_AMT);
192	greg	1.12	}
193
194
195	greg	2.18	void
196	greg	1.14	freereserves() /* free memory reserves */
197	greg	1.12	{
198	greg	1.14	if (reserve_mem == NULL)
199			return;
200	greg	1.12	free(reserve_mem);
201			reserve_mem = NULL;
202			}
203
204
205	greg	2.18	void
206	greg	1.1	command(prompt) /* get/execute command */
207			char *prompt;
208			{
209	greg	2.8	#define badcom(s) strncmp(s, inpbuf, args-inpbuf-1)
210	greg	1.1	char inpbuf[256];
211			char *args;
212			again:
213	greg	1.10	(dev->comin)(inpbuf, prompt); / get command + arguments */
214	greg	1.1	for (args = inpbuf; args && args != ' '; args++)
215			;
216			if (args) args++ = '\0';
217			else *++args = '\0';
218
219			switch (inpbuf[0]) {
220	greg	2.27	case 'f': /* new frame (\|focus\|free) */
221	greg	2.10	if (badcom("frame")) {
222	greg	2.27	if (badcom("focus")) {
223			if (badcom("free"))
224			goto commerr;
225			free_objmem();
226			break;
227			}
228			getfocus(args);
229	greg	2.10	break;
230			}
231	greg	1.1	getframe(args);
232			break;
233			case 'v': /* view */
234			if (badcom("view"))
235			goto commerr;
236			getview(args);
237			break;
238			case 'l': /* last view */
239			if (badcom("last"))
240			goto commerr;
241			lastview(args);
242	greg	2.11	break;
243			case 'V': /* save view */
244			if (badcom("V"))
245			goto commerr;
246			saveview(args);
247			break;
248			case 'L': /* load view */
249			if (badcom("L"))
250			goto commerr;
251			loadview(args);
252	greg	1.1	break;
253			case 'e': /* exposure */
254			if (badcom("exposure"))
255			goto commerr;
256			getexposure(args);
257			break;
258			case 's': /* set a parameter */
259	greg	2.13	if (badcom("set")) {
260			#ifdef SIGTSTP
261			if (!badcom("stop"))
262			goto dostop;
263			#endif
264	greg	1.1	goto commerr;
265	greg	2.13	}
266	greg	1.1	setparam(args);
267			break;
268			case 'n': /* new picture */
269			if (badcom("new"))
270			goto commerr;
271			newimage();
272			break;
273			case 't': /* trace a ray */
274			if (badcom("trace"))
275			goto commerr;
276			traceray(args);
277			break;
278			case 'a': /* aim camera */
279			if (badcom("aim"))
280			goto commerr;
281			getaim(args);
282			break;
283	greg	2.10	case 'm': /* move camera (or memstats) */
284	greg	1.1	if (badcom("move"))
285	greg	2.8	#ifdef MSTATS
286	greg	2.2	{
287			if (badcom("memory"))
288			goto commerr;
289			printmemstats(stderr);
290			break;
291			}
292			#else
293	greg	1.1	goto commerr;
294	greg	2.2	#endif
295	greg	1.1	getmove(args);
296			break;
297	greg	1.8	case 'r': /* rotate/repaint */
298			if (badcom("rotate")) {
299	greg	2.13	if (badcom("repaint")) {
300			if (badcom("redraw"))
301			goto commerr;
302			redraw();
303			break;
304			}
305	greg	1.8	getrepaint(args);
306			break;
307			}
308	greg	1.1	getrotate(args);
309			break;
310			case 'p': /* pivot view */
311	greg	2.13	if (badcom("pivot")) {
312			if (badcom("pause"))
313			goto commerr;
314			goto again;
315			}
316	greg	1.1	getpivot(args);
317			break;
318	greg	2.4	case CTRL('R'): /* redraw */
319	greg	1.1	redraw();
320			break;
321			case 'w': /* write */
322			if (badcom("write"))
323			goto commerr;
324			writepict(args);
325			break;
326			case 'q': /* quit */
327			if (badcom("quit"))
328			goto commerr;
329			quit(0);
330	greg	2.4	case CTRL('C'): /* interrupt */
331	greg	1.1	goto again;
332	greg	2.8	#ifdef SIGTSTP
333	greg	2.13	case CTRL('Z'):; /* stop */
334			dostop:
335	greg	1.1	devclose();
336			kill(0, SIGTSTP);
337			/* pc stops here */
338	greg	2.18	devopen(dvcname);
339	greg	1.1	redraw();
340			break;
341			#endif
342			case '\0': /* continue */
343			break;
344			default:;
345			commerr:
346			if (iscntrl(inpbuf[0]))
347			sprintf(errmsg, "^%c: unknown control",
348			inpbuf[0]\|0100);
349			else
350			sprintf(errmsg, "%s: unknown command", inpbuf);
351			error(COMMAND, errmsg);
352			break;
353			}
354	greg	2.8	#undef badcom
355	greg	1.1	}
356
357
358	greg	2.18	void
359	greg	1.1	rsample() /* sample the image */
360			{
361			int xsiz, ysiz, y;
362			RECT r;
363			PNODE *p;
364			register RECT *rl;
365	greg	2.8	register PNODE **pl;
366	greg	1.1	register int x;
367			/*
368			* We initialize the bottom row in the image at our current
369	greg	2.8	* resolution. During sampling, we check super-pixels to the
370	greg	1.1	* right and above by calling bigdiff(). If there is a significant
371			* difference, we subsample the super-pixels. The testing process
372			* includes initialization of the next row.
373			*/
374	greg	2.12	xsiz = (((long)(pframe.r-pframe.l)<<pdepth)+hresolu-1) / hresolu;
375			ysiz = (((long)(pframe.u-pframe.d)<<pdepth)+vresolu-1) / vresolu;
376	greg	1.1	rl = (RECT )malloc(xsizsizeof(RECT));
377	greg	1.12	if (rl == NULL)
378	greg	1.14	return;
379	greg	1.1	pl = (PNODE *)malloc(xsizsizeof(PNODE *));
380	greg	2.7	if (pl == NULL) {
381	greg	2.18	free((void *)rl);
382	greg	1.14	return;
383	greg	2.7	}
384	greg	1.1	/*
385			* Initialize the bottom row.
386			*/
387			rl[0].l = rl[0].d = 0;
388	greg	1.9	rl[0].r = hresolu; rl[0].u = vresolu;
389	greg	1.1	pl[0] = findrect(pframe.l, pframe.d, &ptrunk, rl, pdepth);
390			for (x = 1; x < xsiz; x++) {
391			rl[x].l = rl[x].d = 0;
392	greg	1.9	rl[x].r = hresolu; rl[x].u = vresolu;
393			pl[x] = findrect(pframe.l+((x*hresolu)>>pdepth),
394	greg	1.1	pframe.d, &ptrunk, rl+x, pdepth);
395			}
396			/* sample the image */
397			for (y = 0; /* y < ysiz */ ; y++) {
398			for (x = 0; x < xsiz-1; x++) {
399	greg	1.20	if (dev->inpready \|\| errno == ENOMEM)
400	greg	1.1	goto escape;
401			/*
402			* Test super-pixel to the right.
403			*/
404			if (pl[x] != pl[x+1] && bigdiff(pl[x]->v,
405			pl[x+1]->v, maxdiff)) {
406			refine(pl[x], rl[x].l, rl[x].d,
407			rl[x].r, rl[x].u, 1);
408			refine(pl[x+1], rl[x+1].l, rl[x+1].d,
409			rl[x+1].r, rl[x+1].u, 1);
410			}
411			}
412			if (y >= ysiz-1)
413			break;
414			for (x = 0; x < xsiz; x++) {
415	greg	1.20	if (dev->inpready \|\| errno == ENOMEM)
416	greg	1.1	goto escape;
417			/*
418			* Find super-pixel at this position in next row.
419			*/
420			r.l = r.d = 0;
421	greg	1.9	r.r = hresolu; r.u = vresolu;
422			p = findrect(pframe.l+((x*hresolu)>>pdepth),
423			pframe.d+(((y+1)*vresolu)>>pdepth),
424	greg	1.1	&ptrunk, &r, pdepth);
425			/*
426			* Test super-pixel in next row.
427			*/
428			if (pl[x] != p && bigdiff(pl[x]->v, p->v, maxdiff)) {
429			refine(pl[x], rl[x].l, rl[x].d,
430			rl[x].r, rl[x].u, 1);
431			refine(p, r.l, r.d, r.r, r.u, 1);
432			}
433			/*
434			* Copy into super-pixel array.
435			*/
436			rl[x].l = r.l; rl[x].d = r.d;
437			rl[x].r = r.r; rl[x].u = r.u;
438			pl[x] = p;
439			}
440			}
441			escape:
442	greg	2.18	free((void *)rl);
443			free((void *)pl);
444	greg	1.1	}
445
446
447			int
448			refine(p, xmin, ymin, xmax, ymax, pd) /* refine a node */
449	greg	2.8	register PNODE *p;
450	greg	1.1	int xmin, ymin, xmax, ymax;
451			int pd;
452			{
453			int growth;
454			int mx, my;
455			int i;
456
457			if (dev->inpready) /* quit for input */
458			return(0);
459
460			if (pd <= 0) /* depth limit */
461			return(0);
462
463			mx = (xmin + xmax) >> 1;
464			my = (ymin + ymax) >> 1;
465			growth = 0;
466
467			if (p->kid == NULL) { /* subdivide */
468
469			if ((p->kid = newptree()) == NULL)
470	greg	1.20	return(0);
471	greg	1.1	/*
472			* The following paint order can leave a black pixel
473	greg	2.7	* if redraw() is called in (*dev->paintr)().
474	greg	1.1	*/
475			if (p->x >= mx && p->y >= my)
476			pcopy(p, p->kid+UR);
477			else
478			paint(p->kid+UR, mx, my, xmax, ymax);
479			if (p->x < mx && p->y >= my)
480			pcopy(p, p->kid+UL);
481			else
482			paint(p->kid+UL, xmin, my, mx, ymax);
483			if (p->x >= mx && p->y < my)
484			pcopy(p, p->kid+DR);
485			else
486			paint(p->kid+DR, mx, ymin, xmax, my);
487			if (p->x < mx && p->y < my)
488			pcopy(p, p->kid+DL);
489			else
490			paint(p->kid+DL, xmin, ymin, mx, my);
491
492			growth++;
493			}
494			/* do children */
495			if (mx > pframe.l) {
496			if (my > pframe.d)
497			growth += refine(p->kid+DL, xmin, ymin, mx, my, pd-1);
498			if (my < pframe.u)
499			growth += refine(p->kid+UL, xmin, my, mx, ymax, pd-1);
500			}
501			if (mx < pframe.r) {
502			if (my > pframe.d)
503			growth += refine(p->kid+DR, mx, ymin, xmax, my, pd-1);
504			if (my < pframe.u)
505			growth += refine(p->kid+UR, mx, my, xmax, ymax, pd-1);
506			}
507			/* recompute sum */
508			if (growth) {
509			setcolor(p->v, 0.0, 0.0, 0.0);
510			for (i = 0; i < 4; i++)
511			addcolor(p->v, p->kid[i].v);
512			scalecolor(p->v, 0.25);
513			}
514			return(growth);
515			}