src/common/colrops.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 * Integer operations on COLR scanlines
 */

/* ====================================================================
 * The Radiance Software License, Version 1.0
 *
 * Copyright (c) 1990 - 2002 The Regents of the University of California,
 * through Lawrence Berkeley National Laboratory.   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *         notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *
 * 3. The end-user documentation included with the redistribution,
 *           if any, must include the following acknowledgment:
 *             "This product includes Radiance software
 *                 (http://radsite.lbl.gov/)
 *                 developed by the Lawrence Berkeley National Laboratory
 *               (http://www.lbl.gov/)."
 *       Alternately, this acknowledgment may appear in the software itself,
 *       if and wherever such third-party acknowledgments normally appear.
 *
 * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
 *       and "The Regents of the University of California" must
 *       not be used to endorse or promote products derived from this
 *       software without prior written permission. For written
 *       permission, please contact [email protected].
 *
 * 5. Products derived from this software may not be called "Radiance",
 *       nor may "Radiance" appear in their name, without prior written
 *       permission of Lawrence Berkeley National Laboratory.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
 * information on Lawrence Berkeley National Laboratory, please see
 * <http://www.lbl.gov/>.
 */

#include <math.h>
#include "color.h"

#define NULL            0

extern char     *bmalloc();

#define MAXGSHIFT       31              /* maximum shift for gamma table */

static BYTE     *g_mant = NULL, *g_nexp = NULL;

static BYTE     (*g_bval)[256] = NULL;


int
setcolrcor(f, a2)               /* set brightness correction */
double  (*f)();
double  a2;
{
        double  mult;
        register int    i, j;
                                        /* allocate tables */
        if (g_bval == NULL && (g_bval =
                        (BYTE (*)[256])bmalloc((MAXGSHIFT+1)*256)) == NULL)
                return(-1);
                                        /* compute colr -> gamb mapping */
        mult = 1.0/256.0;
        for (i = 0; i <= MAXGSHIFT; i++) {
                for (j = 0; j < 256; j++)
                        g_bval[i][j] = 256.0 * (*f)((j+.5)*mult, a2);
                mult *= 0.5;
        }
        return(0);
}


int
setcolrinv(f, a2)               /* set inverse brightness correction */
double  (*f)();
double  a2;
{
        double  mult;
        register int    i, j;
                                        /* allocate tables */
        if (g_mant == NULL && (g_mant = (BYTE *)bmalloc(256)) == NULL)
                return(-1);
        if (g_nexp == NULL && (g_nexp = (BYTE *)bmalloc(256)) == NULL)
                return(-1);
                                        /* compute gamb -> colr mapping */
        i = 0;
        mult = 256.0;
        for (j = 256; j--; ) {
                while ((g_mant[j] = mult * (*f)((j+.5)/256.0, a2)) < 128) {
                        i++;
                        mult *= 2.0;
                }
                g_nexp[j] = i;
        }
        return(0);
}


int
setcolrgam(g)                   /* set gamma conversion */
double  g;
{
        if (setcolrcor(pow, 1.0/g) < 0)
                return(-1);
        return(setcolrinv(pow, g));
}


int
colrs_gambs(scan, len)          /* convert scanline of colrs to gamma bytes */
register COLR   *scan;
int     len;
{
        register int    i, expo;

        if (g_bval == NULL)
                return(-1);
        while (len-- > 0) {
                expo = scan[0][EXP] - COLXS;
                if (expo < -MAXGSHIFT) {
                        if (expo < -MAXGSHIFT-8) {
                                scan[0][RED] =
                                scan[0][GRN] =
                                scan[0][BLU] = 0;
                        } else {
                                i = (-MAXGSHIFT-1) - expo;
                                scan[0][RED] = 
                                g_bval[MAXGSHIFT][((scan[0][RED]>>i)+1)>>1];
                                scan[0][GRN] =
                                g_bval[MAXGSHIFT][((scan[0][GRN]>>i)+1)>>1];
                                scan[0][BLU] =
                                g_bval[MAXGSHIFT][((scan[0][BLU]>>i)+1)>>1];
                        }
                } else if (expo > 0) {
                        if (expo > 8) {
                                scan[0][RED] =
                                scan[0][GRN] =
                                scan[0][BLU] = 255;
                        } else {
                                i = (scan[0][RED]<<1 | 1) << (expo-1);
                                scan[0][RED] = i > 255 ? 255 : g_bval[0][i];
                                i = (scan[0][GRN]<<1 | 1) << (expo-1);
                                scan[0][GRN] = i > 255 ? 255 : g_bval[0][i];
                                i = (scan[0][BLU]<<1 | 1) << (expo-1);
                                scan[0][BLU] = i > 255 ? 255 : g_bval[0][i];
                        }
                } else {
                        scan[0][RED] = g_bval[-expo][scan[0][RED]];
                        scan[0][GRN] = g_bval[-expo][scan[0][GRN]];
                        scan[0][BLU] = g_bval[-expo][scan[0][BLU]];
                }
                scan[0][EXP] = COLXS;
                scan++;
        }
        return(0);
}


