Generative Scripting I

03B Cosmos Bedzra

2009-07-23T11:14:00.003+02:00

############################################################
#EXTRUDING FACE ACCORDING TO A LOCATOR.
############################################################

import maya.cmds as cmds
import math
import random

def magnitude(v):
 x=v[0]
 y=v[1]
 z=v[2]
 m=math.sqrt ((x*x)+(y*y)+(z*z))
 return m

def distance (p1, p2):
 x1=p1[0]
 y1=p1[0]
 z1=p1[1]
 x1=p1[2]
 x2=p1[0]
 y2=p1[1]
 z2=p1[2]
 x= x1-x2
 y= y1-y2
 z= z1-z2
 m= magnitude([x, y, z])
 return m

def ExtrudeToLocator():
 "Extrude based on a distance of a certain Locator"

 selPoly= cmds.filterExpand(sm=12)
 selLoc= cmds.filterExpand(sm=22)
 selPoly= selPoly[0]

 allFaces= cmds.ls(selPoly + ".f[:]", fl=1)

 for face in allFaces:
     vertex= cmds.polyListComponentConversion (face, fromFace=1, toVertex=1)
     vertex= cmds.ls (vertex, fl=1)
     xs= 0
     ys= 0
     zs= 0

     for v in vertex:
         pos= cmds.pointPosition(v)
         x= pos[0]
         y= pos[1]
         z= pos[2]
         xs= xs + x
         ys= ys + y
         zs= zs + z
     centerX= xs/len(vertex)
     centerY= ys/len(vertex)
     centerZ= zs/len(vertex)

     cmds.spaceLocator(p=(centerX, centerY, centerZ))

     posLoc= cmds.pointPosition(selLoc)
     d= distance([centerX, centerY, centerZ], posLoc)
     print d
     #extrude based on distance
     cmds.polyExtrudeFacet(face, ltz=d/1)

#extruding to locator
ExtrudeToLocator()

assignment04__Zhu lei & Qin zhen

2009-07-23T10:57:00.000+02:00

####### Ex04A #######
# a) Create a curve from points
# b) create several curves
# c) loft the curves to create a Nurbs Surface
# d) Convert the Nurbs Surface to a Polygonal Surface
# e) Modify the vertices of the Polygonal Surface randomly
# f) finish
#################################

import maya.cmds as cmds
from math import*
import random

# a) Create a curve from points
# define Curve
def Curve(numPoints):
# define initial variables
numPoints= 20
# create an empty list to store the points
Points= []
#loop and gather point information
for i in range (0, numPoints,1):
# function of the conical helix to generate a curve
x= sin(30*i)*4
y= cos(sin(60*i)*4)*4
z= i+3
myPoint= (x,y,z)
# store the points in the list
Points.append(myPoint)
#create the curve
Curve= cmds.curve(d=3, p=Points) #curve of degree 3
return Curve

MyCurve= Curve(60)

#hide the Curve
cmds.hide(MyCurve)

# b) create several curves
# create an empty list to store the curves
myCurves=[]
# define variables
numCrvs= 6
offset= 4
# create a loop
for e in range (0, numCrvs,1):
crv= Curve(e)
offset= offset*1.2
#store the curve in the list
myCurves.append(crv)
#move the curves with an offset in the "z" axis
cmds.move(0,0,offset,crv)

# c) Loft the curves to create a Nurbs surface
myNurbsSurface= cmds.loft(myCurves, n="myNurbsSurf")

#hide the curves
cmds.hide(myCurves)

# d) convert the Nurbs Surface to Polygonal Surface
# get the Nurbs surface
myNurbsSurface= cmds.filterExpand(sm=10)

# convert
myPolySurface=cmds.nurbsToPoly("myNurbsSurf",pt=1, n="myPolySurf")

#hide the Nurbs Surface
cmds.hide("myNurbsSurf")

# e) Move the vertices of the Polygonal surface randomly
# get all the vertices of myPolySurface
allCvs= cmds.ls("myPolySurf.vtx[:][:]", fl=1)

# Move the vertices in PolySurface randomly
def moveVertiRandomly(allCvs, minimum, maximum):
if minimum>= maximum:
print "poly"
# start a loop through all vertices in "x" and "y" axes
else:
for i in allCvs:
x= random.uniform(minimum, maximum)*e
y= random.uniform(minimum, maximum)*e
z= 0
cmds.move (x,y,z,i,r=True)
# move vertices randomly
moveVertiRandomly (allCvs, 0, .6)

# f) finish!

Assigment 04 - Valentina De Leon

2009-07-23T01:25:00.000+02:00

import maya.cmds as cmds
from math import*
from random import*

#create a locator in random position
x = uniform (5,40)
selLoc = cmds.spaceLocator( p=(x,x,9*x) )
#create a curve
def curves (amplitude):

#def initial variables
numPoints= 9

#create an empty list to store the points
points=[]

#loop and gather information
for i in range (1,numPoints,1):

#function of the spiral curve:
x=cos(i)*i
y=sin(i)*amplitude
z= i
myPoint= (x,y,z)

#store the points in the list
points.append(myPoint)
myCurve=cmds.curve(d=5, p=points)
return myCurve

#create an empty list to store the curves
myCurve=[]

#define number of curves
numCurves=3

#function to call the curves in a loop
for i in range(0,numCurves,1):
crv= curves (i)

#store the curve in the list
myCurve.append (crv)
print crv

#move the curves
cmds.move (15,3,30, crv)

#loft the curves
LoftSrf = cmds.loft(myCurve)

### Move Surface ###

# A) get all the vertices of the Surfaces
allCvs= cmds.ls("loftedSurface1.cv[:][:]", fl=1)
cmds.select (LoftSrf, r = True)

# B) define move cvs in surface randomly
def moveVertiRandomly(allCvs, minimum, maximum):
if minimum>= maximum:
print "hello!"
# B.1) start a loop through all cvs in z axis
else:
for i in allCvs:
x= 0
y= 0
z= uniform (minimum, maximum)
cmds.move (x,y,z,i,r=True)
# C) move cvs randomly
moveVertiRandomly (allCvs, 0, 20)

### Move Cvs of Surface according to Locator direction ###

#define coordinates between locator and CV in order to move CV
def distance1 (posPoint, posLoc, constantMin, constantMax):
#subtract both vectores
x1= posPoint[0]
y1= posPoint[1]
z1= posPoint[2]
x2= posLoc[0]
y2= posLoc[1]
z2= posLoc[2]
constant = uniform (constantMin, constantMax)
x= x1 + ((x2 - x1)/constant)
y= y1 + ((y2 - y1)/constant)
z= z1 + ((z2 - z1)/constant)
m= [x,y,z]
return m

#define moveToLocator function
def moveToLocator(selLoc):
#loop through cvs
for i in allCvs:
# refresh
cmds.refresh ()
posPoint= cmds.pointPosition(i)
posLoc= cmds.pointPosition (selLoc)
# randomly moving CVs towards the locator
d= distance1(posPoint, posLoc, 5,3)
cmds.move (d[0],d[1],d[2],i)

#call the function
moveToLocator(selLoc)

### Move Curves ###

# A) get all the cvsNames of a curve
crvCvs = cmds.ls("curve1.cv[:]", fl=1)

# B) define move cvs randomly
def moveVertRandomly (allCvs, minimum, maximum):
if minimum>= maximum:
print "hello!"
# B.1) start a loop through all cvs
else:
for cv in allCvs:
rx = uniform(minimum, maximum)
ry = uniform(minimum, maximum)
rz = uniform(minimum, maximum)
cmds.move (rx,ry,rz,cv,r=5)
# refresh
cmds.refresh ()
cmds.pause (sec=1)
# C) move cvs randomly
moveVertRandomly (crvCvs, 0, 20)

### Move Curve 5 according to Locator direction ####

def moveCrvFive (selLoc):
fiveCvs = cmds.ls("curve5.cv[:]", fl=1)
for j in fiveCvs:
posPoint= cmds.pointPosition(j)
posLoc= cmds.pointPosition (selLoc)
# randomly moving CVs towards the locator
d= distance1(posPoint, posLoc, 3,2)
cmds.move (d[0],d[1],d[2],j)
# refresh
cmds.refresh ()
cmds.pause (sec=1)

moveCrvFive (selLoc)

03--B Zhulei

2009-07-23T00:32:00.001+02:00

#######################
## Ex03B_Move Cvs of a Nurbs according to Locator direction
#######################

import maya.cmds as cmds
import math
import random

#define distance between PolFaces and locator
def magnitude (v):
#v is a list of x,y,z values
x= v[0]
y= v[1]
z= v[2]
m= math.sqrt ( (x*x) + (y*y) + (z*z) )
return m

def distance (posVert, posLoc):
#subtract both vectors
x1= posVert[0]
y1= posVert[1]
z1= posVert[2]
x2= posLoc[0]
y2= posLoc[1]
z2= posLoc[2]
x= x1 - x2
y= y1 - y2
z= z1 - z2
m= magnitude ([x,y,z])
return m

#define moveToLocator function
def moveToLocator():
# A) get all the verticesNames of a plane
allVertices= cmds.ls ("pSphere1.vtx[:]", fl=1)

#create an empty list to store the points
MyVerts=[]

#get selected Locator
selLoc= cmds.filterExpand(sm=22)

#loop through vertices
for v in allVertices:
pos= cmds.pointPosition(v)
x= pos[0]
y= pos[1]
z= pos[2]

#find distance to Locator
posVert= cmds.pointPosition(v)
posLoc= cmds.pointPosition(selLoc)
d= distance(posVert, posLoc)
print d
x= random.uniform(0, .5)
y= random.uniform(0,.5)
cmds.move (d*x,d*y,0,v,r=True)

#store the cvs in a list
MyVerts.append(allVertices)

#call the function
moveToLocator()

03-A Zhulei

2009-07-23T00:30:00.002+02:00

import maya.cmds as cmds
import random
import math

def moveVertRandomly (allCvs, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allCvs:
rx = random.uniform(1, 19)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)
cmds.move (rx,ry,rz,i,r=8)

def moveVerticeRandomly (allCvs, minimum, maximum, x,y,z):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allCvs:

z = random.uniform(minimum, maximum)
cmds.move (x,y,z,i,r=12)

