@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/test_image_to_model_pipeline.py

@@ -0,0 +1,145 @@
+import os
+import sys
+import logging
+import argparse
+from pathlib import Path
+from typing import Dict, Any, List, Optional, Tuple
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Add project root to path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import components
+from src.ai.venice_api import VeniceImageGenerator
+from src.ai.sam_segmentation import SAMSegmenter
+from src.models.threestudio_generator import ThreeStudioGenerator
+from src.openscad_wrapper.wrapper import OpenSCADWrapper
+from src.workflow.image_to_model_pipeline import ImageToModelPipeline
+from src.config import (
+    VENICE_API_KEY, IMAGES_DIR, MASKS_DIR, MODELS_DIR, SCAD_DIR,
+    SAM2_CHECKPOINT_PATH, SAM2_MODEL_TYPE, SAM2_USE_GPU, THREESTUDIO_PATH
+)
+
+def test_pipeline(prompt: str, output_dir: Optional[str] = None, 
+                 venice_model: str = "fluently-xl", skip_steps: List[str] = None):
+    """
+    Test the full image-to-model pipeline.
+    
+    Args:
+        prompt: Text prompt for image generation
+        output_dir: Directory to save pipeline results
+        venice_model: Venice.ai model to use for image generation
+        skip_steps: List of steps to skip ('image', 'segment', 'model3d', 'openscad')
+    """
+    # Use default output directory if not provided
+    if not output_dir:
+        output_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "output", "pipeline_test")
+    
+    # Create output directory
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Initialize skip_steps if None
+    skip_steps = skip_steps or []
+    
+    logger.info(f"Testing image-to-model pipeline with prompt: {prompt}")
+    logger.info(f"Output directory: {output_dir}")
+    logger.info(f"Venice model: {venice_model}")
+    logger.info(f"Skipping steps: {skip_steps}")
+    
+    try:
+        # Initialize components
+        logger.info("Initializing pipeline components...")
+        
+        # Venice.ai image generator
+        venice_generator = VeniceImageGenerator(
+            api_key=VENICE_API_KEY,
+            output_dir=os.path.join(output_dir, "images")
+        )
+        
+        # SAM2 segmenter
+        sam_segmenter = SAMSegmenter(
+            model_type=SAM2_MODEL_TYPE,
+            checkpoint_path=SAM2_CHECKPOINT_PATH,
+            use_gpu=SAM2_USE_GPU,
+            output_dir=os.path.join(output_dir, "masks")
+        )
+        
+        # ThreeStudio generator
+        threestudio_generator = ThreeStudioGenerator(
+            threestudio_path=THREESTUDIO_PATH,
+            output_dir=os.path.join(output_dir, "models")
+        )
+        
+        # OpenSCAD wrapper
+        openscad_wrapper = OpenSCADWrapper(
+            output_dir=os.path.join(output_dir, "scad")
+        )
+        
+        # Initialize pipeline
+        pipeline = ImageToModelPipeline(
+            venice_generator=venice_generator,
+            sam_segmenter=sam_segmenter,
+            threestudio_generator=threestudio_generator,
+            openscad_wrapper=openscad_wrapper,
+            output_dir=output_dir
+        )
+        
+        # Run pipeline with custom steps
+        if 'image' in skip_steps:
+            # Skip image generation, use a test image
+            logger.info("Skipping image generation, using test image")
+            image_path = os.path.join(IMAGES_DIR, "test_image.png")
+            if not os.path.exists(image_path):
+                logger.error(f"Test image not found: {image_path}")
+                return
+            
+            # TODO: Implement custom pipeline execution with skipped steps
+            logger.info("Custom pipeline execution not implemented yet")
+            return
+        else:
+            # Run full pipeline
+            logger.info("Running full pipeline...")
+            result = pipeline.generate_model_from_text(
+                prompt=prompt,
+                venice_params={"model": venice_model},
+                sam_params={},
+                threestudio_params={}
+            )
+            
+            # Print results
+            logger.info("Pipeline completed successfully")
+            logger.info(f"Pipeline ID: {result.get('pipeline_id')}")
+            logger.info(f"Image path: {result.get('image', {}).get('local_path')}")
+            logger.info(f"Mask count: {result.get('segmentation', {}).get('num_masks', 0)}")
+            logger.info(f"3D model path: {result.get('model_3d', {}).get('exported_files', [])}")
+            logger.info(f"OpenSCAD file: {result.get('openscad', {}).get('scad_file')}")
+            
+            return result
+    
+    except Exception as e:
+        logger.error(f"Error in pipeline: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return None
+
+if __name__ == "__main__":
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(description="Test image-to-model pipeline")
+    parser.add_argument("prompt", help="Text prompt for image generation")
+    parser.add_argument("--output-dir", help="Directory to save pipeline results")
+    parser.add_argument("--venice-model", default="fluently-xl", help="Venice.ai model to use")
+    parser.add_argument("--skip", nargs="+", choices=["image", "segment", "model3d", "openscad"],
+                        help="Steps to skip in the pipeline")
+    
+    args = parser.parse_args()
+    
+    # Run test
+    test_pipeline(
+        args.prompt,
+        args.output_dir,
+        args.venice_model,
+        args.skip
+    )

package/mcp_servers/openscad-mcp-server/legacy/test_model_selection.py

@@ -0,0 +1,41 @@
+import os
+import logging
+from src.ai.venice_api import VeniceImageGenerator
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Venice.ai API key (replace with your own or use environment variable)
+VENICE_API_KEY = os.getenv("VENICE_API_KEY", "B9Y68yQgatQw8wmpmnIMYcGip1phCt-43CS0OktZU6")
+OUTPUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "output", "images")
+
+# Test natural language model selection
+def test_model_selection():
+    """Test the natural language model selection functionality."""
+    # Initialize the Venice API client
+    venice_generator = VeniceImageGenerator(VENICE_API_KEY, OUTPUT_DIR)
+    
+    # Test cases - natural language preferences to expected model mappings
+    test_cases = [
+        ("default", "fluently-xl"),
+        ("fastest model please", "fluently-xl"),
+        ("I need a high quality image", "flux-dev"),
+        ("create an uncensored image", "flux-dev-uncensored"),
+        ("make it realistic", "pony-realism"),
+        ("I want something artistic", "lustify-sdxl"),
+        ("use stable diffusion", "stable-diffusion-3.5"),
+        ("invalid model name", "fluently-xl"),  # Should default to fluently-xl
+    ]
+    
+    # Run tests
+    for preference, expected_model in test_cases:
+        mapped_model = venice_generator.map_model_preference(preference)
+        logger.info(f"Preference: '{preference}' -> Model: '{mapped_model}'")
+        assert mapped_model == expected_model, f"Expected {expected_model}, got {mapped_model}"
+    
+    logger.info("All model preference mappings tests passed!")
+
+if __name__ == "__main__":
+    logger.info("Starting Venice.ai model selection mapping tests")
+    test_model_selection()

