gcodeparser.py

"""GCODE Parser

Parses a GCODE file and creates a model reconstruction split into layers and lines.
Currently only supports GCODE with linear moves (G0/G1) in absolute mode.

The parse_gcode() function takes a GCODE file and turns it into a Model object.
"""

import re
import numpy as np
from scipy.spatial import ConvexHull

try:
	import matplotlib.pyplot as plt
except:
	print("Matplotlib not installed")

class Model():
    """Model class for storing layer and max/min data"""
    
    def __init__(self, layers, max_x, max_y, max_z, min_x, min_y, min_z):
        """
        Parameters
        ----------
        layers : [Layer]
            List of Layer objects
        max_x : float
            Maximum x value of model
        max_y : float
            Maximum y value of model
        max_z : float
            Maximum z value of model
        min_x : float
            Minimum x value of model
        min_y : float
            Minimum y value of model
        min_z : float
            Minimum z value of model
        """
        
        self.layers = layers
        self.max_y = max_y
        self.max_x = max_x
        self.max_z = max_z
        self.min_y = min_y
        self.min_x = min_x
        self.min_z = min_z
        self.layer_heights = [layer.z_height for layer in layers]
        
    def to_svgs(self, dir_name):
        """Saves all layers as SVG images in directory. Used for testing only

        Parameters
        ----------
        dir_name : str
            Directory name to save images into 
        """
        
        for layer_index, layer in enumerate(self.layers):
            layer.to_svg(self.max_y, self.max_x, dir_name + "/{}.svg".format(layer_index))

class Line():
    """Line class defines a continuous extrusion in a layer"""
    
    def __init__(self):
        self.x = []
        self.y = []
        self.line_type = "regular"
        
    def append_coords(self, x, y):
        """Append a coordinate to an existing line

        Parameters
        ----------
        x : float
            x coordinate of point
        y : float
            y coordinate of point
        """

        # If this is first point in the line, append the coordinates to the line
        if len(self.x) == 0:
            self.x.append(x)
            self.y.append(y)
        else:
            prev_x = self.x[-1]
            prev_y = self.y[-1]
            # Compute the length between the new point and the last point
            segment_length = np.sqrt((x-prev_x)**2+(y-prev_y)**2)
            # Calculate number of points required to interpolate to a resolution of 0.1mm
            num_points = int(np.floor(segment_length/0.1))

            # Filter by segment length. Generally, infills are long lines defined by 2 points, whereas
            # shells are defined by regularly spaced points. 
            if segment_length > 2.5:
                if len(self.x) > 5:
                    self.line_type = "regular"
                else:
                    self.line_type = "infill"

            # Interpolation        
            if num_points < 2:
                # If the number of points to interpolate is less than 2, just append the points
                self.x.append(x)
                self.y.append(y)
            else:
                if x < prev_x:
                    xs = np.linspace(x, prev_x, num_points)
                    ys = np.interp(xs, [x, prev_x], [y, prev_y])
                    xs = np.flip(xs)
                    ys = np.flip(ys)
                else:
                    xs = np.linspace(prev_x, x, num_points)
                    ys = np.interp(xs, [prev_x, x], [prev_y, y])
                self.x.extend(xs[1:])
                self.y.extend(ys[1:])
            
    def len(self):
        """Returns number of points in line - 1"""
        return len(self.x) - 1
    
    def is_empty(self):
        """Checks if line is empty"""
        if self.len() > 0:
            return False
        else:
            return True
        
