def __toTree(self, arg): """Converts arg to Grasshopper.DataTree""" if isinstance(arg, DataTree[object]): return arg elif isinstance(arg, list): return th.list_to_tree(arg) else: return th.list_to_tree([arg])
def CSVlist(): #prompt the user for a file to import filter = "CSV file (*.csv)|*.csv|*.txt|All Files (*.*)|*.*||" filename = rs.OpenFileName("top_spots", filter) if not filename: return tmplist = list() with open(filename) as csvfile: #with open('top_spots.csv') as csvfile: reader = csv.reader(csvfile) #reader = csv.reader(csvfile, delimiter=',') header_idx = True for row in reader: if header_idx == True: header_idx = False #print(row) continue lat = float(row[0]) long = float(row[1]) alt = float(row[2]) print(lat, long, alt) rs.AddPoint(lat, long, alt) tmplist.append([lat, long, alt]) print(tmplist) b = th.list_to_tree(tmplist) return b
def drawGasket(c1, c2, c3): """ Draw the Apollonian Gasket. """ # RhinoCommon has .TryFitCircleTTT # BUT unfortunately we don't know the necessary t param c4 = getAdjacent(c1, c2, c3) c5 = flip(c1, c2, c3, c4) recurse(c1, c2, c3, c4) recurse(c5, c2, c3, c4) return th.list_to_tree([c4, c5, rec])
def to_rglines(self, ekeys=None, check_ignore_edge_attr=True): if ekeys is None: ekeys = self.edges() lines = [] for u, v in ekeys: if check_ignore_edge_attr and self.edge_attribute((u, v), "ignore_edge"): continue lines.append(self.edge_to_rgline(u, v)) return list_to_tree(lines)
def draw_frames(self, ik_index=None): """Returns the frames of the reachability map. Parameters ---------- ik_index : int, optional If passed, returns only the reachable frames at a given IK index. For a 6-axis industrial robot this index reaches from 0 to 7 (8 solutions). """ from ghpythonlib.treehelpers import list_to_tree if ik_index is None: xframes = [] for frames in self.reachability_map.frames: xframes.append([]) for frame in frames: xframes[-1].append(PrimitiveArtist(frame).draw()) xframes = list_to_tree(xframes) return xframes else: frames, _ = self.reachability_map.reachable_frames_and_configurations_at_ik_index( ik_index) return [PrimitiveArtist(f).draw() for f in frames]
# 4.DIVIDE CURVE //////////////////////// allDivPts = [] # List of lists for i in line_list: linePts = [] # create an empty list to fill each iteration n_crv = i.ToNurbsCurve() div_crv = n_crv.DivideByCount(z, True) linePts.append(div_crv) divPts = [] for p in div_crv: divPts.append(n_crv.PointAt(p)) allDivPts.append(divPts) d = th.list_to_tree(allDivPts) # 5.SIN FUNCTION ////////////////////////// Sin_Vec = [] # list of moved points for i in allDivPts: pt_vec = [] for j in i: sub_v = rg.Vector3d(j) # create vectors from points vec_len = (sub_v).Length # Vector length sin = math.sin(vec_len) # Sin function z_vec = rg.Vector3d(0, 0, sin * u) sin_z = j - z_vec pt_vec.append(sin_z) Sin_Vec.append(pt_vec)
maxList = [] maxValue = 0 for row in reader: if prev is not None and prev != row[0]: maxList.append(maxValue) chain.append(block) block = [] maxValue = 0 # 0- block index, 1 - hash, 12 - input_total (USD) headersWeWant = [0, 1, 12] row[12] = inputToDimension(row[12]) if (row[12]) > 0: # editedRow = [ row[h] for h in headersWeWant ] editedRow = row[12] block.append(editedRow) if row[12] > maxValue: maxValue = row[12] prev = row[0] return (chain, maxList) fileName = r'C:\Users\ko Yiu Chung\Desktop\blockchain morphologies\blockchair2012.csv' chain, maxList = buildCSV(fileName) maxTree = th.list_to_tree(maxList) tree = th.list_to_tree(chain)
pointList2.append(pt2) for k in range(len(a)): ln = rg.Line(a[k],b[k]) lineList.append(ln) for line in lineList: linePts = [] nc = rg.Line.ToNurbsCurve(line) params = rg.Curve.DivideByCount(nc,10,True) for p in params: divPt = rg.Curve.PointAt(nc,p) linePts.append(divPt) allDivPts.append(linePts) d = th.list_to_tree(allDivPts) for list in allDivPts: movedPts = [] for l in list: vector = rg.Vector3d(l) vLenght = vector.Length mDisplacement = math.sin(vLenght) nVector = rg.Vector3d(0,0,mDisplacement) newPt = l - nVector movedPts.append(newPt) allMovedPts.append(movedPts) d = th.list_to_tree(allMovedPts) for list in allMovedPts:
if 0 <= k <= n: ntok = 1 ktok = 1 for t in range(1, min(k, n - k) + 1): ntok *= n ktok *= t n -= 1 return ntok // ktok else: return 0 bc = BezierCurve(pts, textHeight) legend = bc.legend crvPoints = bc.drawCurvePts(nums, u, (len(pts) - 1) / (len(pts) + 1)) u2p = [] u2p.append(bc.calculatePoint(u)) u2p.append(funPosition + Rhino.Geometry.Point3d(u * funLength, 0, 0)) basisFunction = [] for i in range(len(pts)): basisPts = bc.basisFunction(i, funLength, funPosition, nums) basisPtGooList = [] for pt in basisPts: ptGoo = PointGoo(pt) hslColor = Rhino.Display.ColorHSL(i / (len(pts) + 1), 1, 0.5) ptGoo.SetColor(hslColor.ToArgbColor()) basisPtGooList.append(ptGoo) basisFunction.append(basisPtGooList) basisFunction = th.list_to_tree(basisFunction, source=[0, 0])
postLines.append( rg.LineCurve( ptPostList[i], ptPostList[i] + rg.Point3d(0, 0, 1 - zDistancePost - pipeRadius))) if innerRadius > 0: for i in range(0, len(ptPostInnerList)): # lines from helix to axis postLinesInner.append( rg.LineCurve( ptPostInnerList[i], ptPostInnerList[i] + rg.Point3d(0, 0, 1 - zDistancePost - pipeRadius))) # ----------------------------------------------------------- # Output if showWire: _wire = [helix, helixInner, axis] _stp = stepSrfs _rsr = riserSrfs if innerRadius > 0: _rl = [railing, railingInner] _pst = th.list_to_tree([postLines, postLinesInner]) else: _rl = railing _pst = postLines # CAUTION # Using a struct like `out = [foo,bar] can actually # return a list of a list (like `[foo,[bar]]`) # GH does not like that...
for i in range(K + 1, 0, -1): if len(pts) == 1: PPK.append(pts) break elif K < 1: cent_final = rg.Point3d(0, 0, 0) for pt in pts: cent_final = rg.Point3d.Add(pt, cent_final) cent_final = rg.Point3d.Divide(cent_final, len(pts)) PPK.append(cent_final) break pts, idx, centroids = kMeans(pts, K) PPK.append(pts) centhelp = [cnt for cnt in centroids if cnt.IsValid == True] idxhelp = [centhelp.index(centroids[id]) for id in idx] GPK.append(idxhelp) centroids = centhelp K = K - 1 pts = centroids if len(pts) < K: K = len(pts) C = createCmatrix(GPK) C_matrix = th.list_to_tree(C, source=[0, 0]) Points = th.list_to_tree(PPK, source=[0, 0]) GroupsPerK = th.list_to_tree(GPK, source=[0, 0])
# Debugging output c = lines #--------------------------------------------------------------- # Curve points list of lists Pts contains linePts lists Pts = [] linePts = [] for i in range(len(lines)): linePts = [] for j in range(0, y + 1): linePts.append(lines[i].PointAt(j / y)) Pts.append(linePts) # Debugging output d = th.list_to_tree(Pts) #--------------------------------------------------------------- # Zets list of lists zets contains zetsL lists (Mantain strucutre Why not :D) zets = [] zetsL = [] for i in range(len(Pts)): zetsL = [] for j in range(len(Pts[i])): vec = rg.Vector3d(Pts[i][j].X, Pts[i][j].Y, 0) Len = vec.Length zet = math.sin(Len) zetsL.append(zet) zets.append(zetsL)
# values = set(map(lambda x:x[1], pairs)) newpairs = [[y for y in pairs if min(x) < y[1] < max(x)] for x in intervals] # print newpairs return sorted(newpairs, key=lambda x: x[0][1]) srfpairs = [[x, rs.SurfaceAreaCentroid(x)[0][axis], str(x)] for x in srfs] print(srfpairs[0]) # grouped = groupByPosition(srfpairs) # Intervals = th.list_to_tree(intervals) b = th.list_to_tree(groupByPosition(srfpairs)) a = srfs """[summary] """ # from ghpythonlib.componentbase import executingcomponent as component # import Grasshopper, GhPython # import System # import Rhino # import rhinoscriptsyntax as rs # class MyComponent(component): # def RunScript(self, srfs, dist, count, axis): # import rhinoscriptsyntax as rs
Vaip_r = self.getKnotValue( i+p-r ) a[i][r] = (u-Vai_1)/( Vaip_r-Vai_1) pt[i][r] = calculatePoint4d( pt[i-1][r-1],(1-a[i][r]),pt[i][r-1],a[i][r] ) if haveLines == 1: line = Rhino.Geometry.Line( Rhino.Geometry.Point3d(pt[i-1][r-1]), Rhino.Geometry.Point3d(pt[i][r-1]) ) lineGoo = LineGoo(line) hslColor = Rhino.Display.ColorHSL((r-1)/(h+1),1,0.5) lineGoo.SetColor(hslColor.ToArgbColor()) lines[r-1].append(lineGoo) return Rhino.Geometry.Point3d(pt[k-s+1][p-s]), ptsGoo, lines # draw curves and lines def drawNurbsCurvePts(self,nums,u): pts = [] for f in rs.frange( self.knots[0],self.knots[-1],(self.knots[-1]-self.knots[0])/float(nums) ): if f<u: pt, _, _ = nurbs.calculateNurbsPoint(f) pts.append(pt) pointAtU, ptsGoo, deBoorlines = nurbs.calculateNurbsPoint(u,1) return pts,pointAtU, ptsGoo, deBoorlines ### main ### nurbs = DeBoorAlgorithmNurbs(degree, points, weights, knots, isPeriodic, isRational) curvePoints, pointAtU, deBoorPts, colorlines= nurbs.drawNurbsCurvePts(80,u) deBoorlines = th.list_to_tree( colorlines, source=[0,0])
start_time = time.time() maxTime = random.randint(4, 10) # init the agents for i in range(nAgents): pt = randomPoint(i) myAgent = AgentPipe(pt, i, radius) agentsList.append(myAgent) # RUN # stop after random time # TODO: find a method to call isReset so will automatically restart if RUN and ((time.time() - start_time) < maxTime): for agent in agentsList: if agent.stuck: continue # go into next loop agent.update() ghenv.Component.ExpireSolution(True) #------------------------------------------------------------------------------- # Output if verbose: for i in range(len(agentsList)): print(agentsList[i]) _curPositions = [(agentsList[i].pos) for i in range(len(agentsList))] _colors = [(agentsList[i].color) for i in range(len(agentsList))] _allPos = posList _pipes = th.list_to_tree(pipesList, True) _joints = th.list_to_tree(jointsList, True)
# ganz unten tBrep.append(rg.Brep.CreateEdgeSurface([leftLines[d][0], hLineLeft[d][0], midLines[d][0]])) for w in range(1,nHorDiv-1): tBrep.append(rg.Brep.CreateEdgeSurface([leftLines[d][w], dgLineLeft[d][w-1], hLineLeft[d][w-1]])) tBrep.append(rg.Brep.CreateEdgeSurface([midLines[d][w], dgLineLeft[d][w-1], hLineLeft[d][w]])) # ganz oben tBrep.append(rg.Brep.CreateEdgeSurface([leftLines[d][-1], hLineLeft[d][-1], midLines[d][-1]])) # aaand right tBrep.append(rg.Brep.CreateEdgeSurface([rightLines[d][0], hLineRight[d][0], midLines[d][0]])) for w in range(1,nHorDiv-1): tBrep.append(rg.Brep.CreateEdgeSurface([rightLines[d][w], dgLineRight[d][w-1], hLineRight[d][w-1]])) tBrep.append(rg.Brep.CreateEdgeSurface([midLines[d][w], dgLineRight[d][w-1], hLineRight[d][w]])) # ganz oben tBrep.append(rg.Brep.CreateEdgeSurface([rightLines[d][-1], hLineRight[d][-1], midLines[d][-1]])) # pack all together surfTri.append(tBrep) # ----------------------------------------------------------- # OUTPUT _construction = th.list_to_tree([ovalBottom.oval, ovalMid.oval, ovalTop.oval, vertArcsLeft, vertArcsRight, midArcs]) _linework = th.list_to_tree([hLineLeft, hLineRight, dgLineLeft, dgLineRight, hBars, midLines, leftLines, rightLines]) _surfaces = th.list_to_tree([surfQuad, surfTri]) _verboseOval = ovalBottom.baseCrc _verboseConstr = th.list_to_tree([ovalBottomBx, ovalBottomDivPts, ovalMidDivPts, ovalTopDivPts, vertArcs]) _verbosePoints = th.list_to_tree([midArcPt, leftArcPt, rightArcPt])
# Facade between two ellipses ellipse1 = ellipses[i] ellipse2 = ellipses[i + 1] # Divide the ellipses in equal lines and obtain the points ## Tangent of the points loc1 = rg.Curve.DivideByCount(ellipse1, divisionV, True) loc2 = rg.Curve.DivideByCount(ellipse2, divisionV, True) # Get the points points1 = [] points2 = [] for i, j in zip(loc1, loc2): points1.append(ellipse1.PointAt(i)) points2.append(ellipse2.PointAt(j)) # Create panels for i in range(divisionV): pt1 = points1[i - 1] pt2 = points1[i] pt3 = points2[i] pt4 = points2[i - 1] panel = rg.NurbsSurface.CreateFromCorners(pt1, pt2, pt3, pt4) panels.append(panel) # ----------------------------------------------------------- # Output _curves = th.list_to_tree(ellipses) _panels = panels
def RunScript(self, File, String, Mode): # GeoJSON string to dict geoJsonString = "" # Takes either file path if File: file = open(File, "r") geoJsonString = file.read() geoJsonString = geoJsonString.replace("'", '"') # or the string directly elif String: geoJsonString = String.replace("'", '"') geoJson = json.loads(geoJsonString) # Lists of lists containing attributes of all features # convert into DataTree at the end _type = [] _geometry = [] _keys = [] _values = [] # iter trough all features features = geoJson["features"] for feature in features: # Points if feature['geometry']['type'] == 'Point': type = ["Point"] geometry = [] keys = [] values = [] coord = feature['geometry']['coordinates'] point = rs.CreatePoint(coord) geometry.append(point) for key in feature['properties'].keys(): keys.append(key) for value in feature['properties'].values(): values.append(value) _type.append(type) _geometry.append(geometry) _keys.append(keys) _values.append(values) # Multipoints if feature['geometry']['type'] == 'MultiPoint': type = ["MultiPoint"] geometry = [] keys = [] values = [] for coord in feature['geometry']['coordinates']: point = rs.CreatePoint(coord) geometry.append(point) for key in feature['properties'].keys(): keys.append(key) for value in feature['properties'].values(): values.append(value) _type.append(type) _geometry.append(geometry) _keys.append(keys) _values.append(values) # LineStrings if feature['geometry']['type'] == 'LineString': type = ["LineString"] geometry = [] keys = [] values = [] points = [] for coord in feature['geometry']['coordinates']: points.append(rs.CreatePoint(coord)) polyline = rg.PolylineCurve(points) geometry.append(polyline) for key in feature['properties'].keys(): keys.append(key) for value in feature['properties'].values(): values.append(value) _type.append(type) _geometry.append(geometry) _keys.append(keys) _values.append(values) # MultiLineStrings if feature['geometry']['type'] == 'MultiLineString': type = ["MultiLineString"] geometry = [] keys = [] values = [] for list in feature['geometry']['coordinates']: points = [] for coord in list: points.append(rs.CreatePoint(coord)) polyline = rg.PolylineCurve(points) geometry.append(polyline) for key in feature['properties'].keys(): keys.append(key) for value in feature['properties'].values(): values.append(value) _type.append(type) _geometry.append(geometry) _keys.append(keys) _values.append(values) # Polygons if feature['geometry']['type'] == 'Polygon': type = ["Polygon"] geometry = [] keys = [] values = [] for list in feature['geometry']['coordinates']: points = [] for coord in list: points.append(rs.CreatePoint(coord)) shape = rg.PolylineCurve(points) geometry.append(shape) for key in feature['properties'].keys(): keys.append(key) for value in feature['properties'].values(): values.append(value) _type.append(type) _geometry.append(geometry) _keys.append(keys) _values.append(values) # MultiPolygons if feature['geometry']['type'] == 'MultiPolygon': if Mode: # split Multipolygons in branches as if they were Polygons for polygon in feature['geometry']['coordinates']: type = ["Polygon (from MultiPolygon)"] geometry = [] keys = [] values = [] for list in polygon: points = [] for coord in list: points.append(rs.CreatePoint(coord)) shape = rg.PolylineCurve(points) geometry.append(shape) for key in feature['properties'].keys(): keys.append(key) for value in feature['properties'].values(): values.append(value) _type.append(type) _geometry.append(geometry) _keys.append(keys) _values.append(values) else: # add another subbranch for every Polygon in Multipolygon type = ["Multipolygon"] geometry = [] keys = [] values = [] for shape in feature['geometry']['coordinates']: polygon = [] for list in shape: points = [] for coord in list: points.append(rs.CreatePoint(coord)) outline = rg.PolylineCurve(points) polygon.append(outline) geometry.append(polygon) for key in feature['properties'].keys(): keys.append(key) for value in feature['properties'].values(): values.append(value) _type.append(type) _geometry.append(geometry) _keys.append(keys) _values.append(values) #Turn lists of lists into DataTrees for output Type = th.list_to_tree(_type) Geometry = th.list_to_tree(_geometry) Keys = th.list_to_tree(_keys) Values = th.list_to_tree(_values) return (Type, Geometry, Keys, Values)
import System import clr clr.AddReference("Grasshopper") import rhinoscriptsyntax as rs from Grasshopper import DataTree import Rhino.Geometry as rg import ghpythonlib.components as ghc import ghpythonlib.treehelpers as ght a = [] # Checks whether the input geometry is brep, mesh or curve # If it is a brep or mesh, the input height is used to create the contour, in # the given height # Curves are then projected onto world xy-plane for i in range (len(geometry)): if (geometry[i].ToString().split(".")[-1]).Contains("Brep"): a.append(geometry[i].CreateContourCurves(geometry[i],rs.MovePlane(rs.WorldXYPlane(),[0,0,height]))) elif (geometry[i].ToString().split(".")[-1]).Contains("Mesh"): a.append(geometry[i].CreateContourCurves(geometry[i],rs.MovePlane(rs.WorldXYPlane(),[0,0,height]))) elif (geometry[i].ToString().split(".")[-1]).Contains("Curve"): a.append(geometry[i].ProjectToPlane(geometry[i],rs.WorldXYPlane())) a = ght.list_to_tree(a) a.Flatten()
else: # size by lightness size = (gridSize / 2) * currentLit nSides = int(round(3 * currentLit)) if geomForm == 1: # CIRCLE tGeo.append(rg.Circle(Pts[g][w], size)) elif geomForm == 4: # SQUARE tGeo.append( rg.Rectangle3d(rg.Plane(Pts[g][w], rg.Vector3d.ZAxis), rg.Interval(-size, size), rg.Interval(-size, size))) elif geomForm > 2 & geomForm != 4: # POLYGON tGeo.append( rg.PolylineCurve( rg.Polyline.CreateInscribedPolygon( rg.Circle(Pts[g][w], size), geomForm))) else: # -1 # POLYGON BY SIZE tGeo.append( rg.PolylineCurve( rg.Polyline.CreateInscribedPolygon( rg.Circle(Pts[g][w], size), SIDES[nSides]))) Geometry.append(tGeo) # ----------------------------------------------------------- # OUTPUT _pts = th.list_to_tree(Pts) _geom = th.list_to_tree(Geometry) _origCol = th.list_to_tree(ColorOrig) _newCol = th.list_to_tree(ColorNew) _BCol_ = 0 if nFX == 1 else 1 # stream filter for coloring the geometry
srf = rg.Brep.CreateFromLoft(curves, rg.Point3d.Unset, rg.Point3d.Unset, rg.LoftType(), False) # Create the mesh meshVertex = [] meshVertexL = [] mesh = rg.Mesh() for i in range(Width): for j in range(Heigth): mesh.Vertices.Add(Pts[i][j]) # Function that converts the position in the matrix (r,c) to an index def rc_to_index(co, ro): index = co * Heigth + ro return index for i in range(1, Width): for j in range(0, Heigth - 1): mesh.Faces.AddFace(rc_to_index(i, j), rc_to_index(i, j + 1), rc_to_index(i - 1, j + 1), rc_to_index(i - 1, j)) ######DEBUGING###### #previous = th.list_to_tree(mat0) #final = th.list_to_tree(mat) Grid = th.list_to_tree(Pts) print("Finish") print(mat0)
#---------------------------------------------------------- #4.- divide curve - allDivPts = [] #this will be a list of lists for line in lineList: linePts = [] #create an empty list to fill each iteration curve = line.ToNurbsCurve() params = rg.Curve.DivideByCount(curve, 10, True) for p in params: divPt = rg.Curve.PointAt(line, p) linePts.append(divPt) allDivPts.append( linePts) #append the list of points PER LINE to another list d = th.list_to_tree( allDivPts) #this is how you output nested lists to gh trees #---------------------------------------------------------- #5.- apply sine function to points allMovedPts = [] #list of all moved points for list in allDivPts: movedPts = [] #list of moved points for pt in list: vector = rg.Vector3d(pt) vLen = vector.Length zVec = rg.Vector3d(0, 0, math.sin(vLen)) newPt = pt + zVec movedPts.append(newPt) allMovedPts.append(movedPts)
curve_point = ghc.EvaluateCurve(segment, 0.5)[0] curve_point, _ = ghc.Move(curve_point, normal[0][0] * distance) return [curve_point] # Standardize surfaces rooms = [standardize_surfaces(room) for room in rooms] # Convert brep to polylines room_segments = [ghc.DeconstructBrep(room)[1] for room in rooms] room_polylines = [ghc.JoinCurves(segments, True) for segments in room_segments] # Main script for i, room_polyline in enumerate(room_polylines): connect = set() for segment in room_segments[i]: points = create_outside_points(segment) P.append(points) if type(points) in [list, tuple]: for p in points: for j, pl in enumerate(room_polylines): if j not in connect: relation, _ = ghc.PointInCurve(p, pl) if relation > 0: connect.add(j) connectivity.append(list(connect)) # Convert outputs to trees R = ght.list_to_tree(rooms) P = ght.list_to_tree(P) graph = ght.list_to_tree(connectivity)
import rhinoscriptsyntax as rs import ghpythonlib.treehelpers as th import scriptcontext as sc import Rhino as rc import System.Guid as Guid import Grasshopper as gh layers = rs.LayerNames() def groupByPosition(pairs): newpairs = [[y for y in pairs if y[1] == x] for x in layers] return sorted(newpairs, key=lambda x: x[0][1]) crvpairs = [[x, rs.ObjectLayer(x)] for x in crvs] b = th.list_to_tree(groupByPosition(crvpairs)) """[summary] """
def RunScript(self, Run, Reset, Threshold, Mesh, LocalPlaneDepth, GlobalPlaneStrength, LocalPlaneStrength, EdgeLengthStrength): PLANEMODE = 0 # DEFINE STICKY KEYS FOR STORAGE OF PERISTENT DATA BETWEEN ITERATIONS -- ig = str(self.InstanceGuid) vKey = ig + "___VERTICES" eKey = ig + "___ORIGINALEDGELENGTHS" lKey = ig + "___LOCALVIEWPLANES" cKey = ig + "___CONVERGED" iKey = ig + "___ITERATIONS" # MESH INPUT CHECKING -------------------------------------------------- if not Mesh: rml = Grasshopper.Kernel.GH_RuntimeMessageLevel.Warning self.AddRuntimeMessage(rml, "Missing Mesh input...") return None elif Mesh.IsClosed: rml = Grasshopper.Kernel.GH_RuntimeMessageLevel.Warning self.AddRuntimeMessage(rml, "Boundary is " + "closed! This operation only makes sense " + "with open meshes....") return None # DEFAULT VALUES ------------------------------------------------------- # set default value for threshold if not Threshold: Threshold = 1e-3 # define global plane strength default if GlobalPlaneStrength == None: GlobalPlaneStrength = 0.25 # define local plane strength default if LocalPlaneStrength == None: LocalPlaneStrength = 0.75 # strength for edgelength preservation if EdgeLengthStrength == None: EdgeLengthStrength = 0.5 # RESET HANDLING AND INITIALIZATION ------------------------------------ if Reset or (not vKey in st or not eKey in st or not lKey in st or not cKey in st or not iKey in st) or st[iKey] == 0: self.Message = "Reset" st[vKey] = None st[eKey] = None st[lKey] = None st[cKey] = None st[iKey] = 0 # initialize vertices st[vKey] = list(Mesh.Vertices.ToPoint3dArray()) # initialize original edgelengths originaledgelengths = [] for i, v in enumerate(st[vKey]): ci = list(Mesh.TopologyVertices.ConnectedTopologyVertices(i)) cd = [v.DistanceTo(cv) for cv in [st[vKey][j] for j in ci]] originaledgelengths.append(cd) if originaledgelengths: st[eKey] = originaledgelengths # PAUSED CONDITION ----------------------------------------------------- elif not Run and cKey in st and st[cKey] == False: ghenv.Component.Message = "Paused" # CONVERGED CONDITION elif cKey in st and st[cKey] == True: ghenv.Component.Message = "Converged" vertices = st[vKey] EdgeLengths = st[eKey] Iterations = st[iKey] # CREATE RELAXED MESH OUTPUT ------------------------------------------- RelaxedMesh = Mesh.Duplicate() for i, vertex in enumerate(st[vKey]): RelaxedMesh.Vertices.SetVertex(i, vertex) # COMPUTE AVERAGE MESH NORMAL ------------------------------------------ meshnormals = RelaxedMesh.Normals avgNormal = Rhino.Geometry.Vector3d(meshnormals[0]) for i, normal in enumerate(meshnormals): if i == 0: continue avgNormal += Rhino.Geometry.Vector3d(normal) avgNormal = avgNormal / len(meshnormals) avgNormal.Unitize # COMPUTE AVERAGE MESH VERTEX ------------------------------------------ avgMvx = vertices[0] for i, v in enumerate(vertices[1:]): avgMvx += v avgMvx = avgMvx / len(vertices) # BUILD GLOBAL PLANE FROM AVERAGE MESH NORMAL AND VERTEX --------------- GlobalFitPlane = Rhino.Geometry.Plane(avgMvx, avgNormal) # BUILD LOCALFITPLANES ------------------------------------------------- if lKey in st and st[lKey] != None and st[iKey] > 0: LocalFitPlanes = st[lKey] elif lKey in st and st[lKey] == None: LocalFitPlanes = self.ComputeLocalPlanes(Mesh, LocalPlaneDepth) st[lKey] = LocalFitPlanes # RUN CONDITION -------------------------------------------------------- if Run and not st[cKey]: # set message to component self.Message = "Running" LocalFitPlanes = self.ComputeLocalPlanes(RelaxedMesh, LocalPlaneDepth) st[lKey] = LocalFitPlanes # COMPUTATION OF MOVES --------------------------------------------- if PLANEMODE == 0: totalMoves, collisionCounts = self.ComputeMoves(RelaxedMesh, vertices, GlobalFitPlane, GlobalPlaneStrength, LocalPlaneStrength, EdgeLengthStrength, lKey, eKey) elif PLANEMODE == 1: totalMoves, collisionCounts = self.ComputeQuaternionMoves(RelaxedMesh, vertices, GlobalFitPlane, GlobalPlaneStrength, LocalPlaneStrength, EdgeLengthStrength, lKey, eKey) # EXECTUTION OF MOVES ---------------------------------------------- for i, c in enumerate(vertices): if collisionCounts[i] != 0.0: st[vKey][i] += totalMoves[i] / collisionCounts[i] RelaxedMesh.Vertices.SetVertex(i, st[vKey][i]) # PARTICLE VELOCITY ------------------------------------------------ totalvelocity = 0 for i, v in enumerate(totalMoves): totalvelocity += v.Length if totalvelocity <= Threshold: st[cKey] = True else: st[cKey] = False # set iteration counter in sticky st[iKey] += 1 # update the component self.updateComponent() # DEFINE OUTPUTS ------------------------------------------------------- # LocalFitPlanes LocalFitPlanes = th.list_to_tree(st[lKey]) # AveragePlaneDeviation AveragePlaneDeviation = 0 for i, vertex in enumerate(st[vKey]): AveragePlaneDeviation += abs(GlobalFitPlane.DistanceTo(vertex)) AveragePlaneDeviation = AveragePlaneDeviation / len(st[vKey]) # return outputs if you have them; here I try it for you: return (Iterations, RelaxedMesh, GlobalFitPlane, LocalFitPlanes, AveragePlaneDeviation)
import ghpythonlib.treehelpers as th import Rhino class ToRhino(): def __init__(self): pass layerTree = [list() for _ in layernames] for i in range(len(layernames)): objs = Rhino.RhinoDoc.ActiveDoc.Objects.FindByLayer(layernames[i]) if objs: geoms = [obj.Geometry for obj in objs] layerTree[i].extend(geoms) layerTree = th.list_to_tree(layerTree, source=[0, 0]) a = layerTree
extensions.append(rg.LineCurve(rg.Line(pnt1, tan1, dist1))) return extensions def clean_obstacles(curve, other_curves): oc = [] for other_curve in other_curves: distances = [ gh.Distance(curve.PointAtStart, other_curve.PointAtStart), gh.Distance(curve.PointAtStart, other_curve.PointAtEnd), gh.Distance(curve.PointAtEnd, other_curve.PointAtStart), gh.Distance(curve.PointAtEnd, other_curve.PointAtEnd) ] close = [True if d <= EPS else False for d in distances] if not any(close): oc.append(other_curve) return oc C.Flatten() curves = ght.tree_to_list(C) all_extensions = [] for i, curve in enumerate(curves): obstacles = clean_obstacles(curve, curves) print(i, len(obstacles), "/", len(curves)) curve_extensions = extend_to_collision(curve, obstacles) all_extensions.extend(curve_extensions) curves.extend(all_extensions) C = ght.list_to_tree(curves)
midpts[p][v] ] tl.append(rg.Polyline(resultOuter).ToNurbsCurve()) outerLines.append(tl) # for visual clues how this is made global verbose verbose = segments, midpts, startpts, endpts, sdl1, sdl2, lxlPt return innerLines, outerLines # ----------------------------------------------------------- # gets the base polygon tiling base = th.list_to_tree(tiling(radiusOct, Ex, Ey)) _basetiling = base # Flatten it and make it a list again # Note: We have to call `tiling` again, because I didn't found an easy way to make # a deep copy of a tree in Python (and `Flatten()` is a mutable command) # and I want to retain the octogons and rectangles in different branches tiles = th.list_to_tree(tiling(radiusOct, Ex, Ey)) tiles.Flatten() tiles = th.tree_to_list(tiles) _iStarPatIn = th.list_to_tree(hankins(tiles, contactAngle)[0]) _iStarPatOut = th.list_to_tree(hankins(tiles, contactAngle)[1]) _verbose = th.list_to_tree(verbose)
#Add if it fits intersections = len(pair_sets[k].intersection(pair_set)) if intersections >= 3: pair_sets[k] = pair_sets[k].union(pair_set) continue # Create new if it did not fit and end is reached if k == len(pair_sets)-1: pair_sets.append(pair_set) # Go through existing sets combining them if they have enough intersection for i in range(len(pair_sets)): for j in range(i): intersections = len(pair_sets[i].intersection(pair_sets[j])) if intersections >= 3: pair_sets[i] = pair_sets[i].union(pair_sets[j]) pair_sets[j] = set() pair_sets = [x for x in pair_sets if len(x)!=0] # Ready output room_lists = [list(x) for x in list(pair_sets)] a, b = [], [] for s in pair_sets: sub_a = [] sub_b = [] for x in s: sub_a.append(x[0]) sub_b.append(x[1]) a.append(sub_a) b.append(sub_b) a = ght.list_to_tree(a) b = ght.list_to_tree(b)
#Define empty Square list and parameters rectangleList = [] amountSquares = 5 initialSquareSize = 1 squaresOffset = 2 #Generate square of grid #iterate trough X axis for x in range(gridAmountX): #iterate trough Y axis for y in range(gridAmountY): tempRectangleList = [] #iterate for rectangle from each point for size in range(initialSquareSize,amountSquares*squaresOffset+initialSquareSize, squaresOffset): #Starting Point point = rs.CreatePoint(x*gridSizeX, y*gridSizeY, 0) #Just to viz pointList.append(point) #Correct the origin point for each rectangle (It's not domained, it starts from the 0,0) translation = rs.XformTranslation([-size/2, -size/2, 0]) correctedPoint = rs.TransformObject(point, translation, True) currentPlane = rs.CreatePlane(correctedPoint, (1,0,0), (0,1,0)) #Create all te rectangles from each point tempRectangleList.append(rs.AddRectangle(currentPlane, size, size)) #Appends each sets of rectangle to the tree rectangleList.append(tempRectangleList) #Converts the list of list to a GH Tree offsetRectangle = th.list_to_tree(rectangleList)