What Is Z-Seam in 3D Printing and Why It Matters

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

class GCodeZSeamDetector:
    """Parse FDM G-code files to detect Z-seam coordinates and layer metadata."""

    # Regex patterns for common G-code markers
    LAYER_MARKER = re.compile(r';LAYER:(\d+)')  # Cura/PrusaSlicer layer comment
    Z_HEIGHT_CHANGE = re.compile(r'G1\s+Z(\d+\.?\d*)')  # Z-axis movement
    EXTRUDE_CMD = re.compile(r'G1\s+.*?E(\d+\.?\d*)')  # Extrusion command with E value
    RETRACT_CMD = re.compile(r'G1\s+.*?E-(\d+\.?\d*)')  # Retraction command
    PRIME_CMD = re.compile(r'G1\s+.*?E\+?(\d+\.?\d*)')  # Prime after retraction (positive E move after negative)

    def __init__(self, gcode_path: str):
        if not os.path.exists(gcode_path):
            raise FileNotFoundError(f"G-code file not found: {gcode_path}")
        if not gcode_path.lower().endswith('.gcode'):
            raise ValueError(f"Unsupported file type: {gcode_path}. Only .gcode files are supported.")

        self.gcode_path = gcode_path
        self.seams: List[Dict] = []
        self.current_layer: Optional[int] = None
        self.current_z: float = 0.0
        self.last_e: float = 0.0  # Track last extruder position to detect retraction/prime
        self.in_retract: bool = False  # Flag to track if we just retracted

    def parse(self) -> List[Dict]:
        """Parse the G-code file and return list of detected Z-seams."""
        try:
            with open(self.gcode_path, 'r', encoding='utf-8') as f:
                for line_num, line in enumerate(f, 1):
                    line = line.strip()
                    if not line or line.startswith(';'):
                        continue  # Skip empty lines and comments

                    # Check for layer marker
                    layer_match = self.LAYER_MARKER.search(line)
                    if layer_match:
                        self.current_layer = int(layer_match.group(1))
                        continue

                    # Update Z height if moving Z axis
                    z_match = self.Z_HEIGHT_CHANGE.search(line)
                    if z_match:
                        self.current_z = float(z_match.group(1))
                        continue

                    # Check for retraction first
                    retract_match = self.RETRACT_CMD.search(line)
                    if retract_match:
                        self.last_e = float(retract_match.group(1))  # Negative value
                        self.in_retract = True
                        continue

                    # Check for extrusion (prime after retraction is Z-seam indicator)
                    extrude_match = self.EXTRUDE_CMD.search(line)
                    if extrude_match and self.in_retract:
                        # This is a prime move after retraction: Z-seam location
                        # Extract X/Y coordinates if present
                        x_match = re.search(r'X(\d+\.?\d*)', line)
                        y_match = re.search(r'Y(\d+\.?\d*)', line)
                        x = float(x_match.group(1)) if x_match else None
                        y = float(y_match.group(1)) if y_match else None

                        if x is not None and y is not None and self.current_layer is not None:
                            self.seams.append({
                                'layer': self.current_layer,
                                'z_height': self.current_z,
                                'x': x,
                                'y': y,
                                'line_number': line_num,
                                'gcode_line': line
                            })
                        self.in_retract = False  # Reset retraction flag
                        self.last_e = float(extrude_match.group(1))
                        continue

                    # Update last E value for non-retract extrusion
                    if extrude_match:
                        self.last_e = float(extrude_match.group(1))

        except UnicodeDecodeError:
            raise ValueError(f"Failed to decode {self.gcode_path}: Ensure file is UTF-8 encoded.")
        except Exception as e:
            raise RuntimeError(f"Unexpected error parsing G-code: {str(e)}")

        return self.seams

    def export_to_json(self, output_path: str) -> None:
        """Export detected seams to JSON file for analysis."""
        if not self.seams:
            raise ValueError("No seams detected. Run parse() first.")
        try:
            with open(output_path, 'w', encoding='utf-8') as f:
                json.dump({
                    'source_file': self.gcode_path,
                    'total_seams': len(self.seams),
                    'seams': self.seams
                }, f, indent=2)
        except IOError as e:
            raise RuntimeError(f"Failed to write output JSON: {str(e)}")

