From 1da2d0e71a03296a40b49316b5e23986de823a75 Mon Sep 17 00:00:00 2001
From: Stéphane Lenclud <github@lenclud.com>
Date: Sun, 3 Feb 2019 12:28:12 +0100
Subject: Kinect: Renaming a few files.

---
 tracker-kinect-face/kinect_face_tracker.cpp | 569 ++++++++++++++++++++++++++++
 1 file changed, 569 insertions(+)
 create mode 100644 tracker-kinect-face/kinect_face_tracker.cpp

(limited to 'tracker-kinect-face/kinect_face_tracker.cpp')

diff --git a/tracker-kinect-face/kinect_face_tracker.cpp b/tracker-kinect-face/kinect_face_tracker.cpp
new file mode 100644
index 00000000..ccac8aa9
--- /dev/null
+++ b/tracker-kinect-face/kinect_face_tracker.cpp
@@ -0,0 +1,569 @@
+
+
+#include "kinect_face_tracker.h"
+
+#include <QLayout>
+#include <QPainter>
+
+
+
+///
+bool IsValidRect(const RectI& aRect)
+{
+	if (aRect.Bottom != 0)
+	{
+		return true;
+	}
+
+	if (aRect.Left != 0)
+	{
+		return true;
+	}
+
+	if (aRect.Right != 0)
+	{
+		return true;
+	}
+
+	if (aRect.Top != 0)
+	{
+		return true;
+	}
+
+	return false;
+}
+
+///
+bool IsNullVetor(const Vector4& aVector)
+{
+	if (aVector.w != 0)
+	{
+		return false;
+	}
+
+	if (aVector.x != 0)
+	{
+		return false;
+	}
+
+	if (aVector.y != 0)
+	{
+		return false;
+	}
+
+	if (aVector.z != 0)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+///
+bool IsNullPoint(const CameraSpacePoint& aPoint)
+{
+	if (aPoint.X != 0)
+	{
+		return false;
+	}
+
+	if (aPoint.Y != 0)
+	{
+		return false;
+	}
+
+	if (aPoint.Z != 0)
+	{
+		return false;
+	}
+
+	return true;
+}
+
+
+KinectFaceTracker::KinectFaceTracker():
+	m_pKinectSensor(nullptr),
+	m_pCoordinateMapper(nullptr),
+	m_pColorFrameReader(nullptr),
+	m_pColorRGBX(nullptr),
+	m_pBodyFrameReader(nullptr),
+	iLastFacePosition{0,0,0},
+	iFacePositionCenter{ 0,0,0 },
+	iFacePosition{ 0,0,0 },
+	iLastFaceRotation{ 0,0,0 },
+	iFaceRotationCenter{ 0,0,0 },
+	iFaceRotation{ 0,0,0 }
+{
+	m_pFaceFrameSource = nullptr;
+	m_pFaceFrameReader = nullptr;
+
+	// create heap storage for color pixel data in RGBX format
+	m_pColorRGBX = new RGBQUAD[cColorWidth * cColorHeight];
+}
+
+KinectFaceTracker::~KinectFaceTracker()
+{
+	if (m_pColorRGBX)
+	{
+		delete[] m_pColorRGBX;
+		m_pColorRGBX = nullptr;
+	}
+
+	// clean up Direct2D
+	//SafeRelease(m_pD2DFactory);
+
+	// done with face sources and readers
+	SafeRelease(m_pFaceFrameSource);
+	SafeRelease(m_pFaceFrameReader);
+
+	// done with body frame reader
+	SafeRelease(m_pBodyFrameReader);
+
+	// done with color frame reader
+	SafeRelease(m_pColorFrameReader);
+
+	// done with coordinate mapper
+	SafeRelease(m_pCoordinateMapper);
+
+	// close the Kinect Sensor
+	if (m_pKinectSensor)
+	{
+		m_pKinectSensor->Close();
+	}
+
+	SafeRelease(m_pKinectSensor);
+}
+
+module_status KinectFaceTracker::start_tracker(QFrame* aFrame)
+{
+	t.start();
+
+	if (SUCCEEDED(InitializeDefaultSensor()))
+	{
+		// Setup our video preview widget
+		iVideoWidget = std::make_unique<cv_video_widget>(aFrame);
+		iLayout = std::make_unique<QHBoxLayout>(aFrame);
+		iLayout->setContentsMargins(0, 0, 0, 0);
+		iLayout->addWidget(iVideoWidget.get());
+		aFrame->setLayout(iLayout.get());
+		//video_widget->resize(video_frame->width(), video_frame->height());
+		aFrame->show();
+
+		return status_ok();
+	}
+
+	return error("Kinect init failed!");
+}
+
+#ifdef EMIT_NAN
+#   include <cstdlib>
+#endif
+
+bool KinectFaceTracker::center()
+{
+	// Mark our center
+	iFacePositionCenter = iFacePosition;
+	iFaceRotationCenter = iFaceRotation;
+	return true;
+}
+
+
+void KinectFaceTracker::data(double *data)
+{
+	const double dt = t.elapsed_seconds();
+	t.start();
+
+	Update();
+
+	ExtractFaceRotationInDegrees(&iFaceRotationQuaternion, &iFaceRotation.X, &iFaceRotation.Y, &iFaceRotation.Z);
+
+	//Check if data is valid
+	if (!IsNullPoint(iFacePosition) && !IsNullPoint(iFaceRotation))
+	{
+		// We have valid tracking retain position and rotation
+		iLastFacePosition = iFacePosition;
+		iLastFaceRotation = iFaceRotation;
+	}
+	
+	// Feed our framework our last valid position and rotation
+	data[0] = (iLastFacePosition.X - iFacePositionCenter.X) * 100; // Convert to centimer to be in a range that suites OpenTrack.
+	data[1] = (iLastFacePosition.Y - iFacePositionCenter.Y) * 100;
+	data[2] = (iLastFacePosition.Z - iFacePositionCenter.Z) * 100;
+
+	// Yaw, Picth, Roll
+	data[3] = -(iLastFaceRotation.X - iFaceRotationCenter.X); // Invert to be compatible with ED out-of-the-box
+	data[4] = (iLastFaceRotation.Y - iFaceRotationCenter.Y);
+	data[5] = (iLastFaceRotation.Z - iFaceRotationCenter.Z);
+}
+
+
+/// <summary>
+/// Converts rotation quaternion to Euler angles 
+/// And then maps them to a specified range of values to control the refresh rate
+/// </summary>
+/// <param name="pQuaternion">face rotation quaternion</param>
+/// <param name="pPitch">rotation about the X-axis</param>
+/// <param name="pYaw">rotation about the Y-axis</param>
+/// <param name="pRoll">rotation about the Z-axis</param>
+void KinectFaceTracker::ExtractFaceRotationInDegrees(const Vector4* pQuaternion, float* pYaw, float* pPitch, float* pRoll)
+{
+	double x = pQuaternion->x;
+	double y = pQuaternion->y;
+	double z = pQuaternion->z;
+	double w = pQuaternion->w;
+
+	// convert face rotation quaternion to Euler angles in degrees		
+	double dPitch, dYaw, dRoll;
+	dPitch = atan2(2 * (y * z + w * x), w * w - x * x - y * y + z * z) / M_PI * 180.0;
+	dYaw = asin(2 * (w * y - x * z)) / M_PI * 180.0;
+	dRoll = atan2(2 * (x * y + w * z), w * w + x * x - y * y - z * z) / M_PI * 180.0;
+
+	// clamp rotation values in degrees to a specified range of values to control the refresh rate
+	/*
+	double increment = c_FaceRotationIncrementInDegrees;
+	*pPitch = static_cast<int>(floor((dPitch + increment/2.0 * (dPitch > 0 ? 1.0 : -1.0)) / increment) * increment);
+	*pYaw = static_cast<int>(floor((dYaw + increment/2.0 * (dYaw > 0 ? 1.0 : -1.0)) / increment) * increment);
+	*pRoll = static_cast<int>(floor((dRoll + increment/2.0 * (dRoll > 0 ? 1.0 : -1.0)) / increment) * increment);
+	*/
+
+	*pPitch = dPitch;
+	*pYaw = dYaw;
+	*pRoll = dRoll;
+}
+
+
+
+/// <summary>
+/// Initializes the default Kinect sensor
+/// </summary>
+/// <returns>S_OK on success else the failure code</returns>
+HRESULT KinectFaceTracker::InitializeDefaultSensor()
+{
+	HRESULT hr;
+
+	// Get and open Kinect sensor
+	hr = GetDefaultKinectSensor(&m_pKinectSensor);
+	if (SUCCEEDED(hr))
+	{
+		hr = m_pKinectSensor->Open();
+	}
+
+	// TODO: check if we still need that guy
+	if (SUCCEEDED(hr))
+	{
+		hr = m_pKinectSensor->get_CoordinateMapper(&m_pCoordinateMapper);
+	}
+
+	// Create color frame reader	
+	if (SUCCEEDED(hr))
+	{
+		UniqueInterface<IColorFrameSource> colorFrameSource;
+		hr = m_pKinectSensor->get_ColorFrameSource(colorFrameSource.PtrPtr());
+		colorFrameSource.Reset();
+
+		if (SUCCEEDED(hr))
+		{
+			hr = colorFrameSource->OpenReader(&m_pColorFrameReader);
+		}
+	}
+		
+	// Create body frame reader	
+	if (SUCCEEDED(hr))
+	{
+		UniqueInterface<IBodyFrameSource> bodyFrameSource;
+		hr = m_pKinectSensor->get_BodyFrameSource(bodyFrameSource.PtrPtr());
+		bodyFrameSource.Reset();
+
+		if (SUCCEEDED(hr))
+		{
+			hr = bodyFrameSource->OpenReader(&m_pBodyFrameReader);
+		}
+	}
+
+	// Create HD face frame source
+	if (SUCCEEDED(hr))
+	{
+		// create the face frame source by specifying the required face frame features
+		hr = CreateHighDefinitionFaceFrameSource(m_pKinectSensor, &m_pFaceFrameSource);
+	}
+
+	// Create HD face frame reader
+	if (SUCCEEDED(hr))
+	{
+		// open the corresponding reader
+		hr = m_pFaceFrameSource->OpenReader(&m_pFaceFrameReader);
+	}
+
+	return hr;
+}
+
+/// <summary>
+/// Main processing function
+/// </summary>
+void KinectFaceTracker::Update()
+{
+	if (!m_pColorFrameReader || !m_pBodyFrameReader)
+	{
+		return;
+	}
+
+	IColorFrame* pColorFrame = nullptr;
+	HRESULT hr = m_pColorFrameReader->AcquireLatestFrame(&pColorFrame);
+
+	if (SUCCEEDED(hr))
+	{
+		INT64 nTime = 0;
+		IFrameDescription* pFrameDescription = nullptr;
+		int nWidth = 0;
+		int nHeight = 0;
+		ColorImageFormat imageFormat = ColorImageFormat_None;
+		UINT nBufferSize = 0;
+		RGBQUAD *pBuffer = nullptr;
+
+		hr = pColorFrame->get_RelativeTime(&nTime);
+
+		if (SUCCEEDED(hr))
+		{
+			hr = pColorFrame->get_FrameDescription(&pFrameDescription);
+		}
+
+		if (SUCCEEDED(hr))
+		{
+			hr = pFrameDescription->get_Width(&nWidth);
+		}
+
+		if (SUCCEEDED(hr))
+		{
+			hr = pFrameDescription->get_Height(&nHeight);
+		}
+
+		if (SUCCEEDED(hr))
+		{
+			hr = pColorFrame->get_RawColorImageFormat(&imageFormat);
+		}
+
+		if (SUCCEEDED(hr))
+		{
+			// Fetch color buffer
+			if (imageFormat == ColorImageFormat_Rgba)
+			{
+				hr = pColorFrame->AccessRawUnderlyingBuffer(&nBufferSize, reinterpret_cast<BYTE**>(&pBuffer));
+			}
+			else if (m_pColorRGBX)
+			{
+				pBuffer = m_pColorRGBX;
+				nBufferSize = cColorWidth * cColorHeight * sizeof(RGBQUAD);
+				hr = pColorFrame->CopyConvertedFrameDataToArray(nBufferSize, reinterpret_cast<BYTE*>(pBuffer), ColorImageFormat_Rgba);				
+			}
+			else
+			{
+				hr = E_FAIL;
+			}
+
+		}
+
+		if (SUCCEEDED(hr))
+		{
+			//DrawStreams(nTime, pBuffer, nWidth, nHeight);
+			ProcessFaces();
+		}
+
+		if (SUCCEEDED(hr))
+		{			
+			// Setup our image 
+			QImage image((const unsigned char*)pBuffer, cColorWidth, cColorHeight, sizeof(RGBQUAD)*cColorWidth, QImage::Format_RGBA8888);
+			if (IsValidRect(iFaceBox))
+			{
+				// Draw our face bounding box
+				QPainter painter(&image);
+				painter.setBrush(Qt::NoBrush);
+				painter.setPen(QPen(Qt::red, 8));
+				painter.drawRect(iFaceBox.Left, iFaceBox.Top, iFaceBox.Right - iFaceBox.Left, iFaceBox.Bottom - iFaceBox.Top);
+				bool bEnd = painter.end();
+			}
+
+			// Update our video preview
+			iVideoWidget->update_image(image);
+		}
+
+		SafeRelease(pFrameDescription);
+	}
+
+	SafeRelease(pColorFrame);
+}
+
+
+/// <summary>
+/// Updates body data
+/// </summary>
+/// <param name="ppBodies">pointer to the body data storage</param>
+/// <returns>indicates success or failure</returns>
+HRESULT KinectFaceTracker::UpdateBodyData(IBody** ppBodies)
+{
+	HRESULT hr = E_FAIL;
+
+	if (m_pBodyFrameReader != nullptr)
+	{
+		IBodyFrame* pBodyFrame = nullptr;
+		hr = m_pBodyFrameReader->AcquireLatestFrame(&pBodyFrame);
+		if (SUCCEEDED(hr))
+		{
+			hr = pBodyFrame->GetAndRefreshBodyData(BODY_COUNT, ppBodies);
+		}
+		SafeRelease(pBodyFrame);
+	}
+
+	return hr;
+}
+
+
+
+/// <summary>
+/// Processes new face frames
+/// </summary>
+void KinectFaceTracker::ProcessFaces()
+{
+	HRESULT hr;
+	IBody* ppBodies[BODY_COUNT] = { 0 };
+	bool bHaveBodyData = SUCCEEDED(UpdateBodyData(ppBodies));
+
+	if (!bHaveBodyData)
+	{
+		return;
+	}
+
+	// TODO: Select closest body
+	// Just use the first body we find
+	BOOLEAN tracked;
+	int i = 0;
+	while (i < BODY_COUNT)
+	{
+		hr = ppBodies[i]->get_IsTracked(&tracked);
+		UINT64 trackingId = 0;
+
+		if (SUCCEEDED(hr) && tracked)
+		{
+			hr = ppBodies[i]->get_TrackingId(&trackingId);
+
+			if (SUCCEEDED(hr))
+			{
+				// Tell our face source to use the given body id
+				hr = m_pFaceFrameSource->put_TrackingId(trackingId);
+				break;
+			}
+
+		}
+
+		i++;
+	}
+
+
+	// iterate through each face reader
+	for (int iFace = 0; iFace < BODY_COUNT; ++iFace)
+	{
+		// retrieve the latest face frame from this reader
+		IHighDefinitionFaceFrame* pFaceFrame = nullptr;
+		hr = m_pFaceFrameReader->AcquireLatestFrame(&pFaceFrame);
+
+		BOOLEAN bFaceTracked = false;
+		if (SUCCEEDED(hr) && nullptr != pFaceFrame)
+		{
+			// check if a valid face is tracked in this face frame
+			hr = pFaceFrame->get_IsTrackingIdValid(&bFaceTracked);
+		}
+
+		if (SUCCEEDED(hr))
+		{
+			if (bFaceTracked)
+			{
+				//OutputDebugStringA("Tracking face!\n");
+
+				//IFaceFrameResult* pFaceFrameResult = nullptr;
+				IFaceAlignment* pFaceAlignment = nullptr;
+				CreateFaceAlignment(&pFaceAlignment); // TODO: check return?
+				//D2D1_POINT_2F faceTextLayout;				
+
+				//hr = pFaceFrame->get_FaceFrameResult(&pFaceFrameResult);
+
+				hr = pFaceFrame->GetAndRefreshFaceAlignmentResult(pFaceAlignment);
+
+				// need to verify if pFaceFrameResult contains data before trying to access it
+				if (SUCCEEDED(hr) && pFaceAlignment != nullptr)
+				{
+					hr = pFaceAlignment->get_FaceBoundingBox(&iFaceBox);
+					//pFaceFrameResult->get_FaceBoundingBoxInColorSpace();
+
+					if (SUCCEEDED(hr))
+					{
+						//hr = pFaceFrameResult->GetFacePointsInColorSpace(FacePointType::FacePointType_Count, facePoints);
+						hr = pFaceAlignment->get_HeadPivotPoint(&iFacePosition);
+					}
+
+					if (SUCCEEDED(hr))
+					{
+						//hr = pFaceFrameResult->get_FaceRotationQuaternion(&faceRotation);
+						hr = pFaceAlignment->get_FaceOrientation(&iFaceRotationQuaternion);
+					}
+
+					if (SUCCEEDED(hr))
+					{
+						//hr = pFaceFrameResult->GetFaceProperties(FaceProperty::FaceProperty_Count, faceProperties);
+					}
+
+					if (SUCCEEDED(hr))
+					{
+						//hr = GetFaceTextPositionInColorSpace(ppBodies[0], &faceTextLayout);
+					}
+
+					if (SUCCEEDED(hr))
+					{
+						// draw face frame results
+						//m_pDrawDataStreams->DrawFaceFrameResults(0, &faceBox, facePoints, &faceRotation, faceProperties, &faceTextLayout);
+					}
+				}
+
+				SafeRelease(pFaceAlignment);
+			}
+			else
+			{
+				// face tracking is not valid - attempt to fix the issue
+				// a valid body is required to perform this step
+				if (bHaveBodyData)
+				{
+					// check if the corresponding body is tracked 
+					// if this is true then update the face frame source to track this body
+					IBody* pBody = ppBodies[iFace];
+					if (pBody != nullptr)
+					{
+						BOOLEAN bTracked = false;
+						hr = pBody->get_IsTracked(&bTracked);
+
+						UINT64 bodyTId;
+						if (SUCCEEDED(hr) && bTracked)
+						{
+							// get the tracking ID of this body
+							hr = pBody->get_TrackingId(&bodyTId);
+							if (SUCCEEDED(hr))
+							{
+								// update the face frame source with the tracking ID
+								m_pFaceFrameSource->put_TrackingId(bodyTId);
+							}
+						}
+					}
+				}
+			}
+		}
+
+		SafeRelease(pFaceFrame);
+	}
+
+	if (bHaveBodyData)
+	{
+		for (int i = 0; i < _countof(ppBodies); ++i)
+		{
+			SafeRelease(ppBodies[i]);
+		}
+	}
+}
+
+
-- 
cgit v1.2.3


From 57285c2269f53bc7ae61f40289edc9083432bc8a Mon Sep 17 00:00:00 2001
From: Stéphane Lenclud <github@lenclud.com>
Date: Sun, 3 Feb 2019 13:39:45 +0100
Subject: Kinect: Better body look-up algorithm that should allow someone to
 look over your shoulder without the tracker getting confused.

---
 tracker-kinect-face/kinect_face_tracker.cpp | 239 ++++++++++++++++------------
 tracker-kinect-face/kinect_face_tracker.h   |   5 +
 2 files changed, 143 insertions(+), 101 deletions(-)

(limited to 'tracker-kinect-face/kinect_face_tracker.cpp')

diff --git a/tracker-kinect-face/kinect_face_tracker.cpp b/tracker-kinect-face/kinect_face_tracker.cpp
index ccac8aa9..b7ccfecf 100644
--- a/tracker-kinect-face/kinect_face_tracker.cpp
+++ b/tracker-kinect-face/kinect_face_tracker.cpp
@@ -417,141 +417,178 @@ HRESULT KinectFaceTracker::UpdateBodyData(IBody** ppBodies)
 }
 
 
