Initial commit: Bambu A1 Mini analysis system

.env.example

@@ -0,0 +1,18 @@
+# MQTT Configuration
+host=mqtt.bambulab.com
+port=8883
+username=bblp
+password=bblp
+
+# Printer Information
+PRINTER_SERIAL=0309CA471800852
+
+# S3 Configuration
+AWS_ACCESS_KEY_ID=your_access_key
+AWS_SECRET_ACCESS_KEY=your_secret_key
+AWS_REGION=us-east-1
+S3_BUCKET=bambu-prints
+
+# Logging
+LOG_LEVEL=DEBUG
+LOG_FORMAT=%(asctime)s - %(levelname)s - %(message)s 

.gitignore

@@ -0,0 +1,41 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environment
+.env
+.venv
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Logs
+*.log
+
+# Local files
+temp/
+uploads/ 

app.py

@@ -0,0 +1,376 @@
+import gradio as gr
+import numpy as np
+import cv2
+import paho.mqtt.client as mqtt
+import json
+import time
+import threading
+import os
+from io import BytesIO
+import zipfile
+import logging
+from dotenv import load_dotenv
+from mo_optimizer import MOPrintOptimizer
+from core.analysis import DefectDetector, ImageProcessor
+from core.database import PrintJob
+from datetime import datetime
+import requests
+from PIL import Image
+
+# Load environment variables
+load_dotenv()
+
+# MQTT Configuration
+HOST = os.getenv("host")
+PORT = int(os.getenv("port", 8883))
+USERNAME = os.getenv("username")
+PASSWORD = os.getenv("password")
+PRINTER_SERIAL = os.getenv("PRINTER_SERIAL", "0309CA471800852")
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Global variables to store received data
+latest_data = {
+    "bed_temperature": "N/A",
+    "nozzle_temperature": "N/A",
+    "status": "N/A",
+    "update_time": "Waiting for data...",
+    "current_image_url": None,
+    "print_progress": 0
+}
+
+# Initialize analysis components
+optimizer = MOPrintOptimizer()
+detector = DefectDetector()
+
+def create_3mf_package(gcode_content: str, gcode_filename: str = "Metadata/plate_1.gcode") -> BytesIO:
+    """Create a 3MF package from G-code content"""
+    zip_buffer = BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        zipf.writestr(gcode_filename, gcode_content)
+    zip_buffer.seek(0)
+    return zip_buffer
+
+def create_client(host, port, username, password):
+    """Create and configure MQTT client"""
+    client = mqtt.Client()
+    client.username_pw_set(username, password)
+    client.tls_set(tls_version=mqtt.ssl.PROTOCOL_TLS)
+    client.on_connect = on_connect
+    client.on_message = on_message
+    try:
+        client.connect(host, port)
+        client.loop_start()
+        return client
+    except Exception as e:
+        logger.error(f"MQTT connection failed: {e}")
+        return None
+
+def on_connect(client, userdata, flags, rc):
+    """MQTT connection callback"""
+    logger.info(f"Connected with result code {rc}")
+    if rc == 0:
+        # Subscribe to printer response topic
+        response_topic = f"bambu_a1_mini/response/{PRINTER_SERIAL}"
+        client.subscribe(response_topic)
+        logger.info(f"Subscribed to {response_topic}")
+        
+        # Subscribe to printer status topic
+        status_topic = f"bambu_a1_mini/status/{PRINTER_SERIAL}"
+        client.subscribe(status_topic)
+        logger.info(f"Subscribed to {status_topic}")
+        
+        # Subscribe to camera image topic
+        image_topic = f"bambu_a1_mini/image/{PRINTER_SERIAL}"
+        client.subscribe(image_topic)
+        logger.info(f"Subscribed to {image_topic}")
+
+def on_message(client, userdata, message):
+    """MQTT message callback"""
+    try:
+        data = json.loads(message.payload)
+        
+        if "image" in message.topic:
+            # handle new image URL
+            image_url = data.get("image_url")
+            if image_url:
+                latest_data.update({
+                    "current_image_url": image_url,
+                    "image_timestamp": data.get("timestamp"),
+                    "square_id": data.get("square_id")
+                })
+                # update interface display
+                s3_image.update(value=image_url)
+                
+                # record to database
+                if hasattr(demo, 'db_manager'):
+                    job = demo.db_manager.session.query(PrintJob).filter_by(
+                        square_id=data.get("square_id"),
+                        status="printing"
+                    ).first()
+                    if job:
+                        job.match_image(
+                            image_url,
+                            datetime.strptime(data.get("timestamp"), "%Y-%m-%d %H:%M:%S")
+                        )
+                        demo.db_manager.session.commit()
+        
+        elif "status" in message.topic:
+            # update status
+            latest_data.update({
+                "status": data.get("status"),
+                "print_progress": data.get("progress", 0),
+                "current_square_id": data.get("square_id"),
+                "print_timestamp": data.get("timestamp"),
+                "update_time": time.strftime("%Y-%m-%d %H:%M:%S")
+            })
+    except Exception as e:
+        logger.error(f"Error processing message: {e}")
+
+def send_print_command(params):
+    """Send print parameters to Pi Zero via MQTT"""
+    command = {
+        "action": "print",
+        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "square_id": params.get("square_id"),  # get from position_manager
+        "parameters": {
+            "bed_temp": float(params["bed_temp"]),
+            "nozzle_temp": float(params["nozzle_temp"]),
+            "print_speed": float(params["print_speed"]),
+            "layer_height": float(params["layer_height"]),
+            "flow_rate": float(params["flow_rate"]),
+            "retraction_distance": float(params["retraction_distance"]),
+            "fan_speed": float(params["fan_speed"])
+        }
+    }
+    
+    command_topic = f"bambu_a1_mini/command/{PRINTER_SERIAL}"
+    mqtt_client.publish(command_topic, json.dumps(command))
+    return "Print command sent successfully"
+
+# Initialize MQTT client
+mqtt_client = create_client(HOST, PORT, USERNAME, PASSWORD)
+
+def update_printer_status():
+    """Get current printer status"""
+    if mqtt_client is None:
+        return "MQTT not connected", "No connection"
+    
+    status_text = (
+        f"Status: {latest_data['status']}\n"
+        f"Progress: {latest_data['print_progress']}%\n"
+        f"Bed Temp: {latest_data['bed_temperature']}°C\n"
+        f"Nozzle Temp: {latest_data['nozzle_temperature']}°C\n"
+        f"Last Update: {latest_data['update_time']}"
+    )
+    
+    job_text = (
+        f"Square ID: {latest_data.get('current_square_id', 'N/A')}\n"
+        f"Print Time: {latest_data.get('print_time', 'N/A')}\n"
+        f"Image Status: {'Captured' if latest_data.get('current_image_url') else 'Waiting'}"
+    )
+    
+    return status_text, job_text
+
+def analyze_print(image,
+                 nozzle_temp, print_speed, layer_height,
+                 flow_rate, retraction_distance, fan_speed):
+    """Analyze print quality and return evaluation results"""
+    if image is None:
+        return None, 0, 0, 0, 0, 0, 0, 0, 0
+    
+    # Package current parameters
+    current_params = {
+        'nozzle_temp': float(nozzle_temp),
+        'print_speed': float(print_speed),
+        'layer_height': float(layer_height),
+        'flow_rate': float(flow_rate),
+        'retraction_distance': float(retraction_distance),
+        'fan_speed': float(fan_speed)
+    }
+    
+    # Analyze print quality
+    analysis_results = detector.analyze_print(image)
+    
+    # Get optimization results
+    results = optimizer.evaluate_objectives(image, current_params)
+    
+    # Calculate quality metrics
+    metrics = detector.calculate_quality_metrics(image)
+    
+    return (
+        analysis_results['binary_mask'],  # Visualization
+        float(metrics['missing_rate']),
+        float(metrics['excess_rate']),
+        float(metrics['stringing_rate']),
+        float(metrics['uniformity_score']),
+        float(analysis_results['quality_score']),
+        float(results['objectives']['speed']),
+        float(results['objectives']['material']),
+        float(results['objectives']['total'])
+    )
+
+# Gradio interface
+with gr.Blocks(title="Bambu A1 Mini Print Analysis") as demo:
+    gr.Markdown("# Bambu A1 Mini Print Quality Analysis")
+    
+    with gr.Row():
+        # print status
+        printer_status = gr.Textbox(
+            label="Printer Status",
+            value="Initializing...",
+            interactive=False
+        )
+        current_job_status = gr.Textbox(
+            label="Current Print Job",
+            value="No active print job",
+            interactive=False
+        )
+        refresh_btn = gr.Button("Refresh Status")
+    
+    with gr.Row():
+        # show S3 image
+        s3_image = gr.Image(
+            label="Latest S3 Image",
+            type="filepath",  # use URL
+            interactive=False
+        )
+        captured_image = gr.Image(
+            label="Current Print Image",
+            type="numpy"
+        )
+    
+    with gr.Row():
+        with gr.Column():
+            # Print parameter inputs
+            nozzle_temp = gr.Slider(minimum=180, maximum=250, step=1, 
+                                  value=200,
+                                  label="Nozzle Temperature (°C)")
+            print_speed = gr.Slider(minimum=20, maximum=150, step=1,
+                                  value=60,
+                                  label="Print Speed (mm/s)")
+            layer_height = gr.Slider(minimum=0.1, maximum=0.4, step=0.01,
+                                  value=0.2,
+                                  label="Layer Height (mm)")
+            flow_rate = gr.Slider(minimum=90, maximum=110, step=1,
+                                value=100,
+                                label="Flow Rate (%)")
+            retraction_distance = gr.Slider(minimum=0, maximum=10, step=0.1,
+                                         value=5,
+                                         label="Retraction Distance (mm)")
+            fan_speed = gr.Slider(minimum=0, maximum=100, step=1,
+                                value=100,
+                                label="Fan Speed (%)")
+            
+            capture_btn = gr.Button("Capture Image")
+            analyze_btn = gr.Button("Analyze Print")
+        
+        with gr.Column():
+            # Results visualization
+            result_image = gr.Image(label="Analysis Result")
+            
+            # Quality metrics
+            with gr.Row():
+                missing_rate = gr.Number(label="Missing Rate", value=0.0)
+                excess_rate = gr.Number(label="Excess Rate", value=0.0)
+            with gr.Row():
+                stringing_rate = gr.Number(label="Stringing Rate", value=0.0)
+                uniformity_score = gr.Number(label="Uniformity Score", value=0.0)
+            
+            # Overall scores
+            with gr.Row():
+                quality_output = gr.Number(label="Print Quality Score")
+                speed_output = gr.Number(label="Print Speed Score")
+                material_output = gr.Number(label="Material Efficiency Score")
+                total_output = gr.Number(label="Total Performance Score")
+
+    # Connect inputs to outputs
+    def capture_frame(img):
+        """Capture current image for analysis"""
+        if img is None:
+            return None
+        # Convert URL image to numpy array if needed
+        if isinstance(img, str):
+            response = requests.get(img)
+            img = Image.open(BytesIO(response.content))
+            img = np.array(img)
+        return img
+    
+    capture_btn.click(
+        fn=capture_frame,
+        inputs=[s3_image],
+        outputs=[captured_image]
+    )
+    
+    analyze_btn.click(
+        fn=lambda img, *params: (
+            analyze_print(img, *params),
+            send_print_command(dict(
+                nozzle_temp=params[0],      # nozzle_temp slider
+                print_speed=params[1],      # print_speed slider
+                layer_height=params[2],     # layer_height slider
+                flow_rate=params[3],        # flow_rate slider
+                retraction_distance=params[4], # retraction_distance slider
+                fan_speed=params[5],        # fan_speed slider
+                bed_temp=60  # use default value, because there is no slider for bed_temp
+            ))
+        ),
+        inputs=[
+            captured_image,
+            nozzle_temp, print_speed, layer_height,
+            flow_rate, retraction_distance, fan_speed
+        ],
+        outputs=[
+            result_image,
+            missing_rate, excess_rate,
+            stringing_rate, uniformity_score,
+            quality_output, speed_output,
+            material_output, total_output,
+            printer_status, current_job_status
+        ]
+    )
+    
+    # add image refresh function
+    def refresh_images():
+        """refresh image display"""
+        image_url = latest_data.get("current_image_url")
+        if image_url:
+            return image_url
+        return None
+
+    # connect refresh button
+    refresh_btn.click(
+        fn=lambda: (
+            update_printer_status()[0],
+            update_printer_status()[1],
+            refresh_images()
+        ),
+        outputs=[
+            printer_status,
+            current_job_status,
+            s3_image
+        ]
+    )
+
+    # Auto-refresh printer status
+    def auto_refresh():
+        while True:
+            time.sleep(5)  # Update every 5 seconds
+            status, job_status = update_printer_status()
+            printer_status.update(status)
+            current_job_status.update(job_status)
+            # update image
+            image_url = refresh_images()
+            if image_url:
+                s3_image.update(image_url)
+    
+    threading.Thread(target=auto_refresh, daemon=True).start()
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch() 

