SCA_v3

#gui
# Maya Python SCA v2_02   10/26/2017
# Maya Python SCA v2_03   4/6/2018 - Update: Added ability to use particles to generate structure
print " SCA  "
class leafToCrv:
    leafToCrv = []


from pymel.core import *
import copy as c
import pymel.core.datatypes as dt
import maya.api.OpenMaya as om
import maya.cmds as cmds
import math
import random as r
import time
import bTree_util2
reload(bTree_util2)


width = 0
height = 0
treeCenter = 0
bLength = 0
start = time.clock()
def grpr(name):
    g = ls(name)
    if g:
        delete(g)
    g = group(n=name,em=1)
    return g
def getDist(p1,p2):
    dist = defAttr.srt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2 + (p1[2] - p2[2])**2)
    return dist
def getCenter(p1,p2, offset):
    return (p1 + -p1*offset) + p2*offset

def adder(testPF, t):
    return (testPF[0]+t[0] , testPF[1]+t[1] ,testPF[2]+t[2])
def subber(testPF, t):
    return (testPF[0]-t[0] , testPF[1]-t[1] ,testPF[2]-t[2])
def setMag(testP, amnt):
    return (testP[0]*amnt , testP[1]*amnt ,testP[2]*amnt) # scaler
def getMag(testP):
    return math.sqrt(testP[0]**2 + testP[1]**2 + testP[2]**2) #magnitude
def getMag2(testP):
    return defAttr.srt(testP[0]**2 + testP[1]**2 + testP[2]**2) #magnitude
def makeNormal(vector, mag):
    return (vector[0]/mag ,vector[1]/mag,vector[2]/mag) #normalize
def scaler(testP, amnt):
    return (testP[0]*amnt , testP[1]*amnt ,testP[2]*amnt) # scaler
def scalerD(testP, amnt):
    return (testP[0]/amnt , testP[1]/amnt ,testP[2]/amnt) # scaler

class defAttr:
    gotRoots = []
    toParticles = []
    srt = math.sqrt
    doParticles = 0
    toCrvs = []
    showGrowingCheckValue = 0
    doProgress = 0
    branchCountTotal = 0
    leafCountTotal = 0
    combineCrvs = 0
class Leaf:
    def __init__(self):
        self.leafObj = []
        self.reached = False
        self.shown = 0
        self.pos = om.MVector(r.uniform(-width+treeCenter[0],+width+treeCenter[0]),r.uniform(-height+treeCenter[1],+height+treeCenter[1]),r.uniform(-width+treeCenter[2],+width+treeCenter[2]))
        self.reachedBranch = []
        self.leafParticleID = 0
        self.foundBranches = []
        self.sPos = self.pos
        self.isFound = 0
        self.sObj = self.leafObj
        self.oFound = 0
        self.Found = 0




    def show(self):
        if showGrow == 1:
            ll = polyCube(d=.1,w=.1,h=.1)[0]
            self.leafObj = ll
            move(ll,self.pos)
            parent(ll, leavesGrp)
            refresh(cw=1)
        if showGrow == 2:
            ll = cmds.spaceLocator(p=self.pos)[0]
            setAttr(ll+".overrideEnabled", 1)
            setAttr(ll+".overrideColor", 14)# 13 = red, 14 = green
            self.leafObj = ll

class Branch:
    def __init__(self, papa, pos, dirV):
        self.pos = pos
        self.papa = papa
        self.dirV = dirV
        self.origDir = dirV
        self.count = 0
        self.shown = 0
        self.branchObj = []
        self.bLen = bLength
        self.bCurrent = []
        self.bFound = 0
        self.bRoot = 0
        self.parents = []
        self.doRemove = 0
        self.isAlive = 1

        self.sPos = self.pos
        self.isFound = 0
        self.sObj = self.branchObj
        self.oList = []

        self.p1 = (0,0,0)#p1#pointPosition(s.cv[0], w=1)
        self.p2 = (0,0,0)#p2#pointPosition(s.cv[1], w=1)
        self.toCurve = []
        self.found = 0
        self.found2 = 0


    def reset(self):
        self.dirV = self.origDir
        self.count = 0
    def next(self):
        nextDir = om.MVector(self.dirV * self.bLen)
        #nextDir = scaler(self.dirV, self.bLen)
        if self.bRoot:
            #nextDir = scaler(self.dirV, 2)
            #normalMag = getMag(nextDir)
            #nextDir = makeNormal(nextDir, normalMag)
            nextDir = om.MVector(self.dirV * 2)
            om.MVector.normalize(nextDir)
        nextPos = om.MVector(self.pos + nextDir)
        #nextPos = adder(self.pos, nextDir)
        nextBranch = Branch(self.pos, nextPos, nextDir)
        return nextBranch
    def show(self, i):
        if self.papa:

            if defAttr.showGrowingCheckValue:
                crv = cmds.curve(p = [self.papa, self.pos], d = 1, n = "crv_"+str(i-1))
                bToParent.append(crv)


            self.p1 = [self.papa[0], self.papa[1], self.papa[2]]
            self.p2 = [self.pos[0], self.pos[1], self.pos[2]]
            defAttr.toCrvs.append(self)
            """
            if self.p2 == self.p1: # if curve parent is found mark
                self.toCurve.append(self.p1)
                self.found = 1
            """


            if defAttr.doParticles:
                branchParticlesR.append(.1)
                branchParticles.append(self.pos)

                defAttr.toParticles.append(self.pos)
                extraP = getCenter(self.pos,self.papa, .25)
                defAttr.toParticles.append(extraP)
                extraP = getCenter(self.pos,self.papa, .5)
                defAttr.toParticles.append(extraP)
                extraP = getCenter(self.pos,self.papa, .75)
                defAttr.toParticles.append(extraP)

            self.parents.append(self.pos)
            cmds.select(cl=1)
        else:
            lastPapa = 0,0,0


