############################################################ # FlatCAM: 2D Post-processing for Manufacturing # # http://caram.cl/software/flatcam # # Author: Juan Pablo Caram (c) # # Date: 2/5/2014 # # MIT Licence # # Modified by Marius Stanciu 09/21/2019 # ############################################################ from PyQt5 import QtCore from PyQt5.QtCore import pyqtSignal # needed for legacy mode # Used for solid polygons in Matplotlib from descartes.patch import PolygonPatch from shapely.geometry import Polygon, LineString, LinearRing from copy import deepcopy import logging import numpy as np import gettext import appTranslation as fcTranslate import builtins # Prevent conflict with Qt5 and above. from matplotlib import use as mpl_use mpl_use("Qt5Agg") from matplotlib.figure import Figure from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas from matplotlib.lines import Line2D from matplotlib.offsetbox import AnchoredText # from matplotlib.widgets import Cursor fcTranslate.apply_language('strings') if '_' not in builtins.__dict__: _ = gettext.gettext log = logging.getLogger('base') class CanvasCache(QtCore.QObject): """ Case story #1: 1) No objects in the project. 2) Object is created (app_obj.new_object() emits object_created(obj)). on_object_created() adds (i) object to collection and emits (ii) app_obj.new_object_available() then calls (iii) object.plot() 3) object.plot() creates axes if necessary on app.collection.figure. Then plots on it. 4) Plots on a cache-size canvas (in background). 5) Plot completes. Bitmap is generated. 6) Visible canvas is painted. """ # Signals: # A bitmap is ready to be displayed. new_screen = QtCore.pyqtSignal() def __init__(self, plotcanvas, app, dpi=50): super(CanvasCache, self).__init__() self.app = app self.plotcanvas = plotcanvas self.dpi = dpi self.figure = Figure(dpi=dpi) self.axes = self.figure.add_axes([0.0, 0.0, 1.0, 1.0], alpha=1.0) self.axes.set_frame_on(False) self.axes.set_xticks([]) self.axes.set_yticks([]) if self.app.defaults['global_theme'] == 'white': self.axes.set_facecolor('#FFFFFF') else: self.axes.set_facecolor('#000000') self.canvas = FigureCanvas(self.figure) self.cache = None def run(self): log.debug("CanvasCache Thread Started!") self.plotcanvas.update_screen_request.connect(self.on_update_req) def on_update_req(self, extents): """ Event handler for an updated display request. :param extents: [xmin, xmax, ymin, ymax, zoom(optional)] """ # log.debug("Canvas update requested: %s" % str(extents)) # Note: This information below might be out of date. Establish # a protocol regarding when to change the canvas in the main # thread and when to check these values here in the background, # or pass this data in the signal (safer). # log.debug("Size: %s [px]" % str(self.plotcanvas.get_axes_pixelsize())) # log.debug("Density: %s [units/px]" % str(self.plotcanvas.get_density())) # Move the requested screen portion to the main thread # and inform about the update: self.new_screen.emit() # Continue to update the cache. # def on_app_obj.new_object_available(self): # # log.debug("A new object is available. Should plot it!") class PlotCanvasLegacy(QtCore.QObject): """ Class handling the plotting area in the application. """ # Signals: # Request for new bitmap to display. The parameter # is a list with [xmin, xmax, ymin, ymax, zoom(optional)] update_screen_request = QtCore.pyqtSignal(list) double_click = QtCore.pyqtSignal(object) def __init__(self, container, app): """ The constructor configures the Matplotlib figure that will contain all plots, creates the base axes and connects events to the plotting area. :param container: The parent container in which to draw plots. :rtype: PlotCanvas """ super(PlotCanvasLegacy, self).__init__() self.app = app if self.app.defaults['global_theme'] == 'white': theme_color = '#FFFFFF' tick_color = '#000000' self.rect_hud_color = '#0000FF10' self.text_hud_color = '#000000' else: theme_color = '#000000' tick_color = '#FFFFFF' self.rect_hud_color = '#80808040' self.text_hud_color = '#FFFFFF' # workspace lines; I didn't use the rectangle because I didn't want to add another VisPy Node, # which might decrease performance # self.b_line, self.r_line, self.t_line, self.l_line = None, None, None, None self.workspace_line = None self.pagesize_dict = {} self.pagesize_dict.update( { 'A0': (841, 1189), 'A1': (594, 841), 'A2': (420, 594), 'A3': (297, 420), 'A4': (210, 297), 'A5': (148, 210), 'A6': (105, 148), 'A7': (74, 105), 'A8': (52, 74), 'A9': (37, 52), 'A10': (26, 37), 'B0': (1000, 1414), 'B1': (707, 1000), 'B2': (500, 707), 'B3': (353, 500), 'B4': (250, 353), 'B5': (176, 250), 'B6': (125, 176), 'B7': (88, 125), 'B8': (62, 88), 'B9': (44, 62), 'B10': (31, 44), 'C0': (917, 1297), 'C1': (648, 917), 'C2': (458, 648), 'C3': (324, 458), 'C4': (229, 324), 'C5': (162, 229), 'C6': (114, 162), 'C7': (81, 114), 'C8': (57, 81), 'C9': (40, 57), 'C10': (28, 40), # American paper sizes 'LETTER': (8.5*25.4, 11*25.4), 'LEGAL': (8.5*25.4, 14*25.4), 'ELEVENSEVENTEEN': (11*25.4, 17*25.4), # From https://en.wikipedia.org/wiki/Paper_size 'JUNIOR_LEGAL': (5*25.4, 8*25.4), 'HALF_LETTER': (5.5*25.4, 8*25.4), 'GOV_LETTER': (8*25.4, 10.5*25.4), 'GOV_LEGAL': (8.5*25.4, 13*25.4), 'LEDGER': (17*25.4, 11*25.4), } ) # Options self.x_margin = 15 # pixels self.y_margin = 25 # Pixels # Parent container self.container = container # Plots go onto a single matplotlib.figure self.figure = Figure(dpi=50) self.figure.patch.set_visible(True) self.figure.set_facecolor(theme_color) # These axes show the ticks and grid. No plotting done here. # New axes must have a label, otherwise mpl returns an existing one. self.axes = self.figure.add_axes([0.05, 0.05, 0.9, 0.9], label="base", alpha=0.0) self.axes.set_aspect(1) self.axes.grid(True, color='gray') self.h_line = self.axes.axhline(color=(0.70, 0.3, 0.3), linewidth=2) self.v_line = self.axes.axvline(color=(0.70, 0.3, 0.3), linewidth=2) self.axes.tick_params(axis='x', color=tick_color, labelcolor=tick_color) self.axes.tick_params(axis='y', color=tick_color, labelcolor=tick_color) self.axes.spines['bottom'].set_color(tick_color) self.axes.spines['top'].set_color(tick_color) self.axes.spines['right'].set_color(tick_color) self.axes.spines['left'].set_color(tick_color) self.axes.set_facecolor(theme_color) self.ch_line = None self.cv_line = None # The canvas is the top level container (FigureCanvasQTAgg) self.canvas = FigureCanvas(self.figure) self.canvas.setFocusPolicy(QtCore.Qt.ClickFocus) self.canvas.setFocus() self.native = self.canvas self.adjust_axes(-10, -10, 100, 100) # self.canvas.set_can_focus(True) # For key press # Attach to parent # self.container.attach(self.canvas, 0, 0, 600, 400) self.container.addWidget(self.canvas) # Qt # Copy a bitmap of the canvas for quick animation. # Update every time the canvas is re-drawn. self.background = self.canvas.copy_from_bbox(self.axes.bbox) # ################### NOT IMPLEMENTED YET - EXPERIMENTAL ####################### # ## Bitmap Cache # self.cache = CanvasCache(self, self.app) # self.cache_thread = QtCore.QThread() # self.cache.moveToThread(self.cache_thread) # # super(PlotCanvas, self).connect(self.cache_thread, QtCore.SIGNAL("started()"), self.cache.run) # self.cache_thread.started.connect(self.cache.run) # # self.cache_thread.start() # self.cache.new_screen.connect(self.on_new_screen) # ############################################################################## # Events self.mp = self.graph_event_connect('button_press_event', self.on_mouse_press) self.mr = self.graph_event_connect('button_release_event', self.on_mouse_release) self.mm = self.graph_event_connect('motion_notify_event', self.on_mouse_move) # self.canvas.connect('configure-event', self.auto_adjust_axes) self.aaa = self.graph_event_connect('resize_event', self.auto_adjust_axes) # self.canvas.add_events(Gdk.EventMask.SMOOTH_SCROLL_MASK) # self.canvas.connect("scroll-event", self.on_scroll) self.osc = self.graph_event_connect('scroll_event', self.on_scroll) # self.graph_event_connect('key_press_event', self.on_key_down) # self.graph_event_connect('key_release_event', self.on_key_up) self.odr = self.graph_event_connect('draw_event', self.on_draw) self.key = None self.pan_axes = [] self.panning = False self.mouse = [0, 0] self.big_cursor = False self.big_cursor_isdisabled = None # signal is the mouse is dragging self.is_dragging = False self.mouse_press_pos = None # signal if there is a doubleclick self.is_dblclk = False # HUD Display self.hud_enabled = False self.text_hud = self.Thud(plotcanvas=self) if self.app.defaults['global_hud'] is True: self.on_toggle_hud(state=True, silent=None) # enable Grid lines self.grid_lines_enabled = True # draw a rectangle made out of 4 lines on the canvas to serve as a hint for the work area # all CNC have a limited workspace if self.app.defaults['global_workspace'] is True: self.draw_workspace(workspace_size=self.app.defaults["global_workspaceT"]) # Axis Display self.axis_enabled = True # enable Axis self.on_toggle_axis(state=True, silent=True) self.app.ui.axis_status_label.setStyleSheet(""" QLabel { color: black; background-color: orange; } """) def on_toggle_axis(self, signal=None, state=None, silent=None): if not state: state = not self.axis_enabled if state: self.axis_enabled = True self.app.defaults['global_axis'] = True if self.h_line not in self.axes.lines and self.v_line not in self.axes.lines: self.h_line = self.axes.axhline(color=(0.70, 0.3, 0.3), linewidth=2) self.v_line = self.axes.axvline(color=(0.70, 0.3, 0.3), linewidth=2) self.app.ui.axis_status_label.setStyleSheet(""" QLabel { color: black; background-color: orange; } """) if silent is None: self.app.inform[str, bool].emit(_("Axis enabled."), False) else: self.axis_enabled = False self.app.defaults['global_axis'] = False if self.h_line in self.axes.lines and self.v_line in self.axes.lines: self.axes.lines.remove(self.h_line) self.axes.lines.remove(self.v_line) self.app.ui.axis_status_label.setStyleSheet("") if silent is None: self.app.inform[str, bool].emit(_("Axis disabled."), False) self.canvas.draw() def on_toggle_hud(self, signal=None, state=None, silent=None): if state is None: state = not self.hud_enabled if state: self.hud_enabled = True self.text_hud.add_artist() self.app.defaults['global_hud'] = True self.app.ui.hud_label.setStyleSheet(""" QLabel { color: black; background-color: mediumpurple; } """) if silent is None: self.app.inform[str, bool].emit(_("HUD enabled."), False) else: self.hud_enabled = False self.text_hud.remove_artist() self.app.defaults['global_hud'] = False self.app.ui.hud_label.setStyleSheet("") if silent is None: self.app.inform[str, bool].emit(_("HUD disabled."), False) self.canvas.draw() class Thud(QtCore.QObject): text_changed = QtCore.pyqtSignal(str) def __init__(self, plotcanvas): super().__init__() self.p = plotcanvas units = self.p.app.defaults['units'] self._text = 'Dx: %s [%s]\nDy: %s [%s]\n\nX: %s [%s]\nY: %s [%s]' % \ ('0.0000', units, '0.0000', units, '0.0000', units, '0.0000', units) # set font size qsettings = QtCore.QSettings("Open Source", "FlatCAM") if qsettings.contains("hud_font_size"): # I multiply with 2.5 because this seems to be the difference between the value taken by the VisPy (3D) # and Matplotlib (Legacy2D FlatCAM graphic engine) fsize = int(qsettings.value('hud_font_size', type=int) * 2.5) else: fsize = 20 self.hud_holder = AnchoredText(self._text, prop=dict(size=fsize), frameon=True, loc='upper left') self.hud_holder.patch.set_boxstyle("round,pad=0.,rounding_size=0.2") fc_color = self.p.rect_hud_color[:-2] fc_alpha = int(self.p.rect_hud_color[-2:], 16) / 255 text_color = self.p.text_hud_color self.hud_holder.patch.set_facecolor(fc_color) self.hud_holder.patch.set_alpha(fc_alpha) self.hud_holder.patch.set_edgecolor((0, 0, 0, 0)) self. hud_holder.txt._text.set_color(color=text_color) self.text_changed.connect(self.on_text_changed) @property def text(self): return self._text @text.setter def text(self, val): self.text_changed.emit(val) self._text = val def on_text_changed(self, txt): try: txt = txt.replace('\t', ' ') self.hud_holder.txt.set_text(txt) self.p.canvas.draw() except Exception: pass def add_artist(self): if self.hud_holder not in self.p.axes.artists: self.p.axes.add_artist(self.hud_holder) def remove_artist(self): if self.hud_holder in self.p.axes.artists: self.p.axes.artists.remove(self.hud_holder) def on_toggle_grid_lines(self, signal=None, silent=None): state = not self.grid_lines_enabled if state: self.app.defaults['global_grid_lines'] = True self.grid_lines_enabled = True self.axes.grid(True) try: self.canvas.draw() except IndexError: pass if silent is None: self.app.inform[str, bool].emit(_("Grid enabled."), False) else: self.app.defaults['global_grid_lines'] = False self.grid_lines_enabled = False self.axes.grid(False) try: self.canvas.draw() except IndexError: pass if silent is None: self.app.inform[str, bool].emit(_("Grid disabled."), False) def draw_workspace(self, workspace_size): """ Draw a rectangular shape on canvas to specify our valid workspace. :param workspace_size: the workspace size; tuple :return: """ try: if self.app.defaults['units'].upper() == 'MM': dims = self.pagesize_dict[workspace_size] else: dims = (self.pagesize_dict[workspace_size][0]/25.4, self.pagesize_dict[workspace_size][1]/25.4) except Exception as e: log.debug("PlotCanvasLegacy.draw_workspace() --> %s" % str(e)) return if self.app.defaults['global_workspace_orientation'] == 'l': dims = (dims[1], dims[0]) xdata = [0, dims[0], dims[0], 0, 0] ydata = [0, 0, dims[1], dims[1], 0] if self.workspace_line not in self.axes.lines: self.workspace_line = Line2D(xdata=xdata, ydata=ydata, linewidth=2, antialiased=True, color='#b34d4d') self.axes.add_line(self.workspace_line) self.canvas.draw() self.app.ui.wplace_label.set_value(workspace_size[:3]) self.app.ui.wplace_label.setToolTip(workspace_size) self.fcapp.ui.wplace_label.setStyleSheet(""" QLabel { color: black; background-color: olivedrab; } """) def delete_workspace(self): try: self.axes.lines.remove(self.workspace_line) self.canvas.draw() except Exception: pass self.fcapp.ui.wplace_label.setStyleSheet("") def graph_event_connect(self, event_name, callback): """ Attach an event handler to the canvas through the Matplotlib interface. :param event_name: Name of the event :type event_name: str :param callback: Function to call :type callback: func :return: Connection id :rtype: int """ if event_name == 'mouse_move': event_name = 'motion_notify_event' if event_name == 'mouse_press': event_name = 'button_press_event' if event_name == 'mouse_release': event_name = 'button_release_event' if event_name == 'mouse_double_click': return self.double_click.connect(callback) if event_name == 'key_press': event_name = 'key_press_event' return self.canvas.mpl_connect(event_name, callback) def graph_event_disconnect(self, cid): """ Disconnect callback with the give id. :param cid: Callback id. :return: None """ self.canvas.mpl_disconnect(cid) def on_new_screen(self): pass # log.debug("Cache updated the screen!") def new_cursor(self, axes=None, big=None): # if axes is None: # c = MplCursor(axes=self.axes, color='black', linewidth=1) # else: # c = MplCursor(axes=axes, color='black', linewidth=1) if self.app.defaults["global_cursor_color_enabled"]: color = self.app.defaults["global_cursor_color"] else: if self.app.defaults['global_theme'] == 'white': color = '#000000' else: color = '#FFFFFF' if big is True: self.big_cursor = True self.ch_line = self.axes.axhline(color=color, linewidth=self.app.defaults["global_cursor_width"]) self.cv_line = self.axes.axvline(color=color, linewidth=self.app.defaults["global_cursor_width"]) self.big_cursor_isdisabled = False else: self.big_cursor = False c = FakeCursor() c.mouse_state_updated.connect(self.clear_cursor) return c def draw_cursor(self, x_pos, y_pos, color=None): """ Draw a cursor at the mouse grid snapped position :param x_pos: mouse x position :param y_pos: mouse y position :param color: custom color of the mouse :return: """ # there is no point in drawing mouse cursor when panning as it jumps in a confusing way if self.app.app_cursor.enabled is True and self.panning is False: if color: color = color else: if self.app.defaults['global_theme'] == 'white': color = '#000000' else: color = '#FFFFFF' if self.big_cursor is False: try: x, y = self.snap(x_pos, y_pos) # Pointer (snapped) # The size of the cursor is multiplied by 1.65 because that value made the cursor similar with the # one in the OpenGL(3D) graphic engine pointer_size = int(float(self.app.defaults["global_cursor_size"]) * 1.65) elements = self.axes.plot(x, y, '+', color=color, ms=pointer_size, mew=self.app.defaults["global_cursor_width"], animated=True) for el in elements: self.axes.draw_artist(el) except Exception as e: # this happen at app initialization since self.app.geo_editor does not exist yet # I could reshuffle the object instantiating order but what's the point? # I could crash something else and that's pythonic, too log.debug("PlotCanvasLegacy.draw_cursor() big_cursor is False --> %s" % str(e)) else: try: self.ch_line.set_markeredgewidth(self.app.defaults["global_cursor_width"]) self.cv_line.set_markeredgewidth(self.app.defaults["global_cursor_width"]) except Exception: pass try: x, y = self.app.geo_editor.snap(x_pos, y_pos) self.ch_line.set_ydata(y) self.cv_line.set_xdata(x) except Exception: # this happen at app initialization since self.app.geo_editor does not exist yet # I could reshuffle the object instantiating order but what's the point? # I could crash something else and that's pythonic, too pass self.canvas.draw_idle() self.canvas.blit(self.axes.bbox) def clear_cursor(self, state): if state is True: if self.big_cursor is True and self.big_cursor_isdisabled is True: if self.app.defaults["global_cursor_color_enabled"]: color = self.app.defaults["global_cursor_color"] else: if self.app.defaults['global_theme'] == 'white': color = '#000000' else: color = '#FFFFFF' self.ch_line = self.axes.axhline(color=color, linewidth=self.app.defaults["global_cursor_width"]) self.cv_line = self.axes.axvline(color=color, linewidth=self.app.defaults["global_cursor_width"]) self.big_cursor_isdisabled = False if self.app.defaults["global_cursor_color_enabled"] is True: self.draw_cursor(x_pos=self.mouse[0], y_pos=self.mouse[1], color=self.app.cursor_color_3D) else: self.draw_cursor(x_pos=self.mouse[0], y_pos=self.mouse[1]) else: if self.big_cursor is True: self.big_cursor_isdisabled = True try: self.ch_line.remove() self.cv_line.remove() self.canvas.draw_idle() except Exception as e: log.debug("PlotCanvasLegacy.clear_cursor() big_cursor is True --> %s" % str(e)) self.canvas.restore_region(self.background) self.canvas.blit(self.axes.bbox) def on_key_down(self, event): """ :param event: :return: """ log.debug('on_key_down(): ' + str(event.key)) self.key = event.key def on_key_up(self, event): """ :param event: :return: """ self.key = None def connect(self, event_name, callback): """ Attach an event handler to the canvas through the native Qt interface. :param event_name: Name of the event :type event_name: str :param callback: Function to call :type callback: function :return: Nothing """ self.canvas.connect(event_name, callback) def clear(self): """ Clears axes and figure. :return: None """ # Clear self.axes.cla() try: self.figure.clf() except KeyError: log.warning("KeyError in MPL figure.clf()") # Re-build self.figure.add_axes(self.axes) self.axes.set_aspect(1) self.axes.grid(True) self.axes.axhline(color=(0.70, 0.3, 0.3), linewidth=2) self.axes.axvline(color=(0.70, 0.3, 0.3), linewidth=2) self.adjust_axes(-10, -10, 100, 100) # Re-draw self.canvas.draw_idle() def redraw(self): """ Created only to serve for compatibility with the VisPy plotcanvas (the other graphic engine, 3D) :return: """ self.clear() def adjust_axes(self, xmin, ymin, xmax, ymax): """ Adjusts all axes while maintaining the use of the whole canvas and an aspect ratio to 1:1 between x and y axes. The parameters are an original request that will be modified to fit these restrictions. :param xmin: Requested minimum value for the X axis. :type xmin: float :param ymin: Requested minimum value for the Y axis. :type ymin: float :param xmax: Requested maximum value for the X axis. :type xmax: float :param ymax: Requested maximum value for the Y axis. :type ymax: float :return: None """ # FlatCAMApp.App.log.debug("PC.adjust_axes()") if not self.app.collection.get_list(): xmin = -10 ymin = -10 xmax = 100 ymax = 100 width = xmax - xmin height = ymax - ymin try: r = width / height except ZeroDivisionError: log.error("Height is %f" % height) return canvas_w, canvas_h = self.canvas.get_width_height() canvas_r = float(canvas_w) / canvas_h x_ratio = float(self.x_margin) / canvas_w y_ratio = float(self.y_margin) / canvas_h if r > canvas_r: ycenter = (ymin + ymax) / 2.0 newheight = height * r / canvas_r ymin = ycenter - newheight / 2.0 ymax = ycenter + newheight / 2.0 else: xcenter = (xmax + xmin) / 2.0 newwidth = width * canvas_r / r xmin = xcenter - newwidth / 2.0 xmax = xcenter + newwidth / 2.0 # Adjust axes for ax in self.figure.get_axes(): if ax._label != 'base': ax.set_frame_on(False) # No frame ax.set_xticks([]) # No tick ax.set_yticks([]) # No ticks ax.patch.set_visible(False) # No background ax.set_aspect(1) ax.set_xlim((xmin, xmax)) ax.set_ylim((ymin, ymax)) ax.set_position([x_ratio, y_ratio, 1 - 2 * x_ratio, 1 - 2 * y_ratio]) # Sync re-draw to proper paint on form resize self.canvas.draw() # #### Temporary place-holder for cached update ##### self.update_screen_request.emit([0, 0, 0, 0, 0]) def auto_adjust_axes(self, *args): """ Calls ``adjust_axes()`` using the extents of the base axes. :rtype : None :return: None """ xmin, xmax = self.axes.get_xlim() ymin, ymax = self.axes.get_ylim() self.adjust_axes(xmin, ymin, xmax, ymax) def fit_view(self): self.auto_adjust_axes() def fit_center(self, loc, rect=None): x = loc[0] y = loc[1] xmin, xmax = self.axes.get_xlim() ymin, ymax = self.axes.get_ylim() half_width = (xmax - xmin) / 2 half_height = (ymax - ymin) / 2 # Adjust axes for ax in self.figure.get_axes(): ax.set_xlim((x - half_width, x + half_width)) ax.set_ylim((y - half_height, y + half_height)) # Re-draw self.canvas.draw() # #### Temporary place-holder for cached update ##### self.update_screen_request.emit([0, 0, 0, 0, 0]) def zoom(self, factor, center=None): """ Zooms the plot by factor around a given center point. Takes care of re-drawing. :param factor: Number by which to scale the plot. :type factor: float :param center: Coordinates [x, y] of the point around which to scale the plot. :type center: list :return: None """ factor = 1 / factor xmin, xmax = self.axes.get_xlim() ymin, ymax = self.axes.get_ylim() width = xmax - xmin height = ymax - ymin if center is None or center == [None, None]: center = [(xmin + xmax) / 2.0, (ymin + ymax) / 2.0] # For keeping the point at the pointer location relx = (xmax - center[0]) / width rely = (ymax - center[1]) / height new_width = width / factor new_height = height / factor xmin = center[0] - new_width * (1 - relx) xmax = center[0] + new_width * relx ymin = center[1] - new_height * (1 - rely) ymax = center[1] + new_height * rely # Adjust axes for ax in self.figure.get_axes(): ax.set_xlim((xmin, xmax)) ax.set_ylim((ymin, ymax)) # Async re-draw self.canvas.draw_idle() # #### Temporary place-holder for cached update ##### self.update_screen_request.emit([0, 0, 0, 0, 0]) def pan(self, x, y, idle=True): xmin, xmax = self.axes.get_xlim() ymin, ymax = self.axes.get_ylim() width = xmax - xmin height = ymax - ymin # Adjust axes for ax in self.figure.get_axes(): ax.set_xlim((xmin + x * width, xmax + x * width)) ax.set_ylim((ymin + y * height, ymax + y * height)) # Re-draw if idle: self.canvas.draw_idle() else: self.canvas.draw() # #### Temporary place-holder for cached update ##### self.update_screen_request.emit([0, 0, 0, 0, 0]) def new_axes(self, name): """ Creates and returns an Axes object attached to this object's Figure. :param name: Unique label for the axes. :return: Axes attached to the figure. :rtype: Axes """ new_ax = self.figure.add_axes([0.05, 0.05, 0.9, 0.9], label=name) return new_ax def remove_current_axes(self): """ :return: The name of the deleted axes """ axes_to_remove = self.figure.axes.gca() current_axes_name = deepcopy(axes_to_remove._label) self.figure.axes.remove(axes_to_remove) return current_axes_name def on_scroll(self, event): """ Scroll event handler. :param event: Event object containing the event information. :return: None """ # So it can receive key presses # self.canvas.grab_focus() self.canvas.setFocus() # Event info # z, direction = event.get_scroll_direction() if self.key is None: if event.button == 'up': self.zoom(1 / 1.5, self.mouse) else: self.zoom(1.5, self.mouse) return if self.key == 'shift': if event.button == 'up': self.pan(0.3, 0) else: self.pan(-0.3, 0) return if self.key == 'control': if event.button == 'up': self.pan(0, 0.3) else: self.pan(0, -0.3) return def on_mouse_press(self, event): self.is_dragging = True self.mouse_press_pos = (event.x, event.y) # Check for middle mouse button press if self.app.defaults["global_pan_button"] == '2': pan_button = 3 # right button for Matplotlib else: pan_button = 2 # middle button for Matplotlib if event.button == pan_button: # Prepare axes for pan (using 'matplotlib' pan function) self.pan_axes = [] for a in self.figure.get_axes(): if (event.x is not None and event.y is not None and a.in_axes(event) and a.get_navigate() and a.can_pan()): a.start_pan(event.x, event.y, 1) self.pan_axes.append(a) # Set pan view flag if len(self.pan_axes) > 0: self.panning = True if event.dblclick: self.double_click.emit(event) def on_mouse_release(self, event): mouse_release_pos = (event.x, event.y) delta = 0.05 if abs(self.distance(self.mouse_press_pos, mouse_release_pos)) < delta: self.is_dragging = False # Check for middle mouse button release to complete pan procedure # Check for middle mouse button press if self.app.defaults["global_pan_button"] == '2': pan_button = 3 # right button for Matplotlib else: pan_button = 2 # middle button for Matplotlib if event.button == pan_button: for a in self.pan_axes: a.end_pan() # Clear pan flag self.panning = False # And update the cursor if self.app.defaults["global_cursor_color_enabled"] is True: self.draw_cursor(x_pos=self.mouse[0], y_pos=self.mouse[1], color=self.app.cursor_color_3D) else: self.draw_cursor(x_pos=self.mouse[0], y_pos=self.mouse[1]) def on_mouse_move(self, event): """ Mouse movement event handler. Stores the coordinates. Updates view on pan. :param event: Contains information about the event. :return: None """ try: x = float(event.xdata) y = float(event.ydata) except TypeError: return self.mouse = [event.xdata, event.ydata] self.canvas.restore_region(self.background) # Update pan view on mouse move if self.panning is True: for a in self.pan_axes: a.drag_pan(1, event.key, event.x, event.y) # x_pan, y_pan = self.app.geo_editor.snap(event.xdata, event.ydata) # self.draw_cursor(x_pos=x_pan, y_pos=y_pan) # Async re-draw (redraws only on thread idle state, uses timer on backend) self.canvas.draw_idle() # #### Temporary place-holder for cached update ##### # self.update_screen_request.emit([0, 0, 0, 0, 0]) if self.app.defaults["global_cursor_color_enabled"] is True: self.draw_cursor(x_pos=x, y_pos=y, color=self.app.cursor_color_3D) else: self.draw_cursor(x_pos=x, y_pos=y) # self.canvas.blit(self.axes.bbox) def translate_coords(self, position): """ This does not do much. It's just for code compatibility :param position: Mouse event position :return: Tuple with mouse position """ return position[0], position[1] def on_draw(self, renderer): # Store background on canvas redraw self.background = self.canvas.copy_from_bbox(self.axes.bbox) def get_axes_pixelsize(self): """ Axes size in pixels. :return: Pixel width and height :rtype: tuple """ bbox = self.axes.get_window_extent().transformed(self.figure.dpi_scale_trans.inverted()) width, height = bbox.width, bbox.height width *= self.figure.dpi height *= self.figure.dpi return width, height def get_density(self): """ Returns unit length per pixel on horizontal and vertical axes. :return: X and Y density :rtype: tuple """ xpx, ypx = self.get_axes_pixelsize() xmin, xmax = self.axes.get_xlim() ymin, ymax = self.axes.get_ylim() width = xmax - xmin height = ymax - ymin return width / xpx, height / ypx 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 # ### Grid snap if self.app.grid_status(): if self.app.defaults["global_gridx"] != 0: try: snap_x_ = round(x / float(self.app.defaults["global_gridx"])) * \ float(self.app.defaults["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.app.defaults["global_gridx"] != 0: try: snap_y_ = round(y / float(self.app.defaults["global_gridx"])) * \ float(self.app.defaults["global_gridx"]) except TypeError: snap_y_ = y else: snap_y_ = y else: if self.app.defaults["global_gridy"] != 0: try: snap_y_ = round(y / float(self.app.defaults["global_gridy"])) * \ float(self.app.defaults["global_gridy"]) except TypeError: snap_y_ = y else: snap_y_ = y nearest_grid_distance = self.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 @staticmethod def distance(pt1, pt2): return np.sqrt((pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) ** 2) class FakeCursor(QtCore.QObject): """ This is a fake cursor to ensure compatibility with the OpenGL engine (VisPy). This way I don't have to chane (disable) things related to the cursor all over when using the low performance Matplotlib 2D graphic engine. """ mouse_state_updated = pyqtSignal(bool) def __init__(self): super().__init__() self._enabled = True @property def enabled(self): return True if self._enabled else False @enabled.setter def enabled(self, value): self._enabled = value self.mouse_state_updated.emit(value) def set_data(self, pos, **kwargs): """Internal event handler to draw the cursor when the mouse moves.""" return class ShapeCollectionLegacy: """ This will create the axes for each collection of shapes and will also hold the collection of shapes into a dict self._shapes. This handles the shapes redraw on canvas. """ def __init__(self, obj, app, name=None, annotation_job=None, linewidth=1): """ :param obj: This is the object to which the shapes collection is attached and for which it will have to draw shapes :param app: This is the FLatCAM.App usually, needed because we have to access attributes there :param name: This is the name given to the Matplotlib axes; it needs to be unique due of Matplotlib requurements :param annotation_job: Make this True if the job needed is just for annotation :param linewidth: THe width of the line (outline where is the case) """ self.obj = obj self.app = app self.annotation_job = annotation_job self._shapes = {} self.shape_dict = {} self.shape_id = 0 self._color = None self._face_color = None self._visible = True self._update = False self._alpha = None self._tool_tolerance = None self._tooldia = None self._obj = None self._gcode_parsed = None self._linewidth = linewidth if name is None: axes_name = self.obj.options['name'] else: axes_name = name # Axes must exist and be attached to canvas. if axes_name not in self.app.plotcanvas.figure.axes: self.axes = self.app.plotcanvas.new_axes(axes_name) def add(self, shape=None, color=None, face_color=None, alpha=None, visible=True, update=False, layer=1, tolerance=0.01, obj=None, gcode_parsed=None, tool_tolerance=None, tooldia=None, linewidth=None): """ This function will add shapes to the shape collection :param shape: the Shapely shape to be added to the shape collection :param color: edge color of the shape, hex value :param face_color: the body color of the shape, hex value :param alpha: level of transparency of the shape [0.0 ... 1.0]; Float :param visible: if True will allow the shapes to be added :param update: not used; just for compatibility with VIsPy canvas :param layer: just for compatibility with VIsPy canvas :param tolerance: just for compatibility with VIsPy canvas :param obj: not used :param gcode_parsed: not used; just for compatibility with VIsPy canvas :param tool_tolerance: just for compatibility with VIsPy canvas :param tooldia: :param linewidth: the width of the line :return: """ self._color = color if color is not None else "#006E20" # self._face_color = face_color if face_color is not None else "#BBF268" self._face_color = face_color if linewidth is None: line_width = self._linewidth else: line_width = linewidth if len(self._color) > 7: self._color = self._color[:7] if self._face_color is not None: if len(self._face_color) > 7: self._face_color = self._face_color[:7] # self._alpha = int(self._face_color[-2:], 16) / 255 self._alpha = 0.75 if alpha is not None: self._alpha = alpha self._visible = visible self._update = update # CNCJob object related arguments self._obj = obj self._gcode_parsed = gcode_parsed self._tool_tolerance = tool_tolerance self._tooldia = tooldia # if self._update: # self.clear() try: for sh in shape: self.shape_id += 1 self.shape_dict.update({ 'color': self._color, 'face_color': self._face_color, 'linewidth': line_width, 'alpha': self._alpha, 'visible': self._visible, 'shape': sh }) self._shapes.update({ self.shape_id: deepcopy(self.shape_dict) }) except TypeError: self.shape_id += 1 self.shape_dict.update({ 'color': self._color, 'face_color': self._face_color, 'linewidth': line_width, 'alpha': self._alpha, 'visible': self._visible, 'shape': shape }) self._shapes.update({ self.shape_id: deepcopy(self.shape_dict) }) return self.shape_id def remove(self, shape_id, update=None): for k in list(self._shapes.keys()): if shape_id == k: self._shapes.pop(k, None) if update is True: self.redraw() def clear(self, update=None): """ Clear the canvas of the shapes. :param update: :return: None """ self._shapes.clear() self.shape_id = 0 self.axes.cla() try: self.app.plotcanvas.auto_adjust_axes() except Exception as e: log.debug("ShapeCollectionLegacy.clear() --> %s" % str(e)) if update is True: self.redraw() def redraw(self, update_colors=None): """ This draw the shapes in the shapes collection, on canvas :return: None """ path_num = 0 local_shapes = deepcopy(self._shapes) try: obj_type = self.obj.kind except AttributeError: obj_type = 'utility' # if we don't use this then when adding each new shape, the old ones will be added again, too # if obj_type == 'utility': # self.axes.patches.clear() self.axes.patches.clear() for element in local_shapes: if local_shapes[element]['visible'] is True: if obj_type == 'excellon': # Plot excellon (All polygons?) if self.obj.options["solid"] and isinstance(local_shapes[element]['shape'], Polygon): try: patch = PolygonPatch(local_shapes[element]['shape'], facecolor=local_shapes[element]['face_color'], edgecolor=local_shapes[element]['color'], alpha=local_shapes[element]['alpha'], zorder=3, linewidth=local_shapes[element]['linewidth'] ) self.axes.add_patch(patch) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() excellon poly --> %s" % str(e)) else: try: if isinstance(local_shapes[element]['shape'], Polygon): x, y = local_shapes[element]['shape'].exterior.coords.xy self.axes.plot(x, y, 'r-', linewidth=local_shapes[element]['linewidth']) for ints in local_shapes[element]['shape'].interiors: x, y = ints.coords.xy self.axes.plot(x, y, 'o-', linewidth=local_shapes[element]['linewidth']) elif isinstance(local_shapes[element]['shape'], LinearRing): x, y = local_shapes[element]['shape'].coords.xy self.axes.plot(x, y, 'r-', linewidth=local_shapes[element]['linewidth']) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() excellon no poly --> %s" % str(e)) elif obj_type == 'geometry': if type(local_shapes[element]['shape']) == Polygon: try: x, y = local_shapes[element]['shape'].exterior.coords.xy self.axes.plot(x, y, local_shapes[element]['color'], linestyle='-', linewidth=local_shapes[element]['linewidth']) for ints in local_shapes[element]['shape'].interiors: x, y = ints.coords.xy self.axes.plot(x, y, local_shapes[element]['color'], linestyle='-', linewidth=local_shapes[element]['linewidth']) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() geometry poly --> %s" % str(e)) elif type(local_shapes[element]['shape']) == LineString or \ type(local_shapes[element]['shape']) == LinearRing: try: x, y = local_shapes[element]['shape'].coords.xy self.axes.plot(x, y, local_shapes[element]['color'], linestyle='-', linewidth=local_shapes[element]['linewidth']) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() geometry no poly --> %s" % str(e)) elif obj_type == 'gerber': if self.obj.options["multicolored"]: linespec = '-' else: linespec = 'k-' if self.obj.options["solid"]: if update_colors: gerber_fill_color = update_colors[0] gerber_outline_color = update_colors[1] else: gerber_fill_color = local_shapes[element]['face_color'] gerber_outline_color = local_shapes[element]['color'] try: patch = PolygonPatch(local_shapes[element]['shape'], facecolor=gerber_fill_color, edgecolor=gerber_outline_color, alpha=local_shapes[element]['alpha'], zorder=2, linewidth=local_shapes[element]['linewidth']) self.axes.add_patch(patch) except AssertionError: log.warning("A geometry component was not a polygon:") log.warning(str(element)) except Exception as e: log.debug( "PlotCanvasLegacy.ShepeCollectionLegacy.redraw() gerber 'solid' --> %s" % str(e)) else: try: x, y = local_shapes[element]['shape'].exterior.xy self.axes.plot(x, y, linespec, linewidth=local_shapes[element]['linewidth']) for ints in local_shapes[element]['shape'].interiors: x, y = ints.coords.xy self.axes.plot(x, y, linespec, linewidth=local_shapes[element]['linewidth']) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() gerber no 'solid' --> %s" % str(e)) elif obj_type == 'cncjob': if local_shapes[element]['face_color'] is None: try: linespec = '--' linecolor = local_shapes[element]['color'] # if geo['kind'][0] == 'C': # linespec = 'k-' x, y = local_shapes[element]['shape'].coords.xy self.axes.plot(x, y, linespec, color=linecolor, linewidth=local_shapes[element]['linewidth']) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() cncjob with face_color --> %s" % str(e)) else: try: path_num += 1 if self.obj.ui.annotation_cb.get_value(): if isinstance(local_shapes[element]['shape'], Polygon): self.axes.annotate( str(path_num), xy=local_shapes[element]['shape'].exterior.coords[0], xycoords='data', fontsize=20) else: self.axes.annotate( str(path_num), xy=local_shapes[element]['shape'].coords[0], xycoords='data', fontsize=20) patch = PolygonPatch(local_shapes[element]['shape'], facecolor=local_shapes[element]['face_color'], edgecolor=local_shapes[element]['color'], alpha=local_shapes[element]['alpha'], zorder=2, linewidth=local_shapes[element]['linewidth']) self.axes.add_patch(patch) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() cncjob no face_color --> %s" % str(e)) elif obj_type == 'utility': # not a FlatCAM object, must be utility if local_shapes[element]['face_color']: try: patch = PolygonPatch(local_shapes[element]['shape'], facecolor=local_shapes[element]['face_color'], edgecolor=local_shapes[element]['color'], alpha=local_shapes[element]['alpha'], zorder=2, linewidth=local_shapes[element]['linewidth']) self.axes.add_patch(patch) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() utility poly with face_color --> %s" % str(e)) else: if isinstance(local_shapes[element]['shape'], Polygon): try: ext_shape = local_shapes[element]['shape'].exterior if ext_shape is not None: x, y = ext_shape.xy self.axes.plot(x, y, local_shapes[element]['color'], linestyle='-', linewidth=local_shapes[element]['linewidth']) for ints in local_shapes[element]['shape'].interiors: if ints is not None: x, y = ints.coords.xy self.axes.plot(x, y, local_shapes[element]['color'], linestyle='-', linewidth=local_shapes[element]['linewidth']) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() utility poly no face_color --> %s" % str(e)) else: try: if local_shapes[element]['shape'] is not None: x, y = local_shapes[element]['shape'].coords.xy self.axes.plot(x, y, local_shapes[element]['color'], linestyle='-', linewidth=local_shapes[element]['linewidth']) except Exception as e: log.debug("ShapeCollectionLegacy.redraw() utility lines no face_color --> %s" % str(e)) self.app.plotcanvas.auto_adjust_axes() def set(self, text, pos, visible=True, font_size=16, color=None): """ This will set annotations on the canvas. :param text: a list of text elements to be used as annotations :param pos: a list of positions for showing the text elements above :param visible: if True will display annotations, if False will clear them on canvas :param font_size: the font size or the annotations :param color: color of the annotations :return: None """ if color is None: color = "#000000FF" if visible is not True: self.clear() return if len(text) != len(pos): self.app.inform.emit('[ERROR_NOTCL] %s' % _("Could not annotate due of a difference between the number " "of text elements and the number of text positions.")) return for idx in range(len(text)): try: self.axes.annotate(text[idx], xy=pos[idx], xycoords='data', fontsize=font_size, color=color) except Exception as e: log.debug("ShapeCollectionLegacy.set() --> %s" % str(e)) self.app.plotcanvas.auto_adjust_axes() @property def visible(self): return self._visible @visible.setter def visible(self, value): if value is False: self.axes.cla() self.app.plotcanvas.auto_adjust_axes() else: if self._visible is False: self.redraw() self._visible = value def update_visibility(self, state, indexes=None): if indexes: for i in indexes: if i in self._shapes: self._shapes[i]['visible'] = state else: for i in self._shapes: self._shapes[i]['visible'] = state self.redraw() @property def enabled(self): return self._visible @enabled.setter def enabled(self, value): if value is False: self.axes.cla() self.app.plotcanvas.auto_adjust_axes() else: if self._visible is False: self.redraw() self._visible = value # class MplCursor(Cursor): # """ # Unfortunately this gets attached to the current axes and if a new axes is added # it will not be showed until that axes is deleted. # Not the kind of behavior needed here so I don't use it anymore. # """ # def __init__(self, axes, color='red', linewidth=1): # # super().__init__(ax=axes, useblit=True, color=color, linewidth=linewidth) # self._enabled = True # # self.axes = axes # self.color = color # self.linewidth = linewidth # # self.x = None # self.y = None # # @property # def enabled(self): # return True if self._enabled else False # # @enabled.setter # def enabled(self, value): # self._enabled = value # self.visible = self._enabled # self.canvas.draw() # # def onmove(self, event): # pass # # def set_data(self, event, pos): # """Internal event handler to draw the cursor when the mouse moves.""" # self.x = pos[0] # self.y = pos[1] # # if self.ignore(event): # return # if not self.canvas.widgetlock.available(self): # return # if event.inaxes != self.ax: # self.linev.set_visible(False) # self.lineh.set_visible(False) # # if self.needclear: # self.canvas.draw() # self.needclear = False # return # self.needclear = True # if not self.visible: # return # self.linev.set_xdata((self.x, self.x)) # # self.lineh.set_ydata((self.y, self.y)) # self.linev.set_visible(self.visible and self.vertOn) # self.lineh.set_visible(self.visible and self.horizOn) # # self._update()