Fixed bugs that led to failing prbvolpath tests, corrected and issue with directional volumetric pdf computation of meshes, and disabled memory heavy test_ad_integrators.py tests on Windows.

Author: Microno95

src/integrators/tests/test_ad_integrators.py

@@ -1097,7 +1097,7 @@ def test01_rendering_primal(variants_all_ad_rgb, integrator_name, config):
 
 
 @pytest.mark.slow
-# @pytest.mark.skipif(os.name == 'nt', reason='Skip those memory heavy tests on Windows')
+@pytest.mark.skipif(os.name == 'nt', reason='Skip those memory heavy tests on Windows')
 @pytest.mark.parametrize('integrator_name, config', CONFIGS)
 def test02_rendering_forward(variants_all_ad_rgb, integrator_name, config):
     if "volpath" in integrator_name and integrator_name != "prbvolpath":
@@ -1153,16 +1153,10 @@ def test02_rendering_forward(variants_all_ad_rgb, integrator_name, config):
         print(f"Success in config: {config.name}, {integrator_name}")
         print(f"-> error mean: {error_mean} (threshold={config.error_mean_threshold})")
         print(f"-> error max: {error_max} (threshold={config.error_max_threshold})")
-        # print(f'-> reference image: {pathlib.PurePath(filename)}')
-        # filename = join(os.getcwd(), f"test_{integrator_name}_{config.name}_image_fwd.exr")
-        # print(f'-> write current image: {pathlib.PurePath(filename)}')
-        # mi.util.write_bitmap(filename, image_fwd)
-        # filename = join(os.getcwd(), f"test_{integrator_name}_{config.name}_image_error.exr")
-        # print(f'-> write error image: {pathlib.PurePath(filename)}')
 
 
 @pytest.mark.slow
-# @pytest.mark.skipif(os.name == 'nt', reason='Skip those memory heavy tests on Windows')
+@pytest.mark.skipif(os.name == 'nt', reason='Skip those memory heavy tests on Windows')
 @pytest.mark.parametrize('integrator_name, config', CONFIGS)
 def test03_rendering_backward(variants_all_ad_rgb, integrator_name, config):
     if "volpath" in integrator_name and integrator_name != "prbvolpath":
@@ -1217,7 +1211,7 @@ def test03_rendering_backward(variants_all_ad_rgb, integrator_name, config):
 
 @pytest.mark.skip
 @pytest.mark.slow
-# @pytest.mark.skipif(os.name == 'nt', reason='Skip those memory heavy tests on Windows')
+@pytest.mark.skipif(os.name == 'nt', reason='Skip those memory heavy tests on Windows')
 def test04_render_custom_op(variants_all_ad_rgb):
     config = DiffuseAlbedoConfig()
     config.initialize()
@@ -1361,11 +1355,14 @@ def test04_render_custom_op(variants_all_ad_rgb):
 
         integrator_path = mi.load_dict({
             'type': 'volpath',
-            'max_depth': config.integrator_dict['max_depth']
+            'max_depth': config.integrator_dict['max_depth'],
+            # Use unidirectional sampling for the forward renders, best way to
+            # eliminate any bugs in things like Next-Event Estimation
+            'sampling_mode': 1
         })
 
         # Primal render
-        image_ref = integrator_path.render(config.scene, seed=0, spp=args.spp)
+        image_ref = integrator_path.render(config.scene, seed=0, spp=args.spp if args.spp > 1e5 else 192000)
 
         filename = join(output_dir, f"test_{config.name}_image_primal_ref.exr")
         mi.util.write_bitmap(filename, image_ref)
@@ -1379,7 +1376,7 @@ def test04_render_custom_op(variants_all_ad_rgb):
                 theta = mi.Float(fd_step * config.ref_fd_epsilon)
                 config.update(theta)
                 # Accumulate final image in double precision to avoid truncation error/underflow
-                image_1 = mi.TensorXd(integrator_path.render(config.scene, seed=0, spp=args.spp))
+                image_1 = mi.TensorXd(integrator_path.render(config.scene, seed=0, spp=args.spp if args.spp > 1e5 else 192000))
                 dr.eval(image_1)
                 if image_cumulative is not None:
                     image_cumulative = image_cumulative + fd_weight * image_1

src/python/python/ad/integrators/prbvolpath.py

