//
// Date: 2007/10/04
// Author: Dai Sato   dstruevision@dstruevision.com    http://www.dstruevision.com
// Procedure Name: Mirror Cluster Muscle
// 
// Description: This scripts just reload all texture files.
//	mirrorSelection procedure
//
//	mirrorSelection [axis] [identical] [invert] [tolerance]
//
//	axis = YZ (The default plane) XZ || XY
//
//	tolerance =~ 0.001
//
//	identical = 0	->	mirror effect
//	identical = 1	->	symmetric effect
//
//	invert = 1	->	mirror from the positive side to the negative
//	invert = 0	->	mirror from the negative side to the positive
//
//	Select vertices of object (NURBS surface, NURBS spline, Polygon)
//	and symmetric object if first object is not symmetric.
//
//	Use MEL command `performMirrorSelection 1` for Mirror Selection Option Box
   

global proc Mirror_VertexSelection (string $axis, int $identical, int $invert, float $tolerance) {

        string $objects[] = `ls -sl -type transform`;
	string $shapes[] = `ls -dag -s $objects`;

	string $cp[] = `filterExpand -sm 31 -sm 28`;
	int $cpSize = size($cp);

	if (!(($cpSize > 0) && (size($objects) < 2)))
		error("Select vertices and symmetric object if the object is not symmetric!");

	if (1 < ((size(`ls -type mesh $shapes`) > 0) +
		(size(`ls -type nurbsSurface $shapes`) > 0) +
		(size(`ls -type nurbsCurve $shapes`) > 0)))
		error("Select the same type objects only!");

	string $cpShape[] = `listRelatives -p -f $cp`;
	$cpShape = `stringArrayRemoveDuplicates $cpShape`;

	if (size($cpShape) > 1)
		error("Select Vertices of single object!");

	string $cpType[] = `ls -st $cpShape[0]`;
	string $objectsType[] = `ls -st $shapes[0]`;

	if (($cpSize > 0) && ($objectsType[1] != $cpType[1]) && (size($objects) > 0))
		error("Select the same type objects only!");

	waitCursor -state 1;

	string $nameDef, $nameSym, $nameTarget;

	if ($cpSize == 0)
	{	$nameDef = $shapes[0];
		$shapes = `ls -dag -s $objects[1]`;
		$cp = `ls -fl ($nameDef + ".cp[*]")`;
		$cpSize = size($cp);
	}
	else
		$nameDef = $cpShape[0];

	if (size($objects) > 0)
		$nameSym = $shapes[0];
	else	$nameSym = $nameDef;
	
	$objectsType = `ls -st $nameSym`;
	$nameTarget = $nameDef;
		
	int $cpLink[];
	string $cpIndex[];

	if ($objectsType[1] != "nurbsSurface")
		for ($i = 0; $i < $cpSize; $i++)
		{	tokenize ($cp[$i], "[]", $cpIndex);
			$cpLink[int($cpIndex[1])] = 1;
		}
	else
	{	$cpInV = `getAttr ($nameDef + ".spansV")` + `getAttr ($nameDef + ".degreeV")`;
		for ($i = 0; $i < $cpSize; $i++)
		{	tokenize ($cp[$i], "[]", $cpIndex);
			$cpLink[int($cpInV * int($cpIndex[1]) + int($cpIndex[2]))] = 1;
		}
	}

	int $cpCount, $cpCountDef;

	int $cpLinkZeroCount, $cpLinkPosCount, $cpLinkNegCount;
	int $cpLinksZero[], $cpLinksPositive[], $cpLinksNegative[];
	int $cpLinksSortPositive[], $cpLinksSortNegative[];

	int $flag, $flagGlobal;

	float $cpBuf[3];

	vector $cpSortArr[];

	int $assist = 0;
	vector $signVec = <<-1, 1, 1>>;
	
	$axis = toupper($axis);
	
	if ($axis == "XZ")
	{	$assist = 1;
		$signVec = <<1, -1, 1>>;
	}

	if ($axis == "XY")
	{	$assist = 2;
		$signVec = <<1, 1, -1>>;
	}
	
	$cpCount = `getAttr -size ($nameSym + ".cp")`;
	$cpCountDef = `getAttr -size ($nameDef + ".cp")`;

	// Sort points

	for ($currentPoint = 0; $currentPoint < $cpCount; $currentPoint++)
	{
		$cpBuf = `xform -q -t -os ($nameSym + ".cp[" + $currentPoint +"]")`;
		
		if (abs($cpBuf[$assist]) < $tolerance) 
		{	$cpLinksZero[$cpLinkZeroCount] = $currentPoint;
			$cpLinkZeroCount++;
		}
		else
		{
			if ($cpBuf[$assist] > 0)
			{	$cpLinksPositive[$cpLinkPosCount] = $currentPoint;
				$cpSortArr[$currentPoint] = <<$cpBuf[0], $cpBuf[1], $cpBuf[2]>>;
				$cpLinkPosCount++;
			}

			else
			{	$cpLinksNegative[$cpLinkNegCount] = $currentPoint;
				$cpSortArr[$currentPoint] = <<$signVec.x * $cpBuf[0], $signVec.y * $cpBuf[1], $signVec.z * $cpBuf[2]>>;
				$cpLinkNegCount++;
			} 
		}
	}
	
	// Looking for points
	
	int $cpLinkCount;
	
	for ($currentPoint = 0; $currentPoint < $cpLinkPosCount; $currentPoint++)
	{
		$flag = 0;

		for ($lookPoint = $cpLinkCount; $lookPoint < $cpLinkNegCount; $lookPoint++)
			if (mag($cpSortArr[$cpLinksPositive[$currentPoint]] - $cpSortArr[$cpLinksNegative[$lookPoint]]) < $tolerance)
			{
				$cpLinksSortPositive[$cpLinkCount] = $cpLinksPositive[$currentPoint];
				$cpLinksSortNegative[$cpLinkCount] = $cpLinksNegative[$lookPoint];
				$cpLinksNegative[$lookPoint] = $cpLinksNegative[$cpLinkCount];
				$cpLinksNegative[$cpLinkCount] = $cpLinksSortNegative[$cpLinkCount];
				$cpLinkCount++;
				$flag++;
				break;
			}
			
		if ($flag == 0) $flagGlobal = 1;
	}
	
	$cpLinksPositive = $cpLinksSortPositive;
	$cpLinksNegative = $cpLinksSortNegative;
	
	// Select points

	string $cmd;
	
	for ($currentPoint = 0; $currentPoint < $cpLinkZeroCount; $currentPoint++)
		if ($cpLink[$cpLinksZero[$currentPoint]] == 1)
			$cmd += " " + ($nameTarget + ".cp[" + $cpLinksZero[$currentPoint] + "]");
	
	if ($identical == 0)
		for ($currentPoint = 0; $currentPoint < $cpLinkCount; $currentPoint++)
		{	if (($cpLink[$cpLinksNegative[$currentPoint]] + $cpLink[$cpLinksPositive[$currentPoint]]) > 0)
			{	
				if ($cpLink[$cpLinksNegative[$currentPoint]] == 1)
					$cmd += " " + ($nameTarget + ".cp[" + $cpLinksPositive[$currentPoint] + "]");
				if ($cpLink[$cpLinksPositive[$currentPoint]] == 1)
					$cmd += " " + ($nameTarget + ".cp[" + $cpLinksNegative[$currentPoint] + "]");
			}
		}
	else
		if (!$invert)
		{	for ($currentPoint = 0; $currentPoint < $cpLinkCount; $currentPoint++)
				if (($cpLink[$cpLinksNegative[$currentPoint]] + $cpLink[$cpLinksPositive[$currentPoint]]) > 0)
					if ($cpLink[$cpLinksPositive[$currentPoint]] == 1)
					{	$cmd += " " + ($nameTarget + ".cp[" + $cpLinksPositive[$currentPoint] + "]");
						$cmd += " " + ($nameTarget + ".cp[" + $cpLinksNegative[$currentPoint] + "]");
					}
		}
		else
		{	for ($currentPoint = 0; $currentPoint < $cpLinkCount; $currentPoint++)
				if (($cpLink[$cpLinksNegative[$currentPoint]] + $cpLink[$cpLinksPositive[$currentPoint]]) > 0)
					if ($cpLink[$cpLinksNegative[$currentPoint]] == 1)
					{	$cmd += " " + ($nameTarget + ".cp[" + $cpLinksPositive[$currentPoint] + "]");
						$cmd += " " + ($nameTarget + ".cp[" + $cpLinksNegative[$currentPoint] + "]");
					}
		}
	
	select -cl;
	eval ("select -r" + $cmd);

	waitCursor -state 0;

	print ("// ");
	print ("Result: " + size(`ls -sl -fl`) + "\n");
	
	string $warningStr;
	
	$shapes = `ls $nameSym`; $nameSym = $shapes[0];
	$shapes = `ls $nameDef`; $nameDef = $shapes[0];
	
	if (($cpLinkPosCount != $cpLinkNegCount) || ($flagGlobal == 1))
		$warningStr = "`" + $nameSym + "` is not symmetrical shape. ";

	if ($cpCountDef != $cpCount)
		$warningStr += "There are different vertices amount in `" + $nameSym + "` and `" + $nameDef + "` objects.";

	if ($warningStr != "") warning ($warningStr);

}


