- code cleanup in Isolation Tool

AppTools/ToolIsolation.py

@@ -12,20 +12,17 @@ from AppGUI.GUIElements import FCCheckBox, FCDoubleSpinner, RadioSet, FCTable, F
     FCComboBox, OptionalHideInputSection, FCSpinner
 from AppParsers.ParseGerber import Gerber
 
-from camlib import grace
-
 from copy import deepcopy
 
 import numpy as np
 import math
-from shapely.geometry import base
+
 from shapely.ops import cascaded_union
 from shapely.geometry import MultiPolygon, Polygon, MultiLineString, LineString, LinearRing
 
 from matplotlib.backend_bases import KeyEvent as mpl_key_event
 
 import logging
-import traceback
 import gettext
 import AppTranslation as fcTranslate
 import builtins
@@ -1603,110 +1600,6 @@ class ToolIsolation(AppTool, Gerber):
 
         self.app.worker_task.emit({'fcn': buffer_task, 'params': []})
 
-    def on_isolate_click(self):
-        """
-        Slot for clicking signal of the self.generate_iso_button
-
-        :return: None
-        """
-
-        # init values for the next usage
-        self.reset_usage()
-
-        self.app.defaults.report_usage("on_paint_button_click")
-
-        self.grb_circle_steps = int(self.app.defaults["gerber_circle_steps"])
-        self.obj_name = self.object_combo.currentText()
-
-        # Get source object.
-        try:
-            self.grb_obj = self.app.collection.get_by_name(self.obj_name)
-        except Exception as e:
-            self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Could not retrieve object"), str(self.obj_name)))
-            return "Could not retrieve object: %s with error: %s" % (self.obj_name, str(e))
-
-        if self.grb_obj is None:
-            self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Object not found"), str(self.obj_name)))
-            return
-
-        # use the selected tools in the tool table; get diameters for isolation
-        self.iso_dia_list = []
-        # use the selected tools in the tool table; get diameters for non-copper clear
-        self.ncc_dia_list = []
-
-        if self.tools_table.selectedItems():
-            for x in self.tools_table.selectedItems():
-                try:
-                    self.tooldia = float(self.tools_table.item(x.row(), 1).text())
-                except ValueError:
-                    # try to convert comma to decimal point. if it's still not working error message and return
-                    try:
-                        self.tooldia = float(self.tools_table.item(x.row(), 1).text().replace(',', '.'))
-                    except ValueError:
-                        self.app.inform.emit('[ERROR_NOTCL] %s' % _("Wrong Tool Dia value format entered, "
-                                                                    "use a number."))
-                        continue
-
-                self.iso_dia_list.append(self.tooldia)
-        else:
-            self.app.inform.emit('[ERROR_NOTCL] %s' % _("No selected tools in Tool Table."))
-            return
-
-        self.o_name = '%s_ncc' % self.obj_name
-
-        self.select_method = self.select_combo.get_value()
-        if self.select_method == _('Itself'):
-            self.bound_obj_name = self.object_combo.currentText()
-            # Get source object.
-            try:
-                self.bound_obj = self.app.collection.get_by_name(self.bound_obj_name)
-            except Exception as e:
-                self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Could not retrieve object"), self.bound_obj_name))
-                return "Could not retrieve object: %s with error: %s" % (self.bound_obj_name, str(e))
-
-            self.clear_copper(ncc_obj=self.grb_obj,
-                              ncctooldia=self.ncc_dia_list,
-                              isotooldia=self.iso_dia_list,
-                              outname=self.o_name)
-        elif self.select_method == _("Area Selection"):
-            self.app.inform.emit('[WARNING_NOTCL] %s' % _("Click the start point of the area."))
-
-            if self.app.is_legacy is False:
-                self.app.plotcanvas.graph_event_disconnect('mouse_press', self.app.on_mouse_click_over_plot)
-                self.app.plotcanvas.graph_event_disconnect('mouse_move', self.app.on_mouse_move_over_plot)
-                self.app.plotcanvas.graph_event_disconnect('mouse_release', self.app.on_mouse_click_release_over_plot)
-            else:
-                self.app.plotcanvas.graph_event_disconnect(self.app.mp)
-                self.app.plotcanvas.graph_event_disconnect(self.app.mm)
-                self.app.plotcanvas.graph_event_disconnect(self.app.mr)
-
-            self.mr = self.app.plotcanvas.graph_event_connect('mouse_release', self.on_mouse_release)
-            self.mm = self.app.plotcanvas.graph_event_connect('mouse_move', self.on_mouse_move)
-            self.kp = self.app.plotcanvas.graph_event_connect('key_press', self.on_key_press)
-
-        elif self.select_method == _("Reference Object"):
-            self.bound_obj_name = self.reference_combo.currentText()
-            # Get source object.
-            try:
-                self.bound_obj = self.app.collection.get_by_name(self.bound_obj_name)
-            except Exception as e:
-                self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Could not retrieve object"), self.bound_obj_name))
-                return "Could not retrieve object: %s. Error: %s" % (self.bound_obj_name, str(e))
-
-            self.clear_copper(ncc_obj=self.grb_obj,
-                              sel_obj=self.bound_obj,
-                              ncctooldia=self.ncc_dia_list,
-                              isotooldia=self.iso_dia_list,
-                              outname=self.o_name)
-
-
-
-
-    # ###########################################
-    # ###########################################
-    # ###########################################
-    # ###########################################
-
     def on_iso_button_click(self, *args):
 
         self.obj_name = self.object_combo.currentText()
