- modified behind the scene the UI for Tool Subtract

- modified some strings and updated the translation strings
- in NCC Tool added a check for the validity of the used tools; its only informative
- in NCC Tool done some refactoring

CHANGELOG.md

@@ -10,6 +10,10 @@ CHANGELOG for FlatCAM beta
 22.10.2020
 
 - added  a message to show if voronoi_diagram method can be used (require Shapely >= 1.8)
+- modified behind the scene the UI for Tool Subtract
+- modified some strings and updated the translation strings
+- in NCC Tool added a check for the validity of the used tools; its only informative
+- in NCC Tool done some refactoring
 
 21.10.2020
 

appDatabase.py

@@ -2388,13 +2388,13 @@ class ToolsDB2(QtWidgets.QWidget):
             "extracut_length":  self.ui.ecut_length_entry,
 
             # NCC
-            "tools_nccoperation":       self.ui.op_radio,
-            "tools_nccmilling_type":    self.ui.milling_type_radio,
-            "tools_nccoverlap":         self.ui.ncc_overlap_entry,
-            "tools_nccmargin":          self.ui.ncc_margin_entry,
-            "tools_nccmethod":          self.ui.ncc_method_combo,
-            "tools_nccconnect":         self.ui.ncc_connect_cb,
-            "tools_ncccontour":         self.ui.ncc_contour_cb,
+            "tools_ncc_operation":       self.ui.op_radio,
+            "tools_ncc_milling_type":    self.ui.milling_type_radio,
+            "tools_ncc_overlap":         self.ui.ncc_overlap_entry,
+            "tools_ncc_margin":          self.ui.ncc_margin_entry,
+            "tools_ncc_method":          self.ui.ncc_method_combo,
+            "tools_ncc_connect":         self.ui.ncc_connect_cb,
+            "tools_ncc_contour":         self.ui.ncc_contour_cb,
             "tools_ncc_offset_choice":  self.ui.ncc_choice_offset_cb,
             "tools_ncc_offset_value":   self.ui.ncc_offset_spinner,
 
@@ -2472,15 +2472,15 @@ class ToolsDB2(QtWidgets.QWidget):
             "gdb_ecut_length":      "extracut_length",
 
             # NCC
-            "gdb_n_operation":      "tools_nccoperation",
-            "gdb_n_overlap":        "tools_nccoverlap",
-            "gdb_n_margin":         "tools_nccmargin",
-            "gdb_n_method":         "tools_nccmethod",
-            "gdb_n_connect":        "tools_nccconnect",
-            "gdb_n_contour":        "tools_ncccontour",
+            "gdb_n_operation":      "tools_ncc_operation",
+            "gdb_n_overlap":        "tools_ncc_overlap",
+            "gdb_n_margin":         "tools_ncc_margin",
+            "gdb_n_method":         "tools_ncc_method",
+            "gdb_n_connect":        "tools_ncc_connect",
+            "gdb_n_contour":        "tools_ncc_contour",
             "gdb_n_offset":         "tools_ncc_offset_choice",
             "gdb_n_offset_value":   "tools_ncc_offset_value",
-            "gdb_n_milling_type":   "tools_nccmilling_type",
+            "gdb_n_milling_type":   "tools_ncc_milling_type",
 
             # Paint
             'gdb_p_overlap':        "tools_paintoverlap",
@@ -2818,13 +2818,13 @@ class ToolsDB2(QtWidgets.QWidget):
             "endz":             float(self.app.defaults["geometry_endz"]),
 
             # NCC
-            "tools_nccoperation":       self.app.defaults["tools_nccoperation"],
-            "tools_nccmilling_type":    self.app.defaults["tools_nccmilling_type"],
-            "tools_nccoverlap":         float(self.app.defaults["tools_nccoverlap"]),
-            "tools_nccmargin":          float(self.app.defaults["tools_nccmargin"]),
-            "tools_nccmethod":          self.app.defaults["tools_nccmethod"],
-            "tools_nccconnect":         self.app.defaults["tools_nccconnect"],
-            "tools_ncccontour":         self.app.defaults["tools_ncccontour"],
+            "tools_ncc_operation":       self.app.defaults["tools_ncc_operation"],
+            "tools_ncc_milling_type":    self.app.defaults["tools_ncc_milling_type"],
+            "tools_ncc_overlap":         float(self.app.defaults["tools_ncc_overlap"]),
+            "tools_ncc_margin":          float(self.app.defaults["tools_ncc_margin"]),
+            "tools_ncc_method":          self.app.defaults["tools_ncc_method"],
+            "tools_ncc_connect":         self.app.defaults["tools_ncc_connect"],
+            "tools_ncc_contour":         self.app.defaults["tools_ncc_contour"],
             "tools_ncc_offset_choice":  self.app.defaults["tools_ncc_offset_choice"],
             "tools_ncc_offset_value":   float(self.app.defaults["tools_ncc_offset_value"]),
 
@@ -3349,23 +3349,23 @@ class ToolsDB2(QtWidgets.QWidget):
 
             # NCC Tool
             elif wdg_name == "gdb_n_operation":
-                self.db_tool_dict[tool_id]['data']['tools_nccoperation'] = val
+                self.db_tool_dict[tool_id]['data']['tools_ncc_operation'] = val
             elif wdg_name == "gdb_n_overlap":
-                self.db_tool_dict[tool_id]['data']['tools_nccoverlap'] = val
+                self.db_tool_dict[tool_id]['data']['tools_ncc_overlap'] = val
             elif wdg_name == "gdb_n_margin":
-                self.db_tool_dict[tool_id]['data']['tools_nccmargin'] = val
+                self.db_tool_dict[tool_id]['data']['tools_ncc_margin'] = val
             elif wdg_name == "gdb_n_method":
-                self.db_tool_dict[tool_id]['data']['tools_nccmethod'] = val
+                self.db_tool_dict[tool_id]['data']['tools_ncc_method'] = val
             elif wdg_name == "gdb_n_connect":