int
gambs_colrs(scan, len)          /* convert gamma bytes to colr scanline */
register COLR   *scan;
int     len;
{
        register int    nexpo;

        if (g_mant == NULL | g_nexp == NULL)
                return(-1);
        while (len-- > 0) {
                nexpo = g_nexp[scan[0][RED]];
                if (g_nexp[scan[0][GRN]] < nexpo)
                        nexpo = g_nexp[scan[0][GRN]];
                if (g_nexp[scan[0][BLU]] < nexpo)
                        nexpo = g_nexp[scan[0][BLU]];
                if (nexpo < g_nexp[scan[0][RED]])
                        scan[0][RED] = g_mant[scan[0][RED]]
                                        >> (g_nexp[scan[0][RED]]-nexpo);
                else
                        scan[0][RED] = g_mant[scan[0][RED]];
                if (nexpo < g_nexp[scan[0][GRN]])
                        scan[0][GRN] = g_mant[scan[0][GRN]]
                                        >> (g_nexp[scan[0][GRN]]-nexpo);
                else
                        scan[0][GRN] = g_mant[scan[0][GRN]];
                if (nexpo < g_nexp[scan[0][BLU]])
                        scan[0][BLU] = g_mant[scan[0][BLU]]
                                        >> (g_nexp[scan[0][BLU]]-nexpo);
                else
                        scan[0][BLU] = g_mant[scan[0][BLU]];
                scan[0][EXP] = COLXS - nexpo;
                scan++;
        }
        return(0);
}


void
shiftcolrs(scan, len, adjust)   /* shift a scanline of colors by 2^adjust */
register COLR   *scan;
register int    len;
register int    adjust;
{
        int     minexp;

        if (adjust == 0)
                return;
        minexp = adjust < 0 ? -adjust : 0;
        while (len-- > 0) {
                if (scan[0][EXP] <= minexp)
                        scan[0][RED] = scan[0][GRN] = scan[0][BLU] =
                        scan[0][EXP] = 0;
                else
                        scan[0][EXP] += adjust;
                scan++;
        }
}


