mrv.maya.nt.it

Epydoc: mrv.maya.nt.it

Contains different multi-purpose iterators allowing to conveniently walk the dg and dag.

Functions

mrv.maya.nt.it._argsToFilter(args)

convert the MFnTypes in args list to the respective typeFilter

mrv.maya.nt.it.dagIterator(*args, **kwargs)

Returns:MItDagIterator configured according to args - see docs at iterDagNodes. Note:use this method if you want to use more advanced features of the iterator

mrv.maya.nt.it.dgIterator(*args, **kwargs)

Returns:MItDependencyNodes configured according to args - see docs at iterDgNodes. Note:use this method if you want to use more advanced features of the iterator

mrv.maya.nt.it.graphIterator(nodeOrPlug, *args, **kwargs)

Returns:MItDependencyGraph configured according to args - see docs at iterGraph. Note:use this method if you want to use more advanced features of the iterator Raises RuntimeError:  if the filter types does not allow any nodes to be returned. This is a bug in that sense as it should just return nothing. It also shows that maya pre-parses the result and then just iterates over a list with the iterator in question

mrv.maya.nt.it.iterDagNodes(*args, **kwargs)

Iterate over the hierarchy under a root dag node, if root is None, will iterate on whole Maya scene If a list of types is provided, then only nodes of these types will be returned, if no type is provided all dag nodes under the root will be iterated on. Types are specified as Maya API types being a member of api.MFn The following keywords will affect order and behavior of traversal:

Parameter:kwargs –

• dagpath:

  if True, default True, MDagPaths will be returned If False, MObjects will be returned - it will return each object only once in case they occour in multiple paths.

• depth:

  if True, default True, Nodes will be returned as a depth first traversal of the hierarchy tree if False as a post-order (breadth first)

• underworld:

  if True, default False, traversal will include a shape’s underworld (dag object parented to the shape), if False the underworld will not be traversed,

• asNode:

  if True, default True, the returned item will be wrapped into a Node

• root:

  MObject or MDagPath or Node of the object you would like to start iteration on, or None to start on the scene root. The root node will also be returned by the iteration ! Please note that if an MObject is given, it needs to be an instanced DAG node to have an effect.

• predicate:

  method returning True if passed in iteration element can be yielded default: lambda x: True

mrv.maya.nt.it.iterDgNodes(*args, **kwargs)

Iterator on MObjects or Nodes of the specified api.MFn types

Parameters:

• args – type as found in MFn.k... to optionally restrict the set of nodes the iterator operates upon. All nodes of a type included in the args will be iterated on. args is empty, all nodes of the scene will be iterated on which may include DAG nodes as well.
• kwargs –

  • asNode:

    if True, default True, the returned value will be wrapped as node

  • predicate:

    returns True for every iteration element that may be returned by the iteration, default : lambda x: True

mrv.maya.nt.it.iterGraph(nodeOrPlug, *args, **kwargs)

Iterate Dependency Graph (DG) Nodes or Plugs starting at a specified root Node or Plug. The iteration _includes_ the root node or plug. The following keywords will affect order and behavior of traversal:

Parameters:

• nodeOrPlug – Node, MObject or MPlug to start the iteration at
• args – list of MFn node types If a list of types is provided, only nodes of these types will be returned, if no type is provided all connected nodes will be iterated on.
• kwargs –

  • input:

    if True connections will be followed from destination to source, if False from source to destination default is False (downstream)

  • breadth:

    if True nodes will be returned as a breadth first traversal of the connection graph, if False as a preorder (depth first) default is False (depth first)

  • plug:

    if True traversal will be at plug level (no plug will be traversed more than once), if False at node level (no node will be traversed more than once), default is False (node level)

  • prune:

    if True, the iteration will stop on nodes that do not fit the types list, if False these nodes will be traversed but not returned default is False (do not prune)

  • asNode:

    if True, default True, and if the iteration is on node level, Nodes ( wrapped MObjects ) will be returned If False, MObjects will be returned

  • predicate:

    method returning True if passed in iteration element can be yielded default: lambda x: True