+float VectorLengthSquared(CameraSpacePoint point)
+{
+	float lenghtSquared = pow(point.X, 2) + pow(point.Y, 2) + pow(point.Z, 2);
+
+	//result = Math.Sqrt(result);
+	return lenghtSquared;
+}
+
+//
+// Finds the closest body from the sensor if any
+//
+IBody* KinectFaceTracker::FindClosestBody(IBody** aBodies)
+{
+	IBody* result = nullptr;
+	float closestBodyDistance = std::numeric_limits<float>::max();
+
+	for(int i=0;i<BODY_COUNT;i++)
+	{
+		BOOLEAN tracked;
+		aBodies[i]->get_IsTracked(&tracked);
+
+		if (tracked)
+		{
+			Joint joints[JointType_Count];
+			HRESULT hr = aBodies[i]->GetJoints(JointType_Count,joints);
+			if (FAILED(hr))
+			{
+				continue;
+			}
+
+			auto currentLocation = joints[JointType_SpineBase].Position;
+			auto currentDistance = VectorLengthSquared(currentLocation);
+
+			if (result == nullptr || currentDistance < closestBodyDistance)
+			{
+				result = aBodies[i];
+				closestBodyDistance = currentDistance;
+			}
+		}
+	}
+
+	return result;
+}
+
+//
+// Search our list of body for the one matching our id
+//
+IBody* KinectFaceTracker::FindTrackedBodyById(IBody** aBodies, UINT64 aTrackingId)
+{
+	float closestBodyDistance = std::numeric_limits<float>::max();
+	
+	for (int i = 0; i < BODY_COUNT; i++)
+	{
+		BOOLEAN tracked;
+		HRESULT hr = aBodies[i]->get_IsTracked(&tracked);
+
+		if (tracked)
+		{
+			if (SUCCEEDED(hr) && tracked)
+			{
+				UINT64 trackingId = 0;
+				hr = aBodies[i]->get_TrackingId(&trackingId);
+
+				if (SUCCEEDED(hr) && aTrackingId == trackingId)
+				{
+					return aBodies[i];
+				}
+			}
+		}
+	}
+
+	return nullptr;
+}
+
 
 /// <summary>
 /// Processes new face frames
 /// </summary>
 void KinectFaceTracker::ProcessFaces()
 {
-	HRESULT hr;
-	IBody* ppBodies[BODY_COUNT] = { 0 };
-	bool bHaveBodyData = SUCCEEDED(UpdateBodyData(ppBodies));
-
+	HRESULT hr=0;
+	IBody* bodies[BODY_COUNT] = { 0 }; // Each bodies will need to be released
+	bool bHaveBodyData = SUCCEEDED(UpdateBodyData(bodies));
 	if (!bHaveBodyData)
 	{
 		return;
 	}
 
-	// TODO: Select closest body
-	// Just use the first body we find
-	BOOLEAN tracked;
-	int i = 0;
-	while (i < BODY_COUNT)
+	// Try keep tracking the same body
+	IBody* body = FindTrackedBodyById(bodies, iTrackingId);
+	if (body == nullptr)
 	{
-		hr = ppBodies[i]->get_IsTracked(&tracked);
-		UINT64 trackingId = 0;
-
-		if (SUCCEEDED(hr) && tracked)
+		// The body we were tracking is gone, try tracking the closest body if any
+		body = FindClosestBody(bodies);
+		if (body != nullptr)
 		{
-			hr = ppBodies[i]->get_TrackingId(&trackingId);
-
+			// Update our face source with our new body id
+			hr = body->get_TrackingId(&iTrackingId);
 			if (SUCCEEDED(hr))
 			{
 				// Tell our face source to use the given body id
-				hr = m_pFaceFrameSource->put_TrackingId(trackingId);
-				break;
+				hr = m_pFaceFrameSource->put_TrackingId(iTrackingId);
+				//OutputDebugStringA("Tracking new body!\n");
 			}
-
 		}
-
-		i++;
 	}
 
-
-	// iterate through each face reader
-	for (int iFace = 0; iFace < BODY_COUNT; ++iFace)
+	// retrieve the latest face frame from this reader
+	IHighDefinitionFaceFrame* pFaceFrame = nullptr;
+	if (SUCCEEDED(hr))
 	{
-		// retrieve the latest face frame from this reader
-		IHighDefinitionFaceFrame* pFaceFrame = nullptr;
 		hr = m_pFaceFrameReader->AcquireLatestFrame(&pFaceFrame);
+	}
 
-		BOOLEAN bFaceTracked = false;
-		if (SUCCEEDED(hr) && nullptr != pFaceFrame)
-		{
-			// check if a valid face is tracked in this face frame
-			hr = pFaceFrame->get_IsTrackingIdValid(&bFaceTracked);
-		}
+	BOOLEAN bFaceTracked = false;
+	if (SUCCEEDED(hr) && nullptr != pFaceFrame)
+	{
+		// check if a valid face is tracked in this face frame
+		hr = pFaceFrame->get_IsTrackingIdValid(&bFaceTracked);
+	}
 
-		if (SUCCEEDED(hr))
+	if (SUCCEEDED(hr))
+	{
+		if (bFaceTracked)
 		{
-			if (bFaceTracked)
+			//OutputDebugStringA("Tracking face!\n");
+
+			//IFaceFrameResult* pFaceFrameResult = nullptr;
+			IFaceAlignment* pFaceAlignment = nullptr;
+			CreateFaceAlignment(&pFaceAlignment); // TODO: check return?
+			//D2D1_POINT_2F faceTextLayout;				
+
+			//hr = pFaceFrame->get_FaceFrameResult(&pFaceFrameResult);
+
+			hr = pFaceFrame->GetAndRefreshFaceAlignmentResult(pFaceAlignment);
+
+			// need to verify if pFaceFrameResult contains data before trying to access it
+			if (SUCCEEDED(hr) && pFaceAlignment != nullptr)
 			{
-				//OutputDebugStringA("Tracking face!\n");
+				hr = pFaceAlignment->get_FaceBoundingBox(&iFaceBox);
+				//pFaceFrameResult->get_FaceBoundingBoxInColorSpace();
 
-				//IFaceFrameResult* pFaceFrameResult = nullptr;
-				IFaceAlignment* pFaceAlignment = nullptr;
-				CreateFaceAlignment(&pFaceAlignment); // TODO: check return?
-				//D2D1_POINT_2F faceTextLayout;				
+				if (SUCCEEDED(hr))
+				{
+					//hr = pFaceFrameResult->GetFacePointsInColorSpace(FacePointType::FacePointType_Count, facePoints);
+					hr = pFaceAlignment->get_HeadPivotPoint(&iFacePosition);
+				}
 
-				//hr = pFaceFrame->get_FaceFrameResult(&pFaceFrameResult);
+				if (SUCCEEDED(hr))
+				{
+					//hr = pFaceFrameResult->get_FaceRotationQuaternion(&faceRotation);
+					hr = pFaceAlignment->get_FaceOrientation(&iFaceRotationQuaternion);
+				}
 
-				hr = pFaceFrame->GetAndRefreshFaceAlignmentResult(pFaceAlignment);
+				if (SUCCEEDED(hr))
+				{
+					//hr = pFaceFrameResult->GetFaceProperties(FaceProperty::FaceProperty_Count, faceProperties);
+				}
 
-				// need to verify if pFaceFrameResult contains data before trying to access it
-				if (SUCCEEDED(hr) && pFaceAlignment != nullptr)
+				if (SUCCEEDED(hr))
 				{
-					hr = pFaceAlignment->get_FaceBoundingBox(&iFaceBox);
-					//pFaceFrameResult->get_FaceBoundingBoxInColorSpace();
-
-					if (SUCCEEDED(hr))
-					{
-						//hr = pFaceFrameResult->GetFacePointsInColorSpace(FacePointType::FacePointType_Count, facePoints);
-						hr = pFaceAlignment->get_HeadPivotPoint(&iFacePosition);
-					}
-
-					if (SUCCEEDED(hr))
-					{
-						//hr = pFaceFrameResult->get_FaceRotationQuaternion(&faceRotation);
-						hr = pFaceAlignment->get_FaceOrientation(&iFaceRotationQuaternion);
-					}
-
-					if (SUCCEEDED(hr))
-					{
-						//hr = pFaceFrameResult->GetFaceProperties(FaceProperty::FaceProperty_Count, faceProperties);
-					}
-
-					if (SUCCEEDED(hr))
-					{
-						//hr = GetFaceTextPositionInColorSpace(ppBodies[0], &faceTextLayout);
-					}
-
-					if (SUCCEEDED(hr))
-					{
-						// draw face frame results
-						//m_pDrawDataStreams->DrawFaceFrameResults(0, &faceBox, facePoints, &faceRotation, faceProperties, &faceTextLayout);
-					}
+					//hr = GetFaceTextPositionInColorSpace(ppBodies[0], &faceTextLayout);
 				}
 
-				SafeRelease(pFaceAlignment);
-			}
-			else
-			{
-				// face tracking is not valid - attempt to fix the issue
-				// a valid body is required to perform this step
-				if (bHaveBodyData)
+				if (SUCCEEDED(hr))
 				{
-					// check if the corresponding body is tracked 
-					// if this is true then update the face frame source to track this body
-					IBody* pBody = ppBodies[iFace];
-					if (pBody != nullptr)
-					{
-						BOOLEAN bTracked = false;
-						hr = pBody->get_IsTracked(&bTracked);
-
-						UINT64 bodyTId;
-						if (SUCCEEDED(hr) && bTracked)
-						{
-							// get the tracking ID of this body
-							hr = pBody->get_TrackingId(&bodyTId);
-							if (SUCCEEDED(hr))
-							{
-								// update the face frame source with the tracking ID
-								m_pFaceFrameSource->put_TrackingId(bodyTId);
-							}
-						}
-					}
+					// draw face frame results
+					//m_pDrawDataStreams->DrawFaceFrameResults(0, &faceBox, facePoints, &faceRotation, faceProperties, &faceTextLayout);
 				}
 			}
+
+			SafeRelease(pFaceAlignment);
 		}
 
 		SafeRelease(pFaceFrame);
@@ -559,9 +596,9 @@ void KinectFaceTracker::ProcessFaces()
 
 	if (bHaveBodyData)
 	{
-		for (int i = 0; i < _countof(ppBodies); ++i)
+		for (int i = 0; i < _countof(bodies); ++i)
 		{
-			SafeRelease(ppBodies[i]);
+			SafeRelease(bodies[i]);
 		}
 	}
 }
diff --git a/tracker-kinect-face/kinect_face_tracker.h b/tracker-kinect-face/kinect_face_tracker.h
index 220a126f..de71f081 100644
--- a/tracker-kinect-face/kinect_face_tracker.h
+++ b/tracker-kinect-face/kinect_face_tracker.h
@@ -74,6 +74,8 @@ private:
 	void ProcessFaces();
 	HRESULT UpdateBodyData(IBody** ppBodies);
 	void ExtractFaceRotationInDegrees(const Vector4* pQuaternion, float* pPitch, float* pYaw, float* pRoll);
+	static IBody* FindClosestBody(IBody** aBodies);
+	static IBody* FindTrackedBodyById(IBody** aBodies,UINT64 aTrackingId);
 
 	// Current Kinect
 	IKinectSensor*         m_pKinectSensor;
@@ -110,4 +112,7 @@ private:
 	//
 	std::unique_ptr<cv_video_widget> iVideoWidget;
 	std::unique_ptr<QLayout> iLayout;
+
+	// Id of the body currently being tracked
+	UINT64 iTrackingId = 0;
 };
