// Initialize Face
inline void Kinect::initializeFace()
{
// Set Face Features to Enable
const DWORD features = FaceFrameFeatures::FaceFrameFeatures_BoundingBoxInColorSpace;
Concurrency::parallel_for( 0, BODY_COUNT, [&]( const int count ){
// Create Face Sources
ComPtr<IFaceFrameSource> faceFrameSource;
ERROR_CHECK( CreateFaceFrameSource( kinect.Get(), 0, features, &faceFrameSource ) );
// Open Face Readers
ERROR_CHECK( faceFrameSource->OpenReader( &faceFrameReader[count] ) );
} );
}
HRESULT KinectHDFaceGrabber::initHDFaceReader()
{
IBodyFrameSource* pBodyFrameSource = nullptr;
UINT32 vertices = 0;
HRESULT hr = GetFaceModelVertexCount(&vertices);
if (SUCCEEDED(hr)){
hr = m_pKinectSensor->get_BodyFrameSource(&pBodyFrameSource);
}
std::vector<std::vector<float>> deformations(BODY_COUNT, std::vector<float>(FaceShapeDeformations::FaceShapeDeformations_Count));
if (SUCCEEDED(hr)){
// create a face frame source + reader to track each body in the fov
for (int i = 0; i < BODY_COUNT; i++){
if (SUCCEEDED(hr)){
// create the face frame source by specifying the required face frame features
hr = CreateFaceFrameSource(m_pKinectSensor, 0, c_FaceFrameFeatures, &m_pFaceFrameSources[i]);
}
if (SUCCEEDED(hr)){
// open the corresponding reader
hr = m_pFaceFrameSources[i]->OpenReader(&m_pFaceFrameReaders[i]);
}
std::vector<std::vector<float>> deformations(BODY_COUNT, std::vector<float>(FaceShapeDeformations::FaceShapeDeformations_Count));
if (SUCCEEDED(hr)){
hr = CreateHighDefinitionFaceFrameSource(m_pKinectSensor, &m_pHDFaceSource[i]);
m_pHDFaceSource[i]->put_TrackingQuality(FaceAlignmentQuality_High);
}
if (SUCCEEDED(hr)){
hr = m_pHDFaceSource[i]->OpenReader(&m_pHDFaceReader[i]);
}
if (SUCCEEDED(hr)){
hr = m_pHDFaceSource[i]->OpenModelBuilder(FaceModelBuilderAttributes::FaceModelBuilderAttributes_None, &m_pFaceModelBuilder[i]);
}
if (SUCCEEDED(hr)){
hr = m_pFaceModelBuilder[i]->BeginFaceDataCollection();
}
if (SUCCEEDED(hr)){
hr = CreateFaceAlignment(&m_pFaceAlignment[i]);
}
if (SUCCEEDED(hr)){
m_HDFaceDetectedPointsCamSpace[i].resize(vertices);
m_HDFaceDetectedPointsColorSpace[i].resize(vertices);
}
// Create Face Model
hr = CreateFaceModel(1.0f, FaceShapeDeformations::FaceShapeDeformations_Count, deformations[i].data(), &m_pFaceModel[i]);
if (FAILED(hr)){
std::cerr << "Error : CreateFaceModel()" << std::endl;
return hr;
}
}
if (SUCCEEDED(hr)){
hr = pBodyFrameSource->OpenReader(&m_pBodyFrameReader);
}
SafeRelease(pBodyFrameSource);
}
return hr;
}
void MKinect::init(FaceTrackingApp *app){
this->app = app;
_last_init = false;
last_cloud = CloudType::Ptr(new CloudType);
actual_cloud = CloudType::Ptr(new CloudType);
first_cloud = CloudType::Ptr(new CloudType);
_actual_frame = 0;
if (FAILED(GetDefaultKinectSensor(&sensor))) {
return;
}
if (sensor) {
HRESULT hResult = S_OK;
sensor->get_CoordinateMapper(&mapper);
sensor->Open();
sensor->OpenMultiSourceFrameReader(
FrameSourceTypes::FrameSourceTypes_Depth | FrameSourceTypes::FrameSourceTypes_Color,
&reader);
hResult = sensor->get_BodyFrameSource(&pBodySource);
if (FAILED(hResult)){
std::cerr << "Error : IKinectSensor::get_BodyFrameSource()" << std::endl;
return;
}
hResult = pBodySource->OpenReader(&pBodyReader);
if (FAILED(hResult)){
std::cerr << "Error : IBodyFrameSource::OpenReader()" << std::endl;
return;
}
DWORD features = FaceFrameFeatures::FaceFrameFeatures_BoundingBoxInColorSpace
| FaceFrameFeatures::FaceFrameFeatures_PointsInColorSpace
| FaceFrameFeatures::FaceFrameFeatures_RotationOrientation
| FaceFrameFeatures::FaceFrameFeatures_Happy
| FaceFrameFeatures::FaceFrameFeatures_RightEyeClosed
| FaceFrameFeatures::FaceFrameFeatures_LeftEyeClosed
| FaceFrameFeatures::FaceFrameFeatures_MouthOpen
| FaceFrameFeatures::FaceFrameFeatures_MouthMoved
| FaceFrameFeatures::FaceFrameFeatures_LookingAway
| FaceFrameFeatures::FaceFrameFeatures_Glasses
| FaceFrameFeatures::FaceFrameFeatures_FaceEngagement;
for (int count = 0; count < BODY_COUNT; count++){
// Source
hResult = CreateFaceFrameSource(sensor, 0, features, &pFaceSource[count]);
if (FAILED(hResult)){
std::cerr << "Error : CreateFaceFrameSource" << std::endl;
return;
}
// Reader
hResult = pFaceSource[count]->OpenReader(&pFaceReader[count]);
if (FAILED(hResult)){
std::cerr << "Error : IFaceFrameSource::OpenReader()" << std::endl;
return;
}
}
return;
}
else {
return;
}
}
/// <summary>
/// Initializes the default Kinect sensor
/// </summary>
/// <returns>S_OK on success else the failure code</returns>
HRESULT CFaceBasics::InitializeDefaultSensor()
{
HRESULT hr;
hr = GetDefaultKinectSensor(&m_pKinectSensor);
if (FAILED(hr))
{
return hr;
}
if (m_pKinectSensor)
{
// Initialize Kinect and get color, body and face readers
IColorFrameSource* pColorFrameSource = nullptr;
IBodyFrameSource* pBodyFrameSource = nullptr;
hr = m_pKinectSensor->Open();
if (SUCCEEDED(hr))
{
hr = m_pKinectSensor->get_CoordinateMapper(&m_pCoordinateMapper);
}
if (SUCCEEDED(hr))
{
hr = m_pKinectSensor->get_ColorFrameSource(&pColorFrameSource);
}
if (SUCCEEDED(hr))
{
hr = pColorFrameSource->OpenReader(&m_pColorFrameReader);
}
if (SUCCEEDED(hr))
{
hr = m_pKinectSensor->get_BodyFrameSource(&pBodyFrameSource);
}
if (SUCCEEDED(hr))
{
hr = pBodyFrameSource->OpenReader(&m_pBodyFrameReader);
}
if (SUCCEEDED(hr))
{
// create a face frame source + reader to track each body in the fov
for (int i = 0; i < BODY_COUNT; i++)
{
if (SUCCEEDED(hr))
{
// create the face frame source by specifying the required face frame features
hr = CreateFaceFrameSource(m_pKinectSensor, 0, c_FaceFrameFeatures, &m_pFaceFrameSources[i]);
}
if (SUCCEEDED(hr))
{
// open the corresponding reader
hr = m_pFaceFrameSources[i]->OpenReader(&m_pFaceFrameReaders[i]);
}
if (SUCCEEDED(hr))
{
// create the face frame source by specifying the required face frame features
hr = CreateHighDefinitionFaceFrameSource(m_pKinectSensor, &m_phdFaceFrameSources[i]);
}
if (SUCCEEDED(hr))
{
// open the corresponding reader
hr = m_phdFaceFrameSources[i]->OpenReader(&m_phdFaceFrameReaders[i]);
}
if (SUCCEEDED(hr))
{
// create the face frame alignment
hr = CreateFaceAlignment(&m_phdFaceAlignments[i]);
}
}
}
SafeRelease(pColorFrameSource);
SafeRelease(pBodyFrameSource);
}
if (!m_pKinectSensor || FAILED(hr))
{
SetStatusMessage(L"No ready Kinect found!", 10000, true);
return E_FAIL;
}
return hr;
}
