Homec4science
Diffusion RADIANCE Photon Map (fixSpecular) Browse

RadiancePmap/pmapdata.h
2aaded38bceafixSpecular

Last Change
Raw File

pmapdata.h
View Options

/* RCSid $Id: pmapdata.h,v 2.14 2020/04/08 15:14:21 rschregle Exp $ */
/*
=========================================================================
Photon map types and interface to nearest neighbour lookups in underlying
point cloud data structure.
The default data structure is an in-core kd-tree (see pmapkdt.{h,c}).
This can be overriden with the PMAP_OOC compiletime switch, which enables
an out-of-core octree (see oococt.{h,c}).
Defining PMAP_FLOAT_FLUX stores photon flux as floats rather than packed
RGBE for greater precision; this may be necessary when the flux differs
significantly in individual colour channels, e.g. with highly saturated
colours.
Roland Schregle (roland.schregle@{hslu.ch, gmail.com})
(c) Fraunhofer Institute for Solar Energy Systems,
supported by the German Research Foundation
(DFG LU-204/10-2, "Fassadenintegrierte Regelsysteme" (FARESYS))
(c) Lucerne University of Applied Sciences and Arts,
supported by the Swiss National Science Foundation
(SNSF #147053, "Daylight Redirecting Components",
SNSF #179067, "Light Fields for Spatio-Temporal Glare Assessment")
(c) Tokyo University of Science,
supported by the JSPS Grants-in-Aid for Scientific Research
(KAKENHI JP19KK0115, "Three-Dimensional Light Flow")
=========================================================================
$Id: pmapdata.h,v 2.14 2020/04/08 15:14:21 rschregle Exp $
*/
#ifndef PMAPDATA_H
#define PMAPDATA_H
#ifndef NIX
#if defined(_WIN32) || defined(_WIN64)
#define NIX 0
#else
#define NIX 1
#endif
#endif
#if (defined(PMAP_OOC) && !NIX)
#error "OOC currently only supported on NIX -- tuff luck."
#endif
#include "ray.h"
#include "pmaptype.h"
#include "paths.h"
#include "lookup.h"
#include <stdint.h>
/* Photon origin for light source contributions; these are only used
to precompute contribution photons. They are referenced by contribution
photons (see origin field in struct Photon below) in a surjective
mapping, since multiple photons may share the same origin if they
lie along its associated path. For this reason it is more efficient
to factor this data out of the photons themselves and consolidate
it here until the photons have been precomputed, after which it is
no longer needed. */
typedef struct {
int16 srcIdx, /* Index of emitting light source */
srcBin; /* Bin number corresponding to incident dir */
} PhotonContribOrigin;
#define photonSrcIdx(pm, p) ((pm) -> contribOrg \
? (pm) -> contribOrg [(p) -> org].srcIdx \
: (p) -> org\
)
#define photonSrcBin(pm, p) ((pm) -> contribOrg [(p) -> org].srcBin)
#define photonSrcMod(pm, p) findmaterial(source [photonSrcIdx(pm, p)].so)
/* General photon origin type and limit */
typedef uint32 PhotonOrigin;
#define PMAP_MAXORIGIN UINT32_MAX
/* Macros for photon's generating subprocess field */
#ifdef PMAP_OOC
#define PMAP_PROCBITS 7
#else
#define PMAP_PROCBITS 5
#endif
#define PMAP_MAXPROC (1 << PMAP_PROCBITS)
#define PMAP_GETRAYPROC(r) ((r) -> crtype >> 8)
#define PMAP_SETRAYPROC(r,p) ((r) -> crtype |= p << 8)
typedef struct {
float pos [3]; /* Photon position */
signed char norm [3]; /* Encoded normal / incident
direction [volume photons] */
union {
struct {
#ifndef PMAP_OOC
unsigned char discr : 2; /* kd-tree discriminator axis */
#endif
unsigned char caustic : 1; /* Specularly scattered (=caustic) */
/* Photon's generating subprocess index, used for primary ray
* index linearisation when building contrib pmaps; note this is
* reduced for kd-tree to accommodate the discriminator field */
unsigned char proc : PMAP_PROCBITS;
};
unsigned char flags;
};
/* Photon flux in watts or lumen /
photon contribution [contrib photons] /
average wavelet coefficient [precomputed contrib photons] */
#ifdef PMAP_FLOAT_FLUX
COLOR flux;
#else
COLR flux;
#endif
/* CONTRIB PHOTONS: index into photon map's contrib origin array.
OTHERS: photon path ID. */
PhotonOrigin org;
} Photon;
/* Define PMAP_FLOAT_FLUX to store photon flux as floats instead of
* compact RGBE, which was found to improve accuracy in analytical
* validation. */
#ifdef PMAP_FLOAT_FLUX
#define setPhotonFlux(p,f) copycolor((p) -> flux, f)
#define getPhotonFlux(p,f) copycolor(f, (p) -> flux)
#else
#define setPhotonFlux(p,f) setcolr((p)->flux, (f)[0], (f)[1], (f)[2])
#define getPhotonFlux(p,f) colr_color(f, (p) -> flux)
#endif
/* Bias compensation history node */
typedef struct {
COLOR irrad;
float weight;
} PhotonBiasCompNode;
/* Forward declaration */
struct PhotonMap;
/* Define search queue and underlying data struct types */
#ifdef PMAP_OOC
#include "pmapooc.h"
#else
#include "pmapkdt.h"
#endif
/* Mean size of heapfile write buffer, in number of photons */
#define PMAP_HEAPBUFSIZE 1e6
/* Mean idle time between heap locking attempts, in usec */
#define PMAP_HEAPBUFSLEEP 2e6
/* Temporary filename for photon heaps */
#define PMAP_TMPFNAME TEMPLATE
#define PMAP_TMPFNLEN (TEMPLEN + 1)
typedef struct PhotonMap {
PhotonMapType type; /* See pmaptype.h */
char *fileName; /* Photon map file */
/* ================================================================
* PRE/POST-BUILD STORAGE
* ================================================================ */
FILE *heap; /* Unsorted photon heap prior to
construction of store */
char heapFname [sizeof(PMAP_TMPFNAME)];
Photon *heapBuf; /* Write buffer for above */
unsigned long heapBufLen, /* Current & max size of heapBuf */
heapBufSize;
PhotonStorage store; /* Photon storage in space
subdividing data struct */
/* ================================================================
* PHOTON DISTRIBUTION STUFF
* ================================================================ */
unsigned long distribTarget, /* Num stored specified by user */
numPhotons; /* Num actually stored */
float distribRatio; /* Probability of photon storage */
COLOR photonFlux; /* Average photon flux */
unsigned short randState [3]; /* Local RNG state */
/* ================================================================
* PHOTON LOOKUP STUFF
* ================================================================ */
union { /* Flags passed to findPhotons() */
char lookupCaustic : 1;
char lookupFlags;
};
PhotonSearchQueue squeue; /* Search queue for photon lookups */
unsigned minGather, /* Specified min/max photons per */
maxGather; /* density estimate */
/* NOTE: All distances are SQUARED */
float maxDist2, /* Max search radius */
maxDist0, /* Initial value for above */
maxDist2Limit, /* Hard limit for above */
gatherTolerance; /* Fractional deviation from minGather/
maxGather for short lookup */
void (*lookup)(
struct PhotonMap*, RAY*, COLOR
); /* Callback for type-specific photon
* lookup (usually density estimate) */
#ifdef PMAP_PHOTONFLOW
LUTAB *pathLUT; /* Photon path lookup table to filter
volume photons */
char **pathLUTKeys; /* Preallocated buffer to store keys
for path lookup table */
unsigned numPathLUTKeys; /* Num keys currently in key buffer
(= next free entry at tail) */
#endif
/* ================================================================
* BIAS COMPENSATION STUFF
* ================================================================ */
PhotonBiasCompNode *biasCompHist; /* Bias compensation history */
/* ================================================================
* STATISTIX
* ================================================================ */
unsigned long totalGathered, /* Total photons gathered */
numDensity, /* Num density estimates */
numLookups, /* Counters for short photon lookups */
numShortLookups;
unsigned minGathered, /* Min/max photons actually gathered */
maxGathered, /* per density estimate */
shortLookupPct; /* % of short lookups for stats */
float minError, /* Min/max/rms density estimate error */
maxError,
rmsError,
CoGdist, /* Avg distance to centre of gravity */
maxPos [3], /* Max & min photon positions */
minPos [3];
FVECT CoG; /* Centre of gravity (avg photon pos) */
/* ================================================================
* CONTRIBUTION PHOTON STUFF
* ================================================================ */
PhotonContribOrigin *contribOrg, /* Contribution origin array */
lastContribOrg; /* Current contrib origin for
contrib photon distribution */
PhotonOrigin numContribOrg; /* Number of contrib origins */
LUTAB *srcContrib; /* LUT for source contribs */
} PhotonMap;
/* Photon maps by type (see PhotonMapType) */
extern PhotonMap *photonMaps [];
/* Macros for specific photon map types */
#define globalPmap (photonMaps [PMAP_TYPE_GLOBAL])
#define preCompPmap (photonMaps [PMAP_TYPE_PRECOMP])
#define causticPmap (photonMaps [PMAP_TYPE_CAUSTIC])
#define directPmap (photonMaps [PMAP_TYPE_DIRECT])
#define contribPmap (photonMaps [PMAP_TYPE_CONTRIB])
#ifdef PMAP_PHOTONFLOW
#define volumePmap ( \
lightFlowPmap ? lightFlowPmap : photonMaps [PMAP_TYPE_VOLUME] \
)
#define lightFlowPmap (photonMaps [PMAP_TYPE_LIGHTFLOW])
#else
#define volumePmap (photonMaps [PMAP_TYPE_VOLUME])
#endif
/* Photon map type tests */
#define isGlobalPmap(p) ((p) -> type == PMAP_TYPE_GLOBAL)
#define isCausticPmap(p) ((p) -> type == PMAP_TYPE_CAUSTIC)
#define isContribPmap(p) ((p) -> type == PMAP_TYPE_CONTRIB)
#ifdef PMAP_PHOTONFLOW
#define isVolumePmap(p) ( \
(p) -> type == PMAP_TYPE_VOLUME || isLightFlowPmap(p) \
)
#define isLightFlowPmap(p) ((p) -> type == PMAP_TYPE_LIGHTFLOW)
#else
#define isVolumePmap(p) ((p) -> type == PMAP_TYPE_VOLUME)
#endif
void initPhotonMap (PhotonMap *pmap, PhotonMapType t);
/* Initialise empty photon map of specified type */
int newPhoton (PhotonMap *pmap, const RAY *ray);
/* Create new photon with ray's direction, intersection point, and flux,
and append to unsorted photon heap pmap -> heap. The photon is
accepted with probability pmap -> distribRatio for global density
control; if the photon is rejected, -1 is returned, else 0. The flux
is scaled by ray -> rweight and 1 / pmap -> distribRatio. */
void initPhotonHeap (PhotonMap *pmap);
/* Open photon heap file */
void flushPhotonHeap (PhotonMap *pmap);
/* Flush photon heap buffa pmap -> heapBuf to heap file pmap -> heap;
* used by newPhoton() and to finalise heap in distribPhotons(). */
void buildPhotonMap (
PhotonMap *pmap, double *photonFlux, PhotonOrigin *originOfs,
unsigned nproc
);
/* Postpress unsorted photon heap pmap -> heap and build underlying data
* structure pmap -> store. This is prerequisite to photon lookups with
* findPhotons(). */
/* PhotonFlux is the flux per photon averaged over RGB; this is
* multiplied with each photon's flux during the postprocess. In the
* case of a contribution photon map, this is an array with a separate
* flux specific to each light source due to non-uniform photon emission;
* Otherwise it is referenced as a scalar value. Flux is not scaled if
* photonFlux == NULL. */
/* Photon map construction may be parallelised if nproc > 1, if
* supported. The heap is destroyed on return. */
/* OriginOfs is an array of index offsets for the contribution photon
* origins in pmap->contribOrg generated by each of the nproc subprocesses
* during contrib photon distribution (see distribPhotonContrib()). These
* offsets are used to linearise the photon origin indices in the
* postprocess. This linearisation is skipped if originOfs == NULL,
* e.g. when building a global/caustic/volume photon map, where the
* origins are serial path IDs. */
void findPhotons (PhotonMap* pmap, const RAY *ray);
/* Find pmap -> squeue.len closest photons to ray -> rop with similar
normal. For volume photons ray -> rorg is used and the normal is
ignored (being the incident direction in this case). Found photons
are placed search queue starting with the furthest photon at pmap ->
squeue.node, and pmap -> squeue.tail being the number actually found. */
Photon *find1Photon (PhotonMap *pmap, const RAY *ray, Photon *photon);
/* Find single closest photon to ray -> rop with similar normal.
Return NULL if none found, else the supplied Photon* buffer,
indicating that it contains a valid photon. */
void getPhoton (PhotonMap *pmap, PhotonIdx idx, Photon *photon);
/* Retrieve photon referenced by idx from pmap -> store */
Photon *getNearestPhoton (const PhotonSearchQueue *squeue, PhotonIdx idx);
/* Retrieve photon from NN search queue after calling findPhotons() */
PhotonIdx firstPhoton (const PhotonMap *pmap);
/* Index to first photon, to be passed to getPhoton(). Indices to
* subsequent photons can be optained via increment operator (++) */
void deletePhotons (PhotonMap*);
/* Free dem mammaries... */
#endif
c4science · Help