global proc string Mod_TIMV_ClusterMuscle_FUNC(string $selectedCluster){

$checkLeftRight = checkLeftRight($selectedCluster);
string $muscleName = "";
string $originalName = cutHead($selectedCluster);

if($checkLeftRight == "Right") {
  $muscleName = ("Left_"+$originalName);
                               }
if($checkLeftRight == "Left") {
  $muscleName = ("Right_"+$originalName);
                               }

string $clusterName[] = `cluster`;
rename $clusterName[1] ($muscleName + "_CLUSTER");
vector $clusterPos = `xform -query -worldSpace -rotatePivot ($muscleName + "_CLUSTER")`;
sphere -name ($muscleName);
move ($clusterPos.x) ($clusterPos.y) ($clusterPos.z) ($muscleName);
setAttr ($muscleName + ".scaleX") 0.0;
setAttr ($muscleName + ".scaleY") 0.0;
setAttr ($muscleName + ".scaleZ") 0.0;
makeIdentity -apply 1 -translate 1 -rotate 1 -scale 1 ($muscleName);
delete -constructionHistory ($muscleName);
connectAttr -force ($muscleName + "Shape.parentInverseMatrix") ($muscleName + "_CLUSTERCluster.bindPreMatrix");
parent ($muscleName + "_CLUSTER") ($muscleName);

string $newClusterName = ($muscleName + "_CLUSTER");

if($newClusterName != ""){
       return  $newClusterName;
} 


}


