Add --pixel-material command-line option

src/pbrt/cameras.cpp

@@ -47,6 +47,7 @@ CameraTransform::CameraTransform(const AnimatedTransform &worldFromCamera) {
     default:
         LOG_FATAL("Unhandled rendering coordinate space");
     }
+    LOG_VERBOSE("World-space position: %s", worldFromRender(Point3f(0, 0, 0)));
     // Compute _renderFromCamera_ transformation
     Transform renderFromWorld = Inverse(worldFromRender);
     Transform rfc[2] = {renderFromWorld * worldFromCamera.startTransform,

src/pbrt/cameras.h

@@ -84,6 +84,12 @@ class CameraTransform {
         return renderFromCamera.ApplyInverse(v, time);
     }
 
+    PBRT_CPU_GPU
+    const AnimatedTransform &RenderFromCamera() const { return renderFromCamera; }
+
+    PBRT_CPU_GPU
+    const Transform &WorldFromRender() const { return worldFromRender; }
+
     std::string ToString() const;
 
   private:

src/pbrt/cmd/pbrt.cpp

@@ -131,7 +131,7 @@ int main(int argc, char *argv[]) {
             exit(1);
         };
 
-        std::string cropWindow, pixelBounds, pixel;
+        std::string cropWindow, pixelBounds, pixel, pixelMaterial;
         if (ParseArg(&argv, "cropwindow", &cropWindow, onError)) {
             std::vector<Float> c = SplitStringToFloats(cropWindow, ',');
             if (c.size() != 4) {
@@ -154,6 +154,13 @@ int main(int argc, char *argv[]) {
                 return 1;
             }
             options.pixelBounds = Bounds2i(Point2i(p[0], p[2]), Point2i(p[1], p[3]));
+        } else if (ParseArg(&argv, "pixelmaterial", &pixelMaterial, onError)) {
+            std::vector<int> p = SplitStringToInts(pixelMaterial, ',');
+            if (p.size() != 2) {
+                usage("Didn't find two values after --pixelmaterial");
+                return 1;
+            }
+            options.pixelMaterial = Point2i(p[0], p[1]);
         } else if (
 #ifdef PBRT_BUILD_GPU_RENDERER
             ParseArg(&argv, "gpu", &options.useGPU, onError) ||
@@ -223,6 +230,11 @@ int main(int argc, char *argv[]) {
     if (!options.mseReferenceOutput.empty() && options.mseReferenceImage.empty())
         ErrorExit("Must provide MSE reference image via --mse-reference-image");
 
+    if (options.pixelMaterial && options.useGPU) {
+        Warning("Disabling --use-gpu since --pixelmaterial was specified.");
+        options.useGPU = false;
+    }
+
     options.logLevel = LogLevelFromString(logLevel);
 
     // Initialize pbrt

src/pbrt/cpu/render.cpp

@@ -356,6 +356,34 @@ void CPURender(ParsedScene &parsedScene) {
 
     LOG_VERBOSE("Memory used after scene creation: %d", GetCurrentRSS());
 
+    if (Options->pixelMaterial) {
+        SampledWavelengths lambda = SampledWavelengths::SampleUniform(0.5f);
+
+        CameraSample cs;
+        cs.pFilm = *Options->pixelMaterial + Vector2f(0.5f, 0.5f);
+        cs.time = 0.5f;
+        cs.pLens = Point2f(0.5f, 0.5f);
+        cs.weight = 1;
+        pstd::optional<CameraRay> cr = camera.GenerateRay(cs, lambda);
+        if (!cr)
+            ErrorExit("Unable to generate camera ray for specified pixel.");
+
+        pstd::optional<ShapeIntersection> isect = accel.Intersect(cr->ray, Infinity);
+        if (!isect)
+            ErrorExit("No geometry visible at specified pixel.");
+
+        const SurfaceInteraction &intr = isect->intr;
+        if (!intr.material)
+            ErrorExit("No material at intersection point.");
+
+        for (const auto &mtl : namedMaterials)
+            if (mtl.second == intr.material)
+                Printf("Named material: %s\n", mtl.first);
+        Printf("%s\n\n", intr.material.ToString());
+
+        return;
+    }
+
     // Render!
     integrator->Render();
 

src/pbrt/options.h

@@ -43,6 +43,7 @@ struct PBRTOptions : BasicPBRTOptions {
     std::string displayServer;
     pstd::optional<Bounds2f> cropWindow;
     pstd::optional<Bounds2i> pixelBounds;
+    pstd::optional<Point2i> pixelMaterial;
 
     std::string ToString() const;
 };