How to Fix Tri-Hexagon Infill for Strength: Troubleshooting Tips

import re
import sys
from dataclasses import dataclass
from typing import List, Tuple, Optional
import logging

# Configure logging for debug output
logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
logger = logging.getLogger(__name__)

@dataclass
class InfillMove:
    """Represents a single infill extrusion move in G-code"""
    x: float
    y: float
    extrusion: float
    feedrate: int
    line_num: int  # Track line number for error reporting

def parse_gcode_infill(gcode_path: str, infill_keyword: str = "infill") -> List[InfillMove]:
    """
    Parse G-code file to extract all infill extrusion moves.
    Assumes slicer marks infill sections with comments containing infill_keyword.
    """
    infill_moves = []
    current_infill_section = False
    line_num = 0

    try:
        with open(gcode_path, 'r', encoding='utf-8') as f:
            for line in f:
                line_num += 1
                line = line.strip()
                # Skip empty lines and non-G-code comments
                if not line or line.startswith(';'):
                    # Check if comment marks start/end of infill section
                    if infill_keyword in line.lower():
                        current_infill_section = True
                        logger.debug(f"Entering infill section at line {line_num}")
                    elif "end infill" in line.lower() or "infill end" in line.lower():
                        current_infill_section = False
                        logger.debug(f"Exiting infill section at line {line_num}")
                    continue

                # Only process moves in infill sections
                if not current_infill_section:
                    continue

                # Match G1 move commands with X, Y, E (extrusion) parameters
                g1_match = re.match(
                    r'G1\s+X(-?[\d.]+)\s+Y(-?[\d.]+)\s+E(-?[\d.]+)\s+F(\d+)',
                    line,
                    re.IGNORECASE
                )
                if g1_match:
                    try:
                        x = float(g1_match.group(1))
                        y = float(g1_match.group(2))
                        extrusion = float(g1_match.group(3))
                        feedrate = int(g1_match.group(4))
                        infill_moves.append(InfillMove(x, y, extrusion, feedrate, line_num))
                    except ValueError as e:
                        logger.warning(f"Invalid numeric value in G-code line {line_num}: {e}")
                        continue

    except FileNotFoundError:
        logger.error(f"G-code file not found: {gcode_path}")
        sys.exit(1)
    except UnicodeDecodeError:
        logger.error(f"Unable to decode G-code file: {gcode_path}. Try UTF-8 encoding.")
        sys.exit(1)
    except Exception as e:
        logger.error(f"Unexpected error parsing G-code: {e}")
        sys.exit(1)

    if not infill_moves:
        logger.error(f"No infill moves found in {gcode_path}. Check slicer infill comment markers.")
        sys.exit(1)

    logger.info(f"Parsed {len(infill_moves)} infill moves from {gcode_path}")
    return infill_moves

def detect_tri_hex_gaps(infill_moves: List[InfillMove], expected_spacing: float = 2.0) -> List[str]:
    """
    Detect gaps in tri-hexagon pattern by checking spacing between adjacent infill lines.
    Tri-hexagon has consistent 60-degree angled lines with fixed spacing.
    """
    errors = []
    # Group moves by Y to find adjacent lines (simplified for demo)
    y_groups = {}
    for move in infill_moves:
        y_key = round(move.y, 1)  # Round to 0.1mm to group nearby lines
        if y_key not in y_groups:
            y_groups[y_key] = []
        y_groups[y_key].append(move)

    for y_val, moves in y_groups.items():
        moves_sorted = sorted(moves, key=lambda m: m.x)
        for i in range(1, len(moves_sorted)):
            prev_x = moves_sorted[i-1].x
            curr_x = moves_sorted[i].x
            spacing = curr_x - prev_x
            # Allow 10% tolerance on expected spacing
            if abs(spacing - expected_spacing) > expected_spacing * 0.1:
                errors.append(
                    f"Line {moves_sorted[i].line_num}: Unexpected spacing {spacing:.2f}mm "
                    f"(expected {expected_spacing:.2f}mm) at Y={y_val:.1f}mm"
                )
    return errors

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print(f"Usage: {sys.argv[0]} ")
        sys.exit(1)

    gcode_path = sys.argv[1]
    infill_moves = parse_gcode_infill(gcode_path)
    gaps = detect_tri_hex_gaps(infill_moves)

    if gaps:
        print(f"Found {len(gaps)} tri-hexagon infill gaps:")
        for error in gaps[:10]:  # Print first 10 errors
            print(f"  - {error}")
        if len(gaps) > 10:
            print(f"  ... and {len(gaps) - 10} more errors")
    else:
        print("No tri-hexagon infill gaps detected. Pattern is valid.")

