def convert_dxf2img(self, names, img_format=default_img_format, img_res=default_img_res): for name in names: doc = ezdxf.readfile(name) msp = doc.modelspace() # Recommended: audit & repair DXF document before rendering auditor = doc.audit() # The auditor.errors attribute stores severe errors, # which *may* raise exceptions when rendering. if len(auditor.errors) != 0: raise exception( "The DXF document is damaged and can't be converted!") else: fig = plt.figure() ax = fig.add_axes([0, 0, 1, 1]) ctx = RenderContext(doc) ctx.set_current_layout(msp) ctx.current_layout.set_colors(bg='#FFFFFF') out = MatplotlibBackend(ax) Frontend(ctx, out).draw_layout(msp, finalize=True) img_name = re.findall( "(\S+)\.", name ) # select the image name that is the same as the dxf file name first_param = ''.join( img_name) + img_format #concatenate list and string fig.savefig(first_param, dpi=img_res) #if __name__ == '__main__': # first = DXF2IMG() # first.convert_dxf2img(['slot_star.dxf'],img_format='.png')
def convert_dxf2img(self, names, img_format=default_img_format, img_res=default_img_res, clr=default_bg_color): for name in names: doc = ezdxf.readfile(name) msp = doc.modelspace() # Recommended: audit & repair DXF document before rendering auditor = doc.audit() # The auditor.errors attribute stores severe errors, # which *may* raise exceptions when rendering. if len(auditor.errors) != 0: raise Exception( "This DXF document is damaged and can't be converted! --> ", name) name = name = +1 else: fig = plt.figure() ax = fig.add_axes([0, 0, 1, 1]) ctx = RenderContext(doc) ctx.set_current_layout(msp) ezdxf.addons.drawing.properties.MODEL_SPACE_BG_COLOR = clr out = MatplotlibBackend(ax) Frontend(ctx, out).draw_layout(msp, finalize=True) img_name = re.findall( "(\S+)\.", name ) # select the image name that is the same as the dxf file name first_param = ''.join( img_name) + img_format #concatenate list and string fig.savefig(first_param, dpi=img_res) print(name, " Converted Successfully")
class CadViewer(qw.QMainWindow): def __init__(self, config: Configuration = Configuration.defaults()): super().__init__() self._config = config self.doc = None self._render_context = None self._visible_layers = None self._current_layout = None self._reset_backend() self.view = CADGraphicsViewWithOverlay() self.view.setScene(qw.QGraphicsScene()) self.view.scale(1, -1) # so that +y is up self.view.element_selected.connect(self._on_element_selected) self.view.mouse_moved.connect(self._on_mouse_moved) menu = self.menuBar() select_doc_action = QAction("Select Document", self) select_doc_action.triggered.connect(self._select_doc) menu.addAction(select_doc_action) self.select_layout_menu = menu.addMenu("Select Layout") toggle_sidebar_action = QAction("Toggle Sidebar", self) toggle_sidebar_action.triggered.connect(self._toggle_sidebar) menu.addAction(toggle_sidebar_action) self.sidebar = qw.QSplitter(qc.Qt.Vertical) self.layers = qw.QListWidget() self.layers.setStyleSheet( "QListWidget {font-size: 12pt;} " "QCheckBox {font-size: 12pt; padding-left: 5px;}") self.sidebar.addWidget(self.layers) info_container = qw.QWidget() info_layout = qw.QVBoxLayout() info_layout.setContentsMargins(0, 0, 0, 0) self.selected_info = qw.QPlainTextEdit() self.selected_info.setReadOnly(True) info_layout.addWidget(self.selected_info) self.mouse_pos = qw.QLabel() info_layout.addWidget(self.mouse_pos) info_container.setLayout(info_layout) self.sidebar.addWidget(info_container) container = qw.QSplitter() self.setCentralWidget(container) container.addWidget(self.view) container.addWidget(self.sidebar) container.setCollapsible(0, False) container.setCollapsible(1, True) w = container.width() container.setSizes([int(3 * w / 4), int(w / 4)]) self.setWindowTitle("CAD Viewer") self.resize(1600, 900) self.show() def _reset_backend(self, scale: float = 1.0): backend = PyQtBackend(use_text_cache=True) if scale != 1.0: backend = BackendScaler(backend, factor=scale) # clear caches self._backend = backend def _select_doc(self): path, _ = qw.QFileDialog.getOpenFileName( self, caption="Select CAD Document", filter="CAD Documents (*.dxf *.DXF *.dwg *.DWG)", ) if path: try: if os.path.splitext(path)[1].lower() == ".dwg": doc = odafc.readfile(path) auditor = doc.audit() else: try: doc = ezdxf.readfile(path) except ezdxf.DXFError: doc, auditor = recover.readfile(path) else: auditor = doc.audit() self.set_document(doc, auditor) except IOError as e: qw.QMessageBox.critical(self, "Loading Error", str(e)) except DXFStructureError as e: qw.QMessageBox.critical( self, "DXF Structure Error", f'Invalid DXF file "{path}": {str(e)}', ) def set_document( self, document: Drawing, auditor: Auditor, *, layout: str = "Model", overall_scaling_factor: float = 1.0, ): error_count = len(auditor.errors) if error_count > 0: ret = qw.QMessageBox.question( self, "Found DXF Errors", f'Found {error_count} errors in file "{document.filename}"\n' f"Load file anyway? ", ) if ret == qw.QMessageBox.No: auditor.print_error_report(auditor.errors) return self.doc = document self._render_context = RenderContext(document) self._reset_backend(scale=overall_scaling_factor) self._visible_layers = None self._current_layout = None self._populate_layouts() self._populate_layer_list() self.draw_layout(layout) self.setWindowTitle("CAD Viewer - " + str(document.filename)) def _populate_layer_list(self): self.layers.blockSignals(True) self.layers.clear() for layer in self._render_context.layers.values(): name = layer.layer item = qw.QListWidgetItem() self.layers.addItem(item) checkbox = qw.QCheckBox(name) checkbox.setCheckState( qc.Qt.Checked if layer.is_visible else qc.Qt.Unchecked) checkbox.stateChanged.connect(self._layers_updated) text_color = ("#FFFFFF" if is_dark_color(layer.color, 0.4) else "#000000") checkbox.setStyleSheet( f"color: {text_color}; background-color: {layer.color}") self.layers.setItemWidget(item, checkbox) self.layers.blockSignals(False) def _populate_layouts(self): self.select_layout_menu.clear() for layout_name in self.doc.layout_names_in_taborder(): action = QAction(layout_name, self) action.triggered.connect( lambda: self.draw_layout(layout_name, reset_view=True)) self.select_layout_menu.addAction(action) def draw_layout( self, layout_name: str, reset_view: bool = True, ): print(f"drawing {layout_name}") self._current_layout = layout_name self.view.begin_loading() new_scene = qw.QGraphicsScene() self._backend.set_scene(new_scene) layout = self.doc.layout(layout_name) self._update_render_context(layout) try: start = time.perf_counter() self.create_frontend().draw_layout(layout) duration = time.perf_counter() - start print(f"took {duration:.4f} seconds") except DXFStructureError as e: qw.QMessageBox.critical( self, "DXF Structure Error", f'Abort rendering of layout "{layout_name}": {str(e)}', ) finally: self._backend.finalize() self.view.end_loading(new_scene) self.view.buffer_scene_rect() if reset_view: self.view.fit_to_scene() def create_frontend(self): return Frontend( self._render_context, self._backend, self._config, ) def _update_render_context(self, layout): assert self._render_context self._render_context.set_current_layout(layout) # Direct modification of RenderContext.layers would be more flexible, # but would also expose the internals. if self._visible_layers is not None: self._render_context.set_layers_state(self._visible_layers, state=True) def resizeEvent(self, event: qg.QResizeEvent) -> None: self.view.fit_to_scene() def _layer_checkboxes(self) -> Iterable[Tuple[int, qw.QCheckBox]]: for i in range(self.layers.count()): item = self.layers.itemWidget(self.layers.item(i)) yield i, item # type: ignore @Slot(int) # type: ignore def _layers_updated(self, item_state: qc.Qt.CheckState): shift_held = qw.QApplication.keyboardModifiers() & qc.Qt.ShiftModifier if shift_held: for i, item in self._layer_checkboxes(): item.blockSignals(True) item.setCheckState(item_state) item.blockSignals(False) self._visible_layers = set() for i, layer in self._layer_checkboxes(): if layer.checkState() == qc.Qt.Checked: self._visible_layers.add(layer.text()) self.draw_layout(self._current_layout, reset_view=False) @Slot() def _toggle_sidebar(self): self.sidebar.setHidden(not self.sidebar.isHidden()) @Slot(qc.QPointF) def _on_mouse_moved(self, mouse_pos: qc.QPointF): self.mouse_pos.setText( f"mouse position: {mouse_pos.x():.4f}, {mouse_pos.y():.4f}\n") @Slot(object, int) def _on_element_selected(self, elements: List[qw.QGraphicsItem], index: int): if not elements: text = "No element selected" else: text = ( f"Selected: {index + 1} / {len(elements)} (click to cycle)\n" ) element = elements[index] dxf_entity = element.data(CorrespondingDXFEntity) if dxf_entity is None: text += "No data" else: text += (f"Selected Entity: {dxf_entity}\n" f"Layer: {dxf_entity.dxf.layer}\n\nDXF Attributes:\n") text += _entity_attribs_string(dxf_entity) dxf_parent_stack = element.data(CorrespondingDXFParentStack) if dxf_parent_stack: text += "\nParents:\n" for entity in reversed(dxf_parent_stack): text += f"- {entity}\n" text += _entity_attribs_string(entity, indent=" ") self.selected_info.setPlainText(text)
class CadViewer(qw.QMainWindow): def __init__(self): super().__init__() self.doc = None self._render_context = None self._visible_layers = None self._current_layout = None self.view = CADGraphicsViewWithOverlay() self.view.setScene(qw.QGraphicsScene()) self.view.scale(1, -1) # so that +y is up self.view.element_selected.connect(self._on_element_selected) self.view.mouse_moved.connect(self._on_mouse_moved) menu = self.menuBar() select_doc_action = qw.QAction('Select Document', self) select_doc_action.triggered.connect(self._select_doc) menu.addAction(select_doc_action) self.select_layout_menu = menu.addMenu('Select Layout') toggle_sidebar_action = qw.QAction('Toggle Sidebar', self) toggle_sidebar_action.triggered.connect(self._toggle_sidebar) menu.addAction(toggle_sidebar_action) self.sidebar = qw.QSplitter(qc.Qt.Vertical) self.layers = qw.QListWidget() self.layers.setStyleSheet( 'QListWidget {font-size: 12pt;} QCheckBox {font-size: 12pt; padding-left: 5px;}' ) self.sidebar.addWidget(self.layers) info_container = qw.QWidget() info_layout = qw.QVBoxLayout() info_layout.setContentsMargins(0, 0, 0, 0) self.selected_info = qw.QPlainTextEdit() self.selected_info.setReadOnly(True) info_layout.addWidget(self.selected_info) self.mouse_pos = qw.QLabel() info_layout.addWidget(self.mouse_pos) info_container.setLayout(info_layout) self.sidebar.addWidget(info_container) container = qw.QSplitter() self.setCentralWidget(container) container.addWidget(self.view) container.addWidget(self.sidebar) container.setCollapsible(0, False) container.setCollapsible(1, True) w = container.width() container.setSizes([int(3 * w / 4), int(w / 4)]) self.setWindowTitle('CAD Viewer') self.resize(1600, 900) self.show() def _select_doc(self): path, _ = qw.QFileDialog.getOpenFileName( self, caption='Select CAD Document', filter='DXF Documents(*.dxf);;DWG Documents(*.dwg)') if path: try: if os.path.splitext(path)[1].lower() == '.dwg': doc = odafc.readfile(path) else: doc = ezdxf.readfile(path) self.set_document(doc) except IOError as e: qw.QMessageBox.critical(self, 'Loading Error', str(e)) except DXFStructureError as e: qw.QMessageBox.critical( self, 'DXF Structure Error', f'Invalid DXF file "{path}": {str(e)}') def set_document(self, document: Drawing): auditor = document.audit() error_count = len(auditor.errors) if error_count > 0: ret = qw.QMessageBox.question( self, 'Found DXF Errors', f'Found {error_count} errors in file "{document.filename}"\nLoad file anyway? ' ) if ret == qw.QMessageBox.No: auditor.print_error_report(auditor.errors) return self.doc = document self._render_context = RenderContext(document) self._visible_layers = None self._current_layout = None self._populate_layouts() self._populate_layer_list() self.draw_layout('Model') self.setWindowTitle('CAD Viewer - ' + str(document.filename)) def _populate_layer_list(self): self.layers.blockSignals(True) self.layers.clear() for layer in self._render_context.layers.values(): name = layer.layer item = qw.QListWidgetItem() self.layers.addItem(item) checkbox = qw.QCheckBox(name) checkbox.setCheckState( qc.Qt.Checked if layer.is_visible else qc.Qt.Unchecked) checkbox.stateChanged.connect(self._layers_updated) text_color = '#FFFFFF' if is_dark_color(layer.color, 0.4) else '#000000' checkbox.setStyleSheet( f'color: {text_color}; background-color: {layer.color}') self.layers.setItemWidget(item, checkbox) self.layers.blockSignals(False) def _populate_layouts(self): self.select_layout_menu.clear() for layout_name in self.doc.layout_names_in_taborder(): action = qw.QAction(layout_name, self) action.triggered.connect(partial(self.draw_layout, layout_name)) self.select_layout_menu.addAction(action) def draw_layout(self, layout_name: str, reset_view: bool = True): print(f'drawing {layout_name}') self._current_layout = layout_name self.view.begin_loading() new_scene = qw.QGraphicsScene() renderer = PyQtBackend(new_scene) layout = self.doc.layout(layout_name) self._update_render_context(layout) try: Frontend(self._render_context, renderer).draw_layout(layout) except DXFStructureError as e: qw.QMessageBox.critical( self, 'DXF Structure Error', f'Abort rendering of layout "{layout_name}": {str(e)}') finally: renderer.finalize() self.view.end_loading(new_scene) self.view.buffer_scene_rect() if reset_view: self.view.fit_to_scene() def _update_render_context(self, layout): assert self._render_context self._render_context.set_current_layout(layout) # Direct modification of RenderContext.layers would be more flexible, but would also expose the internals. if self._visible_layers is not None: self._render_context.set_layers_state(self._visible_layers, state=True) def resizeEvent(self, event: qg.QResizeEvent) -> None: self.view.fit_to_scene() def _layer_checkboxes(self) -> Iterable[Tuple[int, qw.QCheckBox]]: for i in range(self.layers.count()): item = self.layers.itemWidget(self.layers.item(i)) yield i, item @qc.pyqtSlot(int) def _layers_updated(self, item_state: qc.Qt.CheckState): shift_held = qw.QApplication.keyboardModifiers() & qc.Qt.ShiftModifier if shift_held: for i, item in self._layer_checkboxes(): item.blockSignals(True) item.setCheckState(item_state) item.blockSignals(False) self._visible_layers = set() for i, layer in self._layer_checkboxes(): if layer.checkState() == qc.Qt.Checked: self._visible_layers.add(layer.text()) self.draw_layout(self._current_layout, reset_view=False) @qc.pyqtSlot() def _toggle_sidebar(self): self.sidebar.setHidden(not self.sidebar.isHidden()) @qc.pyqtSlot(qc.QPointF) def _on_mouse_moved(self, mouse_pos: qc.QPointF): self.mouse_pos.setText( f'mouse position: {mouse_pos.x():.4f}, {mouse_pos.y():.4f}\n') @qc.pyqtSlot(object, int) def _on_element_selected(self, elements: List[qw.QGraphicsItem], index: int): if not elements: text = 'No element selected' else: text = f'Selected: {index + 1} / {len(elements)} (click to cycle)\n' element = elements[index] dxf_entity = element.data(CorrespondingDXFEntity) if dxf_entity is None: text += 'No data' else: text += f'Selected Entity: {dxf_entity}\nLayer: {dxf_entity.dxf.layer}\n\nDXF Attributes:\n' text += _entity_attribs_string(dxf_entity) dxf_parent_stack = element.data(CorrespondingDXFParentStack) if dxf_parent_stack: text += '\nParents:\n' for entity in reversed(dxf_parent_stack): text += f'- {entity}\n' text += _entity_attribs_string(entity, indent=' ') self.selected_info.setPlainText(text)
class CadViewer(qw.QMainWindow): def __init__(self): super().__init__() self.doc = None self._render_context = None self._visible_layers = None self._current_layout = None self.scene = qw.QGraphicsScene() self.view = CADGraphicsViewWithOverlay() self.view.setScene(self.scene) self.view.scale(1, -1) # so that +y is up self.view.element_selected.connect(self._on_element_selected) self.renderer = PyQtBackend(self.scene) menu = self.menuBar() select_doc_action = qw.QAction('Select Document', self) select_doc_action.triggered.connect(self._select_doc) menu.addAction(select_doc_action) self.select_layout_menu = menu.addMenu('Select Layout') toggle_sidebar_action = qw.QAction('Toggle Sidebar', self) toggle_sidebar_action.triggered.connect(self._toggle_sidebar) menu.addAction(toggle_sidebar_action) toggle_join_polylines_action = qw.QAction('Toggle Join Polylines', self) toggle_join_polylines_action.triggered.connect( self._toggle_join_polylines) menu.addAction(toggle_join_polylines_action) self.sidebar = qw.QSplitter(qc.Qt.Vertical) self.layers = qw.QListWidget() self.layers.setStyleSheet('font-size: 12pt') self.layers.itemChanged.connect(self._layers_updated) self.sidebar.addWidget(self.layers) self.info = qw.QPlainTextEdit() self.info.setReadOnly(True) self.sidebar.addWidget(self.info) container = qw.QSplitter() self.setCentralWidget(container) container.addWidget(self.view) container.addWidget(self.sidebar) container.setCollapsible(0, False) container.setCollapsible(1, True) w = container.width() container.setSizes([int(3 * w / 4), int(w / 4)]) self.setWindowTitle('CAD Viewer') self.resize(1600, 900) self.show() def _select_doc(self): path, _ = qw.QFileDialog.getOpenFileName( self, caption='Select CAD Document', filter='DXF Documents (*.dxf)') if path: self.set_document(ezdxf.readfile(path)) def set_document(self, document: Drawing): self.doc = document self._render_context = RenderContext(document) self._visible_layers = None self._current_layout = None self._populate_layouts() self._populate_layer_list() self.draw_layout('Model') def _populate_layer_list(self): self.layers.blockSignals(True) self.layers.clear() for layer in self._render_context.layers.values(): name = layer.layer item = qw.QListWidgetItem(name) item.setCheckState(qc.Qt.Checked) item.setBackground(qg.QColor(layer.color)) self.layers.addItem(item) self.layers.blockSignals(False) def _populate_layouts(self): self.select_layout_menu.clear() for layout_name in self.doc.layout_names_in_taborder(): action = qw.QAction(layout_name, self) action.triggered.connect(partial(self.draw_layout, layout_name)) self.select_layout_menu.addAction(action) def draw_layout(self, layout_name: str): print(f'drawing {layout_name}') self._current_layout = layout_name self.renderer.clear() self.view.clear() layout = self.doc.layout(layout_name) self._update_render_context(layout) Frontend(self._render_context, self.renderer).draw_layout(layout) self.view.fit_to_scene() def _update_render_context(self, layout): assert self._render_context self._render_context.set_current_layout(layout) # Direct modification of RenderContext.layers would be more flexible, but would also expose the internals. if self._visible_layers is not None: self._render_context.set_layers_state(self._visible_layers, state=True) def resizeEvent(self, event: qg.QResizeEvent) -> None: self.view.fit_to_scene() @qc.pyqtSlot(qw.QListWidgetItem) def _layers_updated(self, _item: qw.QListWidgetItem): self._visible_layers = set() for i in range(self.layers.count()): layer = self.layers.item(i) if layer.checkState() == qc.Qt.Checked: self._visible_layers.add(layer.text()) self.draw_layout(self._current_layout) @qc.pyqtSlot() def _toggle_sidebar(self): self.sidebar.setHidden(not self.sidebar.isHidden()) @qc.pyqtSlot() def _toggle_join_polylines(self): self.renderer.draw_individual_polyline_elements = not self.renderer.draw_individual_polyline_elements self.draw_layout(self._current_layout) @qc.pyqtSlot(object, qc.QPointF) def _on_element_selected(self, element: Optional[qw.QGraphicsItem], mouse_pos: qc.QPointF): text = f'mouse position: {mouse_pos.x():.4f}, {mouse_pos.y():.4f}\n' if element is None: text += 'No element selected' else: dxf_entity = element.data(CorrespondingDXFEntity) if dxf_entity is None: text += 'No data' else: text += f'Current Entity: {dxf_entity}\nLayer: {dxf_entity.dxf.layer}\n\nDXF Attributes:\n' for key, value in dxf_entity.dxf.all_existing_dxf_attribs( ).items(): text += f'- {key}: {value}\n' dxf_entity_stack = element.data(CorrespondingDXFEntityStack) if dxf_entity_stack: text += '\nParents:\n' for entity in reversed(dxf_entity_stack): text += f'- {entity}\n' self.info.setPlainText(text)
class MainWindow(qw.QMainWindow, Ui_MainWindow): def __init__(self, controller): super().__init__() self.controller = controller self.setupUi(self) self.scene = qw.QGraphicsScene() items = self.scene.items() for item in items: item.transformations() self.view = self.graphicsView self.view.setScene(self.scene) self.view.scale(1, -1) # so that +y is up self.view.element_selected.connect(self._on_element_selected) self.actionImport_DXF.triggered.connect(self.import_dxf) self.actionNew_Origin.triggered.connect(self.show_origin_dialog) self.actionNew_Setup.triggered.connect(self.show_new_setup_dialog) self.new_face.triggered.connect(self.show_new_face_feature_dialog) self.new_drill.triggered.connect(self.show_new_drill_feature_dialog) self.new_slot.triggered.connect(self.show_new_slot_feature_dialog) self.treeView.setContextMenuPolicy(qc.Qt.CustomContextMenu) self.treeView.customContextMenuRequested.connect( self.show_r_click_tree_menu) self.position_widget = PositionWidget() self.statusbar.addWidget(self.position_widget) self.position_widget.change_current_origin.connect( self.change_current_origin) self.position_widget.change_active_setup.connect( self.change_active_setup) self.save_nc_button.clicked.connect(self.save_nc_file) self.actionPost.triggered.connect(self.post_file) self.actionSet_DB.triggered.connect( self.controller.show_connect_dialog) self.actionGeometry_Palette.triggered.connect( self.show_geometry_palette) self.geometry_palette_dialog = None self.origin_dialog = None self.setup_dialog = None self.feature_dialog = None self.tree_r_click_menu = None self.picker_axis = None self.all_dxf_entities = {} self.selected_dxf_entities = [] self.model_space = None self.right_click_point = None self.picked_item_vector = None self.scene_origin = None self.image = qg.QPixmap('img/splash.png') self.editor_setup = None self.editor_origin = None self.editor_feature = None self.renderer = PyQtBackend(self.scene) self.doc = None self._render_context = None self._visible_layers = None self._current_layout = None self.scene_shift = (0, 0, 0) self.hidden_dialogs = [] def post_file(self): self.get_all_dxf_entities() self.controller.update_machine() self.controller.populate_operation_list() if hasattr(self.controller.current_camo_file, 'operations'): if len(self.controller.current_camo_file.operations) > 0: code_builder = CodeBuilder(self.controller) self.controller.nc_output = code_builder.post() self.nc_output_edit.setText(self.controller.nc_output) self.tabWidget.setCurrentWidget(self.code_tab) else: show_error_message( 'No features', 'please have active setup with features to post NC code') def save_nc_file(self): default_filename = self.controller.current_camo_file.filename if default_filename: default_filename = default_filename.replace('.camo', '.NC') filename, _ = qw.QFileDialog.getSaveFileName(self, 'Save .NC File', default_filename, filter='*.NC') if filename: with open(filename, 'w') as file: file.writelines(self.nc_output_edit.toPlainText()) def get_all_dxf_entities(self): msp = self.controller.current_camo_file.dxf_doc.modelspace() self.all_dxf_entities = {} for entity in msp: self.all_dxf_entities[str(entity)] = entity def show_geometry_palette(self): self.geometry_palette_dialog = GeoPaletteDialog() self.geometry_palette_dialog.show() def show_r_click_tree_menu(self, point): self.right_click_point = point self.tree_r_click_menu = qw.QMenu() edit_tree_item_action = qw.QAction('Edit', self) edit_tree_item_action.triggered.connect(self.edit_tree_item) delete_tree_item_action = qw.QAction('Delete', self) delete_tree_item_action.triggered.connect(self.delete_tree_item) self.tree_r_click_menu.addAction(edit_tree_item_action) self.tree_r_click_menu.addAction(delete_tree_item_action) self.tree_r_click_menu.exec(self.treeView.mapToGlobal(point)) print('rclick') def get_right_clicked_tree_item(self): index = self.treeView.indexAt(self.right_click_point) node = index.internalPointer() return index, node def edit_tree_item(self, ): _, node = self.get_right_clicked_tree_item() if node.type == ct.OSetup: self.show_edit_setup_dialog(node._data[1]) elif node.type == ct.OOrigin: self.show_edit_origin_dialog(node._data[1]) elif node.type == ct.OFeature: self.show_edit_feature_dialog(node._data[1]) print(node) def delete_tree_item(self): selected_node = self.treeView.indexAt(self.right_click_point) item = selected_node.internalPointer() print(item) item = item._data[1] if isinstance(item, Setup): self.controller.current_camo_file.setups.remove(item) elif isinstance(item, Origin): self.controller.current_camo_file.origins.remove(item) elif isinstance(item, PartFeature): self.controller.current_camo_file.features.remove(item) elif hasattr(item, 'DXFTYPE'): self.controller.current_camo_file.dxf_doc.modelspace( ).delete_entity(item) else: return self.set_document(self.controller.current_camo_file.dxf_doc) self.controller.build_file_tree_model() def populate_origin_comboBox(self): self.position_widget.origin_combo.clear() for origin in self.controller.current_camo_file.origins: self.position_widget.origin_combo.addItem(origin.name, origin) def populate_active_setup_combo(self): self.position_widget.active_setup_combo.clear() for setup in self.controller.current_camo_file.setups: self.position_widget.active_setup_combo.addItem(setup.name, setup) def change_current_origin(self, origin): if origin: self.controller.current_camo_file.active_origin = origin self.apply_origin_to_scene() def apply_origin_to_scene(self): self.reset_scene_shift() x = self.controller.current_camo_file.active_origin.x y = self.controller.current_camo_file.active_origin.y a = self.controller.current_camo_file.active_origin.angle self.scene_shift = (x, y, a) self.graphicsView.rotate(a) self.scene_origin.setX(x) self.scene_origin.setY(y) self.scene_origin.setRotation(-a) def reset_scene_shift(self): x, y, a = self.scene_shift self.graphicsView.rotate(360 - a) self.scene_origin.setX(-x) self.scene_origin.setY(-y) self.scene_origin.setRotation(a) self.scene_shift = (0, 0, 0) def change_active_setup(self, setup): if setup: self.controller.current_camo_file.active_setup = setup self.controller.populate_operation_list() def show_origin_dialog(self): self.origin_dialog = OriginDialog() self.origin_dialog.find_x.clicked.connect(self.find_x) self.origin_dialog.find_y.clicked.connect(self.find_y) self.origin_dialog.buttonBox.accepted.connect(self.add_new_origin) self.origin_dialog.show() def find_x(self): self.origin_dialog.hide() self.picker_axis = 'x' self.graphicsView.graphics_view_clicked.connect( self.dxf_entity_clicked_origin) def find_y(self): self.origin_dialog.hide() self.picker_axis = 'y' self.graphicsView.graphics_view_clicked.connect( self.dxf_entity_clicked_origin) def dxf_entity_clicked_origin(self, item): item_data = item.data(0) picked_item_vector = None if item_data.DXFTYPE == 'LINE': picked_item_vector = item_data.dxf.start elif item_data.DXFTYPE == 'CIRCLE': picked_item_vector = item_data.dxf.center elif item_data.DXFTYPE == 'ARC': picked_item_vector = item_data.dxf.center if picked_item_vector: if self.picker_axis == 'x': self.origin_dialog.origin_x.setText( str(round(picked_item_vector.x, 4))) elif self.picker_axis == 'y': self.origin_dialog.origin_y.setText( str(round(picked_item_vector.y, 4))) self.origin_dialog.showNormal() self.graphicsView.graphics_view_clicked.disconnect( self.dxf_entity_clicked_origin) def show_edit_origin_dialog(self, origin): self.show_origin_dialog() self.editor_origin = origin self.origin_dialog.buttonBox.accepted.disconnect(self.add_new_origin) self.origin_dialog.buttonBox.accepted.connect(self.edit_origin) self.origin_dialog.origin_name_input.setText(origin.name) self.origin_dialog.origin_x.setText(str(origin.x)) self.origin_dialog.origin_y.setText(str(origin.y)) self.origin_dialog.angle_input.setText(str(origin.angle)) self.origin_dialog.wfo_spinBox.setValue(origin.wfo_num) def add_new_origin(self): name, wfo, x, y, angle = self.clean_origin_values_from_dialog() origin = Origin(name, wfo, x, y, angle) self.controller.current_camo_file.origins.append(origin) self.controller.build_file_tree_model() self.populate_origin_comboBox() def edit_origin(self): name, wfo, x, y, angle = self.clean_origin_values_from_dialog() self.editor_origin.name = name self.editor_origin.x = x self.editor_origin.y = y self.editor_origin.angle = angle self.editor_origin.wfo_num = wfo self.editor_origin.angle = angle self.controller.build_file_tree_model() def clean_origin_values_from_dialog(self): name = self.origin_dialog.origin_name_input.text() x = self.origin_dialog.origin_x.text() y = self.origin_dialog.origin_y.text() angle = self.origin_dialog.angle_input.text() wfo = self.origin_dialog.wfo_spinBox.value() if x == '': x = 0 if y == '': y = 0 if angle == '': angle = 0 return name, wfo, float(x), float(y), float(angle) def show_new_setup_dialog(self): if len(self.controller.current_camo_file.origins) < 1: show_error_message('Error', 'Please add origin') return self.setup_dialog = SetupDialog(self.controller) self.setup_dialog.buttonBox.accepted.connect(self.add_new_setup) self.setup_dialog.show() def show_edit_feature_dialog(self, feature): self.feature_dialog = FeatureDialog(self.controller) self.editor_feature = feature base_feature = self.controller.session.query(Feature).filter( Feature.id == self.editor_feature.base_feature_id).one() print(base_feature) def show_edit_setup_dialog(self, setup): self.setup_dialog = SetupDialog(self.controller) self.editor_setup = setup self.setup_dialog.buttonBox.accepted.connect(self.edit_setup) self.setup_dialog.machine_combo.setCurrentIndex( self.setup_dialog.machine_combo.findText( setup.get_machine(self.controller.session).name)) self.setup_dialog.origin_combo.setCurrentIndex( self.setup_dialog.origin_combo.findText(setup.origin.name)) self.setup_dialog.clearance_spinbox.setValue(setup.clearance_plane) self.setup_dialog.setup_name_input.setText(setup.name) self.setup_dialog.program_number_spinbox.setValue(setup.program_number) # setup.qb_setup_id = '' self.setup_dialog.setup_id_edit.setText(setup.qb_setup_id) self.setup_dialog.show() def add_new_setup(self): name = self.setup_dialog.setup_name_input.text() machine = get_combo_data(self.setup_dialog.machine_combo) origin = get_combo_data(self.setup_dialog.origin_combo) clearance = self.setup_dialog.clearance_spinbox.value() program_number = self.setup_dialog.program_number_spinbox.value() setup_id = self.setup_dialog.setup_id_edit.text() setup = Setup(name, machine.id, origin, clearance, program_number, setup_id) self.controller.current_camo_file.setups.append(setup) self.controller.build_file_tree_model() self.populate_active_setup_combo() def edit_setup(self): self.editor_setup.name = self.setup_dialog.setup_name_input.text() self.editor_setup.machine = get_combo_data( self.setup_dialog.machine_combo) self.editor_setup.machine_id = self.editor_setup.machine.id self.editor_setup.origin = self.setup_dialog.origin_combo.itemData( self.setup_dialog.origin_combo.currentIndex()) self.editor_setup.clearance_plane = self.setup_dialog.clearance_spinbox.value( ) self.editor_setup.program_number = self.setup_dialog.program_number_spinbox.value( ) self.editor_setup.qb_setup_id = self.setup_dialog.setup_id_edit.text() self.controller.build_file_tree_model() def show_feature_dialog(self): if len(self.controller.current_camo_file.setups) < 1: show_error_message('Error', 'Please add setup') return self.feature_dialog = FeatureDialog(self.controller) for setup in self.controller.current_camo_file.setups: self.feature_dialog.setup_combo.addItem(setup.name, setup) self.feature_dialog.buttonBox.rejected.connect( self.feature_dialog.reject) self.feature_dialog.base_feature_combo.currentIndexChanged.connect( self.populate_depth_inputs) self.feature_dialog.show() def populate_filtered_base_feature_list(self, features): for feature in features: self.feature_dialog.base_feature_combo.addItem( feature.name, feature) def show_face_feature_dialog(self): self.show_feature_dialog() if self.feature_dialog: filtered_list = [ feature for feature in self.controller.feature_list.features if feature.feature_type.feature_type == 'Facing' ] self.populate_filtered_base_feature_list(filtered_list) face_widget = FaceWidget() self.feature_dialog.frame_layout.addWidget(face_widget) def show_drill_feature_dialog(self): self.show_feature_dialog() if self.feature_dialog: filtered_list = [ feature for feature in self.controller.feature_list.features if feature.feature_type.feature_type == 'Drilling' ] self.populate_filtered_base_feature_list(filtered_list) self.feature_dialog.drill_widget = DrillWidget() self.feature_dialog.frame_layout.addWidget( self.feature_dialog.drill_widget) self.feature_dialog.drill_widget.select_sample_circle.clicked.connect( self.find_circle_diameter) self.feature_dialog.drill_widget.find_cirlces_button.clicked.connect( self.find_circles) def show_slot_feature_dialog(self): filtered_list = [ feature for feature in self.controller.feature_list.features if feature.feature_type.feature_type == 'Slotting' ] if len(filtered_list) < 1: show_error_message('Error', 'Please add Slot to database Features') return self.show_feature_dialog() if self.feature_dialog: self.populate_filtered_base_feature_list(filtered_list) self.feature_dialog.slot_widget = SlotWidget() self.feature_dialog.frame_layout.addWidget( self.feature_dialog.slot_widget) self.feature_dialog.slot_widget.add_line_button.clicked.connect( self.add_slot_line) def show_new_face_feature_dialog(self): self.show_face_feature_dialog() self.feature_dialog.buttonBox.accepted.connect(self.add_face_feature) def show_new_drill_feature_dialog(self): self.show_drill_feature_dialog() if self.feature_dialog: self.feature_dialog.buttonBox.accepted.connect( self.add_drill_feature) def show_new_slot_feature_dialog(self): self.show_slot_feature_dialog() if self.feature_dialog: self.feature_dialog.selected_slot_lines = [] self.feature_dialog.buttonBox.accepted.connect( self.add_slot_feature) def populate_depth_inputs(self, index): feature = get_combo_data_index(self.feature_dialog.base_feature_combo, index) # for i in reversed(range(self.feature_dialog.depth_groupBox.layout().count())): # self.feature_dialog.depth_groupBox.layout().itemAt(i).widget().setParent(None) clearLayout(self.feature_dialog.depth_groupBox.layout()) for op in feature.operations: print(str(op.camo_op.op_type)) depth_widget = DepthWidget(op.camo_op.op_type) self.feature_dialog.depth_groupBox.layout().addWidget(depth_widget) def add_face_feature(self): base_feature = get_combo_data(self.feature_dialog.base_feature_combo) print(base_feature) setup = get_combo_data(self.feature_dialog.setup_combo) print(setup) depths = get_depths_from_layout( self.feature_dialog.depth_groupBox.layout()) feature = PartFeature(base_feature.id, setup, depths=depths) self.controller.current_camo_file.features.append(feature) self.controller.build_file_tree_model() def add_slot_feature(self): base_feature = get_combo_data(self.feature_dialog.base_feature_combo) setup = get_combo_data(self.feature_dialog.setup_combo) geo = self.feature_dialog.selected_slot_lines if len(geo) > 0: depths = get_depths_from_layout( self.feature_dialog.depth_groupBox.layout()) feature = PartFeature(base_feature.id, setup, geometry=geo, depths=depths) self.controller.current_camo_file.features.append(feature) self.controller.build_file_tree_model() def add_drill_feature(self): base_feature = get_combo_data(self.feature_dialog.base_feature_combo) setup = get_combo_data(self.feature_dialog.setup_combo) geo = self.feature_dialog.drill_widget.selected_circles depths = get_depths_from_layout( self.feature_dialog.depth_groupBox.layout()) feature = PartFeature(base_feature.id, setup, geometry=geo, depths=depths) self.controller.current_camo_file.features.append(feature) self.controller.build_file_tree_model() def add_slot_line(self): self.feature_dialog.hide() self.graphicsView.graphics_view_clicked.connect( self.dxf_entity_clicked_slot_line) def dxf_entity_clicked_slot_line(self, item): item_data = item.data(0) line = None if item_data.DXFTYPE == 'LINE': line = item_data if line: self.feature_dialog.selected_slot_lines.append(str(line)) self.feature_dialog.slot_widget.line_list.addItem(str(line)) self.feature_dialog.show() self.graphicsView.graphics_view_clicked.disconnect( self.dxf_entity_clicked_slot_line) def find_circle_diameter(self): self.feature_dialog.hide() self.graphicsView.graphics_view_clicked.connect( self.dxf_entity_clicked_circle_diameter) def find_circles(self): diameter = self.feature_dialog.drill_widget.diameter_edit.text() try: diameter = float(diameter) assert diameter > 0 except: show_error_message('Error', 'No diameter given') return circles = [ entity for entity in self.controller.current_camo_file.dxf_doc.modelspace( ).entity_space.entities if entity.DXFTYPE == 'CIRCLE' ] filtered_circles = [ circle for circle in circles if math.isclose(circle.dxf.radius * 2, diameter, rel_tol=.0002) ] self.feature_dialog.drill_widget.geometry_list.clear() self.feature_dialog.drill_widget.selected_circles = [ str(x) for x in filtered_circles ] for circle in filtered_circles: item = qw.QListWidgetItem(str(circle)) item.circle = circle self.feature_dialog.drill_widget.geometry_list.addItem(item) self.feature_dialog.drill_widget.lcdNumber.display( len(filtered_circles)) def dxf_entity_clicked_circle_diameter(self, item): item_data = item.data(0) diameter = None if item_data.DXFTYPE == 'CIRCLE': diameter = item_data.dxf.radius * 2 elif item_data.DXFTYPE == 'ARC': diameter = item_data.dxf.radius * 2 if diameter: self.feature_dialog.drill_widget.diameter_edit.setText( str(round(diameter, 4))) self.feature_dialog.show() self.graphicsView.graphics_view_clicked.disconnect( self.dxf_entity_clicked_circle_diameter) print(diameter) # def fill_dxf_select_list(self, element: Optional[qw.QGraphicsItem]): # self.selected_dxf_entities.append(element.data(0)) # print(element) def import_dxf(self): path, _ = qw.QFileDialog.getOpenFileName( self, caption='Select CAD Document', filter='DXF Documents (*.dxf)') if path: incoming_dxf = ezdxf.readfile(path) importer = Importer(incoming_dxf, self.controller.current_camo_file.dxf_doc) # import all entities from source modelspace into modelspace of the target drawing importer.import_modelspace() importer.finalize() self.set_document(self.controller.current_camo_file.dxf_doc) self.controller.build_file_tree_model() def set_document(self, document: Drawing): self.doc = document self._render_context = RenderContext(document) self._visible_layers = None self._current_layout = None # self._populate_layouts() self._populate_layer_list() self.draw_layout('Model') self.model_space = self.doc.modelspace() self.all_dxf_entities = {} for entity in self.model_space.entity_space: self.all_dxf_entities[str(entity)] = entity if entity.DXFTYPE == "CIRCLE": if hasattr(entity.dxf, 'extrusion'): print(entity.dxf.extrusion) if entity.dxf.extrusion[2] == -1: entity.dxf.extrusion = Vector(0, 0, 1) # entity.dxf.center = Vector(-(entity.dxf.center.x), -(entity.dxf.center.y), 0) self.draw_origin() self.apply_origin_to_scene() def _populate_layer_list(self): self.layers.blockSignals(True) self.layers.clear() for layer in self._render_context.layers.values(): name = layer.layer item = qw.QListWidgetItem(name) item.setCheckState(qc.Qt.Checked) item.setBackground(qg.QColor(layer.color)) self.layers.addItem(item) self.layers.blockSignals(False) def draw_origin(self): pen = qg.QPen(qg.QColor('#e533e5'), 2) pen.setCosmetic(True) # changes width depending on zoom pen.setJoinStyle(qc.Qt.RoundJoin) length = self.scene.itemsBoundingRect().width() / 16 diameter = length / 10 origin_item = qw.QGraphicsItemGroup() circle = qw.QGraphicsEllipseItem( qc.QRectF(-diameter / 2, -diameter / 2, diameter, diameter)) circle.setPen(pen) circle.setEnabled(False) origin_item.addToGroup(circle) x_line = qw.QGraphicsLineItem( 0, 0, length, 0, ) x_line.setPen(pen) origin_item.addToGroup(x_line) y_line = qw.QGraphicsLineItem(0, 0, 0, length) y_line.setPen(pen) origin_item.addToGroup(y_line) origin_item.setEnabled(False) origin_item.setZValue(-1) self.scene_origin = origin_item self.scene.addItem(self.scene_origin) def draw_layout(self, layout_name: str): print(f'drawing {layout_name}') self._current_layout = layout_name self.renderer.clear() self.view.clear() layout = self.doc.layout(layout_name) self._update_render_context(layout) Frontend(self._render_context, self.renderer).draw_layout(layout) self.view.fit_to_scene() def _update_render_context(self, layout): assert self._render_context self._render_context.set_current_layout(layout) # Direct modification of RenderContext.layers would be more flexible, but would also expose the internals. if self._visible_layers is not None: self._render_context.set_layers_state(self._visible_layers, state=True) def resizeEvent(self, event: qg.QResizeEvent) -> None: self.view.fit_to_scene() @qc.pyqtSlot(qw.QListWidgetItem) def _layers_updated(self, _item: qw.QListWidgetItem): self._visible_layers = set() for i in range(self.layers.count()): layer = self.layers.item(i) if layer.checkState() == qc.Qt.Checked: self._visible_layers.add(layer.text()) self.draw_layout(self._current_layout) @qc.pyqtSlot() def _toggle_sidebar(self): self.sidebar.setHidden(not self.sidebar.isHidden()) @qc.pyqtSlot() def _toggle_join_polylines(self): self.renderer.draw_individual_polyline_elements = not self.renderer.draw_individual_polyline_elements self.draw_layout(self._current_layout) @qc.pyqtSlot(object, qc.QPointF) def _on_element_selected(self, element: Optional[qw.QGraphicsItem], mouse_pos: qc.QPointF): shifted_position = (mouse_pos.x() - self.scene_shift[0], mouse_pos.y() - self.scene_shift[1]) x, y = shifted_position x, y = rotate_point((x, y), -self.scene_shift[2]) # rotate also here text = f'mouse position: {shifted_position[0]:.4f}, {shifted_position[1]:.4f}\n' self.position_widget.xlabel.setText(f'X: {x:.4f}') self.position_widget.ylabel.setText(f'Y: {y:.4f}') if element is None: text += 'No element selected' else: dxf_entity = element.data(CorrespondingDXFEntity) if dxf_entity is None: text += 'No data' else: text += f'Current Entity: {dxf_entity}\nLayer: {dxf_entity.dxf.layer}\n\nDXF Attributes:\n' attribs = dxf_entity.dxf.all_existing_dxf_attribs() for key, value in attribs.items(): text += f'- {key}: {value}\n' dxf_entity_stack = element.data(CorrespondingDXFEntityStack) # model = self.controller.main_window.treeView.model() # view = self.treeView # if model and model.indexes: this doe the tree select based on hover # view.setCurrentIndex(model.indexes[str(dxf_entity)]) if dxf_entity_stack: text += '\nParents:\n' for entity in reversed(dxf_entity_stack): text += f'- {entity}\n' self.info.setPlainText(text)