Homec4science
Diffusion RADIANCE Photon Map (pmapmerge) Browse

RadiancePmap/mrgbe.c
be0a78356c8bpmapmerge

Last Change
Raw File

mrgbe.c
View Options

/*
=========================================================================
mRGBE (miniRGBE): reduced RGBE encoding of normalised RGB floats plus
associated integer payload data. See mrgbe.h for encoding details.
Compile with -DmRGBE_TEST to enable unit test (requires libm)
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 "mrgbe.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))
mRGBERange *mRGBEinit (mRGBERange *range,
double rgbMin [3], double rgbMax [3]
)
/* Initialise range state for mRGBEencode()/mRGBEdecode() with the specified
* float input ranges [rgbMin, rgbMax] in _absolute_ values per colour
* channel. This sets the offset and normalisation for the encoding. */
{
unsigned i;
for (i = 0; i < 3; i++) {
range -> min [i] = rgbMin [i];
range -> max [i] = rgbMax [i];
if (rgbMin [i] >= rgbMax [i]) {
fprintf(stderr, "ERROR - invalid mRGBE range\n");
return NULL;
}
range -> norm [i] = mRGBE_RANGE / (rgbMax [i] - rgbMin [i]);
if (range -> norm [i] < mRGBE_MIN) {
fprintf(stderr, "ERROR - Zero mRGBE normalisation\n");
return NULL;
}
}
return range;
}
mRGBE mRGBEencode (double rgb [3], const mRGBERange *range, unsigned data)
/* Encode signed float RGB tuple to mRGBE along with payload data. The
* supplied range state must be previously initialised with mRGBEinit().
* A warning is issued if rgb lies outside the initialised range. */
{
#define sgn(a, b) ((a) >= 0 ? (b) : -(b))
mRGBE mrgbe = {0, 0, 0, 0};
double rgbRange [3], rgbNorm [3], mantNorm;
int i, exp;
/* Check payload data */
if (data > mRGBE_DATAMAX) {
fprintf(stderr, "ERROR - mRGBE data overflow");
return mrgbe;
}
if (!range) {
fprintf(stderr, "ERROR - mRGBE range not initialised\n");
return mrgbe;
}
/* Offset and normalise RGB according to initialised range; note rgbNorm
* is in ABSOLUTE VALUES */
for (i = 0; i < 3; i++) {
rgbNorm [i] = fabs(rgb [i]);
/* Check range */
if (rgbNorm [i] < range -> min [i] || rgbNorm [i] > range -> max [i]) {
fprintf(stderr, "ERROR - mRGBE input outside range\n");
return mrgbe;
}
rgbNorm [i] = (rgbNorm [i] - range -> min [i]) * range -> norm [i];
if (fabs(rgbNorm [i] - mRGBE_MAX) < mRGBE_MIN)
/* Normalisation to maxmimum. This must be avoided by offsetting
by minimum, otherwise frexp() returns a positive exponent.
Normalisation to >mRGBE_MAX is caught by overflow check below */
rgbNorm [i] = mRGBE_RANGE;
}
/* Mantissa normalisation factor (= RGB maximum) */
mantNorm = max(max(rgbNorm [0], rgbNorm [1]), rgbNorm [2]);
/* Get normalised mantissa and exponent to base 2 */
mantNorm = mantNorm < mRGBE_MIN
? 0 : frexp(mantNorm, &exp) * mRGBE_MANTMAX / mantNorm;
/* Set RGB integer mantissas, adding excess (zero offset) and rounding
up or down, depending on sign. Set sign according to original value.
Clamp to mRGBE_MANTOVF to prevent rounding beyond overflow into
negative! */
mrgbe.red = min(
(int)(sgn(rgb [0], rgbNorm [0] * mantNorm + 0.5) + mRGBE_MANTMAX),
mRGBE_MANTOVF
);
mrgbe.grn = min(
(int)(sgn(rgb [1], rgbNorm [1] * mantNorm + 0.5) + mRGBE_MANTMAX),
mRGBE_MANTOVF
);
mrgbe.blu = min(
(int)(sgn(rgb [2], rgbNorm [2] * mantNorm + 0.5) + mRGBE_MANTMAX),
mRGBE_MANTOVF
);
/* Drop the exponent sign, since implicitly negative */
mrgbe.exp = abs(exp);
/* Set payload data */
mrgbe.dat = data;
return mrgbe;
#undef sgn
}
unsigned mRGBEdecode (mRGBE mrgbe, const mRGBERange *range, double rgb [3])
/* Decode mRGBE, returning signed float RGB tuple in array rgb. The
* associated payload data is decoded as return value. The supplied range
* state must be previously initialised with mRGBEinit(). */
{
#define sgn(a, b) ((a) >= mRGBE_MANTMAX ? (b) : -(b))
double mantNorm;
if (!range) {
fprintf(stderr, "ERROR - mRGBE range not initialised\n");
return 0;
}
/* Mantissa normalisation factor; exponent is implicitly negative */
mantNorm = ldexp(1.0, -mrgbe.exp) / mRGBE_MANTMAX;
/* Decode and set RGB components, subtracting excess (zero offset) and
* adding jitter to break up quantisation artefacts. Clamp to -mRGBE_MAX
* in case jitter underflows. Finally denormalise and offset to original
* range with saved state. */
rgb [0] = max(
(mrgbe.red - mRGBE_MANTMAX - sgn(mrgbe.red, 0.5 * drand48())) *
mantNorm / range -> norm [0] + sgn(mrgbe.red, range -> min[0]),
-mRGBE_MAX
);
rgb [1] = max(
(mrgbe.grn - mRGBE_MANTMAX - sgn(mrgbe.grn, 0.5 * drand48())) *
mantNorm / range -> norm [1] + sgn(mrgbe.grn, range -> min [1]),
-mRGBE_MAX
);
rgb [2] = max(
(mrgbe.blu - mRGBE_MANTMAX - sgn(mrgbe.blu, 0.5 * drand48())) *
mantNorm / range -> norm [2] + sgn(mrgbe.blu, range -> min [2]),
-mRGBE_MAX
);
/* Return payload data */
return mrgbe.dat;
#undef sgn
}
#ifdef mRGBE_TEST
/* Build standalone to run unit test */
#define RGBMIN 0.5
#define RGBMAX 1
int main (int argc, char **argv)
{
double rgb [3] = {0, 0, 0}, rgbDec [3],
rgbMin [3] = {0, 0, 0}, rgbMax [3] = {1, 1, 1},
rgbAbs, relDiff, rmse, rmseSum;
unsigned numTests, i, j, k, data, dataDec;
const short rndState0 [3] = {11, 23, 31};
short encFlag = 0, rndState [3];
mRGBERange mrgbeRange;
mRGBE mrgbe;
#if 0
rgb [0] = 0.1999;
rgb [1] = 0.0751;
rgb [2] = 0.0367;
rgbMin [0] = 0.190;
rgbMin [1] = 0.070;
rgbMin [2] = 0.030;
rgbMax [0] = 0.983;
rgbMax [1] = 0.452;
rgbMax [2] = 0.737;
mRGBEinit(&mrgbeRange, rgbMin, rgbMax);
mrgbe = mRGBEencode(rgb, &mrgbeRange, 0);
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], 0,
mrgbe.red, mrgbe.grn, mrgbe.blu, mrgbe.exp
);
/* Decode */
dataDec = mRGBEdecode(mrgbe, &mrgbeRange, rgbDec);
for (j = rmse = 0; j < 3; j++) {
relDiff = 1 - rgbDec [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",
rgbDec [0], rgbDec [1], rgbDec [2],
dataDec, 100 * rmse
);
return 0;
#endif
if (argc > 1 && (numTests = atoi(argv [1])) > 0) {
/* Test range checks */
mRGBEinit(&mrgbeRange, rgbMin, rgbMax);
puts("Check data overflow");
rgb [0] = rgb [1] = rgb [2] = mRGBE_MAX / 2;
mRGBEencode(rgb, &mrgbeRange, mRGBE_DATAMAX << 1);
puts("\nCheck underflow");
rgb [0] = rgb [1] = rgb [2] = mRGBE_MIN / 2;
mRGBEencode(rgb, &mrgbeRange, 0);
puts("\nCheck overflow (positive)");
rgb [0] = rgb [1] = rgb [2] = 2 * mRGBE_MAX;
mRGBEencode(rgb, &mrgbeRange, 0);
puts("\nCheck overflow (negative)");
rgb [0] = rgb [1] = rgb [2] = -2 * mRGBE_MAX;
mRGBEencode(rgb, &mrgbeRange, 0);
puts("\nCheck empty range");
rgbMax [0] = rgbMax [1] = rgbMax [2] = 0;
mRGBEinit(&mrgbeRange, rgbMin, rgbMax);
putchar('\n');
rgbMin [0] = rgbMin [1] = rgbMin [2] = RGBMAX;
rgbMax [0] = rgbMax [1] = rgbMax [2] = RGBMIN;
/* Iterate twice with same random RGB tuples; gather minimum and
* maximum in 1st pass, then initialise and run encode/decode tests
* in 2nd pass. */
do {
/* Initialise RNG state so this can be restored to obtain the
same RGB tuple sequence in both passes. This state needs to
be kept separate from the RNG used for jittering in the
encode/decode routines. */
for (i = 0; i < 3; i++)
rndState [i] = rndState0 [i];
/* Random encode vs. decode */
for (k = 0, rmseSum = 0; k < numTests; k++) {
data = (unsigned)(mRGBE_DATAMAX * erand48(rndState));
for (i = 0; i < 3; i++) {
rgb [i] = (erand48(rndState) > 0.5 ? 1 : -1) *
((RGBMAX - RGBMIN) * erand48(rndState) + RGBMIN);
#if 0
/* Correlate RGB */
if (i > 0)
rgb [i] = rgb [0] * (0.1 + 0.9 * erand48(rndState));
#endif
}
if (encFlag) {
/* Encode */
mrgbe = mRGBEencode(rgb, &mrgbeRange, data);
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], data,
mrgbe.red, mrgbe.grn, mrgbe.blu, mrgbe.exp
);
/* Decode */
dataDec = mRGBEdecode(mrgbe, &mrgbeRange, rgbDec);
for (j = rmse = 0; j < 3; j++) {
relDiff = 1 - rgbDec [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",
rgbDec [0], rgbDec [1], rgbDec [2],
dataDec, 100 * rmse
);
}
else {
/* Update RGB minimum and maximum */
for (i = 0; i < 3; i++) {
rgbAbs = fabs(rgb [i]);
if (rgbAbs > rgbMax [i])
rgbMax [i] = rgbAbs;
if (rgbAbs < rgbMin [i])
rgbMin [i] = rgbAbs;
}
}
}
/* Dump results */
if (!encFlag) {
/* Initialise mRGBE encoding state with min/max */
if (!mRGBEinit(&mrgbeRange, rgbMin, rgbMax))
return -1;
printf(
"RGB Range = [%.3f, %.3f, %.3f] - [%.3f, %.3f, %.3f]\n\n",
rgbMin [0], rgbMin [1], rgbMin [2],
rgbMax [0], rgbMax [1], rgbMax [2]
);
}
else printf("\nAvg RMSE = %.1f%%\n", 100 * rmseSum / numTests);
} while (encFlag = !encFlag);
return 0;
}
else {
printf("Usage: %s <numTests>\n", argv [0]);
return -1;
}
}
#endif
c4science · Help