def EndingCap(stuff1, stuff2): plyu = ChainLink(stuff1[0][0], stuff1[0][1]) plyd = ChainLink(stuff1[1][0], stuff1[1][1]) #a = Pts2List(plyu) #b = Pts2List(plyd) a = PurgePoly(plyu) b = PurgePoly(plyd) #polu = Rhino.Geometry.Polyline(a) #pold = Rhino.Geometry.Polyline(b) polu = rs.AddPolyline(a) pold = rs.AddPolyline(b) up = rs.AddPlanarSrf([polu]) down = rs.AddPlanarSrf([pold]) #rs.AddPoints([stuff2[0][0][len(stuff2[0][0])-1],stuff1[0][0][0],stuff1[0][1][0],stuff2[0][1][len(stuff2[0][1])-1]]) #rs.AddPoints([stuff2[1][0][len(stuff2[1][0])-1],stuff1[1][0][0],stuff1[1][1][0],stuff2[1][1][len(stuff2[1][1])-1]]) uplink = rs.AddSrfPt([ stuff2[0][0][len(stuff2[0][0]) - 1], stuff1[0][0][0], stuff1[0][1][0], stuff2[0][1][len(stuff2[0][1]) - 1] ]) downlink = rs.AddSrfPt([ stuff2[1][0][len(stuff2[1][0]) - 1], stuff1[1][0][0], stuff1[1][1][0], stuff2[1][1][len(stuff2[1][1]) - 1] ]) rs.DeleteObjects([polu, pold]) return [[uplink, up[0]], [downlink, down[0]]]
def recSplit(self, iniPts, counter=0): p=iniPts vertical=False if(rs.Distance(p[0],p[1])>rs.Distance(p[0],p[3])): vertical=True if(vertical==True): p0,p1=self.verSplit(iniPts) else: p0,p1=self.horSplit(iniPts) poly0=rs.AddPolyline(p0) poly1=rs.AddPolyline(p1) counter+=1 if(counter<3): pts0=self.getIntxCrv(poly0) pts1=self.getIntxCrv(poly1) rs.DeleteObjects([poly0,poly1]) self.recSplit(pts0,counter) self.recSplit(pts1,counter) else: intxCrv0=rs.CurveBooleanIntersection(self.SITECRV,poly0) intxCrv1=rs.CurveBooleanIntersection(self.SITECRV,poly1) for i in intxCrv0: self.FPOLY.append(i) for i in intxCrv1: self.FPOLY.append(i) rs.DeleteObjects([poly0,poly1]) rs.DeleteObject(self.crv)
def CockpitWindowContours(Height=1.620, Depth=5): P1 = [0.000, 0.076, Height - 1.620 + 2.194] P2 = [0.000, 0.852, Height - 1.620 + 2.290] P3 = [0.000, 0.904, Height + 0.037] P4 = [0.000, 0.076, Height] CWC1 = rs.AddPolyline([P1, P2, P3, P4, P1]) rs.SelectObject(CWC1) rs.Command("_FilletCorners 0.08 ") P1 = [0.000, 0.951, Height - 1.620 + 2.289] P2 = [0.000, 1.343, Height - 1.620 + 2.224] P3 = [0.000, 1.634, Height - 1.620 + 1.773] P4 = [0.000, 1.557, Height - 1.620 + 1.588] P5 = [0.000, 1.027, Height - 1.620 + 1.671] CWC2 = rs.AddPolyline([P1, P2, P3, P4, P5, P1]) rs.SelectObject(CWC2) rs.Command("_FilletCorners 0.08 ") CWC3 = act.MirrorObjectXZ(CWC1) CWC4 = act.MirrorObjectXZ(CWC2) ExtPathId = rs.AddLine([0, 0, 0], [Depth, 0, 0]) CWC1s = rs.ExtrudeCurve(CWC1, ExtPathId) CWC2s = rs.ExtrudeCurve(CWC2, ExtPathId) CWC3s = rs.ExtrudeCurve(CWC3, ExtPathId) CWC4s = rs.ExtrudeCurve(CWC4, ExtPathId) rs.DeleteObjects([CWC1, CWC2, CWC3, CWC4, ExtPathId]) return CWC1s, CWC2s, CWC3s, CWC4s
def EltCap(stuff1, stuff2): plyu = ChainLink(stuff1[0][0], stuff1[0][1]) plyd = ChainLink(stuff1[1][0], stuff1[1][1]) a = PurgePoly(plyu) b = PurgePoly(plyd) polu = rs.AddPolyline(a) pold = rs.AddPolyline(b) up = rs.AddPlanarSrf([polu]) down = rs.AddPlanarSrf([pold]) uptransition = [ stuff2[0][0][len(stuff2[0][0]) - 1], stuff1[0][0][0], stuff1[0][1][0], stuff2[0][1][len(stuff2[0][1]) - 1] ] dntransition = [ stuff2[1][0][len(stuff2[1][0]) - 1], stuff1[1][0][0], stuff1[1][1][0], stuff2[1][1][len(stuff2[1][1]) - 1] ] #rs.AddPoints(uptransition) #rs.AddPoints(dntransition) uplink = rs.AddSrfPt(uptransition) downlink = rs.AddSrfPt(dntransition) rs.DeleteObjects([polu, pold]) return [[uplink, up[0]], [downlink, down[0]]]
def genHalfPlanes(site_crv, int_crv): B = rs.BoundingBox(site_crv) polyBB = rs.AddPolyline([B[0], B[1], B[2], B[3], B[0]]) diagB = 2 * rs.Distance(B[0], B[2]) rays = [] int_pts = rs.CurvePoints(int_crv) bsp_tree = [] bsp_tree.append(site_crv) for i in range(len(int_pts) - 1): a = int_pts[i] b = int_pts[i + 1] m = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, 0] p = [ m[0] + (a[0] - m[0]) * diagB / (rs.Distance(a, m)), m[1] + (a[1] - m[1]) * diagB / (rs.Distance(a, m)), 0 ] q = [ m[0] + (b[0] - m[0]) * diagB / (rs.Distance(b, m)), m[1] + (b[1] - m[1]) * diagB / (rs.Distance(b, m)), 0 ] u = [q[0] - p[0], q[1] - p[1], 0] v = [-u[1], u[0], 0] r = [p[0] + v[0], p[1] + v[1], 0] s = [q[0] + v[0], q[1] + v[1], 0] w = [u[1], -u[0], 0] R = [p[0] + w[0], p[1] + w[1], 0] S = [q[0] + w[0], q[1] + w[1], 0] polyA = rs.AddPolyline([p, q, s, r, p]) polyB = rs.AddPolyline([p, q, S, R, p]) used_crv = [] new_crv = [] for bsp_crv in bsp_tree: sum = 0 try: crvA = rs.CurveBooleanIntersection(bsp_crv, polyA) new_crv.append(crvA) sum += 1 except: pass try: crvB = rs.CurveBooleanIntersection(bsp_crv, polyB) new_crv.append(crvB) sum += 1 except: pass if (sum > 0): used_crv.append(bsp_crv) for crv in new_crv: bsp_tree.append(crv) for crv in used_crv: bsp_tree.remove(crv) rs.DeleteObject(crv) rs.DeleteObject(polyA) rs.DeleteObject(polyB) rs.DeleteObject(polyBB) return bsp_tree
def create_pipe(self, point_n, point_p): outer_point_n = self.create_scaled_point(point_n, self.PIPE_SCALAR) outer_point_p = self.create_scaled_point(point_p, self.PIPE_SCALAR) inner_point_n = self.create_scaled_point(point_n, self.INNER_PIPE_SCALAR) inner_point_p = self.create_scaled_point(point_p, self.INNER_PIPE_SCALAR) opl = rs.AddPolyline([outer_point_p, self.middle_point, outer_point_n]) ipl = rs.AddPolyline([inner_point_p, self.middle_point, inner_point_n]) o_pipe = rs.AddPipe(opl, 0, self.CIRCLE_WIDTH, 1, 1) i_pipe = rs.AddPipe(ipl, 0, self.CIRCLE_INNER_WIDTH, 1, 1) return rs.BooleanUnion([o_pipe, i_pipe])
def genFuncObj_Site(self): s = site_obj(self.site) pts = s.getPts() s.displayPts() poly_list = [] for i in self.req_obj: for j in range(i.getNumber()): obj = i T = False k = 0 this_gen_poly = None while (T == False and k < 50): x = random.randint(1, len(pts) - 2) p = pts[x - 1] q = pts[x] r = pts[x + 1] poly = obj.getConfig1(p, q, r) sum = 0 if (poly is not None and len(poly) > 0): sum = 0 if (poly_list and len(poly_list) > 0): for m in poly_list: polyY = rs.AddPolyline(m) G = self.checkPoly(poly, polyY) rs.DeleteObject(polyY) if (G == False): sum += 1 break if (sum == 0): T = True if (poly not in poly_list): this_gen_poly = poly poly_list.append(poly) elif (poly is not None and len(poly) > 0): if (poly not in poly_list): this_gen_poly = poly poly_list.append(poly) k += 1 if (this_gen_poly is not None): i.setGenPoly(rs.AddPolyline(this_gen_poly)) for i in self.req_obj: poly = i.getGenPoly() num_flrs = i.getNumFloors() num_crvs = len(i.getGenPoly()) fin_num_flrs = int(num_flrs / num_crvs) i.setNumFloors(fin_num_flrs) for j in poly: i.genIntPoly(j) npoly = i.getReqPoly() for k in range(fin_num_flrs): rs.CopyObjects(npoly, [0, 0, 4 * k]) pass
def subd(pol, ratio): pts = rs.PolylineVertices(pol) vec = rs.VectorCreate(pts[2], pts[1]) vec = rs.VectorScale(vec, ratio) midPt = rs.VectorAdd(pts[1], vec) pts1 = [pts[0], pts[1], midPt, pts[0]] pts2 = [pts[0], midPt, pts[2], pts[0]] triangle1 = rs.AddPolyline(pts1) triangle2 = rs.AddPolyline(pts2)
def StartCap(stuff): plyu = [stuff[0][0][0],stuff[0][0][1],stuff[0][1][1],stuff[0][1][0]] plyd = [stuff[1][0][0],stuff[1][0][1],stuff[1][1][1],stuff[1][1][0]] polu = rs.AddPolyline(plyu) pold = rs.AddPolyline(plyd) up = rs.AddPlanarSrf([polu]) down = rs.AddPlanarSrf([pold]) rs.DeleteObjects([polu,pold]) return [[up[0]],[down[0]]]
def geodesiccurve(): surface_id = rs.GetObject("Select surface for geodesic curve solution", 8, True, True) if not surface_id: return vertices = getr2pathonsurface(surface_id, 10, "Start of geodesic curve", "End of geodesic curve") if not vertices: return tolerance = rs.UnitAbsoluteTolerance() / 10 length = 1e300 newlength = 0.0 while True: print("Solving geodesic fit for %d samples" % len(vertices)) vertices = geodesicfit(vertices, surface_id, tolerance) newlength = polylinelength(vertices) if abs(newlength - length) < tolerance: break if len(vertices) > 1000: break vertices = subdividepolyline(vertices) length = newlength rs.AddPolyline(vertices) print "Geodesic curve added with length: ", newlength
def addJoin(lns, nJoins, xThick, yThick): joins = [] joins_3 = [] points = rs.DivideCurve(lns, nJoins) lenP = len(points) for i in range(lenP): joins.append(rs.AddPoint(points[i])) joins_2 = rs.CopyObjects(joins, [xThick, yThick, 0]) joins_2.remove(joins_2[0]) joins_2.append([0, 0, 0]) for j in range(0, len(joins), 2): c = j + 2 addList(joins, joins_2, joins_3, j, c) joins_3.remove(joins_3[len(joins_3) - 1]) joins_3.remove(joins_3[len(joins_3) - 1]) joined = rs.AddPolyline(joins_3) rs.DeleteObject(lns) return joined
def drawEvaluateValue(list_evaluate): frame = 5000 original_point = 5000 step_x_axis = 100 plane = rs.WorldXYPlane() xform = rs.XformTranslation([0, 5000, 0]) plane1 = rs.PlaneTransform(plane, xform) rs.AddRectangle(plane1, frame, frame) evaluate_sum = [] for i in range(len(list_evaluate)): evaluate_sum.append(sum(list_evaluate[i])) max_value = max(evaluate_sum) min_value = min(evaluate_sum) # if 1000 > max_value > 100: # # if 10000 > max_value >= 1000: point_list = [] for i in range(len(evaluate_sum)): value = evaluate_sum[i] # print("evaluate_sum", evaluate_sum[i]) new_value = remap(value, max_value, 0, 5000, 0) # print("new_value", new_value) pt = rs.AddPoint(i * step_x_axis, original_point + new_value, 0) point_list.append(pt) rs.AddPolyline(point_list)
def get_dist(pt,poly): # find closest point on axis curve param = rs.CurveClosestPoint(axis, pt) # get plane perpendicular to curve ck,pl = axis.PerpendicularFrameAt(param) # part responsible for flat end caps # if distance from point to plane is bigger than 0, # return that distance pp = rs.PlaneClosestPoint(pl,pt) d2 = rs.Distance(pt,pp) if d2>0.01: return d2 # else change the basis of the polygon from world xy # to that plane to check for distance and inside/outside pm = (param-axis.Domain[0])/(axis.Domain[1]-axis.Domain[0]) wxy = rs.WorldXYPlane() tf = rg.Transform.PlaneToPlane(wxy,pl) ang = sa + pm*(ea-sa) tr = rg.Transform.Rotation(ang, pl.Normal, pl.Origin) tpts = rs.CurvePoints(poly) for p in tpts: p.Transform(tf) p.Transform(tr) ply = rs.AddPolyline(tpts) prm = rs.CurveClosestPoint(ply,pt) cp = rs.EvaluateCurve(ply,prm) d = rs.Distance(pt,cp) # if the point is inside the curve, reverse the distance bln = rs.PointInPlanarClosedCurve(pt,ply,pl) if bln: d *= -1 return d
def get_pocket_entry(self, z_level, translation, pocket_list): revised_list = [] last_obj = None for obj in pocket_list: if obj != "sec_plane": revised_list.append(rs.CopyObject(obj, translation)) else: if last_obj != obj: revised_list.append(obj) last_obj = obj pocket_list = revised_list for i in range(0, len(pocket_list)): crv = pocket_list[i] if crv == "sec_plane": #Cambio intermedio pep = rs.CurveEndPoint(pocket_list[i - 1]) try: nsp = rs.CurveStartPoint(pocket_list[i + 1]) except: npt = rs.CurveStartPoint(self.cut_curve) nsp = (npt[0], npt[1], z_level) points = [ rs.CurveEndPoint(pocket_list[i - 1]), (pep[0], pep[1], self.general_input["sec_plane"]), (nsp[0], nsp[1], self.general_input["sec_plane"]), nsp ] travel_line = rs.AddPolyline(points) rs.ObjectColor(travel_line, color_palette["cut"]) pocket_list[i] = travel_line return pocket_list
def wave_line(values, r, in_d): ### interpolation dist # inter_dist = 4 * 0.5 inter_dist = in_d for i in xrange(len(values)): tmp_pt = rs.AddPoint(values[i], i * r, 0) tmp_pt_m = rs.MirrorObject(tmp_pt, (0, 0, 0), (0, 10, 0), True) # zigzag if i % 2 == 0: tmp_pt_0 = rs.CopyObject(tmp_pt) tmp_pt_0 = rs.MoveObject(tmp_pt_0, (0, -1 * (inter_dist), 0)) tmp_pt_1 = rs.CopyObject(tmp_pt) tmp_pt_1 = rs.MoveObject(tmp_pt_1, (0, 1 * (inter_dist), 0)) zigzag.append(tmp_pt_0) zigzag.append(tmp_pt_1) else: tmp_pt_0 = rs.CopyObject(tmp_pt_m) tmp_pt_0 = rs.MoveObject(tmp_pt_0, (0, -1 * (inter_dist), 0)) tmp_pt_1 = rs.CopyObject(tmp_pt_m) tmp_pt_1 = rs.MoveObject(tmp_pt_1, (0, 1 * (inter_dist), 0)) zigzag.append(tmp_pt_0) zigzag.append(tmp_pt_1) tmp_polyline = rs.AddPolyline(zigzag) return zigzag, tmp_polyline
def tool_visualization(origin_coords, mesh, planes, i): """ Visualize example tool motion. """ i = min(i, len(planes) - 1) # make sure i doesn't go beyond available number of planes passed_path = None assert planes[0], 'The planes you have provided are invalid.' origin = [ float(origin_coords[0]), float(origin_coords[1]), float(origin_coords[2]) ] o = rg.Point3d(origin[0], origin[1], origin[2]) x = rg.Vector3d(1, 0, 0) y = rg.Vector3d(0, -1, 0) # z = rg.Vector3d(0, 0, -1) ee_frame = rg.Plane(o, x, y) target_frame = planes[i] T = rg.Transform.PlaneToPlane(ee_frame, target_frame) mesh = rs.TransformObject(rs.CopyObject(mesh), T) passed_path = rs.AddPolyline([plane.Origin for plane in planes[:i + 1]]) return mesh, passed_path
def taxicab_midnormal(Point_1=P3(0, 0, 0), Point_2=P3(0, 0, 0), leng=10000): dx = abs(Point_1.X - Point_2.X) dy = abs(Point_1.Y - Point_2.Y) C = P3((Point_1.X + Point_2.X) / 2, (Point_1.Y + Point_2.Y) / 2, (Point_1.Z + Point_2.Z) / 2) """ MPQN, in which M is on the lengeft(X-) or bottom(Y-) """ P = P3(0, 0, C.Z) Q = P3(0, 0, C.Z) M = P3(0, 0, C.Z) N = P3(0, 0, C.Z) if dx > dy: P.Y = C.Y + dy / 2 Q.Y = C.Y - dy / 2 M.Y = P.Y + leng N.Y = Q.Y - leng if bool(Point_1.Y > Point_2.Y) ^ bool(Point_1.X > Point_2.X): P.X = C.X + dy / 2 Q.X = C.X - dy / 2 else: P.X = C.X - dy / 2 Q.X = C.X + dy / 2 M.X = P.X N.X = Q.X else: if dx < dy: P.X = C.X + dx / 2 Q.X = C.X - dx / 2 M.X = P.X + leng N.X = Q.X - leng if bool(Point_1.Y > Point_2.Y) ^ bool(Point_1.X > Point_2.X): P.Y = C.Y + dx / 2 Q.Y = C.Y - dx / 2 else: P.Y = C.Y - dx / 2 Q.Y = C.Y + dx / 2 M.Y = P.Y N.Y = Q.Y else: if bool(Point_1.Y > Point_2.Y) ^ bool(Point_1.X > Point_2.X): P.Y = C.Y - dx / 2 Q.Y = C.Y + dx / 2 P.X = C.X - dy / 2 Q.X = C.X + dy / 2 M.Y = P.Y - leng M.X = P.X - leng N.Y = Q.Y + leng N.X = Q.X + leng else: P.Y = C.Y - dx / 2 Q.Y = C.Y + dx / 2 P.X = C.X + dy / 2 Q.X = C.X - dy / 2 M.Y = P.Y - leng M.X = P.X + leng N.Y = Q.Y + leng N.X = Q.X - leng return rs.AddPolyline([M, P, Q, N])
def SaveNClean(defject, vertices, i, content): #save all there is to run from current iteration and clean up proper rs.Command("_SelNone") rs.Command("_SelPolysrf") index = i if index < 10: j = "0" + str(index) if index >= 10: j = index #Quite probably there is a purely scripted way of writing the export now #It would be through the Rhino and scriptcontext rs.Command("_-Export C:\R3\OffCenter\Walk\Temp\proto2o" + j + ".igs ENTER") rs.DeleteObject(defject) for vrtx in vertices: rs.AddPolyline(vrtx) #Again rs.Command("-saveas C:\\R3\OffCenter\Walk\Temp\sth" + j + ".3dm") objects = rs.AllObjects() rs.DeleteObjects(objects) #need a place to write our polies to!!! History.WritePolies(tempfolder + "\polies" + j + ".txt", content)
def drawRect( side, location, angle_degrees ): """画一个2D方块 参数: side(double): 方块的长度, double locaiton(tuple(double, double,double)): 方块中心的位置 angle_degrees(double): 旋转角度degree Returns: guid """ p0 = (-side/2,-side/2,0) p1 = (side/2,-side/2,0) p2 = (side/2,side/2,0) p3 = (-side/2,side/2,0) obj = rs.AddPolyline([p0,p1,p2,p3,p0]) xform = rs.XformRotation2(angle_degrees, (0,0,1), (0,0,0)) obj = rs.TransformObject( obj, xform, False ) xform = rs.XformTranslation( location) obj = rs.TransformObject( obj, xform, False ) return obj
def drawTriTab(self, net): holeRadius = net.holeRadius mesh = net.mesh flatVerts = net.flatVerts flatFaces = net.flatFaces minArea = (holeRadius**2.0) * math.pi * 30 # print "minArea: " + str(minArea) flatFace = self.getConnectToFace(flatFaces, mesh) area = flatFace.getArea(flatVerts) pntA, pntC = self.get_coordinates(island) pntB = self.tabFaceCenter points = [pntA, pntB, pntC] polyline = Rhino.Geometry.PolylineCurve([pntA, pntB, pntC, pntA]) props = Rhino.Geometry.AreaMassProperties.Compute(polyline) if area > minArea: centerPnt = props.Centroid else: rs.AddTextDot("o", pntB) centerPnt = flatFaces[self.fromFace].getCenterPoint( flatVerts, True) hole = rs.AddCircle(centerPnt, holeRadius) polyGuid = rs.AddPolyline(points) self.geom.append(polyGuid) self.geom.append(hole) return polyGuid
def create_end_caps(self, corners, vector): srf = rs.AddPolyline( [corners[0], corners[1], corners[2], corners[3], corners[0]]) curve = rs.AddCurve( [corners[0], rs.PointAdd(corners[0], rs.VectorScale(vector, 3))]) return rs.AddSweep1(curve, [srf])
def drawQuadTab(self, island): pntA, pntD = self.get_coordinates(island) vecA = geom.Vector3d(pntA) vecD = geom.Vector3d(pntD) alpha = self.tabAngles[0] beta = self.tabAngles[1] lenI = self.tabWidth / math.sin(alpha * math.pi / 180.0) lenJ = self.tabWidth / math.sin(beta * math.pi / 180.0) if not self.tabOnLeft: alpha = -1 * alpha beta = -1 * beta vec = vecD.Subtract(vecD, vecA) vecUnit = rs.VectorUnitize(vec) vecI = rs.VectorScale(vecUnit, lenI) vecJ = rs.VectorScale(vecUnit, -lenJ) vecI = rs.VectorRotate(vecI, alpha, [0, 0, 1]) vecJ = rs.VectorRotate(vecJ, -beta, [0, 0, 1]) vecB = vecA + vecI vecC = vecD + vecJ pntB = geom.Point3d(vecB) pntC = geom.Point3d(vecC) points = [pntA, pntB, pntC, pntD] polyGuid = rs.AddPolyline(points) self.geom.append(polyGuid) return polyGuid
def drawTruncatedTab(self, island): flatVerts = island.flatVerts tabLen = self.tabWidth I, J = self.get_coordinates(island) K = self.tabFaceCenter if self.tabFaceCenter is None: # this is ahack: TODO: if a new cut edge is created, give it a tabFaceCenter return diagA = Rhino.Geometry.Line(I, K) diagB = Rhino.Geometry.Line(J, K) offsetLine, vecA = getOffset((I, J), K, tabLen, True) resultI, aI, bI = Rhino.Geometry.Intersect.Intersection.LineLine( offsetLine, diagA) resultJ, aJ, bJ = Rhino.Geometry.Intersect.Intersection.LineLine( offsetLine, diagB) if resultI and resultJ: intersectPntI = offsetLine.PointAt(aI) intersectPntJ = offsetLine.PointAt(aJ) shorterThanTab = self.checkIfShortTab(flatVerts) if shorterThanTab == 1: # flip order to avoid self-intersction points = [I, K, J] elif shorterThanTab == 0: points = [I, K, J] elif shorterThanTab == -1: points = [I, intersectPntI, intersectPntJ, J] # order is as expected else: points = [I, K, J] polyGuid = rs.AddPolyline(points) self.geom.append(polyGuid) return polyGuid
def meshSwipPolyAlongPoly(profile, rail): profile = rs.CopyObject(profile) pts = rs.CurveEditPoints(rail) baseVect = Rhino.Geometry.Point3d(0, 1, 0) meshes = [] for i in range(0, len(pts) - 2): p0 = pts[i] p1 = pts[i + 1] p2 = pts[i + 2] v1 = rs.VectorUnitize(p1 - p0) v2 = rs.VectorUnitize(p2 - p1) rv1 = rs.VectorUnitize(p0 - p1) vect = p1 - p0 mid = rs.VectorUnitize((rv1 + v2) / 2) np = p1 + mid up = p1 + Rhino.Geometry.Point3d(0, 0, 1) pln = rs.PlaneFromPoints(p1, np, up) mesh, pjpts = meshExtrudePolyToByVectPlane(profile, vect, pln) meshes.append(mesh) rs.DeleteObject(profile) profile = rs.AddPolyline(pjpts) mesh = rs.JoinMeshes(meshes, True) rs.DeleteObject(profile) return mesh
def update(self): print('update') #delete last generated objects try: rs.DeleteObjects(self.generatedObjs) self.generatedObjs = [] except: print('exception in delete generated object') divWidth = 600 crv = self.baseCrv if not rs.IsObject(crv): print('crv is not an object') return if not rs.IsPolyline(crv): pts = rs.DivideCurveEquidistant(crv, divWidth) rail = rs.AddPolyline(pts) else: rail = rs.CopyObject(crv) pts = rs.CurveEditPoints(rail) if len(pts) < 3: print('too little points') return #find vectors to move and orient the profile vect = pts[1] - pts[0] vect = rs.VectorUnitize(vect) a = rs.VectorAngle(vect, (0, 1, 0)) - 90 #load the component path = self.loadPath component = None try: component = importComponent(path) except: print('exception on importing module') if component is None: print('component is None') return None #rs.MoveObjects(component.breps,pts[0]) #rs.RotateObjects(component.breps,pts[0],a) for b in component.breps: self.generatedObjs.append(b) oriented = orientObjAlongPolyPts(b, pts) print('pts count:', len(pts), ' num gen:', len(oriented)) rs.MoveObjects(component.polys, pts[0]) rs.RotateObjects(component.polys, pts[0], a) for c in component.polys: self.generatedObjs.append(c) mesh = meshSwipPolyAlongPoly(c, rail) self.generatedObjs.append(mesh) rs.DeleteObject(rail) print('generated obj count:', len(self.generatedObjs)) rs.AddGroup('gen') rs.AddObjectsToGroup(self.generatedObjs, 'gen')
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 plot(self): points = [] for i in range(len(self.gaussKernel)): x = i * self.gStepSize y = self.gaussKernel[i] points.append([x, y, 0]) #rs.AddPoint(x,y,0) rs.AddPolyline(points)
def EndingCap(stuff1,stuff2): plyu = ChainLink(stuff1[0][0],stuff1[0][1]) plyd = ChainLink(stuff1[1][0],stuff1[1][1]) polu = rs.AddPolyline(plyu) pold = rs.AddPolyline(plyd) up = rs.AddPlanarSrf([polu]) down = rs.AddPlanarSrf([pold]) uplink = rs.AddSrfPt([stuff2[0][0][len(stuff2[0][0])],stuff1[0][0][0],stuff1[0][1][0],stuff2[0][1][len(stuff2[0][1])]]) downlink = rs.AddSrfPt([stuff2[1][0][len(stuff2[1][0])],stuff1[1][0][0],stuff1[1][1][0],stuff2[1][1][len(stuff2[1][1])]]) rs.DeleteObjects([polu,pold]) return [[uplink,up[0]],[downlink,down[0]]]
def drawTriangle(self, t, vertex): v1 = vertex[t[0]] v2 = vertex[t[1]] v3 = vertex[t[2]] if len(v1) == 2: v1.append(0) if len(v2) == 2: v2.append(0) if len(v3) == 2: v3.append(0) crv = rs.AddPolyline([v1, v2, v3, v1]) return crv
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