def buildGhostAnimation(*args):
    
    obj = 'ghost_body1'

    # get animation start and end points from ui controls
    animation_start = cmds.intField('animation_start', query=True, value=True)
    animation_end   = cmds.intField('animation_end', query=True, value=True)

    for current_time in range(animation_start, animation_end + 1):
        
        cmds.currentTime(current_time, edit=True)
        locatorPos = cmds.xform('character_locator', q=1, t=True)
        
        x = round(locatorPos[0], 2)
        z = round(locatorPos[2], 2)

        if x % 1 == 0.25 or z % 1 == 0.25:
            cmds.xform(obj, rotation = [0, 11.25, 0])
        elif x % 1 == 0.5 or z % 1 == 0.5:
            cmds.xform(obj, rotation = [0, 22.5, 0])
        elif x % 1 == 0.75 or z % 1 == 0.75:
            cmds.xform(obj, rotation = [0, 33.75, 0])
        elif x % 1 == 0 or z % 1 == 0:
            cmds.xform(obj, rotation = [0, 0, 0])
        else:
            assert False, "Unhandled character position"

        cmds.setKeyframe([obj])

def dsEmitAlongLocator(start,end,ss):
    y = start
    x = end
    cmds.currentTime(y)
    
    locX = cmds.getAttr('locator1.translateX')
    locY = cmds.getAttr('locator1.translateY')
    locZ = cmds.getAttr('locator1.translateZ')
    beforePos = [locX,locY,locZ]
    
    while y <= x:
        cmds.currentTime(y)
        locX = cmds.getAttr('locator1.translateX')
        locY = cmds.getAttr('locator1.translateY')
        locZ = cmds.getAttr('locator1.translateZ')
        pos = [locX,locY,locZ]
        
        dist = [pos[0]-beforePos[0],pos[1]-beforePos[1],pos[2]-beforePos[2]]
        val = [dist[0]/ss,dist[1]/ss,dist[2]/ss]

        for i in range(ss):
            beforePos = [beforePos[0]+val[0],beforePos[1]+val[1],beforePos[2]+val[2]]
            cmds.emit( object='trail_pt', pos=(beforePos))
            
        beforePos = pos
        y = y + 1

def exportSgKeyData( targetTransformNodes, startFrame, endFrame, step, folderPath=None, exportByMatrix=False, *args ):
    
    import sgBFunction_scene
    import copy
    
    if step < 0.05:
        cmds.error( "Step Must be larger then %.f." % step )
    
    sgBFunction_base.autoLoadPlugin( "sgBDataCmd" )
    if not folderPath: folderPath = sgBFunction_fileAndPath.getDefaultSgKeyDataPath()
    sgBFunction_fileAndPath.makeFolder( folderPath )
    sgBFunction_fileAndPath.removeChildFiles( folderPath )
    
    targetTransformNodeParents = []
    for transformNode in targetTransformNodes:
        targetTransformNodeParents += sgBFunction_dag.getParents( transformNode )
        targetTransformNodeParents.append( transformNode )
    targetTransformNodeParents = list( set( targetTransformNodeParents ) )
    
    sgBFunction_scene.exportTransformData( targetTransformNodeParents, folderPath )
    
    cmds.sgBDataCmd_key( targetTransformNodes, se=1, folderPath= folderPath, ebm=exportByMatrix )
    
    cuTime = copy.copy( startFrame )
    
    while cuTime <= endFrame+1:
        cmds.currentTime( cuTime )
        cmds.sgBDataCmd_key( write=1 )
        cuTime += step

    cmds.sgBDataCmd_key( ee=1 )

    def exportAbc(self, root, frameRange=(1,24), suffix="", **kargs):

        self.__abc_files.append(expandFileName('testAnimParticleReadWrite_%s.abc' % suffix))

        # seed on first frame
        cmds.currentTime(1)
        maya.mel.eval("seed(1)")
        
        # First, eval time from one to frameRange start to avoid a possible jump
        for i in range(1,frameRange[0]):
            cmds.currentTime(i)


        # Format argument for extra atrbutes
        argStr = " "
        for item in kargs:
            if isinstance(kargs[item], (tuple,list)):
                for element in kargs[item]:
                    argStr += " -%s %s" % ( item, element )
            else:
               argStr += " -%s %s" % ( item, kargs[item] )

        # Export
        stdoutWrite("writefile: %s" % self.__abc_files[-1])
        cmds.AbcExport(j='-fr %d %d -root %s %s -file ' % (frameRange[0], frameRange[1], root, argStr) + self.__abc_files[-1] )

