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 KLController::run()
{
isStop = false;
while(!isStop) {
if(!isAvailable()) {
break; //Not continue, otherwise it will still use cpu
}
HRESULT hr;
if(sourceMarker == SOURCE_TYPE::S_MULTI) {
continue;
}
/* color source */
if(sourceMarker & SOURCE_TYPE::S_COLOR) {
if(!colorReader) {
hr = sensor->get_ColorFrameSource(&colorSource);
if(SUCCEEDED(hr)) {
safeRelease(colorReader);
hr = colorSource->OpenReader(&colorReader);
} else {
emit _hrError(hr);
colorReader = NULL;
}
if(SUCCEEDED(hr)) {
safeRelease(colorDesc);
hr = colorSource->CreateFrameDescription(ColorImageFormat::ColorImageFormat_Rgba, &colorDesc);
} else {
emit _hrError(hr);
colorReader = NULL;
}
if(SUCCEEDED(hr)) {
//
colorDesc->get_BytesPerPixel(&colorBytesPerPixel);
colorDesc->get_Height(&colorHeight);
colorDesc->get_Width(&colorWidth);
colorBuffer = new QVector<BYTE>(colorHeight * colorWidth * colorBytesPerPixel);
emit _readerInfo(true, SOURCE_TYPE::S_COLOR);
} else {
emit _hrError(hr);
colorReader = NULL;
}
}
if(colorReader) {
KLComPtr<IColorFrame> colorFrame;
hr = colorReader->AcquireLatestFrame(&colorFrame);
if(SUCCEEDED(hr)) {
colorFrame->CopyConvertedFrameDataToArray(colorBuffer->size(), (colorBuffer->data()), ColorImageFormat::ColorImageFormat_Rgba);
emit _data(colorBuffer, RESOURCE_TYPE::R_COLOR);
} else {
emit _hrError(hr);
}
}
} else if(colorReader) {
safeRelease(colorSource);
safeRelease(colorReader);
safeRelease(colorDesc);
qDebug()<<"dfd";
emit _readerInfo(false, SOURCE_TYPE::S_COLOR);
}
/* body source */
if(sourceMarker & SOURCE_TYPE::S_BODY) {
if(!bodyReader) {
KLComPtr<IBodyFrameSource> bodySource;
hr = sensor->get_BodyFrameSource(&bodySource);
if(SUCCEEDED(hr)) {
safeRelease(bodyReader);
hr = bodySource->OpenReader(&bodyReader);
} else {
emit _hrError(hr);
safeRelease(bodyReader);
}
if(SUCCEEDED(hr)) {
emit _readerInfo(true, SOURCE_TYPE::S_BODY);
} else {
emit _hrError(hr);
safeRelease(bodyReader);
}
}
if(bodyReader) {
KLComPtr<IBodyFrame> bodyFrame;
hr = bodyReader->AcquireLatestFrame(&bodyFrame);
if(SUCCEEDED(hr)) {
hr = bodyFrame->GetAndRefreshBodyData(_countof(bodies), bodies);
} else {
emit _hrError(hr);
}
}
} else if(bodyReader) {
safeRelease(bodyReader);
for(int i = 0; i < BODY_COUNT; i++) {
safeRelease(bodies[i]);
}
emit _readerInfo(false, SOURCE_TYPE::S_BODY);
}
/* face source */
if(sourceMarker & SOURCE_TYPE::S_FACE_HD) {
for(int i = 0; i < BODY_COUNT; i++) {
faceData[i]->reset();
}
if(!faceHDReaders[0]) {
bool hasError = false;
for(int i = 0; i < BODY_COUNT; i++) {
hr = CreateHighDefinitionFaceFrameSource(sensor, &faceHDSources[i]);
if(SUCCEEDED(hr)) {
safeRelease(faceHDReaders[i]);
hr = faceHDSources[i]->OpenReader(&faceHDReaders[i]);
} else {
hasError = true;
break;
}
if(SUCCEEDED(hr)) {
continue;
//emit _readerInfo(true, SOURCE_TYPE::S_FACE_HD);
} else {
hasError = true;
break;
}
}
if(hasError) {
for(int i = 0; i < BODY_COUNT; i++) {
safeRelease(faceHDReaders[i]);
safeRelease(faceHDSources[i]);
}
emit _hrError(hr);
} else {
emit _readerInfo(true, SOURCE_TYPE::S_FACE_HD);
}
}
if(faceHDReaders[0]) {
bool hasValidFaceTrack = false;
for(int i = 0; i < BODY_COUNT; i++) {
BOOLEAN isFaceTracked = false;
//faceData[i]->frameHD = NULL;
hr = faceHDReaders[i]->AcquireLatestFrame(&faceHDFrames[i]);
if(SUCCEEDED(hr)) {
//qDebug()<<"huuray!!";
hr = faceHDFrames[i]->get_IsTrackingIdValid(&isFaceTracked);
}
if(SUCCEEDED(hr)) {
faceData[i]->frameHD = faceHDFrames[i];
faceData[i]->sourceHD = faceHDSources[i];
faceData[i]->readerHD = faceHDReaders[i];
faceData[i]->index = i;
}
if(!isFaceTracked) {
safeRelease(faceHDFrames[i]);
if(bodyReader) {
if(bodies[i] != NULL) {
BOOLEAN isBodyTracked = false;
hr = bodies[i]->get_IsTracked(&isBodyTracked);
if(SUCCEEDED(hr)) {
if(isBodyTracked) {
UINT64 bodyID;
hr = bodies[i]->get_TrackingId(&bodyID);
if(SUCCEEDED(hr)) {
faceHDSources[i]->put_TrackingId(bodyID);
faceData[i]->trackID = bodyID;
}
}
}
}
} else {
// open body source
sourceMarker |= SOURCE_TYPE::S_BODY;
}
} else {
hasValidFaceTrack = true;
faceData[i]->isValid = true;
}
}
if(hasValidFaceTrack) {
//qDebug()<<"p1";
emit _data(faceData, RESOURCE_TYPE::R_FACE_HD);
}
}
} else if(faceHDReaders[0]) {
for(int i = 0; i < BODY_COUNT; i++) {
safeRelease(faceHDReaders[i]);
safeRelease(faceHDFrames[i]);
safeRelease(faceHDSources[i]);
faceData[i]->reset();
}
emit _readerInfo(false, SOURCE_TYPE::S_FACE_HD);
}
if(sourceMarker == SOURCE_TYPE::S_NONE) {
break;
}
usleep(floor((1.0 / fps) * 1000 * 1000));
emit _pulse();
}
}
/// <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;
}
