Overview

The Motive API allows control of, and access to, the backend software platform of Motive via C/C++ interface. In other words, the Motive API offers Motive functions without the graphical user interface on top. Using the API, you can employ several features of Motive in your custom applications, such as accessing 2D camera images, marker centroid data, unlabeled 3D points, labeled markers, and Rigid Body tracking data. When you install Motive, all of the required components for utilizing the API are installed within the Motive install directory. The key files for using the Motive API are listed in the below section.

What it offers:

• Camera control

• Frame control

• Point Cloud reconstruction engine control

• Obtain and use reconstructed 3D Marker data

• Rigid body tracking

• Query results

• Stream results over the network

What it doesn't offer

• In-depth hardware control (e.g. hardware sync customization). Use the Camera SDK instead.

• Direct support for data recording and playback.

• Control over peripheral devices (Force plates and NI-DAQ)

• Functionalities for Skeleton assets.

Requirements

• The Motive API is supported in Windows only

• Must have a valid Motive license and a corresponding Hardware key.

Files List

When you install Motive, all of the required components of the Motive API will be placed within the installation directory, and by default, Motive is installed in C:\Program Files\OptiTrack\Motive. The following table lists all of the key files of the API and where they could be found.

API Guide / Function Reference

Quick Start Guide: Motive API

This guide introduces some of the commonly used functions of the Motive API.

Motive API Function Reference

The following page provides a full list of the Motive API functions.

NPRESULT & VIDEO TYPES

Many of the Motive API functions return their results as integer values defined NPRESULT. This value expresses the outcome of the result. Not only it indicates whether the function operated successfully or not, but it also provides more detailed information on what type of error has occurred. When you get the NPRESULT output from a function, you can use the TT_GetResultString function to get the plain text result that corresponds to the error message.

const char		*TT_GetResultString( NPRESULT result ); // Returns text of detail information on the result.

Also, camera video types, or image processing modes, are expressed as integer values as well. These values are listed below and are commented within the header file as well.

NPRESULT Values

#define 	NPRESULT_SUCCESS     		0
#define 	NPRESULT_FILENOTFOUND           1
#define 	NPRESULT_LOADFAILED		2
#define 	NPRESULT_FAILED			3
#define 	NPRESULT_INVALIDFILE		8
#define 	NPRESULT_INVALIDCALFILE		9
#define 	NPRESULT_UNABLETOINITIALIZE	10
#define 	NPRESULT_INVALIDLICENSE		11
#define 	NPRESULT_NOFRAMEAVAILABLE	14
#define 	NPRESULT_DEVICESINUSE		15

Camera Video Type Definitions

#define 	NPVIDEOTYPE_SEGMENT	0
#define 	NPVIDEOTYPE_GRAYSCALE	1
#define 	NPVIDEOTYPE_OBJECT	2
#define 	NPVIDEOTYPE_PRECISION	4
#define 	NPVIDEOTYPE_MJPEG	6
#define 	NPVIDEOTYPE_VIDEO	9

This guide provides detailed instructions on commonly used functions of the Motive API for developing custom applications. For a full list of the functions, refer to the Motive API: Function Reference page. Also, for a sample use case of the API functions, please check out the provided marker project. In this guide, the following topics will be covered:

• Library files and header files

• Initialization and shutdown

• Capture setup (Calibration)

• Configuring camera settings

• Updating captured frames

• 3D marker tracking

• Rigid body tracking

• Data streaming

Environment Setup

Library Files

When developing a Motive API project, make sure its linker knows where to find the required library files. This can be done either by specifying its location within the project or by copying these files onto the project folder.

MotiveAPI.h

Motive API libraries (.lib and .dll) are located in the lib folder within the Motive install directory; which is located at C:\Program Files\OptiTrack\Motive\lib by default. In this folder, library files for both 64-bit (MotiveAPI.dll and MotiveAPI.lib) platforms can be found. When using the API library, all of the required DLL files must be located in the executable directory. Copy and paste the MotiveAPI.dll file onto the folder alongside the executable file.

Third-party Libraries

• Additional third-party libraries are required for Motive API, and most of the DLL files for these libraries can be found in the Motive install directory C:\Program Files\OptiTrack\Motive\. You can simply copy and paste all of the DLL files from the Motive installation directory into the directory of the Motive API project to use them. Highlighted items in the below image are the required DLL files.

• Lastly, copy the C:\Program Files\OptiTrack\Motive\plugins\platforms folder and its contents into the EXE as well since the libraries contained in this folder will also be used.

Header Files

For function declarations, there are two required header files: MotiveAPI.h and RigidBodySettings.h, and these files are located in the C:\Program Files\OptiTrack\Motive\inc\ folder. Always include the directive syntax for adding the MotiveAPI.h header file for all programs that are developed against the Motive API. The syntax for including RigidBodySetting.h file is already included in the MotiveAPI.h file, so there is no need to include this separately.

#include    "MotiveAPI.h"

• The MotiveAPI.h file contains the declaration for most of the functions and classes in the API.

• The RigidBodySettings.h file contains declaration for the cRigidBodySettings class, which is used for configuring Rigid Body asset properties.

Note: You could define these directories by using the MOTIVEAPI_INC, MOTIVEAPI_LIB environment variables. Check the project properties (Visual Studio) of the provided marker project for a sample project configuration.

Motive Files

Motive API, by default, loads the default calibration (CAL) and Application profile (MOTIVE) files from the program data directory unless separately specified. These are the files that Motive also loads at the application startup, and they are located in the following folder:

• Default System Calibration: C:\ProgramData\OptiTrack\Motive\System Calibration.cal

• Default Application Profile: C:\ProgramData\OptiTrack\MotiveProfile.motive

If there are specific files that need to be loaded into the project, you can export and import two files from Motive: motive application profile (MOTIVE) and camera calibration (CAL). The application profile is imported in order to obtain software settings and trackable asset definitions. Only after the camera calibration is imported, reliable 3D tracking data can be obtained. Application profiles can be loaded using the TT_LoadProfile function, and the calibration files can be loaded using the TT_LoadCalibration function.

Initialization and Shutdown

When using the API, connected devices and the Motive API library need to be properly initialized at the beginning of a program and closed down at the end. The following section covers Motive API functions for initializing and closing down devices.

Initialization

To initialize all of the connected cameras, call the TT_Initialize function. This function initializes the API library and gets the cameras ready for capturing data, so always call this function at the beginning of a program. If you attempt to use the API functions without the initialization, you will get an error.

// Initializing all connected cameras
TT_Initialize();

Update

The TT_Update function is primarily used for updating captured frames, which will be covered later, but there is another use. The TT_Update can also be called to update a list of connected devices, and you can call this function after the initialization to make sure all of the newly connected devices are properly initialized in the beginning.

// Initializing all connected cameras
TT_Initialize();

//Update for newly arrive cameras
TT_Update();

Shutdown

When exiting out of a program, make sure to call the TT_Shutdown function to completely release and close down all of the connected devices. Cameras may fail to shut down completely when this function is not called.

// Closing down all of the connected cameras
TT_Shutdown();
return 0;

Setup the Project

Motive Application Profile

The Motive application profile (MOTIVE) stores all the trackable assets involved in a capture and software configurations including application settings and data streaming settings. When using the API, it is strongly recommended to first configure all of the settings and define trackable assets in Motive, export a profile MOTIVE file, and then load the file by calling the TT_LoadProfile function. This way, you can adjust the settings for your need in advance and apply them to your program without worrying about configuring individual settings.

TT_LoadProfile("UserProfile.motive"); 	// Loading application profile, UserProfile.motive

Camera Calibration

Cameras must be calibrated in order to track in 3D space. However, since camera calibration is a complex process, and because of this, it's easier to have the camera system calibrated from Motive, export the camera calibration file (CAL), and the exported file can be loaded into custom applications that are developed against the API. Once the calibration data is loaded, the 3D tracking functions can be used. For detailed instructions on camera calibration in Motive, please read through the Calibration page.

TT_LoadCalibration("CameraCal.cal"); 	// Loading CAL file

Loading Calibration

1. Open Motive.

2. [Motive] Calibrate: Calibrate camera system using the Calibration panel. Read through the Calibration page for details.

3. [Motive] Export: After the system has been calibrated, export the calibration file (CAL) from Motive.

4. Close out of Motive.

5. [API] Load: Import calibration onto your custom application by calling the TT_LoadCalibration function to import CAL files.

6. When successfully loaded, you will be able to obtain 3D tracking data using the API functions.

Camera Settings

Connected cameras are accessible by index numbers. The camera indexes are assigned in the order the cameras are initialized. Most of the API functions for controlling cameras require an index value. When processing all of the cameras, use the TT_CameraCount function to obtain the total camera count and process each camera within a loop. For pointing to a specific camera, you can use the TT_CameraID or TT_CameraName functions to check and use the camera with given its index value. This section covers Motive API functions for checking and configuring camera frame rate, camera video type, camera exposure, pixel brightness threshold, and IR illumination intensity.

Fetching Camera Settings

The following functions return integer values for the configured settings of a camera specified by its index number. Camera video type is returned as an integer value that represents a image processing mode, as listed in the NPVIDEOTYPE.

These camera settings are equivalent to the settings that are listed in the Devices pane of Motive. For more information on each of the camera settings, refer to the Devices pane page.

TT_CameraVideoType(int cameraIndex)      // Returns Video Type
TT_CameraExposure (int cameraIndex)      // Returns Camera Exposure
TT_CameraThreshold(int cameraIndex)      // Returns Pixel Threshold
TT_CameraIntensity(int cameraIndex)      // Returns IR Illumination Intensity
TT_CameraFrameRate(int cameraIndex)      // Returns Camera Frame Rate

Configuring Settings

Now that we have covered functions for obtaining configured settings, now let's modify some of them. There are two main functions for adjusting the camera settings: TT_SetCameraSettings and TT_SetCameraFramerate. The TT_SetCameraSettings function configures video type, exposure, threshold, and intensity settings of a camera which is specified by its index number. The TT_SetCameraFrameRate is used for configuring frame rate of a camera. Supported frame rate range may vary for different camera models. Check the device specifications and apply the frame rates only within the supported range.

TT_SetCameraSettings(int cameraIndex, int videoType, int exposure, int threshold, int intensity);

TT_SetCameraFrameRate(int cameraIndex, int framerate);

If you wish to keep part of the current camera settings, you can use the above functions to obtain the configured settings (e.g. TT_CameraVideoType, TT_CameraFrameRate, TT_CameraExposure, etc.) and use them as input arguments for the TT_SetCameraSettings function. The following example demonstrates modifying frame rate and IR illumination intensity for all of the cameras, while keeping the other settings constant.

//== Changing exposure and threshold settings for all of the cameras ==//
int cameraCount = TT_CameraCount();
int intensity = 10;
int framerate = 100;

for (int i = 0; i < cameraCount; i++)
{
	TT_SetCameraSettings(i, TT_CameraVideoType(i), TT_CameraExposure(i),
					TT_CameraThreshold(i), intensity);

	TT_SetCameraFrameRate(i, framerate);

	//== Outputting the Settings ==//
	printf("Camera #%d:\n", i);
	printf("\tFPS: %d\n\tIntensity: %d\n\tExposure: %d\n\tIntensity: %d\n\tVideo Type:%d\n", 
			TT_CameraFrameRate(i), TT_CameraIntensity(i), TT_CameraExposure(i), 
			TT_CameraIntensity(i),TT_CameraVideoType(i));
}

Camera Setting Ranges

Camera Settings

• Valid frame rate values: Varies depending on camera models, refer to the respective hardware specifications.

• Valid exposure values: Depends on camera model and frame rate settings.

• Valid threshold values: 0 - 255

• Valid intensity values: 0 - 15

Video Types

• Video Type: see the Data Recording page for more information on image processing modes.

• Segment Mode: 0

• Grayscale Mode: 1

• Object Mode: 2

• Precision Mode: 4

• MJPEG Mode: 6

Other Settings

There are other camera settings, such as imager gain, that can be configured using the Motive API. Please refer to the Motive API: Function Reference page for descriptions on other functions.

Updating the frames

In order to process multiple consecutive frames, you must update the camera frames using the following API functions: TT_Update or TT_UpdateSingleFrame. Call one of the two functions repeatedly within a loop to process all of the incoming frames. In the 'marker sample', TT_Update function is called within a while loop as the frameCounter variable is incremented, as shown in the example below.

// marker.cpp sample project

int main()
{
        TT_Initialize();
	int frameCounter = 0; // Frame counter variable
 	while (!_kbhit())
	{
		if(TT_Update() == NPRESULT_SUCCESS)
		{
			// Each time the TT_Update function successfully updates the frame,
			// the frame counter is incremented, and the new frame is processed.
			frameCounter++;

			////// PROCESS NEW FRAME //////
		}
	}
}

TT_Update() vs. TT_UpdateSingleFrame()

There are two functions for updating the camera frames: TT_Update and TT_UpdateSingleFrame. At the most fundamental level, these two functions both update the incoming camera frames. However, they may act differently in certain situations. When a client application stalls momentarily, it could get behind on updating the frames and the unprocessed frames may be accumulated. In this situation, each of these two functions will behave differently.

• The TT_Update() function will disregard accumulated frames and service only the most recent frame data, but it also means that the client application will not be processing the previously missed frames.

• The TT_UpdateSingleFrame() function ensures that only one frame is processed each time the function is called. However, when there are significant stalls in the program, using this function may result in accumulated processing latency.

In general, a user should always use TT_Update(). Only in the case where a user wants to ensure their client application has access to every frame of tracking data and they are having problems calling TT_Update() in a timely fashion, should they consider using TT_UpdateSingleFrame(). If it is important for your program to obtain and process every single frame, use the TT_UpdateSingleFrame() function for updating the data.

TT_Update() 		// Process all outstanding frames of data.

TT_UpdateSingleFrame() // Process one outstanding frame of data.

3D Marker Tracking

After loading valid camera calibration, you can use the API functions to track retroreflective markers and get their 3D coordinates. The following section demonstrates using the API functions for obtaining the 3D coordinates. Since marker data is obtained for each frame, always call the TT_Update, or the TT_UpdateSingleFrame, function each time newly captured frames are received.

Marker Index

In a given frame, each reconstructed marker is assigned a marker index number. These marker indexes are used for pointing to a particular reconstruction within a frame. You can also use the TT_FrameMarkerCount function to obtain the total marker count and use this value within a loop to process all of the reconstructed markers. Marker index values may vary between different frames, but unique identifiers will always remain the same. Use the TT_FrameMarkerLabel function to obtain the individual marker labels if you wish to access same reconstructions for multiple frames.

int totalMarker = TT_FrameMarkerCount();
printf("Frame #%d: (Markers: %d)\n", framecounter, totalMarker);

//== Use a loop to access every marker in the frame ==//
for (int i = 0 ; i < totalMarker; i++) {
        printf("\tMarker #%d:\t(%.2f,\t%.2f,\t%.2f)\n\n", 
		i, TT_FrameMarkerX(i), TT_FrameMarkerY(i), TT_FrameMarkerZ(i));
}

Marker Position

For obtaining 3D position of a reconstructed marker, you can use TT_FrameMarkerX, TT_FrameMarkerY, and TT_FrameMarkerZ functions. These functions return 3D coordinates (X/Y/Z) of a marker in respect to the global coordinate system, which was defined during the calibration process. You can further analyze 3D movements directly from the reconstructed 3D marker positions, or you can create a Rigid Body asset from a set of tracked reconstructions for 6 Degrees of Freedom tracking data. Rigid body tracking via the API will be explained in the later section.

int totalMarker = TT_FrameMarkerCount();
printf("Frame #%d: (Markers: %d)\n", framecounter, totalMarker);

//== Use a loop to access every marker in the frame ==//
for (int i = 0 ; i < totalMarker; i++) {
        printf("\tMarker #%d:\t(%.2f,\t%.2f,\t%.2f)\n\n", 
		i, TT_FrameMarkerX(i), TT_FrameMarkerY(i), TT_FrameMarkerZ(i));
}

Rigid Body Tracking

For tracking 6 degrees of freedom (DoF) movement of a Rigid Body, a corresponding Rigid Body (RB) asset must be defined. A RB asset is created from a set of reflective markers attached to a rigid object which is assumed to be undeformable. There are two main approaches for obtaining RB assets when using Motive API; you can either import existing Rigid Body data or you can define new Rigid Bodies using the TT_CreateRigidBody function. Once RB assets are defined in the project, Rigid Body tracking functions can be used to obtain the 6 DoF tracking data. This section covers sample instructions for tracking Rigid Bodies using the Motive API.

Importing Rigid Body Assets

Let's go through importing RB assets into a client application using the API. In Motive, Rigid Body assets can be created from three or more reconstructed markers, and all of the created assets can be exported out into either application profile (MOTIVE) or a Motive Rigid Body file (TRA). Each Rigid Body asset saves marker arrangements when it was first created. As long as the marker locations remain the same, you can use saved asset definitions for tracking respective objects.

Exporting all RB assets from Motive:

• Exporting application profile: File → Save Profile

• Exporting Rigid Body file (TRA): File → Export Rigid Bodies (TRA)

Exporting individual RB asset:

• Exporting Rigid Body file (TRA): Under the Assets pane, right-click on a RB asset and click Export Rigid Body

When using the API, you can load exported assets by calling the TT_LoadProfile function for application profiles and the TT_LoadRigidBodies or TT_AddRigidBodes function for TRA files. When importing TRA files, the TT_LoadRigidBodies function will entirely replace the existing Rigid Bodies with the list of assets from the loaded TRA file. On the other hand, TT_AddRigidBodes will add the loaded assets onto the existing list while keeping the existing assets. Once Rigid Body assets are imported into the application, the API functions can be used to configure and access the Rigid Body assets.

TT_LoadProfile("UserProfile.motive"); 	// Loading application profile

TT_LoadRigidBodies("rbfile.tra"); 	// Loading TRA file
TT_AddRigidBodies("rbfile.tra"); 

Creating New Rigid Body Assets

Rigid body assets can also be defined directly using the API. The TT_CreateRigidBody function defines a new Rigid Body from given 3D coordinates. This function takes in an array float values which represent x/y/z coordinates or multiple markers in respect to Rigid Body pivot point. The float array for multiple markers should be listed as following: {x1, y1, z1, x2, y2, z2, …, xN, yN, zN}. You can manually enter the coordinate values or use the TT_FrameMarkerX, TT_FrameMarkerY, and TT_FrameMarkerZ functions to input 3D coordinates of tracked markers.

When using the TT_FrameMarkerX/Y/Z functions, you need to keep in mind that these locations are taken in respect to the RB pivot point. To set the pivot point at the center of created Rigid Body, you will need to first compute pivot point location, and subtract its coordinates from the 3D coordinates of the markers obtained by the TT_FrameMarkerX/Y/Z functions. This process is shown in the following example.

NPRESULT		TT_CreateRigidBody(const char* name, int userDataID, int markerCount, float *markerList);

Example: Creating RB Assets

int markerCount = TT_FrameMarkerCount;
vector<float> markerListRelativeToGlobal(3*markerCount);

// add markers to markerListRelativeToGlobal using TT_FrameMarkerX, etc
for (int i = 0; i < markerCount; ++i)
{
    	markerListRelativeToGlobal.push_back(TT_FrameMarkerX(i));
    	markerListRelativeToGlobal.push_back(TT_FrameMarkerY(i));
	markerListRelativeToGlobal.push_back(TT_FrameMarkerZ(i));
}

// then average the locations in x, y and z
for (int i = 0; i < markerCount; ++i)
{
    	float sx += markerListRelativeToGlobal[3*i];
    	float sy += markerListRelativeToGlobal[3*i + 1];
    	float sz += markerListRelativeToGlobal[3*i + 2];
}


float ax = sx/markerCount;
float ay = sy/markerCount;
float az = sz/markerCount;
vector<float> pivotPoint = {ax, ay, az};
vector<float> markerListRelativeToPivotPoint(3*markerCount);

// subtract the pivot point location from the marker location
for (int i = 0; i < markerCount; ++i)
{
    markerListRelativeToPivotPoint.push_back(markerListRelativeToGlobal[3*i] - ax);
    markerListRelativeToPivotPoint.push_back(markerListRelativeToGlobal[3*i + 1] - ay);
    markerListRelativeToPivotPoint.push_back(markerListRelativeToGlobal[3*i + 2] - az);
}

TT_CreateRigidBody("Rigid Body New", 1, markerCount, markerListRelativeToPivotPoint);

Rigid Body 6 DoF Tracking Data

6 DoF Rigid Body tracking data can be obtained using the TT_RigidBodyLocation function. Using this function, you can save 3D position and orientation of a Rigid Body into declared variables. The saved position values indicate location of the Rigid Body pivot point, and they are represented in respect to the global coordinate axis. The Orientation is saved in both Euler and Quaternion orientation representations.

void	TT_RigidBodyLocation(int rbIndex, 				//== RigidBody Index
			float *x, float *y, float *z, 			//== Position
			float *qx, float *qy, float *qz, float *qw, 	//== Quaternion
			float *yaw, float *pitch, float *roll);   	//== Euler

Example: RB Tracking Data

//== Declared variables ==//
float	x, y, z;
float 	qx, qy, qz, qw;
float	yaw, pitch, roll;
int rbcount = TT_RigidBodyCount();

for(int i = 0; i < rbcount; i++)
{
	//== Obtaining/Saving the Rigid Body position and orientation ==//
	TT_RigidBodyLocation( i, &x, &y, &z, &qx, & qy, &qz, &qw, &yaw, &pitch, &roll );
	
	if( TT_IsRigidBodyTracked( i ) )
	{
		printf( "%s: Pos (%.3f, %.3f, %.3f) Orient (%.1f, %.1f, %.1f)\n", 
					TT_RigidBodyName( i ), x, y, z, yaw, pitch, roll );
	}
}

Rigid Body Properties

In Motive, Rigid Body assets have Rigid Body properties assigned to each of them. Depending on how these properties are configured, display and tracking behavior of corresponding Rigid Bodies may vary. When using the API, Rigid Body properties are configured and applied using the cRigidBodySettings class which is declared within the RigidBodySetting.h header file.

Within your program, create an instance of cRigidBodySettings class and call the API functions to obtain and adjust Rigid Body properties. Once desired changes are made, use the TT_SetRigidBodySettings function to assign the properties back onto a Rigid Body asset.

For detailed information on individual Rigid Body settings, read through the Properties: Rigid Body page.

NPRESULT	TT_RigidBodySettings(int rbIndex, RigidBodySolver::cRigidBodySettings &settings);

NPRESULT	TT_SetRigidBodySettings(int rbIndex, RigidBodySolver::cRigidBodySettings &settings);

Data Streaming

Once the API has been successfully initialized, data streaming can be enabled, or disabled, by calling either the TT_StreamNP, TT_StreamTrackd, or TT_StreamVRPN function. The TT_StreamNP function enables/disables data streaming via the NatNet. The NatNet SDK is a client/server networking SDK designed for sending and receiving NaturalPoint data across networks, and tracking data from the API can be streamed to client applications from various platforms via the NatNet protocol. Once the data streaming is enabled, connect the NatNet client application to the server IP address to start receiving the data.

TT_StreamNP(true);	//Enabling NatNet Streaming.

The TT_StreamNP function is equivalent to Broadcast Frame Data from the Data Streaming pane in Motive.

Data Streaming Settings

The Motive API does not currently support configuring data streaming settings directly from the API. To configure the streaming server IP address and the data streaming settings, you will need to use Motive and save an application profile MOTIVE file that contains the desired configuration. Then, the exported profile can be loaded when using the API. Through this way, you will be able to set the interface IP address and decide which data to be streamed over the network.

For more information on data streaming settings, read through the Data Streaming page.

This page provides a sample and instructions on how to use Motive API functions to calibrate a camera system.

Sample Code

The following sample code demonstrates calibration process using the Motive API. For details on specific functions, please refer to the Motive API: Function Reference page.

Masking

Auto-Masking

Auto-Masking is done directly by calling the TT_AutoMaskAllCameras function. When this is called, Motive will sample for a short amount of time and apply a mask to the camera imagers where light was detected.

<source> //== To auto-mask, call TT_AutoMaskAllCameras().

TT_AutoMaskAllCameras(); printf( "============\nCamera masking started\n============\n" ); </source>

Camera Mask

This function returns memory block of the mask. One bit per a pixel of the mask. Masking pixels are rasterized from left to right and from top to bottom of the camera's view.

Clear Masks

This function can clear existing masks from the 2D camera view. It returns true when it successfully removes pixel masks. Otherwise, masking is always additive through the API.

Set Camera Mask

The TT_SetCameraMask can be used to replace the existing camera mask for any camera. A mask is an array of bytes, one byte per mask pixel block. Returns true when masks are applied.

Wanding

//== NaturalPoint Motive API Calibration Sample Application ==

include <windows.h>
include <conio.h>
include <stdio.h>
include <stdlib.h>
include <math.h>
include <string>
include "NPTrackingTools.h"
// Local function prototypes void CheckResult( NPRESULT result );

std::string CalibrationStateString( TT_CameraCalibrationStates state ) {
switch( state )
   {
       case TT_CameraCalibration_Initialized:   return "Init    ";
       case TT_CameraCalibration_Sampling:      return "Sampling";
       case TT_CameraCalibration_Solving:       return "Solving ";
       case TT_CameraCalibration_Complete:      return "Complete";
       case TT_CameraCalibration_Uninitialized: break;
       default: break;
   }
   return "Unknown ";
}
// Main application int main( int argc, char* argv[] ) {
  printf( "== NaturalPoint Motive API Calibration Sample Application =======---\n" );
   printf( "== (C) NaturalPoint, Inc.\n\n" );
    printf( "Initializing NaturalPoint Devices\n" );
   
   if( TT_Initialize() != NPRESULT_SUCCESS )
   {
       printf( "Unable to license Motive API\n" );
       return 1;
   }
   // Do an update to pick up any recently-arrived cameras.
   TT_Update();
    // List all detected cameras.
   printf( "Cameras:\n" );
   for( int i = 0; i < TT_CameraCount(); i++)
   {
       printf( "\t%s\n", TT_CameraName(i) );
   }
   printf("\n");
   //== lets set our wand settings ==--
   cCameraCalibrationSettings settings;
   settings.WandLength       = 0.250;  // wand length        = 250mm
   settings.WandCenterOffset = 0.0875; // wand center offset = 87.5mm
    if( TT_SetCalibrationSettings( settings ) != NPRESULT_SUCCESS )
   {
       printf( "Unable to set camera calibration settings.\n\n" );
   }
     if( TT_CalibrationSettings( settings ) == NPRESULT_SUCCESS )
   {
       //== fetch & print default wand settings ==--
        printf( "Wand Length        = %.1fmm\n", settings.WandLength * 1000 );
       printf( "Wand Center Offset = %.1fmm\n", settings.WandCenterOffset * 1000 );
   }
   else
   {
       printf( "Unable to fetch camera calibration settings.\n\n" );
   }
   printf( "\n" );
   printf( "Press 1: Start Wanding\n" );
   printf( "Press 2: Start Calculation\n" );
   printf( "Press 3: Apply Calibration\n" );
   printf( "Press 4: Reset\n" );
   printf( "\n" );
  int frameCounter = 0;
   
   bool done = false;
   while( !done )
   {
       if( _kbhit() )
       {
           char c = _getch();
         if( c == '1' )
           {
               printf( "Start Wanding: " );
               if( TT_StartCalibrationWanding() )
               {
                   printf( "Success\n" );
               }
               else
               {
                   printf( "Failed\n" );
               }
           }
           if( c == '2' )
           {
               printf( "Start Solving: " );
               if( TT_CameraCalibrationSolve() )
               {
                   printf( "Success\n" );
               }
               else
               {
                   printf( "Failed\n" );
               }
           }
           if( c == '3' )
           {
               printf( "Apply Calibration: " );
               if( TT_CameraCalibrationApplyResult() )
               {
                   printf( "Success\n" );
               }
               else
               {
                   printf( "Failed\n" );
               }
               }
           if( c == '4' )
           {
               printf( "Reset Calibration: " );
               if( TT_CameraCalibrationReset() )
               {
                   printf( "Success\n" );
               }
               else
               {
                   printf( "Failed\n" );
               }
           }
       }
       if( TT_Update() == NPRESULT_SUCCESS )
       {
           frameCounter++;
       if( (frameCounter%100) == 0 )
           {
 //== every 100 frames print ongoing sample and calibration state information ==--
   printf( "Frame[%5d] Markers[%3d] Calibration State[%s] ", frameCounter, TT_FrameMarkerCount(), CalibrationStateString( TT_CalibrationState()).c_str() );
       if( TT_CalibrationState() == TT_CameraCalibration_Sampling )
               {
                   for( int index = 0; index < TT_CameraCount(); index++ )
                   {
                       printf( "%d ", TT_CameraCalibrationSamples( index ) );
                   }
                   printf( "\n\nWand Location\n" );
                   printf( "-----------------------\n" );
                   float points[ 6 ];
                   for( int index = 0; index < TT_CameraCount(); index++ )
                   {
                       bool wandPresent = TT_CameraWandLocation( index, points );
                       printf( "Camera #%d: ", index );
                       if( wandPresent )
                       {
                           printf( "[Present    ] " );
                           for( int pointIndex = 0; pointIndex < 6; pointIndex += 2 )
                           {
                               printf( "%.1f,%.1f ", points[ pointIndex ], points[ pointIndex + 1 ] );
                           }
                       }
                       else
                       {
                           printf( "[Not Present] " );
                       }
                       printf( "\n" );
                   }
                   printf( "\n" );
               }
               printf( "\n" );
           }
       }
       Sleep(2);
   }
   printf( "Shutting down NaturalPoint Motive API\n" );
   CheckResult( TT_Shutdown() );
   printf( "Complete\n" );
   while( !_kbhit() )
   {
       Sleep(20);
   }
   return 0;
 }
 
 void CheckResult( NPRESULT result ) //== CheckResult function will display errors and ---

                                     //== exit application after a key is pressed =====---
{

   if( result!= NPRESULT_SUCCESS)
   {
       // Treat all errors as failure conditions.
       printf( "Error: %s\n\n(Press any key to continue)\n", TT_GetResultString(result) );
       Sleep(20);
       exit(1);
   }
} 

Ground Plane

Setting ground plane is done directly by calling the TT_SetGroundPlane function. When this is called, camera system will search for 3-markers that resemble a calibration square and uses the inputted vertical offset value to configure the ground plane.

//== To apply ground plane, call TT_SetGroundPlane(). Specify the vertical offset from the marker centers in meters.
TTAPI bool TT_SetGroundPlane( float verticalOffset ); 

Please use the table of contents to the right to navigate to specific functions or specific group of functions.

Project Management

TT_Initialize

Initializes the API and prepares all connected devices for capturing. Please note that TT_Initialize also loads the default profile from the ProgramData directory: C:\ProgramData\OptiTrack\MotiveProfile.motive. When there is a need to load the profile from a separate directory, use TT_LoadProfile function.

NPRESULT		TT_Initialize();

Description

• This function initializes the API library and prepares all connected devices for capturing.

• When using the API, this function needs to be called at the beginning of a program before using the cameras.

• Returns an NPRESULT value. When the function successfully updates the data, it returns 0 (or NPRESULT_SUCCESS).

Function Input

• None

Function Output

• NPRESULT

C++ Example

// Initializing all connected cameras
TT_Initialize();

TT_Shutdown

Shuts down all of the connected devices.

Description

• This function closes down all connected devices and the camera library. To ensure that all devices properly shutdown, call this function before terminating an application.

• When the function successfully closes down the devices, it returns 0 (or NPRESULT_SUCCESS).

• When calling this function, currently configured camera calibration will be saved under the default System Calibration.cal file.

Function Input

• None

Function Output

• NPRESULT

C++ Example

// Close down all of the connected cameras
TT_Shutdown();
return 0;

TT_Update

Processes incoming frame data from the cameras.

Description

• This function updates frame information with the most recent data from the cameras and 3D processing engines.

• Another use of this function is to pick up newly connected cameras. Call this function at the beginning of a program in order to make sure that all of the new cameras are properly recognized.

• TT_Update vs. TT_UpdateSingleFrame: In the case when a client application stalls momentarily, the program may get behind on updating the frames. In this situation, the TT_Update() function will disregard accumulated frames and service only the most recent frame data, but this also means that the client application will be missing the previous frames. On the other hand, the TT_UpdateSingleFrame function ensures that always a consecutive frame is updated each time the function is called. In general, a user should always use TT_Update(). Only in the case where a user wants to ensure their client application has access to every frame of tracking data and they are having problems calling TT_Update() in a timely fashion, should they consider using TT_UpdateSingleFrame(). If it is important for your program to obtain and process every single frame, use the TT_UpdateSingleFrame() function for updating the data.

• Returns an NPRESULT integer value, depending on whether the operation was successful or not. Returns NPRESULT_SUCCESS when it successfully updates the frame data.

Function Input

• None

Function Output

• NPRESULT

C++ Example

//== Update to pick up recently-arrived cameras ==/
TT_Update();

//== Frame Processing: Polling the frame data ==//
while( programRunning ){
	if( TT_Update() == NPRESULT_SUCCESS ){
		frameNumber++;
		//== Process Frame Data ==//
	}
}

TT_UpdateSingleFrame

Updates a single frame of camera data.

NPRESULT		TT_UpdateSingleFrame();

Description

• Every time this function is called, it updates frame information with the next frame of camera data.

• Using this function ensures that every frame of data is processed.

• TT_Update() vs. TT_UpdateSingleFrame(): In the case when a client application stalls momentarily, the program may get behind on updating the frames. In this situation, the TT_Update() function will disregard accumulated frames and service only the most recent frame data, but this also means that the client application will be missing the previous frames. On the other hand, the TT_UpdateSingleFrame function ensures that always a consecutive frame is updated each time the function is called. In general, a user should always use TT_Update(). Only in the case where a user wants to ensure their client application has access to every frame of tracking data and they are having problems calling TT_Update() in a timely fashion, should they consider using TT_UpdateSingleFrame(). If it is important for your program to obtain and process every single frame, use the TT_UpdateSingleFrame() function for updating the data.

• Returns an NPRESULT value. When the function successfully updates the data, it returns 0 (or NPRESULT_SUCCESS).

Function Input

• None

Function Output

• NPRESULT

C++ Example

//== Update to pick up recently-arrived cameras ==/
TT_Update();

//== Frame Processing: Polling the frame data ==//
while( programRunning ){
	if( TT_UpdateSingleFrame() == NPRESULT_SUCCESS ){
		frameNumber++;
		//== Process Frame Data ==//
	}
}

TT_LoadCalibration, TT_LoadCalibrationW

Loads a Motive camera calibration file.

NPRESULT		TT_LoadCalibration(const char *filename);

NPRESULT		TT_LoadCalibrationW(const wchar_t *filename);

Description

• These functions load a camera calibration file (CAL).

• Camera calibration files need to be exported from Motive.

• Returns a NPRESULT integer value. If the file was successfully loaded, it returns NPRESULT_SUCCESS.

Function Input

• Filename (const char, const wchar_t)

Function Output

• NPRESULT

C++ Example

const char *calFileName= "project.ttp";
NPRESULT fileload = TT_LoadCalibration(calFileName);

if (fileload == NPRESULT_SUCCESS)
{
	printf("%s successfully loaded.\n", calFileName);
}
else
{
	printf("Error: %s\n", TT_GetResultString(fileload));
}

TT_LoadRigidBodies, TT_LoadRigidBodiesW

Imports TRA files and loads Rigid Body assets from it.

NPRESULT		TT_LoadRigidBodies(const char *filename);

NPRESULT		TT_LoadRigidBodiesW(const wchar_t *filename);

Description

• This function imports and loads Rigid Body assets from a saved TRA file.

• TRA files contain exported Rigid Body asset definitions from Motive.

• All existing assets in the project will be replaced with the Rigid Body assets from the TRA file when this function is called. If you want to keep existing assets and only wish to add new Rigid Bodies, use TT_AddRigidBodies function.

• Returns an NPRESULT integer value. It returns NPRESULT_SUCCESS when the file is successfully loaded.

Function Input

Filename (const char, const wchat_t)

Function Output

NPRESULT

C++ Example

//Loading Rigid Body Assets from a TRA file.
const char *traFile = "rigidbody.tra";
TT_LoadRigidBodies(traFile);

TT_SaveRigidBodies, TT_SaveRigidBodiesW

Saves all of the Rigid Body asset definitions into a TRA file.

NPRESULT		TT_SaveRigidBodies(const char *filename);

NPRESULT		TT_SaveRigidBodiesW(const wchar_t *filename);

Description

• This function saves all of the Rigid Body assets from the project into a TRA file.

• Attach *.tra extension at the end of the filename.

• Returns an NPRESULT integer value. It returns 0 or NPRESULT_SUCCESS when successfully saving the file.

Function Input

Filename (const char, const wchar_t)

Function Output

NPRESULT

C++ Example

//== Save Rigid Bodies ==/
TT_SaveRigidBodies("traFileName.tra");

TT_AddRigidBodies, TT_AddRigidBodiesW

Loads a TRA file and adds its Rigid Body assets onto the project.

NPRESULT		TT_AddRigidBodies(const char *filename);

NPRESULT		TT_AddRigidBodiesW(const wchar_t *filename);

Description

• This function adds Rigid Body assets from the imported TRA file onto the existing list.

• Adds Rigid Bodies from imported TRA files onto the asset list of the current project.

• Returns an NPRESULT integer value. If the Rigid Bodies have been added successfully, it returns 0 or NPRESULT_SUCCESS.

Function Input

Filename (const char, const wchat_t)

Function Output

NPRESULT

C++ Example

/== Adding Rigid Bodies ==/
TT_AddRigidBodies("rigidbody.tra");

TT_LoadProfile, TT_LoadProfileW

Loads a Motive User Profile (.MOTIVE).

NPRESULT		TT_LoadProfile(const char *filename);

NPRESULT		TT_LoadProfileW(const wchar_t *filename);

Description

• Loads the default application profile file (MOTIVE), which is located in the ProgramData directory: C:\ProgramData\OptiTrack\MotiveProfile.motive

• The MOTIVE files store software configurations as well as other software-wide settings.

• Profile files also loads trackable asset definitions. Once the application profile containing trackable assets is imported, there is no need to import TRA and SKL files separately.

• Returns an NPRESULT integer value. If the project file was successfully loaded, it returns 0 (NPRESULT_SUCCESS).

Function Input

Filename (const char, const wchar_t)

Function Output

NPRESULT

C++ Example

//== Loading application profile XML file ==/
const char *filename= "UserProfile.ttp";
NPRESULT profileLoad = TT_LoadProfile(filename);

if (profileLoad == NPRESULT_SUCCESS)
{
	printf("%s successfully loaded.\n", filename);
}
else
{
	printf("Error: %s\n", TT_GetResultString(profileLoad));
}

TT_LoadProject, TT_LoadProjectW

Loads a Motive TTP project file.

NPRESULT		TT_LoadProject(const char *filename);

NPRESULT		TT_LoadProjectW(const wchar_t *filename);

Description

• Loads a Motive TTP project file. TTP project file loads and saves both camera calibration and Rigid Body assets, so when using TTP files, there is no need to import or export CAL or TRA files separately.

• Loading a project file will import all of the required information for tracking. These include camera calibration and Rigid Body assets that are associated with a Motive project.

• Returns an NPRESULT integer value. If the project file was successfully loaded, it returns 0 (NPRESULT_SUCCESS).

Function Input

Filename (const char, const wchar_t)

Function Output

NPRESULT

C++ Example

//== Loading TTP project file ==/
const char *filename= "project.ttp";
NPRESULT ttpload = TT_LoadProject(filename);

if (ttpload == NPRESULT_SUCCESS)
{
	printf("%s successfully loaded.\n", filename);
}
else
{
	printf("Error: %s\n", TT_GetResultString(ttpload));
}

TT_SaveProfile, TT_SaveProfileW

Saves current application setting into a Profile XML file.

NPRESULT		TT_SaveProfile(const char *filename);

NPRESULT		TT_SaveProfileW(const wchar_t *filename);

Description

• This function saves the current configuration into an application Profile XML file.

• Attach *.xml extension at the end of the filename.

• Returns an NPRESULT integer value. If the profile XML file was saved successfully, it returns 0 (NPRESULT_SUCCESS).

Function Input

Filename (const char, const wchar_t)

Function Output

NPRESULT

C++ Example

//== Saving the TTP project ==/
const char *projectname = "project.ttp";
NPRESULT result = TT_SaveProfile(projectname);

if ( result == NPRESULT_SUCCESS ){
        printf("Profile XML file saved.");
}
else {
        printf("Error: %s", TT_GetResultString(result));
}

TT_SaveProject, TT_SaveProjectW

TT_LoadCalibrationFromMemory

Loads calibration from memory.

NPRESULT		TT_LoadCalibrationFromMemory(unsigned char* buffer, int bufferSize);

Description

• This function loads camera calibration from memory. In order to do this, the program must have saved calibration memory.

• It assumes the pointer argument (unsigned char*) points to a memory block where calibration data is already stored. The address and size of the calibration buffer must be determined by the developer using the API.

Function Input

• Buffer (unsigned char*)

• Size of the buffer (int)

Function Output

• NPRESULT

C++ Example

// get a pointer to the calibration block in memory
int bufferSize;
 
// get the size of the buffer
NPRESULT result = TT_LoadCalibrationFromMemory(buffer, bufferSize);

TT_CameraExtrinsicsCalibrationFromMemory

Gets camera extrinsics from a calibration file in memory.

NPRESULT		TT_CameraExtrinsicsCalibrationFromMemory(unsigned char* buffer, int bufferSize, eMotiveAPIResult& result);

Description

• This allows for acquiring camera extrinsics for cameras not connected to system.

• It simply returns the list of details for all cameras contained in the calibration file.

Function Input

• Buffer (unsigned char*)

• Size of the buffer (int)

• Result

Function Output

• NPRESULT

C++ Example

// get a pointer to the calibration block in memory
int bufferSize;

// get the size of the buffer
NPRESULT result = TT_CameraExtrinsicsCalibrationFromMemory(unsigned char* buffer, int bufferSize, eMotiveAPIResult& result);

Calibration

TT_StartCalibrationWanding

Start a new calibration wanding for all cameras.

void		TT_StartCalibrationWanding();

Description

• This will cancel any existing calibration process.

Function Input

• None

Function Output

C++ Example

TT_CalibrationState

Returns the current calibration state.

NPRESULT		TT_CalibrationState();

Description

• Returns the current calibration state.

Function Input

• None

Function Output

• NPRESULT

C++ Example

TT_CalibrationCamerasLackingSamples

During calibration wanding, this will return a vector of camera indices that are lacking the minimum number of calibration samples to begin calculation.

std::vector<int>		TT_CalibrationCamerasLackingSamples();

Description

• When the returned vector for this method goes to zero size, you can call TT_StartCalibrationCalculation() to begin calibration calculations.

• Wanding samples will continue to be collected until TT_StartCalibrationCalculation() is called.

Function Input

• None

Function Output

• Vector (int)

C++ Example

TT_CameraCalibrationSamples

During calibration wanding.

int		TT_CameraCalibrationSamples(int cameraIndex);

Description

• This will return the number of wand samples collected for the given camera.

• Return 0 otherwise.

Function Input

• Camera index (int)

Function Output

• Number of samples (int)

C++ Example

TT_CancelCalibration

Cancels wanding or calculation and resets calibration engine.

void		TT_CancelCalibration();

Description

• Cancels wanding or calculation

• Resets calibration engine

Function Input

• none

Function Output

• Exits either TT_StartCalibrationWanding() or TT_StartCalibratoinCalculation()

C++ Example

TT_StartCalibrationCalculation

Once wanding is complete, call this to begin the calibration calculations.

bool		TT_StartCalibrationCalculation();

Description

• Starts calibration calculations after wanding.

Function Input

• Boolean value

Function Output

• Starts calculation

C++ Example

TT_CurrentCalibrationQuality

During calibration calculation.

int		TT_CurrentCalibrationQuality();

Description

• This method will return the current calibration quality in the range [0-5], with 5 being best.

• Returns zero otherwise

Function Input

• none

Function Output

• Quality on scale of 0-5 (int)

C++ Example

TT_ApplyCalibrationCalculation

Run once TT_CalibrationState() returns "Complete".

bool		TT_ApplyCalibrationCalculation();

Description

• Call this method to apply the calibration results to all cameras.

Function Input

• none

Function Output

• Apply calibration results

C++ Example

TT_SetGroundPlane

Set the ground plane using a standard or custom ground plane template.

bool		TT_SetGroundPlane(bool useCustomGroundPlane);

Description

• If true then this function will use a custom ground plane.

Function Input

• Boolean value of useCustomGroundPlane

Function Output

• Either applies custom or preset ground plane to calibration.

C++ Example

TT_TranslateGroundPlane

Translate the existing ground plane (in mm).

void		TT_TranslateGroundPlane(float x, float y, float z);

Description

• Takes float variables to alter existing ground plane.

Function Input

• X, Y, and Z values (float)

Function Output

• Applies new values to existing ground plane.

C++ Example

Data Streaming

TT_StreamNP

Enables/disables the NatNet streaming of the Natrual Point tracking data.

NPRESULT		TT_StreamNP(bool enabled);

Description

• This function enables/disables NaturalPoint data stream.

• This is equivalent to the Broadcase Frame Data in the Data Streaming panel in Motive.

• Returns a NPRESULT integer value. If the operation was successful, it returns 0 (NPRESULT_SUCCESS).

Function Input

• Boolean argument enabled (true) / disabled (false)

Function Output

• NPRESULT

C++ Example

//== Enable NP Streaming ==/
TT_StreamNP(true);

TT_StreamTrackd

Enables/disables streaming frame data into trackd.

NPRESULT		TT_StreamTrackd(bool enabled);

Description

• This function enables/disables streaming data into trackd.

• Returns a NPRESULT integer value. If the operation was successful, it returns 0 (NPRESULT_SUCCESS).

Function Input

• True for enabling and false for disabling (bool)

Function Output

• NPRESULT

C++ Example

//== Enable NP Streaming ==/
TT_StreamTrackd(true);

TT_StreamVRPN

Enables/disables data stream into VRPN.

NPRESULT		TT_StreamVRPN(bool enabled, int port);

Description

• This function enables/disables data streaming into VRPN.

• To stream onto VRPN, the port address must be specified. VRPN server applications run through 3883 port, which is default port for the VRPN streaming.

• Returns an NPRESULT integer value. If streaming was successfully enabled, or disabled, it returns 0 (NPRESULT_SUCCESS).

Function Input

• True for enabling and false for disabling (bool)

• Streaming port address (int)

Function Output

• NPRESULT

C++ Example

//== Enable Streaming into VRPN ==/
TT_StreamVRPN(true);

3D Frame Data

TT_FrameMarkerCount

Gets total number of reconstruected markers in a frame.

int		TT_FrameMarkerCount();

Description

• This function returns a total number of reconstructed 3D markers detected in current capture frame.

• Use this function to count a total number of markers, access every markers, and obtain the marker index values.

Function Input

• None

Function Output

• Total number of reconstructed markers in the frame (int)

C++ Example

//Obtaining total marker count
int totalMarker = TT_FrameMarkerCount();
printf("Total number of markers: %d", totalMarker);

for (int i = 0 ; i < totalMarker; i++) {
        //== Use a loop to access every marker in the frame ==//
        printf("Marker %d (X/Y/Z): (%f, %f, %f)\n", i,
		TT_FrameMarkerX(i), TT_FrameMarkerY(i), TT_FrameMarkerZ(i));
}

TT_FrameMarkerX

Returns x-position of a reconstructed marker.

float		TT_FrameMarkerX(int markerIndex);

Description

• This function returns X coordinate of a reconstructed 3D marker in respect to the global coordinate system, in meters.

• It requires a marker index value.

Function Input

• Marker index (int)

Function Output

• X-position of the 3D marker (float)

C++ Example

int totalMarker = TT_FrameMarkerCount();
printf("Total number of markers: %d", totalMarker);

//== Outputting marker positions ==//
for (int i = 0 ; i < totalMarker; i++) {
        //== Use a loop to access every marker in the frame ==//
        printf("Marker %d (X/Y/Z): (%f, %f, %f)", i,
		TT_FrameMarkerX(i), TT_FrameMarkerY(i), TT_FrameMarkerZ(i));
}

TT_FrameMarkerY

Returns y-position of a reconstructed marker.

float		TT_FrameMarkerY(int markerIndex);

Description

• This function returns Y coordinate of a reconstructed 3D marker in respect to the global coordinate system, in meters.

• It requires a marker index value.

Function Input

• Marker index (int)

Function Output

• Y-position of the 3D marker (float)

C++ Example

int totalMarker = TT_FrameMarkerCount();
printf("Total number of markers: %d", totalMarker);

//== Outputting marker positions ==//
for (int i = 0 ; i < totalMarker; i++) {
        //== Use a loop to access every marker in the frame ==//
        printf("Marker %d (X/Y/Z): (%f, %f, %f)", i,
		TT_FrameMarkerX(i), TT_FrameMarkerY(i), TT_FrameMarkerZ(i));
}

TT_FrameMarkerZ

Returns z-position of a reconstructed marker.

float		TT_FrameMarkerZ(int markerIndex);

Description

• This function returns Z coordinate of a reconstructed 3D marker in respect to the global coordinate system, in meters.

• It requires a marker index value.

Function Input

• Marker index (int)

Function Output

• Z-position of the 3D marker (float)

C++ Example

int totalMarker = TT_FrameMarkerCount();
printf("Total number of markers: %d", totalMarker);

//== Outputting marker positions ==//
for (int i = 0 ; i < totalMarker; i++) {
        //== Use a loop to access every marker in the frame ==//
        printf("Marker %d (X/Y/Z): (%f, %f, %f)", i,
		 TT_FrameMarkerX(i), TT_FrameMarkerY(i), TT_FrameMarkerZ(i));
}

TT_FrameMarkerResidual

Returns residual value of a marker.

float		TT_FrameMarkerResidual(int markerIndex);

Description

• This function returns a residual value for a given marker indicated by the marker index.

• Unit of the returned value is in millimeters.

• The marker index value may change between frames, but the unique identifier will always remain the same.

Function Input

• Marker index (int)

Function Output

• Residual value (float)

TT_FrameMarkerLabel

Returns a unique identifier of a marker.

Core::cUID		TT_FrameMarkerLabel(int markerIndex);

Description

• This function returns a unique identifier (cUID) for a given marker.

• Markers have an index from 0 to [totalMarkers -1] for a given frame. In order to access unique identifier of any marker, it's index must be inputted.

• The marker index value may change between frames, but the unique identifier will always remain the same.

Function Input

• Marker index (int)

Function Output

• Marker label (cUID)

C++ Example

int totalMarkers = TT_FrameMarkerCount();
vector<Core::cUID> unique_Marker_ID(totalMarkers);

for (int i = 0; i < totalMarkers; ++i)
{
    unique_Marker_ID[i] = TT_FrameMarkerLabel(int markerIndex); 
}

TT_FrameTimeStamp

Returns a timestamp value for the current frame.

double		TT_FrameTimeStamp();

Description

• This function returns a timestamp value of the current frame.

Function Input

• None

Function Output

• Frame timestamp (double)

C++ Example

int frameNumber = 0;

//== Display Frame number and Time stamp ==//
while( !_kbhit() )
{
	if( !TT_Update() ){
		frameNumber++;	// increment frame number each time a frame is processed.

		printf("Frame #%d: (Timestamp: %f)\n", frameNumber, TT_FrameTimeStamp());
	}
}

TT_FrameCameraCentroid

Checks whether a camera is contributing to reconstruction of a 3D marker, and saves corresponding 2D location as detected in the camera's view.

bool		TT_FrameCameraCentroid(int markerIndex, int cameraIndex, float &x, float &y);

Description

• This function evaluates whether the specified camera (cameraIndex) is contributing to point cloud reconstruction of a 3D point (markerIndex).

• It returns true if the camera is contributing to the marker.

• After confirming that the camera contributes to the reconstruction, this function will save the 2D location of the corresponding marker centroid in respect to the camera's view.

• The 2D location is saved in the declared variable.

Function Input

• 3D reconstructed marker index (int)

• Camera index (int)

• Reference variables for saving x and y (floats).

Function Output

• True / False (bool)

C++ Example

//== Getting 2D location of marker centroids from a camera.==//
float x, y;
int targetcam = 1;
int frameMarkercount = TT_FrameMarkerCount();

for (int i = 0; i < frameMarkercount; i++) // For each detected markers
{
	bool result = TT_FrameCameraCentroid(i, targetcam, x, y)

	if (result)
	{
		printf("Marker %d location in camera #%d: %f, %f\n", i, targetcam, x, y);
	}
}

TT_FlushCameraQueues

Flushes out the camera queues.

void		TT_FlushCameraQueues();

Description

• This function flushes camera queues.

• In an event when you are tracking a very high number (hundreds) of markers and the application has accumulated data processing latency, you can call TT_FlushCameraQueues() to refresh the camera queue before calling TT_Update() for processing the frame. After calling this function, avoid calling it again until the TT_Update() function is called and NPRESULT_SUCCESS is returned.

Function Input

• None

Function Output

• Void

C++ Example

//== Flush Camera Queues to remove accumulated latency. ==//
TT_FlushCameraQueues();

//== Update the incoming camera data after. ==//
TT_Update();

Rigid Bodies

TT_IsRigidBodyTracked

Checks whether Rigid Body is tracked or not.

bool		TT_IsRigidBodyTracked(int rbIndex);

Description

• Checks whether the Rigid Body is being tracked in the current frame.

• Returns true if the Rigid Body is tracked.

Function Input

• Rigid body index (int)

Function Output

• True / False (bool)

C++ Example

int totalRB = TT_RigidBodyCount();

//== Checking if the Rigid Body is tracked or not ==//
for(int i = 0; i < totalRB)
{
	If(TT_IsRigidBodyTracked(i))
	{
		// Process Rigid Body
	}
}

TT_RigidBodyLocation

Obtains and saves 3D position, quaternion orientation, and Euler orientation of a Rigid Body

void		TT_RigidBodyLocation(int rbIndex,
			float *x, float *y, float *z,
			float *qx, float *qy, float *qz, float *qw,
			float *yaw, float *pitch, float *roll);

Description

• This function saves position and orientation of a Rigid Body. Specifically, position and orientation at the Rigid Body pivot point is obtained.

• 3D coordinates of the Rigid Body will be assigned in declared variable addresses (*x, *y, *z).

• Orientation of the Rigid Body will be saved in two different formats; Euler and quaternion rotations. Yaw, pitch, and roll values for Euler representation will be saved in the declared variable addresses (*yaw, *pitch, *roll), and qx, qy, qz, and qw values for the quaternion rotation will be saved in declared variable addresses (*qx, *qy, *qz, and *qw).

Function Input

• Rigid body index (int)

• Declared variable (float) addresses for:

  • 3D coordinates (x,y,z)

  • Quaternion Rotation (qx, qy, qz, qw)

  • Euler Rotation ( yaw, pitch, roll)

Function Output

• Void

C++ Example

//== Declared variables ==//
float	x, y, z;
float 	qx, qy, qz, qw;
float	yaw, pitch, roll;
int rbcount = TT_RigidBodyCount();

for(int i = 0; i < rbcount; i++)
{
	//== Obtaining/Saving the Rigid Body position and orientation ==//
	TT_RigidBodyLocation( i, &x, &y, &z, &qx, & qy, &qz, &qw, &yaw, &pitch, &roll );
	
	if( TT_IsRigidBodyTracked( i ) )
	{
		printf( "%s: Pos (%.3f, %.3f, %.3f) Orient (%.1f, %.1f, %.1f)\n", 
					TT_RigidBodyName( i ), x, y, z, yaw, pitch, roll );
	}
}

TT_ClearRigidBodyList

Clears and removes all Rigid Body assets.

void		TT_ClearRigidBodyList();

Description

• This function clears all of existing Rigid Body assets in the project.

Function Input

• None

Function Output

• Void

C++ Example

//== Clear all Rigid Bodies ==//
TT_ClearRigidBodyList();

TT_RemoveRigidBody

Removes a Rigid Body from the project

NPRESULT		TT_RemoveRigidBody(int rbIndex);

Description

• This function removes a single Rigid Body from a project.

• Returns a NPRESULT integer value. If the operation was successful, it returns 0 (NPRESULT_SUCCESS).

Function Input

• Rigid body index (int)

Function Output

• NPRESULT

C++ Example

//== Removing Rigid Bodies that are not tracked in the scene ==//
int totalRB = TT_RigidBodyCount();

for (int i = 0; i < totalRB; i++)
{
	if(!TT_IsRigidBodyTracked(i))
	{
 		TT_RemoveRigidBody(i);
	}
}

TT_RigidBodyCount

Returns a total number of Rigid Bodies.

Description

• This function returns a total count of Rigid Bodies involved in the project.

• This can be used within a loop to set required number iterations and access each of the Rigid Bodies.

Function Input

• None

Function Output

• Total Rigid Body count (int)

C++ Example

//== Getting names of all Rigid Bodies ==//
int totalRB = TT_RigidBodyCount();

for (int i = 0; i < totalRB; i++)
{
	printf("Rigid Body #%d: %s\n", i, TT_RigidBodyName(i));
}

TT_RigidBodyUserData

Returns the User Data ID value of a Rigid Body.

int		TT_RigidBodyUserData(int rbIndex);

Description

• This function returns the User Data ID number of a Rigid Body.

• User ID is a user definable ID for the Rigid Body. When working with capture data in external pipelines, this value can be used to address specific Rigid Bodies in the scene.

Function Input

• Rigid body index (int)

Function Output

• User Data ID (int)

C++ Example

int totalRB = TT_RigidBodyCount();

//== User Data ID for all Rigid Bodies ==//
for ( int i = 0 ; i < totalRB; i++ )
{
	printf("%s User Data ID: %d", TT_RigidBodyName(i), TT_RigidBodyUserData(i));
}

TT_SetRigidBodyUserData

Assigns a User Data ID number to a Rigid Body.

void		TT_SetRigidBodyUserData(int rbIndex, int ID);

Description

• Assigns a User Data ID number to a Rigid Body.

• The User Data ID numbers can be used to point to particular assets when processing the data in external applications.

Function Input

• Rigid body index (int)

• Desired User Data ID (int)

Function Output

• Void

C++ Example

int totalRB = TT_RigidBodyCount();

//== Assigning incremental User Data ID for Rigid Bodies. ==//
for( int i = 0; i < totalRB; i++ )
{
	TT_SetRigidBodyUserData(i, i+1);
	printf("Rigid Body: %s, \t User Data ID: %d", TT_RigidBodyName(i), TT_RigidBodyUserData(i)); 
}

TT_RigidBodyMeanError

Returns a mean error of the Rigid Body tracking data.

void		TT_RigidBodyMeanError(int rbIndex, int ID);

Description

• Returns a mean error value of the respective Rigid Body data for the current frame.

Function Input

• Rigid body index (int)

Function Output

• Mean error (meters)

TT_RigidBodyName, TT_RigidBodyNameW

Returns the name for the Rigid Body.

const char* 	 	TT_RigidBodyName(int rbIndex);

const wchar_t*		TT_RigidBodyNameW(int rbIndex);

Description

• These functions are used to obtain name of a Rigid Body.

• Returns the assigned name of the Rigid Body.

Function Input

• Rigid body index (int)

Function Output

• Rigid body name (const char*, const w_chart*)

C++ Example

int totalRB = TT_RigidBodyCount();

//== Printing Rigid Body Names ==//
for( int i = 0; i < totalRB; i++ )
{
	printf("Rigid Body: %s, \t User Data ID: %d", TT_RigidBodyName(i), TT_RigidBodyUserData(i)); 
}

TT_SetRigidBodyEnabled

Enables/disables tracking of a Rigid Body.

void		TT_SetRigidBodyEnabled(int rbIndex, bool enabled);

Description

• This function enables, or disables, tracking of the selected Rigid Body.

• All Rigid Bodies are enabled by default. Disabled Rigid Bodies will not be tracked, and no data will be received from it.

Function Input

• Rigid body index (int)

• Tracking status (bool)

Function Output

• Void

C++ Example

int totalRB = TT_RigidBodyCount();

//== Disabling all Rigid Bodies ==//
for(int i = 0; i < totalRB; i++)
{
	TT_SetRigidBodyEnabled(i, FALSE);
} 

TT_RigidBodyEnabled

Checks whether a Rigid Body is enabled.

bool		TT_RigidBodyEnabled(int rbIndex);

Description

• This function checks whether tracking of the Rigid Body is enabled or not.

• The function returns true is the tracking is enabled.

Function Input

• Rigid body index (int)

Function Output

• True / False (bool)

C++ Example

int totalRB = TT_RigidBodyCount();

for (int i = 0; i < totalRB; i++)
{
	if (TT_RigidBodyEnabled(i))
	{
 		//== Disabling all enabled Rigid Bodies ==//
		TT_SetRigidBodyEnabled(i, FALSE);
	}
}

TT_RigidBodyTranslatePivot

Translates the pivot point of a Rigid Body.

NPRESULT		TT_RigidBodyTranslatePivot(int index, float x, float y, float z);

Description

• This function translates a Rigid Body.

• 3D position of a Rigid Body will be displaced in x/y/z directions by inputted amount (meters).

• Translation is applied in respect to the local Rigid Body coordinate axis, not the global axis.

• Returns a NPRESULT integer value. If the operation was successful, it returns 0 (NPRESULT_SUCCESS).

Function Input

• Rigid body index (int)

• Translation along x-axis, in meters. (float)

• Translation along y-axis, in meters. (float)

• Translation along z-axis, in meters. (float)

Function Output

• NPRESULT

C++ Example

int rbIndex = 1;

//== Translating a Rigid Body 2 cm in positive x-direction ==//
TT_RigidBodyTranslate(rbIndex, 0.02, 0, 0);

TT_RigidBodyResetOrientation

Resets orientation of a Rigid Body.

bool		TT_RigidBodyResetOrientation(int rbIndex);

Description

• This function resets orientation of the Rigid Body and re-aligns its orientation axis with the global coordinate system.

• Additional Note: When creating a Rigid Body, its zero orientation is set by aligning its axis with the global axis at the moment of creation. Calling this function essentially does the same thing on an existing Rigid Body asset.

• Returns true if the Rigid Body orientation was reset.

Function Input

• Rigid body index (int)

Function Input

• True / False (bool)

C++ Example

int rbcount = TT_RigidBodyCount();

//== Resetting orientation of each Rigid Body. ==//
for( int i = 0; i < rbcount i++ )
{
	if(TT_RigidBodyResetOrientation(i))
	{
		printf("Rigid body (%s) orientation reset", TT_RigidBodyName(i));
	}
}

TT_RigidBodyMarkerCount

Gets total number of markers in a Rigid Body.

int		TT_RigidBodyMarkerCount(int rbIndex);

Description

• This function returns total number of markers involved in a Rigid Body.

Function Input

• Rigid body index (int)

Function Output

• Total number of marker in the Rigid Body (int)

C++ Example

int rbcount = TT_RigidBodyCount();

//== Listing out all of the Rigid Body markers ==// 
for(int i = 0; i < rbcount; i++)
{
	printf("Rigid Body:%s\t Marker Count: %d", TT_RigidBodyName(i), TT_RigidBodyMarkerCount(i));
}

TT_RigidBodyMarker

Saves 3D coordinates of a solved Rigid Body marker in respect to respective Rigid Body's local space.

void		TT_RigidBodyMarker(int rbIndex, int markerIndex, float *x, float *y, float *z);

Description

• This function gets 3D position of a solved Rigid Body marker and saves them in designated addresses. Rigid body marker positions from this function represents solved (or expected) location of the Rigid Body markers. For actual reconstructed marker positions, use the TT_RigidBodyPointCloudMarker function.

• Note that the 3D coordinates obtained by this function is represented in respect to Rigid Body's local coordinate axis. For obtaining 3D coordinate in respect to global coordinates, use TT_RigidBodyPointCloudMarker function.

Function Input

• Rigid body index (int)

• Marker index (int)

• Three declared variable addresses for saving x, y, z coordinates of the marker (float)

Function Output

• Void

C++ Example

//== Listing out all of the Rigid Body markers and its respective position. ==//
int rbcount = TT_RigidBodyCount();

for(int i = 0; i < rbcount; i++)
{
	float	x,y,z;

	for(int j = 0; j < TT_RigidBodyMarkerCount(i); j++)
	{
		printf("Rigid Body:%s\t Marker #%d\n", TT_RigidBodyName(i), j);
		
		//== Marker Locations ==//
		TT_RigidBodyMarker(i, j, &x, &y, &z);
		printf("Local: (%f, %f, %f)\n", x, y, z);
	}
}

TT_RigidBodyUpdateMarker

Changes and updates the Rigid Body marker positions.

bool     TT_RigidBodyUpdateMarker( int rbIndex, int markerIndex, float *x, float *y, float *z );

Description

• This function is used to change the expected positions of a single Rigid Body marker.

• Rigid body markers are expected marker positions. Read about marker types in Motive.

Function Input

• Rigid body index (int)

• Marker index (int)

• New x-position of the Rigid Body marker in respect to the local coordinate system.

• New y-position of the Rigid Body marker in respect to the local coordinate system.

• New z-position of the Rigid Body marker in respect to the local coordinate system.

Function Output

• Returns true if marker locations have been successfully updated.

TT_RigidBodyPointCloudMarker

Saves 3D coordinates of a Rigid Body marker in respect to the global space.

void		TT_RigidBodyPointCloudMarker(int rbIndex, int markerIndex, bool &tracked, float &x, float &y, float &z);

Description

• This function saves 3D coordinates of each Rigid Body marker in designated addresses.

• 3D coordinates are saved in respect to global coordinate system.

Function Input

• Rigid body index (int)

• Marker index (int)

• Tracked status, True or False (bool)

• Three declared variable addresses for saving x, y, z coordinates of the marker (float).

Function Output

• Void

C++ Example

//== Listing out all of the Rigid Body markers and its respective position. ==//
int rbcount = TT_RigidBodyCount();

for(int i = 0; i < rbcount; i++)
{
	float	gx, gy, gz;
	bool	tracked;

	for(int j = 0; j < TT_RigidBodyMarkerCount(i); j++)
	{
		printf("Rigid Body:%s\t Marker #%d\n", TT_RigidBodyName(i), j);
		 
		//== Rigid Body Marker Global Coordinates ==//
		TT_RigidBodyPointCloudMarker(i, j, tracked, gx, gy, gz);
		printf("Global: (%f, %f, %f)\n", x, y, z);
	}
}

TT_RigidBodyPlacedMarker

Saves 3D coordinates of a Rigid Body solved marker positions in respect to the global space. Unlike TT_RigidBodyPointCloudMarker function, it does not report point cloud solved positions, but it reports the expected marker positions in respect to Rigid Body position and orientation.

void		TT_RigidBodyPlacedMarker(int rbIndex, int markerIndex, bool &tracked, float &x, float &y, float &z);

Description

• This function saves 3D coordinates of each expected Rigid Body marker positions in designated variable addresses.

• 3D coordinates are saved in respect to global coordinate system.

Function Input

• Rigid body index (int)

• Marker index (int)

• Tracked status, True or False (bool)

• Three declared variable addresses for saving x, y, z coordinates of the marker (float).

Function Output

• Void

C++ Example

//== Listing out all of the Rigid Body markers and its respective position. ==//
int rbcount = TT_RigidBodyCount();

for(int i = 0; i < rbcount; i++)
{
	float	gx, gy, gz;
	bool	tracked;

	for(int j = 0; j < TT_RigidBodyMarkerCount(i); j++)
	{
		printf("Rigid Body:%s\t Marker #%d\n", TT_RigidBodyName(i), j);
		 
		//== Expected Rigid Body marker positions. ==//
		TT_RigidBodyPlacedMarker(i, j, tracked, gx, gy, gz);
		printf("Global: (%f, %f, %f)\n", x, y, z);
	}
}

TT_RigidBodyID

This function is used for obtaining unique identifiers for a specific Rigid Body indicated by the Rigid Body index number.

Core::cUID		TT_RigidBodyID( int rbIndex );

Function Input

• Rigid body index (int)

Function Output

• Rigid body unique ID (Core::cUID)

TT_CreateRigidBody

Creates a Rigid Body asset from a set of reconstructed 3D markers.

NPRESULT		TT_CreateRigidBody(const char* name, int userDataID, int markerCount, float *markerList);

Description

• This functions creates a Rigid Body from the marker list and marker count provided in its argument.

• The marker list is expected to contain a list of marker coordinates in the following order: (x1, y1, z1, x2, y2, z2, …, xN, yN, zN). The x/y/z coordinates must be in respect to the Rigid Body pivot point, in meters.

• Inputted 3D locations are taken as Rigid Body marker positions about the Rigid Body pivot point. If you are using TT_FrameMarkerX/Y/Z functions to obtain the marker coordinates, you will need to subtract the pivot point location from the global marker locations when creating a Rigid Body. This is shown in the below example. If this is not done, created Rigid Body will have its pivot point at the global origin.

• Returns an NPRESULT integer value. If the Rigid Body was successfully created, it returns 0 or NPRESULT_SUCCESS.

Function Input

• Rigid body name (char)

• User Data ID (int)

• Marker Count (int)

• Marker list (float list)

Function Output

• NPRESULT

C++ Example

int markerCount = TT_FrameMarkerCount;
vector<float> markerListRelativeToGlobal;

// add markers to markerListRelativeToGlobal using TT_FrameMarkerX, etc
for (int i = 0; i < markerCount; ++i)
{
    	markerListRelativeToGlobal.push_back(TT_FrameMarkerX(i));
    	markerListRelativeToGlobal.push_back(TT_FrameMarkerY(i));
	markerListRelativeToGlobal.push_back(TT_FrameMarkerZ(i));
}

// then average the locations in x, y and z
float sx = 0, sy = 0, sz = 0;
for (int i = 0; i < markerCount; ++i)
{
    	sx += markerListRelativeToGlobal[3*i];
    	sy += markerListRelativeToGlobal[3*i + 1];
    	sz += markerListRelativeToGlobal[3*i + 2];
}


float ax = sx/markerCount;
float ay = sy/markerCount;
float az = sz/markerCount;


vector<float> pivotPoint = {ax, ay, az};
vector<float> markerListRelativeToPivotPoint;

// subtract the pivot point location from the marker location
for (int i = 0; i < markerCount; ++i)
{
    markerListRelativeToPivotPoint.push_back(markerListRelativeToGlobal[3*i] - ax);
    markerListRelativeToPivotPoint.push_back(markerListRelativeToGlobal[3*i + 1] - ay);
    markerListRelativeToPivotPoint.push_back(markerListRelativeToGlobal[3*i + 2] - az);
}

TT_CreateRigidBody("Rigid Body New", 1, markerCount, markerListRelativeToPivotPoint);

TT_RigidBodySettings

Obtains Rigid Body settings for a given asset, and saves them in a cRigidBodySettings instance.

NPRESULT		TT_RigidBodySettings(int rbIndex, RigidBodySolver::cRigidBodySettings &settings);

Description

• This function obtains Rigid Body settings for a given Rigid Body asset and saves them into a declared cRigidBodySetting instance address.

• Rigid body settings are saved into an instance of the cRigidBodySettings class.

• For detailed information on member function and variables in the cRigidBodySettings class, refer to its declaration in the RigidBodySettings.h header file.

• Returns a NPRESULT integer value.

Function Input

• Rigid body index (int)

• declared instance address (cRigidBodySettings)

Function Output

• NPRESULT

C++ Example

//== Constructor at the Beginning of the program ==//
RigidBodySolver::cRigidBodySettings::cRigidBodySettings()	{};

//== Obtaining Rigid Body Settings ==//
int rbcount = TT_RigidBodyCount();
RigidBodySolver::cRigidBodySettings	settings;

for( int i = 0; i < rbcount; i++ )
{
	TT_RigidBodySettings(i, settings);

	printf("Rigid Body: %s\n", TT_RigidBodyName(i));

	//== Printing Some of the Settings==// 
	printf("MaxMarkerDeflection: %f\n", settings.MaxMarkerDeflection);
	printf("MinimumMarkerCount: %d\n", settings.MinimumMarkerCount);

	if (settings.Unique) 
	{
		printf("Unique: True\n");
	}
}

TT_SetRigidBodySettings

Changes property settings of a Rigid Body.

NPRESULT		TT_SetRigidBodySettings(int rbIndex, RigidBodySolver::cRigidBodySettings &settings);

Description

• This function assigns a set of Rigid Body settings to a Rigid Body asset.

• An instance of cRigidBodySettings will be attached to the provided Rigid Body.

• Returns a NPRESULT integer value. If the marker was successfully created, it returns 0 (NPRESULT_SUCCESS).

Function Input

• Rigid body index (int)

Function Output

• NPRESULT

C++ Example

//== Constructor at the Beginning of the program ==//
int rbcount = TT_RigidBodyCount();
RigidBodySolver::cRigidBodySettings::cRigidBodySettings()	{};

RigidBodySolver::cRigidBodySettings	settings;

for(int i = 0; i < rbcount; i++)
{

	//== Obtaining configured settings for each Rigid Body ==//
	TT_RigidBodySettings(i, settings);

	if(settings.Unique){
		printf("Rigid Body #%d is already set to Unique", i);
	}
	else
	{
 		//== Setting/assigning all Rigid Bodies to Unique ==//
		settings.Unique = TRUE;
 		TT_SetRigidBodySettings(i,settings);

		printf("Rigid Body #%d has been set to Unique", i);
}

TT_RigidBodyRefineStart

Initiates the Rigid Body refinement process. Input the number of samples and the ID of the Rigid Body you wish to refine. After starting the process, TT_RigidBodyRefineSample bust be called on everyframe in order to collect samples.

bool     TT_RigidBodyRefineStart( Core::cUID rigidBodyID, int sampleCount );

Description

• This function is used to start Rigid Body refinement.

Function Input

• Target Rigid Body ID

• Sample count (int)

Function Output

• Returns true if the refinement process has successfully initiated.

TT_RigidBodyRefineSample

This function collects samples for Rigid Body refinement started by calling the TT_RigidBodyRefineStart function. Call this function for every frame; within the update loop. You can check the progress of calibration by calling the TT_RigidBodyRefineProgress function.

bool     TT_RigidBodyRefineSample();

Description

• This function collects sample Rigid Body tracking data for refining the definition of corresponding Rigid Body.

Function Input

• None. Samples frames for the initialized refine process.

Function Output

• Returns true if the refinement process has successfully collected a sample. This function does not collect samples if Rigid Body is not tracked on the frame.

TT_RigidBodyRefineState

This function inquiries the state of the refinement process. It returns TT_RigidBodyRefineStates enum as a result.

TT_RIgidBodyRefineStates     TT_RigidBodyRefineState();

Description

• This function queries the state of the Rigid Body refinement process. It returns an enum value for indicating whether the proess is intialized, sampling, solving, complete, or uninitialized.

<source> enum TT_RigidBodyRefineStates {

   TT_RigidBodyRefine_Initialized = 0,
   TT_RigidBodyRefine_Sampling,
   TT_RigidBodyRefine_Solving,
   TT_RigidBodyRefine_Complete,
   TT_RigidBodyRefine_Uninitialized

};

</source>

Function Input

• None. Checks the state on the ongoing refinement process.

Function Output

• Returns TT_RigidBodyRefineStates enum value.

TT_RigidBodyRefineProgress

This function inquiries the progress of the refinement sampling process.

float     TT_RigidBodyRefintProgress();

Description

• When the refinement process is under the sampling state, calling this function returns the sampling progress. It will return a percentage value representing the sampling progress in respect to the total number of samples given in the TT_RigidBodyRefineStart parameter.

Function Input

• None. Checks the progress on the ongoing refinement process.

Function Output

• Returns percentage completness of the sampling process (float).

TT_RigidBodyRefineInitialError / TT_RigidBodyRefineResultError

These two functions returns error values of the Rigid Body definition before and after the refinement.

float     TT_RigidBodyRefineInitialError();
float     TT_RigidBodyRefineResultError();

Description

• Once the refinement process has reached complete stage, these two functions can be called to compare the error values from corresponding Rigid Body defintion before and after the refinement.

Function Input

• None.

Function Output

• Average error value of the target Rigid Body defintion prior (TT_RigidBodyRefineInitialError) and after (TT_RigidBodyRefineResultError) the refinement.

TT_RigidBodyRefineApplyResult

This function applies the refined result to the corresponding Rigid Body definition.

bool     TT_RigidBodyRefineApplyResult();

Description

• This function applies the refined Rigid Body definition. After comparing the error values before and after the refinement using TT_RigidBodyRefineInitialError and TT_RigidBodyRefineResultError functions, use this function to apply if the results are satisfying.

Function Input

• None.

Function Output

• Returns true if the refined results have been successfully applied.

TT_RigidBodyRefineReset

This function discards the final refinement result and resets the refinement process.

bool     TT_RigidBodyRefineReset();

Description

• If the final refinement result from the TT_RigidBodyRefineResultError call is not satisfying, you can call this function to discard the result and start over from the sampling process again.

Function Input

• None.

Function Output

• Returns true if the refined results have been successfully resetted.

Camera Group

TT_GetCameraManager

Returns pointer to the CameraManager instance.

CameraLibrary::CameraManager*		TT_GetCameraManager();

Description

• This function returns a pointer to the CameraManager instance from the Camera SDK.

• Camera SDK must be installed to use this function.

• The version number of Motive and the Camera SDK must match.

• Corresponding headers and libraries must be included in the program.

Function Input

• None

Function Output

• Pointer to the CameraManager instance (CameraLibrary::CameraManager*)

C++ Example

CameraLibrary::CameraManager *cman = TT_GetCameraManager();
// cman is declared as a pointer to a camera manager used in conjuction with the Camera SDK

TT_BuildNumber

Returns Motive build number.

Description

• This function returns corresponding Motive build number.

Function Input

• None

Function Output

• Build number (int)

C++ Example

//== Printing Motive Build Number ==//
printf("Motive Build: %d\n", TT_BuildNumber());

TT_CameraGroupCount

Returns camera group count.

int		TT_CameraGroupCount();

Description

• This function returns total count of camera groups that are involved in the project.

Function Input

• None

Function Output

• Camera group count (int)

C++ Example

int groupcount = TT_CameraGroupCount();

//== Processing Camera Groups ==//
for(int i = 0; i < groupcount; i++)
{
	//== Process each camera group ==//
}

TT_CreateCameraGroup

Creates a new camera group.

bool		TT_CreateCameraGroup();

Description

• This function adds an additional camera group (empty) to a project.

• Note: Creating an additional camera group is unnecessary for most applications. Most common case is to group cameras to set them as a reference group for recording grayscale videos.

Function Input

• None

Function Output

• True/False (bool)

C++ Example

//== Creating a new camera group ==//
TT_CreateCameraGroup();

TT_RemoveCameraGroup

Removes a camera group.

bool		TT_RemoveCameraGroup(groupIndex);

Description

• This function removes a camera group, specified by its index number.

• The camera group must contain no cameras in order to be removed.

• Returns true if the group was successfully removed.

Function Input

• Camera group index (int)

Function Output

• True/False (bool)

C++ Example

//== For projects with multiple camera groups ==//
int cameracount = TT_CameraCount();
int groupcount = TT_CameraGroupCount();

if(groupcount  > 1)
{
	//== Moving all cameras to the first camera group (index = 0) ==//
	for(int i = 0; i < cameracount; i++)
	{
		TT_SetCameraGroup( i, 0);
	}
	
	//== Removing all other camera groups==//
	for(int j = 1; j < groupcount; j++)
	{
		TT_RemoveCameraGroup(j);
	}
}

TT_CamerasGroup

Returns an index value of a camera group that a camera is involved in.

int		TT_CamerasGroup(int cameraIndex);

Description

• This function takes an index value of a camera and returns corresponding camera group index which the camera is involved in.

Function Input

• Camera index (int)

Function Output

• Camera group index (int)

C++ Example

//== Listing out all of the cameras and their associate group index ==//
int cameracount = TT_CameraCount();

for(int i = 0; i < cameracount; i ++)
{
	printf("Camera: %s\t CameraGroup: #%d", TT_CameraName(i), TT_CamerasGroup(i));
}

TT_SetGroupShutterDelay

Introduces shutter delay to a camera group.

void		TT_SetGroupShutterDelay(int groupIndex, int microseconds);

Description

• This function sets a shutter delay (in microseconds) to a camera group, which is designated by its index number.

• After assigning the delay, all of the cameras involved in the camera group will shutter at a delayed timing when recording.

Function Input

• Camera group index (int)

• Delay in microseconds (int)

Function Output

• Void

C++ Example

//== Setting one second shutter delay for all camera groups ==//
for(int i = 0; i < TT_CameraGroupCount() ; i++)
{
	TT_SetGroupShutterDelay(i, 1000000);
}

TT_SetCameraGroup

Moves a camera to a different camera group.

void		TT_SetCameraGroup(int cameraIndex, int groupIndex);

Description

• This function assigns/moves a camera to a different camera group

Function Input

• Camera index (int)

• Camera group index (int)

Function Output

• Void

C++ Example

//== For projects with multiple camera groups ==//
int cameracount = TT_CameraCount();
int groupcount = TT_CameraGroup();

if(groupcount > 1)
{
	//== Moving all cameras to the first camera group ==//
	for(int i = 0; i < cameracount; i++)
	{
		//== Assigning all cameras to the first camera group (index = 0) ==//
		TT_SetCameraGroup(i, 0);
	}
	
	//== Removing all other camera groups==//
	for(int j = 1; j < groupcount; j++)
	{
		TT_RemoveCameraGroup(j);
	}
}

TT_CameraGroupFilterSettings

Obtains the camera group's filter settings.

NPRESULT		TT_CameraGroupFilterSettings(int groupIndex, cCameraGroupFilterSettings &settings);

Description

• This function fetches configured 2D filter settings from a camera group and saves the settings in the declared cCameraGroupFilterSettings instance.

• Returns a NPRESULT integer value. When the function successfully assigns the filter settings, it returns 0 (or NPRESULT_SUCCESS).

Function Input

• Camera group index (int)

• Group filter settings instance (cCameraGroupFilterSettings)

Function Output

• NPRESULT

C++ Example

//== Declaring cCameraGroupFilterSettings object==//
cCameraGroupFilterSettings	filterSettings;
int groupcount = TT_CameraGroupCount();

//== Obtaining filter settings for all of the camera groups ==//
for (int i = 0; i < groupcount; i++)
{
	TT_CameraGroupFilterSettings(i, filterSettings);

	//== Printing ==//
	printf("GroupFilterSettings (group #%d):\n",i);
	printf("\tMinMarkerSize: %d\n", filterSettings.MinMarkerSize);
	printf("\tMaxMarkerSize: %d\n", filterSettings.MaxMarkerSize);
	printf("\tMinRoundness:  %f\n", filterSettings.MinRoundness);

	if (filterSettings.FilterType == filterSettings.FilterNone)
	{
		printf("\tFilter: Filter None\n");
	}
	printf("\n");
}

TT_SetCameraGroupFilterSettings

Assigns camera group filter settings to a camera group.

NPRESULT		TT_SetCameraGRoupFilterSettings(int groupIndex, cCameraGroupFilterSettings &settings);

Description

• This function assigns inputted filter settings (cCameraGroupFilterSettings) instance to a camera group designated by its index number.

• Returns a NPRESULT integer value. When the function successfully assigns the filter settings, it returns 0 (or NPRESULT_SUCCESS).

Function Input

• Camera group index (int)

• Filter settings instance (cCameraGroupFilterSettings)

Function Output

• NPRESULT

C++ Example

int groupcount = TT_CameraGroupCount();

//== Settings MinMarkerSize threshold settings to 20 pixels for all camera groups==//
for (int i = 0; i < groupcount; i++)
{
	cCameraGroupFilterSettings new_settings;
	TT_CameraGroupFilterSettings(i, new_settings);
	
	// For size and roundness filters
	if (new_settings.FilterType == new_settings.FilterSizeRoundness)
	{
		//== Changing MinMarkerSize setting and reassigning it to the camera group.
		filterSettings.MinMarkerSize = 20;
		TT_SetCameraGroupFilterSettings(i, new_settings);

		printf("\tFilter settings changed");
	}
}

TT_CameraGroupPointCloudSettings / TT_SetCameraGroupPointCloudSettings

TT_CameraGroupMarkerSize

Obtains marker size settings of a camera group

NPRESULT		TT_CameraGroupMarkerSize(int groupIndex, cCameraGroupMarkerSizeSettings &settings);

Description

• This function fetches currently configured marker size settings from a camera group, and saves them onto a declared cCameraGroupMarkerSizeSettings class instance.

• The marker size settings determine display properties of the 3D markers reconstructed from a specific group of cameras.

• Returns a NPRESULT integer value. When the function successfully obtains the settings, it returns 0 (or NPRESULT_SUCCESS).

Function Input

• Camera group index (int)

• Marker size settings (cCameraGroupMarkerSizeSettings)

Function Output

• NPRESULT

C++ Example

int groupcount = TT_CameraGroupCount();

for (int i = 0; i < groupcount; i++)
{
	//== Obtaining marker size settings ==//
	cCameraGRoupMarkerSizeSettings mSettings;
	TT_CameraGroupMarkerSize(i, mSettings);
	
	//== Outputting the settings==//
	printf("Camera Group #%d:\n", i);
	printf("\tMarker Size: %f\n", mSettings.MarkerSize);

	if (mSettings.MarkerSizeType == cCameraGroupMarkerSizeSettings::MarkerSizeCalculated) {
		printf("\tMarkerSizeCalulated\n");
	}
	else if (mSettings.MarkerSizeType == cCameraGroupMarkerSizeSettings::MarkerSizeFixed)
	{
		printf("\tMarkerSizeFixed\n");
		mSettings.MarkerSize = 20.0
	}
}

TT_SetCameraGroupMarkerSize

Applies given marker size settings to a camera group.

NPRESULT		TT_SetCameraGroupMarkerSize(int groupIndex, cCameraGroupMarkerSizeSettings &settings);

Description

• This function applies an instance cCameraGroupMarkerSizeSettings to a camera group.

• The marker size settings determine display properties of 3D markers reconstructed from a specific group of cameras.

• Marker sizes are represented by corresponding diameter in millimeters.

• Returns a NPRESULT integer value. When the function successfully applies the settings, it returns 0 (or NPRESULT_SUCCESS).

Function Input

• Camera group index (int)

• Marker size settings (cCameraGroupMarkerSizeSettings)

Function Output

• NPRESULT

C++ Example

int groupcount = TT_CameraGroupCount();

//== Setting all camera groups to share a fixed marker size ==//
for (int i = 0; i < groupcount; i++)
{
	cCameraGroupMarkerSizeSettings mSettings;
	TT_CameraGroupMarkerSize(i, settings);

	//== Modify and reapply the settings ==//
	mSettings.MarkerSizeType = cCameraGroupMarkerSizeSettings::MarkerSizeFixed;
	mSettings.MarkerSize = 10.0;

	TT_SetCameraGroupMarkerSize(i, settings);
}

TT_SetCameraGroupReconstruction

Enables or disables marker reconstruction contribution from a camera group.

NPRESULT		TT_SetCameraGroupReconstruction(int groupIndex, bool enable);

Description

• Enables or disables marker reconstruction contribution from a camera group.

• Input TRUE for enable argument in order to allow the camera group to reconstruct markers.

• Returns a NPRESULT integer value. When the function successfully enables/disables the reconstruction, it returns 0 (or NPRESULT_SUCCESS).

Function Input

• Camera group index (int)

• Boolean argument for enabling (true) and disabling (false) the mode.

Function Output

• NPRESULT

C++ Example

//== Disabling all camera groups ==//
int groupcount = TT_CameraGroupCount();
bool	enabled = false;

for (int i = 0; i < groupcount; i++)
{
	TT_SetCameraGroupReconstruction(i, enabled);
}

TT_SetEnabledFilterSwitch

Enables or disables filter switchers.

NPRESULT		TT_SetEnabledFilterSwitch(bool enabled);

Description

• This function enables or disables filter switches for all of the connected cameras.

• Returns a NPRESULT integer value. When the function successfully changes the setting, it returns 0 (or NPRESULT_SUCCESS).

Function Input

• Boolean argument for enabling (true) or disabling (false) the filter.

Function Output

• NPRESULT

C++ Example

//== Disabling Filter Switches ==//
bool	enabled = false;
TT_SetEnabledFilterSwitch(enabled);

TT_IsFilterSwitchEnabled

Checks whether filter switches are enabled or not.

bool		TT_IsFilterSwitchEnabled();

Description

• This function checks whether filter switch is enabled in all of the cameras,

• It returns true if the switches are enabled.

Function Input

• Void

Function Output

• Enabled/disabled (bool)

C++ Example

//== Enabling disable filter switches ==//
if (!TT_IsFilterSwitchEnabled())
{
	printf("Enabling all disabled switches\n");
	TT_SetEnabledFilterSwitch(true);
}

Camera

TT_CameraCount

Returns a total number of cameras connected to the system.

Description

• This function returns a total camera count.

Function Input

• None

Function Output

• Total number of cameras (int)

C++ Example

//== Printing Frame rate of the cameras ==//
int totalCamera = TT_CameraCount();
for( int i = 0; i < totalCamera; i++)
{
 	printf("%s frame rate: %d\n", TT_CameraName(i), TT_CameraFrameRate(i));
}

TT_CameraXLocation

Returns x-position of a camera.

int		TT_CameraXLocation(int cameraIndex);

Description

• This function returns camera's X position in respect to the global coordinate system

Function Input

• Camera index (int)

Function Output

• Camera's X position. Measured in meters with reference to global coordinate system. (float)

C++ Example

for(int i = 0; i < TT_CameraCount(); i++)
{
	float camX = TT_CameraXLocation(i);
	float camY = TT_CameraYLocation(i);
	float camZ = TT_CameraZLocation(i);
	
	printf("Camera #%d: (%f, %f, %f)", camX, camY, camZ);
}

TT_CameraYLocation

Returns y-position of a camera.

int		TT_CameraYLocation(int cameraIndex);

Description

• This function returns camera's Y position in respect to the global coordinate system

Function Input

• Camera index (int)

Function Output

• Camera Y-position. Measured in meters with reference to global coordinate system. (float)

C++ Example

for(int i = 0; i < TT_CameraCount(); i++)
{
	float camX = TT_CameraXLocation(i);
	float camY = TT_CameraYLocation(i);
	float camZ = TT_CameraZLocation(i);
	
	printf("Camera #%d: (%f, %f, %f)", camX, camY, camZ);
}

TT_CameraZLocation

Returns z-position of a camera.

int		TT_CameraZLocation(int cameraIndex);

Description

• This function returns camera's Z position in respect to the global coordinate system

Function Input

• Camera index (int)

Function Output

• Camera's Z position. Measured in meters with reference to global coordinate system. (float)

C++ Example

for(int i = 0; i < TT_CameraCount(); i++)
{
	float camX = TT_CameraXLocation(i);
	float camY = TT_CameraYLocation(i);
	float camZ = TT_CameraZLocation(i);
	
	printf("Camera #%d: (%f, %f, %f)", camX, camY, camZ);
}

TT_CameraOrientationMatrix

Gets a components of the camera's orientation matrix.

float		TT_CameraOrientationMatrix(int cameraIndex, int matrixIndex);

Sample output from a program displaying the rotation matrix.

Description

• This function returns a single constant from camera's orientation matrix in respect to the global coordinate axis.

• The camera index input (int) determines which camera to obtain the matrix from.

• The matrix index determines which component of the rotation matrix to return.

Function Input

• Camera index (int)

• Matrix index (int)

Function Output

• Single component of the rotation matrix (float)

C++ Example

printf("Orienation Matrix: \n");

for (int j = 0; j < 3; j++)
{

	for (int k = 0; k < 3; k++)
	{
		//===== Rotation Matrix =====//
		printf("\t%f (index %d)", TT_CameraOrientationMatrix(i, k + (3 * j)), k + (3 * j));
	}
	printf("\n\n");
}

TT_CameraName

Returns coresponding camera's model name and serial number

const char*		TT_CameraName(int cameraIndex);

Description

• This function returns corresponding camera's name and serial number.

Function Input

• Camera index (int)

Function Output

• Camera name and serial number (const char)

C++ Example

//== Displaying all connected cameras ==//
int totalCamera = TT_CameraCount();

printf("Detected Cameras:\n"); 
for (int i = 0; i < totalCamera; i++)
{
	printf("\t%s\n", TT_CameraName(i));
}

TT_CameraSerial

Returns coresponding camera's serial number as an integer.

int		TT_CameraSerial(int cameraIndex);

Description

• This function returns corresponding camera's serial number.

Function Input

• Camera index (int)

Function Output

• Camera serial number (int)

C++ Example

//== Displaying all connected cameras ==//
int totalCamera = TT_CameraCount();

printf("Detected Cameras Serial Numbers:\n"); 
for (int i = 0; i < totalCamera; i++)
{
	printf("\t%d\n", TT_CameraSerial(i));
}

TT_CameraMarkerCount

Returns a total number of centroids detected by a camera.

int		TT_CameraMarkerCount(int cameraIndex);

Description

• This function returns a total number of centroids detected by a camera.

• A centroid is defined for every group of contiguous pixels that forms a shape that encloses the thresholded pixels.

• Size and roundness filter (cCameraGroupFilterSettings) is not applied in this data.

Function Input

• Camera index (int)

Function Output

• Number of centroids (int)

C++ Example

for (int i = 0; i < TT_CameraCount(); i++)
{
	int centroidcount = TT_CameraMarkerCount(i);
	printf("Camera #%d detected centroids: %d\n", i, centroidcount);
}

TT_CameraMarker

Returns 2D location of the centroid as seen by a camera.

bool		TT_CameraMarker(int cameraIndex, int markerIndex, float &x, float &y);

Description

• This function saves 2D location of the centroid as detected by a camera's imager.

• Returns true if the function successfully saves the x and y locations.

Function Input

• Camera index (int)

• Centroid index (int)

• Declared variables for saving x and y (float)

Function Output

• True/False (bool)

C++ Example

int cameracount = TT_CameraCount();

for (int i = 0; i < cameracount; i++)
{
	float x, y;
	int centroidcount = TT_CameraMarkerCount(i);
	printf("Camera #%d detected centroids: %d\n", i, centroidcount);

	for (int j = 0; j < centroidcount; j++)
	{
		TT_CameraMarker(i, j, x, y);
		printf("\t#%d\t(%.2f, %.2f)\n", j, x, y);
	}
}

TT_CameraPixelResolution

Saves camera's pixel resolution.

bool		TT_CameraPixelResolution(int cameraIndex, int &width, int&height);

Description

• This function saves camera's pixel resolutions (width x height) into declared integer variables.

• Returns true when successfully saving the values.

Function Input

• Camera index (int)

• Declared integer variable for saving width (int)

• Declared integer variable for saving height (int)

Function Output

• True/False (bool)

C++ Example

//== Obtaining Camera Resolutions ==//
int width = 0;
int height = 0;

for (int i = 0; i < TT_CameraCount(); i++)
{
	TT_CameraPixelResolution(i, width, height);
	printf("Camera #%d Resolution:\t%d\t%d\n", i, width, height);
}

TT_CameraMarkerPredistorted

Saves predistorted 2D location of a centroid.

bool		TT_CameraMarkerPredistorted(int cameraIndex, int markerIndex, float &x, float &y);

Description

• This function saves predistorted 2D location of a centroid.

• This data is basically where the camera would see a marker if there were no effects from lens distortions. For most of our cameras/lenses, this location is only a few pixels different from the distorted position obtained by the TT_CameraMarker function.

• Returns true when successfully saving the values.

Function Input

• Camera index (int)

• Marker (centroid) index (int)

• Declared variable for saving x location (float)

• Declared variable for saving y location (float)

Function Output

• True/False (bool)

C++ Example

for (int i = 0; i < TT_CameraCount(); i++)
{
	float x, y, pdx, pdy;

	int centroidcount = TT_CameraMarkerCount(i);
	printf("Camera #%d detected centroids: %d\n", i, centroidcount);

	for (int j = 0; j < centroidcount; j++)
	{
		TT_CameraMarker(i, j, x, y);
		TT_CameraMarkerPredistorted(i, j, pdx, pdy);
		printf("\t#%d\t(%.2f, %.2f)\tPredistorted:\t(%.2f, %.2f)\n", j, x, y, pdx, pdy);
	}
}

TT_SetCameraSettings

Configures camera settings.

bool		TT_SetCameraSettings(int cameraIndex, int videoType, int exposure, int threshold, int intensity);

Description

• This function sets camera settings for a camera device specified by its index number.

• Input setting parameters must agree with the supported ranges (or video types) of the camera model.

• A negative return value indicates the function did not complete the task.

• Each of the video types is indicated with the following integers. Supported video types may vary for different camera models. Please check the Data Recording page for more information on which image processing modes are available in different models.

• Segment Mode: 0

• Raw Grayscale Mode: 1

• Object Mode: 2

• Precision Mode: 4

• MJPEG Mode: 6

• Valid exposure ranges depend on the framerate settings:

• Prime series and Flex 13: 1 ~ maximum time gap between the frames, which is approximately (1 / framerate) - 200 microseconds with about 200 microseconds gap for protection.

• Flex3 and Duo/Trio tracking bars: 1 ~ 480 scanlines.

• Valid threshold ranges: 0 - 255

• Valid intensity ranges: 0 - 15

Function Input

• Camera index (int)

• Video type (int)

• Camera exposure (int)

• Pixel threshold (int)

• IR light intensity (int)

• For more information on the camera settings, refer to the Devices pane page.

Function Output

• True/False (bool)

C++ Example

//== Changing exposure and threshold settings for all of the cameras ==//
int intensity = 10;
int exposure = 200;
int totalCamera = TT_CameraCount();

for (int i = 0; i < totalCamera; i++)
{
	TT_SetCameraSettings(i, TT_CameraVideoType(i), exposure, TT_CameraThreshold(i), intensity);
	printf("Camera #%d: \tIntensity: %d\t Exposure: %d\tThreshold: %d\n",
		i, TT_CameraIntensity(i), TT_CameraExposure(i), TT_CameraThreshold(i));
}

TT_SetCameraFrameRate

Sets camera frame rate.

bool		TT_SetCameraFrameRate(int cameraIndex, int framerate);

Description

• This function sets the frame rate of a camera.

• Returns true if it successfully adjusts the settings.

• Note that this function may assign a frame rate setting that is out of the supported range. Check to make sure inputted frame rates are supported.

Function Input

• Camera index (int)

• Frame rate (int)

Function Output

• True/False (bool).

C++ Example

//== Changing frame rate of all cameras ==//
int framerate = 120;

for (int i = 0; i < TT_CameraCount(); i++)
{
	TT_SetCameraFrameRate(i, framerate);
	printf("\t%s\tFrame Rate: %d", TT_CameraName(i), TT_CameraFrameRate(i));
}

TT_CameraFrameRate

Gets configured frame rate of a camera.

int		TT_CameraFrameRate(int cameraIndex);

Description

• This function returns frame rate of a camera.

Function Input

• Camera index (int)

Function Output

• Camera frame rate (int)

C++ Example

//== Checking camera settings ==//
int totalCamera = TT_CameraCount();

for (int i = 0; i < totalCamera; i++)
{
	printf("Camera #%d:\tFPS: %d\tIntensity: %d\tExposure: %d\tThreshold: %d\n",
		i, TT_CameraFrameRate(i), TT_CameraIntensity(i), TT_CameraExposure(i),
		TT_CameraThreshold(i));
}

TT_CameraVideoType