Пример #1
0
def timer(mode="l", function=""):

    if mode == "s":
        try:
            startTime = cmds.timer(startTimer=True)
            G.UM_timerMessage = "startTime: %s\n" % startTime
            G.UM_timerLap = 1
        except:
            pass

    elif mode == "l":
        try:
            lapTime = cmds.timer(lapTime=True)
            G.UM_timerMessage += "lapTime %s: %s\n" % (G.UM_timerLap, lapTime)
            G.UM_timerLap += 1
        except:
            pass

    elif mode == "e":
        try:
            fullTime = cmds.timer(endTimer=True)
            G.UM_timerMessage += "Timer: %s took %s sec.\n" % (function,
                                                               fullTime)
        except:
            pass

        print G.UM_timerMessage
Пример #2
0
def timer(mode="l", function=""):
    
    if mode == "s":
        try: 
            startTime       = cmds.timer( startTimer=True)
            G.UM_timerMessage    = "startTime: %s\n"%startTime
            G.UM_timerLap        = 1
        except:
            pass
        
    elif mode == "l":
        try: 
            lapTime = cmds.timer( lapTime=True)
            G.UM_timerMessage += "lapTime %s: %s\n"%(G.UM_timerLap, lapTime)
            G.UM_timerLap     += 1
        except:
            pass
        
    elif mode == "e":
        try: 
            fullTime = cmds.timer( endTimer=True)
            G.UM_timerMessage += "Timer: %s took %s sec.\n"%(function, fullTime)
        except:
            pass
            
        print G.UM_timerMessage
Пример #3
0
    def onRelease(self):
        cmds.timer(e=True)
        self.endTime = cmds.currentTime(q=True)
        if "translate" in self.mode:
            if self.channelBox is True:
                if self.simplify is True:
                    utils().simplify(self.object,
                                     (self.startTime, self.endTime),
                                     at=self.attributes)
            else:
                if self.simplify is True:
                    if self.shape is True:
                        simpAt = ['xValue', 'yValue', 'zValue']
                    else:
                        simpAt = ['tx', 'ty', 'tz']
                    utils().simplify(self.object,
                                     (self.startTime, self.endTime),
                                     at=simpAt)

        if "rotate" in self.mode and self.shape is False:
            if self.channelBox is True:
                # euler filter
                for at in self.attributes:
                    cmds.filterCurve(self.object + '.' + at,
                                     f='euler',
                                     s=self.startTime,
                                     e=self.endTime)
                if self.simplify is True:
                    utils().simplify(self.object,
                                     (self.startTime, self.endTime),
                                     at=self.attributes)
            else:
                for at in ['rx', 'ry', 'rz']:
                    cmds.filterCurve(self.object + '.' + at,
                                     f='euler',
                                     s=self.startTime,
                                     e=self.endTime)
                if self.simplify is True:
                    utils().simplify(self.object,
                                     (self.startTime, self.endTime),
                                     at=['rx', 'ry', 'rz'])
        mel.eval('timeControl -e -endScrub $gPlayBackSlider;')
Пример #4
0
def main(meshName, outputFolder):

    cmds.timer(s=True)
    cmds.undoInfo( state=False)
    mel.eval("paneLayout -e -manage false $gMainPane")
    
    #Take the markers arranged in groups
    markersSelection = sorted(cmds.listRelatives("TopMarkers")) + sorted(cmds.listRelatives("TopMiddleMarkers")) + sorted(cmds.listRelatives("MiddleMarkers")) + sorted(cmds.listRelatives("MiddleBottomMarkers")) + sorted(cmds.listRelatives("BottomMarkers"))
    
    #Take the geodesic vertices
    geodesicVertices = cmds.ls(cmds.sets("MouthArea", q=True), flatten=True) + cmds.ls(cmds.sets("REyeArea", q=True), flatten=True) + cmds.ls(cmds.sets("LEyeArea", q=True), flatten=True)
    
    matrix = calculateDistanceMatrixToFile(meshName, outputFolder, markersSelection, geodesicVertices, calculateEuclideanMatrix = True, calculateGeodesicMatrix=True)
    
    mel.eval("paneLayout -e -manage true $gMainPane")
    cmds.undoInfo( state=True)
    time = cmds.timer(e=True)

    print("Matrix calculations completed. Files created at: " + outputFolder)
    print("Running time: " + str(time) + "s")