def makeLeaves():
    allTime = time.clock()
    defAttr.doParticles = makeParticlesCheck.getValue()

    defAttr.combineCrvs = combineCrvCheck.getValue()

    defAttr.showGrowingCheckValue = showGrowingCheck.getValue()
    defAttr.toCrvs = []
    defAttr.doProgress = showProgressCheck.getValue()
    global leavesObjGrp, lastPapa, oneCurve, newLeafArray, makeParticles,leafEnd, rootEnd, leavesGrp,  testElapsed, bToParent, branchParticles, branchParticlesR,width, height, treeCenter, bLength, bLength,showGrow, maxDist, minDist, maxItterations, width, height, subItters, treeCenter, directionNoise
    progress = 0
    bToParent = []
    branchParticles = []
    branchParticlesR = []
    leaves = []
    branches = []
    branchPosArray = []
    newLeafArray = []

    ########################################################################################################################
    ########################################################################################################################
    ########################################################################################################################
    ## Main variables ##
    ####################
    maxItterations = 10000 # used for catchers in while loops
    ####################
    if showLeavesCheck.getValue():
        showGrow = 2
    else:
        showGrow = 0 # 0 = dont update and only draw curves, 1 = draw leaves and trunk dynamicly update, 2 = particles/cuves
    scatterType = 0 # 0 volume, 1 surface, 2 both

    leavesGrp = grpr("leaves_grp")
    leavesObjGrp = grpr("leaves_obj_grp")
    newGrp = grpr("combinedCrvs_grp")
    leafPosArray = []
    # Make all the leaves
    #scat = ls("scatter1")
    #scatCombined = ls("combined_leaves_arrayx")
    leaves = []
    rootList = []

    width = float(treeWidth.getText())
    depth = float(treeDepth.getText())
    height = float(treeHeight.getText())
    treeCenter = [float(baseX.getText()),float(baseY.getText()),float(baseZ.getText())]
    """
    width = 200
    depth = 200
    height = 200
    treeCenter = [0, 0, 0]
    """
    checkUseScatter = useSoupCheck.getValue()
    if checkUseScatter:
        scat = ls(soupObj.getText())
        if not soupObj:
            print "Get soup Object"
        else:
            try:
                leafAmnt = getAttr(scat[0].maxNumberOfPoints)
                boundingBox = listConnections(scat[0]+".inGeometry")
                boundingBox = xform(boundingBox, bbi=1, q=1)
            except:
                leafAmnt = getAttr(scat[0]+".count")
                boundingBox = xform(scat[0], bbi=1, q=1)

    else:
        scat = soup().create('scatter')
        leafBall = polyCube(n = "leaf_ball",w = width, d = depth, h = height, ch=0)[0]
        move(leafBall, treeCenter)
        polySmooth(leafBall, ch=0)
        parent(leafBall,leavesGrp)
        rename(scat[0], "leaves_scatter")

        boundingBox = xform(leafBall, bbi=1, q=1)

        scat = ls("leaves_scatter")
        parent(scat,leavesGrp)
        leafBall.getShape().worldMesh[0] >> scat[0].inGeometry
        leafBall.worldMatrix[0] >> scat[0].inWorldMatrix
        setAttr(leafBall.visibility, 0)
        leafAmnt = int(leafAmntA.getText())
        setAttr(scat[0].maxNumberOfPoints, leafAmnt)
    setAttr(scat[0].visibility, 0)
    try:
        setAttr(scat[0].pointDensity, leafAmnt*10)
        scatPosArray = cmds.getAttr(cmds.listRelatives(str(scat[0]),s=1)[0]+".outPositionPP")
    except:
        scatPosArray = cmds.getAttr(cmds.listRelatives(str(scat[0]),s=1)[0]+".position")
    #scatPosArray = getAttr(scat[0].getShape().outPositionPP)
    leafPosArray = []
    for i in range(0,len(scatPosArray)):
        leafPosArray.append(om.MVector(scatPosArray[i]))


    if defAttr.doProgress:
        progress = 1 #################################################  PROGRESS  #######################

    globalScale = float(GlobalScaleTxtAmnt.getText())

    maxDist = float(searchMaxAmnt.getText()) * globalScale#28
    minDist = float(searchMinAmnt.getText()) * globalScale#14
    bLength = float(searchLenAmnt.getText()) * globalScale#1
    directionNoise = float(searchNoiseAmnt.getText()) * globalScale#.01


    if makeMeshCheck.getValue():
        makeParticles = True
    else:
        makeParticles = False
    useScatter = True
    ####################

    ####################
    ####################
    ########################################################################################################################
    ########################################################################################################################
    ########################################################################################################################
    if progress:
        progWin2 = progressWindow(isInterruptable=1, t= "Growing...", min = 0, max = len(leafPosArray))

    directionArray = []
    pi = 1
    for i in leafPosArray:
        if progress:
            progressWindow(progWin2, edit=True, pr = pi)
        l = Leaf()

        if scat:
            l.pos = i
            l.sPos = i
            directionArray.append(i)
        else:
            directionArray.append(l.pos)
        leaves.append(l)
        pi += 1
    toParent = []

    for l in leaves:
        l.show()
        l.shown = 1
        if showGrow == 2:
            toParent.append(l.leafObj)

    parent(leavesObjGrp, leavesGrp)
    parent(toParent, leavesObjGrp)
    select(cl=1)

    if defAttr.gotRoots:
        sl = defAttr.gotRoots
    else:
        sl = selected()

    rootTime = time.clock()
    iA = 0
    if len(sl) >= 1:
        print "Creating roots from selected"
        for s in sl:
            rootPos = om.MVector(s.getTranslation())
            leafAverage = om.MVector(reduce(lambda x, y: x + y, directionArray) / len(directionArray))
            dirV = om.MVector(rootPos - leafAverage)
            root = Branch(None, rootPos, -dirV)
            branches.append(root)
            current = root
            found = False
            catcher = maxItterations*.1
            while not found:
                if catcher == 0:
                    print "Breaking"
                    break
                cLMax = 1000
                for l in leaves:
                    dist = getDist(current.pos, l.pos)
                    if dist < cLMax:
                        newDirV = om.MVector(current.pos - l.pos)
                        root.dirV = -newDirV
                        cLMax = dist
                    if dist < maxDist:
                        found = True
                if not found:
                    current.bRoot = 1
                    randAdd = om.MVector(r.uniform(-directionNoise*.1,directionNoise*.1),r.uniform(-directionNoise*.1,directionNoise*.1),r.uniform(-directionNoise*.1,directionNoise*.1))###
                    current.dirV = om.MVector(current.dirV + randAdd)
                    root = current.next()
                    current = root
                    branches.append(current)
                catcher -= 1
                iA += 1
    else:
        print "Creating root"
        rootPos = om.MVector(0,0,0)
        dirV = om.MVector(reduce(lambda x, y: x + y, directionArray) / len(directionArray))
        root = Branch(None, rootPos, dirV)
        branches = [root]
        current = root
        found = False
        catcher = maxItterations*.1
        while not found:
            if catcher == 0:
                print "Breaking"
                break
            for l in leaves:
                dist = getDist(current.pos,l.pos)
                if dist < maxDist:
                    found = True
            if not found:
                current.bRoot = 1
                randAdd = om.MVector(r.uniform(-directionNoise*.1,directionNoise*.1),r.uniform(-directionNoise*.1,directionNoise*.1),r.uniform(-directionNoise*.1,directionNoise*.1))###
                current.dirV = om.MVector(current.dirV + randAdd)
                root = current.next()
                current = root
                branches.append(current)
            catcher -= 1
            iA += 1
    rootTimeElapsed = (time.clock() - rootTime)
    #print "Step one time:", rootTimeElapsed, iA
    i = 1
    defAttr.toParticles = []
    for b in branches:
        b.show(i)
        i += 1
    #print "Starting grow"
    noBMax = 0
    #leaves = self.leaves
    #branches = self.branches
    branchesSave = []
    #leafPosArray = self.leafPosArray
    newB = 0
    endItter = 0
    iA = 0
    refreshTracker = 0

    lT = 0



    useOcTree = useOcTreeCheck.getValue()


    if useOcTree:
        oTreeTime = time.clock()
        #### ocTree
        subDepth = int(subMaxAmnt.getText())
        subMaxCount = float(subMaxCountAmnt.getText())
        distBuffAmntMultiplier = float(distBuffAmnt.getText())
        oShowGrow = int(showOcTreeCheck.getValue())
        doRefresh = int(showOcTreeGrowCheck.getValue())
        bTree_util2.constructTree(boundingBox, leaves, subDepth, subMaxCount ,oShowGrow, doRefresh)
        ####
        ocTimeElapsed = (time.clock() - oTreeTime)
        print "OcTree Creation:", ocTimeElapsed
        doRefresh = 5





    #bFresh = 0
    for i in range(0,maxItterations):
        #bFresh += 1
        #print "Itteration ", i
        if progress:
            progressWindow(progWin2, edit=True, pr = lT+1)
            if progressWindow(progWin2, query=1, isCancelled=1 ):
                print "killed at", i+1
                break
        itterTime = time.clock()
        bl = len(branches)
        lb = len(leaves)
        if not newB:
            if endItter >= 1:
                break
            endItter += 1
        newB = 0
        refreshTime = time.clock()
        if refreshTracker == 2:
            cmds.refresh(cw=1)
            refreshTracker = 0
        leafLoopItterTime = time.clock()

        if useOcTree:

            #print "branch length ", len(branches)
            #if doRefresh == 10 or bFresh < 5:
            #doRefresh = 0
            leafList = []
            bList = []
            for b in branches:
                if not b.doRemove:
                    #spaceLocator(p=b.pos)
                    closeList = []
                    closeList = bTree_util2.getClose(b.pos, maxDist * distBuffAmntMultiplier, 0)
                    if len(closeList) > 0:
                        bList.append(b)
                    for l in closeList:
                        #spaceLocator(p=l.sPos)
                        if not l.reached:
                            if not l.oFound:
                                leafList.append(l)
                                #l.foundBranches.append(b)
                                l.oFound = 1

            #doRefresh += 1
            #bFresh += 1
            lt = 0
            for l in leafList:

                lt += 1
                closestBranch = False
                record = 10000
                for b in bList:
                    #if not b.doRemove:
                    dist = getDist(b.pos,l.sPos)
                    if dist < minDist:
                        l.reached = True
                        lT += 1
                        closestBranch = False
                        break
                    if dist > maxDist:
                        pass
                    elif closestBranch == False or dist < record:
                        #spaceLocator(p = l.pos)
                        closestBranch = [b]
                        record = dist

                if closestBranch != False:
                    defAttr.leafCountTotal += 1
                    """
                    testPF = setMag(testPF, 10)
                    mPF = getMag(testPF)
                    testPF = makeNormal(testPF, mPF)
                    minusV = (1,2,3)
                    testPF = subber(testPF, minusV)
                    """
                    #newDir = subber(l.sPos, closestBranch[0].pos)
                    newDir = om.MVector(l.sPos - closestBranch[0].pos)
                    om.MVector.normalize(newDir)
                    #normalMag = getMag(newDir)
                    #newDir = makeNormal(newDir, normalMag)
                    #closestBranch[0].dirV =   adder(closestBranch[0].dirV ,newDir)
                    closestBranch[0].dirV = om.MVector(closestBranch[0].dirV + newDir )
                    closestBranch[0].count = closestBranch[0].count + float(1)
                iA += 1
            leafLoopElapsed = (time.clock() - leafLoopItterTime)
            leafLoopAfterItterTime = time.clock()
            # Delet reached leaves
            #if doRefresh == 10 or bFresh < 5:
            for l in leafList[::-1]:
                l.oFound = 0
                if l.reached:
                    l.Found = 1
                    if l.leafObj:
                        cmds.setAttr(l.leafObj+".visibility",0)


            #print lt, len(leafList)
            """
            for l in leafList:
                closestBranch = False
                record = 10000
                for b in l.foundBranches:
                    dist = getDist(b.pos,l.pos)
                    if dist < minDist:
                        l.reached = True
                        lT += 1
                        closestBranch = False
                        break
                    if dist > maxDist:
                        pass
                    elif closestBranch == False or dist < record:
                        #spaceLocator(p = l.pos)
                        closestBranch = [b]
                        record = dist

                if closestBranch != False:
                    newDir = om.MVector(l.pos - closestBranch[0].pos)
                    om.MVector.normalize(newDir)
                    closestBranch[0].dirV = om.MVector(closestBranch[0].dirV + newDir )
                    closestBranch[0].count = closestBranch[0].count + float(1)
                iA += 1
            leafLoopElapsed = (time.clock() - leafLoopItterTime)
            leafLoopAfterItterTime = time.clock()
            for l in leaves[::-1]:
                if l.reached:
                    l.Found = 1
                    if l.leafObj:
                        cmds.setAttr(l.leafObj+".visibility",0)
                else:
                    l.oFound = 0
            """



        else:
            lt = 0
            for l in leaves:
                if not l.Found:
                    lt += 1
                    closestBranch = False
                    record = 10000
                    for b in branches:
                        if not b.doRemove:
                            dist = getDist(b.pos,l.pos)
                            if dist < minDist:
                                l.reached = True
                                lT += 1
                                closestBranch = False
                                break
                            if dist > maxDist:
                                pass
                            elif closestBranch == False or dist < record:
                                #spaceLocator(p = l.pos)
                                closestBranch = [b]
                                record = dist

                    if closestBranch != False:
                        newDir = om.MVector(l.pos - closestBranch[0].pos)
                        om.MVector.normalize(newDir)
                        closestBranch[0].dirV = om.MVector(closestBranch[0].dirV + newDir )
                        closestBranch[0].count = closestBranch[0].count + float(1)
                    iA += 1
            leafLoopElapsed = (time.clock() - leafLoopItterTime)
            leafLoopAfterItterTime = time.clock()
            # Delet reached leaves
            for l in leaves[::-1]:
                if l.reached:
                    l.Found = 1
                    if l.leafObj:
                        cmds.setAttr(l.leafObj+".visibility",0)


            #print lt
        ii = 1
        rBranches = []
        bTrack = 0
        for b in branches[::-1]:
            if not b.doRemove:
                if b.count > 0:
                    bl += 1
                    bTrack += 1
                    defAttr.branchCountTotal += 1

                    #print "here", b.dirV, b.count
                    #newDirV = scalerD(b.dirV, b.count)
                    #print newDirV
                    #normalMag = getMag2(newDirV)
                    #newDirV = makeNormal(newDirV, normalMag)
                    #randAdd = (r.uniform(-directionNoise,directionNoise),r.uniform(-directionNoise,directionNoise),r.uniform(-directionNoise,directionNoise))
                    #print b.dirV
                    #b.dirV = adder(newDirV, randAdd)

                    bVector = om.MVector(b.dirV)
                    newDirV = om.MVector(bVector / b.count)
                    om.MVector.normalize(newDirV)
                    randAdd = om.MVector(r.uniform(-directionNoise,directionNoise),r.uniform(-directionNoise,directionNoise),r.uniform(-directionNoise,directionNoise))###
                    b.dirV = om.MVector(newDirV + randAdd)###

                    newBranch = b.next()
                    branches.append(newBranch)
                    branchesSave.append(newBranch)
                    branchPosArray.append(b.pos)

                    b.isAlive = 1

                    if not b.shown:
                        b.show(ii)
                        newB = 1
                        b.shown = 1
                else:
                    #rBranches.append(b)
                    b.doRemove = 1
                    #b.isAlive = 0
            ii += 1
            b.reset()
        """
        for b in rBranches:
            if b.doRemove == 1:
                #b.isAlive = 0
                branches.remove(b)
        """
        refreshTracker += 1
        #refreshTimeElapsed = (time.clock() - refreshTime)
        #itterElapsed = (time.clock() - itterTime)
        #leafLoopAfterItterTimeElapsed = (time.clock() - leafLoopAfterItterTime)

        #print "Itteration time:", itterElapsed
        #print "       Leaf loop time:", leafLoopElapsed
        #print " After Leaf loop time:", leafLoopAfterItterTimeElapsed
        #print "         Refresh time:", refreshTimeElapsed
    if progress:
        progressWindow(progWin2, endProgress=1)
    print "Total itterations", iA
    parent(bToParent, leavesGrp)



    if makeParticlesCheck.getValue():
        ll = cmds.nParticle(p=defAttr.toParticles)[0]
        #parent(ll, defAttr.popGrp)
        setAttr(ll+".radiusScaleInput", 5)
        setAttr(ll+".radius", 1)
        setAttr(ll+".radiusScaleInputMax", 100)
        setAttr(ll+".colorInput", 5)
        setAttr(ll+".colorInputMax", 100)
        setAttr(ll+".collide", 0)
        setAttr(ll+".selfCollide", 0)
        setAttr(ll+".forcesInWorld", 0)
        setAttr(ll+".ignoreSolverWind", 1)
        setAttr(ll+".ignoreSolverGravity", 1)

        if makeParticles:
            ppp = ls(ll)[0]
            reMesh = createNode("mesh", n=ppp+"_reMeshed")
            rename(reMesh,ppp+"_reMeshed")
            #parent(reMesh[0],defAttr.popGrp)
            # connections
            ppp.outMesh >> reMesh.inMesh
            setAttr(ll+".threshold", 0.01)
            setAttr(ll+".meshMethod", 3)
            setAttr(ll+".meshSmoothingIterations", 5)
            setAttr(ll+".maxTriangleResolution", 200)
            setAttr(ll+".meshTriangleSize", 0.2)
            setAttr(ll+".velocityPerVertex", 0)
            setAttr(ll+".colorPerVertex", 1)

    #return leaves, branches, branchPosArray,leavesObjGrp,branchesSave
    if defAttr.combineCrvs:
        leavesGrpDeletCheck = ls("leaves_obj_grp")
        if leavesGrpDeletCheck:
            delete(leavesObjGrp)
        if defAttr.showGrowingCheckValue:
            delete(leavesGrp)
        crvMakeTime = time.clock()
        def getC(c):
            maxSearch = 0
            papa = c
            toCrvList = []
            while papa:
                toCrvList.append(papa.p1)
                if papa.toCurve:
                    papa = papa.toCurve[0]
                    papa.found2 = 1
                else:
                    toCrvList.append(papa.p2)
                    break
                if maxSearch > 1000:
                    break
                maxSearch += 1
            return toCrvList
        checkList = []
        i = 0
        if len(defAttr.toCrvs) > 0:
            maxSearch = 0
            toCrvList = []
            restCurves = defAttr.toCrvs
            papa = restCurves[0]
            i = 0
            search = 1
            toParent = []
            for crv in restCurves:# loop through curves
                if not crv.found:
                    for crvcrv in restCurves: # loop throuch all cruves for all curves
                        if not crvcrv.found:
                            if crv.p2 == crvcrv.p1: # if curve parent is found mark
                                crv.toCurve.append(crvcrv)
                                crv.found = 1
                i += 1
            for c in restCurves:
                if not c.found2:
                    toC = getC(c)
                    crv = cmds.curve(p = toC, d = 1)
                    toParent.append(crv)
                    crvPiv = pointPosition(crv+".cv[0]", w=1)
                    move(crv+".scalePivot", crvPiv)
                    move(crv+".rotatePivot", crvPiv)
                    move(crv, 0,0,0,rpr=1)
                    makeIdentity(crv,apply=1,t=1,r=1 ,s=1 ,n=0 ,pn=1)
                    move(crv, crvPiv)
                    i += 1

        parent(toParent,newGrp)
        select(cl=1)
        crvMakeTimeElapsed = (time.clock() - crvMakeTime)

    ###
    makeLocatorsGo = makeLocatorsCheck.getValue()
    print makeLocatorsGo, "HERE"
    if makeLocatorsGo:
        makeLocators()
    ###

    allTimeElapsed = (time.clock() - allTime)
    #print "Curve creating time: ", crvMakeTimeElapsed
    print "Branch calculation total: ", defAttr.branchCountTotal
    print "Leaf calculation total: ",defAttr.leafCountTotal
    print "Total time: ", allTimeElapsed

