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

Comparing ray/src/common/tmapcolrs.c (file contents):
Revision 3.19 by greg, Fri Jan 7 22:05:30 2005 UTC vs.
Revision 3.33 by greg, Fri Jul 19 17:37:56 2019 UTC

# Line 10 | Line 10 | static const char      RCSid[] = "$Id$";
10   #include "copyright.h"
11  
12   #include        <stdio.h>
13 + #include        <stdlib.h>
14   #include        <string.h>
15   #include        <math.h>
16   #include        <time.h>
17  
18 + #ifdef PCOND
19 + #include        "paths.h"
20 + #endif
21   #include        "tmprivat.h"
22 + #include        "rtio.h"
23   #include        "resolu.h"
19 – #include        "rtprocess.h"
24  
25 < #ifndef TM_PIC_CTRANS
22 < #define TM_PIC_CTRANS   1               /* transform colors? (expensive) */
23 < #endif
25 > #define GAMTSZ  4096
26  
25 – #define GAMTSZ  1024
26 –
27   typedef struct {
28 <        BYTE            gamb[GAMTSZ];   /* gamma lookup table */
29 <        COLR            clfb;           /* encoded tm->clf */
28 >        uby8            gamb[GAMTSZ];   /* gamma lookup table */
29 >        int             clfb[3];        /* encoded tm->clf */
30 >        int32           cmatb[3][3];    /* encoded color transform */
31          TMbright        inpsfb;         /* encoded tm->inpsf */
32   } COLRDATA;
33  
# Line 39 | Line 40 | static struct tmPackage        colrPkg = {     /* our package fun
40   };
41   static int      colrReg = -1;           /* our package registration number */
42  
43 < #define LOGISZ  260
43 < static TMbright logi[LOGISZ];
43 > static TMbright logi[256];
44  
45  
46   int
47   tmCvColrs(                              /* convert RGBE/XYZE colors */
48   TMstruct        *tms,
49   TMbright        *ls,
50 < BYTE    *cs,
50 > uby8    *cs,
51   COLR    *scan,
52   int     len
53   )
54   {
55          static const char       funcName[] = "tmCvColrs";
56 <        COLR    cmon;
57 <        register COLRDATA       *cd;
58 <        register int    i, bi, li;
56 >        int     cmon[4];
57 >        COLRDATA        *cd;
58 >        int     i, j, bi;
59 >        int32   li, vl;
60  
61          if (tms == NULL)
62                  returnErr(TM_E_TMINVAL);
63          if ((ls == NULL) | (scan == NULL) | (len < 0))
64                  returnErr(TM_E_ILLEGAL);
64 – #if TM_PIC_CTRANS
65 –        if (tmNeedMatrix(tms)) {                /* need floating point */
66 – #else
67 –        if (tms->inppri == TM_XYZPRIM) {        /* no way around this */
68 – #endif
69 –                register COLOR  *newscan;
70 –                newscan = (COLOR *)tempbuffer(len*sizeof(COLOR));
71 –                if (newscan == NULL)
72 –                        returnErr(TM_E_NOMEM);
73 –                for (i = len; i--; )
74 –                        colr_color(newscan[i], scan[i]);
75 –                return(tmCvColors(tms, ls, cs, newscan, len));
76 –        }
65          if (colrReg < 0) {                      /* build tables if necessary */
66                  colrReg = tmRegPkg(&colrPkg);
67                  if (colrReg < 0)
68                          returnErr(TM_E_CODERR1);
69                  for (i = 256; i--; )
70                          logi[i] = TM_BRTSCALE*log((i+.5)/256.) - .5;
83 –                for (i = 256; i < LOGISZ; i++)
84 –                        logi[i] = 0;
71                  tmMkMesofact();
72          }
73          if ((cd = (COLRDATA *)tmPkgData(tms,colrReg)) == NULL)
74                  returnErr(TM_E_NOMEM);
75          for (i = len; i--; ) {
76 <                copycolr(cmon, scan[i]);
76 >                if (tmNeedMatrix(tms)) {                /* apply color xform */
77 >                        for (j = 3; j--; ) {
78 >                                vl =    cd->cmatb[j][RED]*(int32)scan[i][RED] +
79 >                                        cd->cmatb[j][GRN]*(int32)scan[i][GRN] +
80 >                                        cd->cmatb[j][BLU]*(int32)scan[i][BLU] ;
81 >                                if (vl < 0) cmon[j] = vl/0x10000;
82 >                                else cmon[j] = vl>>16;
83 >                        }
84 >                        cmon[EXP] = scan[i][EXP];
85 >                } else
86 >                        copycolr(cmon, scan[i]);
87                                                          /* world luminance */
88 <                li =  ( cd->clfb[RED]*cmon[RED] +
89 <                        cd->clfb[GRN]*cmon[GRN] +
90 <                        cd->clfb[BLU]*cmon[BLU] ) >> 8;
91 <                bi = BRT2SCALE(cmon[EXP]-COLXS) +
92 <                                logi[li] + cd->inpsfb;
93 <                if (li <= 0) {
94 <                        bi = TM_NOBRT;                  /* bogus value */
95 <                        li = 1;                         /* avoid li==0 */
88 >                li =    cd->clfb[RED]*(int32)cmon[RED] +
89 >                        cd->clfb[GRN]*(int32)cmon[GRN] +
90 >                        cd->clfb[BLU]*(int32)cmon[BLU] ;
91 >                if (li >= 1L<<(12+8)) li = 255;
92 >                else li >>= 12;
93 >                bi = BRT2SCALE(cmon[EXP]-COLXS) + cd->inpsfb;
94 >                if (li > 0)
95 >                        bi += logi[li];
96 >                else {
97 >                        bi += logi[0];
98 >                        li = 1;                         /* avoid /0 */
99                  }
100                  ls[i] = bi;
101                  if (cs == TM_NOCHROM)                   /* no color? */
102                          continue;
103                                                          /* mesopic adj. */
104                  if (tms->flags & TM_F_MESOPIC && bi < BMESUPPER) {
105 <                        register int    pf, sli = normscot(cmon);
106 <                        if (bi < BMESLOWER)
105 >                        int     pf, sli = normscot(cmon);
106 >                        if (bi < BMESLOWER) {
107                                  cmon[RED] = cmon[GRN] = cmon[BLU] = sli;
108 <                        else {
108 >                        } else {
109                                  if (tms->flags & TM_F_BW)
110                                          cmon[RED] = cmon[GRN] = cmon[BLU] = li;
111                                  pf = tmMesofact[bi-BMESLOWER];
112                                  sli *= 256 - pf;
113 <                                cmon[RED] = ( sli + pf*cmon[RED] ) >> 8;
114 <                                cmon[GRN] = ( sli + pf*cmon[GRN] ) >> 8;
115 <                                cmon[BLU] = ( sli + pf*cmon[BLU] ) >> 8;
113 >                                for (j = 3; j--; ) {
114 >                                        cmon[j] = sli + pf*cmon[j];
115 >                                        if (cmon[j] <= 0) cmon[j] = 0;
116 >                                        else cmon[j] >>= 8;
117 >                                }
118                          }
119                  } else if (tms->flags & TM_F_BW) {
120                          cmon[RED] = cmon[GRN] = cmon[BLU] = li;
121 +                } else {
122 +                        for (j = 3; j--; )
123 +                                if (cmon[j] < 0) cmon[j] = 0;
124                  }
125 <                bi = ( (int32)GAMTSZ*cd->clfb[RED]*cmon[RED]/li ) >> 8;
125 >                bi = ( (uint32)GAMTSZ*cd->clfb[RED]*cmon[RED]/li ) >> 12;
126                  cs[3*i  ] = bi>=GAMTSZ ? 255 : cd->gamb[bi];
127 <                bi = ( (int32)GAMTSZ*cd->clfb[GRN]*cmon[GRN]/li ) >> 8;
127 >                bi = ( (uint32)GAMTSZ*cd->clfb[GRN]*cmon[GRN]/li ) >> 12;
128                  cs[3*i+1] = bi>=GAMTSZ ? 255 : cd->gamb[bi];
129 <                bi = ( (int32)GAMTSZ*cd->clfb[BLU]*cmon[BLU]/li ) >> 8;
129 >                bi = ( (uint32)GAMTSZ*cd->clfb[BLU]*cmon[BLU]/li ) >> 12;
130                  cs[3*i+2] = bi>=GAMTSZ ? 255 : cd->gamb[bi];
131          }
132          returnOK;
# Line 144 | Line 148 | static struct radhead {
148  
149   static int
150   headline(                       /* grok a header line */
151 <        register char   *s,
151 >        char    *s,
152          void    *vrh
153   )
154   {
155 <        char    fmt[32];
156 <        register struct radhead *rh = vrh;
155 >        char    fmt[MAXFMTLEN];
156 >        struct radhead  *rh = vrh;
157  
158          if (formatval(fmt, s)) {
159                  if (!strcmp(fmt, COLRFMT))
# Line 177 | Line 181 | int
181   tmLoadPicture(                          /* convert Radiance picture */
182   TMstruct        *tms,
183   TMbright        **lpp,
184 < BYTE    **cpp,
184 > uby8    **cpp,
185   int     *xp,
186   int     *yp,
187   char    *fname,
# Line 197 | Line 201 | FILE   *fp
201                          ((fname == NULL) & (fp == TM_GETFILE)))
202                  returnErr(TM_E_ILLEGAL);
203          *xp = *yp = 0;                          /* error precaution */
204 <        if ((inpf = fp) == TM_GETFILE && (inpf = fopen(fname, "r")) == NULL)
204 >        if ((inpf = fp) == TM_GETFILE && (inpf = fopen(fname, "rb")) == NULL)
205                  returnErr(TM_E_BADFILE);
206          *lpp = NULL;
207          if (cpp != TM_NOCHROMP) *cpp = NULL;
# Line 221 | Line 225 | FILE   *fp
225          if (*lpp == NULL)
226                  goto done;
227          if (cpp != TM_NOCHROMP) {
228 <                *cpp = (BYTE *)malloc(3*sizeof(BYTE) * *xp * *yp);
228 >                *cpp = (uby8 *)malloc(3*sizeof(uby8) * *xp * *yp);
229                  if (*cpp == NULL)
230                          goto done;
231          }
# Line 258 | Line 262 | done:                                          /* clean up */
262   #ifdef PCOND
263   static int                                      /* run pcond to map picture */
264   dopcond(psp, xp, yp, flags, monpri, gamval, Lddyn, Ldmax, fname)
265 < BYTE    **psp;
265 > uby8    **psp;
266   int     *xp, *yp;
267   int     flags;
268   RGBPRIMP        monpri;
# Line 269 | Line 273 | char   *fname;
273          TMstruct        *tms = NULL;
274          char    cmdbuf[1024];
275          FILE    *infp;
276 <        register COLR   *scan;
277 <        register BYTE   *rp;
276 >        COLR    *scan;
277 >        uby8    *rp;
278          int     y;
279 <        register int    x;
279 >        int     x;
280                                          /* set up gamma correction */
281          if (setcolrcor(pow, 1./gamval) < 0)
282                  returnErr(TM_E_NOMEM);
# Line 309 | Line 313 | char   *fname;
313                                          /* allocate arrays */
314          scan = (COLR *)malloc(sizeof(COLR) * *xp);
315          if (flags & TM_F_BW)
316 <                rp = (BYTE *)malloc(sizeof(BYTE) * *xp * *yp);
316 >                rp = (uby8 *)malloc(sizeof(uby8) * *xp * *yp);
317          else
318 <                rp = (BYTE *)malloc(3*sizeof(BYTE) * *xp * *yp);
318 >                rp = (uby8 *)malloc(3*sizeof(uby8) * *xp * *yp);
319          if (((*psp = rp) == NULL) | (scan == NULL)) {
320                  pclose(infp);
321                  returnErr(TM_E_NOMEM);
# Line 345 | Line 349 | char   *fname;
349  
350   int                                     /* map a Radiance picture */
351   tmMapPicture(psp, xp, yp, flags, monpri, gamval, Lddyn, Ldmax, fname, fp)
352 < BYTE    **psp;
352 > uby8    **psp;
353   int     *xp, *yp;
354   int     flags;
355   RGBPRIMP        monpri;
# Line 354 | Line 358 | char   *fname;
358   FILE    *fp;
359   {
360          char    *funcName = fname==NULL ? "tmMapPicture" : fname;
361 <        TMstruct        *tms;
362 <        BYTE    *cp;
361 >        TMstruct        *tms = NULL;
362 >        uby8    *cp;
363          TMbright        *lp;
364          int     err;
365                                                  /* check arguments */
# Line 385 | Line 389 | FILE   *fp;
389          }
390                                                  /* allocate space for result */
391          if (flags & TM_F_BW) {
392 <                *psp = (BYTE *)malloc(sizeof(BYTE) * *xp * *yp);
392 >                *psp = (uby8 *)malloc(sizeof(uby8) * *xp * *yp);
393                  if (*psp == NULL) {
394                          free((MEM_PTR)lp);
395                          tmDone(tms);
# Line 418 | Line 422 | done:                                          /* clean up */
422  
423   static void
424   colrNewSpace(tms)               /* color space changed for tone mapping */
425 < register TMstruct       *tms;
425 > TMstruct        *tms;
426   {
427 <        register COLRDATA       *cd;
427 >        COLRDATA        *cd;
428          double  d;
429 +        int     i, j;
430  
431          cd = (COLRDATA *)tms->pd[colrReg];
432 <        cd->clfb[RED] = 256.*tms->clf[RED] + .5;
433 <        cd->clfb[GRN] = 256.*tms->clf[GRN] + .5;
434 <        cd->clfb[BLU] = 256.*tms->clf[BLU] + .5;
435 <        cd->clfb[EXP] = COLXS;
436 <        d = TM_BRTSCALE*log(tms->inpsf);
437 <        cd->inpsfb = d<0. ? d-.5 : d+.5;
432 >        for (i = 3; i--; )
433 >                cd->clfb[i] = 0x1000*tms->clf[i] + .5;
434 >        cd->inpsfb = tmCvLuminance(tms->inpsf);
435 >        for (i = 3; i--; )
436 >                for (j = 3; j--; ) {
437 >                        d = tms->cmat[i][j] / tms->inpsf;
438 >                        cd->cmatb[i][j] = 0x10000*d + (d<0. ? -.5 : .5);
439 >                }
440   }
441  
442  
443   static MEM_PTR
444   colrInit(tms)                   /* initialize private data for tone mapping */
445 < register TMstruct       *tms;
445 > TMstruct        *tms;
446   {
447 <        register COLRDATA       *cd;
448 <        register int    i;
447 >        COLRDATA        *cd;
448 >        int     i;
449                                          /* allocate our data */
450          cd = (COLRDATA *)malloc(sizeof(COLRDATA));
451          if (cd == NULL)

Diff Legend

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