- fixed the camlib.Gerber functions of mirror, scale, offset, skew and rotate to work with the new data structure for apertures geometry

- fixed Gerber Editor selection to work with the new Gerber data structure in self.apertures

README.md

@@ -13,6 +13,8 @@ CAD program, and create G-Code for Isolation routing.
 
 - fixed issue in camlib.CNCjob.generate_from_excellon_by_tool() in the drill path optimization algorithm selection when selecting the MH algorithm. The new API's for Google OR-tools required some changes and also the time parameter can be now just an integer therefore I modified the GUI
 - made the Feedrate Rapids parameter to depend on the type of postprocessor choosed. It will be showed only for a postprocessor which the name contain 'marlin' and for any postprocessor's that have 'custom' in the name
+- fixed the camlib.Gerber functions of mirror, scale, offset, skew and rotate to work with the new data structure for apertures geometry
+- fixed Gerber Editor selection to work with the new Gerber data structure in self.apertures
 
 10.05.2019
 

camlib.py

@@ -3313,8 +3313,7 @@ class Gerber (Geometry):
                     new_obj.append(scale_geom(g))
                 return new_obj
             else:
-                return affinity.scale(obj, xfactor,
-                                             yfactor, origin=(px, py))
+                return affinity.scale(obj, xfactor, yfactor, origin=(px, py))
 
         self.solid_geometry = scale_geom(self.solid_geometry)
         self.follow_geometry = scale_geom(self.follow_geometry)
@@ -3322,27 +3321,21 @@ class Gerber (Geometry):
         # we need to scale the geometry stored in the Gerber apertures, too
         try:
             for apid in self.apertures:
-                if 'solid_geometry' in self.apertures[apid]:
-                    self.apertures[apid]['solid_geometry'] = scale_geom(self.apertures[apid]['solid_geometry'])
-                if 'follow_geometry' in self.apertures[apid]:
-                    self.apertures[apid]['follow_geometry'] = scale_geom(self.apertures[apid]['follow_geometry'])
-                if 'clear_geometry' in self.apertures[apid]:
-                    self.apertures[apid]['clear_geometry'] = scale_geom(self.apertures[apid]['clear_geometry'])
+                if 'geometry' in self.apertures[apid]:
+                    for geo_el in self.apertures[apid]['geometry']:
+                        if 'solid' in geo_el:
+                            geo_el['solid'] = scale_geom(geo_el['solid'])
+                        if 'follow' in geo_el:
+                            geo_el['follow'] = scale_geom(geo_el['follow'])
+                        if 'clear' in geo_el:
+                            geo_el['clear'] = scale_geom(geo_el['clear'])
+
         except Exception as e:
             log.debug('camlib.Gerber.scale() Exception --> %s' % str(e))
             return 'fail'
 
         self.app.inform.emit(_("[success] Gerber Scale done."))
 
