PYTHON24HRS

branching algorithm on a surface

DayThree_Branching Algorithm

The Branching Algorithm has been done as a individual assignment, to practice the scripting skills on a project which can be developed also after the workshop.
This algorithm consists of three main logical steps :


01.   generating Points in the boundary between 4 corners of a subSurface


02.   generating a branch by finding the nearest Point from the last nearest Pt found /starting at corners

03.   repeating the branching process to a subdivided Surface, generating a unique branching pattern each time the process is run on a subSurface of a Surface

The next steps in further development will be to adapt the branch lengths and threshold value for finding the nearest point individually for each subSurface by applying a surface attractor.

CODE:


import rhinoscriptsyntax as rs
import random as rnd

#definition for finding a random point between two points
def randomPtbetweenTwoPoints (strPt00,strPt01):
vec01 = rs.VectorCreate(strPt01,strPt00)
vec01 = rs.VectorScale(vec01,rnd.random())
vecPt01 = rs.VectorAdd(strPt00,vec01)
return vecPt01


#------------------------------------------------------------------------------
#SURFACE EVALUATION#

strSrf = rs.GetObject("Pick a surface",8)
#strAttractor = rs.GetObject("Pick an attractor",1)

#get srf domains
listDomainU = rs.SurfaceDomain(strSrf,0)
listDomainV = rs.SurfaceDomain(strSrf,1)

#getdomain lengths
Udivision = 10
Vdivision = 10

domainULength = listDomainU[1]-listDomainU[0]
domainVLength = listDomainV[1]-listDomainV[0]

#get domain Tstep
uStep = domainULength/Udivision
vStep = domainVLength/Vdivision

#declaring empty Main and Sub Lists
mainListPt = []
mainListNormal = []

rs.EnableRedraw(False)

#starting to evaluate with loop
for i in rs.frange(listDomainU[0],listDomainU[1]+0.01,uStep):
subListNormal = []
subListPt = []
for j in rs.frange(listDomainV[0],listDomainV[1]+0.01,vStep):

#evaluate surface for Ptcoordinates
PtCoord = rs.EvaluateSurface(strSrf,i,j)
Pt = rs.AddPoint(PtCoord)

#evaluate surface for normals
normal = rs.SurfaceNormal(strSrf,[i,j])
normal = rs.VectorUnitize(normal)
 
#append the Pts to the subList and the subList to the mainList
subListPt.append(Pt)
mainListPt.append(subListPt)
#------------------------------------------------------------------------------


intIterations = 80
listPtsRandom = []
gen = 16

# running a loop to find the strating corners of each subSurface quad and generating branches
for k in range(0,Udivision):
for l in range (0,Vdivision):

#corners of the quad
strPt00 = mainListPt[k][l]
strPt01 = mainListPt[k+1][l]
strPt02 = mainListPt[k+1][l+1]
strPt03 = mainListPt[k][l+1]

#generating Pts inbetween the four corner of each quad
for i in range(0,intIterations):
PtA = randomPtbetweenTwoPoints(strPt00,strPt01)
PtB = randomPtbetweenTwoPoints(strPt03,strPt02)

ptRandom = randomPtbetweenTwoPoints(PtA,PtB)

listPtsRandom.append(ptRandom)
rs.AddPoints(listPtsRandom)

#generating the branches from each quad corner
listLines = []

ClosestPt = strPt00

ClosestPts = [strPt00,strPt01,strPt02,strPt03]

for i in range(0,gen):
newClosestPts = []
# print "gen", i
for j in range (0,len(ClosestPts)):
# print "point", j
newIndexPt = rs.PointArrayClosestPoint(listPtsRandom,ClosestPts[j])
newClosestPt = listPtsRandom.pop(newIndexPt)
strLine = rs.AddLine(ClosestPts[j],newClosestPt)
listLines.append(strLine)
newClosestPts.append(newClosestPt)
ClosestPts = newClosestPts

strPolyline = rs.JoinCurves(listLines,True)

rs.EnableRedraw(True)