Python maya.cmds.sets() Examples

def get_outputs(self):
        """
        Retrieve all settings of each available sub widgets
        :return: 
        """

        inputs = self.get_inputs(as_preset=False)
        outputs = dict()
        outputs['off_screen'] = inputs['off_screen']

        import capture_gui.lib

        # Get isolate view members of the active panel
        if inputs['isolate_view']:
            panel = capture_gui.lib.get_active_editor()
            filter_set = mc.modelEditor(panel, query=True, viewObjects=True)
            isolate = mc.sets(filter_set, query=True) if filter_set else None
            outputs['isolate'] = isolate

        return outputs 

def copySkinComponents(source, destinationVerts):

    if not mc.listRelatives(source, shapes=True):
        raise RuntimeError('Source object must be geometry.')

    sourceSkin = utl.getSkinCluster(source)

    if not sourceSkin:
        raise RuntimeError("Source mesh doesn't have a skinCluster to copy from.")

    destMesh = mc.ls(destinationVerts[0], o=True)[0]
    destMesh = mc.listRelatives(destMesh, parent=True)[0]
    destSkin = copySkinInfluences(source, destMesh)

    tempSet = mc.sets(destinationVerts)

    mc.select(source, tempSet)

    mc.copySkinWeights(noMirror=True,
                       surfaceAssociation='closestPoint',
                       influenceAssociation='closestJoint',
                       normalize=True)

    mc.delete(tempSet)
    mc.select(destinationVerts) 

def set_pixel_error(progress_controller=None):
    """Set aiSubdivPixelError to 0

    sets the pixel error on objects which have a linear subdiv
    """
    if progress_controller is None:
        progress_controller = ProgressControllerBase()

    all_meshes = pm.ls(type='mesh')
    progress_controller.maximum = len(all_meshes)
    for node in all_meshes:
        try:
            pixel_error = node.getAttr('aiSubdivPixelError')
            if pixel_error > 0:
                node.setAttr('aiSubdivPixelError', 0)
        except pm.MayaAttributeError as e:
            pass
        progress_controller.increment()
    progress_controller.complete() 

def add_to_set_members():
    selection = cmds.ls(sl=True)
    
    if selection:
        setCount = 0
        for node in selection:
            if cmds.nodeType(node) != 'objectSet':
                continue
            for sel in selection:
                if sel == node:
                    continue
                try:
                    cmds.sets(sel, add=node)
                except Exception as e:
                    print e.message
            setCount += 1
        if setCount == 0:
            cmds.confirmDialog( title='Error',message='Please select set_node')

#選択セットのノード、コンポーネントを削除 

def particleCloud():
    node = cmds.shadingNode('particleCloud', asShader=True)
    shaderGroup = cmds.sets(renderable=True, noSurfaceShader=True,
                            empty=True, name=node + "SG")
    cmds.connectAttr(
        node + '.outColor', shaderGroup + '.volumeShader', force=True) 

def fn_createObject_openMaya():
    global importedObj

    cmds.select( all = True, hierarchy = True)
    currentObjs = cmds.ls(selection = True )

    newMesh = om.MFnMesh()

    mergeVertices = True
    pointTolerance = 0.0001

    for p in range(0, len(importedObj.polys), 1):
        polylist = []
        vCount = len(importedObj.polys[p])
        polylist = om.MPointArray()
        polylist.setLength(vCount)
        for i in range(vCount):
            polylist.set(importedObj.omVertices[int(importedObj.polys[p][i])], i)

        newMesh.addPolygon(polylist, mergeVertices, pointTolerance)


    if len(importedObj.weightMap) > 0:
        for v in range(0, importedObj.vertexCount , 1):
            c = importedObj.weightMap[v]
            vColor = om.MColor(c,c,c,c )
            newMesh.setVertexColor(vColor,v)

    newMesh.updateSurface()

    cmds.select( all = True, hierarchy = True)
    cmds.select(currentObjs, deselect = True)
    newObjs = cmds.ls(selection = True, transforms = True )
    cmds.select(newObjs, replace = True)
    cmds.sets( newObjs, e=True,forceElement='initialShadingGroup')
    cmds.rename (newObjs, importObjectName) 

