FlatCAM/camlib.py

# ########################################################## ##
# FlatCAM: 2D Post-processing for Manufacturing               #
# http://flatcam.org                                          #
# Author: Juan Pablo Caram (c)                                #
# Date: 2/5/2014                                              #
# MIT Licence                                                 #
# ########################################################## ##


from PyQt5 import QtWidgets, QtCore
from io import StringIO

from numpy.linalg import solve, norm

import platform
from copy import deepcopy

import traceback
from decimal import Decimal

from rtree import index as rtindex
from lxml import etree as ET

# See: http://toblerity.org/shapely/manual.html
from shapely.geometry import Polygon, Point, LinearRing

from shapely.geometry import box as shply_box
from shapely.ops import unary_union, substring, linemerge
import shapely.affinity as affinity
from shapely.wkt import loads as sloads
from shapely.wkt import dumps as sdumps
from shapely.geometry.base import BaseGeometry
from shapely.geometry import shape

# ---------------------------------------
# NEEDED for Legacy mode
# Used for solid polygons in Matplotlib
from descartes.patch import PolygonPatch
# ---------------------------------------

from collections import Iterable

import rasterio
from rasterio.features import shapes
import ezdxf

from appCommon.Common import GracefulException as grace

# Commented for FlatCAM packaging with cx_freeze
# from scipy.spatial import KDTree, Delaunay
# from scipy.spatial import Delaunay

from appParsers.ParseSVG import *
from appParsers.ParseDXF import *

if platform.architecture()[0] == '64bit':
    from ortools.constraint_solver import pywrapcp
    from ortools.constraint_solver import routing_enums_pb2

import logging

import gettext
import appTranslation as fcTranslate
import builtins

fcTranslate.apply_language('strings')

log = logging.getLogger('base2')
log.setLevel(logging.DEBUG)

