[ViewVC] Diff of: radiance/ray/src/common/tonemap.c

Comparing ray/src/common/tonemap.c (file contents):
Revision 3.9 by greg, Sat Feb 22 02:07:22 2003 UTC vs.
Revision 3.25 by greg, Thu May 11 00:58:48 2006 UTC

#	Line 9 \| Line 9 \| static const char RCSid[] = "$Id$";
9		* Externals declared in tonemap.h
10		*/
11
12	<	/* ====================================================================
13	<	* The Radiance Software License, Version 1.0
14	<	*
15	<	* Copyright (c) 1990 - 2002 The Regents of the University of California,
16	<	* through Lawrence Berkeley National Laboratory. All rights reserved.
17	<	*
18	<	* Redistribution and use in source and binary forms, with or without
19	<	* modification, are permitted provided that the following conditions
20	<	* are met:
21	<	*
22	<	* 1. Redistributions of source code must retain the above copyright
23	<	* notice, this list of conditions and the following disclaimer.
24	<	*
25	<	* 2. Redistributions in binary form must reproduce the above copyright
26	<	* notice, this list of conditions and the following disclaimer in
27	<	* the documentation and/or other materials provided with the
28	<	* distribution.
29	<	*
30	<	* 3. The end-user documentation included with the redistribution,
31	<	* if any, must include the following acknowledgment:
32	<	* "This product includes Radiance software
33	<	* (http://radsite.lbl.gov/)
34	<	* developed by the Lawrence Berkeley National Laboratory
35	<	* (http://www.lbl.gov/)."
36	<	* Alternately, this acknowledgment may appear in the software itself,
37	<	* if and wherever such third-party acknowledgments normally appear.
38	<	*
39	<	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
40	<	* and "The Regents of the University of California" must
41	<	* not be used to endorse or promote products derived from this
42	<	* software without prior written permission. For written
43	<	* permission, please contact [email protected].
44	<	*
45	<	* 5. Products derived from this software may not be called "Radiance",
46	<	* nor may "Radiance" appear in their name, without prior written
47	<	* permission of Lawrence Berkeley National Laboratory.
48	<	*
49	<	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
50	<	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
51	<	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
52	<	* DISCLAIMED. IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
53	<	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
54	<	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
55	<	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
56	<	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
57	<	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
58	<	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
59	<	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
60	<	* SUCH DAMAGE.
61	<	* ====================================================================
62	<	*
63	<	* This software consists of voluntary contributions made by many
64	<	* individuals on behalf of Lawrence Berkeley National Laboratory. For more
65	<	* information on Lawrence Berkeley National Laboratory, please see
66	<	* <http://www.lbl.gov/>.
67	<	*/
12	>	#include "copyright.h"
13
14		#include <stdio.h>
15		#include <math.h>
#	Line 73 \| Line 18 \| static const char RCSid[] = "$Id$";
18
19		#define exp10(x) exp(M_LN10*(x))
20
76	–	struct tmStruct tmTop = NULL; / current tone mapping stack */
77	–
21		/* our list of conversion packages */
22		struct tmPackage *tmPkg[TM_MAXPKG];
23		int tmNumPkgs = 0; /* number of registered packages */
24
25	<	int tmLastError; /* last error incurred by library */
26	<	char tmLastFunction; / error-generating function name */
25	>	/* luminance->brightness lookup */
26	>	static TMbright *tmFloat2BrtLUT = NULL;
27
28	+	#define tmCvLumLUfp(pf) tmFloat2BrtLUT[(int32 )(pf) >> 15]
29
30	<	struct tmStruct *
31	<	tmInit(flags, monpri, gamval) /* initialize new tone mapping */
32	<	int flags;
33	<	RGBPRIMP monpri;
34	<	double gamval;
30	>
31	>	TMstruct *
32	>	tmInit( /* initialize new tone mapping */
33	>	int flags,
34	>	RGBPRIMP monpri,
35	>	double gamval
36	>	)
37		{
38		COLORMAT cmat;
39	<	register struct tmStruct *tmnew;
40	<	register int i;
39	>	TMstruct *tmnew;
40	>	int i;
41		/* allocate structure */
42	<	tmnew = (struct tmStruct *)malloc(sizeof(struct tmStruct));
42	>	tmnew = (TMstruct *)malloc(sizeof(TMstruct));
43		if (tmnew == NULL)
44		return(NULL);
45
46		tmnew->flags = flags & ~TM_F_UNIMPL;
47	+	if (tmnew->flags & TM_F_BW)
48	+	tmnew->flags &= ~TM_F_MESOPIC;
49		/* set monitor transform */
50		if (monpri == NULL \|\| monpri == stdprims \|\| tmnew->flags & TM_F_BW) {
51		tmnew->monpri = stdprims;
#	Line 125 \| Line 73 \| double gamval;
73		tmnew->inpsf = WHTEFFICACY;
74		tmnew->cmat[0][1] = tmnew->cmat[0][2] = tmnew->cmat[1][0] =
75		tmnew->cmat[1][2] = tmnew->cmat[2][0] = tmnew->cmat[2][1] = 0.;
76	+	tmnew->inpdat = NULL;
77		tmnew->hbrmin = 10; tmnew->hbrmax = -10;
78		tmnew->histo = NULL;
79		tmnew->mbrmin = 10; tmnew->mbrmax = -10;
#	Line 132 \| Line 81 \| double gamval;
81		/* zero private data */
82		for (i = TM_MAXPKG; i--; )
83		tmnew->pd[i] = NULL;
84	<	/* make tmnew current */
85	<	tmnew->tmprev = tmTop;
86	<	return(tmTop = tmnew);
84	>	tmnew->lastError = TM_E_OK;
85	>	tmnew->lastFunc = "NoErr";
86	>	/* return new TMstruct */
87	>	return(tmnew);
88		}
89
90
91		int
92	<	tmSetSpace(pri, sf) /* set input color space for conversions */
93	<	RGBPRIMP pri;
94	<	double sf;
92	>	tmSetSpace( /* set input color space for conversions */
93	>	TMstruct *tms,
94	>	RGBPRIMP pri,
95	>	double sf,
96	>	MEM_PTR dat
97	>	)
98		{
99	<	static char funcName[] = "tmSetSpace";
100	<	register int i, j;
99	>	static const char funcName[] = "tmSetSpace";
100	>	int i, j;
101		/* error check */
102	<	if (tmTop == NULL)
102	>	if (tms == NULL)
103		returnErr(TM_E_TMINVAL);
104		if (sf <= 1e-12)
105		returnErr(TM_E_ILLEGAL);
106		/* check if no change */
107	<	if (pri == tmTop->inppri && FEQ(sf, tmTop->inpsf))
107	>	if (pri == tms->inppri && FEQ(sf, tms->inpsf) && dat == tms->inpdat)
108		returnOK;
109	<	tmTop->inppri = pri; /* let's set it */
110	<	tmTop->inpsf = sf;
109	>	tms->inppri = pri; /* let's set it */
110	>	tms->inpsf = sf;
111	>	tms->inpdat = dat;
112
113	<	if (tmTop->flags & TM_F_BW) { /* color doesn't matter */
114	<	tmTop->monpri = tmTop->inppri; /* eliminate xform */
115	<	if (tmTop->inppri == TM_XYZPRIM) {
116	<	tmTop->clf[CIEX] = tmTop->clf[CIEZ] = 0.;
117	<	tmTop->clf[CIEY] = 1.;
113	>	if (tms->flags & TM_F_BW) { /* color doesn't matter */
114	>	tms->monpri = tms->inppri; /* eliminate xform */
115	>	if (tms->inppri == TM_XYZPRIM) {
116	>	tms->clf[CIEX] = tms->clf[CIEZ] = 0.;
117	>	tms->clf[CIEY] = 1.;
118		} else {
119	<	comprgb2xyzWBmat(tmTop->cmat, tmTop->monpri);
120	<	tmTop->clf[RED] = tmTop->cmat[1][0];
121	<	tmTop->clf[GRN] = tmTop->cmat[1][1];
122	<	tmTop->clf[BLU] = tmTop->cmat[1][2];
119	>	comprgb2xyzWBmat(tms->cmat, tms->monpri);
120	>	tms->clf[RED] = tms->cmat[1][0];
121	>	tms->clf[GRN] = tms->cmat[1][1];
122	>	tms->clf[BLU] = tms->cmat[1][2];
123		}
124	<	tmTop->cmat[0][0] = tmTop->cmat[1][1] = tmTop->cmat[2][2] =
125	<	tmTop->inpsf;
126	<	tmTop->cmat[0][1] = tmTop->cmat[0][2] = tmTop->cmat[1][0] =
127	<	tmTop->cmat[1][2] = tmTop->cmat[2][0] = tmTop->cmat[2][1] = 0.;
124	>	tms->cmat[0][0] = tms->cmat[1][1] = tms->cmat[2][2] =
125	>	tms->inpsf;
126	>	tms->cmat[0][1] = tms->cmat[0][2] = tms->cmat[1][0] =
127	>	tms->cmat[1][2] = tms->cmat[2][0] = tms->cmat[2][1] = 0.;
128
129	<	} else if (tmTop->inppri == TM_XYZPRIM) /* input is XYZ */
130	<	compxyz2rgbWBmat(tmTop->cmat, tmTop->monpri);
129	>	} else if (tms->inppri == TM_XYZPRIM) /* input is XYZ */
130	>	compxyz2rgbWBmat(tms->cmat, tms->monpri);
131
132		else { /* input is RGB */
133	<	if (tmTop->inppri != tmTop->monpri &&
134	<	PRIMEQ(tmTop->inppri, tmTop->monpri))
135	<	tmTop->inppri = tmTop->monpri; /* no xform */
136	<	comprgb2rgbWBmat(tmTop->cmat, tmTop->inppri, tmTop->monpri);
133	>	if (tms->inppri != tms->monpri &&
134	>	PRIMEQ(tms->inppri, tms->monpri))
135	>	tms->inppri = tms->monpri; /* no xform */
136	>	comprgb2rgbWBmat(tms->cmat, tms->inppri, tms->monpri);
137		}
138		for (i = 0; i < 3; i++)
139		for (j = 0; j < 3; j++)
140	<	tmTop->cmat[i][j] *= tmTop->inpsf;
140	>	tms->cmat[i][j] *= tms->inpsf;
141		/* set color divisors */
142		for (i = 0; i < 3; i++)
143	<	if (tmTop->clf[i] > .001)
144	<	tmTop->cdiv[i] =
145	<	256.*pow(tmTop->clf[i], 1./tmTop->mongam);
143	>	if (tms->clf[i] > .001)
144	>	tms->cdiv[i] =
145	>	256.*pow(tms->clf[i], 1./tms->mongam);
146		else
147	<	tmTop->cdiv[i] = 1;
147	>	tms->cdiv[i] = 1;
148		/* notify packages */
149		for (i = tmNumPkgs; i--; )
150	<	if (tmTop->pd[i] != NULL && tmPkg[i]->NewSpace != NULL)
151	<	(*tmPkg[i]->NewSpace)(tmTop);
150	>	if (tms->pd[i] != NULL && tmPkg[i]->NewSpace != NULL)
151	>	(*tmPkg[i]->NewSpace)(tms);
152		returnOK;
153		}
154
155
156		void
157	<	tmClearHisto() /* clear current histogram */
157	>	tmClearHisto( /* clear current histogram */
158	>	TMstruct *tms
159	>	)
160		{
161	<	if (tmTop == NULL \|\| tmTop->histo == NULL)
161	>	if (tms == NULL \|\| tms->histo == NULL)
162		return;
163	<	free((MEM_PTR)tmTop->histo);
164	<	tmTop->histo = NULL;
163	>	free((MEM_PTR)tms->histo);
164	>	tms->histo = NULL;
165		}
166
167
168	+	TMbright
169	+	tmCvLuminance( /* convert a single luminance */
170	+	double lum
171	+	)
172	+	{
173	+	double d;
174	+
175	+	#ifdef isfinite
176	+	if (!isfinite(lum) \|\| lum <= TM_NOLUM)
177	+	#else
178	+	if (lum <= TM_NOLUM)
179	+	#endif
180	+	return(TM_NOBRT);
181	+	d = TM_BRTSCALE*log(lum);
182	+	if (d > 0.)
183	+	return((TMbright)(d+.5));
184	+	return((TMbright)(d-.5));
185	+	}
186	+
187	+
188		int
189	<	tmCvColors(ls, cs, scan, len) /* convert float colors */
190	<	TMbright *ls;
191	<	BYTE *cs;
192	<	COLOR *scan;
193	<	int len;
189	>	tmCvLums( /* convert luminances using lookup */
190	>	TMbright *ls,
191	>	float *scan,
192	>	int len
193	>	)
194		{
195	<	static char funcName[] = "tmCvColors";
196	<	static COLOR csmall = {1e-6, 1e-6, 1e-6};
195	>	if (tmFloat2BrtLUT == NULL) { /* initialize lookup table */
196	>	int32 i;
197	>	tmFloat2BrtLUT = (TMbright )malloc(sizeof(TMbright)0x10000);
198	>	if (tmFloat2BrtLUT == NULL)
199	>	return(TM_E_NOMEM);
200	>	for (i = 0; i < 0x10000; i++) {
201	>	int32 l = (i<<1 \| 1) << 14;
202	>	#ifndef isfinite
203	>	if ((l & 0x7f800000) == 0x7f800000)
204	>	tmFloat2BrtLUT[i] = TM_NOBRT;
205	>	else
206	>	#endif
207	>	tmFloat2BrtLUT[i] = tmCvLuminance((float )&l);
208	>	}
209	>	}
210	>	if (len <= 0)
211	>	return(TM_E_OK);
212	>	if ((ls == NULL) \| (scan == NULL))
213	>	return(TM_E_ILLEGAL);
214	>	while (len--) {
215	>	if (*scan <= TM_NOLUM) {
216	>	*ls++ = TM_NOBRT;
217	>	++scan;
218	>	continue;
219	>	}
220	>	*ls++ = tmCvLumLUfp(scan++);
221	>	}
222	>	return(TM_E_OK);
223	>	}
224	>
225	>
226	>	int
227	>	tmCvGrays( /* convert float gray values */
228	>	TMstruct *tms,
229	>	TMbright *ls,
230	>	float *scan,
231	>	int len
232	>	)
233	>	{
234	>	static const char funcName[] = "tmCvGrays";
235	>	double d;
236	>	int i;
237	>
238	>	if (tms == NULL)
239	>	returnErr(TM_E_TMINVAL);
240	>	if ((ls == NULL) \| (scan == NULL) \| (len < 0))
241	>	returnErr(TM_E_ILLEGAL);
242	>	if (tmFloat2BrtLUT == NULL) /* initialize */
243	>	tmCvLums(NULL, NULL, 0);
244	>	for (i = len; i--; ) {
245	>	float lum = tms->inpsf * scan[i];
246	>	if (lum <= TM_NOLUM)
247	>	ls[i] = TM_NOBRT;
248	>	else
249	>	ls[i] = tmCvLumLUfp(&lum);
250	>	}
251	>	returnOK;
252	>	}
253	>
254	>
255	>	int
256	>	tmCvColors( /* convert float colors */
257	>	TMstruct *tms,
258	>	TMbright *ls,
259	>	BYTE *cs,
260	>	COLOR *scan,
261	>	int len
262	>	)
263	>	{
264	>	static const char funcName[] = "tmCvColors";
265	>	static BYTE gamtab[1024];
266	>	static double curgam = .0;
267		COLOR cmon;
268	<	double lum, slum;
269	<	register double d;
224	<	register int i;
268	>	float lum, slum, d;
269	>	int i;
270
271	<	if (tmTop == NULL)
271	>	if (tms == NULL)
272		returnErr(TM_E_TMINVAL);
273	<	if (ls == NULL \| scan == NULL \| len < 0)
273	>	if ((ls == NULL) \| (scan == NULL) \| (len < 0))
274		returnErr(TM_E_ILLEGAL);
275	+	if (tmFloat2BrtLUT == NULL) /* initialize */
276	+	tmCvLums(NULL, NULL, 0);
277	+	if (cs != TM_NOCHROM && fabs(tms->mongam - curgam) > .02) {
278	+	curgam = tms->mongam; /* (re)build table */
279	+	for (i = 1024; i--; )
280	+	gamtab[i] = (int)(256.*pow((i+.5)/1024., 1./curgam));
281	+	}
282		for (i = len; i--; ) {
283	<	if (tmNeedMatrix(tmTop)) /* get monitor RGB */
284	<	colortrans(cmon, tmTop->cmat, scan[i]);
233	<	else {
234	<	cmon[RED] = tmTop->inpsf*scan[i][RED];
235	<	cmon[GRN] = tmTop->inpsf*scan[i][GRN];
236	<	cmon[BLU] = tmTop->inpsf*scan[i][BLU];
237	<	}
238	<	/* world luminance */
239	<	lum = tmTop->clf[RED]*cmon[RED] +
240	<	tmTop->clf[GRN]*cmon[GRN] +
241	<	tmTop->clf[BLU]*cmon[BLU] ;
242	<	/* check range */
243	<	if (clipgamut(cmon, lum, CGAMUT_LOWER, csmall, cwhite))
244	<	lum = tmTop->clf[RED]*cmon[RED] +
245	<	tmTop->clf[GRN]*cmon[GRN] +
246	<	tmTop->clf[BLU]*cmon[BLU] ;
247	<	if (lum < MINLUM) {
248	<	ls[i] = MINBRT-1; /* bogus value */
249	<	lum = MINLUM;
283	>	if (tmNeedMatrix(tms)) { /* get monitor RGB */
284	>	colortrans(cmon, tms->cmat, scan[i]);
285		} else {
286	<	d = TM_BRTSCALElog(lum); / encode it */
287	<	ls[i] = d>0. ? (int)(d+.5) : (int)(d-.5);
286	>	cmon[RED] = tms->inpsf*scan[i][RED];
287	>	cmon[GRN] = tms->inpsf*scan[i][GRN];
288	>	cmon[BLU] = tms->inpsf*scan[i][BLU];
289		}
290	+	#ifdef isfinite
291	+	if (!isfinite(cmon[RED]) \|\| cmon[RED] < .0f) cmon[RED] = .0f;
292	+	if (!isfinite(cmon[GRN]) \|\| cmon[GRN] < .0f) cmon[GRN] = .0f;
293	+	if (!isfinite(cmon[BLU]) \|\| cmon[BLU] < .0f) cmon[BLU] = .0f;
294	+	#else
295	+	if (cmon[RED] < .0f) cmon[RED] = .0f;
296	+	if (cmon[GRN] < .0f) cmon[GRN] = .0f;
297	+	if (cmon[BLU] < .0f) cmon[BLU] = .0f;
298	+	#endif
299	+	/* world luminance */
300	+	lum = tms->clf[RED]*cmon[RED] +
301	+	tms->clf[GRN]*cmon[GRN] +
302	+	tms->clf[BLU]*cmon[BLU] ;
303	+	if (lum <= TM_NOLUM) { /* convert brightness */
304	+	lum = cmon[RED] = cmon[GRN] = cmon[BLU] = TM_NOLUM;
305	+	ls[i] = TM_NOBRT;
306	+	} else
307	+	ls[i] = tmCvLumLUfp(&lum);
308		if (cs == TM_NOCHROM) /* no color? */
309		continue;
310	<	if (tmTop->flags & TM_F_MESOPIC && lum < LMESUPPER) {
310	>	if (tms->flags & TM_F_MESOPIC && lum < LMESUPPER) {
311		slum = scotlum(cmon); /* mesopic adj. */
312	<	if (lum < LMESLOWER)
312	>	if (lum < LMESLOWER) {
313		cmon[RED] = cmon[GRN] = cmon[BLU] = slum;
314	<	else {
314	>	} else {
315		d = (lum - LMESLOWER)/(LMESUPPER - LMESLOWER);
316	<	if (tmTop->flags & TM_F_BW)
316	>	if (tms->flags & TM_F_BW)
317		cmon[RED] = cmon[GRN] =
318		cmon[BLU] = d*lum;
319		else
320		scalecolor(cmon, d);
321	<	d = (1.-d)*slum;
321	>	d = (1.f-d)*slum;
322		cmon[RED] += d;
323		cmon[GRN] += d;
324		cmon[BLU] += d;
325		}
326	<	} else if (tmTop->flags & TM_F_BW) {
326	>	} else if (tms->flags & TM_F_BW) {
327		cmon[RED] = cmon[GRN] = cmon[BLU] = lum;
328		}
329	<	d = tmTop->clf[RED]*cmon[RED]/lum;
330	<	cs[3*i ] = d>=.999 ? 255 :
331	<	(int)(256.*pow(d, 1./tmTop->mongam));
332	<	d = tmTop->clf[GRN]*cmon[GRN]/lum;
333	<	cs[3*i+1] = d>=.999 ? 255 :
334	<	(int)(256.*pow(d, 1./tmTop->mongam));
281	<	d = tmTop->clf[BLU]*cmon[BLU]/lum;
282	<	cs[3*i+2] = d>=.999 ? 255 :
283	<	(int)(256.*pow(d, 1./tmTop->mongam));
329	>	d = tms->clf[RED]*cmon[RED]/lum;
330	>	cs[3i ] = d>=.999f ? 255 : gamtab[(int)(1024.fd)];
331	>	d = tms->clf[GRN]*cmon[GRN]/lum;
332	>	cs[3i+1] = d>=.999f ? 255 : gamtab[(int)(1024.fd)];
333	>	d = tms->clf[BLU]*cmon[BLU]/lum;
334	>	cs[3i+2] = d>=.999f ? 255 : gamtab[(int)(1024.fd)];
335		}
336		returnOK;
337		}
338
339
340		int
341	<	tmCvGrays(ls, scan, len) /* convert float gray values */
342	<	TMbright *ls;
343	<	float *scan;
344	<	int len;
341	>	tmAddHisto( /* add values to histogram */
342	>	TMstruct *tms,
343	>	TMbright *ls,
344	>	int len,
345	>	int wt
346	>	)
347		{
348	<	static char funcName[] = "tmCvGrays";
296	<	register double d;
297	<	register int i;
298	<
299	<	if (tmTop == NULL)
300	<	returnErr(TM_E_TMINVAL);
301	<	if (ls == NULL \| scan == NULL \| len < 0)
302	<	returnErr(TM_E_ILLEGAL);
303	<	for (i = len; i--; )
304	<	if (scan[i] <= TM_NOLUM) {
305	<	ls[i] = TM_NOBRT; /* bogus value */
306	<	} else {
307	<	d = TM_BRTSCALElog(scan[i]); / encode it */
308	<	ls[i] = d>0. ? (int)(d+.5) : (int)(d-.5);
309	<	}
310	<	returnOK;
311	<	}
312	<
313	<
314	<	int
315	<	tmAddHisto(ls, len, wt) /* add values to histogram */
316	<	register TMbright *ls;
317	<	int len;
318	<	int wt;
319	<	{
320	<	static char funcName[] = "tmAddHisto";
348	>	static const char funcName[] = "tmAddHisto";
349		int oldorig=0, oldlen, horig, hlen;
350	<	register int i, j;
350	>	int i, j;
351
352	<	if (tmTop == NULL)
352	>	if (tms == NULL)
353		returnErr(TM_E_TMINVAL);
354		if (len < 0)
355		returnErr(TM_E_ILLEGAL);
356		if (len == 0)
357		returnOK;
358		/* first, grow limits */
359	<	if (tmTop->histo == NULL) {
359	>	if (tms->histo == NULL) {
360		for (i = len; i-- && ls[i] < MINBRT; )
361		;
362		if (i < 0)
363		returnOK;
364	<	tmTop->hbrmin = tmTop->hbrmax = ls[i];
364	>	tms->hbrmin = tms->hbrmax = ls[i];
365		oldlen = 0;
366		} else {
367	<	oldorig = (tmTop->hbrmin-MINBRT)/HISTEP;
368	<	oldlen = (tmTop->hbrmax-MINBRT)/HISTEP + 1 - oldorig;
367	>	oldorig = (tms->hbrmin-MINBRT)/HISTEP;
368	>	oldlen = (tms->hbrmax-MINBRT)/HISTEP + 1 - oldorig;
369		}
370		for (i = len; i--; ) {
371		if ((j = ls[i]) < MINBRT)
372		continue;
373	<	if (j < tmTop->hbrmin)
374	<	tmTop->hbrmin = j;
375	<	else if (j > tmTop->hbrmax)
376	<	tmTop->hbrmax = j;
373	>	if (j < tms->hbrmin)
374	>	tms->hbrmin = j;
375	>	else if (j > tms->hbrmax)
376	>	tms->hbrmax = j;
377		}
378	<	horig = (tmTop->hbrmin-MINBRT)/HISTEP;
379	<	hlen = (tmTop->hbrmax-MINBRT)/HISTEP + 1 - horig;
378	>	horig = (tms->hbrmin-MINBRT)/HISTEP;
379	>	hlen = (tms->hbrmax-MINBRT)/HISTEP + 1 - horig;
380		if (hlen > oldlen) { /* (re)allocate histogram */
381	<	register int newhist = (int )calloc(hlen, sizeof(int));
381	>	int newhist = (int )calloc(hlen, sizeof(int));
382		if (newhist == NULL)
383		returnErr(TM_E_NOMEM);
384		if (oldlen) { /* copy and free old */
385		for (i = oldlen, j = i+oldorig-horig; i; )
386	<	newhist[--j] = tmTop->histo[--i];
387	<	free((MEM_PTR)tmTop->histo);
386	>	newhist[--j] = tms->histo[--i];
387	>	free((MEM_PTR)tms->histo);
388		}
389	<	tmTop->histo = newhist;
389	>	tms->histo = newhist;
390		}
391		if (wt == 0)
392		returnOK;
393		for (i = len; i--; ) /* add in new counts */
394		if (ls[i] >= MINBRT)
395	<	tmTop->histo[ (ls[i]-MINBRT)/HISTEP - horig ] += wt;
395	>	tms->histo[ (ls[i]-MINBRT)/HISTEP - horig ] += wt;
396		returnOK;
397		}
398
399
400		static double
401	<	htcontrs(La) /* human threshold contrast sensitivity, dL(La) */
402	<	double La;
401	>	htcontrs( /* human threshold contrast sensitivity, dL(La) */
402	>	double La
403	>	)
404		{
405		double l10La, l10dL;
406		/* formula taken from Ferwerda et al. [SG96] */
#	Line 392 \| Line 421 \| double La;
421
422
423		static int
424	<	tmNewMap()
424	>	tmNewMap( /* allocate new tone-mapping array */
425	>	TMstruct *tms
426	>	)
427		{
428	<	if (tmTop->lumap != NULL && (tmTop->mbrmax - tmTop->mbrmin) !=
429	<	(tmTop->hbrmax - tmTop->hbrmin)) {
430	<	free((MEM_PTR)tmTop->lumap);
431	<	tmTop->lumap = NULL;
428	>	if (tms->lumap != NULL && (tms->mbrmax - tms->mbrmin) !=
429	>	(tms->hbrmax - tms->hbrmin)) {
430	>	free((MEM_PTR)tms->lumap);
431	>	tms->lumap = NULL;
432		}
433	<	tmTop->mbrmin = tmTop->hbrmin;
434	<	tmTop->mbrmax = tmTop->hbrmax;
435	<	if (tmTop->mbrmin > tmTop->mbrmax)
433	>	tms->mbrmin = tms->hbrmin;
434	>	tms->mbrmax = tms->hbrmax;
435	>	if (tms->mbrmin > tms->mbrmax)
436		return 0;
437	<	if (tmTop->lumap == NULL)
438	<	tmTop->lumap = (unsigned short )malloc(sizeof(unsigned short)
439	<	(tmTop->mbrmax-tmTop->mbrmin+1));
440	<	return(tmTop->lumap != NULL);
437	>	if (tms->lumap == NULL)
438	>	tms->lumap = (unsigned short )malloc(sizeof(unsigned short)
439	>	(tms->mbrmax-tms->mbrmin+1));
440	>	return(tms->lumap != NULL);
441		}
442
443
444		int
445	<	tmFixedMapping(expmult, gamval)
446	<	double expmult;
447	<	double gamval;
445	>	tmFixedMapping( /* compute fixed, linear tone-mapping */
446	>	TMstruct *tms,
447	>	double expmult,
448	>	double gamval
449	>	)
450		{
451	<	static char funcName[] = "tmFixedMapping";
451	>	static const char funcName[] = "tmFixedMapping";
452		double d;
453	<	register int i;
453	>	int i;
454
455	<	if (!tmNewMap())
455	>	if (!tmNewMap(tms))
456		returnErr(TM_E_NOMEM);
457		if (expmult <= .0)
458		expmult = 1.;
459		if (gamval < MINGAM)
460	<	gamval = tmTop->mongam;
461	<	d = log(expmult/tmTop->inpsf);
462	<	for (i = tmTop->mbrmax-tmTop->mbrmin+1; i--; )
463	<	tmTop->lumap[i] = 256. * exp(
464	<	( d + (tmTop->mbrmin+i)*(1./TM_BRTSCALE) )
460	>	gamval = tms->mongam;
461	>	d = log(expmult/tms->inpsf);
462	>	for (i = tms->mbrmax-tms->mbrmin+1; i--; )
463	>	tms->lumap[i] = 256. * exp(
464	>	( d + (tms->mbrmin+i)*(1./TM_BRTSCALE) )
465		/ gamval );
466		returnOK;
467		}
468
469
470		int
471	<	tmComputeMapping(gamval, Lddyn, Ldmax)
472	<	double gamval;
473	<	double Lddyn;
474	<	double Ldmax;
471	>	tmComputeMapping( /* compute histogram tone-mapping */
472	>	TMstruct *tms,
473	>	double gamval,
474	>	double Lddyn,
475	>	double Ldmax
476	>	)
477		{
478	<	static char funcName[] = "tmComputeMapping";
478	>	static const char funcName[] = "tmComputeMapping";
479		int *histo;
480		float *cumf;
481		int brt0, histlen, threshold, ceiling, trimmings;
482		double logLddyn, Ldmin, Ldavg, Lwavg, Tr, Lw, Ld;
483	<	int4 histot;
483	>	int32 histot;
484		double sum;
485	<	register double d;
486	<	register int i, j;
485	>	double d;
486	>	int i, j;
487
488	<	if (tmTop == NULL \|\| tmTop->histo == NULL)
488	>	if (tms == NULL \|\| tms->histo == NULL)
489		returnErr(TM_E_TMINVAL);
490		/* check arguments */
491		if (Lddyn < MINLDDYN) Lddyn = DEFLDDYN;
492		if (Ldmax < MINLDMAX) Ldmax = DEFLDMAX;
493	<	if (gamval < MINGAM) gamval = tmTop->mongam;
493	>	if (gamval < MINGAM) gamval = tms->mongam;
494		/* compute handy values */
495		Ldmin = Ldmax/Lddyn;
496		logLddyn = log(Lddyn);
497		Ldavg = sqrt(Ldmax*Ldmin);
498	<	i = (tmTop->hbrmin-MINBRT)/HISTEP;
498	>	i = (tms->hbrmin-MINBRT)/HISTEP;
499		brt0 = MINBRT + HISTEP/2 + i*HISTEP;
500	<	histlen = (tmTop->hbrmax-MINBRT)/HISTEP + 1 - i;
500	>	histlen = (tms->hbrmax-MINBRT)/HISTEP + 1 - i;
501		/* histogram total and mean */
502		histot = 0; sum = 0;
503		j = brt0 + histlen*HISTEP;
504		for (i = histlen; i--; ) {
505	<	histot += tmTop->histo[i];
506	<	sum += (j -= HISTEP) * tmTop->histo[i];
505	>	histot += tms->histo[i];
506	>	sum += (j -= HISTEP) * tms->histo[i];
507		}
508	<	threshold = histot*.025 + .5;
508	>	threshold = histot*0.005 + .5;
509		if (threshold < 4)
510		returnErr(TM_E_TMFAIL);
511		Lwavg = tmLuminance( (double)sum / histot );
512		/* allocate space for mapping */
513	<	if (!tmNewMap())
513	>	if (!tmNewMap(tms))
514		returnErr(TM_E_NOMEM);
515		/* use linear tone mapping? */
516	<	if (tmTop->flags & TM_F_LINEAR)
516	>	if (tms->flags & TM_F_LINEAR)
517		goto linearmap;
518		/* clamp histogram */
519		histo = (int )malloc(histlensizeof(int));
520		cumf = (float )malloc((histlen+2)sizeof(float));
521	<	if (histo == NULL \| cumf == NULL)
521	>	if ((histo == NULL) \| (cumf == NULL))
522		returnErr(TM_E_NOMEM);
523		cumf[histlen+1] = 1.; /* guard for assignment code */
524		for (i = histlen; i--; ) /* make malleable copy */
525	<	histo[i] = tmTop->histo[i];
525	>	histo[i] = tms->histo[i];
526		do { /* iterate to solution */
527		sum = 0; /* cumulative probability */
528		for (i = 0; i < histlen; i++) {
#	Line 495 \| Line 530 \| double Ldmax;
530		sum += histo[i];
531		}
532		cumf[histlen] = 1.;
533	<	Tr = histot * (double)(tmTop->hbrmax - tmTop->hbrmin) /
533	>	Tr = histot * (double)(tms->hbrmax - tms->hbrmin) /
534		((double)histlen*TM_BRTSCALE) / logLddyn;
535		ceiling = Tr + 1.;
536		trimmings = 0; /* clip to envelope */
537		for (i = histlen; i--; ) {
538	<	if (tmTop->flags & TM_F_HCONTR) {
538	>	if (tms->flags & TM_F_HCONTR) {
539		Lw = tmLuminance(brt0 + i*HISTEP);
540		Ld = Ldmin * exp( logLddyn *
541		.5*(cumf[i]+cumf[i+1]) );
#	Line 520 \| Line 555 \| double Ldmax;
555		}
556		} while (trimmings > threshold);
557		/* assign tone-mapping */
558	<	for (i = tmTop->mbrmax-tmTop->mbrmin+1; i--; ) {
559	<	j = d = (double)i/(tmTop->mbrmax-tmTop->mbrmin)*histlen;
558	>	for (i = tms->mbrmax-tms->mbrmin+1; i--; ) {
559	>	j = d = (double)i/(tms->mbrmax-tms->mbrmin)*histlen;
560		d -= (double)j;
561		Ld = Ldminexp(logLddyn((1.-d)cumf[j]+dcumf[j+1]));
562		d = (Ld - Ldmin)/(Ldmax - Ldmin);
563	<	tmTop->lumap[i] = 256.*pow(d, 1./gamval);
563	>	tms->lumap[i] = 256.*pow(d, 1./gamval);
564		}
565		free((MEM_PTR)histo); /* clean up and return */
566		free((MEM_PTR)cumf);
567		returnOK;
568		linearmap: /* linear tone-mapping */
569	<	if (tmTop->flags & TM_F_HCONTR)
569	>	if (tms->flags & TM_F_HCONTR)
570		d = htcontrs(Ldavg) / htcontrs(Lwavg);
571		else
572		d = Ldavg / Lwavg;
573	<	return(tmFixedMapping(tmTop->inpsf*d/Ldmax, gamval));
573	>	return(tmFixedMapping(tms, tms->inpsf*d/Ldmax, gamval));
574		}
575
576
577		int
578	<	tmMapPixels(ps, ls, cs, len)
579	<	register BYTE *ps;
580	<	TMbright *ls;
581	<	register BYTE *cs;
582	<	int len;
578	>	tmMapPixels( /* apply tone-mapping to pixel(s) */
579	>	TMstruct *tms,
580	>	BYTE *ps,
581	>	TMbright *ls,
582	>	BYTE *cs,
583	>	int len
584	>	)
585		{
586	<	static char funcName[] = "tmMapPixels";
587	<	register int4 li, pv;
586	>	static const char funcName[] = "tmMapPixels";
587	>	int32 li, pv;
588
589	<	if (tmTop == NULL \|\| tmTop->lumap == NULL)
589	>	if (tms == NULL \|\| tms->lumap == NULL)
590		returnErr(TM_E_TMINVAL);
591	<	if (ps == NULL \| ls == NULL \| len < 0)
591	>	if ((ps == NULL) \| (ls == NULL) \| (len < 0))
592		returnErr(TM_E_ILLEGAL);
593		while (len--) {
594	<	if ((li = *ls++) < tmTop->mbrmin) {
594	>	if ((li = *ls++) < tms->mbrmin) {
595		li = 0;
596		} else {
597	<	if (li > tmTop->mbrmax)
598	<	li = tmTop->mbrmax;
599	<	li = tmTop->lumap[li - tmTop->mbrmin];
597	>	if (li > tms->mbrmax)
598	>	li = tms->mbrmax;
599	>	li = tms->lumap[li - tms->mbrmin];
600		}
601		if (cs == TM_NOCHROM)
602		*ps++ = li>255 ? 255 : li;
603		else {
604	<	pv = cs++ li / tmTop->cdiv[RED];
604	>	pv = cs++ li / tms->cdiv[RED];
605		*ps++ = pv>255 ? 255 : pv;
606	<	pv = cs++ li / tmTop->cdiv[GRN];
606	>	pv = cs++ li / tms->cdiv[GRN];
607		*ps++ = pv>255 ? 255 : pv;
608	<	pv = cs++ li / tmTop->cdiv[BLU];
608	>	pv = cs++ li / tms->cdiv[BLU];
609		*ps++ = pv>255 ? 255 : pv;
610		}
611		}
#	Line 576 \| Line 613 \| int len;
613		}
614
615
579	–	struct tmStruct *
580	–	tmPop() /* pop top tone mapping off stack */
581	–	{
582	–	register struct tmStruct *tms;
616
584	–	if ((tms = tmTop) != NULL)
585	–	tmTop = tms->tmprev;
586	–	return(tms);
587	–	}
617
618	<
619	<	int
620	<	tmPull(tms) /* pull a tone mapping from stack */
621	<	register struct tmStruct *tms;
618	>	TMstruct *
619	>	tmDup( /* duplicate top tone mapping */
620	>	TMstruct *tms
621	>	)
622		{
594	–	register struct tmStruct *tms2;
595	–	/* special cases first */
596	–	if (tms == NULL \| tmTop == NULL)
597	–	return(0);
598	–	if (tms == tmTop) {
599	–	tmTop = tms->tmprev;
600	–	tms->tmprev = NULL;
601	–	return(1);
602	–	}
603	–	for (tms2 = tmTop; tms2->tmprev != NULL; tms2 = tms2->tmprev)
604	–	if (tms == tms2->tmprev) { /* remove it */
605	–	tms2->tmprev = tms->tmprev;
606	–	tms->tmprev = NULL;
607	–	return(1);
608	–	}
609	–	return(0); /* not found on stack */
610	–	}
611	–
612	–
613	–	struct tmStruct *
614	–	tmDup() /* duplicate top tone mapping */
615	–	{
623		int len;
624	<	register int i;
625	<	register struct tmStruct *tmnew;
624	>	int i;
625	>	TMstruct *tmnew;
626
627	<	if (tmTop == NULL) /* anything to duplicate? */
627	>	if (tms == NULL) /* anything to duplicate? */
628		return(NULL);
629	<	tmnew = (struct tmStruct *)malloc(sizeof(struct tmStruct));
629	>	tmnew = (TMstruct *)malloc(sizeof(TMstruct));
630		if (tmnew == NULL)
631		return(NULL);
632	<	tmnew = tmTop; /* copy everything */
632	>	tmnew = tms; /* copy everything */
633		if (tmnew->histo != NULL) { /* duplicate histogram */
634		len = (tmnew->hbrmax-MINBRT)/HISTEP + 1 -
635		(tmnew->hbrmin-MINBRT)/HISTEP;
636		tmnew->histo = (int )malloc(lensizeof(int));
637		if (tmnew->histo != NULL)
638		for (i = len; i--; )
639	<	tmnew->histo[i] = tmTop->histo[i];
639	>	tmnew->histo[i] = tms->histo[i];
640		}
641		if (tmnew->lumap != NULL) { /* duplicate luminance mapping */
642		len = tmnew->mbrmax-tmnew->mbrmin+1;
#	Line 637 \| Line 644 \| *tmDup() / duplicate top tone mapping /*
644		len*sizeof(unsigned short) );
645		if (tmnew->lumap != NULL)
646		for (i = len; i--; )
647	<	tmnew->lumap[i] = tmTop->lumap[i];
647	>	tmnew->lumap[i] = tms->lumap[i];
648		}
649		/* clear package data */
650		for (i = tmNumPkgs; i--; )
651		tmnew->pd[i] = NULL;
652	<	tmnew->tmprev = tmTop; /* make copy current */
653	<	return(tmTop = tmnew);
652	>	/* return copy */
653	>	return(tmnew);
654		}
655
656
650	–	int
651	–	tmPush(tms) /* push tone mapping on top of stack */
652	–	register struct tmStruct *tms;
653	–	{
654	–	static char funcName[] = "tmPush";
655	–	/* check validity */
656	–	if (tms == NULL)
657	–	returnErr(TM_E_ILLEGAL);
658	–	if (tms == tmTop) /* check necessity */
659	–	returnOK;
660	–	/* pull if already in stack */
661	–	(void)tmPull(tms);
662	–	/* push it on top */
663	–	tms->tmprev = tmTop;
664	–	tmTop = tms;
665	–	returnOK;
666	–	}
667	–
668	–
657		void
658		tmDone(tms) /* done with tone mapping -- destroy it */
659	<	register struct tmStruct *tms;
659	>	TMstruct *tms;
660		{
661	<	register int i;
662	<	/* NULL arg. is equiv. to tmTop */
663	<	if (tms == NULL && (tms = tmTop) == NULL)
661	>	int i;
662	>	/* NULL arg. is equiv. to tms */
663	>	if (tms == NULL)
664		return;
677	–	/* take out of stack if present */
678	–	(void)tmPull(tms);
665		/* free tables */
666		if (tms->histo != NULL)
667		free((MEM_PTR)tms->histo);
#	Line 695 \| Line 681 \| BYTE tmMesofact[BMESUPPER-BMESLOWER];
681		void
682		tmMkMesofact() /* build mesopic lookup factor table */
683		{
684	<	register int i;
684	>	int i;
685
686		if (tmMesofact[BMESUPPER-BMESLOWER-1])
687		return;
#	Line 708 \| Line 694 \| *tmMkMesofact() / build mesopic lookup factor table**
694
695
696		int
697	<	tmErrorReturn(func, err) /* error return (with message) */
698	<	char *func;
699	<	int err;
697	>	tmErrorReturn( /* error return (with message) */
698	>	const char *func,
699	>	TMstruct *tms,
700	>	int err
701	>	)
702		{
703	<	tmLastFunction = func;
704	<	tmLastError = err;
705	<	if (tmTop != NULL && tmTop->flags & TM_F_NOSTDERR)
706	<	return(err);
703	>	if (tms != NULL) {
704	>	tms->lastFunc = func;
705	>	tms->lastError = err;
706	>	if (tms->flags & TM_F_NOSTDERR)
707	>	return(err);
708	>	}
709		fputs(func, stderr);
710		fputs(": ", stderr);
711		fputs(tmErrorMessage[err], stderr);

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing ray/src/common/tonemap.c (file contents): Revision 3.9 by greg, Sat Feb 22 02:07:22 2003 UTC vs. Revision 3.25 by greg, Thu May 11 00:58:48 2006 UTC

Diff Legend

Comparing ray/src/common/tonemap.c (file contents):
Revision 3.9 by greg, Sat Feb 22 02:07:22 2003 UTC vs.
Revision 3.25 by greg, Thu May 11 00:58:48 2006 UTC