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