def	skinWeights(x=None, export=None, f=None, fileName=None):
# Import/export skin weights from/to a file
# x/export: 0 for import, 1 for export
# f/fileName: filename under default project directory

	x = x or export

	if not (f or fileName):
		raise Exception, "Missing argument: fileName"
		
	if fileName:
		f = fileName
	
	obj = cmds.ls(sl=1)
	if not obj:
		raise Exception, "No object selected"

	obj = obj[0]

	node = None
	for n in cmds.listHistory(obj, f=0, bf=1):
		if cmds.nodeType(n) == 'skinCluster':
			node = n
			break
	if not node:
		raise Exception, "no skin cluster found"

	mode = "r"
	if x:
		mode = "w"
	f = open(cmds.internalVar(uwd=1) + f, mode)

	allTransforms = cmds.skinPercent(node, cmds.ls(cmds.polyListComponentConversion(obj, tv=1), fl=1), q=1, t=None)

	for vertex in cmds.ls(cmds.polyListComponentConversion(obj,tv=1), fl=1):
		if x:
			transforms = cmds.skinPercent(node, vertex, ib=1e-010, q=1, t=None)
			weights = cmds.skinPercent(node, vertex, ib=1e-010, q=1, v=1)
			s = ""
			for i in range(len(transforms)):
				s += str(weights[i])+"@"+transforms[i]+" "
			f.write(s+"\n")
		else:
			weights = {}
			for t in allTransforms:
				weights[t] = float(0)

			readWeights = f.readline().strip().split(" ")

			for i in readWeights:
				w = i.split("@")
				if w[1] in weights:
					weights[w[1]] = float(w[0])

			w = []
			for i in weights.iteritems():
				w.append(i)
			cmds.skinPercent(node, vertex, tv=w)

	f.close()

    def normalizeWeights(self, selName, infNames, clusterNode):
        """
        Remove non-zero weighting:
        Temporarily removing weight normalization allows for a weight prune
        Weight pruning is done to remove all non-zero weighting
        Non-zero weighting is removed to compress object data (faster speed) and file size
        """
        clusterName = clusterNode.name()

        # Unlock influences first
        for inf in infNames:
            cmds.setAttr("%s.liw" % inf, 0)

        # Temporarily turn off normalize
        normalizeSetting = cmds.getAttr("%s.normalizeWeights" % clusterName)

        if normalizeSetting != 0:
            cmds.setAttr("%s.normalizeWeights" % clusterName, 0)

        # Prune non-zero weights
        cmds.skinPercent(clusterName, selName, nrm=False, prw=100)
        # Turn normalize back on
        if normalizeSetting != 0:
            # cmds.setAttr('%s.normalizeWeights' % clusterName, normalizeSetting)
            cmds.setAttr("%s.normalizeWeights" % clusterName, normalizeSetting)

 def clampInfluences(self, mesh, maxInf, debug=0, force=False):
     '''
     Sets max influences on skincluster of mesh / cutting off smallest ones
     '''
     skinClust = self.findRelatedSkinCluster(mesh)
 
     lockedInfluences = self.checkLockedInfluences(skinClust)
     doit = True
     if lockedInfluences:
         if force:
             self.unlockLockedInfluences(skinClust)
             cmds.warning('Locked influences were unlocked on skinCluster')
         else:
             doit = False
     
     if doit:
         verts = self.checkMaxSkinInfluences(mesh, maxInf)
         
         print 'pruneVertWeights>> Pruning', len(verts), 'vertices'
         
         for v in verts:
             infs = cmds.skinPercent(skinClust, (mesh + ".vtx[" + str(v) + "]"), q=1, v=1)
             active = []
             for inf in infs:
                 if inf > 0.0: active.append(inf)
             active = list(reversed(sorted(active)))
             if debug: print 'Clamping vertex', v, 'to', active[maxInf]
             cmds.skinPercent(skinClust, (mesh + ".vtx[" + str(v) + "]"), pruneWeights=(active[maxInf]*1.001))
     else:
         cmds.warning('Cannot clamp influences due to locked weights on skinCluster')