global proc string Original_TIMV_ClusterMuscle_FUNC(){


if( (`textField -query -text Original_TIMV_GUI_muscleName_textField`) == "" )
{confirmDialog -t "ERROR" -m " Please enter a name for the muscle! " -ma "center" -b "OK" -cb "OK";return 0;} 
string $muscleName = (`textField -query -text Original_TIMV_GUI_muscleName_textField`+"CLUSTERMUSCLE");
string $clusterName[] = `cluster`;
rename $clusterName[1] ($muscleName + "_CLUSTER");
vector $clusterPos = `xform -query -worldSpace -rotatePivot ($muscleName + "_CLUSTER")`;
sphere -name ($muscleName);
move ($clusterPos.x) ($clusterPos.y) ($clusterPos.z) ($muscleName);
setAttr ($muscleName + ".scaleX") 0.0;
setAttr ($muscleName + ".scaleY") 0.0;
setAttr ($muscleName + ".scaleZ") 0.0;
makeIdentity -apply 1 -translate 1 -rotate 1 -scale 1 ($muscleName);
delete -constructionHistory ($muscleName);
connectAttr -force ($muscleName + "Shape.parentInverseMatrix") ($muscleName + "_CLUSTERCluster.bindPreMatrix");
parent ($muscleName + "_CLUSTER") ($muscleName);
confirmDialog -t "CLUSTER MUSCLE" -m " Cluster Muscle successfully created! " -ma "center" -b "OK" -cb "OK";
return 0;

}


global proc bgSelectClusterMembers(string $selectedCluster){

		string $set[] = `listConnections -s 0 -d 1 -t "objectSet" $selectedCluster`;
                select -clear;
                select -add $set[0];
}


global proc string pickUp_Cluster_Then_Members () {
$selectedObject = `ls -sl`;

string $targetCluster[] = `listConnections -s 0 -d 1 -t "cluster" $selectedObject`;
if($targetCluster[0] != "") {
		bgSelectClusterMembers($targetCluster[0]);
                return  $targetCluster[0];
                   }
else {
     confirmDialog -t "ERROR" -m " Please select cluster! " -ma "center" -b "OK" -cb "OK";
     return 0;
     }                                          

}


global proc selectSymmetryVertex(string $selectedCluster, string $newMirroredCluster, int $invert) {
     
     bgSelectClusterMembers($selectedCluster);
       
	string $currentSelectedVertex[] = `ls -sl -fl`;
      
       $amount =  0;
       progressWindow -title "Mirror Cluster" -progress $amount -status "Progress: 0%" -isInterruptable true;

        for($i=0;$i<size($currentSelectedVertex);$i++) { 
              
                 select $currentSelectedVertex[$i];
               
                 $tempOriginalWeight = `percent -q -v $selectedCluster`;
                 Mirror_VertexSelection("YZ", 0, $invert, 0.1 );
                 $tempCurrentSelection = `ls -sl`;
                 
                 $tempCheckSelection = `ls -sl`;  
                 percent -v $tempOriginalWeight[0] ($newMirroredCluster+"Cluster");
                 select -clear;

               if ( `progressWindow -query -isCancelled` ) break;
               $amount += 1; 
               progressWindow -edit -progress $amount -status ("Copying Cluster and Weight: "+($amount+0)+"%");
               //  progressBar -edit -step 1 mainProgressBar;
               
                                  }
            progressWindow -endProgress;
         
}


global proc string checkLeftRight(string $clusterName)
{    
	    string $tokens[];
	    int $numTokens = `tokenize $clusterName "_" $tokens`;
            return $tokens[0];    
}


global proc string my_pickParentNode(string $oneVertex) {

string $tokens[];
int $numTokens = `tokenize $oneVertex "." $tokens`;
return $tokens[0];

}


global proc setNodeState () {

int $setNodeState;

string $selectedRadio = `radioButtonGrp -q -select nodeStateSelection_Radio`;

switch ($selectedRadio) { 
    case "1": 
        $setNodeState = 0;  
        break; 
    case "2": 
       $setNodeState = 1;  
        break; 
    default: 
        break; 
} 

$currentSelection = `ls -sl`;

$NodeHistory = `listHistory $currentSelection[0]`; 

 for($i=0;$i<size($NodeHistory);$i++) { 
            string $tempNodeType = `nodeType $NodeHistory[$i]`;
             if($tempNodeType == "cluster") {
                  setAttr ($NodeHistory[$i]+".nodeState") $setNodeState;
                                           }
                                      }

}


