Generative Scripting II

columbarium_growth_by_grisha

2009-08-11T14:46:00.005+02:00

this is my studio project "a multireligious columbarium"

and this is the script for it

import maya.cmds as cmds
import maya.cmds as cmds
import maya.mel as mm
import math
import sys
from random import*
from setColor import*

# increasing recursion limit to 8000 loops
sys.setrecursionlimit(8000)

#######################
### HELPING SCRIPTS ###
#######################

# getting center of the Face
def centerOfFace(facet):
#find the vertices that define that face.
vertex = cmds.polyListComponentConversion(facet, ff=1, tv=1)
cmds.select(vertex, r=1)
vertexFlat = cmds.ls(sl=1, fl=1)

#find out how many vertices define that face
vertCount = len(vertexFlat)
#print vertexFlat

#for each vertex go through and find it's world space position.
vertPositionSumX = 0.
vertPositionSumY = 0.
vertPositionSumZ = 0.
for a in range(0, vertCount, 1):
coordinate = cmds.pointPosition(vertexFlat[a], w=1)
vertPositionSumX += coordinate[0]
vertPositionSumY += coordinate[1]
vertPositionSumZ += coordinate[2]

centroidX = vertPositionSumX/float(vertCount)
centroidY = vertPositionSumY/float(vertCount)
centroidZ = vertPositionSumZ/float(vertCount)

return [centroidX, centroidY, centroidZ]

# distance between two points
def getDistance(start, end):
#start and end must be lists xyz
v = [start[0]-end[0], start[1]-end[1], start[2]-end[2]] #list format x,y,z
vector = "<<" + str(v[0]) + "," + str(v[1]) + "," + str(v[2]) + ">>"
mag = mm.eval("mag " + vector + ";")

return mag

# looking for closest locator through the list with locators to the LOCATOR
def closestLocator (locator, netOfLocs):
locatorPos = cmds.pointPosition(locator)
distance = 1000000000
closLocData = []
closestLocator = ""
for i in netOfLocs:
locPos = cmds.pointPosition(i)
currDist = getDistance(locatorPos, locPos)
if currDist < distance =" currDist" closlocator =" i" closlocpos =" locPos" closlocdist =" currDist" locatorpos =" Point" distance =" 1000000000" closlocdata =" []" closestlocator = "" locpos =" i[1]" currdist =" getDistance(locatorPos," distance =" currDist" closlocator =" i[0]" closlocpos =" locPos" closlocdist =" currDist" locatorpos =" Point" distance =" 1000000000" closlocdata =" []" closestlocator = "" locpos =" i" currdist =" getDistance(locatorPos," distance =" currDist" closlocator =" i[0]" closlocpos =" locPos" closlocdist =" currDist" locatorpos =" Point" distance =" 1000000000" closlocdata =" []" closestlocator = "" locpos =" i[2]" currdist =" getDistance(locatorPos," distance =" currDist" closlocator =" i[0]" grow =" i[1]" closlocpos =" locPos" closlocdist =" currDist" locatorpos =" Point" distance =" 1000000000" closlocdata =" []" closestlocator = "" locpos =" i[1]" currdist =" getDistance(locatorPos," distance =" currDist" closlocator =" i[0]" closlocpos =" locPos" closlocdist =" currDist" locatorpos =" center" distance =" 1000000000" closlocdata =" []" closestlocator = "" locpos =" i" currdist =" getDistance(locatorPos," distance =" currDist" closlocator =" i" closlocpos =" i" closlocdist =" currDist" x="0" y="0" z="0" n="0" ptpos =" cmds.pointPosition(i)" x="x+ptPos[0]" y="y+ptPos[1]" z="z+ptPos[2]" n="n+1" ptpos =" cmds.pointPosition(i)" x="x+ptPos[0]" y="y+ptPos[1]" z="z+ptPos[2]" n="n+1" midx =" x/n" midy =" y/n" midz =" z/n" midpt="[]" x="0" y="0" z="0" n="0" ptpos =" cmds.pointPosition(listLoc1[i])" x="x+ptPos[0]" y="y+ptPos[1]" z="z+ptPos[2]" n="n+1" ptpos =" listPt2" x="x+(ptPos[0]*len(listLoc1))" y="y+(ptPos[1]*len(listLoc1))" z="z+(ptPos[2]*len(listLoc1))" n="n+len(listLoc1)" midx =" x/n" midy =" y/n" midz =" z/n" midpt="[]" dire =" [" center =" center" loc2 =" loc2[0]" loc3 =" loc3[0]" loc4 =" loc4[0]" clpt1 =" closestPointToPoints" clpt2 =" closestPointToPoints" clpt1 =" clPt1[0]" clpt2 =" clPt2[0]" centerclosrelig =" centerClosRelig[0]" x =" (3*loc2[0]" y =" (3*loc2[1]" point =" [x,y,0]" x =" center[0]" y =" center[1]" new =" [x,y,0]" va =" (locPos[0]" vb =" (0,1,0)" angle =" cmds.angleBetween(v1=" v2="vb)" angle =" angle[3]" graves =" []" mitrary =" []" buddhism =" []" catholic=" []" orthodox =" []" hindu =" []" judaism =" []" protest =" []" islam =" []" allrelig =" []" otherr =" []" amitrary =" []" abuddhism =" []" acatholic=" []" aorthodox =" []" ahindu =" []" ajudaism =" []" aprotest =" []" aislam =" []" aallrelig =" []" ceremony =" []" entrance =" []" otherw =" []" otherm =" []" allrepuls =" []" trees =" []" treessrf=" []" cubes =" []" ff =" []" mitrary =" ff" ff =" []" buddhism =" ff" ff =" []" catholic =" ff" ff =" []" orthodox =" ff" ff =" []" hindu =" ff" ff =" []" judaism =" ff" ff =" []" protest =" ff" ff =" []" islam =" ff" ff =" []" amitrary =" ff" ff =" []" abuddhism =" ff" ff =" []" acatholic =" ff" ff =" []" aorthodox =" ff" ff =" []" ahindu =" ff" ff =" []" ajudaism =" ff" ff =" []" aprotest =" ff" ff =" []" aislam =" ff" otherrr =" []" otherr =" otherRR" allrelig =" self.mitrary" mmm="[]" mmmm="[]" ceremony =" mmm" entrance =" mmmm" otherw =" [centerOfFace('polySurface7766.f[0]'),centerOfFace('polySurface7770.f[0]'),centerOfFace('polySurface7767.f[0]'),centerOfFace('polySurface7769.f[0]'),centerOfFace('polySurface7771.f[0]')]" otherm =" [centerOfFace('polySurface7762.f[0]'),centerOfFace('polySurface7763.f[0]'),centerOfFace('polySurface7764.f[0]'),centerOfFace('polySurface7765.f[0]')]" allrepuls =" self.entrance" mm=" []" mmm =" []" m =" 'polySurface%d.f[0]'" n =" 'polySurface%d'" treessrf =" mmm" trees =" mm" r="True)" faces =" cmds.filterExpand(sm=" faces =" []" all="True)" cface =" centerOfFace(i)" loc =" cmds.spaceLocator(" p="(Cface[0],Cface[1],Cface[2])" graves =" FACES" all =" True)" locs =" cmds.filterExpand(sm=" pp =" []" loc =" i" lpos =" cmds.pointPosition(i)" oo =" []" graves =" PP" cubes =" []" position =" cmds.pointPosition(i)" cube =" cmds.polyCube" w ="size" h="size" d="size" repsize="10," pointsamount =" 4," n="0):" repulsivelocs =" self.allRepuls" locs =" self.graves" l="(repSize/5)*(i+1)" kpos =" k" closloc =" closestLocatorToPoint(Kpos," locpos =" closLoc[1]" clloc =" closLoc[0]" direc =" direction(LOCpos," newx =" ((direc[0]*6)/((i+1)*(i+1)))" newy =" ((direc[1]*6)/((i+1)*(i+1)))" newz =" ((direc[2]*6)/((i+1)*(i+1)))" cll =" [clLoc,LOCpos]" n="0," mn="0," bn="0," cn="0," on="0," hn="0," jn="0," pn="0," in="0," cubes =" []," max =" 150.0," cofcenmove="10" m =" [1]" b =" [2]" c =" [3]" o =" [4]" h =" [5]" j =" [6]" p =" [7]" i =" [8]" way ="=" way ="=" xxx =" randint" way ="=" xxx =" randint" n ="=" n ="=" n ="=" n="=" allrelig =" [M]+[B]+[C]+[O]+[H]+[J]+[P]+[I]" n="N+1" trees =" self.trees" closreligion =" closestPointToPoints1">= closReligion[1]:
 M.append (midPtWater (self.otherW, self.otherM, M[2], self.ceremony, self.entrance, self.Amitrary, closReligion[2])) # midPt [3]
else:
 closPT = closReligion[2]
 g = M[2]
 xx = g[0] - (closPT[0] - g[0])
 yy = g[1] - (closPT[1] - g[1])
 ptt = [xx, yy, 0]
 M.append (midPtWater (self.otherW, self.otherM, M[2], self.ceremony, self.entrance, self.Amitrary, ptt)) # midPt [3]
#setting the center of growing
newCen = newCenter (M[2], M[3], cofCenMove)
M[2] = newCen
prevousPt = newCen

if M[1]/10 == 0:
 GG = randint (0,1)
else:
 GG = M[1]/10
#trees growth
for i in range (GG):
 #looking for closest tree
 closTree = closestTreeToPoint (M[2], Trees)
 closTree = closTree[0]
 #making a circle in new tree position
 cmds.circle (c=(closTree[0], closTree[1], closTree[2]), r=1.5)
 cmds.planarSrf (d=1)
 #1 tree == 2 graves... so... looking for closest two graves to the tree and removing the from the list
 for i in range (2):
  closGrave = closestPointToPoints2 (closTree, allGraves)
  closGraveName = [closGrave[0],closGrave[1]]
  allGraves.remove (closGraveName)
 # stop recursion because allGraves list is empty
 if len(allGraves)==1:
  return "Done."
 # stop the loop if Trees list is empty
 if len(Trees) < closgrave =" closestPointToPoints2" closgravepos =" closGrave[1]" closgravename =" [closGrave[0],closGrave[1]]">= MAX:
  MN = 0
  M2 = closGrave[1]
  allGraves.remove (closGraveName)
  break
 else:
  M2 = M[2]
  #looking for angle rotate the box according it to face the center
  angle = angleBetweenVectors (M[2], closGravePos)
  #making the cube with size which is changing depends on counter
  cube = cmds.polyCube (w =size*(MN/MAX) ,h=size*(MN/MAX) ,d=size*(MN/MAX))
  CUBES.append (cube[0])
  #move the cube to the locator position
  cmds.move (closGravePos[0], closGravePos[1], closGravePos[2], cube)
  #rotate the cube to face the center of the religion
  cmds.rotate ( angle[0], angle[1], angle[2], cube, pivot=closGravePos )
  #remove the locator from the list with locators according to not to loop through it next time
  allGraves.remove (closGraveName)
  # draw a curve between center of the religion and the locator
  cmds.curve( p=[(M2[0],M2[1], M2[2]), (closGravePos[0], closGravePos[1], closGravePos[2])] )
  prevousPt = closGravePos
 # stop recursion because allGraves list is empty
 if len(allGraves)==1:
  return "Done."


#return "Done."
 cmds.refresh()

####### ALL THE RELIGIONS HAVE SIMILAR LOGIC BUT DIFFERENT NUMBERS
  
######BUDDISM######
closReligion = closestPointToPoints1 (B[2], ALLRELIG) #dist - [3]
if B[1] >= closReligion[1]:
 B.append (midPtWater (self.otherW, self.otherM, B[2], self.ceremony, self.entrance, self.Abuddhism, closReligion[2])) # midPt [3]
else:
 closPT = closReligion[2]
 g = B[2]
 xx = g[0] - (closPT[0] - g[0])
 yy = g[1] - (closPT[1] - g[1])
 ptt = [xx, yy, 0]
 B.append (midPtWater (self.otherW, self.otherM, B[2], self.ceremony, self.entrance, self.Abuddhism, ptt)) # midPt [3]
newCen = newCenter (B[2], B[3], cofCenMove)
B[2] = newCen
prevousPt = newCen

if B[1]/10 == 0:
 GG = randint (0,1)
else:
 GG = B[1]/10
for i in range (GG):
 closTree = closestTreeToPoint (B[2], Trees)
 closTree = closTree[0]
 cmds.circle (c=(closTree[0], closTree[1], closTree[2]), r=1.5)
 cmds.planarSrf (d=1)
 #print "closTree"
 #print closTree
 for i in range (2):
  closGrave = closestPointToPoints2 (closTree, allGraves)
  closGraveName = [closGrave[0],closGrave[1]]
  allGraves.remove (closGraveName)
 if len(allGraves)==1:
  return "Done."
 if len(Trees) < closgrave =" closestPointToPoints2" closgravepos =" closGrave[1]" closgravename =" [closGrave[0],closGrave[1]]">= MAX:
  BN = 0
  B2 = closGrave[1]
  allGraves.remove (closGraveName)
  break
 else:
  B2 = B[2]
  cube = cmds.polyCube (w =size*(BN/MAX) ,h=size*(BN/MAX) ,d=size*(BN/MAX))
  CUBES.append (cube[0])
  cmds.move (closGravePos[0], closGravePos[1], closGravePos[2], cube)
  allGraves.remove (closGraveName)
  cmds.curve( p=[(B2[0],B2[1], B2[2]), (closGravePos[0], closGravePos[1], closGravePos[2])] )
  prevousPt = closGravePos
 if len(allGraves)==1:
  return "Done."

 cmds.refresh()

######Catholics######
closReligion = closestPointToPoints1 (C[2], ALLRELIG) #dist - [3]
if C[1] >= closReligion[1]:
 C.append (midPtWater (self.otherW, self.otherM, C[2], self.ceremony, self.entrance, self.Acatholic, closReligion[2])) # midPt [3]
else:
 closPT = closReligion[2]
 g = C[2]
 xx = g[0] - (closPT[0] - g[0])
 yy = g[1] - (closPT[1] - g[1])
 ptt = [xx, yy, 0]
 C.append (midPtWater (self.otherW, self.otherM, C[2], self.ceremony, self.entrance, self.Acatholic, ptt)) # midPt [3]
newCen = newCenter (C[2], C[3], cofCenMove)
C[2] = newCen
prevousPt = newCen

if C[1]/10 == 0:
 GG = randint (0,1)
else:
 GG = C[1]/10
for i in range (GG):
 closTree = closestTreeToPoint (C[2], Trees)
 closTree = closTree[0]
 cmds.circle (c=(closTree[0], closTree[1], closTree[2]), r=1.5)
 cmds.planarSrf (d=1)
 #print "closTree"
 #print closTree
 for i in range (2):
  closGrave = closestPointToPoints2 (closTree, allGraves)
  closGraveName = [closGrave[0],closGrave[1]]
  allGraves.remove (closGraveName)
 if len(allGraves)==1:
  return "Done."
 if len(Trees) < closgrave =" closestPointToPoints2" closgravepos =" closGrave[1]" closgravename =" [closGrave[0],closGrave[1]]">= MAX:
  CN = 0
  C2 = closGrave[1]
  allGraves.remove (closGraveName)
  break
 else:
  C2 = C[2]
  cube = cmds.polyCube (w =size*(CN/MAX) ,h=size*(CN/MAX) ,d=size*(CN/MAX))
  CUBES.append (cube[0])
  cmds.move (closGravePos[0], closGravePos[1], closGravePos[2], cube)
  allGraves.remove (closGraveName)
  cmds.curve( p=[(C2[0],C2[1], C2[2]), (closGravePos[0], closGravePos[1], closGravePos[2])] )
  prevousPt = closGravePos
 if len(allGraves)==1:
  return "Done."

 cmds.refresh()

######Orthodox######
closReligion = closestPointToPoints1 (O[2], ALLRELIG) #dist - [3]
if O[1] >= closReligion[1]:
 O.append (midPtWater (self.otherW, self.otherM, O[2], self.ceremony, self.entrance, self.Aorthodox, closReligion[2])) # midPt [3]
else:
 closPT = closReligion[2]
 g = O[2]
 xx = g[0] - (closPT[0] - g[0])
 yy = g[1] - (closPT[1] - g[1])
 ptt = [xx, yy, 0]
 O.append (midPtWater (self.otherW, self.otherM, O[2], self.ceremony, self.entrance, self.Aorthodox, ptt)) # midPt [3]
newCen = newCenter (O[2], O[3], cofCenMove)
O[2] = newCen
prevousPt = newCen

if O[1]/10 == 0:
 GG = randint (0,1)
else:
 GG = O[1]/10
for i in range (GG):
 closTree = closestTreeToPoint (O[2], Trees)
 closTree = closTree[0]
 cmds.circle (c=(closTree[0], closTree[1], closTree[2]), r=1.5)
 cmds.planarSrf (d=1)
 #print "closTree"
 #print closTree
 for i in range (2):
  closGrave = closestPointToPoints2 (closTree, allGraves)
  closGraveName = [closGrave[0],closGrave[1]]
  allGraves.remove (closGraveName)
 if len(allGraves)==1:
  return "Done."
 if len(Trees) < closgrave =" closestPointToPoints2" closgravepos =" closGrave[1]" closgravename =" [closGrave[0],closGrave[1]]">= MAX:
  ON = 0
  O2 = closGrave[1]
  allGraves.remove (closGraveName)
  break
 else:
  O2 = O[2]
  cube = cmds.polyCube (w =size*(ON/MAX) ,h=size*(ON/MAX) ,d=size*(ON/MAX))
  CUBES.append (cube[0])
  cmds.move (closGravePos[0], closGravePos[1], closGravePos[2], cube)
  allGraves.remove (closGraveName)
  cmds.curve( p=[(O2[0],O2[1], O2[2]), (closGravePos[0], closGravePos[1], closGravePos[2])] )
  prevousPt = closGravePos
 if len(allGraves)==1:
  return "Done."

 cmds.refresh()

######HINDU######
closReligion = closestPointToPoints1 (H[2], ALLRELIG) #dist - [3]
if H[1] >= closReligion[1]:
 H.append (midPtWater (self.otherW, self.otherM, H[2], self.ceremony, self.entrance, self.Aprotest, closReligion[2])) # midPt [3]
else:
 closPT = closReligion[2]
 g = H[2]
 xx = g[0] - (closPT[0] - g[0])
 yy = g[1] - (closPT[1] - g[1])
 ptt = [xx, yy, 0]
 H.append (midPtWater (self.otherW, self.otherM, H[2], self.ceremony, self.entrance, self.Aprotest, ptt)) # midPt [3]
newCen = newCenter (H[2], H[3], cofCenMove)
H[2] = newCen
prevousPt = newCen

if H[1]/10 == 0:
 GG = randint (0,1)
else:
 GG = H[1]/10
for i in range (GG):
 closTree = closestTreeToPoint (H[2], Trees)
 closTree = closTree[0]
 cmds.circle (c=(closTree[0], closTree[1], closTree[2]), r=1.5)
 cmds.planarSrf (d=1)
 #print "closTree"
 #print closTree
 for i in range (2):
  closGrave = closestPointToPoints2 (closTree, allGraves)
  closGraveName = [closGrave[0],closGrave[1]]
  allGraves.remove (closGraveName)
 if len(allGraves)==1:
  return "Done."
 if len(Trees) < closgrave =" closestPointToPoints2" closgravepos =" closGrave[1]" closgravename =" [closGrave[0],closGrave[1]]">= MAX:
  HN = 0
  H2 = closGrave[1]
  allGraves.remove (closGraveName)
  break
 else:
  H2 = H[2]
  cube = cmds.polyCube (w =size*(HN/MAX) ,h=size*(HN/MAX) ,d=size*(HN/MAX))
  CUBES.append (cube[0])
  cmds.move (closGravePos[0], closGravePos[1], closGravePos[2], cube)
  allGraves.remove (closGraveName)
  cmds.curve( p=[(H2[0],H2[1], H2[2]), (closGravePos[0], closGravePos[1], closGravePos[2])] )
  prevousPt = closGravePos
 if len(allGraves)==1:
  return "Done."

 cmds.refresh()

######JUDAISM######
closReligion = closestPointToPoints1 (J[2], ALLRELIG) #dist - [3]
if J[1] >= closReligion[1]:
 J.append (midPtWater (self.otherW, self.otherM, J[2], self.ceremony, self.entrance, self.Ajudaism, closReligion[2])) # midPt [3]
else:
 closPT = closReligion[2]
 g = J[2]
 xx = g[0] - (closPT[0] - g[0])
 yy = g[1] - (closPT[1] - g[1])
 ptt = [xx, yy, 0]
 J.append (midPtWater (self.otherW, self.otherM, J[2], self.ceremony, self.entrance, self.Ajudaism, ptt)) # midPt [3]
newCen = newCenter (J[2], J[3], cofCenMove)
J[2] = newCen
prevousPt = newCen

if J[1]/10 == 0:
 GG = randint (0,1)
else:
 GG = J[1]/10
for i in range (GG):
 closTree = closestTreeToPoint (J[2], Trees)
 closTree = closTree[0]
 cmds.circle (c=(closTree[0], closTree[1], closTree[2]), r=1.5)
 cmds.planarSrf (d=1)
 #print "closTree"
 #print closTree
 for i in range (2):
  closGrave = closestPointToPoints2 (closTree, allGraves)
  closGraveName = [closGrave[0],closGrave[1]]
  allGraves.remove (closGraveName)
 if len(allGraves)==1:
  return "Done."
 if len(Trees) < closgrave =" closestPointToPoints2" closgravepos =" closGrave[1]" closgravename =" [closGrave[0],closGrave[1]]">= MAX:
  JN = 0
  J2 = closGrave[1]
  allGraves.remove (closGraveName)
  break
 else:
  J2 = J[2]
  cube = cmds.polyCube (w =size*(JN/MAX) ,h=size*(JN/MAX) ,d=size*(JN/MAX))
  CUBES.append (cube[0])
  cmds.move (closGravePos[0], closGravePos[1], closGravePos[2], cube)
  allGraves.remove (closGraveName)
  cmds.curve( p=[(J2[0],J2[1], J2[2]), (closGravePos[0], closGravePos[1], closGravePos[2])] )
  prevousPt = closGravePos
 if len(allGraves)==1:
  return "Done."

 cmds.refresh()

######PROTESTANTISM######
closReligion = closestPointToPoints1 (P[2], ALLRELIG) #dist - [3]
if P[1] >= closReligion[1]:
 P.append (midPtWater (self.otherW, self.otherM, P[2], self.ceremony, self.entrance, self.Ahindu, closReligion[2])) # midPt [3]
else:
 closPT = closReligion[2]
 g = P[2]
 xx = g[0] - (closPT[0] - g[0])
 yy = g[1] - (closPT[1] - g[1])
 ptt = [xx, yy, 0]
 P.append (midPtWater (self.otherW, self.otherM, P[2], self.ceremony, self.entrance, self.Ahindu, ptt)) # midPt [3]
newCen = newCenter (P[2], P[3], cofCenMove)
P[2] = newCen
prevousPt = newCen

if P[1]/10 == 0:
 GG = randint (0,1)
else:
 GG = P[1]/10
for i in range (GG):
 closTree = closestTreeToPoint (P[2], Trees)
 closTree = closTree[0]
 cmds.circle (c=(closTree[0], closTree[1], closTree[2]), r=1.5)
 cmds.planarSrf (d=1)
 #print "closTree"
 #print closTree
 for i in range (2):
  closGrave = closestPointToPoints2 (closTree, allGraves)
  closGraveName = [closGrave[0],closGrave[1]]
  allGraves.remove (closGraveName)
 if len(allGraves)==1:
  return "Done."
 if len(Trees) < closgrave =" closestPointToPoints2" closgravepos =" closGrave[1]" closgravename =" [closGrave[0],closGrave[1]]">= MAX:
  PN = 0
  P2 = closGrave[1]
  allGraves.remove (closGraveName)
  break
 else:
  P2 = P[2]
  cube = cmds.polyCube (w =size*(PN/MAX) ,h=size*(PN/MAX) ,d=size*(PN/MAX))
  CUBES.append (cube[0])
  cmds.move (closGravePos[0], closGravePos[1], closGravePos[2], cube)
  allGraves.remove (closGraveName)
  cmds.curve( p=[(P2[0],P2[1], P2[2]), (closGravePos[0], closGravePos[1], closGravePos[2])] )
  prevousPt = closGravePos
 if len(allGraves)==1:
  return "Done."

 cmds.refresh()

######ISLAM######
closReligion = closestPointToPoints1 (I[2], ALLRELIG) #dist - [3]
if I[1] >= closReligion[1]:
 I.append (midPtWater (self.otherW, self.otherM, I[2], self.ceremony, self.entrance, self.Aislam, closReligion[2])) # midPt [3]
