API tools faq
paste
cwisbg

Space Colonization v0.1

cwisbg
Sep 12th, 2016
451
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 39.23 KB | None | 0 0
raw download clone embed print report
  1. #gui
  2. # Maya Python SCA v2_01   6/9/2017
  3. print " SCA  "
  4. class leafToCrv:
  5.     leafToCrv = []
  6.  
  7.  
  8. from pymel.core import *
  9. import copy as c
  10. import pymel.core.datatypes as dt
  11. import maya.api.OpenMaya as om
  12. import maya.cmds as cmds
  13. import math
  14. import random as r
  15. import time
  16. import bTree_util2
  17. reload(bTree_util2)
  18.  
  19.  
  20. width = 0
  21. height = 0
  22. treeCenter = 0
  23. bLength = 0
  24. start = time.clock()
  25. def grpr(name):
  26.     g = ls(name)
  27.     if g:
  28.         delete(g)
  29.     g = group(n=name,em=1)
  30.     return g
  31. def getDist(p1,p2):
  32.     dist = defAttr.srt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2 + (p1[2] - p2[2])**2)
  33.     return dist  
  34. def getCenter(p1,p2, offset):
  35.     return (p1 + -p1*offset) + p2*offset  
  36.      
  37. def adder(testPF, t):
  38.     return (testPF[0]+t[0] , testPF[1]+t[1] ,testPF[2]+t[2])  
  39. def subber(testPF, t):
  40.     return (testPF[0]-t[0] , testPF[1]-t[1] ,testPF[2]-t[2])  
  41. def setMag(testP, amnt):
  42.     return (testP[0]*amnt , testP[1]*amnt ,testP[2]*amnt) # scaler
  43. def getMag(testP):
  44.     return math.sqrt(testP[0]**2 + testP[1]**2 + testP[2]**2) #magnitude
  45. def getMag2(testP):
  46.     return defAttr.srt(testP[0]**2 + testP[1]**2 + testP[2]**2) #magnitude
  47. def makeNormal(vector, mag):
  48.     return (vector[0]/mag ,vector[1]/mag,vector[2]/mag) #normalize
  49. def scaler(testP, amnt):
  50.     return (testP[0]*amnt , testP[1]*amnt ,testP[2]*amnt) # scaler  
  51. def scalerD(testP, amnt):
  52.     return (testP[0]/amnt , testP[1]/amnt ,testP[2]/amnt) # scaler  
  53.          
  54. class defAttr:
  55.     gotRoots = []  
  56.     toParticles = []
  57.     srt = math.sqrt
  58.     doParticles = 0
  59.     toCrvs = []
  60.     showGrowingCheckValue = 0
  61.     doProgress = 0
  62.     branchCountTotal = 0
  63.     leafCountTotal = 0
  64. class Leaf:
  65.     def __init__(self):
  66.         self.leafObj = []
  67.         self.reached = False
  68.         self.shown = 0
  69.         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]))
  70.         self.reachedBranch = []
  71.         self.leafParticleID = 0
  72.         self.foundBranches = []
  73.         self.sPos = self.pos
  74.         self.isFound = 0
  75.         self.sObj = self.leafObj
  76.         self.oFound = 0
  77.         self.Found = 0
  78.        
  79.  
  80.        
  81.        
  82.     def show(self):
  83.         if showGrow == 1:
  84.             ll = polyCube(d=.1,w=.1,h=.1)[0]
  85.             self.leafObj = ll
  86.             move(ll,self.pos)
  87.             parent(ll, leavesGrp)
  88.             refresh(cw=1)
  89.         if showGrow == 2:
  90.             ll = cmds.spaceLocator(p=self.pos)[0]
  91.             setAttr(ll+".overrideEnabled", 1)
  92.             setAttr(ll+".overrideColor", 14)# 13 = red, 14 = green
  93.             self.leafObj = ll
  94.  
  95. class Branch:
  96.     def __init__(self, papa, pos, dirV):
  97.         self.pos = pos
  98.         self.papa = papa
  99.         self.dirV = dirV
  100.         self.origDir = dirV
  101.         self.count = 0
  102.         self.shown = 0
  103.         self.branchObj = []
  104.         self.bLen = bLength
  105.         self.bCurrent = []
  106.         self.bFound = 0
  107.         self.bRoot = 0
  108.         self.parents = []
  109.         self.doRemove = 0
  110.         self.isAlive = 1
  111.        
  112.         self.sPos = self.pos
  113.         self.isFound = 0
  114.         self.sObj = self.branchObj
  115.         self.oList = []    
  116.                
  117.         self.p1 = (0,0,0)#p1#pointPosition(s.cv[0], w=1)
  118.         self.p2 = (0,0,0)#p2#pointPosition(s.cv[1], w=1)
  119.         self.toCurve = []
  120.         self.found = 0
  121.         self.found2 = 0    
  122.        
  123.        
  124.     def reset(self):
  125.         self.dirV = self.origDir
  126.         self.count = 0
  127.     def next(self):
  128.         nextDir = om.MVector(self.dirV * self.bLen)
  129.         #nextDir = scaler(self.dirV, self.bLen)
  130.         if self.bRoot:
  131.             #nextDir = scaler(self.dirV, 2)
  132.             #normalMag = getMag(nextDir)
  133.             #nextDir = makeNormal(nextDir, normalMag)
  134.             nextDir = om.MVector(self.dirV * 2)
  135.             om.MVector.normalize(nextDir)
  136.         nextPos = om.MVector(self.pos + nextDir)
  137.         #nextPos = adder(self.pos, nextDir)
  138.         nextBranch = Branch(self.pos, nextPos, nextDir)
  139.         return nextBranch
  140.     def show(self, i):
  141.         if self.papa:
  142.  
  143.             if defAttr.showGrowingCheckValue:
  144.                 crv = cmds.curve(p = [self.papa, self.pos], d = 1, n = "crv_"+str(i-1))
  145.                 bToParent.append(crv)
  146.            
  147.            
  148.             self.p1 = [self.papa[0], self.papa[1], self.papa[2]]
  149.             self.p2 = [self.pos[0], self.pos[1], self.pos[2]]
  150.             defAttr.toCrvs.append(self)
  151.             """
  152.            if self.p2 == self.p1: # if curve parent is found mark
  153.                self.toCurve.append(self.p1)
  154.                self.found = 1
  155.            """  
  156.            
  157.            
  158.             if defAttr.doParticles:
  159.                 branchParticlesR.append(.1)
  160.                 branchParticles.append(self.pos)
  161.                
  162.                 defAttr.toParticles.append(self.pos)
  163.                 extraP = getCenter(self.pos,self.papa, .25)
  164.                 defAttr.toParticles.append(extraP)
  165.                 extraP = getCenter(self.pos,self.papa, .5)
  166.                 defAttr.toParticles.append(extraP)  
  167.                 extraP = getCenter(self.pos,self.papa, .75)
  168.                 defAttr.toParticles.append(extraP)  
  169.                            
  170.             self.parents.append(self.pos)
  171.             cmds.select(cl=1)
  172.         else:
  173.             lastPapa = 0,0,0  
  174.            
  175.          
  176. def makeLeaves():
  177.     allTime = time.clock()
  178.     defAttr.doParticles = makeParticlesCheck.getValue()
  179.     defAttr.showGrowingCheckValue = showGrowingCheck.getValue()
  180.     defAttr.toCrvs = []
  181.     defAttr.doProgress = showProgressCheck.getValue()
  182.     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
  183.     progress = 0
  184.     bToParent = []
  185.     branchParticles = []
  186.     branchParticlesR = []
  187.     leaves = []
  188.     branches = []
  189.     branchPosArray = []
  190.     newLeafArray = []
  191.    
  192.     ########################################################################################################################
  193.     ########################################################################################################################
  194.     ########################################################################################################################
  195.     ## Main variables ##
  196.     ####################
  197.     maxItterations = 10000 # used for catchers in while loops
  198.     ####################
  199.     if showLeavesCheck.getValue():
  200.         showGrow = 2
  201.     else:
  202.         showGrow = 0 # 0 = dont update and only draw curves, 1 = draw leaves and trunk dynamicly update, 2 = particles/cuves
  203.     scatterType = 0 # 0 volume, 1 surface, 2 both
  204.    
  205.     leavesGrp = grpr("leaves_grp")
  206.     leavesObjGrp = grpr("leaves_obj_grp")
  207.     newGrp = grpr("combinedCrvs_grp")  
  208.     leafPosArray = []
  209.     # Make all the leaves
  210.     #scat = ls("scatter1")
  211.     #scatCombined = ls("combined_leaves_arrayx")
  212.     leaves = []
  213.     rootList = []
  214.  
  215.     width = float(treeWidth.getText())
  216.     depth = float(treeDepth.getText())
  217.     height = float(treeHeight.getText())
  218.     treeCenter = [float(baseX.getText()),float(baseY.getText()),float(baseZ.getText())]
  219.     """
  220.    width = 200
  221.    depth = 200
  222.    height = 200
  223.    treeCenter = [0, 0, 0]  
  224.    """
  225.     checkUseScatter = useSoupCheck.getValue()
  226.     if checkUseScatter:
  227.         scat = ls(soupObj.getText())
  228.         if not soupObj:
  229.             print "Get soup Object"
  230.         else:
  231.             leafAmnt = getAttr(scat[0].maxNumberOfPoints)
  232.             boundingBox = listConnections(scat[0]+".inGeometry")
  233.             boundingBox = xform(boundingBox, bbi=1, q=1)        
  234.     else:
  235.  
  236.         scat = soup().create('scatter')
  237.         leafBall = polyCube(n = "leaf_ball",w = width, d = depth, h = height, ch=0)[0]
  238.         move(leafBall, treeCenter)
  239.         polySmooth(leafBall, ch=0)
  240.         parent(leafBall,leavesGrp)
  241.         rename(scat[0], "leaves_scatter")
  242.  
  243.         boundingBox = xform(leafBall, bbi=1, q=1)
  244.        
  245.         scat = ls("leaves_scatter")
  246.         parent(scat,leavesGrp)
  247.         leafBall.getShape().worldMesh[0] >> scat[0].inGeometry
  248.         leafBall.worldMatrix[0] >> scat[0].inWorldMatrix
  249.         setAttr(leafBall.visibility, 0)  
  250.         leafAmnt = int(leafAmntA.getText())
  251.         setAttr(scat[0].maxNumberOfPoints, leafAmnt)
  252.     print scat    
  253.     setAttr(scat[0].visibility, 0)  
  254.     setAttr(scat[0].pointDensity, leafAmnt*10)    
  255.     scatPosArray = cmds.getAttr(cmds.listRelatives(str(scat[0]),s=1)[0]+".outPositionPP")
  256.     #scatPosArray = getAttr(scat[0].getShape().outPositionPP)
  257.     leafPosArray = []
  258.     for i in range(0,len(scatPosArray)):
  259.         leafPosArray.append(om.MVector(scatPosArray[i]))  
  260.        
  261.        
  262.     if defAttr.doProgress:    
  263.         progress = 1 #################################################  PROGRESS  #######################
  264.    
  265.    
  266.     maxDist = float(searchMaxAmnt.getText())#28
  267.     minDist = float(searchMinAmnt.getText())#14
  268.     bLength = float(searchLenAmnt.getText())#1
  269.     directionNoise = float(searchNoiseAmnt.getText())#.01
  270.    
  271.    
  272.     if makeMeshCheck.getValue():
  273.         makeParticles = True
  274.     else:
  275.         makeParticles = False
  276.     useScatter = True
  277.     ####################
  278.  
  279.     ####################
  280.     ####################
  281.     ########################################################################################################################
  282.     ########################################################################################################################
  283.     ########################################################################################################################
  284.     if progress:
  285.         progWin2 = progressWindow(isInterruptable=1, t= "Growing...", min = 0, max = len(leafPosArray))
  286.  
  287.     directionArray = []
  288.     pi = 1
  289.     for i in leafPosArray:
  290.         if progress:
  291.             progressWindow(progWin2, edit=True, pr = pi)
  292.         l = Leaf()
  293.        
  294.         if scat:
  295.             l.pos = i
  296.             l.sPos = i
  297.             directionArray.append(i)
  298.         else:
  299.             directionArray.append(l.pos)
  300.         leaves.append(l)
  301.         pi += 1
  302.     toParent = []
  303.    
  304.     for l in leaves:
  305.         l.show()  
  306.         l.shown = 1
  307.         if showGrow == 2:
  308.             toParent.append(l.leafObj)
  309.        
  310.     parent(leavesObjGrp, leavesGrp)
  311.     parent(toParent, leavesObjGrp)
  312.     select(cl=1)
  313.    
  314.     if defAttr.gotRoots:
  315.         sl = defAttr.gotRoots
  316.     else:
  317.         sl = selected()
  318.    
  319.     rootTime = time.clock()
  320.     iA = 0
  321.     if len(sl) >= 1:
  322.         print "Creating roots from selected"
  323.         for s in sl:
  324.             rootPos = om.MVector(s.getTranslation())
  325.             leafAverage = om.MVector(reduce(lambda x, y: x + y, directionArray) / len(directionArray))
  326.             dirV = om.MVector(rootPos - leafAverage)
  327.             root = Branch(None, rootPos, -dirV)
  328.             branches.append(root)
  329.             current = root
  330.             found = False
  331.             catcher = maxItterations*.1
  332.             while not found:
  333.                 if catcher == 0:
  334.                     print "Breaking"
  335.                     break
  336.                 cLMax = 1000
  337.                 for l in leaves:
  338.                     dist = getDist(current.pos, l.pos)
  339.                     if dist < cLMax:
  340.                         newDirV = om.MVector(current.pos - l.pos)
  341.                         root.dirV = -newDirV
  342.                         cLMax = dist
  343.                     if dist < maxDist:
  344.                         found = True
  345.                 if not found:
  346.                     current.bRoot = 1
  347.                     randAdd = om.MVector(r.uniform(-directionNoise*.1,directionNoise*.1),r.uniform(-directionNoise*.1,directionNoise*.1),r.uniform(-directionNoise*.1,directionNoise*.1))###
  348.                     current.dirV = om.MVector(current.dirV + randAdd)
  349.                     root = current.next()
  350.                     current = root
  351.                     branches.append(current)
  352.                 catcher -= 1
  353.                 iA += 1
  354.     else:
  355.         print "Creating root"
  356.         rootPos = om.MVector(0,0,0)
  357.         dirV = om.MVector(reduce(lambda x, y: x + y, directionArray) / len(directionArray))
  358.         root = Branch(None, rootPos, dirV)
  359.         branches = [root]
  360.         current = root
  361.         found = False
  362.         catcher = maxItterations*.1
  363.         while not found:
  364.             if catcher == 0:
  365.                 print "Breaking"
  366.                 break
  367.             for l in leaves:
  368.                 dist = getDist(current.pos,l.pos)
  369.                 if dist < maxDist:
  370.                     found = True
  371.             if not found:
  372.                 current.bRoot = 1
  373.                 randAdd = om.MVector(r.uniform(-directionNoise*.1,directionNoise*.1),r.uniform(-directionNoise*.1,directionNoise*.1),r.uniform(-directionNoise*.1,directionNoise*.1))###
  374.                 current.dirV = om.MVector(current.dirV + randAdd)
  375.                 root = current.next()
  376.                 current = root
  377.                 branches.append(current)
  378.             catcher -= 1
  379.             iA += 1
  380.     rootTimeElapsed = (time.clock() - rootTime)
  381.     #print "Step one time:", rootTimeElapsed, iA
  382.     i = 1
  383.     for b in branches:
  384.         b.show(i)
  385.         i += 1  
  386.     #print "Starting grow"
  387.     noBMax = 0
  388.     #leaves = self.leaves
  389.     #branches = self.branches
  390.     branchesSave = []
  391.     #leafPosArray = self.leafPosArray
  392.     newB = 0
  393.     endItter = 0
  394.     iA = 0
  395.     refreshTracker = 0
  396.     defAttr.toParticles = []
  397.     lT = 0
  398.    
  399.    
  400.    
  401.     useOcTree = useOcTreeCheck.getValue()
  402.  
  403.  
  404.     if useOcTree:
  405.         oTreeTime = time.clock()
  406.         #### ocTree
  407.         subDepth = int(subMaxAmnt.getText())
  408.         subMaxCount = float(subMaxCountAmnt.getText())
  409.         distBuffAmntMultiplier = float(distBuffAmnt.getText())
  410.         oShowGrow = int(showOcTreeCheck.getValue())
  411.         doRefresh = int(showOcTreeGrowCheck.getValue())
  412.         bTree_util2.constructTree(boundingBox, leaves, subDepth, subMaxCount ,oShowGrow, doRefresh)    
  413.         ####
  414.         ocTimeElapsed = (time.clock() - oTreeTime)
  415.         print "OcTree Creation:", ocTimeElapsed  
  416.         doRefresh = 5
  417.        
  418.    
  419.    
  420.    
  421.    
  422.     #bFresh = 0
  423.     for i in range(0,maxItterations):
  424.         #bFresh += 1
  425.         #print "Itteration ", i
  426.         if progress:
  427.             progressWindow(progWin2, edit=True, pr = lT+1)
  428.             if progressWindow(progWin2, query=1, isCancelled=1 ):
  429.                 print "killed at", i+1
  430.                 break  
  431.         itterTime = time.clock()
  432.         bl = len(branches)
  433.         lb = len(leaves)  
  434.         if not newB:
  435.             if endItter >= 1:
  436.                 break
  437.             endItter += 1
  438.         newB = 0    
  439.         refreshTime = time.clock()
  440.         if refreshTracker == 2:
  441.             cmds.refresh(cw=1)
  442.             refreshTracker = 0
  443.         leafLoopItterTime = time.clock()
  444.        
  445.         if useOcTree:
  446.  
  447.             #print "branch length ", len(branches)
  448.             #if doRefresh == 10 or bFresh < 5:
  449.             #doRefresh = 0
  450.             leafList = []
  451.             bList = []
  452.             for b in branches:
  453.                 if not b.doRemove:
  454.                     #spaceLocator(p=b.pos)
  455.                     closeList = []
  456.                     closeList = bTree_util2.getClose(b.pos, maxDist * distBuffAmntMultiplier, 0)
  457.                     if len(closeList) > 0:
  458.                         bList.append(b)
  459.                     for l in closeList:
  460.                         #spaceLocator(p=l.sPos)
  461.                         if not l.reached:
  462.                             if not l.oFound:
  463.                                 leafList.append(l)
  464.                                 #l.foundBranches.append(b)
  465.                                 l.oFound = 1
  466.              
  467.             #doRefresh += 1
  468.             #bFresh += 1      
  469.             lt = 0
  470.             for l in leafList:
  471.                
  472.                 lt += 1
  473.                 closestBranch = False
  474.                 record = 10000
  475.                 for b in bList:
  476.                     #if not b.doRemove:
  477.                     dist = getDist(b.pos,l.sPos)
  478.                     if dist < minDist:
  479.                         l.reached = True
  480.                         lT += 1
  481.                         closestBranch = False
  482.                         break                            
  483.                     if dist > maxDist:
  484.                         pass
  485.                     elif closestBranch == False or dist < record:
  486.                         #spaceLocator(p = l.pos)
  487.                         closestBranch = [b]
  488.                         record = dist    
  489.                              
  490.                 if closestBranch != False:
  491.                     defAttr.leafCountTotal += 1
  492.                     """
  493.                    testPF = setMag(testPF, 10)
  494.                    mPF = getMag(testPF)
  495.                    testPF = makeNormal(testPF, mPF)
  496.                    minusV = (1,2,3)
  497.                    testPF = subber(testPF, minusV)
  498.                    """
  499.                     #newDir = subber(l.sPos, closestBranch[0].pos)
  500.                     newDir = om.MVector(l.sPos - closestBranch[0].pos)
  501.                     om.MVector.normalize(newDir)
  502.                     #normalMag = getMag(newDir)
  503.                     #newDir = makeNormal(newDir, normalMag)  
  504.                     #closestBranch[0].dirV =   adder(closestBranch[0].dirV ,newDir)  
  505.                     closestBranch[0].dirV = om.MVector(closestBranch[0].dirV + newDir )
  506.                     closestBranch[0].count = closestBranch[0].count + float(1)
  507.                 iA += 1
  508.             leafLoopElapsed = (time.clock() - leafLoopItterTime)  
  509.             leafLoopAfterItterTime = time.clock()
  510.             # Delet reached leaves
  511.             #if doRefresh == 10 or bFresh < 5:
  512.             for l in leafList[::-1]:
  513.                 l.oFound = 0
  514.                 if l.reached:
  515.                     l.Found = 1
  516.                     if l.leafObj:
  517.                         cmds.setAttr(l.leafObj+".visibility",0)
  518.                        
  519.                        
  520.             #print lt, len(leafList)                              
  521.             """
  522.            for l in leafList:
  523.                closestBranch = False
  524.                record = 10000
  525.                for b in l.foundBranches:
  526.                    dist = getDist(b.pos,l.pos)
  527.                    if dist < minDist:
  528.                        l.reached = True
  529.                        lT += 1
  530.                        closestBranch = False
  531.                        break
  532.                    if dist > maxDist:
  533.                        pass
  534.                    elif closestBranch == False or dist < record:
  535.                        #spaceLocator(p = l.pos)
  536.                        closestBranch = [b]
  537.                        record = dist
  538.                            
  539.                if closestBranch != False:  
  540.                    newDir = om.MVector(l.pos - closestBranch[0].pos)
  541.                    om.MVector.normalize(newDir)
  542.                    closestBranch[0].dirV = om.MVector(closestBranch[0].dirV + newDir )
  543.                    closestBranch[0].count = closestBranch[0].count + float(1)
  544.                iA += 1
  545.            leafLoopElapsed = (time.clock() - leafLoopItterTime)  
  546.            leafLoopAfterItterTime = time.clock()
  547.            for l in leaves[::-1]:
  548.                if l.reached:
  549.                    l.Found = 1
  550.                    if l.leafObj:
  551.                        cmds.setAttr(l.leafObj+".visibility",0)
  552.                else:
  553.                    l.oFound = 0
  554.            """
  555.                    
  556.            
  557.                        
  558.         else:
  559.             lt = 0
  560.             for l in leaves:
  561.                 if not l.Found:
  562.                     lt += 1
  563.                     closestBranch = False
  564.                     record = 10000
  565.                     for b in branches:
  566.                         if not b.doRemove:
  567.                             dist = getDist(b.pos,l.pos)
  568.                             if dist < minDist:
  569.                                 l.reached = True
  570.                                 lT += 1
  571.                                 closestBranch = False
  572.                                 break                            
  573.                             if dist > maxDist:
  574.                                 pass
  575.                             elif closestBranch == False or dist < record:
  576.                                 #spaceLocator(p = l.pos)
  577.                                 closestBranch = [b]
  578.                                 record = dist    
  579.                                  
  580.                     if closestBranch != False:  
  581.                         newDir = om.MVector(l.pos - closestBranch[0].pos)
  582.                         om.MVector.normalize(newDir)
  583.                         closestBranch[0].dirV = om.MVector(closestBranch[0].dirV + newDir )
  584.                         closestBranch[0].count = closestBranch[0].count + float(1)
  585.                     iA += 1
  586.             leafLoopElapsed = (time.clock() - leafLoopItterTime)  
  587.             leafLoopAfterItterTime = time.clock()
  588.             # Delet reached leaves
  589.             for l in leaves[::-1]:
  590.                 if l.reached:
  591.                     l.Found = 1
  592.                     if l.leafObj:
  593.                         cmds.setAttr(l.leafObj+".visibility",0)
  594.  
  595.  
  596.             #print lt
  597.         ii = 1
  598.         rBranches = []
  599.         bTrack = 0
  600.         for b in branches[::-1]:
  601.             if not b.doRemove:
  602.                 if b.count > 0:
  603.                     bl += 1
  604.                     bTrack += 1
  605.                     defAttr.branchCountTotal += 1
  606.                    
  607.                    
  608.                     #print "here", b.dirV, b.count
  609.                     #newDirV = scalerD(b.dirV, b.count)
  610.                     #print newDirV
  611.                     #normalMag = getMag2(newDirV)
  612.                     #newDirV = makeNormal(newDirV, normalMag)
  613.                     #randAdd = (r.uniform(-directionNoise,directionNoise),r.uniform(-directionNoise,directionNoise),r.uniform(-directionNoise,directionNoise))
  614.                     #print b.dirV
  615.                     #b.dirV = adder(newDirV, randAdd)
  616.                    
  617.                     bVector = om.MVector(b.dirV)
  618.                     newDirV = om.MVector(bVector / b.count)
  619.                     om.MVector.normalize(newDirV)
  620.                     randAdd = om.MVector(r.uniform(-directionNoise,directionNoise),r.uniform(-directionNoise,directionNoise),r.uniform(-directionNoise,directionNoise))###
  621.                     b.dirV = om.MVector(newDirV + randAdd)###
  622.                    
  623.                     newBranch = b.next()
  624.                     branches.append(newBranch)
  625.                     branchesSave.append(newBranch)
  626.                     branchPosArray.append(b.pos)
  627.                    
  628.                     b.isAlive = 1
  629.                    
  630.                     if not b.shown:
  631.                         b.show(ii)
  632.                         newB = 1
  633.                         b.shown = 1
  634.                 else:
  635.                     #rBranches.append(b)
  636.                     b.doRemove = 1
  637.                     #b.isAlive = 0
  638.             ii += 1
  639.             b.reset()  
  640.         """
  641.        for b in rBranches:
  642.            if b.doRemove == 1:
  643.                #b.isAlive = 0
  644.                branches.remove(b)    
  645.        """            
  646.         refreshTracker += 1      
  647.         #refreshTimeElapsed = (time.clock() - refreshTime)      
  648.         #itterElapsed = (time.clock() - itterTime)
  649.         #leafLoopAfterItterTimeElapsed = (time.clock() - leafLoopAfterItterTime)
  650.        
  651.         #print "Itteration time:", itterElapsed
  652.         #print "       Leaf loop time:", leafLoopElapsed
  653.         #print " After Leaf loop time:", leafLoopAfterItterTimeElapsed
  654.         #print "         Refresh time:", refreshTimeElapsed
  655.     if progress:  
  656.         progressWindow(progWin2, endProgress=1)  
  657.     print "Total itterations", iA  
  658.     parent(bToParent, leavesGrp)
  659.    
  660.     leavesGrpDeletCheck = ls("leaves_obj_grp")
  661.     if leavesGrpDeletCheck:
  662.         delete(leavesObjGrp)
  663.     #select(cl=1)
  664.     if defAttr.showGrowingCheckValue:
  665.         delete(leavesGrp)
  666.        
  667.     if makeParticlesCheck.getValue():
  668.         ll = cmds.nParticle(p=defAttr.toParticles)[0]
  669.         #parent(ll, defAttr.popGrp)
  670.         setAttr(ll+".radiusScaleInput", 5)
  671.         setAttr(ll+".radius", 1)
  672.         setAttr(ll+".radiusScaleInputMax", 100)
  673.         setAttr(ll+".colorInput", 5)
  674.         setAttr(ll+".colorInputMax", 100)
  675.         setAttr(ll+".collide", 0)
  676.         setAttr(ll+".selfCollide", 0)
  677.         setAttr(ll+".forcesInWorld", 0)
  678.         setAttr(ll+".ignoreSolverWind", 1)
  679.         setAttr(ll+".ignoreSolverGravity", 1)
  680.        
  681.         if makeParticles:
  682.             ppp = ls(ll)[0]
  683.             reMesh = createNode("mesh", n=ppp+"_reMeshed")
  684.             rename(reMesh,ppp+"_reMeshed")
  685.             #parent(reMesh[0],defAttr.popGrp)
  686.             # connections
  687.             ppp.outMesh >> reMesh.inMesh
  688.             setAttr(ll+".threshold", 0.01)
  689.             setAttr(ll+".meshMethod", 3)
  690.             setAttr(ll+".meshSmoothingIterations", 5)
  691.             setAttr(ll+".maxTriangleResolution", 200)
  692.             setAttr(ll+".meshTriangleSize", 0.2)
  693.             setAttr(ll+".velocityPerVertex", 0)
  694.             setAttr(ll+".colorPerVertex", 1)
  695.  
  696.     #return leaves, branches, branchPosArray,leavesObjGrp,branchesSave
  697.    
  698.     crvMakeTime = time.clock()
  699.     def getC(c):
  700.         maxSearch = 0
  701.         papa = c
  702.         toCrvList = []
  703.         while papa:
  704.             toCrvList.append(papa.p1)
  705.             if papa.toCurve:
  706.                 papa = papa.toCurve[0]
  707.                 papa.found2 = 1
  708.             else:
  709.                 toCrvList.append(papa.p2)
  710.                 break
  711.             if maxSearch > 1000:
  712.                 break
  713.             maxSearch += 1    
  714.         return toCrvList
  715.     checkList = []
  716.     i = 0
  717.     if len(defAttr.toCrvs) > 0:
  718.         maxSearch = 0
  719.         toCrvList = []
  720.         restCurves = defAttr.toCrvs
  721.         papa = restCurves[0]
  722.         i = 0
  723.         search = 1
  724.         toParent = []
  725.         for crv in restCurves:# loop through curves
  726.             if not crv.found:
  727.                 for crvcrv in restCurves: # loop throuch all cruves for all curves
  728.                     if not crvcrv.found:
  729.                         if crv.p2 == crvcrv.p1: # if curve parent is found mark
  730.                             crv.toCurve.append(crvcrv)
  731.                             crv.found = 1  
  732.             i += 1
  733.         for c in restCurves:
  734.             if not c.found2:
  735.                 toC = getC(c)
  736.                 crv = cmds.curve(p = toC, d = 1)
  737.                 toParent.append(crv)  
  738.  
  739.                 crvPiv = pointPosition(crv+".cv[0]", w=1)
  740.                 move(crv+".scalePivot", crvPiv)
  741.                 move(crv+".rotatePivot", crvPiv)
  742.  
  743.                 move(crv, 0,0,0,rpr=1)
  744.                 makeIdentity(crv,apply=1,t=1,r=1 ,s=1 ,n=0 ,pn=1)
  745.                 move(crv, crvPiv)
  746.                 i += 1
  747.  
  748.     parent(toParent,newGrp)  
  749.     select(cl=1)
  750.     crvMakeTimeElapsed = (time.clock() - crvMakeTime)  
  751.    
  752.    
  753.     allTimeElapsed = (time.clock() - allTime)
  754.     print "Curve creating time: ", crvMakeTimeElapsed
  755.     print "Branch calculation total: ", defAttr.branchCountTotal
  756.     print "Leaf calculation total: ",defAttr.leafCountTotal
  757.     print "Total time: ", allTimeElapsed  
  758.  
  759. def useSoupChecker():# enable and disable using soup
  760.     soupCheck = useSoupCheck.getValue()
  761.     attrList = [leafAmntA]#, searchMaxAmnt, searchMinAmnt, searchLenAmnt, searchNoiseAmnt
  762.     if soupCheck:
  763.         for attr in attrList:
  764.             textField(attr, en=0, e=1)
  765.         #treeShapeLayout = frameLayout(l = "Tree Shape", cll=1, cl=0)
  766.         frameLayout(treeShapeLayout, e=1, vis=0, cl=1)
  767.         textField(soupObj, en=1, e=1)
  768.         button(soupObjGet,en=1, e=1)
  769.     else:
  770.         for attr in attrList:
  771.             textField(attr, en=1, e=1)
  772.        
  773.         frameLayout(treeShapeLayout, e=1, vis=1, cl=1)  
  774.         textField(soupObj, en=0, e=1)
  775.         button(soupObjGet,en=0, e=1)
  776.        
  777. def runMain():
  778.     print "running"
  779.     """
  780.    branchPosArray=[]
  781.    # main "Program"
  782.    grow()
  783.    parent(bToParent, leavesGrp)
  784.    select(cl=1)
  785.    leavesGrpDeletCheck = ls("leaves_obj_grp")
  786.    if leavesGrpDeletCheck:
  787.        delete(leavesObjGrp)
  788.    select(cl=1)
  789.    elapsed = (time.clock() - start)
  790.    elapsed = elapsed
  791.    print "\n","Run time total:", elapsed
  792.    """
  793. def getScat():
  794.     sl = selected()
  795.     soupObj.setText(str(sl[0]))
  796.    
  797. def getRoots():
  798.     sl = selected()
  799.     if len(sl) > 0:
  800.         defAttr.gotRoots = sl
  801.     else:
  802.         defAttr.gotRoots = []
  803.        
  804. def removeRoots():
  805.     defAttr.gotRoots = []
  806.  
  807.      
  808. def resetPiv():
  809.     sl = selected()
  810.     for s in sl:
  811.         if nodeType(s.getShape()) == "nurbsCurve":
  812.             p = pointPosition(s.cv[0], w=1)
  813.             move(s+".scalePivot", p)
  814.             move(s+".rotatePivot", p)
  815.             move(s, 0,0,0,rpr=1)
  816.             makeIdentity(s,apply=1,t=1,r=1 ,s=1 ,n=0 ,pn=1)
  817.             move(s, p)
  818.            
  819. from pymel.core import *
  820. def crvToParticles():
  821.     import maya.OpenMaya as om
  822.     sl = om.MSelectionList() # create list for selection
  823.     om.MGlobal.getActiveSelectionList(sl) # load list
  824.     selectionIter = om.MItSelectionList(sl)# create ittorator for list
  825.     cvPos = []
  826.     while not selectionIter.isDone():
  827.         crvObj = om.MObject()# Crv object
  828.         cvPosArray = om.MPointArray()# create array to store cv points
  829.         crvPath = om.MDagPath() # create dag path
  830.         selectionIter.getDagPath(crvPath, crvObj)# fill dag path, with crvObj
  831.         crvFn = om.MFnNurbsCurve(crvPath)# functions for curves
  832.         crvFn.getCVs(cvPosArray, om.MSpace.kWorld) # get cvs from cvFn, and add to cvPosArray
  833.         selectionIter.next()# move on to next item in selection
  834.         for i in range(cvPosArray.length()):# loop through length of curve Position array
  835.             x = cvPosArray[i][0]
  836.             y = cvPosArray[i][1]
  837.             z = cvPosArray[i][2]
  838.             pos = [x,y,z]
  839.             cvPos.append(pos)
  840.     ll = mc.nParticle(p=cvPos)[0]
  841.     mc.setAttr(ll+".radiusScaleInput", 5)
  842.     mc.setAttr(ll+".radius", 2.5)
  843.     mc.setAttr(ll+".radiusScaleInputMax", 35)
  844.     mc.setAttr(ll+".colorInput", 5)
  845.     mc.setAttr(ll+".colorInputMax", 35)
  846.     mc.setAttr(ll+".collide", 0)
  847.     mc.setAttr(ll+".selfCollide", 0)
  848.     mc.setAttr(ll+".forcesInWorld", 0)
  849.     mc.setAttr(ll+".ignoreSolverWind", 1)
  850.     mc.setAttr(ll+".ignoreSolverGravity", 1)
  851.  
  852. def slCrvLen():
  853.     sl = selected()
  854.     len = float(crvLenAmnt.getText())
  855.     select(cl=1)
  856.     for s in sl:
  857.         if nodeType(s.getShape()) == "nurbsCurve":
  858.             cl = arclen(s)
  859.             if cl < len:
  860.                 select(s, add=1)
  861.                
  862. def randoSl():
  863.     sl = selected()
  864.     select(cl=1)
  865.     for s in sl:
  866.         rt = r.randint(0,2)
  867.         if rt == 2:
  868.             select(s,add=1)
  869.            
  870. def getCrvTips():
  871.     from pymel.core import *
  872.     import maya.OpenMaya as om
  873.     sl = om.MSelectionList() # create list for selection
  874.     om.MGlobal.getActiveSelectionList(sl) # load list
  875.     selectionIter = om.MItSelectionList(sl)# create ittorator for list
  876.     cvPos = []
  877.     while not selectionIter.isDone():
  878.         crvObj = om.MObject()# Crv object
  879.         cvPosArray = om.MPointArray()# create array to store cv points
  880.         crvPath = om.MDagPath() # create dag path
  881.         selectionIter.getDagPath(crvPath, crvObj)# fill dag path, with crvObj
  882.         crvFn = om.MFnNurbsCurve(crvPath)# functions for curves
  883.         crvFn.getCVs(cvPosArray, om.MSpace.kWorld) # get cvs from cvFn, and add to cvPosArray
  884.         selectionIter.next()# move on to next item in selection
  885.         crvP = cvPosArray[cvPosArray.length()-1]
  886.         x = crvP[0]
  887.         y = crvP[1]
  888.         z = crvP[2]
  889.         pos = [x,y,z]
  890.         cvPos.append(pos)
  891.     slList = []  
  892.     for p in cvPos:
  893.         l = spaceLocator()
  894.         move(l, p)
  895.         slList.append(l)
  896.     select(slList,add=1)
  897.    
  898.    
  899. def crvToMesh():
  900.     #from pymel.core import *
  901.     #import maya.OpenMaya as om
  902.     #import maya.cmds as mc
  903.     #import time
  904.     start = time.clock()
  905.     sl = selected()
  906.     def grprO(name):
  907.         g = ls(name)
  908.         if g:
  909.             delete(g)
  910.         g = group(n=name,em=1)
  911.         return g      
  912.     crvToMeshGrp = grprO("crvsToMeshGrp")
  913.     crvToMeshStrokesGrp = grprO("crvsToMeshStrokeGrp")
  914.     parent(crvToMeshStrokesGrp, crvToMeshGrp)
  915.    
  916.     defaultMatSG = ls("initialShadingGroup")
  917.    
  918.     i = 0
  919.     toParent = []
  920.     toParentS = []
  921.     for s in sl:
  922.         sampleAmnt = int(arclen(s))
  923.         srk = stroke(n = s+"_Stoke_"+str(i))
  924.         toParentS.append(srk)
  925.         bsh = createNode("brush", n = s+"_Brush_"+str(i))
  926.    
  927.         s.worldSpace[0] >> srk.pathCurve[0].curve
  928.         bsh.outBrush >> srk.brush
  929.         connectAttr("time1.outTime", bsh+".time")
  930.         srkSp = srk.getShape()
  931.         setAttr(srkSp.displayPercent, 100)
  932.         setAttr(srkSp.pathCurve[0].samples, 24)
  933.         setAttr(srkSp.useNormal, 0)
  934.         setAttr(srkSp.minimalTwist, 1)
  935.         # Paint effects settings
  936.         sh = srkSp
  937.         scl = arclen(s)
  938.         sB = bsh
  939.         end = (scl*.2)
  940.         sW = scl*.02
  941.         sG = scl*.025
  942.         if end >= .1:
  943.             end = .1
  944.         if sG <= .5:
  945.             sG = .5
  946.         if sW >= .1:
  947.             sW = .1
  948.         if sW <= 1:
  949.             sW = 1
  950.         setAttr(sB.brushWidth, sW)
  951.         setAttr(sB.globalScale, sG)
  952.         setAttr(sh.sampleDensity, .5)
  953.         extrudeList = [["1",.1, 1],["2",1, end]]
  954.         x = 2
  955.         ii = 0
  956.         for ex in extrudeList:
  957.             setAttr(sh+".pressureScale[{0}].pressureScale_FloatValue".format(ii), ex[1])
  958.             setAttr(sh+".pressureScale[{0}].pressureScale_Position".format(ii), ex[2])
  959.             setAttr(sh+".pressureScale[{0}].pressureScale_Interp".format(ii), 2)  
  960.             x += 1
  961.             ii += 1
  962.         setAttr(str(sh)+".pressureMap1", 2)
  963.         setAttr(sh+".pressureMin1",.1)  
  964.         setAttr(sh+".pressureMax1",1)
  965.         setAttr(sh+".meshVertexColorMode",1)
  966.         setAttr(sh+".meshQuadOutput",1)
  967.         #setAttr "strokeShape2.meshVertexColorMode" 1;
  968.         #setAttr "strokeShape2.meshQuadOutput" 1;
  969.         #ii += 1
  970.    
  971.    
  972.         # Make Mesh
  973.         newMeshT = mc.createNode("transform", n = s+"_Mesh"+str(i))
  974.         newMesh = mc.createNode("mesh", n = s+"_MeshShape"+str(i), p = s+"_Mesh"+str(i))
  975.         toParent.append(newMeshT)
  976.         connectAttr(str(srk)+".worldMainMesh", str(newMesh)+".inMesh")
  977.         sets(defaultMatSG[0], e=1, forceElement = newMesh)
  978.    
  979.      
  980.     parent(toParent, crvToMeshGrp)  
  981.     parent(toParentS, crvToMeshStrokesGrp)
  982.     setAttr(crvToMeshStrokesGrp.visibility, 0)
  983.     print time.clock()- start
  984.  
  985.    
  986.    
  987.  
  988.  
  989.  
  990. win = window(title= "Vein Generator", s=1, w=200, ip=1, tlb=1)
  991. mainLayout = rowColumnLayout(nc=1)
  992. #guiLable = text("Vein creator")
  993.  
  994.  
  995.  
  996. attributeLayout = rowColumnLayout(nc=1, p = mainLayout )
  997.  
  998.  
  999. showLeavesCheck = checkBox(l = "Show Leaves")
  1000. useSoupCheck = checkBox(l = "Use Scatter", cc = Callback(useSoupChecker), v=0)
  1001. makeParticlesCheck = checkBox(l = "Make Particles")
  1002. makeMeshCheck = checkBox(l = "Make Mesh")
  1003. showGrowingCheck = checkBox(l = "Show Growing")
  1004. showProgressCheck = checkBox(l = "Show Proggress Bar", v=0)
  1005.  
  1006. soupLayout = rowColumnLayout(nc=2, p = attributeLayout)
  1007. soupObj = textField(tx = "scatter1", p = soupLayout,en=0)
  1008. soupObjGet = button(l = "Get", p=soupLayout,en=0, command=Callback(getScat))
  1009.  
  1010. text(" ",p=attributeLayout)
  1011.  
  1012. #useSoupObj = textFieldButtonGrp(tx="scatter1")##,w=10, cw=[2,1]
  1013.  
  1014.  
  1015. #runAllBtn = button(l="Create Leaves",p = attributeLayout, command=Callback(makeLeaves))
  1016. """
  1017. width = 200
  1018. depth = 200
  1019. height = 200
  1020. treeCenter = [0, 0, 0]  
  1021. """
  1022.  
  1023. treeShapeLayout = frameLayout(l = "Tree Shape", cll=1, cl=1)
  1024. leafAmntTxt = text("leaf amount", p = treeShapeLayout)
  1025. leafAmntA = textField(tx = "1000", p = treeShapeLayout)
  1026.  
  1027. treeShapeSubLayout = rowColumnLayout(nc=2, p = treeShapeLayout, w=10)
  1028.  
  1029. treeWidthTxt = text(l= "Width", p = treeShapeSubLayout)
  1030. treeWidth = textField(tx = "50", p = treeShapeSubLayout)
  1031. treeHeightTxt = text(l= "Height", p = treeShapeSubLayout)
  1032. treeHeight = textField(tx = "100", p = treeShapeSubLayout)
  1033. treeDepthTxt = text(l= "Depth", p = treeShapeSubLayout)
  1034. treeDepth = textField(tx = "50", p = treeShapeSubLayout)
  1035.  
  1036. treeBaseTxt = text(l= "Base Position", p = treeShapeSubLayout)
  1037. treeBaseInfoTxt = text(l= "X Y Z", p = treeShapeLayout)
  1038. baseLocation = rowColumnLayout(nc=3, p = treeShapeLayout)
  1039. baseX = textField(tx = "0", p = baseLocation, w=40)
  1040. baseY = textField(tx = "75", p = baseLocation, w=40)
  1041. baseZ = textField(tx = "0", p = baseLocation, w=40)
  1042. ##
  1043. searchAmntTxt = text("Search Distance", p = attributeLayout)
  1044. searchAmntMaxTxt = text("Max", p = attributeLayout)
  1045. searchMaxAmnt = textField(tx = "25", p = attributeLayout)
  1046.  
  1047. searchAmntMinTxt = text("Min", p = attributeLayout)
  1048. searchMinAmnt = textField(tx = "5", p = attributeLayout)
  1049.  
  1050. searchAmntLenTxt = text("Branch Length", p = attributeLayout)
  1051. searchLenAmnt = textField(tx = "2", p = attributeLayout)
  1052.  
  1053. searchAmntNoiseTxt = text("Noise", p = attributeLayout)
  1054. searchNoiseAmnt = textField(tx = ".1", p = attributeLayout)
  1055. text(" ",p=mainLayout)
  1056. getRootObjs = button(l = "Get Roots",p=mainLayout, command=Callback(getRoots))
  1057. removeRootObjs = button(l = "Remove Roots",p=mainLayout, command=Callback(removeRoots))
  1058.  
  1059. runAllBtn = button(l=" Grow ",p=mainLayout,bgc = [0,1,0], command=Callback(makeLeaves))
  1060.  
  1061.  
  1062. ###
  1063. optionsLayout = frameLayout(l = "Options", cll=1, cl=1, p = mainLayout)
  1064.  
  1065. crvOptionsLayout = frameLayout(l = "Crv Utils", cll=1, cl=1, p = optionsLayout)
  1066.  
  1067. slCrvLength = button(l=" Select Crv Length ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(slCrvLen))
  1068. crvLenAmnt = textField(tx = "10", p = crvOptionsLayout)
  1069.  
  1070. runRandoSl = button(l=" Reduce Selection ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(randoSl))
  1071.  
  1072. resetCrvPivot = button(l=" ResetPivot ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(resetPiv))
  1073. crvToParticels = button(l=" Crv to Particles ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(crvToParticles))
  1074. crvTipsToLctrs = button(l=" Crv tips to Locators ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(getCrvTips))
  1075.  
  1076. crvtoLocatorBtn = button(l=" Crv Mesh ",p=crvOptionsLayout,bgc = [.5,.5,.5], command=Callback(crvToMesh))
  1077.  
  1078.  
  1079.  
  1080. ocTreeOptionsLayout = frameLayout(l = "Octree", cll=1, cl=1, p = optionsLayout)
  1081. useOcTreeCheck = checkBox(l = "Use OcTree", v=1, p=ocTreeOptionsLayout)
  1082. subMaxAmntTxt = text("subMax", p = ocTreeOptionsLayout)
  1083. subMaxAmnt = textField(tx = "20", p = ocTreeOptionsLayout)
  1084. subMaxCountAmntTxt = text("subMaxCoun", p = ocTreeOptionsLayout)
  1085. subMaxCountAmnt = textField(tx = "200", p = ocTreeOptionsLayout)
  1086. subMaxCountAmntTxt = text("Distance Buffer Multiplier", p = ocTreeOptionsLayout)
  1087. distBuffAmnt = textField(tx = "1", p = ocTreeOptionsLayout)
  1088. showOcTreeCheck = checkBox(l = "Show OcTree", v=0, p=ocTreeOptionsLayout)
  1089. showOcTreeGrowCheck = checkBox(l = "Show Grow", v=0, p=ocTreeOptionsLayout)
  1090. win.show()
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!