if __name__ == '__main__':
    # Example usage: analyze a G-code file from PrusaSlicer
    if len(sys.argv) != 2:
        print("Usage: python zseam_detector.py ", file=sys.stderr)
        sys.exit(1)

    gcode_path = sys.argv[1]
    try:
        detector = GCodeZSeamDetector(gcode_path)
        seams = detector.parse()
        print(f"Detected {len(seams)} Z-seams in {gcode_path}")
        if seams:
            detector.export_to_json(gcode_path.replace('.gcode', '_seams.json'))
            print(f"Seam data exported to {gcode_path.replace('.gcode', '_seams.json')}")
    except Exception as e:
        print(f"Error: {str(e)}", file=sys.stderr)
        sys.exit(1)

import subprocess
import json
import os
import sys
from typing import Dict, List, Tuple
from dataclasses import dataclass

@dataclass
class SlicerConfig:
    name: str
    executable: str
    z_seam_settings: List[str]
    version: str

class ZSeamComparisonTool:
    """Compare Z-seam placement across Cura, PrusaSlicer, and Bambu Studio for a given STL."""

    # Pre-defined slicer configurations (update paths to match your local install)
    SLICERS = [
        SlicerConfig(
            name="PrusaSlicer",
            executable="/usr/bin/prusa-slicer",  # Update for your OS
            z_seam_settings=[
                "--seam-position", "random",
                "--seam-preferred-orientation", "0",
                "--seam-avoid-positions", ""
            ],
            version="2.7.1"
        ),
        SlicerConfig(
            name="Cura",
            executable="/usr/bin/cura",
            z_seam_settings=[
                "--setting", "z_seam_position:random",
                "--setting", "z_seam_corner:none"
            ],
            version="5.6.0"
        ),
        SlicerConfig(
            name="BambuStudio",
            executable="/usr/bin/bambu-studio",
            z_seam_settings=[
                "--seam-type", "random",
                "--seam-gap", "0"
            ],
            version="1.9.0"
        )
    ]

    def __init__(self, stl_path: str, output_dir: str = "./slicer_outputs"):
        if not os.path.exists(stl_path):
            raise FileNotFoundError(f"STL file not found: {stl_path}")
        if not stl_path.lower().endswith('.stl'):
            raise ValueError(f"Unsupported file type: {stl_path}. Only .stl files are supported.")

        self.stl_path = stl_path
        self.output_dir = output_dir
        os.makedirs(output_dir, exist_ok=True)
        self.results: Dict[str, List[dict]] = {}

    def _run_slicer(self, slicer: SlicerConfig) -> str:
        """Run a slicer with Z-seam settings and return path to generated G-code."""
        output_gcode = os.path.join(
            self.output_dir,
            f"{os.path.basename(self.stl_path).replace('.stl', '')}_{slicer.name.replace(' ', '_')}.gcode"
        )

        # Build command (simplified for demo; real CLI args vary by slicer)
        cmd = [
            slicer.executable,
            "--export-gcode",
            "--output", output_gcode,
            *slicer.z_seam_settings,
            self.stl_path
        ]

        try:
            result = subprocess.run(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True,
                timeout=300  # 5 minute timeout for large STLs
            )
            if result.returncode != 0:
                raise RuntimeError(f"{slicer.name} failed: {result.stderr}")
            if not os.path.exists(output_gcode):
                raise FileNotFoundError(f"{slicer.name} did not generate G-code at {output_gcode}")
            return output_gcode
        except FileNotFoundError:
            raise RuntimeError(f"{slicer.name} executable not found at {slicer.executable}")
        except subprocess.TimeoutExpired:
            raise RuntimeError(f"{slicer.name} timed out after 5 minutes")

    def _detect_seams(self, gcode_path: str) -> List[dict]:
        """Basic seam detection logic for self-contained execution."""
        seams = []
        current_layer = None
        current_z = 0.0
        last_e = 0.0
        in_retract = False

        with open(gcode_path, 'r') as f:
            for line_num, line in enumerate(f, 1):
                line = line.strip()
                if not line or line.startswith(';'):
                    continue
                # Layer detection
                if ';LAYER:' in line:
                    current_layer = int(line.split(':')[-1])
                # Z height
                if line.startswith('G1') and 'Z' in line:
                    z_part = [p for p in line.split() if p.startswith('Z')]
                    if z_part:
                        current_z = float(z_part[0][1:])
                # Retraction
                if line.startswith('G1') and 'E-' in line:
                    in_retract = True
                    last_e = float([p for p in line.split() if p.startswith('E')][0][1:])
                # Prime after retraction (seam)
                if in_retract and line.startswith('G1') and 'E' in line and 'E-' not in line:
                    x_part = [p for p in line.split() if p.startswith('X')]
                    y_part = [p for p in line.split() if p.startswith('Y')]
                    if x_part and y_part and current_layer is not None:
                        seams.append({
                            'layer': current_layer,
                            'z': current_z,
                            'x': float(x_part[0][1:]),
                            'y': float(y_part[0][1:]),
                            'gcode_line': line_num
                        })
                    in_retract = False
        return seams

    def run_comparison(self) -> None:
        """Run all slicers and compare Z-seam placement."""
        for slicer in self.SLICERS:
            print(f"Processing {slicer.name} v{slicer.version}...")
            try:
                gcode_path = self._run_slicer(slicer)
                seams = self._detect_seams(gcode_path)
                self.results[slicer.name] = {
                    'version': slicer.version,
                    'total_seams': len(seams),
                    'seams': seams,
                    'gcode_path': gcode_path
                }
                print(f"  Detected {len(seams)} seams for {slicer.name}")
            except Exception as e:
                print(f"  Error processing {slicer.name}: {str(e)}", file=sys.stderr)
                self.results[slicer.name] = {'error': str(e)}

    def export_results(self, output_path: str) -> None:
        """Export comparison results to JSON."""
        with open(output_path, 'w') as f:
            json.dump(self.results, f, indent=2)
        print(f"Comparison results exported to {output_path}")

    def print_summary(self) -> None:
        """Print a human-readable summary of seam counts per slicer."""
        print("\n=== Z-Seam Comparison Summary ===")
        for slicer_name, data in self.results.items():
            if 'error' in data:
                print(f"{slicer_name}: Error - {data['error']}")
            else:
                print(f"{slicer_name} v{data['version']}: {data['total_seams']} seams")
                if data['seams']:
                    avg_x = sum(s['x'] for s in data['seams']) / len(data['seams'])
                    avg_y = sum(s['y'] for s in data['seams']) / len(data['seams'])
                    print(f"  Average seam position: X={avg_x:.2f}, Y={avg_y:.2f}")

