// ProjectionLight Method Definitions
ProjectionLight::ProjectionLight(const Transform &LightToWorld,
const MediumInterface &mediumInterface,
const Spectrum &I, const std::string &texname,
Float fov)
: Light((int)LightFlags::DeltaPosition, LightToWorld, mediumInterface),
pLight(LightToWorld(Point3f(0, 0, 0))),
I(I) {
// Create _ProjectionLight_ MIP map
Point2i resolution;
std::unique_ptr<RGBSpectrum[]> texels = ReadImage(texname, &resolution);
if (texels)
projectionMap.reset(new MIPMap<RGBSpectrum>(resolution, texels.get()));
// Initialize _ProjectionLight_ projection matrix
Float aspect =
projectionMap ? (Float(resolution.x) / Float(resolution.y)) : 1;
if (aspect > 1)
screenBounds = Bounds2f(Point2f(-aspect, -1), Point2f(aspect, 1));
else
screenBounds =
Bounds2f(Point2f(-1, -1 / aspect), Point2f(1, 1 / aspect));
hither = 1e-3f;
yon = 1e30f;
lightProjection = Perspective(fov, hither, yon);
// Compute cosine of cone surrounding projection directions
Float opposite = std::tan(Radians(fov) / 2.f);
Float tanDiag = opposite * std::sqrt(1 + 1 / (aspect * aspect));
cosTotalWidth = std::cos(std::atan(tanDiag));
}
std::vector<TestIntegrator> GetIntegrators() {
std::vector<TestIntegrator> integrators;
Point2i resolution(10, 10);
AnimatedTransform identity(new Transform, 0, new Transform, 1);
for (auto scene : GetScenes()) {
// Path tracing integrators
for (auto sampler : GetSamplers(Bounds2i(Point2i(0,0), resolution))) {
std::unique_ptr<Filter> filter(new BoxFilter(Vector2f(0.5, 0.5)));
Film *film = new Film(resolution, Bounds2f(Point2f(0,0), Point2f(1,1)),
std::move(filter), 1., "test.exr", 1.);
std::shared_ptr<Camera> camera = std::make_shared<PerspectiveCamera>(
identity, Bounds2f(Point2f(-1,-1), Point2f(1,1)), 0., 1.,
0., 10., 45, film, nullptr);
Integrator *integrator = new PathIntegrator(8, camera, sampler.first);
integrators.push_back({integrator, film,
"Path, depth 8, Perspective, " + sampler.second + ", " +
scene.description, scene});
}
for (auto sampler : GetSamplers(Bounds2i(Point2i(0,0), resolution))) {
std::unique_ptr<Filter> filter(new BoxFilter(Vector2f(0.5, 0.5)));
Film *film = new Film(resolution, Bounds2f(Point2f(0,0), Point2f(1,1)),
std::move(filter), 1., "test.exr", 1.);
std::shared_ptr<Camera> camera = std::make_shared<OrthographicCamera>(
identity, Bounds2f(Point2f(-.1,-.1), Point2f(.1,.1)), 0., 1.,
0., 10., film, nullptr);
Integrator *integrator = new PathIntegrator(8, camera, sampler.first);
integrators.push_back({integrator, film,
"Path, depth 8, Ortho, " + sampler.second + ", " +
scene.description, scene});
}
// Volume path tracing integrators
for (auto sampler : GetSamplers(Bounds2i(Point2i(0,0), resolution))) {
std::unique_ptr<Filter> filter(new BoxFilter(Vector2f(0.5, 0.5)));
Film *film = new Film(resolution, Bounds2f(Point2f(0,0), Point2f(1,1)),
std::move(filter), 1., "test.exr", 1.);
std::shared_ptr<Camera> camera = std::make_shared<PerspectiveCamera>(
identity, Bounds2f(Point2f(-1,-1), Point2f(1,1)), 0., 1.,
0., 10., 45, film, nullptr);
Integrator *integrator = new VolPathIntegrator(8, camera, sampler.first);
integrators.push_back({integrator, film,
"VolPath, depth 8, Perspective, " + sampler.second + ", " +
scene.description, scene});
}
for (auto sampler : GetSamplers(Bounds2i(Point2i(0,0), resolution))) {
std::unique_ptr<Filter> filter(new BoxFilter(Vector2f(0.5, 0.5)));
Film *film = new Film(resolution, Bounds2f(Point2f(0,0), Point2f(1,1)),
std::move(filter), 1., "test.exr", 1.);
std::shared_ptr<Camera> camera = std::make_shared<OrthographicCamera>(
identity, Bounds2f(Point2f(-.1,-.1), Point2f(.1,.1)), 0., 1.,
0., 10., film, nullptr);
Integrator *integrator = new VolPathIntegrator(8, camera, sampler.first);
integrators.push_back({integrator, film,
"VolPath, depth 8, Ortho, " + sampler.second + ", " +
scene.description, scene});
}
// BDPT
for (auto sampler : GetSamplers(Bounds2i(Point2i(0,0), resolution))) {
std::unique_ptr<Filter> filter(new BoxFilter(Vector2f(0.5, 0.5)));
Film *film = new Film(resolution, Bounds2f(Point2f(0,0), Point2f(1,1)),
std::move(filter), 1., "test.exr", 1.);
std::shared_ptr<Camera> camera = std::make_shared<PerspectiveCamera>(
identity, Bounds2f(Point2f(-1,-1), Point2f(1,1)), 0., 1.,
0., 10., 45, film, nullptr);
Integrator *integrator = new BDPTIntegrator(sampler.first, camera, 6,
false, false);
integrators.push_back({integrator, film,
"BDPT, depth 8, Perspective, " + sampler.second + ", " +
scene.description, scene});
}
#if 0
// Ortho camera not currently supported with BDPT.
for (auto sampler : GetSamplers(Bounds2i(Point2i(0,0), resolution))) {
std::unique_ptr<Filter> filter(new BoxFilter(Vector2f(0.5, 0.5)));
Film *film = new Film(resolution, Bounds2f(Point2f(0,0), Point2f(1,1)),
std::move(filter), 1., "test.exr", 1.);
std::shared_ptr<Camera> camera = std::make_shared<OrthographicCamera>(
identity, Bounds2f(Point2f(-.1,-.1), Point2f(.1,.1)), 0., 1.,
0., 10., film, nullptr);
Integrator *integrator = new BDPTIntegrator(sampler.first, camera, 8,
false, false);
integrators.push_back({integrator, film,
"BDPT, depth 8, Ortho, " + sampler.second + ", " +
scene.description, scene});
}
#endif
// MLT
{
std::unique_ptr<Filter> filter(new BoxFilter(Vector2f(0.5, 0.5)));
Film *film = new Film(resolution, Bounds2f(Point2f(0,0), Point2f(1,1)),
std::move(filter), 1., "test.exr", 1.);
std::shared_ptr<Camera> camera = std::make_shared<PerspectiveCamera>(
identity, Bounds2f(Point2f(-1,-1), Point2f(1,1)), 0., 1.,
0., 10., 45, film, nullptr);
Integrator *integrator =
new MLTIntegrator(camera, 8 /* depth */, 100000 /* n bootstrap */,
1000 /* nchains */, 1024 /* mutations per pixel */,
0.01 /* sigma */, 0.3 /* large step prob */);
integrators.push_back({integrator, film,
"MLT, depth 8, Perspective, " + scene.description,
scene});
}
}
return integrators;
}
Bounds2f Film::GetPhysicalExtent() const {
Float aspect = (Float)fullResolution.y / (Float)fullResolution.x;
Float x = std::sqrt(diagonal * diagonal / (1 + aspect * aspect));
Float y = aspect * x;
return Bounds2f(Point2f(-x / 2, -y / 2), Point2f(x / 2, y / 2));
}
void BDPTIntegrator::Render(const Scene &scene) {
std::unique_ptr<LightDistribution> lightDistribution =
CreateLightSampleDistribution(lightSampleStrategy, scene);
// Compute a reverse mapping from light pointers to offsets into the
// scene lights vector (and, equivalently, offsets into
// lightDistr). Added after book text was finalized; this is critical
// to reasonable performance with 100s+ of light sources.
std::unordered_map<const Light *, size_t> lightToIndex;
for (size_t i = 0; i < scene.lights.size(); ++i)
lightToIndex[scene.lights[i].get()] = i;
// Partition the image into tiles
Film *film = camera->film;
const Bounds2i sampleBounds = film->GetSampleBounds();
const Vector2i sampleExtent = sampleBounds.Diagonal();
const int tileSize = 16;
const int nXTiles = (sampleExtent.x + tileSize - 1) / tileSize;
const int nYTiles = (sampleExtent.y + tileSize - 1) / tileSize;
ProgressReporter reporter(nXTiles * nYTiles, "Rendering");
// Allocate buffers for debug visualization
const int bufferCount = (1 + maxDepth) * (6 + maxDepth) / 2;
std::vector<std::unique_ptr<Film>> weightFilms(bufferCount);
if (visualizeStrategies || visualizeWeights) {
for (int depth = 0; depth <= maxDepth; ++depth) {
for (int s = 0; s <= depth + 2; ++s) {
int t = depth + 2 - s;
if (t == 0 || (s == 1 && t == 1)) continue;
std::string filename =
StringPrintf("bdpt_d%02i_s%02i_t%02i.exr", depth, s, t);
weightFilms[BufferIndex(s, t)] = std::unique_ptr<Film>(new Film(
film->fullResolution,
Bounds2f(Point2f(0, 0), Point2f(1, 1)),
std::unique_ptr<Filter>(CreateBoxFilter(ParamSet())),
film->diagonal * 1000, filename, 1.f));
}
}
}
// Render and write the output image to disk
if (scene.lights.size() > 0) {
ParallelFor2D([&](const Point2i tile) {
// Render a single tile using BDPT
MemoryArena arena;
int seed = tile.y * nXTiles + tile.x;
std::unique_ptr<Sampler> tileSampler = sampler->Clone(seed);
int x0 = sampleBounds.pMin.x + tile.x * tileSize;
int x1 = std::min(x0 + tileSize, sampleBounds.pMax.x);
int y0 = sampleBounds.pMin.y + tile.y * tileSize;
int y1 = std::min(y0 + tileSize, sampleBounds.pMax.y);
Bounds2i tileBounds(Point2i(x0, y0), Point2i(x1, y1));
std::unique_ptr<FilmTile> filmTile =
camera->film->GetFilmTile(tileBounds);
for (Point2i pPixel : tileBounds) {
tileSampler->StartPixel(pPixel);
if (!InsideExclusive(pPixel, pixelBounds))
continue;
do {
// Generate a single sample using BDPT
Point2f pFilm = (Point2f)pPixel + tileSampler->Get2D();
// Trace the camera subpath
Vertex *cameraVertices = arena.Alloc<Vertex>(maxDepth + 2);
Vertex *lightVertices = arena.Alloc<Vertex>(maxDepth + 1);
int nCamera = GenerateCameraSubpath(
scene, *tileSampler, arena, maxDepth + 2, *camera,
pFilm, cameraVertices);
// Get a distribution for sampling the light at the
// start of the light subpath. Because the light path
// follows multiple bounces, basing the sampling
// distribution on any of the vertices of the camera
// path is unlikely to be a good strategy. We use the
// PowerLightDistribution by default here, which
// doesn't use the point passed to it.
const Distribution1D *lightDistr =
lightDistribution->Lookup(cameraVertices[0].p());
// Now trace the light subpath
int nLight = GenerateLightSubpath(
scene, *tileSampler, arena, maxDepth + 1,
cameraVertices[0].time(), *lightDistr, lightToIndex,
lightVertices);
// Execute all BDPT connection strategies
Spectrum L(0.f);
for (int t = 1; t <= nCamera; ++t) {
for (int s = 0; s <= nLight; ++s) {
int depth = t + s - 2;
if ((s == 1 && t == 1) || depth < 0 ||
depth > maxDepth)
continue;
// Execute the $(s, t)$ connection strategy and
// update _L_
Point2f pFilmNew = pFilm;
Float misWeight = 0.f;
Spectrum Lpath = ConnectBDPT(
scene, lightVertices, cameraVertices, s, t,
*lightDistr, lightToIndex, *camera, *tileSampler,
&pFilmNew, &misWeight);
VLOG(2) << "Connect bdpt s: " << s <<", t: " << t <<
", Lpath: " << Lpath << ", misWeight: " << misWeight;
if (visualizeStrategies || visualizeWeights) {
Spectrum value;
if (visualizeStrategies)
value =
misWeight == 0 ? 0 : Lpath / misWeight;
if (visualizeWeights) value = Lpath;
weightFilms[BufferIndex(s, t)]->AddSplat(
pFilmNew, value);
}
if (t != 1)
L += Lpath;
else
film->AddSplat(pFilmNew, Lpath);
}
}
VLOG(2) << "Add film sample pFilm: " << pFilm << ", L: " << L <<
", (y: " << L.y() << ")";
filmTile->AddSample(pFilm, L);
arena.Reset();
} while (tileSampler->StartNextSample());
}
film->MergeFilmTile(std::move(filmTile));
reporter.Update();
}, Point2i(nXTiles, nYTiles));
reporter.Done();
}
film->WriteImage(1.0f / sampler->samplesPerPixel);
// Write buffers for debug visualization
if (visualizeStrategies || visualizeWeights) {
const Float invSampleCount = 1.0f / sampler->samplesPerPixel;
for (size_t i = 0; i < weightFilms.size(); ++i)
if (weightFilms[i]) weightFilms[i]->WriteImage(invSampleCount);
}
}
void BDPTIntegrator::Render(const Scene &scene) {
ProfilePhase p(Prof::IntegratorRender);
// Compute _lightDistr_ for sampling lights proportional to power
std::unique_ptr<Distribution1D> lightDistr =
ComputeLightPowerDistribution(scene);
// Partition the image into tiles
Film *film = camera->film;
const Bounds2i sampleBounds = film->GetSampleBounds();
const Vector2i sampleExtent = sampleBounds.Diagonal();
const int tileSize = 16;
const int nXTiles = (sampleExtent.x + tileSize - 1) / tileSize;
const int nYTiles = (sampleExtent.y + tileSize - 1) / tileSize;
ProgressReporter reporter(nXTiles * nYTiles, "Rendering");
// Allocate buffers for debug visualization
const int bufferCount = (1 + maxDepth) * (6 + maxDepth) / 2;
std::vector<std::unique_ptr<Film>> weightFilms(bufferCount);
if (visualizeStrategies || visualizeWeights) {
for (int depth = 0; depth <= maxDepth; ++depth) {
for (int s = 0; s <= depth + 2; ++s) {
int t = depth + 2 - s;
if (t == 0 || (s == 1 && t == 1)) continue;
std::string filename =
StringPrintf("bdpt_d%02i_s%02i_t%02i.exr", depth, s, t);
weightFilms[BufferIndex(s, t)] = std::unique_ptr<Film>(new Film(
film->fullResolution,
Bounds2f(Point2f(0, 0), Point2f(1, 1)),
std::unique_ptr<Filter>(CreateBoxFilter(ParamSet())),
film->diagonal * 1000, filename, 1.f));
}
}
}
// Render and write the output image to disk
if (scene.lights.size() > 0) {
StatTimer timer(&renderingTime);
ParallelFor2D([&](const Point2i tile) {
// Render a single tile using BDPT
MemoryArena arena;
int seed = tile.y * nXTiles + tile.x;
std::unique_ptr<Sampler> tileSampler = sampler->Clone(seed);
int x0 = sampleBounds.pMin.x + tile.x * tileSize;
int x1 = std::min(x0 + tileSize, sampleBounds.pMax.x);
int y0 = sampleBounds.pMin.y + tile.y * tileSize;
int y1 = std::min(y0 + tileSize, sampleBounds.pMax.y);
Bounds2i tileBounds(Point2i(x0, y0), Point2i(x1, y1));
std::unique_ptr<FilmTile> filmTile =
camera->film->GetFilmTile(tileBounds);
for (Point2i pPixel : tileBounds) {
tileSampler->StartPixel(pPixel);
if (!InsideExclusive(pPixel, pixelBounds))
continue;
do {
// Generate a single sample using BDPT
Point2f pFilm = (Point2f)pPixel + tileSampler->Get2D();
// Trace the camera and light subpaths
Vertex *cameraVertices = arena.Alloc<Vertex>(maxDepth + 2);
Vertex *lightVertices = arena.Alloc<Vertex>(maxDepth + 1);
int nCamera = GenerateCameraSubpath(
scene, *tileSampler, arena, maxDepth + 2, *camera,
pFilm, cameraVertices);
int nLight = GenerateLightSubpath(
scene, *tileSampler, arena, maxDepth + 1,
cameraVertices[0].time(), *lightDistr, lightVertices);
// Execute all BDPT connection strategies
Spectrum L(0.f);
for (int t = 1; t <= nCamera; ++t) {
for (int s = 0; s <= nLight; ++s) {
int depth = t + s - 2;
if ((s == 1 && t == 1) || depth < 0 ||
depth > maxDepth)
continue;
// Execute the $(s, t)$ connection strategy and
// update _L_
Point2f pFilmNew = pFilm;
Float misWeight = 0.f;
Spectrum Lpath = ConnectBDPT(
scene, lightVertices, cameraVertices, s, t,
*lightDistr, *camera, *tileSampler, &pFilmNew,
&misWeight);
if (visualizeStrategies || visualizeWeights) {
Spectrum value;
if (visualizeStrategies)
value =
misWeight == 0 ? 0 : Lpath / misWeight;
if (visualizeWeights) value = Lpath;
weightFilms[BufferIndex(s, t)]->AddSplat(
pFilmNew, value);
}
if (t != 1)
L += Lpath;
else
film->AddSplat(pFilmNew, Lpath);
}
}
filmTile->AddSample(pFilm, L);
arena.Reset();
} while (tileSampler->StartNextSample());
}
film->MergeFilmTile(std::move(filmTile));
reporter.Update();
}, Point2i(nXTiles, nYTiles));
reporter.Done();
}
film->WriteImage(1.0f / sampler->samplesPerPixel);
// Write buffers for debug visualization
if (visualizeStrategies || visualizeWeights) {
const Float invSampleCount = 1.0f / sampler->samplesPerPixel;
for (size_t i = 0; i < weightFilms.size(); ++i)
if (weightFilms[i]) weightFilms[i]->WriteImage(invSampleCount);
}
}
