Adapt RayPointRefiner and RayMarcher to support bins.

Summary:
## Context

Bins are used in mipnerf to allow to manipulate easily intervals. For example, by doing the following, `bins[..., :-1]` you will obtain all the left coordinates of your intervals, while doing `bins[..., 1:]` is equals to the right coordinates of your intervals.

We introduce here the support of bins like in MipNerf implementation.

## RayPointRefiner

Small changes have been made to modify RayPointRefiner.
- If bins is None

```
mids = torch.lerp(ray_bundle.lengths[..., 1:], ray_bundle.lengths[…, :-1], 0.5)
z_samples = sample_pdf(
		mids, # [..., npt]
		weights[..., 1:-1], # [..., npt - 1]
               ….
            )
```

- If bins is not None
In the MipNerf implementation the sampling is done on all the bins. It allows us to use the full weights tensor without slashing it.

```
z_samples = sample_pdf(
		ray_bundle.bins, # [..., npt + 1]
		weights, # [..., npt]
               ...
            )
```

## RayMarcher

Add a ray_deltas optional argument. If None, keep the same deltas computation from ray_lengths.

Reviewed By: shapovalov

Differential Revision: D46389092

fbshipit-source-id: d4f1963310065bd31c1c7fac1adfe11cbeaba606

tests/implicitron/test_ray_point_refiner.py

@@ -70,6 +70,71 @@ class TestRayPointRefiner(TestCaseMixin, unittest.TestCase):
                 (lengths_random[..., 1:] - lengths_random[..., :-1] > 0).all()
             )
 
+    def test_simple_use_bins(self):
+        """
+        Same spirit than test_simple but use bins in the ImplicitronRayBunle.
+        It has been duplicated to avoid cognitive overload while reading the
+        test (lot of if else).
+        """
+        length = 15
+        n_pts_per_ray = 10
+
+        for add_input_samples, use_blurpool in product([False, True], [False, True]):
+            ray_point_refiner = RayPointRefiner(
+                n_pts_per_ray=n_pts_per_ray,
+                random_sampling=False,
+                add_input_samples=add_input_samples,
+            )
+
+            bundle = ImplicitronRayBundle(
+                lengths=None,
+                bins=torch.arange(length + 1, dtype=torch.float32).expand(
+                    3, 25, length + 1
+                ),
+                origins=None,
+                directions=None,
+                xys=None,
+                camera_ids=None,
+                camera_counts=None,
+            )
+            weights = torch.ones(3, 25, length)
+            refined = ray_point_refiner(bundle, weights, blurpool_weights=use_blurpool)
+
+            self.assertIsNone(refined.directions)
+            self.assertIsNone(refined.origins)
+            self.assertIsNone(refined.xys)
+            expected_bins = torch.linspace(0, length, n_pts_per_ray + 1)
+            expected_bins = expected_bins.expand(3, 25, n_pts_per_ray + 1)
+            if add_input_samples:
+                expected_bins = torch.cat((bundle.bins, expected_bins), dim=-1).sort()[
+                    0
+                ]
+            full_expected = torch.lerp(
+                expected_bins[..., :-1], expected_bins[..., 1:], 0.5
+            )
+
+            self.assertClose(refined.lengths, full_expected)
+
+            ray_point_refiner_random = RayPointRefiner(
+                n_pts_per_ray=n_pts_per_ray,
+                random_sampling=True,
+                add_input_samples=add_input_samples,
+            )
+
+            refined_random = ray_point_refiner_random(
+                bundle, weights, blurpool_weights=use_blurpool
+            )
+            lengths_random = refined_random.lengths
+            self.assertEqual(lengths_random.shape, full_expected.shape)
+            if not add_input_samples:
+                self.assertGreater(lengths_random.min().item(), 0)
+                self.assertLess(lengths_random.max().item(), length)
+
+            # Check sorted
+            self.assertTrue(
+                (lengths_random[..., 1:] - lengths_random[..., :-1] > 0).all()
+            )
+
     def test_apply_blurpool_on_weights(self):
         weights = torch.tensor(
             [