I put some effort into commenting the script accordingly, so that it may be used for learning purposes.

cheers!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// query the geometry data
var obj = selection(0);
var geo = obj.Activeprimitive.Geometry;
var polygons = geo.Polygons;
 
// create an array to track which polygon has been visited
var polygonVisited = [];
var polygonsLeft = polygons.Count;
 
// fill up the array to say: "no polygon has been visited yet"
for(var i=0;i<polygons .count;i++)
{
	polygonVisited[i] = false;
}
 
// create some helper variables
var clusterIndices = [];
var currentRow = [];
 
// log the start of the process
logmessage("Starting with "+polygonsLeft+" polygons...");
 
// loop until there are no polygons left
// or there are still items in the cluster array
while(polygonsLeft > 0 || clusterIndices.length > 0)
{
	// if there are no items in the next row...
	if(currentRow.length == 0)
	{
		// if there are items in the cluster index array
		if(clusterIndices.length > 0)
		{
			// log the creation of the cluster
			logmessage("Creating cluster with "+clusterIndices.length+" elements...");
 
			// create a new mesh containing all of these polygons
			// first, create an array containing all pointindices
			// and two additional point hash arrays
			// of which one is used to determine if a point is already used
			// and the second one is used to map the original index to the new one
			var pointIndices = [];
			var pointUsed = [];
			var pointNewIndex = [];
 
			for(var i=0;i<clusterIndices.length;i++)
			{
				var poly = polygons.item(clusterIndices[i]);
				var pointIndexArray = poly.points.indexArray.toArray(); //(VBS to JScript conversion)
 
				// loop through all points and check if it they are used
				for(var j=0;j<pointIndexArray.length;j++)
				{
					var index = pointIndexArray[j];
					if(!pointUsed[index])
					{
						pointNewIndex[index] = pointIndices.length;
						pointIndices.push(index);
						pointUsed[index] = true;	
					}
				}
			}
 
			// now, create the array of the positions of all points of this island
			var islandPos = [];
			for(var i=0;i<pointIndices.length;i++)
			{
				var point = geo.points.item(pointIndices[i]);
				islandPos.push(point.position.x);
				islandPos.push(point.position.y);
				islandPos.push(point.position.z);
			}
 
			// now we need to create the description of the polygons
			var islandPoly = [];
			// for that we loop over the polygons of the island again
			// and record their pointindices, well, actually the remapped
			// indices (given by the pointNewIndex hash array)
			for(var i=0;i<clusterIndices.length;i++)
			{
				var poly = polygons.item(clusterIndices[i]);
				var pointIndexArray = poly.points.indexArray.toArray(); //(VBS to JScript conversion)
 
				// first add the number of points of this polygon 
				// to this polygon's description
				islandPoly.push(pointIndexArray.length);
 
				// now add the remapped index for each point to the description
				for(var j=0;j<pointIndexArray.length;j++)
				{
					var index = pointIndexArray[j];
					islandPoly.push(pointNewIndex[index]);
				}
			}
 
			obj.Parent.AddPolygonMesh(islandPos,islandPoly,obj.name+"_island");
			clusterIndices = [];
 
			// if there are no polyons left we can stop now
			if(polygonsLeft == 0)
				break;
		}
 
		// loop over the polygons and try to find 
		// one which hasn't been visited yet
		for(var i=0;i<polygons.Count;i++)
		{
			if(polygonVisited[i] == false)
			{
				currentRow.push(i);
				clusterIndices.push(i);
				polygonVisited[i] = true;
				polygonsLeft--;
				break;
			}
		}
	}
 
	// define the nextrow after the current row
	var nextRow = [];
 
	// loop over all items in the current row
	for(var i=0;i<currentRow.length;i++)
	{
		var polygon = polygons.item(currentRow[i]);
		var neighbors = polygon.NeighborPolygons();
 
		// loop through all of the neighbors and add them to the nextRow
		for(var j=0;j<neighbors.count;j++)
		{
			// check if the neighbor has been
			// visited yet
			var neighbor = neighbors.item(j).index;
			if(polygonVisited[neighbor]==false)
			{
				// add the neighbor to the next row
				nextRow.push(neighbor);
				clusterIndices.push(neighbor);
				polygonVisited[neighbor] = true;
				polygonsLeft--;
				break;
			}
		}
	}
 
	currentRow = nextRow;
}
 
selection.SetAsText(obj.name+"_island*");

The weird wirings in my brain. That’s what.

Back to the beginning

At the end of last October Steven Caron sent me a plugin he wrote that allows an XSI user to drag and drop .obj files into the interface and have them import automatically according to settings in a custom preference. I was a bit swamped at the time putting up the infrastructure for a new VFX department at my new workplace. And then I totally forgot about it… Sorry Steven.

