def offsetext(): def RepresentsInt(s): try: int(s) return True except ValueError: return False viste = rs.ViewNames() for viewport in viste: rs.ViewDisplayMode(viewport,"Shaded") diametro = rs.StringBox("dimensione della punta","10","scontornatura") if RepresentsInt(diametro): diametro = int(diametro) else: diametro = 10 brep = rs.GetObjects("dammi un solido",16) brepexp = rs.ExplodePolysurfaces(brep) get_val = rs.GetEdgeCurves("dammi le curve") surf_edge = [] for i in get_val: surf_edge.append(i[0]) surf_edge = rs.coerceguidlist(surf_edge) if len(surf_edge)>1: surf_edge = rs.JoinCurves(surf_edge,True) surface = rs.GetObjects("conferma la selezione",8,False,True,1,1) print surf_edge uv= [] temp_edge = rs.ExplodeCurves(surf_edge,False) new_surface = rs.CopyObject(surface,(0,0,0)) 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) edge = rs.OffsetCurveOnSurface(surf_edge,new_surface,diametro) surf_edge = rs.ExplodeCurves(surf_edge,True) print edge rs.ObjectColor(edge,(0,0,255)) for i in brepexp: rs.DeleteObject(i) for i in temp_edge: rs.DeleteObject(i) for i in surf_edge: rs.DeleteObject(i) rs.DeleteObjects([new_surface,surface])
def Cremona2(no, nomes, Linhas, countPF, dicPF): ptos1 = [] dicUp = {} for i in range(countPF): if i == 0: Spt = dicPF[nomes[i]].PointAt(0) Ept = dicPF[nomes[i]].PointAt(1) else: if i == 1: cond1 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0), dicPF[nomes[i]].PointAt(1), Tol) cond2 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0), dicPF[nomes[i]].PointAt(0), Tol) if cond1 or cond2: pAux3 = Spt Spt = Ept Ept = pAux3 if rs.PointCompare(Ept, dicPF[nomes[i]].PointAt(1), Tol): ptAux1 = dicPF[nomes[i]].PointAt(1) ptAux2 = dicPF[nomes[i]].PointAt(0) else: ptAux1 = dicPF[nomes[i]].PointAt(0) ptAux2 = dicPF[nomes[i]].PointAt(1) Ept += (ptAux2 - ptAux1) vAux1 = Line(rs.CurveStartPoint(Linhas[-2]), Ept) vAux2 = Line(rs.CurveStartPoint(Linhas[-1]), Spt) F1 = gh.Move(rs.coerceline(Linhas[-2]), vAux1)[0] F2 = gh.Move(rs.coerceline(Linhas[-1]), vAux2)[0] inter = gh.LineXLine(F1, F2)[2] F1 = rs.AddLine(Ept, inter) F2 = rs.AddLine(inter, Spt) dicUp[nomes[-2]] = rs.coerceline(F1) dicUp[nomes[-1]] = rs.coerceline(F2) #-cargas e nomenclatura #teste de tração e compressão sin1 = TraComp(no, F1, rs.coerceline(Linhas[-2]), nomes[-2]) sin2 = TraComp(no, F2, rs.coerceline(Linhas[-1]), nomes[-1]) #valores das cargas carga1 = rs.CurveLength(F1) * sin1 / Escala carga2 = rs.CurveLength(F2) * sin2 / Escala #teste de tensão admissivel cor1 = teste_elemento(nomes[-2], carga1, Linhas[-2]) cor2 = teste_elemento(nomes[-1], carga2, Linhas[-1]) #nomenclatura do FG txt1 = nomes[-2] + ' = ' + str('%.2f' % carga1) txt2 = nomes[-1] + ' = ' + str('%.2f' % carga2) pt1 = rs.coerceline(Linhas[-2]).PointAt(.5) pt2 = rs.coerceline(Linhas[-1]).PointAt(.5) ptos1 += [pt1, txt1, cor1] ptos1 += [pt2, txt2, cor2] #nimenclatura do PF pt1 = rs.coerceline(F1).PointAt(.5) pt2 = rs.coerceline(F2).PointAt(.5) txt1 = nomes[-2] txt2 = nomes[-1] ptos1 += [pt1, txt1, cor1] ptos1 += [pt2, txt2, cor2] return dicUp, ptos1
def write_strip_data(layer, point_ind): # get all surfaces on layer strips = rs.ObjectsByLayer(layer) strip_ind = 1 strip_dict = {} for strip in strips: # get only surfaces if rs.IsSurface(strip): if rs.IsSurfacePlanar(strip): strip_dict['Strip=' + layer + str(strip_ind)] = [] strip_brep = rs.coercebrep(strip) edges = Rhino.Geometry.Brep.DuplicateEdgeCurves(strip_brep) edge_ids = [] ind = 0 for edge in edges: edge_id = sc.doc.Objects.AddCurve(edge) if edge_id: rs.ObjectName(edge_id, 'active' + str(ind)) edge_ids.append(edge_id) ind += 1 # Get strip geometry # change color to help find strip rs.ObjectColor(strip, color=(255, 0, 255)) start_edge = rs.GetObject('Select start edge.', 4, False, False, active_strip_filter) start_length = rs.CurveLength(start_edge) sp = rs.CurveMidPoint(start_edge) rs.ObjectName(rs.AddPoint(sp), name='SP_' + str(point_ind)) end_edge = rs.GetObject('Select end edge.', 4, False, False, active_strip_filter) end_length = rs.CurveLength(end_edge) ep = rs.CurveMidPoint(end_edge) rs.ObjectName(rs.AddPoint(ep), name='SP_' + str(point_ind)) # Clean up rs.DeleteObjects(edge_ids) rs.ObjectColor(strip, color=(128, 0, 128)) # write to json start = { 'Point': point_ind, 'GlobalX': round(sp.X, 4), 'GlobalY': round(sp.Y, 4), 'WALeft': round(start_length * 0.5, 4), 'WARight': round(start_length * 0.5, 4), 'Autowiden': 'No' } point_ind += 1 end = { 'Point': point_ind, 'GlobalX': round(ep.X, 4), 'GlobalY': round(ep.Y, 4), 'WBLeft': round(end_length * 0.5, 4), 'WBRight': round(end_length * 0.5, 4), } strip_dict['Strip=' + layer + str(strip_ind)].append(start) strip_dict['Strip=' + layer + str(strip_ind)].append(end) point_ind += 1 strip_ind += 1 return strip_dict
def dimension_boundingBox(part): """returns a tuple with the height and width of bounding box""" boundingBox = set_partAligned_boundingBox(part) lineHeight = rs.AddLine(boundingBox[0], boundingBox[1]) lineWidth = rs.AddLine(boundingBox[0], boundingBox[3]) partHeight = rs.CurveLength(lineHeight) partWidth = rs.CurveLength(lineWidth) dimensions = (partHeight, partWidth) return dimensions
def mergeLR(self, Llist, Rlist): assert (len(Llist) == len(Rlist)) mergedList = [] for i in range(len(Llist)): if rs.CurveLength(Llist[i]) >= rs.CurveLength(Rlist[i]): mergedList.append(rs.CopyObject(Llist[i])) else: mergedList.append(rs.CopyObject(Rlist[i])) return mergedList
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 get_adjust(self):# 曲線の長さ調整の仕方を返却 if self.mode == "extend":# 長い方に揃える if rs.CurveLength(self.crvs[self.ind_o]) >= rs.CurveLength(self.crvs[self.ind_x]): pattern = 1 else: pattern = 2 else:# 短い方に揃える if rs.CurveLength(self.crvs[self.ind_o]) >= rs.CurveLength(self.crvs[self.ind_x]): pattern = 3 else: pattern = 4 return pattern
def iterativeshortencurve(): curve_id = rs.GetObject("Open curve to smooth", 4, True) if curve_id is None or rs.IsCurveClosed(curve_id): return min = rs.Distance(rs.CurveStartPoint(curve_id), rs.CurveEndPoint(curve_id)) max = rs.CurveLength(curve_id) goal = rs.GetReal("Goal length", 0.5 * (min + max), min, max) if goal is None: return while rs.CurveLength(curve_id) > goal: rs.EnableRedraw(False) curve_id = smoothcurve(curve_id, 0.1) rs.EnableRedraw(True) if curve_id is None: break
def weave(self, firstcurve, secondcurve, pointcount): e = rs.CurveLength(firstcurve) f = rs.CurveLength(secondcurve) p1 = rs.DivideCurveEquidistant(firstcurve, e / pointcount, True, True) p2 = rs.DivideCurveEquidistant(secondcurve, f / pointcount, True, True) points = [] for i in range(len(p1)): points.append(p1[i]) points.append(p2[i]) for p in points: self.goto(p[0], p[1], p[2])
def BSearchCurve(idCrv, Length, Tolerance): Lcrv = rs.CurveLength(idCrv) if Lcrv < Length: return tmin = rs.CurveDomain(idCrv)[0] tmax = rs.CurveDomain(idCrv)[1] t0 = tmin t1 = tmax while True: t = 0.5 * (t1 + t0) Ltmp = rs.CurveLength(idCrv, 0, [tmin, t]) if abs(Ltmp - Length) < Tolerance: return t if Ltmp < Length: t0 = t else: t1 = t
def TotalLengthOfFractures(self, fracture_guid_list, cut_plane): """ Function to intersect fractures and return the total length of fractures in the cut plane Parameters ---------- fracture_guid_list: list list containing domain fractures' guids cut_plane: guid guid of the cut plane """ # initialise length as 0 length = 0 # convert plane to a surface plane_surf = rs.AddPlanarSrf(cut_plane) # loop through the fractures' GUIDs for i in range(len(fracture_guid_list)): # perform intersection test intersection = rs.IntersectBreps(fracture_guid_list[i], plane_surf) # if there is intersection if intersection is not None: # go through the list for x in intersection: # check it's a line! if rs.IsLine(intersection[0]): # add the GUID to class attribute # 'intersecting_fractures' self.intersecting_fractures.append(intersection[0]) # increment the length of intersecting fractures length += rs.CurveLength(intersection[0]) # delete the plane surface we added to Rhino interface rs.DeleteObject(plane_surf) # return the lotal lengths of intersection return length
def teste_elemento(nome, carga, fglin): #banzo ou diagonal if nome[0] == 'b': bd = 0 else: bd = 1 # se tracionado if carga >= 0: if abs(carga) < F_adm[bd]: #print nome + 'compressão ok' return corpass else: print nome + ' Falhou na tração' return corfail #se comprimido elif carga < 0: len1 = rs.CurveLength(fglin) rGira = (Areas[1][bd] / Areas[0][bd])**0.5 esbelt = len1 / rGira if esbelt >= esb_min: T_comp = (3.14**2 * Mod_E) / (esbelt**2 * coe_Comp) #print nome + ' Formula de Euler' else: T_comp = (17000 - 0.485 * (esbelt**2)) * 6894.745 #print nome + ' Formula do A.I.S.C.' if (abs(carga) / Areas[0][bd] < T_comp) and (abs(carga) < F_adm[bd]): return corpass else: print nome + ' Falhou na compressão' return corfail
def Sierpinsky_triangle(triangle): if rs.CurveLength(triangle[0]) < smallestCurve: return else: #make left triangle line1 = rs.AddLine(rs.CurveStartPoint(triangle[0]), rs.CurveMidPoint(triangle[0])) line2 = rs.AddLine(rs.CurveMidPoint(triangle[0]), rs.CurveMidPoint(triangle[2])) line3 = rs.AddLine(rs.CurveMidPoint(triangle[2]), rs.CurveStartPoint(triangle[0])) #make right triangle line4 = rs.AddLine(rs.CurveMidPoint(triangle[0]), rs.CurveEndPoint(triangle[0])) line5 = rs.AddLine(rs.CurveEndPoint(triangle[0]), rs.CurveMidPoint(triangle[1])) line6 = rs.AddLine(rs.CurveMidPoint(triangle[1]), rs.CurveMidPoint(triangle[0])) #make top triangle line7 = rs.AddLine(rs.CurveMidPoint(triangle[2]), rs.CurveMidPoint(triangle[1])) line8 = rs.AddLine(rs.CurveMidPoint(triangle[1]), rs.CurveEndPoint(triangle[1])) line9 = rs.AddLine(rs.CurveStartPoint(triangle[2]), rs.CurveMidPoint(triangle[2])) #recurse Sierpinsky_triangle([line1, line2, line3]) Sierpinsky_triangle([line4, line5, line6]) Sierpinsky_triangle([line7, line8, line9])
def Rectify_AngleFirst(obj, angleMultiple, lengthMultiple): """ Rebuilds a polyline with exact angles and lengths. Angles have priority input: obj (polyline) angleMultiple (float): Multiple to round to lengthMultiple (float): Length to round to (0 == no rounding) returns: polyline (guid) """ angles = GetCornerAngles(obj) if angleMultiple != 0: fixedAngles = ForceToMultipleOf(angles, angleMultiple) else: fixedAngles = angles if rs.IsLine(obj): lengths = [rs.CurveLength(obj)] fixedAngles = 0 else: lengths = GetSegmentLengths(obj) if lengthMultiple != 0: fixedLengths = ForceToMultipleOf(lengths, lengthMultiple) else: fixedLengths = lengths if rs.IsLine(obj): line = ChangeLineLength(obj, fixedLengths) id = sc.doc.Objects.AddLine(line) else: newPline = ChangeVertexAngles(obj, fixedAngles, fixedLengths) id = sc.doc.Objects.AddPolyline(newPline) sc.doc.Views.Redraw() return id
def vector_sum(lines, preview=False): vector_list = [] total_time = 0 total_length = 0 last_feed = 0 for i in range(len(lines)): point_a = lines[i][:3] if i == len(lines) - 1: break point_b = lines[i + 1][:3] vector = rs.AddLine(point_a, point_b) if preview else rs.VectorCreate( point_a, point_b) if preview: rs.ObjectLayer(vector, LAYER_NAME) rs.ObjectColor(vector, color_palette["cut"]) vector_list.append(vector) if len(lines[i]) == 4: feed = lines[i][-1] last_feed = feed vector_length = rs.CurveLength(vector) if preview else rs.VectorLength( vector) total_length += vector_length total_time += (vector_length) / last_feed return vector_list, round(total_time, 2), round(total_length, 2)
def getRoadCurve(key1, key2, trans_path, road_dict, insert_road_dict): # 根据路径结点序号得到一条路径线段 curve_lst = [] direction = False # 合并后线的方向, true代表和第一段线同向 #trans_path = ([9, 0, 70, 79, 91, 77, 8, 60, 56, 58, 47, 43, 29, 61, 50, 54, 78, 81, 80], 3660.0) if trans_path[1] == 0: return curve_lst curve_lst.append(insert_road_dict[key1]) n = len(trans_path[0]) for i in range(n - 1): node, next = trans_path[0][i], trans_path[0][i + 1] s1, s2 = str(node) + ',' + str(next), str(next) + ',' + str(node) cur = road_dict[s1] if s1 in road_dict else road_dict[ s2] # 0->9 or 9->0 #print(cur) curve_lst.append(cur) curve_lst.append(insert_road_dict[key2]) num = len(curve_lst) if num: if num == 1: return curve_lst[0] join_curve = rs.JoinCurves(curve_lst) length = rs.CurveLength(join_curve) if rs.CurveTangent(join_curve, 0) == rs.CurveTangent(curve_lst[0], 0): direction = True return join_curve, direction #print(length) #t = 0.5 #pt = rs.CurveArcLengthPoint(join_curve, t*length) else: return
def howManyBricksCanWeMake(index): #don't like the name of this method? deal with it curvelen = rs.CurveLength(ContourCurves[index]) return [ math.ceil(curvelen / (BrickWidth + GapDomain[0])), math.floor(curvelen / (BrickWidth + GapDomain[1])) ]
def Intersect(self, other): """ function to check if a fracture intersects another Parameter ------- other: guid guid of the second fracture """ # inputs are frcature instances in fracture list curveA = self.fracture_GUID # check for intersection intersection = rs.IntersectBreps(curveA, other.fracture_GUID) # if no intersection if intersection is None: print('The fractures do not intersect') else: # go through the list of intersection for x in intersection: # check it's a line! if rs.IsLine(intersection[0]): # get intersection length length = rs.CurveLength(intersection[0]) # print a statement print( 'Fracture intersect, the length of intersection\ is:', length)
def getExtendedCrv(self, crvList, dist=50, layer_height=2.5, vecMul=.66): segmentCount = int(math.floor(dist / layer_height)) - 1 tmpList = [] fullHeight = [] for i in range(len(crvList)): extendedCrv = rs.ExtendCurveLength(crvList[i], 2, 0, dist) fullHeight.append(extendedCrv) domStart, domEnd = rs.CurveDomain(extendedCrv) trimmedCrv = rs.TrimCurve(extendedCrv, (domStart, 0)) tmpList.append(trimmedCrv) tmp = [] ###Smooth Curves### for i in range(len(tmpList)): bottomPt = rs.CurveEndPoint(tmpList[i]) zVec = rs.VectorAdd((0, 0, 0), (0, 0, dist)) topPt = rs.CopyObject(bottomPt, zVec) line = rs.AddLine(bottomPt, topPt) crvPts = rs.DivideCurve(tmpList[i], segmentCount) LinePts = rs.DivideCurve(line, segmentCount) for i in range(segmentCount): tmpVec = rs.VectorCreate(LinePts[segmentCount - i - 1], crvPts[i]) tmpVec = rs.VectorScale(tmpVec, vecMul) rs.MoveObject(crvPts[i], tmpVec) tmp.append(rs.AddInterpCurve(crvPts)) result = [] for crv in tmp: crvLen = rs.CurveLength(crv) if crvLen < dist: tmpExt = dist - crvLen result.append(rs.ExtendCurveLength(crv, 2, 0, tmpExt)) else: result.append(rs.CopyObject(crv)) return result
def fitcurvetolength(): curve_id = rs.GetObject("Select a curve to fit to Length", rs.filter.curve, True, True) if curve_id is None:return length = rs.CurveLength(curve_id) length_limit = rs.GetReal("Length limit", 0.5*length, 0.01*length, length) if length_limit is None:return while True: if rs.CurveLength(curve_id)<=length_limit:break curve_id = rs.ScaleObject(curve_id, (0,0,0), (0.95,0.95,0.95)) if curve_id is None: print "Something went wrong" return print "New curve length: ", rs.CurveLength(curve_id)
def _left_over_space(self, curve_id): ''' compute the remaning space that will result from segmenting the given curve with self.spacing chunks. ''' length = rs.CurveLength(curve_id) extra = length - int(length / self.spacing) * self.spacing return extra
def getDiv(srf, dist, uv, eq): domaincrv = rs.ExtractIsoCurve(srf, [0, 0], uv) crvLen = rs.CurveLength(domaincrv) newdist = setDist(crvLen, dist, eq) pts = rs.DivideCurveLength(domaincrv, newdist) pts.pop(0) pts.pop(-1) rs.DeleteObject(domaincrv) return pts
def __init__(self, Rect, deltaHeight, numRisers, thickness, runNum, maxTread): self.Rect = Rect self.segments = rs.ExplodeCurves(self.Rect) self.deltaHeight = deltaHeight self.numRisers = int(numRisers) self.thickness = thickness self.riserHeight = self.deltaHeight / self.numRisers self.firstRiserEdge = self.segments[0] self.runLongEdge = self.segments[1] self.treadLength = rs.CurveLength(self.runLongEdge) / self.numRisers self.maxTread = maxTread if self.treadLength > self.maxTread: self.treadLength = self.maxTread self.runNum = runNum + 1 self.stairWidth = rs.CurveLength(self.segments[0]) self.extenionLength = rs.CurveLength( self.runLongEdge) - (self.treadLength * self.numRisers)
def length(self): """Return the length of the curve. Returns ------- float The curve's length. """ return rs.CurveLength(self.guid)
def divEQCrvToPolyAD(crv,w=900,adjacentCrvs=None): outpoly=PolyAD() crvLen=rs.CurveLength(crv) numDiv=crvLen/w width=crvLen/round(numDiv) pts=rs.DivideCurve(crv,numDiv,False,True) #add to output outpoly.points=pts sharedNormals=[None,None] if adjacentCrvs is not None: sharedNormals=findSharedbisecNormals(crv,adjacentCrvs) for i in range(0,len(pts)-2): up=(0,0,1) # direct direct_end # (p0)-v1->(p1)-v2->(p2) # |n_start |n |n_end # V V V p0=pts[i] p1=pts[i+1] p2=pts[i+2] v1=rs.VectorUnitize(p1-p0) v2=rs.VectorUnitize(p2-p1) n1=rs.VectorCrossProduct(v1,up) n2=rs.VectorCrossProduct(v2,up) mid=rs.VectorAdd(n1,n2) n=rs.VectorUnitize(mid) direct=p1-p0 #add to output outpoly.directions.append(direct) if i==0: if sharedNormals[0] is not None: n_start=sharedNormals[0] else: n_start=rs.VectorCrossProduct(v1,up) outpoly.normals.append(n_start) #add to output outpoly.normals.append(n) if i==len(pts)-3: if sharedNormals[1] is not None: n_end=sharedNormals[1] else: n_end=rs.VectorCrossProduct(v2,up) outpoly.normals.append(n_end) direct_end=p2-p1 outpoly.directions.append(direct_end) return outpoly
def RunCommand(is_interactive): global params pitch_line = rs.GetObject(message="Select pitch line", filter=rs.filter.curve, preselect=True) if pitch_line is None: return 1 # Cancel if not rs.IsLine(pitch_line): print "Selected curve is not a line!" return 1 # Cancel rs.SelectObjects(pitch_line) m = rs.GetReal(message="Rack module", number=params["m"]) pa = rs.GetReal(message="Pressure angle", number=params["pa"], minimum=0, maximum=45) if m is None or pa is None: return 1 # Cancel params["m"] = m params["pa"] = pa pitch_line_center = rs.CurveMidPoint(pitch_line) pitch_line_start = rs.CurveStartPoint(pitch_line) pitch_line_end = rs.CurveEndPoint(pitch_line) angle, reflex_angle = rs.Angle2(line1=((0, 0, 0), (1, 0, 0)), line2=(pitch_line_start, pitch_line_end)) x_vector = rs.VectorCreate(pitch_line_end, pitch_line_start) y_vector = rs.VectorRotate(x_vector, 90.0, [0, 0, 1]) cplane = rs.PlaneFromFrame(origin=pitch_line_center, x_axis=x_vector, y_axis=y_vector) xform = rs.XformChangeBasis(cplane, rs.WorldXYPlane()) rs.EnableRedraw(False) old_plane = rs.ViewCPlane(plane=rs.WorldXYPlane()) rack = draw_rack(length=rs.CurveLength(pitch_line), module=params["m"], pressure_angle=params["pa"]) rs.ViewCPlane(plane=old_plane) rs.TransformObjects(rack, xform) rs.EnableRedraw(True) rs.UnselectAllObjects() rs.SelectObjects(rack) return 0 # Success
def ColorBySize(): try: objs = rs.GetObjects("Select objects to color", 1073815613, preselect=True) if objs is None: return print "Select First Color" firstColor = rs.GetColor() if firstColor is None: return print "Select Second Color" secondColor = rs.GetColor(firstColor) if secondColor is None: return rs.EnableRedraw(False) colorLine = rs.AddLine(firstColor, secondColor) areas = [] for obj in objs: if rs.IsCurve(obj): if rs.IsCurveClosed(obj): areas.append(rs.CurveArea(obj)[0]) else: areas.append(rs.CurveLength(obj)) elif rs.IsSurface(obj): areas.append(rs.SurfaceArea(obj)[0]) elif rs.IsPolysurface(obj): if rs.IsPolysurfaceClosed(obj): areas.append(rs.SurfaceVolume(obj)[0]) elif rs.IsHatch(obj): areas.append(rs.Area(obj)) else: print "Only curves, hatches, and surfaces supported" return newAreas = list(areas) objAreas = zip(newAreas, objs) objAreas.sort() objSorted = [objs for newAreas, objs in objAreas] areas.sort() normalParams = utils.RemapList(areas, 0, 1) colors = [] for t in normalParams: param = rs.CurveParameter(colorLine, t) colors.append(rs.EvaluateCurve(colorLine, param)) for i, obj in enumerate(objSorted): rs.ObjectColor(obj, (colors[i].X, colors[i].Y, colors[i].Z)) rs.DeleteObject(colorLine) rs.EnableRedraw(True) return True except: return False
def weaverandom(self, firstcurve, secondcurve, pointcount): e = rs.CurveLength(firstcurve) f = rs.CurveLength(secondcurve) p1 = rs.DivideCurveEquidistant(firstcurve, e / pointcount, True, True) p2 = rs.DivideCurveEquidistant(secondcurve, f / pointcount, True, True) points = [] for i in range(len(p1)): a = random.randint(0, pointcount - 1) b = random.randint(0, pointcount - 1) points.append(p1[a]) points.append(p2[b]) for p in points: l = self.goto(p[0], p[1], p[2]) clength = rs.CurveLength(l) if clength > e / 2: rs.DeleteObject(l)
def scalecurve(): curve_id = rs.GetObject("pick curve", 4) # provide breakout bc idk if curve_id is None: return length = rs.CurveLength(curve_id) print "current length: %g " % length length_max = rs.GetReal("max length? ", .5 * length, .1 * length, 10 * length) # you can set ranges! if length_max is None: return while length < length_max: curve_id = rs.ScaleObject(curve_id, (0, 0, 0), (1.5, 1.5, 1.5), True) length = rs.CurveLength(curve_id) print "new curve length: %g" % rs.CurveLength(curve_id)
def get_curve_from_segments(self, lines): curves = rs.JoinCurves(lines) index = 0 length = 0 for i in range(0, len(curves)): new_length = rs.CurveLength(curves[i]) if (new_length > length): index = i length = new_length return curves[index]