def get_polyline_coordinates(guids): """Get the point coordinates of polylines. Parameters ---------- guids : list[System.Guid] Polyline curve identifiers. Returns ------- list[list[[float, float, float]]] A list of point coordinates per polyline. """ if isinstance(guids, System.Guid): points = rs.PolylineVertices(guids) coords = [] if points: coords = [map(float, point) for point in points] return coords polylines = [] for guid in guids: points = rs.PolylineVertices(guid) coords = [] if points: coords = [map(float, point) for point in points] polylines.append(coords) return polylines
def Elementos_vigas(viga): #banzo superior v3 -- barras bs = rs.ExplodeCurves(viga[0]) #banzo superior v3 -- nos nbs = rs.PolylineVertices(viga[0]) #diagonais v3 -- barras dg = rs.ExplodeCurves(viga[1]) #diagonais v3 -- nos3 ndg = rs.PolylineVertices(viga[1]) #banzo inferior v3 -- barras bi = rs.ExplodeCurves(viga[2]) #banzo inferior v3 -- nos nbi = rs.PolylineVertices(viga[2]) return bs, nbs, dg, ndg, bi, nbi
def get_polyline_coordinates(guids): if isinstance(guids, System.Guid): points = rs.PolylineVertices(guids) coords = [] if points: coords = [map(float, point) for point in points] return coords polylines = [] for guid in guids: points = rs.PolylineVertices(guid) coords = [] if points: coords = [map(float, point) for point in points] polylines.append(coords) return polylines
def decompose(polyline=None): # Returns a pair (lengths, angles). Angles are in radians. polyline = polyline or rs.GetObject("Select a polyline", rs.filter.curve, True, True) if polyline is None: return vertices = rs.PolylineVertices(polyline) n = len(vertices) lengths = [] angles = [] if vertices: for i in range(n - 1): # n-1 to avoid the last extra point if i > 0: prev = i - 1 else: prev = n - 2 next = i + 1 l_i = subtract(vertices[next], vertices[i]) l_j = subtract(vertices[i], vertices[prev]) lengths.append(length(l_i)) # TODO: assumes that we have always a left turn. # what if the polyline is not convex? angles.append(pi - angle(rev(l_i), l_j)) return lengths, angles
def blendcorners(): polyline_id = rs.GetObject("Polyline to blend", 4, True, True) if not polyline_id: return vertices = rs.PolylineVertices(polyline_id) if not vertices: return radius = rs.GetReal("Blend radius", 1.0, 0.0) if radius is None: return between = lambda a, b: (a + b) / 2.0 newverts = [] for i in range(len(vertices) - 1): a = vertices[i] b = vertices[i + 1] segmentlength = rs.Distance(a, b) vec_segment = rs.PointSubtract(b, a) vec_segment = rs.VectorUnitize(vec_segment) if radius < (0.5 * segmentlength): vec_segment = rs.VectorScale(vec_segment, radius) else: vec_segment = rs.VectorScale(vec_segment, 0.5 * segmentlength) w1 = rs.PointAdd(a, vec_segment) w2 = rs.PointSubtract(b, vec_segment) newverts.append(a) newverts.append(between(a, w1)) newverts.append(w1) newverts.append(between(w1, w2)) newverts.append(w2) newverts.append(between(w2, b)) newverts.append(vertices[len(vertices) - 1]) rs.AddCurve(newverts, 5) rs.DeleteObject(polyline_id)
def align(crv1,crv2,origin,axis): count=0 vert=rs.PolylineVertices(crv1) while testAlign(crv1,crv2)==False or count>len(vert): count=count+1 crv1=rs.RotateObject(crv1,origin,360/len(vert),axis) return crv1
def blendcorners(polyline_id, radius): # Fillets the corners of a polyline (from the McNeel website) if not polyline_id: return vertices = rs.PolylineVertices(polyline_id) if not vertices: return if radius is None: return between = lambda a, b: (a + b) / 2.0 newverts = [] for i in range(len(vertices) - 1): a = vertices[i] b = vertices[i + 1] segmentlength = rs.Distance(a, b) vec_segment = rs.PointSubtract(b, a) vec_segment = rs.VectorUnitize(vec_segment) if radius < (0.5 * segmentlength): vec_segment = rs.VectorScale(vec_segment, radius) else: vec_segment = rs.VectorScale(vec_segment, 0.5 * segmentlength) w1 = rs.PointAdd(a, vec_segment) w2 = rs.PointSubtract(b, vec_segment) newverts.append(a) newverts.append(between(a, w1)) newverts.append(w1) newverts.append(between(w1, w2)) newverts.append(w2) newverts.append(between(w2, b)) newverts.append(vertices[len(vertices) - 1]) CrvId = rs.AddCurve(newverts, 5) rs.DeleteObject(polyline_id) return CrvId
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 CrvSegmentMidPt(crv, n): if rs.IsPolyline(crv): verts = rs.PolylineVertices(crv) midPt = (verts[n] + verts[n + 1]) / 2 elif rs.IsPolyCurve(crv): midPt = rs.CurveMidPoint(crv, n) else: midPt = rs.CurveMidPoint(crv) return midPt
def testAlign(crv1,crv2): start=rs.CurveStartPoint(crv2) crv1Start=rs.CurveStartPoint(crv1) pts=rs.PolylineVertices(crv1) index=rs.PointArrayClosestPoint(pts,start) crv1Pt=pts[index] if index!=0: return False else: return True
def ExportLighthouseSensorsToJSON(filename): print "Writing", filename #objectIds = rs.GetObjects("Select Sensors",rs.filter.curves,True,True) #if( objectIds==None ): return3 # Find all circle and all lines in scene circles = [] lines = [] for obj in rs.AllObjects(): # Skip hidden objects, and invisible layers # TODO: Recuse up layet hierarchy? if rs.IsObjectHidden(obj): continue layer = rs.ObjectLayer(obj) if layer and not rs.IsLayerVisible(layer): continue if rs.IsCurve(obj): if rs.IsCircle(obj): circles.append((obj, rs.CircleCenterPoint(obj))) elif rs.IsLine(obj): verts = rs.PolylineVertices(obj) if len(verts) == 2: lines.append((obj, verts)) print 'found', len(circles), 'sensor candidates (circles) in scene' print 'found', len(lines), 'sensor candidates (normals) in scene' modelJSON = {'modelNormals': [], 'modelPoints': []} # TODO: Better sort order? Perhaps based on winding around origin? for circleObj, circleCenter in reversed(circles): for line, lineVerts in lines: pos, normal = GetSensorPosAndNormal(circleCenter, lineVerts) if pos is None: continue else: modelJSON['modelNormals'].append([float(x) for x in normal]) modelJSON['modelPoints'].append( [float(x) / 1000.0 for x in pos]) break modelJSON['channelMap'] = range(len(modelJSON['modelNormals'])) print "Extracted", len(modelJSON['channelMap']), "sensors" if len(modelJSON['modelNormals']) > 0: outputFile = file(filename, 'w') jsonText = json.dumps(modelJSON, indent=4, sort_keys=True) outputFile.write(jsonText) outputFile.close() print "Wrote", filename else: print "Error: No sensors found in scene"
def mapping(discretization_spacing, surface_guid, curve_features_guids = [], point_features_guids = []): """Creates planar polylines from the boundaries of a NURBS surface, NURBS curves and point on the NURBS surface by using the UV parameterisation with a user-input discretisation spacing. Parameters ---------- discretization_spacing: real Spacing value for discretisation of NURBS surface borders and curves into polylines. surface: Rhino surface guid Untrimmed or trimmed Rhino NURBS surface. curve_features: Rhino curve guid Rhino NURBS curve on the surface. point_features: Rhino point guid Rhino point on the surface. Returns ------- output: list Planar parameterised geometrical output: boundary, holes, polyline features and point features. Raises ------ - """ boundaries = surface_borders(surface_guid, border_type = 1) boundary_polylines = [curve_discretisation(boundary, discretization_spacing) for boundary in boundaries] uv_boundary_polylines = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(boundary_polyline)] for boundary_polyline in boundary_polylines] planar_boundary_polylines = [[[u, v, 0] for u, v in uv_boundary_polyline] for uv_boundary_polyline in uv_boundary_polylines] planar_boundary_polyline = [] for polyline in planar_boundary_polylines: planar_boundary_polyline += polyline[: -1] planar_boundary_polyline.append(planar_boundary_polyline[0]) rs.DeleteObjects(boundaries) rs.DeleteObjects(boundary_polylines) holes = surface_borders(surface_guid, border_type = 2) if len(holes) > 1: holes = rs.JoinCurves(holes, delete_input = True) hole_polylines = [curve_discretisation(hole, discretization_spacing) for hole in holes] uv_hole_polylines = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(hole_polyline)] for hole_polyline in hole_polylines] planar_hole_polylines = [[[u, v, 0] for u, v in hole] for hole in uv_hole_polylines] rs.DeleteObjects(holes) rs.DeleteObjects(hole_polylines) polyline_features = [curve_discretisation(curve_features_guid, discretization_spacing) for curve_features_guid in curve_features_guids] uv_polyline_features = [[rs.SurfaceClosestPoint(surface_guid, vertex) for vertex in rs.PolylineVertices(polyline_feature)] for polyline_feature in polyline_features] planar_polyline_features = [[[u, v, 0] for u, v in feature] for feature in uv_polyline_features] rs.DeleteObjects(polyline_features) uv_point_features = [rs.SurfaceClosestPoint(surface_guid, point) for point in point_features_guids] planar_point_features = [[u, v, 0] for u, v in uv_point_features] return planar_boundary_polyline, planar_hole_polylines, planar_polyline_features, planar_point_features
def get_polyline_points(polylines): polys = {} for key, id in enumerate(polylines): polys[key] = {} if not rs.IsCurveClosed(id): print str(id) + " is an open curve" rs.MessageBox(str(id) + " is an open curve") return None polys[key]['points'] = rs.PolylineVertices(id)[:-1] polys[key]['id'] = id return polys
def GetMaxLength(rect): # find long side rs.ObjectColor(rect, Color.Blue) tempPt = rs.PolylineVertices(rect) tempPt = PointsReorder(tempPt, 1) if rs.Distance(tempPt[0], tempPt[1]) > rs.Distance(tempPt[1], tempPt[2]): rs.ObjectColor(rect, Color.Orange) return rs.Distance(tempPt[0], tempPt[1]) else: rs.ObjectColor(rect, Color.Orange) return rs.Distance(tempPt[1], tempPt[2])
def ptsFromPolyline(poly=None): if poly == None: return pts = rs.PolylineVertices(poly) if len(pts) != 3: return newPts = [] newPts.append(pts[1]) newPts.append(pts[0]) newPts.append(pts[2]) return newPts
def creatrec(rec1): #输入一个gh里的矩形,输出矩形类 rec1 = rs.PolylineVertices(rec1) origin_point1 = Point2D([rec1[0][0],rec1[0][1]]) point1 = rec1[1] point_end = rec1[-2] vecx1 = Vector(point1[0]-origin_point1.x,point1[1]-origin_point1.y) vecy1 = Vector(point_end[0]-origin_point1.x,point_end[1]-origin_point1.y) vecx1_na = vecx1.reverse() vecy1_na = vecy1.reverse() now_rec1 = Rectangle(origin_point1,[vecx1,vecy1,vecx1_na,vecy1_na]) return now_rec1
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 save(obj, x=0, y=0, filename=None): if filename is None: filename = rs.SaveFileName("Save", "CarbideMotion (*.nc)|*.nc||") print('saving to ' + filename) with open(filename, 'w') as f: program_start(f.write, x, y) points = rs.PolylineVertices(obj) for point in points: f.write("X{:.3f}Y{:.3f}Z{:.3f}\n".format(point.X, point.Y, point.Z)) program_end(f.write) print('file sucessfully saved')
def GroupMove(rectOutlineList, objects, objCenter, rotatedAngle, movingCenter): for objs, rect, center, rotAngle, centerStart in zip( objects, rectOutlineList, objCenter, rotatedAngle, movingCenter): # rotate everything by center with rotatedAngle rs.RotateObjects(objs, center, rotAngle) # find vector to move from obj location to rectangle(obj center to rect center) boxCenter = rs.CurveAreaCentroid(rect)[0] moveVector = rs.VectorCreate(boxCenter, center) # check if object is in box rectPt = rs.PolylineVertices(rect) rectPt = PointsReorder(rectPt, 1) if rs.Distance(rectPt[0], rectPt[1]) > rs.Distance( rectPt[1], rectPt[2]): rs.RotateObjects(objs, center, 90) rs.MoveObjects(objs, moveVector)
def Linhas_de_Cargas(viga, cargas, nome): Cargasvigas = [] ptos1 = [] nos = rs.PolylineVertices(viga[0]) for i in range(len(cargas)): lincarg = Linha_force_extena(nos[i], cargas[i], Escala) linCoe = rs.coerceline(lincarg) pt1 = linCoe.PointAt(.5) pt2 = linCoe.PointAt(0) texto1 = str('%.2f' % cargas[i]) texto2 = 'P' + str(i) + '_' + nome Cargasvigas.append(lincarg) ptos1 += [pt1, texto1, corcargas] ptos1 += [pt2, texto2, corcargas] return Cargasvigas, ptos1
def isometricflow(polyline=None, t=0.1): polyline = polyline or rs.GetObject("Select a polyline", rs.filter.curve, True, True) if polyline is None: return vertices = rs.PolylineVertices(polyline) n = len(vertices) - 1 lengths = [] angles = [] if vertices: for i in range(n): if i > 0: prev = i - 1 else: prev = n - 1 next = i + 1 l_i = subtract(vertices[next], vertices[i]) l_j = subtract(vertices[i], vertices[prev]) lengths.append(length(l_i)) # TODO: Is this working only for convex polygons? Does rs.VectorAngle return negative values when it's not convex? angles.append(angle(l_i, l_j)) angles_sum = sum(angles) for a in angles: a = a - t * (a - angles_sum / n) # TODO(mikhaildubov): This is a dead piece of code prev_edge = subtract(vertices[1], vertices[0]) newvertices = [vertices[0]] for i in range(1, n): newvertices.append(rs.PointAdd(newvertices[-1], prev_edge)) next_edge = scale(unit(rotate(prev_edge, angles[i], [0, 0, 1])), lengths[i]) prev_edge = next_edge newvertices.append(newvertices[0]) # first point closes the polyline # new_polyline = rs.AddPolyline(newvertices, polyline) # replaces previous polyline new_polyline = rs.AddPolyline(newvertices) # keeps previous polyline return new_polyline
__version__ = "2021.03.17" import rhinoscriptsyntax as rs import Rhino as rh import scriptcontext as sc sc.doc = rh.RhinoDoc.ActiveDoc all_objs = rs.AllObjects() #obj_crv = rs.coercecurve(all_objs[0]) #print(obj_crv) #pnt = rs.CreatePoint(float(-22), float(-1), float(0)) pnt = rs.CreatePoint(float(42), float(-3), float(0)) counter = 0 for obj in all_objs: crv = rs.coercecurve(obj) in_curve = rs.PointInPlanarClosedCurve(pnt, crv) counter += 1 if (in_curve): print(counter, "Tada") points = rs.PolylineVertices(curve) pnt = rs.CreatePoint(float(235), float(240), float(0)) rs.SetUserText(curve, "PartNo", "KM40-4960") print(counter, crv)
def Outline(refpt,dir,arrlist): data = ReadJoints(di,fil) O = -1 trim = 1 left = [] upl = [] right = [] upr = [] res = Start(refpt,dir,data[0]) dir = res[0] for j in range(len(res[1])): upl.append(rs.VectorAdd(res[1][j],[0,0,-1*trim])) left.append(res[1][j]) for j in range(len(res[2])): upr.append(rs.VectorAdd(res[2][j],[0,0,-1*trim])) right.append(res[2][j]) store = [[left,right],[upl,upr]] info2 = data[0] for i in range(len(arrlist)): trim = trim*fc refpt = rs.VectorAdd(refpt,dir) info = data[arrlist[i]] if i < len(arrlist): res = Elt(refpt,dir,info) res1 = Shift(res,trim) dir = res[0] for j in range(len(res[1])): upl.append(rs.VectorAdd(res[1][j],[0,0,-1*trim])) left.append(res[1][j]) for j in range(len(res[2])): upr.append(rs.VectorAdd(res[2][j],[0,0,-1*trim])) right.append(res[2][j]) store2 = [[res[1],res[2]],[res1[1],res1[2]]] store = store2 else: res = Ending(refpt,dir,info) res1 = Shift(res,trim) dir = res[0] for j in range(len(res[1])): upl.append(rs.VectorAdd(res[1][j],[0,0,-1*trim])) left.append(res[1][j]) for j in range(len(res[2])): upr.append(rs.VectorAdd(res[2][j],[0,0,-1*trim])) right.append(res[2][j]) store2 = [[res[1],res[2]],[res1[1],res1[2]]] store = store2 info2 = info l1 = rs.AddPolyline(left) r1 = rs.AddPolyline(right) #l2 = rs.AddPolyline(upl) #r2 = rs.AddPolyline(upr) output = rs.JoinCurves([l1,r1],True) return rs.PolylineVertices(output[0])
import rhinoscriptsyntax as rs fp = "gcode_out.txt" inCrv = rs.GetObjects("Select curves to draw", filter=4) print inCrv if len(inCrv) > 0: inCrv = sorted(inCrv, key=lambda k:rs.CurveStartPoint(k).Y) #subD = rs.GetReal("Input segment length", number=1.0) with open(fp, mode='w') as outfile: if len(inCrv) >= 1: for crv in inCrv: pts = rs.PolylineVertices(crv) for i, pt in enumerate(pts): if i == 0: #raise pen outfile.write("M03 S0 \n") #go to first position outfile.write("G00 X%.3f Y%.3f \n" %(pt.X,pt.Y) ) #drop pen outfile.write("M03 S1024 \n") continue #go to next position (with pen down) outfile.write("G00 X%.3f Y%.3f \n" %(pt.X,pt.Y) ) #lift pen outfile.write("M03 S0 \n") outfile.write("G00 X0 Y0 \n")
def createAirplane(self): #CREATE FUSELAGE rectangleFuselage = rs.AddRectangle(self.location, self.genes.values['Fw'], self.genes.values['Fh']) endPointsF = rs.PolylineVertices(rectangleFuselage) fPtsB = offsetPoints(self.genes.values['Fpb'], endPointsF[0], endPointsF[1]) fPtsR = offsetPoints(self.genes.values['Fpr'], endPointsF[1], endPointsF[2]) fPtsT = offsetPoints(self.genes.values['Fpt'], endPointsF[2], endPointsF[3]) fPtsL = offsetPoints(self.genes.values['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], (self.genes.values['Fwx'], self.genes.values['Fwy'], 0)) wingSlotEnd = rs.VectorAdd( wingSlotStart, (self.genes.values['Fw'] - self.genes.values['Fwx'] + maxPointOffset * 2, 0, 0)) wingSlot = rs.AddLine(wingSlotStart, wingSlotEnd) #guideLine = rs.AddLine(wingSlotStart,rs.VectorAdd(wingSlotStart,(0,0.2,0))) #rs.ObjectColor(guideLine,(0,0,200)) #wingSlotOffset = rs.OffsetCurve(wingSlot,(0,1,0),1/32) #rs.AddLine(rs.CurveStartPoint(wingSlot),rs.CurveStartPoint(wingSlotOffset)) #CREATE WING wPlaneOffY = self.genes.values['Wh'] + 1 wPlaneOffX = self.genes.values['Fw'] / 2 wingPlane = rs.MovePlane(self.location, (wPlaneOffX + self.location[0].X, -wPlaneOffY + self.location[0].Y, 0)) rectangleWing = rs.AddRectangle(wingPlane, self.genes.values['Ww'], self.genes.values['Wh']) endPointsW = rs.PolylineVertices(rectangleWing) wPtsB = offsetPoints(self.genes.values['Wpb'], endPointsW[0], endPointsW[1]) wPtsR = offsetPoints(self.genes.values['Wps'], endPointsW[1], endPointsW[2]) wPtsT = offsetPoints(self.genes.values['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]) wingCurveM = rs.MirrorObject(wingCurve, endPointsW[3], endPointsW[0], True) #CREATE WING GROOVE wingGrooveStart = rs.VectorAdd(endPointsW[3], (0, maxPointOffset, 0)) wingGrooveEnd = rs.VectorAdd( wingGrooveStart, (0, -(maxPointOffset + self.genes.values['Wh'] * self.genes.values['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) textPlane = rs.MovePlane( self.location, (self.location[0].X + .25, self.location[0].Y + .25, 0)) text = rs.AddText(self.number, textPlane, 0.25) textCurves = rs.ExplodeText(text, True) rs.ObjectColor(textCurves, (0, 0, 200)) planeGroup = rs.AddGroup() rs.AddObjectsToGroup( [fCurveOpen, wingCurveM, wingSlot, wingCurve, wingGroove, text], planeGroup)
#atualizando dicionário dic_2.update(dicUp) #Atualizando elementos na saida PF2 for i in dicUp.keys(): PF2.append(dicUp[i]) print '####--------------------V2-----------------------####' dicUp, ptos = Grafo_Viga(v2, carreg_v2, Plano, dic_2, cirDir, Conector[1], fgR_v2, 'v2') txt_pontos += ptos #atualizando dicionário dic_2.update(dicUp) #Atualizando elementos na saida PF2 for i in dicUp.keys(): PF2.append(dicUp[i]) print '####--------------Eixo do Conector---------------####' nos = rs.PolylineVertices(Conector[1]) no = nos[0] conector = rs.ExplodeCurves(Conector[1]) conector.append(rs.AddLine(no, nos[2])) #elementos do conector elementos, nomesNo = elemntos_node(no, conector, 'bc', 'c') #Força externa fgF0 = (rs.AddLine(F0.PointAt(0), F0.PointAt(1))) nomesNo, elementos, countPF, countCalcular = OrdenaLinhasDeAcao( no, cirDir, elementos, nomesNo, dic_2, Plano) nomesNo.insert(1, 'F0') elementos.insert(1, fgF0) dicUp, ptos1 = Cremona1(no, nomesNo, elementos, countPF + 1, dic_2) txt_pontos += ptos1 dic_2.update(dicUp) #Atualizando elementos na saida PF2
def RectNestingOperation(boards, rectOutlineList): onBoard = [] # store the rectngles placed that are currently on this board rectInOrder = [] # store the rectangles that are in order curBoardIndex = 0 # number of board used nestingOrient = 1 # 1: current (big), 2: cur. turn 90 degrees, 3: reversed (small), 4: reversed and teuned 90 degrees intersectWithRect = False # order rectangle by length (UPDATED) for i in rectOutlineList: # check if list is empty so far if len(rectInOrder) == 0: rectInOrder.append(i) continue lastIndex = len(rectInOrder) - 1 index = 1 rs.ObjectColor(i, Color.Orange) maxLength = GetMaxLength(i) # compare first and last if GetMaxLength(rectInOrder[0]) >= maxLength: rectInOrder.insert(0, i) continue elif GetMaxLength(rectInOrder[lastIndex]) <= maxLength: rectInOrder.append(i) continue # check within the ordered list while GetMaxLength(rectInOrder[index]) < maxLength: index += 1 rectInOrder.insert(index, i) # reverse rectangle order to descending order rectInOrder.reverse() while curBoardIndex <= len(boards): # check if ascend of descend placement (adjust curRect also) if len(rectInOrder) == 0: # done nesting, no more in list return True # update board if previous board is full curBoard = boards[curBoardIndex] curBoardPt = rs.PolylineVertices(curBoard) # nesting Orient checking if nestingOrient == 1 or nestingOrient == 2: if nestingOrient == 1: curRectIndex = 0 curRect = rectInOrder[curRectIndex] curRectPt = rs.PolylineVertices(curRect) else: rs.RotateObject(curRect, (curRectPt[0] + curRectPt[2]) / 2, 90) elif nestingOrient == 3 or nestingOrient == 4: if nestingOrient == 3: curRectIndex = len(rectInOrder) - 1 curRect = rectInOrder[curRectIndex] curRectPt = rs.PolylineVertices(curRect) else: rs.RotateObject(curRect, (curRectPt[0] + curRectPt[2]) / 2, 90) rs.ObjectColor(curRect, Color.LightBlue) curRectPt = rs.PolylineVertices(curRect) curRectPt = PointsReorder(curRectPt, 1) """ ******************************************************************************************************************* # arrange all rect with long side in lateral (MOVE THIS TO GETRECT CLASS)-> THIS IS MOVED TO GETALLRECTOUTLINE CLASS # SO WE CAN SUPPOSE ALL RECT PASSING IN IS MAX LENGTH AT LATERAL DIRECTION ******************************************************************************************************************* if nestingOrient == 1 or nestingOrient == 3: if rs.Distance(curRectPt[0], curRectPt[1]) > rs.Distance(curRectPt[1], curRectPt[2]): rs.RotateObject(curRect,(curRectPt[0] + curRectPt[2]) / 2, 90) """ # remake points for curRectPt and move to board start curRectPt = rs.PolylineVertices(curRect) curRectPt = PointsReorder(curRectPt, 1) moveInBoard = rs.VectorCreate(curBoardPt[0], curRectPt[0]) rs.MoveObject(curRect, moveInBoard) curRectPt = rs.PolylineVertices(curRect) curRectPt = PointsReorder(curRectPt, 1) # nesting movement if len(onBoard) == 0: onBoard.append(curRect) rectInOrder.pop(curRectIndex) else: while True: # check intersection with other rect. for check in onBoard: # True means intersect, false means good to place if other condition pass intersectWithRect = (rs.IsObjectInBox( curRect, rs.PolylineVertices(check), False)) if intersectWithRect == True: break # in board status overBoard = curRectPt[1][0] > curBoardPt[1][0] changeBoard = curRectPt[2][1] > curBoardPt[2][1] if (changeBoard and nestingOrient == 4): # change board curBoardIndex += 1 curBoard = boards[curBoardIndex] del onBoard[:] # clearing onBoard for next board nestingOrient = 1 # move back to original location rs.MoveObject(curRect, -moveInBoard) break elif (changeBoard): # first change orientation and see if it can still fit if (nestingOrient == 1): nestingOrient = 2 break elif (nestingOrient == 2): nestingOrient = 3 # move back to original location (not super ideal but can't think of anything else at this point Lol) moveTemp = [0, -2000000, 0] rs.MoveObject(curRect, moveTemp) rs.RotateObject(curRect, (curRectPt[0] + curRectPt[2]) / 2, -90) break elif (nestingOrient == 3): nestingOrient = 4 break elif (overBoard): # switch to new y (up 1 interval) lateralMove = [(curBoardPt[0][0] - curRectPt[0][0]), 20, 0] rs.MoveObject(curRect, lateralMove) curRectPt = rs.PolylineVertices(curRect) curRectPt = PointsReorder(curRectPt, 1) elif (intersectWithRect): rs.MoveObject(curRect, [10, 0, 0]) curRectPt = rs.PolylineVertices(curRect) curRectPt = PointsReorder(curRectPt, 1) else: onBoard.append(curRect) rectInOrder.pop(curRectIndex) # reset nesting orient to descending if location is found if nestingOrient == 2: nestingOrient = 1 elif nestingOrient == 4: nestingOrient = 3 break return False # meaning element is more than the board that can nest
def Cargas_Vigas(viga, plD, plB, plC, cob, borda1, borda2, conv): # cob = rs.coercecurve(cob) forces = [] #separando entrada viga em seus elementos (polilinhas) #bs = banzo superior, diag = diagonais, bi = banzo inferior bs, diag, bi = viga #extraindo os nós do banzo superior nos = rs.PolylineVertices(bs) # explodindo polilinhas bs = rs.ExplodeCurves(bs) diag = rs.ExplodeCurves(diag) bi = rs.ExplodeCurves(bi) for i in range(len(nos)): P = 0 if 0 < i < (len(nos) - 1): #banzo inferior P = rs.CurveLength(bi[i]) * plB #banzo superior P += (rs.CurveLength(bs[i - 1]) + rs.CurveLength(bs[i])) / 2 * plB #diagonais P += (rs.CurveLength(diag[i * 2]) + rs.CurveLength(diag[(i * 2) + 1])) * plD #cobertura bs1 = bs[i - 1] bs1 = rs.coerceline(bs1) ptAux1 = bs1.PointAt(.5) bs2 = bs[i] bs2 = rs.coerceline(bs2) ptAux2 = bs2.PointAt(.5) param1 = rs.CurveClosestPoint(cob, ptAux1) param2 = rs.CurveClosestPoint(cob, ptAux2) elif i == 0: #banzo inferior P = rs.CurveLength(bi[i]) * plB #banzo superior P += (rs.CurveLength(bs[i]) / 2) * plB #diagonais P += (rs.CurveLength(diag[i * 2]) + rs.CurveLength(diag[(i * 2) + 1])) * plD #cobertura param1 = 0 bs1 = bs[i] bs1 = rs.coerceline(bs1) ptAux = bs1.PointAt(.5) #teste.append(ptAux) param2 = rs.CurveClosestPoint(cob, ptAux) elif i == (len(nos) - 1): #banzo superior e conector P = (rs.CurveLength(bs[i - 1]) + rs.CurveLength(borda1)) / 2 * plB #conector P += rs.CurveLength(borda2) * plB #cobertura bs1 = bs[i - 1] bs1 = rs.coerceline(bs1) ptAux1 = bs1.PointAt(.5) borda1 = rs.coerceline(borda1) ptAux2 = borda1.PointAt(.5) param1 = rs.CurveClosestPoint(cob, ptAux1) param2 = rs.CurveClosestPoint(cob, ptAux2) if not len(diag) % 2 == 0: #banzo inferior P += rs.CurveLength(bi[i]) * plB #diagonal P += (rs.CurveLength(diag[i * 2])) * plD P_viga = P if not param1 == param2: cobAux = rs.TrimCurve(cob, [param1, param2], False) P_cob = rs.CurveLength(cobAux) * plC P += P_cob P *= conv forces.append(P) return forces, P_viga, P_cob
import rhinoscriptsyntax as rs iterationCount = 2 obj = rs.GetObject("Select a polyline") if rs.IsPolyline(obj): controlPoints = rs.PolylineVertices(obj) # if points: # for point in points: rs.AddPoint(point) for j in range(iterationCount): newControlPoints = [] for i in range(len(controlPoints) - 1): oneQuarterPoint = rs.PointAdd( rs.PointScale(controlPoints[i], 0.75), rs.PointScale(controlPoints[i + 1], 0.25)) newControlPoints.append(rs.CreatePoint(oneQuarterPoint)) threeQuarterPoint = rs.PointAdd( rs.PointScale(controlPoints[i], 0.25), rs.PointScale(controlPoints[i + 1], 0.75)) newControlPoints.append(rs.CreatePoint(threeQuarterPoint)) controlPoints = newControlPoints rs.AddPolyline(controlPoints)
def Laplacemotion(): pl_id = rs.GetObject("Select a polyline", rs.filter.curve, True, True) if pl_id is None: return step = 0.3 length = rs.CurveLength(pl_id) #area = rs.CurveArea(pl_id) newvertices = [] vertices = rs.PolylineVertices(pl_id) n = len(vertices) # one more than the actual number of vertices # calcul du centre de gravite g = (0, 0, 0) for i in range(n - 1): g = rs.VectorAdd(g, vertices[i]) g = rs.VectorScale(g, 1 / (n - 1)) rs.AddPoint(g) if vertices: for i in range(n - 1): # n-1 to avoid the last extra point if i > 0: prev = i - 1 else: prev = n - 2 next = i + 1 # 1. Computing the flow vector (H or V) e_i = rs.VectorSubtract(vertices[next], vertices[i]) e_i_1 = rs.VectorSubtract(vertices[i], vertices[prev]) v_i = rs.VectorUnitize(e_i) v_i_1 = rs.VectorUnitize(e_i_1) #vector = rs.VectorSubtract(e_i, e_i_1) # V = e_i - e_i-1 vector = rs.VectorSubtract(v_i, v_i_1) # H = v_i - v_i-1 # 2. Scaling the vecor # HOW TO CHOOSE THE NORMALIZATION COEFFICIENT FOR THE VECTOR? # This doesn't work in all cases # vector = rs.VectorUnitize(vector) # This doesn't either # vector = rs.VectorScale(vector, step) # We can also square the length of the flow vector # (makes sense if it is H, not V) vector = rs.VectorScale(vector, rs.VectorLength(vector)**2) AddVector(vector, vertices[i]) # draws change vectors newvertices.append(rs.PointAdd(vertices[i], vector)) newvertices.append(newvertices[0]) # first point closes the polyline # newpl_id = rs.AddPolyline(newvertices, pl_id) # replaces previous polyline newpl_id = rs.AddPolyline(newvertices) # keeps previous polyline # Scale to preserve the same length # (otherwise the polyline converges to a point) newlength = rs.CurveLength(newpl_id) scaling = length / newlength #rs.ScaleObject(newpl_id, g, (scaling, scaling, scaling)) # Alternatively, one cane scale it by area #newarea = rs.CurveArea(newpl_id) #scaling_area = area / newarea # rs.ScaleObject(newpl_id, g, (scaling_area, scaling_area, scaling_area)) return (newpl_id)