This past week Steven politely reminded me of my omission so I ran back to my email archives and installed it. Neat piece of work.

I didn’t want to just post up the tool as I don’t really see this blog being about tool distribution but about how said tools work and the neat tricks they use. With that philosophy in mind I cracked open Steven’s tool to dig out some of its sexier bits and maybe demystify them for the audience.

To my surprise there weren’t any sexy bits. Please don’t get me wrong, the tool works superbly, how much more intuitive can you get than drag and drop. The tool is also extremely well written, concise and straightforward. There just aren’t any weird tricks or convoluted syntax or things that would generally have you scratching your head.

Then I noticed this in his version trapping code (yes folks, the drag and drop event is new in XSI 6.5):

27
28
29
30
31
32
33
34
35

if int( tXSIVersion[0] ) < 6:
    xsiPrint( xsi.Version() + " doesn't support the 'siOnDragAndDrop' event!" )
    xsi.UnloadPlugin( in_reg.name, True )
    return False
else:
    if int( tXSIVersion[1] ) < 5:
        xsiPrint( xsi.Version() + " doesn't support the 'siOnDragAndDrop' event!" )
        xsi.UnloadPlugin( in_reg.name, True )
        return False

About the waste part

Bare with me…

Last week I was reading a really neat article in Wired by Chris Anderson entitled “Free! Why $0.00 Is the Future of Business”. I invite you to read it, especially the section beginning on page two: Waste and Waste Again.

…So if in the seventies you had to be really tight with your algorithms and optimizations because cpu cycles were so scarce, today I guess we can really waste them. Just the other day I setup an 8 core MacPro with BootCamp, XP x64 and XSI. Whatever I did to the machine, I swear, I could hear it yawn because it was bored.

Which brings me back to Steven’s code. Could it have been written like so:

27
28
29
30

if int( tXSIVersion[0] ) < 6 or int( tXSIVersion[1] ) < 5:
    xsiPrint( xsi.Version() + " doesn't support the 'siOnDragAndDrop' event!" )
    xsi.UnloadPlugin( in_reg.name, True )
    return False

Is it more or less readable by a programmer?
It probably executes in a few cycles less but is it worth it?
Python is interpreted so if the parser goes through this version quicker, is it worty of any mention?
Is it more maintainable?

This example is really simple but in a bigger project, or with more complex cases, should we really be worrying if today transistors and cpu cycles are so cheap as to not even matter anymore

When I'm stuck on a piece of code or when I hit that time of the afternoon where most of my energy is diverted to digesting, I'll often reread my code and tighten it, remove redundancy, put in functions instead of copying a few lines in two locations, consolidate if statements, etc... One of my colleagues used to tell me that "Premature optimization is the root of all evil."

Honestly, if I look back at a good proportion of the code I have written, it either executes in a blink of an eye on today's computers or it sits there waiting 90% of the time for user interaction. Should we, as technical XSI users, XSI scripters or TDs, even worry about optimization from a performance standpoint or a maintainability standpoint? What can be considered a good optimization and what should be considered a bad one?

And now that you're really wondering what I'm rambling about, I'll shut up and let you download Steven's addon.

Have a good weekend. ]]> http://www.softimageblog.com/archives/249/feed 19 http://www.softimageblog.com/archives/93#utm_source=rss&utm_medium=rss&utm_campaign=developing-a-modeling-script-start-to-finish http://www.softimageblog.com/archives/93#comments Sat, 18 Mar 2006 16:39:11 +0000 Helge Mathee http://www.xsi-blog.com/?p=93 Hey all.

In this article I want to discuss the full development process of a custom modeling tool, called “EdgeExtrudePro”.

What you need:

I going to describe the full process, so be warned, it is going to be a long trip. The article is meant for the experienced scripted as well as the start-up scripting TD, but to follow the descriptions, you’ll have to know at least the fundamentals of JScript, Arrays (the multiple usages of them, look-up tables etc) and some basic vector math. I am going to explain the math used for this tool briefly, but this is not a math primer. ;-)

What you will get out of it:

This article will get you an understanding of selection checking and user-error handling. Moreover you can learn some of the basic relationships inside of 3D geometry, such as edge – polygon adjacency, polygon-island boundaries, edge-to-edge connections and some more.

Ok – so let’s start.

The name of the tool was not my idea, so I am just going to keep it that way. What the tool does really, is using a curve to cut a hole into geometry. Here’s a link to the original tool (For Maxon’s Cinema 4D) http://www.vreel-3d.de/plugins/EEPro/EElinks.html

Here’s an animated gif from the webpage above, demonstrating the functionality. We are focusing on the part with the red circle.

Looking the animated gif, I can see the following steps to reach our goal:

• Get a polygonmesh and a curve
• Put the curve onto the surface of the mesh
• Delete all polygons “below” the curve’s shape
• Extrude the resulting new boundary to fit the curve

What’s really important when developing a custom tool, is to focus on what really has to be done. As you don’t know all of the steps before you start working on them, it is still good to partition the huge task into smaller tasks, and partition them again, until you have a task you can easily solve. For now, I am just going to rephrase our tasks a little bit.

• Check the selection for a polygonmesh and a nurbscurvelist
• ShrinkWrap the nurbscurvelist onto the polygonmesh.
• Delete all polygons “below” the nurbscurvelist’s shape
• Extrude the resulting new boundary to fit the curve.

Ok – sounds better. Let’s start with the first one.

1. Check the selection for a polygonmesh and a nurbscurvelist

I don’t want to use picking sessions or anything similar right now, I will simply force the user to have two objects selected. Moreover, there are certain conditions I want to be checked. They look like this:

• The number of objects selected has to be 2
• The first object has to be a polygonmesh
• The second object has to be a nurbscurvelist
• The nurbscurvelist has to be closed
• The nurbscurvelist has to contain only one curve

Allright, putting all of this into a simple JScript function, it looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// checks if the selection is correct
function js_checkSelection()
{
	// check if we have two objects
	if(selection.count!=2)
	{
		logmessage("Please select a polygonmesh and a curvelist!");
		return false;
	}
 
	// check if the first one is a polygonmesh
	if(selection(0).type!="polymsh")
	{
		logmessage("The first object you selected is not a polygonmesh!")
		return false;
	}
 
	// check if the second object is a curvelist
	if(selection(1).type!="crvlist")
	{
		logmessage("The second object you selected is not a curvelist!");
		return false;
	}
 
	// check if the curve is closed
	if(!selection(1).ActivePrimitive.Geometry.Closed)
	{
		logmessage("The curve you selected is not closed!");
		return false;
	}
 
	// check if the curvelist contains only one curve
	if(selection(1).ActivePrimitive.Geometry.Curves.count!=1)
	{
		logmessage("The curve you selected contains more or less curves than 1!");
	}
 
	// if everything went well - just return true
	return true;
}

Allright – let’s go to number 2.

2. ShrinkWrap the nurbscurvelist onto the polygonmesh.

For the projection I am just going to use XSI’s ShrinkWrap. There’s the option to implement the projection myself, but I try to rely on existing functionality as much as possible – to speed up the implementation process. Just ShrinkWrapping is not going to do the full job though. So these are the considerations:

• The two objects have to be in the same reference space
• After projection / shrinking the curve onto the surface we want to freeze it, because we might change the topology the curve was shrinked onto

The only thing I really did is manually shrink-wrapping a curve onto a polygonmesh, copy & pasting the code out of the script editor history and adding some more steps. Here’s my shrinking function:

1
2
3
4
5
6
7
8
9
10
11
12
13

//apply the shrinkwrap
function js_applyShrinkWrap(curve,mesh)
{
	// if the curve is not parented to the mesh yet
	// parent it in... 
	// we have to do this to simplify the reference frames
	if(curve.parent.fullname!=mesh.fullname)
		ParentObj(mesh,curve);
	ResetTransform(curve, siCtr, siSRT, siXYZ);
	var op = ApplyOp("ShrinkWrap", curve+";"+mesh, 3, siPersistentOperation);
	SetValue(op+".proj", 6);
	FreezeObj(op);
}

3. Delete all polygons “below” the nurbscurvelist’s shape

Okay – so now this is where it gets complicated. I am going to explain how we find what needs to be deleted by partitioning the task again:

• Find all edges which are crossing the curve
• Find all adjacent polygons to these edges
• Find the two boundaries of this resulting polygon island (inner and outer boundary)
• Find out which boundary is shorter and call it the inner boundary
• Get all of the polygons inside of the inner boundary + the polygons from the crossing edges
• Delete them

I need a function to figure out if an edge crosses a curve. This seems to be a hard one, it’s not really though. Let’s look at it:

To find out if an edge is crossing a curve, we need to find out if the two points of the edge are on the “opposite” sides of the curve. If they are, the edge crosses the curve. To do that, I will find the closest points on the curve for the two edge-points, find their center, and the center’s point on the curve. Then I take the tangent of the curve at this position and build a plane which cuts the edge in 3D, or not. If it cuts the edge, it crosses the curve.

In the illustration, the blue line is the curve, the green grid marks the plane used for the intersection calculation and the red line is an example edge.

And here’s the javascript function:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