formatter = logging.Formatter('[%(levelname)s] %(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
log.addHandler(handler)

if '_' not in builtins.__dict__:
    _ = gettext.gettext


class ParseError(Exception):
    pass


class ApertureMacro:
    """
    Syntax of aperture macros.

    <AM command>:           AM<Aperture macro name>*<Macro content>
    <Macro content>:        {{<Variable definition>*}{<Primitive>*}}
    <Variable definition>:  $K=<Arithmetic expression>
    <Primitive>:            <Primitive code>,<Modifier>{,<Modifier>}|<Comment>
    <Modifier>:             $M|< Arithmetic expression>
    <Comment>:              0 <Text>
    """

    # ## Regular expressions
    am1_re = re.compile(r'^%AM([^\*]+)\*(.+)?(%)?$')
    am2_re = re.compile(r'(.*)%$')
    amcomm_re = re.compile(r'^0(.*)')
    amprim_re = re.compile(r'^[1-9].*')
    amvar_re = re.compile(r'^\$([0-9a-zA-z]+)=(.*)')

    def __init__(self, name=None):
        self.name = name
        self.raw = ""

        # ## These below are recomputed for every aperture
        # ## definition, in other words, are temporary variables.
        self.primitives = []
        self.locvars = {}
        self.geometry = None

    def to_dict(self):
        """
        Returns the object in a serializable form. Only the name and
        raw are required.

        :return: Dictionary representing the object. JSON ready.
        :rtype: dict
        """

        return {
            'name': self.name,
            'raw': self.raw
        }

    def from_dict(self, d):
        """
        Populates the object from a serial representation created
        with ``self.to_dict()``.

        :param d: Serial representation of an ApertureMacro object.
        :return: None
        """
        for attr in ['name', 'raw']:
            setattr(self, attr, d[attr])

    def parse_content(self):
        """
        Creates numerical lists for all primitives in the aperture
        macro (in ``self.raw``) by replacing all variables by their
        values iteratively and evaluating expressions. Results
        are stored in ``self.primitives``.

        :return: None
        """
        # Cleanup
        self.raw = self.raw.replace('\n', '').replace('\r', '').strip(" *")
        self.primitives = []

        # Separate parts
        parts = self.raw.split('*')

        # ### Every part in the macro ####
        for part in parts:
            # ## Comments. Ignored.
            match = ApertureMacro.amcomm_re.search(part)
            if match:
                continue

            # ## Variables
            # These are variables defined locally inside the macro. They can be
            # numerical constant or defined in terms of previously define
            # variables, which can be defined locally or in an aperture
            # definition. All replacements occur here.
            match = ApertureMacro.amvar_re.search(part)
            if match:
                var = match.group(1)
                val = match.group(2)

                # Replace variables in value
                for v in self.locvars:
                    # replaced the following line with the next to fix Mentor custom apertures not parsed OK
                    # val = re.sub((r'\$'+str(v)+r'(?![0-9a-zA-Z])'), str(self.locvars[v]), val)
                    val = val.replace('$' + str(v), str(self.locvars[v]))

                # Make all others 0
                val = re.sub(r'\$[0-9a-zA-Z](?![0-9a-zA-Z])', "0", val)
                # Change x with *
                val = re.sub(r'[xX]', "*", val)

                # Eval() and store.
                self.locvars[var] = eval(val)
                continue

            # ## Primitives
            # Each is an array. The first identifies the primitive, while the
            # rest depend on the primitive. All are strings representing a
            # number and may contain variable definition. The values of these
            # variables are defined in an aperture definition.
            match = ApertureMacro.amprim_re.search(part)
            if match:
                # ## Replace all variables
                for v in self.locvars:
                    # replaced the following line with the next to fix Mentor custom apertures not parsed OK
                    # part = re.sub(r'\$' + str(v) + r'(?![0-9a-zA-Z])', str(self.locvars[v]), part)
                    part = part.replace('$' + str(v), str(self.locvars[v]))

                # Make all others 0
                part = re.sub(r'\$[0-9a-zA-Z](?![0-9a-zA-Z])', "0", part)

                # Change x with *
                part = re.sub(r'[xX]', "*", part)

                # ## Store
                elements = part.split(",")
                self.primitives.append([eval(x) for x in elements])
                continue

            log.warning("Unknown syntax of aperture macro part: %s" % str(part))

    def append(self, data):
        """
        Appends a string to the raw macro.

        :param data: Part of the macro.
        :type data: str
        :return: None
        """
        self.raw += data

    @staticmethod
    def default2zero(n, mods):
        """
        Pads the ``mods`` list with zeros resulting in an
        list of length n.

        :param n:       Length of the resulting list.
        :type n:        int
        :param mods:    List to be padded.
        :type mods:     list
        :return:        Zero-padded list.
        :rtype:         list
        """

        x = [0.0] * n
        na = len(mods)
        x[0:na] = mods
        return x

    @staticmethod
    def make_circle(mods):
        """

        :param mods: (Exposure 0/1, Diameter >=0, X-coord, Y-coord)
        :return:
        """
        val = ApertureMacro.default2zero(4, mods)
        pol = val[0]
        dia = val[1]
        x = val[2]
        y = val[3]
        # pol, dia, x, y = ApertureMacro.default2zero(4, mods)
        return {"pol": int(pol), "geometry": Point(x, y).buffer(dia / 2)}

    @staticmethod
    def make_vectorline(mods):
        """

        :param mods: (Exposure 0/1, Line width >= 0, X-start, Y-start, X-end, Y-end,
            rotation angle around origin in degrees)
        :return:
        """
        val = ApertureMacro.default2zero(7, mods)
        pol = val[0]
        width = val[1]
        xs = val[2]
        ys = val[3]
        xe = val[4]
        ye = val[5]
        angle = val[6]
        # pol, width, xs, ys, xe, ye, angle = ApertureMacro.default2zero(7, mods)

        line = LineString([(xs, ys), (xe, ye)])
        box = line.buffer(width / 2, cap_style=2)
        box_rotated = affinity.rotate(box, angle, origin=(0, 0))

        return {"pol": int(pol), "geometry": box_rotated}

    @staticmethod
    def make_centerline(mods):
        """

        :param mods: (Exposure 0/1, width >=0, height >=0, x-center, y-center,
            rotation angle around origin in degrees)
        :return:
        """

        # pol, width, height, x, y, angle = ApertureMacro.default2zero(4, mods)
        val = ApertureMacro.default2zero(4, mods)
        pol = val[0]
        width = val[1]
        height = val[2]
        x = val[3]
        y = val[4]
        angle = val[5]

        box = shply_box(x - width / 2, y - height / 2, x + width / 2, y + height / 2)
        box_rotated = affinity.rotate(box, angle, origin=(0, 0))

        return {"pol": int(pol), "geometry": box_rotated}

    @staticmethod
    def make_lowerleftline(mods):
        """

        :param mods: (exposure 0/1, width >=0, height >=0, x-lowerleft, y-lowerleft,
            rotation angle around origin in degrees)
        :return:
        """

        # pol, width, height, x, y, angle = ApertureMacro.default2zero(6, mods)
        val = ApertureMacro.default2zero(6, mods)
        pol = val[0]
        width = val[1]
        height = val[2]
        x = val[3]
        y = val[4]
        angle = val[5]

        box = shply_box(x, y, x + width, y + height)
        box_rotated = affinity.rotate(box, angle, origin=(0, 0))

        return {"pol": int(pol), "geometry": box_rotated}

    @staticmethod
    def make_outline(mods):
        """

        :param mods:
        :return:
        """

        pol = mods[0]
        n = mods[1]
        points = [(0, 0)] * (n + 1)

        for i in range(n + 1):
            points[i] = mods[2 * i + 2:2 * i + 4]

        angle = mods[2 * n + 4]

        poly = Polygon(points)
        poly_rotated = affinity.rotate(poly, angle, origin=(0, 0))

        return {"pol": int(pol), "geometry": poly_rotated}

    @staticmethod
    def make_polygon(mods):
        """
        Note: Specs indicate that rotation is only allowed if the center
        (x, y) == (0, 0). I will tolerate breaking this rule.

        :param mods: (exposure 0/1, n_verts 3<=n<=12, x-center, y-center,
            diameter of circumscribed circle >=0, rotation angle around origin)
        :return:
        """

        # pol, nverts, x, y, dia, angle = ApertureMacro.default2zero(6, mods)
        val = ApertureMacro.default2zero(6, mods)
        pol = val[0]
        nverts = val[1]
        x = val[2]
        y = val[3]
        dia = val[4]
        angle = val[5]

        points = [(0, 0)] * nverts

        for i in range(nverts):
            points[i] = (x + 0.5 * dia * np.cos(2 * np.pi * i / nverts),
                         y + 0.5 * dia * np.sin(2 * np.pi * i / nverts))

        poly = Polygon(points)
        poly_rotated = affinity.rotate(poly, angle, origin=(0, 0))

        return {"pol": int(pol), "geometry": poly_rotated}

    @staticmethod
    def make_moire(mods):
        """
        Note: Specs indicate that rotation is only allowed if the center
        (x, y) == (0, 0). I will tolerate breaking this rule.

        :param mods: (x-center, y-center, outer_dia_outer_ring, ring thickness,
            gap, max_rings, crosshair_thickness, crosshair_len, rotation
            angle around origin in degrees)
        :return:
        """

        # x, y, dia, thickness, gap, nrings, cross_th, cross_len, angle = ApertureMacro.default2zero(9, mods)
        val = ApertureMacro.default2zero(9, mods)
        x = val[0]
        y = val[1]
        dia = val[2]
        thickness = val[3]
        gap = val[4]
        nrings = val[5]
        cross_th = val[6]
        cross_len = val[7]
        angle = val[8]

        r = dia / 2 - thickness / 2
        result = Point((x, y)).buffer(r).exterior.buffer(thickness / 2.0)
        ring = Point((x, y)).buffer(r).exterior.buffer(thickness / 2.0)  # Need a copy!

        i = 1  # Number of rings created so far

        # ## If the ring does not have an interior it means that it is
        # ## a disk. Then stop.
        while len(ring.interiors) > 0 and i < nrings:
            r -= thickness + gap
            if r <= 0:
                break
            ring = Point((x, y)).buffer(r).exterior.buffer(thickness / 2.0)
            result = unary_union([result, ring])
            i += 1

        # ## Crosshair
        hor = LineString([(x - cross_len, y), (x + cross_len, y)]).buffer(cross_th / 2.0, cap_style=2)
        ver = LineString([(x, y - cross_len), (x, y + cross_len)]).buffer(cross_th / 2.0, cap_style=2)
        result = unary_union([result, hor, ver])

        return {"pol": 1, "geometry": result}

    @staticmethod
    def make_thermal(mods):
        """
        Note: Specs indicate that rotation is only allowed if the center
        (x, y) == (0, 0). I will tolerate breaking this rule.

        :param mods: [x-center, y-center, diameter-outside, diameter-inside,
            gap-thickness, rotation angle around origin]
        :return:
        """

        # x, y, dout, din, t, angle = ApertureMacro.default2zero(6, mods)
        val = ApertureMacro.default2zero(6, mods)
        x = val[0]
        y = val[1]
        dout = val[2]
        din = val[3]
        t = val[4]
        angle = val[5]

        ring = Point((x, y)).buffer(dout / 2.0).difference(Point((x, y)).buffer(din / 2.0))
        hline = LineString([(x - dout / 2.0, y), (x + dout / 2.0, y)]).buffer(t / 2.0, cap_style=3)
        vline = LineString([(x, y - dout / 2.0), (x, y + dout / 2.0)]).buffer(t / 2.0, cap_style=3)
        thermal = ring.difference(hline.union(vline))

        return {"pol": 1, "geometry": thermal}

    def make_geometry(self, modifiers):
        """
        Runs the macro for the given modifiers and generates
        the corresponding geometry.

        :param modifiers: Modifiers (parameters) for this macro
        :type modifiers: list
        :return: Shapely geometry
        :rtype: shapely.geometry.polygon
        """

        # ## Primitive makers
        makers = {
            "1": ApertureMacro.make_circle,
            "2": ApertureMacro.make_vectorline,
            "20": ApertureMacro.make_vectorline,
            "21": ApertureMacro.make_centerline,
            "22": ApertureMacro.make_lowerleftline,
            "4": ApertureMacro.make_outline,
            "5": ApertureMacro.make_polygon,
            "6": ApertureMacro.make_moire,
            "7": ApertureMacro.make_thermal
        }

        # ## Store modifiers as local variables
        modifiers = modifiers or []
        modifiers = [float(m) for m in modifiers]
        self.locvars = {}
        for i in range(0, len(modifiers)):
            self.locvars[str(i + 1)] = modifiers[i]

        # ## Parse
        self.primitives = []  # Cleanup
        self.geometry = Polygon()
        self.parse_content()

        # ## Make the geometry
        for primitive in self.primitives:
            # Make the primitive
            prim_geo = makers[str(int(primitive[0]))](primitive[1:])

            # Add it (according to polarity)
            # if self.geometry is None and prim_geo['pol'] == 1:
            #     self.geometry = prim_geo['geometry']
            #     continue
            if prim_geo['pol'] == 1:
                self.geometry = self.geometry.union(prim_geo['geometry'])
                continue
            if prim_geo['pol'] == 0:
                self.geometry = self.geometry.difference(prim_geo['geometry'])
                continue

        return self.geometry


class Geometry(object):
    """
    Base geometry class.
    """

    defaults = {
        "units": 'mm',
        # "geo_steps_per_circle": 128
    }

    def __init__(self, geo_steps_per_circle=None):
        # Units (in or mm)
        self.units = self.app.defaults["units"]
        self.decimals = self.app.decimals

        self.drawing_tolerance = 0.0
        self.tools = None

        # Final geometry: MultiPolygon or list (of geometry constructs)
        self.solid_geometry = None

        # Final geometry: MultiLineString or list (of LineString or Points)
        self.follow_geometry = None

        # Flattened geometry (list of paths only)
        self.flat_geometry = []

        # this is the calculated conversion factor when the file units are different than the ones in the app
        self.file_units_factor = 1

        # Index
        self.index = None

        self.geo_steps_per_circle = geo_steps_per_circle

        # variables to display the percentage of work done
        self.geo_len = 0
        self.old_disp_number = 0
        self.el_count = 0

        if self.app.is_legacy is False:
            self.temp_shapes = self.app.plotcanvas.new_shape_collection(layers=1)
        else:
            from appGUI.PlotCanvasLegacy import ShapeCollectionLegacy
            self.temp_shapes = ShapeCollectionLegacy(obj=self, app=self.app, name='camlib.geometry')

        # Attributes to be included in serialization
        self.ser_attrs = ["units", 'solid_geometry', 'follow_geometry', 'tools']

    def plot_temp_shapes(self, element, color='red'):

        try:
            for sub_el in element:
                self.plot_temp_shapes(sub_el)
        except TypeError:  # Element is not iterable...
            # self.add_shape(shape=element, color=color, visible=visible, layer=0)
            self.temp_shapes.add(tolerance=float(self.app.defaults["global_tolerance"]),
                                 shape=element, color=color, visible=True, layer=0)

    def make_index(self):
        self.flatten()
        self.index = FlatCAMRTree()

        for i, g in enumerate(self.flat_geometry):
            self.index.insert(i, g)

    def add_circle(self, origin, radius, tool=None):
        """
        Adds a circle to the object.

        :param origin:  Center of the circle.
        :param radius:  Radius of the circle.
        :param tool:    A tool in the Tools dictionary attribute of the object
        :return: None
        """

        if self.solid_geometry is None:
            self.solid_geometry = []

        new_circle = Point(origin).buffer(radius, int(self.geo_steps_per_circle))
        if not new_circle.is_valid:
            return "fail"

        # add to the solid_geometry
        try:
            self.solid_geometry.append(new_circle)
        except TypeError:
            try:
                self.solid_geometry = self.solid_geometry.union(new_circle)
            except Exception as e:
                log.error("Failed to run union on polygons. %s" % str(e))
                return "fail"

        # add in tools solid_geometry
        if tool is None or tool not in self.tools:
            tool = 1
        self.tools[tool]['solid_geometry'].append(new_circle)

        # calculate bounds
        try:
            xmin, ymin, xmax, ymax = self.bounds()

            self.options['xmin'] = xmin
            self.options['ymin'] = ymin
            self.options['xmax'] = xmax
            self.options['ymax'] = ymax
        except Exception as e:
            log.error("Failed. The object has no bounds properties. %s" % str(e))

    def add_polygon(self, points, tool=None):
        """
        Adds a polygon to the object (by union)

        :param points:  The vertices of the polygon.
        :param tool:    A tool in the Tools dictionary attribute of the object
        :return:        None
        """
        if self.solid_geometry is None:
            self.solid_geometry = []

        new_poly = Polygon(points)
        if not new_poly.is_valid:
            return "fail"

        # add to the solid_geometry
        if type(self.solid_geometry) is list:
            self.solid_geometry.append(new_poly)
        else:
            try:
                self.solid_geometry = self.solid_geometry.union(Polygon(points))
            except Exception as e:
                log.error("Failed to run union on polygons. %s" % str(e))
                return "fail"

        # add in tools solid_geometry
        if tool is None or tool not in self.tools:
            tool = 1
        self.tools[tool]['solid_geometry'].append(new_poly)

        # calculate bounds
        try:
            xmin, ymin, xmax, ymax = self.bounds()

            self.options['xmin'] = xmin
            self.options['ymin'] = ymin
            self.options['xmax'] = xmax
            self.options['ymax'] = ymax
        except Exception as e:
            log.error("Failed. The object has no bounds properties. %s" % str(e))

    def add_polyline(self, points, tool=None):
        """
        Adds a polyline to the object (by union)

        :param points:  The vertices of the polyline.
        :param tool:    A tool in the Tools dictionary attribute of the object
        :return:        None
        """
        if self.solid_geometry is None:
            self.solid_geometry = []

        new_line = LineString(points)
        if not new_line.is_valid:
            return "fail"

        # add to the solid_geometry
        if type(self.solid_geometry) is list:
            self.solid_geometry.append(new_line)
        else:
            try:
                self.solid_geometry = self.solid_geometry.union(new_line)
            except Exception as e:
                log.error("Failed to run union on polylines. %s" % str(e))
                return "fail"

        # add in tools solid_geometry
        if tool is None or tool not in self.tools:
            tool = 1
        self.tools[tool]['solid_geometry'].append(new_line)

        # calculate bounds
        try:
            xmin, ymin, xmax, ymax = self.bounds()

            self.options['xmin'] = xmin
            self.options['ymin'] = ymin
            self.options['xmax'] = xmax
            self.options['ymax'] = ymax
        except Exception as e:
            log.error("Failed. The object has no bounds properties. %s" % str(e))

    def is_empty(self):
        if isinstance(self.solid_geometry, BaseGeometry) or isinstance(self.solid_geometry, Polygon) or \
                isinstance(self.solid_geometry, MultiPolygon):
            return self.solid_geometry.is_empty

        if isinstance(self.solid_geometry, list):
            return len(self.solid_geometry) == 0

        self.app.inform.emit('[ERROR_NOTCL] %s' % _("self.solid_geometry is neither BaseGeometry or list."))
        return

    def subtract_polygon(self, points):
        """
        Subtract polygon from the given object. This only operates on the paths in the original geometry,
        i.e. it converts polygons into paths.

        :param points: The vertices of the polygon.
        :return: none
        """
        if self.solid_geometry is None:
            self.solid_geometry = []

        # pathonly should be allways True, otherwise polygons are not subtracted
        flat_geometry = self.flatten(pathonly=True)
        log.debug("%d paths" % len(flat_geometry))

        if not isinstance(points, Polygon):
            polygon = Polygon(points)
        else:
            polygon = points
        toolgeo = unary_union(polygon)
        diffs = []
        for target in flat_geometry:
            if isinstance(target, LineString) or isinstance(target, LineString) or isinstance(target, MultiLineString):
                diffs.append(target.difference(toolgeo))
            else:
                log.warning("Not implemented.")

        self.solid_geometry = unary_union(diffs)

    def bounds(self, flatten=False):
        """
        Returns coordinates of rectangular bounds
        of geometry: (xmin, ymin, xmax, ymax).
        :param flatten: will flatten the solid_geometry if True
        :return:
        """
        # fixed issue of getting bounds only for one level lists of objects
        # now it can get bounds for nested lists of objects

        log.debug("camlib.Geometry.bounds()")

        if self.solid_geometry is None:
            log.debug("solid_geometry is None")
            return 0, 0, 0, 0

        def bounds_rec(obj):
            if type(obj) is list:
                gminx = np.Inf
                gminy = np.Inf
                gmaxx = -np.Inf
                gmaxy = -np.Inf

                for k in obj:
                    if type(k) is dict:
                        for key in k:
                            minx_, miny_, maxx_, maxy_ = bounds_rec(k[key])
                            gminx = min(gminx, minx_)
                            gminy = min(gminy, miny_)
                            gmaxx = max(gmaxx, maxx_)
                            gmaxy = max(gmaxy, maxy_)
                    else:
                        try:
                            if k.is_empty:
                                continue
                        except Exception:
                            pass

                        minx_, miny_, maxx_, maxy_ = bounds_rec(k)
                        gminx = min(gminx, minx_)
                        gminy = min(gminy, miny_)
                        gmaxx = max(gmaxx, maxx_)
                        gmaxy = max(gmaxy, maxy_)
                return gminx, gminy, gmaxx, gmaxy
            else:
                # it's a Shapely object, return it's bounds
                return obj.bounds

        if self.multigeo is True:
            minx_list = []
            miny_list = []
            maxx_list = []
            maxy_list = []

            for tool in self.tools:
                working_geo = self.tools[tool]['solid_geometry']

                if flatten:
                    self.flatten(geometry=working_geo, reset=True)
                    working_geo = self.flat_geometry

                minx, miny, maxx, maxy = bounds_rec(working_geo)
                minx_list.append(minx)
                miny_list.append(miny)
                maxx_list.append(maxx)
                maxy_list.append(maxy)

            return min(minx_list), min(miny_list), max(maxx_list), max(maxy_list)
        else:
            if flatten:
                self.flatten(reset=True)
                self.solid_geometry = self.flat_geometry

            bounds_coords = bounds_rec(self.solid_geometry)
            return bounds_coords

        # try:
        #     # from here: http://rightfootin.blogspot.com/2006/09/more-on-python-flatten.html
        #     def flatten(l, ltypes=(list, tuple)):
        #         ltype = type(l)
        #         l = list(l)
        #         i = 0
        #         while i < len(l):
        #             while isinstance(l[i], ltypes):
        #                 if not l[i]:
        #                     l.pop(i)
        #                     i -= 1
        #                     break
        #                 else:
        #                     l[i:i + 1] = l[i]
        #             i += 1
        #         return ltype(l)
        #
        #     log.debug("Geometry->bounds()")
        #     if self.solid_geometry is None:
        #         log.debug("solid_geometry is None")
        #         return 0, 0, 0, 0
        #
        #     if type(self.solid_geometry) is list:
        #         if len(self.solid_geometry) == 0:
        #             log.debug('solid_geometry is empty []')
        #             return 0, 0, 0, 0
        #         return unary_union(flatten(self.solid_geometry)).bounds
        #     else:
        #         return self.solid_geometry.bounds
        # except Exception as e:
        #     self.app.inform.emit("[ERROR_NOTCL] Error cause: %s" % str(e))

        # log.debug("Geometry->bounds()")
        # if self.solid_geometry is None:
        #     log.debug("solid_geometry is None")
        #     return 0, 0, 0, 0
        #
        # if type(self.solid_geometry) is list:
        #     if len(self.solid_geometry) == 0:
        #         log.debug('solid_geometry is empty []')
        #         return 0, 0, 0, 0
        #     return unary_union(self.solid_geometry).bounds
        # else:
        #     return self.solid_geometry.bounds

    def find_polygon(self, point, geoset=None):
        """
        Find an object that object.contains(Point(point)) in
        poly, which can can be iterable, contain iterable of, or
        be itself an implementer of .contains().

        :param point: See description
        :param geoset: a polygon or list of polygons where to find if the param point is contained
        :return: Polygon containing point or None.
        """

        if geoset is None:
            geoset = self.solid_geometry

        try:  # Iterable
            for sub_geo in geoset:
                p = self.find_polygon(point, geoset=sub_geo)
                if p is not None:
                    return p
        except TypeError:  # Non-iterable
            try:  # Implements .contains()
                if isinstance(geoset, LinearRing):
                    geoset = Polygon(geoset)
                if geoset.contains(Point(point)):
                    return geoset
            except AttributeError:  # Does not implement .contains()
                return None

        return None

    def get_interiors(self, geometry=None):

        interiors = []

        if geometry is None:
            geometry = self.solid_geometry

        # ## If iterable, expand recursively.
        try:
            for geo in geometry:
                interiors.extend(self.get_interiors(geometry=geo))

        # ## Not iterable, get the interiors if polygon.
        except TypeError:
            if type(geometry) == Polygon:
                interiors.extend(geometry.interiors)

        return interiors

    def get_exteriors(self, geometry=None):
        """
        Returns all exteriors of polygons in geometry. Uses
        ``self.solid_geometry`` if geometry is not provided.

        :param geometry: Shapely type or list or list of list of such.
        :return: List of paths constituting the exteriors
           of polygons in geometry.
        """

        exteriors = []

        if geometry is None:
            geometry = self.solid_geometry

        # ## If iterable, expand recursively.
        try:
            for geo in geometry:
                exteriors.extend(self.get_exteriors(geometry=geo))

        # ## Not iterable, get the exterior if polygon.
        except TypeError:
            if type(geometry) == Polygon:
                exteriors.append(geometry.exterior)

        return exteriors

    def flatten(self, geometry=None, reset=True, pathonly=False):
        """
        Creates a list of non-iterable linear geometry objects.
        Polygons are expanded into its exterior and interiors if specified.

        Results are placed in self.flat_geometry

        :param geometry: Shapely type or list or list of list of such.
        :param reset: Clears the contents of self.flat_geometry.
        :param pathonly: Expands polygons into linear elements.
        """

        if geometry is None:
            geometry = self.solid_geometry

        if reset:
            self.flat_geometry = []

        # ## If iterable, expand recursively.
        try:
            for geo in geometry:
                if geo is not None:
                    self.flatten(geometry=geo,
                                 reset=False,
                                 pathonly=pathonly)

        # ## Not iterable, do the actual indexing and add.
        except TypeError:
            if pathonly and type(geometry) == Polygon:
                self.flat_geometry.append(geometry.exterior)
                self.flatten(geometry=geometry.interiors,
                             reset=False,
                             pathonly=True)
            else:
                self.flat_geometry.append(geometry)

        return self.flat_geometry

    # def make2Dstorage(self):
    #
    #     self.flatten()
    #
    #     def get_pts(o):
    #         pts = []
    #         if type(o) == Polygon:
    #             g = o.exterior
    #             pts += list(g.coords)
    #             for i in o.interiors:
    #                 pts += list(i.coords)
    #         else:
    #             pts += list(o.coords)
    #         return pts
    #
    #     storage = FlatCAMRTreeStorage()
    #     storage.get_points = get_pts
    #     for shape in self.flat_geometry:
    #         storage.insert(shape)
    #     return storage

    # def flatten_to_paths(self, geometry=None, reset=True):
    #     """
    #     Creates a list of non-iterable linear geometry elements and
    #     indexes them in rtree.
    #
    #     :param geometry: Iterable geometry
    #     :param reset: Wether to clear (True) or append (False) to self.flat_geometry
    #     :return: self.flat_geometry, self.flat_geometry_rtree
    #     """
    #
    #     if geometry is None:
    #         geometry = self.solid_geometry
    #
    #     if reset:
    #         self.flat_geometry = []
    #
    #     # ## If iterable, expand recursively.
    #     try:
    #         for geo in geometry:
    #             self.flatten_to_paths(geometry=geo, reset=False)
    #
    #     # ## Not iterable, do the actual indexing and add.
    #     except TypeError:
    #         if type(geometry) == Polygon:
    #             g = geometry.exterior
    #             self.flat_geometry.append(g)
    #
    #             # ## Add first and last points of the path to the index.
    #             self.flat_geometry_rtree.insert(len(self.flat_geometry) - 1, g.coords[0])
    #             self.flat_geometry_rtree.insert(len(self.flat_geometry) - 1, g.coords[-1])
    #
    #             for interior in geometry.interiors:
    #                 g = interior
    #                 self.flat_geometry.append(g)
    #                 self.flat_geometry_rtree.insert(len(self.flat_geometry) - 1, g.coords[0])
    #                 self.flat_geometry_rtree.insert(len(self.flat_geometry) - 1, g.coords[-1])
    #         else:
    #             g = geometry
    #             self.flat_geometry.append(g)
    #             self.flat_geometry_rtree.insert(len(self.flat_geometry) - 1, g.coords[0])
    #             self.flat_geometry_rtree.insert(len(self.flat_geometry) - 1, g.coords[-1])
    #
    #     return self.flat_geometry, self.flat_geometry_rtree

    def isolation_geometry(self, offset, geometry=None, iso_type=2, corner=None, follow=None, passes=0,
                           prog_plot=False):
        """
        Creates contours around geometry at a given
        offset distance.

        :param offset:      Offset distance.
        :type offset:       float
        :param geometry     The geometry to work with
        :param iso_type:    type of isolation, can be 0 = exteriors or 1 = interiors or 2 = both (complete)
        :param corner:      type of corner for the isolation:
                            0 = round; 1 = square; 2= beveled (line that connects the ends)
        :param follow:      whether the geometry to be isolated is a follow_geometry
        :param passes:      current pass out of possible multiple passes for which the isolation is done
        :param prog_plot:   type of plotting: "normal" or "progressive"
        :return:            The buffered geometry.
        :rtype:             Shapely.MultiPolygon or Shapely.Polygon
        """

        if self.app.abort_flag:
            # graceful abort requested by the user
            raise grace

        geo_iso = []

        if follow:
            return geometry

        if geometry:
            working_geo = geometry
        else:
            working_geo = self.solid_geometry

        try:
            geo_len = len(working_geo)
        except TypeError:
            geo_len = 1

        old_disp_number = 0
        pol_nr = 0
        # yet, it can be done by issuing an unary_union in the end, thus getting rid of the overlapping geo
        try:
            for pol in working_geo:
                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace
                if offset == 0:
                    temp_geo = pol
                else:
                    corner_type = 1 if corner is None else corner
                    temp_geo = pol.buffer(offset, int(self.geo_steps_per_circle), join_style=corner_type)

                geo_iso.append(temp_geo)

                pol_nr += 1

                # activity view update
                disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))

                if old_disp_number < disp_number <= 100:
                    self.app.proc_container.update_view_text(' %s %d: %d%%' %
                                                             (_("Pass"), int(passes + 1), int(disp_number)))
                    old_disp_number = disp_number
        except TypeError:
            # taking care of the case when the self.solid_geometry is just a single Polygon, not a list or a
            # MultiPolygon (not an iterable)
            if offset == 0:
                temp_geo = working_geo
            else:
                corner_type = 1 if corner is None else corner
                temp_geo = working_geo.buffer(offset, int(self.geo_steps_per_circle), join_style=corner_type)

            geo_iso.append(temp_geo)

        self.app.proc_container.update_view_text(' %s' % _("Buffering"))
        geo_iso = unary_union(geo_iso)

        self.app.proc_container.update_view_text('')
        # end of replaced block

        if iso_type == 2:
            ret_geo = geo_iso
        elif iso_type == 0:
            self.app.proc_container.update_view_text(' %s' % _("Get Exteriors"))
            ret_geo = self.get_exteriors(geo_iso)
        elif iso_type == 1:
            self.app.proc_container.update_view_text(' %s' % _("Get Interiors"))
            ret_geo =  self.get_interiors(geo_iso)
        else:
            log.debug("Geometry.isolation_geometry() --> Type of isolation not supported")
            return "fail"

        if prog_plot == 'progressive':
            for elem in ret_geo:
                self.plot_temp_shapes(elem)

        return ret_geo

    def flatten_list(self, obj_list):
        for item in obj_list:
            if isinstance(item, Iterable) and not isinstance(item, (str, bytes)):
                yield from self.flatten_list(item)
            else:
                yield item

    def import_svg(self, filename, object_type=None, flip=True, units=None):
        """
        Imports shapes from an SVG file into the object's geometry.

        :param filename:    Path to the SVG file.
        :type filename:     str
        :param object_type: parameter passed further along
        :param flip:        Flip the vertically.
        :type flip:         bool
        :param units:       FlatCAM units
        :return:            None
        """

        log.debug("camlib.Geometry.import_svg()")

        # Parse into list of shapely objects
        svg_tree = ET.parse(filename)
        svg_root = svg_tree.getroot()

        # Change origin to bottom left
        # h = float(svg_root.get('height'))
        # w = float(svg_root.get('width'))
        h = svgparselength(svg_root.get('height'))[0]  # TODO: No units support yet

        units = self.app.defaults['units'] if units is None else units
        res = self.app.defaults['geometry_circle_steps']
        factor = svgparse_viewbox(svg_root)

        geos = getsvggeo(svg_root, object_type, units=units, res=res, factor=factor)
        if flip:
            geos = [translate(scale(g, 1.0, -1.0, origin=(0, 0)), yoff=h) for g in geos]

        # trying to optimize the resulting geometry by merging contiguous lines
        geos = list(self.flatten_list(geos))
        geos_polys = []
        geos_lines = []
        for g in geos:
            if isinstance(g, Polygon):
                geos_polys.append(g)
            else:
                geos_lines.append(g)

        merged_lines = linemerge(geos_lines)
        geos = geos_polys
        try:
            for l in merged_lines:
                geos.append(l)
        except TypeError:
            geos.append(merged_lines)
            
        # Add to object
        if self.solid_geometry is None:
            self.solid_geometry = []

        if type(self.solid_geometry) is list:
            if type(geos) is list:
                self.solid_geometry += geos
            else:
                self.solid_geometry.append(geos)
        else:  # It's shapely geometry
            self.solid_geometry = [self.solid_geometry, geos]

        # flatten the self.solid_geometry list for import_svg() to import SVG as Gerber
        self.solid_geometry = list(self.flatten_list(self.solid_geometry))

        geos_text = getsvgtext(svg_root, object_type, units=units)
        if geos_text is not None:
            geos_text_f = []
            if flip:
                # Change origin to bottom left
                for i in geos_text:
                    __, minimy, __, maximy = i.bounds
                    h2 = (maximy - minimy) * 0.5
                    geos_text_f.append(translate(scale(i, 1.0, -1.0, origin=(0, 0)), yoff=(h + h2)))
            if geos_text_f:
                self.solid_geometry = self.solid_geometry + geos_text_f

        tooldia = float(self.app.defaults["geometry_cnctooldia"])
        tooldia = float('%.*f' % (self.decimals, tooldia))

        new_data = {k: v for k, v in self.options.items()}

        self.tools.update({
            1: {
                'tooldia': tooldia,
                'offset': 'Path',
                'offset_value': 0.0,
                'type': 'Rough',
                'tool_type': 'C1',
                'data': deepcopy(new_data),
                'solid_geometry': self.solid_geometry
            }
        })

        self.tools[1]['data']['name'] = self.options['name']

    def import_dxf_as_geo(self, filename, units='MM'):
        """
        Imports shapes from an DXF file into the object's geometry.

        :param filename:    Path to the DXF file.
        :type filename:     str
        :param units:       Application units
        :return: None
        """
        log.debug("Parsing DXF file geometry into a Geometry object solid geometry.")

        # Parse into list of shapely objects
        dxf = ezdxf.readfile(filename)
        geos = getdxfgeo(dxf)

        # trying to optimize the resulting geometry by merging contiguous lines
        geos = list(self.flatten_list(geos))
        geos_polys = []
        geos_lines = []
        for g in geos:
            if isinstance(g, Polygon):
                geos_polys.append(g)
            else:
                geos_lines.append(g)

        merged_lines = linemerge(geos_lines)
        geos = geos_polys
        for l in merged_lines:
            geos.append(l)

        # Add to object
        if self.solid_geometry is None:
            self.solid_geometry = []

        if type(self.solid_geometry) is list:
            if type(geos) is list:
                self.solid_geometry += geos
            else:
                self.solid_geometry.append(geos)
        else:  # It's shapely geometry
            self.solid_geometry = [self.solid_geometry, geos]

        tooldia = float(self.app.defaults["geometry_cnctooldia"])
        tooldia = float('%.*f' % (self.decimals, tooldia))

        new_data = {k: v for k, v in self.options.items()}

        self.tools.update({
            1: {
                'tooldia': tooldia,
                'offset': 'Path',
                'offset_value': 0.0,
                'type': 'Rough',
                'tool_type': 'C1',
                'data': deepcopy(new_data),
                'solid_geometry': self.solid_geometry
            }
        })

        self.tools[1]['data']['name'] = self.options['name']

        # commented until this function is ready
        # geos_text = getdxftext(dxf, object_type, units=units)
        # if geos_text is not None:
        #     geos_text_f = []
        #     self.solid_geometry = [self.solid_geometry, geos_text_f]

    def import_image(self, filename, flip=True, units='MM', dpi=96, mode='black', mask=None):
        """
        Imports shapes from an IMAGE file into the object's geometry.

        :param filename:    Path to the IMAGE file.
        :type filename:     str
        :param flip:        Flip the object vertically.
        :type flip:         bool
        :param units:       FlatCAM units
        :type units:        str
        :param dpi:         dots per inch on the imported image
        :param mode:        how to import the image: as 'black' or 'color'
        :type mode:         str
        :param mask:        level of detail for the import
        :return:            None
        """
        if mask is None:
            mask = [128, 128, 128, 128]

        scale_factor = 25.4 / dpi if units.lower() == 'mm' else 1 / dpi

        geos = []
        unscaled_geos = []

        with rasterio.open(filename) as src:
            # if filename.lower().rpartition('.')[-1] == 'bmp':
            #     red = green = blue = src.read(1)
            #     print("BMP")
            # elif filename.lower().rpartition('.')[-1] == 'png':
            #     red, green, blue, alpha = src.read()
            # elif filename.lower().rpartition('.')[-1] == 'jpg':
            #     red, green, blue = src.read()

            red = green = blue = src.read(1)

            try:
                green = src.read(2)
            except Exception:
                pass

            try:
                blue = src.read(3)
            except Exception:
                pass

        if mode == 'black':
            mask_setting = red <= mask[0]
            total = red
            log.debug("Image import as monochrome.")
        else:
            mask_setting = (red <= mask[1]) + (green <= mask[2]) + (blue <= mask[3])
            total = np.zeros(red.shape, dtype=np.float32)
            for band in red, green, blue:
                total += band
            total /= 3
            log.debug("Image import as colored. Thresholds are: R = %s , G = %s, B = %s" %
                      (str(mask[1]), str(mask[2]), str(mask[3])))

        for geom, val in shapes(total, mask=mask_setting):
            unscaled_geos.append(shape(geom))

        for g in unscaled_geos:
            geos.append(scale(g, scale_factor, scale_factor, origin=(0, 0)))

        if flip:
            geos = [translate(scale(g, 1.0, -1.0, origin=(0, 0))) for g in geos]

        # Add to object
        if self.solid_geometry is None:
            self.solid_geometry = []

        if type(self.solid_geometry) is list:
            # self.solid_geometry.append(unary_union(geos))
            if type(geos) is list:
                self.solid_geometry += geos
            else:
                self.solid_geometry.append(geos)
        else:  # It's shapely geometry
            self.solid_geometry = [self.solid_geometry, geos]

        # flatten the self.solid_geometry list for import_svg() to import SVG as Gerber
        self.solid_geometry = list(self.flatten_list(self.solid_geometry))
        self.solid_geometry = unary_union(self.solid_geometry)

        # self.solid_geometry = MultiPolygon(self.solid_geometry)
        # self.solid_geometry = self.solid_geometry.buffer(0.00000001)
        # self.solid_geometry = self.solid_geometry.buffer(-0.00000001)

    def size(self):
        """
        Returns (width, height) of rectangular
        bounds of geometry.
        """
        if self.solid_geometry is None:
            log.warning("Solid_geometry not computed yet.")
            return 0
        bounds = self.bounds()
        return bounds[2] - bounds[0], bounds[3] - bounds[1]

    def get_empty_area(self, boundary=None):
        """
        Returns the complement of self.solid_geometry within
        the given boundary polygon. If not specified, it defaults to
        the rectangular bounding box of self.solid_geometry.
        """
        if boundary is None:
            boundary = self.solid_geometry.envelope
        return boundary.difference(self.solid_geometry)

    def clear_polygon(self, polygon, tooldia, steps_per_circle, overlap=0.15, connect=True, contour=True,
                      prog_plot=False):
        """
        Creates geometry inside a polygon for a tool to cover
        the whole area.

        This algorithm shrinks the edges of the polygon and takes
        the resulting edges as toolpaths.

        :param polygon:             Polygon to clear.
        :param tooldia:             Diameter of the tool.
        :param steps_per_circle:    number of linear segments to be used to approximate a circle
        :param overlap:             Overlap of toolpasses.
        :param connect:             Draw lines between disjoint segments to
                                    minimize tool lifts.
        :param contour:             Paint around the edges. Inconsequential in
                                    this painting method.
        :param prog_plot:           boolean; if Ture use the progressive plotting
        :return:
        """

        # log.debug("camlib.clear_polygon()")
        assert type(polygon) == Polygon or type(polygon) == MultiPolygon, \
            "Expected a Polygon or MultiPolygon, got %s" % type(polygon)

        # ## The toolpaths
        # Index first and last points in paths
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        geoms = FlatCAMRTreeStorage()
        geoms.get_points = get_pts

        # Can only result in a Polygon or MultiPolygon
        # NOTE: The resulting polygon can be "empty".
        current = polygon.buffer((-tooldia / 1.999999), int(steps_per_circle))
        if current.area == 0:
            # Otherwise, trying to to insert current.exterior == None
            # into the FlatCAMStorage will fail.
            # print("Area is None")
            return None

        # current can be a MultiPolygon
        try:
            for p in current:
                geoms.insert(p.exterior)
                for i in p.interiors:
                    geoms.insert(i)

        # Not a Multipolygon. Must be a Polygon
        except TypeError:
            geoms.insert(current.exterior)
            for i in current.interiors:
                geoms.insert(i)

        while True:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            # provide the app with a way to process the GUI events when in a blocking loop
            QtWidgets.QApplication.processEvents()

            # Can only result in a Polygon or MultiPolygon
            current = current.buffer(-tooldia * (1 - overlap), int(steps_per_circle))
            if current.area > 0:

                # current can be a MultiPolygon
                try:
                    for p in current:
                        geoms.insert(p.exterior)
                        for i in p.interiors:
                            geoms.insert(i)
                            if prog_plot:
                                self.plot_temp_shapes(p)

                # Not a Multipolygon. Must be a Polygon
                except TypeError:
                    geoms.insert(current.exterior)
                    if prog_plot:
                        self.plot_temp_shapes(current.exterior)
                    for i in current.interiors:
                        geoms.insert(i)
                        if prog_plot:
                            self.plot_temp_shapes(i)
            else:
                log.debug("camlib.Geometry.clear_polygon() --> Current Area is zero")
                break

        if prog_plot:
            self.temp_shapes.redraw()

        # Optimization: Reduce lifts
        if connect:
            # log.debug("Reducing tool lifts...")
            geoms = Geometry.paint_connect(geoms, polygon, tooldia, int(steps_per_circle))

        return geoms

    def clear_polygon2(self, polygon_to_clear, tooldia, steps_per_circle, seedpoint=None, overlap=0.15,
                       connect=True, contour=True, prog_plot=False):
        """
        Creates geometry inside a polygon for a tool to cover
        the whole area.

        This algorithm starts with a seed point inside the polygon
        and draws circles around it. Arcs inside the polygons are
        valid cuts. Finalizes by cutting around the inside edge of
        the polygon.

        :param polygon_to_clear:    Shapely.geometry.Polygon
        :param steps_per_circle:    how many linear segments to use to approximate a circle
        :param tooldia:             Diameter of the tool
        :param seedpoint:           Shapely.geometry.Point or None
        :param overlap:             Tool fraction overlap bewteen passes
        :param connect:             Connect disjoint segment to minumize tool lifts
        :param contour:             Cut countour inside the polygon.
        :param prog_plot:           boolean; if True use the progressive plotting
        :return:                    List of toolpaths covering polygon.
        :rtype:                     FlatCAMRTreeStorage | None
        """

        # log.debug("camlib.clear_polygon2()")

        # Current buffer radius
        radius = tooldia / 2 * (1 - overlap)

        # ## The toolpaths
        # Index first and last points in paths
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        geoms = FlatCAMRTreeStorage()
        geoms.get_points = get_pts

        # Path margin
        path_margin = polygon_to_clear.buffer(-tooldia / 2, int(steps_per_circle))

        if path_margin.is_empty or path_margin is None:
            return None

        # Estimate good seedpoint if not provided.
        if seedpoint is None:
            seedpoint = path_margin.representative_point()

        # Grow from seed until outside the box. The polygons will
        # never have an interior, so take the exterior LinearRing.
        while True:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            # provide the app with a way to process the GUI events when in a blocking loop
            QtWidgets.QApplication.processEvents()

            path = Point(seedpoint).buffer(radius, int(steps_per_circle)).exterior
            path = path.intersection(path_margin)

            # Touches polygon?
            if path.is_empty:
                break
            else:
                # geoms.append(path)
                # geoms.insert(path)
                # path can be a collection of paths.
                try:
                    for p in path:
                        geoms.insert(p)
                        if prog_plot:
                            self.plot_temp_shapes(p)
                except TypeError:
                    geoms.insert(path)
                    if prog_plot:
                        self.plot_temp_shapes(path)

                if prog_plot:
                    self.temp_shapes.redraw()

            radius += tooldia * (1 - overlap)

        # Clean inside edges (contours) of the original polygon
        if contour:
            buffered_poly = autolist(polygon_to_clear.buffer(-tooldia / 2, int(steps_per_circle)))
            outer_edges = [x.exterior for x in buffered_poly]

            inner_edges = []
            # Over resulting polygons
            for x in buffered_poly:
                for y in x.interiors:  # Over interiors of each polygon
                    inner_edges.append(y)
            # geoms += outer_edges + inner_edges
            for g in outer_edges + inner_edges:
                if g and not g.is_empty:
                    geoms.insert(g)
                    if prog_plot:
                        self.plot_temp_shapes(g)

        if prog_plot:
            self.temp_shapes.redraw()

        # Optimization connect touching paths
        # log.debug("Connecting paths...")
        # geoms = Geometry.path_connect(geoms)

        # Optimization: Reduce lifts
        if connect:
            # log.debug("Reducing tool lifts...")
            geoms_conn = Geometry.paint_connect(geoms, polygon_to_clear, tooldia, steps_per_circle)
            if geoms_conn:
                return geoms_conn

        return geoms

    def clear_polygon3(self, polygon, tooldia, steps_per_circle, overlap=0.15, connect=True, contour=True,
                       prog_plot=False):
        """
        Creates geometry inside a polygon for a tool to cover
        the whole area.

        This algorithm draws horizontal lines inside the polygon.

        :param polygon:             The polygon being painted.
        :type polygon:              shapely.geometry.Polygon
        :param tooldia:             Tool diameter.
        :param steps_per_circle:    how many linear segments to use to approximate a circle
        :param overlap:             Tool path overlap percentage.
        :param connect:             Connect lines to avoid tool lifts.
        :param contour:             Paint around the edges.
        :param prog_plot:           boolean; if to use the progressive plotting
        :return:
        """

        # log.debug("camlib.clear_polygon3()")
        if not isinstance(polygon, Polygon):
            log.debug("camlib.Geometry.clear_polygon3() --> Not a Polygon but %s" % str(type(polygon)))
            return None

        # ## The toolpaths
        # Index first and last points in paths
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        geoms = FlatCAMRTreeStorage()
        geoms.get_points = get_pts

        lines_trimmed = []

        # Bounding box
        left, bot, right, top = polygon.bounds

        try:
            margin_poly = polygon.buffer(-tooldia / 1.99999999, (int(steps_per_circle)))
        except Exception:
            log.debug("camlib.Geometry.clear_polygon3() --> Could not buffer the Polygon")
            return None

        # decide the direction of the lines
        if abs(left - right) >= abs(top - bot):
            # First line
            try:
                y = top - tooldia / 1.99999999
                while y > bot + tooldia / 1.999999999:
                    if self.app.abort_flag:
                        # graceful abort requested by the user
                        raise grace

                    # provide the app with a way to process the GUI events when in a blocking loop
                    QtWidgets.QApplication.processEvents()

                    line = LineString([(left, y), (right, y)])
                    line = line.intersection(margin_poly)
                    lines_trimmed.append(line)
                    y -= tooldia * (1 - overlap)
                    if prog_plot:
                        self.plot_temp_shapes(line)
                        self.temp_shapes.redraw()

                # Last line
                y = bot + tooldia / 2
                line = LineString([(left, y), (right, y)])
                line = line.intersection(margin_poly)

                try:
                    for ll in line:
                        lines_trimmed.append(ll)
                        if prog_plot:
                            self.plot_temp_shapes(ll)
                except TypeError:
                    lines_trimmed.append(line)
                    if prog_plot:
                        self.plot_temp_shapes(line)
            except Exception as e:
                log.debug('camlib.Geometry.clear_polygon3() Processing poly --> %s' % str(e))
                return None
        else:
            # First line
            try:
                x = left + tooldia / 1.99999999
                while x < right - tooldia / 1.999999999:
                    if self.app.abort_flag:
                        # graceful abort requested by the user
                        raise grace

                    # provide the app with a way to process the GUI events when in a blocking loop
                    QtWidgets.QApplication.processEvents()

                    line = LineString([(x, top), (x, bot)])
                    line = line.intersection(margin_poly)
                    lines_trimmed.append(line)
                    x += tooldia * (1 - overlap)
                    if prog_plot:
                        self.plot_temp_shapes(line)
                        self.temp_shapes.redraw()

                # Last line
                x = right + tooldia / 2
                line = LineString([(x, top), (x, bot)])
                line = line.intersection(margin_poly)

                try:
                    for ll in line:
                        lines_trimmed.append(ll)
                        if prog_plot:
                            self.plot_temp_shapes(ll)
                except TypeError:
                    lines_trimmed.append(line)
                    if prog_plot:
                        self.plot_temp_shapes(line)
            except Exception as e:
                log.debug('camlib.Geometry.clear_polygon3() Processing poly --> %s' % str(e))
                return None

        if prog_plot:
            self.temp_shapes.redraw()

        lines_trimmed = unary_union(lines_trimmed)

        # Add lines to storage
        try:
            for line in lines_trimmed:
                if isinstance(line, LineString) or isinstance(line, LinearRing):
                    if not line.is_empty:
                        geoms.insert(line)
                else:
                    log.debug("camlib.Geometry.clear_polygon3(). Not a line: %s" % str(type(line)))
        except TypeError:
            # in case lines_trimmed are not iterable (Linestring, LinearRing)
            if not lines_trimmed.is_empty:
                geoms.insert(lines_trimmed)

        # Add margin (contour) to storage
        if contour:
            try:
                for poly in margin_poly:
                    if isinstance(poly, Polygon) and not poly.is_empty:
                        geoms.insert(poly.exterior)
                        if prog_plot:
                            self.plot_temp_shapes(poly.exterior)
                        for ints in poly.interiors:
                            geoms.insert(ints)
                            if prog_plot:
                                self.plot_temp_shapes(ints)
            except TypeError:
                if isinstance(margin_poly, Polygon) and not margin_poly.is_empty:
                    marg_ext = margin_poly.exterior
                    geoms.insert(marg_ext)
                    if prog_plot:
                        self.plot_temp_shapes(margin_poly.exterior)
                    for ints in margin_poly.interiors:
                        geoms.insert(ints)
                        if prog_plot:
                            self.plot_temp_shapes(ints)

        if prog_plot:
            self.temp_shapes.redraw()

        # Optimization: Reduce lifts
        if connect:
            # log.debug("Reducing tool lifts...")
            geoms_conn = Geometry.paint_connect(geoms, polygon, tooldia, steps_per_circle)
            if geoms_conn:
                return geoms_conn

        return geoms

    def fill_with_lines(self, line, aperture_size, tooldia, steps_per_circle, overlap=0.15, connect=True, contour=True,
                        prog_plot=False):
        """
        Creates geometry of lines inside a polygon for a tool to cover
        the whole area.

        This algorithm draws parallel lines inside the polygon.

        :param line:                The target line that create painted polygon.
        :param aperture_size:       the size of the aperture that is used to draw the 'line' as a polygon
        :type line:                 shapely.geometry.LineString or shapely.geometry.MultiLineString
        :param tooldia:             Tool diameter.
        :param steps_per_circle:    how many linear segments to use to approximate a circle
        :param overlap:             Tool path overlap percentage.
        :param connect:             Connect lines to avoid tool lifts.
        :param contour:             Paint around the edges.
        :param prog_plot:           boolean; if to use the progressive plotting
        :return:
        """

        # log.debug("camlib.fill_with_lines()")
        if not isinstance(line, LineString):
            log.debug("camlib.Geometry.fill_with_lines() --> Not a LineString/MultiLineString but %s" % str(type(line)))
            return None

        # ## The toolpaths
        # Index first and last points in paths
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        geoms = FlatCAMRTreeStorage()
        geoms.get_points = get_pts

        lines_trimmed = []

        polygon = line.buffer(aperture_size / 2.0, int(steps_per_circle))

        try:
            margin_poly = polygon.buffer(-tooldia / 2.0, int(steps_per_circle))
        except Exception:
            log.debug("camlib.Geometry.fill_with_lines() --> Could not buffer the Polygon, tool diameter too high")
            return None

        # First line
        try:
            delta = 0
            while delta < aperture_size / 2:
                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace

                # provide the app with a way to process the GUI events when in a blocking loop
                QtWidgets.QApplication.processEvents()

                new_line = line.parallel_offset(distance=delta, side='left', resolution=int(steps_per_circle))
                new_line = new_line.intersection(margin_poly)
                lines_trimmed.append(new_line)

                new_line = line.parallel_offset(distance=delta, side='right', resolution=int(steps_per_circle))
                new_line = new_line.intersection(margin_poly)
                lines_trimmed.append(new_line)

                delta += tooldia * (1 - overlap)
                if prog_plot:
                    self.plot_temp_shapes(new_line)
                    self.temp_shapes.redraw()

            # Last line
            delta = (aperture_size / 2) - (tooldia / 2.00000001)

            new_line = line.parallel_offset(distance=delta, side='left', resolution=int(steps_per_circle))
            new_line = new_line.intersection(margin_poly)
        except Exception as e:
            log.debug('camlib.Geometry.fill_with_lines() Processing poly --> %s' % str(e))
            return None

        try:
            for ll in new_line:
                lines_trimmed.append(ll)
                if prog_plot:
                    self.plot_temp_shapes(ll)
        except TypeError:
            lines_trimmed.append(new_line)
            if prog_plot:
                self.plot_temp_shapes(new_line)

        new_line = line.parallel_offset(distance=delta, side='right', resolution=int(steps_per_circle))
        new_line = new_line.intersection(margin_poly)

        try:
            for ll in new_line:
                lines_trimmed.append(ll)
                if prog_plot:
                    self.plot_temp_shapes(ll)
        except TypeError:
            lines_trimmed.append(new_line)
            if prog_plot:
                self.plot_temp_shapes(new_line)

        if prog_plot:
            self.temp_shapes.redraw()

        lines_trimmed = unary_union(lines_trimmed)

        # Add lines to storage
        try:
            for line in lines_trimmed:
                if isinstance(line, LineString) or isinstance(line, LinearRing):
                    geoms.insert(line)
                else:
                    log.debug("camlib.Geometry.fill_with_lines(). Not a line: %s" % str(type(line)))
        except TypeError:
            # in case lines_trimmed are not iterable (Linestring, LinearRing)
            geoms.insert(lines_trimmed)

        # Add margin (contour) to storage
        if contour:
            try:
                for poly in margin_poly:
                    if isinstance(poly, Polygon) and not poly.is_empty:
                        geoms.insert(poly.exterior)
                        if prog_plot:
                            self.plot_temp_shapes(poly.exterior)
                        for ints in poly.interiors:
                            geoms.insert(ints)
                            if prog_plot:
                                self.plot_temp_shapes(ints)
            except TypeError:
                if isinstance(margin_poly, Polygon) and not margin_poly.is_empty:
                    marg_ext = margin_poly.exterior
                    geoms.insert(marg_ext)
                    if prog_plot:
                        self.plot_temp_shapes(margin_poly.exterior)
                    for ints in margin_poly.interiors:
                        geoms.insert(ints)
                        if prog_plot:
                            self.plot_temp_shapes(ints)

        if prog_plot:
            self.temp_shapes.redraw()

        # Optimization: Reduce lifts
        if connect:
            # log.debug("Reducing tool lifts...")
            geoms_conn = Geometry.paint_connect(geoms, polygon, tooldia, steps_per_circle)
            if geoms_conn:
                return geoms_conn

        return geoms

    def scale(self, xfactor, yfactor, point=None):
        """
        Scales all of the object's geometry by a given factor. Override
        this method.
        :param xfactor: Number by which to scale on X axis.
        :type xfactor: float
        :param yfactor: Number by which to scale on Y axis.
        :type yfactor: float
        :param point: point to be used as reference for scaling; a tuple
        :return: None
        :rtype: None
        """
        return

    def offset(self, vect):
        """
        Offset the geometry by the given vector. Override this method.

        :param vect: (x, y) vector by which to offset the object.
        :type vect: tuple
        :return: None
        """
        return

    @staticmethod
    def paint_connect(storage, boundary, tooldia, steps_per_circle, max_walk=None):
        """
        Connects paths that results in a connection segment that is
        within the paint area. This avoids unnecessary tool lifting.

        :param storage: Geometry to be optimized.
        :type storage: FlatCAMRTreeStorage
        :param boundary: Polygon defining the limits of the paintable area.
        :type boundary: Polygon
        :param tooldia: Tool diameter.
        :rtype tooldia: float
        :param steps_per_circle: how many linear segments to use to approximate a circle
        :param max_walk: Maximum allowable distance without lifting tool.
        :type max_walk: float or None
        :return: Optimized geometry.
        :rtype: FlatCAMRTreeStorage
        """

        # If max_walk is not specified, the maximum allowed is
        # 10 times the tool diameter
        max_walk = max_walk or 10 * tooldia

        # Assuming geolist is a flat list of flat elements

        # ## Index first and last points in paths
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        # storage = FlatCAMRTreeStorage()
        # storage.get_points = get_pts
        #
        # for shape in geolist:
        #     if shape is not None:
        #         # Make LlinearRings into linestrings otherwise
        #         # When chaining the coordinates path is messed up.
        #         storage.insert(LineString(shape))
        #         #storage.insert(shape)

        # ## Iterate over geometry paths getting the nearest each time.
        # optimized_paths = []
        optimized_paths = FlatCAMRTreeStorage()
        optimized_paths.get_points = get_pts
        path_count = 0
        current_pt = (0, 0)
        try:
            pt, geo = storage.nearest(current_pt)
        except StopIteration:
            log.debug("camlib.Geometry.paint_connect(). Storage empty")
            return None

        storage.remove(geo)

        geo = LineString(geo)
        current_pt = geo.coords[-1]
        try:
            while True:
                path_count += 1
                # log.debug("Path %d" % path_count)

                pt, candidate = storage.nearest(current_pt)
                storage.remove(candidate)

                candidate = LineString(candidate)

                # If last point in geometry is the nearest
                # then reverse coordinates.
                # but prefer the first one if last == first
                if pt != candidate.coords[0] and pt == candidate.coords[-1]:
                    # in place coordinates update deprecated in Shapely 2.0
                    # candidate.coords = list(candidate.coords)[::-1]
                    candidate = LineString(list(candidate.coords)[::-1])

                # Straight line from current_pt to pt.
                # Is the toolpath inside the geometry?
                walk_path = LineString([current_pt, pt])
                walk_cut = walk_path.buffer(tooldia / 2, int(steps_per_circle))

                if walk_cut.within(boundary) and walk_path.length < max_walk:
                    # log.debug("Walk to path #%d is inside. Joining." % path_count)

                    # Completely inside. Append...
                    # in place coordinates update deprecated in Shapely 2.0
                    # geo.coords = list(geo.coords) + list(candidate.coords)
                    geo = LineString(list(geo.coords) + list(candidate.coords))
                    # try:
                    #     last = optimized_paths[-1]
                    #     last.coords = list(last.coords) + list(geo.coords)
                    # except IndexError:
                    #     optimized_paths.append(geo)

                else:

                    # Have to lift tool. End path.
                    # log.debug("Path #%d not within boundary. Next." % path_count)
                    # optimized_paths.append(geo)
                    optimized_paths.insert(geo)
                    geo = candidate

                current_pt = geo.coords[-1]

                # Next
                # pt, geo = storage.nearest(current_pt)

        except StopIteration:  # Nothing left in storage.
            # pass
            optimized_paths.insert(geo)

        return optimized_paths

    @staticmethod
    def path_connect(storage, origin=(0, 0)):
        """
        Simplifies paths in the FlatCAMRTreeStorage storage by
        connecting paths that touch on their endpoints.

        :param storage:     Storage containing the initial paths.
        :rtype storage:     FlatCAMRTreeStorage
        :param origin:      tuple; point from which to calculate the nearest point
        :return:            Simplified storage.
        :rtype:             FlatCAMRTreeStorage
        """

        log.debug("path_connect()")

        # ## Index first and last points in paths
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        #
        # storage = FlatCAMRTreeStorage()
        # storage.get_points = get_pts
        #
        # for shape in pathlist:
        #     if shape is not None:
        #         storage.insert(shape)

        path_count = 0
        pt, geo = storage.nearest(origin)
        storage.remove(geo)
        # optimized_geometry = [geo]
        optimized_geometry = FlatCAMRTreeStorage()
        optimized_geometry.get_points = get_pts
        # optimized_geometry.insert(geo)
        try:
            while True:
                path_count += 1
                _, left = storage.nearest(geo.coords[0])

                # If left touches geo, remove left from original
                # storage and append to geo.
                if type(left) == LineString:
                    if left.coords[0] == geo.coords[0]:
                        storage.remove(left)
                        # geo.coords = list(geo.coords)[::-1] + list(left.coords)   # Shapely 2.0
                        geo = LineString(list(geo.coords)[::-1] + list(left.coords))
                        continue

                    if left.coords[-1] == geo.coords[0]:
                        storage.remove(left)
                        # geo.coords = list(left.coords) + list(geo.coords)  # Shapely 2.0
                        geo = LineString(list(geo.coords)[::-1] + list(left.coords))
                        continue

                    if left.coords[0] == geo.coords[-1]:
                        storage.remove(left)
                        # geo.coords = list(geo.coords) + list(left.coords) # Shapely 2.0
                        geo = LineString(list(geo.coords) + list(left.coords))
                        continue

                    if left.coords[-1] == geo.coords[-1]:
                        storage.remove(left)
                        # geo.coords = list(geo.coords) + list(left.coords)[::-1] # Shapely 2.0
                        geo = LineString(list(geo.coords) + list(left.coords)[::-1])
                        continue

                _, right = storage.nearest(geo.coords[-1])

                # If right touches geo, remove left from original
                # storage and append to geo.
                if type(right) == LineString:
                    if right.coords[0] == geo.coords[-1]:
                        storage.remove(right)
                        # geo.coords = list(geo.coords) + list(right.coords)  # Shapely 2.0
                        geo = LineString(list(geo.coords) + list(right.coords))
                        continue

                    if right.coords[-1] == geo.coords[-1]:
                        storage.remove(right)
                        # geo.coords = list(geo.coords) + list(right.coords)[::-1]    # Shapely 2.0
                        geo = LineString(list(geo.coords) + list(right.coords)[::-1])
                        continue

                    if right.coords[0] == geo.coords[0]:
                        storage.remove(right)
                        # geo.coords = list(geo.coords)[::-1] + list(right.coords)    # Shapely 2.0
                        geo = LineString(list(geo.coords)[::-1] + list(right.coords))
                        continue

                    if right.coords[-1] == geo.coords[0]:
                        storage.remove(right)
                        # geo.coords = list(left.coords) + list(geo.coords)   # Shapely 2.0
                        geo = LineString(list(left.coords) + list(geo.coords))
                        continue

                # right is either a LinearRing or it does not connect
                # to geo (nothing left to connect to geo), so we continue
                # with right as geo.
                storage.remove(right)

                if type(right) == LinearRing:
                    optimized_geometry.insert(right)
                else:
                    # Cannot extend geo any further. Put it away.
                    optimized_geometry.insert(geo)

                    # Continue with right.
                    geo = right

        except StopIteration:  # Nothing found in storage.
            optimized_geometry.insert(geo)

        # print path_count
        log.debug("path_count = %d" % path_count)

        return optimized_geometry

    def convert_units(self, obj_units):
        """
        Converts the units of the object to ``units`` by scaling all
        the geometry appropriately. This call ``scale()``. Don't call
        it again in descendents.

        :param obj_units:   "IN" or "MM"
        :type obj_units:    str
        :return:            Scaling factor resulting from unit change.
        :rtype:             float
        """

        if obj_units.upper() == self.units.upper():
            log.debug("camlib.Geometry.convert_units() --> Factor: 1")
            return 1.0

        if obj_units.upper() == "MM":
            factor = 25.4
            log.debug("camlib.Geometry.convert_units() --> Factor: 25.4")
        elif obj_units.upper() == "IN":
            factor = 1 / 25.4
            log.debug("camlib.Geometry.convert_units() --> Factor: %s" % str(1 / 25.4))
        else:
            log.error("Unsupported units: %s" % str(obj_units))
            log.debug("camlib.Geometry.convert_units() --> Factor: 1")
            return 1.0

        self.units = obj_units
        self.scale(factor, factor)
        self.file_units_factor = factor
        return factor

    def to_dict(self):
        """
        Returns a representation of the object as a dictionary.
        Attributes to include are listed in ``self.ser_attrs``.

        :return:    A dictionary-encoded copy of the object.
        :rtype:     dict
        """
        d = {}
        for attr in self.ser_attrs:
            d[attr] = getattr(self, attr)
        return d

    def from_dict(self, d):
        """
        Sets object's attributes from a dictionary.
        Attributes to include are listed in ``self.ser_attrs``.
        This method will look only for only and all the
        attributes in ``self.ser_attrs``. They must all
        be present. Use only for deserializing saved
        objects.

        :param d:   Dictionary of attributes to set in the object.
        :type d:    dict
        :return:    None
        """
        for attr in self.ser_attrs:
            setattr(self, attr, d[attr])

    def union(self):
        """
        Runs a unary_union on the list of objects in
        solid_geometry.

        :return: None
        """
        self.solid_geometry = [unary_union(self.solid_geometry)]

    def export_svg(self, scale_stroke_factor=0.00,
                   scale_factor_x=None, scale_factor_y=None,
                   skew_factor_x=None, skew_factor_y=None,
                   skew_reference='center', scale_reference='center',
                   mirror=None):
        """
        Exports the Geometry Object as a SVG Element

        :return: SVG Element
        """

        # Make sure we see a Shapely Geometry class and not a list
        if self.kind.lower() == 'geometry':
            flat_geo = []
            if self.multigeo:
                for tool in self.tools:
                    flat_geo += self.flatten(self.tools[tool]['solid_geometry'])
                geom_svg = unary_union(flat_geo)
            else:
                geom_svg = unary_union(self.flatten())
        else:
            geom_svg = unary_union(self.flatten())

        skew_ref = 'center'
        if skew_reference != 'center':
            xmin, ymin, xmax, ymax = geom_svg.bounds
            if skew_reference == 'topleft':
                skew_ref = (xmin, ymax)
            elif skew_reference == 'bottomleft':
                skew_ref = (xmin, ymin)
            elif skew_reference == 'topright':
                skew_ref = (xmax, ymax)
            elif skew_reference == 'bottomright':
                skew_ref = (xmax, ymin)

        geom = geom_svg

        if scale_factor_x and not scale_factor_y:
            geom = affinity.scale(geom_svg, scale_factor_x, 1.0, origin=scale_reference)
        elif not scale_factor_x and scale_factor_y:
            geom = affinity.scale(geom_svg, 1.0, scale_factor_y, origin=scale_reference)
        elif scale_factor_x and scale_factor_y:
            geom = affinity.scale(geom_svg, scale_factor_x, scale_factor_y, origin=scale_reference)

        if skew_factor_x and not skew_factor_y:
            geom = affinity.skew(geom_svg, skew_factor_x, 0.0, origin=skew_ref)
        elif not skew_factor_x and skew_factor_y:
            geom = affinity.skew(geom_svg, 0.0, skew_factor_y, origin=skew_ref)
        elif skew_factor_x and skew_factor_y:
            geom = affinity.skew(geom_svg, skew_factor_x, skew_factor_y, origin=skew_ref)

        if mirror:
            if mirror == 'x':
                geom = affinity.scale(geom_svg, 1.0, -1.0)
            if mirror == 'y':
                geom = affinity.scale(geom_svg, -1.0, 1.0)
            if mirror == 'both':
                geom = affinity.scale(geom_svg, -1.0, -1.0)

        # scale_factor is a multiplication factor for the SVG stroke-width used within shapely's svg export
        # If 0 or less which is invalid then default to 0.01
        # This value appears to work for zooming, and getting the output svg line width
        # to match that viewed on screen with FlatCam
        # MS: I choose a factor of 0.01 so the scale is right for PCB UV film
        if scale_stroke_factor <= 0:
            scale_stroke_factor = 0.01

        # Convert to a SVG
        svg_elem = geom.svg(scale_factor=scale_stroke_factor)
        return svg_elem

    def mirror(self, axis, point):
        """
        Mirrors the object around a specified axis passign through
        the given point.

        :param axis:    "X" or "Y" indicates around which axis to mirror.
        :type axis:     str
        :param point:   [x, y] point belonging to the mirror axis.
        :type point:    list
        :return:        None
        """
        log.debug("camlib.Geometry.mirror()")

        px, py = point
        xscale, yscale = {"X": (1.0, -1.0), "Y": (-1.0, 1.0)}[axis]

        def mirror_geom(obj):
            if type(obj) is list:
                new_obj = []
                for g in obj:
                    new_obj.append(mirror_geom(g))
                return new_obj
            else:
                try:
                    self.el_count += 1
                    disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
                    if self.old_disp_number < disp_number <= 100:
                        self.app.proc_container.update_view_text(' %d%%' % disp_number)
                        self.old_disp_number = disp_number

                    return affinity.scale(obj, xscale, yscale, origin=(px, py))
                except AttributeError:
                    return obj

        try:
            if self.multigeo is True:
                for tool in self.tools:
                    # variables to display the percentage of work done
                    self.geo_len = 0
                    try:
                        self.geo_len = len(self.tools[tool]['solid_geometry'])
                    except TypeError:
                        self.geo_len = 1
                    self.old_disp_number = 0
                    self.el_count = 0

                    self.tools[tool]['solid_geometry'] = mirror_geom(self.tools[tool]['solid_geometry'])
            else:
                # variables to display the percentage of work done
                self.geo_len = 0
                try:
                    self.geo_len = len(self.solid_geometry)
                except TypeError:
                    self.geo_len = 1
                self.old_disp_number = 0
                self.el_count = 0

                self.solid_geometry = mirror_geom(self.solid_geometry)
            self.app.inform.emit('[success] %s...' % _('Object was mirrored'))
        except AttributeError:
            self.app.inform.emit('[ERROR_NOTCL] %s' % _("Failed to mirror. No object selected"))

        self.app.proc_container.new_text = ''

    def rotate(self, angle, point):
        """
        Rotate an object by an angle (in degrees) around the provided coordinates.

        :param angle:
        The angle of rotation are specified in degrees (default). Positive angles are
        counter-clockwise and negative are clockwise rotations.

        :param point:
        The point of origin can be a keyword 'center' for the bounding box
        center (default), 'centroid' for the geometry's centroid, a Point object
        or a coordinate tuple (x0, y0).

        See shapely manual for more information: http://toblerity.org/shapely/manual.html#affine-transformations
        """
        log.debug("camlib.Geometry.rotate()")

        px, py = point

        def rotate_geom(obj):
            try:
                new_obj = []
                for g in obj:
                    new_obj.append(rotate_geom(g))
                return new_obj
            except TypeError:
                try:
                    self.el_count += 1
                    disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
                    if self.old_disp_number < disp_number <= 100:
                        self.app.proc_container.update_view_text(' %d%%' % disp_number)
                        self.old_disp_number = disp_number

                    return affinity.rotate(obj, angle, origin=(px, py))
                except AttributeError:
                    return obj

        try:
            if self.multigeo is True:
                for tool in self.tools:
                    # variables to display the percentage of work done
                    self.geo_len = 0
                    try:
                        self.geo_len = len(self.tools[tool]['solid_geometry'])
                    except TypeError:
                        self.geo_len = 1
                    self.old_disp_number = 0
                    self.el_count = 0

                    self.tools[tool]['solid_geometry'] = rotate_geom(self.tools[tool]['solid_geometry'])
            else:
                # variables to display the percentage of work done
                self.geo_len = 0
                try:
                    self.geo_len = len(self.solid_geometry)
                except TypeError:
                    self.geo_len = 1
                self.old_disp_number = 0
                self.el_count = 0

                self.solid_geometry = rotate_geom(self.solid_geometry)
            self.app.inform.emit('[success] %s...' % _('Object was rotated'))
        except AttributeError:
            self.app.inform.emit('[ERROR_NOTCL] %s' % _("Failed to rotate. No object selected"))

        self.app.proc_container.new_text = ''

    def skew(self, angle_x, angle_y, point):
        """
        Shear/Skew the geometries of an object by angles along x and y dimensions.

        :param angle_x:
        :param angle_y:
        angle_x, angle_y : float, float
            The shear angle(s) for the x and y axes respectively. These can be
            specified in either degrees (default) or radians by setting
            use_radians=True.

        :param point:   Origin point for Skew
        point: tuple of coordinates (x,y)

        See shapely manual for more information: http://toblerity.org/shapely/manual.html#affine-transformations
        """
        log.debug("camlib.Geometry.skew()")

        px, py = point

        def skew_geom(obj):
            try:
                new_obj = []
                for g in obj:
                    new_obj.append(skew_geom(g))
                return new_obj
            except TypeError:
                try:
                    self.el_count += 1
                    disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
                    if self.old_disp_number < disp_number <= 100:
                        self.app.proc_container.update_view_text(' %d%%' % disp_number)
                        self.old_disp_number = disp_number

                    return affinity.skew(obj, angle_x, angle_y, origin=(px, py))
                except AttributeError:
                    return obj

        try:
            if self.multigeo is True:
                for tool in self.tools:
                    # variables to display the percentage of work done
                    self.geo_len = 0
                    try:
                        self.geo_len = len(self.tools[tool]['solid_geometry'])
                    except TypeError:
                        self.geo_len = 1
                    self.old_disp_number = 0
                    self.el_count = 0

                    self.tools[tool]['solid_geometry'] = skew_geom(self.tools[tool]['solid_geometry'])
            else:
                # variables to display the percentage of work done
                self.geo_len = 0
                try:
                    self.geo_len = len(self.solid_geometry)
                except TypeError:
                    self.geo_len = 1
                self.old_disp_number = 0
                self.el_count = 0

                self.solid_geometry = skew_geom(self.solid_geometry)
            self.app.inform.emit('[success] %s...' % _('Object was skewed'))
        except AttributeError:
            self.app.inform.emit('[ERROR_NOTCL] %s' % _("Failed to skew. No object selected"))

        self.app.proc_container.new_text = ''

        # if type(self.solid_geometry) == list:
        #     self.solid_geometry = [affinity.skew(g, angle_x, angle_y, origin=(px, py))
        #                            for g in self.solid_geometry]
        # else:
        #     self.solid_geometry = affinity.skew(self.solid_geometry, angle_x, angle_y,
        #                                         origin=(px, py))

    def buffer(self, distance, join, factor):
        """

        :param distance:    if 'factor' is True then distance is the factor
        :param join:        The kind of join used by the shapely buffer method: round, square or bevel
        :param factor:      True or False (None)
        :return:
        """

        log.debug("camlib.Geometry.buffer()")

        if distance == 0:
            return

        def buffer_geom(obj):
            if type(obj) is list:
                new_obj = []
                for g in obj:
                    new_obj.append(buffer_geom(g))
                return new_obj
            else:
                try:
                    self.el_count += 1
                    disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
                    if self.old_disp_number < disp_number <= 100:
                        self.app.proc_container.update_view_text(' %d%%' % disp_number)
                        self.old_disp_number = disp_number

                    if factor is None:
                        return obj.buffer(distance, resolution=self.geo_steps_per_circle, join_style=join)
                    else:
                        return affinity.scale(obj, xfact=distance, yfact=distance, origin='center')
                except AttributeError:
                    return obj

        try:
            if self.multigeo is True:
                for tool in self.tools:
                    # variables to display the percentage of work done
                    self.geo_len = 0
                    try:
                        self.geo_len += len(self.tools[tool]['solid_geometry'])
                    except TypeError:
                        self.geo_len += 1
                    self.old_disp_number = 0
                    self.el_count = 0

                    res = buffer_geom(self.tools[tool]['solid_geometry'])
                    try:
                        __ = iter(res)
                        self.tools[tool]['solid_geometry'] = res
                    except TypeError:
                        self.tools[tool]['solid_geometry'] = [res]

            # variables to display the percentage of work done
            self.geo_len = 0
            try:
                self.geo_len = len(self.solid_geometry)
            except TypeError:
                self.geo_len = 1
            self.old_disp_number = 0
            self.el_count = 0

            self.solid_geometry = buffer_geom(self.solid_geometry)

            self.app.inform.emit('[success] %s...' % _('Object was buffered'))
        except AttributeError:
            self.app.inform.emit('[ERROR_NOTCL] %s' % _("Failed to buffer. No object selected"))

        self.app.proc_container.new_text = ''