class Layer():
    """Layer class contains all lines in a layer, along with z-height info and
       functions for updating a layer and converting a layer to an SVG image."""
    
    def __init__(self, z_height):
        """
        Parameters
        ----------
        z_height : float
            The height of the layer
        """
        
        self.lines  = []
        self.new_line()
        self.prev_e = 0
        self.prev_g = -1
        self.z_height = z_height
        self.sample_points = dict([('x', []), ('y', [])])
        
    def append_coords(self, x, y, e, g):
        """
        Appends coordinates to a line as appropriate. Checks if a command is an extrusion,
        if it is, adds the coordinates to a line. Also checks if the line is continuous,
        if it is not, starts a new line.
        
        Parameters
        ----------
        x : float
            X-coordinate of command
        y : float
            Y-coordinate of command
        e : float
            Extursion value
        g : int
            G-CODE command type (not used)
        """
        
        if e > self.prev_e:                                 # If extrusion is taking place
            self.lines[-1].append_coords(x,y)               # Append coordinate to line
            self.prev_e = e
            self.prev_g = g
        else:                                               # If no extrusion is taking place
            if not self.lines[-1].is_empty():               # And the line object is not empty
                self.new_line()                             # Start a new line
            self.lines[-1].x = [x]
            self.lines[-1].y = [y]
                
    def new_line(self):
        """Makes a new line"""
        self.lines.append(Line())
            
    def to_svg(self, max_height, max_width, fn):
        """
        Saves a layer as an SVG image file

        Parameters
        ----------
        max_height : float
            Maximum height of model in mm
        max_width : float
            Maximum width of model in mm
        fn : str
            Filename to save image to
        """
        
        with open(fn, "w") as f:
            f.write(('<svg xmlns="http://www.w3.org/2000/svg"'
                     ' xmlns:xlink="http://www.w3.org/1999/xlink"'
                     ' viewBox="0 0 250 40" height="{}mm" width="{}mm">\n').format(max_height, max_width))
            for line in self.lines[::10]:
                points = '\t<polyline points="'
                coords = [f"{x},{y} " for x,y in zip(line.x, line.y)]
                points = points + "".join(coords) + ('"\n\tstyle="fill:none;stroke:black;stroke-width:0.4;'
                                                     'stroke-linejoin:round;stroke-linecap:round" />\n')
                f.write(points)
            for point in zip(self.sample_points['x'], self.sample_points['y']):
                f.write('\t<circle cx="{}" cy="{}" r="1" stroke="red" stroke-width="0" fill="red"></circle>\n'.format(point[0], point[1]))
            f.write('</svg>')
            
    def to_svg_inline(self, max_height, viewbox_width, viewbox_height):
        """
        Returns a layer as an SVG image

        Parameters
        ----------
        max_height : float
            Maximum height of model in mm
        viewbox_width : float
            Width of the SVG viewbox
        viewbox_height : float
            Height of the SVG viewbox
        """

        # Append the SVG header first
        out = ('<svg xmlns="http://www.w3.org/2000/svg"'
                ' xmlns:xlink="http://www.w3.org/1999/xlink"'
                ' viewBox="0 0 {} {}" height="{}" width="100%">\n').format(viewbox_width, viewbox_height, max_height)
        # Iterate through each line
        for line in self.lines:
            points = '\t<polyline points="'
            coords = [f"{x},{y} " for x,y in zip(line.x, line.y)]
            if line.line_type == "regular":
                # Append the points with black color if regular extrusion
                points = points + "".join(coords) + ('"\n\tstyle="fill:none;stroke:black;stroke-width:0.4;'
                                                         'stroke-linejoin:round;stroke-linecap:round" />\n')
            if line.line_type == "infill":
                # Append the points with blue color if infill
                points = points + "".join(coords) + ('"\n\tstyle="fill:none;stroke:blue;stroke-width:0.4;'
                                                         'stroke-linejoin:round;stroke-linecap:round" />\n')
            out += points

        # Add circles for each sample point
        for point in zip(self.sample_points['x'], self.sample_points['y']):
                out += '\t<circle cx="{}" cy="{}" r="1" stroke="red" stroke-width="0" fill="red"></circle>\n'.format(point[0], point[1])
        out += '</svg>'
        return out
    
    def plot_layer(self, col_reg, col_infill):
        """ Plot a layer in Matplotlib. Used for testing

        Parameters
        ----------
        col_reg : str
                Colorspec for regular extrusion
        col_infill : str
                Colorspec for infill

        """
        for line in self.lines:
            if line.line_type == "regular":
                plt.plot(line.x, line.y, col_reg) #self.z_height,
            elif line.line_type == "infill":
                plt.plot(line.x, line.y, col_infill)

    def to_csv(self, fn):
        """ Saves points as as csv

        Parameters
        ----------
        fn : str
                Filename to save to
        """
        with open(fn, "w") as f:
            for line in self.lines:
                [f.write("{},{}\n".format(x, y)) for (x,y) in zip(line.x, line.y)]
             
    def len(self):
        """ Returns the number of lines in the layer """
        return len([line for line in self.lines if line.len() > 0])

    def get_points(self, ignore_infill = False):
        """ Returns a dictionary of all points in the layer

        Keyword Arguments
        -----------------
        ignore_infill : bool (Optional)
                Set to True to ignore infills. Defaults as false
        """
        x_pts = []
        y_pts = []

        [x_pts.extend(line.x) for line in self.lines if ignore_infill != True or line.line_type == "regular"]
        [y_pts.extend(line.y) for line in self.lines if ignore_infill != True or line.line_type == "regular"]

        return dict([('x', x_pts), ('y', y_pts), ('num_pts', len(x_pts))])

    def gen_sample_points(self, method, num_samples):
        """ Generate sample points for this layer

        Sampling point algorithms live here. To add a new method, add a new elif section with an appropriate
        name. Can also add keyword arguments as needed.

        Parameters
        ----------
        method : string
                Name of method to use
        num_samples : int
                Number of samples to generate
        """

        # Get the points in this layer
        points = self.get_points()

        # Random sampling method: Pick X number of points from all available points
        if method == "Random sampling":
            sample_pts = list(np.random.randint(0, points['num_pts'], num_samples))
            x_pts = [points['x'][i] for i in sample_pts]
            y_pts = [points['y'][i] for i in sample_pts]
            self.sample_points = dict([('x', x_pts), ('y', y_pts)])
            
        # Min-max method: Pick points along the maximum/minimum of the X-Y axes, and a 45 degree tilted axes
        elif method == "Min-max":
            # Put the points into a numpy array to make life a bit easier
            point_array = np.array([points['x'], points['y']])

            # Find the minimum and maximum values along the regular axes
            max_vals = np.argmax(point_array, axis=1)
            min_vals = np.argmin(point_array, axis=1)

            rot45 = np.array([[0.7071, -0.7071],[0.7071, 0.7071]])      # Transformation matrix for a rotation by 45 degrees
            point_array_rot = np.matmul(rot45, point_array)             # Rotate all points by 45 degrees
            max_vals_rot = np.argmax(point_array_rot, axis=1)           # Repeat process of finding min/max points
            min_vals_rot = np.argmin(point_array_rot, axis=1)

            # Remove duplicate values if any
            sample_pts = np.unique(np.concatenate((max_vals, min_vals, max_vals_rot, min_vals_rot))).tolist()
            x_pts = [points['x'][i] for i in sample_pts]
            y_pts = [points['y'][i] for i in sample_pts]
            self.sample_points = dict([('x', x_pts), ('y', y_pts)])

        # Inside outside method: Pick 10 points from outside the convex hull, pick 10 points from inside the convex hull
        elif method == "Inside-outside":
            # Put the points into a numpy array to make life a bit easier 
            point_list = []
            [point_list.append([x,y]) for x,y in zip(points['x'], points['y'])]
            features = np.array(point_list)
            
            # If there are less than 4 points, do nothing
            if features.shape[0] < 4:
                self.sample_points = dict([('x', []), ('y', [])])
            else:
                hull = ConvexHull(features)                             # Compute the convex hull
                outside_indx = np.random.choice(hull.vertices, 10)      # Get the indices for 10 random points along the vertices of the hull

                # Find all points that are inside the convex hull
                all_inside_indx = np.arange(1, len(point_list))
                all_inside_indx = all_inside_indx[np.isin(all_inside_indx, hull.vertices, invert=True)]
                # Pick 10 points from inside the hull
                inside_indx = np.random.choice(all_inside_indx, 10)

                all_points = np.concatenate((inside_indx, outside_indx));
                x_pts = [feature[0] for feature in features[all_points]]
                y_pts = [feature[1] for feature in features[all_points]]
                self.sample_points = dict([('x', x_pts), ('y', y_pts)])

        # Return nothing if no sampling method 
        else:
            self.sample_points = dict([('x', []), ('y', [])])    