// check if an edge crosses a curve
function js_doesEdgeCrossCurve(edge,curve)
{
	// get the two positions
	var edgePos1 = edge.points(0).position;
	var edgePos2 = edge.points(1).position;
 
	// get the U value of the closest points on the curve
	var edgeU1 = curve.GetClosestCurvePosition2(edgePos1).toArray()[2];	
	var edgeU2 = curve.GetClosestCurvePosition2(edgePos2).toArray()[2];	
 
	// get the two positions on the curve of the closest points	
	var edgeOnCurve1 = curve.curves(0).EvaluatePosition(edgeU1).toArray()[0];
	var edgeOnCurve2 = curve.curves(0).EvaluatePosition(edgeU2).toArray()[0];
 
	// get the position in the center of the two edge on curves
	var edgePos = XSIMath.CreateVector3();
	edgePos.Add(edgeOnCurve1,edgeOnCurve2);
	edgePos.ScaleInPlace(0.5);
 
	// get the U value of the closest point on the curve to this one
	var edgeU = curve.GetClosestCurvePosition2(edgePos).toArray()[2];	
	// get the position of that point
	var edgeOnCurve = curve.curves(0).EvaluatePosition(edgeU).toArray()[0];
	// get the tangent of the curve at that position
	var tangent = curve.curves(0).EvaluatePosition(edgeU).toArray()[1];
 
	// get the U value of the closest point on the curve to this one
	var normal = XSIMath.CreateVector3();
 
	// make the normal the connection of the first point
	// and the position on the curve
	normal.Sub(edgePos1,edgeOnCurve);
	// cross this result with the tangent to retrieve the bi-normal
	normal.Cross(normal,tangent);
	normal.NormalizeInPlace();
	// cross this result with the tangent again to retrieve the normal
	normal.Cross(normal,tangent);
	normal.NormalizeInPlace();
 
	// define two connection vectors
	var con1 = XSIMath.CreateVector3();
	var con2 = XSIMath.CreateVector3();
 
	// the first is the connection between the edgepos1 and the position on the curve
	// resp. for the second
	con1.Sub(edgePos1,edgeOnCurve);
	con2.Sub(edgePos2,edgeOnCurve);
 
	// get the distance of the two connection vectors to the plane defined by the normal
	var dist1 = con1.Dot(normal);	
	var dist2 = con2.Dot(normal);	
 
	// if the points are on different sides of the plane
	// (if one distance is larger and the other one less than 0)	
	if( (dist1>=0 && dist2< =0) ||
		(dist1<=0 && dist2>=0))
	{
		// the edge crosses the curve
		return true;
	}
	else
	{
		// nope - it doesn't cross
		return false;
	}
}

To find all of the edges, I create a helper function which simply calles js_doesEdgeCrossCurve a couple of times, like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// returns an array of indices of the edge crossing the curve
function js_getAllCrossingEdges(meshObj,curveObj)
{
	// define an array for all of the edges crossing the curve
	var result = new Array();
 
	// get the geometry of both objects
	var mesh = meshObj.ActivePrimitive.Geometry;
	var curve = curveObj.ActivePrimitive.Geometry;
 
	// loop through
	for(var i=0;i<mesh .edges.count;i++)
	{
		// get the edge
		var edge = mesh.edges(i);
		// if it crosses, put in the result array
		if(js_doesEdgeCrossCurve(edge,curve))
		{
			result[result.length] = i;
		}
	}
 
	return result;
}

Result:

Now as we have all edges crossing the curve, we need to find all of the adjacent polygons. As adjacency is a simple task, I am not going to use XSI’s command for selecting adjacent components, but implement a JScript function to do the job. It is simply looping over all edges and finding all polygons adjacent to each edge.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// gets all adjacent polygons of an edge-index-array
function js_getAdjacentPolygons(meshObj,indices)
{
	// get the geometry of the meshObj
	var mesh = meshObj.ActivePrimitive.Geometry;
 
	// an array which is used as a hash-table
	// for all of the polyons used
	// example: if polyUsed[4] == true, that means
	// the polygon with the index 4 is adjacent
	var polyUsed = new Array();
 
	// loop through all edge indices	
	for(var i=0;i<indices .length;i++)
	{
		// get the edge
		var edge = mesh.edges(indices[i]);
 
		// get the collection of neighborpolygons of this edge
		// note: an edge can have only one polygon linked to it
		// that means it is a boundary edge... if that happens,
		// just return false to tell the calling function that
		// we have to stop now.
		var nbPolies = edge.NeighborPolygons();
		if(nbPolies.count&lt;2)
		{
			logmessage("We cannot cut a boundary!");
			return false;
		}
		for(var j=0;j<nbPolies.count;j++)
		{
			polyUsed[nbPolies(j).index] = true;
		}
	}
 
	// define the result array
	var result = new Array();
	for(var index in polyUsed)
	{
		result[result.length] = index;
	}
 
	return result;
}