if __name__ == '__main__':
    if len(sys.argv) != 2:
        print("Usage: python zseam_comparison.py ", file=sys.stderr)
        sys.exit(1)

    stl_path = sys.argv[1]
    try:
        comparator = ZSeamComparisonTool(stl_path)
        comparator.run_comparison()
        comparator.print_summary()
        comparator.export_results("./zseam_comparison_results.json")
    except Exception as e:
        print(f"Fatal error: {str(e)}", file=sys.stderr)
        sys.exit(1)

import re
import sys
import os
import json
from typing import List, Optional, Tuple

class ZSeamOptimizer:
    """Modify G-code to relocate Z-seams to a user-defined target coordinate."""

    # Regex patterns (reuse from previous examples)
    LAYER_MARKER = re.compile(r';LAYER:(\d+)')
    Z_HEIGHT_CHANGE = re.compile(r'G1\s+Z(\d+\.?\d*)')
    RETRACT_CMD = re.compile(r'G1\s+.*?E-(\d+\.?\d*)')
    PRIME_CMD = re.compile(r'G1\s+.*?E\+?(\d+\.?\d*)')
    X_COORD = re.compile(r'X(\d+\.?\d*)')
    Y_COORD = re.compile(r'Y(\d+\.?\d*)')
    E_COORD = re.compile(r'E(\d+\.?\d*)')

    def __init__(self, gcode_path: str, target_xy: Tuple[float, float], tolerance: float = 0.5):
        """
        Initialize optimizer.

        :param gcode_path: Path to input G-code file
        :param target_xy: (X, Y) target coordinate for Z-Seams
        :param tolerance: Maximum distance (mm) a seam can be from target to avoid relocation
        """
        if not os.path.exists(gcode_path):
            raise FileNotFoundError(f"G-code file not found: {gcode_path}")

        self.gcode_path = gcode_path
        self.target_x, self.target_y = target_xy
        self.tolerance = tolerance
        self.lines: List[str] = []
        self.current_layer: Optional[int] = None
        self.current_z: float = 0.0
        self.last_e: float = 0.0
        self.in_retract: bool = False
        self.retract_line_idx: Optional[int] = None
        self.modified_lines: List[str] = []
        self.seams_modified: int = 0

    def _load_gcode(self) -> None:
        """Load G-code lines into memory."""
        with open(self.gcode_path, 'r', encoding='utf-8') as f:
            self.lines = [line.rstrip('\n') for line in f]

    def _save_gcode(self, output_path: str) -> None:
        """Save modified G-code to file."""
        with open(output_path, 'w', encoding='utf-8') as f:
            f.write('\n'.join(self.modified_lines) + '\n')

    def _calculate_distance(self, x1: float, y1: float, x2: float, y2: float) -> float:
        """Calculate Euclidean distance between two points."""
        return ((x1 - x2)**2 + (y1 - y2)**2)**0.5

    def optimize(self, output_path: Optional[str] = None) -> int:
        """
        Optimize Z-seam placement to target coordinates.

        :return: Number of seams modified
        """
        self._load_gcode()
        self.modified_lines = []
        self.seams_modified = 0

        for line_idx, line in enumerate(self.lines):
            stripped = line.strip()
            current_line = line

            # Check for layer markers
            layer_match = self.LAYER_MARKER.search(stripped)
            if layer_match:
                self.current_layer = int(layer_match.group(1))
                self.modified_lines.append(current_line)
                continue

            # Check for Z height changes
            z_match = self.Z_HEIGHT_CHANGE.search(stripped)
            if z_match:
                self.current_z = float(z_match.group(1))
                self.modified_lines.append(current_line)
                continue

            # Check for retraction
            retract_match = self.RETRACT_CMD.search(stripped)
            if retract_match:
                self.in_retract = True
                self.retract_line_idx = line_idx
                self.last_e = -float(retract_match.group(1))
                self.modified_lines.append(current_line)
                continue

            # Check for prime (seam) after retraction
            prime_match = self.PRIME_CMD.search(stripped)
            if prime_match and self.in_retract:
                x_match = self.X_COORD.search(stripped)
                y_match = self.Y_COORD.search(stripped)

                if x_match and y_match:
                    seam_x = float(x_match.group(1))
                    seam_y = float(y_match.group(1))
                    distance = self._calculate_distance(seam_x, seam_y, self.target_x, self.target_y)

                    if distance > self.tolerance:
                        travel_speed = 9000
                        travel_line = f"G0 F{travel_speed} X{self.target_x:.3f} Y{self.target_y:.3f} ; Relocate Z-seam to target"
                        self.modified_lines.append(travel_line)
                        self.seams_modified += 1

                        if not x_match or not y_match:
                            current_line = f"{stripped} X{self.target_x:.3f} Y{self.target_y:.3f}"

                self.in_retract = False
                self.retract_line_idx = None

            self.modified_lines.append(current_line)

        output_path = output_path or self.gcode_path.replace('.gcode', '_optimized.gcode')
        self._save_gcode(output_path)
        print(f"Modified {self.seams_modified} Z-seams. Output saved to {output_path}")
        return self.seams_modified

