Add files via upload

bricklayersNonPlanarInfill.py

@@ -0,0 +1,389 @@
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+#
+# Copyright (c) [2025] [Roman Tenger]
+import re
+import sys
+import logging
+import os
+import argparse
+import math
+
+# Get the directory where the script is located
+script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# Configure logging to save in the script's directory
+log_file_path = os.path.join(script_dir, "z_shift_log.txt")
+logging.basicConfig(
+    filename=log_file_path,
+    filemode="w",
+    level=logging.INFO,
+    format="%(asctime)s - %(message)s"
+)
+
+# Add these constants from nonPlanarInfill.py
+DEFAULT_AMPLITUDE = 0.6  # Default Z variation in mm
+DEFAULT_FREQUENCY = 1.1  # Default frequency of the sine wave
+SEGMENT_LENGTH = 1.0  # Split infill lines into segments of this length (mm)
+
+# Add these helper functions from nonPlanarInfill.py
+def segment_line(x1, y1, x2, y2, segment_length):
+    """Divide a line into smaller segments."""
+    segments = []
+    total_length = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+    num_segments = max(1, int(total_length // segment_length))
+    
+    for i in range(num_segments + 1):
+        t = i / num_segments
+        x = x1 + t * (x2 - x1)
+        y = y1 + t * (y2 - y1)
+        segments.append((x, y))
+    
+    logging.debug(f"Segmented line ({x1}, {y1}) -> ({x2}, {y2}) into {len(segments)} segments.")
+    return segments
+
+def reset_modulation_state():
+    """Reset parameters for Z-modulation to avoid propagating patterns."""
+    global last_sx
+    last_sx = 0
+
+def update_layer_bounds(current_z, solid_infill_heights):
+    """Update the bounds for non-planar processing based on current Z height."""
+    global last_bottom_layer, next_top_layer
+    lower_layers = [z for z in solid_infill_heights if z < current_z]
+    upper_layers = [z for z in solid_infill_heights if z > current_z]
+    if lower_layers:
+        last_bottom_layer = max(lower_layers)
+    if upper_layers:
+        next_top_layer = min(upper_layers)
+
+def process_nonplanar_infill(lines, current_z, amplitude, frequency, solid_infill_heights):
+    """Process only the non-planar infill modifications."""
+    modified_lines = []
+    in_infill = False
+    last_bottom_layer = 0
+    next_top_layer = float('inf')
+    processed_indices = set()
+
+    def update_layer_bounds(current_z):
+        nonlocal last_bottom_layer, next_top_layer
+        lower_layers = [z for z in solid_infill_heights if z < current_z]
+        upper_layers = [z for z in solid_infill_heights if z > current_z]
+        if lower_layers:
+            last_bottom_layer = max(lower_layers)
+        if upper_layers:
+            next_top_layer = min(upper_layers)
+
+    for line_num, line in enumerate(lines):
+        if line.startswith('G1') and 'Z' in line:
+            z_match = re.search(r'Z([-+]?\d*\.?\d+)', line)
+            if z_match:
+                current_z = float(z_match.group(1))
+                update_layer_bounds(current_z)
+
+        if ';TYPE:Internal infill' in line:
+            in_infill = True
+            modified_lines.append(line)
+            continue
+        elif line.startswith(';TYPE:'):
+            in_infill = False
+
+        if in_infill and line_num not in processed_indices and line.startswith('G1') and 'E' in line:
+            processed_indices.add(line_num)
+            match = re.search(r'X([-+]?\d*\.?\d+)\s*Y([-+]?\d*\.?\d+)\s*E([-+]?\d*\.?\d+)', line)
+            if match:
+                x1, y1, e = map(float, match.groups())
+                next_line_index = line_num + 1
+                
+                if next_line_index < len(lines):
+                    next_line = lines[next_line_index]
+                    next_match = re.search(r'X([-+]?\d*\.?\d+)\s*Y([-+]?\d*\.?\d+)', next_line)
+                    if next_match:
+                        x2, y2 = map(float, next_match.groups())
+                        segments = segment_line(x1, y1, x2, y2, SEGMENT_LENGTH)
+                        
+                        distance_to_top = next_top_layer - current_z
+                        distance_to_bottom = current_z - last_bottom_layer
+                        total_distance = next_top_layer - last_bottom_layer
+                        if total_distance > 0:
+                            scaling_factor = min(distance_to_top, distance_to_bottom) / total_distance
+                        else:
+                            scaling_factor = 1.0
+
+                        extrusion_per_segment = e / len(segments)
+                        
+                        for i, (sx, sy) in enumerate(segments):
+                            z_mod = current_z + amplitude * scaling_factor * math.sin(frequency * sx)
+                            
+                            # Simple correction factor based on segment height difference
+                            dz = abs(z_mod - current_z)
+                            segment_2d = SEGMENT_LENGTH
+                            segment_3d = math.sqrt(segment_2d**2 + dz**2)
+                            correction_factor = segment_3d / segment_2d
+                            
+                            modified_lines.append(
+                                f"G1 X{sx:.3f} Y{sy:.3f} Z{z_mod:.3f} "
+                                f"E{(extrusion_per_segment * correction_factor):.5f} ; Correction factor: {correction_factor:.3f} Original E: {extrusion_per_segment:.5f}\n"
+                            )
+                        continue
+        
+        modified_lines.append(line)
+    
+    return modified_lines
+
+def process_wall_shifting(lines, layer_height, extrusion_multiplier, enable_wall_reorder=True):
+    """Process only the wall shifting modifications."""
+    current_layer = 0
+    current_z = 0.0
+    perimeter_type = None
+    perimeter_block_count = 0
+    inside_perimeter_block = False
+    previous_g1_movement = None
+    previous_f_speed = None
+    z_shift = layer_height * 0.5
+    
+    # Add buffers for shifted and non-shifted walls (only used if wall_reorder is enabled)
+    shifted_wall_buffer = []
+    nonshifted_wall_buffer = []
+    current_wall_buffer = []
+    
+    total_layers = sum(1 for line in lines if line.startswith(";AFTER_LAYER_CHANGE"))
+    modified_lines = []
+
+    for line in lines:
+        # Detect layer changes
+        if line.startswith("G1 Z"):
+            z_match = re.search(r'Z([-\d.]+)', line)
+            if z_match:
+                current_z = float(z_match.group(1))
+                current_layer = int(current_z / layer_height)
+                perimeter_block_count = 0  # Reset block counter for new layer
+                logging.info(f"Layer {current_layer} detected at Z={current_z:.3f}")
+            modified_lines.append(line)
+            continue
+
+        # Detect perimeter types from PrusaSlicer comments
+        if ";TYPE:External perimeter" in line or ";TYPE:Outer wall" in line:
+            if enable_wall_reorder:
+                # Output any buffered walls when switching to external perimeter
+                if shifted_wall_buffer or nonshifted_wall_buffer:
+                    # Output non-shifted walls first
+                    for wall in nonshifted_wall_buffer:
+                        modified_lines.extend(wall)
+                    # Then output shifted walls
+                    for wall in shifted_wall_buffer:
+                        modified_lines.extend(wall)
+                    # Clear buffers
+                    shifted_wall_buffer = []
+                    nonshifted_wall_buffer = []
+            
+            perimeter_type = "external"
+            inside_perimeter_block = False
+            logging.info(f"External perimeter detected at layer {current_layer}")
+            modified_lines.append(line)
+        elif ";TYPE:Perimeter" in line or ";TYPE:Inner wall" in line:
+            perimeter_type = "internal"
+            inside_perimeter_block = False
+            if enable_wall_reorder:
+                current_wall_buffer = []  # Start a new wall buffer
+            logging.info(f"Internal perimeter block started at layer {current_layer}")
+            modified_lines.append(line)
+        elif ";TYPE:" in line:  # Reset for other types
+            if enable_wall_reorder:
+                # Output any remaining buffered walls
+                if shifted_wall_buffer or nonshifted_wall_buffer:
+                    for wall in nonshifted_wall_buffer:
+                        modified_lines.extend(wall)
+                    for wall in shifted_wall_buffer:
+                        modified_lines.extend(wall)
+                    shifted_wall_buffer = []
+                    nonshifted_wall_buffer = []
+            
+            perimeter_type = None
+            inside_perimeter_block = False
+            modified_lines.append(line)
+
+        # Group lines into perimeter blocks
+        elif perimeter_type == "internal" and line.startswith("G1") and "X" in line and "Y" in line and "E" in line:
+            # Start a new perimeter block if not already inside one
+            if not inside_perimeter_block:
+                perimeter_block_count += 1
+                inside_perimeter_block = True
+                if enable_wall_reorder:
+                    current_wall_buffer = []  # Start a new wall buffer
+                
+                # Add the cached movement command first
+                if previous_g1_movement:
+                    if enable_wall_reorder:
+                        current_wall_buffer.append(f"{previous_g1_movement};Previous position\n")
+                        current_wall_buffer.append(f"G1 F{previous_f_speed:.3f} ; F speed from previous G1 movement\n")
+                    
+                
+                # Set Z height and determine if wall is shifted
+                is_shifted = perimeter_block_count % 2 == 1
+                if is_shifted:
+                    adjusted_z = current_z + z_shift
+                    z_command = f"G1 Z{adjusted_z:.3f} ; Shifted Z for block #{perimeter_block_count}\n"
+                else:
+                    z_command = f"G1 Z{current_z:.3f} ; Reset Z for block #{perimeter_block_count}\n"
+
+                if enable_wall_reorder:
+                    current_wall_buffer.append(z_command)
+                else:
+                    modified_lines.append(z_command)
+
+            # Process the current line (including extrusion adjustments)
+            if is_shifted:
+                e_match = re.search(r'E([-\d.]+)', line)
+                if e_match:
+                    e_value = float(e_match.group(1))
+                    original_line = line
+                    if current_layer == 1:  # First layer
+                        new_e_value = e_value * 1.5  # 50% more extrusion
+                        line = re.sub(r'E[-\d.]+', f'E{new_e_value:.5f}', line).strip()
+                        line += f" ; Adjusted E for first layer (1.5x), block #{perimeter_block_count}\n"
+                    elif current_layer == total_layers - 1:  # Last layer
+                        new_e_value = e_value * 0.5  # 50% less extrusion
+                        line = re.sub(r'E[-\d.]+', f'E{new_e_value:.5f}', line).strip()
+                        line += f" ; Adjusted E for last layer (0.5x), block #{perimeter_block_count}\n"
+                    else:  # Regular layers
+                        line += f" ; current layer: {current_layer} total layers: {total_layers} \n"
+                        new_e_value = e_value * extrusion_multiplier
+                        line = re.sub(r'E[-\d.]+', f'E{new_e_value:.5f}', line).strip()
+                        line += f" ; Adjusted E for regular layer ({extrusion_multiplier}x), block #{perimeter_block_count}\n"
+              
+
+            if enable_wall_reorder:
+                current_wall_buffer.append(line)
+            else:
+                modified_lines.append(line)
+
+
+
+        elif perimeter_type == "internal" and line.startswith("G1") and "X" in line and "Y" in line and "F" in line:
+            # End of perimeter block
+            if inside_perimeter_block:
+                if enable_wall_reorder:
+                    current_wall_buffer.append(line)
+                    # Add Z reset for shifted blocks
+                    if is_shifted:
+                        current_wall_buffer.append(f"G1 Z{current_z:.3f} ; Reset Z after shifted block #{perimeter_block_count}\n")
+                    # Add completed wall to appropriate buffer
+                    if is_shifted:
+                        shifted_wall_buffer.append(current_wall_buffer)
+                    else:
+                        nonshifted_wall_buffer.append(current_wall_buffer)
+                else:
+                    modified_lines.append(line)
+                    if is_shifted:
+                        modified_lines.append(f"G1 Z{current_z:.3f} ; Reset Z after shifted block #{perimeter_block_count}\n")
+                inside_perimeter_block = False
+                
+        elif perimeter_type == "internal" and line.startswith("G1") and "F" in line:  #fix for Fspeed movements inside perimeter blocks
+            if enable_wall_reorder:
+                current_wall_buffer.append(line)
+            else:
+                modified_lines.append(line)
+        # Cache G1 movements with X and Y coordinates and F speeds
+        if line.startswith("G1"):
+            if "X" in line and "Y" in line:
+                previous_g1_movement = line.strip()
+                logging.info(f"Cached G1 movement: {previous_g1_movement}")
+            if "F" in line:
+                f_match = re.search(r'F([\d.]+)', line)
+                if f_match:
+                    previous_f_speed = float(f_match.group(1))
+                    logging.info(f"Cached F speed: {previous_f_speed}")
+
+        # Add non-wall lines directly to output
+        if not inside_perimeter_block and not perimeter_type == "internal":
+            modified_lines.append(line)
+
+    return modified_lines
+
+def get_layer_height(gcode_lines):
+    """Extract layer height from G-code header comments"""
+    for line in gcode_lines:
+        if "layer_height =" in line.lower():
+            match = re.search(r'layer_height = (\d*\.?\d+)', line, re.IGNORECASE)
+            if match:
+                return float(match.group(1))
+    return None
+
+def process_gcode(input_file, extrusion_multiplier, enable_nonplanar=False, enable_wall_reorder=True, amplitude=DEFAULT_AMPLITUDE, frequency=DEFAULT_FREQUENCY):
+    logging.info("Starting G-code processing")
+    logging.info(f"Input file: {input_file}")
+
+    # Read the input G-code
+    with open(input_file, 'r') as infile:
+        lines = infile.readlines()
+
+    # Get layer height from G-code
+    layer_height = get_layer_height(lines)
+    if layer_height is None:
+        layer_height = 0.2  # Default fallback value
+        logging.warning(f"Could not detect layer height from G-code, using default value: {layer_height}mm")
+    else:
+        logging.info(f"Detected layer height from G-code: {layer_height}mm")
+
+    # First pass: Process non-planar infill if enabled
+    if enable_nonplanar:
+        logging.info("Processing non-planar infill modifications...")
+        solid_infill_heights = []
+        current_z = 0.0
+        
+        # Collect solid infill heights
+        for line in lines:
+            if line.startswith('G1') and 'Z' in line:
+                z_match = re.search(r'Z([-+]?\d*\.?\d+)', line)
+                if z_match:
+                    current_z = float(z_match.group(1))
+            if ';TYPE:Solid infill' in line:
+                solid_infill_heights.append(current_z)
+                logging.info(f"Found solid infill at Z={current_z}")
+
+        # Process non-planar infill
+        lines = process_nonplanar_infill(lines, current_z, amplitude, frequency, solid_infill_heights)
+        logging.info("Non-planar infill processing completed")
+
+    # Second pass: Process wall shifting
+    logging.info("Processing wall shifting modifications...")
+    modified_lines = process_wall_shifting(lines, layer_height, extrusion_multiplier, enable_wall_reorder)
+    logging.info("Wall shifting processing completed")
+
+    # Write the final modified G-code
+    with open(input_file, 'w') as outfile:
+        outfile.writelines(modified_lines)
+
+    logging.info("G-code processing completed")
+    logging.info(f"Log file saved at {log_file_path}")
+
+# Main execution
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Post-process G-code for Z-shifting, extrusion adjustments, and non-planar infill.")
+    parser.add_argument("input_file", help="Path to the input G-code file")
+    parser.add_argument("-extrusionMultiplier", type=float, default=1, help="Extrusion multiplier (default: 1.0)")
+    parser.add_argument("-nonPlanar", type=int, choices=[0, 1], default=0, help="Enable non-planar infill (0=off, 1=on)")
+    parser.add_argument("-wallReorder", type=int, choices=[0, 1], default=1, help="Enable wall reordering (0=off, 1=on)")
+    parser.add_argument("-amplitude", type=float, default=DEFAULT_AMPLITUDE, help=f"Amplitude of the Z modulation (default: {DEFAULT_AMPLITUDE})")
+    parser.add_argument("-frequency", type=float, default=DEFAULT_FREQUENCY, help=f"Frequency of the Z modulation (default: {DEFAULT_FREQUENCY})")
+    args = parser.parse_args()
+
+    process_gcode(
+        input_file=args.input_file,
+        extrusion_multiplier=args.extrusionMultiplier,
+        enable_nonplanar=bool(args.nonPlanar),
+        enable_wall_reorder=bool(args.wallReorder),
+        amplitude=args.amplitude,
+        frequency=args.frequency,
+    )