def set_frame_range(progress_controller=None):
    """Set frame range

    sets the frame range from the shot node
    """
    if progress_controller is None:
        progress_controller = ProgressControllerBase()
    progress_controller.maximum = 5

    shot_nodes = pm.ls(type='shot')
    progress_controller.increment()
    if len(shot_nodes) == 0:
        raise PublishError('No shot nodes in the scene!')
    progress_controller.increment()

    shot_node = shot_nodes[0]
    start_frame = shot_node.startFrame.get()
    end_frame = shot_node.endFrame.get()
    progress_controller.increment()

    handle_count = 1
    try:
        handle_count = shot_node.getAttr('handle')
    except AttributeError:
        pass
    progress_controller.increment()

    # set it in the playback
    pm.playbackOptions(
        ast=start_frame,
        aet=end_frame,
        min=start_frame-handle_count,
        max=end_frame+handle_count
    )
    progress_controller.increment()
    progress_controller.complete() 

def check_objects_still_using_default_shader(progress_controller=None):
    """Default shader is not used

    check if there are objects still using the default shader
    """
    if progress_controller is None:
        progress_controller = ProgressControllerBase()
    progress_controller.maximum = 3

    # skip if this is a representation
    v = staging.get('version')
    if v and Representation.repr_separator in v.take_name:
        progress_controller.complete()
        return
    progress_controller.increment()

    objects_with_default_material = \
        mc.ls(
            mc.sets('initialShadingGroup', q=1),
            type=['mesh', 'nurbsSurface']
        )
    progress_controller.increment()
    if objects_with_default_material and len(objects_with_default_material):
        mc.select(objects_with_default_material)
        progress_controller.increment()
        progress_controller.complete()
        raise PublishError(
            'There are objects still using <b>initialShadingGroup</b><br><br>'
            '%s<br><br>Please assign a proper material to them' %
            '<br>'.join(
                objects_with_default_material[:MAX_NODE_DISPLAY]
            )
        )
    progress_controller.increment()
    progress_controller.complete() 

def members(self, type=None):
        op = operator.eq
        other = "typeId"

        if isinstance(type, string_types):
            other = "typeName"

        if isinstance(type, (tuple, list)):
            op = operator.contains

        for node in cmds.sets(self.name(namespace=True), query=True) or []:
            node = encode(node)

            if not type or op(type, getattr(node._fn, other)):
                yield node 

def flatten(self, type=None):
        """Return members, converting nested object sets into its members

        Example:
            >>> from maya import cmds
            >>> _ = cmds.file(new=True, force=True)
            >>> a = cmds.createNode("transform", name="a")
            >>> b = cmds.createNode("transform", name="b")
            >>> c = cmds.createNode("transform", name="c")
            >>> cmds.select(a)
            >>> gc = cmds.sets([a], name="grandchild")
            >>> cc = cmds.sets([gc, b], name="child")
            >>> parent = cmds.sets([cc, c], name="parent")
            >>> mainset = encode(parent)
            >>> sorted(mainset.flatten(), key=lambda n: n.name())
            [|a, |b, |c]

        """

        members = set()

        def recurse(objset):
            for member in objset:
                if member.isA(om.MFn.kSet):
                    recurse(member)
                elif type is not None:
                    if type == member.typeName:
                        members.add(member)
                else:
                    members.add(member)

        recurse(self)

        return list(members) 

def update(self, members):
        """Add several `members` to set

        Arguments:
            members (list): Series of cmdx.Node instances

        """

        cmds.sets(list(map(str, members)), forceElement=self.path()) 