core/analysis/__init__.py

@@ -0,0 +1,17 @@
+"""
+Bambu A1 Mini Print Analysis Core
+
+This package provides image analysis and defect detection functionality
+for the Bambu A1 Mini 3D printer.
+
+Modules:
+    - image_processor: Basic image processing utilities
+    - defect_detector: Defect detection and analysis
+    - segmentation_model: Print area segmentation
+"""
+
+from .image_processor import ImageProcessor
+from .segmentation_model import PrintQualitySegmentation
+from .defect_detector import DefectDetector
+
+__all__ = ['ImageProcessor', 'DefectDetector', 'PrintQualitySegmentation']

core/analysis/defect_detector.py

@@ -0,0 +1,500 @@
+import numpy as np
+import cv2
+from PIL import Image
+from skimage import feature, filters, morphology
+from sklearn.cluster import HDBSCAN
+from skimage import measure, registration
+from typing import Dict, List, Tuple
+from .image_processor import ImageProcessor
+from .segmentation_model import PrintQualitySegmentation
+
+class DefectDetector:
+    """Specialized detector for well plate / array printing quality analysis"""
+    
+    def __init__(self):
+        self.reference_square_size = None  # mm
+        self.pixels_per_mm = None
+        self.hdbscan_params = {
+            'min_cluster_size': 5,
+            'min_samples': 3,
+            'cluster_selection_epsilon': 0.1
+        }
+        
+        # Add groundtruth template
+        self.groundtruth = self._create_groundtruth_template()
+        
+        self.segmentation_model = PrintQualitySegmentation()
+        
+    def _create_groundtruth_template(self) -> np.ndarray:
+        """Create ideal print template"""
+        # Create a 500x500 white background
+        template = np.zeros((500, 500), dtype=np.uint8)
+        
+        # Draw 4 perfect squares at fixed positions
+        square_size = 100
+        positions = [
+            (50, 50),    
+            (350, 50),   
+            (50, 350),   
+            (350, 350)   
+        ]
+        
+        for x, y in positions:
+            cv2.rectangle(template, 
+                         (x, y), 
+                         (x + square_size, y + square_size), 
+                         255, 
+                         -1)  # -1 means fill
+        
+        return template
+
+    def detect_squares(self, image):
+        """Detect and analyze printed squares in array
+        
+        Args:
+            image: PIL.Image or numpy array of the print
+            
+        Returns:
+            dict: Analysis results for each square
+        """
+        # Convert to numpy array if needed
+        if isinstance(image, Image.Image):
+            image = np.array(image)
+            
+        # Convert to grayscale
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        
+        # Apply adaptive thresholding
+        thresh = cv2.adaptiveThreshold(
+            gray, 255,
+            cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+            cv2.THRESH_BINARY_INV,
+            21, 10
+        )
+        
+        # Find contours
+        contours, _ = cv2.findContours(
+            thresh,
+            cv2.RETR_EXTERNAL,
+            cv2.CHAIN_APPROX_SIMPLE
+        )
+        
+        squares = []
+        for contour in contours:
+            # Filter by area and shape
+            area = cv2.contourArea(contour)
+            if area < 100:  # Minimum area threshold
+                continue
+                
+            # Check if it's approximately square
+            peri = cv2.arcLength(contour, True)
+            approx = cv2.approxPolyDP(contour, 0.04 * peri, True)
+            
+            if len(approx) == 4:  # Square has 4 corners
+                squares.append(contour)
+        
+        return self._analyze_squares(gray, squares)
+    
+    def _analyze_squares(self, gray: np.ndarray, squares: List) -> Dict:
+        """Analyze detected squares for defects"""
+        results = []
+        
+        for square in squares:
+            # Get bounding box
+            x, y, w, h = cv2.boundingRect(square)
+            
+            # Extract square region
+            roi = gray[y:y+h, x:x+w]
+            
+            # Analyze uniformity
+            uniformity = self._analyze_uniformity(roi)
+            
+            # Detect gaps
+            gaps = self._detect_gaps(roi)
+            
+            # Calculate coverage
+            coverage = cv2.contourArea(square) / (w * h)
+            
+            results.append({
+                'position': (x, y, w, h),
+                'uniformity': uniformity,
+                'gaps': gaps,
+                'coverage': coverage
+            })
+        
+        return {
+            'square_count': len(squares),
+            'squares': results
+        }
+    
+    def _analyze_uniformity(self, roi: np.ndarray) -> float:
+        """Analyze print uniformity in region"""
+        # Calculate local standard deviation
+        local_std = filters.rank.std(roi, morphology.square(5))
+        
+        # Normalize and invert (higher is better)
+        uniformity = 1 - (np.mean(local_std) / 255)
+        return float(uniformity)
+    
+    def _detect_gaps(self, roi: np.ndarray) -> List[Dict]:
+        """Detect gaps in printed region"""
+        # Edge detection
+        edges = feature.canny(roi, sigma=2)
+        
+        # Find connected components
+        labels = measure.label(edges)
+        
+        # Get coordinates of edge pixels
+        coords = np.column_stack(np.where(edges > 0))
+        
+        if len(coords) < self.hdbscan_params['min_cluster_size']:
+            return []
+        
+        # HDBSCAN clustering
+        clusterer = HDBSCAN(
+            **self.hdbscan_params
+        )
+        cluster_labels = clusterer.fit_predict(coords)
+        
+        # Analyze gap clusters
+        gap_clusters = []
+        for label in set(cluster_labels):
+            if label == -1:
+                continue
+                
+            cluster_points = coords[cluster_labels == label]
+            
+            # Calculate cluster properties
+            min_x, min_y = np.min(cluster_points, axis=0)
+            max_x, max_y = np.max(cluster_points, axis=0)
+            area = len(cluster_points)
+            
+            if area > 10:  # Minimum gap size
+                gap_clusters.append({
+                    "location": [int(min_x), int(min_y), 
+                               int(max_x - min_x), int(max_y - min_y)],
+                    "area": int(area)
+                })
+        
+        return gap_clusters
+    
+    def _calculate_presence_score(self, region_props: List) -> float:
+        """Calculate filament presence score based on region properties"""
+        if not region_props:
+            return 0.0
+            
+        # Consider region sizes and shapes
+        scores = []
+        for prop in region_props:
+            area = prop.area
+            perimeter = prop.perimeter
+            circularity = 4 * np.pi * area / (perimeter * perimeter) if perimeter > 0 else 0
+            
+            # Higher score for more circular regions
+            score = circularity * np.sqrt(area)
+            scores.append(score)
+            
+        return min(1.0, np.mean(scores) / 100)
+    
+    def _calculate_uniformity(self, img_gray: np.ndarray, binary: np.ndarray) -> float:
+        """Calculate filament uniformity score"""
+        # Only consider regions with filament
+        filament_intensities = img_gray[binary]
+        if len(filament_intensities) == 0:
+            return 0.0
+            
+        # Calculate intensity statistics
+        std_dev = np.std(filament_intensities)
+        mean_intensity = np.mean(filament_intensities)
+        
+        # Calculate uniformity score (inverse of coefficient of variation)
+        uniformity = 1.0 - (std_dev / mean_intensity if mean_intensity > 0 else 1.0)
+        return max(0.0, uniformity)
+
+    def calculate_quality_metrics(self, image, expected_mask=None) -> Dict:
+        """Calculate quantitative metrics for print quality
+        
+        Args:
+            image: Print image
+            expected_mask: Expected print area mask (optional)
+            
+        Returns:
+            dict: Dictionary containing quality metrics
+        """
+        # Convert image format
+        if isinstance(image, Image.Image):
+            image = np.array(image)
+        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        
+        # If no expected mask provided, generate using square detection
+        if expected_mask is None:
+            squares = self.detect_squares(image)
+            expected_mask = np.zeros_like(gray, dtype=np.uint8)
+            for square in squares['squares']:
+                x, y, w, h = square['position']
+                expected_mask[y:y+h, x:x+w] = 255
+        
+        # 1. Calculate missing rate (Missing Rate)
+        _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
+        missing_area = np.logical_and(binary == 0, expected_mask == 255)
+        missing_rate = np.sum(missing_area) / np.sum(expected_mask == 255)
+        
+        # 2. Calculate excess rate (Excess Rate)
+        excess_area = np.logical_and(binary == 255, expected_mask == 0)
+        excess_rate = np.sum(excess_area) / np.sum(expected_mask == 255)
+        
+        # 3. Detect stringing (Stringing)
+        stringing_score = self._detect_stringing_rate(gray, expected_mask)
+        
+        # 4. Calculate uniformity (Uniformity)
+        uniformity_score = self._calculate_uniformity_score(gray, binary)
+        
+        return {
+            "missing_rate": float(missing_rate),
+            "excess_rate": float(excess_rate),
+            "stringing_rate": float(stringing_score),
+            "uniformity_score": float(uniformity_score)
+        }
+
+    def _detect_stringing_rate(self, gray: np.ndarray, mask: np.ndarray) -> float:
+        """Detect stringing and calculate rate"""
+        # Use morphological operations to detect long structures
+        kernel = np.ones((3,3), np.uint8)
+        dilated = cv2.dilate(gray, kernel, iterations=1)
+        eroded = cv2.erode(gray, kernel, iterations=1)
+        strings = cv2.subtract(dilated, eroded)
+        
+        # Only consider strings outside non-print area
+        strings_outside = np.logical_and(strings > 50, mask == 0)
+        
+        # Calculate stringing rate
+        string_rate = np.sum(strings_outside) / np.sum(mask == 255)
+        return min(1.0, string_rate)
+
+    def _calculate_uniformity_score(self, gray: np.ndarray, binary: np.ndarray) -> float:
+        """Calculate uniformity score"""
+        # Only analyze printed area
+        print_area = gray[binary == 255]
+        if len(print_area) == 0:
+            return 0.0
+        
+        # Calculate local standard deviation
+        local_std = filters.rank.std(gray, morphology.square(5))
+        local_std_normalized = local_std[binary == 255] / 255.0
+        
+        # Convert to uniformity score (1 - mean of standard deviation)
+        uniformity = 1.0 - np.mean(local_std_normalized)
+        return max(0.0, uniformity)
+
+    def _calculate_pixel_comparison(self, image: np.ndarray, groundtruth: np.ndarray) -> Dict:
+        """Calculate pixel-level comparison metrics
+        
+        Args:
+            image: Actual print image
+            groundtruth: Ideal template image
+            
+        Returns:
+            dict: Pixel-level comparison metrics
+        """
+        # Ensure image size is consistent
+        image = cv2.resize(image, (500, 500))
+        if len(image.shape) == 3:
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+            
+        # Binarize image
+        _, binary = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)
+        
+        # Calculate pixel matching
+        matching_pixels = np.sum(binary == groundtruth)
+        total_pixels = binary.size
+        pixel_accuracy = matching_pixels / total_pixels
+        
+        # Calculate number of pixels for each category
+        true_positives = np.sum(np.logical_and(binary == 255, groundtruth == 255))
+        false_positives = np.sum(np.logical_and(binary == 255, groundtruth == 0))
+        false_negatives = np.sum(np.logical_and(binary == 0, groundtruth == 255))
+        true_negatives = np.sum(np.logical_and(binary == 0, groundtruth == 0))
+        
+        # Calculate precision and recall
+        precision = true_positives / (true_positives + false_positives) if (true_positives + false_positives) > 0 else 0
+        recall = true_positives / (true_positives + false_negatives) if (true_positives + false_negatives) > 0 else 0
+        
+        # Calculate F1 score
+        f1_score = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0
+        
+        return {
+            "pixel_accuracy": float(pixel_accuracy),
+            "precision": float(precision),
+            "recall": float(recall),
+            "f1_score": float(f1_score),
+            "true_positives": int(true_positives),
+            "false_positives": int(false_positives),
+            "false_negatives": int(false_negatives),
+            "true_negatives": int(true_negatives)
+        }
+
+    def segment_print_area(self, image: np.ndarray) -> np.ndarray:
+        # Ensure image is grayscale
+        if len(image.shape) == 3:
+            gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image
+            
+        # Use adaptive thresholding for segmentation
+        binary = cv2.adaptiveThreshold(
+            gray,
+            255,
+            cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+            cv2.THRESH_BINARY_INV,
+            21,  # Neighborhood size
+            10   # Constant difference
+        )
+        
+        # Morphological operations to remove noise
+        kernel = np.ones((3,3), np.uint8)
+        binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
+        binary = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
+        
+        return binary
+
+    def analyze_print_quality(self, image: np.ndarray) -> Tuple[np.ndarray, np.ndarray, Dict]:
+        """Analyze print quality and return visualization results
+        
+        Args:
+            image: Print image
+            
+        Returns:
+            Tuple[np.ndarray, np.ndarray, Dict]: 
+                - groundtruth image
+                - defect analysis visualization image
+                - quality metrics dictionary
+        """
+        # Ensure image size is consistent
+        image = cv2.resize(image, (500, 500))
+        
+        # Segment print area
+        binary = self.segment_print_area(image)
+        
+        # Calculate quality metrics
+        metrics = self.calculate_quality_metrics(binary, self.groundtruth)
+        
+        # Add pixel-level comparison metrics
+        pixel_metrics = self._calculate_pixel_comparison(binary, self.groundtruth)
+        metrics.update({"pixel_comparison": pixel_metrics})
+        
+        # Generate defect visualization image
+        defect_vis = self._generate_defect_visualization(binary, self.groundtruth, metrics)
+        
+        # Convert groundtruth to RGB for display
+        groundtruth_rgb = cv2.cvtColor(self.groundtruth, cv2.COLOR_GRAY2RGB)
+        
+        return groundtruth_rgb, defect_vis, metrics
+    
+    def _generate_defect_visualization(self, binary: np.ndarray, 
+                                     groundtruth: np.ndarray, 
+                                     metrics: Dict) -> np.ndarray:
+        """Generate defect visualization image"""
+        vis = np.zeros((500, 500, 3), dtype=np.uint8)
+        
+        # Basic defect display
+        correct_area = np.logical_and(binary == 255, groundtruth == 255)
+        vis[correct_area] = [0, 255, 0]  # Correct area (green)
+        
+        missing_area = np.logical_and(binary == 0, groundtruth == 255)
+        vis[missing_area] = [255, 0, 0]  # Missing area (red)
+        
+        excess_area = np.logical_and(binary == 255, groundtruth == 0)
+        vis[excess_area] = [255, 255, 0]  # Excess area (yellow)
+        
+        # Use HDBSCAN to detect and label defect clusters
+        defect_mask = np.logical_or(missing_area, excess_area)
+        defect_clusters = self._detect_defect_clusters(defect_mask)
+        
+        # Label defect clusters on image
+        for i, cluster in enumerate(defect_clusters):
+            # Draw bounding box
+            cv2.rectangle(
+                vis,
+                (int(cluster['bbox']['min_x']), int(cluster['bbox']['min_y'])),
+                (int(cluster['bbox']['max_x']), int(cluster['bbox']['max_y'])),
+                (0, 255, 255),  # Cyan border
+                2
+            )
+            
+            # Label defect ID and size
+            label = f"D{i+1}: {cluster['size']}px"
+            cv2.putText(vis, label,
+                       (int(cluster['centroid'][1]), int(cluster['centroid'][0])),
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
+        
+        # Add metrics text
+        cv2.putText(vis, f"Missing: {metrics['missing_rate']:.2f}", 
+                    (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        cv2.putText(vis, f"Excess: {metrics['excess_rate']:.2f}", 
+                    (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        cv2.putText(vis, f"String: {metrics['stringing_rate']:.2f}", 
+                    (10, 90), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        cv2.putText(vis, f"Uniformity: {metrics['uniformity_score']:.2f}", 
+                    (10, 120), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        cv2.putText(vis, f"Defect Clusters: {len(defect_clusters)}", 
+                    (10, 150), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        
+        return vis
+
+    def _detect_defect_clusters(self, binary: np.ndarray) -> List[Dict]:
+        """Use HDBSCAN to detect defect clusters
+        
+        Args:
+            binary: Binary defect image
+            
+        Returns:
+            List[Dict]: Information for each defect area, including position and size
+        """
+        # Get defect pixel coordinates
+        defect_coords = np.column_stack(np.where(binary > 0))
+        
+        if len(defect_coords) < self.hdbscan_params['min_cluster_size']:
+            return []
+            
+        # Use HDBSCAN for clustering
+        clusterer = HDBSCAN(
+            min_cluster_size=self.hdbscan_params['min_cluster_size'],
+            min_samples=self.hdbscan_params['min_samples'],
+            cluster_selection_epsilon=self.hdbscan_params['cluster_selection_epsilon']
+        )
+        
+        cluster_labels = clusterer.fit_predict(defect_coords)
+        
+        # Analyze each cluster
+        defect_clusters = []
+        for label in set(cluster_labels):
+            if label == -1:  # Noise points
+                continue
+                
+            # Get all points in this cluster
+            cluster_points = defect_coords[cluster_labels == label]
+            
+            # Calculate cluster statistics
+            centroid = np.mean(cluster_points, axis=0)
+            size = len(cluster_points)
+            bbox = {
+                'min_x': np.min(cluster_points[:, 1]),
+                'max_x': np.max(cluster_points[:, 1]),
+                'min_y': np.min(cluster_points[:, 0]),
+                'max_y': np.max(cluster_points[:, 0])
+            }
+            
+            defect_clusters.append({
+                'centroid': centroid,
+                'size': size,
+                'bbox': bbox,
+                'points': cluster_points
+            })
+            
+        return defect_clusters
+
+    def analyze_print(self, image):
+        binary_mask = self.segmentation_model.segment_print_area(image)
+        analysis_results = self.segmentation_model.analyze_quality(image)
+        
+        return analysis_results

core/analysis/image_processor.py

@@ -0,0 +1,43 @@
+import cv2
+import numpy as np
+from typing import Tuple, Dict, Optional
+from PIL import Image
+
+class ImageProcessor:
+    """Basic image processing utilities for print analysis"""
+    
+    @staticmethod
+    def preprocess_image(image) -> np.ndarray:
+        """Preprocess image for analysis
+        
+        Args:
+            image: PIL.Image or numpy array
+            
+        Returns:
+            np.ndarray: Preprocessed image
+        """
+        # Convert to numpy array if needed
+        if isinstance(image, Image.Image):
+            image = np.array(image)
+            
+        # Convert to grayscale if needed
+        if len(image.shape) == 3:
+            image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+            
+        return image
+    
+    @staticmethod
+    def enhance_contrast(image: np.ndarray) -> np.ndarray:
+        """Enhance image contrast"""
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+        return clahe.apply(image)
+    
+    @staticmethod
+    def remove_noise(image: np.ndarray, kernel_size: int = 3) -> np.ndarray:
+        """Remove image noise"""
+        return cv2.medianBlur(image, kernel_size)
+    
+    @staticmethod
+    def detect_edges(image: np.ndarray, sigma: float = 2.0) -> np.ndarray:
+        """Detect edges in image"""
+        return cv2.Canny(image, 100, 200) 

core/analysis/segmentation_model.py

@@ -0,0 +1,1129 @@
+import numpy as np
+import cv2
+from PIL import Image
+from skimage import feature, filters, morphology
+from datetime import datetime
+from typing import Tuple, Dict
+
+def initialize_segmentation_model():
+    """Initialize SegFormer model"""
+    model = SegformerForSemanticSegmentation.from_pretrained(
+        "nvidia/mit-b0",
+        num_labels=3,  # defect, normal, background
+        ignore_mismatched_sizes=True
+    )
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+    return model, device
+
+def process_image(image: Image.Image, model, device):
+    """Process image through segmentation model"""
+    # Transform image
+    transform = transforms.Compose([
+        transforms.Resize((512, 512)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], 
+                           std=[0.229, 0.224, 0.225])
+    ])
+    
+    input_tensor = transform(image).unsqueeze(0).to(device)
+    
+    # Get predictions
+    with torch.no_grad():
+        outputs = model(input_tensor)
+        predictions = outputs.logits.argmax(dim=1)
+    
+    return predictions.cpu().numpy()[0]
+
+def analyze_print_quality(predictions: np.ndarray) -> dict:
+    """Analyze print quality from segmentation predictions"""
+    total_pixels = predictions.size
+    defect_pixels = (predictions == 0).sum().item()
+    normal_pixels = (predictions == 1).sum().item()
+    
+    return {
+        'quality_score': normal_pixels / total_pixels,
+        'defect_ratio': defect_pixels / total_pixels,
+        'normal_ratio': normal_pixels / total_pixels
+    }
+
+class PrintQualitySegmentation:
+    """Independent segmentation model for print quality analysis"""
+    
+    def __init__(self):
+        self.model_params = {
+            'threshold': 127,
+            'kernel_size': 3,
+            'min_area': 100
+        }
+    
+    def segment_print_area(self, image):
+        """Segment print area from background"""
+        # Convert to numpy array if needed
+        if isinstance(image, Image.Image):
+            image = np.array(image)
+            
+        # Convert to grayscale if needed
+        if len(image.shape) == 3:
+            gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        else:
+            gray = image
+            
+        # Basic thresholding
+        _, binary = cv2.threshold(
+            gray, 
+            self.model_params['threshold'], 
+            255, 
+            cv2.THRESH_BINARY
+        )
+        
+        # Clean up noise
+        kernel = np.ones(
+            (self.model_params['kernel_size'], 
+             self.model_params['kernel_size']), 
+            np.uint8
+        )
+        binary = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
+        
+        return binary
+    
+    def detect_defects(self, image, binary_mask):
+        """Detect defects in segmented area"""
+        # Edge detection
+        edges = feature.canny(image, sigma=2)
+        
+        # Find contours
+        contours, _ = cv2.findContours(
+            binary_mask,
+            cv2.RETR_EXTERNAL,
+            cv2.CHAIN_APPROX_SIMPLE
+        )
+        
+        defects = []
+        for contour in contours:
+            area = cv2.contourArea(contour)
+            if area < self.model_params['min_area']:
+                continue
+                
+            x, y, w, h = cv2.boundingRect(contour)
+            defects.append({
+                'position': (x, y, w, h),
+                'area': area
+            })
+            
+        return defects
+    
+    def analyze_quality(self, image) -> Dict:
+        """Analyze print quality metrics"""
+        binary = self.segment_print_area(image)
+        defects = self.detect_defects(image, binary)
+        
+        total_area = np.sum(binary > 0)
+        defect_area = sum(d['area'] for d in defects)
+        quality_score = 1.0 - (defect_area / total_area if total_area > 0 else 0)
+        
+        return {
+            'quality_score': quality_score,
+            'defect_count': len(defects),
+            'total_area': total_area,
+            'defect_area': defect_area,
+            'binary_mask': binary,
+            'defects': defects
+        }
+
+    def calibrate_coordinates(self, gcode_file: str, image: np.ndarray):
+        """Calibrate coordinate system using G-code and actual image
+        
+        Args:
+            gcode_file: G-code file path
+            image: Print plate image
+        """
+        # Get printer coordinates from G-code
+        printer_coords = self.gcode_analyzer.get_print_coordinates(gcode_file)
+        
+        # Detect actual print positions in image
+        detected_positions = self._detect_print_positions(image)
+        
+        # Calculate coordinate mapping
+        if len(printer_coords) >= 2 and len(detected_positions) >= 2:
+            # Use at least two points to establish mapping
+            self.coordinate_mapping = self._calculate_mapping(
+                printer_coords[:2],  # Printer coordinates
+                detected_positions[:2]  # Image pixel coordinates
+            )
+    
+    def _calculate_mapping(self, printer_coords, pixel_coords):
+        """Calculate coordinate mapping
+        
+        Use affine transformation to calculate mapping matrix:
+        [x_pixel] = [a b c] [x_printer]
+        [y_pixel] = [d e f] [y_printer]
+        [1      ]   [0 0 1] [1        ]
+        """
+        # Build transformation matrix
+        src_pts = np.float32([[x, y, 1] for x, y in printer_coords])
+        dst_pts = np.float32([[x, y, 1] for x, y in pixel_coords])
+        
+        # Calculate transformation matrix
+        transform_matrix, _ = cv2.findHomography(src_pts, dst_pts)
+        return transform_matrix
+    
+    def printer_to_pixel(self, printer_coord: tuple) -> tuple:
+        """Convert printer coordinates to image pixel coordinates"""
+        if self.coordinate_mapping is None:
+            raise ValueError("Coordinate mapping not calibrated")
+            
+        x, y = printer_coord
+        point = np.array([x, y, 1])
+        pixel = np.dot(self.coordinate_mapping, point)
+        return (int(pixel[0]), int(pixel[1]))
+    
+    def analyze_print_quality(self, image: np.ndarray, print_position: tuple = None) -> Tuple[np.ndarray, np.ndarray, Dict]:
+        """Analyze print quality, incorporating temporal information
+        
+        Args:
+            image: Current complete print bed image
+            print_position: Current print position (x, y)
+            
+        Returns:
+            groundtruth: Ideal template image
+            defect_vis: Defect visualization image
+            metrics: Quality metrics
+        """
+        # 1. Temporal segmentation: Get current print region
+        current_mask = self._get_current_print_mask(image, print_position)
+        
+        # 2. Use SegFormer for semantic segmentation
+        segmentation_result = self._segment_with_model(image * current_mask)
+        
+        # 3. Combine temporal information and semantic segmentation results
+        combined_mask = self._combine_masks(current_mask, segmentation_result)
+        
+        # 4. Calculate quality metrics
+        metrics = self._calculate_metrics(combined_mask)
+        
+        # 5. Generate visualization results
+        defect_vis = self._generate_visualization(image, combined_mask, metrics)
+        
+        # 6. Update history
+        self._update_history(print_position, combined_mask)
+        
+        return self.groundtruth, defect_vis, metrics
+    
+    def _get_current_print_mask(self, image: np.ndarray, position: tuple) -> np.ndarray:
+        """Get mask of current print region"""
+        mask = np.zeros_like(image[:,:,0], dtype=np.uint8)
+        
+        if position is not None:
+            # Convert printer coordinates to pixel coordinates
+            pixel_pos = self.printer_to_pixel(position)
+            
+            # Create mask for current print region
+            x, y = pixel_pos
+            cv2.rectangle(mask, 
+                         (x, y), 
+                         (x + 100, y + 100),  # 
+                         255, -1)
+        else:
+            # First print, use position information
+            if position is not None:
+                mask = self._create_position_mask(position, image.shape[:2])
+        
+        self.previous_image = image.copy()
+        return mask
+    
+    def _create_position_mask(self, position: tuple, shape: tuple) -> np.ndarray:
+        """Create mask based on print position"""
+        mask = np.zeros(shape, dtype=np.uint8)
+        x, y = position
+        # Assume each print block size is 100x100 pixels
+        # TODO: Need to adjust based on actual printer parameters
+        cv2.rectangle(mask, 
+                     (int(x), int(y)), 
+                     (int(x + 100), int(y + 100)), 
+                     255, -1)
+        return mask
+    
+    def _verify_position(self, contour: np.ndarray, expected_position: tuple) -> bool:
+        """Verify if detected region matches expected position"""
+        x, y = expected_position
+        center = np.mean(contour.reshape(-1, 2), axis=0)
+        distance = np.sqrt((center[0] - x)**2 + (center[1] - y)**2)
+        return distance < 50  # Allow 50 pixel error
+    
+    def _combine_masks(self, time_mask: np.ndarray, seg_mask: np.ndarray) -> np.ndarray:
+        """Combine temporal mask and semantic segmentation results"""
+        # Apply temporal mask to semantic segmentation result
+        combined = seg_mask * (time_mask > 0)
+        return combined
+    
+    def _update_history(self, position: tuple, mask: np.ndarray):
+        """Update print history"""
+        if position is not None:
+            self.print_history.append({
+                'position': position,
+                'mask': mask.copy(),
+                'timestamp': datetime.now()
+            })
+        
+        # Extended printing parameter recommendation rules
+        self.parameter_rules = {
+            'over_extrusion': {
+                'severe': {
+                    'extrusion_multi': (-0.1, "Reduce extrusion multiplier by 10%"),
+                    'nozzle_temp': (-10, "Lower nozzle temperature by 10°C to reduce material flow"),
+                    'print_speed': (+5, "Slightly increase speed to reduce material per unit length"),
+                    'fan_speed': (+10, "Increase fan speed for better cooling"),
+                    'acceleration': (-500, "Reduce acceleration to minimize extrusion fluctuation"),
+                    'jerk': (-2, "Lower jerk to reduce extrusion instability"),
+                    'priority': ['extrusion_multi', 'nozzle_temp', 'fan_speed', 'print_speed', 'acceleration', 'jerk'],
+                    'reason': "Severe over-extrusion, comprehensive adjustment of extrusion and motion parameters"
+                },
+                'moderate': {
+                    'extrusion_multi': (-0.05, "Reduce extrusion multiplier by 5%"),
+                    'nozzle_temp': (-5, "Slightly lower nozzle temperature by 5°C"),
+                    'fan_speed': (+5, "Slightly increase fan speed"),
+                    'priority': ['extrusion_multi', 'nozzle_temp', 'fan_speed'],
+                    'reason': "Minor over-extrusion, fine-tune basic parameters"
+                }
+            },
+            'under_extrusion': {
+                'severe': {
+                    'extrusion_multi': (+0.1, "Increase extrusion multiplier by 10%"),
+                    'nozzle_temp': (+15, "Raise nozzle temperature by 15°C for better flow"),
+                    'print_speed': (-10, "Reduce print speed for proper extrusion"),
+                    'retraction_speed': (-5, "Lower retraction speed to reduce clogging risk"),
+                    'retraction_distance': (-0.5, "Reduce retraction distance to prevent feed issues"),
+                    'min_layer_time': (+5, "Increase minimum layer time for cooling"),
+                    'priority': ['nozzle_temp', 'extrusion_multi', 'print_speed', 'retraction_speed', 'retraction_distance'],
+                    'reason': "Severe under-extrusion, comprehensive extrusion parameter adjustment needed"
+                },
+                'moderate': {
+                    'extrusion_multi': (+0.05, "Increase extrusion multiplier by 5%"),
+                    'nozzle_temp': (+10, "Raise nozzle temperature by 10°C"),
+                    'priority': ['nozzle_temp', 'extrusion_multi'],
+                    'reason': "Minor under-extrusion, mainly adjust temperature"
+                }
+            },
+            'layer_shift': {
+                'severe': {
+                    'print_speed': (-20, "Significantly reduce print speed"),
+                    'acceleration': (-1000, "Significantly reduce acceleration"),
+                    'jerk': (-4, "Lower jerk to reduce speed"),
+                    'outer_wall_speed': (-10, "Lower outer wall speed for better precision"),
+                    'travel_speed': (-20, "Lower travel speed to reduce vibration"),
+                    'priority': ['acceleration', 'print_speed', 'jerk', 'outer_wall_speed', 'travel_speed'],
+                    'reason': "Severe layer shift, comprehensive reduction of motion parameters"
+                },
+                'moderate': {
+                    'print_speed': (-10, "Slightly reduce print speed"),
+                    'priority': ['print_speed'],
+                    'reason': "Minor layer shift, reduce speed is enough"
+                }
+            },
+            'stringing': {
+                'severe': {
+                    'retraction_distance': (+1, "Increase retraction distance by 1mm"),
+                    'retraction_speed': (+10, "Increase retraction speed by 10mm/s"),
+                    'nozzle_temp': (-5, "Lower temperature to reduce oozing"),
+                    'travel_speed': (+20, "Increase travel speed to reduce oozing time"),
+                    'wipe_distance': (+2, "Increase wipe distance"),
+                    'coasting_volume': (+0.03, "Increase coasting volume to reduce stringing"),
+                    'priority': ['retraction_distance', 'retraction_speed', 'nozzle_temp', 'travel_speed', 'wipe_distance'],
+                    'reason': "Severe stringing, optimize retraction and motion parameters"
+                },
+                'moderate': {
+                    'retraction_distance': (+0.5, "Slightly increase retraction distance by 0.5mm"),
+                    'nozzle_temp': (-3, "Slightly lower temperature by 3°C"),
+                    'priority': ['retraction_distance', 'nozzle_temp'],
+                    'reason': "Minor stringing, fine-tune retraction parameters"
+                }
+            },
+            'warping': {
+                'severe': {
+                    'bed_temp': (+10, "Increase bed temperature for better adhesion"),
+                    'first_layer_temp': (+5, "Increase first layer temperature"),
+                    'first_layer_speed': (-10, "Reduce first layer speed"),
+                    'fan_speed_initial_layer': (-50, "Reduce initial layer fan speed"),
+                    'skirt_distance': (-0.5, "Reduce skirt distance"),
+                    'brim_width': (+5, "Increase brim width"),
+                    'priority': ['bed_temp', 'first_layer_temp', 'fan_speed_initial_layer', 'brim_width'],
+                    'reason': "Severe warping, optimize first layer and temperature parameters"
+                }
+            },
+            'gaps': {
+                'severe': {
+                    'line_width': (+0.05, "Increase line width"),
+                    'infill_overlap': (+10, "Increase infill overlap"),
+                    'skin_overlap': (+25, "Increase skin overlap"),
+                    'infill_density': (+5, "Increase infill density"),
+                    'wall_thickness': (+0.4, "Increase wall thickness"),
+                    'priority': ['line_width', 'infill_overlap', 'skin_overlap', 'wall_thickness'],
+                    'reason': "Severe gaps, optimize infill and overlap parameters"
+                }
+            }
+        }
+        
+        # Add common parameter preset combinations
+        self.parameter_presets = {
+            'quality_first': {
+                'name': "Quality-First Mode",
+                'description': "Focus on print quality, suitable for small precision models",
+                'params': {
+                    'layer_height': 0.12,
+                    'print_speed': 40,
+                    'acceleration': 500,
+                    'jerk': 8,
+                    'outer_wall_speed': 20,
+                    'initial_layer_speed': 15,
+                    'fan_speed': 100,
+                    'infill_density': 25,
+                    'wall_thickness': 1.2
+                },
+                'suitable_for': ["Small models", "Precision parts", "Display items"],
+                'trade_offs': "Longer print time but best quality"
+            },
+            'speed_first': {
+                'name': "Speed-First Mode",
+                'description': "Focus on print speed, suitable for prototypes",
+                'params': {
+                    'layer_height': 0.28,
+                    'print_speed': 100,
+                    'acceleration': 2000,
+                    'jerk': 15,
+                    'outer_wall_speed': 50,
+                    'initial_layer_speed': 25,
+                    'fan_speed': 100,
+                    'infill_density': 15,
+                    'wall_thickness': 0.8
+                },
+                'suitable_for': ["Quick prototypes", "Concept validation", "Large simple models"],
+                'trade_offs': "Rougher quality but fast printing"
+            },
+            'balanced': {
+                'name': "Balanced Mode",
+                'description': "Balance between quality and speed, suitable for daily printing",
+                'params': {
+                    'layer_height': 0.2,
+                    'print_speed': 60,
+                    'acceleration': 1000,
+                    'jerk': 10,
+                    'outer_wall_speed': 30,
+                    'initial_layer_speed': 20,
+                    'fan_speed': 100,
+                    'infill_density': 20,
+                    'wall_thickness': 1.0
+                },
+                'suitable_for': ["Daily items", "Medium-sized models", "General parts"],
+                'trade_offs': "Balanced compromise between quality and speed"
+            },
+            'strong_mechanical': {
+                'name': "Strength-First Mode",
+                'description': "Focus on mechanical strength, suitable for functional parts",
+                'params': {
+                    'layer_height': 0.2,
+                    'print_speed': 50,
+                    'wall_thickness': 1.6,
+                    'infill_density': 40,
+                    'infill_pattern': 'gyroid',
+                    'top_bottom_thickness': 1.2,
+                    'fan_speed': 80,
+                    'temperature': 215  # Slightly higher temperature for PLA
+                },
+                'suitable_for': ["Mechanical parts", "Load-bearing components", "Tools"],
+                'trade_offs': "Higher material usage and longer print time"
+            }
+        }
+        
+        # Add specific quick solutions for problems
+        self.quick_fixes = {
+            'stringing': {
+                'name': "Quick solution for stringing",
+                'description': "Quick solution for stringing problems",
+                'adjustments': {
+                    'retraction_distance': (+1, "Increase retraction distance"),
+                    'retraction_speed': (+10, "Increase retraction speed"),
+                    'temperature': (-5, "Slightly lower temperature"),
+                    'travel_speed': (+20, "Increase travel speed")
+                },
+                'explanation': "This set of parameters mainly increases retraction effect and cooling to reduce stringing"
+            },
+            'layer_adhesion': {
+                'name': "Increase layer adhesion",
+                'description': "Solve layer adhesion problems",
+                'adjustments': {
+                    'temperature': (+10, "Increase temperature"),
+                    'print_speed': (-5, "Slightly lower speed"),
+                    'fan_speed': (-20, "Lower fan speed"),
+                    'layer_height': (-0.04, "Reduce layer height")
+                },
+                'explanation': "Increase temperature and reduce cooling to increase layer adhesion"
+            }
+        }
+        
+    def preprocess_image(self, image):
+        """Preprocess image for model input
+        
+        Args:
+            image (PIL.Image): Input image
+            
+        Returns:
+            torch.Tensor: Preprocessed image tensor
+        """
+        # Convert to grayscale for better feature extraction
+        gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
+        
+        # Enhance contrast
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+        enhanced = clahe.apply(gray)
+        
+        # Convert back to RGB
+        enhanced_rgb = cv2.cvtColor(enhanced, cv2.COLOR_GRAY2RGB)
+        enhanced_pil = Image.fromarray(enhanced_rgb)
+        
+        # Transform for model
+        transform = transforms.Compose([
+            transforms.Resize((512, 512)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], 
+                              std=[0.229, 0.224, 0.225])
+        ])
+        
+        return transform(enhanced_pil).unsqueeze(0)
+        
+    def _detect_defects(self, pred_mask):
+        """Enhanced defect detection using HDBSCAN and traditional image processing
+        
+        Args:
+            pred_mask (np.array): Prediction mask from segmentation model
+            
+        Returns:
+            dict: Detected defects with their characteristics
+        """
+        defects = {}
+        
+        # 1. Traditional Image Processing
+        # Edge detection using Canny
+        edges = feature.canny(
+            pred_mask,
+            sigma=2,
+            low_threshold=0.1,
+            high_threshold=0.3
+        )
+        
+        # Local Binary Patterns for texture analysis
+        lbp = feature.local_binary_pattern(
+            pred_mask,
+            P=8,
+            R=1,
+            method='uniform'
+        )
+        
+        # Blob detection for finding continuous defect regions
+        blobs = feature.blob_log(
+            pred_mask,
+            max_sigma=30,
+            num_sigma=10,
+            threshold=.1
+        )
+        
+        # 2. HDBSCAN Clustering
+        # Convert mask to point coordinates
+        defect_coords = np.column_stack(np.where(pred_mask > 0))
+        
+        if len(defect_coords) > 0:
+            # Apply HDBSCAN clustering
+            clusterer = HDBSCAN(
+                min_cluster_size=5,
+                min_samples=3,
+                metric='euclidean',
+                cluster_selection_epsilon=0.5
+            )
+            cluster_labels = clusterer.fit_predict(defect_coords)
+            
+            # Analyze each cluster
+            for label in set(cluster_labels):
+                if label == -1:  # Noise points
+                    continue
+                    
+                cluster_points = defect_coords[cluster_labels == label]
+                
+                # Calculate cluster characteristics
+                center = np.mean(cluster_points, axis=0)
+                size = len(cluster_points)
+                density = size / cv2.convexHull(cluster_points).area
+                
+                # Analyze local texture using LBP
+                x_min, y_min = np.min(cluster_points, axis=0)
+                x_max, y_max = np.max(cluster_points, axis=0)
+                local_lbp = lbp[x_min:x_max+1, y_min:y_max+1]
+                texture_score = np.histogram(local_lbp, bins=10)[0]
+                
+                # Calculate edge density in cluster region
+                local_edges = edges[x_min:x_max+1, y_min:y_max+1]
+                edge_density = np.sum(local_edges) / local_edges.size
+                
+                # Determine defect type based on characteristics
+                defect_type = self._classify_defect(
+                    density=density,
+                    edge_density=edge_density,
+                    texture_score=texture_score,
+                    size=size
+                )
+                
+                if defect_type not in defects:
+                    defects[defect_type] = []
+                
+                defects[defect_type].append({
+                    'center': center,
+                    'size': size,
+                    'density': density,
+                    'edge_density': edge_density,
+                    'texture_score': texture_score,
+                    'points': cluster_points,
+                    'confidence': self._calculate_confidence(
+                        density, edge_density, size
+                    )
+                })
+        
+        return defects
+    
+    def _classify_defect(self, density, edge_density, texture_score, size):
+        """Classify defect type based on characteristics
+        
+        Args:
+            density (float): Point density in cluster
+            edge_density (float): Edge density in cluster region
+            texture_score (np.array): LBP histogram
+            size (int): Number of points in cluster
+            
+        Returns:
+            str: Defect type classification
+        """
+        # High density + High edge density -> Over extrusion
+        if density > 0.8 and edge_density > 0.6:
+            return 'over_extrusion'
+            
+        # Low density + High edge density -> Under extrusion
+        if density < 0.4 and edge_density > 0.7:
+            return 'under_extrusion'
+            
+        # High density + Linear arrangement -> Layer shift
+        if density > 0.6 and self._is_linear_arrangement(texture_score):
+            return 'layer_shift'
+            
+        # Low density + Scattered pattern -> Stringing
+        if density < 0.3 and self._is_scattered_pattern(texture_score):
+            return 'stringing'
+            
+        # Default case
+        return 'unknown_defect'
+    
+    def _calculate_confidence(self, density, edge_density, size):
+        """Calculate confidence score for defect detection
+        
+        Args:
+            density (float): Point density
+            edge_density (float): Edge density
+            size (int): Cluster size
+            
+        Returns:
+            float: Confidence score between 0 and 1
+        """
+        # Normalize size
+        size_score = min(size / 1000, 1.0)
+        
+        # Combine metrics with weights
+        confidence = (
+            0.4 * density +
+            0.3 * edge_density +
+            0.3 * size_score
+        )
+        
+        return min(confidence, 1.0)
+    
+    def _is_linear_arrangement(self, texture_score):
+        """Check if texture suggests linear arrangement"""
+        # Analyze LBP histogram for linear patterns
+        peak_ratio = np.max(texture_score) / np.mean(texture_score)
+        return peak_ratio > 3.0
+    
+    def _is_scattered_pattern(self, texture_score):
+        """Check if texture suggests scattered pattern"""
+        # Analyze LBP histogram for scattered patterns
+        entropy = -np.sum(texture_score * np.log2(texture_score + 1e-10))
+        return entropy > 3.0
+    
+    def detect_defects(self, image):
+        """Detect printing defects in real-time
+        
+        Args:
+            image (PIL.Image): Input image from camera
+            
+        Returns:
+            dict: {
+                'mask': segmentation mask,
+                'defects': list of detected defects with coordinates and types,
+                'quality_score': overall quality score,
+                'suggestions': parameter adjustment suggestions
+            }
+        """
+        # Preprocess image
+        img_tensor = self.preprocess_image(image)
+        
+        # Get model prediction
+        with torch.no_grad():
+            outputs = self.model(img_tensor.to(self.device))
+            logits = outputs.logits
+            pred_mask = torch.argmax(logits, dim=1)[0].cpu().numpy()
+        
+        # Analyze different types of defects
+        defects = []
+        
+        # 1. Detect over-extrusion regions
+        over_regions = self._detect_over_extrusion(pred_mask)
+        defects.extend([{
+            'type': 'over_extrusion',
+            'region': region,
+            'confidence': conf,
+            'suggestion': {
+                'extrusion_multi': '-0.05',
+                'nozzle_temp': '-5°C',
+                'reason': 'Reduce material flow and temperature'
+            }
+        } for region, conf in over_regions])
+        
+        # 2. Detect under-extrusion regions
+        under_regions = self._detect_under_extrusion(pred_mask)
+        defects.extend([{
+            'type': 'under_extrusion',
+            'region': region,
+            'confidence': conf,
+            'suggestion': {
+                'extrusion_multi': '+0.05',
+                'nozzle_temp': '+10°C',
+                'reason': 'Increase material flow and temperature'
+            }
+        } for region, conf in under_regions])
+        
+        # 3. Detect layer shifts
+        shifts = self._detect_layer_shifts(pred_mask)
+        defects.extend([{
+            'type': 'layer_shift',
+            'region': region,
+            'confidence': conf,
+            'suggestion': {
+                'print_speed': '-10mm/s',
+                'reason': 'Reduce speed to prevent shifts'
+            }
+        } for region, conf in shifts])
+        
+        # Calculate overall quality score
+        quality_score = self._calculate_quality_score(pred_mask, defects)
+        
+        return {
+            'mask': pred_mask,
+            'defects': defects,
+            'quality_score': quality_score,
+            'visualization': self._generate_visualization(image, defects)
+        }
+    
+    def _detect_over_extrusion(self, mask):
+        """Detect over-extrusion regions using image processing"""
+        over_mask = mask == 2  # over-extrusion class
+        
+        # Find connected components
+        num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(
+            over_mask.astype(np.uint8), connectivity=8
+        )
+        
+        regions = []
+        for i in range(1, num_labels):  # Skip background
+            if stats[i, cv2.CC_STAT_AREA] > 50:  # Min area threshold
+                x = stats[i, cv2.CC_STAT_LEFT]
+                y = stats[i, cv2.CC_STAT_TOP]
+                w = stats[i, cv2.CC_STAT_WIDTH]
+                h = stats[i, cv2.CC_STAT_HEIGHT]
+                
+                # Calculate confidence based on area and intensity
+                area_score = min(stats[i, cv2.CC_STAT_AREA] / 500, 1.0)
+                intensity = np.mean(mask[labels == i])
+                conf = (area_score + intensity) / 2
+                
+                regions.append(((x, y, w, h), conf))
+                
+        return regions
+    
+    def _detect_under_extrusion(self, mask):
+        """Detect under-extrusion using morphological operations"""
+        under_mask = mask == 3  # under-extrusion class
+        
+        # Apply morphological operations to find gaps
+        kernel = np.ones((3,3), np.uint8)
+        dilated = cv2.dilate(under_mask.astype(np.uint8), kernel, iterations=1)
+        gaps = cv2.subtract(dilated, under_mask.astype(np.uint8))
+        
+        # Find contours of gaps
+        contours, _ = cv2.findContours(gaps, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        regions = []
+        for contour in contours:
+            if cv2.contourArea(contour) > 30:  # Min area threshold
+                x, y, w, h = cv2.boundingRect(contour)
+                # Calculate confidence based on gap size
+                conf = min(cv2.contourArea(contour) / 300, 1.0)
+                regions.append(((x, y, w, h), conf))
+                
+        return regions
+    
+    def _detect_layer_shifts(self, mask):
+        """Detect layer shifts using edge detection and line analysis"""
+        # Edge detection
+        edges = cv2.Canny(mask.astype(np.uint8), 100, 200)
+        
+        # Detect lines using Hough transform
+        lines = cv2.HoughLinesP(edges, 1, np.pi/180, 50, 
+                               minLineLength=40, maxLineGap=10)
+        
+        regions = []
+        if lines is not None:
+            for line in lines:
+                x1, y1, x2, y2 = line[0]
+                # Check for horizontal displacement
+                angle = np.abs(np.arctan2(y2-y1, x2-x1) * 180 / np.pi)
+                if 80 < angle < 100:  # Near horizontal lines
+                    conf = min((100 - np.abs(90 - angle)) / 10, 1.0)
+                    regions.append(((x1, y1, x2-x1, 10), conf))
+                    
+        return regions
+    
+    def _calculate_quality_score(self, mask, defects):
+        """Calculate overall quality score based on defects"""
+        # Base score from normal print area ratio
+        normal_ratio = np.sum(mask == 1) / mask.size
+        base_score = normal_ratio * 100
+        
+        # Deduct points for defects based on confidence
+        for defect in defects:
+            penalty = defect['confidence'] * 10
+            if defect['type'] == 'layer_shift':
+                penalty *= 2  # Layer shifts are more serious
+            base_score -= penalty
+            
+        return max(0, min(100, base_score))
+    
+    def _analyze_pixel_defects(self, pred_mask, reference_gcode=None):
+        """Analyze pixel-level defects
+        
+        Args:
+            pred_mask (np.array): Prediction mask
+            reference_gcode: Optional G-code reference
+            
+        Returns:
+            dict: Detailed defect metrics
+        """
+        total_pixels = pred_mask.size
+        normal_print = np.sum(pred_mask == 1)
+        over_extrusion = np.sum(pred_mask == 2)
+        under_extrusion = np.sum(pred_mask == 3)
+        
+        # Compare with reference if available
+        if reference_gcode is not None:
+            expected_mask = self._generate_expected_mask(reference_gcode)
+            unexpected_print = np.logical_and(pred_mask > 0, expected_mask == 0)
+            missing_print = np.logical_and(pred_mask == 0, expected_mask > 0)
+        else:
+            unexpected_print = np.zeros_like(pred_mask, dtype=bool)
+            missing_print = np.zeros_like(pred_mask, dtype=bool)
+        
+        return {
+            'normal_ratio': normal_print / total_pixels,
+            'over_extrusion_ratio': over_extrusion / total_pixels,
+            'under_extrusion_ratio': under_extrusion / total_pixels,
+            'unexpected_print_pixels': np.sum(unexpected_print),
+            'missing_print_pixels': np.sum(missing_print),
+            'defect_locations': self._get_defect_locations(pred_mask)
+        }
+    
+    def _get_defect_locations(self, pred_mask):
+        """Get coordinates of defect regions
+        
+        Args:
+            pred_mask (np.array): Prediction mask
+            
+        Returns:
+            dict: Coordinates of different defect types
+        """
+        defect_coords = {
+            'over_extrusion': np.where(pred_mask == 2),
+            'under_extrusion': np.where(pred_mask == 3),
+        }
+        
+        # Group nearby defects into regions
+        defect_regions = {}
+        for defect_type, coords in defect_coords.items():
+            regions = self._cluster_defect_points(coords)
+            defect_regions[defect_type] = regions
+            
+        return defect_regions
+    
+    def _cluster_defect_points(self, coords):
+        """Cluster nearby defect points into regions using DBSCAN
+        
+        Args:
+            coords: Tuple of x,y coordinates
+            
+        Returns:
+            list: List of defect regions with their coordinates
+        """
+        if len(coords[0]) == 0:
+            return []
+            
+        points = np.column_stack(coords)
+        clustering = DBSCAN(eps=5, min_samples=4).fit(points)
+        
+        regions = []
+        for label in set(clustering.labels_):
+            if label == -1:  # Noise points
+                continue
+            mask = clustering.labels_ == label
+            region_points = points[mask]
+            regions.append({
+                'center': region_points.mean(axis=0),
+                'size': len(region_points),
+                'points': region_points
+            })
+            
+        return regions
+
+    def _generate_expected_mask(self, reference_gcode):
+        # Implementation of _generate_expected_mask method
+        pass
+
+    def _generate_visualization(self, image, defects):
+        # Implementation of _generate_visualization method
+        pass
+
+    def generate_parameter_suggestions(self, defects):
+        """Generate parameter adjustment suggestions based on detected defects
+        
+        Args:
+            defects (dict): Detected defect information
+            
+        Returns:
+            dict: Parameter adjustment suggestions
+        """
+        suggestions = {}
+        current_adjustments = {}  # Record already suggested adjustments
+        
+        # Sort defects by confidence
+        sorted_defects = sorted(
+            defects.items(), 
+            key=lambda x: x[1]['confidence'], 
+            reverse=True
+        )
+        
+        for defect_type, defect_info in sorted_defects:
+            if defect_info['confidence'] > 0.8:
+                severity = 'severe'
+            elif defect_info['confidence'] > 0.5:
+                severity = 'moderate'
+            else:
+                continue
+                
+            if defect_type in self.parameter_rules:
+                rule = self.parameter_rules[defect_type][severity]
+                
+                # Apply adjustment suggestions based on priority
+                for param in rule['priority']:
+                    if param not in current_adjustments:
+                        adjustment, reason = rule[param]
+                        current_adjustments[param] = adjustment
+                        
+                        if param not in suggestions:
+                            suggestions[param] = {
+                                'adjustment': adjustment,
+                                'reason': f"{reason} (Due to {defect_type})",
+                                'confidence': defect_info['confidence']
+                            }
+                        else:
+                            # If there's already a suggestion, take the larger adjustment
+                            if abs(adjustment) > abs(suggestions[param]['adjustment']):
+                                suggestions[param]['adjustment'] = adjustment
+                                suggestions[param]['reason'] += f"\n{reason} (Due to {defect_type})"
+        
+        return suggestions
+
+    def _analyze_defect_severity(self, defect_regions):
+        """Analyze the severity of defects
+        
+        Args:
+            defect_regions (dict): Defect region information
+            
+        Returns:
+            dict: Severity assessment of different defect types
+        """
+        severity = {}
+        for defect_type, regions in defect_regions.items():
+            if not regions:
+                continue
+                
+            # Calculate total area of defect regions
+            total_area = sum(region['size'] for region in regions)
+            # Calculate maximum continuous defect region
+            max_area = max(region['size'] for region in regions)
+            # Calculate number of defect regions
+            num_regions = len(regions)
+            
+            # Comprehensive severity assessment
+            severity[defect_type] = {
+                'confidence': min(1.0, (total_area / 1000 + max_area / 500 + num_regions / 5) / 3),
+                'total_area': total_area,
+                'max_area': max_area,
+                'num_regions': num_regions
+            } 
+
+    def suggest_preset(self, model_size, quality_requirement, time_constraint):
+        """Recommend preset parameter combination based on printing requirements
+        
+        Args:
+            model_size: "small"/"medium"/"large"
+            quality_requirement: "high"/"medium"/"low"
+            time_constraint: "tight"/"normal"/"relaxed"
+            
+        Returns:
+            dict: Recommended preset configuration
+        """
+        if quality_requirement == "high" and time_constraint == "relaxed":
+            return self.parameter_presets['quality_first']
+        elif time_constraint == "tight" and quality_requirement == "low":
+            return self.parameter_presets['speed_first']
+        else:
+            return self.parameter_presets['balanced'] 
+
+    def analyze_print_quality(self, image, gcode_layer):
+        """Analyze print quality by comparing actual print with expected G-code path
+        
+        Args:
+            image (PIL.Image): Current layer image from camera
+            gcode_layer (dict): Current layer G-code information
+            
+        Returns:
+            dict: Quality analysis results
+        """
+        # Get expected filament path from G-code
+        expected_path = self.gcode_analyzer.get_layer_path(gcode_layer)
+        
+        # Align camera image with G-code coordinates
+        aligned_image = self.align_image_to_gcode(image, expected_path)
+        
+        # Segment the actual printed material
+        actual_material = self.segment_material(aligned_image)
+        
+        # Generate expected material mask from G-code path
+        expected_mask = self.generate_path_mask(expected_path)
+        
+        # Calculate coverage metrics
+        metrics = self.calculate_coverage_metrics(actual_material, expected_mask)
+        
+        return {
+            'metrics': metrics,
+            'visualization': self.visualize_comparison(
+                aligned_image, actual_material, expected_mask)
+        }
+    
+    def calculate_coverage_metrics(self, actual, expected):
+        """Calculate coverage metrics between actual print and expected path
+        
+        Args:
+            actual (np.array): Binary mask of actual printed material
+            expected (np.array): Binary mask of expected material from G-code
+            
+        Returns:
+            dict: Coverage metrics
+        """
+        # Where material should be (positive coverage)
+        should_have_material = expected == 1
+        correct_material = np.logical_and(actual == 1, should_have_material)
+        missing_material = np.logical_and(actual == 0, should_have_material)
+        
+        # Where material shouldn't be (negative coverage)
+        should_not_have_material = expected == 0
+        excess_material = np.logical_and(actual == 1, should_not_have_material)
+        correct_empty = np.logical_and(actual == 0, should_not_have_material)
+        
+        # Calculate metrics
+        positive_coverage = np.sum(correct_material) / np.sum(should_have_material)
+        negative_coverage = np.sum(correct_empty) / np.sum(should_not_have_material)
+        
+        # Calculate error metrics
+        missing_ratio = np.sum(missing_material) / np.sum(should_have_material)
+        excess_ratio = np.sum(excess_material) / np.sum(should_not_have_material)
+        
+        return {
+            'positive_coverage': positive_coverage,  # Material where it should be
+            'negative_coverage': negative_coverage,  # No material where it shouldn't be
+            'missing_ratio': missing_ratio,         # Missing material ratio
+            'excess_ratio': excess_ratio,           # Excess material ratio
+            'overall_score': (positive_coverage + negative_coverage) / 2
+        }
+    
+    def align_image_to_gcode(self, image, gcode_path):
+        """Align camera image with G-code coordinates using reference points
+        
+        Args:
+            image (PIL.Image): Camera image
+            gcode_path (dict): G-code path information
+            
+        Returns:
+            np.array: Aligned image
+        """
+        # Find reference points in image (e.g., bed corners, calibration marks)
+        image_points = self.detect_reference_points(image)
+        
+        # Get corresponding points from G-code coordinates
+        gcode_points = self.gcode_analyzer.get_reference_points()
+        
+        # Calculate transformation matrix
+        transform_matrix = cv2.getPerspectiveTransform(
+            image_points.astype(np.float32),
+            gcode_points.astype(np.float32)
+        )
+        
+        # Apply transformation
+        aligned_image = cv2.warpPerspective(
+            np.array(image),
+            transform_matrix,
+            (image.width, image.height)
+        )
+        
+        return aligned_image
+    
+    def visualize_comparison(self, image, actual, expected):
+        """Generate visualization comparing actual print with expected path
+        
+        Args:
+            image (np.array): Original aligned image
+            actual (np.array): Binary mask of actual material
+            expected (np.array): Binary mask of expected material
+            
+        Returns:
+            PIL.Image: Visualization image
+        """
+        # Create RGB visualization
+        vis = np.zeros((*image.shape[:2], 3), dtype=np.uint8)
+        
+        # Green: Correct material placement
+        vis[np.logical_and(actual == 1, expected == 1)] = [0, 255, 0]
+        
+        # Red: Missing material
+        vis[np.logical_and(actual == 0, expected == 1)] = [255, 0, 0]
+        
+        # Yellow: Excess material
+        vis[np.logical_and(actual == 1, expected == 0)] = [255, 255, 0]
+        
+        # Blend with original image
+        alpha = 0.6
+        blended = cv2.addWeighted(image, 1-alpha, vis, alpha, 0)
+        
+        return Image.fromarray(blended) 

mo_optimizer.py

@@ -0,0 +1,232 @@
+import numpy as np
+import hdbscan
+from skimage import feature, filters
+import cv2
+from typing import Dict, Any
+
+class MOPrintOptimizer:
+    """Multi-objective optimizer for print parameters"""
+    
+    def __init__(self):
+        # Weights for different objectives
+        self.weights = {
+            'quality': 0.4,
+            'speed': 0.3,
+            'material': 0.3
+        }
+        
+        # Quality thresholds
+        self.quality_thresholds = {
+            'missing_rate': 0.1,    # 10% missing is bad
+            'excess_rate': 0.1,     # 10% excess is bad
+            'stringing_rate': 0.05, # 5% stringing is bad
+            'uniformity': 0.8       # At least 80% uniformity is good
+        }
+        
+        # Material efficiency parameters
+        self.material_params = {
+            'optimal_flow_rate': 100,  # 100% flow rate
+            'flow_tolerance': 10,      # ±10% tolerance
+            'optimal_layer_height': 0.2  # 0.2mm layer height
+        }
+    
+    def evaluate_quality(self, metrics: Dict[str, float]) -> float:
+        """Evaluate print quality score
+        
+        Args:
+            metrics: Dictionary containing quality metrics
+                - missing_rate: Percentage of missing material
+                - excess_rate: Percentage of excess material
+                - stringing_rate: Percentage of stringing
+                - uniformity_score: Score for print uniformity
+        
+        Returns:
+            float: Quality score (0-1)
+        """
+        # Convert each metric to a score (0-1)
+        missing_score = 1.0 - min(1.0, metrics['missing_rate'] / self.quality_thresholds['missing_rate'])
+        excess_score = 1.0 - min(1.0, metrics['excess_rate'] / self.quality_thresholds['excess_rate'])
+        stringing_score = 1.0 - min(1.0, metrics['stringing_rate'] / self.quality_thresholds['stringing_rate'])
+        uniformity_score = metrics['uniformity_score']
+        
+        # Combine scores with equal weights
+        quality_score = np.mean([
+            missing_score,
+            excess_score,
+            stringing_score,
+            uniformity_score
+        ])
+        
+        return float(quality_score)
+    
+    def evaluate_material_efficiency(self, params: Dict[str, float]) -> float:
+        """Evaluate material efficiency
+        
+        Args:
+            params: Current print parameters
+        
+        Returns:
+            float: Material efficiency score (0-1)
+        """
+        # Flow rate deviation from optimal
+        flow_deviation = abs(params['flow_rate'] - self.material_params['optimal_flow_rate'])
+        flow_score = 1.0 - min(1.0, flow_deviation / self.material_params['flow_tolerance'])
+        
+        # Layer height optimization (thicker layers use less material for same volume)
+        layer_score = params['layer_height'] / self.material_params['optimal_layer_height']
+        layer_score = min(1.0, layer_score)  # Cap at 1.0
+        
+        # Retraction optimization (less retraction is better for material efficiency)
+        retraction_score = 1.0 - (params['retraction_distance'] / 10.0)  # Assuming max 10mm
+        
+        # Combine scores
+        material_score = np.mean([
+            flow_score * 0.4,  # Flow rate is most important
+            layer_score * 0.4, # Layer height equally important
+            retraction_score * 0.2  # Retraction less important
+        ])
+        
+        return float(material_score)
+    
+    def evaluate_objectives(self, image: np.ndarray, params: Dict[str, float]) -> Dict[str, Any]:
+        """Evaluate all objectives and combine them
+        
+        Args:
+            image: Print image for quality analysis
+            params: Current print parameters
+        
+        Returns:
+            dict: Evaluation results including individual scores and total
+        """
+        # Get quality metrics from image analysis
+        quality_metrics = {
+            'missing_rate': 0.05,    # These should come from DefectDetector
+            'excess_rate': 0.03,     # in real implementation
+            'stringing_rate': 0.02,
+            'uniformity_score': 0.95
+        }
+        
+        # Calculate individual objective scores
+        quality_score = self.evaluate_quality(quality_metrics)
+        speed_score = params['print_speed'] / 150.0  # Normalize to max speed
+        material_score = self.evaluate_material_efficiency(params)
+        
+        # Combine objectives using weights
+        total_score = (
+            quality_score * self.weights['quality'] +
+            speed_score * self.weights['speed'] +
+            material_score * self.weights['material']
+        )
+        
+        return {
+            'objectives': {
+                'quality': float(quality_score),
+                'speed': float(speed_score),
+                'material': float(material_score),
+                'total': float(total_score)
+            },
+            'metrics': quality_metrics
+        }
+    
+    def evaluate_print_quality(self, image, expected_pattern=None):
+        """Evaluate print quality using hybrid approach
+        
+        Args:
+            image: Current print image
+            expected_pattern: Expected print pattern (optional)
+            
+        Returns:
+            dict: Quality metrics
+        """
+        # 1. Traditional Image Processing
+        edge_metrics = self._analyze_edges(image)
+        surface_metrics = self._analyze_surface(image)
+        
+        # 2. HDBSCAN-based defect clustering
+        defect_metrics = self._cluster_defects(image)
+        
+        # 3. Pattern matching if expected pattern provided
+        pattern_metrics = self._analyze_pattern(image, expected_pattern) if expected_pattern else {}
+        
+        return {
+            'edge_quality': edge_metrics,
+            'surface_quality': surface_metrics,
+            'defect_analysis': defect_metrics,
+            'pattern_accuracy': pattern_metrics
+        }
+    
+    def _analyze_edges(self, image):
+        """Analyze edge quality using traditional methods"""
+        # Multi-scale edge detection
+        edges_fine = feature.canny(image, sigma=1)
+        edges_medium = feature.canny(image, sigma=2)
+        edges_coarse = feature.canny(image, sigma=3)
+        
+        return {
+            'fine_edge_score': np.mean(edges_fine),
+            'medium_edge_score': np.mean(edges_medium),
+            'coarse_edge_score': np.mean(edges_coarse),
+            'edge_consistency': self._calculate_edge_consistency(
+                [edges_fine, edges_medium, edges_coarse]
+            )
+        }
+    
+    def _analyze_surface(self, image):
+        """Analyze surface quality using texture analysis"""
+        # Local Binary Patterns for texture
+        lbp = feature.local_binary_pattern(image, P=8, R=1, method='uniform')
+        
+        # GLCM features
+        glcm = feature.graycomatrix(image, [1], [0, np.pi/4, np.pi/2, 3*np.pi/4])
+        contrast = feature.graycoprops(glcm, 'contrast')
+        homogeneity = feature.graycoprops(glcm, 'homogeneity')
+        
+        return {
+            'texture_uniformity': np.std(lbp),
+            'surface_contrast': np.mean(contrast),
+            'surface_homogeneity': np.mean(homogeneity)
+        }
+    
+    def _cluster_defects(self, image):
+        """Use HDBSCAN to cluster potential defects"""
+        # Extract potential defect points
+        defect_points = self._extract_defect_points(image)
+        
+        if len(defect_points) > 0:
+            # Apply HDBSCAN clustering
+            clusterer = hdbscan.HDBSCAN(
+                min_cluster_size=3,
+                min_samples=2,
+                metric='euclidean',
+                cluster_selection_epsilon=0.5
+            )
+            cluster_labels = clusterer.fit_predict(defect_points)
+            
+            # Analyze clusters
+            return self._analyze_defect_clusters(defect_points, cluster_labels)
+        
+        return {'defect_count': 0, 'cluster_sizes': [], 'defect_density': 0}
+    
+    def _calculate_edge_consistency(self, edges):
+        """Calculate edge consistency"""
+        return np.mean([np.mean(edge) for edge in edges])
+
+    def _analyze_pattern(self, image, expected_pattern):
+        """Analyze pattern accuracy"""
+        # Placeholder for pattern matching
+        return 0.8  # Assuming 80% accuracy
+
+    def _extract_defect_points(self, image):
+        """Extract potential defect points"""
+        # Placeholder for defect point extraction
+        return np.array([[0, 0], [1, 1], [2, 2]])  # Placeholder points
+
+    def _analyze_defect_clusters(self, defect_points, cluster_labels):
+        """Analyze defect clusters"""
+        # Placeholder for cluster analysis
+        return {'defect_count': len(np.unique(cluster_labels)), 'cluster_sizes': [], 'defect_density': 0}
+
+    def _apply_parameter_adjustments(self, current_params, adjustments):
+        """Apply parameter adjustments"""
+        # Placeholder for parameter adjustment logic
+        return current_params  # Placeholder return 

requirements.txt

@@ -0,0 +1,26 @@
+# UI and Web
+gradio>=4.0.0
+
+# Core Data Processing
+numpy>=1.20.0
+pandas>=1.3.0
+scipy>=1.7.0
+
+# Image Processing
+opencv-python-headless>=4.5.0
+scikit-image>=0.19.0
+Pillow>=8.0.0
+
+# Machine Learning
+scikit-learn>=0.24.0
+hdbscan>=0.8.29
+
+# Communication
+paho-mqtt>=1.6.1
+
+# Configuration
+python-dotenv>=0.19.0
+
+# Utilities
+tqdm>=4.62.0
+matplotlib>=3.4.0