class AttrDict(dict):
    def __init__(self, *args, **kwargs):
        super(AttrDict, self).__init__(*args, **kwargs)
        self.__dict__ = self


class CNCjob(Geometry):
    """
    Represents work to be done by a CNC machine.

    *ATTRIBUTES*

    * ``gcode_parsed`` (list): Each is a dictionary:

    =====================  =========================================
    Key                    Value
    =====================  =========================================
    geom                   (Shapely.LineString) Tool path (XY plane)
    kind                   (string) "AB", A is "T" (travel) or
                           "C" (cut). B is "F" (fast) or "S" (slow).
    =====================  =========================================
    """

    defaults = {
        "global_zdownrate": None,
        "pp_geometry_name": 'default',
        "pp_excellon_name": 'default',
        "excellon_optimization_type": "B",
    }

    settings = QtCore.QSettings("Open Source", "FlatCAM")
    if settings.contains("machinist"):
        machinist_setting = settings.value('machinist', type=int)
    else:
        machinist_setting = 0

    def __init__(self,
                 units="in", kind="generic", tooldia=0.0,
                 z_cut=-0.002, z_move=0.1,
                 feedrate=3.0, feedrate_z=3.0, feedrate_rapid=3.0, feedrate_probe=3.0,
                 pp_geometry_name='default', pp_excellon_name='default',
                 depthpercut=0.1, z_pdepth=-0.02,
                 spindlespeed=None, spindledir='CW', dwell=True, dwelltime=1000,
                 toolchangez=0.787402, toolchange_xy='0.0,0.0',
                 endz=2.0, endxy='',
                 segx=None,
                 segy=None,
                 steps_per_circle=None):

        self.decimals = self.app.decimals

        # Used when parsing G-code arcs
        self.steps_per_circle = steps_per_circle if steps_per_circle is not None else \
            int(self.app.defaults['cncjob_steps_per_circle'])

        Geometry.__init__(self, geo_steps_per_circle=self.steps_per_circle)

        self.kind = kind
        self.units = units

        self.z_cut = z_cut
        self.multidepth = False
        self.z_depthpercut = depthpercut
        self.z_move = z_move

        self.feedrate = feedrate
        self.z_feedrate = feedrate_z
        self.feedrate_rapid = feedrate_rapid

        self.tooldia = tooldia
        self.toolC = tooldia
        self.toolchange = False
        self.z_toolchange = toolchangez
        self.xy_toolchange = toolchange_xy
        self.toolchange_xy_type = None

        self.startz = None
        self.z_end = endz
        self.xy_end = endxy

        self.extracut = False
        self.extracut_length = None

        self.tolerance = self.drawing_tolerance

        # used by the self.generate_from_excellon_by_tool() method
        # but set directly before the actual usage of the method with obj.excellon_optimization_type = value
        self.excellon_optimization_type = 'No'

        # if set True then the GCode generation will use UI; used in Excellon GVode for now
        self.use_ui = False

        self.unitcode = {"IN": "G20", "MM": "G21"}

        self.feedminutecode = "G94"
        # self.absolutecode = "G90"
        # self.incrementalcode = "G91"
        self.coordinates_type = self.app.defaults["cncjob_coords_type"]

        self.gcode = ""
        self.gcode_parsed = None

        self.pp_geometry_name = pp_geometry_name
        self.pp_geometry = self.app.preprocessors[self.pp_geometry_name]

        self.pp_excellon_name = pp_excellon_name
        self.pp_excellon = self.app.preprocessors[self.pp_excellon_name]

        self.pp_solderpaste_name = None

        # Controls if the move from Z_Toolchange to Z_Move is done fast with G0 or normally with G1
        self.f_plunge = None

        # Controls if the move from Z_Cutto Z_Move is done fast with G0 or G1 until zero and then G0 to Z_move
        self.f_retract = None

        # how much depth the probe can probe before error
        self.z_pdepth = z_pdepth if z_pdepth else None

        # the feedrate(speed) with which the probel travel while probing
        self.feedrate_probe = feedrate_probe if feedrate_probe else None

        self.spindlespeed = spindlespeed
        self.spindledir = spindledir
        self.dwell = dwell
        self.dwelltime = dwelltime

        self.segx = float(segx) if segx is not None else 0.0
        self.segy = float(segy) if segy is not None else 0.0

        self.input_geometry_bounds = None

        self.oldx = None
        self.oldy = None

        self.tool = 0.0

        self.measured_distance = 0.0
        self.measured_down_distance = 0.0
        self.measured_up_to_zero_distance = 0.0
        self.measured_lift_distance = 0.0

        # here store the travelled distance
        self.travel_distance = 0.0
        # here store the routing time
        self.routing_time = 0.0

        # store here the Excellon source object tools to be accessible locally
        self.exc_tools = None

        # search for toolchange parameters in the Toolchange Custom Code
        self.re_toolchange_custom = re.compile(r'(%[a-zA-Z0-9\-_]+%)')

        # search for toolchange code: M6
        self.re_toolchange = re.compile(r'^\s*(M6)$')

        # Attributes to be included in serialization
        # Always append to it because it carries contents
        # from Geometry.
        self.ser_attrs += ['kind', 'z_cut', 'z_move', 'z_toolchange', 'feedrate', 'z_feedrate', 'feedrate_rapid',
                           'tooldia', 'gcode', 'input_geometry_bounds', 'gcode_parsed', 'steps_per_circle',
                           'z_depthpercut', 'spindlespeed', 'dwell', 'dwelltime']

    @property
    def postdata(self):
        """
        This will return all the attributes of the class in the form of a dictionary

        :return:    Class attributes
        :rtype:     dict
        """
        return self.__dict__

    def convert_units(self, units):
        """
        Will convert the parameters in the class that are relevant, from metric to imperial and reverse

        :param units:   FlatCAM units
        :type units:    str
        :return:        conversion factor
        :rtype:         float
        """
        log.debug("camlib.CNCJob.convert_units()")

        factor = Geometry.convert_units(self, units)

        self.z_cut = float(self.z_cut) * factor
        self.z_move *= factor
        self.feedrate *= factor
        self.z_feedrate *= factor
        self.feedrate_rapid *= factor
        self.tooldia *= factor
        self.z_toolchange *= factor
        self.z_end *= factor
        self.z_depthpercut = float(self.z_depthpercut) * factor

        return factor

    def doformat(self, fun, **kwargs):
        return self.doformat2(fun, **kwargs) + "\n"

    def doformat2(self, fun, **kwargs):
        """
        This method will call one of the current preprocessor methods having as parameters all the attributes of
        current class to which will add the kwargs parameters

        :param fun:     One of the methods inside the preprocessor classes which get loaded here in the 'p' object
        :type fun:      class 'function'
        :param kwargs:  keyword args which will update attributes of the current class
        :type kwargs:   dict
        :return:        Gcode line
        :rtype:         str
        """
        attributes = AttrDict()
        attributes.update(self.postdata)
        attributes.update(kwargs)
        try:
            returnvalue = fun(attributes)
            return returnvalue
        except Exception:
            self.app.log.error('Exception occurred within a preprocessor: ' + traceback.format_exc())
            return ''

    def parse_custom_toolchange_code(self, data):
        """
        Will parse a text and get a toolchange sequence in text format suitable to be included in a Gcode file.
        The '%' symbol is used to surround class variables name and must be removed in the returned string.
        After that, the class variables (attributes) are replaced with the current values. The result is returned.

        :param data:    Toolchange sequence
        :type data:     str
        :return:        Processed toolchange sequence
        :rtype:         str
        """
        text = data
        match_list = self.re_toolchange_custom.findall(text)

        if match_list:
            for match in match_list:
                command = match.strip('%')
                try:
                    value = getattr(self, command)
                except AttributeError:
                    self.app.inform.emit('[ERROR] %s: %s' %
                                         (_("There is no such parameter"), str(match)))
                    log.debug("CNCJob.parse_custom_toolchange_code() --> AttributeError ")
                    return 'fail'
                text = text.replace(match, str(value))
            return text

    # Distance callback
    class CreateDistanceCallback(object):
        """Create callback to calculate distances between points."""

        def __init__(self, locs, manager):
            self.manager = manager
            self.matrix = {}

            if locs:
                size = len(locs)

                for from_node in range(size):
                    self.matrix[from_node] = {}
                    for to_node in range(size):
                        if from_node == to_node:
                            self.matrix[from_node][to_node] = 0
                        else:
                            x1 = locs[from_node][0]
                            y1 = locs[from_node][1]
                            x2 = locs[to_node][0]
                            y2 = locs[to_node][1]
                            self.matrix[from_node][to_node] = distance_euclidian(x1, y1, x2, y2)

        # def Distance(self, from_node, to_node):
        #     return int(self.matrix[from_node][to_node])
        def Distance(self, from_index, to_index):
            # Convert from routing variable Index to distance matrix NodeIndex.
            from_node = self.manager.IndexToNode(from_index)
            to_node = self.manager.IndexToNode(to_index)
            return self.matrix[from_node][to_node]

    @staticmethod
    def create_tool_data_array(points):
        # Create the data.
        return [(pt.coords.xy[0][0], pt.coords.xy[1][0]) for pt in points]

    def optimized_ortools_meta(self, locations, start=None, opt_time=0):
        optimized_path = []

        tsp_size = len(locations)
        num_routes = 1  # The number of routes, which is 1 in the TSP.
        # Nodes are indexed from 0 to tsp_size - 1. The depot is the starting node of the route.

        depot = 0 if start is None else start

        # Create routing model.
        if tsp_size == 0:
            log.warning('OR-tools metaheuristics - Specify an instance greater than 0.')
            return optimized_path

        manager = pywrapcp.RoutingIndexManager(tsp_size, num_routes, depot)
        routing = pywrapcp.RoutingModel(manager)
        search_parameters = pywrapcp.DefaultRoutingSearchParameters()
        search_parameters.local_search_metaheuristic = (
            routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)

        # Set search time limit in milliseconds.
        if float(opt_time) != 0:
            search_parameters.time_limit.seconds = int(
                float(opt_time))
        else:
            search_parameters.time_limit.seconds = 3

        # Callback to the distance function. The callback takes two
        # arguments (the from and to node indices) and returns the distance between them.
        dist_between_locations = self.CreateDistanceCallback(locs=locations, manager=manager)

        # if there are no distances then go to the next tool
        if not dist_between_locations:
            return

        dist_callback = dist_between_locations.Distance
        transit_callback_index = routing.RegisterTransitCallback(dist_callback)
        routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

        # Solve, returns a solution if any.
        assignment = routing.SolveWithParameters(search_parameters)

        if assignment:
            # Solution cost.
            log.info("OR-tools metaheuristics - Total distance: " + str(assignment.ObjectiveValue()))

            # Inspect solution.
            # Only one route here; otherwise iterate from 0 to routing.vehicles() - 1.
            route_number = 0
            node = routing.Start(route_number)
            start_node = node

            while not routing.IsEnd(node):
                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace

                optimized_path.append(node)
                node = assignment.Value(routing.NextVar(node))
        else:
            log.warning('OR-tools metaheuristics - No solution found.')

        return optimized_path
        # ############################################# ##

    def optimized_ortools_basic(self, locations, start=None):
        optimized_path = []

        tsp_size = len(locations)
        num_routes = 1  # The number of routes, which is 1 in the TSP.

        # Nodes are indexed from 0 to tsp_size - 1. The depot is the starting node of the route.
        depot = 0 if start is None else start

        # Create routing model.
        if tsp_size == 0:
            log.warning('Specify an instance greater than 0.')
            return optimized_path

        manager = pywrapcp.RoutingIndexManager(tsp_size, num_routes, depot)
        routing = pywrapcp.RoutingModel(manager)
        search_parameters = pywrapcp.DefaultRoutingSearchParameters()

        # Callback to the distance function. The callback takes two
        # arguments (the from and to node indices) and returns the distance between them.
        dist_between_locations = self.CreateDistanceCallback(locs=locations, manager=manager)

        # if there are no distances then go to the next tool
        if not dist_between_locations:
            return

        dist_callback = dist_between_locations.Distance
        transit_callback_index = routing.RegisterTransitCallback(dist_callback)
        routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)

        # Solve, returns a solution if any.
        assignment = routing.SolveWithParameters(search_parameters)

        if assignment:
            # Solution cost.
            log.info("Total distance: " + str(assignment.ObjectiveValue()))

            # Inspect solution.
            # Only one route here; otherwise iterate from 0 to routing.vehicles() - 1.
            route_number = 0
            node = routing.Start(route_number)
            start_node = node

            while not routing.IsEnd(node):
                optimized_path.append(node)
                node = assignment.Value(routing.NextVar(node))
        else:
            log.warning('No solution found.')

        return optimized_path
        # ############################################# ##

    def optimized_travelling_salesman(self, points, start=None):
        """
        As solving the problem in the brute force way is too slow,
        this function implements a simple heuristic: always
        go to the nearest city.

        Even if this algorithm is extremely simple, it works pretty well
        giving a solution only about 25%% longer than the optimal one (cit. Wikipedia),
        and runs very fast in O(N^2) time complexity.

        >>> optimized_travelling_salesman([[i,j] for i in range(5) for j in range(5)])
        [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 4], [1, 3], [1, 2], [1, 1], [1, 0], [2, 0], [2, 1], [2, 2],
        [2, 3], [2, 4], [3, 4], [3, 3], [3, 2], [3, 1], [3, 0], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4]]
        >>> optimized_travelling_salesman([[0,0],[10,0],[6,0]])
        [[0, 0], [6, 0], [10, 0]]

        :param points:  List of tuples with x, y coordinates
        :type points:   list
        :param start:   a tuple with a x,y coordinates of the start point
        :type start:    tuple
        :return:        List of points ordered in a optimized way
        :rtype:         list
        """

        if start is None:
            start = points[0]
        must_visit = points
        path = [start]
        # must_visit.remove(start)
        while must_visit:
            nearest = min(must_visit, key=lambda x: distance(path[-1], x))
            path.append(nearest)
            must_visit.remove(nearest)
        return path

    def geo_optimized_rtree(self, geometry):
        locations = []

        # ## Index first and last points in paths. What points to index.
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        # Create the indexed storage.
        storage = FlatCAMRTreeStorage()
        storage.get_points = get_pts

        # Store the geometry
        log.debug("Indexing geometry before generating G-Code...")
        self.app.inform.emit(_("Indexing geometry before generating G-Code..."))

        for geo_shape in geometry:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            if geo_shape is not None:
                storage.insert(geo_shape)

        current_pt = (0, 0)
        pt, geo = storage.nearest(current_pt)
        try:
            while True:
                storage.remove(geo)
                locations.append((pt, geo))
                current_pt = geo.coords[-1]
                pt, geo = storage.nearest(current_pt)
        except StopIteration:
            pass

        # if there are no locations then go to the next tool
        if not locations:
            return 'fail'

        return locations

    def check_zcut(self, zcut):
        if zcut > 0:
            self.app.inform.emit('[WARNING] %s' %
                                 _("The Cut Z parameter has positive value. "
                                   "It is the depth value to drill into material.\n"
                                   "The Cut Z parameter needs to have a negative value, assuming it is a typo "
                                   "therefore the app will convert the value to negative. "
                                   "Check the resulting CNC code (Gcode etc)."))
            return -zcut
        elif zcut == 0:
            self.app.inform.emit('[WARNING] %s.' % _("The Cut Z parameter is zero. There will be no cut, aborting"))
            return 'fail'

    # used in Tool Drilling
    def excellon_tool_gcode_gen(self, tool, points, tools, first_pt, is_first=False, is_last=False, opt_type='T',
                                toolchange=False):
        """
        Creates Gcode for this object from an Excellon object
        for the specified tools.



        :return:            A tuple made from tool_gcode,  another tuple holding the coordinates of the last point
                            and the start gcode
        :rtype:             tuple
        """
        log.debug("Creating CNC Job from Excellon for tool: %s" % str(tool))

        self.exc_tools = deepcopy(tools)
        t_gcode = ''

        # holds the temporary coordinates of the processed drill point
        locx, locy = first_pt
        temp_locx, temp_locy = first_pt

        # #############################################################################################################
        # #############################################################################################################
        # ##################################   DRILLING !!!   #########################################################
        # #############################################################################################################
        # #############################################################################################################
        if opt_type == 'M':
            log.debug("Using OR-Tools Metaheuristic Guided Local Search drill path optimization.")
        elif opt_type == 'B':
            log.debug("Using OR-Tools Basic drill path optimization.")
        elif opt_type == 'T':
            log.debug("Using Travelling Salesman drill path optimization.")
        else:
            log.debug("Using no path optimization.")

        tool_dict = tools[tool]['data']
        # check if it has drills
        if not points:
            log.debug("Failed. No drills for tool: %s" % str(tool))
            return 'fail'

        if self.app.abort_flag:
            # graceful abort requested by the user
            raise grace

        # #########################################################################################################
        # #########################################################################################################
        # ############# PARAMETERS used in PREPROCESSORS so they need to be updated ###############################
        # #########################################################################################################
        # #########################################################################################################
        self.tool = str(tool)
        # Preprocessor
        p = self.pp_excellon

        # Z_cut parameter
        if self.machinist_setting == 0:
            self.z_cut = self.check_zcut(zcut=tool_dict["tools_drill_cutz"])
            if self.z_cut == 'fail':
                return 'fail'

        # Depth parameters
        self.z_cut = tool_dict['tools_drill_cutz']
        old_zcut = deepcopy(tool_dict["tools_drill_cutz"])      # multidepth use this
        self.multidepth = tool_dict['tools_drill_multidepth']
        self.z_depthpercut = tool_dict['tools_drill_depthperpass']
        self.z_move = tool_dict['tools_drill_travelz']
        self.f_plunge = tool_dict["tools_drill_f_plunge"]       # used directly in the preprocessor Toolchange method
        self.f_retract = tool_dict["tools_drill_f_retract"]     # used in the current method

        # Feedrate parameters
        self.z_feedrate = tool_dict['tools_drill_feedrate_z']
        self.feedrate = tool_dict['tools_drill_feedrate_z']
        self.feedrate_rapid = tool_dict['tools_drill_feedrate_rapid']

        # Spindle parameters
        self.spindlespeed = tool_dict['tools_drill_spindlespeed']
        self.dwell = tool_dict['tools_drill_dwell']
        self.dwelltime = tool_dict['tools_drill_dwelltime']
        self.spindledir = tool_dict['tools_drill_spindledir']

        self.tooldia = tools[tool]["tooldia"]
        self.postdata['toolC'] = tools[tool]["tooldia"]
        self.toolchange = toolchange

        # Z_toolchange parameter
        self.z_toolchange = tool_dict['tools_drill_toolchangez']
        # XY_toolchange parameter
        self.xy_toolchange = tool_dict["tools_drill_toolchangexy"]
        try:
            if self.xy_toolchange == '':
                self.xy_toolchange = None
            else:
                # either originally it was a string or not, xy_toolchange will be made string
                self.xy_toolchange = re.sub('[()\[\]]', '', str(self.xy_toolchange)) if self.xy_toolchange else None

                # and now, xy_toolchange is made into a list of floats in format [x, y]
                if self.xy_toolchange:
                    self.xy_toolchange = [float(eval(a)) for a in self.xy_toolchange.split(",")]

                if self.xy_toolchange and len(self.xy_toolchange) != 2:
                    self.app.inform.emit('[ERROR] %s' % _("The Toolchange X,Y format has to be (x, y)."))
                    return 'fail'
        except Exception as e:
            log.debug("camlib.CNCJob.generate_from_excellon_by_tool() xy_toolchange --> %s" % str(e))
            self.xy_toolchange = [0, 0]

        # End position parameters
        self.startz = tool_dict["tools_drill_startz"]
        if self.startz == '':
            self.startz = None
        self.z_end = tool_dict["tools_drill_endz"]
        self.xy_end = tool_dict["tools_drill_endxy"]

        try:
            if self.xy_end == '':
                self.xy_end = None
            else:
                # either originally it was a string or not, xy_end will be made string
                self.xy_end = re.sub('[()\[\]]', '', str(self.xy_end)) if self.xy_end else None

                # and now, xy_end is made into a list of floats in format [x, y]
                if self.xy_end:
                    self.xy_end = [float(eval(a)) for a in self.xy_end.split(",")]

                if self.xy_end and len(self.xy_end) != 2:
                    self.app.inform.emit('[ERROR] %s' % _("The End X,Y format has to be (x, y)."))
                    return 'fail'
        except Exception as e:
            log.debug("camlib.CNCJob.generate_from_excellon_by_tool() xy_end --> %s" % str(e))
            self.xy_end = [0, 0]

        # Probe parameters
        self.z_pdepth = tool_dict["tools_drill_z_pdepth"]
        self.feedrate_probe = tool_dict["tools_drill_feedrate_probe"]
        # #########################################################################################################
        # #########################################################################################################

        # #########################################################################################################
        # ############ Create the data. ###########################################################################
        # #########################################################################################################
        locations = []
        optimized_path = []

        if opt_type == 'M':
            locations = self.create_tool_data_array(points=points)
            # if there are no locations then go to the next tool
            if not locations:
                return 'fail'
            opt_time = self.app.defaults["excellon_search_time"]
            optimized_path = self.optimized_ortools_meta(locations=locations, opt_time=opt_time)
        elif opt_type == 'B':
            locations = self.create_tool_data_array(points=points)
            # if there are no locations then go to the next tool
            if not locations:
                return 'fail'
            optimized_path = self.optimized_ortools_basic(locations=locations)
        elif opt_type == 'T':
            locations = self.create_tool_data_array(points=points)
            # if there are no locations then go to the next tool
            if not locations:
                return 'fail'
            optimized_path = self.optimized_travelling_salesman(locations)
        else:
            # it's actually not optimized path but here we build a list of (x,y) coordinates
            # out of the tool's drills
            for drill in tools[tool]['drills']:
                unoptimized_coords = (
                    drill.x,
                    drill.y
                )
                optimized_path.append(unoptimized_coords)
        # #########################################################################################################
        # #########################################################################################################

        # Only if there are locations to drill
        if not optimized_path:
            log.debug("CNCJob.excellon_tool_gcode_gen() -> Optimized path is empty.")
            return 'fail'

        if self.app.abort_flag:
            # graceful abort requested by the user
            raise grace

        start_gcode = ''
        if is_first:
            start_gcode = self.doformat(p.start_code)
            # t_gcode += start_gcode

        # do the ToolChange event
        t_gcode += self.doformat(p.z_feedrate_code)
        t_gcode += self.doformat(p.toolchange_code, toolchangexy=(temp_locx, temp_locy))
        t_gcode += self.doformat(p.z_feedrate_code)

        # Spindle start
        t_gcode += self.doformat(p.spindle_code)
        # Dwell time
        if self.dwell is True:
            t_gcode += self.doformat(p.dwell_code)

        current_tooldia = self.app.dec_format(float(tools[tool]["tooldia"]), self.decimals)
        self.app.inform.emit(
            '%s: %s%s.' % (_("Starting G-Code for tool with diameter"), str(current_tooldia), str(self.units))
        )

        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        # APPLY Offset only when using the appGUI, for TclCommand this will create an error
        # because the values for Z offset are created in build_tool_ui()
        # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        try:
            z_offset = float(tool_dict['tools_drill_offset']) * (-1)
        except KeyError:
            z_offset = 0
        self.z_cut = z_offset + old_zcut

        self.coordinates_type = self.app.defaults["cncjob_coords_type"]
        if self.coordinates_type == "G90":
            # Drillling! for Absolute coordinates type G90
            # variables to display the percentage of work done
            geo_len = len(optimized_path)

            old_disp_number = 0
            log.warning("Number of drills for which to generate GCode: %s" % str(geo_len))

            loc_nr = 0
            for point in optimized_path:
                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace

                # if we use Traveling Salesman Algorithm as an optimization
                if opt_type == 'T':
                    locx = point[0]
                    locy = point[1]
                else:
                    locx = locations[point][0]
                    locy = locations[point][1]

                travels = self.app.exc_areas.travel_coordinates(start_point=(temp_locx, temp_locy),
                                                                end_point=(locx, locy),
                                                                tooldia=current_tooldia)
                prev_z = None
                for travel in travels:
                    locx = travel[1][0]
                    locy = travel[1][1]

                    if travel[0] is not None:
                        # move to next point
                        t_gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                        # raise to safe Z (travel[0]) each time because safe Z may be different
                        self.z_move = travel[0]
                        t_gcode += self.doformat(p.lift_code, x=locx, y=locy)

                        # restore z_move
                        self.z_move = tool_dict['tools_drill_travelz']
                    else:
                        if prev_z is not None:
                            # move to next point
                            t_gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                            # we assume that previously the z_move was altered therefore raise to
                            # the travel_z (z_move)
                            self.z_move = tool_dict['tools_drill_travelz']
                            t_gcode += self.doformat(p.lift_code, x=locx, y=locy)
                        else:
                            # move to next point
                            t_gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                    # store prev_z
                    prev_z = travel[0]

                # t_gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                if self.multidepth and abs(self.z_cut) > abs(self.z_depthpercut):
                    doc = deepcopy(self.z_cut)
                    self.z_cut = 0.0

                    while abs(self.z_cut) < abs(doc):

                        self.z_cut -= self.z_depthpercut
                        if abs(doc) < abs(self.z_cut) < (abs(doc) + self.z_depthpercut):
                            self.z_cut = doc
                        # Move down the drill bit
                        t_gcode += self.doformat(p.down_code, x=locx, y=locy)

                        # Update the distance travelled down with the current one
                        self.measured_down_distance += abs(self.z_cut) + abs(self.z_move)

                        if self.f_retract is False:
                            t_gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
                            self.measured_up_to_zero_distance += abs(self.z_cut)
                            self.measured_lift_distance += abs(self.z_move)
                        else:
                            self.measured_lift_distance += abs(self.z_cut) + abs(self.z_move)

                        t_gcode += self.doformat(p.lift_code, x=locx, y=locy)

                else:
                    t_gcode += self.doformat(p.down_code, x=locx, y=locy)

                    self.measured_down_distance += abs(self.z_cut) + abs(self.z_move)

                    if self.f_retract is False:
                        t_gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
                        self.measured_up_to_zero_distance += abs(self.z_cut)
                        self.measured_lift_distance += abs(self.z_move)
                    else:
                        self.measured_lift_distance += abs(self.z_cut) + abs(self.z_move)

                    t_gcode += self.doformat(p.lift_code, x=locx, y=locy)

                self.measured_distance += abs(distance_euclidian(locx, locy, temp_locx, temp_locy))
                temp_locx = locx
                temp_locy = locy
                self.oldx = locx
                self.oldy = locy

                loc_nr += 1
                disp_number = int(np.interp(loc_nr, [0, geo_len], [0, 100]))

                if old_disp_number < disp_number <= 100:
                    self.app.proc_container.update_view_text(' %d%%' % disp_number)
                    old_disp_number = disp_number

        else:
            self.app.inform.emit('[ERROR_NOTCL] %s...' % _('G91 coordinates not implemented'))
            return 'fail'
        self.z_cut = deepcopy(old_zcut)

        if is_last:
            t_gcode += self.doformat(p.spindle_stop_code)
            # Move to End position
            t_gcode += self.doformat(p.end_code, x=0, y=0)

        self.app.inform.emit('%s %s' % (_("Finished G-Code generation for tool:"), str(tool)))
        return t_gcode, (locx, locy), start_gcode

    # used in Geometry (and soon in Tool Milling)
    def geometry_tool_gcode_gen(self, tool, tools, first_pt, tolerance, is_first=False, is_last=False,
                                toolchange=False):
        """
        Algorithm to generate GCode from multitool Geometry.

        :param tool:        tool number for which to generate GCode
        :type tool:         int
        :param tools:       a dictionary holding all the tools and data
        :type tools:        dict
        :param first_pt:    a tuple of coordinates for the first point of the current tool
        :type first_pt:     tuple
        :param tolerance:   geometry tolerance
        :type tolerance:
        :param is_first:    if the current tool is the first tool (for this we need to add start GCode)
        :type is_first:     bool
        :param is_last:     if the current tool is the last tool (for this we need to add the end GCode)
        :type is_last:      bool
        :param toolchange:  add toolchange event
        :type toolchange:   bool
        :return:            GCode
        :rtype:             str
        """

        log.debug("geometry_tool_gcode_gen()")

        t_gcode = ''
        temp_solid_geometry = []

        # The Geometry from which we create GCode
        geometry = tools[tool]['solid_geometry']
        # ## Flatten the geometry. Only linear elements (no polygons) remain.
        flat_geometry = self.flatten(geometry, reset=True, pathonly=True)
        log.debug("%d paths" % len(flat_geometry))

        # #########################################################################################################
        # #########################################################################################################
        # ############# PARAMETERS used in PREPROCESSORS so they need to be updated ###############################
        # #########################################################################################################
        # #########################################################################################################
        self.tool = str(tool)
        tool_dict = tools[tool]['data']
        # this is the tool diameter, it is used as such to accommodate the preprocessor who need the tool diameter
        # given under the name 'toolC'
        self.postdata['toolC'] = float(tools[tool]['tooldia'])
        self.tooldia = float(tools[tool]['tooldia'])
        self.use_ui = True
        self.tolerance = tolerance

        # Optimization type. Can be: 'M', 'B', 'T', 'R', 'No'
        opt_type = tool_dict['optimization_type']
        opt_time = tool_dict['search_time'] if 'search_time' in tool_dict else 'R'

        if opt_type == 'M':
            log.debug("Using OR-Tools Metaheuristic Guided Local Search path optimization.")
        elif opt_type == 'B':
            log.debug("Using OR-Tools Basic path optimization.")
        elif opt_type == 'T':
            log.debug("Using Travelling Salesman path optimization.")
        elif opt_type == 'R':
            log.debug("Using RTree path optimization.")
        else:
            log.debug("Using no path optimization.")

        # Preprocessor
        self.pp_geometry_name = tool_dict['ppname_g']
        self.pp_geometry = self.app.preprocessors[self.pp_geometry_name]
        p = self.pp_geometry

        # Offset the Geometry if it is the case
        if tools[tool]['offset'].lower() == 'in':
            tool_offset = -float(tools[tool]['tooldia']) / 2.0
        elif tools[tool]['offset'].lower() == 'out':
            tool_offset = float(tools[tool]['tooldia']) / 2.0
        elif tools[tool]['offset'].lower() == 'custom':
            tool_offset = tools[tool]['offset_value']
        else:
            tool_offset = 0.0

        if tool_offset != 0.0:
            for it in flat_geometry:
                # if the geometry is a closed shape then create a Polygon out of it
                if isinstance(it, LineString):
                    if it.is_ring:
                        it = Polygon(it)
                temp_solid_geometry.append(it.buffer(tool_offset, join_style=2))
            temp_solid_geometry = self.flatten(temp_solid_geometry, reset=True, pathonly=True)
        else:
            temp_solid_geometry = flat_geometry

        if self.z_cut is None:
            if 'laser' not in self.pp_geometry_name:
                self.app.inform.emit(
                    '[ERROR_NOTCL] %s' % _("Cut_Z parameter is None or zero. Most likely a bad combinations of "
                                           "other parameters."))
                return 'fail'
            else:
                self.z_cut = 0
        if self.machinist_setting == 0:
            if self.z_cut > 0:
                self.app.inform.emit('[WARNING] %s' %
                                     _("The Cut Z parameter has positive value. "
                                       "It is the depth value to cut into material.\n"
                                       "The Cut Z parameter needs to have a negative value, assuming it is a typo "
                                       "therefore the app will convert the value to negative."
                                       "Check the resulting CNC code (Gcode etc)."))
                self.z_cut = -self.z_cut
            elif self.z_cut == 0 and 'laser' not in self.pp_geometry_name:
                self.app.inform.emit('[WARNING] %s: %s' %
                                     (_("The Cut Z parameter is zero. There will be no cut, skipping file"),
                                      self.options['name']))
                return 'fail'

            if self.z_move is None:
                self.app.inform.emit('[ERROR_NOTCL] %s' % _("Travel Z parameter is None or zero."))
                return 'fail'

            if self.z_move < 0:
                self.app.inform.emit('[WARNING] %s' %
                                     _("The Travel Z parameter has negative value. "
                                       "It is the height value to travel between cuts.\n"
                                       "The Z Travel parameter needs to have a positive value, assuming it is a typo "
                                       "therefore the app will convert the value to positive."
                                       "Check the resulting CNC code (Gcode etc)."))
                self.z_move = -self.z_move
            elif self.z_move == 0:
                self.app.inform.emit('[WARNING] %s: %s' %
                                     (_("The Z Travel parameter is zero. This is dangerous, skipping file"),
                                      self.options['name']))
                return 'fail'

        # made sure that depth_per_cut is no more then the z_cut
        if abs(self.z_cut) < self.z_depthpercut:
            self.z_depthpercut = abs(self.z_cut)

        # Depth parameters
        self.z_cut = float(tool_dict['cutz'])
        self.multidepth = tool_dict['multidepth']
        self.z_depthpercut = float(tool_dict['depthperpass'])
        self.z_move = float(tool_dict['travelz'])
        self.f_plunge = self.app.defaults["geometry_f_plunge"]

        self.feedrate = float(tool_dict['feedrate'])
        self.z_feedrate = float(tool_dict['feedrate_z'])
        self.feedrate_rapid = float(tool_dict['feedrate_rapid'])

        self.spindlespeed = float(tool_dict['spindlespeed'])
        try:
            self.spindledir = tool_dict['spindledir']
        except KeyError:
            self.spindledir = self.app.defaults["geometry_spindledir"]

        self.dwell = tool_dict['dwell']
        self.dwelltime = float(tool_dict['dwelltime'])

        self.startz = float(tool_dict['startz']) if tool_dict['startz'] else None
        if self.startz == '':
            self.startz = None

        self.z_end = float(tool_dict['endz'])
        self.xy_end = tool_dict['endxy']
        try:
            if self.xy_end == '' or self.xy_end is None:
                self.xy_end = None
            else:
                # either originally it was a string or not, xy_end will be made string
                self.xy_end = re.sub('[()\[\]]', '', str(self.xy_end)) if self.xy_end else None

                # and now, xy_end is made into a list of floats in format [x, y]
                if self.xy_end:
                    self.xy_end = [float(eval(a)) for a in self.xy_end.split(",")]

                if self.xy_end and len(self.xy_end) != 2:
                    self.app.inform.emit('[ERROR]%s' % _("The End X,Y format has to be (x, y)."))
                    return 'fail'
        except Exception as e:
            log.debug("camlib.CNCJob.geometry_from_excellon_by_tool() xy_end --> %s" % str(e))
            self.xy_end = [0, 0]

        self.z_toolchange = tool_dict['toolchangez']
        self.xy_toolchange = tool_dict["toolchangexy"]
        try:
            if self.xy_toolchange == '':
                self.xy_toolchange = None
            else:
                # either originally it was a string or not, xy_toolchange will be made string
                self.xy_toolchange = re.sub('[()\[\]]', '', str(self.xy_toolchange)) if self.xy_toolchange else None

                # and now, xy_toolchange is made into a list of floats in format [x, y]
                if self.xy_toolchange:
                    self.xy_toolchange = [float(eval(a)) for a in self.xy_toolchange.split(",")]

                if self.xy_toolchange and len(self.xy_toolchange) != 2:
                    self.app.inform.emit('[ERROR] %s' % _("The Toolchange X,Y format has to be (x, y)."))
                    return 'fail'
        except Exception as e:
            log.debug("camlib.CNCJob.geometry_from_excellon_by_tool() --> %s" % str(e))
            pass

        self.extracut = tool_dict['extracut']
        self.extracut_length = tool_dict['extracut_length']

        # Probe parameters
        # self.z_pdepth = tool_dict["tools_drill_z_pdepth"]
        # self.feedrate_probe = tool_dict["tools_drill_feedrate_probe"]

        # #########################################################################################################
        # ############ Create the data. ###########################################################################
        # #########################################################################################################
        optimized_path = []

        geo_storage = {}
        for geo in temp_solid_geometry:
            if not geo is None:
                geo_storage[geo.coords[0]] = geo
        locations = list(geo_storage.keys())

        if opt_type == 'M':
            # if there are no locations then go to the next tool
            if not locations:
                return 'fail'
            optimized_locations = self.optimized_ortools_meta(locations=locations, opt_time=opt_time)
            optimized_path = [(locations[loc], geo_storage[locations[loc]]) for loc in optimized_locations]
        elif opt_type == 'B':
            # if there are no locations then go to the next tool
            if not locations:
                return 'fail'
            optimized_locations = self.optimized_ortools_basic(locations=locations)
            optimized_path = [(locations[loc], geo_storage[locations[loc]]) for loc in optimized_locations]
        elif opt_type == 'T':
            # if there are no locations then go to the next tool
            if not locations:
                return 'fail'
            optimized_locations = self.optimized_travelling_salesman(locations)
            optimized_path = [(loc, geo_storage[loc]) for loc in optimized_locations]
        elif opt_type == 'R':
            optimized_path = self.geo_optimized_rtree(temp_solid_geometry)
            if optimized_path == 'fail':
                return 'fail'
        else:
            # it's actually not optimized path but here we build a list of (x,y) coordinates
            # out of the tool's drills
            for geo in temp_solid_geometry:
                optimized_path.append(geo.coords[0])
        # #########################################################################################################
        # #########################################################################################################

        # Only if there are locations to mill
        if not optimized_path:
            log.debug("camlib.CNCJob.geometry_tool_gcode_gen() -> Optimized path is empty.")
            return 'fail'

        if self.app.abort_flag:
            # graceful abort requested by the user
            raise grace

        # #############################################################################################################
        # #############################################################################################################
        # ################# MILLING !!! ##############################################################################
        # #############################################################################################################
        # #############################################################################################################
        log.debug("Starting G-Code...")

        current_tooldia = float('%.*f' % (self.decimals, float(self.tooldia)))
        self.app.inform.emit('%s: %s%s.' % (_("Starting G-Code for tool with diameter"),
                                            str(current_tooldia),
                                            str(self.units)))

        # Measurements
        total_travel = 0.0
        total_cut = 0.0

        # Start GCode
        start_gcode = ''
        if is_first:
            start_gcode = self.doformat(p.start_code)
            # t_gcode += start_gcode

        # Toolchange code
        t_gcode += self.doformat(p.feedrate_code)  # sets the feed rate
        if toolchange:
            t_gcode += self.doformat(p.toolchange_code)

            if 'laser' not in self.pp_geometry_name.lower():
                t_gcode += self.doformat(p.spindle_code)  # Spindle start
            else:
                # for laser this will disable the laser
                t_gcode += self.doformat(p.lift_code, x=self.oldx, y=self.oldy)  # Move (up) to travel height

            if self.dwell:
                t_gcode += self.doformat(p.dwell_code)  # Dwell time
        else:
            t_gcode += self.doformat(p.lift_code, x=0, y=0)  # Move (up) to travel height
            t_gcode += self.doformat(p.startz_code, x=0, y=0)

            if 'laser' not in self.pp_geometry_name.lower():
                t_gcode += self.doformat(p.spindle_code)  # Spindle start

            if self.dwell is True:
                t_gcode += self.doformat(p.dwell_code)  # Dwell time
        t_gcode += self.doformat(p.feedrate_code)  # sets the feed rate

        # ## Iterate over geometry paths getting the nearest each time.
        path_count = 0

        # variables to display the percentage of work done
        geo_len = len(flat_geometry)
        log.warning("Number of paths for which to generate GCode: %s" % str(geo_len))
        old_disp_number = 0

        current_pt = (0, 0)
        for pt, geo in optimized_path:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            path_count += 1

            # If last point in geometry is the nearest but prefer the first one if last point == first point
            # then reverse coordinates.
            if pt != geo.coords[0] and pt == geo.coords[-1]:
                geo = LineString(list(geo.coords)[::-1])

            # ---------- Single depth/pass --------
            if not self.multidepth:
                # calculate the cut distance
                total_cut = total_cut + geo.length

                t_gcode += self.create_gcode_single_pass(geo, current_tooldia, self.extracut,
                                                         self.extracut_length, self.tolerance,
                                                         z_move=self.z_move, old_point=current_pt)

            # --------- Multi-pass ---------
            else:
                # calculate the cut distance
                # due of the number of cuts (multi depth) it has to multiplied by the number of cuts
                nr_cuts = 0
                depth = abs(self.z_cut)
                while depth > 0:
                    nr_cuts += 1
                    depth -= float(self.z_depthpercut)

                total_cut += (geo.length * nr_cuts)

                gc, geo = self.create_gcode_multi_pass(geo, current_tooldia, self.extracut,
                                                       self.extracut_length, self.tolerance,
                                                       z_move=self.z_move, postproc=p, old_point=current_pt)
                t_gcode += gc

            # calculate the total distance
            total_travel = total_travel + abs(distance(pt1=current_pt, pt2=pt))
            current_pt = geo.coords[-1]

            disp_number = int(np.interp(path_count, [0, geo_len], [0, 100]))
            if old_disp_number < disp_number <= 100:
                self.app.proc_container.update_view_text(' %d%%' % disp_number)
                old_disp_number = disp_number

        log.debug("Finished G-Code... %s paths traced." % path_count)

        # add move to end position
        total_travel += abs(distance_euclidian(current_pt[0], current_pt[1], 0, 0))
        self.travel_distance += total_travel + total_cut
        self.routing_time += total_cut / self.feedrate

        # Finish
        if is_last:
            t_gcode += self.doformat(p.spindle_stop_code)
            t_gcode += self.doformat(p.lift_code, x=current_pt[0], y=current_pt[1])
            t_gcode += self.doformat(p.end_code, x=0, y=0)
            self.app.inform.emit(
                '%s... %s %s.' % (_("Finished G-Code generation"), str(path_count), _("paths traced"))
            )

        self.gcode = t_gcode
        return self.gcode, start_gcode

    # used by the Tcl command Drillcncjob
    def generate_from_excellon_by_tool(self, exobj, tools="all", order='fwd', is_first=False, use_ui=False):
        """
        Creates Gcode for this object from an Excellon object
        for the specified tools.

        :param exobj:       Excellon object to process
        :type exobj:        Excellon
        :param tools:       Comma separated tool names
        :type tools:        str
        :param order:       order of tools processing: "fwd", "rev" or "no"
        :type order:        str
        :param is_first:    if the tool is the first one should generate the start gcode (not that it matter much
                            which is the one doing it)
        :type is_first:     bool
        :param use_ui:      if True the method will use parameters set in UI
        :type use_ui:       bool
        :return:            None
        :rtype:             None
        """

        # #############################################################################################################
        # #############################################################################################################
        # create a local copy of the exobj.tools so it can be used for creating drill CCode geometry
        # #############################################################################################################
        # #############################################################################################################
        self.exc_tools = deepcopy(exobj.tools)

        # the Excellon GCode preprocessor will use this info in the start_code() method
        self.use_ui = True if use_ui else False

        # Z_cut parameter
        if self.machinist_setting == 0:
            self.z_cut = self.check_zcut(zcut=self.z_cut)
            if self.z_cut == 'fail':
                return 'fail'
        # multidepth use this
        old_zcut = deepcopy(self.z_cut)

        # XY_toolchange parameter
        try:
            if self.xy_toolchange == '':
                self.xy_toolchange = None
            else:
                self.xy_toolchange = re.sub('[()\[\]]', '', str(self.xy_toolchange)) if self.xy_toolchange else None

                if self.xy_toolchange:
                    self.xy_toolchange = [float(eval(a)) for a in self.xy_toolchange.split(",")]

                if self.xy_toolchange and len(self.xy_toolchange) != 2:
                    self.app.inform.emit('[ERROR]%s' %
                                         _("The Toolchange X,Y field in Edit -> Preferences has to be "
                                           "in the format (x, y) \nbut now there is only one value, not two. "))
                    return 'fail'
        except Exception as e:
            log.debug("camlib.CNCJob.generate_from_excellon_by_tool() --> %s" % str(e))
            pass

        # XY_end parameter
        self.xy_end = re.sub('[()\[\]]', '', str(self.xy_end)) if self.xy_end else None
        if self.xy_end and self.xy_end != '':
            self.xy_end = [float(eval(a)) for a in self.xy_end.split(",")]
        if self.xy_end and len(self.xy_end) < 2:
            self.app.inform.emit('[ERROR]  %s' % _("The End Move X,Y field in Edit -> Preferences has to be "
                                                   "in the format (x, y) but now there is only one value, not two."))
            return 'fail'

        # Prepprocessor
        self.pp_excellon = self.app.preprocessors[self.pp_excellon_name]
        p = self.pp_excellon

        log.debug("Creating CNC Job from Excellon...")

        # #############################################################################################################
        # #############################################################################################################
        # TOOLS
        # sort the tools list by the second item in tuple (here we have a dict with diameter of the tool)
        # so we actually are sorting the tools by diameter
        # #############################################################################################################
        # #############################################################################################################
        all_tools = []
        for tool_as_key, v in list(self.exc_tools.items()):
            all_tools.append((int(tool_as_key), float(v['tooldia'])))

        if order == 'fwd':
            sorted_tools = sorted(all_tools, key=lambda t1: t1[1])
        elif order == 'rev':
            sorted_tools = sorted(all_tools, key=lambda t1: t1[1], reverse=True)
        else:
            sorted_tools = all_tools

        if tools == "all":
            selected_tools = [i[0] for i in all_tools]  # we get a array of ordered tools
        else:
            selected_tools = eval(tools)

        # Create a sorted list of selected tools from the sorted_tools list
        tools = [i for i, j in sorted_tools for k in selected_tools if i == k]

        log.debug("Tools sorted are: %s" % str(tools))

        # #############################################################################################################
        # #############################################################################################################
        # build a self.options['Tools_in_use'] list from scratch if we don't have one like in the case of
        # running this method from a Tcl Command
        # #############################################################################################################
        # #############################################################################################################
        build_tools_in_use_list = False
        if 'Tools_in_use' not in self.options:
            self.options['Tools_in_use'] = []

        # if the list is empty (either we just added the key or it was already there but empty) signal to build it
        if not self.options['Tools_in_use']:
            build_tools_in_use_list = True

        # #############################################################################################################
        # #############################################################################################################
        # fill the data into the self.exc_cnc_tools dictionary
        # #############################################################################################################
        # #############################################################################################################
        for it in all_tools:
            for to_ol in tools:
                if to_ol == it[0]:
                    sol_geo = []

                    drill_no = 0
                    if 'drills' in exobj.tools[to_ol]:
                        drill_no = len(exobj.tools[to_ol]['drills'])
                        for drill in exobj.tools[to_ol]['drills']:
                            sol_geo.append(drill.buffer((it[1] / 2.0), resolution=self.geo_steps_per_circle))

                    slot_no = 0
                    if 'slots' in exobj.tools[to_ol]:
                        slot_no = len(exobj.tools[to_ol]['slots'])
                        for slot in exobj.tools[to_ol]['slots']:
                            start = (slot[0].x, slot[0].y)
                            stop = (slot[1].x, slot[1].y)
                            sol_geo.append(
                                LineString([start, stop]).buffer((it[1] / 2.0), resolution=self.geo_steps_per_circle)
                            )

                    if self.use_ui:
                        try:
                            z_off = float(exobj.tools[it[0]]['data']['tools_drill_offset']) * (-1)
                        except KeyError:
                            z_off = 0
                    else:
                        z_off = 0

                    default_data = {}
                    for k, v in list(self.options.items()):
                        default_data[k] = deepcopy(v)

                    # it[1] is the tool diameter
                    self.exc_cnc_tools[it[1]] = {}
                    self.exc_cnc_tools[it[1]]['tool'] = it[0]
                    self.exc_cnc_tools[it[1]]['nr_drills'] = drill_no
                    self.exc_cnc_tools[it[1]]['nr_slots'] = slot_no
                    self.exc_cnc_tools[it[1]]['offset_z'] = z_off
                    self.exc_cnc_tools[it[1]]['data'] = default_data
                    self.exc_cnc_tools[it[1]]['solid_geometry'] = deepcopy(sol_geo)

                    # build a self.options['Tools_in_use'] list from scratch if we don't have one like in the case of
                    # running this method from a Tcl Command
                    if build_tools_in_use_list is True:
                        self.options['Tools_in_use'].append(
                            [it[0], it[1], drill_no, slot_no]
                        )

        self.app.inform.emit(_("Creating a list of points to drill..."))

        # #############################################################################################################
        # #############################################################################################################
        # Points (Group by tool): a dictionary of shapely Point geo elements grouped by tool number
        # #############################################################################################################
        # #############################################################################################################
        points = {}
        for tool, tool_dict in self.exc_tools.items():
            if tool in tools:
                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace

                if 'drills' in tool_dict and tool_dict['drills']:
                    for drill_pt in tool_dict['drills']:
                        try:
                            points[tool].append(drill_pt)
                        except KeyError:
                            points[tool] = [drill_pt]
        log.debug("Found %d TOOLS with drills." % len(points))

        # check if there are drill points in the exclusion areas.
        # If we find any within the exclusion areas return 'fail'
        for tool in points:
            for pt in points[tool]:
                for area in self.app.exc_areas.exclusion_areas_storage:
                    pt_buf = pt.buffer(self.exc_tools[tool]['tooldia'] / 2.0)
                    if pt_buf.within(area['shape']) or pt_buf.intersects(area['shape']):
                        self.app.inform.emit("[ERROR_NOTCL] %s" % _("Failed. Drill points inside the exclusion zones."))
                        return 'fail'

        # this holds the resulting GCode
        self.gcode = []
        # #############################################################################################################
        # #############################################################################################################
        # Initialization
        # #############################################################################################################
        # #############################################################################################################
        gcode = ''
        start_gcode = ''
        if is_first:
            start_gcode = self.doformat(p.start_code)

        if use_ui is False:
            gcode += self.doformat(p.z_feedrate_code)

        if self.toolchange is False:
            if self.xy_toolchange is not None:
                gcode += self.doformat(p.lift_code, x=self.xy_toolchange[0], y=self.xy_toolchange[1])
                gcode += self.doformat(p.startz_code, x=self.xy_toolchange[0], y=self.xy_toolchange[1])
            else:
                gcode += self.doformat(p.lift_code, x=0.0, y=0.0)
                gcode += self.doformat(p.startz_code, x=0.0, y=0.0)

        if self.xy_toolchange is not None:
            self.oldx = self.xy_toolchange[0]
            self.oldy = self.xy_toolchange[1]
        else:
            self.oldx = 0.0
            self.oldy = 0.0

        measured_distance = 0.0
        measured_down_distance = 0.0
        measured_up_to_zero_distance = 0.0
        measured_lift_distance = 0.0

        # #############################################################################################################
        # #############################################################################################################
        # GCODE creation
        # #############################################################################################################
        # #############################################################################################################
        self.app.inform.emit('%s...' % _("Starting G-Code"))

        has_drills = None
        for tool, tool_dict in self.exc_tools.items():
            if 'drills' in tool_dict and tool_dict['drills']:
                has_drills = True
                break
        if not has_drills:
            log.debug("camlib.CNCJob.generate_from_excellon_by_tool() --> "
                      "The loaded Excellon file has no drills ...")
            self.app.inform.emit('[ERROR_NOTCL] %s...' % _('The loaded Excellon file has no drills'))
            return 'fail'

        current_platform = platform.architecture()[0]
        if current_platform == '64bit':
            used_excellon_optimization_type = self.excellon_optimization_type
        else:
            used_excellon_optimization_type = 'T'

        # #############################################################################################################
        # #############################################################################################################
        # ##################################   DRILLING !!!   #########################################################
        # #############################################################################################################
        # #############################################################################################################
        if used_excellon_optimization_type == 'M':
            log.debug("Using OR-Tools Metaheuristic Guided Local Search drill path optimization.")
        elif used_excellon_optimization_type == 'B':
            log.debug("Using OR-Tools Basic drill path optimization.")
        elif used_excellon_optimization_type == 'T':
            log.debug("Using Travelling Salesman drill path optimization.")
        else:
            log.debug("Using no path optimization.")

        if self.toolchange is True:
            for tool in tools:
                # check if it has drills
                if not self.exc_tools[tool]['drills']:
                    continue

                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace

                self.tool = tool
                self.tooldia = self.exc_tools[tool]["tooldia"]
                self.postdata['toolC'] = self.tooldia

                if self.use_ui:
                    self.z_feedrate = self.exc_tools[tool]['data']['tools_drill_feedrate_z']
                    self.feedrate = self.exc_tools[tool]['data']['tools_drill_feedrate_z']
                    self.z_cut = self.exc_tools[tool]['data']['tools_drill_cutz']
                    gcode += self.doformat(p.z_feedrate_code)

                    if self.machinist_setting == 0:
                        if self.z_cut > 0:
                            self.app.inform.emit('[WARNING] %s' %
                                                 _("The Cut Z parameter has positive value. "
                                                   "It is the depth value to drill into material.\n"
                                                   "The Cut Z parameter needs to have a negative value, "
                                                   "assuming it is a typo "
                                                   "therefore the app will convert the value to negative. "
                                                   "Check the resulting CNC code (Gcode etc)."))
                            self.z_cut = -self.z_cut
                        elif self.z_cut == 0:
                            self.app.inform.emit('[WARNING] %s: %s' %
                                                 (_(
                                                     "The Cut Z parameter is zero. There will be no cut, "
                                                     "skipping file"),
                                                  exobj.options['name']))
                            return 'fail'

                    old_zcut = deepcopy(self.z_cut)

                    self.z_move = self.exc_tools[tool]['data']['tools_drill_travelz']
                    self.spindlespeed = self.exc_tools[tool]['data']['tools_drill_spindlespeed']
                    self.dwell = self.exc_tools[tool]['data']['tools_drill_dwell']
                    self.dwelltime = self.exc_tools[tool]['data']['tools_drill_dwelltime']
                    self.multidepth = self.exc_tools[tool]['data']['tools_drill_multidepth']
                    self.z_depthpercut = self.exc_tools[tool]['data']['tools_drill_depthperpass']
                else:
                    old_zcut = deepcopy(self.z_cut)

                # #########################################################################################################
                # ############ Create the data. #################
                # #########################################################################################################
                locations = []
                altPoints = []
                optimized_path = []

                if used_excellon_optimization_type == 'M':
                    if tool in points:
                        locations = self.create_tool_data_array(points=points[tool])
                    # if there are no locations then go to the next tool
                    if not locations:
                        continue
                    opt_time = self.app.defaults["excellon_search_time"]
                    optimized_path = self.optimized_ortools_meta(locations=locations, opt_time=opt_time)
                elif used_excellon_optimization_type == 'B':
                    if tool in points:
                        locations = self.create_tool_data_array(points=points[tool])
                    # if there are no locations then go to the next tool
                    if not locations:
                        continue
                    optimized_path = self.optimized_ortools_basic(locations=locations)
                elif used_excellon_optimization_type == 'T':
                    for point in points[tool]:
                        altPoints.append((point.coords.xy[0][0], point.coords.xy[1][0]))
                    optimized_path = self.optimized_travelling_salesman(altPoints)
                else:
                    # it's actually not optimized path but here we build a list of (x,y) coordinates
                    # out of the tool's drills
                    for drill in self.exc_tools[tool]['drills']:
                        unoptimized_coords = (
                            drill.x,
                            drill.y
                        )
                        optimized_path.append(unoptimized_coords)
                # #########################################################################################################
                # #########################################################################################################

                # Only if there are locations to drill
                if not optimized_path:
                    continue

                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace

                # Tool change sequence (optional)
                if self.toolchange:
                    gcode += self.doformat(p.toolchange_code, toolchangexy=(self.oldx, self.oldy))
                # Spindle start
                gcode += self.doformat(p.spindle_code)
                # Dwell time
                if self.dwell is True:
                    gcode += self.doformat(p.dwell_code)

                current_tooldia = float('%.*f' % (self.decimals, float(self.exc_tools[tool]["tooldia"])))

                self.app.inform.emit(
                    '%s: %s%s.' % (_("Starting G-Code for tool with diameter"),
                                   str(current_tooldia),
                                   str(self.units))
                )

                # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                # APPLY Offset only when using the appGUI, for TclCommand this will create an error
                # because the values for Z offset are created in build_ui()
                # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                try:
                    z_offset = float(self.exc_tools[tool]['data']['tools_drill_offset']) * (-1)
                except KeyError:
                    z_offset = 0
                self.z_cut = z_offset + old_zcut

                self.coordinates_type = self.app.defaults["cncjob_coords_type"]
                if self.coordinates_type == "G90":
                    # Drillling! for Absolute coordinates type G90
                    # variables to display the percentage of work done
                    geo_len = len(optimized_path)

                    old_disp_number = 0
                    log.warning("Number of drills for which to generate GCode: %s" % str(geo_len))

                    loc_nr = 0
                    for point in optimized_path:
                        if self.app.abort_flag:
                            # graceful abort requested by the user
                            raise grace

                        if used_excellon_optimization_type == 'T':
                            locx = point[0]
                            locy = point[1]
                        else:
                            locx = locations[point][0]
                            locy = locations[point][1]

                        travels = self.app.exc_areas.travel_coordinates(start_point=(self.oldx, self.oldy),
                                                                        end_point=(locx, locy),
                                                                        tooldia=current_tooldia)
                        prev_z = None
                        for travel in travels:
                            locx = travel[1][0]
                            locy = travel[1][1]

                            if travel[0] is not None:
                                # move to next point
                                gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                                # raise to safe Z (travel[0]) each time because safe Z may be different
                                self.z_move = travel[0]
                                gcode += self.doformat(p.lift_code, x=locx, y=locy)

                                # restore z_move
                                self.z_move = self.exc_tools[tool]['data']['tools_drill_travelz']
                            else:
                                if prev_z is not None:
                                    # move to next point
                                    gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                                    # we assume that previously the z_move was altered therefore raise to
                                    # the travel_z (z_move)
                                    self.z_move = self.exc_tools[tool]['data']['tools_drill_travelz']
                                    gcode += self.doformat(p.lift_code, x=locx, y=locy)
                                else:
                                    # move to next point
                                    gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                            # store prev_z
                            prev_z = travel[0]

                        # gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                        if self.multidepth and abs(self.z_cut) > abs(self.z_depthpercut):
                            doc = deepcopy(self.z_cut)
                            self.z_cut = 0.0

                            while abs(self.z_cut) < abs(doc):

                                self.z_cut -= self.z_depthpercut
                                if abs(doc) < abs(self.z_cut) < (abs(doc) + self.z_depthpercut):
                                    self.z_cut = doc
                                gcode += self.doformat(p.down_code, x=locx, y=locy)

                                measured_down_distance += abs(self.z_cut) + abs(self.z_move)

                                if self.f_retract is False:
                                    gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
                                    measured_up_to_zero_distance += abs(self.z_cut)
                                    measured_lift_distance += abs(self.z_move)
                                else:
                                    measured_lift_distance += abs(self.z_cut) + abs(self.z_move)

                                gcode += self.doformat(p.lift_code, x=locx, y=locy)

                        else:
                            gcode += self.doformat(p.down_code, x=locx, y=locy)

                            measured_down_distance += abs(self.z_cut) + abs(self.z_move)

                            if self.f_retract is False:
                                gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
                                measured_up_to_zero_distance += abs(self.z_cut)
                                measured_lift_distance += abs(self.z_move)
                            else:
                                measured_lift_distance += abs(self.z_cut) + abs(self.z_move)

                            gcode += self.doformat(p.lift_code, x=locx, y=locy)

                        measured_distance += abs(distance_euclidian(locx, locy, self.oldx, self.oldy))
                        self.oldx = locx
                        self.oldy = locy

                        loc_nr += 1
                        disp_number = int(np.interp(loc_nr, [0, geo_len], [0, 100]))

                        if old_disp_number < disp_number <= 100:
                            self.app.proc_container.update_view_text(' %d%%' % disp_number)
                            old_disp_number = disp_number

                else:
                    self.app.inform.emit('[ERROR_NOTCL] %s...' % _('G91 coordinates not implemented'))
                    return 'fail'
                self.z_cut = deepcopy(old_zcut)
        else:
            # We are not using Toolchange therefore we need to decide which tool properties to use
            one_tool = 1

            all_points = []
            for tool in points:
                # check if it has drills
                if not points[tool]:
                    continue
                all_points += points[tool]

            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            self.tool = one_tool
            self.tooldia = self.exc_tools[one_tool]["tooldia"]
            self.postdata['toolC'] = self.tooldia

            if self.use_ui:
                self.z_feedrate = self.exc_tools[one_tool]['data']['tools_drill_feedrate_z']
                self.feedrate = self.exc_tools[one_tool]['data']['tools_drill_feedrate_z']
                self.z_cut = self.exc_tools[one_tool]['data']['tools_drill_cutz']
                gcode += self.doformat(p.z_feedrate_code)

                if self.machinist_setting == 0:
                    if self.z_cut > 0:
                        self.app.inform.emit('[WARNING] %s' %
                                             _("The Cut Z parameter has positive value. "
                                               "It is the depth value to drill into material.\n"
                                               "The Cut Z parameter needs to have a negative value, "
                                               "assuming it is a typo "
                                               "therefore the app will convert the value to negative. "
                                               "Check the resulting CNC code (Gcode etc)."))
                        self.z_cut = -self.z_cut
                    elif self.z_cut == 0:
                        self.app.inform.emit('[WARNING] %s: %s' %
                                             (_(
                                                 "The Cut Z parameter is zero. There will be no cut, "
                                                 "skipping file"),
                                              exobj.options['name']))
                        return 'fail'

                old_zcut = deepcopy(self.z_cut)

                self.z_move = self.exc_tools[one_tool]['data']['tools_drill_travelz']
                self.spindlespeed = self.exc_tools[one_tool]['data']['tools_drill_spindlespeed']
                self.dwell = self.exc_tools[one_tool]['data']['tools_drill_dwell']
                self.dwelltime = self.exc_tools[one_tool]['data']['tools_drill_dwelltime']
                self.multidepth = self.exc_tools[one_tool]['data']['tools_drill_multidepth']
                self.z_depthpercut = self.exc_tools[one_tool]['data']['tools_drill_depthperpass']
            else:
                old_zcut = deepcopy(self.z_cut)

            # #########################################################################################################
            # ############ Create the data. #################
            # #########################################################################################################
            locations = []
            altPoints = []
            optimized_path = []

            if used_excellon_optimization_type == 'M':
                if all_points:
                    locations = self.create_tool_data_array(points=all_points)
                # if there are no locations then go to the next tool
                if not locations:
                    return 'fail'
                opt_time = self.app.defaults["excellon_search_time"]
                optimized_path = self.optimized_ortools_meta(locations=locations, opt_time=opt_time)
            elif used_excellon_optimization_type == 'B':
                if all_points:
                    locations = self.create_tool_data_array(points=all_points)
                # if there are no locations then go to the next tool
                if not locations:
                    return 'fail'
                optimized_path = self.optimized_ortools_basic(locations=locations)
            elif used_excellon_optimization_type == 'T':
                for point in all_points:
                    altPoints.append((point.coords.xy[0][0], point.coords.xy[1][0]))
                optimized_path = self.optimized_travelling_salesman(altPoints)
            else:
                # it's actually not optimized path but here we build a list of (x,y) coordinates
                # out of the tool's drills
                for pt in all_points:
                    unoptimized_coords = (
                        pt.x,
                        pt.y
                    )
                    optimized_path.append(unoptimized_coords)
            # #########################################################################################################
            # #########################################################################################################

            # Only if there are locations to drill
            if not optimized_path:
                return 'fail'

            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            # Spindle start
            gcode += self.doformat(p.spindle_code)
            # Dwell time
            if self.dwell is True:
                gcode += self.doformat(p.dwell_code)

            current_tooldia = float('%.*f' % (self.decimals, float(self.exc_tools[one_tool]["tooldia"])))

            self.app.inform.emit(
                '%s: %s%s.' % (_("Starting G-Code for tool with diameter"),
                               str(current_tooldia),
                               str(self.units))
            )

            # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            # APPLY Offset only when using the appGUI, for TclCommand this will create an error
            # because the values for Z offset are created in build_ui()
            # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            try:
                z_offset = float(self.exc_tools[one_tool]['data']['tools_drill_offset']) * (-1)
            except KeyError:
                z_offset = 0
            self.z_cut = z_offset + old_zcut

            self.coordinates_type = self.app.defaults["cncjob_coords_type"]
            if self.coordinates_type == "G90":
                # Drillling! for Absolute coordinates type G90
                # variables to display the percentage of work done
                geo_len = len(optimized_path)

                old_disp_number = 0
                log.warning("Number of drills for which to generate GCode: %s" % str(geo_len))

                loc_nr = 0
                for point in optimized_path:
                    if self.app.abort_flag:
                        # graceful abort requested by the user
                        raise grace

                    if used_excellon_optimization_type == 'T':
                        locx = point[0]
                        locy = point[1]
                    else:
                        locx = locations[point][0]
                        locy = locations[point][1]

                    travels = self.app.exc_areas.travel_coordinates(start_point=(self.oldx, self.oldy),
                                                                    end_point=(locx, locy),
                                                                    tooldia=current_tooldia)
                    prev_z = None
                    for travel in travels:
                        locx = travel[1][0]
                        locy = travel[1][1]

                        if travel[0] is not None:
                            # move to next point
                            gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                            # raise to safe Z (travel[0]) each time because safe Z may be different
                            self.z_move = travel[0]
                            gcode += self.doformat(p.lift_code, x=locx, y=locy)

                            # restore z_move
                            self.z_move = self.exc_tools[one_tool]['data']['tools_drill_travelz']
                        else:
                            if prev_z is not None:
                                # move to next point
                                gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                                # we assume that previously the z_move was altered therefore raise to
                                # the travel_z (z_move)
                                self.z_move = self.exc_tools[one_tool]['data']['tools_drill_travelz']
                                gcode += self.doformat(p.lift_code, x=locx, y=locy)
                            else:
                                # move to next point
                                gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                        # store prev_z
                        prev_z = travel[0]

                    # gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                    if self.multidepth and abs(self.z_cut) > abs(self.z_depthpercut):
                        doc = deepcopy(self.z_cut)
                        self.z_cut = 0.0

                        while abs(self.z_cut) < abs(doc):

                            self.z_cut -= self.z_depthpercut
                            if abs(doc) < abs(self.z_cut) < (abs(doc) + self.z_depthpercut):
                                self.z_cut = doc
                            gcode += self.doformat(p.down_code, x=locx, y=locy)

                            measured_down_distance += abs(self.z_cut) + abs(self.z_move)

                            if self.f_retract is False:
                                gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
                                measured_up_to_zero_distance += abs(self.z_cut)
                                measured_lift_distance += abs(self.z_move)
                            else:
                                measured_lift_distance += abs(self.z_cut) + abs(self.z_move)

                            gcode += self.doformat(p.lift_code, x=locx, y=locy)

                    else:
                        gcode += self.doformat(p.down_code, x=locx, y=locy)

                        measured_down_distance += abs(self.z_cut) + abs(self.z_move)

                        if self.f_retract is False:
                            gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
                            measured_up_to_zero_distance += abs(self.z_cut)
                            measured_lift_distance += abs(self.z_move)
                        else:
                            measured_lift_distance += abs(self.z_cut) + abs(self.z_move)

                        gcode += self.doformat(p.lift_code, x=locx, y=locy)

                    measured_distance += abs(distance_euclidian(locx, locy, self.oldx, self.oldy))
                    self.oldx = locx
                    self.oldy = locy

                    loc_nr += 1
                    disp_number = int(np.interp(loc_nr, [0, geo_len], [0, 100]))

                    if old_disp_number < disp_number <= 100:
                        self.app.proc_container.update_view_text(' %d%%' % disp_number)
                        old_disp_number = disp_number

            else:
                self.app.inform.emit('[ERROR_NOTCL] %s...' % _('G91 coordinates not implemented'))
                return 'fail'
            self.z_cut = deepcopy(old_zcut)

        if used_excellon_optimization_type == 'M':
            log.debug("The total travel distance with OR-TOOLS Metaheuristics is: %s" % str(measured_distance))
        elif used_excellon_optimization_type == 'B':
            log.debug("The total travel distance with OR-TOOLS Basic Algorithm is: %s" % str(measured_distance))
        elif used_excellon_optimization_type == 'T':
            log.debug("The total travel distance with Travelling Salesman Algorithm is: %s" % str(measured_distance))
        else:
            log.debug("The total travel distance with with no optimization is: %s" % str(measured_distance))

        # if used_excellon_optimization_type == 'M':
        #     log.debug("Using OR-Tools Metaheuristic Guided Local Search drill path optimization.")
        #
        #     if has_drills:
        #         for tool in tools:
        #             if self.app.abort_flag:
        #                 # graceful abort requested by the user
        #                 raise grace
        #
        #             self.tool = tool
        #             self.tooldia = self.exc_tools[tool]["tooldia"]
        #             self.postdata['toolC'] = self.tooldia
        #
        #             if self.use_ui:
        #                 self.z_feedrate = self.exc_tools[tool]['data']['feedrate_z']
        #                 self.feedrate = self.exc_tools[tool]['data']['feedrate']
        #                 gcode += self.doformat(p.z_feedrate_code)
        #                 self.z_cut = self.exc_tools[tool]['data']['cutz']
        #
        #                 if self.machinist_setting == 0:
        #                     if self.z_cut > 0:
        #                         self.app.inform.emit('[WARNING] %s' %
        #                                              _("The Cut Z parameter has positive value. "
        #                                                "It is the depth value to drill into material.\n"
        #                                                "The Cut Z parameter needs to have a negative value, "
        #                                                "assuming it is a typo "
        #                                                "therefore the app will convert the value to negative. "
        #                                                "Check the resulting CNC code (Gcode etc)."))
        #                         self.z_cut = -self.z_cut
        #                     elif self.z_cut == 0:
        #                         self.app.inform.emit('[WARNING] %s: %s' %
        #                                              (_(
        #                                                  "The Cut Z parameter is zero. There will be no cut, "
        #                                                  "skipping file"),
        #                                               exobj.options['name']))
        #                         return 'fail'
        #
        #                 old_zcut = deepcopy(self.z_cut)
        #
        #                 self.z_move = self.exc_tools[tool]['data']['travelz']
        #                 self.spindlespeed = self.exc_tools[tool]['data']['spindlespeed']
        #                 self.dwell = self.exc_tools[tool]['data']['dwell']
        #                 self.dwelltime = self.exc_tools[tool]['data']['dwelltime']
        #                 self.multidepth = self.exc_tools[tool]['data']['multidepth']
        #                 self.z_depthpercut = self.exc_tools[tool]['data']['depthperpass']
        #             else:
        #                 old_zcut = deepcopy(self.z_cut)
        #
        #             # ###############################################
        #             # ############ Create the data. #################
        #             # ###############################################
        #             locations = self.create_tool_data_array(tool=tool, points=points)
        #             # if there are no locations then go to the next tool
        #             if not locations:
        #                 continue
        #             optimized_path = self.optimized_ortools_meta(locations=locations)
        #
        #             # Only if tool has points.
        #             if tool in points:
        #                 if self.app.abort_flag:
        #                     # graceful abort requested by the user
        #                     raise grace
        #
        #                 # Tool change sequence (optional)
        #                 if self.toolchange:
        #                     gcode += self.doformat(p.toolchange_code, toolchangexy=(self.oldx, self.oldy))
        #                 # Spindle start
        #                 gcode += self.doformat(p.spindle_code)
        #                 # Dwell time
        #                 if self.dwell is True:
        #                     gcode += self.doformat(p.dwell_code)
        #
        #                 current_tooldia = float('%.*f' % (self.decimals, float(self.exc_tools[tool]["tooldia"])))
        #
        #                 self.app.inform.emit(
        #                     '%s: %s%s.' % (_("Starting G-Code for tool with diameter"),
        #                                    str(current_tooldia),
        #                                    str(self.units))
        #                 )
        #
        #                 # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        #                 # APPLY Offset only when using the appGUI, for TclCommand this will create an error
        #                 # because the values for Z offset are created in build_ui()
        #                 # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        #                 try:
        #                     z_offset = float(self.exc_tools[tool]['data']['offset']) * (-1)
        #                 except KeyError:
        #                     z_offset = 0
        #                 self.z_cut = z_offset + old_zcut
        #
        #                 self.coordinates_type = self.app.defaults["cncjob_coords_type"]
        #                 if self.coordinates_type == "G90":
        #                     # Drillling! for Absolute coordinates type G90
        #                     # variables to display the percentage of work done
        #                     geo_len = len(optimized_path)
        #
        #                     old_disp_number = 0
        #                     log.warning("Number of drills for which to generate GCode: %s" % str(geo_len))
        #
        #                     loc_nr = 0
        #                     for k in optimized_path:
        #                         if self.app.abort_flag:
        #                             # graceful abort requested by the user
        #                             raise grace
        #
        #                         locx = locations[k][0]
        #                         locy = locations[k][1]
        #
        #                         travels = self.app.exc_areas.travel_coordinates(start_point=(self.oldx, self.oldy),
        #                                                                         end_point=(locx, locy),
        #                                                                         tooldia=current_tooldia)
        #                         prev_z = None
        #                         for travel in travels:
        #                             locx = travel[1][0]
        #                             locy = travel[1][1]
        #
        #                             if travel[0] is not None:
        #                                 # move to next point
        #                                 gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                                 # raise to safe Z (travel[0]) each time because safe Z may be different
        #                                 self.z_move = travel[0]
        #                                 gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #
        #                                 # restore z_move
        #                                 self.z_move = self.exc_tools[tool]['data']['travelz']
        #                             else:
        #                                 if prev_z is not None:
        #                                     # move to next point
        #                                     gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                                     # we assume that previously the z_move was altered therefore raise to
        #                                     # the travel_z (z_move)
        #                                     self.z_move = self.exc_tools[tool]['data']['travelz']
        #                                     gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #                                 else:
        #                                     # move to next point
        #                                     gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                             # store prev_z
        #                             prev_z = travel[0]
        #
        #                         # gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                         if self.multidepth and abs(self.z_cut) > abs(self.z_depthpercut):
        #                             doc = deepcopy(self.z_cut)
        #                             self.z_cut = 0.0
        #
        #                             while abs(self.z_cut) < abs(doc):
        #
        #                                 self.z_cut -= self.z_depthpercut
        #                                 if abs(doc) < abs(self.z_cut) < (abs(doc) + self.z_depthpercut):
        #                                     self.z_cut = doc
        #                                 gcode += self.doformat(p.down_code, x=locx, y=locy)
        #
        #                                 measured_down_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                                 if self.f_retract is False:
        #                                     gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
        #                                     measured_up_to_zero_distance += abs(self.z_cut)
        #                                     measured_lift_distance += abs(self.z_move)
        #                                 else:
        #                                     measured_lift_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                                 gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #
        #                         else:
        #                             gcode += self.doformat(p.down_code, x=locx, y=locy)
        #
        #                             measured_down_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                             if self.f_retract is False:
        #                                 gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
        #                                 measured_up_to_zero_distance += abs(self.z_cut)
        #                                 measured_lift_distance += abs(self.z_move)
        #                             else:
        #                                 measured_lift_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                             gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #
        #                         measured_distance += abs(distance_euclidian(locx, locy, self.oldx, self.oldy))
        #                         self.oldx = locx
        #                         self.oldy = locy
        #
        #                         loc_nr += 1
        #                         disp_number = int(np.interp(loc_nr, [0, geo_len], [0, 100]))
        #
        #                         if old_disp_number < disp_number <= 100:
        #                             self.app.proc_container.update_view_text(' %d%%' % disp_number)
        #                             old_disp_number = disp_number
        #
        #                 else:
        #                     self.app.inform.emit('[ERROR_NOTCL] %s...' % _('G91 coordinates not implemented'))
        #                     return 'fail'
        #             self.z_cut = deepcopy(old_zcut)
        #     else:
        #         log.debug("camlib.CNCJob.generate_from_excellon_by_tool() --> "
        #                   "The loaded Excellon file has no drills ...")
        #         self.app.inform.emit('[ERROR_NOTCL] %s...' % _('The loaded Excellon file has no drills'))
        #         return 'fail'
        #
        #     log.debug("The total travel distance with OR-TOOLS Metaheuristics is: %s" % str(measured_distance))
        #
        # elif used_excellon_optimization_type == 'B':
        #     log.debug("Using OR-Tools Basic drill path optimization.")
        #
        #     if has_drills:
        #         for tool in tools:
        #             if self.app.abort_flag:
        #                 # graceful abort requested by the user
        #                 raise grace
        #
        #             self.tool = tool
        #             self.tooldia = self.exc_tools[tool]["tooldia"]
        #             self.postdata['toolC'] = self.tooldia
        #
        #             if self.use_ui:
        #                 self.z_feedrate = self.exc_tools[tool]['data']['feedrate_z']
        #                 self.feedrate = self.exc_tools[tool]['data']['feedrate']
        #                 gcode += self.doformat(p.z_feedrate_code)
        #                 self.z_cut = self.exc_tools[tool]['data']['cutz']
        #
        #                 if self.machinist_setting == 0:
        #                     if self.z_cut > 0:
        #                         self.app.inform.emit('[WARNING] %s' %
        #                                              _("The Cut Z parameter has positive value. "
        #                                                "It is the depth value to drill into material.\n"
        #                                                "The Cut Z parameter needs to have a negative value, "
        #                                                "assuming it is a typo "
        #                                                "therefore the app will convert the value to negative. "
        #                                                "Check the resulting CNC code (Gcode etc)."))
        #                         self.z_cut = -self.z_cut
        #                     elif self.z_cut == 0:
        #                         self.app.inform.emit('[WARNING] %s: %s' %
        #                                              (_(
        #                                                  "The Cut Z parameter is zero. There will be no cut, "
        #                                                  "skipping file"),
        #                                               exobj.options['name']))
        #                         return 'fail'
        #
        #                 old_zcut = deepcopy(self.z_cut)
        #
        #                 self.z_move = self.exc_tools[tool]['data']['travelz']
        #
        #                 self.spindlespeed = self.exc_tools[tool]['data']['spindlespeed']
        #                 self.dwell = self.exc_tools[tool]['data']['dwell']
        #                 self.dwelltime = self.exc_tools[tool]['data']['dwelltime']
        #                 self.multidepth = self.exc_tools[tool]['data']['multidepth']
        #                 self.z_depthpercut = self.exc_tools[tool]['data']['depthperpass']
        #             else:
        #                 old_zcut = deepcopy(self.z_cut)
        #
        #             # ###############################################
        #             # ############ Create the data. #################
        #             # ###############################################
        #             locations = self.create_tool_data_array(tool=tool, points=points)
        #             # if there are no locations then go to the next tool
        #             if not locations:
        #                 continue
        #             optimized_path = self.optimized_ortools_basic(locations=locations)
        #
        #             # Only if tool has points.
        #             if tool in points:
        #                 if self.app.abort_flag:
        #                     # graceful abort requested by the user
        #                     raise grace
        #
        #                 # Tool change sequence (optional)
        #                 if self.toolchange:
        #                     gcode += self.doformat(p.toolchange_code, toolchangexy=(self.oldx, self.oldy))
        #                     gcode += self.doformat(p.spindle_code)  # Spindle start)
        #                     if self.dwell is True:
        #                         gcode += self.doformat(p.dwell_code)  # Dwell time
        #                 else:
        #                     gcode += self.doformat(p.spindle_code)
        #                     if self.dwell is True:
        #                         gcode += self.doformat(p.dwell_code)  # Dwell time
        #
        #                 current_tooldia = float('%.*f' % (self.decimals, float(self.exc_tools[tool]["tooldia"])))
        #
        #                 self.app.inform.emit(
        #                     '%s: %s%s.' % (_("Starting G-Code for tool with diameter"),
        #                                    str(current_tooldia),
        #                                    str(self.units))
        #                 )
        #
        #                 # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        #                 # APPLY Offset only when using the appGUI, for TclCommand this will create an error
        #                 # because the values for Z offset are created in build_ui()
        #                 # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        #                 try:
        #                     z_offset = float(self.exc_tools[tool]['data']['offset']) * (-1)
        #                 except KeyError:
        #                     z_offset = 0
        #                 self.z_cut = z_offset + old_zcut
        #
        #                 self.coordinates_type = self.app.defaults["cncjob_coords_type"]
        #                 if self.coordinates_type == "G90":
        #                     # Drillling! for Absolute coordinates type G90
        #                     # variables to display the percentage of work done
        #                     geo_len = len(optimized_path)
        #                     old_disp_number = 0
        #                     log.warning("Number of drills for which to generate GCode: %s" % str(geo_len))
        #
        #                     loc_nr = 0
        #                     for k in optimized_path:
        #                         if self.app.abort_flag:
        #                             # graceful abort requested by the user
        #                             raise grace
        #
        #                         locx = locations[k][0]
        #                         locy = locations[k][1]
        #
        #                         travels = self.app.exc_areas.travel_coordinates(start_point=(self.oldx, self.oldy),
        #                                                                         end_point=(locx, locy),
        #                                                                         tooldia=current_tooldia)
        #                         prev_z = None
        #                         for travel in travels:
        #                             locx = travel[1][0]
        #                             locy = travel[1][1]
        #
        #                             if travel[0] is not None:
        #                                 # move to next point
        #                                 gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                                 # raise to safe Z (travel[0]) each time because safe Z may be different
        #                                 self.z_move = travel[0]
        #                                 gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #
        #                                 # restore z_move
        #                                 self.z_move = self.exc_tools[tool]['data']['travelz']
        #                             else:
        #                                 if prev_z is not None:
        #                                     # move to next point
        #                                     gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                                     # we assume that previously the z_move was altered therefore raise to
        #                                     # the travel_z (z_move)
        #                                     self.z_move = self.exc_tools[tool]['data']['travelz']
        #                                     gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #                                 else:
        #                                     # move to next point
        #                                     gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                             # store prev_z
        #                             prev_z = travel[0]
        #
        #                         # gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                         if self.multidepth and abs(self.z_cut) > abs(self.z_depthpercut):
        #                             doc = deepcopy(self.z_cut)
        #                             self.z_cut = 0.0
        #
        #                             while abs(self.z_cut) < abs(doc):
        #
        #                                 self.z_cut -= self.z_depthpercut
        #                                 if abs(doc) < abs(self.z_cut) < (abs(doc) + self.z_depthpercut):
        #                                     self.z_cut = doc
        #                                 gcode += self.doformat(p.down_code, x=locx, y=locy)
        #
        #                                 measured_down_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                                 if self.f_retract is False:
        #                                     gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
        #                                     measured_up_to_zero_distance += abs(self.z_cut)
        #                                     measured_lift_distance += abs(self.z_move)
        #                                 else:
        #                                     measured_lift_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                                 gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #
        #                         else:
        #                             gcode += self.doformat(p.down_code, x=locx, y=locy)
        #
        #                             measured_down_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                             if self.f_retract is False:
        #                                 gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
        #                                 measured_up_to_zero_distance += abs(self.z_cut)
        #                                 measured_lift_distance += abs(self.z_move)
        #                             else:
        #                                 measured_lift_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                             gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #
        #                         measured_distance += abs(distance_euclidian(locx, locy, self.oldx, self.oldy))
        #                         self.oldx = locx
        #                         self.oldy = locy
        #
        #                         loc_nr += 1
        #                         disp_number = int(np.interp(loc_nr, [0, geo_len], [0, 100]))
        #
        #                         if old_disp_number < disp_number <= 100:
        #                             self.app.proc_container.update_view_text(' %d%%' % disp_number)
        #                             old_disp_number = disp_number
        #
        #                 else:
        #                     self.app.inform.emit('[ERROR_NOTCL] %s...' % _('G91 coordinates not implemented'))
        #                     return 'fail'
        #             self.z_cut = deepcopy(old_zcut)
        #     else:
        #         log.debug("camlib.CNCJob.generate_from_excellon_by_tool() --> "
        #                   "The loaded Excellon file has no drills ...")
        #         self.app.inform.emit('[ERROR_NOTCL] %s...' % _('The loaded Excellon file has no drills'))
        #         return 'fail'
        #
        #     log.debug("The total travel distance with OR-TOOLS Basic Algorithm is: %s" % str(measured_distance))
        #
        # elif used_excellon_optimization_type == 'T':
        #     log.debug("Using Travelling Salesman drill path optimization.")
        #
        #     for tool in tools:
        #         if self.app.abort_flag:
        #             # graceful abort requested by the user
        #             raise grace
        #
        #         if has_drills:
        #             self.tool = tool
        #             self.tooldia = self.exc_tools[tool]["tooldia"]
        #             self.postdata['toolC'] = self.tooldia
        #
        #             if self.use_ui:
        #                 self.z_feedrate = self.exc_tools[tool]['data']['feedrate_z']
        #                 self.feedrate = self.exc_tools[tool]['data']['feedrate']
        #                 gcode += self.doformat(p.z_feedrate_code)
        #
        #                 self.z_cut = self.exc_tools[tool]['data']['cutz']
        #
        #                 if self.machinist_setting == 0:
        #                     if self.z_cut > 0:
        #                         self.app.inform.emit('[WARNING] %s' %
        #                                              _("The Cut Z parameter has positive value. "
        #                                                "It is the depth value to drill into material.\n"
        #                                                "The Cut Z parameter needs to have a negative value, "
        #                                                "assuming it is a typo "
        #                                                "therefore the app will convert the value to negative. "
        #                                                "Check the resulting CNC code (Gcode etc)."))
        #                         self.z_cut = -self.z_cut
        #                     elif self.z_cut == 0:
        #                         self.app.inform.emit('[WARNING] %s: %s' %
        #                                              (_(
        #                                                  "The Cut Z parameter is zero. There will be no cut, "
        #                                                  "skipping file"),
        #                                               exobj.options['name']))
        #                         return 'fail'
        #
        #                 old_zcut = deepcopy(self.z_cut)
        #
        #                 self.z_move = self.exc_tools[tool]['data']['travelz']
        #                 self.spindlespeed = self.exc_tools[tool]['data']['spindlespeed']
        #                 self.dwell = self.exc_tools[tool]['data']['dwell']
        #                 self.dwelltime = self.exc_tools[tool]['data']['dwelltime']
        #                 self.multidepth = self.exc_tools[tool]['data']['multidepth']
        #                 self.z_depthpercut = self.exc_tools[tool]['data']['depthperpass']
        #             else:
        #                 old_zcut = deepcopy(self.z_cut)
        #
        #             # ###############################################
        #             # ############ Create the data. #################
        #             # ###############################################
        #             altPoints = []
        #             for point in points[tool]:
        #                 altPoints.append((point.coords.xy[0][0], point.coords.xy[1][0]))
        #             optimized_path = self.optimized_travelling_salesman(altPoints)
        #
        #             # Only if tool has points.
        #             if tool in points:
        #                 if self.app.abort_flag:
        #                     # graceful abort requested by the user
        #                     raise grace
        #
        #                 # Tool change sequence (optional)
        #                 if self.toolchange:
        #                     gcode += self.doformat(p.toolchange_code, toolchangexy=(self.oldx, self.oldy))
        #                     gcode += self.doformat(p.spindle_code)  # Spindle start)
        #                     if self.dwell is True:
        #                         gcode += self.doformat(p.dwell_code)  # Dwell time
        #                 else:
        #                     gcode += self.doformat(p.spindle_code)
        #                     if self.dwell is True:
        #                         gcode += self.doformat(p.dwell_code)  # Dwell time
        #
        #                 current_tooldia = float('%.*f' % (self.decimals, float(self.exc_tools[tool]["tooldia"])))
        #
        #                 self.app.inform.emit(
        #                     '%s: %s%s.' % (_("Starting G-Code for tool with diameter"),
        #                                    str(current_tooldia),
        #                                    str(self.units))
        #                 )
        #
        #                 # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        #                 # APPLY Offset only when using the appGUI, for TclCommand this will create an error
        #                 # because the values for Z offset are created in build_ui()
        #                 # !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        #                 try:
        #                     z_offset = float(self.exc_tools[tool]['data']['offset']) * (-1)
        #                 except KeyError:
        #                     z_offset = 0
        #                 self.z_cut = z_offset + old_zcut
        #
        #                 self.coordinates_type = self.app.defaults["cncjob_coords_type"]
        #                 if self.coordinates_type == "G90":
        #                     # Drillling! for Absolute coordinates type G90
        #                     # variables to display the percentage of work done
        #                     geo_len = len(optimized_path)
        #                     old_disp_number = 0
        #                     log.warning("Number of drills for which to generate GCode: %s" % str(geo_len))
        #
        #                     loc_nr = 0
        #                     for point in optimized_path:
        #                         if self.app.abort_flag:
        #                             # graceful abort requested by the user
        #                             raise grace
        #
        #                         locx = point[0]
        #                         locy = point[1]
        #
        #                         travels = self.app.exc_areas.travel_coordinates(start_point=(self.oldx, self.oldy),
        #                                                                         end_point=(locx, locy),
        #                                                                         tooldia=current_tooldia)
        #                         prev_z = None
        #                         for travel in travels:
        #                             locx = travel[1][0]
        #                             locy = travel[1][1]
        #
        #                             if travel[0] is not None:
        #                                 # move to next point
        #                                 gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                                 # raise to safe Z (travel[0]) each time because safe Z may be different
        #                                 self.z_move = travel[0]
        #                                 gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #
        #                                 # restore z_move
        #                                 self.z_move = self.exc_tools[tool]['data']['travelz']
        #                             else:
        #                                 if prev_z is not None:
        #                                     # move to next point
        #                                     gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                                     # we assume that previously the z_move was altered therefore raise to
        #                                     # the travel_z (z_move)
        #                                     self.z_move = self.exc_tools[tool]['data']['travelz']
        #                                     gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #                                 else:
        #                                     # move to next point
        #                                     gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                             # store prev_z
        #                             prev_z = travel[0]
        #
        #                         # gcode += self.doformat(p.rapid_code, x=locx, y=locy)
        #
        #                         if self.multidepth and abs(self.z_cut) > abs(self.z_depthpercut):
        #                             doc = deepcopy(self.z_cut)
        #                             self.z_cut = 0.0
        #
        #                             while abs(self.z_cut) < abs(doc):
        #
        #                                 self.z_cut -= self.z_depthpercut
        #                                 if abs(doc) < abs(self.z_cut) < (abs(doc) + self.z_depthpercut):
        #                                     self.z_cut = doc
        #                                 gcode += self.doformat(p.down_code, x=locx, y=locy)
        #
        #                                 measured_down_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                                 if self.f_retract is False:
        #                                     gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
        #                                     measured_up_to_zero_distance += abs(self.z_cut)
        #                                     measured_lift_distance += abs(self.z_move)
        #                                 else:
        #                                     measured_lift_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                                 gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #
        #                         else:
        #                             gcode += self.doformat(p.down_code, x=locx, y=locy)
        #
        #                             measured_down_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                             if self.f_retract is False:
        #                                 gcode += self.doformat(p.up_to_zero_code, x=locx, y=locy)
        #                                 measured_up_to_zero_distance += abs(self.z_cut)
        #                                 measured_lift_distance += abs(self.z_move)
        #                             else:
        #                                 measured_lift_distance += abs(self.z_cut) + abs(self.z_move)
        #
        #                             gcode += self.doformat(p.lift_code, x=locx, y=locy)
        #
        #                         measured_distance += abs(distance_euclidian(locx, locy, self.oldx, self.oldy))
        #                         self.oldx = locx
        #                         self.oldy = locy
        #
        #                         loc_nr += 1
        #                         disp_number = int(np.interp(loc_nr, [0, geo_len], [0, 100]))
        #
        #                         if old_disp_number < disp_number <= 100:
        #                             self.app.proc_container.update_view_text(' %d%%' % disp_number)
        #                             old_disp_number = disp_number
        #                 else:
        #                     self.app.inform.emit('[ERROR_NOTCL] %s...' % _('G91 coordinates not implemented'))
        #                     return 'fail'
        #             else:
        #                 log.debug("camlib.CNCJob.generate_from_excellon_by_tool() --> "
        #                           "The loaded Excellon file has no drills ...")
        #                 self.app.inform.emit('[ERROR_NOTCL] %s...' % _('The loaded Excellon file has no drills'))
        #                 return 'fail'
        #         self.z_cut = deepcopy(old_zcut)
        #     log.debug("The total travel distance with Travelling Salesman Algorithm is: %s" % str(measured_distance))
        #
        # else:
        #     log.debug("camlib.CNCJob.generate_from_excellon_by_tool(): Chosen drill optimization doesn't exist.")
        #     return 'fail'

        # Spindle stop
        gcode += self.doformat(p.spindle_stop_code)
        # Move to End position
        gcode += self.doformat(p.end_code, x=0, y=0)

        # #############################################################################################################
        # ############################# Calculate DISTANCE and ESTIMATED TIME #########################################
        # #############################################################################################################
        measured_distance += abs(distance_euclidian(self.oldx, self.oldy, 0, 0))
        log.debug("The total travel distance including travel to end position is: %s" %
                  str(measured_distance) + '\n')
        self.travel_distance = measured_distance

        # I use the value of self.feedrate_rapid for the feadrate in case of the measure_lift_distance and for
        # traveled_time because it is not always possible to determine the feedrate that the CNC machine uses
        # for G0 move (the fastest speed available to the CNC router). Although self.feedrate_rapids is used only with
        # Marlin preprocessor and derivatives.
        self.routing_time = (measured_down_distance + measured_up_to_zero_distance) / self.feedrate
        lift_time = measured_lift_distance / self.feedrate_rapid
        traveled_time = measured_distance / self.feedrate_rapid
        self.routing_time += lift_time + traveled_time

        # #############################################################################################################
        # ############################# Store the GCODE for further usage ############################################
        # #############################################################################################################
        self.gcode = gcode

        self.app.inform.emit(_("Finished G-Code generation..."))
        return gcode, start_gcode

    # no longer used
    def generate_from_multitool_geometry(self, geometry, append=True, tooldia=None, offset=0.0, tolerance=0, z_cut=1.0,
                                         z_move=2.0, feedrate=2.0, feedrate_z=2.0, feedrate_rapid=30,
                                         spindlespeed=None, spindledir='CW', dwell=False, dwelltime=1.0,
                                         multidepth=False, depthpercut=None, toolchange=False, toolchangez=1.0,
                                         toolchangexy="0.0, 0.0", extracut=False, extracut_length=0.2,
                                         startz=None, endz=2.0, endxy='', pp_geometry_name=None, tool_no=1):
        """
        Algorithm to generate from multitool Geometry.

        Algorithm description:
        ----------------------
        Uses RTree to find the nearest path to follow.

        :param geometry:
        :param append:
        :param tooldia:
        :param offset:
        :param tolerance:
        :param z_cut:
        :param z_move:
        :param feedrate:
        :param feedrate_z:
        :param feedrate_rapid:
        :param spindlespeed:
        :param spindledir:          Direction of rotation for the spindle. If using GRBL laser mode will
        adjust the laser mode

        :param dwell:
        :param dwelltime:
        :param multidepth:          If True, use multiple passes to reach the desired depth.
        :param depthpercut:         Maximum depth in each pass.
        :param toolchange:
        :param toolchangez:
        :param toolchangexy:
        :param extracut:            Adds (or not) an extra cut at the end of each path overlapping the
                                    first point in path to ensure complete copper removal
        :param extracut_length:     Extra cut legth at the end of the path
        :param startz:
        :param endz:
        :param endxy:
        :param pp_geometry_name:
        :param tool_no:
        :return:                    GCode - string
        """

        log.debug("generate_from_multitool_geometry()")

        temp_solid_geometry = []
        if offset != 0.0:
            for it in geometry:
                # if the geometry is a closed shape then create a Polygon out of it
                if isinstance(it, LineString):
                    c = it.coords
                    if c[0] == c[-1]:
                        it = Polygon(it)
                temp_solid_geometry.append(it.buffer(offset, join_style=2))
        else:
            temp_solid_geometry = geometry

        # ## Flatten the geometry. Only linear elements (no polygons) remain.
        flat_geometry = self.flatten(temp_solid_geometry, pathonly=True)
        log.debug("%d paths" % len(flat_geometry))

        try:
            self.tooldia = float(tooldia)
        except Exception as e:
            self.app.inform.emit('[ERROR] %s\n%s' % (_("Failed."), str(e)))
            return 'fail'

        self.z_cut = float(z_cut) if z_cut else None
        self.z_move = float(z_move) if z_move is not None else None

        self.feedrate = float(feedrate) if feedrate else  self.app.defaults["geometry_feedrate"]
        self.z_feedrate = float(feedrate_z) if feedrate_z is not None else self.app.defaults["geometry_feedrate_z"]
        self.feedrate_rapid = float(feedrate_rapid) if feedrate_rapid else self.app.defaults["geometry_feedrate_rapid"]

        self.spindlespeed = int(spindlespeed) if spindlespeed != 0 else None
        self.spindledir = spindledir
        self.dwell = dwell
        self.dwelltime = float(dwelltime) if dwelltime else  self.app.defaults["geometry_dwelltime"]

        self.startz = float(startz) if startz is not None else  self.app.defaults["geometry_startz"]
        self.z_end = float(endz) if endz is not None else  self.app.defaults["geometry_endz"]

        self.xy_end = re.sub('[()\[\]]', '', str(endxy)) if endxy else  self.app.defaults["geometry_endxy"]

        if self.xy_end and self.xy_end != '':
            self.xy_end = [float(eval(a)) for a in self.xy_end.split(",")]

        if self.xy_end and len(self.xy_end) < 2:
            self.app.inform.emit('[ERROR]  %s' % _("The End Move X,Y field in Edit -> Preferences has to be "
                                                   "in the format (x, y) but now there is only one value, not two."))
            return 'fail'

        self.z_depthpercut = float(depthpercut) if depthpercut else self.app.defaults["geometry_depthperpass"]
        self.multidepth = multidepth

        self.z_toolchange = float(toolchangez) if toolchangez is not None else self.app.defaults["geometry_toolchangez"]

        # it servers in the preprocessor file
        self.tool = tool_no

        try:
            if toolchangexy == '':
                self.xy_toolchange = None
            else:
                self.xy_toolchange = re.sub('[()\[\]]', '', str(toolchangexy)) \
                    if toolchangexy else self.app.defaults["geometry_toolchangexy"]

                if self.xy_toolchange and self.xy_toolchange != '':
                    self.xy_toolchange = [float(eval(a)) for a in self.xy_toolchange.split(",")]

                if len(self.xy_toolchange) < 2:
                    self.app.inform.emit('[ERROR]  %s' % _("The Toolchange X,Y field in Edit -> Preferences has to be "
                                                           "in the format (x, y) \n"
                                                           "but now there is only one value, not two."))
                    return 'fail'
        except Exception as e:
            log.debug("camlib.CNCJob.generate_from_multitool_geometry() --> %s" % str(e))
            pass

        self.pp_geometry_name = pp_geometry_name if pp_geometry_name else 'default'
        self.f_plunge = self.app.defaults["geometry_f_plunge"]

        if self.z_cut is None:
            if 'laser' not in self.pp_geometry_name:
                self.app.inform.emit(
                    '[ERROR_NOTCL] %s' % _("Cut_Z parameter is None or zero. Most likely a bad combinations of "
                                           "other parameters."))
                return 'fail'
            else:
                self.z_cut = 0

        if self.machinist_setting == 0:
            if self.z_cut > 0:
                self.app.inform.emit('[WARNING] %s' %
                                     _("The Cut Z parameter has positive value. "
                                       "It is the depth value to cut into material.\n"
                                       "The Cut Z parameter needs to have a negative value, assuming it is a typo "
                                       "therefore the app will convert the value to negative."
                                       "Check the resulting CNC code (Gcode etc)."))
                self.z_cut = -self.z_cut
            elif self.z_cut == 0 and 'laser' not in self.pp_geometry_name:
                self.app.inform.emit('[WARNING] %s: %s' %
                                     (_("The Cut Z parameter is zero. There will be no cut, skipping file"),
                                      self.options['name']))
                return 'fail'

            if self.z_move is None:
                self.app.inform.emit('[ERROR_NOTCL] %s' % _("Travel Z parameter is None or zero."))
                return 'fail'

            if self.z_move < 0:
                self.app.inform.emit('[WARNING] %s' %
                                     _("The Travel Z parameter has negative value. "
                                       "It is the height value to travel between cuts.\n"
                                       "The Z Travel parameter needs to have a positive value, assuming it is a typo "
                                       "therefore the app will convert the value to positive."
                                       "Check the resulting CNC code (Gcode etc)."))
                self.z_move = -self.z_move
            elif self.z_move == 0:
                self.app.inform.emit('[WARNING] %s: %s' %
                                     (_("The Z Travel parameter is zero. This is dangerous, skipping file"),
                                      self.options['name']))
                return 'fail'

        # made sure that depth_per_cut is no more then the z_cut
        if abs(self.z_cut) < self.z_depthpercut:
            self.z_depthpercut = abs(self.z_cut)

        # ## Index first and last points in paths
        # What points to index.
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        # Create the indexed storage.
        storage = FlatCAMRTreeStorage()
        storage.get_points = get_pts

        # Store the geometry
        log.debug("Indexing geometry before generating G-Code...")
        self.app.inform.emit(_("Indexing geometry before generating G-Code..."))

        for geo_shape in flat_geometry:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            if geo_shape is not None:
                storage.insert(geo_shape)

        # self.input_geometry_bounds = geometry.bounds()

        if not append:
            self.gcode = ""

        # tell preprocessor the number of tool (for toolchange)
        self.tool = tool_no

        # this is the tool diameter, it is used as such to accommodate the preprocessor who need the tool diameter
        # given under the name 'toolC'
        self.postdata['toolC'] = self.tooldia

        # Initial G-Code
        self.pp_geometry = self.app.preprocessors[self.pp_geometry_name]
        p = self.pp_geometry

        self.gcode = self.doformat(p.start_code)

        self.gcode += self.doformat(p.feedrate_code)  # sets the feed rate

        if toolchange is False:
            self.gcode += self.doformat(p.lift_code, x=0, y=0)  # Move (up) to travel height
            self.gcode += self.doformat(p.startz_code, x=0, y=0)

        if toolchange:
            # if "line_xyz" in self.pp_geometry_name:
            #     self.gcode += self.doformat(p.toolchange_code, x=self.xy_toolchange[0], y=self.xy_toolchange[1])
            # else:
            #     self.gcode += self.doformat(p.toolchange_code)
            self.gcode += self.doformat(p.toolchange_code)

            if 'laser' not in self.pp_geometry_name:
                self.gcode += self.doformat(p.spindle_code)  # Spindle start
            else:
                # for laser this will disable the laser
                self.gcode += self.doformat(p.lift_code, x=self.oldx, y=self.oldy)  # Move (up) to travel height

            if self.dwell is True:
                self.gcode += self.doformat(p.dwell_code)  # Dwell time
        else:
            if 'laser' not in self.pp_geometry_name:
                self.gcode += self.doformat(p.spindle_code)  # Spindle start

            if self.dwell is True:
                self.gcode += self.doformat(p.dwell_code)  # Dwell time

        total_travel = 0.0
        total_cut = 0.0

        # ## Iterate over geometry paths getting the nearest each time.
        log.debug("Starting G-Code...")
        self.app.inform.emit('%s...' % _("Starting G-Code"))

        path_count = 0
        current_pt = (0, 0)

        # variables to display the percentage of work done
        geo_len = len(flat_geometry)

        old_disp_number = 0
        log.warning("Number of paths for which to generate GCode: %s" % str(geo_len))

        current_tooldia = float('%.*f' % (self.decimals, float(self.tooldia)))

        self.app.inform.emit('%s: %s%s.' % (_("Starting G-Code for tool with diameter"),
                                            str(current_tooldia),
                                            str(self.units)))

        pt, geo = storage.nearest(current_pt)

        try:
            while True:
                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace

                path_count += 1

                # Remove before modifying, otherwise deletion will fail.
                storage.remove(geo)

                # If last point in geometry is the nearest but prefer the first one if last point == first point
                # then reverse coordinates.
                if pt != geo.coords[0] and pt == geo.coords[-1]:
                    # geo.coords = list(geo.coords)[::-1] # Shapley 2.0
                    geo = LineString(list(geo.coords)[::-1])

                # ---------- Single depth/pass --------
                if not multidepth:
                    # calculate the cut distance
                    total_cut = total_cut + geo.length

                    self.gcode += self.create_gcode_single_pass(geo, current_tooldia, extracut, extracut_length,
                                                                tolerance, z_move=z_move, old_point=current_pt)

                # --------- Multi-pass ---------
                else:
                    # calculate the cut distance
                    # due of the number of cuts (multi depth) it has to multiplied by the number of cuts
                    nr_cuts = 0
                    depth = abs(self.z_cut)
                    while depth > 0:
                        nr_cuts += 1
                        depth -= float(self.z_depthpercut)

                    total_cut += (geo.length * nr_cuts)

                    gc, geo = self.create_gcode_multi_pass(geo, current_tooldia, extracut, extracut_length,
                                                           tolerance,  z_move=z_move, postproc=p,
                                                           old_point=current_pt)
                    self.gcode += gc

                # calculate the total distance
                total_travel = total_travel + abs(distance(pt1=current_pt, pt2=pt))
                current_pt = geo.coords[-1]

                pt, geo = storage.nearest(current_pt)  # Next

                disp_number = int(np.interp(path_count, [0, geo_len], [0, 100]))
                if old_disp_number < disp_number <= 100:
                    self.app.proc_container.update_view_text(' %d%%' % disp_number)
                    old_disp_number = disp_number
        except StopIteration:  # Nothing found in storage.
            pass

        log.debug("Finished G-Code... %s paths traced." % path_count)

        # add move to end position
        total_travel += abs(distance_euclidian(current_pt[0], current_pt[1], 0, 0))
        self.travel_distance += total_travel + total_cut
        self.routing_time += total_cut / self.feedrate

        # Finish
        self.gcode += self.doformat(p.spindle_stop_code)
        self.gcode += self.doformat(p.lift_code, x=current_pt[0], y=current_pt[1])
        self.gcode += self.doformat(p.end_code, x=0, y=0)
        self.app.inform.emit(
            '%s... %s %s.' % (_("Finished G-Code generation"), str(path_count), _("paths traced"))
        )
        return self.gcode

    def generate_from_geometry_2(self, geometry, append=True, tooldia=None, offset=0.0, tolerance=0, z_cut=None,
                                 z_move=None, feedrate=None, feedrate_z=None, feedrate_rapid=None, spindlespeed=None,
                                 spindledir='CW', dwell=False, dwelltime=None, multidepth=False, depthpercut=None,
                                 toolchange=False, toolchangez=None, toolchangexy="0.0, 0.0", extracut=False,
                                 extracut_length=None, startz=None, endz=None, endxy='', pp_geometry_name=None,
                                 tool_no=1, is_first=False):
        """
        Second algorithm to generate from Geometry.

        Algorithm description:
        ----------------------
        Uses RTree to find the nearest path to follow.

        :param geometry:
        :param append:
        :param tooldia:
        :param offset:
        :param tolerance:
        :param z_cut:
        :param z_move:
        :param feedrate:
        :param feedrate_z:
        :param feedrate_rapid:
        :param spindlespeed:
        :param spindledir:
        :param dwell:
        :param dwelltime:
        :param multidepth:          If True, use multiple passes to reach the desired depth.
        :param depthpercut:         Maximum depth in each pass.
        :param toolchange:
        :param toolchangez:
        :param toolchangexy:
        :param extracut:            Adds (or not) an extra cut at the end of each path overlapping the first point in
                                    path to ensure complete copper removal
        :param extracut_length:     The extra cut length
        :param startz:
        :param endz:
        :param endxy:
        :param pp_geometry_name:
        :param tool_no:
        :param is_first:            if the processed tool is the first one and if we should process the start gcode
        :return:                    None
        """
        log.debug("Executing camlib.CNCJob.generate_from_geometry_2()")

        # if solid_geometry is empty raise an exception
        if not geometry.solid_geometry:
            self.app.inform.emit(
                '[ERROR_NOTCL] %s' % _("Trying to generate a CNC Job from a Geometry object without solid_geometry.")
            )
            return 'fail'

        def bounds_rec(obj):
            if type(obj) is list:
                minx = np.Inf
                miny = np.Inf
                maxx = -np.Inf
                maxy = -np.Inf

                for k in obj:
                    if type(k) is dict:
                        for key in k:
                            minx_, miny_, maxx_, maxy_ = bounds_rec(k[key])
                            minx = min(minx, minx_)
                            miny = min(miny, miny_)
                            maxx = max(maxx, maxx_)
                            maxy = max(maxy, maxy_)
                    else:
                        minx_, miny_, maxx_, maxy_ = bounds_rec(k)
                        minx = min(minx, minx_)
                        miny = min(miny, miny_)
                        maxx = max(maxx, maxx_)
                        maxy = max(maxy, maxy_)
                return minx, miny, maxx, maxy
            else:
                # it's a Shapely object, return it's bounds
                return obj.bounds

        # Create the solid geometry which will be used to generate GCode
        temp_solid_geometry = []
        if offset != 0.0:
            offset_for_use = offset

            if offset < 0:
                a, b, c, d = bounds_rec(geometry.solid_geometry)
                # if the offset is less than half of the total length or less than half of the total width of the
                # solid geometry it's obvious we can't do the offset
                if -offset > ((c - a) / 2) or -offset > ((d - b) / 2):
                    self.app.inform.emit(
                        '[ERROR_NOTCL] %s' %
                        _("The Tool Offset value is too negative to use for the current_geometry.\n"
                          "Raise the value (in module) and try again.")
                    )
                    return 'fail'
                # hack: make offset smaller by 0.0000000001 which is insignificant difference but allow the job
                # to continue
                elif -offset == ((c - a) / 2) or -offset == ((d - b) / 2):
                    offset_for_use = offset - 0.0000000001

            for it in geometry.solid_geometry:
                # if the geometry is a closed shape then create a Polygon out of it
                if isinstance(it, LineString):
                    c = it.coords
                    if c[0] == c[-1]:
                        it = Polygon(it)
                temp_solid_geometry.append(it.buffer(offset_for_use, join_style=2))
        else:
            temp_solid_geometry = geometry.solid_geometry

        # ## Flatten the geometry. Only linear elements (no polygons) remain.
        flat_geometry = self.flatten(temp_solid_geometry, pathonly=True)
        log.debug("%d paths" % len(flat_geometry))

        default_dia = None
        if isinstance(self.app.defaults["geometry_cnctooldia"], float):
            default_dia = self.app.defaults["geometry_cnctooldia"]
        else:
            try:
                tools_string = self.app.defaults["geometry_cnctooldia"].split(",")
                tools_diameters = [eval(a) for a in tools_string if a != '']
                default_dia = tools_diameters[0] if tools_diameters else 0.0
            except Exception as e:
                self.app.log.debug("camlib.CNCJob.generate_from_geometry_2() --> %s" % str(e))

        try:
            self.tooldia = float(tooldia) if tooldia else default_dia
        except ValueError:
            self.tooldia = [float(el) for el in tooldia.split(',') if el != ''] if tooldia is not None else default_dia

        if self.tooldia is None:
            self.app.inform.emit('[ERROR] %s' % _("Failed."))
            return 'fail'

        self.z_cut = float(z_cut) if z_cut is not None else self.app.defaults["geometry_cutz"]
        self.z_move = float(z_move) if z_move is not None else self.app.defaults["geometry_travelz"]

        self.feedrate = float(feedrate) if feedrate is not None else self.app.defaults["geometry_feedrate"]
        self.z_feedrate = float(feedrate_z) if feedrate_z is not None else self.app.defaults["geometry_feedrate_z"]
        self.feedrate_rapid = float(feedrate_rapid) if feedrate_rapid is not None else \
            self.app.defaults["geometry_feedrate_rapid"]

        self.spindlespeed = int(spindlespeed) if spindlespeed != 0 and spindlespeed is not None else None
        self.spindledir = spindledir
        self.dwell = dwell
        self.dwelltime = float(dwelltime) if dwelltime is not None else self.app.defaults["geometry_dwelltime"]

        self.startz = float(startz) if startz is not None and startz != '' else self.app.defaults["geometry_startz"]

        self.z_end = float(endz) if endz is not None else self.app.defaults["geometry_endz"]

        self.xy_end = endxy if endxy != '' and endxy else self.app.defaults["geometry_endxy"]
        self.xy_end = re.sub('[()\[\]]', '', str(self.xy_end)) if self.xy_end else None

        if self.xy_end is not None and self.xy_end != '':
            self.xy_end = [float(eval(a)) for a in self.xy_end.split(",")]

        if self.xy_end and len(self.xy_end) < 2:
            self.app.inform.emit('[ERROR]  %s' % _("The End Move X,Y field in Edit -> Preferences has to be "
                                                   "in the format (x, y) but now there is only one value, not two."))
            return 'fail'

        self.z_depthpercut = float(depthpercut) if depthpercut is not None and depthpercut != 0 else abs(self.z_cut)
        self.multidepth = multidepth
        self.z_toolchange = float(toolchangez) if toolchangez is not None else self.app.defaults["geometry_toolchangez"]
        self.extracut_length = float(extracut_length) if extracut_length is not None else \
            self.app.defaults["geometry_extracut_length"]

        try:
            if toolchangexy == '':
                self.xy_toolchange = None
            else:
                self.xy_toolchange = re.sub('[()\[\]]', '', str(toolchangexy)) if self.xy_toolchange else None

                if self.xy_toolchange and self.xy_toolchange != '':
                    self.xy_toolchange = [float(eval(a)) for a in self.xy_toolchange.split(",")]

                if len(self.xy_toolchange) < 2:
                    self.app.inform.emit('[ERROR] %s' % _("The Toolchange X,Y format has to be (x, y)."))
                    return 'fail'
        except Exception as e:
            log.debug("camlib.CNCJob.generate_from_geometry_2() --> %s" % str(e))
            pass

        self.pp_geometry_name = pp_geometry_name if pp_geometry_name else 'default'
        self.f_plunge = self.app.defaults["geometry_f_plunge"]

        if self.machinist_setting == 0:
            if self.z_cut is None:
                if 'laser' not in self.pp_geometry_name:
                    self.app.inform.emit(
                        '[ERROR_NOTCL] %s' % _("Cut_Z parameter is None or zero. Most likely a bad combinations of "
                                               "other parameters.")
                    )
                    return 'fail'
                else:
                    self.z_cut = 0.0

            if self.z_cut > 0:
                self.app.inform.emit('[WARNING] %s' %
                                     _("The Cut Z parameter has positive value. "
                                       "It is the depth value to cut into material.\n"
                                       "The Cut Z parameter needs to have a negative value, assuming it is a typo "
                                       "therefore the app will convert the value to negative."
                                       "Check the resulting CNC code (Gcode etc)."))
                self.z_cut = -self.z_cut
            elif self.z_cut == 0 and 'laser' not in self.pp_geometry_name:
                self.app.inform.emit(
                    '[WARNING] %s: %s' % (_("The Cut Z parameter is zero. There will be no cut, skipping file"),
                                          geometry.options['name'])
                )
                return 'fail'

            if self.z_move is None:
                self.app.inform.emit('[ERROR_NOTCL] %s' % _("Travel Z parameter is None or zero."))
                return 'fail'

            if self.z_move < 0:
                self.app.inform.emit('[WARNING] %s' %
                                     _("The Travel Z parameter has negative value. "
                                       "It is the height value to travel between cuts.\n"
                                       "The Z Travel parameter needs to have a positive value, assuming it is a typo "
                                       "therefore the app will convert the value to positive."
                                       "Check the resulting CNC code (Gcode etc)."))
                self.z_move = -self.z_move
            elif self.z_move == 0:
                self.app.inform.emit(
                    '[WARNING] %s: %s' % (_("The Z Travel parameter is zero. This is dangerous, skipping file"),
                                          self.options['name'])
                )
                return 'fail'

        # made sure that depth_per_cut is no more then the z_cut
        try:
            if abs(self.z_cut) < self.z_depthpercut:
                self.z_depthpercut = abs(self.z_cut)
        except TypeError:
            self.z_depthpercut = abs(self.z_cut)

        # ## Index first and last points in paths
        # What points to index.
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        # Create the indexed storage.
        storage = FlatCAMRTreeStorage()
        storage.get_points = get_pts

        # Store the geometry
        log.debug("Indexing geometry before generating G-Code...")
        self.app.inform.emit(_("Indexing geometry before generating G-Code..."))

        for geo_shape in flat_geometry:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            if geo_shape is not None:
                storage.insert(geo_shape)

        if not append:
            self.gcode = ""

        # tell preprocessor the number of tool (for toolchange)
        self.tool = tool_no

        # this is the tool diameter, it is used as such to accommodate the preprocessor who need the tool diameter
        # given under the name 'toolC'
        # this is a fancy way of adding a class attribute (which should be added in the __init__ method) without doing
        # it there :)
        self.postdata['toolC'] = self.tooldia

        # Initial G-Code
        self.pp_geometry = self.app.preprocessors[self.pp_geometry_name]

        # the 'p' local attribute is a reference to the current preprocessor class
        p = self.pp_geometry

        self.oldx = 0.0
        self.oldy = 0.0

        start_gcode = ''
        if is_first:
            start_gcode = self.doformat(p.start_code)

        # self.gcode = self.doformat(p.start_code)
        self.gcode += self.doformat(p.feedrate_code)  # sets the feed rate

        if toolchange is False:
            # all the x and y parameters in self.doformat() are used only by some preprocessors not by all
            self.gcode += self.doformat(p.lift_code, x=self.oldx, y=self.oldy)  # Move (up) to travel height
            self.gcode += self.doformat(p.startz_code, x=self.oldx, y=self.oldy)

        if toolchange:
            # if "line_xyz" in self.pp_geometry_name:
            #     self.gcode += self.doformat(p.toolchange_code, x=self.xy_toolchange[0], y=self.xy_toolchange[1])
            # else:
            #     self.gcode += self.doformat(p.toolchange_code)
            self.gcode += self.doformat(p.toolchange_code)

            if 'laser' not in self.pp_geometry_name:
                self.gcode += self.doformat(p.spindle_code)  # Spindle start
            else:
                # for laser this will disable the laser
                self.gcode += self.doformat(p.lift_code, x=self.oldx, y=self.oldy)  # Move (up) to travel height

            if self.dwell is True:
                self.gcode += self.doformat(p.dwell_code)  # Dwell time
        else:
            if 'laser' not in self.pp_geometry_name:
                self.gcode += self.doformat(p.spindle_code)  # Spindle start

            if self.dwell is True:
                self.gcode += self.doformat(p.dwell_code)  # Dwell time

        total_travel = 0.0
        total_cut = 0.0

        # Iterate over geometry paths getting the nearest each time.
        log.debug("Starting G-Code...")
        self.app.inform.emit('%s...' % _("Starting G-Code"))

        # variables to display the percentage of work done
        geo_len = len(flat_geometry)

        old_disp_number = 0
        log.warning("Number of paths for which to generate GCode: %s" % str(geo_len))

        current_tooldia = float('%.*f' % (self.decimals, float(self.tooldia)))

        self.app.inform.emit(
            '%s: %s%s.' % (_("Starting G-Code for tool with diameter"), str(current_tooldia), str(self.units))
        )

        path_count = 0
        current_pt = (0, 0)
        pt, geo = storage.nearest(current_pt)

        # when nothing is left in the storage a StopIteration exception will be raised therefore stopping
        # the whole process including the infinite loop while True below.
        try:
            while True:
                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace

                path_count += 1

                # Remove before modifying, otherwise deletion will fail.
                storage.remove(geo)

                # If last point in geometry is the nearest but prefer the first one if last point == first point
                # then reverse coordinates.
                if pt != geo.coords[0] and pt == geo.coords[-1]:
                    # geo.coords = list(geo.coords)[::-1] # Shapely 2.0
                    geo = LineString(list(geo.coords)[::-1])

                # ---------- Single depth/pass --------
                if not multidepth:
                    # calculate the cut distance
                    total_cut += geo.length
                    self.gcode += self.create_gcode_single_pass(geo, current_tooldia, extracut, self.extracut_length,
                                                                tolerance, z_move=z_move, old_point=current_pt)

                # --------- Multi-pass ---------
                else:
                    # calculate the cut distance
                    # due of the number of cuts (multi depth) it has to multiplied by the number of cuts
                    nr_cuts = 0
                    depth = abs(self.z_cut)
                    while depth > 0:
                        nr_cuts += 1
                        depth -= float(self.z_depthpercut)

                    total_cut += (geo.length * nr_cuts)

                    gc, geo = self.create_gcode_multi_pass(geo, current_tooldia, extracut, self.extracut_length,
                                                           tolerance, z_move=z_move, postproc=p,
                                                           old_point=current_pt)
                    self.gcode += gc

                # calculate the travel distance
                total_travel += abs(distance(pt1=current_pt, pt2=pt))
                current_pt = geo.coords[-1]

                pt, geo = storage.nearest(current_pt)  # Next

                # update the activity counter (lower left side of the app, status bar)
                disp_number = int(np.interp(path_count, [0, geo_len], [0, 100]))
                if old_disp_number < disp_number <= 100:
                    self.app.proc_container.update_view_text(' %d%%' % disp_number)
                    old_disp_number = disp_number
        except StopIteration:  # Nothing found in storage.
            pass

        log.debug("Finishing G-Code... %s paths traced." % path_count)

        # add move to end position
        total_travel += abs(distance_euclidian(current_pt[0], current_pt[1], 0, 0))
        self.travel_distance += total_travel + total_cut
        self.routing_time += total_cut / self.feedrate

        # Finish
        self.gcode += self.doformat(p.spindle_stop_code)
        self.gcode += self.doformat(p.lift_code, x=current_pt[0], y=current_pt[1])
        self.gcode += self.doformat(p.end_code, x=0, y=0)
        self.app.inform.emit(
            '%s... %s %s' % (_("Finished G-Code generation"), str(path_count), _(" paths traced."))
        )

        return self.gcode, start_gcode

    def generate_gcode_from_solderpaste_geo(self, **kwargs):
        """
               Algorithm to generate from multitool Geometry.

               Algorithm description:
               ----------------------
               Uses RTree to find the nearest path to follow.

               :return: Gcode string
               """

        log.debug("Generate_from_solderpaste_geometry()")

        # ## Index first and last points in paths
        # What points to index.
        def get_pts(o):
            return [o.coords[0], o.coords[-1]]

        self.gcode = ""

        if not kwargs:
            log.debug("camlib.generate_from_solderpaste_geo() --> No tool in the solderpaste geometry.")
            self.app.inform.emit('[ERROR_NOTCL] %s' %
                                 _("There is no tool data in the SolderPaste geometry."))

        # this is the tool diameter, it is used as such to accommodate the preprocessor who need the tool diameter
        # given under the name 'toolC'

        self.postdata['z_start'] = kwargs['data']['tools_solderpaste_z_start']
        self.postdata['z_dispense'] = kwargs['data']['tools_solderpaste_z_dispense']
        self.postdata['z_stop'] = kwargs['data']['tools_solderpaste_z_stop']
        self.postdata['z_travel'] = kwargs['data']['tools_solderpaste_z_travel']
        self.postdata['z_toolchange'] = kwargs['data']['tools_solderpaste_z_toolchange']
        self.postdata['xy_toolchange'] = kwargs['data']['tools_solderpaste_xy_toolchange']
        self.postdata['frxy'] = kwargs['data']['tools_solderpaste_frxy']
        self.postdata['frz'] = kwargs['data']['tools_solderpaste_frz']
        self.postdata['frz_dispense'] = kwargs['data']['tools_solderpaste_frz_dispense']
        self.postdata['speedfwd'] = kwargs['data']['tools_solderpaste_speedfwd']
        self.postdata['dwellfwd'] = kwargs['data']['tools_solderpaste_dwellfwd']
        self.postdata['speedrev'] = kwargs['data']['tools_solderpaste_speedrev']
        self.postdata['dwellrev'] = kwargs['data']['tools_solderpaste_dwellrev']
        self.postdata['pp_solderpaste_name'] = kwargs['data']['tools_solderpaste_pp']

        self.postdata['toolC'] = kwargs['tooldia']

        self.pp_solderpaste_name = kwargs['data']['tools_solderpaste_pp'] if kwargs['data']['tools_solderpaste_pp'] \
            else self.app.defaults['tools_solderpaste_pp']
        p = self.app.preprocessors[self.pp_solderpaste_name]

        # ## Flatten the geometry. Only linear elements (no polygons) remain.
        flat_geometry = self.flatten(kwargs['solid_geometry'], pathonly=True)
        log.debug("%d paths" % len(flat_geometry))

        # Create the indexed storage.
        storage = FlatCAMRTreeStorage()
        storage.get_points = get_pts

        # Store the geometry
        log.debug("Indexing geometry before generating G-Code...")
        for geo_shape in flat_geometry:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            if geo_shape is not None:
                storage.insert(geo_shape)

        # Initial G-Code
        self.gcode = self.doformat(p.start_code)
        self.gcode += self.doformat(p.spindle_off_code)
        self.gcode += self.doformat(p.toolchange_code)

        # ## Iterate over geometry paths getting the nearest each time.
        log.debug("Starting SolderPaste G-Code...")
        path_count = 0
        current_pt = (0, 0)

        # variables to display the percentage of work done
        geo_len = len(flat_geometry)
        old_disp_number = 0

        pt, geo = storage.nearest(current_pt)

        try:
            while True:
                if self.app.abort_flag:
                    # graceful abort requested by the user
                    raise grace

                path_count += 1

                # Remove before modifying, otherwise deletion will fail.
                storage.remove(geo)

                # If last point in geometry is the nearest but prefer the first one if last point == first point
                # then reverse coordinates.
                if pt != geo.coords[0] and pt == geo.coords[-1]:
                    # geo.coords = list(geo.coords)[::-1] # Shapely 2.0
                    geo = LineString(list(geo.coords)[::-1])

                self.gcode += self.create_soldepaste_gcode(geo, p=p, old_point=current_pt)
                current_pt = geo.coords[-1]
                pt, geo = storage.nearest(current_pt)  # Next

                disp_number = int(np.interp(path_count, [0, geo_len], [0, 100]))
                if old_disp_number < disp_number <= 100:
                    self.app.proc_container.update_view_text(' %d%%' % disp_number)
                    old_disp_number = disp_number
        except StopIteration:  # Nothing found in storage.
            pass

        log.debug("Finishing SolderPste G-Code... %s paths traced." % path_count)
        self.app.inform.emit(
            '%s... %s %s' % (_("Finished SolderPaste G-Code generation"), str(path_count), _("paths traced."))
        )

        # Finish
        self.gcode += self.doformat(p.lift_code)
        self.gcode += self.doformat(p.end_code)

        return self.gcode

    def create_soldepaste_gcode(self, geometry, p, old_point=(0, 0)):
        gcode = ''
        path = geometry.coords

        self.coordinates_type = self.app.defaults["cncjob_coords_type"]
        if self.coordinates_type == "G90":
            # For Absolute coordinates type G90
            first_x = path[0][0]
            first_y = path[0][1]
        else:
            # For Incremental coordinates type G91
            first_x = path[0][0] - old_point[0]
            first_y = path[0][1] - old_point[1]

        if type(geometry) == LineString or type(geometry) == LinearRing:
            # Move fast to 1st point
            gcode += self.doformat(p.rapid_code, x=first_x, y=first_y)  # Move to first point

            # Move down to cutting depth
            gcode += self.doformat(p.z_feedrate_code)
            gcode += self.doformat(p.down_z_start_code)
            gcode += self.doformat(p.spindle_fwd_code)  # Start dispensing
            gcode += self.doformat(p.dwell_fwd_code)
            gcode += self.doformat(p.feedrate_z_dispense_code)
            gcode += self.doformat(p.lift_z_dispense_code)
            gcode += self.doformat(p.feedrate_xy_code)

            # Cutting...
            prev_x = first_x
            prev_y = first_y
            for pt in path[1:]:
                if self.coordinates_type == "G90":
                    # For Absolute coordinates type G90
                    next_x = pt[0]
                    next_y = pt[1]
                else:
                    # For Incremental coordinates type G91
                    next_x = pt[0] - prev_x
                    next_y = pt[1] - prev_y
                gcode += self.doformat(p.linear_code, x=next_x, y=next_y)  # Linear motion to point
                prev_x = next_x
                prev_y = next_y

            # Up to travelling height.
            gcode += self.doformat(p.spindle_off_code)  # Stop dispensing
            gcode += self.doformat(p.spindle_rev_code)
            gcode += self.doformat(p.down_z_stop_code)
            gcode += self.doformat(p.spindle_off_code)
            gcode += self.doformat(p.dwell_rev_code)
            gcode += self.doformat(p.z_feedrate_code)
            gcode += self.doformat(p.lift_code)
        elif type(geometry) == Point:
            gcode += self.doformat(p.linear_code, x=first_x, y=first_y)  # Move to first point

            gcode += self.doformat(p.feedrate_z_dispense_code)
            gcode += self.doformat(p.down_z_start_code)
            gcode += self.doformat(p.spindle_fwd_code)  # Start dispensing
            gcode += self.doformat(p.dwell_fwd_code)
            gcode += self.doformat(p.lift_z_dispense_code)

            gcode += self.doformat(p.spindle_off_code)  # Stop dispensing
            gcode += self.doformat(p.spindle_rev_code)
            gcode += self.doformat(p.spindle_off_code)
            gcode += self.doformat(p.down_z_stop_code)
            gcode += self.doformat(p.dwell_rev_code)
            gcode += self.doformat(p.z_feedrate_code)
            gcode += self.doformat(p.lift_code)
        return gcode

    def create_gcode_single_pass(self, geometry, cdia, extracut, extracut_length, tolerance, z_move, old_point=(0, 0)):
        """
        # G-code. Note: self.linear2gcode() and self.point2gcode() will lower and raise the tool every time.

        :param geometry:            A Shapely Geometry (LineString or LinearRing) which is the path to be cut
        :type geometry:             LineString, LinearRing
        :param cdia:                Tool diameter
        :type cdia:                 float
        :param extracut:            Will add an extra cut over the point where start of the cut is met with the end cut
        :type extracut:             bool
        :param extracut_length:     The length of the extra cut: half before the meeting point, half after
        :type extracut_length:      float
        :param tolerance:           Tolerance used to simplify the paths (making them mre rough)
        :type tolerance:            float
        :param z_move:              Travel Z
        :type z_move:               float
        :param old_point:           Previous point
        :type old_point:            tuple
        :return:                    Gcode
        :rtype:                     str
        """
        # p = postproc

        if type(geometry) == LineString or type(geometry) == LinearRing:
            if extracut is False or not geometry.is_ring:
                gcode_single_pass = self.linear2gcode(geometry, cdia, z_move=z_move, tolerance=tolerance,
                                                      old_point=old_point)
            else:
                gcode_single_pass = self.linear2gcode_extra(geometry, cdia, extracut_length, tolerance=tolerance,
                                                            z_move=z_move, old_point=old_point)

        elif type(geometry) == Point:
            gcode_single_pass = self.point2gcode(geometry, cdia, z_move=z_move, old_point=old_point)
        else:
            log.warning("G-code generation not implemented for %s" % (str(type(geometry))))
            return

        return gcode_single_pass

    def create_gcode_multi_pass(self, geometry, cdia, extracut, extracut_length, tolerance, postproc, z_move,
                                old_point=(0, 0)):
        """

        :param geometry:            A Shapely Geometry (LineString or LinearRing) which is the path to be cut
        :type geometry:             LineString, LinearRing
        :param cdia:                Tool diameter
        :type cdia:                 float
        :param extracut:            Will add an extra cut over the point where start of the cut is met with the end cut
        :type extracut:             bool
        :param extracut_length:     The length of the extra cut: half before the meeting point, half after
        :type extracut_length:      float
        :param tolerance:           Tolerance used to simplify the paths (making them mre rough)
        :type tolerance:            float
        :param postproc:            Preprocessor class
        :type postproc:             class
        :param z_move:              Travel Z
        :type z_move:               float
        :param old_point:           Previous point
        :type old_point:            tuple
        :return:                    Gcode
        :rtype:                     str
        """
        p = postproc

        gcode_multi_pass = ''

        if isinstance(self.z_cut, Decimal):
            z_cut = self.z_cut
        else:
            z_cut = Decimal(self.z_cut).quantize(Decimal('0.000000001'))

        if self.z_depthpercut is None:
            self.z_depthpercut = z_cut
        elif not isinstance(self.z_depthpercut, Decimal):
            self.z_depthpercut = Decimal(self.z_depthpercut).quantize(Decimal('0.000000001'))

        depth = 0
        reverse = False
        while depth > z_cut:

            # Increase depth. Limit to z_cut.
            depth -= self.z_depthpercut
            if depth < z_cut:
                depth = z_cut

            # Cut at specific depth and do not lift the tool.
            # Note: linear2gcode() will use G00 to move to the first point in the path, but it should be already
            # at the first point if the tool is down (in the material).  So, an extra G00 should show up but
            # is inconsequential.
            if type(geometry) == LineString or type(geometry) == LinearRing:
                if extracut is False or not geometry.is_ring:
                    gcode_multi_pass += self.linear2gcode(geometry, cdia, tolerance=tolerance, z_cut=depth, up=False,
                                                          z_move=z_move, old_point=old_point)
                else:
                    gcode_multi_pass += self.linear2gcode_extra(geometry, cdia, extracut_length, tolerance=tolerance,
                                                                z_move=z_move, z_cut=depth, up=False,
                                                                old_point=old_point)

            # Ignore multi-pass for points.
            elif type(geometry) == Point:
                gcode_multi_pass += self.point2gcode(geometry, cdia, z_move=z_move, old_point=old_point)
                break  # Ignoring ...
            else:
                log.warning("G-code generation not implemented for %s" % (str(type(geometry))))

            # Reverse coordinates if not a loop so we can continue cutting without returning to the beginning.
            if type(geometry) == LineString:
                geometry = LineString(list(geometry.coords)[::-1])
                reverse = True

        # If geometry is reversed, revert.
        if reverse:
            if type(geometry) == LineString:
                geometry = LineString(list(geometry.coords)[::-1])

        # Lift the tool
        gcode_multi_pass += self.doformat(p.lift_code, x=old_point[0], y=old_point[1])
        return gcode_multi_pass, geometry

    def codes_split(self, gline):
        """
        Parses a line of G-Code such as "G01 X1234 Y987" into
        a dictionary: {'G': 1.0, 'X': 1234.0, 'Y': 987.0}

        :param gline:       G-Code line string
        :type gline:        str
        :return:            Dictionary with parsed line.
        :rtype:             dict
        """

        command = {}

        if 'Roland' in self.pp_excellon_name or 'Roland' in self.pp_geometry_name:
            match_z = re.search(r"^Z(\s*-?\d+\.\d+?),(\s*\s*-?\d+\.\d+?),(\s*\s*-?\d+\.\d+?)*;$", gline)
            if match_z:
                command['G'] = 0
                command['X'] = float(match_z.group(1).replace(" ", "")) * 0.025
                command['Y'] = float(match_z.group(2).replace(" ", "")) * 0.025
                command['Z'] = float(match_z.group(3).replace(" ", "")) * 0.025

        elif 'hpgl' in self.pp_excellon_name or 'hpgl' in self.pp_geometry_name:
            match_pa = re.search(r"^PA(\s*-?\d+\.\d+?),(\s*\s*-?\d+\.\d+?)*;$", gline)
            if match_pa:
                command['G'] = 0
                command['X'] = float(match_pa.group(1).replace(" ", "")) / 40
                command['Y'] = float(match_pa.group(2).replace(" ", "")) / 40
            match_pen = re.search(r"^(P[U|D])", gline)
            if match_pen:
                if match_pen.group(1) == 'PU':
                    # the value does not matter, only that it is positive so the gcode_parse() know it is > 0,
                    # therefore the move is of kind T (travel)
                    command['Z'] = 1
                else:
                    command['Z'] = 0

        elif 'laser' in self.pp_excellon_name.lower() or 'laser' in self.pp_geometry_name.lower() or \
                (self.pp_solderpaste_name is not None and 'paste' in self.pp_solderpaste_name.lower()):
            match_lsr = re.search(r"X([\+-]?\d+.[\+-]?\d+)\s*Y([\+-]?\d+.[\+-]?\d+)", gline)
            if match_lsr:
                command['X'] = float(match_lsr.group(1).replace(" ", ""))
                command['Y'] = float(match_lsr.group(2).replace(" ", ""))

            match_lsr_pos = re.search(r"^(M0?[3-5])", gline)
            if match_lsr_pos:
                if 'M05' in match_lsr_pos.group(1) or 'M5' in match_lsr_pos.group(1):
                    # the value does not matter, only that it is positive so the gcode_parse() know it is > 0,
                    # therefore the move is of kind T (travel)
                    command['Z'] = 1
                else:
                    command['Z'] = 0

            match_lsr_pos_2 = re.search(r"^(M10[6|7])", gline)
            if match_lsr_pos_2:
                if 'M107' in match_lsr_pos_2.group(1):
                    command['Z'] = 1
                else:
                    command['Z'] = 0
        elif self.pp_solderpaste_name is not None:
            if 'Paste' in self.pp_solderpaste_name:
                match_paste = re.search(r"X([\+-]?\d+.[\+-]?\d+)\s*Y([\+-]?\d+.[\+-]?\d+)", gline)
                if match_paste:
                    command['X'] = float(match_paste.group(1).replace(" ", ""))
                    command['Y'] = float(match_paste.group(2).replace(" ", ""))
        else:
            match = re.search(r'^\s*([A-Z])\s*([\+\-\.\d\s]+)', gline)
            while match:
                command[match.group(1)] = float(match.group(2).replace(" ", ""))
                gline = gline[match.end():]
                match = re.search(r'^\s*([A-Z])\s*([\+\-\.\d\s]+)', gline)
        return command

    def gcode_parse(self, force_parsing=None):
        """
        G-Code parser (from self.gcode). Generates dictionary with
        single-segment LineString's and "kind" indicating cut or travel,
        fast or feedrate speed.

        Will return a list of dict in the format:
        {
            "geom": LineString(path),
            "kind": kind
        }
        where kind can be either ["C", "F"]  # T=travel, C=cut, F=fast, S=slow

        :param force_parsing:
        :type force_parsing:
        :return:
        :rtype:                 dict
        """

        kind = ["C", "F"]  # T=travel, C=cut, F=fast, S=slow

        # Results go here
        geometry = []

        # Last known instruction
        current = {'X': 0.0, 'Y': 0.0, 'Z': 0.0, 'G': 0}

        # Current path: temporary storage until tool is
        # lifted or lowered.
        if self.toolchange_xy_type == "excellon":
            if self.app.defaults["tools_drill_toolchangexy"] == '' or \
                    self.app.defaults["tools_drill_toolchangexy"] is None:
                pos_xy = (0, 0)
            else:
                pos_xy = self.app.defaults["tools_drill_toolchangexy"]
                try:
                    pos_xy = [float(eval(a)) for a in pos_xy.split(",")]
                except Exception:
                    if len(pos_xy) != 2:
                        pos_xy = (0, 0)
        else:
            if self.app.defaults["geometry_toolchangexy"] == '' or self.app.defaults["geometry_toolchangexy"] is None:
                pos_xy = (0, 0)
            else:
                pos_xy = self.app.defaults["geometry_toolchangexy"]
                try:
                    pos_xy = [float(eval(a)) for a in pos_xy.split(",")]
                except Exception:
                    if len(pos_xy) != 2:
                        pos_xy = (0, 0)

        path = [pos_xy]
        # path = [(0, 0)]

        gcode_lines_list = self.gcode.splitlines()
        self.app.inform.emit('%s: %d' % (_("Parsing GCode file. Number of lines"), len(gcode_lines_list)))

        # Process every instruction
        for line in gcode_lines_list:
            if force_parsing is False or force_parsing is None:
                if '%MO' in line or '%' in line or 'MOIN' in line or 'MOMM' in line:
                    return "fail"

            gobj = self.codes_split(line)

            # ## Units
            if 'G' in gobj and (gobj['G'] == 20.0 or gobj['G'] == 21.0):
                self.units = {20.0: "IN", 21.0: "MM"}[gobj['G']]
                continue

            # TODO take into consideration the tools and update the travel line thickness
            if 'T' in gobj:
                pass

            # ## Changing height
            if 'Z' in gobj:
                if 'Roland' in self.pp_excellon_name or 'Roland' in self.pp_geometry_name:
                    pass
                elif 'hpgl' in self.pp_excellon_name or 'hpgl' in self.pp_geometry_name:
                    pass
                elif 'laser' in self.pp_excellon_name or 'laser' in self.pp_geometry_name:
                    pass
                elif ('X' in gobj or 'Y' in gobj) and gobj['Z'] != current['Z']:
                    if self.pp_geometry_name == 'line_xyz' or self.pp_excellon_name == 'line_xyz':
                        pass
                    else:
                        log.warning("Non-orthogonal motion: From %s" % str(current))
                        log.warning("  To: %s" % str(gobj))

                current['Z'] = gobj['Z']
                # Store the path into geometry and reset path
                if len(path) > 1:
                    geometry.append({"geom": LineString(path),
                                     "kind": kind})
                    path = [path[-1]]  # Start with the last point of last path.

                # create the geometry for the holes created when drilling Excellon drills
                if self.origin_kind == 'excellon':
                    if current['Z'] < 0:
                        current_drill_point_coords = (
                            float('%.*f' % (self.decimals, current['X'])),
                            float('%.*f' % (self.decimals, current['Y']))
                        )

                        # find the drill diameter knowing the drill coordinates
                        break_loop = False
                        for tool, tool_dict in self.exc_tools.items():
                            if 'drills' in tool_dict:
                                for drill_pt in tool_dict['drills']:
                                    point_in_dict_coords = (
                                        float('%.*f' % (self.decimals, drill_pt.x)),
                                        float('%.*f' % (self.decimals, drill_pt.y))
                                    )
                                    if point_in_dict_coords == current_drill_point_coords:
                                        dia = self.exc_tools[tool]['tooldia']
                                        kind = ['C', 'F']
                                        geometry.append(
                                            {
                                                "geom": Point(current_drill_point_coords).buffer(dia / 2.0).exterior,
                                                "kind": kind
                                            }
                                        )
                                        break_loop = True
                                        break
                                if break_loop:
                                    break

            if 'G' in gobj:
                current['G'] = int(gobj['G'])

            if 'X' in gobj or 'Y' in gobj:
                if 'X' in gobj:
                    x = gobj['X']
                    # current['X'] = x
                else:
                    x = current['X']

                if 'Y' in gobj:
                    y = gobj['Y']
                else:
                    y = current['Y']

                kind = ["C", "F"]  # T=travel, C=cut, F=fast, S=slow

                if current['Z'] > 0:
                    kind[0] = 'T'
                if current['G'] > 0:
                    kind[1] = 'S'

                if current['G'] in [0, 1]:  # line
                    path.append((x, y))

                arcdir = [None, None, "cw", "ccw"]
                if current['G'] in [2, 3]:  # arc
                    center = [gobj['I'] + current['X'], gobj['J'] + current['Y']]
                    radius = np.sqrt(gobj['I'] ** 2 + gobj['J'] ** 2)
                    start = np.arctan2(-gobj['J'], -gobj['I'])
                    stop = np.arctan2(-center[1] + y, -center[0] + x)
                    path += arc(center, radius, start, stop, arcdir[current['G']], int(self.steps_per_circle))

                current['X'] = x
                current['Y'] = y

            # Update current instruction
            for code in gobj:
                current[code] = gobj[code]

        self.app.inform.emit('%s...' % _("Creating Geometry from the parsed GCode file. "))
        # There might not be a change in height at the
        # end, therefore, see here too if there is
        # a final path.
        if len(path) > 1:
            geometry.append(
                {
                    "geom": LineString(path),
                    "kind": kind
                }
            )

        self.gcode_parsed = geometry
        return geometry

    def excellon_tool_gcode_parse(self, dia, gcode, start_pt=(0, 0), force_parsing=None):
        """
        G-Code parser (from self.exc_cnc_tools['tooldia']['gcode']). Generates dictionary with
        single-segment LineString's and "kind" indicating cut or travel,
        fast or feedrate speed.

        Will return the Geometry as a list of dict in the format:
        {
            "geom": LineString(path),
            "kind": kind
        }
        where kind can be either ["C", "F"]  # T=travel, C=cut, F=fast, S=slow

        :param dia:             the dia is a tool diameter which is the key in self.exc_cnc_tools dict
        :type dia:              float
        :param gcode:           Gcode to parse
        :type gcode:            str
        :param start_pt:        the point coordinates from where to start the parsing
        :type start_pt:         tuple
        :param force_parsing:
        :type force_parsing:    bool
        :return:                Geometry as a list of dictionaries
        :rtype:                 list
        """

        kind = ["C", "F"]  # T=travel, C=cut, F=fast, S=slow

        # Results go here
        geometry = []

        # Last known instruction
        current = {'X': 0.0, 'Y': 0.0, 'Z': 0.0, 'G': 0}

        # Current path: temporary storage until tool is
        # lifted or lowered.
        pos_xy = start_pt

        path = [pos_xy]
        # path = [(0, 0)]

        gcode_lines_list = gcode.splitlines()
        self.app.inform.emit(
            '%s: %s. %s: %d' % (_("Parsing GCode file for tool diameter"),
                                str(dia), _("Number of lines"),
                                len(gcode_lines_list))
        )

        # Process every instruction
        for line in gcode_lines_list:
            if force_parsing is False or force_parsing is None:
                if '%MO' in line or '%' in line or 'MOIN' in line or 'MOMM' in line:
                    return "fail"

            gobj = self.codes_split(line)

            # ## Units
            if 'G' in gobj and (gobj['G'] == 20.0 or gobj['G'] == 21.0):
                self.units = {20.0: "IN", 21.0: "MM"}[gobj['G']]
                continue

            # TODO take into consideration the tools and update the travel line thickness
            if 'T' in gobj:
                pass

            # ## Changing height
            if 'Z' in gobj:
                if 'Roland' in self.pp_excellon_name or 'Roland' in self.pp_geometry_name:
                    pass
                elif 'hpgl' in self.pp_excellon_name or 'hpgl' in self.pp_geometry_name:
                    pass
                elif 'laser' in self.pp_excellon_name or 'laser' in self.pp_geometry_name:
                    pass
                elif ('X' in gobj or 'Y' in gobj) and gobj['Z'] != current['Z']:
                    if self.pp_geometry_name == 'line_xyz' or self.pp_excellon_name == 'line_xyz':
                        pass
                    else:
                        log.warning("Non-orthogonal motion: From %s" % str(current))
                        log.warning("  To: %s" % str(gobj))

                current['Z'] = gobj['Z']
                # Store the path into geometry and reset path
                if len(path) > 1:
                    geometry.append({"geom": LineString(path),
                                     "kind": kind})
                    path = [path[-1]]  # Start with the last point of last path.

                # create the geometry for the holes created when drilling Excellon drills
                if current['Z'] < 0:
                    current_drill_point_coords = (
                        float('%.*f' % (self.decimals, current['X'])),
                        float('%.*f' % (self.decimals, current['Y']))
                    )

                    kind = ['C', 'F']
                    geometry.append(
                        {
                            "geom": Point(current_drill_point_coords).buffer(dia/2.0).exterior,
                            "kind": kind
                        }
                    )

            if 'G' in gobj:
                current['G'] = int(gobj['G'])

            if 'X' in gobj or 'Y' in gobj:
                x = gobj['X'] if 'X' in gobj else current['X']
                y = gobj['Y'] if 'Y' in gobj else current['Y']

                kind = ["C", "F"]  # T=travel, C=cut, F=fast, S=slow

                if current['Z'] > 0:
                    kind[0] = 'T'
                if current['G'] > 0:
                    kind[1] = 'S'
                if current['G'] in [0, 1]:  # line
                    path.append((x, y))

                arcdir = [None, None, "cw", "ccw"]
                if current['G'] in [2, 3]:  # arc
                    center = [gobj['I'] + current['X'], gobj['J'] + current['Y']]
                    radius = np.sqrt(gobj['I'] ** 2 + gobj['J'] ** 2)
                    start = np.arctan2(-gobj['J'], -gobj['I'])
                    stop = np.arctan2(-center[1] + y, -center[0] + x)
                    path += arc(center, radius, start, stop, arcdir[current['G']], int(self.steps_per_circle))

                current['X'] = x
                current['Y'] = y

            # Update current instruction
            for code in gobj:
                current[code] = gobj[code]

        self.app.inform.emit('%s: %s' % (_("Creating Geometry from the parsed GCode file for tool diameter"), str(dia)))
        # There might not be a change in height at the end, therefore, see here too if there is a final path.
        if len(path) > 1:
            geometry.append(
                {
                    "geom": LineString(path),
                    "kind": kind
                }
            )
        return geometry

    # def plot(self, tooldia=None, dpi=75, margin=0.1,
    #          color={"T": ["#F0E24D", "#B5AB3A"], "C": ["#5E6CFF", "#4650BD"]},
    #          alpha={"T": 0.3, "C": 1.0}):
    #     """
    #     Creates a Matplotlib figure with a plot of the
    #     G-code job.
    #     """
    #     if tooldia is None:
    #         tooldia = self.tooldia
    #
    #     fig = Figure(dpi=dpi)
    #     ax = fig.add_subplot(111)
    #     ax.set_aspect(1)
    #     xmin, ymin, xmax, ymax = self.input_geometry_bounds
    #     ax.set_xlim(xmin-margin, xmax+margin)
    #     ax.set_ylim(ymin-margin, ymax+margin)
    #
    #     if tooldia == 0:
    #         for geo in self.gcode_parsed:
    #             linespec = '--'
    #             linecolor = color[geo['kind'][0]][1]
    #             if geo['kind'][0] == 'C':
    #                 linespec = 'k-'
    #             x, y = geo['geom'].coords.xy
    #             ax.plot(x, y, linespec, color=linecolor)
    #     else:
    #         for geo in self.gcode_parsed:
    #             poly = geo['geom'].buffer(tooldia/2.0)
    #             patch = PolygonPatch(poly, facecolor=color[geo['kind'][0]][0],
    #                                  edgecolor=color[geo['kind'][0]][1],
    #                                  alpha=alpha[geo['kind'][0]], zorder=2)
    #             ax.add_patch(patch)
    #
    #     return fig

    def plot2(self, tooldia=None, dpi=75, margin=0.1, gcode_parsed=None,
              color=None, alpha={"T": 0.3, "C": 1.0}, tool_tolerance=0.0005, obj=None, visible=False, kind='all'):
        """
        Plots the G-code job onto the given axes.

        :param tooldia:             Tool diameter.
        :type tooldia:              float
        :param dpi:                 Not used!
        :type dpi:                  float
        :param margin:              Not used!
        :type margin:               float
        :param gcode_parsed:        Parsed Gcode
        :type gcode_parsed:         str
        :param color:               Color specification.
        :type color:                str
        :param alpha:               Transparency specification.
        :type alpha:                dict
        :param tool_tolerance:      Tolerance when drawing the toolshape.
        :type tool_tolerance:       float
        :param obj:                 The object for whih to plot
        :type obj:                  class
        :param visible:             Visibility status
        :type visible:              bool
        :param kind:                Can be: "travel", "cut", "all"
        :type kind:                 str
        :return:                    None
        :rtype:
        """
        # units = self.app.ui.general_defaults_form.general_app_group.units_radio.get_value().upper()

        if color is None:
            color = {
                "T": [self.app.defaults["cncjob_travel_fill"], self.app.defaults["cncjob_travel_line"]],
                "C": [self.app.defaults["cncjob_plot_fill"], self.app.defaults["cncjob_plot_line"]]
            }

        gcode_parsed = gcode_parsed if gcode_parsed else self.gcode_parsed

        if tooldia is None:
            tooldia = self.tooldia

        # this should be unlikely unless when upstream the tooldia is a tuple made by one dia and a comma like (2.4,)
        if isinstance(tooldia, list):
            tooldia = tooldia[0] if tooldia[0] is not None else self.tooldia

        if tooldia == 0:
            for geo in gcode_parsed:
                if kind == 'all':
                    obj.add_shape(shape=geo['geom'], color=color[geo['kind'][0]][1], visible=visible)
                elif kind == 'travel':
                    if geo['kind'][0] == 'T':
                        obj.add_shape(shape=geo['geom'], color=color['T'][1], visible=visible)
                elif kind == 'cut':
                    if geo['kind'][0] == 'C':
                        obj.add_shape(shape=geo['geom'], color=color['C'][1], visible=visible)
        else:
            path_num = 0

            self.coordinates_type = self.app.defaults["cncjob_coords_type"]
            if self.coordinates_type == "G90":
                # For Absolute coordinates type G90
                for geo in gcode_parsed:
                    if geo['kind'][0] == 'T':
                        start_position = geo['geom'].coords[0]

                        if tooldia not in obj.annotations_dict:
                            obj.annotations_dict[tooldia] = {
                                'pos': [],
                                'text': []
                            }
                        if start_position not in obj.annotations_dict[tooldia]['pos']:
                            path_num += 1
                            obj.annotations_dict[tooldia]['pos'].append(start_position)
                            obj.annotations_dict[tooldia]['text'].append(str(path_num))

                        end_position = geo['geom'].coords[-1]

                        if tooldia not in obj.annotations_dict:
                            obj.annotations_dict[tooldia] = {
                                'pos': [],
                                'text': []
                            }
                        if end_position not in obj.annotations_dict[tooldia]['pos']:
                            path_num += 1
                            obj.annotations_dict[tooldia]['pos'].append(end_position)
                            obj.annotations_dict[tooldia]['text'].append(str(path_num))

                    # plot the geometry of Excellon objects
                    if self.origin_kind == 'excellon':
                        try:
                            # if the geos are travel lines
                            if geo['kind'][0] == 'T':
                                poly = geo['geom'].buffer(distance=(tooldia / 1.99999999),
                                                          resolution=self.steps_per_circle)
                            else:
                                poly = Polygon(geo['geom'])

                            poly = poly.simplify(tool_tolerance)
                        except Exception:
                            # deal here with unexpected plot errors due of LineStrings not valid
                            continue
                    else:
                        # plot the geometry of any objects other than Excellon
                        poly = geo['geom'].buffer(distance=(tooldia / 1.99999999), resolution=self.steps_per_circle)
                        poly = poly.simplify(tool_tolerance)

                    if kind == 'all':
                        obj.add_shape(shape=poly, color=color[geo['kind'][0]][1], face_color=color[geo['kind'][0]][0],
                                      visible=visible, layer=1 if geo['kind'][0] == 'C' else 2)
                    elif kind == 'travel':
                        if geo['kind'][0] == 'T':
                            obj.add_shape(shape=poly, color=color['T'][1], face_color=color['T'][0],
                                          visible=visible, layer=2)
                    elif kind == 'cut':
                        if geo['kind'][0] == 'C':
                            obj.add_shape(shape=poly, color=color['C'][1], face_color=color['C'][0],
                                          visible=visible, layer=1)
            else:
                self.app.inform.emit('[ERROR_NOTCL] %s...' % _('G91 coordinates not implemented'))
                return 'fail'

    def plot_annotations(self, obj, visible=True):
        """
        Plot annotations.

        :param obj:         FlatCAM CNCJob object for which to plot the annotations
        :type obj:
        :param visible:     annotaions visibility
        :type visible:      bool
        :return:            Nothing
        :rtype:
        """

        if not obj.annotations_dict:
            return

        if visible is True:
            obj.text_col.enabled = True
        else:
            obj.text_col.enabled = False
            return

        text = []
        pos = []
        for tooldia in obj.annotations_dict:
            pos += obj.annotations_dict[tooldia]['pos']
            text += obj.annotations_dict[tooldia]['text']

        if not text or not pos:
            return

        try:
            if self.app.defaults['global_theme'] == 'white':
                obj.annotation.set(text=text, pos=pos, visible=obj.options['plot'],
                                   font_size=self.app.defaults["cncjob_annotation_fontsize"],
                                   color=self.app.defaults["cncjob_annotation_fontcolor"])
            else:
                # invert the color
                old_color = self.app.defaults["cncjob_annotation_fontcolor"].lower()
                new_color = ''
                code = {}
                l1 = "#;0123456789abcdef"
                l2 = "#;fedcba9876543210"
                for i in range(len(l1)):
                    code[l1[i]] = l2[i]

                for x in range(len(old_color)):
                    new_color += code[old_color[x]]

                obj.annotation.set(text=text, pos=pos, visible=obj.options['plot'],
                                   font_size=self.app.defaults["cncjob_annotation_fontsize"],
                                   color=new_color)
        except Exception as e:
            log.debug("CNCJob.plot2() --> annotations --> %s" % str(e))
            if self.app.is_legacy is False:
                obj.annotation.clear(update=True)

        obj.annotation.redraw()

    def create_geometry(self):
        """
        It is used by the Excellon objects. Will create the solid_geometry which will be an attribute of the
        Excellon object class.

        :return:    List of Shapely geometry elements
        :rtype:     list
        """

        # This takes forever. Too much data?
        # self.app.inform.emit('%s: %s' % (_("Unifying Geometry from parsed Geometry segments"),
        #                                  str(len(self.gcode_parsed))))
        # self.solid_geometry = unary_union([geo['geom'] for geo in self.gcode_parsed])

        # This is much faster but not so nice to look at as you can see different segments of the geometry
        self.solid_geometry = [geo['geom'] for geo in self.gcode_parsed]

        return self.solid_geometry

    def segment(self, coords):
        """
        Break long linear lines to make it more auto level friendly.
        Code snippet added by Lei Zheng in a rejected pull request on FlatCAM https://bitbucket.org/realthunder/

        :param coords:  List of coordinates tuples
        :type coords:   list
        :return:        A path; list with the multiple coordinates breaking a line.
        :rtype:         list
        """

        if len(coords) < 2 or self.segx <= 0 and self.segy <= 0:
            return list(coords)

        path = [coords[0]]

        # break the line in either x or y dimension only
        def linebreak_single(line, dim, dmax):
            if dmax <= 0:
                return None

            if line[1][dim] > line[0][dim]:
                sign = 1.0
                d = line[1][dim] - line[0][dim]
            else:
                sign = -1.0
                d = line[0][dim] - line[1][dim]
            if d > dmax:
                # make sure we don't make any new lines too short
                if d > dmax * 2:
                    dd = dmax
                else:
                    dd = d / 2
                other = dim ^ 1
                return (line[0][dim] + dd * sign, line[0][other] + \
                        dd * (line[1][other] - line[0][other]) / d)
            return None

        # recursively breaks down a given line until it is within the
        # required step size
        def linebreak(line):
            pt_new = linebreak_single(line, 0, self.segx)
            if pt_new is None:
                pt_new2 = linebreak_single(line, 1, self.segy)
            else:
                pt_new2 = linebreak_single((line[0], pt_new), 1, self.segy)
            if pt_new2 is not None:
                pt_new = pt_new2[::-1]

            if pt_new is None:
                path.append(line[1])
            else:
                path.append(pt_new)
                linebreak((pt_new, line[1]))

        for pt in coords[1:]:
            linebreak((path[-1], pt))

        return path

    def linear2gcode(self, linear, dia, tolerance=0, down=True, up=True, z_cut=None, z_move=None, zdownrate=None,
                     feedrate=None, feedrate_z=None, feedrate_rapid=None, cont=False, old_point=(0, 0)):
        """

        Generates G-code to cut along the linear feature.

        :param linear:          The path to cut along.
        :type:                  Shapely.LinearRing or Shapely.Linear String
        :param dia:             The tool diameter that is going on the path
        :type dia:              float
        :param tolerance:       All points in the simplified object will be within the
                                tolerance distance of the original geometry.
        :type tolerance:        float
        :param down:
        :param up:
        :param z_cut:
        :param z_move:
        :param zdownrate:
        :param feedrate:        speed for cut on X - Y plane
        :param feedrate_z:      speed for cut on Z plane
        :param feedrate_rapid:  speed to move between cuts; usually is G0 but some CNC require to specify it
        :param cont:
        :param old_point:
        :return:                G-code to cut along the linear feature.
        """

        if z_cut is None:
            z_cut = self.z_cut

        if z_move is None:
            z_move = self.z_move
        #
        # if zdownrate is None:
        #     zdownrate = self.zdownrate

        if feedrate is None:
            feedrate = self.feedrate

        if feedrate_z is None:
            feedrate_z = self.z_feedrate

        if feedrate_rapid is None:
            feedrate_rapid = self.feedrate_rapid

        # Simplify paths?
        if tolerance > 0:
            target_linear = linear.simplify(tolerance)
        else:
            target_linear = linear

        gcode = ""

        # path = list(target_linear.coords)
        path = self.segment(target_linear.coords)

        p = self.pp_geometry

        self.coordinates_type = self.app.defaults["cncjob_coords_type"]
        if self.coordinates_type == "G90":
            # For Absolute coordinates type G90
            first_x = path[0][0]
            first_y = path[0][1]
        else:
            # For Incremental coordinates type G91
            first_x = path[0][0] - old_point[0]
            first_y = path[0][1] - old_point[1]

        # Move fast to 1st point
        if not cont:
            current_tooldia = dia
            travels = self.app.exc_areas.travel_coordinates(start_point=(old_point[0], old_point[1]),
                                                            end_point=(first_x, first_y),
                                                            tooldia=current_tooldia)
            prev_z = None
            for travel in travels:
                locx = travel[1][0]
                locy = travel[1][1]

                if travel[0] is not None:
                    # move to next point
                    gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                    # raise to safe Z (travel[0]) each time because safe Z may be different
                    self.z_move = travel[0]
                    gcode += self.doformat(p.lift_code, x=locx, y=locy)

                    # restore z_move
                    self.z_move = z_move
                else:
                    if prev_z is not None:
                        # move to next point
                        gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                        # we assume that previously the z_move was altered therefore raise to
                        # the travel_z (z_move)
                        self.z_move = z_move
                        gcode += self.doformat(p.lift_code, x=locx, y=locy)
                    else:
                        # move to next point
                        gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                # store prev_z
                prev_z = travel[0]

            # gcode += self.doformat(p.rapid_code, x=first_x, y=first_y)  # Move to first point

        # Move down to cutting depth
        if down:
            # Different feedrate for vertical cut?
            gcode += self.doformat(p.z_feedrate_code)
            # gcode += self.doformat(p.feedrate_code)
            gcode += self.doformat(p.down_code, x=first_x, y=first_y, z_cut=z_cut)
            gcode += self.doformat(p.feedrate_code, feedrate=feedrate)

        # Cutting...
        prev_x = first_x
        prev_y = first_y
        for pt in path[1:]:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            if self.coordinates_type == "G90":
                # For Absolute coordinates type G90
                next_x = pt[0]
                next_y = pt[1]
            else:
                # For Incremental coordinates type G91
                # next_x = pt[0] - prev_x
                # next_y = pt[1] - prev_y
                self.app.inform.emit('[ERROR_NOTCL] %s' % _('G91 coordinates not implemented ...'))
                next_x = pt[0]
                next_y = pt[1]

            gcode += self.doformat(p.linear_code, x=next_x, y=next_y, z=z_cut)  # Linear motion to point
            prev_x = pt[0]
            prev_y = pt[1]

        # Up to travelling height.
        if up:
            gcode += self.doformat(p.lift_code, x=prev_x, y=prev_y, z_move=z_move)  # Stop cutting
        return gcode

    def linear2gcode_extra(self, linear, dia, extracut_length, tolerance=0, down=True, up=True,
                           z_cut=None, z_move=None, zdownrate=None,
                           feedrate=None, feedrate_z=None, feedrate_rapid=None, cont=False, old_point=(0, 0)):
        """

        Generates G-code to cut along the linear feature.

        :param linear:              The path to cut along.
        :type:                      Shapely.LinearRing or Shapely.Linear String
        :param dia:                 The tool diameter that is going on the path
        :type dia:                  float
        :param extracut_length:     how much to cut extra over the first point at the end of the path
        :param tolerance:           All points in the simplified object will be within the
                                    tolerance distance of the original geometry.
        :type tolerance:            float
        :param down:
        :param up:
        :param z_cut:
        :param z_move:
        :param zdownrate:
        :param feedrate:            speed for cut on X - Y plane
        :param feedrate_z:          speed for cut on Z plane
        :param feedrate_rapid:      speed to move between cuts; usually is G0 but some CNC require to specify it
        :param cont:
        :param old_point:
        :return:                    G-code to cut along the linear feature.
        :rtype:                     str
        """

        if z_cut is None:
            z_cut = self.z_cut

        if z_move is None:
            z_move = self.z_move
        #
        # if zdownrate is None:
        #     zdownrate = self.zdownrate

        if feedrate is None:
            feedrate = self.feedrate

        if feedrate_z is None:
            feedrate_z = self.z_feedrate

        if feedrate_rapid is None:
            feedrate_rapid = self.feedrate_rapid

        # Simplify paths?
        if tolerance > 0:
            target_linear = linear.simplify(tolerance)
        else:
            target_linear = linear

        gcode = ""

        path = list(target_linear.coords)
        p = self.pp_geometry

        self.coordinates_type = self.app.defaults["cncjob_coords_type"]
        if self.coordinates_type == "G90":
            # For Absolute coordinates type G90
            first_x = path[0][0]
            first_y = path[0][1]
        else:
            # For Incremental coordinates type G91
            first_x = path[0][0] - old_point[0]
            first_y = path[0][1] - old_point[1]

        # Move fast to 1st point
        if not cont:
            current_tooldia = dia
            travels = self.app.exc_areas.travel_coordinates(start_point=(old_point[0], old_point[1]),
                                                            end_point=(first_x, first_y),
                                                            tooldia=current_tooldia)
            prev_z = None
            for travel in travels:
                locx = travel[1][0]
                locy = travel[1][1]

                if travel[0] is not None:
                    # move to next point
                    gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                    # raise to safe Z (travel[0]) each time because safe Z may be different
                    self.z_move = travel[0]
                    gcode += self.doformat(p.lift_code, x=locx, y=locy)

                    # restore z_move
                    self.z_move = z_move
                else:
                    if prev_z is not None:
                        # move to next point
                        gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                        # we assume that previously the z_move was altered therefore raise to
                        # the travel_z (z_move)
                        self.z_move = z_move
                        gcode += self.doformat(p.lift_code, x=locx, y=locy)
                    else:
                        # move to next point
                        gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                # store prev_z
                prev_z = travel[0]

            # gcode += self.doformat(p.rapid_code, x=first_x, y=first_y)  # Move to first point

        # Move down to cutting depth
        if down:
            # Different feedrate for vertical cut?
            if self.z_feedrate is not None:
                gcode += self.doformat(p.z_feedrate_code)
                # gcode += self.doformat(p.feedrate_code)
                gcode += self.doformat(p.down_code, x=first_x, y=first_y, z_cut=z_cut)
                gcode += self.doformat(p.feedrate_code, feedrate=feedrate)
            else:
                gcode += self.doformat(p.down_code, x=first_x, y=first_y, z_cut=z_cut)  # Start cutting

        # Cutting...
        prev_x = first_x
        prev_y = first_y
        for pt in path[1:]:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            if self.coordinates_type == "G90":
                # For Absolute coordinates type G90
                next_x = pt[0]
                next_y = pt[1]
            else:
                # For Incremental coordinates type G91
                # For Incremental coordinates type G91
                # next_x = pt[0] - prev_x
                # next_y = pt[1] - prev_y
                self.app.inform.emit('[ERROR_NOTCL] %s' % _('G91 coordinates not implemented ...'))
                next_x = pt[0]
                next_y = pt[1]

            gcode += self.doformat(p.linear_code, x=next_x, y=next_y, z=z_cut)  # Linear motion to point
            prev_x = next_x
            prev_y = next_y

        # this line is added to create an extra cut over the first point in patch
        # to make sure that we remove the copper leftovers
        # Linear motion to the 1st point in the cut path
        # if self.coordinates_type == "G90":
        #     # For Absolute coordinates type G90
        #     last_x = path[1][0]
        #     last_y = path[1][1]
        # else:
        #     # For Incremental coordinates type G91
        #     last_x = path[1][0] - first_x
        #     last_y = path[1][1] - first_y
        # gcode += self.doformat(p.linear_code, x=last_x, y=last_y)

        # the first point for extracut is always mandatory if the extracut is enabled. But if the length of distance
        # between point 0 and point 1 is more than the distance we set for the extra cut then make an interpolation
        # along the path and find the point at the distance extracut_length

        if extracut_length == 0.0:
            extra_path = [path[-1], path[0], path[1]]
            new_x = extra_path[0][0]
            new_y = extra_path[0][1]

            # this is an extra line therefore lift the milling bit
            gcode += self.doformat(p.lift_code, x=prev_x, y=prev_y, z_move=z_move)  # lift

            # move fast to the new first point
            gcode += self.doformat(p.rapid_code, x=new_x, y=new_y)

            # lower the milling bit
            # Different feedrate for vertical cut?
            if self.z_feedrate is not None:
                gcode += self.doformat(p.z_feedrate_code)
                gcode += self.doformat(p.down_code, x=new_x, y=new_y, z_cut=z_cut)
                gcode += self.doformat(p.feedrate_code, feedrate=feedrate)
            else:
                gcode += self.doformat(p.down_code, x=new_x, y=new_y, z_cut=z_cut)  # Start cutting

            # start cutting the extra line
            last_pt = extra_path[0]
            for pt in extra_path[1:]:
                gcode += self.doformat(p.linear_code, x=pt[0], y=pt[1])
                last_pt = pt

            # go back to the original point
            gcode += self.doformat(p.linear_code, x=path[0][0], y=path[0][1])
            last_pt = path[0]
        else:
            # go to the point that is 5% in length before the end (therefore 95% length from start of the line),
            # along the line to be cut
            if extracut_length >= target_linear.length:
                extracut_length = target_linear.length

            # ---------------------------------------------
            # first half
            # ---------------------------------------------
            start_length = target_linear.length - (extracut_length * 0.5)
            extra_line = substring(target_linear, start_length, target_linear.length)
            extra_path = list(extra_line.coords)
            new_x = extra_path[0][0]
            new_y = extra_path[0][1]

            # this is an extra line therefore lift the milling bit
            gcode += self.doformat(p.lift_code, x=prev_x, y=prev_y, z_move=z_move)  # lift

            # move fast to the new first point
            gcode += self.doformat(p.rapid_code, x=new_x, y=new_y)

            # lower the milling bit
            # Different feedrate for vertical cut?
            if self.z_feedrate is not None:
                gcode += self.doformat(p.z_feedrate_code)
                gcode += self.doformat(p.down_code, x=new_x, y=new_y, z_cut=z_cut)
                gcode += self.doformat(p.feedrate_code, feedrate=feedrate)
            else:
                gcode += self.doformat(p.down_code, x=new_x, y=new_y, z_cut=z_cut)  # Start cutting

            # start cutting the extra line
            for pt in extra_path[1:]:
                gcode += self.doformat(p.linear_code, x=pt[0], y=pt[1])

            # ---------------------------------------------
            # second half
            # ---------------------------------------------
            extra_line = substring(target_linear, 0, (extracut_length * 0.5))
            extra_path = list(extra_line.coords)

            # start cutting the extra line
            last_pt = extra_path[0]
            for pt in extra_path[1:]:
                gcode += self.doformat(p.linear_code, x=pt[0], y=pt[1])
                last_pt = pt

            # ---------------------------------------------
            # back to original start point, cutting
            # ---------------------------------------------
            extra_line = substring(target_linear, 0, (extracut_length * 0.5))
            extra_path = list(extra_line.coords)[::-1]

            # start cutting the extra line
            last_pt = extra_path[0]
            for pt in extra_path[1:]:
                gcode += self.doformat(p.linear_code, x=pt[0], y=pt[1])
                last_pt = pt

        # if extracut_length == 0.0:
        #     gcode += self.doformat(p.linear_code, x=path[1][0], y=path[1][1])
        #     last_pt = path[1]
        # else:
        #     if abs(distance(path[1], path[0])) > extracut_length:
        #         i_point = LineString([path[0], path[1]]).interpolate(extracut_length)
        #         gcode += self.doformat(p.linear_code, x=i_point.x, y=i_point.y)
        #         last_pt = (i_point.x, i_point.y)
        #     else:
        #         last_pt = path[0]
        #         for pt in path[1:]:
        #             extracut_distance = abs(distance(pt, last_pt))
        #             if extracut_distance <= extracut_length:
        #                 gcode += self.doformat(p.linear_code, x=pt[0], y=pt[1])
        #                 last_pt = pt
        #             else:
        #                 break

        # Up to travelling height.
        if up:
            gcode += self.doformat(p.lift_code, x=last_pt[0], y=last_pt[1], z_move=z_move)  # Stop cutting

        return gcode

    def point2gcode(self, point, dia, z_move=None, old_point=(0, 0)):
        """

        :param point:               A Shapely Point
        :type point:                Point
        :param dia:                 The tool diameter that is going on the path
        :type dia:                  float
        :param z_move:              Travel Z
        :type z_move:               float
        :param old_point:           Old point coordinates from which we moved to the 'point'
        :type old_point:            tuple
        :return:                    G-code to cut on the Point feature.
        :rtype:                     str
        """
        gcode = ""

        if self.app.abort_flag:
            # graceful abort requested by the user
            raise grace

        path = list(point.coords)
        p = self.pp_geometry

        self.coordinates_type = self.app.defaults["cncjob_coords_type"]
        if self.coordinates_type == "G90":
            # For Absolute coordinates type G90
            first_x = path[0][0]
            first_y = path[0][1]
        else:
            # For Incremental coordinates type G91
            # first_x = path[0][0] - old_point[0]
            # first_y = path[0][1] - old_point[1]
            self.app.inform.emit('[ERROR_NOTCL] %s' %
                                 _('G91 coordinates not implemented ...'))
            first_x = path[0][0]
            first_y = path[0][1]

        current_tooldia = dia
        travels = self.app.exc_areas.travel_coordinates(start_point=(old_point[0], old_point[1]),
                                                        end_point=(first_x, first_y),
                                                        tooldia=current_tooldia)
        prev_z = None
        for travel in travels:
            locx = travel[1][0]
            locy = travel[1][1]

            if travel[0] is not None:
                # move to next point
                gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                # raise to safe Z (travel[0]) each time because safe Z may be different
                self.z_move = travel[0]
                gcode += self.doformat(p.lift_code, x=locx, y=locy)

                # restore z_move
                self.z_move = z_move
            else:
                if prev_z is not None:
                    # move to next point
                    gcode += self.doformat(p.rapid_code, x=locx, y=locy)

                    # we assume that previously the z_move was altered therefore raise to
                    # the travel_z (z_move)
                    self.z_move = z_move
                    gcode += self.doformat(p.lift_code, x=locx, y=locy)
                else:
                    # move to next point
                    gcode += self.doformat(p.rapid_code, x=locx, y=locy)

            # store prev_z
            prev_z = travel[0]

        # gcode += self.doformat(p.linear_code, x=first_x, y=first_y)  # Move to first point

        if self.z_feedrate is not None:
            gcode += self.doformat(p.z_feedrate_code)
            gcode += self.doformat(p.down_code, x=first_x, y=first_y, z_cut=self.z_cut)
            gcode += self.doformat(p.feedrate_code)
        else:
            gcode += self.doformat(p.down_code, x=first_x, y=first_y, z_cut=self.z_cut)  # Start cutting

        gcode += self.doformat(p.lift_code, x=first_x, y=first_y)  # Stop cutting
        return gcode

    def export_svg(self, scale_stroke_factor=0.00):
        """
        Exports the CNC Job as a SVG Element

        :param scale_stroke_factor:     A factor to scale the SVG geometry
        :type scale_stroke_factor:      float
        :return:                        SVG Element string
        :rtype:                         str
        """
        # scale_factor is a multiplication factor for the SVG stroke-width used within shapely's svg export
        # If not specified then try and use the tool diameter
        # This way what is on screen will match what is outputed for the svg
        # This is quite a useful feature for svg's used with visicut

        if scale_stroke_factor <= 0:
            scale_stroke_factor = self.options['tooldia'] / 2

        # If still 0 then default to 0.05
        # This value appears to work for zooming, and getting the output svg line width
        # to match that viewed on screen with FlatCam
        if scale_stroke_factor == 0:
            scale_stroke_factor = 0.01

        # Separate the list of cuts and travels into 2 distinct lists
        # This way we can add different formatting / colors to both
        cuts = []
        travels = []
        cutsgeom = ''
        travelsgeom = ''

        for g in self.gcode_parsed:
            if self.app.abort_flag:
                # graceful abort requested by the user
                raise grace

            if g['kind'][0] == 'C':
                cuts.append(g)
            if g['kind'][0] == 'T':
                travels.append(g)

        # Used to determine the overall board size
        self.solid_geometry = unary_union([geo['geom'] for geo in self.gcode_parsed])

        # Convert the cuts and travels into single geometry objects we can render as svg xml
        if travels:
            travelsgeom = unary_union([geo['geom'] for geo in travels])

        if self.app.abort_flag:
            # graceful abort requested by the user
            raise grace

        if cuts:
            cutsgeom = unary_union([geo['geom'] for geo in cuts])

        # Render the SVG Xml
        # The scale factor affects the size of the lines, and the stroke color adds different formatting for each set
        # It's better to have the travels sitting underneath the cuts for visicut
        svg_elem = ""
        if travels:
            svg_elem = travelsgeom.svg(scale_factor=scale_stroke_factor, stroke_color="#F0E24D")
        if cuts:
            svg_elem += cutsgeom.svg(scale_factor=scale_stroke_factor, stroke_color="#5E6CFF")

        return svg_elem

    def bounds(self, flatten=None):
        """
        Returns coordinates of rectangular bounds of geometry: (xmin, ymin, xmax, ymax).

        :param flatten:     Not used, it is here for compatibility with base class method
        :type flatten:      bool
        :return:            Bounding values in format (xmin, ymin, xmax, ymax)
        :rtype:             tuple
        """

        log.debug("camlib.CNCJob.bounds()")

        def bounds_rec(obj):
            if type(obj) is list:
                cminx = np.Inf
                cminy = np.Inf
                cmaxx = -np.Inf
                cmaxy = -np.Inf

                for k in obj:
                    if type(k) is dict:
                        for key in k:
                            minx_, miny_, maxx_, maxy_ = bounds_rec(k[key])
                            cminx = min(cminx, minx_)
                            cminy = min(cminy, miny_)
                            cmaxx = max(cmaxx, maxx_)
                            cmaxy = max(cmaxy, maxy_)
                    else:
                        minx_, miny_, maxx_, maxy_ = bounds_rec(k)
                        cminx = min(cminx, minx_)
                        cminy = min(cminy, miny_)
                        cmaxx = max(cmaxx, maxx_)
                        cmaxy = max(cmaxy, maxy_)
                return cminx, cminy, cmaxx, cmaxy
            else:
                # it's a Shapely object, return it's bounds
                return obj.bounds

        if self.multitool is False:
            log.debug("CNCJob->bounds()")
            if self.solid_geometry is None:
                log.debug("solid_geometry is None")
                return 0, 0, 0, 0

            bounds_coords = bounds_rec(self.solid_geometry)
        else:
            minx = np.Inf
            miny = np.Inf
            maxx = -np.Inf
            maxy = -np.Inf
            if self.cnc_tools:
                for k, v in self.cnc_tools.items():
                    minx = np.Inf
                    miny = np.Inf
                    maxx = -np.Inf
                    maxy = -np.Inf
                    try:
                        for k in v['solid_geometry']:
                            minx_, miny_, maxx_, maxy_ = bounds_rec(k)
                            minx = min(minx, minx_)
                            miny = min(miny, miny_)
                            maxx = max(maxx, maxx_)
                            maxy = max(maxy, maxy_)
                    except TypeError:
                        minx_, miny_, maxx_, maxy_ = bounds_rec(v['solid_geometry'])
                        minx = min(minx, minx_)
                        miny = min(miny, miny_)
                        maxx = max(maxx, maxx_)
                        maxy = max(maxy, maxy_)

            if self.exc_cnc_tools:
                for k, v in self.exc_cnc_tools.items():
                    minx = np.Inf
                    miny = np.Inf
                    maxx = -np.Inf
                    maxy = -np.Inf
                    try:
                        for k in v['solid_geometry']:
                            minx_, miny_, maxx_, maxy_ = bounds_rec(k)
                            minx = min(minx, minx_)
                            miny = min(miny, miny_)
                            maxx = max(maxx, maxx_)
                            maxy = max(maxy, maxy_)
                    except TypeError:
                        minx_, miny_, maxx_, maxy_ = bounds_rec(v['solid_geometry'])
                        minx = min(minx, minx_)
                        miny = min(miny, miny_)
                        maxx = max(maxx, maxx_)
                        maxy = max(maxy, maxy_)

            bounds_coords = minx, miny, maxx, maxy
        return bounds_coords

    # TODO This function should be replaced at some point with a "real" function. Until then it's an ugly hack ...
    def scale(self, xfactor, yfactor=None, point=None):
        """
        Scales all the geometry on the XY plane in the object by the
        given factor. Tool sizes, feedrates, or Z-axis dimensions are
        not altered.

        :param factor:  Number by which to scale the object.
        :type factor:   float
        :param point:   the (x,y) coords for the point of origin of scale
        :type           tuple of floats
        :return:        None
        :rtype:         None
        """
        log.debug("camlib.CNCJob.scale()")

        if yfactor is None:
            yfactor = xfactor

        if point is None:
            px = 0
            py = 0
        else:
            px, py = point

        def scale_g(g):
            """

            :param g: 'g' parameter it's a gcode string
            :return:  scaled gcode string
            """

            temp_gcode = ''
            header_start = False
            header_stop = False
            units = self.app.defaults['units'].upper()

            lines = StringIO(g)
            for line in lines:

                # this changes the GCODE header ---- UGLY HACK
                if "TOOL DIAMETER" in line or "Feedrate:" in line:
                    header_start = True

                if "G20" in line or "G21" in line:
                    header_start = False
                    header_stop = True

                if header_start is True:
                    header_stop = False
                    if "in" in line:
                        if units == 'MM':
                            line = line.replace("in", "mm")
                    if "mm" in line:
                        if units == 'IN':
                            line = line.replace("mm", "in")

                    # find any float number in header (even multiple on the same line) and convert it
                    numbers_in_header = re.findall(self.g_nr_re, line)
                    if numbers_in_header:
                        for nr in numbers_in_header:
                            new_nr = float(nr) * xfactor
                            # replace the updated string
                            line = line.replace(nr, ('%.*f' % (self.app.defaults["cncjob_coords_decimals"], new_nr))
                                                )

                # this scales all the X and Y and Z and F values and also the Tool Dia in the toolchange message
                if header_stop is True:
                    if "G20" in line:
                        if units == 'MM':
                            line = line.replace("G20", "G21")
                    if "G21" in line:
                        if units == 'IN':
                            line = line.replace("G21", "G20")

                    # find the X group
                    match_x = self.g_x_re.search(line)
                    if match_x:
                        if match_x.group(1) is not None:
                            new_x = float(match_x.group(1)[1:]) * xfactor
                            # replace the updated string
                            line = line.replace(
                                match_x.group(1),
                                'X%.*f' % (self.app.defaults["cncjob_coords_decimals"], new_x)
                            )
                    # find the Y group
                    match_y = self.g_y_re.search(line)
                    if match_y:
                        if match_y.group(1) is not None:
                            new_y = float(match_y.group(1)[1:]) * yfactor
                            line = line.replace(
                                match_y.group(1),
                                'Y%.*f' % (self.app.defaults["cncjob_coords_decimals"], new_y)
                            )
                    # find the Z group
                    match_z = self.g_z_re.search(line)
                    if match_z:
                        if match_z.group(1) is not None:
                            new_z = float(match_z.group(1)[1:]) * xfactor
                            line = line.replace(
                                match_z.group(1),
                                'Z%.*f' % (self.app.defaults["cncjob_coords_decimals"], new_z)
                            )

                    # find the F group
                    match_f = self.g_f_re.search(line)
                    if match_f:
                        if match_f.group(1) is not None:
                            new_f = float(match_f.group(1)[1:]) * xfactor
                            line = line.replace(
                                match_f.group(1),
                                'F%.*f' % (self.app.defaults["cncjob_fr_decimals"], new_f)
                            )
                    # find the T group (tool dia on toolchange)
                    match_t = self.g_t_re.search(line)
                    if match_t:
                        if match_t.group(1) is not None:
                            new_t = float(match_t.group(1)[1:]) * xfactor
                            line = line.replace(
                                match_t.group(1),
                                '= %.*f' % (self.app.defaults["cncjob_coords_decimals"], new_t)
                            )

                temp_gcode += line
            lines.close()
            header_stop = False
            return temp_gcode

        if self.multitool is False:
            # offset Gcode
            self.gcode = scale_g(self.gcode)

            # variables to display the percentage of work done
            self.geo_len = 0
            try:
                self.geo_len = len(self.gcode_parsed)
            except TypeError:
                self.geo_len = 1
            self.old_disp_number = 0
            self.el_count = 0

            # scale geometry
            for g in self.gcode_parsed:
                try:
                    g['geom'] = affinity.scale(g['geom'], xfactor, yfactor, origin=(px, py))
                except AttributeError:
                    return g['geom']

                self.el_count += 1
                disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
                if self.old_disp_number < disp_number <= 100:
                    self.app.proc_container.update_view_text(' %d%%' % disp_number)
                    self.old_disp_number = disp_number

            self.create_geometry()
        else:
            for k, v in self.cnc_tools.items():
                # scale Gcode
                v['gcode'] = scale_g(v['gcode'])

                # variables to display the percentage of work done
                self.geo_len = 0
                try:
                    self.geo_len = len(v['gcode_parsed'])
                except TypeError:
                    self.geo_len = 1
                self.old_disp_number = 0
                self.el_count = 0

                # scale gcode_parsed
                for g in v['gcode_parsed']:
                    try:
                        g['geom'] = affinity.scale(g['geom'], xfactor, yfactor, origin=(px, py))
                    except AttributeError:
                        return g['geom']

                    self.el_count += 1
                    disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
                    if self.old_disp_number < disp_number <= 100:
                        self.app.proc_container.update_view_text(' %d%%' % disp_number)
                        self.old_disp_number = disp_number

                v['solid_geometry'] = unary_union([geo['geom'] for geo in v['gcode_parsed']])
        self.create_geometry()
        self.app.proc_container.new_text = ''

    def offset(self, vect):
        """
        Offsets all the geometry on the XY plane in the object by the
        given vector.
        Offsets all the GCODE on the XY plane in the object by the
        given vector.

        g_offsetx_re, g_offsety_re, multitool, cnnc_tools are attributes of FlatCAMCNCJob class in camlib

        :param vect:    (x, y) offset vector.
        :type vect:     tuple
        :return:        None
        """
        log.debug("camlib.CNCJob.offset()")

        dx, dy = vect

        def offset_g(g):
            """

            :param g: 'g' parameter it's a gcode string
            :return:  offseted gcode string
            """

            temp_gcode = ''
            lines = StringIO(g)
            for line in lines:
                # find the X group
                match_x = self.g_x_re.search(line)
                if match_x:
                    if match_x.group(1) is not None:
                        # get the coordinate and add X offset
                        new_x = float(match_x.group(1)[1:]) + dx
                        # replace the updated string
                        line = line.replace(
                            match_x.group(1),
                            'X%.*f' % (self.app.defaults["cncjob_coords_decimals"], new_x)
                        )
                match_y = self.g_y_re.search(line)
                if match_y:
                    if match_y.group(1) is not None:
                        new_y = float(match_y.group(1)[1:]) + dy
                        line = line.replace(
                            match_y.group(1),
                            'Y%.*f' % (self.app.defaults["cncjob_coords_decimals"], new_y)
                        )
                temp_gcode += line
            lines.close()
            return temp_gcode

        if self.multitool is False:
            # offset Gcode
            self.gcode = offset_g(self.gcode)

            # variables to display the percentage of work done
            self.geo_len = 0
            try:
                self.geo_len = len(self.gcode_parsed)
            except TypeError:
                self.geo_len = 1
            self.old_disp_number = 0
            self.el_count = 0

            # offset geometry
            for g in self.gcode_parsed:
                try:
                    g['geom'] = affinity.translate(g['geom'], xoff=dx, yoff=dy)
                except AttributeError:
                    return g['geom']

                self.el_count += 1
                disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
                if self.old_disp_number < disp_number <= 100:
                    self.app.proc_container.update_view_text(' %d%%' % disp_number)
                    self.old_disp_number = disp_number

            self.create_geometry()
        else:
            for k, v in self.cnc_tools.items():
                # offset Gcode
                v['gcode'] = offset_g(v['gcode'])

                # variables to display the percentage of work done
                self.geo_len = 0
                try:
                    self.geo_len = len(v['gcode_parsed'])
                except TypeError:
                    self.geo_len = 1
                self.old_disp_number = 0
                self.el_count = 0

                # offset gcode_parsed
                for g in v['gcode_parsed']:
                    try:
                        g['geom'] = affinity.translate(g['geom'], xoff=dx, yoff=dy)
                    except AttributeError:
                        return g['geom']

                    self.el_count += 1
                    disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
                    if self.old_disp_number < disp_number <= 100:
                        self.app.proc_container.update_view_text(' %d%%' % disp_number)
                        self.old_disp_number = disp_number

                # for the bounding box
                v['solid_geometry'] = unary_union([geo['geom'] for geo in v['gcode_parsed']])

        self.app.proc_container.new_text = ''

    def mirror(self, axis, point):
        """
        Mirror the geometry of an object by an given axis around the coordinates of the 'point'

        :param axis:    Axis for Mirror
        :param point:   tuple of coordinates (x,y). Point of origin for Mirror
        :return:
        """
        log.debug("camlib.CNCJob.mirror()")

        px, py = point
        xscale, yscale = {"X": (1.0, -1.0), "Y": (-1.0, 1.0)}[axis]

        # variables to display the percentage of work done
        self.geo_len = 0
        try:
            self.geo_len = len(self.gcode_parsed)
        except TypeError:
            self.geo_len = 1
        self.old_disp_number = 0
        self.el_count = 0

        for g in self.gcode_parsed:
            try:
                g['geom'] = affinity.scale(g['geom'], xscale, yscale, origin=(px, py))
            except AttributeError:
                return g['geom']

            self.el_count += 1
            disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
            if self.old_disp_number < disp_number <= 100:
                self.app.proc_container.update_view_text(' %d%%' % disp_number)
                self.old_disp_number = disp_number

        self.create_geometry()
        self.app.proc_container.new_text = ''

    def skew(self, angle_x, angle_y, point):
        """
        Shear/Skew the geometries of an object by angles along x and y dimensions.

        :param angle_x:
        :param angle_y:
        angle_x, angle_y : float, float
            The shear angle(s) for the x and y axes respectively. These can be
            specified in either degrees (default) or radians by setting
            use_radians=True.

        :param point:   tupple of coordinates (x,y)

        See shapely manual for more information: http://toblerity.org/shapely/manual.html#affine-transformations
        """
        log.debug("camlib.CNCJob.skew()")

        px, py = point

        # variables to display the percentage of work done
        self.geo_len = 0
        try:
            self.geo_len = len(self.gcode_parsed)
        except TypeError:
            self.geo_len = 1
        self.old_disp_number = 0
        self.el_count = 0

        for g in self.gcode_parsed:
            try:
                g['geom'] = affinity.skew(g['geom'], angle_x, angle_y, origin=(px, py))
            except AttributeError:
                return g['geom']

            self.el_count += 1
            disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
            if self.old_disp_number < disp_number <= 100:
                self.app.proc_container.update_view_text(' %d%%' % disp_number)
                self.old_disp_number = disp_number

        self.create_geometry()
        self.app.proc_container.new_text = ''

    def rotate(self, angle, point):
        """
        Rotate the geometry of an object by an given angle around the coordinates of the 'point'

        :param angle:   Angle of Rotation
        :param point:   tuple of coordinates (x,y). Origin point for Rotation
        :return:
        """
        log.debug("camlib.CNCJob.rotate()")

        px, py = point

        # variables to display the percentage of work done
        self.geo_len = 0
        try:
            self.geo_len = len(self.gcode_parsed)
        except TypeError:
            self.geo_len = 1
        self.old_disp_number = 0
        self.el_count = 0

        for g in self.gcode_parsed:
            try:
                g['geom'] = affinity.rotate(g['geom'], angle, origin=(px, py))
            except AttributeError:
                return g['geom']

            self.el_count += 1
            disp_number = int(np.interp(self.el_count, [0, self.geo_len], [0, 100]))
            if self.old_disp_number < disp_number <= 100:
                self.app.proc_container.update_view_text(' %d%%' % disp_number)
                self.old_disp_number = disp_number

        self.create_geometry()
        self.app.proc_container.new_text = ''


