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)
