Softimage Blog

// 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;
}

//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);
}

// 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;
	}
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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);
	}
}

// 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);
}