"""Fabex 'pattern.py' © 2012 Vilem Novak
Functions to read CAM path patterns and return CAM path chunks.
"""
from math import (
ceil,
floor,
pi,
sqrt,
)
import time
import numpy
import bpy
from mathutils import Euler, Vector
from .cam_chunk import (
CamPathChunk,
CamPathChunkBuilder,
shapely_to_chunks,
)
from .utilities.chunk_utils import (
chunks_refine,
parent_child_distance,
)
from .utilities.simple_utils import progress
[docs]
def get_path_pattern_parallel(o, angle):
"""Generate path chunks for parallel movement based on object dimensions
and angle.
This function calculates a series of path chunks for a given object,
taking into account its dimensions and the specified angle. It utilizes
both a traditional method and an alternative algorithm (currently
disabled) to generate these paths. The paths are constructed by
iterating over calculated vectors and applying transformations based on
the object's properties. The resulting path chunks can be used for
various movement types, including conventional and climb movements.
Args:
o (object): An object containing properties such as dimensions and movement type.
angle (float): The angle to rotate the path generation.
Returns:
list: A list of path chunks generated based on the object's dimensions and
angle.
"""
zlevel = 1
pathd = o.distance_between_paths
pathstep = o.distance_along_paths
pathchunks = []
xm = (o.max.x + o.min.x) / 2
ym = (o.max.y + o.min.y) / 2
vm = Vector((xm, ym, 0))
xdim = o.max.x - o.min.x
ydim = o.max.y - o.min.y
dim = (xdim + ydim) / 2.0
e = Euler((0, 0, angle))
reverse = False
if bpy.app.debug_value == 0: # by default off
# this is the original pattern method, slower, but well tested:
dirvect = Vector((0, 1, 0))
dirvect.rotate(e)
dirvect.normalize()
dirvect *= pathstep
for a in range(
int(-dim / pathd), int(dim / pathd)
): # this is highly ineffective, computes path2x the area needed...
chunk = CamPathChunkBuilder([])
v = Vector((a * pathd, int(-dim / pathstep) * pathstep, 0))
v.rotate(e)
# shifting for the rotation, so pattern rotates around middle...
v += vm
for b in range(int(-dim / pathstep), int(dim / pathstep)):
v += dirvect
if v.x > o.min.x and v.x < o.max.x and v.y > o.min.y and v.y < o.max.y:
chunk.points.append((v.x, v.y, zlevel))
if (
(reverse and o.movement.type == "MEANDER")
or (o.movement.type == "CONVENTIONAL" and o.movement.spindle_rotation == "CW")
or (o.movement.type == "CLIMB" and o.movement.spindle_rotation == "CCW")
):
chunk.points.reverse()
if len(chunk.points) > 0:
pathchunks.append(chunk.to_chunk())
if (
len(pathchunks) > 1
and reverse
and o.movement.parallel_step_back
and not o.use_layers
):
# parallel step back - for finishing, best with climb movement, saves cutter life by going into
# material with climb, while using move back on the surface to improve finish
# (which would otherwise be a conventional move in the material)
if o.movement.type == "CONVENTIONAL" or o.movement.type == "CLIMB":
pathchunks[-2].reverse()
changechunk = pathchunks[-1]
pathchunks[-1] = pathchunks[-2]
pathchunks[-2] = changechunk
reverse = not reverse
# print (chunk.points)
else: # alternative algorithm with numpy, didn't work as should so blocked now...
v = Vector((0, 1, 0))
v.rotate(e)
e1 = Euler((0, 0, -pi / 2))
v1 = v.copy()
v1.rotate(e1)
axis_across_paths = numpy.array(
(
numpy.arange(int(-dim / pathd), int(dim / pathd)) * pathd * v1.x + xm,
numpy.arange(int(-dim / pathd), int(dim / pathd)) * pathd * v1.y + ym,
numpy.arange(int(-dim / pathd), int(dim / pathd)) * 0,
)
)
axis_along_paths = numpy.array(
(
numpy.arange(int(-dim / pathstep), int(dim / pathstep)) * pathstep * v.x,
numpy.arange(int(-dim / pathstep), int(dim / pathstep)) * pathstep * v.y,
numpy.arange(int(-dim / pathstep), int(dim / pathstep)) * 0 + zlevel,
)
) # rotate this first
progress(axis_along_paths)
chunks = []
for a in range(0, len(axis_across_paths[0])):
# progress(chunks[a,...,...].shape)
# progress(axis_along_paths.shape)
nax = axis_along_paths.copy()
# progress(nax.shape)
nax[0] += axis_across_paths[0][a]
nax[1] += axis_across_paths[1][a]
# progress(a)
# progress(nax.shape)
# progress(chunks.shape)
# progress(chunks[...,a,...].shape)
xfitmin = nax[0] > o.min.x
xfitmax = nax[0] < o.max.x
xfit = xfitmin & xfitmax
# print(xfit,nax)
nax = numpy.array([nax[0][xfit], nax[1][xfit], nax[2][xfit]])
yfitmin = nax[1] > o.min.y
yfitmax = nax[1] < o.max.y
yfit = yfitmin & yfitmax
nax = numpy.array([nax[0][yfit], nax[1][yfit], nax[2][yfit]])
chunks.append(nax.swapaxes(0, 1))
# chunks
pathchunks = []
for ch in chunks:
ch = ch.tolist()
pathchunks.append(CamPathChunk(ch))
# print (ch)
return pathchunks
[docs]
def get_path_pattern(operation):
"""Generate a path pattern based on the specified operation strategy.
This function constructs a path pattern for a given operation by
analyzing its parameters and applying different strategies such as
'PARALLEL', 'CROSS', 'BLOCK', 'SPIRAL', 'CIRCLES', and 'OUTLINEFILL'.
Each strategy dictates how the path is built, utilizing various
geometric calculations and conditions to ensure the path adheres to the
specified operational constraints. The function also handles the
orientation and direction of the path based on the movement settings
provided in the operation.
Args:
operation (object): An object containing parameters for path generation,
including strategy, movement type, and geometric bounds.
Returns:
list: A list of path chunks representing the generated path pattern.
"""
o = operation
t = time.time()
progress("Building Path Pattern")
minx, miny, minz, maxx, maxy, maxz = o.min.x, o.min.y, o.min.z, o.max.x, o.max.y, o.max.z
pathchunks = []
zlevel = 1 # minz#this should do layers...
if o.strategy == "PARALLEL":
pathchunks = get_path_pattern_parallel(o, o.parallel_angle)
elif o.strategy == "CROSS":
pathchunks.extend(get_path_pattern_parallel(o, o.parallel_angle))
pathchunks.extend(get_path_pattern_parallel(o, o.parallel_angle - pi / 2.0))
elif o.strategy == "BLOCK":
pathd = o.distance_between_paths
pathstep = o.distance_along_paths
maxxp = maxx
maxyp = maxy
minxp = minx
minyp = miny
x = 0.0
y = 0.0
incx = 1
incy = 0
chunk = CamPathChunkBuilder([])
i = 0
while maxxp - minxp > 0 and maxyp - minyp > 0:
y = minyp
for a in range(ceil(minxp / pathstep), ceil(maxxp / pathstep), 1):
x = a * pathstep
chunk.points.append((x, y, zlevel))
if i > 0:
minxp += pathd
chunk.points.append((maxxp, minyp, zlevel))
x = maxxp
for a in range(ceil(minyp / pathstep), ceil(maxyp / pathstep), 1):
y = a * pathstep
chunk.points.append((x, y, zlevel))
minyp += pathd
chunk.points.append((maxxp, maxyp, zlevel))
y = maxyp
for a in range(floor(maxxp / pathstep), ceil(minxp / pathstep), -1):
x = a * pathstep
chunk.points.append((x, y, zlevel))
maxxp -= pathd
chunk.points.append((minxp, maxyp, zlevel))
x = minxp
for a in range(floor(maxyp / pathstep), ceil(minyp / pathstep), -1):
y = a * pathstep
chunk.points.append((x, y, zlevel))
chunk.points.append((minxp, minyp, zlevel))
maxyp -= pathd
i += 1
if o.movement.insideout == "INSIDEOUT":
chunk.points.reverse()
if (o.movement.type == "CLIMB" and o.movement.spindle_rotation == "CW") or (
o.movement.type == "CONVENTIONAL" and o.movement.spindle_rotation == "CCW"
):
for si in range(0, len(chunk.points)):
s = chunk.points[si]
chunk.points[si] = (o.max.x + o.min.x - s[0], s[1], s[2])
pathchunks = [chunk.to_chunk()]
elif o.strategy == "SPIRAL":
chunk = CamPathChunkBuilder([])
pathd = o.distance_between_paths
pathstep = o.distance_along_paths
midx = (o.max.x + o.min.x) / 2
midy = (o.max.y + o.min.y) / 2
x = pathd / 4
y = pathd / 4
v = Vector((pathd / 4, 0, 0))
# progress(x,y,midx,midy)
e = Euler((0, 0, 0))
# pi = pi
chunk.points.append((midx + v.x, midy + v.y, zlevel))
while midx + v.x > o.min.x or midy + v.y > o.min.y:
# v.x=x-midx
# v.y=y-midy
offset = 2 * v.length * pi
e.z = 2 * pi * (pathstep / offset)
v.rotate(e)
v.length = v.length + pathd / (offset / pathstep)
# progress(v.x,v.y)
if o.max.x > midx + v.x > o.min.x and o.max.y > midy + v.y > o.min.y:
chunk.points.append((midx + v.x, midy + v.y, zlevel))
else:
pathchunks.append(chunk.to_chunk())
chunk = CamPathChunkBuilder([])
if len(chunk.points) > 0:
pathchunks.append(chunk.to_chunk())
if o.movement.insideout == "OUTSIDEIN":
pathchunks.reverse()
for chunk in pathchunks:
if o.movement.insideout == "OUTSIDEIN":
chunk.reverse()
if (o.movement.type == "CONVENTIONAL" and o.movement.spindle_rotation == "CW") or (
o.movement.type == "CLIMB" and o.movement.spindle_rotation == "CCW"
):
# TODO
chunk.flip_x(o.max.x + o.min.x)
# for si in range(0, len(chunk.points)):
# s = chunk.points[si]
# chunk.points[si] = (o.max.x + o.min.x - s[0], s[1], s[2])
elif o.strategy == "CIRCLES":
pathd = o.distance_between_paths
pathstep = o.distance_along_paths
midx = (o.max.x + o.min.x) / 2
midy = (o.max.y + o.min.y) / 2
rx = o.max.x - o.min.x
ry = o.max.y - o.min.y
maxr = sqrt(rx * rx + ry * ry)
# progress(x,y,midx,midy)
e = Euler((0, 0, 0))
# pi = pi
chunk = CamPathChunkBuilder([])
chunk.points.append((midx, midy, zlevel))
pathchunks.append(chunk.to_chunk())
r = 0
while r < maxr:
r += pathd
chunk = CamPathChunkBuilder([])
firstchunk = chunk
v = Vector((-r, 0, 0))
steps = 2 * pi * r / pathstep
e.z = 2 * pi / steps
laststepchunks = []
currentstepchunks = []
for a in range(0, int(steps)):
laststepchunks = currentstepchunks
currentstepchunks = []
if o.max.x > midx + v.x > o.min.x and o.max.y > midy + v.y > o.min.y:
chunk.points.append((midx + v.x, midy + v.y, zlevel))
else:
if len(chunk.points) > 0:
chunk.closed = False
chunk = chunk.to_chunk()
pathchunks.append(chunk)
currentstepchunks.append(chunk)
chunk = CamPathChunkBuilder([])
v.rotate(e)
if len(chunk.points) > 0:
chunk.points.append(firstchunk.points[0])
if chunk == firstchunk:
chunk.closed = True
chunk = chunk.to_chunk()
pathchunks.append(chunk)
currentstepchunks.append(chunk)
chunk = CamPathChunkBuilder([])
for ch in laststepchunks:
for p in currentstepchunks:
parent_child_distance(p, ch, o)
if o.movement.insideout == "OUTSIDEIN":
pathchunks.reverse()
for chunk in pathchunks:
if o.movement.insideout == "OUTSIDEIN":
chunk.reverse()
if (o.movement.type == "CONVENTIONAL" and o.movement.spindle_rotation == "CW") or (
o.movement.type == "CLIMB" and o.movement.spindle_rotation == "CCW"
):
chunk.reverse()
# pathchunks=sort_chunks(pathchunks,o)not until they get hierarchy parents!
elif o.strategy == "OUTLINEFILL":
polys = o.silhouette.geoms
pathchunks = []
chunks = []
for p in polys:
p = p.buffer(-o.distance_between_paths / 10, o.optimisation.circle_detail)
# first, move a bit inside, because otherwise the border samples go crazy very often changin between
# hit/non hit and making too many jumps in the path.
chunks.extend(shapely_to_chunks(p, 0))
pathchunks.extend(chunks)
lastchunks = chunks
firstchunks = chunks
approxn = (min(maxx - minx, maxy - miny) / o.distance_between_paths) / 2
i = 0
for porig in polys:
p = porig
while not p.is_empty:
p = p.buffer(-o.distance_between_paths, o.optimisation.circle_detail)
if not p.is_empty:
nchunks = shapely_to_chunks(p, zlevel)
if o.movement.insideout == "INSIDEOUT":
parent_child_distance(lastchunks, nchunks, o)
else:
parent_child_distance(nchunks, lastchunks, o)
pathchunks.extend(nchunks)
lastchunks = nchunks
percent = int(i / approxn * 100)
progress("Outlining Polygons ", percent)
i += 1
pathchunks.reverse()
if not o.inverse: # dont do ambient for inverse milling
lastchunks = firstchunks
for p in polys:
d = o.distance_between_paths
steps = o.ambient_radius / o.distance_between_paths
for a in range(0, int(steps)):
dist = d
if a == int(o.cutter_diameter / 2 / o.distance_between_paths):
if o.optimisation.use_exact:
dist += o.optimisation.pixsize * 0.85
# this is here only because silhouette is still done with zbuffer method,
# even if we use bullet collisions.
else:
dist += o.optimisation.pixsize * 2.5
p = p.buffer(dist, o.optimisation.circle_detail)
if not p.is_empty:
nchunks = shapely_to_chunks(p, zlevel)
if o.movement.insideout == "INSIDEOUT":
parent_child_distance(nchunks, lastchunks, o)
else:
parent_child_distance(lastchunks, nchunks, o)
pathchunks.extend(nchunks)
lastchunks = nchunks
if o.movement.insideout == "OUTSIDEIN":
pathchunks.reverse()
for chunk in pathchunks:
if o.movement.insideout == "OUTSIDEIN":
chunk.reverse()
if (o.movement.type == "CLIMB" and o.movement.spindle_rotation == "CW") or (
o.movement.type == "CONVENTIONAL" and o.movement.spindle_rotation == "CCW"
):
chunk.reverse()
chunks_refine(pathchunks, o)
progress(time.time() - t)
return pathchunks
[docs]
def get_path_pattern_4_axis(operation):
"""Generate path patterns for a specified operation along a rotary axis.
This function constructs a series of path chunks based on the provided
operation's parameters, including the rotary axis, strategy, and
dimensions. It calculates the necessary angles and positions for the
cutter based on the specified strategy (PARALLELR, PARALLEL, or HELIX)
and generates the corresponding path chunks for machining operations.
Args:
operation (object): An object containing parameters for the machining operation,
including min and max coordinates, rotary axis configuration,
distance settings, and movement strategy.
Returns:
list: A list of path chunks generated for the specified operation.
"""
o = operation
t = time.time()
progress("Building Path Pattern")
minx, miny, minz, maxx, maxy, maxz = o.min.x, o.min.y, o.min.z, o.max.x, o.max.y, o.max.z
pathchunks = []
zlevel = 1 # minz#this should do layers...
# set axes for various options, Z option is obvious nonsense now.
if o.rotary_axis_1 == "X":
a1 = 0
a2 = 1
a3 = 2
if o.rotary_axis_1 == "Y":
a1 = 1
a2 = 0
a3 = 2
if o.rotary_axis_1 == "Z":
a1 = 2
a2 = 0
a3 = 1
o.max.z = o.max_z
# set radius for all types of operation
radius = max(o.max.z, 0.0001)
radiusend = o.min.z
mradius = max(radius, radiusend)
circlesteps = (mradius * pi * 2) / o.distance_along_paths
circlesteps = max(4, circlesteps)
anglestep = 2 * pi / circlesteps
# generalized rotation
e = Euler((0, 0, 0))
e[a1] = anglestep
# generalized length of the operation
maxl = o.max[a1]
minl = o.min[a1]
steps = (maxl - minl) / o.distance_between_paths
# set starting positions for cutter e.t.c.
cutterstart = Vector((0, 0, 0))
cutterend = Vector((0, 0, 0)) # end point for casting
if o.strategy_4_axis == "PARALLELR":
for a in range(0, floor(steps) + 1):
chunk = CamPathChunkBuilder([])
cutterstart[a1] = o.min[a1] + a * o.distance_between_paths
cutterend[a1] = cutterstart[a1]
cutterstart[a2] = 0 # radius
cutterend[a2] = 0 # radiusend
cutterstart[a3] = radius
cutterend[a3] = radiusend
for b in range(0, floor(circlesteps) + 1):
# print(cutterstart,cutterend)
chunk.startpoints.append(cutterstart.to_tuple())
chunk.endpoints.append(cutterend.to_tuple())
rot = [0, 0, 0]
rot[a1] = a * 2 * pi + b * anglestep
chunk.rotations.append(rot)
cutterstart.rotate(e)
cutterend.rotate(e)
chunk.depth = radiusend - radius
# last point = first
chunk.startpoints.append(chunk.startpoints[0])
chunk.endpoints.append(chunk.endpoints[0])
chunk.rotations.append(chunk.rotations[0])
pathchunks.append(chunk.to_chunk())
if o.strategy_4_axis == "PARALLEL":
circlesteps = (mradius * pi * 2) / o.distance_between_paths
steps = (maxl - minl) / o.distance_along_paths
anglestep = 2 * pi / circlesteps
# generalized rotation
e = Euler((0, 0, 0))
e[a1] = anglestep
reverse = False
for b in range(0, floor(circlesteps) + 1):
chunk = CamPathChunkBuilder([])
cutterstart[a2] = 0
cutterstart[a3] = radius
cutterend[a2] = 0
cutterend[a3] = radiusend
e[a1] = anglestep * b
cutterstart.rotate(e)
cutterend.rotate(e)
for a in range(0, floor(steps) + 1):
cutterstart[a1] = o.min[a1] + a * o.distance_along_paths
cutterend[a1] = cutterstart[a1]
chunk.startpoints.append(cutterstart.to_tuple())
chunk.endpoints.append(cutterend.to_tuple())
rot = [0, 0, 0]
rot[a1] = b * anglestep
chunk.rotations.append(rot)
chunk = chunk.to_chunk()
chunk.depth = radiusend - radius
pathchunks.append(chunk)
if (
(reverse and o.movement.type == "MEANDER")
or (o.movement.type == "CONVENTIONAL" and o.movement.spindle_rotation == "CW")
or (o.movement.type == "CLIMB" and o.movement.spindle_rotation == "CCW")
):
chunk.reverse()
reverse = not reverse
if o.strategy_4_axis == "HELIX":
print("Helix")
a1step = o.distance_between_paths / circlesteps
chunk = CamPathChunkBuilder([]) # only one chunk, init here
for a in range(0, floor(steps) + 1):
cutterstart[a1] = o.min[a1] + a * o.distance_between_paths
cutterend[a1] = cutterstart[a1]
cutterstart[a2] = 0
cutterstart[a3] = radius
cutterend[a3] = radiusend
for b in range(0, floor(circlesteps) + 1):
# print(cutterstart,cutterend)
cutterstart[a1] += a1step
cutterend[a1] += a1step
chunk.startpoints.append(cutterstart.to_tuple())
chunk.endpoints.append(cutterend.to_tuple())
rot = [0, 0, 0]
rot[a1] = a * 2 * pi + b * anglestep
chunk.rotations.append(rot)
cutterstart.rotate(e)
cutterend.rotate(e)
chunk = chunk.to_chunk()
chunk.depth = radiusend - radius
pathchunks.append(chunk)
return pathchunks
