Exemplo n.º 1
0
def ldmt_turboSmooth():
    mods = cmds.getModifiers()
    mel.eval('resetPolySelectConstraint;')
    sel = cmds.ls(sl=1,o=1)
    sel = sel[0]
    cmds.select(sel+'.e[*]',r=1)
    cmds.polySelectConstraint(m=3,t=0x8000,sm=1)
    cmds.sets(n="ldmt_turboSmoothQS")
    currentSel = cmds.ls(sl=1)
    if currentSel != []:
        try:
            cmds.polyCrease(value=1)
        except:
            pass
    cmds.select(sel,r=1)
    cmds.polySmooth(sel,mth=0,sdt=2,ovb=2,ofb=3,ofc=1,ost=1,ocr=1,dv=1,bnr=1,c=0,kb=0,ksb=1,khe=1,kt=0,kmb=0,suv=1,peh=1,sl=1,dpe=1,ps=0.1,ro=1,ch=1)
    cmds.select("ldmt_turboSmoothQS",r=1)
    currentSel = cmds.ls(sl=1)
    if currentSel != []:
        try:
            cmds.polySoftEdge(a=0,ch=1)
            cmds.polyCrease(value=0)
        except:
            pass
        if mods == 4:
            try:
                cmds.polyCrease(value=1)
            except:
                pass
    cmds.polySelectConstraint(m=0,dis=1)
    cmds.select(sel,r=1)
    cmds.delete("ldmt_turboSmoothQS")
Exemplo n.º 2
0
def selectLaminaFaces():
	"""
	Selects the lamina faces.
	"""

	cmds.polySelectConstraint(m=3, t=8, tp=2)
	cmds.polySelectConstraint(m=0)
Exemplo n.º 3
0
def selectTrianglesFaces():
    """
	This definition selects triangles faces.
	"""

    cmds.polySelectConstraint(m=3, t=8, sz=1)
    cmds.polySelectConstraint(dis=True)
Exemplo n.º 4
0
def uv_borders(lssl=None, dosel=None):
    tim = cm.timerX(st=1)

    lssl = cm.ls(lssl)
    if not lssl:
        lssl = [x for x
                  in cm.ls(tr=1)
                  if cm.listRelatives(x, s=1, type="mesh")]
    
    for sel in lssl:
        # split first
        uvs = cm.ls(sel+".map[*]")
        cm.select(uvs)
        # bord_uvs = cm.polySelectConstraint(
        #     t=0x0010, uv=0, bo=1, m=2, returnSelection=1)
        bord_uvs = cm.polySelectConstraint(
            t=0x0010, uv=0, bo=1, m=2, returnSelection=1)
        # cm.select(bord_uvs)
        # ed = cm.ls(sl=1)[0]
        edgs = cm.filterExpand(cm.polyListComponentConversion(bord_uvs, te=1, internal=1), sm=32)
        uv2edg = []
        for ed in edgs:
            # cm.select(ed)
            uvs = cm.filterExpand(cm.polyListComponentConversion(ed, tuv=1), sm=35)
            if len(uvs) > 2:
                uv2edg.append(ed)
    print ("Finidshed in: ", cm.timerX(st=1) - tim)
    cm.polySelectConstraint(bo=0)
    if dosel:
        cm.select(uv2edg)
    else:
        cm.select(lssl)
    return uv2edg
Exemplo n.º 5
0
def polyConstraint(components, *args, **kwargs):
    """Return the list of *components* with the constraints applied.

    A wrapper around Maya's `polySelectConstraint` to retrieve its results as
    a list without altering selections. For a list of possible constraints
    see `maya.cmds.polySelectConstraint` documentation.

    Arguments:
        components (list): List of components of polygon meshes

    Returns:
        list: The list of components filtered by the given constraints.

    """

    kwargs.pop('mode', None)

    with no_undo(flush=False):
        with maya.maintained_selection():
            # Apply constraint using mode=2 (current and next) so
            # it applies to the selection made before it; because just
            # a `maya.cmds.select()` call will not trigger the constraint.
            with reset_polySelectConstraint():
                cmds.select(components, r=1, noExpand=True)
                cmds.polySelectConstraint(*args, mode=2, **kwargs)
                result = cmds.ls(selection=True)
                cmds.select(clear=True)

    return result
Exemplo n.º 6
0
def selectNsidesFaces():
    """
	This definition selects nsides faces.
	"""

    cmds.polySelectConstraint(m=3, t=8, sz=3)
    cmds.polySelectConstraint(dis=True)
Exemplo n.º 7
0
def getTris(q=False):
    '''
    Selects Triangles in Selection

    Args:
        q(boolean): if true function returns the selection.

    Return:
        result(list): the triangles in the selection
    '''
    cmds.selectMode(co=True)
    cmds.selectType(smp=False,
                    sme=True,
                    smf=False,
                    smu=False,
                    pv=False,
                    pe=True,
                    pf=False,
                    puv=False)
    cmds.polySelectConstraint(mode=3, t=0x0008, size=1)
    cmds.polySelectConstraint(disable=True)
    nPolys = cmds.polyEvaluate(faceComponent=True)
    print >> sys.stderr, str(nPolys) + ' Triangles(s) Selected.',

    if q:
        result = cmds.ls(sl=True, fl=True)
        return result