Result:

To find the two boundaries and determine which one is shorter, I loop through all edges of the polygons I just got from the adjacency function and count their occurences. If I find an edge which is used only once, it is a boundary of the polygon-island. To find the two different boundaries, I start with one edge, mark it as non-boundary and find the next connected edge which is a boundary. I repeat that step until I reach the edge I started with. Those edges all together are one boundary (either the inner or the outer one – I don’t know that yet). Now I can just take all of the edges and define them as “the other” boundary. By comparing the number of elements in both boundaries, I can find the shorter one and define it as “the inner boundary”.

First – I need a function which tells me if two edges are connected or not:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// returns true if two edges are connected
function js_areEdgesConnected(edge1,edge2)
{
	// if the edges are the same, we don't call them "connected"
	if(edge1.index==edge2.index)
	{
		return false;
	}
 
	// compare all points of the one edge with
	// all points of the other one
	// if there is any match, the edges are connected
	if(
		(edge1.points(0).index==edge2.points(0).index) ||
		(edge1.points(0).index==edge2.points(1).index) ||
		(edge1.points(1).index==edge2.points(0).index) ||
		(edge1.points(1).index==edge2.points(1).index))
	{
		return true;
	}
	return false;
}

Second – I need a function which does what I described above: Find the shorter (inner boundary) and its elements:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

// returns the shortest edge boundary of a given polygon index array
function js_getShortestEdgeBoundary(meshObj,indices)
{
	// get the geometry of the mesh
	var mesh = meshObj.ActivePrimitive.Geometry;
 
	// this is a hash-table which counts the usage of edges
	// if the counter is one, the edge is a boundary(!)
	var edgeCount = new Array();
 
	// loop through all given polygons by index
	for(var i=0;i<indices .length;i++)
	{
		// get the polygon (called facet here)
		var facet = mesh.facets(indices[i]);
 
		// get the polygons edges
		var edges = facet.edges;
		for(var j=0;j<edges.count;j++)
		{
			// put the index of the edge into the edgeCount array
			// if it is not there yet, otherwise increment the number there
			if(!edgeCount[edges(j).index])
				edgeCount[edges(j).index] = 1;
			else
				edgeCount[edges(j).index]++;
		}
	}
 
	// define two arrays for the boundaries
	var boundary1 = new Array();
	var boundary2 = new Array();
 
	// now we start by putting the first boundary edge into the boundary1 array
	for(var index in edgeCount)
	{
		// if the edge is a boundary
		if(edgeCount[index]==1)
		{
			// put the edge as the first element in the boundary1 array 
			boundary1[boundary1.length] = index;
			// set the edge to be nothing / so it looks like it is not a boundary anymore
			// because we want to use it only once
			edgeCount[index] = 0;
			// and leave the loop afterwards...
			break;
		}
	}
 
	// check again if we have an element
	if(boundary1.length!=1)
	{
		logmessage("This should never happen... something really bad.");
		return false;
	}
 
	// now we try to add edges to the boundary until we hit the start again
	// we definitively have to leave if we have more edges than exist
	// this is to make sure we don't loop infinitely for some reason
	while(boundary1.length<mesh.edges.count)
	{
		// get the last edge in the boundary
		var lastEdge = mesh.edges(boundary1[boundary1.length-1]);
 
		// check if the boundary is alreay closed
		// the shortest possible boundary has 3 edges,
		// so only check if we have at least 3
		if(boundary1.length>2)
		{
			// the first edge in the boundary
			var firstEdge = mesh.edges(boundary1[0]);
			// if the edges are connected, the boundary is closed.
			if(js_areEdgesConnected(firstEdge,lastEdge))
			{
				// yeah - closed - we leave this loop.
				break;
			}
		}
 
		// try to find the next edge which is connected to the last one
		// in the boundary... init it with -1, so we can check later if we really found one
		var newIndex = -1;
 
		// loop through all edges we counted
		for(var index in edgeCount)
		{
			// if the edge is a boundary 
			// note that we set used edges to 0, so we don't use them more than once
			if(edgeCount[index]==1)
			{
				// get this edge
				var currentEdge = mesh.edges(index);
 
				// if these two edges are connected, we add it to the boundary
				if(js_areEdgesConnected(currentEdge,lastEdge))
				{
					// set the newindex to the current index
					newIndex = index;
 
					// and leave this loop!
					break;
				}
			}
		}
 
		// if the newIndex is still -1, we didn't find a new edge,
		// which is really bad - so we leave the whole function and give up
		if(newIndex==-1)
		{
			logmessage("Something bad happened. I give up.");
			return false;
		}
 
		// add the newIndex to the boundary
		boundary1[boundary1.length] = newIndex;
		// remove it from the edgeCount array,
		// so we don't use it again
		edgeCount[newIndex] = 0;
	}
 
	// so now we have the first boundary - the other boundary simply
	// consists of all of the boundary edges left, so:
	// loop through the edgeCount array and get all edges with count1
	// and put them in boundary2
	for(var index in edgeCount)
	{
		// is it a boundary?
		if(edgeCount[index]==1)
		{
			boundary2[boundary2.length] = index;
		}
	}
 
	// do a last check if both boundaries are valid
	if(boundary1.length&lt;3 || boundary2.length&lt;3)
	{
		logmessage("The boundaries are too short - that's bad - I give up");
		return false;
	}
 
	// so now we know both boundaries, we check which one contains less edges
	if(boundary1.length<boundary2 .length)
		return boundary1;
	else
		return boundary2;
}