def get_bounds(geometry_list):
    """
    Will return limit values for a list of geometries

    :param geometry_list:   List of geometries for which to calculate the bounds limits
    :return:
    """
    xmin = np.Inf
    ymin = np.Inf
    xmax = -np.Inf
    ymax = -np.Inf

    for gs in geometry_list:
        try:
            gxmin, gymin, gxmax, gymax = gs.bounds()
            xmin = min([xmin, gxmin])
            ymin = min([ymin, gymin])
            xmax = max([xmax, gxmax])
            ymax = max([ymax, gymax])
        except Exception:
            log.warning("DEVELOPMENT: Tried to get bounds of empty geometry.")

    return [xmin, ymin, xmax, ymax]


def arc(center, radius, start, stop, direction, steps_per_circ):
    """
    Creates a list of point along the specified arc.

    :param center:          Coordinates of the center [x, y]
    :type center:           list
    :param radius:          Radius of the arc.
    :type radius:           float
    :param start:           Starting angle in radians
    :type start:            float
    :param stop:            End angle in radians
    :type stop:             float
    :param direction:       Orientation of the arc, "CW" or "CCW"
    :type direction:        string
    :param steps_per_circ:  Number of straight line segments to
                            represent a circle.
    :type steps_per_circ:   int
    :return:                The desired arc, as list of tuples
    :rtype:                 list
    """
    # TODO: Resolution should be established by maximum error from the exact arc.

    da_sign = {"cw": -1.0, "ccw": 1.0}
    points = []
    if direction == "ccw" and stop <= start:
        stop += 2 * np.pi
    if direction == "cw" and stop >= start:
        stop -= 2 * np.pi

    angle = abs(stop - start)

    # angle = stop-start
    steps = max([int(np.ceil(angle / (2 * np.pi) * steps_per_circ)), 2])
    delta_angle = da_sign[direction] * angle * 1.0 / steps
    for i in range(steps + 1):
        theta = start + delta_angle * i
        points.append((center[0] + radius * np.cos(theta), center[1] + radius * np.sin(theta)))
    return points


