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

Comparing ray/src/common/tonemap.c (file contents):
Revision 3.3 by greg, Wed Apr 16 20:28:03 1997 UTC vs.
Revision 3.4 by greg, Fri Apr 18 13:59:43 1997 UTC

# Line 18 | Line 18 | static char SCCSid[] = "$SunId$ LBL";
18  
19   struct tmStruct *tmTop = NULL;          /* current tone mapping stack */
20  
21 +                                        /* our list of conversion packages */
22 + struct tmPackage        *tmPkg[TM_MAXPKG];
23 + int     tmNumPkgs = 0;                  /* number of registered packages */
24  
25 +
26   int
27   tmErrorReturn(func, err)                /* error return (with message) */
28   char    *func;
# Line 62 | Line 66 | double gamval;
66                  tmnew->clf[GRN] = cmat[1][1];
67                  tmnew->clf[BLU] = cmat[1][2];
68          }
65 –        tmnew->clfb[RED] = 256.*tmnew->clf[RED] + .5;
66 –        tmnew->clfb[GRN] = 256.*tmnew->clf[GRN] + .5;
67 –        tmnew->clfb[BLU] = 256.*tmnew->clf[BLU] + .5;
68 –        tmnew->clfb[EXP] = COLXS;
69                                                  /* set gamma value */
70          if (gamval < MINGAM)
71                  tmnew->mongam = DEFGAM;
72          else
73                  tmnew->mongam = gamval;
74 <        for (i = TM_GAMTSZ; i--; )
75 <                tmnew->gamb[i] = 256.*pow((i+.5)/TM_GAMTSZ, 1./tmnew->mongam);
74 >                                                /* set color divisors */
75 >        for (i = 0; i < 3; i++)
76 >                tmnew->cdiv[i] = 256.*pow(tmnew->clf[i], 1./tmnew->mongam);
77 >
78                                                  /* set input transform */
79          tmnew->inppri = tmnew->monpri;
80          tmnew->cmat[0][0] = tmnew->cmat[1][1] = tmnew->cmat[2][2] =
81                          tmnew->inpsf = WHTEFFICACY;
80 –        tmnew->inpsfb = TM_BRTSCALE*log(tmnew->inpsf) + .5;
82          tmnew->cmat[0][1] = tmnew->cmat[0][2] = tmnew->cmat[1][0] =
83          tmnew->cmat[1][2] = tmnew->cmat[2][0] = tmnew->cmat[2][1] = 0.;
83 –        tmnew->flags &= ~TM_F_NEEDMAT;
84          tmnew->brmin = tmnew->brmax = 0;
85          tmnew->histo = NULL;
86          tmnew->lumap = NULL;
87 <        tmnew->tmprev = NULL;
88 <
89 <        tmnew->flags |= TM_F_INITED;
90 <                                                /* make it current */
87 >                                                /* zero private data */
88 >        for (i = TM_MAXPKG; i--; )
89 >                tmnew->pd[i] = NULL;
90 >                                                /* make tmnew current */
91          tmnew->tmprev = tmTop;
92          return(tmTop = tmnew);
93   }
# Line 110 | Line 110 | double sf;
110                  returnOK;
111          tmTop->inppri = pri;                    /* let's set it */
112          tmTop->inpsf = sf;
113 –        tmTop->inpsfb = TM_BRTSCALE*log(sf) + (sf>=1. ? .5 : -.5);
113  
114          if (tmTop->flags & TM_F_BW) {           /* color doesn't matter */
115                  tmTop->monpri = tmTop->inppri;          /* eliminate xform */
116                  if (tmTop->inppri == TM_XYZPRIM) {
117                          tmTop->clf[CIEX] = tmTop->clf[CIEZ] = 0.;
118                          tmTop->clf[CIEY] = 1.;
120 –                        tmTop->clfb[CIEX] = tmTop->clfb[CIEZ] = 0;
121 –                        tmTop->clfb[CIEY] = 255;
119                  } else {
120                          comprgb2xyzmat(tmTop->cmat, tmTop->monpri);
121                          tmTop->clf[RED] = tmTop->cmat[1][0];
# Line 142 | Line 139 | double sf;
139          for (i = 0; i < 3; i++)
140                  for (j = 0; j < 3; j++)
141                          tmTop->cmat[i][j] *= tmTop->inpsf;
142 <        if (tmTop->inppri != tmTop->monpri)
143 <                tmTop->flags |= TM_F_NEEDMAT;
144 <        else
145 <                tmTop->flags &= ~TM_F_NEEDMAT;
142 >                                                /* set color divisors */
143 >        for (i = 0; i < 3; i++)
144 >                if (tmTop->clf[i] > .001)
145 >                        tmTop->cdiv[i] =
146 >                                256.*pow(tmTop->clf[i], 1./tmTop->mongam);
147 >                else
148 >                        tmTop->cdiv[i] = 1;
149 >                                                /* notify packages */
150 >        for (i = tmNumPkgs; i--; )
151 >                if (tmTop->pd[i] != NULL && tmPkg[i]->NewSpace != NULL)
152 >                        (*tmPkg[i]->NewSpace)(tmTop);
153          returnOK;
154   }
155  
# Line 155 | Line 159 | tmClearHisto()                 /* clear current histogram */
159   {
160          if (tmTop == NULL || tmTop->histo == NULL)
161                  return;
162 <        free((char *)tmTop->histo);
162 >        free((MEM_PTR)tmTop->histo);
163          tmTop->histo = NULL;
164   }
165  
# Line 168 | Line 172 | COLOR  *scan;
172   int     len;
173   {
174          static char     funcName[] = "tmCvColors";
175 +        static COLOR    csmall = {1e-6, 1e-6, 1e-6};
176          COLOR   cmon;
177          double  lum, slum;
178          register double d;
# Line 178 | Line 183 | int    len;
183          if (ls == NULL | scan == NULL | len <= 0)
184                  returnErr(TM_E_ILLEGAL);
185          for (i = len; i--; ) {
186 <                if (tmTop->flags & TM_F_NEEDMAT)        /* get monitor RGB */
186 >                if (tmNeedMatrix(tmTop))                /* get monitor RGB */
187                          colortrans(cmon, tmTop->cmat, scan[i]);
188                  else {
189                          cmon[RED] = tmTop->inpsf*scan[i][RED];
# Line 190 | Line 195 | int    len;
195                          tmTop->clf[GRN]*cmon[GRN] +
196                          tmTop->clf[BLU]*cmon[BLU] ;
197                                                          /* check range */
198 <                if (clipgamut(cmon, lum, CGAMUT_LOWER, cblack, cwhite))
198 >                if (clipgamut(cmon, lum, CGAMUT_LOWER, csmall, cwhite))
199                          lum =   tmTop->clf[RED]*cmon[RED] +
200                                  tmTop->clf[GRN]*cmon[GRN] +
201                                  tmTop->clf[BLU]*cmon[BLU] ;
# Line 223 | Line 228 | int    len;
228                          cmon[RED] = cmon[GRN] = cmon[BLU] = lum;
229                  }
230                  d = tmTop->clf[RED]*cmon[RED]/lum;
231 <                /* cs[3*i  ] = d>.999 ? 255 : 256.*pow(d, 1./tmTop->mongam); */
232 <                cs[3*i  ] = d>.999 ? 255 : tmTop->gamb[(int)(d*TM_GAMTSZ)];
231 >                cs[3*i  ] = d>=.999 ? 255 :
232 >                                (int)(256.*pow(d, 1./tmTop->mongam));
233                  d = tmTop->clf[GRN]*cmon[GRN]/lum;
234 <                /* cs[3*i+1] = d>.999 ? 255 : 256.*pow(d, 1./tmTop->mongam); */
235 <                cs[3*i+1] = d>.999 ? 255 : tmTop->gamb[(int)(d*TM_GAMTSZ)];
234 >                cs[3*i+1] = d>=.999 ? 255 :
235 >                                (int)(256.*pow(d, 1./tmTop->mongam));
236                  d = tmTop->clf[BLU]*cmon[BLU]/lum;
237 <                /* cs[3*i+2] = d>.999 ? 255 : 256.*pow(d, 1./tmTop->mongam); */
238 <                cs[3*i+2] = d>.999 ? 255 : tmTop->gamb[(int)(d*TM_GAMTSZ)];
237 >                cs[3*i+2] = d>=.999 ? 255 :
238 >                                (int)(256.*pow(d, 1./tmTop->mongam));
239          }
240          returnOK;
241   }
# Line 279 | Line 284 | int    wt;
284                  if (oldlen) {                   /* copy and free old */
285                          for (i = oldlen, j = i+oldorig-horig; i; )
286                                  newhist[--j] = tmTop->histo[--i];
287 <                        free((char *)tmTop->histo);
287 >                        free((MEM_PTR)tmTop->histo);
288                  }
289                  tmTop->histo = newhist;
290                  if (tmTop->lumap != NULL) {     /* invalid tone map */
291 <                        free((char *)tmTop->lumap);
291 >                        free((MEM_PTR)tmTop->lumap);
292                          tmTop->lumap = NULL;
293                  }
294          }
# Line 420 | Line 425 | double Ldmax;
425                  }
426          }
427          if (!(tmTop->flags & TM_F_LINEAR)) {
428 <                free((char *)histo);
429 <                free((char *)cumf);
428 >                free((MEM_PTR)histo);
429 >                free((MEM_PTR)cumf);
430          }
431          returnOK;
432   }
# Line 435 | Line 440 | register BYTE  *cs;
440   int     len;
441   {
442          static char     funcName[] = "tmMapPixels";
443 <        int     rdiv, gdiv, bdiv;
439 <        register int    li, pv;
443 >        register int4   li, pv;
444  
445          if (tmTop == NULL || tmTop->lumap == NULL)
446                  returnErr(TM_E_TMINVAL);
447          if (ps == NULL | ls == NULL | len <= 0)
448                  returnErr(TM_E_ILLEGAL);
445 –        rdiv = tmTop->gamb[((int4)TM_GAMTSZ*tmTop->clfb[RED])>>8];
446 –        gdiv = tmTop->gamb[((int4)TM_GAMTSZ*tmTop->clfb[GRN])>>8];
447 –        bdiv = tmTop->gamb[((int4)TM_GAMTSZ*tmTop->clfb[BLU])>>8];
449          while (len--) {
450                  if ((li = *ls++) < tmTop->brmin)
451                          li = tmTop->brmin;
# Line 454 | Line 455 | int    len;
455                  if (cs == TM_NOCHROM)
456                          *ps++ = li>255 ? 255 : li;
457                  else {
458 <                        pv = *cs++ * li / rdiv;
458 >                        pv = *cs++ * li / tmTop->cdiv[RED];
459                          *ps++ = pv>255 ? 255 : pv;
460 <                        pv = *cs++ * li / gdiv;
460 >                        pv = *cs++ * li / tmTop->cdiv[GRN];
461                          *ps++ = pv>255 ? 255 : pv;
462 <                        pv = *cs++ * li / bdiv;
462 >                        pv = *cs++ * li / tmTop->cdiv[BLU];
463                          *ps++ = pv>255 ? 255 : pv;
464                  }
465          }
# Line 529 | Line 530 | tmDup()                                /* duplicate top tone mapping */
530                          for (i = len; i--; )
531                                  tmnew->lumap[i] = tmTop->lumap[i];
532          }
533 +                                        /* clear package data */
534 +        for (i = tmNumPkgs; i--; )
535 +                tmnew->pd[i] = NULL;
536          tmnew->tmprev = tmTop;          /* make copy current */
537          return(tmTop = tmnew);
538   }
# Line 540 | Line 544 | register struct tmStruct       *tms;
544   {
545          static char     funcName[] = "tmPush";
546                                          /* check validity */
547 <        if (tms == NULL || !(tms->flags & TM_F_INITED))
547 >        if (tms == NULL)
548                  returnErr(TM_E_ILLEGAL);
549          if (tms == tmTop)               /* check necessity */
550                  returnOK;
# Line 557 | Line 561 | void
561   tmDone(tms)                     /* done with tone mapping -- destroy it */
562   register struct tmStruct        *tms;
563   {
564 +        register int    i;
565                                          /* NULL arg. is equiv. to tmTop */
566          if (tms == NULL && (tms = tmTop) == NULL)
567                  return;
# Line 564 | Line 569 | register struct tmStruct       *tms;
569          (void)tmPull(tms);
570                                          /* free tables */
571          if (tms->histo != NULL)
572 <                free((char *)tms->histo);
572 >                free((MEM_PTR)tms->histo);
573          if (tms->lumap != NULL)
574 <                free((char *)tms->lumap);
575 <        tms->flags = 0;
576 <        free((char *)tms);              /* free basic structure */
574 >                free((MEM_PTR)tms->lumap);
575 >                                        /* free private data */
576 >        for (i = tmNumPkgs; i--; )
577 >                if (tms->pd[i] != NULL)
578 >                        (*tmPkg[i]->Free)(tms->pd[i]);
579 >        free((MEM_PTR)tms);             /* free basic structure */
580   }

Diff Legend

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