def useSoupChecker():# enable and disable using soup
    soupCheck = useSoupCheck.getValue()
    attrList = [leafAmntA]#, searchMaxAmnt, searchMinAmnt, searchLenAmnt, searchNoiseAmnt
    if soupCheck:
        for attr in attrList:
            textField(attr, en=0, e=1)
        #treeShapeLayout = frameLayout(l = "Tree Shape", cll=1, cl=0)
        frameLayout(treeShapeLayout, e=1, vis=0, cl=1)
        textField(soupObj, en=1, e=1)
        button(soupObjGet,en=1, e=1)
    else:
        for attr in attrList:
            textField(attr, en=1, e=1)

        frameLayout(treeShapeLayout, e=1, vis=1, cl=1)
        textField(soupObj, en=0, e=1)
        button(soupObjGet,en=0, e=1)

def runMain():
    print "running"
    """
    branchPosArray=[]
    # main "Program"
    grow()
    parent(bToParent, leavesGrp)
    select(cl=1)
    leavesGrpDeletCheck = ls("leaves_obj_grp")
    if leavesGrpDeletCheck:
        delete(leavesObjGrp)
    select(cl=1)
    elapsed = (time.clock() - start)
    elapsed = elapsed
    print "\n","Run time total:", elapsed
    """
def getScat():
    sl = selected()
    soupObj.setText(str(sl[0]))