-- 
cgit v1.2.3


From ecaf8b6403f57e5813190f4ae1b89780c45339d8 Mon Sep 17 00:00:00 2001
From: Stéphane Lenclud <github@lenclud.com>
Date: Sun, 3 Feb 2019 13:45:03 +0100
Subject: Kinect: Fixing tracking validity check.

---
 tracker-kinect-face/kinect_face_tracker.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'tracker-kinect-face/kinect_face_tracker.cpp')

diff --git a/tracker-kinect-face/kinect_face_tracker.cpp b/tracker-kinect-face/kinect_face_tracker.cpp
index b7ccfecf..51990693 100644
--- a/tracker-kinect-face/kinect_face_tracker.cpp
+++ b/tracker-kinect-face/kinect_face_tracker.cpp
@@ -167,7 +167,9 @@ bool KinectFaceTracker::center()
 	return true;
 }
 
-
+//
+//
+//
 void KinectFaceTracker::data(double *data)
 {
 	const double dt = t.elapsed_seconds();
@@ -178,7 +180,7 @@ void KinectFaceTracker::data(double *data)
 	ExtractFaceRotationInDegrees(&iFaceRotationQuaternion, &iFaceRotation.X, &iFaceRotation.Y, &iFaceRotation.Z);
 
 	//Check if data is valid
-	if (!IsNullPoint(iFacePosition) && !IsNullPoint(iFaceRotation))
+	if (IsValidRect(iFaceBox))
 	{
 		// We have valid tracking retain position and rotation
 		iLastFacePosition = iFacePosition;
-- 
cgit v1.2.3


From 58cc914eb84cb4257904e401a91c0cd5fe3aebf7 Mon Sep 17 00:00:00 2001
From: Stéphane Lenclud <github@lenclud.com>
Date: Sun, 3 Feb 2019 14:11:00 +0100
Subject: Kinect: CMake adjustments following code review.

---
 tracker-kinect-face/CMakeLists.txt          | 20 +++++++++++---------
 tracker-kinect-face/kinect_face_tracker.cpp |  5 +++++
 2 files changed, 16 insertions(+), 9 deletions(-)

(limited to 'tracker-kinect-face/kinect_face_tracker.cpp')

diff --git a/tracker-kinect-face/CMakeLists.txt b/tracker-kinect-face/CMakeLists.txt
index e12534b2..690f82e7 100644
--- a/tracker-kinect-face/CMakeLists.txt
+++ b/tracker-kinect-face/CMakeLists.txt
@@ -4,18 +4,18 @@ if (WIN32)
 	if(OpenCV_FOUND)
 		# Setup cache variable to Kinect SDK path
 		if(DEFINED ENV{KINECTSDK20_DIR})
-			set(KINECTSDK20_DIR $ENV{KINECTSDK20_DIR} CACHE PATH $ENV{KINECTSDK20_DIR})
+			set(SDK_KINECT20 $ENV{KINECTSDK20_DIR} CACHE PATH $ENV{KINECTSDK20_DIR})
 		else()
-			set(KINECTSDK20_DIR $ENV{KINECTSDK20_DIR} CACHE PATH "")
+			set(SDK_KINECT20 $ENV{KINECTSDK20_DIR} CACHE PATH "")
 		endif()
 
 		# If we have a valid SDK path, try build that tracker
-		if(EXISTS ${KINECTSDK20_DIR})
+		if(EXISTS ${SDK_KINECT20})
 			# Register our module
 			otr_module(tracker-kinect-face)
 
 			# Add include path to Kinect SDK 
-			target_include_directories(opentrack-tracker-kinect-face SYSTEM PUBLIC ${KINECTSDK20_DIR}/inc)
+			target_include_directories(opentrack-tracker-kinect-face SYSTEM PUBLIC "${SDK_KINECT20}/inc")
 	
 			# Check processor architecture 
 			if(CMAKE_SIZEOF_VOID_P EQUAL 4)
@@ -23,18 +23,20 @@ if (WIN32)
 				set (kinect-arch-dir "x86")
 			elseif(CMAKE_SIZEOF_VOID_P EQUAL 8)
 				# 64 bits
-				set (kinect-arch-dir "x64")		
+				set (kinect-arch-dir "x64")
+			else()
+				message(FATAL_ERROR "Kinect: architecture not supported!")
 			endif()
 	
 			# Link against Kinect SDK libraries
-			target_link_libraries(opentrack-tracker-kinect-face ${KINECTSDK20_DIR}/lib/${kinect-arch-dir}/Kinect20.lib ${KINECTSDK20_DIR}/lib/${kinect-arch-dir}/Kinect20.Face.lib)
+			target_link_libraries(opentrack-tracker-kinect-face "${SDK_KINECT20}/lib/${kinect-arch-dir}/Kinect20.lib" "${SDK_KINECT20}/lib/${kinect-arch-dir}/Kinect20.Face.lib")
 			# Link against OpenCV stuff, needed for video preview
 			target_link_libraries(opentrack-tracker-kinect-face opencv_imgproc opentrack-cv opencv_core)
 
 			# Install Kinect Face DLL
-			install(FILES ${KINECTSDK20_DIR}/Redist/Face/${kinect-arch-dir}/Kinect20.Face.dll DESTINATION ./modules/ PERMISSIONS ${opentrack-perms-exec})
+			install(FILES "${SDK_KINECT20}/Redist/Face/${kinect-arch-dir}/Kinect20.Face.dll" DESTINATION "./modules/" PERMISSIONS ${opentrack-perms-exec})
 			# Install Kinect Face Database
-			install(DIRECTORY ${KINECTSDK20_DIR}/Redist/Face/${kinect-arch-dir}/NuiDatabase DESTINATION ./modules/)
-		endif(EXISTS ${KINECTSDK20_DIR})
+			install(DIRECTORY "${SDK_KINECT20}/Redist/Face/${kinect-arch-dir}/NuiDatabase" DESTINATION "./modules/")
+		endif(EXISTS ${SDK_KINECT20})
 	endif(OpenCV_FOUND)
 endif(WIN32)
\ No newline at end of file
diff --git a/tracker-kinect-face/kinect_face_tracker.cpp b/tracker-kinect-face/kinect_face_tracker.cpp
index 51990693..0b7775bc 100644
--- a/tracker-kinect-face/kinect_face_tracker.cpp
+++ b/tracker-kinect-face/kinect_face_tracker.cpp
@@ -186,6 +186,11 @@ void KinectFaceTracker::data(double *data)
 		iLastFacePosition = iFacePosition;
 		iLastFaceRotation = iFaceRotation;
 	}
+	else
+	{
+		//TODO: after like 5s without tracking reset position to zero
+		//TODO: Instead of hardcoding that delay add it to our settings
+	}
 	
 	// Feed our framework our last valid position and rotation
 	data[0] = (iLastFacePosition.X - iFacePositionCenter.X) * 100; // Convert to centimer to be in a range that suites OpenTrack.
-- 
cgit v1.2.3


From 7397242cb156ae0d1e942fba9d209b8627a2072e Mon Sep 17 00:00:00 2001
From: Stéphane Lenclud <github@lenclud.com>
Date: Sun, 3 Feb 2019 14:17:38 +0100
Subject: Kinect: Removing dead code.

---
 tracker-kinect-face/kinect_face_tracker.cpp | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'tracker-kinect-face/kinect_face_tracker.cpp')