def arc2(p1, p2, center, direction, steps_per_circ):
    r = np.sqrt((center[0] - p1[0]) ** 2 + (center[1] - p1[1]) ** 2)
    start = np.arctan2(p1[1] - center[1], p1[0] - center[0])
    stop = np.arctan2(p2[1] - center[1], p2[0] - center[0])
    return arc(center, r, start, stop, direction, steps_per_circ)


def arc_angle(start, stop, direction):
    if direction == "ccw" and stop <= start:
        stop += 2 * np.pi
    if direction == "cw" and stop >= start:
        stop -= 2 * np.pi

    angle = abs(stop - start)
    return angle


# def find_polygon(poly, point):
#     """
#     Find an object that object.contains(Point(point)) in
#     poly, which can can be iterable, contain iterable of, or
#     be itself an implementer of .contains().
#
#     :param poly: See description
#     :return: Polygon containing point or None.
#     """
#
#     if poly is None:
#         return None
#
#     try:
#         for sub_poly in poly:
#             p = find_polygon(sub_poly, point)
#             if p is not None:
#                 return p
#     except TypeError:
#         try:
#             if poly.contains(Point(point)):
#                 return poly
#         except AttributeError:
#             return None
#
#     return None


def to_dict(obj):
    """
    Makes the following types into serializable form:

    * ApertureMacro
    * BaseGeometry

    :param obj:     Shapely geometry.
    :type obj:      BaseGeometry
    :return:        Dictionary with serializable form if ``obj`` was
                    BaseGeometry or ApertureMacro, otherwise returns ``obj``.
    """
    if isinstance(obj, ApertureMacro):
        return {
            "__class__": "ApertureMacro",
            "__inst__": obj.to_dict()
        }
    if isinstance(obj, BaseGeometry):
        return {
            "__class__": "Shply",
            "__inst__": sdumps(obj)
        }
    return obj