def getRoots():
    sl = selected()
    if len(sl) > 0:
        defAttr.gotRoots = sl
    else:
        defAttr.gotRoots = []

def removeRoots():
    defAttr.gotRoots = []


def resetPiv():
    sl = selected()
    for s in sl:
        if nodeType(s.getShape()) == "nurbsCurve":
            p = pointPosition(s.cv[0], w=1)
            move(s+".scalePivot", p)
            move(s+".rotatePivot", p)
            move(s, 0,0,0,rpr=1)
            makeIdentity(s,apply=1,t=1,r=1 ,s=1 ,n=0 ,pn=1)
            move(s, p)

from pymel.core import *
def crvToParticles():
    import maya.OpenMaya as om
    sl = om.MSelectionList() # create list for selection
    om.MGlobal.getActiveSelectionList(sl) # load list
    selectionIter = om.MItSelectionList(sl)# create ittorator for list
    cvPos = []
    while not selectionIter.isDone():
        crvObj = om.MObject()# Crv object
        cvPosArray = om.MPointArray()# create array to store cv points
        crvPath = om.MDagPath() # create dag path
        selectionIter.getDagPath(crvPath, crvObj)# fill dag path, with crvObj
        crvFn = om.MFnNurbsCurve(crvPath)# functions for curves
        crvFn.getCVs(cvPosArray, om.MSpace.kWorld) # get cvs from cvFn, and add to cvPosArray
        selectionIter.next()# move on to next item in selection
        for i in range(cvPosArray.length()):# loop through length of curve Position array
            x = cvPosArray[i][0]
            y = cvPosArray[i][1]
            z = cvPosArray[i][2]
            pos = [x,y,z]
            cvPos.append(pos)
    ll = mc.nParticle(p=cvPos)[0]
    mc.setAttr(ll+".radiusScaleInput", 5)
    mc.setAttr(ll+".radius", 2.5)
    mc.setAttr(ll+".radiusScaleInputMax", 35)
    mc.setAttr(ll+".colorInput", 5)
    mc.setAttr(ll+".colorInputMax", 35)
    mc.setAttr(ll+".collide", 0)
    mc.setAttr(ll+".selfCollide", 0)
    mc.setAttr(ll+".forcesInWorld", 0)
    mc.setAttr(ll+".ignoreSolverWind", 1)
    mc.setAttr(ll+".ignoreSolverGravity", 1)