package/mcp_servers/openscad-mcp-server/legacy/test_multi_view_pipeline.py

@@ -0,0 +1,290 @@
+"""
+Test script for multi-view to model pipeline.
+"""
+
+import os
+import sys
+import logging
+import unittest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+
+# Add the src directory to the path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.workflow.multi_view_to_model_pipeline import MultiViewToModelPipeline
+from src.ai.gemini_api import GeminiImageGenerator
+from src.models.cuda_mvs import CUDAMultiViewStereo
+from src.workflow.image_approval import ImageApprovalTool
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TestMultiViewPipeline(unittest.TestCase):
+    """
+    Test cases for multi-view to model pipeline.
+    """
+    
+    def setUp(self):
+        """
+        Set up test environment.
+        """
+        # Create test directories
+        self.test_output_dir = "output/test_pipeline"
+        self.test_images_dir = os.path.join(self.test_output_dir, "images")
+        self.test_models_dir = os.path.join(self.test_output_dir, "models")
+        
+        for directory in [self.test_output_dir, self.test_images_dir, self.test_models_dir]:
+            os.makedirs(directory, exist_ok=True)
+        
+        # Create mock CUDA MVS path
+        self.cuda_mvs_path = "mock_cuda_mvs"
+        os.makedirs(os.path.join(self.cuda_mvs_path, "build"), exist_ok=True)
+        
+        # Create mock executable
+        with open(os.path.join(self.cuda_mvs_path, "build", "app_patch_match_mvs"), "w") as f:
+            f.write("#!/bin/bash\necho 'Mock CUDA MVS'\n")
+        os.chmod(os.path.join(self.cuda_mvs_path, "build", "app_patch_match_mvs"), 0o755)
+        
+        # Create mock components
+        self.mock_gemini = MagicMock(spec=GeminiImageGenerator)
+        self.mock_cuda_mvs = MagicMock(spec=CUDAMultiViewStereo)
+        self.mock_approval = MagicMock(spec=ImageApprovalTool)
+        
+        # Configure mock responses
+        self.configure_mocks()
+        
+        # Create the pipeline with mock components
+        self.pipeline = MultiViewToModelPipeline(
+            gemini_generator=self.mock_gemini,
+            cuda_mvs=self.mock_cuda_mvs,
+            approval_tool=self.mock_approval,
+            output_dir=self.test_output_dir
+        )
+    
+    def configure_mocks(self):
+        """
+        Configure mock responses for components.
+        """
+        # Mock Gemini image generation
+        def mock_generate_image(prompt, **kwargs):
+            image_path = os.path.join(self.test_images_dir, f"{prompt[:10].replace(' ', '_')}.png")
+            with open(image_path, "w") as f:
+                f.write(f"Mock image for {prompt}")
+            return {
+                "prompt": prompt,
+                "local_path": image_path,
+                "image_data": b"mock_image_data"
+            }
+        
+        def mock_generate_multiple_views(prompt, num_views, **kwargs):
+            results = []
+            for i in range(num_views):
+                image_path = os.path.join(self.test_images_dir, f"view_{i}.png")
+                with open(image_path, "w") as f:
+                    f.write(f"Mock image for {prompt} - view {i}")
+                results.append({
+                    "prompt": f"{prompt} - view {i}",
+                    "local_path": image_path,
+                    "image_data": b"mock_image_data",
+                    "view_direction": f"view {i}",
+                    "view_index": i + 1
+                })
+            return results
+        
+        self.mock_gemini.generate_image.side_effect = mock_generate_image
+        self.mock_gemini.generate_multiple_views.side_effect = mock_generate_multiple_views
+        
+        # Mock CUDA MVS
+        def mock_generate_model(image_paths, **kwargs):
+            model_dir = os.path.join(self.test_models_dir, "mock_model")
+            os.makedirs(model_dir, exist_ok=True)
+            
+            point_cloud_file = os.path.join(model_dir, "mock_model.ply")
+            with open(point_cloud_file, "w") as f:
+                f.write("Mock point cloud")
+            
+            obj_file = os.path.join(model_dir, "mock_model.obj")
+            with open(obj_file, "w") as f:
+                f.write("Mock OBJ file")
+            
+            return {
+                "model_id": "mock_model",
+                "output_dir": model_dir,
+                "point_cloud_file": point_cloud_file,
+                "obj_file": obj_file,
+                "input_images": image_paths
+            }
+        
+        self.mock_cuda_mvs.generate_model_from_images.side_effect = mock_generate_model
+        self.mock_cuda_mvs.convert_ply_to_obj.return_value = os.path.join(self.test_models_dir, "mock_model", "mock_model.obj")
+        
+        # Mock approval tool
+        def mock_present_image(image_path, metadata):
+            return {
+                "approval_id": os.path.basename(image_path).split('.')[0],
+                "image_path": image_path,
+                "image_url": f"/images/{os.path.basename(image_path)}",
+                "metadata": metadata or {}
+            }
+        
+        def mock_process_approval(approval_id, approved, image_path):
+            if approved:
+                approved_path = os.path.join(self.test_output_dir, "approved", os.path.basename(image_path))
+                os.makedirs(os.path.dirname(approved_path), exist_ok=True)
+                with open(approved_path, "w") as f:
+                    f.write(f"Approved image {approval_id}")
+                
+                return {
+                    "approval_id": approval_id,
+                    "approved": True,
+                    "original_path": image_path,
+                    "approved_path": approved_path
+                }
+            else:
+                return {
+                    "approval_id": approval_id,
+                    "approved": False,
+                    "original_path": image_path
+                }
+        
+        self.mock_approval.present_image_for_approval.side_effect = mock_present_image
+        self.mock_approval.process_approval.side_effect = mock_process_approval
+        self.mock_approval.get_approved_images.return_value = [
+            os.path.join(self.test_output_dir, "approved", f"view_{i}.png") for i in range(3)
+        ]
+    
+    def test_generate_model_from_text(self):
+        """
+        Test generating a 3D model from text prompt.
+        """
+        # Test parameters
+        prompt = "A low-poly rabbit"
+        num_views = 3
+        
+        # Mock approvals - approve all images
+        def mock_get_approval(approval_request):
+            return True
+        
+        # Call the method
+        result = self.pipeline.generate_model_from_text(
+            prompt, num_views=num_views, get_approval_callback=mock_get_approval
+        )
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertTrue("model_id" in result)
+        self.assertTrue("obj_file" in result)
+        self.assertTrue("point_cloud_file" in result)
+        
+        # Verify component calls
+        self.mock_gemini.generate_multiple_views.assert_called_once_with(
+            prompt, num_views=num_views, output_dir=os.path.join(self.test_output_dir, "multi_view")
+        )
+        
+        self.assertEqual(self.mock_approval.present_image_for_approval.call_count, num_views)
+        self.assertEqual(self.mock_approval.process_approval.call_count, num_views)
+        
+        self.mock_cuda_mvs.generate_model_from_images.assert_called_once()
+        self.mock_cuda_mvs.convert_ply_to_obj.assert_called_once()
+    
+    def test_generate_model_from_image(self):
+        """
+        Test generating a 3D model from a base image.
+        """
+        # Create a mock base image
+        base_image_path = os.path.join(self.test_images_dir, "base_image.png")
+        with open(base_image_path, "w") as f:
+            f.write("Mock base image")
+        
+        # Test parameters
+        prompt = "A low-poly rabbit based on this image"
+        num_views = 3
+        
+        # Mock approvals - approve all images
+        def mock_get_approval(approval_request):
+            return True
+        
+        # Call the method
+        result = self.pipeline.generate_model_from_image(
+            base_image_path, prompt, num_views=num_views, get_approval_callback=mock_get_approval
+        )
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertTrue("model_id" in result)
+        self.assertTrue("obj_file" in result)
+        self.assertTrue("point_cloud_file" in result)
+        
+        # Verify component calls
+        self.mock_gemini.generate_multiple_views.assert_called_once_with(
+            prompt, num_views=num_views, base_image_path=base_image_path, 
+            output_dir=os.path.join(self.test_output_dir, "multi_view")
+        )
+        
+        self.assertEqual(self.mock_approval.present_image_for_approval.call_count, num_views)
+        self.assertEqual(self.mock_approval.process_approval.call_count, num_views)
+        
+        self.mock_cuda_mvs.generate_model_from_images.assert_called_once()
+        self.mock_cuda_mvs.convert_ply_to_obj.assert_called_once()
+    
+    def test_selective_approval(self):
+        """
+        Test selective approval of generated images.
+        """
+        # Test parameters
+        prompt = "A low-poly rabbit"
+        num_views = 4
+        
+        # Mock approvals - only approve views 0 and 2
+        def mock_get_approval(approval_request):
+            view_index = int(approval_request["approval_id"].split('_')[1])
+            return view_index % 2 == 0  # Approve even-indexed views
+        
+        # Call the method
+        result = self.pipeline.generate_model_from_text(
+            prompt, num_views=num_views, get_approval_callback=mock_get_approval
+        )
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        
+        # Verify component calls
+        self.assertEqual(self.mock_approval.present_image_for_approval.call_count, num_views)
+        self.assertEqual(self.mock_approval.process_approval.call_count, num_views)
+        
+        # Only 2 images should be approved and used for model generation
+        approved_images = [call[0][0] for call in self.mock_cuda_mvs.generate_model_from_images.call_args_list]
+        if approved_images:
+            self.assertEqual(len(approved_images[0]), 2)  # Only 2 images approved
+    
+    def test_error_handling(self):
+        """
+        Test error handling in the pipeline.
+        """
+        # Test parameters
+        prompt = "A low-poly rabbit"
+        
+        # Mock error in Gemini API
+        self.mock_gemini.generate_multiple_views.side_effect = Exception("Mock API error")
+        
+        # Call the method and expect an exception
+        with self.assertRaises(Exception):
+            self.pipeline.generate_model_from_text(prompt)
+    
+    def tearDown(self):
+        """
+        Clean up after tests.
+        """
+        # Clean up test output directory
+        import shutil
+        if os.path.exists(self.test_output_dir):
+            shutil.rmtree(self.test_output_dir)
+        
+        # Clean up mock CUDA MVS path
+        if os.path.exists(self.cuda_mvs_path):
+            shutil.rmtree(self.cuda_mvs_path)
+
+if __name__ == "__main__":
+    unittest.main()

