New effort to embrace faceAPI 3.2.6

git-svn-id: svn+ssh://svn.code.sf.net/p/facetracknoir/code@54 19e81ba0-9b1a-49c3-bd6c-561e1906d5fb

1 files changed, 460 insertions, 0 deletions

diff --git a/faceAPI/main.cpp b/faceAPI/main.cpp
new file mode 100644
index 00000000..0aeb9bca
--- /dev/null
+++ b/faceAPI/main.cpp
@@ -0,0 +1,460 @@
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+//

+//	FaceAPI2FSX program implementation

+//	Merges the old CockpitCamera.cpp and TestAppConsole.cpp into a single file

+//

+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+

+//Precompiled header

+#include "stdafx.h"

+

+//FaceAPI headers

+#include "sm_api.h"

+#include "utils.h"

+

+//local headers

+#include "build_options.h"

+

+//namespaces

+using namespace std;

+using namespace sm::faceapi::samplecode;

+

+//

+// Definitions for the Shared Memory to send the data to FaceTrackNoIR

+//

+static const char* SM_MM_DATA = "SM_SharedMem";

+static const char* SM_FACEAPI = "SM_FaceAPI";

+static const char* SM_MUTEX = "SM_Mutex";

+

+struct TFaceData {

+	int DataID;

+	smEngineHeadPoseData new_pose;

+};

+typedef TFaceData * PFaceData;

+

+struct SMMemMap {

+	int command;					// Command from FaceTrackNoIR

+	int status;						// Status from faceAPI

+	TFaceData data;

+	HANDLE handle;

+};

+typedef SMMemMap * PSMMemMap;

+

+//

+// global variables

+//

+HANDLE					hSMMemMap = NULL;

+SMMemMap				*pMemData;

+HANDLE					hSMMutex;

+smEngineHeadPoseData	new_head_pose;

+

+//enums

+enum GROUP_ID

+{

+    GROUP0=0,

+};

+

+enum EVENT_ID

+{

+	EVENT_PING=0,

+	EVENT_INIT,

+};

+

+enum INPUT_ID

+{

+    INPUT0=0,

+};

+

+//function definitions

+void	updateHeadPose(smEngineHeadPoseData* temp_head_pose);

+bool	SMCreateMapping();

+

+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+//

+//FaceAPI function implementations

+//

+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

+

+void STDCALL receiveLogMessage(void *, const char *buf, int /*buf_len*/)

+{

+    Lock lock(g_mutex); // serialize logging calls from different threads to avoid garbled output.

+    //cout << string(buf);

+}

+

+// Callback function for face-data

+void STDCALL receiveFaceData(void *, smEngineFaceData face_data, smCameraVideoFrame video_frame)

+{   

+    Lock lock(g_mutex);

+

+    // Get info including data pointer to original image from camera

+    smImageInfo video_frame_image_info;

+    THROW_ON_ERROR(smImageGetInfo(video_frame.image_handle, &video_frame_image_info)); // reentrant, so ok

+

+    // video_frame_image_info.plane_addr[*] now point to the image memory planes. 

+    // The memory is only valid until the end of this routine unless you call smImageAddRef(video_frame.image_handle).

+    // So you can deep copy the image data here, or use smImageAddRef() and just copy the pointer.

+    // If you use smImageAddRef() you are responsible for calling smImageDestroy() to avoid a memory leak later.

+

+    // In this callback you will typically want to copy the smEngineFaceData data into your own data-structure.

+    // Since the smEngineFaceData contains multiple pod types copying it is not atomic and 

+    // a mutex is required to avoid the race-condition with any thread simultaneously 

+    // reading from your data-structure.

+    // Such a race condition will not crash your code but will create weird noise in the tracking data.

+

+    if (g_do_face_data_printing)

+    {

+        //cout << video_frame << " " << face_data;

+

+        // Save any face texture to a PNG file

+        if (face_data.texture)

+        {

+            // Create a unique filename

+            std::stringstream filename;

+            filename << "face_" << video_frame.frame_num << ".png";        

+            // Try saving to a file

+            if (saveToPNGFile(filename.str(), face_data.texture->image_info) == SM_API_OK)

+            {

+                cout << "Saved face-texture to " << filename.str() << std::endl;

+            }

+            else

+            {

+                cout << "Error saving face-texture to " << filename.str() << std::endl;

+            }

+        }

+    }

+}

+

+// Callback function for head-pose

+void STDCALL receiveHeadPose(void *,smEngineHeadPoseData head_pose, smCameraVideoFrame video_frame)

+{

+    Lock lock(g_mutex);

+

+    // Get info including data pointer to original image from camera

+    smImageInfo video_frame_image_info;

+    THROW_ON_ERROR(smImageGetInfo(video_frame.image_handle, &video_frame_image_info)); // reentrant, so ok

+

+    // video_frame_image_info.plane_addr[*] now point to the image memory planes. 

+    // The memory is only valid until the end of this routine unless you call smImageAddRef(video_frame.image_handle).

+    // So you can deep copy the image data here, or use smImageAddRef() and just copy the pointer.

+    // If you use smImageAddRef() you are responsible for calling smImageDestroy() to avoid a memory leak later.

+

+    // In this callback you will typically want to copy the smEngineFaceData data into your own data-structure.

+    // Since the smEngineFaceData contains multiple pod types copying it is not atomic and 

+    // a mutex is required to avoid the race-condition with any thread simultaneously 

+    // reading from your data-structure.

+    // Such a race condition will not crash your code but will create weird noise in the tracking data.

+

+    if (g_do_head_pose_printing)

+    {

+        //cout << video_frame << " " << head_pose << std::endl;

+    }

+

+	//make a copy of the new head pose data and send it to simconnect

+	//when we get a simmconnect frame event the new offset will be applied to the camera

+	updateHeadPose(&head_pose);

+}

+

+// Create the first available camera detected on the system, and return its handle

+smCameraHandle createFirstCamera()

+{

+    // Detect cameras

+    smCameraInfoList info_list;

+    THROW_ON_ERROR(smCameraCreateInfoList(&info_list));

+

+    if (info_list.num_cameras == 0)

+    {

+        throw runtime_error("No cameras were detected");

+    }

+    else

+    {

+        cout << "The followings cameras were detected: " << endl;

+        for (int i=0; i<info_list.num_cameras; ++i)

+        {

+            char buf[1024];

+            cout << "    " << i << ". Type: " << info_list.info[i].type;

+            THROW_ON_ERROR(smStringWriteBuffer(info_list.info[i].model,buf,1024));

+            cout << " Model: " << string(buf);

+            cout << " Instance: " << info_list.info[i].instance_index << endl;

+            // Print all the possible formats for the camera

+            for (int j=0; j<info_list.info[i].num_formats; j++)

+            {

+                smCameraVideoFormat video_format = info_list.info[i].formats[j];

+                cout << "     - Format: ";

+                cout << " res (" << video_format.res.w << "," << video_format.res.h << ")";

+                cout << " image code " << video_format.format;

+                cout << " framerate " << video_format.framerate << "(hz)";

+                cout << " upside-down? " << (video_format.is_upside_down ? "y":"n") << endl;

+            }

+        }

+    }

+

+    // Create the first camera detected on the system

+    smCameraHandle camera_handle = 0;

+    THROW_ON_ERROR(smCameraCreate(&info_list.info[0],   // Use first camera

+                                  0,                    // Use default settings for lens

+                                  &camera_handle));

+

+    // Destroy the info list

+    smCameraDestroyInfoList(&info_list);

+

+    return camera_handle;

+}

+

+// The main function: setup a tracking engine and show a video window, then loop on the keyboard.

+void run()

+{

+    // Capture control-C

+//    signal(SIGINT, CtrlCHandler);

+

+    // Make the console window a bit bigger (see utils.h)

+    initConsole();

+

+	#ifdef _DEBUG

+    // Log API debugging information to a file

+    THROW_ON_ERROR(smLoggingSetFileOutputEnable(SM_API_TRUE));

+

+    // Hook up log message callback

+    THROW_ON_ERROR(smLoggingRegisterCallback(0,receiveLogMessage));

+	#endif

+

+    // Get the version

+    int major, minor, maint;

+    THROW_ON_ERROR(smAPIVersion(&major, &minor, &maint));

+    cout << endl << "API VERSION: " << major << "." << minor << "." << maint << "." << endl << endl;

+    // Print detailed license info

+    char *buff;

+    int size;

+    THROW_ON_ERROR(smAPILicenseInfoString(0,&size,SM_API_TRUE));

+    buff = new char[size];

+    THROW_ON_ERROR(smAPILicenseInfoString(buff,&size,SM_API_TRUE));

+    cout << "LICENSE: " << buff << endl << endl;

+    // Determine if non-commercial restrictions apply

+    const bool non_commercial_license = smAPINonCommercialLicense() == SM_API_TRUE;

+

+    // Initialize the API

+    THROW_ON_ERROR(smAPIInit());

+

+	#ifdef _DEBUG

+    // Get the path to the logfile

+    smStringHandle logfile_path_handle = 0;

+    THROW_ON_ERROR(smStringCreate(&logfile_path_handle));

+    THROW_ON_ERROR(smLoggingGetPath(logfile_path_handle));

+    int buf_len = 0;

+    unsigned short *buf = 0;

+    THROW_ON_ERROR(smStringGetBufferW(logfile_path_handle,(wchar_t **)&buf,&buf_len));

+    wcout << "Writing log to file: " << wstring((wchar_t *)buf) << endl;

+    THROW_ON_ERROR(smStringDestroy(&logfile_path_handle));

+	#endif

+

+    // Register the WDM category of cameras

+    THROW_ON_ERROR(smCameraRegisterType(SM_API_CAMERA_TYPE_WDM));

+

+    smEngineHandle engine_handle = 0;

+    smCameraHandle camera_handle = 0;

+    if (non_commercial_license)

+    {

+        // Create a new Head-Tracker engine that uses the camera

+        THROW_ON_ERROR(smEngineCreate(SM_API_ENGINE_LATEST_HEAD_TRACKER,&engine_handle));

+    }

+    else

+    {

+        // Print out a list of connected cameras, and choose the first camera on the system

+        camera_handle = createFirstCamera();

+        // Create a new Head-Tracker engine that uses the camera

+        THROW_ON_ERROR(smEngineCreateWithCamera(SM_API_ENGINE_LATEST_HEAD_TRACKER,camera_handle,&engine_handle));

+    }

+

+    // Check license for particular engine version (always ok for non-commercial license)

+    const bool engine_licensed = smEngineIsLicensed(engine_handle) == SM_API_OK;

+

+    cout << "-----------------------------------------------------" << endl;

+    cout << "Press 'r' to restart tracking" << endl;

+    cout << "Press 'a' to toggle auto-restart mode" << endl;

+    if (!non_commercial_license)

+    {

+        cout << "Press 'l' to toggle lip-tracking" << endl;

+        cout << "Press 'e' to toggle eyebrow-tracking" << endl;

+    }

+    if (engine_licensed)

+    {

+        cout << "Press 'h' to toggle printing of head-pose data" << endl;

+        cout << "Press 'f' to toggle printing of face-landmark data" << endl;

+    }

+    cout << "Press '1' to toggle face coordinate frame axes" << endl;

+    cout << "Press '2' to toggle performance info" << endl;

+    cout << "Press '3' to toggle face mask" << endl;

+    cout << "Press '4' to toggle face landmarks" << endl;

+    cout << "Press CTRL-C or 'q' to quit" << endl;

+    cout << "-----------------------------------------------------" << endl;

+

+    // Hook up callbacks to receive output data from engine.

+    // These functions will return errors if the engine is not licensed.

+    if (engine_licensed)

+    {

+		#if (USE_HEADPOSE_CALLBACK==1)

+		#pragma message("Using Headpose Callback")

+        THROW_ON_ERROR(smHTRegisterHeadPoseCallback(engine_handle,0,receiveHeadPose));

+		#endif

+        if (!non_commercial_license)

+        {

+            THROW_ON_ERROR(smHTRegisterFaceDataCallback(engine_handle,0,receiveFaceData));

+        }

+    }

+    else

+    {

+        cout << "Engine is not licensed, cannot obtain any output data." << endl;

+    }

+

+    if (!non_commercial_license)

+    {

+        // Enable lip and eyebrow tracking

+        THROW_ON_ERROR(smHTSetLipTrackingEnabled(engine_handle,SM_API_TRUE));

+        THROW_ON_ERROR(smHTSetEyebrowTrackingEnabled(engine_handle,SM_API_TRUE));

+    }

+

+    // Create and show a video-display window

+    smVideoDisplayHandle video_display_handle = 0;

+    THROW_ON_ERROR(smVideoDisplayCreate(engine_handle,&video_display_handle,0,TRUE));

+

+    // Setup the VideoDisplay

+    THROW_ON_ERROR(smVideoDisplaySetFlags(video_display_handle,g_overlay_flags));

+

+    // Get the handle to the window and change the title to "Hello World"

+    smWindowHandle win_handle = 0;

+    THROW_ON_ERROR(smVideoDisplayGetWindowHandle(video_display_handle,&win_handle));    

+    SetWindowText(win_handle, _T("faceAPI Video-widget"));

+

+    // Start tracking

+    THROW_ON_ERROR(smEngineStart(engine_handle));

+

+    // Loop on the keyboard

+    while (processKeyPress(engine_handle, video_display_handle))

+    {

+        // Read and print the current head-pose (if not using the callback mechanism)

+		#if (USE_HEADPOSE_CALLBACK==0)

+		#pragma message("Polling Headpose Manually")

+		if (engine_licensed)

+		{

+			smEngineHeadPoseData head_pose;

+			Lock lock(g_mutex);

+			

+			THROW_ON_ERROR(smHTCurrentHeadPose(engine_handle,&head_pose));

+			if (g_do_head_pose_printing)

+			{

+				std::cout << head_pose << std::endl;

+			}

+

+		}

+		#endif

+

+        // NOTE: If you have a windows event loop in your program you 

+        // will not need to call smAPIProcessEvents(). This manually redraws the video window.

+        THROW_ON_ERROR(smAPIProcessEvents());

+

+        // Prevent CPU overload in our simple loop.

+        const int frame_period_ms = 10;

+        Sleep(frame_period_ms); 

+    }

+

+    // Destroy engine

+    THROW_ON_ERROR(smEngineDestroy(&engine_handle));

+    // Destroy video display

+    THROW_ON_ERROR(smVideoDisplayDestroy(&video_display_handle));

+} // run()

+

+// Application entry point

+int _tmain(int /*argc*/, _TCHAR** /*argv*/)

+{

+	OutputDebugString(_T("_tmain() says: Starting Function\n"));

+

+	try

+    {

+		if (SMCreateMapping()) {

+			run();

+		}

+    }

+    catch (exception &e)

+    {

+        cerr << e.what() << endl;

+    }

+

+    return smAPIQuit();

+}

+

+//

+// This is called exactly once for each FaceAPI callback and must be within an exclusive lock

+//

+void updateHeadPose(smEngineHeadPoseData* temp_head_pose)

+{

+	//

+	// Check if the pointer is OK and wait for the Mutex.

+	//

+	if ( (pMemData != NULL) && (WaitForSingleObject(hSMMutex, 100) == WAIT_OBJECT_0) ) {

+

+		//

+		// Copy the Raw measurements directly to the client.

+		//

+		if (temp_head_pose->confidence > 0.0f)

+		{

+			memcpy(&pMemData->data,temp_head_pose,sizeof(smEngineHeadPoseData));

+		}

+		ReleaseMutex(hSMMutex);

+	}

+

+};

+

+//

+// Create a memory-mapping to the faceAPI data.

+// It contains the tracking data, a command-code from FaceTrackNoIR

+//

+//

+bool SMCreateMapping()

+{

+	OutputDebugString(_T("FTCreateMapping says: Starting Function\n"));

+

+	//

+	// A FileMapping is used to create 'shared memory' between the faceAPI and FaceTrackNoIR.

+	//

+	// Try to create a FileMapping to the Shared Memory.

+	// If one already exists: close it.

+	//

+	hSMMemMap = CreateFileMappingA( INVALID_HANDLE_VALUE , 00 , PAGE_READWRITE , 0 , 

+		                           sizeof( TFaceData ) + sizeof( HANDLE ) + 100, 

+								   (LPCSTR) SM_MM_DATA );

+

+	if ( hSMMemMap != 0 ) {

+		OutputDebugString(_T("FTCreateMapping says: FileMapping Created!\n"));

+	}

+

+	if ( ( hSMMemMap != 0 ) && ( (long) GetLastError == ERROR_ALREADY_EXISTS ) ) {

+		CloseHandle( hSMMemMap );

+		hSMMemMap = 0;

+	}

+

+	//

+	// Create a new FileMapping, Read/Write access

+	//

+	hSMMemMap = OpenFileMappingA( FILE_MAP_ALL_ACCESS , false , (LPCSTR) SM_MM_DATA );

+	if ( ( hSMMemMap != 0 ) ) {

+		OutputDebugString(_T("FTCreateMapping says: FileMapping Created again...\n"));

+		pMemData = (SMMemMap *) MapViewOfFile(hSMMemMap, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(TFaceData));

+		if (pMemData != NULL) {

+			OutputDebugString(_T("FTCreateMapping says: MapViewOfFile OK.\n"));

+//			pMemData->handle = handle;	// The game uses the handle, to send a message that the Program-Name was set!

+		}

+	    hSMMutex = CreateMutexA(NULL, false, SM_MUTEX);

+	}

+	else {

+		OutputDebugString(_T("Error creating Shared Memory for faceAPI\n"));

+        cerr << "Error creating Shared Memory for faceAPI" << endl;

+		return false;

+	}

+

+	//if (pMemData != NULL) {

+	//	pMemData->data.DataID = 1;

+	//	pMemData->data.CamWidth = 100;

+	//	pMemData->data.CamHeight = 250;

+	//}

+

+	return true;

+}