def displacementShader():
    node = cmds.shadingNode('displacementShader', asShader=True)
    shaderGroup = cmds.sets(renderable=True, noSurfaceShader=True,
                            empty=True, name=node + "SG")
    cmds.connectAttr(
        node + '.displacement',
        shaderGroup + '.displacementShader',
        force=True) 

def cMuscleShader():
    node = cmds.shadingNode('cMuscleShader', asShader=True)
    shaderGroup = cmds.sets(renderable=True, noSurfaceShader=True,
                            empty=True, name=node + "SG")
    cmds.connectAttr(
        node + '.outColor',
        shaderGroup + '.displacementShader',
        force=True) 

def volumeFog():
    node = cmds.shadingNode('volumeFog', asShader=True)
    shaderGroup = cmds.sets(renderable=True, noSurfaceShader=True,
                            empty=True, name=node + "SG")
    cmds.connectAttr(
        node + '.outColor', shaderGroup + '.volumeShader', force=True) 

def remove(container):
    """Remove an existing `container` from Maya scene

    Deprecated; this functionality is replaced by `api.remove()`

    Arguments:
        container (avalon-core:container-1.0): Which container
            to remove from scene.

    """

    node = container["objectName"]

    # Assume asset has been referenced
    reference_node = next((node for node in cmds.sets(node, query=True)
                          if cmds.nodeType(node) == "reference"), None)

    assert reference_node, ("Imported container not supported; "
                            "container must be referenced.")

    log.info("Removing '%s' from Maya.." % container["name"])

    namespace = cmds.referenceQuery(reference_node, namespace=True)
    fname = cmds.referenceQuery(reference_node, filename=True)
    cmds.file(fname, removeReference=True)

    try:
        cmds.delete(node)
    except ValueError:
        # Already implicitly deleted by Maya upon removing reference
        pass

    try:
        # If container is not automatically cleaned up by May (issue #118)
        cmds.namespace(removeNamespace=namespace, deleteNamespaceContent=True)
    except RuntimeError:
        pass 

def lightFog():
    node = cmds.shadingNode('lightFog', asShader=True)
    shaderGroup = cmds.sets(renderable=True, noSurfaceShader=True,
                            empty=True, name=node + "SG")
    cmds.connectAttr(
        node + '.outColor', shaderGroup + '.volumeShader', force=True) 

def fluidShape():
    node = cmds.shadingNode('fluidShape', asShader=True)
    shaderGroup = cmds.sets(renderable=True, noSurfaceShader=True,
                            empty=True, name=node + "SG")
    cmds.connectAttr(
        node + '.outColor', shaderGroup + '.volumeShader', force=True)
    cmds.connectAttr("time1.outTime", node + ".currentTime") 

def envFog():
    node = cmds.shadingNode('envFog', asShader=True)
    shaderGroup = cmds.sets(renderable=True, noSurfaceShader=True,
                            empty=True, name=node + "SG")
    cmds.connectAttr(
        node + '.outColor', shaderGroup + '.volumeShader', force=True) 

def remove_set_members():
    selection = cmds.ls(sl=True)
    if selection:
        setCount = 0
        for node in selection:
            if cmds.nodeType(node) != 'objectSet':
                continue
            setMembers = cmds.sets(node, int=node)
            for removeNode in selection:
                if removeNode == node:
                    continue
                try:
                    print 'Remove from set :', node, ': Object :', removeNode
                    cmds.sets(removeNode, rm=node)
                except:
                    pass
            setCount += 1
        if setCount == 0:
            cmds.confirmDialog( title='Error',message='Please select set_node') 