def parse_gcode(filename, sample_spacing, samples_per_layer, method):
    """ Function for parsing GCODE file

    Parameters
    ----------
    filename : str
            File to process
    sample_spacing : int
            Number of layers to space between sample layers
    samples_per_layer : int
            Number of samples per layer
    method : str
            Sampling method. Choose from methods in gen_sample_points method
    """
    layers  = []
    num_layers = 0
    layer_heights = []
    lines  = []
    Gs     = []
    xs     = []
    ys     = []
    zs     = []
    es     = []
    prev_x = 0
    prev_y = 0
    prev_z = 0
    prev_e = 0

    with open(filename) as f:                                           # Open GCODE file
        file = f.readlines()
                    
    for line in file:                                                   # Iterate through lines
        line = line.strip()                                             # Strip newline character
        if not line or line[0] == ";":                                  # Skip empty lines and comments
            continue
        line = line.split(";")[0].strip()                               # Remove any trailing comments

        #TODO: Add handling for G2/G3 and incremental mode
        
        G_match = re.match("^(?:G0|G1)(\.\d+)?\s", line)                # Match for any linear movements
        if G_match:
            lines.append(line)

            G = re.match("G([0123])", line)                             # Match for G command
            Gs.append(int(G.group(1)))
                      
            x_loc = re.match(".*X(-?\d*\.?\d*)", line)                  # Match for X coordinates. If none, use prior
            if x_loc:
                x_loc = float(x_loc.group(1))
                prev_x = x_loc
                xs.append(x_loc)
            else:
                xs.append(prev_x)
            y_loc = re.match(".*Y(-?\d*\.?\d*)", line)                  # Match for Y coordinates. If none, use prior
            if y_loc:
                y_loc = float(y_loc.group(1))
                prev_y = y_loc
                ys.append(y_loc)
            else:
                ys.append(prev_y)

            z_loc = re.match(".*Z(-?\d*\.?\d*)", line)                  # Match for Z coordinates. If none, use prior
            if z_loc:
                z_loc = float(z_loc.group(1))
                prev_z = z_loc
                zs.append(z_loc)
            else:
                zs.append(prev_z)

            e_loc = re.match(".*E(-?\d*\.?\d*)", line)                  # Match for Z coordinates. If none, use prior
            if e_loc:
                e_loc = float(e_loc.group(1))
                prev_e = e_loc
                es.append(e_loc)
            else:
                es.append(prev_e)
    [layer_heights.append(height) for height in set(zs)]                # Find the unique Z heights in the GCODE file
    layer_heights.sort()                                                # Make it a sorted list

    num_layers = len(layer_heights)                                     # Number of layers
    index = dict(zip(layer_heights, range(num_layers)))                 # Map layer height to an index

    layers = [Layer(layer_heights[i]) for i in range(num_layers)]       # Initialize model list with number of layers

    for i in range(len(lines)):                                         # Iterate through each line 
        layers[index[zs[i]]].append_coords(xs[i],ys[i],es[i],Gs[i])     # Append each command into the model list

    layers = [layer for layer in layers if layer.len() > 0]             # Find non-empty layers
    for i in range(len(layers)):
        if (i % sample_spacing) == 0 and (i != 0):
            layers[i].gen_sample_points(method, samples_per_layer)      # Generate sample points for desired layers
        else:
            layers[i].gen_sample_points("none", 0)
    model = Model(layers, max(xs), max(ys), max(zs), min(xs), min(ys), min(zs))
    return model