ViewVC Help

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

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

Comparing ray/src/px/pcond3.c (file contents):
Revision 3.10 by gwlarson, Thu Mar 12 15:47:34 1998 UTC vs.
Revision 3.16 by greg, Fri Aug 21 05:48:28 2015 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1997 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char       RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Routines for computing and applying brightness mapping.
6		*/
7
8	+	#include <string.h>
9	+
10		#include "pcond.h"
11
12
#	Line 16 | Line 15 | static char SCCSid[] = "$SunId$ LBL";
15		#define LN_10           2.30258509299404568402
16		#define exp10(x)        exp(LN_10*(x))
17
18	<	float   modhist[HISTRES];               /* modified histogram */
18	>	double  modhist[HISTRES];               /* modified histogram */
19		double  mhistot;                        /* modified histogram total */
20	<	float   cumf[HISTRES+1];                /* cumulative distribution function */
20	>	double  cumf[HISTRES+1];                /* cumulative distribution function */
21
22	+	static double centprob(int      x, int  y);
23	+	static void mkcumf(void);
24	+	static double cf(double b);
25	+	static double BLw(double        Lw);
26	+	#if ADJ_VEIL
27	+	static void mkcrfimage(void);
28	+	#endif
29
30	<	getfixations(fp)                /* load fixation history list */
31	<	FILE    *fp;
30	>
31	>
32	>	void
33	>	getfixations(           /* load fixation history list */
34	>	FILE    *fp
35	>	)
36		{
37		#define FIXHUNK         128
38		RESOLU  fvres;
39		int     pos[2];
40	<	register int    px, py, i;
40	>	int     px, py, i;
41		/* initialize our resolution struct */
42	<	if ((fvres.or=inpres.or)&YMAJOR) {
42	>	if ((fvres.rt=inpres.rt)&YMAJOR) {
43		fvres.xr = fvxr;
44		fvres.yr = fvyr;
45		} else {
#	Line 57 | Line 67 | FILE   *fp;
67		if (nfixations % FIXHUNK == 0) {
68		if (nfixations)
69		fixlst = (short (*)[2])
70	<	realloc((char *)fixlst,
70	>	realloc((void *)fixlst,
71		(nfixations+FIXHUNK)*
72		2*sizeof(short));
73		else
#	Line 82 | Line 92 | FILE   *fp;
92		}
93
94
95	<	gethisto(fp)                    /* load precomputed luminance histogram */
96	<	FILE    *fp;
95	>	void
96	>	gethisto(                       /* load precomputed luminance histogram */
97	>	FILE    *fp
98	>	)
99		{
100	<	float   histo[MAXPREHIST];
100	>	double  histo[MAXPREHIST];
101		double  histart, histep;
102	<	double  l, b, lastb, w;
102	>	double  b, lastb, w;
103		int     n;
104	<	register int    i;
104	>	int     i;
105		/* load data */
106		for (i = 0; i < MAXPREHIST &&
107	<	fscanf(fp, "%lf %f", &b, &histo[i]) == 2; i++) {
108	<	if (i > 1 && fabs(b - lastb - histep) > 1e-3) {
107	>	fscanf(fp, "%lf %lf", &b, &histo[i]) == 2; i++) {
108	>	if (i > 1 && fabs(b - lastb - histep) > .001) {
109		fprintf(stderr,
110		"%s: uneven step size in histogram data\n",
111		progname);
112		exit(1);
113		}
114		if (i == 1)
115	<	histep = b - (histart = lastb);
115	>	if ((histep = b - (histart = lastb)) <= FTINY) {
116	>	fprintf(stderr,
117	>	"%s: illegal step in histogram data\n",
118	>	progname);
119	>	exit(1);
120	>	}
121		lastb = b;
122		}
123		if (i < 2 || !feof(fp)) {
#	Line 115 | Line 132 | FILE   *fp;
132		/* find extrema */
133		for (i = 0; i < n && histo[i] <= FTINY; i++)
134		;
135	<	bwmin = histart + i*histep;
135	>	bwmin = histart + (i-.001)*histep;
136		for (i = n; i-- && histo[i] <= FTINY; )
137		;
138	<	bwmax = histart + i*histep;
138	>	bwmax = histart + (i+1.001)*histep;
139		if (bwmax > Bl(LMAX))
140		bwmax = Bl(LMAX);
141		if (bwmin < Bl(LMIN))
#	Line 130 | Line 147 | FILE   *fp;
147		for (i = 0; i < HISTRES; i++)
148		bwhist[i] = 0.;
149		for (i = 0, b = histart; i < n; i++, b += histep) {
150	<	if (b < bwmin) continue;
151	<	if (b > bwmax) break;
150	>	if (b < bwmin+FTINY) continue;
151	>	if (b >= bwmax-FTINY) break;
152		w = histo[i];
153		bwavg += w*b;
154		bwhist[bwhi(b)] += w;
#	Line 145 | Line 162 | FILE   *fp;
162		}
163
164
165	<	double
166	<	centprob(x, y)                  /* center-weighting probability function */
167	<	int     x, y;
165	>	static double
166	>	centprob(                       /* center-weighting probability function */
167	>	int     x,
168	>	int     y
169	>	)
170		{
171		double  xr, yr, p;
172		/* paraboloid, 0 at 90 degrees from center */
#	Line 158 | Line 177 | int    x, y;
177		}
178
179
180	<	comphist()                      /* create foveal sampling histogram */
180	>	void
181	>	comphist(void)                  /* create foveal sampling histogram */
182		{
183		double  l, b, w, lwmin, lwmax;
184	<	register int    x, y;
184	>	int     x, y;
185		/* check for precalculated histogram */
186		if (what2do&DO_PREHIST)
187		return;
#	Line 170 | Line 190 | comphist()                     /* create foveal sampling histogram */
190		for (y = 0; y < fvyr; y++)
191		for (x = 0; x < fvxr; x++) {
192		l = plum(fovscan(y)[x]);
193	<	if (l < lwmin) lwmin = l;
194	<	if (l > lwmax) lwmax = l;
193	>	if ((l < lwmin) & (l > LMIN)) lwmin = l;
194	>	if ((l > lwmax) & (l < LMAX)) lwmax = l;
195		}
196		lwmax *= 1.01;
197		if (lwmax > LMAX)
#	Line 194 | Line 214 | comphist()                     /* create foveal sampling histogram */
214		for (y = 0; y < fvyr; y++)
215		for (x = 0; x < fvxr; x++) {
216		l = plum(fovscan(y)[x]);
217	<	if (l < lwmin) continue;
218	<	if (l > lwmax) continue;
217	>	if (l < lwmin+FTINY) continue;
218	>	if (l >= lwmax-FTINY) continue;
219		b = Bl(l);
220		w = what2do&DO_CWEIGHT ? centprob(x,y) : 1.;
221		bwavg += w*b;
#	Line 210 | Line 230 | comphist()                     /* create foveal sampling histogram */
230		w = 1.;
231		for (x = 0; x < nfixations; x++) {
232		l = plum(fovscan(fixlst[x][1])[fixlst[x][0]]);
233	<	if (l < lwmin) continue;
234	<	if (l > lwmax) continue;
233	>	if (l < lwmin+FTINY) continue;
234	>	if (l >= lwmax-FTINY) continue;
235		b = Bl(l);
236		bwavg += w*b;
237		bwhist[bwhi(b)] += w;
#	Line 226 | Line 246 | comphist()                     /* create foveal sampling histogram */
246		}
247
248
249	<	mkcumf()                        /* make cumulative distribution function */
249	>	static void
250	>	mkcumf(void)                    /* make cumulative distribution function */
251		{
252	<	register int    i;
253	<	register double sum;
252	>	int     i;
253	>	double  sum;
254
255		mhistot = 0.;           /* compute modified total */
256		for (i = 0; i < HISTRES; i++)
#	Line 244 | Line 265 | mkcumf()                       /* make cumulative distribution function */
265		}
266
267
268	<	double
269	<	cf(b)                           /* return cumulative function at b */
270	<	double  b;
268	>	static double
269	>	cf(                             /* return cumulative function at b */
270	>	double  b
271	>	)
272		{
273		double  x;
274	<	register int    i;
274	>	int     i;
275
276		i = x = HISTRES*(b - bwmin)/(bwmax - bwmin);
277		x -= (double)i;
#	Line 257 | Line 279 | double b;
279		}
280
281
282	<	double
283	<	BLw(Lw)                         /* map world luminance to display brightness */
284	<	double  Lw;
282	>	static double
283	>	BLw(                            /* map world luminance to display brightness */
284	>	double  Lw
285	>	)
286		{
287		double  b;
288
#	Line 272 | Line 295 | double Lw;
295
296
297		double
298	<	htcontrs(La)            /* human threshold contrast sensitivity, dL(La) */
299	<	double  La;
298	>	htcontrs(               /* human threshold contrast sensitivity, dL(La) */
299	>	double  La
300	>	)
301		{
302		double  l10La, l10dL;
303		/* formula taken from Ferwerda et al. [SG96] */
#	Line 294 | Line 318 | double La;
318
319
320		double
321	<	clampf(Lw)              /* derivative clamping function */
322	<	double  Lw;
321	>	clampf(                 /* histogram clamping function */
322	>	double  Lw
323	>	)
324		{
325		double  bLw, ratio;
326
#	Line 304 | Line 329 | double Lw;
329		return(ratio/(Lb1(bLw)*(Bldmax-Bldmin)*Bl1(Lw)));
330		}
331
332	+	double
333	+	crfactor(                       /* contrast reduction factor */
334	+	double  Lw
335	+	)
336	+	{
337	+	int     i = HISTRES*(Bl(Lw) - bwmin)/(bwmax - bwmin);
338	+	double  bLw, ratio, Tdb;
339
340	+	if (i <= 0)
341	+	return(1.0);
342	+	if (i >= HISTRES)
343	+	return(1.0);
344	+	bLw = BLw(Lw);
345	+	ratio = what2do&DO_HSENS ? htcontrs(Lb(bLw))/htcontrs(Lw) : Lb(bLw)/Lw;
346	+	Tdb = mhistot * (bwmax - bwmin) / HISTRES;
347	+	return(modhist[i]*Lb1(bLw)*(Bldmax-Bldmin)*Bl1(Lw)/(Tdb*ratio));
348	+	}
349	+
350	+
351	+	#if ADJ_VEIL
352	+	static void
353	+	mkcrfimage(void)                        /* compute contrast reduction factor image */
354	+	{
355	+	int     i;
356	+	float   *crfptr;
357	+	COLOR   *fovptr;
358	+
359	+	if (crfimg == NULL)
360	+	crfimg = (float *)malloc(fvxr*fvyr*sizeof(float));
361	+	if (crfimg == NULL)
362	+	syserror("malloc");
363	+	crfptr = crfimg;
364	+	fovptr = fovimg;
365	+	for (i = fvxr*fvyr; i--; crfptr++, fovptr++)
366	+	crfptr[0] = crfactor(plum(fovptr[0]));
367	+	}
368	+	#endif
369	+
370	+
371		int
372	<	mkbrmap()                       /* make dynamic range map */
372	>	mkbrmap(void)                   /* make dynamic range map */
373		{
374	<	double  T, b, s;
374	>	double  Tdb, b, s;
375		double  ceiling, trimmings;
376	<	register int    i;
376	>	int     i;
377		/* copy initial histogram */
378	<	bcopy((char *)bwhist, (char *)modhist, sizeof(modhist));
379	<	s = (bwmax - bwmin)/HISTRES;
378	>	memcpy((void *)modhist, (void *)bwhist, sizeof(modhist));
379	>	s = (bwmax - bwmin)/HISTRES;    /* s is delta b */
380		/* loop until satisfactory */
381		do {
382		mkcumf();                       /* sync brightness mapping */
383		if (mhistot <= histot*CVRATIO)
384		return(-1);             /* no compression needed! */
385	<	T = mhistot * (bwmax - bwmin) / HISTRES;
385	>	Tdb = mhistot * s;
386		trimmings = 0.;                 /* clip to envelope */
387		for (i = 0, b = bwmin + .5*s; i < HISTRES; i++, b += s) {
388	<	ceiling = T*clampf(Lb(b));
388	>	ceiling = Tdb*clampf(Lb(b));
389		if (modhist[i] > ceiling) {
390		trimmings += modhist[i] - ceiling;
391		modhist[i] = ceiling;
#	Line 330 | Line 393 | mkbrmap()                      /* make dynamic range map */
393		}
394		} while (trimmings > histot*CVRATIO);
395
396	+	#if ADJ_VEIL
397	+	mkcrfimage();                   /* contrast reduction image */
398	+	#endif
399	+
400		return(0);                      /* we got it */
401		}
402
403
404	<	scotscan(scan, xres)            /* apply scotopic color sensitivity loss */
405	<	COLOR   *scan;
406	<	int     xres;
404	>	void
405	>	scotscan(               /* apply scotopic color sensitivity loss */
406	>	COLOR   *scan,
407	>	int     xres
408	>	)
409		{
410		COLOR   ctmp;
411		double  incolor, b, Lw;
412	<	register int    i;
412	>	int     i;
413
414		for (i = 0; i < xres; i++) {
415		Lw = plum(scan[i]);
#	Line 365 | Line 434 | int    xres;
434		}
435
436
437	<	mapscan(scan, xres)             /* apply tone mapping operator to scanline */
438	<	COLOR   *scan;
439	<	int     xres;
437	>	void
438	>	mapscan(                /* apply tone mapping operator to scanline */
439	>	COLOR   *scan,
440	>	int     xres
441	>	)
442		{
443		double  mult, Lw, b;
444	<	register int    i;
444	>	int     x;
445
446	<	for (i = 0; i < xres; i++) {
447	<	Lw = plum(scan[i]);
446	>	for (x = 0; x < xres; x++) {
447	>	Lw = plum(scan[x]);
448		if (Lw < LMIN) {
449	<	setcolor(scan[i], 0., 0., 0.);
449	>	setcolor(scan[x], 0., 0., 0.);
450		continue;
451		}
452	<	b = BLw(Lw);
453	<	mult = (Lb(b) - ldmin)/(ldmax - ldmin) / (Lw*inpexp);
452	>	b = BLw(Lw);            /* apply brightness mapping */
453	>	mult = (Lb(b) - ldmin)/(ldmax - ldmin)/(Lw*inpexp);
454		if (lumf == rgblum) mult *= WHTEFFICACY;
455	<	scalecolor(scan[i], mult);
455	>	scalecolor(scan[x], mult);
456		}
457		}
458
459
460	<	putmapping(fp)                  /* put out mapping function */
461	<	FILE    *fp;
460	>	void
461	>	putmapping(                     /* put out mapping function */
462	>	FILE    *fp
463	>	)
464		{
465		double  b, s;
466	<	register int    i;
466	>	int     i;
467		double  wlum, sf, dlum;
468
469		sf = scalef*inpexp;

Diff Legend

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