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

Comparing ray/src/common/tmapluv.c (file contents):
Revision 3.3 by gwlarson, Sun Dec 20 16:38:29 1998 UTC vs.
Revision 3.4 by greg, Sat Feb 22 02:07:22 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1998 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Routines for tone-mapping LogLuv encoded pixels.
6 + *
7 + * Externals declared in tmaptiff.h
8   */
9  
10 + /* ====================================================================
11 + * The Radiance Software License, Version 1.0
12 + *
13 + * Copyright (c) 1990 - 2002 The Regents of the University of California,
14 + * through Lawrence Berkeley National Laboratory.   All rights reserved.
15 + *
16 + * Redistribution and use in source and binary forms, with or without
17 + * modification, are permitted provided that the following conditions
18 + * are met:
19 + *
20 + * 1. Redistributions of source code must retain the above copyright
21 + *         notice, this list of conditions and the following disclaimer.
22 + *
23 + * 2. Redistributions in binary form must reproduce the above copyright
24 + *       notice, this list of conditions and the following disclaimer in
25 + *       the documentation and/or other materials provided with the
26 + *       distribution.
27 + *
28 + * 3. The end-user documentation included with the redistribution,
29 + *           if any, must include the following acknowledgment:
30 + *             "This product includes Radiance software
31 + *                 (http://radsite.lbl.gov/)
32 + *                 developed by the Lawrence Berkeley National Laboratory
33 + *               (http://www.lbl.gov/)."
34 + *       Alternately, this acknowledgment may appear in the software itself,
35 + *       if and wherever such third-party acknowledgments normally appear.
36 + *
37 + * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
38 + *       and "The Regents of the University of California" must
39 + *       not be used to endorse or promote products derived from this
40 + *       software without prior written permission. For written
41 + *       permission, please contact [email protected].
42 + *
43 + * 5. Products derived from this software may not be called "Radiance",
44 + *       nor may "Radiance" appear in their name, without prior written
45 + *       permission of Lawrence Berkeley National Laboratory.
46 + *
47 + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
48 + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49 + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
50 + * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
51 + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
52 + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
53 + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
54 + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
55 + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
56 + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
57 + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 + * SUCH DAMAGE.
59 + * ====================================================================
60 + *
61 + * This software consists of voluntary contributions made by many
62 + * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
63 + * information on Lawrence Berkeley National Laboratory, please see
64 + * <http://www.lbl.gov/>.
65 + */
66 +
67 + #define LOGLUV_PUBLIC           1
68 +
69   #include <stdio.h>
70 + #include <string.h>
71   #include <math.h>
72   #include "tiffio.h"
73   #include "tmprivat.h"
74 < #include "uvcode.h"
74 > #include "tmaptiff.h"
75  
76   #ifndef BSD
77   #define bzero(d,n)              (void)memset(d,0,n)
# Line 23 | Line 82 | static char SCCSid[] = "$SunId$ SGI";
82   #define clruv(p,uv)             uvflgop(p,uv,&=~)
83   #define clruvall(p)             bzero((MEM_PTR)(p)->rgbflg,sizeof((p)->rgbflg))
84  
85 < #define U_NEU                   0.210526316
27 < #define V_NEU                   0.473684211
28 <
85 > #ifdef NOPROTO
86   static MEM_PTR  luv32Init();
87   static void     luv32NewSpace();
88   static MEM_PTR  luv24Init();
89   static void     luv24NewSpace();
90 < extern void     free();
90 > #else
91 > static MEM_PTR  luv32Init(struct tmStruct *);
92 > static void     luv32NewSpace(struct tmStruct *);
93 > static MEM_PTR  luv24Init(struct tmStruct *);
94 > static void     luv24NewSpace(struct tmStruct *);
95 > #endif
96  
97   typedef struct {
98          int     offset;                 /* computed luminance offset */
# Line 38 | Line 100 | typedef struct {
100          uint32  rgbflg[1<<(16-5)];      /* flags for computed values */
101   } LUV32DATA;                    /* LogLuv 32-bit conversion data */
102  
41 – #define UVSCALE                 410.
103   #define UVNEU                   ((int)(UVSCALE*U_NEU)<<8 \
104                                          | (int)(UVSCALE*V_NEU))
105  
# Line 61 | Line 122 | static int     luv24Reg = -1;          /* 24-bit package reg. numb
122   static int      uv14neu = -1;           /* neutral index for 14-bit (u',v') */
123  
124  
125 < static
125 > static void
126   uv2rgb(rgb, tm, uvp)                    /* compute RGB from uv coordinate */
127   BYTE    rgb[3];
128   register struct tmStruct        *tm;
# Line 78 | Line 139 | double uvp[2];
139          XYZ[CIEZ] = (1.-x-y)/y * XYZ[CIEY];
140                                          /* convert to RGB and clip */
141          colortrans(RGB, tm->cmat, XYZ);
142 <        clipgamut(RGB, XYZ[CIEY], CGAMUT_LOWER, cblack, cwhite);
142 >        clipgamut(RGB, 1., CGAMUT_LOWER, cblack, cwhite);
143                                          /* perform final scaling & gamma */
144          d = tm->clf[RED] * RGB[RED];
145          rgb[RED] = d>=.999 ? 255 : (int)(256.*pow(d, 1./tm->mongam));
# Line 94 | Line 155 | compmeshift(li, uvp)                   /* compute mesopic color shift
155   TMbright        li;             /* encoded world luminance */
156   double  uvp[2];                 /* world (u',v') -> returned desaturated */
157   {
158 <        double  scotrat, d;
158 >        double  scotrat;
159 >        register double d;
160  
161          if (li >= BMESUPPER)
162                  return(li);
163 <        scotrat = 1.33/9.*(6.*uvp[0]-16.*uvp[1]+12.)/uvp[0] - 1.68;
163 >        scotrat = (.767676768 - 1.02356902*uvp[1])/uvp[0] - .343434343;
164          if (li <= BMESLOWER) {
165                  d = 0.;
166                  uvp[0] = U_NEU; uvp[1] = V_NEU;
167          } else {
168 <                d = (tmLuminance(li) - LMESLOWER)/(LMESUPPER - LMESLOWER);
168 >                d = (tmMesofact[li-BMESLOWER] + .5) * (1./256.);
169                  uvp[0] = d*uvp[0] + (1.-d)*U_NEU;
170                  uvp[1] = d*uvp[1] + (1.-d)*V_NEU;
171          }
172 <        d = li + (double)TM_BRTSCALE*log(d + (1.-d)*scotrat/2.26);
173 <        return((TMbright)(d+.5));
172 >        /*
173 >        d = li + (double)TM_BRTSCALE*log(d + (1.-d)*scotrat);
174 >        */
175 >        d = d + (1.-d)*scotrat;
176 >        d -= 1.;                        /* Taylor expansion of log(x) about 1 */
177 >        d = d*(1. + d*(-.5 + d*(1./3. + d*-.125)));
178 >        d = li + (double)TM_BRTSCALE*d;
179 >        return((TMbright)(d>0. ? d+.5 : d-.5));
180   }
181  
182  
115 – static int
116 – uvpencode(uvp)                  /* encode (u',v') coordinates */
117 – double  uvp[2];
118 – {
119 –        register int    vi, ui;
120 –
121 –        if (uvp[1] < UV_VSTART)
122 –                return(-1);
123 –        vi = (uvp[1] - UV_VSTART)*(1./UV_SQSIZ);
124 –        if (vi >= UV_NVS)
125 –                return(-1);
126 –        if (uvp[0] < uv_row[vi].ustart)
127 –                return(-1);
128 –        ui = (uvp[0] - uv_row[vi].ustart)*(1./UV_SQSIZ);
129 –        if (ui >= uv_row[vi].nus)
130 –                return(-1);
131 –        return(uv_row[vi].ncum + ui);
132 – }
133 –
134 –
135 – static int
136 – uvpdecode(uvp, c)               /* decode (u',v') index */
137 – double  uvp[2];
138 – int     c;
139 – {
140 –        int     upper, lower;
141 –        register int    ui, vi;
142 –
143 –        if (c < 0 || c >= UV_NDIVS)
144 –                return(-1);
145 –        lower = 0;                      /* binary search */
146 –        upper = UV_NVS;
147 –        do {
148 –                vi = (lower + upper) >> 1;
149 –                ui = c - uv_row[vi].ncum;
150 –                if (ui > 0)
151 –                        lower = vi;
152 –                else if (ui < 0)
153 –                        upper = vi;
154 –                else
155 –                        break;
156 –        } while (upper - lower > 1);
157 –        vi = lower;
158 –        ui = c - uv_row[vi].ncum;
159 –        uvp[0] = uv_row[vi].ustart + (ui+.5)*UV_SQSIZ;
160 –        uvp[1] = UV_VSTART + (vi+.5)*UV_SQSIZ;
161 –        return(0);
162 – }
163 –
164 –
183   int
184   tmCvLuv32(ls, cs, luvs, len)            /* convert raw 32-bit LogLuv values */
185   TMbright        *ls;
# Line 179 | Line 197 | int    len;
197          if (ls == NULL | luvs == NULL | len < 0)
198                  returnErr(TM_E_ILLEGAL);
199                                          /* check package registration */
200 <        if (luv32Reg < 0 && (luv32Reg = tmRegPkg(&luv32Pkg)) < 0)
201 <                returnErr(TM_E_CODERR1);
200 >        if (luv32Reg < 0) {
201 >                if ((luv32Reg = tmRegPkg(&luv32Pkg)) < 0)
202 >                        returnErr(TM_E_CODERR1);
203 >                tmMkMesofact();
204 >        }
205                                          /* get package data */
206          if ((ld = (LUV32DATA *)tmPkgData(tmTop,luv32Reg)) == NULL)
207                  returnErr(TM_E_NOMEM);
# Line 190 | Line 211 | int    len;
211                  if (j & 0x8000)                 /* negative luminance */
212                          ls[i] = TM_NOBRT;       /* assign bogus value */
213                  else                            /* else convert to lnL */
214 <                        ls[i] = (BRT2SCALE*j >> 8) - ld->offset;
214 >                        ls[i] = (BRT2SCALE(j) >> 8) - ld->offset;
215                  if (cs == TM_NOCHROM)           /* no color? */
216                          continue;
217                                                  /* get chrominance */
# Line 206 | Line 227 | int    len;
227                          j = tmTop->flags&TM_F_BW ? UVNEU : luvs[i]&0xffff;
228                  }
229                  if (!isuvset(ld, j)) {
230 <                        uvp[0] = 1./UVSCALE*((luvs[i]>>8 & 0xff) + .5);
231 <                        uvp[1] = 1./UVSCALE*((luvs[i] & 0xff) + .5);
230 >                        uvp[0] = 1./UVSCALE*((j>>8) + .5);
231 >                        uvp[1] = 1./UVSCALE*((j & 0xff) + .5);
232                          uv2rgb(ld->rgbval[j], tmTop, uvp);
233                          setuv(ld, j);
234                  }
# Line 236 | Line 257 | int    len;
257          if (ls == NULL | luvs == NULL | len < 0)
258                  returnErr(TM_E_ILLEGAL);
259                                          /* check package registration */
260 <        if (luv24Reg < 0 && (luv24Reg = tmRegPkg(&luv24Pkg)) < 0)
261 <                returnErr(TM_E_CODERR1);
260 >        if (luv24Reg < 0) {
261 >                if ((luv24Reg = tmRegPkg(&luv24Pkg)) < 0)
262 >                        returnErr(TM_E_CODERR1);
263 >                tmMkMesofact();
264 >        }
265                                          /* get package data */
266          if ((ld = (LUV24DATA *)tmPkgData(tmTop,luv24Reg)) == NULL)
267                  returnErr(TM_E_NOMEM);
268                                          /* convert each pixel */
269          for (i = len; i--; ) {
270                  j = luvs[i] >> 14;              /* get luminance */
271 <                ls[i] = (BRT2SCALE*j >> 6) - ld->offset;
271 >                ls[i] = (BRT2SCALE(j) >> 6) - ld->offset;
272                  if (cs == TM_NOCHROM)           /* no color? */
273                          continue;
274                                                  /* get chrominance */
275                  if (tmTop->flags & TM_F_MESOPIC && ls[i] < BMESUPPER) {
276 <                        if (uvpdecode(uvp, luvs[i]&0x3fff) < 0) {
276 >                        if (uv_decode(uvp, uvp+1, luvs[i]&0x3fff) < 0) {
277                                  uvp[0] = U_NEU;         /* should barf? */
278                                  uvp[1] = V_NEU;
279                          }
280                          ls[i] = compmeshift(ls[i], uvp);
281                          if (tmTop->flags&TM_F_BW || ls[i]<BMESLOWER
282 <                                        || (j = uvpencode(uvp)) < 0)
282 >                                        || (j = uv_encode(uvp[0], uvp[1],
283 >                                                SGILOGENCODE_NODITHER)) < 0)
284                                  j = uv14neu;
285                  } else {
286                          j = tmTop->flags&TM_F_BW ? uv14neu : luvs[i]&0x3fff;
287                  }
288                  if (!isuvset(ld, j)) {
289 <                        if (uvpdecode(uvp, j) < 0) {
289 >                        if (uv_decode(&uvp[0], &uvp[1], j) < 0) {
290                                  uvp[0] = U_NEU; uvp[1] = V_NEU;
291                          }
292                          uv2rgb(ld->rgbval[j], tmTop, uvp);
# Line 292 | Line 317 | int    len;
317                  returnErr(TM_E_ILLEGAL);
318                                          /* check scaling offset */
319          if (!FEQ(tmTop->inpsf, lastsf)) {
320 <                offset = BRT2SCALE*64;
320 >                offset = BRT2SCALE(64);
321                  if (tmTop->inpsf > 1.0001)
322                          offset -= (int)(TM_BRTSCALE*log(tmTop->inpsf)+.5);
323                  else if (tmTop->inpsf < 0.9999)
# Line 304 | Line 329 | int    len;
329                  if (l16s[i] & 0x8000)           /* negative luminance */
330                          ls[i] = TM_NOBRT;       /* assign bogus value */
331                  else                            /* else convert to lnL */
332 <                        ls[i] = (BRT2SCALE*l16s[i] >> 8) - offset;
332 >                        ls[i] = (BRT2SCALE(l16s[i]) >> 8) - offset;
333          }
334          returnOK;
335   }
# Line 321 | Line 346 | struct tmStruct        *tm;
346                  exit(1);
347          }
348          ld = (LUV32DATA *)tm->pd[luv32Reg];
349 <        ld->offset = BRT2SCALE*64;
349 >        ld->offset = BRT2SCALE(64);
350          if (tm->inpsf > 1.0001)
351                  ld->offset -= (int)(TM_BRTSCALE*log(tmTop->inpsf)+.5);
352          else if (tm->inpsf < 0.9999)
# Line 350 | Line 375 | luv24NewSpace(tm)              /* initialize 24-bit LogLuv color s
375   struct tmStruct *tm;
376   {
377          register LUV24DATA      *ld;
353 –        double  uvp[2];
378  
379          if (tm->inppri != TM_XYZPRIM) {         /* panic time! */
380                  fputs("Improper input color space in luv24NewSpace!\n", stderr);
381                  exit(1);
382          }
383          ld = (LUV24DATA *)tm->pd[luv24Reg];
384 <        ld->offset = BRT2SCALE*12;
384 >        ld->offset = BRT2SCALE(12);
385          if (tm->inpsf > 1.0001)
386                  ld->offset -= (int)(TM_BRTSCALE*log(tmTop->inpsf)+.5);
387          else if (tm->inpsf < 0.9999)
# Line 376 | Line 400 | struct tmStruct        *tm;
400          if (ld == NULL)
401                  return(NULL);
402          tm->pd[luv24Reg] = (MEM_PTR)ld;
403 <        if (uv14neu < 0) {              /* initialize neutral color index */
404 <                double  uvp[2];
381 <                uvp[0] = U_NEU; uvp[1] = V_NEU;
382 <                uv14neu = uvpencode(uvp);
383 <        }
403 >        if (uv14neu < 0)                /* initialize neutral color index */
404 >                uv14neu = uv_encode(U_NEU, V_NEU, SGILOGENCODE_NODITHER);
405          luv24NewSpace(tm);
406          return((MEM_PTR)ld);
407   }

Diff Legend

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