Exemplo n.º 8
0
def run():
    """Detect overlapping (lamina) faces. Lamina faces are faces that share all of their edges. 
    ---
    Returns True/False, the number of isolated vertices and a list of the isolated vertices
    has_isolatedvertices2() -> (boolean, int, [mesh:v[id],])
    """
    t0 = float(time.time())
    verbose = cmds.optionVar(query='checkmateVerbosity')
    result=False
    # meshes = cmds.ls(type='mesh')
    meshes = [x for x in cmds.ls(typ='mesh', noIntermediate=True) if not cm.tests.shapes.mesh.isEmpty(x)]
    try:
        cmds.select(meshes)
    except TypeError:
    	print "# Warning: No meshes in scene"
    cmds.selectType( pf=True ) 
    cmds.polySelectConstraint(
        mode=3, # all and next
        type=0x0008, # faces
        topology=2, # lamina
        )
    sel=cmds.ls(sl=True, fl=True)
    result =  (len(sel) > 0) or False
    cmds.polySelectConstraint(disable=True)
    try:
        cmds.select(sel)
    except TypeError:
    	pass 
    # print execution time
    print '%-24s : %.6f seconds' % ('f.lamina.run()', (float(time.time())-t0))
    return (result, len(sel), sel)
Exemplo n.º 9
0
def uvShells():
    """
		List all the shells based in our uv's selection
		Returns:
			list with list of shells

		"""
    selection = mc.ls(sl=True, fl=True, type='float2')
    TotalShells = []

    while len(selection) > 0:

        mc.select(selection[0], r=True)
        mc.polySelectConstraint(type=0x0010, shell=1, border=0, mode=2)
        mc.polySelectConstraint(shell=0, border=0, mode=0)
        shell = mc.ls(sl=True, fl=True)
        mc.select(clear=True)

        TotalShells.append(shell)

        for delete in shell:
            if delete in selection:
                selection.remove(delete)

    return TotalShells
Exemplo n.º 10
0
def SetVertexColorForBorderVertices():
    with mayaUtils.DebugTimer('SetVertexColorForBorderVertices'):
        skinList = cmds.ls(type='skinCluster')
        cmds.select(clear=True)

        for s in skinList:
            cmds.select(clear=True)
            mesh = mayaUtils.GetMeshFromSkinCluster(s)
            cmds.select(mesh)
            cmds.selectType(polymeshFace=True)
            cmds.polySelectConstraint(mode=3, type=8,
                                      where=1)  # to get border vertices
            borderVerts = cmds.polyListComponentConversion(tv=True)
            cmds.polySelectConstraint(mode=0, sh=0, bo=0)
            cmds.select(clear=True)

            allVerts = cmds.polyListComponentConversion(mesh, tv=True)
            mayaUtils.SetVertexColors(allVerts, (1, 1, 1))
            mayaUtils.SetVertexColors(borderVerts, (0, 1, 1))

        cmds.select(clear=True)

        shape = mayaUtils.FindMeshByWildcard(
            'FemaleBody*', checkForMatWithName='Body')  #new name is 'Body'
        if shape:
            MaskShellsEdgesForTesselation(shape, 0)
            MaskShellsEdgesForTesselation(shape, 1)
            MaskShellsEdgesForTesselation(shape, 2)
            MaskShellsEdgesForTesselation(shape, 3)
            MaskShellsEdgesForTesselation(shape, 4)
Exemplo n.º 11
0
def selectLaminaFaces():
    """
	This definition selects the lamina faces.
	"""

    cmds.polySelectConstraint(m=3, t=8, tp=2)
    cmds.polySelectConstraint(m=0)
Exemplo n.º 12
0
    def bGFAll(self, *args):

        allGeo = []

        cmds.selectMode(q=True, co=True)

        for i in range(1, 4):

            cmds.polySelectConstraint(m=3, t=0x0008, sz=i)
            cmds.polySelectConstraint(dis=True)

            bGFPolys = cmds.polyEvaluate(fc=True)

            allGeo.append(bGFPolys)

        print allGeo

        try:
            cmds.textField(self.bGF_results,
                           e=True,
                           tx=("%s Triangle(s)" % int(allGeo[0]) + '\n' +
                               "%s Quad(s)" % int(allGeo[1]) + '\n' +
                               "%s N-Gons(s)" % int(allGeo[2])))
        except:
            cmds.textField(self.bGF_results,
                           e=True,
                           tx=("Nothing is selected."))