package/mcp_servers/openscad-mcp-server/legacy/test_primitives.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Test OpenSCAD primitives with different export formats
+
+PYTHON="python"
+OUTPUT_DIR="test_output"
+
+# Create output directory
+mkdir -p $OUTPUT_DIR
+
+# Run the tests
+$PYTHON -m src.testing.test_primitives --output-dir $OUTPUT_DIR --validate
+
+echo "Tests completed. Results are in $OUTPUT_DIR"

package/mcp_servers/openscad-mcp-server/legacy/test_rabbit_direct.py

@@ -0,0 +1,71 @@
+import os
+import sys
+import json
+import requests
+import base64
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Venice.ai API configuration
+VENICE_API_KEY = os.getenv("VENICE_API_KEY", "B9Y68yQgatQw8wmpmnIMYcGip1phCt-43CS0OktZU6")
+OUTPUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "output", "images")
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+# API configuration
+url = "https://api.venice.ai/api/v1/image/generate"
+headers = {
+    "Authorization": f"Bearer {VENICE_API_KEY}",
+    "Content-Type": "application/json"
+}
+
+# Payload for image generation
+payload = {
+    "height": 1024,
+    "width": 1024,
+    "steps": 20,
+    "return_binary": True,  # Request binary data directly
+    "hide_watermark": False,
+    "format": "png",
+    "embed_exif_metadata": False,
+    "model": "flux-dev",
+    "prompt": "A low-poly rabbit with black background. 3d file"
+}
+
+def generate_image():
+    """Generate image using Venice.ai API with the rabbit prompt."""
+    try:
+        logger.info(f"Sending request to {url} with prompt: '{payload['prompt']}'")
+        response = requests.post(url, json=payload, headers=headers)
+        
+        logger.info(f"Response status: {response.status_code}")
+        
+        if response.status_code == 200:
+            # Save the raw binary response
+            filename = "rabbit_low_poly_3d.png"
+            output_path = os.path.join(OUTPUT_DIR, filename)
+            
+            with open(output_path, "wb") as f:
+                f.write(response.content)
+            
+            logger.info(f"Image saved to {output_path}")
+            return output_path
+        else:
+            logger.error(f"Error: {response.status_code} - {response.text}")
+        
+        return None
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        return None
+
+if __name__ == "__main__":
+    logger.info("Starting Venice.ai image generation test with rabbit prompt")
+    image_path = generate_image()
+    
+    if image_path:
+        logger.info(f"Successfully generated and saved image to {image_path}")
+        print(f"\nImage saved to: {image_path}")
+    else:
+        logger.error("Failed to generate image")