def crackpolygon(pls, count):
temppls = pls
pls = []
if count == 0:
return 1
else:
for pl in temppls:
if rs.CloseCurve(pl) == False:
print
"Not a closed curve"
else:
# print "Cool"
centroid = rs.CurveAreaCentroid(pl)
centpt = rs.AddPoint(centroid[0])
curves = rs.ExplodeCurves(pl)
for crv in curves:
# print crv
pt1 = rs.CurveStartPoint(crv)
pt2 = rs.CurveEndPoint(crv)
pts = []
pts.append(pt1)
pts.append(pt2)
pts.append(centpt)
pts.append(pt1)
newpl = rs.AddPolyline(pts)
pls.append(newpl)
rs.DeleteObject(crv)
cleanup = []
cleanup.append(centpt)
# cleanup.append(curves)
rs.DeleteObjects(cleanup)
count = count - 1
return crackpolygon(pls, count)
def addLevelMarks(func):
rs.EnableRedraw(False)
leftAlign = True
geometry = []
currentLevels = setLevels.getFloorLevels()
for level in currentLevels:
if level is None:
print "Levels have not been set."
return
levelNames = rs.GetDocumentData("Levels")
size = 10
i = 0
stPts = []
for level in currentLevels:
vec1 = [size*.2,size*.1,0]
ptA = [0, level, 0]
ptB = [size*.5, level, 0]
stPts.append(ptA)
geometry.append(rs.AddLine(ptA, ptB))
geometry.append(rs.AddText(levelNames[i] + ": +" + str(level), rs.VectorAdd(ptA, vec1), size*.1))
#Triangle Marking
triPts = [[0,0,0], [size*.05, size*.07,0], [-size*.05, size*.07,0], [0,0,0]]
newPts = []
triPt = rs.VectorAdd(ptA, [size*.1, 0,0])
for j in range(0, 4):
newPts.append(rs.VectorAdd(triPt, triPts[j]))
tri = rs.AddPolyline(newPts)
geometry.append(rs.CloseCurve(tri))
i=i+1
#Dimensions
for i in range(0, len(currentLevels)-1):
pt1 = [0,currentLevels[i], 0]
pt2 = [0,currentLevels[i+1], 0]
pt3 = [size*-.15,currentLevels[i+1], 0]
geometry.append(rs.AddAlignedDimension(pt1, pt2, pt3))
firstPt = [0,currentLevels[0], 0]
lastPt = [0,currentLevels[-1], 0]
dimOffset = [size*-.3,currentLevels[-1], 0]
geometry.append(rs.AddAlignedDimension(firstPt, lastPt, dimOffset))
rs.AddLayer("80_LAYOUT", visible = True)
annoLayer = rs.AddLayer("ANNO", parent = "80_LAYOUT")
for geo in geometry:
rs.ObjectLayer(geo, annoLayer)
rs.AddBlock(geometry, [0,0,0], "Level Marks", True)
if (func == 0):
block = rs.InsertBlock("Level Marks", [0,0,0])
rs.ObjectLayer(block, "ANNO")
rs.EnableRedraw(True)
return
def modify_input(filename):
# Import object from file
join_string = str(input_directory + filename)
combined_string = '!_Import ' + '"' + join_string + '"'
rs.Command(combined_string)
# Get all objects imported
objs = rs.LastCreatedObjects(select=False)[0]
# Close curve
closed_curve = rs.CloseCurve(objs, 0.5)
rs.DeleteObject(objs)
# Rebuild curve to create smoother shape
rs.RebuildCurve(closed_curve, 3, 100)
# Pipe figure with radius of 0.25
piped = rs.AddPipe(closed_curve, 0, 0.4)[0]
rs.MoveObject(piped, [0, 0, 0])
bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane())
maxX = 0
minX = 0
minY = 0
minZ = 0
for pt in bounding_pts:
if pt[0] < minX:
minX = pt[0]
if pt[0] > maxX:
maxX = pt[0]
if pt[1] < minY:
minY = pt[1]
if pt[2] < minZ:
minZ = pt[2]
rect = rs.AddRectangle(rs.WorldXYPlane(), abs(maxX - minX), 3.0)
# Move rect up 1/2 of diameter of circle used to pipe
# Potentially use solid but smaller in height rect
# Select function in rhino module could allow us to select objects so that the export works.
rs.MoveObject(rect, [minX, minY - 3.0, minZ + 0.4])
piped_rect = rs.AddPipe(rect, 0, 0.4)
rs.DeleteObject(closed_curve)
rs.DeleteObject(rect)
rs.SelectObjects([piped, piped_rect])
rs.Command("_-Export " + output_directory + filename + '.stl' +
" _Enter _Tolerance=.001 _Enter")
def output_frame (filename):
join_string = str(input_directory + filename)
combined_string = '!_Import ' + '"' + join_string + '"'
rs.Command(combined_string)
# Get all objects imported
objs = rs.LastCreatedObjects(select=False)[0]
# Close curve
closed_curve = rs.CloseCurve(objs, 0.5)
rs.DeleteObject(objs)
# Rebuild curve to create smoother shape
rs.RebuildCurve(closed_curve, 3, 100)
# Pipe figure with radius of 0.25
piped = rs.AddPipe(closed_curve,0,pipe_diameter)[0]
rs.MoveObject(piped, [0,0,0])
bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane())
maxX = 0
minX = 0
minY = 0
minZ = 0
for pt in bounding_pts:
if pt[0] < minX:
minX = pt[0]
if pt[0] > maxX:
maxX = pt[0]
if pt[1] < minY:
minY = pt[1]
if pt[2] < minZ:
minZ = pt[2]
epsilon = 0.5
center = 0
one = [center - (box_width / 2),minY-epsilon,-1 * pipe_diameter]
two = [center - (box_width / 2),minY-epsilon,pipe_diameter]
three = [center + (box_width / 2),minY-epsilon,pipe_diameter]
four = [center + (box_width / 2),minY-epsilon,-1 * pipe_diameter]
five = [center - (box_width / 2),minY+epsilon,-1 * pipe_diameter]
six = [center - (box_width / 2),minY+epsilon,pipe_diameter]
seven = [center + (box_width / 2),minY+epsilon,pipe_diameter]
eight = [center + (box_width / 2),minY+epsilon,-1 * pipe_diameter]
bowx = rs.AddBox([two, three, four, one, six, seven, eight, five])
def modify_input(filename):
# Import object from file
join_string = str(input_directory + filename)
combined_string = '!_Import ' + '"' + join_string + '"'
rs.Command(combined_string)
# Get all objects imported
objs = rs.LastCreatedObjects(select=False)[0]
# Close curve
closed_curve = rs.CloseCurve(objs, 0.5)
rs.DeleteObject(objs)
# Rebuild curve to create smoother shape
rs.RebuildCurve(closed_curve, 3, 100)
# Pipe figure with radius of 0.25
piped = rs.AddPipe(closed_curve, 0, 0.4)[0]
rs.MoveObject(piped, [0, 0, 0])
bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane())
maxX = 0
minX = 0
minY = 0
minZ = 0
for pt in bounding_pts:
if pt[0] < minX:
minX = pt[0]
if pt[0] > maxX:
maxX = pt[0]
if pt[1] < minY:
minY = pt[1]
if pt[2] < minZ:
minZ = pt[2]
rect = rs.AddRectangle(rs.WorldXYPlane(), abs(maxX - minX), 3.0)
rs.MoveObject(rect, [minX, minY - 3.0, minZ])
rs.AddPipe(rect, 0, 0.4)
rs.DeleteObject(closed_curve)
rs.DeleteObject(rect)
export_string = '!_Export ' + '"' + str(output_directory + filename) + '"'
rs.Command(export_string)
def generate_frame(pt_array):
crv_frame = []
for i in xrange(len(pt_array)):
pt_list = []
tmp_list = pt_array[i]
### closed, add -1
for j in xrange(len(tmp_list)):
pt_list.append(tmp_list[j])
pt_list.append(tmp_list[0])
crv = rs.AddInterpCurve(pt_list)
rs.CloseCurve(crv)
crv_frame.append(crv)
return crv_frame
def clean_curve(b):
"""Clean curve geometry
1. Checks if guid or object
2. Simplifiebs
3. Reverse curve dirn
4. Closes curve if not already closed
"""
if type(b) == type(rs.AddPoint(0, 0, 0)): # already guid
pass
else:
b = sc.doc.Objects.AddCurve(b)
rs.SimplifyCurve(b)
# reverse curve direction
boundarybrep = rs.coercecurve(b)
Rhino.Geometry.Curve.Reverse(boundarybrep)
sc.doc.Objects.Replace(b, boundarybrep)
if rs.IsCurveClosed(b):
return b
else:
return rs.CloseCurve(b)
def dogbone(curves, diam, diam_barrenos, tol):
for curve in curves:
if rs.CloseCurve(curve):
centroid = rs.CurveAreaCentroid(curve)[0]
else:
centroid = rs.CurveMidPoint(curve)
if diam_barrenos == -1:
rs.AddPoint(centroid)
elif diam_barrenos == 0:
pass
else:
rs.AddCircle(centroid, diam_barrenos * .5)
curve = rs.ConvertCurveToPolyline(curve, delete_input=True)
tol_curve = rs.OffsetCurve(curve, centroid, -tol) if tol else curve
ocurve = rs.OffsetCurve(tol_curve,
rs.CurveAreaCentroid(curve)[0], diam * .3)
circles = [rs.AddCircle(i, diam / 2) for i in rs.CurvePoints(ocurve)]
rs.CurveBooleanUnion(circles + [tol_curve])
rs.DeleteObjects([ocurve, tol_curve] + circles)
if curve: rs.DeleteObject(curve)
def output_frame(filename):
global box_height
global box_width
global pipe_diameter
# Import object from file
join_string = str(input_directory + filename)
combined_string = '!_Import ' + '"' + join_string + '"'
rs.Command(combined_string)
# Get all objects imported
objs = rs.LastCreatedObjects(select=False)[0]
# Close curve
closed_curve = rs.CloseCurve(objs, 0.5)
rs.DeleteObject(objs)
# Rebuild curve to create smoother shape
rs.RebuildCurve(closed_curve, 3, 100)
# Pipe figure with radius of 0.25
piped = rs.AddPipe(closed_curve, 0, pipe_diameter)[0]
rs.MoveObject(piped, [0, 0, 0])
bounding_pts = rs.BoundingBox([piped], view_or_plane=rs.WorldXYPlane())
maxX = 0
minX = 0
minY = 0
minZ = 0
for pt in bounding_pts:
if pt[0] < minX:
minX = pt[0]
if pt[0] > maxX:
maxX = pt[0]
if pt[1] < minY:
minY = pt[1]
if pt[2] < minZ:
minZ = pt[2]
epsilon = 0.5
center = 0
one = [
center - (box_width / 2) - box_height, minY - epsilon,
-1 * pipe_diameter
]
two = [
center - (box_width / 2) - box_height, minY - epsilon, pipe_diameter
]
three = [
center + (box_width / 2) + box_height, minY - epsilon, pipe_diameter
]
four = [
center + (box_width / 2) + box_height, minY - epsilon,
-1 * pipe_diameter
]
five = [
center - (box_width / 2) - box_height, minY + epsilon,
-1 * pipe_diameter
]
six = [
center - (box_width / 2) - box_height, minY + epsilon, pipe_diameter
]
seven = [
center + (box_width / 2) + box_height, minY + epsilon, pipe_diameter
]
eight = [
center + (box_width / 2) + box_height, minY + epsilon,
-1 * pipe_diameter
]
bowx = rs.AddBox([two, three, four, one, six, seven, eight, five])
# rect = rs.AddRectangle(rs.WorldXYPlane(), box_width, box_height)
#rect = rs.AddRectangle(rs.WorldXYPlane(), box_width, box_height)
# Potentially use solid but smaller in height rect
# rs.MoveObject(rect, [minX, minY - 3.0, minZ + pipe_diameter])
# piped_rect = rs.AddPipe(rect,0,pipe_diameter)
rs.DeleteObject(closed_curve)
# rs.DeleteObject(rect)
rs.SelectObjects([piped, bowx])
rs.Command("_-Export " + output_directory + filename + '.stl' +
" _Enter _Tolerance=.001 _Enter")
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