def slCrvLen():
    sl = selected()
    len = float(crvLenAmnt.getText())
    select(cl=1)
    for s in sl:
        if nodeType(s.getShape()) == "nurbsCurve":
            cl = arclen(s)
            if cl < len:
                select(s, add=1)

def randoSl():
    sl = selected()
    select(cl=1)
    for s in sl:
        rt = r.randint(0,2)
        if rt == 2:
            select(s,add=1)

def getCrvTips():
    from pymel.core import *
    import maya.OpenMaya as om
    sl = om.MSelectionList() # create list for selection
    om.MGlobal.getActiveSelectionList(sl) # load list
    selectionIter = om.MItSelectionList(sl)# create ittorator for list
    cvPos = []
    while not selectionIter.isDone():
        crvObj = om.MObject()# Crv object
        cvPosArray = om.MPointArray()# create array to store cv points
        crvPath = om.MDagPath() # create dag path
        selectionIter.getDagPath(crvPath, crvObj)# fill dag path, with crvObj
        crvFn = om.MFnNurbsCurve(crvPath)# functions for curves
        crvFn.getCVs(cvPosArray, om.MSpace.kWorld) # get cvs from cvFn, and add to cvPosArray
        selectionIter.next()# move on to next item in selection
        crvP = cvPosArray[cvPosArray.length()-1]
        x = crvP[0]
        y = crvP[1]
        z = crvP[2]
        pos = [x,y,z]
        cvPos.append(pos)
    slList = []
    for p in cvPos:
        l = spaceLocator()
        move(l, p)
        slList.append(l)
    select(slList,add=1)