-                self.db_tool_dict[tool_id]['data']['tools_nccconnect'] = val
+                self.db_tool_dict[tool_id]['data']['tools_ncc_connect'] = val
             elif wdg_name == "gdb_n_contour":
-                self.db_tool_dict[tool_id]['data']['tools_ncccontour'] = val
+                self.db_tool_dict[tool_id]['data']['tools_ncc_contour'] = val
             elif wdg_name == "gdb_n_offset":
                 self.db_tool_dict[tool_id]['data']['tools_ncc_offset_choice'] = val
             elif wdg_name == "gdb_n_offset_value":
                 self.db_tool_dict[tool_id]['data']['tools_ncc_offset_value'] = val
             elif wdg_name == "gdb_n_milling_type":
-                self.db_tool_dict[tool_id]['data']['tools_nccmilling_type'] = val
+                self.db_tool_dict[tool_id]['data']['tools_ncc_milling_type'] = val
 
             # Paint Tool
             elif wdg_name == "gdb_p_overlap":

appGUI/ObjectUI.py

@@ -1783,13 +1783,10 @@ class GeometryObjectUI(ObjectUI):
         self.paint_tool_button = QtWidgets.QPushButton(_('Paint Tool'))
         self.paint_tool_button.setIcon(QtGui.QIcon(self.app.resource_location + '/paint20_1.png'))
         self.paint_tool_button.setToolTip(
-            _(
-                "Creates tool paths to cover the\n"
-                "whole area of a polygon (remove\n"
-                "all copper). You will be asked\n"
-                "to click on the desired polygon."
-            )
+            _("Creates tool paths to cover the\n"
+              "whole area of a polygon.")
         )
+
         # self.paint_tool_button.setStyleSheet("""
         #                 QPushButton
         #                 {

appGUI/preferences/PreferencesUIManager.py

@@ -389,25 +389,26 @@ class PreferencesUIManager:
             "tools_drill_area_overz":       self.ui.tools_defaults_form.tools_drill_group.over_z_entry,
 
             # NCC Tool
-            "tools_ncctools":           self.ui.tools_defaults_form.tools_ncc_group.ncc_tool_dia_entry,
-            "tools_nccorder":           self.ui.tools_defaults_form.tools_ncc_group.ncc_order_radio,
-            "tools_nccoverlap":         self.ui.tools_defaults_form.tools_ncc_group.ncc_overlap_entry,
-            "tools_nccmargin":          self.ui.tools_defaults_form.tools_ncc_group.ncc_margin_entry,
-            "tools_nccmethod":          self.ui.tools_defaults_form.tools_ncc_group.ncc_method_combo,
-            "tools_nccconnect":         self.ui.tools_defaults_form.tools_ncc_group.ncc_connect_cb,
-            "tools_ncccontour":         self.ui.tools_defaults_form.tools_ncc_group.ncc_contour_cb,
-            "tools_nccrest":            self.ui.tools_defaults_form.tools_ncc_group.ncc_rest_cb,
+            "tools_ncc_tools":           self.ui.tools_defaults_form.tools_ncc_group.ncc_tool_dia_entry,
+            "tools_ncc_order":           self.ui.tools_defaults_form.tools_ncc_group.ncc_order_radio,
+            "tools_ncc_overlap":         self.ui.tools_defaults_form.tools_ncc_group.ncc_overlap_entry,
+            "tools_ncc_margin":          self.ui.tools_defaults_form.tools_ncc_group.ncc_margin_entry,
+            "tools_ncc_method":          self.ui.tools_defaults_form.tools_ncc_group.ncc_method_combo,
+            "tools_ncc_connect":         self.ui.tools_defaults_form.tools_ncc_group.ncc_connect_cb,
+            "tools_ncc_contour":         self.ui.tools_defaults_form.tools_ncc_group.ncc_contour_cb,
+            "tools_ncc_rest":            self.ui.tools_defaults_form.tools_ncc_group.ncc_rest_cb,
             "tools_ncc_offset_choice":  self.ui.tools_defaults_form.tools_ncc_group.ncc_choice_offset_cb,
             "tools_ncc_offset_value":   self.ui.tools_defaults_form.tools_ncc_group.ncc_offset_spinner,
-            "tools_nccref":             self.ui.tools_defaults_form.tools_ncc_group.select_combo,
+            "tools_ncc_ref":             self.ui.tools_defaults_form.tools_ncc_group.select_combo,
             "tools_ncc_area_shape":     self.ui.tools_defaults_form.tools_ncc_group.area_shape_radio,
-            "tools_nccmilling_type":    self.ui.tools_defaults_form.tools_ncc_group.milling_type_radio,
-            "tools_ncctool_type":       self.ui.tools_defaults_form.tools_ncc_group.tool_type_radio,
-            "tools_ncccutz":            self.ui.tools_defaults_form.tools_ncc_group.cutz_entry,
-            "tools_ncctipdia":          self.ui.tools_defaults_form.tools_ncc_group.tipdia_entry,
-            "tools_ncctipangle":        self.ui.tools_defaults_form.tools_ncc_group.tipangle_entry,
-            "tools_nccnewdia":          self.ui.tools_defaults_form.tools_ncc_group.newdia_entry,
+            "tools_ncc_milling_type":    self.ui.tools_defaults_form.tools_ncc_group.milling_type_radio,
+            "tools_ncc_tool_type":       self.ui.tools_defaults_form.tools_ncc_group.tool_type_radio,
+            "tools_ncc_cutz":            self.ui.tools_defaults_form.tools_ncc_group.cutz_entry,
+            "tools_ncc_tipdia":          self.ui.tools_defaults_form.tools_ncc_group.tipdia_entry,
+            "tools_ncc_tipangle":        self.ui.tools_defaults_form.tools_ncc_group.tipangle_entry,
+            "tools_ncc_newdia":          self.ui.tools_defaults_form.tools_ncc_group.newdia_entry,
             "tools_ncc_plotting":       self.ui.tools_defaults_form.tools_ncc_group.plotting_radio,
+            "tools_ncc_check_valid":    self.ui.tools_defaults_form.tools_ncc_group.valid_cb,
 
             # CutOut Tool
             "tools_cutout_tooldia":          self.ui.tools_defaults_form.tools_cutout_group.cutout_tooldia_entry,

