backup 06_ovow_code 2026-11-08 10:30:30 (part 9)

.gitattributes

@@ -3998,3 +3998,4 @@ OVOW/engine/oneposeviagen/fpose/fpose/bundlesdf/mycuda/gridencoder.cpython-311-x
 OVOW/engine/oneposeviagen/fpose/fpose/mycpp/build/CMakeFiles/mycpp.dir/src/Utils.cpp.o filter=lfs diff=lfs merge=lfs -text
 OVOW/engine/oneposeviagen/fpose/fpose/mycpp/build/CMakeFiles/mycpp.dir/src/app/pybind_api.cpp.o filter=lfs diff=lfs merge=lfs -text
 OVOW/engine/oneposeviagen/fpose/fpose/mycpp/build/mycpp.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+OVOW/third_party/Motion324/scripts/hy3dgen/texgen/differentiable_renderer/mesh_processor.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

OVOW/third_party/Motion324/configs/dyscene.yaml

@@ -0,0 +1,67 @@
+model:
+  class_name: model.Pcd_motion.Motion_Latent_Model
+  feat_dim: 768
+  tokens: 64
+  pcd_layers: 4
+  video_encoder:
+    image_tokenizer:
+      image_size: 224
+      patch_size: 14 
+      patch_length: 1
+      in_channels: 3
+    transformer:
+      d: 768
+      d_head: 64
+      n_layer: 16
+      special_init: true
+      depth_init: true
+      use_qk_norm: true
+
+training:
+  amp_dtype: bf16
+  api_key_path: ./configs/api_keys.yaml
+  batch_size_per_gpu: 16
+  beta1: 0.9
+  beta2: 0.95
+  allowed_gradnorm_factor: 5
+  dataset_name: dataset.dyscene.Dyscene16k_Dataset
+  dataset_path: /path/to/your/dataset
+  train_lst: dataset/train.lst
+  dataset_end: -1
+  dataset_begin: 1000
+  num_shape_samples: 4096
+  num_pcd_samples: 4096
+  replica: 1
+  frames: 12
+  grad_accum_steps: 1
+  use_checkpoint: True
+  grad_checkpoint_every: 1
+  grad_clip_norm: 1.0
+  coord_mse_loss_weight: 1.0
+  lr: 0.0004
+  num_workers: 8
+  prefetch_factor: 2
+  print_every: 20
+  use_amp: true
+  use_tf32: true
+  checkpoint_every: 10000
+  train_steps: 30000
+  stop_steps: 30000
+  warmup: 1000
+  wandb_log_every: 1
+  wandb_exp_name: test
+  wandb_project: Motion324
+  resume_ckpt: ''
+  checkpoint_dir: ./experiments/checkpoints/${training.wandb_exp_name}
+  weight_decay: 0.05
+
+# evaluation:
+#   dataset_name: dataset.dyscene.Dyscene16k_Dataset
+#   dataset_path: /path/to/your/dataset
+#   dataset_begin: 0
+#   dataset_end: 1000
+#   batch_size_per_gpu: 8
+#   frames: 12
+#   replica: 1
+#   num_shape_samples: 4096
+#   num_pcd_samples: 4096

OVOW/third_party/Motion324/dataset/dataset_utils.py

@@ -0,0 +1,136 @@
+import os
+from typing import Dict, Tuple
+
+import numpy as np
+import torch
+import trimesh
+
+
+def load_uv_preprocessing_data(save_dir: str) -> Dict[str, np.ndarray]:
+    """Load preprocessed UV data."""
+    
+    data = np.load(save_dir)
+    return {
+        'face_uvs': data['face_uvs'],
+        'texture_array': data['texture_array']
+    }
+
+
+def sample_texture_color_vectorized(
+    uvs: np.ndarray, 
+    texture_array: np.ndarray
+) -> np.ndarray:
+    """
+    Sample colors from texture map in batch based on UV coordinates.
+
+    Args:
+        uvs (np.ndarray): UV coordinate array with shape (N, 2).
+        texture_array (np.ndarray): Texture map with shape (H, W, 3).
+
+    Returns:
+        np.ndarray: Sampled RGB color array with shape (N, 3).
+    """
+    u, v = uvs[:, 0], uvs[:, 1]
+    
+    x = (u * (texture_array.shape[1] - 1)).astype(int)
+    y = ((1 - v) * (texture_array.shape[0] - 1)).astype(int)
+    
+    x = np.clip(x, 0, texture_array.shape[1] - 1)
+    y = np.clip(y, 0, texture_array.shape[0] - 1)
+    
+    return texture_array[y, x]
+
+
+def track_with_normal_rgb(
+    init_mesh: trimesh.Trimesh,
+    vertex_frames: np.ndarray,
+    faces: np.ndarray,
+    num_samples: int,
+    face_uvs: np.ndarray,
+    texture_array: np.ndarray
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, np.ndarray]:
+    """
+    Sample points on a deforming mesh sequence and track their positions, normals, and RGB colors.
+
+    This method first samples points on the first frame (t=0) and computes their barycentric coordinates.
+    Then it uses these fixed coordinates to compute the positions of sampled points in all subsequent frames,
+    interpolated normals, and RGB colors based on UV mapping.
+
+    Args:
+        init_mesh (trimesh.Trimesh): Trimesh mesh object of the first frame, used for initial sampling.
+        vertex_frames (np.ndarray): Mesh vertex sequence with shape (T, N, 3).
+        faces (np.ndarray): Mesh faces with shape (F, 3), shared across all frames.
+        num_samples (int): Number of points to sample and track.
+        face_uvs (np.ndarray): UV coordinates for three vertices of each face, with shape (F, 3, 2).
+        texture_array (np.ndarray): Texture map with shape (H, W, 3).
+
+    Returns:
+        Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        - tracked_points (torch.Tensor): Tracked point cloud sequence with shape (T, num_samples, 3).
+        - tracked_normals (torch.Tensor): Corresponding normal vector sequence with shape (T, num_samples, 3).
+        - tracked_rgbs (torch.Tensor): Corresponding RGB color sequence with shape (T, num_samples, 3).
+                                      Colors are fixed across all frames.
+    """
+    num_frames = vertex_frames.shape[0]
+
+    
+    sampled_points_t0, face_indices = trimesh.sample.sample_surface(init_mesh, num_samples)
+
+    triangles_t0 = init_mesh.vertices[faces[face_indices]]
+
+    barycentric_coords = trimesh.triangles.points_to_barycentric(
+        triangles=triangles_t0, points=sampled_points_t0
+    )
+
+    # face_uvs: (F, 3, 2) -> sampled_face_uvs: (num_samples, 3, 2)
+    sampled_face_uvs = face_uvs[face_indices]
+
+    # barycentric_coords: (num_samples, 3), sampled_face_uvs: (num_samples, 3, 2)
+    interpolated_uvs = np.einsum(
+        'ij,ijk->ik',
+        barycentric_coords,
+        sampled_face_uvs
+    )
+
+    tracked_rgbs_np = sample_texture_color_vectorized(interpolated_uvs, texture_array)
+    tracked_rgbs_np = tracked_rgbs_np / 255.0
+
+    all_tracked_points = []
+    all_tracked_normals = []
+
+    tracking_mesh = trimesh.Trimesh(faces=faces, process=False)
+
+    for t in range(num_frames):
+        tracking_mesh.vertices = vertex_frames[t]
+
+        current_triangles = tracking_mesh.vertices[faces[face_indices]]
+        current_points = trimesh.triangles.barycentric_to_points(current_triangles, barycentric_coords)
+        all_tracked_points.append(current_points)
+
+        vertex_normals_of_triangles = tracking_mesh.vertex_normals[faces[face_indices]]
+        
+        interpolated_normals = np.einsum(
+            'ij,ijk->ik',
+            barycentric_coords,
+            vertex_normals_of_triangles
+        )
+        
+        norms = np.linalg.norm(interpolated_normals, axis=1, keepdims=True)
+        non_zero_norms = np.where(norms == 0, 1.0, norms)
+        interpolated_normals /= non_zero_norms
+        
+        all_tracked_normals.append(interpolated_normals)
+
+    tracked_points_np = np.stack(all_tracked_points, axis=0)
+    tracked_normals_np = np.stack(all_tracked_normals, axis=0)
+    
+    tracked_rgbs_np_expanded = np.tile(
+        tracked_rgbs_np[np.newaxis, :, :], 
+        (num_frames, 1, 1)
+    )
+
+    tracked_points = torch.from_numpy(tracked_points_np).float()
+    tracked_normals = torch.from_numpy(tracked_normals_np).float()
+    tracked_rgbs = torch.from_numpy(tracked_rgbs_np_expanded).float()
+    
+    return tracked_points, tracked_normals, tracked_rgbs, face_indices

OVOW/third_party/Motion324/dataset/dyscene.py

@@ -0,0 +1,383 @@
+import os
+import random
+import re
+from pathlib import Path
+
+import numpy as np
+import torch
+import trimesh
+from torch.utils.data import Dataset
+
+from dataset.dataset_utils import load_uv_preprocessing_data, track_with_normal_rgb
+
+
+class Dyscene16k_Dataset(Dataset):
+    def __init__(self, config, pcd_subdir="pcds", transform=None):
+        """
+        Args:
+            root_dir (string): Directory with all the .glb files, .mp4 files, and the pcd_subdir.
+                               e.g., /path/to/Dataset/3d_object/dyobjs/Arti-XL/glbs/tracks/
+            pcd_subdir (string): Subdirectory under root_dir where object-named folders
+                                 containing .npy point clouds are located. Default is "pcds".
+            transform (callable, optional): Optional transform to be applied on a sample.
+        """
+        self.root_dir = Path(config.dataset_path)
+        self.pcd_base_dir = self.root_dir / pcd_subdir
+        self.image_base_dir = self.root_dir / "all_images"
+        if hasattr(config, 'train_lst') and config.train_lst:
+            train_lst_path = config.train_lst
+        else:
+            train_lst_path = 'dataset/train.lst'
+        self.transform = transform
+        self.frames = config.frames
+        self.replica = config.replica
+        self.num_shape_samples = config.num_shape_samples
+        self.num_pcd_samples = config.num_pcd_samples
+
+        # Find all .glb files and derive object names all_train
+        with open(train_lst_path, 'r') as f: #valid all_unique_fliter 2kagain.lst
+            self.obj_names = [line.strip() for line in f if line.strip()]
+        
+        self.obj_names = self.obj_names[config.dataset_begin:config.dataset_end]
+
+        if not self.obj_names:
+            raise RuntimeError(f"No .glb files found in {self.root_dir}")
+
+        print(f"Found {len(self.obj_names)} objects: {self.obj_names[0]}...") # Print first 5 for brevity
+
+    def __len__(self):
+        return len(self.obj_names) * self.replica
+
+    def _get_sequence_length(self, obj_name):
+        """Get the total number of frames for a given object"""
+        # Check point cloud files
+        pcd_path = obj_name + '_pointclouds'
+        obj_pcd_dir = self.pcd_base_dir / pcd_path
+        pcd_files = []
+        if obj_pcd_dir.is_dir():
+            pcd_files = sorted(
+                list(obj_pcd_dir.glob("frame_*.npy")),
+                key=self._extract_frame_number
+            )
+        
+        # Check image files
+        image_path = obj_name + '_images'
+        obj_image_dir = self.image_base_dir / image_path / 'camera_0'
+        image_files = []
+        if obj_image_dir.is_dir():
+            image_files = sorted(
+                list(obj_image_dir.glob("frame_*.jpg")) + list(obj_image_dir.glob("frame_*.png")),
+                key=self._extract_frame_number
+            )
+        
+        # Return the minimum length to ensure both modalities have data
+        return max(len(pcd_files), len(image_files)) if pcd_files and image_files else 0
+
+    def _generate_frame_indices(self, T):
+        """Generate frame indices based on sampling strategies"""
+        if T < self.frames:
+            return None
+            
+        possible_options = []
+        if T >= self.frames:
+            possible_options.append({
+                'name': 'skip1',
+                'skip_interval': 1,
+                'probability_weight': 0.4,
+                'span': self.frames
+            })
+        required_span_skip2 = (self.frames - 1) * 2 + 1
+        if T >= required_span_skip2:
+            possible_options.append({
+                'name': 'skip2',
+                'skip_interval': 2,
+                'probability_weight': 0.4,
+                'span': required_span_skip2
+            })
+        required_span_skip4 = (self.frames - 1) * 4 + 1
+        if T >= required_span_skip4:
+            possible_options.append({
+                'name': 'skip4',
+                'skip_interval': 4,
+                'probability_weight': 0.2,
+                'span': required_span_skip4
+            })
+        
+        if not possible_options:
+            return None
+            
+        total_weight = sum(opt['probability_weight'] for opt in possible_options)
+        probabilities = [opt['probability_weight'] / total_weight for opt in possible_options]
+        
+        chosen_opt_index = np.random.choice(len(possible_options), p=probabilities)
+        chosen_strategy = possible_options[chosen_opt_index]
+
+        skip = chosen_strategy['skip_interval']
+        span_needed = chosen_strategy['span']
+
+        max_start_idx = T - span_needed
+        if max_start_idx <= 0:
+            start_idx = np.random.randint(0, T - self.frames + 1)
+            return list(range(start_idx, start_idx + self.frames))
+        else:
+            start_idx = np.random.randint(0, max_start_idx + 1)
+            if skip == 1:
+                return list(range(start_idx, start_idx + self.frames))
+            else:
+                return [start_idx + i * skip for i in range(self.frames)]
+
+    def _load_single_image(self, image_path):
+        """Load a single image file"""
+        try:
+            from PIL import Image
+            image = Image.open(image_path).convert('RGB')
+            # Convert to numpy array and normalize to [0, 1]
+            image_array = np.array(image).astype(np.float32) / 255.0
+            return image_array
+        except Exception as e:
+            #print(f"Warning: Could not load image {image_path}: {e}")
+            return None
+
+    def _load_single_pointcloud(self, pcd_path):
+        """Load a single point cloud file"""
+        try:
+            point_cloud = np.load(pcd_path)
+            return point_cloud
+        except Exception as e:
+            print(f"Warning: Could not load point cloud {pcd_path}: {e}")
+            return None
+
+    def _extract_frame_number(self, filename):
+        """Extracts frame number from filenames like frame_0001.npy"""
+        match = re.search(r'frame_(\d+)\.npy', filename.name)
+        if not match:
+            match = re.search(r'frame_(\d+)\.(jpg|png)', filename.name)
+        return int(match.group(1)) if match else -1
+
+    def __getitem__(self, idx):
+        if torch.is_tensor(idx):
+            idx = idx.tolist()
+        
+        obj_name = self.obj_names[idx % len(self.obj_names)]
+        
+        # Get total sequence length
+        T = self._get_sequence_length(obj_name)
+        
+        if T < self.frames:
+            #print(f"Warning: No data found for object {obj_name}. Returning empty sample.")
+            new_idx = random.randint(0, len(self) - 1)
+            return self[new_idx]
+        
+        # Generate frame indices
+        frame_indices = self._generate_frame_indices(T)
+        
+        if frame_indices is None:
+            print(f"Warning: Cannot generate valid frame indices for {obj_name} with T={T}")
+            new_idx = random.randint(0, len(self) - 1)
+            return self[new_idx]
+
+        if len(frame_indices) != self.frames:
+            print(f"Warning: Cannot generate valid frame indices for {obj_name} with T={T}")
+            new_idx = random.randint(0, len(self) - 1)
+            return self[new_idx]
+
+        # assert len(frame_indices) == self.frames
+        # Load images and point clouds based on frame indices
+        image_path = obj_name + '_images'
+        camera = random.choice([f'camera_{i}' for i in range(15)])
+        obj_image_dir = self.image_base_dir / image_path / camera
+
+        pcd_path = obj_name + '_pointclouds'
+        obj_pcd_dir = self.pcd_base_dir / pcd_path
+
+        faces_path = obj_pcd_dir / 'faces.npy'
+        faces_np = np.load(faces_path)
+        faces = torch.from_numpy(faces_np)
+
+        # Get sorted file lists
+        image_files = sorted(
+            list(obj_image_dir.glob("frame_*.jpg")) + list(obj_image_dir.glob("frame_*.png")),
+            key=self._extract_frame_number
+        )
+        pcd_files = sorted(
+            list(obj_pcd_dir.glob("frame_*.npy")),
+            key=self._extract_frame_number
+        )
+        
+        # Load selected frames
+        rgb_frames = []
+        point_clouds_list = []
+
+        #assert len(frame_indices) == self.frames
+
+        for frame_idx in frame_indices:
+            # Load image
+            if frame_idx < len(image_files):
+                image_data = self._load_single_image(image_files[frame_idx])
+                if image_data is not None:
+                    rgb_frames.append(image_data)
+                else:
+                    #print(f"Warning: Failed to load image frame {frame_idx} for {obj_name}")
+                    continue
+            else:
+                #print(f"Warning: Image frame {frame_idx} not found for {obj_name}")
+                continue
+                
+            # Load point cloud
+            if frame_idx < len(pcd_files):
+                pcd_data = self._load_single_pointcloud(pcd_files[frame_idx])
+                if pcd_data is not None:
+                    point_clouds_list.append(pcd_data)
+                else:
+                    print(f"Warning: Failed to load point cloud frame {frame_idx} for {obj_name}")
+                    continue
+            else:
+                print(f"Warning: Point cloud frame {frame_idx} not found for {obj_name}")
+                continue
+        
+        if len(point_clouds_list) != self.frames or len(rgb_frames) !=self.frames:
+            new_idx = random.randint(0, len(self) - 1)
+            return self[new_idx]
+
+        # Convert to tensors
+        video_np = np.stack(rgb_frames, axis=0).astype(np.float32)
+        vertex_np = np.stack(point_clouds_list, axis=0)
+
+        if video_np.shape[0] != vertex_np.shape[0]:
+            #print(f"Warning: video_np.shape[0] ({video_np.shape[0]}) != vertex_np.shape[0] ({vertex_np.shape[0]}), resampling for {obj_name}")
+            new_idx = random.randint(0, len(self) - 1)
+            return self[new_idx]
+
+        uv_data_dir = obj_pcd_dir
+        data_path = os.path.join(uv_data_dir, 'uv_face_texture.npz')
+        
+        if not os.path.exists(data_path):
+            print(f"Warning: UV data not found for {obj_name}")
+            new_idx = random.randint(0, len(self) - 1)
+            return self[new_idx]
+        
+        uv_data = load_uv_preprocessing_data(data_path)
+        face_uvs = uv_data['face_uvs']
+        texture_array = uv_data['texture_array']
+
+        try:
+            final_rgb_frames = torch.from_numpy(video_np).float()
+
+            ref_shape_pcd, ref_shape_normals, ref_shape_rgbs, ref_shape_face_indices = track_with_normal_rgb(
+                init_mesh=trimesh.Trimesh(vertices=vertex_np[0], faces=faces_np, process=False),
+                vertex_frames=vertex_np[0][None, ...],
+                faces=faces,
+                num_samples=self.num_shape_samples,
+                face_uvs=face_uvs,
+                texture_array=texture_array
+            )
+            ref_shape_pcd = ref_shape_pcd[0]
+            ref_shape_normals = ref_shape_normals[0]
+            ref_shape_rgbs = ref_shape_rgbs[0]
+
+            if (
+                torch.isnan(ref_shape_pcd).any() or torch.isinf(ref_shape_pcd).any() or
+                torch.isnan(ref_shape_normals).any() or torch.isinf(ref_shape_normals).any()
+            ):
+                new_idx = random.randint(0, len(self) - 1)
+                return self[new_idx]
+
+            if isinstance(faces, torch.Tensor):
+                faces = faces.cpu().numpy()
+            else:
+                faces = faces
+
+            initial_vertices = vertex_np[0]
+            initial_mesh = trimesh.Trimesh(vertices=initial_vertices, faces=faces_np, process=False)
+
+            final_point_clouds, final_point_normals, final_point_rgbs, face_indices = track_with_normal_rgb(
+                init_mesh=initial_mesh,
+                vertex_frames=vertex_np,
+                faces=faces,
+                num_samples=self.num_pcd_samples,
+                face_uvs=face_uvs,
+                texture_array=texture_array
+            )
+
+
+            if (
+                torch.isnan(final_point_clouds).any() or torch.isinf(final_point_clouds).any() or
+                torch.isnan(final_point_normals).any() or torch.isinf(final_point_normals).any()
+            ):
+                new_idx = random.randint(0, len(self) - 1)
+                return self[new_idx]
+
+        except Exception as e:
+            #print(f"Error processing object {obj_name} at index {idx}: {str(e)}. Skipping and trying a new one.")
+            new_idx = random.randint(0, len(self) - 1)
+            return self[new_idx]
+
+        sample = {
+            'obj_name': obj_name,
+            'rgb_video': final_rgb_frames,
+            'point_clouds': final_point_clouds,
+            'point_rgbs': final_point_rgbs,
+            'ref_shape_pcd': ref_shape_pcd,
+            'ref_shape_normals': ref_shape_normals,
+            'ref_shape_rgbs': ref_shape_rgbs,
+            'ref_pcd': final_point_clouds[0],
+            'ref_normal': final_point_normals[0],
+            'ref_rgb': final_point_rgbs[0],
+
+        }
+
+        return sample
+
+def collate_fn_with_topology(batch):
+    """
+    Batch processing function supporting topology information.
+    """
+    collated = {}
+    
+    tensor_keys = [
+        'rgb_video',
+        'point_clouds',
+        'point_rgbs',
+        'ref_shape_pcd',
+        'ref_shape_normals',
+        'ref_shape_rgbs',
+        'ref_pcd',
+        'ref_normal',
+        'ref_rgb',
+    ]
+    
+    for key in tensor_keys:
+        if key in batch[0]:
+            try:
+                collated[key] = torch.stack([item[key] for item in batch])
+            except RuntimeError as e:
+                # shapes = [item[key].shape for item in batch]
+                for i, item in enumerate(batch):
+                    if item[key].shape != batch[0][key].shape:
+                        expected_shape = batch[0][key].shape
+                        actual_shape = item[key].shape
+                        raise RuntimeError(
+                            f"Shape mismatch in tensor '{key}' for object {item['obj_name']}. "
+                            f"Expected {expected_shape} (from {batch[0]['obj_name']}), "
+                            f"got {actual_shape}"
+                        )
+                raise RuntimeError(f"Failed to stack tensor '{key}' for batch. Original error: {str(e)}")
+    
+    collated['obj_name'] = [item['obj_name'] for item in batch]
+
+    edge_indices = []
+    num_nodes_offset = 0
+    num_nodes_per_sample = batch[0]['point_clouds'].size(1)
+    if 'edge_indices' in batch[0]:
+        for sample in batch:
+            edge_index_offset = sample['edge_indices'] + num_nodes_offset
+            edge_indices.append(edge_index_offset)
+            
+            num_nodes_offset += num_nodes_per_sample
+            
+        # final shape: (2, B * E)
+        batched_edge_index = torch.cat(edge_indices, dim=1)
+
+        collated['edge_indices'] = batched_edge_index
+
+    return collated

OVOW/third_party/Motion324/dataset/long_videos.txt

@@ -0,0 +1,16 @@
+bca5350dd54847eea333362dd7997c43-0-mixamo.com-_rootJoint
+b1a2f41008644ce18fdd479437490045-0-Armature.002|Armature.002|mixamo.com|Layer0-_rootJoint
+6569cdd64e104494a9afc76f769a23b8-0-mixamo.com-_rootJoint
+01051d98271941bd971018f50e31fc2f-0-mixamo.com-_rootJoint
+02721a2abe0e4df9851833b4c7dcd6e2-0-mixamo.com-_rootJoint
+064d35c29ddc4e33a9c9028ef9b9bfc9-0-mixamo.com-_rootJoint
+0b649b76d8714363b128c28f31d74153-0-mixamo.com-_rootJoint
+0b7ec4c4e35b49f0bfb278e5424c294c-0-Main-_rootJoint
+0e28b645254b4ff0973791a70268e4ee-0-mixamo.com-_rootJoint
+2011f20f7a7e4442bd44630f9e7ca9a9-0-mixamo.com-_rootJoint
+238eaf4c3a2b425ab9e848d7554d8b06-0-mixamo.com-_rootJoint
+256e92c5fa134f128b737b6f01dc80d3-0-mixamo.com-_rootJoint
+2691fa718007408d87e28ec916c7a400-0-mixamo.com-_rootJoint
+329b630700cf44ff8632498a51512905-0-mixamo.com-_rootJoint
+33bd85b5b24b4ba3b28fc455c021ff8c-0-Take 001-_rootJoint
+36a33548949a47a896acdb4b89b01c81-0-mixamo.com-_rootJoint

OVOW/third_party/Motion324/dataset/short_videos.txt

@@ -0,0 +1,64 @@
+fa9f51beb7634443be3fce568b66af73-0-Roar-_rootJoint
+d3b7ce8de999486da4651c0cb9147953-0-drunk-_rootJoint
+604e591e0d61402095ad71302d73ff59-0-Take 001-_rootJoint
+5f144ff373404241a4638acb61704fdc-0-Take 001-_rootJoint
+66b977817f6a495f889cdb87e79335cf-0-CINEMA_4D_Principal-GLTF_created_0_rootJoint
+47e7184b167144b3b14c47f20c7f7892-0-mixamo.com-_rootJoint
+b3139fdc5465449589b023d19d39dd5e-0-Take 001-_rootJoint
+bff251cf00374a24839c9b5ea0697c95-0-mixamo.com-_rootJoint
+b2a9701db8b84d3a82f99d1f719af0d4-0-mixamo.com-_rootJoint
+828017e697e64547b552aa868f045714-0-idle-_rootJoint
+1b15161e662d49ab9ead9991500f7342-0-mixamo.com-_rootJoint
+5ff228693ab04cdbad53d42311342b4e-0-mixamo.com-_rootJoint
+f819d72955004cc3bfab5afedee8250a-0-Armature|ArmatureAction.001-_rootJoint
+d0d43e2a29434a1cae0c619667c87815-0-Animation-Skeleton
+d65a6d1e87bf444088a0e8168e34e9e0-0-Armature|ArmatureAction-Armature
+9cda2dc67b5c4a9a88fe1550d1ee40fe-0-Armature|Walk-_rootJoint
+00b9f134359645148c3a5113b8449d1d-0-metarig.001|metarig.001|mixamo.com|Layer0-metarig.001
+00e7a6daedd24e429858182a334f3f88-0-mixamo.com-_rootJoint
+01bd7226a80148e0b1dae42a298580b0-0-Take 001-_rootJoint
+01fa8487749d4aca8ae56e673191c019-0-Take 001-walker_lfLegIkCtrl_space_switch_grp
+045b22e7c1c249a4acd58f14d63977f3-0-mixamo.com-_rootJoint
+075da77f55894dec9dcc38c74bf5465a-0-Armature|ArmatureAction-_rootJoint
+088687e4034a49658f030e30d99f5601-0-dance dance-_rootJoint
+09148d8bdff447ab84b1c10b384efe09-0-Armature|ArmatureAction-_rootJoint
+0a4604dad8da45e18a65179a686cb98e-0-Animation-_rootJoint
+0a7369afec3e461d8f668498e36b7707-0-Take 001-_rootJoint
+0b871ded46ec48f295daae79cee8f0b4-0-Take 001-Plane003
+0b9df8b7d0db4093b7a94746b55a4d88-0-mixamo.com-_rootJoint
+0c5d13b5a1ba4b3aa0f79c3929a2f3a5-0-Win-_rootJoint
+0c7abbb8b0e34a34bf1fb783da518664-0-mixamo.com-_rootJoint
+0f142eaa4ab94740ba9e5d074f306a15-0-Take 001-_rootJoint
+117fe1c12ffe44f698fe5d68f94a61ad-0-mixamo.com-_rootJoint
+1197e9da0aca440c8d371c6a7fe2b8bb-0-jumpin-_rootJoint
+12ad1547bf74421781481cec3dbf18ab-0-Walk-_rootJoint
+1322ec88c4214129a37cb0a870325d2f-0-Walk_blocking-GLTF_created_0_rootJoint
+1398503ac9c54bd89d8ec214be3f898c-0-mixamo.com-_rootJoint
+147255b123c4419cb745c9a688f5a460-0-mixamo.com-_rootJoint
+1646ade065cc4674891c596dd48e1b39-0-mixamo.com-_rootJoint
+1651f10085fb4fe881c9327339c05a49-0-Take 001-_rootJoint
+1697d86e7a2f417185a752c5303fa678-0-mixamo.com-_rootJoint
+16f1c72703974d35957eeeabb4ff3d32-0-mixamo.com-_rootJoint
+1711a1d0703a46baa21ede68b0743930-0-CINEMA_4D_Main-_rootJoint
+17c607eafc3e406785013094598f8226-0-mixamo.com-_rootJoint
+1aa28900f0474e85824085d15340ce15-0-walk-GLTF_created_0_rootJoint
+1c092117ed114d1cad4b43f59e13fe71-0-Take 001-_rootJoint
+1cd64f4208314981ae300cb014c19be4-0-Take 001-_rootJoint
+1f098a7cc2744736ba13ab5bda7c74a8-0-Armature.001|Walk-_rootJoint
+2066afa87c7240d3b74b2ee6116fe0d7-0-mixamo.com-_rootJoint
+21154183a9b44152857bedf21b69e1e5-0-Take 001-_rootJoint
+21507e49b8f3404ea5ac5ffb000bb176-0-ArmatureAction-Armature_rootJoint
+21c898fa071b4414a8c1fd2ea4773b43-0-walk-_rootJoint
+25015f5f3ac64d2dac358f8c17af5128-0-walk-GLTF_created_0_rootJoint
+2611cb5fc0e048bdbb421b142d4ca7f5-0-mixamo.com-_rootJoint
+2932fca2b6bf428ab38944efb12209a1-0-angry talk-_rootJoint
+2b75f50d68084580b16d5986139c407a-0-mixamo.com-_rootJoint
+2d0701a199924a9ca36e76759ceaeea6-0-Take 01-galinha_esqueleto
+2ed510f819b7483198db65f5fcd156cd-0-Attack-_rootJoint
+2efd5252155048499a1fe725462dc77f-0-mixamo.com-Armature
+2f98af6aeee24e1f8225883e52e78425-0-CINEMA_4D_Main-Root_Anim_Hat
+3279369cb5a04838a859bd69823d545c-0-Walking-GLTF_created_0_rootJoint
+32f1d70cbdfa4b0e8cf81e91618df201-0-������Action-GLTF_created_0_rootJoint
+330015cf2cca49f3a84276975eb2687d-0-Take 001-_rootJoint
+34fe9318855d4f9ea80d121dd28cc890-0-Runway_Walk-_rootJoint
+35689c8c52d54f9bbf4a0a789f407469-0-Idle-_rootJoint

OVOW/third_party/Motion324/evaluation/calculate_fvd.py

@@ -0,0 +1,99 @@
+import numpy as np
+import torch
+from tqdm import tqdm
+
+def trans(x):
+    # if greyscale images add channel
+    if x.shape[-3] == 1:
+        x = x.repeat(1, 1, 3, 1, 1)
+
+    # permute BTCHW -> BCTHW
+    x = x.permute(0, 2, 1, 3, 4) 
+
+    return x
+
+def calculate_fvd(videos1, videos2, device, method='styleganv', only_final=False, i3d_model=None):
+
+    from fvd.styleganv.fvd import get_fvd_feats, frechet_distance, load_i3d_pretrained
+
+    print("calculate_fvd...")
+
+    # videos [batch_size, timestamps, channel, h, w]
+    
+    assert videos1.shape == videos2.shape
+
+    # Only load model if not provided
+    if i3d_model is None:
+        i3d = load_i3d_pretrained(device=device)
+    else:
+        i3d = i3d_model
+    
+    fvd_results = []
+
+    # support grayscale input, if grayscale -> channel*3
+    # BTCHW -> BCTHW
+    # videos -> [batch_size, channel, timestamps, h, w]
+
+    videos1 = trans(videos1)
+    videos2 = trans(videos2)
+
+    fvd_results = []
+
+    if only_final:
+
+        assert videos1.shape[2] >= 10, "for calculate FVD, each clip_timestamp must >= 10"
+
+        # videos_clip [batch_size, channel, timestamps, h, w]
+        videos_clip1 = videos1
+        videos_clip2 = videos2
+
+        # get FVD features
+        feats1 = get_fvd_feats(videos_clip1, i3d=i3d, device=device)
+        feats2 = get_fvd_feats(videos_clip2, i3d=i3d, device=device)
+
+        # calculate FVD
+        fvd_results.append(frechet_distance(feats1, feats2))
+    
+    else:
+
+        # for calculate FVD, each clip_timestamp must >= 10
+        for clip_timestamp in tqdm(range(10, videos1.shape[-3]+1)):
+        
+            # get a video clip
+            # videos_clip [batch_size, channel, timestamps[:clip], h, w]
+            videos_clip1 = videos1[:, :, : clip_timestamp]
+            videos_clip2 = videos2[:, :, : clip_timestamp]
+
+            # get FVD features
+            feats1 = get_fvd_feats(videos_clip1, i3d=i3d, device=device)
+            feats2 = get_fvd_feats(videos_clip2, i3d=i3d, device=device)
+        
+            # calculate FVD when timestamps[:clip]
+            fvd_results.append(frechet_distance(feats1, feats2))
+
+    result = {
+        "value": fvd_results,
+    }
+
+    return result
+
+# test code / using example
+
+def main():
+    NUMBER_OF_VIDEOS = 8
+    VIDEO_LENGTH = 30
+    CHANNEL = 3
+    SIZE = 64
+    videos1 = torch.zeros(NUMBER_OF_VIDEOS, VIDEO_LENGTH, CHANNEL, SIZE, SIZE, requires_grad=False)
+    videos2 = torch.ones(NUMBER_OF_VIDEOS, VIDEO_LENGTH, CHANNEL, SIZE, SIZE, requires_grad=False)
+    device = torch.device("cuda")
+    # device = torch.device("cpu")
+
+    result = calculate_fvd(videos1, videos2, device, method='videogpt', only_final=False)
+    print("[fvd-videogpt ]", result["value"])
+
+    result = calculate_fvd(videos1, videos2, device, method='styleganv', only_final=False)
+    print("[fvd-styleganv]", result["value"])
+
+if __name__ == "__main__":
+    main()

OVOW/third_party/Motion324/evaluation/calculate_lpips.py

@@ -0,0 +1,219 @@
+import numpy as np
+import torch
+from tqdm import tqdm
+import math
+
+import torch
+import lpips
+
+# ignore torchvision UserWarning of 'weights'
+import warnings
+warnings.filterwarnings("ignore")
+
+spatial = True         # Return a spatial map of perceptual distance.
+
+# Linearly calibrated models (LPIPS)
+loss_fn = lpips.LPIPS(net='vgg', spatial=spatial) # Can also set net = 'squeeze' or 'vgg'
+# loss_fn = lpips.LPIPS(net='alex', spatial=spatial, lpips=False) # Can also set net = 'squeeze' or 'vgg'
+
+def trans(x):
+    # if greyscale images add channel
+    if x.shape[-3] == 1:
+        x = x.repeat(1, 1, 3, 1, 1)
+
+    # value range [0, 1] -> [-1, 1]
+    x = x * 2 - 1
+
+    return x
+
+import open_clip
+
+from dreamsim import dreamsim
+from torchvision import transforms
+
+def calculate_dreamsim_loss(videos1, videos2, device, only_final=False, dreamsim_model=None):
+    print("calculate_dreamsim_loss...")
+    
+    assert videos1.shape == videos2.shape
+    
+    # Only load model if not provided
+    if dreamsim_model is None:
+        dreamsim_model, _ = dreamsim(pretrained=True, device=device)
+    
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor()
+    ])
+    
+    dreamsim_loss_results = []
+    
+    for video_num in tqdm(range(videos1.shape[0])):
+        video1 = videos1[video_num]
+        video2 = videos2[video_num]
+        
+        dreamsim_loss_results_of_a_video = []
+        for clip_timestamp in range(len(video1)):
+            img1 = transforms.Resize((224, 224))(video1[clip_timestamp])
+            img2 = transforms.Resize((224, 224))(video2[clip_timestamp])
+            
+            img1_tensor = img1.unsqueeze(0).to(device)
+            img2_tensor = img2.unsqueeze(0).to(device)
+            
+            loss = dreamsim_model(img1_tensor, img2_tensor).item()
+            
+            dreamsim_loss_results_of_a_video.append(loss)
+        
+        dreamsim_loss_results.append(dreamsim_loss_results_of_a_video)
+    
+    dreamsim_loss_results = np.array(dreamsim_loss_results)
+    
+    dreamsim_loss = []
+    dreamsim_loss_std = []
+    
+    if only_final:
+        dreamsim_loss.append(np.mean(dreamsim_loss_results))
+        dreamsim_loss_std.append(np.std(dreamsim_loss_results))
+    else:
+        for clip_timestamp in range(len(video1)):
+            dreamsim_loss.append(np.mean(dreamsim_loss_results[:, clip_timestamp]))
+            dreamsim_loss_std.append(np.std(dreamsim_loss_results[:, clip_timestamp]))
+    
+    result = {
+        "value": dreamsim_loss,
+        "value_std": dreamsim_loss_std,
+    }
+    
+    # return mean for each video
+    return result, dreamsim_loss_results.mean(axis=1)
+
+
+def calculate_clip_loss(videos1, videos2, device, only_final=False, clip_model=None, clip_preprocess=None):
+    print("Calculating CLIP loss with OpenCLIP's best model...")
+    
+    assert videos1.shape == videos2.shape, "Input videos must have the same shape."
+    
+    # Only load model if not provided
+    if clip_model is None or clip_preprocess is None:
+        model, _, preprocess = open_clip.create_model_and_transforms("ViT-bigG-14", pretrained="laion2B_s39B_b160k")
+        model = model.to(device).eval()
+    else:
+        model = clip_model
+        preprocess = clip_preprocess
+    
+    clip_loss_results = []
+    
+    for video_num in tqdm(range(videos1.shape[0])):
+        video1 = videos1[video_num]
+        video2 = videos2[video_num]
+        
+        clip_loss_results_of_a_video = []
+        for clip_timestamp in range(len(video1)):
+            img1 = video1[clip_timestamp].cpu()
+            img2 = video2[clip_timestamp].cpu()
+            
+            # Convert numpy images to PIL images for preprocessing
+            img1 = preprocess(transforms.ToPILImage()(torch.tensor(img1)))
+            img2 = preprocess(transforms.ToPILImage()(torch.tensor(img2)))
+            
+            # Stack and move to device
+            images = torch.stack([img1, img2]).to(device)
+            
+            # Compute image features
+            with torch.no_grad():
+                image_features = model.encode_image(images)
+                image_features = torch.nn.functional.normalize(image_features, dim=-1)
+            
+            # Compute cosine similarity
+            similarity = torch.cosine_similarity(image_features[0], image_features[1], dim=0)
+            clip_loss_results_of_a_video.append(similarity.cpu().item())
+        
+        clip_loss_results.append(clip_loss_results_of_a_video)
+    
+    clip_loss_results = np.array(clip_loss_results)
+    clip_loss = np.mean(clip_loss_results, axis=0) if not only_final else [np.mean(clip_loss_results)]
+    clip_loss_std = np.std(clip_loss_results, axis=0) if not only_final else [np.std(clip_loss_results)]
+    
+    return {"value": clip_loss, "value_std": clip_loss_std}, clip_loss_results.mean(axis=1)
+
+
+def calculate_lpips(videos1, videos2, device, only_final=False, lpips_model=None):
+    # image should be RGB, IMPORTANT: normalized to [-1,1]
+    print("calculate_lpips...")
+
+    assert videos1.shape == videos2.shape
+
+    # videos [batch_size, timestamps, channel, h, w]
+
+    # support grayscale input, if grayscale -> channel*3
+    # value range [0, 1] -> [-1, 1]
+    videos1 = trans(videos1)
+    videos2 = trans(videos2)
+
+    lpips_results = []
+
+    # Use provided model or global loss_fn
+    if lpips_model is None:
+        lpips_model = loss_fn
+    
+    lpips_model.to(device)
+
+    for video_num in tqdm(range(videos1.shape[0])):
+        # get a video
+        # video [timestamps, channel, h, w]
+        video1 = videos1[video_num]
+        video2 = videos2[video_num]
+
+        lpips_results_of_a_video = []
+        for clip_timestamp in range(len(video1)):
+            # get a img
+            # img [timestamps[x], channel, h, w]
+            # img [channel, h, w] tensor
+
+            img1 = video1[clip_timestamp].unsqueeze(0).to(device)
+            img2 = video2[clip_timestamp].unsqueeze(0).to(device)
+
+            # calculate lpips of a video
+            lpips_results_of_a_video.append(lpips_model.forward(img1, img2).mean().detach().cpu().tolist())
+        lpips_results.append(lpips_results_of_a_video)
+    
+    lpips_results = np.array(lpips_results)
+    
+    lpips = []
+    lpips_std = []
+
+    if only_final:
+
+        lpips.append(np.mean(lpips_results))
+        lpips_std.append(np.std(lpips_results))
+
+    else:
+
+        for clip_timestamp in range(len(video1)):
+            lpips.append(np.mean(lpips_results[:,clip_timestamp]))
+            lpips_std.append(np.std(lpips_results[:,clip_timestamp]))
+
+    result = {
+        "value": lpips,
+        "value_std": lpips_std,
+    }
+
+    return result, lpips_results.mean(axis=1)
+
+# test code / using example
+
+def main():
+    NUMBER_OF_VIDEOS = 8
+    VIDEO_LENGTH = 30
+    CHANNEL = 3
+    SIZE = 64
+    videos1 = torch.zeros(NUMBER_OF_VIDEOS, VIDEO_LENGTH, CHANNEL, SIZE, SIZE, requires_grad=False)
+    videos2 = torch.ones(NUMBER_OF_VIDEOS, VIDEO_LENGTH, CHANNEL, SIZE, SIZE, requires_grad=False)
+    device = torch.device("cuda")
+    # device = torch.device("cpu")
+
+    result = calculate_lpips(videos1, videos2, device)
+    print("[lpips avg]", result["value"])
+    print("[lpips std]", result["value_std"])
+
+if __name__ == "__main__":
+    main()

OVOW/third_party/Motion324/evaluation/evaluation.py

@@ -0,0 +1,274 @@
+import torch
+import torchvision.transforms as transforms
+import cv2
+import os
+import json
+import numpy as np
+from calculate_fvd import calculate_fvd
+from calculate_lpips import calculate_lpips, calculate_dreamsim_loss, calculate_clip_loss
+import argparse
+from glob import glob
+from PIL import Image
+import lpips
+import open_clip
+from dreamsim import dreamsim
+
+# Constants
+FRAME_SIZE = 512  # Resize all frames to 512x512
+TIMESTAMP_LIMIT = 32  # Split videos into 32-frame subvideos
+
+# Define transformation
+transform = transforms.Compose([
+    transforms.ToPILImage(),
+    transforms.Resize((FRAME_SIZE, FRAME_SIZE)),
+    transforms.ToTensor()  # Converts to [0,1] range
+])
+
+def load_video_as_tensor(video_path):
+    """Load a video and convert it into a tensor [timestamp, channel, width, height]."""
+    cap = cv2.VideoCapture(video_path)
+    frames = []
+    
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB
+        frame = transform(frame)  # Resize & normalize
+        frames.append(frame)
+    
+    cap.release()
+    
+    #if len(frames) < TIMESTAMP_LIMIT:
+    #    return None  # Ignore videos with fewer than 32 frames
+    
+    video_tensor = torch.stack(frames)  # Shape: [timestamp, channel, width, height]
+    return video_tensor
+
+def load_images_as_tensor(image_dir):
+    """Load images from a directory and convert them into a tensor [timestamp, channel, width, height]."""
+    # Find all image files (png, jpg, jpeg)
+    image_files = sorted(glob(os.path.join(image_dir, "*.png")) + 
+                        glob(os.path.join(image_dir, "*.jpg")) + 
+                        glob(os.path.join(image_dir, "*.jpeg")))
+    
+    #if len(image_files) < TIMESTAMP_LIMIT:
+    #    return None  # Ignore if fewer than required frames
+    
+    frames = []
+    for img_path in image_files:
+        img = Image.open(img_path).convert('RGB')
+        img_array = np.array(img)
+        frame = transform(img_array)  # Resize & normalize
+        frames.append(frame)
+    
+    video_tensor = torch.stack(frames)  # Shape: [timestamp, channel, width, height]
+    return video_tensor
+
+def is_video_file(path):
+    """Check if path is a video file"""
+    video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.flv', '.wmv', '.webm']
+    return os.path.isfile(path) and any(path.lower().endswith(ext) for ext in video_extensions)
+
+def load_input(path):
+    """Load input from video file or image directory"""
+    if is_video_file(path):
+        return load_video_as_tensor(path)
+    elif os.path.isdir(path):
+        return load_images_as_tensor(path)
+    else:
+        raise ValueError(f"Path {path} is neither a video file nor a directory")
+
+def get_frame_count(path):
+    """Get frame count from video file or image directory"""
+    if is_video_file(path):
+        cap = cv2.VideoCapture(path)
+        count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        cap.release()
+        return count
+    elif os.path.isdir(path):
+        image_files = sorted(glob(os.path.join(path, "*.png")) + 
+                            glob(os.path.join(path, "*.jpg")) + 
+                            glob(os.path.join(path, "*.jpeg")))
+        return len(image_files)
+    else:
+        return 0
+
+def process_single_video(video_path_or_dir):
+    """Load a single video/image directory and convert it into a tensor [timestamp, channel, width, height]."""
+    tensor = load_input(video_path_or_dir)
+    if tensor.shape[0] == 0:
+        raise ValueError(f"Input {video_path_or_dir} has no frames")
+    # If video has fewer frames than TIMESTAMP_LIMIT, pad by repeating the last frame
+    if tensor.shape[0] < TIMESTAMP_LIMIT:
+        num_frames_needed = TIMESTAMP_LIMIT - tensor.shape[0]
+        # Take the last num_frames_needed frames and reverse them for padding
+        padding = tensor[-num_frames_needed:].flip(0)  # Reverse the last num_frames_needed frames
+        tensor = torch.cat([tensor, padding], dim=0)  # Concatenate along timestamp dimension
+        print(f"Input {video_path_or_dir} padded from {tensor.shape[0] - num_frames_needed} to {tensor.shape[0]} frames")
+    # Split into 32-frame subvideos
+    subvideos = [tensor[i:i+TIMESTAMP_LIMIT] for i in range(0, tensor.shape[0] - TIMESTAMP_LIMIT + 1, TIMESTAMP_LIMIT)]
+    print(f"Loaded {len(subvideos)} subvideos from {video_path_or_dir}")
+    
+    # Stack into batch: [batch, timestamp, channel, width, height]
+    return torch.stack(subvideos)
+
+parser = argparse.ArgumentParser(description="Evaluate video metrics between videos/images.")
+parser.add_argument('--gt_paths', type=str, required=True, nargs='+', help='Path(s) to ground truth video(s) or image directory(ies)')
+parser.add_argument('--result_paths', type=str, required=True, nargs='+', help='Path(s) to generated/result video(s) or image directory(ies)')
+parser.add_argument('--output_dir', type=str, default=None, help='Directory to save results (optional)')
+args = parser.parse_args()
+
+gt_paths = args.gt_paths
+result_paths = args.result_paths
+output_dir = args.output_dir
+
+# Ensure same number of paths
+if len(gt_paths) != len(result_paths):
+    raise ValueError(f"Number of GT paths ({len(gt_paths)}) must match number of result paths ({len(result_paths)})")
+
+# Move tensors to device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Load all models once before the loop
+print("Loading all models...")
+print("  - Loading LPIPS model...")
+lpips_model = lpips.LPIPS(net='vgg', spatial=True)
+lpips_model = lpips_model.to(device)
+
+print("  - Loading I3D model for FVD...")
+from fvd.styleganv.fvd import load_i3d_pretrained
+i3d_model = load_i3d_pretrained(device=device)
+
+print("  - Loading DreamSim model...")
+dreamsim_model, _ = dreamsim(pretrained=True, device=device)
+
+print("  - Loading OpenCLIP model...")
+clip_model, _, clip_preprocess = open_clip.create_model_and_transforms("ViT-bigG-14", pretrained="laion2B_s39B_b160k")
+clip_model = clip_model.to(device).eval()
+
+print("All models loaded successfully!\n")
+
+# Create output directory if specified
+if output_dir:
+    os.makedirs(output_dir, exist_ok=True)
+
+# Process each pair of paths
+all_results = []
+for idx, (gt_path, result_path) in enumerate(zip(gt_paths, result_paths)):
+    print(f"\n{'='*60}")
+    print(f"Processing pair {idx+1}/{len(gt_paths)}")
+    print(f"{'='*60}")
+    
+    # Check if paths exist
+    if not os.path.exists(gt_path):
+        print(f"Warning: GT path not found at {gt_path}, skipping...")
+        continue
+    if not os.path.exists(result_path):
+        print(f"Warning: Result path not found at {result_path}, skipping...")
+        continue
+    
+    print(f"GT: {gt_path}")
+    print(f"Result: {result_path}")
+    
+    try:
+        # Get frame counts
+        gt_frame_count = get_frame_count(gt_path)
+        result_frame_count = get_frame_count(result_path)
+        
+        if gt_frame_count == 0:
+            print(f"Warning: GT path {gt_path} has no frames, skipping...")
+            continue
+        if result_frame_count == 0:
+            print(f"Warning: Result path {result_path} has no frames, skipping...")
+            continue
+        
+        if gt_frame_count != result_frame_count:
+            print(f"Warning: Frame count mismatch: GT has {gt_frame_count} frames, but result has {result_frame_count} frames.")
+        
+        print(f"GT has {gt_frame_count} frames")
+        print(f"Result has {result_frame_count} frames")
+        print(f"Processing...")
+        
+        videos1 = process_single_video(gt_path)
+        videos2 = process_single_video(result_path)
+        
+        # Compute metrics
+        only_final = True
+        
+        print("Computing metrics...")
+        lpips_result, lpips_eachvideo = calculate_lpips(videos1, videos2, device, only_final=only_final, lpips_model=lpips_model)
+        fvd_result = calculate_fvd(videos1, videos2, device, method='styleganv', only_final=only_final, i3d_model=i3d_model)
+        dreamsim_result, dreamsim_eachvideo = calculate_dreamsim_loss(videos1, videos2, device, only_final=only_final, dreamsim_model=dreamsim_model)
+        clip_loss_result, clip_loss_eachvideo = calculate_clip_loss(videos1, videos2, device, only_final=only_final, clip_model=clip_model, clip_preprocess=clip_preprocess)
+        
+        # Extract scalar values from result dictionaries
+        # When only_final=True, value is a list with single element
+        fvd_value = fvd_result['value'][0] if isinstance(fvd_result['value'], list) else fvd_result['value']
+        lpips_value = lpips_result['value'][0] if isinstance(lpips_result['value'], list) else lpips_result['value']
+        dreamsim_value = dreamsim_result['value'][0] if isinstance(dreamsim_result['value'], list) else dreamsim_result['value']
+        clip_loss_value = clip_loss_result['value'] if isinstance(clip_loss_result['value'], (int, float)) else clip_loss_result['value'][0]
+        
+        result = {
+            'gt_path': gt_path,
+            'result_path': result_path,
+            'fvd': fvd_value,
+            'lpips': lpips_value,
+            'dreamsim': dreamsim_value,
+            'clip_loss': clip_loss_value,
+        }
+        all_results.append(result)
+        
+        # Print results
+        print(f"\nResults:")
+        print(json.dumps({k: v for k, v in result.items() if k not in ['gt_path', 'result_path']}, indent=4))
+        
+        # Save results to file
+        # Default: save to result_path's dirname with basename.txt
+        result_basename = os.path.basename(result_path.rstrip('/'))
+        # Remove extension if it's a file
+        if os.path.isfile(result_path):
+            result_basename = os.path.splitext(result_basename)[0]
+        
+        if output_dir:
+            # If output_dir is specified, save there
+            output_file = os.path.join(output_dir, f'{result_basename}.txt')
+            os.makedirs(output_dir, exist_ok=True)
+        else:
+            # Otherwise, save to result_path's directory
+            result_dir = os.path.dirname(result_path)
+            if result_dir:
+                output_file = os.path.join(result_dir, f'{result_basename}.txt')
+                os.makedirs(result_dir, exist_ok=True)
+            else:
+                # If result_path has no dirname (current directory), save to current directory
+                output_file = f'{result_basename}.txt'
+            with open(output_file, 'w') as f:
+                f.write(f"GT Source: {gt_path}\n")
+                f.write(f"Result Source: {result_path}\n")
+                f.write(f"FVD: {fvd_value}\n")
+                f.write(f"LPIPS: {lpips_value}\n")
+                f.write(f"DreamSim: {dreamsim_value}\n")
+                f.write(f"CLIP Loss: {clip_loss_value}\n")
+                f.write("-" * 50 + "\n")
+        print(f"Results saved to {output_file}")
+        
+    except Exception as e:
+        print(f"Error processing pair {idx+1}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        continue
+
+# Print summary
+print(f"\n{'='*60}")
+print(f"Summary: Processed {len(all_results)}/{len(gt_paths)} pairs")
+if len(all_results) > 0:
+    avg_fvd = np.mean([r['fvd'] for r in all_results])
+    avg_lpips = np.mean([r['lpips'] for r in all_results])
+    avg_dreamsim = np.mean([r['dreamsim'] for r in all_results])
+    avg_clip = np.mean([r['clip_loss'] for r in all_results])
+    print(f"Average FVD: {avg_fvd:.6f}")
+    print(f"Average LPIPS: {avg_lpips:.6f}")
+    print(f"Average DreamSim: {avg_dreamsim:.6f}")
+    print(f"Average CLIP Loss: {avg_clip:.6f}")
+print(f"{'='*60}")

OVOW/third_party/Motion324/evaluation/evaluation_pcd.py

@@ -0,0 +1,940 @@
+import argparse
+import numpy as np
+import trimesh
+from pathlib import Path
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+from scipy.spatial import cKDTree
+import os
+
+# Try to import bpy for GLB/FBX loading
+try:
+    import bpy
+    BLENDER_AVAILABLE = True
+except ImportError:
+    BLENDER_AVAILABLE = False
+    print("Warning: bpy not available. GLB/FBX loading will not work.")
+
+
+def load_pred_mesh_from_file(pred_file_path, frame_idx, pred_mesh_cache=None):
+    """
+    Load predicted mesh from GLB/FBX file using Blender.
+    pred_mesh_cache should be a dict containing 'obj', 'depsgraph', 'scene', 'file_ext', 'frames'
+    """
+    if not BLENDER_AVAILABLE:
+        raise RuntimeError("bpy is not available. Cannot load GLB/FBX files.")
+    
+    if pred_mesh_cache is None:
+        raise ValueError("pred_mesh_cache must be provided for file loading")
+    
+    obj = pred_mesh_cache['obj']
+    depsgraph = pred_mesh_cache['depsgraph']
+    scene = pred_mesh_cache['scene']
+    file_ext = pred_mesh_cache['file_ext']
+    frames = pred_mesh_cache['frames']
+    
+    # Get the actual frame number (handle FBX frame offset)
+    if frame_idx < len(frames):
+        actual_frame = frames[frame_idx]
+    else:
+        # If frame_idx exceeds available frames, use last frame
+        actual_frame = frames[-1]
+    
+    # Set scene to the target frame
+    scene.frame_set(actual_frame)
+    obj_eval = obj.evaluated_get(depsgraph)
+    me = bpy.data.meshes.new_from_object(
+        obj_eval,
+        preserve_all_data_layers=True,
+        depsgraph=depsgraph,
+    )
+    
+    # Extract vertices
+    vertices = np.zeros((len(me.vertices), 3), dtype=np.float32)
+    for i, v in enumerate(me.vertices):
+        vertices[i] = v.co
+    
+    # Extract faces
+    faces = []
+    for poly in me.polygons:
+        faces.append(list(poly.vertices))
+    faces = np.array(faces, dtype=np.int32)
+    
+    # Clean up temporary mesh
+    bpy.data.meshes.remove(me)
+    
+    mesh = trimesh.Trimesh(vertices=vertices, faces=faces, process=False)
+    return mesh
+
+
+def load_pred_mesh_from_dir(pred_path, frame_idx):
+    """Load predicted mesh from faces.npy and frame_{frame_idx:04d}.npy"""
+    faces = np.load(Path(pred_path) / "faces.npy")
+    vertices = np.load(Path(pred_path) / f"frame_{frame_idx:04d}.npy")
+    mesh = trimesh.Trimesh(vertices=vertices, faces=faces, process=False)
+    return mesh
+
+
+def load_pred_mesh(pred_path, frame_idx, pred_mesh_cache=None):
+    """
+    Load predicted mesh. Supports both:
+    1. Directory with faces.npy and frame_*.npy files
+    2. GLB/FBX file (requires Blender)
+    """
+    pred_path_obj = Path(pred_path)
+    
+    # Check if it's a file (GLB/FBX) or directory (npy files)
+    if pred_path_obj.is_file():
+        # It's a file, use Blender to load
+        if pred_mesh_cache is None:
+            raise ValueError("pred_mesh_cache must be provided when loading from GLB/FBX file")
+        return load_pred_mesh_from_file(pred_path, frame_idx, pred_mesh_cache)
+    else:
+        # It's a directory, load from npy files
+        return load_pred_mesh_from_dir(pred_path, frame_idx)
+
+
+def initialize_pred_mesh_cache(pred_path):
+    """
+    Initialize Blender scene and load predicted mesh file.
+    Returns a cache dict containing necessary Blender objects and frame information.
+    Returns None if pred_path is not a file or Blender is not available.
+    """
+    pred_path_obj = Path(pred_path)
+    
+    # If it's not a file, return None (will use directory loading)
+    if not pred_path_obj.is_file():
+        return None
+    
+    if not BLENDER_AVAILABLE:
+        raise RuntimeError("bpy is not available. Cannot load GLB/FBX files.")
+    
+    file_ext = pred_path_obj.suffix.lower()
+    if file_ext not in ['.glb', '.gltf', '.fbx']:
+        return None  # Not a supported file format, will use directory loading
+    
+    print(f"Loading predicted mesh from {pred_path_obj}...")
+    
+    # Clear scene and import file
+    bpy.ops.object.select_all(action='SELECT')
+    bpy.ops.object.delete()
+    
+    if file_ext == '.glb' or file_ext == '.gltf':
+        bpy.ops.import_scene.gltf(filepath=str(pred_path_obj))
+    elif file_ext == '.fbx':
+        bpy.ops.import_scene.fbx(filepath=str(pred_path_obj))
+    
+    # Get the mesh object
+    obj = None
+    for o in bpy.context.scene.objects:
+        if o.type == 'MESH':
+            obj = o
+            break
+    
+    if obj is None:
+        raise ValueError("No mesh object found in the imported file")
+    
+    # Gather keyframes
+    def gather_keyframes(o):
+        frames = set()
+        ad = o.animation_data
+        if ad and ad.action:
+            for fc in ad.action.fcurves:
+                for kp in fc.keyframe_points:
+                    frames.add(int(round(kp.co.x)))
+        sk = getattr(o.data, "shape_keys", None)
+        if sk and sk.animation_data and sk.animation_data.action:
+            for fc in sk.animation_data.action.fcurves:
+                for kp in fc.keyframe_points:
+                    frames.add(int(round(kp.co.x)))
+        return sorted(frames)
+    
+    frames = gather_keyframes(obj)
+    
+    # If no keyframes, use scene frame range
+    if not frames:
+        frames = list(range(bpy.context.scene.frame_start, bpy.context.scene.frame_end + 1))
+    
+    print(f"Found {len(frames)} frames in predicted mesh file: {frames[:10]}..." if len(frames) > 10 else f"Found {len(frames)} frames in predicted mesh file: {frames}")
+    
+    scene = bpy.context.scene
+    depsgraph = bpy.context.evaluated_depsgraph_get()
+    
+    return {
+        'obj': obj,
+        'depsgraph': depsgraph,
+        'scene': scene,
+        'file_ext': file_ext,
+        'frames': frames
+    }
+
+def normalize_mesh(mesh):
+    """
+    Normalize mesh similar to bpyrenderer's normalize_scene method.
+    Uses CUBE range type normalization.
+    """
+    vertices = mesh.vertices
+    
+    # Calculate bounding box
+    bbox_min = vertices.min(axis=0)
+    bbox_max = vertices.max(axis=0)
+    
+    # Calculate offset to center (similar to normalize_scene)
+    offset = -(bbox_min + bbox_max) / 2
+    center = -offset  # Store original center for later use
+    
+    # Calculate scale (CUBE range type: normalize_range / max(bbox_max - bbox_min))
+    normalize_range = 2.0
+    scale = normalize_range / np.max(bbox_max - bbox_min)
+    
+    # Apply normalization: first translate to center, then scale
+    vertices_centered = vertices + offset
+    vertices_normalized = vertices_centered * scale
+    
+    return vertices_normalized, center, 1.0 / scale
+
+def apply_normalization(vertices, center, scale):
+    """Apply pre-computed normalization parameters"""
+    return (vertices - center) / scale
+
+def apply_icp_alignment(vertices_norm, R, t, s):
+    """Apply ICP alignment transformation: s * (vertices_norm @ R.T) + t"""
+    return s * (vertices_norm @ R.T) + t
+
+
+def icp_alignment(source_points, target_points, max_iterations=1000, tolerance=1e-7, output_dir=None, optimize_scale=False, visualize=False):
+    """
+    Use standard Point-to-Point ICP algorithm to align source to target.
+    Returns: rotation matrix R, translation vector t, scale factor s
+    such that: aligned = s * (source @ R.T) + t
+    
+    Args:
+        source_points: source point cloud
+        target_points: target point cloud
+        max_iterations: maximum number of iterations
+        tolerance: convergence threshold
+        output_dir: output directory (for saving visualizations)
+        optimize_scale: whether to optimize scale factor (default False, scale limited to 0.95-1.05 range)
+        visualize: whether to generate visualizations
+    """
+    # Initialize
+    source = source_points.copy()
+    target = target_points.copy()
+    
+    # Calculate initial scale (based on bbox max range)
+    source_bbox_min = np.min(source, axis=0)
+    source_bbox_max = np.max(source, axis=0)
+    source_max_range = np.max((source_bbox_max - source_bbox_min)[:2])  # Only consider x and y axes
+    
+    target_bbox_min = np.min(target, axis=0)
+    target_bbox_max = np.max(target, axis=0)
+    target_max_range = np.max((target_bbox_max - target_bbox_min)[:2])  # Only consider x and y axes
+    
+    print(f"Source max range: {source_max_range}, Target max range: {target_max_range}")
+    # Calculate scale factor based on bbox max range
+    if source_max_range > 1e-10:
+        scale = target_max_range / source_max_range
+        # Limit initial scale to 0.95-1.05 range
+        scale = np.clip(scale, 0.95, 1.05)
+    else:
+        print(f"Warning: source_max_range is too small: {source_max_range}")
+        scale = 1.0
+    
+    # ICP iteration
+    R = np.eye(3)
+    t = np.zeros(3)
+    prev_error = float('inf')
+    
+    # List to save intermediate results
+    iteration_data = []
+    
+    # Create output directory (only when visualizing)
+    if visualize and output_dir is not None:
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+        temp_dir = output_dir / "icp_iterations"
+        temp_dir.mkdir(exist_ok=True)
+    
+    for iteration in range(max_iterations):
+        # Apply current transformation: scale * (source @ R.T) + t
+        source_transformed = scale * (source @ R.T) + t
+        
+        # Find nearest neighbors
+        tree = cKDTree(target)
+        distances, indices = tree.query(source_transformed)
+        
+        # Get corresponding target points
+        matched_target = target[indices]
+        
+        # Calculate point-to-point distance
+        error = np.mean(distances)
+        
+        if visualize:
+            print(f"ICP Iteration {iteration+1}: Mean Distance = {error:.6f}, Scale = {scale:.6f}")
+        
+        # Save iteration data (only when visualizing)
+        if visualize:
+            iteration_data.append({
+                'iteration': iteration,
+                'error': error,
+                'R': R.copy(),
+                't': t.copy(),
+                'scale': scale,
+                'source_transformed': source_transformed.copy()
+            })
+        
+        # Visualize current iteration state (only when visualizing)
+        if visualize and output_dir is not None and (iteration % 5 == 0 or iteration == 0 or iteration == max_iterations - 1):
+            fig = plt.figure(figsize=(15, 5))
+            
+            # Downsample for visualization
+            sample_rate = max(1, len(source_transformed) // 5000)
+            source_sample = source_transformed[::sample_rate]
+            target_sample = target[::sample_rate]
+            
+            # 3D view - front
+            ax1 = fig.add_subplot(131, projection='3d')
+            ax1.scatter(source_sample[:, 0], source_sample[:, 1], source_sample[:, 2], 
+                       c='red', s=1, alpha=0.5, label='Source')
+            ax1.scatter(target_sample[:, 0], target_sample[:, 1], target_sample[:, 2], 
+                       c='blue', s=1, alpha=0.5, label='Target')
+            ax1.set_xlabel('X')
+            ax1.set_ylabel('Y')
+            ax1.set_zlabel('Z')
+            ax1.set_title(f'3D View - Iter {iteration+1}')
+            ax1.legend()
+            ax1.view_init(elev=20, azim=45)
+            
+            # Set same axis range
+            all_points = np.vstack([source_transformed, target])
+            max_range = np.array([all_points[:, 0].max()-all_points[:, 0].min(),
+                                 all_points[:, 1].max()-all_points[:, 1].min(),
+                                 all_points[:, 2].max()-all_points[:, 2].min()]).max() / 2.0
+            mid_x = (all_points[:, 0].max()+all_points[:, 0].min()) * 0.5
+            mid_y = (all_points[:, 1].max()+all_points[:, 1].min()) * 0.5
+            mid_z = (all_points[:, 2].max()+all_points[:, 2].min()) * 0.5
+            ax1.set_xlim(mid_x - max_range, mid_x + max_range)
+            ax1.set_ylim(mid_y - max_range, mid_y + max_range)
+            ax1.set_zlim(mid_z - max_range, mid_z + max_range)
+            
+            # 3D view - side
+            ax2 = fig.add_subplot(132, projection='3d')
+            ax2.scatter(source_sample[:, 0], source_sample[:, 1], source_sample[:, 2], 
+                       c='red', s=1, alpha=0.5, label='Source')
+            ax2.scatter(target_sample[:, 0], target_sample[:, 1], target_sample[:, 2], 
+                       c='blue', s=1, alpha=0.5, label='Target')
+            ax2.set_xlabel('X')
+            ax2.set_ylabel('Y')
+            ax2.set_zlabel('Z')
+            ax2.set_title(f'Side View - Iter {iteration+1}')
+            ax2.legend()
+            ax2.view_init(elev=0, azim=0)
+            ax2.set_xlim(mid_x - max_range, mid_x + max_range)
+            ax2.set_ylim(mid_y - max_range, mid_y + max_range)
+            ax2.set_zlim(mid_z - max_range, mid_z + max_range)
+            
+            # Error curve
+            ax3 = fig.add_subplot(133)
+            errors = [d['error'] for d in iteration_data]
+            ax3.plot(range(len(errors)), errors, 'b-', linewidth=2)
+            ax3.scatter(len(errors)-1, errors[-1], c='red', s=50, zorder=5)
+            ax3.set_xlabel('Iteration')
+            ax3.set_ylabel('Mean Distance Error')
+            ax3.set_title(f'Convergence Curve\nCurrent Error: {error:.6f}')
+            ax3.grid(True, alpha=0.3)
+            
+            plt.tight_layout()
+            
+            # Save image
+            img_path = temp_dir / f"iteration_{iteration:04d}.png"
+            plt.savefig(img_path, dpi=100, bbox_inches='tight')
+            plt.close()
+            print(f"  Saved visualization to {img_path}")
+        
+        # Check convergence
+        if abs(prev_error - error) < tolerance:
+            if visualize:
+                print(f"ICP converged at iteration {iteration+1}")
+            break
+        prev_error = error
+        
+        # Calculate centroids
+        source_centroid = np.mean(source_transformed, axis=0)
+        target_centroid = np.mean(matched_target, axis=0)
+        
+        # Center
+        source_centered_iter = source_transformed - source_centroid
+        target_centered_iter = matched_target - target_centroid
+        
+        # Calculate covariance matrix
+        H = source_centered_iter.T @ target_centered_iter
+        
+        # SVD decomposition
+        U, S, Vt = np.linalg.svd(H)
+        
+        # Calculate rotation matrix
+        R_delta = Vt.T @ U.T
+        
+        # Ensure right-handed coordinate system (determinant = 1)
+        if np.linalg.det(R_delta) < 0:
+            Vt[-1, :] *= -1
+            R_delta = Vt.T @ U.T
+        
+        # Calculate translation increment
+        t_delta = target_centroid - source_centroid @ R_delta.T
+        
+        # Update rotation and translation
+        R = R @ R_delta
+        t = t @ R_delta.T + t_delta
+        
+        # Orthogonalize rotation matrix (ensure numerical stability)
+        U, _, Vt = np.linalg.svd(R)
+        R = U @ Vt
+        
+        # Optimize scale factor (if enabled)
+        if optimize_scale:
+            # After applying current R and t, optimize scale
+            source_rotated_translated = source @ R.T + t
+            # Optimal scale = sum(target * source) / sum(source * source)
+            numerator = np.sum(target[indices] * source_rotated_translated)
+            denominator = np.sum(source_rotated_translated * source_rotated_translated)
+            if denominator > 1e-10:
+                scale_new = numerator / denominator
+                # Limit scale to 0.95-1.05 range
+                scale_new = np.clip(scale_new, 0.95, 1.05)
+                # Smooth scale update to avoid oscillation
+                scale = 0.8 * scale + 0.2 * scale_new
+                # Ensure scale is in range again
+                scale = np.clip(scale, 0.95, 1.05)
+    
+    # Print final error
+    print(f"Final Mean Distance: {error:.6f}")
+    
+    # Create final comparison plot (only when visualizing)
+    if visualize and output_dir is not None:
+        print("\nCreating final comparison visualization...")
+        
+        # Select key frames for display
+        key_iterations = [0]
+        step = max(1, len(iteration_data) // 8)
+        for i in range(step, len(iteration_data), step):
+            key_iterations.append(i)
+        if len(iteration_data) - 1 not in key_iterations:
+            key_iterations.append(len(iteration_data) - 1)
+        
+        n_images = len(key_iterations)
+        n_cols = min(4, n_images)
+        n_rows = (n_images + n_cols - 1) // n_cols
+        
+        fig = plt.figure(figsize=(5*n_cols, 5*n_rows))
+        
+        for idx, iter_idx in enumerate(key_iterations):
+            ax = fig.add_subplot(n_rows, n_cols, idx+1, projection='3d')
+            
+            data = iteration_data[iter_idx]
+            source_transformed = data['source_transformed']
+            
+            sample_rate = max(1, len(source_transformed) // 3000)
+            source_sample = source_transformed[::sample_rate]
+            target_sample = target[::sample_rate]
+            
+            ax.scatter(source_sample[:, 0], source_sample[:, 1], source_sample[:, 2], 
+                      c='red', s=1, alpha=0.5, label='Source')
+            ax.scatter(target_sample[:, 0], target_sample[:, 1], target_sample[:, 2], 
+                      c='blue', s=1, alpha=0.5, label='Target')
+            
+            ax.set_xlabel('X')
+            ax.set_ylabel('Y')
+            ax.set_zlabel('Z')
+            ax.set_title(f"Iter {data['iteration']+1}\nError: {data['error']:.6f}, Scale: {data['scale']:.6f}")
+            ax.legend()
+            ax.view_init(elev=20, azim=45)
+            
+            # Set same axis range
+            all_points = np.vstack([source_transformed, target])
+            max_range = np.array([all_points[:, 0].max()-all_points[:, 0].min(),
+                                 all_points[:, 1].max()-all_points[:, 1].min(),
+                                 all_points[:, 2].max()-all_points[:, 2].min()]).max() / 2.0
+            mid_x = (all_points[:, 0].max()+all_points[:, 0].min()) * 0.5
+            mid_y = (all_points[:, 1].max()+all_points[:, 1].min()) * 0.5
+            mid_z = (all_points[:, 2].max()+all_points[:, 2].min()) * 0.5
+            ax.set_xlim(mid_x - max_range, mid_x + max_range)
+            ax.set_ylim(mid_y - max_range, mid_y + max_range)
+            ax.set_zlim(mid_z - max_range, mid_z + max_range)
+        
+        plt.tight_layout()
+        final_grid_path = output_dir / "icp_iterations_grid.png"
+        plt.savefig(final_grid_path, dpi=150, bbox_inches='tight')
+        plt.close()
+        print(f"Final grid saved to {final_grid_path}")
+        
+        # Save error curve and scale curve
+        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 10))
+        
+        errors = [d['error'] for d in iteration_data]
+        ax1.plot(range(len(errors)), errors, 'b-', linewidth=2, label='Error')
+        ax1.scatter(range(len(errors)), errors, c='blue', s=20, alpha=0.5)
+        ax1.set_xlabel('Iteration', fontsize=12)
+        ax1.set_ylabel('Mean Distance Error', fontsize=12)
+        ax1.set_title('ICP Convergence Curve', fontsize=14)
+        ax1.grid(True, alpha=0.3)
+        ax1.legend()
+        
+        if optimize_scale:
+            scales = [d['scale'] for d in iteration_data]
+            ax2.plot(range(len(scales)), scales, 'r-', linewidth=2, label='Scale')
+            ax2.scatter(range(len(scales)), scales, c='red', s=20, alpha=0.5)
+            ax2.axhline(y=0.95, color='g', linestyle='--', alpha=0.5, label='Scale limits')
+            ax2.axhline(y=1.05, color='g', linestyle='--', alpha=0.5)
+            ax2.set_xlabel('Iteration', fontsize=12)
+            ax2.set_ylabel('Scale Factor', fontsize=12)
+            ax2.set_title('Scale Optimization (limited to 0.95-1.05)', fontsize=14)
+            ax2.grid(True, alpha=0.3)
+            ax2.legend()
+        
+        plt.tight_layout()
+        error_curve_path = output_dir / "icp_error_curve.png"
+        plt.savefig(error_curve_path, dpi=150, bbox_inches='tight')
+        plt.close()
+        print(f"Error curve saved to {error_curve_path}")
+    
+    return R, t, scale
+
+
+def compute_alignment_from_first_frame(gt_path, pred_path, pred_mesh_cache=None, visualize=False):
+    """
+    Compute ICP alignment parameters from the first frame.
+    Returns: rotation matrix R, translation vector t, scale factor s, and normalization parameters.
+    
+    Args:
+        gt_path: path to GT data directory (contains faces.npy and frame_*.npy)
+        pred_path: path to predicted data (can be directory with frame_*.npy or GLB/FBX file)
+        pred_mesh_cache: cache for predicted mesh (if loading from file)
+        visualize: whether to generate visualizations
+    """
+    gt_path = Path(gt_path)
+    pred_path = Path(pred_path)
+    
+    # Load GT first frame
+    print(f"Loading GT frame 0 from {gt_path}...")
+    gt_faces_path = gt_path / "faces.npy"
+    if gt_faces_path.exists():
+        gt_faces = np.load(gt_faces_path)
+    else:
+        gt_faces = None
+    
+    gt_frame_0 = np.load(gt_path / "frame_0000.npy")
+    if gt_faces is not None:
+        gt_mesh_0 = trimesh.Trimesh(vertices=gt_frame_0, faces=gt_faces, process=False)
+    else:
+        gt_mesh_0 = trimesh.Trimesh(vertices=gt_frame_0, process=False)
+    
+    # Normalize GT
+    gt_vertices_0_norm, gt_center, gt_scale = normalize_mesh(gt_mesh_0)
+    print(f"GT Normalization - Center: {gt_center}, Scale: {gt_scale}")
+    
+    # Sample 10000 points from GT mesh surface for ICP
+    print("Sampling 10000 points from GT mesh surface...")
+    gt_sampled_points, _ = trimesh.sample.sample_surface(gt_mesh_0, 10000)
+    # Apply same normalization to sampled points
+    gt_sampled_points_norm = (gt_sampled_points - gt_center) / gt_scale
+    
+    # Load predicted first frame
+    print(f"Loading predicted frame 0 from {pred_path}...")
+    pred_mesh_0 = load_pred_mesh(pred_path, 0, pred_mesh_cache)
+    
+    # Normalize prediction
+    pred_vertices_0_norm, pred_center, pred_scale = normalize_mesh(pred_mesh_0)
+    print(f"Pred Normalization - Center: {pred_center}, Scale: {pred_scale}")
+    
+    # Use standard Point-to-Point ICP alignment (using GT sampled points)
+    print("\nRunning Point-to-Point ICP alignment...")
+    output_dir = gt_path / "icp_visualization" if visualize else None
+    R, t, s = icp_alignment(pred_vertices_0_norm, gt_sampled_points_norm,
+                           output_dir=output_dir, visualize=visualize)
+    print(f"\nICP Alignment Results:")
+    print(f"Rotation Matrix R:\n{R}")
+    print(f"Translation t: {t}")
+    print(f"Scale s: {s}")
+    
+    # Save alignment parameters
+    # Save to GT path (as npz format for easy loading)
+    np.savez(gt_path / 'icp_alignment_params.npz',
+             R=R, t=t, s=s)
+    print(f"Alignment parameters saved to: {gt_path / 'icp_alignment_params.npz'}")
+    
+    return R, t, s
+
+
+def sample_points_from_mesh(mesh, num_points=50000):
+    """Sample points uniformly from mesh surface"""
+    points, _ = trimesh.sample.sample_surface(mesh, num_points)
+    return points
+
+
+def compute_chamfer_distance(points1, points2):
+    """Compute bidirectional Chamfer distance"""
+    # Build KD-trees
+    tree1 = cKDTree(points1)
+    tree2 = cKDTree(points2)
+    
+    # Compute distances from points1 to points2
+    dist1, _ = tree1.query(points2, k=1)
+    # Compute distances from points2 to points1
+    dist2, _ = tree2.query(points1, k=1)
+    
+    # Chamfer distance is the mean of both directions
+    chamfer_dist = (np.mean(dist1) + np.mean(dist2))
+    return chamfer_dist
+
+
+def compute_fscore(points1, points2, threshold=0.02):
+    """Compute F-score at given threshold"""
+    # Build KD-trees
+    tree1 = cKDTree(points1)
+    tree2 = cKDTree(points2)
+    
+    # Compute distances
+    dist1, _ = tree1.query(points2, k=1)
+    dist2, _ = tree2.query(points1, k=1)
+    
+    # Compute precision and recall
+    precision = np.mean(dist1 < threshold)
+    recall = np.mean(dist2 < threshold)
+    
+    # Compute F-score
+    if precision + recall == 0:
+        return 0.0
+    fscore = 2 * precision * recall / (precision + recall)
+    return fscore
+
+
+def compute_iou_voxel(mesh1, mesh2, resolution=128):
+    """Compute IoU on voxel grids"""
+    # Voxelize both meshes
+    voxel1 = mesh1.voxelized(pitch=1.0/resolution)
+    voxel2 = mesh2.voxelized(pitch=1.0/resolution)
+    
+    # Get filled voxel grids
+    grid1 = voxel1.matrix
+    grid2 = voxel2.matrix
+    
+    # Ensure same shape
+    max_shape = np.maximum(grid1.shape, grid2.shape)
+    padded_grid1 = np.zeros(max_shape, dtype=bool)
+    padded_grid2 = np.zeros(max_shape, dtype=bool)
+    
+    padded_grid1[:grid1.shape[0], :grid1.shape[1], :grid1.shape[2]] = grid1
+    padded_grid2[:grid2.shape[0], :grid2.shape[1], :grid2.shape[2]] = grid2
+    
+    # Compute IoU
+    intersection = np.logical_and(padded_grid1, padded_grid2).sum()
+    union = np.logical_or(padded_grid1, padded_grid2).sum()
+    
+    if union == 0:
+        return 0.0
+    iou = intersection / union
+    return iou
+
+
+def visualize_mesh_comparison(gt_mesh, pred_mesh, frame_idx, viz_dir):
+    """Visualize ground truth and predicted meshes"""
+    fig = plt.figure(figsize=(15, 5))
+    
+    # Plot GT mesh
+    ax1 = fig.add_subplot(131, projection='3d')
+    ax1.plot_trisurf(gt_mesh.vertices[:, 0], gt_mesh.vertices[:, 1], gt_mesh.vertices[:, 2],
+                     triangles=gt_mesh.faces, alpha=0.7, color='blue', edgecolor='none')
+    ax1.set_title(f'GT Mesh (Frame {frame_idx})')
+    ax1.set_xlabel('X')
+    ax1.set_ylabel('Y')
+    ax1.set_zlabel('Z')
+    ax1.set_xlim(-1, 1)
+    ax1.set_ylim(-1, 1)
+    ax1.set_zlim(-1, 1)
+    
+    # Plot predicted mesh
+    ax2 = fig.add_subplot(132, projection='3d')
+    ax2.plot_trisurf(pred_mesh.vertices[:, 0], pred_mesh.vertices[:, 1], pred_mesh.vertices[:, 2],
+                     triangles=pred_mesh.faces, alpha=0.7, color='red', edgecolor='none')
+    ax2.set_title(f'Predicted Mesh (Frame {frame_idx})')
+    ax2.set_xlabel('X')
+    ax2.set_ylabel('Y')
+    ax2.set_zlabel('Z')
+    ax2.set_xlim(-1, 1)
+    ax2.set_ylim(-1, 1)
+    ax2.set_zlim(-1, 1)
+    
+    # Plot both together (wireframe for better visibility)
+    ax3 = fig.add_subplot(133, projection='3d')
+    ax3.plot_trisurf(gt_mesh.vertices[:, 0], gt_mesh.vertices[:, 1], gt_mesh.vertices[:, 2],
+                     triangles=gt_mesh.faces, alpha=0.3, color='blue', edgecolor='none')
+    ax3.plot_trisurf(pred_mesh.vertices[:, 0], pred_mesh.vertices[:, 1], pred_mesh.vertices[:, 2],
+                     triangles=pred_mesh.faces, alpha=0.3, color='red', edgecolor='none')
+    ax3.set_title(f'Mesh Overlay (Frame {frame_idx})')
+    ax3.set_xlabel('X')
+    ax3.set_ylabel('Y')
+    ax3.set_zlabel('Z')
+    ax3.set_xlim(-1, 1)
+    ax3.set_ylim(-1, 1)
+    ax3.set_zlim(-1, 1)
+    # Set viewing angle to 45 degrees
+    for ax in [ax1, ax2, ax3]:
+        ax.view_init(elev=30, azim=45)
+    plt.tight_layout()
+    save_path = os.path.join(viz_dir, f'mesh_comparison_frame_{frame_idx:04d}.png')
+    plt.savefig(save_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"Saved mesh comparison to {save_path}")
+
+
+def visualize_pointcloud_comparison(gt_points, pred_points, frame_idx, viz_dir):
+    """Visualize ground truth and predicted point clouds"""
+    fig = plt.figure(figsize=(15, 5))
+    
+    # Plot GT points
+    ax1 = fig.add_subplot(131, projection='3d')
+    ax1.scatter(gt_points[:, 0], gt_points[:, 1], gt_points[:, 2], 
+                c='blue', s=1, alpha=0.5, label='GT Points')
+    ax1.set_title(f'GT Point Cloud (Frame {frame_idx})')
+    ax1.set_xlabel('X')
+    ax1.set_ylabel('Y')
+    ax1.set_zlabel('Z')
+    ax1.set_xlim(-1, 1)
+    ax1.set_ylim(-1, 1)
+    ax1.set_zlim(-1, 1)
+    ax1.legend()
+    
+    # Plot predicted points
+    ax2 = fig.add_subplot(132, projection='3d')
+    ax2.scatter(pred_points[:, 0], pred_points[:, 1], pred_points[:, 2], 
+                c='red', s=1, alpha=0.5, label='Pred Points')
+    ax2.set_title(f'Predicted Point Cloud (Frame {frame_idx})')
+    ax2.set_xlabel('X')
+    ax2.set_ylabel('Y')
+    ax2.set_zlabel('Z')
+    ax2.set_xlim(-1, 1)
+    ax2.set_ylim(-1, 1)
+    ax2.set_zlim(-1, 1)
+    ax2.legend()
+    
+    # Plot both together
+    ax3 = fig.add_subplot(133, projection='3d')
+    ax3.scatter(gt_points[:, 0], gt_points[:, 1], gt_points[:, 2], 
+                c='blue', s=1, alpha=0.3, label='GT')
+    ax3.scatter(pred_points[:, 0], pred_points[:, 1], pred_points[:, 2], 
+                c='red', s=1, alpha=0.3, label='Pred')
+    ax3.set_title(f'Point Cloud Overlay (Frame {frame_idx})')
+    ax3.set_xlabel('X')
+    ax3.set_ylabel('Y')
+    ax3.set_zlabel('Z')
+    ax3.set_xlim(-1, 1)
+    ax3.set_ylim(-1, 1)
+    ax3.set_zlim(-1, 1)
+    ax3.legend()
+
+    for ax in [ax1, ax2, ax3]:
+        ax.view_init(elev=30, azim=45)
+    
+    plt.tight_layout()
+    save_path = os.path.join(viz_dir, f'pointcloud_comparison_frame_{frame_idx:04d}.png')
+    plt.savefig(save_path, dpi=150, bbox_inches='tight')
+    plt.close()
+    print(f"Saved point cloud comparison to {save_path}")
+
+
+def evaluate_sequence(gt_path, pred_path, num_samples=2048, viz=False, icp_viz=False):
+    """Evaluate entire sequence"""
+    pred_path = Path(pred_path)
+    gt_path = Path(gt_path)
+    
+    # Create visualization directory
+    viz_dir = Path(pred_path).parent.parent / 'viz'
+    viz_dir.mkdir(exist_ok=True)
+    print(f"Visualization directory: {viz_dir}")
+    
+    # Initialize predicted mesh cache if loading from file
+    pred_mesh_cache = initialize_pred_mesh_cache(pred_path)
+    is_pred_file = pred_mesh_cache is not None
+    
+    # Load GT frames from point cloud directory
+    print(f"Loading GT frames from {gt_path}...")
+    gt_frame_files = sorted(gt_path.glob("frame_*.npy"))
+    gt_frames = [np.load(f) for f in gt_frame_files]
+    print(f"Loaded {len(gt_frames)} frames from GT point clouds")
+    
+    # Load GT faces
+    gt_faces_path = gt_path / "faces.npy"
+    if gt_faces_path.exists():
+        gt_faces = np.load(gt_faces_path)
+        print(f"Loaded GT faces from {gt_faces_path}")
+    else:
+        print(f"Warning: No faces.npy found in {gt_path}")
+        gt_faces = None
+    
+    # Get number of frames from predicted mesh
+    if is_pred_file:
+        # Get frame count from Blender cache
+        num_frames = len(pred_mesh_cache['frames'])
+        print(f"Found {num_frames} frames in predicted mesh file")
+        # Extract predicted faces from first frame (they should be consistent)
+        pred_mesh_first = load_pred_mesh_from_file(pred_path, 0, pred_mesh_cache)
+        pred_faces = pred_mesh_first.faces
+        print(f"Loaded predicted faces from first frame: {len(pred_faces)} faces")
+    else:
+        # Get frame count from directory
+        frame_files = sorted(pred_path.glob("frame_*.npy"))
+        num_frames = len(frame_files)
+        print(f"Found {num_frames} frames in predicted data directory")
+        
+        # Load predicted faces
+        pred_faces_path = pred_path / "faces.npy"
+        if pred_faces_path.exists():
+            pred_faces = np.load(pred_faces_path)
+            print(f"Loaded predicted faces from {pred_faces_path}")
+        else:
+            print(f"Warning: No faces.npy found in {pred_path}")
+            pred_faces = None
+    
+    # Ensure we have enough GT frames
+    if len(gt_frames) < num_frames:
+        print(f"Warning: GT data has {len(gt_frames)} frames but prediction has {num_frames} frames")
+        print(f"Will repeat last frame to match predicted length")
+        while len(gt_frames) < num_frames:
+            gt_frames.append(gt_frames[-1].copy())
+    
+    # Load first predicted frame for normalization
+    pred_mesh_0 = load_pred_mesh(pred_path, 0, pred_mesh_cache)
+    _, pred_center, pred_scale = normalize_mesh(pred_mesh_0)
+
+    print(f"Pred Normalization params - Center: {pred_center}, Scale: {pred_scale}")
+    
+    # Normalize predicted frame 0
+    pred_vertices_0_norm = apply_normalization(pred_mesh_0.vertices, pred_center, pred_scale)
+
+    # Normalize GT frame 0
+    if gt_faces is not None:
+        gt_mesh_0 = trimesh.Trimesh(vertices=gt_frames[0], faces=gt_faces, process=False)
+    else:
+        gt_mesh_0 = trimesh.Trimesh(vertices=gt_frames[0], process=False)
+    _, gt_center, gt_scale = normalize_mesh(gt_mesh_0)
+
+    gt_vertices_0_norm = apply_normalization(gt_frames[0], gt_center, gt_scale)
+    print(f"GT Normalization params - Center: {gt_center}, Scale: {gt_scale}")
+    print(f"GT Normalization params - Min: {min(gt_vertices_0_norm[:, 0])}, Max: {max(gt_vertices_0_norm[:, 0])}")
+    print(f"GT Normalization params - Min: {min(gt_vertices_0_norm[:, 1])}, Max: {max(gt_vertices_0_norm[:, 1])}")
+    print(f"GT Normalization params - Min: {min(gt_vertices_0_norm[:, 2])}, Max: {max(gt_vertices_0_norm[:, 2])}")
+    # Load ICP alignment parameters
+    icp_params_path = viz_dir / 'icp_alignment_params.npz'
+    if icp_params_path.exists():
+        icp_params = np.load(icp_params_path)
+        R = icp_params['R']
+        t = icp_params['t']
+        s = icp_params['s']
+        print(f"Loaded ICP alignment parameters from {icp_params_path}")
+        print(f"R shape: {R.shape}, t shape: {t.shape}, s: {s}")
+    else:
+        print(f"No icp_alignment_params.npz found in {gt_path}")
+        print("Computing ICP alignment from first frame...")
+        # Make visualize for compute_alignment_from_first_frame configurable via arg
+        R, t, s = compute_alignment_from_first_frame(gt_path, pred_path, pred_mesh_cache, visualize=icp_viz)
+        print(f"ICP alignment computed - R shape: {R.shape}, t shape: {t.shape}, s: {s}")
+    
+    # Store metrics for all frames
+    chamfer_distances = []
+    fscores = []
+    ious = []
+    if viz:
+        print(f"Visualization directory: {viz_dir}")
+        os.makedirs(viz_dir, exist_ok=True)
+
+    for frame_idx in range(num_frames):
+        print(f"\nProcessing frame {frame_idx}/{num_frames-1}...")
+        
+        # Load predicted mesh and apply prediction normalization
+        pred_mesh = load_pred_mesh(pred_path, frame_idx, pred_mesh_cache)
+        pred_vertices_norm = apply_normalization(pred_mesh.vertices, pred_center, pred_scale)
+        # Use predicted faces from cache or from mesh
+        pred_faces_to_use = pred_faces if pred_faces is not None else pred_mesh.faces
+        pred_mesh_norm = trimesh.Trimesh(vertices=pred_vertices_norm, faces=pred_faces_to_use, process=False)
+        
+        # Get GT frame, apply GT normalization, then apply ICP alignment
+        gt_vertices = gt_frames[frame_idx]
+        gt_vertices_norm = apply_normalization(gt_vertices, gt_center, gt_scale)
+        gt_vertices_aligned = apply_icp_alignment(gt_vertices_norm, R, t, s)
+        if gt_faces is not None:
+            gt_mesh_aligned = trimesh.Trimesh(vertices=gt_vertices_aligned, faces=gt_faces, process=False)
+        else:
+            gt_mesh_aligned = trimesh.Trimesh(vertices=gt_vertices_aligned, process=False)
+        
+        # Visualize mesh comparison for every frame
+        #print(f"Visualizing mesh comparison for frame {frame_idx}...")
+        if viz:
+            visualize_mesh_comparison(gt_mesh_aligned, pred_mesh_norm, frame_idx, viz_dir)
+        
+        # Sample points
+        gt_points = sample_points_from_mesh(gt_mesh_aligned, num_samples)
+        pred_points = sample_points_from_mesh(pred_mesh_norm, num_samples)
+        
+        # Visualize point cloud comparison for every frame
+        #print(f"Visualizing point cloud comparison for frame {frame_idx}...")
+        
+        #visualize_pointcloud_comparison(gt_points, pred_points, frame_idx, viz_dir)
+        # Compute metrics
+        chamfer = compute_chamfer_distance(gt_points, pred_points)
+        fscore = compute_fscore(gt_points, pred_points, threshold=0.02)
+        # iou = compute_iou_voxel(gt_mesh_aligned, pred_mesh_norm, resolution=128)
+        
+        chamfer_distances.append(chamfer)
+        fscores.append(fscore)
+        # ious.append(iou)
+        
+        print(f"Frame {frame_idx} - Chamfer: {chamfer:.6f}, F-score: {fscore:.4f}")
+    
+    # Print summary statistics
+    print("\n" + "="*50)
+    print("Summary Statistics:")
+    print("="*50)
+    print(f"Chamfer Distance - Mean: {np.mean(chamfer_distances):.6f}, Std: {np.std(chamfer_distances):.6f}")
+    print(f"F-score - Mean: {np.mean(fscores):.4f}, Std: {np.std(fscores):.4f}")
+    # print(f"IoU - Mean: {np.mean(ious):.4f}, Std: {np.std(ious):.4f}")
+    
+    # Save results to txt file in gt_path
+    gt_path_obj = Path(gt_path)
+    os.makedirs(gt_path_obj, exist_ok=True)
+    results_txt_path = gt_path_obj / 'evaluation_results.txt'
+    with open(results_txt_path, 'w') as f:
+        f.write(f"{gt_path_obj.name}\n")
+        f.write(f"cd_mean_{np.mean(chamfer_distances):.6f}\n")
+        f.write(f"fs_mean_{np.mean(fscores):.6f}\n")
+    print(f"\nResults saved to {results_txt_path}")
+    
+    return {
+        'chamfer_distances': chamfer_distances,
+        'fscores': fscores,
+        # 'ious': ious
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Evaluate mesh reconstruction quality')
+    parser.add_argument('--gt_path', type=str, required=True,
+                    help='Path to ground-truth point cloud directory (contains faces.npy and frame_*.npy)')
+    parser.add_argument('--pred_path', type=str, required=True,
+                        help='Path to predicted data (contains faces.npy and frame_*.npy)')
+    parser.add_argument('--num_samples', type=int, default=50000,
+                        help='Number of points to sample from each mesh')
+    parser.add_argument('--viz', action='store_true',
+                        help='Visualize point clouds and meshes')
+    parser.add_argument('--icp_viz', action='store_true',
+                        help='Visualize ICP alignment procedure for first frame')
+    
+    args = parser.parse_args()
+    
+    results = evaluate_sequence(args.gt_path, args.pred_path, args.num_samples, args.viz, icp_viz=args.icp_viz)
+    
+    print(f"\nResults saved to {args.pred_path}")
+
+
+if __name__ == '__main__':
+    main()

OVOW/third_party/Motion324/evaluation/fvd/styleganv/fvd.py

@@ -0,0 +1,90 @@
+import torch
+import os
+import math
+import torch.nn.functional as F
+
+# https://github.com/universome/fvd-comparison
+
+
+def load_i3d_pretrained(device=torch.device('cpu')):
+    i3D_WEIGHTS_URL = "https://www.dropbox.com/s/ge9e5ujwgetktms/i3d_torchscript.pt"
+    filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'i3d_torchscript.pt')
+    print('Loading model from: %s'%filepath)
+    if not os.path.exists(filepath):
+        print(f"preparing for download {i3D_WEIGHTS_URL}, you can download it by yourself.")
+        os.system(f"wget {i3D_WEIGHTS_URL} -O {filepath}")
+    i3d = torch.jit.load(filepath).eval().to(device)
+    i3d = torch.nn.DataParallel(i3d)
+    return i3d
+    
+
+def get_feats(videos, detector, device, bs=10):
+    # videos : torch.tensor BCTHW [0, 1]
+    detector_kwargs = dict(rescale=False, resize=False, return_features=True) # Return raw features before the softmax layer.
+    feats = np.empty((0, 400))
+    with torch.no_grad():
+        for i in range((len(videos)-1)//bs + 1):
+            feats = np.vstack([feats, detector(x=torch.stack([preprocess_single(video) for video in videos[i*bs:(i+1)*bs]]).to(device), **detector_kwargs).detach().cpu().numpy()])
+    return feats
+
+
+def get_fvd_feats(videos, i3d, device, bs=10):
+    # videos in [0, 1] as torch tensor BCTHW
+    # videos = [preprocess_single(video) for video in videos]
+    embeddings = get_feats(videos, i3d, device, bs)
+    return embeddings
+
+
+def preprocess_single(video, resolution=224, sequence_length=None):
+    # video: CTHW, [0, 1]
+    c, t, h, w = video.shape
+
+    # temporal crop
+    if sequence_length is not None:
+        assert sequence_length <= t
+        video = video[:, :sequence_length]
+
+    # scale shorter side to resolution
+    scale = resolution / min(h, w)
+    if h < w:
+        target_size = (resolution, math.ceil(w * scale))
+    else:
+        target_size = (math.ceil(h * scale), resolution)
+    video = F.interpolate(video, size=target_size, mode='bilinear', align_corners=False)
+
+    # center crop
+    c, t, h, w = video.shape
+    w_start = (w - resolution) // 2
+    h_start = (h - resolution) // 2
+    video = video[:, :, h_start:h_start + resolution, w_start:w_start + resolution]
+
+    # [0, 1] -> [-1, 1]
+    video = (video - 0.5) * 2
+
+    return video.contiguous()
+
+
+"""
+Copy-pasted from https://github.com/cvpr2022-stylegan-v/stylegan-v/blob/main/src/metrics/frechet_video_distance.py
+"""
+from typing import Tuple
+from scipy.linalg import sqrtm
+import numpy as np
+
+
+def compute_stats(feats: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+    mu = feats.mean(axis=0) # [d]
+    sigma = np.cov(feats, rowvar=False) # [d, d]
+    return mu, sigma
+
+
+def frechet_distance(feats_fake: np.ndarray, feats_real: np.ndarray) -> float:
+    mu_gen, sigma_gen = compute_stats(feats_fake)
+    mu_real, sigma_real = compute_stats(feats_real)
+    m = np.square(mu_gen - mu_real).sum()
+    if feats_fake.shape[0]>1:
+        s, _ = sqrtm(np.dot(sigma_gen, sigma_real), disp=False) # pylint: disable=no-member
+        fid = np.real(m + np.trace(sigma_gen + sigma_real - s * 2))
+    else:
+        fid = np.real(m)
+    return float(fid)

OVOW/third_party/Motion324/evaluation/lpips/__init__.py

@@ -0,0 +1,126 @@
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+import torch
+# from torch.autograd import Variable
+
+from lpips.trainer import *
+from lpips.lpips import *
+
+def normalize_tensor(in_feat,eps=1e-10):
+    norm_factor = torch.sqrt(torch.sum(in_feat**2,dim=1,keepdim=True))
+    return in_feat/(norm_factor+eps)
+
+def l2(p0, p1, range=255.):
+    return .5*np.mean((p0 / range - p1 / range)**2)
+
+def psnr(p0, p1, peak=255.):
+    return 10*np.log10(peak**2/np.mean((1.*p0-1.*p1)**2))
+
+def dssim(p0, p1, range=255.):
+    from skimage.measure import compare_ssim
+    return (1 - compare_ssim(p0, p1, data_range=range, multichannel=True)) / 2.
+
+def tensor2np(tensor_obj):
+    # change dimension of a tensor object into a numpy array
+    return tensor_obj[0].cpu().float().numpy().transpose((1,2,0))
+
+def np2tensor(np_obj):
+     # change dimenion of np array into tensor array
+    return torch.Tensor(np_obj[:, :, :, np.newaxis].transpose((3, 2, 0, 1)))
+
+def tensor2tensorlab(image_tensor,to_norm=True,mc_only=False):
+    # image tensor to lab tensor
+    from skimage import color
+
+    img = tensor2im(image_tensor)
+    img_lab = color.rgb2lab(img)
+    if(mc_only):
+        img_lab[:,:,0] = img_lab[:,:,0]-50
+    if(to_norm and not mc_only):
+        img_lab[:,:,0] = img_lab[:,:,0]-50
+        img_lab = img_lab/100.
+
+    return np2tensor(img_lab)
+
+def tensorlab2tensor(lab_tensor,return_inbnd=False):
+    from skimage import color
+    import warnings
+    warnings.filterwarnings("ignore")
+
+    lab = tensor2np(lab_tensor)*100.
+    lab[:,:,0] = lab[:,:,0]+50
+
+    rgb_back = 255.*np.clip(color.lab2rgb(lab.astype('float')),0,1)
+    if(return_inbnd):
+        # convert back to lab, see if we match
+        lab_back = color.rgb2lab(rgb_back.astype('uint8'))
+        mask = 1.*np.isclose(lab_back,lab,atol=2.)
+        mask = np2tensor(np.prod(mask,axis=2)[:,:,np.newaxis])
+        return (im2tensor(rgb_back),mask)
+    else:
+        return im2tensor(rgb_back)
+
+def load_image(path):
+    if(path[-3:] == 'dng'):
+        import rawpy
+        with rawpy.imread(path) as raw:
+            img = raw.postprocess()
+    elif(path[-3:]=='bmp' or path[-3:]=='jpg' or path[-3:]=='png' or path[-4:]=='jpeg'):
+        import cv2
+        return cv2.imread(path)[:,:,::-1]
+    else:
+        import matplotlib.pyplot as plt        
+        img = (255*plt.imread(path)[:,:,:3]).astype('uint8')
+
+    return img
+
+def tensor2im(image_tensor, imtype=np.uint8, cent=1., factor=255./2.):
+    image_numpy = image_tensor[0].cpu().float().numpy()
+    image_numpy = (np.transpose(image_numpy, (1, 2, 0)) + cent) * factor
+    return image_numpy.astype(imtype)
+
+def im2tensor(image, imtype=np.uint8, cent=1., factor=255./2.):
+    return torch.Tensor((image / factor - cent)
+                        [:, :, :, np.newaxis].transpose((3, 2, 0, 1)))
+
+def tensor2vec(vector_tensor):
+    return vector_tensor.data.cpu().numpy()[:, :, 0, 0]
+
+
+def voc_ap(rec, prec, use_07_metric=False):
+    """ ap = voc_ap(rec, prec, [use_07_metric])
+    Compute VOC AP given precision and recall.
+    If use_07_metric is true, uses the
+    VOC 07 11 point method (default:False).
+    """
+    if use_07_metric:
+        # 11 point metric
+        ap = 0.
+        for t in np.arange(0., 1.1, 0.1):
+            if np.sum(rec >= t) == 0:
+                p = 0
+            else:
+                p = np.max(prec[rec >= t])
+            ap = ap + p / 11.
+    else:
+        # correct AP calculation
+        # first append sentinel values at the end
+        mrec = np.concatenate(([0.], rec, [1.]))
+        mpre = np.concatenate(([0.], prec, [0.]))
+
+        # compute the precision envelope
+        for i in range(mpre.size - 1, 0, -1):
+            mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
+
+        # to calculate area under PR curve, look for points
+        # where X axis (recall) changes value
+        i = np.where(mrec[1:] != mrec[:-1])[0]
+
+        # and sum (\Delta recall) * prec
+        ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
+    return ap
+

OVOW/third_party/Motion324/evaluation/lpips/lpips.py

@@ -0,0 +1,241 @@
+
+from __future__ import absolute_import
+
+import torch
+import torch.nn as nn
+import torch.nn.init as init
+from torch.autograd import Variable
+import numpy as np
+from . import pretrained_networks as pn
+import torch.nn
+
+import lpips
+
+def spatial_average(in_tens, keepdim=True):
+    return in_tens.mean([2,3],keepdim=keepdim)
+
+def upsample(in_tens, out_HW=(64,64)): # assumes scale factor is same for H and W
+    in_H, in_W = in_tens.shape[2], in_tens.shape[3]
+    return nn.Upsample(size=out_HW, mode='bilinear', align_corners=False)(in_tens)
+
+# Learned perceptual metric
+class LPIPS(nn.Module):
+    def __init__(self, pretrained=True, net='alex', version='0.1', lpips=True, spatial=False, 
+        pnet_rand=False, pnet_tune=False, use_dropout=True, model_path=None, eval_mode=True, verbose=True):
+        """ Initializes a perceptual loss torch.nn.Module
+
+        Parameters (default listed first)
+        ---------------------------------
+        lpips : bool
+            [True] use linear layers on top of base/trunk network
+            [False] means no linear layers; each layer is averaged together
+        pretrained : bool
+            This flag controls the linear layers, which are only in effect when lpips=True above
+            [True] means linear layers are calibrated with human perceptual judgments
+            [False] means linear layers are randomly initialized
+        pnet_rand : bool
+            [False] means trunk loaded with ImageNet classification weights
+            [True] means randomly initialized trunk
+        net : str
+            ['alex','vgg','squeeze'] are the base/trunk networks available
+        version : str
+            ['v0.1'] is the default and latest
+            ['v0.0'] contained a normalization bug; corresponds to old arxiv v1 (https://arxiv.org/abs/1801.03924v1)
+        model_path : 'str'
+            [None] is default and loads the pretrained weights from paper https://arxiv.org/abs/1801.03924v1
+
+        The following parameters should only be changed if training the network
+
+        eval_mode : bool
+            [True] is for test mode (default)
+            [False] is for training mode
+        pnet_tune
+            [False] keep base/trunk frozen
+            [True] tune the base/trunk network
+        use_dropout : bool
+            [True] to use dropout when training linear layers
+            [False] for no dropout when training linear layers
+        """
+
+        super(LPIPS, self).__init__()
+        if(verbose):
+            print('Setting up [%s] perceptual loss: trunk [%s], v[%s], spatial [%s]'%
+                ('LPIPS' if lpips else 'baseline', net, version, 'on' if spatial else 'off'))
+
+        self.pnet_type = net
+        self.pnet_tune = pnet_tune
+        self.pnet_rand = pnet_rand
+        self.spatial = spatial
+        self.lpips = lpips # false means baseline of just averaging all layers
+        self.version = version
+        self.scaling_layer = ScalingLayer()
+
+        if(self.pnet_type in ['vgg','vgg16']):
+            net_type = pn.vgg16
+            self.chns = [64,128,256,512,512]
+        elif(self.pnet_type=='alex'):
+            net_type = pn.alexnet
+            self.chns = [64,192,384,256,256]
+        elif(self.pnet_type=='squeeze'):
+            net_type = pn.squeezenet
+            self.chns = [64,128,256,384,384,512,512]
+        self.L = len(self.chns)
+
+        self.net = net_type(pretrained=not self.pnet_rand, requires_grad=self.pnet_tune)
+
+        if(lpips):
+            self.lin0 = NetLinLayer(self.chns[0], use_dropout=use_dropout)
+            self.lin1 = NetLinLayer(self.chns[1], use_dropout=use_dropout)
+            self.lin2 = NetLinLayer(self.chns[2], use_dropout=use_dropout)
+            self.lin3 = NetLinLayer(self.chns[3], use_dropout=use_dropout)
+            self.lin4 = NetLinLayer(self.chns[4], use_dropout=use_dropout)
+            self.lins = [self.lin0,self.lin1,self.lin2,self.lin3,self.lin4]
+            if(self.pnet_type=='squeeze'): # 7 layers for squeezenet
+                self.lin5 = NetLinLayer(self.chns[5], use_dropout=use_dropout)
+                self.lin6 = NetLinLayer(self.chns[6], use_dropout=use_dropout)
+                self.lins+=[self.lin5,self.lin6]
+            self.lins = nn.ModuleList(self.lins)
+
+            if(pretrained):
+                if(model_path is None):
+                    import inspect
+                    import os
+                    model_path = os.path.abspath(os.path.join(inspect.getfile(self.__init__), '..', 'weights/v%s/%s.pth'%(version,net)))
+
+                if(verbose):
+                    print('Loading model from: %s'%model_path)
+                self.load_state_dict(torch.load(model_path, map_location='cpu'), strict=False)          
+
+        if(eval_mode):
+            self.eval()
+
+    def forward(self, in0, in1, retPerLayer=False, normalize=False):
+        if normalize: # turn on this flag if input is [0,1] so it can be adjusted to [-1, +1]
+            in0 = 2 * in0  - 1
+            in1 = 2 * in1  - 1
+
+        # v0.0 - original release had a bug, where input was not scaled
+        in0_input, in1_input = (self.scaling_layer(in0), self.scaling_layer(in1)) if self.version=='0.1' else (in0, in1)
+        outs0, outs1 = self.net.forward(in0_input), self.net.forward(in1_input)
+        feats0, feats1, diffs = {}, {}, {}
+
+        for kk in range(self.L):
+            feats0[kk], feats1[kk] = lpips.normalize_tensor(outs0[kk]), lpips.normalize_tensor(outs1[kk])
+            diffs[kk] = (feats0[kk]-feats1[kk])**2
+
+        if(self.lpips):
+            if(self.spatial):
+                res = [upsample(self.lins[kk](diffs[kk]), out_HW=in0.shape[2:]) for kk in range(self.L)]
+            else:
+                res = [spatial_average(self.lins[kk](diffs[kk]), keepdim=True) for kk in range(self.L)]
+        else:
+            if(self.spatial):
+                res = [upsample(diffs[kk].sum(dim=1,keepdim=True), out_HW=in0.shape[2:]) for kk in range(self.L)]
+            else:
+                res = [spatial_average(diffs[kk].sum(dim=1,keepdim=True), keepdim=True) for kk in range(self.L)]
+
+        val = 0
+        for l in range(self.L):
+            val += res[l]
+        
+        if(retPerLayer):
+            return (val, res)
+        else:
+            return val
+
+
+class ScalingLayer(nn.Module):
+    def __init__(self):
+        super(ScalingLayer, self).__init__()
+        self.register_buffer('shift', torch.Tensor([-.030,-.088,-.188])[None,:,None,None])
+        self.register_buffer('scale', torch.Tensor([.458,.448,.450])[None,:,None,None])
+
+    def forward(self, inp):
+        return (inp - self.shift) / self.scale
+
+
+class NetLinLayer(nn.Module):
+    ''' A single linear layer which does a 1x1 conv '''
+    def __init__(self, chn_in, chn_out=1, use_dropout=False):
+        super(NetLinLayer, self).__init__()
+
+        layers = [nn.Dropout(),] if(use_dropout) else []
+        layers += [nn.Conv2d(chn_in, chn_out, 1, stride=1, padding=0, bias=False),]
+        self.model = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.model(x)
+
+class Dist2LogitLayer(nn.Module):
+    ''' takes 2 distances, puts through fc layers, spits out value between [0,1] (if use_sigmoid is True) '''
+    def __init__(self, chn_mid=32, use_sigmoid=True):
+        super(Dist2LogitLayer, self).__init__()
+
+        layers = [nn.Conv2d(5, chn_mid, 1, stride=1, padding=0, bias=True),]
+        layers += [nn.LeakyReLU(0.2,True),]
+        layers += [nn.Conv2d(chn_mid, chn_mid, 1, stride=1, padding=0, bias=True),]
+        layers += [nn.LeakyReLU(0.2,True),]
+        layers += [nn.Conv2d(chn_mid, 1, 1, stride=1, padding=0, bias=True),]
+        if(use_sigmoid):
+            layers += [nn.Sigmoid(),]
+        self.model = nn.Sequential(*layers)
+
+    def forward(self,d0,d1,eps=0.1):
+        return self.model.forward(torch.cat((d0,d1,d0-d1,d0/(d1+eps),d1/(d0+eps)),dim=1))
+
+class BCERankingLoss(nn.Module):
+    def __init__(self, chn_mid=32):
+        super(BCERankingLoss, self).__init__()
+        self.net = Dist2LogitLayer(chn_mid=chn_mid)
+        # self.parameters = list(self.net.parameters())
+        self.loss = torch.nn.BCELoss()
+
+    def forward(self, d0, d1, judge):
+        per = (judge+1.)/2.
+        self.logit = self.net.forward(d0,d1)
+        return self.loss(self.logit, per)
+
+# L2, DSSIM metrics
+class FakeNet(nn.Module):
+    def __init__(self, use_gpu=True, colorspace='Lab'):
+        super(FakeNet, self).__init__()
+        self.use_gpu = use_gpu
+        self.colorspace = colorspace
+
+class L2(FakeNet):
+    def forward(self, in0, in1, retPerLayer=None):
+        assert(in0.size()[0]==1) # currently only supports batchSize 1
+
+        if(self.colorspace=='RGB'):
+            (N,C,X,Y) = in0.size()
+            value = torch.mean(torch.mean(torch.mean((in0-in1)**2,dim=1).view(N,1,X,Y),dim=2).view(N,1,1,Y),dim=3).view(N)
+            return value
+        elif(self.colorspace=='Lab'):
+            value = lpips.l2(lpips.tensor2np(lpips.tensor2tensorlab(in0.data,to_norm=False)), 
+                lpips.tensor2np(lpips.tensor2tensorlab(in1.data,to_norm=False)), range=100.).astype('float')
+            ret_var = Variable( torch.Tensor((value,) ) )
+            if(self.use_gpu):
+                ret_var = ret_var.cuda()
+            return ret_var
+
+class DSSIM(FakeNet):
+
+    def forward(self, in0, in1, retPerLayer=None):
+        assert(in0.size()[0]==1) # currently only supports batchSize 1
+
+        if(self.colorspace=='RGB'):
+            value = lpips.dssim(1.*lpips.tensor2im(in0.data), 1.*lpips.tensor2im(in1.data), range=255.).astype('float')
+        elif(self.colorspace=='Lab'):
+            value = lpips.dssim(lpips.tensor2np(lpips.tensor2tensorlab(in0.data,to_norm=False)), 
+                lpips.tensor2np(lpips.tensor2tensorlab(in1.data,to_norm=False)), range=100.).astype('float')
+        ret_var = Variable( torch.Tensor((value,) ) )
+        if(self.use_gpu):
+            ret_var = ret_var.cuda()
+        return ret_var
+
+def print_network(net):
+    num_params = 0
+    for param in net.parameters():
+        num_params += param.numel()
+    print('Network',net)
+    print('Total number of parameters: %d' % num_params)

OVOW/third_party/Motion324/evaluation/lpips/pretrained_networks.py

@@ -0,0 +1,180 @@
+from collections import namedtuple
+import torch
+from torchvision import models as tv
+
+class squeezenet(torch.nn.Module):
+    def __init__(self, requires_grad=False, pretrained=True):
+        super(squeezenet, self).__init__()
+        pretrained_features = tv.squeezenet1_1(pretrained=pretrained).features
+        self.slice1 = torch.nn.Sequential()
+        self.slice2 = torch.nn.Sequential()
+        self.slice3 = torch.nn.Sequential()
+        self.slice4 = torch.nn.Sequential()
+        self.slice5 = torch.nn.Sequential()
+        self.slice6 = torch.nn.Sequential()
+        self.slice7 = torch.nn.Sequential()
+        self.N_slices = 7
+        for x in range(2):
+            self.slice1.add_module(str(x), pretrained_features[x])
+        for x in range(2,5):
+            self.slice2.add_module(str(x), pretrained_features[x])
+        for x in range(5, 8):
+            self.slice3.add_module(str(x), pretrained_features[x])
+        for x in range(8, 10):
+            self.slice4.add_module(str(x), pretrained_features[x])
+        for x in range(10, 11):
+            self.slice5.add_module(str(x), pretrained_features[x])
+        for x in range(11, 12):
+            self.slice6.add_module(str(x), pretrained_features[x])
+        for x in range(12, 13):
+            self.slice7.add_module(str(x), pretrained_features[x])
+        if not requires_grad:
+            for param in self.parameters():
+                param.requires_grad = False
+
+    def forward(self, X):
+        h = self.slice1(X)
+        h_relu1 = h
+        h = self.slice2(h)
+        h_relu2 = h
+        h = self.slice3(h)
+        h_relu3 = h
+        h = self.slice4(h)
+        h_relu4 = h
+        h = self.slice5(h)
+        h_relu5 = h
+        h = self.slice6(h)
+        h_relu6 = h
+        h = self.slice7(h)
+        h_relu7 = h
+        vgg_outputs = namedtuple("SqueezeOutputs", ['relu1','relu2','relu3','relu4','relu5','relu6','relu7'])
+        out = vgg_outputs(h_relu1,h_relu2,h_relu3,h_relu4,h_relu5,h_relu6,h_relu7)
+
+        return out
+
+
+class alexnet(torch.nn.Module):
+    def __init__(self, requires_grad=False, pretrained=True):
+        super(alexnet, self).__init__()
+        alexnet_pretrained_features = tv.alexnet(pretrained=pretrained).features
+        self.slice1 = torch.nn.Sequential()
+        self.slice2 = torch.nn.Sequential()
+        self.slice3 = torch.nn.Sequential()
+        self.slice4 = torch.nn.Sequential()
+        self.slice5 = torch.nn.Sequential()
+        self.N_slices = 5
+        for x in range(2):
+            self.slice1.add_module(str(x), alexnet_pretrained_features[x])
+        for x in range(2, 5):
+            self.slice2.add_module(str(x), alexnet_pretrained_features[x])
+        for x in range(5, 8):
+            self.slice3.add_module(str(x), alexnet_pretrained_features[x])
+        for x in range(8, 10):
+            self.slice4.add_module(str(x), alexnet_pretrained_features[x])
+        for x in range(10, 12):
+            self.slice5.add_module(str(x), alexnet_pretrained_features[x])
+        if not requires_grad:
+            for param in self.parameters():
+                param.requires_grad = False
+
+    def forward(self, X):
+        h = self.slice1(X)
+        h_relu1 = h
+        h = self.slice2(h)
+        h_relu2 = h
+        h = self.slice3(h)
+        h_relu3 = h
+        h = self.slice4(h)
+        h_relu4 = h
+        h = self.slice5(h)
+        h_relu5 = h
+        alexnet_outputs = namedtuple("AlexnetOutputs", ['relu1', 'relu2', 'relu3', 'relu4', 'relu5'])
+        out = alexnet_outputs(h_relu1, h_relu2, h_relu3, h_relu4, h_relu5)
+
+        return out
+
+class vgg16(torch.nn.Module):
+    def __init__(self, requires_grad=False, pretrained=True):
+        super(vgg16, self).__init__()
+        vgg_pretrained_features = tv.vgg16(pretrained=pretrained).features
+        self.slice1 = torch.nn.Sequential()
+        self.slice2 = torch.nn.Sequential()
+        self.slice3 = torch.nn.Sequential()
+        self.slice4 = torch.nn.Sequential()
+        self.slice5 = torch.nn.Sequential()
+        self.N_slices = 5
+        for x in range(4):
+            self.slice1.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(4, 9):
+            self.slice2.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(9, 16):
+            self.slice3.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(16, 23):
+            self.slice4.add_module(str(x), vgg_pretrained_features[x])
+        for x in range(23, 30):
+            self.slice5.add_module(str(x), vgg_pretrained_features[x])
+        if not requires_grad:
+            for param in self.parameters():
+                param.requires_grad = False
+
+    def forward(self, X):
+        h = self.slice1(X)
+        h_relu1_2 = h
+        h = self.slice2(h)
+        h_relu2_2 = h
+        h = self.slice3(h)
+        h_relu3_3 = h
+        h = self.slice4(h)
+        h_relu4_3 = h
+        h = self.slice5(h)
+        h_relu5_3 = h
+        vgg_outputs = namedtuple("VggOutputs", ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3', 'relu5_3'])
+        out = vgg_outputs(h_relu1_2, h_relu2_2, h_relu3_3, h_relu4_3, h_relu5_3)
+
+        return out
+
+
+
+class resnet(torch.nn.Module):
+    def __init__(self, requires_grad=False, pretrained=True, num=18):
+        super(resnet, self).__init__()
+        if(num==18):
+            self.net = tv.resnet18(pretrained=pretrained)
+        elif(num==34):
+            self.net = tv.resnet34(pretrained=pretrained)
+        elif(num==50):
+            self.net = tv.resnet50(pretrained=pretrained)
+        elif(num==101):
+            self.net = tv.resnet101(pretrained=pretrained)
+        elif(num==152):
+            self.net = tv.resnet152(pretrained=pretrained)
+        self.N_slices = 5
+
+        self.conv1 = self.net.conv1
+        self.bn1 = self.net.bn1
+        self.relu = self.net.relu
+        self.maxpool = self.net.maxpool
+        self.layer1 = self.net.layer1
+        self.layer2 = self.net.layer2
+        self.layer3 = self.net.layer3
+        self.layer4 = self.net.layer4
+
+    def forward(self, X):
+        h = self.conv1(X)
+        h = self.bn1(h)
+        h = self.relu(h)
+        h_relu1 = h
+        h = self.maxpool(h)
+        h = self.layer1(h)
+        h_conv2 = h
+        h = self.layer2(h)
+        h_conv3 = h
+        h = self.layer3(h)
+        h_conv4 = h
+        h = self.layer4(h)
+        h_conv5 = h
+
+        outputs = namedtuple("Outputs", ['relu1','conv2','conv3','conv4','conv5'])
+        out = outputs(h_relu1, h_conv2, h_conv3, h_conv4, h_conv5)
+
+        return out

OVOW/third_party/Motion324/evaluation/lpips/trainer.py

@@ -0,0 +1,280 @@
+
+from __future__ import absolute_import
+
+import numpy as np
+import torch
+from torch import nn
+from collections import OrderedDict
+from torch.autograd import Variable
+from scipy.ndimage import zoom
+from tqdm import tqdm
+import lpips
+import os
+
+
+class Trainer():
+    def name(self):
+        return self.model_name
+
+    def initialize(self, model='lpips', net='alex', colorspace='Lab', pnet_rand=False, pnet_tune=False, model_path=None,
+            use_gpu=True, printNet=False, spatial=False, 
+            is_train=False, lr=.0001, beta1=0.5, version='0.1', gpu_ids=[0]):
+        '''
+        INPUTS
+            model - ['lpips'] for linearly calibrated network
+                    ['baseline'] for off-the-shelf network
+                    ['L2'] for L2 distance in Lab colorspace
+                    ['SSIM'] for ssim in RGB colorspace
+            net - ['squeeze','alex','vgg']
+            model_path - if None, will look in weights/[NET_NAME].pth
+            colorspace - ['Lab','RGB'] colorspace to use for L2 and SSIM
+            use_gpu - bool - whether or not to use a GPU
+            printNet - bool - whether or not to print network architecture out
+            spatial - bool - whether to output an array containing varying distances across spatial dimensions
+            is_train - bool - [True] for training mode
+            lr - float - initial learning rate
+            beta1 - float - initial momentum term for adam
+            version - 0.1 for latest, 0.0 was original (with a bug)
+            gpu_ids - int array - [0] by default, gpus to use
+        '''
+        self.use_gpu = use_gpu
+        self.gpu_ids = gpu_ids
+        self.model = model
+        self.net = net
+        self.is_train = is_train
+        self.spatial = spatial
+        self.model_name = '%s [%s]'%(model,net)
+
+        if(self.model == 'lpips'): # pretrained net + linear layer
+            self.net = lpips.LPIPS(pretrained=not is_train, net=net, version=version, lpips=True, spatial=spatial, 
+                pnet_rand=pnet_rand, pnet_tune=pnet_tune, 
+                use_dropout=True, model_path=model_path, eval_mode=False)
+        elif(self.model=='baseline'): # pretrained network
+            self.net = lpips.LPIPS(pnet_rand=pnet_rand, net=net, lpips=False)
+        elif(self.model in ['L2','l2']):
+            self.net = lpips.L2(use_gpu=use_gpu,colorspace=colorspace) # not really a network, only for testing
+            self.model_name = 'L2'
+        elif(self.model in ['DSSIM','dssim','SSIM','ssim']):
+            self.net = lpips.DSSIM(use_gpu=use_gpu,colorspace=colorspace)
+            self.model_name = 'SSIM'
+        else:
+            raise ValueError("Model [%s] not recognized." % self.model)
+
+        self.parameters = list(self.net.parameters())
+
+        if self.is_train: # training mode
+            # extra network on top to go from distances (d0,d1) => predicted human judgment (h*)
+            self.rankLoss = lpips.BCERankingLoss()
+            self.parameters += list(self.rankLoss.net.parameters())
+            self.lr = lr
+            self.old_lr = lr
+            self.optimizer_net = torch.optim.Adam(self.parameters, lr=lr, betas=(beta1, 0.999))
+        else: # test mode
+            self.net.eval()
+
+        if(use_gpu):
+            self.net.to(gpu_ids[0])
+            self.net = torch.nn.DataParallel(self.net, device_ids=gpu_ids)
+            if(self.is_train):
+                self.rankLoss = self.rankLoss.to(device=gpu_ids[0]) # just put this on GPU0
+
+        if(printNet):
+            print('---------- Networks initialized -------------')
+            networks.print_network(self.net)
+            print('-----------------------------------------------')
+
+    def forward(self, in0, in1, retPerLayer=False):
+        ''' Function computes the distance between image patches in0 and in1
+        INPUTS
+            in0, in1 - torch.Tensor object of shape Nx3xXxY - image patch scaled to [-1,1]
+        OUTPUT
+            computed distances between in0 and in1
+        '''
+
+        return self.net.forward(in0, in1, retPerLayer=retPerLayer)
+
+    # ***** TRAINING FUNCTIONS *****
+    def optimize_parameters(self):
+        self.forward_train()
+        self.optimizer_net.zero_grad()
+        self.backward_train()
+        self.optimizer_net.step()
+        self.clamp_weights()
+
+    def clamp_weights(self):
+        for module in self.net.modules():
+            if(hasattr(module, 'weight') and module.kernel_size==(1,1)):
+                module.weight.data = torch.clamp(module.weight.data,min=0)
+
+    def set_input(self, data):
+        self.input_ref = data['ref']
+        self.input_p0 = data['p0']
+        self.input_p1 = data['p1']
+        self.input_judge = data['judge']
+
+        if(self.use_gpu):
+            self.input_ref = self.input_ref.to(device=self.gpu_ids[0])
+            self.input_p0 = self.input_p0.to(device=self.gpu_ids[0])
+            self.input_p1 = self.input_p1.to(device=self.gpu_ids[0])
+            self.input_judge = self.input_judge.to(device=self.gpu_ids[0])
+
+        self.var_ref = Variable(self.input_ref,requires_grad=True)
+        self.var_p0 = Variable(self.input_p0,requires_grad=True)
+        self.var_p1 = Variable(self.input_p1,requires_grad=True)
+
+    def forward_train(self): # run forward pass
+        self.d0 = self.forward(self.var_ref, self.var_p0)
+        self.d1 = self.forward(self.var_ref, self.var_p1)
+        self.acc_r = self.compute_accuracy(self.d0,self.d1,self.input_judge)
+
+        self.var_judge = Variable(1.*self.input_judge).view(self.d0.size())
+
+        self.loss_total = self.rankLoss.forward(self.d0, self.d1, self.var_judge*2.-1.)
+
+        return self.loss_total
+
+    def backward_train(self):
+        torch.mean(self.loss_total).backward()
+
+    def compute_accuracy(self,d0,d1,judge):
+        ''' d0, d1 are Variables, judge is a Tensor '''
+        d1_lt_d0 = (d1<d0).cpu().data.numpy().flatten()
+        judge_per = judge.cpu().numpy().flatten()
+        return d1_lt_d0*judge_per + (1-d1_lt_d0)*(1-judge_per)
+
+    def get_current_errors(self):
+        retDict = OrderedDict([('loss_total', self.loss_total.data.cpu().numpy()),
+                            ('acc_r', self.acc_r)])
+
+        for key in retDict.keys():
+            retDict[key] = np.mean(retDict[key])
+
+        return retDict
+
+    def get_current_visuals(self):
+        zoom_factor = 256/self.var_ref.data.size()[2]
+
+        ref_img = lpips.tensor2im(self.var_ref.data)
+        p0_img = lpips.tensor2im(self.var_p0.data)
+        p1_img = lpips.tensor2im(self.var_p1.data)
+
+        ref_img_vis = zoom(ref_img,[zoom_factor, zoom_factor, 1],order=0)
+        p0_img_vis = zoom(p0_img,[zoom_factor, zoom_factor, 1],order=0)
+        p1_img_vis = zoom(p1_img,[zoom_factor, zoom_factor, 1],order=0)
+
+        return OrderedDict([('ref', ref_img_vis),
+                            ('p0', p0_img_vis),
+                            ('p1', p1_img_vis)])
+
+    def save(self, path, label):
+        if(self.use_gpu):
+            self.save_network(self.net.module, path, '', label)
+        else:
+            self.save_network(self.net, path, '', label)
+        self.save_network(self.rankLoss.net, path, 'rank', label)
+
+    # helper saving function that can be used by subclasses
+    def save_network(self, network, path, network_label, epoch_label):
+        save_filename = '%s_net_%s.pth' % (epoch_label, network_label)
+        save_path = os.path.join(path, save_filename)
+        torch.save(network.state_dict(), save_path)
+
+    # helper loading function that can be used by subclasses
+    def load_network(self, network, network_label, epoch_label):
+        save_filename = '%s_net_%s.pth' % (epoch_label, network_label)
+        save_path = os.path.join(self.save_dir, save_filename)
+        print('Loading network from %s'%save_path)
+        network.load_state_dict(torch.load(save_path))
+
+    def update_learning_rate(self,nepoch_decay):
+        lrd = self.lr / nepoch_decay
+        lr = self.old_lr - lrd
+
+        for param_group in self.optimizer_net.param_groups:
+            param_group['lr'] = lr
+
+        print('update lr [%s] decay: %f -> %f' % (type,self.old_lr, lr))
+        self.old_lr = lr
+
+
+    def get_image_paths(self):
+        return self.image_paths
+
+    def save_done(self, flag=False):
+        np.save(os.path.join(self.save_dir, 'done_flag'),flag)
+        np.savetxt(os.path.join(self.save_dir, 'done_flag'),[flag,],fmt='%i')
+
+
+def score_2afc_dataset(data_loader, func, name=''):
+    ''' Function computes Two Alternative Forced Choice (2AFC) score using
+        distance function 'func' in dataset 'data_loader'
+    INPUTS
+        data_loader - CustomDatasetDataLoader object - contains a TwoAFCDataset inside
+        func - callable distance function - calling d=func(in0,in1) should take 2
+            pytorch tensors with shape Nx3xXxY, and return numpy array of length N
+    OUTPUTS
+        [0] - 2AFC score in [0,1], fraction of time func agrees with human evaluators
+        [1] - dictionary with following elements
+            d0s,d1s - N arrays containing distances between reference patch to perturbed patches 
+            gts - N array in [0,1], preferred patch selected by human evaluators
+                (closer to "0" for left patch p0, "1" for right patch p1,
+                "0.6" means 60pct people preferred right patch, 40pct preferred left)
+            scores - N array in [0,1], corresponding to what percentage function agreed with humans
+    CONSTS
+        N - number of test triplets in data_loader
+    '''
+
+    d0s = []
+    d1s = []
+    gts = []
+
+    for data in tqdm(data_loader.load_data(), desc=name):
+        d0s+=func(data['ref'],data['p0']).data.cpu().numpy().flatten().tolist()
+        d1s+=func(data['ref'],data['p1']).data.cpu().numpy().flatten().tolist()
+        gts+=data['judge'].cpu().numpy().flatten().tolist()
+
+    d0s = np.array(d0s)
+    d1s = np.array(d1s)
+    gts = np.array(gts)
+    scores = (d0s<d1s)*(1.-gts) + (d1s<d0s)*gts + (d1s==d0s)*.5
+
+    return(np.mean(scores), dict(d0s=d0s,d1s=d1s,gts=gts,scores=scores))
+
+def score_jnd_dataset(data_loader, func, name=''):
+    ''' Function computes JND score using distance function 'func' in dataset 'data_loader'
+    INPUTS
+        data_loader - CustomDatasetDataLoader object - contains a JNDDataset inside
+        func - callable distance function - calling d=func(in0,in1) should take 2
+            pytorch tensors with shape Nx3xXxY, and return pytorch array of length N
+    OUTPUTS
+        [0] - JND score in [0,1], mAP score (area under precision-recall curve)
+        [1] - dictionary with following elements
+            ds - N array containing distances between two patches shown to human evaluator
+            sames - N array containing fraction of people who thought the two patches were identical
+    CONSTS
+        N - number of test triplets in data_loader
+    '''
+
+    ds = []
+    gts = []
+
+    for data in tqdm(data_loader.load_data(), desc=name):
+        ds+=func(data['p0'],data['p1']).data.cpu().numpy().tolist()
+        gts+=data['same'].cpu().numpy().flatten().tolist()
+
+    sames = np.array(gts)
+    ds = np.array(ds)
+
+    sorted_inds = np.argsort(ds)
+    ds_sorted = ds[sorted_inds]
+    sames_sorted = sames[sorted_inds]
+
+    TPs = np.cumsum(sames_sorted)
+    FPs = np.cumsum(1-sames_sorted)
+    FNs = np.sum(sames_sorted)-TPs
+
+    precs = TPs/(TPs+FPs)
+    recs = TPs/(TPs+FNs)
+    score = lpips.voc_ap(recs,precs)
+
+    return(score, dict(ds=ds,sames=sames))

OVOW/third_party/Motion324/experiments/checkpoints/ckpt_0000000000060000.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:010696cea050b6be9f4ff540ccbfd9b5e17d0f97080f73009ff0b539c5dd8d15
+size 2240544438

OVOW/third_party/Motion324/model/Pcd_motion.py

@@ -0,0 +1,598 @@
+import os
+import math
+import time
+import traceback
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from easydict import EasyDict as edict
+from .transformer import (QK_Norm_TransformerBlock, init_weights, 
+                          QK_Norm_CrossAttentionBlock)
+from .loss import MSELossComputer
+from .image_encoder.dinov2 import DinoEncoder
+
+class FrequencyPositionalEmbedding(nn.Module):
+    """The sin/cosine positional embedding. Given an input tensor `x` of shape [n_batch, ..., c_dim], it converts
+    each feature dimension of `x[..., i]` into:
+        [
+            sin(x[..., i]),
+            sin(f_1*x[..., i]),
+            sin(f_2*x[..., i]),
+            ...
+            sin(f_N * x[..., i]),
+            cos(x[..., i]),
+            cos(f_1*x[..., i]),
+            cos(f_2*x[..., i]),
+            ...
+            cos(f_N * x[..., i]),
+            x[..., i]     # only present if include_input is True.
+        ], here f_i is the frequency.
+
+    Denote the space is [0 / num_freqs, 1 / num_freqs, 2 / num_freqs, 3 / num_freqs, ..., (num_freqs - 1) / num_freqs].
+    If logspace is True, then the frequency f_i is [2^(0 / num_freqs), ..., 2^(i / num_freqs), ...];
+    Otherwise, the frequencies are linearly spaced between [1.0, 2^(num_freqs - 1)].
+
+    Args:
+        num_freqs (int): the number of frequencies, default is 6;
+        logspace (bool): If logspace is True, then the frequency f_i is [..., 2^(i / num_freqs), ...],
+            otherwise, the frequencies are linearly spaced between [1.0, 2^(num_freqs - 1)];
+        input_dim (int): the input dimension, default is 3;
+        include_input (bool): include the input tensor or not, default is True.
+
+    Attributes:
+        frequencies (torch.Tensor): If logspace is True, then the frequency f_i is [..., 2^(i / num_freqs), ...],
+                otherwise, the frequencies are linearly spaced between [1.0, 2^(num_freqs - 1);
+
+        out_dim (int): the embedding size, if include_input is True, it is input_dim * (num_freqs * 2 + 1),
+            otherwise, it is input_dim * num_freqs * 2.
+
+    """
+
+    def __init__(
+        self,
+        num_freqs: int = 6,
+        logspace: bool = True,
+        input_dim: int = 3,
+        include_input: bool = True,
+        include_pi: bool = True,
+    ) -> None:
+        """The initialization"""
+
+        super().__init__()
+
+        if logspace:
+            frequencies = 2.0 ** torch.arange(num_freqs, dtype=torch.float32)
+        else:
+            frequencies = torch.linspace(
+                1.0, 2.0 ** (num_freqs - 1), num_freqs, dtype=torch.float32
+            )
+
+        if include_pi:
+            frequencies *= torch.pi
+
+        self.register_buffer("frequencies", frequencies, persistent=False)
+        self.include_input = include_input
+        self.num_freqs = num_freqs
+
+        self.out_dim = self._get_dims(input_dim)
+
+    def _get_dims(self, input_dim):
+        temp = 1 if self.include_input or self.num_freqs == 0 else 0
+        out_dim = input_dim * (self.num_freqs * 2 + temp)
+
+        return out_dim
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Forward process.
+
+        Args:
+            x: tensor of shape [..., dim]
+
+        Returns:
+            embedding: an embedding of `x` of shape [..., dim * (num_freqs * 2 + temp)]
+                where temp is 1 if include_input is True and 0 otherwise.
+        """
+
+        if self.num_freqs > 0:
+            embed = (x[..., None].contiguous() * self.frequencies.to(device=x.device)).view(
+                *x.shape[:-1], -1
+            )
+            if self.include_input:
+                return torch.cat((x, embed.sin(), embed.cos()), dim=-1)
+            else:
+                return torch.cat((embed.sin(), embed.cos()), dim=-1)
+        else:
+            return x
+
+def get_sinusoidal_time_embed(num_frames, embed_dim, device):
+    """
+    Generate time embedding with shape=[num_frames, embed_dim].
+    """
+    position = torch.arange(num_frames, dtype=torch.float32, device=device).unsqueeze(1)
+    div_term = torch.exp(torch.arange(0, embed_dim, 2, device=device).float() * (-math.log(10000.0) / embed_dim))
+    pe = torch.zeros(num_frames, embed_dim, device=device)
+    pe[:, 0::2] = torch.sin(position * div_term)
+    pe[:, 1::2] = torch.cos(position * div_term)
+    return pe  # [T, C]
+
+class SinusoidalPositionalEncoding(nn.Module):
+    """
+    Sinusoidal positional encoding module.
+    """
+    def __init__(self, d_model: int, max_len: int = 4096, dropout: float = 0.0):
+        """
+        Args:
+            d_model (int): Model dimension (embedding dimension).
+            max_len (int): Maximum sequence length supported.
+            dropout (float): Dropout rate.
+        """
+        super().__init__()
+        self.dropout = nn.Dropout(p=dropout)
+
+        if d_model % 2 != 0:
+            raise ValueError(f"d_model ({d_model}) must be even to use paired sin/cos for sinusoidal positional encoding.")
+
+        position = torch.arange(max_len).unsqueeze(1)  # Shape: [max_len, 1]
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)) # Shape: [d_model / 2]
+        
+        pe = torch.zeros(1, max_len, d_model)
+        pe[0, :, 0::2] = torch.sin(position * div_term)
+        pe[0, :, 1::2] = torch.cos(position * div_term)
+        
+        self.register_buffer('pe', pe)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Forward propagation.
+        Args:
+            x: Input tensor with shape [batch_size, seq_len, embedding_dim]
+        Returns:
+            torch.Tensor: Output tensor with positional encoding added, same shape as input.
+        """
+        x = x + self.pe[:, :x.size(1), :]
+        return self.dropout(x)
+
+class PointEmbed(nn.Module):
+    def __init__(self, hidden_dim=48, dim=768):
+        super().__init__()
+
+        assert hidden_dim % 6 == 0
+
+        self.embedding_dim = hidden_dim
+        e = torch.pow(2, torch.arange(self.embedding_dim // 6)).float() * np.pi
+        e = torch.stack([
+            torch.cat([e, torch.zeros(self.embedding_dim // 6),
+                        torch.zeros(self.embedding_dim // 6)]),
+            torch.cat([torch.zeros(self.embedding_dim // 6), e,
+                        torch.zeros(self.embedding_dim // 6)]),
+            torch.cat([torch.zeros(self.embedding_dim // 6),
+                        torch.zeros(self.embedding_dim // 6), e]),
+        ])
+        self.register_buffer('basis', e)  # 3 x 16
+
+        self.mlp = nn.Linear(self.embedding_dim+3, dim)
+
+    @staticmethod
+    def embed(input, basis):
+        projections = torch.einsum(
+            'bnd,de->bne', input, basis)
+        embeddings = torch.cat([projections.sin(), projections.cos()], dim=2)
+        return embeddings
+    
+    def forward(self, input):
+        # input: B x N x 3
+        embed = self.mlp(torch.cat([self.embed(input, self.basis), input], dim=2)) # B x N x C
+        return embed
+        
+class PatchEmbed(nn.Module):#4 patch_length normal
+    """Video patch embedding layer."""
+    def __init__(self, video_size=224, video_length=16, patch_size=16, patch_length=4, 
+                 in_chans=3, embed_dim=768):
+        super().__init__()
+        self.video_size = video_size
+        self.video_length = video_length
+        self.patch_size = patch_size
+        self.patch_length = patch_length
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+        
+        # Calculate number of patches
+        self.num_patches_h = video_size // patch_size
+        self.num_patches_w = video_size // patch_size
+        self.num_patches_t = video_length // patch_length
+        self.num_patches = self.num_patches_t * self.num_patches_h * self.num_patches_w
+        
+        # Patch embedding layer
+        self.proj = nn.Conv3d(in_chans, embed_dim, 
+                             kernel_size=(patch_length, patch_size, patch_size),
+                             stride=(patch_length, patch_size, patch_size))
+    
+    def forward(self, x):
+        # Input: B, C, T, H, W
+        B, C, T, H, W = x.shape
+        assert T == self.video_length and H == self.video_size and W == self.video_size, \
+            f"Input size mismatch: got {T}x{H}x{W}, expected {self.video_length}x{self.video_size}x{self.video_size}"
+        
+        x = self.proj(x)  # B, embed_dim, T/pT, H/pH, W/pW
+        return x
+
+def resize_pos_embed(posemb, src_shape, target_shape):
+    """Resize position embedding to match target shape."""
+    posemb = posemb.reshape(1, src_shape[0], src_shape[1], src_shape[2], -1)
+    posemb = posemb.permute(0, 4, 1, 2, 3)
+    posemb = nn.functional.interpolate(posemb, size=target_shape, mode='trilinear', align_corners=False)
+    posemb = posemb.permute(0, 2, 3, 4, 1)
+    posemb = posemb.reshape(1, target_shape[0] * target_shape[1] * target_shape[2], -1)
+    return posemb
+
+def generate_pos_embed(T, H, W, embed_dim):
+    """Generate 3D position embedding."""
+    latent_t = torch.arange(T, dtype=torch.float32)
+    latent_h = torch.arange(H, dtype=torch.float32)
+    latent_w = torch.arange(W, dtype=torch.float32)
+    
+    if T > 1:
+        latent_t = 2 * (latent_t / (T - 1)) - 1
+    else:
+        latent_t = torch.tensor([0.0], dtype=torch.float32)
+
+    if H > 1:
+        latent_h = 2 * (latent_h / (H - 1)) - 1
+    else:
+        latent_h = torch.tensor([0.0], dtype=torch.float32)
+
+    if W > 1:
+        latent_w = 2 * (latent_w / (W - 1)) - 1
+    else:
+        latent_w = torch.tensor([0.0], dtype=torch.float32)
+
+    t, h, w = torch.meshgrid(latent_t, latent_h, latent_w, indexing='ij')
+    
+    pos = torch.stack([t, h, w], dim=-1)
+
+    # Apply Fourier feature mapping
+    freq_bands = 2.0 ** torch.linspace(0.0, 7.0, embed_dim // 6)
+    freq_bands = freq_bands.view(1, 1, 1, 1, -1)
+    
+    # Project to higher dimensions using sin and cos
+    pos = pos.unsqueeze(-1) * freq_bands
+    pos = torch.cat([torch.sin(pos), torch.cos(pos)], dim=-1)
+    
+    # Reshape to 1D sequence
+    pos = pos.reshape(1, -1, embed_dim)
+    
+    return pos
+
+class Motion_Latent_Model(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.config = config
+        self.feat_dim = self.config.model.feat_dim
+        
+        self._init_video_patchify()
+    
+        transformer_config = self.config.model.video_encoder.transformer
+        use_qk_norm = transformer_config.get("use_qk_norm", True)
+        d_model = transformer_config.d
+        d_head = transformer_config.d_head
+
+        use_qk_norm = transformer_config.get("use_qk_norm", True)
+
+        self.point_embed = PointEmbed(dim=transformer_config.d)
+        self.point_normal_rgb_proj = nn.Linear(transformer_config.d + 3 + 3, transformer_config.d)
+        self.point_normal_rgb_proj.apply(init_weights)
+
+        self.num_learnable_tokens = config.model.tokens
+        self.learnable_tokens = nn.Parameter(torch.randn(1, self.num_learnable_tokens, d_model))
+
+        # Special tokens for t=0 and t>0. Each is (1, 4, d_model).
+        self.special_token_0 = nn.Parameter(torch.randn(1, 4, d_model))
+        self.special_token_rest = nn.Parameter(torch.randn(1, 4, d_model))
+
+        self.encoder_cross_attn = QK_Norm_CrossAttentionBlock(
+            dim=d_model,
+            head_dim=d_head,
+            kv_dim=d_model,
+            use_qk_norm=use_qk_norm
+        )
+
+        self.points_transformer_blocks = nn.ModuleList([
+            QK_Norm_TransformerBlock(
+                transformer_config.d, transformer_config.d_head, use_qk_norm=use_qk_norm
+            ) for _ in range(config.model.pcd_layers)
+        ])
+        self.points_transformer_blocks.apply(init_weights)
+
+        self.image_encoder = DinoEncoder(patch_size=14)
+        self.alternating_layers = transformer_config.get("n_layer", 12)
+        assert self.alternating_layers % 2 == 0, "Alternating layers should be even."
+        
+        self.global_transformer_blocks = nn.ModuleList([
+            QK_Norm_TransformerBlock(
+                transformer_config.d, transformer_config.d_head, use_qk_norm=use_qk_norm
+            ) for _ in range(self.alternating_layers // 2)
+        ])
+        self.global_transformer_blocks.apply(init_weights)
+
+        self.local_transformer_blocks = nn.ModuleList([
+            QK_Norm_TransformerBlock(
+                transformer_config.d, transformer_config.d_head, use_qk_norm=use_qk_norm
+            ) for _ in range(self.alternating_layers // 2)
+        ])
+        self.local_transformer_blocks.apply(init_weights)
+
+        self.transformer_input_layernorm = nn.LayerNorm(transformer_config.d, bias=False)
+        self.transformer_input_layernorm.apply(init_weights)
+
+        self.decoder_cross_attn = QK_Norm_CrossAttentionBlock(
+            dim=d_model,
+            head_dim=d_head,
+            kv_dim=d_model,
+            use_qk_norm=use_qk_norm
+        )
+
+        self.shared_mlp_output = nn.Sequential(
+            nn.LayerNorm(self.feat_dim),
+            nn.Linear(self.feat_dim, self.feat_dim),
+            nn.GELU(),
+            nn.Linear(self.feat_dim, 3),
+        )
+        self.shared_mlp_output.apply(init_weights)
+
+        self.loss_computer = MSELossComputer(self.config)
+
+    def _init_video_patchify(self):
+        video_config = self.config.model.video_encoder
+        transformer_config = video_config.transformer
+        token_config = video_config.image_tokenizer
+        
+        self.image_size = token_config.get("image_size", 224)
+        self.video_length = self.config.training.frames
+        self.patch_size = token_config.get("patch_size", 14)
+        self.patch_length = token_config.get("patch_length", 1)
+        self.embed_dim = transformer_config.d
+        
+        self.num_patches_h = self.image_size // self.patch_size
+        self.num_patches_w = self.image_size // self.patch_size
+        self.num_patches_t = self.video_length // self.patch_length
+        
+        self.latent_length = self.num_patches_t
+        self.latent_size = self.num_patches_h  # Assuming square patches
+        
+        pos_embed = generate_pos_embed(
+            self.latent_length, self.latent_size, self.latent_size, self.embed_dim
+        )
+        self.register_buffer('pos_embed', pos_embed)
+        
+        drop_rate = transformer_config.get("drop_rate", 0.1)
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+    def train(self, mode=True):
+        super().train(mode)
+
+    def pass_transformer_layers(self, blocks, input_tokens, gradient_checkpoint=False, checkpoint_every=1):
+        num_layers = len(blocks)
+        if not gradient_checkpoint:
+            for layer in blocks:
+                input_tokens = layer(input_tokens)
+            return input_tokens
+            
+        def _process_layer_group(tokens, start_idx, end_idx):
+            for idx in range(start_idx, end_idx):
+                tokens = blocks[idx](tokens)
+            return tokens
+            
+        for start_idx in range(0, num_layers, checkpoint_every):
+            end_idx = min(start_idx + checkpoint_every, num_layers)
+            input_tokens = torch.utils.checkpoint.checkpoint(
+                _process_layer_group, input_tokens, start_idx, end_idx, use_reentrant=False
+            )
+        return input_tokens
+        
+    def pass_alternating_attention(self, input_tokens, gradient_checkpoint=False, checkpoint_every=1):
+        B, T, L, C = input_tokens.shape
+        num_loops = len(self.global_transformer_blocks)
+
+        if not gradient_checkpoint:
+            processed_tokens = input_tokens
+            for i in range(num_loops):
+                processed_tokens = processed_tokens.view(B, T * L, C)
+                processed_tokens = self.global_transformer_blocks[i](
+                    processed_tokens
+                )
+                processed_tokens = processed_tokens.view(B, T, L, C)
+                processed_tokens_reshaped = processed_tokens.view(B * T, L, C)
+                processed_tokens_local = self.local_transformer_blocks[i](processed_tokens_reshaped)
+                processed_tokens = processed_tokens_local.view(B, T, L, C)
+            return processed_tokens
+
+        def _process_alternating_group(tokens, start_idx, end_idx):
+            for i in range(start_idx, end_idx):
+                tokens = tokens.view(B, T * L, C)
+                tokens = self.global_transformer_blocks[i](
+                    tokens
+                )
+                tokens = tokens.view(B, T, L, C)
+                tokens_reshaped = tokens.view(B * T, L, C)
+                tokens_processed = self.local_transformer_blocks[i](tokens_reshaped)
+                tokens = tokens_processed.view(B, T, L, C)
+            return tokens
+        
+        processed_tokens = input_tokens
+        for start_idx in range(0, num_loops, checkpoint_every):
+            end_idx = min(start_idx + checkpoint_every, num_loops)
+            processed_tokens = torch.utils.checkpoint.checkpoint(
+                _process_alternating_group, processed_tokens, start_idx, end_idx, use_reentrant=False
+            )
+        return processed_tokens
+
+    def pass_pcd_layers(self, input_tokens, gradient_checkpoint=False, checkpoint_every=1):
+        num_layers = len(self.points_transformer_blocks)
+        if not gradient_checkpoint:
+            for layer in self.points_transformer_blocks:
+                input_tokens = layer(input_tokens)
+            return input_tokens
+            
+        def _process_layer_group(tokens, start_idx, end_idx):
+            for idx in range(start_idx, end_idx):
+                tokens = self.points_transformer_blocks[idx](tokens)
+            return tokens
+            
+        for start_idx in range(0, num_layers, checkpoint_every):
+            end_idx = min(start_idx + checkpoint_every, num_layers)
+            input_tokens = torch.utils.checkpoint.checkpoint(
+                _process_layer_group, input_tokens, start_idx, end_idx, use_reentrant=False
+            )
+        return input_tokens
+
+    def forward(self, sample):
+        B = sample['ref_pcd'].shape[0]
+        N_points = sample['ref_pcd'].shape[1]
+        device = sample['ref_pcd'].device
+        tokens = self.learnable_tokens.shape[1]
+        
+        point_embedding = self.point_embed(sample['ref_shape_pcd'])
+        checkpoint_every = self.config.training.grad_checkpoint_every
+        
+        point_normal_rgb_embedding = self.point_normal_rgb_proj(torch.cat([point_embedding, sample['ref_shape_normals'], sample['ref_shape_rgbs']], dim=-1))
+        
+        query_tokens = self.learnable_tokens.expand(B, -1, -1).to(device)
+        mesh_point_feat = self.encoder_cross_attn(query_tokens, point_normal_rgb_embedding, point_normal_rgb_embedding)
+        use_checkpoint = self.config.training.get('use_checkpoint', True)
+        mesh_feat = self.pass_pcd_layers(mesh_point_feat, gradient_checkpoint=use_checkpoint, checkpoint_every=checkpoint_every)
+
+        rgb_video = sample['rgb_video']  # B, T, H, W, C
+        B_vid, T_in, H_in, W_in, C_rgb = rgb_video.shape
+        #assert self.config.training.frames == T_in, "Mismatch between configured frames and input video frames."
+
+        tokenizer_input = rgb_video.permute(0, 1, 4, 2, 3)
+        tokenizer_input = tokenizer_input.reshape(B_vid * T_in, tokenizer_input.shape[-3], tokenizer_input.shape[-2], tokenizer_input.shape[-1])
+        tokenizer_input = F.interpolate(tokenizer_input, (self.image_size, self.image_size), mode="bilinear", align_corners=False)
+        
+        with torch.no_grad():
+            image_tokens_raw = self.image_encoder(tokenizer_input)
+        
+        x = image_tokens_raw.view(B_vid, T_in, self.num_patches_h, self.num_patches_w, image_tokens_raw.shape[-1])
+        x = x.permute(0, 4, 1, 2, 3)
+        latentT, latentH, latentW = x.shape[2], x.shape[3], x.shape[4]
+        x = x.flatten(2).transpose(1, 2)
+        if latentT != self.latent_length or latentH != self.latent_size or latentW != self.latent_size:
+            pos_embed = resize_pos_embed(
+                self.pos_embed,
+                src_shape=(self.latent_length, self.latent_size, self.latent_size),
+                target_shape=(latentT, latentH, latentW),
+            )
+        else:
+            pos_embed = self.pos_embed
+        x = x + pos_embed
+        x = self.pos_drop(x)
+        video_tokens_projected = x
+        num_video_patches_per_frame = video_tokens_projected.shape[1] // T_in
+        video_tokens_per_frame = video_tokens_projected.view(B, T_in, num_video_patches_per_frame, -1)  # [B,T,L_img,C]
+
+        special_token_0 = self.special_token_0.expand(B, 4, -1)  # [B, 4, C]
+        special_token_rest = self.special_token_rest.expand(B, 4, -1)  # [B, 4, C]
+
+        all_special_tokens = torch.stack([special_token_0] + [special_token_rest]*(T_in-1), dim=1)  # [B, T_in, 4, C]
+
+        # mesh_feat: [B, tokens, C] -> [B, T_in, tokens, C]
+        pcd_tokens_repeated = mesh_feat.unsqueeze(1).expand(B, T_in, tokens, mesh_feat.shape[-1])  # [B, T_in, tokens, C]
+        # [B, T_in, tokens+4+L_img, C]
+        concatenated_tokens = torch.cat([
+            all_special_tokens,
+            pcd_tokens_repeated,                         # [B, T_in, tokens, C]
+            video_tokens_per_frame                       # [B,T_in,L_img,C]
+        ], dim=2)
+
+        concatenated_tokens = self.transformer_input_layernorm(concatenated_tokens)
+        B, T, L, C = concatenated_tokens.shape
+        
+        use_checkpoint = self.config.training.get('use_checkpoint', True)
+        checkpoint_every = self.config.training.get('grad_checkpoint_every', 1)
+
+        processed_tokens_BTLC = self.pass_alternating_attention(
+            input_tokens=concatenated_tokens,
+            gradient_checkpoint=use_checkpoint,
+            checkpoint_every=checkpoint_every
+        )
+        pcd_tokens_final = processed_tokens_BTLC[:, :, 4:4+tokens, :]
+
+        output_pcds = sample['ref_pcd']
+        output_normals = sample['ref_normal']
+        output_rgbs = sample['ref_rgb']
+
+        B, N, _ = output_pcds.shape
+        chunk_size = 4096
+
+        def decode_chunk(pcd_chunk, normal_chunk, rgb_chunk, pcd_tokens_for_decode):
+            B = pcd_chunk.shape[0]
+            N = pcd_chunk.shape[1]
+            T = T_in
+            # Repeat to [B, T_in, N, C]
+            pcd_chunk_proj = pcd_chunk[:, None, :, :].expand(-1, T, -1, -1)
+            normal_chunk_proj = normal_chunk[:, None, :, :].expand(-1, T, -1, -1)
+            rgb_chunk_proj = rgb_chunk[:, None, :, :].expand(-1, T, -1, -1)
+
+            outputs = []
+            for t in range(T):
+                # For each time step, get corresponding token slice
+                # pcd_tokens_for_decode: [B, T_in, tokens, C]
+                pcd_tokens_t = pcd_tokens_for_decode[:, t, :, :]  # [B, tokens, C]
+
+                # The inputs for this time step
+                pcd_input = pcd_chunk_proj[:, t, :, :]  # [B, N, C]
+                normal_input = normal_chunk_proj[:, t, :, :]
+                rgb_input = rgb_chunk_proj[:, t, :, :]
+
+                # Project and concat features
+                out_ref_emb = self.point_embed(pcd_input)
+                point_feat = self.point_normal_rgb_proj(torch.cat([
+                    out_ref_emb, normal_input, rgb_input
+                ], dim=-1))
+
+                # query: [B, chunk_size, C], key/value: [B, num_pcd_tokens, C]
+                decoded_out_t = self.decoder_cross_attn(
+                    query=point_feat,
+                    key=pcd_tokens_t,
+                    value=pcd_tokens_t
+                )
+                output_t = self.shared_mlp_output(decoded_out_t) # [B, N, 3]
+                outputs.append(output_t)
+            decoded_chunk = torch.stack(outputs, dim=1).contiguous().view(-1, outputs[0].shape[1], outputs[0].shape[2])
+            return decoded_chunk
+
+        if not self.training and N > chunk_size:
+            pcds_chunks = []
+            for i in range(0, N, chunk_size):
+                pcd_chunk_slice = output_pcds[:, i:i + chunk_size, :]
+                normal_chunk_slice = output_normals[:, i:i + chunk_size, :]
+                rgb_chunk_slice = output_rgbs[:, i:i + chunk_size, :]
+                
+                decoded_chunk = decode_chunk(pcd_chunk_slice, normal_chunk_slice, rgb_chunk_slice, pcd_tokens_final)
+                pcds_chunks.append(decoded_chunk)
+            pcds = torch.cat(pcds_chunks, dim=1) # [B*T, N, C]
+        else:
+            pcds = decode_chunk(output_pcds, output_normals, output_rgbs, pcd_tokens_final) # [B*T, N, C]
+
+        output = pcds.view(B, T_in, N_points, 3)
+        
+        # Check if ground truth is available for loss computation
+        if 'point_clouds' in sample:
+            xyz_loss_metrics = self.loss_computer(output[..., :3], sample['point_clouds'])
+            loss_metrics = edict()
+            loss_metrics.loss = xyz_loss_metrics.loss
+            loss_metrics.xyz_loss = xyz_loss_metrics.coord_mse_loss
+            
+            result = edict(
+                input_data=sample,
+                pcd_moved=output[..., :3],
+                loss_metrics=loss_metrics
+            )
+        else:
+            result = edict(
+                input_data=sample,
+                pcd_moved=output[..., :3]
+            )
+        return result

OVOW/third_party/Motion324/model/image_encoder/dino/model_dino.py

@@ -0,0 +1,859 @@
+# coding=utf-8
+# Copyright 2023 Meta AI and The HuggingFace Inc. team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" PyTorch DINOv2 model."""
+
+
+import collections.abc
+import math
+from typing import Dict, List, Optional, Set, Tuple, Union
+
+import torch
+import torch.utils.checkpoint
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from transformers.activations import ACT2FN
+from transformers.modeling_outputs import (
+    BackboneOutput,
+    BaseModelOutput,
+    BaseModelOutputWithPooling,
+    ImageClassifierOutput,
+)
+from transformers.modeling_utils import PreTrainedModel
+from transformers.pytorch_utils import find_pruneable_heads_and_indices, prune_linear_layer
+from transformers.utils import (
+    add_code_sample_docstrings,
+    add_start_docstrings,
+    add_start_docstrings_to_model_forward,
+    logging,
+    replace_return_docstrings,
+)
+from transformers.utils.backbone_utils import BackboneMixin
+from transformers.models.dinov2.configuration_dinov2 import Dinov2Config
+
+
+logger = logging.get_logger(__name__)
+
+# General docstring
+_CONFIG_FOR_DOC = "Dinov2Config"
+
+# Base docstring
+_CHECKPOINT_FOR_DOC = "facebook/dinov2-base"
+_EXPECTED_OUTPUT_SHAPE = [1, 257, 768]
+
+# Image classification docstring
+_IMAGE_CLASS_CHECKPOINT = "facebook/dinov2-small-imagenet1k-1-layer"
+_IMAGE_CLASS_EXPECTED_OUTPUT = "tabby, tabby cat"
+
+
+DINOV2_PRETRAINED_MODEL_ARCHIVE_LIST = [
+    "facebook/dinov2-base",
+    # See all DINOv2 models at https://huggingface.co/models?filter=dinov2
+]
+
+
+class Dinov2Embeddings(nn.Module):
+    """
+    Construct the CLS token, mask token, position and patch embeddings.
+    """
+
+    def __init__(self, config: Dinov2Config) -> None:
+        super().__init__()
+
+        self.cls_token = nn.Parameter(torch.randn(1, 1, config.hidden_size))
+        self.mask_token = nn.Parameter(torch.zeros(1, config.hidden_size))
+        self.patch_embeddings = Dinov2PatchEmbeddings(config)
+        num_patches = self.patch_embeddings.num_patches
+        self.position_embeddings = nn.Parameter(torch.randn(1, num_patches + 1, config.hidden_size))
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+        self.config = config
+
+    def interpolate_pos_encoding(self, embeddings: torch.Tensor, height: int, width: int) -> torch.Tensor:
+        """
+        This method allows to interpolate the pre-trained position encodings, to be able to use the model on higher
+        resolution images.
+
+        Source:
+        https://github.com/facebookresearch/dino/blob/de9ee3df6cf39fac952ab558447af1fa1365362a/vision_transformer.py#L174
+        """
+
+        num_patches = embeddings.shape[1] - 1
+        num_positions = self.position_embeddings.shape[1] - 1
+        if num_patches == num_positions and height == width:
+            return self.position_embeddings
+        class_pos_embed = self.position_embeddings[:, 0]
+        patch_pos_embed = self.position_embeddings[:, 1:]
+        dim = embeddings.shape[-1]
+        height = height // self.config.patch_size
+        width = width // self.config.patch_size
+        # we add a small number to avoid floating point error in the interpolation
+        # see discussion at https://github.com/facebookresearch/dino/issues/8
+        height, width = height + 0.1, width + 0.1
+        patch_pos_embed = patch_pos_embed.reshape(1, int(math.sqrt(num_positions)), int(math.sqrt(num_positions)), dim)
+        patch_pos_embed = patch_pos_embed.permute(0, 3, 1, 2)
+        target_dtype = patch_pos_embed.dtype
+        patch_pos_embed = nn.functional.interpolate(
+            patch_pos_embed.to(dtype=torch.float32),
+            scale_factor=(float(height / math.sqrt(num_positions)), float(width / math.sqrt(num_positions))),
+            mode="bicubic",
+            align_corners=False,
+        ).to(dtype=target_dtype)
+        if int(height) != patch_pos_embed.shape[-2] or int(width) != patch_pos_embed.shape[-1]:
+            raise ValueError("Width or height does not match with the interpolated position embeddings")
+        patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
+        return torch.cat((class_pos_embed.unsqueeze(0), patch_pos_embed), dim=1)
+
+    def forward(self, pixel_values: torch.Tensor, bool_masked_pos: Optional[torch.Tensor] = None) -> torch.Tensor:
+        batch_size, _, height, width = pixel_values.shape
+        target_dtype = self.patch_embeddings.projection.weight.dtype
+        embeddings = self.patch_embeddings(pixel_values.to(dtype=target_dtype))
+
+        if bool_masked_pos is not None:
+            embeddings = torch.where(
+                bool_masked_pos.unsqueeze(-1), self.mask_token.to(embeddings.dtype).unsqueeze(0), embeddings
+            )
+
+        # add the [CLS] token to the embedded patch tokens
+        cls_tokens = self.cls_token.expand(batch_size, -1, -1)
+        embeddings = torch.cat((cls_tokens, embeddings), dim=1)
+
+        # add positional encoding to each token
+        embeddings = embeddings + self.interpolate_pos_encoding(embeddings, height, width)
+
+        embeddings = self.dropout(embeddings)
+
+        return embeddings
+
+
+class Dinov2PatchEmbeddings(nn.Module):
+    """
+    This class turns `pixel_values` of shape `(batch_size, num_channels, height, width)` into the initial
+    `hidden_states` (patch embeddings) of shape `(batch_size, seq_length, hidden_size)` to be consumed by a
+    Transformer.
+    """
+
+    def __init__(self, config):
+        super().__init__()
+        image_size, patch_size = config.image_size, config.patch_size
+        num_channels, hidden_size = config.num_channels, config.hidden_size
+
+        image_size = image_size if isinstance(image_size, collections.abc.Iterable) else (image_size, image_size)
+        patch_size = patch_size if isinstance(patch_size, collections.abc.Iterable) else (patch_size, patch_size)
+        num_patches = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
+        self.image_size = image_size
+        self.patch_size = patch_size
+        self.num_channels = num_channels
+        self.num_patches = num_patches
+
+        self.projection = nn.Conv2d(num_channels, hidden_size, kernel_size=patch_size, stride=patch_size)
+
+    def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
+        num_channels = pixel_values.shape[1]
+        if num_channels != self.num_channels:
+            raise ValueError(
+                "Make sure that the channel dimension of the pixel values match with the one set in the configuration."
+                f" Expected {self.num_channels} but got {num_channels}."
+            )
+        embeddings = self.projection(pixel_values).flatten(2).transpose(1, 2)
+        return embeddings
+
+
+# Copied from transformers.models.vit.modeling_vit.ViTSelfAttention with ViT->Dinov2
+class Dinov2SelfAttention(nn.Module):
+    def __init__(self, config: Dinov2Config) -> None:
+        super().__init__()
+        if config.hidden_size % config.num_attention_heads != 0 and not hasattr(config, "embedding_size"):
+            raise ValueError(
+                f"The hidden size {config.hidden_size,} is not a multiple of the number of attention "
+                f"heads {config.num_attention_heads}."
+            )
+
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+
+        self.query = nn.Linear(config.hidden_size, self.all_head_size, bias=config.qkv_bias)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size, bias=config.qkv_bias)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size, bias=config.qkv_bias)
+
+        self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
+
+    def transpose_for_scores(self, x: torch.Tensor) -> torch.Tensor:
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
+        x = x.view(new_x_shape)
+        return x.permute(0, 2, 1, 3)
+
+    def forward(
+        self, hidden_states, head_mask: Optional[torch.Tensor] = None, output_attentions: bool = False
+    ) -> Union[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor]]:
+        mixed_query_layer = self.query(hidden_states)
+
+        key_layer = self.transpose_for_scores(self.key(hidden_states))
+        value_layer = self.transpose_for_scores(self.value(hidden_states))
+        query_layer = self.transpose_for_scores(mixed_query_layer)
+
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
+
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.functional.softmax(attention_scores, dim=-1)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        # Mask heads if we want to
+        if head_mask is not None:
+            attention_probs = attention_probs * head_mask
+
+        context_layer = torch.matmul(attention_probs, value_layer)
+
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(new_context_layer_shape)
+
+        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
+
+        return outputs
+
+
+# Copied from transformers.models.vit.modeling_vit.ViTSelfOutput with ViT->Dinov2
+class Dinov2SelfOutput(nn.Module):
+    """
+    The residual connection is defined in Dinov2Layer instead of here (as is the case with other models), due to the
+    layernorm applied before each block.
+    """
+
+    def __init__(self, config: Dinov2Config) -> None:
+        super().__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states: torch.Tensor, input_tensor: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+
+        return hidden_states
+
+
+# Copied from transformers.models.vit.modeling_vit.ViTAttention with ViT->Dinov2
+class Dinov2Attention(nn.Module):
+    def __init__(self, config: Dinov2Config) -> None:
+        super().__init__()
+        self.attention = Dinov2SelfAttention(config)
+        self.output = Dinov2SelfOutput(config)
+        self.pruned_heads = set()
+
+    def prune_heads(self, heads: Set[int]) -> None:
+        if len(heads) == 0:
+            return
+        heads, index = find_pruneable_heads_and_indices(
+            heads, self.attention.num_attention_heads, self.attention.attention_head_size, self.pruned_heads
+        )
+
+        # Prune linear layers
+        self.attention.query = prune_linear_layer(self.attention.query, index)
+        self.attention.key = prune_linear_layer(self.attention.key, index)
+        self.attention.value = prune_linear_layer(self.attention.value, index)
+        self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
+
+        # Update hyper params and store pruned heads
+        self.attention.num_attention_heads = self.attention.num_attention_heads - len(heads)
+        self.attention.all_head_size = self.attention.attention_head_size * self.attention.num_attention_heads
+        self.pruned_heads = self.pruned_heads.union(heads)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        head_mask: Optional[torch.Tensor] = None,
+        output_attentions: bool = False,
+    ) -> Union[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor]]:
+        self_outputs = self.attention(hidden_states, head_mask, output_attentions)
+
+        attention_output = self.output(self_outputs[0], hidden_states)
+
+        outputs = (attention_output,) + self_outputs[1:]  # add attentions if we output them
+        return outputs
+
+
+class Dinov2LayerScale(nn.Module):
+    def __init__(self, config) -> None:
+        super().__init__()
+        self.lambda1 = nn.Parameter(config.layerscale_value * torch.ones(config.hidden_size))
+
+    def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+        return hidden_state * self.lambda1
+
+
+# Copied from transformers.models.beit.modeling_beit.drop_path
+def drop_path(input: torch.Tensor, drop_prob: float = 0.0, training: bool = False) -> torch.Tensor:
+    """
+    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).
+
+    Comment by Ross Wightman: This is the same as the DropConnect impl I created for EfficientNet, etc networks,
+    however, the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper...
+    See discussion: https://github.com/tensorflow/tpu/issues/494#issuecomment-532968956 ... I've opted for changing the
+    layer and argument names to 'drop path' rather than mix DropConnect as a layer name and use 'survival rate' as the
+    argument.
+    """
+    if drop_prob == 0.0 or not training:
+        return input
+    keep_prob = 1 - drop_prob
+    shape = (input.shape[0],) + (1,) * (input.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
+    random_tensor = keep_prob + torch.rand(shape, dtype=input.dtype, device=input.device)
+    random_tensor.floor_()  # binarize
+    output = input.div(keep_prob) * random_tensor
+    return output
+
+
+# Copied from transformers.models.beit.modeling_beit.BeitDropPath
+class Dinov2DropPath(nn.Module):
+    """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""
+
+    def __init__(self, drop_prob: Optional[float] = None) -> None:
+        super().__init__()
+        self.drop_prob = drop_prob
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return drop_path(hidden_states, self.drop_prob, self.training)
+
+    def extra_repr(self) -> str:
+        return "p={}".format(self.drop_prob)
+
+
+class Dinov2MLP(nn.Module):
+    def __init__(self, config) -> None:
+        super().__init__()
+        in_features = out_features = config.hidden_size
+        hidden_features = int(config.hidden_size * config.mlp_ratio)
+        self.fc1 = nn.Linear(in_features, hidden_features, bias=True)
+        if isinstance(config.hidden_act, str):
+            self.activation = ACT2FN[config.hidden_act]
+        else:
+            self.activation = config.hidden_act
+        self.fc2 = nn.Linear(hidden_features, out_features, bias=True)
+
+    def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+        hidden_state = self.fc1(hidden_state)
+        hidden_state = self.activation(hidden_state)
+        hidden_state = self.fc2(hidden_state)
+        return hidden_state
+
+
+class Dinov2SwiGLUFFN(nn.Module):
+    def __init__(self, config) -> None:
+        super().__init__()
+        in_features = out_features = config.hidden_size
+        hidden_features = int(config.hidden_size * config.mlp_ratio)
+        hidden_features = (int(hidden_features * 2 / 3) + 7) // 8 * 8
+
+        self.weights_in = nn.Linear(in_features, 2 * hidden_features, bias=True)
+        self.weights_out = nn.Linear(hidden_features, out_features, bias=True)
+
+    def forward(self, hidden_state: torch.Tensor) -> torch.Tensor:
+        hidden_state = self.weights_in(hidden_state)
+        x1, x2 = hidden_state.chunk(2, dim=-1)
+        hidden = nn.functional.silu(x1) * x2
+        return self.weights_out(hidden)
+
+
+class Dinov2Layer(nn.Module):
+    """This corresponds to the Block class in the original implementation."""
+
+    def __init__(self, config: Dinov2Config) -> None:
+        super().__init__()
+
+        self.norm1 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.attention = Dinov2Attention(config)
+        self.layer_scale1 = Dinov2LayerScale(config)
+        self.drop_path = Dinov2DropPath(config.drop_path_rate) if config.drop_path_rate > 0.0 else nn.Identity()
+
+        self.norm2 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+        if config.use_swiglu_ffn:
+            self.mlp = Dinov2SwiGLUFFN(config)
+        else:
+            self.mlp = Dinov2MLP(config)
+        self.layer_scale2 = Dinov2LayerScale(config)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        head_mask: Optional[torch.Tensor] = None,
+        output_attentions: bool = False,
+    ) -> Union[Tuple[torch.Tensor, torch.Tensor], Tuple[torch.Tensor]]:
+        self_attention_outputs = self.attention(
+            self.norm1(hidden_states),  # in Dinov2, layernorm is applied before self-attention
+            head_mask,
+            output_attentions=output_attentions,
+        )
+        attention_output = self_attention_outputs[0]
+
+        attention_output = self.layer_scale1(attention_output)
+        outputs = self_attention_outputs[1:]  # add self attentions if we output attention weights
+
+        # first residual connection
+        hidden_states = self.drop_path(attention_output) + hidden_states
+
+        # in Dinov2, layernorm is also applied after self-attention
+        layer_output = self.norm2(hidden_states)
+        layer_output = self.mlp(layer_output)
+        layer_output = self.layer_scale2(layer_output)
+
+        # second residual connection
+        layer_output = self.drop_path(layer_output) + hidden_states
+
+        outputs = (layer_output,) + outputs
+
+        return outputs
+
+
+# Copied from transformers.models.vit.modeling_vit.ViTEncoder with ViT->Dinov2
+class Dinov2Encoder(nn.Module):
+    def __init__(self, config: Dinov2Config) -> None:
+        super().__init__()
+        self.config = config
+        self.layer = nn.ModuleList([Dinov2Layer(config) for _ in range(config.num_hidden_layers)])
+        self.gradient_checkpointing = False
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        head_mask: Optional[torch.Tensor] = None,
+        output_attentions: bool = False,
+        output_hidden_states: bool = False,
+        return_dict: bool = True,
+    ) -> Union[tuple, BaseModelOutput]:
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attentions = () if output_attentions else None
+
+        for i, layer_module in enumerate(self.layer):
+            if output_hidden_states:
+                all_hidden_states = all_hidden_states + (hidden_states,)
+
+            layer_head_mask = head_mask[i] if head_mask is not None else None
+
+            if self.gradient_checkpointing and self.training:
+                layer_outputs = self._gradient_checkpointing_func(
+                    layer_module.__call__,
+                    hidden_states,
+                    layer_head_mask,
+                    output_attentions,
+                )
+            else:
+                layer_outputs = layer_module(hidden_states, layer_head_mask, output_attentions)
+
+            hidden_states = layer_outputs[0]
+
+            if output_attentions:
+                all_self_attentions = all_self_attentions + (layer_outputs[1],)
+
+        if output_hidden_states:
+            all_hidden_states = all_hidden_states + (hidden_states,)
+
+        if not return_dict:
+            return tuple(v for v in [hidden_states, all_hidden_states, all_self_attentions] if v is not None)
+        return BaseModelOutput(
+            last_hidden_state=hidden_states,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attentions,
+        )
+
+
+class Dinov2PreTrainedModel(PreTrainedModel):
+    """
+    An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
+    models.
+    """
+
+    config_class = Dinov2Config
+    base_model_prefix = "dinov2"
+    main_input_name = "pixel_values"
+    supports_gradient_checkpointing = True
+
+    def _init_weights(self, module: Union[nn.Linear, nn.Conv2d, nn.LayerNorm]) -> None:
+        """Initialize the weights"""
+        if isinstance(module, (nn.Linear, nn.Conv2d)):
+            # Upcast the input in `fp32` and cast it back to desired `dtype` to avoid
+            # `trunc_normal_cpu` not implemented in `half` issues
+            module.weight.data = nn.init.trunc_normal_(
+                module.weight.data.to(torch.float32), mean=0.0, std=self.config.initializer_range
+            ).to(module.weight.dtype)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+        elif isinstance(module, Dinov2Embeddings):
+            module.position_embeddings.data = nn.init.trunc_normal_(
+                module.position_embeddings.data.to(torch.float32),
+                mean=0.0,
+                std=self.config.initializer_range,
+            ).to(module.position_embeddings.dtype)
+
+            module.cls_token.data = nn.init.trunc_normal_(
+                module.cls_token.data.to(torch.float32),
+                mean=0.0,
+                std=self.config.initializer_range,
+            ).to(module.cls_token.dtype)
+
+
+DINOV2_START_DOCSTRING = r"""
+    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it
+    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
+    behavior.
+
+    Parameters:
+        config ([`Dinov2Config`]): Model configuration class with all the parameters of the model.
+            Initializing with a config file does not load the weights associated with the model, only the
+            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
+"""
+
+DINOV2_BASE_INPUTS_DOCSTRING = r"""
+    Args:
+        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
+            [`BitImageProcessor.preprocess`] for details.
+
+        bool_masked_pos (`torch.BoolTensor` of shape `(batch_size, sequence_length)`):
+            Boolean masked positions. Indicates which patches are masked (1) and which aren't (0). Only relevant for
+            pre-training.
+
+        head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
+            Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+DINOV2_INPUTS_DOCSTRING = r"""
+    Args:
+        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
+            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
+            [`BitImageProcessor.preprocess`] for details.
+
+        head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
+            Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:
+
+            - 1 indicates the head is **not masked**,
+            - 0 indicates the head is **masked**.
+
+        output_attentions (`bool`, *optional*):
+            Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
+            tensors for more detail.
+        output_hidden_states (`bool`, *optional*):
+            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
+            more detail.
+        return_dict (`bool`, *optional*):
+            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
+"""
+
+
+@add_start_docstrings(
+    "The bare DINOv2 Model transformer outputting raw hidden-states without any specific head on top.",
+    DINOV2_START_DOCSTRING,
+)
+class Dinov2Model(Dinov2PreTrainedModel):
+    def __init__(self, config: Dinov2Config):
+        super().__init__(config)
+        self.config = config
+
+        self.embeddings = Dinov2Embeddings(config)
+        self.encoder = Dinov2Encoder(config)
+
+        self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self) -> Dinov2PatchEmbeddings:
+        return self.embeddings.patch_embeddings
+
+    def _prune_heads(self, heads_to_prune: Dict[int, List[int]]) -> None:
+        """
+        Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
+        class PreTrainedModel
+        """
+        for layer, heads in heads_to_prune.items():
+            self.encoder.layer[layer].attention.prune_heads(heads)
+
+    @add_start_docstrings_to_model_forward(DINOV2_BASE_INPUTS_DOCSTRING)
+    @add_code_sample_docstrings(
+        checkpoint=_CHECKPOINT_FOR_DOC,
+        output_type=BaseModelOutputWithPooling,
+        config_class=_CONFIG_FOR_DOC,
+        modality="vision",
+        expected_output=_EXPECTED_OUTPUT_SHAPE,
+    )
+    def forward(
+        self,
+        pixel_values: Optional[torch.Tensor] = None,
+        bool_masked_pos: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutputWithPooling]:
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if pixel_values is None:
+            raise ValueError("You have to specify pixel_values")
+
+        # Prepare head mask if needed
+        # 1.0 in head_mask indicate we keep the head
+        # attention_probs has shape bsz x n_heads x N x N
+        # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
+        # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
+        head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
+
+        embedding_output = self.embeddings(pixel_values, bool_masked_pos=bool_masked_pos)
+
+        encoder_outputs = self.encoder(
+            embedding_output,
+            head_mask=head_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        sequence_output = encoder_outputs[0]
+        sequence_output = self.layernorm(sequence_output)
+        pooled_output = sequence_output[:, 0, :]
+
+        if not return_dict:
+            head_outputs = (sequence_output, pooled_output)
+            return head_outputs + encoder_outputs[1:]
+
+        return BaseModelOutputWithPooling(
+            last_hidden_state=sequence_output,
+            pooler_output=pooled_output,
+            hidden_states=encoder_outputs.hidden_states,
+            attentions=encoder_outputs.attentions,
+        )
+
+
+@add_start_docstrings(
+    """
+    Dinov2 Model transformer with an image classification head on top (a linear layer on top of the final hidden state
+    of the [CLS] token) e.g. for ImageNet.
+    """,
+    DINOV2_START_DOCSTRING,
+)
+class Dinov2ForImageClassification(Dinov2PreTrainedModel):
+    def __init__(self, config: Dinov2Config) -> None:
+        super().__init__(config)
+
+        self.num_labels = config.num_labels
+        self.dinov2 = Dinov2Model(config)
+
+        # Classifier head
+        self.classifier = (
+            nn.Linear(config.hidden_size * 2, config.num_labels) if config.num_labels > 0 else nn.Identity()
+        )
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @add_start_docstrings_to_model_forward(DINOV2_INPUTS_DOCSTRING)
+    @add_code_sample_docstrings(
+        checkpoint=_IMAGE_CLASS_CHECKPOINT,
+        output_type=ImageClassifierOutput,
+        config_class=_CONFIG_FOR_DOC,
+        expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT,
+    )
+    def forward(
+        self,
+        pixel_values: Optional[torch.Tensor] = None,
+        head_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.Tensor] = None,
+        output_attentions: Optional[bool] = None,
+        output_hidden_states: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> Union[tuple, ImageClassifierOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the image classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
+            `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        outputs = self.dinov2(
+            pixel_values,
+            head_mask=head_mask,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        sequence_output = outputs[0]  # batch_size, sequence_length, hidden_size
+
+        cls_token = sequence_output[:, 0]
+        patch_tokens = sequence_output[:, 1:]
+
+        linear_input = torch.cat([cls_token, patch_tokens.mean(dim=1)], dim=1)
+
+        logits = self.classifier(linear_input)
+
+        loss = None
+        if labels is not None:
+            # move labels to correct device to enable model parallelism
+            labels = labels.to(logits.device)
+            if self.config.problem_type is None:
+                if self.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
+                    self.config.problem_type = "single_label_classification"
+                else:
+                    self.config.problem_type = "multi_label_classification"
+
+            if self.config.problem_type == "regression":
+                loss_fct = MSELoss()
+                if self.num_labels == 1:
+                    loss = loss_fct(logits.squeeze(), labels.squeeze())
+                else:
+                    loss = loss_fct(logits, labels)
+            elif self.config.problem_type == "single_label_classification":
+                loss_fct = CrossEntropyLoss()
+                loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(logits, labels)
+
+        if not return_dict:
+            output = (logits,) + outputs[2:]
+            return ((loss,) + output) if loss is not None else output
+
+        return ImageClassifierOutput(
+            loss=loss,
+            logits=logits,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+
+@add_start_docstrings(
+    """
+    Dinov2 backbone, to be used with frameworks like DETR and MaskFormer.
+    """,
+    DINOV2_START_DOCSTRING,
+)
+class Dinov2Backbone(Dinov2PreTrainedModel, BackboneMixin):
+    def __init__(self, config):
+        super().__init__(config)
+        super()._init_backbone(config)
+
+        self.num_features = [config.hidden_size for _ in range(config.num_hidden_layers + 1)]
+        self.embeddings = Dinov2Embeddings(config)
+        self.encoder = Dinov2Encoder(config)
+
+        self.layernorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self) -> Dinov2PatchEmbeddings:
+        return self.embeddings.patch_embeddings
+
+    @add_start_docstrings_to_model_forward(DINOV2_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=BackboneOutput, config_class=_CONFIG_FOR_DOC)
+    def forward(
+        self,
+        pixel_values: torch.Tensor,
+        output_hidden_states: Optional[bool] = None,
+        output_attentions: Optional[bool] = None,
+        return_dict: Optional[bool] = None,
+    ) -> BackboneOutput:
+        """
+        Returns:
+
+        Examples:
+
+        ```python
+        >>> from transformers import AutoImageProcessor, AutoBackbone
+        >>> import torch
+        >>> from PIL import Image
+        >>> import requests
+
+        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
+        >>> image = Image.open(requests.get(url, stream=True).raw)
+
+        >>> processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
+        >>> model = AutoBackbone.from_pretrained(
+        ...     "facebook/dinov2-base", out_features=["stage2", "stage5", "stage8", "stage11"]
+        ... )
+
+        >>> inputs = processor(image, return_tensors="pt")
+
+        >>> outputs = model(**inputs)
+        >>> feature_maps = outputs.feature_maps
+        >>> list(feature_maps[-1].shape)
+        [1, 768, 16, 16]
+        ```"""
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+
+        embedding_output = self.embeddings(pixel_values)
+
+        outputs = self.encoder(
+            embedding_output, output_hidden_states=True, output_attentions=output_attentions, return_dict=return_dict
+        )
+
+        hidden_states = outputs.hidden_states if return_dict else outputs[1]
+
+        feature_maps = ()
+        for stage, hidden_state in zip(self.stage_names, hidden_states):
+            if stage in self.out_features:
+                if self.config.apply_layernorm:
+                    hidden_state = self.layernorm(hidden_state)
+                if self.config.reshape_hidden_states:
+                    hidden_state = hidden_state[:, 1:]
+                    # this was actually a bug in the original implementation that we copied here,
+                    # cause normally the order is height, width
+                    batch_size, _, height, width = pixel_values.shape
+                    patch_size = self.config.patch_size
+                    hidden_state = hidden_state.reshape(batch_size, height // patch_size, width // patch_size, -1)
+                    hidden_state = hidden_state.permute(0, 3, 1, 2).contiguous()
+                feature_maps += (hidden_state,)
+
+        if not return_dict:
+            if output_hidden_states:
+                output = (feature_maps,) + outputs[1:]
+            else:
+                output = (feature_maps,) + outputs[2:]
+            return output
+
+        return BackboneOutput(
+            feature_maps=feature_maps,
+            hidden_states=outputs.hidden_states if output_hidden_states else None,
+            attentions=outputs.attentions if output_attentions else None,
+        )

OVOW/third_party/Motion324/model/image_encoder/dinov2.py

@@ -0,0 +1,144 @@
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Dict, Tuple
+
+
+_RESNET_MEAN = [0.485, 0.456, 0.406]
+_RESNET_STD = [0.229, 0.224, 0.225]
+
+
+class PositionGetter:
+    """Generates and caches 2D spatial positions for patches in a grid."""
+
+    def __init__(self):
+        self.position_cache: Dict[Tuple[int, int], torch.Tensor] = {}
+
+    def __call__(self, batch_size: int, height: int, width: int, device: torch.device) -> torch.Tensor:
+        """
+        Generate spatial positions for a batch of patches.
+
+        Args:
+            batch_size: Number of samples in the batch
+            height: Height of the grid in patches
+            width: Width of the grid in patches
+            device: Target device for the position tensor
+
+        Returns:
+            Tensor of shape (batch_size, height*width, 2) containing y,x coordinates
+        """
+        if (height, width) not in self.position_cache:
+            y_coords = torch.arange(height, device=device)
+            x_coords = torch.arange(width, device=device)
+            positions = torch.cartesian_prod(y_coords, x_coords)
+            self.position_cache[height, width] = positions
+
+        cached_positions = self.position_cache[height, width]
+        return cached_positions.view(1, height * width, 2).expand(batch_size, -1, -1).clone()
+
+class DinoEncoder(nn.Module):
+    """DINOv2 vision transformer encoder for extracting image features."""
+    
+    def __init__(self, patch_size=14, model_name='dinov2_vitb14'):
+        super(DinoEncoder, self).__init__()
+        repo_override = os.environ.get("DINOv2_REPO")
+        local_repo_candidates = [
+            repo_override,
+            os.path.join(torch.hub.get_dir(), "facebookresearch_dinov2_main"),
+            "~/.cache/torch/hub/facebookresearch_dinov2_main",
+        ]
+        local_repo = next((p for p in local_repo_candidates if p and os.path.isdir(p)), None)
+        # pretrained=False: the backbone weights are restored from the Motion324
+        # checkpoint (image_encoder.model.*), so skip the network download that
+        # fails offline (SSL/CA) and would be overwritten anyway.
+        if local_repo:
+            self.model = torch.hub.load(local_repo, model_name, source="local", pretrained=False)
+        else:
+            self.model = torch.hub.load("facebookresearch/dinov2", model_name, pretrained=False)
+        if hasattr(self.model, 'patch_size'):
+            assert self.model.patch_size == patch_size, \
+                f"DINOv2 model's patch size ({self.model.patch_size}) must match provided patch_size ({patch_size})"
+        else:
+            print(f"Warning: DINOv2 model does not expose patch_size. Assuming it is {patch_size}.")
+
+        self.patch_size = patch_size
+        self.position_getter = PositionGetter()
+
+        # For fixed 224x224 input with patch_size=14
+        self.image_size = 224
+        self.num_patches_per_dim = self.image_size // self.patch_size  # 16
+        self.num_patches_total = self.num_patches_per_dim * self.num_patches_per_dim  # 256
+
+        for param in self.model.parameters():
+            param.requires_grad = False
+
+        self.model.eval()
+        
+    def forward(self, image):
+        """
+        Forward pass through DINOv2 encoder.
+        
+        Args:
+            image: Input images of shape (B, C, H, W), e.g., (B, 3, 224, 224)
+        
+        Returns:
+            encoded_feats: Patch features of shape (B, N_patches, D_embed)
+        """
+        B, C, H, W = image.shape
+        device = image.device
+
+        resnet_mean = torch.tensor(_RESNET_MEAN, device=device).view(1, 3, 1, 1)
+        resnet_std = torch.tensor(_RESNET_STD, device=device).view(1, 3, 1, 1)
+        images_resnet_norm = (image - resnet_mean) / resnet_std
+        
+        assert H == self.image_size and W == self.image_size, \
+            f"Input image size must be {self.image_size}x{self.image_size}, but got {H}x{W}"
+
+        encoded_feats = self._process_images(images_resnet_norm)
+        return encoded_feats
+
+    def _process_images(self, images):
+        """
+        Process a batch of images through DINO encoder.
+        
+        Args:
+            images: Input images of shape (B, C, H, W), e.g., (B, 3, 224, 224)
+        
+        Returns:
+            encoded_features: Patch features
+        """
+        B, C, H, W = images.shape
+        features_dict = self.model.forward_features(images)
+        
+        # Get patch tokens
+        if 'x_norm_patchtokens' in features_dict:
+            encoded_features = features_dict['x_norm_patchtokens']
+        elif 'x_patchtokens' in features_dict:
+            encoded_features = features_dict['x_patchtokens']
+        else:
+            if isinstance(features_dict, torch.Tensor) and features_dict.ndim == 3 and features_dict.shape[0] == B:
+                num_expected_patches = (H // self.patch_size) * (W // self.patch_size)
+                if features_dict.shape[1] == num_expected_patches:
+                    encoded_features = features_dict
+                else:
+                    raise KeyError(f"DINOv2 output shape {features_dict.shape} does not match expected patch tokens")
+            else:
+                available_keys = list(features_dict.keys()) if isinstance(features_dict, dict) else 'N/A'
+                raise KeyError(f"Could not find patch tokens in DINOv2 output. Available keys: {available_keys}")
+
+        if hasattr(self.model, 'embed_dim'):
+            assert encoded_features.shape[-1] == self.model.embed_dim, \
+                f"Feature dimension {encoded_features.shape[-1]} does not match model embed_dim {self.model.embed_dim}"
+
+        assert encoded_features.shape[1] == self.num_patches_total, \
+            f"Number of patches {encoded_features.shape[1]} does not match expected {self.num_patches_total}"
+
+        return encoded_features
+    
+    def train(self, mode: bool = False):
+        """Override train method to keep DINO model in eval mode."""
+        super(DinoEncoder, self).train(mode)
+        if self.model is not None:
+            self.model.eval()
+        return self

OVOW/third_party/Motion324/model/loss.py

@@ -0,0 +1,66 @@
+import torch.nn as nn
+import torch
+import torch.nn.functional as F
+from easydict import EasyDict as edict
+
+class MSELossComputer(nn.Module):
+    def __init__(self, config):
+        """
+        Initializes the LossComputer.
+
+        Args:
+            config: Configuration object. Expected to have config.training.coord_mse_loss_weight.
+        """
+        super().__init__()
+        self.config = config
+
+        # Ensure the config has 'coord_mse_loss_weight' defined.
+        if not hasattr(self.config, 'training') or \
+           not hasattr(self.config.training, 'coord_mse_loss_weight'):
+            raise ValueError(
+                "Configuration must have 'config.training.coord_mse_loss_weight' defined."
+            )
+
+    def forward(
+        self,
+        coords_pred: torch.Tensor,
+        coords_target: torch.Tensor,
+    ):
+        """
+        Calculate Mean Squared Error (MSE) loss for coordinates.
+
+        Args:
+            coords_pred (torch.Tensor): Predicted coordinates. Shape [B, T, N, C].
+            coords_target (torch.Tensor): Ground truth coordinates. Shape [B, T, N, C].
+        
+        Returns:
+            edict: Dictionary of loss metrics, containing 'loss' and 'coord_mse_loss'.
+        """
+
+        # Determine device from input tensor
+        current_device = coords_pred.device
+
+        total_loss = torch.tensor(0.0, device=current_device)
+        loss_metrics = edict()
+
+        # --- Coordinate MSE Loss ---
+        coord_mse_loss_value = torch.tensor(0.0, device=current_device)
+
+        # Validate shapes
+        if not (coords_pred.ndim == 4 and \
+                coords_target.ndim == 4 and \
+                coords_pred.shape == coords_target.shape):
+            raise ValueError(
+                f"Shape mismatch or invalid shape for coordinate MSE. "
+                f"Expected both tensors of shape (B, T, N, C). "
+                f"Got pred: {coords_pred.shape}, target: {coords_target.shape}"
+            )
+
+        if self.config.training.coord_mse_loss_weight > 0.0:
+            coord_mse_loss_value = F.mse_loss(coords_pred, coords_target)
+            total_loss += self.config.training.coord_mse_loss_weight * coord_mse_loss_value
+        
+        loss_metrics.coord_mse_loss = coord_mse_loss_value
+        loss_metrics.loss = total_loss # The final combined loss (which is just coord_mse_loss weighted)
+        
+        return loss_metrics

OVOW/third_party/Motion324/model/transformer.py

@@ -0,0 +1,423 @@
+# Copyright (c) 2025 Haian Jin. Created for the LVSM project (ICLR 2025).
+# Modifications Copyright (c) 2025 Hongyuan Chen.
+
+import torch
+import torch.nn as nn
+from einops import rearrange
+
+try:
+    import xformers.ops as xops
+except ImportError:
+    raise ImportError("Please use flashatt v2")
+
+
+
+def init_weights(module, std=0.02):
+    """Initialize weights for linear and embedding layers.
+    
+    Args:
+        module: Module to initialize
+        std: Standard deviation for normal initialization
+    """
+    if isinstance(module, (nn.Linear, nn.Embedding)):
+        torch.nn.init.normal_(module.weight, mean=0.0, std=std)
+        if isinstance(module, nn.Linear) and module.bias is not None:
+            torch.nn.init.zeros_(module.bias)
+
+
+
+# src: https://github.com/pytorch/benchmark/blob/main/torchbenchmark/models/llama/model.py#L28
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-5):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def _norm(self, x):
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps)
+
+    def forward(self, x):
+        output = self._norm(x.float()).type_as(x)
+
+        return output * self.weight.type_as(x)
+
+
+
+class MLP(nn.Module):
+    """
+    Multi-Layer Perceptron block.
+    Reference: https://github.com/facebookresearch/dino/blob/7c446df5b9f45747937fb0d72314eb9f7b66930a/vision_transformer.py#L49-L65
+    """
+    
+    def __init__(
+        self,
+        dim,
+        mlp_ratio=4,
+        bias=False,
+        dropout=0.0,
+        activation=nn.GELU,
+        mlp_dim=None,
+    ):
+        """
+        Args:
+            dim: Input dimension
+            mlp_ratio: Multiplier for hidden dimension
+            bias: Whether to use bias in linear layers
+            dropout: Dropout probability
+            activation: Activation function
+            mlp_dim: Optional explicit hidden dimension (overrides mlp_ratio)
+        """
+        super().__init__()
+        hidden_dim = mlp_dim if mlp_dim is not None else int(dim * mlp_ratio)
+        
+        self.mlp = nn.Sequential(
+            nn.Linear(dim, hidden_dim, bias=bias),
+            activation(),
+            nn.Linear(hidden_dim, dim, bias=bias),
+            nn.Dropout(dropout),
+        )
+
+    def forward(self, x):
+        return self.mlp(x)
+
+
+class QK_Norm_CrossAttention(nn.Module):
+    """
+    Cross-attention module with optional Q-K normalization.
+    Takes separate query, key, and value inputs.
+    """
+    def __init__(
+        self,
+        dim,
+        head_dim,
+        kv_dim=None,
+        qkv_bias=False,
+        fc_bias=True,
+        attn_dropout=0.0,
+        fc_dropout=0.0,
+        use_qk_norm=True,
+    ):
+        super().__init__()
+        assert dim % head_dim == 0, f"Token dimension {dim} should be divisible by head dimension {head_dim}"
+        if kv_dim is None:
+            kv_dim = dim
+
+        self.dim = dim
+        self.kv_dim = kv_dim
+        self.head_dim = head_dim
+        self.num_heads = dim // head_dim
+        self.attn_dropout = attn_dropout
+        self.use_qk_norm = use_qk_norm
+
+        self.to_q = nn.Linear(dim, dim, bias=qkv_bias)
+        self.to_k = nn.Linear(kv_dim, dim, bias=qkv_bias)
+        self.to_v = nn.Linear(kv_dim, dim, bias=qkv_bias)
+
+        self.fc = nn.Linear(dim, dim, bias=fc_bias)
+        self.attn_fc_dropout = nn.Dropout(fc_dropout)
+        
+        if self.use_qk_norm:
+            self.q_norm = RMSNorm(head_dim)
+            self.k_norm = RMSNorm(head_dim)
+
+    def forward(self, query, key, value, attn_bias=None):
+        q = self.to_q(query)
+        k = self.to_k(key)
+        v = self.to_v(value)
+
+        q, k, v = (rearrange(t, "b l (nh dh) -> b l nh dh", dh=self.head_dim) for t in (q, k, v))
+        
+        if self.use_qk_norm:
+            q = self.q_norm(q)
+            k = self.k_norm(k)
+
+        x = xops.memory_efficient_attention(
+            q, k, v,
+            attn_bias=attn_bias,
+            p=self.attn_dropout if self.training else 0.0,
+            op=(xops.fmha.flash.FwOp, xops.fmha.flash.BwOp),
+        )
+        
+        x = rearrange(x, "b l nh dh -> b l (nh dh)")
+        x = self.attn_fc_dropout(self.fc(x))
+        
+        return x
+
+class QK_Norm_SelfAttention(nn.Module):
+    """
+    Self-attention with optional Q-K normalization.
+    Reference: https://github.com/facebookresearch/dino/blob/7c446df5b9f45747937fb0d72314eb9f7b66930a/vision_transformer.py#L68-L92
+    """
+
+    def __init__(
+        self,
+        dim,
+        head_dim,
+        qkv_bias=False,
+        fc_bias=True,
+        attn_dropout=0.0,
+        fc_dropout=0.0,
+        use_qk_norm=True,
+    ):
+        """
+        Args:
+            dim: Input dimension
+            head_dim: Dimension of each attention head
+            qkv_bias: Whether to use bias in QKV projection
+            fc_bias: Whether to use bias in output projection
+            attn_dropout: Dropout probability for attention weights
+            fc_dropout: Dropout probability for output projection
+            use_qk_norm: Whether to use Q-K normalization
+        We use flash attention V2 for efficiency.
+        """
+        super().__init__()
+        assert dim % head_dim == 0, f"Token dimension {dim} should be divisible by head dimension {head_dim}"
+        
+        self.dim = dim
+        self.head_dim = head_dim
+        self.num_heads = dim // head_dim
+        self.attn_dropout = attn_dropout
+        self.use_qk_norm = use_qk_norm
+
+        self.to_qkv = nn.Linear(dim, 3 * dim, bias=qkv_bias)
+        self.fc = nn.Linear(dim, dim, bias=fc_bias)
+        self.attn_fc_dropout = nn.Dropout(fc_dropout)
+        
+        # Optional Q-K normalization
+        if self.use_qk_norm:
+            self.q_norm = RMSNorm(head_dim)
+            self.k_norm = RMSNorm(head_dim)
+
+    def forward(self, x, attn_bias=None):
+        """
+        Args:
+            x: Input tensor of shape (batch, seq_len, dim)
+            attn_bias: Optional attention bias mask
+            
+        Returns:
+            Output tensor of shape (batch, seq_len, dim)
+        """
+        q, k, v = self.to_qkv(x).chunk(3, dim=-1)
+        
+        q, k, v = (rearrange(t, "b l (nh dh) -> b l nh dh", dh=self.head_dim) for t in (q, k, v))
+        
+        # Apply qk normalization if enabled
+        if self.use_qk_norm:
+            q = self.q_norm(q)
+            k = self.k_norm(k)
+
+        x = xops.memory_efficient_attention(
+            q, k, v,
+            attn_bias=attn_bias,
+            p=self.attn_dropout if self.training else 0.0,
+            op=(xops.fmha.flash.FwOp, xops.fmha.flash.BwOp),
+        )
+        
+        x = rearrange(x, "b l nh dh -> b l (nh dh)")
+        x = self.attn_fc_dropout(self.fc(x))
+        
+        return x
+
+class SubsetAttention(nn.Module):
+    """Attention that can attend to subsets of queries or keys/values."""
+    
+    def __init__(
+        self,
+        dim,
+        head_dim,
+        qkv_bias=False,
+        attn_dropout=0.0,
+        fc_bias=False,
+        fc_dropout=0.0,
+        use_qk_norm=False
+    ):
+        """
+        Args:
+            dim: Input dimension
+            head_dim: Dimension of each attention head
+            qkv_bias: Whether to use bias in QKV projection
+            attn_dropout: Dropout probability for attention weights
+            fc_bias: Whether to use bias in output projection
+            fc_dropout: Dropout probability for output projection
+            use_qk_norm: Whether to use Q-K normalization
+        We use flash attention V2 for efficiency.
+        """
+        super().__init__()
+        assert dim % head_dim == 0, f"Token dimension {dim} should be divisible by head dimension {head_dim}"
+        
+        self.dim = dim
+        self.head_dim = head_dim
+        self.num_heads = dim // head_dim
+        self.attn_dropout = attn_dropout
+        self.use_qk_norm = use_qk_norm
+
+        # Projections
+        self.to_qkv = nn.Linear(dim, 3 * dim, bias=qkv_bias)
+        self.fc = nn.Linear(dim, dim, bias=fc_bias)
+        self.attn_fc_dropout = nn.Dropout(fc_dropout)
+        
+        # Optional Q-K normalization
+        if self.use_qk_norm:
+            self.q_norm = RMSNorm(head_dim)
+            self.k_norm = RMSNorm(head_dim)
+
+    def forward(self, x, subset_kv_size=None, subset_q_size=None):
+        """
+        Args:
+            x: Input tensor of shape (batch, seq_len, dim)
+            subset_kv_size: If provided, only attend to tokens after this index in KV
+            subset_q_size: If provided, only compute attention for queries up to this index
+            
+        Returns:
+            Output tensor of shape (batch, seq_len, dim)
+        """
+        # Only one subset parameter can be provided
+        assert not (subset_kv_size is not None and subset_q_size is not None), \
+            "Only one of subset_kv_size or subset_q_size can be provided"
+
+        q, k, v = self.to_qkv(x).chunk(3, dim=-1)
+        
+        q, k, v = (rearrange(t, "b l (nh dh) -> b l nh dh", dh=self.head_dim) for t in (q, k, v))
+        
+        if self.use_qk_norm:
+            q = self.q_norm(q)
+            k = self.k_norm(k)
+        
+        # Handle subset attention cases
+        if subset_kv_size is not None and subset_kv_size < k.shape[1]:
+            # Attend to subset of key/value tokens
+            k_subset = k[:, subset_kv_size:, :, :].contiguous()
+            v_subset = v[:, subset_kv_size:, :, :].contiguous()
+            
+            x = xops.memory_efficient_attention(
+                q, k_subset, v_subset,
+                attn_bias=None,
+                p=self.attn_dropout if self.training else 0.0,
+                op=(xops.fmha.flash.FwOp, xops.fmha.flash.BwOp),
+            )
+        elif subset_q_size is not None and subset_q_size < q.shape[1]:
+            # Only compute attention for subset of query tokens
+            q_subset = q[:, :subset_q_size, :, :].contiguous()
+            
+            x = xops.memory_efficient_attention(
+                q_subset, k, v,
+                attn_bias=None,
+                p=self.attn_dropout if self.training else 0.0,
+                op=(xops.fmha.flash.FwOp, xops.fmha.flash.BwOp),
+            )
+        else:
+            # Regular attention for all tokens
+            x = xops.memory_efficient_attention(
+                q, k, v,
+                attn_bias=None,
+                p=self.attn_dropout if self.training else 0.0,
+                op=(xops.fmha.flash.FwOp, xops.fmha.flash.BwOp),
+            )
+        
+        x = rearrange(x, "b l nh dh -> b l (nh dh)")
+
+        # Final projection
+        x = self.attn_fc_dropout(self.fc(x))
+        
+        return x
+
+class QK_Norm_CrossAttentionBlock(nn.Module):
+    """
+    Transformer block using cross-attention.
+    Query is processed, then interacts with Key/Value.
+    """
+    def __init__(
+        self,
+        dim,
+        head_dim,
+        kv_dim=None,
+        ln_bias=False,
+        attn_qkv_bias=False,
+        attn_dropout=0.0,
+        attn_fc_bias=False,
+        attn_fc_dropout=0.0,
+        mlp_ratio=4,
+        mlp_bias=False,
+        mlp_dropout=0.0,
+        use_qk_norm=True,
+    ):
+        super().__init__()
+        self.norm_q = nn.LayerNorm(dim, bias=ln_bias)
+        self.norm_kv = nn.LayerNorm(kv_dim if kv_dim is not None else dim, bias=ln_bias)
+        self.attn = QK_Norm_CrossAttention(
+            dim=dim,
+            head_dim=head_dim,
+            kv_dim=kv_dim,
+            qkv_bias=attn_qkv_bias,
+            fc_bias=attn_fc_bias,
+            attn_dropout=attn_dropout,
+            fc_dropout=attn_fc_dropout,
+            use_qk_norm=use_qk_norm,
+        )
+        self.norm2 = nn.LayerNorm(dim, bias=ln_bias)
+        self.mlp = MLP(
+            dim=dim,
+            mlp_ratio=mlp_ratio,
+            bias=mlp_bias,
+            dropout=mlp_dropout,
+        )
+
+    def forward(self, query, key, value):
+        # Pre-normalization
+        q_norm = self.norm_q(query)
+        k_norm = self.norm_kv(key)
+        v_norm = self.norm_kv(value)
+        
+        # Cross-attention
+        attn_out = self.attn(q_norm, k_norm, v_norm)
+        
+        # Residual connection and MLP
+        x = query + attn_out
+        x = x + self.mlp(self.norm2(x))
+        return x
+
+class QK_Norm_TransformerBlock(nn.Module):
+    """
+    Standard transformer block with pre-normalization architecture.
+    Reference: https://github.com/facebookresearch/dino/blob/7c446df5b9f45747937fb0d72314eb9f7b66930a/vision_transformer.py#L95-L113
+    """
+
+    def __init__(
+        self,
+        dim,
+        head_dim,
+        ln_bias=False,
+        attn_qkv_bias=False,
+        attn_dropout=0.0,
+        attn_fc_bias=False,
+        attn_fc_dropout=0.0,
+        mlp_ratio=4,
+        mlp_bias=False,
+        mlp_dropout=0.0,
+        use_qk_norm=True,
+    ):
+        super().__init__()
+        self.norm1 = nn.LayerNorm(dim, bias=ln_bias)
+        self.attn = QK_Norm_SelfAttention(
+            dim=dim,
+            head_dim=head_dim,
+            qkv_bias=attn_qkv_bias,
+            fc_bias=attn_fc_bias,
+            attn_dropout=attn_dropout,
+            fc_dropout=attn_fc_dropout,
+            use_qk_norm=use_qk_norm,
+        )
+
+        self.norm2 = nn.LayerNorm(dim, bias=ln_bias)
+        self.mlp = MLP(
+            dim=dim,
+            mlp_ratio=mlp_ratio,
+            bias=mlp_bias,
+            dropout=mlp_dropout,
+        )
+
+
+    def forward(self, x):
+        x = x + self.attn(self.norm1(x))
+        x = x + self.mlp(self.norm2(x))
+        return x

OVOW/third_party/Motion324/pyrightconfig.json

@@ -0,0 +1,12 @@
+{
+    "exclude": [
+      "experiments/**",
+      "log/**",
+      "metric_checkpoint/**",
+      "preprocessed_data/**"    ],
+    "typeCheckingMode": "off"
+    // "reportMissingImports": false,
+    // "reportUnknownMemberType": false,
+    // "reportAttributeAccessIssue": false,
+    // "reportUnknownVariableType": false
+}

OVOW/third_party/Motion324/requirements.txt

@@ -0,0 +1,36 @@
+# --extra-index-url https://download.pytorch.org/whl/cu124
+torch==2.4.1
+torchvision==0.19.1+cu124
+xformers==0.0.28
+imageio==2.33.0
+Pillow==10.0.1
+imageio-ffmpeg==0.5.0
+omegaconf==2.1.1
+einops>= 0.4.1 
+transformers==4.56.1
+peft==0.17.0
+torchmetrics>= 0.11.0
+datasets==2.14.5
+rich>=13.3.2
+wandb==0.21.1
+ipdb
+tqdm
+easydict==1.13
+lpips==0.1.4
+dreamsim==0.2.1
+open-clip-torch==3.1.0
+jaxtyping==0.3.1
+scikit-image==0.23.2
+rembg==2.0.68
+onnxruntime
+trimesh==4.6.9
+bpy==4.4.0
+natsort
+scikit-learn
+numpy==1.26.4
+matplotlib
+pybind11==2.13.6
+diffusers==0.35.2
+xatlas==0.0.11
+pymeshlab
+pygltflib

OVOW/third_party/Motion324/scripts/4D_from_existing.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+
+# Script to generate 4D animation from existing mesh and video
+# Usage: ./scripts/4D_from_existing.sh <data_dir> <video_path> <output_dir>
+# Example: ./scripts/4D_from_existing.sh ./examples/mesh.glb ./examples/video.mp4 ./examples/output
+set -e
+
+# Check arguments
+if [ $# -lt 3 ]; then
+    echo "Usage: $0 <data_dir> <video_path> <output_dir>"
+    echo "  data_dir: Path to .glb or .fbx mesh file (FBX will be automatically converted to GLB)"
+    echo "  video_path: Path to video file (.mp4/.avi/.mov) or directory containing images"
+    echo "  output_dir: Output directory for animation results"
+    echo ""
+    echo "Example: $0 ./examples/chili.glb ./examples/chili.mp4 ./examples/output"
+    exit 1
+fi
+
+DATA_DIR="$1"
+VIDEO_PATH="$2"
+OUTPUT_DIR="$3"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="${SCRIPT_DIR}/.."
+
+# Validate data_dir
+if [ ! -f "$DATA_DIR" ]; then
+    echo "Error: Mesh file not found: $DATA_DIR"
+    echo "Supported formats: .glb, .fbx"
+    exit 1
+fi
+
+# Validate video_path
+if [ ! -f "$VIDEO_PATH" ] && [ ! -d "$VIDEO_PATH" ]; then
+    echo "Error: Video file or directory not found: $VIDEO_PATH"
+    echo "Supported: .mp4/.avi/.mov video files or directory containing images"
+    exit 1
+fi
+
+# Create output directory
+mkdir -p "$OUTPUT_DIR"
+
+echo "=========================================="
+echo "Generating 4D animation from existing mesh and video"
+echo "Mesh file: $DATA_DIR"
+echo "Video path: $VIDEO_PATH"
+echo "Output directory: $OUTPUT_DIR"
+echo "=========================================="
+
+# Change to project root directory
+cd "$PROJECT_ROOT"
+
+# Run inference
+python scripts/inference_with_video_mesh.py \
+    --config=configs/dyscene.yaml \
+    training.resume_ckpt="$PROJECT_ROOT/experiments/checkpoints/ckpt_0000000000060000.pt" \
+    model.class_name=model.Pcd_motion.Motion_Latent_Model \
+    training.num_shape_samples=16384 \
+    training.frames=256 \
+    start_frame=0 \
+    use_segmentation=True \
+    data_dir="$DATA_DIR" \
+    video_path="$VIDEO_PATH" \
+    output_dir="$OUTPUT_DIR"
+
+echo ""
+echo "=========================================="
+echo "Processing complete!"
+echo "Animation output: $OUTPUT_DIR"
+echo "=========================================="
+

OVOW/third_party/Motion324/scripts/4D_from_video.sh

@@ -0,0 +1,145 @@
+#!/bin/bash
+
+# Script to convert video input to 4D animation
+# Usage: ./scripts/4D_from_video.sh <input_video_path> [--split_only] [--backend hunyuan|trellis2]
+# ./scripts/4D_from_video.sh ./examples/tiger.mp4
+# ./scripts/4D_from_video.sh ./examples/tiger.mp4 --split_only
+# ./scripts/4D_from_video.sh ./examples/tiger.mp4 --backend trellis2
+set -e
+
+# Check arguments
+if [ $# -lt 1 ]; then
+    echo "Usage: $0 <input_video_path> [--split_only] [--backend hunyuan|trellis2]"
+    echo "Example: $0 ./examples/tiger.mp4"
+    echo "        $0 ./examples/tiger.mp4 --split_only"
+    echo "        $0 ./examples/tiger.mp4 --backend trellis2"
+    exit 1
+fi
+
+INPUT_VIDEO="$1"
+shift
+
+# Defaults
+SPLIT_ONLY="false"
+BACKEND="hunyuan"
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --split_only)
+            SPLIT_ONLY="true"
+            shift
+            ;;
+        --backend)
+            if [ -z "$2" ]; then
+                echo "Error: --backend requires a value (hunyuan|trellis2)"
+                exit 1
+            fi
+            BACKEND="$2"
+            shift 2
+            ;;
+        --trellis2)
+            BACKEND="trellis2"
+            shift
+            ;;
+        *)
+            echo "Error: Unknown option '$1'"
+            exit 1
+            ;;
+    esac
+done
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_ROOT="${SCRIPT_DIR}/.."
+OUTPUT_BASE_DIR="$(dirname "$INPUT_VIDEO")"
+
+# Keep Hunyuan weights under /data to avoid repeated downloads into /mnt/einsia/aws01-nvme/einsia-shared/homes/gaomingju/.cache.
+CKPT_ROOT="${MOTION324_CKPT_ROOT:-/mnt/einsia/aws01-nvme/einsia-shared/homes/gaomingju/jiayin/OVOW/ckpts}"
+export HY3DGEN_MODELS="${HY3DGEN_MODELS:-${CKPT_ROOT}/hy3dgen}"
+mkdir -p "$HY3DGEN_MODELS"
+
+# Validate input video
+if [ ! -f "$INPUT_VIDEO" ]; then
+    echo "Error: Input video not found: $INPUT_VIDEO"
+    exit 1
+fi
+
+# Set up paths
+VIDEO_NAME=$(basename "$INPUT_VIDEO" | sed 's/\.[^.]*$//')
+PROCESSED_DIR="$OUTPUT_BASE_DIR/${VIDEO_NAME}_processed"
+MASKED_RGB_DIR="$PROCESSED_DIR/masked_rgb"
+ANIMATION_OUTPUT_DIR="$PROCESSED_DIR/animation"
+
+echo "=========================================="
+echo "Processing video: $INPUT_VIDEO"
+echo "Base directory: $OUTPUT_BASE_DIR"
+echo "Processed directory: $PROCESSED_DIR"
+echo "Split only: $SPLIT_ONLY"
+echo "Backend: $BACKEND"
+echo "HY3DGEN_MODELS: $HY3DGEN_MODELS"
+echo "=========================================="
+
+# Step 1: Remove background and extract frames or only split frames
+echo ""
+if [ "$SPLIT_ONLY" = "true" ]; then
+    echo "Step 1: Extracting frames only (split_only mode)..."
+    python "$PROJECT_ROOT/utils/rmbg_for_black_bg.py" --input "$INPUT_VIDEO" --split_only
+    echo "Split only mode done. Exiting pipeline after video frame extraction."
+else
+    echo "Step 1: Removing background and extracting frames..."
+    python "$PROJECT_ROOT/utils/rmbg_for_black_bg.py" --input "$INPUT_VIDEO"
+fi
+
+HUNYUAN_INPUT_DIR="$OUTPUT_BASE_DIR/${VIDEO_NAME}_processed/Hunyuan_Gen_Input"
+# Step 2: Generate Hunyuan mesh
+echo ""
+echo "Step 2: Generating mesh ($BACKEND)..."
+FBX_HUNYUAN_O="$(find "$HUNYUAN_INPUT_DIR" -name "*_hunyuan_original_wo_remap_converted.fbx" | head -1)"
+if [ -f "$FBX_HUNYUAN_O" ]; then
+    echo "Hunyuan mesh already exists at $FBX_HUNYUAN_O, skipping generation."
+else
+    if [ "$BACKEND" = "trellis2" ]; then
+        export HF_ENDPOINT=https://huggingface.co
+    else
+        export HF_ENDPOINT=https://hf-mirror.com
+    fi
+    python "$PROJECT_ROOT/scripts/hunyuan_Gen.py" \
+        --root "$OUTPUT_BASE_DIR" \
+        --output "$OUTPUT_BASE_DIR" \
+        --N 1 \
+        --n 0 \
+        --skip 256 \
+        --seed 42 \
+        --backend "$BACKEND"
+fi
+
+if [ "$BACKEND" != "trellis2" ]; then
+    python "$PROJECT_ROOT/utils/convert_fbx.py" "$HUNYUAN_INPUT_DIR"
+fi
+# Step 3: Find the generated FBX file
+FBX_FILE=$(find "$HUNYUAN_INPUT_DIR" -name "*_hunyuan_original_wo_remap_converted.fbx" | head -1)
+if [ -z "$FBX_FILE" ]; then
+    echo "Error: FBX file not found in $HUNYUAN_INPUT_DIR"
+    exit 1
+fi
+
+# Step 4: Generate animation
+echo ""
+echo "Step 3: Generating animation..."
+python "$PROJECT_ROOT/scripts/inference_with_video_only.py" \
+    --config="$PROJECT_ROOT/configs/dyscene.yaml" \
+    training.resume_ckpt="$PROJECT_ROOT/experiments/checkpoints/ckpt_0000000000060000.pt" \
+    model.class_name=model.Pcd_motion.Motion_Latent_Model \
+    data_dir="$FBX_FILE" \
+    image_path="$MASKED_RGB_DIR" \
+    training.num_shape_samples=16384 \
+    training.num_pcd_samples=4096 \
+    training.frames=256 \
+    start_frame=0 \
+    training.use_fbx=True \
+    output_dir="$ANIMATION_OUTPUT_DIR"
+
+echo ""
+echo "=========================================="
+echo "Processing complete!"
+echo "Animation output: $ANIMATION_OUTPUT_DIR"
+echo "=========================================="

OVOW/third_party/Motion324/scripts/hunyuan_Gen.py

@@ -0,0 +1,375 @@
+# Modified from V2M4
+import os
+# os.environ['ATTN_BACKEND'] = 'xformers'   # Can be 'flash-attn' or 'xformers', default is 'flash-attn'
+os.environ['SPCONV_ALGO'] = 'native'        # Can be 'native' or 'auto', default is 'auto'.
+                                            # 'auto' is faster but will do benchmarking at the beginning.
+                                            # Recommended to set to 'native' if run only once.
+import imageio
+import torch
+import random
+import numpy as np
+import rembg
+from PIL import Image
+from natsort import ns, natsorted
+import argparse
+import trimesh
+import shutil
+import subprocess
+import sys
+
+# Work around transformers torch.load safety gate (CVE-2025-32434) for local trusted checkpoints.
+if os.environ.get("MOTION324_DISABLE_TORCH_LOAD_CHECK", "1") == "1":
+    try:
+        import transformers.modeling_utils as _tf_mu
+        _tf_mu.check_torch_load_is_safe = lambda: None
+    except Exception:
+        pass
+
+def preprocess_image(input: Image.Image, return_rgba=False, return_all_rbga=False) -> Image.Image:
+    """
+    Preprocess the input image.
+    """
+    # If the input has an alpha channel, use it directly; otherwise, remove background
+    has_alpha = False
+    if input.mode == 'RGBA':
+        alpha = np.array(input)[:, :, 3]
+        if not np.all(alpha == 255):
+            has_alpha = True
+    if has_alpha:
+        output = input
+    else:
+        input = input.convert('RGB')
+        max_size = max(input.size)
+        scale = min(1, 1024 / max_size)
+        if scale < 1:
+            input = input.resize((int(input.width * scale), int(input.height * scale)), Image.Resampling.LANCZOS)
+        # Use birefnet-massive instead of u2net for better performance
+        rembg_session = rembg.new_session('birefnet-massive')
+        output = rembg.remove(input, session=rembg_session)
+    output_np = np.array(output)
+    alpha = output_np[:, :, 3]
+    bbox = np.argwhere(alpha > 0.8 * 255)
+    bbox = np.min(bbox[:, 1]), np.min(bbox[:, 0]), np.max(bbox[:, 1]), np.max(bbox[:, 0])
+    center = (bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2
+    size = max(bbox[2] - bbox[0], bbox[3] - bbox[1])
+    size = int(size * 1.2)
+    bbox = center[0] - size // 2, center[1] - size // 2, center[0] + size // 2, center[1] + size // 2
+
+    # Uncropped image
+    before_crop = output.resize((518, 518), Image.Resampling.LANCZOS)
+    before_crop = np.array(before_crop).astype(np.float32) / 255
+
+    # If the crop region is out of the image, it will be automatically padded with black.
+    output = output.crop(bbox)  # type: ignore
+    output = output.resize((518, 518), Image.Resampling.LANCZOS)
+    output = np.array(output).astype(np.float32) / 255
+
+    if return_all_rbga:
+        before_crop_rgba = Image.fromarray((before_crop * 255).astype(np.uint8), mode='RGBA')
+        
+        before_crop = before_crop[:, :, :3] * before_crop[:, :, 3:4]
+        before_crop = Image.fromarray((before_crop * 255).astype(np.uint8))
+
+        output = Image.fromarray((output * 255).astype(np.uint8), mode='RGBA')
+        return output, before_crop_rgba, before_crop
+
+    before_crop = before_crop[:, :, :3] * before_crop[:, :, 3:4]
+    before_crop = Image.fromarray((before_crop * 255).astype(np.uint8))
+
+    if return_rgba:
+        output = Image.fromarray((output * 255).astype(np.uint8), mode='RGBA')
+        return output, before_crop
+
+    output = output[:, :, :3] * output[:, :, 3:4]
+    output = Image.fromarray((output * 255).astype(np.uint8))
+    return output, before_crop
+
+def seed_torch(seed=0):
+    print("Seed Fixed!")
+    random.seed(seed)
+    os.environ['PYTHONHASHSEED'] = str(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.benchmark = False
+    torch.backends.cudnn.deterministic = True
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='HunyuanGen Pipeline')
+    parser.add_argument('--root', type=str, default='', help='Root directory of the dataset')
+    parser.add_argument('--output', type=str, default='', help='Output directory of the results')
+    parser.add_argument('--N', type=int, default=1, help='Total number of parallel processes')
+    parser.add_argument('--n', type=int, default=0, help='Index of the current process')
+    parser.add_argument('--model', type=str, default='Hunyuan', help='Base model', choices=['Hunyuan'])
+    parser.add_argument('--seed', type=int, default=42, help='Random seed for reproducibility')
+    parser.add_argument('--skip', type=int, default=256, help='Skip every N frames for large movement of the object (default: 5)')
+    parser.add_argument('--max_faces', type=int, default=10000, help='Maximum number of faces for the generated mesh (default: 10000)')
+    parser.add_argument('--backend', type=str, default='hunyuan', choices=['hunyuan', 'trellis2'], help='Mesh generation backend')
+    parser.add_argument('--trellis2_env', type=str, default=os.environ.get('TRELLIS2_ENV', 'opg'), help='Conda env for Trellis2')
+    parser.add_argument('--trellis2_ckpt', type=str, default=os.environ.get('TRELLIS2_CKPT', '/mnt/einsia/aws01-nvme/einsia-shared/homes/gaomingju/jiayin/OVOW/engine/checkpoints/TRELLIS.2-4B'), help='Trellis2 checkpoint path')
+    parser.add_argument('--trellis2_pipeline_type', type=str, default=os.environ.get('TRELLIS2_PIPELINE_TYPE', '1024'), help='Trellis2 pipeline type')
+    parser.add_argument('--trellis2_max_num_tokens', type=int, default=int(os.environ.get('TRELLIS2_MAX_NUM_TOKENS', '49152')), help='Trellis2 max tokens')
+    parser.add_argument('--trellis2_texture_size', type=int, default=int(os.environ.get('TRELLIS2_TEXTURE_SIZE', '1024')), help='Trellis2 texture size')
+    parser.add_argument('--blender_bin', type=str, default=os.environ.get('BLENDER_BIN', '/mnt/einsia/aws01-nvme/einsia-shared/homes/gaomingju/jiayin/OVOW/blender-5.0.0-linux-x64/blender'), help='Blender binary for FBX export')
+    return parser.parse_args()
+
+def get_folder_size(folder):
+    return len([f for f in os.listdir(folder) if os.path.isfile(os.path.join(folder, f))])
+
+
+def _init_hunyuan_pipelines():
+    from hy3dgen.texgen import Hunyuan3DPaintPipeline
+    from hy3dgen.shapegen import Hunyuan3DDiTFlowMatchingPipeline
+    from hy3dgen.shapegen import FaceReducer, FloaterRemover, DegenerateFaceRemover
+
+    pipeline = Hunyuan3DDiTFlowMatchingPipeline.from_pretrained('tencent/Hunyuan3D-2')
+    pipeline_paint = Hunyuan3DPaintPipeline.from_pretrained('tencent/Hunyuan3D-2')
+
+    pipeline.model.requires_grad = False
+    pipeline.vae.requires_grad = False
+    pipeline.conditioner.requires_grad = False
+    pipeline_paint.models['delight_model'].pipeline.feature_extractor.requires_grad = False
+    pipeline_paint.models['delight_model'].pipeline.text_encoder.requires_grad = False
+    pipeline_paint.models['delight_model'].pipeline.unet.requires_grad = False
+    pipeline_paint.models['delight_model'].pipeline.vae.requires_grad = False
+    pipeline_paint.models['multiview_model'].pipeline.unet.requires_grad = False
+    pipeline_paint.models['multiview_model'].pipeline.vae.requires_grad = False
+    pipeline_paint.models['multiview_model'].pipeline.text_encoder.requires_grad = False
+    pipeline_paint.models['multiview_model'].pipeline.feature_extractor.requires_grad = False
+
+    return pipeline, pipeline_paint, (FaceReducer, FloaterRemover, DegenerateFaceRemover)
+
+
+def _resolve_conda_exe():
+    conda_exe = os.environ.get("CONDA_EXE")
+    if conda_exe and os.path.exists(conda_exe):
+        return conda_exe
+    for candidate in ["conda", "/root/miniconda3/bin/conda", "conda"]:
+        if os.path.isabs(candidate):
+            if os.path.exists(candidate):
+                return candidate
+        else:
+            return candidate
+    return "conda"
+
+
+def _run_trellis2(
+    trellis2_script,
+    image_path,
+    output_glb,
+    ckpt_path,
+    env_name,
+    pipeline_type,
+    max_num_tokens,
+    simplify_target,
+    texture_size,
+    seed,
+    log_path=None,
+):
+    conda_exe = _resolve_conda_exe()
+    cmd = [
+        conda_exe,
+        "run",
+        "-n",
+        env_name,
+        "python",
+        "-u",
+        trellis2_script,
+        "--input",
+        image_path,
+        "--output_glb",
+        output_glb,
+        "--ckpt",
+        ckpt_path,
+        "--seed",
+        str(seed),
+        "--pipeline_type",
+        str(pipeline_type),
+        "--max_num_tokens",
+        str(max_num_tokens),
+        "--simplify_target",
+        str(simplify_target),
+        "--texture_size",
+        str(texture_size),
+        "--disable_rembg",
+    ]
+    print("Running Trellis2:", " ".join(cmd))
+    env = os.environ.copy()
+    env["PYTHONUNBUFFERED"] = "1"
+    # Prefer spconv backend to avoid flex_gemm/triton incompatibilities.
+    env.setdefault("SPARSE_CONV_BACKEND", "spconv")
+    env.setdefault("SPCONV_ALGO", "native")
+    if log_path:
+        os.makedirs(os.path.dirname(log_path) or ".", exist_ok=True)
+        with open(log_path, "a", encoding="utf-8") as log_f:
+            log_f.write("CMD: " + " ".join(cmd) + "\n")
+            log_f.flush()
+            proc = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                text=True,
+                bufsize=1,
+                env=env,
+            )
+            assert proc.stdout is not None
+            for line in proc.stdout:
+                sys.stdout.write(line)
+                sys.stdout.flush()
+                log_f.write(line)
+                log_f.flush()
+            ret = proc.wait()
+            if ret != 0:
+                raise subprocess.CalledProcessError(ret, cmd)
+    else:
+        subprocess.run(cmd, check=True, env=env)
+
+
+def _convert_glb_to_fbx(convert_script, glb_path, fbx_path, blender_bin):
+    cmd = [
+        sys.executable,
+        convert_script,
+        "--input",
+        glb_path,
+        "--output",
+        fbx_path,
+        "--blender_bin",
+        blender_bin,
+    ]
+    print("Converting GLB to FBX:", " ".join(cmd))
+    subprocess.run(cmd, check=True)
+
+if __name__ == "__main__":
+    args = parse_args()
+    backend = args.backend.lower()
+    root = "/path/to/obj_motion/Eval/1/viz" if args.root == "" else args.root
+    default_output_root = "results_examples"
+    print(f"Root viz dir: {root}")
+
+    output_root = args.output if args.output != "" else default_output_root
+
+    processed_dirs = []
+    for name in os.listdir(root):
+        sub_path = os.path.join(root, name)
+        if not os.path.isdir(sub_path):
+            continue
+        processed_path = os.path.join(sub_path, "masked_rgb")
+        animation_path = os.path.join(sub_path, "animation")
+        if os.path.isdir(processed_path) and not os.path.isdir(animation_path):
+            processed_dirs.append(processed_path)
+    print("Found processed masked_rgb folders:")
+    print(processed_dirs)
+    animations = natsorted(processed_dirs, alg=ns.PATH)
+
+    folder_sizes = [(anim, get_folder_size(anim)) for anim in animations]
+    folder_sizes.sort(key=lambda x: x[1], reverse=True)
+
+    assignments = [[] for _ in range(args.N)]
+    workload = [0] * args.N
+
+    for folder, size in folder_sizes:
+        min_index = workload.index(min(workload))
+        assignments[min_index].append(folder)
+        workload[min_index] += size
+
+    assigned_animations = assignments[args.n]
+
+    total_imgs = sum(get_folder_size(f) for f in assigned_animations)
+    print(f"Process {args.n} assigned {len(assigned_animations)} folders with total images: {total_imgs}")
+
+    if backend == "hunyuan":
+        pipeline, pipeline_paint, cleaners = _init_hunyuan_pipelines()
+
+    for animation in assigned_animations:
+        source_path = animation
+        output_path = source_path if args.output == "" else os.path.join(args.output, source_path.split("/")[-2], 'Hunyuan_Gen_Input')
+
+        print("/n/n ============= Start processing: ", animation, " =============/n")
+        os.makedirs(output_path, exist_ok=True)
+
+        seed = args.seed
+        seed_torch(seed)
+        
+        imgs_list = os.listdir(source_path)
+        imgs_list = [img for img in imgs_list if not os.path.isdir(source_path + "/" + img)]
+        imgs_list = natsorted(imgs_list, alg=ns.PATH)
+
+        outputs_list = []
+        base_name_list = []
+        extrinsics_list = []
+        visual_list = []
+        params = None
+
+        for ind, img in enumerate(imgs_list):            
+            if ind % args.skip != 0:
+                continue
+
+            image = Image.open(source_path + "/" + img)
+            base_name = image.filename.split("/")[-1].split(".")[0]
+
+            save_path = output_path + "/" + base_name + "_rmbg.png"
+            cropped_image, rmbg_image = preprocess_image(image, return_rgba=True)
+            rmbg_image.save(save_path)
+            cropped_image.save(save_path.replace(".png", "_cropped.png"))
+            if backend == "trellis2":
+                trellis2_script = os.path.join(os.path.dirname(os.path.abspath(__file__)), "trellis2_gen.py")
+                trellis2_input = save_path.replace(".png", "_cropped.png")
+                glb_path = output_path + "/" + base_name + "_hunyuan_original_wo_remap.glb"
+                fbx_path = output_path + "/" + base_name + "_hunyuan_original_wo_remap_converted.fbx"
+                if os.path.exists(fbx_path):
+                    print(f"FBX already exists, skipping: {fbx_path}")
+                    continue
+                _run_trellis2(
+                    trellis2_script,
+                    trellis2_input,
+                    glb_path,
+                    args.trellis2_ckpt,
+                    args.trellis2_env,
+                    args.trellis2_pipeline_type,
+                    args.trellis2_max_num_tokens,
+                    args.max_faces,
+                    args.trellis2_texture_size,
+                    args.seed,
+                    log_path=os.path.join(output_path, f"{base_name}_trellis2.log"),
+                )
+                watertight_path = output_path + "/" + base_name + "_hunyuan_original_watertight.glb"
+                if not os.path.exists(watertight_path):
+                    shutil.copy(glb_path, watertight_path)
+                convert_script = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "utils", "convert_glb_to_fbx.py")
+                _convert_glb_to_fbx(convert_script, glb_path, fbx_path, args.blender_bin)
+                print(f"Trellis2 GLB exported: {glb_path}")
+                print(f"Trellis2 FBX exported: {fbx_path}")
+                continue
+            import time
+            start_time = time.time()
+            
+            torch.manual_seed(seed)
+            mesh = pipeline(image=cropped_image)[0]
+
+            for cleaner in [cleaners[1](), cleaners[2]()]:
+                mesh = cleaner(mesh)
+
+            mesh = cleaners[0]()(mesh, max_facenum=args.max_faces)
+
+            vertices_watertight = mesh.vertices @ np.array([[1, 0, 0], [0, 0, 1], [0, -1, 0]])
+            faces_watertight = mesh.faces
+            mean_point = mesh.vertices.mean(axis=0)
+            vertices_watertight = (vertices_watertight - mean_point) * 0.5 + mean_point
+            mesh_watertight = trimesh.Trimesh(vertices_watertight, faces_watertight, process=False)
+            mesh_watertight.export(output_path + "/" + base_name + "_hunyuan_original_watertight.glb")
+            print("mesh_watertight exported:", output_path + "/" + base_name + "_hunyuan_original_watertight.glb")
+
+            mesh, vmapping = pipeline_paint(mesh, image=cropped_image)
+            # Save vmapping for later use
+            vmapping_path = output_path + "/" + base_name + "_vmapping.npy"
+            np.save(vmapping_path, vmapping)
+            print(f"vmapping saved to: {vmapping_path}")
+            
+            end_time = time.time()
+            generation_time = end_time - start_time
+            print(f"Hunyuan generation time: {generation_time:.4f} seconds")
+            # Save the original Hunyuan mesh before further processing
+            mesh_original = mesh.copy()
+            mesh_original.export(output_path + "/" + base_name + "_hunyuan_original_wo_remap.glb")
+            print("mesh_original exported:", output_path + "/" + base_name + "_hunyuan_original_wo_remap.glb")

OVOW/third_party/Motion324/scripts/hy3dgen/__init__.py

@@ -0,0 +1,13 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.

OVOW/third_party/Motion324/scripts/hy3dgen/rembg.py

@@ -0,0 +1,25 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+from PIL import Image
+from rembg import remove, new_session
+
+
+class BackgroundRemover():
+    def __init__(self):
+        self.session = new_session()
+
+    def __call__(self, image: Image.Image):
+        output = remove(image, session=self.session, bgcolor=[255, 255, 255, 0])
+        return output

OVOW/third_party/Motion324/scripts/hy3dgen/shapegen/__init__.py

@@ -0,0 +1,17 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+from .pipelines import Hunyuan3DDiTPipeline, Hunyuan3DDiTFlowMatchingPipeline
+from .postprocessors import FaceReducer, FloaterRemover, DegenerateFaceRemover, MeshSimplifier
+from .preprocessors import ImageProcessorV2, IMAGE_PROCESSORS, DEFAULT_IMAGEPROCESSOR

OVOW/third_party/Motion324/scripts/hy3dgen/shapegen/pipelines.py

@@ -0,0 +1,765 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+import copy
+import importlib
+import inspect
+import os
+from typing import List, Optional, Union
+
+import numpy as np
+import torch
+import trimesh
+import yaml
+from PIL import Image
+from diffusers.utils.torch_utils import randn_tensor
+from diffusers.utils.import_utils import is_accelerate_version, is_accelerate_available
+from tqdm import tqdm
+
+from .models.autoencoders import ShapeVAE
+from .models.autoencoders import SurfaceExtractors
+from .utils import logger, synchronize_timer, smart_load_model
+
+
+def retrieve_timesteps(
+    scheduler,
+    num_inference_steps: Optional[int] = None,
+    device: Optional[Union[str, torch.device]] = None,
+    timesteps: Optional[List[int]] = None,
+    sigmas: Optional[List[float]] = None,
+    **kwargs,
+):
+    """
+    Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles
+    custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`.
+
+    Args:
+        scheduler (`SchedulerMixin`):
+            The scheduler to get timesteps from.
+        num_inference_steps (`int`):
+            The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps`
+            must be `None`.
+        device (`str` or `torch.device`, *optional*):
+            The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
+        timesteps (`List[int]`, *optional*):
+            Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed,
+            `num_inference_steps` and `sigmas` must be `None`.
+        sigmas (`List[float]`, *optional*):
+            Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed,
+            `num_inference_steps` and `timesteps` must be `None`.
+
+    Returns:
+        `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the
+        second element is the number of inference steps.
+    """
+    if timesteps is not None and sigmas is not None:
+        raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values")
+    if timesteps is not None:
+        accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys())
+        if not accepts_timesteps:
+            raise ValueError(
+                f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom"
+                f" timestep schedules. Please check whether you are using the correct scheduler."
+            )
+        scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs)
+        timesteps = scheduler.timesteps
+        num_inference_steps = len(timesteps)
+    elif sigmas is not None:
+        accept_sigmas = "sigmas" in set(inspect.signature(scheduler.set_timesteps).parameters.keys())
+        if not accept_sigmas:
+            raise ValueError(
+                f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom"
+                f" sigmas schedules. Please check whether you are using the correct scheduler."
+            )
+        scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs)
+        timesteps = scheduler.timesteps
+        num_inference_steps = len(timesteps)
+    else:
+        scheduler.set_timesteps(num_inference_steps, device=device, **kwargs)
+        timesteps = scheduler.timesteps
+    return timesteps, num_inference_steps
+
+
+@synchronize_timer('Export to trimesh')
+def export_to_trimesh(mesh_output):
+    if isinstance(mesh_output, list):
+        outputs = []
+        for mesh in mesh_output:
+            if mesh is None:
+                outputs.append(None)
+            else:
+                mesh.mesh_f = mesh.mesh_f[:, ::-1]
+                mesh_output = trimesh.Trimesh(mesh.mesh_v, mesh.mesh_f)
+                outputs.append(mesh_output)
+        return outputs
+    else:
+        mesh_output.mesh_f = mesh_output.mesh_f[:, ::-1]
+        mesh_output = trimesh.Trimesh(mesh_output.mesh_v, mesh_output.mesh_f)
+        return mesh_output
+
+
+def get_obj_from_str(string, reload=False):
+    module, cls = string.rsplit(".", 1)
+    if reload:
+        module_imp = importlib.import_module(module)
+        importlib.reload(module_imp)
+    return getattr(importlib.import_module(module, package=None), cls)
+
+
+def instantiate_from_config(config, **kwargs):
+    if "target" not in config:
+        raise KeyError("Expected key `target` to instantiate.")
+    cls = get_obj_from_str(config["target"])
+    params = config.get("params", dict())
+    kwargs.update(params)
+    instance = cls(**kwargs)
+    return instance
+
+
+class Hunyuan3DDiTPipeline:
+    model_cpu_offload_seq = "conditioner->model->vae"
+    _exclude_from_cpu_offload = []
+
+    @classmethod
+    @synchronize_timer('Hunyuan3DDiTPipeline Model Loading')
+    def from_single_file(
+        cls,
+        ckpt_path,
+        config_path,
+        device='cuda',
+        dtype=torch.float16,
+        use_safetensors=None,
+        **kwargs,
+    ):
+        # load config
+        with open(config_path, 'r') as f:
+            config = yaml.safe_load(f)
+
+        # load ckpt
+        if use_safetensors:
+            ckpt_path = ckpt_path.replace('.ckpt', '.safetensors')
+        if not os.path.exists(ckpt_path):
+            raise FileNotFoundError(f"Model file {ckpt_path} not found")
+        logger.info(f"Loading model from {ckpt_path}")
+
+        if use_safetensors:
+            # parse safetensors
+            import safetensors.torch
+            safetensors_ckpt = safetensors.torch.load_file(ckpt_path, device='cpu')
+            ckpt = {}
+            for key, value in safetensors_ckpt.items():
+                model_name = key.split('.')[0]
+                new_key = key[len(model_name) + 1:]
+                if model_name not in ckpt:
+                    ckpt[model_name] = {}
+                ckpt[model_name][new_key] = value
+        else:
+            ckpt = torch.load(ckpt_path, map_location='cpu', weights_only=True)
+        # load model
+        model = instantiate_from_config(config['model'])
+        model.load_state_dict(ckpt['model'])
+        vae = instantiate_from_config(config['vae'])
+        vae.load_state_dict(ckpt['vae'], strict=False)
+        conditioner = instantiate_from_config(config['conditioner'])
+        if 'conditioner' in ckpt:
+            conditioner.load_state_dict(ckpt['conditioner'])
+        image_processor = instantiate_from_config(config['image_processor'])
+        scheduler = instantiate_from_config(config['scheduler'])
+
+        model_kwargs = dict(
+            vae=vae,
+            model=model,
+            scheduler=scheduler,
+            conditioner=conditioner,
+            image_processor=image_processor,
+            device=device,
+            dtype=dtype,
+        )
+        model_kwargs.update(kwargs)
+
+        return cls(
+            **model_kwargs
+        )
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        model_path,
+        device='cuda',
+        dtype=torch.float16,
+        use_safetensors=True,
+        variant='fp16',
+        subfolder='hunyuan3d-dit-v2-0',
+        **kwargs,
+    ):
+        kwargs['from_pretrained_kwargs'] = dict(
+            model_path=model_path,
+            subfolder=subfolder,
+            use_safetensors=use_safetensors,
+            variant=variant,
+            dtype=dtype,
+            device=device,
+        )
+        config_path, ckpt_path = smart_load_model(
+            model_path,
+            subfolder=subfolder,
+            use_safetensors=use_safetensors,
+            variant=variant
+        )
+        return cls.from_single_file(
+            ckpt_path,
+            config_path,
+            device=device,
+            dtype=dtype,
+            use_safetensors=use_safetensors,
+            **kwargs
+        )
+
+    def __init__(
+        self,
+        vae,
+        model,
+        scheduler,
+        conditioner,
+        image_processor,
+        device='cuda',
+        dtype=torch.float16,
+        **kwargs
+    ):
+        self.vae = vae
+        self.model = model
+        self.scheduler = scheduler
+        self.conditioner = conditioner
+        self.image_processor = image_processor
+        self.kwargs = kwargs
+        self.to(device, dtype)
+
+    def compile(self):
+        self.vae = torch.compile(self.vae)
+        self.model = torch.compile(self.model)
+        self.conditioner = torch.compile(self.conditioner)
+
+    def enable_flashvdm(
+        self,
+        enabled: bool = True,
+        adaptive_kv_selection=True,
+        topk_mode='mean',
+        mc_algo='mc',
+        replace_vae=True,
+    ):
+        if enabled:
+            model_path = self.kwargs['from_pretrained_kwargs']['model_path']
+            turbo_vae_mapping = {
+                'Hunyuan3D-2': ('tencent/Hunyuan3D-2', 'hunyuan3d-vae-v2-0-turbo'),
+                'Hunyuan3D-2mv': ('tencent/Hunyuan3D-2', 'hunyuan3d-vae-v2-0-turbo'),
+                'Hunyuan3D-2mini': ('tencent/Hunyuan3D-2mini', 'hunyuan3d-vae-v2-mini-turbo'),
+            }
+            model_name = model_path.split('/')[-1]
+            if replace_vae and model_name in turbo_vae_mapping:
+                model_path, subfolder = turbo_vae_mapping[model_name]
+                self.vae = ShapeVAE.from_pretrained(
+                    model_path, subfolder=subfolder,
+                    use_safetensors=self.kwargs['from_pretrained_kwargs']['use_safetensors'],
+                    device=self.device,
+                )
+            self.vae.enable_flashvdm_decoder(
+                enabled=enabled,
+                adaptive_kv_selection=adaptive_kv_selection,
+                topk_mode=topk_mode,
+                mc_algo=mc_algo
+            )
+        else:
+            model_path = self.kwargs['from_pretrained_kwargs']['model_path']
+            vae_mapping = {
+                'Hunyuan3D-2': ('tencent/Hunyuan3D-2', 'hunyuan3d-vae-v2-0'),
+                'Hunyuan3D-2mv': ('tencent/Hunyuan3D-2', 'hunyuan3d-vae-v2-0'),
+                'Hunyuan3D-2mini': ('tencent/Hunyuan3D-2mini', 'hunyuan3d-vae-v2-mini'),
+            }
+            model_name = model_path.split('/')[-1]
+            if model_name in vae_mapping:
+                model_path, subfolder = vae_mapping[model_name]
+                self.vae = ShapeVAE.from_pretrained(model_path, subfolder=subfolder)
+            self.vae.enable_flashvdm_decoder(enabled=False)
+
+    def to(self, device=None, dtype=None):
+        if dtype is not None:
+            self.dtype = dtype
+            self.vae.to(dtype=dtype)
+            self.model.to(dtype=dtype)
+            self.conditioner.to(dtype=dtype)
+        if device is not None:
+            self.device = torch.device(device)
+            self.vae.to(device)
+            self.model.to(device)
+            self.conditioner.to(device)
+
+    @property
+    def _execution_device(self):
+        r"""
+        Returns the device on which the pipeline's models will be executed. After calling
+        [`~DiffusionPipeline.enable_sequential_cpu_offload`] the execution device can only be inferred from
+        Accelerate's module hooks.
+        """
+        for name, model in self.components.items():
+            if not isinstance(model, torch.nn.Module) or name in self._exclude_from_cpu_offload:
+                continue
+
+            if not hasattr(model, "_hf_hook"):
+                return self.device
+            for module in model.modules():
+                if (
+                    hasattr(module, "_hf_hook")
+                    and hasattr(module._hf_hook, "execution_device")
+                    and module._hf_hook.execution_device is not None
+                ):
+                    return torch.device(module._hf_hook.execution_device)
+        return self.device
+
+    def enable_model_cpu_offload(self, gpu_id: Optional[int] = None, device: Union[torch.device, str] = "cuda"):
+        r"""
+        Offloads all models to CPU using accelerate, reducing memory usage with a low impact on performance. Compared
+        to `enable_sequential_cpu_offload`, this method moves one whole model at a time to the GPU when its `forward`
+        method is called, and the model remains in GPU until the next model runs. Memory savings are lower than with
+        `enable_sequential_cpu_offload`, but performance is much better due to the iterative execution of the `unet`.
+
+        Arguments:
+            gpu_id (`int`, *optional*):
+                The ID of the accelerator that shall be used in inference. If not specified, it will default to 0.
+            device (`torch.Device` or `str`, *optional*, defaults to "cuda"):
+                The PyTorch device type of the accelerator that shall be used in inference. If not specified, it will
+                default to "cuda".
+        """
+        if self.model_cpu_offload_seq is None:
+            raise ValueError(
+                "Model CPU offload cannot be enabled because no `model_cpu_offload_seq` class attribute is set."
+            )
+
+        if is_accelerate_available() and is_accelerate_version(">=", "0.17.0.dev0"):
+            from accelerate import cpu_offload_with_hook
+        else:
+            raise ImportError("`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.")
+
+        torch_device = torch.device(device)
+        device_index = torch_device.index
+
+        if gpu_id is not None and device_index is not None:
+            raise ValueError(
+                f"You have passed both `gpu_id`={gpu_id} and an index as part of the passed device `device`={device}"
+                f"Cannot pass both. Please make sure to either not define `gpu_id` or not pass the index as part of the device: `device`={torch_device.type}"
+            )
+
+        # _offload_gpu_id should be set to passed gpu_id (or id in passed `device`) or default to previously set id or default to 0
+        self._offload_gpu_id = gpu_id or torch_device.index or getattr(self, "_offload_gpu_id", 0)
+
+        device_type = torch_device.type
+        device = torch.device(f"{device_type}:{self._offload_gpu_id}")
+
+        if self.device.type != "cpu":
+            self.to("cpu")
+            device_mod = getattr(torch, self.device.type, None)
+            if hasattr(device_mod, "empty_cache") and device_mod.is_available():
+                device_mod.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)
+
+        all_model_components = {k: v for k, v in self.components.items() if isinstance(v, torch.nn.Module)}
+
+        self._all_hooks = []
+        hook = None
+        for model_str in self.model_cpu_offload_seq.split("->"):
+            model = all_model_components.pop(model_str, None)
+            if not isinstance(model, torch.nn.Module):
+                continue
+
+            _, hook = cpu_offload_with_hook(model, device, prev_module_hook=hook)
+            self._all_hooks.append(hook)
+
+        # CPU offload models that are not in the seq chain unless they are explicitly excluded
+        # these models will stay on CPU until maybe_free_model_hooks is called
+        # some models cannot be in the seq chain because they are iteratively called, such as controlnet
+        for name, model in all_model_components.items():
+            if not isinstance(model, torch.nn.Module):
+                continue
+
+            if name in self._exclude_from_cpu_offload:
+                model.to(device)
+            else:
+                _, hook = cpu_offload_with_hook(model, device)
+                self._all_hooks.append(hook)
+
+    def maybe_free_model_hooks(self):
+        r"""
+        Function that offloads all components, removes all model hooks that were added when using
+        `enable_model_cpu_offload` and then applies them again. In case the model has not been offloaded this function
+        is a no-op. Make sure to add this function to the end of the `__call__` function of your pipeline so that it
+        functions correctly when applying enable_model_cpu_offload.
+        """
+        if not hasattr(self, "_all_hooks") or len(self._all_hooks) == 0:
+            # `enable_model_cpu_offload` has not be called, so silently do nothing
+            return
+
+        for hook in self._all_hooks:
+            # offload model and remove hook from model
+            hook.offload()
+            hook.remove()
+
+        # make sure the model is in the same state as before calling it
+        self.enable_model_cpu_offload()
+
+    @synchronize_timer('Encode cond')
+    def encode_cond(self, image, additional_cond_inputs, do_classifier_free_guidance, dual_guidance):
+        bsz = image.shape[0]
+        cond = self.conditioner(image=image, **additional_cond_inputs)
+
+        if do_classifier_free_guidance:
+            un_cond = self.conditioner.unconditional_embedding(bsz, **additional_cond_inputs)
+
+            if dual_guidance:
+                un_cond_drop_main = copy.deepcopy(un_cond)
+                un_cond_drop_main['additional'] = cond['additional']
+
+                def cat_recursive(a, b, c):
+                    if isinstance(a, torch.Tensor):
+                        return torch.cat([a, b, c], dim=0).to(self.dtype)
+                    out = {}
+                    for k in a.keys():
+                        out[k] = cat_recursive(a[k], b[k], c[k])
+                    return out
+
+                cond = cat_recursive(cond, un_cond_drop_main, un_cond)
+            else:
+                def cat_recursive(a, b):
+                    if isinstance(a, torch.Tensor):
+                        return torch.cat([a, b], dim=0).to(self.dtype)
+                    out = {}
+                    for k in a.keys():
+                        out[k] = cat_recursive(a[k], b[k])
+                    return out
+
+                cond = cat_recursive(cond, un_cond)
+        return cond
+
+    def prepare_extra_step_kwargs(self, generator, eta):
+        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
+        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
+        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
+        # and should be between [0, 1]
+
+        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
+        extra_step_kwargs = {}
+        if accepts_eta:
+            extra_step_kwargs["eta"] = eta
+
+        # check if the scheduler accepts generator
+        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
+        if accepts_generator:
+            extra_step_kwargs["generator"] = generator
+        return extra_step_kwargs
+
+    def prepare_latents(self, batch_size, dtype, device, generator, latents=None):
+        shape = (batch_size, *self.vae.latent_shape)
+        if isinstance(generator, list) and len(generator) != batch_size:
+            raise ValueError(
+                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
+                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
+            )
+
+        if latents is None:
+            latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
+        else:
+            latents = latents.to(device)
+
+        # scale the initial noise by the standard deviation required by the scheduler
+        latents = latents * getattr(self.scheduler, 'init_noise_sigma', 1.0)
+        return latents
+
+    def prepare_image(self, image) -> dict:
+        if isinstance(image, str) and not os.path.exists(image):
+            raise FileNotFoundError(f"Couldn't find image at path {image}")
+
+        if not isinstance(image, list):
+            image = [image]
+
+        outputs = []
+        for img in image:
+            output = self.image_processor(img)
+            outputs.append(output)
+
+        cond_input = {k: [] for k in outputs[0].keys()}
+        for output in outputs:
+            for key, value in output.items():
+                cond_input[key].append(value)
+        for key, value in cond_input.items():
+            if isinstance(value[0], torch.Tensor):
+                cond_input[key] = torch.cat(value, dim=0)
+
+        return cond_input
+
+    def get_guidance_scale_embedding(self, w, embedding_dim=512, dtype=torch.float32):
+        """
+        See https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298
+
+        Args:
+            timesteps (`torch.Tensor`):
+                generate embedding vectors at these timesteps
+            embedding_dim (`int`, *optional*, defaults to 512):
+                dimension of the embeddings to generate
+            dtype:
+                data type of the generated embeddings
+
+        Returns:
+            `torch.FloatTensor`: Embedding vectors with shape `(len(timesteps), embedding_dim)`
+        """
+        assert len(w.shape) == 1
+        w = w * 1000.0
+
+        half_dim = embedding_dim // 2
+        emb = torch.log(torch.tensor(10000.0)) / (half_dim - 1)
+        emb = torch.exp(torch.arange(half_dim, dtype=dtype) * -emb)
+        emb = w.to(dtype)[:, None] * emb[None, :]
+        emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
+        if embedding_dim % 2 == 1:  # zero pad
+            emb = torch.nn.functional.pad(emb, (0, 1))
+        assert emb.shape == (w.shape[0], embedding_dim)
+        return emb
+
+    def set_surface_extractor(self, mc_algo):
+        if mc_algo is None:
+            return
+        logger.info('The parameters `mc_algo` is deprecated, and will be removed in future versions.\n'
+                    'Please use: \n'
+                    'from hy3dgen.shapegen.models.autoencoders import SurfaceExtractors\n'
+                    'pipeline.vae.surface_extractor = SurfaceExtractors[mc_algo]() instead\n')
+        if mc_algo not in SurfaceExtractors.keys():
+            raise ValueError(f"Unknown mc_algo {mc_algo}")
+        self.vae.surface_extractor = SurfaceExtractors[mc_algo]()
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        image: Union[str, List[str], Image.Image] = None,
+        num_inference_steps: int = 50,
+        timesteps: List[int] = None,
+        sigmas: List[float] = None,
+        eta: float = 0.0,
+        guidance_scale: float = 7.5,
+        dual_guidance_scale: float = 10.5,
+        dual_guidance: bool = True,
+        generator=None,
+        box_v=1.01,
+        octree_resolution=384,
+        mc_level=-1 / 512,
+        num_chunks=8000,
+        mc_algo=None,
+        output_type: Optional[str] = "trimesh",
+        enable_pbar=True,
+        **kwargs,
+    ) -> List[List[trimesh.Trimesh]]:
+        callback = kwargs.pop("callback", None)
+        callback_steps = kwargs.pop("callback_steps", None)
+
+        self.set_surface_extractor(mc_algo)
+
+        device = self.device
+        dtype = self.dtype
+        do_classifier_free_guidance = guidance_scale >= 0 and \
+                                      getattr(self.model, 'guidance_cond_proj_dim', None) is None
+        dual_guidance = dual_guidance_scale >= 0 and dual_guidance
+
+        cond_inputs = self.prepare_image(image)
+        image = cond_inputs.pop('image')
+        cond = self.encode_cond(
+            image=image,
+            additional_cond_inputs=cond_inputs,
+            do_classifier_free_guidance=do_classifier_free_guidance,
+            dual_guidance=False,
+        )
+        batch_size = image.shape[0]
+
+        t_dtype = torch.long
+        timesteps, num_inference_steps = retrieve_timesteps(
+            self.scheduler, num_inference_steps, device, timesteps, sigmas)
+
+        latents = self.prepare_latents(batch_size, dtype, device, generator)
+        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
+
+        guidance_cond = None
+        if getattr(self.model, 'guidance_cond_proj_dim', None) is not None:
+            logger.info('Using lcm guidance scale')
+            guidance_scale_tensor = torch.tensor(guidance_scale - 1).repeat(batch_size)
+            guidance_cond = self.get_guidance_scale_embedding(
+                guidance_scale_tensor, embedding_dim=self.model.guidance_cond_proj_dim
+            ).to(device=device, dtype=latents.dtype)
+        with synchronize_timer('Diffusion Sampling'):
+            for i, t in enumerate(tqdm(timesteps, disable=not enable_pbar, desc="Diffusion Sampling:", leave=False)):
+                # expand the latents if we are doing classifier free guidance
+                if do_classifier_free_guidance:
+                    latent_model_input = torch.cat([latents] * (3 if dual_guidance else 2))
+                else:
+                    latent_model_input = latents
+                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
+
+                # predict the noise residual
+                timestep_tensor = torch.tensor([t], dtype=t_dtype, device=device)
+                timestep_tensor = timestep_tensor.expand(latent_model_input.shape[0])
+                noise_pred = self.model(latent_model_input, timestep_tensor, cond, guidance_cond=guidance_cond)
+
+                # no drop, drop clip, all drop
+                if do_classifier_free_guidance:
+                    if dual_guidance:
+                        noise_pred_clip, noise_pred_dino, noise_pred_uncond = noise_pred.chunk(3)
+                        noise_pred = (
+                            noise_pred_uncond
+                            + guidance_scale * (noise_pred_clip - noise_pred_dino)
+                            + dual_guidance_scale * (noise_pred_dino - noise_pred_uncond)
+                        )
+                    else:
+                        noise_pred_cond, noise_pred_uncond = noise_pred.chunk(2)
+                        noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_cond - noise_pred_uncond)
+
+                # compute the previous noisy sample x_t -> x_t-1
+                outputs = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs)
+                latents = outputs.prev_sample
+
+                if callback is not None and i % callback_steps == 0:
+                    step_idx = i // getattr(self.scheduler, "order", 1)
+                    callback(step_idx, t, outputs)
+
+        return self._export(
+            latents,
+            output_type,
+            box_v, mc_level, num_chunks, octree_resolution, mc_algo,
+        )
+
+    def _export(
+        self,
+        latents,
+        output_type='trimesh',
+        box_v=1.01,
+        mc_level=0.0,
+        num_chunks=20000,
+        octree_resolution=256,
+        mc_algo='mc',
+        enable_pbar=True
+    ):
+        if not output_type == "latent":
+            latents = 1. / self.vae.scale_factor * latents
+            latents = self.vae(latents)
+            outputs = self.vae.latents2mesh(
+                latents,
+                bounds=box_v,
+                mc_level=mc_level,
+                num_chunks=num_chunks,
+                octree_resolution=octree_resolution,
+                mc_algo=mc_algo,
+                enable_pbar=enable_pbar,
+            )
+        else:
+            outputs = latents
+
+        if output_type == 'trimesh':
+            outputs = export_to_trimesh(outputs)
+
+        return outputs
+
+
+class Hunyuan3DDiTFlowMatchingPipeline(Hunyuan3DDiTPipeline):
+
+    @torch.inference_mode()
+    def __call__(
+        self,
+        image: Union[str, List[str], Image.Image, dict, List[dict]] = None,
+        num_inference_steps: int = 50,
+        timesteps: List[int] = None,
+        sigmas: List[float] = None,
+        eta: float = 0.0,
+        guidance_scale: float = 5.0,
+        generator=None,
+        box_v=1.01,
+        octree_resolution=384,
+        mc_level=0.0,
+        mc_algo=None,
+        num_chunks=8000,
+        output_type: Optional[str] = "trimesh",
+        enable_pbar=True,
+        **kwargs,
+    ) -> List[List[trimesh.Trimesh]]:
+        callback = kwargs.pop("callback", None)
+        callback_steps = kwargs.pop("callback_steps", None)
+
+        self.set_surface_extractor(mc_algo)
+
+        device = self.device
+        dtype = self.dtype
+        do_classifier_free_guidance = guidance_scale >= 0 and not (
+            hasattr(self.model, 'guidance_embed') and
+            self.model.guidance_embed is True
+        )
+
+        cond_inputs = self.prepare_image(image)
+        image = cond_inputs.pop('image')
+        cond = self.encode_cond(
+            image=image,
+            additional_cond_inputs=cond_inputs,
+            do_classifier_free_guidance=do_classifier_free_guidance,
+            dual_guidance=False,
+        )
+        batch_size = image.shape[0]
+
+        # 5. Prepare timesteps
+        # NOTE: this is slightly different from common usage, we start from 0.
+        sigmas = np.linspace(0, 1, num_inference_steps) if sigmas is None else sigmas
+        timesteps, num_inference_steps = retrieve_timesteps(
+            self.scheduler,
+            num_inference_steps,
+            device,
+            sigmas=sigmas,
+        )
+        latents = self.prepare_latents(batch_size, dtype, device, generator)
+
+        guidance = None
+        if hasattr(self.model, 'guidance_embed') and \
+            self.model.guidance_embed is True:
+            guidance = torch.tensor([guidance_scale] * batch_size, device=device, dtype=dtype)
+            # logger.info(f'Using guidance embed with scale {guidance_scale}')
+
+        with synchronize_timer('Diffusion Sampling'):
+            for i, t in enumerate(tqdm(timesteps, disable=not enable_pbar, desc="Diffusion Sampling:")):
+                # expand the latents if we are doing classifier free guidance
+                if do_classifier_free_guidance:
+                    latent_model_input = torch.cat([latents] * 2)
+                else:
+                    latent_model_input = latents
+
+                # NOTE: we assume model get timesteps ranged from 0 to 1
+                timestep = t.expand(latent_model_input.shape[0]).to(
+                    latents.dtype) / self.scheduler.config.num_train_timesteps
+                noise_pred = self.model(latent_model_input, timestep, cond, guidance=guidance)
+
+                if do_classifier_free_guidance:
+                    noise_pred_cond, noise_pred_uncond = noise_pred.chunk(2)
+                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_cond - noise_pred_uncond)
+
+                # compute the previous noisy sample x_t -> x_t-1
+                outputs = self.scheduler.step(noise_pred, t, latents)
+                latents = outputs.prev_sample
+
+                if callback is not None and i % callback_steps == 0:
+                    step_idx = i // getattr(self.scheduler, "order", 1)
+                    callback(step_idx, t, outputs)
+
+        return self._export(
+            latents,
+            output_type,
+            box_v, mc_level, num_chunks, octree_resolution, mc_algo,
+            enable_pbar=enable_pbar,
+        )

OVOW/third_party/Motion324/scripts/hy3dgen/shapegen/postprocessors.py

@@ -0,0 +1,204 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+import os
+import tempfile
+from typing import Union
+
+import numpy as np
+import pymeshlab
+import torch
+import trimesh
+
+from .models.autoencoders import Latent2MeshOutput
+from .utils import synchronize_timer
+
+
+def load_mesh(path):
+    if path.endswith(".glb"):
+        mesh = trimesh.load(path)
+    else:
+        mesh = pymeshlab.MeshSet()
+        mesh.load_new_mesh(path)
+    return mesh
+
+
+def reduce_face(mesh: pymeshlab.MeshSet, max_facenum: int = 200000):
+    if max_facenum > mesh.current_mesh().face_number():
+        return mesh
+
+    mesh.apply_filter(
+        "meshing_decimation_quadric_edge_collapse",
+        targetfacenum=max_facenum,
+        qualitythr=1.0,
+        preserveboundary=True,
+        boundaryweight=3,
+        preservenormal=True,
+        preservetopology=True,
+        autoclean=True
+    )
+    return mesh
+
+
+def remove_floater(mesh: pymeshlab.MeshSet):
+    mesh.apply_filter("compute_selection_by_small_disconnected_components_per_face",
+                      nbfaceratio=0.005)
+    mesh.apply_filter("compute_selection_transfer_face_to_vertex", inclusive=False)
+    mesh.apply_filter("meshing_remove_selected_vertices_and_faces")
+    return mesh
+
+
+def pymeshlab2trimesh(mesh: pymeshlab.MeshSet):
+    tmp_dir = os.path.join(os.environ.get('TMPDIR', tempfile.gettempdir()), 'hy3dgen_tmp')
+    os.makedirs(tmp_dir, exist_ok=True)
+    temp_file_path = os.path.join(tmp_dir, f'temp_mesh_{os.getpid()}.ply')
+    mesh.save_current_mesh(temp_file_path)
+    mesh = trimesh.load(temp_file_path)
+    # Check loaded object type
+    if isinstance(mesh, trimesh.Scene):
+        combined_mesh = trimesh.Trimesh()
+        # If it's a Scene, iterate through all geometries and merge them
+        for geom in mesh.geometry.values():
+            combined_mesh = trimesh.util.concatenate([combined_mesh, geom])
+        mesh = combined_mesh
+    return mesh
+
+
+def trimesh2pymeshlab(mesh: trimesh.Trimesh):
+    with tempfile.NamedTemporaryFile(suffix='.ply', delete=False) as temp_file:
+        if isinstance(mesh, trimesh.scene.Scene):
+            for idx, obj in enumerate(mesh.geometry.values()):
+                if idx == 0:
+                    temp_mesh = obj
+                else:
+                    temp_mesh = temp_mesh + obj
+            mesh = temp_mesh
+        mesh.export(temp_file.name)
+        mesh = pymeshlab.MeshSet()
+        mesh.load_new_mesh(temp_file.name)
+    return mesh
+
+
+def export_mesh(input, output):
+    if isinstance(input, pymeshlab.MeshSet):
+        mesh = output
+    elif isinstance(input, Latent2MeshOutput):
+        output = Latent2MeshOutput()
+        output.mesh_v = output.current_mesh().vertex_matrix()
+        output.mesh_f = output.current_mesh().face_matrix()
+        mesh = output
+    else:
+        mesh = pymeshlab2trimesh(output)
+    return mesh
+
+
+def import_mesh(mesh: Union[pymeshlab.MeshSet, trimesh.Trimesh, Latent2MeshOutput, str]) -> pymeshlab.MeshSet:
+    if isinstance(mesh, str):
+        mesh = load_mesh(mesh)
+    elif isinstance(mesh, Latent2MeshOutput):
+        mesh = pymeshlab.MeshSet()
+        mesh_pymeshlab = pymeshlab.Mesh(vertex_matrix=mesh.mesh_v, face_matrix=mesh.mesh_f)
+        mesh.add_mesh(mesh_pymeshlab, "converted_mesh")
+
+    if isinstance(mesh, (trimesh.Trimesh, trimesh.scene.Scene)):
+        mesh = trimesh2pymeshlab(mesh)
+
+    return mesh
+
+
+class FaceReducer:
+    @synchronize_timer('FaceReducer')
+    def __call__(
+        self,
+        mesh: Union[pymeshlab.MeshSet, trimesh.Trimesh, Latent2MeshOutput, str],
+        max_facenum: int = 40000
+    ) -> Union[pymeshlab.MeshSet, trimesh.Trimesh]:
+        ms = import_mesh(mesh)
+        ms = reduce_face(ms, max_facenum=max_facenum)
+        mesh = export_mesh(mesh, ms)
+        return mesh
+
+
+class FloaterRemover:
+    @synchronize_timer('FloaterRemover')
+    def __call__(
+        self,
+        mesh: Union[pymeshlab.MeshSet, trimesh.Trimesh, Latent2MeshOutput, str],
+    ) -> Union[pymeshlab.MeshSet, trimesh.Trimesh, Latent2MeshOutput]:
+        ms = import_mesh(mesh)
+        ms = remove_floater(ms)
+        mesh = export_mesh(mesh, ms)
+        return mesh
+
+
+class DegenerateFaceRemover:
+    @synchronize_timer('DegenerateFaceRemover')
+    def __call__(
+        self,
+        mesh: Union[pymeshlab.MeshSet, trimesh.Trimesh, Latent2MeshOutput, str],
+    ) -> Union[pymeshlab.MeshSet, trimesh.Trimesh, Latent2MeshOutput]:
+        ms = import_mesh(mesh)
+
+        with tempfile.NamedTemporaryFile(suffix='.ply', delete=False) as temp_file:
+            ms.save_current_mesh(temp_file.name)
+            ms = pymeshlab.MeshSet()
+            ms.load_new_mesh(temp_file.name)
+
+        mesh = export_mesh(mesh, ms)
+        return mesh
+
+
+def mesh_normalize(mesh):
+    """
+    Normalize mesh vertices to sphere
+    """
+    scale_factor = 1.2
+    vtx_pos = np.asarray(mesh.vertices)
+    max_bb = (vtx_pos - 0).max(0)[0]
+    min_bb = (vtx_pos - 0).min(0)[0]
+
+    center = (max_bb + min_bb) / 2
+
+    scale = torch.norm(torch.tensor(vtx_pos - center, dtype=torch.float32), dim=1).max() * 2.0
+
+    vtx_pos = (vtx_pos - center) * (scale_factor / float(scale))
+    mesh.vertices = vtx_pos
+
+    return mesh
+
+
+class MeshSimplifier:
+    def __init__(self, executable: str = None):
+        if executable is None:
+            CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+            executable = os.path.join(CURRENT_DIR, "mesh_simplifier.bin")
+        self.executable = executable
+
+    @synchronize_timer('MeshSimplifier')
+    def __call__(
+        self,
+        mesh: Union[trimesh.Trimesh],
+    ) -> Union[trimesh.Trimesh]:
+        with tempfile.NamedTemporaryFile(suffix='.obj', delete=False) as temp_input:
+            with tempfile.NamedTemporaryFile(suffix='.obj', delete=False) as temp_output:
+                mesh.export(temp_input.name)
+                os.system(f'{self.executable} {temp_input.name} {temp_output.name}')
+                ms = trimesh.load(temp_output.name, process=False)
+                if isinstance(ms, trimesh.Scene):
+                    combined_mesh = trimesh.Trimesh()
+                    for geom in ms.geometry.values():
+                        combined_mesh = trimesh.util.concatenate([combined_mesh, geom])
+                    ms = combined_mesh
+                ms = mesh_normalize(ms)
+                return ms

OVOW/third_party/Motion324/scripts/hy3dgen/shapegen/preprocessors.py

@@ -0,0 +1,167 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+import cv2
+import numpy as np
+import torch
+from PIL import Image
+from einops import repeat, rearrange
+
+
+def array_to_tensor(np_array):
+    image_pt = torch.tensor(np_array).float()
+    image_pt = image_pt / 255 * 2 - 1
+    image_pt = rearrange(image_pt, "h w c -> c h w")
+    image_pts = repeat(image_pt, "c h w -> b c h w", b=1)
+    return image_pts
+
+
+class ImageProcessorV2:
+    def __init__(self, size=512, border_ratio=None):
+        self.size = size
+        self.border_ratio = border_ratio
+
+    @staticmethod
+    def recenter(image, border_ratio: float = 0.2):
+        """ recenter an image to leave some empty space at the image border.
+
+        Args:
+            image (ndarray): input image, float/uint8 [H, W, 3/4]
+            mask (ndarray): alpha mask, bool [H, W]
+            border_ratio (float, optional): border ratio, image will be resized to (1 - border_ratio). Defaults to 0.2.
+
+        Returns:
+            ndarray: output image, float/uint8 [H, W, 3/4]
+        """
+
+        if image.shape[-1] == 4:
+            mask = image[..., 3]
+        else:
+            mask = np.ones_like(image[..., 0:1]) * 255
+            image = np.concatenate([image, mask], axis=-1)
+            mask = mask[..., 0]
+
+        H, W, C = image.shape
+
+        size = max(H, W)
+        result = np.zeros((size, size, C), dtype=np.uint8)
+
+        coords = np.nonzero(mask)
+        x_min, x_max = coords[0].min(), coords[0].max()
+        y_min, y_max = coords[1].min(), coords[1].max()
+        h = x_max - x_min
+        w = y_max - y_min
+        if h == 0 or w == 0:
+            raise ValueError('input image is empty')
+        desired_size = int(size * (1 - border_ratio))
+        scale = desired_size / max(h, w)
+        h2 = int(h * scale)
+        w2 = int(w * scale)
+        x2_min = (size - h2) // 2
+        x2_max = x2_min + h2
+
+        y2_min = (size - w2) // 2
+        y2_max = y2_min + w2
+
+        result[x2_min:x2_max, y2_min:y2_max] = cv2.resize(image[x_min:x_max, y_min:y_max], (w2, h2),
+                                                          interpolation=cv2.INTER_AREA)
+
+        bg = np.ones((result.shape[0], result.shape[1], 3), dtype=np.uint8) * 255
+
+        mask = result[..., 3:].astype(np.float32) / 255
+        result = result[..., :3] * mask + bg * (1 - mask)
+
+        mask = mask * 255
+        result = result.clip(0, 255).astype(np.uint8)
+        mask = mask.clip(0, 255).astype(np.uint8)
+        return result, mask
+
+    def load_image(self, image, border_ratio=0.15, to_tensor=True):
+        if isinstance(image, str):
+            image = cv2.imread(image, cv2.IMREAD_UNCHANGED)
+            image, mask = self.recenter(image, border_ratio=border_ratio)
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        elif isinstance(image, Image.Image):
+            image = image.convert("RGBA")
+            image = np.asarray(image)
+            image, mask = self.recenter(image, border_ratio=border_ratio)
+
+        image = cv2.resize(image, (self.size, self.size), interpolation=cv2.INTER_CUBIC)
+        mask = cv2.resize(mask, (self.size, self.size), interpolation=cv2.INTER_NEAREST)
+        mask = mask[..., np.newaxis]
+
+        if to_tensor:
+            image = array_to_tensor(image)
+            mask = array_to_tensor(mask)
+        return image, mask
+
+    def __call__(self, image, border_ratio=0.15, to_tensor=True, **kwargs):
+        if self.border_ratio is not None:
+            border_ratio = self.border_ratio
+        image, mask = self.load_image(image, border_ratio=border_ratio, to_tensor=to_tensor)
+        outputs = {
+            'image': image,
+            'mask': mask
+        }
+        return outputs
+
+
+class MVImageProcessorV2(ImageProcessorV2):
+    """
+    view order: front, front clockwise 90, back, front clockwise 270
+    """
+    return_view_idx = True
+
+    def __init__(self, size=512, border_ratio=None):
+        super().__init__(size, border_ratio)
+        self.view2idx = {
+            'front': 0,
+            'left': 1,
+            'back': 2,
+            'right': 3
+        }
+
+    def __call__(self, image_dict, border_ratio=0.15, to_tensor=True, **kwargs):
+        if self.border_ratio is not None:
+            border_ratio = self.border_ratio
+
+        images = []
+        masks = []
+        view_idxs = []
+        for idx, (view_tag, image) in enumerate(image_dict.items()):
+            view_idxs.append(self.view2idx[view_tag])
+            image, mask = self.load_image(image, border_ratio=border_ratio, to_tensor=to_tensor)
+            images.append(image)
+            masks.append(mask)
+
+        zipped_lists = zip(view_idxs, images, masks)
+        sorted_zipped_lists = sorted(zipped_lists)
+        view_idxs, images, masks = zip(*sorted_zipped_lists)
+
+        image = torch.cat(images, 0).unsqueeze(0)
+        mask = torch.cat(masks, 0).unsqueeze(0)
+        outputs = {
+            'image': image,
+            'mask': mask,
+            'view_idxs': view_idxs
+        }
+        return outputs
+
+
+IMAGE_PROCESSORS = {
+    "v2": ImageProcessorV2,
+    'mv_v2': MVImageProcessorV2,
+}
+
+DEFAULT_IMAGEPROCESSOR = 'v2'

OVOW/third_party/Motion324/scripts/hy3dgen/shapegen/schedulers.py

@@ -0,0 +1,480 @@
+# Copyright 2024 Stability AI, Katherine Crowson and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+import math
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils import BaseOutput, logging
+
+logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
+
+
+@dataclass
+class FlowMatchEulerDiscreteSchedulerOutput(BaseOutput):
+    """
+    Output class for the scheduler's `step` function output.
+
+    Args:
+        prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
+            Computed sample `(x_{t-1})` of previous timestep. `prev_sample` should be used as next model input in the
+            denoising loop.
+    """
+
+    prev_sample: torch.FloatTensor
+
+
+class FlowMatchEulerDiscreteScheduler(SchedulerMixin, ConfigMixin):
+    """
+    NOTE: this is very similar to diffusers.FlowMatchEulerDiscreteScheduler. Except our timesteps are reversed
+
+    Euler scheduler.
+
+    This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic
+    methods the library implements for all schedulers such as loading and saving.
+
+    Args:
+        num_train_timesteps (`int`, defaults to 1000):
+            The number of diffusion steps to train the model.
+        timestep_spacing (`str`, defaults to `"linspace"`):
+            The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and
+            Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information.
+        shift (`float`, defaults to 1.0):
+            The shift value for the timestep schedule.
+    """
+
+    _compatibles = []
+    order = 1
+
+    @register_to_config
+    def __init__(
+        self,
+        num_train_timesteps: int = 1000,
+        shift: float = 1.0,
+        use_dynamic_shifting=False,
+    ):
+        timesteps = np.linspace(1, num_train_timesteps, num_train_timesteps, dtype=np.float32).copy()
+        timesteps = torch.from_numpy(timesteps).to(dtype=torch.float32)
+
+        sigmas = timesteps / num_train_timesteps
+        if not use_dynamic_shifting:
+            # when use_dynamic_shifting is True, we apply the timestep shifting on the fly based on the image resolution
+            sigmas = shift * sigmas / (1 + (shift - 1) * sigmas)
+
+        self.timesteps = sigmas * num_train_timesteps
+
+        self._step_index = None
+        self._begin_index = None
+
+        self.sigmas = sigmas.to("cpu")  # to avoid too much CPU/GPU communication
+        self.sigma_min = self.sigmas[-1].item()
+        self.sigma_max = self.sigmas[0].item()
+
+    @property
+    def step_index(self):
+        """
+        The index counter for current timestep. It will increase 1 after each scheduler step.
+        """
+        return self._step_index
+
+    @property
+    def begin_index(self):
+        """
+        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
+        """
+        return self._begin_index
+
+    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index
+    def set_begin_index(self, begin_index: int = 0):
+        """
+        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
+
+        Args:
+            begin_index (`int`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def scale_noise(
+        self,
+        sample: torch.FloatTensor,
+        timestep: Union[float, torch.FloatTensor],
+        noise: Optional[torch.FloatTensor] = None,
+    ) -> torch.FloatTensor:
+        """
+        Forward process in flow-matching
+
+        Args:
+            sample (`torch.FloatTensor`):
+                The input sample.
+            timestep (`int`, *optional*):
+                The current timestep in the diffusion chain.
+
+        Returns:
+            `torch.FloatTensor`:
+                A scaled input sample.
+        """
+        # Make sure sigmas and timesteps have the same device and dtype as original_samples
+        sigmas = self.sigmas.to(device=sample.device, dtype=sample.dtype)
+
+        if sample.device.type == "mps" and torch.is_floating_point(timestep):
+            # mps does not support float64
+            schedule_timesteps = self.timesteps.to(sample.device, dtype=torch.float32)
+            timestep = timestep.to(sample.device, dtype=torch.float32)
+        else:
+            schedule_timesteps = self.timesteps.to(sample.device)
+            timestep = timestep.to(sample.device)
+
+        # self.begin_index is None when scheduler is used for training, or pipeline does not implement set_begin_index
+        if self.begin_index is None:
+            step_indices = [self.index_for_timestep(t, schedule_timesteps) for t in timestep]
+        elif self.step_index is not None:
+            # add_noise is called after first denoising step (for inpainting)
+            step_indices = [self.step_index] * timestep.shape[0]
+        else:
+            # add noise is called before first denoising step to create initial latent(img2img)
+            step_indices = [self.begin_index] * timestep.shape[0]
+
+        sigma = sigmas[step_indices].flatten()
+        while len(sigma.shape) < len(sample.shape):
+            sigma = sigma.unsqueeze(-1)
+
+        sample = sigma * noise + (1.0 - sigma) * sample
+
+        return sample
+
+    def _sigma_to_t(self, sigma):
+        return sigma * self.config.num_train_timesteps
+
+    def time_shift(self, mu: float, sigma: float, t: torch.Tensor):
+        return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma)
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int = None,
+        device: Union[str, torch.device] = None,
+        sigmas: Optional[List[float]] = None,
+        mu: Optional[float] = None,
+    ):
+        """
+        Sets the discrete timesteps used for the diffusion chain (to be run before inference).
+
+        Args:
+            num_inference_steps (`int`):
+                The number of diffusion steps used when generating samples with a pre-trained model.
+            device (`str` or `torch.device`, *optional*):
+                The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
+        """
+
+        if self.config.use_dynamic_shifting and mu is None:
+            raise ValueError(" you have a pass a value for `mu` when `use_dynamic_shifting` is set to be `True`")
+
+        if sigmas is None:
+            self.num_inference_steps = num_inference_steps
+            timesteps = np.linspace(
+                self._sigma_to_t(self.sigma_max), self._sigma_to_t(self.sigma_min), num_inference_steps
+            )
+
+            sigmas = timesteps / self.config.num_train_timesteps
+
+        if self.config.use_dynamic_shifting:
+            sigmas = self.time_shift(mu, 1.0, sigmas)
+        else:
+            sigmas = self.config.shift * sigmas / (1 + (self.config.shift - 1) * sigmas)
+
+        sigmas = torch.from_numpy(sigmas).to(dtype=torch.float32, device=device)
+        timesteps = sigmas * self.config.num_train_timesteps
+
+        self.timesteps = timesteps.to(device=device)
+        self.sigmas = torch.cat([sigmas, torch.ones(1, device=sigmas.device)])
+
+        self._step_index = None
+        self._begin_index = None
+
+    def index_for_timestep(self, timestep, schedule_timesteps=None):
+        if schedule_timesteps is None:
+            schedule_timesteps = self.timesteps
+
+        indices = (schedule_timesteps == timestep).nonzero()
+
+        # The sigma index that is taken for the **very** first `step`
+        # is always the second index (or the last index if there is only 1)
+        # This way we can ensure we don't accidentally skip a sigma in
+        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
+        pos = 1 if len(indices) > 1 else 0
+
+        return indices[pos].item()
+
+    def _init_step_index(self, timestep):
+        if self.begin_index is None:
+            if isinstance(timestep, torch.Tensor):
+                timestep = timestep.to(self.timesteps.device)
+            self._step_index = self.index_for_timestep(timestep)
+        else:
+            self._step_index = self._begin_index
+
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: Union[float, torch.FloatTensor],
+        sample: torch.FloatTensor,
+        s_churn: float = 0.0,
+        s_tmin: float = 0.0,
+        s_tmax: float = float("inf"),
+        s_noise: float = 1.0,
+        generator: Optional[torch.Generator] = None,
+        return_dict: bool = True,
+    ) -> Union[FlowMatchEulerDiscreteSchedulerOutput, Tuple]:
+        """
+        Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+        process from the learned model outputs (most often the predicted noise).
+
+        Args:
+            model_output (`torch.FloatTensor`):
+                The direct output from learned diffusion model.
+            timestep (`float`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.FloatTensor`):
+                A current instance of a sample created by the diffusion process.
+            s_churn (`float`):
+            s_tmin  (`float`):
+            s_tmax  (`float`):
+            s_noise (`float`, defaults to 1.0):
+                Scaling factor for noise added to the sample.
+            generator (`torch.Generator`, *optional*):
+                A random number generator.
+            return_dict (`bool`):
+                Whether or not to return a [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or
+                tuple.
+
+        Returns:
+            [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or `tuple`:
+                If return_dict is `True`, [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] is
+                returned, otherwise a tuple is returned where the first element is the sample tensor.
+        """
+
+        if (
+            isinstance(timestep, int)
+            or isinstance(timestep, torch.IntTensor)
+            or isinstance(timestep, torch.LongTensor)
+        ):
+            raise ValueError(
+                (
+                    "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                    " `EulerDiscreteScheduler.step()` is not supported. Make sure to pass"
+                    " one of the `scheduler.timesteps` as a timestep."
+                ),
+            )
+
+        if self.step_index is None:
+            self._init_step_index(timestep)
+
+        # Upcast to avoid precision issues when computing prev_sample
+        sample = sample.to(torch.float32)
+
+        sigma = self.sigmas[self.step_index]
+        sigma_next = self.sigmas[self.step_index + 1]
+
+        prev_sample = sample + (sigma_next - sigma) * model_output
+
+        # Cast sample back to model compatible dtype
+        prev_sample = prev_sample.to(model_output.dtype)
+
+        # upon completion increase step index by one
+        self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return FlowMatchEulerDiscreteSchedulerOutput(prev_sample=prev_sample)
+
+    def __len__(self):
+        return self.config.num_train_timesteps
+
+
+@dataclass
+class ConsistencyFlowMatchEulerDiscreteSchedulerOutput(BaseOutput):
+    prev_sample: torch.FloatTensor
+    pred_original_sample: torch.FloatTensor
+
+
+class ConsistencyFlowMatchEulerDiscreteScheduler(SchedulerMixin, ConfigMixin):
+    _compatibles = []
+    order = 1
+
+    @register_to_config
+    def __init__(
+        self,
+        num_train_timesteps: int = 1000,
+        pcm_timesteps: int = 50,
+    ):
+        sigmas = np.linspace(0, 1, num_train_timesteps)
+        step_ratio = num_train_timesteps // pcm_timesteps
+
+        euler_timesteps = (np.arange(1, pcm_timesteps) * step_ratio).round().astype(np.int64) - 1
+        euler_timesteps = np.asarray([0] + euler_timesteps.tolist())
+
+        self.euler_timesteps = euler_timesteps
+        self.sigmas = sigmas[self.euler_timesteps]
+        self.sigmas = torch.from_numpy((self.sigmas.copy())).to(dtype=torch.float32)
+        self.timesteps = self.sigmas * num_train_timesteps
+        self._step_index = None
+        self._begin_index = None
+        self.sigmas = self.sigmas.to("cpu")  # to avoid too much CPU/GPU communication
+
+    @property
+    def step_index(self):
+        """
+        The index counter for current timestep. It will increase 1 after each scheduler step.
+        """
+        return self._step_index
+
+    @property
+    def begin_index(self):
+        """
+        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
+        """
+        return self._begin_index
+
+    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index
+    def set_begin_index(self, begin_index: int = 0):
+        """
+        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
+
+        Args:
+            begin_index (`int`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def _sigma_to_t(self, sigma):
+        return sigma * self.config.num_train_timesteps
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int = None,
+        device: Union[str, torch.device] = None,
+        sigmas: Optional[List[float]] = None,
+    ):
+        """
+        Sets the discrete timesteps used for the diffusion chain (to be run before inference).
+
+        Args:
+            num_inference_steps (`int`):
+                The number of diffusion steps used when generating samples with a pre-trained model.
+            device (`str` or `torch.device`, *optional*):
+                The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
+        """
+        self.num_inference_steps = num_inference_steps if num_inference_steps is not None else len(sigmas)
+        inference_indices = np.linspace(
+            0, self.config.pcm_timesteps, num=self.num_inference_steps, endpoint=False
+        )
+        inference_indices = np.floor(inference_indices).astype(np.int64)
+        inference_indices = torch.from_numpy(inference_indices).long()
+
+        self.sigmas_ = self.sigmas[inference_indices]
+        timesteps = self.sigmas_ * self.config.num_train_timesteps
+        self.timesteps = timesteps.to(device=device)
+        self.sigmas_ = torch.cat(
+            [self.sigmas_, torch.ones(1, device=self.sigmas_.device)]
+        )
+
+        self._step_index = None
+        self._begin_index = None
+
+    def index_for_timestep(self, timestep, schedule_timesteps=None):
+        if schedule_timesteps is None:
+            schedule_timesteps = self.timesteps
+
+        indices = (schedule_timesteps == timestep).nonzero()
+
+        # The sigma index that is taken for the **very** first `step`
+        # is always the second index (or the last index if there is only 1)
+        # This way we can ensure we don't accidentally skip a sigma in
+        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
+        pos = 1 if len(indices) > 1 else 0
+
+        return indices[pos].item()
+
+    def _init_step_index(self, timestep):
+        if self.begin_index is None:
+            if isinstance(timestep, torch.Tensor):
+                timestep = timestep.to(self.timesteps.device)
+            self._step_index = self.index_for_timestep(timestep)
+        else:
+            self._step_index = self._begin_index
+
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: Union[float, torch.FloatTensor],
+        sample: torch.FloatTensor,
+        generator: Optional[torch.Generator] = None,
+        return_dict: bool = True,
+    ) -> Union[ConsistencyFlowMatchEulerDiscreteSchedulerOutput, Tuple]:
+        if (
+            isinstance(timestep, int)
+            or isinstance(timestep, torch.IntTensor)
+            or isinstance(timestep, torch.LongTensor)
+        ):
+            raise ValueError(
+                (
+                    "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                    " `EulerDiscreteScheduler.step()` is not supported. Make sure to pass"
+                    " one of the `scheduler.timesteps` as a timestep."
+                ),
+            )
+
+        if self.step_index is None:
+            self._init_step_index(timestep)
+
+        sample = sample.to(torch.float32)
+
+        sigma = self.sigmas_[self.step_index]
+        sigma_next = self.sigmas_[self.step_index + 1]
+
+        prev_sample = sample + (sigma_next - sigma) * model_output
+        prev_sample = prev_sample.to(model_output.dtype)
+
+        pred_original_sample = sample + (1.0 - sigma) * model_output
+        pred_original_sample = pred_original_sample.to(model_output.dtype)
+
+        self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return ConsistencyFlowMatchEulerDiscreteSchedulerOutput(prev_sample=prev_sample,
+                                                                pred_original_sample=pred_original_sample)
+
+    def __len__(self):
+        return self.config.num_train_timesteps

OVOW/third_party/Motion324/scripts/hy3dgen/shapegen/utils.py

@@ -0,0 +1,126 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+import logging
+import os
+from functools import wraps
+
+import torch
+
+
+def get_logger(name):
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    return logger
+
+
+logger = get_logger('hy3dgen.shapgen')
+
+
+class synchronize_timer:
+    """ Synchronized timer to count the inference time of `nn.Module.forward`.
+
+        Supports both context manager and decorator usage.
+
+        Example as context manager:
+        ```python
+        with synchronize_timer('name') as t:
+            run()
+        ```
+
+        Example as decorator:
+        ```python
+        @synchronize_timer('Export to trimesh')
+        def export_to_trimesh(mesh_output):
+            pass
+        ```
+    """
+
+    def __init__(self, name=None):
+        self.name = name
+
+    def __enter__(self):
+        """Context manager entry: start timing."""
+        if os.environ.get('HY3DGEN_DEBUG', '0') == '1':
+            self.start = torch.cuda.Event(enable_timing=True)
+            self.end = torch.cuda.Event(enable_timing=True)
+            self.start.record()
+            return lambda: self.time
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        """Context manager exit: stop timing and log results."""
+        if os.environ.get('HY3DGEN_DEBUG', '0') == '1':
+            self.end.record()
+            torch.cuda.synchronize()
+            self.time = self.start.elapsed_time(self.end)
+            if self.name is not None:
+                logger.info(f'{self.name} takes {self.time} ms')
+
+    def __call__(self, func):
+        """Decorator: wrap the function to time its execution."""
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            with self:
+                result = func(*args, **kwargs)
+            return result
+
+        return wrapper
+
+
+def smart_load_model(
+    model_path,
+    subfolder,
+    use_safetensors,
+    variant,
+):
+    original_model_path = model_path
+    # try local path
+    base_dir = os.environ.get('HY3DGEN_MODELS', '~/.cache/hy3dgen')
+    model_path = os.path.expanduser(os.path.join(base_dir, model_path, subfolder))
+    logger.info(f'Try to load model from local path: {model_path}')
+    if not os.path.exists(model_path):
+        logger.info('Model path not exists, try to download from huggingface')
+        try:
+            from huggingface_hub import snapshot_download
+            # Only download specified subdirectory
+            path = snapshot_download(
+                repo_id=original_model_path,
+                allow_patterns=[f"{subfolder}/*"],  # Key modification: pattern match subfolder
+            )
+            model_path = os.path.join(path, subfolder)  # Keep path concatenation logic unchanged
+        except ImportError:
+            logger.warning(
+                "You need to install HuggingFace Hub to load models from the hub."
+            )
+            raise RuntimeError(f"Model path {model_path} not found")
+        except Exception as e:
+            raise e
+
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"Model path {original_model_path} not found")
+
+    extension = 'ckpt' if not use_safetensors else 'safetensors'
+    variant = '' if variant is None else f'.{variant}'
+    ckpt_name = f'model{variant}.{extension}'
+    config_path = os.path.join(model_path, 'config.yaml')
+    ckpt_path = os.path.join(model_path, ckpt_name)
+    return config_path, ckpt_path

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/__init__.py

@@ -0,0 +1,16 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+
+from .pipelines import Hunyuan3DPaintPipeline, Hunyuan3DTexGenConfig

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/custom_rasterizer/__init__.py

@@ -0,0 +1,22 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+'''
+from .hierarchy import BuildHierarchy, BuildHierarchyWithColor
+from .io_obj import LoadObj, LoadObjWithTexture
+from .render import rasterize, interpolate
+'''
+from .io_glb import *
+from .io_obj import *
+from .render import *

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/custom_rasterizer/io_glb.py

@@ -0,0 +1,241 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+import base64
+import io
+import os
+
+import numpy as np
+from PIL import Image as PILImage
+from pygltflib import GLTF2
+from scipy.spatial.transform import Rotation as R
+
+
+# Function to extract buffer data
+def get_buffer_data(gltf, buffer_view):
+    buffer = gltf.buffers[buffer_view.buffer]
+    buffer_data = gltf.get_data_from_buffer_uri(buffer.uri)
+    byte_offset = buffer_view.byteOffset if buffer_view.byteOffset else 0
+    byte_length = buffer_view.byteLength
+    return buffer_data[byte_offset:byte_offset + byte_length]
+
+
+# Function to extract attribute data
+def get_attribute_data(gltf, accessor_index):
+    accessor = gltf.accessors[accessor_index]
+    buffer_view = gltf.bufferViews[accessor.bufferView]
+    buffer_data = get_buffer_data(gltf, buffer_view)
+
+    comptype = {5120: np.int8, 5121: np.uint8, 5122: np.int16, 5123: np.uint16, 5125: np.uint32, 5126: np.float32}
+    dtype = comptype[accessor.componentType]
+
+    t2n = {'SCALAR': 1, 'VEC2': 2, 'VEC3': 3, 'VEC4': 4, 'MAT2': 4, 'MAT3': 9, 'MAT4': 16}
+    num_components = t2n[accessor.type]
+
+    # Calculate the correct slice of data
+    byte_offset = accessor.byteOffset if accessor.byteOffset else 0
+    byte_stride = buffer_view.byteStride if buffer_view.byteStride else num_components * np.dtype(dtype).itemsize
+    count = accessor.count
+
+    # Extract the attribute data
+    attribute_data = np.zeros((count, num_components), dtype=dtype)
+    for i in range(count):
+        start = byte_offset + i * byte_stride
+        end = start + num_components * np.dtype(dtype).itemsize
+        attribute_data[i] = np.frombuffer(buffer_data[start:end], dtype=dtype)
+
+    return attribute_data
+
+
+# Function to extract image data
+def get_image_data(gltf, image, folder):
+    if image.uri:
+        if image.uri.startswith('data:'):
+            # Data URI
+            header, encoded = image.uri.split(',', 1)
+            data = base64.b64decode(encoded)
+        else:
+            # External file
+            fn = image.uri
+            if not os.path.isabs(fn):
+                fn = folder + '/' + fn
+            with open(fn, 'rb') as f:
+                data = f.read()
+    else:
+        buffer_view = gltf.bufferViews[image.bufferView]
+        data = get_buffer_data(gltf, buffer_view)
+    return data
+
+
+# Function to convert triangle strip to triangles
+def convert_triangle_strip_to_triangles(indices):
+    triangles = []
+    for i in range(len(indices) - 2):
+        if i % 2 == 0:
+            triangles.append([indices[i], indices[i + 1], indices[i + 2]])
+        else:
+            triangles.append([indices[i], indices[i + 2], indices[i + 1]])
+    return np.array(triangles).reshape(-1, 3)
+
+
+# Function to convert triangle fan to triangles
+def convert_triangle_fan_to_triangles(indices):
+    triangles = []
+    for i in range(1, len(indices) - 1):
+        triangles.append([indices[0], indices[i], indices[i + 1]])
+    return np.array(triangles).reshape(-1, 3)
+
+
+# Function to get the transformation matrix from a node
+def get_node_transform(node):
+    if node.matrix:
+        return np.array(node.matrix).reshape(4, 4).T
+    else:
+        T = np.eye(4)
+        if node.translation:
+            T[:3, 3] = node.translation
+        if node.rotation:
+            R_mat = R.from_quat(node.rotation).as_matrix()
+            T[:3, :3] = R_mat
+        if node.scale:
+            S = np.diag(node.scale + [1])
+            T = T @ S
+        return T
+
+
+def get_world_transform(gltf, node_index, parents, world_transforms):
+    if parents[node_index] == -2:
+        return world_transforms[node_index]
+
+    node = gltf.nodes[node_index]
+    if parents[node_index] == -1:
+        world_transforms[node_index] = get_node_transform(node)
+        parents[node_index] = -2
+        return world_transforms[node_index]
+
+    parent_index = parents[node_index]
+    parent_transform = get_world_transform(gltf, parent_index, parents, world_transforms)
+    world_transforms[node_index] = parent_transform @ get_node_transform(node)
+    parents[node_index] = -2
+    return world_transforms[node_index]
+
+
+def LoadGlb(path):
+    # Load the GLB file using pygltflib
+    gltf = GLTF2().load(path)
+
+    primitives = []
+    images = {}
+    # Iterate through the meshes in the GLB file
+
+    world_transforms = [np.identity(4) for i in range(len(gltf.nodes))]
+    parents = [-1 for i in range(len(gltf.nodes))]
+    for node_index, node in enumerate(gltf.nodes):
+        for idx in node.children:
+            parents[idx] = node_index
+    # for i in range(len(gltf.nodes)):
+    #    get_world_transform(gltf, i, parents, world_transform)
+
+    for node_index, node in enumerate(gltf.nodes):
+        if node.mesh is not None:
+            world_transform = get_world_transform(gltf, node_index, parents, world_transforms)
+            # Iterate through the primitives in the mesh
+            mesh = gltf.meshes[node.mesh]
+            for primitive in mesh.primitives:
+                # Access the attributes of the primitive
+                attributes = primitive.attributes.__dict__
+                mode = primitive.mode if primitive.mode is not None else 4  # Default to TRIANGLES
+                result = {}
+                if primitive.indices is not None:
+                    indices = get_attribute_data(gltf, primitive.indices)
+                    if mode == 4:  # TRIANGLES
+                        face_indices = indices.reshape(-1, 3)
+                    elif mode == 5:  # TRIANGLE_STRIP
+                        face_indices = convert_triangle_strip_to_triangles(indices)
+                    elif mode == 6:  # TRIANGLE_FAN
+                        face_indices = convert_triangle_fan_to_triangles(indices)
+                    else:
+                        continue
+                    result['F'] = face_indices
+
+                # Extract vertex positions
+                if 'POSITION' in attributes and attributes['POSITION'] is not None:
+                    positions = get_attribute_data(gltf, attributes['POSITION'])
+                    # Apply the world transformation to the positions
+                    positions_homogeneous = np.hstack([positions, np.ones((positions.shape[0], 1))])
+                    transformed_positions = (world_transform @ positions_homogeneous.T).T[:, :3]
+                    result['V'] = transformed_positions
+
+                # Extract vertex colors
+                if 'COLOR_0' in attributes and attributes['COLOR_0'] is not None:
+                    colors = get_attribute_data(gltf, attributes['COLOR_0'])
+                    if colors.shape[-1] > 3:
+                        colors = colors[..., :3]
+                    result['VC'] = colors
+
+                # Extract UVs
+                if 'TEXCOORD_0' in attributes and not attributes['TEXCOORD_0'] is None:
+                    uvs = get_attribute_data(gltf, attributes['TEXCOORD_0'])
+                    result['UV'] = uvs
+
+                if primitive.material is not None:
+                    material = gltf.materials[primitive.material]
+                    if (
+                        material.pbrMetallicRoughness is not None 
+                        and material.pbrMetallicRoughness.baseColorTexture is not None
+                    ):
+                        texture_index = material.pbrMetallicRoughness.baseColorTexture.index
+                        texture = gltf.textures[texture_index]
+                        image_index = texture.source
+                        if not image_index in images:
+                            image = gltf.images[image_index]
+                            image_data = get_image_data(gltf, image, os.path.dirname(path))
+                            pil_image = PILImage.open(io.BytesIO(image_data))
+                            if pil_image.mode != 'RGB':
+                                pil_image = pil_image.convert('RGB')
+                            images[image_index] = pil_image
+                        result['TEX'] = image_index
+                    elif material.emissiveTexture is not None:
+                        texture_index = material.emissiveTexture.index
+                        texture = gltf.textures[texture_index]
+                        image_index = texture.source
+                        if not image_index in images:
+                            image = gltf.images[image_index]
+                            image_data = get_image_data(gltf, image, os.path.dirname(path))
+                            pil_image = PILImage.open(io.BytesIO(image_data))
+                            if pil_image.mode != 'RGB':
+                                pil_image = pil_image.convert('RGB')
+                            images[image_index] = pil_image
+                        result['TEX'] = image_index
+                    else:
+                        if material.pbrMetallicRoughness is not None:
+                            base_color = material.pbrMetallicRoughness.baseColorFactor
+                        else:
+                            base_color = np.array([0.8, 0.8, 0.8], dtype=np.float32)
+                        result['MC'] = base_color
+
+                primitives.append(result)
+
+    return primitives, images
+
+
+def RotatePrimitives(primitives, transform):
+    for i in range(len(primitives)):
+        if 'V' in primitives[i]:
+            primitives[i]['V'] = primitives[i]['V'] @ transform.T
+
+
+if __name__ == '__main__':
+    path = 'data/test.glb'
+    LoadGlb(path)

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/custom_rasterizer/io_obj.py

@@ -0,0 +1,66 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+import cv2
+import numpy as np
+
+
+def LoadObj(fn):
+    lines = [l.strip() for l in open(fn)]
+    vertices = []
+    faces = []
+    for l in lines:
+        words = [w for w in l.split(' ') if w != '']
+        if len(words) == 0:
+            continue
+        if words[0] == 'v':
+            v = [float(words[i]) for i in range(1, 4)]
+            vertices.append(v)
+        elif words[0] == 'f':
+            f = [int(words[i]) - 1 for i in range(1, 4)]
+            faces.append(f)
+
+    return np.array(vertices).astype('float32'), np.array(faces).astype('int32')
+
+
+def LoadObjWithTexture(fn, tex_fn):
+    lines = [l.strip() for l in open(fn)]
+    vertices = []
+    vertex_textures = []
+    faces = []
+    face_textures = []
+    for l in lines:
+        words = [w for w in l.split(' ') if w != '']
+        if len(words) == 0:
+            continue
+        if words[0] == 'v':
+            v = [float(words[i]) for i in range(1, len(words))]
+            vertices.append(v)
+        elif words[0] == 'vt':
+            v = [float(words[i]) for i in range(1, len(words))]
+            vertex_textures.append(v)
+        elif words[0] == 'f':
+            f = []
+            ft = []
+            for i in range(1, len(words)):
+                t = words[i].split('/')
+                f.append(int(t[0]) - 1)
+                ft.append(int(t[1]) - 1)
+            for i in range(2, len(f)):
+                faces.append([f[0], f[i - 1], f[i]])
+                face_textures.append([ft[0], ft[i - 1], ft[i]])
+
+    tex_image = cv2.cvtColor(cv2.imread(tex_fn), cv2.COLOR_BGR2RGB)
+    return np.array(vertices).astype('float32'), np.array(vertex_textures).astype('float32'), np.array(faces).astype(
+        'int32'), np.array(face_textures).astype('int32'), tex_image

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/custom_rasterizer/render.py

@@ -0,0 +1,31 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.
+
+import custom_rasterizer_kernel
+import torch
+
+
+def rasterize(pos, tri, resolution, clamp_depth=torch.zeros(0), use_depth_prior=0):
+    assert (pos.device == tri.device)
+    findices, barycentric = custom_rasterizer_kernel.rasterize_image(pos[0], tri, clamp_depth, resolution[1],
+                                                                     resolution[0], 1e-6, use_depth_prior)
+    return findices, barycentric
+
+
+def interpolate(col, findices, barycentric, tri):
+    f = findices - 1 + (findices == 0)
+    vcol = col[0, tri.long()[f.long()]]
+    result = barycentric.view(*barycentric.shape, 1) * vcol
+    result = torch.sum(result, axis=-2)
+    return result.view(1, *result.shape)

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/lib/custom_rasterizer_kernel/__init__.py

@@ -0,0 +1,13 @@
+# Hunyuan 3D is licensed under the TENCENT HUNYUAN NON-COMMERCIAL LICENSE AGREEMENT
+# except for the third-party components listed below.
+# Hunyuan 3D does not impose any additional limitations beyond what is outlined
+# in the repsective licenses of these third-party components.
+# Users must comply with all terms and conditions of original licenses of these third-party
+# components and must ensure that the usage of the third party components adheres to
+# all relevant laws and regulations.
+
+# For avoidance of doubts, Hunyuan 3D means the large language models and
+# their software and algorithms, including trained model weights, parameters (including
+# optimizer states), machine-learning model code, inference-enabling code, training-enabling code,
+# fine-tuning enabling code and other elements of the foregoing made publicly available
+# by Tencent in accordance with TENCENT HUNYUAN COMMUNITY LICENSE AGREEMENT.

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/lib/custom_rasterizer_kernel/grid_neighbor.cpp

@@ -0,0 +1,574 @@
+#include "rasterizer.h"
+#include <fstream>
+
+inline int pos2key(float* p, int resolution) {
+    int x = (p[0] * 0.5 + 0.5) * resolution;
+    int y = (p[1] * 0.5 + 0.5) * resolution;
+    int z = (p[2] * 0.5 + 0.5) * resolution;
+    return (x * resolution + y) * resolution + z;
+}
+
+inline void key2pos(int key, int resolution, float* p) {
+    int x = key / resolution / resolution;
+    int y = key / resolution % resolution;
+    int z = key % resolution;
+    p[0] = ((x + 0.5) / resolution - 0.5) * 2;
+    p[1] = ((y + 0.5) / resolution - 0.5) * 2;
+    p[2] = ((z + 0.5) / resolution - 0.5) * 2;
+}
+
+inline void key2cornerpos(int key, int resolution, float* p) {
+    int x = key / resolution / resolution;
+    int y = key / resolution % resolution;
+    int z = key % resolution;
+    p[0] = ((x + 0.75) / resolution - 0.5) * 2;
+    p[1] = ((y + 0.25) / resolution - 0.5) * 2;
+    p[2] = ((z + 0.75) / resolution - 0.5) * 2;
+}
+
+inline float* pos_ptr(int l, int i, int j, torch::Tensor t) {
+    float* pdata = t.data_ptr<float>();
+    int height = t.size(1);
+    int width = t.size(2);
+    return &pdata[((l * height + i) * width + j) * 4];
+}
+
+struct Grid
+{
+    std::vector<int> seq2oddcorner;
+    std::vector<int> seq2evencorner;
+    std::vector<int> seq2grid;
+    std::vector<int> seq2normal;
+    std::vector<int> seq2neighbor;
+    std::unordered_map<int, int> grid2seq;
+    std::vector<int> downsample_seq;
+    int num_origin_seq;
+    int resolution;
+    int stride;
+};
+
+inline void pos_from_seq(Grid& grid, int seq, float* p) {
+    auto k = grid.seq2grid[seq];
+    key2pos(k, grid.resolution, p);
+}
+
+inline int fetch_seq(Grid& grid, int l, int i, int j, torch::Tensor pdata) {
+    float* p = pos_ptr(l, i, j, pdata);
+    if (p[3] == 0)
+        return -1;
+    auto key = pos2key(p, grid.resolution);
+    int seq = grid.grid2seq[key];
+    return seq;
+}
+
+inline int fetch_last_seq(Grid& grid, int i, int j, torch::Tensor pdata) {
+    int num_layers = pdata.size(0);
+    int l = 0;
+    int idx = fetch_seq(grid, l, i, j, pdata);
+    while (l < num_layers - 1) {
+        l += 1;
+        int new_idx = fetch_seq(grid, l, i, j, pdata);
+        if (new_idx == -1)
+            break;
+        idx = new_idx;
+    }
+    return idx;
+}
+
+inline int fetch_nearest_seq(Grid& grid, int i, int j, int dim, float d, torch::Tensor pdata) {
+    float p[3];
+    float max_dist = 1e10;
+    int best_idx = -1;
+    int num_layers = pdata.size(0);
+    for (int l = 0; l < num_layers; ++l) {
+        int idx = fetch_seq(grid, l, i, j, pdata);
+        if (idx == -1)
+            break;
+        pos_from_seq(grid, idx, p);
+        float dist = std::abs(d - p[(dim + 2) % 3]);
+        if (dist < max_dist) {
+            max_dist = dist;
+            best_idx = idx;
+        }
+    }
+    return best_idx;
+}
+
+inline int fetch_nearest_seq_layer(Grid& grid, int i, int j, int dim, float d, torch::Tensor pdata) {
+    float p[3];
+    float max_dist = 1e10;
+    int best_layer = -1;
+    int num_layers = pdata.size(0);
+    for (int l = 0; l < num_layers; ++l) {
+        int idx = fetch_seq(grid, l, i, j, pdata);
+        if (idx == -1)
+            break;
+        pos_from_seq(grid, idx, p);
+        float dist = std::abs(d - p[(dim + 2) % 3]);
+        if (dist < max_dist) {
+            max_dist = dist;
+            best_layer = l;
+        }
+    }
+    return best_layer;
+}
+
+void FetchNeighbor(Grid& grid, int seq, float* pos, int dim, int boundary_info, std::vector<torch::Tensor>& view_layer_positions,
+    int* output_indices)
+{
+    auto t = view_layer_positions[dim];
+    int height = t.size(1);
+    int width = t.size(2);
+    int top = 0;
+    int ci = 0;
+    int cj = 0;
+    if (dim == 0) {
+        ci = (pos[1]/2+0.5)*height;
+        cj = (pos[0]/2+0.5)*width;
+    }
+    else if (dim == 1) {
+        ci = (pos[1]/2+0.5)*height;
+        cj = (pos[2]/2+0.5)*width;
+    }
+    else {
+        ci = (-pos[2]/2+0.5)*height;
+        cj = (pos[0]/2+0.5)*width;
+    }
+    int stride = grid.stride;
+    for (int ni = ci + stride; ni >= ci - stride; ni -= stride) {
+        for (int nj = cj - stride; nj <= cj + stride; nj += stride) {
+            int idx = -1;
+            if (ni == ci && nj == cj)
+                idx = seq;
+            else if (!(ni < 0 || ni >= height || nj < 0 || nj >= width)) {
+                if (boundary_info == -1)
+                    idx = fetch_seq(grid, 0, ni, nj, t);
+                else if (boundary_info == 1)
+                    idx = fetch_last_seq(grid, ni, nj, t);
+                else
+                    idx = fetch_nearest_seq(grid, ni, nj, dim, pos[(dim + 2) % 3], t);
+            }
+            output_indices[top] = idx;
+            top += 1;
+        }
+    }
+}
+
+void DownsampleGrid(Grid& src, Grid& tar)
+{
+    src.downsample_seq.resize(src.seq2grid.size(), -1);
+    tar.resolution = src.resolution / 2;
+    tar.stride = src.stride * 2;
+    float pos[3];
+    std::vector<int> seq2normal_count;
+    for (int i = 0; i < src.seq2grid.size(); ++i) {
+        key2pos(src.seq2grid[i], src.resolution, pos);
+        int k = pos2key(pos, tar.resolution);
+        int s = seq2normal_count.size();
+        if (!tar.grid2seq.count(k)) {
+            tar.grid2seq[k] = tar.seq2grid.size();
+            tar.seq2grid.emplace_back(k);
+            seq2normal_count.emplace_back(0);
+            seq2normal_count.emplace_back(0);
+            seq2normal_count.emplace_back(0);
+            //tar.seq2normal.emplace_back(src.seq2normal[i]);
+        } else {
+            s = tar.grid2seq[k] * 3;
+        }
+        seq2normal_count[s + src.seq2normal[i]] += 1;
+        src.downsample_seq[i] = tar.grid2seq[k];
+    }
+    tar.seq2normal.resize(seq2normal_count.size() / 3);
+    for (int i = 0; i < seq2normal_count.size(); i += 3) {
+        int t = 0;
+        for (int j = 1; j < 3; ++j) {
+            if (seq2normal_count[i + j] > seq2normal_count[i + t])
+                t = j;
+        }
+        tar.seq2normal[i / 3] = t;
+    }
+}
+
+void NeighborGrid(Grid& grid, std::vector<torch::Tensor> view_layer_positions, int v)
+{
+    grid.seq2evencorner.resize(grid.seq2grid.size(), 0);
+    grid.seq2oddcorner.resize(grid.seq2grid.size(), 0);
+    std::unordered_set<int> visited_seq;
+    for (int vd = 0; vd < 3; ++vd) {
+        auto t = view_layer_positions[vd];
+        auto t0 = view_layer_positions[v];
+        int height = t.size(1);
+        int width = t.size(2);
+        int num_layers = t.size(0);
+        int num_view_layers = t0.size(0);
+        for (int i = 0; i < height; ++i) {
+            for (int j = 0; j < width; ++j) {
+                for (int l = 0; l < num_layers; ++l) {
+                    int seq = fetch_seq(grid, l, i, j, t);
+                    if (seq == -1)
+                        break;
+                    int dim = grid.seq2normal[seq];
+                    if (dim != v)
+                        continue;
+
+                    float pos[3];
+                    pos_from_seq(grid, seq, pos);
+
+                    int ci = 0;
+                    int cj = 0;
+                    if (dim == 0) {
+                        ci = (pos[1]/2+0.5)*height;
+                        cj = (pos[0]/2+0.5)*width;
+                    }
+                    else if (dim == 1) {
+                        ci = (pos[1]/2+0.5)*height;
+                        cj = (pos[2]/2+0.5)*width;
+                    }
+                    else {
+                        ci = (-pos[2]/2+0.5)*height;
+                        cj = (pos[0]/2+0.5)*width;
+                    }
+
+                    if ((ci % (grid.stride * 2) < grid.stride) && (cj % (grid.stride * 2) >= grid.stride))
+                        grid.seq2evencorner[seq] = 1;
+
+                    if ((ci % (grid.stride * 2) >= grid.stride) && (cj % (grid.stride * 2) < grid.stride))
+                        grid.seq2oddcorner[seq] = 1;
+
+                    bool is_boundary = false;
+                    if (vd == v) {
+                        if (l == 0 || l == num_layers - 1)
+                            is_boundary = true;
+                        else {
+                            int seq_new = fetch_seq(grid, l + 1, i, j, t);
+                            if (seq_new == -1)
+                                is_boundary = true;
+                        }
+                    }
+                    int boundary_info = 0;
+                    if (is_boundary && (l == 0))
+                        boundary_info = -1;
+                    else if (is_boundary)
+                        boundary_info = 1;
+                    if (visited_seq.count(seq))
+                        continue;
+                    visited_seq.insert(seq);
+
+                    FetchNeighbor(grid, seq, pos, dim, boundary_info, view_layer_positions, &grid.seq2neighbor[seq * 9]);
+                }
+            }
+        }
+    }
+}
+
+void PadGrid(Grid& src, Grid& tar, std::vector<torch::Tensor>& view_layer_positions) {
+    auto& downsample_seq = src.downsample_seq;
+    auto& seq2evencorner = src.seq2evencorner;
+    auto& seq2oddcorner = src.seq2oddcorner;
+    int indices[9];
+    std::vector<int> mapped_even_corners(tar.seq2grid.size(), 0);
+    std::vector<int> mapped_odd_corners(tar.seq2grid.size(), 0);
+    for (int i = 0; i < downsample_seq.size(); ++i) {
+        if (seq2evencorner[i] > 0) {
+            mapped_even_corners[downsample_seq[i]] = 1;
+        }
+        if (seq2oddcorner[i] > 0) {
+            mapped_odd_corners[downsample_seq[i]] = 1;
+        }
+    }
+    auto& tar_seq2normal = tar.seq2normal;
+    auto& tar_seq2grid = tar.seq2grid;
+    for (int i = 0; i < tar_seq2grid.size(); ++i) {
+        if (mapped_even_corners[i] == 1 && mapped_odd_corners[i] == 1)
+            continue;
+        auto k = tar_seq2grid[i];
+        float p[3];
+        key2cornerpos(k, tar.resolution, p);
+
+        int src_key = pos2key(p, src.resolution);
+        if (!src.grid2seq.count(src_key)) {
+            int seq = src.seq2grid.size();
+            src.grid2seq[src_key] = seq;
+            src.seq2evencorner.emplace_back((mapped_even_corners[i] == 0));
+            src.seq2oddcorner.emplace_back((mapped_odd_corners[i] == 0));
+            src.seq2grid.emplace_back(src_key);
+            src.seq2normal.emplace_back(tar_seq2normal[i]);
+            FetchNeighbor(src, seq, p, tar_seq2normal[i], 0, view_layer_positions, indices);
+            for (int j = 0; j < 9; ++j) {
+                src.seq2neighbor.emplace_back(indices[j]);
+            }
+            src.downsample_seq.emplace_back(i);
+        } else {
+            int seq = src.grid2seq[src_key];
+            if (mapped_even_corners[i] == 0)
+                src.seq2evencorner[seq] = 1;
+            if (mapped_odd_corners[i] == 0)
+                src.seq2oddcorner[seq] = 1;
+        }
+    }
+}
+
+std::vector<std::vector<torch::Tensor>> build_hierarchy(std::vector<torch::Tensor> view_layer_positions,
+    std::vector<torch::Tensor> view_layer_normals, int num_level, int resolution)
+{
+    if (view_layer_positions.size() != 3 || num_level < 1) {
+        printf("Alert! We require 3 layers and at least 1 level! (%d %d)\n", view_layer_positions.size(), num_level);
+        return {{},{},{},{}};
+    }
+
+    std::vector<Grid> grids;
+    grids.resize(num_level);
+
+    std::vector<float> seq2pos;
+    auto& seq2grid = grids[0].seq2grid;
+    auto& seq2normal = grids[0].seq2normal;
+    auto& grid2seq = grids[0].grid2seq;
+    grids[0].resolution = resolution;
+    grids[0].stride = 1;
+
+    auto int64_options = torch::TensorOptions().dtype(torch::kInt64).requires_grad(false);
+    auto float_options = torch::TensorOptions().dtype(torch::kFloat32).requires_grad(false);
+
+    for (int v = 0; v < 3; ++v) {
+        int num_layers = view_layer_positions[v].size(0);
+        int height = view_layer_positions[v].size(1);
+        int width = view_layer_positions[v].size(2);
+        float* data = view_layer_positions[v].data_ptr<float>();
+        float* data_normal = view_layer_normals[v].data_ptr<float>();
+        for (int l = 0; l < num_layers; ++l) {
+            for (int i = 0; i < height; ++i) {
+                for (int j = 0; j < width; ++j) {
+                    float* p = &data[(i * width + j) * 4];
+                    float* n = &data_normal[(i * width + j) * 3];
+                    if (p[3] == 0)
+                        continue;
+                    auto k = pos2key(p, resolution);
+                    if (!grid2seq.count(k)) {
+                        int dim = 0;
+                        for (int d = 0; d < 3; ++d) {
+                            if (std::abs(n[d]) > std::abs(n[dim]))
+                                dim = d;
+                        }
+                        dim = (dim + 1) % 3;
+                        grid2seq[k] = seq2grid.size();
+                        seq2grid.emplace_back(k);
+                        seq2pos.push_back(p[0]);
+                        seq2pos.push_back(p[1]);
+                        seq2pos.push_back(p[2]);
+                        seq2normal.emplace_back(dim);
+                    }
+                }
+            }
+            data += (height * width * 4);
+            data_normal += (height * width * 3);
+        }
+    }
+
+    for (int i = 0; i < num_level - 1; ++i) {
+        DownsampleGrid(grids[i], grids[i + 1]);
+    }
+
+    for (int l = 0; l < num_level; ++l) {
+        grids[l].seq2neighbor.resize(grids[l].seq2grid.size() * 9, -1);
+        grids[l].num_origin_seq = grids[l].seq2grid.size();
+        for (int d = 0; d < 3; ++d) {
+            NeighborGrid(grids[l], view_layer_positions, d);
+        }
+    }
+
+    for (int i = num_level - 2; i >= 0; --i) {
+        PadGrid(grids[i], grids[i + 1], view_layer_positions);
+    }
+    for (int i = grids[0].num_origin_seq; i < grids[0].seq2grid.size(); ++i) {
+        int k = grids[0].seq2grid[i];
+        float p[3];
+        key2pos(k, grids[0].resolution, p);
+        seq2pos.push_back(p[0]);
+        seq2pos.push_back(p[1]);
+        seq2pos.push_back(p[2]);
+    }
+
+    std::vector<torch::Tensor> texture_positions(2);
+    std::vector<torch::Tensor> grid_neighbors(grids.size());
+    std::vector<torch::Tensor> grid_downsamples(grids.size() - 1);
+    std::vector<torch::Tensor> grid_evencorners(grids.size());
+    std::vector<torch::Tensor> grid_oddcorners(grids.size());
+
+    texture_positions[0] = torch::zeros({static_cast<int64_t>(seq2pos.size() / 3), static_cast<int64_t>(3)}, float_options);
+    texture_positions[1] = torch::zeros({static_cast<int64_t>(seq2pos.size() / 3)}, float_options);
+    float* positions_out_ptr = texture_positions[0].data_ptr<float>();
+    memcpy(positions_out_ptr, seq2pos.data(), sizeof(float) * seq2pos.size());
+    positions_out_ptr = texture_positions[1].data_ptr<float>();
+    for (int i = 0; i < grids[0].seq2grid.size(); ++i) {
+        positions_out_ptr[i] = (i < grids[0].num_origin_seq);
+    }
+
+    for (int i = 0; i < grids.size(); ++i) {
+        grid_neighbors[i] = torch::zeros({static_cast<int64_t>(grids[i].seq2grid.size()), static_cast<int64_t>(9)}, int64_options);
+        int64_t* nptr = grid_neighbors[i].data_ptr<int64_t>();
+        for (int j = 0; j < grids[i].seq2neighbor.size(); ++j) {
+            nptr[j] = grids[i].seq2neighbor[j];
+        }
+
+        grid_evencorners[i] = torch::zeros({static_cast<int64_t>(grids[i].seq2evencorner.size())}, int64_options);
+        grid_oddcorners[i] = torch::zeros({static_cast<int64_t>(grids[i].seq2oddcorner.size())}, int64_options);
+        int64_t* dptr = grid_evencorners[i].data_ptr<int64_t>();
+        for (int j = 0; j < grids[i].seq2evencorner.size(); ++j) {
+            dptr[j] = grids[i].seq2evencorner[j];
+        }
+        dptr = grid_oddcorners[i].data_ptr<int64_t>();
+        for (int j = 0; j < grids[i].seq2oddcorner.size(); ++j) {
+            dptr[j] = grids[i].seq2oddcorner[j];
+        }            
+        if (i + 1 < grids.size()) {
+            grid_downsamples[i] = torch::zeros({static_cast<int64_t>(grids[i].downsample_seq.size())}, int64_options);
+            int64_t* dptr = grid_downsamples[i].data_ptr<int64_t>();
+            for (int j = 0; j < grids[i].downsample_seq.size(); ++j) {
+                dptr[j] = grids[i].downsample_seq[j];
+            }
+        }
+
+    }
+    return {texture_positions, grid_neighbors, grid_downsamples, grid_evencorners, grid_oddcorners};
+}
+
+std::vector<std::vector<torch::Tensor>> build_hierarchy_with_feat(
+    std::vector<torch::Tensor> view_layer_positions,
+    std::vector<torch::Tensor> view_layer_normals,
+    std::vector<torch::Tensor> view_layer_feats,
+    int num_level, int resolution)
+{
+    if (view_layer_positions.size() != 3 || num_level < 1) {
+        printf("Alert! We require 3 layers and at least 1 level! (%d %d)\n", view_layer_positions.size(), num_level);
+        return {{},{},{},{}};
+    }
+
+    std::vector<Grid> grids;
+    grids.resize(num_level);
+
+    std::vector<float> seq2pos;
+    std::vector<float> seq2feat;
+    auto& seq2grid = grids[0].seq2grid;
+    auto& seq2normal = grids[0].seq2normal;
+    auto& grid2seq = grids[0].grid2seq;
+    grids[0].resolution = resolution;
+    grids[0].stride = 1;
+
+    auto int64_options = torch::TensorOptions().dtype(torch::kInt64).requires_grad(false);
+    auto float_options = torch::TensorOptions().dtype(torch::kFloat32).requires_grad(false);
+
+    int feat_channel = 3;
+    for (int v = 0; v < 3; ++v) {
+        int num_layers = view_layer_positions[v].size(0);
+        int height = view_layer_positions[v].size(1);
+        int width = view_layer_positions[v].size(2);
+        float* data = view_layer_positions[v].data_ptr<float>();
+        float* data_normal = view_layer_normals[v].data_ptr<float>();
+        float* data_feat = view_layer_feats[v].data_ptr<float>();
+        feat_channel = view_layer_feats[v].size(3);
+        for (int l = 0; l < num_layers; ++l) {
+            for (int i = 0; i < height; ++i) {
+                for (int j = 0; j < width; ++j) {
+                    float* p = &data[(i * width + j) * 4];
+                    float* n = &data_normal[(i * width + j) * 3];
+                    float* f = &data_feat[(i * width + j) * feat_channel];
+                    if (p[3] == 0)
+                        continue;
+                    auto k = pos2key(p, resolution);
+                    if (!grid2seq.count(k)) {
+                        int dim = 0;
+                        for (int d = 0; d < 3; ++d) {
+                            if (std::abs(n[d]) > std::abs(n[dim]))
+                                dim = d;
+                        }
+                        dim = (dim + 1) % 3;
+                        grid2seq[k] = seq2grid.size();
+                        seq2grid.emplace_back(k);
+                        seq2pos.push_back(p[0]);
+                        seq2pos.push_back(p[1]);
+                        seq2pos.push_back(p[2]);
+                        for (int c = 0; c < feat_channel; ++c) {
+                            seq2feat.emplace_back(f[c]);
+                        }
+                        seq2normal.emplace_back(dim);
+                    }
+                }
+            }
+            data += (height * width * 4);
+            data_normal += (height * width * 3);
+            data_feat += (height * width * feat_channel);
+        }
+    }
+
+    for (int i = 0; i < num_level - 1; ++i) {
+        DownsampleGrid(grids[i], grids[i + 1]);
+    }
+
+    for (int l = 0; l < num_level; ++l) {
+        grids[l].seq2neighbor.resize(grids[l].seq2grid.size() * 9, -1);
+        grids[l].num_origin_seq = grids[l].seq2grid.size();
+        for (int d = 0; d < 3; ++d) {
+            NeighborGrid(grids[l], view_layer_positions, d);
+        }
+    }
+
+    for (int i = num_level - 2; i >= 0; --i) {
+        PadGrid(grids[i], grids[i + 1], view_layer_positions);
+    }
+    for (int i = grids[0].num_origin_seq; i < grids[0].seq2grid.size(); ++i) {
+        int k = grids[0].seq2grid[i];
+        float p[3];
+        key2pos(k, grids[0].resolution, p);
+        seq2pos.push_back(p[0]);
+        seq2pos.push_back(p[1]);
+        seq2pos.push_back(p[2]);
+        for (int c = 0; c < feat_channel; ++c) {
+            seq2feat.emplace_back(0.5);
+        }
+    }
+
+    std::vector<torch::Tensor> texture_positions(2);
+    std::vector<torch::Tensor> texture_feats(1);
+    std::vector<torch::Tensor> grid_neighbors(grids.size());
+    std::vector<torch::Tensor> grid_downsamples(grids.size() - 1);
+    std::vector<torch::Tensor> grid_evencorners(grids.size());
+    std::vector<torch::Tensor> grid_oddcorners(grids.size());
+
+    texture_positions[0] = torch::zeros({static_cast<int64_t>(seq2pos.size() / 3), static_cast<int64_t>(3)}, float_options);
+    texture_positions[1] = torch::zeros({static_cast<int64_t>(seq2pos.size() / 3)}, float_options);
+    texture_feats[0] = torch::zeros({static_cast<int64_t>(seq2feat.size() / feat_channel), static_cast<int64_t>(feat_channel)}, float_options);
+    float* positions_out_ptr = texture_positions[0].data_ptr<float>();
+    memcpy(positions_out_ptr, seq2pos.data(), sizeof(float) * seq2pos.size());
+    positions_out_ptr = texture_positions[1].data_ptr<float>();
+    for (int i = 0; i < grids[0].seq2grid.size(); ++i) {
+        positions_out_ptr[i] = (i < grids[0].num_origin_seq);
+    }
+    float* feats_out_ptr = texture_feats[0].data_ptr<float>();
+    memcpy(feats_out_ptr, seq2feat.data(), sizeof(float) * seq2feat.size());
+
+    for (int i = 0; i < grids.size(); ++i) {
+        grid_neighbors[i] = torch::zeros({static_cast<int64_t>(grids[i].seq2grid.size()), static_cast<int64_t>(9)}, int64_options);
+        int64_t* nptr = grid_neighbors[i].data_ptr<int64_t>();
+        for (int j = 0; j < grids[i].seq2neighbor.size(); ++j) {
+            nptr[j] = grids[i].seq2neighbor[j];
+        }
+        grid_evencorners[i] = torch::zeros({static_cast<int64_t>(grids[i].seq2evencorner.size())}, int64_options);
+        grid_oddcorners[i] = torch::zeros({static_cast<int64_t>(grids[i].seq2oddcorner.size())}, int64_options);
+        int64_t* dptr = grid_evencorners[i].data_ptr<int64_t>();
+        for (int j = 0; j < grids[i].seq2evencorner.size(); ++j) {
+            dptr[j] = grids[i].seq2evencorner[j];
+        }
+        dptr = grid_oddcorners[i].data_ptr<int64_t>();
+        for (int j = 0; j < grids[i].seq2oddcorner.size(); ++j) {
+            dptr[j] = grids[i].seq2oddcorner[j];
+        }
+        if (i + 1 < grids.size()) {
+            grid_downsamples[i] = torch::zeros({static_cast<int64_t>(grids[i].downsample_seq.size())}, int64_options);
+            int64_t* dptr = grid_downsamples[i].data_ptr<int64_t>();
+            for (int j = 0; j < grids[i].downsample_seq.size(); ++j) {
+                dptr[j] = grids[i].downsample_seq[j];
+            }
+        }
+    }
+    return {texture_positions, texture_feats, grid_neighbors, grid_downsamples, grid_evencorners, grid_oddcorners};
+}

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/lib/custom_rasterizer_kernel/rasterizer.cpp

@@ -0,0 +1,139 @@
+#include "rasterizer.h"
+
+void rasterizeTriangleCPU(int idx, float* vt0, float* vt1, float* vt2, int width, int height, INT64* zbuffer, float* d, float occlusion_truncation) {
+    float x_min = std::min(vt0[0], std::min(vt1[0],vt2[0]));
+    float x_max = std::max(vt0[0], std::max(vt1[0],vt2[0]));
+    float y_min = std::min(vt0[1], std::min(vt1[1],vt2[1]));
+    float y_max = std::max(vt0[1], std::max(vt1[1],vt2[1]));
+
+    for (int px = x_min; px < x_max + 1; ++px) {
+        if (px < 0 || px >= width)
+            continue;
+        for (int py = y_min; py < y_max + 1; ++py) {
+            if (py < 0 || py >= height)
+                continue;
+            float vt[2] = {px + 0.5, py + 0.5};
+            float baryCentricCoordinate[3];
+            calculateBarycentricCoordinate(vt0, vt1, vt2, vt, baryCentricCoordinate);
+            if (isBarycentricCoordInBounds(baryCentricCoordinate)) {
+                int pixel = py * width + px;
+                if (zbuffer == 0) {
+                    zbuffer[pixel] = (INT64)(idx + 1);
+                    continue;
+                }
+
+                float depth = baryCentricCoordinate[0] * vt0[2] + baryCentricCoordinate[1] * vt1[2] + baryCentricCoordinate[2] * vt2[2];
+                float depth_thres = 0;
+                if (d) {
+                    depth_thres = d[pixel] * 0.49999f + 0.5f + occlusion_truncation;
+                }
+                
+                int z_quantize = depth * (2<<17);
+                INT64 token = (INT64)z_quantize * MAXINT + (INT64)(idx + 1);
+                if (depth < depth_thres)
+                    continue;
+                zbuffer[pixel] = std::min(zbuffer[pixel], token);
+            }
+        }
+    }
+}
+
+void barycentricFromImgcoordCPU(float* V, int* F, int* findices, INT64* zbuffer, int width, int height, int num_vertices, int num_faces,
+    float* barycentric_map, int pix)
+{
+    INT64 f = zbuffer[pix] % MAXINT;
+    if (f == (MAXINT-1)) {
+        findices[pix] = 0;
+        barycentric_map[pix * 3] = 0;
+        barycentric_map[pix * 3 + 1] = 0;
+        barycentric_map[pix * 3 + 2] = 0;
+        return;
+    }
+    findices[pix] = f;
+    f -= 1;
+    float barycentric[3] = {0, 0, 0};
+    if (f >= 0) {
+        float vt[2] = {float(pix % width) + 0.5f, float(pix / width) + 0.5f};
+        float* vt0_ptr = V + (F[f * 3] * 4);
+        float* vt1_ptr = V + (F[f * 3 + 1] * 4);
+        float* vt2_ptr = V + (F[f * 3 + 2] * 4);
+
+        float vt0[2] = {(vt0_ptr[0] / vt0_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt0_ptr[1] / vt0_ptr[3]) * (height - 1) + 0.5f};
+        float vt1[2] = {(vt1_ptr[0] / vt1_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt1_ptr[1] / vt1_ptr[3]) * (height - 1) + 0.5f};
+        float vt2[2] = {(vt2_ptr[0] / vt2_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt2_ptr[1] / vt2_ptr[3]) * (height - 1) + 0.5f};
+
+        calculateBarycentricCoordinate(vt0, vt1, vt2, vt, barycentric);
+
+        barycentric[0] = barycentric[0] / vt0_ptr[3];
+        barycentric[1] = barycentric[1] / vt1_ptr[3];
+        barycentric[2] = barycentric[2] / vt2_ptr[3];
+        float w = 1.0f / (barycentric[0] + barycentric[1] + barycentric[2]);
+        barycentric[0] *= w;
+        barycentric[1] *= w;
+        barycentric[2] *= w;
+
+    }
+    barycentric_map[pix * 3] = barycentric[0];
+    barycentric_map[pix * 3 + 1] = barycentric[1];
+    barycentric_map[pix * 3 + 2] = barycentric[2];
+}
+
+void rasterizeImagecoordsKernelCPU(float* V, int* F, float* d, INT64* zbuffer, float occlusion_trunc, int width, int height, int num_vertices, int num_faces, int f)
+{
+    float* vt0_ptr = V + (F[f * 3] * 4);
+    float* vt1_ptr = V + (F[f * 3 + 1] * 4);
+    float* vt2_ptr = V + (F[f * 3 + 2] * 4);
+
+    float vt0[3] = {(vt0_ptr[0] / vt0_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt0_ptr[1] / vt0_ptr[3]) * (height - 1) + 0.5f, vt0_ptr[2] / vt0_ptr[3] * 0.49999f + 0.5f};
+    float vt1[3] = {(vt1_ptr[0] / vt1_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt1_ptr[1] / vt1_ptr[3]) * (height - 1) + 0.5f, vt1_ptr[2] / vt1_ptr[3] * 0.49999f + 0.5f};
+    float vt2[3] = {(vt2_ptr[0] / vt2_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt2_ptr[1] / vt2_ptr[3]) * (height - 1) + 0.5f, vt2_ptr[2] / vt2_ptr[3] * 0.49999f + 0.5f};
+
+    rasterizeTriangleCPU(f, vt0, vt1, vt2, width, height, zbuffer, d, occlusion_trunc);
+}
+
+std::vector<torch::Tensor> rasterize_image_cpu(torch::Tensor V, torch::Tensor F, torch::Tensor D,
+    int width, int height, float occlusion_truncation, int use_depth_prior)
+{
+    int num_faces = F.size(0);
+    int num_vertices = V.size(0);
+    auto options = torch::TensorOptions().dtype(torch::kInt32).requires_grad(false);
+    auto INT64_options = torch::TensorOptions().dtype(torch::kInt64).requires_grad(false);
+    auto findices = torch::zeros({height, width}, options);
+    INT64 maxint = (INT64)MAXINT * (INT64)MAXINT + (MAXINT - 1);
+    auto z_min = torch::ones({height, width}, INT64_options) * (int64_t)maxint;
+
+    if (!use_depth_prior) {
+        for (int i = 0; i < num_faces; ++i) {
+            rasterizeImagecoordsKernelCPU(V.data_ptr<float>(), F.data_ptr<int>(), 0,
+                (INT64*)z_min.data_ptr<int64_t>(), occlusion_truncation, width, height, num_vertices, num_faces, i); 
+        }
+    } else {
+        for (int i = 0; i < num_faces; ++i)
+            rasterizeImagecoordsKernelCPU(V.data_ptr<float>(), F.data_ptr<int>(), D.data_ptr<float>(),
+                (INT64*)z_min.data_ptr<int64_t>(), occlusion_truncation, width, height, num_vertices, num_faces, i);
+    }
+
+    auto float_options = torch::TensorOptions().dtype(torch::kFloat32).requires_grad(false);
+    auto barycentric = torch::zeros({height, width, 3}, float_options);
+    for (int i = 0; i < width * height; ++i)
+        barycentricFromImgcoordCPU(V.data_ptr<float>(), F.data_ptr<int>(),
+            findices.data_ptr<int>(), (INT64*)z_min.data_ptr<int64_t>(), width, height, num_vertices, num_faces, barycentric.data_ptr<float>(), i);
+
+    return {findices, barycentric};
+}
+
+std::vector<torch::Tensor> rasterize_image(torch::Tensor V, torch::Tensor F, torch::Tensor D,
+    int width, int height, float occlusion_truncation, int use_depth_prior)
+{
+    int device_id = V.get_device();
+    if (device_id == -1)
+        return rasterize_image_cpu(V, F, D, width, height, occlusion_truncation, use_depth_prior);
+    else
+        return rasterize_image_gpu(V, F, D, width, height, occlusion_truncation, use_depth_prior);
+}
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+  m.def("rasterize_image", &rasterize_image, "Custom image rasterization");
+  m.def("build_hierarchy", &build_hierarchy, "Custom image rasterization");
+  m.def("build_hierarchy_with_feat", &build_hierarchy_with_feat, "Custom image rasterization");
+}

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/lib/custom_rasterizer_kernel/rasterizer.h

@@ -0,0 +1,54 @@
+#ifndef RASTERIZER_H_
+#define RASTERIZER_H_
+
+#include <torch/extension.h>
+#include <vector>
+#include <ATen/ATen.h>
+#include <ATen/cuda/CUDAContext.h> // For CUDA context
+
+#define INT64 unsigned long long
+#define MAXINT 2147483647
+
+__host__ __device__ inline float calculateSignedArea2(float* a, float* b, float* c) {
+    return ((c[0] - a[0]) * (b[1] - a[1]) - (b[0] - a[0]) * (c[1] - a[1]));
+}
+
+__host__ __device__  inline void calculateBarycentricCoordinate(float* a, float* b, float* c, float* p,
+    float* barycentric)
+{
+    float beta_tri = calculateSignedArea2(a, p, c);
+    float gamma_tri = calculateSignedArea2(a, b, p);
+    float area = calculateSignedArea2(a, b, c);
+    if (area == 0) {
+        barycentric[0] = -1.0;
+        barycentric[1] = -1.0;
+        barycentric[2] = -1.0;
+        return;
+    }
+    float tri_inv = 1.0 / area;
+    float beta = beta_tri * tri_inv;
+    float gamma = gamma_tri * tri_inv;
+    float alpha = 1.0 - beta - gamma;
+    barycentric[0] = alpha;
+    barycentric[1] = beta;
+    barycentric[2] = gamma;
+}
+
+__host__ __device__  inline bool isBarycentricCoordInBounds(float* barycentricCoord) {
+    return barycentricCoord[0] >= 0.0 && barycentricCoord[0] <= 1.0 &&
+           barycentricCoord[1] >= 0.0 && barycentricCoord[1] <= 1.0 &&
+           barycentricCoord[2] >= 0.0 && barycentricCoord[2] <= 1.0;
+}
+
+std::vector<torch::Tensor> rasterize_image_gpu(torch::Tensor V, torch::Tensor F, torch::Tensor D,
+    int width, int height, float occlusion_truncation, int use_depth_prior);
+
+std::vector<std::vector<torch::Tensor>> build_hierarchy(std::vector<torch::Tensor> view_layer_positions, std::vector<torch::Tensor> view_layer_normals, int num_level, int resolution);
+
+std::vector<std::vector<torch::Tensor>> build_hierarchy_with_feat(
+    std::vector<torch::Tensor> view_layer_positions,
+    std::vector<torch::Tensor> view_layer_normals,
+    std::vector<torch::Tensor> view_layer_feats,
+    int num_level, int resolution);
+
+#endif

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/lib/custom_rasterizer_kernel/rasterizer_gpu.cu

@@ -0,0 +1,127 @@
+#include "rasterizer.h"
+
+__device__ void rasterizeTriangleGPU(int idx, float* vt0, float* vt1, float* vt2, int width, int height, INT64* zbuffer, float* d, float occlusion_truncation) {
+    float x_min = std::min(vt0[0], std::min(vt1[0],vt2[0]));
+    float x_max = std::max(vt0[0], std::max(vt1[0],vt2[0]));
+    float y_min = std::min(vt0[1], std::min(vt1[1],vt2[1]));
+    float y_max = std::max(vt0[1], std::max(vt1[1],vt2[1]));
+
+    for (int px = x_min; px < x_max + 1; ++px) {
+        if (px < 0 || px >= width)
+            continue;
+        for (int py = y_min; py < y_max + 1; ++py) {
+            if (py < 0 || py >= height)
+                continue;
+            float vt[2] = {px + 0.5f, py + 0.5f};
+            float baryCentricCoordinate[3];
+            calculateBarycentricCoordinate(vt0, vt1, vt2, vt, baryCentricCoordinate);
+            if (isBarycentricCoordInBounds(baryCentricCoordinate)) {
+                int pixel = py * width + px;
+                if (zbuffer == 0) {
+                    atomicExch(&zbuffer[pixel], (INT64)(idx + 1));
+                    continue;
+                }
+                float depth = baryCentricCoordinate[0] * vt0[2] + baryCentricCoordinate[1] * vt1[2] + baryCentricCoordinate[2] * vt2[2];
+                float depth_thres = 0;
+                if (d) {
+                    depth_thres = d[pixel] * 0.49999f + 0.5f + occlusion_truncation;
+                }
+                
+                int z_quantize = depth * (2<<17);
+                INT64 token = (INT64)z_quantize * MAXINT + (INT64)(idx + 1);
+                if (depth < depth_thres)
+                    continue;
+                atomicMin(&zbuffer[pixel], token);
+            }
+        }
+    }
+}
+
+__global__ void barycentricFromImgcoordGPU(float* V, int* F, int* findices, INT64* zbuffer, int width, int height, int num_vertices, int num_faces,
+    float* barycentric_map)
+{
+    int pix = blockIdx.x * blockDim.x + threadIdx.x;
+    if (pix >= width * height)
+        return;
+    INT64 f = zbuffer[pix] % MAXINT;
+    if (f == (MAXINT-1)) {
+        findices[pix] = 0;
+        barycentric_map[pix * 3] = 0;
+        barycentric_map[pix * 3 + 1] = 0;
+        barycentric_map[pix * 3 + 2] = 0;
+        return;
+    }
+    findices[pix] = f;
+    f -= 1;
+    float barycentric[3] = {0, 0, 0};
+    if (f >= 0) {
+        float vt[2] = {float(pix % width) + 0.5f, float(pix / width) + 0.5f};
+        float* vt0_ptr = V + (F[f * 3] * 4);
+        float* vt1_ptr = V + (F[f * 3 + 1] * 4);
+        float* vt2_ptr = V + (F[f * 3 + 2] * 4);
+
+        float vt0[2] = {(vt0_ptr[0] / vt0_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt0_ptr[1] / vt0_ptr[3]) * (height - 1) + 0.5f};
+        float vt1[2] = {(vt1_ptr[0] / vt1_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt1_ptr[1] / vt1_ptr[3]) * (height - 1) + 0.5f};
+        float vt2[2] = {(vt2_ptr[0] / vt2_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt2_ptr[1] / vt2_ptr[3]) * (height - 1) + 0.5f};
+
+        calculateBarycentricCoordinate(vt0, vt1, vt2, vt, barycentric);
+
+        barycentric[0] = barycentric[0] / vt0_ptr[3];
+        barycentric[1] = barycentric[1] / vt1_ptr[3];
+        barycentric[2] = barycentric[2] / vt2_ptr[3];
+        float w = 1.0f / (barycentric[0] + barycentric[1] + barycentric[2]);
+        barycentric[0] *= w;
+        barycentric[1] *= w;
+        barycentric[2] *= w;
+
+    }
+    barycentric_map[pix * 3] = barycentric[0];
+    barycentric_map[pix * 3 + 1] = barycentric[1];
+    barycentric_map[pix * 3 + 2] = barycentric[2];
+}
+
+__global__ void rasterizeImagecoordsKernelGPU(float* V, int* F, float* d, INT64* zbuffer, float occlusion_trunc, int width, int height, int num_vertices, int num_faces)
+{
+    int f = blockIdx.x * blockDim.x + threadIdx.x;
+    if (f >= num_faces)
+        return; 
+
+    float* vt0_ptr = V + (F[f * 3] * 4);
+    float* vt1_ptr = V + (F[f * 3 + 1] * 4);
+    float* vt2_ptr = V + (F[f * 3 + 2] * 4);
+
+    float vt0[3] = {(vt0_ptr[0] / vt0_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt0_ptr[1] / vt0_ptr[3]) * (height - 1) + 0.5f, vt0_ptr[2] / vt0_ptr[3] * 0.49999f + 0.5f};
+    float vt1[3] = {(vt1_ptr[0] / vt1_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt1_ptr[1] / vt1_ptr[3]) * (height - 1) + 0.5f, vt1_ptr[2] / vt1_ptr[3] * 0.49999f + 0.5f};
+    float vt2[3] = {(vt2_ptr[0] / vt2_ptr[3] * 0.5f + 0.5f) * (width - 1) + 0.5f, (0.5f + 0.5f * vt2_ptr[1] / vt2_ptr[3]) * (height - 1) + 0.5f, vt2_ptr[2] / vt2_ptr[3] * 0.49999f + 0.5f};
+
+    rasterizeTriangleGPU(f, vt0, vt1, vt2, width, height, zbuffer, d, occlusion_trunc);
+}
+
+std::vector<torch::Tensor> rasterize_image_gpu(torch::Tensor V, torch::Tensor F, torch::Tensor D,
+    int width, int height, float occlusion_truncation, int use_depth_prior)
+{
+    int device_id = V.get_device();
+    cudaSetDevice(device_id);
+    int num_faces = F.size(0);
+    int num_vertices = V.size(0);
+    auto options = torch::TensorOptions().dtype(torch::kInt32).device(torch::kCUDA, device_id).requires_grad(false);
+    auto INT64_options = torch::TensorOptions().dtype(torch::kInt64).device(torch::kCUDA, device_id).requires_grad(false);
+    auto findices = torch::zeros({height, width}, options);
+    INT64 maxint = (INT64)MAXINT * (INT64)MAXINT + (MAXINT - 1);
+    auto z_min = torch::ones({height, width}, INT64_options) * (int64_t)maxint;
+
+    if (!use_depth_prior) {
+        rasterizeImagecoordsKernelGPU<<<(num_faces+255)/256,256,0,at::cuda::getCurrentCUDAStream()>>>(V.data_ptr<float>(), F.data_ptr<int>(), 0,
+            (INT64*)z_min.data_ptr<int64_t>(), occlusion_truncation, width, height, num_vertices, num_faces); 
+    } else {
+        rasterizeImagecoordsKernelGPU<<<(num_faces+255)/256,256,0,at::cuda::getCurrentCUDAStream()>>>(V.data_ptr<float>(), F.data_ptr<int>(), D.data_ptr<float>(),
+            (INT64*)z_min.data_ptr<int64_t>(), occlusion_truncation, width, height, num_vertices, num_faces); 
+    }
+
+    auto float_options = torch::TensorOptions().dtype(torch::kFloat32).device(torch::kCUDA, device_id).requires_grad(false);
+    auto barycentric = torch::zeros({height, width, 3}, float_options);
+    barycentricFromImgcoordGPU<<<(width * height + 255)/256, 256>>>(V.data_ptr<float>(), F.data_ptr<int>(),
+        findices.data_ptr<int>(), (INT64*)z_min.data_ptr<int64_t>(), width, height, num_vertices, num_faces, barycentric.data_ptr<float>());
+
+    return {findices, barycentric};
+}

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+from torch.utils.cpp_extension import BuildExtension, CUDAExtension
+
+# build custom rasterizer
+# build with `python setup.py install`
+# nvcc is needed
+
+custom_rasterizer_module = CUDAExtension('custom_rasterizer_kernel', [
+    'lib/custom_rasterizer_kernel/rasterizer.cpp',
+    'lib/custom_rasterizer_kernel/grid_neighbor.cpp',
+    'lib/custom_rasterizer_kernel/rasterizer_gpu.cu',
+])
+
+setup(
+    packages=find_packages(),
+    version='0.1',
+    name='custom_rasterizer',
+    include_package_data=True,
+    package_dir={'': '.'},
+    ext_modules=[
+        custom_rasterizer_module,
+    ],
+    cmdclass={
+        'build_ext': BuildExtension
+    }
+)

OVOW/third_party/Motion324/scripts/hy3dgen/texgen/custom_rasterizer/setup.py.hy3d

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+from torch.utils.cpp_extension import BuildExtension, CUDAExtension
+
+# build custom rasterizer
+# build with `python setup.py install`
+# nvcc is needed
+
+custom_rasterizer_module = CUDAExtension('custom_rasterizer_kernel', [
+    'lib/custom_rasterizer_kernel/rasterizer.cpp',
+    'lib/custom_rasterizer_kernel/grid_neighbor.cpp',
+    'lib/custom_rasterizer_kernel/rasterizer_gpu.cu',
+])
+
+setup(
+    packages=find_packages(),
+    version='0.1',
+    name='custom_rasterizer',
+    include_package_data=True,
+    package_dir={'': '.'},
+    ext_modules=[
+        custom_rasterizer_module,
+    ],
+    cmdclass={
+        'build_ext': BuildExtension
+    }
+)