def HorizontalLines():
#Course = rs.OffsetCurve(,bbox[3],sill_remain)
Surf_Height = rs.Distance(bbox[0], bbox[3])
#number of horizontal cources
hori_no = Surf_Height / ipHeight
#convert to intiger
hori_no = int(hori_no)
Course_All = []
Course = rs.AddLine(bbox[0], bbox[1])
Course_start = rs.ExtendCurveLength(Course, 0, 0, ipThick)
Course_end = rs.ExtendCurveLength(Course, 0, 1, ipThick)
Course = rs.JoinCurves((Course_start, Course, Course_end), True)
Course1 = Course
Course_All.append(Course)
for index in range(0, hori_no, 1):
Course = rs.OffsetCurve(Course, bbox[3], ipHeight)
Course_All.append(Course)
Course = rs.OffsetCurve(Course1, bbox[3], Surf_Height)
Course_All.append(Course)
rs.ObjectColor(Course_All, [255, 0, 0])
return Course_All
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 GenStaggeredCourtyardBlock(site_crv, setback, stepbacks, bay_gap, fsr_li,
flr_depth):
bldg_srf_li = []
outer_setback_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0],
setback)
inner_floor_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0],
setback + flr_depth)
req_ht = (rs.CurveArea(site_crv)[0] * fsr_li[0]) / (
rs.CurveArea(outer_setback_crv)[0] - rs.CurveArea(inner_floor_crv)[0])
l = rs.AddLine([0, 0, 0], [0, 0, req_ht])
srf = rs.AddPlanarSrf([outer_setback_crv, inner_floor_crv])
srf2 = rs.ExtrudeSurface(srf, l)
rs.DeleteObject(l)
prev_ht = req_ht
k = 1
for depth in stepbacks:
req_ar = rs.CurveArea(site_crv)[0] * fsr_li[k]
itr_stepback_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0],
setback + depth)
got_ar = rs.CurveArea(itr_stepback_crv)[0] - rs.CurveArea(
inner_floor_crv)[0]
ht = req_ar / got_ar
l = rs.AddLine([0, 0, 0], [0, 0, ht])
srf = rs.AddPlanarSrf([itr_stepback_crv, inner_floor_crv])
srf2 = rs.ExtrudeSurface(srf, l)
rs.MoveObject(srf2, [0, 0, prev_ht])
rs.DeleteObject(l)
rs.DeleteObject(srf)
bldg_srf_li.append(srf2) #
prev_ht += ht
k += 1
def GenStagerredBlock(site_crv, setback, stepbacks, bay_gap, fsr_li,
flr_depths):
bldg_srf_li = []
setback_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0], setback)
ht = fsr_li[0] * rs.CurveArea(site_crv)[0] / rs.CurveArea(setback_crv)[0]
pl_srf0 = rs.AddPlanarSrf(setback_crv)
l = rs.AddLine([0, 0, 0], [0, 0, ht])
ext_srf = rs.ExtrudeSurface(pl_srf0, l)
rs.DeleteObjects([l, pl_srf0])
k = 1
for depth in stepbacks:
stepback_crv = rs.OffsetCurve(setback_crv,
rs.CurveAreaCentroid(site_crv)[0], depth)
ht2 = rs.CurveArea(site_crv)[0] * fsr_li[k] / rs.CurveArea(
stepback_crv)[0]
l = rs.AddLine([0, 0, 0], [0, 0, ht2])
pl_srf = rs.AddPlanarSrf(stepback_crv)
ext_srf = rs.ExtrudeSurface(pl_srf, l)
rs.MoveObject(ext_srf, [0, 0, ht])
bldg_srf_li.append(ext_srf)
rs.DeleteObject(l)
rs.DeleteObject(pl_srf)
ht += ht2
k += 1
def setPlanarBaseSurface(self):
'''
set surface that is planar surface
this surface will be made from additiveObj
this surface will be used in offsetNonPlanarSurface()
'''
explodedSurfaces = rs.ExplodePolysurfaces(self.additiveObj)
editPoint = []
if len(explodedSurfaces) is 0:
meshed = rhino.Geometry.Mesh.CreateFromBrep(
rs.coercebrep(self.additiveObj))
editPoint = rs.MeshVertices(meshed[0])
else:
for i in explodedSurfaces:
meshed = rhino.Geometry.Mesh.CreateFromBrep(rs.coercebrep(i))
vertices = rs.MeshVertices(meshed[0])
editPoint.extend(vertices)
rs.DeleteObjects(explodedSurfaces)
xValues = [i[0] for i in editPoint]
yValues = [i[1] for i in editPoint]
xValues.sort()
yValues.sort()
xMin = xValues[0]
xMax = xValues[-1]
yMin = yValues[0]
yMax = yValues[-1]
lineForSur = []
lineForSur.append(rs.AddLine((xMin, yMin, 0), (xMax, yMin, 0)))
lineForSur.append(rs.AddLine((xMax, yMin, 0), (xMax, yMax, 0)))
lineForSur.append(rs.AddLine((xMax, yMax, 0), (xMin, yMax, 0)))
lineForSur.append(rs.AddLine((xMin, yMax, 0), (xMin, yMin, 0)))
joinedCurve = rs.JoinCurves(lineForSur)
rs.DeleteObjects(lineForSur)
curveForSur = rs.OffsetCurve(joinedCurve, (0, 0, 1), 20)
if len(curveForSur) > 1:
curveForSur = rs.OffsetCurve(joinedCurve, (0, 0, 1), -20)
self.basePlanarSurface = rs.AddPlanarSrf(curveForSur)
rs.DeleteObjects(curveForSur)
if self.basePlanarSurface is None:
return False
return True
def VerticalLines():
start_ll = bbox[0]
end_ll = bbox[3]
#Add first line in the left
surfLeftLine = rs.AddLine(start_ll, end_ll)
VerticalLine_All = []
# Add Vertical line for finger joint
Ver_Line = rs.OffsetCurve(surfLeftLine, -bbox[2], ipThick)
VerticalLine_All.append(Ver_Line)
#Add Second line
Ver_Line = rs.OffsetCurve(Ver_Line, bbox[2], ipThick)
VerticalLine_All.append(Ver_Line)
Window_leftRemain = Window_leftDistance % (ipLength / 2)
#Ver_Line = rs.OffsetCurve(surfLeftLine,bbox[2],Window_leftRemain)
#VerticalLine_All.append(Ver_Line)
vertLeft_no = Window_leftDistance / (ipLength / 2)
vertLeft_no = int(vertLeft_no)
groundLine_distance = rs.Distance(bbox[0], bbox[1])
vert_no = groundLine_distance / (ipLength / 2)
vert_no = int(vert_no)
Vertical = surfLeftLine
for index in range(0, vert_no, 1):
Vertical = rs.OffsetCurve(Vertical, bbox[2], (ipLength / 2))
VerticalLine_All.append(Vertical)
last_finger = rs.AddLine(bbox[1], bbox[2])
VerticalLine_All.append(last_finger)
last_line = rs.OffsetCurve(surfLeftLine, bbox[2],
groundLine_distance + ipThick)
VerticalLine_All.append(last_line)
#Start_sill = rs.CurveStartPoint(window_sillLine[1])
#End_sill = rs.CurveEndPoint(window_sillLine[1])
#sillLine_Distance = rs.Distance(Start_sill,End_sill)
#Sill_Remain = sillLine_Distance % (ipLength/2)
#Sillvert_no = sillLine_Distance / (ipLength/2)
#Sillvert_no = int(vertLeft_no)
rs.DeleteObject(surfLeftLine)
return VerticalLine_All
def get_cut_curve(self):
if self.compensation == 0: return rs.CopyObject(self.nurbs_curve)
offset_distance = self.general_input["cut_diam"] * 0.5
scl_obj = rs.ScaleObject(self.nurbs_curve, self.point, (1.2, 1.2, 1),
True)
offset_points = rs.BoundingBox(scl_obj)
rs.DeleteObject(scl_obj)
offset_point_a = offset_points[0]
offset_point_b = self.point
if not rs.PointInPlanarClosedCurve(self.point, self.nurbs_curve):
offset_point_b = self.find_point_in_curve(self.nurbs_curve)
offset_a = rs.OffsetCurve(self.nurbs_curve, offset_point_a,
offset_distance, None, 2)
offset_b = rs.OffsetCurve(self.nurbs_curve, offset_point_b,
offset_distance, None, 2)
#Revisa si el offset no genero curvas separadas y si es el caso asigna la curva original como offset comparativo
if not offset_a or len(offset_a) != 1:
self.log.append(
"offset error: el cortador no cabe en una de las curvas, se reemplazo con la curva original."
)
if offset_a: rs.DeleteObjects(offset_a)
offset_a = rs.CopyObject(self.nurbs_curve)
if not offset_b or len(offset_b) != 1:
self.log.append(
"offset error: el cortador no cabe en una de las curvas, se reemplazo con la curva original."
)
if offset_b: rs.DeleteObjects(offset_b)
offset_b = rs.CopyObject(self.nurbs_curve)
#Revisa el area para saber cual es el offset interno o externo
if rs.CurveArea(offset_a) < rs.CurveArea(offset_b):
in_offset = offset_a
out_offset = offset_b
else:
in_offset = offset_b
out_offset = offset_a
#Responde dependiendo que compensacion se necesita
if self.compensation == 1:
rs.DeleteObject(in_offset)
return out_offset
elif self.compensation == -1:
rs.DeleteObject(out_offset)
return in_offset
else:
rs.DeleteObject(in_offset)
rs.DeleteObject(out_offset)
return None
def Extend_trim_crv(A, B, thickness):
if mode == "extend":
if rs.CurveLength(A) > rs.CurveLength(B):
B = rs.OffsetCurve(A, rs.CurveMidPoint(B), thickness)
else:
A = rs.OffsetCurve(B, rs.CurveMidPoint(A), thickness)
elif mode == "trim":
if rs.CurveLength(A) > rs.CurveLength(B):
A = rs.OffsetCurve(B, rs.CurveMidPoint(A), thickness)
else:
B = rs.OffsetCurve(A, rs.CurveMidPoint(B), thickness)
return (A, B)
def offsetBothCrvs(crvs, width):
if rs.IsCurveClosed(crvs):
domain = rs.CurveDomain(crvs)
parameter = (domain[0] + domain[1]) / 2.0
rs.CurveSeam(crvs, parameter)
offsets = []
offsets.append(rs.OffsetCurve(crvs, [0, 0, 0], width / 2))
offsets.append(rs.OffsetCurve(crvs, [0, 0, 0], -width / 2))
section = rs.AddLoftSrf(offsets, loft_type=2)
if offsets: rs.DeleteObjects(offsets)
return section
def GenCourtyardBlock(site_crv, setback, flr_depth, bay_gap, fsr):
setback_crv = rs.OffsetCurve(site_crv,
rs.CurveAreaCentroid(site_crv)[0], setback)
inner_crv = rs.OffsetCurve(setback_crv,
rs.CurveAreaCentroid(site_crv)[0], flr_depth)
got_ar = rs.CurveArea(setback_crv)[0] - rs.CurveArea(inner_crv)[0]
req_ar = rs.CurveArea(site_crv)[0] * fsr
ht = req_ar / got_ar
l = rs.AddLine([0, 0, 0], [0, 0, ht])
pl_srf = rs.AddPlanarSrf([setback_crv, inner_crv])
ext_srf = rs.ExtrudeSurface(pl_srf, l) #
rs.DeleteObject(l)
rs.DeleteObject(pl_srf)
def OffsetCurve(self, level_cut):
check_presision = 10
offset_type = 1
branched_curves = []
main_curve = level_cut
offset_distance = self.general_input["cut_diam"] * self.input_data[
"xy_dist"]
curve_1 = rs.OffsetCurve(main_curve,
rs.CurveAreaCentroid(main_curve)[0], -.1,
None, offset_type)
curve_2 = rs.OffsetCurve(main_curve,
rs.CurveAreaCentroid(main_curve)[0], .1, None,
offset_type)
if curve_1 and curve_2:
if len(curve_1) != 1 or len(curve_2) != 1:
rs.DeleteObjects(curve_1)
rs.DeleteObjects(curve_2)
return branched_curves
mini_test = self.getSmall(curve_1, curve_2)
do_points = rs.DivideCurve(mini_test, check_presision, False)
rs.DeleteObjects([curve_1, curve_2])
do_points.append(rs.CurveAreaCentroid(main_curve)[0])
for i in range(0, len(do_points)):
new_offset_curve = rs.OffsetCurve(main_curve, do_points[i],
offset_distance, None,
offset_type)
try:
if self.isCurveNew(branched_curves,
new_offset_curve) and rs.IsCurveClosed(
new_offset_curve) and self.isSmall(
new_offset_curve, main_curve):
branched_curves.append(new_offset_curve)
else:
rs.DeleteObject(new_offset_curve)
except:
if new_offset_curve:
rs.DeleteObjects(new_offset_curve)
for curve in branched_curves:
rs.ObjectColor(curve, color_palette["cut"])
if not branched_curves or len(branched_curves) > 1:
branched_curves.append("sec_plane")
return branched_curves
def right():
spt = rs.CurveStartPoint(curve)
l = rs.OffsetCurve(curve, [-1, 0, 0], plinth_lst[2])
l_p = rs.AddEdgeSrf([curve, l])
guide_curve1 = rs.AddLine(spt, rs.PointAdd(spt, [0, 0, plinth_lst[1]]))
rs.ExtrudeSurface(l_p, guide_curve1)
rs.DeleteObjects([guide_curve1, l])
def left(): #very very computationally heavy. Be patient
spt = rs.CurveStartPoint(ref)
r = rs.OffsetCurve(ref, [1, 0, 0], plinth_lst[2])
r_p = rs.AddEdgeSrf([ref, r])
guide_curve2 = rs.AddLine(spt, rs.PointAdd(spt, [0, 0, plinth_lst[1]]))
rs.ExtrudeSurface(r_p, guide_curve2)
rs.DeleteObjects([guide_curve2, r])
def createAirplane():
#CREATE FUSELAGE
rectangleFuselage = rs.AddRectangle(rs.WorldXYPlane(), Fw, Fh)
endPointsF = rs.PolylineVertices(rectangleFuselage)
fPtsB = offsetPoints(Fpb, endPointsF[0], endPointsF[1])
fPtsR = offsetPoints(Fpr, endPointsF[1], endPointsF[2])
fPtsT = offsetPoints(Fpt, endPointsF[2], endPointsF[3])
fPtsL = offsetPoints(Fpl, endPointsF[3], endPointsF[0])
fPtsL.append(fPtsB[0])
fCurveOpen = rs.AddCurve(fPtsB + fPtsR + fPtsT + fPtsL, 2)
#CREATE WING SLOT
wingSlotStart = rs.VectorAdd(endPointsF[0], (Fwx, Fwy, 0))
wingSlotEnd = rs.VectorAdd(wingSlotStart,
(Fw - Fwx + maxPointOffset * 2, 0, 0))
wingSlot = rs.AddLine(wingSlotStart, wingSlotEnd)
wingSlotOffset = rs.OffsetCurve(wingSlot, (0, 1, 0), 1 / 32)
rs.AddLine(rs.CurveStartPoint(wingSlot),
rs.CurveStartPoint(wingSlotOffset))
#CREATE WING
wPlaneOffY = Wh + 1
wPlaneOffX = Fw / 2
wingPlane = rs.MovePlane(rs.WorldXYPlane(), (wPlaneOffX, -wPlaneOffY, 0))
rectangleWing = rs.AddRectangle(wingPlane, Ww, Wh)
endPointsW = rs.PolylineVertices(rectangleWing)
wPtsB = offsetPoints(Wpb, endPointsW[0], endPointsW[1])
wPtsR = offsetPoints(Wps, endPointsW[1], endPointsW[2])
wPtsT = offsetPoints(Wpt, endPointsW[2], endPointsW[3])
wPtsT.append(endPointsW[3])
wPtsB.insert(0, endPointsW[0])
wingCurve = rs.AddCurve(wPtsB + wPtsR + wPtsT)
#wingLine = rs.AddLine(endPointsW[3],endPointsW[0])
rs.MirrorObject(wingCurve, endPointsW[3], endPointsW[0], True)
#CREATE WING GROOVE
wingGrooveStart = rs.VectorAdd(endPointsW[3], (-1 / 64, maxPointOffset, 0))
wingGrooveEnd = rs.VectorAdd(wingGrooveStart,
(0, -(maxPointOffset + Wh * Wsd), 0))
wingGroove = rs.AddLine(wingGrooveStart, wingGrooveEnd)
wingGrooveOffset = rs.OffsetCurve(wingGroove, (1, 0, 0), -1 / 32)
rs.AddLine(rs.CurveEndPoint(wingGroove),
rs.CurveEndPoint(wingGrooveOffset))
#DELETE RECTANGLES
rs.DeleteObject(rectangleFuselage)
rs.DeleteObject(rectangleWing)
def addWallRhino(corners, thickness, height):
outWallCrv = rs.AddPolyline(corners)
inWallCrv = rs.OffsetCurve(outWallCrv, [0,1,0], thickness, [0,0,1], CurveOffsetCornerStyle.Sharp)
objs = [outWallCrv, inWallCrv]
btmWall = rs.AddPlanarSrf(objs)[0]
extrudeLine = rs.AddLine(corners[0],map(sum, zip(corners[0],[0,0,height])))
allWalls = rs.ExtrudeSurface(btmWall, extrudeLine, True)
rs.DeleteObjects([outWallCrv,inWallCrv,btmWall,extrudeLine])
return allWalls
def offset():
curves = [curve]
offset_curve = rs.OffsetCurve(curve, dir, dist)
curves.append(offset_curve)
curves.append(
rs.AddLine(rs.CurveEndPoint(offset_curve), rs.CurveEndPoint(curve)))
curves.append(
rs.AddLine(rs.CurveStartPoint(offset_curve),
rs.CurveStartPoint(curve)))
rs.JoinCurves(curves, True)
print "Offset created."
def draw_coaming(c):
pts = [[0, 0, 0]]
half = [[(i + 1) * c.spacing, c.points[i], 0]
for i in range(len(c.points))]
pts.extend(half)
pts.append([c.length, 0, 0])
half = [[(i + 1) * c.spacing, -c.points[i], 0]
for i in range(len(c.points))]
half.reverse()
pts.extend(half)
pts.append([0, 0, 0])
crv = rs.AddInterpCurve(pts,
degree=3,
knotstyle=0,
start_tangent=[0, 1, 0],
end_tangent=[0, 1, 0])
strip = [crv, rs.OffsetCurve(crv, [-1, 0, 0], c.width1)]
rs.CopyObjects(strip, [0, c.beam + 2 * c.width1, 0])
strip2 = [rs.CopyObjects(crv), rs.OffsetCurve(crv, [-1, 0, 0], c.width2)]
rs.MoveObjects(strip2, [0, -c.beam - c.width1 - c.width2, 0])
def Volumetria(eixos, dist_e, dist_l, pto):
plAux = rs.CopyObject(eixos, -eZ * (dist_l))
plAux2 = rs.CopyObject(eixos, eZ * (dist_l))
pl1 = rs.OffsetCurve(plAux, pto, dist_e, eZ)
pl1 = rs.coercegeometry(pl1)
pl2 = rs.OffsetCurve(plAux, pto, -dist_e, eZ)
pl2 = rs.coercegeometry(pl2)
pl3 = rs.AddLine(rs.CurveStartPoint(pl1), rs.CurveStartPoint(pl2))
pl4 = rs.AddLine(rs.CurveEndPoint(pl1), rs.CurveEndPoint(pl2))
eixos3D = rs.AddPlanarSrf((pl1, pl3, pl2, pl4))
lin = rs.AddLine(rs.CurveStartPoint(plAux), rs.CurveStartPoint(plAux2))
eixos3D = rs.ExtrudeSurface(eixos3D, lin, True)
eixos3D = rs.coercegeometry(eixos3D)
return eixos3D
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 basiclines(basicpoint, lengthunit, angle, offsetvalue, topbplineheight,
multiple1, multiple2, multiple3):
#
#建立初始母线
bpoint0 = (basicpoint[0], basicpoint[1], basicpoint[2])
#初始定位点
bpoits = [] #
bpoits.append(bpoint0)
bpoint1 = (bpoint0[0] + multiple1 * lengthunit, bpoint0[1], bpoint0[2])
#根据初始定位点坐标计算第一个折线点的坐标
bpoints.append(bpoint1)
hypotenuse = multiple2 * lengthunit #计算第二段折线长度基础值
bpoint2 = (bpoint1[0], hypotenuse * math.sin(angle),
bpoint1[1] + hypotenuse * math.cos(angle))
#第二个折线点的坐标
bpoints.append(bpoint2)
bpoint3 = (bpoint2[0] + multiple3 * lengthunit, bpoint2[1], bpoint2[2])
#
bpoints.append(bpoint3)
bpline0 = rs.AddPolyline(bpoints)
bplines = [] #z方向上确定每一层母线
bplines.append(bpline0)
for i in range(1, 4):
dividecurvelength = rs.CopyObject(bpline0, [0, 0, 5 * i])
bplines.append(dividecurvelength)
offsetbplines = [] #每层母线offset
for j in bplines:
offsetbpline = rs.OffsetCurve(j, [0, 0, 0], offsetvalue)
offsetbplines.append(offsetbpline)
#屋脊结构线
topbplinecenter = rs.OffsetCurve(bplines[-1], [0, 0, 0],
offsetvalue / 2) #用于屋脊水平方向折线的基础线
topbpline = rs.CopyObject(topbplinecenter,
[0, 0, topbplineheight]) #根据新的坐标点复制屋脊水平方向折线的基础线
rs.DeleteObject(topbplinecenter)
return bplines, offsetbplines, topbpline #各层结构母线，水平结构线，屋脊结构线
def curvy_stairs(curve, start_pt, end_pt, stair_width, steps, plinth_lst,
bannister_lst):
ref = rs.OffsetCurve(
curve, [1, 0, 0],
stair_width) # create the second curve to guide the stair
ref_pts = [n * 1 / steps for n in range(steps + 1)
] # guide points to divide up the curve
left_pts = [rs.EvaluateCurve(curve, t)
for t in ref_pts] # guide points on input curve
right_pts = [rs.EvaluateCurve(ref, t)
for t in ref_pts] #guide points on the offset curve
height = end_pt[2] - start_pt[2] #stair height
rise = [0, 0, height / steps] # a vector
for i in range(steps):
#draw rise
v_ver = [
left_pts[i], right_pts[i],
rs.PointAdd(right_pts[i], rise),
rs.PointAdd(left_pts[i], rise)
]
rs.AddSrfPt(v_ver)
#draw run
v_hori = [v_ver[3], v_ver[2], right_pts[i + 1], left_pts[i + 1]]
rs.AddSrfPt(v_hori)
#draw sides
s1 = rs.AddLine(left_pts[i], rs.PointAdd(left_pts[i], rise))
s2 = rs.AddLine(rs.PointAdd(left_pts[i], rise), left_pts[i + 1])
s3 = rs.AddSubCrv(curve, rs.CurveClosestPoint(curve, left_pts[i]),
rs.CurveClosestPoint(curve, left_pts[i + 1]))
rs.AddEdgeSrf([s1, s2, s3])
rs.DeleteObjects([s1, s2, s3])
s1 = rs.AddLine(right_pts[i], rs.PointAdd(right_pts[i], rise))
s2 = rs.AddLine(rs.PointAdd(right_pts[i], rise), right_pts[i + 1])
s3 = rs.AddSubCrv(ref, rs.CurveClosestPoint(ref, right_pts[i]),
rs.CurveClosestPoint(ref, right_pts[i + 1]))
rs.AddEdgeSrf([s1, s2, s3])
rs.DeleteObjects([s1, s2, s3])
s1 = rs.AddLine(left_pts[0], right_pts[0])
s2 = rs.AddLine(left_pts[-1], right_pts[-1])
rs.AddEdgeSrf([s1, curve, s2, ref])
rs.DeleteObjects([s1, s2])
if plinth_lst[0]:
curvy_plinth(curve, ref, stair_width, plinth_lst)
if bannister_lst[0]:
curvy_bannister(curve, ref, stair_width, bannister_lst)
def Offset_total():
off_dist = rs.GetReal("Enter distance of offsets", 2.5)
off_dist = abs(off_dist)
curve_sel = rs.GetObject("Select curve")
off_direct = Offset_Direction(curve_sel)
#off_direct=rs.GetPoint("Pick point")
new_curve = rs.OffsetCurve(curve_sel, off_direct, off_dist)
#get curve area for safety break if offset goes outside (it would be infinite)
if rs.IsCurveClosed(curve_sel):
curve_sel_area = rs.CurveArea(curve_sel)
print(curve_sel_area)
new_curve_area = rs.CurveArea(new_curve)
print(new_curve_area)
i = 0
# while curve_sel_area > new_curve_area and new_curve !=None:
while i < 20:
print "iterating"
curve_sel = new_curve
print curve_sel, off_direct, off_dist
new_curve = rs.OffsetCurve(curve_sel, off_direct, off_dist)
if new_curve is None:
print "Is none"
break
if rs.IsCurve(new_curve):
if len(new_curve) > 1:
print ">1"
rs.DeleteObjects(new_curve)
break
else:
print "It is not curve anymore"
break
i = i + 1
def wallBaseSrf(crv, width):
rs.SimplifyCurve(crv)
if rs.IsCurveClosed(crv):
domain = rs.CurveDomain(crv)
parameter = (domain[0] + domain[1]) / 2.0
rs.CurveSeam(crv, parameter)
offsets = map(lambda x: rs.OffsetCurve(crv, [0, 0, 0], x),
[width / 2, -width / 2])
section = rs.AddLoftSrf(offsets, loft_type=2)
if offsets: rs.DeleteObjects(offsets)
if rs.IsPolysurface(section):
return rs.ExplodePolysurfaces(section, delete_input=True)
return section
def createSupPt(origin, nCores, nFloors, rad1, rad2, hP, ang):
for i in range((nCores * nFloors) + 1):
ptO = rs.PointAdd(origin, (0, 0, hP * i / nCores))
pt1 = rs.Polar(ptO, (360 * i / nCores), rad1)
pt1AuxA = rs.Polar(ptO, (360 * i / nCores) + ang, rad1)
pt1AuxB = rs.Polar(ptO, (360 * i / nCores) - ang, rad1)
pt2 = rs.Polar(ptO, (360 * i / nCores), rad2)
pt2AuxA = rs.Polar(ptO, (360 * i / nCores) + ang, rad2)
pt2AuxB = rs.Polar(ptO, (360 * i / nCores) - ang, rad2)
#pExt.append(pt1)
pExt.Add(pt1, g.Kernel.Data.GH_Path(i // nCores))
auxExtPts.extend([pt1AuxA, pt1AuxB])
arc1 = rs.AddArc3Pt(pt1AuxA, pt1AuxB, pt1)
#arc drawing pedestrian path in core area
arcPed.Add(
rs.OffsetCurve(arc1, origin, pedOff)[0],
g.Kernel.Data.GH_Path(i // nCores))
arcPark.Add(
rs.OffsetCurve(arc1, origin, pedOff + parkOff)[0],
g.Kernel.Data.GH_Path(i // nCores))
#extArcs.append(arc1)
extArcs.Add(arc1, g.Kernel.Data.GH_Path(i // nCores))
#pInt.append(pt2)
pInt.Add(pt2, g.Kernel.Data.GH_Path(i // nCores))
auxIntPts.extend([pt2AuxA, pt2AuxB])
arc2 = rs.AddArc3Pt(pt2AuxA, pt2AuxB, pt2)
#intArcs.append(arc2)
intArcs.Add(arc2, g.Kernel.Data.GH_Path(i // nCores))
pSupExt.AddRange([pt1AuxA, pt1AuxB, pt2AuxA, pt2AuxB],
g.Kernel.Data.GH_Path(i // nCores))
def inset_rhino_surface(_srfc, _inset_dist=0.001, _srfc_name=""):
""" Insets/shrinks a Rhino Brep some dimension
Arg:
_srfc: A Rhino Brep
_inset_dist: float: Default=0.001m
_srfc_name: str: The name of the surface, used for error messages
Returns:
new_srfc: A new Rhino surface, shrunk/inset by the specified amount
"""
#-----------------------------------------------------------------------
# Get all the surface params needed
srfc_Center = ghc.Area(_srfc).centroid
srfc_normal_vector = brep_avg_surface_normal(_srfc)
srfc_edges = ghc.DeconstructBrep(_srfc).edges
srfc_perimeter = ghc.JoinCurves(srfc_edges, False)
#-----------------------------------------------------------------------
# Try to inset the perimeter Curve
inset_curve = rs.OffsetCurve(srfc_perimeter, srfc_Center, _inset_dist, srfc_normal_vector, 0)
#-----------------------------------------------------------------------
# In case the new curve goes 'out' and the offset fails
# Or is too small and results in multiple offset Curves
if len(inset_curve)>1:
warning = 'Error. The surface: "{}" is too small. The offset of {} m"\
"can not be done. Check the offset size?'.format(_srfc_name, _inset_dist)
print(warning)
inset_curve = rs.OffsetCurve(srfc_perimeter, srfc_Center, 0.001, srfc_normal_vector, 0)
inset_curve = rs.coercecurve( inset_curve[0] )
else:
inset_curve = rs.coercecurve( inset_curve[0] )
new_srfc = ghc.BoundarySurfaces(inset_curve)
return new_srfc
def Previewwall(dict, index, crvs, zoommode):# 壁を作る # get_adjustの中身で処理を決める if dict[index][2] == 1: A = crvs[dict[index][0]] B = rs.OffsetCurve(crvs[dict[index][0]], rs.CurveMidPoint(crvs[dict[index][1]]), dict[index][3]) elif dict[index][2] == 2: A = rs.OffsetCurve(crvs[dict[index][1]], rs.CurveMidPoint(crvs[dict[index][0]]), dict[index][3]) B = crvs[dict[index][1]] elif dict[index][2] == 3: A = rs.OffsetCurve(crvs[dict[index][1]], rs.CurveMidPoint(crvs[dict[index][0]]), dict[index][3]) B = crvs[dict[index][1]] elif dict[index][2] == 4: A = crvs[dict[index][0]] B = rs.OffsetCurve(crvs[dict[index][0]], rs.CurveMidPoint(crvs[dict[index][1]]), dict[index][3]) obj_srf = rs.AddLoftSrf([A, B]) obj_height = rs.AddLine((0,0,0), (0,0,dict[index][4])) obj_wall = rs.ExtrudeSurface(obj_srf, obj_height) if zoommode:# 壁と曲線で箱を作り、箱をズーム obj_zoom = rs.BoundingBox([obj_wall, crvs[dict[index][0]], crvs[dict[index][1]]]) rs.ZoomBoundingBox(obj_zoom) return obj_wall
def MultiOffset():
try:
obj = rs.GetObjects('Select Closed Curves for Offset', preselect=True)
bool = rs.GetBoolean('Offset Direction',
('Direction', 'Inward', 'Outward'), (False))
if bool:
bool = bool[0]
offset = rs.GetReal('Distance to Offset')
for i in obj:
if rs.IsCurveClosed(i):
if bool == False:
pt = rs.CurveAreaCentroid(i)
pt = pt[0]
rs.OffsetCurve(i, pt, offset)
if bool == True:
pt = [1000000, 1000000, 1000000]
rs.OffsetCurve(i, pt, offset)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
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 offsetRow(self, edge, vec, width):
"""
Offset a row depending on the type of width and direction.
need to use self.edges
:return:
"""
# print("edge", rs.CurveLength(edge))
# print("vec", vec)
# print("width", width)
newRow = rs.OffsetCurve(edge, vec, width)
# Magic number
# print("newRow", newRow)
# print("newRowCurve", rs.CurveLength(newRow))
rs.ScaleObject(newRow, rs.CurveMidPoint(newRow), [20, 20, 0])
# print("ScaleNewRowCurve", rs.CurveLength(newRow))
# Problem Below!!
param = []
for e in self.edges:
intersect = rs.CurveCurveIntersection(newRow, e)
# Follows the Rhino api
if intersect is not None:
param.append(intersect[0][5])
# print("param", param)
if param[0] < param[1]:
newRow = rs.TrimCurve(newRow, [param[0], param[1]])
elif param[0] > param[1]:
newRow = rs.TrimCurve(newRow, [param[1], param[0]])
else:
# only one intersection, it's time to stop
newRow = None
# newRow = rs.TrimCurve(newRow, [param[0], param[1]])
# print("TrimNewRowCurve", rs.CurveLength(newRow))
return newRow
#Add pipes
pipe = rs.AddPipe(A_lines, 0, radius_pipes, blend_type=0, cap=1, fit=False)
#Append each pipe to Legs
Legs.append(pipe)
#rs.DeleteObjects([A_lines, Poly_base, Poly_top])
#Create group
rs.AddGroup("Legs")
rs.AddObjectsToGroup(Legs, "Legs")
#Construct the table top, draw offset curve
offset_crv = rs.OffsetCurve(Poly_top,
Cen_top,
-(offset_dist),
normal=None,
style=1)
rs.CurrentLayer("Tabletop")
#extrude Offset Curve
extruded_crv = rs.ExtrudeCurve(offset_crv, extrude_path)
#cap Extruded shape
closed_polysrf = rs.CapPlanarHoles(extruded_crv)
#Delete objects
erase = [A_lines, Poly_base, Poly_top, offset_crv]
rs.DeleteObjects(erase)
#Redraw geometry