Пример #5
0
    def onPress(self):
        self.attributes = cmds.channelBox("mainChannelBox",
                                          query=True,
                                          sma=True)
        if self.attributes is None:
            self.attributes = []
        self.lastT = 0
        cmds.timer(s=True)
        self.startTime = cmds.currentTime(q=True)
        self.lastHit = cmds.draggerContext(self.dragCtx,
                                           q=True,
                                           anchorPoint=True)

        # get cam vectors
        camObject = utils().getCam()
        viewDir = camObject.viewDirection(om.MSpace.kWorld)
        self.upDir = camObject.upDirection(om.MSpace.kWorld)
        rightDir = camObject.rightDirection(om.MSpace.kWorld)
        self.lastVec = None
        self.lastRot = [0.0, 0.0, 0.0]
        self.idQuat = utils().quatFromObj(self.object)
        self.idVec = utils().localToWorld(self.idLocalVec, self.object)
        mel.eval('timeControl -e -beginScrub $gPlayBackSlider;')
Пример #6
0
    def onDrag(self):
        # timer
        lap = cmds.timer(lap=True)
        curTime = cmds.currentTime(q=True)
        sub = lap - self.lastT

        #get position
        dragPosition = cmds.draggerContext(self.dragCtx,
                                           q=True,
                                           dragPoint=True)

        # start operations
        if sub > self.timeFactor / self.fps:
            self.objPos = cmds.xform(self.object, q=True, ws=True, t=True)

            # translate
            if "translate" in self.mode:
                # key attributes
                if self.channelBox is True:
                    if 'tx' in self.attributes:
                        cmds.move(dragPosition[0] * self.unit,
                                  self.object,
                                  ws=True,
                                  absolute=True,
                                  wd=True,
                                  x=True)
                        cmds.setKeyframe(self.object, at='tx')
                    if 'ty' in self.attributes:
                        cmds.move(dragPosition[1] * self.unit,
                                  self.object,
                                  ws=True,
                                  absolute=True,
                                  wd=True,
                                  y=True)
                        cmds.setKeyframe(self.object, at='ty')
                    if 'tz' in self.attributes:
                        cmds.move(dragPosition[2] * self.unit,
                                  self.object,
                                  ws=True,
                                  absolute=True,
                                  wd=True,
                                  z=True)
                        cmds.setKeyframe(self.object, at='tz')
                else:
                    cmds.move(dragPosition[0] * self.unit,
                              dragPosition[1] * self.unit,
                              dragPosition[2] * self.unit,
                              self.object,
                              ws=True,
                              absolute=True,
                              wd=True)
                    if self.shape:
                        cmds.setKeyframe(self.object)
                    else:
                        cmds.setKeyframe(self.object, at='translate')

            # rotate
            if "rotate" in self.mode and self.shape is False:
                self.vector = om.MVector(dragPosition[0] - self.objPos[0],
                                         dragPosition[1] - self.objPos[1],
                                         dragPosition[2] - self.objPos[2])

                if self.autoAim is True:
                    if self.lastVec is None:
                        self.idVec = self.vector

                rotator = om.MQuaternion(self.idVec, self.vector)
                result = self.idQuat * rotator
                euler = result.asEulerRotation()
                dragRotation = [
                    math.degrees(euler.x),
                    math.degrees(euler.y),
                    math.degrees(euler.z)
                ]
                relRotation = [
                    new - old for new, old in zip(dragRotation, self.lastRot)
                ]

                # key attributes
                if self.channelBox is True:
                    if 'rx' in self.attributes:
                        cmds.rotate(dragRotation[0],
                                    ws=True,
                                    absolute=True,
                                    x=True)
                        cmds.setKeyframe(self.object, at='rx')
                    if 'ry' in self.attributes:
                        cmds.rotate(dragRotation[1],
                                    ws=True,
                                    absolute=True,
                                    y=True)
                        cmds.setKeyframe(self.object, at='ry')
                    if 'rz' in self.attributes:
                        cmds.rotate(dragRotation[2],
                                    ws=True,
                                    absolute=True,
                                    z=True)
                        cmds.setKeyframe(self.object, at='rz')
                else:
                    cmds.rotate(dragRotation[0],
                                dragRotation[1],
                                dragRotation[2],
                                ws=True,
                                absolute=True)
                    # cmds.rotate(relRotation[0],relRotation[1],relRotation[2],ws=True,relative=True,eu=True)
                    self.lastRot = dragRotation
                    cmds.setKeyframe(self.object, at='rotate')

                # looping variables
                self.lastVec = self.vector

        # change time
            cmds.currentTime(curTime + 1)
            cmds.currentTime(curTime + 1)
            self.lastT = lap