def crvToMesh():
    #from pymel.core import *
    #import maya.OpenMaya as om
    #import maya.cmds as mc
    #import time
    start = time.clock()
    sl = selected()
    def grprO(name):
        g = ls(name)
        if g:
            delete(g)
        g = group(n=name,em=1)
        return g
    crvToMeshGrp = grprO("crvsToMeshGrp")
    crvToMeshStrokesGrp = grprO("crvsToMeshStrokeGrp")
    parent(crvToMeshStrokesGrp, crvToMeshGrp)

    defaultMatSG = ls("initialShadingGroup")

    i = 0
    toParent = []
    toParentS = []
    for s in sl:
        sampleAmnt = int(arclen(s))
        srk = stroke(n = s+"_Stoke_"+str(i))
        toParentS.append(srk)
        bsh = createNode("brush", n = s+"_Brush_"+str(i))

        s.worldSpace[0] >> srk.pathCurve[0].curve
        bsh.outBrush >> srk.brush
        connectAttr("time1.outTime", bsh+".time")
        srkSp = srk.getShape()
        setAttr(srkSp.displayPercent, 100)
        setAttr(srkSp.pathCurve[0].samples, 24)
        setAttr(srkSp.useNormal, 0)
        setAttr(srkSp.minimalTwist, 1)
        # Paint effects settings
        sh = srkSp
        scl = arclen(s)
        sB = bsh
        end = (scl*.2)
        sW = scl*.02
        sG = scl*.025
        if end >= .1:
            end = .1
        if sG <= .5:
            sG = .5
        if sW >= .1:
            sW = .1
        if sW <= 1:
            sW = 1
        setAttr(sB.brushWidth, sW)
        setAttr(sB.globalScale, sG)
        setAttr(sh.sampleDensity, .5)
        extrudeList = [["1",.1, 1],["2",1, end]]
        x = 2
        ii = 0
        for ex in extrudeList:
            setAttr(sh+".pressureScale[{0}].pressureScale_FloatValue".format(ii), ex[1])
            setAttr(sh+".pressureScale[{0}].pressureScale_Position".format(ii), ex[2])
            setAttr(sh+".pressureScale[{0}].pressureScale_Interp".format(ii), 2)
            x += 1
            ii += 1
        setAttr(str(sh)+".pressureMap1", 2)
        setAttr(sh+".pressureMin1",.1)
        setAttr(sh+".pressureMax1",1)
        setAttr(sh+".meshVertexColorMode",1)
        setAttr(sh+".meshQuadOutput",1)
        #setAttr "strokeShape2.meshVertexColorMode" 1;
        #setAttr "strokeShape2.meshQuadOutput" 1;
        #ii += 1


        # Make Mesh
        newMeshT = mc.createNode("transform", n = s+"_Mesh"+str(i))
        newMesh = mc.createNode("mesh", n = s+"_MeshShape"+str(i), p = s+"_Mesh"+str(i))
        toParent.append(newMeshT)
        connectAttr(str(srk)+".worldMainMesh", str(newMesh)+".inMesh")
        sets(defaultMatSG[0], e=1, forceElement = newMesh)


    parent(toParent, crvToMeshGrp)
    parent(toParentS, crvToMeshStrokesGrp)
    setAttr(crvToMeshStrokesGrp.visibility, 0)
    print time.clock()- start