def dict2obj(d):
    """
    Default deserializer.

    :param d:   Serializable dictionary representation of an object
                to be reconstructed.
    :return:    Reconstructed object.
    """
    if '__class__' in d and '__inst__' in d:
        if d['__class__'] == "Shply":
            return sloads(d['__inst__'])
        if d['__class__'] == "ApertureMacro":
            am = ApertureMacro()
            am.from_dict(d['__inst__'])
            return am
        return d
    else:
        return d


# def plotg(geo, solid_poly=False, color="black"):
#     try:
#         __ = iter(geo)
#     except:
#         geo = [geo]
#
#     for g in geo:
#         if type(g) == Polygon:
#             if solid_poly:
#                 patch = PolygonPatch(g,
#                                      facecolor="#BBF268",
#                                      edgecolor="#006E20",
#                                      alpha=0.75,
#                                      zorder=2)
#                 ax = subplot(111)
#                 ax.add_patch(patch)
#             else:
#                 x, y = g.exterior.coords.xy
#                 plot(x, y, color=color)
#                 for ints in g.interiors:
#                     x, y = ints.coords.xy
#                     plot(x, y, color=color)
#                 continue
#
#         if type(g) == LineString or type(g) == LinearRing:
#             x, y = g.coords.xy
#             plot(x, y, color=color)
#             continue
#
#         if type(g) == Point:
#             x, y = g.coords.xy
#             plot(x, y, 'o')
#             continue
#
#         try:
#             __ = iter(g)
#             plotg(g, color=color)
#         except:
#             log.error("Cannot plot: " + str(type(g)))
#             continue