def extrudeFacesRandomly(allFaces, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allFaces:
rz = random.uniform(minimum, maximum)
cmds.polyExtrudeFacet(i, ltz = rz)

def polygonVertices (allVert, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allVert:
rx = random.uniform(minimum, maximum)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)
cmds.move (rx,ry,rz,i,r=7)

allCvs = cmds.ls("curve1.cv[:]", fl=5)
moveVertRandomly (allCvs, -1, 20)

allCvs1 = cmds.ls("nurbsPlane1.cv[:][:]", fl=5)
moveVerticeRandomly (allCvs, 1, 2,3,4,5)
allFaces = cmds.ls ("pPlane1.f[:]", fl = 5)

extrudeFacesRandomly(allFaces, 0, 6)
allVert = cmds.ls("pPlane2.vtx[:]", fl=5)
polygonVertices (allVert, 0, 20)

02-B Zhulei

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

import maya.cmds as cmds
from random import*
from math import*

#REVOLVING A CURVE TO FORM A SURFACE
def revolve(numPoints,myAxis,myEndSweep):
"revolve a curve"
myPoints=[]
for i in range(numPoints):
x=uniform(0,15)
y=i*3
z=cos(sin(5*i))*i
myPoints.append([x,y,z])
crv=cmds.curve(ep=myPoints,d=3)
cmds.revolve(crv,axis=myAxis,endSweep=myEndSweep)
revolve(20,[1,0,1],360)

02-A Zhulei

2009-07-23T00:23:00.003+02:00

import maya.cmds as cmds
from math import*
from random import*

#from curves to surfaces
#step 1, create a curve
def curves (amplitude):
#def initial variables
numPoints=80
#create an empty list to store the points
points=[]
#loop and gather information
for i in range (1,numPoints,1):
#function of the spiral curve:
x=sin(i*3)
y=cos(cos(i)*2+1)
z=i
myPoint=(x,y,z)
#store the points in the list
points.append(myPoint)
myCurve=cmds.curve(d=60, p=points)

#create an empty list to store the curves
myCurve=[]
#define the number of curves
numCurves=10
#function to call the curves in a loop
for i in range(0,numCurves,2):
crv=curves(i)
#store the curve in the list
myCurve.append (crv)
print crv
#move the curves
cmds.move(2,11,4, crv)
#loft the curves
cmds.loft(myCurve)

qinzhen_3b

2009-07-23T00:00:00.003+02:00

Assiment_03B_DengLei

2009-07-22T22:56:00.000+02:00

04 Cosmos Bedzra

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

import maya.cmds as cmds
import random
import math


#revolve a curve to form a surface
def revolve(numPoints,myAxis,myEndSweep):
  "revolve 12a curve"
  myPoints=[]
  for i in range(numPoints):
      x=uniform(0,20)
      y=10
      z=i*5
      myPoints.append([x,y,z])
  crv=cmds.curve(ep=myPoints,d=3)
  cmds.revolve(crv,axis=myAxis,endSweep=myEndSweep)
revolve(10,[0,0,1],180)


#get all the Cvs of the revolved surface
allCvs= cmds.ls("revolvedSurface8.cv[:][:]", fl=1)

#define move cvs in nurbsPlane randomly
def moveVertiRandomly(allCvs, minimum, maximum,x,y,z):
  if minimum>= maximum:
      print "hello!"
  #start a loop through all cvs in x axis
  else:
      for i in allCvs:
          x= random.uniform(minimum, maximum)
          y=0
          z=0
          cmds.move (x,y,z,i,r=True)
#move Cvs randomly
moveVertiRandomly (allCvs, 2, 18, 0,0,7)

03A Cosmos Bedzra

2009-07-22T18:02:00.002+02:00

import maya.cmds as cmds
import random
import math

##################################################
#Curve CVs
##################################################
# getting all CVs of the curve
allCvs = cmds.ls("curve1.cv[:]", fl=1)

# randomly moving CVs
def moveVertRandomly (allCvs, minimum, maximum):
  if minimum>= maximum:
      print "Dessau!"
  # start a loop through all cvs
  else:
      for cv in allCvs:
          rx = random.uniform(minimum, maximum)
          ry = random.uniform(minimum, maximum)
          rz = random.uniform(minimum, maximum)
          cmds.move (rx,ry,rz,cv,r=2)

moveVertRandomly (allCvs, -5, 5)

##################################################
# Nurbs Surfaces CVs
##################################################
# getting vertices of the Nurbs surface
allCvs= cmds.ls("nurbsPlane1.cv[:][:]", fl=1)

# randomly moving Cvs of the Nurbs surface
def moveVertiRandomly(allCvs, minimum, maximum,x,y,z):
  if minimum>= maximum:
      print "Dessau!"
  # start a loop through all cvs in z axis
  else:
      for i in allCvs:
          x= 0
          y= 0  
          z= random.uniform(minimum, maximum)
          cmds.move (x,y,z,i,r=True)

moveVertiRandomly (allCvs, -1, 3, 0,0,1)

##################################################
# Faces of a polygon
##################################################
# getting all faces of Polygon
allFaces= cmds.ls ("pSolid1.f[:]", fl=1)

# extruding faces of the polygon
def ExtrudeFacesRandom (allFaces, minimum, maximum):
  if minimum>= maximum:
      print "Dessau"
  # start a loop through all faces in y axis
  else:
      for face in allFaces:
          ry= random.uniform(minimum, maximum)
          cmds.polyExtrudeFacet(face, ltz=ry)

ExtrudeFacesRandom(allFaces, 0,2)

##################################################
# Polygon Vertices
##################################################
# getting all vertices of a Polygon
allVertices= cmds.ls ("pPlane1.vtx[:]", fl=1)

# randomly moving Polygon Vertices
def movePolVert (allVertices, minimum, maximum):
  if minimum>= maximum:
      print "Dessau"
  # start a loop through vertices in z axis
  else:
      for e in allVertices:
          rx= random.uniform (minimum, maximum)
          ry= random.uniform (minimum, maximum)
          rz= random.uniform (minimum, maximum)
          cmds.move (rx,ry,rz,e,r=True)

movePolVert(allVertices,-1,1)

qinzhen_3a

2009-07-22T15:29:00.002+02:00

qinzhen assignment2b

2009-07-22T14:54:00.002+02:00

04 - Deborah Kaiser - images

2009-07-22T10:56:00.003+02:00

04 - Deborah Kaiser

2009-07-22T10:45:00.000+02:00

import maya.cmds as cmds
from math import*
from random import*

#create a locator in random position
x = uniform (10,30)
selLoc = cmds.spaceLocator( p=(x,x,2*x) )
#create a curve
def curves (amplitude):

#def initial variables
numPoints= 35

#create an empty list to store the points
points=[]

#loop and gather information
for i in range (1,numPoints,1):

#function of the spiral curve:
x=cos(i)*i
y=sin(i)*amplitude
z= i
myPoint= (x,y,z)

#store the points in the list
points.append(myPoint)
myCurve=cmds.curve(d=3, p=points)
return myCurve

#create an empty list to store the curves
myCurve=[]

#define number of curves
numCurves=5

#function to call the curves in a loop
for i in range(0,numCurves,1):
crv= curves (i)

#store the curve in the list
myCurve.append (crv)
print crv

#move the curves
cmds.move (10,5,5, crv)

#loft the curves
LoftSrf = cmds.loft(myCurve)

### Move Surface ###

# A) get all the vertices of the Surfaces
allCvs= cmds.ls("loftedSurface1.cv[:][:]", fl=1)
cmds.select (LoftSrf, r = True)

# B) define move cvs in surface randomly
def moveVertiRandomly(allCvs, minimum, maximum):
if minimum>= maximum:
print "hello!"
# B.1) start a loop through all cvs in z axis
else:
for i in allCvs:
x= 0
y= 0
z= uniform (minimum, maximum)
cmds.move (x,y,z,i,r=True)
# C) move cvs randomly
moveVertiRandomly (allCvs, 0, 10)

### Move Cvs of Surface according to Locator direction ###

#define coordinates between locator and CV in order to move CV
def distance1 (posPoint, posLoc, constantMin, constantMax):
#subtract both vectores
x1= posPoint[0]
y1= posPoint[1]
z1= posPoint[2]
x2= posLoc[0]
y2= posLoc[1]
z2= posLoc[2]
constant = uniform (constantMin, constantMax)
x= x1 + ((x2 - x1)/constant)
y= y1 + ((y2 - y1)/constant)
z= z1 + ((z2 - z1)/constant)
m= [x,y,z]
return m

#define moveToLocator function
def moveToLocator(selLoc):
#loop through cvs
for i in allCvs:
# refresh
cmds.refresh ()
posPoint= cmds.pointPosition(i)
posLoc= cmds.pointPosition (selLoc)
# randomly moving CVs towards the locator
d= distance1(posPoint, posLoc, 2,5)
cmds.move (d[0],d[1],d[2],i)

#call the function
moveToLocator(selLoc)

### Move Curves ###

# A) get all the cvsNames of a curve
crvCvs = cmds.ls("curve1.cv[:]", fl=1)

# B) define move cvs randomly
def moveVertRandomly (allCvs, minimum, maximum):
if minimum>= maximum:
print "hello!"
# B.1) start a loop through all cvs
else:
for cv in allCvs:
rx = uniform(minimum, maximum)
ry = uniform(minimum, maximum)
rz = uniform(minimum, maximum)
cmds.move (rx,ry,rz,cv,r=2)
# refresh
cmds.refresh ()
cmds.pause (sec=1)
# C) move cvs randomly
moveVertRandomly (crvCvs, 0, 17)

### Move Curve 5 according to Locator direction ####

def moveCrvFive (selLoc):
fiveCvs = cmds.ls("curve5.cv[:]", fl=1)
for j in fiveCvs:
posPoint= cmds.pointPosition(j)
posLoc= cmds.pointPosition (selLoc)
# randomly moving CVs towards the locator
d= distance1(posPoint, posLoc, 2,2)
cmds.move (d[0],d[1],d[2],j)
# refresh
cmds.refresh ()
cmds.pause (sec=1)

moveCrvFive (selLoc)

03-A Anthony Adelmann Confusion

2009-07-22T03:21:00.002+02:00

I have some trouble getting this script to work, a lot of weird spacing errors popped up.

#assignment 3A
import maya.cmds as cmds
import random
import math
def moveVertRandomly (allCvs, minimum, maximum):
if minimum>=maximum:
print "Find new variables"
else:
for i in allCvs:
rx = random.uniform(minimum, maximum)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)

def moveVerticeRandomly (allCvs, minimum, maximum, x,y,z):
if minimum>= maximum:
print "Find new variables"
else:
for i in allCvs:
z = random.uniform(minimum, maximum)
cmds.move (x,y,z,i, r=3)
def extrudeFacesRandomly (allFaces, minimum, maximum):
if minimum>= maximum:
print "Find new variables"
else:
for i in allFaces:
rz = random.uniform(minimum, maximum)
cmds.polyExtrudeFacet (i, ltz = rz)
def polygonVertices (allVert, minimum, maximum):
if minimum>= maximum:
print "Find new variables"
else:
for i in allVert:
rz = random.uniform(minimum, maximum)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)
cmds.move (rx, ry, rz, i, r=2)
allCvs = cmds.ls("curve1.cv[:]", fl=4)
moveVertRandomly (allCvs, 11, 17)
allCvs1 = cmds.ls("nurbsPlane1.cv[:][:]", fl=1)
moveVerticeRandomly (allCvs, 5, 11, 7, 7, 12)
allFaces = cmds.ls ("pPlanel.f[:]", fl = 7)
extrudeFacesRandomly(allFaces, 7, 17)
allVert = cmds.ls("pPlane2.vtx[:]", fl=8)
polygonVertices (allVert, 6, 12)

Claudia_Ex04B_Nurbs Surfaces

2009-07-22T01:23:00.007+02:00

########## EX04B ###########
# 1) Create a curve from points
# 2) Tubulize the curve
# 3) Create 3 more tubes displaced in a radial way
# 4) Move the Cvs of each tube
#     according to a locator distance
# 5) Populate each tube with cylinders
# 6) finish!

###########################
import maya.cmds as cmds
from math import*
from random import*

# 1) Create a list of points to generate a curve
# define initial variables
numPoints= 15
# create an empty list to store the points
myPoints= []

# def Curve
def Curve(amplitude):
    #loop and gather point information
    for i in range (0, numPoints, 1):
        # function of the helix to generate a curve
        x= cos(7*i)
        y= sin(7*i)
        z= i*amplitude
        myPoint= (x,y,z)
        # store the points in the list
        myPoints.append(myPoint)
    #create the curve
    Curve= cmds.curve(d=3, p=myPoints, n="myCurve") #curve of degree 3

#call function
myCurve=Curve(5)

# 2) Create a tube
# first select the curve
myCurve= cmds.filterExpand(sm=9)

# define the function
def tubulize(path,radius,tubeSections):
    # function to create tubes out of a curve
    #position on end of the curve where I will put the circle profile
    pos= cmds.pointOnCurve(path, position=1, pr=0.001, top=1)
    #get tangent of this point
    tan= cmds.pointOnCurve(path,tangent=1,pr=0.001,top=1)
    #create the profile circle
    profile=cmds.circle(c=pos,r=radius,normal=tan,s=tubeSections,ch=1, n="circle")
    #center the circle pivot
    cmds.xform(cp=1)
    
    #extrude the circle along the path
    tube=cmds.extrude(profile[0], path, ucp=1, upn=1, et=2, rb=1, dl=3, ch=1,n="spiralTube")

# call function
myTube=tubulize(myCurve,6,10)

# 3) duplicate tubes rotating them according to a Locator
# create a locator
pivot= (-12,15,0)
myPoint= cmds.spaceLocator( p=pivot, n="myPoint")

# create a list to store the tubes
myTubes=[]
# select the tube to copy
selObjects=cmds.select("spiralTube")

# define variables
numTubes=3
rot = 0
# duplicate the tubes
for e in range (0,numTubes,1):
    rot=rot+70
    mynewTubes= cmds.duplicate("spiralTube", n="myNewTubes_%s" %e)
    cmds.rotate(0,0,rot, "myNewTubes_%s" %e, p=pivot)
    myTubes.append("myNewTubes_%s" %e)

#4) Move the vertices of each tube according
#   a locator distance
# 4.1) For the Spiral Tube
#define distance between cvs and locator
def magnitude (v):
    #v is a list of x,y,z values
    x= v[0]
    y= v[1]
    z= v[2]
    m= math.sqrt( (x*x) + (y*y) + (z*z) )
    return m
    
def distance (posPoint,pivot):
    #subtract both vectors
    x1= posPoint[0]
    y1= posPoint[1]
    z1= posPoint[2]
    x2= pivot[0]
    y2= pivot[1]
    z2= pivot[2]
    x= x1 - x2
    y= y1 - y2
    z= z1 - z2
    m= magnitude ([x,y,z])
    return m

#define moveToLocator function
def moveToLocator():
    # A) get all the cvsNames of myTubes
    spiralTubeCvs = cmds.ls("spiralTube.cv[:]", fl=1)
    
    #create an empty list to store the points
    mySpiralCvs=[]
        
    #get selected Locator
    #myPoint= cmds.filterExpand(sm=22)
    myPointPos= cmds.ls("myPoint", fl=1)
    
    #loop through cvs
    for i in spiralTubeCvs:
        posPoint= cmds.pointPosition(i)
        posPivot= cmds.pointPosition(myPoint)
        d= distance(posPoint, pivot)
        cmds.move (d,d,d,i,r=True)
        
        #store the cvs in a list
        mySpiralCvs.append(spiralTubeCvs)

#call the function
moveToLocator()

#####################3
# 4.2) For myNewTubes_0

#define moveToLocator function
def moveToLocator():
    # A) get all the cvsNames of myTubes
    newTubeCvs = cmds.ls("myNewTubes_0.cv[:]", fl=1)
    
    #create an empty list to store the points
    myNewTubeCvs=[]
        
    #get selected Locator
    #myPoint= cmds.filterExpand(sm=22)
    myPointPos= cmds.ls("myPoint", fl=1)
    
    #loop through cvs
    for i in newTubeCvs:
        posPoint= cmds.pointPosition(i)
        posPivot= cmds.pointPosition(myPoint)
        d= distance(posPoint, pivot)
        cmds.move (d,d,d,i,r=True)
        
        #store the cvs in a list
        myNewTubeCvs.append(newTubeCvs)

#call the function
moveToLocator()

###################
#4.3) For myNewTubes_1
#define moveToLocator function
def moveToLocator():
    # A) get all the cvsNames of myTubes
    newTube1Cvs = cmds.ls("myNewTubes_1.cv[:]", fl=1)
    
    #create an empty list to store the points
    myNewTube1Cvs=[]
        
    #get selected Locator
    #myPoint= cmds.filterExpand(sm=22)
    myPointPos= cmds.ls("myPoint", fl=1)
    
    #loop through cvs
    for i in newTube1Cvs:
        posPoint= cmds.pointPosition(i)
        posPivot= cmds.pointPosition(myPoint)
        d= distance(posPoint, pivot)
        cmds.move (d,d,d,i,r=True)
        
        #store the cvs in a list
        myNewTube1Cvs.append(newTube1Cvs)

#call the function
moveToLocator()

###################
#4.3) For myNewTubes_2

#define moveToLocator function
def moveToLocator():
    # A) get all the cvsNames of myTubes
    newTube2Cvs = cmds.ls("myNewTubes_2.cv[:]", fl=1)
    
    #create an empty list to store the points
    myNewTube2Cvs=[]
        
    #get selected Locator
    #myPoint= cmds.filterExpand(sm=22)
    myPointPos= cmds.ls("myPoint", fl=1)
    
    #loop through cvs
    for i in newTube2Cvs:
        posPoint= cmds.pointPosition(i)
        posPivot= cmds.pointPosition(myPoint)
        d= distance(posPoint, pivot)
        print d
        cmds.move (d,d,d,i,r=True)
        
        #store the cvs in a list
        myNewTube2Cvs.append(newTube2Cvs)

#call the function
moveToLocator()