global proc setNodeState_ForMirror () {

int $setNodeState;

string $selectedRadio = `radioButtonGrp -q -select nodeStateSelection_Radio`;

switch ($selectedRadio) { 
    case "1": 
        $setNodeState = 0;  
        break; 
    case "2": 
       $setNodeState = 1;  
        break; 
    default: 
        break; 
} 

pickUp_Cluster_Then_Members ();
$currentSelection = `ls -sl`;
$oneVertex = $currentSelection[0];

$parentObject = my_pickParentNode($oneVertex);
$NodeHistory = `listHistory $parentObject`; 

 for($i=0;$i<size($NodeHistory);$i++) { 
            string $tempNodeType = `nodeType $NodeHistory[$i]`;
             if($tempNodeType == "cluster") {
                  setAttr ($NodeHistory[$i]+".nodeState") $setNodeState;
                                           }
               
                                  }

}


global proc string checkLeftRight(string $selectedCluster) {

string $tokens[];
int $numTokens = `tokenize $selectedCluster "_" $tokens`;

for($i=0;$i<size($tokens);$i++) { 
            $tempBuffer = $tokens[$i];
             if($tempBuffer == "Left"|| $tempBuffer =="LEFT") {
                      return "Left";
                                               }
             if($tempBuffer == "Right"||$tempBuffer =="RIGHT") {
                      return "Right";
                                               }
             
                                      }
}


global proc string cutHead(string $selectedCluster) {

string $tokens[];
string $tempBuffer;
int $numTokens = `tokenize $selectedCluster "_" $tokens`;

for($i=1;$i<size($tokens)-1;$i++) { 
            $tempBuffer = $tempBuffer+$tokens[$i];
         if($i<size($tokens)-2) {
            $tempBuffer = $tempBuffer+"_";
                                }
                                  }
return $tempBuffer;
}


global proc string UnderBarSplit (string $tokensSpace) {

string $tokensUnderbar[];
string $tempBuffer_FortokensUnderbar = "";
int $checkStartDollor = 0;
int $checkEndDollor = 0;
int $checkStartPlus = 0;
int $checkEndPlus = 0;
int $checkStartMinus = 0;
int $checkEndMinus = 0;
int $checkStartMultiply = 0;
int $checkEndMultiply = 0;
int $checkStartDivide = 0;
int $checkEndDivide = 0;

int $numTokensUnderbar = `tokenize $tokensSpace "_" $tokensUnderbar`;

                   for($k=0; $k< $numTokensUnderbar;$k++)   { 
                        
                       if($tokensUnderbar[$k] == "Right" || $tokensUnderbar[$k] == "RIGHT") {
                          
                                                                        $tokensUnderbar[$k] = "Left";
                                                                                              }
                          else if($tokensUnderbar[$k] == "Left" || $tokensUnderbar[$k] == "LEFT") {
                        
                                                                         $tokensUnderbar[$k] = "Right"; 
                                                                                                   }
                            $checkStartDollor = startsWith($tokensUnderbar[$k], "$");
                            $checkEndDollor = endsWith($tokensUnderbar[$k], "$");                                                                       
                            $checkStartPlus = startsWith($tokensUnderbar[$k], "+");
                            $checkEndPlus = endsWith($tokensUnderbar[$k], "+");
                            $checkStartMinus = startsWith($tokensUnderbar[$k], "-");
                            $checkEndMinus = endsWith($tokensUnderbar[$k], "-");
                            $checkStartMultiply = startsWith($tokensUnderbar[$k], "*");
                            $checkEndMultiply = endsWith($tokensUnderbar[$k], "*");
                            $checkStartDivide = startsWith($tokensUnderbar[$k], "/");
                            $checkEndDivide = endsWith($tokensUnderbar[$k], "/");
                            $checkStartPercent = startsWith($tokensUnderbar[$k], "%");
                            $checkEndPercent = endsWith($tokensUnderbar[$k], "%"); 
                            $checkStartBracket = startsWith($tokensUnderbar[$k], "(");
                            $checkEndBracket = endsWith($tokensUnderbar[$k], "(");                                                   
                     
                          if($checkStartDollor ==1 || $checkEndDollor ==1 ) {
                              $tokensUnderbar[$k] = dollorSplit ($tokensUnderbar[$k], $checkStartDollor, $checkEndDollor );
                                                  }

                          if($checkStartPlus ==1 || $checkEndPlus ==1 ) {
                              $tokensUnderbar[$k] = plusSplit ($tokensUnderbar[$k], $checkStartPlus, $checkEndPlus );
                                                  }

                          if($checkStartMinus ==1 || $checkEndMinus ==1 ) {
                              $tokensUnderbar[$k] = minusSplit ($tokensUnderbar[$k], $checkStartMinus, $checkEndMinus );
                                                  }
                          
                          if($checkStartMultiply ==1 || $checkEndMultiply ==1 ) {
                              $tokensUnderbar[$k] = multiplySplit ($tokensUnderbar[$k], $checkStartMultiply, $checkEndMultiply);
                                                  }

                          if($checkStartDivide ==1 || $checkEndDivide ==1 ) {
                              $tokensUnderbar[$k] = divideSplit ($tokensUnderbar[$k], $checkStartDivide, $checkEndDivide);
                                                  }
        
                           if($checkStartPercent ==1 || $checkEndPercent ==1 ) {
                              $tokensUnderbar[$k] = percentSplit ($tokensUnderbar[$k], $checkStartPercent, $checkEndPercent);
                                                  }
                           if($checkStartBracket ==1 || $checkEndBracket ==1 ) {
                              $tokensUnderbar[$k] =bracketSplit ($tokensUnderbar[$k], $checkStartBracket, $checkEndBracket);
                                                                              }
                           $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar +  $tokensUnderbar[$k];
                           if($k<$numTokensUnderbar-1) {
                                    $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "_";
                                                        } 
                                   
                                                               }
return $tempBuffer_FortokensUnderbar;

}

