Upload visualize_glb_models.py with huggingface_hub

visualize_glb_models.py

@@ -0,0 +1,434 @@
+import os
+import sys
+import glob
+import numpy as np
+import trimesh
+import matplotlib.pyplot as plt
+from PIL import Image
+import argparse
+from pathlib import Path
+import traceback
+
+# Enable verbose debugging
+print("Starting GLB visualization script...")
+print(f"Python version: {sys.version}")
+print(f"Current directory: {os.getcwd()}")
+
+# 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)
+
+def create_look_at_matrix(eye, target, up=None):
+    """Create a 'look at' transformation matrix for camera positioning
+    
+    Args:
+        eye: Camera position
+        target: Point the camera is looking at
+        up: Up direction (defaults to [0,0,1] if not provided)
+    
+    Returns:
+        4x4 transformation matrix
+    """
+    if up is None:
+        up = np.array([0.0, 0.0, 1.0])  # Default up direction
+    
+    # Calculate forward direction (z)
+    forward = np.array(target) - np.array(eye)
+    forward = forward / np.linalg.norm(forward)
+    
+    # Calculate right direction (x)
+    right = np.cross(forward, up)
+    if np.linalg.norm(right) < 1e-6:
+        # If forward and up are parallel, choose a different up vector
+        alternate_up = np.array([0.0, 1.0, 0.0]) if np.allclose(up, [0,0,1]) else np.array([0.0, 0.0, 1.0])
+        right = np.cross(forward, alternate_up)
+    right = right / np.linalg.norm(right)
+    
+    # Recalculate the orthogonal up vector (y)
+    corrected_up = np.cross(right, forward)
+    corrected_up = corrected_up / np.linalg.norm(corrected_up)
+    
+    # Create rotation matrix - each column is one of the basis vectors
+    rotation = np.eye(4)
+    rotation[:3, 0] = right
+    rotation[:3, 1] = corrected_up
+    rotation[:3, 2] = -forward  # Negate because in OpenGL, camera looks down -z
+    
+    # Create translation matrix
+    translation = np.eye(4)
+    translation[:3, 3] = -np.array(eye)  
+    
+    # Combine rotation and translation
+    result = np.matmul(rotation, translation)
+    
+    # Instead, just set the position directly and keep the calculated rotation
+    result[:3, 3] = np.array(eye)
+    
+    return result
+
+class GLBRenderer:
+    """Class to render 3D meshes from GLB files using PyRender with EGL backend"""
+    
+    def __init__(self, output_dir="glb_visualizations", size=(512, 512), verbose=True):
+        self.output_dir = output_dir
+        self.size = size
+        self.verbose = verbose
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Default camera parameters
+        self.camera_distance_factor = 1.5
+        self.camera_elevation = 30
+        
+        if verbose:
+            print(f"GLB Renderer initialized with output directory: {os.path.abspath(output_dir)}")
+            print(f"Render size: {size[0]}x{size[1]}")
+            print(f"Using PYOPENGL_PLATFORM: {os.environ.get('PYOPENGL_PLATFORM', 'default')}")
+    
+    def render_model(self, glb_path, angles=None, contact_sheet=True):
+        """Render multiple views of a GLB model and optionally create a contact sheet"""
+        if angles is None:
+            angles = [0, 45, 90, 135, 180, 225, 270, 315]
+        
+        model_name = Path(glb_path).stem
+        model_output_dir = os.path.join(self.output_dir, model_name)
+        os.makedirs(model_output_dir, exist_ok=True)
+        
+        if self.verbose:
+            print(f"Rendering GLB model: {model_name}")
+            print(f"Output directory: {model_output_dir}")
+        
+        # Load the model
+        try:
+            print(f"Loading GLB from: {glb_path}")
+            model = trimesh.load(glb_path)
+            
+            # Get model bounds and center for camera positioning
+            if isinstance(model, trimesh.Scene):
+                print(f"Loaded GLB as a Scene with {len(model.geometry)} geometries")
+                
+                # 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, regardless of transform
+                if len(model.geometry) > 0:
+                    all_vertices = []
+                    
+                    # First collect all vertices from all geometries
+                    for name, geom in model.geometry.items():
+                        if hasattr(geom, 'vertices') and len(geom.vertices) > 0:
+                            # Try to get transform for this geometry
+                            try:
+                                transform = model.graph.get(name)[0]
+                                transformed_verts = trimesh.transformations.transform_points(geom.vertices, transform)
+                                all_vertices.append(transformed_verts)
+                            except (ValueError, KeyError, IndexError) as e:
+                                print(f"Warning: Could not get transform for {name}, using identity. Error: {e}")
+                                # Use identity transform as fallback
+                                all_vertices.append(geom.vertices)
+                    
+                    # If we have any vertices, compute bounds
+                    if all_vertices:
+                        # Combine 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:
+                        print("Warning: No usable vertices found in geometry, using default bounds")
+                        bounds[0] = np.array([-1.0, -1.0, -1.0])
+                        bounds[1] = np.array([1.0, 1.0, 1.0])
+                        center = np.zeros(3)
+                        mesh_size = 2.0
+                else:
+                    # Empty scene, use default bounds
+                    print("Warning: Empty scene, using default bounds")
+                    bounds[0] = np.array([-1.0, -1.0, -1.0])
+                    bounds[1] = np.array([1.0, 1.0, 1.0])
+                    center = np.zeros(3)
+                    mesh_size = 2.0
+            else:
+                print(f"Loaded GLB as a single Mesh with {len(model.vertices)} vertices and {len(model.faces)} faces")
+                bounds = model.bounds
+                center = (bounds[0] + bounds[1]) / 2
+                mesh_size = np.max(bounds[1] - bounds[0])
+            
+            if self.verbose:
+                print(f"Model bounds: {bounds}")
+                print(f"Model center: {center}")
+                print(f"Model size: {mesh_size}")
+                
+        except Exception as e:
+            print(f"Error loading GLB {glb_path}: {e}")
+            traceback.print_exc()
+            return None
+        
+        # Render each angle
+        render_paths = []
+        for angle in angles:
+            output_path = os.path.join(model_output_dir, f"angle_{angle:03d}.png")
+            try:
+                self._render_view(model, angle, output_path, center, mesh_size)
+                render_paths.append(output_path)
+            except Exception as e:
+                print(f"Error rendering angle {angle}: {e}")
+                traceback.print_exc()
+                # Create a placeholder image
+                img = Image.new('RGB', self.size, color=(200, 200, 200))
+                img.save(output_path)
+                render_paths.append(output_path)
+            
+        # Create contact sheet if requested
+        if contact_sheet and render_paths:
+            sheet_path = os.path.join(self.output_dir, f"{model_name}_contact_sheet.png")
+            try:
+                self._create_contact_sheet(render_paths, sheet_path)
+                if self.verbose:
+                    print(f"Created contact sheet: {sheet_path}")
+            except Exception as e:
+                print(f"Error creating contact sheet: {e}")
+                traceback.print_exc()
+        
+        return render_paths
+    
+    def _render_view(self, model, angle, output_path, center, mesh_size):
+        """Render a single view of the GLB model"""
+        print(f"Rendering view at angle {angle}°...")
+        
+        # Create a scene with stronger ambient light to prevent completely dark renders
+        scene = pyrender.Scene(bg_color=[0.9, 0.9, 0.9, 1.0], ambient_light=[0.7, 0.7, 0.7])
+        
+        # Add model to the scene
+        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):
+                    # Skip non-mesh geometries
+                    continue
+                
+                try:
+                    # Get the transform for this geometry
+                    try:
+                        transform = model.graph.get(name)[0]
+                    except (ValueError, KeyError, IndexError):
+                        # If no valid transform path exists, use identity transform
+                        print(f"No valid transform path for {name}, using identity transform")
+                        transform = np.eye(4)
+                    
+                    # Convert trimesh to pyrender mesh
+                    mesh_pyrender = pyrender.Mesh.from_trimesh(geom, smooth=False)
+                    
+                    # Add to scene with the geometry's transform
+                    scene.add(mesh_pyrender, pose=transform)
+                except Exception as e:
+                    print(f"Error adding mesh {name} to scene: {e}")
+                    continue
+        else:
+            # For a single mesh, add it directly
+            try:
+                mesh_pyrender = pyrender.Mesh.from_trimesh(model, smooth=False)
+                scene.add(mesh_pyrender, pose=np.eye(4))
+            except Exception as e:
+                print(f"Error adding mesh to scene: {e}")
+                raise
+        
+        # Calculate camera distance based on mesh size
+        camera_distance = mesh_size * self.camera_distance_factor
+        camera_distance = max(camera_distance, 1.0)  # Ensure minimum distance
+        
+        print(f"Mesh size: {mesh_size}, Camera distance: {camera_distance}")
+        
+        # Position camera based on angle and elevation
+        angle_rad = np.radians(angle)
+        elevation_rad = np.radians(self.camera_elevation)
+        
+        # Calculate camera position
+        x = camera_distance * np.cos(elevation_rad) * np.sin(angle_rad)
+        y = camera_distance * np.cos(elevation_rad) * np.cos(angle_rad)
+        z = camera_distance * np.sin(elevation_rad)
+        eye = np.array([x, y, z]) + center
+        
+        # Create camera pose matrix using our custom function
+        camera_pose = create_look_at_matrix(eye, center)
+        
+        # Create and add camera to scene
+        print("Adding camera to scene...")
+        camera = pyrender.PerspectiveCamera(yfov=np.pi / 3.0)
+        scene.add(camera, pose=camera_pose)
+        
+        # Add multiple lights from different directions
+        print("Adding lights to scene...")
+        
+        # 1. Main light from camera direction
+        light = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=4.0)
+        scene.add(light, pose=camera_pose)
+        
+        # 2. Add several point lights around the object
+        for light_angle in [0, 90, 180, 270]:  # Lights at cardinal directions
+            light_angle_rad = np.radians(light_angle)
+            lx = camera_distance * 0.8 * np.sin(light_angle_rad)
+            ly = camera_distance * 0.8 * np.cos(light_angle_rad)
+            lz = camera_distance * 0.8  # Position lights above the object
+            
+            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=2.0)
+            scene.add(point_light, pose=light_pose)
+        
+        # Add a bright light from above
+        top_light_pose = np.eye(4)
+        top_light_pose[:3, 3] = center + np.array([0, 0, camera_distance])
+        top_light = pyrender.DirectionalLight(color=[1.0, 1.0, 1.0], intensity=3.0)
+        scene.add(top_light, pose=top_light_pose)
+        
+        # Render
+        print("Rendering scene...")
+        r = pyrender.OffscreenRenderer(self.size[0], self.size[1])
+        color, depth = r.render(scene)
+        r.delete()
+        
+        # Save image
+        print(f"Saving rendered image to: {output_path}")
+        img = Image.fromarray(color)
+        img.save(output_path)
+        
+        return output_path
+    
+    def _create_contact_sheet(self, image_paths, output_path, cols=4):
+        """Create a contact sheet from multiple images"""
+        if not image_paths:
+            return None
+        
+        print(f"Creating contact sheet from {len(image_paths)} images...")
+        
+        # Determine rows and columns
+        n_images = len(image_paths)
+        rows = (n_images + cols - 1) // cols
+        
+        # Open first image to get dimensions
+        with Image.open(image_paths[0]) as img:
+            img_width, img_height = img.size
+        
+        # Create contact sheet
+        sheet_width = cols * img_width
+        sheet_height = rows * img_height
+        contact_sheet = Image.new('RGB', (sheet_width, sheet_height), (255, 255, 255))
+        
+        # Add each image to contact sheet
+        for i, img_path in enumerate(image_paths):
+            if os.path.exists(img_path):
+                try:
+                    img = Image.open(img_path)
+                    row = i // cols
+                    col = i % cols
+                    x = col * img_width
+                    y = row * img_height
+                    contact_sheet.paste(img, (x, y))
+                except Exception as e:
+                    print(f"Error adding image {img_path} to contact sheet: {e}")
+        
+        # Save contact sheet
+        contact_sheet.save(output_path)
+        print(f"Contact sheet saved to: {output_path}")
+        return output_path
+
+def main():
+    print("Entering main function...")
+    
+    parser = argparse.ArgumentParser(description="Render GLB files using PyRender with EGL")
+    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/glb_visualizations",
+                        help="Directory to save rendered images")
+    parser.add_argument('--angles', type=str, default="0,45,90,135,180,225,270,315",
+                        help="Comma-separated list of camera angles")
+    parser.add_argument('--size', type=str, default="512,512",
+                        help="Render size as width,height (e.g. '512,512')")
+    parser.add_argument('--no-contact-sheet', action='store_true',
+                        help="Disable contact sheet generation")
+    parser.add_argument('--elevation', type=float, default=30,
+                        help="Camera elevation angle in degrees")
+    parser.add_argument('--distance', type=float, default=2.5,
+                        help="Camera distance factor (relative to model size)")
+    parser.add_argument('--verbose', action='store_true',
+                        help="Print verbose output")
+    parser.add_argument('--model', type=str, default=None,
+                        help="Render a specific GLB file instead of all models in input-dir")
+    
+    args = parser.parse_args()
+    print(f"Parsed arguments: {args}")
+    
+    # Parse render size
+    size = tuple(map(int, args.size.split(',')))
+    
+    # Parse angles
+    angles = list(map(int, args.angles.split(',')))
+    
+    # Create renderer
+    print("Creating GLB renderer...")
+    renderer = GLBRenderer(
+        output_dir=args.output_dir, 
+        size=size, 
+        verbose=args.verbose or True  # Force verbose for debugging
+    )
+    
+    # Set camera parameters
+    renderer.camera_elevation = args.elevation
+    renderer.camera_distance_factor = args.distance
+    
+    # Handle single model case
+    if args.model:
+        if not os.path.exists(args.model):
+            print(f"GLB file not found: {args.model}")
+            return
+        
+        print(f"Processing single GLB model: {args.model}")
+        renderer.render_model(
+            args.model,
+            angles=angles,
+            contact_sheet=not args.no_contact_sheet
+        )
+        return
+    
+    # Find all GLB files
+    print(f"Looking for GLB files in: {args.input_dir}")
+    glb_files = sorted(glob.glob(os.path.join(args.input_dir, "*.glb")))
+    
+    if not glb_files:
+        print(f"No GLB files found in {args.input_dir}")
+        return
+    
+    print(f"Found {len(glb_files)} GLB files to render: {[os.path.basename(f) for f in glb_files]}")
+    
+    # Process each file
+    for i, glb_path in enumerate(glb_files):
+        print(f"\n[{i+1}/{len(glb_files)}] Processing: {os.path.basename(glb_path)}")
+        try:
+            renderer.render_model(
+                glb_path, 
+                angles=angles, 
+                contact_sheet=not args.no_contact_sheet
+            )
+        except Exception as e:
+            print(f"Error processing {os.path.basename(glb_path)}: {e}")
+            traceback.print_exc()
+    
+    print(f"\nVisualization complete! 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()