-
-        ## solid_geometry ???
-        #  It's a cascaded union of objects.
-        # self.solid_geometry = affinity.scale(self.solid_geometry, factor,
-        #                                      factor, origin=(0, 0))
-
-        # # Now buffered_paths, flash_geometry and solid_geometry
-        # self.create_geometry()
-
     def offset(self, vect):
         """
         Offsets the objects' geometry on the XY plane by a given vector.
@@ -3385,15 +3378,17 @@ class Gerber (Geometry):
         # we need to offset the geometry stored in the Gerber apertures, too
         try:
             for apid in self.apertures:
-                self.apertures[apid]['solid_geometry'] = offset_geom(self.apertures[apid]['solid_geometry'])
-        except Exception as e:
-            log.debug('camlib.Gerber.offset() --> %s' % str(e))
-            return 'fail'
-        try:
-            for apid in self.apertures:
-                self.apertures[apid]['follow_geometry'] = offset_geom(self.apertures[apid]['follow_geometry'])
+                if 'geometry' in self.apertures[apid]:
+                    for geo_el in self.apertures[apid]['geometry']:
+                        if 'solid' in geo_el:
+                            geo_el['solid'] = offset_geom(geo_el['solid'])
+                        if 'follow' in geo_el:
+                            geo_el['follow'] = offset_geom(geo_el['follow'])
+                        if 'clear' in geo_el:
+                            geo_el['clear'] = offset_geom(geo_el['clear'])
+
         except Exception as e:
-            log.debug('camlib.Gerber.offset() --> %s' % str(e))
+            log.debug('camlib.Gerber.offset() Exception --> %s' % str(e))
             return 'fail'
 
         self.app.inform.emit(_("[success] Gerber Offset done."))
@@ -3438,20 +3433,19 @@ class Gerber (Geometry):
         # we need to mirror the geometry stored in the Gerber apertures, too
         try:
             for apid in self.apertures:
-                self.apertures[apid]['solid_geometry'] = mirror_geom(self.apertures[apid]['solid_geometry'])
-        except Exception as e:
-            log.debug('camlib.Gerber.mirror() --> %s' % str(e))
-            return 'fail'
-        try:
-            for apid in self.apertures:
-                self.apertures[apid]['follow_geometry'] = mirror_geom(self.apertures[apid]['follow_geometry'])
+                if 'geometry' in self.apertures[apid]:
+                    for geo_el in self.apertures[apid]['geometry']:
+                        if 'solid' in geo_el:
+                            geo_el['solid'] = mirror_geom(geo_el['solid'])
+                        if 'follow' in geo_el:
+                            geo_el['follow'] = mirror_geom(geo_el['follow'])
+                        if 'clear' in geo_el:
+                            geo_el['clear'] = mirror_geom(geo_el['clear'])
         except Exception as e:
-            log.debug('camlib.Gerber.mirror() --> %s' % str(e))
+            log.debug('camlib.Gerber.mirror() Exception --> %s' % str(e))
             return 'fail'
 
-        #  It's a cascaded union of objects.
-        # self.solid_geometry = affinity.scale(self.solid_geometry,
-        #                                      xscale, yscale, origin=(px, py))
+        self.app.inform.emit(_("[success] Gerber Mirror done."))
 
     def skew(self, angle_x, angle_y, point):
         """
@@ -3485,18 +3479,19 @@ class Gerber (Geometry):
         # we need to skew the geometry stored in the Gerber apertures, too
         try:
             for apid in self.apertures:
-                self.apertures[apid]['solid_geometry'] = skew_geom(self.apertures[apid]['solid_geometry'])
-        except Exception as e:
-            log.debug('camlib.Gerber.skew() --> %s' % str(e))
-            return 'fail'
-        try:
-            for apid in self.apertures:
-                self.apertures[apid]['follow_geometry'] = skew_geom(self.apertures[apid]['follow_geometry'])
+                if 'geometry' in self.apertures[apid]:
+                    for geo_el in self.apertures[apid]['geometry']:
+                        if 'solid' in geo_el:
+                            geo_el['solid'] = skew_geom(geo_el['solid'])
+                        if 'follow' in geo_el:
+                            geo_el['follow'] = skew_geom(geo_el['follow'])
+                        if 'clear' in geo_el:
+                            geo_el['clear'] = skew_geom(geo_el['clear'])
         except Exception as e:
-            log.debug('camlib.Gerber.skew() --> %s' % str(e))
+            log.debug('camlib.Gerber.skew() Exception --> %s' % str(e))
             return 'fail'
 
-        # self.solid_geometry = affinity.skew(self.solid_geometry, angle_x, angle_y, origin=(px, py))
+        self.app.inform.emit(_("[success] Gerber Skew done."))
 
     def rotate(self, angle, point):
         """
@@ -3523,17 +3518,18 @@ class Gerber (Geometry):
         # we need to rotate the geometry stored in the Gerber apertures, too
         try:
             for apid in self.apertures:
-                self.apertures[apid]['solid_geometry'] = rotate_geom(self.apertures[apid]['solid_geometry'])
-        except Exception as e:
-            log.debug('camlib.Gerber.rotate() --> %s' % str(e))
-            return 'fail'
-        try:
-            for apid in self.apertures:
-                self.apertures[apid]['follow_geometry'] = rotate_geom(self.apertures[apid]['follow_geometry'])
+                if 'geometry' in self.apertures[apid]:
+                    for geo_el in self.apertures[apid]['geometry']:
+                        if 'solid' in geo_el:
+                            geo_el['solid'] = rotate_geom(geo_el['solid'])
+                        if 'follow' in geo_el:
+                            geo_el['follow'] = rotate_geom(geo_el['follow'])
+                        if 'clear' in geo_el:
+                            geo_el['clear'] = rotate_geom(geo_el['clear'])
         except Exception as e:
-            log.debug('camlib.Gerber.rotate() --> %s' % str(e))
+            log.debug('camlib.Gerber.rotate() Exception --> %s' % str(e))
             return 'fail'
-        # self.solid_geometry = affinity.rotate(self.solid_geometry, angle, origin=(px, py))
+        self.app.inform.emit(_("[success] Gerber Rotate done."))
 
 
 class Excellon(Geometry):

flatcamEditors/FlatCAMGrbEditor.py

@@ -1803,22 +1803,24 @@ class FCApertureSelect(DrawTool):
 
         for storage in self.grb_editor_app.storage_dict:
             try:
-                for shape in self.grb_editor_app.storage_dict[storage]['solid_geometry']:
-                    if Point(point).within(shape.geo):
-                        if (self.grb_editor_app.app.defaults["global_mselect_key"] == 'Control' and
-                            key_modifier == Qt.ControlModifier) or \
-                                (self.grb_editor_app.app.defaults["global_mselect_key"] == 'Shift' and
-                                 key_modifier == Qt.ShiftModifier):
-
-                            if shape in self.draw_app.selected:
-                                self.draw_app.selected.remove(shape)
+                for geo_el in self.grb_editor_app.storage_dict[storage]['geometry']:
+                    if 'solid' in geo_el.geo:
+                        geometric_data = geo_el.geo['solid']
+                        if Point(point).within(geometric_data):
+                            if (self.grb_editor_app.app.defaults["global_mselect_key"] == 'Control' and
+                                key_modifier == Qt.ControlModifier) or \
+                                    (self.grb_editor_app.app.defaults["global_mselect_key"] == 'Shift' and
+                                     key_modifier == Qt.ShiftModifier):
+
+                                if geo_el in self.draw_app.selected:
+                                    self.draw_app.selected.remove(geo_el)
+                                else:
+                                    # add the object to the selected shapes
+                                    self.draw_app.selected.append(geo_el)
+                                    sel_aperture.add(storage)
                             else:
-                                # add the object to the selected shapes
-                                self.draw_app.selected.append(shape)
+                                self.draw_app.selected.append(geo_el)
                                 sel_aperture.add(storage)
-                        else:
-                            self.draw_app.selected.append(shape)
-                            sel_aperture.add(storage)
             except KeyError:
                 pass
 
@@ -2803,13 +2805,15 @@ class FlatCAMGrbEditor(QtCore.QObject):
                 geometric_data = geo_el.geo
                 new_geo_el = dict()
                 if 'solid' in geometric_data:
-                    new_geo_el['solid'] = deepcopy(geometric_data['solid'])
+                    new_geo_el['solid'] = deepcopy(affinity.scale(geometric_data['solid'],
+                                                                  xfact=factor, yfact=factor))
                 if 'follow' in geometric_data:
-                    new_geo_el['follow'] = deepcopy(geometric_data['follow'])
+                    new_geo_el['follow'] = deepcopy(affinity.scale(geometric_data['follow'],
+                                                                   xfact=factor, yfact=factor))
                 if 'clear' in geometric_data:
-                    new_geo_el['clear'] = deepcopy(geometric_data['clear'])
-                # geometry.append(DrawToolShape(
-                #     MultiLineString([affinity.scale(subgeo, xfact=factor, yfact=factor) for subgeo in shape.geo])))
+                    new_geo_el['clear'] = deepcopy(affinity.scale(geometric_data['clear'],
+                                                                  xfact=factor, yfact=factor))
+                geometry.append(new_geo_el)
 
             self.add_gerber_shape(geometry, self.storage_dict[current_table_dia_edited])