###############################
# 5) Populate each Tube with cylinders
def cylindersOnSurface(numU, numV):
        
    #5.1)Select objects on stage
    SelTubes= cmds.select("spiralTube", "myNewTubes_0", "myNewTubes_1", "myNewTubes_2")
    #5.2) get selected objects
    tubs= cmds.filterExpand(sm=10)
    #5.3) create cylinders on the surface
    for srf in tubs:
        # first find the maximum number in U and V
        U= cmds.getAttr(srf + ".minMaxRangeU")
        V= cmds.getAttr(srf + ".minMaxRangeV")
        U=U[0]
        V=V[0]
        rangeU= U[1]-U[0]
        stepU= rangeU/numU
        rangeV= V[1]-V[0]
        stepV= rangeV/numV
        
        #loop in U direction
        for i in range (numU):
            u = i*stepU
            #loop in V direction
            for j in range (numV):
                v= j*stepV
                coord= cmds.pointOnSurface(srf, p=1, u=u, v=v)
                cmds.spaceLocator(p=coord)
                normal = cmds.pointOnSurface(srf, u=u, v=v, normalizedNormal=1)
                #create cilinders perpendicular to the normal of the tube
                cmds.cylinder(p=coord, ax=normal, radius=4) 
### call the function
cylindersOnSurface(10,10)

# erase the cilinder profile, the initial curve and the locator
cmds.delete("myCurve", "myPoint", "circle")
# 6) Finish!

Claudia_Ex04A_Polygonal Surface

2009-07-22T01:20:00.008+02:00

####### Ex04A #######
# a) Create a curve from points
# b) create several curves
# c) loft the curves to create a Nurbs Surface
# d) Convert the Nurbs Surface to a Polygonal Surface
# e) Modify the vertices of the Polygonal Surface randomly
# f) finish
#################################

import maya.cmds as cmds
from math import*
import random

# a) Create a curve from points
# define Curve
def Curve(numPoints):
    # define initial variables
    numPoints= 60
    # create an empty list to store the points
    Points= []    
    #loop and gather point information
    for i in range (0, numPoints,1):
        # function of the conical helix to generate a curve
        x= i*cos(6*i)
        y= i*(sin(6*i)+2)
        z= i+3
        myPoint= (x,y,z)
        # store the points in the list
        Points.append(myPoint)
    #create the curve
    Curve= cmds.curve(d=3, p=Points) #curve of degree 3
    return Curve

MyCurve= Curve(60)

#hide the Curve
cmds.hide(MyCurve)

# b) create several curves
# create an empty list to store the curves
myCurves=[]
# define variables
numCrvs= 9
offset= 4
# create a loop
for e in range (0, numCrvs,1):
    crv= Curve(e)
    offset= offset*1.2
    #store the curve in the list
    myCurves.append(crv)
    #move the curves with an offset in the "z" axis
    cmds.move(0,0,offset,crv)

# c) Loft the curves to create a Nurbs surface
myNurbsSurface= cmds.loft(myCurves, n="myNurbsSurf")

#hide the curves
cmds.hide(myCurves)

# d) convert the Nurbs Surface to Polygonal Surface
# get the Nurbs surface
myNurbsSurface= cmds.filterExpand(sm=10)

# convert
myPolySurface=cmds.nurbsToPoly("myNurbsSurf",pt=1, n="myPolySurf")

#hide the Nurbs Surface
cmds.hide("myNurbsSurf")

# e) Move the vertices of the Polygonal surface randomly
# get all the vertices of myPolySurface
allCvs= cmds.ls("myPolySurf.vtx[:][:]", fl=1)

# Move the vertices in PolySurface randomly
def moveVertiRandomly(allCvs, minimum, maximum):
    if minimum>= maximum:
        print "poly"
    # start a loop through all vertices in "x" and "y" axes
    else:
        for i in allCvs:
            x= random.uniform(minimum, maximum)*e
            y= random.uniform(minimum, maximum)*e
            z= 0
            cmds.move (x,y,z,i,r=True)
# move vertices randomly
moveVertiRandomly (allCvs, 0, 0.6)

# f) finish!

Assiment_04_DengLei

2009-07-21T17:08:00.004+02:00

Masha - Assignment 03B

2009-07-12T20:06:00.004+02:00


import maya.cmds as cmds
import random
import math

def magnitude (v):
   x= v[0]
   y= v[1]
   z= v[2]
   m = math.sqrt ((x*x)+(y*y)+(z*z))
   return m
 
def distance (p1, p2):
   #substract both vectors
   x1 = p1[0]
   y1 = p1[1]
   z1 = p1[2]
   x2 = p2[0]
   y2 = p2[1]
   z2 = p2[2]    
   x = x1-x2
   y = y1-y2
   z = z1-z2
   m = magnitude ([x,y,z])
   return m
 
def unit(v):
   #returns unit vector of v
   #first get magnitude
   m = magnitude(v)
   x = v[0]
   y = v[1]
   z = v[2]
   #devide each element by magnitude
   x = x/m
   y = y/m
   z = z/m
   vu = [x,y,z]
   return vu
 
def move (v, amount):
   "Move by certaine amount in directio v"
   x = v[0]
   y = v[1]
   z = v[2]
   x = x+amount
   y = y+amount
   z = z+amount
   newP = [x,y,z]
   return amount  
 
def vectorBetweenPoints (p1, p2):
   "Returns vector between p1 and p2"
   #substract both vectors
   x1 = p1[0]
   y1 = p1[1]
   z1 = p1[2]
   x2 = p2[0]
   y2 = p2[1]
   z2 = p2[2]    
   x = x1-x2
   y = y1-y2
   z = z1-z2
   newV = [x,y,z]
   return newV

def moveVert (allCvs):
   selLoc = cmds.filterExpand (sm = 22)
   xs = 0
    ys = 0
    zs = 0
   for i in allCvs:
       pos = cmds.pointPosition(i)

       posLoc = cmds.pointPosition (selLoc)
        dd = distance ([centerX, centerY, centerZ], posLoc)
        print dd
        cmds.polyExtrudeVertex( l =dd, w=3, d=4 )
 
         
def moveVertice (allCvs):
   selLoc = cmds.filterExpand (sm = 22)
   allCvs1 = cmds.ls("nurbsPlane2.cv[:][:]", fl=1)
   #d=1000
   dist =1000
   allDist =[]
   print selLoc
   for i in allCvs1:
       pos = cmds.pointPosition(i)
       for j in selLoc:
           posLoc = cmds.pointPosition (j)
           dd = distance (pos, posLoc)
           if dd

03B - Deborah Kaiser - Extrudying faces of a polygon according to locator

2009-07-12T18:51:00.002+02:00

#################################################
#####
### 03B
#####

import maya.cmds as cmds
import math
import random

#EXTRUDE FACES OF POLYGON ACCORDING TO DISTANCE TO LOCATOR

def magnitude(v):
x=v[0]
y=v[1]
z=v[2]
m=math.sqrt ((x*x)+(y*y)+(z*z))
return m

def distance (p1, p2):
x1=p1[0]
y1=p1[0]
z1=p1[1]
x1=p1[2]
x2=p1[0]
y2=p1[1]
z2=p1[2]
x= x1-x2
y= y1-y2
z= z1-z2
m= magnitude([x, y, z])
return m

def ExtrudeToLocator():
"Extrude based on a distance of a certain Locator"

#GET LOCATOR AND POLYGON
selPoly= cmds.filterExpand(sm=12)
selLoc= cmds.filterExpand(sm=22)
selPoly= selPoly[0]

#GET ALL FACES OF POLYGON
allFaces= cmds.ls(selPoly + ".f[:]", fl=1)

#LOOP THROUGH FACES
for face in allFaces:
vertex= cmds.polyListComponentConversion (face, fromFace=1, toVertex=1)
vertex= cmds.ls (vertex, fl=1)
# find the center of the face
xs= 0
ys= 0
zs= 0

# LOOP THROUGH VERTICES
for v in vertex:
pos= cmds.pointPosition(v)
x= pos[0]
y= pos[1]
z= pos[2]
xs= xs + x
ys= ys + y
zs= zs + z
centerX= xs/len(vertex)
centerY= ys/len(vertex)
centerZ= zs/len(vertex)

#PLACE LOCATOR
cmds.spaceLocator(p=(centerX, centerY, centerZ))

#DISTANCE TO LOCATOR
posLoc= cmds.pointPosition(selLoc)
d= distance([centerX, centerY, centerZ], posLoc)
print d
#extrude based on distance
cmds.polyExtrudeFacet(face, ltz=d/10)

#EXTRUDE TO LOCATOR
ExtrudeToLocator()

Ex03B_PolyPlane_Deborah&Claudia

2009-07-12T18:41:00.003+02:00

#######################
## Ex03B_Move Cvs of a Nurbs according to Locator direction
#######################

import maya.cmds as cmds
import math

#define distance between PolFaces and locator
def magnitude (v):
    #v is a list of x,y,z values
    x= v[0]
    y= v[1]
    z= v[2]
    m= math.sqrt ( (x*x) + (y*y) + (z*z) )
    return m
    
def distance (posVert, posLoc):
    #subtract both vectors
    x1= posVert[0]
    y1= posVert[1]
    z1= posVert[2]
    x2= posLoc[0]
    y2= posLoc[1]
    z2= posLoc[2]
    x= x1 - x2
    y= y1 - y2
    z= z1 - z2
    m= magnitude ([x,y,z])
    return m
    
#define moveToLocator function
def moveToLocator():
    # A) get all the verticesNames of a plane
    allVertices= cmds.ls ("pPlane1.vtx[:]", fl=1)
    
    #create an empty list to store the points
    MyVerts=[]
        
    #get selected Locator
    selLoc= cmds.filterExpand(sm=22)
    
    #loop through vertices
    for v in allVertices:
        pos= cmds.pointPosition(v)
        x= pos[0]
        y= pos[1]
        z= pos[2]
        
        #find distance to Locator
        posVert= cmds.pointPosition(v)
        posLoc= cmds.pointPosition(selLoc)
        d= distance(posVert, posLoc)
        print d
        cmds.move (d,3,d,v,r=True)
        
        #store the cvs in a list
        MyVerts.append(allVertices)

#call the function
moveToLocator()

Ex03B_NurbsSphere_Deborah&Claudia

2009-07-12T18:39:00.001+02:00

#######################
## Ex03B_Move Cvs of a Nurbs according to Locator direction
#######################

import maya.cmds as cmds
import math

#define distance between cvs and locator
def magnitude (v):
    #v is a list of x,y,z values
    x= v[0]
    y= v[1]
    z= v[2]
    m= math.sqrt ( (x*x) + (y*y) + (z*z) )
    return m
    
def distance (posPoint, posLoc):
    #subtract both vectores
    x1= posPoint[0]
    y1= posPoint[1]
    z1= posPoint[2]
    x2= posLoc[0]
    y2= posLoc[1]
    z2= posLoc[2]
    x= x1 - x2
    y= y1 - y2
    z= z1 - z2
    m= magnitude ([x,y,z])
    return m

#define moveToLocator function
def moveToLocator():
    # A) get all the cvsNames of a NurbsPlane
    NurbsCvs = cmds.ls("nurbsSphere1.cv[:]", fl=1)
    
    #create an empty list to store the points
    MyCvs=[]
        
    #get selected Locator
    selLoc= cmds.filterExpand(sm=22)
    
    #loop through cvs
    for i in NurbsCvs:
        posPoint= cmds.pointPosition(i)
        posLoc= cmds.pointPosition (selLoc)
        d= distance(posPoint, posLoc)
        print d
        cmds.move (d,d,d,i,r=True)
        
        #store the cvs in a list
        MyCvs.append(NurbsCvs)

#call the function
moveToLocator()

Ex03B_Curve_Claudia&Deborah

2009-07-12T17:39:00.003+02:00

#####################
## Ex03B_Move Cvs of a Curve according to Locator direction
#######################

import maya.cmds as cmds
import math

#define distance between cvs and locator
def magnitude (v):
    #v is a list of x,y,z values
    x= v[0]
    y= v[1]
    z= v[2]
    m= math.sqrt ( (x*x) + (y*y) + (z*z) )
    return m
    
def distance (posPoint, posLoc):
    #subtract both vectores
    x1= posPoint[0]
    y1= posPoint[1]
    z1= posPoint[2]
    x2= posLoc[0]
    y2= posLoc[1]
    z2= posLoc[2]
    x= x1 - x2
    y= y1 - y2
    z= z1 - z2
    m= magnitude ([x,y,z])
    return m

#define moveToLocator function
def moveToLocator():
    # A) get all the cvsNames of a curve
    allCvs = cmds.ls("curve1.cv[:]", fl=1)
    
    #create an empty list to store the points
    MyCvs=[]
        
    #get selected Locator
    selLoc= cmds.filterExpand(sm=22)
    
    #loop through cvs
    for i in allCvs:
        posPoint= cmds.pointPosition(i)
        posLoc= cmds.pointPosition (selLoc)
        d= distance(posPoint, posLoc)
        print d
        cmds.move (0,0,d,i,r=True)
        
        #store the cvs in a list
        MyCvs.append(cvs)

#call the function
moveToLocator()

02B - Anthony Adelmann

2009-07-12T12:05:00.002+02:00

import maya.cmds as cmds
from math import*
from random import*

#from curves to surfaces
#step 1, create a curve
def curves (amplitude):
#def initial variables
numPoints= 70
#create an empty list to store the points
points=[]
#loop and gather information
for i in range (1,numPoints,1):
#function of the spiral curve:
x=sin(i)*amplitude
y=cos(i)*amplitude
z=i
myPoint=(x,y,z)
#store the points in the list
points.append(myPoint)
myCurve=cmds.curve(d=3, p=points)
return myCurve
#create an empty list to store the curves
myCurve=[]
#define the number of curves
numCurves=19
#function to call the curves in a loop
for i in range(0,numCurves,2):
crv=curves(i)
#store the curve in the list
myCurve.append (crv)
print crv
#move the curves
cmds.move(3,11,4, crv)
#loft the curves
cmds.loft(myCurve)

01A - Diana Perez - Make capuccino

2009-07-12T01:23:00.002+02:00


function fillBoiler: 
 with cup
  fill with coldMilk
 get boiler     
 place boiler right to cup 
 with cup 
  move 20cm up     
  turn -90°
 if cup = „empty“ 
  turn 90°         
  move 20cm down
  execute function boilMilk
  
function boilMilk:
 get boiler
 put boiler on heater
 turn heater.switch to „on“
 desiredTime = 5min
 when desiredTime:             
  turn heater.switch to „off“
  execute function putCapuccino
   
function putCapuccino: 
 get cup 
 desiredCapuccino = 2
 desiredSugar = 2 
 execute function fillCup
 
function fillCup:
 get cup 
 place cup right to boiler 
 with boiler:
      move 20cm up
      turn -90° 
 if cup = „full“     
  with boiler:
      turn 90°         
       move 20cm down     
       
finish

Clau_Ex03B_Doubts

