"""Fabex 'joinery.py' © 2021 Alain Pelletier
Functions to create various woodworking joints - mortise, finger etc.
"""
from math import (
asin,
atan2,
degrees,
hypot,
pi,
)
from shapely.geometry import (
LineString,
Point,
)
import bpy
from . import puzzle_joinery
from .utilities.shapely_utils import shapely_to_curve
from .utilities.simple_utils import (
active_name,
union,
rotate,
move,
remove_doubles,
join_multiple,
duplicate,
add_rectangle,
mirror_y,
difference,
make_active,
remove_multiple,
)
# boolean operations for curve objects
[docs]
def finger_amount(space, size):
"""Calculates the amount of fingers needed from the available space vs the size of the finger
Args:
space (float):available distance to cover
size (float): size of the finger
"""
finger_amt = space / size
if (finger_amt % 1) != 0:
finger_amt = round(finger_amt) + 1
if (finger_amt % 2) != 0:
finger_amt = round(finger_amt) + 1
return finger_amt
[docs]
def mortise(length, thickness, finger_play, cx=0, cy=0, rotation=0):
"""Generates a mortise of length, thickness and finger_play tolerance
cx and cy are the center position and rotation is the angle
Args:
length (float): length of the mortise
thickness (float): thickness of material
finger_play (float): tolerance for good fit
cx (float): coordinate for x center of the finger
cy (float):coordinate for y center of the finger
rotation (float): angle of rotation
"""
bpy.ops.curve.simple(
align="WORLD",
location=(cx, cy, 0),
rotation=(0, 0, rotation),
Simple_Type="Rectangle",
Simple_width=length + finger_play,
Simple_length=thickness,
shape="3D",
outputType="POLY",
use_cyclic_u=True,
handleType="AUTO",
edit_mode=False,
)
active_name("_mortise")
[docs]
def interlock_groove(length, thickness, finger_play, cx=0, cy=0, rotation=0):
"""Generates an interlocking groove.
Args:
length (float): Length of groove
thickness (float): thickness of groove
finger_play (float): tolerance for proper fit
cx (float): center offset x
cy (float): center offset y
rotation (float): angle of rotation
"""
mortise(length, thickness, finger_play, 0, 0, 0)
bpy.ops.transform.translate(value=(length / 2 - finger_play / 2, 0.0, 0.0))
bpy.ops.object.transform_apply(location=True, rotation=False, scale=False)
bpy.context.active_object.rotation_euler.z = rotation
bpy.ops.transform.translate(value=(cx, cy, 0.0))
active_name("_groove")
[docs]
def interlock_twist(length, thickness, finger_play, cx=0, cy=0, rotation=0, percentage=0.5):
"""Generates an interlocking twist.
Args:
length (float): Length of groove
thickness (float): thickness of groove
finger_play (float): tolerance for proper fit
cx (float): center offset x
cy (float): center offset y
rotation (float): angle of rotation
percentage (float): percentage amount the twist will take (between 0 and 1)
"""
mortise(length, thickness, finger_play, 0, 0, 0)
active_name("_tmp")
mortise(length * percentage, thickness, finger_play, 0, 0, pi / 2)
active_name("_tmp")
h = hypot(thickness, length * percentage)
oangle = degrees(asin(length * percentage / h))
bpy.ops.curve.simple(
align="WORLD",
location=(0, 0, 0),
rotation=(0, 0, 0),
Simple_Type="Sector",
Simple_startangle=90 + oangle,
Simple_endangle=180 - oangle,
Simple_radius=h / 2,
use_cyclic_u=True,
edit_mode=False,
)
active_name("_tmp")
bpy.ops.curve.simple(
align="WORLD",
location=(0, 0, 0),
rotation=(0, 0, 0),
Simple_Type="Sector",
Simple_startangle=270 + oangle,
Simple_endangle=360 - oangle,
Simple_radius=h / 2,
use_cyclic_u=True,
edit_mode=False,
)
active_name("_tmp")
union("_tmp")
rotate(rotation)
move(x=cx, y=cy)
active_name("_groove")
remove_doubles()
[docs]
def twist_line(length, thickness, finger_play, percentage, amount, distance, center=True):
"""Generates a multiple interlocking twist.
Args:
length (float): Length of groove
thickness (float): thickness of groove
finger_play (float): tolerance for proper fit
percentage (float): percentage amount the twist will take (between 0 and 1)
amount (int):amount of twists generated
distance (float): distance between twists
center (bool): center or not from origin
"""
spacing = distance / amount
while amount > 0:
position = spacing * amount
interlock_twist(length, thickness, finger_play, percentage=percentage, cx=position)
print("Twistline", amount, distance, position)
amount -= 1
join_multiple("_groove")
active_name("twist_line")
if center:
move(x=(-distance - spacing) / 2)
[docs]
def twist_separator_slot(length, thickness, finger_play=0.00005, percentage=0.5):
"""Generates a slot for interlocking twist separator.
Args:
length (float): Length of slot
thickness (float): thickness of slot
finger_play (float): tolerance for proper fit
percentage (float): percentage amount the twist will take (between 0 and 1)
"""
add_rectangle(thickness + finger_play / 2, length, center_y=False)
move(y=((length * percentage - finger_play / 2) / 2))
duplicate()
mirror_y()
join_multiple("simple_rectangle")
active_name("_separator_slot")
[docs]
def interlock_twist_separator(
length,
thickness,
amount,
spacing,
edge_distance,
finger_play=0.00005,
percentage=0.5,
start="rounded",
end="rounded",
):
"""Generates a interlocking twist separator.
Args:
length (float): Length of separator
thickness (float): thickness of separator
amount (int): quantity of separation grooves
spacing (float): distance between slots
edge_distance (float): distance of the first slots close to the edge
finger_play (float): tolerance for proper fit
percentage (float): percentage amount the twist will take (between 0 and 1)
start (string): type of start wanted (rounded, flat or other) not implemented
start (string): type of end wanted (rounded, flat or other) not implemented
"""
amount -= 1
base_width = 2 * edge_distance + spacing * amount + thickness
add_rectangle(base_width, length - finger_play * 2, center_x=False)
active_name("_base")
twist_separator_slot(length, thickness, finger_play, percentage)
while amount > 0:
duplicate(x=spacing)
amount -= 1
join_multiple("_separator_slot")
move(x=edge_distance + thickness / 2)
difference("_", "_base")
active_name("twist_separator")
[docs]
def horizontal_finger(length, thickness, finger_play, amount, center=True):
"""Generates an interlocking horizontal finger pair _wfa and _wfb.
_wfa is centered at 0,0
_wfb is _wfa offset by one length
Args:
length (float): Length of mortise
thickness (float): thickness of material
amount (int): quantity of fingers
finger_play (float): tolerance for proper fit
center (bool): centered of not
"""
if center:
for i in range(amount):
if i == 0:
mortise(length, thickness, finger_play, 0, thickness / 2)
active_name("_width_finger")
else:
mortise(length, thickness, finger_play, i * 2 * length, thickness / 2)
active_name("_width_finger")
mortise(length, thickness, finger_play, -i * 2 * length, thickness / 2)
active_name("_width_finger")
else:
for i in range(amount):
mortise(length, thickness, finger_play, length / 2 + 2 * i * length, 0)
active_name("_width_finger")
join_multiple("_width_finger")
active_name("_wfa")
bpy.ops.object.duplicate_move(
OBJECT_OT_duplicate={"linked": False, "mode": "TRANSLATION"},
TRANSFORM_OT_translate={"value": (length, 0.0, 0.0)},
)
active_name("_wfb")
[docs]
def vertical_finger(length, thickness, finger_play, amount):
"""Generates an interlocking horizontal finger pair _vfa and _vfb.
_vfa is starts at 0,0
_vfb is _vfa offset by one length
Args:
length (float): Length of mortise
thickness (float): thickness of material
amount (int): quantity of fingers
finger_play (float): tolerance for proper fit
"""
for i in range(amount):
mortise(length, thickness, finger_play, 0, i * 2 * length + length / 2, rotation=pi / 2)
active_name("_height_finger")
join_multiple("_height_finger")
active_name("_vfa")
bpy.ops.object.duplicate_move(
OBJECT_OT_duplicate={"linked": False, "mode": "TRANSLATION"},
TRANSFORM_OT_translate={"value": (0, -length, 0.0)},
)
active_name("_vfb")
[docs]
def finger_pair(name, dx=0, dy=0):
"""Creates a duplicate set of fingers.
Args:
name (str): name of original finger
dx (float): x offset
dy (float): y offset
"""
make_active(name)
xpos = (dx / 2) * 1.006
ypos = 1.006 * dy / 2
bpy.ops.object.duplicate_move(
OBJECT_OT_duplicate={"linked": False, "mode": "TRANSLATION"},
TRANSFORM_OT_translate={"value": (xpos, ypos, 0.0)},
)
active_name("_finger_pair")
make_active(name)
bpy.ops.object.duplicate_move(
OBJECT_OT_duplicate={"linked": False, "mode": "TRANSLATION"},
TRANSFORM_OT_translate={"value": (-xpos, -ypos, 0.0)},
)
active_name("_finger_pair")
join_multiple("_finger_pair")
bpy.ops.object.select_all(action="DESELECT")
return bpy.context.active_object
[docs]
def create_base_plate(height, width, depth):
"""Creates blank plates for a box.
Args:
height (float): height size for box
width (float): width size for box
depth (float): depth size for box
"""
bpy.ops.curve.simple(
align="WORLD",
location=(0, height / 2, 0),
rotation=(0, 0, 0),
Simple_Type="Rectangle",
Simple_width=width,
Simple_length=height,
shape="3D",
outputType="POLY",
use_cyclic_u=True,
handleType="AUTO",
edit_mode=False,
)
active_name("_back")
bpy.ops.curve.simple(
align="WORLD",
location=(0, height / 2, 0),
rotation=(0, 0, 0),
Simple_Type="Rectangle",
Simple_width=depth,
Simple_length=height,
shape="3D",
outputType="POLY",
use_cyclic_u=True,
handleType="AUTO",
edit_mode=False,
)
active_name("_side")
bpy.ops.curve.simple(
align="WORLD",
location=(0, 0, 0),
rotation=(0, 0, 0),
Simple_Type="Rectangle",
Simple_width=width,
Simple_length=depth,
shape="3D",
outputType="POLY",
use_cyclic_u=True,
handleType="AUTO",
edit_mode=False,
)
active_name("_bottom")
[docs]
def make_flex_pocket(length, height, finger_thick, finger_width, pocket_width):
"""creates pockets using mortise function for kerf bending
Args:
length (float): Length of pocket
height (float): height of pocket
finger_thick (float): thickness of finger
finger_width (float): width of finger
pocket_width (float): width of pocket
"""
dist = 3 * finger_width / 2
while dist < length:
mortise(height - 2 * finger_thick, pocket_width, 0, dist, 0, pi / 2)
active_name("_flex_pocket")
dist += finger_width * 2
join_multiple("_flex_pocket")
active_name("flex_pocket")
[docs]
def make_variable_flex_pocket(height, finger_thick, pocket_width, locations):
"""creates pockets pocket using mortise function for kerf bending
Args:
height (float): height of the side
finger_thick (float): thickness of the finger
pocket_width (float): width of pocket
locations (tuple): coordinates for pocket
"""
for dist in locations:
mortise(height + 2 * finger_thick, pocket_width, 0, dist, 0, pi / 2)
active_name("_flex_pocket")
join_multiple("_flex_pocket")
active_name("flex_pocket")
[docs]
def create_flex_side(length, height, finger_thick, top_bottom=False):
"""crates a flex side for mortise on curve. Assumes the base fingers were created and exist
Args:
length (float): length of curve
height (float): height of side
finger_thick (float): finger thickness or thickness of material
top_bottom (bool): fingers on top and bottom if true, just on bottom if false
"""
if top_bottom:
fingers = finger_pair("base", 0, height - finger_thick)
else:
make_active("base")
fingers = bpy.context.active_object
bpy.ops.transform.translate(value=(0.0, height / 2 - finger_thick / 2 + 0.0003, 0.0))
bpy.ops.curve.simple(
align="WORLD",
location=(length / 2 + 0.00025, 0, 0),
rotation=(0, 0, 0),
Simple_Type="Rectangle",
Simple_width=length,
Simple_length=height,
shape="3D",
outputType="POLY",
use_cyclic_u=True,
handleType="AUTO",
edit_mode=False,
)
active_name("no_fingers")
bpy.ops.curve.simple(
align="WORLD",
location=(length / 2 + 0.00025, 0, 0),
rotation=(0, 0, 0),
Simple_Type="Rectangle",
Simple_width=length,
Simple_length=height,
shape="3D",
outputType="POLY",
use_cyclic_u=True,
handleType="AUTO",
edit_mode=False,
)
active_name("_side")
make_active("_side")
fingers.select_set(True)
bpy.ops.object.curve_boolean(boolean_type="DIFFERENCE")
active_name("side")
remove_multiple("_")
remove_multiple("base")
[docs]
def angle(a, b):
"""returns angle of a vector
Args:
a (tuple): point a x,y coordinates
b (tuple): point b x,y coordinates
"""
return atan2(b[1] - a[1], b[0] - a[0])
[docs]
def angle_difference(a, b, c):
"""returns the difference between two lines with three points
Args:
a (tuple): point a x,y coordinates
b (tuple): point b x,y coordinates
c (tuple): point c x,y coordinates
"""
return angle(a, b) - angle(b, c)
[docs]
def fixed_finger(loop, loop_length, finger_size, finger_thick, finger_tolerance, base=False):
"""distributes mortises of a fixed distance. Dynamically changes the finger tolerance with the angle differences
Args:
loop (list of tuples): takes in a shapely shape
loop_length (float): length of loop
finger_size (float): size of the mortise
finger_thick (float): thickness of the material
finger_tolerance (float): minimum finger tolerance
base (bool): if base exists, it will join with it
"""
coords = list(loop.coords)
old_mortise_angle = 0
distance = finger_size / 2
j = 0
print("Joinery Loop Length", round(loop_length * 1000), "mm")
for i, p in enumerate(coords):
if i == 0:
p_start = p
if p != p_start:
not_start = True
else:
not_start = False
pd = loop.project(Point(p))
if not_start:
while distance <= pd:
mortise_angle = angle(oldp, p)
mortise_angle_difference = abs(mortise_angle - old_mortise_angle)
mad = 1 + 6 * min(mortise_angle_difference, pi / 4) / (
pi / 4
) # factor for tolerance for the finger
if base:
mortise(finger_size, finger_thick, finger_tolerance * mad, distance, 0, 0)
active_name("_base")
else:
mortise_point = loop.interpolate(distance)
mortise(
finger_size,
finger_thick,
finger_tolerance * mad,
mortise_point.x,
mortise_point.y,
mortise_angle,
)
j += 1
distance = j * 2 * finger_size + finger_size / 2
old_mortise_angle = mortise_angle
oldp = p
if base:
join_multiple("_base")
active_name("base")
move(x=finger_size)
else:
join_multiple("_mort")
active_name("mortise")
[docs]
def find_slope(p1, p2):
"""returns slope of a vector
Args:
p1 (tuple): point 1 x,y coordinates
p2 (tuple): point 2 x,y coordinates
"""
return (p2[1] - p1[1]) / max(p2[0] - p1[0], 0.00001)
[docs]
def slope_array(loop):
"""Returns an array of slopes from loop coordinates.
Args:
loop (list of tuples): list of coordinates for a curve
"""
remove_multiple("-")
coords = list(loop.coords)
# pnt_amount = round(length / resolution)
sarray = []
dsarray = []
for i, p in enumerate(coords):
distance = loop.project(Point(p))
if i != 0:
slope = find_slope(p, oldp)
sarray.append((distance, slope * -0.001))
oldp = p
for i, p in enumerate(sarray):
distance = p[0]
if i != 0:
slope = find_slope(p, oldp)
if abs(slope) > 10:
print(distance)
dsarray.append((distance, slope * -0.00001))
oldp = p
derivative = LineString(sarray)
dderivative = LineString(dsarray)
shapely_to_curve("-derivative", derivative, 0.0)
shapely_to_curve("-doublederivative", dderivative, 0.0)
return sarray
[docs]
def d_slope_array(loop, resolution=0.001):
"""Returns a double derivative array or slope of the slope
Args:
loop (list of tuples): list of coordinates for a curve
resolution (float): granular resolution of the array
"""
length = loop.length
pnt_amount = round(length / resolution)
sarray = []
dsarray = []
for i in range(pnt_amount):
distance = i * resolution
pt = loop.interpolate(distance)
p = (pt.x, pt.y)
if i != 0:
slope = abs(angle(p, oldp))
sarray.append((distance, slope * -0.01))
oldp = p
for i, p in enumerate(sarray):
distance = p[0]
if i != 0:
slope = find_slope(p, oldp)
if abs(slope) > 10:
print(distance)
dsarray.append((distance, slope * -0.1))
oldp = p
dderivative = LineString(dsarray)
shapely_to_curve("doublederivative", dderivative, 0.0)
return sarray
[docs]
def variable_finger(
loop,
loop_length,
min_finger,
finger_size,
finger_thick,
finger_tolerance,
adaptive,
base=False,
double_adaptive=False,
):
"""Distributes mortises of a fixed distance. Dynamically changes the finger tolerance with the angle differences
Args:
loop (list of tuples): takes in a shapely shape
loop_length (float): length of loop
finger_size (float): size of the mortise
finger_thick (float): thickness of the material
min_finger (float): minimum finger size
finger_tolerance (float): minimum finger tolerance
adaptive (float): angle threshold to reduce finger size
base (bool): join with base if true
double_adaptive (bool): uses double adaptive algorithm if true
"""
coords = list(loop.coords)
old_mortise_angle = 0
distance = min_finger / 2
finger_sz = min_finger
oldfinger_sz = min_finger
hpos = [] # hpos is the horizontal positions of the middle of the mortise
# slope_array(loop)
print("Joinery Loop Length", round(loop_length * 1000), "mm")
for i, p in enumerate(coords):
if i == 0:
p_start = p
if p != p_start:
not_start = True
else:
not_start = False
pd = loop.project(Point(p))
if not_start:
while distance <= pd:
mortise_angle = angle(oldp, p)
mortise_angle_difference = abs(mortise_angle - old_mortise_angle)
mad = 1 + 6 * min(mortise_angle_difference, pi / 4) / (
pi / 4
) # factor for tolerance for the finger
# move finger by the factor mad greater with larger angle difference
distance += mad * finger_tolerance
mortise_point = loop.interpolate(distance)
if mad > 2 and double_adaptive:
hpos.append(distance) # saves the mortise center
hpos.append(distance + finger_sz) # saves the mortise center
if base:
mortise(
finger_sz, finger_thick, finger_tolerance * mad, distance + finger_sz, 0, 0
)
active_name("_base")
else:
mortise(
finger_sz,
finger_thick,
finger_tolerance * mad,
mortise_point.x,
mortise_point.y,
mortise_angle,
)
if i == 1:
# put a mesh cylinder at the first coordinates to indicate start
remove_multiple("start_here")
bpy.ops.mesh.primitive_cylinder_add(
radius=finger_thick / 2,
depth=0.025,
enter_editmode=False,
align="WORLD",
location=(mortise_point.x, mortise_point.y, 0),
scale=(1, 1, 1),
)
active_name("start_here_mortise")
old_distance = distance
old_mortise_point = mortise_point
finger_sz = finger_size
next_angle_difference = pi
# adaptive finger length start
while finger_sz > min_finger and next_angle_difference > adaptive:
# while finger_sz > min_finger and next_angle_difference > adaptive:
# reduce the size of finger by a percentage... the closer to 1.0, the slower
finger_sz *= 0.95
distance = old_distance + 3 * oldfinger_sz / 2 + finger_sz / 2
mortise_point = loop.interpolate(distance) # get the next mortise point
next_mortise_angle = angle(
(old_mortise_point.x, old_mortise_point.y),
(mortise_point.x, mortise_point.y),
) # calculate next angle
next_angle_difference = abs(next_mortise_angle - mortise_angle)
oldfinger_sz = finger_sz
old_mortise_angle = mortise_angle
oldp = p
if base:
join_multiple("_base")
active_name("base")
else:
print("Placeholder")
join_multiple("_mort")
active_name("variable_mortise")
return hpos
[docs]
def single_interlock(
finger_depth,
finger_thick,
finger_tolerance,
x,
y,
groove_angle,
type,
amount=1,
twist_percentage=0.5,
):
"""Generates a single interlock at coodinate x,y.
Args:
finger_depth (float): depth of finger
finger_thick (float): thickness of finger
finger_tolerance (float): tolerance for proper fit
x (float): offset x
y (float): offset y
groove_angle (float): angle of rotation
type (str): GROOVE, TWIST, PUZZLE are the valid choices
twist_percentage: percentage of thickness for twist (not used in puzzle or groove)
"""
if type == "GROOVE":
interlock_groove(finger_depth, finger_thick, finger_tolerance, x, y, groove_angle)
elif type == "TWIST":
interlock_twist(
finger_depth,
finger_thick,
finger_tolerance,
x,
y,
groove_angle,
percentage=twist_percentage,
)
elif type == "PUZZLE":
puzzle_joinery.fingers(finger_thick, finger_tolerance)
[docs]
def distributed_interlock(
loop,
loop_length,
finger_depth,
finger_thick,
finger_tolerance,
finger_amount,
tangent=0,
fixed_angle=0,
start=0.01,
end=0.01,
closed=True,
type="GROOVE",
twist_percentage=0.5,
):
"""Distributes interlocking joints of a fixed amount.
Dynamically changes the finger tolerance with the angle differences
Args:
loop (list of tuples): coordinates curve
loop_length (float): length of the curve
finger_depth (float): depth of the mortise
finger_thick (float) thickness of the material
finger_tolerance (float): minimum finger tolerance
finger_amount (int): quantity of fingers
tangent (int):
fixed_angle (float): 0 will be variable, desired angle for the finger
closed (bool): False:open curve - True:closed curved
twist_percentage = portion of twist finger which is the stem (for twist joint only)
type (str): GROOVE, TWIST, PUZZLE are the valid choices
start (float): start distance from first point
end (float): end distance from last point
"""
coords = list(loop.coords)
print(closed)
if not closed:
spacing = (loop_length - start - end) / (finger_amount - 1)
distance = start
end_distance = loop_length - end
else:
spacing = loop_length / finger_amount
distance = 0
end_distance = loop_length
j = 0
print("Joinery Loop Length", round(loop_length * 1000), "mm")
print("Distance Between Joints", round(spacing * 1000), "mm")
for i, p in enumerate(coords):
if i == 0:
p_start = p
if p != p_start:
not_start = True
else:
not_start = False
pd = loop.project(Point(p))
if not_start:
while distance <= pd and end_distance >= distance:
if fixed_angle == 0:
groove_angle = angle(oldp, p) + pi / 2 + tangent
else:
groove_angle = fixed_angle
groove_point = loop.interpolate(distance)
print(
j,
"groove_angle",
round(180 * groove_angle / pi),
"distance",
round(distance * 1000),
"mm",
)
single_interlock(
finger_depth,
finger_thick,
finger_tolerance,
groove_point.x,
groove_point.y,
groove_angle,
type,
twist_percentage=twist_percentage,
)
j += 1
distance = j * spacing + start
oldp = p
join_multiple("_groove")
active_name("interlock")