def setInfluenceWeightsSlow(skinCluster,influence,weightList,normalize=True,componentList=[]):
	'''
	'''
	# Verify skinCluster
	if not isSkinCluster(skinCluster):
		raise Exception('Invalid skinCluster "' + skinCluster + '" specified!')
	
	# Check influence
	if not mc.objExists(influence):
		raise Exception('Influence object "'+influence+'" does not exists!')
	if not mc.skinCluster(skinCluster,q=True,inf=True).count(influence):
		raise Exception('Influence "'+influence+'" not connected to skinCluster "'+skinCluster+'"!')
	
	# Get geometry
	affectedGeo = glTools.utils.deformer.getAffectedGeometry(skinCluster).keys()[0]
	
	# Check component list
	if not componentList: componentList = glTools.utils.component.getComponentStrList(affectedGeo)
	componentIndexList = glTools.utils.component.getComponentIndexList(componentList)
	componentIndexList = componentIndexList[componentIndexList.keys()[0]]
	
	# Check component and weight list lengths
	if len(componentIndexList) != len(weightList):
		raise Exception('List length mis-match!')
	
	# Set weight values
	for i in range(len(componentIndexList)):
		comp = glTools.utils.component.getComponentStrList(affectedGeo,[componentIndexList[i]])[0]
		mc.skinPercent(skinCluster,comp,tv=(influence,weightList[i]),normalize=normalize)

def add_skinCluster_weights (vertexIDs, src_mesh, dst_mesh, mask_joint=None):
    src_skin = get_skinCluster(src_mesh)
    dst_skin = get_skinCluster(dst_mesh)
    
    src_skinCls_matrix_dict = loads_skinCluster_matrix(src_mesh)
    dst_skinCls_matrix_dict = loads_skinCluster_matrix(dst_mesh)
    
    cmds.skinCluster(dst_skin, e=True, normalizeWeights=False)
    
    for vertexID in vertexIDs:
        if not mask_joint: #if no mask joint defined, overwrite weight onto dst mesh
            cmds.skinPercent( dst_skin, "%s.vtx[%s]"%(dst_mesh, vertexID), pruneWeights=100)
            maskValue = 1
        else:
            mask_jointIndex = dst_skinCls_matrix_dict[mask_joint]
            maskValue = cmds.getAttr("%s.wl[%s].w[%s]" %(dst_skin, vertexID, mask_jointIndex))
            cmds.setAttr("%s.wl[%s].w[%s]" %(dst_skin, vertexID, mask_jointIndex), 0)
                        
        for src_joint, src_jointIndex in src_skinCls_matrix_dict.iteritems():
            weight = cmds.getAttr("%s.wl[%s].w[%s]" %(src_skin, vertexID, src_jointIndex)) * maskValue
            if weight != 0.0:
                dst_jointIndex = dst_skinCls_matrix_dict[src_joint]
                cmds.setAttr("%s.wl[%s].w[%s]" %(dst_skin, vertexID, dst_jointIndex), weight)

    cmds.skinCluster(dst_skin, e=True, normalizeWeights=True)

def readDirtyInfInfo(*args):
    sel = cmds.ls(sl=True, fl=True)
    obj = sel[0].split('.')[0]
    shape = cmds.listRelatives(obj, shapes=True)[0]
    skinCluster = mm.eval('findRelatedSkinCluster("' + shape + '")')
    infLst = cmds.skinCluster(skinCluster, query=True, inf=True)
    cmds.setAttr(skinCluster + '.normalizeWeights', 0)

    filePath = os.path.join(os.getenv('HOME'), 'Desktop/tmpWgtExport.txt')
    f = open(filePath, 'r')
    lines = f.readlines()

    cvCnt = 0
    if len(sel) == len(lines):
        for cv in sel:
            wgtLst = cmds.skinPercent(skinCluster, cv, query=True, v=True)
            # set turn off normalization and set all weights to zero
            for i in range(0, len(infLst), 1):
                cmds.skinPercent(skinCluster, cv, tv=(infLst[i], 0))

            rLine = eval(lines[cvCnt])
            for i in range(0, len(rLine), 1):
                cmds.skinPercent(skinCluster, cv, tv=(rLine[i][0], rLine[i][1]))
            f.close()
            cvCnt += 1
        cmds.setAttr(skinCluster + '.normalizeWeights', 1)
    else:
        print 'Maya selection count doesn\'t match exported file component count.'