@@ -1799,7 +1692,7 @@ class ToolIsolation(AppTool, Gerber):
             else:
                 self.grid_status_memory = False
 
-            self.mr = self.app.plotcanvas.graph_event_connect('mouse_release', self.on_mouse_click_release)
+            self.mr = self.app.plotcanvas.graph_event_connect('mouse_release', self.on_poly_mouse_click_release)
             self.kp = self.app.plotcanvas.graph_event_connect('key_press', self.on_key_press)
 
             if self.app.is_legacy is False:
@@ -1941,8 +1834,8 @@ class ToolIsolation(AppTool, Gerber):
                 if len(self.iso_tools) > 1:
                     geo_obj.multigeo = True
                 else:
-                    passes = float(self.iso_tools[0]['data']['tools_iso_passes'])
-                    geo_obj.multigeo = True if passes > 1 else False
+                    passes_no = float(self.iso_tools[0]['data']['tools_iso_passes'])
+                    geo_obj.multigeo = True if passes_no > 1 else False
 
                 # detect if solid_geometry is empty and this require list flattening which is "heavy"
                 # or just looking in the lists (they are one level depth) and if any is not empty
@@ -2096,7 +1989,7 @@ class ToolIsolation(AppTool, Gerber):
                             return 'fail'
                         else:
                             fc_obj.inform.emit('[success] %s: %s' %
-                                                (_("Isolation geometry created"), geo_obj.options["name"]))
+                                               (_("Isolation geometry created"), geo_obj.options["name"]))
                         geo_obj.multigeo = False
 
                     # TODO: Do something if this is None. Offer changing name?
@@ -2215,7 +2108,7 @@ class ToolIsolation(AppTool, Gerber):
                         new_geometry.append(new_geo)
         return new_geometry
 
-    def on_mouse_click_release(self, event):
+    def on_poly_mouse_click_release(self, event):
         if self.app.is_legacy is False:
             event_pos = event.pos
             right_button = 2
@@ -2278,7 +2171,7 @@ class ToolIsolation(AppTool, Gerber):
                 self.app.ui.grid_snap_btn.trigger()
 
             if self.app.is_legacy is False:
-                self.app.plotcanvas.graph_event_disconnect('mouse_release', self.on_mouse_click_release)
+                self.app.plotcanvas.graph_event_disconnect('mouse_release', self.on_poly_mouse_click_release)
                 self.app.plotcanvas.graph_event_disconnect('key_press', self.on_key_pres)
             else:
                 self.app.plotcanvas.graph_event_disconnect(self.mr)
@@ -2365,14 +2258,6 @@ class ToolIsolation(AppTool, Gerber):
         else:
             self.app.inform.emit(_("No polygon in selection."))
 
-    # ###########################################
-    # ###########################################
-    # ###########################################
-    # ###########################################
-
-
-
-
     # To be called after clicking on the plot.
     def on_mouse_release(self, event):
         if self.app.is_legacy is False:
@@ -2605,785 +2490,6 @@ class ToolIsolation(AppTool, Gerber):
             self.delete_moving_selection_shape()
             self.delete_tool_selection_shape()
 
