So the New() method takes an integer which specifies the type of map, and a string for its name. It will return this new maps ID. In dir(lx.symbol) we can find in the integers (starting with lx.symbol.i) for vmaps, and specifically pick maps, which is another name for a selection set: lx.symbol.i_VMAP_PICK

+

So the New() method takes an integer which specifies the type of map, and a string for its name. It will return this new maps ID. In dir(lx.symbol) we can find among the integers (symbols starting with lx.symbol.i) symbols for vmaps, and specifically a symbol for pick maps, which is another name for a selection set: lx.symbol.i_VMAP_PICK

<syntaxhighlight lang="python">

<syntaxhighlight lang="python">

mapID = mapAccessor.New(lx.symbol.i_VMAP_PICK, "Selection Set")

mapID = mapAccessor.New(lx.symbol.i_VMAP_PICK, "Selection Set")

Revision as of 00:48, 21 January 2014

Contents

Localizing a Mesh for Editing

When you localize a mesh in the API, you need to specify what you're going to be doing with the mesh in advance. It may not seem like it, but creating a new vertex map (in this case a selection set) is editing a mesh. That means we need to localize a mesh object specifically for editing. This can be done through a Layer Scan Object. So the first step is to create a layer scan object.

Notice that the flag we use when we allocate a layer scan object is 'lx.symbol.f_LAYERSCAN_EDIT'. This creates a layerscan object that is capable of making edits, as opposed to some other flags which are specifically used for reading data. If we take a look at the declarations for layerscan objects (meaning the flags we give when we allocate the object) we can see the flags we can give in the left hand column, and any flags that are implicitly included with it on the right. Notice that all of the EDIT flags include a WRITEMESH flag and an ACTIVE flag. The WRITEMESH flag is what gives us the ability to make edits to a mesh, while the ACTIVE flag means that the layerscan object will be capable of localizing all active mesh items. So now we need to localize an editable mesh. If we do a quick dir() on our Layer Scan Object, we can see the different methods for localizing meshes:

The MeshAction(), MeshBase(), and MeshEdit() methods will give us a localized mesh in action, base, or editable mode. The MeshInstance() method will allow us to localize a specific instance of a mesh based on index, and the MeshItem() method will return a generic item object lx.object.Item. It's important to note that because were implicitly using the lx.object.f_LAYERSCAN_ACTIVE flag, the layer scan object may have access to more than one mesh. For our purposes we'll just use the first available one (the index 0 mesh) but it would probably be better to localize each available mesh (you can check how many are there with the Count() method) and make sure it's the mesh you want. We want an editable mesh, so we'll use the MeshEdit() method to localize our mesh.

meshObject = layerScanObject.MeshEdit(0)

Creating a Selection Set

What you might not know is that internally, selection sets are vertex maps just like UV Maps, Weight Maps, or Morph Maps. Because of this, the logical place to look for creating a new vertex map might be in a Mesh Map Accessor. By doing a quick dir() on our localized mesh, we can see that we can create a Mesh Map Accessor by using the MeshMapAccessor() call. If we then look at the dir() of the Mesh Map Accessor, we can find a method called New(). So what does it take to create a new mesh map?

So the New() method takes an integer which specifies the type of map, and a string for its name. It will return this new maps ID. In dir(lx.symbol) we can find among the integers (symbols starting with lx.symbol.i) symbols for vmaps, and specifically a symbol for pick maps, which is another name for a selection set: lx.symbol.i_VMAP_PICK

mapID = mapAccessor.New(lx.symbol.i_VMAP_PICK,"Selection Set")

Now we have a new map created, and the ID for that map stored as mapID. The last thing we need is to tell it which points to select.

Adding Points to the Selection Set

In order to assign points to a pick map, we need to have access to the points. So let's create a Point Accessor.

pointAccessor = meshObject.PointAccessor()

In the dir(pointAccessor), we can see a method for setting a points map value, so let's see what it needs to work.

pointAccessor.SetMapValue.__doc__
- SetMapValue(idmap,float[] value)

So we need the id of the map, which we already have, and a float storage object which contains the value we want to set. When you see [] in the requirements of a method, it denotes a storage object set to the datatype next to it. Since there's no point ID in the requirements for this method, it's safe to assume that we need to use our Point Accessor to select a point before we run the SetMapValue() call. So let's create a float storage object, select a point with our accessor, and then run the SetMapValue() method.

As discussed in the Map Types page, pick maps are dimensionless. That means that our storage object didn't need any dimensions (hence the 0 when it was created), and we don't need to set a value or values for it (using the set() method). Just feeding it in to our Point Accessor's SetMapValue() method while a point is selected is enough to add it to the selection set.

Note that when we talk about a point being selected by the Point Accessor, it just means it currently holds the focus of the API, not that the element is selected in modo's UI.

Finishing up and Making this more useful

Since we've edited attributes of our mesh, we need to let modo know when we're finished in a couple of ways. Since our mesh was localized as an editable mesh (remember our LayerScanObject.MeshEdit(0) call) we need to use the mesh object's SetMeshEdits() method to tell modo what we did. We also need to tell our Layer Scan Object that we're finished editing, and to Apply changes by using the Apply() method. The mesh's SetMeshEdits() method requires a falg to tell it what we've edited, and we can find these again in the dir(lx.symbol) starting with lx.symbol.f_MESHEDIT. For this situation, we're going to use MESHEDIT_MAP_OTHER because there isn't a specific flag for editing pick maps. We'll also call the Apply() method on our Layer Scan Object.

So we now have a selection set which has a single vertex in it. That's probably not too useful, so how about we clean this up a little into a function that we can feed a list of elements, a name for the selection set, and it will create a selection set with those elements in it? Here's a commented script that does just that. Almost all of it we have just been through, with the exception of a 'for' loop and defined function.

#pythonimport lx
# We'll define a function called 'createVertSet' that takes two arguments. # A list of element indices to make into a selection set, and a string name for the selection set.def createVertSet(elements, setName):
# Localize an editable mesh and create map and point accessors
layerScan = lx.service.Layer().ScanAllocate(lx.symbol.f_LAYERSCAN_EDIT)
mesh = layerScan.MeshEdit(0)
mapAccessor = mesh.MeshMapAccessor()
pointAccessor = mesh.PointAccessor()# Create a storage object and a new pick map, then loop through our elements and add them
storageBuffer = lx.object.storage('f',0)
newMap = mapAccessor.New(lx.symbol.i_VMAP_PICK,setName)for i in elements:
pointAccessor.SelectByIndex(i)
pointAccessor.SetMapValue(newMap, storageBuffer)# Apply our changes in the layerscan object and tell the mesh what changes we made
layerScan.Apply()
mesh.SetMeshEdits(lx.symbol.f_MESHEDIT_MAP_OTHER)# Here's an example of using our function. Just calling the function with a list of indices, and the name 'Set'
createVertSet((2,3,4,5),'Set')

If we wanted, we could delete the usage example at the end, save this in a file in an lxserv folder, and import it to use in the python interpreter. We could also put this defined function in another script to use over and over, or we could adapt it to use in regular modo use. Because there are no SDK objects being created (like visitors or tools) this can still be run as a normal script in modo.