appGUI/preferences/tools/ToolsNCCPrefGroupUI.py

@@ -346,4 +346,14 @@ class ToolsNCCPrefGroupUI(OptionsGroupUI):
         grid0.addWidget(plotting_label, 21, 0)
         grid0.addWidget(self.plotting_radio, 21, 1)
 
+        # Check Tool validity
+        self.valid_cb = FCCheckBox(label=_('Check validity'))
+        self.valid_cb.setToolTip(
+            _("If checked then the tools diameters are verified\n"
+              "if they will provide a complete isolation.")
+        )
+        self.valid_cb.setObjectName("n_check")
+
+        grid0.addWidget(self.valid_cb, 23, 0, 1, 2)
+
         self.layout.addStretch()

appGUI/preferences/tools/ToolsPaintPrefGroupUI.py

@@ -33,9 +33,7 @@ class ToolsPaintPrefGroupUI(OptionsGroupUI):
         self.paint_label = QtWidgets.QLabel(_('<b>Parameters:</b>'))
         self.paint_label.setToolTip(
             _("Creates tool paths to cover the\n"
-              "whole area of a polygon (remove\n"
-              "all copper). You will be asked\n"
-              "to click on the desired polygon.")
+              "whole area of a polygon.")
         )
         self.layout.addWidget(self.paint_label)
 

appParsers/ParseHPGL2.py

@@ -90,17 +90,17 @@ class HPGL2:
             "tools_paintoverlap":       self.app.defaults["tools_paintoverlap"],
             "tools_paintrest":          self.app.defaults["tools_paintrest"],
 
-            "tools_nccoperation":       self.app.defaults["tools_nccoperation"],
-            "tools_nccmargin":          self.app.defaults["tools_nccmargin"],
-            "tools_nccmethod":          self.app.defaults["tools_nccmethod"],
-            "tools_nccconnect":         self.app.defaults["tools_nccconnect"],
-            "tools_ncccontour":         self.app.defaults["tools_ncccontour"],
-            "tools_nccoverlap":         self.app.defaults["tools_nccoverlap"],
-            "tools_nccrest":            self.app.defaults["tools_nccrest"],
-            "tools_nccref":             self.app.defaults["tools_nccref"],
+            "tools_ncc_operation":       self.app.defaults["tools_ncc_operation"],
+            "tools_ncc_margin":          self.app.defaults["tools_ncc_margin"],
+            "tools_ncc_method":          self.app.defaults["tools_ncc_method"],
+            "tools_ncc_connect":         self.app.defaults["tools_ncc_connect"],
+            "tools_ncc_contour":         self.app.defaults["tools_ncc_contour"],
+            "tools_ncc_overlap":         self.app.defaults["tools_ncc_overlap"],
+            "tools_ncc_rest":            self.app.defaults["tools_ncc_rest"],
+            "tools_ncc_ref":             self.app.defaults["tools_ncc_ref"],
             "tools_ncc_offset_choice":  self.app.defaults["tools_ncc_offset_choice"],
             "tools_ncc_offset_value":   self.app.defaults["tools_ncc_offset_value"],
-            "tools_nccmilling_type":    self.app.defaults["tools_nccmilling_type"],
+            "tools_ncc_milling_type":    self.app.defaults["tools_ncc_milling_type"],
 
             "tools_iso_passes":         self.app.defaults["tools_iso_passes"],
             "tools_iso_overlap":        self.app.defaults["tools_iso_overlap"],

appTools/ToolDblSided.py