Returns:

Iterator yielding MObject, Node or Plug depending on the configuration flags, first yielded item is always the root node or plug.

mrv.maya.nt.it.iterSelectionList(sellist, filterType=0, predicate=<function <lambda> at 0x5f03ed8>, asNode=True, handlePlugs=True, handleComponents=False)

Iterate the given selection list

Parameters:

• sellist – MSelectionList to iterate
• filterType – MFnType id acting as simple type filter to ignore all objects which do not have the given object type
• asNode – if True, returned MObjects or DagPaths will be wrapped as Node, compoents will be wrapped as Component. Otherwise they will be returned as MObjects and MDagPaths respectively.
• handlePlugs – if True, plugs can be part of the selection list and will be returned. This implicitly means that the selection list will be iterated without an iterator, and MFnType filters will be slower as it is implemented in python. If components are enabled, the tuple returned will be ( Plug, MObject() )
• predicate – method returninng True if passed in iteration element can be yielded default: lambda x: True
• handleComponents – if True, possibly selected components of dagNodes will be returned as well. This forces the return value into tuple(Node, Component)

Returns:

Node or Plug on each iteration step If handleComponents is True, for each Object, a tuple will be returned as tuple( Node, Component ) where component is NullObject ( MObject ) if the whole object is on the list. If the original object was a plug, it will be in the tuples first slot, whereas the component will be a NullObject

mrv.maya.nt.it.selectionListIterator(sellist, **kwargs)

Returns:iterator suitable to iterate given selection list - for more info see iterSelectionList

Classes

Epydoc: mrv.maya.nt.it

class mrv.maya.nt.it.Component(*args)

Bases: maya.OpenMaya.MObject, mrv.maya.nt._root_

Represents a shape component - its derivates can be used to handle component lists to be used in object sets and shading engines

addElement(*args)

see addElements

Returns:self Note:do not use this function as it will be really slow when handling many items, use addElements instead

addElements(*args)

Operates exactly as described in the MFn...IndexComponent documentation, but returns self to allow combined calls and on-the-fly component generation

Returns:self

apiType()

apiTypeStr()

assign()

className()

classmethod create(component_type)

Returns:A new component instance carrying data of the given component type Parameter:component_type – MFn:: component type to be created. Note:It is important that you call this function on the Component Class of a compatible type, or a RuntimeError will occour

classmethod getMFnType()

Returns:mfn type of this class Note:the type returned is not the type of the shape component

hasFn()

isNull()

kNullObj

thisown

The membership flag

Epydoc: mrv.maya.nt.it

class mrv.maya.nt.it.DagNode

Bases: mrv.maya.nt.Entity, mrv.interface.iDagItem

Implements access to DAG nodes

addAttribute(attr)

Add the given attribute to the node as local dynamic attribute

Parameter:attr – MObject of attribute or Attribute instance as retrieved from a plug Returns:plug to the newly added attribute Note:This method is explicitly not undoable as attributes are being deleted in memory right in the moment they are being removed, thus they cannot reside on the undo queue

addChild(*args, **kwargs)

Add the given childNode as child to this Node. Allows instancing !

Parameters:

• childNode – Node you wish to add
• position – the index to which to add the new child, kNextPos will add it as last child. It supports python style negative indices
• keepExistingParent – if True, the childNode will be instanced as it will have its previous parent(s) and this one, if False, the previous parent will be removed from the child’s parent list
• renameOnClash – resolve nameclashes by automatically renaming the node to make it unique
• keepWorldSpace – see reparent, only effective if the node is not instanced

Returns:

childNode whose path is pointing to the new child location

Raises ValueError:  

if keepWorldSpace is requested with directly instanced nodes

Note:

as maya internally handles add/remove child as instancing operation, even though keepExistingParent is False, it will mess up things and for a short period of time in fact have two n + 1 instances, right before one is unlinked, This still fills a slot or something, and isInstanced will be true, although the pathcount is 1. Long story short: if the item to be added to us is not instanced, we use reparent instead. It will not harm in direct instances, so its save to use.

Note:

if the instance count of the item is 1 and keepExistingParent is False, the position argument is being ignored

addInstancedChild(*args, **kwargs)

Add childnode as instanced child to this node

Note:for more information, see addChild Note:its a shortcut to addChild allowing to clearly indicate what is happening

addParent(*args, **kwargs)

Adds ourselves as instance to the given parentnode at position

Parameter:kwargs – see addChild Returns:self with updated dag path

classmethod addSep(item, sep)

Returns:

item with separator added to it ( just once )

Note:

operates best on strings

Parameters:

• item – item to add separator to
• sep – the separator

addTo(setnode, component=<maya.OpenMaya.MObject; proxy of <Swig Object of type 'MObject *' at 0x5c828e0> >, **kwargs)

Add ourselves to the given set

Note:method is undoable See:sets.ObjectSet

allocateFlag()

apiObject()

Returns:our dag path as this is our api object - the object defining this node best

apiType()

Returns:the MFn Type id of the wrapped object

basename()

Returns:basename of this path, ‘/hello/world’ -> ‘world’

child(index)

Returns:child of self at index Note:this method fixes the MFnDagNode.child method - it returns an MObject, which doesnt work well with instanced nodes - a dag path is required, which is what we use to aquire the object

childTransforms(predicate=<function <lambda> at 0x5e9b2a8>)

Returns:list of all transform nodes below this one

children(predicate=<function <lambda> at 0x5e99f50>, asNode=True)

Returns:all child nodes below this dag node if predicate returns True for passed Node Parameter:asNode – if True, you will receive the children as wrapped Nodes, otherwise you get MDagPaths

childrenByType(nodeType, predicate=<function <lambda> at 0x5e9b0c8>)

Returns:all childnodes below this one matching the given nodeType and the predicate Parameter:nodeType – class of the nodeTyoe, like nt.Transform

childrenDeep(order=1, predicate=<function <lambda> at 0x7f41dd7c5050>)

Returns:

list of all children of path, [ child1 , child2 ]

Parameters:

• order – order enumeration
• predicate – returns true if x may be returned

Note:

the child objects returned are supposed to be valid paths, not just relative paths

className()

classification()

connectedSets(setFilter=(459, False, 0))

Returns:list of object set compatible Nodes having self as member Parameter:setFilter – tuple(apiType, use_exact_type) - the combination of the desired api type and the exact type flag allow precise control whether you which to get only renderable shading engines, only objectfSets (tuple[1] = True), or all objects supporting the given object type. Its preset to only return shading engines Note:the returned sets order is defined by the order connections to instObjGroups Note:only sets will be returned that have the whole object as member, thus you will not see sets having component assignments like per-compoent shader assignments or deformer sets

connections()

Returns:MPlugArray of connected plugs

copyFrom(other, *args, **kwargs)

Copy the data from other into self as good as possible Only copy the data that is unique to your specific class - the data of other classes will be taken care of by them !

Note:you must support args and kwargs if one of your iDuplicate bases does

copyTo(instance, *args, **kwargs)

Copy the values of ourselves onto the given instance which must be an instance of our class to be compatible. Only the common classes will be copied to instance

Returns:altered instance Note:instance will be altered during the process

copyToOther(instance, *args, **kwargs)

As copyTo, but does only require the objects to have a common base. It will match the actually compatible base classes and call copyFrom if possible. As more checking is performed, this method performs worse than copyTo

createInstance(*args, **kwargs)

Create and Initialize an instance of self.__class__( ... ) based on your own data

Returns:new instance of self Note:using self.__class__ instead of an explicit class allows derived classes that do not have anything to duplicate just to use your implementeation Note:you must support args and kwargs if one of your iDuplicate bases does