import pandas as pd
import numpy as np
import sys
from dataclasses import dataclass
from typing import List, Tuple, Optional
import logging

logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
logger = logging.getLogger(__name__)

@dataclass
class InfillTestCube:
    """Stores measured dimensions for a single infill calibration cube"""
    multiplier: float  # Extrusion multiplier used for infill
    measured_width: float  # Measured X/Y width in mm
    target_width: float  # Target width from CAD (e.g., 20mm)
    tensile_strength_mpa: float  # Measured tensile strength in MPa
    line_num: int  # Row number in input CSV

def load_test_data(csv_path: str) -> List[InfillTestCube]:
    """Load infill calibration test data from CSV file."""
    test_cubes = []
    try:
        df = pd.read_csv(csv_path)
        # Validate required columns
        required_cols = ['infill_multiplier', 'measured_width', 'target_width', 'tensile_strength_mpa']
        missing_cols = [col for col in required_cols if col not in df.columns]
        if missing_cols:
            logger.error(f"CSV missing required columns: {missing_cols}")
            sys.exit(1)

        for idx, row in df.iterrows():
            try:
                cube = InfillTestCube(
                    multiplier=float(row['infill_multiplier']),
                    measured_width=float(row['measured_width']),
                    target_width=float(row['target_width']),
                    tensile_strength_mpa=float(row['tensile_strength_mpa']),
                    line_num=idx + 2  # +2 for header and 0-index
                )
                # Validate data ranges
                if not (0.8 <= cube.multiplier <= 1.2):
                    logger.warning(f"Row {cube.line_num}: Multiplier {cube.multiplier} out of range 0.8-1.2")
                if cube.measured_width <= 0 or cube.target_width <= 0:
                    logger.warning(f"Row {cube.line_num}: Invalid width values")
                test_cubes.append(cube)
            except ValueError as e:
                logger.warning(f"Row {idx + 2}: Invalid numeric value: {e}")
                continue

    except FileNotFoundError:
        logger.error(f"Test data CSV not found: {csv_path}")
        sys.exit(1)
    except pd.errors.EmptyDataError:
        logger.error(f"CSV file is empty: {csv_path}")
        sys.exit(1)
    except Exception as e:
        logger.error(f"Unexpected error loading CSV: {e}")
        sys.exit(1)

    if not test_cubes:
        logger.error("No valid test cube data found in CSV")
        sys.exit(1)

    logger.info(f"Loaded {len(test_cubes)} valid infill test cubes from {csv_path}")
    return test_cubes

