370 lines
18 KiB
Python
370 lines
18 KiB
Python
# SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
import bpy, math, bmesh
|
|
from bpy_extras import view3d_utils
|
|
from mathutils import Vector, Matrix
|
|
from . import internal
|
|
|
|
class OffsetCurve(bpy.types.Operator):
|
|
bl_idname = 'curvetools.add_toolpath_offset_curve'
|
|
bl_description = bl_label = 'Offset Curve'
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
offset: bpy.props.FloatProperty(name='Offset', description='Distace between the original and the first trace', unit='LENGTH', default=0.1)
|
|
pitch: bpy.props.FloatProperty(name='Pitch', description='Distace between two parallel traces', unit='LENGTH', default=0.1)
|
|
step_angle: bpy.props.FloatProperty(name='Resolution', description='Smaller values make curves smoother by adding more vertices', unit='ROTATION', min=math.pi/128, default=math.pi/16)
|
|
count: bpy.props.IntProperty(name='Count', description='Number of parallel traces', min=1, default=1)
|
|
round_line_join: bpy.props.BoolProperty(name='Round Line Join', description='Insert circle arcs at convex corners', default=True)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return bpy.context.object != None and bpy.context.object.type == 'CURVE'
|
|
|
|
def execute(self, context):
|
|
if bpy.context.object.mode == 'EDIT':
|
|
splines = internal.getSelectedSplines(True, True)
|
|
else:
|
|
splines = bpy.context.object.data.splines
|
|
|
|
if len(splines) == 0:
|
|
self.report({'WARNING'}, 'Nothing selected')
|
|
return {'CANCELLED'}
|
|
|
|
if bpy.context.object.mode != 'EDIT':
|
|
internal.addObject('CURVE', 'Offset Toolpath')
|
|
origin = bpy.context.scene.cursor.location
|
|
else:
|
|
origin = Vector((0.0, 0.0, 0.0))
|
|
|
|
for spline in splines:
|
|
spline_points = spline.bezier_points if spline.type == 'BEZIER' else spline.points
|
|
for spline_point in spline_points:
|
|
if spline_point.co.z != spline_points[0].co.z:
|
|
self.report({'WARNING'}, 'Curves must be planar and in XY plane')
|
|
return {'CANCELLED'}
|
|
for index in range(0, self.count):
|
|
traces = internal.offsetPolygonOfSpline(spline, self.offset+self.pitch*index, self.step_angle, self.round_line_join)
|
|
for trace in traces:
|
|
internal.addPolygonSpline(bpy.context.object, spline.use_cyclic_u, [vertex-origin for vertex in trace])
|
|
return {'FINISHED'}
|
|
|
|
class SliceMesh(bpy.types.Operator):
|
|
bl_idname = 'curvetools.add_toolpath_slice_mesh'
|
|
bl_description = bl_label = 'Slice Mesh'
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
pitch: bpy.props.FloatProperty(name='Pitch', unit='LENGTH', description='Distance between two slices', default=0.1)
|
|
offset: bpy.props.FloatProperty(name='Offset', unit='LENGTH', description='Position of first slice along the axis', default=0.0)
|
|
slice_count: bpy.props.IntProperty(name='Count', description='Number of slices', min=1, default=3)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return bpy.context.object != None and bpy.context.object.mode == 'OBJECT'
|
|
|
|
def perform(self, context):
|
|
axis = Vector((0.0, 0.0, 1.0))
|
|
for i in range(0, self.slice_count):
|
|
aux_mesh = self.mesh.copy()
|
|
cut_geometry = bmesh.ops.bisect_plane(aux_mesh, geom=aux_mesh.edges[:]+aux_mesh.faces[:], dist=0, plane_co=axis*(i*self.pitch+self.offset), plane_no=axis, clear_outer=False, clear_inner=False)['geom_cut']
|
|
edge_pool = set([e for e in cut_geometry if isinstance(e, bmesh.types.BMEdge)])
|
|
while len(edge_pool) > 0:
|
|
current_edge = edge_pool.pop()
|
|
first_vertex = current_vertex = current_edge.verts[0]
|
|
vertices = [current_vertex.co]
|
|
follow_edge_loop = len(edge_pool) > 0
|
|
while follow_edge_loop:
|
|
current_vertex = current_edge.other_vert(current_vertex)
|
|
vertices.append(current_vertex.co)
|
|
if current_vertex == first_vertex:
|
|
break
|
|
follow_edge_loop = False
|
|
for edge in current_vertex.link_edges:
|
|
if edge in edge_pool:
|
|
current_edge = edge
|
|
edge_pool.remove(current_edge)
|
|
follow_edge_loop = True
|
|
break
|
|
current_vertex = current_edge.other_vert(current_vertex)
|
|
vertices.append(current_vertex.co)
|
|
internal.addPolygonSpline(self.result, False, vertices)
|
|
aux_mesh.free()
|
|
|
|
def invoke(self, context, event):
|
|
if bpy.context.object.type != 'MESH':
|
|
self.report({'WARNING'}, 'Active object must be a mesh')
|
|
return {'CANCELLED'}
|
|
self.pitch = 0.1
|
|
self.offset = 0.0
|
|
self.slice_count = 3
|
|
self.mode = 'PITCH'
|
|
self.input_obj = bpy.context.object
|
|
depsgraph = context.evaluated_depsgraph_get()
|
|
self.mesh = bmesh.new()
|
|
self.mesh.from_object(self.input_obj, depsgraph, deform=True, cage=False, face_normals=True)
|
|
self.mesh.transform(bpy.context.scene.cursor.matrix.inverted()@self.input_obj.matrix_world)
|
|
self.result = internal.addObject('CURVE', 'Slices')
|
|
self.result.matrix_world = bpy.context.scene.cursor.matrix
|
|
self.perform(context)
|
|
context.window_manager.modal_handler_add(self)
|
|
return {'RUNNING_MODAL'}
|
|
|
|
def modal(self, context, event):
|
|
if event.type == 'MOUSEMOVE':
|
|
mouse = (event.mouse_region_x, event.mouse_region_y)
|
|
input_value = internal.nearestPointOfLines(
|
|
bpy.context.scene.cursor.location,
|
|
bpy.context.scene.cursor.matrix.col[2].xyz,
|
|
view3d_utils.region_2d_to_origin_3d(context.region, context.region_data, mouse),
|
|
view3d_utils.region_2d_to_vector_3d(context.region, context.region_data, mouse)
|
|
)[0]
|
|
if self.mode == 'PITCH':
|
|
self.pitch = input_value/(self.slice_count-1) if self.slice_count > 2 else input_value
|
|
elif self.mode == 'OFFSET':
|
|
self.offset = input_value-self.pitch*0.5*((self.slice_count-1) if self.slice_count > 2 else 1.0)
|
|
elif event.type == 'WHEELUPMOUSE':
|
|
if self.slice_count > 2:
|
|
self.pitch *= (self.slice_count-1)
|
|
self.slice_count += 1
|
|
if self.slice_count > 2:
|
|
self.pitch /= (self.slice_count-1)
|
|
elif event.type == 'WHEELDOWNMOUSE':
|
|
if self.slice_count > 2:
|
|
self.pitch *= (self.slice_count-1)
|
|
if self.slice_count > 1:
|
|
self.slice_count -= 1
|
|
if self.slice_count > 2:
|
|
self.pitch /= (self.slice_count-1)
|
|
elif event.type == 'LEFTMOUSE' and event.value == 'RELEASE':
|
|
if self.mode == 'PITCH':
|
|
self.mode = 'OFFSET'
|
|
return {'RUNNING_MODAL'}
|
|
elif self.mode == 'OFFSET':
|
|
self.mesh.free()
|
|
return {'FINISHED'}
|
|
elif event.type in {'RIGHTMOUSE', 'ESC'}:
|
|
self.mesh.free()
|
|
bpy.context.scene.collection.objects.unlink(self.result)
|
|
bpy.context.view_layer.objects.active = self.input_obj
|
|
return {'CANCELLED'}
|
|
else:
|
|
return {'PASS_THROUGH'}
|
|
self.result.data.splines.clear()
|
|
self.perform(context)
|
|
return {'RUNNING_MODAL'}
|
|
|
|
class DogBone(bpy.types.Operator):
|
|
bl_idname = 'curvetools.add_toolpath_dogbone'
|
|
bl_description = bl_label = 'Dog Bone'
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
radius: bpy.props.FloatProperty(name='Radius', description='Tool radius to compensate for', unit='LENGTH', min=0.0, default=0.1)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return bpy.context.object != None and bpy.context.object.type == 'CURVE'
|
|
|
|
def execute(self, context):
|
|
if bpy.context.object.mode == 'EDIT':
|
|
splines = internal.getSelectedSplines(True, False)
|
|
else:
|
|
splines = bpy.context.object.data.splines
|
|
|
|
if len(splines) == 0:
|
|
self.report({'WARNING'}, 'Nothing selected')
|
|
return {'CANCELLED'}
|
|
|
|
if bpy.context.object.mode != 'EDIT':
|
|
internal.addObject('CURVE', 'Dog Bone')
|
|
origin = bpy.context.scene.cursor.location
|
|
else:
|
|
origin = Vector((0.0, 0.0, 0.0))
|
|
|
|
for spline in splines:
|
|
if spline.type != 'BEZIER':
|
|
continue
|
|
result = internal.dogBone(spline, self.radius)
|
|
internal.addBezierSpline(bpy.context.object, spline.use_cyclic_u, result) # [vertex-origin for vertex in result])
|
|
return {'FINISHED'}
|
|
|
|
class DiscretizeCurve(bpy.types.Operator):
|
|
bl_idname = 'curvetools.add_toolpath_discretize_curve'
|
|
bl_description = bl_label = 'Discretize Curve'
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
step_angle: bpy.props.FloatProperty(name='Resolution', description='Smaller values make curves smoother by adding more vertices', unit='ROTATION', min=math.pi/512, default=math.pi/16)
|
|
samples: bpy.props.IntProperty(name='Sample Count', description='Number of samples to test per curve segment', min=1, default=128)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return bpy.context.object != None and bpy.context.object.type == 'CURVE'
|
|
|
|
def execute(self, context):
|
|
if bpy.context.object.mode == 'EDIT':
|
|
splines = internal.getSelectedSplines(True, False)
|
|
else:
|
|
splines = bpy.context.object.data.splines
|
|
|
|
if len(splines) == 0:
|
|
self.report({'WARNING'}, 'Nothing selected')
|
|
return {'CANCELLED'}
|
|
|
|
if bpy.context.object.mode != 'EDIT':
|
|
internal.addObject('CURVE', 'Discretized Curve')
|
|
origin = bpy.context.scene.cursor.location
|
|
else:
|
|
origin = Vector((0.0, 0.0, 0.0))
|
|
|
|
for spline in splines:
|
|
if spline.type != 'BEZIER':
|
|
continue
|
|
result = internal.discretizeCurve(spline, self.step_angle, self.samples)
|
|
internal.addPolygonSpline(bpy.context.object, spline.use_cyclic_u, [vertex-origin for vertex in result])
|
|
return {'FINISHED'}
|
|
|
|
class Truncate(bpy.types.Operator):
|
|
bl_idname = 'curvetools.add_toolpath_truncate'
|
|
bl_description = bl_label = 'Truncate'
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
min_dist: bpy.props.FloatProperty(name='Min Distance', unit='LENGTH', description='Remove vertices which are too close together', min=0.0, default=0.001)
|
|
z_hop: bpy.props.BoolProperty(name='Z Hop', description='Add movements to the ceiling at trace ends', default=True)
|
|
|
|
@classmethod
|
|
def poll(cls, context):
|
|
return bpy.context.object != None and bpy.context.object.mode == 'OBJECT'
|
|
|
|
def execute(self, context):
|
|
if bpy.context.object.type != 'EMPTY' or bpy.context.object.empty_display_type != 'CUBE':
|
|
self.report({'WARNING'}, 'Active object must be an empty of display type cube')
|
|
return {'CANCELLED'}
|
|
selection = bpy.context.selected_objects[:]
|
|
workspace = bpy.context.object
|
|
aabb = internal.AABB(center=Vector((0.0, 0.0, 0.0)), dimensions=Vector((1.0, 1.0, 1.0))*workspace.empty_display_size)
|
|
toolpath = internal.addObject('CURVE', 'Truncated Toolpath')
|
|
for curve in selection:
|
|
if curve.type == 'CURVE':
|
|
transform = workspace.matrix_world.inverted()@curve.matrix_world
|
|
inverse_transform = Matrix.Translation(-toolpath.location)@workspace.matrix_world
|
|
curve_traces = []
|
|
for spline in curve.data.splines:
|
|
if spline.type == 'POLY':
|
|
curve_traces += internal.truncateToFitBox(transform, spline, aabb)
|
|
for trace in curve_traces:
|
|
i = len(trace[0])-1
|
|
while i > 1:
|
|
if (trace[0][i-1]-trace[0][i]).length < self.min_dist:
|
|
trace[0].pop(i-1)
|
|
trace[1].pop(i-1)
|
|
i -= 1
|
|
if self.z_hop:
|
|
begin = Vector(trace[0][0])
|
|
end = Vector(trace[0][-1])
|
|
begin.z = end.z = workspace.empty_display_size
|
|
trace[0].insert(0, begin)
|
|
trace[1].insert(0, 1.0)
|
|
trace[0].append(end)
|
|
trace[1].append(1.0)
|
|
internal.addPolygonSpline(toolpath, False, [inverse_transform@vertex for vertex in trace[0]], trace[1])
|
|
return {'FINISHED'}
|
|
|
|
class RectMacro(bpy.types.Operator):
|
|
bl_idname = 'curvetools.add_toolpath_rect_macro'
|
|
bl_description = bl_label = 'Rect Macro'
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
track_count: bpy.props.IntProperty(name='Number Tracks', description='How many tracks', min=1, default=10)
|
|
stride: bpy.props.FloatProperty(name='Stride', unit='LENGTH', description='Distance to previous track on the way back', min=0.0, default=0.5)
|
|
pitch: bpy.props.FloatProperty(name='Pitch', unit='LENGTH', description='Distance between two tracks', default=-1.0)
|
|
length: bpy.props.FloatProperty(name='Length', unit='LENGTH', description='Length of one track', default=10.0)
|
|
speed: bpy.props.FloatProperty(name='Speed', description='Stored in softbody goal weight', min=0.0, max=1.0, default=0.1)
|
|
|
|
def execute(self, context):
|
|
if not internal.curveObject():
|
|
internal.addObject('CURVE', 'Rect Toolpath')
|
|
origin = Vector((0.0, 0.0, 0.0))
|
|
else:
|
|
origin = bpy.context.scene.cursor.location
|
|
stride = math.copysign(self.stride, self.pitch)
|
|
length = self.length*0.5
|
|
vertices = []
|
|
weights = []
|
|
for i in range(0, self.track_count):
|
|
shift = i*self.pitch
|
|
flipped = -1 if (stride == 0 and i%2 == 1) else 1
|
|
vertices.append(origin+Vector((shift, -length*flipped, 0.0)))
|
|
weights.append(self.speed)
|
|
vertices.append(origin+Vector((shift, length*flipped, 0.0)))
|
|
weights.append(self.speed)
|
|
if stride != 0:
|
|
vertices.append(origin+Vector((shift-stride, length, 0.0)))
|
|
weights.append(self.speed)
|
|
vertices.append(origin+Vector((shift-stride, -length, 0.0)))
|
|
weights.append(1)
|
|
internal.addPolygonSpline(bpy.context.object, False, vertices, weights)
|
|
return {'FINISHED'}
|
|
|
|
class DrillMacro(bpy.types.Operator):
|
|
bl_idname = 'curvetools.add_toolpath_drill_macro'
|
|
bl_description = bl_label = 'Drill Macro'
|
|
bl_options = {'REGISTER', 'UNDO'}
|
|
|
|
screw_count: bpy.props.FloatProperty(name='Screw Turns', description='How many screw truns', min=1.0, default=10.0)
|
|
spiral_count: bpy.props.FloatProperty(name='Spiral Turns', description='How many spiral turns', min=0.0, default=0.0)
|
|
vertex_count: bpy.props.IntProperty(name='Number Vertices', description = 'How many vertices per screw turn', min=3, default=32)
|
|
radius: bpy.props.FloatProperty(name='Radius', unit='LENGTH', description='Radius at tool center', min=0.0, default=5.0)
|
|
pitch: bpy.props.FloatProperty(name='Pitch', unit='LENGTH', description='Distance between two screw turns', min=0.0, default=1.0)
|
|
speed: bpy.props.FloatProperty(name='Speed', description='Stored in softbody goal weight', min=0.0, max=1.0, default=0.1)
|
|
|
|
def execute(self, context):
|
|
if not internal.curveObject():
|
|
internal.addObject('CURVE', 'Drill Toolpath')
|
|
origin = Vector((0.0, 0.0, 0.0))
|
|
else:
|
|
origin = bpy.context.scene.cursor.location
|
|
count = int(self.vertex_count*self.screw_count)
|
|
height = -count/self.vertex_count*self.pitch
|
|
vertices = []
|
|
weights = []
|
|
def addRadialVertex(param, radius, height):
|
|
angle = param*math.pi*2
|
|
vertices.append(origin+Vector((math.sin(angle)*radius, math.cos(angle)*radius, height)))
|
|
weights.append(self.speed)
|
|
if self.radius > 0:
|
|
if self.spiral_count > 0.0:
|
|
sCount = math.ceil(self.spiral_count*self.vertex_count)
|
|
for j in range(1, int(self.screw_count)+1):
|
|
if j > 1:
|
|
vertices.append(origin+Vector((0.0, 0.0, sHeight)))
|
|
weights.append(self.speed)
|
|
sHeight = max(-j*self.pitch, height)
|
|
for i in range(0, sCount+1):
|
|
sParam = i/self.vertex_count
|
|
addRadialVertex(sParam, i/sCount*self.radius, sHeight)
|
|
for i in range(0, self.vertex_count+1):
|
|
addRadialVertex(sParam+(count+i)/self.vertex_count, self.radius, sHeight)
|
|
else:
|
|
for i in range(0, count):
|
|
param = i/self.vertex_count
|
|
addRadialVertex(param, self.radius, -param*self.pitch)
|
|
for i in range(0, self.vertex_count+1):
|
|
addRadialVertex((count+i)/self.vertex_count, self.radius, height)
|
|
weights += [1, 1]
|
|
else:
|
|
weights += [self.speed, 1]
|
|
vertices += [origin+Vector((0.0, 0.0, height)), origin]
|
|
internal.addPolygonSpline(bpy.context.object, False, vertices, weights)
|
|
return {'FINISHED'}
|
|
|
|
def register():
|
|
for cls in classes:
|
|
bpy.utils.register_class(operators)
|
|
|
|
def unregister():
|
|
for cls in classes:
|
|
bpy.utils.unregister_class(operators)
|
|
|
|
if __name__ == "__main__":
|
|
register()
|
|
|
|
operators = [OffsetCurve, SliceMesh, DogBone, DiscretizeCurve, Truncate, RectMacro, DrillMacro]
|