def lookAt(base, target, up=[0,1,0]):
    x = omm.MVector(target[0]-base[0], target[1]-base[1], target[2]-base[2])
    x.normalize()
    z = x ^ omm.MVector(-up[0], -up[1], -up[2])
    z.normalize()
    y = x ^ z
    y.normalize()
    m = omm.MMatrix()
    l = [x.x, x.y, x.z, 0, y.x, y.y, y.z, 0, z.x, z.y, z.z, 0, 0, 0, 0, 1]
    omm.MScriptUtil.createMatrixFromList(l, m)
    r = omm.MTransformationMatrix(m).eulerRotation() * 57.2958
    return r[0], r[1], r[2]

def makeLocators():
    lctrGrp = grpr("lctr_grp")
    toParentL = []
    for p in defAttr.toCrvs:
        l = spaceLocator()
        move(l, p.pos)
        newV = p.pos - p.dirV
        aimToRotate =  lookAt(p.pos, newV)
        mc.rotate(aimToRotate[0],aimToRotate[1],aimToRotate[2],str(l))
        toParentL.append(l)
    parent(toParentL, lctrGrp)



win = window(title= "Vein Generator", s=1, w=200, ip=1, tlb=1)
mainLayout = rowColumnLayout(nc=1)
#guiLable = text("Vein creator")



attributeLayout = rowColumnLayout(nc=1, p = mainLayout )

