@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/src/models/code_generator.py

@@ -0,0 +1,321 @@
+import os
+import logging
+import uuid
+from typing import Dict, Any, List, Tuple, Optional
+
+logger = logging.getLogger(__name__)
+
+class CodeGenerator:
+    """
+    Generates OpenSCAD code from natural language descriptions and parameters.
+    Implements translation of requirements to OpenSCAD primitives and modules.
+    """
+    
+    def __init__(self, scad_templates_dir: str, output_dir: str, ai_service=None):
+        """
+        Initialize the code generator.
+        
+        Args:
+            scad_templates_dir: Directory containing SCAD template files
+            output_dir: Directory to store generated SCAD files
+            ai_service: Optional AI service for enhanced code generation
+        """
+        self.scad_templates_dir = scad_templates_dir
+        self.output_dir = output_dir
+        self.ai_service = ai_service
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Map of shape types to their corresponding module names
+        self.shape_module_map = {
+            'cube': 'parametric_cube',
+            'sphere': 'parametric_sphere',
+            'cylinder': 'parametric_cylinder',
+            'box': 'hollow_box',
+            'rounded_box': 'rounded_box',
+            'container': 'rounded_container',
+            'tube': 'tube',
+            'cone': 'cone',
+            'wedge': 'wedge',
+            'rounded_cylinder': 'rounded_cylinder',
+            'torus': 'torus',
+            'hexagonal_prism': 'hexagonal_prism',
+            'text': 'text_3d',
+            'prism': 'triangular_prism',
+            'custom': 'custom_shape'
+        }
+        
+        # Parameter mapping from natural language to OpenSCAD parameters
+        self.parameter_map = {
+            'width': 'width',
+            'depth': 'depth',
+            'height': 'height',
+            'radius': 'radius',
+            'thickness': 'thickness',
+            'segments': 'segments',
+            'center': 'center',
+            'inner_radius': 'inner_radius',
+            'outer_radius': 'outer_radius',
+            'corner_radius': 'corner_radius',
+            'text': 'text',
+            'size': 'size',
+            'font': 'font',
+            'base_radius': 'base_radius',
+            'major_radius': 'major_radius',
+            'minor_radius': 'minor_radius',
+            'angle': 'angle',
+            'scale': 'scale',
+            'resolution': 'resolution'
+        }
+    
+    def generate_code(self, model_type: str, parameters: Dict[str, Any], description: Optional[str] = None) -> str:
+        """
+        Generate OpenSCAD code for a given model type and parameters.
+        
+        Args:
+            model_type: Type of model to generate
+            parameters: Dictionary of parameters for the model
+            description: Optional natural language description for AI-driven generation
+            
+        Returns:
+            Path to the generated SCAD file
+        """
+        # Generate a unique ID for the model
+        model_id = str(uuid.uuid4())
+        scad_file = os.path.join(self.output_dir, f"{model_id}.scad")
+        
+        # Check if we should use AI-driven generation for complex models
+        if model_type == 'custom' and description and self.ai_service:
+            scad_code = self._generate_ai_driven_code(description, parameters)
+        else:
+            # Get the module name for the model type
+            module_name = self.shape_module_map.get(model_type)
+            if not module_name:
+                raise ValueError(f"Unsupported model type: {model_type}")
+            
+            # Map parameters to OpenSCAD parameter names
+            scad_params = self._map_parameters(parameters)
+            
+            # Generate the OpenSCAD code
+            scad_code = self._generate_scad_code(module_name, scad_params)
+        
+        # Write the code to a file
+        with open(scad_file, 'w') as f:
+            f.write(scad_code)
+        
+        logger.info(f"Generated OpenSCAD code: {scad_file}")
+        return scad_file
+    
+    def update_code(self, scad_file: str, parameters: Dict[str, Any]) -> str:
+        """
+        Update an existing SCAD file with new parameters.
+        
+        Args:
+            scad_file: Path to the SCAD file to update
+            parameters: New parameters to apply
+            
+        Returns:
+            Path to the updated SCAD file
+        """
+        if not os.path.exists(scad_file):
+            raise FileNotFoundError(f"SCAD file not found: {scad_file}")
+        
+        # Read the existing SCAD file
+        with open(scad_file, 'r') as f:
+            scad_code = f.read()
+        
+        # Determine the module name from the code
+        module_name = None
+        for shape_type, module in self.shape_module_map.items():
+            if module in scad_code:
+                module_name = module
+                break
+        
+        if not module_name:
+            raise ValueError("Could not determine module name from existing SCAD file")
+        
+        # Map parameters to OpenSCAD parameter names
+        scad_params = self._map_parameters(parameters)
+        
+        # Generate the updated OpenSCAD code
+        updated_code = self._generate_scad_code(module_name, scad_params)
+        
+        # Write the updated code to the file
+        with open(scad_file, 'w') as f:
+            f.write(updated_code)
+        
+        logger.info(f"Updated OpenSCAD code: {scad_file}")
+        return scad_file
+    
+    def combine_models(self, operations: List[Dict[str, Any]]) -> str:
+        """
+        Combine multiple models using CSG operations.
+        
+        Args:
+            operations: List of operations, each containing:
+                - model_type: Type of model
+                - parameters: Parameters for the model
+                - operation: CSG operation (union, difference, intersection)
+                - transform: Optional transformation to apply
+            
+        Returns:
+            Path to the generated SCAD file
+        """
+        # Generate a unique ID for the combined model
+        model_id = str(uuid.uuid4())
+        scad_file = os.path.join(self.output_dir, f"{model_id}.scad")
+        
+        # Include the basic shapes library
+        scad_code = f"""// Combined model
+include <{os.path.join(self.scad_templates_dir, "basic_shapes.scad")}>;
+
+"""
+        
+        # Process each operation
+        current_op = None
+        for i, op in enumerate(operations):
+            model_type = op.get('model_type')
+            parameters = op.get('parameters', {})
+            operation = op.get('operation')
+            transform = op.get('transform')
+            
+            # Get the module name for the model type
+            if model_type is None:
+                raise ValueError("Model type cannot be None")
+            module_name = self.shape_module_map.get(str(model_type))
+            if not module_name:
+                raise ValueError(f"Unsupported model type: {model_type}")
+            
+            # Map parameters to OpenSCAD parameter names
+            scad_params = self._map_parameters(parameters)
+            
+            # Format parameters for the module call
+            params_str = ", ".join([f"{k}={v}" for k, v in scad_params.items()])
+            
+            # Start or continue the CSG operation chain
+            if i == 0:
+                # First operation doesn't need an operator
+                if operation:
+                    current_op = operation
+                    scad_code += f"{operation}() {{\n"
+                
+                # Add the module call with optional transformation
+                if transform:
+                    scad_code += f"    {transform} {module_name}({params_str});\n"
+                else:
+                    scad_code += f"    {module_name}({params_str});\n"
+            else:
+                # Check if we need to close the previous operation and start a new one
+                if operation and operation != current_op:
+                    if current_op:
+                        scad_code += "}\n\n"
+                    current_op = operation
+                    scad_code += f"{operation}() {{\n"
+                
+                # Add the module call with optional transformation
+                if transform:
+                    scad_code += f"    {transform} {module_name}({params_str});\n"
+                else:
+                    scad_code += f"    {module_name}({params_str});\n"
+        
+        # Close the final operation if needed
+        if current_op:
+            scad_code += "}\n"
+        
+        # Write the code to a file
+        with open(scad_file, 'w') as f:
+            f.write(scad_code)
+        
+        logger.info(f"Generated combined OpenSCAD code: {scad_file}")
+        return scad_file
+    
+    def _map_parameters(self, parameters: Dict[str, Any]) -> Dict[str, Any]:
+        """Map natural language parameters to OpenSCAD parameters."""
+        scad_params = {}
+        
+        for param, value in parameters.items():
+            # Map the parameter name if it exists in the mapping
+            scad_param = self.parameter_map.get(param, param)
+            
+            # Format the value appropriately for OpenSCAD
+            if isinstance(value, bool):
+                scad_params[scad_param] = str(value).lower()
+            elif isinstance(value, str):
+                if value.lower() == 'true' or value.lower() == 'false':
+                    scad_params[scad_param] = value.lower()
+                else:
+                    # For text parameters, add quotes
+                    scad_params[scad_param] = f'"{value}"'
+            else:
+                scad_params[scad_param] = value
+        
+        return scad_params
+    
+    def _generate_scad_code(self, module_name: str, parameters: Dict[str, Any]) -> str:
+        """Generate OpenSCAD code for a module with parameters."""
+        # Include the basic shapes library
+        scad_code = f"""// Generated OpenSCAD code
+include <{os.path.join(self.scad_templates_dir, "basic_shapes.scad")}>;
+
+// Parameters
+"""
+        
+        # Add parameter declarations
+        for param, value in parameters.items():
+            scad_code += f"{param} = {value};\n"
+        
+        # Add the module call
+        scad_code += f"\n// Model\n{module_name}("
+        
+        # Add parameters to the module call
+        param_list = [f"{param}={param}" for param in parameters.keys()]
+        scad_code += ", ".join(param_list)
+        
+        scad_code += ");\n"
+        
+        return scad_code
+        
+    def _generate_ai_driven_code(self, description: str, parameters: Dict[str, Any]) -> str:
+        """
+        Generate OpenSCAD code using AI-driven techniques based on natural language description.
+        
+        Args:
+            description: Natural language description of the model
+            parameters: Dictionary of parameters for the model
+            
+        Returns:
+            Generated OpenSCAD code
+        """
+        if not self.ai_service:
+            logger.warning("AI service not available, falling back to basic shape generation")
+            # Fall back to a basic cube if AI service is not available
+            return self._generate_scad_code('parametric_cube', {'width': 10, 'height': 10, 'depth': 10})
+        
+        try:
+            # Use the AI service to generate OpenSCAD code
+            logger.info(f"Generating OpenSCAD code from description: {description}")
+            
+            # Prepare context for the AI service
+            context = {
+                "description": description,
+                "parameters": parameters,
+                "templates_dir": self.scad_templates_dir
+            }
+            
+            # Call the AI service to generate code
+            scad_code = self.ai_service.generate_openscad_code(context)
+            
+            # Ensure the code includes the basic shapes library
+            if "include <" not in scad_code:
+                scad_code = f"""// AI-generated OpenSCAD code
+include <{os.path.join(self.scad_templates_dir, "basic_shapes.scad")}>;
+
+{scad_code}
+"""
+            
+            return scad_code
+        except Exception as e:
+            logger.error(f"Error generating AI-driven code: {e}")
+            # Fall back to a basic shape if there's an error
+            return self._generate_scad_code('parametric_cube', {'width': 10, 'height': 10, 'depth': 10})