else:
 closPT = closReligion[2]
 g = I[2]
 xx = g[0] - (closPT[0] - g[0])
 yy = g[1] - (closPT[1] - g[1])
 ptt = [xx, yy, 0]
 I.append (midPtWater (self.otherW, self.otherM, I[2], self.ceremony, self.entrance, self.Aislam, ptt)) # midPt [3]
newCen = newCenter (I[2], I[3], cofCenMove)
I[2] = newCen
prevousPt = newCen

if I[1]/10 == 0:
 GG = randint (0,1)
else:
 GG = I[1]/10
for i in range (GG):
 closTree = closestTreeToPoint (I[2], Trees)
 closTree = closTree[0]
 cmds.circle (c=(closTree[0], closTree[1], closTree[2]), r=1.5)
 cmds.planarSrf (d=1)
 #print "closTree"
 #print closTree
 for i in range (2):
  closGrave = closestPointToPoints2 (closTree, allGraves)
  closGraveName = [closGrave[0],closGrave[1]]
  allGraves.remove (closGraveName)
 if len(allGraves)==1:
  return "Done."
 if len(Trees) < closgrave =" closestPointToPoints2" closgravepos =" closGrave[1]" closgravename =" [closGrave[0],closGrave[1]]">= MAX:
  IN = 0
  I2 = closGrave[1]
  allGraves.remove (closGraveName)
  break
 else:
  I2 = I[2]
  cube = cmds.polyCube (w =size*(IN/MAX) ,h=size*(IN/MAX) ,d=size*(IN/MAX))
  CUBES.append (cube[0])
  cmds.move (closGravePos[0], closGravePos[1], closGravePos[2], cube)
  allGraves.remove (closGraveName)
  cmds.curve( p=[(I2[0],I2[1], I2[2]), (closGravePos[0], closGravePos[1], closGravePos[2])] )
  prevousPt = closGravePos
 if len(allGraves)==1:
  return "Done."

 cmds.refresh()

#duplicate and move all the cubes to see the growth progress after running the script
sss = cmds.duplicate( CUBES )
gr = cmds.group( sss )
cmds.select (gr, r=True)
cmds.move( 0, 300*N, 0 )

#run the recursion again if there are more elements in the locators list then 0
if len(allGraves)>0:  
 self.GROWTH (Way, minGrow, maxGrow, size, allGraves, M2, B2, C2, O2, H2, J2, P2, I2, N, MN, BN, CN, ON, HN, JN, PN, IN, CUBES, MAX = 150.0, cofCenMove=10)
else:
 return "Done."

to run the script


g= graves()
allGraves=g.allLocs()
g.getAll()
g.changeNetBecauseRepulsive()
allGraves = g.allLocs1()
g.deleteTrees ()
#'Random'-1 'Normal'-2 'War'-3
g.GROWTH (1,3,80,1.5,allGraves,0,0,0,0,0,0,0,0)

maya file

Crowd system - first attempt

2009-08-07T13:05:00.002+02:00

It doesn't always consider the obstacles as it should. Sometimes the objects are rejected (although they should be deleted) and sometimes they just ignore the obstacles.

#######################################################################################################
##
## Crowd System
## student Andreea Nica
##
## Active agents: predacious & small fishes
## Passive agents: edge & fishing line
##
## Rules:
## - fishes meet the edge - delete fishes
## - fishes meet the fishing line - delete fishes
## - small fish meets predacious - delete small fish
## - small fish meets small fish - scale 0.5
## - predacious meets predacious - duplicate predacious
##
#######################################################################################################

import maya.cmds as cmds
from random import *

def hit(hit, agent):
### define what to do when it some collision is detected
#all transformations are made only on the agent, as the hit object will perform the same queries on this agent
#if it hit the cube, ignore
if hit == "wall_rigid":
return
agentRole = cmds.getAttr(agent + ".role")
hitRole = cmds.getAttr(hit + ".role")
if hitRole == agentRole:
#check if both are bad
if hitRole == "bad":
#then delete - edge rule
cmds.delete('agent')
else:
#if good, increase size
cmds.delete( 'agent')
elif hitRole != agentRole:
if hitRole == "bad":
#means agent role is good (small fish)
cmds.scale(.5,.5,.5, agent, r=1)
elif hitRole == "good":
#means agent was bad (predacious - duplicate)
cmds.duplicate( 'agent')

class Agent:
def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="cube", rigidType="active", bounciness=.6, collide=1):
#set agent atributes
self.bounciness = bounciness
self.collide = collide
self.rigidType = rigidType
self.solver=solver
self.role = role
self.initialScale = size
#create the agent and scale it
self.object = cmds.polyCube(ax=(0,0,1))
cmds.scale(size[0], size[1], size[2])
#apply a color to the agent
#set the object color
#sh = createShader(color, transparency=0, type="lambert")
#applyShaderOnObject(self.object[0], sh)

#create the rigid body
self.rigid = cmds.rigidBody(self.object,
name=self.object[0] + "_rigid",
p=position,
b=self.bounciness,
impulse=(0,0,0),
sio=objType, #stand in object
cc = 1, #contact count
cp = 1, #contact position
cn = 1, #contact name
solver=self.solver)

#add attribute to the rigid body to store the type of agent
cmds.select(self.rigid, r=1)
cmds.addAttr(ln="role", dt="string", keyable=1)
cmds.setAttr(self.rigid + ".role", "good", type="string")

if self.rigidType == "active":
cmds.setAttr(self.rigid + ".active", 1)
else:
cmds.setAttr(self.rigid + ".active", 0)

#apply the expression
self.applyExpression()

def applyExpression(self):
"Function to apply the expression to the agent"
#first disconnect the rotation attributes because we want to controll it via expressions
cmds.disconnectAttr (self.rigid + "ry.output", self.object[0] + ".rotateY")
cmds.disconnectAttr (self.rigid + "rx.output", self.object[0] + ".rotateX")
cmds.disconnectAttr (self.rigid + "rz.output", self.object[0] + ".rotateZ")
# Create expression for VehicleF with a random multiplier added to the expression.
randX = random.uniform(-3,3)
randY = random.uniform(3,-3)
####COMPOSE THE EXPRESSION STRING

#now put the text above in a python string
#the first lines define how the agent will wander
expString = "// Set wander motion of vehicle and add random multipliers.\n"
expString += "%s.impulseX" % self.rigid
expString += " = sin(time * %f);\n" % randX
expString += "%s.impulseY" % self.rigid
expString += " = (noise(time) * %f);\n\n" % randY
#the second part, how it rotates according to the direction it is going (velocity vector)
expString += "// Set orientation of Vehicle according to the velocity direction.\n"
expString += "float $fVel[];\n"
expString += "$fVel = `getAttr %s.velocity`;\n\n" % (self.rigid)
expString += "%s.rotateX = 0;\n" % self.object[0]
expString += "%s.rotateZ = atan2d( $fVel[0], $fVel[1] );\n" % (self.object[0])
expString += "%s.rotateY = 0;\n\n" % self.object[0]
#the third part, checking bumps on other agents
expString += "//checking bumps on other agents\n"
expString += "string $lastHit;\n"
expString += "if (%s.contactCount > 0){\n" % self.rigid
expString += " int $contactCount = `getAttr %s.contactCount`;\n" % self.rigid
expString += " $lastHit = `getAttr %s.contactName[0]`;\n" %self.rigid
expString += ' string $rigid = "%s";\n' % self.rigid
expString += ' python("hit(\'"+$lastHit+"\', \'"+ $rigid +"\')");\n'
expString += "};//endif\n"

self.expString = expString
cmds.expression(s=expString)

class Crowd:
def __init__(self):
"Initialize attributes"
#objects for obstacles
self.collectObjects = []
#number of vehicles
self.vNumber = 0
#boolean for obstacles
self.obst = 0
#boolean for global forces
self.gforces = 0
#dictionary for UI elements
self.UIelements = {}
#set timeline
cmds.playbackOptions(min= 1, max=1000)
#get selected objects
self.collectObjects = cmds.ls(sl=1)
#start UI
self.crowdSystemUI()

def crowdSystemUI(self):
"Assembles and displays the UI for the Crowd System"
self.UIelements["window"] = cmds.window(title="Crowd System",
widthHeight=(300, 200)
)

self.UIelements["form"] = cmds.formLayout()
txt = cmds.text(label="Number of Vehicles")
collection = cmds.radioCollection()
radiob1 = cmds.radioButton(label="10", data=1, changeCommand=self.changeVnumber)
radiob2 = cmds.radioButton(label="20", onCommand="vNumber = 20")
cmds.setParent(upLevel=1)
cmds.setParent(upLevel=1)

txtOB = cmds.text(label="Obstacles")
collection2 = cmds.radioCollection()
radiob3 = cmds.radioButton(label="On", changeCommand=self.changeObst)
radiob4 = cmds.radioButton(label="Off")
cmds.setParent(upLevel=1)
cmds.setParent(upLevel=1)

txtGF = cmds.text( label = "Global Forces")
collection3 = cmds.radioCollection()
radiob5 = cmds.radioButton(label= "On" ,changeCommand =self.changeGforces)
radiob6 = cmds.radioButton(label="Off")
cmds.setParent(upLevel=1)
cmds.setParent(upLevel=1)

cmds.radioCollection(collection, edit=1, select=radiob1)
cmds.radioCollection(collection2, edit=1, select=radiob4)
cmds.radioCollection(collection3, edit=1, select=radiob6)

# Place Vehicle options
form = self.UIelements["form"]
cmds.formLayout(form,
edit=1,
attachForm= [
( txt, "top", 20),
(txt ,"left", 70),
(radiob1,"top", 10),
(radiob1,"left", 20),
(radiob2,"top", 30),
(radiob2,"left", 20)
]
)
# Place environment options
cmds.formLayout(form,
edit=1,
attachForm= [
(txtOB, "top", 80),
(txtOB, "left", 80),
(radiob3, "top", 80),
(radiob3, "left", 150),
(radiob4 ,"top", 80),
(radiob4, "left", 190),
(txtGF, "top", 110),
(txtGF, "left", 63),
(radiob5, "top", 110),
(radiob5, "left", 150),
(radiob6, "top", 110),
(radiob6, "left", 190)
]
)
# Create buttons
button1 = cmds.button(label = "Create")
button2 = cmds.button(label = "Cancel")

# Place buttons in the window
cmds.formLayout(form,
edit=1,
attachForm =[
(button1, "bottom", 10),
(button1, "left", 185),
(button2, "bottom", 10),
(button2, "right", 10)
]
)
# Add the commands to the buttons.
cmds.button(button1, edit=1, command=self.createCrowd )
cmds.button(button2, edit=1, command=self.deleteUI )

cmds.showWindow(self.UIelements["window"])
## UI help functions
def changeVnumber(self, *args):
if args[0] == "true":
self.vNumber = 10
else:
self.vNumber = 20
print "vNumber:",self.vNumber
def changeObst(self, *args):
if args[0] == "true":
self.obst = 1
else:
self.obst = 0
print "Obst:", self.obst
def changeGforces(self, *args):
if args[0] == "true":
self.gforces = 1
else:
self.gforces = 0
print "gforces:", self.gforces
def deleteUI(self, *args):
cmds.deleteUI(self.UIelements["window"])
self.UIelements["window"] = ""

## MAIN METHODS
def createCrowdSolver(self):
"Creates the main rigidSolver for the elements in the Crowd System"
self.crowdSolver = cmds.rigidSolver( create=1,
current=1,
name="crowdSolver",
velocityVectorScale=0.5,
displayVelocity=1
)
cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)

def createVehicle(self, vType, N):
"Creates one vehicle and add fields and expressions to it."
#first verify if the vehicle is of type follower (F) or leader (L)
#and set the size of the cube according to the type (leaders are bigger! :)
if vType == "F":
w = 1 #width
h = .5 #height
d = 1 #depth
else:
w = 5
h = 3
d = 5

#creates the basic cube
vehicle = cmds.polyCube(w=w,d=d,h=h)

#create a vehicle force to the agent
field = cmds.radial(position = [0,0,0],
magnitude = 50, #positive magnitude means repoulsion, negative magnitude means atraction
attenuation = 0.3,
maxDistance = 8.0
)

cmds.parent(field[0],vehicle[0])
cmds.hide(field)

if vType == "L":
Lfield = cmds.radial(position = [0,0,0],
magnitude =-1,
attenuation = .2,
maxDistance = 50
)
cmds.parent(Lfield[0],vehicle[0])
cmds.hide(Lfield)

#convert it to a rigid body with random placement
rigid = cmds.rigidBody(
vehicle[0],
n="rigidVeh1%s%d" % (vType, N),
active=1,
mass=1,
bounciness=0,
damping=1.5,
position=(uniform(-70,70),uniform(-70,70),0),
impulse=(0,0,0),
standInObject="cube",
solver=self.crowdSolver
)

#disconnect the rotation attributes of the vehicle
cmds.disconnectAttr(rigid + "rx.output", vehicle[0]+".rx")
cmds.disconnectAttr(rigid + "ry.output", vehicle[0]+".ry")
cmds.disconnectAttr(rigid + "rz.output", vehicle[0]+".rz")

#add expression for movement
randX = uniform(-3,3)
randY = uniform(-3,3)

expString = "%s.impulseX = sin(time * %f);" % (rigid, randX)
expString += "%s.impulseY = (noise(time)*%f);" % (rigid, randY)
expString += "float $Vel[] = `getAttr %s.velocity`;" % rigid
expString += "%s.rotateX = 0;" % vehicle[0]
expString += "%s.rotateY = 0;" % vehicle[0]
expString += "%s.rotateZ = atan2d( $Vel[0], $Vel[2] );" % vehicle[0]

cmds.expression(s=expString)

if vType== "F":
return [rigid,field]
else:
return [rigid, field, Lfield]

def createCrowd(self, *args):
"Method to assemble the whole system"
#creates a rigidSolver to add the vehicle to
self.createCrowdSolver()
#turn on the velocity arrow
cmds.setAttr(self.crowdSolver + ".displayVelocity", 1)
cmds.setAttr(self.crowdSolver + ".scaleVelocity", .5)

#allow disconnections on the rigidSolver
cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)

##create amount of agents
if self.vNumber == 10: #vNumber = number of vehicles
FNumber = 8 #followers
LNumber = 2 #leaders
elif self.vNumber ==20:
FNumber =18
LNumber =2

#create empty lists to store followers and leaders
followers = []
leaders = []

#creating the followrs
for i in range(FNumber):
v = self.createVehicle("F",i)
followers.append(v)
#creating the leaders
for i in range(LNumber):
v = self.createVehicle("L",i)
leaders.append(v)

#CONNECT THE FIELDS TO THE RIGID BODIES (AGENTS)
#1) connect the leaders (predacious fishes) to the followers (small fishes)
for i in range (LNumber):
Lfield = leaders[i][2]
lfield = leaders[i][1]
for j in range(FNumber):
Frigid = followers[j][0]
#connect the fields
cmds.connectDynamic(Frigid, fields=Lfield)
cmds.connectDynamic(Frigid, fields=lfield)

#2) connect followers (small fishes) to leaders (predacious fishes)
for i in range(FNumber):
Ffield = followers[i][1]
for j in range(LNumber):
Lrigid = leaders[j][0]
cmds.connectDynamic(Lrigid, fields=Ffield)

#3) connect leaders (predacious fishes) to leaders ((predacious fishes))
for i in range(LNumber):
Lfield = leaders[i][1]
for j in range(LNumber):
if i==j: continue
L1rigid = leaders[j][0]
cmds.connectDynamic(L1rigid, fields=Lfield)

#4) connect followers (small fishes) to followes (small fishes)
for i in range(FNumber):
Ffield = followers[i][1]
for j in range(FNumber):
if i==j: continue
F1rigid = followers[j][0]

cmds.connectDynamic(F1rigid, fields=Ffield)

#create obstacles if I want
if self.obst: self.collectObstacles()

#disable solver warnings
cmds.cycleCheck(e=0)

def collectObstacles(self):
"Collects all obstacles"
if len(self.collectObjects) == 0:
#there is nothing selected
return "There is nothing selected!"

for o in self.collectObjects:
cmds.rigidBody( o,
passive=1,
name=o+"_rb",
bounciness=2.0 )

### create an instance of this class
c = Crowd()

2009-08-06T17:28:00.001+02:00

Assignment01B

2009-08-06T17:08:00.002+02:00

I managed to make the part with the rotation and the scale of the square but when i tried to make it recursive i could not manage to select all the time the last square created. I tried to make a list where to store all of them and always refer to it from the list but it doesn't work as well.

###########################
###assignment01B
###student Andreea Nica

import maya.cmds as cmds

def squares (it,i):

##select the needed sides of the square
t=i-1
cmds.select('nurbsSquare%d'%t)
isSides = cmds.filterExpand(sm=9)

line1 = isSides[0]
line2 = isSides[1]

##get the point on the side of the square at the specific proportion
poc1 = cmds.pointOnCurve( line1, pr=perc1, top=True, p=True ) #rightnurbsSquare
poc2 = cmds.pointOnCurve( line2, pr=perc2, top=True, p=True )

##find the corner of the square in order to find the exact position where the second square will be moved
perc3 =1
corner = cmds.pointOnCurve( line2, pr=perc3, top=True, p=True )

##create the second square

cmds.duplicate('nurbsSquare%d'%t)
if t <> 1:
SquaresList.append('nurbsSquare%d'%t)

##find the position where the last square will be placed
x = corner[0]-poc1[0]
xx=float(x/3)
y= corner[0]
yy=float(y/3)

##move the square
cmds.move (xx,yy,0, 'nurbsSquare%d'%i)
cmds.select('nurbsSquare%d'%i)

##find the pivot for scale and rotation
x1=float(poc2[0])
y1=float(poc2[1])

##scale and rotate
cmds.scale( .8, .8, .8, 'nurbsSquare%d'%i, pivot=(x1, y1, 0), absolute=True )
cmds.rotate(0,0,'20deg',pivot=(x1, y1, 0),absolute=True)

##select only the last square created
cmds.select( clear=True )
cmds.select('nurbsSquare%d'%i)

cmds.hide('nurbsSquare%d'%t)

##check if the last iteration was reached or not
if it == 0 :
#stop
cmds.showHidden( all=True )
print 'gataaaaaaaaaaaaaaaa'
return "Done."
else:
#did not finish yet
#remove one unit (count down)
it -= 1
i += 1

squares(it,i)

##create the initial square
initialSquare = cmds.nurbsSquare( sl1=10, sl2=10 )
isSides = cmds.filterExpand(sm=9)
print isSides
perc1 = 1./3
perc2 = 2./3

SquaresList = []
SquaresList.append('nurbsSquare1')
print SquaresList
##call the recursive function

squares(4,2)

print 'Final List'
print SquaresList

Alice_Assignment01+03

2009-07-30T14:36:00.003+02:00

To see the animation :

http://www.vimeo.com/5838178

Assignment 01B, fianl, Liu

2009-07-28T00:37:00.002+02:00


























#######################################################

# Assignment 01B Recursion

# Editted by Liu, Ko-cheng

# Logic:

#  Step1: Set up initial conditions

#	 setup01): Create Biggest and smallest circles

#    setup02): Make these two circles tangent

#  Step2: Define the principles of how to get the next cirlce tangent with previous two

#  Step3: Start the recursion by the loop

###########################################################







import maya.cmds as cmds



#Step1:Define the biggest and smallest circles

BigRadius=30

SmallRadius=2

Minus= BigRadius-SmallRadius



# Create these two circles which are tangent to each other

cmds.circle(c=(0,0,0),r=30)

cmds.circle(c=(0,-28,0),r=2)



#Step2:Generate two circles which follow the tangent princples

#2.1)r1+r2=D

NextRadius=SmallRadius+1

D= NextRadius+SmallRadius

cmds.circle(n="Mcircle",c=(0,-28,0),r=D)



#2.2)offset the outmost circle based on the radius of next circle 

cmds.circle(n="Moffset",c=(0,0,0), r=BigRadius-NextRadius)

#2.3)Get the intersection point at the right side and as the center point of the new circle

#  which is tangent with previous two circles



inters = cmds.curveIntersect('Mcircle','Moffset')

inters = inters.split()

print inters

inters1 = inters[1:2]

for i in inters1:

	u = float(i)

	pos1=cmds.pointOnCurve("Mcircle", p=1, pr=u)

	myCircle=cmds.circle(c=pos1,r=3)

cmds.delete('Mcircle','Moffset')



#Step3: Loop through it based on previous steps

for i in range(1,BigRadius-3,1):

	cmds.circle(n="myOffset"+str(i),c=(0,0,0),r=Minus-i-1)

	cmds.rotate

	radius=2+i

	r1= radius

	r2= radius+1

	D=r1+r2

	

	cmds.circle(n="mycircle"+str(i),c=pos1,r=D)

	cmds.rotate(0,0,20*i,cp=u)

	myInters= cmds.curveIntersect('mycircle'+str(i),'myOffset'+str(i))

	myInters= myInters.split()

	print myInters

	

	myInters= myInters[0:2]

	for j in myInters:

		u=float(j)

		if 4 < pos2="cmds.pointOnCurve(" p="1,pr="u)" mycircle="cmds.circle(c="pos2,r="i+3)" pos1="pos2">

Assignment 03 Shi xinyu & Liu

2009-07-28T00:21:00.002+02:00

There are still some problems among the scripting, we would like to ask how to solve the problems.
1) Since our initial idea is to show the good and bad objects in certain time, and the agent will be attracted. But we couldn't find out how to show the object in some specific times. (Which command we need to use in the scripting?)
2) We can make it work when the agent hits the good angel, but not working in Bad Evil. We still don't know why it doesn't work. We know the "hit" part is among the mel scripting and we couldn't understand the mel code so well.

These are the two main problems we have met so far. We have done our best, and thank you for your teaching in whole semester!

Liu & Shi

Assignment 03 Shi xinyu & Liu

2009-07-28T00:01:00.001+02:00


################################################################
## Assignment03 Crowd System
## Professor: Daniel da Rocha
## Students: Liu, ko-cheng & Shi, xinyu
##
## Logic
##   Create 3 kinds of objs
##     1. agent
##       a) active movement
##     2. Good Angel (helps increase the size of agent)
##       a) passive movement
##     3. Bad Evil (shrink the size of agent)
##   a) non-movable
##   When the agents hit the Good Angel, they increase the size.
##   On ther other hand, they shrink when they hit the Bad Evil
##
## Initial Set up:
##   1. Create a cyclinder as wall that holds all the objs inside 
###################################################################

import maya.cmds as cmds
import maya.mel as mel
import random
import math

def hit(hit, agent, GoodAngel, BadEvil):
 ### define what to do when it some collision is detected
 #all transformations are made only on the agent, as the hit object will perform the same queries on this agent
 #if it hit the cube, ignore
 if hit == "wall_rigid":
  return
 agentRole = cmds.getAttr(agent + ".role")
 hitRole = cmds.getAttr(hit + ".role")
 GoodAngelRole= cmds.getAttr(GoodAngel+".role")
 BadEvilRole= cmds.getAttr(BadEvil+".role")
 if hitRole == GoodAngelRole:
  if hitRole== "good":
   cmds.scale(1.1,1.1,1.1, agent, r=1)
 elif hitRole == GoodAngelRole:
  if hitRole == "bad":
   cmds.scale(.1,.1,.1, agent, r=1)
 elif hitRole == agentRole:
  #check if both are bad
  if hitRole == "bad":
   #then shrink
   cmds.scale(.9,.9,.9, agent, r=1)
  else:
   #if good, increase size
   cmds.scale(1.1,1.1,1.1, agent, r=1)
 elif hitRole != agentRole:
  if hitRole == "bad":
   #means agent role is good
   cmds.scale(.90,.90,.90, agent, r=1)
  elif hitRole == "good":
   #means agent was bad
   cmds.scale(1.1,1.1,1.1, agent, r=1)

   
#function to create shader
def createShader(color, transparency=0, type="lambert"):
 #steps to create a new material
 shadingNode1 = cmds.shadingNode(type, asShader=1)
 shadingNode2 = cmds.sets(renderable=1, noSurfaceShader = 1, empty=1, name=shadingNode1+"SG")
 cmds.connectAttr(shadingNode1+".outColor", shadingNode2 + ".surfaceShader", force=1)
 #steps to modify material attributes
 cmds.setAttr(shadingNode1 + ".color", color[0],color[1], color[2]) #color in r g b values
 cmds.setAttr(shadingNode1 + ".transparency", transparency, transparency, transparency)
 
 return shadingNode2
 
def applyShaderOnObject(obj, shader):
 cmds.sets(obj, e=1, forceElement=shader)




