- started to modify the Substract Tool to work on Geometry objects too

FlatCAMApp.py

@@ -2067,7 +2067,7 @@ class App(QtCore.QObject):
         self.ui.panelize_btn.triggered.connect(lambda: self.panelize_tool.run(toggle=True))
         self.ui.film_btn.triggered.connect(lambda: self.film_tool.run(toggle=True))
         self.ui.solder_btn.triggered.connect(lambda: self.paste_tool.run(toggle=True))
-        self.ui.silk_btn.triggered.connect(lambda: self.sub_tool.run(toggle=True))
+        self.ui.sub_btn.triggered.connect(lambda: self.sub_tool.run(toggle=True))
 
         self.ui.calculators_btn.triggered.connect(lambda: self.calculator_tool.run(toggle=True))
         self.ui.transform_btn.triggered.connect(lambda: self.transform_tool.run(toggle=True))

README.md

@@ -14,6 +14,7 @@ CAD program, and create G-Code for Isolation routing.
 - in ObjectCollection class, made sure that renaming an object in Project View does not result in an empty name. If new name is blank the rename is cancelled.
 - made ObjectCollection.TreeItem() inherit KeySensitiveListVIew and implicitly QTreeView (in the hope that the theme applied on app will be applied on the tree items, too (for MacOs new DarkUI theme)
 - renamed SilkScreen Tool to Substract Tool and move it's menu location in Edit -> Conversion
+- started to modify the Substract Tool to work on Geometry objects too
 
 29.04.2019
 

flatcamGUI/FlatCAMGUI.py

@@ -638,7 +638,7 @@ class FlatCAMGUI(QtWidgets.QMainWindow):
         self.panelize_btn = self.toolbartools.addAction(QtGui.QIcon('share/panel16.png'), _("Panel Tool"))
         self.film_btn = self.toolbartools.addAction(QtGui.QIcon('share/film16.png'),_( "Film Tool"))
         self.solder_btn = self.toolbartools.addAction(QtGui.QIcon('share/solderpastebis32.png'), _("SolderPaste Tool"))
-        self.silk_btn = self.toolbartools.addAction(QtGui.QIcon('share/sub32.png'), _("Substract Tool"))
+        self.sub_btn = self.toolbartools.addAction(QtGui.QIcon('share/sub32.png'), _("Substract Tool"))
 
         self.toolbartools.addSeparator()
 
@@ -1855,7 +1855,7 @@ class FlatCAMGUI(QtWidgets.QMainWindow):
         self.film_btn = self.toolbartools.addAction(QtGui.QIcon('share/film16.png'), _("Film Tool"))
         self.solder_btn = self.toolbartools.addAction(QtGui.QIcon('share/solderpastebis32.png'),
                                                       _("SolderPaste Tool"))
-        self.silk_btn = self.toolbartools.addAction(QtGui.QIcon('share/sub32.png'), _("Substract Tool"))
+        self.sub_btn = self.toolbartools.addAction(QtGui.QIcon('share/sub32.png'), _("Substract Tool"))
 
         self.toolbartools.addSeparator()
 

flatcamTools/ToolSub.py

@@ -52,42 +52,91 @@ class ToolSub(FlatCAMTool):
         form_layout = QtWidgets.QFormLayout()
         self.tools_box.addLayout(form_layout)
 
-        # Object Silkscreen
-        self.silk_object_combo = QtWidgets.QComboBox()
-        self.silk_object_combo.setModel(self.app.collection)
-        self.silk_object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
-        self.silk_object_combo.setCurrentIndex(1)
-
-        self.silk_object_label = QtWidgets.QLabel("Silk Gerber:")
-        self.silk_object_label.setToolTip(
-            _("Silkscreen Gerber object to be adjusted\n"
-              "so it does not intersects the soldermask.")
+        self.gerber_title = QtWidgets.QLabel(_("<b>Gerber Objects</b>"))
+        form_layout.addRow(self.gerber_title)
+
+        # Target Gerber Object
+        self.target_gerber_combo = QtWidgets.QComboBox()
+        self.target_gerber_combo.setModel(self.app.collection)
+        self.target_gerber_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
+        self.target_gerber_combo.setCurrentIndex(1)
+
+        self.target_gerber_label = QtWidgets.QLabel(_("Target:"))
+        self.target_gerber_label.setToolTip(
+            _("Gerber object from which to substract\n"
+              "the substractor Gerber object.")
         )
 
-        form_layout.addRow(self.silk_object_label, self.silk_object_combo)
+        form_layout.addRow(self.target_gerber_label, self.target_gerber_combo)
 
-        # Object Soldermask
-        self.sm_object_combo = QtWidgets.QComboBox()
-        self.sm_object_combo.setModel(self.app.collection)
-        self.sm_object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
-        self.sm_object_combo.setCurrentIndex(1)
+        # Substractor Gerber Object
+        self.sub_gerber_combo = QtWidgets.QComboBox()
+        self.sub_gerber_combo.setModel(self.app.collection)
+        self.sub_gerber_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
+        self.sub_gerber_combo.setCurrentIndex(1)
 
-        self.sm_object_label = QtWidgets.QLabel("SM Gerber:")
-        self.sm_object_label.setToolTip(
-            _("Soldermask Gerber object that will adjust\n"
-              "the silkscreen so it does not overlap.")
+        self.sub_gerber_label = QtWidgets.QLabel(_("Substractor:"))
+        self.sub_gerber_label.setToolTip(
+            _("Gerber object that will be substracted\n"
+              "from the target Gerber object.")
         )
         e_lab_1 = QtWidgets.QLabel('')
 
-        form_layout.addRow(self.sm_object_label, self.sm_object_combo)
-        form_layout.addRow(e_lab_1)
+        form_layout.addRow(self.sub_gerber_label, self.sub_gerber_combo)
 
-        self.intersect_btn = FCButton(_('Remove overlap'))
+        self.intersect_btn = FCButton(_('Substract Gerber'))
         self.intersect_btn.setToolTip(
-            _("Remove the silkscreen geometry\n"
-              "that overlaps over the soldermask.")
+            _("Will remove the area occupied by the substractor\n"
+              "Gerber from the Target Gerber.\n"
+              "Can be used to remove the overlapping silkscreen\n"
+              "over the soldermask.")
         )
         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)
+
+        self.geo_title = QtWidgets.QLabel(_("<b>Geometry Objects</b>"))
+        form_geo_layout.addRow(self.geo_title)
+
+        # Target Geometry Object
+        self.target_geo_combo = QtWidgets.QComboBox()
+        self.target_geo_combo.setModel(self.app.collection)
+        self.target_geo_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
+        self.target_geo_combo.setCurrentIndex(1)
+
+        self.target_geo_label = QtWidgets.QLabel(_("Target:"))
+        self.target_geo_label.setToolTip(
+            _("Geometry object from which to substract\n"
+              "the substractor Geometry object.")
+        )
+
+        form_geo_layout.addRow(self.target_geo_label, self.target_geo_combo)
+
+        # Substractor Geometry Object
+        self.sub_geo_combo = QtWidgets.QComboBox()
+        self.sub_geo_combo.setModel(self.app.collection)
+        self.sub_geo_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
+        self.sub_geo_combo.setCurrentIndex(1)
+
+        self.sub_geo_label = QtWidgets.QLabel(_("Substractor:"))
+        self.sub_geo_label.setToolTip(
+            _("Geometry object that will be substracted\n"
+              "from the target Geometry object.")
+        )
+        e_lab_1 = QtWidgets.QLabel('')
+
+        form_geo_layout.addRow(self.sub_geo_label, self.sub_geo_combo)
+
+        self.intersect_geo_btn = FCButton(_('Substract Geometry'))
+        self.intersect_geo_btn.setToolTip(
+            _("Will remove the area occupied by the substractor\n"
+              "Geometry from the Target Geometry.")
+        )
+        self.tools_box.addWidget(self.intersect_geo_btn)
+        self.tools_box.addWidget(e_lab_1)
 
         self.tools_box.addStretch()
 
@@ -99,29 +148,44 @@ class ToolSub(FlatCAMTool):
         self.promises = []
 
         self.new_apertures = {}
+        self.new_tools = {}
         self.new_solid_geometry = []
 
-        self.solder_union = None
+        self.sub_union = None
 
         # object to hold a flattened geometry
         self.flat_geometry = []
 
-        self.sm_obj = None
-        self.sm_obj_name = None
-        self.silk_obj = None
-        self.silk_obj_name = None
+        self.sub_grb_obj = None
+        self.sub_grb_obj_name = None
+        self.target_grb_obj = None
+        self.target_grb_obj_name = None
+
+        self.sub_geo_obj = None
+        self.sub_geo_obj_name = None
+        self.target_geo_obj = None
+        self.target_geo_obj_name = None
+
+        # signal which type of substraction to do: "geo" or "gerber"
+        self.sub_type = None
+
+        try:
+            self.intersect_btn.clicked.disconnect(self.on_grb_intersection_click)
+        except:
+            pass
+        self.intersect_btn.clicked.connect(self.on_grb_intersection_click)
 
         try:
-            self.intersect_btn.clicked.disconnect(self.on_intersection_click)
+            self.intersect_geo_btn.clicked.disconnect(self.on_geo_intersection_click)
         except:
             pass
-        self.intersect_btn.clicked.connect(self.on_intersection_click)
+        self.intersect_geo_btn.clicked.connect(self.on_geo_intersection_click)
 
     def install(self, icon=None, separator=None, **kwargs):
         FlatCAMTool.install(self, icon, separator, shortcut='ALT+W', **kwargs)
 
     def run(self, toggle=True):
-        self.app.report_usage("ToolNonCopperClear()")
+        self.app.report_usage("ToolSub()")
 
         if toggle:
             # if the splitter is hidden, display it, else hide it but only if the current widget is the same
@@ -141,56 +205,67 @@ class ToolSub(FlatCAMTool):
         self.set_tool_ui()
 
         self.new_apertures.clear()
+        self.new_tools.clear()
         self.new_solid_geometry = []
 
-        self.app.ui.notebook.setTabText(2, _("Silk Tool"))
+        self.app.ui.notebook.setTabText(2, _("Sub Tool"))
 
     def set_tool_ui(self):
         self.tools_frame.show()
 
-    def on_intersection_click(self):
+    def on_grb_intersection_click(self):
         # reset previous values
         self.new_apertures.clear()
         self.new_solid_geometry = []
-        self.solder_union = []
+        self.sub_union = []
+
+        self.sub_type = "gerber"
+
+        self.target_grb_obj_name = self.target_gerber_combo.currentText()
+        if self.target_grb_obj_name == '':
+            self.app.inform.emit(_("[ERROR_NOTCL] No Target object loaded."))
+            return
 
-        self.silk_obj_name = self.silk_object_combo.currentText()
         # Get source object.
         try:
-            self.silk_obj = self.app.collection.get_by_name(self.silk_obj_name)
+            self.target_grb_obj = self.app.collection.get_by_name(self.target_grb_obj_name)
         except:
             self.app.inform.emit(_("[ERROR_NOTCL] Could not retrieve object: %s") % self.obj_name)
-            return "Could not retrieve object: %s" % self.silk_obj_name
+            return "Could not retrieve object: %s" % self.target_grb_obj_name
+
+        self.sub_grb_obj_name = self.sub_gerber_combo.currentText()
+        if self.sub_grb_obj_name == '':
+            self.app.inform.emit(_("[ERROR_NOTCL] No Substractor object loaded."))
+            return
 
-        self.sm_obj_name = self.sm_object_combo.currentText()
         # Get source object.
         try:
-            self.sm_obj = self.app.collection.get_by_name(self.sm_obj_name)
+            self.sub_grb_obj = self.app.collection.get_by_name(self.sub_grb_obj_name)
         except:
             self.app.inform.emit(_("[ERROR_NOTCL] Could not retrieve object: %s") % self.obj_name)
-            return "Could not retrieve object: %s" % self.sm_obj_name
+            return "Could not retrieve object: %s" % self.sub_grb_obj_name
 
         # crate the new_apertures dict structure
-        for apid in self.silk_obj.apertures:
+        for apid in self.target_grb_obj.apertures:
             self.new_apertures[apid] = {}
             self.new_apertures[apid]['type'] = 'C'
-            self.new_apertures[apid]['size'] = self.silk_obj.apertures[apid]['size']
+            self.new_apertures[apid]['size'] = self.target_grb_obj.apertures[apid]['size']
             self.new_apertures[apid]['solid_geometry'] = []
 
         geo_union_list = []
-        for apid1 in self.sm_obj.apertures:
-            geo_union_list += self.sm_obj.apertures[apid1]['solid_geometry']
-        self.solder_union = cascaded_union(geo_union_list)
+        for apid1 in self.sub_grb_obj.apertures:
+            geo_union_list += self.sub_grb_obj.apertures[apid1]['solid_geometry']
+        self.sub_union = cascaded_union(geo_union_list)
 
         # add the promises
-        for apid in self.silk_obj.apertures:
+        for apid in self.target_grb_obj.apertures:
             self.promises.append(apid)
 
         # start the QTimer to check for promises with 1 second period check
         self.periodic_check(1000, reset=True)
 
-        for apid in self.silk_obj.apertures:
-            geo = self.silk_obj.apertures[apid]['solid_geometry']
+        for apid in self.target_grb_obj.apertures:
+            geo = self.target_grb_obj.apertures[apid]['solid_geometry']
             self.app.worker_task.emit({'fcn': self.aperture_intersection,
                                        'params': [apid, geo]})
 
@@ -200,8 +275,8 @@ class ToolSub(FlatCAMTool):
 
         with self.app.proc_container.new(_("Parsing aperture %s geometry ..." % str(apid))):
             for geo_silk in geo:
-                if geo_silk.intersects(self.solder_union):
-                    new_geo = geo_silk.difference(self.solder_union)
+                if geo_silk.intersects(self.sub_union):
+                    new_geo = geo_silk.difference(self.sub_union)
                     new_geo = new_geo.buffer(0)
                     if new_geo:
                         if not new_geo.is_empty:
@@ -229,54 +304,158 @@ class ToolSub(FlatCAMTool):
 
         log.debug("Promise fulfilled: %s" % str(apid))
 
+    def new_gerber_object(self, outname):
 
-    def periodic_check(self, check_period, reset=False):
-        """
-        This function starts an QTimer and it will periodically check if intersections are done
-
-        :param check_period: time at which to check periodically
-        :param reset: will reset the timer
-        :return:
-        """
+        def obj_init(grb_obj, app_obj):
 
-        log.debug("ToolSub --> Periodic Check started.")
+            grb_obj.apertures = deepcopy(self.new_apertures)
 
-        try:
-            self.check_thread.stop()
-        except:
-            pass
+            poly_buff = []
+            for ap in self.new_apertures:
+                for poly in self.new_apertures[ap]['solid_geometry']:
+                    poly_buff.append(poly)
 
-        if reset:
-            self.check_thread.setInterval(check_period)
+            work_poly_buff = cascaded_union(poly_buff)
             try:
-                self.check_thread.timeout.disconnect(self.periodic_check_handler)
-            except:
+                poly_buff = work_poly_buff.buffer(0.0000001)
+            except ValueError:
+                pass
+            try:
+                poly_buff = poly_buff.buffer(-0.0000001)
+            except ValueError:
                 pass
 
-        self.check_thread.timeout.connect(self.periodic_check_handler)
-        self.check_thread.start(QtCore.QThread.HighPriority)
+            grb_obj.solid_geometry = deepcopy(poly_buff)
 
-    def periodic_check_handler(self):
-        """
-        If the intersections workers finished then start creating the solid_geometry
-        :return:
-        """
-        # log.debug("checking parsing --> %s" % str(self.parsing_promises))
+        with self.app.proc_container.new(_("Generating new object ...")):
+            ret = self.app.new_object('gerber', outname, obj_init, autoselected=False)
+            if ret == 'fail':
+                self.app.inform.emit(_('[ERROR_NOTCL] Generating new object failed.'))
+                return
+            # Register recent file
+            self.app.file_opened.emit('gerber', outname)
+            # GUI feedback
+            self.app.inform.emit(_("[success] Created: %s") % outname)
 
-        outname = self.silk_object_combo.currentText() + '_cleaned'
+            # cleanup
+            self.new_apertures.clear()
+            self.new_solid_geometry[:] = []
+            self.sub_union[:] = []
 
+    def on_geo_intersection_click(self):
+        # reset previous values
+        self.new_tools.clear()
+        self.new_solid_geometry = []
+        self.sub_union = []
+
+        self.sub_type = "geo"
+
+        self.target_geo_obj_name = self.target_geo_combo.currentText()
+        if self.target_geo_obj_name == '':
+            self.app.inform.emit(_("[ERROR_NOTCL] No Target object loaded."))
+            return
+
+        # Get source object.
         try:
-            if not self.promises:
-                self.check_thread.stop()
-                # intersection jobs finished, start the creation of solid_geometry
-                self.app.worker_task.emit({'fcn': self.new_silkscreen_object,
-                                           'params': [outname]})
+            self.target_geo_obj = self.app.collection.get_by_name(self.target_geo_obj_name)
+        except:
+            self.app.inform.emit(_("[ERROR_NOTCL] Could not retrieve object: %s") % self.target_geo_obj_name)
+            return "Could not retrieve object: %s" % self.target_grb_obj_name
 
-                log.debug("ToolSub --> Periodic check finished.")
-        except Exception:
-            traceback.print_exc()
+        self.sub_geo_obj_name = self.sub_geo_combo.currentText()
+        if self.sub_geo_obj_name == '':
+            self.app.inform.emit(_("[ERROR_NOTCL] No Substractor object loaded."))
+            return
+
+        if self.sub_geo_obj.multigeo:
+            self.app.inform.emit(_("[ERROR_NOTCL] Currently, the Substractor geometry cannot be of type Multigeo."))
+            return
+
+        # Get source object.
+        try:
+            self.sub_geo_obj = self.app.collection.get_by_name(self.sub_geo_obj_name)
+        except:
+            self.app.inform.emit(_("[ERROR_NOTCL] Could not retrieve object: %s") % self.sub_geo_obj_name)
+            return "Could not retrieve object: %s" % self.sub_geo_obj_name
+
+        geo_union_list = []
+        if self.target_grb_obj.multigeo:
+            # crate the new_tools dict structure
+            for tool in self.target_geo_obj.tools:
+                self.new_tools[tool] = {}
+                self.new_tools[tool]['solid_geometry'] = []
+
+            for t in self.sub_geo_obj.tools:
+                geo_union_list += self.sub_geo_obj.tools[t]['solid_geometry']
+
+            # add the promises
+            for tool in self.target_geo_obj.tools:
+                self.promises.append(tool)
+        else:
+            geo_union_list = self.sub_geo_obj.solid_geometry
+            # add the promise
+            self.promises.append("single")
 
-    def new_silkscreen_object(self, outname):
+        self.sub_union = cascaded_union(geo_union_list)
+
+        if self.target_grb_obj.multigeo:
+            # start the QTimer to check for promises with 0.5 second period check
+            self.periodic_check(500, reset=True)
+
+            for tool in self.target_geo_obj.tools:
+                geo = self.target_grb_obj.tools[tool]['solid_geometry']
+                self.app.worker_task.emit({'fcn': self.toolgeo_intersection,
+                                           'params': [tool, geo]})
+        else:
+            geo = self.target_grb_obj.solid_geometry
+            self.app.worker_task.emit({'fcn': self.toolgeo_intersection,
+                                       'params': ["single", geo]})
+
+    def toolgeo_intersection(self, tool, geo):
+        new_geometry = []
+        log.debug("Working on promise: %s" % str(tool))
+
+        if tool == "single":
+            text = _("Parsing solid_geometry ...")
+        else:
+            text = _("Parsing tool %s geometry ...") % str(tool)
+
+        with self.app.proc_container.new(text):
+            for t_geo in geo:
+                if t_geo.intersects(self.sub_union):
+                    new_geo = t_geo.difference(self.sub_union)
+                    new_geo = new_geo.buffer(0)
+                    if new_geo:
+                        if not new_geo.is_empty:
+                            new_geometry.append(new_geo)
+                        else:
+                            new_geometry.append(t_geo)
+                    else:
+                        new_geometry.append(t_geo)
+                else:
+                    new_geometry.append(t_geo)
+
+        if new_geometry:
+            if tool == "single":
+                while not self.new_solid_geometry:
+                    self.new_solid_geometry = deepcopy(new_geometry)
+                    time.sleep(0.5)
+            else:
+                while not self.new_tools[tool]['solid_geometry']:
+                    self.new_tools[tool]['solid_geometry'] = deepcopy(new_geometry)
+                    time.sleep(0.5)
+
+        while True:
+            # removal from list is done in a multithreaded way therefore not always the removal can be done
+            # so we keep trying until it's done
+            if tool not in self.promises:
+                break
+
+            self.promises.remove(tool)
+            time.sleep(0.5)
+        log.debug("Promise fulfilled: %s" % str(tool))
+
+    def new_geo_object(self, outname):
 
         def obj_init(grb_obj, app_obj):
 
@@ -299,10 +478,10 @@ class ToolSub(FlatCAMTool):
 
             grb_obj.solid_geometry = deepcopy(poly_buff)
 
-        with self.app.proc_container.new(_("Generating cleaned SS object ...")):
+        with self.app.proc_container.new(_("Generating new object ...")):
             ret = self.app.new_object('gerber', outname, obj_init, autoselected=False)
             if ret == 'fail':
-                self.app.inform.emit(_('[ERROR_NOTCL] Generating SilkScreen file failed.'))
+                self.app.inform.emit(_('[ERROR_NOTCL] Generating new object failed.'))
                 return
             # Register recent file
             self.app.file_opened.emit('gerber', outname)
@@ -312,8 +491,69 @@ class ToolSub(FlatCAMTool):
             # cleanup
             self.new_apertures.clear()
             self.new_solid_geometry[:] = []
-            self.solder_union[:] = []
+            self.sub_union[:] = []
+
+    def periodic_check(self, check_period, reset=False):
+        """
+        This function starts an QTimer and it will periodically check if intersections are done
+
+        :param check_period: time at which to check periodically
+        :param reset: will reset the timer
+        :return:
+        """
+
+        log.debug("ToolSub --> Periodic Check started.")
+
+        try:
+            self.check_thread.stop()
+        except Exception as e:
+            pass
+
+        if reset:
+            self.check_thread.setInterval(check_period)
+            try:
+                self.check_thread.timeout.disconnect(self.periodic_check_handler)
+            except Exception as e:
+                pass
+
+        self.check_thread.timeout.connect(self.periodic_check_handler)
+        self.check_thread.start(QtCore.QThread.HighPriority)
+
+    def periodic_check_handler(self):
+        """
+        If the intersections workers finished then start creating the solid_geometry
+        :return:
+        """
+        # log.debug("checking parsing --> %s" % str(self.parsing_promises))
+
+
+        try:
+            if not self.promises:
+                self.check_thread.stop()
+                if self.sub_type == "gerber":
+                    outname = self.target_gerber_combo.currentText() + '_sub'
+
+                    # intersection jobs finished, start the creation of solid_geometry
+                    self.app.worker_task.emit({'fcn': self.new_gerber_object,
+                                               'params': [outname]})
+                else:
+                    outname = self.target_geo_combo.currentText() + '_sub'
+
+                    # intersection jobs finished, start the creation of solid_geometry
+                    self.app.worker_task.emit({'fcn': self.new_geo_object,
+                                               'params': [outname]})
+
+                # reset the type of substraction for next time
+                self.sub_type = None
+
+                log.debug("ToolSub --> Periodic check finished.")
+        except Exception as e:
+            log.debug("ToolSub().periodic_check_handler() --> %s" % str(e))
+            traceback.print_exc()
 
     def reset_fields(self):
-        self.silk_object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
-        self.sm_object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
+        self.target_gerber_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
+        self.sub_gerber_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
+
+        self.target_geo_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
+        self.sub_geo_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))