dagPath()

Returns:the original DagPath attached to this Node - it’s not wrapped for performance Note:If you plan to alter it, make sure you copy it using the MDagPath(node.dagPath()) construct !

deallocateAllFlags()

deallocateFlag()

delete(*args, **kwargs)

Delete this node - this special version must be

Note:if the undo queue is enabled, the object becomes invalid, but stays alive until it drops off the queue Note:if you want to delete many nodes, its more efficient to delete them using the global delete method

dependencyInfo(attribute, by=True)

Returns:

list of attributes that given attribute affects or that the given attribute is affected by if the attribute turns dirty.

Parameters:

• attribute – attribute instance or attribute name
• by – if false, affected attributes will be returned, otherwise the attributes affecting this one

Note:

see also MPlug.affectedByPlugs

Note:

USING MEL: as api command and mObject array always crashed on me ... don’t know :(

displayOverrideValue(plugName)

Returns:the override display value actually identified by plugName affecting the given object (that should be a leaf node for the result you see in the viewport. The display type in effect is always the last one set in the hierarchy returns None display overrides are disabled

duplicate(*args, **kwargs)

Duplciate the given node to newpath

Parameters:

• newpath –

  result depends on its format:

  • ‘’ - empty string, creates a unique name based on the actual node name by appending a copy number to it, if newTransform is True, the newly created shape/transform will keep its name, but receives a new parent
  • ‘newname’ - relative path, the node will be duplicated not changing its current parent if newTransform is False

  • |parent|newname - absolute path, the node will be duplicated and reparented under the given path

    if newTransform is True, a new transform name will be created based on your name by appending a unique copy number

• autocreateNamespace – if true, namespaces given in newpath will be created automatically, otherwise a RuntimeException will be thrown if a required namespace does not exist
• renameOnClash – if true, clashing names will automatically be resolved by adjusting the name
• newTransform – if True, a new transform will be created based on the name of the parent transform of this shape node, appending a unique copy number to it. Only has an effect for shape nodes

Returns:

newly create Node

Note:

duplicate performance could be improved by checking more before doing work that does not really change the scene, but adds undo operations

Note:

inbetween parents are always required as needed

Todo:

add example for each version of newpath

Note:

instancing can be realized using the addChild function

Note:

If meshes have tweaks applied, the duplicate will not have these tweaks and the meshes will look mislocated. Using MEL works in that case ... (they fixed it there obviously) , but creates invalid objects

Todo:

Undo implementation - every undoable operation must in fact be based on strings to really work, all this is far too much - dagNode.duplicate must be undoable by itself

Todo:

duplicate should be completely reimplemented to support all mel options and actually work with meshes and tweaks - the underlying api duplication would still be used of course, as well as connections (to sets) and so on ...

fullChildName(childname)

Add the given name to the string version of our instance :return: string with childname added like name _sep childname

classmethod getMFnClasses()

Returns:list of all function set classes this node supports, most derived function set comes first

hasChild(node)

Returns:True if node is a child of self

hasFn(mfntype)

Returns:True if our object supports the given function set type

instance(instanceNumber)

Returns:Node to the instance identified by instanceNumber Parameter:instanceNumber – range(0, self.instanceCount()-1)

instanceNumber()

Returns:our instance number Note:0 does not indicate that this object is not instanced - use getInstanceCount instead

isAlive()

Returns:True if the object exists in memory Note:objects on the undo queue are alive, but NOT valid

isMemberOf(setnode, component=<maya.OpenMaya.MObject; proxy of <Swig Object of type 'MObject *' at 0x5c1d740> >)

Returns:True if self is part of setnode Note:method is undoable See:sets.ObjectSet

isPartOf(other)

Returns:True if self is a part of other, and thus can be found in other Note:operates on strings only

isRoot()

Returns:True if this path is the root of the DAG

isRootOf(other)

Returns:True other starts with self Note:operates on strings Note:we assume other has the same type as self, thus the same separator

isTemplate()

Returns:True if this node is templated - this is the case if itself or one of its parents are templated

isValid()

Returns:True if the object exists in the scene Note:Handles DAG objects correctly that can be instanced, in which case the MObject may be valid , but the respective dag path is not. Additionally, if the object is not parented below any object, everything appears to be valid, but the path name is empty

isVisible()

Returns:True if this node is visible - its visible if itself and all parents are visible

iterInstances(excludeSelf=False)

Get iterator over all (direct and indirect)instances of this node

Parameter:excludeSelf – if True, self will not be returned, if False, it will be in the list of items Note:Iterating instances is more efficient than querying all instances individually using instance Todo:add flag to allow iteration of indirect instances as well

iterParents(predicate=<function <lambda> at 0x7f41dd7c5230>)

Returns:generator retrieving all parents up to the root Parameter:predicate – returns True for all x that you want to be returned

name()

Returns:fully qualified (long) name of this dag node

object()

Returns:MObject as retrieved from the MDagPath of our Node

parent()

Returns:Maya node of the parent of this instance or None if this is the root

parentAtIndex(index)

Returns:Node of the parent at the given index - non-instanced nodes only have one parent Note:if a node is instanced, it can have parentCount parents Todo:Update dagpath afterwards ! Use dagpaths instead !

parentDeep()

Returns:all parents of this path, ‘/hello/my/world’ -> [ ‘/hello/my’,’/hello’ ]

referenceFile()

Returns:name (str) of file this node is coming from - it could contain a copy number as {x} Note:will raise if the node is not referenced, use isReferenced to figure that out

removeAttribute(attr)

Remove the given attribute from the node

Parameter:attr – see addAttribute

removeChild(*args, **kwargs)

remove the given childNode (being a child of this node) from our child list, effectively parenting it under world !

Parameters:

• childNode – Node to unparent - if it is not one of our children, no change takes place
• allowZeroParents – if True, it is possible to leave a node unparented, thus no valid dag paths leads to it. If False, transforms will just be reparented under the world

Returns:

copy of childnode pointing to the first valid dag path we find.

Note:

to prevent the child (if transform) to dangle in unknown space if the last instance is to be removed, it will instead be reparented to world.

Note:

removing shapes from their last parent will result in an error

removeFrom(setnode, component=<maya.OpenMaya.MObject; proxy of <Swig Object of type 'MObject *' at 0x5b41420> >)

remove ourselves to the given set

Note:method is undoable See:sets.ObjectSet

removeParent(*args, **kwargs)

Remove ourselves from given parentnode

Returns:None

rename(*args, **kwargs)

Rename this node to newname

Parameters:

• newname – new name of the node
• autocreateNamespace – if true, namespaces given in newpath will be created automatically, otherwise a RuntimeException will be thrown if a required namespace does not exist
• renameOnClash – if true, clashing names will automatically be resolved by adjusting the name

Returns:

renamed node which is the node itself

Note:

for safety reasons, this node is dagnode aware and uses a dag modifier for them !

reparent(*args, **kwargs)

Change the parent of all nodes (also instances) to be located below parentnode

Parameters:

• parentnode – Node instance of transform under which this node should be parented to if None, node will be reparented under the root (which only works for transforms)
• renameOnClash – resolve nameclashes by automatically renaming the node to make it unique
• raiseOnInstance – if True, this method will raise if you try to reparent an instanced object. If false, instanced objects will be merged into the newly created path under parentnode, effectively eliminating all other paths , keeping the newly created one
• keepWorldSpace – if True and node to be reparented is a transform, the world space position will be kept by adjusting the transformation accordingly. WARNNG: Currently we reset pivots when doing so

:return : copy of self pointing to the new dag path self

Note:will remove all instance of this object and leave this object at only one path - if this is not what you want, use the addChild method instead as it can properly handle this case Note:this method handles namespaces properly

root()

Returns:the root of the DAG - it has no further parents

setLocked(*args, **kwargs)

Lock or unloack this node

Parameter:state – if True, the node is locked. Locked nodes cannot be deleted, renamed or reparented Note:you can query the lock state with isLocked

setNamespace(*args, **kwargs)

Returns:

self after being moved to the given namespace. This will effectively rename the object.

Parameters:

• newns – Namespace instance to put this Node into
• kwargs – to be passed to rename

setParent(*args, **kwargs)

Change the parent of self to parentnode being placed at position

Parameter:kwargs – see addChild Returns:self with updated dag path

sets(setFilter=(459, False, 0))

Returns:list of object set compatible Nodes having self as member Parameter:setFilter – tuple(apiType, use_exact_type) - the combination of the desired api type and the exact type flag allow precise control whether you which to get only renderable shading engines, only objectfSets (tuple[1] = True), or all objects supporting the given object type. Its preset to only return shading engines Note:the returned sets order is defined by the order connections to instObjGroups Note:only sets will be returned that have the whole object as member, thus you will not see sets having component assignments like per-compoent shader assignments or deformer sets

shapes(predicate=<function <lambda> at 0x5e9b1b8>)

Returns:all our Shape nodes Note:you could use getChildren with a predicate, but this method is more efficient as it uses dagpath functions to filter shapes

supports(interface_type)

Returns:True if this instance supports the interface of the given type Parameter:interface_type – Type of the interface you require this instance to support Note:Must be used in case you only have a weak reference of your interface instance or proxy which is a case where the ordinary isinstance( obj, iInterface ) will not work

transform()

Returns:Node to lowest transform in the path attached to our node Note:for shapes this is the parent, for transforms the transform itself

unparent(*args, **kwargs)

As reparent, but will unparent this transform under the scene root

Epydoc: mrv.maya.nt.it

class mrv.maya.nt.it.MDagPath(*args)

Bases: object

apiType()

assign()

child()

childCount()

className()

exclusiveMatrix()

exclusiveMatrixInverse()

extendToShape()

extendToShapeDirectlyBelow()

fullPathName()

getAPathTo()

getAllPathsTo()

getPath()

hasFn()

inclusiveMatrix()

inclusiveMatrixInverse()

instanceNumber()

isInstanced()

isValid()

length()

node()

numberOfShapesDirectlyBelow()

partialPathName()

pathCount()

pop()

push()

set()

thisown

The membership flag

transform()

Epydoc: mrv.maya.nt.it

class mrv.maya.nt.it.MObject(*args)

Bases: object

apiType()

apiTypeStr()

assign()

hasFn()

isNull()

kNullObj

thisown

The membership flag

Epydoc: mrv.maya.nt.it

class mrv.maya.nt.it.Node

Bases: object

Common base for all maya nodes, providing access to the maya internal object representation Use this class to directly create a maya node of the required type

apiObject()

Returns:the highest qualified api object of the actual superclass, usually either MObject or MDagPath

apiType()

Returns:the MFn Type id of the wrapped object

classmethod getMFnClasses()

Returns:list of all function set classes this node supports, most derived function set comes first

hasFn(mfntype)

Returns:True if our object supports the given function set type

Epydoc: mrv.maya.nt.it

class mrv.maya.nt.it.NodeFromObj

Bases: object

Virtual Constructor, producing nodes as the Node does, but it will only accept MObjects or dagpaths which are expected to be valid. As no additional checking is performed, it might be more unsafe to use, but will be faster as it does not perform any runtime checks

It duplicates code from _checkedInstanceCreation and _checkedInstanceCreationDagPathSupport to squeeze out the last tiny bit of performance as it can make quite a few more assumptions and reduces method calls.

Note:Do not derive from this class, derive from Node instead Note:We will always create the node type as determined by the type hierarchy