From b19fe1de2fd39aa40c888a1cc02e45ed91a87851 Mon Sep 17 00:00:00 2001 From: Christoph Lassner Date: Tue, 3 Nov 2020 13:05:02 -0800 Subject: [PATCH] pulsar integration. Summary: This diff integrates the pulsar renderer source code into PyTorch3D as an alternative backend for the PyTorch3D point renderer. This diff is the first of a series of three diffs to complete that migration and focuses on the packaging and integration of the source code. For more information about the pulsar backend, see the release notes and the paper (https://arxiv.org/abs/2004.07484). For information on how to use the backend, see the point cloud rendering notebook and the examples in the folder `docs/examples`. Tasks addressed in the following diffs: * Add the PyTorch3D interface, * Add notebook examples and documentation (or adapt the existing ones to feature both interfaces). Reviewed By: nikhilaravi Differential Revision: D23947736 fbshipit-source-id: a5e77b53e6750334db22aefa89b4c079cda1b443 --- docs/examples/pulsar_basic.py | 50 + docs/examples/pulsar_cam.py | 158 ++ docs/examples/pulsar_multiview.py | 201 +++ docs/examples/pulsar_optimization.py | 140 ++ pytorch3d/csrc/ext.cpp | 91 + pytorch3d/csrc/pulsar/constants.h | 12 + pytorch3d/csrc/pulsar/cuda/README.md | 5 + pytorch3d/csrc/pulsar/cuda/commands.h | 501 ++++++ .../csrc/pulsar/cuda/renderer.backward.gpu.cu | 2 + .../pulsar/cuda/renderer.backward_dbg.gpu.cu | 2 + .../cuda/renderer.calc_gradients.gpu.cu | 2 + .../cuda/renderer.calc_signature.gpu.cu | 2 + .../pulsar/cuda/renderer.construct.gpu.cu | 2 + .../cuda/renderer.create_selector.gpu.cu | 2 + .../csrc/pulsar/cuda/renderer.destruct.gpu.cu | 2 + .../csrc/pulsar/cuda/renderer.fill_bg.gpu.cu | 2 + .../csrc/pulsar/cuda/renderer.forward.gpu.cu | 2 + .../cuda/renderer.norm_cam_gradients.gpu.cu | 2 + .../renderer.norm_sphere_gradients.gpu.cu | 2 + .../csrc/pulsar/cuda/renderer.render.gpu.cu | 2 + pytorch3d/csrc/pulsar/global.h | 85 + pytorch3d/csrc/pulsar/host/README.md | 5 + pytorch3d/csrc/pulsar/host/commands.h | 383 +++++ .../pulsar/host/renderer.backward.cpu.cpp | 2 + .../pulsar/host/renderer.backward_dbg.cpu.cpp | 2 + .../host/renderer.calc_gradients.cpu.cpp | 2 + .../host/renderer.calc_signature.cpu.cpp | 2 + .../pulsar/host/renderer.construct.cpu.cpp | 2 + .../host/renderer.create_selector.cpu.cpp | 2 + .../pulsar/host/renderer.destruct.cpu.cpp | 2 + .../csrc/pulsar/host/renderer.fill_bg.cpu.cpp | 2 + .../csrc/pulsar/host/renderer.forward.cpu.cpp | 2 + .../host/renderer.norm_cam_gradients.cpu.cpp | 2 + .../renderer.norm_sphere_gradients.cpu.cpp | 2 + .../csrc/pulsar/host/renderer.render.cpu.cpp | 2 + pytorch3d/csrc/pulsar/include/README.md | 16 + pytorch3d/csrc/pulsar/include/camera.device.h | 18 + pytorch3d/csrc/pulsar/include/camera.h | 72 + .../include/closest_sphere_tracker.device.h | 131 ++ pytorch3d/csrc/pulsar/include/commands.h | 30 + pytorch3d/csrc/pulsar/include/fastermath.h | 87 + pytorch3d/csrc/pulsar/include/math.h | 150 ++ .../pulsar/include/renderer.backward.device.h | 182 ++ .../include/renderer.backward.instantiate.h | 30 + .../include/renderer.backward_dbg.device.h | 150 ++ .../renderer.backward_dbg.instantiate.h | 32 + .../include/renderer.calc_gradients.device.h | 191 +++ .../renderer.calc_gradients.instantiate.h | 41 + .../include/renderer.calc_signature.device.h | 194 +++ .../renderer.calc_signature.instantiate.h | 18 + .../include/renderer.construct.device.h | 104 ++ .../include/renderer.construct.instantiate.h | 22 + .../include/renderer.create_selector.device.h | 34 + .../renderer.create_selector.instantiate.h | 23 + .../pulsar/include/renderer.destruct.device.h | 82 + .../include/renderer.destruct.instantiate.h | 13 + .../pulsar/include/renderer.draw.device.h | 839 ++++++++++ .../pulsar/include/renderer.fill_bg.device.h | 55 + .../include/renderer.fill_bg.instantiate.h | 15 + .../pulsar/include/renderer.forward.device.h | 293 ++++ .../include/renderer.forward.instantiate.h | 23 + .../include/renderer.get_screen_area.device.h | 137 ++ pytorch3d/csrc/pulsar/include/renderer.h | 461 +++++ .../renderer.norm_cam_gradients.device.h | 28 + .../renderer.norm_cam_gradients.instantiate.h | 10 + .../renderer.norm_sphere_gradients.device.h | 68 + ...nderer.norm_sphere_gradients.instantiate.h | 12 + .../pulsar/include/renderer.render.device.h | 409 +++++ .../include/renderer.render.instantiate.h | 39 + pytorch3d/csrc/pulsar/logging.h | 108 ++ pytorch3d/csrc/pulsar/pytorch/camera.cpp | 63 + pytorch3d/csrc/pulsar/pytorch/camera.h | 61 + pytorch3d/csrc/pulsar/pytorch/renderer.cpp | 1481 +++++++++++++++++ pytorch3d/csrc/pulsar/pytorch/renderer.h | 167 ++ pytorch3d/csrc/pulsar/pytorch/tensor_util.cpp | 48 + pytorch3d/csrc/pulsar/pytorch/tensor_util.h | 16 + pytorch3d/csrc/pulsar/pytorch/util.cpp | 24 + pytorch3d/csrc/pulsar/pytorch/util.h | 59 + pytorch3d/csrc/pulsar/warnings.cpp | 14 + pytorch3d/renderer/points/pulsar/__init__.py | 2 + pytorch3d/renderer/points/pulsar/renderer.py | 692 ++++++++ pytorch3d/transforms/__init__.py | 5 + pytorch3d/transforms/external/__init__.py | 1 + .../kornia_angle_axis_to_rotation_matrix.py | 94 ++ .../transforms/external/kornia_license.txt | 201 +++ tests/bm_barycentric_clipping.py | 4 + tests/bm_blending.py | 4 + tests/bm_cameras_alignment.py | 4 + tests/bm_chamfer.py | 6 + tests/bm_cubify.py | 4 + tests/bm_face_areas_normals.py | 4 + tests/bm_graph_conv.py | 4 + tests/bm_interpolate_face_attributes.py | 4 + tests/bm_knn.py | 4 + tests/bm_lighting.py | 4 + tests/bm_main.py | 34 +- tests/bm_mesh_edge_loss.py | 4 + tests/bm_mesh_io.py | 4 + tests/bm_mesh_laplacian_smoothing.py | 4 + tests/bm_mesh_normal_consistency.py | 4 + tests/bm_mesh_rasterizer_transform.py | 4 + tests/bm_meshes.py | 4 + tests/bm_packed_to_padded.py | 4 + tests/bm_perspective_n_points.py | 4 + tests/bm_point_mesh_distance.py | 4 + tests/bm_pointclouds.py | 4 + tests/bm_points_alignment.py | 5 + tests/bm_pulsar.py | 121 ++ tests/bm_rasterize_meshes.py | 4 + tests/bm_rasterize_points.py | 4 + tests/bm_sample_points_from_meshes.py | 4 + tests/bm_so3.py | 4 + tests/bm_subdivide_meshes.py | 4 + tests/bm_vert_align.py | 4 + tests/pulsar/__init__.py | 1 + tests/pulsar/create_multiview.py | 88 + .../examples_TestRenderer_test_cam.png | Bin 0 -> 112613 bytes .../examples_TestRenderer_test_cam_ortho.png | Bin 0 -> 63422 bytes ...examples_TestRenderer_test_multiview_0.png | Bin 0 -> 52316 bytes ...examples_TestRenderer_test_multiview_1.png | Bin 0 -> 52282 bytes ...examples_TestRenderer_test_multiview_2.png | Bin 0 -> 52061 bytes ...examples_TestRenderer_test_multiview_3.png | Bin 0 -> 52066 bytes ...examples_TestRenderer_test_multiview_4.png | Bin 0 -> 52468 bytes ...examples_TestRenderer_test_multiview_5.png | Bin 0 -> 52160 bytes ...examples_TestRenderer_test_multiview_6.png | Bin 0 -> 52546 bytes ...examples_TestRenderer_test_multiview_7.png | Bin 0 -> 53702 bytes .../examples_TestRenderer_test_smallopt.png | Bin 0 -> 118366 bytes tests/pulsar/reference/nr0000-in.pth | Bin 0 -> 1186356 bytes tests/pulsar/reference/nr0000-out.pth | Bin 0 -> 4719096 bytes tests/pulsar/test_channels.py | 149 ++ tests/pulsar/test_depth.py | 97 ++ tests/pulsar/test_forward.py | 353 ++++ tests/pulsar/test_hands.py | 120 ++ tests/pulsar/test_ortho.py | 126 ++ tests/pulsar/test_out/empty.txt | 0 tests/pulsar/test_small_spheres.py | 139 ++ tests/test_build.py | 29 +- 137 files changed, 10055 insertions(+), 37 deletions(-) create mode 100755 docs/examples/pulsar_basic.py create mode 100755 docs/examples/pulsar_cam.py create mode 100755 docs/examples/pulsar_multiview.py create mode 100755 docs/examples/pulsar_optimization.py create mode 100644 pytorch3d/csrc/pulsar/constants.h create mode 100644 pytorch3d/csrc/pulsar/cuda/README.md create mode 100644 pytorch3d/csrc/pulsar/cuda/commands.h create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.backward.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.backward_dbg.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.calc_gradients.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.calc_signature.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.construct.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.create_selector.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.destruct.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.fill_bg.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.forward.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.norm_cam_gradients.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.norm_sphere_gradients.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/cuda/renderer.render.gpu.cu create mode 100644 pytorch3d/csrc/pulsar/global.h create mode 100644 pytorch3d/csrc/pulsar/host/README.md create mode 100644 pytorch3d/csrc/pulsar/host/commands.h create mode 100644 pytorch3d/csrc/pulsar/host/renderer.backward.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.backward_dbg.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.calc_gradients.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.calc_signature.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.construct.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.create_selector.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.destruct.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.fill_bg.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.forward.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.norm_cam_gradients.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.norm_sphere_gradients.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/host/renderer.render.cpu.cpp create mode 100644 pytorch3d/csrc/pulsar/include/README.md create mode 100644 pytorch3d/csrc/pulsar/include/camera.device.h create mode 100644 pytorch3d/csrc/pulsar/include/camera.h create mode 100644 pytorch3d/csrc/pulsar/include/closest_sphere_tracker.device.h create mode 100644 pytorch3d/csrc/pulsar/include/commands.h create mode 100644 pytorch3d/csrc/pulsar/include/fastermath.h create mode 100644 pytorch3d/csrc/pulsar/include/math.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.backward.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.backward.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.backward_dbg.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.backward_dbg.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.calc_gradients.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.calc_gradients.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.calc_signature.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.calc_signature.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.construct.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.construct.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.create_selector.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.create_selector.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.destruct.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.destruct.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.draw.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.fill_bg.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.fill_bg.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.forward.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.forward.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.get_screen_area.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.norm_cam_gradients.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.norm_cam_gradients.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.norm_sphere_gradients.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.norm_sphere_gradients.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.render.device.h create mode 100644 pytorch3d/csrc/pulsar/include/renderer.render.instantiate.h create mode 100644 pytorch3d/csrc/pulsar/logging.h create mode 100644 pytorch3d/csrc/pulsar/pytorch/camera.cpp create mode 100644 pytorch3d/csrc/pulsar/pytorch/camera.h create mode 100644 pytorch3d/csrc/pulsar/pytorch/renderer.cpp create mode 100644 pytorch3d/csrc/pulsar/pytorch/renderer.h create mode 100644 pytorch3d/csrc/pulsar/pytorch/tensor_util.cpp create mode 100644 pytorch3d/csrc/pulsar/pytorch/tensor_util.h create mode 100644 pytorch3d/csrc/pulsar/pytorch/util.cpp create mode 100644 pytorch3d/csrc/pulsar/pytorch/util.h create mode 100644 pytorch3d/csrc/pulsar/warnings.cpp create mode 100644 pytorch3d/renderer/points/pulsar/__init__.py create mode 100644 pytorch3d/renderer/points/pulsar/renderer.py create mode 100644 pytorch3d/transforms/external/__init__.py create mode 100644 pytorch3d/transforms/external/kornia_angle_axis_to_rotation_matrix.py create mode 100644 pytorch3d/transforms/external/kornia_license.txt create mode 100755 tests/bm_pulsar.py create mode 100644 tests/pulsar/__init__.py create mode 100644 tests/pulsar/create_multiview.py create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_cam.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_cam_ortho.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_multiview_0.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_multiview_1.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_multiview_2.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_multiview_3.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_multiview_4.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_multiview_5.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_multiview_6.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_multiview_7.png create mode 100644 tests/pulsar/reference/examples_TestRenderer_test_smallopt.png create mode 100644 tests/pulsar/reference/nr0000-in.pth create mode 100644 tests/pulsar/reference/nr0000-out.pth create mode 100644 tests/pulsar/test_channels.py create mode 100644 tests/pulsar/test_depth.py create mode 100644 tests/pulsar/test_forward.py create mode 100644 tests/pulsar/test_hands.py create mode 100644 tests/pulsar/test_ortho.py create mode 100644 tests/pulsar/test_out/empty.txt create mode 100644 tests/pulsar/test_small_spheres.py diff --git a/docs/examples/pulsar_basic.py b/docs/examples/pulsar_basic.py new file mode 100755 index 00000000..62dccd03 --- /dev/null +++ b/docs/examples/pulsar_basic.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +""" +This example demonstrates the most trivial, direct interface of the pulsar +sphere renderer. It renders and saves an image with 10 random spheres. +Output: basic.png. +""" +from os import path + +import imageio +import torch +from pytorch3d.renderer.points.pulsar import Renderer + + +n_points = 10 +width = 1_000 +height = 1_000 +device = torch.device("cuda") +renderer = Renderer(width, height, n_points).to(device) +# Generate sample data. +vert_pos = torch.rand(n_points, 3, dtype=torch.float32, device=device) * 10.0 +vert_pos[:, 2] += 25.0 +vert_pos[:, :2] -= 5.0 +vert_col = torch.rand(n_points, 3, dtype=torch.float32, device=device) +vert_rad = torch.rand(n_points, dtype=torch.float32, device=device) +cam_params = torch.tensor( + [ + 0.0, + 0.0, + 0.0, # Position 0, 0, 0 (x, y, z). + 0.0, + 0.0, + 0.0, # Rotation 0, 0, 0 (in axis-angle format). + 5.0, # Focal length in world size. + 2.0, # Sensor size in world size. + ], + dtype=torch.float32, + device=device, +) +# Render. +image = renderer( + vert_pos, + vert_col, + vert_rad, + cam_params, + 1.0e-1, # Renderer blending parameter gamma, in [1., 1e-5]. + 45.0, # Maximum depth. +) +print("Writing image to `%s`." % (path.abspath("basic.png"))) +imageio.imsave("basic.png", (image.cpu().detach() * 255.0).to(torch.uint8).numpy()) diff --git a/docs/examples/pulsar_cam.py b/docs/examples/pulsar_cam.py new file mode 100755 index 00000000..dcc08759 --- /dev/null +++ b/docs/examples/pulsar_cam.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +""" +This example demonstrates camera parameter optimization with the plain +pulsar interface. For this, a reference image has been pre-generated +(you can find it at `../../tests/pulsar/reference/examples_TestRenderer_test_cam.png`). +The same scene parameterization is loaded and the camera parameters +distorted. Gradient-based optimization is used to converge towards the +original camera parameters. +""" +from os import path + +import cv2 +import imageio +import numpy as np +import torch +from pytorch3d.renderer.points.pulsar import Renderer +from torch import nn, optim + + +n_points = 20 +width = 1_000 +height = 1_000 +device = torch.device("cuda") + + +class SceneModel(nn.Module): + """ + A simple scene model to demonstrate use of pulsar in PyTorch modules. + + The scene model is parameterized with sphere locations (vert_pos), + channel content (vert_col), radiuses (vert_rad), camera position (cam_pos), + camera rotation (cam_rot) and sensor focal length and width (cam_sensor). + + The forward method of the model renders this scene description. Any + of these parameters could instead be passed as inputs to the forward + method and come from a different model. + """ + + def __init__(self): + super(SceneModel, self).__init__() + self.gamma = 0.1 + # Points. + torch.manual_seed(1) + vert_pos = torch.rand(n_points, 3, dtype=torch.float32) * 10.0 + vert_pos[:, 2] += 25.0 + vert_pos[:, :2] -= 5.0 + self.register_parameter("vert_pos", nn.Parameter(vert_pos, requires_grad=False)) + self.register_parameter( + "vert_col", + nn.Parameter( + torch.rand(n_points, 3, dtype=torch.float32), requires_grad=False + ), + ) + self.register_parameter( + "vert_rad", + nn.Parameter( + torch.rand(n_points, dtype=torch.float32), requires_grad=False + ), + ) + self.register_parameter( + "cam_pos", + nn.Parameter( + torch.tensor([0.1, 0.1, 0.0], dtype=torch.float32), requires_grad=True + ), + ) + self.register_parameter( + "cam_rot", + nn.Parameter( + torch.tensor( + [ + # We're using the 6D rot. representation for better gradients. + 0.9995, + 0.0300445, + -0.0098482, + -0.0299445, + 0.9995, + 0.0101482, + ], + dtype=torch.float32, + ), + requires_grad=True, + ), + ) + self.register_parameter( + "cam_sensor", + nn.Parameter( + torch.tensor([4.8, 1.8], dtype=torch.float32), requires_grad=True + ), + ) + self.renderer = Renderer(width, height, n_points) + + def forward(self): + return self.renderer.forward( + self.vert_pos, + self.vert_col, + self.vert_rad, + torch.cat([self.cam_pos, self.cam_rot, self.cam_sensor]), + self.gamma, + 45.0, + ) + + +# Load reference. +ref = ( + torch.from_numpy( + imageio.imread( + "../../tests/pulsar/reference/examples_TestRenderer_test_cam.png" + ) + ).to(torch.float32) + / 255.0 +).to(device) +# Set up model. +model = SceneModel().to(device) +# Optimizer. +optimizer = optim.SGD( + [ + {"params": [model.cam_pos], "lr": 1e-4}, # 1e-3 + {"params": [model.cam_rot], "lr": 5e-6}, + {"params": [model.cam_sensor], "lr": 1e-4}, + ] +) + +print("Writing video to `%s`." % (path.abspath("cam.gif"))) +writer = imageio.get_writer("cam.gif", format="gif", fps=25) + +# Optimize. +for i in range(300): + optimizer.zero_grad() + result = model() + # Visualize. + result_im = (result.cpu().detach().numpy() * 255).astype(np.uint8) + cv2.imshow("opt", result_im[:, :, ::-1]) + writer.append_data(result_im) + overlay_img = np.ascontiguousarray( + ((result * 0.5 + ref * 0.5).cpu().detach().numpy() * 255).astype(np.uint8)[ + :, :, ::-1 + ] + ) + overlay_img = cv2.putText( + overlay_img, + "Step %d" % (i), + (10, 40), + cv2.FONT_HERSHEY_SIMPLEX, + 1, + (0, 0, 0), + 2, + cv2.LINE_AA, + False, + ) + cv2.imshow("overlay", overlay_img) + cv2.waitKey(1) + # Update. + loss = ((result - ref) ** 2).sum() + print("loss {}: {}".format(i, loss.item())) + loss.backward() + optimizer.step() +writer.close() diff --git a/docs/examples/pulsar_multiview.py b/docs/examples/pulsar_multiview.py new file mode 100755 index 00000000..4be9af72 --- /dev/null +++ b/docs/examples/pulsar_multiview.py @@ -0,0 +1,201 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +""" +This example demonstrates multiview 3D reconstruction using the plain +pulsar interface. For this, reference images have been pre-generated +(you can find them at `../../tests/pulsar/reference/examples_TestRenderer_test_multiview_%d.png`). +The camera parameters are assumed given. The scene is initialized with +random spheres. Gradient-based optimization is used to optimize sphere +parameters and prune spheres to converge to a 3D representation. +""" +from os import path + +import cv2 +import imageio +import numpy as np +import torch +from pytorch3d.renderer.points.pulsar import Renderer +from torch import nn, optim + + +n_points = 400_000 +width = 1_000 +height = 1_000 +visualize_ids = [0, 1] +device = torch.device("cuda") + + +class SceneModel(nn.Module): + """ + A simple scene model to demonstrate use of pulsar in PyTorch modules. + + The scene model is parameterized with sphere locations (vert_pos), + channel content (vert_col), radiuses (vert_rad), camera position (cam_pos), + camera rotation (cam_rot) and sensor focal length and width (cam_sensor). + + The forward method of the model renders this scene description. Any + of these parameters could instead be passed as inputs to the forward + method and come from a different model. Optionally, camera parameters can + be provided to the forward method in which case the scene is rendered + using those parameters. + """ + + def __init__(self): + super(SceneModel, self).__init__() + self.gamma = 1.0 + # Points. + torch.manual_seed(1) + vert_pos = torch.rand((1, n_points, 3), dtype=torch.float32) * 10.0 + vert_pos[:, :, 2] += 25.0 + vert_pos[:, :, :2] -= 5.0 + self.register_parameter("vert_pos", nn.Parameter(vert_pos, requires_grad=True)) + self.register_parameter( + "vert_col", + nn.Parameter( + torch.ones(1, n_points, 3, dtype=torch.float32) * 0.5, + requires_grad=True, + ), + ) + self.register_parameter( + "vert_rad", + nn.Parameter( + torch.ones(1, n_points, dtype=torch.float32) * 0.05, requires_grad=True + ), + ) + self.register_parameter( + "vert_opy", + nn.Parameter( + torch.ones(1, n_points, dtype=torch.float32), requires_grad=True + ), + ) + self.register_buffer( + "cam_params", + torch.tensor( + [ + [ + np.sin(angle) * 35.0, + 0.0, + 30.0 - np.cos(angle) * 35.0, + 0.0, + -angle, + 0.0, + 5.0, + 2.0, + ] + for angle in [-1.5, -0.8, -0.4, -0.1, 0.1, 0.4, 0.8, 1.5] + ], + dtype=torch.float32, + ), + ) + self.renderer = Renderer(width, height, n_points) + + def forward(self, cam=None): + if cam is None: + cam = self.cam_params + n_views = 8 + else: + n_views = 1 + return self.renderer.forward( + self.vert_pos.expand(n_views, -1, -1), + self.vert_col.expand(n_views, -1, -1), + self.vert_rad.expand(n_views, -1), + cam, + self.gamma, + 45.0, + ) + + +# Load reference. +ref = torch.stack( + [ + torch.from_numpy( + imageio.imread( + "../../tests/pulsar/reference/examples_TestRenderer_test_multiview_%d.png" + % idx + ) + ).to(torch.float32) + / 255.0 + for idx in range(8) + ] +).to(device) +# Set up model. +model = SceneModel().to(device) +# Optimizer. +optimizer = optim.SGD( + [ + {"params": [model.vert_col], "lr": 1e-1}, + {"params": [model.vert_rad], "lr": 1e-3}, + {"params": [model.vert_pos], "lr": 1e-3}, + ] +) + +# For visualization. +angle = 0.0 +print("Writing video to `%s`." % (path.abspath("multiview.avi"))) +writer = imageio.get_writer("multiview.gif", format="gif", fps=25) + +# Optimize. +for i in range(300): + optimizer.zero_grad() + result = model() + # Visualize. + result_im = (result.cpu().detach().numpy() * 255).astype(np.uint8) + cv2.imshow("opt", result_im[0, :, :, ::-1]) + overlay_img = np.ascontiguousarray( + ((result * 0.5 + ref * 0.5).cpu().detach().numpy() * 255).astype(np.uint8)[ + 0, :, :, ::-1 + ] + ) + overlay_img = cv2.putText( + overlay_img, + "Step %d" % (i), + (10, 40), + cv2.FONT_HERSHEY_SIMPLEX, + 1, + (0, 0, 0), + 2, + cv2.LINE_AA, + False, + ) + cv2.imshow("overlay", overlay_img) + cv2.waitKey(1) + # Update. + loss = ((result - ref) ** 2).sum() + print("loss {}: {}".format(i, loss.item())) + loss.backward() + optimizer.step() + # Cleanup. + with torch.no_grad(): + model.vert_col.data = torch.clamp(model.vert_col.data, 0.0, 1.0) + # Remove points. + model.vert_pos.data[model.vert_rad < 0.001, :] = -1000.0 + model.vert_rad.data[model.vert_rad < 0.001] = 0.0001 + vd = ( + (model.vert_col - torch.ones(1, 1, 3, dtype=torch.float32).to(device)) + .abs() + .sum(dim=2) + ) + model.vert_pos.data[vd <= 0.2] = -1000.0 + # Rotating visualization. + cam_control = torch.tensor( + [ + [ + np.sin(angle) * 35.0, + 0.0, + 30.0 - np.cos(angle) * 35.0, + 0.0, + -angle, + 0.0, + 5.0, + 2.0, + ] + ], + dtype=torch.float32, + ).to(device) + with torch.no_grad(): + result = model.forward(cam=cam_control)[0] + result_im = (result.cpu().detach().numpy() * 255).astype(np.uint8) + cv2.imshow("vis", result_im[:, :, ::-1]) + writer.append_data(result_im) + angle += 0.05 +writer.close() diff --git a/docs/examples/pulsar_optimization.py b/docs/examples/pulsar_optimization.py new file mode 100755 index 00000000..67b2f81b --- /dev/null +++ b/docs/examples/pulsar_optimization.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +""" +This example demonstrates scene optimization with the plain +pulsar interface. For this, a reference image has been pre-generated +(you can find it at `../../tests/pulsar/reference/examples_TestRenderer_test_smallopt.png`). +The scene is initialized with random spheres. Gradient-based +optimization is used to converge towards a faithful +scene representation. +""" +import cv2 +import imageio +import numpy as np +import torch +from pytorch3d.renderer.points.pulsar import Renderer +from torch import nn, optim + + +n_points = 10_000 +width = 1_000 +height = 1_000 +device = torch.device("cuda") + + +class SceneModel(nn.Module): + """ + A simple scene model to demonstrate use of pulsar in PyTorch modules. + + The scene model is parameterized with sphere locations (vert_pos), + channel content (vert_col), radiuses (vert_rad), camera position (cam_pos), + camera rotation (cam_rot) and sensor focal length and width (cam_sensor). + + The forward method of the model renders this scene description. Any + of these parameters could instead be passed as inputs to the forward + method and come from a different model. + """ + + def __init__(self): + super(SceneModel, self).__init__() + self.gamma = 1.0 + # Points. + torch.manual_seed(1) + vert_pos = torch.rand(n_points, 3, dtype=torch.float32) * 10.0 + vert_pos[:, 2] += 25.0 + vert_pos[:, :2] -= 5.0 + self.register_parameter("vert_pos", nn.Parameter(vert_pos, requires_grad=True)) + self.register_parameter( + "vert_col", + nn.Parameter( + torch.ones(n_points, 3, dtype=torch.float32) * 0.5, requires_grad=True + ), + ) + self.register_parameter( + "vert_rad", + nn.Parameter( + torch.ones(n_points, dtype=torch.float32) * 0.3, requires_grad=True + ), + ) + self.register_buffer( + "cam_params", + torch.tensor([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.0, 2.0], dtype=torch.float32), + ) + # The volumetric optimization works better with a higher number of tracked + # intersections per ray. + self.renderer = Renderer(width, height, n_points, n_track=32) + + def forward(self): + return self.renderer.forward( + self.vert_pos, + self.vert_col, + self.vert_rad, + self.cam_params, + self.gamma, + 45.0, + return_forward_info=True, + ) + + +# Load reference. +ref = ( + torch.from_numpy( + imageio.imread( + "../../tests/pulsar/reference/examples_TestRenderer_test_smallopt.png" + ) + ).to(torch.float32) + / 255.0 +).to(device) +# Set up model. +model = SceneModel().to(device) +# Optimizer. +optimizer = optim.SGD( + [ + {"params": [model.vert_col], "lr": 1e0}, + {"params": [model.vert_rad], "lr": 5e-3}, + {"params": [model.vert_pos], "lr": 1e-2}, + ] +) + +# Optimize. +for i in range(500): + optimizer.zero_grad() + result, result_info = model() + # Visualize. + result_im = (result.cpu().detach().numpy() * 255).astype(np.uint8) + cv2.imshow("opt", result_im[:, :, ::-1]) + overlay_img = np.ascontiguousarray( + ((result * 0.5 + ref * 0.5).cpu().detach().numpy() * 255).astype(np.uint8)[ + :, :, ::-1 + ] + ) + overlay_img = cv2.putText( + overlay_img, + "Step %d" % (i), + (10, 40), + cv2.FONT_HERSHEY_SIMPLEX, + 1, + (0, 0, 0), + 2, + cv2.LINE_AA, + False, + ) + cv2.imshow("overlay", overlay_img) + cv2.waitKey(1) + # Update. + loss = ((result - ref) ** 2).sum() + print("loss {}: {}".format(i, loss.item())) + loss.backward() + optimizer.step() + # Cleanup. + with torch.no_grad(): + model.vert_col.data = torch.clamp(model.vert_col.data, 0.0, 1.0) + # Remove points. + model.vert_pos.data[model.vert_rad < 0.001, :] = -1000.0 + model.vert_rad.data[model.vert_rad < 0.001] = 0.0001 + vd = ( + (model.vert_col - torch.ones(3, dtype=torch.float32).to(device)) + .abs() + .sum(dim=1) + ) + model.vert_pos.data[vd <= 0.2] = -1000.0 diff --git a/pytorch3d/csrc/ext.cpp b/pytorch3d/csrc/ext.cpp index c80800e3..5fae7948 100644 --- a/pytorch3d/csrc/ext.cpp +++ b/pytorch3d/csrc/ext.cpp @@ -1,6 +1,11 @@ // Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +// clang-format off +#include "./pulsar/global.h" // Include before . #include +// clang-format on +#include "./pulsar/pytorch/renderer.h" +#include "./pulsar/pytorch/tensor_util.h" #include "blending/sigmoid_alpha_blend.h" #include "compositing/alpha_composite.h" #include "compositing/norm_weighted_sum.h" @@ -65,4 +70,90 @@ PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { m.def("face_point_dist_backward", &FacePointDistanceBackward); m.def("point_face_array_dist_forward", &PointFaceArrayDistanceForward); m.def("point_face_array_dist_backward", &PointFaceArrayDistanceBackward); + + // Pulsar. +#ifdef PULSAR_LOGGING_ENABLED + c10::ShowLogInfoToStderr(); +#endif + py::class_< + pulsar::pytorch::Renderer, + std::shared_ptr>(m, "PulsarRenderer") + .def(py::init< + const uint&, + const uint&, + const uint&, + const bool&, + const bool&, + const float&, + const uint&, + const uint&>()) + .def( + "__eq__", + [](const pulsar::pytorch::Renderer& a, + const pulsar::pytorch::Renderer& b) { return a == b; }, + py::is_operator()) + .def( + "__ne__", + [](const pulsar::pytorch::Renderer& a, + const pulsar::pytorch::Renderer& b) { return !(a == b); }, + py::is_operator()) + .def( + "__repr__", + [](const pulsar::pytorch::Renderer& self) { + std::stringstream ss; + ss << self; + return ss.str(); + }) + .def( + "forward", + &pulsar::pytorch::Renderer::forward, + py::arg("vert_pos"), + py::arg("vert_col"), + py::arg("vert_radii"), + + py::arg("cam_pos"), + py::arg("pixel_0_0_center"), + py::arg("pixel_vec_x"), + py::arg("pixel_vec_y"), + py::arg("focal_length"), + py::arg("principal_point_offsets"), + + py::arg("gamma"), + py::arg("max_depth"), + py::arg("min_depth") /* = 0.f*/, + py::arg( + "bg_col") /* = at::nullopt not exposed properly in pytorch 1.1. */ + , + py::arg("opacity") /* = at::nullopt ... */, + py::arg("percent_allowed_difference") = 0.01f, + py::arg("max_n_hits") = MAX_UINT, + py::arg("mode") = 0) + .def("backward", &pulsar::pytorch::Renderer::backward) + .def_property( + "device_tracker", + [](const pulsar::pytorch::Renderer& self) { + return self.device_tracker; + }, + [](pulsar::pytorch::Renderer& self, const torch::Tensor& val) { + self.device_tracker = val; + }) + .def_property_readonly("width", &pulsar::pytorch::Renderer::width) + .def_property_readonly("height", &pulsar::pytorch::Renderer::height) + .def_property_readonly( + "max_num_balls", &pulsar::pytorch::Renderer::max_num_balls) + .def_property_readonly( + "orthogonal", &pulsar::pytorch::Renderer::orthogonal) + .def_property_readonly( + "right_handed", &pulsar::pytorch::Renderer::right_handed) + .def_property_readonly("n_track", &pulsar::pytorch::Renderer::n_track); + m.def( + "pulsar_sphere_ids_from_result_info_nograd", + &pulsar::pytorch::sphere_ids_from_result_info_nograd); + // Constants. + m.attr("EPS") = py::float_(EPS); + m.attr("MAX_FLOAT") = py::float_(MAX_FLOAT); + m.attr("MAX_INT") = py::int_(MAX_INT); + m.attr("MAX_UINT") = py::int_(MAX_UINT); + m.attr("MAX_USHORT") = py::int_(MAX_USHORT); + m.attr("PULSAR_MAX_GRAD_SPHERES") = py::int_(MAX_GRAD_SPHERES); } diff --git a/pytorch3d/csrc/pulsar/constants.h b/pytorch3d/csrc/pulsar/constants.h new file mode 100644 index 00000000..787f0456 --- /dev/null +++ b/pytorch3d/csrc/pulsar/constants.h @@ -0,0 +1,12 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_CONSTANTS_H_ +#define PULSAR_NATIVE_CONSTANTS_H_ + +#define EPS 1E-6 +#define FEPS 1E-6f +#define MAX_FLOAT 3.4E38f +#define MAX_INT 2147483647 +#define MAX_UINT 4294967295u +#define MAX_USHORT 65535u + +#endif diff --git a/pytorch3d/csrc/pulsar/cuda/README.md b/pytorch3d/csrc/pulsar/cuda/README.md new file mode 100644 index 00000000..60c5d07c --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/README.md @@ -0,0 +1,5 @@ +# CUDA device compilation units + +This folder contains `.cu` files to create compilation units +for device-specific functions. See `../include/README.md` for +more information. diff --git a/pytorch3d/csrc/pulsar/cuda/commands.h b/pytorch3d/csrc/pulsar/cuda/commands.h new file mode 100644 index 00000000..fa966e8b --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/commands.h @@ -0,0 +1,501 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_CUDA_COMMANDS_H_ +#define PULSAR_NATIVE_CUDA_COMMANDS_H_ + +// Definitions for GPU commands. +#include +#include +namespace cg = cooperative_groups; + +#ifdef __DRIVER_TYPES_H__ +#ifndef DEVICE_RESET +#define DEVICE_RESET cudaDeviceReset(); +#endif +#else +#ifndef DEVICE_RESET +#define DEVICE_RESET +#endif +#endif + +#define HANDLECUDA(CMD) CMD +// handleCudaError((CMD), __FILE__, __LINE__) +inline void +handleCudaError(const cudaError_t err, const char* file, const int line) { + if (err != cudaSuccess) { +#ifndef __NVCC__ + fprintf( + stderr, + "%s(%i) : getLastCudaError() CUDA error :" + " (%d) %s.\n", + file, + line, + static_cast(err), + cudaGetErrorString(err)); + DEVICE_RESET + exit(1); +#endif + } +} +inline void +getLastCudaError(const char* errorMessage, const char* file, const int line) { + cudaError_t err = cudaGetLastError(); + if (cudaSuccess != err) { + fprintf(stderr, "Error: %s.", errorMessage); + handleCudaError(err, file, line); + } +} + +#define ALIGN(VAL) __align__(VAL) +#define SYNC() HANDLECUDE(cudaDeviceSynchronize()) +#define THREADFENCE_B() __threadfence_block() +#define SHFL_SYNC(a, b, c) __shfl_sync((a), (b), (c)) +#define SHARED __shared__ +#define ACTIVEMASK() __activemask() +#define BALLOT(mask, val) __ballot_sync((mask), val) +/** + * Find the cumulative sum within a warp up to the current + * thread lane, with each mask thread contributing base. + */ +template +DEVICE T +WARP_CUMSUM(const cg::coalesced_group& group, const uint& mask, const T& base) { + T ret = base; + T shfl_val; + shfl_val = __shfl_down_sync(mask, ret, 1u); // Deactivate the rightmost lane. + ret += (group.thread_rank() < 31) * shfl_val; + shfl_val = __shfl_down_sync(mask, ret, 2u); + ret += (group.thread_rank() < 30) * shfl_val; + shfl_val = __shfl_down_sync(mask, ret, 4u); // ...4 + ret += (group.thread_rank() < 28) * shfl_val; + shfl_val = __shfl_down_sync(mask, ret, 8u); // ...8 + ret += (group.thread_rank() < 24) * shfl_val; + shfl_val = __shfl_down_sync(mask, ret, 16u); // ...16 + ret += (group.thread_rank() < 16) * shfl_val; + return ret; +} + +template +DEVICE T +WARP_MAX(const cg::coalesced_group& group, const uint& mask, const T& base) { + T ret = base; + ret = max(ret, __shfl_down_sync(mask, ret, 16u)); + ret = max(ret, __shfl_down_sync(mask, ret, 8u)); + ret = max(ret, __shfl_down_sync(mask, ret, 4u)); + ret = max(ret, __shfl_down_sync(mask, ret, 2u)); + ret = max(ret, __shfl_down_sync(mask, ret, 1u)); + return ret; +} + +template +DEVICE T +WARP_SUM(const cg::coalesced_group& group, const uint& mask, const T& base) { + T ret = base; + ret = ret + __shfl_down_sync(mask, ret, 16u); + ret = ret + __shfl_down_sync(mask, ret, 8u); + ret = ret + __shfl_down_sync(mask, ret, 4u); + ret = ret + __shfl_down_sync(mask, ret, 2u); + ret = ret + __shfl_down_sync(mask, ret, 1u); + return ret; +} + +INLINE DEVICE float3 WARP_SUM_FLOAT3( + const cg::coalesced_group& group, + const uint& mask, + const float3& base) { + float3 ret = base; + ret.x = WARP_SUM(group, mask, base.x); + ret.y = WARP_SUM(group, mask, base.y); + ret.z = WARP_SUM(group, mask, base.z); + return ret; +} + +// Floating point. +// #define FMUL(a, b) __fmul_rn((a), (b)) +#define FMUL(a, b) ((a) * (b)) +#define FDIV(a, b) __fdiv_rn((a), (b)) +// #define FSUB(a, b) __fsub_rn((a), (b)) +#define FSUB(a, b) ((a) - (b)) +#define FADD(a, b) __fadd_rn((a), (b)) +#define FSQRT(a) __fsqrt_rn(a) +#define FEXP(a) fasterexp(a) +#define FLN(a) fasterlog(a) +#define FPOW(a, b) __powf((a), (b)) +#define FMAX(a, b) fmax((a), (b)) +#define FMIN(a, b) fmin((a), (b)) +#define FCEIL(a) ceilf(a) +#define FFLOOR(a) floorf(a) +#define FROUND(x) nearbyintf(x) +#define FSATURATE(x) __saturatef(x) +#define FABS(a) abs(a) +#define IASF(a, loc) (loc) = __int_as_float(a) +#define FASI(a, loc) (loc) = __float_as_int(a) +#define FABSLEQAS(a, b, c) \ + ((a) <= (b) ? FSUB((b), (a)) <= (c) : FSUB((a), (b)) < (c)) +/** Calculates x*y+z. */ +#define FMA(x, y, z) __fmaf_rn((x), (y), (z)) +#define I2F(a) __int2float_rn(a) +#define FRCP(x) __frcp_rn(x) +__device__ static float atomicMax(float* address, float val) { + int* address_as_i = (int*)address; + int old = *address_as_i, assumed; + do { + assumed = old; + old = ::atomicCAS( + address_as_i, + assumed, + __float_as_int(::fmaxf(val, __int_as_float(assumed)))); + } while (assumed != old); + return __int_as_float(old); +} +__device__ static float atomicMin(float* address, float val) { + int* address_as_i = (int*)address; + int old = *address_as_i, assumed; + do { + assumed = old; + old = ::atomicCAS( + address_as_i, + assumed, + __float_as_int(::fminf(val, __int_as_float(assumed)))); + } while (assumed != old); + return __int_as_float(old); +} +#define DMAX(a, b) FMAX(a, b) +#define DMIN(a, b) FMIN(a, b) +#define DSQRT(a) sqrt(a) +#define DSATURATE(a) DMIN(1., DMAX(0., (a))) +// half +#define HADD(a, b) __hadd((a), (b)) +#define HSUB2(a, b) __hsub2((a), (b)) +#define HMUL2(a, b) __hmul2((a), (b)) +#define HSQRT(a) hsqrt(a) + +// uint. +#define CLZ(VAL) __clz(VAL) +#define POPC(a) __popc(a) +// +// +// +// +// +// +// +// +// +#define ATOMICADD(PTR, VAL) atomicAdd((PTR), (VAL)) +#define ATOMICADD_F3(PTR, VAL) \ + ATOMICADD(&((PTR)->x), VAL.x); \ + ATOMICADD(&((PTR)->y), VAL.y); \ + ATOMICADD(&((PTR)->z), VAL.z); +#if (CUDART_VERSION >= 10000) +#define ATOMICADD_B(PTR, VAL) atomicAdd_block((PTR), (VAL)) +#else +#define ATOMICADD_B(PTR, VAL) ATOMICADD(PTR, VAL) +#endif +// +// +// +// +// int. +#define IMIN(a, b) min((a), (b)) +#define IMAX(a, b) max((a), (b)) +#define IABS(a) abs(a) + +// Checks. +#define CHECKOK THCudaCheck +#define ARGCHECK THArgCheck + +// Math. +#define NORM3DF(x, y, z) norm3df(x, y, z) +#define RNORM3DF(x, y, z) rnorm3df(x, y, z) + +// High level. +INLINE DEVICE void prefetch_l1(unsigned long addr) { + asm(" prefetch.global.L1 [ %1 ];" : "=l"(addr) : "l"(addr)); +} +#define PREFETCH(PTR) prefetch_l1((unsigned long)(PTR)) +#define GET_SORT_WS_SIZE(RES_PTR, KEY_TYPE, VAL_TYPE, NUM_OBJECTS) \ + cub::DeviceRadixSort::SortPairsDescending( \ + (void*)NULL, \ + *(RES_PTR), \ + reinterpret_cast(NULL), \ + reinterpret_cast(NULL), \ + reinterpret_cast(NULL), \ + reinterpret_cast(NULL), \ + (NUM_OBJECTS)); +#define GET_REDUCE_WS_SIZE(RES_PTR, TYPE, REDUCE_OP, NUM_OBJECTS) \ + { \ + TYPE init = TYPE(); \ + cub::DeviceReduce::Reduce( \ + (void*)NULL, \ + *(RES_PTR), \ + (TYPE*)NULL, \ + (TYPE*)NULL, \ + (NUM_OBJECTS), \ + (REDUCE_OP), \ + init); \ + } +#define GET_SELECT_WS_SIZE( \ + RES_PTR, TYPE_SELECTOR, TYPE_SELECTION, NUM_OBJECTS) \ + { \ + cub::DeviceSelect::Flagged( \ + (void*)NULL, \ + *(RES_PTR), \ + (TYPE_SELECTION*)NULL, \ + (TYPE_SELECTOR*)NULL, \ + (TYPE_SELECTION*)NULL, \ + (int*)NULL, \ + (NUM_OBJECTS)); \ + } +#define GET_SUM_WS_SIZE(RES_PTR, TYPE_SUM, NUM_OBJECTS) \ + { \ + cub::DeviceReduce::Sum( \ + (void*)NULL, \ + *(RES_PTR), \ + (TYPE_SUM*)NULL, \ + (TYPE_SUM*)NULL, \ + NUM_OBJECTS); \ + } +#define GET_MM_WS_SIZE(RES_PTR, TYPE, NUM_OBJECTS) \ + { \ + TYPE init = TYPE(); \ + cub::DeviceReduce::Max( \ + (void*)NULL, *(RES_PTR), (TYPE*)NULL, (TYPE*)NULL, (NUM_OBJECTS)); \ + } +#define SORT_DESCENDING( \ + TMPN1, SORT_PTR, SORTED_PTR, VAL_PTR, VAL_SORTED_PTR, NUM_OBJECTS) \ + void* TMPN1 = NULL; \ + size_t TMPN1##_bytes = 0; \ + cub::DeviceRadixSort::SortPairsDescending( \ + TMPN1, \ + TMPN1##_bytes, \ + (SORT_PTR), \ + (SORTED_PTR), \ + (VAL_PTR), \ + (VAL_SORTED_PTR), \ + (NUM_OBJECTS)); \ + HANDLECUDA(cudaMalloc(&TMPN1, TMPN1##_bytes)); \ + cub::DeviceRadixSort::SortPairsDescending( \ + TMPN1, \ + TMPN1##_bytes, \ + (SORT_PTR), \ + (SORTED_PTR), \ + (VAL_PTR), \ + (VAL_SORTED_PTR), \ + (NUM_OBJECTS)); \ + HANDLECUDA(cudaFree(TMPN1)); +#define SORT_DESCENDING_WS( \ + TMPN1, \ + SORT_PTR, \ + SORTED_PTR, \ + VAL_PTR, \ + VAL_SORTED_PTR, \ + NUM_OBJECTS, \ + WORKSPACE_PTR, \ + WORKSPACE_BYTES) \ + cub::DeviceRadixSort::SortPairsDescending( \ + (WORKSPACE_PTR), \ + (WORKSPACE_BYTES), \ + (SORT_PTR), \ + (SORTED_PTR), \ + (VAL_PTR), \ + (VAL_SORTED_PTR), \ + (NUM_OBJECTS)); +#define SORT_ASCENDING_WS( \ + SORT_PTR, \ + SORTED_PTR, \ + VAL_PTR, \ + VAL_SORTED_PTR, \ + NUM_OBJECTS, \ + WORKSPACE_PTR, \ + WORKSPACE_BYTES, \ + STREAM) \ + cub::DeviceRadixSort::SortPairs( \ + (WORKSPACE_PTR), \ + (WORKSPACE_BYTES), \ + (SORT_PTR), \ + (SORTED_PTR), \ + (VAL_PTR), \ + (VAL_SORTED_PTR), \ + (NUM_OBJECTS), \ + 0, \ + sizeof(*(SORT_PTR)) * 8, \ + (STREAM)); +#define SUM_WS( \ + SUM_PTR, OUT_PTR, NUM_OBJECTS, WORKSPACE_PTR, WORKSPACE_BYTES, STREAM) \ + cub::DeviceReduce::Sum( \ + (WORKSPACE_PTR), \ + (WORKSPACE_BYTES), \ + (SUM_PTR), \ + (OUT_PTR), \ + (NUM_OBJECTS), \ + (STREAM)); +#define MIN_WS( \ + MIN_PTR, OUT_PTR, NUM_OBJECTS, WORKSPACE_PTR, WORKSPACE_BYTES, STREAM) \ + cub::DeviceReduce::Min( \ + (WORKSPACE_PTR), \ + (WORKSPACE_BYTES), \ + (MIN_PTR), \ + (OUT_PTR), \ + (NUM_OBJECTS), \ + (STREAM)); +#define MAX_WS( \ + MAX_PTR, OUT_PTR, NUM_OBJECTS, WORKSPACE_PTR, WORKSPACE_BYTES, STREAM) \ + cub::DeviceReduce::Min( \ + (WORKSPACE_PTR), \ + (WORKSPACE_BYTES), \ + (MAX_PTR), \ + (OUT_PTR), \ + (NUM_OBJECTS), \ + (STREAM)); +// +// +// +// TODO: rewrite using nested contexts instead of temporary names. +#define REDUCE(REDUCE_PTR, RESULT_PTR, NUM_ITEMS, REDUCE_OP, REDUCE_INIT) \ + cub::DeviceReduce::Reduce( \ + TMPN1, \ + TMPN1##_bytes, \ + (REDUCE_PTR), \ + (RESULT_PTR), \ + (NUM_ITEMS), \ + (REDUCE_OP), \ + (REDUCE_INIT)); \ + HANDLECUDA(cudaMalloc(&TMPN1, TMPN1##_bytes)); \ + cub::DeviceReduce::Reduce( \ + TMPN1, \ + TMPN1##_bytes, \ + (REDUCE_PTR), \ + (RESULT_PTR), \ + (NUM_ITEMS), \ + (REDUCE_OP), \ + (REDUCE_INIT)); \ + HANDLECUDA(cudaFree(TMPN1)); +#define REDUCE_WS( \ + REDUCE_PTR, \ + RESULT_PTR, \ + NUM_ITEMS, \ + REDUCE_OP, \ + REDUCE_INIT, \ + WORKSPACE_PTR, \ + WORSPACE_BYTES, \ + STREAM) \ + cub::DeviceReduce::Reduce( \ + (WORKSPACE_PTR), \ + (WORSPACE_BYTES), \ + (REDUCE_PTR), \ + (RESULT_PTR), \ + (NUM_ITEMS), \ + (REDUCE_OP), \ + (REDUCE_INIT), \ + (STREAM)); +#define SELECT_FLAGS_WS( \ + FLAGS_PTR, \ + ITEM_PTR, \ + OUT_PTR, \ + NUM_SELECTED_PTR, \ + NUM_ITEMS, \ + WORKSPACE_PTR, \ + WORSPACE_BYTES, \ + STREAM) \ + cub::DeviceSelect::Flagged( \ + (WORKSPACE_PTR), \ + (WORSPACE_BYTES), \ + (ITEM_PTR), \ + (FLAGS_PTR), \ + (OUT_PTR), \ + (NUM_SELECTED_PTR), \ + (NUM_ITEMS), \ + stream = (STREAM)); + +#define COPY_HOST_DEV(PTR_D, PTR_H, TYPE, SIZE) \ + HANDLECUDA(cudaMemcpy( \ + (PTR_D), (PTR_H), sizeof(TYPE) * (SIZE), cudaMemcpyHostToDevice)) +#define COPY_DEV_HOST(PTR_H, PTR_D, TYPE, SIZE) \ + HANDLECUDA(cudaMemcpy( \ + (PTR_H), (PTR_D), sizeof(TYPE) * (SIZE), cudaMemcpyDeviceToHost)) +#define COPY_DEV_DEV(PTR_T, PTR_S, TYPE, SIZE) \ + HANDLECUDA(cudaMemcpy( \ + (PTR_T), (PTR_S), sizeof(TYPE) * (SIZE), cudaMemcpyDeviceToDevice)) +// +// We *must* use cudaMallocManaged for pointers on device that should +// interact with pytorch. However, this comes at a significant speed penalty. +// We're using plain CUDA pointers for the rendering operations and +// explicitly copy results to managed pointers wrapped for pytorch (see +// pytorch/util.h). +#define MALLOC(VAR, TYPE, SIZE) cudaMalloc(&(VAR), sizeof(TYPE) * (SIZE)) +#define FREE(PTR) HANDLECUDA(cudaFree(PTR)) +#define MEMSET(VAR, VAL, TYPE, SIZE, STREAM) \ + HANDLECUDA(cudaMemsetAsync((VAR), (VAL), sizeof(TYPE) * (SIZE), (STREAM))) + +#define LAUNCH_MAX_PARALLEL_1D(FUNC, N, STREAM, ...) \ + { \ + int64_t max_threads = \ + at::cuda::getCurrentDeviceProperties()->maxThreadsPerBlock; \ + uint num_threads = min((N), max_threads); \ + uint num_blocks = iDivCeil((N), num_threads); \ + FUNC<<>>(__VA_ARGS__); \ + } +#define LAUNCH_PARALLEL_1D(FUNC, N, TN, STREAM, ...) \ + { \ + uint num_threads = min(static_cast(N), static_cast(TN)); \ + uint num_blocks = iDivCeil((N), num_threads); \ + FUNC<<>>(__VA_ARGS__); \ + } +#define LAUNCH_MAX_PARALLEL_2D(FUNC, NX, NY, STREAM, ...) \ + { \ + int64_t max_threads = \ + at::cuda::getCurrentDeviceProperties()->maxThreadsPerBlock; \ + int64_t max_threads_sqrt = static_cast(sqrt(max_threads)); \ + dim3 num_threads, num_blocks; \ + num_threads.x = min((NX), max_threads_sqrt); \ + num_blocks.x = iDivCeil((NX), num_threads.x); \ + num_threads.y = min((NY), max_threads_sqrt); \ + num_blocks.y = iDivCeil((NY), num_threads.y); \ + num_threads.z = 1; \ + num_blocks.z = 1; \ + FUNC<<>>(__VA_ARGS__); \ + } +#define LAUNCH_PARALLEL_2D(FUNC, NX, NY, TX, TY, STREAM, ...) \ + { \ + dim3 num_threads, num_blocks; \ + num_threads.x = min((NX), (TX)); \ + num_blocks.x = iDivCeil((NX), num_threads.x); \ + num_threads.y = min((NY), (TY)); \ + num_blocks.y = iDivCeil((NY), num_threads.y); \ + num_threads.z = 1; \ + num_blocks.z = 1; \ + FUNC<<>>(__VA_ARGS__); \ + } + +#define GET_PARALLEL_IDX_1D(VARNAME, N) \ + const uint VARNAME = __mul24(blockIdx.x, blockDim.x) + threadIdx.x; \ + if (VARNAME >= (N)) { \ + return; \ + } +#define GET_PARALLEL_IDS_2D(VAR_X, VAR_Y, WIDTH, HEIGHT) \ + const uint VAR_X = __mul24(blockIdx.x, blockDim.x) + threadIdx.x; \ + const uint VAR_Y = __mul24(blockIdx.y, blockDim.y) + threadIdx.y; \ + if (VAR_X >= (WIDTH) || VAR_Y >= (HEIGHT)) \ + return; +#define END_PARALLEL() +#define END_PARALLEL_NORET() +#define END_PARALLEL_2D_NORET() +#define END_PARALLEL_2D() +#define RETURN_PARALLEL() return +#define CHECKLAUNCH() THCudaCheck(cudaGetLastError()); +#define ISONDEVICE true +#define SYNCDEVICE() HANDLECUDA(cudaDeviceSynchronize()) +#define START_TIME(TN) \ + cudaEvent_t __time_start_##TN, __time_stop_##TN; \ + cudaEventCreate(&__time_start_##TN); \ + cudaEventCreate(&__time_stop_##TN); \ + cudaEventRecord(__time_start_##TN); +#define STOP_TIME(TN) cudaEventRecord(__time_stop_##TN); +#define GET_TIME(TN, TOPTR) \ + cudaEventSynchronize(__time_stop_##TN); \ + cudaEventElapsedTime((TOPTR), __time_start_##TN, __time_stop_##TN); +#define START_TIME_CU(TN) START_TIME(CN) +#define STOP_TIME_CU(TN) STOP_TIME(TN) +#define GET_TIME_CU(TN, TOPTR) GET_TIME(TN, TOPTR) + +#endif diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.backward.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.backward.gpu.cu new file mode 100644 index 00000000..6969a3fc --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.backward.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.backward.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.backward_dbg.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.backward_dbg.gpu.cu new file mode 100644 index 00000000..e38f3b5b --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.backward_dbg.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.backward_dbg.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.calc_gradients.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.calc_gradients.gpu.cu new file mode 100644 index 00000000..0668eced --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.calc_gradients.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.calc_gradients.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.calc_signature.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.calc_signature.gpu.cu new file mode 100644 index 00000000..8e05de28 --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.calc_signature.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.calc_signature.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.construct.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.construct.gpu.cu new file mode 100644 index 00000000..f04df519 --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.construct.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.construct.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.create_selector.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.create_selector.gpu.cu new file mode 100644 index 00000000..c9a64f78 --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.create_selector.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.create_selector.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.destruct.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.destruct.gpu.cu new file mode 100644 index 00000000..e5dec0db --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.destruct.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.destruct.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.fill_bg.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.fill_bg.gpu.cu new file mode 100644 index 00000000..01e6c6f9 --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.fill_bg.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.fill_bg.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.forward.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.forward.gpu.cu new file mode 100644 index 00000000..c73b8f69 --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.forward.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.forward.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.norm_cam_gradients.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.norm_cam_gradients.gpu.cu new file mode 100644 index 00000000..2c26f5a9 --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.norm_cam_gradients.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.norm_cam_gradients.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.norm_sphere_gradients.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.norm_sphere_gradients.gpu.cu new file mode 100644 index 00000000..4ee8128e --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.norm_sphere_gradients.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.norm_sphere_gradients.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/cuda/renderer.render.gpu.cu b/pytorch3d/csrc/pulsar/cuda/renderer.render.gpu.cu new file mode 100644 index 00000000..c9a664e1 --- /dev/null +++ b/pytorch3d/csrc/pulsar/cuda/renderer.render.gpu.cu @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.render.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/global.h b/pytorch3d/csrc/pulsar/global.h new file mode 100644 index 00000000..6c0e94c1 --- /dev/null +++ b/pytorch3d/csrc/pulsar/global.h @@ -0,0 +1,85 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_GLOBAL_H +#define PULSAR_GLOBAL_H + +#include "./constants.h" +#ifndef WIN32 +#include +#endif + +#if defined(_WIN64) || defined(_WIN32) +#define uint unsigned int +#define ushort unsigned short +#endif + +#include "./logging.h" // <- include before torch/extension.h + +#define MAX_GRAD_SPHERES 128 + +#ifdef __CUDACC__ +#define INLINE __forceinline__ +#define HOST __host__ +#define DEVICE __device__ +#define GLOBAL __global__ +#define RESTRICT __restrict__ +#define DEBUGBREAK() +#pragma diag_suppress = attribute_not_allowed +#pragma diag_suppress = 1866 +#pragma diag_suppress = 2941 +#pragma diag_suppress = 2951 +#pragma diag_suppress = 2967 +#else // __CUDACC__ +#define INLINE inline +#define HOST +#define DEVICE +#define GLOBAL +#define RESTRICT +#define DEBUGBREAK() std::raise(SIGINT) +// Don't care about pytorch warnings; they shouldn't clutter our warnings. +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Weverything" +#include +#include +#pragma clang diagnostic pop +namespace py = pybind11; +inline float3 make_float3(const float& x, const float& y, const float& z) { + float3 res; + res.x = x; + res.y = y; + res.z = z; + return res; +} + +inline bool operator==(const float3& a, const float3& b) { + return a.x == b.x && a.y == b.y && a.z == b.z; +} +#endif // __CUDACC__ +#define IHD INLINE HOST DEVICE + +// An assertion command that can be used on host and device. +#ifdef PULSAR_ASSERTIONS +#ifdef __CUDACC__ +#define PASSERT(VAL) \ + if (!(VAL)) { \ + printf( \ + "Pulsar assertion failed in %s, line %d: %s.\n", \ + __FILE__, \ + __LINE__, \ + #VAL); \ + } +#else +#define PASSERT(VAL) \ + if (!(VAL)) { \ + printf( \ + "Pulsar assertion failed in %s, line %d: %s.\n", \ + __FILE__, \ + __LINE__, \ + #VAL); \ + std::raise(SIGINT); \ + } +#endif +#else +#define PASSERT(VAL) +#endif + +#endif diff --git a/pytorch3d/csrc/pulsar/host/README.md b/pytorch3d/csrc/pulsar/host/README.md new file mode 100644 index 00000000..34f1bade --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/README.md @@ -0,0 +1,5 @@ +# Device-specific host compilation units + +This folder contains `.cpp` files to create compilation units +for device specific functions. See `../include/README.md` for +more information. diff --git a/pytorch3d/csrc/pulsar/host/commands.h b/pytorch3d/csrc/pulsar/host/commands.h new file mode 100644 index 00000000..737c6224 --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/commands.h @@ -0,0 +1,383 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_COMMANDS_H_ +#define PULSAR_NATIVE_COMMANDS_H_ + +#ifdef _MSC_VER +#include +#define __builtin_popcount (int)__popcnt +#endif + +// Definitions for CPU commands. +// #include +// #include + +namespace cg { +struct coalesced_group { + INLINE uint thread_rank() const { + return 0u; + } + INLINE uint size() const { + return 1u; + } + INLINE uint ballot(uint val) const { + return static_cast(val > 0); + } +}; + +struct thread_block { + INLINE uint thread_rank() const { + return 0u; + } + INLINE uint size() const { + return 1u; + } + INLINE void sync() const {} +}; + +INLINE coalesced_group coalesced_threads() { + coalesced_group ret; + return ret; +} + +INLINE thread_block this_thread_block() { + thread_block ret; + return ret; +} +} // namespace cg +#define SHFL_SYNC(a, b, c) (b) +template +T WARP_CUMSUM( + const cg::coalesced_group& group, + const uint& mask, + const T& base) { + return base; +} + +template +DEVICE T +WARP_MAX(const cg::coalesced_group& group, const uint& mask, const T& base) { + return base; +} + +template +DEVICE T +WARP_SUM(const cg::coalesced_group& group, const uint& mask, const T& base) { + return base; +} + +INLINE DEVICE float3 WARP_SUM_FLOAT3( + const cg::coalesced_group& group, + const uint& mask, + const float3& base) { + return base; +} + +#define ACTIVEMASK() (1u << 31) +#define ALIGN(VAL) +#define SYNC() +#define THREADFENCE_B() +#define BALLOT(mask, val) (val != 0) +#define SHARED +// Floating point. +#define FMAX(a, b) std::fmax((a), (b)) +#define FMIN(a, b) std::fmin((a), (b)) +INLINE float atomicMax(float* address, float val) { + *address = std::max(*address, val); + return *address; +} +INLINE float atomicMin(float* address, float val) { + *address = std::min(*address, val); + return *address; +} +#define FMUL(a, b) ((a) * (b)) +#define FDIV(a, b) ((a) / (b)) +#define FSUB(a, b) ((a) - (b)) +#define FABSLEQAS(a, b, c) \ + ((a) <= (b) ? FSUB((b), (a)) <= (c) : FSUB((a), (b)) < (c)) +#define FADD(a, b) ((a) + (b)) +#define FSQRT(a) sqrtf(a) +#define FEXP(a) fasterexp(a) +#define FLN(a) fasterlog(a) +#define FPOW(a, b) powf((a), (b)) +#define FROUND(x) roundf(x) +#define FCEIL(a) ceilf(a) +#define FFLOOR(a) floorf(a) +#define FSATURATE(x) std::max(0.f, std::min(1.f, x)) +#define FABS(a) abs(a) +#define FMA(x, y, z) ((x) * (y) + (z)) +#define I2F(a) static_cast(a) +#define FRCP(x) (1.f / (x)) +#define IASF(x, loc) memcpy(&(loc), &(x), sizeof(x)) +#define FASI(x, loc) memcpy(&(loc), &(x), sizeof(x)) +#define DMAX(a, b) std::max((a), (b)) +#define DMIN(a, b) std::min((a), (b)) +#define DSATURATE(a) DMIN(1., DMAX(0., (a))) +#define DSQRT(a) sqrt(a) +// +// +// +// +// +// +// +// +// +// +// +// +// uint. +#define CLZ(VAL) _clz(VAL) +template +INLINE T ATOMICADD(T* address, T val) { + T old = *address; + *address += val; + return old; +} +template +INLINE void ATOMICADD_F3(T* address, T val) { + ATOMICADD(&(address->x), val.x); + ATOMICADD(&(address->y), val.y); + ATOMICADD(&(address->z), val.z); +} +#define ATOMICADD_B(a, b) ATOMICADD((a), (b)) +#define POPC(a) __builtin_popcount(a) + +// int. +#define IMIN(a, b) std::min((a), (b)) +#define IMAX(a, b) std::max((a), (b)) +#define IABS(a) abs(a) + +// Checks. +#define CHECKOK THCheck +#define ARGCHECK THArgCheck + +// Math. +#define NORM3DF(x, y, z) sqrtf(x* x + y * y + z * z) +#define RNORM3DF(x, y, z) (1.f / sqrtf(x * x + y * y + z * z)) + +// High level. +#define PREFETCH(PTR) +#define GET_SORT_WS_SIZE(RES_PTR, KEY_TYPE, VAL_TYPE, NUM_OBJECTS) \ + *(RES_PTR) = 0; +#define GET_REDUCE_WS_SIZE(RES_PTR, TYPE, REDUCE_OP, NUM_OBJECTS) \ + *(RES_PTR) = 0; +#define GET_SELECT_WS_SIZE( \ + RES_PTR, TYPE_SELECTOR, TYPE_SELECTION, NUM_OBJECTS) \ + *(RES_PTR) = 0; +#define GET_SUM_WS_SIZE(RES_PTR, TYPE_SUM, NUM_OBJECTS) *(RES_PTR) = 0; +#define GET_MM_WS_SIZE(RES_PTR, TYPE, NUM_OBJECTS) *(RES_PTR) = 0; + +#define SORT_DESCENDING( \ + TMPN1, SORT_PTR, SORTED_PTR, VAL_PTR, VAL_SORTED_PTR, NUM_OBJECTS) \ + std::vector TMPN1(NUM_OBJECTS); \ + std::iota(TMPN1.begin(), TMPN1.end(), 0); \ + const auto TMPN1##_val_ptr = (SORT_PTR); \ + std::sort( \ + TMPN1.begin(), TMPN1.end(), [&TMPN1##_val_ptr](size_t i1, size_t i2) { \ + return TMPN1##_val_ptr[i1] > TMPN1##_val_ptr[i2]; \ + }); \ + for (int i = 0; i < (NUM_OBJECTS); ++i) { \ + (SORTED_PTR)[i] = (SORT_PTR)[TMPN1[i]]; \ + } \ + for (int i = 0; i < (NUM_OBJECTS); ++i) { \ + (VAL_SORTED_PTR)[i] = (VAL_PTR)[TMPN1[i]]; \ + } + +#define SORT_ASCENDING( \ + SORT_PTR, SORTED_PTR, VAL_PTR, VAL_SORTED_PTR, NUM_OBJECTS, STREAM) \ + { \ + std::vector TMPN1(NUM_OBJECTS); \ + std::iota(TMPN1.begin(), TMPN1.end(), 0); \ + const auto TMPN1_val_ptr = (SORT_PTR); \ + std::sort( \ + TMPN1.begin(), \ + TMPN1.end(), \ + [&TMPN1_val_ptr](size_t i1, size_t i2) -> bool { \ + return TMPN1_val_ptr[i1] < TMPN1_val_ptr[i2]; \ + }); \ + for (int i = 0; i < (NUM_OBJECTS); ++i) { \ + (SORTED_PTR)[i] = (SORT_PTR)[TMPN1[i]]; \ + } \ + for (int i = 0; i < (NUM_OBJECTS); ++i) { \ + (VAL_SORTED_PTR)[i] = (VAL_PTR)[TMPN1[i]]; \ + } \ + } + +#define SORT_DESCENDING_WS( \ + TMPN1, \ + SORT_PTR, \ + SORTED_PTR, \ + VAL_PTR, \ + VAL_SORTED_PTR, \ + NUM_OBJECTS, \ + WORSPACE_PTR, \ + WORKSPACE_SIZE) \ + SORT_DESCENDING( \ + TMPN1, SORT_PTR, SORTED_PTR, VAL_PTR, VAL_SORTED_PTR, NUM_OBJECTS) + +#define SORT_ASCENDING_WS( \ + SORT_PTR, \ + SORTED_PTR, \ + VAL_PTR, \ + VAL_SORTED_PTR, \ + NUM_OBJECTS, \ + WORSPACE_PTR, \ + WORKSPACE_SIZE, \ + STREAM) \ + SORT_ASCENDING( \ + SORT_PTR, SORTED_PTR, VAL_PTR, VAL_SORTED_PTR, NUM_OBJECTS, STREAM) + +#define REDUCE(REDUCE_PTR, RESULT_PTR, NUM_ITEMS, REDUCE_OP, REDUCE_INIT) \ + { \ + *(RESULT_PTR) = (REDUCE_INIT); \ + for (int i = 0; i < (NUM_ITEMS); ++i) { \ + *(RESULT_PTR) = REDUCE_OP(*(RESULT_PTR), (REDUCE_PTR)[i]); \ + } \ + } +#define REDUCE_WS( \ + REDUCE_PTR, \ + RESULT_PTR, \ + NUM_ITEMS, \ + REDUCE_OP, \ + REDUCE_INIT, \ + WORKSPACE_PTR, \ + WORKSPACE_SIZE, \ + STREAM) \ + REDUCE(REDUCE_PTR, RESULT_PTR, NUM_ITEMS, REDUCE_OP, REDUCE_INIT) + +#define SELECT_FLAGS_WS( \ + FLAGS_PTR, \ + ITEM_PTR, \ + OUT_PTR, \ + NUM_SELECTED_PTR, \ + NUM_ITEMS, \ + WORKSPACE_PTR, \ + WORSPACE_BYTES, \ + STREAM) \ + { \ + *NUM_SELECTED_PTR = 0; \ + ptrdiff_t write_pos = 0; \ + for (int i = 0; i < NUM_ITEMS; ++i) { \ + if (FLAGS_PTR[i]) { \ + OUT_PTR[write_pos++] = ITEM_PTR[i]; \ + *NUM_SELECTED_PTR += 1; \ + } \ + } \ + } + +template +void SUM_WS( + T* SUM_PTR, + T* OUT_PTR, + size_t NUM_OBJECTS, + char* WORKSPACE_PTR, + size_t WORKSPACE_BYTES, + cudaStream_t STREAM) { + *(OUT_PTR) = T(); + for (int i = 0; i < (NUM_OBJECTS); ++i) { + *(OUT_PTR) = *(OUT_PTR) + (SUM_PTR)[i]; + } +} + +template +void MIN_WS( + T* MIN_PTR, + T* OUT_PTR, + size_t NUM_OBJECTS, + char* WORKSPACE_PTR, + size_t WORKSPACE_BYTES, + cudaStream_t STREAM) { + *(OUT_PTR) = T(); + for (int i = 0; i < (NUM_OBJECTS); ++i) { + *(OUT_PTR) = std::min(*(OUT_PTR), (MIN_PTR)[i]); + } +} + +template +void MAX_WS( + T* MAX_PTR, + T* OUT_PTR, + size_t NUM_OBJECTS, + char* WORKSPACE_PTR, + size_t WORKSPACE_BYTES, + cudaStream_t STREAM) { + *(OUT_PTR) = T(); + for (int i = 0; i < (NUM_OBJECTS); ++i) { + *(OUT_PTR) = std::max(*(OUT_PTR), (MAX_PTR)[i]); + } +} +// +// +// +// +#define COPY_HOST_DEV(PTR_D, PTR_H, TYPE, SIZE) \ + std::memcpy((PTR_D), (PTR_H), sizeof(TYPE) * (SIZE)) +// +#define COPY_DEV_HOST(PTR_H, PTR_D, TYPE, SIZE) \ + std::memcpy((PTR_H), (PTR_D), sizeof(TYPE) * (SIZE)) +// +#define COPY_DEV_DEV(PTR_T, PTR_S, TYPE, SIZE) \ + std::memcpy((PTR_T), (PTR_S), sizeof(TYPE) * SIZE) +// + +#define MALLOC(VAR, TYPE, SIZE) MALLOC_HOST(VAR, TYPE, SIZE) +#define FREE(PTR) FREE_HOST(PTR) +#define MEMSET(VAR, VAL, TYPE, SIZE, STREAM) \ + memset((VAR), (VAL), sizeof(TYPE) * (SIZE)) +// + +#define LAUNCH_MAX_PARALLEL_1D(FUNC, N, STREAM, ...) FUNC(__VA_ARGS__); +#define LAUNCH_PARALLEL_1D(FUNC, N, TN, STREAM, ...) FUNC(__VA_ARGS__); +#define LAUNCH_MAX_PARALLEL_2D(FUNC, NX, NY, STREAM, ...) FUNC(__VA_ARGS__); +#define LAUNCH_PARALLEL_2D(FUNC, NX, NY, TX, TY, STREAM, ...) FUNC(__VA_ARGS__); +// +// +// +// +// +#define GET_PARALLEL_IDX_1D(VARNAME, N) \ + for (uint VARNAME = 0; VARNAME < (N); ++VARNAME) { +#define GET_PARALLEL_IDS_2D(VAR_X, VAR_Y, WIDTH, HEIGHT) \ + int2 blockDim; \ + blockDim.x = 1; \ + blockDim.y = 1; \ + uint __parallel_2d_width = WIDTH; \ + uint __parallel_2d_height = HEIGHT; \ + for (uint VAR_Y = 0; VAR_Y < __parallel_2d_height; ++(VAR_Y)) { \ + for (uint VAR_X = 0; VAR_X < __parallel_2d_width; ++(VAR_X)) { +// +// +// +#define END_PARALLEL() \ + end_parallel:; \ + } +#define END_PARALLEL_NORET() } +#define END_PARALLEL_2D() \ + end_parallel:; \ + } \ + } +#define END_PARALLEL_2D_NORET() \ + } \ + } +#define RETURN_PARALLEL() goto end_parallel; +#define CHECKLAUNCH() +#define ISONDEVICE false +#define SYNCDEVICE() +#define START_TIME(TN) \ + auto __time_start_##TN = std::chrono::steady_clock::now(); +#define STOP_TIME(TN) auto __time_stop_##TN = std::chrono::steady_clock::now(); +#define GET_TIME(TN, TOPTR) \ + *TOPTR = std::chrono::duration_cast( \ + __time_stop_##TN - __time_start_##TN) \ + .count() +#define START_TIME_CU(TN) \ + cudaEvent_t __time_start_##TN, __time_stop_##TN; \ + cudaEventCreate(&__time_start_##TN); \ + cudaEventCreate(&__time_stop_##TN); \ + cudaEventRecord(__time_start_##TN); +#define STOP_TIME_CU(TN) cudaEventRecord(__time_stop_##TN); +#define GET_TIME_CU(TN, TOPTR) \ + cudaEventSynchronize(__time_stop_##TN); \ + cudaEventElapsedTime((TOPTR), __time_start_##TN, __time_stop_##TN); + +#endif diff --git a/pytorch3d/csrc/pulsar/host/renderer.backward.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.backward.cpu.cpp new file mode 100644 index 00000000..6969a3fc --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.backward.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.backward.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.backward_dbg.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.backward_dbg.cpu.cpp new file mode 100644 index 00000000..e38f3b5b --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.backward_dbg.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.backward_dbg.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.calc_gradients.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.calc_gradients.cpu.cpp new file mode 100644 index 00000000..0668eced --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.calc_gradients.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.calc_gradients.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.calc_signature.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.calc_signature.cpu.cpp new file mode 100644 index 00000000..8e05de28 --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.calc_signature.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.calc_signature.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.construct.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.construct.cpu.cpp new file mode 100644 index 00000000..f04df519 --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.construct.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.construct.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.create_selector.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.create_selector.cpu.cpp new file mode 100644 index 00000000..c9a64f78 --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.create_selector.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.create_selector.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.destruct.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.destruct.cpu.cpp new file mode 100644 index 00000000..e5dec0db --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.destruct.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.destruct.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.fill_bg.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.fill_bg.cpu.cpp new file mode 100644 index 00000000..01e6c6f9 --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.fill_bg.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.fill_bg.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.forward.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.forward.cpu.cpp new file mode 100644 index 00000000..c73b8f69 --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.forward.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.forward.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.norm_cam_gradients.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.norm_cam_gradients.cpu.cpp new file mode 100644 index 00000000..2c26f5a9 --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.norm_cam_gradients.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.norm_cam_gradients.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.norm_sphere_gradients.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.norm_sphere_gradients.cpu.cpp new file mode 100644 index 00000000..4ee8128e --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.norm_sphere_gradients.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.norm_sphere_gradients.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/host/renderer.render.cpu.cpp b/pytorch3d/csrc/pulsar/host/renderer.render.cpu.cpp new file mode 100644 index 00000000..c9a664e1 --- /dev/null +++ b/pytorch3d/csrc/pulsar/host/renderer.render.cpu.cpp @@ -0,0 +1,2 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "../include/renderer.render.instantiate.h" diff --git a/pytorch3d/csrc/pulsar/include/README.md b/pytorch3d/csrc/pulsar/include/README.md new file mode 100644 index 00000000..e963ff04 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/README.md @@ -0,0 +1,16 @@ +# The `include` folder + +This folder contains header files with implementations of several useful +algorithms. These implementations are usually done in files called `x.device.h` +and use macros that route every device specific command to the right +implementation (see `commands.h`). + +If you're using a device specific implementation, include `x.device.h`. +This gives you the high-speed, device specific implementation that lets +you work with all the details of the datastructure. All function calls are +inlined. If you need to work with the high-level interface and be able to +dynamically pick a device, only include `x.h`. The functions there are +templated with a boolean `DEV` flag and are instantiated in device specific +compilation units. You will not be able to use any other functions, but can +use `func(params)` to work on a CUDA device, or `func(params)` +to work on the host. diff --git a/pytorch3d/csrc/pulsar/include/camera.device.h b/pytorch3d/csrc/pulsar/include/camera.device.h new file mode 100644 index 00000000..5633bc62 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/camera.device.h @@ -0,0 +1,18 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_CAMERA_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_CAMERA_DEVICE_H_ + +#include "../global.h" +#include "./camera.h" +#include "./commands.h" + +namespace pulsar { +IHD CamGradInfo::CamGradInfo() { + cam_pos = make_float3(0.f, 0.f, 0.f); + pixel_0_0_center = make_float3(0.f, 0.f, 0.f); + pixel_dir_x = make_float3(0.f, 0.f, 0.f); + pixel_dir_y = make_float3(0.f, 0.f, 0.f); +} +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/camera.h b/pytorch3d/csrc/pulsar/include/camera.h new file mode 100644 index 00000000..2bf2a454 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/camera.h @@ -0,0 +1,72 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_CAMERA_H_ +#define PULSAR_NATIVE_INCLUDE_CAMERA_H_ + +#include "../global.h" + +namespace pulsar { +/** + * Everything that's needed to raycast with our camera model. + */ +struct CamInfo { + float3 eye; /** Position in world coordinates. */ + float3 pixel_0_0_center; /** LUC center of pixel position in world + coordinates. */ + float3 pixel_dir_x; /** Direction for increasing x for one pixel to the next, + * in world coordinates. */ + float3 pixel_dir_y; /** Direction for increasing y for one pixel to the next, + * in world coordinates. */ + float3 sensor_dir_z; /** Normalized direction vector from eye through the + * sensor in z direction (optical axis). */ + float half_pixel_size; /** Half size of a pixel, in world coordinates. This + * must be consistent with pixel_dir_x and pixel_dir_y! + */ + float focal_length; /** The focal length, if applicable. */ + uint aperture_width; /** Full image width in px, possibly not fully used + * in case of a shifted principal point. */ + uint aperture_height; /** Full image height in px, possibly not fully used + * in case of a shifted principal point. */ + uint film_width; /** Resulting image width. */ + uint film_height; /** Resulting image height. */ + /** The top left coordinates (inclusive) of the film in the full aperture. */ + uint film_border_left, film_border_top; + int32_t principal_point_offset_x; /** Horizontal principal point offset. */ + int32_t principal_point_offset_y; /** Vertical principal point offset. */ + float min_dist; /** Minimum distance for a ball to be rendered. */ + float max_dist; /** Maximum distance for a ball to be rendered. */ + float norm_fac; /** 1 / (max_dist - min_dist), pre-computed. */ + /** The depth where to place the background, in normalized coordinates where + * 0. is the backmost depth and 1. the frontmost. */ + float background_normalization_depth; + /** The number of image content channels to use. Usually three. */ + uint n_channels; + /** Whether to use an orthogonal instead of a perspective projection. */ + bool orthogonal_projection; + /** Whether to use a right-handed system (inverts the z axis). */ + bool right_handed; +}; + +inline bool operator==(const CamInfo& a, const CamInfo& b) { + return a.film_width == b.film_width && a.film_height == b.film_height && + a.background_normalization_depth == b.background_normalization_depth && + a.n_channels == b.n_channels && + a.orthogonal_projection == b.orthogonal_projection && + a.right_handed == b.right_handed; +}; + +struct CamGradInfo { + HOST DEVICE CamGradInfo(); + float3 cam_pos; + float3 pixel_0_0_center; + float3 pixel_dir_x; + float3 pixel_dir_y; +}; + +// TODO: remove once https://github.com/NVlabs/cub/issues/172 is resolved. +struct IntWrapper { + int val; +}; + +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/closest_sphere_tracker.device.h b/pytorch3d/csrc/pulsar/include/closest_sphere_tracker.device.h new file mode 100644 index 00000000..85423e50 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/closest_sphere_tracker.device.h @@ -0,0 +1,131 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_CLOSEST_SPHERE_TRACKER_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_CLOSEST_SPHERE_TRACKER_DEVICE_H_ + +#include "../global.h" + +namespace pulsar { +namespace Renderer { + +/** + * A facility to track the closest spheres to the camera. + * + * Their max number is defined by MAX_GRAD_SPHERES (this is defined in + * `pulsar/native/global.h`). This is done to keep the performance as high as + * possible because this struct needs to do updates continuously on the GPU. + */ +struct ClosestSphereTracker { + public: + IHD ClosestSphereTracker(const int& n_track) : n_hits(0), n_track(n_track) { + PASSERT(n_track < MAX_GRAD_SPHERES); + // Initialize the sphere IDs to -1 and the weights to 0. + for (int i = 0; i < n_track; ++i) { + this->most_important_sphere_ids[i] = -1; + this->closest_sphere_intersection_depths[i] = MAX_FLOAT; + } + }; + + IHD void track( + const uint& sphere_idx, + const float& intersection_depth, + const uint& coord_x, + const uint& coord_y) { + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_TRACKER_PIX, + "tracker|tracking sphere %u (depth: %f).\n", + sphere_idx, + intersection_depth); + for (int i = IMIN(this->n_hits, n_track) - 1; i >= -1; --i) { + if (i < 0 || + this->closest_sphere_intersection_depths[i] < intersection_depth) { + // Write position is i+1. + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_TRACKER_PIX, + "tracker|determined writing position: %d.\n", + i + 1); + if (i + 1 < n_track) { + // Shift every other sphere back. + for (int j = n_track - 1; j > i + 1; --j) { + this->closest_sphere_intersection_depths[j] = + this->closest_sphere_intersection_depths[j - 1]; + this->most_important_sphere_ids[j] = + this->most_important_sphere_ids[j - 1]; + } + this->closest_sphere_intersection_depths[i + 1] = intersection_depth; + this->most_important_sphere_ids[i + 1] = sphere_idx; + } + break; + } + } +#if PULSAR_LOG_TRACKER_PIX + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_TRACKER_PIX, + "tracker|sphere list after adding sphere %u:\n", + sphere_idx); + for (int i = 0; i < n_track; ++i) { + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_TRACKER_PIX, + "tracker|sphere %d: %d (depth: %f).\n", + i, + this->most_important_sphere_ids[i], + this->closest_sphere_intersection_depths[i]); + } +#endif // PULSAR_LOG_TRACKER_PIX + this->n_hits += 1; + } + + /** + * Get the number of hits registered. + */ + IHD int get_n_hits() const { + return this->n_hits; + } + + /** + * Get the idx closest sphere ID. + * + * For example, get_closest_sphere_id(0) gives the overall closest + * sphere id. + * + * This method is implemented for highly optimized scenarios and will *not* + * perform an index check at runtime if assertions are disabled. idx must be + * >=0 and < IMIN(n_hits, n_track) for a valid result, if it is >= + * n_hits it will return -1. + */ + IHD int get_closest_sphere_id(const int& idx) { + PASSERT(idx >= 0 && idx < n_track); + return this->most_important_sphere_ids[idx]; + } + + /** + * Get the idx closest sphere normalized_depth. + * + * For example, get_closest_sphere_depth(0) gives the overall closest + * sphere depth (normalized). + * + * This method is implemented for highly optimized scenarios and will *not* + * perform an index check at runtime if assertions are disabled. idx must be + * >=0 and < IMIN(n_hits, n_track) for a valid result, if it is >= + * n_hits it will return 1. + FEPS. + */ + IHD float get_closest_sphere_depth(const int& idx) { + PASSERT(idx >= 0 && idx < n_track); + return this->closest_sphere_intersection_depths[idx]; + } + + private: + /** The number of registered hits so far. */ + int n_hits; + /** The number of intersections to track. Must be (malloc(sizeof(TYPE) * (SIZE))) +#define FREE_HOST(PTR) free(PTR) + +/* Include command definitions depending on CPU or GPU use. */ + +#ifdef __CUDACC__ +// TODO: find out which compiler we're using here and use the suppression. +// #pragma push +// #pragma diag_suppress = 68 +#include +#include +// #pragma pop +#include "../cuda/commands.h" +#else +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Weverything" +#include +#pragma clang diagnostic pop +#include "../host/commands.h" +#endif + +#endif diff --git a/pytorch3d/csrc/pulsar/include/fastermath.h b/pytorch3d/csrc/pulsar/include/fastermath.h new file mode 100644 index 00000000..2276ae6a --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/fastermath.h @@ -0,0 +1,87 @@ +#ifndef PULSAR_NATIVE_INCLUDE_FASTERMATH_H_ +#define PULSAR_NATIVE_INCLUDE_FASTERMATH_H_ + +/*=====================================================================* + * Copyright (C) 2011 Paul Mineiro * + * All rights reserved. * + * * + * Redistribution and use in source and binary forms, with * + * or without modification, are permitted provided that the * + * following conditions are met: * + * * + * * Redistributions of source code must retain the * + * above copyright notice, this list of conditions and * + * the following disclaimer. * + * * + * * Redistributions in binary form must reproduce the * + * above copyright notice, this list of conditions and * + * the following disclaimer in the documentation and/or * + * other materials provided with the distribution. * + * * + * * Neither the name of Paul Mineiro nor the names * + * of other contributors may be used to endorse or promote * + * products derived from this software without specific * + * prior written permission. * + * * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * + * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER * + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR * + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * + * POSSIBILITY OF SUCH DAMAGE. * + * * + * Contact: Paul Mineiro * + *=====================================================================*/ + +#include +#include "./commands.h" + +#ifdef __cplusplus +#define cast_uint32_t static_cast +#else +#define cast_uint32_t (uint32_t) +#endif + +IHD float fasterlog2(float x) { + union { + float f; + uint32_t i; + } vx = {x}; + float y = vx.i; + y *= 1.1920928955078125e-7f; + return y - 126.94269504f; +} + +IHD float fasterlog(float x) { + // return 0.69314718f * fasterlog2 (x); + union { + float f; + uint32_t i; + } vx = {x}; + float y = vx.i; + y *= 8.2629582881927490e-8f; + return y - 87.989971088f; +} + +IHD float fasterpow2(float p) { + float clipp = (p < -126) ? -126.0f : p; + union { + uint32_t i; + float f; + } v = {cast_uint32_t((1 << 23) * (clipp + 126.94269504f))}; + return v.f; +} + +IHD float fasterexp(float p) { + return fasterpow2(1.442695040f * p); +} + +#endif diff --git a/pytorch3d/csrc/pulsar/include/math.h b/pytorch3d/csrc/pulsar/include/math.h new file mode 100644 index 00000000..48995bcc --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/math.h @@ -0,0 +1,150 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_IMPL_MATH_H_ +#define PULSAR_NATIVE_IMPL_MATH_H_ + +#include "./camera.h" +#include "./commands.h" +#include "./fastermath.h" + +/** + * Get the direction of val. + * + * Returns +1 if val is positive, -1 if val is zero or negative. + */ +IHD int sign_dir(const int& val) { + return -(static_cast((val <= 0)) << 1) + 1; +}; + +/** + * Get the direction of val. + * + * Returns +1 if val is positive, -1 if val is zero or negative. + */ +IHD float sign_dir(const float& val) { + return static_cast(1 - (static_cast((val <= 0)) << 1)); +}; + +/** + * Integer ceil division. + */ +IHD uint iDivCeil(uint a, uint b) { + return (a % b != 0) ? (a / b + 1) : (a / b); +} + +IHD float3 outer_product_sum(const float3& a) { + return make_float3( + a.x * a.x + a.x * a.y + a.x * a.z, + a.x * a.y + a.y * a.y + a.y * a.z, + a.x * a.z + a.y * a.z + a.z * a.z); +} + +// TODO: put intrinsics here. +IHD float3 operator+(const float3& a, const float3& b) { + return make_float3(a.x + b.x, a.y + b.y, a.z + b.z); +} + +IHD void operator+=(float3& a, const float3& b) { + a.x += b.x; + a.y += b.y; + a.z += b.z; +} + +IHD void operator-=(float3& a, const float3& b) { + a.x -= b.x; + a.y -= b.y; + a.z -= b.z; +} + +IHD void operator/=(float3& a, const float& b) { + a.x /= b; + a.y /= b; + a.z /= b; +} + +IHD void operator*=(float3& a, const float& b) { + a.x *= b; + a.y *= b; + a.z *= b; +} + +IHD float3 operator/(const float3& a, const float& b) { + return make_float3(a.x / b, a.y / b, a.z / b); +} + +IHD float3 operator-(const float3& a, const float3& b) { + return make_float3(a.x - b.x, a.y - b.y, a.z - b.z); +} + +IHD float3 operator*(const float3& a, const float& b) { + return make_float3(a.x * b, a.y * b, a.z * b); +} + +IHD float3 operator*(const float3& a, const float3& b) { + return make_float3(a.x * b.x, a.y * b.y, a.z * b.z); +} + +IHD float3 operator*(const float& a, const float3& b) { + return b * a; +} + +IHD float length(const float3& v) { + // TODO: benchmark what's faster. + return NORM3DF(v.x, v.y, v.z); + // return __fsqrt_rn(v.x * v.x + v.y * v.y + v.z * v.z); +} + +/** + * Left-hand multiplication of the constructed rotation matrix with the vector. + */ +IHD float3 rotate( + const float3& v, + const float3& dir_x, + const float3& dir_y, + const float3& dir_z) { + return make_float3( + dir_x.x * v.x + dir_x.y * v.y + dir_x.z * v.z, + dir_y.x * v.x + dir_y.y * v.y + dir_y.z * v.z, + dir_z.x * v.x + dir_z.y * v.y + dir_z.z * v.z); +} + +IHD float3 normalize(const float3& v) { + return v * RNORM3DF(v.x, v.y, v.z); +} + +INLINE DEVICE float dot(const float3& a, const float3& b) { + return FADD(FADD(FMUL(a.x, b.x), FMUL(a.y, b.y)), FMUL(a.z, b.z)); +} + +INLINE DEVICE float3 cross(const float3& a, const float3& b) { + // TODO: faster + return make_float3( + a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x); +} + +namespace pulsar { +IHD CamGradInfo operator+(const CamGradInfo& a, const CamGradInfo& b) { + CamGradInfo res; + res.cam_pos = a.cam_pos + b.cam_pos; + res.pixel_0_0_center = a.pixel_0_0_center + b.pixel_0_0_center; + res.pixel_dir_x = a.pixel_dir_x + b.pixel_dir_x; + res.pixel_dir_y = a.pixel_dir_y + b.pixel_dir_y; + return res; +} + +IHD CamGradInfo operator*(const CamGradInfo& a, const float& b) { + CamGradInfo res; + res.cam_pos = a.cam_pos * b; + res.pixel_0_0_center = a.pixel_0_0_center * b; + res.pixel_dir_x = a.pixel_dir_x * b; + res.pixel_dir_y = a.pixel_dir_y * b; + return res; +} + +IHD IntWrapper operator+(const IntWrapper& a, const IntWrapper& b) { + IntWrapper res; + res.val = a.val + b.val; + return res; +} +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.backward.device.h b/pytorch3d/csrc/pulsar/include/renderer.backward.device.h new file mode 100644 index 00000000..175be513 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.backward.device.h @@ -0,0 +1,182 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_RENDERER_BACKWARD_DEVICE_H_ +#define PULSAR_NATIVE_RENDERER_BACKWARD_DEVICE_H_ + +#include "./camera.device.h" +#include "./math.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +template +void backward( + Renderer* self, + const float* grad_im, + const float* image, + const float* forw_info, + const float* vert_pos, + const float* vert_col, + const float* vert_rad, + const CamInfo& cam, + const float& gamma, + float percent_allowed_difference, + const uint& max_n_hits, + const float* vert_opy_d, + const size_t& num_balls, + const uint& mode, + const bool& dif_pos, + const bool& dif_col, + const bool& dif_rad, + const bool& dif_cam, + const bool& dif_opy, + cudaStream_t stream) { + ARGCHECK(gamma > 0.f && gamma <= 1.f, 6, "gamma must be in [0., 1.]"); + ARGCHECK( + percent_allowed_difference >= 0.f && percent_allowed_difference <= 1.f, + 7, + "percent_allowed_difference must be in [0., 1.]"); + ARGCHECK(max_n_hits >= 1u, 8, "max_n_hits must be >= 1"); + ARGCHECK( + num_balls > 0 && num_balls <= self->max_num_balls, + 9, + "num_balls must be >0 and less than max num balls!"); + ARGCHECK( + cam.film_width == self->cam.film_width && + cam.film_height == self->cam.film_height, + 5, + "cam film size must agree"); + ARGCHECK(mode <= 1, 10, "mode must be <= 1!"); + if (percent_allowed_difference < EPS) { + LOG(WARNING) << "percent_allowed_difference < " << FEPS << "! Clamping to " + << FEPS << "."; + percent_allowed_difference = FEPS; + } + if (percent_allowed_difference > 1.f - FEPS) { + LOG(WARNING) << "percent_allowed_difference > " << (1.f - FEPS) + << "! Clamping to " << (1.f - FEPS) << "."; + percent_allowed_difference = 1.f - FEPS; + } + LOG_IF(INFO, PULSAR_LOG_RENDER) << "Rendering backward pass..."; + // Update camera. + self->cam.eye = cam.eye; + self->cam.pixel_0_0_center = cam.pixel_0_0_center - cam.eye; + self->cam.pixel_dir_x = cam.pixel_dir_x; + self->cam.pixel_dir_y = cam.pixel_dir_y; + self->cam.sensor_dir_z = cam.sensor_dir_z; + self->cam.half_pixel_size = cam.half_pixel_size; + self->cam.focal_length = cam.focal_length; + self->cam.aperture_width = cam.aperture_width; + self->cam.aperture_height = cam.aperture_height; + self->cam.min_dist = cam.min_dist; + self->cam.max_dist = cam.max_dist; + self->cam.norm_fac = cam.norm_fac; + self->cam.principal_point_offset_x = cam.principal_point_offset_x; + self->cam.principal_point_offset_y = cam.principal_point_offset_y; + self->cam.film_border_left = cam.film_border_left; + self->cam.film_border_top = cam.film_border_top; +#ifdef PULSAR_TIMINGS_ENABLED + START_TIME(calc_signature); +#endif + LAUNCH_MAX_PARALLEL_1D( + calc_signature, + num_balls, + stream, + *self, + reinterpret_cast(vert_pos), + vert_col, + vert_rad, + num_balls); + CHECKLAUNCH(); +#ifdef PULSAR_TIMINGS_ENABLED + STOP_TIME(calc_signature); + START_TIME(calc_gradients); +#endif + MEMSET(self->grad_pos_d, 0, float3, num_balls, stream); + MEMSET(self->grad_col_d, 0, float, num_balls * self->cam.n_channels, stream); + MEMSET(self->grad_rad_d, 0, float, num_balls, stream); + MEMSET(self->grad_cam_d, 0, float, 12, stream); + MEMSET(self->grad_cam_buf_d, 0, CamGradInfo, num_balls, stream); + MEMSET(self->grad_opy_d, 0, float, num_balls, stream); + MEMSET(self->ids_sorted_d, 0, int, num_balls, stream); + LAUNCH_PARALLEL_2D( + calc_gradients, + self->cam.film_width, + self->cam.film_height, + GRAD_BLOCK_SIZE, + GRAD_BLOCK_SIZE, + stream, + self->cam, + grad_im, + gamma, + reinterpret_cast(vert_pos), + vert_col, + vert_rad, + vert_opy_d, + num_balls, + image, + forw_info, + self->di_d, + self->ii_d, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + self->grad_rad_d, + self->grad_col_d, + self->grad_pos_d, + self->grad_cam_buf_d, + self->grad_opy_d, + self->ids_sorted_d, + self->n_track); + CHECKLAUNCH(); +#ifdef PULSAR_TIMINGS_ENABLED + STOP_TIME(calc_gradients); + START_TIME(normalize); +#endif + LAUNCH_MAX_PARALLEL_1D( + norm_sphere_gradients, num_balls, stream, *self, num_balls); + CHECKLAUNCH(); + if (dif_cam) { + SUM_WS( + self->grad_cam_buf_d, + reinterpret_cast(self->grad_cam_d), + static_cast(num_balls), + self->workspace_d, + self->workspace_size, + stream); + CHECKLAUNCH(); + SUM_WS( + (IntWrapper*)(self->ids_sorted_d), + (IntWrapper*)(self->n_grad_contributions_d), + static_cast(num_balls), + self->workspace_d, + self->workspace_size, + stream); + CHECKLAUNCH(); + LAUNCH_MAX_PARALLEL_1D( + norm_cam_gradients, static_cast(1), stream, *self); + CHECKLAUNCH(); + } +#ifdef PULSAR_TIMINGS_ENABLED + STOP_TIME(normalize); + float time_ms; + // This blocks the result and prevents batch-processing from parallelizing. + GET_TIME(calc_signature, &time_ms); + std::cout << "Time for signature calculation: " << time_ms << " ms" + << std::endl; + GET_TIME(calc_gradients, &time_ms); + std::cout << "Time for gradient calculation: " << time_ms << " ms" + << std::endl; + GET_TIME(normalize, &time_ms); + std::cout << "Time for aggregation and normalization: " << time_ms << " ms" + << std::endl; +#endif + LOG_IF(INFO, PULSAR_LOG_RENDER) << "Backward pass complete."; +} + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.backward.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.backward.instantiate.h new file mode 100644 index 00000000..3ad16599 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.backward.instantiate.h @@ -0,0 +1,30 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./renderer.backward.device.h" + +namespace pulsar { +namespace Renderer { + +template void backward( + Renderer* self, + const float* grad_im, + const float* image, + const float* forw_info, + const float* vert_pos, + const float* vert_col, + const float* vert_rad, + const CamInfo& cam, + const float& gamma, + float percent_allowed_difference, + const uint& max_n_hits, + const float* vert_opy, + const size_t& num_balls, + const uint& mode, + const bool& dif_pos, + const bool& dif_col, + const bool& dif_rad, + const bool& dif_cam, + const bool& dif_opy, + cudaStream_t stream); + +} // namespace Renderer +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/include/renderer.backward_dbg.device.h b/pytorch3d/csrc/pulsar/include/renderer.backward_dbg.device.h new file mode 100644 index 00000000..5e1c0172 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.backward_dbg.device.h @@ -0,0 +1,150 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_RENDERER_BACKWARD_DBG_DEVICE_H_ +#define PULSAR_NATIVE_RENDERER_BACKWARD_DBG_DEVICE_H_ + +#include "./camera.device.h" +#include "./math.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +template +void backward_dbg( + Renderer* self, + const float* grad_im, + const float* image, + const float* forw_info, + const float* vert_pos, + const float* vert_col, + const float* vert_rad, + const CamInfo& cam, + const float& gamma, + float percent_allowed_difference, + const uint& max_n_hits, + const float* vert_opy_d, + const size_t& num_balls, + const uint& mode, + const bool& dif_pos, + const bool& dif_col, + const bool& dif_rad, + const bool& dif_cam, + const bool& dif_opy, + const uint& pos_x, + const uint& pos_y, + cudaStream_t stream) { + ARGCHECK(gamma > 0.f && gamma <= 1.f, 6, "gamma must be in [0., 1.]"); + ARGCHECK( + percent_allowed_difference >= 0.f && percent_allowed_difference <= 1.f, + 7, + "percent_allowed_difference must be in [0., 1.]"); + ARGCHECK(max_n_hits >= 1u, 8, "max_n_hits must be >= 1"); + ARGCHECK( + num_balls > 0 && num_balls <= self->max_num_balls, + 9, + "num_balls must be >0 and less than max num balls!"); + ARGCHECK( + cam.film_width == self->cam.film_width && + cam.film_height == self->cam.film_height, + 5, + "cam film size must agree"); + ARGCHECK(mode <= 1, 10, "mode must be <= 1!"); + if (percent_allowed_difference < EPS) { + LOG(WARNING) << "percent_allowed_difference < " << FEPS << "! Clamping to " + << FEPS << "."; + percent_allowed_difference = FEPS; + } + ARGCHECK( + pos_x < cam.film_width && pos_y < cam.film_height, + 15, + "pos_x must be < width and pos_y < height."); + if (percent_allowed_difference > 1.f - FEPS) { + LOG(WARNING) << "percent_allowed_difference > " << (1.f - FEPS) + << "! Clamping to " << (1.f - FEPS) << "."; + percent_allowed_difference = 1.f - FEPS; + } + LOG_IF(INFO, PULSAR_LOG_RENDER) + << "Rendering debug backward pass for x: " << pos_x << ", y: " << pos_y; + // Update camera. + self->cam.eye = cam.eye; + self->cam.pixel_0_0_center = cam.pixel_0_0_center - cam.eye; + self->cam.pixel_dir_x = cam.pixel_dir_x; + self->cam.pixel_dir_y = cam.pixel_dir_y; + self->cam.sensor_dir_z = cam.sensor_dir_z; + self->cam.half_pixel_size = cam.half_pixel_size; + self->cam.focal_length = cam.focal_length; + self->cam.aperture_width = cam.aperture_width; + self->cam.aperture_height = cam.aperture_height; + self->cam.min_dist = cam.min_dist; + self->cam.max_dist = cam.max_dist; + self->cam.norm_fac = cam.norm_fac; + self->cam.principal_point_offset_x = cam.principal_point_offset_x; + self->cam.principal_point_offset_y = cam.principal_point_offset_y; + self->cam.film_border_left = cam.film_border_left; + self->cam.film_border_top = cam.film_border_top; + LAUNCH_MAX_PARALLEL_1D( + calc_signature, + num_balls, + stream, + *self, + reinterpret_cast(vert_pos), + vert_col, + vert_rad, + num_balls); + CHECKLAUNCH(); + MEMSET(self->grad_pos_d, 0, float3, num_balls, stream); + MEMSET(self->grad_col_d, 0, float, num_balls * self->cam.n_channels, stream); + MEMSET(self->grad_rad_d, 0, float, num_balls, stream); + MEMSET(self->grad_cam_d, 0, float, 12, stream); + MEMSET(self->grad_cam_buf_d, 0, CamGradInfo, num_balls, stream); + MEMSET(self->grad_opy_d, 0, float, num_balls, stream); + MEMSET(self->ids_sorted_d, 0, int, num_balls, stream); + LAUNCH_MAX_PARALLEL_2D( + calc_gradients, + (int64_t)1, + (int64_t)1, + stream, + self->cam, + grad_im, + gamma, + reinterpret_cast(vert_pos), + vert_col, + vert_rad, + vert_opy_d, + num_balls, + image, + forw_info, + self->di_d, + self->ii_d, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + self->grad_rad_d, + self->grad_col_d, + self->grad_pos_d, + self->grad_cam_buf_d, + self->grad_opy_d, + self->ids_sorted_d, + self->n_track, + pos_x, + pos_y); + CHECKLAUNCH(); + // We're not doing sphere gradient normalization here. + SUM_WS( + self->grad_cam_buf_d, + reinterpret_cast(self->grad_cam_d), + static_cast(1), + self->workspace_d, + self->workspace_size, + stream); + CHECKLAUNCH(); + // We're not doing camera gradient normalization here. + LOG_IF(INFO, PULSAR_LOG_RENDER) << "Debug backward pass complete."; +} + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.backward_dbg.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.backward_dbg.instantiate.h new file mode 100644 index 00000000..c15108f9 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.backward_dbg.instantiate.h @@ -0,0 +1,32 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./renderer.backward_dbg.device.h" + +namespace pulsar { +namespace Renderer { + +template void backward_dbg( + Renderer* self, + const float* grad_im, + const float* image, + const float* forw_info, + const float* vert_pos, + const float* vert_col, + const float* vert_rad, + const CamInfo& cam, + const float& gamma, + float percent_allowed_difference, + const uint& max_n_hits, + const float* vert_opy, + const size_t& num_balls, + const uint& mode, + const bool& dif_pos, + const bool& dif_col, + const bool& dif_rad, + const bool& dif_cam, + const bool& dif_opy, + const uint& pos_x, + const uint& pos_y, + cudaStream_t stream); + +} // namespace Renderer +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/include/renderer.calc_gradients.device.h b/pytorch3d/csrc/pulsar/include/renderer.calc_gradients.device.h new file mode 100644 index 00000000..edf6ea8b --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.calc_gradients.device.h @@ -0,0 +1,191 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_CALC_GRADIENTS_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_CALC_GRADIENTS_H_ + +#include "../global.h" +#include "./commands.h" +#include "./renderer.h" + +#include "./renderer.draw.device.h" + +namespace pulsar { +namespace Renderer { + +template +GLOBAL void calc_gradients( + const CamInfo cam, /** Camera in world coordinates. */ + float const* const RESTRICT grad_im, /** The gradient image. */ + const float + gamma, /** The transparency parameter used in the forward pass. */ + float3 const* const RESTRICT vert_poss, /** Vertex position vector. */ + float const* const RESTRICT vert_cols, /** Vertex color vector. */ + float const* const RESTRICT vert_rads, /** Vertex radius vector. */ + float const* const RESTRICT opacity, /** Vertex opacity. */ + const uint num_balls, /** Number of balls. */ + float const* const RESTRICT result_d, /** Result image. */ + float const* const RESTRICT forw_info_d, /** Forward pass info. */ + DrawInfo const* const RESTRICT di_d, /** Draw information. */ + IntersectInfo const* const RESTRICT ii_d, /** Intersect information. */ + // Mode switches. + const bool calc_grad_pos, + const bool calc_grad_col, + const bool calc_grad_rad, + const bool calc_grad_cam, + const bool calc_grad_opy, + // Out variables. + float* const RESTRICT grad_rad_d, /** Radius gradients. */ + float* const RESTRICT grad_col_d, /** Color gradients. */ + float3* const RESTRICT grad_pos_d, /** Position gradients. */ + CamGradInfo* const RESTRICT grad_cam_buf_d, /** Camera gradient buffer. */ + float* const RESTRICT grad_opy_d, /** Opacity gradient buffer. */ + int* const RESTRICT + grad_contributed_d, /** Gradient contribution counter. */ + // Infrastructure. + const int n_track, + const uint offs_x, + const uint offs_y /** Debug offsets. */ +) { + uint limit_x = cam.film_width, limit_y = cam.film_height; + if (offs_x != 0) { + // We're in debug mode. + limit_x = 1; + limit_y = 1; + } + GET_PARALLEL_IDS_2D(coord_x_base, coord_y_base, limit_x, limit_y); + // coord_x_base and coord_y_base are in the film coordinate system. + // We now need to translate to the aperture coordinate system. If + // the principal point was shifted left/up nothing has to be + // subtracted - only shift needs to be added in case it has been + // shifted down/right. + const uint film_coord_x = coord_x_base + offs_x; + const uint ap_coord_x = film_coord_x + + 2 * static_cast(std::max(0, cam.principal_point_offset_x)); + const uint film_coord_y = coord_y_base + offs_y; + const uint ap_coord_y = film_coord_y + + 2 * static_cast(std::max(0, cam.principal_point_offset_y)); + const float3 ray_dir = /** Ray cast through the pixel, normalized. */ + cam.pixel_0_0_center + ap_coord_x * cam.pixel_dir_x + + ap_coord_y * cam.pixel_dir_y; + const float norm_ray_dir = length(ray_dir); + // ray_dir_norm *must* be calculated here in the same way as in the draw + // function to have the same values withno other numerical instabilities + // (for example, ray_dir * FRCP(norm_ray_dir) does not work)! + float3 ray_dir_norm; /** Ray cast through the pixel, normalized. */ + float2 projected_ray; /** Ray intersection with the sensor. */ + if (cam.orthogonal_projection) { + ray_dir_norm = cam.sensor_dir_z; + projected_ray.x = static_cast(ap_coord_x); + projected_ray.y = static_cast(ap_coord_y); + } else { + ray_dir_norm = normalize( + cam.pixel_0_0_center + ap_coord_x * cam.pixel_dir_x + + ap_coord_y * cam.pixel_dir_y); + // This is a reasonable assumption for normal focal lengths and image sizes. + PASSERT(FABS(ray_dir_norm.z) > FEPS); + projected_ray.x = ray_dir_norm.x / ray_dir_norm.z * cam.focal_length; + projected_ray.y = ray_dir_norm.y / ray_dir_norm.z * cam.focal_length; + } + float* result = const_cast( + result_d + film_coord_y * cam.film_width * cam.n_channels + + film_coord_x * cam.n_channels); + const float* grad_im_l = grad_im + + film_coord_y * cam.film_width * cam.n_channels + + film_coord_x * cam.n_channels; + // For writing... + float3 grad_pos; + float grad_rad, grad_opy; + CamGradInfo grad_cam_local = CamGradInfo(); + // Set up shared infrastructure. + const int fwi_loc = film_coord_y * cam.film_width * (3 + 2 * n_track) + + film_coord_x * (3 + 2 * n_track); + float sm_m = forw_info_d[fwi_loc]; + float sm_d = forw_info_d[fwi_loc + 1]; + PULSAR_LOG_DEV_APIX( + PULSAR_LOG_GRAD, + "grad|sm_m: %f, sm_d: %f, result: " + "%f, %f, %f; grad_im: %f, %f, %f.\n", + sm_m, + sm_d, + result[0], + result[1], + result[2], + grad_im_l[0], + grad_im_l[1], + grad_im_l[2]); + // Start processing. + for (int grad_idx = 0; grad_idx < n_track; ++grad_idx) { + int sphere_idx; + FASI(forw_info_d[fwi_loc + 3 + 2 * grad_idx], sphere_idx); + PASSERT( + sphere_idx == -1 || + sphere_idx >= 0 && static_cast(sphere_idx) < num_balls); + if (sphere_idx >= 0) { + // TODO: make more efficient. + grad_pos = make_float3(0.f, 0.f, 0.f); + grad_rad = 0.f; + grad_cam_local = CamGradInfo(); + const DrawInfo di = di_d[sphere_idx]; + grad_opy = 0.f; + draw( + di, + opacity == NULL ? 1.f : opacity[sphere_idx], + cam, + gamma, + ray_dir_norm, + projected_ray, + // Mode switches. + false, // draw only + calc_grad_pos, + calc_grad_col, + calc_grad_rad, + calc_grad_cam, + calc_grad_opy, + // Position info. + ap_coord_x, + ap_coord_y, + sphere_idx, + // Optional in. + &ii_d[sphere_idx], + &ray_dir, + &norm_ray_dir, + grad_im_l, + NULL, + // In/out + &sm_d, + &sm_m, + result, + // Optional out. + NULL, + NULL, + &grad_pos, + grad_col_d + sphere_idx * cam.n_channels, + &grad_rad, + &grad_cam_local, + &grad_opy); + ATOMICADD(&(grad_rad_d[sphere_idx]), grad_rad); + // Color has been added directly. + ATOMICADD_F3(&(grad_pos_d[sphere_idx]), grad_pos); + ATOMICADD_F3( + &(grad_cam_buf_d[sphere_idx].cam_pos), grad_cam_local.cam_pos); + if (!cam.orthogonal_projection) { + ATOMICADD_F3( + &(grad_cam_buf_d[sphere_idx].pixel_0_0_center), + grad_cam_local.pixel_0_0_center); + } + ATOMICADD_F3( + &(grad_cam_buf_d[sphere_idx].pixel_dir_x), + grad_cam_local.pixel_dir_x); + ATOMICADD_F3( + &(grad_cam_buf_d[sphere_idx].pixel_dir_y), + grad_cam_local.pixel_dir_y); + ATOMICADD(&(grad_opy_d[sphere_idx]), grad_opy); + ATOMICADD(&(grad_contributed_d[sphere_idx]), 1); + } + } + END_PARALLEL_2D_NORET(); +}; + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.calc_gradients.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.calc_gradients.instantiate.h new file mode 100644 index 00000000..14c70386 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.calc_gradients.instantiate.h @@ -0,0 +1,41 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./renderer.calc_gradients.device.h" + +namespace pulsar { +namespace Renderer { + +template GLOBAL void calc_gradients( + const CamInfo cam, /** Camera in world coordinates. */ + float const* const RESTRICT grad_im, /** The gradient image. */ + const float + gamma, /** The transparency parameter used in the forward pass. */ + float3 const* const RESTRICT vert_poss, /** Vertex position vector. */ + float const* const RESTRICT vert_cols, /** Vertex color vector. */ + float const* const RESTRICT vert_rads, /** Vertex radius vector. */ + float const* const RESTRICT opacity, /** Vertex opacity. */ + const uint num_balls, /** Number of balls. */ + float const* const RESTRICT result_d, /** Result image. */ + float const* const RESTRICT forw_info_d, /** Forward pass info. */ + DrawInfo const* const RESTRICT di_d, /** Draw information. */ + IntersectInfo const* const RESTRICT ii_d, /** Intersect information. */ + // Mode switches. + const bool calc_grad_pos, + const bool calc_grad_col, + const bool calc_grad_rad, + const bool calc_grad_cam, + const bool calc_grad_opy, + // Out variables. + float* const RESTRICT grad_rad_d, /** Radius gradients. */ + float* const RESTRICT grad_col_d, /** Color gradients. */ + float3* const RESTRICT grad_pos_d, /** Position gradients. */ + CamGradInfo* const RESTRICT grad_cam_buf_d, /** Camera gradient buffer. */ + float* const RESTRICT grad_opy_d, /** Opacity gradient buffer. */ + int* const RESTRICT + grad_contributed_d, /** Gradient contribution counter. */ + // Infrastructure. + const int n_track, + const uint offs_x, + const uint offs_y); + +} // namespace Renderer +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/include/renderer.calc_signature.device.h b/pytorch3d/csrc/pulsar/include/renderer.calc_signature.device.h new file mode 100644 index 00000000..84b3e0aa --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.calc_signature.device.h @@ -0,0 +1,194 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_CALC_SIGNATURE_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_CALC_SIGNATURE_DEVICE_H_ + +#include "../global.h" +#include "./camera.device.h" +#include "./commands.h" +#include "./math.h" +#include "./renderer.get_screen_area.device.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +template +GLOBAL void calc_signature( + Renderer renderer, + float3 const* const RESTRICT vert_poss, + float const* const RESTRICT vert_cols, + float const* const RESTRICT vert_rads, + const uint num_balls) { + /* We're not using RESTRICT here for the pointers within `renderer`. Just one + value is being read from each of the pointers, so the effect would be + negligible or non-existent. */ + GET_PARALLEL_IDX_1D(idx, num_balls); + // Create aliases. + // For reading... + const float3& vert_pos = vert_poss[idx]; /** Vertex position. */ + const float* vert_col = + vert_cols + idx * renderer.cam.n_channels; /** Vertex color. */ + const float& vert_rad = vert_rads[idx]; /** Vertex radius. */ + const CamInfo& cam = renderer.cam; /** Camera in world coordinates. */ + // For writing... + /** Ball ID (either original index of the ball or -1 if not visible). */ + int& id_out = renderer.ids_d[idx]; + /** Intersection helper structure for the ball. */ + IntersectInfo& intersect_helper_out = renderer.ii_d[idx]; + /** Draw helper structure for this ball. */ + DrawInfo& draw_helper_out = renderer.di_d[idx]; + /** Minimum possible intersection depth for this ball. */ + float& closest_possible_intersect_out = renderer.min_depth_d[idx]; + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|vert_pos: %.9f, %.9f, %.9f, vert_col (first three): " + "%.9f, %.9f, %.9f.\n", + idx, + vert_pos.x, + vert_pos.y, + vert_pos.z, + vert_col[0], + vert_col[1], + vert_col[2]); + // Set flags to invalid for a potential early return. + id_out = -1; // Invalid ID. + closest_possible_intersect_out = + MAX_FLOAT; // These spheres are sorted to the very end. + intersect_helper_out.max.x = MAX_USHORT; // No intersection possible. + intersect_helper_out.min.x = MAX_USHORT; + intersect_helper_out.max.y = MAX_USHORT; + intersect_helper_out.min.y = MAX_USHORT; + // Start processing. + /** Ball center in the camera coordinate system. */ + const float3 ball_center_cam = vert_pos - cam.eye; + /** Distance to the ball center in the camera coordinate system. */ + const float t_center = length(ball_center_cam); + /** Closest possible intersection with this ball from the camera. */ + float closest_possible_intersect; + if (cam.orthogonal_projection) { + const float3 ball_center_cam_rot = rotate( + ball_center_cam, + cam.pixel_dir_x / length(cam.pixel_dir_x), + cam.pixel_dir_y / length(cam.pixel_dir_y), + cam.sensor_dir_z); + closest_possible_intersect = ball_center_cam_rot.z - vert_rad; + } else { + closest_possible_intersect = t_center - vert_rad; + } + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|t_center: %f. vert_rad: %f. " + "closest_possible_intersect: %f.\n", + idx, + t_center, + vert_rad, + closest_possible_intersect); + /** + * Corner points of the enclosing projected rectangle of the ball. + * They are first calculated in the camera coordinate system, then + * converted to the pixel coordinate system. + */ + float x_1, x_2, y_1, y_2; + bool hits_screen_plane; + float3 ray_center_norm = ball_center_cam / t_center; + PASSERT(vert_rad >= 0.f); + if (closest_possible_intersect < cam.min_dist || + closest_possible_intersect > cam.max_dist) { + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|ignoring sphere out of min/max bounds: %.9f, " + "min: %.9f, max: %.9f.\n", + idx, + closest_possible_intersect, + cam.min_dist, + cam.max_dist); + RETURN_PARALLEL(); + } + // Find the relevant region on the screen plane. + hits_screen_plane = get_screen_area( + ball_center_cam, + ray_center_norm, + vert_rad, + cam, + idx, + &x_1, + &x_2, + &y_1, + &y_2); + if (!hits_screen_plane) + RETURN_PARALLEL(); + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|in pixels: x_1: %f, x_2: %f, y_1: %f, y_2: %f.\n", + idx, + x_1, + x_2, + y_1, + y_2); + // Check whether the pixel coordinates are on screen. + if (FMAX(x_1, x_2) <= static_cast(cam.film_border_left) || + FMIN(x_1, x_2) >= + static_cast(cam.film_border_left + cam.film_width) - 0.5f || + FMAX(y_1, y_2) <= static_cast(cam.film_border_top) || + FMIN(y_1, y_2) > + static_cast(cam.film_border_top + cam.film_height) - 0.5f) + RETURN_PARALLEL(); + // Write results. + id_out = idx; + intersect_helper_out.min.x = static_cast( + FMAX(FMIN(x_1, x_2), static_cast(cam.film_border_left))); + intersect_helper_out.min.y = static_cast( + FMAX(FMIN(y_1, y_2), static_cast(cam.film_border_top))); + // In the following calculations, the max that needs to be stored is + // exclusive. + // That means that the calculated value needs to be `ceil`ed and incremented + // to find the correct value. + intersect_helper_out.max.x = static_cast(FMIN( + FCEIL(FMAX(x_1, x_2)) + 1, + static_cast(cam.film_border_left + cam.film_width))); + intersect_helper_out.max.y = static_cast(FMIN( + FCEIL(FMAX(y_1, y_2)) + 1, + static_cast(cam.film_border_top + cam.film_height))); + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|limits after refining: x_1: %u, x_2: %u, " + "y_1: %u, y_2: %u.\n", + idx, + intersect_helper_out.min.x, + intersect_helper_out.max.x, + intersect_helper_out.min.y, + intersect_helper_out.max.y); + if (intersect_helper_out.min.x == MAX_USHORT) { + id_out = -1; + RETURN_PARALLEL(); + } + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|writing info. closest_possible_intersect: %.9f. " + "ray_center_norm: %.9f, %.9f, %.9f. t_center: %.9f. radius: %.9f.\n", + idx, + closest_possible_intersect, + ray_center_norm.x, + ray_center_norm.y, + ray_center_norm.z, + t_center, + vert_rad); + closest_possible_intersect_out = closest_possible_intersect; + draw_helper_out.ray_center_norm = ray_center_norm; + draw_helper_out.t_center = t_center; + draw_helper_out.radius = vert_rad; + if (cam.n_channels <= 3) { + draw_helper_out.first_color = vert_col[0]; + for (uint c_id = 1; c_id < cam.n_channels; ++c_id) { + draw_helper_out.color_union.color[c_id - 1] = vert_col[c_id]; + } + } else { + draw_helper_out.color_union.ptr = const_cast(vert_col); + } + END_PARALLEL(); +}; + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.calc_signature.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.calc_signature.instantiate.h new file mode 100644 index 00000000..b87bcff7 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.calc_signature.instantiate.h @@ -0,0 +1,18 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_CALC_SIGNATURE_INSTANTIATE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_CALC_SIGNATURE_INSTANTIATE_H_ + +#include "./renderer.calc_signature.device.h" + +namespace pulsar { +namespace Renderer { +template GLOBAL void calc_signature( + Renderer renderer, + float3 const* const RESTRICT vert_poss, + float const* const RESTRICT vert_cols, + float const* const RESTRICT vert_rads, + const uint num_balls); +} +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.construct.device.h b/pytorch3d/csrc/pulsar/include/renderer.construct.device.h new file mode 100644 index 00000000..55bde54d --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.construct.device.h @@ -0,0 +1,104 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_CONSTRUCT_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_CONSTRUCT_DEVICE_H_ + +#include "../global.h" +#include "./camera.device.h" +#include "./commands.h" +#include "./math.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +template +HOST void construct( + Renderer* self, + const size_t& max_num_balls, + const int& width, + const int& height, + const bool& orthogonal_projection, + const bool& right_handed_system, + const float& background_normalization_depth, + const uint& n_channels, + const uint& n_track) { + ARGCHECK( + (max_num_balls > 0 && max_num_balls < MAX_INT), + 2, + ("the maximum number of balls must be >0 and <" + + std::to_string(MAX_INT) + ". Is " + std::to_string(max_num_balls) + ".") + .c_str()); + ARGCHECK(width > 1, 3, "the image width must be > 1"); + ARGCHECK(height > 1, 4, "the image height must be > 1"); + ARGCHECK( + background_normalization_depth > 0.f && + background_normalization_depth < 1.f, + 6, + "background_normalization_depth must be in ]0., 1.[."); + ARGCHECK(n_channels > 0, 7, "n_channels must be >0!"); + ARGCHECK( + n_track > 0 && n_track <= MAX_GRAD_SPHERES, + 8, + ("n_track must be >0 and <" + std::to_string(MAX_GRAD_SPHERES) + ". Is " + + std::to_string(n_track) + ".") + .c_str()); + self->cam.film_width = width; + self->cam.film_height = height; + self->max_num_balls = max_num_balls; + MALLOC(self->result_d, float, width* height* n_channels); + self->cam.orthogonal_projection = orthogonal_projection; + self->cam.right_handed = right_handed_system; + self->cam.background_normalization_depth = background_normalization_depth; + self->cam.n_channels = n_channels; + MALLOC(self->min_depth_d, float, max_num_balls); + MALLOC(self->min_depth_sorted_d, float, max_num_balls); + MALLOC(self->ii_d, IntersectInfo, max_num_balls); + MALLOC(self->ii_sorted_d, IntersectInfo, max_num_balls); + MALLOC(self->ids_d, int, max_num_balls); + MALLOC(self->ids_sorted_d, int, max_num_balls); + size_t sort_id_size = 0; + GET_SORT_WS_SIZE(&sort_id_size, float, int, max_num_balls); + CHECKLAUNCH(); + size_t sort_ii_size = 0; + GET_SORT_WS_SIZE(&sort_ii_size, float, IntersectInfo, max_num_balls); + CHECKLAUNCH(); + size_t sort_di_size = 0; + GET_SORT_WS_SIZE(&sort_di_size, float, DrawInfo, max_num_balls); + CHECKLAUNCH(); + size_t select_ii_size = 0; + GET_SELECT_WS_SIZE(&select_ii_size, char, IntersectInfo, max_num_balls); + size_t select_di_size = 0; + GET_SELECT_WS_SIZE(&select_di_size, char, DrawInfo, max_num_balls); + size_t sum_size = 0; + GET_SUM_WS_SIZE(&sum_size, CamGradInfo, max_num_balls); + size_t sum_cont_size = 0; + GET_SUM_WS_SIZE(&sum_cont_size, int, max_num_balls); + size_t reduce_size = 0; + GET_REDUCE_WS_SIZE( + &reduce_size, IntersectInfo, IntersectInfoMinMax(), max_num_balls); + self->workspace_size = IMAX( + IMAX(IMAX(sort_id_size, sort_ii_size), sort_di_size), + IMAX( + IMAX(select_di_size, select_ii_size), + IMAX(IMAX(sum_size, sum_cont_size), reduce_size))); + MALLOC(self->workspace_d, char, self->workspace_size); + MALLOC(self->di_d, DrawInfo, max_num_balls); + MALLOC(self->di_sorted_d, DrawInfo, max_num_balls); + MALLOC(self->region_flags_d, char, max_num_balls); + MALLOC(self->num_selected_d, size_t, 1); + MALLOC(self->forw_info_d, float, width* height*(3 + 2 * n_track)); + MALLOC(self->min_max_pixels_d, IntersectInfo, 1); + MALLOC(self->grad_pos_d, float3, max_num_balls); + MALLOC(self->grad_col_d, float, max_num_balls* n_channels); + MALLOC(self->grad_rad_d, float, max_num_balls); + MALLOC(self->grad_cam_d, float, 12); + MALLOC(self->grad_cam_buf_d, CamGradInfo, max_num_balls); + MALLOC(self->grad_opy_d, float, max_num_balls); + MALLOC(self->n_grad_contributions_d, int, 1); + self->n_track = static_cast(n_track); +} + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.construct.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.construct.instantiate.h new file mode 100644 index 00000000..09964f2b --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.construct.instantiate.h @@ -0,0 +1,22 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_CONSTRUCT_INSTANTIATE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_CONSTRUCT_INSTANTIATE_H_ + +#include "./renderer.construct.device.h" + +namespace pulsar { +namespace Renderer { +template void construct( + Renderer* self, + const size_t& max_num_balls, + const int& width, + const int& height, + const bool& orthogonal_projection, + const bool& right_handed_system, + const float& background_normalization_depth, + const uint& n_channels, + const uint& n_track); +} +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.create_selector.device.h b/pytorch3d/csrc/pulsar/include/renderer.create_selector.device.h new file mode 100644 index 00000000..42ef5c25 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.create_selector.device.h @@ -0,0 +1,34 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_CREATE_SELECTOR_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_CREATE_SELECTOR_DEVICE_H_ + +#include "../global.h" +#include "./commands.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +template +GLOBAL void create_selector( + IntersectInfo const* const RESTRICT ii_sorted_d, + const uint num_balls, + const int min_x, + const int max_x, + const int min_y, + const int max_y, + /* Out variables. */ + char* RESTRICT region_flags_d) { + GET_PARALLEL_IDX_1D(idx, num_balls); + bool hit = (static_cast(ii_sorted_d[idx].min.x) <= max_x) && + (static_cast(ii_sorted_d[idx].max.x) > min_x) && + (static_cast(ii_sorted_d[idx].min.y) <= max_y) && + (static_cast(ii_sorted_d[idx].max.y) > min_y); + region_flags_d[idx] = hit; + END_PARALLEL_NORET(); +} + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.create_selector.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.create_selector.instantiate.h new file mode 100644 index 00000000..bafd9fac --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.create_selector.instantiate.h @@ -0,0 +1,23 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_CREATE_SELECTOR_INSTANTIATE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_CREATE_SELECTOR_INSTANTIATE_H_ + +#include "./renderer.create_selector.device.h" + +namespace pulsar { +namespace Renderer { + +template GLOBAL void create_selector( + IntersectInfo const* const RESTRICT ii_sorted_d, + const uint num_balls, + const int min_x, + const int max_x, + const int min_y, + const int max_y, + /* Out variables. */ + char* RESTRICT region_flags_d); + +} +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.destruct.device.h b/pytorch3d/csrc/pulsar/include/renderer.destruct.device.h new file mode 100644 index 00000000..a3a1044e --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.destruct.device.h @@ -0,0 +1,82 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_DESTRUCT_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_DESTRUCT_H_ + +#include "../global.h" +#include "./commands.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +template +HOST void destruct(Renderer* self) { + if (self->result_d != NULL) + FREE(self->result_d); + self->result_d = NULL; + if (self->min_depth_d != NULL) + FREE(self->min_depth_d); + self->min_depth_d = NULL; + if (self->min_depth_sorted_d != NULL) + FREE(self->min_depth_sorted_d); + self->min_depth_sorted_d = NULL; + if (self->ii_d != NULL) + FREE(self->ii_d); + self->ii_d = NULL; + if (self->ii_sorted_d != NULL) + FREE(self->ii_sorted_d); + self->ii_sorted_d = NULL; + if (self->ids_d != NULL) + FREE(self->ids_d); + self->ids_d = NULL; + if (self->ids_sorted_d != NULL) + FREE(self->ids_sorted_d); + self->ids_sorted_d = NULL; + if (self->workspace_d != NULL) + FREE(self->workspace_d); + self->workspace_d = NULL; + if (self->di_d != NULL) + FREE(self->di_d); + self->di_d = NULL; + if (self->di_sorted_d != NULL) + FREE(self->di_sorted_d); + self->di_sorted_d = NULL; + if (self->region_flags_d != NULL) + FREE(self->region_flags_d); + self->region_flags_d = NULL; + if (self->num_selected_d != NULL) + FREE(self->num_selected_d); + self->num_selected_d = NULL; + if (self->forw_info_d != NULL) + FREE(self->forw_info_d); + self->forw_info_d = NULL; + if (self->min_max_pixels_d != NULL) + FREE(self->min_max_pixels_d); + self->min_max_pixels_d = NULL; + if (self->grad_pos_d != NULL) + FREE(self->grad_pos_d); + self->grad_pos_d = NULL; + if (self->grad_col_d != NULL) + FREE(self->grad_col_d); + self->grad_col_d = NULL; + if (self->grad_rad_d != NULL) + FREE(self->grad_rad_d); + self->grad_rad_d = NULL; + if (self->grad_cam_d != NULL) + FREE(self->grad_cam_d); + self->grad_cam_d = NULL; + if (self->grad_cam_buf_d != NULL) + FREE(self->grad_cam_buf_d); + self->grad_cam_buf_d = NULL; + if (self->grad_opy_d != NULL) + FREE(self->grad_opy_d); + self->grad_opy_d = NULL; + if (self->n_grad_contributions_d != NULL) + FREE(self->n_grad_contributions_d); + self->n_grad_contributions_d = NULL; +} + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.destruct.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.destruct.instantiate.h new file mode 100644 index 00000000..ce3d10f2 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.destruct.instantiate.h @@ -0,0 +1,13 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_DESTRUCT_INSTANTIATE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_DESTRUCT_INSTANTIATE_H_ + +#include "./renderer.destruct.device.h" + +namespace pulsar { +namespace Renderer { +template void destruct(Renderer* self); +} +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.draw.device.h b/pytorch3d/csrc/pulsar/include/renderer.draw.device.h new file mode 100644 index 00000000..379319a7 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.draw.device.h @@ -0,0 +1,839 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_CALC_SIGNATURE_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_CALC_SIGNATURE_DEVICE_H_ + +#include "../global.h" +#include "./camera.device.h" +#include "./commands.h" +#include "./math.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +/** + * Draw a ball into the `result`. + * + * Returns whether a hit was noticed. See README for an explanation of sphere + * points and variable notation. + */ +INLINE DEVICE bool draw( + /* In variables. */ + const DrawInfo& draw_info, /** The draw information for this ball. */ + const float& opacity, /** The sphere opacity. */ + const CamInfo& + cam, /** Camera information. Doesn't have to be normalized. */ + const float& gamma, /** 'Transparency' indicator (see paper for details). */ + const float3& ray_dir_norm, /** The direction of the ray, normalized. */ + const float2& projected_ray, /** The intersection of the ray with the image + in pixel space. */ + /** Mode switches. */ + const bool& draw_only, /** Whether we are in draw vs. grad mode. */ + const bool& calc_grad_pos, /** Calculate position gradients. */ + const bool& calc_grad_col, /** Calculate color gradients. */ + const bool& calc_grad_rad, /** Calculate radius gradients. */ + const bool& calc_grad_cam, /** Calculate camera gradients. */ + const bool& calc_grad_opy, /** Calculate opacity gradients. */ + /** Position info. */ + const uint& coord_x, /** The pixel position x to draw at. */ + const uint& coord_y, /** The pixel position y to draw at. */ + const uint& idx, /** The id of the sphere to process. */ + /* Optional in variables. */ + IntersectInfo const* const RESTRICT + intersect_info, /** The intersect information for this ball. */ + float3 const* const RESTRICT ray_dir, /** The ray direction (not normalized) + to draw at. Only used for grad computation. */ + float const* const RESTRICT norm_ray_dir, /** The length of the direction + vector. Only used for grad computation. */ + float const* const RESTRICT grad_pix, /** The gradient for this pixel. Only + used for grad computation. */ + float const* const RESTRICT + ln_pad_over_1minuspad, /** Allowed percentage indicator. */ + /* In or out variables, depending on mode. */ + float* const RESTRICT sm_d, /** Normalization denominator. */ + float* const RESTRICT + sm_m, /** Maximum of normalization weight factors observed. */ + float* const RESTRICT + result, /** Result pixel color. Must be zeros initially. */ + /* Optional out variables. */ + float* const RESTRICT depth_threshold, /** The depth threshold to use. Only + used for rendering. */ + float* const RESTRICT intersection_depth_norm_out, /** The intersection + depth. Only set when rendering. */ + float3* const RESTRICT grad_pos, /** Gradient w.r.t. position. */ + float* const RESTRICT grad_col, /** Gradient w.r.t. color. */ + float* const RESTRICT grad_rad, /** Gradient w.r.t. radius. */ + CamGradInfo* const RESTRICT grad_cam, /** Gradient w.r.t. camera. */ + float* const RESTRICT grad_opy /** Gradient w.r.t. opacity. */ +) { + // TODO: variable reuse? + PASSERT( + isfinite(draw_info.ray_center_norm.x) && + isfinite(draw_info.ray_center_norm.y) && + isfinite(draw_info.ray_center_norm.z)); + PASSERT(isfinite(draw_info.t_center) && draw_info.t_center >= 0.f); + PASSERT( + isfinite(draw_info.radius) && draw_info.radius >= 0.f && + draw_info.radius <= draw_info.t_center); + PASSERT(isfinite(ray_dir_norm.x)); + PASSERT(isfinite(ray_dir_norm.y)); + PASSERT(isfinite(ray_dir_norm.z)); + PASSERT(isfinite(*sm_d)); + PASSERT( + cam.orthogonal_projection && cam.focal_length == 0.f || + cam.focal_length > 0.f); + PASSERT(gamma <= 1.f && gamma >= 1e-5f); + /** The ball center in the camera coordinate system. */ + float3 center = draw_info.ray_center_norm * draw_info.t_center; + /** The vector from the reference point to the ball center. */ + float3 raydiff; + if (cam.orthogonal_projection) { + center = rotate( + center, + cam.pixel_dir_x / length(cam.pixel_dir_x), + cam.pixel_dir_y / length(cam.pixel_dir_y), + cam.sensor_dir_z); + raydiff = + make_float3( // TODO: make offset consistent with `get_screen_area`. + center.x - + (projected_ray.x - + static_cast(cam.aperture_width) * .5f) * + (2.f * cam.half_pixel_size), + center.y - + (projected_ray.y - + static_cast(cam.aperture_height) * .5f) * + (2.f * cam.half_pixel_size), + 0.f); + } else { + /** The reference point on the ray; the point in the same distance + * from the camera as the ball center, but along the ray. + */ + const float3 rayref = ray_dir_norm * draw_info.t_center; + raydiff = center - rayref; + } + /** The closeness of the reference point to ball center in world coords. + * + * In [0., radius]. + */ + const float closeness_world = length(raydiff); + /** The reciprocal radius. */ + const float radius_rcp = FRCP(draw_info.radius); + /** The closeness factor normalized with the ball radius. + * + * In [0., 1.]. + */ + float closeness = FSATURATE(FMA(-closeness_world, radius_rcp, 1.f)); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_DRAW_PIX, + "drawprep %u|center: %.9f, %.9f, %.9f. raydiff: %.9f, " + "%.9f, %.9f. closeness_world: %.9f. closeness: %.9f\n", + idx, + center.x, + center.y, + center.z, + raydiff.x, + raydiff.y, + raydiff.z, + closeness_world, + closeness); + /** Whether this is the 'center pixel' for this ball, the pixel that + * is closest to its projected center. This information is used to + * make sure to draw 'tiny' spheres with less than one pixel in + * projected size. + */ + bool ray_through_center_pixel; + float projected_radius, projected_x, projected_y; + if (cam.orthogonal_projection) { + projected_x = center.x / (2.f * cam.half_pixel_size) + + (static_cast(cam.aperture_width) - 1.f) / 2.f; + projected_y = center.y / (2.f * cam.half_pixel_size) + + (static_cast(cam.aperture_height) - 1.f) / 2.f; + projected_radius = draw_info.radius / (2.f * cam.half_pixel_size); + ray_through_center_pixel = + (FABS(FSUB(projected_x, projected_ray.x)) < 0.5f + FEPS && + FABS(FSUB(projected_y, projected_ray.y)) < 0.5f + FEPS); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_DRAW_PIX, + "drawprep %u|closeness_world: %.9f. closeness: %.9f. " + "projected (x, y): %.9f, %.9f. projected_ray (x, y): " + "%.9f, %.9f. ray_through_center_pixel: %d.\n", + idx, + closeness_world, + closeness, + projected_x, + projected_y, + projected_ray.x, + projected_ray.y, + ray_through_center_pixel); + } else { + // Misusing this variable for half pixel size projected to the depth + // at which the sphere resides. Leave some slack for numerical + // inaccuracy (factor 1.5). + projected_x = FMUL(cam.half_pixel_size * 1.5, draw_info.t_center) * + FRCP(cam.focal_length); + projected_radius = FMUL(draw_info.radius, cam.focal_length) * + FRCP(draw_info.t_center) / (2.f * cam.half_pixel_size); + ray_through_center_pixel = projected_x > closeness_world; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_DRAW_PIX, + "drawprep %u|closeness_world: %.9f. closeness: %.9f. " + "projected half pixel size: %.9f. " + "ray_through_center_pixel: %d.\n", + idx, + closeness_world, + closeness, + projected_x, + ray_through_center_pixel); + } + if (draw_only && draw_info.radius < closeness_world && + !ray_through_center_pixel) { + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_DRAW_PIX, + "drawprep %u|Abandoning since no hit has been detected.\n", + idx); + return false; + } else { + // This is always a hit since we are following the forward execution pass. + // p2 is the closest intersection point with the sphere. + } + if (ray_through_center_pixel && projected_radius < 1.f) { + // Make a tiny sphere visible. + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_DRAW_PIX, + "drawprep %u|Setting closeness to 1 (projected radius: %.9f).\n", + idx, + projected_radius); + closeness = 1.; + } + PASSERT(closeness >= 0.f && closeness <= 1.f); + /** Distance between the camera (`o`) and `p1`, the closest point to the + * ball center along the casted ray. + * + * In [t_center - radius, t_center]. + */ + float o__p1_; + /** The distance from ball center to p1. + * + * In [0., sqrt(t_center ^ 2 - (t_center - radius) ^ 2)]. + */ + float c__p1_; + if (cam.orthogonal_projection) { + o__p1_ = FABS(center.z); + c__p1_ = length(raydiff); + } else { + o__p1_ = dot(center, ray_dir_norm); + /** + * This is being calculated as sqrt(t_center^2 - o__p1_^2) = + * sqrt((t_center + o__p1_) * (t_center - o__p1_)) to avoid + * catastrophic cancellation in floating point representations. + */ + c__p1_ = FSQRT( + (draw_info.t_center + o__p1_) * FMAX(draw_info.t_center - o__p1_, 0.f)); + // PASSERT(o__p1_ >= draw_info.t_center - draw_info.radius); + // Numerical errors lead to too large values. + o__p1_ = FMIN(o__p1_, draw_info.t_center); + // PASSERT(o__p1_ <= draw_info.t_center); + } + /** The distance from the closest point to the sphere center (p1) + * to the closest intersection point (p2). + * + * In [0., radius]. + */ + const float p1__p2_ = + FSQRT((draw_info.radius + c__p1_) * FMAX(draw_info.radius - c__p1_, 0.f)); + PASSERT(p1__p2_ >= 0.f && p1__p2_ <= draw_info.radius); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_DRAW_PIX, + "drawprep %u|o__p1_: %.9f, c__p1_: %.9f, p1__p2_: %.9f.\n", + idx, + o__p1_, + c__p1_, + p1__p2_); + /** The intersection depth of the ray with this ball. + * + * In [t_center - radius, t_center]. + */ + const float intersection_depth = (o__p1_ - p1__p2_); + PASSERT( + cam.orthogonal_projection && + (intersection_depth >= center.z - draw_info.radius && + intersection_depth <= center.z) || + intersection_depth >= draw_info.t_center - draw_info.radius && + intersection_depth <= draw_info.t_center); + /** Normalized distance of the closest intersection point; in [0., 1.]. */ + const float norm_dist = + FMUL(FSUB(intersection_depth, cam.min_dist), cam.norm_fac); + PASSERT(norm_dist >= 0.f && norm_dist <= 1.f); + /** Scaled, normalized distance in [1., 0.] (closest, farthest). */ + const float norm_dist_scaled = FSUB(1.f, norm_dist) / gamma * opacity; + PASSERT(norm_dist_scaled >= 0.f && norm_dist_scaled <= 1.f / gamma); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_DRAW_PIX, + "drawprep %u|intersection_depth: %.9f, norm_dist: %.9f, " + "norm_dist_scaled: %.9f.\n", + idx, + intersection_depth, + norm_dist, + norm_dist_scaled); + float const* const col_ptr = + cam.n_channels > 3 ? draw_info.color_union.ptr : &draw_info.first_color; + // The implementation for the numerically stable weighted softmax is based + // on https://arxiv.org/pdf/1805.02867.pdf . + if (draw_only) { + /** The old maximum observed value. */ + const float sm_m_old = *sm_m; + *sm_m = FMAX(*sm_m, norm_dist_scaled); + const float coeff_exp = FEXP(norm_dist_scaled - *sm_m); + PASSERT(isfinite(coeff_exp)); + /** The color coefficient for the ball color; in [0., 1.]. */ + const float coeff = closeness * coeff_exp * opacity; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_DRAW_PIX, + "draw %u|coeff: %.9f. closeness: %.9f. coeff_exp: %.9f. " + "opacity: %.9f.\n", + idx, + coeff, + closeness, + coeff_exp, + opacity); + // Rendering. + if (sm_m_old == *sm_m) { + // Use the fact that exp(0) = 1 to avoid the exp calculation for + // the case that the maximum remains the same (which it should + // most of the time). + *sm_d = FADD(*sm_d, coeff); + for (uint c_id = 0; c_id < cam.n_channels; ++c_id) { + PASSERT(isfinite(result[c_id])); + result[c_id] = FMA(coeff, col_ptr[c_id], result[c_id]); + } + } else { + const float exp_correction = FEXP(sm_m_old - *sm_m); + *sm_d = FMA(*sm_d, exp_correction, coeff); + for (uint c_id = 0; c_id < cam.n_channels; ++c_id) { + PASSERT(isfinite(result[c_id])); + result[c_id] = + FMA(coeff, col_ptr[c_id], FMUL(result[c_id], exp_correction)); + } + } + PASSERT(isfinite(*sm_d)); + *intersection_depth_norm_out = intersection_depth; + // Update the depth threshold. + *depth_threshold = + 1.f - (FLN(*sm_d + FEPS) + *ln_pad_over_1minuspad + *sm_m) * gamma; + *depth_threshold = + FMA(*depth_threshold, FSUB(cam.max_dist, cam.min_dist), cam.min_dist); + } else { + // Gradient computation. + const float coeff_exp = FEXP(norm_dist_scaled - *sm_m); + const float gamma_rcp = FRCP(gamma); + const float radius_sq = FMUL(draw_info.radius, draw_info.radius); + const float coeff = FMAX( + FMIN(closeness * coeff_exp * opacity, *sm_d - FEPS), + 0.f); // in [0., sm_d - FEPS]. + PASSERT(coeff >= 0.f && coeff <= *sm_d); + const float otherw = *sm_d - coeff; // in [FEPS, sm_d]. + const float p1__p2_safe = FMAX(p1__p2_, FEPS); // in [eps, t_center]. + const float cam_range = FSUB(cam.max_dist, cam.min_dist); // in ]0, inf[ + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|pos: %.9f, %.9f, %.9f. pixeldirx: %.9f, %.9f, %.9f. " + "pixeldiry: %.9f, %.9f, %.9f. pixel00center: %.9f, %.9f, %.9f.\n", + idx, + draw_info.ray_center_norm.x * draw_info.t_center, + draw_info.ray_center_norm.y * draw_info.t_center, + draw_info.ray_center_norm.z * draw_info.t_center, + cam.pixel_dir_x.x, + cam.pixel_dir_x.y, + cam.pixel_dir_x.z, + cam.pixel_dir_y.x, + cam.pixel_dir_y.y, + cam.pixel_dir_y.z, + cam.pixel_0_0_center.x, + cam.pixel_0_0_center.y, + cam.pixel_0_0_center.z); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|ray_dir: %.9f, %.9f, %.9f. " + "ray_dir_norm: %.9f, %.9f, %.9f. " + "draw_info.ray_center_norm: %.9f, %.9f, %.9f.\n", + idx, + ray_dir->x, + ray_dir->y, + ray_dir->z, + ray_dir_norm.x, + ray_dir_norm.y, + ray_dir_norm.z, + draw_info.ray_center_norm.x, + draw_info.ray_center_norm.y, + draw_info.ray_center_norm.z); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|coeff_exp: %.9f. " + "norm_dist_scaled: %.9f. cam.norm_fac: %f.\n", + idx, + coeff_exp, + norm_dist_scaled, + cam.norm_fac); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|p1__p2_: %.9f. p1__p2_safe: %.9f.\n", + idx, + p1__p2_, + p1__p2_safe); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|o__p1_: %.9f. c__p1_: %.9f.\n", + idx, + o__p1_, + c__p1_); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|intersection_depth: %f. norm_dist: %f. " + "coeff: %.9f. closeness: %f. coeff_exp: %f. opacity: " + "%f. color: %f, %f, %f.\n", + idx, + intersection_depth, + norm_dist, + coeff, + closeness, + coeff_exp, + opacity, + draw_info.first_color, + draw_info.color_union.color[0], + draw_info.color_union.color[1]); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|t_center: %.9f. " + "radius: %.9f. max_dist: %f. min_dist: %f. gamma: %f.\n", + idx, + draw_info.t_center, + draw_info.radius, + cam.max_dist, + cam.min_dist, + gamma); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|sm_d: %f. sm_m: %f. grad_pix (first three): %f, %f, %f.\n", + idx, + *sm_d, + *sm_m, + grad_pix[0], + grad_pix[1], + grad_pix[2]); + PULSAR_LOG_DEV_PIX(PULSAR_LOG_GRAD, "grad %u|otherw: %f.\n", idx, otherw); + if (calc_grad_col) { + const float sm_d_norm = FRCP(FMAX(*sm_d, FEPS)); + // First do the multiplication of coeff (in [0., sm_d]) and 1/sm_d. The + // result is a factor in [0., 1.] to be multiplied with the incoming + // gradient. + for (uint c_id = 0; c_id < cam.n_channels; ++c_id) { + ATOMICADD(grad_col + c_id, grad_pix[c_id] * FMUL(coeff, sm_d_norm)); + } + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdcol.x: %f. dresDdcol.x: %f.\n", + idx, + FMUL(coeff, sm_d_norm) * grad_pix[0], + coeff * sm_d_norm); + } + // We disable the computation for too small spheres. + // The comparison is made this way to avoid subtraction of unsigned types. + if (calc_grad_cam || calc_grad_pos || calc_grad_rad || calc_grad_opy) { + //! First find dimDdcoeff. + const float n0 = + otherw * FRCP(FMAX(*sm_d * *sm_d, FEPS)); // in [0., 1. / sm_d]. + PASSERT(isfinite(n0) && n0 >= 0. && n0 <= 1. / *sm_d + 1e2f * FEPS); + // We'll aggergate dimDdcoeff over all the 'color' channels. + float dimDdcoeff = 0.f; + const float otherw_safe_rcp = FRCP(FMAX(otherw, FEPS)); + float othercol; + for (uint c_id = 0; c_id < cam.n_channels; ++c_id) { + othercol = + (result[c_id] * *sm_d - col_ptr[c_id] * coeff) * otherw_safe_rcp; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|othercol[%u]: %.9f.\n", + idx, + c_id, + othercol); + dimDdcoeff += + FMUL(FMUL(grad_pix[c_id], FSUB(col_ptr[c_id], othercol)), n0); + } + PASSERT(isfinite(dimDdcoeff)); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdcoeff: %.9f, n0: %f.\n", + idx, + dimDdcoeff, + n0); + if (calc_grad_opy) { + //! dimDdopacity. + *grad_opy += dimDdcoeff * coeff_exp * closeness * + (1.f + opacity * (1.f - norm_dist) * gamma_rcp); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcoeffDdopacity: %.9f, dimDdopacity: %.9f.\n", + idx, + coeff_exp * closeness, + dimDdcoeff * coeff_exp * closeness); + } + if (intersect_info->max.x >= intersect_info->min.x + 3 && + intersect_info->max.y >= intersect_info->min.y + 3) { + //! Now find dcoeffDdintersection_depth and dcoeffDdcloseness. + const float dcoeffDdintersection_depth = + -closeness * coeff_exp * opacity * opacity / (gamma * cam_range); + const float dcoeffDdcloseness = coeff_exp * opacity; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcoeffDdintersection_depth: %.9f. " + "dimDdintersection_depth: %.9f. " + "dcoeffDdcloseness: %.9f. dimDdcloseness: %.9f.\n", + idx, + dcoeffDdintersection_depth, + dimDdcoeff * dcoeffDdintersection_depth, + dcoeffDdcloseness, + dimDdcoeff * dcoeffDdcloseness); + //! Here, the execution paths for orthogonal and pinyhole camera split. + if (cam.orthogonal_projection) { + if (calc_grad_rad) { + //! Find dcoeffDdrad. + float dcoeffDdrad = + dcoeffDdcloseness * (closeness_world / radius_sq) - + dcoeffDdintersection_depth * draw_info.radius / p1__p2_safe; + PASSERT(isfinite(dcoeffDdrad)); + *grad_rad += FMUL(dimDdcoeff, dcoeffDdrad); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdrad: %.9f. dcoeffDdrad: %.9f.\n", + idx, + FMUL(dimDdcoeff, dcoeffDdrad), + dcoeffDdrad); + } + if (calc_grad_pos || calc_grad_cam) { + float3 dimDdcenter = raydiff / + p1__p2_safe; /* making it dintersection_depthDdcenter. */ + dimDdcenter.z = sign_dir(center.z); + PASSERT(FABS(center.z) >= cam.min_dist && cam.min_dist >= FEPS); + dimDdcenter *= dcoeffDdintersection_depth; // dcoeffDdcenter + dimDdcenter -= dcoeffDdcloseness * /* dclosenessDdcenter. */ + raydiff * FRCP(FMAX(length(raydiff) * draw_info.radius, FEPS)); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcoeffDdcenter: %.9f, %.9f, %.9f.\n", + idx, + dimDdcenter.x, + dimDdcenter.y, + dimDdcenter.z); + // Now dcoeffDdcenter is stored in dimDdcenter. + dimDdcenter *= dimDdcoeff; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdcenter: %.9f, %.9f, %.9f.\n", + idx, + dimDdcenter.x, + dimDdcenter.y, + dimDdcenter.z); + // Prepare for posglob and cam pos. + const float pixel_size = length(cam.pixel_dir_x); + // pixel_size is the same as length(pixeldiry)! + const float pixel_size_rcp = FRCP(pixel_size); + float3 dcenterDdposglob = + (cam.pixel_dir_x + cam.pixel_dir_y) * pixel_size_rcp + + cam.sensor_dir_z; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcenterDdposglob: %.9f, %.9f, %.9f.\n", + idx, + dcenterDdposglob.x, + dcenterDdposglob.y, + dcenterDdposglob.z); + if (calc_grad_pos) { + //! dcenterDdposglob. + *grad_pos += dimDdcenter * dcenterDdposglob; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdpos: %.9f, %.9f, %.9f.\n", + idx, + dimDdcenter.x * dcenterDdposglob.x, + dimDdcenter.y * dcenterDdposglob.y, + dimDdcenter.z * dcenterDdposglob.z); + } + if (calc_grad_cam) { + //! Camera. + grad_cam->cam_pos -= dimDdcenter * dcenterDdposglob; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdeye: %.9f, %.9f, %.9f.\n", + idx, + -dimDdcenter.x * dcenterDdposglob.x, + -dimDdcenter.y * dcenterDdposglob.y, + -dimDdcenter.z * dcenterDdposglob.z); + // coord_world + /* + float3 dclosenessDdcoord_world = + raydiff * FRCP(FMAX(draw_info.radius * length(raydiff), FEPS)); + float3 dintersection_depthDdcoord_world = -2.f * raydiff; + */ + float3 dimDdcoord_world = /* dcoeffDdcoord_world */ + dcoeffDdcloseness * raydiff * + FRCP(FMAX(draw_info.radius * length(raydiff), FEPS)) - + dcoeffDdintersection_depth * raydiff / p1__p2_safe; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcoeffDdcoord_world: %.9f, %.9f, %.9f.\n", + idx, + dimDdcoord_world.x, + dimDdcoord_world.y, + dimDdcoord_world.z); + dimDdcoord_world *= dimDdcoeff; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdcoord_world: %.9f, %.9f, %.9f.\n", + idx, + dimDdcoord_world.x, + dimDdcoord_world.y, + dimDdcoord_world.z); + // The third component of dimDdcoord_world is 0! + PASSERT(dimDdcoord_world.z == 0.f); + float3 coord_world = center - raydiff; + coord_world.z = 0.f; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|coord_world: %.9f, %.9f, %.9f.\n", + idx, + coord_world.x, + coord_world.y, + coord_world.z); + // Do this component-wise to save unnecessary matmul steps. + grad_cam->pixel_dir_x += dimDdcoord_world.x * cam.pixel_dir_x * + coord_world.x * pixel_size_rcp * pixel_size_rcp; + grad_cam->pixel_dir_x += dimDdcoord_world.y * cam.pixel_dir_x * + coord_world.y * pixel_size_rcp * pixel_size_rcp; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdpixel_dir_x|coord_world: %.9f, %.9f, %.9f.\n", + idx, + grad_cam->pixel_dir_x.x, + grad_cam->pixel_dir_x.y, + grad_cam->pixel_dir_x.z); + // dcenterkDdpixel_dir_k. + float3 center_in_pixels = draw_info.ray_center_norm * + draw_info.t_center * pixel_size_rcp; + grad_cam->pixel_dir_x += dimDdcenter.x * + (center_in_pixels - + outer_product_sum(cam.pixel_dir_x) * center_in_pixels * + pixel_size_rcp * pixel_size_rcp); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcenter0dpixel_dir_x: %.9f, %.9f, %.9f.\n", + idx, + (center_in_pixels - + outer_product_sum(cam.pixel_dir_x) * center_in_pixels * + pixel_size_rcp * pixel_size_rcp) + .x, + (center_in_pixels - + outer_product_sum(cam.pixel_dir_x) * center_in_pixels * + pixel_size_rcp * pixel_size_rcp) + .y, + (center_in_pixels - + outer_product_sum(cam.pixel_dir_x) * center_in_pixels * + pixel_size_rcp * pixel_size_rcp) + .z); + grad_cam->pixel_dir_y += dimDdcenter.y * + (center_in_pixels - + outer_product_sum(cam.pixel_dir_y) * center_in_pixels * + pixel_size_rcp * pixel_size_rcp); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcenter1dpixel_dir_y: %.9f, %.9f, %.9f.\n", + idx, + (center_in_pixels - + outer_product_sum(cam.pixel_dir_y) * center_in_pixels * + pixel_size_rcp * pixel_size_rcp) + .x, + (center_in_pixels - + outer_product_sum(cam.pixel_dir_y) * center_in_pixels * + pixel_size_rcp * pixel_size_rcp) + .y, + (center_in_pixels - + outer_product_sum(cam.pixel_dir_y) * center_in_pixels * + pixel_size_rcp * pixel_size_rcp) + .z); + // dcenterzDdpixel_dir_k. + float sensordirz_norm_rcp = FRCP( + FMAX(length(cross(cam.pixel_dir_y, cam.pixel_dir_x)), FEPS)); + grad_cam->pixel_dir_x += dimDdcenter.z * + (dot(center, cam.sensor_dir_z) * + cross(cam.pixel_dir_y, cam.sensor_dir_z) - + cross(cam.pixel_dir_y, center)) * + sensordirz_norm_rcp; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcenterzDdpixel_dir_x: %.9f, %.9f, %.9f.\n", + idx, + ((dot(center, cam.sensor_dir_z) * + cross(cam.pixel_dir_y, cam.sensor_dir_z) - + cross(cam.pixel_dir_y, center)) * + sensordirz_norm_rcp) + .x, + ((dot(center, cam.sensor_dir_z) * + cross(cam.pixel_dir_y, cam.sensor_dir_z) - + cross(cam.pixel_dir_y, center)) * + sensordirz_norm_rcp) + .y, + ((dot(center, cam.sensor_dir_z) * + cross(cam.pixel_dir_y, cam.sensor_dir_z) - + cross(cam.pixel_dir_y, center)) * + sensordirz_norm_rcp) + .z); + grad_cam->pixel_dir_y += dimDdcenter.z * + (dot(center, cam.sensor_dir_z) * + cross(cam.pixel_dir_x, cam.sensor_dir_z) - + cross(cam.pixel_dir_x, center)) * + sensordirz_norm_rcp; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcenterzDdpixel_dir_y: %.9f, %.9f, %.9f.\n", + idx, + ((dot(center, cam.sensor_dir_z) * + cross(cam.pixel_dir_x, cam.sensor_dir_z) - + cross(cam.pixel_dir_x, center)) * + sensordirz_norm_rcp) + .x, + ((dot(center, cam.sensor_dir_z) * + cross(cam.pixel_dir_x, cam.sensor_dir_z) - + cross(cam.pixel_dir_x, center)) * + sensordirz_norm_rcp) + .y, + ((dot(center, cam.sensor_dir_z) * + cross(cam.pixel_dir_x, cam.sensor_dir_z) - + cross(cam.pixel_dir_x, center)) * + sensordirz_norm_rcp) + .z); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdpixel_dir_x: %.9f, %.9f, %.9f.\n", + idx, + grad_cam->pixel_dir_x.x, + grad_cam->pixel_dir_x.y, + grad_cam->pixel_dir_x.z); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdpixel_dir_y: %.9f, %.9f, %.9f.\n", + idx, + grad_cam->pixel_dir_y.x, + grad_cam->pixel_dir_y.y, + grad_cam->pixel_dir_y.z); + } + } + } else { + if (calc_grad_rad) { + //! Find dcoeffDdrad. + float dcoeffDdrad = + dcoeffDdcloseness * (closeness_world / radius_sq) - + dcoeffDdintersection_depth * draw_info.radius / p1__p2_safe; + PASSERT(isfinite(dcoeffDdrad)); + *grad_rad += FMUL(dimDdcoeff, dcoeffDdrad); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdrad: %.9f. dcoeffDdrad: %.9f.\n", + idx, + FMUL(dimDdcoeff, dcoeffDdrad), + dcoeffDdrad); + } + if (calc_grad_pos || calc_grad_cam) { + const float3 tmp1 = center - ray_dir_norm * o__p1_; + const float3 tmp1n = tmp1 / p1__p2_safe; + const float ray_dir_normDotRaydiff = dot(ray_dir_norm, raydiff); + const float3 dcoeffDdray = dcoeffDdintersection_depth * + (tmp1 - o__p1_ * tmp1n) / *norm_ray_dir + + dcoeffDdcloseness * + (ray_dir_norm * -ray_dir_normDotRaydiff + raydiff) / + (closeness_world * draw_info.radius) * + (draw_info.t_center / *norm_ray_dir); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcoeffDdray: %.9f, %.9f, %.9f. dimDdray: " + "%.9f, %.9f, %.9f.\n", + idx, + dcoeffDdray.x, + dcoeffDdray.y, + dcoeffDdray.z, + dimDdcoeff * dcoeffDdray.x, + dimDdcoeff * dcoeffDdray.y, + dimDdcoeff * dcoeffDdray.z); + const float3 dcoeffDdcenter = + dcoeffDdintersection_depth * (ray_dir_norm + tmp1n) + + dcoeffDdcloseness * + (draw_info.ray_center_norm * ray_dir_normDotRaydiff - + raydiff) / + (closeness_world * draw_info.radius); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dcoeffDdcenter: %.9f, %.9f, %.9f. " + "dimDdcenter: %.9f, %.9f, %.9f.\n", + idx, + dcoeffDdcenter.x, + dcoeffDdcenter.y, + dcoeffDdcenter.z, + dimDdcoeff * dcoeffDdcenter.x, + dimDdcoeff * dcoeffDdcenter.y, + dimDdcoeff * dcoeffDdcenter.z); + if (calc_grad_pos) { + *grad_pos += dimDdcoeff * dcoeffDdcenter; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdposglob: %.9f, %.9f, %.9f.\n", + idx, + dimDdcoeff * dcoeffDdcenter.x, + dimDdcoeff * dcoeffDdcenter.y, + dimDdcoeff * dcoeffDdcenter.z); + } + if (calc_grad_cam) { + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdeye: %.9f, %.9f, %.9f.\n", + idx, + -dimDdcoeff * (dcoeffDdcenter.x + dcoeffDdray.x), + -dimDdcoeff * (dcoeffDdcenter.y + dcoeffDdray.y), + -dimDdcoeff * (dcoeffDdcenter.z + dcoeffDdray.z)); + grad_cam->cam_pos += -dimDdcoeff * (dcoeffDdcenter + dcoeffDdray); + grad_cam->pixel_0_0_center += dimDdcoeff * dcoeffDdray; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdpixel00centerglob: %.9f, %.9f, %.9f.\n", + idx, + dimDdcoeff * dcoeffDdray.x, + dimDdcoeff * dcoeffDdray.y, + dimDdcoeff * dcoeffDdray.z); + grad_cam->pixel_dir_x += + (dimDdcoeff * static_cast(coord_x)) * dcoeffDdray; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdpixel_dir_x: %.9f, %.9f, %.9f.\n", + idx, + (dimDdcoeff * static_cast(coord_x)) * dcoeffDdray.x, + (dimDdcoeff * static_cast(coord_x)) * dcoeffDdray.y, + (dimDdcoeff * static_cast(coord_x)) * dcoeffDdray.z); + grad_cam->pixel_dir_y += + (dimDdcoeff * static_cast(coord_y)) * dcoeffDdray; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_GRAD, + "grad %u|dimDdpixel_dir_y: %.9f, %.9f, %.9f.\n", + idx, + (dimDdcoeff * static_cast(coord_y)) * dcoeffDdray.x, + (dimDdcoeff * static_cast(coord_y)) * dcoeffDdray.y, + (dimDdcoeff * static_cast(coord_y)) * dcoeffDdray.z); + } + } + } + } + } + } + return true; +}; + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.fill_bg.device.h b/pytorch3d/csrc/pulsar/include/renderer.fill_bg.device.h new file mode 100644 index 00000000..4137d2d1 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.fill_bg.device.h @@ -0,0 +1,55 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_FILL_BG_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_FILL_BG_DEVICE_H_ + +#include "../global.h" +#include "./camera.h" +#include "./commands.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +template +GLOBAL void fill_bg( + Renderer renderer, + const CamInfo cam, + float const* const bg_col_d, + const float gamma, + const uint mode) { + GET_PARALLEL_IDS_2D(coord_x, coord_y, cam.film_width, cam.film_height); + int write_loc = coord_y * cam.film_width * (3 + 2 * renderer.n_track) + + coord_x * (3 + 2 * renderer.n_track); + if (renderer.forw_info_d[write_loc + 1] // sm_d + == 0.f) { + // This location has not been processed yet. + // Write first the forw_info: + // sm_m + renderer.forw_info_d[write_loc] = + cam.background_normalization_depth / gamma; + // sm_d + renderer.forw_info_d[write_loc + 1] = 1.f; + // max_closest_possible_intersection_hit + renderer.forw_info_d[write_loc + 2] = -1.f; + // sphere IDs and intersection depths. + for (int i = 0; i < renderer.n_track; ++i) { + int sphere_id = -1; + IASF(sphere_id, renderer.forw_info_d[write_loc + 3 + i * 2]); + renderer.forw_info_d[write_loc + 3 + i * 2 + 1] = -1.f; + } + if (mode == 0) { + // Image background. + for (int i = 0; i < cam.n_channels; ++i) { + renderer.result_d + [coord_y * cam.film_width * cam.n_channels + + coord_x * cam.n_channels + i] = bg_col_d[i]; + } + } + } + END_PARALLEL_2D_NORET(); +}; + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.fill_bg.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.fill_bg.instantiate.h new file mode 100644 index 00000000..2b4e279d --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.fill_bg.instantiate.h @@ -0,0 +1,15 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./renderer.fill_bg.device.h" + +namespace pulsar { +namespace Renderer { + +template GLOBAL void fill_bg( + Renderer renderer, + const CamInfo norm, + float const* const bg_col_d, + const float gamma, + const uint mode); + +} // namespace Renderer +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/include/renderer.forward.device.h b/pytorch3d/csrc/pulsar/include/renderer.forward.device.h new file mode 100644 index 00000000..60f52850 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.forward.device.h @@ -0,0 +1,293 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_FORWARD_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_FORWARD_DEVICE_H_ + +#include "../global.h" +#include "./camera.device.h" +#include "./commands.h" +#include "./math.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +template +void forward( + Renderer* self, + const float* vert_pos, + const float* vert_col, + const float* vert_rad, + const CamInfo& cam, + const float& gamma, + float percent_allowed_difference, + const uint& max_n_hits, + const float* bg_col_d, + const float* opacity_d, + const size_t& num_balls, + const uint& mode, + cudaStream_t stream) { + ARGCHECK(gamma > 0.f && gamma <= 1.f, 6, "gamma must be in [0., 1.]"); + ARGCHECK( + percent_allowed_difference >= 0.f && percent_allowed_difference <= 1.f, + 7, + "percent_allowed_difference must be in [0., 1.]"); + ARGCHECK(max_n_hits >= 1u, 8, "max_n_hits must be >= 1"); + ARGCHECK( + num_balls > 0 && num_balls <= self->max_num_balls, + 9, + ("num_balls must be >0 and <= max num balls! (" + + std::to_string(num_balls) + " vs. " + + std::to_string(self->max_num_balls) + ")") + .c_str()); + ARGCHECK( + cam.film_width == self->cam.film_width && + cam.film_height == self->cam.film_height, + 5, + "cam result width and height must agree"); + ARGCHECK(mode <= 1, 10, "mode must be <= 1!"); + if (percent_allowed_difference > 1.f - FEPS) { + LOG(WARNING) << "percent_allowed_difference > " << (1.f - FEPS) + << "! Clamping to " << (1.f - FEPS) << "."; + percent_allowed_difference = 1.f - FEPS; + } + LOG_IF(INFO, PULSAR_LOG_RENDER) << "Rendering forward pass..."; + // Update camera and transform into a new virtual camera system with + // centered principal point and subsection rendering. + self->cam.eye = cam.eye; + self->cam.pixel_0_0_center = cam.pixel_0_0_center - cam.eye; + self->cam.pixel_dir_x = cam.pixel_dir_x; + self->cam.pixel_dir_y = cam.pixel_dir_y; + self->cam.sensor_dir_z = cam.sensor_dir_z; + self->cam.half_pixel_size = cam.half_pixel_size; + self->cam.focal_length = cam.focal_length; + self->cam.aperture_width = cam.aperture_width; + self->cam.aperture_height = cam.aperture_height; + self->cam.min_dist = cam.min_dist; + self->cam.max_dist = cam.max_dist; + self->cam.norm_fac = cam.norm_fac; + self->cam.principal_point_offset_x = cam.principal_point_offset_x; + self->cam.principal_point_offset_y = cam.principal_point_offset_y; + self->cam.film_border_left = cam.film_border_left; + self->cam.film_border_top = cam.film_border_top; +#ifdef PULSAR_TIMINGS_ENABLED + START_TIME(calc_signature); +#endif + LAUNCH_MAX_PARALLEL_1D( + calc_signature, + num_balls, + stream, + *self, + reinterpret_cast(vert_pos), + vert_col, + vert_rad, + num_balls); + CHECKLAUNCH(); +#ifdef PULSAR_TIMINGS_ENABLED + STOP_TIME(calc_signature); + START_TIME(sort); +#endif + SORT_ASCENDING_WS( + self->min_depth_d, + self->min_depth_sorted_d, + self->ids_d, + self->ids_sorted_d, + num_balls, + self->workspace_d, + self->workspace_size, + stream); + SORT_ASCENDING_WS( + self->min_depth_d, + self->min_depth_sorted_d, + self->ii_d, + self->ii_sorted_d, + num_balls, + self->workspace_d, + self->workspace_size, + stream); + SORT_ASCENDING_WS( + self->min_depth_d, + self->min_depth_sorted_d, + self->di_d, + self->di_sorted_d, + num_balls, + self->workspace_d, + self->workspace_size, + stream); + CHECKLAUNCH(); +#ifdef PULSAR_TIMINGS_ENABLED + STOP_TIME(sort); + START_TIME(minmax); +#endif + IntersectInfo pixel_minmax; + pixel_minmax.min.x = MAX_USHORT; + pixel_minmax.min.y = MAX_USHORT; + pixel_minmax.max.x = 0; + pixel_minmax.max.y = 0; + REDUCE_WS( + self->ii_sorted_d, + self->min_max_pixels_d, + num_balls, + IntersectInfoMinMax(), + pixel_minmax, + self->workspace_d, + self->workspace_size, + stream); + COPY_DEV_HOST(&pixel_minmax, self->min_max_pixels_d, IntersectInfo, 1); + LOG_IF(INFO, PULSAR_LOG_RENDER) + << "Region with pixels to render: " << pixel_minmax.min.x << ":" + << pixel_minmax.max.x << " (x), " << pixel_minmax.min.y << ":" + << pixel_minmax.max.y << " (y)."; +#ifdef PULSAR_TIMINGS_ENABLED + STOP_TIME(minmax); + START_TIME(render); +#endif + MEMSET( + self->result_d, + 0, + float, + self->cam.film_width * self->cam.film_height * self->cam.n_channels, + stream); + MEMSET( + self->forw_info_d, + 0, + float, + self->cam.film_width * self->cam.film_height * (3 + 2 * self->n_track), + stream); + if (pixel_minmax.max.y > pixel_minmax.min.y && + pixel_minmax.max.x > pixel_minmax.min.x) { + PASSERT( + pixel_minmax.min.x >= static_cast(self->cam.film_border_left) && + pixel_minmax.min.x < + static_cast( + self->cam.film_border_left + self->cam.film_width) && + pixel_minmax.max.x <= + static_cast( + self->cam.film_border_left + self->cam.film_width) && + pixel_minmax.min.y >= static_cast(self->cam.film_border_top) && + pixel_minmax.min.y < + static_cast( + self->cam.film_border_top + self->cam.film_height) && + pixel_minmax.max.y <= + static_cast( + self->cam.film_border_top + self->cam.film_height)); + // Cut the image in 3x3 regions. + int y_step = RENDER_BLOCK_SIZE * + iDivCeil(pixel_minmax.max.y - pixel_minmax.min.y, + 3u * RENDER_BLOCK_SIZE); + int x_step = RENDER_BLOCK_SIZE * + iDivCeil(pixel_minmax.max.x - pixel_minmax.min.x, + 3u * RENDER_BLOCK_SIZE); + LOG_IF(INFO, PULSAR_LOG_RENDER) << "Using image slices of size " << x_step + << ", " << y_step << " (W, H)."; + for (int y_min = pixel_minmax.min.y; y_min < pixel_minmax.max.y; + y_min += y_step) { + for (int x_min = pixel_minmax.min.x; x_min < pixel_minmax.max.x; + x_min += x_step) { + // Create region selection. + LAUNCH_MAX_PARALLEL_1D( + create_selector, + num_balls, + stream, + self->ii_sorted_d, + num_balls, + x_min, + x_min + x_step, + y_min, + y_min + y_step, + self->region_flags_d); + CHECKLAUNCH(); + SELECT_FLAGS_WS( + self->region_flags_d, + self->ii_sorted_d, + self->ii_d, + self->num_selected_d, + num_balls, + self->workspace_d, + self->workspace_size, + stream); + CHECKLAUNCH(); + SELECT_FLAGS_WS( + self->region_flags_d, + self->di_sorted_d, + self->di_d, + self->num_selected_d, + num_balls, + self->workspace_d, + self->workspace_size, + stream); + CHECKLAUNCH(); + SELECT_FLAGS_WS( + self->region_flags_d, + self->ids_sorted_d, + self->ids_d, + self->num_selected_d, + num_balls, + self->workspace_d, + self->workspace_size, + stream); + CHECKLAUNCH(); + LAUNCH_PARALLEL_2D( + render, + x_step, + y_step, + RENDER_BLOCK_SIZE, + RENDER_BLOCK_SIZE, + stream, + self->num_selected_d, + self->ii_d, + self->di_d, + self->min_depth_d, + self->ids_d, + opacity_d, + self->cam, + gamma, + percent_allowed_difference, + max_n_hits, + bg_col_d, + mode, + x_min, + y_min, + x_step, + y_step, + self->result_d, + self->forw_info_d, + self->n_track); + CHECKLAUNCH(); + } + } + } + if (mode == 0) { + LAUNCH_MAX_PARALLEL_2D( + fill_bg, + static_cast(self->cam.film_width), + static_cast(self->cam.film_height), + stream, + *self, + self->cam, + bg_col_d, + gamma, + mode); + CHECKLAUNCH(); + } +#ifdef PULSAR_TIMINGS_ENABLED + STOP_TIME(render); + float time_ms; + // This blocks the result and prevents batch-processing from parallelizing. + GET_TIME(calc_signature, &time_ms); + std::cout << "Time for signature calculation: " << time_ms << " ms" + << std::endl; + GET_TIME(sort, &time_ms); + std::cout << "Time for sorting: " << time_ms << " ms" << std::endl; + GET_TIME(minmax, &time_ms); + std::cout << "Time for minmax pixel calculation: " << time_ms << " ms" + << std::endl; + GET_TIME(render, &time_ms); + std::cout << "Time for rendering: " << time_ms << " ms" << std::endl; +#endif + LOG_IF(INFO, PULSAR_LOG_RENDER) << "Forward pass complete."; +} + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.forward.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.forward.instantiate.h new file mode 100644 index 00000000..31fae46b --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.forward.instantiate.h @@ -0,0 +1,23 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./renderer.forward.device.h" + +namespace pulsar { +namespace Renderer { + +template void forward( + Renderer* self, + const float* vert_pos, + const float* vert_col, + const float* vert_rad, + const CamInfo& cam, + const float& gamma, + float percent_allowed_difference, + const uint& max_n_hits, + const float* bg_col_d, + const float* opacity_d, + const size_t& num_balls, + const uint& mode, + cudaStream_t stream); + +} // namespace Renderer +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/include/renderer.get_screen_area.device.h b/pytorch3d/csrc/pulsar/include/renderer.get_screen_area.device.h new file mode 100644 index 00000000..e2b7f504 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.get_screen_area.device.h @@ -0,0 +1,137 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_GET_SCREEN_AREA_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_GET_SCREEN_AREA_DEVICE_H_ + +#include "../global.h" +#include "./camera.device.h" +#include "./commands.h" +#include "./math.h" + +namespace pulsar { +namespace Renderer { + +/** + * Find the closest enclosing screen area rectangle in pixels that encloses a + * ball. + * + * The method returns the two x and the two y values of the boundaries. They + * are not ordered yet and you need to find min and max for the left/right and + * lower/upper boundary. + * + * The return values are floats and need to be rounded appropriately. + */ +INLINE DEVICE bool get_screen_area( + const float3& ball_center_cam, + const float3& ray_center_norm, + const float& vert_rad, + const CamInfo& cam, + const uint& idx, + /* Out variables. */ + float* x_1, + float* x_2, + float* y_1, + float* y_2) { + float cos_alpha = dot(cam.sensor_dir_z, ray_center_norm); + float2 o__c_, alpha, theta; + if (cos_alpha < EPS) { + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|ball not visible. cos_alpha: %.9f.\n", + idx, + cos_alpha); + // No intersection, ball won't be visible. + return false; + } + // Multiply the direction vector with the camera rotation matrix + // to have the optical axis being the canonical z vector (0, 0, 1). + // TODO: optimize. + const float3 ball_center_cam_rot = rotate( + ball_center_cam, + cam.pixel_dir_x / length(cam.pixel_dir_x), + cam.pixel_dir_y / length(cam.pixel_dir_y), + cam.sensor_dir_z); + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|ball_center_cam_rot: %f, %f, %f.\n", + idx, + ball_center_cam.x, + ball_center_cam.y, + ball_center_cam.z); + const float pixel_size_norm_fac = FRCP(2.f * cam.half_pixel_size); + const float optical_offset_x = + (static_cast(cam.aperture_width) - 1.f) * .5f; + const float optical_offset_y = + (static_cast(cam.aperture_height) - 1.f) * .5f; + if (cam.orthogonal_projection) { + *x_1 = + FMA(ball_center_cam_rot.x - vert_rad, + pixel_size_norm_fac, + optical_offset_x); + *x_2 = + FMA(ball_center_cam_rot.x + vert_rad, + pixel_size_norm_fac, + optical_offset_x); + *y_1 = + FMA(ball_center_cam_rot.y - vert_rad, + pixel_size_norm_fac, + optical_offset_y); + *y_2 = + FMA(ball_center_cam_rot.y + vert_rad, + pixel_size_norm_fac, + optical_offset_y); + return true; + } else { + o__c_.x = FMAX( + FSQRT( + ball_center_cam_rot.x * ball_center_cam_rot.x + + ball_center_cam_rot.z * ball_center_cam_rot.z), + FEPS); + o__c_.y = FMAX( + FSQRT( + ball_center_cam_rot.y * ball_center_cam_rot.y + + ball_center_cam_rot.z * ball_center_cam_rot.z), + FEPS); + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|o__c_: %f, %f.\n", + idx, + o__c_.x, + o__c_.y); + alpha.x = sign_dir(ball_center_cam_rot.x) * + acos(FMIN(FMAX(ball_center_cam_rot.z / o__c_.x, -1.f), 1.f)); + alpha.y = -sign_dir(ball_center_cam_rot.y) * + acos(FMIN(FMAX(ball_center_cam_rot.z / o__c_.y, -1.f), 1.f)); + theta.x = asin(FMIN(FMAX(vert_rad / o__c_.x, -1.f), 1.f)); + theta.y = asin(FMIN(FMAX(vert_rad / o__c_.y, -1.f), 1.f)); + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|alpha.x: %f, alpha.y: %f, theta.x: %f, theta.y: %f.\n", + idx, + alpha.x, + alpha.y, + theta.x, + theta.y); + *x_1 = tan(alpha.x - theta.x) * cam.focal_length; + *x_2 = tan(alpha.x + theta.x) * cam.focal_length; + *y_1 = tan(alpha.y - theta.y) * cam.focal_length; + *y_2 = tan(alpha.y + theta.y) * cam.focal_length; + PULSAR_LOG_DEV( + PULSAR_LOG_CALC_SIGNATURE, + "signature %d|in sensor plane: x_1: %f, x_2: %f, y_1: %f, y_2: %f.\n", + idx, + *x_1, + *x_2, + *y_1, + *y_2); + *x_1 = FMA(*x_1, pixel_size_norm_fac, optical_offset_x); + *x_2 = FMA(*x_2, pixel_size_norm_fac, optical_offset_x); + *y_1 = FMA(*y_1, -pixel_size_norm_fac, optical_offset_y); + *y_2 = FMA(*y_2, -pixel_size_norm_fac, optical_offset_y); + return true; + } +}; + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.h b/pytorch3d/csrc/pulsar/include/renderer.h new file mode 100644 index 00000000..dfcfae53 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.h @@ -0,0 +1,461 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_H_ + +#include + +#include "../global.h" +#include "./camera.h" + +namespace pulsar { +namespace Renderer { + +//! Remember to order struct members from larger size to smaller size +//! to avoid padding (for more info, see for example here: +//! http://www.catb.org/esr/structure-packing/). + +/** + * This is the information that's needed to do a fast screen point + * intersection with one of the balls. + * + * Aim to keep this below 8 bytes (256 bytes per cache-line / 32 threads in a + * warp = 8 bytes per thread). + */ +struct IntersectInfo { + ushort2 min; /** minimum x, y in pixel coordinates. */ + ushort2 max; /** maximum x, y in pixel coordinates. */ +}; +static_assert( + sizeof(IntersectInfo) == 8, + "The compiled size of `IntersectInfo` is wrong."); + +/** + * Reduction operation to find the limits of multiple IntersectInfo objects. + */ +struct IntersectInfoMinMax { + IHD IntersectInfo + operator()(const IntersectInfo& a, const IntersectInfo& b) const { + // Treat the special case of an invalid intersect info object or one for + // a ball out of bounds. + if (b.max.x == MAX_USHORT && b.min.x == MAX_USHORT && + b.max.y == MAX_USHORT && b.min.y == MAX_USHORT) { + return a; + } + if (a.max.x == MAX_USHORT && a.min.x == MAX_USHORT && + a.max.y == MAX_USHORT && a.min.y == MAX_USHORT) { + return b; + } + IntersectInfo result; + result.min.x = std::min(a.min.x, b.min.x); + result.min.y = std::min(a.min.y, b.min.y); + result.max.x = std::max(a.max.x, b.max.x); + result.max.y = std::max(a.max.y, b.max.y); + return result; + } +}; + +/** + * All information that's needed to draw a ball. + * + * It's necessary to keep this information in float (not half) format, + * because the loss in accuracy would be too high and lead to artifacts. + */ +struct DrawInfo { + float3 ray_center_norm; /** Ray to the ball center, normalized. */ + /** Ball color. + * + * This might be the full color in the case of n_channels <= 3. Otherwise, + * a pointer to the original 'color' data is stored in the following union. + */ + float first_color; + union { + float color[2]; + float* ptr; + } color_union; + float t_center; /** Distance from the camera to the ball center. */ + float radius; /** Ball radius. */ +}; +static_assert( + sizeof(DrawInfo) == 8 * 4, + "The compiled size of `DrawInfo` is wrong."); + +/** + * An object to collect all associated data with the renderer. + * + * The `_d` suffixed pointers point to memory 'on-device', potentially on the + * GPU. All other variables are expected to point to CPU memory. + */ +struct Renderer { + /** Dummy initializer to make sure all pointers are set to NULL to + * be safe for the device-specific 'construct' and 'destruct' methods. + */ + inline Renderer() { + max_num_balls = 0; + result_d = NULL; + min_depth_d = NULL; + min_depth_sorted_d = NULL; + ii_d = NULL; + ii_sorted_d = NULL; + ids_d = NULL; + ids_sorted_d = NULL; + workspace_d = NULL; + di_d = NULL; + di_sorted_d = NULL; + region_flags_d = NULL; + num_selected_d = NULL; + forw_info_d = NULL; + grad_pos_d = NULL; + grad_col_d = NULL; + grad_rad_d = NULL; + grad_cam_d = NULL; + grad_opy_d = NULL; + grad_cam_buf_d = NULL; + n_grad_contributions_d = NULL; + }; + /** The camera for this renderer. In world-coordinates. */ + CamInfo cam; + /** + * The maximum amount of balls the renderer can handle. Resources are + * pre-allocated to account for this size. Less than this amount of balls + * can be rendered, but not more. + */ + int max_num_balls; + /** The result buffer. */ + float* result_d; + /** Closest possible intersection depth per sphere w.r.t. the camera. */ + float* min_depth_d; + /** Closest possible intersection depth per sphere, ordered ascending. */ + float* min_depth_sorted_d; + /** The intersect infos per sphere. */ + IntersectInfo* ii_d; + /** The intersect infos per sphere, ordered by their closest possible + * intersection depth (asc.). */ + IntersectInfo* ii_sorted_d; + /** Original sphere IDs. */ + int* ids_d; + /** Original sphere IDs, ordered by their closest possible intersection depth + * (asc.). */ + int* ids_sorted_d; + /** Workspace for CUB routines. */ + char* workspace_d; + /** Workspace size for CUB routines. */ + size_t workspace_size; + /** The draw information structures for each sphere. */ + DrawInfo* di_d; + /** The draw information structures sorted by closest possible intersection + * depth (asc.). */ + DrawInfo* di_sorted_d; + /** Region association buffer. */ + char* region_flags_d; + /** Num spheres in the current region. */ + size_t* num_selected_d; + /** Pointer to information from the forward pass. */ + float* forw_info_d; + /** Struct containing information about the min max pixels that contain + * rendered information in the image. */ + IntersectInfo* min_max_pixels_d; + /** Gradients w.r.t. position. */ + float3* grad_pos_d; + /** Gradients w.r.t. color. */ + float* grad_col_d; + /** Gradients w.r.t. radius. */ + float* grad_rad_d; + /** Gradients w.r.t. camera parameters. */ + float* grad_cam_d; + /** Gradients w.r.t. opacity. */ + float* grad_opy_d; + /** Camera gradient information by sphere. + * + * Here, every sphere's contribution to the camera gradients is stored. It is + * aggregated and written to grad_cam_d in a separate step. This avoids write + * conflicts when processing the spheres. + */ + CamGradInfo* grad_cam_buf_d; + /** Total of all gradient contributions for this image. */ + int* n_grad_contributions_d; + /** The number of spheres to track for backpropagation. */ + int n_track; +}; + +inline bool operator==(const Renderer& a, const Renderer& b) { + return a.cam == b.cam && a.max_num_balls == b.max_num_balls; +} + +/** + * Construct a renderer. + */ +template +void construct( + Renderer* self, + const size_t& max_num_balls, + const int& width, + const int& height, + const bool& orthogonal_projection, + const bool& right_handed_system, + const float& background_normalization_depth, + const uint& n_channels, + const uint& n_track); + +/** + * Destruct the renderer and free the associated memory. + */ +template +void destruct(Renderer* self); + +/** + * Create a selection of points inside a rectangle. + * + * This write boolen values into `region_flags_d', which can + * for example be used by a CUB function to extract the selection. + */ +template +GLOBAL void create_selector( + IntersectInfo const* const RESTRICT ii_sorted_d, + const uint num_balls, + const int min_x, + const int max_x, + const int min_y, + const int max_y, + /* Out variables. */ + char* RESTRICT region_flags_d); + +/** + * Calculate a signature for a ball. + * + * Populate the `ids_d`, `ii_d`, `di_d` and `min_depth_d` fields of the + * renderer. For spheres not visible in the image, sets the id field to -1, + * min_depth_d to MAX_FLOAT and the ii_d.min.x fields to MAX_USHORT. + */ +template +GLOBAL void calc_signature( + Renderer renderer, + float3 const* const RESTRICT vert_poss, + float const* const RESTRICT vert_cols, + float const* const RESTRICT vert_rads, + const uint num_balls); + +/** + * The block size for rendering. + * + * This should be as large as possible, but is limited due to the amount + * of variables we use and the memory required per thread. + */ +#define RENDER_BLOCK_SIZE 16 +/** + * The buffer size of spheres to be loaded and analyzed for relevance. + * + * This must be at least RENDER_BLOCK_SIZE * RENDER_BLOCK_SIZE so that + * for every iteration through the loading loop every thread could add a + * 'hit' to the buffer. + */ +#define RENDER_BUFFER_SIZE RENDER_BLOCK_SIZE* RENDER_BLOCK_SIZE * 2 +/** + * The threshold after which the spheres that are in the render buffer + * are rendered and the buffer is flushed. + * + * Must be less than RENDER_BUFFER_SIZE. + */ +#define RENDER_BUFFER_LOAD_THRESH 16 * 4 + +/** + * The render function. + * + * Assumptions: + * * the focal length is appropriately chosen, + * * ray_dir_norm.z is > EPS. + * * to be completed... + */ +template +GLOBAL void render( + size_t const* const RESTRICT + num_balls, /** Number of balls relevant for this pass. */ + IntersectInfo const* const RESTRICT ii_d, /** Intersect information. */ + DrawInfo const* const RESTRICT di_d, /** Draw information. */ + float const* const RESTRICT min_depth_d, /** Minimum depth per sphere. */ + int const* const RESTRICT id_d, /** IDs. */ + float const* const RESTRICT op_d, /** Opacity. */ + const CamInfo cam_norm, /** Camera normalized with all vectors to be in the + * camera coordinate system. + */ + const float gamma, /** Transparency parameter. **/ + const float percent_allowed_difference, /** Maximum allowed + error in color. */ + const uint max_n_hits, + const float* bg_col_d, + const uint mode, + const int x_min, + const int y_min, + const int x_step, + const int y_step, + // Out variables. + float* const RESTRICT result_d, /** The result image. */ + float* const RESTRICT forw_info_d, /** Additional information needed for the + grad computation. */ + // Infrastructure. + const int n_track /** The number of spheres to track. */ +); + +/** + * Makes sure to paint background information. + * + * This is required as a separate post-processing step because certain + * pixels may not be processed during the forward pass if there is no + * possibility for a sphere to be present at their location. + */ +template +GLOBAL void fill_bg( + Renderer renderer, + const CamInfo norm, + float const* const bg_col_d, + const float gamma, + const uint mode); + +/** + * Rendering forward pass. + * + * Takes a renderer and sphere data as inputs and creates a rendering. + */ +template +void forward( + Renderer* self, + const float* vert_pos, + const float* vert_col, + const float* vert_rad, + const CamInfo& cam, + const float& gamma, + float percent_allowed_difference, + const uint& max_n_hits, + const float* bg_col_d, + const float* opacity_d, + const size_t& num_balls, + const uint& mode, + cudaStream_t stream); + +/** + * Normalize the camera gradients by the number of spheres that contributed. + */ +template +GLOBAL void norm_cam_gradients(Renderer renderer); + +/** + * Normalize the sphere gradients. + * + * We're assuming that the samples originate from a Monte Carlo + * sampling process and normalize by number and sphere area. + */ +template +GLOBAL void norm_sphere_gradients(Renderer renderer, const int num_balls); + +#define GRAD_BLOCK_SIZE 16 +/** Calculate the gradients. + */ +template +GLOBAL void calc_gradients( + const CamInfo cam, /** Camera in world coordinates. */ + float const* const RESTRICT grad_im, /** The gradient image. */ + const float + gamma, /** The transparency parameter used in the forward pass. */ + float3 const* const RESTRICT vert_poss, /** Vertex position vector. */ + float const* const RESTRICT vert_cols, /** Vertex color vector. */ + float const* const RESTRICT vert_rads, /** Vertex radius vector. */ + float const* const RESTRICT opacity, /** Vertex opacity. */ + const uint num_balls, /** Number of balls. */ + float const* const RESTRICT result_d, /** Result image. */ + float const* const RESTRICT forw_info_d, /** Forward pass info. */ + DrawInfo const* const RESTRICT di_d, /** Draw information. */ + IntersectInfo const* const RESTRICT ii_d, /** Intersect information. */ + // Mode switches. + const bool calc_grad_pos, + const bool calc_grad_col, + const bool calc_grad_rad, + const bool calc_grad_cam, + const bool calc_grad_opy, + // Out variables. + float* const RESTRICT grad_rad_d, /** Radius gradients. */ + float* const RESTRICT grad_col_d, /** Color gradients. */ + float3* const RESTRICT grad_pos_d, /** Position gradients. */ + CamGradInfo* const RESTRICT grad_cam_buf_d, /** Camera gradient buffer. */ + float* const RESTRICT grad_opy_d, /** Opacity gradient buffer. */ + int* const RESTRICT + grad_contributed_d, /** Gradient contribution counter. */ + // Infrastructure. + const int n_track, + const uint offs_x = 0, + const uint offs_y = 0); + +/** + * A full backward pass. + * + * Creates the gradients for the given gradient_image and the spheres. + */ +template +void backward( + Renderer* self, + const float* grad_im, + const float* image, + const float* forw_info, + const float* vert_pos, + const float* vert_col, + const float* vert_rad, + const CamInfo& cam, + const float& gamma, + float percent_allowed_difference, + const uint& max_n_hits, + const float* vert_opy, + const size_t& num_balls, + const uint& mode, + const bool& dif_pos, + const bool& dif_col, + const bool& dif_rad, + const bool& dif_cam, + const bool& dif_opy, + cudaStream_t stream); + +/** + * A debug backward pass. + * + * This is a function to debug the gradient calculation. It calculates the + * gradients for exactly one pixel (set with pos_x and pos_y) without averaging. + * + * *Uses only the first sphere for camera gradient calculation!* + */ +template +void backward_dbg( + Renderer* self, + const float* grad_im, + const float* image, + const float* forw_info, + const float* vert_pos, + const float* vert_col, + const float* vert_rad, + const CamInfo& cam, + const float& gamma, + float percent_allowed_difference, + const uint& max_n_hits, + const float* vert_opy, + const size_t& num_balls, + const uint& mode, + const bool& dif_pos, + const bool& dif_col, + const bool& dif_rad, + const bool& dif_cam, + const bool& dif_opy, + const uint& pos_x, + const uint& pos_y, + cudaStream_t stream); + +template +void nn( + const float* ref_ptr, + const float* tar_ptr, + const uint& k, + const uint& d, + const uint& n, + float* dist_ptr, + int32_t* inds_ptr, + cudaStream_t stream); + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.norm_cam_gradients.device.h b/pytorch3d/csrc/pulsar/include/renderer.norm_cam_gradients.device.h new file mode 100644 index 00000000..14f6a21f --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.norm_cam_gradients.device.h @@ -0,0 +1,28 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_NORM_CAM_GRADIENTS_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_NORM_CAM_GRADIENTS_DEVICE_H_ + +#include "../global.h" +#include "./camera.device.h" +#include "./commands.h" +#include "./math.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +/** + * Normalize the camera gradients by the number of spheres that contributed. + */ +template +GLOBAL void norm_cam_gradients(Renderer renderer) { + GET_PARALLEL_IDX_1D(idx, 1); + CamGradInfo* cgi = reinterpret_cast(renderer.grad_cam_d); + *cgi = *cgi * FRCP(static_cast(*renderer.n_grad_contributions_d)); + END_PARALLEL_NORET(); +}; + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.norm_cam_gradients.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.norm_cam_gradients.instantiate.h new file mode 100644 index 00000000..77433245 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.norm_cam_gradients.instantiate.h @@ -0,0 +1,10 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./renderer.norm_cam_gradients.device.h" + +namespace pulsar { +namespace Renderer { + +template GLOBAL void norm_cam_gradients(Renderer renderer); + +} // namespace Renderer +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/include/renderer.norm_sphere_gradients.device.h b/pytorch3d/csrc/pulsar/include/renderer.norm_sphere_gradients.device.h new file mode 100644 index 00000000..1d68a303 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.norm_sphere_gradients.device.h @@ -0,0 +1,68 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_NORM_SPHERE_GRADIENTS_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_NORM_SPHERE_GRADIENTS_H_ + +#include "../global.h" +#include "./commands.h" +#include "./math.h" +#include "./renderer.h" + +namespace pulsar { +namespace Renderer { + +/** + * Normalize the sphere gradients. + * + * We're assuming that the samples originate from a Monte Carlo + * sampling process and normalize by number and sphere area. + */ +template +GLOBAL void norm_sphere_gradients(Renderer renderer, const int num_balls) { + GET_PARALLEL_IDX_1D(idx, num_balls); + float norm_fac = 0.f; + IntersectInfo ii; + if (renderer.ids_sorted_d[idx] > 0) { + ii = renderer.ii_d[idx]; + // Normalize the sphere gradients as averages. + // This avoids the case that there are small spheres in a scene with still + // un-converged colors whereas the big spheres already converged, just + // because their integrated learning rate is 'higher'. + norm_fac = FRCP(static_cast(renderer.ids_sorted_d[idx])); + } + PULSAR_LOG_DEV_NODE( + PULSAR_LOG_NORMALIZE, + "ids_sorted_d[idx]: %d, norm_fac: %.9f.\n", + renderer.ids_sorted_d[idx], + norm_fac); + renderer.grad_rad_d[idx] *= norm_fac; + for (uint c_idx = 0; c_idx < renderer.cam.n_channels; ++c_idx) { + renderer.grad_col_d[idx * renderer.cam.n_channels + c_idx] *= norm_fac; + } + renderer.grad_pos_d[idx] *= norm_fac; + renderer.grad_opy_d[idx] *= norm_fac; + + if (renderer.ids_sorted_d[idx] > 0) { + // For the camera, we need to be more correct and have the gradients + // be proportional to the area they cover in the image. + // This leads to a formulation very much like in monte carlo integration: + norm_fac = FRCP(static_cast(renderer.ids_sorted_d[idx])) * + (static_cast(ii.max.x) - static_cast(ii.min.x)) * + (static_cast(ii.max.y) - static_cast(ii.min.y)) * + 1e-3f; // for better numerics. + } + renderer.grad_cam_buf_d[idx].cam_pos *= norm_fac; + renderer.grad_cam_buf_d[idx].pixel_0_0_center *= norm_fac; + renderer.grad_cam_buf_d[idx].pixel_dir_x *= norm_fac; + renderer.grad_cam_buf_d[idx].pixel_dir_y *= norm_fac; + // The sphere only contributes to the camera gradients if it is + // large enough in screen space. + if (renderer.ids_sorted_d[idx] > 0 && ii.max.x >= ii.min.x + 3 && + ii.max.y >= ii.min.y + 3) + renderer.ids_sorted_d[idx] = 1; + END_PARALLEL_NORET(); +}; + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.norm_sphere_gradients.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.norm_sphere_gradients.instantiate.h new file mode 100644 index 00000000..2a48aa07 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.norm_sphere_gradients.instantiate.h @@ -0,0 +1,12 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./renderer.norm_sphere_gradients.device.h" + +namespace pulsar { +namespace Renderer { + +template GLOBAL void norm_sphere_gradients( + Renderer renderer, + const int num_balls); + +} // namespace Renderer +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/include/renderer.render.device.h b/pytorch3d/csrc/pulsar/include/renderer.render.device.h new file mode 100644 index 00000000..95adf9af --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.render.device.h @@ -0,0 +1,409 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_RENDER_DEVICE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_RENDER_DEVICE_H_ + +#include "../global.h" +#include "./camera.device.h" +#include "./commands.h" +#include "./math.h" +#include "./renderer.h" + +#include "./closest_sphere_tracker.device.h" +#include "./renderer.draw.device.h" + +namespace pulsar { +namespace Renderer { + +template +GLOBAL void render( + size_t const* const RESTRICT + num_balls, /** Number of balls relevant for this pass. */ + IntersectInfo const* const RESTRICT ii_d, /** Intersect information. */ + DrawInfo const* const RESTRICT di_d, /** Draw information. */ + float const* const RESTRICT min_depth_d, /** Minimum depth per sphere. */ + int const* const RESTRICT ids_d, /** IDs. */ + float const* const RESTRICT op_d, /** Opacity. */ + const CamInfo cam_norm, /** Camera normalized with all vectors to be in the + * camera coordinate system. + */ + const float gamma, /** Transparency parameter. **/ + const float percent_allowed_difference, /** Maximum allowed + error in color. */ + const uint max_n_hits, + const float* bg_col, + const uint mode, + const int x_min, + const int y_min, + const int x_step, + const int y_step, + // Out variables. + float* const RESTRICT result_d, /** The result image. */ + float* const RESTRICT forw_info_d, /** Additional information needed for the + grad computation. */ + const int n_track /** The number of spheres to track for backprop. */ +) { + // Do not early stop threads in this block here. They can all contribute to + // the scanning process, we just have to prevent from writing their result. + GET_PARALLEL_IDS_2D(offs_x, offs_y, x_step, y_step); + // Variable declarations and const initializations. + const float ln_pad_over_1minuspad = + FLN(percent_allowed_difference / (1.f - percent_allowed_difference)); + /** A facility to track the closest spheres to the camera + (in preparation for gradient calculation). */ + ClosestSphereTracker tracker(n_track); + const uint coord_x = x_min + offs_x; /** Ray coordinate x. */ + const uint coord_y = y_min + offs_y; /** Ray coordinate y. */ + float3 ray_dir_norm; /** Ray cast through the pixel, normalized. */ + float2 projected_ray; /** Ray intersection with the sensor. */ + if (cam_norm.orthogonal_projection) { + ray_dir_norm = cam_norm.sensor_dir_z; + projected_ray.x = static_cast(coord_x); + projected_ray.y = static_cast(coord_y); + } else { + ray_dir_norm = normalize( + cam_norm.pixel_0_0_center + coord_x * cam_norm.pixel_dir_x + + coord_y * cam_norm.pixel_dir_y); + // This is a reasonable assumption for normal focal lengths and image sizes. + PASSERT(FABS(ray_dir_norm.z) > FEPS); + projected_ray.x = ray_dir_norm.x / ray_dir_norm.z * cam_norm.focal_length; + projected_ray.y = ray_dir_norm.y / ray_dir_norm.z * cam_norm.focal_length; + } + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_RENDER_PIX, + "render|ray_dir_norm: %.9f, %.9f, %.9f. projected_ray: %.9f, %.9f.\n", + ray_dir_norm.x, + ray_dir_norm.y, + ray_dir_norm.z, + projected_ray.x, + projected_ray.y); + // Set up shared infrastructure. + /** This entire thread block. */ + cg::thread_block thread_block = cg::this_thread_block(); + /** The collaborators within a warp. */ + cg::coalesced_group thread_warp = cg::coalesced_threads(); + /** The number of loaded balls in the load buffer di_l. */ + SHARED uint n_loaded; + /** Draw information buffer. */ + SHARED DrawInfo di_l[RENDER_BUFFER_SIZE]; + /** The original sphere id of each loaded sphere. */ + SHARED uint sphere_id_l[RENDER_BUFFER_SIZE]; + /** The number of pixels in this block that are done. */ + SHARED int n_pixels_done; + /** Whether loading of balls is completed. */ + SHARED bool loading_done; + /** The number of balls loaded overall (just for statistics). */ + SHARED int n_balls_loaded; + /** The area this thread block covers. */ + SHARED IntersectInfo block_area; + if (thread_block.thread_rank() == 0) { + // Initialize the shared variables. + n_loaded = 0; + block_area.min.x = static_cast(coord_x); + block_area.max.x = static_cast(IMIN( + coord_x + blockDim.x, cam_norm.film_border_left + cam_norm.film_width)); + block_area.min.y = static_cast(coord_y); + block_area.max.y = static_cast(IMIN( + coord_y + blockDim.y, cam_norm.film_border_top + cam_norm.film_height)); + n_pixels_done = 0; + loading_done = false; + n_balls_loaded = 0; + } + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_RENDER_PIX, + "render|block_area.min: %d, %d. block_area.max: %d, %d.\n", + block_area.min.x, + block_area.min.y, + block_area.max.x, + block_area.max.y); + // Initialization of the pixel with the background color. + /** + * The result of this very pixel. + * the offset calculation might overflow if this thread is out of + * bounds of the film. However, in this case result is not + * accessed, so this is fine. + */ + float* result = result_d + + (coord_y - cam_norm.film_border_top) * cam_norm.film_width * + cam_norm.n_channels + + (coord_x - cam_norm.film_border_left) * cam_norm.n_channels; + if (coord_x >= cam_norm.film_border_left && + coord_x < cam_norm.film_border_left + cam_norm.film_width && + coord_y >= cam_norm.film_border_top && + coord_y < cam_norm.film_border_top + cam_norm.film_height) { + // Initialize the result. + if (mode == 0u) { + for (uint c_id = 0; c_id < cam_norm.n_channels; ++c_id) + result[c_id] = bg_col[c_id]; + } else { + result[0] = 0.f; + } + } + /** Normalization denominator. */ + float sm_d = 1.f; + /** Normalization tracker for stable softmax. The maximum observed value. */ + float sm_m = cam_norm.background_normalization_depth / gamma; + /** Whether this pixel has had all information needed for drawing. */ + bool done = + (coord_x < cam_norm.film_border_left || + coord_x >= cam_norm.film_border_left + cam_norm.film_width || + coord_y < cam_norm.film_border_top || + coord_y >= cam_norm.film_border_top + cam_norm.film_height); + /** The depth threshold for a new point to have at least + * `percent_allowed_difference` influence on the result color. All points that + * are further away than this are ignored. + */ + float depth_threshold = done ? -1.f : MAX_FLOAT; + /** The closest intersection possible of a ball that was hit by this pixel + * ray. */ + float max_closest_possible_intersection_hit = -1.f; + bool hit; /** Whether a sphere was hit. */ + float intersection_depth; /** The intersection_depth for a sphere at this + pixel. */ + float closest_possible_intersection; /** The closest possible intersection + for this sphere. */ + float max_closest_possible_intersection; + // Sync up threads so that everyone is similarly initialized. + thread_block.sync(); + //! Coalesced loading and intersection analysis of balls. + for (uint ball_idx = thread_block.thread_rank(); + ball_idx < iDivCeil(static_cast(*num_balls), thread_block.size()) * + thread_block.size() && + !loading_done && n_pixels_done < thread_block.size(); + ball_idx += thread_block.size()) { + if (ball_idx < static_cast(*num_balls)) { // Account for overflow. + const IntersectInfo& ii = ii_d[ball_idx]; + hit = (ii.min.x <= block_area.max.x) && (ii.max.x > block_area.min.x) && + (ii.min.y <= block_area.max.y) && (ii.max.y > block_area.min.y); + if (hit) { + uint write_idx = ATOMICADD_B(&n_loaded, 1u); + di_l[write_idx] = di_d[ball_idx]; + sphere_id_l[write_idx] = static_cast(ids_d[ball_idx]); + PULSAR_LOG_DEV_PIXB( + PULSAR_LOG_RENDER_PIX, + "render|found intersection with sphere %u.\n", + sphere_id_l[write_idx]); + } + if (ii.min.x == MAX_USHORT) + // This is an invalid sphere (out of image). These spheres have + // maximum depth. Since we ordered the spheres by earliest possible + // intersection depth we re certain that there will no other sphere + // that is relevant after this one. + loading_done = true; + } + // Reset n_pixels_done. + n_pixels_done = 0; + thread_block.sync(); // Make sure n_loaded is updated. + if (n_loaded > RENDER_BUFFER_LOAD_THRESH) { + // The load buffer is full enough. Draw. + if (thread_block.thread_rank() == 0) + n_balls_loaded += n_loaded; + max_closest_possible_intersection = 0.f; + // This excludes threads outside of the image boundary. Also, it reduces + // block artifacts. + if (!done) { + for (uint draw_idx = 0; draw_idx < n_loaded; ++draw_idx) { + intersection_depth = 0.f; + if (cam_norm.orthogonal_projection) { + // The closest possible intersection is the distance to the camera + // plane. + closest_possible_intersection = min_depth_d[sphere_id_l[draw_idx]]; + } else { + closest_possible_intersection = + di_l[draw_idx].t_center - di_l[draw_idx].radius; + } + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_RENDER_PIX, + "render|drawing sphere %u (depth: %f, " + "closest possible intersection: %f).\n", + sphere_id_l[draw_idx], + di_l[draw_idx].t_center, + closest_possible_intersection); + hit = draw( + di_l[draw_idx], // Sphere to draw. + op_d == NULL ? 1.f : op_d[sphere_id_l[draw_idx]], // Opacity. + cam_norm, // Cam. + gamma, // Gamma. + ray_dir_norm, // Ray direction. + projected_ray, // Ray intersection with the image. + // Mode switches. + true, // Draw. + false, + false, + false, + false, + false, // No gradients. + // Position info. + coord_x, + coord_y, + sphere_id_l[draw_idx], + // Optional in variables. + NULL, // intersect information. + NULL, // ray_dir. + NULL, // norm_ray_dir. + NULL, // grad_pix. + &ln_pad_over_1minuspad, + // in/out variables + &sm_d, + &sm_m, + result, + // Optional out. + &depth_threshold, + &intersection_depth, + NULL, + NULL, + NULL, + NULL, + NULL // gradients. + ); + if (hit) { + max_closest_possible_intersection_hit = FMAX( + max_closest_possible_intersection_hit, + closest_possible_intersection); + tracker.track( + sphere_id_l[draw_idx], intersection_depth, coord_x, coord_y); + } + max_closest_possible_intersection = FMAX( + max_closest_possible_intersection, closest_possible_intersection); + } + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_RENDER_PIX, + "render|max_closest_possible_intersection: %f, " + "depth_threshold: %f.\n", + max_closest_possible_intersection, + depth_threshold); + } + done = done || + (percent_allowed_difference > 0.f && + max_closest_possible_intersection > depth_threshold) || + tracker.get_n_hits() >= max_n_hits; + uint warp_done = thread_warp.ballot(done); + if (thread_warp.thread_rank() == 0) + ATOMICADD_B(&n_pixels_done, POPC(warp_done)); + // This sync is necessary to keep n_loaded until all threads are done with + // painting. + thread_block.sync(); + n_loaded = 0; + } + thread_block.sync(); + } + if (thread_block.thread_rank() == 0) + n_balls_loaded += n_loaded; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_RENDER_PIX, + "render|loaded %d balls in total.\n", + n_balls_loaded); + if (!done) { + for (uint draw_idx = 0; draw_idx < n_loaded; ++draw_idx) { + intersection_depth = 0.f; + if (cam_norm.orthogonal_projection) { + // The closest possible intersection is the distance to the camera + // plane. + closest_possible_intersection = min_depth_d[sphere_id_l[draw_idx]]; + } else { + closest_possible_intersection = + di_l[draw_idx].t_center - di_l[draw_idx].radius; + } + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_RENDER_PIX, + "render|drawing sphere %u (depth: %f, " + "closest possible intersection: %f).\n", + sphere_id_l[draw_idx], + di_l[draw_idx].t_center, + closest_possible_intersection); + hit = draw( + di_l[draw_idx], // Sphere to draw. + op_d == NULL ? 1.f : op_d[sphere_id_l[draw_idx]], // Opacity. + cam_norm, // Cam. + gamma, // Gamma. + ray_dir_norm, // Ray direction. + projected_ray, // Ray intersection with the image. + // Mode switches. + true, // Draw. + false, + false, + false, + false, + false, // No gradients. + // Logging info. + coord_x, + coord_y, + sphere_id_l[draw_idx], + // Optional in variables. + NULL, // intersect information. + NULL, // ray_dir. + NULL, // norm_ray_dir. + NULL, // grad_pix. + &ln_pad_over_1minuspad, + // in/out variables + &sm_d, + &sm_m, + result, + // Optional out. + &depth_threshold, + &intersection_depth, + NULL, + NULL, + NULL, + NULL, + NULL // gradients. + ); + if (hit) { + max_closest_possible_intersection_hit = FMAX( + max_closest_possible_intersection_hit, + closest_possible_intersection); + tracker.track( + sphere_id_l[draw_idx], intersection_depth, coord_x, coord_y); + } + } + } + if (coord_x < cam_norm.film_border_left || + coord_y < cam_norm.film_border_top || + coord_x >= cam_norm.film_border_left + cam_norm.film_width || + coord_y >= cam_norm.film_border_top + cam_norm.film_height) { + RETURN_PARALLEL(); + } + if (mode == 1u) { + // The subtractions, for example coord_y - cam_norm.film_border_left, are + // safe even though both components are uints. We checked their relation + // just above. + result_d + [(coord_y - cam_norm.film_border_top) * cam_norm.film_width * + cam_norm.n_channels + + (coord_x - cam_norm.film_border_left) * cam_norm.n_channels] = + static_cast(tracker.get_n_hits()); + } else { + float sm_d_normfac = FRCP(FMAX(sm_d, FEPS)); + for (uint c_id = 0; c_id < cam_norm.n_channels; ++c_id) + result[c_id] *= sm_d_normfac; + int write_loc = (coord_y - cam_norm.film_border_top) * cam_norm.film_width * + (3 + 2 * n_track) + + (coord_x - cam_norm.film_border_left) * (3 + 2 * n_track); + forw_info_d[write_loc] = sm_m; + forw_info_d[write_loc + 1] = sm_d; + forw_info_d[write_loc + 2] = max_closest_possible_intersection_hit; + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_RENDER_PIX, + "render|writing the %d most important ball infos.\n", + IMIN(n_track, tracker.get_n_hits())); + for (int i = 0; i < n_track; ++i) { + int sphere_id = tracker.get_closest_sphere_id(i); + IASF(sphere_id, forw_info_d[write_loc + 3 + i * 2]); + forw_info_d[write_loc + 3 + i * 2 + 1] = + tracker.get_closest_sphere_depth(i) == MAX_FLOAT + ? -1.f + : tracker.get_closest_sphere_depth(i); + PULSAR_LOG_DEV_PIX( + PULSAR_LOG_RENDER_PIX, + "render|writing %d most important: id: %d, normalized depth: %f.\n", + i, + tracker.get_closest_sphere_id(i), + tracker.get_closest_sphere_depth(i)); + } + } + END_PARALLEL_2D(); +} + +} // namespace Renderer +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/include/renderer.render.instantiate.h b/pytorch3d/csrc/pulsar/include/renderer.render.instantiate.h new file mode 100644 index 00000000..3379bae4 --- /dev/null +++ b/pytorch3d/csrc/pulsar/include/renderer.render.instantiate.h @@ -0,0 +1,39 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_INCLUDE_RENDERER_RENDER_INSTANTIATE_H_ +#define PULSAR_NATIVE_INCLUDE_RENDERER_RENDER_INSTANTIATE_H_ + +#include "./renderer.render.device.h" + +namespace pulsar { +namespace Renderer { +template GLOBAL void render( + size_t const* const RESTRICT + num_balls, /** Number of balls relevant for this pass. */ + IntersectInfo const* const RESTRICT ii_d, /** Intersect information. */ + DrawInfo const* const RESTRICT di_d, /** Draw information. */ + float const* const RESTRICT min_depth_d, /** Minimum depth per sphere. */ + int const* const RESTRICT id_d, /** IDs. */ + float const* const RESTRICT op_d, /** Opacity. */ + const CamInfo cam_norm, /** Camera normalized with all vectors to be in the + * camera coordinate system. + */ + const float gamma, /** Transparency parameter. **/ + const float percent_allowed_difference, /** Maximum allowed + error in color. */ + const uint max_n_hits, + const float* bg_col_d, + const uint mode, + const int x_min, + const int y_min, + const int x_step, + const int y_step, + // Out variables. + float* const RESTRICT result_d, /** The result image. */ + float* const RESTRICT forw_info_d, /** Additional information needed for the + grad computation. */ + const int n_track /** The number of spheres to track for backprop. */ +); +} +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/logging.h b/pytorch3d/csrc/pulsar/logging.h new file mode 100644 index 00000000..977e0c9d --- /dev/null +++ b/pytorch3d/csrc/pulsar/logging.h @@ -0,0 +1,108 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_LOGGING_H_ +#define PULSAR_LOGGING_H_ + +// #define PULSAR_LOGGING_ENABLED +/** + * Enable detailed per-operation timings. + * + * This timing scheme is not appropriate to measure batched calculations. + * Use `PULSAR_TIMINGS_BATCHED_ENABLED` for that. + */ +// #define PULSAR_TIMINGS_ENABLED +/** + * Time batched operations. + */ +// #define PULSAR_TIMINGS_BATCHED_ENABLED +#if defined(PULSAR_TIMINGS_BATCHED_ENABLED) && defined(PULSAR_TIMINGS_ENABLED) +#pragma message("Pulsar|batched and unbatched timings enabled. This will not") +#pragma message("Pulsar|create meaningful results.") +#endif + +#ifdef PULSAR_LOGGING_ENABLED + +// Control logging. +// 0: INFO, 1: WARNING, 2: ERROR, 3: FATAL (Abort after logging). +#define CAFFE2_LOG_THRESHOLD 0 +#define PULSAR_LOG_INIT false +#define PULSAR_LOG_FORWARD false +#define PULSAR_LOG_CALC_SIGNATURE false +#define PULSAR_LOG_RENDER false +#define PULSAR_LOG_RENDER_PIX false +#define PULSAR_LOG_RENDER_PIX_X 428 +#define PULSAR_LOG_RENDER_PIX_Y 669 +#define PULSAR_LOG_RENDER_PIX_ALL false +#define PULSAR_LOG_TRACKER_PIX false +#define PULSAR_LOG_TRACKER_PIX_X 428 +#define PULSAR_LOG_TRACKER_PIX_Y 669 +#define PULSAR_LOG_TRACKER_PIX_ALL false +#define PULSAR_LOG_DRAW_PIX false +#define PULSAR_LOG_DRAW_PIX_X 428 +#define PULSAR_LOG_DRAW_PIX_Y 669 +#define PULSAR_LOG_DRAW_PIX_ALL false +#define PULSAR_LOG_BACKWARD false +#define PULSAR_LOG_GRAD false +#define PULSAR_LOG_GRAD_X 509 +#define PULSAR_LOG_GRAD_Y 489 +#define PULSAR_LOG_GRAD_ALL false +#define PULSAR_LOG_NORMALIZE false +#define PULSAR_LOG_NORMALIZE_X 0 +#define PULSAR_LOG_NORMALIZE_ALL false + +#define PULSAR_LOG_DEV(ID, ...) \ + if ((ID)) { \ + printf(__VA_ARGS__); \ + } +#define PULSAR_LOG_DEV_APIX(ID, MSG, ...) \ + if ((ID) && (film_coord_x == (ID##_X) && film_coord_y == (ID##_Y)) || \ + ID##_ALL) { \ + printf( \ + "%u %u (ap %u %u)|" MSG, \ + film_coord_x, \ + film_coord_y, \ + ap_coord_x, \ + ap_coord_y, \ + __VA_ARGS__); \ + } +#define PULSAR_LOG_DEV_PIX(ID, MSG, ...) \ + if ((ID) && (coord_x == (ID##_X) && coord_y == (ID##_Y)) || ID##_ALL) { \ + printf("%u %u|" MSG, coord_x, coord_y, __VA_ARGS__); \ + } +#ifdef __CUDACC__ +#define PULSAR_LOG_DEV_PIXB(ID, MSG, ...) \ + if ((ID) && static_cast(block_area.min.x) <= (ID##_X) && \ + static_cast(block_area.max.x) > (ID##_X) && \ + static_cast(block_area.min.y) <= (ID##_Y) && \ + static_cast(block_area.max.y) > (ID##_Y)) { \ + printf("%u %u|" MSG, coord_x, coord_y, __VA_ARGS__); \ + } +#else +#define PULSAR_LOG_DEV_PIXB(ID, MSG, ...) \ + if ((ID) && coord_x == (ID##_X) && coord_y == (ID##_Y)) { \ + printf("%u %u|" MSG, coord_x, coord_y, __VA_ARGS__); \ + } +#endif +#define PULSAR_LOG_DEV_NODE(ID, MSG, ...) \ + if ((ID) && idx == (ID##_X) || (ID##_ALL)) { \ + printf("%u|" MSG, idx, __VA_ARGS__); \ + } + +#else + +#define CAFFE2_LOG_THRESHOLD 2 + +#define PULSAR_LOG_RENDER false +#define PULSAR_LOG_INIT false +#define PULSAR_LOG_FORWARD false +#define PULSAR_LOG_BACKWARD false +#define PULSAR_LOG_TRACKER_PIX false + +#define PULSAR_LOG_DEV(...) +#define PULSAR_LOG_DEV_APIX(...) +#define PULSAR_LOG_DEV_PIX(...) +#define PULSAR_LOG_DEV_PIXB(...) +#define PULSAR_LOG_DEV_NODE(...) + +#endif + +#endif diff --git a/pytorch3d/csrc/pulsar/pytorch/camera.cpp b/pytorch3d/csrc/pulsar/pytorch/camera.cpp new file mode 100644 index 00000000..3f1cfca4 --- /dev/null +++ b/pytorch3d/csrc/pulsar/pytorch/camera.cpp @@ -0,0 +1,63 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./camera.h" +#include "../include/math.h" + +namespace pulsar { +namespace pytorch { + +CamInfo cam_info_from_params( + const torch::Tensor& cam_pos, + const torch::Tensor& pixel_0_0_center, + const torch::Tensor& pixel_vec_x, + const torch::Tensor& pixel_vec_y, + const torch::Tensor& principal_point_offset, + const float& focal_length, + const uint& width, + const uint& height, + const float& min_dist, + const float& max_dist, + const bool& right_handed) { + CamInfo res; + fill_cam_vecs( + cam_pos.detach().cpu(), + pixel_0_0_center.detach().cpu(), + pixel_vec_x.detach().cpu(), + pixel_vec_y.detach().cpu(), + principal_point_offset.detach().cpu(), + right_handed, + &res); + res.half_pixel_size = 0.5f * length(res.pixel_dir_x); + if (length(res.pixel_dir_y) * 0.5f - res.half_pixel_size > EPS) { + throw std::runtime_error("Pixel sizes must agree in x and y direction!"); + } + res.focal_length = focal_length; + res.aperture_width = + width + 2u * static_cast(abs(res.principal_point_offset_x)); + res.aperture_height = + height + 2u * static_cast(abs(res.principal_point_offset_y)); + res.pixel_0_0_center -= + res.pixel_dir_x * static_cast(abs(res.principal_point_offset_x)); + res.pixel_0_0_center -= + res.pixel_dir_y * static_cast(abs(res.principal_point_offset_y)); + res.film_width = width; + res.film_height = height; + res.film_border_left = + static_cast(std::max(0, 2 * res.principal_point_offset_x)); + res.film_border_top = + static_cast(std::max(0, 2 * res.principal_point_offset_y)); + LOG_IF(INFO, PULSAR_LOG_INIT) + << "Aperture width, height: " << res.aperture_width << ", " + << res.aperture_height; + LOG_IF(INFO, PULSAR_LOG_INIT) + << "Film width, height: " << res.film_width << ", " << res.film_height; + LOG_IF(INFO, PULSAR_LOG_INIT) + << "Film border left, top: " << res.film_border_left << ", " + << res.film_border_top; + res.min_dist = min_dist; + res.max_dist = max_dist; + res.norm_fac = 1.f / (max_dist - min_dist); + return res; +}; + +} // namespace pytorch +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/pytorch/camera.h b/pytorch3d/csrc/pulsar/pytorch/camera.h new file mode 100644 index 00000000..f7312364 --- /dev/null +++ b/pytorch3d/csrc/pulsar/pytorch/camera.h @@ -0,0 +1,61 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_CAMERA_H_ +#define PULSAR_NATIVE_CAMERA_H_ + +#include +#include "../global.h" + +#include "../include/camera.h" + +namespace pulsar { +namespace pytorch { + +inline void fill_cam_vecs( + const torch::Tensor& pos_vec, + const torch::Tensor& pixel_0_0_center, + const torch::Tensor& pixel_dir_x, + const torch::Tensor& pixel_dir_y, + const torch::Tensor& principal_point_offset, + const bool& right_handed, + CamInfo* res) { + res->eye.x = pos_vec.data_ptr()[0]; + res->eye.y = pos_vec.data_ptr()[1]; + res->eye.z = pos_vec.data_ptr()[2]; + res->pixel_0_0_center.x = pixel_0_0_center.data_ptr()[0]; + res->pixel_0_0_center.y = pixel_0_0_center.data_ptr()[1]; + res->pixel_0_0_center.z = pixel_0_0_center.data_ptr()[2]; + res->pixel_dir_x.x = pixel_dir_x.data_ptr()[0]; + res->pixel_dir_x.y = pixel_dir_x.data_ptr()[1]; + res->pixel_dir_x.z = pixel_dir_x.data_ptr()[2]; + res->pixel_dir_y.x = pixel_dir_y.data_ptr()[0]; + res->pixel_dir_y.y = pixel_dir_y.data_ptr()[1]; + res->pixel_dir_y.z = pixel_dir_y.data_ptr()[2]; + auto sensor_dir_z = pixel_dir_y.cross(pixel_dir_x); + sensor_dir_z /= sensor_dir_z.norm(); + if (right_handed) { + sensor_dir_z *= -1.f; + } + res->sensor_dir_z.x = sensor_dir_z.data_ptr()[0]; + res->sensor_dir_z.y = sensor_dir_z.data_ptr()[1]; + res->sensor_dir_z.z = sensor_dir_z.data_ptr()[2]; + res->principal_point_offset_x = principal_point_offset.data_ptr()[0]; + res->principal_point_offset_y = principal_point_offset.data_ptr()[1]; +} + +CamInfo cam_info_from_params( + const torch::Tensor& cam_pos, + const torch::Tensor& pixel_0_0_center, + const torch::Tensor& pixel_vec_x, + const torch::Tensor& pixel_vec_y, + const torch::Tensor& principal_point_offset, + const float& focal_length, + const uint& width, + const uint& height, + const float& min_dist, + const float& max_dist, + const bool& right_handed); + +} // namespace pytorch +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/pytorch/renderer.cpp b/pytorch3d/csrc/pulsar/pytorch/renderer.cpp new file mode 100644 index 00000000..b44f6dc5 --- /dev/null +++ b/pytorch3d/csrc/pulsar/pytorch/renderer.cpp @@ -0,0 +1,1481 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./renderer.h" +#include "../include/commands.h" +#include "./camera.h" +#include "./util.h" + +#include +#include +#include + +namespace PRE = ::pulsar::Renderer; + +namespace pulsar { +namespace pytorch { + +Renderer::Renderer( + const unsigned int& width, + const unsigned int& height, + const unsigned int& max_n_balls, + const bool& orthogonal_projection, + const bool& right_handed_system, + const float& background_normalization_depth, + const uint& n_channels, + const uint& n_track) { + LOG_IF(INFO, PULSAR_LOG_INIT) << "Initializing renderer."; + THArgCheck(width > 0, 1, "image width must be > 0!"); + THArgCheck(height > 0, 2, "image height must be > 0!"); + THArgCheck(max_n_balls > 0, 3, "max_n_balls must be > 0!"); + THArgCheck( + background_normalization_depth > 0.f && + background_normalization_depth < 1.f, + 5, + "background_normalization_depth must be in ]0., 1.["); + THArgCheck(n_channels > 0, 6, "n_channels must be > 0"); + THArgCheck( + n_track > 0 && n_track <= MAX_GRAD_SPHERES, + 7, + ("n_track must be > 0 and <" + std::to_string(MAX_GRAD_SPHERES) + + ". Is " + std::to_string(n_track) + ".") + .c_str()); + LOG_IF(INFO, PULSAR_LOG_INIT) + << "Image width: " << width << ", height: " << height; + this->renderer_vec.emplace_back(); + this->device_type = c10::DeviceType::CPU; + this->device_index = -1; + PRE::construct( + this->renderer_vec.data(), + max_n_balls, + width, + height, + orthogonal_projection, + right_handed_system, + background_normalization_depth, + n_channels, + n_track); + this->device_tracker = torch::zeros(1); +}; + +Renderer::~Renderer() { + if (this->device_type == c10::DeviceType::CUDA) { + at::cuda::CUDAGuard device_guard(this->device_tracker.device()); + for (auto nrend : this->renderer_vec) { + PRE::destruct(&nrend); + } + } else { + for (auto nrend : this->renderer_vec) { + PRE::destruct(&nrend); + } + } +} + +bool Renderer::operator==(const Renderer& rhs) const { + LOG_IF(INFO, PULSAR_LOG_INIT) << "Equality check."; + bool renderer_agrees = (this->renderer_vec[0] == rhs.renderer_vec[0]); + LOG_IF(INFO, PULSAR_LOG_INIT) << " Renderer agrees: " << renderer_agrees; + bool device_agrees = + (this->device_tracker.device() == rhs.device_tracker.device()); + LOG_IF(INFO, PULSAR_LOG_INIT) << " Device agrees: " << device_agrees; + return (renderer_agrees && device_agrees); +}; + +void Renderer::ensure_on_device(torch::Device device, bool /*non_blocking*/) { + THArgCheck( + device.type() == c10::DeviceType::CUDA || + device.type() == c10::DeviceType::CPU, + 1, + "Only CPU and CUDA device types are supported."); + if (device.type() != this->device_type || + device.index() != this->device_index) { + LOG_IF(INFO, PULSAR_LOG_INIT) + << "Transferring render buffers between devices."; + int prev_active; + cudaGetDevice(&prev_active); + if (this->device_type == c10::DeviceType::CUDA) { + LOG_IF(INFO, PULSAR_LOG_INIT) << " Destructing on CUDA."; + cudaSetDevice(this->device_index); + for (auto& nrend : this->renderer_vec) { + PRE::destruct(&nrend); + } + } else { + LOG_IF(INFO, PULSAR_LOG_INIT) << " Destructing on CPU."; + for (auto& nrend : this->renderer_vec) { + PRE::destruct(&nrend); + } + } + if (device.type() == c10::DeviceType::CUDA) { + LOG_IF(INFO, PULSAR_LOG_INIT) << " Constructing on CUDA."; + cudaSetDevice(device.index()); + for (auto& nrend : this->renderer_vec) { + PRE::construct( + &nrend, + this->renderer_vec[0].max_num_balls, + this->renderer_vec[0].cam.film_width, + this->renderer_vec[0].cam.film_height, + this->renderer_vec[0].cam.orthogonal_projection, + this->renderer_vec[0].cam.right_handed, + this->renderer_vec[0].cam.background_normalization_depth, + this->renderer_vec[0].cam.n_channels, + this->n_track()); + } + } else { + LOG_IF(INFO, PULSAR_LOG_INIT) << " Constructing on CPU."; + for (auto& nrend : this->renderer_vec) { + PRE::construct( + &nrend, + this->renderer_vec[0].max_num_balls, + this->renderer_vec[0].cam.film_width, + this->renderer_vec[0].cam.film_height, + this->renderer_vec[0].cam.orthogonal_projection, + this->renderer_vec[0].cam.right_handed, + this->renderer_vec[0].cam.background_normalization_depth, + this->renderer_vec[0].cam.n_channels, + this->n_track()); + } + } + cudaSetDevice(prev_active); + this->device_type = device.type(); + this->device_index = device.index(); + } +}; + +void Renderer::ensure_n_renderers_gte(const size_t& batch_size) { + if (this->renderer_vec.size() < batch_size) { + ptrdiff_t diff = batch_size - this->renderer_vec.size(); + LOG_IF(INFO, PULSAR_LOG_INIT) + << "Increasing render buffers by " << diff + << " to account for batch size " << batch_size; + for (ptrdiff_t i = 0; i < diff; ++i) { + this->renderer_vec.emplace_back(); + if (this->device_type == c10::DeviceType::CUDA) { + PRE::construct( + &this->renderer_vec[this->renderer_vec.size() - 1], + this->max_num_balls(), + this->width(), + this->height(), + this->renderer_vec[0].cam.orthogonal_projection, + this->renderer_vec[0].cam.right_handed, + this->renderer_vec[0].cam.background_normalization_depth, + this->renderer_vec[0].cam.n_channels, + this->n_track()); + } else { + PRE::construct( + &this->renderer_vec[this->renderer_vec.size() - 1], + this->max_num_balls(), + this->width(), + this->height(), + this->renderer_vec[0].cam.orthogonal_projection, + this->renderer_vec[0].cam.right_handed, + this->renderer_vec[0].cam.background_normalization_depth, + this->renderer_vec[0].cam.n_channels, + this->n_track()); + } + } + } +} + +std::tuple Renderer::arg_check( + const torch::Tensor& vert_pos, + const torch::Tensor& vert_col, + const torch::Tensor& vert_radii, + const torch::Tensor& cam_pos, + const torch::Tensor& pixel_0_0_center, + const torch::Tensor& pixel_vec_x, + const torch::Tensor& pixel_vec_y, + const torch::Tensor& focal_length, + const torch::Tensor& principal_point_offsets, + const float& gamma, + const float& max_depth, + float& min_depth, + const c10::optional& bg_col, + const c10::optional& opacity, + const float& percent_allowed_difference, + const uint& max_n_hits, + const uint& mode) { + LOG_IF(INFO, PULSAR_LOG_FORWARD || PULSAR_LOG_BACKWARD) << "Arg check."; + size_t batch_size = 1; + size_t n_points; + bool batch_processing = false; + if (vert_pos.ndimension() == 3) { + // Check all parameters adhere batch size. + batch_processing = true; + batch_size = vert_pos.size(0); + THArgCheck( + vert_col.ndimension() == 3 && vert_col.size(0) == batch_size, + 2, + "vert_col needs to have batch size."); + THArgCheck( + vert_radii.ndimension() == 2 && vert_radii.size(0) == batch_size, + 3, + "vert_radii must be specified per batch."); + THArgCheck( + cam_pos.ndimension() == 2 && cam_pos.size(0) == batch_size, + 4, + "cam_pos must be specified per batch and have the correct batch size."); + THArgCheck( + pixel_0_0_center.ndimension() == 2 && + pixel_0_0_center.size(0) == batch_size, + 5, + "pixel_0_0_center must be specified per batch."); + THArgCheck( + pixel_vec_x.ndimension() == 2 && pixel_vec_x.size(0) == batch_size, + 6, + "pixel_vec_x must be specified per batch."); + THArgCheck( + pixel_vec_y.ndimension() == 2 && pixel_vec_y.size(0) == batch_size, + 7, + "pixel_vec_y must be specified per batch."); + THArgCheck( + focal_length.ndimension() == 1 && focal_length.size(0) == batch_size, + 8, + "focal_length must be specified per batch."); + THArgCheck( + principal_point_offsets.ndimension() == 2 && + principal_point_offsets.size(0) == batch_size, + 9, + "principal_point_offsets must be specified per batch."); + if (opacity.has_value()) { + THArgCheck( + opacity.value().ndimension() == 2 && + opacity.value().size(0) == batch_size, + 13, + "Opacity needs to be specified batch-wise."); + } + // Check all parameters are for a matching number of points. + n_points = vert_pos.size(1); + THArgCheck( + vert_col.size(1) == n_points, + 2, + ("The number of points for vertex positions (" + + std::to_string(n_points) + ") and vertex colors (" + + std::to_string(vert_col.size(1)) + ") doesn't agree.") + .c_str()); + THArgCheck( + vert_radii.size(1) == n_points, + 3, + ("The number of points for vertex positions (" + + std::to_string(n_points) + ") and vertex radii (" + + std::to_string(vert_col.size(1)) + ") doesn't agree.") + .c_str()); + if (opacity.has_value()) { + THArgCheck( + opacity.value().size(1) == n_points, + 13, + "Opacity needs to be specified per point."); + } + // Check all parameters have the correct last dimension size. + THArgCheck( + vert_pos.size(2) == 3, + 1, + ("Vertex positions must be 3D (have shape " + + std::to_string(vert_pos.size(2)) + ")!") + .c_str()); + THArgCheck( + vert_col.size(2) == this->renderer_vec[0].cam.n_channels, + 2, + ("Vertex colors must have the right number of channels (have shape " + + std::to_string(vert_col.size(2)) + ", need " + + std::to_string(this->renderer_vec[0].cam.n_channels) + ")!") + .c_str()); + THArgCheck( + cam_pos.size(1) == 3, + 4, + ("Camera position must be 3D (has shape " + + std::to_string(cam_pos.size(1)) + ")!") + .c_str()); + THArgCheck( + pixel_0_0_center.size(1) == 3, + 5, + ("pixel_0_0_center must be 3D (has shape " + + std::to_string(pixel_0_0_center.size(1)) + ")!") + .c_str()); + THArgCheck( + pixel_vec_x.size(1) == 3, + 6, + ("pixel_vec_x must be 3D (has shape " + + std::to_string(pixel_vec_x.size(1)) + ")!") + .c_str()); + THArgCheck( + pixel_vec_y.size(1) == 3, + 7, + ("pixel_vec_y must be 3D (has shape " + + std::to_string(pixel_vec_y.size(1)) + ")!") + .c_str()); + THArgCheck( + principal_point_offsets.size(1) == 2, + 9, + "principal_point_offsets must contain x and y offsets."); + // Ensure enough renderers are available for the batch. + ensure_n_renderers_gte(batch_size); + } else { + // Check all parameters are of correct dimension. + THArgCheck( + vert_col.ndimension() == 2, 2, "vert_col needs to have dimension 2."); + THArgCheck( + vert_radii.ndimension() == 1, 3, "vert_radii must have dimension 1."); + THArgCheck(cam_pos.ndimension() == 1, 4, "cam_pos must have dimension 1."); + THArgCheck( + pixel_0_0_center.ndimension() == 1, + 5, + "pixel_0_0_center must have dimension 1."); + THArgCheck( + pixel_vec_x.ndimension() == 1, 6, "pixel_vec_x must have dimension 1."); + THArgCheck( + pixel_vec_y.ndimension() == 1, 7, "pixel_vec_y must have dimension 1."); + THArgCheck( + focal_length.ndimension() == 0, + 8, + "focal_length must have dimension 0."); + THArgCheck( + principal_point_offsets.ndimension() == 1, + 9, + "principal_point_offsets must have dimension 1."); + if (opacity.has_value()) { + THArgCheck( + opacity.value().ndimension() == 1, + 13, + "Opacity needs to be specified per sample."); + } + // Check each. + n_points = vert_pos.size(0); + THArgCheck( + vert_col.size(0) == n_points, + 2, + ("The number of points for vertex positions (" + + std::to_string(n_points) + ") and vertex colors (" + + std::to_string(vert_col.size(0)) + ") doesn't agree.") + .c_str()); + THArgCheck( + vert_radii.size(0) == n_points, + 3, + ("The number of points for vertex positions (" + + std::to_string(n_points) + ") and vertex radii (" + + std::to_string(vert_col.size(0)) + ") doesn't agree.") + .c_str()); + if (opacity.has_value()) { + THArgCheck( + opacity.value().size(0) == n_points, + 12, + "Opacity needs to be specified per point."); + } + // Check all parameters have the correct last dimension size. + THArgCheck( + vert_pos.size(1) == 3, + 1, + ("Vertex positions must be 3D (have shape " + + std::to_string(vert_pos.size(1)) + ")!") + .c_str()); + THArgCheck( + vert_col.size(1) == this->renderer_vec[0].cam.n_channels, + 2, + ("Vertex colors must have the right number of channels (have shape " + + std::to_string(vert_col.size(1)) + ", need " + + std::to_string(this->renderer_vec[0].cam.n_channels) + ")!") + .c_str()); + THArgCheck( + cam_pos.size(0) == 3, + 4, + ("Camera position must be 3D (has shape " + + std::to_string(cam_pos.size(0)) + ")!") + .c_str()); + THArgCheck( + pixel_0_0_center.size(0) == 3, + 5, + ("pixel_0_0_center must be 3D (has shape " + + std::to_string(pixel_0_0_center.size(0)) + ")!") + .c_str()); + THArgCheck( + pixel_vec_x.size(0) == 3, + 6, + ("pixel_vec_x must be 3D (has shape " + + std::to_string(pixel_vec_x.size(0)) + ")!") + .c_str()); + THArgCheck( + pixel_vec_y.size(0) == 3, + 7, + ("pixel_vec_y must be 3D (has shape " + + std::to_string(pixel_vec_y.size(0)) + ")!") + .c_str()); + THArgCheck( + principal_point_offsets.size(0) == 2, + 9, + "principal_point_offsets must have x and y component."); + } + // Check device placement. + auto dev = torch::device_of(vert_pos).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 1, + ("Vertex positions must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + dev = torch::device_of(vert_col).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 2, + ("Vertex colors must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + dev = torch::device_of(vert_radii).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 3, + ("Vertex radii must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + dev = torch::device_of(cam_pos).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 4, + ("Camera position must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + dev = torch::device_of(pixel_0_0_center).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 5, + ("pixel_0_0_center must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + dev = torch::device_of(pixel_vec_x).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 6, + ("pixel_vec_x must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + dev = torch::device_of(pixel_vec_y).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 7, + ("pixel_vec_y must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + dev = torch::device_of(principal_point_offsets).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 9, + ("principal_point_offsets must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + if (opacity.has_value()) { + dev = torch::device_of(opacity.value()).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 13, + ("opacity must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Is stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + } + // Type checks. + THArgCheck( + vert_pos.scalar_type() == c10::kFloat, 1, "pulsar requires float types."); + THArgCheck( + vert_col.scalar_type() == c10::kFloat, 2, "pulsar requires float types."); + THArgCheck( + vert_radii.scalar_type() == c10::kFloat, + 3, + "pulsar requires float types."); + THArgCheck( + cam_pos.scalar_type() == c10::kFloat, 4, "pulsar requires float types."); + THArgCheck( + pixel_0_0_center.scalar_type() == c10::kFloat, + 5, + "pulsar requires float types."); + THArgCheck( + pixel_vec_x.scalar_type() == c10::kFloat, + 6, + "pulsar requires float types."); + THArgCheck( + pixel_vec_y.scalar_type() == c10::kFloat, + 7, + "pulsar requires float types."); + THArgCheck( + focal_length.scalar_type() == c10::kFloat, + 8, + "pulsar requires float types."); + THArgCheck( + // Unfortunately, the PyTorch interface is inconsistent for + // Int32: in Python, there exists an explicit int32 type, in + // C++ this is currently `c10::kInt`. + principal_point_offsets.scalar_type() == c10::kInt, + 9, + "principal_point_offsets must be provided as int32."); + if (opacity.has_value()) { + THArgCheck( + opacity.value().scalar_type() == c10::kFloat, + 13, + "opacity must be a float type."); + } + // Content checks. + THArgCheck( + (vert_radii > FEPS).all().item(), + 3, + ("Vertex radii must be > FEPS (min is " + + std::to_string(vert_radii.min().item()) + ").") + .c_str()); + if (this->orthogonal()) { + THArgCheck( + (focal_length == 0.f).all().item(), + 8, + ("for an orthogonal projection focal length must be zero (abs max: " + + std::to_string(focal_length.abs().max().item()) + ").") + .c_str()); + } else { + THArgCheck( + (focal_length > FEPS).all().item(), + 8, + ("for a perspective projection focal length must be > FEPS (min " + + std::to_string(focal_length.min().item()) + ").") + .c_str()); + } + THArgCheck( + gamma <= 1.f && gamma >= 1E-5f, + 10, + ("gamma must be in [1E-5, 1] (" + std::to_string(gamma) + ").").c_str()); + if (min_depth == 0.f) { + min_depth = focal_length.max().item() + 2.f * FEPS; + } + THArgCheck( + min_depth > focal_length.max().item(), + 12, + ("min_depth must be > focal_length (" + std::to_string(min_depth) + + " vs. " + std::to_string(focal_length.max().item()) + ").") + .c_str()); + THArgCheck( + max_depth > min_depth + FEPS, + 11, + ("max_depth must be > min_depth + FEPS (" + std::to_string(max_depth) + + " vs. " + std::to_string(min_depth + FEPS) + ").") + .c_str()); + THArgCheck( + percent_allowed_difference >= 0.f && percent_allowed_difference < 1.f, + 14, + ("percent_allowed_difference must be in [0., 1.[ (" + + std::to_string(percent_allowed_difference) + ").") + .c_str()); + THArgCheck(max_n_hits > 0, 14, "max_n_hits must be > 0!"); + THArgCheck(mode < 2, 15, "mode must be in {0, 1}."); + torch::Tensor real_bg_col; + if (bg_col.has_value()) { + THArgCheck( + bg_col.value().device().type() == this->device_type && + bg_col.value().device().index() == this->device_index, + 13, + "bg_col must be stored on the renderer device!"); + THArgCheck( + bg_col.value().ndimension() == 1 && + bg_col.value().size(0) == renderer_vec[0].cam.n_channels, + 13, + "bg_col must have the same number of channels as the image,)."); + real_bg_col = bg_col.value(); + } else { + real_bg_col = torch::ones( + {renderer_vec[0].cam.n_channels}, + c10::Device(this->device_type, this->device_index)) + .to(c10::kFloat); + } + if (opacity.has_value()) { + THArgCheck( + (opacity.value() >= 0.f).all().item(), + 13, + "opacity must be >= 0."); + THArgCheck( + (opacity.value() <= 1.f).all().item(), + 13, + "opacity must be <= 1."); + } + LOG_IF(INFO, PULSAR_LOG_FORWARD || PULSAR_LOG_BACKWARD) + << " batch_size: " << batch_size; + LOG_IF(INFO, PULSAR_LOG_FORWARD || PULSAR_LOG_BACKWARD) + << " n_points: " << n_points; + LOG_IF(INFO, PULSAR_LOG_FORWARD || PULSAR_LOG_BACKWARD) + << " batch_processing: " << batch_processing; + return std::tuple( + batch_size, n_points, batch_processing, real_bg_col); +} + +std::tuple Renderer::forward( + const torch::Tensor& vert_pos, + const torch::Tensor& vert_col, + const torch::Tensor& vert_radii, + const torch::Tensor& cam_pos, + const torch::Tensor& pixel_0_0_center, + const torch::Tensor& pixel_vec_x, + const torch::Tensor& pixel_vec_y, + const torch::Tensor& focal_length, + const torch::Tensor& principal_point_offsets, + const float& gamma, + const float& max_depth, + float min_depth, + const c10::optional& bg_col, + const c10::optional& opacity, + const float& percent_allowed_difference, + const uint& max_n_hits, + const uint& mode) { + // Parameter checks. + this->ensure_on_device(this->device_tracker.device()); + size_t batch_size; + size_t n_points; + bool batch_processing; + torch::Tensor real_bg_col; + std::tie(batch_size, n_points, batch_processing, real_bg_col) = + this->arg_check( + vert_pos, + vert_col, + vert_radii, + cam_pos, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + focal_length, + principal_point_offsets, + gamma, + max_depth, + min_depth, + bg_col, + opacity, + percent_allowed_difference, + max_n_hits, + mode); + LOG_IF(INFO, PULSAR_LOG_FORWARD) << "Extracting camera objects..."; + // Create the camera information. + std::vector cam_infos(batch_size); + if (batch_processing) { + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + cam_infos[batch_i] = cam_info_from_params( + cam_pos[batch_i], + pixel_0_0_center[batch_i], + pixel_vec_x[batch_i], + pixel_vec_y[batch_i], + principal_point_offsets[batch_i], + focal_length[batch_i].item(), + this->renderer_vec[0].cam.film_width, + this->renderer_vec[0].cam.film_height, + min_depth, + max_depth, + this->renderer_vec[0].cam.right_handed); + } + } else { + cam_infos[0] = cam_info_from_params( + cam_pos, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + principal_point_offsets, + focal_length.item(), + this->renderer_vec[0].cam.film_width, + this->renderer_vec[0].cam.film_height, + min_depth, + max_depth, + this->renderer_vec[0].cam.right_handed); + } + LOG_IF(INFO, PULSAR_LOG_FORWARD) << "Processing..."; + // Let's go! + // Contiguous version of opacity, if available. We need to create this object + // in scope to keep it alive. + torch::Tensor opacity_contiguous; + float const* opacity_ptr = nullptr; + if (opacity.has_value()) { + opacity_contiguous = opacity.value().contiguous(); + opacity_ptr = opacity_contiguous.data_ptr(); + } + if (this->device_type == c10::DeviceType::CUDA) { + int prev_active; + cudaGetDevice(&prev_active); + cudaSetDevice(this->device_index); +#ifdef PULSAR_TIMINGS_BATCHED_ENABLED + START_TIME_CU(batch_forward); +#endif + if (batch_processing) { + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + // These calls are non-blocking and just kick off the computations. + PRE::forward( + &this->renderer_vec[batch_i], + vert_pos[batch_i].contiguous().data_ptr(), + vert_col[batch_i].contiguous().data_ptr(), + vert_radii[batch_i].contiguous().data_ptr(), + cam_infos[batch_i], + gamma, + percent_allowed_difference, + max_n_hits, + real_bg_col.contiguous().data_ptr(), + opacity_ptr, + n_points, + mode, + at::cuda::getCurrentCUDAStream()); + } + } else { + PRE::forward( + this->renderer_vec.data(), + vert_pos.contiguous().data_ptr(), + vert_col.contiguous().data_ptr(), + vert_radii.contiguous().data_ptr(), + cam_infos[0], + gamma, + percent_allowed_difference, + max_n_hits, + real_bg_col.contiguous().data_ptr(), + opacity_ptr, + n_points, + mode, + at::cuda::getCurrentCUDAStream()); + } +#ifdef PULSAR_TIMINGS_BATCHED_ENABLED + STOP_TIME_CU(batch_forward); + float time_ms; + GET_TIME_CU(batch_forward, &time_ms); + std::cout << "Forward render batched time per example: " + << time_ms / static_cast(batch_size) << "ms" << std::endl; +#endif + cudaSetDevice(prev_active); + } else { +#ifdef PULSAR_TIMINGS_BATCHED_ENABLED + START_TIME(batch_forward); +#endif + if (batch_processing) { + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + // These calls are non-blocking and just kick off the computations. + PRE::forward( + &this->renderer_vec[batch_i], + vert_pos[batch_i].contiguous().data_ptr(), + vert_col[batch_i].contiguous().data_ptr(), + vert_radii[batch_i].contiguous().data_ptr(), + cam_infos[batch_i], + gamma, + percent_allowed_difference, + max_n_hits, + real_bg_col.contiguous().data_ptr(), + opacity_ptr, + n_points, + mode, + nullptr); + } + } else { + PRE::forward( + this->renderer_vec.data(), + vert_pos.contiguous().data_ptr(), + vert_col.contiguous().data_ptr(), + vert_radii.contiguous().data_ptr(), + cam_infos[0], + gamma, + percent_allowed_difference, + max_n_hits, + real_bg_col.contiguous().data_ptr(), + opacity_ptr, + n_points, + mode, + nullptr); + } +#ifdef PULSAR_TIMINGS_BATCHED_ENABLED + STOP_TIME(batch_forward); + float time_ms; + GET_TIME(batch_forward, &time_ms); + std::cout << "Forward render batched time per example: " + << time_ms / static_cast(batch_size) << "ms" << std::endl; +#endif + } + LOG_IF(INFO, PULSAR_LOG_FORWARD) << "Extracting results..."; + // Create the results. + std::vector results(batch_size); + std::vector forw_infos(batch_size); + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + results[batch_i] = from_blob( + this->renderer_vec[batch_i].result_d, + {this->renderer_vec[0].cam.film_height, + this->renderer_vec[0].cam.film_width, + this->renderer_vec[0].cam.n_channels}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + if (mode == 1) + results[batch_i] = results[batch_i].slice(2, 0, 1, 1); + forw_infos[batch_i] = from_blob( + this->renderer_vec[batch_i].forw_info_d, + {this->renderer_vec[0].cam.film_height, + this->renderer_vec[0].cam.film_width, + 3 + 2 * this->n_track()}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + LOG_IF(INFO, PULSAR_LOG_FORWARD) << "Forward render complete."; + if (batch_processing) { + return std::tuple( + torch::stack(results), torch::stack(forw_infos)); + } else { + return std::tuple(results[0], forw_infos[0]); + } +}; + +std::tuple< + at::optional, + at::optional, + at::optional, + at::optional, + at::optional, + at::optional, + at::optional, + at::optional> +Renderer::backward( + const torch::Tensor& grad_im, + const torch::Tensor& image, + const torch::Tensor& forw_info, + const torch::Tensor& vert_pos, + const torch::Tensor& vert_col, + const torch::Tensor& vert_radii, + const torch::Tensor& cam_pos, + const torch::Tensor& pixel_0_0_center, + const torch::Tensor& pixel_vec_x, + const torch::Tensor& pixel_vec_y, + const torch::Tensor& focal_length, + const torch::Tensor& principal_point_offsets, + const float& gamma, + const float& max_depth, + float min_depth, + const c10::optional& bg_col, + const c10::optional& opacity, + const float& percent_allowed_difference, + const uint& max_n_hits, + const uint& mode, + const bool& dif_pos, + const bool& dif_col, + const bool& dif_rad, + const bool& dif_cam, + const bool& dif_opy, + const at::optional>& dbg_pos) { + this->ensure_on_device(this->device_tracker.device()); + size_t batch_size; + size_t n_points; + bool batch_processing; + torch::Tensor real_bg_col; + std::tie(batch_size, n_points, batch_processing, real_bg_col) = + this->arg_check( + vert_pos, + vert_col, + vert_radii, + cam_pos, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + focal_length, + principal_point_offsets, + gamma, + max_depth, + min_depth, + bg_col, + opacity, + percent_allowed_difference, + max_n_hits, + mode); + // Additional checks for the gradient computation. + THArgCheck( + (grad_im.ndimension() == 3 + batch_processing && + static_cast(grad_im.size(0 + batch_processing)) == + this->height() && + static_cast(grad_im.size(1 + batch_processing)) == this->width() && + static_cast(grad_im.size(2 + batch_processing)) == + this->renderer_vec[0].cam.n_channels), + 1, + "The gradient image size is not correct."); + THArgCheck( + (image.ndimension() == 3 + batch_processing && + static_cast(image.size(0 + batch_processing)) == this->height() && + static_cast(image.size(1 + batch_processing)) == this->width() && + static_cast(image.size(2 + batch_processing)) == + this->renderer_vec[0].cam.n_channels), + 2, + "The result image size is not correct."); + THArgCheck( + grad_im.scalar_type() == c10::kFloat, + 1, + "The gradient image must be of float type."); + THArgCheck( + image.scalar_type() == c10::kFloat, + 2, + "The image must be of float type."); + if (dif_opy) { + THArgCheck(opacity.has_value(), 13, "dif_opy set requires opacity values."); + } + if (batch_processing) { + THArgCheck( + grad_im.size(0) == batch_size, + 1, + "Gradient image batch size must agree."); + THArgCheck(image.size(0) == batch_size, 2, "Image batch size must agree."); + THArgCheck( + forw_info.size(0) == batch_size, + 3, + "forward info must have batch size."); + } + THArgCheck( + (forw_info.ndimension() == 3 + batch_processing && + static_cast(forw_info.size(0 + batch_processing)) == + this->height() && + static_cast(forw_info.size(1 + batch_processing)) == + this->width() && + static_cast(forw_info.size(2 + batch_processing)) == + 3 + 2 * this->n_track()), + 3, + "The forward info image size is not correct."); + THArgCheck( + forw_info.scalar_type() == c10::kFloat, + 3, + "The forward info must be of float type."); + // Check device. + auto dev = torch::device_of(grad_im).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 1, + ("grad_im must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + dev = torch::device_of(image).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 2, + ("image must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + dev = torch::device_of(forw_info).value(); + THArgCheck( + dev.type() == this->device_type && dev.index() == this->device_index, + 3, + ("forw_info must be stored on device " + + c10::DeviceTypeName(this->device_type) + ", index " + + std::to_string(this->device_index) + "! Are stored on " + + c10::DeviceTypeName(dev.type()) + ", index " + + std::to_string(dev.index()) + ".") + .c_str()); + if (dbg_pos.has_value()) { + THArgCheck( + dbg_pos.value().first < this->width() && + dbg_pos.value().second < this->height(), + 23, + "The debug position must be within image bounds."); + } + // Prepare the return value. + std::tuple< + at::optional, + at::optional, + at::optional, + at::optional, + at::optional, + at::optional, + at::optional, + at::optional> + ret; + if (mode == 1 || (!dif_pos && !dif_col && !dif_rad && !dif_cam)) { + return ret; + } + // Create the camera information. + std::vector cam_infos(batch_size); + if (batch_processing) { + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + cam_infos[batch_i] = cam_info_from_params( + cam_pos[batch_i], + pixel_0_0_center[batch_i], + pixel_vec_x[batch_i], + pixel_vec_y[batch_i], + principal_point_offsets[batch_i], + focal_length[batch_i].item(), + this->renderer_vec[0].cam.film_width, + this->renderer_vec[0].cam.film_height, + min_depth, + max_depth, + this->renderer_vec[0].cam.right_handed); + } + } else { + cam_infos[0] = cam_info_from_params( + cam_pos, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + principal_point_offsets, + focal_length.item(), + this->renderer_vec[0].cam.film_width, + this->renderer_vec[0].cam.film_height, + min_depth, + max_depth, + this->renderer_vec[0].cam.right_handed); + } + // Let's go! + // Contiguous version of opacity, if available. We need to create this object + // in scope to keep it alive. + torch::Tensor opacity_contiguous; + float const* opacity_ptr = nullptr; + if (opacity.has_value()) { + opacity_contiguous = opacity.value().contiguous(); + opacity_ptr = opacity_contiguous.data_ptr(); + } + if (this->device_type == c10::DeviceType::CUDA) { + int prev_active; + cudaGetDevice(&prev_active); + cudaSetDevice(this->device_index); +#ifdef PULSAR_TIMINGS_BATCHED_ENABLED + START_TIME_CU(batch_backward); +#endif + if (batch_processing) { + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + // These calls are non-blocking and just kick off the computations. + if (dbg_pos.has_value()) { + PRE::backward_dbg( + &this->renderer_vec[batch_i], + grad_im[batch_i].contiguous().data_ptr(), + image[batch_i].contiguous().data_ptr(), + forw_info[batch_i].contiguous().data_ptr(), + vert_pos[batch_i].contiguous().data_ptr(), + vert_col[batch_i].contiguous().data_ptr(), + vert_radii[batch_i].contiguous().data_ptr(), + cam_infos[batch_i], + gamma, + percent_allowed_difference, + max_n_hits, + opacity_ptr, + n_points, + mode, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + dbg_pos.value().first, + dbg_pos.value().second, + at::cuda::getCurrentCUDAStream()); + } else { + PRE::backward( + &this->renderer_vec[batch_i], + grad_im[batch_i].contiguous().data_ptr(), + image[batch_i].contiguous().data_ptr(), + forw_info[batch_i].contiguous().data_ptr(), + vert_pos[batch_i].contiguous().data_ptr(), + vert_col[batch_i].contiguous().data_ptr(), + vert_radii[batch_i].contiguous().data_ptr(), + cam_infos[batch_i], + gamma, + percent_allowed_difference, + max_n_hits, + opacity_ptr, + n_points, + mode, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + at::cuda::getCurrentCUDAStream()); + } + } + } else { + if (dbg_pos.has_value()) { + PRE::backward_dbg( + this->renderer_vec.data(), + grad_im.contiguous().data_ptr(), + image.contiguous().data_ptr(), + forw_info.contiguous().data_ptr(), + vert_pos.contiguous().data_ptr(), + vert_col.contiguous().data_ptr(), + vert_radii.contiguous().data_ptr(), + cam_infos[0], + gamma, + percent_allowed_difference, + max_n_hits, + opacity_ptr, + n_points, + mode, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + dbg_pos.value().first, + dbg_pos.value().second, + at::cuda::getCurrentCUDAStream()); + } else { + PRE::backward( + this->renderer_vec.data(), + grad_im.contiguous().data_ptr(), + image.contiguous().data_ptr(), + forw_info.contiguous().data_ptr(), + vert_pos.contiguous().data_ptr(), + vert_col.contiguous().data_ptr(), + vert_radii.contiguous().data_ptr(), + cam_infos[0], + gamma, + percent_allowed_difference, + max_n_hits, + opacity_ptr, + n_points, + mode, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + at::cuda::getCurrentCUDAStream()); + } + } + cudaSetDevice(prev_active); +#ifdef PULSAR_TIMINGS_BATCHED_ENABLED + STOP_TIME_CU(batch_backward); + float time_ms; + GET_TIME_CU(batch_backward, &time_ms); + std::cout << "Backward render batched time per example: " + << time_ms / static_cast(batch_size) << "ms" << std::endl; +#endif + } else { +#ifdef PULSAR_TIMINGS_BATCHED_ENABLED + START_TIME(batch_backward); +#endif + if (batch_processing) { + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + // These calls are non-blocking and just kick off the computations. + if (dbg_pos.has_value()) { + PRE::backward_dbg( + &this->renderer_vec[batch_i], + grad_im[batch_i].contiguous().data_ptr(), + image[batch_i].contiguous().data_ptr(), + forw_info[batch_i].contiguous().data_ptr(), + vert_pos[batch_i].contiguous().data_ptr(), + vert_col[batch_i].contiguous().data_ptr(), + vert_radii[batch_i].contiguous().data_ptr(), + cam_infos[batch_i], + gamma, + percent_allowed_difference, + max_n_hits, + opacity_ptr, + n_points, + mode, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + dbg_pos.value().first, + dbg_pos.value().second, + nullptr); + } else { + PRE::backward( + &this->renderer_vec[batch_i], + grad_im[batch_i].contiguous().data_ptr(), + image[batch_i].contiguous().data_ptr(), + forw_info[batch_i].contiguous().data_ptr(), + vert_pos[batch_i].contiguous().data_ptr(), + vert_col[batch_i].contiguous().data_ptr(), + vert_radii[batch_i].contiguous().data_ptr(), + cam_infos[batch_i], + gamma, + percent_allowed_difference, + max_n_hits, + opacity_ptr, + n_points, + mode, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + nullptr); + } + } + } else { + if (dbg_pos.has_value()) { + PRE::backward_dbg( + this->renderer_vec.data(), + grad_im.contiguous().data_ptr(), + image.contiguous().data_ptr(), + forw_info.contiguous().data_ptr(), + vert_pos.contiguous().data_ptr(), + vert_col.contiguous().data_ptr(), + vert_radii.contiguous().data_ptr(), + cam_infos[0], + gamma, + percent_allowed_difference, + max_n_hits, + opacity_ptr, + n_points, + mode, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + dbg_pos.value().first, + dbg_pos.value().second, + nullptr); + } else { + PRE::backward( + this->renderer_vec.data(), + grad_im.contiguous().data_ptr(), + image.contiguous().data_ptr(), + forw_info.contiguous().data_ptr(), + vert_pos.contiguous().data_ptr(), + vert_col.contiguous().data_ptr(), + vert_radii.contiguous().data_ptr(), + cam_infos[0], + gamma, + percent_allowed_difference, + max_n_hits, + opacity_ptr, + n_points, + mode, + dif_pos, + dif_col, + dif_rad, + dif_cam, + dif_opy, + nullptr); + } + } +#ifdef PULSAR_TIMINGS_BATCHED_ENABLED + STOP_TIME(batch_backward); + float time_ms; + GET_TIME(batch_backward, &time_ms); + std::cout << "Backward render batched time per example: " + << time_ms / static_cast(batch_size) << "ms" << std::endl; +#endif + } + if (dif_pos) { + if (batch_processing) { + std::vector results(batch_size); + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + results[batch_i] = from_blob( + reinterpret_cast(this->renderer_vec[batch_i].grad_pos_d), + {static_cast(n_points), 3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + std::get<0>(ret) = torch::stack(results); + } else { + std::get<0>(ret) = from_blob( + reinterpret_cast(this->renderer_vec[0].grad_pos_d), + {static_cast(n_points), 3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + } + if (dif_col) { + if (batch_processing) { + std::vector results(batch_size); + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + results[batch_i] = from_blob( + reinterpret_cast(this->renderer_vec[batch_i].grad_col_d), + {static_cast(n_points), + this->renderer_vec[0].cam.n_channels}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + std::get<1>(ret) = torch::stack(results); + } else { + std::get<1>(ret) = from_blob( + reinterpret_cast(this->renderer_vec[0].grad_col_d), + {static_cast(n_points), + this->renderer_vec[0].cam.n_channels}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + } + if (dif_rad) { + if (batch_processing) { + std::vector results(batch_size); + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + results[batch_i] = from_blob( + reinterpret_cast(this->renderer_vec[batch_i].grad_rad_d), + {static_cast(n_points)}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + std::get<2>(ret) = torch::stack(results); + } else { + std::get<2>(ret) = from_blob( + reinterpret_cast(this->renderer_vec[0].grad_rad_d), + {static_cast(n_points)}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + } + if (dif_cam) { + if (batch_processing) { + std::vector res_p1(batch_size); + std::vector res_p2(batch_size); + std::vector res_p3(batch_size); + std::vector res_p4(batch_size); + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + res_p1[batch_i] = from_blob( + reinterpret_cast(this->renderer_vec[batch_i].grad_cam_d), + {3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + res_p2[batch_i] = from_blob( + reinterpret_cast( + this->renderer_vec[batch_i].grad_cam_d + 3), + {3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + res_p3[batch_i] = from_blob( + reinterpret_cast( + this->renderer_vec[batch_i].grad_cam_d + 6), + {3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + res_p4[batch_i] = from_blob( + reinterpret_cast( + this->renderer_vec[batch_i].grad_cam_d + 9), + {3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + std::get<3>(ret) = torch::stack(res_p1); + std::get<4>(ret) = torch::stack(res_p2); + std::get<5>(ret) = torch::stack(res_p3); + std::get<6>(ret) = torch::stack(res_p4); + } else { + std::get<3>(ret) = from_blob( + reinterpret_cast(this->renderer_vec[0].grad_cam_d), + {3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + std::get<4>(ret) = from_blob( + reinterpret_cast(this->renderer_vec[0].grad_cam_d + 3), + {3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + std::get<5>(ret) = from_blob( + reinterpret_cast(this->renderer_vec[0].grad_cam_d + 6), + {3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + std::get<6>(ret) = from_blob( + reinterpret_cast(this->renderer_vec[0].grad_cam_d + 9), + {3}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + } + if (dif_opy) { + if (batch_processing) { + std::vector results(batch_size); + for (size_t batch_i = 0; batch_i < batch_size; ++batch_i) { + results[batch_i] = from_blob( + reinterpret_cast(this->renderer_vec[batch_i].grad_opy_d), + {static_cast(n_points)}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + std::get<7>(ret) = torch::stack(results); + } else { + std::get<7>(ret) = from_blob( + reinterpret_cast(this->renderer_vec[0].grad_opy_d), + {static_cast(n_points)}, + this->device_type, + this->device_index, + torch::kFloat, + this->device_type == c10::DeviceType::CUDA + ? at::cuda::getCurrentCUDAStream() + : (cudaStream_t) nullptr); + } + } + return ret; +}; + +} // namespace pytorch +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/pytorch/renderer.h b/pytorch3d/csrc/pulsar/pytorch/renderer.h new file mode 100644 index 00000000..a5144d29 --- /dev/null +++ b/pytorch3d/csrc/pulsar/pytorch/renderer.h @@ -0,0 +1,167 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_PYTORCH_RENDERER_H_ +#define PULSAR_NATIVE_PYTORCH_RENDERER_H_ + +#include "../global.h" +#include "../include/renderer.h" + +namespace pulsar { +namespace pytorch { + +struct Renderer { + public: + /** + * Pytorch Pulsar differentiable rendering module. + */ + explicit Renderer( + const unsigned int& width, + const unsigned int& height, + const uint& max_n_balls, + const bool& orthogonal_projection, + const bool& right_handed_system, + const float& background_normalization_depth, + const uint& n_channels, + const uint& n_track); + ~Renderer(); + + std::tuple forward( + const torch::Tensor& vert_pos, + const torch::Tensor& vert_col, + const torch::Tensor& vert_radii, + const torch::Tensor& cam_pos, + const torch::Tensor& pixel_0_0_center, + const torch::Tensor& pixel_vec_x, + const torch::Tensor& pixel_vec_y, + const torch::Tensor& focal_length, + const torch::Tensor& principal_point_offsets, + const float& gamma, + const float& max_depth, + float min_depth, + const c10::optional& bg_col, + const c10::optional& opacity, + const float& percent_allowed_difference, + const uint& max_n_hits, + const uint& mode); + + std::tuple< + at::optional, + at::optional, + at::optional, + at::optional, + at::optional, + at::optional, + at::optional, + at::optional> + backward( + const torch::Tensor& grad_im, + const torch::Tensor& image, + const torch::Tensor& forw_info, + const torch::Tensor& vert_pos, + const torch::Tensor& vert_col, + const torch::Tensor& vert_radii, + const torch::Tensor& cam_pos, + const torch::Tensor& pixel_0_0_center, + const torch::Tensor& pixel_vec_x, + const torch::Tensor& pixel_vec_y, + const torch::Tensor& focal_length, + const torch::Tensor& principal_point_offsets, + const float& gamma, + const float& max_depth, + float min_depth, + const c10::optional& bg_col, + const c10::optional& opacity, + const float& percent_allowed_difference, + const uint& max_n_hits, + const uint& mode, + const bool& dif_pos, + const bool& dif_col, + const bool& dif_rad, + const bool& dif_cam, + const bool& dif_opy, + const at::optional>& dbg_pos); + + // Infrastructure. + /** + * Ensure that the renderer is placed on this device. + * Is nearly a no-op if the device is correct. + */ + void ensure_on_device(torch::Device device, bool non_blocking = false); + + /** + * Ensure that at least n renderers are available. + */ + void ensure_n_renderers_gte(const size_t& batch_size); + + /** + * Check the parameters. + */ + std::tuple arg_check( + const torch::Tensor& vert_pos, + const torch::Tensor& vert_col, + const torch::Tensor& vert_radii, + const torch::Tensor& cam_pos, + const torch::Tensor& pixel_0_0_center, + const torch::Tensor& pixel_vec_x, + const torch::Tensor& pixel_vec_y, + const torch::Tensor& focal_length, + const torch::Tensor& principal_point_offsets, + const float& gamma, + const float& max_depth, + float& min_depth, + const c10::optional& bg_col, + const c10::optional& opacity, + const float& percent_allowed_difference, + const uint& max_n_hits, + const uint& mode); + + bool operator==(const Renderer& rhs) const; + inline friend std::ostream& operator<<( + std::ostream& stream, + const Renderer& self) { + stream << "pulsar::Renderer["; + // Device info. + stream << self.device_type; + if (self.device_index != -1) + stream << ", ID " << self.device_index; + stream << "]"; + return stream; + } + + inline uint width() const { + return this->renderer_vec[0].cam.film_width; + } + inline uint height() const { + return this->renderer_vec[0].cam.film_height; + } + inline int max_num_balls() const { + return this->renderer_vec[0].max_num_balls; + } + inline bool orthogonal() const { + return this->renderer_vec[0].cam.orthogonal_projection; + } + inline bool right_handed() const { + return this->renderer_vec[0].cam.right_handed; + } + inline uint n_track() const { + return static_cast(this->renderer_vec[0].n_track); + } + + /** A tensor that is registered as a buffer with this Module to track its + * device placement. Unfortunately, pytorch doesn't offer tracking Module + * device placement in a better way as of now. + */ + torch::Tensor device_tracker; + + protected: + /** The device type for this renderer. */ + c10::DeviceType device_type; + /** The device index for this renderer. */ + c10::DeviceIndex device_index; + /** Pointer to the underlying pulsar renderers. */ + std::vector renderer_vec; +}; + +} // namespace pytorch +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/pytorch/tensor_util.cpp b/pytorch3d/csrc/pulsar/pytorch/tensor_util.cpp new file mode 100644 index 00000000..c1e9e108 --- /dev/null +++ b/pytorch3d/csrc/pulsar/pytorch/tensor_util.cpp @@ -0,0 +1,48 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include +#include +#include + +#include "./tensor_util.h" + +namespace pulsar { +namespace pytorch { + +torch::Tensor sphere_ids_from_result_info_nograd( + const torch::Tensor& forw_info) { + torch::Tensor result = torch::zeros( + {forw_info.size(0), + forw_info.size(1), + forw_info.size(2), + (forw_info.size(3) - 3) / 2}, + torch::TensorOptions().device(forw_info.device()).dtype(torch::kInt32)); + // Get the relevant slice, contiguous. + torch::Tensor tmp = + forw_info + .slice( + /*dim=*/3, /*start=*/3, /*end=*/forw_info.size(3), /*step=*/2) + .contiguous(); + if (forw_info.device().type() == c10::DeviceType::CUDA) { + cudaMemcpyAsync( + result.data_ptr(), + tmp.data_ptr(), + sizeof(uint32_t) * tmp.size(0) * tmp.size(1) * tmp.size(2) * + tmp.size(3), + cudaMemcpyDeviceToDevice, + at::cuda::getCurrentCUDAStream()); + } else { + memcpy( + result.data_ptr(), + tmp.data_ptr(), + sizeof(uint32_t) * tmp.size(0) * tmp.size(1) * tmp.size(2) * + tmp.size(3)); + } + // `tmp` is freed after this, the memory might get reallocated. However, + // only kernels in the same stream should ever be able to write to this + // memory, which are executed only after the memcpy is complete. That's + // why we can just continue. + return result; +} + +} // namespace pytorch +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/pytorch/tensor_util.h b/pytorch3d/csrc/pulsar/pytorch/tensor_util.h new file mode 100644 index 00000000..b98f7e50 --- /dev/null +++ b/pytorch3d/csrc/pulsar/pytorch/tensor_util.h @@ -0,0 +1,16 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_PYTORCH_TENSOR_UTIL_H_ +#define PULSAR_NATIVE_PYTORCH_TENSOR_UTIL_H_ + +#include + +namespace pulsar { +namespace pytorch { + +torch::Tensor sphere_ids_from_result_info_nograd( + const torch::Tensor& forw_info); + +} +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/pytorch/util.cpp b/pytorch3d/csrc/pulsar/pytorch/util.cpp new file mode 100644 index 00000000..847e697e --- /dev/null +++ b/pytorch3d/csrc/pulsar/pytorch/util.cpp @@ -0,0 +1,24 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include + +namespace pulsar { +namespace pytorch { + +void cudaDevToDev( + void* trg, + const void* src, + const int& size, + const cudaStream_t& stream) { + cudaMemcpyAsync(trg, src, size, cudaMemcpyDeviceToDevice, stream); +} + +void cudaDevToHost( + void* trg, + const void* src, + const int& size, + const cudaStream_t& stream) { + cudaMemcpyAsync(trg, src, size, cudaMemcpyDeviceToHost, stream); +} + +} // namespace pytorch +} // namespace pulsar diff --git a/pytorch3d/csrc/pulsar/pytorch/util.h b/pytorch3d/csrc/pulsar/pytorch/util.h new file mode 100644 index 00000000..bab41678 --- /dev/null +++ b/pytorch3d/csrc/pulsar/pytorch/util.h @@ -0,0 +1,59 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#ifndef PULSAR_NATIVE_PYTORCH_UTIL_H_ +#define PULSAR_NATIVE_PYTORCH_UTIL_H_ + +#include +#include "../global.h" + +namespace pulsar { +namespace pytorch { + +void cudaDevToDev( + void* trg, + const void* src, + const int& size, + const cudaStream_t& stream); +void cudaDevToHost( + void* trg, + const void* src, + const int& size, + const cudaStream_t& stream); + +/** + * This method takes a memory pointer and wraps it into a pytorch tensor. + * + * This is preferred over `torch::from_blob`, since that requires a CUDA + * managed pointer. However, working with these for high performance + * operations is slower. Most of the rendering operations should stay + * local to the respective GPU anyways, so unmanaged pointers are + * preferred. + */ +template +torch::Tensor from_blob( + const T* ptr, + const torch::IntArrayRef& shape, + const c10::DeviceType& device_type, + const c10::DeviceIndex& device_index, + const torch::Dtype& dtype, + const cudaStream_t& stream) { + torch::Tensor ret = torch::zeros( + shape, torch::device({device_type, device_index}).dtype(dtype)); + const int num_elements = + std::accumulate(shape.begin(), shape.end(), 1, std::multiplies{}); + if (device_type == c10::DeviceType::CUDA) { + cudaDevToDev( + ret.data_ptr(), + static_cast(ptr), + sizeof(T) * num_elements, + stream); + // TODO: check for synchronization. + } else { + memcpy(ret.data_ptr(), ptr, sizeof(T) * num_elements); + } + return ret; +}; + +} // namespace pytorch +} // namespace pulsar + +#endif diff --git a/pytorch3d/csrc/pulsar/warnings.cpp b/pytorch3d/csrc/pulsar/warnings.cpp new file mode 100644 index 00000000..0a875b2a --- /dev/null +++ b/pytorch3d/csrc/pulsar/warnings.cpp @@ -0,0 +1,14 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +#include "./global.h" +#include "./logging.h" + +/** + * A compilation unit to provide warnings about the code and avoid + * repeated messages. + */ +#ifdef PULSAR_ASSERTIONS +#pragma message("WARNING: assertions are enabled in Pulsar.") +#endif +#ifdef PULSAR_LOGGING_ENABLED +#pragma message("WARNING: logging is enabled in Pulsar.") +#endif diff --git a/pytorch3d/renderer/points/pulsar/__init__.py b/pytorch3d/renderer/points/pulsar/__init__.py new file mode 100644 index 00000000..383929f9 --- /dev/null +++ b/pytorch3d/renderer/points/pulsar/__init__.py @@ -0,0 +1,2 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +from .renderer import Renderer # noqa: F401 diff --git a/pytorch3d/renderer/points/pulsar/renderer.py b/pytorch3d/renderer/points/pulsar/renderer.py new file mode 100644 index 00000000..0e86d6aa --- /dev/null +++ b/pytorch3d/renderer/points/pulsar/renderer.py @@ -0,0 +1,692 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +"""pulsar renderer PyTorch integration. + +Proper Python support for pytorch requires creating a torch.autograd.function +(independent of whether this is being done within the C++ module). This is done +here and a torch.nn.Module is exposed for the use in more complex models. +""" +import logging +import math +import warnings +from typing import Optional, Tuple, Union + +import torch + +# pyre-fixme[21]: Could not find a name `_C` defined in module `pytorch3d`. +from pytorch3d import _C +from pytorch3d.transforms import axis_angle_to_matrix, rotation_6d_to_matrix + + +LOGGER = logging.getLogger(__name__) +GAMMA_WARNING_EMITTED = False +AXANGLE_WARNING_EMITTED = False + + +class _Render(torch.autograd.Function): + """ + Differentiable rendering function for the Pulsar renderer. + + Usually this will be used through the `Renderer` module, which takes care of + setting up the buffers and putting them on the correct device. If you use + the function directly, you will have to do this manually. + + The steps for this are two-fold: first, you need to create a native Renderer + object to provide the required buffers. This is the `native_renderer` parameter + for this function. You can create it by creating a `pytorch3d._C.PulsarRenderer` + object (with parameters for width, height and maximum number of balls it should + be able to render). This object by default resides on the CPU. If you want to + shift the buffers to a different device, just assign an empty tensor on the target + device to its property `device_tracker`. + + To convert camera parameters from a more convenient representation to the + required vectors as in this function, you can use the static + function `pytorch3d.renderer.points.pulsar.Renderer._transform_cam_params`. + + Args: + * ctx: Pytorch context. + * vert_pos: vertex positions. [Bx]Nx3 tensor of positions in 3D space. + * vert_col: vertex colors. [Bx]NxK tensor of channels. + * vert_rad: vertex radii. [Bx]N tensor of radiuses, >0. + * cam_pos: camera position(s). [Bx]3 tensor in 3D coordinates. + * pixel_0_0_center: [Bx]3 tensor center(s) of the upper left pixel(s) in + world coordinates. + * pixel_vec_x: [Bx]3 tensor from one pixel center to the next in image x + direction in world coordinates. + * pixel_vec_y: [Bx]3 tensor from one pixel center to the next in image y + direction in world coordinates. + * focal_length: [Bx]1 tensor of focal lengths in world coordinates. + * principal_point_offsets: [Bx]2 tensor of principal point offsets in pixels. + * gamma: sphere transparency in [1.,1E-5], with 1 being mostly transparent. + [Bx]1. + * max_depth: maximum depth for spheres to render. Set this as tighly + as possible to have good numerical accuracy for gradients. + * native_renderer: a `pytorch3d._C.PulsarRenderer` object. + * min_depth: a float with the minimum depth a sphere must have to be renderer. + Must be 0. or > max(focal_length). + * bg_col: K tensor with a background color to use or None (uses all ones). + * opacity: [Bx]N tensor of opacity values in [0., 1.] or None (uses all ones). + * percent_allowed_difference: a float in [0., 1.[ with the maximum allowed + difference in color space. This is used to speed up the + computation. Default: 0.01. + * max_n_hits: a hard limit on the number of hits per ray. Default: max int. + * mode: render mode in {0, 1}. 0: render an image; 1: render the hit map. + * return_forward_info: whether to return a second map. This second map contains + 13 channels: first channel contains sm_m (the maximum exponent factor + observed), the second sm_d (the normalization denominator, the sum of all + coefficients), the third the maximum closest possible intersection for a + hit. The following channels alternate with the float encoded integer index + of a sphere and its weight. They are the five spheres with the highest + color contribution to this pixel color, ordered descending. + + Returns: + * image: [Bx]HxWxK float tensor with the resulting image. + * forw_info: [Bx]HxWx13 float forward information as described above, + if enabled. + """ + + @staticmethod + def forward( + ctx, + vert_pos, + vert_col, + vert_rad, + cam_pos, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + focal_length, + principal_point_offsets, + gamma, + max_depth, + native_renderer, + min_depth=0.0, + bg_col=None, + opacity=None, + percent_allowed_difference=0.01, + max_n_hits=_C.MAX_UINT, + mode=0, + return_forward_info=False, + ) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + if mode != 0: + assert not return_forward_info, ( + "You are using a non-standard rendering mode. This does " + "not provide gradients, and also no `forward_info`. Please " + "set `return_forward_info` to `False`." + ) + ctx.gamma = gamma + ctx.max_depth = max_depth + ctx.min_depth = min_depth + ctx.percent_allowed_difference = percent_allowed_difference + ctx.max_n_hits = max_n_hits + ctx.mode = mode + ctx.native_renderer = native_renderer + image, info = ctx.native_renderer.forward( + vert_pos, + vert_col, + vert_rad, + cam_pos, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + focal_length, + principal_point_offsets, + gamma, + max_depth, + min_depth, + bg_col, + opacity, + percent_allowed_difference, + max_n_hits, + mode, + ) + if mode != 0: + # Backprop not possible! + info = None + # Prepare for backprop. + ctx.save_for_backward( + vert_pos, + vert_col, + vert_rad, + cam_pos, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + focal_length, + principal_point_offsets, + bg_col, + opacity, + image, + info, + ) + if return_forward_info: + return image, info + else: + return image + + @staticmethod + def backward(ctx, grad_im, *args): + global GAMMA_WARNING_EMITTED + ( + vert_pos, + vert_col, + vert_rad, + cam_pos, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + focal_length, + principal_point_offsets, + bg_col, + opacity, + image, + info, + ) = ctx.saved_tensors + if ( + ( + ctx.needs_input_grad[0] + or ctx.needs_input_grad[2] + or ctx.needs_input_grad[3] + or ctx.needs_input_grad[4] + or ctx.needs_input_grad[5] + or ctx.needs_input_grad[6] + or ctx.needs_input_grad[7] + ) + and ctx.gamma < 1e-3 + and not GAMMA_WARNING_EMITTED + ): + warnings.warn( + "Optimizing for non-color parameters and having a gamma value < 1E-3! " + "This is probably not going to produce usable gradients." + ) + GAMMA_WARNING_EMITTED = True + if ctx.mode == 0: + ( + grad_pos, + grad_col, + grad_rad, + grad_cam_pos, + grad_pixel_0_0_center, + grad_pixel_vec_x, + grad_pixel_vec_y, + grad_opacity, + ) = ctx.native_renderer.backward( + grad_im, + image, + info, + vert_pos, + vert_col, + vert_rad, + cam_pos, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + focal_length, + principal_point_offsets, + ctx.gamma, + ctx.max_depth, + ctx.min_depth, + bg_col, + opacity, + ctx.percent_allowed_difference, + ctx.max_n_hits, + ctx.mode, + ctx.needs_input_grad[0], + ctx.needs_input_grad[1], + ctx.needs_input_grad[2], + ctx.needs_input_grad[3] + or ctx.needs_input_grad[4] + or ctx.needs_input_grad[5] + or ctx.needs_input_grad[6], + ctx.needs_input_grad[13], + None, # No debug information provided. + ) + else: + raise ValueError( + "Performing a backward pass for a " + "rendering with `mode != 0`! This is not possible." + ) + return ( + grad_pos, + grad_col, + grad_rad, + grad_cam_pos, + grad_pixel_0_0_center, + grad_pixel_vec_x, + grad_pixel_vec_y, + None, # focal_length + None, # principal_point_offsets + None, # gamma + None, # max_depth + None, # native_renderer + None, # min_depth + None, # bg_col + grad_opacity, + None, # percent_allowed_difference + None, # max_n_hits + None, # mode + None, # return_forward_info + ) + + +class Renderer(torch.nn.Module): + """ + Differentiable rendering module for the Pulsar renderer. + + Set the maximum number of balls to a reasonable value. It is used to determine + several buffer sizes. It is no problem to render less balls than this number, + but never more. + + When optimizing for sphere positions, sphere radiuses or camera parameters you + have to use higher gamma values (closer to one) and larger sphere sizes: spheres + can only 'move' to areas that they cover, and only with higher gamma values exists + a gradient w.r.t. their color depending on their position. + + Args: + * width: result image width in pixels. + * height: result image height in pixels. + * max_num_balls: the maximum number of balls this renderer will handle. + * orthogonal_projection: use an orthogonal instead of perspective projection. + Default: False. + * right_handed_system: use a right-handed instead of a left-handed coordinate + system. This is relevant for compatibility with other drawing or scanning + systems. Pulsar by default assumes a left-handed world and camera coordinate + system as known from mathematics with x-axis to the right, y axis up and z + axis for increasing depth along the optical axis. In the image coordinate + system, only the y axis is pointing down, leading still to a left-handed + system. If you set this to True, it is assuming a right-handed world and + camera coordinate system with x axis to the right, y axis to the top and + z axis decreasing along the optical axis. Again, the image coordinate + system has a flipped y axis, remaining a right-handed system. + Default: False. + * background_normalized_depth: the normalized depth the background is placed + at. + This is on a scale from 0. to 1. between the specified min and max depth + (see the forward function). The value 0. is the most furthest depth whereas + 1. is the closest. Be careful when setting the background too far front - it + may hide elements in your scene. Default: EPS. + * n_channels: the number of image content channels to use. This is usually three + for regular color representations, but can be a higher or lower number. + Default: 3. + * n_track: the number of spheres to track for gradient calculation per pixel. + Only the closest n_track spheres will receive gradients. Default: 5. + """ + + def __init__( + self, + width: int, + height: int, + max_num_balls: int, + orthogonal_projection: bool = False, + right_handed_system: bool = False, + background_normalized_depth: float = _C.EPS, + n_channels: int = 3, + n_track: int = 5, + ): + super(Renderer, self).__init__() + # pyre-fixme[16]: Module `pytorch3d` has no attribute `_C`. + self._renderer = _C.PulsarRenderer( + width, + height, + max_num_balls, + orthogonal_projection, + right_handed_system, + background_normalized_depth, + n_channels, + n_track, + ) + self.register_buffer("device_tracker", torch.zeros(1)) + + @staticmethod + def sphere_ids_from_result_info_nograd(result_info: torch.Tensor) -> torch.Tensor: + """ + Get the sphere IDs from a result info tensor. + """ + if result_info.ndim == 3: + return Renderer.sphere_ids_from_result_info_nograd(result_info[None, ...]) + # pyre-fixme[16]: Module `pytorch3d` has no attribute `_C`. + return _C.pulsar_sphere_ids_from_result_info_nograd(result_info) + + @staticmethod + def depth_map_from_result_info_nograd(result_info: torch.Tensor) -> torch.Tensor: + """ + Get the depth map from a result info tensor. + + This returns a map of the same size as the image with just one channel + containing the closest intersection value at that position. Gradients + are not available for this tensor, but do note that you can use + `sphere_ids_from_result_info_nograd` to get the IDs of the spheres at + each position and directly create a loss on their depth if required. + + The depth map contains -1. at positions where no intersection has + been detected. + """ + return result_info[..., 4] + + @staticmethod + def _transform_cam_params( + cam_params: torch.Tensor, + width: int, + height: int, + orthogonal: bool, + right_handed: bool, + ) -> Tuple[ + torch.Tensor, + torch.Tensor, + torch.Tensor, + torch.Tensor, + torch.Tensor, + torch.Tensor, + ]: + """ + Transform 8 component camera parameter vector(s) to the internal camera + representation. + + The input vectors consists of: + * 3 components for camera position, + * 3 components for camera rotation (three rotation angles) or + 6 components as described in "On the Continuity of Rotation + Representations in Neural Networks" (Zhou et al.), + * focal length, + * the sensor width in world coordinates, + * [optional] the principal point offset in x and y. + + The sensor height is inferred by pixel size and sensor width to obtain + quadratic pixels. + + Args: + * cam_params: [Bx]{8, 10, 11, 13}, input tensors as described above. + * width: number of pixels in x direction. + * height: number of pixels in y direction. + * orthogonal: bool, whether an orthogonal projection is used + (does not use focal length). + * right_handed: bool, whether to use a right handed system + (negative z in camera direction). + + Returns: + * pos_vec: the position vector in 3D, + * pixel_0_0_center: the center of the upper left pixel in world coordinates, + * pixel_vec_x: the step to move one pixel on the image x axis + in world coordinates, + * pixel_vec_y: the step to move one pixel on the image y axis + in world coordinates, + * focal_length: the focal lengths, + * principal_point_offsets: the principal point offsets in x, y. + """ + global AXANGLE_WARNING_EMITTED + # Set up all direction vectors, i.e., the sensor direction of all axes. + assert width > 0 + assert height > 0 + batch_processing = True + if cam_params.ndimension() == 1: + batch_processing = False + cam_params = cam_params[None, :] + batch_size = cam_params.size(0) + continuous_rep = True + if cam_params.shape[1] in [8, 10]: + if cam_params.requires_grad and not AXANGLE_WARNING_EMITTED: + warnings.warn( + "Using an axis angle representation for camera rotations. " + "This has discontinuities and should not be used for optimization. " + "Alternatively, use a six-component representation as described in " + "'On the Continuity of Rotation Representations in Neural Networks'" + " (Zhou et al.). " + "The `pytorch3d.transforms` module provides " + "facilities for using this representation." + ) + AXANGLE_WARNING_EMITTED = True + continuous_rep = False + else: + assert cam_params.shape[1] in [11, 13] + pos_vec: torch.Tensor = cam_params[:, :3] + principal_point_offsets: torch.Tensor = torch.zeros( + (cam_params.shape[0], 2), dtype=torch.int32, device=cam_params.device + ) + if continuous_rep: + rot_vec = cam_params[:, 3:9] + focal_length: torch.Tensor = cam_params[:, 9:10] + sensor_size_x = cam_params[:, 10:11] + if cam_params.shape[1] == 13: + principal_point_offsets: torch.Tensor = cam_params[:, 11:13].to( + torch.int32 + ) + else: + rot_vec = cam_params[:, 3:6] + focal_length: torch.Tensor = cam_params[:, 6:7] + sensor_size_x = cam_params[:, 7:8] + if cam_params.shape[1] == 10: + principal_point_offsets: torch.Tensor = cam_params[:, 8:10].to( + torch.int32 + ) + # Always get quadratic pixels. + pixel_size_x = sensor_size_x / float(width) + sensor_size_y = height * pixel_size_x + LOGGER.debug( + "Camera position: %s, rotation: %s. Focal length: %s.", + str(pos_vec), + str(rot_vec), + str(focal_length), + ) + if continuous_rep: + rot_mat = rotation_6d_to_matrix(rot_vec) + else: + rot_mat = axis_angle_to_matrix(rot_vec) + sensor_dir_x = torch.matmul( + rot_mat, + torch.tensor( + [1.0, 0.0, 0.0], dtype=torch.float32, device=rot_mat.device + ).repeat(batch_size, 1)[:, :, None], + )[:, :, 0] + sensor_dir_y = torch.matmul( + rot_mat, + torch.tensor( + [0.0, -1.0, 0.0], dtype=torch.float32, device=rot_mat.device + ).repeat(batch_size, 1)[:, :, None], + )[:, :, 0] + sensor_dir_z = torch.matmul( + rot_mat, + torch.tensor( + [0.0, 0.0, 1.0], dtype=torch.float32, device=rot_mat.device + ).repeat(batch_size, 1)[:, :, None], + )[:, :, 0] + if right_handed: + sensor_dir_z *= -1 + LOGGER.debug( + "Sensor direction vectors: %s, %s, %s.", + str(sensor_dir_x), + str(sensor_dir_y), + str(sensor_dir_z), + ) + if orthogonal: + sensor_center = pos_vec + else: + sensor_center = pos_vec + focal_length * sensor_dir_z + LOGGER.debug("Sensor center: %s.", str(sensor_center)) + sensor_luc = ( # Sensor left upper corner. + sensor_center + - sensor_dir_x * (sensor_size_x / 2.0) + - sensor_dir_y * (sensor_size_y / 2.0) + ) + LOGGER.debug("Sensor luc: %s.", str(sensor_luc)) + pixel_size_x = sensor_size_x / float(width) + pixel_size_y = sensor_size_y / float(height) + LOGGER.debug( + "Pixel sizes (x): %s, (y) %s.", str(pixel_size_x), str(pixel_size_y) + ) + pixel_vec_x: torch.Tensor = sensor_dir_x * pixel_size_x + pixel_vec_y: torch.Tensor = sensor_dir_y * pixel_size_y + pixel_0_0_center = sensor_luc + 0.5 * pixel_vec_x + 0.5 * pixel_vec_y + LOGGER.debug( + "Pixel 0 centers: %s, vec x: %s, vec y: %s.", + str(pixel_0_0_center), + str(pixel_vec_x), + str(pixel_vec_y), + ) + if not orthogonal: + LOGGER.debug( + "Camera horizontal fovs: %s deg.", + str( + 2.0 + * torch.atan(0.5 * sensor_size_x / focal_length) + / math.pi + * 180.0 + ), + ) + LOGGER.debug( + "Camera vertical fovs: %s deg.", + str( + 2.0 + * torch.atan(0.5 * sensor_size_y / focal_length) + / math.pi + * 180.0 + ), + ) + # Reduce dimension. + focal_length: torch.Tensor = focal_length[:, 0] + if batch_processing: + return ( + pos_vec, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + focal_length, + principal_point_offsets, + ) + else: + return ( + pos_vec[0], + pixel_0_0_center[0], + pixel_vec_x[0], + pixel_vec_y[0], + focal_length[0], + principal_point_offsets[0], + ) + + def forward( + self, + vert_pos: torch.Tensor, + vert_col: torch.Tensor, + vert_rad: torch.Tensor, + cam_params: torch.Tensor, + gamma: float, + max_depth: float, + min_depth: float = 0.0, + bg_col: Optional[torch.Tensor] = None, + opacity: Optional[torch.Tensor] = None, + percent_allowed_difference: float = 0.01, + max_n_hits: int = _C.MAX_UINT, + mode: int = 0, + return_forward_info: bool = False, + ) -> Union[torch.Tensor, Tuple[torch.Tensor, Optional[torch.Tensor]]]: + """ + Rendering pass to create an image from the provided spheres and camera + parameters. + + Args: + * vert_pos: vertex positions. [Bx]Nx3 tensor of positions in 3D space. + * vert_col: vertex colors. [Bx]NxK tensor of channels. + * vert_rad: vertex radii. [Bx]N tensor of radiuses, >0. + * cam_params: camera parameter(s). [Bx]8 tensor, consisting of: + - 3 components for camera position, + - 3 components for camera rotation (axis angle representation) or + 6 components as described in "On the Continuity of Rotation + Representations in Neural Networks" (Zhou et al.), + - focal length, + - the sensor width in world coordinates, + - [optional] an offset for the principal point in x, y (no gradients). + * gamma: sphere transparency in [1.,1E-5], with 1 being mostly transparent. + [Bx]1. + * max_depth: maximum depth for spheres to render. Set this as tightly + as possible to have good numerical accuracy for gradients. + float > min_depth + eps. + * min_depth: a float with the minimum depth a sphere must have to be + rendered. Must be 0. or > max(focal_length) + eps. + * bg_col: K tensor with a background color to use or None (uses all ones). + * opacity: [Bx]N tensor of opacity values in [0., 1.] or None (uses all + ones). + * percent_allowed_difference: a float in [0., 1.[ with the maximum allowed + difference in color space. This is used to speed up the + computation. Default: 0.01. + * max_n_hits: a hard limit on the number of hits per ray. Default: max int. + * mode: render mode in {0, 1}. 0: render an image; 1: render the hit map. + * return_forward_info: whether to return a second map. This second map + contains 13 channels: first channel contains sm_m (the maximum + exponent factor observed), the second sm_d (the normalization + denominator, the sum of all coefficients), the third the maximum closest + possible intersection for a hit. The following channels alternate with + the float encoded integer index of a sphere and its weight. They are the + five spheres with the highest color contribution to this pixel color, + ordered descending. Default: False. + + Returns: + * image: [Bx]HxWx3 float tensor with the resulting image. + * forw_info: [Bx]HxWx13 float forward information as described above, if + enabled. + """ + # The device tracker is registered as buffer. + # pyre-fixme[16]: `Renderer` has no attribute `device_tracker`. + self._renderer.device_tracker = self.device_tracker + ( + pos_vec, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + focal_lengths, + principal_point_offsets, + ) = Renderer._transform_cam_params( + cam_params, + self._renderer.width, + self._renderer.height, + self._renderer.orthogonal, + self._renderer.right_handed, + ) + if ( + focal_lengths.min().item() > 0.0 + and max_depth > 10_000.0 * focal_lengths.min().item() + ): + warnings.warn( + ( + "Extreme ratio of `max_depth` vs. focal length detected " + "(%f vs. %f, ratio: %f). This will likely lead to " + "artifacts due to numerical instabilities." + ) + % ( + max_depth, + focal_lengths.min().item(), + max_depth / focal_lengths.min().item(), + ) + ) + # pyre-fixme[16]: `_Render` has no attribute `apply`. + ret_res = _Render.apply( + vert_pos, + vert_col, + vert_rad, + pos_vec, + pixel_0_0_center, + pixel_vec_x, + pixel_vec_y, + # Focal length and sensor size don't need gradients other than through + # `pixel_vec_x` and `pixel_vec_y`. The focal length is only used in the + # renderer to determine the projection areas of the balls. + focal_lengths, + # principal_point_offsets does not receive gradients. + principal_point_offsets, + gamma, + max_depth, + self._renderer, + min_depth, + bg_col, + opacity, + percent_allowed_difference, + max_n_hits, + mode, + (mode == 0) and return_forward_info, + ) + if return_forward_info and mode != 0: + return ret_res, None + return ret_res + + def extra_repr(self) -> str: + """Extra information to print in pytorch graphs.""" + return "width={}, height={}, max_num_balls={}".format( + self._renderer.width, self._renderer.height, self._renderer.max_num_balls + ) diff --git a/pytorch3d/transforms/__init__.py b/pytorch3d/transforms/__init__.py index b30b7fa1..2f0a0301 100644 --- a/pytorch3d/transforms/__init__.py +++ b/pytorch3d/transforms/__init__.py @@ -1,9 +1,13 @@ # Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +from .external.kornia_angle_axis_to_rotation_matrix import ( + angle_axis_to_rotation_matrix as axis_angle_to_matrix, +) from .rotation_conversions import ( euler_angles_to_matrix, matrix_to_euler_angles, matrix_to_quaternion, + matrix_to_rotation_6d, quaternion_apply, quaternion_invert, quaternion_multiply, @@ -12,6 +16,7 @@ from .rotation_conversions import ( random_quaternions, random_rotation, random_rotations, + rotation_6d_to_matrix, standardize_quaternion, ) from .so3 import ( diff --git a/pytorch3d/transforms/external/__init__.py b/pytorch3d/transforms/external/__init__.py new file mode 100644 index 00000000..40539064 --- /dev/null +++ b/pytorch3d/transforms/external/__init__.py @@ -0,0 +1 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. diff --git a/pytorch3d/transforms/external/kornia_angle_axis_to_rotation_matrix.py b/pytorch3d/transforms/external/kornia_angle_axis_to_rotation_matrix.py new file mode 100644 index 00000000..1269813a --- /dev/null +++ b/pytorch3d/transforms/external/kornia_angle_axis_to_rotation_matrix.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python3 +""" +This file contains the great angle axis to rotation matrix conversion +from kornia (https://github.com/arraiyopensource/kornia). The license +can be found in kornia_license.txt. + +The method is used unchanged; the documentation has been adjusted +to match our doc format. +""" +import torch + + +def angle_axis_to_rotation_matrix(angle_axis): + """Convert 3d vector of axis-angle rotation to 4x4 rotation matrix + + Args: + angle_axis (Tensor): tensor of 3d vector of axis-angle rotations. + + Returns: + Tensor: tensor of 3x3 rotation matrix. + + Shape: + - Input: :math:`(N, 3)` + - Output: :math:`(N, 3, 3)` + + Example: + + ..code-block::python + + >>> input = torch.rand(1, 3) # Nx3 + >>> output = tgm.angle_axis_to_rotation_matrix(input) # Nx3x3 + >>> output = tgm.angle_axis_to_rotation_matrix(input) # Nx3x3 + """ + + def _compute_rotation_matrix(angle_axis, theta2, eps=1e-6): + # We want to be careful to only evaluate the square root if the + # norm of the angle_axis vector is greater than zero. Otherwise + # we get a division by zero. + k_one = 1.0 + theta = torch.sqrt(theta2) + wxyz = angle_axis / (theta + eps) + wx, wy, wz = torch.chunk(wxyz, 3, dim=1) + cos_theta = torch.cos(theta) + sin_theta = torch.sin(theta) + + r00 = cos_theta + wx * wx * (k_one - cos_theta) + r10 = wz * sin_theta + wx * wy * (k_one - cos_theta) + r20 = -wy * sin_theta + wx * wz * (k_one - cos_theta) + r01 = wx * wy * (k_one - cos_theta) - wz * sin_theta + r11 = cos_theta + wy * wy * (k_one - cos_theta) + r21 = wx * sin_theta + wy * wz * (k_one - cos_theta) + r02 = wy * sin_theta + wx * wz * (k_one - cos_theta) + r12 = -wx * sin_theta + wy * wz * (k_one - cos_theta) + r22 = cos_theta + wz * wz * (k_one - cos_theta) + rotation_matrix = torch.cat( + [r00, r01, r02, r10, r11, r12, r20, r21, r22], dim=1 + ) + return rotation_matrix.view(-1, 3, 3) + + def _compute_rotation_matrix_taylor(angle_axis): + rx, ry, rz = torch.chunk(angle_axis, 3, dim=1) + k_one = torch.ones_like(rx) + rotation_matrix = torch.cat( + [k_one, -rz, ry, rz, k_one, -rx, -ry, rx, k_one], dim=1 + ) + return rotation_matrix.view(-1, 3, 3) + + # stolen from ceres/rotation.h + + _angle_axis = torch.unsqueeze(angle_axis + 1e-6, dim=1) + # _angle_axis.register_hook(lambda grad: pdb.set_trace()) + # _angle_axis = 1e-6 + theta2 = torch.matmul(_angle_axis, _angle_axis.transpose(1, 2)) + theta2 = torch.squeeze(theta2, dim=1) + + # compute rotation matrices + rotation_matrix_normal = _compute_rotation_matrix(angle_axis, theta2) + rotation_matrix_taylor = _compute_rotation_matrix_taylor(angle_axis) + + # create mask to handle both cases + eps = 1e-6 + mask = (theta2 > eps).view(-1, 1, 1).to(theta2.device) + mask_pos = (mask).type_as(theta2) + mask_neg = (mask == False).type_as(theta2) # noqa + + # create output pose matrix + batch_size = angle_axis.shape[0] + rotation_matrix = torch.eye(3).to(angle_axis.device).type_as(angle_axis) + rotation_matrix = rotation_matrix.view(1, 3, 3).repeat(batch_size, 1, 1) + # fill output matrix with masked values + rotation_matrix[..., :3, :3] = ( + mask_pos * rotation_matrix_normal + mask_neg * rotation_matrix_taylor + ) + return rotation_matrix.to(angle_axis.device).type_as(angle_axis) # Nx4x4 diff --git a/pytorch3d/transforms/external/kornia_license.txt b/pytorch3d/transforms/external/kornia_license.txt new file mode 100644 index 00000000..261eeb9e --- /dev/null +++ b/pytorch3d/transforms/external/kornia_license.txt @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/tests/bm_barycentric_clipping.py b/tests/bm_barycentric_clipping.py index df72987e..d55c3c0c 100644 --- a/tests/bm_barycentric_clipping.py +++ b/tests/bm_barycentric_clipping.py @@ -110,3 +110,7 @@ def bm_barycentric_clip() -> None: benchmark(baryclip_cuda, "BARY_CLIP_CUDA", kwargs_list, warmup_iters=1) benchmark(baryclip_pytorch, "BARY_CLIP_PYTORCH", kwargs_list, warmup_iters=1) + + +if __name__ == "__main__": + bm_barycentric_clip() diff --git a/tests/bm_blending.py b/tests/bm_blending.py index 16aa11bc..7febc7ad 100644 --- a/tests/bm_blending.py +++ b/tests/bm_blending.py @@ -42,3 +42,7 @@ def bm_blending() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_blending() diff --git a/tests/bm_cameras_alignment.py b/tests/bm_cameras_alignment.py index 4d0c0397..128cc9c8 100644 --- a/tests/bm_cameras_alignment.py +++ b/tests/bm_cameras_alignment.py @@ -22,3 +22,7 @@ def bm_cameras_alignment() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_cameras_alignment() diff --git a/tests/bm_chamfer.py b/tests/bm_chamfer.py index 4de5829e..5cdee080 100644 --- a/tests/bm_chamfer.py +++ b/tests/bm_chamfer.py @@ -8,6 +8,8 @@ from test_chamfer import TestChamfer def bm_chamfer() -> None: + # Currently disabled. + return devices = ["cpu"] if torch.cuda.is_available(): devices.append("cuda:0") @@ -53,3 +55,7 @@ def bm_chamfer() -> None: } ) benchmark(TestChamfer.chamfer_with_init, "CHAMFER", kwargs_list, warmup_iters=1) + + +if __name__ == "__main__": + bm_chamfer() diff --git a/tests/bm_cubify.py b/tests/bm_cubify.py index 239b1e69..632a1751 100644 --- a/tests/bm_cubify.py +++ b/tests/bm_cubify.py @@ -11,3 +11,7 @@ def bm_cubify() -> None: {"batch_size": 16, "V": 32}, ] benchmark(TestCubify.cubify_with_init, "CUBIFY", kwargs_list, warmup_iters=1) + + +if __name__ == "__main__": + bm_cubify() diff --git a/tests/bm_face_areas_normals.py b/tests/bm_face_areas_normals.py index 0a01441f..66f85c23 100644 --- a/tests/bm_face_areas_normals.py +++ b/tests/bm_face_areas_normals.py @@ -37,3 +37,7 @@ def bm_face_areas_normals() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_face_areas_normals() diff --git a/tests/bm_graph_conv.py b/tests/bm_graph_conv.py index 404c44a4..bf77b8b5 100644 --- a/tests/bm_graph_conv.py +++ b/tests/bm_graph_conv.py @@ -40,3 +40,7 @@ def bm_graph_conv() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_graph_conv() diff --git a/tests/bm_interpolate_face_attributes.py b/tests/bm_interpolate_face_attributes.py index 60fb8d1c..f721eead 100644 --- a/tests/bm_interpolate_face_attributes.py +++ b/tests/bm_interpolate_face_attributes.py @@ -74,3 +74,7 @@ def bm_interpolate_face_attribues() -> None: kwargs_list.append({"N": N, "S": S, "K": K, "F": F, "D": D, "impl": impl}) benchmark(_bm_forward, "FORWARD", kwargs_list, warmup_iters=3) benchmark(_bm_forward_backward, "FORWARD+BACKWARD", kwargs_list, warmup_iters=3) + + +if __name__ == "__main__": + bm_interpolate_face_attribues() diff --git a/tests/bm_knn.py b/tests/bm_knn.py index 4a96d64b..5a894a22 100644 --- a/tests/bm_knn.py +++ b/tests/bm_knn.py @@ -24,3 +24,7 @@ def bm_knn() -> None: benchmark(TestKNN.knn_square, "KNN_SQUARE", kwargs_list, warmup_iters=1) benchmark(TestKNN.knn_ragged, "KNN_RAGGED", kwargs_list, warmup_iters=1) + + +if __name__ == "__main__": + bm_knn() diff --git a/tests/bm_lighting.py b/tests/bm_lighting.py index a98d0ed1..cc9fcb88 100644 --- a/tests/bm_lighting.py +++ b/tests/bm_lighting.py @@ -45,3 +45,7 @@ def bm_lighting() -> None: kwargs_list.append({"N": N, "S": S, "K": K}) benchmark(_bm_diffuse_cuda_with_init, "DIFFUSE", kwargs_list, warmup_iters=3) benchmark(_bm_specular_cuda_with_init, "SPECULAR", kwargs_list, warmup_iters=3) + + +if __name__ == "__main__": + bm_lighting() diff --git a/tests/bm_main.py b/tests/bm_main.py index f178ef98..26665092 100755 --- a/tests/bm_main.py +++ b/tests/bm_main.py @@ -2,8 +2,10 @@ # Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. import glob -import importlib -from os.path import basename, dirname, isfile, join, sys +import os +import subprocess +import sys +from os.path import dirname, isfile, join if __name__ == "__main__": @@ -11,20 +13,22 @@ if __name__ == "__main__": if len(sys.argv) > 1: # Parse from flags. # pyre-ignore[16] - module_names = [n for n in sys.argv if n.startswith("bm_")] + file_names = [ + join(dirname(__file__), n) for n in sys.argv if n.startswith("bm_") + ] else: # Get all the benchmark files (starting with "bm_"). bm_files = glob.glob(join(dirname(__file__), "bm_*.py")) - module_names = [ - basename(f)[:-3] - for f in bm_files - if isfile(f) and not f.endswith("bm_main.py") - ] + file_names = sorted( + f for f in bm_files if isfile(f) and not f.endswith("bm_main.py") + ) - for module_name in module_names: - module = importlib.import_module(module_name) - for attr in dir(module): - # Run all the functions with names "bm_*" in the module. - if attr.startswith("bm_"): - print("Running benchmarks for " + module_name + "/" + attr + "...") - getattr(module, attr)() + # Forward all important path information to the subprocesses through the + # environment. + os.environ["PATH"] = sys.path[0] + ":" + os.environ.get("PATH", "") + os.environ["LD_LIBRARY_PATH"] = ( + sys.path[0] + ":" + os.environ.get("LD_LIBRARY_PATH", "") + ) + os.environ["PYTHONPATH"] = ":".join(sys.path) + for file_name in file_names: + subprocess.check_call([sys.executable, file_name]) diff --git a/tests/bm_mesh_edge_loss.py b/tests/bm_mesh_edge_loss.py index b7a9566b..4410b0fb 100644 --- a/tests/bm_mesh_edge_loss.py +++ b/tests/bm_mesh_edge_loss.py @@ -19,3 +19,7 @@ def bm_mesh_edge_loss() -> None: benchmark( TestMeshEdgeLoss.mesh_edge_loss, "MESH_EDGE_LOSS", kwargs_list, warmup_iters=1 ) + + +if __name__ == "__main__": + bm_mesh_edge_loss() diff --git a/tests/bm_mesh_io.py b/tests/bm_mesh_io.py index 15719813..a8f43be2 100644 --- a/tests/bm_mesh_io.py +++ b/tests/bm_mesh_io.py @@ -95,3 +95,7 @@ def bm_save_load() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_save_load() diff --git a/tests/bm_mesh_laplacian_smoothing.py b/tests/bm_mesh_laplacian_smoothing.py index 44eeec2a..7a3bd337 100644 --- a/tests/bm_mesh_laplacian_smoothing.py +++ b/tests/bm_mesh_laplacian_smoothing.py @@ -30,3 +30,7 @@ def bm_mesh_laplacian_smoothing() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_mesh_laplacian_smoothing() diff --git a/tests/bm_mesh_normal_consistency.py b/tests/bm_mesh_normal_consistency.py index 2d69c76d..f6f48699 100644 --- a/tests/bm_mesh_normal_consistency.py +++ b/tests/bm_mesh_normal_consistency.py @@ -27,3 +27,7 @@ def bm_mesh_normal_consistency() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_mesh_normal_consistency() diff --git a/tests/bm_mesh_rasterizer_transform.py b/tests/bm_mesh_rasterizer_transform.py index 0d875f3f..c21346b2 100644 --- a/tests/bm_mesh_rasterizer_transform.py +++ b/tests/bm_mesh_rasterizer_transform.py @@ -43,3 +43,7 @@ def bm_mesh_rasterizer_transform() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_mesh_rasterizer_transform() diff --git a/tests/bm_meshes.py b/tests/bm_meshes.py index 66c4178e..bd14340a 100644 --- a/tests/bm_meshes.py +++ b/tests/bm_meshes.py @@ -33,3 +33,7 @@ def bm_compute_packed_padded_meshes() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_compute_packed_padded_meshes() diff --git a/tests/bm_packed_to_padded.py b/tests/bm_packed_to_padded.py index ff597a21..5a8f9122 100644 --- a/tests/bm_packed_to_padded.py +++ b/tests/bm_packed_to_padded.py @@ -38,3 +38,7 @@ def bm_packed_to_padded() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_packed_to_padded() diff --git a/tests/bm_perspective_n_points.py b/tests/bm_perspective_n_points.py index 75d77a37..c8f3e1b6 100644 --- a/tests/bm_perspective_n_points.py +++ b/tests/bm_perspective_n_points.py @@ -23,3 +23,7 @@ def bm_perspective_n_points() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_perspective_n_points() diff --git a/tests/bm_point_mesh_distance.py b/tests/bm_point_mesh_distance.py index 2f96b461..494806c7 100644 --- a/tests/bm_point_mesh_distance.py +++ b/tests/bm_point_mesh_distance.py @@ -34,3 +34,7 @@ def bm_point_mesh_distance() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_point_mesh_distance() diff --git a/tests/bm_pointclouds.py b/tests/bm_pointclouds.py index a214ce2f..86362514 100644 --- a/tests/bm_pointclouds.py +++ b/tests/bm_pointclouds.py @@ -28,3 +28,7 @@ def bm_compute_packed_padded_pointclouds() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_compute_packed_padded_pointclouds() diff --git a/tests/bm_points_alignment.py b/tests/bm_points_alignment.py index 39e5bb9a..559b1c8c 100644 --- a/tests/bm_points_alignment.py +++ b/tests/bm_points_alignment.py @@ -69,3 +69,8 @@ def bm_corresponding_points_alignment() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_corresponding_points_alignment() + bm_iterative_closest_point() diff --git a/tests/bm_pulsar.py b/tests/bm_pulsar.py new file mode 100755 index 00000000..6dfbe9f9 --- /dev/null +++ b/tests/bm_pulsar.py @@ -0,0 +1,121 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +"""Test render speed.""" +import logging +import sys +from os import path + +import torch +from fvcore.common.benchmark import benchmark +from pytorch3d.renderer.points.pulsar import Renderer +from torch.autograd import Variable + + +# Making sure you can run this, even if pulsar hasn't been installed yet. +sys.path.insert(0, path.join(path.dirname(__file__), "..")) +LOGGER = logging.getLogger(__name__) + + +"""Measure the execution speed of the rendering. + +This measures a very pessimistic upper bound on speed, because synchronization +points have to be introduced in Python. On a pure PyTorch execution pipeline, +results should be significantly faster. You can get pure CUDA timings through +C++ by activating `PULSAR_TIMINGS_BATCHED_ENABLED` in the file +`pytorch3d/csrc/pulsar/logging.h` or defining it for your compiler. +""" + + +def _bm_pulsar(): + n_points = 1_000_000 + width = 1_000 + height = 1_000 + renderer = Renderer(width, height, n_points) + # Generate sample data. + torch.manual_seed(1) + vert_pos = torch.rand(n_points, 3, dtype=torch.float32) * 10.0 + vert_pos[:, 2] += 25.0 + vert_pos[:, :2] -= 5.0 + vert_col = torch.rand(n_points, 3, dtype=torch.float32) + vert_rad = torch.rand(n_points, dtype=torch.float32) + cam_params = torch.tensor( + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.0, 2.0], dtype=torch.float32 + ) + device = torch.device("cuda") + vert_pos = vert_pos.to(device) + vert_col = vert_col.to(device) + vert_rad = vert_rad.to(device) + cam_params = cam_params.to(device) + renderer = renderer.to(device) + vert_pos_var = Variable(vert_pos, requires_grad=False) + vert_col_var = Variable(vert_col, requires_grad=False) + vert_rad_var = Variable(vert_rad, requires_grad=False) + cam_params_var = Variable(cam_params, requires_grad=False) + + def bm_closure(): + renderer.forward( + vert_pos_var, + vert_col_var, + vert_rad_var, + cam_params_var, + 1.0e-1, + 45.0, + percent_allowed_difference=0.01, + ) + torch.cuda.synchronize() + + return bm_closure + + +def _bm_pulsar_backward(): + n_points = 1_000_000 + width = 1_000 + height = 1_000 + renderer = Renderer(width, height, n_points) + # Generate sample data. + torch.manual_seed(1) + vert_pos = torch.rand(n_points, 3, dtype=torch.float32) * 10.0 + vert_pos[:, 2] += 25.0 + vert_pos[:, :2] -= 5.0 + vert_col = torch.rand(n_points, 3, dtype=torch.float32) + vert_rad = torch.rand(n_points, dtype=torch.float32) + cam_params = torch.tensor( + [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 5.0, 2.0], dtype=torch.float32 + ) + device = torch.device("cuda") + vert_pos = vert_pos.to(device) + vert_col = vert_col.to(device) + vert_rad = vert_rad.to(device) + cam_params = cam_params.to(device) + renderer = renderer.to(device) + vert_pos_var = Variable(vert_pos, requires_grad=True) + vert_col_var = Variable(vert_col, requires_grad=True) + vert_rad_var = Variable(vert_rad, requires_grad=True) + cam_params_var = Variable(cam_params, requires_grad=True) + res = renderer.forward( + vert_pos_var, + vert_col_var, + vert_rad_var, + cam_params_var, + 1.0e-1, + 45.0, + percent_allowed_difference=0.01, + ) + loss = res.sum() + + def bm_closure(): + loss.backward(retain_graph=True) + torch.cuda.synchronize() + + return bm_closure + + +def bm_pulsar() -> None: + if not torch.cuda.is_available(): + return + + benchmark(_bm_pulsar, "PULSAR_FORWARD", [{}], warmup_iters=3) + benchmark(_bm_pulsar_backward, "PULSAR_BACKWARD", [{}], warmup_iters=3) + + +if __name__ == "__main__": + bm_pulsar() diff --git a/tests/bm_rasterize_meshes.py b/tests/bm_rasterize_meshes.py index 68832c1c..fe596e5d 100644 --- a/tests/bm_rasterize_meshes.py +++ b/tests/bm_rasterize_meshes.py @@ -85,3 +85,7 @@ def bm_rasterize_meshes() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_rasterize_meshes() diff --git a/tests/bm_rasterize_points.py b/tests/bm_rasterize_points.py index 0deb3ef2..d00e45ac 100644 --- a/tests/bm_rasterize_points.py +++ b/tests/bm_rasterize_points.py @@ -80,3 +80,7 @@ def bm_python_vs_cpu_vs_cuda() -> None: benchmark( _bm_rasterize_points_with_init, "RASTERIZE_CUDA", kwargs_list, warmup_iters=1 ) + + +if __name__ == "__main__": + bm_python_vs_cpu_vs_cuda() diff --git a/tests/bm_sample_points_from_meshes.py b/tests/bm_sample_points_from_meshes.py index 0b8dbadd..630b4a76 100644 --- a/tests/bm_sample_points_from_meshes.py +++ b/tests/bm_sample_points_from_meshes.py @@ -36,3 +36,7 @@ def bm_sample_points() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_sample_points() diff --git a/tests/bm_so3.py b/tests/bm_so3.py index 9d7ebaa0..6762e2e5 100644 --- a/tests/bm_so3.py +++ b/tests/bm_so3.py @@ -13,3 +13,7 @@ def bm_so3() -> None: ] benchmark(TestSO3.so3_expmap, "SO3_EXP", kwargs_list, warmup_iters=1) benchmark(TestSO3.so3_logmap, "SO3_LOG", kwargs_list, warmup_iters=1) + + +if __name__ == "__main__": + bm_so3() diff --git a/tests/bm_subdivide_meshes.py b/tests/bm_subdivide_meshes.py index c4e5b2bc..e74fc09c 100644 --- a/tests/bm_subdivide_meshes.py +++ b/tests/bm_subdivide_meshes.py @@ -21,3 +21,7 @@ def bm_subdivide() -> None: kwargs_list, warmup_iters=1, ) + + +if __name__ == "__main__": + bm_subdivide() diff --git a/tests/bm_vert_align.py b/tests/bm_vert_align.py index 9b695428..092d5dd2 100644 --- a/tests/bm_vert_align.py +++ b/tests/bm_vert_align.py @@ -27,3 +27,7 @@ def bm_vert_align() -> None: benchmark( TestVertAlign.vert_align_with_init, "VERT_ALIGN", kwargs_list, warmup_iters=1 ) + + +if __name__ == "__main__": + bm_vert_align() diff --git a/tests/pulsar/__init__.py b/tests/pulsar/__init__.py new file mode 100644 index 00000000..40539064 --- /dev/null +++ b/tests/pulsar/__init__.py @@ -0,0 +1 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. diff --git a/tests/pulsar/create_multiview.py b/tests/pulsar/create_multiview.py new file mode 100644 index 00000000..e060c69c --- /dev/null +++ b/tests/pulsar/create_multiview.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +"""Create multiview data.""" +import sys +from os import path + + +# Making sure you can run this, even if pulsar hasn't been installed yet. +sys.path.insert(0, path.join(path.dirname(__file__), "..", "..")) + + +def create_multiview(): + """Test multiview optimization.""" + from pytorch3d.renderer.points.pulsar import Renderer + import torch + from torch import nn + import imageio + from torch.autograd import Variable + + # import cv2 + # import skvideo.io + import numpy as np + + # Constructor. + n_points = 10 + width = 1000 + height = 1000 + + class Model(nn.Module): + """A dummy model to test the integration into a stacked model.""" + + def __init__(self): + super(Model, self).__init__() + self.gamma = 0.1 + self.renderer = Renderer(width, height, n_points) + + def forward(self, vp, vc, vr, cam_params): + # self.gamma *= 0.995 + # print("gamma: ", self.gamma) + return self.renderer.forward(vp, vc, vr, cam_params, self.gamma, 45.0) + + # Generate sample data. + torch.manual_seed(1) + vert_pos = torch.rand(n_points, 3, dtype=torch.float32) * 10.0 + vert_pos[:, 2] += 25.0 + vert_pos[:, :2] -= 5.0 + # print(vert_pos[0]) + vert_col = torch.rand(n_points, 3, dtype=torch.float32) + vert_rad = torch.rand(n_points, dtype=torch.float32) + + # Distortion. + # vert_pos[:, 1] += 0.5 + vert_col *= 0.5 + # vert_rad *= 0.7 + + for device in [torch.device("cuda")]: + model = Model().to(device) + vert_pos = vert_pos.to(device) + vert_col = vert_col.to(device) + vert_rad = vert_rad.to(device) + for angle_idx, angle in enumerate([-1.5, -0.8, -0.4, -0.1, 0.1, 0.4, 0.8, 1.5]): + vert_pos_v = Variable(vert_pos, requires_grad=False) + vert_col_v = Variable(vert_col, requires_grad=False) + vert_rad_v = Variable(vert_rad, requires_grad=False) + cam_params = torch.tensor( + [ + np.sin(angle) * 35.0, + 0.0, + 30.0 - np.cos(angle) * 35.0, + 0.0, + -angle, + 0.0, + 5.0, + 2.0, + ], + dtype=torch.float32, + ).to(device) + cam_params_v = Variable(cam_params, requires_grad=False) + result = model.forward(vert_pos_v, vert_col_v, vert_rad_v, cam_params_v) + result_im = (result.cpu().detach().numpy() * 255).astype(np.uint8) + imageio.imsave( + "reference/examples_TestRenderer_test_multiview_%d.png" % (angle_idx), + result_im, + ) + + +if __name__ == "__main__": + create_multiview() diff --git a/tests/pulsar/reference/examples_TestRenderer_test_cam.png b/tests/pulsar/reference/examples_TestRenderer_test_cam.png new file mode 100644 index 0000000000000000000000000000000000000000..836aaa4bef63c7bea1945f6234a35abe52fd9493 GIT binary patch literal 112613 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
}kxrYu=S2-5vir)8-RU>BysVy)T18 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

ZM6u^t(~?)=FpNE^69jhHhoF-xL87< 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 AJpcdz literal 0 HcmV?d00001 diff --git a/tests/pulsar/reference/examples_TestRenderer_test_multiview_0.png b/tests/pulsar/reference/examples_TestRenderer_test_multiview_0.png new file mode 100644 index 0000000000000000000000000000000000000000..f26e27adcb6bec1d817fbfa1f77dd90a9a3908e3 GIT binary patch literal 52316 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 literal 0 HcmV?d00001 diff --git a/tests/pulsar/reference/examples_TestRenderer_test_multiview_1.png b/tests/pulsar/reference/examples_TestRenderer_test_multiview_1.png new file mode 100644 index 0000000000000000000000000000000000000000..3973792ba318b99246a983cec44aa66957945ca3 GIT binary patch literal 52282 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 KgUTDfJ^4TUsuuVF literal 0 HcmV?d00001 diff --git a/tests/pulsar/reference/examples_TestRenderer_test_multiview_2.png b/tests/pulsar/reference/examples_TestRenderer_test_multiview_2.png new file mode 100644 index 0000000000000000000000000000000000000000..9d6c1e1280d2fac034c188d72dae193882bd1c9f GIT binary patch literal 52061 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≦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

S2@f7u43*KGTo+XwgqIQ; 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 literal 0 HcmV?d00001 diff --git a/tests/pulsar/reference/examples_TestRenderer_test_multiview_3.png b/tests/pulsar/reference/examples_TestRenderer_test_multiview_3.png new file mode 100644 index 0000000000000000000000000000000000000000..e9fabd786533836a26d0149dcd3f8268cd362b11 GIT binary patch literal 52066 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 z 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 literal 0 HcmV?d00001 diff --git a/tests/pulsar/reference/examples_TestRenderer_test_multiview_7.png b/tests/pulsar/reference/examples_TestRenderer_test_multiview_7.png new file mode 100644 index 0000000000000000000000000000000000000000..9af131e4070a4a0e87b5ee5183b6da2733560dae GIT binary patch literal 53702 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

eZVm{$R%DzicP5 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 !3rS)26Y{=NZHqGw$QZT99> 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 EKc{*%+5i9m literal 0 HcmV?d00001 diff --git a/tests/pulsar/reference/nr0000-in.pth b/tests/pulsar/reference/nr0000-in.pth new file mode 100644 index 0000000000000000000000000000000000000000..c89dd9f15d7625d5d218da706dfed0a01bae94eb GIT binary patch literal 1186356 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

vha}_E

b!d&T_ei8%folA&Iia_Wg!#)*@e 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