def nuke_track_node():
	"""
	creates a nuke track node for the selected transform.
	selection order: trasnform, camera
	"""
	
	selection	= cmds.ls( selection = True )
	point		= selection[0]
	camera		= selection[1]
	cameraShape	= cmds.listRelatives( shapes = True )[0]
	aperture_h	= cmds.camera( camera, hfa=1, q=1)
	aperture_v	= cmds.camera( camera, vfa=1, q=1)
	trackNode	= 'Tracker3 { track1 {{curve x1 '
	tx			= ''
	ty			= ''
	endframe	= 48
	
	for frame in range( 1, endframe + 1 ):
		cmds.currentTime( frame )
		fov_h	= cmds.camera( camera, hfv=1, q=1)
		fov_v	= cmds.camera( camera, vfv=1, q=1)
		track	= get_normalized_screen_position( point, camera, fov_h, fov_v, aperture_h, aperture_v )
		tx		+= str( track[0] * 1280 ) + ' '
		ty		+= str( track[1] * 720 ) + ' '

	trackNode += tx + '} {curve x1 ' + ty + '}}}'
	print '#' * 50
	print '>>> tracker node, copy paste to nuke:'
	print trackNode

    def exportAndRender(self,
                        renderDir,
                        renderSettings,
                        mitsubaPath,
                        oiiotoolPath,
                        mtsDir, 
                        keepTempFiles,  
                        animation, 
                        frame=None, 
                        verbose=False):

        if frame != None:
            # Calling this can lead to Maya 2016 locking up if you don't have MAYA_RELEASE_PYTHON_GIL set
            # See Readme
            cmds.currentTime(float(frame))
        else:
            frame = 1

        sceneName = self.getScenePrefix()

        scenePrefix = cmds.getAttr("defaultRenderGlobals.imageFilePrefix")
        if scenePrefix is None:
            scenePrefix = sceneName

        outFileName = os.path.join(renderDir, "%s.xml" % scenePrefix)

        # Export scene and geometry
        geometryFiles = MitsubaRendererIO.writeScene(outFileName, renderDir, renderSettings)

        # Render scene, delete scene and geometry
        imageName = self.renderScene(outFileName, renderDir, mitsubaPath, oiiotoolPath,
            mtsDir, keepTempFiles, geometryFiles, animation, frame, verbose,
            renderSettings)

        return imageName

 def _plotter_avrg(self):
     '''plots a locator to a vertice or face per keyframe in a timeline'''
     selObj=cmds.ls(sl=1, fl=1)      
     if len(selObj)>0:
         pass
     else:
         print "Select 1 object" 
         return     
     getTopRange=cmds.playbackOptions(q=1, max=1)+1#get framerange of scene to set keys in iteration 
     getLowRange=cmds.playbackOptions(q=1, min=1)-1#get framerange of scene to set keys in iteration 
     edgeBucket=[]
     getRange=arange(getLowRange,getTopRange, 1 )
     getloc=cmds.spaceLocator(n=selObj[0]+"cnstr_lctr")
     cmds.normalConstraint(selObj[0], getloc[0])
     placeloc=cmds.spaceLocator(n=selObj[0]+"lctr")
     for each in getRange:
         cmds.currentTime(each)            
         transform=cmds.xform(selObj, q=1, ws=1, t=1)
         posBucketx=self.array_median_find(transform[0::3])
         posBuckety=self.array_median_find(transform[1::3])
         posBucketz=self.array_median_find(transform[2::3])
         cmds.xform(getloc[0], ws=1, t=(posBucketx, posBuckety, posBucketz))  
         cmds.SetKeyTranslate(getloc[0])
         cmds.xform(placeloc[0], ws=1, t=(posBucketx, posBuckety, posBucketz))
         cmds.SetKeyTranslate(placeloc[0])               
         rotate=cmds.xform(getloc[0], q=True, ws=1, ro=True)
         cmds.xform(placeloc[0], ws=1, ro=rotate)  
         cmds.SetKeyRotate(placeloc[0])
         cmds.currentTime(each)            

 def setObjectToShatterCmd(self, *args):
     '''
     
     '''
     if not (cmds.draggerContext(self._IScontextTool._mContext, exists = True)):
         
         iMinTime = cmds.playbackOptions(query = True, minTime = True)
         cmds.currentTime(iMinTime, edit = True)       
         
         polySelection = cmds.filterExpand(selectionMask = 12)
         if polySelection:            
             
             if len(polySelection) > 0:                   
                 
                 mBreakNode = cmds.listConnections(polySelection[0], sh = True, type = 'fxBreakGeometry')
                 if not mBreakNode:
                     
                     cmds.button(self._ISaddBtn, edit = True, label = 'Please wait... checking mesh toplogy')
                     self._IScontextTool.checkForNonManifoldMeshes(polySelection[0])
                     cmds.delete(polySelection[0], ch = True)                    
                 
                 self.resetIShatterGUI()
                 self._IScontextTool._mVoroObject = polySelection[0]                
                 cmds.button(self._ISaddBtn, edit = True, label = polySelection[0])
                 cmds.button(self._ISdelBtn, edit = True, enable = True)
                 cmds.button(self._ISprocessBtn, edit = True, enable = True)
                 cmds.checkBox(self._ISborderEdgesCbx, edit = True, enable = True)
                 cmds.checkBox(self._IShideObjectsCbx, edit = True, enable = True)                                                                                                  
                 
         else:
             cmds.confirmDialog(title = 'Oups... IShatter Error', message = 'You must select one mesh object first !', button = 'OK', defaultButton = 'Yes', cancelButton = 'No', dismissString = 'No')            