global proc string dollorSplit (string $tokensSpace, int $checkStartDollor, int $checkEndDollor) {

//print ("InputToken"+"\n"+ $tokensSpace + "\n");
string $tokensUnderbar[];
string $tempBuffer_FortokensUnderbar = "";

int $numTokensUnderbar = `tokenize $tokensSpace "$" $tokensUnderbar`;

                   for($k=0; $k< $numTokensUnderbar;$k++)   { 
                        
                       if($tokensUnderbar[$k] == "Right" ||$tokensUnderbar[$k] == "RIGHT") {
                          
                                                                        $tokensUnderbar[$k] = "Left";
                                                                                              }
                          else if($tokensUnderbar[$k] == "Left" || $tokensUnderbar[$k] == "LEFT") {
                        
                                                                         $tokensUnderbar[$k] = "Right";
                                                                                              }
 
                          $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar +  $tokensUnderbar[$k];

                          if($k<$numTokensUnderbar&& $checkStartDollor == 1) {
                                    $tempBuffer_FortokensUnderbar = "$" + $tempBuffer_FortokensUnderbar ;
                                                                            } 
                           if($k<$numTokensUnderbar&& $checkEndDollor == 1&& $tokensSpace != "$") {
                                    $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "$";
                                                                                                   }
                                                            }

//print ("OutputToken"+"\n"+  $tempBuffer_FortokensUnderbar + "\n");
return $tempBuffer_FortokensUnderbar;

}



global proc string plusSplit (string $tokensSpace, int $checkStartPlus, int $checkEndPlus) {

string $tokensUnderbar[];
string $tempBuffer_FortokensUnderbar = "";
string $doublePlusCheck = endString($tokensSpace, 2);

int $numTokensUnderbar = `tokenize $tokensSpace "+" $tokensUnderbar`;

                   for($k=0; $k< $numTokensUnderbar;$k++)   { 
                        
                       if($tokensUnderbar[$k] == "Right" || $tokensUnderbar[$k] == "RIGHT") {
                          
                                                                        $tokensUnderbar[$k] = "Left";
                                                                                              }
                          else if($tokensUnderbar[$k] == "Left" || $tokensUnderbar[$k] == "LEFT") {
                        
                                                                         $tokensUnderbar[$k] = "Right"; 
                                                                                                  }
                                                                                         
                     $checkStartDollor = startsWith($tokensUnderbar[$k], "$");
                     $checkEndDollor = endsWith($tokensUnderbar[$k], "$");

                             if($checkStartDollor ==1 || $checkEndDollor ==1 ) {
                                              $tokensUnderbar[$k] = dollorSplit ($tokensUnderbar[$k], $checkStartDollor, $checkEndDollor );
                                                                               }         
                  
                           $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar +  $tokensUnderbar[$k];
                         
                     
                           if($k<$numTokensUnderbar&& $checkStartPlus == 1) {
                                    $tempBuffer_FortokensUnderbar = "+" + $tempBuffer_FortokensUnderbar ;
                                                                            } 
                           if($k<$numTokensUnderbar&& $checkEndPlus == 1&& $tokensSpace != "+") {
                                    $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "+";
                                        if($doublePlusCheck == "++") {
                                               $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "+";
                                                                     }
                                                                                                }
                                                                          
                                       
                                                             }
return $tempBuffer_FortokensUnderbar;
}