Exemplo n.º 13
0
def run():
    """Detect faces without uvs.  
    ---
    Show associated geometry for missingUVS
    returns True/False, the number of isolated vertices and a list of the isolated vertices
    has_unmappedfaces() -> (boolean, int, [mesh:v[id],])
    """
    t0 = float(time.time())
    verbose = cmds.optionVar(query='checkmateVerbosity')
    result=False
    # meshes = cmds.ls(type='mesh')
    meshes = [x for x in cmds.ls(typ='mesh', noIntermediate=True) if not cm.tests.shapes.mesh.isEmpty(x)]
    try:
        cmds.select(meshes)
    except TypeError:
    	print "# Warning: No meshes in scene"
    cmds.selectType( pf=True ) 
    cmds.polySelectConstraint(
        mode=3, # all and next
        type=0x0008, # faces
        textured=2, # unmapped
        )
    sel=cmds.ls(sl=True, fl=True)
    result =  (len(sel) > 0) or False
    cmds.polySelectConstraint(disable=True)
    try:
        cmds.select(sel)
    except TypeError:
    	pass 
    # print execution time
    print '%-24s : %.6f seconds' % ('uv.missing.run()', (float(time.time())-t0))
    return (result, len(sel), sel)
Exemplo n.º 14
0
def selectBorderEdges():
	"""
	Selects the border edges.
	"""

	cmds.polySelectConstraint(m=3, t=0x8000, w=1)
	cmds.polySelectConstraint(m=0)
    def _exportMeshes(self):
        mc.currentTime(mc.playbackOptions(q=True, ast=True))

        # export all
        if self.accessMode == MPxFileTranslator.kExportAccessMode:
            meshes = self._getMeshes(mc.ls(typ='mesh'))

        # export selection
        elif self.accessMode == MPxFileTranslator.kExportActiveAccessMode:
            transformObjs = mc.ls(sl=1)
            if not len(transformObjs):
                print 'ERROR: Nothing Selected - please select an object and try again'
                raise ThreeJsError('ERROR: Nothing Selected: {0}'.format(
                    self.accessMode))
            meshes = self._getMeshes(transformObjs)
        else:
            raise ThreeJsError('Unsupported access mode: {0}'.format(
                self.accessMode))

        for mesh in meshes:
            #print mesh
            mc.currentTime(mc.playbackOptions(q=True, ast=True))

            mc.polySelectConstraint(dis=True)
            mc.select(mesh)
            sel = MSelectionList()
            MGlobal.getActiveSelectionList(sel)
            mDag = MDagPath()
            mComp = MObject()
            sel.getDagPath(0, mDag, mComp)
            self.gotoBindPose()
            self._exportMesh(mDag, mComp, mesh)
            self._exportBones(mesh, mDag)
Exemplo n.º 16
0
def selectZeroGeometryAreaFaces():
	"""
	Selects the zero geometry area faces.
	"""

	cmds.polySelectConstraint(m=3, t=8, ga=True, gab=(0, 0.001))
	cmds.polySelectConstraint(m=0)
Exemplo n.º 17
0
def selectZeroGeometryAreaFaces():
    """
	This definition selects the zero geometry area faces.
	"""

    cmds.polySelectConstraint(m=3, t=8, ga=True, gab=(0, 0.001))
    cmds.polySelectConstraint(m=0)
Exemplo n.º 18
0
def selectStarVertices():
    """
	This definition selects star vertices.
	"""

    cmds.polySelectConstraint(m=3, t=1, order=True, orb=(5, 65535))
    cmds.polySelectConstraint(dis=True)
Exemplo n.º 19
0
    def get_umvs(self):
        # get object selected
        obj = self.dictOfSceneObjects[self.indexed]

        # Turn into vert selection
        verts = cm.polyListComponentConversion(obj, tv=True)
        cm.select(verts)

        # Filter verts to border only
        cm.polySelectConstraint(
            m=3,
            t=1,
            w=1,
            bo=0,
            sh=0,
            cr=0,
        )

        # Count
        num_v = cm.ls(sl=1, fl=1)
        cm.polySelectConstraint(
            m=0,
            t=0,
            # w=0,  # disabled for now
        )

        return len(num_v)
Exemplo n.º 20
0
def selectNonManifoldVertices():
	"""
	Selects the non manifold vertices.
	"""

	cmds.polySelectConstraint(m=3, t=1, nonmanifold=True)
	cmds.polySelectConstraint(m=0)
Exemplo n.º 21
0
def selectHardEdges():
	"""
	Selects the hard edges.
	"""

	cmds.polySelectConstraint(m=3, t=0x8000, sm=1)
	cmds.polySelectConstraint(m=0)
Exemplo n.º 22
0
def selectStarVertices():
	"""
	Selects star vertices.
	"""

	cmds.polySelectConstraint(m=3, t=1, order=True, orb=(5, 65535))
	cmds.polySelectConstraint(dis=True)
Exemplo n.º 23
0
def selectHardEdges():
    """
	This definition selects the hard edges.
	"""

    cmds.polySelectConstraint(m=3, t=0x8000, sm=1)
    cmds.polySelectConstraint(m=0)
