lab/grow.py

# This code is called when instances of this SOP cook.
#scaleFactor = node.parm("scaleFactor").eval()

import random
import os
import sys
from os import path

node = hou.pwd()
geo = node.geometry()


# the "seed"
point=geo.createPoint()
pointers=[point]
initVector=hou.Vector3([0,0,0])

# init the point attributes to store the values in
NAttr = geo.addAttrib(hou.attribType.Point, "N", initVector)
BAttr = geo.addAttrib(hou.attribType.Point, "Branch", 0)
GAttr = geo.addAttrib(hou.attribType.Point, "Generation", 0)
BNAttr = geo.addAttrib(hou.attribType.Point, "BranchPoint", 0)
BTNAttr = geo.addAttrib(hou.attribType.Point, 'NormalizedPosition', 0.0)
DAttr = geo.addAttrib(hou.attribType.Point, 'Diameter', 1.0)




point.setAttribValue("N", hou.Vector3([0,1,0]))
point.setAttribValue("Branch", 0)
point.setAttribValue('NormalizedPosition', 0.5)



defaultGrp=geo.createPointGroup('name')
defaultGrp.add(point)

#print point.attribValue("N")

def duplicatePoint(p):
    # hmm. maybe there is sth like this already, but i missed it...
    dupe=geo.createPoint()
    dupe.setPosition(p.position())
    allAttr=geo.pointAttribs()
    for i in allAttr:
        #print i
        holder=None
        holder=p.attribValue(i)
        #print holder
        dupe.setAttribValue(i, holder)
    return dupe

#dupe=duplicatePoint(point)
    

def tropism(pt,vector,factor):
    '''Move point towards another point, as in growing towards a light source (sun)
       or a food source (roots)
    '''
    P = pt.position()
    pt.setPosition( P + 1 * vector)

def moveAlongNormal(pt,factor):
    P = pt.position()
    #P = hou.Vector3(P)
    # be careful - this returns a value you cant simply add to P, must convert it to a hou.Vector3
    N = pt.attribValue("N")
    N = hou.Vector3(N)
    pt.setPosition( P + (1*factor) * N )
    
def createRandomVector():
    rx = (random.random()-0.5)*2
    ry = (random.random()-0.5)*2
    rz = (random.random()-0.5)*2
    return hou.Vector3([rx,ry,rz])

def addNoiseToNormal(pt,factor):
    N = pt.attribValue("N")
    N = hou.Vector3(N)
    rx = (random.random()-0.5)*2
    ry = (random.random()-0.5)*2
    rz = (random.random()-0.5)*2
    rvec = hou.Vector3([rx*factor,ry*factor,rz*factor])
    newN = rvec + 1 * N
    pt.setAttribValue("N", newN)
    return pt

def rotateNormal(pt,factor):
    N = pt.attribValue("N")
    N = hou.Vector3(N)
    rx = (random.random()-0.5)*2
    ry = (random.random()-0.5)*2
    rz = (random.random()-0.5)*2
    rvec = hou.Vector3([rx*factor,ry*factor,rz*factor])
    newN = rvec + 1 * N
    pt.setAttribValue("N", newN)
    return pt

def getPointsByAttribValue(attr,val):
    plist=[]
    for p in geo.iterPoints():
        if p.attribValue(attr)==val:
            plist.append(p)
    return plist

def getHighestNumericAttrVal(points,attr):
    val=0.0
    for p in points:
        v=float(p.attribValue(attr))
        if v > val:val=v
    return val



branchgroups=[]

branchNum=0

def step(pointers):
    updatedPointers=[]
    for p in pointers:
        n=p.attribValue("N")
        
        #print 'pointer is point w/ # ' + str(p.number())

        newP=duplicatePoint(p)
        #print 'copy is point w/ # ' + str(newP.number())

        updatedPointers.append(newP)
        newP.setAttribValue('BranchPoint',newP.attribValue('BranchPoint')+1)

        # Should we branch?
        # TODO allow multiple branches at once
        rnd=random.random()
        if rnd > 0.7:
            
            
            # Dirty, find a better way soon!
            global branchNum
            branchNum+=1

            global treeInfo
            #treeInfo['totalbranches']+=1

            #print 'branch'
            branchP=duplicatePoint(p)
            
            branchP.setAttribValue('BranchPoint',0)

            b=branchP.attribValue('Branch')
            branchP.setAttribValue('Branch',branchNum)
            #branchP.setAttribValue('Branch',b+1)
            
            
            g=branchP.attribValue('Generation')
            branchP.setAttribValue('Generation',g+1)
            updatedPointers.append(branchP)
                 
        newP=rotateNormal(newP,0.4)    
        # now move along normal
        moveAlongNormal(newP,1)
        v=hou.Vector3(0,1,1)
        tropism(newP,v,1)
        newP.setAttribValue('Diameter',newP.attribValue('Diameter')*0.9 )
    return updatedPointers

    
x=step(pointers)

for arsch in range(15):
    x = step(x)



# until there is a better way, 'postprocess' the tree to gain info that is not present at runtime.


def postprocess():
    tInfo={}
    '''
    for n in range(0,branchNum):
        for p in geo.iterPoints():
            #print p
            print p.attribValue('BranchPoint')
            #if p.attribValue('Branch') == n:
            #    print p.attribValue('BranchPoint')
    '''
    for p in geo.iterPoints():
        curBranch=p.attribValue('Branch')
        tInfo['branch']=curBranch


print '[[[[[[[[[[***]]]]]]]]]]'
totalBranches=int(getHighestNumericAttrVal(geo.iterPoints(),'Branch'))
#print geo.points()

for i in range(0,totalBranches):
    # go through all branches
    max=0
    for p in getPointsByAttribValue('Branch',i):
        v=p.attribValue('BranchPoint')
        if v>max: max=v
    for p in getPointsByAttribValue('Branch',i):
        bp=p.attribValue('BranchPoint')
        print max
        print bp
        try:
            relpos=float(bp)/float(max)
        except:
            relpos=0
        #p.setAttribValue('NormalizedPosition',1)
        p.setAttribValue('NormalizedPosition', float(relpos))



        print '---'
        #print bp + max

    #print 'branch {0} points {1}'.format(i,max)
    


# TODO and thoughts
# in addition to the branch 'id' we need a distance of each point of a branch towards it's parent.
# useful: how many 'levels' are we away from the main parent? > point needs to have parent id, increment on branch
# roots