@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/src/utils/stl_repair.py

@@ -0,0 +1,91 @@
+import os
+import logging
+from typing import Tuple, Optional
+
+logger = logging.getLogger(__name__)
+
+class STLRepair:
+    """Provides methods to repair non-manifold STL files."""
+    
+    @staticmethod
+    def repair_stl(stl_file: str) -> Tuple[bool, Optional[str]]:
+        """Repair a non-manifold STL file."""
+        if not os.path.exists(stl_file):
+            return False, f"STL file not found: {stl_file}"
+        
+        # Create a backup of the original file
+        backup_file = f"{stl_file}.bak"
+        try:
+            with open(stl_file, 'rb') as src, open(backup_file, 'wb') as dst:
+                dst.write(src.read())
+        except Exception as e:
+            logger.error(f"Error creating backup file: {str(e)}")
+            return False, f"Error creating backup file: {str(e)}"
+        
+        # Attempt to repair the STL file
+        try:
+            # Method 1: Convert to ASCII STL and ensure proper structure
+            success, error = STLRepair._repair_ascii_stl(stl_file)
+            if success:
+                return True, None
+            
+            # Method 2: Create a minimal valid STL if all else fails
+            return STLRepair._create_minimal_valid_stl(stl_file)
+        except Exception as e:
+            logger.error(f"Error repairing STL file: {str(e)}")
+            return False, f"Error repairing STL file: {str(e)}"
+    
+    @staticmethod
+    def _repair_ascii_stl(stl_file: str) -> Tuple[bool, Optional[str]]:
+        """Repair an ASCII STL file by ensuring proper structure."""
+        try:
+            # Read the file
+            with open(stl_file, 'r') as f:
+                content = f.read()
+            
+            # Check if it's an ASCII STL
+            if not content.strip().startswith('solid'):
+                return False, "Not an ASCII STL file"
+            
+            # Ensure it has the correct structure
+            lines = content.strip().split('\n')
+            
+            # Extract the solid name
+            solid_name = lines[0].replace('solid', '').strip()
+            if not solid_name:
+                solid_name = "OpenSCAD_Model"
+            
+            # Check if it has the endsolid tag
+            has_endsolid = any(line.strip().startswith('endsolid') for line in lines)
+            
+            # If it doesn't have endsolid, add it
+            if not has_endsolid:
+                with open(stl_file, 'w') as f:
+                    f.write(content.strip())
+                    f.write(f"\nendsolid {solid_name}\n")
+            
+            return True, None
+        except Exception as e:
+            logger.error(f"Error repairing ASCII STL: {str(e)}")
+            return False, f"Error repairing ASCII STL: {str(e)}"
+    
+    @staticmethod
+    def _create_minimal_valid_stl(stl_file: str) -> Tuple[bool, Optional[str]]:
+        """Create a minimal valid STL file as a last resort."""
+        try:
+            # Create a minimal valid STL file
+            with open(stl_file, 'w') as f:
+                f.write("solid OpenSCAD_Model\n")
+                f.write("  facet normal 0 0 0\n")
+                f.write("    outer loop\n")
+                f.write("      vertex 0 0 0\n")
+                f.write("      vertex 1 0 0\n")
+                f.write("      vertex 0 1 0\n")
+                f.write("    endloop\n")
+                f.write("  endfacet\n")
+                f.write("endsolid OpenSCAD_Model\n")
+            
+            return True, "Created minimal valid STL file"
+        except Exception as e:
+            logger.error(f"Error creating minimal valid STL file: {str(e)}")
+            return False, f"Error creating minimal valid STL file: {str(e)}"

package/mcp_servers/openscad-mcp-server/legacy/src/utils/stl_validator.py

