import os
import xml.etree.ElementTree as etree

def scene_version(PATH_OF_THE_SCN):
	version = ""
	if os.path.exists(PATH_OF_THE_SCN+"toc"):
		tree = etree.parse(PATH_OF_THE_SCN+"toc")
		root = tree.getroot()
		version = root.get("xsi_version")
	else:
		p = subprocess.Popen( 'printver %s' % PATH_OF_THE_SCN, stdout=subprocess.PIPE )
		stdout = p.stdout.readlines()
		version = stdout[-1].split(':')[1].lstrip().rstrip()
	return version

print scene_version("C:\\Users\\ChrisChia\\Documents\\softimage\\projects\\ice_test\\Scenes\\point_index_to_location2012.scn")

8. Expand grid1 in the explorer window. Create a localised material for grid1.
9. Click on the connection plug of diffuse and choose the right Texture Projection and image.

si = Application

def getCloudData(obj, attName, index):
	pc = si.Dictionary.getObject(obj)
	geo = pc.ActivePrimitive.Geometry
	pp = geo.GetICEAttributeFromName(attName)
	data = pp.GetDataArrayChunk( 0, index+1 )
	j = 0
	for i in data:
		if j==index:
			si.logmessage(str(i.X) + " " + str(i.Y) + " " + str(i.Z))
			return(i.X, i.Y, i.Z)
		j = j + 1
	return(0, 0, 0)

getCloudData("pointcloud", "PointPosition", 500)

Hint: if you have only imported 2 or less inputs for the animation sources, you can always reuse the same animation source for the 3 inputs. But make sure that the excess input ports are removed.

Here’s a workflow on how to get it to work for Softimage 2013 x64.
Softimage 2013 is shipped with Python 2.6 and hence you have to find the right PIL for it.
If you are running Softimage 2013 x86, then you can get PIL (32bit) from:
PIL (32bit)

However if you are running Softimage 2013 x64, then you’ll have to get PIL (64bit).
Christoph Gohlke from University of California, Irvine, has recompiled and released PIL for 64bit.
You can download it from:
PIL (64bit)

You also have to make sure that your computer sees Python 2.6 in your registry before you can even install it.
If you need help in installing PIL on computer which does not have Python 2.6 (which is needed for Softimage 2013) and you have no intention in installing a standalone Python (apart from the one which is shipped in Softimage 2013),
you can find a tutorial guide here

Lastly, you need to make sure that you add the python system path to the right folder directory.

I did a quick test on PIL and it works on my machine:

from siutils import log
import sys
log(sys.path)  #ensure that you can see PIL library folder here

import PIL
import Image, ImageDraw
im = Image.open("C:\\lena.ppm")

draw = ImageDraw.Draw(im)
draw.line((0, 0) + im.size, fill=128)
draw.line((0, im.size[1], im.size[0], 0), fill=128)
del draw

im.save("C:\\ab.png", "PNG")</blockquote>

There is a workaround for now (while waiting for our Dev to work on it):

1. Go to Explorer and expand the Crowd model
2. Expand Actors_Copies group and select your model.Actors_Copies
3. Expand the model.Actors_Copies and double click on the Material.
4. A pop-up dialog will prompt you to make a local copy of the shared properties of the material.
5. Choose yes.
6. Right click on the Connection Socket of the color attribute of Diffuse, and select Image
7. Under Texture Projection, Choose the right Texture Projection Map.
8. Also ensure that the correct texture is picked.

The new model will be added to the existing crowd.

• Select the geometry
• Crowd > Add Emitter from Selection
• Simulate > Pedestrian / Stadium Crowd

Emit Evenly from Geometry Ice Operator allows user to custom some basic behaviour of Crowd:
Some of the important settings have been circled in red.
1. You can access the PPG from the ice node in the Ice Tree.
2. You can set the number of actors in the crowd in the emission control.
3. You can use a weight map from your geometry emitter to control the place where crowd is created.
4. You can constraint the crowd within the boundary of the emitter.
5. You can set any crowd that is outside the boundary to be removed.
6. You can control the size of the crowd.
7. You can set the initial state of the crowd.

• Crowd/Simulation/Point_Cloud/Shape_Instance_Skinning: This Ice Tree is where the instance shapes get the skinning
• Crowd/Simulation/Point_Cloud/Skeleton_Simulation: This Ice Tree transfers the data of the character’s rig/skeleton to the crowd.
• Crowd/Simulation/Point_Cloud/Particle_Simulation: This Ice Tree contains particle data to compute collision avoidance between the particles and to drive the “crowd” particles to the target goals.
• Crowd/Simulation/Point_Cloud/Emit_Evenly_from_Geometry: Main heart of the simulation which allows user to make changes to the Crowd Simulation (just like any other Ice Simulation).
• Crowd/Simulation/Point_Cloud/Get_Animations_Sources: I would say this is the 2nd important Ice Tree which allows user to change the animation of the crowd without going through the PPGs.
• Crowd/Actors_Proxies/Pedestrian_Mesh/Actor_Copies/Crowd_Skinning: This Ice Tree operates the crowd skinning on the geometry mesh
• Crowd/Actors_Proxies/Pedestrian_Mesh/Actor_Copies/Duplicate_Actor_Geometry: This Ice Tree duplicates actor geometry on the “Crowd”.
• Pedestrian/Mesh/Set_Mesh_Proxy: This Ice Tree copies the Actual Model and set mesh proxy for the “Crowd” mesh.
• Pedestrian/Mesh/Set_ICE_Materials: This Ice Tree copies the material / color of the different clusters of the Actual Model and transfer the data to the Crowd (proxy mesh).
• Disc/Set_Emitter_Data: This Ice Tree determines the crowd’s initial position in the simulation

The above example illustrates a Ice Crowd scenario that has the following in the scene:

• Disc: Polygon Geometry used as a Crowd Emitter
• Pedestrian: Actual Model from which crowd is instanced from
• Crowd: The final result of crowd simulation