Make OpenGL optional in tests

Summary: Add an option to run tests without the OpenGL Renderer.

Reviewed By: patricklabatut

Differential Revision: D53573400

fbshipit-source-id: 54a14e7b2f156d24e0c561fdb279f4a9af01b793

tests/common_testing.py

@@ -24,6 +24,13 @@ def interactive_testing_requested() -> bool:
     return os.environ.get("PYTORCH3D_INTERACTIVE_TESTING", "") == "1"
 
 
+def skip_opengl_requested() -> bool:
+    return os.environ.get("PYTORCH3D_NO_TEST_OPENGL", "") == "1"
+
+
+usesOpengl = unittest.skipIf(skip_opengl_requested(), "uses opengl")
+
+
 def get_tests_dir() -> Path:
     """
     Returns Path for the directory containing this file.

tests/test_opengl_utils.py

@@ -26,7 +26,7 @@ from pytorch3d.renderer.opengl.opengl_utils import (  # noqa
     global_device_context_store,
 )
 
-from .common_testing import TestCaseMixin  # noqa
+from .common_testing import TestCaseMixin, usesOpengl  # noqa
 
 MAX_EGL_HEIGHT = global_device_context_store.max_egl_height
 MAX_EGL_WIDTH = global_device_context_store.max_egl_width
@@ -82,6 +82,7 @@ def _draw_squares_with_context_store(
             result[thread_id] = data
 
 
+@usesOpengl
 class TestDeviceContextStore(TestCaseMixin, unittest.TestCase):
     def test_cuda_context(self):
         cuda_context_1 = global_device_context_store.get_cuda_context(
@@ -118,6 +119,7 @@ class TestDeviceContextStore(TestCaseMixin, unittest.TestCase):
         self.assertIsNot(egl_context_1, egl_context_3)
 
 
+@usesOpengl
 class TestUtils(TestCaseMixin, unittest.TestCase):
     def test_load_extensions(self):
         # This should work
@@ -145,6 +147,7 @@ class TestUtils(TestCaseMixin, unittest.TestCase):
         self.assertEqual(attribute_array[2], egl.EGL_NONE)
 
 
+@usesOpengl
 class TestOpenGLSingleThreaded(TestCaseMixin, unittest.TestCase):
     def test_draw_square(self):
         context = EGLContext(width=MAX_EGL_WIDTH, height=MAX_EGL_HEIGHT)
@@ -184,6 +187,7 @@ class TestOpenGLSingleThreaded(TestCaseMixin, unittest.TestCase):
         )
 
 
+@usesOpengl
 class TestOpenGLMultiThreaded(TestCaseMixin, unittest.TestCase):
     def test_multiple_renders_single_gpu_single_context(self):
         _draw_squares_with_context()
@@ -321,6 +325,7 @@ class TestOpenGLMultiThreaded(TestCaseMixin, unittest.TestCase):
             thread.join()
 
 
+@usesOpengl
 class TestOpenGLUtils(TestCaseMixin, unittest.TestCase):
     @classmethod
     def tearDownClass(cls):

tests/test_rasterize_rectangle_images.py

@@ -51,6 +51,7 @@ from .common_testing import (
     get_tests_dir,
     load_rgb_image,
     TestCaseMixin,
+    usesOpengl,
 )
 
 
@@ -454,6 +455,7 @@ class TestRasterizeRectangleImagesMeshes(TestCaseMixin, unittest.TestCase):
     def test_render_cow(self):
         self._render_cow(MeshRasterizer)
 
+    @usesOpengl
     def test_render_cow_opengl(self):
         self._render_cow(MeshRasterizerOpenGL)
 

tests/test_rasterizer.py

@@ -33,7 +33,12 @@ from pytorch3d.structures import Pointclouds
 from pytorch3d.structures.meshes import Meshes
 from pytorch3d.utils.ico_sphere import ico_sphere
 
-from .common_testing import get_tests_dir, TestCaseMixin
+from .common_testing import (
+    get_tests_dir,
+    skip_opengl_requested,
+    TestCaseMixin,
+    usesOpengl,
+)
 
 
 DATA_DIR = get_tests_dir() / "data"
@@ -55,6 +60,7 @@ class TestMeshRasterizer(unittest.TestCase):
     def test_simple_sphere_fisheye(self):
         self._simple_sphere_fisheye_against_perspective(MeshRasterizer)
 
+    @usesOpengl
     def test_simple_sphere_opengl(self):
         self._simple_sphere(MeshRasterizerOpenGL)
 
@@ -250,9 +256,11 @@ class TestMeshRasterizer(unittest.TestCase):
         rasterizer = MeshRasterizer()
         rasterizer.to(device)
 
-        rasterizer = MeshRasterizerOpenGL()
-        rasterizer.to(device)
+        if not skip_opengl_requested():
+            rasterizer = MeshRasterizerOpenGL()
+            rasterizer.to(device)
 
+    @usesOpengl
     def test_compare_rasterizers(self):
         device = torch.device("cuda:0")
 
@@ -321,6 +329,7 @@ class TestMeshRasterizer(unittest.TestCase):
         )
 
 
+@usesOpengl
 class TestMeshRasterizerOpenGLUtils(TestCaseMixin, unittest.TestCase):
     def setUp(self):
         verts = torch.tensor(

tests/test_render_meshes.py

@@ -59,7 +59,9 @@ from .common_testing import (
     get_pytorch3d_dir,
     get_tests_dir,
     load_rgb_image,
+    skip_opengl_requested,
     TestCaseMixin,
+    usesOpengl,
 )
 
 # If DEBUG=True, save out images generated in the tests for debugging.
@@ -159,13 +161,16 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
                     MeshRasterizer, HardGouraudShader, "gouraud", "hard_gouraud"
                 ),
                 RasterizerTest(MeshRasterizer, HardFlatShader, "flat", "hard_flat"),
-                RasterizerTest(
-                    MeshRasterizerOpenGL,
-                    SplatterPhongShader,
-                    "splatter",
-                    "splatter_phong",
-                ),
             ]
+            if not skip_opengl_requested():
+                rasterizer_tests.append(
+                    RasterizerTest(
+                        MeshRasterizerOpenGL,
+                        SplatterPhongShader,
+                        "splatter",
+                        "splatter_phong",
+                    )
+                )
             for test in rasterizer_tests:
                 shader = test.shader(
                     lights=lights,
@@ -400,13 +405,16 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
                 MeshRasterizer, HardGouraudShader, "gouraud", "hard_gouraud"
             ),
             RasterizerTest(MeshRasterizer, HardFlatShader, "flat", "hard_flat"),
-            RasterizerTest(
-                MeshRasterizerOpenGL,
-                SplatterPhongShader,
-                "splatter",
-                "splatter_phong",
-            ),
         ]
+        if not skip_opengl_requested():
+            rasterizer_tests.append(
+                RasterizerTest(
+                    MeshRasterizerOpenGL,
+                    SplatterPhongShader,
+                    "splatter",
+                    "splatter_phong",
+                )
+            )
         for test in rasterizer_tests:
             reference_name = test.reference_name
             debug_name = test.debug_name
@@ -518,6 +526,7 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
         """
         self._texture_map_per_rasterizer(MeshRasterizer)
 