class Agent:
 def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="cube", rigidType="active", bounciness=.6, collide=1):
  #set agent atributes
  self.bounciness = bounciness
  self.collide = collide
  self.rigidType = rigidType
  self.solver=solver
  self.role = role
  self.initialScale = size
  #create the agent and scale it
  self.object = cmds.polyCube(ax=(0,0,1))
  cmds.scale(size[0], size[1], size[2])
  #apply a color to the agent
  #set the object color
  sh = createShader(color, transparency=0, type="lambert")
  applyShaderOnObject(self.object[0], sh)
  
  #create the rigid body
  self.rigid = cmds.rigidBody(self.object,
         name=self.object[0] + "_rigid",
         p=position,
         b=self.bounciness,
         impulse=(0,0,0),
         sio=objType, #stand in object
         cc = 1, #contact count
         cp = 1, #contact position
         cn = 1, #contact name
         solver=self.solver)
         
  #add attribute to the rigid body to store the type of agent
  cmds.select(self.rigid, r=1)
  cmds.addAttr(ln="role", dt="string", keyable=1)
  cmds.setAttr(self.rigid + ".role", "good", type="string")

  if self.rigidType == "active":
   cmds.setAttr(self.rigid + ".active", 1)
  else:
   cmds.setAttr(self.rigid + ".active", 0)
   
  #apply the expression
  self.applyExpression()
 
 def applyExpression(self):
  "Function to apply the expression to the agent"
  #first disconnect the rotation attributes because we want to controll it via expressions
  cmds.disconnectAttr (self.rigid + "ry.output", self.object[0] + ".rotateY")
  cmds.disconnectAttr (self.rigid + "rx.output", self.object[0] +  ".rotateX")
  cmds.disconnectAttr (self.rigid + "rz.output", self.object[0] + ".rotateZ")
  # Create expression for VehicleF with a random multiplier added to the expression.
  randX = random.uniform(-3,3)
  randY = random.uniform(3,-3)
  ####COMPOSE THE EXPRESSION STRING
  #this is how it should look like (in MEL)
  '''
  // Set wander motion of vehicle and add random multipliers.
  pCube1_rigid_0.impulseX = sin(time * -2.808801);
  pCube1_rigid_0.impulseY = (noise(time) * -1.041035);

  // Set orientation of Vehicle according to the velocity direction.
  float $fVel[];
  $fVel  = `getAttr pCube1_rigid_0.velocity`;

  pCube1.rotateX = 0;
  pCube1.rotateZ = atan2d( $fVel[0], $fVel[1] );
  pCube1.rotateY = 0;
  
  //checking bumps on other agents
  string $lastHit;
  if (pCube1_rigid_0.contactCount > 0){
   int $contactCount = `getAttr pCube1_rigid_0.contactCount`;
   $lastHit = `getAttr pCube1_rigid_0.contactName[0]`;
   string $rigid = "pCube1_rigid_0";
   string $rigid01 = "pSphere1_rigid_0";
   python("hit('"+$lastHit+"', '"+ $rigid +"','"+rigid01+"')");
  };//endif
  '''
  #now put the text above in a python string
  #the first lines define how the agent will wander
  expString = "// Set wander motion of vehicle and add random multipliers.\n"
  expString += "%s.impulseX" % self.rigid
  expString += " = sin(time * %f);\n" % randX
  expString += "%s.impulseY" % self.rigid
  expString += " = (noise(time) * %f);\n\n" % randY
  #the second part, how it rotates according to the direction it is going (velocity vector)
  expString += "// Set orientation of Vehicle according to the velocity direction.\n"
  expString += "float $fVel[];\n"
  expString += "$fVel  = `getAttr %s.velocity`;\n\n" % (self.rigid)
  expString += "%s.rotateX = 0;\n" % self.object[0]
  expString += "%s.rotateZ = atan2d( $fVel[0], $fVel[1] );\n" % (self.object[0])
  expString += "%s.rotateY = 0;\n\n" % self.object[0]
  #the third part, checking bumps on other agents
  expString += "//checking bumps on other agents\n"
  expString += "string $lastHit;\n"
  expString += "if (%s.contactCount > 0){\n" % self.rigid
  expString += "  int $contactCount = `getAttr %s.contactCount`;\n" % self.rigid
  expString += "  $lastHit = `getAttr %s.contactName[0]`;\n" %self.rigid
  expString += '  string $rigid = "%s";\n' % self.rigid
  expString += '  string $rigid01 = "%s";\n' % self.rigid
  expString += '  string $rigid02 = "%s";\n' % self.rigid
  expString += '  python("hit(\'"+$lastHit+"\', \'"+ $rigid +"\',\'"+ $rigid01 +"\',\'"+ $rigid02 +"\')");\n'
  expString += "};//endif\n"
  
  
  
  self.expString = expString
  cmds.expression(s=expString)  
  
class Goodobj:
 def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="cube", rigidType="active", bounciness=.6, collide=1):
  #set Goodobj atributes
  self.bounciness = bounciness
  self.collide = collide
  self.rigidType = rigidType
  self.solver=solver
  self.role = role
  self.initialScale = size
  #create the agent and scale it
  self.object = cmds.polySphere(ax=(0,0,1))
  cmds.scale(size[0], size[1], size[2])
  #apply a color to the agent
  #set the object color
  sh = createShader(color, transparency=0, type="lambert")
  applyShaderOnObject(self.object[0], sh)
  
  #create the rigid body
  self.rigid01 = cmds.rigidBody(self.object,
         name=self.object[0] + "_rigid",
         p=position,
         b=self.bounciness,
         impulse=(0,0,0),
         sio=objType, #stand in object
         cc = 1, #contact count
         cp = 1, #contact position
         cn = 1, #contact name
         solver=self.solver)
         
  #add attribute to the rigid body to store the type of agent
  cmds.select(self.rigid01, r=1)
  cmds.addAttr(ln="role", dt="string", keyable=1)
  cmds.setAttr(self.rigid01 + ".role", "good", type="string")

  if self.rigidType == "active":
   cmds.setAttr(self.rigid01 + ".active", 1)
  else:
   cmds.setAttr(self.rigid01 + ".active", 0)

   
class Badobj:
 def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="cube", rigidType="active", bounciness=.6, collide=1):
  #set Goodobj atributes
  self.bounciness = bounciness
  self.collide = collide
  self.rigidType = rigidType
  self.solver=solver
  self.role = role
  self.initialScale = size
  #create the agent and scale it
  self.object = cmds.polyCone(ax=(0,0,1))
  cmds.scale(size[0], size[1], size[2])
  #apply a color to the agent
  #set the object color
  sh = createShader(color, transparency=0, type="lambert")
  applyShaderOnObject(self.object[0], sh)
  
  #create the rigid body
  self.rigid02 = cmds.rigidBody(self.object,
         name=self.object[0] + "_rigid",
         p=position,
         b=self.bounciness,
         impulse=(0,0,0),
         sio=objType, #stand in object
         cc = 1, #contact count
         cp = 1, #contact position
         cn = 1, #contact name
         solver=self.solver)
         
  #add attribute to the rigid body to store the type of agent
  cmds.select(self.rigid02, r=1)
  cmds.addAttr(ln="role", dt="string", keyable=1)
  cmds.setAttr(self.rigid02 + ".role", "good", type="string")

  if self.rigidType == "active":
   cmds.setAttr(self.rigid02 + ".active", 0)
  else:
   cmds.setAttr(self.rigid02 + ".active", 0)

##############################################
class Crowd:
 def __init__(self, numAgents=20, numGoodobjs=20, numBadobjs=20,minPosition=-70, maxPosition=70, walls=0):
  #set the playback options to increase the time range
  cmds.playbackOptions(min= 1, max=5000)
  self.numAgents = numAgents
  self.numGoodobjs= numGoodobjs
  self.numBadobjs= numBadobjs
  self.minPosition = minPosition
  self.maxPosition = maxPosition
  #get any selected objects
  self.wallObjs = cmds.ls(sl=1)
  #create the rigid solver
  self.solver = self.createSolver()
  #create the agents
  self.createAgents()
  #create the goodobjs
  self.createGoodobj()
  #create the badobjs
  self.createBadobj()
  #create the walls
  if walls: self.makeWalls()
  
 def createSolver(self):
  solver = cmds.rigidSolver( create=1,
            current=1,
            name="crowdSolver",
            velocityVectorScale=0.5,
            displayVelocity=1,
            sc=1, #showcollision
            ctd=1 #contact data
            )
  cmds.setAttr(solver + ".allowDisconnection", 1)
  return solver
  
 def createAgents(self):
  type = ["good", (3,3,3), (1,1,0)] #name, scale, color
  self.goodAgents = []
  for i in range(self.numAgents):
   #get the agent type randomly
   #get random x and y
   x = random.uniform(self.minPosition,self.maxPosition)
   y = random.uniform(self.minPosition,self.maxPosition)
   #create the agents
   a = Agent(self.solver, type[0], color=type[2], size=type[1], position=(x,y,0))

   self.goodAgents.append(a)
 def createGoodobj(self):
   type = ["good", (3,3,3), (1,0,0)] #name, scale, color
   self.goodobjs = []
   for i in range(self.numGoodobjs):
    #get the agent type randomly
    #get random x and y
    x = random.uniform(self.minPosition,self.maxPosition)
    y = random.uniform(self.minPosition,self.maxPosition)
    #create the agents
    a = Goodobj(self.solver, type[0], color=type[2], size=type[1], position=(x,y,0))
 
    self.goodobjs.append(a)

 def createBadobj(self):
   type = ["bad", (2,2,2), (0,0,0)] #name, scale, color
   self.Badobjs = []
   for i in range(self.numBadobjs):
    #get the agent type randomly
    #get random x and y
    x = random.uniform(self.minPosition,self.maxPosition)
    y = random.uniform(self.minPosition,self.maxPosition)
    #create the agents
    a = Badobj(self.solver, type[0], color=type[2], size=type[1], position=(x,y,0))
    self.Badobjs.append(a)


 def makeWalls(self):
  #get selected object,
  #which should be already with its normals facing to the right directions,
  #and convert it to passive rigid bodies
  if len(self.wallObjs) == 0:
   return "No wall objects were selected."
  else:
   for w in self.wallObjs:
    self.wallRigid = cmds.rigidBody(w, passive=1, name= "wall_rigid", bounciness=.8)
########################################
c=Crowd(numAgents=2,numGoodobjs=10,numBadobjs=20,walls=1)

assignment 01B-Shi Xinyu

2009-07-27T23:45:00.005+02:00


       ###############################################################
## Assignment 01
## Pof.Daniel da Rocha 
## Student.SHI Xinyu
###############################################################

# logic
# 1) creste an initial square
# 2) find these two points (pocA & pocB) for rotate the square:
#   1) get current line
#  2) use pointOnCurve find the four points of the square
#  3) use the formula to find the pocA or pocB
#   1) if this is even number times, find pocA as rotation piont
#   2) if this is odd number times, find pocB as rotation piont
# 3) select the initail square
# 4) copy & rotate the square by pocA or pocB
# 5) select the last square and run this again

import maya.cmds as cmds

# creating initial square
mySquare = cmds.nurbsSquare(sl1=6,sl2=20)

def realRecursionOpt2(iterations):
 #select mySquare  
 cmds.select( cl=1 ) 
 cmds.select( mySquare )   
 mySquareNew = cmds.duplicate( mySquare )  
 
 sides = cmds.filterExpand( sm=9 )  
   
 #create a list to store the positions  
 positions = []  
 for i in range( len(sides)  ):  
     pos = cmds.pointPosition( sides[i] +".cv[0]" )  
     positions.append(pos)  
 print positions
 
 Xa = ((positions[1][0] + positions[2][0])/2 + positions[0][0])/2
 Ya = ((positions[1][1] + positions[2][1])/2 + positions[0][1])/2
 Za = ((positions[1][2] + positions[2][2])/2 + positions[0][2])/2
 
 Xb = ((positions[1][0] + positions[2][0])/2 + positions[3][0])/2
 Yb = ((positions[1][1] + positions[2][1])/2 + positions[3][1])/2
 Zb = ((positions[1][2] + positions[2][2])/2 + positions[3][2])/2
 
 if iterations/2 ==0:
  cmds.rotate( 0,0,30, pivot=(Xa, Ya, Za) )
 else:
  cmds.rotate( 0,0,30, pivot=(Xb, Yb, Zb) )
  
 mySquare = mySquareNew

 #recursion part
 if iterations ==0:
  return "Done"
 else:
  iterations -=1
  realRecursionOpt2(iterations)

realRecursionOpt2(1)

Assignment 03 B - second try

2009-07-21T01:53:00.002+02:00

This is what should be our assignment. The error is the same like in the previous script. Here we added more pavilions and a field for each pavilion and we connected the elements.



###############crowd system
###Assignment 03B

#generate random static attractors
#generate random static repulsors
#generate random dynamic principle attractors
#generate random dynamic followers

#


import maya.cmds as cmds
from random import *