Exemplo n.º 24
0
def selectTrianglesFaces():
	"""
	Selects triangles faces.
	"""

	cmds.polySelectConstraint(m=3, t=8, sz=1)
	cmds.polySelectConstraint(dis=True)
Exemplo n.º 25
0
def triFinder(nodeListInput):
    nodeList = nodeListInput
    triObjects = []
    mel.select(clear=1)
    for node in nodeList:
        mel.select(node, add=1)
    ##This line constrains the selection to faces with 3 sides and then selects them.
    ##It also constrains the selection to tris so it must be reset before exiting.
    mel.polySelectConstraint(mode=3, type=8, size=1)
    triFaces = mel.ls(selection=1)
    for item in triFaces:
        tempHolder = item.split('.')
        triObjects.append(tempHolder[0])
    newRange = []
    range = []
    for x in triFaces:
        if ":" in x:
            triFaces.remove(x)
            range.append(x)
    newRange = rangeSplit(range)
    for t in newRange:
        triFaces.append(t)
    ##This resets the selection to 'normal'
    mel.polySelectConstraint(mode=0, type=8, size=0)
    triObjects = list(set(triObjects))
    mel.select(clear=1)

    return triObjects, triFaces
Exemplo n.º 26
0
def createCurves() :
    
    #get border edges
    cmds.polySelectConstraint(m=3, t=0x8000, w=1)

    borderEdges = cmds.ls(sl=True, fl=True)

    cmds.polySelectConstraint(dis=True)
    
    #create curves
    
    curveList = []
    
    for eachBorder in borderEdges :
        cmds.select(eachBorder, r=True)
        edgeLoopBorder = cmds.pickWalk(d='right', type='edgeloop')
        edgeLoopBorders = cmds.ls(sl=True, fl=True)
        createCurve=mel.eval("polyToCurve -form 0 -degree 1;")
        curveList.append(createCurve[0])
        
        for edgeLo in edgeLoopBorders :
            borderEdges.remove(edgeLo)
        
        cmds.select(createCurve, r=True)
        mel.eval("DeleteHistory;")
        
    for eachCurve in curveList :
        index = curveList.index(eachCurve)
        cutBirailCurves(eachCurve, index)
Exemplo n.º 27
0
    def nGonFinder(self, inputNodes):
        nodeList = inputNodes
        nSidedObjects = []
        cmds.select(clear=1)
        for node in nodeList:
            cmds.select(node, add=1)
        ##This line constrains the selection to faces with more than 4 sides and then selects them.
        ##It also constrains the selection to N-gons so it must be reset before exiting.
        cmds.polySelectConstraint(mode=3, type=8, size=3)
        nSidedFaces = cmds.ls(selection=1)
        for item in nSidedFaces:
            tempHolder = item.split('.')
            nSidedObjects.append(tempHolder[0])
        newRange = []
        range = []
        for x in nSidedFaces:
            if ":" in x:
                nSidedFaces.remove(x)
                range.append(x)
        newRange = self.rangeSplit(range)
        for t in newRange:
            nSidedFaces.append(t)
        #This resets the selection to 'normal'
        cmds.polySelectConstraint(mode=0, type=8, size=0)
        nSidedObjects = list(set(nSidedObjects))
        cmds.select(clear=1)

        return nSidedObjects, nSidedFaces
Exemplo n.º 28
0
def degenerate():
    """Detect Isolated Vertices. Isolated vertices are vertices that are not 
    connected to another vertex by two edges.
    --
    returns True/False, the number of isolated vertices and a list of the 
    isolated vertices
    has_isolatedvertices() -> (boolean, int, [mesh:v[id],])
    """
    t0 = float(time.time())
    verbose = cmds.optionVar(query='checkmateVerbosity')
    result=False
    # meshes = cmds.ls(type='mesh')
    meshes = [x for x in cmds.ls(typ='mesh', noIntermediate=True) if not cm.tests.shapes.mesh.isEmpty(x)]
    try:
        cmds.select(meshes)
    except TypeError:
    	print "# Warning: No meshes in scene"
    cmds.selectType( pf=True ) 
    cmds.polySelectConstraint(
        mode=3, # all and next
        type=0x0001, # vertices
        where=2, # inside
        order=2, # neighbours
        orderbound=[0,1] # min and max neighbours
        )
    sel=cmds.ls(sl=True, fl=True)
    cmds.polySelectConstraint(disable=True)
    result =  (len(sel) > 0) or False
    print '%-24s : %.6f seconds' % ('isolated.run()', (float(time.time())-t0)) 
    return (result, len(sel), sel)
	def _exportMeshes(self):
		mc.currentTime(mc.playbackOptions(q=True, ast=True))
		
		# export all
		if self.accessMode == MPxFileTranslator.kExportAccessMode:
			meshes = self._getMeshes(mc.ls(typ='mesh'))
			
		# export selection
		elif self.accessMode == MPxFileTranslator.kExportActiveAccessMode:
			transformObjs = mc.ls(sl=1)
			if not len(transformObjs):
				print 'ERROR: Nothing Selected - please select an object and try again'
				raise ThreeJsError('ERROR: Nothing Selected: {0}'.format(self.accessMode))
			meshes = self._getMeshes(transformObjs)
		else:
			raise ThreeJsError('Unsupported access mode: {0}'.format(self.accessMode))
			
		for mesh in meshes:
			#print mesh
			mc.currentTime(mc.playbackOptions(q=True, ast=True))
			
			mc.polySelectConstraint(dis=True)
			mc.select(mesh)
			sel = MSelectionList()
			MGlobal.getActiveSelectionList(sel)
			mDag = MDagPath() 
			mComp = MObject()
			sel.getDagPath(0, mDag, mComp)
			self.gotoBindPose()
			self._exportMesh(mDag, mComp, mesh)
			self._exportBones(mesh,mDag)