+    @usesOpengl
     def test_texture_map_opengl(self):
         """
         Test a mesh with a texture map is loaded and rendered correctly.
@@ -694,6 +703,7 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
     def test_batch_uvs(self):
         self._batch_uvs(MeshRasterizer)
 
+    @usesOpengl
     def test_batch_uvs_opengl(self):
         self._batch_uvs(MeshRasterizer)
 
@@ -786,6 +796,7 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
     def test_join_uvs(self):
         self._join_uvs(MeshRasterizer)
 
+    @usesOpengl
     def test_join_uvs_opengl(self):
         self._join_uvs(MeshRasterizerOpenGL)
 
@@ -975,6 +986,7 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
     def test_join_verts(self):
         self._join_verts(MeshRasterizer)
 
+    @usesOpengl
     def test_join_verts_opengl(self):
         self._join_verts(MeshRasterizerOpenGL)
 
@@ -1051,6 +1063,7 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
     def test_join_atlas(self):
         self._join_atlas(MeshRasterizer)
 
+    @usesOpengl
     def test_join_atlas_opengl(self):
         self._join_atlas(MeshRasterizerOpenGL)
 
@@ -1151,6 +1164,7 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
     def test_joined_spheres(self):
         self._joined_spheres(MeshRasterizer)
 
+    @usesOpengl
     def test_joined_spheres_opengl(self):
         self._joined_spheres(MeshRasterizerOpenGL)
 
@@ -1233,6 +1247,7 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
     def test_texture_map_atlas(self):
         self._texture_map_atlas(MeshRasterizer)
 
+    @usesOpengl
     def test_texture_map_atlas_opengl(self):
         self._texture_map_atlas(MeshRasterizerOpenGL)
 
@@ -1351,6 +1366,7 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
     def test_simple_sphere_outside_zfar(self):
         self._simple_sphere_outside_zfar(MeshRasterizer)
 
+    @usesOpengl
     def test_simple_sphere_outside_zfar_opengl(self):
         self._simple_sphere_outside_zfar(MeshRasterizerOpenGL)
 
@@ -1445,13 +1461,16 @@ class TestRenderMeshes(TestCaseMixin, unittest.TestCase):
         # No elevation or azimuth rotation
         rasterizer_tests = [
             RasterizerTest(MeshRasterizer, HardPhongShader, "phong", "hard_phong"),
-            RasterizerTest(
-                MeshRasterizerOpenGL,
-                SplatterPhongShader,
-                "splatter",
-                "splatter_phong",
-            ),
         ]
+        if not skip_opengl_requested():
+            rasterizer_tests.append(
+                RasterizerTest(
+                    MeshRasterizerOpenGL,
+                    SplatterPhongShader,
+                    "splatter",
+                    "splatter_phong",
+                )
+            )
         R, T = look_at_view_transform(2.7, 0.0, 0.0)
         for cam_type in (
             FoVPerspectiveCameras,

tests/test_render_multigpu.py

@@ -29,7 +29,7 @@ from pytorch3d.renderer.opengl import MeshRasterizerOpenGL
 from pytorch3d.structures import Meshes, Pointclouds
 from pytorch3d.utils.ico_sphere import ico_sphere
 
-from .common_testing import TestCaseMixin
+from .common_testing import TestCaseMixin, usesOpengl
 
 
 # Set the number of GPUS you want to test with
@@ -119,6 +119,7 @@ class TestRenderMeshesMultiGPU(TestCaseMixin, unittest.TestCase):
     def test_mesh_renderer_to(self):
         self._mesh_renderer_to(MeshRasterizer, SoftPhongShader)
 
+    @usesOpengl
     def test_mesh_renderer_opengl_to(self):
         self._mesh_renderer_to(MeshRasterizerOpenGL, SplatterPhongShader)
 
@@ -177,6 +178,7 @@ class TestRenderMeshesMultiGPU(TestCaseMixin, unittest.TestCase):
         self._render_meshes(MeshRasterizer, HardGouraudShader)
 
     # @unittest.skip("Multi-GPU OpenGL training is currently not supported.")
+    @usesOpengl
     def test_render_meshes_opengl(self):
         self._render_meshes(MeshRasterizerOpenGL, SplatterPhongShader)