class Crowd:
 def __init__(self):
  "Initialize attributes"
  #objects for obstacles
  self.collectObjects = []
  #number of vehicles
  self.vNumber = 0
  #boolean for obstacles
  self.obst = 0
  #boolean for global forces
  self.gforces = 0
  #dictionary for UI elements
  self.UIelements = {}
  #set timeline
  cmds.playbackOptions(min= 1, max=1000)
  #get selected objects
  self.collectObjects = cmds.ls(sl=1)
  #start UI
  self.crowdSystemUI()

 def crowdSystemUI(self):
  "Assembles and displays the UI for the Crowd System"
  self.UIelements["window"] = cmds.window(title="Crowd System",
            widthHeight=(300, 200)
            )
  
  self.UIelements["form"] = cmds.formLayout()
  txt = cmds.text(label="Number of Vehicles")
  collection = cmds.radioCollection()
  radiob1 = cmds.radioButton(label="10", data=1, changeCommand=self.changeVnumber)
  radiob2 = cmds.radioButton(label="20", onCommand="vNumber = 20")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  txtOB = cmds.text(label="Obstacles")
  collection2 = cmds.radioCollection()
  radiob3 = cmds.radioButton(label="On", changeCommand=self.changeObst)
  radiob4 = cmds.radioButton(label="Off")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  txtGF = cmds.text( label = "Global Forces")
  collection3 = cmds.radioCollection()
  radiob5 = cmds.radioButton(label= "On" ,changeCommand =self.changeGforces)
  radiob6 = cmds.radioButton(label="Off")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  cmds.radioCollection(collection, edit=1, select=radiob1)
  cmds.radioCollection(collection2, edit=1, select=radiob4)
  cmds.radioCollection(collection3, edit=1, select=radiob6)

  # Place Vehicle options
  form = self.UIelements["form"]
  cmds.formLayout(form,
      edit=1,
      attachForm= [
         ( txt, "top", 20),
         (txt ,"left", 70),
         (radiob1,"top", 10),
         (radiob1,"left", 20),
         (radiob2,"top", 30),
         (radiob2,"left", 20)
         ]
      )
  # Place environment options
  cmds.formLayout(form,
      edit=1,
      attachForm= [
         (txtOB, "top", 80),
         (txtOB, "left", 80),
         (radiob3, "top", 80),
         (radiob3, "left", 150),
         (radiob4 ,"top", 80),
         (radiob4, "left", 190),
         (txtGF, "top", 110),
         (txtGF, "left", 63),
         (radiob5, "top", 110),
         (radiob5, "left", 150),
         (radiob6, "top", 110),
         (radiob6, "left", 190)
         ]
      )
  # Create buttons
  button1 = cmds.button(label = "Create")
  button2 = cmds.button(label = "Cancel")

  # Place buttons in the window
  cmds.formLayout(form,
      edit=1,
      attachForm =[
         (button1, "bottom", 10),
         (button1, "left", 185),
         (button2, "bottom", 10),
         (button2, "right", 10)
         ]
      )
  # Add the commands to the buttons.
  cmds.button(button1, edit=1, command=self.createCrowd )
  cmds.button(button2, edit=1, command=self.deleteUI )
  
  cmds.showWindow(self.UIelements["window"])
 ## UI help functions
 def changeVnumber(self, *args):
  if args[0] == "true":
   self.vNumber = 10
  else:
   self.vNumber = 20
  print "vNumber:",self.vNumber 
 def changeObst(self, *args):
  if args[0] == "true":
   self.obst = 1
  else:
   self.obst = 0
  print "Obst:", self.obst
 def changeGforces(self, *args):
  if args[0] == "true":
   self.gforces = 1
  else:
   self.gforces = 0
  print "gforces:", self.gforces
 def deleteUI(self, *args):
  cmds.deleteUI(self.UIelements["window"])
  self.UIelements["window"] = ""

 ## MAIN METHODS
 def createCrowdSolver(self):
  "Creates the main rigidSolver for the elements in the Crowd System"
  self.crowdSolver = cmds.rigidSolver( create=1, 
            current=1,
            name="crowdSolver",
            velocityVectorScale=0.5,
            displayVelocity=1
            )
  cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)
  
 def createVehicle(self, vType, N):
  "Creates one vehicle and add fields and expressions to it."
  #first verify if the vehicle is of type follower (F) or leader (L)
  #and set the size of the cube according to the type (leaders are bigger! :)
  if vType == "P1":
   w = 70  #width
   h = 70#height
   d = 70  #depth
  if vType == "P2":
   w = 100 #width
   h = 100 #height
   d = 100 #depth
  
  
  if vType == "F1":
   w = 2  #width
   h = 2 #height
   d = 2  #depth
  if vType == "F2":
   w = 2  #width
   h = 4   #height
   d = 2  #depth
  if vType == "F3":
   w = 2  #width
   h = 6   #height
   d = 2  #depth
   
  if vType == "L1":
   w = 5  #width
   h = 3  #height
   d = 5  #depth
  if vType == "L2":
   w = 5  #width
   h = 5   #height
   d = 5  #depth  
  else:
   w = 5
   h = 7
   d = 5
  
  #creates the basic cube
  vehicle = cmds.polyCube(w=w,d=d,h=h)
  
  #creates the pavilion
  pavilion1 = cmds.polyCube(w=w,d=d,h=h)
  pavilion2 = cmds.polyCube(w=w,d=d,h=h)
  
  #create a vehicule force to the agent - force 1
  field1=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field1[0], vehicle[0])
  cmds.hide(field1)
  
  if vType=="L1":
   Lfield1 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=50
         )
         
   cmds.parent(Lfield1[0], vehicle[0])
   cmds.hide(Lfield1)
   
  #create a vehicule force to the agent - force 2
  field2=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field2[0], vehicle[0])
  cmds.hide(field2)
  
  if vType=="L2":
   Lfield2 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=50
         )
         
   cmds.parent(Lfield2[0], vehicle[0])
   cmds.hide(Lfield2)
   
  #create a vehicule force to the agent - force 3
  field3=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field3[0], vehicle[0])
  cmds.hide(field3)
  
  if vType=="L3":
   Lfield3 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=50
         )
         
   cmds.parent(Lfield3[0], vehicle[0])
   cmds.hide(Lfield3)
  
  #create a static force to the agent - force 4
  field4=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field4[0], pavilion1[0])
  cmds.hide(field4)
  
  if vType=="P1":
   Lfield4 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=70
         )
         
   cmds.parent(Lfield4[0], pavilion1[0])
   cmds.hide(Lfield4)
 
  #create a static force to the agent - force 5
  field5=cmds.radial(position=[0,0,0], 
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
         
  cmds.parent(field5[0], pavilion2[0])
  cmds.hide(field5)
  
  if vType=="P2":
   Lfield5 = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=100
         )
         
   cmds.parent(Lfield5[0], pavilion2[0])
   cmds.hide(Lfield5)
 
   
  #convert vehicle to a rigid body with random placement 
  rigid = cmds.rigidBody(
     vehicle[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=1,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
     
  #convert pavillion1 to a passive rigid body with random placement
  rigid = cmds.rigidBody(
     pavilion1[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=0,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
     
  #convert pavillion2 to a passive rigid body with random placement
  rigid = cmds.rigidBody(
     pavilion2[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=0,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
     
  #disconnect the rotation attributes of the vehicle
  cmds.disconnectAttr(rigid + "rx.output", vehicle[0]+".rx")
  cmds.disconnectAttr(rigid + "ry.output", vehicle[0]+".ry")
  cmds.disconnectAttr(rigid + "rz.output", vehicle[0]+".rz")
  
  #add expression for movement
  randX = uniform(-3,3)
  randY = uniform(-3,3)
  
  expString = "%s.impulseX = sin(time * %f);" % (rigid, randX)
  expString += "%s.impulseY = (noise(time)*%f);" % (rigid, randY)
  expString += "float $Vel[] = `getAttr %s.velocity`;" % rigid
  expString += "%s.rotateX = 0;" % vehicle[0]
  expString += "%s.rotateY = 0;" % vehicle[0]
  expString += "%s.rotateZ = atan2d( $Vel[0], $Vel[2] );" % vehicle[0]
  
  cmds.expression(s=expString)
  
  if vType == "F1":
   return [rigid, field] #returns the name of the function
   
  else:
   return[rigid, field, Lfield1]
  
  if vType == "F2":
   return [rigid, field] #returns the name of the function
   
  else:
   return[rigid, field, Lfield2] 
   
  if vType == "F3":
   return [rigid, field] #returns the name of the function
   
  else:
   return[rigid, field, Lfield3]
   
 def createCrowd(self, *args):
  "Method to assemble the whole system"
  #creates a rigidSolver to add the vehicle to
  self.createCrowdSolver()
  #turn on the velocity arrow   
  cmds.setAttr(self.crowdSolver + ".displayVelocity", 1)
  cmds.setAttr(self.crowdSolver + ".scaleVelocity", .5)
  
  #allow disconnections on the rigidSolver
  cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)
  
  ###create amount of agents
  if self.vNumber == 10:
   FNumber = 8
   LNumber = 2
  elif self.vNumber == 20:
   FNumber=18
   Lnumber=2
   
  
  #create empty lists to store followers and leaders
  followers1=[]
  leaders1=[]
  followers2=[]
  leaders2=[]
  followers3=[]
  leaders3=[]
  pavilions1=[]
  pavilions2=[]
  
  #create the followers
  for i in range(FNumber):
   if i%3 == 0:
    v=self.createVehicle("F1",i)
    followers1.append(v)

   if i%3 == 1:
    v=self.createVehicle("F2",i)
    followers2.append(v)

   if i%3 == 2:
    v=self.createVehicle("F3",i)
    followers3.append(v)
    
  #create the leaders
  for i in range(LNumber):
   if i%3 == 0:
    v=self.createVehicle("L1",i)
    leaders1.append(v)

   if i%3 == 1:
    v=self.createVehicle("L2",i)
    leaders2.append(v)

   if i%3 == 2:
    v=self.createVehicle("L3",i)
    leaders3.append(v)

  #create static attractor
  for i in range(2):
   if i%2 == 0:
    v=self.createVehicle("P1",i)
    pavilions1.append(v)

   if i%2 == 1:
    v=self.createVehicle("P2",i)
    pavilions2.append(v)


  
  cmds.polyCube( sx=10, sy=15, sz=5, h=20 )
  #result is a 20 units height rectangular box
  #with 10 subdivisions along X, 15 along Y and 20 along Z.


      
   
     
  #CONNECT THE FIELDS TO THE RIGID BODIES(AGENTS)
  #1) Connect the leaders with the followers 1-1
  
  for i in range(LNumber):
   if i%3 == 0:
    Lfield1=leaders1[i][2]
    lfield1=leaders1[i][1]
    for j in range (FNumber):
     if j%3 == 0:
      Frigid1 = followers1[j][0]
      #connect the fields
      cmds.connectDynamic(Frigid1, fields=Lfields)
      cmds.connectDynamic(Frigid1, fields=lfields)
     
   if i%3 == 1:
    Lfield2=leaders2[i][2]
    lfield2=leaders2[i][1]
    for j in range (FNumber):
     if j%3 == 1:
      Frigid1 = followers2[j][0]
      #connect the fields
      cmds.connectDynamic(Frigid2, fields=Lfields)
      cmds.connectDynamic(Frigid2, fields=lfields)
     
   else:
    Lfield3=leaders3[i][2]
    lfield3=leaders3[i][1]
    for j in range (FNumber):
     if j%3 == 2:
      Frigid3 = followers3[j][0]
      #connect the fields
      cmds.connectDynamic(Frigid3, fields=Lfields)
      cmds.connectDynamic(Frigid3, fields=lfields)
     
    
    
    
  #2) Connect followers to leaders
  for i in range(FNumber):
   if i%3 == 0:
    Ffield1 = followers1[i][1]
    for j in range(LNumber):
     if j%3 == 0:
      Lrigid1 = leaders1[j][0]
      cmds.connectDynamic(Lrigid1, fields=Ffield)
      
  
   if i%3 == 1:
    Ffield2 = followers2[i][1]
    for j in range(LNumber):
     if j%3 == 1:
      Lrigid2 = leaders2[j][0]
      cmds.connectDynamic(Lrigid2, fields=Ffield)
    
     else:
     Ffield3 = followers3[i][1]
     for j in range(LNumber):
      if j%3 == 2:
       Lrigid3 = leaders3[j][0]
       cmds.connectDynamic(Lrigid3, fields=Ffield)
     
    
    
    
  #3) Connect leaders to leaders
  for i in range (LNumber):
   if i%3 == 0:
    Lrigid1 = leaders1[i][0]
    Lfield1 = leaders1[i][1]
    for j in range(LNumber):
     if i == f: continue
     if j%3 == 0:
      L1rigid = leaders1[j][0]
      #l1field = leaders1[j][1]
      cmds.connectDynamic(L1rigid, fields=Lfield)
     
   if i%3 == 1:
    Lrigid2 = leaders2[i][0]
    Lfield2 = leaders2[i][1]
    for j in range(LNumber):
     if i == f: continue
     if j%3 == 1:
      L1rigid = leaders2[j][0]
      #l1field = leaders1[j][1]
      cmds.connectDynamic(L1rigid, fields=Lfield)
  
   if i%3 == 2:
    Lrigid3 = leaders3[i][0]
    Lfield3 = leaders3[i][1]
    for j in range(LNumber):
     if i == f: continue
     if j%3 == 2:
      L1rigid = leaders3[j][0]
      #l1field = leaders1[j][1]
      cmds.connectDynamic(L1rigid, fields=Lfield)
    
  #4) Connect followers to followers
  for i in range(FNumber):
   if i%3 == 0:
    Ffield1=followers1[i][1]
    for j in range(FNumber):
     if i==j: continue
     if j%3 == 0:
      Frigid1 = followers1[j][0]
      
      cmds.connectDynamics(Frigid1, fields=Ffield)
   if i%3 == 1:
    Ffield2=followers2[i][1]
    for j in range(FNumber):
     if i==j: continue
     if j%3 == 1:
      Frigid2 = followers2[j][0]
      
      cmds.connectDynamics(Frigid2, fields=Ffield)
   else:
    Ffield3=followers3[i][1]
    for j in range(FNumber):
     if i==j: continue
     if j%3 == 2:
      Frigid3 = followers3[j][0]
      
      cmds.connectDynamics(Frigid3, fields=Ffield)
    
  
    
    
    
  #create obstacles if i want
  if self.obst:self.collectObstacles()
 
  
  
  
  #disable solver warnings
  cmds.cycleCheck(e=0)  
      
  #disable solver warnings
  cmds.cycleCheck(e=0)
  
 def collectObstacles(self):
  "Collects all obstacles"
  if len(self.collectObjects) == 0:
   #there is nothing selected
   return "There is nothing selected!"
   
  for o in self.collectObjects:
   cmds.rigidBody( o,
       passive = 1,
       name=o+"_rb",
       bounciness=2.0)
       
#craete an instance for this class
c=Crowd()

Assignment 03B - first try

2009-07-21T01:40:00.004+02:00

In this script we tried to add pavilions(by script) and obstacles(manually in maya). It seams to be something wrong when we define the pavilions. Pavilions are static rigid bodies. The only difference between vehicles and pavilions is the varriable active, which is 0 for pavilions. It is a wrong way to define pavilions like that?


#######################################################################################################
##
## CROWD SYSTEM
## Adapted from original idea by Mark R. Wilkins and Chris Kazmier
##
## Modified: 22.06.09 by Daniel da Rocha
##
## Last Modified: 21.07.09 by  Alexandra Virlan and Mircea Mogan
##
#######################################################################################################


import maya.cmds as cmds
from random import *


class Crowd:
 def __init__(self):
  "Initialize attributes"
  #objects for obstacles
  self.collectObjects = []
  #number of vehicles
  self.vNumber = 0
  #boolean for obstacles
  self.obst = 0
  #boolean for global forces
  self.gforces = 0
  #dictionary for UI elements
  self.UIelements = {}
  #set timeline
  cmds.playbackOptions(min= 1, max=1000)
  #get selected objects
  self.collectObjects = cmds.ls(sl=1)
  #start UI
  self.crowdSystemUI()

 def crowdSystemUI(self):
  "Assembles and displays the UI for the Crowd System"
  self.UIelements["window"] = cmds.window(title="Crowd System",
            widthHeight=(300, 200)
            )

  self.UIelements["form"] = cmds.formLayout()
  txt = cmds.text(label="Number of Vehicles")
  collection = cmds.radioCollection()
  radiob1 = cmds.radioButton(label="10", data=1, changeCommand=self.changeVnumber)
  radiob2 = cmds.radioButton(label="20", onCommand="vNumber = 20")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  txtOB = cmds.text(label="Obstacles")
  collection2 = cmds.radioCollection()
  radiob3 = cmds.radioButton(label="On", changeCommand=self.changeObst)
  radiob4 = cmds.radioButton(label="Off")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  txtGF = cmds.text( label = "Global Forces")
  collection3 = cmds.radioCollection()
  radiob5 = cmds.radioButton(label= "On" ,changeCommand =self.changeGforces)
  radiob6 = cmds.radioButton(label="Off")
  cmds.setParent(upLevel=1)
  cmds.setParent(upLevel=1)

  cmds.radioCollection(collection, edit=1, select=radiob1)
  cmds.radioCollection(collection2, edit=1, select=radiob4)
  cmds.radioCollection(collection3, edit=1, select=radiob6)

  # Place Vehicle options
  form = self.UIelements["form"]
  cmds.formLayout(form,
      edit=1,
      attachForm= [
         ( txt, "top", 20),
         (txt ,"left", 70),
         (radiob1,"top", 10),
         (radiob1,"left", 20),
         (radiob2,"top", 30),
         (radiob2,"left", 20)
         ]
      )
  # Place environment options
  cmds.formLayout(form,
      edit=1,
      attachForm= [
         (txtOB, "top", 80),
         (txtOB, "left", 80),
         (radiob3, "top", 80),
         (radiob3, "left", 150),
         (radiob4 ,"top", 80),
         (radiob4, "left", 190),
         (txtGF, "top", 110),
         (txtGF, "left", 63),
         (radiob5, "top", 110),
         (radiob5, "left", 150),
         (radiob6, "top", 110),
         (radiob6, "left", 190)
         ]
      )
  # Create buttons
  button1 = cmds.button(label = "Create")
  button2 = cmds.button(label = "Cancel")

  # Place buttons in the window
  cmds.formLayout(form,
      edit=1,
      attachForm =[
         (button1, "bottom", 10),
         (button1, "left", 185),
         (button2, "bottom", 10),
         (button2, "right", 10)
         ]
      )
  # Add the commands to the buttons.
  cmds.button(button1, edit=1, command=self.createCrowd )
  cmds.button(button2, edit=1, command=self.deleteUI )

  cmds.showWindow(self.UIelements["window"])
 ## UI help functions
 def changeVnumber(self, *args):
  if args[0] == "true":
   self.vNumber = 10
  else:
   self.vNumber = 20
  print "vNumber:",self.vNumber
 def changeObst(self, *args):
  if args[0] == "true":
   self.obst = 1
  else:
   self.obst = 0
  print "Obst:", self.obst
 def changeGforces(self, *args):
  if args[0] == "true":
   self.gforces = 1
  else:
   self.gforces = 0
  print "gforces:", self.gforces
 def deleteUI(self, *args):
  cmds.deleteUI(self.UIelements["window"])
  self.UIelements["window"] = ""

 ## MAIN METHODS
 def createCrowdSolver(self):
  "Creates the main rigidSolver for the elements in the Crowd System"
  self.crowdSolver = cmds.rigidSolver( create=1,
            current=1,
            name="crowdSolver",
            velocityVectorScale=0.5,
            displayVelocity=1
            )
  cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)

 def createVehicle(self, vType, N):
  "Creates one vehicle and add fields and expressions to it."
  #first verify if the vehicle is of type follower (F) or leader (L)
  #and set the size of the cube according to the type (leaders are bigger! :)
  if vType == "F":
   w = 2  #width
   h = 2.5 #height
   d = 2  #depth

  if vType == "P":
   w = 100 #width
   h = 100 #height
   d = 100 #depth

  else:
   w = 5
   h = 3.5
   d = 5

  #creates the basic cube
  vehicle = cmds.polyCube(w=w,d=d,h=h)
  pavilion = cmds.polyCube(w=w,d=d,h=h)

  #create a vehicule force to the agent
  field=cmds.radial(position=[0,0,0],
         magnitude=50,
         attenuation = 0.3,
         maxDistance = 8.0
         )
       
  cmds.parent(field[0], vehicle[0])
  cmds.parent(field[0], pavilion[0])
  cmds.hide(field)

  if vType=="L":
   Lfield = cmds.radial(position=[0,0,0],
         magnitude=-1,
         attenuation=.2,
         maxDistance=50
         )
       
   cmds.parent(Lfield[0], vehicle[0])
   cmds.hide(Lfield)

  #convert it to a rigid body with random placement
  rigid = cmds.rigidBody(
     vehicle[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=1,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
   
  rigid = cmds.rigidBody(
     pavilion[0],
     n="rigidVeh1%s%d" %(vType, N),
     active=0,
     mass=1,
     bounciness=0,
     damping=1.5,
     position=(uniform(-70,70),uniform(-70,70),0),
     impulse=(0,0,0),
     standInObject="cube",
     solver=self.crowdSolver
     )
   
  #disconnect the rotation attributes of the vehicle   ??)?)?)?)
  cmds.disconnectAttr(rigid + "rx.output", vehicle[0]+".rx")
  cmds.disconnectAttr(rigid + "ry.output", vehicle[0]+".ry")
  cmds.disconnectAttr(rigid + "rz.output", vehicle[0]+".rz")

  #add expression for movement
  randX = uniform(-3,3)
  randY = uniform(-3,3)

  expString = "%s.impulseX = sin(time * %f);" % (rigid, randX)
  expString += "%s.impulseY = (noise(time)*%f);" % (rigid, randY)
  expString += "float $Vel[] = `getAttr %s.velocity`;" % rigid
  expString += "%s.rotateX = 0;" % vehicle[0]
  expString += "%s.rotateY = 0;" % vehicle[0]
  expString += "%s.rotateZ = atan2d( $Vel[0], $Vel[2] );" % vehicle[0]

  cmds.expression(s=expString)

  if vType == "F":
   return [rigid, field] #returns the name of the function
 
  if vType == "L":
   return[rigid, field, Lfield]
 
  else:
   return[rigid, field, Pfield]

 def createCrowd(self, *args):
  "Method to assemble the whole system"
  #creates a rigidSolver to add the vehicle to
  self.createCrowdSolver()
  #turn on the velocity arrow 
  cmds.setAttr(self.crowdSolver + ".displayVelocity", 1)
  cmds.setAttr(self.crowdSolver + ".scaleVelocity", .5)

  #allow disconnections on the rigidSolver
  cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)

  ###create amount of agents
  if self.vNumber == 10:
   FNumber = 8
   LNumber = 2
  elif self.vNumber == 20:
   FNumber=18
   Lnumber=2
 
  #create empty lists to store followers and leaders
  followers=[]
  leaders=[]
  pavilions=[]
  #create the followers
  for i in range(FNumber):
     v=self.createVehicle("F",i)
     followers.append(v)

  #create the leaders
  for i in range(LNumber):
     v=self.createVehicle("L",i)
     leaders.append(v)
   
  create pavilion
  for i in range(1):
     v=self.createVehicle("P",i)
     pavilions.append(v)
   
   

  #CONNECT THE FIELDS TO THE RIGID BODIES(AGENTS)
  #1) Connect the leaders with the followers

  for i in range(LNumber):
   Lfield=leaders[i][2]
   lfield=leaders[i][1]
   for j in range (FNumber):
    Frigid = followers[j][0]
    #connect the fields
    cmds.connectDynamic(Frigid, fields=Lfields)
    cmds.connectDynamic(Frigid, fields=lfields)
  

  #2) Connect followers to leaders
  for i in range(FNumber):
   Ffield = followers[i][1]
   for j in range(LNumber):
    Lrigid = leaders[j][0]
    cmds.connectDynamic(Lrigid, fields=Ffield)
  
  #3) Connect leaders to leaders
  for i in range (LNumber):
   Lrigid = leaders[i][0]
   Lfield = leaders[i][1]
   for j in range(LNumber):
    if i == f: continue
    L1rigid = leaders[j][0]
    #l1field = leaders[j][1]
    cmds.connectDynamic(L1rigid, fields=Lfield)
  
  #4) Connect followers to followers
  for i in range(FNumber):
   Ffield=followers[i][1]
   for j in range(FNumber):
    if i==j: continue
    Frigid = followers[j][0]
  
    cmds.connectDynamics(Frigid, fields=Ffield)
  
  #5) Connect the pavilion with the leaders

  for i in range(1):
   Pfield=pavilions[i][2]
   Lfield=pavilions[i][1]
 
   for j in range (LNumber):
    Frigid = leaders[j][0]
    #connect the fields
    cmds.connectDynamic(Frigid, fields=Pfields)
    cmds.connectDynamic(Frigid, fields=Lfields)
  

  #6) Connect leaders to pavilions
  for i in range(LNumber):
   Lfield = leaders[i][1]
   for j in range(1):
    Frigid = pavilions[j][0]
    cmds.connectDynamic(Prigid, fields=Lfield)

  #create obstacles if i want
  if self.obst:self.collectObstacles()

  #disable solver warnings
  cmds.cycleCheck(e=0)
    
  #disable solver warnings
  cmds.cycleCheck(e=0)

 def collectObstacles(self):
  "Collects all obstacles"
  if len(self.collectObjects) == 0:
   #there is nothing selected
   return "There is nothing selected!"
 
  for o in self.collectObjects:
   cmds.rigidBody( o,
       passive = 1,
       name=o+"_rb",
       bounciness=2.0)
     
#craete an instance for this class
c=Crowd()

Chinese whispers

2009-07-12T21:11:00.007+02:00

Chinese whispers

::: SYNOPSIS :::
My idea is to have 1EMITER, 1RECEPTOR, and n number of TRANSMITOR!
The aim of this script is to bring the information from the EMITER, to the RECEPTOR by the TRANSMITOR!
The information is symbolized by the red color, the white color symbolized the un-information ...
The EMITER and the RECEPTOR doesn't move, only theTRANSMITOR can move!...

When a TRANSMITOR hit the EMITER, the TRANSMITOR become red, the EMITER become white!
Then when this red-TRANSMITOR hit another black-TRANSMITOR, the red become black again, and the black become red!
The Information is transmitted! ... When finally the RECEPTOR is hitting by a red TRANSMITOR, the script stop! ...

::: AUTO-COMMENTS :::
- Does this script too simple?
- I will try to clean a little bit the hit part! It's a little bit messy, and I found a new way to do it!
- I also want to script another scenerio based on the same principe


####################################
## INFORMATIONS DIFFUSION
## Chinese whispers
####################################

import maya.cmds as cmds
import maya.mel as mel
import random
import math


# Function to create shader
def createShader(color, transparency=0, type="lambert", name="shader"):
#steps to create a new material
shadingNode1 = cmds.shadingNode(type, asShader=1, name=name)
shadingNode2 = cmds.sets(renderable=1, noSurfaceShader = 1, empty=1, name=name)
cmds.connectAttr(shadingNode1+".outColor", shadingNode2 + ".surfaceShader", force=1)
#steps to modify material attributes
cmds.setAttr(shadingNode1 + ".color", color[0],color[1], color[2]) #color in r g b values
cmds.setAttr(shadingNode1 + ".transparency", transparency, transparency, transparency)

return shadingNode2


# Function to create shader I need
def myshaders():
# Create the transmitter shader => no information
if cmds.objExists('noir'):
# stupid line just to say to python to do nothing!
nothing = 0
else:
noir = createShader((0,0,0), transparency=0, type="lambert", name="noir")

# Create the Receptor shader => awaiting the information
if cmds.objExists('blanc'):
# stupid line just to say to python to do nothing!
nothing = 0
else:
blanc = createShader((255,255,255), transparency=0, type="lambert", name="blanc")

# Create the transmitter shader => information
if cmds.objExists('rouge'):
# stupid line just to say to python to do nothing!
nothing = 0
else:
rouge = createShader((255,0,0), transparency=0, type="lambert", name="rouge")

# Create the box shader, transparent to see what's happen inside! =)
if cmds.objExists('transparent'):
# stupid line just to say to python to do nothing!
nothing = 0
else:
transparent = createShader((0,0,0), transparency=.9, type="lambert", name="transparent")

# Function to apply the shader
def applyShaderOnObject(obj, shader):
cmds.sets(obj, e=1, forceElement=shader)

# SYNOPSIS :::
# My idea is to have 1EMITER, 1RECEPTOR, and n number of TRANSMITOR!
# The aim of this script is to bring the information from the EMITER, to the RECEPTOR by the TRANSMITOR!
# The information is symbolized by the red color, the white color symbolized the un-information ...
# The EMITER and the RECEPTOR doesn't move, only the TRANSMITOR can move!...

# When a TRANSMITOR hit the EMITER, the TRANSMITOR become red, the EMITER become white!
# Then when this red-TRANSMITOR hit another black-TRANSMITOR, the red become black again, and the black become red!
# The Information is transmitted! ... When finally the RECEPTOR is hitting by a red TRANSMITOR, the script stop! ...

def hit(hit, agent):
### define what to do when it some collision is detected
if hit == "wall_rigid":
return

agentRole = cmds.getAttr(agent + ".role")
hitRole = cmds.getAttr(hit + ".role")
agentShader = cmds.getAttr(agent + ".shader")
hitShader = cmds.getAttr(hit + ".shader")

# If the emitter hit a transmitter
if agentRole == "emitter":
if hitRole == "transmitters":
#print agentRole # = emitter
#print hitRole # = transmitter

if agentShader == 'rouge1':
# change the color of the transmitter from black to red
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(hit+".shader", 'rouge1', type="string")

# change the color of the emitter from red to black
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(agent+".shader", 'noir1', type="string")


# If a transmiter hit a emitter
if agentRole == "transmitters":
if hitRole == "emitter":
#print agentRole # = trans
#print hitRole # = emit

if hitShader == 'rouge1':
# change the color of the emitter from red to black
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(hit+".shader", 'noir1', type="string")

# change the color of the transmitter from black to red
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(agent+".shader", 'rouge1', type="string")


# If a transmitter hit another transmitter
if agentRole == "transmitters":
if hitRole == "transmitters":

if agentShader == 'rouge1':
# change the color of the frist transmitter from black to red
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(hit+".shader", 'rouge1', type="string")

# change the color of the second transmitter from red to black
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(agent+".shader", 'noir1', type="string")


if hitShader == 'rouge1':
# change the color of the frist transmitter from red to black
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(hit+".shader", 'noir1', type="string")

# change the color of the second transmitter from black to red
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(agent+".shader", 'rouge1', type="string")


# And Finally, if an emitter hit the receptor!
if agentRole == "receptor":
if hitRole == "transmitters":
#print agentRole # = receptor
#print hitRole # = emitter

if hitShader == 'rouge1':
# change the color of the transmitter from red to black
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(hit+".shader", 'noir1', type="string")

# change the color of the receptor form white to red
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(agent+".shader", 'rouge1', type="string")

# means that the information is propely transmitted
# so, stop the animation, and print a feedback
cmds.play( state=False )
frame = cmds.currentTime( query=True )
print "INFORMATION TRANSMITED IN", frame, "FRAMES"


# if an emitter hit the receptor!
if agentRole == "transmitters":
if hitRole == "receptor":
#print agentRole # = emit
#print hitRole # = trans

if agentShader == 'rouge1':
# change the color of the receptor form white to red
obj = cmds.getAttr(hit+".obj")
applyShaderOnObject(obj, 'rouge1')
cmds.setAttr(hit+".shader", 'rouge1', type="string")

# change the color of the transmitter from red to black
obj = cmds.getAttr(agent+".obj")
applyShaderOnObject(obj, 'noir1')
cmds.setAttr(agent+".shader", 'noir1', type="string")

# means that the information is propely transmitted
# so, stop the animation, and print a feedback
cmds.play( state=False )
frame = cmds.currentTime( query=True )
print "INFORMATION TRANSMITED IN", frame, "FRAMES"



class Agent:
def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="sphere", rigidType="active", bounciness=.6, collide=1, mass=1, speed=5):
#set agent atributes
self.bounciness = bounciness
self.collide = collide
self.rigidType = rigidType
self.solver=solver
self.role = role
self.initialScale = size
self.mass=mass
self.speed = speed

#create the agent and scale it
self.object = cmds.polySphere(ax=(0,0,1))
cmds.scale(size[0], size[1], size[2])
#apply a color to the agent
#set the object color

applyShaderOnObject(self.object[0], color)

#create the rigid body
self.rigid = cmds.rigidBody(self.object,
    name=self.object[0] + "_rigid",
    p=position,
    b=self.bounciness,
    impulse=(0,0,0),
    sio=objType, #stand in object
    cc = 1, #contact count
    cp = 1, #contact position
    cn = 1, #contact name
    si = (190,190,190),
    m=mass,
    solver=self.solver)

#add attribute to the rigid body to store the type of agent
cmds.select(self.rigid, r=1)
cmds.addAttr(ln="role", dt="string", keyable=1, w=1)
cmds.setAttr(self.rigid + ".role", self.role, type="string")

cmds.addAttr(ln="obj", dt="string", keyable=1, w=1)
cmds.setAttr(self.rigid + ".obj", self.object[0] , type="string")

cmds.addAttr(ln="shader", dt="string", keyable=1, w=1)
cmds.setAttr(self.rigid + ".shader", color , type="string")

self.applyExpression(speed)

def applyExpression(self, speed):
"Function to apply the expression to the agent"
#first disconnect the rotation attributes because we want to controll it via expressions
cmds.disconnectAttr (self.rigid + "ry.output", self.object[0] + ".rotateY")
cmds.disconnectAttr (self.rigid + "rx.output", self.object[0] +  ".rotateX")
cmds.disconnectAttr (self.rigid + "rz.output", self.object[0] + ".rotateZ")

# Create expression for VehicleF with a random multiplier added to the expression.
randX = random.uniform(-speed,speed)
randY = random.uniform(speed,-speed)

expString = "// Set wander motion of vehicle and add random multipliers.\n"

if self.role == "transmitters":
####COMPOSE THE EXPRESSION STRING
#now put the text above in a python string
#the first lines define how the agent will wander

expString += "%s.impulseX" % self.rigid
expString += " = (cos(time*%f));\n" % randX
expString += "%s.impulseY" % self.rigid
expString += " = ((noise(time) * %f));\n\n" % randY


#the second part, how it rotates according to the direction it is going (velocity vector)
expString += "// Set orientation of Vehicle according to the velocity direction.\n"
expString += "float $fVel[];\n"
expString += "$fVel  = `getAttr %s.velocity`;\n\n" % (self.rigid)
expString += "%s.rotateX = 0;\n" % self.object[0]
expString += "%s.rotateZ = atan2d( $fVel[0], $fVel[1] );\n" % (self.object[0])
expString += "%s.rotateY = 0;\n\n" % self.object[0]


#the third part, checking bumps on other agents
expString += "//checking bumps on other agents\n"
expString += "string $lastHit;\n"
expString += "if (%s.contactCount > 0){\n" % self.rigid
expString += "  int $contactCount = `getAttr %s.contactCount`;\n" % self.rigid
expString += "  $lastHit = `getAttr %s.contactName[0]`;\n" %self.rigid
expString += '  string $rigid = "%s";\n' % self.rigid
expString += '  python("hit(\'"+$lastHit+"\', \'"+ $rigid +"\')");\n'
expString += "};//endif\n"

self.expString = expString
cmds.expression(s=expString)







##############################################
class Crowd:
def __init__(self, numAgents=20, scaleRecept=2.5, scaleTrans=2, minPosition=-70, maxPosition=70, walls=1, speed=5):
#set the playback options to increase the time range
cmds.playbackOptions(min= 1, max=5000)
self.numAgents = numAgents
self.minPosition = minPosition
self.maxPosition = maxPosition
self.scaleRecept = scaleRecept
self.scaleTrans = scaleTrans
self.speed = speed

#get any selected objects
self.createBorders(scaleRecept,maxPosition)
self.wallObjs = cmds.ls(sl=1)

#create the rigid solver
self.solver = self.createSolver()
#create the agents
self.createAgents(scaleRecept, scaleTrans, speed)
#create the walls
if walls: self.makeWalls()


# Create a box to contain the balls
def createBorders(self, scaleRecept,maxPosition):
cmds.polyCube(n="border", ax=(0,0,0), w=((maxPosition*2)+(scaleRecept*2)), h=((maxPosition*2)+(scaleRecept*2)), d=(scaleRecept*2))
cmds.polyNormal( nm=0 )
myshaders()
applyShaderOnObject("border", 'transparent1')

cmds.select("border")


# Create Solver
def createSolver(self):
solver = cmds.rigidSolver(create=1, current=1, name="crowdSolver", velocityVectorScale=0.1, displayVelocity=1, sc=1, ctd=1)
cmds.setAttr(solver + ".allowDisconnection", 1)
return solver

# Create x numbers of transmittors
def createAgents(self, scaleRecept, scaleTrans, speed):
myshaders()
self.speed = speed
transmitters = ['transmitters', (scaleTrans,scaleTrans,scaleTrans), 1, 'noir1'] #name, scale, mass, color
emitter = ['emitter', (scaleRecept,scaleRecept,scaleRecept), 1000, 'rouge1'] #name, scale, mass, color
receptor = ['receptor', (scaleRecept,scaleRecept,scaleRecept), 1000, 'blanc1'] #name, scale, mass, color

self.transmitlist = []
self.emitlist = []
self.receptlist = []


# Create the emeter
x = float(random.uniform(self.minPosition,self.maxPosition))
y = float(random.uniform(self.minPosition,self.maxPosition))
z = 0

emitagent = Agent(self.solver, emitter[0], size=emitter[1], color=emitter[3], position=(x,y,z), bounciness=0, mass=emitter[2], speed=speed)
liste = (self.solver, emitagent)
self.emitlist.append(liste)

# Create the receptor
x = float(random.uniform(self.minPosition,self.maxPosition))
y = float(random.uniform(self.minPosition,self.maxPosition))
z = 0

receptagent = Agent(self.solver, receptor[0], size=receptor[1], color=receptor[3], position=(x,y,z), bounciness=0, mass=receptor[2], speed=speed)
liste = (self.solver, receptagent)
self.receptlist.append(liste)


# Create n transmiters
for i in range(self.numAgents):
#get random x and y
x = random.uniform(self.minPosition,self.maxPosition)
y = random.uniform(self.minPosition,self.maxPosition)
z = 0

#create the agents
transagent = Agent(self.solver, transmitters[0], position=(x,y,z), size=transmitters[1], color=transmitters[3], mass=transmitters[2], speed=speed)
liste = (self.solver, transagent)
self.transmitlist.append(liste)


def makeWalls(self):
#get selected object,
#which should be already with its normals facing to the right directions,
#and convert it to passive rigid bodies
if len(self.wallObjs) == 0:
return "No wall objects were selected."
else:
for w in self.wallObjs:
self.wallRigid = cmds.rigidBody(w, passive=1, name= "wall_rigid", bounciness=.8)

########################################


c=Crowd(numAgents=50, walls=1, speed=5)

Predator-Prey crowd system

2009-07-10T18:29:00.003+02:00

The goal of the script was to create a primary state of equality and to add some fields which would tarnsform(change) the boids behaviour. Therefore from simple wanderers (with no leaders) some boids would become either preys or predators.

If a predator would hit a wanderer, the number of predators would increase by one. If the predator would hit a prey, the number of preys would decrease by one and the number of predators would be the same. If a predator would enter the "force" field which changes the boids behaviour to preys, it would become a prey. If a prey would enter the "force" field which changes the boids behaviour to predators, it would become a predator.

import maya.cmds as cmds
import random

# Main
# ____
class Crowd:
def __init__(self):
#def crowdMain():
self.vNumber = 10
self.obst = 0
self.gforces = 0
self.UIelements = {}
cmds.playbackOptions(min= 1, max=500)
self.crowdSystemUI()
#end if
#end def __init__

def crowdSystemUI(self):
self.UIelements["window"] = cmds.window(title="Crowd System",
widthHeight=(300, 200)
)

self.UIelements["form"] = cmds.formLayout()
txt = cmds.text(label="Number of Vehicles")
collection = cmds.radioCollection()
radiob1 = cmds.radioButton(label="10", data=1, changeCommand=self.changeVnumber)
radiob2 = cmds.radioButton(label="20", onCommand="vNumber = 20")
cmds.setParent(upLevel=1)
cmds.setParent(upLevel=1)

txtOB = cmds.text(label="Obstacles")
collection2 = cmds.radioCollection()
radiob3 = cmds.radioButton(label="On", changeCommand=self.changeObst)
radiob4 = cmds.radioButton(label="Off")
cmds.setParent(upLevel=1)
cmds.setParent(upLevel=1)

txtGF = cmds.text( label = "Global Forces")
collection3 = cmds.radioCollection()
radiob5 = cmds.radioButton(label= "On" ,changeCommand =self.changeGforces)
radiob6 = cmds.radioButton(label="Off")
cmds.setParent(upLevel=1)
cmds.setParent(upLevel=1)

cmds.radioCollection(collection, edit=1, select=radiob1)
cmds.radioCollection(collection2, edit=1, select=radiob4)
cmds.radioCollection(collection3, edit=1, select=radiob6)

# Place Vehicle options
form = self.UIelements["form"]
cmds.formLayout(form,
edit=1,
attachForm= [
( txt, "top", 20),
(txt ,"left", 70),
(radiob1,"top", 10),
(radiob1,"left", 20),
(radiob2,"top", 30),
(radiob2,"left", 20)
]
)

# Place environment options
cmds.formLayout(form,
edit=1,
attachForm= [
(txtOB, "top", 80),
(txtOB, "left", 80),
(radiob3, "top", 80),
(radiob3, "left", 150),
(radiob4 ,"top", 80),
(radiob4, "left", 190),
(txtGF, "top", 110),
(txtGF, "left", 63),
(radiob5, "top", 110),
(radiob5, "left", 150),
(radiob6, "top", 110),
(radiob6, "left", 190)
]
)

# Create buttons
button1 = cmds.button(label = "Create")
button2 = cmds.button(label = "Cancel")

# Place buttons in the window
cmds.formLayout(form,
edit=1,
attachForm =[
(button1, "bottom", 10),
(button1, "left", 185),
(button2, "bottom", 10),
(button2, "right", 10)
]
)

# Add the commands to the buttons.

cmds.button(button1, edit=1, command=self.createCrowd )
cmds.button(button2, edit=1, command=self.deleteUI )

cmds.showWindow(self.UIelements["window"])

##############################################################
def createCrowdSolver(self):
self.crowdSolver = cmds.rigidSolver( create=1,
current=1,
name="crowdSolver",
velocityVectorScale=0.5,
displayVelocity=1,
sc=1
)
cmds.setAttr(self.crowdSolver + ".allowDisconnection", 1)

def createVehicle(self, i, vType):
"Creates a Vehicle"
if vType == "F":
w = 2
h = 2.5
d = 2
else:
w=5
h=3.5
d=5
v = cmds.polyCube(name="vehicle%s_%d" % (vType, i), width = w, height = h, depth = d)
#Add a Vehicle force field for follower.
field = cmds.radial( position=(0, 0, 0),
name = "vehicle%sForce_%d" % (vType, i),
magnitude=50,
attenuation=0.3,
maxDistance = 8.0
)
cmds.parent(field[0], v[0])
cmds.hide (field)
'''
if vType == "L":
# Add leader field
lRadial = cmds.radial( position = (0, 0, 0),
name = "vehicleGlobalLeadForce_%d" % i,
magnitude = -1,
attenuation = 0.2,
maxDistance = 50
)
cmds.parent (lRadial[0], v[0])
cmds.hide (lRadial)
'''
# Make the Vehicle a Rigid Body with random placement.
rigid = cmds.rigidBody(v[0],
name="rigidVehicle%s_%d" % (vType, i),
active=1,
mass=1,
bounciness=0,
damping= 1.5 ,
position = (random.uniform(-70,70), random.uniform(-70,70), 0),
impulse =( 0, 0, 0),
standInObject="cube",
solver= self.crowdSolver
)

cmds.disconnectAttr (rigid + "ry.output", v[0] + ".rotateY")
cmds.disconnectAttr (rigid + "rx.output", v[0] + ".rotateX")
cmds.disconnectAttr (rigid + "rz.output", v[0] + ".rotateZ")

# Create expression for VehicleF with a random multiplier added to the expression.
randX = random.uniform(-3,3)
randY = random.uniform(3,-3)
expString = "// Set wander motion of vehicle and add random multipliers.\n"
expString += "%s.impulseX" % rigid
expString += " = sin(time * %f);\n" % randX
expString += "%s.impulseY" % rigid
expString += " = (noise(time) * %f);\n\n" % randY
expString += "// Set orientation of Vehicle according to the velocity direction.\n"
expString += "float $fVel%d[];\n" % i
expString += "$fVel%d = `getAttr %s.velocity`;\n\n" % (i,rigid)
expString += "%s.rotateX = 0;\n" % v[0]
expString += "%s.rotateY = atan2d( $fVel%d[0], $fVel%d[2] );\n" % (v[0],i,i)
expString += "%s.rotateZ = 0;\n" % v[0]
expString += "string $ContactNames = `getAttr %s.cnn`;\n" % rigid
expString += "print($ContactNames);\n"

#print expString
exp = cmds.expression(s=expString )
######################################################################### start w08
if vType == "F":
return [rigid, field]
else:
return [rigid, field, lRadial]

def createCrowd(self, *args) :

self.collectObjects = cmds.ls(sl=1) ###################################### get selected objects

# Bring in ints and string from interface.
# Vehicle creation for crowd system.
# Create a master crowdSolver for all Vehicles.
self.createCrowdSolver()

# Get total number of Vehicles from interface options.
if self.vNumber == 10:
FvNumber = 10 # Followers
#LvNumber = 2 # Leaders
elif self.vNumber == 20:
FvNumber = 20 # Followers
#LvNumber = 2 # Leaders

#if (self.gforces == 1): self.makeGforces() # Check Global Forces option.

# Basic Vehicle model type: follower
#____________________________
followers = []
for i in range(FvNumber):
v = self.createVehicle(i, "F")
followers.append(v)

# Basic Vehicle model type: Leader
#_________________________________
#leaders = []
#for i in range(LvNumber):
# v = self.createVehicle(i, "L")
# leaders.append(v)
##########################
# Connect the fields nested loops.
# ________________________________
'''
for i in range(LvNumber): # Connect Leaders to Followers both fields.
fieldL = leaders[i][1]
fieldLG = leaders[i][2]
for j in range(FvNumber):
rigidF = followers[j][0]
cmds.connectDynamic(rigidF, fields=fieldL)
cmds.connectDynamic(rigidF, fields=fieldLG)

for i in range(FvNumber): # Connect Followers to Leaders
fieldF = followers[i][1]
for j in range(LvNumber):
rigidL = leaders[j][0]
cmds.connectDynamic(rigidL, fields=fieldF)

# Connect same type Vehicles to each other. Disconnect Vehicle from itself.

for i in range(LvNumber): # Connect Leaders to Leaders
rigidL1 = leaders[i][0]
fieldL1 = leaders[i][1]
for j in range(LvNumber):
rigidL2 = leaders[j][0]
fieldL2 = leaders[j][1]
cmds.connectDynamic(rigidL2, fields=fieldL1)

cmds.connectDynamic(rigidL1, delete=1, fields=fieldL1)
'''
for i in range(FvNumber): # Connect Follower to Followers
rigidF1 = followers[i][0]
fieldF1 = followers[i][1]
for j in range(FvNumber):
rigidF2 = followers[j][0]
fieldF2 = followers[j][1]
cmds.connectDynamic(rigidF2, fields=fieldF1)

cmds.connectDynamic(rigidF1, delete=1, fields=fieldF1)

######################################################################################## skip this global forces thing
# Connect the Global Forces to both types of Vehicles if option is on.

if self.gforces:
self.makeGforces()

compass = [ "N", "S", "E", "W" ]
for i in range(LvNumber):
for c in range(len(compass)):
cmds.connectDynamic(leaders[i][0], fields = "Gforce" + compass[c])

for i in range(FvNumber):
for c in range(len(compass)):
cmds.connectDynamic(followers[i][0], fields = "Gforce" + compass[c])

# Build Obstacles if option is selected.
if self.obst: self.collectObstacles()

# Disable warning.

cmds.cycleCheck(e=0)

# End of createCrowd def

def collectObstacles(self):
print "collecting obstacles!!"
if len(self.collectObjects) == 0: ### show on __init__ def
return "No obstacle objects were selected."
else:
print "elseeeee"
for ob in self.collectObjects:
print ob
cmds.rigidBody(ob, passive=1, name= ob + "_RigidB", bounciness=2.0)

#end def collectObstacles

# Make Global Forces with an interface.
#______________________________________

########################################### UI functions (for radio buttons)
def changeVnumber(self, *args):
if args[0] == "true":
self.vNumber = 10
else:
self.vNumber = 20
print "vNumber:",self.vNumber
def changeObst(self, *args):
if args[0] == "true":
self.obst = 1
else:
self.obst = 0
print "Obst:", self.obst
def changeGforces(self, *args):
if args[0] == "true":
self.gforces = 1
else:
self.gforces = 0
print "gforces:", self.gforces
def deleteUI(self, *args):
cmds.deleteUI(self.UIelements["window"])
self.UIelements = {}

############### call the class
c = Crowd()

And part of the second attempt:

import maya.cmds as cmds
import maya.mel as mel
import random
import math

def hit(hit, agent):
### define what to do when it some collision is detected
#all transformations are made only on the agent, as the hit object will perform the same queries on this agent
#if it hit the cube, ignore
if hit == "wall_rigid":
return
agentRole = cmds.getAttr(agent + ".role")
hitRole = cmds.getAttr(hit + ".role")
if hitRole == agentRole:
#check if both are bad
if hitRole == "bad":
#then shrink
cmds.scale(.9,.9,.9, agent, r=1)
else:
#if good, increase size
cmds.scale(1.1,1.1,1.1, agent, r=1)
elif hitRole != agentRole:
if hitRole == "bad":
#means agent role is good
cmds.scale(.90,.90,.90, agent, r=1)
elif hitRole == "good":
#means agent was bad
cmds.scale(1.1,1.1,1.1, agent, r=1)

#function to create shader
def createShader(color, transparency=0, type="lambert"):
#steps to create a new material
shadingNode1 = cmds.shadingNode(type, asShader=1)
shadingNode2 = cmds.sets(renderable=1, noSurfaceShader = 1, empty=1, name=shadingNode1+"SG")
cmds.connectAttr(shadingNode1+".outColor", shadingNode2 + ".surfaceShader", force=1)
#steps to modify material attributes
cmds.setAttr(shadingNode1 + ".color", color[0],color[1], color[2]) #color in r g b values
cmds.setAttr(shadingNode1 + ".transparency", transparency, transparency, transparency)

return shadingNode2

def applyShaderOnObject(obj, shader):
cmds.sets(obj, e=1, forceElement=shader)

class Agent:
def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="cube", rigidType="active", bounciness=.6, collide=1):
#set agent atributes
self.bounciness = bounciness
self.collide = collide
self.rigidType = rigidType
self.solver=solver
self.role = role
self.initialScale = size
#create the agent and scale it
self.object = cmds.polySphere(ax=(0,0,1))
cmds.scale(size[0], size[1], size[2])
#apply a color to the agent
#set the object color
sh = createShader(color, transparency=0, type="lambert")
applyShaderOnObject(self.object[0], sh)

#create the rigid body
self.rigid = cmds.rigidBody(self.object,
name=self.object[0] + "_rigid",
p=position,
b=self.bounciness,
impulse=(0,0,0),
sio=objType, #stand in object
cc = 1, #contact count
cp = 1, #contact position
cn = 1, #contact name
solver=self.solver)

#add attribute to the rigid body to store the type of agent
cmds.select(self.rigid, r=1)
cmds.addAttr(ln="role", dt="string", keyable=1)
cmds.setAttr(self.rigid + ".role", "good", type="string")

if self.rigidType == "active":
cmds.setAttr(self.rigid + ".active", 1)
else:
cmds.setAttr(self.rigid + ".active", 0)

#apply the expression
self.applyExpression()

def applyExpression(self):
"Function to apply the expression to the agent"
#first disconnect the rotation attributes because we want to controll it via expressions
cmds.disconnectAttr (self.rigid + "ry.output", self.object[0] + ".rotateY")
cmds.disconnectAttr (self.rigid + "rx.output", self.object[0] + ".rotateX")
cmds.disconnectAttr (self.rigid + "rz.output", self.object[0] + ".rotateZ")
# Create expression for VehicleF with a random multiplier added to the expression.
randX = random.uniform(-3,3)
randY = random.uniform(3,-3)
####COMPOSE THE EXPRESSION STRING
#this is how it should look like (in MEL)
'''
// Set wander motion of vehicle and add random multipliers.
pCube1_rigid_0.impulseX = sin(time * -2.808801);
pCube1_rigid_0.impulseY = (noise(time) * -1.041035);

// Set orientation of Vehicle according to the velocity direction.
float $fVel[];
$fVel = `getAttr pCube1_rigid_0.velocity`;

pCube1.rotateX = 0;
pCube1.rotateZ = atan2d( $fVel[0], $fVel[1] );
pCube1.rotateY = 0;

//checking bumps on other agents
string $lastHit;
if (pCube1_rigid_0.contactCount > 0){
int $contactCount = `getAttr pCube1_rigid_0.contactCount`;
$lastHit = `getAttr pCube1_rigid_0.contactName[0]`;
string $rigid = "pCube1_rigid_0";
python("hit('"+$lastHit+"', '"+ $rigid +"')");
};//endif
'''
#now put the text above in a python string
#the first lines define how the agent will wander
expString = "// Set wander motion of vehicle and add random multipliers.\n"
expString += "%s.impulseX" % self.rigid
expString += " = sin(time * %f);\n" % randX
expString += "%s.impulseY" % self.rigid
expString += " = (noise(time) * %f);\n\n" % randY
#the second part, how it rotates according to the direction it is going (velocity vector)
expString += "// Set orientation of Vehicle according to the velocity direction.\n"
expString += "float $fVel[];\n"
expString += "$fVel = `getAttr %s.velocity`;\n\n" % (self.rigid)
expString += "%s.rotateX = 0;\n" % self.object[0]
expString += "%s.rotateZ = atan2d( $fVel[0], $fVel[1] );\n" % (self.object[0])
expString += "%s.rotateY = 0;\n\n" % self.object[0]
#the third part, checking bumps on other agents
expString += "//checking bumps on other agents\n"
expString += "string $lastHit;\n"
expString += "if (%s.contactCount > 0){\n" % self.rigid
expString += " int $contactCount = `getAttr %s.contactCount`;\n" % self.rigid
expString += " $lastHit = `getAttr %s.contactName[0]`;\n" %self.rigid
expString += ' string $rigid = "%s";\n' % self.rigid
expString += ' python("hit(\'"+$lastHit+"\', \'"+ $rigid +"\')");\n'
expString += "};//endif\n"

self.expString = expString
cmds.expression(s=expString)

##############################################
class Crowd:
def __init__(self, numAgents=20, minPosition=-70, maxPosition=70, walls=0):
#set the playback options to increase the time range
cmds.playbackOptions(min= 1, max=5000)
self.numAgents = numAgents
self.minPosition = minPosition
self.maxPosition = maxPosition
#get any selected objects
self.wallObjs = cmds.ls(sl=1)
#create the rigid solver
self.solver = self.createSolver()
#create the agents
self.createAgents()
#create the walls
if walls: self.makeWalls()

def createSolver(self):
solver = cmds.rigidSolver( create=1,
current=1,
name="crowdSolver",
velocityVectorScale=0.5,
displayVelocity=1,
sc=1, #showcollision
ctd=1 #contact data
)
cmds.setAttr(solver + ".allowDisconnection", 1)
return solver

def createAgents(self):
type1 = ["good", (3,3,3), (250,100,0)] #name, scale, color
type2 = ["bad", (5,5,5), (100,100,100)]
types = [type1, type2]
self.badAgents = []
self.goodAgents = []
for i in range(self.numAgents):
#get the agent type randomly
at = random.choice(types)
#get random x and y
x = random.uniform(self.minPosition,self.maxPosition)
y = random.uniform(self.minPosition,self.maxPosition)
#create the agents
a = Agent(self.solver, at[0], color=at[2], size=at[1], position=(x,y,0))
if at[0] == "good":
self.goodAgents.append(a)
else:
self.badAgents.append(a)

def makeWalls(self):
#get selected object,
#which should be already with its normals facing to the right directions,
#and convert it to passive rigid bodies
if len(self.wallObjs) == 0:
return "No wall objects were selected."
else:
for w in self.wallObjs:
self.wallRigid = cmds.rigidBody(w, passive=1, name= "wall_rigid", bounciness=.8)

########################################
c=Crowd(numAgents=30, walls=1)

2009-07-09T03:12:00.000+02:00

##### Bacteria War _ crowd systems
#### started 20:21 08.07.09

### import all possibly needed

### Super Plan
###Passive agents:
## BODY (obstacles__rigid body)
## BRAIN (finish area__rigid body)
##Active agents:
## BACTERIUM (agent type1)
## DRUG (agent type2)

#####################################TRANSLATING into script
####create "BODY" and Agent 3d(small - Bacterium, big - Drug)
#### have them on stage
### rename 3d objects
### run script

import maya.cmds as cmds
import maya.mel as mel
import random
import math

def hit(hit, agent):
### define what to do when it some collision is detected
#if it hit the body, ignore
if hit == "wall_rigid":
return
agentRole = cmds.getAttr(agent + ".role")
hitRole = cmds.getAttr(hit + ".role")
if hitRole == agentRole:
#check if both are Drugs
if hitRole == "Drug":
#then rotate
cmds.rotate(90,90,0)
else:
#if Bacteria, delete Bacteria
cmds.delete('agent')
elif hitRole != agentRole:
if hitRole == "Drug":
#means agent role is Bacteria
cmds.duplicate('agent')
cmds.move(0,0,0)
elif hitRole == "Bacteria":
#means agent was Drug
cmds.delete('agent')

class Agent:
def __init__(self, solver, role, position=(0,0,0), size=(3,3,3), color=(0,0,0), objType="agent", rigidType="active", bounciness=.6, collide=1):
#set agent atributes
self.bounciness = bounciness
self.collide = collide
self.rigidType = rigidType
self.solver=solver
self.role = role
self.initialScale = size
#create the agent and scale it
NameDubObj1 = []
myDubObj1 = cmds.duplicate( 'agent' )# creation ( dublication) of the elements (bacteria/drug)
self.object = myDubObj1
cmds.scale(size[0], size[1], size[2])

#create the rigid body
self.rigid = cmds.rigidBody(self.object,
name=self.object[0] + "_rigid",
p=position,
b=self.bounciness,
impulse=(0,0,0),
sio=objType, #stand in object
cc = 1, #contact count
cp = 1, #contact position
cn = 1, #contact name
solver=self.solver)

#add attribute to the rigid body to store the type of agent
cmds.select(self.rigid, r=1)
cmds.addAttr(ln="role", dt="string", keyable=1)
cmds.setAttr(self.rigid + ".role", "Bacteria", type="string")

if self.rigidType == "active":
cmds.setAttr(self.rigid + ".active", 1)
else:
cmds.setAttr(self.rigid + ".active", 0)

#apply the expression
self.applyExpression()

def applyExpression(self):
"Function to apply the expression to the agent"
#first disconnect the rotation attributes because we want to controll it via expressions
cmds.disconnectAttr (self.rigid + "ry.output", self.object[0] + ".rotateY")
cmds.disconnectAttr (self.rigid + "rx.output", self.object[0] + ".rotateX")
cmds.disconnectAttr (self.rigid + "rz.output", self.object[0] + ".rotateZ")
# Create expression for VehicleF with a random multiplier added to the expression.
randX = random.uniform(-1,1)
randY = random.uniform(1,-1)

#the first lines define how the agent will wander
expString = "// Set wander motion of vehicle and add random multipliers.\n"
expString += "%s.impulseX" % self.rigid
expString += " = sin(time * %f);\n" % randX
expString += "%s.impulseY" % self.rigid
expString += " = (noise(time) * %f);\n\n" % randY
#the second part, how it rotates according to the direction it is going (velocity vector)
expString += "// Set orientation of Vehicle according to the velocity direction.\n"
expString += "float $fVel[];\n"
expString += "$fVel = `getAttr %s.velocity`;\n\n" % (self.rigid)
expString += "%s.rotateX = 0;\n" % self.object[0]
expString += "%s.rotateZ = atan2d( $fVel[0], $fVel[1] );\n" % (self.object[0])
expString += "%s.rotateY = 0;\n\n" % self.object[0]
#the third part, checking bumps on other agents
expString += "//checking bumps on other agents\n"
expString += "string $lastHit;\n"
expString += "if (%s.contactCount > 0){\n" % self.rigid
expString += " int $contactCount = `getAttr %s.contactCount`;\n" % self.rigid
expString += " $lastHit = `getAttr %s.contactName[0]`;\n" %self.rigid
expString += ' string $rigid = "%s";\n' % self.rigid
expString += ' python("hit(\'"+$lastHit+"\', \'"+ $rigid +"\')");\n'
expString += "};//endif\n"

self.expString = expString
cmds.expression(s=expString)

##############################################
class Crowd:
def __init__(self, numAgents=4, minPosition=-20, maxPosition=20, walls=0):
#set the playback options to increase the time range
cmds.playbackOptions(min= 1, max=5000)
self.numAgents = numAgents
self.minPosition = minPosition
self.maxPosition = maxPosition
#get any selected objects
self.wallObjs = cmds.ls(sl=1)
#create the rigid solver
self.solver = self.createSolver()
#create the agents
self.createAgents()
#create the walls
if walls: self.makeWalls()

def createSolver(self):
solver = cmds.rigidSolver( create=1,
current=1,
name="crowdSolver",
velocityVectorScale=0.5,
displayVelocity=1,
sc=1, #showcollision
ctd=1 #contact data
)
cmds.setAttr(solver + ".allowDisconnection", 1)
return solver

def createAgents(self):
type1 = ["Bacteria", (1,1,1), (1,1,0)] #name, scale, color
type2 = ["Drug", (5,5,5), (.6,.6,.6)]
types = [type1, type2]
self.DrugAgents = []
self.BacteriaAgents = []
for i in range(self.numAgents):
#get the agent type randomly
at = random.choice(types)
#get random x and y
x = random.uniform(self.minPosition,self.maxPosition)
y = random.uniform(self.minPosition,self.maxPosition)
#create the agents
a = Agent(self.solver, at[0], color=at[2], size=at[1], position=(x,y,0))
if at[0] == "Bacteria":
self.BacteriaAgents.append(a)
else:
self.DrugAgents.append(a)

def makeWalls(self):
#get selected object,
#which should be already with its normals facing to the right directions,
#and convert it to passive rigid bodies
if len(self.wallObjs) == 0:
return "No wall objects were selected."
else:
for w in self.wallObjs:
self.wallRigid = cmds.rigidBody(w, passive=1, name= "wall_rigid", bounciness=.8)

########################################
c=Crowd(numAgents=4, walls=1)

Assignment 03B - Final

2009-07-08T01:29:00.001+02:00

As a continuation of the final assignment, you should now try to script your idea. Most of the ideas posted deal with collisions, and reactions according to those collisions. As this was not part of our original crowd system example given in class, here is an example script which deals with collision detection:

cs_help.py

Here is also an example .mb file where the system above is already placed in the scene:

cs_help.mb

The rule which deals with the collision can be found in the hit function, right in the beginning of the script. this system not perfect, has tons of caveats, but you can get the idea.

In this script you can also see how to create an enclosure for your agents, something such as a box which contains the whole system inside, so that your agents are "trapped".

If you have too much difficulty, post your doubt on the blog. I'll check it daily to answer it!

The deadline for this assignment is this Sunday (12.07).

w08 - script

2009-07-08T01:16:00.001+02:00

Here is the finalized script for the crowd system done in the past two classes. It also includes the global forces option in it. For details, read the comments.

crowdSystem.py

Assignment 03 A - Biennale Self Organization System - Alexandra and Mircea

2009-07-05T16:25:00.006+02:00

BACTERIUM WAR

2009-07-05T14:42:00.002+02:00

Assignment 03A_Alice

2009-07-05T14:05:00.006+02:00

This is my initial thought...but I am not sure if my scenairo is too complicated. Represented by simple boxes, it is imitating a situation found in a district or shopping mall.

Agent Type A represents poeple in different age groups. Therefore, in general, they are attracted/repulsed to different programmes, with different speeds.

Agent Type B (passive) represents different programmes we can found either on streets or in a shopping mall. I have just named few in the list.

Things to be defined

- Attraction Level i,e the speed and amount

- Attraction Duration i.e. how long will Agent A be attached with Agent B

- Attraction Capacity i.e. repulsion occcurs when some Agent B is over-attracted.

Differen types of Agent A should be generated randomly and being replaced along the timeline.

Assignment 03A Shi xinyu & Liu

2009-07-05T12:37:00.001+02:00

Agent-based system - applications

2009-07-01T18:28:00.001+02:00

Here are some examples of the use and study of agent-based, self-organizing systems in architecture:

The images above are from the project Swarm Urbanism (2008) from Kokkugia, a speculative proposal which

(...) posits an urban design methodology based on the emergent capacities of Swarm Intelligence in rethinking of the current redevelopment of the Melbourne Docklands. Swarm systems involve the local interaction of autonomous agents, which give rise to emergent behavior and the self-organisation of structures. An application of swarm logic to urbanism enables a shift from notions of the master-plan to that of master-algorithm as an urban design tool. This shift changes the conception of urban design from a sequential set of decisions at reducing scales, to a simultaneous process in which a set of micro or local decisions interact generate a complex urban system. Rather than designing an urban plan that meets a set of criteria, urban imperatives are programmed into a set of agents which are able to self-organise. Consequently this conception of urbanism generates systems that are flexible to respond to the constantly changing political, economic and social pressures of urban development.

Also from Kokkugia, the above project (Emergent Fields, 2003), in which

(...) Agent-based simulation techniques are used to generate programmatic relationships and an architectonic response to this field of program. Architectural elements such as a façade, plaza, or construction grid are assigned rules or behaviours, which govern the way in which they interact with this field in the form making process. This develops an emergent relationship between program and peculiarities of architectural form, enabling the design process, and resultant architecture to exhibit particular behavioural qualities.

Also in the research developed by Space Syntax together with the Space Group at Barttlet, we can find the use of agent-based systems to explore pedestrian behaviour within the field of urbanism, flight-routes, programmatic organization, etc.

Space syntax has found that, despite many proposed higher-level cognitive models, there appears to be a fundamental process that informs human and social usage of an environment. In this paper we describe an exosomatic visual architecture, based on space syntax visibility graphs, giving many agents simultaneous access to the same pre-processed information about the configuration of a space layout. Results of experiments in a simulated retail environment show that a surprisingly simple 'random next step' based rule outperforms a more complex 'destination based' rule in reproducing observed human movement behaviour. We conclude that the effects of spatial configuration on movement patterns that space syntax studies have found are consistent with a model of individual decision behaviour based on the spatial affordances offered by the morphology of the local visual field.

Assignment 03A

2009-06-23T14:20:00.001+02:00

In the first part of this assignment, you should think about the logic of a self-organizing system. You should draw diagrams and write the whole logic by which it would work. Here are some guidelines:

Think about local intelligence and local interactions. Each agent will only "look" at its immediate surroundings and make decisions based on these "encounters". The collective intelligence comes from these local interactions (think ant colonies!)
Define roles of your agents, or types of agents. Each agent has a set of properties and will react in a certain way when encountering certain other agents. Keep in mind the exponential complexity here: for each agent you should define the action to be taken when it encounters each of the other agents and also agents of the same type (in case there is more than one). So if you have 4 types of agents, you have to think of circa 16 types of interactions
Think also of passive agents. Obstacles, for example, could be characterized as passive agents: they affect all other agents, but it doesn't react on any way.
Think of forces of attraction and repulsion, and also on other more complex arrangements (in case one agent encounter a group of other agents combined, for example)

More important, use your imagination. Produce material which could explain for ANYONE about your idea, and post on the blog. Be as thorough as possible!

Please post all until Sunday, so you can have it out of the way the following week, and I can use the other week to prepare some help for you!

w07 - recap + script

2009-06-23T14:11:00.001+02:00

Yesterday we started looking at our third and final topic: self-organizing systems and dynamics/expressions in Maya. We started some simple crowd system class, and saw some principles of dynamics in Maya (rigid bodies) and expressions (to make objects move).

Here is the script until the part we accomplish together yesterday:

crowdSystem_w07.py

In the next class we should finish it by applying fields forces (for attraction and repulsion between elements) and create the desired number of leaders and followers, connecting their dynamic forces to make them interact with each other.

Delaunay Triangulation via Math

2009-06-21T16:40:00.001+02:00

Here is what was supposed to be your assignment 02B, a class definition to calculate Delaunay triangulations from a set of points by means of mathematical calculations (without the help from Qhull).

delaunay.py

There are several algorithms to approach such problem, some more efficient than others. This seems to be one of the simplest, and this class definition is based on it.

Take some time to study it and check if you understand how it is done. I'll talk about it shortly on next class.

w06 - recap and script

2009-06-17T13:42:00.001+02:00

Last class we saw how to parse a Delaunay 2D text file generated by qhull and convert it to objects in Maya's stage. Here is the link from the finished script, which also contains the Delaunay3D and ConvexHull classes:

qhull_w06.py

I'm not stupid :-)

2009-06-14T21:22:00.012+02:00


import maya.cmds as cmds

def IsBounded(item):
    for x in item:
        if x < 0:
            return False
    return True
 
class delauney:
 def __init__(self):
  self.vertices = []
  self.regions = []
  self.dimension = ""
  self.path = "C:/MAYA/"
  print "Instance of class Delauney created."
  
 def load(self):
  # Get vertices positions in the points.txt
  
  print "Loading Qhull file..."
  # Open the file and get the second line in order to get the number of vertices
  f = open('C:/MAYA/points.txt', 'r')
  d = f.readline()
  i = f.readline()
  i = int(i.strip())

  # Get line by line the x, y positions (and z if it exists) 
  while i > 0:
   l = f.readline()
   t = l.split()
   pt1 = float(t[0])
   pt2 = float(t[1])
   if len(t) > 2:
    pt3 = float(t[2])
    self.dimension = "3D"
    self.vertices.append([pt1, pt2, pt3])

   else:
    pt3 = 0
    self.dimension = "2D"
    self.vertices.append([pt1, pt2])    
   i = i-1
  
  # Feedback 
  print ">>> RESULTS"
  print len(self.vertices), " vertices ", self.vertices
  
  # Open the qHullResults.txt in order to get the name of the points to join.
  # Get the first number, in order to get number of regions
  # Daniel, I'm sorry for the hardcoding for the names of the files, and for the "region.append(int(t[2]))" if its not a 3D drawing, but i'm really tired
  f = open('C:/MAYA/qHullResults.txt', 'r')
  l = f.readline()
  i = int(l)
  
  # Get line by line the name of the points to join
  while i > 0:
   l = f.readline()
   t = l.split()
   region = []
   j=0
   while j < i:
    region.append(int(t[0]))
    region.append(int(t[1]))
    region.append(int(t[2]))
    j = j + 1
   self.regions.append(region)
   i = i-1
  
  # Feedback 
  print len(self.regions), " regions ", self.regions
  f.close()
   
 def draw(self):
  # draw a curve between the points to create the regions! 
  
  for region in filter(IsBounded, self.regions):
   vs = []
   neg = 0
   
   for i in region:
    if i < 0:
     neg = 1
     break
   
    v = self.vertices[i]
    vs.append(v)
      
   if neg == 0:
    crv = cmds.curve(ep=vs, d=1)
    cmds.closeCurve(crv, rpo=1)

2009-06-13T13:42:00.006+02:00

this is my studio script (using classes). i wrote some more helping scripts in the beginning.

in the maya scene should be a few locators (which are attraction and repulsion points)


import maya.cmds as cmds
import maya.mel as mm
import math
import sys
from random import*
from setColor import*
sys.setrecursionlimit(8000)

############################################################################################################################

def centerOfFace(facet):
 #find the vertices that define that face.
 vertex = cmds.polyListComponentConversion(facet, ff=1, tv=1)
 cmds.select(vertex, r=1)
 vertexFlat = cmds.ls(sl=1, fl=1)

 #find out how many vertices define that face
 vertCount = len(vertexFlat)
 #print vertexFlat
 
 #for each vertex go through and find it's world space position. 
 vertPositionSumX = 0.
 vertPositionSumY = 0.
 vertPositionSumZ = 0.
 for a in range(0, vertCount, 1):
  coordinate = cmds.pointPosition(vertexFlat[a], w=1)
  vertPositionSumX += coordinate[0]
  vertPositionSumY += coordinate[1]
  vertPositionSumZ += coordinate[2]

 centroidX = vertPositionSumX/float(vertCount)
 centroidY = vertPositionSumY/float(vertCount)
 centroidZ = vertPositionSumZ/float(vertCount)
 
 return [centroidX, centroidY, centroidZ]
 
def getDistance(start, end):
 #start and end must be lists xyz
 v = [start[0]-end[0], start[1]-end[1], start[2]-end[2]] #list format x,y,z
 vector = "<<" + str(v[0]) + "," + str(v[1]) + "," + str(v[2]) + ">>"
 mag = mm.eval("mag " + vector + ";")

 return mag
 
def closestLocator (locator, netOfLocs):
 locatorPos = cmds.pointPosition(locator)
 distance = 1000000000
 closLocData = []
 closestLocator = ""
 for i in netOfLocs:
  locPos = cmds.pointPosition(i)
  currDist = getDistance(locatorPos, locPos)
  if currDist < distance:
   distance = currDist
   closLocator = i
   closLocPos = locPos
   closLocDist = currDist
 closLocData.append (closLocator)
 closLocData.append (closLocPos)
 closLocData.append (closLocDist)
 
 return closLocData
 
def closestLocatorToPoint (Point, netOfLocs):

 locatorPos = Point
 distance = 1000000000
 closLocData = []
 closestLocator = ""
 for i in netOfLocs:
  locPos = cmds.pointPosition(i)
  currDist = getDistance(locatorPos, locPos)
  if currDist < distance:
   distance = currDist
   closLocator = i
   closLocPos = locPos
   closLocDist = currDist
 closLocData.append (closLocator)
 closLocData.append (closLocPos)
 closLocData.append (closLocDist)
 
 return closLocData
 
def midPoint (listPt1,listPt2):
 x=0
 y=0
 z=0
 n=0
 for i in listPt1:
  ptPos = cmds.pointPosition(i)
  x=x+ptPos[0]
  y=y+ptPos[1]
  z=z+ptPos[2]
  n=n+1
 for i in listPt2:
  ptPos = cmds.pointPosition(i)
  x=x+ptPos[0]
  y=y+ptPos[1]
  z=z+ptPos[2]
  n=n+1
 midX = x/n
 midY = y/n
 midZ = z/n 
 midPt=[]
 midPt.append (midX) 
 midPt.append (midY)
 midPt.append (midZ)
 
 return midPt
 
def midPointInPtLocs (listLoc1,listPt2):
 x=0
 y=0
 z=0
 n=0
 for i in (1,len(listLoc1)-1,1):
  ptPos = cmds.pointPosition(listLoc1[i])
  x=x+ptPos[0]
  y=y+ptPos[1]
  z=z+ptPos[2]
  n=n+1
 ptPos = listPt2
 x=x+(ptPos[0]*len(listLoc1))
 y=y+(ptPos[1]*len(listLoc1))
 z=z+(ptPos[2]*len(listLoc1))
 n=n+len(listLoc1)
 midX = x/n
 midY = y/n
 midZ = z/n 
 midPt=[]
 midPt.append (midX) 
 midPt.append (midY)
 midPt.append (midZ)
 
 return midPt

def direction(a,b):
 "Returns the direction vector going from a to b"
 # Calculate direction vector
 dire = [  a[0] - b[0], a[1] - b[1], a[2] - b[2] ]  #  a-b
 return dire

############################################################################################################################

class graves:
 def __init__(self):
  print "Instance of class Graves created."
  
 def getData(self):
  locs = cmds.filterExpand(sm=22)
  return locs
 
 def getRepulsiveLocs (self):
  locs1 = cmds.filterExpand(sm=22)
  return locs1
  
 def getAllLocators (self, AmountOfAttractors):
  repulciveLocs = cmds.filterExpand(sm=22)

  locs =[]
  for i in range (AmountOfAttractors):
   L = repulciveLocs[0]
   repulciveLocs.remove (L)
   locs.append (L)
  return locs, repulciveLocs
 
 def polyCubesInLocators (self, locators, size):
  cubes = []
  for i in locators:
   position = cmds.pointPosition(i)
   cube = cmds.polyCube (w =size ,h=size ,d=size )
   cmds.move (position[0], position[1], position[2], cube)
   cubes.append (cube)
  
  return cubes
  
 def makeNet (self, locators, numRow, numCell):
  allLocs = []
  startLocs = []
  x = randint (98,102)
  x = x/100.0
  for i in range (numRow):
   for j in range (numCell):
    newloc= cmds.spaceLocator( p=(j*10*x, i*10*x, 0) )
    if i == 0: 
     startLocs.append (newloc)
    elif i == (numRow-1):
     startLocs.append (newloc)
    else:
     allLocs.append (newloc)
  cmds.refresh()
  return startLocs, allLocs
 
 def changeNetBecauseRepulsive (self, allLocs, repulsiveLocs, repSize, pointsAmount = 4, N=0):
  Empty =[]
  LOCS = allLocs
  for i in allLocs:
   Empty.append (i)
  C = pointsAmount
  
  for k in repulsiveLocs: 
   for i in range (repSize):
    L=(repSize/5)*(i+1)
    for j in range (L):
     Kpos = cmds.pointPosition(k)
     closLoc = closestLocatorToPoint(Kpos, LOCS) 
     LOCpos = closLoc[1]
     clLoc = closLoc[0] 
     direc = direction(LOCpos, Kpos)
     newX = ((direc[0]*6)/((i+1)*(i+1)))
     newY = ((direc[1]*6)/((i+1)*(i+1)))
     newZ = ((direc[2]*6)/((i+1)*(i+1)))
     cmds.move  (newX, newY, newZ, clLoc)
     LOCS.remove (clLoc)
     
    cmds.refresh()
  return Empty
   
 def subdivStartLocs (self, startLocs, locs):
  subStartLocs = []
  lenLocs = len(locs)
  lenStertLocs = len(startLocs)
  locsPerUnit = lenStertLocs/lenLocs
  for i in range (lenLocs):
   groupOfLocs = []
   groupOfLocs.append (locs[i])
   for j in range (locsPerUnit):
    numOfLoc = i*locsPerUnit+j
    loccc = startLocs [numOfLoc] 
    loccc = loccc[0]
    groupOfLocs.append (loccc)
   subStartLocs.append (groupOfLocs)  
  
  return subStartLocs

 def looping1 (self, subdivStartLocs, allLocs, locs, size, number, cubes):
  #cmds.pause( sec=0.5 )
  cmds.refresh()
  size *= 1.03
  color = 255/(size*10) 
  number = number + 1
  print "number"
  print number
  temploryList = []
  midPoints =[]
  N=0
  for i in subdivStartLocs:
   if number == 1:
    Pt1 = len(i)/2
    midP = i[Pt1]
    midP = cmds.pointPosition(midP)
    remLocs = []
    remLocs.append (i[0])
    x = randint (2,len(i)+7)
   else: 
    midP = i
    remLocs = []
    #remLocs.append (i)
    x = randint (2,len(subdivStartLocs)+7)
   n = 0 
   if len(allLocs)>x:
    for g in range (x):
     closLocData = closestLocatorToPoint (midP, allLocs)
     closLocator = closLocData[0]
     closLocPos = closLocData[1]
     closLocDist = closLocData[2]
     
     newSphere = cmds.polySphere (r=size, sx=4, sy=4)
     cmds.move  (closLocPos[0], closLocPos[1], closLocPos[2], newSphere)
     remLocs.append (closLocator)
     allLocs.remove (closLocator)
   if len(allLocs)<2:
    return "Done."
     
   temploryList.append (remLocs)
   
   #################################################################
   if number == 1:
    Pt1 = len(i)/2
    midPt1 = i[Pt1]
    midPt1 = cmds.pointPosition(midPt1)
    ptPos = cmds.pointPosition(i[0])
    midPt = midPoint (remLocs,i)
   else:
    ptPos = cmds.pointPosition(locs[N])
    midPt = midPointInPtLocs (remLocs,i)
   
   midX = midPt[0] - midP[0]
   midY = midPt[1] - midP[1]
   midX = ptPos[0] + (midX/2)
   midY = ptPos[1] + (midY/2)
   cmds.move  (midX, midY, 0, cubes[N])
   cmds.move  (midX, midY, 0, locs[N])
   midP = midPt
   N = N+1
   midPoints.append (midP)
   ##################################################################
  
  subdivStartLocs = midPoints
  
  if len(allLocs)>0:    
   self.looping1 (subdivStartLocs, allLocs, locs, size, number, cubes)
  else:
   return "Done."

this part is running the script in way like on the video above


g= graves()

locs, repulsiveLocs = g.getAllLocators (8)
cubes = g.polyCubesInLocators ( locs, 6)
cubes1 = g.polyCubesInLocators ( repulsiveLocs, 10)

startLocs, allLocs = g.makeNet(locs,48,48)
cubes2 = g.polyCubesInLocators ( startLocs, 1)
allLocsPPP = allLocs


ALLLOCS = g.changeNetBecauseRepulsive (allLocsPPP, repulsiveLocs, 13)


subd = g.subdivStartLocs(startLocs,locs)
g.looping1 (subd, ALLLOCS, locs, 1.2, 0, cubes)

Assignment 02A

2009-06-10T13:34:00.001+02:00

In this assignment you should take a look at the script from last class and try to write it further. The idea is to create a new class definition on it, either to produce Delaunay triangulations or convex hulls. Here are some tips:

The qhull commands you need to run are already in the runQhull method of the Qhull class. You don't need to worry about them. They will return you a text file containing all the information you need to assemble your objects
The structure of the new class should be very similar from the Voronoi class structure. You should write a load method to read the file you generated from qhull and parse it, saving vertex and region information on the regions and vertices attributes of the class.
Then you should then concentrate on the draw function. Keep in mind some of the workarounds done in the Voronoi class, like re-ordering the vertices, are not necessary in the Delaunay or convex hull. Just read all the vertices, then draw the regions using the vertices indexes.
You can find some help on the web. Some sites:

You should post whatever results you get on the blog by this Sunday, 14.06. You should also post any questions you might encounter.

Week 05 - script

2009-06-10T13:22:00.001+02:00

Here is a link to download the working script from last class, which already contains the new voronoiShatter method. It is entirely commented and you should be able to understand it from what was explained in class.

Week 05 - recap

2009-06-10T11:47:00.001+02:00

On this class we took a look on all the functions contained in the voronoi script we are working on: point generation function, qhull commands, voronoi creation. We also wrote our own voronoi shatter method to the voronoi class, going through concepts of vector math along the way.

Week 05 - file to download

2009-06-08T03:10:00.002+02:00

In our class tomorrow we will take a close look at a ready-made script containing advanced methods for the generation of Voronoi diagrams using Qhull.

After that, we will add one more method to the class, which uses pure mathematics to perform voronoi calculations, so we can learn a bit about vector math and some other scripting techniques.

For that, you should download this script and save it in your script folder.

01B-Alice-Questions

2009-05-25T13:43:00.003+02:00

Thanks a lot Daniel for all the comments. I am happy to know the script is working in the right direction. :) Sorry for sending you back my questions again...late...

Refer to your comments

1) I understand what you said and why the value of the points should be generated inside the function. However, if I change my function to

def pointBoundary(iterations, ptA, ptB, ptC):

do I still need to, at least for once, use the random function to generate 3 points before I can call my function?
when I call the recursion, can I just say, for instance:

pointBoundary(10, ptA, ptB, ptC) or pointBoundary(10)

2) I am not clear what do you mean:
"it should be idented under the else statement, so that it is executed only if iterations are not equal to 0"
because I have already idented...what should I change?