Пример #7
0
def calculateDistanceMatrixToFile(meshName, outputFolder, markersList, geodesicVertices, calculateEuclideanMatrix=True, calculateGeodesicMatrix=True):
    
    #Start progress bar 
    progressAmount = 0;
    gMainProgressBar = mel.eval('$tmp = $gMainProgressBar')
    cmds.progressBar(gMainProgressBar, edit=True, progress=progressAmount, status='Calculating...', isInterruptable=True, bp=True )
    
    nVert = cmds.polyEvaluate(meshName, v=True)
    
    outFileEuclidean = None
    outFileGeodesics = None
    outFileHybrid = None
    
    #Open the output files
    if (calculateEuclideanMatrix):
        if not os.path.exists(outputFolder):
            try:
                os.makedirs(outputFolder)
            except OSError as exc:
                if exc.errno != errno.EEXIST:
                    raise
        path = outputFolder+"/eucMatrix.mtx"
        outFileEuclidean = open(path, 'w')
        
    if (calculateGeodesicMatrix):
        if not os.path.exists(outputFolder):
            try:
                os.makedirs(outputFolder)
            except OSError as exc:
                if exc.errno != errno.EEXIST:
                    raise
        path = outputFolder+"/geoMatrix.mtx"
        outFileGeodesics = open(path, 'w')
    
    if (calculateEuclideanMatrix and calculateGeodesicMatrix):
        if not os.path.exists(outputFolder):
            try:
                os.makedirs(outputFolder)
            except OSError as exc:
                if exc.errno != errno.EEXIST:
                    raise
        path = outputFolder+"/hybMatrix.mtx"
        outFileHybrid = open(path, 'w')
    
    #Go to frame 0 (reference frame)
    cmds.currentTime(0)
    
    #Create a list with the closest vertices to the markers
    vertexMarkers = matchMarkersWithMesh(markersList, meshName)
    
    #Progress control
    progressStep = float(100) / float(nVert)
    euclideanTime = 0
    geodesicTime = 0
    hybridTime = 0
    
    #Calculate distance matrix values for every vertex
    if (calculateEuclideanMatrix or calculateGeodesicMatrix):
        for i in range (0, nVert):
        
            progressAmount += progressStep
            cmds.progressBar(gMainProgressBar, edit=True, status="Calculating distance matrices for row " + str(i) + " of " + str(nVert), progress=progressAmount)

            for j in range (0, len(vertexMarkers)):
                v1Name = meshName + ".vtx[" + str(i) + "]"
                v2Name = meshName + ".vtx[" + str(vertexMarkers[j]) + "]"
                
                eucDist = 0
                geoDist = 0
                
                if (calculateEuclideanMatrix):
                    cmds.timer(s=True, name="euclideanTimer")
                    v1 = cmds.pointPosition(v1Name)
                    v2 = cmds.pointPosition(v2Name)
                    eucDist = getEuclideanDistance(v1, v2)
                    outFileEuclidean.write(str(eucDist)+"\n")
                    euclideanTime += cmds.timer(e=True, name="euclideanTimer")
                    
                if (calculateGeodesicMatrix):
                    cmds.timer(s=True, name="geodesicTimer")
                    geoDist = getGeodesicDistancev2(meshName, i, vertexMarkers[j])
                    outFileGeodesics.write(str(geoDist)+"\n")
                    geodesicTime += cmds.timer(e=True, name="geodesicTimer")
                
                if (calculateEuclideanMatrix and calculateGeodesicMatrix):
                    cmds.timer(s=True, name="hybridTimer")
                    hybDist = getHybridDistance(geodesicVertices, v1Name, eucDist, geoDist)
                    outFileHybrid.write(str(hybDist)+"\n")
                    hybridTime += cmds.timer(e=True, name="hybridTimer")
                
                #Progress control
                if cmds.progressBar(gMainProgressBar, q=True, ic=True):
                    cmds.progressBar(gMainProgressBar, edit=1, ep=1)
                    if (outFileEuclidean != None):
                        outFileEuclidean.close()
                    if (outFileGeodesics != None):
                        outFileGeodesics.close()
                    if (outFileHybrid != None):
                        outFileHybrid.close()
                    return
    
    #Close the file descriptors
    if (outFileEuclidean != None):
        outFileEuclidean.close()
    if (outFileGeodesics != None):
        outFileGeodesics.close()
    if (outFileHybrid != None):
        outFileHybrid.close()
    
    #Close the progress bar
    cmds.progressBar(gMainProgressBar, edit=1, ep=1)
    
    #Print the time results
    print("Time for calculating Euclidean dist. matrix: " + str(euclideanTime))
    print("Time for calculating Geodesic dist. matrix: " + str(geodesicTime))
    print("Time for calculating Hybrid dist. matrix: " + str(hybridTime))
