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