# ------------------------------------------------------------------- # scripts/data/build_lmdb.py # ------------------------------------------------------------------- """ Build LMDB databases for VAE/KPP training. This script samples point clouds in a low-memory mode, performs normalization, and writes train/val splits to LMDB for efficient training I/O. """ import sys import os import argparse import json import torch import numpy as np import trimesh from torch.utils.data import Dataset, random_split, Subset # Ensure the repository root is importable sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))) # Import the GAPartNet loader. from dragmesh.data.data_loader_v2 import GAPartNetLoaderV2 from dragmesh.data.balanced_dataset_utils import build_vae_lmdb from dragmesh.utils.kpp_normalization import bbox_center_scale, normalize_points, normalize_vector class SmartProcessingDataset(Dataset): """ Smart processing dataset: 1) Category-based filtering (config-driven) 2) Uses the GAPartNet loader 3) Filtering based on motion magnitude 4) Normalization and point sampling """ def __init__(self, root, categories=None, num_frames=16, num_points=4096, joint_selection: str = "largest_motion"): print(f"Initializing Loader from: {root}") self.loader = GAPartNetLoaderV2(root) self.num_frames = num_frames self.num_points = num_points self.joint_selection = joint_selection # === 1) Category-based filtering === if categories: print(f"Filtering for {len(categories)} categories...") self.valid_indices = [] for i, obj_path in enumerate(self.loader.object_list): # Check meta.json for category labels. meta_path = os.path.join(obj_path, "meta.json") if os.path.exists(meta_path): try: with open(meta_path, 'r') as f: meta = json.load(f) if meta.get('model_cat') in categories: self.valid_indices.append(i) except: pass print(f"Found {len(self.valid_indices)} objects matching categories.") else: self.valid_indices = list(range(len(self.loader.object_list))) def __len__(self): return len(self.valid_indices) def __getitem__(self, idx): # Map back to the loader's global object index. real_idx = self.valid_indices[idx] try: # 1) Fetch a raw sample from the loader. raw = self.loader.generate_training_sample( real_idx, self.num_frames, joint_selection=self.joint_selection, return_mesh=False, # key: low-memory point-cloud mode (avoid mesh concat OOM) num_points=self.num_points # sample points inside the loader ) # 2) Motion-based filtering. joint_type = raw['joint_type'] is_valid = False if joint_type in ['revolute', 'continuous']: # Check rotation magnitude via quaternion angle difference (first vs last frame). q_s, q_e = raw['qr_sequence'][0], raw['qr_sequence'][-1] dot = np.abs(np.dot(q_s, q_e)) angle_diff = 2 * np.arccos(np.clip(dot, -1, 1)) # Threshold: > ~17 degrees (~0.3 rad). if angle_diff > 0.3: is_valid = True elif joint_type == 'prismatic': # Check translation distance. traj = raw['drag_trajectory'] dist = np.linalg.norm(traj[-1] - traj[0]) if dist > 0.1: is_valid = True if not is_valid: return None # tell build_vae_lmdb to skip this sample # 3) === Normalization (points already sampled by the loader) === # KPP predicts the origin in the normalized point-cloud frame. This # frame must be available at inference, so center on the object bbox, # not the GT joint origin. points = raw['initial_mesh'] # [N,3] ndarray # Compute scale: prefer loader-provided bounds; otherwise use point-cloud bounds. if 'bounds_min' in raw and 'bounds_max' in raw: bmin = raw['bounds_min'] bmax = raw['bounds_max'] else: bmin = points.min(axis=0) bmax = points.max(axis=0) center, scale = bbox_center_scale(bmin, bmax) points = normalize_points(points, center, scale) # 4) Part mask is already point-level (0=static, 1=movable). p_mask = raw['part_mask'].astype(np.int32) # 5) Pack output dict out = { 'initial_mesh': points.astype(np.float32, copy=False), 'drag_point': normalize_points(raw['drag_point'], center, scale), 'drag_vector': normalize_vector(raw['drag_vector'], scale), 'qr_gt': raw['qr_sequence'].astype(np.float32), 'qd_gt': (raw['qd_sequence'] / scale).astype(np.float32), 'joint_type': 0 if joint_type in ['revolute', 'continuous'] else 1, 'joint_axis': raw['joint_axis'].astype(np.float32), 'joint_origin': normalize_points(raw['joint_origin'], center, scale), 'part_mask': p_mask.astype(np.float32), 'norm_center': center.astype(np.float32), 'norm_scale': np.array(scale, dtype=np.float32), 'origin_normalization_version': np.array(1, dtype=np.int64), # Extra fields (used by loss/augmentation) 'rotation_direction': raw['rotation_direction'].astype(np.float32), 'trajectory_vectors': (raw['trajectory_vectors'] / scale).astype(np.float32), 'drag_trajectory': normalize_points(raw['drag_trajectory'], center, scale) } return out except Exception as e: # print(f"Skip sample {real_idx}: {e}") return None def main(args): print("\n" + "="*70) print("BUILDING LMDB DATABASES (IN-CATEGORY VALIDATION ONLY)") print("With motion-based filtering and low-memory point sampling") print("="*70) # 1) Load configuration. print(f"Loading config: {args.config}") with open(args.config, 'r') as f: config = json.load(f) # Load train_categories only. train_categories = config['train_categories'] val_in_config = config.get('val_in_category', {}) val_split_ratio = val_in_config.get('split_ratio', 0.1) seed = val_in_config.get('random_seed', 42) print(f"Total categories: {len(train_categories)}") print(f"Val split ratio: {val_split_ratio}") # 2) Initialize smart dataset (includes filtering in __getitem__). # Note: we do not use FixedDragMeshDatasetV2 here; we use SmartProcessingDataset to avoid # unnecessary work performed during dataset initialization. print("\nInitializing Smart Dataset...") full_dataset = SmartProcessingDataset( root=args.dataset_root, categories=train_categories, num_frames=args.num_frames, num_points=args.num_points, joint_selection=args.joint_selection ) # 3) Note: len(full_dataset) counts objects matching categories; the number of valid samples is # determined during LMDB build because __getitem__ may return None. print(f"Found {len(full_dataset)} matching objects (filtering happens during build).") # 4) Split into train/val objects. val_size = int(len(full_dataset) * val_split_ratio) train_size = len(full_dataset) - val_size print(f"\nSplitting into {train_size} (Train) and {val_size} (Val) objects.") train_subset, val_subset = random_split( full_dataset, [train_size, val_size], generator=torch.Generator().manual_seed(seed) ) # 5) Build training LMDB. output_path_train = args.output_prefix + "_train.lmdb" print(f"\nBuilding TRAINING LMDB...") build_vae_lmdb( dataset=train_subset, output_path=output_path_train, categories=train_categories, num_frames=args.num_frames, num_points=args.num_points ) # 6) Build validation LMDB. output_path_val = args.output_prefix + "_val.lmdb" print(f"\nBuilding VALIDATION LMDB...") build_vae_lmdb( dataset=val_subset, output_path=output_path_val, categories=train_categories, num_frames=args.num_frames, num_points=args.num_points ) print("\n" + "="*70) print("LMDB BUILD COMPLETE!") print(f"Train Output: {output_path_train}") print(f"Val Output: {output_path_val}") print("="*70 + "\n") if __name__ == "__main__": parser = argparse.ArgumentParser(description="Build VAE LMDB") parser.add_argument('--dataset_root', type=str, required=True, help='Root directory of dataset') parser.add_argument('--output_prefix', type=str, required=True, help='Prefix for output LMDBs') parser.add_argument('--config', type=str, default='configs/category_split_v2.json', help='Category split configuration') parser.add_argument('--num_frames', type=int, default=16, help='Number of trajectory frames') parser.add_argument('--num_points', type=int, default=4096, help='Number of points to sample') parser.add_argument( '--joint_selection', type=str, default='largest_motion', choices=['largest_motion', 'random', 'first'], help='How to choose the joint for each object when generating samples' ) args = parser.parse_args() main(args)