Hermes/fluencyCAD
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Bsic sketch to object approach

Browse Source
This commit is contained in:
bklronin 2024-07-28 13:46:55 +02:00
parent cebe1b41e7
commit b80185e93e
3 changed files with 182 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

243
drawing_modules/draw_widget2d.py
View File

@ -1,6 +1,7 @@
import math
import re
from copy import copy
from typing import Optional
import numpy as np
from PySide6.QtWidgets import QApplication, QWidget, QMessageBox, QInputDialog
@ -19,9 +20,6 @@ class SketchWidget(QWidget):
self.drag_buffer = [None, None]
self.main_buffer = [None, None]
self.proj_snap_points = []
self.proj_snap_lines = []
self.hovered_point = None
self.selected_line = None
@ -30,11 +28,17 @@ class SketchWidget(QWidget):
self.setMouseTracking(True)
self.mouse_mode = False
self.wp = None
self.solv = SolverSystem()
self.slv_points_main = []
self.slv_lines_main = []
self.sketch = None
def set_sketch(self, sketch) -> None:
print(sketch)
self.sketch = sketch
self.create_workplane()
def get_sketch(self):
return self.sketch
def reset_buffers(self):
self.line_draw_buffer = [None, None]
@ -46,44 +50,28 @@ class SketchWidget(QWidget):
#self.update()
def create_workplane(self):
self.wp = self.solv.create_2d_base()
self.sketch.working_plane = self.solv.create_2d_base()
def create_workplane_projected(self):
self.wp = self.solv.create_2d_base()
self.sketch.working_plane = self.solv.create_2d_base()
def create_proj_points(self, proj_points):
"""Lines as orientation projected from the sketch"""
for point in proj_points:
def convert_proj_points(self):
out_points = []
for point in self.sketch.proj_points:
x, y = point
coord = QPoint(x, y)
self.proj_snap_points.append(coord)
out_points.append(coord)
"""relation_point = {} # Reinitialize the dictionary
#handle_nr = self.get_handle_nr(str(point))
#relation_point['handle_nr'] = handle_nr
#relation_point['solv_handle'] = point
relation_point['ui_point'] = QPoint(x, y)
self.sketch.proj_points = out_points
self.slv_points_main.append(relation_point)"""
def create_proj_lines(self, sel_edges):
"""Lines as orientation projected from the sketch"""
print("Incoming corrd lines", sel_edges)
for line in sel_edges:
start = QPoint(line[0][0], line[0][1] )
def convert_proj_lines(self):
out_lines = []
for line in self.sketch.proj_lines:
start = QPoint(line[0][0], line[0][1])
end = QPoint(line[1][0], line[1][1])
coord = QLine(start, end)
self.proj_snap_lines.append(coord)
"""relation_point = {} # Reinitialize the dictionary
#handle_nr = self.get_handle_nr(str(point))
#relation_point['handle_nr'] = handle_nr
#relation_point['solv_handle'] = point
relation_point['ui_point'] = QPoint(x, y)
self.slv_points_main.append(relation_point)"""
out_lines.append(coord)
self.sketch.proj_lines = out_lines
def find_duplicate_points_2d(self, edges):
points = []
@ -132,8 +120,8 @@ class SketchWidget(QWidget):
qw, qx, qy, qz = self.normal_to_quaternion(normal)
slv_normal = self.solv.add_normal_3d(qw, qx, qy, qz)
self.wp = self.solv.add_work_plane(origin_handle, slv_normal)
print(self.wp)
self.sketch.working_plane = self.solv.add_work_plane(origin_handle, slv_normal)
print(self.sketch.working_plane)
def get_handle_nr(self, input_str: str) -> int:
# Define the regex pattern to extract the handle number
@ -168,7 +156,7 @@ class SketchWidget(QWidget):
def get_handle_from_ui_point(self, ui_point: QPoint):
"""Input QPoint and you shall reveive a slvs entity handle!"""
for point in self.slv_points_main:
for point in self.sketch.slv_points:
if ui_point == point['ui_point']:
slv_handle = point['solv_handle']
@ -176,7 +164,7 @@ class SketchWidget(QWidget):
def get_line_handle_from_ui_point(self, ui_point: QPoint):
"""Input Qpoint that is on a line and you shall receive the handle of the line!"""
for target_line_con in self.slv_lines_main:
for target_line_con in self.sketch.slv_lines:
if self.is_point_on_line(ui_point, target_line_con['ui_points'][0], target_line_con['ui_points'][1]):
slv_handle = target_line_con['solv_handle']
@ -184,7 +172,7 @@ class SketchWidget(QWidget):
def get_point_line_handles_from_ui_point(self, ui_point: QPoint) -> tuple:
"""Input Qpoint that is on a line and you shall receive the handles of the points of the line!"""
for target_line_con in self.slv_lines_main:
for target_line_con in self.sketch.slv_lines:
if self.is_point_on_line(ui_point, target_line_con['ui_points'][0], target_line_con['ui_points'][1]):
lines_to_cons = target_line_con['solv_entity_points']
@ -231,7 +219,7 @@ class SketchWidget(QWidget):
old_points_ui = []
new_points_ui = []
for old_point_ui in self.slv_points_main:
for old_point_ui in self.sketch.slv_points:
old_points_ui.append(old_point_ui['ui_point'])
for i in range(self.solv.entity_len()):
@ -265,14 +253,14 @@ class SketchWidget(QWidget):
index, old_point, new_point = tbu_points_idx
# Update the point in slv_points_main
self.slv_points_main[index]['ui_point'] = new_point
self.sketch.slv_points[index]['ui_point'] = new_point
# Print updated state
# print("Updated slv_points_main:", self.slv_points_main)
def check_all_lines_and_update(self,changed_points: list):
for tbu_points_idx in changed_points:
index, old_point, new_point = tbu_points_idx
for line_needs_update in self.slv_lines_main:
for line_needs_update in self.sketch.slv_lines:
if old_point == line_needs_update['ui_points'][0]:
line_needs_update['ui_points'][0] = new_point
elif old_point == line_needs_update['ui_points'][1]:
@ -334,7 +322,7 @@ class SketchWidget(QWidget):
u = clicked_pos.x()
v = clicked_pos.y()
point = self.solv.add_point_2d(u, v, self.wp)
point = self.solv.add_point_2d(u, v, self.sketch.working_plane)
relation_point = {} # Reinitialize the dictionary
handle_nr = self.get_handle_nr(str(point))
@ -342,17 +330,17 @@ class SketchWidget(QWidget):
relation_point['solv_handle'] = point
relation_point['ui_point'] = clicked_pos
self.slv_points_main.append(relation_point)
self.sketch.slv_points.append(relation_point)
print("points", self.slv_points_main)
print("lines", self.slv_lines_main)
print("points", self.sketch.slv_points)
print("lines", self.sketch.slv_lines)
elif self.line_draw_buffer[0]:
self.line_draw_buffer[1] = clicked_pos
u = clicked_pos.x()
v = clicked_pos.y()
point2 = self.solv.add_point_2d(u, v, self.wp)
point2 = self.solv.add_point_2d(u, v, self.sketch.working_plane)
relation_point = {} # Reinitialize the dictionary
handle_nr = self.get_handle_nr(str(point2))
@ -360,19 +348,18 @@ class SketchWidget(QWidget):
relation_point['solv_handle'] = point2
relation_point['ui_point'] = clicked_pos
self.slv_points_main.append(relation_point)
self.sketch.slv_points.append(relation_point)
print("points", self.slv_points_main)
print("lines", self.slv_lines_main)
print("points", self.sketch.slv_points)
print("lines", self.sketch.slv_lines)
print("Buffer state", self.line_draw_buffer)
if self.line_draw_buffer[0] and self.line_draw_buffer[1]:
point_slv1 = self.get_handle_from_ui_point(self.line_draw_buffer[0])
point_slv2 = self.get_handle_from_ui_point(self.line_draw_buffer[1])
print(point_slv1)
print(point_slv2)
line = self.solv.add_line_2d(point_slv1, point_slv2, self.wp)
line = self.solv.add_line_2d(point_slv1, point_slv2, self.sketch.working_plane)
relation_line = {} # Reinitialize the dictionary
handle_nr_line = self.get_handle_nr(str(line))
@ -384,7 +371,7 @@ class SketchWidget(QWidget):
# Track relationship of point in line
relation_point['part_of_entity'] = handle_nr_line
self.slv_lines_main.append(relation_line)
self.sketch.slv_lines.append(relation_line)
# Reset the buffer for the next line segment
self.line_draw_buffer[0] = self.line_draw_buffer[1]
@ -403,7 +390,7 @@ class SketchWidget(QWidget):
if self.main_buffer[0] and self.main_buffer[1]:
print("buf", self.main_buffer)
self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.wp)
self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.sketch.working_plane)
if self.solv.solve() == ResultFlag.OKAY:
print("Fuck yeah")
@ -431,7 +418,7 @@ class SketchWidget(QWidget):
# Contrain point to line
if self.main_buffer[1]:
self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.wp)
self.solv.coincident(self.main_buffer[0], self.main_buffer[1], self.sketch.working_plane)
if self.solv.solve() == ResultFlag.OKAY:
print("Fuck yeah")
@ -462,7 +449,7 @@ class SketchWidget(QWidget):
# Contrain point to line
if self.main_buffer[1]:
self.solv.midpoint(self.main_buffer[0], self.main_buffer[1], self.wp)
self.solv.midpoint(self.main_buffer[0], self.main_buffer[1], self.sketch.working_plane)
if self.solv.solve() == ResultFlag.OKAY:
print("Fuck yeah")
@ -484,7 +471,7 @@ class SketchWidget(QWidget):
line_selected = self.get_line_handle_from_ui_point(local_event_pos)
if line_selected:
self.solv.horizontal(line_selected, self.wp)
self.solv.horizontal(line_selected, self.sketch.working_plane)
if self.solv.solve() == ResultFlag.OKAY:
print("Fuck yeah")
@ -502,7 +489,7 @@ class SketchWidget(QWidget):
line_selected = self.get_line_handle_from_ui_point(local_event_pos)
if line_selected:
self.solv.vertical(line_selected, self.wp)
self.solv.vertical(line_selected, self.sketch.working_plane)
if self.solv.solve() == ResultFlag.OKAY:
print("Fuck yeah")
@ -543,7 +530,7 @@ class SketchWidget(QWidget):
if e1 and e2:
# Ask fo the dimension and solve if both elements are present
length, ok = QInputDialog.getDouble(self, 'Distance', 'Enter a mm value:', value=100, decimals=2)
self.solv.distance(e1, e2, length, self.wp)
self.solv.distance(e1, e2, length, self.sketch.working_plane)
if self.solv.solve() == ResultFlag.OKAY:
print("Fuck yeah")
@ -574,33 +561,35 @@ class SketchWidget(QWidget):
min_distance = float('inf')
threshold = 10 # Distance threshold for highlighting
for point in self.slv_points_main:
distance = (local_event_pos - point['ui_point']).manhattanLength()
if distance < threshold and distance < min_distance:
closest_point = point['ui_point']
min_distance = distance
if self.sketch:
for point in self.proj_snap_points:
distance = (local_event_pos - point).manhattanLength()
if distance < threshold and distance < min_distance:
closest_point = point
min_distance = distance
for point in self.sketch.slv_points:
distance = (local_event_pos - point['ui_point']).manhattanLength()
if distance < threshold and distance < min_distance:
closest_point = point['ui_point']
min_distance = distance
if closest_point != self.hovered_point:
self.hovered_point = closest_point
print(self.hovered_point)
for point in self.sketch.proj_points:
distance = (local_event_pos - point).manhattanLength()
if distance < threshold and distance < min_distance:
closest_point = point
min_distance = distance
for dic in self.slv_lines_main:
p1 = dic['ui_points'][0]
p2 = dic['ui_points'][1]
if closest_point != self.hovered_point:
self.hovered_point = closest_point
print(self.hovered_point)
if self.is_point_on_line(local_event_pos, p1, p2):
self.selected_line = p1, p2
break
else:
self.selected_line = None
for dic in self.sketch.slv_lines:
p1 = dic['ui_points'][0]
p2 = dic['ui_points'][1]
self.update()
if self.is_point_on_line(local_event_pos, p1, p2):
self.selected_line = p1, p2
break
else:
self.selected_line = None
self.update()
def mouseDoubleClickEvent(self, event):
pass
@ -722,50 +711,51 @@ class SketchWidget(QWidget):
painter.setPen(pen)
# Draw points
for point in self.slv_points_main:
painter.drawEllipse(point['ui_point'], 3 / self.zoom, 3 / self.zoom)
if self.sketch:
for point in self.sketch.slv_points:
painter.drawEllipse(point['ui_point'], 3 / self.zoom, 3 / self.zoom)
for dic in self.slv_lines_main:
p1 = dic['ui_points'][0]
p2 = dic['ui_points'][1]
painter.drawLine(p1, p2)
for dic in self.sketch.slv_lines:
p1 = dic['ui_points'][0]
p2 = dic['ui_points'][1]
painter.drawLine(p1, p2)
dis = self.distance(p1, p2)
mid = self.calculate_midpoint(p1, p2)
painter.drawText(mid, str(round(dis, 2)))
dis = self.distance(p1, p2)
mid = self.calculate_midpoint(p1, p2)
painter.drawText(mid, str(round(dis, 2)))
pen = QPen(Qt.green)
pen.setWidthF(2 / self.zoom)
painter.setPen(pen)
if self.solv.entity_len():
for i in range(self.solv.entity_len()):
entity = self.solv.entity(i)
if entity.is_point_2d() and self.solv.params(entity.params):
x, y = self.solv.params(entity.params)
point = QPointF(x, y)
painter.drawEllipse(point, 6 / self.zoom, 6 / self.zoom)
# Highlight point hovered
if self.hovered_point:
highlight_pen = QPen(QColor(255, 0, 0))
highlight_pen.setWidthF(2 / self.zoom)
painter.setPen(highlight_pen)
painter.drawEllipse(self.hovered_point, 5 / self.zoom, 5 / self.zoom)
# Highlight line hovered
if self.selected_line and not self.hovered_point:
p1, p2 = self.selected_line
painter.setPen(QPen(Qt.red, 2 / self.zoom))
painter.drawLine(p1, p2)
for cross in self.proj_snap_points:
self.draw_cross(painter, cross, 10 / self.zoom)
for selected in self.proj_snap_lines:
pen = QPen(Qt.white, 1, Qt.DashLine)
pen = QPen(Qt.green)
pen.setWidthF(2 / self.zoom)
painter.setPen(pen)
painter.drawLine(selected)
if self.solv.entity_len():
for i in range(self.solv.entity_len()):
entity = self.solv.entity(i)
if entity.is_point_2d() and self.solv.params(entity.params):
x, y = self.solv.params(entity.params)
point = QPointF(x, y)
painter.drawEllipse(point, 6 / self.zoom, 6 / self.zoom)
# Highlight point hovered
if self.hovered_point:
highlight_pen = QPen(QColor(255, 0, 0))
highlight_pen.setWidthF(2 / self.zoom)
painter.setPen(highlight_pen)
painter.drawEllipse(self.hovered_point, 5 / self.zoom, 5 / self.zoom)
# Highlight line hovered
if self.selected_line and not self.hovered_point:
p1, p2 = self.selected_line
painter.setPen(QPen(Qt.red, 2 / self.zoom))
painter.drawLine(p1, p2)
for cross in self.sketch.proj_points:
self.draw_cross(painter, cross, 10 / self.zoom)
for selected in self.sketch.proj_lines:
pen = QPen(Qt.white, 1, Qt.DashLine)
painter.setPen(pen)
painter.drawLine(selected)
painter.end()
@ -777,13 +767,6 @@ class SketchWidget(QWidget):
def aspect_ratio(self):
return self.width() / self.height() * (1.0 / abs(self.zoom))
def clear_sketch(self):
self.slv_points_main = []
self.slv_lines_main = []
self.proj_snap_lines.clear()
self.proj_snap_points.clear()
self.reset_buffers()
self.solv = SolverSystem()
# Example usage
if __name__ == "__main__":