def calculate_optimal_multiplier(test_cubes: List[InfillTestCube]) -> Tuple[float, float]:
    """
    Calculate optimal extrusion multiplier balancing dimensional accuracy and strength.
    Returns (optimal_multiplier, expected_strength_mpa)
    """
    # Calculate width error for each cube
    for cube in test_cubes:
        cube.width_error = abs(cube.measured_width - cube.target_width) / cube.target_width

    # Filter to cubes with <5% width error (dimensional accuracy)
    accurate_cubes = [c for c in test_cubes if c.width_error < 0.05]
    if not accurate_cubes:
        logger.error("No test cubes with <5% width error found. Reprint calibration cubes.")
        sys.exit(1)

    # Find multiplier with highest tensile strength among dimensionally accurate cubes
    optimal_cube = max(accurate_cubes, key=lambda c: c.tensile_strength_mpa)
    expected_strength = optimal_cube.tensile_strength_mpa

    # Linear regression to predict strength for nearby multipliers (optional refinement)
    multipliers = np.array([c.multiplier for c in accurate_cubes])
    strengths = np.array([c.tensile_strength_mpa for c in accurate_cubes])
    if len(multipliers) >= 2:
        slope, intercept = np.polyfit(multipliers, strengths, 1)
        # Check if optimal is at the edge of tested range
        if optimal_cube.multiplier == max(multipliers):
            logger.warning("Optimal multiplier at max tested value. Consider testing higher multipliers.")
        elif optimal_cube.multiplier == min(multipliers):
            logger.warning("Optimal multiplier at min tested value. Consider testing lower multipliers.")

    return optimal_cube.multiplier, expected_strength

def generate_slicer_config(optimal_multiplier: float, slicer: str = "cura") -> str:
    """Generate slicer config snippet for infill extrusion multiplier."""
    if slicer.lower() == "cura":
        return f"; Infill extrusion multiplier calibration result\ninfill_extrusion_width = {optimal_multiplier:.3f}\n"
    elif slicer.lower() == "prusaslicer":
        return f"; Infill extrusion multiplier calibration result\nperimeter_extrusion_multiplier = {optimal_multiplier:.3f}\ninfill_extrusion_multiplier = {optimal_multiplier:.3f}\n"
    else:
        return f"; Infill extrusion multiplier: {optimal_multiplier:.3f}\n"

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print(f"Usage: {sys.argv[0]} ")
        sys.exit(1)

    csv_path = sys.argv[1]
    test_cubes = load_test_data(csv_path)
    optimal_mult, expected_str = calculate_optimal_multiplier(test_cubes)

    print(f"Optimal infill extrusion multiplier: {optimal_mult:.3f}")
    print(f"Expected tensile strength: {expected_str:.1f} MPa")
    print("\nCura slicer config snippet:")
    print(generate_slicer_config(optimal_mult, "cura"))
    print("\nPrusaSlicer config snippet:")
    print(generate_slicer_config(optimal_mult, "prusaslicer"))

import numpy as np
import sys
from typing import Tuple, List
import logging

logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
logger = logging.getLogger(__name__)

# Material properties database (tensile strength in MPa, modulus in GPa)
MATERIAL_PROPS = {
    "PLA": {"strength": 50, "modulus": 3.5},
    "ABS": {"strength": 40, "modulus": 2.2},
    "PETG": {"strength": 50, "modulus": 2.3},
    "TPU": {"strength": 30, "modulus": 0.05},
}

def calculate_infill_strength(
    density: float,
    filament_type: str,
    line_width: float = 0.4,
    layer_height: float = 0.2
) -> Tuple[float, float]:
    """
    Calculate expected tensile strength and stiffness of tri-hexagon infill.
    Uses rule of mixtures with 5% penalty for tri-hexagon voids.
    Returns (strength_mpa, stiffness_gpa)
    """
    if filament_type not in MATERIAL_PROPS:
        logger.error(f"Unsupported filament type: {filament_type}. Supported: {list(MATERIAL_PROPS.keys())}")
        sys.exit(1)
    if not (0.1 <= density <= 1.0):
        logger.error(f"Density {density} out of range 0.1-1.0")
        sys.exit(1)
    if line_width <= 0 or layer_height <= 0:
        logger.error("Line width and layer height must be positive")
        sys.exit(1)

    mat = MATERIAL_PROPS[filament_type]
    # Rule of mixtures: strength = density * solid strength * (1 - void_penalty)
    void_penalty = 0.05  # Tri-hexagon has 5% more voids than grid infill
    infill_strength = density * mat["strength"] * (1 - void_penalty)
    # Stiffness scales with density more linearly for tri-hexagon
    infill_stiffness = density * mat["modulus"] * 0.95  # 5% loss from layer adhesion

    logger.debug(f"Calculated for {density*100}% density {filament_type}: {infill_strength:.1f} MPa, {infill_stiffness:.2f} GPa")
    return infill_strength, infill_stiffness

