ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/px/pcond4.c

Comparing ray/src/px/pcond4.c (file contents):
Revision 3.6 by greg, Sat Oct 5 08:05:27 1996 UTC vs.
Revision 3.14 by greg, Tue Jan 28 16:31:17 1997 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1996 Regents of the University of California */
1	>	/* Copyright (c) 1997 Regents of the University of California */
2
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
#	Line 14 | Line 14 | static char SCCSid[] = "$SunId$ LBL";
14
15		#define VADAPT          0.08            /* fraction of adaptation from veil */
16
17	<	extern COLOR    *fovimg;                /* foveal (1 degree) averaged image */
18	<	extern short    fvxr, fvyr;             /* foveal image resolution */
17	>	static COLOR    *veilimg = NULL;        /* veiling image */
18
20	–	#define fovscan(y)      (fovimg+(y)*fvxr)
21	–
22	–	static COLOR    *veilimg;               /* veiling image */
23	–
19		#define veilscan(y)     (veilimg+(y)*fvxr)
20
21		static float    (*raydir)[3] = NULL;    /* ray direction for each pixel */
#	Line 83 | Line 78 | compveil()                             /* compute veiling image */
78		COLOR   ctmp, vsum;
79		int     px, py;
80		register int    x, y;
81	+
82	+	if (veilimg != NULL)            /* already done? */
83	+	return;
84		/* compute ray directions */
85		compraydir();
86		/* compute veil image */
#	Line 100 | Line 98 | compveil()                             /* compute veiling image */
98		rdirscan(y)[x]);
99		if (t2 <= FTINY) continue;
100		/*      use approximation instead
101	<	t2 = acos(t2);
102	<	t2 = 1./(t2*t2);
101	>	t3 = acos(t2);
102	>	t2 = t2/(t3*t3);
103		*/
104	<	t2 = .5 / (1. - t2);
104	>	t2 *= .5 / (1. - t2);
105		copycolor(ctmp, fovscan(y)[x]);
106		scalecolor(ctmp, t2);
107		addcolor(vsum, ctmp);
#	Line 113 | Line 111 | compveil()                             /* compute veiling image */
111		scalecolor(vsum, VADAPT/t2sum);
112		copycolor(veilscan(py)[px], vsum);
113		}
114	+	/* modify FOV sample image */
115	+	for (y = 0; y < fvyr; y++)
116	+	for (x = 0; x < fvxr; x++) {
117	+	scalecolor(fovscan(y)[x], 1.-VADAPT);
118	+	addcolor(fovscan(y)[x], veilscan(y)[x]);
119	+	}
120	+	comphist();                     /* recompute histogram */
121		}
122
123
#	Line 126 | Line 131 | int    y;
131		register int    x, i;
132
133		vy = dy = (y+.5)/numscans(&inpres)*fvyr - .5;
134	<	if (vy >= fvyr-1) vy--;
134	>	while (vy >= fvyr-1) vy--;
135		dy -= (double)vy;
136		for (x = 0; x < scanlen(&inpres); x++) {
137		vx = dx = (x+.5)/scanlen(&inpres)*fvxr - .5;
138	<	if (vx >= fvxr-1) vx--;
138	>	while (vx >= fvxr-1) vx--;
139		dx -= (double)vx;
140		for (i = 0; i < 3; i++) {
141		lv = (1.-dy)*colval(veilscan(vy)[vx],i) +
#	Line 146 | Line 151 | int    y;
151
152		/****************** ACUITY STUFF *******************/
153
154	<	typedef struct scanbar {
155	<	short   sampr;          /* sample area size (power of 2) */
154	>	typedef struct {
155	>	short   sampe;          /* sample area size (exponent of 2) */
156		short   nscans;         /* number of scanlines in this bar */
157		int     len;            /* individual scanline length */
153	–	struct scanbar  *next;  /* next higher resolution scanbar */
158		int     nread;          /* number of scanlines loaded */
159	<	/* followed by the scanline data */
159	>	COLOR   *sdata;         /* scanbar data */
160		} SCANBAR;
161
162	<	#define bscan(sb,y)     ((COLOR *)((sb)+1)+((y)%(sb)->nscans)*(sb)->len)
162	>	#define bscan(sb,y)     ((COLOR *)(sb)->sdata+((y)%(sb)->nscans)*(sb)->len)
163
164		SCANBAR *rootbar;               /* root scan bar (lowest resolution) */
165
#	Line 167 | Line 171 | float  *inpacuD;               /* input acuity data (cycles/degree)
171		double
172		hacuity(La)                     /* return visual acuity in cycles/degree */
173		double  La;
174	<	{                               /* data due to S. Shaler (we should fit it!) */
175	<	#define NPOINTS 20
176	<	static float    l10lum[NPOINTS] = {
173	<	-3.10503,-2.66403,-2.37703,-2.09303,-1.64403,-1.35803,
174	<	-1.07403,-0.67203,-0.38503,-0.10103,0.29397,0.58097,0.86497,
175	<	1.25697,1.54397,1.82797,2.27597,2.56297,2.84697,3.24897
176	<	};
177	<	static float    resfreq[NPOINTS] = {
178	<	2.09,3.28,3.79,4.39,6.11,8.83,10.94,18.66,23.88,31.05,37.42,
179	<	37.68,41.60,43.16,45.30,47.00,48.43,48.32,51.06,51.09
180	<	};
181	<	double  l10La;
182	<	register int    i;
183	<	/* check limits */
184	<	if (La <= 7.85e-4)
185	<	return(resfreq[0]);
186	<	if (La >= 1.78e3)
187	<	return(resfreq[NPOINTS-1]);
188	<	/* interpolate data */
189	<	l10La = log10(La);
190	<	for (i = 0; i < NPOINTS-2 && l10lum[i+1] <= l10La; i++)
191	<	;
192	<	return( ( (l10lum[i+1] - l10La)*resfreq[i] +
193	<	(l10La - l10lum[i])*resfreq[i+1] ) /
194	<	(l10lum[i+1] - l10lum[i]) );
195	<	#undef NPOINTS
174	>	{
175	>	/* functional fit */
176	>	return(17.25*atan(1.4*log10(La) + 0.35) + 25.72);
177		}
178
179
#	Line 208 | Line 189 | int    y;
189		return(NULL);
190		for ( ; y >= sb->nread; sb->nread++) {          /* read as necessary */
191		mysl = bscan(sb, sb->nread);
192	<	if (sb->sampr == 1) {
192	>	if (sb->sampe == 0) {
193		if (freadscan(mysl, sb->len, infp) < 0) {
194		fprintf(stderr, "%s: %s: scanline read error\n",
195		progname, infn);
196		exit(1);
197		}
198		} else {
199	<	sl0 = getascan(sb->next, 2*y);
199	>	sl0 = getascan(sb+1, 2*y);
200		if (sl0 == NULL)
201		return(NULL);
202	<	sl1 = getascan(sb->next, 2*y+1);
202	>	sl1 = getascan(sb+1, 2*y+1);
203		for (i = 0; i < sb->len; i++) {
204		copycolor(mysl[i], sl0[2*i]);
205		addcolor(mysl[i], sl0[2*i+1]);
#	Line 242 | Line 223 | int    y;
223		register int    x;
224		/* compute foveal y position */
225		iy = dy = (y+.5)/numscans(&inpres)*fvyr - .5;
226	<	if (iy >= fvyr-1) iy--;
226	>	while (iy >= fvyr-1) iy--;
227		dy -= (double)iy;
228		for (x = 0; x < scanlen(&inpres); x++) {
229		/* compute foveal x position */
230		ix = dx = (x+.5)/scanlen(&inpres)*fvxr - .5;
231	<	if (ix >= fvxr-1) ix--;
231	>	while (ix >= fvxr-1) ix--;
232		dx -= (double)ix;
233		/* interpolate sample rate */
234		sr = (1.-dy)*((1.-dx)*tsampr(ix,iy) + dx*tsampr(ix+1,iy)) +
#	Line 267 | Line 248 | double sr;
248		double  d;
249		register SCANBAR        *sb0;
250
251	<	for (sb0 = rootbar; sb0->next != NULL && sb0->next->sampr > sr;
271	<	sb0 = sb0->next)
251	>	for (sb0 = rootbar; sb0->sampe != 0 && 1<<sb0[1].sampe > sr; sb0++)
252		;
253		ascanval(col, x, y, sb0);
254	<	if (sb0->next == NULL)          /* don't extrapolate highest */
254	>	if (sb0->sampe == 0)            /* don't extrapolate highest */
255		return;
256	<	ascanval(c1, x, y, sb0->next);
257	<	d = (sb0->sampr - sr)/(sb0->sampr - sb0->next->sampr);
256	>	ascanval(c1, x, y, sb0+1);
257	>	d = ((1<<sb0->sampe) - sr)/(1<<sb0[1].sampe);
258		scalecolor(col, 1.-d);
259		scalecolor(c1, d);
260		addcolor(col, c1);
#	Line 290 | Line 270 | SCANBAR        *sb;
270		double  dx, dy;
271		int     ix, iy;
272
273	<	if (sb->sampr == 1) {           /* no need to interpolate */
273	>	if (sb->sampe == 0) {           /* no need to interpolate */
274		sl0 = getascan(sb, y);
275		copycolor(col, sl0[x]);
276		return;
277		}
278		/* compute coordinates for sb */
279	<	ix = dx = (x+.5)/sb->sampr - .5;
280	<	if (ix >= sb->len-1) ix--;
279	>	ix = dx = (x+.5)/(1<<sb->sampe) - .5;
280	>	while (ix >= sb->len-1) ix--;
281		dx -= (double)ix;
282	<	iy = dy = (y+.5)/sb->sampr - .5;
283	<	if (iy >= numscans(&inpres)/sb->sampr-1) iy--;
282	>	iy = dy = (y+.5)/(1<<sb->sampe) - .5;
283	>	while (iy >= (numscans(&inpres)>>sb->sampe)-1) iy--;
284		dy -= (double)iy;
285		/* get scanlines */
286		sl0 = getascan(sb, iy);
287	<	if (sl0 == NULL) {
288	<	fprintf(stderr, "%s: internal - cannot backspace in ascanval\n",
289	<	progname);
290	<	exit(1);
311	<	}
287	>	#ifdef DEBUG
288	>	if (sl0 == NULL)
289	>	error(INTERNAL, "cannot backspace in ascanval");
290	>	#endif
291		sl1 = getascan(sb, iy+1);
292		/* 2D linear interpolation */
293		copycolor(col, sl0[ix]);
#	Line 324 | Line 303 | SCANBAR        *sb;
303		scalecolor(col, 1.-dy);
304		scalecolor(c1y, dy);
305		addcolor(col, c1y);
306	+	for (ix = 0; ix < 3; ix++)      /* make sure no negative */
307	+	if (colval(col,ix) < 0.)
308	+	colval(col,ix) = 0.;
309		}
310
311
312		SCANBAR *
313	<	sballoc(sr, ns, sl)             /* allocate scanbar */
314	<	int     sr;             /* sampling rate */
313	>	sballoc(se, ns, sl)             /* allocate scanbar */
314	>	int     se;             /* sampling rate exponent */
315		int     ns;             /* number of scanlines */
316		int     sl;             /* original scanline length */
317		{
318	+	SCANBAR *sbarr;
319		register SCANBAR        *sb;
320
321	<	sb = (SCANBAR *)malloc(sizeof(SCANBAR)+(sl/sr)*ns*sizeof(COLOR));
321	>	sbarr = sb = (SCANBAR *)malloc((se+1)*sizeof(SCANBAR));
322		if (sb == NULL)
323		syserror("malloc");
324	<	sb->nscans = ns;
325	<	sb->len = sl/sr;
326	<	sb->nread = 0;
327	<	if ((sb->sampr = sr) > 1)
328	<	sb->next = sballoc(sr/2, ns*2, sl);
329	<	else
330	<	sb->next = NULL;
331	<	return(sb);
324	>	do {
325	>	sb->sampe = se;
326	>	sb->len = sl>>se;
327	>	sb->nscans = ns;
328	>	sb->sdata = (COLOR *)malloc(sb->len*ns*sizeof(COLOR));
329	>	if (sb->sdata == NULL)
330	>	syserror("malloc");
331	>	sb->nread = 0;
332	>	ns <<= 1;
333	>	sb++;
334	>	} while (--se >= 0);
335	>	return(sbarr);
336		}
337
338
#	Line 373 | Line 360 | initacuity()                   /* initialize variable acuity sampling
360		}
361		fcross(cp, diffx, diffy);
362		omega = 0.5 * sqrt(DOT(cp,cp));
363	<	if (omega <= FTINY)
363	>	if (omega <= FTINY*FTINY)
364		tsampr(x,y) = 1.;
365		else if ((tsampr(x,y) = PI/180. / sqrt(omega) /
366		hacuity(plum(fovscan(y)[x]))) > maxsr)
#	Line 385 | Line 372 | initacuity()                   /* initialize variable acuity sampling
372		tsampr(x,fvyr-1) = tsampr(x,fvyr-2);
373		}
374		for (y = 0; y < fvyr; y++) {
375	<	tsampr(y,0) = tsampr(y,1);
376	<	tsampr(y,fvxr-1) = tsampr(y,fvxr-2);
375	>	tsampr(0,y) = tsampr(1,y);
376	>	tsampr(fvxr-1,y) = tsampr(fvxr-2,y);
377		}
378		/* initialize with next power of two */
379	<	rootbar = sballoc(2<<(int)(log(maxsr)/log(2.)), 2, scanlen(&inpres));
379	>	rootbar = sballoc((int)(log(maxsr)/log(2.))+1, 2, scanlen(&inpres));
380		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)