def isShareEdge(srf1, srf2):
border1 = rs.DuplicateSurfaceBorder(srf1)
border2 = rs.DuplicateSurfaceBorder(srf2)
edges1 = rs.ExplodeCurves(border1, True)
edges2 = rs.ExplodeCurves(border2, True)
shareMid = []
threshold = 0.001
flag = False
for e1 in edges1:
for e2 in edges2:
mid1 = rs.CurveMidPoint(e1)
mid2 = rs.CurveMidPoint(e2)
if rs.Distance(mid1, mid2) < threshold:
s1 = rs.CurveStartPoint(e1)
s2 = rs.CurveStartPoint(e2)
e1 = rs.CurveEndPoint(e1)
e2 = rs.CurveEndPoint(e2)
if rs.Distance(s1, s1) < threshold:
flag = True
break
if rs.Distance(s1, e1) < threshold:
flag = True
break
rs.DeleteObjects(edges1)
rs.DeleteObjects(edges2)
return flag
def wallProfile(polySrf):
if polySrf:
offsets = []
border = rs.DuplicateSurfaceBorder(polySrf)
rs.SimplifyCurve(border)
offsets.append(rs.OffsetCurve(border, [0, 0, 0], width / 2))
faces = rs.ExplodePolysurfaces(polySrf, False)
faceborders = [rs.DuplicateSurfaceBorder(face) for face in faces]
rs.DeleteObjects(faces)
for faceborder in faceborders:
rs.SimplifyCurve(faceborder)
centroid = rs.CurveAreaCentroid(faceborder)
offsets.append(rs.OffsetCurve(faceborder, centroid[0], width / 2))
rs.DeleteObjects(faceborders)
srf = rs.AddPlanarSrf(offsets)
rs.DeleteObjects(border)
rs.DeleteObjects(offsets)
return srf
def unroll(self):
x = 0
for i in range(len(self.srfList)):
g = rs.AddGroup()
s, p = rs.UnrollSurface(self.srfList[i], False, self.unrollList[i])
s = rs.JoinSurfaces(s, True)
p = rs.MoveObjects(p, [x, self.name * 10, 0])
s = rs.MoveObject(s, [x, self.name * 10, 0])
b = rs.DuplicateSurfaceBorder(s, 1)
rs.ObjectLayer(b, "cut")
rs.AddObjectsToGroup(b, g)
rs.AddObjectsToGroup(p, g)
bb = rs.BoundingBox(s)
x += fabs(bb[0].X - bb[1].X) + 1
t = rs.AddText(
str(self.name) + "-" + str(i),
util.averagePt(rs.CurvePoints(b)), 0.3)
t = util.makeEngravingFont(t)
rs.AddObjectsToGroup(t, g)
rs.DeleteObjects(s)
def makeFace(srfs):
srfsJoined = rs.JoinSurfaces(srfs, True)
boundaryCrv = rs.DuplicateSurfaceBorder(srfsJoined)
srf = rs.AddPlanarSrf(boundaryCrv)
rs.DeleteObjects(boundaryCrv)
rs.DeleteObject(srfsJoined)
rs.DeleteObjects(srfs)
return srf
def getSrfHLimit(srf):
boundary=rs.DuplicateSurfaceBorder(srf)
pts=srf.CurveEditPoints(boundary)
zs=[]
for p in pts:zs.append(p[2])
zs.sort()
top=zs[-1]
bot=zs[0]
return bot,top
def extframe(srf):
crv = rs.DuplicateSurfaceBorder(srf, type=1)
point = rs.EvaluateCurve(crv, 0)
parameter = rs.SurfaceClosestPoint(srf, point)
plane = rs.SurfaceFrame(srf, parameter)
direction = rs.CurveTangent(crv, 0)
newplane = rs.PlaneFromNormal(point, direction, plane.ZAxis)
frame = sweepSec(crv, newplane, vec1)
if crv: rs.DeleteObjects(crv)
return frame
def isHorizontalUpSrf(srf,tolerance=TOLERANCE):
boundary=rs.DuplicateSurfaceBorder(srf)
if type(boundary is list):boundary=boundary[0]
sp=rs.CurveStartPoint(boundary)
uv=rs.SurfaceClosestPoint(srf,sp)
normal=rs.SurfaceNormal(srf,uv)
normal=rs.VectorUnitize(normal)
nz=normal[2]
rs.DeleteObject(boundary)
if abs(nz-1)<tolerance:return True
return False
def get_ref_pts(ref_obj, srf_num, indexes):
obj_copy = rs.CopyObject(ref_obj)
all_srf = rs.ExplodePolysurfaces(obj_copy)
ref_srf = rs.DuplicateSurfaceBorder(all_srf[srf_num])
ref_lines = rs.ExplodeCurves(ref_srf)
ref_points = [
rs.CurveEndPoint(ref_lines[indexes[0]]),
rs.CurveEndPoint(ref_lines[indexes[1]]),
rs.CurveEndPoint(ref_lines[indexes[2]])
]
return ref_points
def __init__(self, srfGUID):
self.GUID = srfGUID
self.borderGUID = rs.DuplicateSurfaceBorder(srfGUID)
self.srfGeo = rs.coercesurface(srfGUID)
self.brep = self.srfGeo.ToBrep()
self.edgeCrvs = self.brep.DuplicateEdgeCurves()
self.border = rg.Curve.JoinCurves( self.edgeCrvs )[0]
self.nurbsCrv = self.border.ToNurbsCurve()
amp = rg.AreaMassProperties.Compute(self.nurbsCrv, us.util.tol() )
self.Centroid = amp .Centroid
self.Area = amp.Area
def getVertSrf(srfs):
vertSrfs = []
for f in srfs:
edges = rs.ExplodeCurves(rs.DuplicateSurfaceBorder(f), True)
for e in edges:
p1 = rs.CurveStartPoint(e)
p2 = rs.CurveEndPoint(e)
if p1[0] == p2[0] and p1[1] == p2[1]:
vertSrfs.append(f)
rs.DeleteObjects(edges)
break
rs.DeleteObjects(edges)
return vertSrfs
def isHorizonalSrf(srf,return_dir=False,tolerance=TOLERANCE):
boundary=rs.DuplicateSurfaceBorder(srf)
if type(boundary is list):boundary=boundary[0]
sp=rs.CurveStartPoint(boundary)
uv=rs.SurfaceClosestPoint(srf,sp)
normal=rs.SurfaceNormal(srf,uv)
normal=rs.VectorUnitize(normal)
direct=normal[2]
nz=abs(normal[2])
rs.DeleteObject(boundary)
if abs(nz-1)<tolerance:
if return_dir:return True,direct
return True
if return_dir:return False,direct
return False
def sweep_path_profile(path, profile, rotation, scale):
if rh.IsCurve(profile):
return single_ref_or_union(
sweep_path_curve(path, profile, rotation, scale))
elif rh.IsSurface(profile):
o_refs, i_refs = ([
solid_sweep_path_curve(path, border, rotation, scale)
for border in rh.DuplicateSurfaceBorder(profile, i)
] for i in (1, 2))
if i_refs == []:
return single_ref_or_union(o_refs)
else:
return subtract_refs(single_ref_or_union(o_refs),
single_ref_or_union(i_refs))
else:
raise RuntimeError('Continue this')
def splitIrregularPolygon(srf):
boundary=rs.DuplicateSurfaceBorder(srf)
if type(boundary) is list:
crvs=rs.ExplodeCurves(boundary[0],False)
rs.DeleteObjects(boundary)
else :crvs=rs.ExplodeCurves(boundary,True)
hors=[]
for c in crvs:
if isHorizontal(c): hors.append(c)
pts=[]
#print('hors=',hors)
for c in hors:
p=rs.CurveStartPoint(c)
pts.append(p)
rs.DeleteObjects(crvs)#
#print('from splitIrregularPoly ',pts)
return splitSrfVerticallyByPts(srf,pts)
def extframe(srf, vec):
frames = []
crv = rs.DuplicateSurfaceBorder(srf, type=1)
rs.SimplifyCurve(crv)
domain = rs.CurveDomain(crv)
param = (domain[0] + domain[1]) / 2.0
rs.CurveSeam(crv, param)
point = rs.EvaluateCurve(crv, 0)
parameter = rs.SurfaceClosestPoint(srf, point)
plane = rs.SurfaceFrame(srf, parameter)
direction = rs.CurveTangent(crv, 0)
newplane = rs.PlaneFromNormal(point, direction, plane.ZAxis)
frame.append(sweepSec(crv, newplane, vec))
if crv: rs.DeleteObjects(crv)
return frames
def WindowFrame():
surf_int_edge_all = rs.DuplicateSurfaceBorder(surf[1], type=2)
print len(surf_int_edge_all)
window_frame_all = []
for item in range(0, len(surf_int_edge_all), 1):
surf_int_edge = surf_int_edge_all[item]
surf_int_edge = rs.ExplodeCurves(surf_int_edge, True)
trans1 = rs.XformTranslation((0, 0, 2 * ipThick))
trans2 = rs.XformTranslation((0, 0, -2 * ipThick))
point_1 = rs.CurveStartPoint(surf_int_edge[0])
point_2 = rs.CurveStartPoint(surf_int_edge[1])
point_3 = rs.CurveStartPoint(surf_int_edge[2])
point_4 = rs.CurveStartPoint(surf_int_edge[3])
point_5 = rs.PointTransform(point_1, trans1)
point_6 = rs.PointTransform(point_2, trans1)
point_7 = rs.PointTransform(point_3, trans1)
point_8 = rs.PointTransform(point_4, trans1)
point_1 = rs.PointTransform(point_1, trans2)
point_2 = rs.PointTransform(point_2, trans2)
point_3 = rs.PointTransform(point_3, trans2)
point_4 = rs.PointTransform(point_4, trans2)
frame_points = []
frame_points.append(point_1)
frame_points.append(point_2)
frame_points.append(point_3)
frame_points.append(point_4)
frame_points.append(point_5)
frame_points.append(point_6)
frame_points.append(point_7)
frame_points.append(point_8)
window_frame = rs.AddBox(frame_points)
window_frame_all.append(window_frame)
return window_frame_all
def saveSurfaceBorders():
surfaces = rs.GetObjects('select surfaces', 8)
filename = rs.SaveFileName()
vI = 1
file = open(filename, "w")
for surface in surfaces:
layername = rs.ObjectLayer(surface)
border = rs.DuplicateSurfaceBorder(surface)
pts = rs.CurvePoints(border)
pts = pts[:-1]
indexes = []
for point in pts:
file.write(getVertexString(point))
indexes.append(vI)
vI += 1
file.write(getFaceStringComment(indexes, layername))
# file.write(getFaceString(indexes))
rs.DeleteObject(border)
file.close()
return
def borders(self, type=1):
"""Duplicate the borders of the surface.
Parameters
----------
type : {0, 1, 2}
The type of border.
* 0: All borders
* 1: The exterior borders.
* 2: The interior borders.
Returns
-------
list
The GUIDs of the extracted border curves.
"""
border = rs.DuplicateSurfaceBorder(self.guid, type=type)
curves = rs.ExplodeCurves(border, delete_input=True)
return curves
def getSrfTopBotVertCrvs(srf):
tolerance = 0.0001
#borders=rs.DuplicateSurfaceBorder(srf,1)
borders = rs.DuplicateSurfaceBorder(srf)
crvs = rs.ExplodeCurves(borders)
hor_crvs = []
ver_crvs = []
trash = []
for c in crvs:
start = rs.CurveStartPoint(c)
end = rs.CurveEndPoint(c)
# print('checking z of end points:',start[2],end[2])
if abs(start[2] - end[2]) < tolerance: hor_crvs.append(c)
elif abs(start[1] - end[1]) < tolerance and abs(start[0] -
end[0]) < tolerance:
ver_crvs.append(c)
else:
trash.append(c)
# print('hor_crvs len:',len(hor_crvs))
hor_crvs = rs.JoinCurves(hor_crvs, True)
bot = None
top = None
if len(hor_crvs) == 2:
s1 = rs.CurveStartPoint(hor_crvs[0])
s2 = rs.CurveStartPoint(hor_crvs[1])
if s1[2] > s2[2]:
bot = hor_crvs[1]
top = hor_crvs[0]
else:
bot = hor_crvs[0]
top = hor_crvs[1]
rs.DeleteObjects(borders)
rs.DeleteObjects(trash)
return top, bot, ver_crvs
def create_slots(array, partIndex):
""" Creates half-lap slots for a given part with its intersecting neighbors.
Returns a list of tuples with part index and slot curve."""
numItems = len(array)
if partIndex >= numItems:
return "part index outside of array"
part = array[partIndex]
intersections = find_neighbor_intersections(array, partIndex)
boundary = rs.DuplicateSurfaceBorder(part)
slots = []
## check intersections with the part's boundary to determine joint case
## rs.CurveCurveIntersection returns case specific lists see F1 help.
for line in intersections:
if len(line) == 1: return
intersectTest = rs.CurveCurveIntersection(line[1], boundary)
## Case 1: slot is floating in part boundary (Only works in some cases)
if intersectTest == None:
slots.append((partIndex, line[1]))
## Case 2: intersection coincedent along an edge and can't be slotted
elif intersectTest[0][0] == 2:
print "no slot needed"
## Case 3: part and neighbor have a valid connection and slot is drawn
else:
## create Current Part slot
startPoint = intersectTest[0][1]
endPoint = evaluateCrv(line[1], .5)
slot = rs.AddLine(startPoint, endPoint)
slots.append((partIndex, slot))
## create neighbor slot
testPoint = rs.CurveEndPoint(line[1])
distance = rs.Distance(startPoint, testPoint)
if distance != 0:
startPoint = testPoint
else:
startPoint = rs.CurveStartPoint(line[1])
slot = rs.AddLine(startPoint, endPoint)
slots.append((line[0], slot))
return slots
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)
hatch_scale = rs.HatchScale(hatch)
# Make hatch solid so we able to explode it and get surface instead
if hatch_pattern != "Solid":
rs.HatchPattern(hatch, "Solid")
dup_border_surface = []
dup_border_surface.append(rs.ExplodeHatch(hatch)[0])
rs.SurfaceIsocurveDensity(dup_border_surface, 100)
selected_objects.append(dup_border_surface)
reduced_selected_objects = reduce(operator.add, selected_objects)
rs.SelectObjects(reduced_selected_objects)
rs.HideObject(hatch)
rs.Command("_Trim")
trimmed_surface = rs.LastCreatedObjects()
new_borders = []
if trimmed_surface:
for surface in trimmed_surface:
new_borders.append(rs.DuplicateSurfaceBorder(surface))
selected_objects.append(new_borders)
# Keep trimming lines but everything else will be deleted further
selected_objects.remove(trim_lines)
new_hatches = rs.AddHatches(new_borders, hatch_pattern, hatch_scale, hatch_rotation)
rs.MatchObjectAttributes(new_hatches, hatch)
rs.ShowObject(new_hatches)
rs.DeleteObjects(trimmed_surface)
else:
print("No trimmed surfaces was created.")
else:
print("No hatches was selected.")
def Ramp_HeightSlope(path, width, slope):
#Variables
rampThickness = 6
handrailOffset = 3
handrailRadius = 1.5
handrailHeight = 34
if width < 36:
width = 36
width = width + (handrailOffset * 2)
comments = ''
handrailCenterlineOffset = (handrailOffset - handrailRadius / 2)
rs.SimplifyCurve(path)
runs = MakeRampRuns(path, width)
if slope > .05:
runData = CheckRunLengths(runs)
runs = runData[0]
comments += runData[1]
runGeo = []
hdrls = []
finalHandrails = []
vertMove = (0, 0, 0)
for run in runs:
length = rs.Distance(rs.CurveStartPoint(run[0]),
rs.CurveStartPoint(run[1]))
stHeight = vertMove
vertMove = (0, 0, length * slope)
rs.MoveObject(run[-1], vertMove)
rs.MoveObjects(run, stHeight)
vertMove = rs.VectorAdd(stHeight, vertMove)
srf = rs.AddLoftSrf(run)
norm = rs.SurfaceNormal(srf[0], [.5, .5])
if norm.Z < 0:
rs.FlipSurface(srf[0], True)
runGeo.append(srf[0])
else:
runGeo.append(srf[0])
hdrls.append(MakeHandrailFromRuns(run, handrailCenterlineOffset))
rs.DeleteObjects(run)
#Get highest and lowest lines
landingEdges = []
for run in runGeo:
curves = rs.DuplicateEdgeCurves(run)
highestIndex = None
highestValue = -999999
lowestIndex = None
lowestValue = 999999
for i, curve in enumerate(curves):
crvZ = rs.CurveMidPoint(curve)[2]
if crvZ < lowestValue:
lowestIndex = i
lowestValue = crvZ
if crvZ > highestValue:
highestIndex = i
highestValue = crvZ
lowestEdge = rs.CopyObject(curves[lowestIndex])
highestEdge = rs.CopyObject(curves[highestIndex])
landingEdges.append(lowestEdge)
rs.ReverseCurve(highestEdge)
landingEdges.append(highestEdge)
rs.DeleteObjects(curves)
comments += 'Total ramp height {}"\n'.format(str(highestValue))
#Make Landings
landingGeos = MakeRampLandings(landingEdges, handrailCenterlineOffset)
landings = landingGeos[0]
hdrls += landingGeos[1]
allHandrails = []
for hdrl in hdrls:
for each in hdrl:
allHandrails.append(each)
longRails = rs.JoinCurves(allHandrails, True)
#Handrail Extension
for rail in longRails:
stPt = rs.CurveStartPoint(rail)
stVec = rs.CurveTangent(rail, 0)
stVecProj = rs.VectorScale(
rs.VectorReverse(rs.VectorUnitize((stVec[0], stVec[1], 0))), 12)
endPt = rs.CurveEndPoint(rail)
endParam = rs.CurveClosestPoint(rail, endPt)
endVec = rs.CurveTangent(rail, endParam)
endVecProj = rs.VectorScale(
rs.VectorUnitize((endVec[0], endVec[1], 0)), 12)
stPtTemp = rs.CurveStartPoint(rail)
endPtTemp = rs.CurveEndPoint(rail)
stPtOffset = rs.MoveObject(stPtTemp, stVecProj)
endPtOffset = rs.MoveObject(endPtTemp, endVecProj)
stProj = rs.AddLine(stPt, stPtOffset)
endProj = rs.AddLine(endPt, endPtOffset)
finalHandrails.append(rs.JoinCurves([stProj, rail, endProj], True)[0])
rs.DeleteObject(stPtOffset)
rs.DeleteObject(endPtOffset)
#Move handrails up
for rail in finalHandrails:
rs.MoveObject(rail, (0, 0, handrailHeight))
#Make solid geometry
topSurface = rs.JoinSurfaces(runGeo + landings, True)
if topSurface is None: topSurface = runGeo
btmSurface = rs.CopyObject(topSurface, (0, 0, -rampThickness))
edgeCurves = rs.DuplicateSurfaceBorder(topSurface)
extrusionLine = rs.AddLine((0, 0, 0), (0, 0, -rampThickness))
extrusionGeo = rs.ExtrudeCurve(edgeCurves, extrusionLine)
rs.DeleteObject(extrusionLine)
rs.DeleteObject(edgeCurves)
finalGeo = rs.JoinSurfaces([topSurface, btmSurface, extrusionGeo], True)
#rs.EnableRedraw(True)
#print "A"
if slope <= .05:
rs.DeleteObjects(finalHandrails)
return [finalGeo, comments]
else:
return [finalGeo, comments, finalHandrails]
import rhinoscriptsyntax as rs
import scriptcontext as sc
import Rhino as rh
viste = rs.ViewNames()
for viewport in viste:
rs.ViewDisplayMode(viewport, "Shaded")
diametro = 1
brep = rs.GetObjects("dammi un solido", 16)
brepexp = rs.ExplodePolysurfaces(brep)
surface = rs.GetObject("dammi la superficie", 8)
surf_edge = rs.DuplicateSurfaceBorder(surface, 1)
new_surface = rs.CopyObject(surface, (0, 0, 0))
uv = []
temp_edge = rs.ExplodeCurves(surf_edge, False)
list_evpt = []
for i in temp_edge:
evpt = rs.CurveMidPoint(i)
print evpt
list_evpt.append(evpt)
for i in list_evpt:
bord = rs.SurfaceClosestPoint(new_surface, i)
uv.append(bord)
for i in uv:
rs.ExtendSurface(new_surface, i, diametro * 10)
edge = rs.OffsetCurveOnSurface(surf_edge, new_surface, -diametro)
print edge
if rs.CurveLength(edge) < rs.CurveLength(surf_edge):
rs.DeleteObject(edge)
def surface_borders(surface, border_type=0):
border = rs.DuplicateSurfaceBorder(surface, border_type)
curves = rs.ExplodeCurves(border, delete_input=True)
return curves
def rebuildSrfCrv(obj):
crv = rs.DuplicateSurfaceBorder(obj, type=0)
map(lambda x: rs.SimplifyCurve(x), crv)
return crv
if abs(start[1]-end[1])<tolerance and abs(start[0]-end[0])<tolerance:
return True
return False
def isHorizontal(crv,tolerance=0.0001):
start=rs.CurveStartPoint(c)
end=rs.CurveEndPoint(c)
if abs(start[2]-end[2])<tolerance:
return True
return False
objs=rs.ObjectsByLayer('GENMASSING')
srf=objs[0]
print(srf)
boundary=rs.DuplicateSurfaceBorder(srf)
pts=rs.CurveEditPoints(boundary)
# rs.AddPoints(pts)
crvs=rs.ExplodeCurves(boundary,True)
hors=[]
for c in crvs:
if isHorizontal(c): hors.append(c)
up=(0,0,100000000)
cutters=[]
for c in hors:
p=rs.CurveStartPoint(c)
start=rs.VectorSubtract(p,up)
end=rs.VectorAdd(p,up)
l=rs.AddLine(start,end)
def stairHeight(route, width=48, height=120):
"""
Makes a stair to specified height.
input: route(pline), width (num), height(num)
returns: Geo
"""
try:
rs.EnableRedraw(False)
rs.SimplifyCurve(route)
if route is None:
print("ERROR: No path selected")
return
if (rs.UnitSystem() == 2): #if mm
maxRiserHeight = 180
thickness = 200
if (rs.UnitSystem() == 4): #if m
maxRiserHeight = .180
thickness = .200
if (rs.UnitSystem() == 8): #if in"
maxRiserHeight = 7
thickness = 9
negativeBoo = False
if (height < 0):
#if the stair
negativeBoo = True
landingEdges = []
landings = []
segments = rs.ExplodeCurves(route)
if len(segments) < 1:
segments = [rs.CopyObject(route)]
landingHeight = []
geometry = []
#Check that all segments are lines
for i in range(0, len(segments)):
if not (rs.IsLine(segments[i])):
print(
"ERROR: This function only accepts lines. No arcs or nurb curves."
)
rs.DeleteObjects(segments)
return
#first landing edge
norm = rs.VectorRotate(rs.CurveTangent(segments[0], 0), 90, [0, 0, 1])
norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2)
side1Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), norm)
side2Pt = rs.VectorAdd(rs.CurveStartPoint(segments[0]), -norm)
landingEdges.append(rs.AddLine(side1Pt, side2Pt))
#middle landing edges
for i in range(0, len(segments) - 1):
edgeList, landing = rampIntersection(segments[i], segments[i + 1],
width)
landingEdges.append(edgeList[0])
landingEdges.append(edgeList[1])
landings.append(landing)
#last landing edge
norm = rs.VectorRotate(
rs.CurveTangent(segments[-1], rs.CurveParameter(segments[-1], 1)),
90, [0, 0, 1])
norm = rs.VectorScale(rs.VectorUnitize(norm), width / 2)
side1Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), norm)
side2Pt = rs.VectorAdd(rs.CurveEndPoint(segments[-1]), -norm)
landingEdges.append(rs.AddLine(side1Pt, side2Pt))
#Add risers
riserCrvs = []
treadVecs = []
numRisersPerRun = []
numRisers = abs(int(math.ceil(height / maxRiserHeight)))
risersSoFar = 0
totalRun = getTotalRun(landingEdges)
optTreadDepth = totalRun / (numRisers - 1)
#2R+T = 635
riserHeight = height / numRisers
if (negativeBoo):
curRiserHeight = 0
else:
curRiserHeight = riserHeight
for i in range(0, len(landingEdges), 2): #find numRisers in each run
a = rs.CurveMidPoint(landingEdges[i])
b = rs.CurveMidPoint(landingEdges[i + 1])
runDist = rs.Distance(a, b)
numRisersThisRun = int(round((runDist / optTreadDepth), 0))
if (numRisersThisRun == 0):
numRisersThisRun = 1
if (i == len(landingEdges) -
2): #if last run, add the rest of the risers
numRisersThisRun = numRisers - risersSoFar
else:
risersSoFar = risersSoFar + numRisersThisRun
numRisersPerRun.append(numRisersThisRun)
#Create Risers on Plan
for i in range(0, len(landingEdges), 2):
run = []
a = rs.CurveMidPoint(landingEdges[i])
b = rs.CurveMidPoint(landingEdges[i + 1])
centerStringer = rs.AddLine(a, b)
runDist = rs.Distance(a, b)
numRisersThisRun = numRisersPerRun[int(i / 2)] #risers in this run
tarPts = rs.DivideCurve(centerStringer,
numRisersThisRun,
create_points=False)
rs.DeleteObject(centerStringer)
for j in range(0, numRisersThisRun + 1):
if (j == 0):
treadVecs.append(rs.VectorCreate(tarPts[0], tarPts[1]))
transVec = rs.VectorCreate(tarPts[0], tarPts[j])
run.append(rs.CopyObject(landingEdges[i], -transVec))
riserCrvs.append(run)
print('Flight {0} has {1} risers: {3}" tall, Treads: {2}" deep'.
format(
int(i / 2) + 1, numRisersThisRun,
rs.VectorLength(treadVecs[int(i / 2)]), riserHeight))
#Move riser edges vertically
for i in range(0, len(riserCrvs)):
triangles = []
if (negativeBoo):
for j in range(0, len(riserCrvs[i]) - 1):
#if stairs descending
rs.MoveObject(
riserCrvs[i][j],
rs.VectorAdd([0, 0, curRiserHeight], -treadVecs[i]))
riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j],
[0, 0, 0],
[0, 0, riserHeight])
treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j],
[0, 0, 0], treadVecs[i])
stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j]))
pt1 = rs.CopyObject(
stPt, [0, 0, riserHeight]) #first riser in run
pt2 = rs.CopyObject(stPt, treadVecs[i]) #last riser in run
triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt])
triangles.append(rs.AddPlanarSrf(triCrv))
geometry.append(riserGeo) #riser
geometry.append(treadGeo) #tread
curRiserHeight = curRiserHeight + riserHeight
rs.MoveObject(riserCrvs[i][j], treadVecs[i])
#cleanup
rs.DeleteObject(triCrv)
rs.DeleteObject(stPt)
rs.DeleteObject(pt1)
rs.DeleteObject(pt2)
else:
for j in range(0, len(riserCrvs[i]) - 1):
#if stairs ascend
rs.MoveObject(riserCrvs[i][j], [0, 0, curRiserHeight])
stPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][j]))
pt1 = rs.CopyObject(
stPt, [0, 0, -riserHeight]) #first riser in run
pt2 = rs.CopyObject(stPt,
-treadVecs[i]) #last riser in run
triCrv = rs.AddPolyline([stPt, pt1, pt2, stPt])
triangles.append(rs.AddPlanarSrf(triCrv))
riserGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j],
[0, 0, 0],
[0, 0, -riserHeight])
treadGeo = rs.ExtrudeCurveStraight(riserCrvs[i][j],
[0, 0, 0],
-treadVecs[i])
geometry.append(riserGeo) #riser
geometry.append(treadGeo) #tread
curRiserHeight = curRiserHeight + riserHeight
#cleanup
rs.DeleteObject(triCrv)
rs.DeleteObject(stPt)
rs.DeleteObject(pt1)
rs.DeleteObject(pt2)
#Make Stringer
if (negativeBoo):
firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0]))
lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2]))
#rs.MoveObject(firstStartPt, [0,0,riserHeight]) #first riser in run
rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run
rs.MoveObject(lastStartPt,
[0, 0, riserHeight]) #last riser in run
else:
firstStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][0]))
lastStartPt = rs.AddPoint(rs.CurveStartPoint(riserCrvs[i][-2]))
rs.MoveObject(firstStartPt,
[0, 0, -riserHeight]) #first riser in run
rs.MoveObject(lastStartPt, -treadVecs[i]) #last riser in run
stringerCrv = rs.AddLine(firstStartPt, lastStartPt)
stringerSrf = rs.ExtrudeCurveStraight(stringerCrv, [0, 0, 0],
[0, 0, -thickness])
triangles.append(stringerSrf)
stringer = makeFace(triangles)
stringerVec = rs.VectorCreate(rs.CurveEndPoint(riserCrvs[i][0]),
rs.CurveStartPoint(riserCrvs[i][0]))
underside = rs.ExtrudeCurveStraight(
stringerCrv, rs.CurveStartPoint(riserCrvs[i][0]),
rs.CurveEndPoint(riserCrvs[i][0]))
geometry.append(rs.MoveObject(underside, [0, 0, -thickness]))
geometry.append(rs.CopyObject(stringer, stringerVec))
geometry.append(stringer)
#cleanup
rs.DeleteObject(firstStartPt)
rs.DeleteObject(lastStartPt)
rs.DeleteObject(stringerCrv)
rs.DeleteObject(stringerSrf)
#Move Landings
lastLandingHeight = 0
for i in range(0, len(segments) - 1):
landingHeight = lastLandingHeight + numRisersPerRun[i] * riserHeight
rs.MoveObject(landings[i], [0, 0, landingHeight])
landingTopSrf = rs.AddPlanarSrf(landings[i])
landingBtmSrf = rs.CopyObject(landingTopSrf, [0, 0, -thickness])
geometry.append(landingTopSrf)
geometry.append(landingBtmSrf)
lastLandingHeight = landingHeight
landingEdgesToEx = rs.ExplodeCurves(landings[i])
geometry.append(
rs.ExtrudeCurveStraight(landingEdgesToEx[1], [0, 0, 0],
[0, 0, -thickness]))
geometry.append(
rs.ExtrudeCurveStraight(landingEdgesToEx[2], [0, 0, 0],
[0, 0, -thickness]))
rs.DeleteObjects(landingEdgesToEx)
#Create final geometry
joinedGeo = rs.JoinSurfaces(geometry, True)
holes = rs.DuplicateSurfaceBorder(joinedGeo)
cap = rs.AddPlanarSrf(holes)
newGeo = rs.ExplodePolysurfaces(joinedGeo, True)
for i in cap:
newGeo.append(i)
FinalGeo = rs.JoinSurfaces(newGeo, True)
#cleanup
try:
rs.DeleteObjects(segments)
except:
rs.DeleteObject(segments)
rs.DeleteObjects(holes)
rs.DeleteObjects(landings)
rs.DeleteObjects(landingEdges)
for i in riserCrvs:
rs.DeleteObjects(i)
rs.EnableRedraw(True)
return FinalGeo
except:
print "Error"
return None
def hatch_3d():
objs = rs.GetObjects("Select surfaces to hatch",
rs.filter.surface,
select=True)
for obj in objs:
rs.DuplicateSurfaceBorder(obj, type=1)
def borders(self):
""""""
border = rs.DuplicateSurfaceBorder(self.guid, type=1)
curves = rs.ExplodeCurves(border, delete_input=True)
return curves
def hatchFromSrf(srf):
border = rs.DuplicateSurfaceBorder(srf, type=0)
hatch = rs.AddHatches(border, "SOLID")
rs.DeleteObjects(border)
return hatch