2009-07-12T00:21:00.004+02:00

Daniel, I am trying to move the vertices of a Curve according to the direction of a Locator. I could move the position of the Curve to the direction of a locator -see script below- however, when i try to apply this logic to move the vertices of the curve, i get lost. Don't tell you about moving the cv's of a nurbs surface according the direction of a locator. Could you help me?
This is the scripting with probls

## Ex03B_Move Curve Cvs according to Locator direction
#####

import maya.cmds as cmds
import math

#get names of selected objects on Stage
#first select the objects
selObj= cmds.ls(sl=1)
print selObj

#find position of this two objetcs
obj1= selObj[0] #this is for locator1
obj2= selObj[1] #this is for curve1
print obj1
print obj2

pos1= cmds.pointPosition(obj1)
pos2 = cmds.pointOnCurve(obj2)
print pos1
print pos2

#find distance between two objects
d= distance (pos1,pos2)
print d

#move all vertices of obj2 10 times in direction to obj1
# select all vertices of obj2
allCvs = cmds.ls("curve1.cv[:]", fl=1)

# I dont know how to continue....

Here is the script to move the curve position according to loc1 direction

## Ex03B_Move Curve according to Locator direction
#####

import maya.cmds as cmds
import math

#get names of selected objects on Stage
#first select the objects
selObj= cmds.ls(sl=1)
print selObj

#find position of this two objetcs
obj1= selObj[0] #this is for locator1
obj2= selObj[1] #this is for curve1
print obj1
print obj2

pos1= cmds.pointPosition(obj1)
pos2= cmds.pointOnCurve(obj2)
print pos1
print pos2

#find distance between two objects
d= distance (pos1,pos2)
print d

#move obj2 4 times in direction to obj1
# first get vectors between obj2 and obj1
v= vectorBetweenPoints(pos1,pos2)
# get the unit of vector v
dir= unit(v)

#move 4 units in dir obj1
newPos= move (dir,4)

#move obj2 to that position
cmds.move (newPos[0], newPos[1], newPos[2], obj2)

This is the exercise of extruding faces of a polygon according to the distance of a Locator.

### Ex03B ######
## Vector Functions
import maya.cmds as cmds
import math
import random

########### extrude the faces of a polygonal object
# according to its distance to a certain
# locator

def ExtrudeToLocator():
    "Extrude based on a distance of a certain Locator"
    #get selected Poly and selected Locator
    selPoly= cmds.filterExpand(sm=12)
    selLoc= cmds.filterExpand(sm=22)
    selPoly= selPoly[0]
    
    #get all faces of the Poly
    allFaces= cmds.ls(selPoly + ".f[:]", fl=1)
    
    #start a loop through all faces
    for face in allFaces:
        vertex= cmds.polyListComponentConversion (face, fromFace=1, toVertex=1)
        vertex= cmds.ls (vertex, fl=1)
        # find the center of the face
        xs= 0
        ys= 0
        zs= 0
        
        #loop through vertices
        for v in vertex:
            pos= cmds.pointPosition(v)
            x= pos[0]
            y= pos[1]
            z= pos[2]
            xs= xs + x
            ys= ys + y
            zs= zs + z
        centerX= xs/len(vertex)
        centerY= ys/len(vertex)
        centerZ= zs/len(vertex)
        
        #check by placing a Locator
        cmds.spaceLocator(p=(centerX, centerY, centerZ))
        
        #find distance to Locator
        posLoc= cmds.pointPosition(selLoc)
        d= distance([centerX, centerY, centerZ], posLoc)
                
        #extrude based on distance
        cmds.polyExtrudeFacet(face, ltz=d)

#extrude to locator
ExtrudeToLocator()

02A - Anthony Adelmann

2009-07-11T19:35:00.002+02:00

import maya.cmds as cmds
from math import*
from random import*

numRow = 20
numColumns = 13
numHeights = 12
points = []

for i in range(0, numRow, 1):
x = (i)
for j in range (0, numColumns, 1):
y = j
for k in range (-1, numHeights, 1):
z = sin (k*i*j)
myPoint = (x,y,z)
points.append(myPoint)
cmds.curve(d=3, p=points)

Claudia_Ex03A

2009-07-11T15:53:00.008+02:00

######### Excercise 03A
import maya.cmds as cmds
import random
import math

###### CURVE ######
# A) get all the cvsNames of a curve
allCvs = cmds.ls("curve1.cv[:]", fl=1)

# B) define move cvs randomly
def moveVertRandomly (allCvs, minimum, maximum):  
    if minimum>= maximum:  
        print "hello!"  
    # B.1) start a loop through all cvs
    else:
        for cv in allCvs:  
            rx = random.uniform(minimum, maximum)  
            ry = random.uniform(minimum, maximum)  
            rz = random.uniform(minimum, maximum)  
            cmds.move (rx,ry,rz,cv,r=2)
    
# C) move cvs randomly
moveVertRandomly (allCvs, 0, 17)

####### Nurbs Surface #######
# A) get all the vertices of the Nurbs
allCvs= cmds.ls("nurbsPlane1.cv[:][:]", fl=1)

# B) define move cvs in nurbsPlane randomly
def moveVertiRandomly(allCvs, minimum, maximum,x,y,z):
    if minimum>= maximum:
        print "hello!"
    # B.1) start a loop through all cvs in z axis
    else:
        for i in allCvs:
            x= 0
            y= 0    
            z= random.uniform(minimum, maximum)
            cmds.move (x,y,z,i,r=True)
# C) move dvs randomly
moveVertiRandomly (allCvs, 2, 18, 0,0,7)

####### Faces of a Polygon #######
# A) get all faces of a Polygon
allFaces= cmds.ls ("pCone1.f[:]", fl=1)

# B) define extrude faces of a polygon
def ExtrudeFacesRandom (allFaces, minimum, maximum):
    if minimum>= maximum:
        print "polygon"
    # B.1 start a loop through all faces in y axix
    else:
        for face in allFaces:
            ry= random.uniform(minimum, maximum)
            cmds.polyExtrudeFacet(face, ltz=ry)

# C) extrude faces
ExtrudeFacesRandom(allFaces, 0,10)

####### Polygon Vertices #######
# A) get all vertices of a Polygon
allVertices= cmds.ls ("pPlane1.vtx[:]", fl=1)

# B) define movePolVertices
def movePolVert (allVertices, minimum, maximum):
    if minimum>= maximum:
        print "polygon"
    # B.1 start a loop through vertices in z axis
    else:
        for e in allVertices:
            rx= random.uniform (minimum, maximum)
            ry= random.uniform (minimum, maximum)
            rz= random.uniform (minimum, maximum)
            cmds.move (rx,ry,rz,e,r=True)

# C) move Polygon Vertices
movePolVert(allVertices,1,7)

03A - Valentina de Leon

2009-07-10T23:25:00.000+02:00

import maya.cmds as cmds
import random
import math

def moveVertRandomly (allCvs, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allCvs:
rx = random.uniform(minimum, maximum)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)
cmds.move (rx,ry,rz,i,r=1)

def moveVerticeRandomly (allCvs, minimum, maximum, x,y,z):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allCvs:

z = random.uniform(minimum, maximum)
cmds.move (x,y,z,i,r=1)