3)I successfully created random points and store them in a list.


pts=["ptA","ptB","ptC"]
 for i in range (len(pt)):
  from random import *

  x = uniform(-squareSideLength/2, squareSideLength/2)  
  y = uniform(-squareSideLength/2, squareSideLength/2)
  pts[i] =(x,y)

Is that alright?

** I have extra questions -
any differences if I write "pts[%d]%i" but not "pt[i]" ??

4) How to make sure I offset the line outward but not inward, in relation to the centre of the square??

5) Would using "classes" will help to shortening the script? because I always need to repeat the each steps for A, B, C...but I can't simply use loop...

6) Other questions you haven't answered:

a) Can you run the Serpentine Pavilion Script? I have syntax error with the line "iterations-=i"
b) What does argument type -"boolean" and "linear" mean?
c) What does "break" mean?
d) I can check cmds.command on the python help list, but how about others like "random" commands, those kinds of none cmds. commands?

Thanks.

01B - Alexandra+Micea - Recursion squares - ScreenShots

2009-05-24T20:13:00.004+02:00

01B - Mircea+Alexandra - Recursion squares-Script

2009-05-24T19:58:00.009+02:00


#assignment o1B_A+M

#create an initial square 
#get the coordinates of the points on each line, depending on the percentage ( in this case the percenatege is a subdivison)
#create a new square with the center in each point we get in the previous step
#rotate the squares with an angle
#scale the initial square
#recursion (by each iteration a new square is created, and along the lines other squares are created and rotated in the same time)