def frameSection(nudge=24):

    curvesShown = cmds.animCurveEditor("graphEditor1GraphEd", query=True, curvesShown=True)
    if not curvesShown:
        return

    firstSelKey = cmds.keyframe(selected=True, query=True, timeChange=True)
    # lastKey     = max(cmds.keyframe(selected=False, query=True, timeChange=True))
    lastKey = cmds.playbackOptions(query=True, maxTime=True)

    if firstSelKey:  # if key is selected
        firstSelKey = min(firstSelKey)
    else:
        # firstSelKey = min(cmds.keyframe(selected=False, query=True, timeChange=True))
        firstSelKey = cmds.playbackOptions(query=True, minTime=True)

        try:
            if G.AM_lastFrameSection + nudge < lastKey and G.AM_lastCurvesShown == curvesShown:
                firstSelKey = G.AM_lastFrameSection + nudge
        except:
            pass

    G.AM_lastFrameSection = firstSelKey
    G.AM_lastCurvesShown = curvesShown

    framePlaybackRange.framePlaybackRangeFn(rangeStart=(firstSelKey - 1), rangeEnd=(firstSelKey + nudge + 2))
    cmds.currentTime(firstSelKey, edit=True)

def createKeyFrames(numFrames, boundary):
	'''create the keyframes for the animation'''
	for frame in range(numFrames):
		cmds.currentTime( frame, edit=True )
		for b in boids:

			# How to stop a running maya script:
			# When a script is running in maya, Everything
			# freezes and maya does not repond to input.
			# To get around this maya has to be stopped from
			# the outside. This if-statement looks for a empty file
			# named "stop.maya" anywhere you want in your filesystem.
			# If it is found, maya exits the script. To stop a script,
			# just add this file to your defined path and it exits. When
			# you want to start the script again, just rename it to something
			# else, eg: run.maya.
			if os.path.isfile('C:\\dev\\stop.maya'):
				sys.exit()

			neighborhood = getNeighborhood(b)
			alignment(b, neighborhood)
			separation(b, neighborhood)
			cohesion(b, neighborhood)
			boundary.avoidWalls(b)
			followPath(b)
			obstacleAvoidance(b)
			wander(b)
			b.move(dt)
			b.setKeyFrame(frame)

