@hybridlabor-api/bdb-hardware-pcb 0.1.0

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

@@ -0,0 +1,374 @@
+"""
+Test script for the complete workflow from text to 3D model.
+"""
+
+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.ai.gemini_api import GeminiImageGenerator
+from src.workflow.image_approval import ImageApprovalManager
+from src.models.cuda_mvs import CUDAMultiViewStereo
+from src.workflow.multi_view_to_model_pipeline import MultiViewToModelPipeline
+from src.config import MULTI_VIEW_PIPELINE, IMAGE_APPROVAL, REMOTE_CUDA_MVS
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TestCompleteWorkflow(unittest.TestCase):
+    """
+    Test cases for the complete workflow from text to 3D model.
+    """
+    
+    def setUp(self):
+        """
+        Set up test environment.
+        """
+        # Create test output directories
+        self.test_output_dir = "output/test_complete_workflow"
+        self.test_images_dir = os.path.join(self.test_output_dir, "images")
+        self.test_multi_view_dir = os.path.join(self.test_output_dir, "multi_view")
+        self.test_approved_dir = os.path.join(self.test_output_dir, "approved")
+        self.test_models_dir = os.path.join(self.test_output_dir, "models")
+        
+        os.makedirs(self.test_output_dir, exist_ok=True)
+        os.makedirs(self.test_images_dir, exist_ok=True)
+        os.makedirs(self.test_multi_view_dir, exist_ok=True)
+        os.makedirs(self.test_approved_dir, exist_ok=True)
+        os.makedirs(self.test_models_dir, exist_ok=True)
+        
+        # Mock API key
+        self.api_key = "test_api_key"
+        
+        # Create the components
+        self.image_generator = GeminiImageGenerator(
+            api_key=self.api_key,
+            output_dir=self.test_images_dir
+        )
+        
+        self.approval_manager = ImageApprovalManager(
+            output_dir=self.test_multi_view_dir,
+            approved_dir=self.test_approved_dir,
+            min_approved_images=3,
+            auto_approve=False
+        )
+        
+        self.cuda_mvs = CUDAMultiViewStereo(
+            output_dir=self.test_models_dir,
+            use_gpu=False
+        )
+        
+        # Create the pipeline
+        self.pipeline = MultiViewToModelPipeline(
+            image_generator=self.image_generator,
+            approval_manager=self.approval_manager,
+            model_generator=self.cuda_mvs,
+            output_dir=self.test_output_dir,
+            config=MULTI_VIEW_PIPELINE
+        )
+    
+    @patch('src.ai.gemini_api.requests.post')
+    def test_generate_images_from_text(self, mock_post):
+        """
+        Test generating images from text description.
+        """
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [
+                            {
+                                "text": "Generated image description"
+                            },
+                            {
+                                "inlineData": {
+                                    "mimeType": "image/png",
+                                    "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
+                                }
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+        mock_post.return_value = mock_response
+        
+        # Test parameters
+        prompt = "A low-poly rabbit"
+        num_views = 4
+        
+        # Call the method
+        results = self.pipeline.generate_images_from_text(prompt, num_views)
+        
+        # Verify the results
+        self.assertEqual(len(results), num_views)
+        for i, result in enumerate(results):
+            self.assertTrue("view_direction" in result)
+            self.assertEqual(result["view_index"], i + 1)
+            self.assertTrue("local_path" in result)
+            self.assertTrue(os.path.exists(result["local_path"]))
+        
+        # Verify the API calls
+        self.assertEqual(mock_post.call_count, num_views)
+    
+    def test_approve_images(self):
+        """
+        Test approving images in the workflow.
+        """
+        # Create test images
+        test_images = []
+        for i in range(4):
+            image_path = os.path.join(self.test_multi_view_dir, f"test_image_{i}.png")
+            with open(image_path, "w") as f:
+                f.write(f"test image data {i}")
+            test_images.append({
+                "id": f"image_{i}",
+                "local_path": image_path,
+                "view_index": i + 1,
+                "view_direction": f"view_{i}"
+            })
+        
+        # Add images to the pipeline
+        self.pipeline.add_images_for_approval(test_images)
+        
+        # Approve some images
+        self.pipeline.approve_image("image_0")
+        self.pipeline.approve_image("image_1")
+        self.pipeline.approve_image("image_2")
+        
+        # Reject an image
+        self.pipeline.reject_image("image_3")
+        
+        # Get the status
+        status = self.pipeline.get_approval_status()
+        
+        # Verify the status
+        self.assertEqual(status["total_images"], 4)
+        self.assertEqual(status["pending_count"], 0)
+        self.assertEqual(status["approved_count"], 3)
+        self.assertEqual(status["rejected_count"], 1)
+        self.assertTrue(status["has_minimum_approved"])
+    
+    @patch('src.models.cuda_mvs.subprocess.run')
+    def test_create_model_from_approved_images(self, mock_run):
+        """
+        Test creating a 3D model from approved images.
+        """
+        # Mock subprocess.run
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_run.return_value = mock_process
+        
+        # Create test images
+        test_images = []
+        for i in range(4):
+            image_path = os.path.join(self.test_approved_dir, f"image_{i}.png")
+            with open(image_path, "w") as f:
+                f.write(f"test image data {i}")
+            test_images.append({
+                "id": f"image_{i}",
+                "local_path": image_path,
+                "view_index": i + 1,
+                "view_direction": f"view_{i}"
+            })
+        
+        # Create a mock model file
+        model_path = os.path.join(self.test_models_dir, "test_model.obj")
+        with open(model_path, "w") as f:
+            f.write("test model data")
+        
+        # Call the method
+        result = self.pipeline.create_model_from_approved_images("test_model")
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertTrue("model_path" in result)
+        self.assertTrue("model_id" in result)
+        self.assertTrue("format" in result)
+        self.assertEqual(result["format"], "obj")
+    
+    @patch('src.ai.gemini_api.requests.post')
+    @patch('src.models.cuda_mvs.subprocess.run')
+    def test_complete_workflow(self, mock_run, mock_post):
+        """
+        Test the complete workflow from text to 3D model.
+        """
+        # Mock Gemini API response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [
+                            {
+                                "text": "Generated image description"
+                            },
+                            {
+                                "inlineData": {
+                                    "mimeType": "image/png",
+                                    "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
+                                }
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+        mock_post.return_value = mock_response
+        
+        # Mock subprocess.run
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_run.return_value = mock_process
+        
+        # Create a mock model file
+        model_path = os.path.join(self.test_models_dir, "test_model.obj")
+        with open(model_path, "w") as f:
+            f.write("test model data")
+        
+        # Create a pipeline with auto-approve
+        auto_pipeline = MultiViewToModelPipeline(
+            image_generator=self.image_generator,
+            approval_manager=ImageApprovalManager(
+                output_dir=self.test_multi_view_dir,
+                approved_dir=self.test_approved_dir,
+                min_approved_images=3,
+                auto_approve=True
+            ),
+            model_generator=self.cuda_mvs,
+            output_dir=self.test_output_dir,
+            config=MULTI_VIEW_PIPELINE
+        )
+        
+        # Test parameters
+        prompt = "A low-poly rabbit"
+        num_views = 4
+        
+        # Call the complete workflow
+        result = auto_pipeline.complete_workflow(prompt, num_views, "test_model")
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertTrue("model_path" in result)
+        self.assertTrue("model_id" in result)
+        self.assertTrue("format" in result)
+        self.assertEqual(result["format"], "obj")
+        self.assertTrue("prompt" in result)
+        self.assertEqual(result["prompt"], prompt)
+        self.assertTrue("num_views" in result)
+        self.assertEqual(result["num_views"], num_views)
+        self.assertTrue("approved_images" in result)
+        self.assertEqual(len(result["approved_images"]), num_views)
+    
+    @patch('src.remote.cuda_mvs_client.requests.post')
+    @patch('src.remote.cuda_mvs_client.requests.get')
+    def test_remote_workflow(self, mock_get, mock_post):
+        """
+        Test the workflow with remote CUDA MVS processing.
+        """
+        # Mock upload response
+        mock_upload_response = MagicMock()
+        mock_upload_response.status_code = 200
+        mock_upload_response.json.return_value = {
+            "job_id": "test_job_123",
+            "status": "uploaded",
+            "message": "Images uploaded successfully"
+        }
+        
+        # Mock process response
+        mock_process_response = MagicMock()
+        mock_process_response.status_code = 200
+        mock_process_response.json.return_value = {
+            "job_id": "test_job_123",
+            "status": "processing",
+            "message": "Job started processing"
+        }
+        
+        # Mock status response
+        mock_status_response = MagicMock()
+        mock_status_response.status_code = 200
+        mock_status_response.json.return_value = {
+            "job_id": "test_job_123",
+            "status": "completed",
+            "progress": 100,
+            "message": "Job completed successfully"
+        }
+        
+        # Mock download response
+        mock_download_response = MagicMock()
+        mock_download_response.status_code = 200
+        mock_download_response.content = b"test model data"
+        
+        # Set up the mock responses
+        mock_post.side_effect = [mock_upload_response, mock_process_response]
+        mock_get.side_effect = [mock_status_response, mock_download_response]
+        
+        # Create test images
+        test_images = []
+        for i in range(4):
+            image_path = os.path.join(self.test_approved_dir, f"image_{i}.png")
+            with open(image_path, "w") as f:
+                f.write(f"test image data {i}")
+            test_images.append({
+                "id": f"image_{i}",
+                "local_path": image_path,
+                "view_index": i + 1,
+                "view_direction": f"view_{i}"
+            })
+        
+        # Create a remote CUDA MVS client
+        from src.remote.cuda_mvs_client import CUDAMVSClient
+        remote_client = CUDAMVSClient(
+            api_key=self.api_key,
+            output_dir=self.test_models_dir
+        )
+        
+        # Create a pipeline with the remote client
+        remote_pipeline = MultiViewToModelPipeline(
+            image_generator=self.image_generator,
+            approval_manager=self.approval_manager,
+            model_generator=remote_client,
+            output_dir=self.test_output_dir,
+            config=MULTI_VIEW_PIPELINE
+        )
+        
+        # Add the approved images
+        remote_pipeline.add_images_for_approval(test_images)
+        for image in test_images:
+            remote_pipeline.approve_image(image["id"])
+        
+        # Call the method to create a model using the remote client
+        with patch('src.workflow.multi_view_to_model_pipeline.CUDAMVSClient', return_value=remote_client):
+            result = remote_pipeline.create_model_from_approved_images("test_model", server_url="http://test-server:8765")
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertTrue("model_path" in result)
+        self.assertTrue("model_id" in result)
+        self.assertTrue("format" in result)
+        self.assertEqual(result["format"], "obj")
+        self.assertTrue("job_id" in result)
+        self.assertEqual(result["job_id"], "test_job_123")
+    
+    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)
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,191 @@
+"""
+Test script for CUDA Multi-View Stereo integration.
+"""
+
+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.models.cuda_mvs import CUDAMultiViewStereo
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TestCUDAMVS(unittest.TestCase):
+    """
+    Test cases for CUDA Multi-View Stereo integration.
+    """
+    
+    def setUp(self):
+        """
+        Set up test environment.
+        """
+        # Create a test output directory
+        self.test_output_dir = "output/test_cuda_mvs"
+        os.makedirs(self.test_output_dir, exist_ok=True)
+        
+        # Create test image directory
+        self.test_images_dir = "output/test_cuda_mvs/images"
+        os.makedirs(self.test_images_dir, 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 test images
+        for i in range(3):
+            with open(os.path.join(self.test_images_dir, f"view_{i}.png"), "w") as f:
+                f.write(f"Mock image {i}")
+        
+        # Create the CUDA MVS wrapper with the mock path
+        with patch('os.path.exists', return_value=True):
+            self.cuda_mvs = CUDAMultiViewStereo(
+                cuda_mvs_path=self.cuda_mvs_path,
+                output_dir=self.test_output_dir
+            )
+    
+    @patch('subprocess.Popen')
+    def test_generate_model_from_images(self, mock_popen):
+        """
+        Test generating a 3D model from multiple images.
+        """
+        # Mock subprocess
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.communicate.return_value = ("Mock stdout", "")
+        mock_popen.return_value = mock_process
+        
+        # Mock file creation
+        def mock_exists(path):
+            if "point_cloud_file" in str(path):
+                # Create the mock point cloud file
+                os.makedirs(os.path.dirname(path), exist_ok=True)
+                with open(path, "w") as f:
+                    f.write("Mock point cloud")
+                return True
+            return os.path.exists(path)
+        
+        # Test parameters
+        image_paths = [os.path.join(self.test_images_dir, f"view_{i}.png") for i in range(3)]
+        output_name = "test_model"
+        
+        # Call the method with patched os.path.exists
+        with patch('os.path.exists', side_effect=mock_exists):
+            result = self.cuda_mvs.generate_model_from_images(image_paths, output_name=output_name)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertEqual(result["model_id"], output_name)
+        self.assertTrue("point_cloud_file" in result)
+        self.assertTrue("camera_params_file" in result)
+        self.assertEqual(len(result["input_images"]), 3)
+        
+        # Verify the subprocess call
+        mock_popen.assert_called_once()
+        args, kwargs = mock_popen.call_args
+        self.assertTrue("app_patch_match_mvs" in args[0][0])
+    
+    def test_generate_camera_params(self):
+        """
+        Test generating camera parameters from images.
+        """
+        # Test parameters
+        image_paths = [os.path.join(self.test_images_dir, f"view_{i}.png") for i in range(3)]
+        model_dir = os.path.join(self.test_output_dir, "camera_params_test")
+        os.makedirs(model_dir, exist_ok=True)
+        
+        # Mock PIL.Image.open
+        mock_image = MagicMock()
+        mock_image.size = (800, 600)
+        
+        # Call the method with patched PIL.Image.open
+        with patch('PIL.Image.open', return_value=mock_image):
+            params_file = self.cuda_mvs._generate_camera_params(image_paths, model_dir)
+        
+        # Verify the result
+        self.assertTrue(os.path.exists(params_file))
+        
+        # Read the params file
+        import json
+        with open(params_file, "r") as f:
+            params = json.load(f)
+        
+        # Verify the params
+        self.assertEqual(len(params), 3)
+        for i, param in enumerate(params):
+            self.assertEqual(param["image_id"], i)
+            self.assertEqual(param["width"], 800)
+            self.assertEqual(param["height"], 600)
+            self.assertTrue("camera" in param)
+            self.assertEqual(param["camera"]["model"], "PINHOLE")
+    
+    def test_convert_ply_to_obj(self):
+        """
+        Test converting PLY point cloud to OBJ mesh.
+        """
+        # Create a mock PLY file
+        ply_file = os.path.join(self.test_output_dir, "test.ply")
+        with open(ply_file, "w") as f:
+            f.write("Mock PLY file")
+        
+        # Call the method
+        obj_file = self.cuda_mvs.convert_ply_to_obj(ply_file)
+        
+        # Verify the result
+        self.assertTrue(os.path.exists(obj_file))
+        self.assertTrue(obj_file.endswith(".obj"))
+        
+        # Read the OBJ file
+        with open(obj_file, "r") as f:
+            content = f.read()
+        
+        # Verify the content
+        self.assertTrue("# Converted from test.ply" in content)
+        self.assertTrue("v " in content)
+        self.assertTrue("f " in content)
+    
+    def test_error_handling(self):
+        """
+        Test error handling in the CUDA MVS wrapper.
+        """
+        # Test parameters
+        image_paths = [os.path.join(self.test_images_dir, f"view_{i}.png") for i in range(3)]
+        output_name = "error_test"
+        
+        # Mock subprocess with error
+        mock_process = MagicMock()
+        mock_process.returncode = 1
+        mock_process.communicate.return_value = ("", "Mock error")
+        
+        # Call the method with patched subprocess.Popen
+        with patch('subprocess.Popen', return_value=mock_process):
+            with self.assertRaises(RuntimeError):
+                self.cuda_mvs.generate_model_from_images(image_paths, output_name=output_name)
+    
+    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()