import maya.cmds as cmds

#create one initial square
x=10
y=10
mySquare = cmds.nurbsSquare(sl1=x, sl2=y)

      
def recursion( iterations , amt , percentage): 
 it=iterations  
 pp=percentage
 
 #select the square
 cmds.select( mySquare, r=1 )   
 isSides = cmds.filterExpand( sm=9 )  
 print isSides
  
 #go through all the lines of the square 
 for i in range(0, len(isSides), 1):  
  print i 
  line = isSides[i]  
      #get the coordinates on the lines depending on the percentages
   for j in range(1, pp+1, 1):
   procent = j/float(pp)
   poc = cmds.pointOnCurve(line,pr=procent,top=True,p=True)
   #create a new square with the center in each point;
   #the side of the squares created either can have decreasing values or the same length
   #newSquare = cmds.nurbsSquare(c=poc, sl1=1/float(x/pp), sl2=1/float(y/pp))  
   newSquare = cmds.nurbsSquare(c=poc, sl1=2, sl2=2)      
   #rotate squares with an angle
   cmds.rotate(0,0,it*amt*2, newSquare, pivot=poc)

 if iterations == 0:  
  return "Done."  
 else:  
  iterations -= 1 
  percentage -= 1 
  #scale the initial square
  cmds.scale( 1/float( x/pp),1/float( x/pp), 1/float( x/pp) , mySquare, pivot=(0, 0, 0), absolute=True )
  recursion(iterations, amt, percentage) 
   
   
