@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/old/src/ai/sam_segmentation.py

@@ -0,0 +1,209 @@
+"""
+SAM2 (Segment Anything Model 2) integration for object segmentation.
+"""
+
+import os
+import cv2
+import numpy as np
+import logging
+from typing import Dict, Any, List, Tuple, Optional
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class SAMSegmenter:
+    """
+    Wrapper for Segment Anything Model 2 (SAM2) for object segmentation.
+    """
+    
+    def __init__(self, model_type: str = "vit_h", checkpoint_path: Optional[str] = None,
+                use_gpu: bool = True, output_dir: str = "output/masks"):
+        """
+        Initialize the SAM2 segmenter.
+        
+        Args:
+            model_type: SAM2 model type ("vit_h", "vit_l", "vit_b")
+            checkpoint_path: Path to model checkpoint
+            use_gpu: Whether to use GPU for inference
+            output_dir: Directory to store segmentation results
+        """
+        self.model_type = model_type
+        self.checkpoint_path = checkpoint_path
+        self.use_gpu = use_gpu
+        self.output_dir = output_dir
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Model will be initialized on first use to avoid loading it unnecessarily
+        self.model = None
+        self.predictor = None
+    
+    def _initialize_model(self) -> None:
+        """
+        Initialize the SAM2 model.
+        
+        Note: This requires PyTorch and the segment-anything-2 package to be installed.
+        """
+        try:
+            # Import here to avoid dependency issues if SAM2 is not installed
+            import torch
+            from segment_anything_2 import sam_model_registry, SamPredictor
+            
+            if not self.checkpoint_path:
+                raise ValueError("SAM2 checkpoint path is required")
+            
+            # Check if checkpoint exists
+            if not os.path.exists(self.checkpoint_path):
+                raise FileNotFoundError(f"SAM2 checkpoint not found at {self.checkpoint_path}")
+            
+            # Determine device
+            device = "cuda" if self.use_gpu and torch.cuda.is_available() else "cpu"
+            
+            # Load SAM2 model
+            self.model = sam_model_registry[self.model_type](checkpoint=self.checkpoint_path)
+            self.model.to(device=device)
+            self.predictor = SamPredictor(self.model)
+            
+            logger.info(f"Initialized SAM2 model ({self.model_type}) on {device}")
+        except ImportError as e:
+            logger.error(f"Required packages not installed: {str(e)}")
+            raise
+        except Exception as e:
+            logger.error(f"Error initializing SAM2 model: {str(e)}")
+            raise
+    
+    def segment_image(self, image_path: str, points: Optional[List[Tuple[int, int]]] = None,
+                     output_dir: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Segment objects in an image using SAM2.
+        
+        Args:
+            image_path: Path to input image
+            points: Optional list of (x, y) points to guide segmentation
+            output_dir: Optional directory to save segmentation results
+            
+        Returns:
+            Dictionary containing segmentation masks and metadata
+        """
+        # Initialize model if not already initialized
+        if self.model is None:
+            self._initialize_model()
+        
+        try:
+            # Load image
+            image = cv2.imread(image_path)
+            if image is None:
+                raise ValueError(f"Could not load image from {image_path}")
+            
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            
+            # Set image in predictor
+            self.predictor.set_image(image)
+            
+            # Generate masks
+            if points:
+                # Convert points to numpy arrays
+                import numpy as np
+                point_coords = np.array(points)
+                point_labels = np.ones(len(points))
+                
+                # Generate masks from points
+                masks, scores, logits = self.predictor.predict(
+                    point_coords=point_coords,
+                    point_labels=point_labels,
+                    multimask_output=True
+                )
+            else:
+                # Automatic segmentation (using center point)
+                h, w = image.shape[:2]
+                center_point = np.array([[w//2, h//2]])
+                center_label = np.array([1])
+                
+                masks, scores, logits = self.predictor.predict(
+                    point_coords=center_point,
+                    point_labels=center_label,
+                    multimask_output=True
+                )
+            
+            # Use provided output directory or default
+            output_dir = output_dir or os.path.join(self.output_dir, Path(image_path).stem)
+            os.makedirs(output_dir, exist_ok=True)
+            
+            # Process results
+            masked_images = []
+            for i, mask in enumerate(masks):
+                # Apply mask to image
+                masked_image = self._apply_mask_to_image(image, mask)
+                
+                # Save masked image
+                output_path = os.path.join(output_dir, f"mask_{i}.png")
+                cv2.imwrite(output_path, cv2.cvtColor(masked_image, cv2.COLOR_RGB2BGR))
+                
+                masked_images.append(output_path)
+            
+            # Convert numpy arrays to lists for JSON serialization
+            result = {
+                "image_path": image_path,
+                "masked_images": masked_images,
+                "scores": scores.tolist(),
+                "mask_count": len(masks)
+            }
+            
+            return result
+        except Exception as e:
+            logger.error(f"Error segmenting image: {str(e)}")
+            raise
+    
+    def _apply_mask_to_image(self, image: np.ndarray, mask: np.ndarray) -> np.ndarray:
+        """
+        Apply mask to image, keeping only the masked region.
+        
+        Args:
+            image: Input image as numpy array
+            mask: Binary mask as numpy array
+            
+        Returns:
+            Masked image as numpy array
+        """
+        # Create a copy of the image
+        masked_image = image.copy()
+        
+        # Apply mask
+        masked_image[~mask] = [0, 0, 0]  # Set background to black
+        
+        return masked_image
+    
+    def segment_with_auto_points(self, image_path: str, num_points: int = 5,
+                               output_dir: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Segment image using automatically generated points with SAM2.
+        
+        Args:
+            image_path: Path to input image
+            num_points: Number of points to generate
+            output_dir: Optional directory to save segmentation results
+            
+        Returns:
+            Dictionary containing segmentation masks and metadata
+        """
+        # Load image
+        image = cv2.imread(image_path)
+        if image is None:
+            raise ValueError(f"Could not load image from {image_path}")
+        
+        h, w = image.shape[:2]
+        
+        # Generate points in a grid pattern
+        points = []
+        rows = int(np.sqrt(num_points))
+        cols = num_points // rows
+        
+        for i in range(rows):
+            for j in range(cols):
+                x = int(w * (j + 0.5) / cols)
+                y = int(h * (i + 0.5) / rows)
+                points.append((x, y))
+        
+        # Segment with generated points
+        return self.segment_image(image_path, points, output_dir)

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

@@ -0,0 +1,231 @@
+"""
+threestudio integration for 3D model generation from images.
+"""
+
+import os
+import subprocess
+import logging
+import json
+import tempfile
+from typing import Dict, Any, List, Optional
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class ThreeStudioGenerator:
+    """
+    Wrapper for threestudio for 3D model generation from images.
+    """
+    
+    def __init__(self, threestudio_path: str, output_dir: str = "output/models"):
+        """
+        Initialize the threestudio generator.
+        
+        Args:
+            threestudio_path: Path to threestudio installation
+            output_dir: Directory to store output files
+        """
+        self.threestudio_path = threestudio_path
+        self.output_dir = output_dir
+        
+        # Create output directory if it doesn't exist
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Validate threestudio installation
+        self._validate_installation()
+    
+    def _validate_installation(self) -> None:
+        """
+        Validate threestudio installation.
+        
+        Raises:
+            FileNotFoundError: If threestudio installation is not found
+        """
+        if not os.path.exists(self.threestudio_path):
+            raise FileNotFoundError(f"threestudio not found at {self.threestudio_path}")
+        
+        # Check for required files
+        required_files = ["launch.py", "README.md"]
+        for file in required_files:
+            if not os.path.exists(os.path.join(self.threestudio_path, file)):
+                raise FileNotFoundError(f"Required file {file} not found in threestudio directory")
+    
+    def generate_model_from_image(self, image_path: str, method: str = "zero123",
+                                 num_iterations: int = 5000, export_format: str = "obj",
+                                 config_overrides: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Generate a 3D model from an image using threestudio.
+        
+        Args:
+            image_path: Path to input image
+            method: Method to use ("zero123", "sjc", "magic3d", etc.)
+            num_iterations: Number of training iterations
+            export_format: Format to export ("obj", "glb", "ply")
+            config_overrides: Optional configuration overrides
+            
+        Returns:
+            Dictionary containing paths to generated model files
+        """
+        try:
+            # Create a unique ID for this generation
+            model_id = Path(image_path).stem
+            
+            # Create a temporary config file
+            config_file = self._create_config_file(image_path, method, num_iterations, config_overrides)
+            
+            # Run threestudio
+            output_dir = os.path.join(self.output_dir, model_id)
+            os.makedirs(output_dir, exist_ok=True)
+            
+            cmd = [
+                "python", "launch.py",
+                "--config", config_file,
+                "--train",
+                "--gpu", "0",
+                "--output_dir", output_dir
+            ]
+            
+            logger.info(f"Running threestudio with command: {' '.join(cmd)}")
+            
+            # Execute in threestudio directory
+            process = subprocess.Popen(
+                cmd,
+                cwd=self.threestudio_path,
+                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 threestudio: {stderr}")
+                raise RuntimeError(f"threestudio failed with exit code {process.returncode}")
+            
+            # Export model
+            exported_files = self._export_model(output_dir, export_format)
+            
+            return {
+                "model_id": model_id,
+                "output_dir": output_dir,
+                "exported_files": exported_files,
+                "preview_images": self._get_preview_images(output_dir)
+            }
+        except Exception as e:
+            logger.error(f"Error generating 3D model with threestudio: {str(e)}")
+            raise
+    
+    def _create_config_file(self, image_path: str, method: str, num_iterations: int,
+                          config_overrides: Optional[Dict[str, Any]] = None) -> str:
+        """
+        Create a configuration file for threestudio.
+        
+        Args:
+            image_path: Path to input image
+            method: Method to use
+            num_iterations: Number of training iterations
+            config_overrides: Optional configuration overrides
+            
+        Returns:
+            Path to the created configuration file
+        """
+        # Base configuration
+        config = {
+            "method": method,
+            "image_path": os.path.abspath(image_path),
+            "num_iterations": num_iterations,
+            "save_interval": 1000,
+            "export_interval": 1000
+        }
+        
+        # Apply overrides
+        if config_overrides:
+            config.update(config_overrides)
+        
+        # Write to temporary file
+        fd, config_file = tempfile.mkstemp(suffix=".json")
+        with os.fdopen(fd, 'w') as f:
+            json.dump(config, f, indent=2)
+        
+        return config_file
+    
+    def _export_model(self, output_dir: str, export_format: str) -> List[str]:
+        """
+        Export the model in the specified format.
+        
+        Args:
+            output_dir: Directory containing the model
+            export_format: Format to export
+            
+        Returns:
+            List of paths to exported files
+        """
+        # Find the latest checkpoint
+        checkpoints_dir = os.path.join(output_dir, "checkpoints")
+        if not os.path.exists(checkpoints_dir):
+            raise FileNotFoundError(f"Checkpoints directory not found: {checkpoints_dir}")
+        
+        # Get the latest checkpoint
+        checkpoints = sorted([f for f in os.listdir(checkpoints_dir) if f.endswith(".ckpt")])
+        if not checkpoints:
+            raise FileNotFoundError("No checkpoints found")
+        
+        latest_checkpoint = os.path.join(checkpoints_dir, checkpoints[-1])
+        
+        # Export command
+        cmd = [
+            "python", "launch.py",
+            "--config", os.path.join(output_dir, "config.yaml"),
+            "--export",
+            "--gpu", "0",
+            "--checkpoint", latest_checkpoint,
+            "--export_format", export_format
+        ]
+        
+        logger.info(f"Exporting model with command: {' '.join(cmd)}")
+        
+        # Execute in threestudio directory
+        process = subprocess.Popen(
+            cmd,
+            cwd=self.threestudio_path,
+            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 exporting model: {stderr}")
+            raise RuntimeError(f"Model export failed with exit code {process.returncode}")
+        
+        # Find exported files
+        exports_dir = os.path.join(output_dir, "exports")
+        if not os.path.exists(exports_dir):
+            raise FileNotFoundError(f"Exports directory not found: {exports_dir}")
+        
+        exported_files = [os.path.join(exports_dir, f) for f in os.listdir(exports_dir)]
+        
+        return exported_files
+    
+    def _get_preview_images(self, output_dir: str) -> List[str]:
+        """
+        Get paths to preview images.
+        
+        Args:
+            output_dir: Directory containing the model
+            
+        Returns:
+            List of paths to preview images
+        """
+        # Find preview images
+        previews_dir = os.path.join(output_dir, "images")
+        if not os.path.exists(previews_dir):
+            return []
+        
+        preview_images = [os.path.join(previews_dir, f) for f in os.listdir(previews_dir) 
+                         if f.endswith(".png") or f.endswith(".jpg")]
+        
+        return sorted(preview_images)

package/mcp_servers/openscad-mcp-server/legacy/old/src/workflow/image_to_model_pipeline.py

@@ -0,0 +1,260 @@
+"""
+Workflow orchestration for the image-to-model pipeline.
+"""
+
+import os
+import logging
+import uuid
+from typing import Dict, Any, List, Optional, Tuple
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class ImageToModelPipeline:
+    """
+    Orchestrates the workflow from text prompt to 3D model:
+    1. Generate image with Venice.ai
+    2. Segment object with SAM2
+    3. Create 3D model with threestudio
+    4. Convert to OpenSCAD for parametric editing
+    """
+    
+    def __init__(self, 
+                venice_generator,
+                sam_segmenter,
+                threestudio_generator,
+                openscad_wrapper,
+                output_dir: str = "output/pipeline"):
+        """
+        Initialize the pipeline.
+        
+        Args:
+            venice_generator: Instance of VeniceImageGenerator
+            sam_segmenter: Instance of SAMSegmenter
+            threestudio_generator: Instance of ThreeStudioGenerator
+            openscad_wrapper: Instance of OpenSCADWrapper
+            output_dir: Directory to store output files
+        """
+        self.venice_generator = venice_generator
+        self.sam_segmenter = sam_segmenter
+        self.threestudio_generator = threestudio_generator
+        self.openscad_wrapper = openscad_wrapper
+        self.output_dir = output_dir
+        
+        # Create output directories
+        os.makedirs(os.path.join(output_dir, "images"), exist_ok=True)
+        os.makedirs(os.path.join(output_dir, "masks"), exist_ok=True)
+        os.makedirs(os.path.join(output_dir, "models"), exist_ok=True)
+        os.makedirs(os.path.join(output_dir, "scad"), exist_ok=True)
+    
+    def generate_model_from_text(self, prompt: str, 
+                               venice_params: Optional[Dict[str, Any]] = None,
+                               sam_params: Optional[Dict[str, Any]] = None,
+                               threestudio_params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Generate a 3D model from a text prompt.
+        
+        Args:
+            prompt: Text description for image generation
+            venice_params: Optional parameters for Venice.ai
+            sam_params: Optional parameters for SAM2
+            threestudio_params: Optional parameters for threestudio
+            
+        Returns:
+            Dictionary containing paths to generated files and metadata
+        """
+        try:
+            # Generate a unique ID for this pipeline run
+            pipeline_id = str(uuid.uuid4())
+            logger.info(f"Starting pipeline {pipeline_id} for prompt: {prompt}")
+            
+            # Step 1: Generate image with Venice.ai
+            image_path = os.path.join(self.output_dir, "images", f"{pipeline_id}.png")
+            venice_result = self._generate_image(prompt, image_path, venice_params)
+            
+            # Step 2: Segment object with SAM2
+            masks_dir = os.path.join(self.output_dir, "masks", pipeline_id)
+            sam_result = self._segment_image(image_path, masks_dir, sam_params)
+            
+            # Get the best mask (highest score or first mask if no scores)
+            if "scores" in sam_result and sam_result["scores"]:
+                best_mask_idx = sam_result["scores"].index(max(sam_result["scores"]))
+                best_mask_path = sam_result["mask_paths"][best_mask_idx]
+            else:
+                # If no scores available, use the first mask
+                best_mask_path = sam_result["mask_paths"][0] if sam_result.get("mask_paths") else None
+                
+            if not best_mask_path:
+                raise ValueError("No valid mask generated from segmentation")
+            
+            # Step 3: Create 3D model with threestudio
+            threestudio_result = self._generate_3d_model(best_mask_path, threestudio_params)
+            
+            # Step 4: Convert to OpenSCAD for parametric editing
+            scad_result = self._convert_to_openscad(threestudio_result["exported_files"][0], pipeline_id)
+            
+            # Compile results
+            result = {
+                "pipeline_id": pipeline_id,
+                "prompt": prompt,
+                "image": venice_result,
+                "segmentation": sam_result,
+                "model_3d": threestudio_result,
+                "openscad": scad_result
+            }
+            
+            logger.info(f"Pipeline {pipeline_id} completed successfully")
+            return result
+        except Exception as e:
+            logger.error(f"Error in pipeline: {str(e)}")
+            raise
+    
+    def _generate_image(self, prompt: str, output_path: str, 
+                      params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Generate image with Venice.ai.
+        
+        Args:
+            prompt: Text description for image generation
+            output_path: Path to save the generated image
+            params: Optional parameters for Venice.ai
+            
+        Returns:
+            Dictionary containing image data and metadata
+        """
+        logger.info(f"Generating image for prompt: {prompt}")
+        
+        # Default parameters
+        default_params = {
+            "model": "fluently-xl",  # Default to fastest model
+            "width": 1024,
+            "height": 1024
+        }
+        
+        # Merge with provided parameters
+        if params:
+            default_params.update(params)
+        
+        # Generate image
+        result = self.venice_generator.generate_image(
+            prompt=prompt,
+            output_path=output_path,
+            **default_params
+        )
+        
+        logger.info(f"Image generated: {output_path}")
+        return result
+    
+    def _segment_image(self, image_path: str, output_dir: str,
+                     params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Segment object with SAM2.
+        
+        Args:
+            image_path: Path to input image
+            output_dir: Directory to save segmentation results
+            params: Optional parameters for SAM2
+            
+        Returns:
+            Dictionary containing segmentation masks and metadata
+        """
+        logger.info(f"Segmenting image: {image_path}")
+        
+        # Segment image with SAM2
+        # Check if points are provided in params
+        points = params.get("points") if params else None
+        
+        if points:
+            result = self.sam_segmenter.segment_image(
+                image_path=image_path,
+                points=points,
+                output_dir=output_dir
+            )
+        else:
+            # Use automatic point generation
+            result = self.sam_segmenter.segment_with_auto_points(
+                image_path=image_path,
+                output_dir=output_dir
+            )
+        
+        logger.info(f"Image segmented, {result.get('num_masks', 0)} masks generated")
+        return result
+    
+    def _generate_3d_model(self, image_path: str,
+                         params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Generate 3D model with threestudio.
+        
+        Args:
+            image_path: Path to input image
+            params: Optional parameters for threestudio
+            
+        Returns:
+            Dictionary containing paths to generated model files
+        """
+        logger.info(f"Generating 3D model from image: {image_path}")
+        
+        # Default parameters
+        default_params = {
+            "method": "zero123",
+            "num_iterations": 5000,
+            "export_format": "obj"
+        }
+        
+        # Merge with provided parameters
+        if params:
+            default_params.update(params)
+        
+        # Generate 3D model
+        result = self.threestudio_generator.generate_model_from_image(
+            image_path=image_path,
+            **default_params
+        )
+        
+        logger.info(f"3D model generated: {result['exported_files']}")
+        return result
+    
+    def _convert_to_openscad(self, model_path: str, model_id: str) -> Dict[str, Any]:
+        """
+        Convert 3D model to OpenSCAD format.
+        
+        Args:
+            model_path: Path to input model
+            model_id: Unique identifier for the model
+            
+        Returns:
+            Dictionary containing paths to generated files
+        """
+        logger.info(f"Converting model to OpenSCAD: {model_path}")
+        
+        # Generate OpenSCAD code for importing the model
+        scad_code = f"""// Generated OpenSCAD code for model {model_id}
+// Imported from {os.path.basename(model_path)}
+
+// Parameters
+scale_factor = 1.0;
+position_x = 0;
+position_y = 0;
+position_z = 0;
+rotation_x = 0;
+rotation_y = 0;
+rotation_z = 0;
+
+// Import and transform the model
+translate([position_x, position_y, position_z])
+rotate([rotation_x, rotation_y, rotation_z])
+scale(scale_factor)
+import("{model_path}");
+"""
+        
+        # Save SCAD code to file
+        scad_file = self.openscad_wrapper.generate_scad(scad_code, model_id)
+        
+        # Generate previews
+        previews = self.openscad_wrapper.generate_multi_angle_previews(scad_file)
+        
+        return {
+            "scad_file": scad_file,
+            "previews": previews,
+            "model_path": model_path
+        }