def cut_building_volumes(terrain_section_breps, bldg_section_breps):
"""
input: list of lists of extruded terrain breps and section breps.
first level of list is section heights, second level is breps.
output: the new terrain breps
"""
#boolean problem is caused by non-manifold error. need to scale the B_breps prior to booleaning.
new_terrain_section_breps = []
for i, brep_level in enumerate(terrain_section_breps):
new_level_terrain_section_breps = []
for A_brep in brep_level:
#rs.ObjectLayer(A_brep,"s10") #debug
B_breps = rs.CopyObjects(bldg_section_breps[i])
#[rs.ObjectLayer(B_brep,"s11") for B_brep in B_breps] #debug
boolean_result = rs.BooleanDifference([A_brep], B_breps, False)
if boolean_result:
c = [rs.CopyObject(x) for x in boolean_result]
rs.DeleteObjects(boolean_result)
new_level_terrain_section_breps.extend(c)
else:
new_level_terrain_section_breps.append(rs.CopyObject(A_brep))
#print new_level_terrain_section_breps
rs.DeleteObjects(A_brep)
rs.DeleteObjects(B_breps)
rs.DeleteObjects(B_breps) #possibly not needed
rs.DeleteObjects(boolean_result)
#rs.ObjectLayer(new_level_terrain_section_breps,"s3")
new_terrain_section_breps.append(new_level_terrain_section_breps)
return new_terrain_section_breps
def main():
# first, select objects in three orthogonal planes
xs = rs.GetObjects("select X objects", filter=16)
# polysurface
ys = rs.GetObjects("select Y objects", filter=16)
zs = rs.GetObjects("select Z objects", filter=16)
subdivisions = rs.GetInteger(message="enter subdivisions (odd)",
number=5,
minimum=2,
maximum=None)
for positive, negative, hidden in ((xs, ys, zs), (xs, zs, ys), (ys, zs,
xs)):
rs.HideObjects(hidden)
make_fingers(positive, negative, subdivisions)
rs.ShowObjects(hidden)
# each time make_fingers is run, it fills guid_to_difference
# with more fingers to subtract.
# after all the fingers are subtracted at once
for guid, objs in guid_to_difference.items():
if objs:
rs.BooleanDifference(guid, objs)
def perform_subtraction():
# each time make_fingers is run, it fills guid_to_difference
# with more fingers to subtract.
# after all the fingers are subtracted at once
for guid, objs in guid_to_difference.items():
print guid, len(objs)
rs.BooleanDifference(guid, objs)
def subtrackCubeFrom(self, curid, pts, height): btmSuf = rs.AddSrfPt(pts) extrudeLine = rs.AddLine(pts[0],map(sum, zip(pts[0],[0,0,height]))) suf = rs.ExtrudeSurface(btmSuf, extrudeLine, True) newid = rs.BooleanDifference(curid,suf,True) rs.DeleteObjects([btmSuf,extrudeLine,suf]) return newid
def addHallWall(self, roomids, corners, corners2, thickness, height): outWallCrv = rs.AddPolyline(corners) inWallCrv = rs.AddPolyline(corners2) #inWallCrv = rs.OffsetCurve(outWallCrv, [20,14,0], thickness, [0,0,1], CurveOffsetCornerStyle.Sharp) outExtrudeLine = rs.AddLine(corners[0],map(sum, zip(corners[0],[0,0,height]))) outBtmSuf = rs.AddPlanarSrf(outWallCrv)[0] outWall = rs.ExtrudeSurface(outBtmSuf, outExtrudeLine, True) inExtrudeLine = rs.AddLine(corners[0],map(sum, zip(corners[0],[0,0,height-thickness]))) inBtmSuf = rs.AddPlanarSrf(inWallCrv)[0] inWall = rs.ExtrudeSurface(inBtmSuf, inExtrudeLine, True) hallway = rs.BooleanDifference(outWall,inWall,True) rs.DeleteObjects([outWallCrv,inWallCrv,outExtrudeLine,outBtmSuf,outWall,inExtrudeLine,inBtmSuf,inWall]) newroomids = list(roomids) for roomid in roomids: newhallway = rs.BooleanDifference(hallway, roomid,False) newroomid = rs.BooleanDifference(roomid, hallway,False) newroomids.append(newroomid) rs.DeleteObject(hallway) rs.DeleteObject(roomid) hallway = newhallway return hallway
def main():
to_delete = []
rs.ProjectOsnaps(False)
positive_object = rs.GetObject("select positive object", 16)
negative_object = rs.GetObject("select negative object", 16)
rs.HideObject(negative_object)
polysurface, face = GetSubSurface("select tenon surface")
to_delete.append(face)
normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5)))
plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal)
rs.ViewCPlane(plane=plane)
rs.ProjectOsnaps(True)
tenon_rects = rs.GetObjects(message="select tenon curves", filter=4)
tenon_faces = []
for rect in tenon_rects:
tenon_faces.append(rs.AddPlanarSrf(rect)[0])
rs.ShowObject(negative_object)
rs.ProjectOsnaps(False)
height_pt = rs.GetPoint("enter height point")
# compule a vector normal to plane of the desired height
extrude_vec_a = rs.EvaluateSurface(face, 0.5, 0.5)
dist = rs.DistanceToPlane(plane, height_pt)
extrude_vec_b = [dist * el for el in normal]
extrude_vec_b = rs.VectorAdd(extrude_vec_a, extrude_vec_b)
extrude_curve = rs.AddCurve((extrude_vec_a, extrude_vec_b))
to_delete.append(extrude_curve)
tenons = []
for tenon_face in tenon_faces:
tenon = rs.ExtrudeSurface(tenon_face, extrude_curve)
tenons.append(tenon)
rs.BooleanUnion([positive_object] + tenons, delete_input=False)
rs.BooleanDifference([negative_object], tenons, delete_input=False)
to_delete.append(positive_object)
to_delete.append(negative_object)
rs.DeleteObjects(to_delete)
rs.DeleteObjects(tenon_faces)
rs.DeleteObjects(tenons)
def get_frame_brep(outline_srf, border_thickness, thickness):
"""get the frame brep. This is a solid that is booleaned with the slices of
terrain to make a border when border mode is on."""
edge_crvs = rs.DuplicateEdgeCurves(outline_srf)
outline_crv = rs.JoinCurves(edge_crvs)
pt, _ = rs.CurveAreaCentroid(outline_crv)
inner_crv = rs.OffsetCurve(outline_crv, pt, border_thickness, [0, 0, 1])
rs.MoveObjects([outline_crv, inner_crv], [0, 0, thickness * 2])
path_line = rs.AddLine([0, 0, 0], [0, 0, -thickness * 4])
inner_brep = rs.ExtrudeCurve(inner_crv, path_line)
outer_brep = rs.ExtrudeCurve(outline_crv, path_line)
rs.CapPlanarHoles(inner_brep)
rs.CapPlanarHoles(outer_brep)
frame_brep = rs.BooleanDifference([outer_brep], [inner_brep])
rs.DeleteObjects([outline_crv, inner_crv])
rs.DeleteObjects(edge_crvs)
rs.DeleteObject(path_line)
return frame_brep
def SplitGeometry(objs, plane, dir=1):
global diffRadius
circle = Rhino.Geometry.Circle(plane, diffRadius)
negShape = Rhino.Geometry.Cylinder(circle, diffRadius * dir)
negShapeBrep = negShape.ToBrep(True, True)
negShapeGeo = sc.doc.Objects.AddBrep(negShapeBrep)
visibleGeometry = []
for obj in objs:
if rs.IsBrep(obj):
if rs.IsPolysurfaceClosed(obj):
resultObjs = rs.BooleanDifference(obj, negShapeGeo, False)
if resultObjs is None:
visibleGeometry.append(obj)
elif len(resultObjs) < 1:
visibleGeometry.append(obj)
else:
for each in resultObjs:
visibleGeometry.append(each)
else:
resultObjs = rs.SplitBrep(obj, negShapeGeo)
if resultObjs is None:
visibleGeometry.append(obj)
elif len(resultObjs) < 1:
visibleGeometry.append(obj)
else:
for each in resultObjs:
if IsAbovePlane(each, plane.OriginZ):
if dir == -1:
visibleGeometry.append(each)
else:
rs.DeleteObject(each)
else:
if dir == 1:
visibleGeometry.append(each)
else:
rs.DeleteObject(each)
rs.DeleteObject(negShapeGeo)
return visibleGeometry
(newPtCoord[0]+xnum,newPtCoord[1]+ynum,newPtCoord[2]),(newPtCoord[0],newPtCoord[1]+ynum,newPtCoord[2]),\
(newPtCoord[0],newPtCoord[1],newPtCoord[2]+znum),(newPtCoord[0]+xnum,newPtCoord[1],\
newPtCoord[2]+znum),(newPtCoord[0]+xnum,newPtCoord[1]+ynum,newPtCoord[2]+znum),\
(newPtCoord[0],newPtCoord[1]+ynum,newPtCoord[2]+znum)])
pts.append(newPt)
boxes.append(newboxArray)
#for each new box created, boolean difference the previous box
#newObject = rs.BooleanIntersection(boxes[i-1],boxes[i],delete_input=False)
if i == 1:
intersectTrue = rs.IntersectBreps(boxes[i - 1], boxes[i])
if intersectTrue:
newObject = rs.BooleanDifference(boxes[i - 1],
boxes[i],
delete_input=False)
else:
print "No Intersection"
else:
intersectTrue = rs.IntersectBreps(newObject, boxes[i])
if intersectTrue:
newObject = rs.BooleanDifference(newObject,
boxes[i],
delete_input=False)
else:
print "nothing"
#newObject = boxes[i]
#rs.DeleteObject(boxes[i])
def main():
global inner_curves, outer_curves, curve_coords
# save for later
orig_hidden_objects = rs.HiddenObjects()
# we put reference points in the dogbone-ref layer, so create it if it doesn't exist
rs.AddLayer("dogbone-ref")
panel, face = getsubsurface.GetSubSurface("select dogbone face")
diameter = rs.GetReal("enter cutter diameter", number=0.25)
diameter = diameter * 1.1
rs.EnableRedraw(False)
# compute the plane
normal = rs.VectorUnitize(rs.SurfaceNormal(face, (0.5, 0.5)))
plane = rs.PlaneFromNormal(rs.EvaluateSurface(face, 0.5, 0.5), normal)
rs.ViewCPlane(plane=plane)
rs.ProjectOsnaps(True)
outer_curves = rs.DuplicateSurfaceBorder(face, 1)
inner_curves = rs.DuplicateSurfaceBorder(face, 2)
# make a dict mapping each curve to the coords in that curve
curve_coords = dict()
for curve in outer_curves + inner_curves:
coords = rs.CurvePoints(curve)[:-1]
curve_coords[curve] = coords
# make a dict mapping each curve to the z component of its cross product at each index
curve_cross_zs = dict()
for curve, coords in curve_coords.items():
proj_coords = [rs.SurfaceClosestPoint(face, coord) for coord in coords]
cross_zs = []
for idx in range(len(proj_coords)):
triplet = [
proj_coords[(idx + 1) % len(proj_coords)], proj_coords[idx],
proj_coords[(idx - 1) % len(proj_coords)]
]
v0 = (triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1],
0)
v1 = (triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1],
0)
cross_z = rs.VectorCrossProduct(v0, v1)[2]
cross_zs.append(cross_z)
curve_cross_zs[curve] = cross_zs
points = []
bones = []
temp_points = []
rs.EnableRedraw(True)
while True:
coord = rs.GetPoint("select corner")
if coord is None:
break
try:
curve, idx = get_curve_and_idx_for_coord(coord)
point = rs.AddPoint(coord)
rs.ObjectColor(point, (255, 0, 0))
temp_points.append(point)
bones.append((curve, idx))
except ValueError:
print "invalid curve point"
continue
rs.EnableRedraw(False)
rs.DeleteObjects(temp_points)
# try to automatically identify dogbone points if user selected none
if len(bones) == 0:
for curve, coords in curve_coords.items():
proj_coords = [
rs.SurfaceClosestPoint(face, coord) for coord in coords
]
for idx in range(len(proj_coords)):
triplet = [
proj_coords[(idx + 1) % len(proj_coords)],
proj_coords[idx], proj_coords[(idx - 1) % len(proj_coords)]
]
if curve_cross_zs[curve][idx] > 0:
bones.append((curve, idx))
# make the bones
extrusions = []
for bone in bones:
curve, idx = bone
coords = curve_coords[curve]
point = rs.AddPoint(coords[idx])
rs.ObjectLayer(point, "dogbone-ref")
triplet = [
coords[(idx + 1) % len(coords)],
coords[idx],
coords[(idx - 1) % len(coords)],
]
angle = rs.Angle2(
(triplet[1], triplet[0]),
(triplet[1], triplet[2]),
)
angle = angle[0]
# This is a hacky method to determine the handedness of the curve
# the cross product SHOULD have worked here, but for some reason
# it did not.
v0 = triplet[2][0] - triplet[1][0], triplet[2][1] - triplet[1][1], 0
v1 = triplet[1][0] - triplet[0][0], triplet[1][1] - triplet[0][1], 0
_angle = math.degrees(
math.atan2(v0[1], v0[0]) - math.atan2(v1[1], v1[0]))
while _angle > 180:
_angle -= 360
while _angle < -180:
_angle += 360
if math.copysign(1, angle) != math.copysign(1, _angle):
angle -= 180
point = rs.VectorAdd(
triplet[1],
rs.VectorRotate(
0.5 * diameter *
rs.VectorUnitize(rs.VectorSubtract(triplet[2], triplet[1])),
angle / 2, (0, 0, 1)))
circle = rs.AddCircle((point.X, point.Y, -10), diameter / 2.0)
circle_srf = rs.AddPlanarSrf(circle)
p0 = (point.X, point.Y, -10)
p1 = (point.X, point.Y, 10)
line = rs.AddLine(p0, p1)
extrusion = rs.ExtrudeSurface(circle_srf, line)
extrusions.append(extrusion)
rs.DeleteObjects([circle, circle_srf, line])
rs.BooleanDifference([panel], extrusions, delete_input=True)
rs.DeleteObject(panel)
rs.DeleteObjects(extrusions)
rs.DeleteObjects(points)
rs.DeleteObjects(inner_curves)
rs.DeleteObjects(outer_curves)
rs.DeleteObject(face)
rs.ShowObject(rs.AllObjects())
rs.HideObjects(orig_hidden_objects)
rs.EnableRedraw(True)
def piece(layers, maxScale):
curves = []
initialRadii = []
results = []
for i in range(count):
initialRadii.append(random.uniform(minScale * maxScale, maxScale))
# outerExtrusions
outerExtrusions = []
radii = initialRadii[:]
for layer in range(layers):
height = layer * layerHeight
smooth(radii, smoothAmount)
shrink(radii, outerReduce)
scale(radii, random.uniform(1 - wiggle, 1 + wiggle))
scale(radii, upwardsShaping(layer / (layers - 1)))
vertices = []
for i in range(count):
theta = 2 * math.pi * i / count
vertices.append((math.sin(theta) * radii[i],
math.cos(theta) * radii[i], height))
vertices.append(vertices[0])
curve = rs.AddCurve(vertices, 5)
curves.append(curve)
if complete:
extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0),
(0, 0, layerHeight))
rs.CapPlanarHoles(extrusion)
outerExtrusions.append(extrusion)
if not hollow:
results.append(extrusion)
if hollow:
for i in range(shrinkPasses):
shrink(radii, innerReduce)
# innerExtrusions
for layer in range(layers):
actualLayer = layers - layer - 1
height = actualLayer * layerHeight
smooth(radii, smoothAmount)
shrink(radii, innerReduce)
vertices = []
for i in range(count):
theta = 2 * math.pi * i / count
vertices.append((math.sin(theta) * radii[i],
math.cos(theta) * radii[i], height))
vertices.append(vertices[0])
curve = rs.AddCurve(vertices, 5)
curves.append(curve)
if complete:
extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0),
(0, 0, layerHeight))
rs.CapPlanarHoles(extrusion)
result = rs.BooleanDifference(outerExtrusions[actualLayer],
extrusion)
results.append(result)
if downwards:
radii = initialRadii[:]
for layer in range(downwardsLayers):
height = -(layer + 1) * layerHeight
smooth(radii, smoothAmount)
shrink(radii, downwardsReduce)
scale(radii, random.uniform(1 - wiggle, 1 + wiggle))
scale(radii, downwardsShaping(layer / (downwardsLayers - 1)))
vertices = []
for i in range(count):
theta = 2 * math.pi * i / count
vertices.append((math.sin(theta) * radii[i],
math.cos(theta) * radii[i], height))
vertices.append(vertices[0])
curve = rs.AddCurve(vertices, 5)
curves.append(curve)
if complete:
extrusion = rs.ExtrudeCurveStraight(curve, (0, 0, 0),
(0, 0, layerHeight))
rs.CapPlanarHoles(extrusion)
outerExtrusions.append(extrusion)
if not hollow:
results.append(extrusion)
if buildScaffolding:
scaffoldBase = rs.AddRectangle(
(-scaffoldSide / 2, -scaffoldSide / 2, 0), scaffoldSide,
scaffoldSide)
scaffold = rs.ExtrudeCurveStraight(scaffoldBase, (0, 0, 0),
(0, 0, (layers - 1) * layerHeight))
rs.CapPlanarHoles(scaffold)
rs.DeleteObject(scaffoldBase)
results.append(scaffold)
if complete:
rs.DeleteObjects(curves)
rs.AddObjectsToGroup(results, rs.AddGroup())
return results
else:
rs.AddObjectsToGroup(curves, rs.AddGroup())
return curves
def convertLayers( objs, material_thickness ):
invalid_layers =[]
# first find relevant layers
layers = []
volumes = []
subtracts = []
# sort objects
for obj in objs:
layer_name = rs.ObjectLayer(obj)
# todo's
# - add Clamex
m = re.search( '(\d.\d.\d)\s'+
# '.+(Pocket|Engrave|Inner contour|Outer contour|Drill|Saw-X|Saw-Y|Clamex horizontaal|Clamex verticaal).+'+
'.+(Pocket|Engrave|Inner contour|Outer contour|Drill|Saw-X|Saw-Y|Clamex horizontaal).+'+
'((?<=\s\+)\d+\.?\d*|(?<=\s)d\d+\.?\d*)'
, layer_name)
if m and len(m.groups()) == 3:
tool_id = m.group(1)
operation = m.group(2)
z_pos = m.group(3)
if operation == 'Outer contour':
volume = makeExtrusions(m, obj, material_thickness)
if volume:
volumes.append(volume)
elif operation == "Pocket" or operation == 'Pocket' or operation=='Drill':
pocket = createPockets(m, obj)
if pocket:
subtracts.append(pocket )
elif operation == 'Engrave':
pocket = makeEngraves(m, obj)
if pocket:
subtracts.append(pocket )
else:
invalid_layers.append(layer_name)
# rs.CopyObjects(subtracts)
myset = set(invalid_layers)
msg = 'layers could not be processed:\n'
for layer in myset:
msg += '- ' + layer + "\n"
# rs.MessageBox(msg)
part = None
if len(subtracts)> 0:
part = rs.BooleanDifference(volumes, subtracts, False)
rs.DeleteObjects(volumes)
else:
part = volumes
if part:
return part, subtracts
else:
rs.MessageBox('part could not be created')
))
layer1 = rss.BooleanUnion(
quad_rotate_object(
extrude_crv_along_line(
beam_path,
beam_origin,
(0, BEAM_WIDTH, 0)
)))
if ADD_JUNCTION:
# Original `base` is deleted during the boolean union, re-binding name `base` for later reference.
base = rss.BooleanUnion(
base + quad_rotate_object(
rss.AddCylinder((CORE_RADIUS, 0, PLANE_HEIGHT), 3, 0.8)
))
diff = rss.BooleanDifference(layer1, base, delete_input=False)
rss.DeleteObject(layer1)
layer1 = diff
if REMOVE_DRAFT:
rss.DeleteObject(beam_path)
# Part 2: Layer 2
PLANE_HEIGHT = 75
BEAM_LENGTH = 80
BEAM_HALF_LENGTH = BEAM_LENGTH / 2
if BUILD_TARGET == 'all' or 'layer2' in BUILD_TARGET:
beam_origin = (CORE_RADIUS, BEAM_HALF_LENGTH, PLANE_HEIGHT)
# if nghd['name'] != 'Central Oakland':
# continue
# uncomment the above to try out one nghd
border_points = nghd['border']
curve = rs.AddPolyline(border_points)
surface = rs.AddPlanarSrf(curve)
extrusion_line = rs.AddLine((0,0,0), (0,0,3))
solid = rs.ExtrudeSurface(surface, extrusion_line)
rs.DeleteObjects([curve, surface, extrusion_line])
for pipe in nghd['pipes']:
p0 = pipe[0]
p1 = pipe[1]
pipe_line = rs.AddLine((p0[0], p0[1], -.5), (p1[0], p1[1], 3.5))
pipe = rs.AddPipe(pipe_line, 0, 0.5, cap=2)
rs.DeleteObject(pipe_line)
new_solid = None
try:
new_solid = rs.BooleanDifference([solid], [pipe])
except:
print "a boolean difference failed in " + nghd['name']
rs.DeleteObject(pipe)
continue
if new_solid == None:
rs.DeleteObject(pipe)
continue # boolean difference failed, just skip one pipe
else:
solid = new_solid
def main():
# get objects to export
objs = rs.GetObjects("select objects to Make3d", 0, True, True)
if not objs: print "make3d aborted"; return
defaults = {
'material_thickness':18
}
defaults = getDefaultValues(defaults, 'TNM_make3d')
material_thickness = rs.GetReal("Material Thickness", number=defaults['material_thickness'])
storeDefaultValues('TNM_make3d', {'material_thickness':material_thickness} )
rs.EnableRedraw(False)
checkPos(objs)
set_volumes = []
set_subtracts = []
fail_objects =[]
for obj in objs:
if rs.IsBlockInstance(obj):
# get content
copy = rs.CopyObject(obj)
content = ce.explodeBlock( [copy] )
# filter objects to only curves and points
copies = ce.filterObjects(content)
copies = ce.joinCurves(copies)
# copies = ce.joinCurves(copies)
ce.simplify(copies)
volumes, subtracts = convertToVolumes(copies, material_thickness)
parts = volumes
for subtract in subtracts:
if rs.IsPolysurface(parts[0]) and rs.IsPolysurface(subtract) and rs.IsPolysurfaceClosed(parts[0]) and rs.IsPolysurfaceClosed(subtract):
# print parts
# print subtract
temp_parts = rs.BooleanDifference(parts, [subtract], False)
if temp_parts:
print 'subtract success'
rs.DeleteObjects(parts)
rs.DeleteObject(subtract)
parts = temp_parts
else:
print 'boolean differce failed on: %s' % subtract
fail_objects.append(subtract)
else:
print 'boolean differce failed on: %s' % subtract
fail_objects.append(subtract)
# addResultToBlock(obj, result)
else:
# add warning message collision check
print obj
rs.UnselectAllObjects()
rs.SelectObjects(fail_objects)
intersect = None
# for i, volume in enumerate(set_volumes):
# for j, subtracts in enumerate(set_subtracts):
# if(i != j):
# print rs.ObjectLayer(volume)
# intersect = rs.BooleanIntersection(rs.CopyObject(volume), subtracts, False)
# if intersect:
# rs.SelectObjects(intersect)
# rs.DeleteObjects(subtracts)
if intersect:
rs.MessageBox("ERROR")
rs.DeleteObjects(copies)
ce.redraw()
def make_hinge(num_knuckles, knuckle_height, knuckle_radius, thickness,
leaf_length, gap, add_vents):
origin = [0, 0, 0]
hinge_height = num_knuckles * knuckle_height
######################################################################
# Make pin with caps
cap_radius = knuckle_radius - 0.5 * thickness - gap
cap_height = thickness
cap_bottom = rs.AddCylinder(origin, cap_height, cap_radius)
cap_top = rs.AddCylinder([0, 0, hinge_height - cap_height], cap_height,
cap_radius)
pin_radius = knuckle_radius - (gap + thickness)
pin = rs.AddCylinder(origin, hinge_height, pin_radius)
pin = rs.BooleanUnion([pin, cap_bottom, cap_top])
######################################################################
# Make knuckle and holes
right_knuckle = rs.AddCylinder(origin, hinge_height, knuckle_radius)
knuckle_pin_hole = rs.AddCylinder(origin, hinge_height,
knuckle_radius - thickness)
knuckle_bottom_hole = rs.AddCylinder(origin, cap_height + gap,
cap_radius + gap)
knuckle_top_hole = rs.AddCylinder([0, 0, hinge_height - cap_height - gap],
cap_height + gap, cap_radius + gap)
######################################################################
# Make leaves
right_p0 = (0, knuckle_radius, 0)
right_p1 = (leaf_length, knuckle_radius - thickness, hinge_height)
right_leaf = rs.AddBox(mz.box_verts_from_corners(right_p0, right_p1))
right_leaf = rs.BooleanUnion([right_knuckle, right_leaf])
right_leaf, = rs.BooleanDifference(
[right_leaf],
[knuckle_pin_hole, knuckle_bottom_hole, knuckle_top_hole])
mirror_leaf = rs.XformMirror(origin, (1, 0, 0))
left_leaf = rs.TransformObject(right_leaf, mirror_leaf, True)
######################################################################
# Cut out alternating knuckles
z0 = 0
sz = knuckle_radius + gap
left_boxes = []
right_boxes = []
vent_height = knuckle_height - 4 * thickness
for stage in range(num_knuckles):
z1 = z0 + knuckle_height
if stage == 0:
cur_z0 = z0
else:
cur_z0 = z0 - 0.5 * gap
if stage == num_knuckles - 1:
cur_z1 = z1
else:
cur_z1 = z1 + 0.5 * gap
knuckle_box = rs.AddBox(
mz.box_verts_from_corners((-sz, -sz, cur_z0), (sz, sz, cur_z1)))
if stage % 2 == 0:
left_boxes.append(knuckle_box)
else:
right_boxes.append(knuckle_box)
if add_vents:
zmid = z0 + 0.5 * knuckle_height
za = zmid - 0.5 * vent_height
zb = zmid + 0.5 * vent_height
mid_box = rs.AddBox(
mz.box_verts_from_corners((-sz, -pin_radius - gap, za),
(sz, pin_radius + gap, zb)))
if stage % 2 == 0:
right_boxes.append(mid_box)
else:
left_boxes.append(mid_box)
z0 += knuckle_height
left_leaf, = rs.BooleanDifference([left_leaf], left_boxes)
right_leaf, = rs.BooleanDifference([right_leaf], right_boxes)
rs.SelectObjects([left_leaf, right_leaf, pin])
rs.Command('MergeAllFaces')
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
def cut_frame_from_brep(brep, frame):
bdiff = rs.BooleanDifference(brep, frame, False)
if bdiff:
rs.DeleteObject(brep)
brep = bdiff
return brep
def rc_terraincut2(b_obj, building_guids, etching_guids):
join_dist = 0
if str(b_obj.ObjectType) != "Brep":
b_geo = extrusion_to_brep(b_obj.Geometry)
else:
b_geo = b_obj.Geometry
outline_crv = get_surface_outline(b_geo)
#wrh.add_curves_to_layer(outline_crv,1)
#extrude down the topography surface in order to take sections
bool_merged = Rhino.Geometry.Brep.MergeCoplanarFaces(b_geo, D_TOL)
extruded_srf_id = extrude_down_srf(wrh.docobj_to_guid(b_obj))
extruded_srf = rs.coercebrep(extruded_srf_id)
#get planes for sectioning.
planes = get_section_planes(b_geo, THICKNESS)
#get the section curves and the section srfs
#rs.Redraw()
section_srfs = []
for i, plane in enumerate(planes):
#print i
#if first level, get brep outline
if i > 0:
plane_sections = get_section(extruded_srf, plane)
else:
plane_sections = outline_crv
###DEBUG STARTS####
current_level_srfs = []
for crv in plane_sections:
closed = crv.IsClosed
if not closed:
dist = rs.Distance(crv.PointAtStart, crv.PointAtEnd)
res = crv.MakeClosed(dist * 2)
join_dist = dist if dist > join_dist else join_dist
if res == False: return 0
new_brep = Rhino.Geometry.Brep.CreatePlanarBreps(crv)[0]
current_level_srfs.append(new_brep)
#new_brep_added = doc.Objects.AddBrep(new_brep)
#rs.ObjectLayer(new_brep_added,"s15")
###DEBUG ENDS###
section_srfs.append(current_level_srfs)
rs.DeleteObject(extruded_srf_id)
#get extrusions of section srfs
extruded_section_breps = []
boolean_section_breps = []
frame_base_surface = None
for i, brep_level in enumerate(section_srfs):
extruded_breps = []
for brep in brep_level:
srf_added = wrh.add_brep_to_layer(brep, LCUT_IND[2])
if i == 0: frame_base_surface = rs.CopyObject(srf_added)
extruded_breps.append(rs.ExtrudeSurface(srf_added, SHORT_GUIDE))
rs.DeleteObject(srf_added)
extruded_section_breps.append(extruded_breps)
#rs.Redraw()
#make voids for existing buildings
building_breps = building_guids
bldg_subtraction_breps = get_building_booleans(building_breps, planes)
if bldg_subtraction_breps:
extruded_section_breps = cut_building_volumes(extruded_section_breps,
bldg_subtraction_breps)
[rs.DeleteObjects(x)
for x in bldg_subtraction_breps] #purge the building breps
num_divisions = len(section_srfs)
frame_brep = get_frame_brep(frame_base_surface, BORDER_THICKNESS,
THICKNESS * num_divisions)
rs.DeleteObject(frame_base_surface)
#boolean out the features
final_breps = []
for i, brep_level in enumerate(extruded_section_breps):
boolean_level_ind = i + 2
final_level_breps = []
if boolean_level_ind < len(extruded_section_breps):
for A_brep in brep_level:
final_brep = None
B_breps = []
for B_srf in section_srfs[boolean_level_ind]:
B_breps.append(rs.ExtrudeSurface(B_srf, LONG_GUIDE))
#truncate the B_breps
if BORDER_BOOL:
B_breps = [
cut_frame_from_brep(b, frame_brep) for b in B_breps
]
#rs.AddLayer("debug6",[50,200,50]) #debug
#rs.ObjectLayer(B_breps,"debug6")
#handle a bug creating lists of lists sometimes.
if isinstance(B_breps[0], (list, )): B_breps = B_breps[0]
boolean_result = rs.BooleanDifference([A_brep], B_breps, False)
rs.DeleteObjects(B_breps)
if boolean_result:
final_brep = boolean_result
else:
final_brep = rs.CopyObjects([A_brep])
rs.DeleteObjects([A_brep])
#rs.ObjectLayer(B_breps,"debug6")
#rs.AddLayer("s11",[200,200,50]) #debug
#rs.ObjectLayer(final_brep,"s11") #debug
final_level_breps.extend(final_brep)
else:
#rs.ObjectLayer(A_brep,"s11")
final_level_breps.extend(brep_level)
final_breps.append(final_level_breps)
#get the final surfaces by iterating through the final section breps and extracting the top faces.
final_srfs = []
for i, breplevel in enumerate(final_breps):
final_srfs_level = []
for brep in breplevel:
xsrf = wge.get_extreme_srf(rs.coercebrep(brep), 5)
final_srfs_level.append(
doc.Objects.Add(xsrf[0].DuplicateFace(
False))) #must properly type the faces
#rs.ObjectLayer(final_srfs_level,"s4")
final_srfs.append(final_srfs_level)
[rs.DeleteObjects(x) for x in final_breps] #DEBUG
#project etching layers to final srfs
final_srfs.reverse()
#get the boundary curves
main_curves = []
guide_curves = []
etch_curves = []
for i, srflevel in enumerate(final_srfs):
main_curves_level = []
guide_curves_level = []
etch_curves_level = []
for srf in srflevel:
sb = rs.DuplicateSurfaceBorder(srf)
sb_outer = rs.DuplicateSurfaceBorder(srf, 1)
if sb:
main_curves_level.extend(sb)
if i < len(final_srfs) - 1 and sb_outer:
p = rs.ProjectCurveToSurface(sb_outer, final_srfs[i + 1],
[0, 0, -1])
if p: guide_curves_level.extend(p)
rs.DeleteObject(sb_outer)
if sb_outer: rs.DeleteObject(sb_outer) #refactor...
etch_curves_level = project_etching(etching_guids, srflevel)
etch_curves.append(etch_curves_level)
main_curves.append(main_curves_level)
guide_curves.append(guide_curves_level)
flat_srf_list = [item for sublist in final_srfs for item in sublist]
etch_curves.reverse()
main_curves.reverse()
guide_curves.reverse()
bb = rs.BoundingBox(b_geo)
layout_dist = rs.Distance(bb[0], bb[3]) + LASER_GAP
preview_dist = rs.Distance(bb[0], bb[1]) + LASER_GAP
movement_range = [(i + 1) * layout_dist for i in xrange(len(main_curves))]
for i, level_list in enumerate(main_curves):
cp_main = rs.CurvePlane(level_list[0])
rs.MoveObjects(level_list, [0, movement_range[i], -cp_main.OriginZ])
if etch_curves[i]:
rs.MoveObjects(etch_curves[i],
[0, movement_range[i], -cp_main.OriginZ])
if i > 0:
cp_guide = rs.CurvePlane(guide_curves[i][0])
rs.MoveObjects(guide_curves[i],
[0, movement_range[i - 1], -cp_guide.OriginZ])
main_curves = [item for sublist in main_curves for item in sublist]
guide_curves = [item for sublist in guide_curves for item in sublist]
etch_curves = [item for sublist in etch_curves for item in sublist]
preview_geo = [item for sublist in final_srfs for item in sublist]
rs.MoveObjects(preview_geo, [preview_dist, 0, 0])
#close the boundary curves
cb_crvs = []
for c in guide_curves:
if not rs.IsCurveClosed(c):
if rs.IsCurveClosable(c, D_TOL):
cb_curves.append(rs.CloseCurve(rs.CopyObject(c)))
else:
cb_crvs.append(rs.CopyObject(c))
etch_curves = wge.trim_boundary(etch_curves, cb_crvs, D_TOL)
rs.DeleteObjects(cb_crvs)
rs.DeleteObject(frame_brep)
rs.ObjectLayer(main_curves, "XXX_LCUT_01-CUT")
rs.ObjectLayer(guide_curves, "XXX_LCUT_03-LSCORE")
rs.ObjectLayer(etch_curves, "XXX_LCUT_04-ENGRAVE")
rs.ObjectLayer(preview_geo, "XXX_LCUT_00-GUIDES")
if join_dist > 0:
s = "Had to force-close gaps up to a distance of " + str(join_dist)
Rhino.RhinoApp.WriteLine(s)
return 1