Exemplo n.º 30
0
def selectBorderEdges():
    """
	This definition selects the border edges.
	"""

    cmds.polySelectConstraint(m=3, t=0x8000, w=1)
    cmds.polySelectConstraint(m=0)
Exemplo n.º 31
0
def run():
    """Detect Isolated Vertices. Isolated vertices are the result of deleting 
    edges with Delete rather than with the Delete Edge/Vertex. Using Delete 
    leaves the vertices in place that connected the deleted edge(s). This test 
    ignores vertices on borders, where having such vertices is not a problem.
    ---
    returns True/False, the number of isolated vertices and a list of the 
    isolated vertices
    has_isolatedvertices2() -> (boolean, int, list)
    """
    t0 = float(time.time())
    verbose = cmds.optionVar(query='checkmateVerbosity')
    result=False
    # meshes = cmds.ls(type='mesh')
    meshes = [x for x in cmds.ls(typ='mesh', noIntermediate=True) if not cm.tests.shapes.mesh.isEmpty(x)]
    try:
        cmds.select(meshes)
    except TypeError:
    	print "# Warning: No meshes in scene"
    cmds.selectType( pf=True ) 
    cmds.polySelectConstraint(
        mode=3, # all and next
        type=0x0001, # vertices
        where=2, # inside
        order=2, # neighbours
        orderbound=[2,2] # min and max neighbours
        )
    sel=cmds.ls(sl=True, fl=True)
    cmds.polySelectConstraint(disable=True)
    result =  (len(sel) > 0) or False
    print '%-24s : %.6f seconds' % ('vtx.isolated.run()', (float(time.time())-t0)) 
    return (result, len(sel), sel)
Exemplo n.º 32
0
def addShader(face, shader):
    cmds.select(face)
    cmds.polySelectConstraint(pp=1)
    selection = cmds.ls(sl=True)
    selection.remove(face)
    faces = selection[0]
    cmds.sets(faces, e=True, forceElement=shader+"SG")
Exemplo n.º 33
0
def selectNsidesFaces():
	"""
	Selects nsides faces.
	"""

	cmds.polySelectConstraint(m=3, t=8, sz=3)
	cmds.polySelectConstraint(dis=True)
Exemplo n.º 34
0
def selectNonManifoldVertices():
    """
	This definition selects the non manifold vertices.
	"""

    cmds.polySelectConstraint(m=3, t=1, nonmanifold=True)
    cmds.polySelectConstraint(m=0)
Exemplo n.º 35
0
    def tear_down(self):
        if self.mode == self.HILITED:
            cmds.polySelectConstraint(disable=True)

        if self.add:
            cmds.select(list(self.old_selection), add=True)
        self.label.close()
Exemplo n.º 36
0
 def _setup_hilited(self):
     cmds.polySelectConstraint(
         type=0x0008,
         mode=3,
         orient=1,
         orientbound=[0, self.threshold],
         orientaxis=self.normal
     )
Exemplo n.º 37
0
def creaseHardEdges():
    #crsAmt = 10
    crsAmt = cmds.floatSliderGrp('crsAmt', q=True, value=True)
    cmds.selectType(pe=True)  # Selects Edges
    cmds.polySelectConstraint(m=3, t=0x8000,
                              sm=1)  # Constrains selection to hard edges
    cmds.polyCrease(value=crsAmt)
    cmds.polySelectConstraint(sm=0)  # Turns off contraint
Exemplo n.º 38
0
 def searchConcaveFaces(self, mesh):
     cmds.select(mesh, r=True)
     mel.eval("PolySelectConvert 1")
     cmds.polySelectConstraint(mode=3, convexity=1, type=8)
     cmds.polySelectConstraint(mode=0, convexity=0, type=8)
     concaveFacesList = cmds.ls(sl=True, fl=True, r=True)
     cmds.select(d=True)
     return concaveFacesList
