1532 lines
50 KiB
Python
1532 lines
50 KiB
Python
############################################################
|
|
# FlatCAM: 2D Post-processing for Manufacturing #
|
|
# http://flatcam.org #
|
|
# Author: Juan Pablo Caram (c) #
|
|
# Date: 2/5/2014 #
|
|
# MIT Licence #
|
|
############################################################
|
|
|
|
from PyQt4 import QtGui, QtCore, Qt
|
|
import FlatCAMApp
|
|
from camlib import *
|
|
from FlatCAMTool import FlatCAMTool
|
|
from ObjectUI import LengthEntry, RadioSet
|
|
|
|
from shapely.geometry import Polygon, LineString, Point, LinearRing
|
|
from shapely.geometry import MultiPoint, MultiPolygon
|
|
from shapely.geometry import box as shply_box
|
|
from shapely.ops import cascaded_union, unary_union
|
|
import shapely.affinity as affinity
|
|
from shapely.wkt import loads as sloads
|
|
from shapely.wkt import dumps as sdumps
|
|
from shapely.geometry.base import BaseGeometry
|
|
|
|
from numpy import arctan2, Inf, array, sqrt, pi, ceil, sin, cos, sign, dot
|
|
from numpy.linalg import solve
|
|
|
|
#from mpl_toolkits.axes_grid.anchored_artists import AnchoredDrawingArea
|
|
|
|
from rtree import index as rtindex
|
|
|
|
|
|
class BufferSelectionTool(FlatCAMTool):
|
|
"""
|
|
Simple input for buffer distance.
|
|
"""
|
|
|
|
toolName = "Buffer Selection"
|
|
|
|
def __init__(self, app, fcdraw):
|
|
FlatCAMTool.__init__(self, app)
|
|
|
|
self.fcdraw = fcdraw
|
|
|
|
## Title
|
|
title_label = QtGui.QLabel("<font size=4><b>%s</b></font>" % self.toolName)
|
|
self.layout.addWidget(title_label)
|
|
|
|
## Form Layout
|
|
form_layout = QtGui.QFormLayout()
|
|
self.layout.addLayout(form_layout)
|
|
|
|
## Buffer distance
|
|
self.buffer_distance_entry = LengthEntry()
|
|
form_layout.addRow("Buffer distance:", self.buffer_distance_entry)
|
|
|
|
## Buttons
|
|
hlay = QtGui.QHBoxLayout()
|
|
self.layout.addLayout(hlay)
|
|
hlay.addStretch()
|
|
self.buffer_button = QtGui.QPushButton("Buffer")
|
|
hlay.addWidget(self.buffer_button)
|
|
|
|
self.layout.addStretch()
|
|
|
|
## Signals
|
|
self.buffer_button.clicked.connect(self.on_buffer)
|
|
|
|
def on_buffer(self):
|
|
buffer_distance = self.buffer_distance_entry.get_value()
|
|
self.fcdraw.buffer(buffer_distance)
|
|
|
|
|
|
class PaintOptionsTool(FlatCAMTool):
|
|
"""
|
|
Inputs to specify how to paint the selected polygons.
|
|
"""
|
|
|
|
toolName = "Paint Options"
|
|
|
|
def __init__(self, app, fcdraw):
|
|
FlatCAMTool.__init__(self, app)
|
|
|
|
self.app = app
|
|
self.fcdraw = fcdraw
|
|
|
|
## Title
|
|
title_label = QtGui.QLabel("<font size=4><b>%s</b></font>" % self.toolName)
|
|
self.layout.addWidget(title_label)
|
|
|
|
## Form Layout
|
|
form_layout = QtGui.QFormLayout()
|
|
self.layout.addLayout(form_layout)
|
|
|
|
# Tool dia
|
|
ptdlabel = QtGui.QLabel('Tool dia:')
|
|
ptdlabel.setToolTip(
|
|
"Diameter of the tool to\n"
|
|
"be used in the operation."
|
|
)
|
|
|
|
self.painttooldia_entry = LengthEntry()
|
|
form_layout.addRow(ptdlabel, self.painttooldia_entry)
|
|
|
|
# Overlap
|
|
ovlabel = QtGui.QLabel('Overlap:')
|
|
ovlabel.setToolTip(
|
|
"How much (fraction) of the tool\n"
|
|
"width to overlap each tool pass."
|
|
)
|
|
|
|
self.paintoverlap_entry = LengthEntry()
|
|
form_layout.addRow(ovlabel, self.paintoverlap_entry)
|
|
|
|
# Margin
|
|
marginlabel = QtGui.QLabel('Margin:')
|
|
marginlabel.setToolTip(
|
|
"Distance by which to avoid\n"
|
|
"the edges of the polygon to\n"
|
|
"be painted."
|
|
)
|
|
|
|
self.paintmargin_entry = LengthEntry()
|
|
form_layout.addRow(marginlabel, self.paintmargin_entry)
|
|
|
|
# Method
|
|
methodlabel = QtGui.QLabel('Method:')
|
|
methodlabel.setToolTip(
|
|
"Algorithm to paint the polygon:<BR>"
|
|
"<B>Standard</B>: Fixed step inwards.<BR>"
|
|
"<B>Seed-based</B>: Outwards from seed."
|
|
)
|
|
|
|
self.paintmethod_combo = RadioSet([
|
|
{"label": "Standard", "value": "standard"},
|
|
{"label": "Seed-based", "value": "seed"}
|
|
])
|
|
form_layout.addRow(methodlabel, self.paintmethod_combo)
|
|
|
|
## Buttons
|
|
hlay = QtGui.QHBoxLayout()
|
|
self.layout.addLayout(hlay)
|
|
hlay.addStretch()
|
|
self.paint_button = QtGui.QPushButton("Paint")
|
|
hlay.addWidget(self.paint_button)
|
|
|
|
self.layout.addStretch()
|
|
|
|
## Signals
|
|
self.paint_button.clicked.connect(self.on_paint)
|
|
|
|
def on_paint(self):
|
|
|
|
tooldia = self.painttooldia_entry.get_value()
|
|
overlap = self.paintoverlap_entry.get_value()
|
|
margin = self.paintoverlap_entry.get_value()
|
|
method = self.paintmethod_combo.get_value()
|
|
|
|
self.fcdraw.paint(tooldia, overlap, margin, method)
|
|
|
|
|
|
class DrawToolShape(object):
|
|
"""
|
|
Encapsulates "shapes" under a common class.
|
|
"""
|
|
|
|
@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: geometric object
|
|
:return: List of points
|
|
:rtype: list
|
|
"""
|
|
pts = []
|
|
|
|
## Iterable: descend into each item.
|
|
try:
|
|
for subo in o:
|
|
pts += DrawToolShape.get_pts(subo)
|
|
|
|
## Non-iterable
|
|
except TypeError:
|
|
|
|
## DrawToolShape: descend into .geo.
|
|
if isinstance(o, DrawToolShape):
|
|
pts += DrawToolShape.get_pts(o.geo)
|
|
|
|
## Descend into .exerior and .interiors
|
|
elif type(o) == Polygon:
|
|
pts += DrawToolShape.get_pts(o.exterior)
|
|
for i in o.interiors:
|
|
pts += DrawToolShape.get_pts(i)
|
|
|
|
## Has .coords: list them.
|
|
else:
|
|
pts += list(o.coords)
|
|
|
|
return pts
|
|
|
|
def __init__(self, geo=[]):
|
|
|
|
# Shapely type or list of such
|
|
self.geo = geo
|
|
self.utility = False
|
|
|
|
def get_all_points(self):
|
|
return DrawToolShape.get_pts(self)
|
|
|
|
|
|
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=[]):
|
|
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.start_msg = "Click on 1st point..."
|
|
self.points = []
|
|
self.geometry = None # DrawToolShape or None
|
|
|
|
def click(self, point):
|
|
"""
|
|
:param point: [x, y] Coordinate pair.
|
|
"""
|
|
return ""
|
|
|
|
def on_key(self, key):
|
|
return None
|
|
|
|
def utility_geometry(self, data=None):
|
|
return None
|
|
|
|
|
|
class FCShapeTool(DrawTool):
|
|
"""
|
|
Abstarct class for tools that create a shape.
|
|
"""
|
|
def __init__(self, draw_app):
|
|
DrawTool.__init__(self, draw_app)
|
|
|
|
def make(self):
|
|
pass
|
|
|
|
|
|
class FCCircle(FCShapeTool):
|
|
"""
|
|
Resulting type: Polygon
|
|
"""
|
|
|
|
def __init__(self, draw_app):
|
|
DrawTool.__init__(self, draw_app)
|
|
self.start_msg = "Click on CENTER ..."
|
|
|
|
def click(self, point):
|
|
self.points.append(point)
|
|
|
|
if len(self.points) == 1:
|
|
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 = sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
|
|
return DrawToolUtilityShape(Point(p1).buffer(radius))
|
|
|
|
return None
|
|
|
|
def make(self):
|
|
p1 = self.points[0]
|
|
p2 = self.points[1]
|
|
radius = distance(p1, p2)
|
|
self.geometry = DrawToolShape(Point(p1).buffer(radius))
|
|
self.complete = True
|
|
|
|
|
|
class FCArc(FCShapeTool):
|
|
def __init__(self, draw_app):
|
|
DrawTool.__init__(self, draw_app)
|
|
self.start_msg = "Click on CENTER ..."
|
|
|
|
# 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.steps_per_circ = 55
|
|
|
|
def click(self, point):
|
|
self.points.append(point)
|
|
|
|
if len(self.points) == 1:
|
|
return "Click on 1st point ..."
|
|
|
|
if len(self.points) == 2:
|
|
return "Click on 2nd point to complete ..."
|
|
|
|
if len(self.points) == 3:
|
|
self.make()
|
|
return "Done."
|
|
|
|
return ""
|
|
|
|
def on_key(self, key):
|
|
if key == 'o':
|
|
self.direction = 'cw' if self.direction == 'ccw' else 'ccw'
|
|
return 'Direction: ' + self.direction.upper()
|
|
|
|
if key == 'p':
|
|
if self.mode == 'c12':
|
|
self.mode = '12c'
|
|
elif self.mode == '12c':
|
|
self.mode = '132'
|
|
else:
|
|
self.mode = 'c12'
|
|
return 'Mode: ' + self.mode
|
|
|
|
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 = sqrt((center[0] - p1[0]) ** 2 + (center[1] - p1[1]) ** 2)
|
|
startangle = arctan2(p1[1] - center[1], p1[0] - center[0])
|
|
stopangle = 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 = array(self.points[0])
|
|
p3 = array(self.points[1])
|
|
p2 = array(data)
|
|
|
|
center, radius, t = three_point_circle(p1, p2, p3)
|
|
direction = 'cw' if sign(t) > 0 else 'ccw'
|
|
|
|
startangle = arctan2(p1[1] - center[1], p1[0] - center[0])
|
|
stopangle = 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 = array(self.points[0])
|
|
p2 = array(self.points[1])
|
|
|
|
# Midpoint
|
|
a = (p1 + p2) / 2.0
|
|
|
|
# Parallel vector
|
|
c = p2 - p1
|
|
|
|
# Perpendicular vector
|
|
b = dot(c, array([[0, -1], [1, 0]], dtype=float32))
|
|
b /= 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 *= sign(side)
|
|
|
|
# Center = a + bt
|
|
center = a + b * t
|
|
|
|
radius = norm(center - p1)
|
|
startangle = arctan2(p1[1] - center[1], p1[0] - center[0])
|
|
stopangle = 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 = arctan2(p1[1] - center[1], p1[0] - center[0])
|
|
stopangle = 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 = array(self.points[0])
|
|
p3 = array(self.points[1])
|
|
p2 = array(self.points[2])
|
|
|
|
center, radius, t = three_point_circle(p1, p2, p3)
|
|
direction = 'cw' if sign(t) > 0 else 'ccw'
|
|
|
|
startangle = arctan2(p1[1] - center[1], p1[0] - center[0])
|
|
stopangle = 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 = array(self.points[0])
|
|
p2 = array(self.points[1])
|
|
pc = array(self.points[2])
|
|
|
|
# Midpoint
|
|
a = (p1 + p2) / 2.0
|
|
|
|
# Parallel vector
|
|
c = p2 - p1
|
|
|
|
# Perpendicular vector
|
|
b = dot(c, array([[0, -1], [1, 0]], dtype=float32))
|
|
b /= 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 *= sign(side)
|
|
|
|
# Center = a + bt
|
|
center = a + b * t
|
|
|
|
radius = norm(center - p1)
|
|
startangle = arctan2(p1[1] - center[1], p1[0] - center[0])
|
|
stopangle = 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
|
|
|
|
|
|
class FCRectangle(FCShapeTool):
|
|
"""
|
|
Resulting type: Polygon
|
|
"""
|
|
|
|
def __init__(self, draw_app):
|
|
DrawTool.__init__(self, draw_app)
|
|
self.start_msg = "Click on 1st corner ..."
|
|
|
|
def click(self, point):
|
|
self.points.append(point)
|
|
|
|
if len(self.points) == 1:
|
|
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):
|
|
p1 = self.points[0]
|
|
p2 = self.points[1]
|
|
#self.geometry = LinearRing([p1, (p2[0], p1[1]), p2, (p1[0], p2[1])])
|
|
self.geometry = DrawToolShape(Polygon([p1, (p2[0], p1[1]), p2, (p1[0], p2[1])]))
|
|
self.complete = True
|
|
|
|
|
|
class FCPolygon(FCShapeTool):
|
|
"""
|
|
Resulting type: Polygon
|
|
"""
|
|
|
|
def __init__(self, draw_app):
|
|
DrawTool.__init__(self, draw_app)
|
|
self.start_msg = "Click on 1st point ..."
|
|
|
|
def click(self, point):
|
|
self.points.append(point)
|
|
|
|
if len(self.points) > 0:
|
|
return "Click on next point or hit SPACE to complete ..."
|
|
|
|
return ""
|
|
|
|
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))
|
|
|
|
if len(self.points) > 1:
|
|
temp_points = [x for x in self.points]
|
|
temp_points.append(data)
|
|
return DrawToolUtilityShape(LinearRing(temp_points))
|
|
|
|
return None
|
|
|
|
def make(self):
|
|
# self.geometry = LinearRing(self.points)
|
|
self.geometry = DrawToolShape(Polygon(self.points))
|
|
self.complete = True
|
|
|
|
def on_key(self, key):
|
|
if key == 'backspace':
|
|
if len(self.points) > 0:
|
|
self.points = self.points[0:-1]
|
|
|
|
|
|
class FCPath(FCPolygon):
|
|
"""
|
|
Resulting type: LineString
|
|
"""
|
|
|
|
def make(self):
|
|
self.geometry = DrawToolShape(LineString(self.points))
|
|
self.complete = True
|
|
|
|
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 on_key(self, key):
|
|
if key == 'backspace':
|
|
if len(self.points) > 0:
|
|
self.points = self.points[0:-1]
|
|
|
|
|
|
class FCSelect(DrawTool):
|
|
def __init__(self, draw_app):
|
|
DrawTool.__init__(self, draw_app)
|
|
self.storage = self.draw_app.storage
|
|
#self.shape_buffer = self.draw_app.shape_buffer
|
|
self.selected = self.draw_app.selected
|
|
self.start_msg = "Click on geometry to select"
|
|
|
|
def click(self, point):
|
|
try:
|
|
_, closest_shape = self.storage.nearest(point)
|
|
except StopIteration:
|
|
return ""
|
|
|
|
if self.draw_app.key != 'control':
|
|
self.draw_app.selected = []
|
|
|
|
self.draw_app.set_selected(closest_shape)
|
|
self.draw_app.app.log.debug("Selected shape containing: " + str(closest_shape.geo))
|
|
|
|
return ""
|
|
|
|
|
|
class FCMove(FCShapeTool):
|
|
def __init__(self, draw_app):
|
|
FCShapeTool.__init__(self, draw_app)
|
|
#self.shape_buffer = self.draw_app.shape_buffer
|
|
self.origin = None
|
|
self.destination = None
|
|
self.start_msg = "Click on reference point."
|
|
|
|
def set_origin(self, origin):
|
|
self.origin = origin
|
|
|
|
def click(self, point):
|
|
if len(self.draw_app.get_selected()) == 0:
|
|
return "Nothing to move."
|
|
|
|
if self.origin is None:
|
|
self.set_origin(point)
|
|
return "Click on final location."
|
|
else:
|
|
self.destination = point
|
|
self.make()
|
|
return "Done."
|
|
|
|
def make(self):
|
|
# Create new geometry
|
|
dx = self.destination[0] - self.origin[0]
|
|
dy = self.destination[1] - self.origin[1]
|
|
self.geometry = [DrawToolShape(affinity.translate(geom.geo, xoff=dx, yoff=dy))
|
|
for geom in self.draw_app.get_selected()]
|
|
|
|
# Delete old
|
|
self.draw_app.delete_selected()
|
|
|
|
# # Select the new
|
|
# for g in self.geometry:
|
|
# # Note that g is not in the app's buffer yet!
|
|
# self.draw_app.set_selected(g)
|
|
|
|
self.complete = True
|
|
|
|
def utility_geometry(self, data=None):
|
|
"""
|
|
Temporary geometry on screen while using this tool.
|
|
|
|
:param data:
|
|
:return:
|
|
"""
|
|
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]
|
|
|
|
return DrawToolUtilityShape([affinity.translate(geom.geo, xoff=dx, yoff=dy)
|
|
for geom in self.draw_app.get_selected()])
|
|
|
|
|
|
class FCCopy(FCMove):
|
|
def make(self):
|
|
# Create new geometry
|
|
dx = self.destination[0] - self.origin[0]
|
|
dy = self.destination[1] - self.origin[1]
|
|
self.geometry = [DrawToolShape(affinity.translate(geom.geo, xoff=dx, yoff=dy))
|
|
for geom in self.draw_app.get_selected()]
|
|
self.complete = True
|
|
|
|
|
|
########################
|
|
### Main Application ###
|
|
########################
|
|
class FlatCAMDraw(QtCore.QObject):
|
|
def __init__(self, app, disabled=False):
|
|
assert isinstance(app, FlatCAMApp.App), \
|
|
"Expected the app to be a FlatCAMApp.App, got %s" % type(app)
|
|
|
|
super(FlatCAMDraw, self).__init__()
|
|
|
|
self.app = app
|
|
self.canvas = app.plotcanvas
|
|
self.axes = self.canvas.new_axes("draw")
|
|
|
|
### Drawing Toolbar ###
|
|
self.drawing_toolbar = QtGui.QToolBar()
|
|
self.drawing_toolbar.setDisabled(disabled)
|
|
self.app.ui.addToolBar(self.drawing_toolbar)
|
|
self.select_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/pointer32.png'), "Select 'Esc'")
|
|
self.add_circle_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/circle32.png'), 'Add Circle')
|
|
self.add_arc_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/arc32.png'), 'Add Arc')
|
|
self.add_rectangle_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/rectangle32.png'), 'Add Rectangle')
|
|
self.add_polygon_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/polygon32.png'), 'Add Polygon')
|
|
self.add_path_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/path32.png'), 'Add Path')
|
|
self.union_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/union32.png'), 'Polygon Union')
|
|
self.intersection_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/intersection32.png'), 'Polygon Intersection')
|
|
self.subtract_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/subtract32.png'), 'Polygon Subtraction')
|
|
self.cutpath_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/cutpath32.png'), 'Cut Path')
|
|
self.move_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/move32.png'), "Move Objects 'm'")
|
|
self.copy_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/copy32.png'), "Copy Objects 'c'")
|
|
self.delete_btn = self.drawing_toolbar.addAction(QtGui.QIcon('share/deleteshape32.png'), "Delete Shape '-'")
|
|
|
|
### Snap Toolbar ###
|
|
self.snap_toolbar = QtGui.QToolBar()
|
|
self.grid_snap_btn = self.snap_toolbar.addAction(QtGui.QIcon('share/grid32.png'), 'Snap to grid')
|
|
self.grid_gap_x_entry = QtGui.QLineEdit()
|
|
self.grid_gap_x_entry.setMaximumWidth(70)
|
|
self.grid_gap_x_entry.setToolTip("Grid X distance")
|
|
self.snap_toolbar.addWidget(self.grid_gap_x_entry)
|
|
self.grid_gap_y_entry = QtGui.QLineEdit()
|
|
self.grid_gap_y_entry.setMaximumWidth(70)
|
|
self.grid_gap_y_entry.setToolTip("Grid Y distante")
|
|
self.snap_toolbar.addWidget(self.grid_gap_y_entry)
|
|
|
|
self.corner_snap_btn = self.snap_toolbar.addAction(QtGui.QIcon('share/corner32.png'), 'Snap to corner')
|
|
self.snap_max_dist_entry = QtGui.QLineEdit()
|
|
self.snap_max_dist_entry.setMaximumWidth(70)
|
|
self.snap_max_dist_entry.setToolTip("Max. magnet distance")
|
|
self.snap_toolbar.addWidget(self.snap_max_dist_entry)
|
|
|
|
self.snap_toolbar.setDisabled(disabled)
|
|
self.app.ui.addToolBar(self.snap_toolbar)
|
|
|
|
### Application menu ###
|
|
self.menu = QtGui.QMenu("Drawing")
|
|
self.app.ui.menu.insertMenu(self.app.ui.menutoolaction, self.menu)
|
|
# self.select_menuitem = self.menu.addAction(QtGui.QIcon('share/pointer16.png'), "Select 'Esc'")
|
|
# self.add_circle_menuitem = self.menu.addAction(QtGui.QIcon('share/circle16.png'), 'Add Circle')
|
|
# self.add_arc_menuitem = self.menu.addAction(QtGui.QIcon('share/arc16.png'), 'Add Arc')
|
|
# self.add_rectangle_menuitem = self.menu.addAction(QtGui.QIcon('share/rectangle16.png'), 'Add Rectangle')
|
|
# self.add_polygon_menuitem = self.menu.addAction(QtGui.QIcon('share/polygon16.png'), 'Add Polygon')
|
|
# self.add_path_menuitem = self.menu.addAction(QtGui.QIcon('share/path16.png'), 'Add Path')
|
|
self.union_menuitem = self.menu.addAction(QtGui.QIcon('share/union16.png'), 'Polygon Union')
|
|
self.intersection_menuitem = self.menu.addAction(QtGui.QIcon('share/intersection16.png'), 'Polygon Intersection')
|
|
# self.subtract_menuitem = self.menu.addAction(QtGui.QIcon('share/subtract16.png'), 'Polygon Subtraction')
|
|
self.cutpath_menuitem = self.menu.addAction(QtGui.QIcon('share/cutpath16.png'), 'Cut Path')
|
|
# self.move_menuitem = self.menu.addAction(QtGui.QIcon('share/move16.png'), "Move Objects 'm'")
|
|
# self.copy_menuitem = self.menu.addAction(QtGui.QIcon('share/copy16.png'), "Copy Objects 'c'")
|
|
self.delete_menuitem = self.menu.addAction(QtGui.QIcon('share/deleteshape16.png'), "Delete Shape '-'")
|
|
self.buffer_menuitem = self.menu.addAction(QtGui.QIcon('share/buffer16.png'), "Buffer selection 'b'")
|
|
self.paint_menuitem = self.menu.addAction(QtGui.QIcon('share/paint16.png'), "Paint selection")
|
|
self.menu.addSeparator()
|
|
|
|
self.paint_menuitem.triggered.connect(self.on_paint_tool)
|
|
self.buffer_menuitem.triggered.connect(self.on_buffer_tool)
|
|
self.delete_menuitem.triggered.connect(self.on_delete_btn)
|
|
self.union_menuitem.triggered.connect(self.union)
|
|
self.intersection_menuitem.triggered.connect(self.intersection)
|
|
self.cutpath_menuitem.triggered.connect(self.cutpath)
|
|
|
|
### Event handlers ###
|
|
# Connection ids for Matplotlib
|
|
self.cid_canvas_click = None
|
|
self.cid_canvas_move = None
|
|
self.cid_canvas_key = None
|
|
self.cid_canvas_key_release = None
|
|
|
|
# Connect the canvas
|
|
#self.connect_canvas_event_handlers()
|
|
|
|
self.union_btn.triggered.connect(self.union)
|
|
self.intersection_btn.triggered.connect(self.intersection)
|
|
self.subtract_btn.triggered.connect(self.subtract)
|
|
self.cutpath_btn.triggered.connect(self.cutpath)
|
|
self.delete_btn.triggered.connect(self.on_delete_btn)
|
|
|
|
## Toolbar events and properties
|
|
self.tools = {
|
|
"select": {"button": self.select_btn,
|
|
"constructor": FCSelect},
|
|
"circle": {"button": self.add_circle_btn,
|
|
"constructor": FCCircle},
|
|
"arc": {"button": self.add_arc_btn,
|
|
"constructor": FCArc},
|
|
"rectangle": {"button": self.add_rectangle_btn,
|
|
"constructor": FCRectangle},
|
|
"polygon": {"button": self.add_polygon_btn,
|
|
"constructor": FCPolygon},
|
|
"path": {"button": self.add_path_btn,
|
|
"constructor": FCPath},
|
|
"move": {"button": self.move_btn,
|
|
"constructor": FCMove},
|
|
"copy": {"button": self.copy_btn,
|
|
"constructor": FCCopy}
|
|
}
|
|
|
|
### Data
|
|
self.active_tool = None
|
|
|
|
self.storage = FlatCAMDraw.make_storage()
|
|
self.utility = []
|
|
|
|
## List of selected shapes.
|
|
self.selected = []
|
|
|
|
self.move_timer = QtCore.QTimer()
|
|
self.move_timer.setSingleShot(True)
|
|
|
|
self.key = None # Currently pressed key
|
|
|
|
def make_callback(thetool):
|
|
def f():
|
|
self.on_tool_select(thetool)
|
|
return f
|
|
|
|
for tool in self.tools:
|
|
self.tools[tool]["button"].triggered.connect(make_callback(tool)) # Events
|
|
self.tools[tool]["button"].setCheckable(True) # Checkable
|
|
|
|
# for snap_tool in [self.grid_snap_btn, self.corner_snap_btn]:
|
|
# snap_tool.triggered.connect(lambda: self.toolbar_tool_toggle("grid_snap"))
|
|
# snap_tool.setCheckable(True)
|
|
self.grid_snap_btn.setCheckable(True)
|
|
self.grid_snap_btn.triggered.connect(lambda: self.toolbar_tool_toggle("grid_snap"))
|
|
self.corner_snap_btn.setCheckable(True)
|
|
self.corner_snap_btn.triggered.connect(lambda: self.toolbar_tool_toggle("corner_snap"))
|
|
|
|
self.options = {
|
|
"snap-x": 0.1,
|
|
"snap-y": 0.1,
|
|
"snap_max": 0.05,
|
|
"grid_snap": False,
|
|
"corner_snap": False,
|
|
}
|
|
|
|
self.grid_gap_x_entry.setText(str(self.options["snap-x"]))
|
|
self.grid_gap_y_entry.setText(str(self.options["snap-y"]))
|
|
self.snap_max_dist_entry.setText(str(self.options["snap_max"]))
|
|
|
|
self.rtree_index = rtindex.Index()
|
|
|
|
def entry2option(option, entry):
|
|
self.options[option] = float(entry.text())
|
|
|
|
self.grid_gap_x_entry.setValidator(QtGui.QDoubleValidator())
|
|
self.grid_gap_x_entry.editingFinished.connect(lambda: entry2option("snap-x", self.grid_gap_x_entry))
|
|
self.grid_gap_y_entry.setValidator(QtGui.QDoubleValidator())
|
|
self.grid_gap_y_entry.editingFinished.connect(lambda: entry2option("snap-y", self.grid_gap_y_entry))
|
|
self.snap_max_dist_entry.setValidator(QtGui.QDoubleValidator())
|
|
self.snap_max_dist_entry.editingFinished.connect(lambda: entry2option("snap_max", self.snap_max_dist_entry))
|
|
|
|
def activate(self):
|
|
pass
|
|
|
|
def connect_canvas_event_handlers(self):
|
|
## Canvas events
|
|
self.cid_canvas_click = self.canvas.mpl_connect('button_press_event', self.on_canvas_click)
|
|
self.cid_canvas_move = self.canvas.mpl_connect('motion_notify_event', self.on_canvas_move)
|
|
self.cid_canvas_key = self.canvas.mpl_connect('key_press_event', self.on_canvas_key)
|
|
self.cid_canvas_key_release = self.canvas.mpl_connect('key_release_event', self.on_canvas_key_release)
|
|
|
|
def disconnect_canvas_event_handlers(self):
|
|
self.canvas.mpl_disconnect(self.cid_canvas_click)
|
|
self.canvas.mpl_disconnect(self.cid_canvas_move)
|
|
self.canvas.mpl_disconnect(self.cid_canvas_key)
|
|
self.canvas.mpl_disconnect(self.cid_canvas_key_release)
|
|
|
|
def add_shape(self, shape):
|
|
"""
|
|
Adds a shape to the shape storage.
|
|
|
|
:param shape: Shape to be added.
|
|
:type shape: DrawToolShape
|
|
:return: None
|
|
"""
|
|
|
|
# List of DrawToolShape?
|
|
if isinstance(shape, list):
|
|
for subshape in shape:
|
|
self.add_shape(subshape)
|
|
return
|
|
|
|
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:
|
|
self.storage.insert(shape)
|
|
|
|
def deactivate(self):
|
|
self.disconnect_canvas_event_handlers()
|
|
self.clear()
|
|
self.drawing_toolbar.setDisabled(True)
|
|
self.snap_toolbar.setDisabled(True) # TODO: Combine and move into tool
|
|
|
|
def delete_utility_geometry(self):
|
|
#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)
|
|
|
|
def cutpath(self):
|
|
selected = self.get_selected()
|
|
tools = selected[1:]
|
|
toolgeo = cascaded_union([shp.geo for shp in tools])
|
|
|
|
target = selected[0]
|
|
if type(target.geo) == Polygon:
|
|
for ring in poly2rings(target.geo):
|
|
self.add_shape(DrawToolShape(ring.difference(toolgeo)))
|
|
self.delete_shape(target)
|
|
elif type(target.geo) == LineString or type(target.geo) == LinearRing:
|
|
self.add_shape(DrawToolShape(target.geo.difference(toolgeo)))
|
|
self.delete_shape(target)
|
|
else:
|
|
self.app.log.warning("Not implemented.")
|
|
|
|
self.replot()
|
|
|
|
def toolbar_tool_toggle(self, key):
|
|
self.options[key] = self.sender().isChecked()
|
|
|
|
def clear(self):
|
|
self.active_tool = None
|
|
#self.shape_buffer = []
|
|
self.selected = []
|
|
self.storage = FlatCAMDraw.make_storage()
|
|
self.replot()
|
|
|
|
def edit_fcgeometry(self, fcgeometry):
|
|
"""
|
|
Imports the geometry from the given FlatCAM Geometry object
|
|
into the editor.
|
|
|
|
:param fcgeometry: FlatCAMGeometry
|
|
:return: None
|
|
"""
|
|
assert isinstance(fcgeometry, Geometry), \
|
|
"Expected a Geometry, got %s" % type(fcgeometry)
|
|
|
|
self.deactivate()
|
|
|
|
self.connect_canvas_event_handlers()
|
|
self.select_tool("select")
|
|
|
|
# Link shapes into editor.
|
|
for shape in fcgeometry.flatten():
|
|
if shape is not None: # TODO: Make flatten never create a None
|
|
self.add_shape(DrawToolShape(shape))
|
|
|
|
self.replot()
|
|
self.drawing_toolbar.setDisabled(False)
|
|
self.snap_toolbar.setDisabled(False)
|
|
|
|
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)
|
|
self.app.info(self.active_tool.start_msg)
|
|
else:
|
|
self.app.log.debug("%s is NOT checked." % tool)
|
|
for t in self.tools:
|
|
self.tools[t]["button"].setChecked(False)
|
|
self.active_tool = None
|
|
|
|
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
|
|
"""
|
|
# Selection with left mouse button
|
|
if self.active_tool is not None and event.button is 1:
|
|
# Dispatch event to active_tool
|
|
msg = self.active_tool.click(self.snap(event.xdata, event.ydata))
|
|
self.app.info(msg)
|
|
|
|
# If it is a shape generating tool
|
|
if isinstance(self.active_tool, FCShapeTool) and self.active_tool.complete:
|
|
self.on_shape_complete()
|
|
return
|
|
|
|
if isinstance(self.active_tool, FCSelect):
|
|
self.app.log.debug("Replotting after click.")
|
|
self.replot()
|
|
else:
|
|
self.app.log.debug("No active tool to respond to click!")
|
|
|
|
def on_canvas_move(self, event):
|
|
"""
|
|
event.x and .y have canvas coordinates
|
|
event.xdaya and .ydata have plot coordinates
|
|
|
|
:param event: Event object dispatched by Matplotlib
|
|
:return:
|
|
"""
|
|
self.on_canvas_move_effective(event)
|
|
return None
|
|
|
|
# self.move_timer.stop()
|
|
#
|
|
# if self.active_tool is None:
|
|
# return
|
|
#
|
|
# # Make a function to avoid late evaluation
|
|
# def make_callback():
|
|
# def f():
|
|
# self.on_canvas_move_effective(event)
|
|
# return f
|
|
# callback = make_callback()
|
|
#
|
|
# self.move_timer.timeout.connect(callback)
|
|
# self.move_timer.start(500) # Stops if aready running
|
|
|
|
def on_canvas_move_effective(self, event):
|
|
"""
|
|
Is called after timeout on timer set in on_canvas_move.
|
|
|
|
For details on animating on MPL see:
|
|
http://wiki.scipy.org/Cookbook/Matplotlib/Animations
|
|
|
|
event.x and .y have canvas coordinates
|
|
event.xdaya and .ydata have plot coordinates
|
|
|
|
:param event: Event object dispatched by Matplotlib
|
|
:return: None
|
|
"""
|
|
|
|
try:
|
|
x = float(event.xdata)
|
|
y = float(event.ydata)
|
|
except TypeError:
|
|
return
|
|
|
|
if self.active_tool is None:
|
|
return
|
|
|
|
### Snap coordinates
|
|
x, y = self.snap(x, y)
|
|
|
|
### Utility geometry (animated)
|
|
self.canvas.canvas.restore_region(self.canvas.background)
|
|
geo = self.active_tool.utility_geometry(data=(x, y))
|
|
|
|
if isinstance(geo, DrawToolShape) and geo.geo is not None:
|
|
|
|
# Remove any previous utility shape
|
|
self.delete_utility_geometry()
|
|
|
|
# Add the new utility shape
|
|
self.add_shape(geo)
|
|
|
|
# Efficient plotting for fast animation
|
|
|
|
#self.canvas.canvas.restore_region(self.canvas.background)
|
|
elements = self.plot_shape(geometry=geo.geo,
|
|
linespec="b--",
|
|
linewidth=1,
|
|
animated=True)
|
|
for el in elements:
|
|
self.axes.draw_artist(el)
|
|
#self.canvas.canvas.blit(self.axes.bbox)
|
|
|
|
# Pointer (snapped)
|
|
elements = self.axes.plot(x, y, 'bo', animated=True)
|
|
for el in elements:
|
|
self.axes.draw_artist(el)
|
|
|
|
self.canvas.canvas.blit(self.axes.bbox)
|
|
|
|
def on_canvas_key(self, event):
|
|
"""
|
|
event.key has the key.
|
|
|
|
:param event:
|
|
:return:
|
|
"""
|
|
self.key = event.key
|
|
|
|
### Finish the current action. Use with tools that do not
|
|
### complete automatically, like a polygon or path.
|
|
if event.key == ' ':
|
|
if isinstance(self.active_tool, FCShapeTool):
|
|
self.active_tool.click(self.snap(event.xdata, event.ydata))
|
|
self.active_tool.make()
|
|
if self.active_tool.complete:
|
|
self.on_shape_complete()
|
|
self.app.info("Done.")
|
|
return
|
|
|
|
### Abort the current action
|
|
if event.key == 'escape':
|
|
# TODO: ...?
|
|
#self.on_tool_select("select")
|
|
self.app.info("Cancelled.")
|
|
|
|
self.delete_utility_geometry()
|
|
|
|
self.replot()
|
|
# self.select_btn.setChecked(True)
|
|
# self.on_tool_select('select')
|
|
self.select_tool('select')
|
|
return
|
|
|
|
### Delete selected object
|
|
if event.key == '-':
|
|
self.delete_selected()
|
|
self.replot()
|
|
|
|
### Move
|
|
if event.key == 'm':
|
|
self.move_btn.setChecked(True)
|
|
self.on_tool_select('move')
|
|
self.active_tool.set_origin(self.snap(event.xdata, event.ydata))
|
|
self.app.info("Click on target point.")
|
|
|
|
### Copy
|
|
if event.key == 'c':
|
|
self.copy_btn.setChecked(True)
|
|
self.on_tool_select('copy')
|
|
self.active_tool.set_origin(self.snap(event.xdata, event.ydata))
|
|
self.app.info("Click on target point.")
|
|
|
|
### Snap
|
|
if event.key == 'g':
|
|
self.grid_snap_btn.trigger()
|
|
if event.key == 'k':
|
|
self.corner_snap_btn.trigger()
|
|
|
|
### Buffer
|
|
if event.key == 'b':
|
|
self.on_buffer_tool()
|
|
|
|
### Propagate to tool
|
|
response = None
|
|
if self.active_tool is not None:
|
|
response = self.active_tool.on_key(event.key)
|
|
if response is not None:
|
|
self.app.info(response)
|
|
|
|
def on_canvas_key_release(self, event):
|
|
self.key = None
|
|
|
|
def on_delete_btn(self):
|
|
self.delete_selected()
|
|
self.replot()
|
|
|
|
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 delete_selected(self):
|
|
tempref = [s for s in self.selected]
|
|
for shape in tempref:
|
|
self.delete_shape(shape)
|
|
|
|
self.selected = []
|
|
|
|
def plot_shape(self, geometry=None, linespec='b-', linewidth=1, animated=False):
|
|
"""
|
|
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 linespec: Matplotlib linespec string.
|
|
:param linewidth: Width of lines in # of pixels.
|
|
:param animated: If geometry is to be animated. (See MPL plot())
|
|
:return: List of plotted elements.
|
|
"""
|
|
plot_elements = []
|
|
|
|
if geometry is None:
|
|
geometry = self.active_tool.geometry
|
|
|
|
try:
|
|
for geo in geometry:
|
|
plot_elements += self.plot_shape(geometry=geo,
|
|
linespec=linespec,
|
|
linewidth=linewidth,
|
|
animated=animated)
|
|
|
|
## Non-iterable
|
|
except TypeError:
|
|
|
|
## DrawToolShape
|
|
if isinstance(geometry, DrawToolShape):
|
|
plot_elements += self.plot_shape(geometry=geometry.geo,
|
|
linespec=linespec,
|
|
linewidth=linewidth,
|
|
animated=animated)
|
|
|
|
## Polygon: Dscend into exterior and each interior.
|
|
if type(geometry) == Polygon:
|
|
plot_elements += self.plot_shape(geometry=geometry.exterior,
|
|
linespec=linespec,
|
|
linewidth=linewidth,
|
|
animated=animated)
|
|
plot_elements += self.plot_shape(geometry=geometry.interiors,
|
|
linespec=linespec,
|
|
linewidth=linewidth,
|
|
animated=animated)
|
|
|
|
if type(geometry) == LineString or type(geometry) == LinearRing:
|
|
x, y = geometry.coords.xy
|
|
element, = self.axes.plot(x, y, linespec, linewidth=linewidth, animated=animated)
|
|
plot_elements.append(element)
|
|
|
|
if type(geometry) == Point:
|
|
x, y = geometry.coords.xy
|
|
element, = self.axes.plot(x, y, 'bo', linewidth=linewidth, animated=animated)
|
|
plot_elements.append(element)
|
|
|
|
return plot_elements
|
|
|
|
def plot_all(self):
|
|
"""
|
|
Plots all shapes in the editor.
|
|
Clears the axes, plots, and call self.canvas.auto_adjust_axes.
|
|
|
|
:return: None
|
|
:rtype: None
|
|
"""
|
|
self.app.log.debug("plot_all()")
|
|
self.axes.cla()
|
|
|
|
for shape in self.storage.get_objects():
|
|
if shape.geo is None: # TODO: This shouldn't have happened
|
|
continue
|
|
|
|
if shape in self.selected:
|
|
self.plot_shape(geometry=shape.geo, linespec='k-', linewidth=2)
|
|
continue
|
|
|
|
self.plot_shape(geometry=shape.geo)
|
|
|
|
for shape in self.utility:
|
|
self.plot_shape(geometry=shape.geo, linespec='k--', linewidth=1)
|
|
continue
|
|
|
|
self.canvas.auto_adjust_axes()
|
|
|
|
def on_shape_complete(self):
|
|
self.app.log.debug("on_shape_complete()")
|
|
|
|
# Add shape
|
|
self.add_shape(self.active_tool.geometry)
|
|
|
|
# Remove any utility shapes
|
|
self.delete_utility_geometry()
|
|
|
|
# Replot and reset tool.
|
|
self.replot()
|
|
self.active_tool = type(self.active_tool)(self)
|
|
|
|
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 replot(self):
|
|
self.axes = self.canvas.new_axes("draw")
|
|
self.plot_all()
|
|
|
|
@staticmethod
|
|
def make_storage():
|
|
|
|
## Shape storage.
|
|
storage = FlatCAMRTreeStorage()
|
|
storage.get_points = DrawToolShape.get_pts
|
|
|
|
return storage
|
|
|
|
def select_tool(self, toolname):
|
|
"""
|
|
Selects a drawing tool. Impacts the object and GUI.
|
|
|
|
:param toolname: Name of the tool.
|
|
:return: None
|
|
"""
|
|
self.tools[toolname]["button"].setChecked(True)
|
|
self.on_tool_select(toolname)
|
|
|
|
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 = Inf
|
|
|
|
### Object (corner?) snap
|
|
### No need for the objects, just the coordinates
|
|
### in the index.
|
|
if self.options["corner_snap"]:
|
|
try:
|
|
nearest_pt, shape = self.storage.nearest((x, y))
|
|
|
|
nearest_pt_distance = distance((x, y), nearest_pt)
|
|
if nearest_pt_distance <= self.options["snap_max"]:
|
|
snap_distance = nearest_pt_distance
|
|
snap_x, snap_y = nearest_pt
|
|
except (StopIteration, AssertionError):
|
|
pass
|
|
|
|
### Grid snap
|
|
if self.options["grid_snap"]:
|
|
if self.options["snap-x"] != 0:
|
|
snap_x_ = round(x / self.options["snap-x"]) * self.options['snap-x']
|
|
else:
|
|
snap_x_ = x
|
|
|
|
if self.options["snap-y"] != 0:
|
|
snap_y_ = round(y / self.options["snap-y"]) * self.options['snap-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 update_fcgeometry(self, fcgeometry):
|
|
"""
|
|
Transfers the drawing tool shape buffer to the selected geometry
|
|
object. The geometry already in the object are removed.
|
|
|
|
:param fcgeometry: FlatCAMGeometry
|
|
:return: None
|
|
"""
|
|
fcgeometry.solid_geometry = []
|
|
#for shape in self.shape_buffer:
|
|
for shape in self.storage.get_objects():
|
|
fcgeometry.solid_geometry.append(shape.geo)
|
|
|
|
def union(self):
|
|
"""
|
|
Makes union of selected polygons. Original polygons
|
|
are deleted.
|
|
|
|
:return: None.
|
|
"""
|
|
|
|
results = cascaded_union([t.geo for t in self.get_selected()])
|
|
|
|
# Delete originals.
|
|
for_deletion = [s for s in self.get_selected()]
|
|
for shape in for_deletion:
|
|
self.delete_shape(shape)
|
|
|
|
# Selected geometry is now gone!
|
|
self.selected = []
|
|
|
|
self.add_shape(DrawToolShape(results))
|
|
|
|
self.replot()
|
|
|
|
def intersection(self):
|
|
"""
|
|
Makes intersectino of selected polygons. Original polygons are deleted.
|
|
|
|
:return: None
|
|
"""
|
|
|
|
shapes = self.get_selected()
|
|
|
|
results = shapes[0].geo
|
|
|
|
for shape in shapes[1:]:
|
|
results = results.intersection(shape.geo)
|
|
|
|
# Delete originals.
|
|
for_deletion = [s for s in self.get_selected()]
|
|
for shape in for_deletion:
|
|
self.delete_shape(shape)
|
|
|
|
# Selected geometry is now gone!
|
|
self.selected = []
|
|
|
|
self.add_shape(DrawToolShape(results))
|
|
|
|
self.replot()
|
|
|
|
def subtract(self):
|
|
selected = self.get_selected()
|
|
tools = selected[1:]
|
|
toolgeo = cascaded_union([shp.geo for shp in tools])
|
|
result = selected[0].geo.difference(toolgeo)
|
|
|
|
self.delete_shape(selected[0])
|
|
self.add_shape(DrawToolShape(result))
|
|
|
|
self.replot()
|
|
|
|
def buffer(self, buf_distance):
|
|
selected = self.get_selected()
|
|
|
|
if len(selected) == 0:
|
|
self.app.inform.emit("[warning] Nothing selected for buffering.")
|
|
return
|
|
|
|
if not isinstance(buf_distance, float):
|
|
self.app.inform.emit("[warning] Invalid distance for buffering.")
|
|
return
|
|
|
|
pre_buffer = cascaded_union([t.geo for t in selected])
|
|
results = pre_buffer.buffer(buf_distance)
|
|
self.add_shape(DrawToolShape(results))
|
|
|
|
self.replot()
|
|
|
|
def paint(self, tooldia, overlap, margin, method):
|
|
selected = self.get_selected()
|
|
|
|
if len(selected) == 0:
|
|
self.app.inform.emit("[warning] Nothing selected for painting.")
|
|
return
|
|
|
|
for param in [tooldia, overlap, margin]:
|
|
if not isinstance(param, float):
|
|
param_name = [k for k, v in list(locals().items()) if v is param][0]
|
|
self.app.inform.emit("[warning] Invalid value for {}".format())
|
|
|
|
# Todo: Check for valid method.
|
|
|
|
# Todo: This is the 3rd implementation on painting polys... try to consolidate
|
|
|
|
results = []
|
|
|
|
def recurse(geo):
|
|
try:
|
|
for subg in geo:
|
|
for subsubg in recurse(subg):
|
|
yield subsubg
|
|
except TypeError:
|
|
if isinstance(geo, Polygon):
|
|
yield geo
|
|
|
|
raise StopIteration
|
|
|
|
for geo in selected:
|
|
|
|
local_results = []
|
|
for poly in recurse(geo.geo):
|
|
|
|
if method == "seed":
|
|
# Type(cp) == FlatCAMRTreeStorage | None
|
|
cp = Geometry.clear_polygon2(poly.buffer(-margin),
|
|
tooldia, overlap=overlap)
|
|
|
|
else:
|
|
# Type(cp) == FlatCAMRTreeStorage | None
|
|
cp = Geometry.clear_polygon(poly.buffer(-margin),
|
|
tooldia, overlap=overlap)
|
|
|
|
if cp is not None:
|
|
local_results += list(cp.get_objects())
|
|
|
|
results.append(cascaded_union(local_results))
|
|
|
|
# This is a dirty patch:
|
|
for r in results:
|
|
self.add_shape(DrawToolShape(r))
|
|
|
|
self.replot()
|
|
|
|
|
|
def distance(pt1, pt2):
|
|
return sqrt((pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) ** 2)
|
|
|
|
|
|
def mag(vec):
|
|
return sqrt(vec[0] ** 2 + vec[1] ** 2)
|
|
|
|
|
|
def poly2rings(poly):
|
|
return [poly.exterior] + [interior for interior in poly.interiors] |