global proc string minusSplit (string $tokensSpace, int $checkStartMinus, int $checkEndMinus) {

string $tokensUnderbar[];
string $tempBuffer_FortokensUnderbar = "";
string $doubleMinusCheck = endString($tokensSpace, 2);

int $numTokensUnderbar = `tokenize $tokensSpace "-" $tokensUnderbar`;

                   for($k=0; $k< $numTokensUnderbar;$k++)   { 
                        
                       if($tokensUnderbar[$k] == "Right" || $tokensUnderbar[$k] == "RIGHT") {
                          
                                                                        $tokensUnderbar[$k] = "Left";
                                                                                              }
                          else if($tokensUnderbar[$k] == "Left" || $tokensUnderbar[$k] == "LEFT") {
                        
                                                                         $tokensUnderbar[$k] = "Right"; 
                                                                                                  }
                   
                             $checkStartDollor = startsWith($tokensUnderbar[$k], "$");
                             $checkEndDollor = endsWith($tokensUnderbar[$k], "$");
                                                  
                                  if($checkStartDollor ==1 || $checkEndDollor ==1 ) {
                                        print "COME!!!!!!!!!!";
                                        $tokensUnderbar[$k] = dollorSplit ($tokensUnderbar[$k], $checkStartDollor, $checkEndDollor );  
                                                                                     }

                           $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar +  $tokensUnderbar[$k];
                         
                     
                           if($k<$numTokensUnderbar&& $checkStartMinus == 1) {
                                    $tempBuffer_FortokensUnderbar = "-" + $tempBuffer_FortokensUnderbar ;
                                                                            } 
                           if($k<$numTokensUnderbar&& $checkEndMinus == 1&& $tokensSpace != "-") {
                                    $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "-";
                                        if($doubleMinusCheck == "--") {
                                               $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "-";
                                                                     }
                                                                            } 
                                       
                                                               }
return $tempBuffer_FortokensUnderbar;
}


global proc string multiplySplit (string $tokensSpace, int $checkStartMultiply, int $checkEndMultiply) {

string $tokensUnderbar[];
string $tempBuffer_FortokensUnderbar = "";

int $numTokensUnderbar = `tokenize $tokensSpace "*" $tokensUnderbar`;

                   for($k=0; $k< $numTokensUnderbar;$k++)   { 
                        
                       if($tokensUnderbar[$k] == "Right" || $tokensUnderbar[$k] == "RIGHT") {
                          
                                                                        $tokensUnderbar[$k] = "Left";
                                                                                              }
                          else if($tokensUnderbar[$k] == "Left" || $tokensUnderbar[$k] == "LEFT") {
                        
                                                                         $tokensUnderbar[$k] = "Right"; 
                                                                                                  }
                           
                             $checkStartDollor = startsWith($tokensUnderbar[$k], "$");
                             $checkEndDollor = endsWith($tokensUnderbar[$k], "$");
                                                  
                                  if($checkStartDollor ==1 || $checkEndDollor ==1 ) {
                                        print "COME!!!!!!!!!!";
                                        $tokensUnderbar[$k] = dollorSplit ($tokensUnderbar[$k], $checkStartDollor, $checkEndDollor );
                                                                                     }
                           $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar +  $tokensUnderbar[$k];
                         
                     
                           if($k<$numTokensUnderbar&& $checkStartMultiply == 1) {
                                    $tempBuffer_FortokensUnderbar = "*" + $tempBuffer_FortokensUnderbar ;
                                                                            } 
                           if($k<$numTokensUnderbar&& $checkEndMultiply == 1 && $tokensSpace != "*") {
                                    $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "*";
                                                                            } 
                                                     
                                                               }
return $tempBuffer_FortokensUnderbar;
}


global proc string divideSplit (string $tokensSpace, int $checkStartDivide, int $checkEndDivide) {

string $tokensUnderbar[];
string $tempBuffer_FortokensUnderbar = "";

int $numTokensUnderbar = `tokenize $tokensSpace "/" $tokensUnderbar`;

                   for($k=0; $k< $numTokensUnderbar;$k++)   { 
                        
                       if($tokensUnderbar[$k] == "Right" || $tokensUnderbar[$k] == "RIGHT") {
                          
                                                                        $tokensUnderbar[$k] = "Left";
                                                                                              }
                          else if($tokensUnderbar[$k] == "Left" || $tokensUnderbar[$k] == "LEFT") {
                        
                                                                         $tokensUnderbar[$k] = "Right"; 
                                                                                                  }

                       $checkStartDollor = startsWith($tokensUnderbar[$k], "$");
                       $checkEndDollor = endsWith($tokensUnderbar[$k], "$");

                             if($checkStartDollor ==1 || $checkEndDollor ==1 ) {
                                              $tokensUnderbar[$k] = dollorSplit ($tokensUnderbar[$k], $checkStartDollor, $checkEndDollor );
                                                                               }         

                           $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar +  $tokensUnderbar[$k];
                         
                     
                           if($k<$numTokensUnderbar&& $checkStartDivide == 1) {
                                    $tempBuffer_FortokensUnderbar = "/" + $tempBuffer_FortokensUnderbar ;
                                                                            } 
                           if($k<$numTokensUnderbar&& $checkEndDivide == 1 && $tokensSpace != "/") {
                                    $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "/";
                                                                            } 
                                       
                                                               }
return $tempBuffer_FortokensUnderbar;
}