@@ -518,10 +518,7 @@ class DsidedUI:
         # Type of object to be cutout
         self.type_obj_combo_label = QtWidgets.QLabel('%s:' % _("Type"))
         self.type_obj_combo_label.setToolTip(
-            _("Specify the type of object to be cutout.\n"
-              "It can be of type: Gerber or Geometry.\n"
-              "What is selected here will dictate the kind\n"
-              "of objects that will populate the 'Object' combobox.")
+            _("Select the type of application object to be processed in this tool.")
         )
 
         self.object_type_radio = RadioSet([

appTools/ToolNCC.py

@@ -98,6 +98,9 @@ class NonCopperClear(AppTool, Gerber):
         self.contour = None
         self.rest = None
 
+        # store here the tool diameter that is guaranteed to isolate the object
+        self.safe_tooldia = None
+
         self.first_click = False
         self.cursor_pos = None
         self.mouse_is_dragging = False
@@ -126,27 +129,29 @@ class NonCopperClear(AppTool, Gerber):
         self.tooldia = None
 
         self.form_fields = {
-            "tools_nccoperation": self.ui.op_radio,
-            "tools_nccoverlap": self.ui.ncc_overlap_entry,
-            "tools_nccmargin": self.ui.ncc_margin_entry,
-            "tools_nccmethod": self.ui.ncc_method_combo,
-            "tools_nccconnect": self.ui.ncc_connect_cb,
-            "tools_ncccontour": self.ui.ncc_contour_cb,
-            "tools_ncc_offset_choice": self.ui.ncc_choice_offset_cb,
-            "tools_ncc_offset_value": self.ui.ncc_offset_spinner,
-            "tools_nccmilling_type": self.ui.milling_type_radio
+            "tools_ncc_operation":      self.ui.op_radio,
+            "tools_ncc_overlap":        self.ui.ncc_overlap_entry,
+            "tools_ncc_margin":         self.ui.ncc_margin_entry,
+            "tools_ncc_method":         self.ui.ncc_method_combo,
+            "tools_ncc_connect":        self.ui.ncc_connect_cb,
+            "tools_ncc_contour":        self.ui.ncc_contour_cb,
+            "tools_ncc_offset_choice":  self.ui.ncc_choice_offset_cb,
+            "tools_ncc_offset_value":   self.ui.ncc_offset_spinner,
+            "tools_ncc_milling_type":   self.ui.milling_type_radio,
+            "tools_ncc_check_valid":    self.ui.valid_cb
         }
 
         self.name2option = {
-            "n_operation": "tools_nccoperation",
-            "n_overlap": "tools_nccoverlap",
-            "n_margin": "tools_nccmargin",
-            "n_method": "tools_nccmethod",
-            "n_connect": "tools_nccconnect",
-            "n_contour": "tools_ncccontour",
-            "n_offset": "tools_ncc_offset_choice",
-            "n_offset_value": "tools_ncc_offset_value",
-            "n_milling_type": "tools_nccmilling_type",
+            "n_operation":      "tools_ncc_operation",
+            "n_overlap":        "tools_ncc_overlap",
+            "n_margin":         "tools_ncc_margin",
+            "n_method":         "tools_ncc_method",
+            "n_connect":        "tools_ncc_connect",
+            "n_contour":        "tools_ncc_contour",
+            "n_offset":         "tools_ncc_offset_choice",
+            "n_offset_value":   "tools_ncc_offset_value",
+            "n_milling_type":   "tools_ncc_milling_type",
+            "n_check":          "tools_ncc_check_valid",
         }
 
         self.old_tool_dia = None
@@ -241,7 +246,7 @@ class NonCopperClear(AppTool, Gerber):
         current_row = self.ui.tools_table.currentRow()
         try:
             current_uid = int(self.ui.tools_table.item(current_row, 3).text())
-            self.ncc_tools[current_uid]['data']['tools_nccoperation'] = val
+            self.ncc_tools[current_uid]['data']['tools_ncc_operation'] = val
             # TODO got a crash here, a KeyError exception; need to see it again and find out the why
         except AttributeError:
             return
@@ -463,7 +468,10 @@ class NonCopperClear(AppTool, Gerber):
 
     def set_tool_ui(self):
         self.units = self.app.defaults['units'].upper()
-        self.old_tool_dia = self.app.defaults["tools_nccnewdia"]
+        self.old_tool_dia = self.app.defaults["tools_ncc_newdia"]
+
+        # reset the value to prepare for another isolation
+        self.safe_tooldia = None
 
         self.ui.tools_frame.show()
 
@@ -492,29 +500,30 @@ class NonCopperClear(AppTool, Gerber):
             self.on_type_obj_index_changed(val=kind)
             self.on_reference_combo_changed()
 
-        self.ui.op_radio.set_value(self.app.defaults["tools_nccoperation"])
-        self.ui.ncc_order_radio.set_value(self.app.defaults["tools_nccorder"])
-        self.ui.ncc_overlap_entry.set_value(self.app.defaults["tools_nccoverlap"])
-        self.ui.ncc_margin_entry.set_value(self.app.defaults["tools_nccmargin"])
-        self.ui.ncc_method_combo.set_value(self.app.defaults["tools_nccmethod"])
-        self.ui.ncc_connect_cb.set_value(self.app.defaults["tools_nccconnect"])
-        self.ui.ncc_contour_cb.set_value(self.app.defaults["tools_ncccontour"])
+        self.ui.op_radio.set_value(self.app.defaults["tools_ncc_operation"])
+        self.ui.ncc_order_radio.set_value(self.app.defaults["tools_ncc_order"])
+        self.ui.ncc_overlap_entry.set_value(self.app.defaults["tools_ncc_overlap"])
+        self.ui.ncc_margin_entry.set_value(self.app.defaults["tools_ncc_margin"])
+        self.ui.ncc_method_combo.set_value(self.app.defaults["tools_ncc_method"])
+        self.ui.ncc_connect_cb.set_value(self.app.defaults["tools_ncc_connect"])
+        self.ui.ncc_contour_cb.set_value(self.app.defaults["tools_ncc_contour"])
         self.ui.ncc_choice_offset_cb.set_value(self.app.defaults["tools_ncc_offset_choice"])
         self.ui.ncc_offset_spinner.set_value(self.app.defaults["tools_ncc_offset_value"])
 
-        self.ui.ncc_rest_cb.set_value(self.app.defaults["tools_nccrest"])
-        self.ui.rest_ncc_margin_entry.set_value(self.app.defaults["tools_nccmargin"])
-        self.ui.rest_ncc_connect_cb.set_value(self.app.defaults["tools_nccconnect"])
-        self.ui.rest_ncc_contour_cb.set_value(self.app.defaults["tools_ncccontour"])
+        self.ui.ncc_rest_cb.set_value(self.app.defaults["tools_ncc_rest"])
+        self.ui.rest_ncc_margin_entry.set_value(self.app.defaults["tools_ncc_margin"])
+        self.ui.rest_ncc_connect_cb.set_value(self.app.defaults["tools_ncc_connect"])
+        self.ui.rest_ncc_contour_cb.set_value(self.app.defaults["tools_ncc_contour"])
         self.ui.rest_ncc_choice_offset_cb.set_value(self.app.defaults["tools_ncc_offset_choice"])
         self.ui.rest_ncc_offset_spinner.set_value(self.app.defaults["tools_ncc_offset_value"])
 
-        self.ui.select_combo.set_value(self.app.defaults["tools_nccref"])
+        self.ui.select_combo.set_value(self.app.defaults["tools_ncc_ref"])
         self.ui.area_shape_radio.set_value(self.app.defaults["tools_ncc_area_shape"])
+        self.ui.valid_cb.set_value(self.app.defaults["tools_ncc_check_valid"])
 
-        self.ui.milling_type_radio.set_value(self.app.defaults["tools_nccmilling_type"])
+        self.ui.milling_type_radio.set_value(self.app.defaults["tools_ncc_milling_type"])
 
-        self.ui.new_tooldia_entry.set_value(self.app.defaults["tools_nccnewdia"])
+        self.ui.new_tooldia_entry.set_value(self.app.defaults["tools_ncc_newdia"])
 
         # init the working variables
         self.default_data.clear()
@@ -550,26 +559,27 @@ class NonCopperClear(AppTool, Gerber):
             "area_overz":               float(self.app.defaults["geometry_area_overz"]),
             "optimization_type":        self.app.defaults["geometry_optimization_type"],
 
-            "tools_nccoperation":       self.app.defaults["tools_nccoperation"],
-            "tools_nccmargin":          self.app.defaults["tools_nccmargin"],
-            "tools_nccmethod":          self.app.defaults["tools_nccmethod"],
-            "tools_nccconnect":         self.app.defaults["tools_nccconnect"],
-            "tools_ncccontour":         self.app.defaults["tools_ncccontour"],
-            "tools_nccoverlap":         self.app.defaults["tools_nccoverlap"],
-            "tools_nccrest":            self.app.defaults["tools_nccrest"],
-            "tools_nccref":             self.app.defaults["tools_nccref"],
+            "tools_ncc_operation":      self.app.defaults["tools_ncc_operation"],
+            "tools_ncc_margin":         self.app.defaults["tools_ncc_margin"],
+            "tools_ncc_method":         self.app.defaults["tools_ncc_method"],
+            "tools_ncc_connect":        self.app.defaults["tools_ncc_connect"],
+            "tools_ncc_contour":        self.app.defaults["tools_ncc_contour"],
+            "tools_ncc_overlap":        self.app.defaults["tools_ncc_overlap"],
+            "tools_ncc_rest":           self.app.defaults["tools_ncc_rest"],
+            "tools_ncc_ref":            self.app.defaults["tools_ncc_ref"],
             "tools_ncc_offset_choice":  self.app.defaults["tools_ncc_offset_choice"],
             "tools_ncc_offset_value":   self.app.defaults["tools_ncc_offset_value"],
-            "tools_nccmilling_type":    self.app.defaults["tools_nccmilling_type"]
+            "tools_ncc_milling_type":   self.app.defaults["tools_ncc_milling_type"],
+            "tools_ncc_check_valid":    self.app.defaults["tools_ncc_check_valid"],
         }
 
         try:
-            dias = [float(self.app.defaults["tools_ncctools"])]
+            dias = [float(self.app.defaults["tools_ncc_tools"])]
         except (ValueError, TypeError):
             try:
-                dias = [float(eval(dia)) for dia in self.app.defaults["tools_ncctools"].split(",") if dia != '']
+                dias = [float(eval(dia)) for dia in self.app.defaults["tools_ncc_tools"].split(",") if dia != '']
             except AttributeError:
-                dias = self.app.defaults["tools_ncctools"]
+                dias = self.app.defaults["tools_ncc_tools"]
         except Exception:
             dias = []
 
@@ -819,6 +829,10 @@ class NonCopperClear(AppTool, Gerber):
             })
 
     def on_find_optimal_tooldia(self):