package/mcp_servers/openscad-mcp-server/legacy/src/models/cuda_mvs.py

@@ -0,0 +1,209 @@
+"""
+CUDA Multi-View Stereo wrapper for 3D reconstruction from multiple images.
+"""
+
+import os
+import subprocess
+import logging
+import json
+from typing import Dict, Any, List, Optional
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class CUDAMultiViewStereo:
+    """
+    Wrapper for CUDA Multi-View Stereo for 3D reconstruction from multiple images.
+    """
+    
+    def __init__(self, cuda_mvs_path: str, output_dir: str = "output/models"):
+        """
+        Initialize the CUDA MVS wrapper.
+        
+        Args:
+            cuda_mvs_path: Path to CUDA MVS installation
+            output_dir: Directory to store output files
+        """
+        self.cuda_mvs_path = cuda_mvs_path
+        self.output_dir = output_dir
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Validate installation
+        self._validate_installation()
+    
+    def _validate_installation(self) -> None:
+        """
+        Validate CUDA MVS installation.
+        
+        Raises:
+            FileNotFoundError: If CUDA MVS installation is not found
+        """
+        if not os.path.exists(self.cuda_mvs_path):
+            raise FileNotFoundError(f"CUDA MVS not found at {self.cuda_mvs_path}")
+        
+        # Check for required executables
+        required_files = ["app_patch_match_mvs"]
+        for file in required_files:
+            exec_path = os.path.join(self.cuda_mvs_path, "build", file)
+            if not os.path.exists(exec_path):
+                raise FileNotFoundError(f"Required executable {file} not found at {exec_path}")
+    
+    def generate_model_from_images(self, image_paths: List[str], 
+                                camera_params: Optional[Dict[str, Any]] = None,
+                                output_name: str = "model") -> Dict[str, Any]:
+        """
+        Generate a 3D model from multiple images using CUDA MVS.
+        
+        Args:
+            image_paths: List of paths to input images
+            camera_params: Optional camera parameters
+            output_name: Name for the output files
+            
+        Returns:
+            Dictionary containing paths to generated model files
+        """
+        try:
+            # Create a unique directory for this reconstruction
+            model_dir = os.path.join(self.output_dir, output_name)
+            os.makedirs(model_dir, exist_ok=True)
+            
+            # Create a camera parameters file if provided
+            params_file = None
+            if camera_params:
+                params_file = os.path.join(model_dir, "camera_params.json")
+                with open(params_file, 'w') as f:
+                    json.dump(camera_params, f, indent=2)
+            
+            # Generate camera parameters if not provided
+            if not params_file:
+                params_file = self._generate_camera_params(image_paths, model_dir)
+            
+            # Generate point cloud
+            point_cloud_file = os.path.join(model_dir, f"{output_name}.ply")
+            
+            # Run CUDA MVS
+            cmd = [
+                os.path.join(self.cuda_mvs_path, "build", "app_patch_match_mvs"),
+                "--image_dir", os.path.dirname(image_paths[0]),
+                "--camera_params", params_file,
+                "--output_file", point_cloud_file
+            ]
+            
+            logger.info(f"Running CUDA MVS with command: {' '.join(cmd)}")
+            
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            # Wait for process to complete
+            stdout, stderr = process.communicate()
+            
+            if process.returncode != 0:
+                logger.error(f"Error running CUDA MVS: {stderr}")
+                raise RuntimeError(f"CUDA MVS failed with exit code {process.returncode}")
+            
+            # Check if output file was created
+            if not os.path.exists(point_cloud_file):
+                raise FileNotFoundError(f"Output point cloud file not found at {point_cloud_file}")
+            
+            return {
+                "model_id": output_name,
+                "output_dir": model_dir,
+                "point_cloud_file": point_cloud_file,
+                "camera_params_file": params_file,
+                "input_images": image_paths
+            }
+        
+        except Exception as e:
+            logger.error(f"Error generating 3D model with CUDA MVS: {str(e)}")
+            raise
+    
+    def _generate_camera_params(self, image_paths: List[str], model_dir: str) -> str:
+        """
+        Generate camera parameters from images.
+        
+        Args:
+            image_paths: List of paths to input images
+            model_dir: Directory to save parameter file
+            
+        Returns:
+            Path to camera parameters file
+        """
+        # This is a simplified version for demonstration
+        # In a real implementation, this would use SfM or camera estimation
+        
+        params = []
+        for i, img_path in enumerate(image_paths):
+            # Extract image dimensions
+            from PIL import Image
+            with Image.open(img_path) as img:
+                width, height = img.size
+            
+            # Generate simple camera parameters
+            # In reality, these would be estimated from the images
+            # or provided by the user
+            params.append({
+                "image_id": i,
+                "image_name": os.path.basename(img_path),
+                "width": width,
+                "height": height,
+                "camera": {
+                    "model": "PINHOLE",
+                    "focal_length": min(width, height),
+                    "principal_point": [width / 2, height / 2],
+                    "rotation": [1, 0, 0, 0, 1, 0, 0, 0, 1],
+                    "translation": [0, 0, 0]
+                }
+            })
+        
+        # Write parameters to file
+        params_file = os.path.join(model_dir, "camera_params.json")
+        with open(params_file, 'w') as f:
+            json.dump(params, f, indent=2)
+        
+        return params_file
+    
+    def convert_ply_to_obj(self, ply_file: str, output_dir: Optional[str] = None) -> str:
+        """
+        Convert PLY point cloud to OBJ mesh.
+        
+        Args:
+            ply_file: Path to input PLY file
+            output_dir: Directory to save output OBJ file
+            
+        Returns:
+            Path to output OBJ file
+        """
+        # In a real implementation, this would use a mesh reconstruction library
+        # such as Open3D or PyMeshLab to convert the point cloud to a mesh
+        
+        if not output_dir:
+            output_dir = os.path.dirname(ply_file)
+        
+        # Generate output file path
+        obj_file = os.path.join(output_dir, f"{Path(ply_file).stem}.obj")
+        
+        logger.info(f"Converting PLY to OBJ: {ply_file} -> {obj_file}")
+        
+        # This is a placeholder for the actual conversion
+        # In a real implementation, you would use a library like Open3D:
+        # import open3d as o3d
+        # pcd = o3d.io.read_point_cloud(ply_file)
+        # mesh = o3d.geometry.TriangleMesh.create_from_point_cloud_poisson(pcd)[0]
+        # o3d.io.write_triangle_mesh(obj_file, mesh)
+        
+        # For now, we'll just create a dummy OBJ file
+        with open(obj_file, 'w') as f:
+            f.write(f"# Converted from {os.path.basename(ply_file)}\n")
+            f.write("# This is a placeholder OBJ file\n")
+            f.write("v 0 0 0\n")
+            f.write("v 1 0 0\n")
+            f.write("v 0 1 0\n")
+            f.write("f 1 2 3\n")
+        
+        return obj_file