-    def get_tool_empty_area(self, name, ncc_obj, geo_obj, isotooldia, has_offset, ncc_offset, ncc_margin,
-                            bounding_box, tools_storage):
-        """
-        Calculate the empty area by subtracting the solid_geometry from the object bounding box geometry.
-
-        :param name:
-        :param ncc_obj:
-        :param geo_obj:
-        :param isotooldia:
-        :param has_offset:
-        :param ncc_offset:
-        :param ncc_margin:
-        :param bounding_box:
-        :param tools_storage:
-        :return:
-        """
-
-        log.debug("NCC Tool. Calculate 'empty' area.")
-        self.app.inform.emit(_("NCC Tool. Calculate 'empty' area."))
-
-        # a flag to signal that the isolation is broken by the bounding box in 'area' and 'box' cases
-        # will store the number of tools for which the isolation is broken
-        warning_flag = 0
-
-        if ncc_obj.kind == 'gerber' and isotooldia:
-            isolated_geo = []
-
-            # unfortunately for this function to work time efficient,
-            # if the Gerber was loaded without buffering then it require the buffering now.
-            # TODO 'buffering status' should be a property of the object not the project property
-            if self.app.defaults['gerber_buffering'] == 'no':
-                self.solid_geometry = ncc_obj.solid_geometry.buffer(0)
-            else:
-                self.solid_geometry = ncc_obj.solid_geometry
-
-            # if milling type is climb then the move is counter-clockwise around features
-            milling_type = self.milling_type_radio.get_value()
-
-            for tool_iso in isotooldia:
-                new_geometry = []
-
-                if milling_type == 'cl':
-                    isolated_geo = self.generate_envelope(tool_iso / 2, 1)
-                else:
-                    isolated_geo = self.generate_envelope(tool_iso / 2, 0)
-
-                if isolated_geo == 'fail':
-                    self.app.inform.emit('[ERROR_NOTCL] %s %s' %
-                                         (_("Isolation geometry could not be generated."), str(tool_iso)))
-                    continue
-
-                if ncc_margin < tool_iso:
-                    self.app.inform.emit('[WARNING_NOTCL] %s' % _("Isolation geometry is broken. Margin is less "
-                                                                  "than isolation tool diameter."))
-                try:
-                    for geo_elem in isolated_geo:
-                        # provide the app with a way to process the GUI events when in a blocking loop
-                        QtWidgets.QApplication.processEvents()
-
-                        if self.app.abort_flag:
-                            # graceful abort requested by the user
-                            raise grace
-
-                        if isinstance(geo_elem, Polygon):
-                            for ring in self.poly2rings(geo_elem):
-                                new_geo = ring.intersection(bounding_box)
-                                if new_geo and not new_geo.is_empty:
-                                    new_geometry.append(new_geo)
-                        elif isinstance(geo_elem, MultiPolygon):
-                            for poly in geo_elem:
-                                for ring in self.poly2rings(poly):
-                                    new_geo = ring.intersection(bounding_box)
-                                    if new_geo and not new_geo.is_empty:
-                                        new_geometry.append(new_geo)
-                        elif isinstance(geo_elem, LineString):
-                            new_geo = geo_elem.intersection(bounding_box)
-                            if new_geo:
-                                if not new_geo.is_empty:
-                                    new_geometry.append(new_geo)
-                        elif isinstance(geo_elem, MultiLineString):
-                            for line_elem in geo_elem:
-                                new_geo = line_elem.intersection(bounding_box)
-                                if new_geo and not new_geo.is_empty:
-                                    new_geometry.append(new_geo)
-                except TypeError:
-                    if isinstance(isolated_geo, Polygon):
-                        for ring in self.poly2rings(isolated_geo):
-                            new_geo = ring.intersection(bounding_box)
-                            if new_geo:
-                                if not new_geo.is_empty:
-                                    new_geometry.append(new_geo)
-                    elif isinstance(isolated_geo, LineString):
-                        new_geo = isolated_geo.intersection(bounding_box)
-                        if new_geo and not new_geo.is_empty:
-                            new_geometry.append(new_geo)
-                    elif isinstance(isolated_geo, MultiLineString):
-                        for line_elem in isolated_geo:
-                            new_geo = line_elem.intersection(bounding_box)
-                            if new_geo and not new_geo.is_empty:
-                                new_geometry.append(new_geo)
-
-                # a MultiLineString geometry element will show that the isolation is broken for this tool
-                for geo_e in new_geometry:
-                    if type(geo_e) == MultiLineString:
-                        warning_flag += 1
-                        break
-
-                current_uid = 0
-                for k, v in tools_storage.items():
-                    if float('%.*f' % (self.decimals, v['tooldia'])) == float('%.*f' % (self.decimals,
-                                                                                        tool_iso)):
-                        current_uid = int(k)
-                        # add the solid_geometry to the current too in self.paint_tools dictionary
-                        # and then reset the temporary list that stored that solid_geometry
-                        v['solid_geometry'] = deepcopy(new_geometry)
-                        v['data']['name'] = name
-                        break
-                geo_obj.tools[current_uid] = dict(tools_storage[current_uid])
-
-            sol_geo = cascaded_union(isolated_geo)
-            if has_offset is True:
-                self.app.inform.emit('[WARNING_NOTCL] %s ...' % _("Buffering"))
-                sol_geo = sol_geo.buffer(distance=ncc_offset)
-                self.app.inform.emit('[success] %s ...' % _("Buffering finished"))
-
-            empty = self.get_ncc_empty_area(target=sol_geo, boundary=bounding_box)
-            if empty == 'fail':
-                return 'fail'
-
-            if empty.is_empty:
-                self.app.inform.emit('[ERROR_NOTCL] %s' %
-                                     _("Isolation geometry is broken. Margin is less than isolation tool diameter."))
-                return 'fail'
-        else:
-            self.app.inform.emit('[ERROR_NOTCL] %s' % _('The selected object is not suitable for copper clearing.'))
-            return 'fail'
-
-        if type(empty) is Polygon:
-            empty = MultiPolygon([empty])
-
-        log.debug("NCC Tool. Finished calculation of 'empty' area.")
-        self.app.inform.emit(_("NCC Tool. Finished calculation of 'empty' area."))
-
-        return empty, warning_flag
-
-    def clear_copper(self, ncc_obj, sel_obj=None, ncctooldia=None, isotooldia=None, outname=None, order=None,
-                     tools_storage=None, run_threaded=True):
-        """
-        Clear the excess copper from the entire object.
-
-        :param ncc_obj:         ncc cleared object
-        :param sel_obj:
-        :param ncctooldia:      a tuple or single element made out of diameters of the tools to be used to ncc clear
-        :param isotooldia:      a tuple or single element made out of diameters of the tools to be used for isolation
-        :param outname:         name of the resulting object
-        :param order:           Tools order
-        :param tools_storage:   whether to use the current tools_storage self.iso_tools or a different one.
-                                Usage of the different one is related to when this function is called
-                                from a TcL command.
-
-        :param run_threaded:    If True the method will be run in a threaded way suitable for GUI usage; if False
-                                it will run non-threaded for TclShell usage
-        :return:
-        """
-        log.debug("Executing the handler ...")
-
-        if run_threaded:
-            proc = self.app.proc_container.new(_("Non-Copper clearing ..."))
-        else:
-            self.app.proc_container.view.set_busy(_("Non-Copper clearing ..."))
-            QtWidgets.QApplication.processEvents()
-
-        # ######################################################################################################
-        # ######################### Read the parameters ########################################################
-        # ######################################################################################################
-
-        units = self.app.defaults['units']
-        order = order if order else self.order_radio.get_value()
-        ncc_select = self.select_combo.get_value()
-        rest_machining_choice = self.rest_cb.get_value()
-
-        # determine if to use the progressive plotting
-        prog_plot = True if self.app.defaults["tools_iso_plotting"] == 'progressive' else False
-        tools_storage = tools_storage if tools_storage is not None else self.iso_tools
-
-        # ######################################################################################################
-        # # Read the tooldia parameter and create a sorted list out them - they may be more than one diameter ##
-        # ######################################################################################################
-        sorted_clear_tools = []
-        if ncctooldia is not None:
-            try:
-                sorted_clear_tools = [float(eval(dia)) for dia in ncctooldia.split(",") if dia != '']
-            except AttributeError:
-                if not isinstance(ncctooldia, list):
-                    sorted_clear_tools = [float(ncctooldia)]
-                else:
-                    sorted_clear_tools = ncctooldia
-        else:
-            # for row in range(self.tools_table.rowCount()):
-            #     if self.tools_table.cellWidget(row, 1).currentText() == 'clear_op':
-            #         sorted_clear_tools.append(float(self.tools_table.item(row, 1).text()))
-            for tooluid in self.iso_tools:
-                if self.iso_tools[tooluid]['data']['tools_nccoperation'] == 'clear':
-                    sorted_clear_tools.append(self.iso_tools[tooluid]['tooldia'])
-
-        # ########################################################################################################
-        # set the name for the future Geometry object
-        # I do it here because it is also stored inside the gen_clear_area() and gen_clear_area_rest() methods
-        # ########################################################################################################
-        name = outname if outname is not None else self.obj_name + "_ncc"
-
-        # ########################################################################################################
-        # ######### #####Initializes the new geometry object #####################################################
-        # ########################################################################################################
-        def gen_clear_area(geo_obj, app_obj):
-            log.debug("NCC Tool. Normal copper clearing task started.")
-            self.app.inform.emit(_("NCC Tool. Finished non-copper polygons. Normal copper clearing task started."))
-
-            # provide the app with a way to process the GUI events when in a blocking loop
-            if not run_threaded:
-                QtWidgets.QApplication.processEvents()
-
-            # a flag to signal that the isolation is broken by the bounding box in 'area' and 'box' cases
-            # will store the number of tools for which the isolation is broken
-            warning_flag = 0
-
-            if order == 'fwd':
-                sorted_clear_tools.sort(reverse=False)
-            elif order == 'rev':
-                sorted_clear_tools.sort(reverse=True)
-            else:
-                pass
-
-            cleared_geo = []
-            cleared = MultiPolygon()  # Already cleared area
-            app_obj.poly_not_cleared = False  # flag for polygons not cleared
-
-            # Generate area for each tool
-            offset = sum(sorted_clear_tools)
-            current_uid = int(1)
-            # try:
-            #     tool = eval(self.app.defaults["tools_ncctools"])[0]
-            # except TypeError:
-            #     tool = eval(self.app.defaults["tools_ncctools"])
-
-            if ncc_select == _("Reference Object"):
-                bbox_geo, bbox_kind = self.calculate_bounding_box(
-                    ncc_obj=ncc_obj, box_obj=sel_obj, ncc_select=ncc_select)
-            else:
-                bbox_geo, bbox_kind = self.calculate_bounding_box(ncc_obj=ncc_obj, ncc_select=ncc_select)
-
-            if bbox_geo is None and bbox_kind is None:
-                self.app.inform.emit("[ERROR_NOTCL] %s" % _("NCC Tool failed creating bounding box."))
-                return "fail"
-
-            # COPPER CLEARING with tools marked for CLEAR#
-            for tool in sorted_clear_tools:
-                log.debug("Starting geometry processing for tool: %s" % str(tool))
-                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
-                if not run_threaded:
-                    QtWidgets.QApplication.processEvents()
-
-                app_obj.inform.emit('[success] %s = %s%s %s' % (
-                    _('NCC Tool clearing with tool diameter'), str(tool), units.lower(), _('started.'))
-                                    )
-                app_obj.proc_container.update_view_text(' %d%%' % 0)
-
-                tool_uid = 0  # find the current tool_uid
-                for k, v in self.iso_tools.items():
-                    if float('%.*f' % (self.decimals, v['tooldia'])) == float('%.*f' % (self.decimals, tool)):
-                        tool_uid = int(k)
-                        break
-
-                # parameters that are particular to the current tool
-                ncc_overlap = float(self.iso_tools[tool_uid]["data"]["tools_nccoverlap"]) / 100.0
-                ncc_margin = float(self.iso_tools[tool_uid]["data"]["tools_nccmargin"])
-                ncc_method = self.iso_tools[tool_uid]["data"]["tools_nccmethod"]
-                ncc_connect = self.iso_tools[tool_uid]["data"]["tools_nccconnect"]
-                ncc_contour = self.iso_tools[tool_uid]["data"]["tools_ncccontour"]
-                has_offset = self.iso_tools[tool_uid]["data"]["tools_ncc_offset_choice"]
-                ncc_offset = float(self.iso_tools[tool_uid]["data"]["tools_ncc_offset_value"])
-
-                # Get remaining tools offset
-                offset -= (tool - 1e-12)
-
-                # Bounding box for current tool
-                bbox = self.apply_margin_to_bounding_box(bbox=bbox_geo, box_kind=bbox_kind,
-                                                         ncc_select=ncc_select, ncc_margin=ncc_margin)
-
-                # Area to clear
-                empty, warning_flag = self.get_tool_empty_area(name=name, ncc_obj=ncc_obj, geo_obj=geo_obj,
-                                                               isotooldia=isotooldia, ncc_margin=ncc_margin,
-                                                               has_offset=has_offset, ncc_offset=ncc_offset,
-                                                               tools_storage=tools_storage, bounding_box=bbox)
-
-                area = empty.buffer(-offset)
-                try:
-                    area = area.difference(cleared)
-                except Exception:
-                    continue
-
-                # Transform area to MultiPolygon
-                if isinstance(area, Polygon):
-                    area = MultiPolygon([area])
-
-                # variables to display the percentage of work done
-                geo_len = len(area.geoms)
-
-                old_disp_number = 0
-                log.warning("Total number of polygons to be cleared. %s" % str(geo_len))
-
-                cleared_geo[:] = []
-                if area.geoms:
-                    if len(area.geoms) > 0:
-                        pol_nr = 0
-                        for p in area.geoms:
-                            # provide the app with a way to process the GUI events when in a blocking loop
-                            if not run_threaded:
-                                QtWidgets.QApplication.processEvents()
-
-                            if self.app.abort_flag:
-                                # graceful abort requested by the user
-                                raise grace
-
-                            # clean the polygon
-                            p = p.buffer(0)
-
-                            if p is not None and p.is_valid:
-                                poly_failed = 0
-                                try:
-                                    for pol in p:
-                                        if pol is not None and isinstance(pol, Polygon):
-                                            res = self.clear_polygon_worker(pol=pol, tooldia=tool,
-                                                                            ncc_method=ncc_method,
-                                                                            ncc_overlap=ncc_overlap,
-                                                                            ncc_connect=ncc_connect,
-                                                                            ncc_contour=ncc_contour,
-                                                                            prog_plot=prog_plot)
-                                            if res is not None:
-                                                cleared_geo += res
-                                            else:
-                                                poly_failed += 1
-                                        else:
-                                            log.warning("Expected geo is a Polygon. Instead got a %s" % str(type(pol)))
-                                except TypeError:
-                                    if isinstance(p, Polygon):
-                                        res = self.clear_polygon_worker(pol=p, tooldia=tool,
-                                                                        ncc_method=ncc_method,
-                                                                        ncc_overlap=ncc_overlap,
-                                                                        ncc_connect=ncc_connect,
-                                                                        ncc_contour=ncc_contour,
-                                                                        prog_plot=prog_plot)
-                                        if res is not None:
-                                            cleared_geo += res
-                                        else:
-                                            poly_failed += 1
-                                    else:
-                                        log.warning("Expected geo is a Polygon. Instead got a %s" % str(type(p)))
-
-                                if poly_failed > 0:
-                                    app_obj.poly_not_cleared = True
-
-                                pol_nr += 1
-                                disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))
-                                # log.debug("Polygons cleared: %d" % pol_nr)
-
-                                if old_disp_number < disp_number <= 100:
-                                    self.app.proc_container.update_view_text(' %d%%' % disp_number)
-                                    old_disp_number = disp_number
-                                    # log.debug("Polygons cleared: %d. Percentage done: %d%%" % (pol_nr, disp_number))
-
-                        # check if there is a geometry at all in the cleared geometry
-                        if cleared_geo:
-                            cleared = empty.buffer(-offset * (1 + ncc_overlap))  # Overall cleared area
-                            cleared = cleared.buffer(-tool / 1.999999).buffer(tool / 1.999999)
-
-                            # clean-up cleared geo
-                            cleared = cleared.buffer(0)
-
-                            # find the tooluid associated with the current tool_dia so we know where to add the tool
-                            # solid_geometry
-                            for k, v in tools_storage.items():
-                                if float('%.*f' % (self.decimals, v['tooldia'])) == float('%.*f' % (self.decimals,
-                                                                                                    tool)):
-                                    current_uid = int(k)
-
-                                    # add the solid_geometry to the current too in self.paint_tools dictionary
-                                    # and then reset the temporary list that stored that solid_geometry
-                                    v['solid_geometry'] = deepcopy(cleared_geo)
-                                    v['data']['name'] = name
-                                    break
-                            geo_obj.tools[current_uid] = dict(tools_storage[current_uid])
-                        else:
-                            log.debug("There are no geometries in the cleared polygon.")
-            # clean the progressive plotted shapes if it was used
-            if self.app.defaults["tools_iso_plotting"] == 'progressive':
-                self.temp_shapes.clear(update=True)
-
-            # delete tools with empty geometry
-            # look for keys in the tools_storage dict that have 'solid_geometry' values empty
-            for uid, uid_val in list(tools_storage.items()):
-                try:
-                    # if the solid_geometry (type=list) is empty
-                    if not uid_val['solid_geometry']:
-                        tools_storage.pop(uid, None)
-                except KeyError:
-                    tools_storage.pop(uid, None)
-
-            geo_obj.options["cnctooldia"] = str(tool)
-
-            geo_obj.multigeo = True
-            geo_obj.tools.clear()
-            geo_obj.tools = dict(tools_storage)
-
-            # test if at least one tool has solid_geometry. If no tool has solid_geometry we raise an Exception
-            has_solid_geo = 0
-            for tid in geo_obj.tools:
-                if geo_obj.tools[tid]['solid_geometry']:
-                    has_solid_geo += 1
-            if has_solid_geo == 0:
-                app_obj.inform.emit('[ERROR] %s' %
-                                    _("There is no NCC Geometry in the file.\n"
-                                      "Usually it means that the tool diameter is too big for the painted geometry.\n"
-                                      "Change the painting parameters and try again."))
-                return 'fail'
-
-            # check to see if geo_obj.tools is empty
-            # it will be updated only if there is a solid_geometry for tools
-            if geo_obj.tools:
-                if warning_flag == 0:
-                    self.app.inform.emit('[success] %s' % _("NCC Tool clear all done."))
-                else:
-                    self.app.inform.emit('[WARNING] %s: %s %s.' % (
-                        _("NCC Tool clear all done but the copper features isolation is broken for"),
-                        str(warning_flag),
-                        _("tools")))
-                    return
-
-                # create the solid_geometry
-                geo_obj.solid_geometry = []
-                for tool_id in geo_obj.tools:
-                    if geo_obj.tools[tool_id]['solid_geometry']:
-                        try:
-                            for geo in geo_obj.tools[tool_id]['solid_geometry']:
-                                geo_obj.solid_geometry.append(geo)
-                        except TypeError:
-                            geo_obj.solid_geometry.append(geo_obj.tools[tool_id]['solid_geometry'])
-            else:
-                # I will use this variable for this purpose although it was meant for something else
-                # signal that we have no geo in the object therefore don't create it
-                app_obj.poly_not_cleared = False
-                return "fail"
-
-            # # Experimental...
-            # # print("Indexing...", end=' ')
-            # # geo_obj.make_index()
-
-        # ###########################################################################################
-        # Initializes the new geometry object for the case of the rest-machining ####################
-        # ###########################################################################################
-        def gen_clear_area_rest(geo_obj, app_obj):
-            assert geo_obj.kind == 'geometry', \
-                "Initializer expected a GeometryObject, got %s" % type(geo_obj)
-
-            log.debug("NCC Tool. Rest machining copper clearing task started.")
-            app_obj.inform.emit('_(NCC Tool. Rest machining copper clearing task started.')
-
-            # provide the app with a way to process the GUI events when in a blocking loop
-            if not run_threaded:
-                QtWidgets.QApplication.processEvents()
-
-            # a flag to signal that the isolation is broken by the bounding box in 'area' and 'box' cases
-            # will store the number of tools for which the isolation is broken
-            warning_flag = 0
-
-            sorted_clear_tools.sort(reverse=True)
-
-            cleared_geo = []
-            cleared_by_last_tool = []
-            rest_geo = []
-            current_uid = 1
-            try:
-                tool = eval(self.app.defaults["tools_ncctools"])[0]
-            except TypeError:
-                tool = eval(self.app.defaults["tools_ncctools"])
-
-            # repurposed flag for final object, geo_obj. True if it has any solid_geometry, False if not.
-            app_obj.poly_not_cleared = True
-
-            if ncc_select == _("Reference Object"):
-                env_obj, box_obj_kind = self.calculate_bounding_box(
-                    ncc_obj=ncc_obj, box_obj=sel_obj, ncc_select=ncc_select)
-            else:
-                env_obj, box_obj_kind = self.calculate_bounding_box(ncc_obj=ncc_obj, ncc_select=ncc_select)
-
-            if env_obj is None and box_obj_kind is None:
-                self.app.inform.emit("[ERROR_NOTCL] %s" % _("NCC Tool failed creating bounding box."))
-                return "fail"
-
-            log.debug("NCC Tool. Calculate 'empty' area.")
-            app_obj.inform.emit("NCC Tool. Calculate 'empty' area.")
-
-            # Generate area for each tool
-            while sorted_clear_tools:
-                log.debug("Starting geometry processing for tool: %s" % str(tool))
-                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()
-
-                app_obj.inform.emit('[success] %s = %s%s %s' % (
-                    _('NCC Tool clearing with tool diameter'), str(tool), units.lower(), _('started.'))
-                                    )
-                app_obj.proc_container.update_view_text(' %d%%' % 0)
-
-                tool = sorted_clear_tools.pop(0)
-
-                tool_uid = 0
-                for k, v in self.iso_tools.items():
-                    if float('%.*f' % (self.decimals, v['tooldia'])) == float('%.*f' % (self.decimals, tool)):
-                        tool_uid = int(k)
-                        break
-
-                ncc_overlap = float(self.iso_tools[tool_uid]["data"]["tools_nccoverlap"]) / 100.0
-                ncc_margin = float(self.iso_tools[tool_uid]["data"]["tools_nccmargin"])
-                ncc_method = self.iso_tools[tool_uid]["data"]["tools_nccmethod"]
-                ncc_connect = self.iso_tools[tool_uid]["data"]["tools_nccconnect"]
-                ncc_contour = self.iso_tools[tool_uid]["data"]["tools_ncccontour"]
-                has_offset = self.iso_tools[tool_uid]["data"]["tools_ncc_offset_choice"]
-                ncc_offset = float(self.iso_tools[tool_uid]["data"]["tools_ncc_offset_value"])
-
-                tool_used = tool - 1e-12
-                cleared_geo[:] = []
-
-                # Bounding box for current tool
-                bbox = self.apply_margin_to_bounding_box(bbox=env_obj, box_kind=box_obj_kind,
-                                                         ncc_select=ncc_select, ncc_margin=ncc_margin)
-
-                # Area to clear
-                empty, warning_flag = self.get_tool_empty_area(name=name, ncc_obj=ncc_obj, geo_obj=geo_obj,
-                                                               isotooldia=isotooldia,
-                                                               has_offset=has_offset, ncc_offset=ncc_offset,
-                                                               ncc_margin=ncc_margin, tools_storage=tools_storage,
-                                                               bounding_box=bbox)
-
-                area = empty.buffer(0)
-
-                # Area to clear
-                for poly in cleared_by_last_tool:
-                    # provide the app with a way to process the GUI events when in a blocking loop
-                    QtWidgets.QApplication.processEvents()
-
-                    if self.app.abort_flag:
-                        # graceful abort requested by the user
-                        raise grace
-                    try:
-                        area = area.difference(poly)
-                    except Exception:
-                        pass
-                cleared_by_last_tool[:] = []
-
-                # Transform area to MultiPolygon
-                if type(area) is Polygon:
-                    area = MultiPolygon([area])
-
-                # add the rest that was not able to be cleared previously; area is a MultyPolygon
-                # and rest_geo it's a list
-                allparts = [p.buffer(0) for p in area.geoms]
-                allparts += deepcopy(rest_geo)
-                rest_geo[:] = []
-                area = MultiPolygon(deepcopy(allparts))
-                allparts[:] = []
-
-                # variables to display the percentage of work done
-                geo_len = len(area.geoms)
-                old_disp_number = 0
-                log.warning("Total number of polygons to be cleared. %s" % str(geo_len))
-
-                if area.geoms:
-                    if len(area.geoms) > 0:
-                        pol_nr = 0
-                        for p in area.geoms:
-                            if self.app.abort_flag:
-                                # graceful abort requested by the user
-                                raise grace
-
-                            # clean the polygon
-                            p = p.buffer(0)
-
-                            if p is not None and p.is_valid:
-                                # provide the app with a way to process the GUI events when in a blocking loop
-                                QtWidgets.QApplication.processEvents()
-
-                                if isinstance(p, Polygon):
-                                    try:
-                                        if ncc_method == _("Standard"):
-                                            cp = self.clear_polygon(p, tool_used,
-                                                                    self.grb_circle_steps,
-                                                                    overlap=ncc_overlap, contour=ncc_contour,
-                                                                    connect=ncc_connect,
-                                                                    prog_plot=prog_plot)
-                                        elif ncc_method == _("Seed"):
-                                            cp = self.clear_polygon2(p, tool_used,
-                                                                     self.grb_circle_steps,
-                                                                     overlap=ncc_overlap, contour=ncc_contour,
-                                                                     connect=ncc_connect,
-                                                                     prog_plot=prog_plot)
-                                        else:
-                                            cp = self.clear_polygon3(p, tool_used,
-                                                                     self.grb_circle_steps,
-                                                                     overlap=ncc_overlap, contour=ncc_contour,
-                                                                     connect=ncc_connect,
-                                                                     prog_plot=prog_plot)
-                                        cleared_geo.append(list(cp.get_objects()))
-                                    except Exception as e:
-                                        log.warning("Polygon can't be cleared. %s" % str(e))
-                                        # this polygon should be added to a list and then try clear it with
-                                        # a smaller tool
-                                        rest_geo.append(p)
-                                elif isinstance(p, MultiPolygon):
-                                    for poly in p:
-                                        if poly is not None:
-                                            # provide the app with a way to process the GUI events when
-                                            # in a blocking loop
-                                            QtWidgets.QApplication.processEvents()
-
-                                            try:
-                                                if ncc_method == _("Standard"):
-                                                    cp = self.clear_polygon(poly, tool_used,
-                                                                            self.grb_circle_steps,
-                                                                            overlap=ncc_overlap, contour=ncc_contour,
-                                                                            connect=ncc_connect,
-                                                                            prog_plot=prog_plot)
-                                                elif ncc_method == _("Seed"):
-                                                    cp = self.clear_polygon2(poly, tool_used,
-                                                                             self.grb_circle_steps,
-                                                                             overlap=ncc_overlap, contour=ncc_contour,
-                                                                             connect=ncc_connect,
-                                                                             prog_plot=prog_plot)
-                                                else:
-                                                    cp = self.clear_polygon3(poly, tool_used,
-                                                                             self.grb_circle_steps,
-                                                                             overlap=ncc_overlap, contour=ncc_contour,
-                                                                             connect=ncc_connect,
-                                                                             prog_plot=prog_plot)
-                                                cleared_geo.append(list(cp.get_objects()))
-                                            except Exception as e:
-                                                log.warning("Polygon can't be cleared. %s" % str(e))
-                                                # this polygon should be added to a list and then try clear it with
-                                                # a smaller tool
-                                                rest_geo.append(poly)
-
-                                pol_nr += 1
-                                disp_number = int(np.interp(pol_nr, [0, geo_len], [0, 100]))
-                                # log.debug("Polygons cleared: %d" % pol_nr)
-
-                                if old_disp_number < disp_number <= 100:
-                                    self.app.proc_container.update_view_text(' %d%%' % disp_number)
-                                    old_disp_number = disp_number
-                                    # log.debug("Polygons cleared: %d. Percentage done: %d%%" % (pol_nr, disp_number))
-
-                        if self.app.abort_flag:
-                            # graceful abort requested by the user
-                            raise grace
-
-                        # check if there is a geometry at all in the cleared geometry
-                        if cleared_geo:
-                            # Overall cleared area
-                            cleared_area = list(self.flatten_list(cleared_geo))
-
-                            # cleared = MultiPolygon([p.buffer(tool_used / 2).buffer(-tool_used / 2)
-                            #                         for p in cleared_area])
-
-                            # here we store the poly's already processed in the original geometry by the current tool
-                            # into cleared_by_last_tool list
-                            # this will be sutracted from the original geometry_to_be_cleared and make data for
-                            # the next tool
-                            buffer_value = tool_used / 2
-                            for p in cleared_area:
-                                if self.app.abort_flag:
-                                    # graceful abort requested by the user
-                                    raise grace
-
-                                poly = p.buffer(buffer_value)
-                                cleared_by_last_tool.append(poly)
-
-                            # find the tool uid associated with the current tool_dia so we know
-                            # where to add the tool solid_geometry
-                            for k, v in tools_storage.items():
-                                if float('%.*f' % (self.decimals, v['tooldia'])) == float('%.*f' % (self.decimals,
-                                                                                                    tool)):
-                                    current_uid = int(k)
-
-                                    # add the solid_geometry to the current too in self.paint_tools dictionary
-                                    # and then reset the temporary list that stored that solid_geometry
-                                    v['solid_geometry'] = deepcopy(cleared_area)
-                                    v['data']['name'] = name
-                                    cleared_area[:] = []
-                                    break
-
-                            geo_obj.tools[current_uid] = dict(tools_storage[current_uid])
-                        else:
-                            log.debug("There are no geometries in the cleared polygon.")
-
-            geo_obj.multigeo = True
-            geo_obj.options["cnctooldia"] = str(tool)
-
-            # clean the progressive plotted shapes if it was used
-            if self.app.defaults["tools_iso_plotting"] == 'progressive':
-                self.temp_shapes.clear(update=True)
-
-            # check to see if geo_obj.tools is empty
-            # it will be updated only if there is a solid_geometry for tools
-            if geo_obj.tools:
-                if warning_flag == 0:
-                    self.app.inform.emit('[success] %s' % _("NCC Tool Rest Machining clear all done."))
-                else:
-                    self.app.inform.emit(
-                        '[WARNING] %s: %s %s.' % (_("NCC Tool Rest Machining clear all done but the copper features "
-                                                    "isolation is broken for"), str(warning_flag), _("tools")))
-                    return
-
-                # create the solid_geometry
-                geo_obj.solid_geometry = []
-                for tool_uid in geo_obj.tools:
-                    if geo_obj.tools[tool_uid]['solid_geometry']:
-                        try:
-                            for geo in geo_obj.tools[tool_uid]['solid_geometry']:
-                                geo_obj.solid_geometry.append(geo)
-                        except TypeError:
-                            geo_obj.solid_geometry.append(geo_obj.tools[tool_uid]['solid_geometry'])
-            else:
-                # I will use this variable for this purpose although it was meant for something else
-                # signal that we have no geo in the object therefore don't create it
-                app_obj.poly_not_cleared = False
-                return "fail"
-
-        # ###########################################################################################
-        # Create the Job function and send it to the worker to be processed in another thread #######
-        # ###########################################################################################
-        def job_thread(a_obj):
-            try:
-                if rest_machining_choice is True:
-                    a_obj.app_obj.new_object("geometry", name, gen_clear_area_rest)
-                else:
-                    a_obj.app_obj.new_object("geometry", name, gen_clear_area)
-            except grace:
-                if run_threaded:
-                    proc.done()
-                return
-            except Exception:
-                if run_threaded:
-                    proc.done()
-                traceback.print_stack()
-                return
-
-            if run_threaded:
-                proc.done()
-            else:
-                a_obj.proc_container.view.set_idle()
-
-            # focus on Selected Tab
-            self.app.ui.notebook.setCurrentWidget(self.app.ui.selected_tab)
-
-        if run_threaded:
-            # Promise object with the new name
-            self.app.collection.promise(name)
-
-            # Background
-            self.app.worker_task.emit({'fcn': job_thread, 'params': [self.app]})
-        else:
-            job_thread(app_obj=self.app)
-
     @staticmethod
     def poly2rings(poly):
         return [poly.exterior] + [interior for interior in poly.interiors]