Spectrum MisPathTracer::Li(const Scene* scene, Sampler& sampler, Ray3f& ray) const
{
Spectrum L(0.f);
Intersection its;
Spectrum throughput(1.f);
bool isSpecular = true;
while (true)
{
if (!scene->rayIntersect(ray, its))
break;
if (isSpecular && its.shape->getEmitter())
{
EmitterSample emittanceSample(ray.o, its.p, its.shFrame.n);
L += throughput * its.shape->getEmitter()->eval(emittanceSample);
}
if (its.shape->getBSDF()->getType() != BSDFType::Delta)
{
EmitterSample emSam(its.p);
auto lightSpec = scene->sampleEmitter(its, sampler, emSam);
float cosFactor = its.shFrame.n.dot(emSam.wi);
if (!(cosFactor <= 0.f || lightSpec.isZero() || scene->rayIntersect(emSam.shadowRay)))
{
BSDFSample bsdfSam(its.p, its.toLocal(-ray.d), its.toLocal(emSam.wi));
bsdfSam.measure = Measure::SolidAngle;
auto bsdfSpec = its.shape->getBSDF()->eval(bsdfSam);
float pdfEm = emSam.pdf;
float pdfBsdf = its.shape->getBSDF()->pdf(bsdfSam);
L += throughput * bsdfSpec * lightSpec * cosFactor * miWeight(pdfEm, pdfBsdf);
}
}
BSDFSample bsdfSample(its.p, its.toLocal(-ray.d));
auto bsdf = its.shape->getBSDF()->sample(bsdfSample, sampler);
Intersection bsdfIts;
Ray3f bsdfRay(its.p, its.toWorld(bsdfSample.wo));
if (scene->rayIntersect(bsdfRay, bsdfIts) && bsdfIts.shape->getEmitter())
{
const auto* em = bsdfIts.shape->getEmitter();
EmitterSample emSam(its.p, bsdfIts.p, bsdfIts.shFrame.n);
emSam.wi = bsdfRay.d;
auto lightSpec = em->eval(emSam);
float pdfBsdf = its.shape->getBSDF()->pdf(bsdfSample);
float pdfEm = em->pdf(emSam) * scene->getEmitterPdf();
if (pdfBsdf + pdfEm > 0.f)
L += throughput * bsdf * lightSpec * miWeight(pdfBsdf, pdfEm);
}
isSpecular = its.shape->getBSDF()->getType() == BSDFType::Delta;
throughput *= bsdf;
ray = bsdfRay;
float q = 1.f - std::min(throughput.maxCoeff(), 0.99f);
if (sampler.next1D() > q)
throughput /= (1.f - q);
else
break;
}
return L;
}
Spectrum Li(const RayDifferential &r, RadianceQueryRecord &rRec) const {
/* Some aliases and local variables */
const Scene *scene = rRec.scene;
Intersection &its = rRec.its;
RayDifferential ray(r);
Spectrum Li(0.0f);
bool scattered = false;
/* Perform the first ray intersection (or ignore if the
intersection has already been provided). */
rRec.rayIntersect(ray);
ray.mint = Epsilon;
Spectrum throughput(1.0f);
Float eta = 1.0f;
while (rRec.depth <= m_maxDepth || m_maxDepth < 0) {
if (!its.isValid()) {
/* If no intersection could be found, potentially return
radiance from a environment luminaire if it exists */
if ((rRec.type & RadianceQueryRecord::EEmittedRadiance)
&& (!m_hideEmitters || scattered))
Li += throughput * scene->evalEnvironment(ray);
break;
}
const BSDF *bsdf = its.getBSDF(ray);
/* Possibly include emitted radiance if requested */
if (its.isEmitter() && (rRec.type & RadianceQueryRecord::EEmittedRadiance)
&& (!m_hideEmitters || scattered))
Li += throughput * its.Le(-ray.d);
/* Include radiance from a subsurface scattering model if requested */
if (its.hasSubsurface() && (rRec.type & RadianceQueryRecord::ESubsurfaceRadiance))
Li += throughput * its.LoSub(scene, rRec.sampler, -ray.d, rRec.depth);
if ((rRec.depth >= m_maxDepth && m_maxDepth > 0)
|| (m_strictNormals && dot(ray.d, its.geoFrame.n)
* Frame::cosTheta(its.wi) >= 0)) {
/* Only continue if:
1. The current path length is below the specifed maximum
2. If 'strictNormals'=true, when the geometric and shading
normals classify the incident direction to the same side */
break;
}
/* ==================================================================== */
/* Direct illumination sampling */
/* ==================================================================== */
/* Estimate the direct illumination if this is requested */
DirectSamplingRecord dRec(its);
if (rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance &&
(bsdf->getType() & BSDF::ESmooth)) {
Spectrum value = scene->sampleEmitterDirect(dRec, rRec.nextSample2D());
if (!value.isZero()) {
const Emitter *emitter = static_cast<const Emitter *>(dRec.object);
/* Allocate a record for querying the BSDF */
BSDFSamplingRecord bRec(its, its.toLocal(dRec.d), ERadiance);
/* Evaluate BSDF * cos(theta) */
const Spectrum bsdfVal = bsdf->eval(bRec);
/* Prevent light leaks due to the use of shading normals */
if (!bsdfVal.isZero() && (!m_strictNormals
|| dot(its.geoFrame.n, dRec.d) * Frame::cosTheta(bRec.wo) > 0)) {
/* Calculate prob. of having generated that direction
using BSDF sampling */
Float bsdfPdf = (emitter->isOnSurface() && dRec.measure == ESolidAngle)
? bsdf->pdf(bRec) : 0;
/* Weight using the power heuristic */
Float weight = miWeight(dRec.pdf, bsdfPdf);
Li += throughput * value * bsdfVal * weight;
}
}
}
/* ==================================================================== */
/* BSDF sampling */
/* ==================================================================== */
/* Sample BSDF * cos(theta) */
Float bsdfPdf;
BSDFSamplingRecord bRec(its, rRec.sampler, ERadiance);
Spectrum bsdfWeight = bsdf->sample(bRec, bsdfPdf, rRec.nextSample2D());
if (bsdfWeight.isZero())
break;
scattered |= bRec.sampledType != BSDF::ENull;
/* Prevent light leaks due to the use of shading normals */
const Vector wo = its.toWorld(bRec.wo);
Float woDotGeoN = dot(its.geoFrame.n, wo);
if (m_strictNormals && woDotGeoN * Frame::cosTheta(bRec.wo) <= 0)
break;
bool hitEmitter = false;
Spectrum value;
/* Trace a ray in this direction */
ray = Ray(its.p, wo, ray.time);
if (scene->rayIntersect(ray, its)) {
/* Intersected something - check if it was a luminaire */
if (its.isEmitter()) {
value = its.Le(-ray.d);
dRec.setQuery(ray, its);
hitEmitter = true;
}
} else {
/* Intersected nothing -- perhaps there is an environment map? */
const Emitter *env = scene->getEnvironmentEmitter();
if (env) {
if (m_hideEmitters && !scattered)
break;
value = env->evalEnvironment(ray);
if (!env->fillDirectSamplingRecord(dRec, ray))
break;
hitEmitter = true;
} else {
break;
}
}
/* Keep track of the throughput and relative
refractive index along the path */
throughput *= bsdfWeight;
eta *= bRec.eta;
/* If a luminaire was hit, estimate the local illumination and
weight using the power heuristic */
if (hitEmitter &&
(rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance)) {
/* Compute the prob. of generating that direction using the
implemented direct illumination sampling technique */
const Float lumPdf = (!(bRec.sampledType & BSDF::EDelta)) ?
scene->pdfEmitterDirect(dRec) : 0;
Li += throughput * value * miWeight(bsdfPdf, lumPdf);
}
/* ==================================================================== */
/* Indirect illumination */
/* ==================================================================== */
/* Set the recursive query type. Stop if no surface was hit by the
BSDF sample or if indirect illumination was not requested */
if (!its.isValid() || !(rRec.type & RadianceQueryRecord::EIndirectSurfaceRadiance))
break;
rRec.type = RadianceQueryRecord::ERadianceNoEmission;
if (rRec.depth++ >= m_rrDepth) {
/* Russian roulette: try to keep path weights equal to one,
while accounting for the solid angle compression at refractive
index boundaries. Stop with at least some probability to avoid
getting stuck (e.g. due to total internal reflection) */
Float q = std::min(throughput.max() * eta * eta, (Float) 0.95f);
if (rRec.nextSample1D() >= q)
break;
throughput /= q;
}
}
/* Store statistics */
avgPathLength.incrementBase();
avgPathLength += rRec.depth;
return Li;
}
Spectrum Li(const RayDifferential &r, RadianceQueryRecord &rRec) const {
/* Some aliases and local variables */
const Scene *scene = rRec.scene;
Intersection &its = rRec.its, bsdfIts;
RayDifferential ray(r);
LuminaireSamplingRecord lRec;
Spectrum Li(0.0f);
Point2 sample;
/* Perform the first ray intersection (or ignore if the
intersection has already been provided). */
if (!rRec.rayIntersect(ray)) {
/* If no intersection could be found, possibly return
radiance from a background luminaire */
if (rRec.type & RadianceQueryRecord::EEmittedRadiance)
return scene->LeBackground(ray);
else
return Spectrum(0.0f);
}
/* Possibly include emitted radiance if requested */
if (its.isLuminaire() && (rRec.type & RadianceQueryRecord::EEmittedRadiance))
Li += its.Le(-ray.d);
/* Include radiance from a subsurface integrator if requested */
if (its.hasSubsurface() && (rRec.type & RadianceQueryRecord::ESubsurfaceRadiance))
Li += its.LoSub(scene, rRec.sampler, -ray.d, rRec.depth);
const BSDF *bsdf = its.getBSDF(ray);
if (EXPECT_NOT_TAKEN(!bsdf)) {
/* The direct illumination integrator doesn't support
surfaces without a BSDF (e.g. medium transitions)
-- give up. */
return Li;
}
/* Leave here if direct illumination was not requested */
if (!(rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance))
return Li;
/* ==================================================================== */
/* Luminaire sampling */
/* ==================================================================== */
bool adaptiveQuery = (rRec.extra & RadianceQueryRecord::EAdaptiveQuery);
Point2 *sampleArray;
size_t numLuminaireSamples = m_luminaireSamples,
numBSDFSamples = m_bsdfSamples;
Float fracLum = m_fracLum, fracBSDF = m_fracBSDF,
weightLum = m_weightLum, weightBSDF = m_weightBSDF;
if (rRec.depth > 1 || adaptiveQuery) {
/* This integrator is used recursively by another integrator.
Be less accurate as this sample will not directly be observed. */
numBSDFSamples = numLuminaireSamples = 1;
fracLum = fracBSDF = .5f;
weightLum = weightBSDF = 1.0f;
}
if (numLuminaireSamples > 1) {
sampleArray = rRec.sampler->next2DArray(numLuminaireSamples);
} else {
sample = rRec.nextSample2D(); sampleArray = &sample;
}
for (size_t i=0; i<numLuminaireSamples; ++i) {
/* Estimate the direct illumination if this is requested */
if (scene->sampleLuminaire(its.p, ray.time, lRec, sampleArray[i])) {
/* Allocate a record for querying the BSDF */
BSDFQueryRecord bRec(its, its.toLocal(-lRec.d));
/* Evaluate BSDF * cos(theta) */
const Spectrum bsdfVal = bsdf->eval(bRec);
if (!bsdfVal.isZero()) {
/* Calculate prob. of having sampled that direction
using BSDF sampling */
Float bsdfPdf = (lRec.luminaire->isIntersectable()
|| lRec.luminaire->isBackgroundLuminaire()) ?
bsdf->pdf(bRec) : 0;
/* Weight using the power heuristic */
const Float weight = miWeight(lRec.pdf * fracLum,
bsdfPdf * fracBSDF) * weightLum;
Li += lRec.value * bsdfVal * weight;
}
}
}
/* ==================================================================== */
/* BSDF sampling */
/* ==================================================================== */
if (numBSDFSamples > 1) {
sampleArray = rRec.sampler->next2DArray(numBSDFSamples);
} else {
sample = rRec.nextSample2D(); sampleArray = &sample;
}
for (size_t i=0; i<numBSDFSamples; ++i) {
/* Sample BSDF * cos(theta) */
BSDFQueryRecord bRec(its, rRec.sampler, ERadiance);
Float bsdfPdf;
Spectrum bsdfVal = bsdf->sample(bRec, bsdfPdf, sampleArray[i]);
if (bsdfVal.isZero())
continue;
/* Trace a ray in this direction */
Ray bsdfRay(its.p, its.toWorld(bRec.wo), ray.time);
if (scene->rayIntersect(bsdfRay, bsdfIts)) {
/* Intersected something - check if it was a luminaire */
if (bsdfIts.isLuminaire()) {
lRec = LuminaireSamplingRecord(bsdfIts, -bsdfRay.d);
lRec.value = bsdfIts.Le(-bsdfRay.d);
} else {
continue;
}
} else {
/* No intersection found. Possibly, there is a background
luminaire such as an environment map? */
if (scene->hasBackgroundLuminaire()) {
lRec.luminaire = scene->getBackgroundLuminaire();
lRec.d = -bsdfRay.d;
lRec.value = lRec.luminaire->Le(bsdfRay);
} else {
continue;
}
}
const Float lumPdf = (!(bRec.sampledType & BSDF::EDelta)) ?
scene->pdfLuminaire(its.p, lRec) : 0;
const Float weight = miWeight(bsdfPdf * fracBSDF,
lumPdf * fracLum) * weightBSDF;
Li += lRec.value * bsdfVal * weight;
}
return Li;
}
Spectrum Li(const RayDifferential &ray, RadianceQueryRecord &rRec) const {
Spectrum LiSurf(0.0f), LiMedium(0.0f), transmittance(1.0f);
Intersection &its = rRec.its;
const Scene *scene = rRec.scene;
bool cacheQuery = (rRec.extra & RadianceQueryRecord::ECacheQuery);
bool adaptiveQuery = (rRec.extra & RadianceQueryRecord::EAdaptiveQuery);
/* Perform the first ray intersection (or ignore if the
intersection has already been provided). */
rRec.rayIntersect(ray);
if (rRec.medium) {
Ray mediumRaySegment(ray, 0, its.t);
transmittance = rRec.medium->evalTransmittance(mediumRaySegment);
mediumRaySegment.mint = ray.mint;
if (rRec.type & RadianceQueryRecord::EVolumeRadiance &&
(rRec.depth < m_maxDepth || m_maxDepth < 0) && m_bre.get() != NULL)
LiMedium = m_bre->query(mediumRaySegment, rRec.medium);
}
if (!its.isValid()) {
/* If no intersection could be found, possibly return
attenuated radiance from a background luminaire */
if ((rRec.type & RadianceQueryRecord::EEmittedRadiance) && !m_hideEmitters)
LiSurf = scene->evalEnvironment(ray);
return LiSurf * transmittance + LiMedium;
}
/* Possibly include emitted radiance if requested */
if (its.isEmitter() && (rRec.type & RadianceQueryRecord::EEmittedRadiance) && !m_hideEmitters)
LiSurf += its.Le(-ray.d);
/* Include radiance from a subsurface scattering model if requested */
if (its.hasSubsurface() && (rRec.type & RadianceQueryRecord::ESubsurfaceRadiance))
LiSurf += its.LoSub(scene, rRec.sampler, -ray.d, rRec.depth);
const BSDF *bsdf = its.getBSDF(ray);
if (rRec.depth >= m_maxDepth && m_maxDepth > 0)
return LiSurf * transmittance + LiMedium;
unsigned int bsdfType = bsdf->getType() & BSDF::EAll;
/* Irradiance cache query -> treat as diffuse */
bool isDiffuse = (bsdfType == BSDF::EDiffuseReflection) || cacheQuery;
bool hasSpecular = bsdfType & BSDF::EDelta;
/* Exhaustively recurse into all specular lobes? */
bool exhaustiveSpecular = rRec.depth < m_maxSpecularDepth && !cacheQuery;
if (isDiffuse && (dot(its.shFrame.n, ray.d) < 0 || (bsdf->getType() & BSDF::EBackSide))) {
/* 1. Diffuse indirect */
int maxDepth = m_maxDepth == -1 ? INT_MAX : (m_maxDepth-rRec.depth);
if (rRec.type & RadianceQueryRecord::EIndirectSurfaceRadiance && m_globalPhotonMap.get())
LiSurf += m_globalPhotonMap->estimateIrradiance(its.p,
its.shFrame.n, m_globalLookupRadius, maxDepth,
m_globalLookupSize) * bsdf->getDiffuseReflectance(its) * INV_PI;
if (rRec.type & RadianceQueryRecord::ECausticRadiance && m_causticPhotonMap.get())
LiSurf += m_causticPhotonMap->estimateIrradiance(its.p,
its.shFrame.n, m_causticLookupRadius, maxDepth,
m_causticLookupSize) * bsdf->getDiffuseReflectance(its) * INV_PI;
}
if (hasSpecular && exhaustiveSpecular
&& (rRec.type & RadianceQueryRecord::EIndirectSurfaceRadiance)) {
/* 1. Specular indirect */
int compCount = bsdf->getComponentCount();
RadianceQueryRecord rRec2;
for (int i=0; i<compCount; i++) {
unsigned int type = bsdf->getType(i);
if (!(type & BSDF::EDelta))
continue;
/* Sample the BSDF and recurse */
BSDFSamplingRecord bRec(its, rRec.sampler, ERadiance);
bRec.component = i;
Spectrum bsdfVal = bsdf->sample(bRec, Point2(0.5f));
if (bsdfVal.isZero())
continue;
rRec2.recursiveQuery(rRec, RadianceQueryRecord::ERadiance);
RayDifferential bsdfRay(its.p, its.toWorld(bRec.wo), ray.time);
if (its.isMediumTransition())
rRec2.medium = its.getTargetMedium(bsdfRay.d);
LiSurf += bsdfVal * m_parentIntegrator->Li(bsdfRay, rRec2);
}
}
/* Estimate the direct illumination if this is requested */
int numEmitterSamples = m_directSamples, numBSDFSamples;
Float weightLum, weightBSDF;
Point2 *sampleArray;
Point2 sample;
if (rRec.depth > 1 || cacheQuery || adaptiveQuery) {
/* This integrator is used recursively by another integrator.
Be less accurate as this sample will not directly be observed. */
numBSDFSamples = numEmitterSamples = 1;
weightLum = weightBSDF = 1.0f;
} else {
if (isDiffuse) {
numBSDFSamples = m_directSamples;
weightBSDF = weightLum = m_invEmitterSamples;
} else {
numBSDFSamples = m_glossySamples;
weightLum = m_invEmitterSamples;
weightBSDF = m_invGlossySamples;
}
}
if ((bsdfType & BSDF::ESmooth) && (rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance)) {
DirectSamplingRecord dRec(its);
if (numEmitterSamples > 1) {
sampleArray = rRec.sampler->next2DArray(m_directSamples);
} else {
sample = rRec.nextSample2D(); sampleArray = &sample;
}
for (int i=0; i<numEmitterSamples; ++i) {
int interactions = m_maxDepth - rRec.depth - 1;
Spectrum value = scene->sampleAttenuatedEmitterDirect(
dRec, its, rRec.medium, interactions,
sampleArray[i], rRec.sampler);
/* Estimate the direct illumination if this is requested */
if (!value.isZero()) {
const Emitter *emitter = static_cast<const Emitter *>(dRec.object);
/* Allocate a record for querying the BSDF */
BSDFSamplingRecord bRec(its, its.toLocal(dRec.d));
/* Evaluate BSDF * cos(theta) */
const Spectrum bsdfVal = bsdf->eval(bRec);
if (!bsdfVal.isZero()) {
/* Calculate prob. of having sampled that direction
using BSDF sampling */
if (!hasSpecular || exhaustiveSpecular)
bRec.typeMask = BSDF::ESmooth;
Float bsdfPdf = (emitter->isOnSurface()
&& dRec.measure == ESolidAngle
&& interactions == 0)
? bsdf->pdf(bRec) : (Float) 0.0f;
/* Weight using the power heuristic */
const Float weight = miWeight(dRec.pdf * numEmitterSamples,
bsdfPdf * numBSDFSamples) * weightLum;
LiSurf += value * bsdfVal * weight;
}
}
}
}
/* ==================================================================== */
/* BSDF sampling */
/* ==================================================================== */
/* Sample direct compontent via BSDF sampling if this is generally requested AND
the BSDF is smooth, or there is a delta component that was not handled by the
exhaustive sampling loop above */
bool bsdfSampleDirect = (rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance) &&
((bsdfType & BSDF::ESmooth) || (hasSpecular && !exhaustiveSpecular));
/* Sample indirect component via BSDF sampling if this is generally requested AND
the BSDF is non-diffuse (diffuse is handled by the global photon map)
or there is a delta component that was not handled by the exhaustive sampling loop
above. */
bool bsdfSampleIndirect = (rRec.type & RadianceQueryRecord::EIndirectSurfaceRadiance) &&
!isDiffuse && ((bsdfType & BSDF::ESmooth) || (hasSpecular && !exhaustiveSpecular));
if (bsdfSampleDirect || bsdfSampleIndirect) {
if (numBSDFSamples > 1) {
sampleArray = rRec.sampler->next2DArray(
std::max(m_directSamples, m_glossySamples));
} else {
sample = rRec.nextSample2D(); sampleArray = &sample;
}
RadianceQueryRecord rRec2;
Intersection &bsdfIts = rRec2.its;
DirectSamplingRecord dRec(its);
for (int i=0; i<numBSDFSamples; ++i) {
/* Sample BSDF * cos(theta) */
BSDFSamplingRecord bRec(its, rRec.sampler, ERadiance);
if (!hasSpecular || exhaustiveSpecular)
bRec.typeMask = BSDF::ESmooth;
Float bsdfPdf;
Spectrum bsdfVal = bsdf->sample(bRec, bsdfPdf, sampleArray[i]);
if (bsdfVal.isZero())
continue;
/* Trace a ray in this direction */
RayDifferential bsdfRay(its.p, its.toWorld(bRec.wo), ray.time);
Spectrum value;
bool hitEmitter = false;
if (scene->rayIntersect(bsdfRay, bsdfIts)) {
/* Intersected something - check if it was a luminaire */
if (bsdfIts.isEmitter() && bsdfSampleDirect) {
value = bsdfIts.Le(-bsdfRay.d);
dRec.setQuery(bsdfRay, bsdfIts);
hitEmitter = true;
}
} else if (bsdfSampleDirect) {
/* Intersected nothing -- perhaps there is an environment map? */
const Emitter *env = scene->getEnvironmentEmitter();
if (env) {
value = env->evalEnvironment(bsdfRay);
if (env->fillDirectSamplingRecord(dRec, bsdfRay))
hitEmitter = true;
}
}
if (hitEmitter) {
const Float emitterPdf = scene->pdfEmitterDirect(dRec);
Spectrum transmittance = rRec2.medium ?
rRec2.medium->evalTransmittance(Ray(bsdfRay, 0, bsdfIts.t)) : Spectrum(1.0f);
const Float weight = miWeight(bsdfPdf * numBSDFSamples,
emitterPdf * numEmitterSamples) * weightBSDF;
LiSurf += value * bsdfVal * weight * transmittance;
}
/* Recurse */
if (bsdfSampleIndirect) {
rRec2.recursiveQuery(rRec,
RadianceQueryRecord::ERadianceNoEmission);
rRec2.type ^= RadianceQueryRecord::EIntersection;
if (its.isMediumTransition())
rRec2.medium = its.getTargetMedium(bsdfRay.d);
LiSurf += bsdfVal * m_parentIntegrator->Li(bsdfRay, rRec2) * weightBSDF;
}
}
}
return LiSurf * transmittance + LiMedium;
}
void process(const WorkUnit *workUnit, WorkResult *workResult, const bool &stop) {
const RectangularWorkUnit *rect = static_cast<const RectangularWorkUnit *>(workUnit);
GBDPTWorkResult *result = static_cast<GBDPTWorkResult *>(workResult);
bool needsTimeSample = m_sensor->needsTimeSample();
Float time = m_sensor->getShutterOpen();
result->setOffset(rect->getOffset());
result->setSize(rect->getSize());
result->clear();
m_hilbertCurve.initialize(TVector2<uint8_t>(rect->getSize()));
Path emitterSubpath;
Path sensorSubpath;
/*shift direction is hard-coded. future releases should support arbitrary kernels. */
Vector2 shifts[4] = { Vector2(0, -1), Vector2(-1, 0), Vector2(1, 0), Vector2(0, 1) };
if (m_config.maxDepth == -1){
Log(EWarn, "maxDepth is unlimited, set to 12!");
m_config.maxDepth = 12;
}
/* Determine the necessary random walk depths based on properties of
the endpoints */
int emitterDepth = m_config.maxDepth,
sensorDepth = m_config.maxDepth;
//marco: ensure some required properties (temporary solution)
m_config.sampleDirect = false;
/* Go one extra step if the sensor can be intersected */
if (!m_scene->hasDegenerateSensor() && emitterDepth != -1)
++emitterDepth;
/* Sensor subpath legth +1 if there are emitters that can be intersected (to allow very direct sensor paths)*/
if (!m_scene->hasDegenerateEmitters() && sensorDepth != -1)
++sensorDepth;
/*loop over pixels in block*/
for (size_t i = 0; i<m_hilbertCurve.getPointCount(); ++i) {
int neighborCount = m_config.nNeighbours;
std::vector<ShiftPathData> pathData(neighborCount+1, sensorDepth+3);
pathData[0].success = true;
pathData[0].couldConnectAfterB = true;
/*allocate memory depending on number of neighbours*/
std::vector<Path> emitterSubpath(neighborCount + 1);
std::vector<Path> sensorSubpath(neighborCount + 1);
std::vector<double> jacobianLP(neighborCount);
std::vector<double> genGeomTermLP(neighborCount + 1);
std::vector<Spectrum> value(neighborCount + 1);
std::vector<Float> miWeight(neighborCount + 1);
std::vector<Float> valuePdf(neighborCount + 1);
bool *pathSuccess = (bool *)alloca((neighborCount + 1) * sizeof(bool));
Point2 samplePos;
Point2i offset = Point2i(m_hilbertCurve[i]) + Vector2i(rect->getOffset());
m_sampler->generate(offset);
int spp = m_sampler->getSampleCount();
/* For each sample */
for (size_t j = 0; j<spp; j++) {
if (stop)
break;
if (needsTimeSample)
time = m_sensor->sampleTime(m_sampler->next1D());
/* Start new emitter and sensor subpaths */
emitterSubpath[0].initialize(m_scene, time, EImportance, m_pool);
sensorSubpath[0].initialize(m_scene, time, ERadiance, m_pool);
/* Perform a random walk using alternating steps on each path */
Path::alternatingRandomWalkFromPixel(m_scene, m_sampler,
emitterSubpath[0], emitterDepth, sensorSubpath[0],
sensorDepth, offset, m_config.rrDepth, m_pool);
samplePos = sensorSubpath[0].vertex(1)->getSamplePosition();
double jx, jy;
//marco: Hack- Required to store negative gradients...
for (size_t i = 0; i < (1 + m_config.nNeighbours); ++i){
const_cast<ImageBlock *>(result->getImageBlock(i))->setAllowNegativeValues(true);
if (m_config.lightImage)
const_cast<ImageBlock *>(result->getLightImage(i))->setAllowNegativeValues(true);
}
Path connectPath;
int ptx;
/* create shift-able path */
bool couldConnect = createShiftablePath(connectPath, emitterSubpath[0], sensorSubpath[0], 1, sensorSubpath[0].vertexCount() - 1, ptx);
/* geometry term(s) of base */
m_offsetGenerator->computeMuRec(connectPath, pathData[0].muRec);
int idx = 0;
for (int v = pathData[0].muRec.extra[0] - 1; v >= 0; v--){
int idx = connectPath.vertexCount() - 1 - v;
if (Path::isConnectable_GBDPT(connectPath.vertex(v), m_config.m_shiftThreshold) && v >= pathData[0].muRec.extra[2])
pathData[0].genGeomTerm.at(idx) = connectPath.calcSpecularPDFChange(v, m_offsetGenerator);
else
pathData[0].genGeomTerm.at(idx) = pathData[0].genGeomTerm.at(idx - 1);
}
/*shift base path if possible*/
for (int k = 0; k<neighborCount; k++){
//we cannot shift very direct paths!
pathData[k + 1].success = pathData[0].muRec.extra[0] <= 2 ? false : m_offsetGenerator->generateOffsetPathGBDPT(connectPath, sensorSubpath[k + 1], pathData[k + 1].muRec, shifts[k], pathData[k + 1].couldConnectAfterB, false);
//if shift successful, compute jacobian and geometry term for each possible connection strategy that affects the shifted sub path
//for the manifold exploration shift there are only two connectible vertices in the affected chain (v_b and v_c)
if (pathData[k + 1].success){
int idx = 0; int a, b, c;
for (int v = pathData[k + 1].muRec.extra[0] - 1; v >= 0; v--){
int idx = connectPath.vertexCount() - 1 - v;
if (Path::isConnectable_GBDPT(connectPath.vertex(v), m_config.m_shiftThreshold) && v >= pathData[k + 1].muRec.extra[2]){
a = pathData[k + 1].muRec.extra[0];
b = v >= pathData[k + 1].muRec.extra[1] ? v : pathData[k + 1].muRec.extra[1];
c = v >= pathData[k + 1].muRec.extra[1] ? v - 1 : pathData[k + 1].muRec.extra[2];
jx = connectPath.halfJacobian_GBDPT(a, b, c, m_offsetGenerator);
jy = sensorSubpath[k + 1].halfJacobian_GBDPT(a, b, c, m_offsetGenerator);
pathData[k+1].jacobianDet.at(idx) = jy / jx;
pathData[k+1].genGeomTerm.at(idx) = sensorSubpath[k + 1].calcSpecularPDFChange(v, m_offsetGenerator);
}
else{
pathData[k + 1].jacobianDet.at(idx) = pathData[k + 1].jacobianDet.at(idx - 1);
pathData[k + 1].genGeomTerm.at(idx) = pathData[k + 1].genGeomTerm.at(idx - 1);
}
}
}
sensorSubpath[k + 1].reverse();
}
/*save index of vertex b for evaluation (indexing is reversed)*/
int v_b = connectPath.vertexCount() - 1 - pathData[0].muRec.extra[1];
/* evaluate base and offset paths */
evaluate(result, emitterSubpath[0], sensorSubpath, pathData, v_b,
value, miWeight, valuePdf, jacobianLP, genGeomTermLP, pathSuccess);
/* clean up memory */
connectPath.release(ptx, ptx + 2, m_pool);
for (int k = 0; k<neighborCount; k++){
if (pathData[k+1].success){
sensorSubpath[k + 1].reverse();
sensorSubpath[k + 1].release(pathData[k + 1].muRec.l, pathData[k + 1].muRec.m + 1, m_pool);
}
}
sensorSubpath[0].release(m_pool);
emitterSubpath[0].release(m_pool);
for (size_t i = 0; i < (1 + m_config.nNeighbours); ++i){
const_cast<ImageBlock *>(result->getImageBlock(i))->setAllowNegativeValues(false);
if (m_config.lightImage)
const_cast<ImageBlock *>(result->getLightImage(i))->setAllowNegativeValues(false);
}
m_sampler->advance();
}
}
/* Make sure that there were no memory leaks */
Assert(m_pool.unused());
}
Spectrum Li(const RayDifferential &r, RadianceQueryRecord &rRec) const {
/* Some aliases and local variables */
const Scene *scene = rRec.scene;
Intersection &its = rRec.its;
RayDifferential ray(r);
Spectrum Li(0.0f);
/* Perform the first ray intersection (or ignore if the
intersection has already been provided). */
rRec.rayIntersect(ray);
ray.mint = Epsilon;
Spectrum pathThroughput(1.0f);
while (rRec.depth <= m_maxDepth || m_maxDepth < 0) {
if (!its.isValid()) {
/* If no intersection could be found, potentially return
radiance from a background luminaire if it exists */
if (rRec.type & RadianceQueryRecord::EEmittedRadiance)
Li += pathThroughput * scene->LeBackground(ray);
break;
}
const BSDF *bsdf = its.getBSDF(ray);
if (EXPECT_NOT_TAKEN(bsdf == NULL)) {
/* The MI path tracer doesn't support
surfaces without a BSDF (e.g. medium transitions)
-- give up. */
break;
}
/* Possibly include emitted radiance if requested */
if (its.isLuminaire() && (rRec.type & RadianceQueryRecord::EEmittedRadiance))
Li += pathThroughput * its.Le(-ray.d);
/* Include radiance from a subsurface integrator if requested */
if (its.hasSubsurface() && (rRec.type & RadianceQueryRecord::ESubsurfaceRadiance))
Li += pathThroughput * its.LoSub(scene, rRec.sampler, -ray.d, rRec.depth);
if (m_maxDepth > 0 && rRec.depth >= m_maxDepth)
break;
/* ==================================================================== */
/* Luminaire sampling */
/* ==================================================================== */
/* Prevent light leaks due to the use of shading normals */
Float wiDotGeoN = -dot(its.geoFrame.n, ray.d),
wiDotShN = Frame::cosTheta(its.wi);
if (wiDotGeoN * wiDotShN < 0 && m_strictNormals)
break;
/* Estimate the direct illumination if this is requested */
LuminaireSamplingRecord lRec;
if (rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance &&
scene->sampleLuminaire(its.p, ray.time, lRec, rRec.nextSample2D())) {
/* Allocate a record for querying the BSDF */
const Vector wo = -lRec.d;
const BSDFQueryRecord bRec(its, its.toLocal(wo));
/* Evaluate BSDF * cos(theta) */
const Spectrum bsdfVal = bsdf->fCos(bRec);
Float woDotGeoN = dot(its.geoFrame.n, wo);
/* Prevent light leaks due to the use of shading normals */
if (!bsdfVal.isZero() && (!m_strictNormals
|| woDotGeoN * Frame::cosTheta(bRec.wo) > 0)) {
/* Calculate prob. of having sampled that direction
using BSDF sampling */
Float bsdfPdf = (lRec.luminaire->isIntersectable()
|| lRec.luminaire->isBackgroundLuminaire()) ?
bsdf->pdf(bRec) : 0;
/* Weight using the power heuristic */
const Float weight = miWeight(lRec.pdf, bsdfPdf);
Li += pathThroughput * lRec.value * bsdfVal * weight;
}
}
/* ==================================================================== */
/* BSDF sampling */
/* ==================================================================== */
/* Sample BSDF * cos(theta) */
BSDFQueryRecord bRec(its);
Float bsdfPdf;
Spectrum bsdfVal = bsdf->sampleCos(bRec, bsdfPdf, rRec.nextSample2D());
if (bsdfVal.isZero())
break;
bsdfVal /= bsdfPdf;
/* Prevent light leaks due to the use of shading normals */
const Vector wo = its.toWorld(bRec.wo);
Float woDotGeoN = dot(its.geoFrame.n, wo);
if (woDotGeoN * Frame::cosTheta(bRec.wo) <= 0 && m_strictNormals)
break;
/* Trace a ray in this direction */
ray = Ray(its.p, wo, ray.time);
bool hitLuminaire = false;
if (scene->rayIntersect(ray, its)) {
/* Intersected something - check if it was a luminaire */
if (its.isLuminaire()) {
lRec = LuminaireSamplingRecord(its, -ray.d);
lRec.value = its.Le(-ray.d);
hitLuminaire = true;
}
} else {
/* No intersection found. Possibly, there is a background
luminaire such as an environment map? */
if (scene->hasBackgroundLuminaire()) {
lRec.luminaire = scene->getBackgroundLuminaire();
lRec.value = lRec.luminaire->Le(ray);
lRec.d = -ray.d;
hitLuminaire = true;
} else {
rRec.depth++;
break;
}
}
/* If a luminaire was hit, estimate the local illumination and
weight using the power heuristic */
if (hitLuminaire &&
(rRec.type & RadianceQueryRecord::EDirectSurfaceRadiance)) {
/* Prob. of having generated this sample using luminaire sampling */
const Float lumPdf = (!(bRec.sampledType & BSDF::EDelta)) ?
scene->pdfLuminaire(ray.o, lRec) : 0;
const Float weight = miWeight(bsdfPdf, lumPdf);
Li += pathThroughput * lRec.value * bsdfVal * weight;
}
/* ==================================================================== */
/* Indirect illumination */
/* ==================================================================== */
/* Set the recursive query type */
/* Stop if no surface was hit by the BSDF sample or if indirect illumination
was not requested */
if (!its.isValid() || !(rRec.type & RadianceQueryRecord::EIndirectSurfaceRadiance))
break;
rRec.type = RadianceQueryRecord::ERadianceNoEmission;
/* Russian roulette - Possibly stop the recursion. Don't do this when
dealing with a transmission component, since solid angle compression
factors cause problems with the heuristic below */
if (rRec.depth >= m_rrDepth && !(bRec.sampledType & BSDF::ETransmission)) {
/* Assuming that BSDF importance sampling is perfect,
'bsdfVal.max()' should equal the maximum albedo
over all spectral samples */
Float approxAlbedo = std::min((Float) 0.9f, bsdfVal.max());
if (rRec.nextSample1D() > approxAlbedo)
break;
else
pathThroughput /= approxAlbedo;
}
pathThroughput *= bsdfVal;
rRec.depth++;
}
/* Store statistics */
avgPathLength.incrementBase();
avgPathLength += rRec.depth;
return Li;
}
