// Copyright (C) 1997-2006 Autodesk, Inc., and/or its licensors.
// All rights reserved.
//
// The coded instructions, statements, computer programs, and/or related
// material (collectively the "Data") in these files contain unpublished
// information proprietary to Autodesk, Inc. ("Autodesk") and/or its licensors,
// which is protected by U.S. and Canadian federal copyright law and by
// international treaties.
//
// The Data is provided for use exclusively by You. You have the right to use,
// modify, and incorporate this Data into other products for purposes authorized 
// by the Autodesk software license agreement, without fee.
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND. AUTODESK
// DOES NOT MAKE AND HEREBY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTIES
// INCLUDING, BUT NOT LIMITED TO, THE WARRANTIES OF NON-INFRINGEMENT,
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, OR ARISING FROM A COURSE 
// OF DEALING, USAGE, OR TRADE PRACTICE. IN NO EVENT WILL AUTODESK AND/OR ITS
// LICENSORS BE LIABLE FOR ANY LOST REVENUES, DATA, OR PROFITS, OR SPECIAL,
// DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES, EVEN IF AUTODESK AND/OR ITS
// LICENSORS HAS BEEN ADVISED OF THE POSSIBILITY OR PROBABILITY OF SUCH DAMAGES.

//
// Alias Script File
// MODIFY THIS AT YOUR OWN RISK
//


///////////////////////////////////////////////////////////////////////////////
//
//  Procedure Name:
//	mlConnectClipToTrackedPoint
//
//

global proc mlConnectClipToTrackedPoint( string $clip, string $trackedPoint )
{
    // if this is the first clip, renormalize the tracking parameters
    string $curClip[] = `listConnections -s true -d false ($trackedPoint+".clip")`;
    if ( size( $curClip ) == 0 ) {
	float $sizeX = `getAttr ($trackedPoint+".sizeX")`;
	float $sizeY = `getAttr ($trackedPoint+".sizeY")`;
	float $newSizeXY[] = `mlPixelToNormalized $sizeX $sizeY false true`;
	setAttr ($trackedPoint+".sizeX") $newSizeXY[0];
	setAttr ($trackedPoint+".sizeY") $newSizeXY[1];

	float $searchX = `getAttr ($trackedPoint+".searchX")`;
	float $searchY = `getAttr ($trackedPoint+".searchY")`;
	float $newSearchXY[] = `mlPixelToNormalized $searchX $searchY false true`;
	setAttr ($trackedPoint+".searchX") $newSearchXY[0];
	setAttr ($trackedPoint+".searchY") $newSearchXY[1];

    }

    connectAttr -force ($clip+".message") ($trackedPoint+".clip");
}


///////////////////////////////////////////////////////////////////////////////
//
//  Procedure Name:
//	mlDisconnectClipFromTrackedPoint
//
//

global proc mlDisconnectClipFromTrackedPoint( string $clip, string $trackedPoint )
{
	disconnectAttr ($clip+".message") ($trackedPoint+".clip");
}


///////////////////////////////////////////////////////////////////////////////
//
//  Procedure Name:
//	mlCreatePointOrDragger
//
//

