ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/src/common/colrops.c
(Generate patch)

Comparing src/common/colrops.c (file contents):
Revision 2.1 by greg, Tue Nov 12 16:55:43 1991 UTC vs.
Revision 2.6 by greg, Sat Feb 22 02:07:22 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1990 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   * 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 MAXGSHIFT       15              /* maximum shift for gamma table */
68 > #define NULL            0
69  
70 < static BYTE     g_mant[256], g_nexp[256];
70 > extern char     *bmalloc();
71  
72 < static BYTE     g_bval[MAXGSHIFT+1][256];
72 > #define MAXGSHIFT       31              /* maximum shift for gamma table */
73  
74 + static BYTE     *g_mant = NULL, *g_nexp = NULL;
75  
76 < setcolrgam(g)                   /* set gamma conversion */
77 < double  g;
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   {
23 –        extern double   pow();
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++) {
28 –                mult = pow(0.5, (double)(i+8));
93                  for (j = 0; j < 256; j++)
94 <                        g_bval[i][j] = 256.0 * pow((j+.5)*mult, 1.0/g);
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 = 255; j > 0; j--) {
117 <                while ((g_mant[j] = mult * pow(j/256.0, g)) < 128) {
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 <        g_mant[0] = 0;
43 <        g_nexp[0] = COLXS;
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) {
# Line 87 | Line 180 | int    len;
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)
# Line 120 | Line 217 | int    len;
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 <                scan[0][EXP] += adjust;
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;

Diff Legend

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