def walkParticlesProjection(camera, particles, step=1, start=None, end=None, pBar=None):
    if start is None:
        start = cmds.playbackOptions(q=True, minTime=True)
    if end is None:
        end   = cmds.playbackOptions(q=True, maxTime=True)
    start = int(start)
    end   = int(end)
        
    #pStep = 0 if pBar is None else int(100 / (end - start + 1))
    pStep = 1

    coords = None
    
    for frame in xrange(start, end + 1):
        #log("... FRAME %d ..." % frame)
        cmds.currentTime(frame)
        
        points = getParticlesProjection(camera, particles, step)
        pid    = 0

        if coords is None:
            coords = [None] * len(points)
        
        for point in points:
            if coords[pid] is None:
                coords[pid] = [None] * (end - start + 1)
                
            coords[pid][frame - start] = point
            pid += 1
            
        if pBar:
            cmds.progressBar(pBar, e=1, s=pStep)
    
    return coords

 def setUp(self):
     cmds.file(new=1, f=1)
     self.cube = cmds.polyCube()[0]
     for i in xrange(1,21,2):
         cmds.currentTime(i)
         pm.setAttr(self.cube + '.tx', i)
         pm.setKeyframe(self.cube + '.tx')

    def __exit__(self, *exc_info):

        cmds.autoKeyframe(state=self.autoKeyState)
        cmds.currentTime(self.time)

        if self.selection:
            cmds.select(self.selection)

def createTrackwayVisualization(trackway):

    references = []

    for foot in trackway:
        references.extend(createMarchingSphere(foot))

    references.append(createHipsIndicator(trackway))
    references.append(createShoulderIndicator(trackway))

    group = cmds.group(*references, world=True, name=name)
    cmds.select(group)

    applyShaders(trackway)
    createRenderEnvironment()

    minTime = min(0, int(cmds.playbackOptions(query=True, minTime=True)))
    maxTime = trackway.duration

    cmds.playbackOptions(
        minTime=minTime, animationStartTime=minTime,
        maxTime= maxTime, animationEndTime=maxTime)

    cmds.currentTime(0, update=True)
    cmds.select(group)

    def testAnimMeshReload(self):

        MayaCmds.polyCube( name = 'mesh')
        MayaCmds.setKeyframe('meshShape.vtx[0:7]', time=[1, 24])
        MayaCmds.setKeyframe('meshShape.vtx[0:7]')
        MayaCmds.currentTime(12, update=True)
        MayaCmds.select('meshShape.vtx[0:7]')
        MayaCmds.scale(5, 5, 5, r=True)
        MayaCmds.setKeyframe('meshShape.vtx[0:7]', time=[12])
        self.__files.append(util.expandFileName('testAnimMeshReadWrite.abc'))
        MayaCmds.AbcExport(j='-fr 1 24 -root mesh -f ' + self.__files[-1])

        # reading test
        MayaCmds.AbcImport(self.__files[-1], mode='open')

        # save as a maya file
        self.__files.append(util.expandFileName('test.mb'))
        MayaCmds.file(rename=self.__files[-1])
        MayaCmds.file(save=True)

        # reload as a maya file
        MayaCmds.file(self.__files[-1], open=True)
        MayaCmds.AbcImport(self.__files[-2], mode='import')

        retVal = True
        mesh1 = '|mesh|meshShape'
        mesh2 = '|mesh1|meshShape'
        for t in range(1, 25):
            MayaCmds.currentTime(t, update=True)
            if not util.compareMesh( mesh1, mesh2 ):
                self.fail('%s and %s were not equal at frame %d' % (mesh1,
                    mesh2, t))

def refresh():
    cmds.undoInfo(stateWithoutFlush=False)
    # cmds.refresh(force=True)
    # print "refresh"
    cmds.refresh(suspend=False)
    cmds.currentTime(cmds.currentTime(query=True), edit=True)
    cmds.undoInfo(stateWithoutFlush=True)

	def exportObjects(self):
		for object in self.objects:
			cmds.select(object, r= True)
	
			if self.exportType == 1:
				fileType = 'Fbx'
				cmds.loadPlugin('fbxmaya', qt= True)
				melCmd.eval('FBXExportShowUI -v false;')
			else:
			  fileType = 'OBJexport'
			  cmds.loadPlugin('objExport', qt= True)
			
			if bool(self.exportGeometrySequence) == bool(True):
				startF = self.startFrame
				endF = self.endFrame 
			else:
				startF = endF = cmds.currentTime( query=True )
			
			nameExtension = ''
			exportName = object.replace(':', '_')
			
			for timevalue in range(startF, (endF+1), 1):
				if bool(self.exportGeometrySequence) == bool(True):
					nameExtension = '.%04d' % timevalue 
				cmds.currentTime(timevalue)
				if self.exportType == 1:
					melCmd.eval('FBXExport -f "' + self.exportPath + exportName + nameExtension + '.fbx" -s')
				else:
					cmds.file(self.exportPath+exportName+nameExtension, op='', typ=fileType, pr=True, es=True )  

			print 'Exported: ' + object;