Exemplo n.º 39
0
def expandSelection():
    '''Expands current component selection to its max bounds'''
    oldSize = len(cmds.filterExpand(sm=[28,29,31,32,33,34,35]))
    while(1):
        cmds.polySelectConstraint(pp=1,t=0x00100)
        newSize = len(cmds.filterExpand(sm=[28,29,31,32,33,34,35]))
        if oldSize == newSize: break
        oldSize = newSize
Exemplo n.º 40
0
def expandSelection():
    '''Expands current component selection to its max bounds'''
    oldSize = len(cmds.filterExpand(sm=[28, 29, 31, 32, 33, 34, 35]))
    while (1):
        cmds.polySelectConstraint(pp=1, t=0x00100)
        newSize = len(cmds.filterExpand(sm=[28, 29, 31, 32, 33, 34, 35]))
        if oldSize == newSize: break
        oldSize = newSize
Exemplo n.º 41
0
 def Action_SelectBorder():
     maya_cmds.undoInfo(openChunk=True)
     try:
         maya_cmds.ConvertSelectionToEdges()
         maya_cmds.polySelectConstraint(mode=2, type=0x8000, where=1)
         mel_eval('resetPolySelectConstraint')
     except Exception as e:
         print >> stderr, str(e)
     maya_cmds.undoInfo(closeChunk=True)
Exemplo n.º 42
0
def Hardedge_Check(*args):
    obj = cmds.ls(selection=True)  # 存储当前选择物体
    cmds.polySelectConstraint(m=3, t=0x8000, sm=1)  # 只选择硬边
    sel = cmds.ls(selection=True)  # 存储选择边
    cmds.polySelectConstraint(sm=0)  # 还原选zhi择约束
    cmds.select(obj)  # 还原之前选择的物体
    cmds.selectMode(component=True)  # 更改选择模式
    cmds.selectType(edge=True)  # 更改选择项为到边模式
    cmds.select(sel)  # 选择存储的边
Exemplo n.º 43
0
def run(*args, **kwargs):
    """8a. Extra. Find faces with 0 surface area. These look like edges, 
    but cause shading problems  
    ---
    returns True/False, the number of 0 area faces
    and a list of faces.
    has_zeroareafaces -> (boolean, int, [mesh:f[id],])
    """
    t0 = float(time.time())
    valid_kwargs = ['verbose']
    for k, v in kwargs.iteritems():
        if k not in valid_kwargs:
            raise TypeError("Invalid keyword argument %s" % k)  
    result = False
    err = list()
    verbose = False
    # verbose defaults to False if verbose option not set in menu 
    # or specified in cmdline
    try:
        verbose = kwargs['verbose']
    except KeyError:
    	verbose = False
    	if cmds.optionVar(exists='checkmateVerbosity'):
    		verbose = cmds.optionVar(query='checkmateVerbosity')
    else:
        verbose = False
    
    result=False
    meshes = cmds.ls(type='mesh', noIntermediate=True, long=True)
    if verbose: print 'before: ',  meshes
    meshes = [x for x in meshes if not cm.tests.shapes.mesh.isEmpty(x)]
    if verbose: print 'after :', meshes
    try:
        cmds.select(meshes)
    except TypeError:
    	print "# Warning: No meshes in scene"
    if verbose: print 'line 805'	
    cmds.selectType( pf=True ) 
    if verbose: print 'line 807'	
    cmds.polySelectConstraint(
        mode=3, # all and next
        type=0x0008, # faces
        geometricarea=True,
        geometricareabound = [0.0, 0.00001], # zero area
        )
    if verbose: print 'line 814'	
    
    sel=cmds.ls(sl=True, fl=True)
    result =  (len(sel) > 0) or False
    cmds.polySelectConstraint(disable=True)
    try:
        cmds.select(sel)
    except TypeError:
    	pass 
    print '%-24s : %.6f seconds' % ('f.area.run()', (float(time.time())-t0)) 
    return (result, len(sel), sel)
Exemplo n.º 44
0
def averageInsideVertices(mesh):
    """
  This function grabs the inside vertices of the mesh and average out the distance between
  Args:
    mesh: The mesh to average vertices
  """
    cmds.select(mesh)
    cmds.polySelectConstraint(m=3, t=0x0001, w=2)
    cmds.polySelectConstraint(dis=True)
    cmds.polyAverageVertex(i=10, ch=0)
Exemplo n.º 45
0
 def changeSelectionConstraint(self, *args):
     mode = cmds.radioButtonGrp(self.selectionModeRadioButton,
                                q=True,
                                select=True)
     if mode == 1:
         cmds.polySelectConstraint(disable=True)
     elif mode == 2:
         cmds.polySelectConstraint(disable=True)
         cmds.polySelectConstraint(shell=True)
     elif mode == 3:
         cmds.polySelectConstraint(disable=True)
     elif mode == 4:
         cmds.polySelectConstraint(disable=True)
