Bubbling What Is in 3D Printing and Why It Matters

import cv2
import numpy as np
import time
import smtplib
from email.mime.text import MIMEText
from typing import Optional, List

class ResinBubbleDetector:
    """Real-time bubble detector for SLA resin vats using OpenCV."""
    def __init__(self, camera_id: int = 0, bubble_area_threshold: int = 100,
                 alert_email: Optional[str] = None, smtp_config: Optional[dict] = None):
        self.bubble_area_threshold = bubble_area_threshold
        self.alert_email = alert_email
        self.smtp_config = smtp_config or {}
        self.frame_count = 0
        self.bubble_count = 0

        # Initialize camera with error handling
        self.cap = cv2.VideoCapture(camera_id)
        if not self.cap.isOpened():
            raise RuntimeError(f"Failed to open camera with ID {camera_id}")
        # Set 1080p resolution at 30 FPS
        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)
        self.cap.set(cv2.CAP_PROP_FPS, 30)

    def capture_frame(self) -> Optional[np.ndarray]:
        """Capture a single frame from the camera with error handling."""
        try:
            ret, frame = self.cap.read()
            if not ret:
                print(f"Warning: Failed to capture frame {self.frame_count}")
                return None
            self.frame_count += 1
            return frame
        except Exception as e:
            print(f"Camera capture error: {str(e)}")
            return None

    def process_frame(self, frame: np.ndarray) -> tuple[np.ndarray, List[np.ndarray]]:
        """Process frame to detect bubbles, return annotated frame and bubble contours."""
        # Convert to grayscale and apply Gaussian blur to reduce noise
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(gray, (5, 5), 0)

        # Threshold to isolate bright bubbles (resin is clear, bubbles are dark)
        _, thresh = cv2.threshold(blurred, 200, 255, cv2.THRESH_BINARY_INV)

        # Find contours of potential bubbles
        contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

        # Filter contours by minimum area threshold
        bubbles = [c for c in contours if cv2.contourArea(c) > self.bubble_area_threshold]

        # Annotate frame with bubble outlines
        annotated = frame.copy()
        cv2.drawContours(annotated, bubbles, -1, (0, 0, 255), 2)
        cv2.putText(annotated, f"Bubbles: {len(bubbles)}", (10, 30),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)

        self.bubble_count += len(bubbles)
        return annotated, bubbles

    def send_alert(self, bubble_count: int) -> None:
        """Send email alert if bubble count exceeds threshold."""
        if not self.alert_email or not self.smtp_config:
            return
        try:
            msg = MIMEText(f"Alert: Detected {bubble_count} bubbles in resin vat")
            msg['Subject'] = 'SLA Vat Bubble Alert'
            msg['From'] = self.smtp_config.get('user', 'detector@printer.local')
            msg['To'] = self.alert_email

            with smtplib.SMTP(self.smtp_config['host'], self.smtp_config['port']) as server:
                server.starttls()
                server.login(self.smtp_config['user'], self.smtp_config['password'])
                server.send_message(msg)
            print(f"Sent alert email to {self.alert_email}")
        except Exception as e:
            print(f"Failed to send alert email: {str(e)}")

    def run(self, duration_sec: int = 3600) -> None:
        """Run detection loop for specified duration."""
        start_time = time.time()
        print(f"Starting bubble detection for {duration_sec} seconds...")
        while time.time() - start_time < duration_sec:
            frame = self.capture_frame()
            if frame is None:
                time.sleep(0.1)
                continue

            annotated, bubbles = self.process_frame(frame)

            # Display frame (comment out for headless operation)
            cv2.imshow('Resin Vat Bubble Detection', annotated)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break

            # Send alert if >5 bubbles in single frame
            if len(bubbles) > 5:
                self.send_alert(len(bubbles))

            time.sleep(1/30)  # Maintain 30 FPS

        # Cleanup
        self.cap.release()
        cv2.destroyAllWindows()
        print(f"Total frames processed: {self.frame_count}")
        print(f"Total bubbles detected: {self.bubble_count}")

if __name__ == '__main__':
    # Example configuration (update with real SMTP credentials)
    SMTP_CONFIG = {
        'host': 'smtp.gmail.com',
        'port': 587,
        'user': 'your-email@gmail.com',
        'password': 'your-app-password'
    }
    try:
        detector = ResinBubbleDetector(
            camera_id=0,
            bubble_area_threshold=100,
            alert_email='admin@printlab.com',
            smtp_config=SMTP_CONFIG
        )
        detector.run(duration_sec=3600)
    except Exception as e:
        print(f"Fatal error: {str(e)}")

import re
import sys
from typing import Dict, List, Optional