recursion(4,10,4)

Assignment 01B

2009-05-24T02:06:00.002+02:00

Question:
How to get the intersection coordinate in this case?

Assignment 01B

2009-05-24T02:01:00.002+02:00

import maya.cmds as cmds

#Step1:Define the biggest and smallest circles
BigRadius=30
SmallRadius=2
Minus= BigRadius-SmallRadius

#Step2:Create these two circles
cmds.circle(c=(0,0,0),r=30)
cmds.circle(c=(0,-28,0),r=2)

#Step3:Generate two circles which follow the tangent princples
#1)r1+r2=D
NextRadius=SmallRadius+1
D= NextRadius+SmallRadius
cmds.circle(c=(0,-28,0),r=D)

#2)offset the outmost circle based on the radius of next circle
cmds.circle(c=(0,0,0), r=BigRadius-NextRadius)
#3)Get the intersection point at the right side and as the center point of the new circle
# which is tangent with previous two circles
#Question:
# How to find out the coordinate of the intersection point in this case??????????????????????

'''
#Loop through it based on previous steps
for i in range(2,BigRadius,1):
cmds.circle(c=(0,0,0),r=Minus-i)
radius=3
r1= radius
r2= radius+i
radius+=1
D=r1+r2
cmds.circle(c=(the center coordinate from the intersection point),r=D)
'''

2009-05-24T01:57:00.001+02:00

MY SCRIPT "RECURSION STUFF" - pic

2009-05-23T22:07:00.002+02:00

MY SCRIPT "RECURSION STUFF" - it works)

2009-05-23T21:43:00.001+02:00

def PLAN():

1)Create primitive (6 angle for ex-le)

2)Use this primitive as a path (curve)

3)Define the random amount of primitives(within Fibonacci numbers 1,1,3,5,8,13,21,44,65...)

4)Dulicate them

5)Pick a random point within pritive length

6)Move them on it

7)Scale primitives random

8)enjoy)

PLAN()

###RECURSION STUFF#####

def primitives(numSides, radius):

#create a circle

myCircle = cmds.circle(radius = 30)

#get param steps, I will take 6 for ex-le

paramSteps = 1./6

#loop and get points coordinates

points = []

for i in range(0, 8, 1):

points.append( cmds.pointOnCurve(myCircle[0], p=1, pr=paramSteps*i, top=1) )

#create a curve connecting points

myPrimitive = cmds.curve(ep=points, d=1)

#close the curve

cmds.closeCurve(n="p_"+str(numSides)+"_sides", rpo=1)

#delete the circle

cmds.delete(myCircle)

#return the name of the primitive

return myPrimitive

primitives(6, 30)

from random import *

def Whatamess():

#define the random amount of primitives

randomAmount = randint(21,44) # fibonachi number 1,1,3,5,8,13,21,44,65... and so on

for i in range (0,randomAmount,1):

#duplicate my primitiv

myDupObj2 = cmds.duplicate( 'curve1' )

# get the center of the duplicated object

myCenter = cmds.xform(myDupObj2, q=1, t=1, ws=1)

# get the maximun "length" of the curve, so we can pick a random point within this length

#I wanna use my Primitive as a curve. Why not?)

myCurveParam = cmds.getAttr("curve1.maxValue")

# select a random point on the curve

myPoint = cmds.pointOnCurve( 'curve1', pr = uniform(0,myCurveParam), p=True)

# select the previously duplicated object

cmds.select(myDupObj2)

# move it to the new location

cmds.move(myPoint[0],myPoint[1],myPoint[2])

#scales it

cmds.scale(uniform(1,1.5),uniform(1,1.5),uniform(1,1.5),a=1)

Whatamess()

### As You can see, I changed my consept a bit,

### from controlled variant to random, because I dont know how to put

### mathematical formulas (Fibonacci x3 = x2+x1) But I included one of your "helpful" scripts and I like the result) after all

def PLAN1():

1)Create primitive (6 angle for ex-le)

2)Use this primitive as a path (curve)

3)Define the random amount of primitives(within Fibonacci numbers 1,1,3,5,8,13,21,44,65...)

4)Dulicate them

5)Pick a point within pritive length ( I dont know how to pick different

points with Fibonacci proporsion-divide curve propotionally [1,1,3,5...])

6)Move them on it (I dont know how to put them, so they will not intersect)

7)Scale primitives (but I dont know how to scale them proportionally)

8)enjoy more)

PLAN1()

2009-05-23T20:32:00.003+02:00

It does not work and giving mistake:
UnboundLocalError: local variable 'Squares' referenced before assignment #


import maya.cmds as cmds
x=10
y=10
#Make a Square
initialSqare = cmds.nurbsSquare(sl1=x, sl2=y)
#get outline
isSides = cmds.filterExpand (sm=9)
print isSides
#make an empty list
Squares = []
Squares.append (1)

def squareINsquare (number):
#scale
x=10/(1.5*len(Squares)+1)
y=10/(1.5*len(Squares)+1)
#loop
for j in range (0,len(Squares),1):
cmds.select (Squares[j], r=True)
#get outline
isSides = cmds.filterExpand (sm=9)
#looping in outline
for i in range (0,2,1):
perc1 = 0
perc2 = 1
line1=isSides[1]
line2 = isSides[2]
if i == 0:
 poc1 = cmds.pointOnCurve(line1, pr=perc1, top=True, p=True)
 print poc1
 #change the center of the new square
 poc1[0]=poc1[0]-x/2
 poc1[1]=poc1[1]+y/2
 print poc1
 #make a new square
 initialSqare1 = cmds.nurbsSquare(c = poc1, sl1=x, sl2=y)
#the same for the oposit corner of the squre
else:
 poc2 = cmds.pointOnCurve(line2, pr=perc2, top=True, p=True)
 print poc2
 poc2[0]=poc2[0]+x/2
 poc2[1]=poc2[1]-y/2
 print poc2
 initialSqare2 = cmds.nurbsSquare(c = poc2, sl1=x, sl2=y)

Squares.append (initialSqare1)
Squares.append (initialSqare2)
Squares=Squares1
Squares1=[]
if number == 0 :
#stop
return "Done."
else:
#did not finish yet
#remove one unit (count down)
number -= 1

squareINsquare (number)

squareINsquare (3)

01B - alec' - Real recursion, soft code, optimized, updated, improved & commented new script...

2009-05-23T18:58:00.011+02:00

In this script I mainly correct my mistakes! I changed the loop in a real recursive function, I used "soft code" instead of "hard code" and I tried to optimized my codes.

I also added a recursion "J" which makes vary the result every time we call the function once again. This new "j" parameter (called "recursions" with a "s") increase the rotation angle and the scale of the squares. (= the first 4th screenshots)

In this example, I used a loop at the end of the script to call the function 5times!
and I configured this script to show only the z-axis projection. (= the last screenshot)

I didn't managed to simplify the "projection part" ... from the line 53 to 65.



import maya.cmds as cmds

##########################
### INITIAL PARAMETERS ###
##########################
### drawx = project square on x axis,  drawy = project square on y axis,  drawz = project square on z axis
### delete3Dsquare = delete the original iterated squares
### deletelocator = delete locator related to the rotationpoint
### deleteSquareSurface = delete the nurbsSquare used for the pointPosition + offset function
drawx = 0             # 0 = Fasle /// 1 = True
drawy = 0             # 0 = Fasle /// 1 = True
drawz = 1             # 0 = Fasle /// 1 = True
delete3Dsquare = 1        # 0 = Fasle /// 1 = True
deletelocator = 1        # 0 = Fasle /// 1 = True
deleteSquareSurface = 1        # 0 = Fasle /// 1 = True
iterationgroup = cmds.group(em=True)
if cmds.objExists('j'):
print "rien"
else:
cmds.spaceLocator(n='j')
iterations = 1
j = []



############################
### DEF RECURSIVE SQUARE ###
############################
### Def the function according to 3 parameters; number of iterations, angle of rotation between each square, offset of the point of rotation
### rotationpoint [0,0,0] is the initial rotation point position /// these position are used only for the first iteration

def recursivesquares(j,iteration, angle, offset, rotationpoint=[0,0,0]):
group = cmds.group(em=True)

### Create the square, and rotate it according to the angle and rotationpoint parameters
nurbsSquare = cmds.nurbsSquare(sl1=iterations*5, sl2=iterations*5, c=rotationpoint, nry=1, nrz=0)
cmds.parent(nurbsSquare[0], group)
cmds.rotate(iterations*iteration*angle, iterations*iteration*angle, iterations*iteration*angle, [nurbsSquare[0]], pivot=(rotationpoint))

### Determining the position of each corner of this square
topposition = cmds.pointPosition('top'+nurbsSquare[0]+'.cv[0]', world=True)
leftposition = cmds.pointPosition('left'+nurbsSquare[0]+'.cv[0]', world=True)
rightposition = cmds.pointPosition('right'+nurbsSquare[0]+'.cv[0]', world=True)
bottomposition = cmds.pointPosition('bottom'+nurbsSquare[0]+'.cv[0]', world=True)

### Create a nurbs surface to use the pointOnSurface command with the offset parameter
### Create a locator in the position of this new rotationpoint
nurbsSquareSurface = cmds.squareSurface('top'+nurbsSquare[0], 'right'+nurbsSquare[0], 'bottom'+nurbsSquare[0], 'left'+nurbsSquare[0], ct1=1, ct2=1, ct3=1, ct4=1, po=0)
rotationpoint = cmds.pointOnSurface(nurbsSquareSurface[0], u=offset/(iteration+1), v=offset/(iteration+1), position=True)
locator = cmds.spaceLocator(p=rotationpoint)
cmds.parent(locator[0], nurbsSquareSurface[0], group)

### Project the squares on the x, y or/and z axis
if drawx == 1:
  squaresonx = cmds.curve(d=1, p=[(topposition[0], topposition[1], 0),(leftposition[0], leftposition[1], 0),(bottomposition[0], bottomposition[1], 0),(rightposition[0], rightposition[1], 0), (topposition[0], topposition[1], 0)] )
  cmds.parent(squaresonx, group)

if drawy == 1:
  squaresony = cmds.curve(d=1, p=[(topposition[0], 0, topposition[2]),(leftposition[0], 0, leftposition[2]),(bottomposition[0], 0, bottomposition[2]),(rightposition[0], 0, rightposition[2]), (topposition[0], 0, topposition[2])] )
  cmds.parent(squaresony, group)

if drawz == 1:
  squaresonz = cmds.curve(d=1, p=[(0, topposition[1], topposition[2]),(0, leftposition[1], leftposition[2]),(0, bottomposition[1], bottomposition[2]),(0, rightposition[1], rightposition[2]), (0, topposition[1], topposition[2])] )
  cmds.parent(squaresonz, group)

else:
  print "project nothing"

### Clean the Scene
cmds.parent(group, iterationgroup)

if delete3Dsquare == 1:
  cmds.delete(nurbsSquare[0])

if deletelocator == 1:
  cmds.delete(locator[0])

if deleteSquareSurface == 1:
  cmds.delete(nurbsSquareSurface[0])



### Iterate the function
if iteration == 0:
  j.append(1)
  return j

else:
  iteration -= 1
  recursivesquares(j,iteration, angle, offset, rotationpoint)


#############################
### CALL RECURSIVE SQUARE ###
#############################


for i in range (0, 5, 1):
recursivesquares(j,10,15,.9, [0,0,0])
iterations = len(j)+1
print iterations

Week 03 – code (part 2) - classes

2009-05-20T15:39:00.001+02:00

Classes are the workhorses of object-oriented programming languages (OOP) like Python. As we saw, everything in Python is an object. Strings, lists, functions and even modules are objects and, as objects, they all have attributes and functions (which in the case of objects are called methods) associated with them. Let’s take the example of a list:

myList = [1 ,3.4, 5, 66, 298] 
myList.append(243) 
myList.sort( )

In the above examples, append() and sort() are methods of the object list, and can be called by using the construction objectName.method(arguments).

Lists, integers, strings, etc, are built-in objects in Python. But you can create your own objects by using classes. Classes are object definitions created by the user, and work as a place to collect functions and attributes related to the object you want to create.

When you put functions and variables into a class, they have a way to “talk” to each other and keep information together. Here is an better explanation and example taken from a tutorial on the web:

For example, imagine you have a golf club. It has information about it (i.e. variables) like the length of the shaft, the material of the grip, and the material of the head. It also has functions associated with it, like the function of swinging your golf club, or the function of breaking it in pure frustration. For those functions, you need to know the variables of the shaft length, head material, etc. (…)
What happens if each time you use your golf club, the shaft gets weaker, the grip on the handle wears away a little, you get that little more frustrated, and a new scratch is formed on the head of the club? A function cannot [handle] that. A function only makes one output, not four or five, or five hundred. What is needed is a way to group functions and variables that are closely related into one place so that they can interact with each other.
Chances are that you also have more than one golf club. Without classes, you need to write a whole heap of code for each different golf club. This is a pain, seeing that all clubs share common features, it is just that some have changed properties - like what the shaft is made of, and it's weight. The ideal situation would be to have a design of your basic golf club. Each time you create a new club, simply specify its attributes - the length of its shaft, its weight, etc. (…)
These problems that a thing called object-oriented-programming solves. It puts functions and variables together in a way that they can see each other and work together, be replicated, and altered as needed, and not when unneeded. And we use a thing called a 'class' to do this.

To use classes, the same way when you create functions, you have first to define them (class definition), and then call them by creating instances of this class. Like what we did in class:

#### CLASSES
#defining a class
class Student: 
	#first define the class constructor
	#which is the function that is executed
	#every time you create an instance of this class
	def __init__(self, name, attendance):
		#in this function, we pass three arguments:
		#self should ALWAYS be passed as the first argument
		#in every function inside of a class definition
		#the following arguments are defined by you
		#depending on what you want to pass for the instance
		#when you are creating it
		self.name = name
		self.attendance = attendance
		self.marks = []
		#in the lines above we declare a series of variables
		#inhrent to the class, which will later work as 
		#attributes of each instance of the class you create
		#as use of the "self.nameOfVariable" syntax indicates
		numberOfAssignments = 0
		#above we created a local variable which will exist only
		#inside the class, and cannot be accessed as attributes
		#of the instances you create (note we don't use "self"
		print "New student was created"
		print "this student did", numberOfAssignments, " assignments"
		#the lines above are simple print statements which will
		#show when you create an instance of the class,
		#because they are located on the __init__ function
		
	#now we leave the __init__ function and we can than create 
	#as many internal functions as we want 
	#(which are called "methods" of this class
	#note that all of them MUST take as a first argument
	#the variable self, so that they always refer to the
	#instance itself
	
	def addMark(self, mark):
		#this is a simple function which
		#appends whatever value we pass as an argument
		#to the internal list "marks", which was
		#created in the __init__ function
		self.marks.append(mark)
		
	def addAttendance(self):
		#the same with this method, which doesn't take
		#any additional arguments, but still makes modifications
		#(by adding one unit) to the attendance attribute of the class
		self.attendance += 1

Now that we have our class define, we can create instances of it and call its attributes and functions easily:

## creating an instance of the class		
myStudent = Student("Liu", 10)
#as you see, we create instances of a class
#by simply assigning it to a variable and
#passing the necessary intial arguments
#required by the __init__ function
#Note that we don't ever need to pass "self" as an argument
#on the instance creation, as Python automatically
#does it internally

#now we can access the attribute of these functions, also
#defined on the __init__ function, by using a simple construction:
print myStudent.name
print myStudent.attendance

#Here lies one of the powers of classes: I can create 
#as many instances of that class as I need,
#and all of them inherit the methods and attributes of the class
myStudent2 = Student("Grisha", 20)
print myStudent2.name
print myStudent2.marks

#the same way as I accessed attributes aobve, I can
#call the class's methods:
myStudent2.addMark(10)
print myStudent2.marks

This was a short and small example of classes. You can do many powerful things with it as we will see next class. So keep in mind that the class definition works as a blueprint, from which as many instances as you want can be generated.

Week 03 – code (part 1)

2009-05-19T18:49:00.001+02:00

We started by creating a function which would create an object on stage by recursion:

import maya.cmds as cmds

def fakeRecursion( iterations ):
	for i in range(iterations): #range(0, iterations, 1)
		#create the objects
		cmds.circle(  n="myCircle_%d" % i )
		cmds.nurbsSquare( n="mySquare_%d" % i )
		#rotate objs
		cmds.rotate(i*10, i*10, i*10, "myCircle_%d"%i)
		cmds.rotate(-i*10,- i*10,- i*10, "mySquare_%d"%i)
		#move objs
		cmds.move(0,0,i/10, 	"myCircle_%d"%i)
		cmds.move(0,0,i/10, 	"mySquare_%d"%i)
		#collect points for polyFacet
		pos1 = cmds.pointPosition("topmySquare_%d.cv[0]" %i)
		pos2 = cmds.pointPosition("myCircle_%d.cv[0]" % i)
		pos3 = cmds.pointPosition("rightmySquare_%d.cv[0]" %i)
		pos4 = cmds.pointPosition("myCircle_%d.cv[1]" % i)
		pos5 = cmds.pointPosition("bottommySquare_%d.cv[0]" %i)
		pos6 = cmds.pointPosition("myCircle_%d.cv[2]" % i)
		pos7 = cmds.pointPosition("leftmySquare_%d.cv[0]" %i)
		pos8 = cmds.pointPosition("myCircle_%d.cv[3]" % i)
		
		cmds.polyCreateFacet(n="myFacet_%d" % i,
					p=[pos1, pos2, pos3, pos4, pos5, pos6, pos7, pos8]
					)
		cmds.group("myCircle_%d" % i,
						"mySquare_%d" % i,
						"myFacet_%d" % i )
						
fakeRecursion(30)

As we saw, the code above works, but has a series of coding problem which makes it non-flexible and difficult to read and modify. The first modification we did was to convert the recursion, which in this case was made by using a for loop, to what we could call “real” recursion, when the function calls itself:

def realRecursion( iterations ):
	i = iterations
	#create the objects
	cmds.circle(  n="myCircle_%d" % i )
	cmds.nurbsSquare( n="mySquare_%d" % i )
	#rotate objs
	cmds.rotate(i*10, i*10, i*10, "myCircle_%d"%i)
	cmds.rotate(-i*10,- i*10,- i*10, "mySquare_%d"%i)
	#move objs
	cmds.move(0,0,i/10, 	"myCircle_%d"%i)
	cmds.move(0,0,i/10, 	"mySquare_%d"%i)
	#collect points for polyFacet
	pos1 = cmds.pointPosition("topmySquare_%d.cv[0]" %i)
	pos2 = cmds.pointPosition("myCircle_%d.cv[0]" % i)
	pos3 = cmds.pointPosition("rightmySquare_%d.cv[0]" %i)
	pos4 = cmds.pointPosition("myCircle_%d.cv[1]" % i)
	pos5 = cmds.pointPosition("bottommySquare_%d.cv[0]" %i)
	pos6 = cmds.pointPosition("myCircle_%d.cv[2]" % i)
	pos7 = cmds.pointPosition("leftmySquare_%d.cv[0]" %i)
	pos8 = cmds.pointPosition("myCircle_%d.cv[3]" % i)
	
	cmds.polyCreateFacet(n="myFacet_%d" % i,
					p=[pos1, pos2, pos3, pos4, pos5, pos6, pos7, pos8]
					)
	cmds.group("myCircle_%d" % i,
						"mySquare_%d" % i,
						"myFacet_%d" % i )
						
	#recursion part
	if iterations == 0:
		return "Done."
	else:
		iterations -= 1
		realRecursion(iterations)
		
realRecursion( 30 )

As we see it keeps producing the same result as the function before. Also, in terms of speed and memory, the difference is not noticeable. But as we saw, when you start to use complex and long functions, the use of “real” recursion is regarded as much more efficient.

The second step on the optimization of the function was to remove all the hard-coded bits. This allows for greater flexibility, as we don’t really need to care about the names of the created objects, simply by using variables to store them and to refer to them later:

def realRecursionOpt1( iterations ):
	i = iterations
	#create the objects
	myCircle = cmds.circle( )
	mySquare = cmds.nurbsSquare( )
	#rotate objs
	cmds.rotate(i*10, i*10, i*10, myCircle )
	cmds.rotate(-i*10,- i*10,- i*10, mySquare)
	#move objs
	cmds.move(0,0,i/10, 	myCircle )
	cmds.move(0,0,i/10, 	mySquare )
	
	#collect points for polyFacet
	#select mySquare
	cmds.select( mySquare, r=1 ) 
	sides = cmds.filterExpand( sm=9 )
	pos1 = cmds.pointPosition( sides[0]+".cv[0]" )
	pos2 = cmds.pointPosition( myCircle[0] + ".cv[0]"  )
	pos3 = cmds.pointPosition( sides[1]+".cv[0]" )
	pos4 = cmds.pointPosition( myCircle[0] + ".cv[1]")
	pos5 = cmds.pointPosition( sides[2]+".cv[0]" )
	pos6 = cmds.pointPosition( myCircle[0] + ".cv[2]")
	pos7 = cmds.pointPosition( sides[3]+".cv[0]" )
	pos8 = cmds.pointPosition( myCircle[0] + ".cv[3]")
	
	myFacet = cmds.polyCreateFacet(
					p=[pos1, pos2, pos3, pos4, pos5, pos6, pos7, pos8]
					)
	cmds.group( myCircle, mySquare, myFacet  )
						
	#recursion part
	if iterations == 0:
		return "Done."
	else:
		iterations -= 1
		realRecursionOpt1(iterations)	
		
realRecursionOpt1( 30 )

As you can see, we do not have to know any names of objects if we store them in variables and use them to refer to them later.

As a last step on the optmization process, we saw how when you repeat a command too many times, it almost always means you can convert it into a loop. The same is valid for numbers or strings which are being repeated too many times: you should always recur to variables or arguments to define values which are used several times:

def realRecursionOpt2( iterations , amt=10  ):
	i = iterations
	#create the objects
	myCircle = cmds.circle( )
	mySquare = cmds.nurbsSquare( )
	#rotate objs
	cmds.rotate(i*amt, i*amt, i*amt, myCircle )
	cmds.rotate(-i*amt,- i*amt,- i*amt, mySquare)
	#move objs
	cmds.move(0,0,i/amt, 	myCircle )
	cmds.move(0,0,i/amt, 	mySquare )
	
	#collect points for polyFacet
	#select mySquare
	cmds.select( mySquare, r=1 ) 
	sides = cmds.filterExpand( sm=9 )
	
	#create a list to store the positions
	positions = []
	for i in range( len(sides)  ):
		pos1 = cmds.pointPosition( sides[i] +".cv[0]" )
		pos2 = cmds.pointPosition( myCircle[0] + ".cv[%d]" % i )
		positions.append(pos1)
		positions.append(pos2)
	
	
	myFacet = cmds.polyCreateFacet(
					p=positions
					)
	cmds.group( myCircle, mySquare, myFacet  )
						
	#recursion part
	if iterations == 0:
		return "Done."
	else:
		iterations -= 1
		realRecursionOpt2(iterations, iterations )	
		
realRecursionOpt2( 30 )

Another thing we saw on the example above is the creation and usage of optional function arguments, in this case, amt=10. In this case, as we already assign a value to amt in the function definition, it means that if you don’t pass this argument in the function call, Maya will assume its value as 10. In case you do supply an argument, Maya will use this value instead.

Week 03 – recap

2009-05-19T18:28:00.001+02:00

Yesterday in our third class we started by taking a look on how to optimize your code. In the example, we saw how to avoid common mistakes on scripting, such as hard-coding and repetition instead of loops. Also, we saw again how to convert a loop recursion into a “real” recursion.

In the end we had a initial and quick introduction to classes in Python, which will be our main topic next class. We will then start to look into voronoi diagrams, delaunay tessellations, and convex hulls.

Assignment 01B

2009-05-19T17:40:00.002+02:00


import maya.cmds as cmds
import math
import maya.mel as mm



def getDistance(start, end):
 #start and end must be lists xyz
 v = [start[0]-end[0], start[1]-end[1], start[2]-end[2]] #list format x,y,z
 vector = "<<" + str(v[0]) + "," + str(v[1]) + "," + str(v[2]) + ">>"
 mag = mm.eval("mag " + vector + ";")

 return mag