Exemplo n.º 46
0
def Upgrade():
    mc.selectMode(co=True)
    Hard = mc.ls(sl=True)  #gets selection
    mc.polySelectConstraint(m=3, t=0x8000,
                            sm=1)  #constraints hard edges and selects them
    mc.polyBevel3(fraction=0.5,
                  offsetAsFraction=1,
                  depth=1,
                  chamfer=0,
                  segments=1,
                  subdivideNgons=1,
                  mergeVertices=1)
    mc.polySelectConstraint(sm=0)  # turn off edge smoothness constraint
Exemplo n.º 47
0
def hasBorderEdges(object):
	"""
	This definition returns if an object has border edges.

	:param object: Object. ( String )
	:return: Has object border edges. ( Boolean )
	"""

	cmds.select(object)
	cmds.polySelectConstraint(m=3, t=0x8000, w=1)
	cmds.polySelectConstraint(m=0)
	if cmds.ls(sl=True):
		return True
Exemplo n.º 48
0
def GetBorderVertices(mesh):
    cmds.select(clear=True)
    borderVertsList = []

    cmds.select(mesh)
    cmds.selectType(polymeshEdge=True)
    cmds.polySelectConstraint(mode=3, type=0x8000,
                              where=1)  # to get border vertices
    borderVerts = cmds.polyListComponentConversion(tv=True)
    borderVertsList.extend(borderVerts)
    cmds.polySelectConstraint(mode=0, sh=0, bo=0)
    cmds.select(clear=True)
    return borderVertsList
Exemplo n.º 49
0
def polySelectTraverse(traversal=1):
    """
    Grow polyComponent selection

    :param traversal: 0 = Off.
                      1 = More : will add current selection border to current selection.
                      2 = Less : will remove current selection border from current selection.
                      3 = Border : will keep only current selection border.
                      4 = Contiguous Edges : Add edges aligned with the current edges selected
    :type traversal: int
    """
    #--- Vertex ---#
    result = mc.polyListComponentConversion(fv=True, tv=True)
    if result:
        mc.polySelectConstraint(pp=traversal, t=0x0001)
    else:
        #--- Edge ---#
        result = mc.polyListComponentConversion(fe=True, te=True)
        if result:
            mc.polySelectConstraint(pp=traversal, t=0x8000)
        else:
            #--- Face ---#
            result = mc.polyListComponentConversion(ff=True, tf=True)
            if result:
                mc.polySelectConstraint(pp=traversal, t=0x0008)
            else:
                #--- Uv ---#
                result = mc.polyListComponentConversion(fuv=True, tuv=True)
                if result:
                    mc.polySelectConstraint(pp=traversal, t=0x0010)
Exemplo n.º 50
0
Arquivo: miUV.py Projeto: minoue/miUV
 def changeSelectionConstraint(self, *args):
     mode = cmds.radioButtonGrp(
         self.selectionModeRadioButton,
         q=True,
         select=True)
     if mode == 1:
         cmds.polySelectConstraint(disable=True)
     elif mode == 2:
         cmds.polySelectConstraint(disable=True)
         cmds.polySelectConstraint(shell=True)
     elif mode == 3:
         cmds.polySelectConstraint(disable=True)
     elif mode == 4:
         cmds.polySelectConstraint(disable=True)
Exemplo n.º 51
0
    def drag_left(self):
        change = (self.dragPoint[0] - self.anchorPoint[0]) * 0.001
        self.value = change + self.default
        if self.value < self.min:
            self.value = self.min
        elif self.value > self.max:
            self.value = self.max

        if self.mode == self.HILITED:
            cmds.polySelectConstraint(orientbound=[0, self.value * 180])
        elif self.mode == self.OBJECT:
            self._update_object()
        elif self.mode == self.CONTIGUOUS:
            self._update_contiguous()
Exemplo n.º 52
0
def polySelectTraverse(traversal=1):
    """
    Grow polyComponent selection

    :param traversal: 0 = Off.
                      1 = More : will add current selection border to current selection.
                      2 = Less : will remove current selection border from current selection.
                      3 = Border : will keep only current selection border.
                      4 = Contiguous Edges : Add edges aligned with the current edges selected
    :type traversal: int
    """
    #--- Vertex ---#
    result = mc.polyListComponentConversion(fv=True, tv=True)
    if result:
        mc.polySelectConstraint(pp=traversal, t=0x0001)
    else:
        #--- Edge ---#
        result = mc.polyListComponentConversion(fe=True, te=True)
        if result:
            mc.polySelectConstraint(pp=traversal, t=0x8000)
        else:
            #--- Face ---#
            result = mc.polyListComponentConversion(ff=True, tf=True)
            if result:
                mc.polySelectConstraint(pp=traversal, t=0x0008)
            else:
                #--- Uv ---#
                result = mc.polyListComponentConversion(fuv=True, tuv=True)
                if result:
                    mc.polySelectConstraint(pp=traversal, t=0x0010)