Result:

Now we have the polygons crossing the curve and the inner boundary. Another function will now get all polygons to be deleted. It basically does a “grow selection”, but with the following rule: We can only grow the selection over edges which are on the inner boundary. That way we get all polygons “inside” the boundary – not the ones outside of the polygons crossing the curve.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

// adds all polygons inside of a polygonselection to a given array
// by using a given edgeboundary
function js_addAllInsidePolygons(meshObj,polyIndices,edgeIndices)
{
	// get the geometry of the meshObj
	var mesh = meshObj.ActivePrimitive.Geometry;
 
	// put all polygons in a "used" hashtable
	var polyUsed = new Array();
	for(var i=0;i<polyindices .length;i++)
	{
		polyUsed[polyIndices[i]] = true;
	}
 
	// put all the edges in a "used" hashtable
	var edgeUsed = new Array();
	for(var i=0;i<edgeIndices.length;i++)
	{
		edgeUsed[edgeIndices[i]] = true;
	}
 
	// now loop through all polygons and
	// find all neighbor polygons, but(!)
	// only the one which are connected by edges
	// edgeIndices array
	// so we get only the ones on the right side
	for(var i=0;i<polyIndices.length;i++)
	{
		// get the polygon (called facet)
		var facet = mesh.facets(polyIndices[i]);
 
		// get the edges of the polygon
		var edges = facet.edges
 
		// loop through all edges and checked if they are used
		for(var j=0;j<edges.count;j++)
		{
			if(edgeUsed[edges(j).index])
			{
				// get the two polygons of the edge
				var nbFacets = edges(j).neighborPolygons();
 
				// if the edge has more than one polygon
				// (if not - we only counted it, otherwise how would we
				// be here, huh?)
				if(nbFacets.count>1)
				{
					// for each nb-facet
					for(var l=0;l&lt;2;l++)
					{
						// if the facet is not used yet
						if(!polyUsed[nbFacets(l).index])
						{
							// put it as used and add it to the polyIndices array
							polyUsed[nbFacets(l).index] = true;
							polyIndices[polyIndices.length] = nbFacets(l).index;
 
							// afterwards put all edges of the new polygon into the edgeUsed array
							var nbFacetEdges = nbFacets(l).edges;
							for(var k=0;k<nbfacetedges .count;k++)
							{
								edgeUsed[nbFacetEdges(k).index] = true;
							}
						}
					}
				}
			}
		}
	}
 
	// now get all used polygons and return them as an array
	var result = new Array();
	for(var index in polyUsed)
	{
		result[result.length] = index;
	}
 
	return result;
}

Result:

4. Move the resulting new points onto the curve

The extrude is going to be done by the main function, more about that later. For now – I just write a function which takes all of the points above a specific index and moves them onto the curve by closest point. For this it is really important that we froze the curve earlier, just in case we need to delete the polygons we shrunk onto.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// moves all points of a mesh starting with the given index onto the curve
function js_movePointsOntoCurve(meshObj,curveObj,startIndex)
{
	// get the geometries of the objects
	var mesh = meshObj.ActivePrimitive.Geometry;
	var curve = curveObj.ActivePrimitive.Geometry;
 
	// loop through all points starting with the given index
	for(var i=startIndex;i<mesh .points.count;i++)
	{
		var oldPos = mesh.points(i).position;
 
		// get the U value of the closest point on the curve
		var newPos = curve.GetClosestCurvePosition2(oldPos).toArray()[3];	
 
		// now move the point
		Translate(meshObj+".pnt["+i+"]", newPos.x,newPos.y,newPos.z, siAbsolute, siParent, siObj, siXYZ);
	}
}

To finish up the tool, we end by creating a main function which calls all of our helper functions one after another.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