Пример #8
0
	def startRender(self): # Will also return time taken from start to finish in minutes, to 2 decimal places
	
		frameDataLog = [] #Stores a comprehensive list of each frame as it is rendered with a timestamp for initialisation
		frameDataStringLog = []#Stores a comprehensive string list of each frame as it is rendered with a timestamp for initialisation, for using in the render log
		frameDataLogTemp = [] #Stores frame information temporarily
	
		#ints
		framesRendered = 0 #Stores current amount of frames rendered for determining overall progress
		percentComplete = 0 #Stores the percentage to completion, also used to determine if render completed successfully
		#Strings
		frameDataString = "null" #Stores frame information
		renderStartTimeStamp = ma.date(t=True) #Stores the time in which the render function was first called
		#floats
		renderTimeStamp = 0.0 #Stores the time in which the render completed or was forcably stopped
		#startTimer
		renderTimer = ma.timer(startTimer = True)
	
	
		###WINDOW CREATION
		#createWindow to allow interupting of progress.
		ma.progressWindow(isInterruptable=1, t="aBRS_RENDER", status = "Rendering...")

		#begin rendering frames
		for frame in self._frameList:
			##Allow interuption to stop the render
			if ma.progressWindow(query=True, isCancelled = True):
				print "Render Cancelled by User."
				break
		
			#set current frame
			ma.currentTime(frame)
		
			#store frame data and timestamp for initialisation then print.
			frameDataLogTemp = [self._getCam(frame), frame, ma.date(t=True)] # A nice list storing frame information (incase of storage)
			frameDataString = "Camera: %s, Frame: %s, TimeStarted: %s" % (str(frameDataLogTemp[0]), str(frameDataLogTemp[1]), str(frameDataLogTemp[2]))
		
			#Store data in lists
			frameDataLog.append(frameDataLogTemp)
			frameDataStringLog.append(frameDataString)
		
			#print current string data to viewport
			print frameDataString
			
			"""RENDER OCCURS HERE"""
			
			#try as maya 2018 arnold render returns a runtime error when interuption is detected
			self.tryArnoldRender(frame)
			#Add to frames rendered
			framesRendered += 1
			#Get percentage according to rendered vs total frames
			percentComplete = self._renderPercentComplete(framesRendered)
			#Update the progress window
			ma.progressWindow( edit=True, progress=percentComplete )
		
		'''Rendering has finished - Closing procedures'''	  
	
		#End timer
		renderTimer = ma.timer(endTimer = True)
		#End Progress window
		ma.progressWindow(endProgress=1)
		#Store total render time
		renderTimeStamp = str(round(renderTimer/60, 2))
	
		#record values for log file
		self._lS_frameDataSTR = frameDataStringLog
		self._lS_frameData = frameDataLog
		self._lS_renderStartTime = renderStartTimeStamp
		self._lS_renderEndTime = ma.date(t=True)
		self._lS_renderTimeInMinutes = renderTimeStamp
		self._lS_renderCompletionSuccessful = percentComplete == 100
		self.storeRenderData()
	
	
		#Generate log
		self.generateRenderLog()
	
		return "Render Time in Minutes: " + str(renderTimeStamp)