class GCodeBubblePreventer:
    """Post-process G-code to prevent FDM bubbling defects."""
    def __init__(self, moisture_rh: float = 0.0, max_temp_reduction: int = 10,
                 extrusion_multiplier: float = 0.95, retraction_adjust: float = -0.5):
        self.moisture_rh = max(0.0, min(100.0, moisture_rh))
        self.max_temp_reduction = max_temp_reduction
        self.extrusion_multiplier = extrusion_multiplier
        self.retraction_adjust = retraction_adjust
        # Regex patterns for common G-code commands
        self.temp_pattern = re.compile(r'M104\s+S(\d+)')  # Set extruder temp
        self.extrude_pattern = re.compile(r'G1\s+.*E([\d.]+)')  # Extrusion move
        self.retract_pattern = re.compile(r'G10')  # Retract
        self.unretract_pattern = re.compile(r'G11')  # Unretract

    def _adjust_temperature(self, line: str) -> str:
        """Reduce extrusion temperature for moist filament."""
        match = self.temp_pattern.match(line.strip())
        if not match:
            return line
        current_temp = int(match.group(1))
        # Reduce temp by 5°C per 10% RH above 30%
        if self.moisture_rh > 30:
            reduction = min(self.max_temp_reduction, int((self.moisture_rh - 30) / 10 * 5))
            new_temp = max(180, current_temp - reduction)  # Never go below 180°C
            return line.replace(f'S{current_temp}', f'S{new_temp}')
        return line

    def _adjust_extrusion(self, line: str) -> str:
        """Apply extrusion multiplier to reduce over-extrusion bubbling."""
        match = self.extrude_pattern.match(line.strip())
        if not match:
            return line
        current_e = float(match.group(1))
        new_e = current_e * self.extrusion_multiplier
        return line.replace(f'E{current_e}', f'E{new_e:.4f}')

    def _adjust_retraction(self, line: str) -> str:
        """Adjust retraction length to reduce air intake during retraction."""
        if self.retract_pattern.match(line.strip()):
            # Add retraction length adjustment (G10 normally uses P parameter for length)
            if 'P' not in line:
                return f'{line.strip()} P{abs(self.retraction_adjust):.2f}\n'
            else:
                # Adjust existing P value
                p_match = re.search(r'P([\d.]+)', line)
                if p_match:
                    current_p = float(p_match.group(1))
                    new_p = max(0.0, current_p + self.retraction_adjust)
                    return line.replace(f'P{current_p}', f'P{new_p:.2f}')
        return line

    def process_file(self, input_path: str, output_path: str) -> None:
        """Process input G-code file and write adjusted G-code to output."""
        try:
            with open(input_path, 'r', encoding='utf-8') as f:
                lines = f.readlines()
        except FileNotFoundError:
            raise FileNotFoundError(f"Input G-code file not found: {input_path}")
        except Exception as e:
            raise RuntimeError(f"Error reading input file: {str(e)}")

        processed_lines = []
        for line_num, line in enumerate(lines, 1):
            try:
                # Skip comment lines
                if line.strip().startswith(';'):
                    processed_lines.append(line)
                    continue
                # Apply adjustments in order: temp, extrusion, retraction
                adjusted = self._adjust_temperature(line)
                adjusted = self._adjust_extrusion(adjusted)
                adjusted = self._adjust_retraction(adjusted)
                processed_lines.append(adjusted)
            except Exception as e:
                print(f"Warning: Error processing line {line_num}: {str(e)}")
                processed_lines.append(line)  # Keep original line on error

        try:
            with open(output_path, 'w', encoding='utf-8') as f:
                f.writelines(processed_lines)
            print(f"Processed G-code written to {output_path}")
            print(f"Adjusted for filament moisture: {self.moisture_rh}% RH")
        except Exception as e:
            raise RuntimeError(f"Error writing output file: {str(e)}")

if __name__ == '__main__':
    if len(sys.argv) != 4:
        print("Usage: python gcode_preventer.py   ")
        sys.exit(1)
    input_path = sys.argv[1]
    output_path = sys.argv[2]
    try:
        moisture_rh = float(sys.argv[3])
    except ValueError:
        print("Error: Moisture RH must be a numeric value")
        sys.exit(1)

    preventer = GCodeBubblePreventer(moisture_rh=moisture_rh)
    try:
        preventer.process_file(input_path, output_path)
    except Exception as e:
        print(f"Fatal error: {str(e)}")
        sys.exit(1)

import numpy as np
from dataclasses import dataclass
from typing import Optional

@dataclass
class SimParams:
    """Parameters for PBF bubble simulation."""
    laser_power: float  # Watts, range 10-100W
    scan_speed: float   # mm/s, range 100-5000 mm/s
    humidity: float     # Powder moisture %, range 0-1.0%
    num_layers: int     # Number of printed layers, >0
    num_simulations: int  # Number of Monte Carlo runs, >0
    layer_height: float  # mm, default 0.1mm