// the main function to run the tool
function js_main()
{
	// check the selection
	if(!js_checkSelection())
	{
		return false;
	}
 
	// define our variables (we can because the selection was checked before)
	var mesh = selection(0);
	var curve = selection(1);
 
	// apply the shrink wrap...
	js_applyShrinkWrap(curve,mesh);
 
	// get the crossing edges..
	var edgesCrossing = js_getAllCrossingEdges(mesh,curve);
	if(edgesCrossing.length==0)
	{
		logmessage("There are no crossing edges!");
		return false;
	}
 
	// get the adjacent polygons
	var poliesOnCurve = js_getAdjacentPolygons(mesh,edgesCrossing);
	if(!poliesOnCurve)
	{
		// something didn't work - we have to abort.
		return false;
	}
 
	// now get the shortest edge boundary
	var edgeBoundary = js_getShortestEdgeBoundary(mesh,poliesOnCurve)
 
	// now get all polygons inside that boundary as well
	var polygonsToDelete = js_addAllInsidePolygons(mesh,poliesOnCurve,edgeBoundary);
 
	// select the adjacent edges of the polygons
	SelectAdjacent(mesh+".poly["+polygonsToDelete+"]", "Edge", false);
 
	// delete all polygons... finally something's happenin' !
	ApplyTopoOp("DeleteComponent", mesh+".poly["+polygonsToDelete+"]", siUnspecified, siPersistentOperation, null);
 
	// now we have the edges still selected, as we selected the adjacent ones before,
	// what we do now is remember the pointcount - as the points we have to move are the
	// new ones after the extrude operation
	var pointCount = mesh.ActivePrimitive.Geometry.Points.Count;
 
	// now duplicate the edges (if we don't specify anything it is going to be the selection
	DuplicateMeshComponent(null, siPersistentOperation);
 
	// now move all points on the mesh onto the curve starting with the given index
	js_movePointsOntoCurve(mesh,curve,pointCount);
}

Result:

Ressources

Here’s the final script: Edge Extrude Pro
Moreover, here is a camtasia capture of working with it: Camtasia Demo (Techsmith, 9 MB)

cheers!

]]> http://www.softimageblog.com/archives/93/feed 20 http://www.softimageblog.com/archives/84#utm_source=rss&utm_medium=rss&utm_campaign=what-is-softimage-scaling-anyway http://www.softimageblog.com/archives/84#comments Tue, 31 Jan 2006 03:10:05 +0000 Brent McPherson http://www.xsi-blog.com/?p=84 You may not be aware that in XSI scaling is handled differently than in other 3D software packages or perhaps you have encountered situations where scaling a hierarchy did not quite give you the results you were expecting.

In this article I’m going to crack open the mysteries surrounding Softimage scaling. You might find this useful if you are exporting rigs out of XSI or trying to integrate XSI into an existing pipeline. At the very least you might be able to use this knowledge to impress the newbies at work.

There are two types of transformation schemes that XSI supports: Softimage scaling (also affectionately known as SI scaling) and classical scaling (which is a term we invented to refer to the way everyone else handles scaling).

SI scaling was invented at Softimage and it was designed to avoid shearing. Shearing happens when an object is scaled in a direction that does not line up with one of its local axes. One characteristic of shearing is that the object’s local axes may no longer be perpendicular. Shearing can also affect your mesh normals in undesirable ways.

So, if shearing is generally undesirable then why don’t we see other software taking a similar approach? Well for starters classical scaling more closely matches the matrix-stack transformation model used by the graphics hardware and it is simpler to implement and understand. Another reason is that even though shearing can occur with classical scaling it is fairly easy to avoid in practice.

In fact, under many circumstances SI scaling and classical scaling may yield the exact same results which is one reason why SI scaling is not more well known. In fact, the only situation where SI scaling differs from classical scaling is when you apply different scale factors to one or more axes on a 3D object with children *and* the local axes of the children do not line up with the parent’s local axes. If you stick to uniform scaling or the parent and children’s local axes line up or you only apply non uniform scaling to 3D objects without children then the math works out the same.

Time to get down and dirty with the implementation details of SI scaling. I’m going to try and keep this discussion simple even though transformations in XSI are anything but simple. The local transform is chock full of buttons and sliders that let you modify scale orientation, pivots, constraints, neutral poses and a bunch of other stuff I’m too lazy to look up. So, I’m just going to gloss over all that stuff and pretend that our transformation is made up of a scale, a rotation and a translation. After all those are the main parameters animators deal with and they are the only ones that show up in the transform panel. (so I do have some justification for my simplification) You can think of all the other parameters as optional accessories that hang off the main transform.

The first thing to note is that in both schemes the local transform is defined exactly the same. SI scaling only kicks in when 3D objects are parented in a hierarchy. In both schemes our local matrix is just formed by converting our scaling, rotation and translations to matrices (using the standard 4×4 matrix formulas) and multiplying all three matrices together.