if __name__ == '__main__':
    if len(sys.argv) != 4:
        print("Usage: python zseam_optimizer.py   ", file=sys.stderr)
        print("Example: python zseam_optimizer.py benchy.gcode 150.0 10.0", file=sys.stderr)
        sys.exit(1)

    gcode_path = sys.argv[1]
    try:
        target_x = float(sys.argv[2])
        target_y = float(sys.argv[3])
    except ValueError:
        print("Error: Target X and Y must be numeric values.", file=sys.stderr)
        sys.exit(1)

    try:
        optimizer = ZSeamOptimizer(gcode_path, (target_x, target_y))
        optimizer.optimize()
    except Exception as e:
        print(f"Error optimizing G-code: {str(e)}", file=sys.stderr)
        sys.exit(1)

#!/bin/bash
GCODE_PATH=$1
python zseam_detector.py "$GCODE_PATH" || { echo "Z-seam validation failed"; exit 1; }
echo "Z-seam validation passed for $GCODE_PATH"

#!/bin/bash
for stl in ./parts/*.stl; do
  output="${stl/.stl/.gcode}"
  prusa-slicer \
    --seam-position aligned \
    --seam-preferred-orientation 180 \
    --seam-avoid-positions "0,0,100,100" \
    --export-gcode \
    --output "$output" \
    "$stl"
done

import requests
import time
from prometheus_client import Gauge, start_http_server

SEAM_DISTANCE = Gauge('z_seam_distance_from_target_mm', 'Distance of Z-seam from target coordinate')

def collect_metrics():
    # Pull latest print G-code from OctoPrint API
    resp = requests.get('http://octoprint/api/files/local', headers={'X-Api-Key': 'YOUR_API_KEY'})
    latest_gcode = resp.json()['files'][-1]['path']
    # Run seam detector (simplified)
    distance = 0.5  # Replace with actual detector output
    SEAM_DISTANCE.set(distance)

if __name__ == '__main__':
    start_http_server(8000)
    while True:
        collect_metrics()
        time.sleep(300)  # Collect every 5 minutes