Пример #9
0
def main(firstFrame, lastFrame, steps, meshName, matrixFolderPath,
         stiffnessValues, RBFTechnique):

    #Check if the mesh exists in the DAG
    if not cmds.objExists(meshName):
        print("Mesh name does not match any object")
        return

    #Check that the RBF technique is valid
    if (RBFTechnique < 0 or RBFTechnique > 2):
        print("The RBF Technique code is not valid")
        return

    #Try to open the distance matrix files

    matrixFileEuclidean = None
    matrixFileGeodesics = None
    matrixFileHybrid = None

    if (RBFTechnique == 0):
        try:
            matrixFileEuclidean = open(matrixFolderPath + "/eucMatrix.mtx",
                                       'r')
        except IOError:
            confirm = cmds.confirmDialog(
                title='Matrix no found',
                message=
                'Could not find the Euclidean matrix file (eucmatrix.mtx) in the given path, do you want to proceed with the calculations without matrix? (not recommended for dense meshes)',
                button=['Yes', 'No'],
                defaultButton='Yes',
                cancelButton='No',
                dismissString='No')
            if (confirm == "No"):
                return

    if (RBFTechnique == 1):
        try:
            matrixFileGeodesics = open(matrixFolderPath + "/geoMatrix.mtx",
                                       'r')
        except IOError:
            confirm = cmds.confirmDialog(
                title='Matrix no found',
                message=
                'Could not find the Geodesics matrix file (geomatrix.mtx) in the given path, do you want to proceed with the calculations without matrix? (not recommended for dense meshes)',
                button=['Yes', 'No'],
                defaultButton='Yes',
                cancelButton='No',
                dismissString='No')
            if (confirm == "No"):
                return

    if (RBFTechnique == 2):
        try:
            matrixFileHybrid = open(matrixFolderPath + "/hybMatrix.mtx", 'r')
        except IOError:
            confirm = cmds.confirmDialog(
                title='Matrix no found',
                message=
                'Could not find the Hybrid matrix file (hybmatrix.mtx) in the given path, do you want to proceed with the calculations without matrix? (not recommended for dense meshes)',
                button=['Yes', 'No'],
                defaultButton='Yes',
                cancelButton='No',
                dismissString='No')
            if (confirm == "No"):
                return

    #Take the markers arranged in groups

    markersSelection = sorted(cmds.listRelatives("TopMarkers")) + sorted(
        cmds.listRelatives("TopMiddleMarkers")) + sorted(
            cmds.listRelatives("MiddleMarkers")) + sorted(
                cmds.listRelatives("MiddleBottomMarkers")) + sorted(
                    cmds.listRelatives("BottomMarkers"))

    #Take the vertices of the geodesic areas (for hybrid)

    geodesicVertices = None
    if (RBFTechnique == 2):
        geodesicVertices = cmds.ls(
            cmds.sets("MouthArea", q=True), flatten=True) + cmds.ls(
                cmds.sets("REyeArea", q=True), flatten=True) + cmds.ls(
                    cmds.sets("LEyeArea", q=True), flatten=True)

    #Calculate the animation of the mesh

    cmds.undoInfo(state=False)
    cmds.timer(s=True)
    mel.eval("paneLayout -e -manage false $gMainPane")

    animateMesh(meshName, markersSelection, firstFrame, lastFrame, steps,
                stiffnessValues, RBFTechnique, matrixFileEuclidean,
                matrixFileGeodesics, matrixFileHybrid, geodesicVertices)

    mel.eval("paneLayout -e -manage true $gMainPane")
    totalTime = cmds.timer(e=True)
    cmds.undoInfo(state=True)

    #Close the file descriptors
    if (matrixFileEuclidean != None):
        matrixFileEuclidean.close()
    if (matrixFileGeodesics != None):
        matrixFileGeodesics.close()
    if (matrixFileHybrid != None):
        matrixFileHybrid.close()

    #Print total time
    print("TOTAL ---------------------------------------")
    print("Total running time: " + str(totalTime) + "s")
    print("---------------------------------------------")
    print("")