M      = M      x M      x M
 local    scale    rot      trans

Now, here is where classical scaling really shines. To get a global matrix for a 3D object A which is parented under another 3D object B we simply multiply together the local matrix and the parent’s global matrix.

A       = A      x  B
 global    local     global

Nice and simple. If B has a parent C we expand this formula again. (Note: if an object doesn”t have any parents then the global matrix is the same as the local matrix)

A         A      x  B      x C      x  and so on...
 global =  local     local    local

SI scaling takes a different approach by constraining the scale factors to always happen around an object’s local axes. Therefore, shearing cannot occur by definition. So, what this means is that, when dealing with a hierarchy, all the scaling matrices are combined together first followed by all the rotation matrices and finally all the global translations.

One other thing to note is that SI scaling is not a simple matrix product (like classical scaling) since it requires us to handle translations in a slightly different manner. In SI scaling a global matrix is formed as follows.

A       = A      x B      x A    x B    x AB
 global    scale    scale    rot    rot    trans

You can see how the in SI scaling the scale/rotation/translation components are combined separately. The only strange thing in this equation is the AB translation matrix and this is formed by taking the translation component of the following matrix product. (which is just a fancy way of getting the translation in parent space by transforming it by the parent’s local matrix)

AB      = 4th row of matrix | A       x  B      |
 trans                      |   trans     local |

And if we add another node to the hierarchy we get the following.

A       = A      x B      x C      x A    x B    x C    x ABC
 global    scale    scale    scale    rot    rot    rot    trans

ABC      = 4th row of matrix | AB       x  C      |
 trans                       |  trans       local |

Whew! That was a lot of trouble to avoid shearing. [1]

Most users won’t need to concern themselves with SI scaling versus classical scaling especially if they are doing everything in XSI and just outputting rendered frames. However, I would still like to give you a practical example of where you might want to use classical scaling instead of SI scaling. In the example below I have created a brick wall by translating and rotating individual (identical) bricks and parenting them under a null. Now, if I want to squish the entire wall by scaling the (null) parent I will get very different results depending on whether I am using SI or classical scaling. In this situation classical scaling is more useful since we do not want the bricks to scale along their local axes. (which point in different directions)

The good news is that, in XSI, you can mix and match SI scaling and classical scaling to fit your needs. Perhaps you are more comfortable with classical scaling because you cut your teeth on a different 3D software package.

First, if you want to make classical scaling the default in XSI, there is a preference to activate classical scaling globally under File > Preferences > General > Use Classical Scaling for Newly Created Objects.

If however you just want to use classical scaling on a few objects you simply need to 1) select all the objects in your hierarchy 2) hit Ctrl+K to inspect their local transforms and 3) turn off “Hierarchical (Softimage) Scaling” parameter. (which is found under the “Scaling” tab)

If you are interested in learning more about SI scaling and transforms you might also want to also check out Michael Isner’s website where he explores SI scaling from a technical animator/TD perspective. He even has some nifty JScript sample code for dealing with SI scaling that you can incorporate into your own scripts.

Footnotes:

[1] In XSI there is actually a way to shear local transforms by using the scale orientation parameter which changes the axes about which scaling occurs. Oh the irony!

“It would be nice if I could select all the polygons that are facing the camera…”

Okay, so maybe you haven’t had that reflection but Gabriel Tremblay sure has, and one fateful evening he talked to me about it over a beer. So here it is, from his brain to your workspace with a little detour through my keyboard: PB_selPolyFromCam.

The idea behind this tool is to select polygons on polygonal objects as a planar or camera projection would, if it could. If the polygon is facing the camera of choice and within a threshold angle from the camera’s axis… BAM! It’s selected. Weeelllll, not so fast, I’d have to write the tool in C++ and compile it as well as remove the few remaining commands that are in there to gain some additionnal speed. Not to mention my actual algorythim might not be as tight as it could be.

Here’s a snapshot of the UI to help visualize how the tool works:

Here is what the above PPG setup looks like on a sphere. The camera doing the selecting is the one in the screenshot.

Because I couldn’t get to the Selection menu in the Selection pannel, I hooked the tool in the Modify -> PolyMesh section of the Model toolbar. Did someone over at Softimage understand the subtle hint? I’d like to hook things into the Selection menu of the Selection pannel… Just driving the point home. Thanks!

Just drop the file in your favorite Application\Plugins location and have a ball! Of course you’ll also need the latest buzz.xsi library available through the download area.

I hope all you texturers and camera projectors out there enjoy!
As usual, if you find bugs or have comments, don’t be shy.

Thanks go out to Gabriel and the guys at Buzz on this one.