def setInfluenceWeight(skn, mesh, influenceName, weightList):
    '''
    Set weights on influence using a float list
    '''
    for vertId in range(len(weightList)):
        if weightList[vertId]:
            mc.skinPercent(skn, mesh+'.vtx[%d]'%vertId, transformValue=[influenceName, weightList[vertId]])

    def doIt(self,argList):
        polygons = cmds.filterExpand(sm=12)
        if not polygons:
            print 'Please select a polygon.'
            return

        paths = cmds.fileDialog2(dialogStyle=2, fileMode = 3, okCaption = "Save", cancelCaption = "Cancel")
        if not paths:
            return

        for p in range(0, len(polygons)):
            polygon = polygons[p]
            related_cluster = mel.eval('findRelatedSkinCluster '+polygon)
            if related_cluster == '':
                print 'Please bind skin for this polygon.' + polygon
                continue

            path = paths[0]
            joints = cmds.skinPercent(related_cluster, polygon+'.vtx[0]', q = True, t = None);
            f = open(path+'/'+polygon+'.weights', 'w')

            vertices = cmds.getAttr(polygon+'.vrts', multiIndices = True);
            for i in range(0, len(vertices)):
                infs = cmds.skinPercent(related_cluster, polygon+'.vtx['+str(vertices[i])+']', q = True, v = True)
                pos = cmds.xform(polygon+'.vtx['+str(vertices[i])+']', q=1, ws=1, t=1)
                f.write('vp ' + str(pos[0])+' '+str(pos[1])+' '+str(pos[2]) + '\n')
                f.write('vinf');
                for j in range(0, len(infs)):
                    f.write(' ' + joints[j] + ' ' + str(infs[j]))
                f.write('\n')
            f.close()

        print 'Export Complete.'

 def setVertWts(self,*args):
     sel = cmds.ls(sl=True,fl=True)
     mesh = sel[0].split('.')[0]
     self.skClstr = mel.eval('findRelatedSkinCluster("%s")'%mesh)        
     for vert in sel:
         for val,inf in zip(self.srcVals,self.infs):
             cmds.skinPercent( self.skClstr, vert, transformValue=[(inf,val)] )

def weightZero(skinClusterName, deformerName):
    scNormalWeights = skinClusterName + '.normalizeWeights'
    cmds.setAttr(scNormalWeights, 1)
    cmds.skinPercent(skinClusterName, transformValue=[ (deformerName, 1.0)])
    cmds.setAttr(scNormalWeights, 0)
    cmds.skinCluster(skinClusterName, edit = True, fnw = True)
    cmds.skinPercent(skinClusterName, transformValue=[ (deformerName, 0.0)])

 def cache(s, meshes=None):
     """
     Store joints influence on objects for quick checking later
     """
     if meshes:
         # Cache Joints and Meshes
         for mesh in meshes:
             skin = mel.eval("findRelatedSkinCluster %s" % mesh)
             if skin:
                 joints = cmds.skinPercent(skin, "%s.vtx[0]" % mesh, q=True, t=None)
                 for vert in range(cmds.getAttr("%s.weightList" % skin, size=True)):
                     for i, v in enumerate(cmds.skinPercent(skin, "%s.vtx[%s]" % (mesh, vert), q=True, v=True)):
                         joint = joints[i]
                         if 0.2 < v:
                             # Sort by joints
                             s.joints[joint] = s.joints.get(joint, [])
                             s.joints[joint].append("%s.vtx[%s]" % (mesh, vert))
                             # Sort by meshes
                             s.meshes[mesh] = s.meshes.get(mesh, {})
                             s.meshes[mesh][joint] = s.meshes[mesh].get(joint, {})
                             s.meshes[mesh][joint][vert] = v
         # Speed up Cache
         if s.joints:
             s.select.ignore = True
             for j in s.joints:
                 cmds.select(s.joints[j], r=True)
                 s.joints[j] = cmds.filterExpand(ex=False, sm=31)
             cmds.select(clear=True)
     else:
         s.meshes = {}
         s.joints = {}
     pass

	def scaleMin( self , arg=None ) :
		
		val = self.getScaleVal()
		
		vtcs = mc.ls( sl=True , fl=True )
		
		for vtc in vtcs :
			
			geo = vtc.split( '.' )[0]
			skn = mm.eval( 'findRelatedSkinCluster( "%s" )' % geo )
			
			mc.setAttr( '%s.normalizeWeights' % skn , False )
			
			infs = mc.skinCluster( skn , q=True , inf=True )
			skinVals = mc.skinPercent( skn , vtc , q = True , v = True )
			
			maxVal = sorted( skinVals )[-1]
			
			minVal = 1
			for skinVal in skinVals :
				if skinVal and skinVal < minVal :
					minVal = skinVal
			
			minId = skinVals.index( minVal )
			maxId = skinVals.index( maxVal )
			
			newMin = minVal * val
			newMax = maxVal + ( minVal - newMin )
			
			mc.skinPercent( skn , vtc , tv = ( infs[minId] , newMin ) )
			mc.skinPercent( skn , vtc , tv = ( infs[maxId] , newMax ) )
			
			mc.setAttr( '%s.normalizeWeights' % skn , True )