class PowderBedBubbleSim:
    """Monte Carlo simulation of bubbling defects in Powder Bed Fusion."""
    def __init__(self, params: SimParams):
        self._validate_params(params)
        self.params = params
        self.defect_prob_map: Optional[np.ndarray] = None
        self.avg_bubble_count: float = 0.0

    def _validate_params(self, params: SimParams) -> None:
        """Validate simulation parameters."""
        if params.laser_power <= 0 or params.laser_power > 100:
            raise ValueError(f"Laser power must be 0 < P <= 100W, got {params.laser_power}")
        if params.scan_speed <= 0 or params.scan_speed > 5000:
            raise ValueError(f"Scan speed must be 0 < S <= 5000 mm/s, got {params.scan_speed}")
        if params.humidity < 0 or params.humidity > 1.0:
            raise ValueError(f"Humidity must be 0 <= H <= 1.0%, got {params.humidity}")
        if params.num_layers <= 0:
            raise ValueError(f"Number of layers must be positive, got {params.num_layers}")
        if params.num_simulations <= 0:
            raise ValueError(f"Number of simulations must be positive, got {params.num_simulations}")

    def run_simulation(self) -> None:
        """Run Monte Carlo simulations to calculate average bubble count."""
        total_bubbles = 0
        # Base bubble probability per layer: scales with humidity, laser power, inverse scan speed
        base_prob = 0.01 * (self.params.humidity / 1.0) * (self.params.laser_power / 50) * (1000 / self.params.scan_speed)
        # Ensure probability is between 0 and 1
        base_prob = max(0.0, min(1.0, base_prob))

        for sim in range(self.params.num_simulations):
            sim_bubbles = 0
            for layer in range(self.params.num_layers):
                # Add random noise to probability (±20%)
                layer_prob = base_prob * np.random.uniform(0.8, 1.2)
                layer_prob = max(0.0, min(1.0, layer_prob))
                # Count bubbles in layer (Poisson distribution for rare events)
                sim_bubbles += np.random.poisson(layer_prob * 100)  # per 100mm²
            total_bubbles += sim_bubbles
        self.avg_bubble_count = total_bubbles / self.params.num_simulations

    def generate_defect_map(self, width: int = 100) -> np.ndarray:
        """Generate a 2D defect probability map (layers x width)."""
        if self.avg_bubble_count == 0.0:
            self.run_simulation()
        # Normalize bubble count to probability per mm²
        prob_per_mm2 = (self.avg_bubble_count / self.params.num_layers) / 100
        # Generate random defect map
        self.defect_prob_map = np.random.rand(self.params.num_layers, width) < prob_per_mm2
        return self.defect_prob_map

    def print_stats(self) -> None:
        """Print simulation statistics."""
        print(f"Simulation Parameters:")
        print(f"  Laser Power: {self.params.laser_power}W")
        print(f"  Scan Speed: {self.params.scan_speed}mm/s")
        print(f"  Powder Humidity: {self.params.humidity}%")
        print(f"  Number of Layers: {self.params.num_layers}")
        print(f"  Number of Simulations: {self.params.num_simulations}")
        print(f"Average Bubbles per Layer: {self.avg_bubble_count / self.params.num_layers:.2f}")
        print(f"Total Average Bubbles: {self.avg_bubble_count:.2f}")

if __name__ == '__main__':
    # Example simulation for nylon 12 SLS print
    params = SimParams(
        laser_power=30.0,    # 30W fiber laser
        scan_speed=2000.0,   # 2000 mm/s
        humidity=0.2,        # 0.2% powder moisture
        num_layers=500,      # 50mm part height at 0.1mm layer height
        num_simulations=1000,# 1000 Monte Carlo runs
        layer_height=0.1
    )
    try:
        sim = PowderBedBubbleSim(params)
        sim.run_simulation()
        sim.print_stats()
        defect_map = sim.generate_defect_map()
        print(f"Defect map shape: {defect_map.shape}")
        print(f"Defect density: {np.sum(defect_map) / defect_map.size:.2%}")
    except Exception as e:
        print(f"Fatal simulation error: {str(e)}")

import adafruit_dht
import board
import time

dht = adafruit_dht.DHT22(board.D4)
while True:
    try:
        humidity = dht.humidity
        if humidity > 30:
            print(f"Humidity {humidity}% RH: Triggering drying cycle")
            # Add GPIO call to activate dry box heater
    except RuntimeError as e:
        print(f"DHT22 read error: {str(e)}")
    time.sleep(60)

import re

def get_layer_height(line):
    layer_match = re.search(r';LAYER_HEIGHT:([\d.]+)', line)
    if layer_match:
        return float(layer_match.group(1))
    return 0.2  # Default layer height

def get_adaptive_multiplier(layer_height, moisture_rh):
    base = 0.92 if layer_height <= 0.15 else 0.97
    moisture_adjust = 0.0
    if moisture_rh > 20:
        moisture_adjust = -0.02 * ((moisture_rh - 20) / 10)
    return max(0.85, base + moisture_adjust)

import RPi.GPIO as GPIO
import time

VACUUM_PIN = 17
GPIO.setmode(GPIO.BCM)
GPIO.setup(VACUUM_PIN, GPIO.OUT)

def run_degassing_cycle(duration_sec=30):
    print(f"Starting {duration_sec}s degassing cycle...")
    GPIO.output(VACUUM_PIN, GPIO.HIGH)  # Activate vacuum pump
    time.sleep(duration_sec)
    GPIO.output(VACUUM_PIN, GPIO.LOW)   # Deactivate pump
    print("Degassing complete. Waiting 120s for resin to settle...")
    time.sleep(120)

if __name__ == '__main__':
    run_degassing_cycle()
    GPIO.cleanup()