Upload pytorch3d_stub/pytorch3d/renderer/__init__.py with huggingface_hub

pytorch3d_stub/pytorch3d/renderer/__init__.py

@@ -1,6 +1,21 @@
-"""pytorch3d.renderer stub – all classes needed by SAM3D."""
+"""pytorch3d.renderer stub with catch-all for missing attributes."""
 import torch
 import math
+import warnings
+
+
+def __getattr__(name):
+    """Catch-all: return a dummy class/function for any missing attribute."""
+    if name.startswith("_"):
+        raise AttributeError(name)
+    warnings.warn(f"pytorch3d.renderer stub: {name} not implemented, returning dummy", stacklevel=2)
+    class _Dummy:
+        def __init__(self, *a, **kw): pass
+        def __call__(self, *a, **kw): return None
+        def to(self, *a, **kw): return self
+        def forward(self, *a, **kw): return None
+    _Dummy.__name__ = _Dummy.__qualname__ = name
+    return _Dummy
 
 
 def look_at_view_transform(dist=1.0, elev=0.0, azim=0.0, degrees=True, eye=None,
@@ -11,23 +26,18 @@ def look_at_view_transform(dist=1.0, elev=0.0, azim=0.0, degrees=True, eye=None,
         if eye.dim() == 1:
             eye = eye.unsqueeze(0)
     else:
-        if degrees:
-            elev_r = math.radians(float(elev))
-            azim_r = math.radians(float(azim))
-        else:
-            elev_r, azim_r = float(elev), float(azim)
+        elev_r = math.radians(float(elev)) if degrees else float(elev)
+        azim_r = math.radians(float(azim)) if degrees else float(azim)
         x = dist * math.cos(elev_r) * math.sin(azim_r)
         y = dist * math.sin(elev_r)
         z = dist * math.cos(elev_r) * math.cos(azim_r)
         eye = torch.tensor([[x, y, z]], dtype=torch.float32, device=device)
     if not isinstance(at, torch.Tensor):
         at = torch.tensor(at, dtype=torch.float32, device=device)
-    if at.dim() == 1:
-        at = at.unsqueeze(0)
+    if at.dim() == 1: at = at.unsqueeze(0)
     if not isinstance(up, torch.Tensor):
         up = torch.tensor(up, dtype=torch.float32, device=device)
-    if up.dim() == 1:
-        up = up.unsqueeze(0)
+    if up.dim() == 1: up = up.unsqueeze(0)
     z_axis = eye - at
     z_axis = z_axis / z_axis.norm(dim=-1, keepdim=True).clamp(min=1e-8)
     x_axis = torch.cross(up.expand_as(z_axis), z_axis, dim=-1)
@@ -38,8 +48,11 @@ def look_at_view_transform(dist=1.0, elev=0.0, azim=0.0, degrees=True, eye=None,
     return R, T
 
 
+def ray_bundle_to_ray_points(ray_bundle):
+    return None
+
+
 class CamerasBase:
-    """Base camera class stub."""
     pass
 
 
@@ -53,24 +66,18 @@ class PerspectiveCameras(CamerasBase):
         self.T = T if T is not None else torch.zeros(1, 3, device=device)
         self.image_size = image_size
         self.in_ndc = in_ndc
-
     def to(self, device):
-        self.device = device
-        return self
+        self.device = device; return self
 
 
 class RasterizationSettings:
     def __init__(self, image_size=256, blur_radius=0.0, faces_per_pixel=1, **kwargs):
-        self.image_size = image_size
-        self.blur_radius = blur_radius
-        self.faces_per_pixel = faces_per_pixel
+        self.image_size = image_size; self.blur_radius = blur_radius; self.faces_per_pixel = faces_per_pixel
 
 
 class BlendParams:
     def __init__(self, sigma=1e-4, gamma=1e-4, background_color=(0.0, 0.0, 0.0)):
-        self.sigma = sigma
-        self.gamma = gamma
-        self.background_color = background_color
+        self.sigma = sigma; self.gamma = gamma; self.background_color = background_color
 
 
 class SoftSilhouetteShader:
@@ -81,116 +88,39 @@ class SoftSilhouetteShader:
 class MeshRasterizer(torch.nn.Module):
     def __init__(self, cameras=None, raster_settings=None):
         super().__init__()
-        self.cameras = cameras
-        self.raster_settings = raster_settings or RasterizationSettings()
-    def forward(self, meshes, **kwargs):
+        self.cameras = cameras; self.raster_settings = raster_settings
+    def forward(self, meshes, **kw):
         raise NotImplementedError("MeshRasterizer stub")
 
 
 class MeshRenderer(torch.nn.Module):
     def __init__(self, rasterizer=None, shader=None):
         super().__init__()
-        self.rasterizer = rasterizer
-        self.shader = shader
-    def forward(self, meshes, **kwargs):
+        self.rasterizer = rasterizer; self.shader = shader
+    def forward(self, meshes, **kw):
         raise NotImplementedError("MeshRenderer stub")
 
 
 class TexturesVertex:
     def __init__(self, verts_features=None):
         self.verts_features_list = verts_features if isinstance(verts_features, list) else [verts_features]
-    def to(self, device):
-        return self
-
-
-class HeterogeneousRayBundle:
-    """Stub for HeterogeneousRayBundle (not used in inference)."""
-    pass
-
-
-class RayBundle:
-    """Stub for RayBundle (not used in inference)."""
-    def __init__(self, origins=None, directions=None, lengths=None, xys=None, **kwargs):
-        self.origins = origins
-        self.directions = directions
-        self.lengths = lengths
-        self.xys = xys
-
-
-class PointsRasterizationSettings:
-    def __init__(self, **kwargs):
-        pass
-
-
-class PointsRenderer:
-    def __init__(self, **kwargs):
-        pass
-
-
-class PointsRasterizer:
-    def __init__(self, **kwargs):
-        pass
-
-
-class AlphaCompositor:
-    def __init__(self, **kwargs):
-        pass
-
-
-class NormWeightedCompositor:
-    def __init__(self, **kwargs):
-        pass
+    def to(self, device): return self
 
 
 class TexturesAtlas:
-    def __init__(self, atlas=None, **kwargs):
-        self.atlas = atlas
-    def to(self, device):
-        return self
+    def __init__(self, atlas=None, **kw): self.atlas = atlas
+    def to(self, device): return self
 
-class TexturesUV:
-    def __init__(self, maps=None, faces_uvs=None, verts_uvs=None, **kwargs):
-        self.maps = maps
-        self.faces_uvs = faces_uvs
-        self.verts_uvs = verts_uvs
-    def to(self, device):
-        return self
-
-class FoVPerspectiveCameras(CamerasBase):
-    def __init__(self, **kwargs):
-        pass
-    def to(self, device):
-        return self
 
-class FoVOrthographicCameras(CamerasBase):
-    def __init__(self, **kwargs):
-        pass
-    def to(self, device):
-        return self
-
-class OrthographicCameras(CamerasBase):
-    def __init__(self, **kwargs):
-        pass
-    def to(self, device):
-        return self
-
-class SoftPhongShader:
-    def __init__(self, **kwargs):
-        pass
+class TexturesUV:
+    def __init__(self, **kw): pass
+    def to(self, device): return self
 
-class HardPhongShader:
-    def __init__(self, **kwargs):
-        pass
 
-class PointLights:
-    def __init__(self, **kwargs):
-        pass
-    def to(self, device):
-        return self
+class HeterogeneousRayBundle:
+    def __init__(self, *a, **kw): pass
 
-class DirectionalLights:
-    def __init__(self, **kwargs):
-        pass
-    def to(self, device):
-        return self
 
+class RayBundle:
+    def __init__(self, origins=None, directions=None, lengths=None, xys=None, **kw):
+        self.origins = origins; self.directions = directions; self.lengths = lengths; self.xys = xys