Slicer for 3D Printing

      """
      This file contains parameters, helpers, and setup to 
      create a basic gcode generation algorithm from line segments.
      
      The main 
      
      Inputs:
          lines: the line segments to be converted into gcode commands for extrusion 
          nozzle_diameter: the diameter of the 3D printer's nozzle
          filament_diameter: the diameter of the 3d printing filament
          layer_height: the height of each layer in the print
          extrusion_width: the width of the extruded line from the printer
          travel_feed_rate: the speed at which the extruder moves in X and Y
          layer_change_feed_rate: the speed at which teh extruder moves when 
              changing layers in the Z direction
          extrusion_feed_rate: the speed at which the extruder move when extruding
  
      Output:
          gcode_output: a string with gcode commands separate by new-lines"""
  
  __author__ = "mrivera-cu"
  
  import rhinoscriptsyntax as rs
  
  import math
  
  
  ########## CONSTANTS BELOW ###############
  
  # GCODE COMMANDS
  COMMAND_MOVE = "G1"
  
  # GCODE PARAM NAMES
  PARAM_X = "X"
  PARAM_Y = "Y"
  PARAM_Z = "Z"
  PARAM_E = "E"
  PARAM_F = "F"
  
  # Separates commands
  COMMAND_DELIMITER = "\n"
  
  # Precision for converting floats to strings
  E_VALUE_PRECISION = 5
  XYZ_VALUE_PRECISION = 3
  
  # Float equality precision
  FLOAT_EQUALITY_PRECISION = 5
  
  # Converts a float (f) to a string with some precision of decimal places
  # For example: 
  # Input: f=0.1234, precision=3 
  # Output: "0.123"
  def float_to_string(f, precision=XYZ_VALUE_PRECISION): 
      f = float(f)
      str_format = "{value:." + str(precision) +"f}"
      return str_format.format(value=f)
      
  # Helper to convert the E value to the proper precision
  def e_value_to_string(e):
      return float_to_string(e, E_VALUE_PRECISION)
  
  # Helper to convert the XYZ value to the proper precision
  def xyz_value_to_string(e):
      return float_to_string(e, XYZ_VALUE_PRECISION)
  
  #########################################################################
  
  # Helper function to compare floats in grasshopper/python due to float precision errors
  def are_floats_equal(f1, f2, epsilon=10**(-FLOAT_EQUALITY_PRECISION)):
      f1 *= 10**FLOAT_EQUALITY_PRECISION
      f2 *= 10**FLOAT_EQUALITY_PRECISION
      return math.fabs(f2 - f1) <= epsilon
      
  # Helper function to compare if two points are equal (have the same coordinates)
  # by handling float precision comparisons
  def is_same_pt(ptA, ptB):
      return are_floats_equal(ptA[0], ptB[0]) and are_floats_equal(ptA[1], ptB[1]) and are_floats_equal(ptA[2], ptB[2])
        
        
  ########################################################################
  # creates a string consisting of a G1 move command and 
  # any associated parameters
  def gcode_move(current_pos, next_pos, feed_rate=None, should_extrude=False):
      # Start with "G1" as command
      move_command_str = COMMAND_MOVE
  
      # Compare X positions
      if not are_floats_equal(current_pos[0], next_pos[0]):
          x_value = float_to_string(next_pos[0], precision=XYZ_VALUE_PRECISION)
          move_command_str += " " + PARAM_X + x_value
  
      # Compare Y positions
      if not are_floats_equal(current_pos[1], next_pos[1]):
          y_value = float_to_string(next_pos[1], precision=XYZ_VALUE_PRECISION)
          move_command_str += " " + PARAM_Y + y_value
  
      # Compare Z positions
      if not are_floats_equal(current_pos[2], next_pos[2]):
          z_value = float_to_string(next_pos[2], precision=XYZ_VALUE_PRECISION)
          move_command_str += " " + PARAM_Z + z_value
  
      if should_extrude:
          dx = next_pos[0] - current_pos[0]
          dy = next_pos[1] - current_pos[1]
          dz = next_pos[2] - current_pos[2]
          distance = math.sqrt(dx**2 + dy**2 + dz**2)
          
          # Updated capsule model:
          # Use the corrected rectangle area: layer_height * (extrusion_width - layer_height)
          rect_area = layer_height * (extrusion_width - layer_height)
          semi_circles_area = 0.25 * math.pi * (layer_height ** 2)
          v_out = distance * (rect_area + semi_circles_area)
  
          # Filament volume = π * (filament_diameter/2)^2
          filament_radius = filament_diameter / 2
          filament_area = math.pi * (filament_radius ** 2)
          e_value = v_out / filament_area
  
          if e_value > 0.0 and e_value < 5:
              e_str = e_value_to_string(e_value)
              move_command_str += " " + PARAM_E + e_str
  
      if feed_rate is not None:
          feed_rate_value = round(feed_rate)
          move_command_str += " " + PARAM_F + str(feed_rate_value)
      
      move_command_str = move_command_str.strip(" ")
      return move_command_str
  
  
  
  ############################################
  ############################################
  ############################################
      
  ''' Here's the main method of the script that uses the helper methods above '''
  
  def generate_gcode():
      current_position = [0, 0, 0]        # start extruder at the origin
      all_move_commands = []             # list to hold for all the move commands
  
      for i in range(0, len(lines)):
          line = lines[i]
          start = line.From
          end = line.To
          start_pos = [start.X, start.Y, start.Z]
          end_pos = [end.X, end.Y, end.Z]
  
          # Step 1: Z change (layer change)
          if not are_floats_equal(current_position[2], start_pos[2]):
              z_only_pos = [current_position[0], current_position[1], start_pos[2]]
              layer_move_cmd = gcode_move(current_position, z_only_pos, feed_rate=layer_change_feed_rate)
              all_move_commands.append(layer_move_cmd)
              current_position = z_only_pos
  
          # Step 2: Travel move to start of segment if necessary
          if not is_same_pt(current_position, start_pos):
              travel_cmd = gcode_move(current_position, start_pos, feed_rate=travel_feed_rate)
              all_move_commands.append(travel_cmd)
              current_position = start_pos
  
          # Step 3: Extrude along the segment
          extrude_cmd = gcode_move(current_position, end_pos, feed_rate=extrusion_feed_rate, should_extrude=True)
          all_move_commands.append(extrude_cmd)
          current_position = end_pos
  
      # Step 4: Combine with start and end gcode
      gcode_lines = start_gcode_lines + all_move_commands + end_gcode_lines
  
      # Final output
      output = COMMAND_DELIMITER.join(gcode_lines)
      return output
  
      
  ''' RUN THE MAIN FUNCITON ABOVE - DO NOT EDIT '''
  # this sets the gcode commands to be the the `gcode_output` variable of this grasshopper component
  gcode_output = generate_gcode()