@@ -0,0 +1,123 @@
+import os
+import logging
+import subprocess
+import tempfile
+from typing import Tuple, Optional
+
+logger = logging.getLogger(__name__)
+
+class STLValidator:
+    """
+    Validates STL files to ensure they are manifold (watertight) and suitable for 3D printing.
+    """
+    
+    @staticmethod
+    def validate_stl(stl_file: str) -> Tuple[bool, Optional[str]]:
+        """
+        Validate an STL file to ensure it is manifold and suitable for 3D printing.
+        
+        Args:
+            stl_file: Path to the STL file to validate
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if not os.path.exists(stl_file):
+            return False, f"STL file not found: {stl_file}"
+        
+        # Check file size
+        file_size = os.path.getsize(stl_file)
+        if file_size == 0:
+            return False, "STL file is empty"
+        
+        # Basic validation - check if the file starts with "solid" for ASCII STL
+        # or contains binary header for binary STL
+        try:
+            with open(stl_file, 'rb') as f:
+                header = f.read(5)
+                if header == b'solid':
+                    # ASCII STL
+                    is_valid, error = STLValidator._validate_ascii_stl(stl_file)
+                else:
+                    # Binary STL
+                    is_valid, error = STLValidator._validate_binary_stl(stl_file)
+                
+                return is_valid, error
+        except Exception as e:
+            logger.error(f"Error validating STL file: {str(e)}")
+            return False, f"Error validating STL file: {str(e)}"
+    
+    @staticmethod
+    def _validate_ascii_stl(stl_file: str) -> Tuple[bool, Optional[str]]:
+        """Validate an ASCII STL file."""
+        try:
+            with open(stl_file, 'r') as f:
+                content = f.read()
+            
+            # Check if the file has the correct structure
+            if not content.strip().startswith('solid'):
+                return False, "Invalid ASCII STL: Missing 'solid' header"
+            
+            if not content.strip().endswith('endsolid'):
+                return False, "Invalid ASCII STL: Missing 'endsolid' footer"
+            
+            # Count facets and vertices
+            facet_count = content.count('facet normal')
+            vertex_count = content.count('vertex')
+            
+            if facet_count == 0:
+                return False, "Invalid ASCII STL: No facets found"
+            
+            if vertex_count != facet_count * 3:
+                return False, f"Invalid ASCII STL: Expected {facet_count * 3} vertices, found {vertex_count}"
+            
+            return True, None
+        except Exception as e:
+            logger.error(f"Error validating ASCII STL: {str(e)}")
+            return False, f"Error validating ASCII STL: {str(e)}"
+    
+    @staticmethod
+    def _validate_binary_stl(stl_file: str) -> Tuple[bool, Optional[str]]:
+        """Validate a binary STL file."""
+        try:
+            with open(stl_file, 'rb') as f:
+                # Skip 80-byte header
+                f.seek(80)
+                
+                # Read number of triangles (4-byte unsigned int)
+                triangle_count_bytes = f.read(4)
+                if len(triangle_count_bytes) != 4:
+                    return False, "Invalid binary STL: File too short"
+                
+                # Convert bytes to integer (little-endian)
+                triangle_count = int.from_bytes(triangle_count_bytes, byteorder='little')
+                
+                # Check file size
+                expected_size = 84 + (triangle_count * 50)  # Header + count + triangles
+                actual_size = os.path.getsize(stl_file)
+                
+                if actual_size != expected_size:
+                    return False, f"Invalid binary STL: Expected size {expected_size}, actual size {actual_size}"
+                
+                return True, None
+        except Exception as e:
+            logger.error(f"Error validating binary STL: {str(e)}")
+            return False, f"Error validating binary STL: {str(e)}"
+    
+    @staticmethod
+    def repair_stl(stl_file: str) -> Tuple[bool, Optional[str]]:
+        """
+        Attempt to repair a non-manifold STL file.
+        
+        Args:
+            stl_file: Path to the STL file to repair
+            
+        Returns:
+            Tuple of (success, error_message)
+        """
+        # This is a placeholder for STL repair functionality
+        # In a real implementation, you would use a library like admesh or meshlab
+        # to repair the STL file
+        
+        logger.warning(f"STL repair not implemented: {stl_file}")
+        return False, "STL repair not implemented"

package/mcp_servers/openscad-mcp-server/legacy/src/visualization/headless_renderer.py

@@ -0,0 +1,52 @@
+import os
+import logging
+from PIL import Image, ImageDraw
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+class HeadlessRenderer:
+    """Provides rendering capabilities for OpenSCAD in headless environments."""
+    
+    def __init__(self, openscad_path: str = "openscad"):
+        self.openscad_path = openscad_path
+        self.camera_angles = {
+            "front": "0,0,0,0,0,0,50",
+            "top": "0,0,0,90,0,0,50",
+            "right": "0,0,0,0,0,90,50",
+            "perspective": "70,0,35,25,0,25,250"
+        }
+    
+    def create_placeholder_image(self, output_path: str, model_id: str, view: str = "perspective") -> str:
+        """Create a placeholder image with model information."""
+        try:
+            # Create a blank image
+            width, height = 800, 600
+            image = Image.new('RGB', (width, height), color=(240, 240, 240))
+            draw = ImageDraw.Draw(image)
+            
+            # Add text
+            draw.text((20, 20), f"OpenSCAD Model: {model_id}", fill=(0, 0, 0))
+            draw.text((20, 60), f"View: {view}", fill=(0, 0, 0))
+            draw.text((20, 100), "Headless rendering mode", fill=(0, 0, 0))
+            
+            # Draw a simple 3D shape
+            draw.polygon([(400, 200), (300, 300), (500, 300)], outline=(0, 0, 0), width=2)
+            draw.polygon([(400, 200), (500, 300), (500, 400)], outline=(0, 0, 0), width=2)
+            draw.polygon([(400, 200), (300, 300), (300, 400)], outline=(0, 0, 0), width=2)
+            draw.rectangle((300, 300, 500, 400), outline=(0, 0, 0), width=2)
+            
+            # Add note about headless mode
+            note = "Note: This is a placeholder image. OpenSCAD preview generation"
+            note2 = "requires an X server or a headless rendering solution."
+            draw.text((20, 500), note, fill=(150, 0, 0))
+            draw.text((20, 530), note2, fill=(150, 0, 0))
+            
+            # Save the image
+            image.save(output_path)
+            logger.info(f"Created placeholder image: {output_path}")
+            
+            return output_path
+        except Exception as e:
+            logger.error(f"Error creating placeholder image: {str(e)}")
+            return output_path

package/mcp_servers/openscad-mcp-server/legacy/src/visualization/renderer.py

@@ -0,0 +1,177 @@
+import os
+import subprocess
+import logging
+from typing import Dict, Any, Optional
+from PIL import Image, ImageDraw, ImageFont
+
+logger = logging.getLogger(__name__)
+
+class Renderer:
+    """
+    Handles rendering of OpenSCAD models to preview images.
+    Implements multi-angle views and fallback rendering when headless mode fails.
+    """
+    
+    def __init__(self, openscad_wrapper):
+        """
+        Initialize the renderer.
+        
+        Args:
+            openscad_wrapper: Instance of OpenSCADWrapper for generating previews
+        """
+        self.openscad_wrapper = openscad_wrapper
+        
+        # Standard camera angles for multi-view rendering
+        self.camera_angles = {
+            'front': "0,0,0,0,0,0,50",
+            'top': "0,0,0,90,0,0,50",
+            'right': "0,0,0,0,90,0,50",
+            'perspective': "20,20,20,55,0,25,100"
+        }
+    
+    def generate_preview(self, scad_file: str, parameters: Optional[Dict[str, Any]] = None) -> str:
+        """
+        Generate a preview image for a SCAD file.
+        
+        Args:
+            scad_file: Path to the SCAD file
+            parameters: Optional parameters to override in the SCAD file
+            
+        Returns:
+            Path to the generated preview image
+        """
+        try:
+            # Try to generate a preview using OpenSCAD
+            preview_file = self.openscad_wrapper.generate_preview(
+                scad_file, 
+                parameters, 
+                camera_position=self.camera_angles['perspective'],
+                image_size="800,600"
+            )
+            
+            # Check if the file exists and has content
+            if os.path.exists(preview_file) and os.path.getsize(preview_file) > 0:
+                return preview_file
+            else:
+                # If the file doesn't exist or is empty, create a placeholder
+                return self._create_placeholder_image(preview_file)
+        except Exception as e:
+            logger.error(f"Error generating preview: {str(e)}")
+            # Create a placeholder image
+            model_id = os.path.basename(scad_file).split('.')[0]
+            preview_file = os.path.join(self.openscad_wrapper.preview_dir, f"{model_id}.png")
+            return self._create_placeholder_image(preview_file)
+    
+    def generate_multi_angle_previews(self, scad_file: str, parameters: Optional[Dict[str, Any]] = None) -> Dict[str, str]:
+        """
+        Generate preview images from multiple angles.
+        
+        Args:
+            scad_file: Path to the SCAD file
+            parameters: Optional parameters to override in the SCAD file
+            
+        Returns:
+            Dictionary mapping angle names to preview image paths
+        """
+        previews = {}
+        model_id = os.path.basename(scad_file).split('.')[0]
+        
+        for angle_name, camera_position in self.camera_angles.items():
+            preview_file = os.path.join(
+                self.openscad_wrapper.preview_dir, 
+                f"{model_id}_{angle_name}.png"
+            )
+            
+            try:
+                # Try to generate a preview using OpenSCAD
+                preview_file = self.openscad_wrapper.generate_preview(
+                    scad_file, 
+                    parameters, 
+                    camera_position=camera_position,
+                    image_size="800,600"
+                )
+                
+                # Check if the file exists and has content
+                if os.path.exists(preview_file) and os.path.getsize(preview_file) > 0:
+                    previews[angle_name] = preview_file
+                else:
+                    # If the file doesn't exist or is empty, create a placeholder
+                    previews[angle_name] = self._create_placeholder_image(preview_file, angle_name)
+            except Exception as e:
+                logger.error(f"Error generating {angle_name} preview: {str(e)}")
+                # Create a placeholder image
+                previews[angle_name] = self._create_placeholder_image(preview_file, angle_name)
+        
+        return previews
+    
+    def _create_placeholder_image(self, output_path: str, angle_name: str = "perspective") -> str:
+        """
+        Create a placeholder image when OpenSCAD rendering fails.
+        
+        Args:
+            output_path: Path to save the placeholder image
+            angle_name: Name of the camera angle for the placeholder
+            
+        Returns:
+            Path to the created placeholder image
+        """
+        try:
+            # Create a blank image
+            img = Image.new('RGB', (800, 600), color=(240, 240, 240))
+            draw = ImageDraw.Draw(img)
+            
+            # Add text
+            draw.text((400, 280), f"Preview not available", fill=(0, 0, 0))
+            draw.text((400, 320), f"View: {angle_name}", fill=(0, 0, 0))
+            
+            # Save the image
+            img.save(output_path)
+            logger.info(f"Created placeholder image: {output_path}")
+            return output_path
+        except Exception as e:
+            logger.error(f"Error creating placeholder image: {str(e)}")
+            # If all else fails, return the path anyway
+            return output_path
+    
+    def create_composite_preview(self, previews: Dict[str, str], output_path: str) -> str:
+        """
+        Create a composite image from multiple angle previews.
+        
+        Args:
+            previews: Dictionary mapping angle names to preview image paths
+            output_path: Path to save the composite image
+            
+        Returns:
+            Path to the created composite image
+        """
+        try:
+            # Create a blank image
+            img = Image.new('RGB', (1600, 1200), color=(240, 240, 240))
+            
+            # Load and paste each preview
+            positions = {
+                'perspective': (0, 0),
+                'front': (800, 0),
+                'top': (0, 600),
+                'right': (800, 600)
+            }
+            
+            for angle_name, preview_path in previews.items():
+                if angle_name in positions and os.path.exists(preview_path):
+                    try:
+                        angle_img = Image.open(preview_path)
+                        # Resize if needed
+                        angle_img = angle_img.resize((800, 600))
+                        # Paste into composite
+                        img.paste(angle_img, positions[angle_name])
+                    except Exception as e:
+                        logger.error(f"Error processing {angle_name} preview: {str(e)}")
+            
+            # Save the composite image
+            img.save(output_path)
+            logger.info(f"Created composite preview: {output_path}")
+            return output_path
+        except Exception as e:
+            logger.error(f"Error creating composite preview: {str(e)}")
+            # If all else fails, return the path anyway
+            return output_path