def crenupMultiUV(self):
        self.defaultName = 'map'#デフォルト名
        #print self.mesh
        shapes = cmds.listRelatives(self.mesh, s=True, pa=True)
        self.shapes = shapes[0]
        #ヒストリ削除
        cmds.bakePartialHistory(self.shapes,ppt=True)
        #cmds.bakePartialHistory(self.shapes,preCache=True)
        
        self.uvSetAll = cmds.polyUVSet(self.mesh, q=True, allUVSets=True)
        self.currentSet = cmds.polyUVSet(self.mesh, q=True, currentUVSet=True)
        
        #現在のUVが空かどうか調べてスキップフラグがTrueなら関数抜ける
        if not self.checkCurrentUV():
            print 'Skip (No UV in Current UVSet) : ' + self.mesh
            return
        self.delUVFlag = True
        self.uvNum = 1#マルチUVリネーム用
        #マルチUVの指定名があれば削除フラグをFalseに
        if 'Multi_UV' in self.mesh or self.delMultiUV is False:
            self.delUVFlag = False
            self.uvNum = len(self.uvSetAll)#マルチUVリネーム用
        
        if len(self.uvSetAll) > 0:#UVセットがあったら
            self.deleteUV()
            #UVセットの名前を変更、マルチUVの場合は繰り返し処理
            self.renameUVSet()
        if self.groupMultiUV is True and len(self.uvSetAll) > 1:#UVセットが複数の場合セットに追加する
            cmds.sets(self.mesh,add='Multi_UV_Set')   #setに追加 

def removeZeroSet(self):
        memberTemp = cmds.sets(self.set , int=self.set)
        if len(memberTemp)==0:
            cmds.delete(self.set) 

def checkMultiUVSet(self):
        self.set = cmds.ls('Multi_UV_Set')
        if not self.set:
            self.set = cmds.sets(em=True,n='Multi_UV_Set')
        else:
            self.set = self.set[0]
            #セットメンバーを検索してマルチUVでない場合は取り除く
            setMembers = []
            setMembers = cmds.sets(self.set, int=self.set)
            for menber in setMembers:
                uvSet = cmds.polyUVSet(menber, q=True, allUVSets=True)
                if len(uvSet) < 2:
                    cmds.sets(menber,rm='Multi_UV_Set')   #setに追加 

def apply_shaders(relationships, namespace=None):
    """Given a dictionary of `relationships`, apply shaders to meshes

    Arguments:
        relationships (avalon-core:shaders-1.0): A dictionary of
            shaders and how they relate to meshes.

    """

    if namespace is not None:
        # Append namespace to shader group identifier.
        # E.g. `blinn1SG` -> `Bruce_:blinn1SG`
        relationships = {
            "%s:%s" % (namespace, shader): relationships[shader]
            for shader in relationships
        }

    for shader, ids in relationships.items():
        print("Looking for '%s'.." % shader)
        shader = next(iter(cmds.ls(shader)), None)
        assert shader, "Associated shader not part of asset, this is a bug"

        for id_ in ids:
            mesh, faces = (id_.rsplit(".", 1) + [""])[:2]

            # Find all meshes matching this particular ID
            # Convert IDs to mesh + id, e.g. "nameOfNode.f[1:100]"
            meshes = list(".".join([mesh, faces])
                          for mesh in lsattr("mbID", value=mesh))

            if not meshes:
                continue

            print("Assigning '%s' to '%s'" % (shader, ", ".join(meshes)))
            cmds.sets(meshes, forceElement=shader) 

def process(self):
        nodes = list()

        with lib.undo_chunk():
            if (self.options or {}).get("useSelection"):
                nodes = cmds.ls(selection=True)

            instance = cmds.sets(nodes, name=self.name)
            lib.imprint(instance, self.data)

        return instance 

def update_hierarchy(containers):
    """Hierarchical container support

    This is the function to support Scene Inventory to draw hierarchical
    view for containers.

    We need both parent and children to visualize the graph.

    """
    container_names = set(_ls())  # lookup set

    for container in containers:
        # Find parent
        parent = cmds.listSets(object=container["objectName"]) or []
        for node in parent:
            if node in container_names:
                container["parent"] = node
                break

        # List children
        children = cmds.ls(cmds.sets(container["objectName"], query=True),
                           type="objectSet")
        container["children"] = [child for child in children
                                 if child in container_names]

        yield container