def oldSkooFaceRigWeightImport(path):

    pickleFile = open(path, 'r')
    Import_Info = pickle.load(pickleFile)
    pickleFile.close()
    sknClstr = Import_Info.skinCluster
    cmds.setAttr(sknClstr + '.normalizeWeights', 0)
    points = cmds.getAttr('faceDriver_Crv.spans')
    # Iterate through each point on the faceDriver_Crv
    for i in range(0, points, 1):
        cv = OldSkooPointInfo('faceDriver_Crv.cv[' + str(i) + ']')
        closestPoint = getMapPnt(Import_Info.influenceInfoDict.keys(), cv)
        if Import_Info.influenceInfoDict.has_key(closestPoint[0]):
            setInfList = Import_Info.influenceInfoDict[closestPoint[0]][0]
            setWgtList = Import_Info.influenceInfoDict[closestPoint[0]][1]

            infLst = cmds.skinPercent(sknClstr, cv.name, ib=1e-4, query=True, transform=None)
            # Set the weights to 0
            for i in infLst:
                cmds.skinPercent(sknClstr, cv.name, tv=[i, 0])

            for i, inf in enumerate(setInfList):
                cmds.skinPercent(sknClstr, cv.name, tv=[inf, setWgtList[i]])
        else:
            print '-- point missed: %s, closest point: %s' % (cv.name, closestPoint[0])
    cmds.setAttr(sknClstr + '.normalizeWeights', 1)

 def test_import_skin_sets_correct_data(self):
     file_path = self.get_temp_filename('temp.skin')
     skinio.export_skin(file_path, self.shape)
     cmds.skinPercent(self.skin, '{0}.vtx[0]'.format(self.shape),
                      transformValue=[(self.joint1, 0.1), (self.joint2, 0.2), (self.joint3, 0.7)])
     skinio.import_skin(file_path)
     self.test_skincluster_data_is_correct()

 def setWeightFn(self):
     if self.currentInf:
         if len(self.currentInf) > 1:
             cmds.warning('skinWrangler: Set Weight does not work with multi-selection because I am too lazy at the moment to write my own normalization code.')
         else:
             cmds.skinPercent(self.currentSkin, self.currentVerts, tv=[self.currentInf[0], self.setWeightSpin.value()])
         self.refreshUI()
     else: cmds.warning('[skinWrangler] No influences/joints selected')