void
normcolrs(scan, len, adjust)    /* normalize a scanline of colrs */
register COLR  *scan;
int  len;
int  adjust;
{
        register int  c;
        register int  shift;

        while (len-- > 0) {
                shift = scan[0][EXP] + adjust - COLXS;
                if (shift > 0) {
                        if (shift > 8) {
                                scan[0][RED] =
                                scan[0][GRN] =
                                scan[0][BLU] = 255;
                        } else {
                                shift--;
                                c = (scan[0][RED]<<1 | 1) << shift;
                                scan[0][RED] = c > 255 ? 255 : c;
                                c = (scan[0][GRN]<<1 | 1) << shift;
                                scan[0][GRN] = c > 255 ? 255 : c;
                                c = (scan[0][BLU]<<1 | 1) << shift;
                                scan[0][BLU] = c > 255 ? 255 : c;
                        }
                } else if (shift < 0) {
                        if (shift < -8) {
                                scan[0][RED] =
                                scan[0][GRN] =
                                scan[0][BLU] = 0;
                        } else {
                                shift = -1-shift;
                                scan[0][RED] = ((scan[0][RED]>>shift)+1)>>1;
                                scan[0][GRN] = ((scan[0][GRN]>>shift)+1)>>1;
                                scan[0][BLU] = ((scan[0][BLU]>>shift)+1)>>1;
                        }
                }
                scan[0][EXP] = COLXS - adjust;
                scan++;
        }
}
Revision:	2.6
Committed:	Sat Feb 22 02:07:22 2003 UTC (21 years, 2 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.5:	+66 -8 lines
Log Message:	Changes and check-in for 3.5 release Includes new source files and modifications not recorded for many years See ray/doc/notes/ReleaseNotes for notes between 3.1 and 3.5 release
#	Content
1	#ifndef lint
2	static const char RCSid[] = "$Id$";
3	#endif
4	/*
5	* Integer operations on COLR scanlines
6	*/
7
8	/* ====================================================================
9	* The Radiance Software License, Version 1.0
10	*
11	* Copyright (c) 1990 - 2002 The Regents of the University of California,
12	* through Lawrence Berkeley National Laboratory. All rights reserved.
13	*
14	* Redistribution and use in source and binary forms, with or without
15	* modification, are permitted provided that the following conditions
16	* are met:
17	*
18	* 1. Redistributions of source code must retain the above copyright
19	* notice, this list of conditions and the following disclaimer.
20	*
21	* 2. Redistributions in binary form must reproduce the above copyright
22	* notice, this list of conditions and the following disclaimer in
23	* the documentation and/or other materials provided with the
24	* distribution.
25	*
26	* 3. The end-user documentation included with the redistribution,
27	* if any, must include the following acknowledgment:
28	* "This product includes Radiance software
29	* (http://radsite.lbl.gov/)
30	* developed by the Lawrence Berkeley National Laboratory
31	* (http://www.lbl.gov/)."
32	* Alternately, this acknowledgment may appear in the software itself,
33	* if and wherever such third-party acknowledgments normally appear.
34	*
35	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
36	* and "The Regents of the University of California" must
37	* not be used to endorse or promote products derived from this
38	* software without prior written permission. For written
39	* permission, please contact [email protected].
40	*
41	* 5. Products derived from this software may not be called "Radiance",
42	* nor may "Radiance" appear in their name, without prior written
43	* permission of Lawrence Berkeley National Laboratory.
44	*
45	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
46	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48	* DISCLAIMED. IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
49	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
51	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
52	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
53	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
54	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
55	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56	* SUCH DAMAGE.
57	* ====================================================================
58	*
59	* This software consists of voluntary contributions made by many
60	* individuals on behalf of Lawrence Berkeley National Laboratory. For more
61	* information on Lawrence Berkeley National Laboratory, please see
62	* <http://www.lbl.gov/>.
63	*/
64
65	#include <math.h>
66	#include "color.h"
67
68	#define NULL 0
69
70	extern char *bmalloc();
71
72	#define MAXGSHIFT 31 /* maximum shift for gamma table */
73
74	static BYTE g_mant = NULL, g_nexp = NULL;
75
76	static BYTE (*g_bval)[256] = NULL;
77
78
79	int
80	setcolrcor(f, a2) /* set brightness correction */
81	double (*f)();
82	double a2;
83	{
84	double mult;
85	register int i, j;
86	/* allocate tables */
87	if (g_bval == NULL && (g_bval =
88	(BYTE ()[256])bmalloc((MAXGSHIFT+1)256)) == NULL)
89	return(-1);
90	/* compute colr -> gamb mapping */
91	mult = 1.0/256.0;
92	for (i = 0; i <= MAXGSHIFT; i++) {
93	for (j = 0; j < 256; j++)
94	g_bval[i][j] = 256.0 * (f)((j+.5)mult, a2);
95	mult *= 0.5;
96	}
97	return(0);
98	}
99
100
101	int
102	setcolrinv(f, a2) /* set inverse brightness correction */
103	double (*f)();
104	double a2;
105	{
106	double mult;
107	register int i, j;
108	/* allocate tables */
109	if (g_mant == NULL && (g_mant = (BYTE *)bmalloc(256)) == NULL)
110	return(-1);
111	if (g_nexp == NULL && (g_nexp = (BYTE *)bmalloc(256)) == NULL)
112	return(-1);
113	/* compute gamb -> colr mapping */
114	i = 0;
115	mult = 256.0;
116	for (j = 256; j--; ) {
117	while ((g_mant[j] = mult * (*f)((j+.5)/256.0, a2)) < 128) {
118	i++;
119	mult *= 2.0;
120	}
121	g_nexp[j] = i;
122	}
123	return(0);
124	}
125
126
127	int
128	setcolrgam(g) /* set gamma conversion */
129	double g;
130	{
131	if (setcolrcor(pow, 1.0/g) < 0)
132	return(-1);
133	return(setcolrinv(pow, g));
134	}
135
136
137	int
138	colrs_gambs(scan, len) /* convert scanline of colrs to gamma bytes */
139	register COLR *scan;
140	int len;
141	{
142	register int i, expo;
143
144	if (g_bval == NULL)
145	return(-1);
146	while (len-- > 0) {
147	expo = scan[0][EXP] - COLXS;
148	if (expo < -MAXGSHIFT) {
149	if (expo < -MAXGSHIFT-8) {
150	scan[0][RED] =
151	scan[0][GRN] =
152	scan[0][BLU] = 0;
153	} else {
154	i = (-MAXGSHIFT-1) - expo;
155	scan[0][RED] =
156	g_bval[MAXGSHIFT][((scan[0][RED]>>i)+1)>>1];
157	scan[0][GRN] =
158	g_bval[MAXGSHIFT][((scan[0][GRN]>>i)+1)>>1];
159	scan[0][BLU] =
160	g_bval[MAXGSHIFT][((scan[0][BLU]>>i)+1)>>1];
161	}
162	} else if (expo > 0) {
163	if (expo > 8) {
164	scan[0][RED] =
165	scan[0][GRN] =
166	scan[0][BLU] = 255;
167	} else {
168	i = (scan[0][RED]<<1 \| 1) << (expo-1);
169	scan[0][RED] = i > 255 ? 255 : g_bval[0][i];
170	i = (scan[0][GRN]<<1 \| 1) << (expo-1);
171	scan[0][GRN] = i > 255 ? 255 : g_bval[0][i];
172	i = (scan[0][BLU]<<1 \| 1) << (expo-1);
173	scan[0][BLU] = i > 255 ? 255 : g_bval[0][i];
174	}
175	} else {
176	scan[0][RED] = g_bval[-expo][scan[0][RED]];
177	scan[0][GRN] = g_bval[-expo][scan[0][GRN]];
178	scan[0][BLU] = g_bval[-expo][scan[0][BLU]];
179	}
180	scan[0][EXP] = COLXS;
181	scan++;
182	}
183	return(0);
184	}
185
186
187	int
188	gambs_colrs(scan, len) /* convert gamma bytes to colr scanline */
189	register COLR *scan;
190	int len;
191	{
192	register int nexpo;
193
194	if (g_mant == NULL \| g_nexp == NULL)
195	return(-1);
196	while (len-- > 0) {
197	nexpo = g_nexp[scan[0][RED]];
198	if (g_nexp[scan[0][GRN]] < nexpo)
199	nexpo = g_nexp[scan[0][GRN]];
200	if (g_nexp[scan[0][BLU]] < nexpo)
201	nexpo = g_nexp[scan[0][BLU]];
202	if (nexpo < g_nexp[scan[0][RED]])
203	scan[0][RED] = g_mant[scan[0][RED]]
204	>> (g_nexp[scan[0][RED]]-nexpo);
205	else
206	scan[0][RED] = g_mant[scan[0][RED]];
207	if (nexpo < g_nexp[scan[0][GRN]])
208	scan[0][GRN] = g_mant[scan[0][GRN]]
209	>> (g_nexp[scan[0][GRN]]-nexpo);
210	else
211	scan[0][GRN] = g_mant[scan[0][GRN]];
212	if (nexpo < g_nexp[scan[0][BLU]])
213	scan[0][BLU] = g_mant[scan[0][BLU]]
214	>> (g_nexp[scan[0][BLU]]-nexpo);
215	else
216	scan[0][BLU] = g_mant[scan[0][BLU]];
217	scan[0][EXP] = COLXS - nexpo;
218	scan++;
219	}
220	return(0);
221	}
222
223
224	void
225	shiftcolrs(scan, len, adjust) /* shift a scanline of colors by 2^adjust */
226	register COLR *scan;
227	register int len;
228	register int adjust;
229	{
230	int minexp;
231
232	if (adjust == 0)
233	return;
234	minexp = adjust < 0 ? -adjust : 0;
235	while (len-- > 0) {
236	if (scan[0][EXP] <= minexp)
237	scan[0][RED] = scan[0][GRN] = scan[0][BLU] =
238	scan[0][EXP] = 0;
239	else
240	scan[0][EXP] += adjust;
241	scan++;
242	}
243	}
244
245
246	void
247	normcolrs(scan, len, adjust) /* normalize a scanline of colrs */
248	register COLR *scan;
249	int len;
250	int adjust;
251	{
252	register int c;
253	register int shift;
254
255	while (len-- > 0) {
256	shift = scan[0][EXP] + adjust - COLXS;
257	if (shift > 0) {
258	if (shift > 8) {
259	scan[0][RED] =
260	scan[0][GRN] =
261	scan[0][BLU] = 255;
262	} else {
263	shift--;
264	c = (scan[0][RED]<<1 \| 1) << shift;
265	scan[0][RED] = c > 255 ? 255 : c;
266	c = (scan[0][GRN]<<1 \| 1) << shift;
267	scan[0][GRN] = c > 255 ? 255 : c;
268	c = (scan[0][BLU]<<1 \| 1) << shift;
269	scan[0][BLU] = c > 255 ? 255 : c;
270	}
271	} else if (shift < 0) {
272	if (shift < -8) {
273	scan[0][RED] =
274	scan[0][GRN] =
275	scan[0][BLU] = 0;
276	} else {
277	shift = -1-shift;
278	scan[0][RED] = ((scan[0][RED]>>shift)+1)>>1;
279	scan[0][GRN] = ((scan[0][GRN]>>shift)+1)>>1;
280	scan[0][BLU] = ((scan[0][BLU]>>shift)+1)>>1;
281	}
282	}
283	scan[0][EXP] = COLXS - adjust;
284	scan++;
285	}
286	}