combineCrvCheck = checkBox(l = "Combine Crvs", v=1)
showLeavesCheck = checkBox(l = "Show Leaves")
useSoupCheck = checkBox(l = "Use Scatter", cc = Callback(useSoupChecker), v=0)
makeParticlesCheck = checkBox(l = "Make Particles")
makeMeshCheck = checkBox(l = "Make Mesh")
showGrowingCheck = checkBox(l = "Show Growing", v=1)
showProgressCheck = checkBox(l = "Show Proggress Bar", v=0)
makeLocatorsCheck = checkBox(l = "Make Locators", v=0)

soupLayout = rowColumnLayout(nc=2, p = attributeLayout)
soupObj = textField(tx = "scatter1", p = soupLayout,en=0)
soupObjGet = button(l = "Get", p=soupLayout,en=0, command=Callback(getScat))

text(" ",p=attributeLayout)

#useSoupObj = textFieldButtonGrp(tx="scatter1")##,w=10, cw=[2,1]


#runAllBtn = button(l="Create Leaves",p = attributeLayout, command=Callback(makeLeaves))
"""
width = 200
depth = 200
height = 200
treeCenter = [0, 0, 0]
"""

treeShapeLayout = frameLayout(l = "Tree Shape", cll=1, cl=1)
leafAmntTxt = text("leaf amount", p = treeShapeLayout)
leafAmntA = textField(tx = "1000", p = treeShapeLayout)

treeShapeSubLayout = rowColumnLayout(nc=2, p = treeShapeLayout, w=10)

treeWidthTxt = text(l= "Width", p = treeShapeSubLayout)
treeWidth = textField(tx = "50", p = treeShapeSubLayout)
treeHeightTxt = text(l= "Height", p = treeShapeSubLayout)
treeHeight = textField(tx = "100", p = treeShapeSubLayout)
treeDepthTxt = text(l= "Depth", p = treeShapeSubLayout)
treeDepth = textField(tx = "50", p = treeShapeSubLayout)

treeBaseTxt = text(l= "Base Position", p = treeShapeSubLayout)
treeBaseInfoTxt = text(l= "X Y Z", p = treeShapeLayout)
baseLocation = rowColumnLayout(nc=3, p = treeShapeLayout)
baseX = textField(tx = "0", p = baseLocation, w=40)
baseY = textField(tx = "75", p = baseLocation, w=40)
baseZ = textField(tx = "0", p = baseLocation, w=40)
##
GlobalScaleTxt = text("Global Scale", p = attributeLayout)
GlobalScaleTxtAmnt = textField(tx = "1", p = attributeLayout)

searchAmntTxt = text("Search Distance", p = attributeLayout)
searchAmntMaxTxt = text("Max", p = attributeLayout)
searchMaxAmnt = textField(tx = "25", p = attributeLayout)

searchAmntMinTxt = text("Min", p = attributeLayout)
searchMinAmnt = textField(tx = "5", p = attributeLayout)

searchAmntLenTxt = text("Branch Length", p = attributeLayout)
searchLenAmnt = textField(tx = "2", p = attributeLayout)

searchAmntNoiseTxt = text("Noise", p = attributeLayout)
searchNoiseAmnt = textField(tx = ".1", p = attributeLayout)
text(" ",p=mainLayout)
getRootObjs = button(l = "Get Roots",p=mainLayout, command=Callback(getRoots))
removeRootObjs = button(l = "Remove Roots",p=mainLayout, command=Callback(removeRoots))

runAllBtn = button(l=" Grow ",p=mainLayout,bgc = [0,1,0], command=Callback(makeLeaves))


###
optionsLayout = frameLayout(l = "Options", cll=1, cl=1, p = mainLayout)

crvOptionsLayout = frameLayout(l = "Crv Utils", cll=1, cl=1, p = optionsLayout)

slCrvLength = button(l=" Select Crv Length ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(slCrvLen))
crvLenAmnt = textField(tx = "10", p = crvOptionsLayout)

runRandoSl = button(l=" Reduce Selection ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(randoSl))

resetCrvPivot = button(l=" ResetPivot ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(resetPiv))
crvToParticels = button(l=" Crv to Particles ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(crvToParticles))
crvTipsToLctrs = button(l=" Crv tips to Locators ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(getCrvTips))

crvtoLocatorBtn = button(l=" Crv Mesh ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(crvToMesh))



ocTreeOptionsLayout = frameLayout(l = "Octree", cll=1, cl=1, p = optionsLayout)
useOcTreeCheck = checkBox(l = "Use OcTree", v=1, p=ocTreeOptionsLayout)
subMaxAmntTxt = text("subMax", p = ocTreeOptionsLayout)
subMaxAmnt = textField(tx = "20", p = ocTreeOptionsLayout)
subMaxCountAmntTxt = text("subMaxCoun", p = ocTreeOptionsLayout)
subMaxCountAmnt = textField(tx = "200", p = ocTreeOptionsLayout)
subMaxCountAmntTxt = text("Distance Buffer Multiplier", p = ocTreeOptionsLayout)
distBuffAmnt = textField(tx = "1", p = ocTreeOptionsLayout)
showOcTreeCheck = checkBox(l = "Show OcTree", v=0, p=ocTreeOptionsLayout)
showOcTreeGrowCheck = checkBox(l = "Show Grow", v=0, p=ocTreeOptionsLayout)
win.show()