global proc string percentSplit (string $tokensSpace, int $checkStartPercent, int $checkEndPercent) {

string $tokensUnderbar[];
string $tempBuffer_FortokensUnderbar = "";

int $numTokensUnderbar = `tokenize $tokensSpace "%" $tokensUnderbar`;

                   for($k=0; $k< $numTokensUnderbar;$k++)   { 
                        
                       if($tokensUnderbar[$k] == "Right" || $tokensUnderbar[$k] == "RIGHT") {
                          
                                                                        $tokensUnderbar[$k] = "Left";
                                                                                              }
                          else if($tokensUnderbar[$k] == "Left" || $tokensUnderbar[$k] == "LEFT") {
                        
                                                                         $tokensUnderbar[$k] = "Right"; 
                                                                                                  }

                       $checkStartDollor = startsWith($tokensUnderbar[$k], "$");
                       $checkEndDollor = endsWith($tokensUnderbar[$k], "$");

                             if($checkStartDollor ==1 || $checkEndDollor ==1 ) {
                                              $tokensUnderbar[$k] = dollorSplit ($tokensUnderbar[$k], $checkStartDollor, $checkEndDollor );
                                                                               }         

                           $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar +  $tokensUnderbar[$k];
                         
                     
                           if($k<$numTokensUnderbar&&$checkStartPercent == 1) {
                                    $tempBuffer_FortokensUnderbar = "%" + $tempBuffer_FortokensUnderbar ;
                                                                            } 
                           if($k<$numTokensUnderbar&& $checkEndPercent == 1 && $tokensSpace != "%") {
                                    $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "%";
                                                                            } 
                                       
                                                               }
return $tempBuffer_FortokensUnderbar;
}

global proc string bracketSplit (string $tokensSpace, int $checkStartBracket, int $checkEndkBracket) {

string $tokensUnderbar[];
string $tempBuffer_FortokensUnderbar = "";

int $numTokensUnderbar = `tokenize $tokensSpace "(" $tokensUnderbar`;

                   for($k=0; $k< $numTokensUnderbar;$k++)   { 
                        
                       if($tokensUnderbar[$k] == "Right" || $tokensUnderbar[$k] == "RIGHT") {
                          
                                                                        $tokensUnderbar[$k] = "Left";
                                                                                              }
                          else if($tokensUnderbar[$k] == "Left" || $tokensUnderbar[$k] == "LEFT") {
                        
                                                                         $tokensUnderbar[$k] = "Right"; 
                                                                                                  }

                       $checkStartDollor = startsWith($tokensUnderbar[$k], "$");
                       $checkEndDollor = endsWith($tokensUnderbar[$k], "$");

                             if($checkStartDollor ==1 || $checkEndDollor ==1 ) {
                                              $tokensUnderbar[$k] = dollorSplit ($tokensUnderbar[$k], $checkStartDollor, $checkEndDollor );
                                                                               }         

                           $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar +  $tokensUnderbar[$k];
                         
                     
                           if($k<$numTokensUnderbar&&$checkStartBracket == 1) {
                                    $tempBuffer_FortokensUnderbar = "(" + $tempBuffer_FortokensUnderbar ;
                                                                            } 
                           if($k<$numTokensUnderbar&& $checkEndkBracket == 1 && $tokensSpace != "(") {
                                    $tempBuffer_FortokensUnderbar = $tempBuffer_FortokensUnderbar + "(";
                                                                            } 
                                       
                                                               }
return $tempBuffer_FortokensUnderbar;
}



global proc string renameExpression(string $expressionString) {

string $tokensEqual[];
string $tokensBracket[];
string $tokensSpace[];
string $tokensReturn[];
string $tokensSemiColon[];
string $tempBuffer_FortokensEqual = "";
string $tempBuffer_FortokensSpace = "";
string $tempBuffer_FortokensBracket = "";
string $tempBuffer_ForSemiColon = "";
string $tempBuffer_ForReturn = "";
string $renamedExpression = "";
string $rightWithReturn = "\n" + "Right";
string $rightWithReturnCap = "\n" + "RIGHT"; 
string $leftWithReturn = "\n" + "Left";
string $leftWithReturnCap = "\n" + "LEFT"; 

 int $numTokensReturn = `tokenize $expressionString "\n" $tokensReturn`;

//----";" split loop BIG-------------

for($m=0;$m<$numTokensReturn;$m++) { 

 int $numTokensSemiColon = `tokenize $tokensReturn[$m] ";" $tokensSemiColon`;

 for($h=0;$h<$numTokensSemiColon;$h++) {

  int $numTokensEqual = `tokenize $tokensSemiColon[$h] "=" $tokensEqual`;    

      for($i=0;$i<$numTokensEqual;$i++) { 
                  
         int $numTokensSpace = `tokenize $tokensEqual[$i] " " $tokensSpace`;
           
            for($n=0;$n<$numTokensSpace;$n++)   { 

                       $tokensSpace[$n] = UnderBarSplit ($tokensSpace[$n]);                        
                       
                       $tempBuffer_FortokensSpace = $tempBuffer_FortokensSpace + $tokensSpace[$n]; 
                         if($n<$numTokensSpace-1) { 
                                  $tempBuffer_FortokensSpace = $tempBuffer_FortokensSpace +  " " ;
                                                   }                    
                                                } 

                  $tempBuffer_FortokensEqual = $tempBuffer_FortokensEqual + $tempBuffer_FortokensSpace;  

                    if($i<$numTokensEqual-1) {
                            $tempBuffer_FortokensEqual =   $tempBuffer_FortokensEqual + "=";
                                                   }
                    $tempBuffer_FortokensSpace = ""; 
  
                                         }


   $tempBuffer_ForSemiColon = $tempBuffer_ForSemiColon + $tempBuffer_FortokensEqual;  

                    if($h<$numTokensSemiColon-1) {
                           $tempBuffer_ForSemiColon =  $tempBuffer_ForSemiColon + ";";
                                                   }
                    $tempBuffer_FortokensEqual = ""; 
                    
                                         }

 $tempBuffer_ForReturn  = $tempBuffer_ForReturn  + $tempBuffer_ForSemiColon;  

                    if($m <$numTokensReturn-1) {
                           $tempBuffer_ForReturn  = $tempBuffer_ForReturn  + "\n";
                                                }
                    $tempBuffer_ForSemiColon = ""; 

                                     }
//----";" split loop BIG END ------------- 
                                                                        
return $tempBuffer_ForReturn; 
                  
}