def extrudeFacesRandomly(allFaces, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allFaces:
rz = random.uniform(minimum, maximum)
cmds.polyExtrudeFacet(i, ltz = rz)

def polygonVertices (allVert, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allVert:
rx = random.uniform(minimum, maximum)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)
cmds.move (rx,ry,rz,i,r=1)

allCvs = cmds.ls("curve1.cv[:]", fl=1)
moveVertRandomly (allCvs, 10, 20)

allCvs1 = cmds.ls("nurbsPlane1.cv[:][:]", fl=1)
moveVerticeRandomly (allCvs, 1, 10,3,7,5)
allFaces = cmds.ls("pPlane1.f[:]", fl=1)

extrudeFacesRandomly(allFaces, 0, 15)

allVert = cmds.ls("pPlane2.vtx[:]", fl=1)
polygonVertices (allVert, 0, 5)

02A - Valentina de Leon

2009-07-10T21:52:00.002+02:00

import maya.cmds as cmds

#CURVES THROUGH POINTS

from math import*

numRows = 15
numColumns = 30
num3rdDimension = 50
points=[]
for i in range(0,numRows,1):
x = (i)
for j in range(-15,numColumns,30):
y = j
for k in range(5,num3rdDimension,30):
z = sin(k*i*j)*5

# ONDULATING GRID
myPoint=(x,y,z)
points.append(myPoint)
cmds.curve(d=30, p=points)

03A - Deborah Kaiser

2009-07-10T18:38:00.000+02:00

03A - Deborah Kaiser

2009-07-10T18:30:00.002+02:00

########################################################
##
###03A
##
import maya.cmds as cmds
import random
import math
#MOVE CURVES
def moveVertRandomly (allCvs, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allCvs:
rx = random.uniform(minimum, maximum)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)
cmds.move (rx,ry,rz,i,r=1)
def moveVerticeRandomly (allCvs, minimum, maximum, x,y,z):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allCvs:
z = random.uniform(minimum, maximum)
cmds.move (x,y,z,i,r=1)
#EXTRUDE FACES
def extrudeFacesRandomly(allFaces, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allFaces:
rz = random.uniform(minimum, maximum)
cmds.polyExtrudeFacet(i, ltz = rz)
#POLYGON VERTICES
def polygonVertices (allVert, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allVert:
rx = random.uniform(minimum, maximum)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)
cmds.move (rx,ry,rz,i,r=1)
allCvs = cmds.ls("curve1.cv[:]", fl=1)
moveVertRandomly (allCvs, 5, 25)
allCvs1 = cmds.ls("nurbsPlane1.cv[:][:]", fl=1)
moveVerticeRandomly (allCvs, 10, 1, 2,20,5)
allFaces = cmds.ls("pPlane1.f[:]", fl=1)
extrudeFacesRandomly(allFaces, 5, 10)
allVert = cmds.ls("pPlane2.vtx[:]", fl=1)
polygonVertices (allVert, 0, 5)

Assiment_03A

2009-07-09T16:27:00.009+02:00

03A - Deborah Kaiser - doubt

2009-07-08T22:18:00.001+02:00

Hey daniel, i dont know why i can only make the curve part work, i get a syntax error with the extrude and the last one and i can not figure out why.
Could u help me?

Thnx!

########################################################
##
###03A
##

import maya.cmds as cmds
import random
import math

#MOVE CURVES

def moveVertRandomly (allCvs, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allCvs:
rx = random.uniform(minimum, maximum)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)
cmds.move (rx,ry,rz,i,r=1)

def moveVerticeRandomly (allCvs, minimum, maximum, x,y,z):
if minimum>= maximum:
print "Find new variables!"

else:
for i in allCvs:
z = random.uniform(minimum, maximum)
cmds.move (x,y,z,i,r=1)

#EXTRUDE FACES

def extrudeFacesRandomly(allFaces, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allFaces:
rz = random.uniform(minimum, maximum
cmds.polyExtrudeFacet(i, ltz = rz)

#POLYGON VERTICES

def polygonVertices (allVert, minimum, maximum):
if minimum>= maximum:
print "Find new variables!"
else:
for i in allVert:
rx = random.uniform(minimum, maximum)
ry = random.uniform(minimum, maximum)
rz = random.uniform(minimum, maximum)
cmds.move (rx,ry,rz,i,r=1)

allCvs = cmds.ls("curve1.cv[:]", fl=1)
moveVertRandomly (allCvs, 5, 25)

allCvs1 = cmds.ls("nurbsPlane1.cv[:][:]", fl=1)
moveVerticeRandomly (allCvs, 10, 1, 2,20,5)

allVert = cmds.ls("pPlane2.vtx[:]", fl=1)
polygonVertices (allVert, 0, 5)

Assignment 04

2009-07-08T02:53:00.001+02:00

This final assignment should be a collection of all the topics from the last assignments. You should try to create a system starting from the point going all the way up to the surface, and finishing it by making modification on this surface's components.

You should to this both by creating a polygonal and a nurbs surface, as the final component modifications will depend on the type of object you have in the end.

Here are a few guidelines:

You should produce new work, and not simply copy from the past assignments or from material given in class
Start by writing down the logic by which your script will work to produce the final result you want to achieve. This should be done in plain English, just like your pseudo-code in the beginning of the course
Create functions for each of the steps, using both arguments and return values, so that one function depends on the results of the last to work
Document each step by doing renderings or screenshots, and also by intensively commenting your script
Post both final results (polygonal and nurbs surface) along with corresponding scripts and images

You can do the work in groups of two if you want, but keep in mind that double the quality of work is expected from two thinking heads working together!

This assignment, along with any other missing assignment you migh have, should be delivered by Sunday (12.07)

w08 - recap and script

2009-07-08T02:33:00.001+02:00

As we saw last class, this semester we studied the following topics:

a. Basics of scripting
    i. Variables
    ii. Lists
    iii. Loops
    iv. Conditional statements
    v. Functions
b. Object manipulation in maya
    i. Points
        1. How to represent a point
        2. How to plot points in space
    ii. Curves
        1. How to get points coordinates and use them to draw a curve
        2. Using mathematical functions to generate curves
    iii. Surfaces
        1. How to use curves to generate surfaces
        2. Primitive surfaces in Maya
        3. Types of surfaces
            a. Polygonal surfaces
            b. Nurbs surfaces
            c. Subdivisions
        4. Object components
            a. Polygons
                i. Vertices
                ii. Faces
                iii. Edges
            b. Nurbs
                i. Control vertices
                ii. Isoparms
                iii. Surface points
        5. Volumes
            a. Primitives

In our last class we saw the last function for the semester, which showed you how to determine point on a nurbs surface and how to use the normals to orient the placement of objects on them. Here is the whole function, with some modifications to increase flexibility:

####################
## GSI
## w08
####################

import maya.cmds as cmds

def createCellsNormalToSurface(whatCell, numU, numV, size):
	#determine the scale of the objects
	scale = (size/100.)*.5
	#get selected objects
	objs = cmds.ls(sl=1)
	#check if you do have selected objects on stage
	if (len(objs) == 0):
		#in case you dont, stop the function execution
		print "You need to select at least one surface!"
		return
	
	#if you have selected surfaces, 
	#apply the objects on each one of the
	for mySurface in objs:
		for i in range(numU):
			myu = i/float(numU)
			for j in range(numV):
				myv = j/float(numV)
				#get the coordinates and the normal on the current uv parameter
				myCoord = cmds.pointOnSurface(mySurface, top=1, u=myu, v=myv, p=1)
				myNorm = cmds.pointOnSurface(mySurface, top=1, normalizedNormal=1, u=myu, v=myv)
				#then according to the type of object you want place it
				if (whatCell == "Cylinder"):
					myCell = cmds.cylinder(p=myCoord,ax=myNorm, r=scale, hr=scale)
				elif (whatCell == "Plane"):
					myCell = cmds.nurbsPlane(p=myCoord, ax=myNorm, w=scale, lr=scale)
				elif (whatCell == "Cone"):
					myCell = cmds.cone(p=myCoord, ax=myNorm, r=scale, s=20, hr=scale)

				else:
					print "You need to specify Cylinder, Plane or Cone!
					
##call the function
createCellsNormalToSurface("Cylinder", 30, 15, 200)

Assignment_03A

2009-07-05T14:24:00.004+02:00



import maya.cmds as cmds
import random
import math

def moveVertRandomly (allCvs, minimum, maximum):
 if minimum>= maximum:
     print "Find new variables!"
 else:
     for i in allCvs:
         rx = random.uniform(minimum, maximum)
         ry = random.uniform(minimum, maximum)
         rz = random.uniform(minimum, maximum)
         cmds.move (rx,ry,rz,i,r=1)
     
def moveVerticeRandomly (allCvs, minimum, maximum, x,y,z):
 if minimum>= maximum:
     print "Find new variables!"
 else:
     for i in allCvs:

         z = random.uniform(minimum, maximum)
         cmds.move (x,y,z,i,r=1)    
         
def extrudeFacesRandomly(allFaces, minimum, maximum):
 if minimum>= maximum:
     print "Find new variables!"
 else:
     for i in allFaces:
         rz = random.uniform(minimum, maximum)
         cmds.polyExtrudeFacet(i, ltz = rz)
         
def polygonVertices (allVert, minimum, maximum):
 if minimum>= maximum:
     print "Find new variables!"
 else:
     for i in allVert:
         rx = random.uniform(minimum, maximum)
         ry = random.uniform(minimum, maximum)
         rz = random.uniform(minimum, maximum)
         cmds.move (rx,ry,rz,i,r=1)
     
  
allCvs = cmds.ls("curve1.cv[:]", fl=1)
moveVertRandomly (allCvs, 0, 10)

allCvs1 = cmds.ls("nurbsPlane1.cv[:][:]", fl=1)
moveVerticeRandomly (allCvs, 0, 10, 0,0,5)

extrudeFacesRandomly(allFaces, 0, 5)
allFaces = cmds.ls ("pPlane1.f[:]", fl = 1)

allVert = cmds.ls("pPlane2.vtx[:]", fl=1)
polygonVertices (allVert, 0, 5)

Assignment 03B

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

Redo the assignment 03A by making all those transformations based on a single or multiple locators.

You can do that by either using the distance, direction, relative rotation, etc, to the locator, which will in turn define the amount of the transformation you applied. You'll need to use the vector functions we defined last class.

This assignment should be delivered by 05.07, the day before our last class.

w07 - recap and scripts

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

On our 7th class, we looked into some vector math to help us with certain calculations in Maya. We then developed the following functions:

#######
##
## VECTOR FUNCTIONS
##

import maya.cmds as cmds
import math

#find the magnitude (length) of a vector
def magnitude(v):
	#v is a list of x,y,z values
	x = v[0]
	y = v[1]
	z = v[2]
	m = math.sqrt( (x*x) + (y*y) + (z*z)  )
	
	return m

#find the distance between two points
#by getting the vector between the points and 
#getting its magnitude
def distance(p1, p2):
	#subtract both vectors
	x1 = p1[0]
	y1 = p1[1]
	z1 = p1[2]
	x2 = p2[0]
	y2 = p2[1]
	z2 = p2[2]
	x = x1 - x2
	y = y1 - y2
	z = z1 - z2
	m = magnitude([x,y,z])
	return m

#find the unit vector of a given vector
def unit(v):
	"returns unit vector of v"
	#firt get magnitude
	m = magnitude(v)
	x = v[0]
	y = v[1]
	z = v[2]
	#divide each element by magnitude
	x = x/m
	y = y/m
	z = z/m
	vu = [x,y,z]
	return vu

#find the new position of an object which
#it supposed to move a certain amount in the
#direction of a vector (which should be a unit vector)
def move(v, amount):
	"Move by certain amount in direction v"
	x = v[0]
	y = v[1]
	z = v[2]
	x = x + amount
	y = y + amount
	z = z + amount
	newP = [x,y,z]
	return newP

#find the vector between two given points
def vectorBetweenPoints(p1, p2):
	"Returns vector between p1 and p2"
	#subtract both vectors
	x1 = p1[0]
	y1 = p1[1]
	z1 = p1[2]
	x2 = p2[0]
	y2 = p2[1]
	z2 = p2[2]
	x = x1 - x2
	y = y1 - y2
	z = z1 - z2
	newV = [x,y,z]
	return newV

We then used a bit of this content to extrude the faces of a certain polygonal object according to its distance to a certain locator, by using the function below:

def extrudeToLocator():
	"Extrude based on distance to a certain locator"
	#get selected poly
	#get selected locator
	#get faces of poly
	#loop through faces
	#	find center
	#	get distance from center to locator
	#	extrude based on distance
	selPoly = cmds.filterExpand(sm=12)
	selLoc = cmds.filterExpand(sm=22)
	
	selPoly = selPoly[0]
	
	allFaces = cmds.ls(selPoly + ".f[:]", fl=1)
	#loop
	for face in allFaces:
		vertex = cmds.polyListComponentConversion( face, fromFace=1, toVertex=1 )
		vertex = cmds.ls(vertex, fl=1)
		#find the center of the face
		xs = 0
		ys = 0
		zs = 0
		#loop through vertices
		for v in vertex:
			pos = cmds.pointPosition(v)
			x = pos[0]
			y = pos[1]
			z = pos[2]
			xs = xs + x
			ys = ys + y
			zs = zs + z
		centerX = xs/len(vertex)
		centerY = ys/len(vertex)
		centerZ = zs/len(vertex)
		#check by placing a locator
		cmds.spaceLocator(p=(centerX, centerY, centerZ))
		
		#find distance to locator
		posLoc = cmds.pointPosition(selLoc)
		d = distance([centerX, centerY, centerZ], posLoc)
		print d
		
		#extrude based on distance
		cmds.polyExtrudeFacet( face, ltz=d)

Assiment_02B

2009-06-16T16:12:00.003+02:00

Assignment 03A

2009-06-16T14:40:00.001+02:00

For this assignment, you should mainly work with components of objects in Maya (cvs, edges, faces, vertices). You should try and create a function definition for each one of the exercises, making them flexible by passing arguments and using if/else statements in your code.

Curve CVs: function to randomly move all control vertices of a curve. As arguments in your function, you should pass the minimum and maximum values for the random movement
Nurbs Surfaces CVs: function to randomly move all control vertices of a nurbs surface. As arguments in your function, you should pass the minimum and maximum values for the random movement, as well as the axis in which you want to randomly move the CVs (x, y or z)
Faces of a polygon: function for randomly extrude all faces of a polygonal surface. As arguments in your function, you should pass the minimum and maximum values for the random extrusion
Polygon Vertices: function to randomly move all vertices of a polygonal surface. As arguments in your function, you should pass the minimum and maximum values for the random movement, as well as the axis in which you want to randomly move the vertices (x, y or z)
Add an if statement to the above functions to jump every n element (you choose the number). If you want, you can also change the operation being performed (for example, use poke face instead of extrude face, or extrude vertex instead of move vertex). Check the Python Command Reference in the Help menu to look for other operations that could be used with the desired component.

All the above is repetition of everything we saw in class and that you have been producing the past weeks.

Please, post your results (scripts along with screenshots) on the blog by 21.06, around midday.

w06 - recap and scripts

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

Yesterday we tried to do a kind of workshop in class. It was good, but a bit slower than I imagined. We started by seeing how to access all cvs of curves and nurbs surfaces, and all faces, vertices and edges of polygonal surfaces, and how to start a loop to make modifications with them.

## how to get all CVs of a curve
## this will result in a list containing all the names of the curve CVs
allCVs = cmds.ls("nameOfCurve.cv[:]", fl=1)

## you can also use the same code for a selected curve on stage
## which would make more sense for the flexibility of your script

# this will return you the name of all nurbs curves selected on stage
curve = cmds.filterExpand(sm=9) 

#this will return you the names of all CVs from the first selected curve
#or of the only curve in case there is only one
allCVs = cmds.ls(curve[0] + ".cv[:]", fl=1) 

## the same can be done with any selected nurbs surface
srf = cmds.filterExpand(sm=10)
allCVs = cmds.ls(srf[0] + ".cv[:][:]", fl=1)

## and with polygons
poly = cmds.filterExpand(sm=12)
# all faces:
allFaces = cmds.ls(poly[0] + ".f[:]", fl=1)
# all vertices:
allVertices = cmds.ls(poly[0] + ".vtx[:]", fl=1)
# all edges:
allEdges = cmds.ls(poly[0] + ".e[:]", fl=1)

## Then, if you want to make modifications on each one
## of those elements, you have to start a loop through the list.

#In the case of all cvs of a curve, for example:
for cv in allCVs:
	#here come the code you want to perform with each cv
	print cv
	
# or with faces of a polygon.
for face in allFaces:
	#do something...

# keep in mind that the words cv or face in the line above
# are simply names of variables which you define, and which
# represent the cv or face at each iteration of the loop

## another way to do a loop, would be:
numCVs = len(allCVs) #this will return you the amount of elements you have in allCVs list
for i in range(numCVs):
	print i #this will iterate through numbers
	cv = allCVs[i] #like this you get the name of the CV
	#and here you can put your code to make transformations with each cv

	

## One thing you can do in a loop is to jump in certain steps
## like for example, only perform action every 5th element, for example
## you do that by using the % operator and an if statement
for i in range(numCVs):
	if i % 5 == 0:
		#whatever is indented here will oly be executed everytime
		#the above if statement is equal to true
		print i

02B_COSMOS BEDZRA_SURFACE

2009-06-16T01:52:00.002+02:00

import maya.cmds as cmds
from random import*
from math import*


#REVOLVING A CURVE TO FORM A SURFACE
def revolve(numPoints,myAxis,myEndSweep):
"revolve a curve"
myPoints=[]
for i in range(numPoints):
    x=uniform(0,20)
    y=10
    z=i*5
    myPoints.append([x,y,z])
crv=cmds.curve(ep=myPoints,d=3)
cmds.revolve(crv,axis=myAxis,endSweep=myEndSweep)
revolve(10,[1,0,1],90)

week05_assignment_Masha

2009-06-15T12:25:00.002+02:00


import maya.cmds as cmds
import random
import math
from random import *
from math import *


def Curve(numPoints):
    #create an empty list to store the point
    points = []
    #loop and gather point information
    for i in range (1, numPoints, 1):
        amplitude = randint(0,3)
        amp = randint(0,3)
        #function for the spiral curve
        a=i*0.3
        x = cos(a)*amplitude
        y = 0
       
        z =-i
        myPoint = (x,y,z)
        #store the point in the list
        points.append(myPoint)
       
    #create the curve
    myCurve = cmds.curve (d = 3, p=points) #degree 3
    return myCurve
   
def Curve2(numPoints):
    #create an empty list to store the point
    points = []
    #loop and gather point information
    for i in range (1, numPoints, 1):
        amplitude = randint(0,3)
        amp = randint(0,3)
        #function for the spiral curve
        a = i*0.3
        x = sin(a)*amplitude
        y = i
        z = amp*4
        myPoint = (x,y,z)
        #store the point in the list
        points.append(myPoint)
   
    #create the curve
    myCurve = cmds.curve (d = 3, p=points) #degree 3
    return myCurve
   
def tubulize (path, radius, tubeSections = 8):
    "Function to create tubes out of curve"
    #position on end of curve where i will put the circle profile
    pos = cmds.pointOnCurve (path, position = 1, pr = 0.001, top = 1)
    #get tangent of this point
    tan = cmds.pointOnCurve (path, tangent = 1, pr = 0.001, top = 1)
   
    #create the profile circle
    profile = cmds.circle (c=pos, r = radius, normal = tan, s= tubeSections, ch = 1)
    #center of circle pivot
    cmds.xform (cp = 1)
    #extrude the circle along path
    tube =cmds.extrude (profile [0], path, ucp =1, upn=1,et=1,rb=1,dl=3,ch=1, n ="spiralTube" )
    #returne values
    return [tube[0],radius,profile]   

radius = 6
numCurves = 200   
myCrv = []   
y1 = 0
angle = 360/numCurves
x1 = radius
z1 = 10   

for i in range (0, numCurves+1, 1):
    rad = randint(3,8)
    r = rad/10.0
   
    if i%2 == 0:
        curve1 = Curve(50)
       
    else:
        curve1 = Curve2(50)
       
    #cmds.move (0,0,10, curve1)
    #cmds.rotate( 0, 0, 90, curve1, pivot=(0,0,0))
    #curve1= Curve(30)
    cmds.rotate( 0, 0, angle*i+i,curve1, pivot=(x1,y1,z1))
    crv1 = tubulize (curve1, r, tubeSections = 8)
    #cmds.move (j,j,0, curve1)
    myCrv.append (curve1)

02 B - Valentina De León

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

import maya.cmds as cmds
from math import*
from random import*
#creating the curve
def curves (amplitude):
numPoints= 40
points=[]
#loop
for i in range (1,numPoints,1):
#function of the spiral curve:
x=sin(i)*amplitude
y=cos(i)*amplitude/30
z= i
myPoint= (x,y,z)
#points in the list
points.append(myPoint)
myCurve=cmds.curve(d=30, p=points)
return myCurve
#list to store the curves
myCurve=[]
numCurves=70
#function
for i in range(0,numCurves,5):
crv= curves (i)
myCurve.append (crv)
print crv
#moving the curves
cmds.move (45,70,35, crv)
cmds.loft(myCurve)

Week 05 - script pt01

2009-06-10T11:46:00.003+02:00

Here is the what we saw last class:


def tubulize( path, radius, tubeSections=8):
	"Function to create tubes out of a curve"
	#position on end of curve where i will put the circle profile
	pos = cmds.pointOnCurve( path, position=1, pr=0.001, top=1)
	#get tangent of this point
	tan = cmds.pointOnCurve( path, tangent=1, pr=0.001, top=1)
	
	#create the profile circle
	profile = cmds.circle( c=pos, r=radius, normal=tan, s=tubeSections, ch=1 )
	#center the circle pivot
	cmds.xform( cp=1 )
	
	#extrude the circle along the path
	tube = cmds.extrude( profile[0], path, ucp=1, upn=1, et=2, rb=1, dl=3, ch=1, n="spiralTube")	
	
	#return values
	return [tube[0],  radius, profile]

The first function we wrote, used to create pipes on any curve, defining its radius. Also here, we saw what are and how to use optional function arguments, in this case, the

tubeSections

argument.


def crvMoveRandom( curve, minimum, maximum ):
	"This function gets all CVs of a curve and move them"
	#get all cvs of curve.
	allCVs = "%s.cv[:] " % curve
	print allCVs
	cvs = cmds.ls( allCVs, fl=1 )
	print cvs
	#loop through cvs
	for cv in cvs:
		rx = random.uniform(minimum, maximum)
		ry = random.uniform(minimum, maximum)
		rz = random.uniform(minimum, maximum)
		cmds.move( rx, ry, rz, cv, r=1 )
		
	return cvs

On this function we learned a way to easily access all the control vertices (CVs) of a nurbs curve. By using the

cmds.ls

command along with the

fl

flag, you end up having a list with names of all cvs, through which you can later iterate and make whatever modifications you'd like.
We also saw that if we have a curve on which we aplpied the

tubulize()

function, the tube will automatically update when we make transformations on the curve. This happens due to Maya's construction history.


def animateCurve( curve, time ):
	fps = 24
	#start a loop through time
	for i in range( time ):
		#first go forward in time
		cmds.currentTime( i * fps )
		#then make transformations
		cvs = crvMoveRandom(curve, -10, 10)
		#set keyframe
		cmds.setKeyframe(cvs)

The final function was just a quick example of what we could do with the construction history turned on, along with some animation commands. By setting keyframes on each modification, Maya automatically interpolates the frames in between returning you a smooth animation.

Week 05 - recap

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

Yesterday we saw how to identify and correct some common scripting mistakes. We saw that the output panel from the script editor in Maya always tells us exactly what is wrong with our script and where the mistake is located.

We also tried to go into surface manipulation techniques, which unfortunately wasn't completed as expected. You were supposed to have seen how to access and manupilate nurbs CVs, polygons vertices, faces and edges. But we ended up only seeing how to use construction history to manipulate surfaces my modifying their generating curves.

02B - Deborah Kaiser - Lofting curves (exploring the results with different functions)

2009-06-09T00:29:00.002+02:00

import maya.cmds as cmds
from math import*
from random import*

# Surfaces from curves
#Curves
def curves (amplitude):
numPoints= 50
#list to store the points
points=[]
#loop
for i in range (1,numPoints,1):
#function of the spiral curve:
x=i*i/10
y=x*x*.5
z=y*x*sin(i)*.03
myPoint= (x,y,z)
#store the points in the list
points.append(myPoint)
myCurve=cmds.curve(d=3, p=points)
return myCurve
#List to store the curves
myCurve=[]
#Number of curves
numCurves=20
#Call the curve in a loop
for i in range(0,numCurves,2):
crv= curves (i)
#Store the curve in the list
myCurve.append (crv)
print crv
#move the curves
cmds.move (15,10,30, crv)
#Lofting the curves
cmds.loft(myCurve)

Assingnment 01B - 3D GRID

2009-06-09T00:01:00.002+02:00

import maya.cmds as cmds
#3d points grid
from math import*
numRows = 50
numColumns = 10
num3rdDimension =40
for i in range(0,numRows,3):
x = (i)
for j in range(0,numColumns,1):
y = j
for k in range(-1,num3rdDimension,1):
z = sin(k*i*j)
myPoint=(x,y,z)
cmds.spaceLocator(p=myPoint)

02B - Deborah Kaiser - Lofting curves (exploring the results with different functions)

2009-06-08T23:30:00.002+02:00

import maya.cmds as cmds
from math import*
from random import*

# Surfaces from curves
#Curves
def curves (amplitude):
numPoints= 50
#list to store the points
points=[]
#loop
for i in range (1,numPoints,1):
#function of the spiral curve:
x=tan(i)*amplitude
y=sin(i)*cos(i)*20
z=tan(i)*10
myPoint= (x,y,z)
#store the points in the list
points.append(myPoint)
myCurve=cmds.curve(d=3, p=points)
return myCurve
#List to store the curves
myCurve=[]
#Number of curves
numCurves=20
#Call the curve in a loop
for i in range(0,numCurves,2):
crv= curves (i)
#Store the curve in the list
myCurve.append (crv)
print crv
#move the curves
cmds.move (10,20,10, crv)
#Lofting the curves
cmds.loft(myCurve)

Lofting curves - Deborah Kaiser

2009-06-08T23:22:00.001+02:00

import maya.cmds as cmds
from math import*
from random import*

# Surfaces from curves
#Curves
def curves (amplitude):
numPoints= 50
#list to store the points
points=[]
#loop
for i in range (1,numPoints,1):
#function of the spiral curve:
x=sin(i)*100
y=cos(i)*amplitude*i/10*tan(i)
z= i*2*sin(i)
myPoint= (x,y,z)
#store the points in the list
points.append(myPoint)
myCurve=cmds.curve(d=3, p=points)
return myCurve
#List to store the curves
myCurve=[]
#Number of curves
numCurves=20
#Call the curve in a loop
for i in range(0,numCurves,2):
crv= curves (i)
#Store the curve in the list
myCurve.append (crv)
print crv
#move the curves
cmds.move (10,50,1, crv)
#Lofting the curves
cmds.loft(myCurve)

Assingnment 01B - Points to curves

2009-06-08T16:23:00.002+02:00

import maya.cmds as cmds
from math import*
from random import*
######################################################
#from points to curves
#defining initial variables
numRows= 30
numColumns=3
numLevels=9
amplitude = 7
#create an empty list to store the points
points= []
#defining the loop and gather information
for i in range (-1,numRows,1):
x= sin(6*i)*amplitude
for j in range (-1,numColumns,2):
y= cos(i)*8
for k in range (0,numLevels,2):
z= k+1
myPoint=(x,y,z)
#store the point in the list
points.append(myPoint)
#create the curve
cmds.curve (d= 3, p= points) #curve degree 3

Clau_Ex 02B

2009-06-08T16:17:00.003+02:00

#Exercise 02B
import maya.cmds as cmds
from math import*
from random import*
#from curves to surfaces
#1 Step: create a curve
def curves (amplitude):
    #def initial variables
    numPoints= 50
    #create an empty list to store the points
    points=[]
    #loop and gather information
    for i in range (1,numPoints,1):
        #function of the spiral curve:
        x=sin(i)*amplitude
        y=cos(i)*amplitude/1.2
        z= i
        myPoint= (x,y,z)
        #store the points in the list
        points.append(myPoint)
    myCurve=cmds.curve(d=3, p=points)
    return myCurve

#create an empty list to store the curves
myCurve=[]
#define the number of curves
numCurves=20
#function to call the curve in a loop
for i in range(0,numCurves,2):
    crv= curves (i)
    #store the curve in the list
    myCurve.append (crv)
    print crv
#move the curves
cmds.move (25,15,15, crv)
#loft the curves
cmds.loft(myCurve)

Assignment 01 A Pseudo Code

2009-06-08T15:48:00.003+02:00

for humans

boil the water
put rice in the water
wait 20 min

for computer

function boilWater:
with waterBoiler
fill with coldWater
if waterBoiler = full:
stop fill
turn waterBoiler.switch to „on“
when waterBoiler.switch = „off“:
execute function fillPot

function fillPot:
get pot
place pot right to waterBoiler
with waterBoiler:
move 30cm up
turn -90°
if pot = „full“
with waterBoiler:
turn 90°
move 15cm down
execute function makeRice

function makeRice:
desiredRice = 200
desiredTime = 20min
get rice
with rice:
place inside pot

start counting time
if time = 20min:
put pot in initial position
when waterBoiler.switch = „off“:
finish

Week 05 - file to download

2009-06-08T03:03:00.004+02:00

In our next class (08.06), we will start by learning how to detect, identify, and correct common scripting mistakes. For that you should download this Python script and save it in your script folder.

We will also take a look on how can we access sub-elements (vertices, faces, edges, control vertices, etc) of polygonal and Nurbs surfaces and apply transformations to them.

Assignment 02B

2009-06-08T02:57:00.001+02:00

As discussed in class on 25.05, the Assignment 2B is a simple exercise coming from the previous assignment.

Now that you created series of curves with variations (by using functions and arguments) go one step further and from these curves generate surfaces.

You can use one of the several surface generation commands in Maya, but always using commands which depend on curves to work - loft, revolve, planar, boundary, birail, extrude, etc.

You should create a few variations, and post on the blog along with your code and screenshots. Don't forget to explain a bit what you were trying to do as well!

As I had a problem to post this before, the deadline for this assignment is 14.06 by noon.

02B - Masha - Loft

2009-06-07T18:42:00.002+02:00


import maya.cmds as cmds
from random import *
from math import *

#numPoints = 60
numCurves = 40.0
radius = 10

def Curve(numPoints):
   
    #create an empty list to store the point
    points = []
    #loop and gather point information
    for i in range (1, numPoints, 1):
        amplitude = 1
        #function for the spiral curve
        x = sin(i)*amplitude
        y = 0
        z = i
        myPoint = (x,y,z)
        #store the point in the list
        points.append(myPoint)
   
    #create the curve
    myCurve = cmds.curve (d = 3, p=points) #degree 3
    return myCurve
   
def Curve2(numPoints):
   
    #create an empty list to store the point
    points = []
    #loop and gather point information
    for i in range (1, numPoints, 1):
        amplitude = 1
        #function for the spiral curve
        x = (cos(i)*amplitude)
        y = 0
        z = i
        myPoint = (x,y,z)
        #store the point in the list
        points.append(myPoint)
   
    #create the curve
    myCurve = cmds.curve (d = 3, p=points) #degree 3
    return myCurve   

myCrv = []   
y1 = 0
angle = 360/numCurves
x1 = radius
z1 = 10   
for i in range (0, numCurves+1, 1):
    if i%2 == 0:
        curve1 = Curve(50)
    else:
        curve1 = Curve2(50)
    #cmds.move (0,0,10, curve1)
    #cmds.rotate( 0, 0, 90, curve1, pivot=(0,0,0))
    cmds.rotate( 0, 0, angle*i,curve1, pivot=(x1,y1,z1))
   
    #cmds.move (j,j,0, curve1)
    myCrv.append (curve1)
print myCrv

cmds.loft(myCrv)

2009-05-28T20:48:00.000+02:00

O2A_DengLei

2009-05-25T16:25:00.004+02:00

I creat some curves but they all in the same position , i mean they are all overlap, i divide by hand

03 - Diana Pérez - Curves

2009-05-25T04:05:00.002+02:00

I tried this script to create curves out of the points created with the Math Function script I wrote before, but somehow it's not drawing the curves. Could you tell me what's wrong?

Thanks


#function to create curves on the fly
def curves(amplitude):
 #define initial variables
 numPoints = 600
 amplitude = 10
 
 #create an empty list to store the points
 points = []

 #loop and gather point information
 for i in range (0, numPoints, 1):
  #funtion for the curve
  x = sin(i)*i
  y = (cos(i)*sin(i))*i
  z = i*amplitude/10
  myPoint = (x, y, z)
  #store the point in the list
  points.append (myPoint)

 #create the curves
 myCurve = cmds.curve(d=3, p=points) #degree 3
 return myCurve

02B - Diana Pérez - Math Function

2009-05-25T04:03:00.002+02:00


#define initial variables
numPoints = 600
amplitude = 10

#loop and gather point information
for i in range (0, numPoints, 1):
 #funtion for the curve
 x = sin(i)*i
 y = (cos(i)*sin(i))*i
 z = i*amplitude/10
 myPoint = (x, y, z)
 cmds.spaceLocator (p = myPoint)(your code here)

02A - Diana Pérez - 3D Grid

2009-05-25T03:11:00.002+02:00

This is the assignment about making a 3D grid of points, which I couldn't make work the last time.


# GRID 3D
numColumns = 30
numRows = 30
numLevels = 30

for i in range (0, numColumns, 1):
 x = i
 for j in range (0, numRows, 1):
  y = j
  for k in range (0, numLevels, 1):
   z = k
   myPoint = [x, y, z]
   cmds.spaceLocator (p = myPoint)

02A_COSMOS_CURVES

2009-05-25T00:22:00.004+02:00

import maya.cmds as cmds

#craeting curves through points

from math import*

numRows = 20
numColumns = 20
num3rdDimension = 1
Points=[]
for i in range(0,numRows,1):
 x = (i)
 for j in range(0,numColumns,1):
     y = j
     for k in range(-1,num3rdDimension,1):
         z = sin(k*i*j)# this will craete an undulating grid
         myPoint=(x,y,z)
         points.append(myPoint)
     cmds.curve(d=3, p=points)

01B_COSMOS_POINTS

2009-05-24T23:45:00.005+02:00

import maya.cmds as cmds

#creating a 3d points grid using mathematical function

from math import*

numRows = 20
numColumns = 20
num3rdDimension = 1
for i in range(0,numRows,1):
x = (i)
for j in range(0,numColumns,1):
   y = j
   for k in range(-1,num3rdDimension,1):
       z = sin(k*i*j)# this will craete an undulating grid
       myPoint=(x,y,z)
       cmds.spaceLocator(p=myPoint)

02A_Natasha_from points to curves

2009-05-24T22:40:00.005+02:00

import maya.cmds as cmds

from math import *

from random import *

numRows = 5

numColumns = 7

numLevels = 5

amplitude = 4

points = []

#define curves first

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

x = tan(3*i)*amplitude

for j in range(0, numColumns, 1):

y = sin(2*j)*amplitude

for k in range(0, numLevels, 1):

z = k+amplitude

myPoint = [x,y,z]

print "point ", x, y, z

points.append(myPoint)

#create curves from points

cmds.curve(d=1, p=points)

02A - Deborah Kaiser - from point to curves

2009-05-24T21:58:00.001+02:00

Daniel, i took the function from the previous exercise but i can not get it to turn the points into a curve. What am i doing wrong?

Thnx!

def curves (amplitude):
numPoints = 200
amplitude = 1
points = []

for i in range (0,numPoints,1) : # (start, end, increment)ve
x = i + 3*i
y = cos (i)*amplitude*10
z = i*x*.001 + y*0.0001 +1
myPoint = [x,y,z]
points.append (myPoint)

myCurve = cmds.curve (d =3, p= points)
return myCurve

01A - Deborah Kaiser - making rice

2009-05-24T21:33:00.001+02:00

Sorry it is so overdo, i was not getting the e mails...

function cook rice:

function fillCup:
get cup
get rice bag
place cup right to rice bag
with rice bag:
move 20cm up
turn -90°
if cup = „full“
with rice bag:
turn 90°
move 20cm down

with cup:
get pan
turn 90°
let all content fall into pan

function fillCup:
get cup
get water jar
place cup right to water jar
with water jar:
move 20cm up
turn -90°
if cup = „full“
with water jar:
turn 90°
move 20cm down

with cup:
get pan
turn 90°
let all content fall into pan

execute function makeRice

function makeRice:
desiredSalt = 2
desiredTime = 10 min

get pan
with pan:
place on burner
turn burner on

start counting time
if time = 10min:
turn burner off

finish

01B - Deborah Kaiser - function, succesful attempt

2009-05-24T21:13:00.002+02:00

01B - Deborah Kaiser - function, succesful attempt

2009-05-24T21:11:00.000+02:00

from math import *

numPoints = 200
amplitude = 1

for i in range (0,numPoints,1) : # (start, end, increment)
x = i + 3*i
y = cos (i)*amplitude*10
z = i*x*.001 + y*0.0001 +1
myPoint = [x,y,z]
cmds.spaceLocator (p=myPoint)

01B - Deborah Kaiser - 3d grid, succesful attempt

2009-05-24T20:59:00.001+02:00

# 3d grid

numColumns = 30
numRows = 30
numHeights = 30

for k in range (0, numHeights,1):
z = k
for i in range (0, numColumns,1):
x=i
for j in range(0,numRows, 1):
y = j
myPoint = [x,y,z]
cmds.spaceLocator (p=myPoint)

02A_Clau_from points to curves

2009-05-24T17:34:00.003+02:00

In the first part of this exercise I took the code of the previous assingment, but instead of plotting points I generated curves (see image). Then I tried to convert the code into a function and return the value but didn't get a result. I have a Syntax Error. I don't know where is the mistake.

import maya.cmds as cmds
from math import*
from random import*
######################################################
#from points to curves
#defining initial variables
numRows= 40
numColumns=4
numLevels=12
amplitude = 12

#create an empty list to store the points
points= []

#defining the loop and gather information
for i in range (-1,numRows,1):
    x= sin(6*i)*amplitude
    for j in range (-1,numColumns,2):
        y= cos(i)*8
        for k in range (0,numLevels,1.5):
            z= k+1
                    myPoint=(x,y,z)
            #store the point in the list
            points.append(myPoint)

    #create the curve
    cmds.curve (d= 3, p= points) #curve degree 3 

######################################################
######################################################
#2ND PART
#####################################################
#defining initial variables
numRows= 40
numColumns=4
numLevels=12
amplitude = 12

#defining the curve
def Curves (numPoints, amplitude)

#create an empty list to store the points
points= []

#loop and gather point information
for i in range (-1,numRows,1):
    x= sin(6*i)*amplitude
    for j in range (-1,numColumns,2):
        y= cos(i)*8
        for k in range (0,numLevels,1.5):
            z= k+1
                    myPoint=(x,y,z)
            #store the point in the list
            points.append(myPoint)

    #creating the curve
    myCurve= cmds.curve (d=3, p=points) #curve degree 3

    #returning the name of the curve created
    return myCurve

2009-05-24T13:19:00.000+02:00



import maya.cmds as cmds
from math import *
from random import *

radius = 50                                    
numCirc = 10
amplitude = 2

def curves(amplitude):
 numPoints = 10
 points = []
 #loop and gather point information
 for i in range (1, numPoints, 1):
 #function for the spiral curve
  x = sin(i)*amplitude
  y = cos(i)*amplitude
  z = i*(i+1)
  myPoint = (x,y,z)
  #store the point in the list
  points.append(myPoint)
                  
 #create the curve
 myCurve = cmds.curve (d = 3, p=points) #degree 3 
 return myCurve
 
numCol = 10
numRows = 10                                              

def array(numCol):     
 #create empty list of curvs
 numCurvs = []                                             
 for j in range (0, 360/numCirc, 1):
  #create curve and then rotate
  crv = curves (j)
  cmds.rotate( 0, 10*j, 0, crv )
  #store the point in the list
  numCurvs.append (crv)
  cmds.select (numCurvs)# select the number of created curvs
 cmds.group (numCurvs, r=True)
   
#loop which made copies of created curvs in 2 directions
for m in range (0, numRows, 1):
 for n in range (0, numCol, 1):
  ar = array (1)
  s = randint(0,3)
  cmds.move (n*200, 0, m*200)
  #change the size of group of curvs
  cmds.scale (s,s,s)

squareINsquare (3)

2009-05-24T13:09:00.001+02:00

Anthony_random vertical points

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

For next class

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

As I told you last class, you should have an external script editor installed in your computer. Here is a list of nice editors, just choose one:

Crimson Editor (Win)
jEdit (Win+OS)
conTEXT (Win+OS)
BBEdit (OS)
Notepad++ (Win)

If you don't like any of those, feel free to chose any other you desire. Just be sure it has Python syntax highlighting.

It would be great if you could setup your computer to make it able work with external scripts. Here is a step-by-step tutorial on how to do that.

Assignment 02A

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

For this assignment you should do two things:

Take the code you developed for the assignment 01A and use it not to plot points, but to generate a curve
Convert this code into a function with arguments and return value, and use it in a loop to generate several different instances of your curve

Like usual, you should post the script along with screenshots. Don’t forget to comment all your code!

Delivery limit: 24.05 by noon.

w03 code: from points to curves

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

First we saw how to store the points coordinates generated in a loop into an empty list , and then use this list to generate a curve:

import maya.cmds as cmds

#generating  a straight line with even spacing between points
#define initial variables
numPoints = 20.0 #we use floats instead of integers so that the division below works properly
lineLength = 30.0
spacing = lineLength/numPoints #spacing between points


#create an empty list to store my points
#it is empty and will be "populated" in the following loop
points = []

#loop and get point coordinates
for i in range(0, numPoints, 1): #(start, end, increment)
	#define x y and z variables
	x = spacing*i #this will vary in each loop
	y = 0
	z = 0
	#put all these variables in a list
	myPoint = (x,y,z)
	
	print "point ", i, myPoint #shows in the output window the point coordinates which were generated above (just for your feedback)
		
	#append the point to the list (add it to the end of the list)
	points.append(myPoint)
	

print "points list = ", points  #for your feedback

#after the loop, I have all points in my "points" list
#now I can use the curve command to create my curve
#by using the points in "points"
cmds.curve(d=1, p=points) #creates a curve of degree 1 > linear curve
cmds.curve(d=3, p=points) #creates a curve of degree 3 > "curved" curve

Then we looked at some functions to make operations on list objects:

#some list functions
#first we create a new list
myList = ["Dessau", "Germany", "europe"]
print myList

#add element to list
myList.append("world")
print myList

#remove element from list
myList.remove("world")
print myList

#insert element in a specified place (specified by the index value)
myList.insert(1, "DIA")
print myList

#remove the last element
myList.pop()
print myList

#sort the elements of the list alphabetically
myList.sort()
print myList

Then we looked quickly at another function to gather point coordinated and generate a curve, which in this case resembles a helix:

#import all functions of the math module
#we will use the function sin() and cos()
from math import * 

#define initial variables
numPoints = 60
amplitude  = 2

# create an empty list to store the points
points = [ ]

#loop and gather point information
for i in range( 1, numPoints, 1) :
	#function for the spiral curve
	x = sin( i ) * amplitude
	y = cos( i ) * amplitude
	z = i / 10
	myPoint = (x,y,z)
	#store the point in the list
	points.append(myPoint)

#create the curve
cmds.curve( d = 3, p = points ) #degree 3

The we started to look at functions. We saw some simple examples of functions with and without arguments, and how to define and call them:

#FUNCTIONS - INTRO

#first we need to define the function
def myFunction( ):
	print "Hello world!"
	
#the code above doesn't do anything apparently
#but it stores the function definition on memory and 
#you can use it by calling the function:
myFunction()

#you'll see the command indented under the function
#be executed and printing the text we wrote

#functions get more interesting when we start
#to add arguments to it:

def printMessage( msg ):
	print msg
	
#the definition above means that this function
#takes as an argument the variable "msg"
#and inside the function we use this argument and print it

#to call this function you have to pass the argument in the function call:
printMessage( "this is my message" )

#you can also pass a pre-defined variable as the argument
#and python will do all the replacing and printing the same way:
a = "Another message"
printMessage( a )

Finally, we took the helix code and converted it into a function:

#converting the helix code into a function
#first import the math module if you still did not do so
from math import *

#then start the function definition
def curves( numPoints, amplitude ): 
	#it takes as an argument the value of the amplitude of the curve
	#and the number of points we want in the curve
	
	#then we just repeat the code of the helix
	# create an empty list to store the points
	points = [ ]
	
	#loop and gather point information
	for i in range( 1, numPoints, 1) :
		#function for the spiral curve
		x = sin( i ) * amplitude
		y = cos( i ) * amplitude
		z = i / 10
		myPoint = (x,y,z)
		#store the point in the list
		points.append(myPoint)

	#now as we saw, every command in Maya returns me a value
	#you can see which values each function returns, 
	#take a look at Help > Python Command Reference
	#and we can store this value in a variable to use it later:
	myCurve = cmds.curve( d = 3, p = points ) #degree 3
	
	#also in our own functions we can return values
	#in this case, we will return the name of the curve created above
	return myCurve

In the end, we saw how to use our new function to generate several curves on the fly. By using the arguments, we can vary each curve, and by using the return value, we can make modifications on the curve after its creation:

#function call in a loop
#first we define how many curves we want
numCurves = 10

#then run the loop
for i in range(0, numCurves, 1):
	#then inside the loop we call the function
	#and store its return value in the variable crv
	crv = curves(60, i ) #arguments (numPoints, amplitude)
	
	#as we stored the return value (in our case, name of the curve)
	#in the variable crv, we can later use it to
	#do anything we want with the curve
	#in this case, we'll move it along the x-axis:
	cmds.move(i*10, 0, 0, crv)

Week 03 - recap

2009-05-19T17:26:00.001+02:00

Yesterday in our third class we saw how to move from point generation to curves. We reused the code from last class and captured the point coordinates and instead of plotting points, we learned how to use them to generate curves.

Also, we learned about functions and their importance in scripting. We converted previous code into a function to see how it allows us to have more flexibility in our scripts.

Deborah & Diana Intent 2 - Doubt

2009-05-18T15:43:00.000+02:00

#We couldn't make this work either

from math import *

numPoints = 200
amplitude = 10
for i in range (0,numPoints,1) : # (start, end, increment)
x = (i*i + 3i + 5)
y = cos (i)*amplitude
z = i*x + y*y +1
myPoint = [x,y,z]
print myPoint
cmds.spaceLocator (p=myPoint)

Deborah & Diana Intent - Doubt

2009-05-18T15:34:00.001+02:00

# Daniel, it's not working. Can you tell us why?

numRows=20
numColumns=50
numLevels=70

for i in range (0,numRows,1):
x=i
print "x", i
for j in range (0,numColumns,1):
y=j
print "y", j
for k in range (0,numLevels,1):
z=k
print "z", k
myPoint = (x,y,z)
cmds.spaceLocator (p=myPoint)

Deng_Point

2009-05-18T15:00:00.003+02:00

Zhulei_ points in grids

2009-05-18T14:06:00.002+02:00

import maya.cmds as cmds
from math import *

numColumns=10

for k in range(0,numColumns,1):
    z=2 * k
    for i in range(0, numColumns,1):
        x=4*tan(i)
        for j in range(0,numColumns,1):
            y=3 * sin(j)

        myPoint= [x,3*sin(30*z),z]
        cmds.spaceLocator(p=myPoint)

clau_tower of points

2009-05-18T13:20:00.001+02:00

#creating a tower of points
numRows= 90
numColumns=42
numLevels=12
amplitude = 5
for i in range (-1,numRows,1):
    x= sin(6*i)*amplitude
    print "row", i
    for j in range (-1,numColumns,2):
        y= cos(i)*3
        print "column", j
        for k in range (0,numLevels,1.5):
            z= k+1
            myPoint=(x,y,z)
            cmds.spaceLocator(p=myPoint)

clau_grids of points

2009-05-18T12:09:00.001+02:00

#grid of points using nested loops
#rotating grids of points in "z" axis
numRows=12
numColumns=10
for i in range (0,numRows,2):
    x=i
    print "row", i
    for j in range (0,numColumns,1):
        y=j+1
        print "column", j
        z=1
        myPoint = (x,y,z)
        cmds.spaceLocator (p=myPoint

numRows=12
numColumns=10
for i in range (0,numRows,2):
    x=i/2
    print "row", i
    for j in range (0,numColumns,1):
        y=j+1
        print "column", j
        z=-1
        myPoint = (x,y,z)
        cmds.spaceLocator (p=myPoint)

numRows=12
numColumns=10
for i in range (0,numRows,2):
    x=-i/2
    print "row", i
    for j in range (0,numColumns,1):
        y=-j
        print "column", j
        z=2
        myPoint = (x,y,z)
        cmds.spaceLocator (p=myPoint)

numRows=12
numColumns=10
for i in range (0,numRows,2):
    x=-i
    print "row", i
    for j in range (0,numColumns,1):
        y=j
        print "column", j
        z=3
        myPoint = (x,y,z)
        cmds.spaceLocator (p=myPoint)

numRows=12
numColumns=10
for i in range (4,numRows,2):
    x=i
    print "row", i
    for j in range (0,numColumns,1):
        y=j+2
        print "column", j
        z=5
        myPoint = (x,y,z)
        cmds.spaceLocator (p=myPoint)

clau_plot points

2009-05-18T11:23:00.002+02:00

#random points loop using negative numbers
numPoints = 60
for i in range (-5,numPoints,1):
    x= randint(0,5) #this generate a random integer between 0 and 5
    y= randint (0,5)
    z= 0
    myPoint= (x,y,z)
    cmds.spaceLocator (p=myPoint)

numPoints = 100
for i in range (-5,numPoints,1):
    x= randint(0,5) #this generate a random integer between 0 and 5
    y= randint (0,5)
    z= 5
    myPoint= (x,y,z)
    cmds.spaceLocator (p=myPoint)

numPoints = 60
for i in range (-5,numPoints,1):
    x= randint(-5,0) #this generate a random integer between 0 and 5
    y= randint (-5,0)
    z= 10
    myPoint= (x,y,z)
    cmds.spaceLocator (p=myPoint)

numPoints = 100
for i in range (-5,numPoints,1):
    x= randint(-3,0) #this generate a random integer between -3 and 0
    y= randint (0,5)
    z= 10
    myPoint= (x,y,z)
    cmds.spaceLocator (p=myPoint)

numPoints = 180
for i in range (-5,numPoints,1):
    x= randint(-3,0) #this generate a random integer between -3 and 0
    y= randint (-5,5)
    z= -5
    myPoint= (x,y,z)
    cmds.spaceLocator (p=myPoint)

numPoints = 240
for i in range (-5,numPoints,1):
    x= randint(-5,10) #this generate a random integer between -5 and 10
    y= randint (-5,0)
    z= -3
    myPoint= (x,y,z)
    cmds.spaceLocator (p=myPoint)

qin-points

2009-05-17T21:56:00.003+02:00

2009-05-15T19:56:00.003+02:00

# create cylinder with nonuniform density of points

import maya.cmds as cmds
from math import *
from random import *

radius = 10                                     
numCirc = 10                                    
                                               
for n in range (0, numCirc, 1):                 
   y = n  #Number Of Elements By Y Axis                            
   for i in range (0, 36, 1):                 
         cmds.rotate( 0, 10*i, 0, pivot=(1, 0, 0) )
         x = radius   #create circle                         
         z = randint (0,2)                                 
         myPoint = [x, y, z]                   
         cmds.spaceLocator (p = myPoint)

Assignment 01B

2009-05-15T16:00:00.001+02:00

You should try to plot points in different ways. Here are some guidelines:

Try to use mathematical functions, like the sine or cosine functions we used in our example. Here are some useful sources:

Populate also in 3D: use the z axis!
Use random functions

Most important: use your imagination. And if you get stuck, try to delineate the logic behind your idea (remember the pseudo-code exercise) to try and make it clearer.

Also important: don’t forget to comment each line in your code (by using #, as we saw last class).

Post your results along with screenshots on the blog.

2009-05-14T20:01:00.000+02:00

numColumns = 10
numRows = 10
numHeights = 10

for k in range (0, numHeights,1):
     z = k
     for i in range (0, numColumns,1):
                x=i
                print i
                for j in range(0,numRows, 1):
                          y = j
                                         
                          myPoint = [x,y,z]
                          cmds.spaceLocator (p=myPoint)

w02 – Plotting point in space

2009-05-14T19:10:00.001+02:00

We can’t forget to always write in the beginning of our script:

import maya.cmds as cmds

We then saw how to create a variable to define the coordinates x,y,z of a point, and then use it to create a locator on that position.

# points x,y,z
myPoint = (0,0,0)  
cmds.spaceLocator() #this will create a locator in the default position (0,0,0)
cmds.spaceLocator(p=myPoint) #this will create a locator on the position define in myPoint
# change the point values
myPoint = (10,2,0) # keep z=0 to work in 2D only
cmds.spaceLocator(p=myPoint)

Next step was to create several points at once by using loops.

#how to create lots of points
#LOOPS

numPoints = 10 #define the number of desired points

for i in range(0, numPoints, 1): 
	cmds.spaceLocator()
	
#the loop above created 10 locator, but all of them on the default position
# I can place the locators in a variable position
# if I use the i variable as one of the position values
for i in range(0, numPoints, 1):
	myPoint = (i,0,0)
	cmds.spaceLocator(p=myPoint)

#other examples:
for i in range(0, numPoints, 1):
	myPoint = (i,i,0)
	cmds.spaceLocator(p=myPoint)

for i in range(0, numPoints, 1):
	myPoint = (i*10,i+5,0)
	cmds.spaceLocator(p=myPoint)

Then we used random functions to generate x,y values. For that, we first need to import the random module as we did for the maya.cmds module.

# import all the functions from the random module
from random import *

numPoints = 20
for i in range(0,numPoints,1):
	x = randint(0,10) #this generates a random integer between 0 and 10
	y = randint(0,10)
	z = 0
	myPoint = (x,y,z)
	cmds.spaceLocator(p=myPoint)

Then we saw an example of how to plot points in a straight lines with evenly spaced distances:

# how to plot points in a line of a certain length
numPoints = 20
lineLength = 30
#divide to get the space between the points
spaces = lineLength/numPoints
for i in range(0, numPoints, 1):
	x = spaces*i
	y = 0
	z = 0
	myPoint = (x,y,z)
	cmds.spaceLocator(p=myPoint)

We then saw how to create grids of points with rows and columns, by using nested loops.

## how to create grids of points > rows and columns
## NESTED LOOPS!

numRows = 10
numColumns = 10
for i in range(0, numRows, 1):
	x = i
	print "row ", i
	for j in range(0, numColumns, 1):
		print "column ", j
		y = j
		z = 0
		myPoint = (x,y,z)
		cmds.spaceLocator(p=myPoint)

Finally, we started to use mathematical functions to plot points, such as the sine and cosine functions. Again, we need to import the math module in order to be able to use mathematical functions in Python.

#how to use mathematical function to plot the points!
#sine function
from math import *

numPoints = 30
for i in range(0, numPoints, 1):
	x = sin(i)
	y = i
	z = 0
	myPoint = (x,y,z)
	cmds.spaceLocator(p=myPoint)
	
#add amplitude

numPoints = 60
amplitude = 2
for i in range(0, numPoints, 1):
	x = sin(i)*amplitude
	y = i
	z = 0
	myPoint = (x,y,z)
	cmds.spaceLocator(p=myPoint)

### spiral
numPoints = 60
amplitude = 2
for i in range(0, numPoints, 1):
	x = sin(i)/i*amplitude
	y = cos(i)/i*amplitude
	z = 0
	cmds.spaceLocator()
	cmds.scale(.1,.1,.1)
	cmds.move(x,y,z)

Week 02 - recap

2009-05-14T18:50:00.001+02:00

Last Monday we took a quick look at the Maya interface and learned how to start scripting with Python. We learned the difference between Python/MEL, and how to use the script editor window to input Python code in Maya.

We also saw different ways to get help on a particular command (quick help and command reference), and how to convert a MEL command from the output window into Python.

In the end, we saw how to use variables, loops, Math functions and Random functions to plot points (locators) on stage.

clau.pseudo-code again

2009-05-04T15:52:00.002+02:00

I realized what the problem was with my code flow and here I fix it. I hope it is ok. Again I have problems with identation, I don´t know how to controll it in order to have desired order of functions

Buy a train ticket to Berlin in a ticket-vending machine.

For humans

Go to the ticket machine
Press the button Ticket- Reservation
Select the departure and destination cities
Select the date and time
Select the number of travelers
Select the means of transport
Press search button
Select the journey that fit best with your request
Press purchase button and proceed to buy the ticket

For computers

function informationRequest:
with ticketMachine
press  ticketMachine.monitor
select ticketReservation.button
press departure.button
with the keyboard on the monitor
write Dessau
press DessauHbf.button    
press destination.Key
with the keyboard on the monitor
write Berlin
press BerlinHbf.button
desiredDay = Today
desiredTime = 23:00
desiredTravelers = Adult
desiredTravelers.number = 1
desiredTravel.class= secondClass
desiredMeansTransport = localTransport
        press search.button
execute function selectionJourney

function selectionJourney:
on standardFare.column and
along dep 23.17 arr 01:06.row  
press purchase.button
execute function buyTicket

function buyTicket:
get credit.Card 
 with credit.Card
move 20 cm right
move 5 cm up
        insert credit.Card inside ticketMachine.slot

when hear “beep” sound
remove creditCard
put creditCard in initial position
with keyboard near ticketMachine.slot
        write creditCard.pinCode
        press B button
wait monitor change image
move 60 cm down
open window
remove ticket
execute function remove ticket
else:
finish

scipting assignment1

2009-04-30T14:13:00.001+02:00

Frying two Eggs

For humans:
Open the eggs
Put some oil inside the pan
Put eggs in when the oil is hot
Put in some salt
Wait for five minutes

For computer:
function taking out eggs:
take two eggs out of the box
if the oven switch = off
switch it to “on”

function switching on the oven:
if the oven switch=off
switch the oven to “on”

function putting in oil:
put the pan on top of the oven
open the oil bottle
put 20ml oil inside the pan
if the time=2 minutes

function putting the eggs in:
get the eggs
open the shell of one egg
place it inside the pan
open the shell of another egg
place it inside the pan
start counting time

function adding some salt:
if the desired salt>0
get the salt bag
open the salt bag
place 2mg on the top of one egg
place 2mg on the top of another egg
if time=5 minutes
else:finish

assignment I

2009-04-26T16:49:00.002+02:00

have a bath
##########################
human instruction
open geyser to boilwater
take a bath
dry body
####################
computer instruction
function boilwater
with geyser
set up the temperature
turn geyser.switch to "on"
when geyser.temple = 50
execute function have a shower
function take a bath
place body in bath
open geyser tap
if all body be covered by water = yes
turn off geyser tap
start counting time
if time = 15min
execute function dry body
function dry body
desiredbodyhumidity = 5%
desiredglobonskin = 0
get body out of bath
use bath towel wipe body
if desiredbodyhumidity > 5%
execute function dry body
if desiredglobonskin > 0
execute funcion dry body
else:
finish

01A_BEDZRA_Pseudo-Code: washing a plate

2009-04-26T12:06:00.007+02:00

for humans

make soapy water
put plate in
scrub
rinse plate with fresh water

for a computer

function make soapyWater:
with kitchenSink
cover wasteWater drain
turn coldWater tap to ,,on"
if kitchenSink = 25%full:
 turn coldWater tap to ,,off"
 lift liquid soap
 with liquidSoap:
   position over kitchenSink
   turn -180°
   add 4 drops  to coldWater
   turn 180°
   place on counterTop
   stair coldWater
     execute function putPlate

function putPlate:
lift plate
position plate over kitchenSink
lay gently in kitchenSink
execute function scrubPlate

function scrubPlate:
get sponge
with Sponge:
dip in soapyWater
stroke over plateSurfaces
place on counterTop
execute function rinsePlate

function rinsePlate:
open wasteWater drain
when wasteWater = 0:
cover wasteWater drain
turn coldWater tap to ,,on"
if kitchenSink = 50%full:
 turn coldWater tap ,,off"
 move plate in coldWater
If  plateSurfaces = clean:
  place on counterTop
  finish

boiling noodles

2009-04-25T19:44:00.002+02:00

FOR PEOPLE:
boil the water
put noodles into the water
put them in a plate
add sauce if you want
FOR COMPUTER:
function boilWater:
with waterBoiler,
fill with cold water,
if waterBoiler=full:
stop fill
turn water Boiler switch to"on"
when water boiling
execute function put Noodles
function put Noodles:
desiredTime=10min
get noodles
with noodles:
place inside waterBoiler
start counting time
when Time=10min
turn waterBoiler switch to off
execute function fill plate
function fill Plate
get plate
place plate right to waterBoiler
with water Boiler:
move 20cm up
turn-90
if plate="full"
with waterBoiler:
turn90
move 20cm down
execute function add Sauce
finction add Sauce
desired Sauce=1
get sauce
with sauce
place inside plate
if desired Sauce>0
execute function add sauce
else:
finish

Pseduo-Code

2009-04-25T19:23:00.003+02:00

Pseudo-Code for how to follow our Generative Scripting I

For humans:

Take a laptop to get Internet
Register account in Google Website
Follow the Generative Scripting I

For computer:

Function get Internet:
With a computer
Press on-off of computer
Desired time= 2 min
If desired time < 2:
Enter Windows system
Else:
Reopen
Cable plug in
Open the Internet window
Input "www.Google.com" into Address field
Press "Enter"
Desired time = 5 sec
If desired time < 5 sec:
Connect the Internet
Else:
Reconnect
Execute function register account
Function register account
Click "sign in"
Input Email address
Press "Tab"
Input password
Click “sign in”
Desired time = 5 sec
If desired time < 5 sec:
Register done
Else：
Rewrite User name (Email) and Password
Execute function register account
Function follow the Scripting I Group
Input the "http://gs-i blogspot.com" into address filed
Press "Enter"
Click "view blog"
Click "Follow"
Input email and password
Click sign in
Desired time = 5 sec
If desired time < 5 sec:
Execute function follow Scripting I Group
Else:
Finish.

2009-04-25T15:03:00.000+02:00

clau.pseudo-code

2009-04-24T20:05:00.003+02:00

Although I tried many times that the format looked nicer (using/not using tab) with the Format for blogging, I couldn´t achieve it. I don´t know what is the mistake. But here is the exercise.

Buy a train ticket to Berlin in a ticket-vending machine.
For humans

Go to the ticket machine
Press the button Ticket- Reservation
Select the departure and destination cities
Select the date and time
Select the number of travelers
Select the means of transport
Press search button
Select the journey that fit best with your request
Press purchase button and proceed to buy the ticket

For computer

function informationRequest:
with ticketMachine
press  ticketMachine.monitor
select ticketReservation.button
press departure.button
with the keyboard on the monitor
write Dessau
press DessauHbf.button    
press destination.Key
with the keyboard on the monitor
write Berlin
press BerlinHbf.button
desiredDay = Today
desiredTime = 23:00
desiredTravelers = Adult
desiredTravelers.number = 1
desiredTravel.class= secondClass
desiredMeansTransport = localTransport
        press search.button
execute function informationRequest

function selectionJourney:
on standardFare.column and
along dep 23.17 arr 01:06.row  
press purchase.button
execute selectionJourney

function buyTicket:
get credit.Card 
 with credit.Card
move 20 cm right
move 5 cm up
        insert credit.Card inside ticketMachine.slot

when hear “beep” sound
remove creditCard
put creditCard in initial position
with keyboard near ticketMachine.slot
        write creditCard.pinCode
        press B button
wait monitor change image
move 60 cm down
open window
remove ticket
execute buyTicket
else:
finish