more code blocks for readthedocs

Summary: More rst syntax fixes

Reviewed By: davidsonic

Differential Revision: D40977328

fbshipit-source-id: a3a3accbf2ba7cd9c84a0a82d0265010764a9d61

Author: bottler

pytorch3d/io/pluggable.py

@@ -25,19 +25,16 @@
 The main usage is via the IO object, and its methods
 `load_mesh`, `save_mesh`, `load_pointcloud` and `save_pointcloud`.
 
-For example, to load a mesh you might do
-```
-from pytorch3d.io import IO
+For example, to load a mesh you might do::
 
-mesh = IO().load_mesh("mymesh.obj")
-```
+    from pytorch3d.io import IO
 
-and to save a point cloud you might do
+    mesh = IO().load_mesh("mymesh.obj")
 
-```
-pcl = Pointclouds(...)
-IO().save_pointcloud(pcl, "output_pointcloud.obj")
-```
+and to save a point cloud you might do::
+
+    pcl = Pointclouds(...)
+    IO().save_pointcloud(pcl, "output_pointcloud.obj")
 
 """
 

pytorch3d/io/ply_io.py

@@ -1067,33 +1067,33 @@ def load_ply(
     is to use the IO.load_mesh and IO.load_pointcloud functions,
     which can read more of the data.
 
-    Example .ply file format:
-
-    ply
-    format ascii 1.0           { ascii/binary, format version number }
-    comment made by Greg Turk  { comments keyword specified, like all lines }
-    comment this file is a cube
-    element vertex 8           { define "vertex" element, 8 of them in file }
-    property float x           { vertex contains float "x" coordinate }
-    property float y           { y coordinate is also a vertex property }
-    property float z           { z coordinate, too }
-    element face 6             { there are 6 "face" elements in the file }
-    property list uchar int vertex_index { "vertex_indices" is a list of ints }
-    end_header                 { delimits the end of the header }
-    0 0 0                      { start of vertex list }
-    0 0 1
-    0 1 1
-    0 1 0
-    1 0 0
-    1 0 1
-    1 1 1
-    1 1 0
-    4 0 1 2 3                  { start of face list }
-    4 7 6 5 4
-    4 0 4 5 1
-    4 1 5 6 2
-    4 2 6 7 3
-    4 3 7 4 0
+    Example .ply file format::
+
+        ply
+        format ascii 1.0           { ascii/binary, format version number }
+        comment made by Greg Turk  { comments keyword specified, like all lines }
+        comment this file is a cube
+        element vertex 8           { define "vertex" element, 8 of them in file }
+        property float x           { vertex contains float "x" coordinate }
+        property float y           { y coordinate is also a vertex property }
+        property float z           { z coordinate, too }
+        element face 6             { there are 6 "face" elements in the file }
+        property list uchar int vertex_index { "vertex_indices" is a list of ints }
+        end_header                 { delimits the end of the header }
+        0 0 0                      { start of vertex list }
+        0 0 1
+        0 1 1
+        0 1 0
+        1 0 0
+        1 0 1
+        1 1 1
+        1 1 0
+        4 0 1 2 3                  { start of face list }
+        4 7 6 5 4
+        4 0 4 5 1
+        4 1 5 6 2
+        4 2 6 7 3
+        4 3 7 4 0
 
     Args:
         f:  A binary or text file-like object (with methods read, readline,

pytorch3d/ops/points_to_volumes.py

@@ -208,8 +208,8 @@ def add_pointclouds_to_volumes(
     of `initial_volumes` with its `features` and `densities` updated with the
     result of the pointcloud addition.
 
-    Example:
-        ```
+    Example::
+
         # init a random point cloud
         pointclouds = Pointclouds(
             points=torch.randn(4, 100, 3), features=torch.rand(4, 100, 5)
@@ -229,7 +229,6 @@ def add_pointclouds_to_volumes(
             initial_volumes=initial_volumes,
             mode="trilinear",
         )
-        ```
 
     Args:
         pointclouds: Batch of 3D pointclouds represented with a `Pointclouds`

pytorch3d/renderer/implicit/harmonic_embedding.py

@@ -21,8 +21,8 @@ def __init__(
         (i.e. vector along the last dimension) in `x`
         into a series of harmonic features `embedding`,
         where for each i in range(dim) the following are present
-        in embedding[...]:
-            ```
+        in embedding[...]::
+
             [
                 sin(f_1*x[..., i]),
                 sin(f_2*x[..., i]),
@@ -34,7 +34,7 @@ def __init__(
                 cos(f_N * x[..., i]),
                 x[..., i],              # only present if append_input is True.
             ]
-            ```
+
         where N corresponds to `n_harmonic_functions-1`, and f_i is a scalar
         denoting the i-th frequency of the harmonic embedding.
 

pytorch3d/renderer/implicit/raymarching.py

@@ -25,20 +25,20 @@ class EmissionAbsorptionRaymarcher(torch.nn.Module):
     (i.e. its density -> 1.0).
 
     EA first utilizes `rays_densities` to compute the absorption function
-    along each ray as follows:
-        ```
+    along each ray as follows::
+
         absorption = cumprod(1 - rays_densities, dim=-1)
-        ```
+
     The value of absorption at position `absorption[..., k]` specifies
     how much light has reached `k`-th point along a ray since starting
     its trajectory at `k=0`-th point.
 
     Each ray is then rendered into a tensor `features` of shape `(..., feature_dim)`
-    by taking a weighed combination of per-ray features `rays_features` as follows:
-        ```
+    by taking a weighed combination of per-ray features `rays_features` as follows::
+
         weights = absorption * rays_densities
         features = (rays_features * weights).sum(dim=-2)
-        ```
+
     Where `weights` denote a function that has a strong peak around the location
     of the first surface point that a given ray passes through.
 

pytorch3d/renderer/implicit/raysampling.py

@@ -32,23 +32,22 @@ class MultinomialRaysampler(torch.nn.Module):
     have uniformly-spaced z-coordinates between a predefined
     minimum and maximum depth.
 
-    The raysampler first generates a 3D coordinate grid of the following form:
-    ```
-       / min_x, min_y, max_depth -------------- / max_x, min_y, max_depth
-      /                                        /|
-     /                                        / |     ^
-    / min_depth                    min_depth /  |     |
-    min_x ----------------------------- max_x   |     | image
-    min_y                               min_y   |     | height
-    |                                       |   |     |
-    |                                       |   |     v
-    |                                       |   |
-    |                                       |   / max_x, max_y,     ^
-    |                                       |  /  max_depth        /
-    min_x                               max_y /                   / n_pts_per_ray
-    max_y ----------------------------- max_x/ min_depth         v
-              < --- image_width --- >
-    ```
+    The raysampler first generates a 3D coordinate grid of the following form::
+
+           / min_x, min_y, max_depth -------------- / max_x, min_y, max_depth
+          /                                        /|
+         /                                        / |     ^
+        / min_depth                    min_depth /  |     |
+        min_x ----------------------------- max_x   |     | image
+        min_y                               min_y   |     | height
+        |                                       |   |     |
+        |                                       |   |     v
+        |                                       |   |
+        |                                       |   / max_x, max_y,     ^
+        |                                       |  /  max_depth        /
+        min_x                               max_y /                   / n_pts_per_ray
+        max_y ----------------------------- max_x/ min_depth         v
+                < --- image_width --- >
 
     In order to generate ray points, `MultinomialRaysampler` takes each 3D point of
     the grid (with coordinates `[x, y, depth]`) and unprojects it

pytorch3d/renderer/implicit/renderer.py

@@ -41,13 +41,13 @@ class ImplicitRenderer(torch.nn.Module):
     as well as the `volumetric_function` `Callable`, which defines a field of opacity
     and feature vectors over the 3D domain of the scene.
 
-    A standard `volumetric_function` has the following signature:
-    ```
-    def volumetric_function(
-        ray_bundle: Union[RayBundle, HeterogeneousRayBundle],
-        **kwargs,
-    ) -> Tuple[torch.Tensor, torch.Tensor]
-    ```
+    A standard `volumetric_function` has the following signature::
+
+        def volumetric_function(
+            ray_bundle: Union[RayBundle, HeterogeneousRayBundle],
+            **kwargs,
+        ) -> Tuple[torch.Tensor, torch.Tensor]
+
     With the following arguments:
         `ray_bundle`: A RayBundle or HeterogeneousRayBundle object
             containing the following variables:
@@ -79,32 +79,32 @@ def volumetric_function(
 
     Example:
         A simple volumetric function of a 0-centered
-        RGB sphere with a unit diameter is defined as follows:
-        ```
-        def volumetric_function(
-            ray_bundle: Union[RayBundle, HeterogeneousRayBundle],
-            **kwargs,
-        ) -> Tuple[torch.Tensor, torch.Tensor]:
+        RGB sphere with a unit diameter is defined as follows::
 
-            # first convert the ray origins, directions and lengths
-            # to 3D ray point locations in world coords
-            rays_points_world = ray_bundle_to_ray_points(ray_bundle)
+            def volumetric_function(
+                ray_bundle: Union[RayBundle, HeterogeneousRayBundle],
+                **kwargs,
+            ) -> Tuple[torch.Tensor, torch.Tensor]:
 
-            # set the densities as an inverse sigmoid of the
-            # ray point distance from the sphere centroid
-            rays_densities = torch.sigmoid(
-                -100.0 * rays_points_world.norm(dim=-1, keepdim=True)
-            )
+                # first convert the ray origins, directions and lengths
+                # to 3D ray point locations in world coords
+                rays_points_world = ray_bundle_to_ray_points(ray_bundle)
+
+                # set the densities as an inverse sigmoid of the
+                # ray point distance from the sphere centroid
+                rays_densities = torch.sigmoid(
+                    -100.0 * rays_points_world.norm(dim=-1, keepdim=True)
+                )
+
+                # set the ray features to RGB colors proportional
+                # to the 3D location of the projection of ray points
+                # on the sphere surface
+                rays_features = torch.nn.functional.normalize(
+                    rays_points_world, dim=-1
+                ) * 0.5 + 0.5
 
-            # set the ray features to RGB colors proportional
-            # to the 3D location of the projection of ray points
-            # on the sphere surface
-            rays_features = torch.nn.functional.normalize(
-                rays_points_world, dim=-1
-            ) * 0.5 + 0.5
+                return rays_densities, rays_features
 
-            return rays_densities, rays_features
-        ```
     """
 
     def __init__(self, raysampler: Callable, raymarcher: Callable) -> None:

pytorch3d/renderer/implicit/utils.py

@@ -73,13 +73,13 @@ def ray_bundle_to_ray_points(
     extending each ray according to the corresponding length.
 
     E.g. for 2 dimensional tensors `ray_bundle.origins`, `ray_bundle.directions`
-        and `ray_bundle.lengths`, the ray point at position `[i, j]` is:
-        ```
+        and `ray_bundle.lengths`, the ray point at position `[i, j]` is::
+
             ray_bundle.points[i, j, :] = (
                 ray_bundle.origins[i, :]
                 + ray_bundle.directions[i, :] * ray_bundle.lengths[i, j]
             )
-        ```
+
     Note that both the directions and magnitudes of the vectors in
     `ray_bundle.directions` matter.
 
@@ -109,13 +109,13 @@ def ray_bundle_variables_to_ray_points(
     ray length:
 
     E.g. for 2 dimensional input tensors `rays_origins`, `rays_directions`
-    and `rays_lengths`, the ray point at position `[i, j]` is:
-        ```
+    and `rays_lengths`, the ray point at position `[i, j]` is::
+
             rays_points[i, j, :] = (
                 rays_origins[i, :]
                 + rays_directions[i, :] * rays_lengths[i, j]
             )
-        ```
+
     Note that both the directions and magnitudes of the vectors in
     `rays_directions` matter.
 

pytorch3d/renderer/opengl/opengl_utils.py

@@ -285,26 +285,26 @@ class _DeviceContextStore:
 
     The EGL/CUDA contexts are not meant to be created and destroyed all the time,
     and having multiple on a single device can be troublesome. Intended use is entirely
-    transparent to the user:
-
-    ```
-    rasterizer1 = MeshRasterizerOpenGL(...some args...)
-    mesh1 = load_mesh_on_cuda_0()
-
-    # Now rasterizer1 will request EGL/CUDA contexts from global_device_context_store
-    # on cuda:0, and since there aren't any, the store will create new ones.
-    rasterizer1.rasterize(mesh1)
-
-    # rasterizer2 also needs EGL & CUDA contexts. But global_context_store already has
-    # them for cuda:0. Instead of creating new contexts, the store will tell rasterizer2
-    # to use them.
-    rasterizer2 = MeshRasterizerOpenGL(dcs)
-    rasterize2.rasterize(mesh1)
-
-    # When rasterizer1 needs to render on cuda:1, the store will create new contexts.
-    mesh2 = load_mesh_on_cuda_1()
-    rasterizer1.rasterize(mesh2)
-    ```
+    transparent to the user::
+
+        rasterizer1 = MeshRasterizerOpenGL(...some args...)
+        mesh1 = load_mesh_on_cuda_0()
+
+        # Now rasterizer1 will request EGL/CUDA contexts from
+        # global_device_context_store on cuda:0, and since there aren't any, the
+        # store will create new ones.
+        rasterizer1.rasterize(mesh1)
+
+        # rasterizer2 also needs EGL & CUDA contexts. But global_context_store
+        # already has them for cuda:0. Instead of creating new contexts, the store
+        # will tell rasterizer2 to use them.
+        rasterizer2 = MeshRasterizerOpenGL(dcs)
+        rasterize2.rasterize(mesh1)
+
+        # When rasterizer1 needs to render on cuda:1, the store will create new contexts.
+        mesh2 = load_mesh_on_cuda_1()
+        rasterizer1.rasterize(mesh2)
+
     """
 
     def __init__(self):

pytorch3d/renderer/points/pulsar/renderer.py

@@ -11,7 +11,6 @@
 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