+        self.find_safe_tooldia_worker(is_displayed=True)
+
+    def find_safe_tooldia_worker(self, is_displayed):
+        self.app.inform.emit(_("NCC Tool. Checking tools for validity."))
         self.units = self.app.defaults['units'].upper()
 
         obj_name = self.ui.object_combo.currentText()
@@ -836,7 +850,7 @@ class NonCopperClear(AppTool, Gerber):
 
         proc = self.app.proc_container.new(_("Working..."))
 
-        def job_thread(app_obj):
+        def job_thread(app_obj, is_display):
             try:
                 old_disp_number = 0
                 pol_nr = 0
@@ -901,18 +915,48 @@ class NonCopperClear(AppTool, Gerber):
                 min_dist = min(min_list)
 
                 min_dist_truncated = self.app.dec_format(float(min_dist), self.decimals)
+                self.safe_tooldia = min_dist_truncated
+
+                if is_display:
+                    self.optimal_found_sig.emit(min_dist_truncated)
 
-                self.optimal_found_sig.emit(min_dist_truncated)
+                    app_obj.inform.emit('[success] %s: %s %s' %
+                                        (_("Optimal tool diameter found"), str(min_dist_truncated),
+                                         self.units.lower()))
+                else:
+                    # find the selected tool ID's
+                    sorted_tools = []
+                    table_items = self.ui.tools_table.selectedItems()
+                    sel_rows = {t.row() for t in table_items}
+                    for row in sel_rows:
+                        tid = int(self.ui.tools_table.item(row, 3).text())
+                        sorted_tools.append(tid)
+                    if not sorted_tools:
+                        msg = _("There are no tools selected in the Tool Table.")
+                        self.app.inform.emit('[ERROR_NOTCL] %s' % msg)
+                        return 'fail'
+
+                    # check if the tools diameters are less then the safe tool diameter
+                    suitable_tools = []
+                    for tool in sorted_tools:
+                        tool_dia = float(self.ncc_tools[tool]['tooldia'])
+                        if tool_dia <= self.safe_tooldia:
+                            suitable_tools.append(tool_dia)
+
+                    if not suitable_tools:
+                        msg = _("Incomplete isolation. None of the selected tools could do a complete isolation.")
+                        self.app.inform.emit('[WARNING] %s' % msg)
+                    else:
+                        msg = _("At least one of the selected tools can do a complete isolation.")
+                        self.app.inform.emit('[success] %s' % msg)
 
-                app_obj.inform.emit('[success] %s: %s %s' %
-                                    (_("Optimal tool diameter found"), str(min_dist_truncated), self.units.lower()))
+                    # reset the value to prepare for another isolation
+                    self.safe_tooldia = None
             except Exception as ee:
-                proc.done()
                 log.debug(str(ee))
                 return
-            proc.done()
 
-        self.app.worker_task.emit({'fcn': job_thread, 'params': [self.app]})
+        self.app.worker_task.emit({'fcn': job_thread, 'params': [self.app, is_displayed]})
 
     def on_tool_add(self, custom_dia=None):
         self.blockSignals(True)
@@ -1113,7 +1157,7 @@ class NonCopperClear(AppTool, Gerber):
                 'offset':           'Path',
                 'offset_value':     0.0,
                 'type':             'Iso',
-                'tool_type':        deepcopy(self.app.defaults["tools_ncctool_type"]),
+                'tool_type':        deepcopy(self.app.defaults["tools_ncc_tool_type"]),
                 'data':             deepcopy(self.default_data),
                 'solid_geometry':   []
             }
