Update app.py

app.py

@@ -3,10 +3,10 @@ import numpy as np
 import trimesh
 import tempfile
 import os
-from pathlib import Path
-import logging
-from typing import Tuple, Optional
 import struct
+import logging
+from pathlib import Path
+from typing import Tuple
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -14,101 +14,82 @@ logger = logging.getLogger(__name__)
 
 class VoxParser:
     """Parse MagicaVoxel .vox files"""
-    def __init__(self, file_data):
-        self.file_data = file_data
-        self.voxels = []
-        self.palette = []
-        self.size = {}
-        self.offset = 0
+    
+    def __init__(self, file_path):
+        self.file_path = file_path
         
     def parse(self) -> dict:
         """Parse the .vox file and extract voxel data"""
         try:
-            # Handle both bytes and file objects
-            if hasattr(self.file_data, 'read'):
-                data = self.file_data.read()
-            else:
-                data = self.file_data
+            with open(self.file_path, 'rb') as f:
+                data = f.read()
                 
-            self.buffer = data
-            self.view = memoryview(data)
-            self.offset = 0
+            offset = 0
             
             # Read header
-            header = self.read_string(4)
+            header = data[offset:offset+4].decode('ascii', errors='ignore')
+            offset += 4
             if header != 'VOX ':
                 raise ValueError("Invalid VOX file header")
             
-            version = self.read_int32()
+            version = struct.unpack('<I', data[offset:offset+4])[0]
+            offset += 4
+            
+            voxels = []
+            palette = []
+            size = {}
             
             # Parse chunks
-            while self.offset < len(data):
-                chunk_id = self.read_string(4)
-                chunk_size = self.read_int32()
-                child_size = self.read_int32()
+            while offset < len(data):
+                chunk_id = data[offset:offset+4].decode('ascii', errors='ignore')
+                offset += 4
+                chunk_size = struct.unpack('<I', data[offset:offset+4])[0]
+                offset += 4
+                child_size = struct.unpack('<I', data[offset:offset+4])[0]
+                offset += 4
                 
                 if chunk_id == 'SIZE':
-                    self.parse_size(chunk_size)
+                    size = {
+                        'x': struct.unpack('<I', data[offset:offset+4])[0],
+                        'y': struct.unpack('<I', data[offset+4:offset+8])[0],
+                        'z': struct.unpack('<I', data[offset+8:offset+12])[0]
+                    }
+                    offset += chunk_size
                 elif chunk_id == 'XYZI':
-                    self.parse_voxels(chunk_size)
+                    num_voxels = struct.unpack('<I', data[offset:offset+4])[0]
+                    offset += 4
+                    
+                    for i in range(num_voxels):
+                        if offset + 4 <= len(data):
+                            x, y, z, color_index = struct.unpack('BBBB', data[offset:offset+4])
+                            voxels.append({
+                                'x': x,
+                                'y': y,
+                                'z': z,
+                                'color_index': color_index
+                            })
+                            offset += 4
                 elif chunk_id == 'RGBA':
-                    self.parse_palette(chunk_size)
+                    for i in range(256):
+                        if offset + 4 <= len(data):
+                            r, g, b, a = struct.unpack('BBBB', data[offset:offset+4])
+                            palette.append({'r': r, 'g': g, 'b': b, 'a': a})
+                            offset += 4
                 else:
-                    self.offset += chunk_size
+                    offset += chunk_size
                 
-                # Safety check
-                if self.offset >= len(data):
+                if offset >= len(data):
                     break
-                
+            
             return {
-                'voxels': self.voxels,
-                'palette': self.palette or self._default_palette(),
-                'size': self.size
+                'voxels': voxels,
+                'palette': palette or self._default_palette(),
+                'size': size
             }
         except Exception as e:
-            logger.error(f"Error parsing VOX file: {e}")
-            raise
-    
-    def parse_size(self, size: int):
-        """Parse size chunk"""
-        if self.offset + 12 <= len(self.buffer):
-            self.size = {
-                'x': self.read_int32(),
-                'y': self.read_int32(),
-                'z': self.read_int32()
-            }
-    
-    def parse_voxels(self, size: int):
-        """Parse voxel data"""
-        if self.offset + 4 <= len(self.buffer):
-            num_voxels = self.read_int32()
-            
-            for i in range(num_voxels):
-                if self.offset + 4 <= len(self.buffer):
-                    x, y, z, color_index = struct.unpack('BBBB', self.buffer[self.offset:self.offset+4])
-                    self.voxels.append({
-                        'x': x,
-                        'y': y, 
-                        'z': z,
-                        'color_index': color_index
-                    })
-                    self.offset += 4
-    
-    def parse_palette(self, size: int):
-        """Parse palette data"""
-        for i in range(256):
-            if self.offset + 4 <= len(self.buffer):
-                r, g, b, a = struct.unpack('BBBB', self.buffer[self.offset:self.offset+4])
-                self.palette.append({
-                    'r': r,
-                    'g': g,
-                    'b': b,
-                    'a': a
-                })
-                self.offset += 4
+            raise ValueError(f"Error parsing VOX file: {e}")
     
     def _default_palette(self) -> list:
-        """Default MagicaVoxel palette if none found"""
         colors = []
         for i in range(256):
             intensity = i / 255.0
@@ -120,41 +101,17 @@ class VoxParser:
             })
         return colors
 
-    def read_string(self, length: int) -> str:
-        """Read string from buffer"""
-        if self.offset + length <= len(self.buffer):
-            result = self.buffer[self.offset:self.offset+length].tobytes().decode('ascii', errors='ignore')
-            self.offset += length
-            return result
-        return ""
-    
-    def read_int32(self) -> int:
-        """Read 32-bit integer"""
-        if self.offset + 4 <= len(self.buffer):
-            result = struct.unpack('<I', self.buffer[self.offset:self.offset+4])[0]
-            self.offset += 4
-            return result
-        return 0
-
 class VoxToGlbConverter:
     """Convert MagicaVoxel files to GLB format"""
     
     def __init__(self):
         self.voxel_size = 1.0
         
-    def vox_to_glb(self, vox_file) -> Tuple[str, str]:
-        """
-        Convert .vox file to .glb file
-        
-        Args:
-            vox_file: Gradio file object
-            
-        Returns:
-            Tuple of (glb_file_path, status_message)
-        """
+    def vox_to_glb(self, vox_file_path: str) -> Tuple[str, str]:
+        """Convert .vox file to .glb file"""
         try:
-            # Parse the .vox file directly from the file object
-            parser = VoxParser(vox_file)
+            # Parse the .vox file
+            parser = VoxParser(vox_file_path)
             voxel_data = parser.parse()
             
             if not voxel_data['voxels']:
@@ -178,7 +135,7 @@ class VoxToGlbConverter:
         voxels = voxel_data['voxels']
         palette = voxel_data['palette']
         
-        # Group voxels by color for better performance
+        # Group voxels by color
         color_groups = {}
         for voxel in voxels:
             color_idx = voxel['color_index']
@@ -186,122 +143,97 @@ class VoxToGlbConverter:
                 color_groups[color_idx] = []
             color_groups[color_idx].append(voxel)
         
-        # Create meshes for each color group
         meshes = []
         
         for color_idx, voxels in color_groups.items():
             color = palette[color_idx] if color_idx < len(palette) else {'r': 255, 'g': 255, 'b': 255, 'a': 255}
             
-            # Create instanced cubes for this color
             cube = trimesh.creation.box(extents=[self.voxel_size, self.voxel_size, self.voxel_size])
             
             for voxel in voxels:
-                # Position the cube
                 translation = trimesh.transformations.translation_matrix([
                     voxel['x'] * self.voxel_size,
-                    voxel['z'] * self.voxel_size,  # Swap Y and Z for proper orientation
+                    voxel['z'] * self.voxel_size,
                     voxel['y'] * self.voxel_size
                 ])
                 
                 transformed_cube = cube.copy()
                 transformed_cube.apply_transform(translation)
                 
-                # Set vertex colors
                 vertex_colors = np.tile([color['r']/255, color['g']/255, color['b']/255, color['a']/255], 
                                       (len(transformed_cube.vertices), 1))
                 transformed_cube.visual.vertex_colors = vertex_colors
                 
                 meshes.append(transformed_cube)
         
