Homec4science
Diffusion RADIANCE Photon Map (pmapmerge) Browse

RadiancePmap/rgbecontrib.c
9af7c1af6f96pmapmerge

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>
#define min(a,b) ((a) < (b) ? (a) : (b))
#define max(a,b) ((a) > (b) ? (a) : (b))
RGBEContrib RGBEContribEnc (double rgb [3], unsigned bin)
/* Encode signed float RGB contributions with associated bin to RGBE. */
{
#define sgn(a) ((a) >= 0 ? 1.0 : -1.0)
/* RGB maximum for mantissa normalisation */
double mantNorm = max(
max(fabs(rgb [0]), fabs(rgb [1])),
fabs(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 (mantNorm < RGBE_CONTRIB_MIN) {
/* Below encoding range, clamp to zero */
fprintf(stderr, "WARNING - RGBEContrib underflow, clamping to 0\n");
return rgbeCont;
}
if (mantNorm > RGBE_CONTRIB_MAX) {
/* Exceeds encoding range, clamp to maximum */
fprintf(
stderr, "WARNING - RGBEContrib overflow, clamping to +/-%.1f\n",
RGBE_CONTRIB_MAX
);
rgbeCont.red = (1 + sgn(rgb [0])) * RGBE_CONTRIB_MAXMANT;
rgbeCont.grn = (1 + sgn(rgb [1])) * RGBE_CONTRIB_MAXMANT;
rgbeCont.blu = (1 + sgn(rgb [2])) * RGBE_CONTRIB_MAXMANT;
return rgbeCont;
}
/* Get normalised mantissa and exponent to base 2 */
mantNorm = frexp(mantNorm, &exp) * RGBE_CONTRIB_MAXMANT / mantNorm;
/* Set RGB integer mantissas, adding excess (zero offset) and rounding
up or down, depending on sign. Clamp to RGBE_CONTRIB_MANTOVF to
prevent rounding beyond overflow into negative. */
rgbeCont.red = min(
(int)(rgb [0] * mantNorm + RGBE_CONTRIB_MAXMANT + 0.5),
RGBE_CONTRIB_MANTOVF
);
rgbeCont.grn = min(
(int)(rgb [1] * mantNorm + RGBE_CONTRIB_MAXMANT + 0.5),
RGBE_CONTRIB_MANTOVF
);
rgbeCont.blu = min(
(int)(rgb [2] * mantNorm + RGBE_CONTRIB_MAXMANT + 0.5),
RGBE_CONTRIB_MANTOVF
);
/* Drop the exponent sign, since implicitly negative */
rgbeCont.exp = abs(exp);
return rgbeCont;
#undef sgn
}
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 hSgn(a) ((a) > RGBE_CONTRIB_MAXMANT ? 0.1 : -0.1)
/* 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) and
* adding some jitter to break up quantisation artefacts.
* Clamp to -RGBE_CONTRIB_MAX (-1) in case jitter underflows. */
rgb [0] = max(
mantNorm * (
rgbeCont.red - RGBE_CONTRIB_MAXMANT + drand48() * hSgn(rgbeCont.red)
),
-RGBE_CONTRIB_MAX
);
rgb [1] = max(
mantNorm * (
rgbeCont.grn - RGBE_CONTRIB_MAXMANT + drand48() * hSgn(rgbeCont.grn)
),
-RGBE_CONTRIB_MAX
);
rgb [2] = max(
mantNorm * (
rgbeCont.blu - RGBE_CONTRIB_MAXMANT + drand48() * hSgn(rgbeCont.blu)
),
-RGBE_CONTRIB_MAX
);
/* Return bin */
return rgbeCont.bin;
#undef hSgn
}
#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());
#if 1
for (i = 0; i < 3; i++) {
if (i > 0)
/* Correlate RGB */
rgb [i] = rgb [0] * (0.1 + 0.9 * drand48());
else
rgb [i] = 2 * drand48() - 1;
}
#else
#if 1
rgb [0] = rgb [1] = rgb [2] = 2 * drand48() - 1;
#else
rgb [0] = 0.9772;
rgb [1] = 0.4369;
rgb [2] = 0.1869;
#endif
#endif
/* Encode */
rgbeCont = RGBEContribEnc(rgb, bin);
printf(
"% 7.4f\t% 7.4f\t% 7.4f\t%4d\t-->\t"
"%02d:%02d:%02d:%02d\t-->\t",
rgb [0], rgb [1], rgb [2], bin,
rgbeCont.red, rgbeCont.grn, rgbeCont.blu, rgbeCont.exp
);
/* 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