@@ -1266,6 +1310,9 @@ class NonCopperClear(AppTool, Gerber):
             self.app.inform.emit('[ERROR_NOTCL] %s: %s' % (_("Object not found"), str(self.obj_name)))
             return
 
+        if self.ui.valid_cb.get_value() is True:
+            self.find_safe_tooldia_worker(is_displayed=False)
+
         # 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
@@ -1288,7 +1335,7 @@ class NonCopperClear(AppTool, Gerber):
                 # find out which tools is for isolation and which are for copper clearing
                 for uid_k, uid_v in self.ncc_tools.items():
                     if round(uid_v['tooldia'], self.decimals) == round(self.tooldia, self.decimals):
-                        if uid_v['data']['tools_nccoperation'] == "iso":
+                        if uid_v['data']['tools_ncc_operation'] == "iso":
                             self.iso_dia_list.append(self.tooldia)
                         else:
                             self.ncc_dia_list.append(self.tooldia)
@@ -2113,10 +2160,10 @@ class NonCopperClear(AppTool, Gerber):
                         break
 
                 # parameters that are particular to the current tool
-                ncc_overlap = float(self.ncc_tools[tool_uid]["data"]["tools_nccoverlap"]) / 100.0
-                ncc_method = self.ncc_tools[tool_uid]["data"]["tools_nccmethod"]
-                ncc_connect = self.ncc_tools[tool_uid]["data"]["tools_nccconnect"]
-                ncc_contour = self.ncc_tools[tool_uid]["data"]["tools_ncccontour"]
+                ncc_overlap = float(self.ncc_tools[tool_uid]["data"]["tools_ncc_overlap"]) / 100.0
+                ncc_method = self.ncc_tools[tool_uid]["data"]["tools_ncc_method"]
+                ncc_connect = self.ncc_tools[tool_uid]["data"]["tools_ncc_connect"]
+                ncc_contour = self.ncc_tools[tool_uid]["data"]["tools_ncc_contour"]
                 has_offset = self.ncc_tools[tool_uid]["data"]["tools_ncc_offset_choice"]
                 ncc_offset = float(self.ncc_tools[tool_uid]["data"]["tools_ncc_offset_value"])
 
@@ -2360,8 +2407,8 @@ class NonCopperClear(AppTool, Gerber):
                         break
 
                 # parameters that are particular to the current tool
-                ncc_overlap = float(self.ncc_tools[tool_uid]["data"]["tools_nccoverlap"]) / 100.0
-                ncc_method = self.ncc_tools[tool_uid]["data"]["tools_nccmethod"]
+                ncc_overlap = float(self.ncc_tools[tool_uid]["data"]["tools_ncc_overlap"]) / 100.0
+                ncc_method = self.ncc_tools[tool_uid]["data"]["tools_ncc_method"]
 
                 # variables to display the percentage of work done
                 geo_len = len(area.geoms)
@@ -2716,9 +2763,9 @@ class NonCopperClear(AppTool, Gerber):
             offset_a = sum(sorted_tools)
             current_uid = int(1)
             try:
-                tool = eval(self.app.defaults["tools_ncctools"])[0]
+                tool = eval(self.app.defaults["tools_ncc_tools"])[0]
             except TypeError:
-                tool = eval(self.app.defaults["tools_ncctools"])
+                tool = eval(self.app.defaults["tools_ncc_tools"])
 
             # ###################################################################################################
             # Calculate the empty area by subtracting the solid_geometry from the object bounding box geometry ##
@@ -2758,7 +2805,7 @@ class NonCopperClear(AppTool, Gerber):
                     self.solid_geometry = ncc_obj.solid_geometry
 
                 # if milling type is climb then the move is counter-clockwise around features
-                milling_type = self.app.defaults["tools_nccmilling_type"]
+                milling_type = self.app.defaults["tools_ncc_milling_type"]
 
                 for tool_iso in isotooldia:
                     new_geometry = []
@@ -3106,9 +3153,9 @@ class NonCopperClear(AppTool, Gerber):
             rest_geo = []
             current_uid = 1
             try:
-                tool = eval(self.app.defaults["tools_ncctools"])[0]
+                tool = eval(self.app.defaults["tools_ncc_tools"])[0]
             except TypeError:
-                tool = eval(self.app.defaults["tools_ncctools"])
+                tool = eval(self.app.defaults["tools_ncc_tools"])
 
             # repurposed flag for final object, geo_obj. True if it has any solid_geometry, False if not.
             app_obj.poly_not_cleared = True
@@ -3137,7 +3184,7 @@ class NonCopperClear(AppTool, Gerber):
                 self.solid_geometry = ncc_obj.solid_geometry
 
                 # if milling type is climb then the move is counter-clockwise around features
-                milling_type = self.app.defaults["tools_nccmilling_type"]
+                milling_type = self.app.defaults["tools_ncc_milling_type"]
 
                 for tool_iso in isotooldia:
                     new_geometry = []
@@ -4247,10 +4294,20 @@ class NccUI:
         self.area_shape_label.hide()
         self.area_shape_radio.hide()
 
+        # Check Tool validity
+        self.valid_cb = FCCheckBox(label=_('Check validity'))
+        self.valid_cb.setToolTip(
+            _("If checked then the tools diameters are verified\n"
+              "if they will provide a complete isolation.")
+        )
+        self.valid_cb.setObjectName("n_check")
+
+        self.grid3.addWidget(self.valid_cb, 33, 0, 1, 2)
+
         separator_line = QtWidgets.QFrame()
         separator_line.setFrameShape(QtWidgets.QFrame.HLine)
         separator_line.setFrameShadow(QtWidgets.QFrame.Sunken)
-        self.grid3.addWidget(separator_line, 32, 0, 1, 2)
+        self.grid3.addWidget(separator_line, 35, 0, 1, 2)
 
         self.generate_ncc_button = FCButton(_('Generate Geometry'))
         self.generate_ncc_button.setIcon(QtGui.QIcon(self.app.resource_location + '/geometry32.png'))

appTools/ToolSub.py

@@ -635,11 +635,13 @@ class SubUI:
         self.tools_frame.setLayout(self.tools_box)
 
         # Form Layout