global proc string mlCreatePointOrDragger( int $mlIsTtlDragger )
{
    // create a new trackedPoint
    string $trackedPoint = `createNode trackedPoint`;

    // rename the transform and shape nodes
    string $fullName[] = `ls -l $trackedPoint`;
    string $components[];
    tokenize ( $fullName[0], "|", $components );
    string $transformName = $components[0];
    string $shapeName = $components[1];
    string $newShapeName = `substitute "trackedPoint" $shapeName "trackedPointShape"`;

    rename $shapeName $newShapeName;
    rename $transformName $shapeName;

    // lock transform attributes to prevent manip'ing the tracked point
    setAttr -lock true ($shapeName+".translate");
    setAttr -lock true ($shapeName+".rotate");
    setAttr -lock true ($shapeName+".scale");

    mlCreateTrackedPoint3DLocator( $shapeName );
    
    return $trackedPoint;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Procedure Name:
//	mlDeleteTrackedPoint
//
//

global proc mlDeleteTrackedPoint( string $trackedPoint )
{
    string $newName = $trackedPoint;
 
    global string $gCurrShot;
    string $ttlSolver = `mlGetShotTtlSolver( $gCurrShot )`;
   
    if( `mlIsTtlDragger( $trackedPoint )` ) {
	mlDisconnectTtlDraggerLocFromTtlSolver( $trackedPoint );
	mlDisconnectTtlDraggerFromTtlSolver( $trackedPoint, $ttlSolver );
    }

    string $clip[] = `listConnections ($trackedPoint+".clip")`;
    if ( $clip[0] != "" ) {
	$newName = `mlDisconnectTrackedPointFromClip $trackedPoint $clip[0]`;
    }

    // commented because we need to re-visit this behavior. Basically,
    // the 3D locator should be owned by the candidate points. When
    // the the locator is deleted, the corresponding candidate point
    // should be deleted. When the trackedPoint is deleted, the 3d
    // locator is not affected. - bw 99.03
    // 
//     string $loc[] = `listConnections ($newName+".threeDLocator")`;
//     if ( $loc[0] != "" ) {
// 	// delete all the candidate points that refer to this tracked point
// 	string $point;
// 	string $points[] = `listConnections ($loc[0]+".message")`;
// 	for ( $point in $points ) {
// 	    string $nt = `nodeType $point`;
// 	    if ( $nt == "cameraSolutionCandidatePoint" ) {
// 		delete $point;
// 	    }
// 	}
// 	delete $loc[0];
//     }

	//delete $newName;
	
	// Made the delete operation as evalDeferred with least priority so that
	// all the previous operations goes into the undo queue properly

	global string $trackedPtName = "";
	$trackedPtName = $newName;
	evalDeferred -lp ("mlDeleteTrackedPt($trackedPtName);");
}

global proc mlDeleteTrackedPt (string $trackedPtName)
{
	string $strList[];
	$strList = `ls $trackedPtName`;
	if ( size ($strList) > 0 ) 
		delete $trackedPtName; 
	mlDeleteActualCB;
}


///////////////////////////////////////////////////////////////////////////////
//
//  Procedure Name:
//	mlRename3DLocator
//
//

global proc mlRename3DLocator( string $point )
{
    string $components[];
    tokenize $point "|" $components;
    string $locName = $components[(`size $components`-1)];

    string $loc[] = `listConnections -s true -d false ($point+".threeDLocator")`;

    if ( size( $loc ) > 0 && $loc[0] != "" && $locName != "" ) {
		string $renamedName = `rename $loc[0] ($locName+"_3D")`;
		string $shapes[] = `listRelatives -pa -shapes $renamedName`;
		string $shapeName = ($locName+"_3DShape");

		if ( size( $shapes ) > 0 && $shapes[0] != "" && $shapeName != "" ) {
			$renamedName = `rename $shapes[0] $shapeName`;
		}
    }
}


///////////////////////////////////////////////////////////////////////////////
//
//  Procedure Name:
//	mlSetTrackedPointValidity
//
//

global proc mlSetTrackedPointValidity( string $point,
				     int $startFrame,
				     int $endFrame,
				     int $valid )
{
    string $shapes[] = `listRelatives -shapes $point`;

    // handle the subsequent frame
    int $nextValidity = `getAttr -t ($endFrame + 1) ($shapes[0]+".active")`;
    if ( $nextValidity != $valid ) {
	setKeyframe -t ($endFrame+1) -v $nextValidity -at "active" $shapes[0];
    } else {
	cutKey -time ($endFrame+1) -attribute active -option keys $shapes[0];
    }
    
    // handle the first frame
    if ( $startFrame > 1 ) {
	cutKey -time $startFrame -attribute active -option keys $shapes[0];
    }
    int $startValidity = `getAttr -t $startFrame ($shapes[0]+".active")`;
    if ( $startValidity != $valid ) {
	setKeyframe -t $startFrame -v $valid -at "active" $shapes[0];
    }

    // remove all intermediate keyframes
    if ( $startFrame != $endFrame ) {
	cutKey
	    -time (($startFrame+1)+":"+$endFrame)
	    -attribute active
	    -option keys
	    $shapes[0];
    }
}


///////////////////////////////////////////////////////////////////////////////
//
//  Procedure Name:
//	mlUserTrackedFrame
//
//

global proc mlUserTrackedFrame( string $trackedPoint, int $frame, int $tf )
{
    // Note the change in meaning of the 'userTracked' attribute. The
    // value is not used, just whether a keyframe exists or not.

    // find out if it's keyframed on frame
    float $kv[] = `keyframe -t $frame -q ($trackedPoint+".userTracked")`;

    if ( size($kv ) > 0 && $tf == 0 ) { 
	// has keyframe and wants it reset - delete key
	cutKey -t $frame -clear -at "userTracked" $trackedPoint;

    } else if( size($kv ) == 0 && $tf ) { 
	// no keyframe and wants it - add key
	setKeyframe -t $frame -v $tf -at "userTracked" $trackedPoint;

	// reset the error
	setKeyframe -t $frame -v 0 -at "error" $trackedPoint;
    }
}


global proc string[] mlGetTrackPoints()
{
    string $shot = `mlGetCurrentShot`;
    string $clip = `mlGetShotBackgroundImage( $shot )`;

    string $pts[];

    if( $clip != "" ) {
	$pts = `listConnections ($clip+".trackedPoints")`;
    }
    return $pts;
}


global proc string[] mlGetSelectedTrackPoints()
{

    string $allPoints[] = mlGetTrackPoints();

    // print "tracked points to refresh:\n";
    // print $points;

    string $selectedPoints[];
    int $end = 0;

    string $point;
    for( $point in $allPoints ) {

    	if( mlObjectIsSelected( $point ) ) {
	    $selectedPoints[$end++] = $point;
	}
    }

    return $selectedPoints;
}


global proc string[] mlGet3DPoints()
{
    string $shot = `mlGetCurrentShot`;
    string $clip = `mlGetShotBackgroundImage( $shot )`;

    string $pt3D[];
    int $end = 0;

    if ( $clip != "" ) {
	string $pts[] = `listConnections ($clip+".trackedPoints")`;
	for ( $pt in $pts ) {
	    string $td[] = `listConnections ($pt+".threeDLocator")`;
	    if( size( $td ) > 0 ) {
		$pt3D[$end++] = $td[0];
	    }
	}
    }
    return $pt3D;
}


global proc string[] mlGetSelected3DPoints()
{

    string $allPoints[] = mlGet3DPoints();

    // print "3Ded points to refresh:\n";
    // print $points;

    string $selectedPoints[];
    int $end = 0;

    string $point;
    for( $point in $allPoints ) {

    	if ( mlObjectIsSelected( $point ) ) {
	    $selectedPoints[$end++] = $point;
	}
    }

    return $selectedPoints;
}


global proc string mlGetCurrentTrackedPoint()
{
    warning( "// mlGetCurrentTrackedPoint is obsolete\n" );
    return `mlGetLeadSelectedTrackPoint`;
}


global proc string mlGetLeadSelectedTrackPoint()
{
    string $selectedPoints[] = mlGetSelectedTrackPoints();

    if( size( $selectedPoints ) > 0 ) {
	return $selectedPoints[0];
    } else {
	return "";
    }
}

global proc mlSetVarianceTangent( string $point )
{
    keyTangent -itt "step" -ott "step" -at "variance" -an objects $point;
}


global proc string mlCreateTrackedPoint()
{
    global string $gCurrShot;
    
    string $destClip = `mlGetShotBackgroundImage $gCurrShot`;
    string $tp = `mlCreateTrackedPointForClip $destClip 0`;
    
 
    return $tp;
}


global proc string mlCreateTrackedPointForClip( string $clip, int $mlIsTtlDragger )
{
    global string $gCurrCamera;

    // create pointTrack node
    string $trackedPointName = `mlCreatePointOrDragger $mlIsTtlDragger`;

    mlConnectTrackedPointToClip $trackedPointName $clip;

    // mark other attributes in transform as read-only?
    // add to trackbox group node

    // initialize values
    // normalized coords; init to center of image ie. (0, 0)
    //
    int $initX = 0;
    int $initY = 0;


    if( !$mlIsTtlDragger ) {
	setKeyframe -attribute locationX -value $initX $trackedPointName;
	setKeyframe -attribute locationY -value $initY $trackedPointName;
    }

    // key the following so that the controls will add keys instead of
    // updating the default values
    setKeyframe
	-time 1
	-value 1
	-attribute active
	$trackedPointName;

    setKeyframe
	-attribute variance
        -itt "flat" -ott "flat"
	$trackedPointName;

    return $trackedPointName;
}

global proc string mlCreateTtlDragger( string $locator )
{
    global string $gCurrShot;
    global string $gCurrCamera;

    string $destClip = `mlGetShotBackgroundImage $gCurrShot`;
    string $point = `mlCreateTrackedPointForClip $destClip 1`;
    
    //set initial position to 3D Point position
    mlProject $gCurrCamera $destClip $locator $point;

    //assign user specified 3D point
    connectAttr ($locator +".message") ($point +".threeDLocator");
    setAttr ($point +".ttlDragger") true;

    string $ttlSolver = `mlGetShotTtlSolver( $gCurrShot )`;
    mlConnectTtlDraggerToTtlSolver( $point, $ttlSolver );

    return $point;
}

global proc mlConnectTtlDraggerToTtlSolver( string $ttlDragger, 
					  string $ttlSolver )
{
    //print "in connect ttl dragger\n";
    string $ttlSolverPts[] = `listConnections ($ttlSolver +".ttlDraggers")`;

    for( $ttlSolverPt in $ttlSolverPts ) {
	if( $ttlDragger == $ttlSolverPt ) {
	    //print "already connected\n";
	    return;
	}
    }
    
    connectAttr -nextAvailable ($ttlDragger+".message") 
	($ttlSolver+".ttlDraggers");
}

global proc mlDisconnectTtlDraggerFromTtlSolver( string $ttlDragger, string $ttlSolver )
{
    mlDisconnectFromArrayAttr $ttlDragger "message" $ttlSolver "ttlDraggers";

}
global proc mlConnectTtlDraggerLocToTtlSolver( string $ttlDragger )
{
    //expects ttlDragger name to be its long name

    global string $gCurrShot;
    string $ttlSolver = `mlGetShotTtlSolver $gCurrShot`;
 
    string $connectTtlTrkPts[] = `listConnections ($ttlSolver +".ttlDraggerLocation" )`;

	// compute the short names
	string $shortName;
	string $tokens[];
	int $numTokens;;
	$numTokens = `tokenize $ttlDragger "|" $tokens`; 
	$shortName = $tokens[$numTokens - 1];

	string $connectName;
	string $conTokens[];
	$numTokens = `tokenize $connectTtlTrkPts[0] "|" $conTokens`;
	$connectName = $conTokens[$numTokens -1];

    if( $connectName != $shortName )
	connectAttr -force ($shortName+".location") ($ttlSolver+".ttlDraggerLocation");

}

global proc mlDisconnectTtlDraggerLocFromTtlSolver( string $ttlDragger )
{
    global string $gCurrShot;
    string $ttlSolver = `mlGetShotTtlSolver $gCurrShot`;
    
    string $connectTtlTrkPts[] = `listConnections ($ttlSolver +".ttlDraggerLocation" )`;
	// compute the short names
	string $shortName;
	string $tokens[];
	int $numTokens;;
	$numTokens = `tokenize $ttlDragger "|" $tokens`; 
	$shortName = $tokens[$numTokens - 1];

	string $connectName;
	string $conTokens[];
	$numTokens = `tokenize $connectTtlTrkPts[0] "|" $conTokens`;
	$connectName = $conTokens[$numTokens -1];

    if( $connectName == $shortName ) {  
	disconnectAttr ($ttlDragger+".location") ($ttlSolver+".ttlDraggerLocation");
    }

}

global proc mlSetUseTtlSolver( )
{
    global string $gCurrShot;
    string $ttlSolver = `mlGetShotTtlSolver $gCurrShot`;
    string $point = `mlGetLeadSelectedTrackPoint`;

    mlConnectTtlDraggerToTtlSolver( $point, $ttlSolver );
    mlConnectTtlDraggerLocToTtlSolver( $point );

}

global proc mlSetUseBatchSolver()
{
    global string $gCurrShot;
    string $ttlSolver = `mlGetShotTtlSolver $gCurrShot`;
    string $point = `mlGetLeadSelectedTrackPoint`;

    mlDisconnectTtlDraggerFromTtlSolver( $point, $ttlSolver );

    string $connectTtlDraggerLoc[] = `listConnections ($ttlSolver +".ttlDraggerLocation")`;

    if( $connectTtlDraggerLoc[0] == $point )
       mlDisconnectTtlDraggerLocFromTtlSolver( $point );
}

global proc string mlGet3DPointTrackedPoint( string $locator )
{
    // Note:  This assumes a locator may only be associated with one tp
    string $assocPoint = "";

    // get the tracked points
    string $points[] = `mlGetTrackPoints`;

     for( $point in $points ) {
	 string $trkPt3DPoint[] = `listConnections ($point +".threeDLocator")`;
	 if( $trkPt3DPoint[0] != "" ) {
	     if( $trkPt3DPoint[0] == $locator ) {
		 $assocPoint = $point;
		 break;
	     }
	 }
    }

    return $assocPoint;
}

global proc int mlIsTtlDragger( string $point )
{
    if( $point != "" )
       return (`getAttr ($point +".ttlDragger")`);
    else 
       return 0;
}

global proc string mlGetTrackedPoint3DLocator( string $point )
{
    string $locator[] = `listConnections ($point +".threeDLocator")`;
    
    return $locator[0];    
}


global proc mlGetTrackedPointStats()
{
    string $pts[] = `mlGetTrackPoints`;
    string $pt;
    int $start = `mlGetFirstFrameOfScene`;
    int $end   = `mlGetLastFrameOfScene`;
    int $fr;
    float $validFrames = 0.0;
    float $userTrackedFrames = 0.0;

    // count up number of valid points / frame and frames covered / point
    //
    for( $pt in $pts ) {
	$validFrames += `keyframe -t ":" -q -keyframeCount ($pt +".locationX")`;
	$userTrackedFrames += `keyframe -t ":" -q -keyframeCount ($pt +".userTracked")`;
    }

    print ( "// # of points = "+ size( $pts )
	    +", points/frame = "+ mlRoundOff( $validFrames / ($end - $start), 2 )
	    +", user frames = "+ $userTrackedFrames
	    +"\n" );
}

global proc mlCreateTrackedPoint3DLocator( string $point) 
{
    string $locator = `createNode trackedPoint3DLocator`;
    setAttr ($locator+".visibility") false;

    string $locTransform[] = `listRelatives -p -pa $locator`;
    connectAttr ($locTransform[0]+".message") ($point +".threeDLocator");

    mlRename3DLocator $point;

    string $soln = mlGetCurrentCameraSoln();
    string $elem = mlGetSolutionElement( $soln );
    string $td[] = `listConnections ($point +".threeDLocator")`;
   
    parent $td[0] $elem;

}