def assignWeights(skinClusterName, objectName, vertices, deformers):
    scNormalWeights = skinClusterName + '.normalizeWeights'
    cmds.setAttr( scNormalWeights, 0)
    for vertexId in vertices:
        for deformerId in vertices[vertexId]:
            deformerVertex = "%s.vtx[%s]" % (objectName, vertexId)
            deformerName = deformers[deformerId]
            vertexWeight = float( vertices[vertexId][deformerId] )
            cmds.skinPercent( skinClusterName, deformerVertex,  transformValue=[(deformerName, vertexWeight)])

    def loadSkinWeights(self, *args):
        import maya.mel as mel
        
        try:
            character = cmds.ls(sl=True)[0]
        except:
            cmds.headsUpMessage("Please Select Valid Geometry")
            return

        
        # Define the file name and path
        characterName = self.characterName
        skinPath = turbineUtils.setupDirs(characterName, create=False)[4]
        outFileSuffix = '_skinWeight.csv'
        outFile = (character + outFileSuffix )
        finalPath = (skinPath + outFile)

        missingJoints = []
        allCV = []
        if cmds.file(finalPath, q=True, ex=True):
            reader = csv.reader(open(finalPath, 'rb'), delimiter=' ', quotechar='|')
        else:
            return
        
        # Find the skin cluster
        selection= cmds.ls(sl=True, fl=True)
        mel.eval("$selectionList = `ls -sl`")
        skCl = mel.eval('findRelatedSkinCluster $selectionList[0]')
    
        for row in reader:
            if row not in allCV:
                allCV.append(row)
                
        for cv in allCV:
            splitString1 = cv[0].partition(",")
            vert =  splitString1[0]
            splitString2 = splitString1[2].partition(",")
            joint = splitString2[0]
            value = float(splitString2[2])
        
            
            if cmds.objExists(joint):
                cmds.skinPercent( skCl, vert, transformValue=[(joint, value)])
            else:
                missingJoints.append(joint)
                
        """ Normalize the weights """
        cmds.skinPercent(skCl, normalize=True)
        
        if len(missingJoints) == 0:  
            cmds.headsUpMessage("The weight has been loaded from " + finalPath)
        else:
            cmds.headsUpMessage("Influences are missing.  Please view the script editor for details.")
            print "These influences do not exist"
            for joint in missingJoints:
                print joint

 def weightFullFn(self):
     if self.currentInf:
         num = len(self.currentInf)
     if num == 1:
         cmds.skinPercent(self.currentSkin, self.currentVerts, tv=[self.currentInf[0], 1.0])
     elif num > 1:
         if self.currentNormalization != 'None':
             cmds.warning('skinWrangler: Cannot skin more than two influences to 1.0 in a normalization mode')
             return None
     self.refreshUI()

def pasteWeights(showProgress=True):
    """
    @param showProgress: Show operation progress using the main progress bar
    @type showProgress: bool
    """
    # Global Weight Value
    wt = gl_globals.glCopyPasteWeightCmd

    # Get Component Selection
    sel = cmds.filterExpand(ex=True, sm=[28, 31, 46])
    if not sel: return

    # Begin Progress Bar
    gMainProgressBar = mel.eval('$tmp = $gMainProgressBar')
    if showProgress:
        cmds.progressBar(gMainProgressBar, e=True, bp=True, ii=True, status=('Pasting Skin Weights...'),
                       maxValue=len(sel))

    selComp = glTools.utils.selection.componentListByObject(sel)
    for objComp in selComp:

        # Get Object from Component
        geo = cmds.ls(objComp[0], o=True)[0]

        # Get SkinCluster from Geometry
        skin = glTools.utils.skinCluster.findRelatedSkinCluster(geo)
        if not skin: raise Exception('Geometry "' + geo + '" is not attached to a valid skinCluster!')
        # Disable Weight Normalization
        cmds.setAttr(skin + '.normalizeWeights', 0)

        # For Each Component
        for cv in objComp:

            # Update skinPercent Command
            cmd = wt.replace('###', skin)

            # Evaluate skinPercent Command
            try:
                mel.eval(cmd)
            # print(cmd)
            except Exception, e:
                if showProgress: cmds.progressBar(gMainProgressBar, e=True, endProgress=True)
                raise Exception(str(s))

            # Update Progress Bar
            cvLen = len(cmds.ls(cv, fl=True))
            if showProgress:
                if cmds.progressBar(gMainProgressBar, q=True, isCancelled=True):
                    cmds.progressBar(gMainProgressBar, e=True, endProgress=True)
                    raise UserInterupted('Operation cancelled by user!')
                cmds.progressBar(gMainProgressBar, e=True, step=cvLen)

        # Normalize Weights
        cmds.setAttr(skin + '.normalizeWeights', 1)
        cmds.skinPercent(skin, normalize=True)

def OldSkooFaceRigWeightExportCMD(OldSkooObj):
    # Interate through each CV on the faceDriver_Crv
    for cv in OldSkooObj.cvList:
        infLst = cmds.skinPercent(OldSkooObj.skinCluster, cv.name, ib=1e-4, query=True, transform=None)
        wgtLst = cmds.skinPercent(OldSkooObj.skinCluster, cv.name, ib=1e-4, query=True, v=True)
        closestPoint = getMapPnt(OldSkooObj.microList, cv)
        # Some debugging info
        # if OldSkooObj.influenceInfoDict.has_key(closestPoint[0]):
        #    print 'Key Exists %s, for %s, %s' %( closestPoint[0], cv.name,closestPoint[1])
        #    print infLst, wgtLst
        OldSkooObj.influenceInfoDict[closestPoint[0]] = [infLst, wgtLst]