Homec4science
Diffusion RADIANCE Photon Map (pmapmerge) Browse

RadiancePmap/pmapdata.h
27ff00f002cepmapmerge

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>
/* Source of a contribution photon. This consists of the emitting light
source and binned direction. These records are only used to precompute
contribution photons. They are referenced by contribution photons (see
contribIdx field in struct Photon below) in a surjective mapping, since
multiple photons may share the same emitting source and direction 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; /* Binned incident direction */
} PhotonContribSource;
typedef uint32 PhotonPathID;
typedef uint32 PhotonContribSourceIdx;
#define PMAP_MAXCONTRIBSRC UINT32_MAX
#define photonSrcIdx(pm, p) ((pm) -> contribSrc \
? (pm) -> contribSrc [(p) -> aux.contribSrc].srcIdx \
: (p) -> aux.pathID\
)
#define photonSrcBin(pm, p) ( \
(pm) -> contribSrc [(p) -> aux.contribSrc].srcBin \
)
#define photonSrcMod(pm, p) findmaterial(source [photonSrcIdx(pm, p)].so)
/* Multipurpose auxiliary photon attribute type */
typedef union {
/* Photon's propagation distance (= path length / time of flight)
for temporal light flow */
float pathLen;
/* Index into contribution photon's emitting source and binned
direction; see struct PhotonContribSource above */
PhotonContribSourceIdx contribSrc;
/* Unique path ID for all other photon types */
PhotonPathID pathID;
} PhotonAuxAttrib;
/* 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
/* Auxiliary field; this is a multipurpose, type-specific field used
by the following photon types (as identified by enum PhotonMapType
in pmaptype.h):
PMAP_TYPE_CONTRIB: Index into photon map's contrib
origin array.
PMAP_TYPE_TEMPLIGHTFLOW: Distance travelled by photon / time
of flight
All others: Photon path ID.
*/
PhotonAuxAttrib aux;
} 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
/* Define search queue and underlying data struct types */
#ifdef PMAP_OOC
#include "pmapooc.h"
#else
#include "pmapkdt.h"
#include "pmaptkdt.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)
/* Forward declarations */
struct PhotonMap;
struct PreComputedContrib;
struct PhotonBiasCompNode;
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) */
/* ================================================================
* TRANSIENT PHOTON STUFF
* ================================================================ */
double velocity, /* Speed of light in units of scene
geometry [1/sec] */
time, /* Photons' time of flight for
transient lookups */
minPathLen,
maxPathLen,
avgPathLen; /* Min/max/avg path length */
/* ================================================================
* CONTRIBUTION PHOTON STUFF
* ================================================================ */
PhotonContribSource *contribSrc, /* Contribution source array */
lastContribSrc; /* Current contrib source */
PhotonContribSourceIdx numContribSrc; /* Number of contrib sources */
LUTAB *preCompContribTab; /* LUT for per-modifier precomp
contrib child photon maps (in
parent) or NULL (in child) */
struct PreComputedContrib *preCompContrib; /* Precomputed contribs
(in child) or NULL
(in parent) */
FILE *contribHeap; /* Out-of-core heap containing
unsorted precomputed contrib
photon bins prior to
construction of store */
char contribHeapFname [sizeof(PMAP_TMPFNAME)];
int contribMode; /* If 0, photon map contains
precomputed coefficients,
else contributions */
#ifdef PMAP_OOC
OOC_Cache *contribCache;
#endif
/* ================================================================
* BIAS COMPENSATION STUFF
* ================================================================ */
struct 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) */
#ifdef PMAP_PATHFILT
/* ================================================================
* PHOTON PATH FILTERING STUFF
* ================================================================ */
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
} 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])
#define volumePmap (photonMaps [PMAP_TYPE_VOLUME])
#define transientPmap (photonMaps [PMAP_TYPE_TRANSIENT])
#ifdef PMAP_PHOTONFLOW
/* Transient lightflow has precedence */
#define lightFlowPmap (transLightFlowPmap \
? transLightFlowPmap : photonMaps [PMAP_TYPE_LIGHTFLOW] \
)
#define transLightFlowPmap (photonMaps [PMAP_TYPE_TRANSLIGHTFLOW])
#else
#define lightflowPmap NULL
#define transLightFlowPmap NULL
#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)
#define isContribChildPmap(p) ((p) -> type == PMAP_TYPE_CONTRIB_CHILD)
#define isVolumePmap(p) ((p) -> type == PMAP_TYPE_VOLUME)
#define isTransientPmap(p) ((p) -> type == PMAP_TYPE_TRANSIENT)
#ifdef PMAP_PHOTONFLOW
/* lightflow also implies transient lightflow */
#define isLightFlowPmap(p) ( \
(p) -> type == PMAP_TYPE_LIGHTFLOW || isTransLightFlowPmap(p) \
)
#define isTransLightFlowPmap(p) ( \
(p) -> type == PMAP_TYPE_TRANSLIGHTFLOW \
)
#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,
PhotonContribSourceIdx *contribSrcOfs, unsigned nproc
);
/* Postprocess 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,
void *photonIdx
);
/* Find single closest photon to ray -> rop with similar normal.
Return NULL if none found, else the supplied Photon* buffer
and the photon's index/ID (if photonIdx != NULL), 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