Merge branch 'main' into main

Author: couperle

.github/workflows/core_code_checks.yml

@@ -15,10 +15,10 @@ jobs:
 
     steps:
       - uses: actions/checkout@v3
-      - name: Set up Python 3.8.13
+      - name: Set up Python 3.11.13
         uses: actions/setup-python@v4
         with:
-          python-version: '3.8.13'
+          python-version: '3.11.13'
       - uses: actions/cache@v3
         with:
           path: ${{ env.pythonLocation }}

nerfstudio/cameras/camera_utils.py

@@ -172,7 +172,7 @@ def get_interpolated_poses(pose_a: NDArray, pose_b: NDArray, steps: int = 10) ->
     quat_b = quaternion_from_matrix(pose_b[:3, :3])
 
     ts = np.linspace(0, 1, steps)
-    quats = [quaternion_slerp(quat_a, quat_b, t) for t in ts]
+    quats = [quaternion_slerp(quat_a, quat_b, float(t)) for t in ts]
     trans = [(1 - t) * pose_a[:3, 3] + t * pose_b[:3, 3] for t in ts]
 
     poses_ab = []
@@ -199,7 +199,7 @@ def get_interpolated_k(
         List of interpolated camera poses
     """
     Ks: List[Float[Tensor, "3 3"]] = []
-    ts = np.linspace(0, 1, steps)
+    ts = torch.linspace(0, 1, steps, dtype=k_a.dtype, device=k_a.device)
     for t in ts:
         new_k = k_a * (1.0 - t) + k_b * t
         Ks.append(new_k)
@@ -218,7 +218,7 @@ def get_interpolated_time(
         steps: number of steps the interpolated pose path should contain
     """
     times: List[Float[Tensor, "1"]] = []
-    ts = np.linspace(0, 1, steps)
+    ts = torch.linspace(0, 1, steps, dtype=time_a.dtype, device=time_a.device)
     for t in ts:
         new_t = time_a * (1.0 - t) + time_b * t
         times.append(new_t)

nerfstudio/cameras/rays.py

@@ -136,6 +136,7 @@ def get_weights(self, densities: Float[Tensor, "*batch num_samples 1"]) -> Float
             Weights for each sample
         """
 
+        assert self.deltas is not None, "Deltas must be set to compute weights"
         delta_density = self.deltas * densities
         alphas = 1 - torch.exp(-delta_density)
 

nerfstudio/data/dataparsers/colmap_dataparser.py

@@ -472,6 +472,7 @@ def _load_3D_points(self, colmap_path: Path, transform_matrix: torch.Tensor, sca
                 points3D_image_ids.append(
                     torch.cat((nids, torch.full((max_num_points - len(nids),), -1, dtype=torch.int64)))
                 )
+                assert downscale_factor is not None
                 points3D_image_xy.append(
                     torch.cat((nxy, torch.full((max_num_points - len(nxy), nxy.shape[-1]), 0, dtype=torch.float32)))
                     / downscale_factor

nerfstudio/data/dataparsers/dycheck_dataparser.py

@@ -289,8 +289,8 @@ def process_frames(self, frame_names: List[str], time_ids: np.ndarray) -> Tuple[
             cam_json = load_from_json(self.data / f"camera/{frame}.json")
             c2w = torch.as_tensor(cam_json["orientation"]).T
             position = torch.as_tensor(cam_json["position"])
-            position -= self._center  # some scenes look weird (wheel)
-            position *= self._scale * self.config.scale_factor
+            position -= torch.as_tensor(self._center)  # some scenes look weird (wheel)
+            position *= torch.as_tensor(self._scale) * self.config.scale_factor
             pose = torch.zeros([3, 4])
             pose[:3, :3] = c2w
             pose[:3, 3] = position

nerfstudio/data/dataparsers/nerfstudio_dataparser.py

@@ -484,6 +484,7 @@ def _get_fname(self, filepath: Path, data_dir: Path, downsample_folder_prefix="i
                 CONSOLE.log(f"Auto image downscale factor of {self.downscale_factor}")
             else:
                 self.downscale_factor = self.config.downscale_factor
+            assert self.downscale_factor is not None
 
         if self.downscale_factor > 1:
             return data_dir / f"{downsample_folder_prefix}{self.downscale_factor}" / filepath.name

nerfstudio/data/pixel_samplers.py

@@ -227,6 +227,7 @@ def sample_method_fisheye(
 
                 rand_samples = torch.rand((samples_needed, 2), device=device)
                 # Convert random samples to radius and theta.
+                assert self.config.fisheye_crop_radius is not None
                 radii = self.config.fisheye_crop_radius * torch.sqrt(rand_samples[:, 0])
                 theta = 2.0 * torch.pi * rand_samples[:, 1]
 

nerfstudio/data/utils/data_utils.py

@@ -116,7 +116,7 @@ def get_depth_image_from_path(
     else:
         image = cv2.imread(str(filepath.absolute()), cv2.IMREAD_ANYDEPTH)
         image = image.astype(np.float32) * scale_factor
-        image = cv2.resize(image, (width, height), interpolation=interpolation)
+        image = cv2.resize(image, (width, height), interpolation=interpolation)  # type: ignore
     return torch.from_numpy(image[:, :, np.newaxis])
 
 

nerfstudio/exporter/exporter_utils.py

@@ -345,6 +345,7 @@ def collect_camera_poses(pipeline: VanillaPipeline) -> Tuple[List[Dict[str, Any]
     camera_optimizer = None
     if hasattr(pipeline.model, "camera_optimizer"):
         camera_optimizer = pipeline.model.camera_optimizer
+        assert isinstance(camera_optimizer, CameraOptimizer)
 
     train_frames = collect_camera_poses_for_dataset(train_dataset, camera_optimizer)
     # Note: returning original poses, even if --eval-mode=all

nerfstudio/field_components/encodings.py

@@ -45,11 +45,6 @@ def __init__(self, in_dim: int) -> None:
             raise ValueError("Input dimension should be greater than zero")
         super().__init__(in_dim=in_dim)
 
-    @classmethod
-    def get_tcnn_encoding_config(cls) -> dict:
-        """Get the encoding configuration for tcnn if implemented"""
-        raise NotImplementedError("Encoding does not have a TCNN implementation")
-
     @abstractmethod
     def forward(self, in_tensor: Shaped[Tensor, "*bs input_dim"]) -> Shaped[Tensor, "*bs output_dim"]:
         """Call forward and returns and processed tensor
@@ -217,6 +212,7 @@ def __init__(
         self.min_freq = min_freq_exp
         self.max_freq = max_freq_exp
         self.register_buffer(name="b_matrix", tensor=basis)
+        self.b_matrix: Tensor
         self.include_input = include_input
 
     def get_out_dim(self) -> int: