# ########################################################## # FlatCAM: 2D Post-processing for Manufacturing # # http://flatcam.org # # Author: Juan Pablo Caram (c) # # Date: 2/5/2014 # # MIT Licence # # ########################################################## # ########################################################## # File Modified: Marius Adrian Stanciu (c) # # Date: 3/10/2019 # # ########################################################## # import inspect import math from camlib import distance, arc, three_point_circle, Geometry, AppRTreeStorage, flatten_shapely_geometry from appGUI.GUIElements import * from appGUI.VisPyVisuals import ShapeCollection from appEditors.plugins.GeoBufferPlugin import BufferSelectionTool from appEditors.plugins.GeoPaintPlugin import PaintOptionsTool from appEditors.plugins.GeoTextPlugin import TextInputTool from appEditors.plugins.GeoTransformationPlugin import TransformEditorTool from appEditors.plugins.GeoPathPlugin import PathEditorTool from vispy.geometry import Rect from shapely.geometry import LineString, LinearRing, MultiLineString, Polygon, MultiPolygon, Point from shapely.ops import unary_union, linemerge from shapely.affinity import translate, scale, skew, rotate from shapely.geometry.polygon import orient from shapely.geometry.base import BaseGeometry import numpy as np from numpy.linalg import norm as numpy_norm import logging from rtree import index as rtindex from copy import deepcopy # from vispy.io import read_png import gettext import appTranslation as fcTranslate import builtins fcTranslate.apply_language('strings') if '_' not in builtins.__dict__: _ = gettext.gettext log = logging.getLogger('base') class DrawToolShape(object): """ Encapsulates "shapes" under a common class. """ tolerance = None @staticmethod def get_pts(o): """ Returns a list of all points in the object, where the object can be a Polygon, Not a polygon, or a list of such. Search is done recursively. :param o: geometric object :return: List of points :rtype: list """ pts = [] # Iterable: descend into each item. try: if isinstance(o, (MultiPolygon, MultiLineString)): for subo in o.geoms: pts += DrawToolShape.get_pts(subo) else: for subo in o: pts += DrawToolShape.get_pts(subo) # Non-iterable except TypeError: if o is None: return # DrawToolShape: descend into .geo. if isinstance(o, DrawToolShape): pts += DrawToolShape.get_pts(o.geo) # Descend into .exterior and .interiors elif isinstance(o, Polygon): pts += DrawToolShape.get_pts(o.exterior) for i in o.interiors: pts += DrawToolShape.get_pts(i) elif isinstance(o, (MultiLineString, MultiPolygon)): for geo_pol_line in o.geoms: pts += DrawToolShape.get_pts(geo_pol_line) # Has .coords: list them. else: if DrawToolShape.tolerance is not None: pts += list(o.simplify(DrawToolShape.tolerance).coords) else: pts += list(o.coords) return pts def __init__(self, geo: (BaseGeometry, list)): # Shapely type or list of such self.geo = geo self.utility = False self.data = { 'name': _("Geo Elem"), 'type': _('Path'), # 'Path', 'Arc', 'Rectangle', 'Polygon', 'Circle', 'origin': 'center', # 'center', 'tl', 'tr', 'bl', 'br' 'bounds': self.bounds() # xmin, ymin, xmax, ymax } def get_all_points(self): return DrawToolShape.get_pts(self) def bounds(self): """ Returns coordinates of rectangular bounds of geometry: (xmin, ymin, xmax, ymax). """ # fixed issue of getting bounds only for one level lists of objects # now it can get bounds for nested lists of objects def bounds_rec(shape_el): if type(shape_el) is list: minx = np.Inf miny = np.Inf maxx = -np.Inf maxy = -np.Inf for k in shape_el: minx_, miny_, maxx_, maxy_ = bounds_rec(k) minx = min(minx, minx_) miny = min(miny, miny_) maxx = max(maxx, maxx_) maxy = max(maxy, maxy_) return minx, miny, maxx, maxy else: # it's a Shapely object, return it's bounds return shape_el.bounds bounds_coords = bounds_rec(self.geo) return bounds_coords def mirror(self, axis, point): """ Mirrors the shape around a specified axis passing through the given point. :param axis: "X" or "Y" indicates around which axis to mirror. :type axis: str :param point: [x, y] point belonging to the mirror axis. :type point: list :return: None """ px, py = point xscale, yscale = {"X": (1.0, -1.0), "Y": (-1.0, 1.0)}[axis] def mirror_geom(shape_el): if type(shape_el) is list: new_obj = [] for g in shape_el: new_obj.append(mirror_geom(g)) return new_obj else: return scale(shape_el, xscale, yscale, origin=(px, py)) try: self.geo = mirror_geom(self.geo) except AttributeError: log.debug("DrawToolShape.mirror() --> Failed to mirror. No shape selected") def rotate(self, angle, point): """ Rotate a shape by an angle (in degrees) around the provided coordinates. The angle of rotation are specified in degrees (default). Positive angles are counter-clockwise and negative are clockwise rotations. The point of origin can be a keyword 'center' for the bounding box center (default), 'centroid' for the geometry's centroid, a Point object or a coordinate tuple (x0, y0). See shapely manual for more information: http://toblerity.org/shapely/manual.html#affine-transformations :param angle: The angle of rotation :param point: The point of origin :return: None """ px, py = point def rotate_geom(shape_el): if type(shape_el) is list: new_obj = [] for g in shape_el: new_obj.append(rotate_geom(g)) return new_obj else: return rotate(shape_el, angle, origin=(px, py)) try: self.geo = rotate_geom(self.geo) except AttributeError: log.debug("DrawToolShape.rotate() --> Failed to rotate. No shape selected") def skew(self, angle_x, angle_y, point): """ Shear/Skew a shape by angles along x and y dimensions. angle_x, angle_y : float, float The shear angle(s) for the x and y axes respectively. These can be specified in either degrees (default) or radians by setting use_radians=True. See shapely manual for more information: http://toblerity.org/shapely/manual.html#affine-transformations :param angle_x: :param angle_y: :param point: tuple of coordinates (x,y) :return: """ px, py = point def skew_geom(shape_el): if type(shape_el) is list: new_obj = [] for g in shape_el: new_obj.append(skew_geom(g)) return new_obj else: return skew(shape_el, angle_x, angle_y, origin=(px, py)) try: self.geo = skew_geom(self.geo) except AttributeError: log.debug("DrawToolShape.skew() --> Failed to skew. No shape selected") def offset(self, vect): """ Offsets all shapes by a given vector :param vect: (x, y) vector by which to offset the shape geometry :type vect: tuple :return: None :rtype: None """ try: dx, dy = vect except TypeError: log.debug("DrawToolShape.offset() --> An (x,y) pair of values are needed. " "Probable you entered only one value in the Offset field.") return def translate_recursion(geom): if type(geom) == list: geoms = [] for local_geom in geom: geoms.append(translate_recursion(local_geom)) return geoms else: return translate(geom, xoff=dx, yoff=dy) try: self.geo = translate_recursion(self.geo) except AttributeError: log.debug("DrawToolShape.offset() --> Failed to offset. No shape selected") def scale(self, xfactor, yfactor=None, point=None): """ Scales all shape geometry by a given factor. :param xfactor: Factor by which to scale the shape's geometry/ :type xfactor: float :param yfactor: Factor by which to scale the shape's geometry/ :type yfactor: float :param point: Point of origin; tuple :return: None :rtype: None """ try: xfactor = float(xfactor) except Exception: log.debug("DrawToolShape.offset() --> Scale factor has to be a number: integer or float.") return if yfactor is None: yfactor = xfactor else: try: yfactor = float(yfactor) except Exception: log.debug("DrawToolShape.offset() --> Scale factor has to be a number: integer or float.") return if point is None: px = 0 py = 0 else: px, py = point def scale_recursion(geom): if type(geom) == list: geoms = [] for local_geom in geom: geoms.append(scale_recursion(local_geom)) return geoms else: return scale(geom, xfactor, yfactor, origin=(px, py)) try: self.geo = scale_recursion(self.geo) except AttributeError: log.debug("DrawToolShape.scale() --> Failed to scale. No shape selected") def buffer(self, value, join=None, factor=None): """ Create a buffered geometry :param value: the distance to which to buffer :param join: the type of connections between nearby buffer lines :param factor: a scaling factor which will do a "sort of" buffer :return: None """ def buffer_recursion(geom): if type(geom) == list: geoms = [] for local_geom in geom: geoms.append(buffer_recursion(local_geom)) return geoms else: if factor: return scale(geom, xfact=value, yfact=value, origin='center') else: return geom.buffer(value, resolution=32, join_style=join) try: self.geo = buffer_recursion(self.geo) except AttributeError: log.debug("DrawToolShape.buffer() --> Failed to buffer. No shape selected") class DrawToolUtilityShape(DrawToolShape): """ Utility shapes are temporary geometry in the editor to assist in the creation of shapes. For example, it will show the outline of a rectangle from the first point to the current mouse pointer before the second point is clicked and the final geometry is created. """ def __init__(self, geo: (BaseGeometry, list)): super(DrawToolUtilityShape, self).__init__(geo=geo) self.utility = True class DrawTool(object): """ Abstract Class representing a tool in the drawing program. Can generate geometry, including temporary utility geometry that is updated on user clicks and mouse motion. """ def __init__(self, draw_app): self.draw_app = draw_app self.complete = False self.points = [] self.geometry = None # DrawToolShape or None def click(self, point): """ :param point: [x, y] Coordinate pair. """ return "" def click_release(self, point): """ :param point: [x, y] Coordinate pair. """ return "" def on_key(self, key): # Jump to coords if key == QtCore.Qt.Key.Key_J or key == 'J': self.draw_app.app.on_jump_to() return def utility_geometry(self, data=None): return None @staticmethod def bounds(obj): def bounds_rec(o): if type(o) is list: minx = np.Inf miny = np.Inf maxx = -np.Inf maxy = -np.Inf for k in o: try: minx_, miny_, maxx_, maxy_ = bounds_rec(k) except Exception as e: log.error("camlib.Gerber.bounds() --> %s" % str(e)) return minx = min(minx, minx_) miny = min(miny, miny_) maxx = max(maxx, maxx_) maxy = max(maxy, maxy_) return minx, miny, maxx, maxy else: # it's a Shapely object, return it's bounds return o.geo.bounds bounds_coords = bounds_rec(obj) return bounds_coords class FCShapeTool(DrawTool): """ Abstract class for tools that create a shape. """ def __init__(self, draw_app): DrawTool.__init__(self, draw_app) self.name = None def make(self): pass class FCCircle(FCShapeTool): """ Resulting type: Polygon """ def __init__(self, draw_app): DrawTool.__init__(self, draw_app) self.name = 'circle' self.draw_app = draw_app try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.cursor = QtGui.QCursor(QtGui.QPixmap(self.draw_app.app.resource_location + '/aero_circle_geo.png')) QtGui.QGuiApplication.setOverrideCursor(self.cursor) self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.draw_app.app.inform.emit(_("Click on Center point ...")) self.steps_per_circ = self.draw_app.app.options["geometry_circle_steps"] def click(self, point): try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.points.append(point) if len(self.points) == 1: self.draw_app.app.inform.emit(_("Click on Perimeter point to complete ...")) return "Click on perimeter to complete ..." if len(self.points) == 2: self.make() return "Done." return "" def utility_geometry(self, data=None): if len(self.points) == 1: p1 = self.points[0] p2 = data radius = np.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2) return DrawToolUtilityShape(Point(p1).buffer(radius, int(self.steps_per_circ / 4))) return None def make(self): try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass p1 = self.points[0] p2 = self.points[1] radius = distance(p1, p2) circle_shape = Point(p1).buffer(radius, int(self.steps_per_circ / 4)).exterior self.geometry = DrawToolShape(circle_shape) self.complete = True self.draw_app.app.jump_signal.disconnect() self.geometry.data['type'] = _('Circle') self.draw_app.app.inform.emit('[success] %s' % _("Done.")) def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass class FCArc(FCShapeTool): def __init__(self, draw_app): DrawTool.__init__(self, draw_app) self.name = 'arc' self.draw_app = draw_app try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.cursor = QtGui.QCursor(QtGui.QPixmap(self.draw_app.app.resource_location + '/aero_arc.png')) QtGui.QGuiApplication.setOverrideCursor(self.cursor) self.draw_app.app.inform.emit(_("Click on Center point ...")) # Direction of rotation between point 1 and 2. # 'cw' or 'ccw'. Switch direction by hitting the # 'o' key. self.direction = "cw" # Mode # C12 = Center, p1, p2 # 12C = p1, p2, Center # 132 = p1, p3, p2 self.mode = "c12" # Center, p1, p2 self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.steps_per_circ = self.draw_app.app.options["geometry_circle_steps"] def click(self, point): try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.points.append(point) if len(self.points) == 1: if self.mode == 'c12': self.draw_app.app.inform.emit(_("Click on Start point ...")) elif self.mode == '132': self.draw_app.app.inform.emit(_("Click on Point3 ...")) else: self.draw_app.app.inform.emit(_("Click on Stop point ...")) return "Click on 1st point ..." if len(self.points) == 2: if self.mode == 'c12': self.draw_app.app.inform.emit(_("Click on Stop point to complete ...")) elif self.mode == '132': self.draw_app.app.inform.emit(_("Click on Point2 to complete ...")) else: self.draw_app.app.inform.emit(_("Click on Center point to complete ...")) return "Click on 2nd point to complete ..." if len(self.points) == 3: self.make() return "Done." return "" def on_key(self, key): if key == 'D' or key == QtCore.Qt.Key.Key_D: self.direction = 'cw' if self.direction == 'ccw' else 'ccw' return '%s: %s' % (_('Direction'), self.direction.upper()) # Jump to coords if key == QtCore.Qt.Key.Key_J or key == 'J': self.draw_app.app.on_jump_to() if key == 'M' or key == QtCore.Qt.Key.Key_M: # delete the possible points made before this action; we want to start anew self.points[:] = [] # and delete the utility geometry made up until this point self.draw_app.delete_utility_geometry() if self.mode == 'c12': self.mode = '12c' return _('Mode: Start -> Stop -> Center. Click on Start point ...') elif self.mode == '12c': self.mode = '132' return _('Mode: Point1 -> Point3 -> Point2. Click on Point1 ...') else: self.mode = 'c12' return _('Mode: Center -> Start -> Stop. Click on Center point ...') def utility_geometry(self, data=None): if len(self.points) == 1: # Show the radius center = self.points[0] p1 = data return DrawToolUtilityShape(LineString([center, p1])) if len(self.points) == 2: # Show the arc if self.mode == 'c12': center = self.points[0] p1 = self.points[1] p2 = data radius = np.sqrt((center[0] - p1[0]) ** 2 + (center[1] - p1[1]) ** 2) startangle = np.arctan2(p1[1] - center[1], p1[0] - center[0]) stopangle = np.arctan2(p2[1] - center[1], p2[0] - center[0]) return DrawToolUtilityShape([LineString(arc(center, radius, startangle, stopangle, self.direction, self.steps_per_circ)), Point(center)]) elif self.mode == '132': p1 = np.array(self.points[0]) p3 = np.array(self.points[1]) p2 = np.array(data) try: center, radius, t = three_point_circle(p1, p2, p3) except TypeError: return direction = 'cw' if np.sign(t) > 0 else 'ccw' startangle = np.arctan2(p1[1] - center[1], p1[0] - center[0]) stopangle = np.arctan2(p3[1] - center[1], p3[0] - center[0]) return DrawToolUtilityShape([LineString(arc(center, radius, startangle, stopangle, direction, self.steps_per_circ)), Point(center), Point(p1), Point(p3)]) else: # '12c' p1 = np.array(self.points[0]) p2 = np.array(self.points[1]) # Midpoint a = (p1 + p2) / 2.0 # Parallel vector c = p2 - p1 # Perpendicular vector b = np.dot(c, np.array([[0, -1], [1, 0]], dtype=np.float32)) b /= numpy_norm(b) # Distance t = distance(data, a) # Which side? Cross product with c. # cross(M-A, B-A), where line is AB and M is test point. side = (data[0] - p1[0]) * c[1] - (data[1] - p1[1]) * c[0] t *= np.sign(side) # Center = a + bt center = a + b * t radius = numpy_norm(center - p1) startangle = np.arctan2(p1[1] - center[1], p1[0] - center[0]) stopangle = np.arctan2(p2[1] - center[1], p2[0] - center[0]) return DrawToolUtilityShape([LineString(arc(center, radius, startangle, stopangle, self.direction, self.steps_per_circ)), Point(center)]) return None def make(self): if self.mode == 'c12': center = self.points[0] p1 = self.points[1] p2 = self.points[2] radius = distance(center, p1) startangle = np.arctan2(p1[1] - center[1], p1[0] - center[0]) stopangle = np.arctan2(p2[1] - center[1], p2[0] - center[0]) self.geometry = DrawToolShape(LineString(arc(center, radius, startangle, stopangle, self.direction, self.steps_per_circ))) elif self.mode == '132': p1 = np.array(self.points[0]) p3 = np.array(self.points[1]) p2 = np.array(self.points[2]) center, radius, t = three_point_circle(p1, p2, p3) direction = 'cw' if np.sign(t) > 0 else 'ccw' startangle = np.arctan2(p1[1] - center[1], p1[0] - center[0]) stopangle = np.arctan2(p3[1] - center[1], p3[0] - center[0]) self.geometry = DrawToolShape(LineString(arc(center, radius, startangle, stopangle, direction, self.steps_per_circ))) else: # self.mode == '12c' p1 = np.array(self.points[0]) p2 = np.array(self.points[1]) pc = np.array(self.points[2]) # Midpoint a = (p1 + p2) / 2.0 # Parallel vector c = p2 - p1 # Perpendicular vector b = np.dot(c, np.array([[0, -1], [1, 0]], dtype=np.float32)) b /= numpy_norm(b) # Distance t = distance(pc, a) # Which side? Cross product with c. # cross(M-A, B-A), where line is AB and M is test point. side = (pc[0] - p1[0]) * c[1] - (pc[1] - p1[1]) * c[0] t *= np.sign(side) # Center = a + bt center = a + b * t radius = numpy_norm(center - p1) startangle = np.arctan2(p1[1] - center[1], p1[0] - center[0]) stopangle = np.arctan2(p2[1] - center[1], p2[0] - center[0]) self.geometry = DrawToolShape(LineString(arc(center, radius, startangle, stopangle, self.direction, self.steps_per_circ))) self.complete = True self.draw_app.app.jump_signal.disconnect() self.geometry.data['type'] = _('Arc') self.draw_app.app.inform.emit('[success] %s' % _("Done.")) def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass class FCRectangle(FCShapeTool): """ Resulting type: Polygon """ def __init__(self, draw_app): DrawTool.__init__(self, draw_app) self.name = 'rectangle' self.draw_app = draw_app try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.cursor = QtGui.QCursor(QtGui.QPixmap(self.draw_app.app.resource_location + '/aero.png')) QtGui.QGuiApplication.setOverrideCursor(self.cursor) self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.draw_app.app.inform.emit(_("Click on 1st corner ...")) def click(self, point): try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.points.append(point) if len(self.points) == 1: self.draw_app.app.inform.emit(_("Click on opposite corner to complete ...")) return "Click on opposite corner to complete ..." if len(self.points) == 2: self.make() return "Done." return "" def utility_geometry(self, data=None): if len(self.points) == 1: p1 = self.points[0] p2 = data return DrawToolUtilityShape(LinearRing([p1, (p2[0], p1[1]), p2, (p1[0], p2[1])])) return None def make(self): try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass p1 = self.points[0] p2 = self.points[1] # self.geometry = LinearRing([p1, (p2[0], p1[1]), p2, (p1[0], p2[1])]) geo = LinearRing([p1, (p2[0], p1[1]), p2, (p1[0], p2[1])]) self.geometry = DrawToolShape(geo) self.geometry.data['type'] = _('Rectangle') self.complete = True self.draw_app.app.jump_signal.disconnect() self.draw_app.app.inform.emit('[success] %s' % _("Done.")) def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass class FCPolygon(FCShapeTool): """ Resulting type: Polygon """ def __init__(self, draw_app): DrawTool.__init__(self, draw_app) self.name = 'polygon' self.draw_app = draw_app self.app = self.draw_app.app self.plugin_name = _("Polygon") try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.cursor = QtGui.QCursor(QtGui.QPixmap(self.draw_app.app.resource_location + '/aero.png')) QtGui.QGuiApplication.setOverrideCursor(self.cursor) if self.app.use_3d_engine: self.draw_app.app.plotcanvas.view.camera.zoom_callback = self.draw_cursor_data self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.polygon_tool = PathEditorTool(self.app, self.draw_app, plugin_name=self.plugin_name) self.polygon_tool.run() self.new_segment = True self.app.ui.notebook.setTabText(2, self.plugin_name) if self.draw_app.app.ui.splitter.sizes()[0] == 0: self.draw_app.app.ui.splitter.setSizes([1, 1]) self.draw_app.app.inform.emit(_("Click on 1st corner ...")) def click(self, point): try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.draw_app.in_action = True if point != self.points[-1:]: self.points.append(point) if len(self.points) > 0: self.draw_app.app.inform.emit(_("Click on next Point or click right mouse button to complete ...")) return "Click on next point or hit ENTER to complete ..." return "" def make(self): try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass if self.points[-1] == self.points[-2]: self.points.pop(-1) # self.geometry = LinearRing(self.points) self.geometry = DrawToolShape(LinearRing(self.points)) self.draw_app.in_action = False self.complete = True self.draw_app.app.jump_signal.disconnect() self.geometry.data['type'] = self.plugin_name self.draw_cursor_data(delete=True) self.draw_app.app.inform.emit('[success] %s' % _("Done.")) def utility_geometry(self, data=None): if len(self.points) == 1: temp_points = [x for x in self.points] temp_points.append(data) return DrawToolUtilityShape(LineString(temp_points)) elif len(self.points) > 1: temp_points = [x for x in self.points] temp_points.append(data) return DrawToolUtilityShape(LinearRing(temp_points)) else: return None def draw_cursor_data(self, pos=None, delete=False): if pos is None: pos = self.draw_app.snap_x, self.draw_app.snap_y if delete: if self.draw_app.app.use_3d_engine: self.draw_app.app.plotcanvas.text_cursor.parent = None self.draw_app.app.plotcanvas.view.camera.zoom_callback = lambda *args: None return # font size qsettings = QtCore.QSettings("Open Source", "FlatCAM") if qsettings.contains("hud_font_size"): fsize = qsettings.value('hud_font_size', type=int) else: fsize = 8 x = pos[0] y = pos[1] try: length = abs(np.sqrt((pos[0] - self.points[-1][0]) ** 2 + (pos[1] - self.points[-1][1]) ** 2)) except IndexError: length = self.draw_app.app.dec_format(0.0, self.draw_app.app.decimals) units = self.draw_app.app.app_units.lower() x_dec = str(self.draw_app.app.dec_format(x, self.draw_app.app.decimals)) if x else '0.0' y_dec = str(self.draw_app.app.dec_format(y, self.draw_app.app.decimals)) if y else '0.0' length_dec = str(self.draw_app.app.dec_format(length, self.draw_app.app.decimals)) if length else '0.0' l1_txt = 'X: %s [%s]' % (x_dec, units) l2_txt = 'Y: %s [%s]' % (y_dec, units) l3_txt = 'L: %s [%s]' % (length_dec, units) cursor_text = '%s\n%s\n\n%s' % (l1_txt, l2_txt, l3_txt) if self.draw_app.app.use_3d_engine: new_pos = self.draw_app.app.plotcanvas.translate_coords_2((x, y)) x, y, __, ___ = self.draw_app.app.plotcanvas.translate_coords((new_pos[0]+30, new_pos[1])) # text self.draw_app.app.plotcanvas.text_cursor.font_size = fsize self.draw_app.app.plotcanvas.text_cursor.text = cursor_text self.draw_app.app.plotcanvas.text_cursor.pos = x, y self.draw_app.app.plotcanvas.text_cursor.anchors = 'left', 'top' if self.draw_app.app.plotcanvas.text_cursor.parent is None: self.draw_app.app.plotcanvas.text_cursor.parent = self.draw_app.app.plotcanvas.view.scene def on_key(self, key): # Jump to coords if key == QtCore.Qt.Key.Key_J or key == 'J': self.draw_app.app.on_jump_to() if key == 'Backspace' or key == QtCore.Qt.Key.Key_Backspace: if len(self.points) > 0: self.points = self.points[0:-1] # Remove any previous utility shape self.draw_app.tool_shape.clear(update=False) geo = self.utility_geometry(data=(self.draw_app.snap_x, self.draw_app.snap_y)) self.draw_app.draw_utility_geometry(geo=geo) if geo: return _("Backtracked one point ...") else: self.draw_app.app.inform.emit(_("Click on 1st corner ...")) if key in [str(i) for i in range(10)] + ['.', ',', '+', '-', '/', '*'] or \ key in [QtCore.Qt.Key.Key_0, QtCore.Qt.Key.Key_0, QtCore.Qt.Key.Key_1, QtCore.Qt.Key.Key_2, QtCore.Qt.Key.Key_3, QtCore.Qt.Key.Key_4, QtCore.Qt.Key.Key_5, QtCore.Qt.Key.Key_6, QtCore.Qt.Key.Key_7, QtCore.Qt.Key.Key_8, QtCore.Qt.Key.Key_9, QtCore.Qt.Key.Key_Minus, QtCore.Qt.Key.Key_Plus, QtCore.Qt.Key.Key_Comma, QtCore.Qt.Key.Key_Period, QtCore.Qt.Key.Key_Slash, QtCore.Qt.Key.Key_Asterisk]: try: # VisPy keys if self.polygon_tool.length == 0 or self.new_segment is True: self.polygon_tool.length = str(key.name) self.new_segment = False else: self.polygon_tool.length = str(self.polygon_tool.length) + str(key.name) except AttributeError: # Qt keys if self.polygon_tool.length == 0 or self.new_segment is True: self.polygon_tool.length = chr(key) self.new_segment = False else: self.polygon_tool.length = str(self.polygon_tool.length) + chr(key) if key == 'Enter' or key == QtCore.Qt.Key.Key_Return or key == QtCore.Qt.Key.Key_Enter: if self.polygon_tool.length != 0: target_length = self.polygon_tool.length if target_length is None: self.polygon_tool.length = 0.0 return _("Failed.") first_pt = self.points[-1] last_pt = self.draw_app.app.mouse seg_length = math.sqrt((last_pt[0] - first_pt[0])**2 + (last_pt[1] - first_pt[1])**2) if seg_length == 0.0: return try: new_x = first_pt[0] + (last_pt[0] - first_pt[0]) / seg_length * target_length new_y = first_pt[1] + (last_pt[1] - first_pt[1]) / seg_length * target_length except ZeroDivisionError as err: self.points = [] self.clean_up() return '[ERROR_NOTCL] %s %s' % (_("Failed."), str(err).capitalize()) if self.points[-1] != (new_x, new_y): self.points.append((new_x, new_y)) self.new_segment = True self.draw_app.app.on_jump_to(custom_location=(new_x, new_y), fit_center=False) if len(self.points) > 0: msg = '%s: %s. %s' % ( _("Projected"), str(self.polygon_tool.length), _("Click on next Point or click right mouse button to complete ...")) self.draw_app.app.inform.emit(msg) def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() if self.draw_app.app.use_3d_engine: self.draw_app.app.plotcanvas.text_cursor.parent = None self.draw_app.app.plotcanvas.view.camera.zoom_callback = lambda *args: None try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.polygon_tool.on_tab_close() class FCPath(FCShapeTool): """ Resulting type: LineString """ def __init__(self, draw_app): FCShapeTool.__init__(self, draw_app) self.draw_app = draw_app self.name = 'path' self.app = self.draw_app.app try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.cursor = QtGui.QCursor(QtGui.QPixmap(self.draw_app.app.resource_location + '/aero_path5.png')) QtGui.QGuiApplication.setOverrideCursor(self.cursor) if self.app.use_3d_engine: self.draw_app.app.plotcanvas.view.camera.zoom_callback = self.draw_cursor_data self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.path_tool = PathEditorTool(self.app, self.draw_app, plugin_name=_("Path")) self.path_tool.run() self.new_segment = True self.app.ui.notebook.setTabText(2, _("Path")) if self.draw_app.app.ui.splitter.sizes()[0] == 0: self.draw_app.app.ui.splitter.setSizes([1, 1]) self.draw_app.app.inform.emit(_("Click on 1st point ...")) def click(self, point): try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) self.draw_app.in_action = True if point != self.points[-1:]: self.points.append(point) if len(self.points) > 0: self.draw_app.app.inform.emit(_("Click on next Point or click right mouse button to complete ...")) return "Click on next point or hit ENTER to complete ..." return "" def make(self): self.geometry = DrawToolShape(LineString(self.points)) self.name = 'path' try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.draw_app.in_action = False self.complete = True self.draw_app.app.jump_signal.disconnect() self.geometry.data['type'] = _('Path') self.draw_cursor_data(delete=True) self.draw_app.app.inform.emit('[success] %s' % _("Done.")) def utility_geometry(self, data=None): if len(self.points) > 0: temp_points = [x for x in self.points] temp_points.append(data) return DrawToolUtilityShape(LineString(temp_points)) return None def draw_cursor_data(self, pos=None, delete=False): if pos is None: pos = self.draw_app.snap_x, self.draw_app.snap_y if delete: if self.draw_app.app.use_3d_engine: self.draw_app.app.plotcanvas.text_cursor.parent = None self.draw_app.app.plotcanvas.view.camera.zoom_callback = lambda *args: None return # font size qsettings = QtCore.QSettings("Open Source", "FlatCAM") if qsettings.contains("hud_font_size"): fsize = qsettings.value('hud_font_size', type=int) else: fsize = 8 x = pos[0] y = pos[1] try: length = abs(np.sqrt((pos[0] - self.points[-1][0]) ** 2 + (pos[1] - self.points[-1][1]) ** 2)) except IndexError: length = self.draw_app.app.dec_format(0.0, self.draw_app.app.decimals) units = self.draw_app.app.app_units.lower() x_dec = str(self.draw_app.app.dec_format(x, self.draw_app.app.decimals)) if x else '0.0' y_dec = str(self.draw_app.app.dec_format(y, self.draw_app.app.decimals)) if y else '0.0' length_dec = str(self.draw_app.app.dec_format(length, self.draw_app.app.decimals)) if length else '0.0' l1_txt = 'X: %s [%s]' % (x_dec, units) l2_txt = 'Y: %s [%s]' % (y_dec, units) l3_txt = 'L: %s [%s]' % (length_dec, units) cursor_text = '%s\n%s\n\n%s' % (l1_txt, l2_txt, l3_txt) if self.draw_app.app.use_3d_engine: new_pos = self.draw_app.app.plotcanvas.translate_coords_2((x, y)) x, y, __, ___ = self.draw_app.app.plotcanvas.translate_coords((new_pos[0]+30, new_pos[1])) # text self.draw_app.app.plotcanvas.text_cursor.font_size = fsize self.draw_app.app.plotcanvas.text_cursor.text = cursor_text self.draw_app.app.plotcanvas.text_cursor.pos = x, y self.draw_app.app.plotcanvas.text_cursor.anchors = 'left', 'top' if self.draw_app.app.plotcanvas.text_cursor.parent is None: self.draw_app.app.plotcanvas.text_cursor.parent = self.draw_app.app.plotcanvas.view.scene def on_key(self, key): # Jump to coords if key == QtCore.Qt.Key.Key_J or key == 'J': self.draw_app.app.on_jump_to() if key == 'Backspace' or key == QtCore.Qt.Key.Key_Backspace: if len(self.points) > 0: self.points = self.points[0:-1] # Remove any previous utility shape self.draw_app.tool_shape.clear(update=False) geo = self.utility_geometry(data=(self.draw_app.snap_x, self.draw_app.snap_y)) self.draw_app.draw_utility_geometry(geo=geo) if geo: return _("Backtracked one point ...") else: return _("Click on 1st point ...") if key in [str(i) for i in range(10)] + ['.', ',', '+', '-', '/', '*'] or \ key in [QtCore.Qt.Key.Key_0, QtCore.Qt.Key.Key_0, QtCore.Qt.Key.Key_1, QtCore.Qt.Key.Key_2, QtCore.Qt.Key.Key_3, QtCore.Qt.Key.Key_4, QtCore.Qt.Key.Key_5, QtCore.Qt.Key.Key_6, QtCore.Qt.Key.Key_7, QtCore.Qt.Key.Key_8, QtCore.Qt.Key.Key_9, QtCore.Qt.Key.Key_Minus, QtCore.Qt.Key.Key_Plus, QtCore.Qt.Key.Key_Comma, QtCore.Qt.Key.Key_Period, QtCore.Qt.Key.Key_Slash, QtCore.Qt.Key.Key_Asterisk]: try: # VisPy keys if self.path_tool.length == 0 or self.new_segment is True: self.path_tool.length = str(key.name) self.new_segment = False else: self.path_tool.length = str(self.path_tool.length) + str(key.name) except AttributeError: # Qt keys if self.path_tool.length == 0 or self.new_segment is True: self.path_tool.length = chr(key) self.new_segment = False else: self.path_tool.length = str(self.path_tool.length) + chr(key) if key == 'Enter' or key == QtCore.Qt.Key.Key_Return or key == QtCore.Qt.Key.Key_Enter: if self.path_tool.length != 0: # target_length = self.interpolate_length.replace(',', '.') # try: # target_length = eval(target_length) # except SyntaxError as err: # ret = '%s: %s' % (str(err).capitalize(), self.interpolate_length) # self.interpolate_length = '' # return ret target_length = self.path_tool.length if target_length is None: self.path_tool.length = 0.0 return _("Failed.") first_pt = self.points[-1] last_pt = self.draw_app.app.mouse seg_length = math.sqrt((last_pt[0] - first_pt[0])**2 + (last_pt[1] - first_pt[1])**2) if seg_length == 0.0: return try: new_x = first_pt[0] + (last_pt[0] - first_pt[0]) / seg_length * target_length new_y = first_pt[1] + (last_pt[1] - first_pt[1]) / seg_length * target_length except ZeroDivisionError as err: self.points = [] self.clean_up() return '[ERROR_NOTCL] %s %s' % (_("Failed."), str(err).capitalize()) if self.points[-1] != (new_x, new_y): self.points.append((new_x, new_y)) self.new_segment = True self.draw_app.app.on_jump_to(custom_location=(new_x, new_y), fit_center=False) if len(self.points) > 0: msg = '%s: %s. %s' % ( _("Projected"), str(self.path_tool.length), _("Click on next Point or click right mouse button to complete ...")) self.draw_app.app.inform.emit(msg) # self.interpolate_length = '' # return "Click on next point or hit ENTER to complete ..." def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() if self.draw_app.app.use_3d_engine: self.draw_app.app.plotcanvas.text_cursor.parent = None self.draw_app.app.plotcanvas.view.camera.zoom_callback = lambda *args: None try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.path_tool.on_tab_close() class FCSelect(DrawTool): def __init__(self, draw_app): DrawTool.__init__(self, draw_app) self.name = 'select' self.draw_app = draw_app try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.storage = self.draw_app.storage # self.shape_buffer = self.draw_app.shape_buffer # self.selected = self.draw_app.selected # make sure that the cursor text from the FCPath is deleted if self.draw_app.app.plotcanvas.text_cursor.parent: self.draw_app.app.plotcanvas.text_cursor.parent = None # make sure that the Tools tab is removed try: self.draw_app.app.ui.notebook.removeTab(2) except Exception: pass def click_release(self, point): """ :param point: The point for which to find the neasrest shape :return: """ # list where we store the overlapped shapes under our mouse left click position over_shape_list = [] if self.draw_app.interdict_selection is True: self.draw_app.app.inform.emit('[WARNING_NOTCL] %s' % _("Selection not allowed. Wait ...")) return # pos[0] and pos[1] are the mouse click coordinates (x, y) for ____ in self.storage.get_objects(): # first method of click selection -> inconvenient # minx, miny, maxx, maxy = obj_shape.geo.bounds # if (minx <= pos[0] <= maxx) and (miny <= pos[1] <= maxy): # over_shape_list.append(obj_shape) # second method of click selection -> slow # outside = obj_shape.geo.buffer(0.1) # inside = obj_shape.geo.buffer(-0.1) # shape_band = outside.difference(inside) # if Point(pos).within(shape_band): # over_shape_list.append(obj_shape) # 3rd method of click selection -> inconvenient try: __, closest_shape = self.storage.nearest(point) except StopIteration: return "" over_shape_list.append(closest_shape) try: # if there is no shape under our click then deselect all shapes # it will not work for 3rd method of click selection if not over_shape_list: self.draw_app.selected = [] AppGeoEditor.draw_shape_idx = -1 else: # if there are shapes under our click then advance through the list of them, one at the time in a # circular way AppGeoEditor.draw_shape_idx = (AppGeoEditor.draw_shape_idx + 1) % len(over_shape_list) obj_to_add = over_shape_list[int(AppGeoEditor.draw_shape_idx)] key_modifier = QtWidgets.QApplication.keyboardModifiers() if key_modifier == QtCore.Qt.KeyboardModifier.ShiftModifier: mod_key = 'Shift' elif key_modifier == QtCore.Qt.KeyboardModifier.ControlModifier: mod_key = 'Control' else: mod_key = None if mod_key == self.draw_app.app.options["global_mselect_key"]: # if modifier key is pressed then we add to the selected list the current shape but if it's already # in the selected list, we removed it. Therefore first click selects, second deselects. if obj_to_add in self.draw_app.selected: self.draw_app.selected.remove(obj_to_add) else: self.draw_app.selected.append(obj_to_add) else: self.draw_app.selected = [obj_to_add] except Exception as e: log.error("[ERROR] AppGeoEditor.FCSelect.click_release() -> Something went bad. %s" % str(e)) # if selection is done on canvas update the Tree in Properties Tab with the selection try: self.draw_app.tw.itemPressed.disconnect(self.draw_app.on_tree_geo_click) except (AttributeError, TypeError): pass self.draw_app.tw.selectionModel().clearSelection() for sel_shape in self.draw_app.selected: iterator = QtWidgets.QTreeWidgetItemIterator(self.draw_app.tw) while iterator.value(): item = iterator.value() try: if int(item.text(0)) == id(sel_shape): item.setSelected(True) except ValueError: pass iterator += 1 self.draw_app.tw.itemPressed.connect(self.draw_app.on_tree_geo_click) # self.draw_app.tw.itemClicked.emit(self.draw_app.tw.currentItem(), 0) self.draw_app.update_ui() return "" def clean_up(self): pass class FCExplode(FCShapeTool): def __init__(self, draw_app): FCShapeTool.__init__(self, draw_app) self.name = 'explode' self.draw_app = draw_app try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.storage = self.draw_app.storage self.origin = (0, 0) self.destination = None self.draw_app.active_tool = self if len(self.draw_app.get_selected()) == 0: self.draw_app.app.inform.emit('[WARNING_NOTCL] %s' % _("No shape selected.")) else: self.make() def make(self): to_be_deleted_list = [] lines = [] for shape in self.draw_app.get_selected(): to_be_deleted_list.append(shape) geo = shape.geo if geo.geom_type == 'MultiLineString': lines = [line for line in geo.geoms] elif geo.geom_type == 'MultiPolygon': lines = [] for poly in geo.geoms: lines.append(poly.exterior) lines += list(poly.interiors) elif geo.is_ring: geo = Polygon(geo) ext_coords = list(geo.exterior.coords) for c in range(len(ext_coords)): if c < len(ext_coords) - 1: lines.append(LineString([ext_coords[c], ext_coords[c + 1]])) for int_geo in geo.interiors: int_coords = list(int_geo.coords) for c in range(len(int_coords)): if c < len(int_coords): lines.append(LineString([int_coords[c], int_coords[c + 1]])) for shape in to_be_deleted_list: self.draw_app.storage.remove(shape) if shape in self.draw_app.selected: self.draw_app.selected.remove(shape) geo_list = [] for line in lines: line_geo = DrawToolShape(line) line_geo.data['type'] = _('Path') geo_list.append(line_geo) self.geometry = geo_list self.draw_app.on_shape_complete() self.draw_app.app.inform.emit('[success] %s...' % _("Done.")) def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass class FCMove(FCShapeTool): def __init__(self, draw_app): FCShapeTool.__init__(self, draw_app) self.name = 'move' self.draw_app = draw_app try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.storage = self.draw_app.storage self.origin = None self.destination = None self.sel_limit = self.draw_app.app.options["geometry_editor_sel_limit"] self.selection_shape = self.selection_bbox() if len(self.draw_app.get_selected()) == 0: self.draw_app.app.inform.emit('[WARNING_NOTCL] %s' % _("No shape selected.")) return else: self.draw_app.app.inform.emit(_("Click on reference location ...")) self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) def set_origin(self, origin): self.draw_app.app.inform.emit(_("Click on destination point ...")) self.origin = origin def click(self, point): try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) if len(self.draw_app.get_selected()) == 0: # self.complete = True # self.draw_app.app.inform.emit(_("[WARNING_NOTCL] Move cancelled. No shape selected.")) self.select_shapes(point) self.draw_app.plot_all() self.draw_app.app.inform.emit(_("Click on reference location ...")) return if self.origin is None: self.set_origin(point) self.selection_shape = self.selection_bbox() return "Click on final location." else: self.destination = point self.make() # self.draw_app.app.worker_task.emit(({'fcn': self.make, # 'params': []})) return "Done." def make(self): with self.draw_app.app.proc_container.new('%s...' % _("Moving")): # Create new geometry dx = self.destination[0] - self.origin[0] dy = self.destination[1] - self.origin[1] self.geometry = [DrawToolShape(translate(geom.geo, xoff=dx, yoff=dy)) for geom in self.draw_app.get_selected()] # Delete old self.draw_app.delete_selected() self.complete = True self.draw_app.app.inform.emit('[success] %s' % _("Done.")) try: self.draw_app.app.jump_signal.disconnect() except TypeError: pass def selection_bbox(self): geo_list = [] for select_shape in self.draw_app.get_selected(): geometric_data = select_shape.geo try: for g in geometric_data: geo_list.append(g) except TypeError: geo_list.append(geometric_data) xmin, ymin, xmax, ymax = get_shapely_list_bounds(geo_list) pt1 = (xmin, ymin) pt2 = (xmax, ymin) pt3 = (xmax, ymax) pt4 = (xmin, ymax) return Polygon([pt1, pt2, pt3, pt4]) def utility_geometry(self, data=None): """ Temporary geometry on screen while using this tool. :param data: :return: """ geo_list = [] if self.origin is None: return None if len(self.draw_app.get_selected()) == 0: return None dx = data[0] - self.origin[0] dy = data[1] - self.origin[1] if len(self.draw_app.get_selected()) <= self.sel_limit: try: for geom in self.draw_app.get_selected(): geo_list.append(translate(geom.geo, xoff=dx, yoff=dy)) except AttributeError: self.draw_app.select_tool('select') self.draw_app.selected = [] return return DrawToolUtilityShape(geo_list) else: try: ss_el = translate(self.selection_shape, xoff=dx, yoff=dy) except ValueError: ss_el = None return DrawToolUtilityShape(ss_el) def select_shapes(self, pos): # list where we store the overlapped shapes under our mouse left click position over_shape_list = [] try: _, closest_shape = self.storage.nearest(pos) except StopIteration: return "" over_shape_list.append(closest_shape) try: # if there is no shape under our click then deselect all shapes # it will not work for 3rd method of click selection if not over_shape_list: self.draw_app.selected = [] self.draw_app.draw_shape_idx = -1 else: # if there are shapes under our click then advance through the list of them, one at the time in a # circular way self.draw_app.draw_shape_idx = (AppGeoEditor.draw_shape_idx + 1) % len(over_shape_list) try: obj_to_add = over_shape_list[int(AppGeoEditor.draw_shape_idx)] except IndexError: return key_modifier = QtWidgets.QApplication.keyboardModifiers() if self.draw_app.app.options["global_mselect_key"] == 'Control': # if CONTROL key is pressed then we add to the selected list the current shape but if it's # already in the selected list, we removed it. Therefore first click selects, second deselects. if key_modifier == Qt.KeyboardModifier.ControlModifier: if obj_to_add in self.draw_app.selected: self.draw_app.selected.remove(obj_to_add) else: self.draw_app.selected.append(obj_to_add) else: self.draw_app.selected = [] self.draw_app.selected.append(obj_to_add) else: if key_modifier == Qt.KeyboardModifier.ShiftModifier: if obj_to_add in self.draw_app.selected: self.draw_app.selected.remove(obj_to_add) else: self.draw_app.selected.append(obj_to_add) else: self.draw_app.selected = [] self.draw_app.selected.append(obj_to_add) except Exception as e: log.error("[ERROR] Something went bad. %s" % str(e)) raise def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass class FCCopy(FCMove): def __init__(self, draw_app): FCMove.__init__(self, draw_app) self.name = 'copy' def make(self): # Create new geometry dx = self.destination[0] - self.origin[0] dy = self.destination[1] - self.origin[1] self.geometry = [DrawToolShape(translate(geom.geo, xoff=dx, yoff=dy)) for geom in self.draw_app.get_selected()] self.complete = True self.draw_app.app.inform.emit('[success] %s' % _("Done.")) try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass class FCText(FCShapeTool): def __init__(self, draw_app): FCShapeTool.__init__(self, draw_app) self.name = 'text' self.draw_app = draw_app try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass self.cursor = QtGui.QCursor(QtGui.QPixmap(self.draw_app.app.resource_location + '/aero_text.png')) QtGui.QGuiApplication.setOverrideCursor(self.cursor) self.app = draw_app.app self.draw_app.app.inform.emit(_("Click on 1st point ...")) self.origin = (0, 0) self.text_gui = TextInputTool(app=self.app, draw_app=self.draw_app) self.text_gui.run() self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) def click(self, point): try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) # Create new geometry dx = point[0] dy = point[1] if self.text_gui.text_path: try: self.geometry = DrawToolShape(translate(self.text_gui.text_path, xoff=dx, yoff=dy)) except Exception as e: log.error("Font geometry is empty or incorrect: %s" % str(e)) self.draw_app.app.inform.emit('[ERROR] %s: %s' % (_("Font not supported. Only Regular, Bold, Italic and BoldItalic are " "supported. Error"), str(e))) self.text_gui.text_path = [] # self.text_gui.hide_tool() self.draw_app.select_tool('select') self.draw_app.app.jump_signal.disconnect() return else: self.draw_app.app.inform.emit('[WARNING_NOTCL] %s' % _("No text to add.")) try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass return self.text_gui.text_path = [] self.text_gui.hide_tool() self.complete = True self.draw_app.app.inform.emit('[success]%s' % _("Done.")) def utility_geometry(self, data=None): """ Temporary geometry on screen while using this tool. :param data: mouse position coords :return: """ dx = data[0] - self.origin[0] dy = data[1] - self.origin[1] try: return DrawToolUtilityShape(translate(self.text_gui.text_path, xoff=dx, yoff=dy)) except Exception: return def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass class FCBuffer(FCShapeTool): def __init__(self, draw_app): FCShapeTool.__init__(self, draw_app) self.name = 'buffer' # self.shape_buffer = self.draw_app.shape_buffer self.draw_app = draw_app self.app = draw_app.app self.draw_app.app.inform.emit(_("Create buffer geometry ...")) self.origin = (0, 0) self.buff_tool = BufferSelectionTool(self.app, self.draw_app) self.buff_tool.run() self.app.ui.notebook.setTabText(2, _("Buffer")) if self.draw_app.app.ui.splitter.sizes()[0] == 0: self.draw_app.app.ui.splitter.setSizes([1, 1]) self.activate() def on_buffer(self): if not self.draw_app.selected: self.draw_app.app.inform.emit('[WARNING_NOTCL] %s %s' % (_("Cancelled."), _("No shape selected."))) return try: buffer_distance = float(self.buff_tool.ui.buffer_distance_entry.get_value()) except ValueError: # try to convert comma to decimal point. if it's still not working error message and return try: buffer_distance = float(self.buff_tool.ui.buffer_distance_entry.get_value().replace(',', '.')) self.buff_tool.ui.buffer_distance_entry.set_value(buffer_distance) except ValueError: self.app.inform.emit('[WARNING_NOTCL] %s' % _("Buffer distance value is missing or wrong format. Add it and retry.")) return # the cb index start from 0 but the join styles for the buffer start from 1 therefore the adjustment # I populated the combobox such that the index coincide with the join styles value (whcih is really an INT) join_style = self.buff_tool.ui.buffer_corner_cb.currentIndex() + 1 ret_val = self.draw_app.buffer(buffer_distance, join_style) self.deactivate() if ret_val == 'fail': return self.draw_app.app.inform.emit('[success] %s' % _("Done.")) def on_buffer_int(self): if not self.draw_app.selected: self.draw_app.app.inform.emit('[WARNING_NOTCL] %s %s' % (_("Cancelled."), _("No shape selected."))) return try: buffer_distance = float(self.buff_tool.ui.buffer_distance_entry.get_value()) except ValueError: # try to convert comma to decimal point. if it's still not working error message and return try: buffer_distance = float(self.buff_tool.ui.buffer_distance_entry.get_value().replace(',', '.')) self.buff_tool.ui.buffer_distance_entry.set_value(buffer_distance) except ValueError: self.app.inform.emit('[WARNING_NOTCL] %s' % _("Buffer distance value is missing or wrong format. Add it and retry.")) return # the cb index start from 0 but the join styles for the buffer start from 1 therefore the adjustment # I populated the combobox such that the index coincide with the join styles value (whcih is really an INT) join_style = self.buff_tool.ui.buffer_corner_cb.currentIndex() + 1 ret_val = self.draw_app.buffer_int(buffer_distance, join_style) self.deactivate() if ret_val == 'fail': return self.draw_app.app.inform.emit('[success] %s' % _("Done.")) def on_buffer_ext(self): if not self.draw_app.selected: self.draw_app.app.inform.emit('[WARNING_NOTCL] %s %s' % (_("Cancelled."), _("No shape selected."))) return try: buffer_distance = float(self.buff_tool.ui.buffer_distance_entry.get_value()) except ValueError: # try to convert comma to decimal point. if it's still not working error message and return try: buffer_distance = float(self.buff_tool.ui.buffer_distance_entry.get_value().replace(',', '.')) self.buff_tool.ui.buffer_distance_entry.set_value(buffer_distance) except ValueError: self.draw_app.app.inform.emit('[WARNING_NOTCL] %s' % _("Buffer distance value is missing or wrong format. Add it and retry.")) return # the cb index start from 0 but the join styles for the buffer start from 1 therefore the adjustment # I populated the combobox such that the index coincide with the join styles value (whcih is really an INT) join_style = self.buff_tool.ui.buffer_corner_cb.currentIndex() + 1 ret_val = self.draw_app.buffer_ext(buffer_distance, join_style) # self.app.ui.notebook.setTabText(2, _("Tools")) # self.draw_app.app.ui.splitter.setSizes([0, 1]) self.deactivate() if ret_val == 'fail': return self.draw_app.app.inform.emit('[success] %s' % _("Done.")) def activate(self): self.buff_tool.ui.buffer_button.clicked.disconnect() self.buff_tool.ui.buffer_int_button.clicked.disconnect() self.buff_tool.ui.buffer_ext_button.clicked.disconnect() self.buff_tool.ui.buffer_button.clicked.connect(self.on_buffer) self.buff_tool.ui.buffer_int_button.clicked.connect(self.on_buffer_int) self.buff_tool.ui.buffer_ext_button.clicked.connect(self.on_buffer_ext) def deactivate(self): self.buff_tool.ui.buffer_button.clicked.disconnect() self.buff_tool.ui.buffer_int_button.clicked.disconnect() self.buff_tool.ui.buffer_ext_button.clicked.disconnect() self.buff_tool.ui.buffer_button.clicked.connect(self.buff_tool.on_buffer) self.buff_tool.ui.buffer_int_button.clicked.connect(self.buff_tool.on_buffer_int) self.buff_tool.ui.buffer_ext_button.clicked.connect(self.buff_tool.on_buffer_ext) self.complete = True self.draw_app.select_tool("select") # self.buff_tool.hide_tool() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass class FCEraser(FCShapeTool): def __init__(self, draw_app): DrawTool.__init__(self, draw_app) self.name = 'eraser' self.draw_app = draw_app self.origin = None self.destination = None if len(self.draw_app.get_selected()) == 0: if self.draw_app.launched_from_shortcuts is True: self.draw_app.launched_from_shortcuts = False self.draw_app.app.inform.emit(_("Select a shape to act as deletion area ...")) else: self.draw_app.app.inform.emit(_("Click to pick-up the erase shape...")) self.geometry = [] self.storage = self.draw_app.storage # Switch notebook to Properties page self.draw_app.app.ui.notebook.setCurrentWidget(self.draw_app.app.ui.properties_tab) self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) def set_origin(self, origin): self.origin = origin def click(self, point): try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass self.draw_app.app.jump_signal.connect(lambda x: self.draw_app.update_utility_geometry(data=x)) if len(self.draw_app.get_selected()) == 0: for ____ in self.storage.get_objects(): try: __, closest_shape = self.storage.nearest(point) self.draw_app.selected.append(closest_shape) except StopIteration: if len(self.draw_app.selected) > 0: self.draw_app.app.inform.emit(_("Click to pick-up the erase shape...")) return "" if len(self.draw_app.get_selected()) == 0: return "Nothing to ersase." else: self.draw_app.app.inform.emit(_("Click to pick-up the erase shape...")) if self.origin is None: self.set_origin(point) self.draw_app.app.inform.emit(_("Click to erase ...")) return else: self.destination = point self.make() # self.draw_app.select_tool("select") return def make(self): eraser_sel_shapes = [] # create the eraser shape from selection for eraser_shape in self.utility_geometry(data=self.destination).geo: temp_shape = eraser_shape.buffer(0.0000001) temp_shape = Polygon(temp_shape.exterior) eraser_sel_shapes.append(temp_shape) eraser_sel_shapes = unary_union(eraser_sel_shapes) for obj_shape in self.storage.get_objects(): try: geometric_data = obj_shape.geo if eraser_sel_shapes.intersects(geometric_data): obj_shape.geo = geometric_data.difference(eraser_sel_shapes) except KeyError: pass self.draw_app.delete_utility_geometry() self.draw_app.plot_all() self.draw_app.app.inform.emit('[success] %s' % _("Done.")) try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass def utility_geometry(self, data=None): """ Temporary geometry on screen while using this tool. :param data: :return: """ geo_list = [] if self.origin is None: return None if len(self.draw_app.get_selected()) == 0: return None dx = data[0] - self.origin[0] dy = data[1] - self.origin[1] try: for geom in self.draw_app.get_selected(): geo_list.append(translate(geom.geo, xoff=dx, yoff=dy)) except AttributeError: self.draw_app.select_tool('select') self.draw_app.selected = [] return return DrawToolUtilityShape(geo_list) def clean_up(self): self.draw_app.selected = [] self.draw_app.plot_all() try: self.draw_app.app.jump_signal.disconnect() except (TypeError, AttributeError): pass class FCPaint(FCShapeTool): def __init__(self, draw_app): FCShapeTool.__init__(self, draw_app) self.name = 'paint' self.draw_app = draw_app self.app = draw_app.app self.draw_app.app.inform.emit(_("Create Paint geometry ...")) self.origin = (0, 0) self.draw_app.paint_tool.run() class FCTransform(FCShapeTool): def __init__(self, draw_app): FCShapeTool.__init__(self, draw_app) self.name = 'transformation' self.draw_app = draw_app self.app = draw_app.app self.draw_app.app.inform.emit(_("Shape transformations ...")) self.origin = (0, 0) self.draw_app.transform_tool.run() # ############################################### # ################ Main Application ############# # ############################################### class AppGeoEditor(QtCore.QObject): # will emit the name of the object that was just selected item_selected = QtCore.pyqtSignal(str) transform_complete = QtCore.pyqtSignal() build_ui_sig = QtCore.pyqtSignal() clear_tree_sig = QtCore.pyqtSignal() draw_shape_idx = -1 def __init__(self, app, disabled=False): # assert isinstance(app, FlatCAMApp.App), \ # "Expected the app to be a FlatCAMApp.App, got %s" % type(app) super(AppGeoEditor, self).__init__() self.app = app self.canvas = app.plotcanvas self.decimals = app.decimals self.units = self.app.app_units # when True the Editor can't do selection due of an ongoing process self.interdict_selection = False self.geo_edit_widget = QtWidgets.QWidget() # ## Box for custom widgets # This gets populated in offspring implementations. layout = QtWidgets.QVBoxLayout() self.geo_edit_widget.setLayout(layout) # add a frame and inside add a vertical box layout. Inside this vbox layout I add all the Drills widgets # this way I can hide/show the frame self.geo_frame = QtWidgets.QFrame() self.geo_frame.setContentsMargins(0, 0, 0, 0) layout.addWidget(self.geo_frame) self.tools_box = QtWidgets.QVBoxLayout() self.tools_box.setContentsMargins(0, 0, 0, 0) self.geo_frame.setLayout(self.tools_box) if disabled: self.geo_frame.setDisabled(True) # ## Page Title box (spacing between children) self.title_box = QtWidgets.QHBoxLayout() self.tools_box.addLayout(self.title_box) # ## Page Title icon pixmap = QtGui.QPixmap(self.app.resource_location + '/app32.png') self.icon = FCLabel() self.icon.setPixmap(pixmap) self.title_box.addWidget(self.icon, stretch=0) # ## Title label self.title_label = FCLabel("%s" % _('Geometry Editor')) self.title_label.setAlignment(QtCore.Qt.AlignmentFlag.AlignLeft | QtCore.Qt.AlignmentFlag.AlignVCenter) self.title_box.addWidget(self.title_label, stretch=1) # App Level label self.level = QtWidgets.QToolButton() self.level.setToolTip( _( "Beginner Mode - many parameters are hidden.\n" "Advanced Mode - full control.\n" "Permanent change is done in 'Preferences' menu." ) ) # self.level.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) self.level.setCheckable(True) self.title_box.addWidget(self.level) self.grid_d = GLay(v_spacing=5, h_spacing=3) self.tools_box.addLayout(self.grid_d) # Tool diameter tooldia_lbl = FCLabel('%s:' % _("Tool dia")) tooldia_lbl.setToolTip( _("Edited tool diameter.") ) self.tooldia_entry = FCDoubleSpinner() self.tooldia_entry.set_precision(self.decimals) self.tooldia_entry.setSingleStep(10 ** -self.decimals) self.tooldia_entry.set_range(-10000.0000, 10000.0000) self.grid_d.addWidget(tooldia_lbl, 0, 0) self.grid_d.addWidget(self.tooldia_entry, 0, 1) # Tree Widget Title tw_label = FCLabel('%s:' % _("Geometry Table")) tw_label.setToolTip( _("The list of geometry elements inside the edited object.") ) self.tools_box.addWidget(tw_label) # Tree Widget self.tw = FCTree(columns=3, header_hidden=False, protected_column=[0, 1], extended_sel=True) self.tw.setHeaderLabels(["ID", _("Type"), _("Name")]) self.tw.setIndentation(0) self.tw.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu) self.tw.header().setStretchLastSection(True) self.tw.header().setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.ResizeToContents) self.tools_box.addWidget(self.tw) self.geo_font = QtGui.QFont() self.geo_font.setBold(True) self.geo_parent = self.tw.invisibleRootItem() # ############################################################################################################# # ############################################ Advanced Editor ################################################ # ############################################################################################################# self.adv_frame = QtWidgets.QFrame() self.adv_frame.setContentsMargins(0, 0, 0, 0) self.tools_box.addWidget(self.adv_frame) grid0 = GLay(v_spacing=5, h_spacing=3) grid0.setContentsMargins(0, 0, 0, 0) self.adv_frame.setLayout(grid0) # Zoom Selection self.geo_zoom = FCCheckBox(_("Zoom on selection")) grid0.addWidget(self.geo_zoom, 0, 0, 1, 3) separator_line = QtWidgets.QFrame() separator_line.setFrameShape(QtWidgets.QFrame.Shape.HLine) separator_line.setFrameShadow(QtWidgets.QFrame.Shadow.Sunken) grid0.addWidget(separator_line, 2, 0, 1, 3) # Parameters Title param_title = FCLabel('%s:' % _("Parameters")) param_title.setToolTip( _("Geometry parameters.") ) grid0.addWidget(param_title, 4, 0, 1, 3) # Is Valid is_valid_lbl = FCLabel('%s:' % _("Is Valid")) self.is_valid_entry = FCLabel('None') grid0.addWidget(is_valid_lbl, 10, 0) grid0.addWidget(self.is_valid_entry, 10, 1, 1, 2) # Is Empty is_empty_lbl = FCLabel('%s:' % _("Is Empty")) self.is_empty_entry = FCLabel('None') grid0.addWidget(is_empty_lbl, 12, 0) grid0.addWidget(self.is_empty_entry, 12, 1, 1, 2) # Is Ring is_ring_lbl = FCLabel('%s:' % _("Is Ring")) self.is_ring_entry = FCLabel('None') grid0.addWidget(is_ring_lbl, 14, 0) grid0.addWidget(self.is_ring_entry, 14, 1, 1, 2) # Is CCW is_ccw_lbl = FCLabel('%s:' % _("Is CCW")) self.is_ccw_entry = FCLabel('None') self.change_orientation_btn = FCButton(_("Change")) self.change_orientation_btn.setIcon(QtGui.QIcon(self.app.resource_location + '/orientation32.png')) self.change_orientation_btn.setToolTip( _("Change the orientation of the geometric element.\n" "Works for LinearRing and Polygons.") ) grid0.addWidget(is_ccw_lbl, 16, 0) grid0.addWidget(self.is_ccw_entry, 16, 1) grid0.addWidget(self.change_orientation_btn, 16, 2) # Is Simple is_simple_lbl = FCLabel('%s:' % _("Is Simple")) self.is_simple_entry = FCLabel('None') grid0.addWidget(is_simple_lbl, 18, 0) grid0.addWidget(self.is_simple_entry, 18, 1, 1, 2) # Length len_lbl = FCLabel('%s:' % _("Length")) len_lbl.setToolTip( _("The length of the geometry element.") ) self.geo_len_entry = FCEntry(decimals=self.decimals) self.geo_len_entry.setReadOnly(True) grid0.addWidget(len_lbl, 20, 0) grid0.addWidget(self.geo_len_entry, 20, 1, 1, 2) # Coordinates coords_lbl = FCLabel('%s:' % _("Coordinates")) coords_lbl.setToolTip( _("The coordinates of the selected geometry element.") ) grid0.addWidget(coords_lbl, 22, 0, 1, 3) self.geo_coords_entry = FCTextEdit() self.geo_coords_entry.setPlaceholderText( _("The coordinates of the selected geometry element.") ) grid0.addWidget(self.geo_coords_entry, 24, 0, 1, 3) # Vertex Points Number vertex_lbl = FCLabel('%s:' % _("Vertex Points")) vertex_lbl.setToolTip( _("The number of vertex points in the selected geometry element.") ) self.geo_vertex_entry = FCEntry(decimals=self.decimals) self.geo_vertex_entry.setReadOnly(True) grid0.addWidget(vertex_lbl, 26, 0) grid0.addWidget(self.geo_vertex_entry, 26, 1, 1, 2) separator_line = QtWidgets.QFrame() separator_line.setFrameShape(QtWidgets.QFrame.Shape.HLine) separator_line.setFrameShadow(QtWidgets.QFrame.Shadow.Sunken) grid0.addWidget(separator_line, 28, 0, 1, 3) # Simplification Title simplif_lbl = FCLabel('%s:' % _("Simplification")) simplif_lbl.setToolTip( _("Simplify a geometry by reducing its vertex points number.") ) grid0.addWidget(simplif_lbl, 30, 0, 1, 3) # Simplification Tolerance simplification_tol_lbl = FCLabel('%s:' % _("Tolerance")) simplification_tol_lbl.setToolTip( _("All points in the simplified object will be\n" "within the tolerance distance of the original geometry.") ) self.geo_tol_entry = FCDoubleSpinner() self.geo_tol_entry.set_precision(self.decimals) self.geo_tol_entry.setSingleStep(10 ** -self.decimals) self.geo_tol_entry.set_range(0.0000, 10000.0000) grid0.addWidget(simplification_tol_lbl, 32, 0) grid0.addWidget(self.geo_tol_entry, 32, 1, 1, 2) # Simplification button self.simplification_btn = FCButton(_("Simplify")) self.simplification_btn.setIcon(QtGui.QIcon(self.app.resource_location + '/simplify32.png')) self.simplification_btn.setToolTip( _("Simplify a geometry element by reducing its vertex points number.") ) self.simplification_btn.setStyleSheet(""" QPushButton { font-weight: bold; } """) grid0.addWidget(self.simplification_btn, 34, 0, 1, 3) layout.addStretch() # Editor self.exit_editor_button = FCButton(_('Exit Editor')) self.exit_editor_button.setIcon(QtGui.QIcon(self.app.resource_location + '/power16.png')) self.exit_editor_button.setToolTip( _("Exit from Editor.") ) self.exit_editor_button.setStyleSheet(""" QPushButton { font-weight: bold; } """) layout.addWidget(self.exit_editor_button) # ## Toolbar events and properties self.tools = {} # # ## Data self.active_tool = None self.storage = AppGeoEditor.make_storage() self.utility = [] # VisPy visuals self.fcgeometry = None if self.app.use_3d_engine: self.shapes = self.app.plotcanvas.new_shape_collection(layers=1) self.tool_shape = self.app.plotcanvas.new_shape_collection(layers=1) else: from appGUI.PlotCanvasLegacy import ShapeCollectionLegacy self.shapes = ShapeCollectionLegacy(obj=self, app=self.app, name='shapes_geo_editor') self.tool_shape = ShapeCollectionLegacy(obj=self, app=self.app, name='tool_shapes_geo_editor') # Remove from scene self.shapes.enabled = False self.tool_shape.enabled = False # List of selected shapes. self.selected = [] self.flat_geo = [] self.move_timer = QtCore.QTimer() self.move_timer.setSingleShot(True) # this var will store the state of the toolbar before starting the editor self.toolbar_old_state = False self.key = None # Currently pressed key self.geo_key_modifiers = None self.x = None # Current mouse cursor pos self.y = None # if we edit a multigeo geometry store here the tool number self.multigeo_tool = None # Current snapped mouse pos self.snap_x = None self.snap_y = None self.pos = None # signal that there is an action active like polygon or path self.in_action = False self.units = None # this will flag if the Editor "tools" are launched from key shortcuts (True) or from menu toolbar (False) self.launched_from_shortcuts = False self.editor_options = { "global_gridx": 0.1, "global_gridy": 0.1, "global_snap_max": 0.05, "grid_snap": True, "corner_snap": False, "grid_gap_link": True } self.editor_options.update(self.app.options) for option in self.editor_options: if option in self.app.options: self.editor_options[option] = self.app.options[option] self.app.ui.grid_gap_x_entry.setText(str(self.editor_options["global_gridx"])) self.app.ui.grid_gap_y_entry.setText(str(self.editor_options["global_gridy"])) self.app.ui.snap_max_dist_entry.setText(str(self.editor_options["global_snap_max"])) self.app.ui.grid_gap_link_cb.setChecked(True) self.rtree_index = rtindex.Index() self.app.ui.grid_gap_x_entry.setValidator(QtGui.QDoubleValidator()) self.app.ui.grid_gap_y_entry.setValidator(QtGui.QDoubleValidator()) self.app.ui.snap_max_dist_entry.setValidator(QtGui.QDoubleValidator()) # if using Paint store here the tool diameter used self.paint_tooldia = None self.paint_tool = PaintOptionsTool(self.app, self) self.transform_tool = TransformEditorTool(self.app, self) # ############################################################################################################# # ####################### GEOMETRY Editor Signals ############################################################# # ############################################################################################################# self.build_ui_sig.connect(self.build_ui) self.level.toggled.connect(self.on_level_changed) self.app.ui.grid_gap_x_entry.textChanged.connect(self.on_gridx_val_changed) self.app.ui.grid_gap_y_entry.textChanged.connect(self.on_gridy_val_changed) self.app.ui.snap_max_dist_entry.textChanged.connect( lambda: self.entry2option("snap_max", self.app.ui.snap_max_dist_entry)) self.app.ui.grid_snap_btn.triggered.connect(lambda: self.on_grid_toggled()) self.app.ui.corner_snap_btn.setCheckable(True) self.app.ui.corner_snap_btn.triggered.connect(lambda: self.toolbar_tool_toggle("corner_snap")) self.app.pool_recreated.connect(self.pool_recreated) self.exit_editor_button.clicked.connect(lambda: self.app.editor2object()) # connect the toolbar signals self.connect_geo_toolbar_signals() # connect Geometry Editor Menu signals self.app.ui.geo_add_circle_menuitem.triggered.connect(lambda: self.select_tool('circle')) self.app.ui.geo_add_arc_menuitem.triggered.connect(lambda: self.select_tool('arc')) self.app.ui.geo_add_rectangle_menuitem.triggered.connect(lambda: self.select_tool('rectangle')) self.app.ui.geo_add_polygon_menuitem.triggered.connect(lambda: self.select_tool('polygon')) self.app.ui.geo_add_path_menuitem.triggered.connect(lambda: self.select_tool('path')) self.app.ui.geo_add_text_menuitem.triggered.connect(lambda: self.select_tool('text')) self.app.ui.geo_paint_menuitem.triggered.connect(self.on_paint_tool) self.app.ui.geo_buffer_menuitem.triggered.connect(self.on_buffer_tool) self.app.ui.geo_transform_menuitem.triggered.connect(self.transform_tool.run) self.app.ui.geo_delete_menuitem.triggered.connect(self.on_delete_btn) self.app.ui.geo_union_menuitem.triggered.connect(self.union) self.app.ui.geo_intersection_menuitem.triggered.connect(self.intersection) self.app.ui.geo_subtract_menuitem.triggered.connect(self.subtract) self.app.ui.geo_subtract_alt_menuitem.triggered.connect(self.subtract_2) self.app.ui.geo_cutpath_menuitem.triggered.connect(self.cutpath) self.app.ui.geo_copy_menuitem.triggered.connect(lambda: self.select_tool('copy')) self.app.ui.geo_union_btn.triggered.connect(self.union) self.app.ui.geo_intersection_btn.triggered.connect(self.intersection) self.app.ui.geo_subtract_btn.triggered.connect(self.subtract) self.app.ui.geo_alt_subtract_btn.triggered.connect(self.subtract_2) self.app.ui.geo_cutpath_btn.triggered.connect(self.cutpath) self.app.ui.geo_delete_btn.triggered.connect(self.on_delete_btn) self.app.ui.geo_move_menuitem.triggered.connect(self.on_move) self.app.ui.geo_cornersnap_menuitem.triggered.connect(self.on_corner_snap) self.transform_complete.connect(self.on_transform_complete) self.simplification_btn.clicked.connect(self.on_simplification_click) self.change_orientation_btn.clicked.connect(self.on_change_orientation) self.tw.customContextMenuRequested.connect(self.on_menu_request) self.clear_tree_sig.connect(self.on_clear_tree) # Event signals disconnect id holders self.mp = None self.mm = None self.mr = None self.app.log.debug("Initialization of the Geometry Editor is finished ...") def make_callback(self, thetool): def f(): self.on_tool_select(thetool) return f def connect_geo_toolbar_signals(self): self.tools.update({ "select": {"button": self.app.ui.geo_select_btn, "constructor": FCSelect}, "arc": {"button": self.app.ui.geo_add_arc_btn, "constructor": FCArc}, "circle": {"button": self.app.ui.geo_add_circle_btn, "constructor": FCCircle}, "path": {"button": self.app.ui.geo_add_path_btn, "constructor": FCPath}, "rectangle": {"button": self.app.ui.geo_add_rectangle_btn, "constructor": FCRectangle}, "polygon": {"button": self.app.ui.geo_add_polygon_btn, "constructor": FCPolygon}, "text": {"button": self.app.ui.geo_add_text_btn, "constructor": FCText}, "buffer": {"button": self.app.ui.geo_add_buffer_btn, "constructor": FCBuffer}, "paint": {"button": self.app.ui.geo_add_paint_btn, "constructor": FCPaint}, "eraser": {"button": self.app.ui.geo_eraser_btn, "constructor": FCEraser}, "move": {"button": self.app.ui.geo_move_btn, "constructor": FCMove}, "transform": {"button": self.app.ui.geo_transform_btn, "constructor": FCTransform}, "copy": {"button": self.app.ui.geo_copy_btn, "constructor": FCCopy}, "explode": {"button": self.app.ui.geo_explode_btn, "constructor": FCExplode} }) for tool in self.tools: self.tools[tool]["button"].triggered.connect(self.make_callback(tool)) # Events self.tools[tool]["button"].setCheckable(True) # Checkable def pool_recreated(self, pool): self.shapes.pool = pool self.tool_shape.pool = pool def on_transform_complete(self): self.delete_selected() self.plot_all() def entry2option(self, opt, entry): """ :param opt: A option from the self.editor_options dictionary :param entry: A GUI element which text value is used :return: """ try: text_value = entry.text() if ',' in text_value: text_value = text_value.replace(',', '.') self.editor_options[opt] = float(text_value) except Exception as e: entry.set_value(self.app.options[opt]) self.app.log.error("AppGeoEditor.__init__().entry2option() --> %s" % str(e)) return def grid_changed(self, goption, gentry): """ :param goption: String. Can be either 'global_gridx' or 'global_gridy' :param gentry: A GUI element which text value is read and used :return: """ if goption not in ['global_gridx', 'global_gridy']: return self.entry2option(opt=goption, entry=gentry) # if the grid link is checked copy the value in the GridX field to GridY try: text_value = gentry.text() if ',' in text_value: text_value = text_value.replace(',', '.') val = float(text_value) except ValueError: return if self.app.ui.grid_gap_link_cb.isChecked(): self.app.ui.grid_gap_y_entry.set_value(val, decimals=self.decimals) def on_gridx_val_changed(self): self.grid_changed("global_gridx", self.app.ui.grid_gap_x_entry) # try: # self.app.options["global_gridx"] = float(self.app.ui.grid_gap_x_entry.get_value()) # except ValueError: # return def on_gridy_val_changed(self): self.entry2option("global_gridy", self.app.ui.grid_gap_y_entry) def set_editor_ui(self): # updated units self.units = self.app.app_units.upper() self.decimals = self.app.decimals # Remove anything else in the GUI Selected Tab self.app.ui.properties_scroll_area.takeWidget() # Put ourselves in the appGUI Properties Tab self.app.ui.properties_scroll_area.setWidget(self.geo_edit_widget) # Switch notebook to Properties page self.app.ui.notebook.setCurrentWidget(self.app.ui.properties_tab) self.geo_coords_entry.setText('') self.is_ccw_entry.set_value('None') self.is_ring_entry.set_value('None') self.is_simple_entry.set_value('None') self.is_empty_entry.set_value('None') self.is_valid_entry.set_value('None') self.geo_vertex_entry.set_value(0.0) self.geo_tol_entry.set_value(0.01 if self.units == 'MM' else 0.0004) self.geo_zoom.set_value(False) # Show/Hide Advanced Options app_mode = self.app.options["global_app_level"] self.change_level(app_mode) def build_ui(self): """ Build the appGUI in the Properties Tab for this editor :return: """ iterator = QtWidgets.QTreeWidgetItemIterator(self.geo_parent) to_delete = [] while iterator.value(): item = iterator.value() to_delete.append(item) iterator += 1 for it in to_delete: self.geo_parent.removeChild(it) for elem in self.storage.get_objects(): geo_type = type(elem.geo) if geo_type is MultiLineString: el_type = _('Multi-Line') elif geo_type is MultiPolygon: el_type = _('Multi-Polygon') else: el_type = elem.data['type'] self.tw.addParentEditable( self.geo_parent, [ str(id(elem)), '%s' % el_type, _("Geo Elem") ], font=self.geo_font, font_items=2, # color=QtGui.QColor("#FF0000"), editable=True ) self.tw.resize_sig.emit() def on_geo_elem_selected(self): pass def update_ui(self): self.selected = [] last_obj_shape = None last_id = None selected_tree_items = self.tw.selectedItems() for sel in selected_tree_items: for obj_shape in self.storage.get_objects(): try: if id(obj_shape) == int(sel.text(0)): self.selected.append(obj_shape) last_obj_shape = obj_shape last_id = sel.text(0) except ValueError: pass if last_obj_shape: last_sel_geo = last_obj_shape.geo self.is_valid_entry.set_value(last_sel_geo.is_valid) self.is_empty_entry.set_value(last_sel_geo.is_empty) if last_sel_geo.geom_type == 'MultiLineString': length = last_sel_geo.length self.is_simple_entry.set_value(last_sel_geo.is_simple) self.is_ring_entry.set_value(last_sel_geo.is_ring) self.is_ccw_entry.set_value('None') coords = '' vertex_nr = 0 for idx, line in enumerate(last_sel_geo.geoms): line_coords = list(line.coords) vertex_nr += len(line_coords) coords += 'Line %s\n' % str(idx) coords += str(line_coords) + '\n' elif last_sel_geo.geom_type == 'MultiPolygon': length = 0.0 self.is_simple_entry.set_value('None') self.is_ring_entry.set_value('None') self.is_ccw_entry.set_value('None') coords = '' vertex_nr = 0 for idx, poly in enumerate(last_sel_geo.geoms): poly_coords = list(poly.exterior.coords) + [list(i.coords) for i in poly.interiors] vertex_nr += len(poly_coords) coords += 'Polygon %s\n' % str(idx) coords += str(poly_coords) + '\n' elif last_sel_geo.geom_type in ['LinearRing', 'LineString']: length = last_sel_geo.length coords = list(last_sel_geo.coords) vertex_nr = len(coords) self.is_simple_entry.set_value(last_sel_geo.is_simple) self.is_ring_entry.set_value(last_sel_geo.is_ring) if last_sel_geo.geom_type == 'LinearRing': self.is_ccw_entry.set_value(last_sel_geo.is_ccw) elif last_sel_geo.geom_type == 'Polygon': length = last_sel_geo.exterior.length coords = list(last_sel_geo.exterior.coords) vertex_nr = len(coords) self.is_simple_entry.set_value(last_sel_geo.is_simple) self.is_ring_entry.set_value(last_sel_geo.is_ring) if last_sel_geo.exterior.geom_type == 'LinearRing': self.is_ccw_entry.set_value(last_sel_geo.exterior.is_ccw) else: length = 0.0 coords = 'None' vertex_nr = 0 if self.geo_zoom.get_value(): xmin, ymin, xmax, ymax = last_sel_geo.bounds if xmin == xmax and ymin != ymax: xmin = ymin xmax = ymax elif xmin != xmax and ymin == ymax: ymin = xmin ymax = xmax if self.app.use_3d_engine: rect = Rect(xmin, ymin, xmax, ymax) rect.left, rect.right = xmin, xmax rect.bottom, rect.top = ymin, ymax # Lock updates in other threads assert isinstance(self.shapes, ShapeCollection) self.shapes.lock_updates() # adjust the view camera to be slightly bigger than the bounds so the shape collection can be # seen clearly otherwise the shape collection boundary will have no border dx = rect.right - rect.left dy = rect.top - rect.bottom x_factor = dx * 0.02 y_factor = dy * 0.02 rect.left -= x_factor rect.bottom -= y_factor rect.right += x_factor rect.top += y_factor self.app.plotcanvas.view.camera.rect = rect self.shapes.unlock_updates() else: width = xmax - xmin height = ymax - ymin xmin -= 0.05 * width xmax += 0.05 * width ymin -= 0.05 * height ymax += 0.05 * height self.app.plotcanvas.adjust_axes(xmin, ymin, xmax, ymax) self.geo_len_entry.set_value(length, decimals=self.decimals) self.geo_coords_entry.setText(str(coords)) self.geo_vertex_entry.set_value(vertex_nr) self.app.inform.emit('%s: %s' % (_("Last selected shape ID"), str(last_id))) def on_tree_geo_click(self): try: self.update_ui() self.plot_all() except Exception as e: self.app.log.error("APpGeoEditor.on_tree_selection_change() -> %s" % str(e)) def change_level(self, level): """ :param level: application level: either 'b' or 'a' :type level: str :return: """ if level == 'a': self.level.setChecked(True) else: self.level.setChecked(False) self.on_level_changed(self.level.isChecked()) def on_level_changed(self, checked): if not checked: self.level.setText('%s' % _('Beginner')) self.level.setStyleSheet(""" QToolButton { color: green; } """) self.adv_frame.hide() # Context Menu section # self.tw.removeContextMenu() else: self.level.setText('%s' % _('Advanced')) self.level.setStyleSheet(""" QToolButton { color: red; } """) self.adv_frame.show() # Context Menu section # self.tw.setupContextMenu() def on_simplification_click(self): self.app.log.debug("AppGeoEditor.on_simplification_click()") selected_shapes = [] selected_shapes_geos = [] tol = self.geo_tol_entry.get_value() selected_tree_items = self.tw.selectedItems() def task_job(): with self.app.proc_container.new('%s...' % _("Simplify")): self.interdict_selection = True for sel in selected_tree_items: for obj_shape in self.storage.get_objects(): try: if id(obj_shape) == int(sel.text(0)): selected_shapes.append(obj_shape) selected_shapes_geos.append(obj_shape.geo.simplify(tolerance=tol)) except ValueError: pass for shape in selected_shapes: self.delete_shape(shape=shape) for geo in selected_shapes_geos: self.add_shape(DrawToolShape(geo), build_ui=False) self.plot_all() self.interdict_selection = False self.build_ui_sig.emit() self.app.worker_task.emit({'fcn': task_job, 'params': []}) def on_change_orientation(self): self.app.log.debug("AppGeoEditor.on_change_orientation()") selected_tree_items = self.tw.selectedItems() processed_shapes = [] new_shapes = [] def task_job(): with self.app.proc_container.new('%s...' % _("Working")): for sel in selected_tree_items: for obj_shape in self.storage.get_objects(): try: if id(obj_shape) == int(sel.text(0)): old_geo = obj_shape.geo if old_geo.geom_type == 'LineaRing': processed_shapes.append(obj_shape) new_shapes.append(LinearRing(list(old_geo.coords)[::-1])) elif old_geo.geom_type == 'LineString': processed_shapes.append(obj_shape) new_shapes.append(LineString(list(old_geo.coords)[::-1])) elif old_geo.geom_type == 'Polygon': processed_shapes.append(obj_shape) if old_geo.exterior.is_ccw is True: new_shapes.append(deepcopy(orient(old_geo, -1))) else: new_shapes.append(deepcopy(orient(old_geo, 1))) except ValueError: pass for shape in processed_shapes: self.delete_shape(shape=shape) for geo in new_shapes: self.add_shape(DrawToolShape(geo), build_ui=False) self.build_ui_sig.emit() self.app.worker_task.emit({'fcn': task_job, 'params': []}) def on_menu_request(self, pos): menu = QtWidgets.QMenu() delete_action = menu.addAction(QtGui.QIcon(self.app.resource_location + '/delete32.png'), _("Delete")) delete_action.triggered.connect(self.delete_selected) menu.addSeparator() orientation_change = menu.addAction(QtGui.QIcon(self.app.resource_location + '/orientation32.png'), _("Change")) orientation_change.triggered.connect(self.on_change_orientation) if not self.tw.selectedItems(): delete_action.setDisabled(True) orientation_change.setDisabled(True) menu.exec(self.tw.viewport().mapToGlobal(pos)) def activate(self): # adjust the status of the menu entries related to the editor self.app.ui.menueditedit.setDisabled(True) self.app.ui.menueditok.setDisabled(False) # adjust the visibility of some of the canvas context menu self.app.ui.popmenu_edit.setVisible(False) self.app.ui.popmenu_save.setVisible(True) self.connect_canvas_event_handlers() # initialize working objects self.storage = AppGeoEditor.make_storage() self.utility = [] self.selected = [] self.shapes.enabled = True self.tool_shape.enabled = True self.app.app_cursor.enabled = True self.app.ui.corner_snap_btn.setVisible(True) self.app.ui.snap_magnet.setVisible(True) self.app.ui.geo_editor_menu.setDisabled(False) self.app.ui.geo_editor_menu.menuAction().setVisible(True) self.app.ui.editor_exit_btn_ret_action.setVisible(True) self.app.ui.editor_start_btn.setVisible(False) self.app.ui.g_editor_cmenu.setEnabled(True) self.app.ui.geo_edit_toolbar.setDisabled(False) self.app.ui.geo_edit_toolbar.setVisible(True) self.app.ui.status_toolbar.setDisabled(False) self.app.ui.pop_menucolor.menuAction().setVisible(False) self.app.ui.popmenu_numeric_move.setVisible(False) self.app.ui.popmenu_move2origin.setVisible(False) self.app.ui.popmenu_disable.setVisible(False) self.app.ui.cmenu_newmenu.menuAction().setVisible(False) self.app.ui.popmenu_properties.setVisible(False) self.app.ui.g_editor_cmenu.menuAction().setVisible(True) # prevent the user to change anything in the Properties Tab while the Geo Editor is active # sel_tab_widget_list = self.app.ui.properties_tab.findChildren(QtWidgets.QWidget) # for w in sel_tab_widget_list: # w.setEnabled(False) self.item_selected.connect(self.on_geo_elem_selected) # ## appGUI Events self.tw.itemPressed.connect(self.on_tree_geo_click) # self.tw.keyPressed.connect(self.app.ui.keyPressEvent) # self.tw.customContextMenuRequested.connect(self.on_menu_request) self.geo_frame.show() self.app.log.debug("Finished activating the Geometry Editor...") def deactivate(self): try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass # adjust the status of the menu entries related to the editor self.app.ui.menueditedit.setDisabled(False) self.app.ui.menueditok.setDisabled(True) # adjust the visibility of some of the canvas context menu self.app.ui.popmenu_edit.setVisible(True) self.app.ui.popmenu_save.setVisible(False) self.disconnect_canvas_event_handlers() self.clear() self.app.ui.geo_edit_toolbar.setDisabled(True) self.app.ui.corner_snap_btn.setVisible(False) self.app.ui.snap_magnet.setVisible(False) # set the Editor Toolbar visibility to what was before entering in the Editor self.app.ui.geo_edit_toolbar.setVisible(False) if self.toolbar_old_state is False \ else self.app.ui.geo_edit_toolbar.setVisible(True) # Disable visuals self.shapes.enabled = False self.tool_shape.enabled = False # disable text cursor (for FCPath) if self.app.use_3d_engine: self.app.plotcanvas.text_cursor.parent = None self.app.plotcanvas.view.camera.zoom_callback = lambda *args: None self.app.ui.geo_editor_menu.setDisabled(True) self.app.ui.geo_editor_menu.menuAction().setVisible(False) self.app.ui.editor_exit_btn_ret_action.setVisible(False) self.app.ui.editor_start_btn.setVisible(True) self.app.ui.g_editor_cmenu.setEnabled(False) self.app.ui.e_editor_cmenu.setEnabled(False) self.app.ui.pop_menucolor.menuAction().setVisible(True) self.app.ui.popmenu_numeric_move.setVisible(True) self.app.ui.popmenu_move2origin.setVisible(True) self.app.ui.popmenu_disable.setVisible(True) self.app.ui.cmenu_newmenu.menuAction().setVisible(True) self.app.ui.popmenu_properties.setVisible(True) self.app.ui.grb_editor_cmenu.menuAction().setVisible(False) self.app.ui.e_editor_cmenu.menuAction().setVisible(False) self.app.ui.g_editor_cmenu.menuAction().setVisible(False) try: self.item_selected.disconnect() except (AttributeError, TypeError): pass try: # ## appGUI Events self.tw.itemPressed.disconnect(self.on_tree_geo_click) # self.tw.keyPressed.connect(self.app.ui.keyPressEvent) # self.tw.customContextMenuRequested.connect(self.on_menu_request) except (AttributeError, TypeError): pass # try: # # re-enable all the widgets in the Selected Tab that were disabled after entering in Edit Geometry Mode # sel_tab_widget_list = self.app.ui.properties_tab.findChildren(QtWidgets.QWidget) # for w in sel_tab_widget_list: # w.setEnabled(True) # except Exception as e: # self.app.log.error("AppGeoEditor.deactivate() --> %s" % str(e)) # Show original geometry try: if self.fcgeometry: self.fcgeometry.visible = True # clear the Tree self.clear_tree_sig.emit() except Exception as err: self.app.log.error("AppGeoEditor.deactivate() --> %s" % str(err)) # hide the UI self.geo_frame.hide() self.app.log.debug("Finished deactivating the Geometry Editor...") def connect_canvas_event_handlers(self): # Canvas events # first connect to new, then disconnect the old handlers # don't ask why but if there is nothing connected I've seen issues self.mp = self.canvas.graph_event_connect('mouse_press', self.on_canvas_click) self.mm = self.canvas.graph_event_connect('mouse_move', self.on_canvas_move) self.mr = self.canvas.graph_event_connect('mouse_release', self.on_canvas_click_release) if self.app.use_3d_engine: # make sure that the shortcuts key and mouse events will no longer be linked to the methods from FlatCAMApp # but those from AppGeoEditor 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) self.app.plotcanvas.graph_event_disconnect('mouse_double_click', self.app.on_mouse_double_click_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.app.plotcanvas.graph_event_disconnect(self.app.mdc) # self.app.collection.view.clicked.disconnect() self.app.ui.popmenu_copy.triggered.disconnect() self.app.ui.popmenu_delete.triggered.disconnect() self.app.ui.popmenu_move.triggered.disconnect() self.app.ui.popmenu_copy.triggered.connect(lambda: self.select_tool('copy')) self.app.ui.popmenu_delete.triggered.connect(self.on_delete_btn) self.app.ui.popmenu_move.triggered.connect(lambda: self.select_tool('move')) # Geometry Editor self.app.ui.draw_line.triggered.connect(self.draw_tool_path) self.app.ui.draw_rect.triggered.connect(self.draw_tool_rectangle) self.app.ui.draw_circle.triggered.connect(lambda: self.select_tool('circle')) self.app.ui.draw_poly.triggered.connect(lambda: self.select_tool('polygon')) self.app.ui.draw_arc.triggered.connect(lambda: self.select_tool('arc')) self.app.ui.draw_text.triggered.connect(lambda: self.select_tool('text')) self.app.ui.draw_buffer.triggered.connect(lambda: self.select_tool('buffer')) self.app.ui.draw_paint.triggered.connect(lambda: self.select_tool('paint')) self.app.ui.draw_eraser.triggered.connect(lambda: self.select_tool('eraser')) self.app.ui.draw_union.triggered.connect(self.union) self.app.ui.draw_intersect.triggered.connect(self.intersection) self.app.ui.draw_substract.triggered.connect(self.subtract) self.app.ui.draw_substract_alt.triggered.connect(self.subtract_2) self.app.ui.draw_cut.triggered.connect(self.cutpath) self.app.ui.draw_transform.triggered.connect(lambda: self.select_tool('transform')) self.app.ui.draw_move.triggered.connect(self.on_move) def disconnect_canvas_event_handlers(self): # we restore the key and mouse control to FlatCAMApp method # first connect to new, then disconnect the old handlers # don't ask why but if there is nothing connected I've seen issues self.app.mp = self.app.plotcanvas.graph_event_connect('mouse_press', self.app.on_mouse_click_over_plot) self.app.mm = self.app.plotcanvas.graph_event_connect('mouse_move', self.app.on_mouse_move_over_plot) self.app.mr = self.app.plotcanvas.graph_event_connect('mouse_release', self.app.on_mouse_click_release_over_plot) self.app.mdc = self.app.plotcanvas.graph_event_connect('mouse_double_click', self.app.on_mouse_double_click_over_plot) # self.app.collection.view.clicked.connect(self.app.collection.on_mouse_down) if self.app.use_3d_engine: self.canvas.graph_event_disconnect('mouse_press', self.on_canvas_click) self.canvas.graph_event_disconnect('mouse_move', self.on_canvas_move) self.canvas.graph_event_disconnect('mouse_release', self.on_canvas_click_release) else: self.canvas.graph_event_disconnect(self.mp) self.canvas.graph_event_disconnect(self.mm) self.canvas.graph_event_disconnect(self.mr) try: self.app.ui.popmenu_copy.triggered.disconnect(lambda: self.select_tool('copy')) except (TypeError, AttributeError): pass try: self.app.ui.popmenu_delete.triggered.disconnect(self.on_delete_btn) except (TypeError, AttributeError): pass try: self.app.ui.popmenu_move.triggered.disconnect(lambda: self.select_tool('move')) except (TypeError, AttributeError): pass self.app.ui.popmenu_copy.triggered.connect(self.app.on_copy_command) self.app.ui.popmenu_delete.triggered.connect(self.app.on_delete) self.app.ui.popmenu_move.triggered.connect(self.app.obj_move) # Geometry Editor try: self.app.ui.draw_line.triggered.disconnect(self.draw_tool_path) except (TypeError, AttributeError): pass try: self.app.ui.draw_rect.triggered.disconnect(self.draw_tool_rectangle) except (TypeError, AttributeError): pass try: self.app.ui.draw_cut.triggered.disconnect(self.cutpath) except (TypeError, AttributeError): pass try: self.app.ui.draw_move.triggered.disconnect(self.on_move) except (TypeError, AttributeError): pass try: self.app.ui.draw_circle.triggered.disconnect() except (TypeError, AttributeError): pass try: self.app.ui.draw_poly.triggered.disconnect() except (TypeError, AttributeError): pass try: self.app.ui.draw_arc.triggered.disconnect() except (TypeError, AttributeError): pass try: self.app.ui.draw_text.triggered.disconnect() except (TypeError, AttributeError): pass try: self.app.ui.draw_buffer.triggered.disconnect() except (TypeError, AttributeError): pass try: self.app.ui.draw_paint.triggered.disconnect() except (TypeError, AttributeError): pass try: self.app.ui.draw_eraser.triggered.disconnect() except (TypeError, AttributeError): pass try: self.app.ui.draw_union.triggered.disconnect(self.union) except (TypeError, AttributeError): pass try: self.app.ui.draw_intersect.triggered.disconnect(self.intersection) except (TypeError, AttributeError): pass try: self.app.ui.draw_substract.triggered.disconnect(self.subtract) except (TypeError, AttributeError): pass try: self.app.ui.draw_substract_alt.triggered.disconnect(self.subtract_2) except (TypeError, AttributeError): pass try: self.app.ui.draw_transform.triggered.disconnect() except (TypeError, AttributeError): pass try: self.app.jump_signal.disconnect() except (TypeError, AttributeError): pass def on_clear_tree(self): self.tw.clearSelection() self.tw.clear() self.geo_parent = self.tw.invisibleRootItem() def add_shape(self, shape, build_ui=True): """ Adds a shape to the shape storage. :param shape: Shape to be added. :type shape: DrawToolShape, list :param build_ui: If to trigger a build of the UI :type build_ui: bool :return: None """ if shape is None: return # List of DrawToolShape? # if isinstance(shape, list): # for subshape in shape: # self.add_shape(subshape) # return try: w_geo = shape.geoms if isinstance(shape, (MultiPolygon, MultiLineString)) else shape for subshape in w_geo: self.add_shape(subshape) return except TypeError: pass if not isinstance(shape, DrawToolShape): shape = DrawToolShape(shape) # assert isinstance(shape, DrawToolShape), "Expected a DrawToolShape, got %s" % type(shape) assert shape.geo is not None, "Shape object has empty geometry (None)" assert (isinstance(shape.geo, list) and len(shape.geo) > 0) or not isinstance(shape.geo, list), \ "Shape objects has empty geometry ([])" if isinstance(shape, DrawToolUtilityShape): self.utility.append(shape) else: geometry = shape.geo if geometry and geometry.is_valid and not geometry.is_empty and geometry.geom_type != 'Point': try: self.storage.insert(shape) except Exception as err: self.app.inform_shell.emit('%s\n%s' % (_("Error on inserting shapes into storage."), str(err))) if build_ui is True: self.build_ui_sig.emit() # Build UI def delete_utility_geometry(self): """ Will delete the shapes in the utility shapes storage. :return: None """ # for_deletion = [shape for shape in self.shape_buffer if shape.utility] # for_deletion = [shape for shape in self.storage.get_objects() if shape.utility] for_deletion = [shape for shape in self.utility] for shape in for_deletion: self.delete_shape(shape) self.tool_shape.clear(update=True) self.tool_shape.redraw() def toolbar_tool_toggle(self, key): """ It is used as a slot by the Snap buttons. :param key: Key in the self.editor_options dictionary that is to be updated :return: Boolean. Status of the checkbox that toggled the Editor Tool """ cb_widget = self.sender() assert isinstance(cb_widget, QtGui.QAction), "Expected a QAction got %s" % type(cb_widget) self.editor_options[key] = cb_widget.isChecked() return 1 if self.editor_options[key] is True else 0 def clear(self): """ Will clear the storage for the Editor shapes, the selected shapes storage and plot_all. Clean up method. :return: None """ self.active_tool = None # self.shape_buffer = [] self.selected = [] self.shapes.clear(update=True) self.tool_shape.clear(update=True) # self.storage = AppGeoEditor.make_storage() self.plot_all() def on_buffer_tool(self): buff_tool = BufferSelectionTool(self.app, self) buff_tool.run() def on_paint_tool(self): paint_tool = PaintOptionsTool(self.app, self) paint_tool.run() def on_tool_select(self, tool): """ Behavior of the toolbar. Tool initialization. :rtype : None """ self.app.log.debug("on_tool_select('%s')" % tool) # This is to make the group behave as radio group if tool in self.tools: if self.tools[tool]["button"].isChecked(): self.app.log.debug("%s is checked." % tool) for t in self.tools: if t != tool: self.tools[t]["button"].setChecked(False) self.active_tool = self.tools[tool]["constructor"](self) else: self.app.log.debug("%s is NOT checked." % tool) for t in self.tools: self.tools[t]["button"].setChecked(False) self.select_tool('select') self.active_tool = FCSelect(self) def draw_tool_path(self): self.select_tool('path') return def draw_tool_rectangle(self): self.select_tool('rectangle') return def on_grid_toggled(self): self.toolbar_tool_toggle("grid_snap") # make sure that the cursor shape is enabled/disabled, too if self.editor_options['grid_snap'] is True: self.app.options['global_grid_snap'] = True self.app.inform[str, bool].emit(_("Grid Snap enabled."), False) self.app.app_cursor.enabled = True else: self.app.options['global_grid_snap'] = False self.app.inform[str, bool].emit(_("Grid Snap disabled."), False) self.app.app_cursor.enabled = False def on_canvas_click(self, event): """ event.x and .y have canvas coordinates event.xdaya and .ydata have plot coordinates :param event: Event object dispatched by Matplotlib :return: None """ if self.app.use_3d_engine: event_pos = event.pos else: event_pos = (event.xdata, event.ydata) self.pos = self.canvas.translate_coords(event_pos) if self.app.grid_status(): self.pos = self.app.geo_editor.snap(self.pos[0], self.pos[1]) else: self.pos = (self.pos[0], self.pos[1]) if event.button == 1: self.app.ui.rel_position_label.setText("Dx: %.4f   Dy: " "%.4f    " % (0, 0)) modifiers = QtWidgets.QApplication.keyboardModifiers() # If the SHIFT key is pressed when LMB is clicked then the coordinates are copied to clipboard if modifiers == QtCore.Qt.KeyboardModifier.ShiftModifier: self.app.clipboard.setText( self.app.options["global_point_clipboard_format"] % (self.decimals, self.pos[0], self.decimals, self.pos[1]) ) return # Selection with left mouse button if self.active_tool is not None: # Dispatch event to active_tool self.active_tool.click(self.snap(self.pos[0], self.pos[1])) # If it is a shape generating tool if isinstance(self.active_tool, FCShapeTool) and self.active_tool.complete: self.on_shape_complete() if isinstance(self.active_tool, (FCText, FCMove)): self.select_tool("select") else: self.select_tool(self.active_tool.name) # if isinstance(self.active_tool, FCSelect): # # self.app.log.debug("plot_allting after click.") # self.plot_all() else: self.app.log.debug("No active tool to respond to click!") def on_canvas_click_release(self, event): if self.app.use_3d_engine: event_pos = event.pos # event_is_dragging = event.is_dragging right_button = 2 else: event_pos = (event.xdata, event.ydata) # event_is_dragging = self.app.plotcanvas.is_dragging right_button = 3 pos_canvas = self.canvas.translate_coords(event_pos) if self.app.grid_status(): pos = self.snap(pos_canvas[0], pos_canvas[1]) else: pos = (pos_canvas[0], pos_canvas[1]) # if the released mouse button was RMB then test if it was a panning motion or not, if not it was a context # canvas menu try: # if the released mouse button was LMB then test if we had a right-to-left selection or a left-to-right # selection and then select a type of selection ("enclosing" or "touching") if event.button == 1: # left click if self.app.selection_type is not None: self.draw_selection_area_handler(self.pos, pos, self.app.selection_type) self.app.selection_type = None elif isinstance(self.active_tool, FCSelect): # Dispatch event to active_tool # msg = self.active_tool.click(self.snap(event.xdata, event.ydata)) self.active_tool.click_release((self.pos[0], self.pos[1])) # self.app.inform.emit(msg) self.plot_all() elif event.button == right_button: # right click if self.app.ui.popMenu.mouse_is_panning is False: if self.in_action is False: try: QtGui.QGuiApplication.restoreOverrideCursor() except Exception: pass if self.active_tool.complete is False and not isinstance(self.active_tool, FCSelect): self.active_tool.complete = True self.in_action = False self.delete_utility_geometry() self.active_tool.clean_up() self.app.inform.emit('[success] %s' % _("Done.")) self.select_tool('select') else: self.app.cursor = QtGui.QCursor() self.app.populate_cmenu_grids() self.app.ui.popMenu.popup(self.app.cursor.pos()) else: # if right click on canvas and the active tool need to be finished (like Path or Polygon) # right mouse click will finish the action if isinstance(self.active_tool, FCShapeTool): self.active_tool.click(self.snap(self.x, self.y)) self.active_tool.make() if self.active_tool.complete: self.on_shape_complete() self.app.inform.emit('[success] %s' % _("Done.")) self.select_tool(self.active_tool.name) except Exception as e: self.app.log.error("FLatCAMGeoEditor.on_canvas_click_release() --> Error: %s" % str(e)) return def on_canvas_move(self, event): """ Called on 'mouse_move' event event.pos have canvas screen coordinates :param event: Event object dispatched by VisPy SceneCavas :return: None """ if self.app.use_3d_engine: event_pos = event.pos event_is_dragging = event.is_dragging right_button = 2 else: event_pos = (event.xdata, event.ydata) event_is_dragging = self.app.plotcanvas.is_dragging right_button = 3 pos = self.canvas.translate_coords(event_pos) event.xdata, event.ydata = pos[0], pos[1] self.x = event.xdata self.y = event.ydata self.app.ui.popMenu.mouse_is_panning = False # if the RMB is clicked and mouse is moving over plot then 'panning_action' is True if event.button == right_button: if event_is_dragging: self.app.ui.popMenu.mouse_is_panning = True # return else: self.app.ui.popMenu.mouse_is_panning = False if self.active_tool is None: return try: x = float(event.xdata) y = float(event.ydata) except TypeError: return # ### Snap coordinates ### if self.app.grid_status(): x, y = self.snap(x, y) # Update cursor self.app.app_cursor.set_data(np.asarray([(x, y)]), symbol='++', edge_color=self.app.plotcanvas.cursor_color, edge_width=self.app.options["global_cursor_width"], size=self.app.options["global_cursor_size"]) self.snap_x = x self.snap_y = y self.app.mouse = [x, y] if self.pos is None: self.pos = (0, 0) self.app.dx = x - self.pos[0] self.app.dy = y - self.pos[1] # # update the position label in the infobar since the APP mouse event handlers are disconnected # self.app.ui.position_label.setText(" X: %.4f   " # "Y: %.4f " % (x, y)) # # # # # update the reference position label in the infobar since the APP mouse event handlers are disconnected # self.app.ui.rel_position_label.setText("Dx: %.4f   Dy: " # "%.4f    " % (self.app.dx, self.app.dy)) self.app.ui.update_location_labels(self.app.dx, self.app.dy, x, y) # units = self.app.app_units.lower() # self.app.plotcanvas.text_hud.text = \ # 'Dx:\t{:<.4f} [{:s}]\nDy:\t{:<.4f} [{:s}]\n\nX: \t{:<.4f} [{:s}]\nY: \t{:<.4f} [{:s}]'.format( # self.app.dx, units, self.app.dy, units, x, units, y, units) self.app.plotcanvas.on_update_text_hud(self.app.dx, self.app.dy, x, y) if event.button == 1 and event_is_dragging and isinstance(self.active_tool, FCEraser): pass else: self.update_utility_geometry(data=(x, y)) if self.active_tool.name in ['path', 'polygon']: self.active_tool.draw_cursor_data(pos=(x, y)) # ### Selection area on canvas section ### dx = pos[0] - self.pos[0] if event_is_dragging and event.button == 1: self.app.delete_selection_shape() if dx < 0: self.app.draw_moving_selection_shape((self.pos[0], self.pos[1]), (x, y), color=self.app.options["global_alt_sel_line"], face_color=self.app.options['global_alt_sel_fill']) self.app.selection_type = False else: self.app.draw_moving_selection_shape((self.pos[0], self.pos[1]), (x, y)) self.app.selection_type = True else: self.app.selection_type = None def update_utility_geometry(self, data): # ### Utility geometry (animated) ### geo = self.active_tool.utility_geometry(data=data) if isinstance(geo, DrawToolShape) and geo.geo is not None: # Remove any previous utility shape self.tool_shape.clear(update=True) self.draw_utility_geometry(geo=geo) def draw_selection_area_handler(self, start_pos, end_pos, sel_type): """ :param start_pos: mouse position when the selection LMB click was done :param end_pos: mouse position when the left mouse button is released :param sel_type: if True it's a left to right selection (enclosure), if False it's a 'touch' selection :return: """ poly_selection = Polygon([start_pos, (end_pos[0], start_pos[1]), end_pos, (start_pos[0], end_pos[1])]) key_modifier = QtWidgets.QApplication.keyboardModifiers() if key_modifier == QtCore.Qt.KeyboardModifier.ShiftModifier: mod_key = 'Shift' elif key_modifier == QtCore.Qt.KeyboardModifier.ControlModifier: mod_key = 'Control' else: mod_key = None self.app.delete_selection_shape() sel_objects_list = [] for obj in self.storage.get_objects(): if (sel_type is True and poly_selection.contains(obj.geo)) or (sel_type is False and poly_selection.intersects(obj.geo)): sel_objects_list.append(obj) if mod_key == self.app.options["global_mselect_key"]: for obj in sel_objects_list: if obj in self.selected: self.selected.remove(obj) else: # add the object to the selected shapes self.selected.append(obj) else: self.selected = [] self.selected = sel_objects_list # ############################################################################################################# # ######### if selection is done on canvas update the Tree in Selected Tab with the selection ############### # ############################################################################################################# try: self.tw.itemPressed.disconnect(self.on_tree_geo_click) except (AttributeError, TypeError): pass self.tw.selectionModel().clearSelection() for sel_shape in self.selected: iterator = QtWidgets.QTreeWidgetItemIterator(self.tw) while iterator.value(): item = iterator.value() try: if int(item.text(0)) == id(sel_shape): item.setSelected(True) except ValueError: pass iterator += 1 # ############################################################################################################# # ################### calculate vertex numbers for all selected shapes ###################################### # ############################################################################################################# vertex_nr = 0 for sha in sel_objects_list: sha_geo_solid = sha.geo if sha_geo_solid.geom_type == 'Polygon': sha_geo_solid_coords = list(sha_geo_solid.exterior.coords) elif sha_geo_solid.geom_type in ['LinearRing', 'LineString']: sha_geo_solid_coords = list(sha_geo_solid.coords) else: sha_geo_solid_coords = [] vertex_nr += len(sha_geo_solid_coords) self.geo_vertex_entry.set_value(vertex_nr) self.tw.itemPressed.connect(self.on_tree_geo_click) self.plot_all() def draw_utility_geometry(self, geo): # Add the new utility shape try: # this case is for the Font Parse w_geo = list(geo.geo.geoms) if isinstance(geo.geo, (MultiPolygon, MultiLineString)) else list(geo.geo) for el in w_geo: if type(el) == MultiPolygon: for poly in el.geoms: self.tool_shape.add( shape=poly, color=(self.app.options["global_draw_color"]), update=False, layer=0, tolerance=None ) elif type(el) == MultiLineString: for linestring in el.geoms: self.tool_shape.add( shape=linestring, color=(self.app.options["global_draw_color"]), update=False, layer=0, tolerance=None ) else: self.tool_shape.add( shape=el, color=(self.app.options["global_draw_color"]), update=False, layer=0, tolerance=None ) except TypeError: self.tool_shape.add( shape=geo.geo, color=(self.app.options["global_draw_color"]), update=False, layer=0, tolerance=None) except AttributeError: pass self.tool_shape.redraw() def on_delete_btn(self): self.delete_selected() self.plot_all() def delete_selected(self): tempref = [s for s in self.selected] for shape in tempref: self.delete_shape(shape) self.plot_all() self.selected = [] self.build_ui() def delete_shape(self, shape): if shape in self.utility: self.utility.remove(shape) return self.storage.remove(shape) if shape in self.selected: self.selected.remove(shape) def on_move(self): # if not self.selected: # self.app.inform.emit(_("[WARNING_NOTCL] Move cancelled. No shape selected.")) # return self.app.ui.geo_move_btn.setChecked(True) self.on_tool_select('move') def on_move_click(self): try: x, y = self.snap(self.x, self.y) except TypeError: return self.on_move() self.active_tool.set_origin((x, y)) def on_copy_click(self): if not self.selected: self.app.inform.emit('[WARNING_NOTCL] %s %s' % (_("Cancelled."), _("No shape selected."))) return self.app.ui.geo_copy_btn.setChecked(True) self.app.geo_editor.on_tool_select('copy') self.app.geo_editor.active_tool.set_origin(self.app.geo_editor.snap( self.app.geo_editor.x, self.app.geo_editor.y)) self.app.inform.emit(_("Click on target point.")) def on_corner_snap(self): self.app.ui.corner_snap_btn.trigger() def get_selected(self): """ Returns list of shapes that are selected in the editor. :return: List of shapes. """ # return [shape for shape in self.shape_buffer if shape["selected"]] return self.selected def plot_shape(self, geometry=None, color='#000000FF', linewidth=1): """ Plots a geometric object or list of objects without rendering. Plotted objects are returned as a list. This allows for efficient/animated rendering. :param geometry: Geometry to be plotted (Any Shapely.geom kind or list of such) :param color: Shape color :param linewidth: Width of lines in # of pixels. :return: List of plotted elements. """ plot_elements = [] if geometry is None: geometry = self.active_tool.geometry try: w_geo = geometry.geoms if isinstance(geometry, (MultiPolygon, MultiLineString)) else geometry for geo in w_geo: plot_elements += self.plot_shape(geometry=geo, color=color, linewidth=linewidth) # Non-iterable except TypeError: # DrawToolShape if isinstance(geometry, DrawToolShape): plot_elements += self.plot_shape(geometry=geometry.geo, color=color, linewidth=linewidth) # Polygon: Descend into exterior and each interior. # if isinstance(geometry, Polygon): # plot_elements += self.plot_shape(geometry=geometry.exterior, color=color, linewidth=linewidth) # plot_elements += self.plot_shape(geometry=geometry.interiors, color=color, linewidth=linewidth) if isinstance(geometry, Polygon): plot_elements.append(self.shapes.add(shape=geometry, color=color, face_color=color[:-2] + '50', layer=0, tolerance=self.fcgeometry.drawing_tolerance, linewidth=linewidth)) if isinstance(geometry, (LineString, LinearRing)): plot_elements.append(self.shapes.add(shape=geometry, color=color, layer=0, tolerance=self.fcgeometry.drawing_tolerance, linewidth=linewidth)) if type(geometry) == Point: pass return plot_elements def plot_all(self): """ Plots all shapes in the editor. :return: None :rtype: None """ # self.app.log.debug(str(inspect.stack()[1][3]) + " --> AppGeoEditor.plot_all()") self.shapes.clear(update=True) draw_color = self.app.options['global_draw_color'][:-2] + "FF" sel_color = self.app.options['global_sel_draw_color'][:-2] + 'FF' for shape in self.storage.get_objects(): if shape.geo and not shape.geo.is_empty and shape.geo.is_valid: if shape in self.selected: self.plot_shape(geometry=shape.geo, color=sel_color) else: self.plot_shape(geometry=shape.geo, color=draw_color) for shape in self.utility: self.plot_shape(geometry=shape.geo, linewidth=1) self.shapes.redraw() def on_shape_complete(self): self.app.log.debug("on_shape_complete()") geom_list = [] try: for shape in self.active_tool.geometry: geom_list.append(shape) except TypeError: geom_list = [self.active_tool.geometry] if self.app.options['geometry_editor_milling_type'] == 'cl': # reverse the geometry coordinates direction to allow creation of Gcode for climb milling try: for shp in geom_list: p = shp.geo if p is not None: if isinstance(p, Polygon): shp.geo = Polygon(p.exterior.coords[::-1], p.interiors) elif isinstance(p, LinearRing): shp.geo = LinearRing(p.coords[::-1]) elif isinstance(p, LineString): shp.geo = LineString(p.coords[::-1]) elif isinstance(p, MultiLineString): new_line = [] for line in p.geoms: new_line.append(LineString(line.coords[::-1])) shp.geo = MultiLineString(new_line) elif isinstance(p, MultiPolygon): new_poly = [] for poly in p.geoms: new_poly.append(Polygon(poly.exterior.coords[::-1], poly.interiors)) shp.geo = MultiPolygon(new_poly) else: self.app.log.debug("AppGeoEditor.on_shape_complete() Error --> Unexpected Geometry %s" % type(p)) except Exception as e: self.app.log.error("AppGeoEditor.on_shape_complete() Error --> %s" % str(e)) return 'fail' # Add shape self.add_shape(geom_list) # Remove any utility shapes self.delete_utility_geometry() self.tool_shape.clear(update=True) # Re-plot and reset tool. self.plot_all() # self.active_tool = type(self.active_tool)(self) @staticmethod def make_storage(): # Shape storage. storage = AppRTreeStorage() storage.get_points = DrawToolShape.get_pts return storage def select_tool(self, pluginName): """ Selects a drawing tool. Impacts the object and appGUI. :param pluginName: Name of the tool. :return: None """ self.tools[pluginName]["button"].setChecked(True) self.on_tool_select(pluginName) def set_selected(self, shape): # Remove and add to the end. if shape in self.selected: self.selected.remove(shape) self.selected.append(shape) def set_unselected(self, shape): if shape in self.selected: self.selected.remove(shape) def snap(self, x, y): """ Adjusts coordinates to snap settings. :param x: Input coordinate X :param y: Input coordinate Y :return: Snapped (x, y) """ snap_x, snap_y = (x, y) snap_distance = np.Inf # # ## Object (corner?) snap # # ## No need for the objects, just the coordinates # # ## in the index. if self.editor_options["corner_snap"]: try: nearest_pt, shape = self.storage.nearest((x, y)) nearest_pt_distance = distance((x, y), nearest_pt) if nearest_pt_distance <= float(self.editor_options["global_snap_max"]): snap_distance = nearest_pt_distance snap_x, snap_y = nearest_pt except (StopIteration, AssertionError): pass # # ## Grid snap if self.editor_options["grid_snap"]: if self.editor_options["global_gridx"] != 0: try: snap_x_ = round( x / float(self.editor_options["global_gridx"])) * float(self.editor_options['global_gridx']) except TypeError: snap_x_ = x else: snap_x_ = x # If the Grid_gap_linked on Grid Toolbar is checked then the snap distance on GridY entry will be ignored # and it will use the snap distance from GridX entry if self.app.ui.grid_gap_link_cb.isChecked(): if self.editor_options["global_gridx"] != 0: try: snap_y_ = round( y / float(self.editor_options["global_gridx"])) * float(self.editor_options['global_gridx']) except TypeError: snap_y_ = y else: snap_y_ = y else: if self.editor_options["global_gridy"] != 0: try: snap_y_ = round( y / float(self.editor_options["global_gridy"])) * float(self.editor_options['global_gridy']) except TypeError: snap_y_ = y else: snap_y_ = y nearest_grid_distance = distance((x, y), (snap_x_, snap_y_)) if nearest_grid_distance < snap_distance: snap_x, snap_y = (snap_x_, snap_y_) return snap_x, snap_y def edit_fcgeometry(self, fcgeometry, multigeo_tool=None): """ Imports the geometry from the given FlatCAM Geometry object into the editor. :param fcgeometry: GeometryObject :param multigeo_tool: A tool for the case of the edited geometry being of type 'multigeo' :return: None """ assert isinstance(fcgeometry, Geometry), "Expected a Geometry, got %s" % type(fcgeometry) self.deactivate() self.activate() self.set_editor_ui() self.units = self.app.app_units # Hide original geometry self.fcgeometry = fcgeometry fcgeometry.visible = False # Set selection tolerance DrawToolShape.tolerance = fcgeometry.drawing_tolerance * 10 self.select_tool("select") if self.app.options['tools_mill_spindledir'] == 'CW': if self.app.options['geometry_editor_milling_type'] == 'cl': milling_type = 1 # CCW motion = climb milling (spindle is rotating CW) else: milling_type = -1 # CW motion = conventional milling (spindle is rotating CW) else: if self.app.options['geometry_editor_milling_type'] == 'cl': milling_type = -1 # CCW motion = climb milling (spindle is rotating CCW) else: milling_type = 1 # CW motion = conventional milling (spindle is rotating CCW) self.multigeo_tool = multigeo_tool def task_job(editor_obj): # Link shapes into editor. with editor_obj.app.proc_container.new(_("Working...")): editor_obj.app.inform.emit(_("Loading the Geometry into the Editor...")) if self.multigeo_tool: editor_obj.multigeo_tool = self.multigeo_tool geo_to_edit = editor_obj.flatten(geometry=fcgeometry.tools[self.multigeo_tool]['solid_geometry'], orient_val=milling_type) else: geo_to_edit = editor_obj.flatten(geometry=fcgeometry.solid_geometry, orient_val=milling_type) # #################################################################################################### # remove the invalid geometry and also the Points as those are not relevant for the Editor # #################################################################################################### geo_to_edit = flatten_shapely_geometry(geo_to_edit) cleaned_geo = [g for g in geo_to_edit if g and not g.is_empty and g.is_valid and g.geom_type != 'Point'] for shape in cleaned_geo: if shape.geom_type == 'Polygon': editor_obj.add_shape(DrawToolShape(shape.exterior), build_ui=False) for inter in shape.interiors: editor_obj.add_shape(DrawToolShape(inter), build_ui=False) else: editor_obj.add_shape(DrawToolShape(shape), build_ui=False) editor_obj.plot_all() # updated units editor_obj.units = self.app.app_units.upper() editor_obj.decimals = self.app.decimals # start with GRID toolbar activated if editor_obj.app.ui.grid_snap_btn.isChecked() is False: editor_obj.app.ui.grid_snap_btn.trigger() # trigger a build of the UI self.build_ui_sig.emit() if multigeo_tool: editor_obj.app.inform.emit( '[WARNING_NOTCL] %s: %s %s: %s' % ( _("Editing MultiGeo Geometry, tool"), str(self.multigeo_tool), _("with diameter"), str(fcgeometry.tools[self.multigeo_tool]['tooldia']) ) ) self.tooldia_entry.set_value( float(fcgeometry.tools[self.multigeo_tool]['data']['tools_mill_tooldia'])) else: self.tooldia_entry.set_value(float(fcgeometry.obj_options['tools_mill_tooldia'])) self.app.worker_task.emit({'fcn': task_job, 'params': [self]}) def update_fcgeometry(self, fcgeometry): """ Transfers the geometry tool shape buffer to the selected geometry object. The geometry already in the object are removed. :param fcgeometry: GeometryObject :return: None """ def task_job(editor_obj): # Link shapes into editor. with editor_obj.app.proc_container.new(_("Working...")): if editor_obj.multigeo_tool: edited_dia = float(fcgeometry.tools[self.multigeo_tool]['tooldia']) new_dia = self.tooldia_entry.get_value() if new_dia != edited_dia: fcgeometry.tools[self.multigeo_tool]['tooldia'] = new_dia fcgeometry.tools[self.multigeo_tool]['data']['tools_mill_tooldia'] = new_dia fcgeometry.tools[self.multigeo_tool]['solid_geometry'] = [] # for shape in self.shape_buffer: for shape in editor_obj.storage.get_objects(): new_geo = shape.geo # simplify the MultiLineString if isinstance(new_geo, MultiLineString): new_geo = linemerge(new_geo) fcgeometry.tools[self.multigeo_tool]['solid_geometry'].append(new_geo) editor_obj.multigeo_tool = None else: edited_dia = float(fcgeometry.obj_options['tools_mill_tooldia']) new_dia = self.tooldia_entry.get_value() if new_dia != edited_dia: fcgeometry.obj_options['tools_mill_tooldia'] = new_dia fcgeometry.solid_geometry = [] # for shape in self.shape_buffer: for shape in editor_obj.storage.get_objects(): new_geo = shape.geo # simplify the MultiLineString if isinstance(new_geo, MultiLineString): new_geo = linemerge(new_geo) fcgeometry.solid_geometry.append(new_geo) try: bounds = fcgeometry.bounds() fcgeometry.obj_options['xmin'] = bounds[0] fcgeometry.obj_options['ymin'] = bounds[1] fcgeometry.obj_options['xmax'] = bounds[2] fcgeometry.obj_options['ymax'] = bounds[3] except Exception: pass self.deactivate() editor_obj.app.inform.emit(_("Editor Exit. Geometry object was updated ...")) self.app.worker_task.emit({'fcn': task_job, 'params': [self]}) def update_options(self, obj): if self.paint_tooldia: obj.obj_options['tools_mill_tooldia'] = deepcopy(str(self.paint_tooldia)) self.paint_tooldia = None return True else: return False def union(self): """ Makes union of selected polygons. Original polygons are deleted. :return: None. """ def work_task(editor_self): with editor_self.app.proc_container.new(_("Working...")): results = unary_union([t.geo for t in editor_self.get_selected()]) if results.geom_type == 'MultiLineString': results = linemerge(results) # Delete originals. for_deletion = [s for s in editor_self.get_selected()] for shape in for_deletion: editor_self.delete_shape(shape) # Selected geometry is now gone! editor_self.selected = [] editor_self.add_shape(DrawToolShape(results)) editor_self.plot_all() editor_self.build_ui_sig.emit() editor_self.app.inform.emit('[success] %s' % _("Done.")) self.app.worker_task.emit({'fcn': work_task, 'params': [self]}) def intersection_2(self): """ Makes intersection of selected polygons. Original polygons are deleted. :return: None """ def work_task(editor_self): editor_self.app.log.debug("AppGeoEditor.intersection_2()") with editor_self.app.proc_container.new(_("Working...")): selected = editor_self.get_selected() if len(selected) < 2: editor_self.app.inform.emit('[WARNING_NOTCL] %s' % _("A selection of minimum two items is required to do Intersection.")) editor_self.select_tool('select') return target = deepcopy(selected[0].geo) if target.is_ring: target = Polygon(target) tools = selected[1:] # toolgeo = unary_union([deepcopy(shp.geo) for shp in tools]).buffer(0.0000001) # result = DrawToolShape(target.difference(toolgeo)) for tool in tools: if tool.geo.is_ring: intersector_geo = Polygon(tool.geo) target = target.difference(intersector_geo) if target.geom_type in ['LineString', 'MultiLineString']: target = linemerge(target) if target.geom_type == 'Polygon': target = target.exterior result = DrawToolShape(target) editor_self.add_shape(deepcopy(result)) # Delete originals. for_deletion = [s for s in editor_self.get_selected()] for shape_el in for_deletion: editor_self.delete_shape(shape_el) # Selected geometry is now gone! editor_self.selected = [] editor_self.plot_all() editor_self.build_ui_sig.emit() editor_self.app.inform.emit('[success] %s' % _("Done.")) self.app.worker_task.emit({'fcn': work_task, 'params': [self]}) def intersection(self): """ Makes intersection of selected polygons. Original polygons are deleted. :return: None """ def work_task(editor_self): editor_self.app.log.debug("AppGeoEditor.intersection()") with editor_self.app.proc_container.new(_("Working...")): selected = editor_self.get_selected() results = [] intact = [] if len(selected) < 2: editor_self.app.inform.emit('[WARNING_NOTCL] %s' % _("A selection of minimum two items is required to do Intersection.")) editor_self.select_tool('select') return intersector = selected[0].geo if intersector.is_ring: intersector = Polygon(intersector) tools = selected[1:] for tool in tools: if tool.geo.is_ring: intersected = Polygon(tool.geo) else: intersected = tool.geo if intersector.intersects(intersected): results.append(intersector.intersection(intersected)) else: intact.append(tool) if results: # Delete originals. for_deletion = [s for s in editor_self.get_selected()] for shape_el in for_deletion: if shape_el not in intact: editor_self.delete_shape(shape_el) for geo in results: if geo.geom_type == 'MultiPolygon': for poly in geo.geoms: p_geo = [poly.exterior] + [ints for ints in poly.interiors] for g in p_geo: editor_self.add_shape(DrawToolShape(g)) elif geo.geom_type == 'Polygon': p_geo = [geo.exterior] + [ints for ints in geo.interiors] for g in p_geo: editor_self.add_shape(DrawToolShape(g)) else: editor_self.add_shape(DrawToolShape(geo)) # Selected geometry is now gone! editor_self.selected = [] editor_self.plot_all() editor_self.build_ui_sig.emit() editor_self.app.inform.emit('[success] %s' % _("Done.")) self.app.worker_task.emit({'fcn': work_task, 'params': [self]}) def subtract(self): def work_task(editor_self): with editor_self.app.proc_container.new(_("Working...")): selected = editor_self.get_selected() try: target = deepcopy(selected[0].geo) tools = selected[1:] # toolgeo = unary_union([deepcopy(shp.geo) for shp in tools]).buffer(0.0000001) # result = DrawToolShape(target.difference(toolgeo)) for tool in tools: if tool.geo.is_ring: sub_geo = Polygon(tool.geo) target = target.difference(sub_geo) result = DrawToolShape(target) editor_self.add_shape(deepcopy(result)) for_deletion = [s for s in editor_self.get_selected()] for shape in for_deletion: self.delete_shape(shape) editor_self.plot_all() editor_self.build_ui_sig.emit() editor_self.app.inform.emit('[success] %s' % _("Done.")) except Exception as e: editor_self.app.log.error(str(e)) self.app.worker_task.emit({'fcn': work_task, 'params': [self]}) def subtract_2(self): def work_task(editor_self): with editor_self.app.proc_container.new(_("Working...")): selected = editor_self.get_selected() try: target = deepcopy(selected[0].geo) tools = selected[1:] # toolgeo = unary_union([shp.geo for shp in tools]).buffer(0.0000001) for tool in tools: if tool.geo.is_ring: sub_geo = Polygon(tool.geo) target = target.difference(sub_geo) result = DrawToolShape(target) editor_self.add_shape(deepcopy(result)) editor_self.delete_shape(selected[0]) editor_self.plot_all() editor_self.build_ui_sig.emit() editor_self.app.inform.emit('[success] %s' % _("Done.")) except Exception as e: editor_self.app.log.error(str(e)) self.app.worker_task.emit({'fcn': work_task, 'params': [self]}) def cutpath(self): def work_task(editor_self): with editor_self.app.proc_container.new(_("Working...")): selected = editor_self.get_selected() tools = selected[1:] toolgeo = unary_union([shp.geo for shp in tools]) target = selected[0] if type(target.geo) == Polygon: for ring in poly2rings(target.geo): editor_self.add_shape(DrawToolShape(ring.difference(toolgeo))) elif type(target.geo) == LineString or type(target.geo) == LinearRing: editor_self.add_shape(DrawToolShape(target.geo.difference(toolgeo))) elif type(target.geo) == MultiLineString: try: for linestring in target.geo: editor_self.add_shape(DrawToolShape(linestring.difference(toolgeo))) except Exception as e: editor_self.app.log.error("Current LinearString does not intersect the target. %s" % str(e)) else: editor_self.app.log.warning("Not implemented. Object type: %s" % str(type(target.geo))) return editor_self.delete_shape(target) editor_self.plot_all() editor_self.build_ui_sig.emit() editor_self.app.inform.emit('[success] %s' % _("Done.")) self.app.worker_task.emit({'fcn': work_task, 'params': [self]}) def flatten(self, geometry, orient_val=1, reset=True, pathonly=False): """ Creates a list of non-iterable linear geometry objects. Polygons are expanded into its exterior and interiors if specified. Results are placed in self.flat_geometry :param geometry: Shapely type or list or list of list of such. :param orient_val: will orient the exterior coordinates CW if 1 and CCW for else (whatever else means ...) https://shapely.readthedocs.io/en/stable/manual.html#polygons :param reset: Clears the contents of self.flat_geometry. :param pathonly: Expands polygons into linear elements. """ if reset: self.flat_geo = [] # ## If iterable, expand recursively. try: if isinstance(geometry, (MultiPolygon, MultiLineString)): work_geo = geometry.geoms else: work_geo = geometry for geo in work_geo: if geo is not None: self.flatten(geometry=geo, orient_val=orient_val, reset=False, pathonly=pathonly) # ## Not iterable, do the actual indexing and add. except TypeError: if type(geometry) == Polygon: geometry = orient(geometry, orient_val) if pathonly and type(geometry) == Polygon: self.flat_geo.append(geometry.exterior) self.flatten(geometry=geometry.interiors, reset=False, pathonly=True) else: self.flat_geo.append(geometry) return self.flat_geo def distance(pt1, pt2): return np.sqrt((pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) ** 2) def mag(vec): return np.sqrt(vec[0] ** 2 + vec[1] ** 2) def poly2rings(poly): return [poly.exterior] + [interior for interior in poly.interiors] def get_shapely_list_bounds(geometry_list): xmin = np.Inf ymin = np.Inf xmax = -np.Inf ymax = -np.Inf for gs in geometry_list: try: gxmin, gymin, gxmax, gymax = gs.bounds xmin = min([xmin, gxmin]) ymin = min([ymin, gymin]) xmax = max([xmax, gxmax]) ymax = max([ymax, gymax]) except Exception as e: log.error("Tried to get bounds of empty geometry. --> %s" % str(e)) return [xmin, ymin, xmax, ymax]