package/mcp_servers/openscad-mcp-server/legacy/src/models/scad_templates/basic_shapes.scad

@@ -0,0 +1,144 @@
+// Basic Shapes Library for OpenSCAD MCP Server
+// Contains reusable modules for common geometric patterns
+
+// Basic cube with optional center parameter
+module parametric_cube(width=10, depth=10, height=10, center=false) {
+    cube([width, depth, height], center=center);
+}
+
+// Basic sphere with customizable segments
+module parametric_sphere(radius=10, segments=32) {
+    $fn = segments;
+    sphere(r=radius);
+}
+
+// Basic cylinder with customizable segments
+module parametric_cylinder(radius=10, height=20, center=false, segments=32) {
+    $fn = segments;
+    cylinder(h=height, r=radius, center=center);
+}
+
+// Hollow box with customizable wall thickness
+module hollow_box(width=30, depth=20, height=15, thickness=2) {
+    difference() {
+        cube([width, depth, height]);
+        translate([thickness, thickness, thickness])
+        cube([width - 2*thickness, depth - 2*thickness, height - thickness]);
+    }
+}
+
+// Rounded box with customizable corner radius
+module rounded_box(width=30, depth=20, height=15, radius=3, segments=32) {
+    $fn = segments;
+    hull() {
+        translate([radius, radius, radius])
+        sphere(r=radius);
+        
+        translate([width-radius, radius, radius])
+        sphere(r=radius);
+        
+        translate([radius, depth-radius, radius])
+        sphere(r=radius);
+        
+        translate([width-radius, depth-radius, radius])
+        sphere(r=radius);
+        
+        translate([radius, radius, height-radius])
+        sphere(r=radius);
+        
+        translate([width-radius, radius, height-radius])
+        sphere(r=radius);
+        
+        translate([radius, depth-radius, height-radius])
+        sphere(r=radius);
+        
+        translate([width-radius, depth-radius, height-radius])
+        sphere(r=radius);
+    }
+}
+
+// Rounded hollow box (container with rounded corners)
+module rounded_container(width=30, depth=20, height=15, radius=3, thickness=2, segments=32) {
+    $fn = segments;
+    difference() {
+        rounded_box(width, depth, height, radius, segments);
+        translate([thickness, thickness, thickness])
+        rounded_box(
+            width - 2*thickness, 
+            depth - 2*thickness, 
+            height - thickness + 0.01, // Slight overlap to ensure clean difference
+            radius - thickness > 0 ? radius - thickness : 0.1,
+            segments
+        );
+    }
+}
+
+// Tube (hollow cylinder)
+module tube(outer_radius=10, inner_radius=8, height=20, center=false, segments=32) {
+    $fn = segments;
+    difference() {
+        cylinder(h=height, r=outer_radius, center=center);
+        cylinder(h=height+0.01, r=inner_radius, center=center);
+    }
+}
+
+// Cone
+module cone(bottom_radius=10, top_radius=0, height=20, center=false, segments=32) {
+    $fn = segments;
+    cylinder(h=height, r1=bottom_radius, r2=top_radius, center=center);
+}
+
+// Wedge (triangular prism)
+module wedge(width=20, depth=20, height=10) {
+    polyhedron(
+        points=[
+            [0,0,0], [width,0,0], [width,depth,0], [0,depth,0],
+            [0,0,height], [width,0,0], [0,depth,0]
+        ],
+        faces=[
+            [0,1,2,3], // bottom
+            [4,5,1,0], // front
+            [4,0,3,6], // left
+            [6,3,2,5], // back
+            [4,6,5], // top
+        ]
+    );
+}
+
+// Rounded cylinder (cylinder with rounded top and bottom)
+module rounded_cylinder(radius=10, height=20, corner_radius=2, center=false, segments=32) {
+    $fn = segments;
+    hull() {
+        translate([0, 0, corner_radius])
+        cylinder(h=height - 2*corner_radius, r=radius, center=center);
+        
+        translate([0, 0, corner_radius])
+        rotate_extrude()
+        translate([radius - corner_radius, 0, 0])
+        circle(r=corner_radius);
+        
+        translate([0, 0, height - corner_radius])
+        rotate_extrude()
+        translate([radius - corner_radius, 0, 0])
+        circle(r=corner_radius);
+    }
+}
+
+// Torus (donut shape)
+module torus(outer_radius=20, inner_radius=5, segments=32) {
+    $fn = segments;
+    rotate_extrude()
+    translate([outer_radius - inner_radius, 0, 0])
+    circle(r=inner_radius);
+}
+
+// Hexagonal prism
+module hexagonal_prism(radius=10, height=20, center=false) {
+    cylinder(h=height, r=radius, $fn=6, center=center);
+}
+
+// Text with customizable parameters
+module text_3d(text="OpenSCAD", size=10, height=3, font="Liberation Sans", halign="center", valign="center") {
+    linear_extrude(height=height)
+    text(text=text, size=size, font=font, halign=halign, valign=valign);
+}