warp-engine 0.1.0__tar.gz

warp_engine-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: warp-engine
+Version: 0.1.0
+Summary: G-code warp prediction engine for 3D printing
+Author: RM Productions LLC
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Requires-Dist: numpy>=2.0
+Requires-Dist: scipy>=1.12
+Requires-Dist: trimesh>=4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"

warp_engine-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["warp_engine*"]
+
+[project]
+name = "warp-engine"
+version = "0.1.0"
+description = "G-code warp prediction engine for 3D printing"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [
+    { name = "RM Productions LLC" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Manufacturing",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering",
+]
+dependencies = [
+    "numpy>=2.0",
+    "scipy>=1.12",
+    "trimesh>=4.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+addopts = "--strict-markers --tb=short"
+markers = [
+    "slow: marks tests as slow",
+    "integration: integration tests",
+]

warp_engine-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

warp_engine-0.1.0/tests/test_engine.py

@@ -0,0 +1,58 @@
+"""Tests for the main engine entry point."""
+from warp_engine.engine import Engine
+from warp_engine.models import WarpReport, RiskLevel, AnalysisTier
+
+
+SIMPLE_GCODE = """\
+;FLAVOR:Marlin
+M140 S60
+M104 S210
+M190 S60
+M109 S210
+G28
+M83
+G1 Z0.3 F600
+G1 X80 Y0 E5.0 F1200
+G1 X80 Y80 E10.0
+G1 X0 Y80 E15.0
+G1 X0 Y0 E20.0
+G1 Z0.5
+G1 X80 Y0 E25.0
+G1 X80 Y80 E30.0
+G1 X0 Y80 E35.0
+G1 X0 Y0 E40.0
+"""
+
+
+def test_engine_analyze_returns_report():
+    engine = Engine()
+    result = engine.analyze(gcode=SIMPLE_GCODE, material="PLA")
+    assert isinstance(result, WarpReport)
+
+
+def test_engine_default_tier_is_quick():
+    engine = Engine()
+    result = engine.analyze(gcode=SIMPLE_GCODE, material="PLA")
+    assert result.metadata.tier == AnalysisTier.QUICK
+
+
+def test_engine_with_printer_profile():
+    engine = Engine()
+    result = engine.analyze(
+        gcode=SIMPLE_GCODE, material="PLA", printer_profile="bambu_x1c",
+    )
+    assert isinstance(result, WarpReport)
+
+
+def test_engine_abs_higher_risk_than_pla():
+    engine = Engine()
+    pla = engine.analyze(gcode=SIMPLE_GCODE, material="PLA")
+    abs_r = engine.analyze(gcode=SIMPLE_GCODE, material="ABS")
+    assert abs_r.overall_score >= pla.overall_score
+
+
+def test_engine_empty_gcode():
+    engine = Engine()
+    result = engine.analyze(gcode="", material="PLA")
+    assert result.overall_score == 0.0
+    assert result.risk_level == RiskLevel.LOW

warp_engine-0.1.0/tests/test_materials.py

@@ -0,0 +1,56 @@
+"""Tests for material property database."""
+from warp_engine.materials.profiles import (
+    MaterialProfile, get_material, list_materials, MATERIAL_DB,
+)
+
+
+def test_pla_exists():
+    pla = get_material("PLA")
+    assert pla is not None
+    assert pla.name == "PLA"
+
+
+def test_abs_exists():
+    abs_mat = get_material("ABS")
+    assert abs_mat is not None
+    assert abs_mat.glass_transition_temp > 100
+
+
+def test_pla_glass_transition():
+    pla = get_material("PLA")
+    assert 55 <= pla.glass_transition_temp <= 65
+
+
+def test_abs_higher_warp_susceptibility_than_pla():
+    pla = get_material("PLA")
+    abs_mat = get_material("ABS")
+    assert abs_mat.warp_susceptibility > pla.warp_susceptibility
+
+
+def test_list_materials_returns_all():
+    materials = list_materials()
+    assert "PLA" in materials
+    assert "ABS" in materials
+    assert "PETG" in materials
+    assert len(materials) >= 7
+
+
+def test_get_material_case_insensitive():
+    assert get_material("pla") is not None
+    assert get_material("Pla") is not None
+
+
+def test_get_unknown_material_returns_none():
+    assert get_material("unobtainium") is None
+
+
+def test_all_materials_have_valid_cte():
+    for name in list_materials():
+        mat = get_material(name)
+        assert mat.cte > 0, f"{name} has invalid CTE"
+
+
+def test_thermal_diffusivity_derived():
+    pla = get_material("PLA")
+    expected = pla.thermal_conductivity / (pla.density * pla.specific_heat)
+    assert abs(pla.thermal_diffusivity - expected) < 1e-12

warp_engine-0.1.0/tests/test_models.py

@@ -0,0 +1,103 @@
+"""Tests for core data models."""
+from warp_engine.models import (
+    Vec3, BBox3D, MoveType, AdhesionType, GcodeFlavor, BedShape,
+    RiskLevel, AirflowType, AnalysisTier,
+    MoveSegment, Layer, PrintSettings, PrintIR,
+    AirflowSource, ThermalEnvironment, LayerThermalState, ThermalField,
+    Region, GeometryRisk, AdhesionRisk, SettingsRisk,
+    RiskRegion, Recommendation, AnalysisMetadata, WarpReport,
+)
+
+
+def test_vec3_creation():
+    v = Vec3(1.0, 2.0, 3.0)
+    assert v.x == 1.0
+    assert v.y == 2.0
+    assert v.z == 3.0
+
+
+def test_vec3_distance():
+    a = Vec3(0.0, 0.0, 0.0)
+    b = Vec3(3.0, 4.0, 0.0)
+    assert abs(a.distance_to(b) - 5.0) < 1e-9
+
+
+def test_bbox3d_volume():
+    box = BBox3D(min=Vec3(0, 0, 0), max=Vec3(10, 20, 30))
+    assert box.volume() == 6000.0
+
+
+def test_move_segment_length():
+    seg = MoveSegment(
+        start=Vec3(0, 0, 0), end=Vec3(10, 0, 0),
+        extrusion=1.0, speed=60.0, move_type=MoveType.PERIMETER,
+    )
+    assert abs(seg.length - 10.0) < 1e-9
+
+
+def test_layer_total_extrusion():
+    seg1 = MoveSegment(
+        start=Vec3(0, 0, 0), end=Vec3(10, 0, 0),
+        extrusion=1.5, speed=60.0, move_type=MoveType.PERIMETER,
+    )
+    seg2 = MoveSegment(
+        start=Vec3(10, 0, 0), end=Vec3(20, 0, 0),
+        extrusion=1.5, speed=60.0, move_type=MoveType.INFILL,
+    )
+    layer = Layer(z_height=0.2, segments=[seg1, seg2], layer_time=10.0, fan_speed=0.0)
+    assert abs(layer.total_extrusion - 3.0) < 1e-9
+
+
+def test_print_settings_defaults():
+    ps = PrintSettings(
+        bed_temp=60.0, nozzle_temp=210.0, material="PLA",
+        layer_height=0.2, first_layer_height=0.3,
+        adhesion_type=AdhesionType.SKIRT,
+        infill_density=0.2, infill_pattern="grid",
+    )
+    assert ps.material == "PLA"
+
+
+def test_print_ir_layer_count():
+    ir = PrintIR(
+        layers=[], settings=PrintSettings(
+            bed_temp=60, nozzle_temp=210, material="PLA",
+            layer_height=0.2, first_layer_height=0.3,
+            adhesion_type=AdhesionType.NONE,
+            infill_density=0.2, infill_pattern="grid",
+        ),
+        bed_shape=BedShape.RECTANGULAR, flavor=GcodeFlavor.MARLIN,
+    )
+    assert ir.layer_count == 0
+
+
+def test_thermal_field_creation():
+    tf = ThermalField(layer_temps=[], hotspots=[], stress_map={})
+    assert tf.layer_temps == []
+
+
+def test_warp_report_creation():
+    report = WarpReport(
+        overall_score=0.5, risk_level=RiskLevel.MODERATE,
+        regions=[], recommendations=[],
+        thermal_field=ThermalField(layer_temps=[], hotspots=[], stress_map={}),
+        metadata=AnalysisMetadata(tier=AnalysisTier.QUICK, time_ms=100, version="0.1.0"),
+    )
+    assert report.risk_level == RiskLevel.MODERATE
+
+
+def test_risk_level_ordering():
+    assert RiskLevel.LOW.value < RiskLevel.MODERATE.value
+    assert RiskLevel.MODERATE.value < RiskLevel.HIGH.value
+    assert RiskLevel.HIGH.value < RiskLevel.CRITICAL.value
+
+
+def test_recommendation_creation():
+    rec = Recommendation(
+        priority=1, category="temperature",
+        message="Increase bed temp to 65C",
+        expected_improvement=0.15,
+        setting_change={"bed_temp": 65},
+    )
+    assert rec.priority == 1
+    assert rec.setting_change == {"bed_temp": 65}

warp_engine-0.1.0/tests/test_printers.py

@@ -0,0 +1,52 @@
+"""Tests for printer profile database."""
+from warp_engine.printers.profiles import (
+    PrinterProfile, get_printer, list_printers,
+)
+from warp_engine.models import AirflowType, BedShape
+
+
+def test_bambu_x1c_exists():
+    printer = get_printer("bambu_x1c")
+    assert printer is not None
+    assert "X1" in printer.name
+
+
+def test_bambu_h2d_has_side_fan():
+    printer = get_printer("bambu_h2d")
+    assert printer is not None
+    fan_types = [af.type for af in printer.airflow_sources]
+    assert AirflowType.SIDE_FAN in fan_types
+
+
+def test_bambu_a1_no_enclosure():
+    printer = get_printer("bambu_a1")
+    assert printer is not None
+    assert printer.has_enclosure is False
+    assert printer.default_chamber_temp is None
+
+
+def test_enclosed_printer_has_chamber_temp():
+    printer = get_printer("bambu_x1c")
+    assert printer.has_enclosure is True
+    assert printer.default_chamber_temp is not None
+
+
+def test_list_printers_has_entries():
+    printers = list_printers()
+    assert len(printers) >= 4
+
+
+def test_get_unknown_printer_returns_none():
+    assert get_printer("nonexistent_printer") is None
+
+
+def test_all_printers_have_part_cooling():
+    for pid in list_printers():
+        printer = get_printer(pid)
+        fan_types = [af.type for af in printer.airflow_sources]
+        assert AirflowType.PART_COOLING in fan_types, f"{pid} missing part cooling"
+
+
+def test_bed_shape():
+    printer = get_printer("bambu_x1c")
+    assert printer.bed_shape == BedShape.RECTANGULAR

warp_engine-0.1.0/warp_engine/__init__.py

@@ -0,0 +1,2 @@
+"""G-code warp prediction engine."""
+__version__ = "0.1.0"

warp_engine-0.1.0/warp_engine/analysis/__init__.py

@@ -0,0 +1 @@
+"""Analysis engine package."""

warp_engine-0.1.0/warp_engine/analysis/adhesion.py

@@ -0,0 +1,108 @@
+"""Adhesion risk analyzer.
+
+Evaluates bed adhesion risk by examining first-layer contact area,
+adhesion type, perimeter length, and estimated lift forces.
+"""
+from __future__ import annotations
+
+from warp_engine.models import AdhesionRisk, AdhesionType, MoveType, PrintIR
+
+# Assumed nozzle width for contact area estimation (mm).
+_NOZZLE_WIDTH = 0.4
+
+# Adhesion type scores: higher means better adhesion assistance.
+_ADHESION_SCORES: dict[AdhesionType, float] = {
+    AdhesionType.NONE: 0.0,
+    AdhesionType.SKIRT: 0.2,
+    AdhesionType.BRIM: 0.6,
+    AdhesionType.RAFT: 0.9,
+}
+
+
+def analyze_adhesion(ir: PrintIR) -> AdhesionRisk:
+    """Analyze adhesion risk for a print.
+
+    Examines the first layer to estimate bed contact area, perimeter length,
+    and coverage.  Scores the chosen adhesion type and estimates a rough
+    lift-force metric.
+
+    Parameters
+    ----------
+    ir:
+        The intermediate representation of the parsed G-code.
+
+    Returns
+    -------
+    AdhesionRisk
+        Populated adhesion risk dataclass.
+    """
+    if not ir.layers:
+        return AdhesionRisk(
+            bed_contact_area=0.0,
+            contact_ratio=0.0,
+            first_layer_coverage=0.0,
+            adhesion_type_score=_ADHESION_SCORES.get(
+                ir.settings.adhesion_type, 0.0
+            ),
+            perimeter_length=0.0,
+            lift_force_estimate=0.0,
+        )
+
+    first_layer = ir.layers[0]
+
+    # Sum path lengths for extrusion moves (non-travel) on the first layer.
+    total_path_length = 0.0
+    perimeter_length = 0.0
+
+    for seg in first_layer.segments:
+        if seg.move_type == MoveType.TRAVEL:
+            continue
+        seg_len = seg.length
+        total_path_length += seg_len
+        if seg.move_type == MoveType.PERIMETER:
+            perimeter_length += seg_len
+
+    # Contact area: path length * nozzle width (mm^2).
+    bed_contact_area = total_path_length * _NOZZLE_WIDTH
+
+    # Bounding-box area of the first layer for coverage ratio.
+    xs = []
+    ys = []
+    for seg in first_layer.segments:
+        if seg.move_type == MoveType.TRAVEL:
+            continue
+        xs.extend([seg.start.x, seg.end.x])
+        ys.extend([seg.start.y, seg.end.y])
+
+    if xs and ys:
+        bbox_area = (max(xs) - min(xs)) * (max(ys) - min(ys))
+    else:
+        bbox_area = 0.0
+
+    # Contact ratio: fraction of bounding box covered by extrusion paths.
+    contact_ratio = bed_contact_area / bbox_area if bbox_area > 0 else 0.0
+
+    # First layer coverage is the same as contact ratio (0-1 range, clamped).
+    first_layer_coverage = min(contact_ratio, 1.0)
+
+    # Adhesion type score.
+    adhesion_type_score = _ADHESION_SCORES.get(
+        ir.settings.adhesion_type, 0.0
+    )
+
+    # Lift-force estimate: a heuristic proportional to perimeter length
+    # divided by contact area.  Longer perimeters relative to contact area
+    # mean higher edge-peel risk.
+    if bed_contact_area > 0:
+        lift_force_estimate = perimeter_length / bed_contact_area
+    else:
+        lift_force_estimate = 0.0
+
+    return AdhesionRisk(
+        bed_contact_area=bed_contact_area,
+        contact_ratio=contact_ratio,
+        first_layer_coverage=first_layer_coverage,
+        adhesion_type_score=adhesion_type_score,
+        perimeter_length=perimeter_length,
+        lift_force_estimate=lift_force_estimate,
+    )

warp_engine-0.1.0/warp_engine/analysis/airflow.py

@@ -0,0 +1,104 @@
+"""Airflow-aware convection coefficient computation.
+
+Computes spatially varying convective heat transfer coefficient h(x,y,z)
+based on distance and angle from each AirflowSource.
+"""
+from __future__ import annotations
+
+import math
+
+from warp_engine.models import AirflowSource, AirflowType, Vec3
+
+# Base natural convection coefficient (no forced airflow)
+H_NATURAL = 8.0  # W/(m**2*K)
+
+# Maximum forced convection from a fan at 100% speed
+H_FAN_MAX = 40.0  # W/(m**2*K)
+
+
+def compute_convection_coefficient(
+    point: Vec3,
+    airflow_sources: list[AirflowSource],
+    layer_index: int = 0,
+) -> float:
+    """Compute the convective heat transfer coefficient at a point.
+
+    Args:
+        point: The (x,y,z) position to evaluate.
+        airflow_sources: List of fan/airflow sources.
+        layer_index: Current layer index (used to look up fan speed curves).
+
+    Returns:
+        h in W/(m**2*K) -- sum of natural convection + all fan contributions.
+    """
+    h = H_NATURAL
+
+    for source in airflow_sources:
+        h += _fan_contribution(point, source, layer_index)
+
+    return h
+
+
+def _fan_contribution(point: Vec3, source: AirflowSource, layer_index: int) -> float:
+    """Compute convection contribution from a single airflow source."""
+    # Get fan speed at this layer
+    speed_pct = _get_speed_at_layer(source.speed_curve, layer_index)
+    if speed_pct <= 0:
+        return 0.0
+
+    speed_factor = speed_pct / 100.0
+
+    # Vector from fan to point
+    dx = point.x - source.position.x
+    dy = point.y - source.position.y
+    dz = point.z - source.position.z
+    dist = math.sqrt(dx * dx + dy * dy + dz * dz)
+
+    if dist < 1e-6:
+        return H_FAN_MAX * speed_factor
+
+    # Angle between fan direction and vector to point
+    dot = (
+        dx * source.direction.x + dy * source.direction.y + dz * source.direction.z
+    ) / dist
+    dir_mag = math.sqrt(
+        source.direction.x ** 2
+        + source.direction.y ** 2
+        + source.direction.z ** 2
+    )
+    if dir_mag > 0:
+        dot /= dir_mag
+
+    # Cosine of angle -- 1.0 = directly in line, 0 = perpendicular, -1 = behind
+    cos_angle = max(0.0, dot)  # No contribution from behind the fan
+
+    # Angular falloff -- within spread angle: full effect, outside: decays
+    spread_rad = math.radians(source.spread_angle)
+    angle = math.acos(min(1.0, cos_angle))
+    if angle <= spread_rad:
+        angle_factor = 1.0
+    else:
+        # Exponential decay outside spread cone
+        angle_factor = math.exp(-(angle - spread_rad) / spread_rad)
+
+    # Distance falloff -- inverse square but capped
+    dist_factor = 1.0 / (1.0 + (dist / 100.0) ** 2)
+
+    return H_FAN_MAX * speed_factor * angle_factor * dist_factor
+
+
+def _get_speed_at_layer(
+    speed_curve: list[tuple[int, float]], layer_index: int
+) -> float:
+    """Look up fan speed percentage at a given layer from the speed curve."""
+    if not speed_curve:
+        return 0.0
+
+    # Find the last entry at or before this layer
+    result = speed_curve[0][1]
+    for layer, speed in speed_curve:
+        if layer <= layer_index:
+            result = speed
+        else:
+            break
+    return result