-        form_layout = QtWidgets.QFormLayout()
-        self.tools_box.addLayout(form_layout)
+        grid0 = QtWidgets.QGridLayout()
+        grid0.setColumnStretch(0, 0)
+        grid0.setColumnStretch(1, 1)
+        self.tools_box.addLayout(grid0)
 
         self.gerber_title = QtWidgets.QLabel("<b>%s</b>" % _("GERBER"))
-        form_layout.addRow(self.gerber_title)
+        grid0.addWidget(self.gerber_title, 0, 0, 1, 2)
 
         # Target Gerber Object
         self.target_gerber_combo = FCComboBox()
@@ -655,7 +657,8 @@ class SubUI:
               "the subtractor Gerber object.")
         )
 
-        form_layout.addRow(self.target_gerber_label, self.target_gerber_combo)
+        grid0.addWidget(self.target_gerber_label, 2, 0)
+        grid0.addWidget(self.target_gerber_combo, 2, 1)
 
         # Substractor Gerber Object
         self.sub_gerber_combo = FCComboBox()
@@ -669,9 +672,9 @@ class SubUI:
             _("Gerber object that will be subtracted\n"
               "from the target Gerber object.")
         )
-        e_lab_1 = QtWidgets.QLabel('')
 
-        form_layout.addRow(self.sub_gerber_label, self.sub_gerber_combo)
+        grid0.addWidget(self.sub_gerber_label, 4, 0)
+        grid0.addWidget(self.sub_gerber_combo, 4, 1)
 
         self.intersect_btn = FCButton(_('Subtract Gerber'))
         self.intersect_btn.setToolTip(
@@ -686,15 +689,11 @@ class SubUI:
                                     font-weight: bold;
                                 }
                                 """)
-        self.tools_box.addWidget(self.intersect_btn)
-        self.tools_box.addWidget(e_lab_1)
-
-        # Form Layout
-        form_geo_layout = QtWidgets.QFormLayout()
-        self.tools_box.addLayout(form_geo_layout)
+        grid0.addWidget(self.intersect_btn, 6, 0, 1, 2)
+        grid0.addWidget(QtWidgets.QLabel(''), 8, 0, 1, 2)
 
         self.geo_title = QtWidgets.QLabel("<b>%s</b>" % _("GEOMETRY"))
-        form_geo_layout.addRow(self.geo_title)
+        grid0.addWidget(self.geo_title, 10, 0, 1, 2)
 
         # Target Geometry Object
         self.target_geo_combo = FCComboBox()
@@ -710,7 +709,8 @@ class SubUI:
               "the subtractor Geometry object.")
         )
 
-        form_geo_layout.addRow(self.target_geo_label, self.target_geo_combo)
+        grid0.addWidget(self.target_geo_label, 12, 0)
+        grid0.addWidget(self.target_geo_combo, 12, 1)
 
         # Substractor Geometry Object
         self.sub_geo_combo = FCComboBox()
@@ -724,13 +724,14 @@ class SubUI:
             _("Geometry object that will be subtracted\n"
               "from the target Geometry object.")
         )
-        e_lab_1 = QtWidgets.QLabel('')
 
-        form_geo_layout.addRow(self.sub_geo_label, self.sub_geo_combo)
+        grid0.addWidget(self.sub_geo_label, 14, 0)
+        grid0.addWidget(self.sub_geo_combo, 14, 1)
 
         self.close_paths_cb = FCCheckBox(_("Close paths"))
         self.close_paths_cb.setToolTip(_("Checking this will close the paths cut by the Geometry subtractor object."))
-        self.tools_box.addWidget(self.close_paths_cb)
+
+        grid0.addWidget(self.close_paths_cb, 16, 0, 1, 2)
 
         self.intersect_geo_btn = FCButton(_('Subtract Geometry'))
         self.intersect_geo_btn.setToolTip(
@@ -743,8 +744,9 @@ class SubUI:
                                     font-weight: bold;
                                 }
                                 """)
-        self.tools_box.addWidget(self.intersect_geo_btn)
-        self.tools_box.addWidget(e_lab_1)
+
+        grid0.addWidget(self.intersect_geo_btn, 18, 0, 1, 2)
+        grid0.addWidget(QtWidgets.QLabel(''), 20, 0, 1, 2)
 
         self.tools_box.addStretch()
 

app_Main.py

@@ -4139,7 +4139,7 @@ class App(QtCore.QObject):
 
     def scale_defaults(self, sfactor, dimensions):
         for dim in dimensions:
-            if dim in ['geometry_cnctooldia', 'tools_ncctools', 'tools_solderpaste_tools', 'tools_iso_tooldia',
+            if dim in ['geometry_cnctooldia', 'tools_ncc_tools', 'tools_solderpaste_tools', 'tools_iso_tooldia',
                        'tools_painttooldia', 'tools_transform_ref_point', 'tools_cal_toolchange_xy',
                        'gerber_editor_newdim', 'tools_drill_toolchangexy', 'tools_drill_endxy',
                        'geometry_toolchangexy', 'geometry_endxy', 'tools_solderpaste_xy_toolchange']:
@@ -4255,8 +4255,8 @@ class App(QtCore.QObject):
              "tools_drill_feedrate_probe", "tools_drill_z_pdepth", "tools_drill_area_overz",
             
             # NCC Tool
-            "tools_ncctools", "tools_nccmargin", "tools_ncc_offset_value", "tools_ncccutz", "tools_ncctipdia",
-            "tools_nccnewdia",
+            "tools_ncc_tools", "tools_ncc_margin", "tools_ncc_offset_value", "tools_ncc_cutz", "tools_ncc_tipdia",
+            "tools_ncc_newdia",
 
             # Cutout Tool
             "tools_cutout_tooldia", 'tools_cutout_margin', "tools_cutout_z", "tools_cutout_depthperpass",
@@ -9686,7 +9686,7 @@ class App(QtCore.QObject):
         # label = QtWidgets.QLabel("Choose an item from Project")
         # label.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
 
-        sel_title = QtWidgets.QTextEdit(_('<b>Shortcut Key List</b>'))
+        sel_title = QtWidgets.QTextEdit()
         sel_title.setTextInteractionFlags(QtCore.Qt.NoTextInteraction)
         sel_title.setFrameStyle(QtWidgets.QFrame.NoFrame)
 

defaults.py

@@ -461,26 +461,27 @@ class FlatCAMDefaults:
         "tools_drill_area_overz": 1.0,
 
         # NCC Tool
-        "tools_ncctools": "1.0, 0.5",
-        "tools_nccorder": 'rev',
-        "tools_nccoperation": 'clear',
-        "tools_nccoverlap": 40,
-        "tools_nccmargin": 1.0,
-        "tools_nccmethod": _("Seed"),
-        "tools_nccconnect": True,
-        "tools_ncccontour": True,
-        "tools_nccrest": False,
+        "tools_ncc_tools": "1.0, 0.5",
+        "tools_ncc_order": 'rev',
+        "tools_ncc_operation": 'clear',
+        "tools_ncc_overlap": 40,
+        "tools_ncc_margin": 1.0,
+        "tools_ncc_method": _("Seed"),
+        "tools_ncc_connect": True,
+        "tools_ncc_contour": True,
+        "tools_ncc_rest": False,
         "tools_ncc_offset_choice": False,
         "tools_ncc_offset_value": 0.0000,
-        "tools_nccref": _('Itself'),
+        "tools_ncc_ref": _('Itself'),
         "tools_ncc_area_shape": "square",
-        "tools_nccmilling_type": 'cl',
-        "tools_ncctool_type": 'C1',
-        "tools_ncccutz": -0.05,
-        "tools_ncctipdia": 0.1,
-        "tools_ncctipangle": 30,
-        "tools_nccnewdia": 0.1,
+        "tools_ncc_milling_type": 'cl',
+        "tools_ncc_tool_type": 'C1',
+        "tools_ncc_cutz": -0.05,
+        "tools_ncc_tipdia": 0.1,
+        "tools_ncc_tipangle": 30,
+        "tools_ncc_newdia": 0.1,
         "tools_ncc_plotting": 'normal',
+        "tools_ncc_check_valid": True,
 
         # Cutout Tool
         "tools_cutout_tooldia": 2.4,

tclCommands/TclCommandCopperClear.py

@@ -103,22 +103,22 @@ class TclCommandCopperClear(TclCommand):
         if 'tooldia' in args:
             tooldia = str(args['tooldia'])
         else:
-            tooldia = self.app.defaults["tools_ncctools"]
+            tooldia = self.app.defaults["tools_ncc_tools"]
 
         if 'overlap' in args:
             overlap = float(args['overlap']) / 100.0
         else:
-            overlap = float(self.app.defaults["tools_nccoverlap"]) / 100.0
+            overlap = float(self.app.defaults["tools_ncc_overlap"]) / 100.0
 
         if 'order' in args:
             order = args['order']
         else:
-            order = str(self.app.defaults["tools_nccorder"])
+            order = str(self.app.defaults["tools_ncc_order"])
 
         if 'margin' in args:
             margin = float(args['margin'])
         else:
-            margin = float(self.app.defaults["tools_nccmargin"])
+            margin = float(self.app.defaults["tools_ncc_margin"])
 
         if 'method' in args:
             method = args['method']
@@ -129,7 +129,7 @@ class TclCommandCopperClear(TclCommand):
             else:
                 method_data = _("Lines")
         else:
-            method = str(self.app.defaults["tools_nccmethod"])
+            method = str(self.app.defaults["tools_ncc_method"])
             method_data = method
             if method == _("Standard"):
                 method = "standard"
@@ -145,7 +145,7 @@ class TclCommandCopperClear(TclCommand):
                 par = args['connect']
             connect = bool(eval(par))
         else:
-            connect = bool(eval(str(self.app.defaults["tools_nccconnect"])))
+            connect = bool(eval(str(self.app.defaults["tools_ncc_connect"])))
 
         if 'contour' in args:
             try:
@@ -154,7 +154,7 @@ class TclCommandCopperClear(TclCommand):
                 par = args['contour']
             contour = bool(eval(par))
         else:
-            contour = bool(eval(str(self.app.defaults["tools_ncccontour"])))
+            contour = bool(eval(str(self.app.defaults["tools_ncc_contour"])))
 
         offset = 0.0
         if 'offset' in args:
@@ -175,7 +175,7 @@ class TclCommandCopperClear(TclCommand):
                 par = args['rest']
             rest = bool(eval(par))
         else:
-            rest = bool(eval(str(self.app.defaults["tools_nccrest"])))
+            rest = bool(eval(str(self.app.defaults["tools_ncc_rest"])))
 
         if 'outname' in args:
             outname = args['outname']
@@ -224,18 +224,18 @@ class TclCommandCopperClear(TclCommand):
             "area_overz":       float(self.app.defaults["geometry_area_overz"]),
 
             "tooldia":              self.app.defaults["tools_painttooldia"],
-            "tools_nccoperation":   self.app.defaults["tools_nccoperation"],
+            "tools_ncc_operation":   self.app.defaults["tools_ncc_operation"],
 
-            "tools_nccmargin":  margin,
-            "tools_nccmethod":  method_data,
-            "tools_nccref":     select,
-            "tools_nccconnect": connect,
-            "tools_ncccontour": contour,
-            "tools_nccoverlap": overlap,
+            "tools_ncc_margin":  margin,
+            "tools_ncc_method":  method_data,
+            "tools_ncc_ref":     select,
+            "tools_ncc_connect": connect,
+            "tools_ncc_contour": contour,
+            "tools_ncc_overlap": overlap,
 
             "tools_ncc_offset_choice":  self.app.defaults["tools_ncc_offset_choice"],
             "tools_ncc_offset_value":   self.app.defaults["tools_ncc_offset_value"],
-            "tools_nccmilling_type":    self.app.defaults["tools_nccmilling_type"]
+            "tools_ncc_milling_type":    self.app.defaults["tools_ncc_milling_type"]
         })
         ncc_tools = {}