# def alpha_shape(points, alpha):
#     """
#     Compute the alpha shape (concave hull) of a set of points.
#
#     @param points: Iterable container of points.
#     @param alpha: alpha value to influence the gooeyness of the border. Smaller
#                   numbers don't fall inward as much as larger numbers. Too large,
#                   and you lose everything!
#     """
#     if len(points) < 4:
#         # When you have a triangle, there is no sense in computing an alpha
#         # shape.
#         return MultiPoint(list(points)).convex_hull
#
#     def add_edge(edges, edge_points, coords, i, j):
#         """Add a line between the i-th and j-th points, if not in the list already"""
#         if (i, j) in edges or (j, i) in edges:
#             # already added
#             return
#         edges.add( (i, j) )
#         edge_points.append(coords[ [i, j] ])
#
#     coords = np.array([point.coords[0] for point in points])
#
#     tri = Delaunay(coords)
#     edges = set()
#     edge_points = []
#     # loop over triangles:
#     # ia, ib, ic = indices of corner points of the triangle
#     for ia, ib, ic in tri.vertices:
#         pa = coords[ia]
#         pb = coords[ib]
#         pc = coords[ic]
#
#         # Lengths of sides of triangle
#         a = math.sqrt((pa[0]-pb[0])**2 + (pa[1]-pb[1])**2)
#         b = math.sqrt((pb[0]-pc[0])**2 + (pb[1]-pc[1])**2)
#         c = math.sqrt((pc[0]-pa[0])**2 + (pc[1]-pa[1])**2)
#
#         # Semiperimeter of triangle
#         s = (a + b + c)/2.0
#
#         # Area of triangle by Heron's formula
#         area = math.sqrt(s*(s-a)*(s-b)*(s-c))
#         circum_r = a*b*c/(4.0*area)
#
#         # Here's the radius filter.
#         #print circum_r
#         if circum_r < 1.0/alpha:
#             add_edge(edges, edge_points, coords, ia, ib)
#             add_edge(edges, edge_points, coords, ib, ic)
#             add_edge(edges, edge_points, coords, ic, ia)
#
#     m = MultiLineString(edge_points)
#     triangles = list(polygonize(m))
#     return unary_union(triangles), edge_points

