def makeNget(_srfs):
flsrf = rs.JoinSurfaces(_srfs, delete_input=False)
pntstr = []
points = rs.SurfacePoints(flsrf)
for point in points:
pt = (point.X, point.Y)
pntstr.append(pt)
def room_from_rhino(frequencies, srf_dict, src_layer, src_power, mic_layer):
room = Room()
room.add_frequencies(frequencies)
# add mics -------------------------------------------------------------
mics = [
list(rs.PointCoordinates(pt)) for pt in rs.ObjectsByLayer(mic_layer)
]
room.add_spherical_recs(mics, radius=.3)
# add source -----------------------------------------------------------
sxyz = list(rs.PointCoordinates(rs.ObjectsByLayer(src_layer)[0]))
room.add_fib_source(sxyz, power=src_power)
# add surfaces ---------------------------------------------------------
for key in srf_dict:
layer = srf_dict[key]['layer']
mat = srf_dict[key]['material']
is_boundary = srf_dict[key]['is_boundary']
guids = rs.ObjectsByLayer(layer)
srf_pts = []
for guid in guids:
pts = [[pt.X, pt.Y, pt.Z] for pt in rs.SurfacePoints(guid)]
pts = [pts[0], pts[1], pts[3], pts[2]]
srf_pts.append(pts)
room.add_material(layer, mat['abs'], mat['sct'], mat['trn'])
room.add_room_surfaces(srf_pts, layer, is_boundary)
return room
def FitSurface(srf_id, samples):
surf_points = rs.SurfacePoints(srf_id)
G = rs.SurfaceEditPoints(srf_id, True, True)
N = GrevilleNormals(srf_id)
S = ConvertToUVW(srf_id, samples)
Forces = [(0, 0, 0) for pt in surf_points]
Factors = [0.0 for pt in surf_points]
proximity = 0.0
translation = 0.0
for i in range(len(S)):
proximity += abs(S[i][2])
for j in range(len(surf_points)):
local_dist = (S[i][0] - G[j][0])**2 + (S[i][1] - G[j][1])**2
if local_dist < 0.01: local_dist = 0.01
local_factor = 1 / local_dist
local_force = rs.VectorScale(N[j], local_factor * S[i][2])
Forces[j] = rs.VectorAdd(Forces(j), local_force)
Factors[j] += local_factor
Forces = DivideVectorArray(Forces, Factors)
for i in range(len(surf_points)):
surf_points[i] = rs.PointAdd(surf_points[i], Forces[i])
translation += rs.VectorLength(Forces[i])
srf_N = rs.SurfacePointCount(srf_id)
srf_K = rs.SurfaceKnots(srf_id)
srf_W = rs.SurfaceWeights(srf_id)
srf_D = (rs.SurfaceDegree(srf_id, 0), rs.SurfaceDegree(srf_id, 1))
return rs.AddNurbsSurface(srf_N, P, srf_K[0], srf_K[1], srf_D, srf_W)
def add_quad(self, obj):
attr = Description(rs.ObjectName(obj))
no = attr.no
corner_numbers = []
pts = rs.SurfacePoints(obj)
for pt in pts:
n = self.add_node(Node(-1, pt, ""))
corner_numbers.append(n.no)
if (no == -1):
no = self.quads.fan
else:
l = len(self.quads.list)
for i in range(0, l):
if (attr.no == self.quads.list[i].no) and (self.current_group == self.quads.list[i].grp):
self.quads.list[i].no = self.quads.fan
q = Quad(self.current_group, no, corner_numbers, attr.prop)
self.quads.list.append(q)
self.output_quads += q.export()
self.quads.update_fan(self.current_group)
def FitSurface(srf_id, samples):
ptSurface = rs.SurfacePoints(srf_id)
grSurface = rs.SurfaceEditPoints(srf_id, True, True)
nrSurface = GrevilleNormals(srf_id)
uvSamples = XYZ_To_UVW(srf_id, samples)
vecForce = [(0, 0, 0) for p in ptSurface]
vecFactor = [0 for p in ptSurface]
#Create null vectors for all control-point forces
for sample in uvSamples:
for j in range(len(grSurface)):
local_distance = (sample[0] - grSurface[j][0])**2 + (
sample[1] - grSurface[j][1])**2
local_factor = 100 / (local_distance**2)
local_force = nrSurface[j]
local_force = rs.VectorScale(local_force, local_factor * sample[2])
vecForce[j] = rs.VectorAdd(vecForce[j], local_force)
vecFactor[j] = vecFactor[j] + local_factor
for i in range(len(ptSurface)):
ptSurface[i] = rs.PointAdd(ptSurface[i],
rs.VectorDivide(vecForce[i], vecFactor[i]))
srf_CP_Count = rs.SurfacePointCount(srf_id)
srf_Knots = rs.SurfaceKnots(srf_id)
srf_Weights = rs.SurfaceWeights(srf_id)
srf_Degree = (rs.SurfaceDegree(srf, 0), rs.SurfaceDegree(srf_id, 1))
return rs.AddNurbsSurface(srf_CP_Count, ptSurface, srf_Knots[0],
srf_Knots[1], srf_Degree, srf_Weights)
def _get_verts(_srfc):
pntstr = []
points = rs.SurfacePoints(_srfc)
for point in points:
#pntstr.append((point.X, point.Y))
pt = (point.X, point.Y)
pntstr.append(pt)
return pntstr
def _get_one_surface_XY_verts(_srfc):
"""Looks at a single surface, finds its point XY data, returns them"""
xy_points = []
points = rs.SurfacePoints(_srfc)
for point in points:
xy_points.append((point.X, point.Y))
return xy_points #=> list
def add_area_element(self, obj, typ_sofi, layer):
"""Adds area element from object."""
qd = AreaElement(obj)
pts = rs.SurfacePoints(obj)
qd.n1 = self.nodes.add(Node(None, pts[0]))
qd.n2 = self.nodes.add(Node(None, pts[1]))
qd.n3 = self.nodes.add(Node(None, pts[3]))
qd.n4 = self.nodes.add(Node(None, pts[2]))
qd.layer = layer
self.area_elements.add(qd)
def init():
dicSur = getSurfaces()
print dicSur
if dicSur['mod']:
rs.DeleteObject(dicSur['mod'])
if dicSur['ref']:
surface = dicSur['ref']
else:
raise RuntimeError, "No surface"
vec = readTrfFyl()
points = rs.SurfacePoints(surface)
seldic = {k: points[k] for k in vec.keys()}
trTic = moveDic(seldic, vec)
srf = transformSrf(surface, trTic)
msrf = trimSurface(srf)
rs.HideObject(surface)
genOffFile()
rs.DeleteObject(msrf)
rs.ShowObject(surface)
def FitSurface(srf_id, samples):
ptSurface = rs.SurfacePoints(srf_id)
grSurface = rs.SurfaceEditPoints(idSrf, True, True)
nrSurface = GrevilleNormals(srf_id)
uvSamples = XYZ_To_UVW(srf_id, samples)
#Create null vectors for all control-point forces
vecForce = [(0,0,0) for pt in ptSurface]
for i in range(len(uvSamples)):
LocalCP = NearestUV(uvSamples[i], grSurface)
LocalForce = nrSurface[LocalCP]
LocalForce = rs.VectorScale(LocalForce, uvSamples[i][2])
vecForce[LocalCP] = rs.VectorAdd(vecForce[LocalCP], LocalForce)
ptSurface = [rs.PointAdd(ptSurface[i], vecForce[i]) for i in range(len(ptSurface))]
srf_CP_Count = rs.SurfacePointCount(srf_id)
srf_Knots = rs.SurfaceKnots(srf_id)
srf_Weights = rs.SurfaceWeights(srf_id)
srf_Degree = (rs.SurfaceDegree(srf_id, 0), rs.SurfaceDegree(srf_id, 1))
return rs.AddNurbsSurface(srf_CP_Count, ptSurface, srf_Knots[0], srf_Knots[1], srf_Degree, srf_Weights)
def transformSrf(obj, dicTr):
if obj:
point_count = rs.SurfacePointCount(obj)
points = rs.SurfacePoints(obj)
knots = rs.SurfaceKnots(obj)
degree = rs.SurfaceDegree(obj)
else:
return None
for k in dicTr:
points[k] = dicTr[k]
if rs.IsSurfaceRational(obj):
weights = rs.SurfaceWeights(obj)
objout = rs.AddNurbsSurface(point_count, points, knots[0], knots[1],
degree, weights)
else:
objout = rs.AddNurbsSurface(point_count, points, knots[0], knots[1],
degree)
if objout:
rs.SelectObject(objout)
rs.ObjectName(objout, "mod")
return objout
else:
return objout
def Main():
rectangle = rs.GetObject(
"Select rectangle to create mortise and tenon from", rs.filter.curve,
True, True)
if rs.IsCurveClosed(rectangle):
x = 0
else:
print "Failed....Curve must be closed and rectangular"
return
if rs.IsCurvePlanar(rectangle):
x = 0
else:
print "Failed....Curve must be planar"
return
lines = rs.ExplodeCurves(rectangle)
count = 0
for line in lines:
count = count + 1
if count != 4:
print "Failed....To many line segments, redraw rectangle"
return
if rs.IsLine(lines[0]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
if rs.IsLine(lines[1]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
if rs.IsLine(lines[2]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
if rs.IsLine(lines[3]):
x = 0
else:
print "Failed....Curve must be rectangular"
return
face = rs.GetObject("Select tenon surface", rs.filter.surface, False, True,
None, True)
length = rs.GetReal("Enter tenon length", number=None)
if length and length != 0:
x = 0
else:
print "Failed....No length was entered"
return
depth = rs.GetReal("Enter mortise depth", number=length + 0.05)
if depth and depth != 0:
x = 0
else:
print "Failed....No depth was entered"
return
fit = rs.GetReal("Enter mortise fit", number=0.01)
line1 = rs.AddLine(rs.CurveStartPoint(lines[0]),
rs.CurveEndPoint(lines[0]))
line2 = rs.AddLine(rs.CurveStartPoint(lines[1]),
rs.CurveEndPoint(lines[1]))
line3 = rs.AddLine(rs.CurveStartPoint(lines[2]),
rs.CurveEndPoint(lines[2]))
line4 = rs.AddLine(rs.CurveStartPoint(lines[3]),
rs.CurveEndPoint(lines[3]))
rs.DeleteObjects(lines)
lines = line1, line2, line3, line4
if rs.CurveLength(lines[0]) > rs.CurveLength(lines[1]):
smallside = rs.CurveLength(lines[1])
longside1 = lines[0]
longside2 = lines[2]
else:
smallside = rs.CurveLength(lines[0])
longside1 = lines[1]
longside2 = lines[3]
filletRadius = smallside / 2
fillet1 = rs.CurveFilletPoints(lines[0], lines[1])
fillet2 = rs.CurveFilletPoints(lines[1], lines[2])
fillet3 = rs.CurveFilletPoints(lines[2], lines[3])
fillet4 = rs.CurveFilletPoints(lines[3], lines[0])
arc1 = rs.AddFilletCurve(lines[0], lines[1], radius=filletRadius)
arc2 = rs.AddFilletCurve(lines[1], lines[2], radius=filletRadius)
arc3 = rs.AddFilletCurve(lines[2], lines[3], radius=filletRadius)
arc4 = rs.AddFilletCurve(lines[3], lines[0], radius=filletRadius)
arcs = arc1, arc2, arc3, arc4
arcs = rs.JoinCurves(arcs)
arcEnd1 = rs.CurveEndPoint(arcs[0])
arcStart1 = rs.CurveStartPoint(arcs[0])
arcEnd2 = rs.CurveEndPoint(arcs[1])
arcStart2 = rs.CurveStartPoint(arcs[1])
if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1, arcStart2):
temp = arcEnd2
arcEnd2 = arcStart2
arcStart2 = temp
line1 = rs.AddLine(arcEnd1, arcEnd2)
line2 = rs.AddLine(arcStart1, arcStart2)
curves = line1, arcs[0], arcs[1], line2
tenonOut = rs.JoinCurves(curves)
tenonSurf = rs.AddPlanarSrf(tenonOut)
point = rs.SurfacePoints(face)
param = rs.SurfaceClosestPoint(face, point[0])
normal = rs.SurfaceNormal(face, param)
normal = normal * length
vect = rs.AddLine(arcEnd1, arcEnd1 + normal)
tenon = rs.ExtrudeSurface(tenonSurf, vect, cap=True)
rs.DeleteObjects(curves)
arcs = arc1, arc2, arc3, arc4
rs.DeleteObjects(arcs)
rs.DeleteObject(rectangle)
rs.ExtendCurveLength(longside1, 0, 0, fit)
rs.ExtendCurveLength(longside1, 0, 1, fit)
rs.ExtendCurveLength(longside2, 0, 0, fit)
rs.ExtendCurveLength(longside2, 0, 1, fit)
if rs.Distance(rs.CurveEndPoint(longside1),
rs.CurveEndPoint(longside2)) < rs.Distance(
rs.CurveStartPoint(longside1),
rs.CurveEndPoint(longside2)):
line1Start = rs.CurveEndPoint(longside1)
line1End = rs.CurveEndPoint(longside2)
line2Start = rs.CurveStartPoint(longside1)
line2End = rs.CurveStartPoint(longside2)
else:
line1Start = rs.CurveStartPoint(longside1)
line1End = rs.CurveEndPoint(longside2)
line2Start = rs.CurveEndPoint(longside1)
line2End = rs.CurveStartPoint(longside2)
shortside1 = rs.AddLine(line1Start, line1End)
shortside2 = rs.AddLine(line2Start, line2End)
arc1 = rs.AddFilletCurve(longside1, shortside1, radius=filletRadius)
arc2 = rs.AddFilletCurve(shortside1, longside2, radius=filletRadius)
arc3 = rs.AddFilletCurve(longside2, shortside2, radius=filletRadius)
arc4 = rs.AddFilletCurve(shortside2, longside1, radius=filletRadius)
arcs = arc1, arc2, arc3, arc4
arcs = rs.JoinCurves(arcs)
arcEnd1 = rs.CurveEndPoint(arcs[0])
arcStart1 = rs.CurveStartPoint(arcs[0])
arcEnd2 = rs.CurveEndPoint(arcs[1])
arcStart2 = rs.CurveStartPoint(arcs[1])
if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1, arcStart2):
temp = arcEnd2
arcEnd2 = arcStart2
arcStart2 = temp
line1 = rs.AddLine(arcEnd1, arcEnd2)
line2 = rs.AddLine(arcStart1, arcStart2)
curves = line1, arcs[0], arcs[1], line2
mortiseOut = rs.JoinCurves(curves)
mortiseSurf = rs.AddPlanarSrf(mortiseOut)
param = rs.SurfaceClosestPoint(face, point[0])
normal = rs.SurfaceNormal(face, param)
normal = normal * depth
vect = rs.AddLine(arcEnd1, arcEnd1 + normal)
mortise = rs.ExtrudeSurface(mortiseSurf, vect, cap=True)
rs.DeleteObject(shortside1)
rs.DeleteObject(shortside2)
rs.DeleteObject(mortiseOut)
rs.DeleteObject(mortiseSurf)
rs.DeleteObjects(curves)
rs.DeleteObjects(lines)
arcs = arc1, arc2, arc3, arc4
rs.DeleteObjects(arcs)
rs.DeleteObject(rectangle)
rs.DeleteObject(tenonOut)
rs.DeleteObject(tenonSurf)
return
import rhinoscriptsyntax as rs
import math
solid = rs.GetObjects("Select solid to miter", rs.filter.polysurface, True, True, objects=None, minimum_count=1, maximum_count=-1)
solid2 = rs.GetObjects("Select second solid to miter (if none, press enter)", rs.filter.polysurface, True, True, objects=None, minimum_count=1, maximum_count=-1)
outerFace = rs.GetObject("Select outer surface", rs.filter.surface, False, True, None, True)
miterFace = rs.GetObject("Select second outer surface", rs.filter.surface, False, True, None, True)
outerFacePoints = rs.SurfacePoints(outerFace)
miterFacePoints = rs.SurfacePoints(miterFace)
intersectPoints = []
for outerFacePoint in outerFacePoints:
for miterFacePoint in miterFacePoints:
if miterFacePoint == outerFacePoint:
intersectPoints.append(miterFacePoint)
param = rs.SurfaceClosestPoint(outerFace, intersectPoints[0])
normal = rs.SurfaceNormal(outerFace, param)
outerEndPoint = intersectPoints[0] + normal
outerVector = normal
param = rs.SurfaceClosestPoint(miterFace, intersectPoints[0])
normal = rs.SurfaceNormal(miterFace, param)
miterEndPoint = intersectPoints[0] + normal
miterVector = normal
line = rs.AddLine(outerEndPoint, miterEndPoint)
rs.HideObject(line)
midPoint = rs.CurveMidPoint(line)
import rhinoscriptsyntax as rs
import math
solid = rs.GetObjects("Select solid to bullnose",
rs.filter.polysurface,
True,
True,
objects=None,
minimum_count=1,
maximum_count=-1)
face = rs.GetObject("Select surface to bullnose", rs.filter.surface, False,
True, None, True)
points = rs.SurfacePoints(face)
if rs.Distance(points[0], points[1]) < rs.Distance(points[1], points[2]):
distance = rs.Distance(points[0], points[1])
line = rs.AddLine(points[0], points[1])
line2 = rs.AddLine(points[2], points[3])
mid1 = rs.CurveMidPoint(line)
mid2 = rs.CurveMidPoint(line2)
path = rs.AddLine(mid1, mid2)
else:
distance = rs.Distance(points[1], points[2])
line = rs.AddLine(points[1], points[2])
line2 = rs.AddLine(points[3], points[0])
mid1 = rs.CurveMidPoint(line)
mid2 = rs.CurveMidPoint(line2)
path = rs.AddLine(mid1, mid2)
def _get_spaceVerts(_srfc):
xy_points = []
points = rs.SurfacePoints(_srfc)
for point in points:
xy_points.append( (point.X, point.Y) )
return xy_points
def main():
rectangle = rs.GetObject("Select rectangle to create mortise and tenon from", rs.filter.curve, True, True)
errorCheck = curveErrorCheck(rectangle)
if errorCheck == True:
return
lines = rs.ExplodeCurves(rectangle)
errorCheck = lineErrorCheck(lines)
if errorCheck == True:
return
face = rs.GetObject("Select tenon surface", rs.filter.surface, False, True, None, True)
length = rs.GetReal("Enter tenon length", number=None)
if length and length != 0:
x = 0
else:
print "Failed....No length was entered"
return
depth = rs.GetReal("Enter mortise depth", number=length+0.05)
if depth and depth != 0:
x = 0
else:
print "Failed....No depth was entered"
return
fit = rs.GetReal("Enter mortise fit", number=0.01)
line1 = rs.AddLine(rs.CurveStartPoint(lines[0]),rs.CurveEndPoint(lines[0]))
line2 = rs.AddLine(rs.CurveStartPoint(lines[1]),rs.CurveEndPoint(lines[1]))
line3 = rs.AddLine(rs.CurveStartPoint(lines[2]),rs.CurveEndPoint(lines[2]))
line4 = rs.AddLine(rs.CurveStartPoint(lines[3]),rs.CurveEndPoint(lines[3]))
rs.DeleteObjects(lines)
lines = line1, line2, line3, line4
if rs.CurveLength(lines[0]) > rs.CurveLength(lines[1]):
smallside = rs.CurveLength(lines[1])
longside1 = lines[0]
longside2 = lines[2]
else:
smallside = rs.CurveLength(lines[0])
longside1 = lines[1]
longside2 = lines[3]
filletRadius = smallside/2
fillet1 = rs.CurveFilletPoints (lines[0], lines[1])
fillet2 = rs.CurveFilletPoints (lines[1], lines[2])
fillet3 = rs.CurveFilletPoints (lines[2], lines[3])
fillet4 = rs.CurveFilletPoints (lines[3], lines[0])
arc1 = rs.AddFilletCurve(lines[0],lines[1], radius = filletRadius)
arc2 = rs.AddFilletCurve(lines[1],lines[2], radius = filletRadius)
arc3 = rs.AddFilletCurve(lines[2],lines[3], radius = filletRadius)
arc4 = rs.AddFilletCurve(lines[3],lines[0], radius = filletRadius)
arcs = arc1, arc2, arc3, arc4
arcs = rs.JoinCurves(arcs)
arcEnd1 = rs.CurveEndPoint(arcs[0])
arcStart1 = rs.CurveStartPoint(arcs[0])
arcEnd2 = rs.CurveEndPoint(arcs[1])
arcStart2 = rs.CurveStartPoint(arcs[1])
if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1,arcStart2):
temp = arcEnd2
arcEnd2 = arcStart2
arcStart2 = temp
line1 = rs.AddLine(arcEnd1, arcEnd2)
line2 = rs.AddLine(arcStart1, arcStart2)
curves = line1, arcs[0], arcs[1], line2
tenonOut = rs.JoinCurves(curves)
tenonSurf = rs.AddPlanarSrf(tenonOut)
point = rs.SurfacePoints(face)
param = rs.SurfaceClosestPoint(face, point[0])
normal = rs.SurfaceNormal(face, param)
normal = normal * length
vect = rs.AddLine( arcEnd1, arcEnd1 + normal )
tenon = rs.ExtrudeSurface(tenonSurf, vect, cap=True)
rs.DeleteObjects(curves)
arcs = arc1, arc2, arc3, arc4
rs.DeleteObjects(arcs)
rs.DeleteObject(rectangle)
rs.ExtendCurveLength(longside1, 0, 0, fit)
rs.ExtendCurveLength(longside1, 0, 1, fit)
rs.ExtendCurveLength(longside2, 0, 0, fit)
rs.ExtendCurveLength(longside2, 0, 1, fit)
if rs.Distance(rs.CurveEndPoint(longside1), rs.CurveEndPoint(longside2)) < rs.Distance(rs.CurveStartPoint(longside1), rs.CurveEndPoint(longside2)):
line1Start = rs.CurveEndPoint(longside1)
line1End = rs.CurveEndPoint(longside2)
line2Start = rs.CurveStartPoint(longside1)
line2End = rs.CurveStartPoint(longside2)
else:
line1Start = rs.CurveStartPoint(longside1)
line1End = rs.CurveEndPoint(longside2)
line2Start = rs.CurveEndPoint(longside1)
line2End = rs.CurveStartPoint(longside2)
shortside1 = rs.AddLine(line1Start, line1End)
shortside2 = rs.AddLine(line2Start, line2End)
arc1 = rs.AddFilletCurve(longside1, shortside1, radius = filletRadius)
arc2 = rs.AddFilletCurve(shortside1, longside2, radius = filletRadius)
arc3 = rs.AddFilletCurve(longside2, shortside2, radius = filletRadius)
arc4 = rs.AddFilletCurve(shortside2, longside1, radius = filletRadius)
arcs = arc1, arc2, arc3, arc4
arcs = rs.JoinCurves(arcs)
arcEnd1 = rs.CurveEndPoint(arcs[0])
arcStart1 = rs.CurveStartPoint(arcs[0])
arcEnd2 = rs.CurveEndPoint(arcs[1])
arcStart2 = rs.CurveStartPoint(arcs[1])
if rs.Distance(arcEnd1, arcEnd2) > rs.Distance(arcEnd1,arcStart2):
temp = arcEnd2
arcEnd2 = arcStart2
arcStart2 = temp
line1 = rs.AddLine(arcEnd1, arcEnd2)
line2 = rs.AddLine(arcStart1, arcStart2)
curves = line1, arcs[0], arcs[1], line2
mortiseOut = rs.JoinCurves(curves)
mortiseSurf = rs.AddPlanarSrf(mortiseOut)
param = rs.SurfaceClosestPoint(face, point[0])
normal = rs.SurfaceNormal(face, param)
normal = normal * depth
vect = rs.AddLine( arcEnd1, arcEnd1 + normal )
mortise = rs.ExtrudeSurface(mortiseSurf, vect, cap=True)
rs.DeleteObject(shortside1)
rs.DeleteObject(shortside2)
rs.DeleteObject(mortiseOut)
rs.DeleteObject(mortiseSurf)
rs.DeleteObjects(curves)
rs.DeleteObjects(lines)
arcs = arc1, arc2, arc3, arc4
rs.DeleteObjects(arcs)
rs.DeleteObject(rectangle)
rs.DeleteObject(tenonOut)
rs.DeleteObject(tenonSurf)
mortiseSide = rs.GetObject("Select part to mortise", rs.filter.polysurface, False, False)
tenonSide = rs.GetObject("Select part to tenon", rs.filter.polysurface, False, False)
tenonUnion = tenonSide, tenon
rs.BooleanDifference(mortiseSide, mortise, delete_input = True)
rs.BooleanUnion(tenonUnion, delete_input = True)
return
