def add_constraint(self,constraintclass):
from popupcad.filetypes.genericshapes import GenericLine
self.undoredo.savesnapshot()
items = []
new_constraints = []
for item in self.scene.selectedItems():
if isinstance(item,ReferenceInteractiveVertex):
generic = item.get_generic()
newgeneric = generic.copy_values(DrawnPoint(),False)
newitem = newgeneric.gen_interactive()
self.scene.addItem(newitem)
items.append(newgeneric)
item.setSelected(False)
newitem.setSelected(True)
new_constraints.append(constraints.fixed.new(newgeneric))
elif isinstance(item,ReferenceInteractiveEdge):
generic = item.get_generic()
v1 = generic.vertex1.copy_values(ShapeVertex(),False)
v2 = generic.vertex2.copy_values(ShapeVertex(),False)
new_constraints.append(constraints.fixed.new(v1,v2))
l = GenericLine([v1,v2],[],construction = True)
a = l.outputinteractive()
# b = v1.gen_interactive()
# c = v2.gen_interactive()
self.scene.addItem(a)
# self.scene.addItem(b)
# self.scene.addItem(c)
item.setSelected(False)
a.setSelected(True)
# b.setSelected(True)
# c.setSelected(True)
items.append(a.selectableedges[0].get_generic())
elif isinstance(item,InteractiveVertex):
items.append(item.get_generic())
elif isinstance(item,InteractiveEdge):
items.append(item.get_generic())
elif isinstance(item,InteractiveLine):
items.append(item.selectableedges[0].get_generic())
elif isinstance(item,StaticLine):
items.append(item.selectableedges[0].get_generic())
elif isinstance(item,DrawingPoint):
items.append(item.get_generic())
elif isinstance(item,StaticDrawingPoint):
items.append(item.get_generic())
new_constraints .append(constraintclass.new(*items))
for constraint in new_constraints:
self.sketch.constraintsystem.add_constraint(constraint)
self.refreshconstraints()
def add_constraint(self, constraintclass):
from popupcad.filetypes.genericshapes import GenericLine
self.undoredo.savesnapshot()
items = []
new_constraints = []
for item in self.scene.selectedItems():
if isinstance(item, ReferenceInteractiveVertex):
generic = item.get_generic()
newgeneric = DrawnPoint(generic.getpos(), construction=True)
newitem = newgeneric.gen_interactive()
self.scene.addItem(newitem)
items.append(newgeneric)
item.setSelected(False)
newitem.setSelected(True)
new_constraints.append(
constraints.FixedConstraint.new(newgeneric))
elif isinstance(item, ReferenceInteractiveEdge):
generic = item.get_generic()
v1 = ShapeVertex(generic.vertex1.getpos())
v2 = ShapeVertex(generic.vertex2.getpos())
new_constraints.append(constraints.FixedConstraint.new(v1, v2))
l = GenericLine([v1, v2], [], construction=True)
a = l.outputinteractive()
self.scene.addItem(a)
item.setSelected(False)
a.setSelected(True)
items.append(a.selectableedges[0].get_generic())
elif isinstance(item, InteractiveVertex):
items.append(item.get_generic())
elif isinstance(item, InteractiveEdge):
items.append(item.get_generic())
elif isinstance(item, DrawingPoint):
items.append(item.get_generic())
new_constraint = constraintclass.new(*items)
if new_constraint is not None:
new_constraints.append(new_constraint)
for constraint in new_constraints:
self.sketch.constraintsystem.add_constraint(constraint)
self.refreshconstraints()
def add_constraint(self, constraintclass):
from popupcad.filetypes.genericshapes import GenericLine
self.undoredo.savesnapshot()
items = []
new_constraints = []
for item in self.scene.selectedItems():
if isinstance(item, ReferenceInteractiveVertex):
generic = item.get_generic()
newgeneric = DrawnPoint(generic.getpos(),construction = True)
newitem = newgeneric.gen_interactive()
self.scene.addItem(newitem)
items.append(newgeneric)
item.setSelected(False)
newitem.setSelected(True)
new_constraints.append(constraints.FixedConstraint.new(newgeneric))
elif isinstance(item, ReferenceInteractiveEdge):
generic = item.get_generic()
v1 = ShapeVertex(generic.vertex1.getpos())
v2 = ShapeVertex(generic.vertex2.getpos())
new_constraints.append(constraints.FixedConstraint.new(v1, v2))
l = GenericLine([v1, v2], [], construction=True)
a = l.outputinteractive()
self.scene.addItem(a)
item.setSelected(False)
a.setSelected(True)
items.append(a.selectableedges[0].get_generic())
elif isinstance(item, InteractiveVertex):
items.append(item.get_generic())
elif isinstance(item, InteractiveEdge):
items.append(item.get_generic())
elif isinstance(item, DrawingPoint):
items.append(item.get_generic())
new_constraint = constraintclass.new(*items)
if new_constraint is not None:
new_constraints.append(new_constraint)
for constraint in new_constraints:
self.sketch.constraintsystem.add_constraint(constraint)
self.refreshconstraints()
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 getjoints(geoms,roundvalue):
from popupcad.geometry.vertex import ShapeVertex
from popupcad.filetypes.genericshapes import GenericLine
tolerance = 10**(-roundvalue)
lines = []
for geom in geoms:
p = geom.exteriorpoints()
lines.extend(zip(p, p[1:] + p[:1]))
for interior in geom.interiorpoints():
lines.extend(zip(interior, interior[1:] + interior[:1]))
l3 = popupcad.algorithms.points.distance_of_lines(lines, [0, 0])
l4 = popupcad.algorithms.points.distance_of_lines(lines, [10 * tolerance, 0])
l5 = popupcad.algorithms.points.distance_of_lines(lines, [10 * tolerance, 10 * tolerance])
l6 = popupcad.algorithms.points.distance_of_lines(lines, [0, 10 * tolerance])
l7 = popupcad.algorithms.points.distance_of_lines(lines, [10 * tolerance, 20 * tolerance])
m = numpy.c_[l3, l4, l5, l6, l7]
m = m.round(roundvalue)
m2 = [tuple(items) for items in m.tolist()]
m3 = list(set(m2))
# jj = numpy.searchsorted(m3,m2)
index_to_unique = [m3.index(item) for item in m2]
indeces_to_orig = [[] for item in m3]
[indeces_to_orig[item].append(ii) for ii, item in enumerate(index_to_unique)]
newsegments = []
for segments in indeces_to_orig:
if len(segments) > 1:
a = [lines[ii] for ii in segments]
vertices = []
[vertices.extend(item) for item in a[1:]]
ordered_vertices = popupcad.algorithms.points.order_vertices(vertices,a[0],tolerance=tolerance)
segs = list(zip(ordered_vertices[:-1], ordered_vertices[1:]))
midpoints = popupcad.algorithms.points.segment_midpoints(segs)
count = [0 for item in midpoints]
for ii in segments:
for jj, point in enumerate(midpoints):
if popupcad.algorithms.points.point_within_line(point,lines[ii],tolerance=tolerance):
count[jj] += 1
newsegments.extend([seg for count_ii, seg in zip(count, segs) if count_ii > 1])
generic_lines = [GenericLine([ShapeVertex(v1), ShapeVertex(v2)], []) for v1, v2 in newsegments]
generic_lines = [item for item in generic_lines if len(item.get_exterior()) == 2]
return generic_lines
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 operate(self, design):
design_copy = design
# design_copy.reprocessoperations()
part_to_insert = design_copy.operations[design_copy.operation_index(self.part_opref)]
sheet_to_insert_into = design_copy.operations[design_copy.operation_index(self.sheet_opref)]
release_to_insert_into = design_copy.operations[design_copy.operation_index(self.release_opref)]
# build the op_links, then auto make the operation
op = part_to_insert
op_ref = op.id
op_links = {'parent': [(op_ref, op.getoutputref())]}
new_web = AutoWeb4(op_links,[self.support_offset,0],MultiValueOperation3.keepout_types.laser_keepout)
new_web.setcustomname(op.name)
# support = OperationOutput(new_web.output[1], "support", self)
design_copy.addoperation(new_web)
new_web.generate(design_copy)
######################## generate the same size construction line somewhere in the sheet file
# get geom for line
parts_bounding_box = new_web.output[1].generic_laminate().getBoundingBox()
# parts_bounding_box = support.generic_laminate().getBoundingBox()
# make the sketch
construction_geom_hinge = Sketch.new()
tmp_geom = [(parts_bounding_box[0],parts_bounding_box[1]), (parts_bounding_box[0],parts_bounding_box[3])]
construction_line = GenericLine.gen_from_point_lists(tmp_geom,[],construction=False)
construction_geom_hinge.addoperationgeometries([construction_line])
# add sketch to sketch list
design_copy.sketches[construction_geom_hinge.id] = construction_geom_hinge
######################## generate the external transform geometry in the sheet
# center the locate line top left as origin
position_hinge = (-tmp_geom[0][0],-tmp_geom[0][1])
locate_lines = [(x + position_hinge[0], y + position_hinge[1]) for (x,y) in tmp_geom]
# lets make 4x4
width = (parts_bounding_box[2] - parts_bounding_box[0])*self.sc + self.x_gap
height = (parts_bounding_box[3] - parts_bounding_box[1])*self.sc + self.y_gap
# check if will all fit in one window, if not fill first and check if remainder will fit in second window
max_num_cols = divmod(self.sketch_bounding_box[2] - self.sketch_bounding_box[0], width)[0]
max_num_rows = divmod(self.sketch_bounding_box[3] - self.sketch_bounding_box[1], height)[0]
if max_num_cols == 0 or max_num_rows == 0:
print('Cannot tile into this area')
design.remove_operation(new_web)
return Laminate()
# check if can fit in one
# if N <= max_num_rows*max_num_cols:
rows = math.ceil(self.N / max_num_cols)
cols = math.ceil(self.N / rows) # spread across the two windows
upper_right_origin_bounding_box = (self.sketch_bounding_box[0], self.sketch_bounding_box[3])
n_count = 0
arrayed_reference_lines = []
for row in range(rows):
for col in range(cols):
if n_count >= self.N or n_count >= max_num_rows*max_num_cols*2:
break
newx = upper_right_origin_bounding_box[0] + locate_lines[0][0] + col*width
newy = upper_right_origin_bounding_box[1] - locate_lines[1][1] - row*height
arrayed_reference_lines.append([(newx, newy), (newx, newy + height)])
n_count = n_count + 1
construction_geom_sheet = Sketch.new()
construction_line = [GenericLine.gen_from_point_lists(line,[],construction=False) for
line in arrayed_reference_lines]
construction_geom_sheet.addoperationgeometries(construction_line)
# add sketch to sketch list
design_copy.sketches[construction_geom_sheet.id] = construction_geom_sheet
######################## External transform the hinge onto the sheet construction line
# # insert hinge into sheet as subdesign
# sheet.subdesigns[hinge.id] = hinge
# # make design links
operation_links = {}
operation_links['from'] = [(part_to_insert.id,0)]
sketch_links = {}
sketch_links['sketch_to'] = [construction_geom_sheet.id]
sketch_links['sketch_from'] = [construction_geom_hinge.id]
insert_part = TransformInternal(sketch_links, operation_links, 'scale', 'scale', 0, False, 1., 1.)
insert_part.customname = 'Inserted part'
design_copy.addoperation(insert_part)
insert_part.generate(design_copy)
insert_part_id = design_copy.operations[-1].id # save for later
######################## External transform the web.sheet to the construction line
# # make design links
operation_links = {}
operation_links['from'] = [(new_web.id,1)]
sketch_links = {}
sketch_links['sketch_to'] = [construction_geom_sheet.id]
sketch_links['sketch_from'] = [construction_geom_hinge.id]
insert_webs = TransformInternal(sketch_links, operation_links, 'scale', 'scale', 0, False, 1., 1.)
insert_webs.customname = 'Inserted part webs'
design_copy.addoperation(insert_webs)
insert_webs.generate(design_copy)
######################## Remove web.sheet from sheet, union external transform + generateed sheet with hole + web
# first the difference
# link 1 is the sheet
sheet_with_hole = LaminateOperation2({'unary': [(sheet_to_insert_into.id,0)], 'binary': [(insert_webs.id,0)]},'difference')
sheet_with_hole.customname = 'Sheet with hole'
design_copy.addoperation(sheet_with_hole)
sheet_with_hole.generate(design_copy)
sheet_with_part = LaminateOperation2({'unary': [(sheet_with_hole.id,0), (insert_part_id,0)],
'binary':[]},'union')
sheet_with_part.customname = 'First pass cuts'
design_copy.addoperation(sheet_with_part)
sheet_with_part.generate(design_copy)
# ######################## Make release cut laminate operation
operation_links = {}
operation_links['from'] = [(release_to_insert_into.id,0)]
sketch_links = {}
sketch_links['sketch_to'] = [construction_geom_sheet.id]
sketch_links['sketch_from'] = [construction_geom_hinge.id]
insert_release = TransformInternal(sketch_links, operation_links, 'scale', 'scale', 0, False, 1., 1.)
design.addoperation(insert_release)
insert_release.generate(design)
######################################### prepare outputs
# delete the intermediate layers
design.remove_operation(sheet_with_hole)
design.remove_operation(insert_webs)
design.remove_operation(insert_part)
design.remove_operation(new_web)
design.remove_operation(sheet_with_part)
design.remove_operation(insert_release)
self.output = [OperationOutput(sheet_with_part.output[0].csg, 'FirstCuts', self),
OperationOutput(sheet_with_part.output[0].csg, 'FirstCuts', self),
OperationOutput(insert_release.output[0].csg, 'Release', self)]
return sheet_with_part.output[0].csg
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.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
