Homec4science
Diffusion RADIANCE Photon Map (pmapmerge) Browse

RadiancePmap/rgbecontrib.c
73332c190648pmapmerge

Last Change
Raw File

rgbecontrib.c
View Options

/*
=========================================================================
Routines to encode/decode RGBE representation of normalised binned
contributions. See rgbecontrib.h for encoding details.
Compile with -D_RGBE_CONTRIB_TEST to enable unit test.
Roland Schregle (roland.schregle@{hslu.ch, gmail.com})
(c) Lucerne University of Applied Sciences and Arts,
supported by the Swiss National Science Foundation
(SNSF #179067, "Light Fields for Spatio-Temporal Glare Assessment")
=========================================================================
$Id$
*/
#include "rgbecontrib.h"
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
RGBEContrib RGBEContribEnc (double rgb [3], unsigned bin)
/* Encode signed float RGB contributions with associated bin to RGBE. */
{
#define absMax(a, b) (fabs(a) > fabs(b) ? a : b)
#define sgn(a) ((a) >= 0 ? 1 : -1)
/* RGB maximum for mantissa normalisation */
double mantNorm = absMax(absMax(rgb [0], rgb [1]), rgb [2]);
int exp;
RGBEContrib rgbeCont = {0, 0, 0, 0};
/* Check and set bin */
if (bin > RGBE_CONTRIB_MAXBIN) {
fprintf(stderr, "WARNING - RGBEContrib bin overflow\n");
return rgbeCont;
}
else
rgbeCont.bin = bin;
/* Check RGB range */
if (fabs(mantNorm) < RGBE_CONTRIB_MIN) {
/* Below encoding range, clamp to zero */
fprintf(stderr, "WARNING - RGBEContrib underflow, clamping to 0\n");
return rgbeCont;
}
if (fabs(mantNorm) > RGBE_CONTRIB_MAX) {
/* Exceeds encoding range, clamp to maximum */
fprintf(
stderr,
"WARNING - RGBEContrib overflow, clamping to %d\n", sgn(mantNorm)
);
rgbeCont.red = rgbeCont.grn = rgbeCont.blu =
sgn(mantNorm) * ((1 << RGBE_CONTRIB_MAXMANT) - 1);
return rgbeCont;
}
/* Get normalised mantissa and exponent to base 2 */
mantNorm = frexp(mantNorm, &exp) * RGBE_CONTRIB_MAXMANT / mantNorm;
/* Set RGB integer mantissas, rounding up or down depending on sign, and
* add excess (zero offset) */
rgbeCont.red = (int)(
rgb [0] * mantNorm + 0.5 * sgn(rgb [0]) + RGBE_CONTRIB_MAXMANT
);
rgbeCont.grn = (int)(
rgb [1] * mantNorm + 0.5 * sgn(rgb [1]) + RGBE_CONTRIB_MAXMANT
);
rgbeCont.blu = (int)(
rgb [2] * mantNorm + 0.5 * sgn(rgb [2]) + RGBE_CONTRIB_MAXMANT
);
/* Drop the exponent sign, since implicitly negative */
rgbeCont.exp = abs(exp);
return rgbeCont;
#undef sgn
#undef absMax
}
unsigned RGBEContribDec (RGBEContrib rgbeCont, double rgb [3])
/* Decode rgbeCont, returning signed floating point contributions in array
* rgb, and the associated bin as return value */
{
#define sgn(a) ((a) < RGBE_CONTRIB_MAXMANT ? -1 : 1)
//#define sgn(a) 0
/* Normalisation factor for RGB; note exponent is implicitly negative */
const double mantNorm = ldexp(1.0, -rgbeCont.exp) / RGBE_CONTRIB_MAXMANT;
/* Decode and set RGB components, subtracting excess (zero offset) */
rgb [0] = mantNorm * (
rgbeCont.red - 0.5 * sgn(rgbeCont.red) - RGBE_CONTRIB_MAXMANT
);
rgb [1] = mantNorm * (
rgbeCont.grn - 0.5 * sgn(rgbeCont.grn) - RGBE_CONTRIB_MAXMANT
);
rgb [2] = mantNorm * (
rgbeCont.blu - 0.5 * sgn(rgbeCont.blu) - RGBE_CONTRIB_MAXMANT
);
/* Return bin */
return rgbeCont.bin;
#undef sgn
}
#ifdef _RGBE_CONTRIB_TEST
/* Build standalone to run unit test */
int main (int argc, char **argv)
{
double rgb [3] = {0, 0, 0}, irgb [3], relDiff, rmse, rmseSum;
unsigned numTests, i, j, k, bin, ibin;
RGBEContrib rgbeCont;
/* Test range checks */
RGBEContribEnc(rgb, RGBE_CONTRIB_MAXBIN << 1);
rgb [0] = RGBE_CONTRIB_MIN / 2;
RGBEContribEnc(rgb, 0);
rgb [0] = 2;
RGBEContribEnc(rgb, 0);
rgb [0] = -2;
RGBEContribEnc(rgb, 0);
if (argc > 1 && (numTests = atoi(argv [1])) > 0) {
/* Random encode vs. decode */
srand48(111);
for (k = 0, rmseSum = 0; k < numTests; k++) {
bin = (unsigned)(RGBE_CONTRIB_MAXBIN * drand48());
for (i = 0; i < 3; i++)
rgb [i] = 2 * drand48() - 1;
/* Encode */
rgbeCont = RGBEContribEnc(rgb, bin);
printf(
"% 7.4f\t% 7.4f\t% 7.4f\t%4d\t--> %08x\t--> ",
rgb [0], rgb [1], rgb [2], bin, rgbeCont.rgbeBin
);
/* Decode */
ibin = RGBEContribDec(rgbeCont, irgb);
for (j = rmse = 0; j < 3; j++) {
relDiff = 1 - irgb [j] / rgb [j];
rmse += relDiff * relDiff;
}
rmseSum += rmse = sqrt(rmse / 3);
printf(
"% 7.4f\t% 7.4f\t% 7.4f\t%4d\tRMSE = %.1f%%\n",
irgb [0], irgb [1], irgb [2], ibin, 100 * rmse
);
}
printf("\nAvg RMSE = %.1f%%\n", 100 * rmseSum / numTests);
}
return 0;
}
#endif
c4science · Help