-        # Combine all meshes
         if meshes:
             combined = trimesh.util.concatenate(meshes)
             return combined
         else:
-            # Fallback: create a simple cube
             return trimesh.creation.box(extents=[self.voxel_size, self.voxel_size, self.voxel_size])
 
 def process_vox_file(vox_file) -> Tuple[str, str]:
-    """Process uploaded .vox file and convert to .glb"""
+    """Process uploaded .vox file and convert to .glb - FIXED for Error 21"""
     if vox_file is None:
         return "", "Please upload a .vox file"
     
     try:
         converter = VoxToGlbConverter()
-        glb_path, message = converter.vox_to_glb(vox_file)
-        return glb_path, message
+        
+        # PROPER FIX FOR ERROR 21:
+        # Create temp file and copy the actual uploaded file
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.vox') as tmp_file:
+            # Get the actual file path from Gradio's file object
+            if hasattr(vox_file, 'name'):
+                real_file_path = vox_file.name
+                
+                # Verify it's a file, not a directory
+                if os.path.isfile(real_file_path):
+                    # Copy the uploaded file to temp location
+                    import shutil
+                    shutil.copy(real_file_path, tmp_file.name)
+                    temp_vox_path = tmp_file.name
+                else:
+                    return "", "Could not access uploaded file - may be a directory"
+            else:
+                return "", "Invalid file format"
+            
+            # Convert using the temp file path
+            glb_path, message = converter.vox_to_glb(temp_vox_path)
+            
+            # Clean up temp file
+            if os.path.exists(temp_vox_path):
+                os.unlink(temp_vox_path)
+            
+            return glb_path, message
+            
     except Exception as e:
         return "", f"Error: {str(e)}"
 
 def create_gradio_interface():
-    """Create the Gradio interface"""
-    
     with gr.Blocks(title="VOX to GLB Converter", theme=gr.themes.Soft()) as app:
         gr.Markdown("""
         # 🧊 MagicaVoxel to GLB Converter
-        
-        Convert your MagicaVoxel `.vox` files to `.glb` format for preview and use in 3D applications.
-        
-        **Features:**
-        - ✅ Preserves voxel colors and structure
-        - ✅ Optimized for 3D preview
-        - ✅ Handles legacy VOX formats (2019-2020)
-        - ✅ Downloads as GLB file
+        Convert your MagicaVoxel `.vox` files to `.glb` format
         """)
         
         with gr.Row():
             with gr.Column():
-                vox_input = gr.File(
-                    label="Upload VOX File",
-                    file_types=[".vox"],
-                    file_count="single"
-                )
-                
+                vox_input = gr.File(label="Upload VOX File", file_types=[".vox"], file_count="single")
                 convert_btn = gr.Button("Convert to GLB", variant="primary")
-                
-                status_output = gr.Textbox(
-                    label="Status",
-                    interactive=False,
-                    placeholder="Ready to convert..."
-                )
+                status_output = gr.Textbox(label="Status", interactive=False, placeholder="Ready...")
                 
             with gr.Column():
-                glb_output = gr.File(
-                    label="Download GLB File",
-                    file_types=[".glb"],
-                    interactive=False
-                )
-                
-                preview_info = gr.Markdown("""
-                **Preview Info:**
-                - Download the GLB file
-                - Drag into any 3D viewer
-                - Compatible with Three.js, Babylon.js, Unity, Blender
-                """)
+                glb_output = gr.File(label="Download GLB File", file_types=[".glb"], interactive=False)
         
-        # Event handlers
         convert_btn.click(
             fn=process_vox_file,
             inputs=[vox_input],
             outputs=[glb_output, status_output]
         )
-        
-        gr.Markdown("### 📁 Example Usage")
-        gr.Markdown("""
-        **How to use:**
-        1. Click "Upload VOX File" and select your `.vox` file
-        2. Click "Convert to GLB" 
-        3. Download the converted `.glb` file
-        4. Preview in any 3D viewer or use in your projects
-        """)
     
     return app
 
 if __name__ == "__main__":
     app = create_gradio_interface()
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        show_error=True
-    )
+    app.launch(server_name="0.0.0.0", server_port=7860, share=True, show_error=True)