def import_dxf_layer_geometry(dxf, layername):
entities = dxf.entities
generics = []
for entity in entities:
if entity.dxf.layer in layername:
if isinstance(entity, ezdxf.modern.graphics.Line):
import numpy
points = numpy.array(
[entity.dxf.start[:2], entity.dxf.end[:2]])
generics.append(
GenericLine.gen_from_point_lists(points.tolist(), []))
elif isinstance(entity, ezdxf.modern.graphics.LWPolyline):
import numpy
points = numpy.array([item for item in entity.get_points()])
points = points[:, :2]
if entity.closed:
generics.append(
GenericPoly.gen_from_point_lists(points.tolist(), []))
else:
generics.append(
GenericPolyline.gen_from_point_lists(
points.tolist(), []))
elif isinstance(entity, ezdxf.modern.graphics.Point):
from popupcad.geometry.vertex import DrawnPoint
point = DrawnPoint(
numpy.array(entity.get_dxf_attrib('location')[:2]))
generics.append(point)
elif isinstance(entity, ezdxf.modern.graphics.Spline):
knots = entity.get_knot_values()
control_points = entity.get_control_points()
weights = entity.get_weights()
n = len(control_points) - 1
domain = popupcad.algorithms.spline_functions.make_domain(
knots, n * 5)
points = popupcad.algorithms.spline_functions.interpolated_points(
control_points, knots, weights, domain)
points = points[:, :2]
if entity.closed:
generics.append(
GenericPoly.gen_from_point_lists(points.tolist(), []))
else:
generics.append(
GenericPolyline.gen_from_point_lists(
points.tolist(), []))
# print(points)
else:
print(entity)
new = popupcad.filetypes.sketch.Sketch.new()
new.addoperationgeometries(generics)
newsketchname = layername + '.sketch'
new.updatefilename(newsketchname)
return new
def import_dxf_layer_geometry(dxf, layername):
entities = dxf.entities
generics = []
for entity in entities:
if entity.dxf.layer in layername:
if isinstance(entity, ezdxf.modern.graphics.Line):
import numpy
points = numpy.array(
[entity.dxf.start[:2], entity.dxf.end[:2]])
generics.append(
GenericLine.gen_from_point_lists(
points.tolist(),
[]))
elif isinstance(entity, ezdxf.modern.graphics.LWPolyline):
import numpy
points = numpy.array([item for item in entity.get_points()])
points = points[:, :2]
if entity.closed:
generics.append(GenericPoly.gen_from_point_lists(points.tolist(), []))
else:
generics.append(GenericPolyline.gen_from_point_lists(points.tolist(), []))
elif isinstance(entity, ezdxf.modern.graphics.Point):
from popupcad.geometry.vertex import DrawnPoint
point = DrawnPoint(numpy.array(entity.get_dxf_attrib('location')[:2]))
generics.append(point)
elif isinstance(entity, ezdxf.modern.graphics.Spline):
knots = entity.get_knot_values()
control_points = entity.get_control_points()
weights = entity.get_weights()
n = len(control_points) - 1
domain = popupcad.algorithms.spline_functions.make_domain(knots, n * 5)
points = popupcad.algorithms.spline_functions.interpolated_points(control_points, knots, weights,
domain)
points = points[:, :2]
if entity.closed:
generics.append(GenericPoly.gen_from_point_lists(points.tolist(), []))
else:
generics.append(GenericPolyline.gen_from_point_lists(points.tolist(), []))
# print(points)
else:
print(entity)
new = popupcad.filetypes.sketch.Sketch.new()
new.addoperationgeometries(generics)
newsketchname = layername + '.sketch'
new.updatefilename(newsketchname)
return new
def triangulate(vertices):
'''Create the triangulation of a set of points, and output the resulting triangles'''
from scipy.spatial import Delaunay
d = Delaunay(vertices)
polys = d.points[d.vertices].tolist()
genericpolys = [GenericPoly.gen_from_point_lists(poly,[]) for poly in polys]
return genericpolys
def convex_hull(vertices):
'''Create a convex polygon from given points'''
delaunay = Delaunay(vertices)
cvx = delaunay.convex_hull.copy()
lastrow = cvx[0]
iis = range(len(cvx))
for ii in iis[1:-1]:
lastindex = lastrow[1]
findop = (cvx[ii:] == lastindex).nonzero()
jj = findop[0][0] + ii
cvx[(ii, jj), :] = cvx[(jj, ii), :]
if findop[1][0] == 1:
cvx[ii, (1, 0)] = cvx[ii, (0, 1)]
lastrow = cvx[ii]
lastindex = lastrow[1]
findop = (cvx[-1] == lastindex).nonzero()
if findop[0][0] == 1:
cvx[-1, (1, 0)] = cvx[-1, (0, 1)]
polyindeces = cvx[:, 0]
polypoints = delaunay.points[polyindeces, :].tolist()
poly = GenericPoly.gen_from_point_lists(polypoints, [])
return poly
def convex_hull(vertices):
'''Create a convex polygon from given points'''
delaunay = Delaunay(vertices)
cvx = delaunay.convex_hull.copy()
lastrow = cvx[0]
iis = range(len(cvx))
for ii in iis[1:-1]:
lastindex = lastrow[1]
findop = (cvx[ii:] == lastindex).nonzero()
jj = findop[0][0] + ii
cvx[(ii, jj), :] = cvx[(jj, ii), :]
if findop[1][0] == 1:
cvx[ii, (1, 0)] = cvx[ii, (0, 1)]
lastrow = cvx[ii]
lastindex = lastrow[1]
findop = (cvx[-1] == lastindex).nonzero()
if findop[0][0] == 1:
cvx[-1, (1, 0)] = cvx[-1, (0, 1)]
polyindeces = cvx[:, 0]
polypoints = delaunay.points[polyindeces, :].tolist()
poly = GenericPoly.gen_from_point_lists(polypoints, [])
return poly
def triangulate(vertices):
'''Create the triangulation of a set of points, and output the resulting triangles'''
from scipy.spatial import Delaunay
d = Delaunay(vertices)
polys = d.points[d.vertices].tolist()
genericpolys = [
GenericPoly.gen_from_point_lists(poly, []) for poly in polys
]
return genericpolys
def _convert(
self,
scalefactor,
area_ratio,
colinear_tol,
bufferval,
cleanup):
self.geoms = []
T1 = numpy.array(self.transform)
R1 = T1[0:3, 0:3]
b1 = T1[0:3, 3:4]
for ii, component in enumerate(self.components):
T2 = numpy.array(component.transform)
R2 = T2[0:3, 0:3]
b2 = T2[0:3, 3:4]
if component.faces is not None:
for jj, face in enumerate(component.faces):
try:
loops = face.loops
ints_c = [
self.transform_loop(
interior,
R1,
b1,
R2,
b2,
scalefactor) for interior in loops]
a = [
GenericPoly.gen_from_point_lists(
loop,
[]) for loop in ints_c]
b = [item.to_shapely() for item in a]
if cleanup >= 0:
b = [
item.simplify(
cleanup *
popupcad.csg_processing_scaling) for item in b]
c = b.pop(0)
for item in b:
c = c.symmetric_difference(item)
d = popupcad.algorithms.csg_shapely.condition_shapely_entities(c)
e = popupcad.algorithms.csg_shapely.condition_shapely_entities(*[item.buffer(bufferval * popupcad.csg_processing_scaling,resolution=popupcad.default_buffer_resolution) for item in d])
f = [popupcad.algorithms.csg_shapely.to_generic(item) for item in e]
self.geoms.extend(f)
except NotSimple:
pass
except ShapeInvalid:
pass
except ValueError as ex:
print(ex)
# if ex.message!='A LinearRing must have at least 3 coordinate tuples':
# print(ex.message)
self.filter_small_areas(area_ratio)
def painterpath_to_generics(p, subdivision):
elements = [p.elementAt(ii) for ii in range(p.elementCount())]
# element_types = [str(item.type).split('.')[-1] for item in elements]
vertex_lists = []
vertex_list = []
lastelement = elements[0]
while not not elements:
element = elements.pop(0)
if element.type == qg.QPainterPath.MoveToElement:
# print('moveto',element.x,element.y)
if len(vertex_list) > 0:
vertex_lists.append(vertex_list)
vertex_list = [(element.x, element.y)]
lastelement = element
elif element.type == qg.QPainterPath.LineToElement:
# print('lineto',element.x,element.y)
vertex_list.append((element.x, element.y))
lastelement = element
elif element.type == qg.QPainterPath.CurveToElement:
# print('curveto',element.x,element.y)
subelements = []
next_is_data = True
while next_is_data:
subelements.append(elements.pop(0))
if len(elements) > 0:
next_is_data = elements[
0].type == qg.QPainterPath.CurveToDataElement
else:
next_is_data = False
if len(subelements) == 1:
points = [lastelement, element, subelements[0]]
vertex_list.extend(interp_2d(quadratic, points, subdivision))
lastelement = subelements[0]
elif len(subelements) == 2:
points = [lastelement, element, subelements[0], subelements[1]]
vertex_list.extend(interp_2d(cubic, points, subdivision))
lastelement = subelements[1]
else:
raise (Exception('Wrong number of subelements'))
vertex_lists.append(vertex_list)
polys = []
for vertex_list in vertex_lists:
polys.append(GenericPoly.gen_from_point_lists(vertex_list, []))
return polys
def painterpath_to_generics(p, subdivision):
elements = [p.elementAt(ii) for ii in range(p.elementCount())]
# element_types = [str(item.type).split('.')[-1] for item in elements]
vertex_lists = []
vertex_list = []
lastelement = elements[0]
while not not elements:
element = elements.pop(0)
if element.type == qg.QPainterPath.ElementType.MoveToElement:
# print('moveto',element.x,element.y)
if len(vertex_list) > 0:
vertex_lists.append(vertex_list)
vertex_list = [(element.x, element.y)]
lastelement = element
elif element.type == qg.QPainterPath.ElementType.LineToElement:
# print('lineto',element.x,element.y)
vertex_list.append((element.x, element.y))
lastelement = element
elif element.type == qg.QPainterPath.ElementType.CurveToElement:
# print('curveto',element.x,element.y)
subelements = []
next_is_data = True
while next_is_data:
subelements.append(elements.pop(0))
if len(elements) > 0:
next_is_data = elements[0].type == qg.QPainterPath.ElementType.CurveToDataElement
else:
next_is_data = False
if len(subelements) == 1:
points = [lastelement, element, subelements[0]]
vertex_list.extend(interp_2d(quadratic, points, subdivision))
lastelement = subelements[0]
elif len(subelements) == 2:
points = [lastelement, element, subelements[0], subelements[1]]
vertex_list.extend(interp_2d(cubic, points, subdivision))
lastelement = subelements[1]
else:
raise (Exception("Wrong number of subelements"))
vertex_lists.append(vertex_list)
polys = []
for vertex_list in vertex_lists:
polys.append(GenericPoly.gen_from_point_lists(vertex_list, []))
return polys
def supportsheet(layerdef, lsin, value):
allext = []
for layer, layer_geometry in lsin.layer_sequence.items():
for geom in layer_geometry.geoms:
geom2 = popupcad.algorithms.csg_shapely.to_generic(geom)
allext.extend(geom2.exteriorpoints(scaling = popupcad.csg_processing_scaling))
allext = numpy.array(allext)
minx = allext[:, 0].min() - value
miny = allext[:, 1].min() - value
maxx = allext[:, 0].max() + value
maxy = allext[:, 1].max() + value
exterior = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]]
exterior_scaled = (numpy.array(exterior)/popupcad.csg_processing_scaling).tolist()
geom = GenericPoly.gen_from_point_lists(exterior_scaled, [])
geom = geom.to_shapely()
ls = Laminate(layerdef)
[ls.replacelayergeoms(layer, [geom]) for layer in layerdef.layers]
return ls, exterior[0]
def _convert(self,scalefactor,area_ratio,colinear_tol,bufferval,cleanup):
self.geoms = []
T1 = numpy.array(self.transform)
R1 = T1[0:3, 0:3]
b1 = T1[0:3, 3:4]
for ii, component in enumerate(self.components):
T2 = numpy.array(component.transform)
R2 = T2[0:3, 0:3]
b2 = T2[0:3, 3:4]
if component.faces is not None:
for jj, face in enumerate(component.faces):
try:
loops = face.loops
ints_c = [self.transform_loop(interior,R1,b1,R2,b2,scalefactor) for interior in loops]
a = [
GenericPoly.gen_from_point_lists(
loop,
[]) for loop in ints_c]
b = [item.to_shapely(scaling = popupcad.csg_processing_scaling) for item in a]
if cleanup >= 0:
b = [
item.simplify(
cleanup *
popupcad.csg_processing_scaling) for item in b]
c = b.pop(0)
for item in b:
c = c.symmetric_difference(item)
d = popupcad.algorithms.csg_shapely.condition_shapely_entities(c)
e = popupcad.algorithms.csg_shapely.condition_shapely_entities(*[item.buffer(bufferval * popupcad.csg_processing_scaling,resolution=popupcad.default_buffer_resolution) for item in d])
f = [popupcad.algorithms.csg_shapely.to_generic(item) for item in e]
self.geoms.extend(f)
except NotSimple:
pass
except ShapeInvalid:
pass
except ValueError as ex:
print(ex)
# if ex.message!='A LinearRing must have at least 3 coordinate tuples':
# print(ex.message)
self.filter_small_areas(area_ratio)
def supportsheet(layerdef, lsin, value):
allext = []
for layer, layer_geometry in lsin.layer_sequence.items():
for geom in layer_geometry.geoms:
geom2 = popupcad.algorithms.csg_shapely.to_generic(geom)
allext.extend(
geom2.exteriorpoints(scaling=popupcad.csg_processing_scaling))
allext = numpy.array(allext)
minx = allext[:, 0].min() - value
miny = allext[:, 1].min() - value
maxx = allext[:, 0].max() + value
maxy = allext[:, 1].max() + value
exterior = [[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy]]
exterior_scaled = (numpy.array(exterior) /
popupcad.csg_processing_scaling).tolist()
geom = GenericPoly.gen_from_point_lists(exterior_scaled, [])
geom = geom.to_shapely(scaling=popupcad.csg_processing_scaling)
ls = Laminate(layerdef)
[ls.replacelayergeoms(layer, [geom]) for layer in layerdef.layers]
return ls, exterior[0]
def to_generic_polygons(self,add_shift = True):
# import popupcad.algorithms.painterpath as pp
import dev_tools.text_to_polygons
from matplotlib.font_manager import FontProperties
from popupcad.filetypes.genericshapes import GenericPoly
text = self.text
# small font scalings actually produce different paths. use 10pt font as invariant size
internal_font = 10
fp = FontProperties(family = self.font,size=internal_font)
if text !='':
# p = qg.QPainterPath()
# font = qg.QFont(self.font,pointSize=internal_font)
# p.addText(qc.QPointF(0,internal_font),font,text)
# generic_polygons = pp.painterpath_to_generics(p,popupcad.text_approximation)
polygons = dev_tools.text_to_polygons.text_to_polygons(self.text,fp,popupcad.text_approximation)
generic_polygons = []
for item in polygons:
item = numpy.array(item)
if popupcad.flip_y:
item[:,1]=-1*item[:,1]+internal_font
item*=(4/3)
item = item.tolist()
generic_polygons.append(GenericPoly.gen_from_point_lists(item,[]))
#
else:
generic_polygons = []
T = numpy.eye(3)
T[1,1]=-1
generic_polygons = [item.transform(T) for item in generic_polygons]
[item.scale(self.fontsize/internal_font) for item in generic_polygons]
if add_shift:
for item in generic_polygons:
item.shift(self.pos.getpos())
return generic_polygons
def to_generic_polygons(self, add_shift=True):
import idealab_tools.text_to_polygons
from matplotlib.font_manager import FontProperties
from popupcad.filetypes.genericshapes import GenericPoly
text = self.text
# small font scalings actually produce different paths. use 10pt font as invariant size
internal_font = 10
fp = {'family': self.font, 'size': internal_font}
if text != '':
polygons = idealab_tools.text_to_polygons.text_to_polygons(
self.text, fp, popupcad.text_approximation)
generic_polygons = []
for item in polygons:
item = numpy.array(item)
if popupcad.flip_y:
item[:, 1] = -1 * item[:, 1] + internal_font
item *= (4 / 3)
item = item.tolist()
generic_polygons.append(
GenericPoly.gen_from_point_lists(item, []))
#
else:
generic_polygons = []
T = numpy.eye(3)
T[1, 1] = -1
generic_polygons = [item.transform(T) for item in generic_polygons]
[
item.scale(self.fontsize / internal_font)
for item in generic_polygons
]
if add_shift:
for item in generic_polygons:
item.shift(self.pos.getpos())
return generic_polygons
def load_dxf(cls, filename, parent=None):
import ezdxf
ezdxf.options.template_dir = popupcad.supportfiledir
import ezdxf.modern
dxf = ezdxf.readfile(filename)
layer_names = [layer.dxf.name for layer in dxf.layers]
dialog = qg.QDialog()
lw = qg.QListWidget()
for item in layer_names:
lw.addItem(qg.QListWidgetItem(item))
lw.setSelectionMode(lw.SelectionMode.ExtendedSelection)
button_ok = qg.QPushButton('Ok')
button_cancel = qg.QPushButton('Cancel')
button_ok.clicked.connect(dialog.accept)
button_cancel.clicked.connect(dialog.reject)
layout = qg.QVBoxLayout()
layout_buttons = qg.QHBoxLayout()
layout_buttons.addWidget(button_ok)
layout_buttons.addWidget(button_cancel)
layout.addWidget(lw)
layout.addLayout(layout_buttons)
dialog.setLayout(layout)
result = dialog.exec_()
if result:
selected_layers = [
item.data(
qc.Qt.ItemDataRole.DisplayRole) for item in lw.selectedItems()]
entities = dxf.entities
generics = []
for entity in entities:
if entity.dxf.layer in selected_layers:
if isinstance(entity, ezdxf.modern.graphics.Line):
from popupcad.filetypes.genericshapes import GenericLine
import numpy
points = numpy.array(
[entity.dxf.start[:2], entity.dxf.end[:2]])
generics.append(
GenericLine.gen_from_point_lists(
points.tolist(),
[]))
elif isinstance(entity, ezdxf.modern.graphics.LWPolyline):
from popupcad.filetypes.genericshapes import GenericPolyline
from popupcad.filetypes.genericshapes import GenericPoly
import numpy
points = numpy.array([item for item in entity.get_points()])
points = points[:,:2]
if entity.closed:
generics.append(
GenericPoly.gen_from_point_lists(
points.tolist(),
[]))
else:
generics.append(
GenericPolyline.gen_from_point_lists(
points.tolist(),
[]))
elif isinstance(entity, ezdxf.modern.graphics.Point):
from popupcad.geometry.vertex import DrawnPoint
point = DrawnPoint(numpy.array(entity.get_dxf_attrib('location')[:2]))
generics.append(point)
else:
print(entity)
new = cls()
new.addoperationgeometries(generics)
return filename, new
else:
return None, None
def load_dxf(cls, filename, parent=None):
import ezdxf
ezdxf.options.template_dir = popupcad.supportfiledir
import ezdxf.modern
dxf = ezdxf.readfile(filename)
layer_names = [layer.dxf.name for layer in dxf.layers]
dialog = qg.QDialog()
lw = qg.QListWidget()
for item in layer_names:
lw.addItem(qg.QListWidgetItem(item))
lw.setSelectionMode(lw.ExtendedSelection)
button_ok = qg.QPushButton('Ok')
button_cancel = qg.QPushButton('Cancel')
button_ok.clicked.connect(dialog.accept)
button_cancel.clicked.connect(dialog.reject)
layout = qg.QVBoxLayout()
layout_buttons = qg.QHBoxLayout()
layout_buttons.addWidget(button_ok)
layout_buttons.addWidget(button_cancel)
layout.addWidget(lw)
layout.addLayout(layout_buttons)
dialog.setLayout(layout)
result = dialog.exec_()
if result:
selected_layers = [
item.data(qc.Qt.DisplayRole) for item in lw.selectedItems()
]
entities = [item for item in dxf.modelspace()]
generics = []
for entity in entities:
if entity.dxf.layer in selected_layers:
if isinstance(entity, ezdxf.modern.graphics.Line):
import numpy
points = numpy.array(
[entity.dxf.start[:2], entity.dxf.end[:2]])
generics.append(
GenericLine.gen_from_point_lists(
points.tolist(), []))
elif isinstance(entity, ezdxf.modern.graphics.LWPolyline):
import numpy
points = numpy.array(
[item for item in entity.get_points()])
points = points[:, :2]
if entity.closed:
generics.append(
GenericPoly.gen_from_point_lists(
points.tolist(), []))
else:
generics.append(
GenericPolyline.gen_from_point_lists(
points.tolist(), []))
elif isinstance(entity, ezdxf.modern.graphics.Point):
from popupcad.geometry.vertex import DrawnPoint
point = DrawnPoint(
numpy.array(entity.get_dxf_attrib('location')[:2]))
generics.append(point)
elif isinstance(entity, ezdxf.modern.spline.Spline):
knots = entity.get_knot_values()
control_points = entity.get_control_points()
weights = entity.get_weights()
n = len(control_points) - 1
domain = popupcad.algorithms.spline_functions.make_domain(
knots, n * 5)
points = popupcad.algorithms.spline_functions.interpolated_points(
control_points, knots, weights, domain)
points = points[:, :2]
if entity.closed:
generics.append(
GenericPoly.gen_from_point_lists(
points.tolist(), []))
else:
generics.append(
GenericPolyline.gen_from_point_lists(
points.tolist(), []))
# print(points)
else:
print(entity)
new = cls.new()
new.addoperationgeometries(generics)
newfile = os.path.splitext(filename)[0] + '.sketch'
new.updatefilename(newfile)
return filename, new
else:
return None, None
def load_dxf(cls, filename, parent=None):
import ezdxf
ezdxf.options.template_dir = popupcad.supportfiledir
import ezdxf.modern
dxf = ezdxf.readfile(filename)
layer_names = [layer.dxf.name for layer in dxf.layers]
dialog = qg.QDialog()
lw = qg.QListWidget()
for item in layer_names:
lw.addItem(qg.QListWidgetItem(item))
lw.setSelectionMode(lw.ExtendedSelection)
button_ok = qg.QPushButton('Ok')
button_cancel = qg.QPushButton('Cancel')
button_ok.clicked.connect(dialog.accept)
button_cancel.clicked.connect(dialog.reject)
layout = qg.QVBoxLayout()
layout_buttons = qg.QHBoxLayout()
layout_buttons.addWidget(button_ok)
layout_buttons.addWidget(button_cancel)
layout.addWidget(lw)
layout.addLayout(layout_buttons)
dialog.setLayout(layout)
result = dialog.exec_()
if result:
selected_layers = [
item.data(
qc.Qt.DisplayRole) for item in lw.selectedItems()]
entities = [item for item in dxf.modelspace()]
generics = []
for entity in entities:
if entity.dxf.layer in selected_layers:
if isinstance(entity, ezdxf.modern.graphics.Line):
import numpy
points = numpy.array(
[entity.dxf.start[:2], entity.dxf.end[:2]])
generics.append(
GenericLine.gen_from_point_lists(
points.tolist(),
[]))
elif isinstance(entity, ezdxf.modern.graphics.LWPolyline):
import numpy
points = numpy.array([item for item in entity.get_points()])
points = points[:,:2]
if entity.closed:
generics.append(GenericPoly.gen_from_point_lists(points.tolist(),[]))
else:
generics.append(GenericPolyline.gen_from_point_lists(points.tolist(),[]))
elif isinstance(entity, ezdxf.modern.graphics.Point):
from popupcad.geometry.vertex import DrawnPoint
point = DrawnPoint(numpy.array(entity.get_dxf_attrib('location')[:2]))
generics.append(point)
elif isinstance(entity, ezdxf.modern.graphics.Spline):
knots = entity.get_knot_values()
control_points = entity.get_control_points()
weights = entity.get_weights()
n = len(control_points)-1
domain = popupcad.algorithms.spline_functions.make_domain(knots,n*5)
points = popupcad.algorithms.spline_functions.interpolated_points(control_points,knots,weights,domain)
points = points[:,:2]
if entity.closed:
generics.append(GenericPoly.gen_from_point_lists(points.tolist(),[]))
else:
generics.append(GenericPolyline.gen_from_point_lists(points.tolist(),[]))
# print(points)
else:
print(entity)
new = cls.new()
new.addoperationgeometries(generics)
newfile = os.path.splitext(filename)[0]+'.sketch'
new.updatefilename(newfile)
return filename, new
else:
return None, None
