Upload rotation_dataset_lightfix.py with huggingface_hub

rotation_dataset_lightfix.py

@@ -0,0 +1,810 @@
+import os
+import sys
+import glob
+import numpy as np
+import trimesh
+from PIL import Image
+import argparse
+from pathlib import Path
+import traceback
+import random
+from tqdm import tqdm
+import itertools
+
+# Set OpenGL platform to EGL before importing pyrender
+os.environ['PYOPENGL_PLATFORM'] = 'egl'
+print(f"Set PYOPENGL_PLATFORM to: {os.environ.get('PYOPENGL_PLATFORM')}")
+
+try:
+    import pyrender
+    print(f"Successfully imported pyrender {pyrender.__version__}")
+except Exception as e:
+    print(f"Error importing pyrender: {e}")
+    traceback.print_exc()
+    sys.exit(1)
+
+# Import core rendering functionality from visualize_glb_models
+from visualize_glb_models import create_look_at_matrix, GLBRenderer
+
+class RotationDatasetGenerator(GLBRenderer):
+    """Generate dataset of GLB models with paired rotated views for rotation prediction training"""
+    
+    def __init__(self, output_dir="rotation_dataset", size=(512, 512), verbose=True):
+        super().__init__(output_dir=output_dir, size=size, verbose=verbose)
+        # Ensure outputs directory exists
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Valid rotation angles (divisible by 30, between -180 and 180)
+        self.rotation_angles = [-150, -120, -90, -60, -30, 30, 60, 90, 120, 150, 180]
+        # Valid rotation axes
+        self.rotation_axes = ['x', 'y', 'z']
+        
+        # Dictionary to track figure numbers for each glb file
+        self.glb_to_fignum = {}
+        self.current_fignum = 0
+
+    def extract_euler_angles(self, matrix):
+        """Extract Euler angles (in degrees) from a transformation matrix."""
+        # Extract rotation matrix (top-left 3x3)
+        rotation_matrix = matrix[:3, :3]
+        
+        # Convert to Euler angles (in radians)
+        euler_angles = trimesh.transformations.euler_from_matrix(rotation_matrix, 'sxyz')
+        
+        # Convert to degrees
+        euler_degrees = np.degrees(euler_angles)
+        
+        # Return as a tuple of x, y, z angles
+        return tuple(round(angle, 2) for angle in euler_degrees)
+    
+    def generate_specific_orientation(self, x_angle=0.0, y_angle=0.0, z_angle=0.0):
+        """Generate a specific orientation using the given Euler angles (in degrees)"""
+        # Convert angles to radians
+        x_rad = np.radians(x_angle)
+        y_rad = np.radians(y_angle)
+        z_rad = np.radians(z_angle)
+        
+        # Create rotation matrices for each axis
+        x_rot = trimesh.transformations.rotation_matrix(x_rad, [1, 0, 0])
+        y_rot = trimesh.transformations.rotation_matrix(y_rad, [0, 1, 0])
+        z_rot = trimesh.transformations.rotation_matrix(z_rad, [0, 0, 1])
+        
+        # Combine rotations (order matters: first z, then y, then x)
+        rotation_matrix = trimesh.transformations.concatenate_matrices(x_rot, y_rot, z_rot)
+        
+        return rotation_matrix
+
+    def render_separate_views(self, model, base_transform, initial_z_rotation, rotation_axis, rotation_angle, 
+                        output_folder, center, mesh_size, show_axes=False):
+        """Render initial view and rotated view as separate files in a folder"""
+        # Create scenes for both views
+        scene1 = pyrender.Scene(bg_color=[1.0, 1.0, 1.0, 1.0], ambient_light=[0.7, 0.7, 0.7])
+        scene2 = pyrender.Scene(bg_color=[1.0, 1.0, 1.0, 1.0], ambient_light=[0.7, 0.7, 0.7])
+        #scene1 = pyrender.Scene(bg_color=[0.9, 0.9, 0.9, 1.0], ambient_light=[0.7, 0.7, 0.7])
+        #scene2 = pyrender.Scene(bg_color=[0.9, 0.9, 0.9, 1.0], ambient_light=[0.7, 0.7, 0.7])
+        
+        # Apply initial z-rotation after base transform
+        initial_z_rotation_matrix = self.create_rotation_matrix('z', initial_z_rotation)
+        initial_transform = trimesh.transformations.concatenate_matrices(initial_z_rotation_matrix, base_transform)
+        
+        # Apply the initial transformation to scene1
+        self._add_model_to_scene(model, scene1, initial_transform)
+        
+        # Calculate the combined transformation (base + initial z-rotation + main rotation)
+        main_rotation_matrix = self.create_rotation_matrix(rotation_axis, rotation_angle)
+        combined_transform = trimesh.transformations.concatenate_matrices(main_rotation_matrix, initial_transform)
+        
+        self._add_model_to_scene(model, scene2, combined_transform)
+        
+        # Setup camera and lights for both scenes
+        camera_distance = mesh_size * self.camera_distance_factor
+        camera_distance = max(camera_distance, 1.0)
+        
+        # Standard front view camera (negative z-axis)
+        eye = np.array([0, 0, camera_distance]) + center
+        target = center
+        up = [0, 1, 0]  # Standard "up" direction
+        camera_pose = create_look_at_matrix(eye, target, up)
+        
+        # Add camera and lights to both scenes
+        camera = pyrender.PerspectiveCamera(yfov=np.pi / 3.0)
+        scene1.add(camera, pose=camera_pose)
+        scene2.add(camera, pose=camera_pose)
+        
+        # Add light to scenes
+        self._add_lights_to_scene(scene1, camera_pose, center, camera_distance)
+        self._add_lights_to_scene(scene2, camera_pose, center, camera_distance)
+        
+        # Add coordinate axes if requested
+        if show_axes:
+            # Scale axes size based on mesh size
+            axis_length = mesh_size * 0.4  # Slightly smaller to avoid overwhelming the object
+            
+            # Place axes at the center of the object
+            axis_pose1 = np.eye(4)
+            axis_pose1[:3, 3] = center  # Center position for first scene
+            
+            axis_pose2 = np.eye(4)
+            axis_pose2[:3, 3] = center  # Center position for second scene
+            
+            # Add the coordinate axes to both scenes
+            self._add_coordinate_axes(scene1, pose=axis_pose1, axis_length=axis_length)
+            self._add_coordinate_axes(scene2, pose=axis_pose2, axis_length=axis_length)
+
+        # Render both scenes
+        #r = pyrender.OffscreenRenderer(self.size[0], self.size[1], point_size=1.0, antialias_samples=4)
+        r = pyrender.OffscreenRenderer(self.size[0], self.size[1], point_size=1.0)
+        
+        # Create the output folder if it doesn't exist
+        os.makedirs(output_folder, exist_ok=True)
+        
+        # Get the base filename from the folder
+        folder_name = os.path.basename(output_folder)
+        
+        # Render and save the initial orientation image with the new naming pattern
+        image1, _ = r.render(scene1)
+        ini_path = os.path.join(output_folder, f"{folder_name}_ini.png")
+        Image.fromarray(image1).save(ini_path)
+        
+        # Render and save the rotated image with the new naming pattern
+        image2, _ = r.render(scene2)
+        rot_path = os.path.join(output_folder, f"{folder_name}_rot.png")
+        Image.fromarray(image2).save(rot_path)
+        
+        r.delete()
+        
+        return output_folder
+    
+    def _add_coordinate_axes(self, scene, pose=None, axis_length=1.0):
+        """Add coordinate axes visualization to scene (x:red, y:green, z:blue)"""
+        if pose is None:
+            pose = np.eye(4)
+        
+        origin = pose[:3, 3]
+        
+        # Create meshes for each axis
+        for i, (axis, color) in enumerate(zip(['x', 'y', 'z'], 
+                                            [[1.0, 0.0, 0.0], 
+                                            [0.0, 1.0, 0.0], 
+                                            [0.0, 0.0, 1.0]])):
+            # Create direction vector based on the pose
+            direction = np.zeros(3)
+            direction[i] = 1.0
+            direction = pose[:3, :3] @ direction  # Transform direction by rotation part of pose
+            
+            # Create cylinder for the shaft
+            cylinder_height = axis_length - 0.2  # Leave space for cone
+            cylinder_radius = axis_length * 0.02  # Thin line
+            
+            # Create a trimesh cylinder
+            cylinder = trimesh.creation.cylinder(
+                radius=cylinder_radius,
+                height=cylinder_height,
+                sections=8
+            )
+            
+            # Rotate cylinder to point in the right direction
+            z_axis = np.array([0, 0, 1])
+            rotation_axis = np.cross(z_axis, direction)
+            rotation_angle = np.arccos(np.dot(z_axis, direction) / (np.linalg.norm(z_axis) * np.linalg.norm(direction)))
+            
+            if np.linalg.norm(rotation_axis) > 1e-6:  # Avoid zero division
+                rotation_matrix = trimesh.transformations.rotation_matrix(rotation_angle, rotation_axis)
+                cylinder.apply_transform(rotation_matrix)
+            
+            # Position cylinder
+            translation = origin + direction * cylinder_height / 2
+            translation_matrix = trimesh.transformations.translation_matrix(translation)
+            cylinder.apply_transform(translation_matrix)
+            
+            # Create a cone for the arrow tip
+            cone_height = 0.2
+            cone_radius = cylinder_radius * 2.5
+            cone = trimesh.creation.cone(radius=cone_radius, height=cone_height, sections=8)
+            
+            # Rotate cone to point in the right direction
+            if np.linalg.norm(rotation_axis) > 1e-6:
+                cone.apply_transform(rotation_matrix)
+                
+            # Position cone at the end of the cylinder
+            tip_translation = origin + direction * axis_length - direction * cone_height / 2
+            tip_translation_matrix = trimesh.transformations.translation_matrix(tip_translation)
+            cone.apply_transform(tip_translation_matrix)
+            
+            # Combine shaft and arrow into one mesh
+            axis_mesh = trimesh.util.concatenate([cylinder, cone])
+            
+            # Apply material color
+            material = pyrender.MetallicRoughnessMaterial(
+                baseColorFactor=color + [1.0],  # RGBA
+                metallicFactor=0.0,
+                roughnessFactor=0.5
+            )
+            
+            # Add to scene
+            mesh = pyrender.Mesh.from_trimesh(axis_mesh, material=material)
+            scene.add(mesh)
+        
+    def create_rotation_matrix(self, axis, angle_degrees):
+        """Create a rotation matrix about the camera-aligned axis by the given angle in degrees"""
+        angle_rad = np.radians(angle_degrees)
+        
+        if axis == 'x':
+            # Horizontal axis (left-right in the image)
+            return trimesh.transformations.rotation_matrix(angle_rad, [1, 0, 0])
+        elif axis == 'y': 
+            # Vertical axis (up-down in the image)
+            return trimesh.transformations.rotation_matrix(angle_rad, [0, 1, 0])
+        elif axis == 'z':
+            # Depth axis (in-out of the image)
+            return trimesh.transformations.rotation_matrix(angle_rad, [0, 0, 1])
+        else:
+            raise ValueError(f"Invalid rotation axis: {axis}. Must be 'x', 'y', or 'z'")
+    
+    def render_paired_views(self, model, base_transform, initial_z_rotation, rotation_axis, rotation_angle, 
+                        output_path, center, mesh_size, show_axes=False):
+        """Render initial view and rotated view side by side using PIL instead of matplotlib"""
+        # Create scenes for both views
+        scene1 = pyrender.Scene(bg_color=[1.0, 1.0, 1.0, 1.0], ambient_light=[0.7, 0.7, 0.7])
+        scene2 = pyrender.Scene(bg_color=[1.0, 1.0, 1.0, 1.0], ambient_light=[0.7, 0.7, 0.7])
+        
+        # Apply initial z-rotation after base transform
+        initial_z_rotation_matrix = self.create_rotation_matrix('z', initial_z_rotation)
+        initial_transform = trimesh.transformations.concatenate_matrices(initial_z_rotation_matrix, base_transform)
+        
+        # Add model with initial transformation to scene1
+        self._add_model_to_scene(model, scene1, initial_transform)
+        
+        # Calculate the combined transformation (base + initial z-rotation + main rotation)
+        main_rotation_matrix = self.create_rotation_matrix(rotation_axis, rotation_angle)
+        combined_transform = trimesh.transformations.concatenate_matrices(main_rotation_matrix, initial_transform)
+        
+        # Add model with combined transformation to scene2
+        self._add_model_to_scene(model, scene2, combined_transform)
+        
+        # Setup camera and lights for both scenes
+        camera_distance = mesh_size * self.camera_distance_factor
+        camera_distance = max(camera_distance, 1.0)
+        
+        # Standard front view camera (negative z-axis)
+        eye = np.array([0, 0, camera_distance]) + center
+        target = center
+        up = [0, 1, 0]  # Standard "up" direction
+        camera_pose = create_look_at_matrix(eye, target, up)
+        
+        # Add camera and lights to both scenes
+        camera = pyrender.PerspectiveCamera(yfov=np.pi / 3.0)
+        scene1.add(camera, pose=camera_pose)
+        scene2.add(camera, pose=camera_pose)
+        
+        # Add light to scenes
+        self._add_lights_to_scene(scene1, camera_pose, center, camera_distance)
+        self._add_lights_to_scene(scene2, camera_pose, center, camera_distance)
+        
+        # Add coordinate axes if requested
+        if show_axes:
+            # Scale axes size based on mesh size
+            axis_length = mesh_size * 0.4  # Slightly smaller to avoid overwhelming the object
+            
+            # Place axes at the center of the object
+            axis_pose1 = np.eye(4)
+            axis_pose1[:3, 3] = center  # Center position for first scene
+            
+            axis_pose2 = np.eye(4)
+            axis_pose2[:3, 3] = center  # Center position for second scene
+            
+            # Apply the appropriate transform to the second scene's axes
+            # to maintain consistency with the object's rotation
+            axis_pose2 = trimesh.transformations.concatenate_matrices(main_rotation_matrix, axis_pose2)
+            
+            self._add_coordinate_axes(scene1, pose=axis_pose1, axis_length=axis_length)
+            self._add_coordinate_axes(scene2, pose=axis_pose2, axis_length=axis_length)
+        
+        # Render both scenes
+        #r = pyrender.OffscreenRenderer(self.size[0], self.size[1], point_size=1.0, antialias_samples=4)
+        r = pyrender.OffscreenRenderer(self.size[0], self.size[1], point_size=1.0)
+        
+        image1, _ = r.render(scene1)
+        image2, _ = r.render(scene2)
+        
+        r.delete()
+        
+        # Combine images side by side using PIL
+        pil_img1 = Image.fromarray(image1)
+        pil_img2 = Image.fromarray(image2)
+        
+        # Create a new image with twice the width (no gap)
+        combined_width = pil_img1.width + pil_img2.width
+        combined_height = max(pil_img1.height, pil_img2.height)
+        combined_img = Image.new('RGB', (combined_width, combined_height))
+        
+        # Paste the two images side by side with no gap
+        combined_img.paste(pil_img1, (0, 0))
+        combined_img.paste(pil_img2, (pil_img1.width, 0))
+        
+        # Save the combined image
+        combined_img.save(output_path)
+        
+        return output_path
+    
+    def _add_model_to_scene(self, model, scene, transform=None):
+        """Add a model to a scene with the given transformation"""
+        if transform is None:
+            transform = np.eye(4)
+            
+        if isinstance(model, trimesh.Scene):
+            # For a scene, add each mesh with its transform
+            for name, geom in model.geometry.items():
+                if not isinstance(geom, trimesh.Trimesh):
+                    continue
+                
+                try:
+                    # Get the geometry's transform
+                    try:
+                        geom_transform = model.graph.get(name)[0]
+                    except (ValueError, KeyError, IndexError):
+                        geom_transform = np.eye(4)
+                    
+                    # Combine with the provided transform
+                    combined_transform = trimesh.transformations.concatenate_matrices(transform, geom_transform)
+                    
+                    # Add to scene - CHANGED smooth=False to smooth=True
+                    mesh_pyrender = pyrender.Mesh.from_trimesh(geom, smooth=True)
+                    scene.add(mesh_pyrender, pose=combined_transform)
+                except Exception as e:
+                    if self.verbose:
+                        print(f"Info: Skipped mesh {name}: {str(e)[:100]}")
+                    continue
+        else:
+            # For a single mesh, add it directly with the transform
+            try:
+                # CHANGED smooth=False to smooth=True
+                mesh_pyrender = pyrender.Mesh.from_trimesh(model, smooth=True)
+                scene.add(mesh_pyrender, pose=transform)
+            except Exception as e:
+                if self.verbose:
+                    print(f"Error adding mesh to scene: {e}")
+                raise
+    
+    def _add_lights_to_scene(self, scene, camera_pose, center, camera_distance):
+        """Add more balanced lighting to a scene"""
+        # 1. Main light from camera direction (reduced intensity)
+        main_light = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=2.0)  # Reduced from 4.0
+        scene.add(main_light, pose=camera_pose)
+        
+        # 2. Add point lights around the object (fewer lights, reduced intensity)
+        for light_angle in [0, 180]:  # Reduced from 4 lights to 2
+            light_angle_rad = np.radians(light_angle)
+            lx = camera_distance * 0.8 * np.cos(light_angle_rad)
+            ly = camera_distance * 0.3
+            lz = camera_distance * 0.8 * np.sin(light_angle_rad)
+            
+            light_pose = np.eye(4)
+            light_pose[:3, 3] = np.array([lx, ly, lz]) + center
+            
+            point_light = pyrender.PointLight(color=[1.0, 1.0, 1.0], intensity=1.0)  # Reduced from 2.0
+            scene.add(point_light, pose=light_pose)
+        
+        # 3. Add a soft light from above (reduced intensity)
+        top_light_pose = np.eye(4)
+        top_light_pose[:3, 3] = center + np.array([0, camera_distance, 0])
+        top_light = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=1.5)  # Reduced from 3.0
+        scene.add(top_light, pose=top_light_pose)
+    
+    def generate_dataset(self, glb_paths, rotation_axes=None, rotation_angles=None, 
+                        x_angles=None, y_angles=None, z_angles=None, initial_z_rotations=None,
+                        show_axes=False, generation_mode='combined'):
+        """Generate a dataset from multiple GLB files with specific orientations and rotations"""
+        dataset_info = []
+        
+        # Use default rotation axes if not specified
+        if rotation_axes is None:
+            rotation_axes = self.rotation_axes
+            
+        # Use default rotation angles if not specified
+        if rotation_angles is None:
+            rotation_angles = self.rotation_angles
+        
+        # Define the orientation angles to use
+        # Use custom x_angles if provided, otherwise use default
+        if x_angles is None:
+            x_angles = [0.0]  # Default is fixed at 0
+        # Use custom y_angles if provided, otherwise use default
+        if y_angles is None:
+            y_angles = [0, 45, 90, 135, 180, 225, 270, 315]
+        # Use custom z_angles if provided, otherwise use default
+        if z_angles is None:
+            z_angles = [0, 180]
+        # Use custom initial_z_rotations if provided, otherwise use default
+        if initial_z_rotations is None:
+            initial_z_rotations = [0.0]  # Default is no initial z rotation
+        
+        # Calculate all orientation combinations
+        orientation_configs = list(itertools.product(x_angles, y_angles, z_angles))
+        
+        # Calculate all rotation configurations (combinations of axis and angle)
+        rotation_configs = list(itertools.product(rotation_axes, rotation_angles))
+        
+        # Calculate total number of samples
+        total_samples = len(glb_paths) * len(orientation_configs) * len(initial_z_rotations) * len(rotation_configs)
+        
+        with tqdm(total=total_samples, desc="Generating dataset") as pbar:
+            for i, glb_path in enumerate(glb_paths):
+                if self.verbose:
+                    print(f"\nProcessing model {i+1}/{len(glb_paths)}: {Path(glb_path).name}")
+                
+                # Load the GLB model once per model to save time
+                try:
+                    # In your mesh loading code
+                    model = trimesh.load(glb_path, process=False, force='mesh')
+                    
+                    # Get model bounds and center for camera positioning
+                    if isinstance(model, trimesh.Scene):
+                        center, mesh_size = self._get_scene_bounds(model)
+                    else:
+                        bounds = model.bounds
+                        center = (bounds[0] + bounds[1]) / 2
+                        mesh_size = np.max(bounds[1] - bounds[0])
+                    
+                    # Get the GLB file name
+                    mesh_name = Path(glb_path).stem
+                    
+                    # Check if this GLB file already has a figure number assigned
+                    if mesh_name not in self.glb_to_fignum:
+                        # Assign a new figure number
+                        self.glb_to_fignum[mesh_name] = self.current_fignum
+                        self.current_fignum += 1
+                    
+                    # Get the assigned figure number
+                    fig_num = self.glb_to_fignum[mesh_name]
+                    
+                    # Generate a sample for each orientation, initial z rotation, and main rotation combination
+                    sample_id = 0
+                    for x_angle, y_angle, z_angle in orientation_configs:
+                        # Generate the specific orientation
+                        base_transform = self.generate_specific_orientation(x_angle, y_angle, z_angle)
+                        
+                        # Extract orientation angles for CSV output
+                        orientation_angles = (x_angle, y_angle, z_angle)
+                        
+                        for initial_z_rotation in initial_z_rotations:
+                            for rotation_axis, rotation_angle in rotation_configs:
+                                # Create output filename with ground truth info - USING THE ORIGINAL NAMING CONVENTION
+                                # Remove the initial_z_rotation from the filename to match the original format
+                                base_name = f"fig{fig_num:04d}_{sample_id:03d}_{rotation_axis}_{rotation_angle}"
+                                
+                                if generation_mode == 'separate':
+                                    # Create a folder for the separate images
+                                    output_folder = os.path.join(self.output_dir, base_name)
+                                    
+                                    # Render the separate views
+                                    self.render_separate_views(
+                                        model=model,
+                                        base_transform=base_transform,
+                                        initial_z_rotation=initial_z_rotation,
+                                        rotation_axis=rotation_axis,
+                                        rotation_angle=rotation_angle,
+                                        output_folder=output_folder,
+                                        center=center,
+                                        mesh_size=mesh_size,
+                                        show_axes=show_axes
+                                    )
+                                    
+                                    output_path = output_folder
+                                else:
+                                    # Combined mode (default)
+                                    output_path = os.path.join(self.output_dir, f"{base_name}.png")
+                                    
+                                    # Render the paired views
+                                    self.render_paired_views(
+                                        model=model,
+                                        base_transform=base_transform,
+                                        initial_z_rotation=initial_z_rotation,
+                                        rotation_axis=rotation_axis,
+                                        rotation_angle=rotation_angle,
+                                        output_path=output_path,
+                                        center=center,
+                                        mesh_size=mesh_size,
+                                        show_axes=show_axes
+                                    )
+                                
+                                # Add to dataset info
+                                dataset_info.append({
+                                    "file_path": output_path,
+                                    "model": mesh_name,
+                                    "sample_id": sample_id,
+                                    "initial_z_rotation": initial_z_rotation,
+                                    "rotation_axis": rotation_axis,
+                                    "rotation_angle": rotation_angle,
+                                    "orientation_x": orientation_angles[0],
+                                    "orientation_y": orientation_angles[1],
+                                    "orientation_z": orientation_angles[2],
+                                    "generation_mode": generation_mode
+                                })
+                                
+                                sample_id += 1
+                                pbar.update(1)
+                            
+                except Exception as e:
+                    if self.verbose:
+                        print(f"Error processing {glb_path}: {e}")
+                        traceback.print_exc()
+                    # Update progress bar for skipped configurations
+                    skipped_count = len(orientation_configs) * len(initial_z_rotations) * len(rotation_configs)
+                    pbar.update(skipped_count)
+        
+        # Create a CSV file with dataset information
+        self.save_dataset_info(dataset_info)
+        
+        return dataset_info
+    
+    def _get_scene_bounds(self, scene):
+        """Get the bounds and size of a scene"""
+        # Get overall scene bounds
+        bounds = np.zeros((2, 3))
+        center = np.zeros(3)
+        mesh_size = 1.0  # Default size if we can't compute bounds
+        
+        # Try to calculate bounds from all geometries
+        if len(scene.geometry) > 0:
+            all_vertices = []
+            
+            # First collect all vertices from all geometries
+            for name, geom in scene.geometry.items():
+                if hasattr(geom, 'vertices') and len(geom.vertices) > 0:
+                    # Try to get transform for this geometry
+                    try:
+                        transform = scene.graph.get(name)[0]
+                        transformed_verts = trimesh.transformations.transform_points(geom.vertices, transform)
+                        all_vertices.append(transformed_verts)
+                    except (ValueError, KeyError, IndexError) as e:
+                        if self.verbose:
+                            print(f"Warning: Could not get transform for {name}, using identity")
+                        # Use identity transform as fallback
+                        all_vertices.append(geom.vertices)
+            
+            # If we have any vertices, compute bounds
+            if all_vertices:
+                combined_vertices = np.vstack(all_vertices)
+                bounds[0] = np.min(combined_vertices, axis=0)
+                bounds[1] = np.max(combined_vertices, axis=0)
+                center = (bounds[0] + bounds[1]) / 2
+                mesh_size = np.max(bounds[1] - bounds[0])
+            else:
+                if self.verbose:
+                    print("Warning: No usable vertices found in geometry, using default bounds")
+        
+        return center, mesh_size
+    
+    def save_dataset_info(self, dataset_info):
+        """Save dataset information to a CSV file"""
+        import csv
+        
+        csv_path = os.path.join(self.output_dir, "dataset_info.csv")
+        
+        with open(csv_path, 'w', newline='') as csvfile:
+            # Add initial_z_rotation to fieldnames
+            fieldnames = ['file_path', 'model', 'sample_id', 'initial_z_rotation', 'rotation_axis', 'rotation_angle', 
+                         'orientation_x', 'orientation_y', 'orientation_z', 'generation_mode']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            
+            writer.writeheader()
+            for item in dataset_info:
+                writer.writerow(item)
+        
+        if self.verbose:
+            print(f"Dataset information saved to {csv_path}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a dataset of 3D model rotations")
+    parser.add_argument('--input-dir', type=str, default="/mnt/data/yma71/vrg/0330/Hunyuan3D-2/objaverse_downloads",
+                      help="Directory containing GLB files")
+    parser.add_argument('--output-dir', type=str, default="/mnt/data/yma71/vrg/0330/Hunyuan3D-2/rotation_dataset",
+                      help="Directory to save generated dataset")
+    parser.add_argument('--size', type=str, default="1024,1024",
+                    help="Render size as width,height (e.g. '1024,1024')")
+    parser.add_argument('--random-seed', type=int, default=42,
+                      help="Random seed for reproducibility")
+    parser.add_argument('--rotation-axes', type=str, default=None,
+                      help="Comma-separated list of rotation axes (e.g. 'x,y,z')")
+    parser.add_argument('--rotation-angles', type=str, default=None,
+                      help="Comma-separated list of rotation angles (e.g. '30,60,90')")
+    parser.add_argument('--model', type=str, default=None,
+                      help="Use a specific GLB file instead of all in input-dir")
+    parser.add_argument('--show-axes', action='store_true',
+                      help="Show coordinate axes in the renderings")
+    parser.add_argument('--generation-mode', type=str, choices=['combined', 'separate'], default='combined',
+                      help="Mode for generating images (combined = one image with both views, separate = folder with two images)")
+    parser.add_argument('--verbose', action='store_true',
+                      help="Print verbose output")
+    parser.add_argument('--x-angles', type=str, default=None,
+                      help="Comma-separated list of x angles (e.g. '0,45,90')")
+    parser.add_argument('--y-angles', type=str, default=None,
+                      help="Comma-separated list of y angles (e.g. '0,45,90,135,180,225,270,315')")
+    parser.add_argument('--z-angles', type=str, default=None,
+                      help="Comma-separated list of z angles (e.g. '0,180')")
+    # Add new argument for initial z rotations
+    parser.add_argument('--initial-z-rotations', type=str, default=None,
+                      help="Comma-separated list of initial z rotations (e.g. '0,90,180,270')")
+    
+    args = parser.parse_args()
+    
+    # Set random seed for reproducibility (still useful for some operations)
+    random.seed(args.random_seed)
+    np.random.seed(args.random_seed)
+    
+    # Parse render size
+    size = tuple(map(int, args.size.split(',')))
+    
+    # Create dataset generator
+    generator = RotationDatasetGenerator(
+        output_dir=args.output_dir,
+        size=size,
+        verbose=args.verbose
+    )
+
+    # Get GLB files to process
+    if args.model:
+        if not os.path.exists(args.model):
+            print(f"GLB file not found: {args.model}")
+            return
+        glb_files = [args.model]
+    else:
+        # Search recursively for GLB files in input_dir and all subdirectories
+        glb_files = []
+        for root, dirs, files in os.walk(args.input_dir):
+            for file in files:
+                if file.lower().endswith('.glb'):
+                    glb_files.append(os.path.join(root, file))
+        glb_files = sorted(glb_files)
+    
+    if not glb_files:
+        print(f"No GLB files found in {args.input_dir} or its subdirectories")
+        return
+    
+    print(f"Found {len(glb_files)} GLB files to process")
+    if args.verbose:
+        # Print first few files to verify correct discovery
+        for i, file in enumerate(glb_files[:5]):
+            print(f"  {i+1}. {file}")
+        if len(glb_files) > 5:
+            print(f"  ... and {len(glb_files)-5} more files")
+    
+    # Parse rotation axes if provided
+    rotation_axes = None
+    if args.rotation_axes:
+        rotation_axes = args.rotation_axes.split(',')
+        # Validate rotation axes
+        for axis in rotation_axes:
+            if axis not in ['x', 'y', 'z']:
+                print(f"Invalid rotation axis: {axis}. Must be one of 'x', 'y', 'z'")
+                return
+    
+    # Parse rotation angles if provided
+    rotation_angles = None
+    if args.rotation_angles:
+        try:
+            rotation_angles = [int(angle) for angle in args.rotation_angles.split(',')]
+            
+            # Make sure angles are within the valid range
+            for angle in rotation_angles:
+                if not (-180 <= angle <= 180):
+                    print(f"All rotation angles must be between -180 and 180 degrees. Got {angle}")
+                    return
+                
+        except ValueError as e:
+            print(f"Invalid rotation angles format. Use comma-separated integers: {e}")
+            return
+    
+    # Parse x angles if provided
+    x_angles = None
+    if args.x_angles:
+        try:
+            x_angles = [float(angle) for angle in args.x_angles.split(',')]
+        except ValueError as e:
+            print(f"Invalid x angles format. Use comma-separated numbers: {e}")
+            return
+
+    # Parse y angles if provided
+    y_angles = None
+    if args.y_angles:
+        try:
+            y_angles = [float(angle) for angle in args.y_angles.split(',')]
+        except ValueError as e:
+            print(f"Invalid y angles format. Use comma-separated numbers: {e}")
+            return
+    
+    # Parse z angles if provided
+    z_angles = None
+    if args.z_angles:
+        try:
+            z_angles = [float(angle) for angle in args.z_angles.split(',')]
+        except ValueError as e:
+            print(f"Invalid z angles format. Use comma-separated numbers: {e}")
+            return
+    
+    # Parse initial z rotations if provided
+    initial_z_rotations = None
+    if args.initial_z_rotations:
+        try:
+            initial_z_rotations = [float(angle) for angle in args.initial_z_rotations.split(',')]
+        except ValueError as e:
+            print(f"Invalid initial z rotations format. Use comma-separated numbers: {e}")
+            return
+    
+    # Update print statements to include all angles
+    print("Using initial orientations:")
+    if x_angles:
+        print(f"  x = {x_angles}")
+    else:
+        print("  x = [0.0]")
+    if y_angles:
+        print(f"  y = {y_angles}")
+    else:
+        print("  y = [0, 45, 90, 135, 180, 225, 270, 315]")
+    if z_angles:
+        print(f"  z = {z_angles}")
+    else:
+        print("  z = [0, 180]")
+    
+    # Print initial z rotations
+    if initial_z_rotations:
+        print(f"Using initial z rotations: {initial_z_rotations}")
+    else:
+        print("Using default initial z rotation: [0.0]")
+    
+    # Update calculation of total combinations
+    x_count = len(x_angles) if x_angles else 1  # Default is [0.0]
+    y_count = len(y_angles) if y_angles else 8  # Default is [0, 45, 90, 135, 180, 225, 270, 315]
+    z_count = len(z_angles) if z_angles else 2  # Default is [0, 180]
+    initial_z_count = len(initial_z_rotations) if initial_z_rotations else 1  # Default is [0.0]
+    
+    if rotation_axes:
+        print(f"Using rotation axes: {rotation_axes}")
+    else:
+        print(f"Using default rotation axes: {generator.rotation_axes}")
+        
+    if rotation_angles:
+        print(f"Using rotation angles: {rotation_angles}")
+    else:
+        print(f"Using default rotation angles: {generator.rotation_angles}")
+        
+    if args.show_axes:
+        print("Coordinate axes will be shown in the renderings")
+    
+    rot_axis_count = len(rotation_axes) if rotation_axes else len(generator.rotation_axes)
+    rot_angle_count = len(rotation_angles) if rotation_angles else len(generator.rotation_angles)
+    
+    total_orientations = x_count * y_count * z_count
+    total_rotations = rot_axis_count * rot_angle_count
+    total_combinations_per_model = total_orientations * initial_z_count * total_rotations
+    
+    print(f"Total orientations: {total_orientations}")
+    print(f"Total initial z rotations per orientation: {initial_z_count}")
+    print(f"Total rotations per initial state: {total_rotations}")
+    print(f"Total combinations per model: {total_combinations_per_model}")
+    print(f"Total samples to generate: {total_combinations_per_model * len(glb_files)}")
+    
+    # Generate the dataset with new parameters
+    dataset_info = generator.generate_dataset(
+        glb_files,
+        rotation_axes=rotation_axes,
+        rotation_angles=rotation_angles,
+        x_angles=x_angles,
+        y_angles=y_angles,
+        z_angles=z_angles,
+        initial_z_rotations=initial_z_rotations,
+        show_axes=args.show_axes,
+        generation_mode=args.generation_mode
+    )
+    
+    print(f"\nDataset generation complete!")
+    print(f"Generated {len(dataset_info)} samples")
+    print(f"Results saved to {args.output_dir}")
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print(f"Unhandled exception in main: {e}")
+        traceback.print_exc()