Update app.py

app.py

@@ -7,6 +7,7 @@ from pathlib import Path
 import logging
 from typing import Tuple, Optional
 import struct
+import shutil
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -23,87 +24,95 @@ class VoxParser:
     def parse(self) -> dict:
         """Parse the .vox file and extract voxel data"""
         try:
-            with open(self.file_path, 'rb') as f:
-                # Read header
-                header = f.read(4).decode('ascii')
-                if header != 'VOX ':
-                    raise ValueError("Invalid VOX file header")
+            # Handle both file paths and file-like objects
+            if hasattr(self.file_path, 'read'):
+                # File-like object from Gradio
+                data = self.file_path.read()
+            else:
+                # File path
+                with open(self.file_path, 'rb') as f:
+                    data = f.read()
+            
+            self.buffer = data
+            self.view = memoryview(data)
+            self.offset = 0
+            
+            # Read header
+            header = self.read_string(4)
+            if header != 'VOX ':
+                raise ValueError("Invalid VOX file header")
+            
+            version = self.read_int32()
+            
+            # Parse chunks
+            while self.offset < len(data):
+                chunk_id = self.read_string(4)
+                chunk_size = self.read_int32()
+                child_size = self.read_int32()
                 
-                version = struct.unpack('<I', f.read(4))[0]
+                if chunk_id == 'SIZE':
+                    self.parse_size(chunk_size)
+                elif chunk_id == 'XYZI':
+                    self.parse_voxels(chunk_size)
+                elif chunk_id == 'RGBA':
+                    self.parse_palette(chunk_size)
+                else:
+                    self.offset += chunk_size
                 
-                # Parse chunks
-                while True:
-                    chunk_data = f.read(8)
-                    if len(chunk_data) < 8:
-                        break
-                        
-                    chunk_id = chunk_data[:4].decode('ascii')
-                    chunk_size, child_size = struct.unpack('<II', chunk_data[4:])
-                    
-                    chunk_content = f.read(chunk_size)
-                    
-                    if chunk_id == 'SIZE':
-                        self.parse_size(chunk_content)
-                    elif chunk_id == 'XYZI':
-                        self.parse_voxels(chunk_content)
-                    elif chunk_id == 'RGBA':
-                        self.parse_palette(chunk_content)
-                    else:
-                        # Skip unknown chunks
-                        if chunk_size > 0:
-                            f.seek(chunk_size, 1)
+                # Safety check
+                if self.offset >= len(data):
+                    break
                 
-                return {
-                    'voxels': self.voxels,
-                    'palette': self.palette or self._default_palette(),
-                    'size': self.size
-                }
+            return {
+                'voxels': self.voxels,
+                'palette': self.palette or self._default_palette(),
+                'size': self.size
+            }
         except Exception as e:
             logger.error(f"Error parsing VOX file: {e}")
             raise
     
-    def parse_size(self, data: bytes):
+    def parse_size(self, size: int):
         """Parse size chunk"""
-        self.size = {
-            'x': struct.unpack('<I', data[:4])[0],
-            'y': struct.unpack('<I', data[4:8])[0],
-            'z': struct.unpack('<I', data[8:12])[0]
-        }
+        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, data: bytes):
+    def parse_voxels(self, size: int):
         """Parse voxel data"""
-        num_voxels = struct.unpack('<I', data[: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])
-                self.voxels.append({
-                    'x': x,
-                    'y': y, 
-                    'z': z,
-                    'color_index': color_index
-                })
-                offset += 4
+        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, data: bytes):
+    def parse_palette(self, size: int):
         """Parse palette data"""
-        offset = 0
         for i in range(256):
-            if offset + 4 <= len(data):
-                r, g, b, a = struct.unpack('BBBB', data[offset:offset+4])
+            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
                 })
-                offset += 4
+                self.offset += 4
     
     def _default_palette(self) -> list:
         """Default MagicaVoxel palette if none found"""
         colors = []
-        # Create a simple gradient palette
         for i in range(256):
             intensity = i / 255.0
             colors.append({
@@ -114,39 +123,69 @@ 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_path: str) -> Tuple[str, str]:
+    def vox_to_glb(self, vox_file) -> Tuple[str, str]:
         """
         Convert .vox file to .glb file
         
         Args:
-            vox_file_path: Path to the .vox file
+            vox_file: Gradio file object or file path
             
         Returns:
             Tuple of (glb_file_path, status_message)
         """
         try:
-            # Parse the .vox file
-            parser = VoxParser(vox_file_path)
-            voxel_data = parser.parse()
-            
-            if not voxel_data['voxels']:
-                return "", "No voxels found in the file"
-            
-            # Create mesh from voxels
-            mesh = self.create_mesh_from_voxels(voxel_data)
-            
-            # Save as GLB
-            output_path = str(Path(vox_file_path).with_suffix('.glb'))
-            mesh.export(output_path)
-            
-            return output_path, f"Successfully converted {len(voxel_data['voxels'])} voxels to GLB format"
-            
+            # Create a temporary file to handle the upload
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.vox') as tmp_file:
+                if hasattr(vox_file, 'name'):
+                    # Gradio file object - copy to temp file
+                    shutil.copy(vox_file.name, tmp_file.name)
+                    temp_vox_path = tmp_file.name
+                else:
+                    # Direct file path
+                    temp_vox_path = vox_file
+                
+                # Parse the .vox file
+                parser = VoxParser(temp_vox_path)
+                voxel_data = parser.parse()
+                
+                if not voxel_data['voxels']:
+                    return "", "No voxels found in the file"
+                
+                # Create mesh from voxels
+                mesh = self.create_mesh_from_voxels(voxel_data)
+                
+                # Save as GLB to a permanent location
+                output_path = str(Path(tempfile.gettempdir()) / f"converted_{os.path.basename(temp_vox_path)}.glb")
+                mesh.export(output_path)
+                
+                # Clean up temp file
+                if temp_vox_path != vox_file:
+                    os.unlink(temp_vox_path)
+                
+                return output_path, f"Successfully converted {len(voxel_data['voxels'])} voxels to GLB format"
+                
         except Exception as e:
             logger.error(f"Conversion error: {e}")
             return "", f"Error converting file: {str(e)}"
@@ -206,7 +245,7 @@ def process_vox_file(vox_file) -> Tuple[str, str]:
     
     try:
         converter = VoxToGlbConverter()
-        glb_path, message = converter.vox_to_glb(vox_file.name)
+        glb_path, message = converter.vox_to_glb(vox_file)
         return glb_path, message
     except Exception as e:
         return "", f"Error: {str(e)}"
@@ -264,7 +303,6 @@ def create_gradio_interface():
             outputs=[glb_output, status_output]
         )
         
-        # Examples
         gr.Markdown("### 📁 Example Usage")
         gr.Markdown("""
         **How to use:**
@@ -272,11 +310,6 @@ def create_gradio_interface():
         2. Click "Convert to GLB" 
         3. Download the converted `.glb` file
         4. Preview in any 3D viewer or use in your projects
-        
-        **Supported formats:**
-        - MagicaVoxel .vox files (all versions)
-        - Preserves colors and voxel positions
-        - Optimized mesh output
         """)
     
     return app