# def voronoi(P):
#     """
#     Returns a list of all edges of the voronoi diagram for the given input points.
#     """
#     delauny = Delaunay(P)
#     triangles = delauny.points[delauny.vertices]
#
#     circum_centers = np.array([triangle_csc(tri) for tri in triangles])
#     long_lines_endpoints = []
#
#     lineIndices = []
#     for i, triangle in enumerate(triangles):
#         circum_center = circum_centers[i]
#         for j, neighbor in enumerate(delauny.neighbors[i]):
#             if neighbor != -1:
#                 lineIndices.append((i, neighbor))
#             else:
#                 ps = triangle[(j+1)%3] - triangle[(j-1)%3]
#                 ps = np.array((ps[1], -ps[0]))
#
#                 middle = (triangle[(j+1)%3] + triangle[(j-1)%3]) * 0.5
#                 di = middle - triangle[j]
#
#                 ps /= np.linalg.norm(ps)
#                 di /= np.linalg.norm(di)
#
#                 if np.dot(di, ps) < 0.0:
#                     ps *= -1000.0
#                 else:
#                     ps *= 1000.0
#
#                 long_lines_endpoints.append(circum_center + ps)
#                 lineIndices.append((i, len(circum_centers) + len(long_lines_endpoints)-1))
#
#     vertices = np.vstack((circum_centers, long_lines_endpoints))
#
#     # filter out any duplicate lines
#     lineIndicesSorted = np.sort(lineIndices) # make (1,2) and (2,1) both (1,2)
#     lineIndicesTupled = [tuple(row) for row in lineIndicesSorted]
#     lineIndicesUnique = np.unique(lineIndicesTupled)
#
#     return vertices, lineIndicesUnique
#
#
# def triangle_csc(pts):
#     rows, cols = pts.shape
#
#     A = np.bmat([[2 * np.dot(pts, pts.T), np.ones((rows, 1))],
#                  [np.ones((1, rows)), np.zeros((1, 1))]])
#
#     b = np.hstack((np.sum(pts * pts, axis=1), np.ones((1))))
#     x = np.linalg.solve(A,b)
#     bary_coords = x[:-1]
#     return np.sum(pts * np.tile(bary_coords.reshape((pts.shape[0], 1)), (1, pts.shape[1])), axis=0)
#
#
# def voronoi_cell_lines(points, vertices, lineIndices):
#     """
#     Returns a mapping from a voronoi cell to its edges.
#
#     :param points: shape (m,2)
#     :param vertices: shape (n,2)
#     :param lineIndices: shape (o,2)
#     :rtype: dict point index -> list of shape (n,2) with vertex indices
#     """
#     kd = KDTree(points)
#
#     cells = collections.defaultdict(list)
#     for i1, i2 in lineIndices:
#         v1, v2 = vertices[i1], vertices[i2]
#         mid = (v1+v2)/2
#         _, (p1Idx, p2Idx) = kd.query(mid, 2)
#         cells[p1Idx].append((i1, i2))
#         cells[p2Idx].append((i1, i2))
#
#     return cells
#
#
# def voronoi_edges2polygons(cells):
#     """
#     Transforms cell edges into polygons.
#
#     :param cells: as returned from voronoi_cell_lines
#     :rtype: dict point index -> list of vertex indices which form a polygon
#     """
#
#     # first, close the outer cells
#     for pIdx, lineIndices_ in cells.items():
#         dangling_lines = []
#         for i1, i2 in lineIndices_:
#             p = (i1, i2)
#             connections = filter(lambda k: p != k and
#             (p[0] == k[0] or p[0] == k[1] or p[1] == k[0] or p[1] == k[1]), lineIndices_)
#             # connections = filter(lambda (i1_, i2_): (i1, i2) != (i1_, i2_) and
#             (i1 == i1_ or i1 == i2_ or i2 == i1_ or i2 == i2_), lineIndices_)
#             assert 1 <= len(connections) <= 2
#             if len(connections) == 1:
#                 dangling_lines.append((i1, i2))
#         assert len(dangling_lines) in [0, 2]
#         if len(dangling_lines) == 2:
#             (i11, i12), (i21, i22) = dangling_lines
#             s = (i11, i12)
#             t = (i21, i22)
#
#             # determine which line ends are unconnected
#             connected = filter(lambda k: k != s and (k[0] == s[0] or k[1] == s[0]), lineIndices_)
#             # connected = filter(lambda (i1,i2): (i1,i2) != (i11,i12) and (i1 == i11 or i2 == i11), lineIndices_)
#             i11Unconnected = len(connected) == 0
#
#             connected = filter(lambda k: k != t and (k[0] == t[0] or k[1] == t[0]), lineIndices_)
#             # connected = filter(lambda (i1,i2): (i1,i2) != (i21,i22) and (i1 == i21 or i2 == i21), lineIndices_)
#             i21Unconnected = len(connected) == 0
#
#             startIdx = i11 if i11Unconnected else i12
#             endIdx = i21 if i21Unconnected else i22
#
#             cells[pIdx].append((startIdx, endIdx))
#
#     # then, form polygons by storing vertex indices in (counter-)clockwise order
#     polys = {}
#     for pIdx, lineIndices_ in cells.items():
#         # get a directed graph which contains both directions and arbitrarily follow one of both
#         directedGraph = lineIndices_ + [(i2, i1) for (i1, i2) in lineIndices_]
#         directedGraphMap = collections.defaultdict(list)
#         for (i1, i2) in directedGraph:
#             directedGraphMap[i1].append(i2)
#         orderedEdges = []
#         currentEdge = directedGraph[0]
#         while len(orderedEdges) < len(lineIndices_):
#             i1 = currentEdge[1]
#             i2 = directedGraphMap[i1][0] if directedGraphMap[i1][0] != currentEdge[0] else directedGraphMap[i1][1]
#             nextEdge = (i1, i2)
#             orderedEdges.append(nextEdge)
#             currentEdge = nextEdge
#
#         polys[pIdx] = [i1 for (i1, i2) in orderedEdges]
#
#     return polys
#
#
# def voronoi_polygons(points):
#     """
#     Returns the voronoi polygon for each input point.
#
#     :param points: shape (n,2)
#     :rtype: list of n polygons where each polygon is an array of vertices
#     """
#     vertices, lineIndices = voronoi(points)
#     cells = voronoi_cell_lines(points, vertices, lineIndices)
#     polys = voronoi_edges2polygons(cells)
#     polylist = []
#     for i in range(len(points)):
#         poly = vertices[np.asarray(polys[i])]
#         polylist.append(poly)
#     return polylist
#
#
# class Zprofile:
#     def __init__(self):
#
#         # data contains lists of [x, y, z]
#         self.data = []
#
#         # Computed voronoi polygons (shapely)
#         self.polygons = []
#         pass
#
#     # def plot_polygons(self):
#     #     axes = plt.subplot(1, 1, 1)
#     #
#     #     plt.axis([-0.05, 1.05, -0.05, 1.05])
#     #
#     #     for poly in self.polygons:
#     #         p = PolygonPatch(poly, facecolor=np.random.rand(3, 1), alpha=0.3)
#     #         axes.add_patch(p)
#
#     def init_from_csv(self, filename):
#         pass
#
#     def init_from_string(self, zpstring):
#         pass
#
#     def init_from_list(self, zplist):
#         self.data = zplist
#
#     def generate_polygons(self):
#         self.polygons = [Polygon(p) for p in voronoi_polygons(array([[x[0], x[1]] for x in self.data]))]
#
#     def normalize(self, origin):
#         pass
#
#     def paste(self, path):
#         """
#         Return a list of dictionaries containing the parts of the original
#         path and their z-axis offset.
#         """
#
#         # At most one region/polygon will contain the path
#         containing = [i for i in range(len(self.polygons)) if self.polygons[i].contains(path)]
#
#         if len(containing) > 0:
#             return [{"path": path, "z": self.data[containing[0]][2]}]
#
#         # All region indexes that intersect with the path
#         crossing = [i for i in range(len(self.polygons)) if self.polygons[i].intersects(path)]
#
#         return [{"path": path.intersection(self.polygons[i]),
#                  "z": self.data[i][2]} for i in crossing]


def autolist(obj):
    try:
        __ = iter(obj)
        return obj
    except TypeError:
        return [obj]


def three_point_circle(p1, p2, p3):
    """
    Computes the center and radius of a circle from
    3 points on its circumference.

    :param p1:  Point 1
    :param p2:  Point 2
    :param p3:  Point 3
    :return:    center, radius
    """
    # Midpoints
    a1 = (p1 + p2) / 2.0
    a2 = (p2 + p3) / 2.0

    # Normals
    b1 = np.dot((p2 - p1), np.array([[0, -1], [1, 0]], dtype=np.float32))
    b2 = np.dot((p3 - p2), np.array([[0, 1], [-1, 0]], dtype=np.float32))

    # Params
    try:
        T = solve(np.transpose(np.array([-b1, b2])), a1 - a2)
    except Exception as e:
        log.debug("camlib.three_point_circle() --> %s" % str(e))
        return

    # Center
    center = a1 + b1 * T[0]

    # Radius
    radius = np.linalg.norm(center - p1)

    return center, radius, T[0]


def distance(pt1, pt2):
    return np.sqrt((pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) ** 2)


def distance_euclidian(x1, y1, x2, y2):
    return np.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)


class FlatCAMRTree(object):
    """
    Indexes geometry (Any object with "cooords" property containing
    a list of tuples with x, y values). Objects are indexed by
    all their points by default. To index by arbitrary points,
    override self.points2obj.
    """

    def __init__(self):
        # Python RTree Index
        self.rti = rtindex.Index()

        # ## Track object-point relationship
        # Each is list of points in object.
        self.obj2points = []

        # Index is index in rtree, value is index of
        # object in obj2points.
        self.points2obj = []

        self.get_points = lambda go: go.coords

    def grow_obj2points(self, idx):
        """
        Increases the size of self.obj2points to fit
        idx + 1 items.

        :param idx: Index to fit into list.
        :return: None
        """
        if len(self.obj2points) > idx:
            # len == 2, idx == 1, ok.
            return
        else:
            # len == 2, idx == 2, need 1 more.
            # range(2, 3)
            for i in range(len(self.obj2points), idx + 1):
                self.obj2points.append([])

    def insert(self, objid, obj):
        self.grow_obj2points(objid)
        self.obj2points[objid] = []

        for pt in self.get_points(obj):
            self.rti.insert(len(self.points2obj), (pt[0], pt[1], pt[0], pt[1]), obj=objid)
            self.obj2points[objid].append(len(self.points2obj))
            self.points2obj.append(objid)

    def remove_obj(self, objid, obj):
        # Use all ptids to delete from index
        for i, pt in enumerate(self.get_points(obj)):
            try:
                self.rti.delete(self.obj2points[objid][i], (pt[0], pt[1], pt[0], pt[1]))
            except IndexError:
                pass

    def nearest(self, pt):
        """
        Will raise StopIteration if no items are found.

        :param pt:
        :return:
        """
        return next(self.rti.nearest(pt, objects=True))


class FlatCAMRTreeStorage(FlatCAMRTree):
    """
    Just like FlatCAMRTree it indexes geometry, but also serves
    as storage for the geometry.
    """

    def __init__(self):
        # super(FlatCAMRTreeStorage, self).__init__()
        super().__init__()

        self.objects = []

        # Optimization attempt!
        self.indexes = {}

    def insert(self, obj):
        self.objects.append(obj)
        idx = len(self.objects) - 1

        # Note: Shapely objects are not hashable any more, although
        # there seem to be plans to re-introduce the feature in
        # version 2.0. For now, we will index using the object's id,
        # but it's important to remember that shapely geometry is
        # mutable, ie. it can be modified to a totally different shape
        # and continue to have the same id.
        # self.indexes[obj] = idx
        self.indexes[id(obj)] = idx

        # super(FlatCAMRTreeStorage, self).insert(idx, obj)
        super().insert(idx, obj)

    # @profile
    def remove(self, obj):
        # See note about self.indexes in insert().
        # objidx = self.indexes[obj]
        objidx = self.indexes[id(obj)]

        # Remove from list
        self.objects[objidx] = None

        # Remove from index
        self.remove_obj(objidx, obj)

    def get_objects(self):
        return (o for o in self.objects if o is not None)

    def nearest(self, pt):
        """
        Returns the nearest matching points and the object
        it belongs to.

        :param pt: Query point.
        :return: (match_x, match_y), Object owner of
          matching point.
        :rtype: tuple
        """
        tidx = super(FlatCAMRTreeStorage, self).nearest(pt)
        return (tidx.bbox[0], tidx.bbox[1]), self.objects[tidx.object]

# class myO:
#     def __init__(self, coords):
#         self.coords = coords
#
#
# def test_rti():
#
#     o1 = myO([(0, 0), (0, 1), (1, 1)])
#     o2 = myO([(2, 0), (2, 1), (2, 1)])
#     o3 = myO([(2, 0), (2, 1), (3, 1)])
#
#     os = [o1, o2]
#
#     idx = FlatCAMRTree()
#
#     for o in range(len(os)):
#         idx.insert(o, os[o])
#
#     print [x.bbox for x in idx.rti.nearest((0, 0), num_results=20, objects=True)]
#
#     idx.remove_obj(0, o1)
#
#     print [x.bbox for x in idx.rti.nearest((0, 0), num_results=20, objects=True)]
#
#     idx.remove_obj(1, o2)
#
#     print [x.bbox for x in idx.rti.nearest((0, 0), num_results=20, objects=True)]
#
#
# def test_rtis():
#
#     o1 = myO([(0, 0), (0, 1), (1, 1)])
#     o2 = myO([(2, 0), (2, 1), (2, 1)])
#     o3 = myO([(2, 0), (2, 1), (3, 1)])
#
#     os = [o1, o2]
#
#     idx = FlatCAMRTreeStorage()
#
#     for o in range(len(os)):
#         idx.insert(os[o])
#
#     #os = None
#     #o1 = None
#     #o2 = None
#
#     print [x.bbox for x in idx.rti.nearest((0, 0), num_results=20, objects=True)]
#
#     idx.remove(idx.nearest((2,0))[1])
#
#     print [x.bbox for x in idx.rti.nearest((0, 0), num_results=20, objects=True)]
#
#     idx.remove(idx.nearest((0,0))[1])
#
#     print [x.bbox for x in idx.rti.nearest((0, 0), num_results=20, objects=True)]