def selectNsidesFaces():
	"""
	Selects nsides faces.
	"""

	cmds.polySelectConstraint(m=3, t=8, sz=3)
	cmds.polySelectConstraint(dis=True)

	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)

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)

def selectLaminaFaces():
	"""
	Selects the lamina faces.
	"""

	cmds.polySelectConstraint(m=3, t=8, tp=2)
	cmds.polySelectConstraint(m=0)

def selectBorderEdges():
	"""
	Selects the border edges.
	"""

	cmds.polySelectConstraint(m=3, t=0x8000, w=1)
	cmds.polySelectConstraint(m=0)

def selectHardEdges():
	"""
	Selects the hard edges.
	"""

	cmds.polySelectConstraint(m=3, t=0x8000, sm=1)
	cmds.polySelectConstraint(m=0)

def selectNonManifoldVertices():
	"""
	Selects the non manifold vertices.
	"""

	cmds.polySelectConstraint(m=3, t=1, nonmanifold=True)
	cmds.polySelectConstraint(m=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 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)

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)

def selectZeroGeometryAreaFaces():
	"""
	Selects the zero geometry area faces.
	"""

	cmds.polySelectConstraint(m=3, t=8, ga=True, gab=(0, 0.001))
	cmds.polySelectConstraint(m=0)

def selectStarVertices():
	"""
	Selects star vertices.
	"""

	cmds.polySelectConstraint(m=3, t=1, order=True, orb=(5, 65535))
	cmds.polySelectConstraint(dis=True)

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)

    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()

def selectTrianglesFaces():
	"""
	Selects triangles faces.
	"""

	cmds.polySelectConstraint(m=3, t=8, sz=1)
	cmds.polySelectConstraint(dis=True)

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")

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

 def _setup_hilited(self):
     cmds.polySelectConstraint(
         type=0x0008,
         mode=3,
         orient=1,
         orientbound=[0, self.threshold],
         orientaxis=self.normal
     )

 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

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)