def set_vertex_position(getVtxPosOfFrame = 101):
    '''
    This method sets the vertex positions 
    of the mesh by the vertex positions at the 
    specified frameNumber 
    '''

    #Cloudy:SF_C_hatSculpt138918980693
    #Cloudy:C_hat_PLY

    #--- get the selected object
    sel = cmds.ls(selection = True)
    #--- get the current frame
    current_frame = cmds.currentTime(query = True)
    #--- jump to the specified frame
    cmds.currentTime(getVtxPosOfFrame)

    #--- get the vertex positions of the selected mesh
    for i in sel:
        #--- get the original mesh, verts and vert positions
        original_mesh = i.split('SF')[0] + i.split('SF_')[-1].split('Sculpt')[0] + '_PLY' 
        original_vert = cmds.ls(original_mesh + '.vtx[*]', flatten = True)
        original_pos = []
        for v in original_vert:
            pos = cmds.xform(v, query = True, translation = True, worldSpace = True)
            original_pos.append(pos)

        #--- go to the initial frame
        cmds.currentTime(current_frame)
        #--- set the vertex positions of the sculpt mesh
        sculpt_vert = cmds.ls(i + '.vtx[*]', flatten = True)
        for v, pos in zip(sculpt_vert, original_pos):
            cmds.xform(v, translation = pos, worldSpace = True)

def changeToLastFrame(currentFrame):
    removeBoxesFromView(currentFrame)
    cmds.currentTime( currentFrame - 1, edit = True, update= True)
    showNewBoxesInView(frame = int(cmds.currentTime( query=True )))
    cmds.textField(g_currentFrameField,e=True,ip=1,tx=currentFrame-1)
    global g_currentFrame
    g_currentFrame = currentFrame-1

def bake_camera(node):
        print 'baking camera '+str(node)+'...', 
        camera_info = get_camera_info(node)

        newCamera = cmds.camera()
        
        for frame in camera_info['frames']:
            cmds.currentTime(frame)
            # set matrix
            cmds.xform(newCamera[0], m=camera_info['matrix.'+str(frame)])
            cmds.setAttr(newCamera[1]+'.focalLength', camera_info['focal.'+str(frame)])
            cmds.setAttr(newCamera[1]+'.horizontalFilmAperture', camera_info['hap.'+str(frame)])
            cmds.setAttr(newCamera[1]+'.verticalFilmAperture', camera_info['vap.'+str(frame)])
            cmds.setAttr(newCamera[1]+'.horizontalFilmOffset', camera_info['hfo.'+str(frame)])
            cmds.setAttr(newCamera[1]+'.verticalFilmOffset', camera_info['vfo.'+str(frame)])
            # set keyframes
            cmds.setKeyframe(newCamera[0]+'.tx')
            cmds.setKeyframe(newCamera[0]+'.ty')
            cmds.setKeyframe(newCamera[0]+'.tz')
            cmds.setKeyframe(newCamera[0]+'.rx')
            cmds.setKeyframe(newCamera[0]+'.ry')
            cmds.setKeyframe(newCamera[0]+'.rz')
            cmds.setKeyframe(newCamera[1]+'.focalLength')
            cmds.setKeyframe(newCamera[1]+'.horizontalFilmAperture')
            cmds.setKeyframe(newCamera[1]+'.verticalFilmAperture')
            cmds.setKeyframe(newCamera[1]+'.horizontalFilmOffset')
            cmds.setKeyframe(newCamera[1]+'.verticalFilmOffset')
        print 'created '+str(newCamera)+',',