Update helvipad_utils.py

helvipad_utils.py

@@ -2,7 +2,7 @@ import torch
 import cv2
 import time
 
-# Constants
+# Dataset constants
 BASELINE = 0.191  # Baseline in meters
 HEIGHT_ORIGINAL = 1920  # Original image height
 HEIGHT_DOWNSCALED = 960  # Downscaled height for disparity
@@ -17,8 +17,8 @@ def compute_depth_from_disparity(disparity_map: torch.Tensor) -> torch.Tensor:
         depth = B * (sin(theta) / tan(disparity_rad) + cos(theta))
 
     where:
-        - B is the baseline (0.191 meters for Helvipad).
-        - theta is the vertical angle corresponding to each pixel.
+        - B is the baseline.
+        - theta is the vertical angle corresponding to each pixel in the y-grid.
         - disparity_rad is the disparity map scaled to radians.
 
     Parameters:
@@ -50,7 +50,7 @@ def compute_depth_from_disparity(disparity_map: torch.Tensor) -> torch.Tensor:
     # Initialize depth map
     depth_map = torch.zeros_like(disparity_map, dtype=torch.float32)
 
-    # Compute depth only where disparity is valid (avoid division errors)
+    # Compute depth only where disparity is valid
     non_zero_disparity = disparity_map != 0
     depth_map[non_zero_disparity] = (
         (torch.sin(theta_grid[non_zero_disparity]) / torch.tan(disparity_map_rad[non_zero_disparity])) 
@@ -64,6 +64,66 @@ def compute_depth_from_disparity(disparity_map: torch.Tensor) -> torch.Tensor:
     return depth_map
 
 
+def compute_disparity_from_depth(depth_map: torch.Tensor) -> torch.Tensor:
+    """
+    Convert a depth map to a disparity map based on dataset-specific calibration.
+
+    This function reverses the depth-to-disparity conversion, based on the relationship:
+
+        tan(disparity_rad) = sin(theta) / (depth / B - cos(theta))
+
+    The final disparity in pixel units is then:
+
+        disparity = (H / pi) * atan(tan(disparity_rad))
+
+    where:
+        - B is the baseline.
+        - theta is the vertical angle corresponding to each pixel in the y-grid.
+        - disparity_rad is the angular disparity in radians.
+
+    Parameters:
+        depth_map (torch.Tensor): Input tensor of shape (bs, 1, h, w) or (bs, h, w).
+
+    Returns:
+        torch.Tensor: Disparity map of shape (bs, h, w).
+    """
+    
+    # Ensure input is 3D (batch, height, width)
+    has_channel_dim: bool = depth_map.dim() == 4 and depth_map.shape[1] == 1
+    if has_channel_dim:
+        depth_map = depth_map.squeeze(1)
+
+    bs, height, width = depth_map.shape
+
+    # Compute y-grid values
+    y_grid = (
+        torch.arange(512 + 2 * height - 1, 512, step=-2, device=depth_map.device)
+        .unsqueeze(0)
+        .unsqueeze(-1)
+        .expand(bs, -1, width)
+    )
+
+    # Compute theta (polar angle)
+    theta_grid = y_grid * torch.pi / HEIGHT_ORIGINAL
+
+    # Initialize depth map
+    disparity_map = torch.zeros_like(depth_map, dtype=torch.float32)
+
+    # Compute disparity only where depth is valid
+    non_zero_depth = depth_map != 0
+    tan_disparity_rad = torch.sin(theta_grid[non_zero_depth]) / (
+        (depth_map[non_zero_depth] / BASELINE) - torch.cos(theta_grid[non_zero_depth])
+    )
+    disparity_map_rad = torch.atan(tan_disparity_rad)
+    disparity_map[non_zero_depth] = (HEIGHT_DOWNSCALED / torch.pi) * disparity_map_rad
+
+    # Restore channel dimension if input had it
+    if has_channel_dim:
+        disparity_map = disparity_map.unsqueeze(1)
+
+    return disparity_map
+
+
 def disp_deg_to_disp_pix(disp_deg: float) -> float:
     """
     Convert a disparity value from degrees to pixels.