This wiki is intended for older versions of Motive. For the latest documentation, please refer to

Motive Batch Processor


The Motive Batch Processor is a windows application that applies a function, in the form of an IronPython or C# script file, to a set of selected take files. The Batch Processor include some example script files but, in general, you must write your own. Scripts make use of the NMotive .NET class library. Note that you can also use the NMotive classes to write .NET programs and IronPython scripts that run outside of the Batch Processor. The NMotive assembly installed in the Global Assembly Cache and also located in the assemblies sub-directory of the Motive install directory. For example, the default location for the assembly included in the 64-bit Motive installer is:

C:\Program Files\OptiTrack\Motive\assemblies\x64.

A class reference in Microsoft compiled HTML format can be found in the Help sum-directory of the the Motive install directory. For example the default location for the help file is (64-bit Motive installer): C:\Program Files\OptiTrack\Motive\Help\NMotiveAPI.chm

C# Scripts

Motive Batch Processor can run C# and IronPython scripts. Here we describe the C# script format and give an example.

C# Script Format

A valid Batch Processor C# script file must contain a single class implementing the ItakeProcessingScript interface. This interface defines a single function:

Result ProcessTake( Take t, ProgressIndicator progress ). Result, Take, and ProgressIndicator are all classes defined in the NMotive namespace. The Take object t is an instance of the NMotive Take class. It is the take being processed. The progress object is an instance of the NMotive ProgressIndicator and allows the script to update the Batch Processor UI with progress and messages. The general format of a Batch Processor C# script is:

  using NMotive;
  // any other using statements
  public class MyCSharpScript : ITakeProcessingScript
     public Result ProcessTake(Take t, ProgressIndicator progress)
        Result scriptResult;
        // Script processing code here
        progress.SetMessage(“Done processing take “ + t.Name);
        progress.SetProgress( 100 );
        return scriptResult;

C# Example

The following is an example of a C# Batch Processor script that exports a take to C3D format. using System; using NMotive; using System.IO;

public class C3DExportScript : ItakeProcessingScript {

  public Result ProcessTake(Take t, ProgressIndicator progress)
     // Create the name of the C3D file. The name will be the same as the 
     // take file name, but with a .c3d extension.
     string c3dFileName =   
        Path.GetFullPath(Path.GetFileNameWithoutExtension(t.FileName) + ".c3d");
     // Create the C3D exporter object (from the NMotive class library)
     // and ensure that the exported 3D data uses MotionBuilder 
     // compatible axes.
     C3DExporter exporter = new C3DExporter();
     // Finally perform the export and return the result of the result of the 
     // export. The last argument to the Export function is a bool indicating
     // whether or not we wish to overwrite any existing file. True means
     // overwrite it if it already exists.
     Result exportResult = exporter.Export(t, c3dFileName, true);
     return exportResult;

} Note that your C# script file must have a '.cs' extension.

IronPython Scripts

IronPython is an implementation of the Python programming language that can use the .NET libraries and Python libraries. The batch processor can execute valid IronPython scripts in addition to C# scripts.

IronPython Script Format

Your IronPython script file must import the clr module and reference the NMotive assembly. In addition, it must contain the following function -

  def  ProcessTake(Take t, ProgressIndicator progress) 
  The following illustrates a typical IronPython script format.
  #import sys and clr modules
  import sys
  import clr
  # Add a reference to the NMotive assembly
  # Import everything from sys and NMotive.
  from System import *
  from NMotive import *
  # Define the ProcessTake function.
  def ProcessTake(take, progress):
     # Take processing code here
     # return result object

IronPython Script Example

The following is an example IronPython Batch Processor script that first performs a trim tails operation followed by a filtering/smoothing operation. If both operations succeed, the resulting take is saved.

  import sys
  import clr
  # Add a reference to the NMotive assembly
  # Import everything from System and NMotive.
  from System import *
  from NMotive import *
  # Define out ProcessTake function
  def ProcessTake(take, progress):
     # Messages set with the ProgressIndicator SetMessage
     # function appear on the batch processor UI below the
     # status bar.
     progress.SetMessage('Triming tails...')
     # Create an NMotive TrimTails object, set desired
     # properties and apply the trimming operation by
     # invoking the Process function.
     tailTrimming = TrimTails()
     tailTrimming.Automatic = True
     tailTrimming.LeadingTrimSize = 4
     tailTrimming.TrailingTrimSize = 4
     trimResult = tailTrimming.Process(take)
     # If the trimming operation did not succeed we
     # do not continue with filtering and saving the
     # take file. We just exit the function by returning
     # the result of the trimming operation.
     if not trimResult.Success:
        return trimResult
     # Now apply the filter.
     filtering = Filter()
     filtering.CutOffFrequency = 8 # Hz
     filteringResult = filtering.Process(take)
     # If filtering fails do not save the take. Just return.
     if not filteringResult.Success:
        return filteringResult
     # trimming and filtering operations are successful. Save
     # the take file and return the result of the file save.
     fileSaveResult = take.Save()
     if fileSaveResult != FileResult.ResultOK:
        return Result(false, 'File save failed')
     return Result(true, )