--- ray/src/common/tonemap.c 2003/02/22 02:07:22 3.9
+++ ray/src/common/tonemap.c 2005/11/15 06:53:00 3.19
@@ -1,5 +1,5 @@
#ifndef lint
-static const char RCSid[] = "$Id: tonemap.c,v 3.9 2003/02/22 02:07:22 greg Exp $";
+static const char RCSid[] = "$Id: tonemap.c,v 3.19 2005/11/15 06:53:00 greg Exp $";
#endif
/*
* Tone mapping functions.
@@ -9,62 +9,7 @@ static const char RCSid[] = "$Id: tonemap.c,v 3.9 2003
* Externals declared in tonemap.h
*/
-/* ====================================================================
- * 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 radiance@radsite.lbl.gov.
- *
- * 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
- * .
- */
+#include "copyright.h"
#include
#include
@@ -73,31 +18,29 @@ static const char RCSid[] = "$Id: tonemap.c,v 3.9 2003
#define exp10(x) exp(M_LN10*(x))
-struct tmStruct *tmTop = NULL; /* current tone mapping stack */
-
/* our list of conversion packages */
struct tmPackage *tmPkg[TM_MAXPKG];
int tmNumPkgs = 0; /* number of registered packages */
-int tmLastError; /* last error incurred by library */
-char *tmLastFunction; /* error-generating function name */
-
-struct tmStruct *
-tmInit(flags, monpri, gamval) /* initialize new tone mapping */
-int flags;
-RGBPRIMP monpri;
-double gamval;
+TMstruct *
+tmInit( /* initialize new tone mapping */
+int flags,
+RGBPRIMP monpri,
+double gamval
+)
{
COLORMAT cmat;
- register struct tmStruct *tmnew;
- register int i;
+ TMstruct *tmnew;
+ int i;
/* allocate structure */
- tmnew = (struct tmStruct *)malloc(sizeof(struct tmStruct));
+ tmnew = (TMstruct *)malloc(sizeof(TMstruct));
if (tmnew == NULL)
return(NULL);
tmnew->flags = flags & ~TM_F_UNIMPL;
+ if (tmnew->flags & TM_F_BW)
+ tmnew->flags &= ~TM_F_MESOPIC;
/* set monitor transform */
if (monpri == NULL || monpri == stdprims || tmnew->flags & TM_F_BW) {
tmnew->monpri = stdprims;
@@ -125,6 +68,7 @@ double gamval;
tmnew->inpsf = WHTEFFICACY;
tmnew->cmat[0][1] = tmnew->cmat[0][2] = tmnew->cmat[1][0] =
tmnew->cmat[1][2] = tmnew->cmat[2][0] = tmnew->cmat[2][1] = 0.;
+ tmnew->inpdat = NULL;
tmnew->hbrmin = 10; tmnew->hbrmax = -10;
tmnew->histo = NULL;
tmnew->mbrmin = 10; tmnew->mbrmax = -10;
@@ -132,118 +76,127 @@ double gamval;
/* zero private data */
for (i = TM_MAXPKG; i--; )
tmnew->pd[i] = NULL;
- /* make tmnew current */
- tmnew->tmprev = tmTop;
- return(tmTop = tmnew);
+ tmnew->lastError = TM_E_OK;
+ tmnew->lastFunc = "NoErr";
+ /* return new TMstruct */
+ return(tmnew);
}
int
-tmSetSpace(pri, sf) /* set input color space for conversions */
-RGBPRIMP pri;
-double sf;
+tmSetSpace( /* set input color space for conversions */
+TMstruct *tms,
+RGBPRIMP pri,
+double sf,
+MEM_PTR dat
+)
{
- static char funcName[] = "tmSetSpace";
- register int i, j;
+ static const char funcName[] = "tmSetSpace";
+ int i, j;
/* error check */
- if (tmTop == NULL)
+ if (tms == NULL)
returnErr(TM_E_TMINVAL);
if (sf <= 1e-12)
returnErr(TM_E_ILLEGAL);
/* check if no change */
- if (pri == tmTop->inppri && FEQ(sf, tmTop->inpsf))
+ if (pri == tms->inppri && FEQ(sf, tms->inpsf) && dat == tms->inpdat)
returnOK;
- tmTop->inppri = pri; /* let's set it */
- tmTop->inpsf = sf;
+ tms->inppri = pri; /* let's set it */
+ tms->inpsf = sf;
+ tms->inpdat = dat;
- if (tmTop->flags & TM_F_BW) { /* color doesn't matter */
- tmTop->monpri = tmTop->inppri; /* eliminate xform */
- if (tmTop->inppri == TM_XYZPRIM) {
- tmTop->clf[CIEX] = tmTop->clf[CIEZ] = 0.;
- tmTop->clf[CIEY] = 1.;
+ if (tms->flags & TM_F_BW) { /* color doesn't matter */
+ tms->monpri = tms->inppri; /* eliminate xform */
+ if (tms->inppri == TM_XYZPRIM) {
+ tms->clf[CIEX] = tms->clf[CIEZ] = 0.;
+ tms->clf[CIEY] = 1.;
} else {
- comprgb2xyzWBmat(tmTop->cmat, tmTop->monpri);
- tmTop->clf[RED] = tmTop->cmat[1][0];
- tmTop->clf[GRN] = tmTop->cmat[1][1];
- tmTop->clf[BLU] = tmTop->cmat[1][2];
+ comprgb2xyzWBmat(tms->cmat, tms->monpri);
+ tms->clf[RED] = tms->cmat[1][0];
+ tms->clf[GRN] = tms->cmat[1][1];
+ tms->clf[BLU] = tms->cmat[1][2];
}
- tmTop->cmat[0][0] = tmTop->cmat[1][1] = tmTop->cmat[2][2] =
- tmTop->inpsf;
- tmTop->cmat[0][1] = tmTop->cmat[0][2] = tmTop->cmat[1][0] =
- tmTop->cmat[1][2] = tmTop->cmat[2][0] = tmTop->cmat[2][1] = 0.;
+ tms->cmat[0][0] = tms->cmat[1][1] = tms->cmat[2][2] =
+ tms->inpsf;
+ tms->cmat[0][1] = tms->cmat[0][2] = tms->cmat[1][0] =
+ tms->cmat[1][2] = tms->cmat[2][0] = tms->cmat[2][1] = 0.;
- } else if (tmTop->inppri == TM_XYZPRIM) /* input is XYZ */
- compxyz2rgbWBmat(tmTop->cmat, tmTop->monpri);
+ } else if (tms->inppri == TM_XYZPRIM) /* input is XYZ */
+ compxyz2rgbWBmat(tms->cmat, tms->monpri);
else { /* input is RGB */
- if (tmTop->inppri != tmTop->monpri &&
- PRIMEQ(tmTop->inppri, tmTop->monpri))
- tmTop->inppri = tmTop->monpri; /* no xform */
- comprgb2rgbWBmat(tmTop->cmat, tmTop->inppri, tmTop->monpri);
+ if (tms->inppri != tms->monpri &&
+ PRIMEQ(tms->inppri, tms->monpri))
+ tms->inppri = tms->monpri; /* no xform */
+ comprgb2rgbWBmat(tms->cmat, tms->inppri, tms->monpri);
}
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
- tmTop->cmat[i][j] *= tmTop->inpsf;
+ tms->cmat[i][j] *= tms->inpsf;
/* set color divisors */
for (i = 0; i < 3; i++)
- if (tmTop->clf[i] > .001)
- tmTop->cdiv[i] =
- 256.*pow(tmTop->clf[i], 1./tmTop->mongam);
+ if (tms->clf[i] > .001)
+ tms->cdiv[i] =
+ 256.*pow(tms->clf[i], 1./tms->mongam);
else
- tmTop->cdiv[i] = 1;
+ tms->cdiv[i] = 1;
/* notify packages */
for (i = tmNumPkgs; i--; )
- if (tmTop->pd[i] != NULL && tmPkg[i]->NewSpace != NULL)
- (*tmPkg[i]->NewSpace)(tmTop);
+ if (tms->pd[i] != NULL && tmPkg[i]->NewSpace != NULL)
+ (*tmPkg[i]->NewSpace)(tms);
returnOK;
}
void
-tmClearHisto() /* clear current histogram */
+tmClearHisto( /* clear current histogram */
+TMstruct *tms
+)
{
- if (tmTop == NULL || tmTop->histo == NULL)
+ if (tms == NULL || tms->histo == NULL)
return;
- free((MEM_PTR)tmTop->histo);
- tmTop->histo = NULL;
+ free((MEM_PTR)tms->histo);
+ tms->histo = NULL;
}
int
-tmCvColors(ls, cs, scan, len) /* convert float colors */
-TMbright *ls;
-BYTE *cs;
-COLOR *scan;
-int len;
+tmCvColors( /* convert float colors */
+TMstruct *tms,
+TMbright *ls,
+BYTE *cs,
+COLOR *scan,
+int len
+)
{
- static char funcName[] = "tmCvColors";
- static COLOR csmall = {1e-6, 1e-6, 1e-6};
+ static const char funcName[] = "tmCvColors";
+ static COLOR csmall = {.5*MINLUM, .5*MINLUM, .5*MINLUM};
COLOR cmon;
double lum, slum;
- register double d;
- register int i;
+ double d;
+ int i;
- if (tmTop == NULL)
+ if (tms == NULL)
returnErr(TM_E_TMINVAL);
- if (ls == NULL | scan == NULL | len < 0)
+ if ((ls == NULL) | (scan == NULL) | (len < 0))
returnErr(TM_E_ILLEGAL);
for (i = len; i--; ) {
- if (tmNeedMatrix(tmTop)) /* get monitor RGB */
- colortrans(cmon, tmTop->cmat, scan[i]);
- else {
- cmon[RED] = tmTop->inpsf*scan[i][RED];
- cmon[GRN] = tmTop->inpsf*scan[i][GRN];
- cmon[BLU] = tmTop->inpsf*scan[i][BLU];
+ if (tmNeedMatrix(tms)) { /* get monitor RGB */
+ colortrans(cmon, tms->cmat, scan[i]);
+ } else {
+ cmon[RED] = tms->inpsf*scan[i][RED];
+ cmon[GRN] = tms->inpsf*scan[i][GRN];
+ cmon[BLU] = tms->inpsf*scan[i][BLU];
}
/* world luminance */
- lum = tmTop->clf[RED]*cmon[RED] +
- tmTop->clf[GRN]*cmon[GRN] +
- tmTop->clf[BLU]*cmon[BLU] ;
+ lum = tms->clf[RED]*cmon[RED] +
+ tms->clf[GRN]*cmon[GRN] +
+ tms->clf[BLU]*cmon[BLU] ;
/* check range */
if (clipgamut(cmon, lum, CGAMUT_LOWER, csmall, cwhite))
- lum = tmTop->clf[RED]*cmon[RED] +
- tmTop->clf[GRN]*cmon[GRN] +
- tmTop->clf[BLU]*cmon[BLU] ;
+ lum = tms->clf[RED]*cmon[RED] +
+ tms->clf[GRN]*cmon[GRN] +
+ tms->clf[BLU]*cmon[BLU] ;
if (lum < MINLUM) {
ls[i] = MINBRT-1; /* bogus value */
lum = MINLUM;
@@ -253,13 +206,13 @@ int len;
}
if (cs == TM_NOCHROM) /* no color? */
continue;
- if (tmTop->flags & TM_F_MESOPIC && lum < LMESUPPER) {
+ if (tms->flags & TM_F_MESOPIC && lum < LMESUPPER) {
slum = scotlum(cmon); /* mesopic adj. */
if (lum < LMESLOWER)
cmon[RED] = cmon[GRN] = cmon[BLU] = slum;
else {
d = (lum - LMESLOWER)/(LMESUPPER - LMESLOWER);
- if (tmTop->flags & TM_F_BW)
+ if (tms->flags & TM_F_BW)
cmon[RED] = cmon[GRN] =
cmon[BLU] = d*lum;
else
@@ -269,36 +222,54 @@ int len;
cmon[GRN] += d;
cmon[BLU] += d;
}
- } else if (tmTop->flags & TM_F_BW) {
+ } else if (tms->flags & TM_F_BW) {
cmon[RED] = cmon[GRN] = cmon[BLU] = lum;
}
- d = tmTop->clf[RED]*cmon[RED]/lum;
+ d = tms->clf[RED]*cmon[RED]/lum;
cs[3*i ] = d>=.999 ? 255 :
- (int)(256.*pow(d, 1./tmTop->mongam));
- d = tmTop->clf[GRN]*cmon[GRN]/lum;
+ (int)(256.*pow(d, 1./tms->mongam));
+ d = tms->clf[GRN]*cmon[GRN]/lum;
cs[3*i+1] = d>=.999 ? 255 :
- (int)(256.*pow(d, 1./tmTop->mongam));
- d = tmTop->clf[BLU]*cmon[BLU]/lum;
+ (int)(256.*pow(d, 1./tms->mongam));
+ d = tms->clf[BLU]*cmon[BLU]/lum;
cs[3*i+2] = d>=.999 ? 255 :
- (int)(256.*pow(d, 1./tmTop->mongam));
+ (int)(256.*pow(d, 1./tms->mongam));
}
returnOK;
}
+TMbright
+tmCvLuminance( /* convert a single luminance */
+double lum
+)
+{
+ double d;
+
+ if (lum <= TM_NOLUM)
+ return(TM_NOBRT);
+ d = TM_BRTSCALE*log(lum);
+ if (d > 0.)
+ return((TMbright)(d+.5));
+ return((TMbright)(d-.5));
+}
+
+
int
-tmCvGrays(ls, scan, len) /* convert float gray values */
-TMbright *ls;
-float *scan;
-int len;
+tmCvGrays( /* convert float gray values */
+TMstruct *tms,
+TMbright *ls,
+float *scan,
+int len
+)
{
- static char funcName[] = "tmCvGrays";
- register double d;
- register int i;
+ static const char funcName[] = "tmCvGrays";
+ double d;
+ int i;
- if (tmTop == NULL)
+ if (tms == NULL)
returnErr(TM_E_TMINVAL);
- if (ls == NULL | scan == NULL | len < 0)
+ if ((ls == NULL) | (scan == NULL) | (len < 0))
returnErr(TM_E_ILLEGAL);
for (i = len; i--; )
if (scan[i] <= TM_NOLUM) {
@@ -312,66 +283,69 @@ int len;
int
-tmAddHisto(ls, len, wt) /* add values to histogram */
-register TMbright *ls;
-int len;
-int wt;
+tmAddHisto( /* add values to histogram */
+TMstruct *tms,
+TMbright *ls,
+int len,
+int wt
+)
{
- static char funcName[] = "tmAddHisto";
+ static const char funcName[] = "tmAddHisto";
int oldorig=0, oldlen, horig, hlen;
- register int i, j;
+ int i, j;
- if (tmTop == NULL)
+ if (tms == NULL)
returnErr(TM_E_TMINVAL);
if (len < 0)
returnErr(TM_E_ILLEGAL);
if (len == 0)
returnOK;
/* first, grow limits */
- if (tmTop->histo == NULL) {
+ if (tms->histo == NULL) {
for (i = len; i-- && ls[i] < MINBRT; )
;
if (i < 0)
returnOK;
- tmTop->hbrmin = tmTop->hbrmax = ls[i];
+ tms->hbrmin = tms->hbrmax = ls[i];
oldlen = 0;
} else {
- oldorig = (tmTop->hbrmin-MINBRT)/HISTEP;
- oldlen = (tmTop->hbrmax-MINBRT)/HISTEP + 1 - oldorig;
+ oldorig = (tms->hbrmin-MINBRT)/HISTEP;
+ oldlen = (tms->hbrmax-MINBRT)/HISTEP + 1 - oldorig;
}
for (i = len; i--; ) {
if ((j = ls[i]) < MINBRT)
continue;
- if (j < tmTop->hbrmin)
- tmTop->hbrmin = j;
- else if (j > tmTop->hbrmax)
- tmTop->hbrmax = j;
+ if (j < tms->hbrmin)
+ tms->hbrmin = j;
+ else if (j > tms->hbrmax)
+ tms->hbrmax = j;
}
- horig = (tmTop->hbrmin-MINBRT)/HISTEP;
- hlen = (tmTop->hbrmax-MINBRT)/HISTEP + 1 - horig;
+ horig = (tms->hbrmin-MINBRT)/HISTEP;
+ hlen = (tms->hbrmax-MINBRT)/HISTEP + 1 - horig;
if (hlen > oldlen) { /* (re)allocate histogram */
- register int *newhist = (int *)calloc(hlen, sizeof(int));
+ int *newhist = (int *)calloc(hlen, sizeof(int));
if (newhist == NULL)
returnErr(TM_E_NOMEM);
if (oldlen) { /* copy and free old */
for (i = oldlen, j = i+oldorig-horig; i; )
- newhist[--j] = tmTop->histo[--i];
- free((MEM_PTR)tmTop->histo);
+ newhist[--j] = tms->histo[--i];
+ free((MEM_PTR)tms->histo);
}
- tmTop->histo = newhist;
+ tms->histo = newhist;
}
if (wt == 0)
returnOK;
for (i = len; i--; ) /* add in new counts */
if (ls[i] >= MINBRT)
- tmTop->histo[ (ls[i]-MINBRT)/HISTEP - horig ] += wt;
+ tms->histo[ (ls[i]-MINBRT)/HISTEP - horig ] += wt;
returnOK;
}
static double
-htcontrs(La) /* human threshold contrast sensitivity, dL(La) */
-double La;
+htcontrs( /* human threshold contrast sensitivity, dL(La) */
+double La
+)
{
double l10La, l10dL;
/* formula taken from Ferwerda et al. [SG96] */
@@ -392,102 +366,108 @@ double La;
static int
-tmNewMap()
+tmNewMap( /* allocate new tone-mapping array */
+TMstruct *tms
+)
{
- if (tmTop->lumap != NULL && (tmTop->mbrmax - tmTop->mbrmin) !=
- (tmTop->hbrmax - tmTop->hbrmin)) {
- free((MEM_PTR)tmTop->lumap);
- tmTop->lumap = NULL;
+ if (tms->lumap != NULL && (tms->mbrmax - tms->mbrmin) !=
+ (tms->hbrmax - tms->hbrmin)) {
+ free((MEM_PTR)tms->lumap);
+ tms->lumap = NULL;
}
- tmTop->mbrmin = tmTop->hbrmin;
- tmTop->mbrmax = tmTop->hbrmax;
- if (tmTop->mbrmin > tmTop->mbrmax)
+ tms->mbrmin = tms->hbrmin;
+ tms->mbrmax = tms->hbrmax;
+ if (tms->mbrmin > tms->mbrmax)
return 0;
- if (tmTop->lumap == NULL)
- tmTop->lumap = (unsigned short *)malloc(sizeof(unsigned short)*
- (tmTop->mbrmax-tmTop->mbrmin+1));
- return(tmTop->lumap != NULL);
+ if (tms->lumap == NULL)
+ tms->lumap = (unsigned short *)malloc(sizeof(unsigned short)*
+ (tms->mbrmax-tms->mbrmin+1));
+ return(tms->lumap != NULL);
}
int
-tmFixedMapping(expmult, gamval)
-double expmult;
-double gamval;
+tmFixedMapping( /* compute fixed, linear tone-mapping */
+TMstruct *tms,
+double expmult,
+double gamval
+)
{
- static char funcName[] = "tmFixedMapping";
+ static const char funcName[] = "tmFixedMapping";
double d;
- register int i;
+ int i;
- if (!tmNewMap())
+ if (!tmNewMap(tms))
returnErr(TM_E_NOMEM);
if (expmult <= .0)
expmult = 1.;
if (gamval < MINGAM)
- gamval = tmTop->mongam;
- d = log(expmult/tmTop->inpsf);
- for (i = tmTop->mbrmax-tmTop->mbrmin+1; i--; )
- tmTop->lumap[i] = 256. * exp(
- ( d + (tmTop->mbrmin+i)*(1./TM_BRTSCALE) )
+ gamval = tms->mongam;
+ d = log(expmult/tms->inpsf);
+ for (i = tms->mbrmax-tms->mbrmin+1; i--; )
+ tms->lumap[i] = 256. * exp(
+ ( d + (tms->mbrmin+i)*(1./TM_BRTSCALE) )
/ gamval );
returnOK;
}
int
-tmComputeMapping(gamval, Lddyn, Ldmax)
-double gamval;
-double Lddyn;
-double Ldmax;
+tmComputeMapping( /* compute histogram tone-mapping */
+TMstruct *tms,
+double gamval,
+double Lddyn,
+double Ldmax
+)
{
- static char funcName[] = "tmComputeMapping";
+ static const char funcName[] = "tmComputeMapping";
int *histo;
float *cumf;
int brt0, histlen, threshold, ceiling, trimmings;
double logLddyn, Ldmin, Ldavg, Lwavg, Tr, Lw, Ld;
- int4 histot;
+ int32 histot;
double sum;
- register double d;
- register int i, j;
+ double d;
+ int i, j;
- if (tmTop == NULL || tmTop->histo == NULL)
+ if (tms == NULL || tms->histo == NULL)
returnErr(TM_E_TMINVAL);
/* check arguments */
if (Lddyn < MINLDDYN) Lddyn = DEFLDDYN;
if (Ldmax < MINLDMAX) Ldmax = DEFLDMAX;
- if (gamval < MINGAM) gamval = tmTop->mongam;
+ if (gamval < MINGAM) gamval = tms->mongam;
/* compute handy values */
Ldmin = Ldmax/Lddyn;
logLddyn = log(Lddyn);
Ldavg = sqrt(Ldmax*Ldmin);
- i = (tmTop->hbrmin-MINBRT)/HISTEP;
+ i = (tms->hbrmin-MINBRT)/HISTEP;
brt0 = MINBRT + HISTEP/2 + i*HISTEP;
- histlen = (tmTop->hbrmax-MINBRT)/HISTEP + 1 - i;
+ histlen = (tms->hbrmax-MINBRT)/HISTEP + 1 - i;
/* histogram total and mean */
histot = 0; sum = 0;
j = brt0 + histlen*HISTEP;
for (i = histlen; i--; ) {
- histot += tmTop->histo[i];
- sum += (j -= HISTEP) * tmTop->histo[i];
+ histot += tms->histo[i];
+ sum += (j -= HISTEP) * tms->histo[i];
}
- threshold = histot*.025 + .5;
+ threshold = histot*0.005 + .5;
if (threshold < 4)
returnErr(TM_E_TMFAIL);
Lwavg = tmLuminance( (double)sum / histot );
/* allocate space for mapping */
- if (!tmNewMap())
+ if (!tmNewMap(tms))
returnErr(TM_E_NOMEM);
/* use linear tone mapping? */
- if (tmTop->flags & TM_F_LINEAR)
+ if (tms->flags & TM_F_LINEAR)
goto linearmap;
/* clamp histogram */
histo = (int *)malloc(histlen*sizeof(int));
cumf = (float *)malloc((histlen+2)*sizeof(float));
- if (histo == NULL | cumf == NULL)
+ if ((histo == NULL) | (cumf == NULL))
returnErr(TM_E_NOMEM);
cumf[histlen+1] = 1.; /* guard for assignment code */
for (i = histlen; i--; ) /* make malleable copy */
- histo[i] = tmTop->histo[i];
+ histo[i] = tms->histo[i];
do { /* iterate to solution */
sum = 0; /* cumulative probability */
for (i = 0; i < histlen; i++) {
@@ -495,12 +475,12 @@ double Ldmax;
sum += histo[i];
}
cumf[histlen] = 1.;
- Tr = histot * (double)(tmTop->hbrmax - tmTop->hbrmin) /
+ Tr = histot * (double)(tms->hbrmax - tms->hbrmin) /
((double)histlen*TM_BRTSCALE) / logLddyn;
ceiling = Tr + 1.;
trimmings = 0; /* clip to envelope */
for (i = histlen; i--; ) {
- if (tmTop->flags & TM_F_HCONTR) {
+ if (tms->flags & TM_F_HCONTR) {
Lw = tmLuminance(brt0 + i*HISTEP);
Ld = Ldmin * exp( logLddyn *
.5*(cumf[i]+cumf[i+1]) );
@@ -520,55 +500,57 @@ double Ldmax;
}
} while (trimmings > threshold);
/* assign tone-mapping */
- for (i = tmTop->mbrmax-tmTop->mbrmin+1; i--; ) {
- j = d = (double)i/(tmTop->mbrmax-tmTop->mbrmin)*histlen;
+ for (i = tms->mbrmax-tms->mbrmin+1; i--; ) {
+ j = d = (double)i/(tms->mbrmax-tms->mbrmin)*histlen;
d -= (double)j;
Ld = Ldmin*exp(logLddyn*((1.-d)*cumf[j]+d*cumf[j+1]));
d = (Ld - Ldmin)/(Ldmax - Ldmin);
- tmTop->lumap[i] = 256.*pow(d, 1./gamval);
+ tms->lumap[i] = 256.*pow(d, 1./gamval);
}
free((MEM_PTR)histo); /* clean up and return */
free((MEM_PTR)cumf);
returnOK;
linearmap: /* linear tone-mapping */
- if (tmTop->flags & TM_F_HCONTR)
+ if (tms->flags & TM_F_HCONTR)
d = htcontrs(Ldavg) / htcontrs(Lwavg);
else
d = Ldavg / Lwavg;
- return(tmFixedMapping(tmTop->inpsf*d/Ldmax, gamval));
+ return(tmFixedMapping(tms, tms->inpsf*d/Ldmax, gamval));
}
int
-tmMapPixels(ps, ls, cs, len)
-register BYTE *ps;
-TMbright *ls;
-register BYTE *cs;
-int len;
+tmMapPixels( /* apply tone-mapping to pixel(s) */
+TMstruct *tms,
+BYTE *ps,
+TMbright *ls,
+BYTE *cs,
+int len
+)
{
- static char funcName[] = "tmMapPixels";
- register int4 li, pv;
+ static const char funcName[] = "tmMapPixels";
+ int32 li, pv;
- if (tmTop == NULL || tmTop->lumap == NULL)
+ if (tms == NULL || tms->lumap == NULL)
returnErr(TM_E_TMINVAL);
- if (ps == NULL | ls == NULL | len < 0)
+ if ((ps == NULL) | (ls == NULL) | (len < 0))
returnErr(TM_E_ILLEGAL);
while (len--) {
- if ((li = *ls++) < tmTop->mbrmin) {
+ if ((li = *ls++) < tms->mbrmin) {
li = 0;
} else {
- if (li > tmTop->mbrmax)
- li = tmTop->mbrmax;
- li = tmTop->lumap[li - tmTop->mbrmin];
+ if (li > tms->mbrmax)
+ li = tms->mbrmax;
+ li = tms->lumap[li - tms->mbrmin];
}
if (cs == TM_NOCHROM)
*ps++ = li>255 ? 255 : li;
else {
- pv = *cs++ * li / tmTop->cdiv[RED];
+ pv = *cs++ * li / tms->cdiv[RED];
*ps++ = pv>255 ? 255 : pv;
- pv = *cs++ * li / tmTop->cdiv[GRN];
+ pv = *cs++ * li / tms->cdiv[GRN];
*ps++ = pv>255 ? 255 : pv;
- pv = *cs++ * li / tmTop->cdiv[BLU];
+ pv = *cs++ * li / tms->cdiv[BLU];
*ps++ = pv>255 ? 255 : pv;
}
}
@@ -576,60 +558,30 @@ int len;
}
-struct tmStruct *
-tmPop() /* pop top tone mapping off stack */
-{
- register struct tmStruct *tms;
- if ((tms = tmTop) != NULL)
- tmTop = tms->tmprev;
- return(tms);
-}
-
-int
-tmPull(tms) /* pull a tone mapping from stack */
-register struct tmStruct *tms;
+TMstruct *
+tmDup( /* duplicate top tone mapping */
+TMstruct *tms
+)
{
- register struct tmStruct *tms2;
- /* special cases first */
- if (tms == NULL | tmTop == NULL)
- return(0);
- if (tms == tmTop) {
- tmTop = tms->tmprev;
- tms->tmprev = NULL;
- return(1);
- }
- for (tms2 = tmTop; tms2->tmprev != NULL; tms2 = tms2->tmprev)
- if (tms == tms2->tmprev) { /* remove it */
- tms2->tmprev = tms->tmprev;
- tms->tmprev = NULL;
- return(1);
- }
- return(0); /* not found on stack */
-}
-
-
-struct tmStruct *
-tmDup() /* duplicate top tone mapping */
-{
int len;
- register int i;
- register struct tmStruct *tmnew;
+ int i;
+ TMstruct *tmnew;
- if (tmTop == NULL) /* anything to duplicate? */
+ if (tms == NULL) /* anything to duplicate? */
return(NULL);
- tmnew = (struct tmStruct *)malloc(sizeof(struct tmStruct));
+ tmnew = (TMstruct *)malloc(sizeof(TMstruct));
if (tmnew == NULL)
return(NULL);
- *tmnew = *tmTop; /* copy everything */
+ *tmnew = *tms; /* copy everything */
if (tmnew->histo != NULL) { /* duplicate histogram */
len = (tmnew->hbrmax-MINBRT)/HISTEP + 1 -
(tmnew->hbrmin-MINBRT)/HISTEP;
tmnew->histo = (int *)malloc(len*sizeof(int));
if (tmnew->histo != NULL)
for (i = len; i--; )
- tmnew->histo[i] = tmTop->histo[i];
+ tmnew->histo[i] = tms->histo[i];
}
if (tmnew->lumap != NULL) { /* duplicate luminance mapping */
len = tmnew->mbrmax-tmnew->mbrmin+1;
@@ -637,45 +589,24 @@ tmDup() /* duplicate top tone mapping */
len*sizeof(unsigned short) );
if (tmnew->lumap != NULL)
for (i = len; i--; )
- tmnew->lumap[i] = tmTop->lumap[i];
+ tmnew->lumap[i] = tms->lumap[i];
}
/* clear package data */
for (i = tmNumPkgs; i--; )
tmnew->pd[i] = NULL;
- tmnew->tmprev = tmTop; /* make copy current */
- return(tmTop = tmnew);
+ /* return copy */
+ return(tmnew);
}
-int
-tmPush(tms) /* push tone mapping on top of stack */
-register struct tmStruct *tms;
-{
- static char funcName[] = "tmPush";
- /* check validity */
- if (tms == NULL)
- returnErr(TM_E_ILLEGAL);
- if (tms == tmTop) /* check necessity */
- returnOK;
- /* pull if already in stack */
- (void)tmPull(tms);
- /* push it on top */
- tms->tmprev = tmTop;
- tmTop = tms;
- returnOK;
-}
-
-
void
tmDone(tms) /* done with tone mapping -- destroy it */
-register struct tmStruct *tms;
+TMstruct *tms;
{
- register int i;
- /* NULL arg. is equiv. to tmTop */
- if (tms == NULL && (tms = tmTop) == NULL)
+ int i;
+ /* NULL arg. is equiv. to tms */
+ if (tms == NULL)
return;
- /* take out of stack if present */
- (void)tmPull(tms);
/* free tables */
if (tms->histo != NULL)
free((MEM_PTR)tms->histo);
@@ -695,7 +626,7 @@ BYTE tmMesofact[BMESUPPER-BMESLOWER];
void
tmMkMesofact() /* build mesopic lookup factor table */
{
- register int i;
+ int i;
if (tmMesofact[BMESUPPER-BMESLOWER-1])
return;
@@ -708,14 +639,18 @@ tmMkMesofact() /* build mesopic lookup factor table
int
-tmErrorReturn(func, err) /* error return (with message) */
-char *func;
-int err;
+tmErrorReturn( /* error return (with message) */
+const char *func,
+TMstruct *tms,
+int err
+)
{
- tmLastFunction = func;
- tmLastError = err;
- if (tmTop != NULL && tmTop->flags & TM_F_NOSTDERR)
- return(err);
+ if (tms != NULL) {
+ tms->lastFunc = func;
+ tms->lastError = err;
+ if (tms->flags & TM_F_NOSTDERR)
+ return(err);
+ }
fputs(func, stderr);
fputs(": ", stderr);
fputs(tmErrorMessage[err], stderr);