def simulate_tri_hex_stress(
    density: float,
    filament_type: str,
    load_mpa: float,
    line_width: float = 0.4
) -> List[float]:
    """
    Simulate stress distribution across tri-hexagon cells under tensile load.
    Returns list of stress values per cell (for visualization).
    """
    # Generate simplified tri-hexagon cell coordinates (2mm cell size)
    cell_size = 2.0
    num_cells = int(10 / cell_size)  # 10mm sample width
    stresses = []

    for i in range(num_cells):
        for j in range(num_cells):
            # Calculate angle of hex line (60 degrees for tri-hexagon)
            angle = np.deg2rad(60 * (i % 3))  # Cycle through 0, 60, 120 degrees
            # Project load onto hex line direction
            stress_component = load_mpa * np.cos(angle)
            # Apply density scaling (lower density = higher stress per line)
            stress = stress_component / (density * line_width)
            stresses.append(stress)
    return stresses

def recommend_density(
    target_strength_mpa: float,
    filament_type: str,
    safety_factor: float = 1.5
) -> float:
    """
    Recommend minimum tri-hexagon density to meet target strength with safety factor.
    """
    required_strength = target_strength_mpa * safety_factor
    mat = MATERIAL_PROPS[filament_type]
    # Reverse calculate density from strength formula
    min_density = required_strength / (mat["strength"] * (1 - 0.05))
    min_density = max(0.1, min(1.0, min_density))  # Clamp to valid range
    return min_density

if __name__ == "__main__":
    if len(sys.argv) != 4:
        print(f"Usage: {sys.argv[0]}   ")
        print(f"Example: {sys.argv[0]} PLA 30 20")
        sys.exit(1)

    filament_type = sys.argv[1]
    try:
        target_strength = float(sys.argv[2])
        load = float(sys.argv[3])
    except ValueError:
        logger.error("Target strength and load must be numeric")
        sys.exit(1)

    # Calculate recommended density
    min_density = recommend_density(target_strength, filament_type)
    print(f"Minimum tri-hexagon density for {filament_type}: {min_density*100:.1f}%")
    print(f"Safety factor applied: 1.5")

    # Simulate strength at recommended density
    strength, stiffness = calculate_infill_strength(min_density, filament_type)
    print(f"Expected strength at {min_density*100:.1f}% density: {strength:.1f} MPa")
    print(f"Expected stiffness: {stiffness:.2f} GPa")

    # Simulate stress distribution
    stresses = simulate_tri_hex_stress(min_density, filament_type, load)
    max_stress = max(stresses)
    print(f"Max simulated stress per cell: {max_stress:.1f} MPa")
    if max_stress > strength:
        print("WARNING: Max stress exceeds expected infill strength. Increase density.")
    else:
        print("Stress distribution within safe limits.")

# Sample CI integration snippet
import subprocess
def validate_gcode(gcode_path):
    result = subprocess.run(
        ["python", "validate_tri_hex.py", gcode_path],
        capture_output=True, text=True
    )
    return "gaps detected" not in result.stdout.lower()

tri-hexagon-infill-fix/
├── gcode_validator/
│   └── validate_tri_hex.py
├── calibration/
│   ├── extrusion_multiplier.py
│   └── test_data.csv
├── simulation/
│   └── stress_simulator.py
├── slicer_configs/
│   ├── cura_5.6/
│   └── prusaslicer_2.7/
└── README.md