#########THIS IS THE NON_RECURSIVE PART ------ JUST SKIP#######################
'''
mySquare = cmds.nurbsSquare(sl1=10, sl2=15)

isSides = cmds.filterExpand (sm=9)

pos = []

for i in range (len(isSides)):
 posa = cmds.pointPosition(isSides[i]+".cv[0]")
 pos.append (posa)
 
 

diag = getDistance(pos[0],pos[2])
a = getDistance(pos[2],pos[3])
b = getDistance(pos[3],pos[0])

h = math.sqrt(a*a - ((a*diag)/(b+a)) * ((a*diag)/(b+a)))


mySquare2 = cmds.nurbsSquare(sl1=h, sl2=diag)
isSides2 = cmds.filterExpand (sm=9)
pos2 = []

for i in range (len(isSides2)):
 posb = cmds.pointPosition(isSides2[i]+".cv[0]")
 pos2.append (posb)

#get diference between actual location and move
dist = getDistance(pos[2],pos2[2])
p1 = pos[2]
p2 = pos2[2]
x=p2[0] - p1[0]
print x
y=p2[0] - p1[0]
cmds.move(x,-y,0,mySquare)



#get angle of rotation
sinF = getDistance(pos[0],pos[1])
alpha = math.asin(sinF/diag)
Ld= math.degrees (alpha)

cmds.rotate(0,0,Ld,mySquare2, pivot = pos2[2])
'''



#create initial rectangle
mySquare = cmds.nurbsSquare(sl1=a, sl2=b)


#define recursive function
def MyRecursive(iterations,a,b):
 
 isSides = cmds.filterExpand (sm=9)
 
 pos = []
 for i in range (len(isSides)):
  posa = cmds.pointPosition(isSides[i]+".cv[0]")
  pos.append (posa)
  
  
 #define length of diagonal in order to use it for next rectangle
 diag = getDistance(pos[0],pos[2])
 #define length of 2 sides to get height
 a = getDistance(pos[2],pos[3])
 b = getDistance(pos[3],pos[0])
 #get height of triangle (diagonal and the two sides)
 h = math.sqrt(a*a - ((a*diag)/(b+a)) * ((a*diag)/(b+a)))
 
 #create new rectangle with l2=diagonal length and l1= height of triangle
 mySquare2 = cmds.nurbsSquare(sl1=h, sl2=diag)
 isSides2 = cmds.filterExpand (sm=9)
 
 pos2 = []
 
 for i in range (len(isSides2)):
  posb = cmds.pointPosition(isSides2[i]+".cv[0]")
  pos2.append (posb)
 
 #get diference between actual location and move to future pivot point
 dist = getDistance(pos[2],pos2[2])
 p1 = pos[2]
 p2 = pos2[2]
 x=p2[0] - p1[0]
 y=p2[0] - p1[0]
 cmds.move(x,-y,0,mySquare)
 
 
 
 #get angle of rotation from diagonal
 sinF = getDistance(pos[0],pos[1])
 alpha = math.asin(sinF/diag)
 Ld= math.degrees (alpha)
 
 #rotate on diagonal
 cmds.rotate(0,0,Ld,mySquare2, pivot = pos2[2])
 
 #recursion part
 #if else conditions
 if iterations == 0:
  return "Done"
 else:
  iterations -= 1
  MyRecursive(iterations, a,b)
  
#call function
MyRecursive(10,10,15)

The problems i have are first of all that the height of the triangle i am calculating is not corresponding to the actual height.

Second would be that the recursion is not working as it should.

What it should do is first create a rectangle, create another one(with length=diagonal, and width=height of the triangle formed by diagonal and two sides). Rotate the last created rectangle on the diagonal, so that one of the sides "becomes" the diagonal. And then repeat everything for the next one.

Irina_Algorithm Sketches

2009-05-19T16:30:00.003+02:00

Alice_Assignment 01B script trial

2009-05-19T14:37:00.004+02:00


import maya.cmds as cmds

#create an initial square
initialSquare = cmds.nurbsSquare (sl1=10, sl2=10)
isSides = cmds.filterExpand(sm=9)

#create 3 random points inside the square** (I don't know how to find this random command)
ptA =
ptB =
ptC =

def pointBoundary(iterations)
 i=iterations
 
 #Create 3 curves
  lineA = cmds.curve(ep=(ptC,ptB),d=1)
  lineB = cmds.curve(ep=(ptA,ptC),d=1)
  lineC = cmds.curve(ep=(ptB,ptA),d=1)
 
 #Get the distance between 3 points
  lenA = cmds.distanceDimension(ptC,ptB)
  lenB = cmds.distanceDimension(ptA,ptC)
  lenC = cmds.distanceDimension(ptB,ptA)
 
 #Radius of the 3 circles:riA,riB,riC
  riA = (lenB + lenC - lenA)/2
  riB = (lenA + lenC - lenB)/2
  riC = (lenA + lenB - lenC)/2
 
 #Create 3 circles
  cirleA = cmds.circle(c=ptA,r=riA)
  cirleB = cmds.circle(c=ptB,r=riB)
  CirleC = cmds.circle(c=ptC,r=riC)
  
 #Tangent points among the 3 circles
  tanA = cmds.curveIntersect(lineA,circleB)
  tanB = cmds.curveIntersect(lineB,circleC)
  tanC = cmds.curveIntersect(lineC,circleA)
   
 #Offset lenA, lenB, lenC to a long distance and create new lines offA, offB, offC
 #(I am not sure if it offset to the right direction!!!)
 
  offA = cmds.offsetCurve(lenA,1000)
  offB = cmds.offsetCurve(lenB,1000)
  offC = cmds.offsetCurve(lenC,1000)
  
  nodeA = cmds.closestPointOnCurve(offA,tanA)
  nodeB = cmds.closestPointOnCurve(offB,tanB)
  nodeC = cmds.closestPointOnCurve(offC,tanC)
  
 #Draw perpendicular lines 
  perA = cmds.curve(ep=(tanA,nodeA), d=1)
  perB = cmds.curve(ep=(tanB,nodeB), d=1)
  perC = cmds.curve(ep=(tanC,nodeC), d=1)
  
 
 #Test if perpendicular lines intersect with which sides of the square
 #Get coordinates of the 3 intersection points on the square and 
 #replace the existing values of ptA, ptB, ptC
 
 for i in range(len(isSides)):
  isIntA = cmds.curveIntersect(perA,isSides[i])
  isIntB = cmds.curveIntersect(perB,isSides[i])
  isIntC = cmds.curveIntersect(perC,isSides[i])
  if isIntA != None:
   ptA = isIntA
  if isIntB != None:
   ptB = isIntB
  if isIntC != None:
   ptC =isIntC
   
 
 #Resize the initial Square
  cmds.rotate(0,0,30,initialSquare)
  cmds.scale(1.5,1.5,1,initialSquare)
 
 #Recursion
 if iterations ==0:
  return "Done"
 else:
  iterations -=1
 
def pointBoundary(10)

2009-05-18T19:22:00.000+02:00


 import maya.cmds as cmds
 x=10
 y=10
 #Make a Square
 initialSqare = cmds.nurbsSquare(sl1=x, sl2=y)
 #get outline
 isSides = cmds.filterExpand (sm=9)
 print isSides
 #make an empty list
 Squares = []
 Squares.append (1)

 def squareINsquare (number):
  #scale
  x=10/(1.5*len(Squares)+1)
 y=10/(1.5*len(Squares)+1)
 #loop 
 for j in range (0,len(Squares),1):
  cmds.select (Squares[j], r=True)
  #get outline
  isSides = cmds.filterExpand (sm=9)
  #looping in outline
  for i in range (0,2,1):
   perc1 = 0
   perc2 = 1
   line1=isSides[1]
   line2 = isSides[2]
   if i == 0:
    poc1 = cmds.pointOnCurve(line1, pr=perc1, top=True, p=True)
    print poc1
    #change the center of the new square 
    poc1[0]=poc1[0]-x/2
    poc1[1]=poc1[1]+y/2
    print poc1
    #make a new square
    initialSqare1 = cmds.nurbsSquare(c = poc1, sl1=x, sl2=y)
   #the same for the oposit corner of the squre 
   else:
    poc2 = cmds.pointOnCurve(line2, pr=perc2, top=True, p=True)
    print poc2
    poc2[0]=poc2[0]+x/2
    poc2[1]=poc2[1]-y/2
    print poc2
    initialSqare2 = cmds.nurbsSquare(c = poc2, sl1=x, sl2=y)
   
   Squares.append (initialSqare1)
   Squares.append (initialSqare2)
 Squares=Squares1
 Squares1=[]  
 if number == 0 :
  #stop
  return "Done."
 else:
  #did not finish yet
  #remove one unit (count down)
  number -= 1
 
  squareINsquare (number)

 squareINsquare (3)

Andreea Assignment01B

2009-05-18T12:35:00.000+02:00

Alice_Assignment 01B

2009-05-18T03:42:00.010+02:00

I started by writing a simple algorithm and tried to search for suitable commands in Maya to execute the task, according to my idea. But soon enough, I already feel like I don't know much commands -.-.....

Besides, to answer your comments for my last post, mathematically speaking, there should be only 1 possibility to draw 3 circles touching each of the others. Therefore, given any 3 points, there should be only 1 result.

I haven't get to the point to solve how to avoid concentrations result of the circles after many iterations. However, if it doesn't make the script much more complicated, I would like to try out if the square(the boundary) is rotated/extended according to a certain rule each time after making 3 new points and in a way to create an intricate network.... : )

Assignment 01B

2009-05-18T02:13:00.000+02:00

assignment 01b-1

2009-05-18T01:02:00.001+02:00

homework

2009-05-17T23:36:00.002+02:00

Assignment 01B

2009-05-17T22:49:00.004+02:00

Question:
How to find out the point which is tangent to the other circle in this case?

First Assignement ::: Relationship between 2D & 3D

2009-05-17T00:19:00.011+02:00

Recurcive square ($iteration=10, $angle=15, $offset=2)
Recurcive square ($iteration=10, $angle=15, $offset=2)

Recurcive square ($iteration=10, $angle=15, $offset=0.2)

Recurcive square ($iteration=15, $angle=33, $offset=0.2)
Recurcive square ($iteration=8, $angle=75, $offset=0.2)

import maya.cmds as cmds

cmds.select(all=True)
cmds.delete()


def recursivesquares(iteration, angle, offset):
rotationpoint = [0,0,0]
for i in range (0, iteration, 1):

cmds.nurbsSquare(n="nurbsSquare%d" %i, sl1=10, sl2=10, c=rotationpoint, nry=1, nrz=0)
cmds.select("topnurbsSquare%d" %i)

cmds.select("nurbsSquare%d" %i)
cmds.rotate(i*angle, i*angle, i*angle, pivot=(rotationpoint))

top = 'topnurbsSquare%d' %i
topposition = cmds.pointPosition('topnurbsSquare%d.cv[0]' %i, world=True)
left = 'leftnurbsSquare%d' %i
leftposition = cmds.pointPosition('leftnurbsSquare%d.cv[0]' %i, world=True)
bottom = 'bottomnurbsSquare%d' %i
bottomposition = cmds.pointPosition('bottomnurbsSquare%d.cv[0]' %i, world=True)
right = 'rightnurbsSquare%d' %i
rightposition = cmds.pointPosition('rightnurbsSquare%d.cv[0]' %i, world=True)

cmds.squareSurface(top, right, bottom, left, n='nurbsSurface%d'%i, ct1=1, ct2=1, ct3=1, ct4=1, po=0)
rotationpoint = cmds.pointOnSurface('nurbsSurface%d'%i, u=offset, v=offset, position=True)
cmds.spaceLocator(p=rotationpoint, n="locator%d" %i)
cmds.delete('nurbsSurface%d'%i)

cmds.delete('nurbsSquare%d' %i)
cmds.curve(n='topviewnurbsSquare%d' %i, d=1, p=[(topposition[0], topposition[1], 0),(leftposition[0], leftposition[1], 0),(bottomposition[0], bottomposition[1], 0),(rightposition[0], rightposition[1], 0), (topposition[0], topposition[1], 0)] )
cmds.curve(n='frontviewnurbsSquare%d' %i, d=1, p=[(topposition[0], 0, topposition[2]),(leftposition[0], 0, leftposition[2]),(bottomposition[0], 0, bottomposition[2]),(rightposition[0], 0, rightposition[2]), (topposition[0], 0, topposition[2])] )
cmds.curve(n='sideviewnurbsSquare%d' %i, d=1, p=[(0, topposition[1], topposition[2]),(0, leftposition[1], leftposition[2]),(0, bottomposition[1], bottomposition[2]),(0, rightposition[1], rightposition[2]), (0, topposition[1], topposition[2])] )

group = cmds.group('topviewnurbsSquare%d' %i, 'frontviewnurbsSquare%d' %i, 'sideviewnurbsSquare%d' %i, 'locator%d' %i, n='Squares%d' %i)

recursivesquares(10,15,0.9)

Assignment 01B

2009-05-14T15:02:00.001+02:00

Now it is time to start scripting your idea. Don’t worry about making it perfect, just start simple and small and go step-by-step. Simplification is the key. Here some guidelines:

Make your diagrams and logic (Assignment 01A) very clear. Divide the script into smaller tasks to check which tasks you know and which you don’t know how to perform
Define initial condition for your function to work. If it is very clear, you know that after you reach the initial condition again, you can run your function one more time. That’s where the recursion is.
Define a clear final condition
Make one iteration of your function work and only then make it recursive
If you reach a point where you can’t proceed, either look for help on the web, or post your progress on the blog, so I can make some comments

Please, post your progress by Sunday (17.05) morning on the blog, as I need time to take a look at it and prepare for the class on Monday, to be able to help you.

Don’t forget to post and updated diagram and logic if you changed it or developed further. We need to understand what you want to achieve!

If you manage the whole script by Sunday, great. If not, please make sure you tried really hard!

Assignment 01B – Help Functions

2009-05-14T14:52:00.001+02:00

For the completion of Assignment 01, I prepared some small help functions and procedures to help you out in the process of scripting. They are based on things I observed on most submissions. They are not intended to provide ready solutions, but to offer some hints. Therefore they might seem a bit random and out of context. Any help you need to use them, please post on the comments.

gsii_A01_helpFunctions.py

The serpentine() function

2009-05-14T14:19:00.003+02:00

We started the script by defining the main logic behind it, according to the diagrams posted last week.

# Basic logic
# 1) create an initial square (4 sides)
# 2) loop thorugh the sides:
#    2.1) get current line (line1)
#    2.2) get next line (line2)
#    2.3) define the percentages
#    2.4) find the point on curve
#    2.5) connect these points
# 3) After finished, select all 4 new lines and run again

As we see by this logic, what we need to run the loop each time is 4 curves through which we will loop and generate a new set of 4 lines. You can notice that as soon as we reach the initial condition, we can run the whole loop again (3): this is where recursion comes in handy.

#creating initial square
initialSquare = cmds.nurbsSquare( sl1=10, sl2=10 )
isSides = cmds.filterExpand(sm=9)
print isSides

This is how we start everything. With this command we have the 4 initial curve which make our connection loop work. Most important is that, by the way Maya created a nurbsSquare, all curves are selected in the right order on which they compose the square.

#lets connect line after line in a loop
for i in range(0, len(isSides), 1):
   print i
   #get the name of the current line
   line1 = isSides[i]
   #get the name of the following line
   #but first check if we are already on the last line
   #because then we have to pick back the first line
   if i == len(isSides)-1:
       #this means it is in the last element
       #so we have to get the first curve
       line2 = isSides[0]
   else:
       #otherwise, get next curve
       line2 = isSides[i+1]
      
   print line1, line2 #to check the line pair
   #define the percentages on which to connect the lines
   #this could be defined before the loop, because it is fixed
   #but in case we wanted to make it variable, we need to
   #define them here
   perc1 = 1./2
   perc2 = 1./3
   #get the coordinates on the lines on the percentages
   poc1 = cmds.pointOnCurve(  line1, pr=perc1, top=True, p=True  )
   poc2 = cmds.pointOnCurve(  line2, pr=perc2, top=True, p=True  )
   #create the curve to connect both lines
   cmds.curve(ep=(poc1, poc2), d=1)

This is the basic main loop we need. Having a set of four consecutive curves selected, it works by going through each one of them and connecting them with a straight line from certain points in each line (define by percentages). By the end of this loop, we have 4 new curves, which we can use to feed the next iteration of the function.

To convert this basic part into a recursive function, we just need some small adjustments. The most important is the if/else statement after the loop which checks for the final condition. This ensures us the loop will not be infinite, and that the function will call itself again in case the end condition is still not met, creating the recursive effect we need.

#turning this into a recursive function
def serpentine(iterations):
   #we assume that 4 lines are selected on stage
   #and that these lines are in correct order
   #this is the initial condition for the loop to work
   isSides = cmds.filterExpand(sm=9)
   #create a group to store the new lines
   #in the end all we need is to select the group
   #and we'll have the condition to run the function again
   group = cmds.group( n="newCurves", em=True )
   #loop through the curves in isSides
   for i in range(0, len(isSides),1):
      #get first curve name
      line1 = isSides[i]
      #get second curve name
      if i == len(isSides)-1:
         #this means it is in the last element
         #so I have to get the first
         line2 = isSides[0]
      else:
         #otherwise, get next element
         line2 = isSides[i+1]
      #print to check the pair 
      print line1, line2
      #define the percentages
      perc1 = 1./2
      perc2 = 1./3
      #get the coordinates on the lines
      poc1 = cmds.pointOnCurve( line1, pr=perc1, top=True, p=True )
      poc2 = cmds.pointOnCurve( line2, pr=perc2, top=True, p=True )      
      #create the curve
      crv = cmds.curve( ep=(poc1, poc2), d=1 )
      #put the curve in the group
      cmds.parent( crv, group )
  
   ## now the recursive part
   #check for the final condition
   if iterations == 0:
      #finished stop!
      return "Done."
   else:
      #did not finish yet...
      #remove one unit form iterations
      #(coutdown)
      iterations –= 1
      #select the group
      cmds.select( group, r=True )
      #call the function again
      serpentine( iterations )

Now, all you need is to create an initial square on stage, select it, and run the function, passing as a parameter the number of iterations you want it to perform.

Week 02 - recap

2009-05-14T13:30:00.001+02:00

Last Monday we translated the rules from the Serpentine Pavilion to a full working script. In it, you saw how to find points in a curve, how to turn an initial loop into a recursive function, and how to create workaround for the lack of full 2D drafting support in Maya.

Also, we reviewed your submissions for assignment 01A (all comments are on the blog, under each post).

As a continuation of the assignment, you should give the first go at scripting your idea, keeping in mind the comments made, and what you should improve. Some of you should post new diagrams showing the improved logic of your script, according to the comments.

Alice_Structure defined by Point + Boundary

2009-04-30T01:33:00.009+02:00

Concept

> My intention is to generate a complex pattern by given as few points as possible within a certain area. Later on, this pattern can be interpreted as building structure with a specific relationship or logic. In fact, I have tried out many different logical ways to generate points for iterations in order to set up a particular conditions between the point and its curvatures and hopefully to create a stable and balance structure. Above is only one of the attempts. However, I think it is not successful enough to achieve my goal. The difficulty is that the intersection of the curves is always too localized at a specific area. Modification should be made for clearer logic and waited to be explored 3-dimensionally.

p.s. Sorry for the belated post. but it's really hard to concentrate in front of the computer when you get to Barcelona!!!!! ;P

Relationship between 2D & 3D ::: alec' in direct from Barcelona ;-)

2009-04-27T00:43:00.006+02:00

Assignement 01A ::: Relationship between 3D and 2D.

The principle of this recursion is simple. It is a question of interpreting in 2D, a 3D operation! So, the forms do not change topologicaly), it's the point of view of each element which change!

In these examples, I used a simple rotation of every element, successively from 0, 15, 30, 45, 60, 75 and 90 ° on three axes of rotation, x, y and z! I also used a vertical movement for more visibility, but the plan remains unchanged.

Assignment 01 - Andreea

2009-04-27T00:32:00.002+02:00

Assignment 01

2009-04-26T21:35:00.002+02:00

assignment 01A

2009-04-26T16:52:00.000+02:00

Fibonacci number spiral

2009-04-26T15:01:00.002+02:00

Assignment 01

2009-04-26T13:51:00.002+02:00

Recursive subdivision

2009-04-25T20:53:00.003+02:00

Each first time the function divides a rectangle/square in 1/3 and each second time in 2/3

One of the possibilities could be to either extract according to this diagram parts from a cube or add parts to a surface.

Alexander & Tudor

Assignment 01A

2009-04-25T17:45:00.000+02:00

Calendar

2009-04-24T13:40:00.001+02:00

I created a Google Calendar for the course.

As you can see, for the next two Mondays we won't have any classes. But that will mean that when everybody is back we will have extra Scripting classes, at least in the first 1 or 2 weeks.

You can check the calendar on this blog's sidebar, or go to the calendar address to see it in its entirety.

Assignment 01A

2009-04-23T17:19:00.001+02:00

As discussed in last class, you are supposed to deliver a small set of diagrams (like the ones from the post below), showing an idea of a recursive algorithm using basic 2D geometric shapes (square, circle, triangle, straight line, pentagon etc).

You should define a simple rule and show in a diagram how the iteration of this rule is going to create complexity. Also, define initial state and final condition.

The results should be posted here on the blog by Saturday, 25.04, so that I can take a look at it on Sunday and choose some to further develop in class.

The goal of this first assignment is to create the basic graphical idea to be further explored and developed into a pavilion-like structure.

Recursion

2009-04-23T17:18:00.001+02:00

Our first topic this semester is recursion. Here are some randomly collected notes about recursion:

Recursion is a way of thinking about and solving problems
one of the central ideas of computer science
Solving a problem using recursion means that the solution depends on solutions to smaller instances of the same problem
Function called in itself
Loops (for, while) are a way of creating recursive functions without the advent of calling the function inside itself
A common method of simplification is to divide a problem into sub-problems of the same type. For example:
- How do you move a stack of 100 boxes?
- Answer: you move one box, remember where you put it, and then solve the smaller problem: how do you move a stack of 99 boxes?
- Eventually, you're left with the problem of how to move a single box
Here is another, perhaps simpler way to understand recursive processes:
- Are we done yet?
- If so, return the results. Without such a termination condition a recursion would go on forever.
- If not, simplify the problem, solve the simpler problem(s), and assemble the results into a solution for the original problem.
- Then return that solution

Source, among others: en.wikipedia.org/wiki/Recursion_(computer_science)

The concept of recursion can be easily observed in the case of the Serpentine Pavilion. You start with a simple rule of connecting the middle of one size of the square with the first third of the adjacent side:

So instead of following a 1/2 to 1/2 rule, which would create a simple square spiraling inside itself, the algorithm follow a 1/2 to 1/3 rule, which creates a spiraling square with intersects with itself. This slight change in the rule ends up increasing the complexity of the final result and creates more support points for the structure of the building.

The 1/2 to 1/3 rule is iterated only 7 times. By the dimensions of the pavilion (17x17m), this is enough to end up with efficient beam vs. holes sizes:

As the final step, all lines from all squares are extended. Then the borders are "folded" down to form the box, so that the pattern/structure continues until the floor.

The final result is beautiful, complex, and most important, extremely efficient structure-wise and construction-wise.

Week 1 - recap

2009-04-23T14:56:00.003+02:00

Last Monday we had our first class, where I introduced the first part of the course. In the next days, we'll be working on the concept of recursion, creating complexity out of very simple rules.

The basis for this idea can be found in the Serpentine Pavillion 2002, by Toyo Ito in collaboration with Cecil Balmond. As I showed in class, this impressive piece of architecture creates a whole new language of complexity and holistic design which parts from a simple recursive rule.

We also started to create some fairly simple recursive functions, as well as an approach to the recursive squares as used at the Serpentine Pavillion.

As a result of this first week, you are required to deliver a small assignment, as detailed in the next blog post.

Script editors

2009-04-20T02:15:00.001+02:00

Another list, this time with Script Editors. It is highly recommended that you use a script editor to write your scripts.

Resources

2009-04-20T02:13:00.001+02:00

Here is a list with several resources to aid you in the scripting learning process. Make good use of it!

Setting up

2009-04-20T02:11:00.001+02:00

As a first step, all students should perform the instructions contained in the setting up document from the former Dia Scripting wiki.

Click here to go to the document directly.

Generative Scripting II - SS09

2009-04-20T02:04:00.001+02:00

Today we start our Generative Scripting II course for the Summer Semester 09.

From the syllabus:

Starting with the premise that the student already has basic familiarity with scripting, this course will go one step further and look closely at the relationship of scripting and architecture.

As in the course Generative Scripting I, it will be divided in parts. In each part, we will start with the analysis of one contemporary existing building which experiments with geometric algorithms
to structure and organize its space. By studying, understanding and extracting the basic principles of these algorithms, we will develop our own variants.

Each group of two students will be required to deliver a small assignment by the end of
each part. The sum of these assignments will compose the final course grade.

The classes will take place every Monday 14:30, at the Marmorsaal in Building 01.