def cleanupHierarchicalSubdivisionConversion(object):
	"""
	This definition cleans Maya hierarchical polygonal conversion.

	:param object: Object to cleanup. ( String )
	"""

	cmds.select(object)
	cmds.polySelectConstraint(m=3, t=8, sz=3)
	cmds.polySelectConstraint(dis=True)
	nsidesFaces = cmds.ls(sl=True, l=True, fl=True)
	cmds.select(nsidesFaces)
	cmds.polySelectConstraint(m=3, t=1, order=True, orb=(3, 3))
	cmds.polySelectConstraint(dis=True)
	nsideVertices = cmds.ls(sl=True, l=True, fl=True)
	offendingEdges = []
	for vertice in nsideVertices:
		faces = cmds.ls(cmds.polyListComponentConversion(vertice, fv=True, tf=True), fl=True, l=True)
		faces = [face for face in faces if not face in nsidesFaces]
		if len(faces) == 2:
			faceEdgesA = cmds.ls(cmds.polyListComponentConversion(faces[0], ff=True, te=True), fl=True, l=True)
			faceEdgesB = cmds.ls(cmds.polyListComponentConversion(faces[1], ff=True, te=True), fl=True, l=True)
			sharedEdge = list(set(faceEdgesA).intersection(faceEdgesB))
			offendingEdges.append(sharedEdge[0])
	cmds.polySelectSp(offendingEdges, loop=True)
	cmds.polyDelEdge(cmds.ls(sl=True), cv=True, ch=True)
	cmds.select(object)
Exemplo n.º 54
0
def hasBorderEdges(object):
	"""
	Returns if an object has border edges.

	:param object: Object.
	:type object: str
	:return: Has object border edges.
	:rtype: bool
	"""

	cmds.select(object)
	cmds.polySelectConstraint(m=3, t=0x8000, w=1)
	cmds.polySelectConstraint(m=0)
	if cmds.ls(sl=True):
		return True
Exemplo n.º 55
0
 def checkTriangle (self, *args):        
     cmds.select(cmds.ls(type="mesh"))
 
     # to get triangles
     cmds.selectMode( co=True )
     cmds.selectType( pf=True )
     cmds.polySelectConstraint( m=3, t=8, sz=1 ) 
     
     components = cmds.ls(sl=True)
     self.updateButton(components, self.widgets['checkTriangle_button'], self.widgets['selectTriangle_button'])
     
     cmds.polySelectConstraint( sz=0 ) # turn off face size constraint
     cmds.selectMode( o=True )
     
     return components
Exemplo n.º 56
0
 def checkNonTriangulatable (self, *args):        
     cmds.select(cmds.ls(type="mesh"))
 
     # to get triangles
     cmds.selectMode( co=True )
     cmds.selectType( pf=True)
     cmds.polySelectConstraint( m=3, t=8, tp=1 ) 
     
     components = cmds.ls(sl=True)
     self.updateButton(components, self.widgets['checkNonTriangulatable_button'], self.widgets['selectNonTriangulatable_button'])
     
     cmds.polySelectConstraint( tp=0 ) # turn off the face topology constraint
     cmds.selectMode( o=True )
     
     return components
Exemplo n.º 57
0
def hasBorderEdges(object):
    """
	Returns if an object has border edges.

	:param object: Object.
	:type object: str
	:return: Has object border edges.
	:rtype: bool
	"""

    cmds.select(object)
    cmds.polySelectConstraint(m=3, t=0x8000, w=1)
    cmds.polySelectConstraint(m=0)
    if cmds.ls(sl=True):
        return True
Exemplo n.º 58
0
    def badNGons(self):
        sel = cmds.ls(sl=1)

        cmds.selectMode(q=1, co=1)

        cmds.polySelectConstraint(m=3, t=0x0008, sz=3)
        cmds.polySelectConstraint(dis=1)

        numPolys = cmds.polyEvaluate(fc=1)

        try:
            self.polyCountLabel.setText('Poly Counts: %s N-Gon(s)' %
                                        str(int(numPolys)))
        except:
            self.polyCountLabel.setText('Please Select a Mesh!')
Exemplo n.º 59
0
def addShader(face, shader):
    """
    Adds shader to the given face.

    @param face string
        A polygon face.
    @param shader string
        The shader to apply.
    """
    cmds.select(face)
    cmds.polySelectConstraint(pp=1)
    selection = cmds.ls(sl=True)
    selection.remove(face)
    faces = selection[0]
    cmds.sets(faces, e=True, forceElement=shader+"SG")
Exemplo n.º 60
0
def nGons(meshList=[]):
    """
    Return a list of all polygon faces with more than 4 sides in a specified list of meshes.
    @param meshList: List of meshes to check for triangles
    @type meshList: list
    """
    # Check Mesh List
    meshList = getMeshList(meshList)
    if not meshList: return []

    # Find N-Gons
    cmds.select(meshList)
    cmds.polySelectConstraint(mode=3, type=0x0008, size=3)
    cmds.polySelectConstraint(disable=True)
    ngon = cmds.filterExpand(ex=True, sm=34) or []
    cmds.select(meshList)

    # Return Result
    return ngon