Пример #10
0
def animateMesh(mesh, markersList, firstFrame, lastFrame, steps,
                stiffnessValues, RBFTechnique, matrixFileEuclidean,
                matrixFileGeodesics, matrixFileHybrid, geodesicVertices):

    #File flags
    eucMatrixExists = (matrixFileEuclidean != None)
    geoMatrixExists = (matrixFileGeodesics != None)
    hybMatrixExists = (matrixFileHybrid != None)

    #Start progress bar
    progressAmount = 0
    gMainProgressBar = mel.eval('$tmp = $gMainProgressBar')
    cmds.progressBar(gMainProgressBar,
                     edit=True,
                     progress=progressAmount,
                     status='Initializing calculations...',
                     isInterruptable=True,
                     bp=True)

    meshFullPath = cmds.ls(mesh, long=True)[0]
    nVert = cmds.polyEvaluate(mesh, v=True)

    RBFTime = 0

    #Set the default position of the vertices in all the frames

    print("Setting default position in all frames")

    for x in range(firstFrame, lastFrame + 1, steps):

        cmds.currentTime(x)

        for i in range(nVert):
            cmds.select(mesh + ".vtx[" + str(i) + "]", r=True)
            cmds.setKeyframe(meshFullPath + "|" + mesh + "Shape.pnts[" +
                             str(i) + "]",
                             breakdown=0)
            cmds.setKeyframe(mesh + ".vtx[" + str(i) + "]",
                             breakdown=0,
                             hierarchy="none",
                             controlPoints=0,
                             shape=0)

        #Progress control
        if cmds.progressBar(gMainProgressBar, q=True, ic=True):
            cmds.progressBar(gMainProgressBar, edit=1, ep=1)
            return

    #Calculate the vertices matching the markers at frame 0
    print("Calculating corresponding vertex for each marker...")

    #Pre-calculation timer starts
    cmds.timer(s=True, name="precalcTimer")

    cmds.currentTime(0)

    vertexMarkers = matchMarkersWithMesh(markersList, mesh)

    #Take the position reference from frame 0
    print("Calculating initial positions...")

    markersInitialPos = []

    for i in range(len(markersList)):
        markersInitialPos.append(getObjectPoint(markersList[i]))

    print("Filling distance matrix...")

    #Create and fill the distance matrix for Euclidean
    distMatrixEuc = []

    if (RBFTechnique == 0):

        for i in range(nVert):
            distMatrixEuc.append([])
            for j in range(nVert):
                distMatrixEuc[i].append(0)

        if (eucMatrixExists):
            for v in range(nVert):
                for c in range(len(markersList)):
                    cmds.timer(s=True, name="RBFTimer")
                    dist = float(matrixFileEuclidean.readline())
                    distMatrixEuc[v][vertexMarkers[c]] = dist
                    distMatrixEuc[vertexMarkers[c]][v] = dist
                    RBFTime += cmds.timer(e=True, name="RBFTimer")

        else:

            for v in range(nVert):
                for c in range(len(markersList)):
                    vPos1 = cmds.pointPosition(mesh + ".vtx[" + str(v) + "]")
                    vPos2 = cmds.pointPosition(mesh + ".vtx[" +
                                               str(vertexMarkers[c]) + "]")
                    cmds.timer(s=True, name="RBFTimer")
                    dist = getEuclideanDistance(vPos1, vPos2)
                    distMatrixEuc[v][vertexMarkers[c]] = dist
                    distMatrixEuc[vertexMarkers[c]][v] = dist
                    RBFTime += cmds.timer(e=True, name="RBFTimer")

    #Create and fill the distance matrix for Geodesics
    distMatrixGeo = []

    if (RBFTechnique == 1):

        for i in range(nVert):
            distMatrixGeo.append([])
            for j in range(nVert):
                distMatrixGeo[i].append(0)

        if (geoMatrixExists):

            for v in range(nVert):
                for c in range(len(vertexMarkers)):
                    cmds.timer(s=True, name="RBFTimer")
                    dist = float(matrixFileGeodesics.readline())
                    distMatrixGeo[v][vertexMarkers[c]] = dist
                    distMatrixGeo[vertexMarkers[c]][v] = dist
                    RBFTime += cmds.timer(e=True, name="RBFTimer")

        else:

            for v in range(nVert):
                for c in range(len(markersList)):
                    cmds.timer(s=True, name="RBFTimer")
                    dist = getGeodesicDistancev2(mesh, v, vertexMarkers[c])
                    distMatrixGeo[v][vertexMarkers[c]] = dist
                    distMatrixGeo[vertexMarkers[c]][v] = dist
                    RBFTime += cmds.timer(e=True, name="RBFTimer")

    print("Calculating weight matrix...")

    #Create and fill the distance matrix for Hybrid
    distMatrixHybrid = []

    if (RBFTechnique == 2):

        for i in range(nVert):
            distMatrixHybrid.append([])
            for j in range(nVert):
                distMatrixHybrid[i].append(0)

        if (hybMatrixExists):

            for v in range(nVert):
                for c in range(len(vertexMarkers)):
                    cmds.timer(s=True, name="RBFTimer")
                    dist = float(matrixFileHybrid.readline())
                    distMatrixHybrid[v][vertexMarkers[c]] = dist
                    distMatrixHybrid[vertexMarkers[c]][v] = dist
                    RBFTime += cmds.timer(e=True, name="RBFTimer")

        else:
            for v in range(nVert):

                averWeight = 1

                vName = mesh + ".vtx[" + str(v) + "]"
                vPoint = cmds.pointPosition(vName)
                if (not (vName in geodesicVertices)):
                    gdist = sys.float_info.max
                    for j in range(len(geodesicVertices)):
                        auxDist = getEuclideanDistance(
                            vPoint, cmds.pointPosition(geodesicVertices[j]))
                        if (auxDist < gdist):
                            gdist = auxDist
                    averWeight = calculateGaussianRBF(gdist, 2)

                for c in range(len(markersList)):

                    cmds.timer(s=True, name="RBFTimer")

                    dist = 0
                    if (averWeight < 0.6):
                        dist = getEuclideanDistance(vPoint,
                                                    markersInitialPos[c])
                    else:
                        dist = getGeodesicDistancev2(
                            mesh, v, vertexMarkers[c]
                        ) * averWeight + getEuclideanDistance(
                            vPoint, markersInitialPos[c]) * (1 - averWeight)

                    distMatrixHybrid[v][vertexMarkers[c]] = dist
                    distMatrixHybrid[vertexMarkers[c]][v] = dist

                    RBFTime += cmds.timer(e=True, name="RBFTimer")

    #Print total RBF Time
    RBFPrecTime = RBFTime
    print("Total RBF Time in distance calculations: " + str(RBFPrecTime) +
          " s")

    #Progress control
    progressStep = float(90) / (float(1 + lastFrame - firstFrame) /
                                float(steps))
    progressAmount += 5
    if cmds.progressBar(gMainProgressBar, q=True, ic=True):
        cmds.progressBar(gMainProgressBar, edit=1, ep=1)
        return

    #End pre-calculation timer
    precalcTime = cmds.timer(e=True, name="precalcTimer")

    #Initialize new timers
    frameTime = 0
    averageFrameTime = 0
    keyframingTime = 0
    averageKeyframingTime = 0
    iterations = 0

    for x in range(firstFrame, lastFrame + 1, steps):

        iterations += 1

        #Frame timer starts
        cmds.timer(s=True, name="frameTimer")

        #Progress control
        cmds.progressBar(gMainProgressBar,
                         edit=True,
                         status="Calculating mesh deformation for frame " +
                         str(x),
                         progress=progressAmount)

        print("Calculating deformations for frame " + str(x))

        #Calculate the displacement of the control points

        cmds.currentTime(x)

        markersDispPos = []
        markersDisp = []

        for i in range(len(markersList)):

            markersDispPos.append(getObjectPoint(markersList[i]))

            markersDisp.append([
                markersDispPos[i][0] - markersInitialPos[i][0],
                markersDispPos[i][1] - markersInitialPos[i][1],
                markersDispPos[i][2] - markersInitialPos[i][2]
            ])

        #Calculate the displacement of all the vertices by the RBF method

        #Initialize rbf matrix

        rbfMatrix = []
        for i in range(len(markersList)):
            rbfMatrix.append([])
            for j in range(len(markersList)):
                rbfMatrix[i].append(0)

        #Calculate the rbf matrix

        print("   Calculating RBF matrix... ")

        for i in range(0, len(markersList)):
            for j in range(i, len(markersList)):

                dist = 0
                eucDist = 0
                geoDist = 0
                hybDist = 0

                #Euclidean calculations
                if (RBFTechnique == 0):
                    dist = distMatrixEuc[vertexMarkers[i]][vertexMarkers[j]]

                #Geodesics calculations
                if (RBFTechnique == 1):
                    dist = distMatrixGeo[vertexMarkers[i]][vertexMarkers[j]]

                #Hybrid calculations
                if (RBFTechnique == 2):
                    dist = distMatrixHybrid[vertexMarkers[i]][vertexMarkers[j]]

                cmds.timer(s=True, name="RBFTimer")

                rbf = calculateGaussianRBF(dist, stiffnessValues[i])

                rbfMatrix[i][j] = rbf
                rbfMatrix[j][i] = rbf

                RBFTime += cmds.timer(e=True, name="RBFTimer")

        #Progress control
        if cmds.progressBar(gMainProgressBar, q=True, ic=True):
            cmds.progressBar(gMainProgressBar, edit=1, ep=1)
            return

        #Calculate the weight of each control point
        print("   Calculating weight of control points...")

        weights = []

        for i in range(len(markersList)):

            weights.append([0, 0, 0])

            cmds.timer(s=True, name="RBFTimer")

            for j in range(len(markersList)):
                weights[i][0] += rbfMatrix[i][j]
                weights[i][1] += rbfMatrix[i][j]
                weights[i][2] += rbfMatrix[i][j]

            weights[i][0] = markersDisp[i][0] / weights[i][0]
            weights[i][1] = markersDisp[i][1] / weights[i][1]
            weights[i][2] = markersDisp[i][2] / weights[i][2]

            RBFTime += cmds.timer(e=True, name="RBFTimer")

        #Calculate the displacement of the vertices of the mesh
        print("   Calculating displacement of the vertices of the mesh...")

        vDisp = []

        for i in range(nVert):

            vDisp.append([0, 0, 0])

            vName = mesh + ".vtx[" + str(i) + "]"
            vPos = cmds.pointPosition(vName)

            for c in range(len(markersList)):

                dist = 0

                #Euclidean calculations
                if (RBFTechnique == 0):
                    dist = distMatrixEuc[i][vertexMarkers[c]]

                #Geodesics calculations
                if (RBFTechnique == 1):
                    dist = distMatrixGeo[i][vertexMarkers[c]]

                #Hybrid calculations
                if (RBFTechnique == 2):
                    dist = distMatrixHybrid[i][vertexMarkers[c]]

                cmds.timer(s=True, name="RBFTimer")

                rbf = calculateGaussianRBF(dist, stiffnessValues[c])

                vDisp[i][0] += weights[c][0] * rbf
                vDisp[i][1] += weights[c][1] * rbf
                vDisp[i][2] += weights[c][2] * rbf

                RBFTime += cmds.timer(e=True, name="RBFTimer")

        #Progress control
        if cmds.progressBar(gMainProgressBar, q=True, ic=True):
            cmds.progressBar(gMainProgressBar, edit=1, ep=1)
            return

        # Apply the calculated displacement to all the vertices
        print("   Applying displacements...")

        for j in range(nVert):

            #Keyframing timer starts
            cmds.timer(s=True, name="keyframingTimer")

            #Displace the vertex
            cmds.select(mesh + ".vtx[" + str(j) + "]", r=True)
            cmds.move(vDisp[j][0],
                      vDisp[j][1],
                      vDisp[j][2],
                      r=True,
                      ls=True,
                      wd=True)

            #Set a key for the vertex
            cmds.setKeyframe(meshFullPath + "|" + mesh + "Shape.pnts[" +
                             str(j) + "]",
                             breakdown=0)
            cmds.setKeyframe(mesh + ".vtx[" + str(j) + "]",
                             breakdown=0,
                             hierarchy="none",
                             controlPoints=0,
                             shape=0)

            #Keyframing timer ends
            keyframingTime += cmds.timer(e=True, name="keyframingTimer")

        #Progress control
        progressAmount += progressStep
        if cmds.progressBar(gMainProgressBar, q=True, ic=True):
            cmds.progressBar(gMainProgressBar, edit=1, ep=1)
            return

        #Frame timer ends
        frameTime += cmds.timer(e=True, name="frameTimer")

    #Print times
    averageKeyframingTime = float(keyframingTime) / float(iterations)
    averageFrameTime = float(frameTime) / float(iterations)
    RBFTimePerFrame = float(RBFTime - RBFPrecTime) / float(iterations)

    print("")
    print("ALGORITHM: ----------------------------------")
    print("Pre-calculation time: " + str(precalcTime) + " s")
    print("Frames calculated: " + str(iterations) + " frames")
    print("Average frame time: " + str(averageFrameTime) + " s/frame")
    print("  Average keyframing time: " + str(averageKeyframingTime) +
          " s/frame")
    print("  Average algorithm time: " +
          str(averageFrameTime - averageKeyframingTime) + " s/frame")
    print("---------------------------------------------")
    print("")
    print("RBF CALCULATIONS: ---------------------------")
    print("RBF total calculation time: " + str(RBFTime) + " s")
    print("  RBF dist. calculation time: " + str(RBFPrecTime) + " s")
    print("  RBF calculation time per frame: " + str(RBFTimePerFrame) +
          " s/frame")
    print("---------------------------------------------")
    print("")

    #End progress bar
    cmds.progressBar(gMainProgressBar, edit=1, ep=1)
    return