diff --git a/tracker-kinect-face/kinect_face_tracker.cpp b/tracker-kinect-face/kinect_face_tracker.cpp
index 0b7775bc..40571a28 100644
--- a/tracker-kinect-face/kinect_face_tracker.cpp
+++ b/tracker-kinect-face/kinect_face_tracker.cpp
@@ -155,9 +155,6 @@ module_status KinectFaceTracker::start_tracker(QFrame* aFrame)
 	return error("Kinect init failed!");
 }
 
-#ifdef EMIT_NAN
-#   include <cstdlib>
-#endif
 
 bool KinectFaceTracker::center()
 {
-- 
cgit v1.2.3


From 4508be24ef4adc4dac0c40ef316b07da75765b77 Mon Sep 17 00:00:00 2001
From: Stéphane Lenclud <github@lenclud.com>
Date: Sun, 3 Feb 2019 15:03:57 +0100
Subject: Kinect: Limit actual frame rate to 30Hz. Fixing settings dialog.

---
 tracker-kinect-face/kinect_face_settings.cpp | 16 +++++++------
 tracker-kinect-face/kinect_face_settings.h   | 10 ++++----
 tracker-kinect-face/kinect_face_settings.ui  | 10 ++++----
 tracker-kinect-face/kinect_face_tracker.cpp  | 35 +++++++++++++++++-----------
 tracker-kinect-face/kinect_face_tracker.h    |  4 +++-
 tracker-kinect-face/lang/nl_NL.ts            |  8 +++----
 tracker-kinect-face/lang/ru_RU.ts            |  8 +++----
 tracker-kinect-face/lang/stub.ts             |  8 +++----
 tracker-kinect-face/lang/zh_CN.ts            |  8 +++----
 9 files changed, 59 insertions(+), 48 deletions(-)

(limited to 'tracker-kinect-face/kinect_face_tracker.cpp')

diff --git a/tracker-kinect-face/kinect_face_settings.cpp b/tracker-kinect-face/kinect_face_settings.cpp
index 53aada06..238a3da6 100644
--- a/tracker-kinect-face/kinect_face_settings.cpp
+++ b/tracker-kinect-face/kinect_face_settings.cpp
@@ -17,29 +17,31 @@
 #include <QDebug>
 
 
-test_dialog::test_dialog()
+KinectFaceSettings::KinectFaceSettings()
 {
     ui.setupUi(this);
 
     connect(ui.buttonBox, &QDialogButtonBox::clicked, [this](QAbstractButton* btn) {
-        if (btn == ui.buttonBox->button(QDialogButtonBox::Abort))
-            // NOLINTNEXTLINE
-            *(volatile int*)nullptr = 0;
+		if (btn == ui.buttonBox->button(QDialogButtonBox::Abort))
+		{
+			// NOLINTNEXTLINE
+			//*(volatile int*)nullptr = 0;
+		}
     });
 
     connect(ui.buttonBox, SIGNAL(accepted()), this, SLOT(doOK()));
     connect(ui.buttonBox, SIGNAL(rejected()), this, SLOT(doCancel()));
 }
 
-void test_dialog::doOK()
+void KinectFaceSettings::doOK()
 {
     //s.b->save();
     close();
 }
 
-void test_dialog::doCancel()
+void KinectFaceSettings::doCancel()
 {
     close();
 }
 
-OPENTRACK_DECLARE_TRACKER(KinectFaceTracker, test_dialog, test_metadata)
+OPENTRACK_DECLARE_TRACKER(KinectFaceTracker, KinectFaceSettings, KinectFaceMetadata)
diff --git a/tracker-kinect-face/kinect_face_settings.h b/tracker-kinect-face/kinect_face_settings.h
index 0f8c170b..647aa754 100644
--- a/tracker-kinect-face/kinect_face_settings.h
+++ b/tracker-kinect-face/kinect_face_settings.h
@@ -1,16 +1,16 @@
 #pragma once
-#include "ui_test.h"
+#include "ui_kinect_face_settings.h"
 #include "compat/macros.hpp"
 #include "api/plugin-api.hpp"
 
 
-class test_dialog : public ITrackerDialog
+class KinectFaceSettings : public ITrackerDialog
 {
     Q_OBJECT
 
-    Ui::test_ui ui;
+    Ui::KinectFaceUi ui;
 public:
-    test_dialog();
+    KinectFaceSettings();
     void register_tracker(ITracker *) override {}
     void unregister_tracker() override {}
 private slots:
@@ -18,7 +18,7 @@ private slots:
     void doCancel();
 };
 
-class test_metadata : public Metadata
+class KinectFaceMetadata : public Metadata
 {
     Q_OBJECT
 
diff --git a/tracker-kinect-face/kinect_face_settings.ui b/tracker-kinect-face/kinect_face_settings.ui
index 509eb819..a6192d9b 100644
--- a/tracker-kinect-face/kinect_face_settings.ui
+++ b/tracker-kinect-face/kinect_face_settings.ui
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>test_ui</class>
- <widget class="QWidget" name="test_ui">
+ <class>KinectFaceUi</class>
+ <widget class="QWidget" name="KinectFaceUi">
   <property name="windowModality">
    <enum>Qt::NonModal</enum>
   </property>
@@ -14,11 +14,11 @@
    </rect>
   </property>
   <property name="windowTitle">
-   <string>Sine wave</string>
+   <string>Kinect Face Tracker</string>
   </property>
   <property name="windowIcon">
    <iconset>
-    <normaloff>../gui/images/opentrack.png</normaloff>../gui/images/opentrack.png</iconset>
+    <normaloff>:/images/kinect.png</normaloff>:/images/kinect.png</iconset>
   </property>
   <property name="layoutDirection">
    <enum>Qt::LeftToRight</enum>
@@ -36,7 +36,7 @@
       </sizepolicy>
      </property>
      <property name="text">
-      <string>Pressing &quot;Abort&quot; will immediately crash the application.</string>
+      <string>Start OpenTrack to check if Kinect Face Tracker is working.</string>
      </property>
     </widget>
    </item>
diff --git a/tracker-kinect-face/kinect_face_tracker.cpp b/tracker-kinect-face/kinect_face_tracker.cpp
index 40571a28..ab568f1e 100644
--- a/tracker-kinect-face/kinect_face_tracker.cpp
+++ b/tracker-kinect-face/kinect_face_tracker.cpp
@@ -170,25 +170,32 @@ bool KinectFaceTracker::center()
 void KinectFaceTracker::data(double *data)
 {
 	const double dt = t.elapsed_seconds();
-	t.start();
-
-	Update();
-
-	ExtractFaceRotationInDegrees(&iFaceRotationQuaternion, &iFaceRotation.X, &iFaceRotation.Y, &iFaceRotation.Z);
 
-	//Check if data is valid
-	if (IsValidRect(iFaceBox))
+	const double KMinDelayInSeconds = 1.0 / 30.0; // Pointless running faster than Kinect hardware itself
+	if (dt > KMinDelayInSeconds)
 	{
-		// We have valid tracking retain position and rotation
-		iLastFacePosition = iFacePosition;
-		iLastFaceRotation = iFaceRotation;
+		t.start(); // Reset our timer
+		//OutputDebugStringA("Updating frame!\n");
+		Update();
+		ExtractFaceRotationInDegrees(&iFaceRotationQuaternion, &iFaceRotation.X, &iFaceRotation.Y, &iFaceRotation.Z);
+		//Check if data is valid
+		if (IsValidRect(iFaceBox))
+		{
+			// We have valid tracking retain position and rotation
+			iLastFacePosition = iFacePosition;
+			iLastFaceRotation = iFaceRotation;
+		}
+		else
+		{
+			//TODO: after like 5s without tracking reset position to zero
+			//TODO: Instead of hardcoding that delay add it to our settings
+		}
 	}
 	else
 	{
-		//TODO: after like 5s without tracking reset position to zero
-		//TODO: Instead of hardcoding that delay add it to our settings
+		//OutputDebugStringA("Skipping frame!\n");
 	}
-	
+		
 	// Feed our framework our last valid position and rotation
 	data[0] = (iLastFacePosition.X - iFacePositionCenter.X) * 100; // Convert to centimer to be in a range that suites OpenTrack.
 	data[1] = (iLastFacePosition.Y - iFacePositionCenter.Y) * 100;
@@ -344,7 +351,7 @@ void KinectFaceTracker::Update()
 		if (SUCCEEDED(hr))
 		{
 			hr = pColorFrame->get_RawColorImageFormat(&imageFormat);
-		}
+		}		
 
 		if (SUCCEEDED(hr))
 		{
diff --git a/tracker-kinect-face/kinect_face_tracker.h b/tracker-kinect-face/kinect_face_tracker.h
index de71f081..9f75507d 100644
--- a/tracker-kinect-face/kinect_face_tracker.h
+++ b/tracker-kinect-face/kinect_face_tracker.h
@@ -51,7 +51,9 @@ private:
 };
 
 
-
+//
+//
+//
 class KinectFaceTracker : public ITracker
 {
 public:
diff --git a/tracker-kinect-face/lang/nl_NL.ts b/tracker-kinect-face/lang/nl_NL.ts
index f4fe07d8..a0a737ee 100644
--- a/tracker-kinect-face/lang/nl_NL.ts
+++ b/tracker-kinect-face/lang/nl_NL.ts
@@ -2,20 +2,20 @@
 <!DOCTYPE TS>
 <TS version="2.1" language="nl_NL">
 <context>
-    <name>test_metadata</name>
+    <name>KinectFaceMetadata</name>
     <message>
         <source>Kinect Face 0.1</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
-    <name>test_ui</name>
+    <name>KinectFaceUi</name>
     <message>
-        <source>Sine wave</source>
+        <source>Kinect Face Tracker</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Pressing &quot;Abort&quot; will immediately crash the application.</source>
+        <source>Start OpenTrack to check if Kinect Face Tracker is working.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
diff --git a/tracker-kinect-face/lang/ru_RU.ts b/tracker-kinect-face/lang/ru_RU.ts
index d4108ed3..72f91367 100644
--- a/tracker-kinect-face/lang/ru_RU.ts
+++ b/tracker-kinect-face/lang/ru_RU.ts
@@ -2,20 +2,20 @@
 <!DOCTYPE TS>
 <TS version="2.1" language="ru_RU">
 <context>
-    <name>test_metadata</name>
+    <name>KinectFaceMetadata</name>
     <message>
         <source>Kinect Face 0.1</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
-    <name>test_ui</name>
+    <name>KinectFaceUi</name>
     <message>
-        <source>Sine wave</source>
+        <source>Kinect Face Tracker</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Pressing &quot;Abort&quot; will immediately crash the application.</source>
+        <source>Start OpenTrack to check if Kinect Face Tracker is working.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
diff --git a/tracker-kinect-face/lang/stub.ts b/tracker-kinect-face/lang/stub.ts
index f82903a3..055ec4e1 100644
--- a/tracker-kinect-face/lang/stub.ts
+++ b/tracker-kinect-face/lang/stub.ts
@@ -2,20 +2,20 @@
 <!DOCTYPE TS>
 <TS version="2.1">
 <context>
-    <name>test_metadata</name>
+    <name>KinectFaceMetadata</name>
     <message>
         <source>Kinect Face 0.1</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
-    <name>test_ui</name>
+    <name>KinectFaceUi</name>
     <message>
-        <source>Sine wave</source>
+        <source>Kinect Face Tracker</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Pressing &quot;Abort&quot; will immediately crash the application.</source>
+        <source>Start OpenTrack to check if Kinect Face Tracker is working.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
diff --git a/tracker-kinect-face/lang/zh_CN.ts b/tracker-kinect-face/lang/zh_CN.ts
index f82903a3..055ec4e1 100644
--- a/tracker-kinect-face/lang/zh_CN.ts
+++ b/tracker-kinect-face/lang/zh_CN.ts
@@ -2,20 +2,20 @@
 <!DOCTYPE TS>
 <TS version="2.1">
 <context>
-    <name>test_metadata</name>
+    <name>KinectFaceMetadata</name>
     <message>
         <source>Kinect Face 0.1</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
-    <name>test_ui</name>
+    <name>KinectFaceUi</name>
     <message>
-        <source>Sine wave</source>
+        <source>Kinect Face Tracker</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Pressing &quot;Abort&quot; will immediately crash the application.</source>
+        <source>Start OpenTrack to check if Kinect Face Tracker is working.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
-- 
cgit v1.2.3


From 1f82111bbee522c4d31372f9f64b903a08ccc11e Mon Sep 17 00:00:00 2001
From: Stéphane Lenclud <github@lenclud.com>
Date: Sun, 3 Feb 2019 15:20:36 +0100
Subject: Kinect: Don't do video preview when not needed.

---
 tracker-kinect-face/kinect_face_tracker.cpp | 76 ++++++++++++++++-------------
 1 file changed, 43 insertions(+), 33 deletions(-)

(limited to 'tracker-kinect-face/kinect_face_tracker.cpp')

diff --git a/tracker-kinect-face/kinect_face_tracker.cpp b/tracker-kinect-face/kinect_face_tracker.cpp
index ab568f1e..5663de0f 100644
--- a/tracker-kinect-face/kinect_face_tracker.cpp
+++ b/tracker-kinect-face/kinect_face_tracker.cpp
@@ -5,6 +5,7 @@
 #include <QLayout>
 #include <QPainter>
 
+#include "compat/check-visible.hpp"
 
 
 ///
@@ -308,6 +309,8 @@ HRESULT KinectFaceTracker::InitializeDefaultSensor()
 	return hr;
 }
 
+
+
 /// <summary>
 /// Main processing function
 /// </summary>
@@ -353,50 +356,57 @@ void KinectFaceTracker::Update()
 			hr = pColorFrame->get_RawColorImageFormat(&imageFormat);
 		}		
 
-		if (SUCCEEDED(hr))
-		{
-			// Fetch color buffer
-			if (imageFormat == ColorImageFormat_Rgba)
-			{
-				hr = pColorFrame->AccessRawUnderlyingBuffer(&nBufferSize, reinterpret_cast<BYTE**>(&pBuffer));
-			}
-			else if (m_pColorRGBX)
-			{
-				pBuffer = m_pColorRGBX;
-				nBufferSize = cColorWidth * cColorHeight * sizeof(RGBQUAD);
-				hr = pColorFrame->CopyConvertedFrameDataToArray(nBufferSize, reinterpret_cast<BYTE*>(pBuffer), ColorImageFormat_Rgba);				
-			}
-			else
-			{
-				hr = E_FAIL;
-			}
-
-		}
-
 		if (SUCCEEDED(hr))
 		{
 			//DrawStreams(nTime, pBuffer, nWidth, nHeight);
 			ProcessFaces();
 		}
 
-		if (SUCCEEDED(hr))
-		{			
-			// Setup our image 
-			QImage image((const unsigned char*)pBuffer, cColorWidth, cColorHeight, sizeof(RGBQUAD)*cColorWidth, QImage::Format_RGBA8888);
-			if (IsValidRect(iFaceBox))
+		if (check_is_visible())
+		{
+			//OutputDebugStringA("Widget visible!\n");
+			// If our widget is visible we feed it our frame
+			if (SUCCEEDED(hr))
 			{
-				// Draw our face bounding box
-				QPainter painter(&image);
-				painter.setBrush(Qt::NoBrush);
-				painter.setPen(QPen(Qt::red, 8));
-				painter.drawRect(iFaceBox.Left, iFaceBox.Top, iFaceBox.Right - iFaceBox.Left, iFaceBox.Bottom - iFaceBox.Top);
-				bool bEnd = painter.end();
+				// Fetch color buffer
+				if (imageFormat == ColorImageFormat_Rgba)
+				{
+					hr = pColorFrame->AccessRawUnderlyingBuffer(&nBufferSize, reinterpret_cast<BYTE**>(&pBuffer));
+				}
+				else if (m_pColorRGBX)
+				{
+					pBuffer = m_pColorRGBX;
+					nBufferSize = cColorWidth * cColorHeight * sizeof(RGBQUAD);
+					hr = pColorFrame->CopyConvertedFrameDataToArray(nBufferSize, reinterpret_cast<BYTE*>(pBuffer), ColorImageFormat_Rgba);
+				}
+				else
+				{
+					hr = E_FAIL;
+				}
+
+			}
+
+			if (SUCCEEDED(hr))
+			{
+				// Setup our image 
+				QImage image((const unsigned char*)pBuffer, cColorWidth, cColorHeight, sizeof(RGBQUAD)*cColorWidth, QImage::Format_RGBA8888);
+				if (IsValidRect(iFaceBox))
+				{
+					// Draw our face bounding box
+					QPainter painter(&image);
+					painter.setBrush(Qt::NoBrush);
+					painter.setPen(QPen(Qt::red, 8));
+					painter.drawRect(iFaceBox.Left, iFaceBox.Top, iFaceBox.Right - iFaceBox.Left, iFaceBox.Bottom - iFaceBox.Top);
+					bool bEnd = painter.end();
+				}
+
+				// Update our video preview
+				iVideoWidget->update_image(image);
 			}
 
-			// Update our video preview
-			iVideoWidget->update_image(image);
 		}
 
+
 		SafeRelease(pFrameDescription);
 	}
 
-- 
cgit v1.2.3


From 0011f928da90b6b7116f3c633a0a0cb855d75024 Mon Sep 17 00:00:00 2001
From: Stéphane Lenclud <github@lenclud.com>
Date: Sun, 3 Feb 2019 15:35:16 +0100
Subject: Kinect: Tracker code cleaning.

---
 tracker-kinect-face/kinect_face_tracker.cpp | 86 +++++++++++++----------------
 tracker-kinect-face/kinect_face_tracker.h   | 38 ++++++-------
 2 files changed, 56 insertions(+), 68 deletions(-)

(limited to 'tracker-kinect-face/kinect_face_tracker.cpp')

diff --git a/tracker-kinect-face/kinect_face_tracker.cpp b/tracker-kinect-face/kinect_face_tracker.cpp
index 5663de0f..9f4f133b 100644
--- a/tracker-kinect-face/kinect_face_tracker.cpp
+++ b/tracker-kinect-face/kinect_face_tracker.cpp
@@ -7,6 +7,8 @@
 
 #include "compat/check-visible.hpp"
 
+static const int KColorWidth = 1920;
+static const int KColorHeight = 1080;
 
 ///
 bool IsValidRect(const RectI& aRect)
@@ -82,62 +84,48 @@ bool IsNullPoint(const CameraSpacePoint& aPoint)
 }
 
 
-KinectFaceTracker::KinectFaceTracker():
-	m_pKinectSensor(nullptr),
-	m_pCoordinateMapper(nullptr),
-	m_pColorFrameReader(nullptr),
-	m_pColorRGBX(nullptr),
-	m_pBodyFrameReader(nullptr),
-	iLastFacePosition{0,0,0},
-	iFacePositionCenter{ 0,0,0 },
-	iFacePosition{ 0,0,0 },
-	iLastFaceRotation{ 0,0,0 },
-	iFaceRotationCenter{ 0,0,0 },
-	iFaceRotation{ 0,0,0 }
+KinectFaceTracker::KinectFaceTracker()
 {
-	m_pFaceFrameSource = nullptr;
-	m_pFaceFrameReader = nullptr;
-
 	// create heap storage for color pixel data in RGBX format
-	m_pColorRGBX = new RGBQUAD[cColorWidth * cColorHeight];
+	iColorRGBX = new RGBQUAD[KColorWidth * KColorHeight];
 }
 
 KinectFaceTracker::~KinectFaceTracker()
 {
-	if (m_pColorRGBX)
+	if (iColorRGBX)
 	{
-		delete[] m_pColorRGBX;
-		m_pColorRGBX = nullptr;
+		delete[] iColorRGBX;
+		iColorRGBX = nullptr;
 	}
 
 	// clean up Direct2D
 	//SafeRelease(m_pD2DFactory);
 
 	// done with face sources and readers
-	SafeRelease(m_pFaceFrameSource);
-	SafeRelease(m_pFaceFrameReader);
+	SafeRelease(iFaceFrameSource);
+	SafeRelease(iFaceFrameReader);
 
 	// done with body frame reader
-	SafeRelease(m_pBodyFrameReader);
+	SafeRelease(iBodyFrameReader);
 
 	// done with color frame reader
-	SafeRelease(m_pColorFrameReader);
+	SafeRelease(iColorFrameReader);
 
 	// done with coordinate mapper
-	SafeRelease(m_pCoordinateMapper);
+	SafeRelease(iCoordinateMapper);
 
 	// close the Kinect Sensor
-	if (m_pKinectSensor)
+	if (iKinectSensor)
 	{
-		m_pKinectSensor->Close();
+		iKinectSensor->Close();
 	}
 
-	SafeRelease(m_pKinectSensor);
+	SafeRelease(iKinectSensor);
 }
 
 module_status KinectFaceTracker::start_tracker(QFrame* aFrame)
 {
-	t.start();
+	iTimer.start();
 
 	if (SUCCEEDED(InitializeDefaultSensor()))
 	{
@@ -170,12 +158,12 @@ bool KinectFaceTracker::center()
 //
 void KinectFaceTracker::data(double *data)
 {
-	const double dt = t.elapsed_seconds();
+	const double dt = iTimer.elapsed_seconds();
 
 	const double KMinDelayInSeconds = 1.0 / 30.0; // Pointless running faster than Kinect hardware itself
 	if (dt > KMinDelayInSeconds)
 	{
-		t.start(); // Reset our timer
+		iTimer.start(); // Reset our timer
 		//OutputDebugStringA("Updating frame!\n");
 		Update();
 		ExtractFaceRotationInDegrees(&iFaceRotationQuaternion, &iFaceRotation.X, &iFaceRotation.Y, &iFaceRotation.Z);
@@ -254,28 +242,28 @@ HRESULT KinectFaceTracker::InitializeDefaultSensor()
 	HRESULT hr;
 
 	// Get and open Kinect sensor
-	hr = GetDefaultKinectSensor(&m_pKinectSensor);
+	hr = GetDefaultKinectSensor(&iKinectSensor);
 	if (SUCCEEDED(hr))
 	{
-		hr = m_pKinectSensor->Open();
+		hr = iKinectSensor->Open();
 	}
 
 	// TODO: check if we still need that guy
 	if (SUCCEEDED(hr))
 	{
-		hr = m_pKinectSensor->get_CoordinateMapper(&m_pCoordinateMapper);
+		hr = iKinectSensor->get_CoordinateMapper(&iCoordinateMapper);
 	}
 
 	// Create color frame reader	
 	if (SUCCEEDED(hr))
 	{
 		UniqueInterface<IColorFrameSource> colorFrameSource;
-		hr = m_pKinectSensor->get_ColorFrameSource(colorFrameSource.PtrPtr());
+		hr = iKinectSensor->get_ColorFrameSource(colorFrameSource.PtrPtr());
 		colorFrameSource.Reset();
 
 		if (SUCCEEDED(hr))
 		{
-			hr = colorFrameSource->OpenReader(&m_pColorFrameReader);
+			hr = colorFrameSource->OpenReader(&iColorFrameReader);
 		}
 	}
 		
@@ -283,12 +271,12 @@ HRESULT KinectFaceTracker::InitializeDefaultSensor()
 	if (SUCCEEDED(hr))
 	{
 		UniqueInterface<IBodyFrameSource> bodyFrameSource;
-		hr = m_pKinectSensor->get_BodyFrameSource(bodyFrameSource.PtrPtr());
+		hr = iKinectSensor->get_BodyFrameSource(bodyFrameSource.PtrPtr());
 		bodyFrameSource.Reset();
 
 		if (SUCCEEDED(hr))
 		{
-			hr = bodyFrameSource->OpenReader(&m_pBodyFrameReader);
+			hr = bodyFrameSource->OpenReader(&iBodyFrameReader);
 		}
 	}
 
@@ -296,14 +284,14 @@ HRESULT KinectFaceTracker::InitializeDefaultSensor()
 	if (SUCCEEDED(hr))
 	{
 		// create the face frame source by specifying the required face frame features
-		hr = CreateHighDefinitionFaceFrameSource(m_pKinectSensor, &m_pFaceFrameSource);
+		hr = CreateHighDefinitionFaceFrameSource(iKinectSensor, &iFaceFrameSource);
 	}
 
 	// Create HD face frame reader
 	if (SUCCEEDED(hr))
 	{
 		// open the corresponding reader
-		hr = m_pFaceFrameSource->OpenReader(&m_pFaceFrameReader);
+		hr = iFaceFrameSource->OpenReader(&iFaceFrameReader);
 	}
 
 	return hr;
@@ -316,13 +304,13 @@ HRESULT KinectFaceTracker::InitializeDefaultSensor()
 /// </summary>
 void KinectFaceTracker::Update()
 {
-	if (!m_pColorFrameReader || !m_pBodyFrameReader)
+	if (!iColorFrameReader || !iBodyFrameReader)
 	{
 		return;
 	}
 
 	IColorFrame* pColorFrame = nullptr;
-	HRESULT hr = m_pColorFrameReader->AcquireLatestFrame(&pColorFrame);
+	HRESULT hr = iColorFrameReader->AcquireLatestFrame(&pColorFrame);
 
 	if (SUCCEEDED(hr))
 	{
@@ -373,10 +361,10 @@ void KinectFaceTracker::Update()
 				{
 					hr = pColorFrame->AccessRawUnderlyingBuffer(&nBufferSize, reinterpret_cast<BYTE**>(&pBuffer));
 				}
-				else if (m_pColorRGBX)
+				else if (iColorRGBX)
 				{
-					pBuffer = m_pColorRGBX;
-					nBufferSize = cColorWidth * cColorHeight * sizeof(RGBQUAD);
+					pBuffer = iColorRGBX;
+					nBufferSize = KColorWidth * KColorHeight * sizeof(RGBQUAD);
 					hr = pColorFrame->CopyConvertedFrameDataToArray(nBufferSize, reinterpret_cast<BYTE*>(pBuffer), ColorImageFormat_Rgba);
 				}
 				else
@@ -389,7 +377,7 @@ void KinectFaceTracker::Update()
 			if (SUCCEEDED(hr))
 			{
 				// Setup our image 
-				QImage image((const unsigned char*)pBuffer, cColorWidth, cColorHeight, sizeof(RGBQUAD)*cColorWidth, QImage::Format_RGBA8888);
+				QImage image((const unsigned char*)pBuffer, KColorWidth, KColorHeight, sizeof(RGBQUAD)*KColorWidth, QImage::Format_RGBA8888);
 				if (IsValidRect(iFaceBox))
 				{
 					// Draw our face bounding box
@@ -423,10 +411,10 @@ HRESULT KinectFaceTracker::UpdateBodyData(IBody** ppBodies)
 {
 	HRESULT hr = E_FAIL;
 
-	if (m_pBodyFrameReader != nullptr)
+	if (iBodyFrameReader != nullptr)
 	{
 		IBodyFrame* pBodyFrame = nullptr;
-		hr = m_pBodyFrameReader->AcquireLatestFrame(&pBodyFrame);
+		hr = iBodyFrameReader->AcquireLatestFrame(&pBodyFrame);
 		if (SUCCEEDED(hr))
 		{
 			hr = pBodyFrame->GetAndRefreshBodyData(BODY_COUNT, ppBodies);
@@ -539,7 +527,7 @@ void KinectFaceTracker::ProcessFaces()
 			if (SUCCEEDED(hr))
 			{
 				// Tell our face source to use the given body id
-				hr = m_pFaceFrameSource->put_TrackingId(iTrackingId);
+				hr = iFaceFrameSource->put_TrackingId(iTrackingId);
 				//OutputDebugStringA("Tracking new body!\n");
 			}
 		}
@@ -549,7 +537,7 @@ void KinectFaceTracker::ProcessFaces()
 	IHighDefinitionFaceFrame* pFaceFrame = nullptr;
 	if (SUCCEEDED(hr))
 	{
-		hr = m_pFaceFrameReader->AcquireLatestFrame(&pFaceFrame);
+		hr = iFaceFrameReader->AcquireLatestFrame(&pFaceFrame);
 	}
 
 	BOOLEAN bFaceTracked = false;
diff --git a/tracker-kinect-face/kinect_face_tracker.h b/tracker-kinect-face/kinect_face_tracker.h
index 9f75507d..a6d4e89b 100644
--- a/tracker-kinect-face/kinect_face_tracker.h
+++ b/tracker-kinect-face/kinect_face_tracker.h
@@ -64,13 +64,9 @@ public:
 	bool center() override;
 
 private:
-	Timer t;
+	
 
 	// Kinect stuff
-	static const int       cColorWidth = 1920;
-	static const int       cColorHeight = 1080;
-
-
 	void Update();
 	HRESULT InitializeDefaultSensor();
 	void ProcessFaces();
@@ -78,39 +74,43 @@ private:
 	void ExtractFaceRotationInDegrees(const Vector4* pQuaternion, float* pPitch, float* pYaw, float* pRoll);
 	static IBody* FindClosestBody(IBody** aBodies);
 	static IBody* FindTrackedBodyById(IBody** aBodies,UINT64 aTrackingId);
+	
+	//
+	Timer iTimer;
 
 	// Current Kinect
-	IKinectSensor*         m_pKinectSensor;
+	IKinectSensor* iKinectSensor = nullptr;
 
 	// Coordinate mapper
-	ICoordinateMapper*     m_pCoordinateMapper;
+	ICoordinateMapper* iCoordinateMapper = nullptr;
 
 	// Color reader
-	IColorFrameReader*     m_pColorFrameReader;
+	IColorFrameReader* iColorFrameReader = nullptr;
 
 	// Body reader
-	IBodyFrameReader*      m_pBodyFrameReader;
+	IBodyFrameReader* iBodyFrameReader = nullptr;
 
 	// Face sources
-	IHighDefinitionFaceFrameSource*	   m_pFaceFrameSource;
+	IHighDefinitionFaceFrameSource*	iFaceFrameSource = nullptr;
 
 	// Face readers
-	IHighDefinitionFaceFrameReader*	   m_pFaceFrameReader;
+	IHighDefinitionFaceFrameReader*	iFaceFrameReader = nullptr;
 
 	//
-	RGBQUAD*               m_pColorRGBX;
+	RGBQUAD* iColorRGBX = nullptr;
 
 	RectI iFaceBox = { 0 };
 
-	CameraSpacePoint iLastFacePosition;
-	CameraSpacePoint iFacePosition;
-	CameraSpacePoint iFacePositionCenter;
+	// Face position
+	CameraSpacePoint iLastFacePosition = { 0 };
+	CameraSpacePoint iFacePosition = { 0 };
+	CameraSpacePoint iFacePositionCenter = { 0 };
 
-	Vector4 iFaceRotationQuaternion;
+	Vector4 iFaceRotationQuaternion = { 0 };
 	// As Yaw, Pitch, Roll
-	CameraSpacePoint iLastFaceRotation;
-	CameraSpacePoint iFaceRotation;
-	CameraSpacePoint iFaceRotationCenter;
+	CameraSpacePoint iLastFaceRotation = { 0 };
+	CameraSpacePoint iFaceRotation = { 0 };
+	CameraSpacePoint iFaceRotationCenter = { 0 };
 	//
 	std::unique_ptr<cv_video_widget> iVideoWidget;
 	std::unique_ptr<QLayout> iLayout;
-- 
cgit v1.2.3


From 26ad3d2b154f9161cf577060f9b161e3312b5e76 Mon Sep 17 00:00:00 2001
From: Stéphane Lenclud <github@lenclud.com>
Date: Thu, 7 Feb 2019 12:41:00 +0100
Subject: Kinect: Removing unused coordinate mapper.

---
 tracker-kinect-face/kinect_face_tracker.cpp | 9 ---------
 tracker-kinect-face/kinect_face_tracker.h   | 3 ---
 2 files changed, 12 deletions(-)

(limited to 'tracker-kinect-face/kinect_face_tracker.cpp')

diff --git a/tracker-kinect-face/kinect_face_tracker.cpp b/tracker-kinect-face/kinect_face_tracker.cpp
index 9f4f133b..104ecda8 100644
--- a/tracker-kinect-face/kinect_face_tracker.cpp
+++ b/tracker-kinect-face/kinect_face_tracker.cpp
@@ -111,9 +111,6 @@ KinectFaceTracker::~KinectFaceTracker()
 	// done with color frame reader
 	SafeRelease(iColorFrameReader);
 
-	// done with coordinate mapper
-	SafeRelease(iCoordinateMapper);
-
 	// close the Kinect Sensor
 	if (iKinectSensor)
 	{
@@ -248,12 +245,6 @@ HRESULT KinectFaceTracker::InitializeDefaultSensor()
 		hr = iKinectSensor->Open();
 	}
 
-	// TODO: check if we still need that guy
-	if (SUCCEEDED(hr))
-	{
-		hr = iKinectSensor->get_CoordinateMapper(&iCoordinateMapper);
-	}
-
 	// Create color frame reader	
 	if (SUCCEEDED(hr))
 	{
diff --git a/tracker-kinect-face/kinect_face_tracker.h b/tracker-kinect-face/kinect_face_tracker.h
index a6d4e89b..6273cba1 100644
--- a/tracker-kinect-face/kinect_face_tracker.h
+++ b/tracker-kinect-face/kinect_face_tracker.h
@@ -81,9 +81,6 @@ private:
 	// Current Kinect
 	IKinectSensor* iKinectSensor = nullptr;
 
-	// Coordinate mapper
-	ICoordinateMapper* iCoordinateMapper = nullptr;
-
 	// Color reader
 	IColorFrameReader* iColorFrameReader = nullptr;
 
-- 
cgit v1.2.3