@@ -285,7 +285,7 @@ def sample(self,
                     else:
                         δL += dr.forward_to(Le_surface)
 
-            L[active_e_surface_sampl] += dr.detach(Le_surface)
+            L[active_e_surface_sampl] += dr.detach(Le_surface if is_primal else -Le_surface)
 
             active_surface &= si.is_valid()
             bsdf_ctx = mi.BSDFContext()
@@ -335,7 +335,9 @@ def sample(self,
                                         adj_emitted=adj_emitted, adj_throughput=adj_throughput,
                                         δL=δL, mode=mode)
 
-                L[active_e] += dr.detach(Lr_dir)
+                L[active_e] += dr.detach(Lr_dir if is_primal else -Lr_dir)
+            else:
+                Lr_dir = mi.Spectrum(0.0)
 
             # -------------------- Phase function sampling ------------------
 

src/render/mesh.cpp

@@ -1037,6 +1037,7 @@ Mesh<Float, Spectrum>::sample_direction_volume(const Interaction3f &it, const Po
     auto bbox_volume = m_bbox.volume();
     auto bbox_volume_inv_cbrt = dr::rcp(dr::safe_cbrt(bbox_volume));
     dr::masked(near_t, active && (near_t < 0.f)) = 0.0f;
+    active &= (far_t > near_t);
     ds.dist = far_t;
     near_t *= bbox_volume_inv_cbrt;
     far_t *= bbox_volume_inv_cbrt;
@@ -1130,6 +1131,7 @@ MI_VARIANT Float Mesh<Float, Spectrum>::pdf_direction_volume(const Interaction3f
     auto bbox_volume = m_bbox.volume();
     auto bbox_volume_inv_cbrt = dr::rcp(dr::safe_cbrt(bbox_volume));
     dr::masked(near_t, active && (near_t < 0.f)) = 0.0f;
+    active &= (far_t > near_t);
     near_t *= bbox_volume_inv_cbrt;
     far_t *= bbox_volume_inv_cbrt;
     auto line_pdf = (dr::square(far_t) * far_t - dr::square(near_t) * near_t) / 3.f;

src/render/tests/test_mesh.py

@@ -1338,12 +1338,13 @@ def test35_mesh_vcalls(variants_vec_rgb):
 
 @fresolver_append_path
 def test36_correct_volume(variants_all_rgb):
-    objects_to_test = ["obj/cbox_smallbox.obj", "ply/bunny_watertight.ply"]
+    # Test that the correct volume is computed for both simple and complex meshes
+    objects_to_test = ["tests/obj/cbox_smallbox.obj", "common/meshes/bunny_watertight.ply"]
     object_volumes = [4559445.0373, 1.6012674570083618]
     for mesh_path, mesh_volume in zip(objects_to_test, object_volumes):
         shape = mi.load_dict({
             "type": "obj" if mesh_path.endswith("obj") else "ply",
-            "filename": f"resources/data/tests/{mesh_path}",
+            "filename": f"resources/data/{mesh_path}",
         })
         assert dr.allclose(shape.volume(), mesh_volume)
 
@@ -1380,9 +1381,10 @@ def test37_volume_position_sampling_normalisation(variants_vec_rgb):
 @pytest.mark.slow
 @fresolver_append_path
 def test38_volume_direction_sampling_normalisation(variants_vec_rgb):
+    # Test that the directional pdf is normalised
     shape = mi.load_dict({
         "type": "ply",
-        "filename": f"resources/data/tests/ply/bunny_watertight.ply",
+        "filename": f"resources/data/common/meshes/bunny_watertight.ply",
     })
 
     iter_count = 32
@@ -1406,6 +1408,9 @@ def test38_volume_direction_sampling_normalisation(variants_vec_rgb):
 
         resulting_line_pdfs = 0.0
 
+        # We select a set of random points both inside and outside the bounding sphere
+        # and then sample the entire sphere of directions. A normalised directional pdf
+        # will integrate to 1 over the entire sphere centered at any arbitrary point.
         if iter_index == 0:
             ray_offset = mi.Vector3f(0.0, 0.0, 0.0)
         else:
@@ -1430,7 +1435,7 @@ def test38_volume_direction_sampling_normalisation(variants_vec_rgb):
             test_ds.d = ray.d
 
             underlying_pdf = shape.pdf_direction_volume(test_si, test_ds, active)
-            resulting_line_pdfs = resulting_line_pdfs + (underlying_pdf / pdf)
+            resulting_line_pdfs = resulting_line_pdfs + underlying_pdf * dr.select(pdf != 0.0, dr.rcp(pdf), 0.0)
 
         sum_pdf = dr.mean(resulting_line_pdfs / iter_count, axis=None, mode="evaluated")
         assert(dr.allclose(sum_pdf, 1.0, atol=32/(32*131072)**0.5))