global proc copyExpression (string $selectedCluster) {

$connectedNodes = `listConnections $selectedCluster`;

for($i=0;$i<size($connectedNodes)-1;$i++) { 
                    $tempNodeType = `nodeType $connectedNodes[$i]`;
                    print $connectedNodes[$i];
                    print "\n";
            
                      if($tempNodeType == "expression") {
                              $expressionString = `expression -q -s $connectedNodes[$i]`;
                             
                              $renamedExpression = renameExpression($expressionString);
                             print  $renamedExpression;
                              expression -s $renamedExpression;
                                                        }
                                           }

}


global proc Mirror_Cluster_Muscle_FUNC () {

$invert = `checkBoxGrp -q -enable inverseMirrorSelection`;
$justClusterNode =`ls -sl`;
$selectedCluster = pickUp_Cluster_Then_Members ();
Mirror_VertexSelection("YZ", 0, $invert, 0.1 );
$newMirroredCluster = Mod_TIMV_ClusterMuscle_FUNC($selectedCluster);
selectSymmetryVertex($selectedCluster, $newMirroredCluster, $invert );
copyExpression ($justClusterNode[0]);

}

global proc Mirror_Cluster_Muscle () {
global int $progressMax = 10;
global string $tempString = "YZ";
if ((`window -ex Mirror_Cluster_Muscle_Window`) == true) deleteUI Mirror_Cluster_Muscle_Window;
window -t "Mirror_Cluster_Muscle_Window" -s false Mirror_Cluster_Muscle_Window;

columnLayout -rs 10 -co left 10 maincolumnLayout;

$tempString = "YZ";

rowColumnLayout -numberOfRows 1;

setParent -top;
rowColumnLayout -numberOfRows 1;
textField -w 150 -editable 1 Original_TIMV_GUI_muscleName_textField;
text -label "" -height 20;
button -label "Create Cluster Muscle" -command "Original_TIMV_ClusterMuscle_FUNC()";
setParent -top;

//radioButtonGrp  
//                -cw4 80 50 50 50
//		-label "Mirror Axis"
//		-numberOfRadioButtons 3
//		-label1 "XY"
//		-label2 "YZ"
//		-label3 "XZ"
//		-cc1 "checkBoxGrp -e -label1 \"Positive to Negative (+Z to -Z)\" inverseMirrorSelection"
//		-cc2 "checkBoxGrp -e -label1 \"Positive to Negative (+X to -X)\" inverseMirrorSelection"
//		-cc3 "checkBoxGrp -e -label1 \"Positive to Negative (+Y to -Y)\" inverseMirrorSelection"
//		axisRadioMirrorSelection;
	
checkBoxGrp
			-label "Direction"
			-label1 "Positive to Negative"
			-numberOfCheckBoxes 1
			inverseMirrorSelection;
setParent -top;

separator -height 10 -width 300;
setParent -top;

rowColumnLayout -numberOfRows 1;
radioButtonGrp  
                -cw3 80 50 50
                -columnAlign4 center center center center 
		-label "NodeState "
		-numberOfRadioButtons 2
		-label1 "On"
		-label2 "Off"
                -select 1
		nodeStateSelection_Radio;
button -l "Make" -w 50 -h 30 -c "setNodeState ()";
setParent -top;

separator -height 5 -width 300;
setParent -top;

rowColumnLayout -numberOfRows 1;
text -label "Select Cluster Members";
text -label "";
button -l "Select" -w 50 -h 30 -c "pickUp_Cluster_Then_Members ()";
setParent -top;

separator -height 10 -width 300;
setParent -top;

//progressBar -width 150 -height 10 mainProgressBar;

rowColumnLayout -numberOfRows 1;
//button -l "Mirror" -w 50 -h 30 -c "Mirror_CMuscle( $tempString, 0, 0, 0.001 )";
button -l "Mirror" -w 50 -h 30 -c "Mirror_Cluster_Muscle_FUNC () ";
button -l "Undo" -w 50 -h 30 -c "undo";
//button -l "test" -w 50 -h 30 -c "text -e -vis true Copying_Weight";
setParent -top;


window -e -width 300 -height 300 Mirror_Cluster_Muscle_Window;
showWindow;

}

Mirror_Cluster_Muscle ();