1
drawing_modules/vtk_widget.py
View File

@ -146,7 +146,6 @@ class VTKWidget(QtWidgets.QWidget):
self.renderer_indicators.ResetCameraClippingRange()
self.vtk_widget.GetRenderWindow().Render()
def create_grid(self, size=100, spacing=10):
# Create a vtkPoints object and store the points in it
points = vtk.vtkPoints()

124
main.py
View File

@ -23,6 +23,7 @@ class ExtrudeDialog(QDialog):
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle('Extrude Options')
def create_hline():
line = QLabel()
line.setStyleSheet("border-top: 1px solid #cccccc;") # Light grey line
@ -76,6 +77,7 @@ class ExtrudeDialog(QDialog):
def get_values(self):
return self.length_input.value(), self.symmetric_checkbox.isChecked() ,self.invert_checkbox.isChecked(), self.cut_checkbox.isChecked(), self.union_checkbox.isChecked(), self.rounded_checkbox.isChecked()
class MainWindow(QMainWindow):
send_command = Signal(str)
@ -100,7 +102,7 @@ class MainWindow(QMainWindow):
### Main Model
self.model = {
'sketch': {},
'sketches': {},
'operation': {},
}
self.list_selected = []
@ -145,8 +147,6 @@ class MainWindow(QMainWindow):
"""Project -> Timeline -> Component -> Sketch -> Body / Interactor -> Connector -> Assembly -> PB Render"""
def on_flip_face(self):
self.send_command.emit("flip")
@ -208,7 +208,7 @@ class MainWindow(QMainWindow):
def draw_mesh(self):
name = self.ui.body_list.currentItem().text()
print("selected_for disp", name)
model = self.project.timeline[-1].body.sdf_body
model = self.project.timeline[-1].body[name].sdf_body
vesta = vesta_mesh
model_data = vesta.generate_mesh_from_sdf(model, resolution=64, threshold=0)
@ -234,6 +234,8 @@ class MainWindow(QMainWindow):
compo = Component()
compo.id = "New Compo"
compo.descript = "Initial Component"
compo.sketches = {}
compo.body = {}
self.project.timeline.append(compo)
# Create a horizontal layout
@ -257,61 +259,67 @@ class MainWindow(QMainWindow):
horizontal_layout.setAlignment(Qt.AlignLeft)
def add_new_sketch_origin(self):
self.sketchWidget.clear_sketch()
self.sketchWidget.create_workplane()
name = f"sketches-{str(names.get_first_name())}"
sketch = Sketch()
sketch.id = name
sketch.origin = [0,0,0]
sketch.slv_points = []
sketch.slv_lines = []
sketch.proj_points = []
sketch.proj_lines = []
self.sketchWidget.set_sketch(sketch)
def add_new_sketch_wp(self):
self.sketchWidget.clear_sketch()
#edges = [((-158.0, -20.0, -25.0), (286.0, -195.0, -25.0)), ((-158.0, -20.0, 25.0), (-158.0, -20.0, -25.0))]
points = self.custom_3D_Widget.project_tosketch_points
normal = self.custom_3D_Widget.selected_normal
selected_lines = self.custom_3D_Widget.project_tosketch_lines
print("Selected lines", selected_lines)
name = f"sketches-{str(names.get_first_name())}"
sketch = Sketch()
sketch.id = name
sketch.origin = self.custom_3D_Widget.centroid
sketch.normal = self.custom_3D_Widget.selected_normal
sketch.slv_points = []
sketch.slv_lines = []
sketch.proj_points = self.custom_3D_Widget.project_tosketch_points
sketch.proj_lines = self.custom_3D_Widget.project_tosketch_lines
self.sketchWidget.set_sketch(sketch)
self.sketchWidget.create_workplane_projected()
self.sketchWidget.create_proj_points(points)
self.sketchWidget.create_proj_lines(selected_lines)
self.sketchWidget.convert_proj_points()
self.sketchWidget.convert_proj_lines()
self.sketchWidget.update()
# CLear all selections after it has been projected
self.custom_3D_Widget.project_tosketch_points.clear()
self.custom_3D_Widget.project_tosketch_lines.clear()
self.custom_3D_Widget.clear_actors_projection()
self.custom_3D_Widget.clear_actors_normals()
#self.custom_3D_Widget.clear_actors_projection()
#self.sketchWidget.create_workplane_space(edges, normal)
def add_sketch(self):
name = f"sketch-{str(names.get_first_name())}"
sketch = Sketch()
sketch.id = name
sketch.slv_points = self.sketchWidget.slv_points_main
sketch.slv_lines = self.sketchWidget.slv_lines_main
sketch = self.sketchWidget.get_sketch()
sketch.convert_points_for_sdf()
self.project.timeline[-1].sketch = sketch
self.project.timeline[-1].sketches[sketch.id] = sketch
self.ui.sketch_list.addItem(name)
self.ui.sketch_list.addItem(sketch.id)
self.ui.pb_linetool.setChecked(False)
self.sketchWidget.line_mode = False
items = self.ui.sketch_list.findItems(name, Qt.MatchExactly)[0]
items = self.ui.sketch_list.findItems(sketch.id, Qt.MatchExactly)[0]
self.ui.sketch_list.setCurrentItem(items)
def edit_sketch(self):
name = self.ui.sketch_list.currentItem().text()
#self.sketchWidget.clear_sketch()
self.sketchWidget.slv_points_main = self.model['sketch'][name]['point_list']
self.sketchWidget.slv_lines_main = self.model['sketch'][name]['line_list']
self.sketchWidget.solv = self.model['sketch'][name]['solver']
selected = self.ui.sketch_list.currentItem()
name = selected.text()
# TODO: add selected element from timeline
sel_compo = self.project.timeline[-1]
sketch = sel_compo.sketches[name]
self.sketchWidget.set_sketch(sketch)
self.sketchWidget.update()
print("model",self.model)
print("widget", self.sketchWidget.slv_points_main)
def del_sketch(self):
# Old
print("Deleting")
name = self.ui.sketch_list.currentItem() # Get the current item
@ -321,14 +329,14 @@ class MainWindow(QMainWindow):
item_name = name.text()
print("obj_name", item_name)
# Check if the 'sketch' key exists in the model dictionary
if 'sketch' in self.model and item_name in self.model['sketch']:
if self.model['sketch'][item_name]['id'] == item_name:
# Check if the 'sketches' key exists in the model dictionary
if 'sketches' in self.model and item_name in self.model['sketches']:
if self.model['sketches'][item_name]['id'] == item_name:
row = self.ui.sketch_list.row(name) # Get the row of the current item
self.ui.sketch_list.takeItem(row) # Remove the item from the list widget
self.sketchWidget.clear_sketch()
self.model['sketch'].pop(item_name) # Remove the item from the sketch dictionary
print(f"Removed sketch: {item_name}")
self.model['sketches'].pop(item_name) # Remove the item from the sketches dictionary
print(f"Removed sketches: {item_name}")
# Check if the 'operation' key exists in the model dictionary
elif 'operation' in self.model and item_name in self.model['operation']:
@ -340,7 +348,7 @@ class MainWindow(QMainWindow):
print(f"Removed operation: {item_name}")
else:
print(f"Item '{item_name}' not found in either 'sketch' or 'operation' dictionary.")
print(f"Item '{item_name}' not found in either 'sketches' or 'operation' dictionary.")
else:
print("No item selected.")
@ -374,7 +382,7 @@ class MainWindow(QMainWindow):
name = selected.text()
# TODO: add selected element from timeline
sel_compo = self.project.timeline[-1]
sketch = sel_compo.sketch
sketch = sel_compo.sketches[name]
points = sketch.sdf_points
if points[-1] == points[0]:
@ -389,7 +397,6 @@ class MainWindow(QMainWindow):
length = 0
print("Extrude cancelled")
normal = self.custom_3D_Widget.selected_normal
#print("Normie enter", normal)
if normal is None:
@ -408,21 +415,25 @@ class MainWindow(QMainWindow):
f = sketch.extrude(length, is_symmetric, invert, 0)
name_op = f"extrd-{name}"
sel_compo.body = Body()
sel_compo.body.sketch = sketch #we add the sketch for reference here
sel_compo.body.id = name_op
sel_compo.body.sdf_body = f
sel_compo.body
body = Body()
body.sketch = sketch #we add the sketches for reference here
body.id = name_op
body.sdf_body = f
### Interactor
sel_compo.interactor = Interactor()
sel_compo.interactor.add_lines_for_interactor(sketch.slv_lines)
interactor = Interactor()
interactor.add_lines_for_interactor(sketch.slv_lines)
if not invert:
edges = interactor_mesh.generate_mesh(sel_compo.interactor.lines, 0, length)
edges = interactor_mesh.generate_mesh(interactor.lines, 0, length)
else:
edges = interactor_mesh.generate_mesh(sel_compo.interactor.lines, 0, -length)
edges = interactor_mesh.generate_mesh(interactor.lines, 0, -length)
offset_vector = sel_compo.interactor.vector_to_centroid(None, centroid, normal)
body.interactor = interactor
sel_compo.body[name_op] = body
offset_vector = interactor.vector_to_centroid(None, centroid, normal)
#print("off_ved", offset_vector)
if len(offset_vector) == 0 :
offset_vector = [0, 0, 0]
@ -483,7 +494,7 @@ class Assembly:
class Component:
"""The base container combining all related elements
id : The unique ID
sketch : the base sketch, bodys can contain additonal sketches for features
sketches : the base sketches, bodys can contain additonal sketches for features
interactor : A smiplified model used as interactor
body : The body class that contains the actual 3d information
connector : Vector and Nomral information for assembly
@ -491,9 +502,8 @@ class Component:
materil : Speicfy a material for pbr rendering
"""
id = None
sketch = None
interactor = None
body = None
sketches: dict = None
body: dict = None
connector = None
# Description
@ -531,7 +541,7 @@ class Code:
@dataclass
class Sketch:
"""All of the 2D Information of a sketch"""
"""All of the 2D Information of a sketches"""
id = None
# Space Information
@ -539,7 +549,7 @@ class Sketch:
slv_plane = None
normal = None
# Points in UI form the sketch widget
# Points in UI form the sketches widget
ui_points: list = None
ui_lines: list = None
@ -553,6 +563,9 @@ class Sketch:
proj_points: list = None
proj_lines: list = None
# Workingplane
working_plane = None
def translate_points_tup(self, point: QPoint):
"""QPoints from Display to mesh data
input: Qpoints
@ -712,6 +725,7 @@ class Body:
id = None
sketch = None
height = None
interactor = None
sdf_body = None
def mirror_body(self, sdf_object3d):