Обзор технологии Intel® RealSense™ и ноутбука с 3D камерой

Здравия! Меня зовут Ярослав. Я - участник конкурса Intel® RealSense™ App Challenge 2014. В этой статье мы поговорим о технологии Intel® RealSense™ и вспомним, как вообще камеры начали проникать в персональные компьютеры. Вы увидите, как с помощью одной руки можно перемещаться в виртуальном 3D пространстве. Я раскрою для вас исходные коды своего суперпроекта и расскажу, что может дать камера глубины встроенная в ноутбук, и помечтаю о возможном развитии технологии.

С чего все начиналось?

Если опустить Большой взрыв, то впервые веб-камера зарегистрирована в 1991 году. Она была установлена в старой компьютерной лаборатории Кембриджского университета и транслировала по локальной сети не что иное, как уровень кофе в кофеварке.

Благодаря этому, сотрудники всегда знали, когда можно идти за свежесваренным кофе.
Эта первая камера передавала черно-белую картинку разрешением 128x128 пикселей.

С тех пор веб-камеры развивались в сторону миниатюризации, увеличения разрешения и улучшения качества картинки. Сейчас нам уже сложно представить ноутбук или смартфон без встроенной камеры. Но компания Intel® решила пойти дальше и разработала революционную технологию Intel® RealSense. Данная технология не просто набор навороченных веб-камер, RealSense™ основана на парадигме Natural Interaction - природное общение человека и машины. Ну, действительно, мы уже собираем миссию на Марс, а до сих пор пользуемся компьютерными мышками, которые еще в прошлом веке разработали в компании Xerox*.

Итак, революция Intel® RealSense

На волне революции Natural Interaction, компания Intel® разработала аппаратно-программный комплекс RealSense.

Основные направления технологии:

- распознавание голоса
- отслеживание рук и пальцев
- распознавание жестов
- распознавание лица и эмоций
- сканирование объектов для 3D печати

Из выше перечисленного списка видно, что компания Intel® решила перевернуть, наше представление о стандартных устройствах ввода.

Технология RealSense™ – это набор высококачественных камер, датчиков и встроенный графический процессор, а также SDK для разработчиков Intel® RealSense™ SDK

- Цветовая камера – просто веб-камера с поддержкой Full HD видео, расширением до 1920x1080 пикселей.
- ИК сенсор глубины – инфракрасный датчик глубины, используется вместе с ИК лазерным проектором. Вообще, лазерный проектор звучит грозно, но если вспомнить физику, то инфракрасные лучи – одни из самых неактивных из доступного нам спектра. То есть для глаз, к примеру, такой лазер безвреден.
Расширение датчика глубины 640x480 пикселей.
- Графический процессор (не путать с ГПУ) – специализированный микрочип для первичной обработки потока данных в таких алгоритмах, как расчет глубины, фильтры помех и т.п. Встроенный графический процессор существенно разгружает центральный процессор компьютера и ускоряет работу камеры в целом. Все алгоритмы, обрабатываемые на встроенном графическом процессоре, реализованы в отдельной прошивке, что позволяет обновлять ‘мозги’ камеры с выходом новых прошивок.
- Также присутствуют стереомикрофоны для качественного распознавания речи.

Для чего датчик глубины вообще нужен?

Простая цветовая камера передает картинку в плоскости. К примеру, если ваша левая рука находится ближе к камере, чем правая, то машина может ‘понять’, что руки находятся на разных расстояниях, только используя специальные алгоритмы распознавания образов. Камера глубины решает этот вопрос намного проще, и работает как летучая мышь или эхолот, отправляя ИК луч и замеряя через сколько времени он вернулся. Зная скорость света, можно легко посчитать расстояние от камеры до объекта.

Картинка глубины - так видит мир зубастая летучая мышь ночью.

А как это все использовать?

Благодаря Intel® RealSense™ SDK, нам простым прикладным программистам, не нужно разбираться в алгоритмах распознавания образов или нормализовать данные с датчика глубины. В RealSense™ SDK это все скрыто на низком уровне, а на верхнем уровне находятся абстрактные модули, к примеру: Hand Tracking, Emotion Detection и прочие. Дергая модули, мы как кукловоды управляем театром. Детальную документация по SDK можно найти здесь.
Также RealSense™ SDK предоставляет доступ к ‘сырым’ данным, полученным непосредственно с датчиков, вот отличная статья: Intel® RealSense Работа с потоками необработанных данных.

В RealSense™ SDK, есть много примеров кода, причем минималистичные примеры есть в документации для каждого модуля. А в самом SDK есть полноценные примеры на разных языках программирования.
На данный момент поддерживаются следующие языки и платформы разработки:

- C++, C#, Java, JavaScript (да да, RealSense™ уже работает в Интернет браузерах!).

- Microsoft Visual Studio 2010-2013 с последними обновлениями
- Microsoft .NET 4.0 Framework для C# разработки
- Unity PRO 4.1.0+ для разработки игр
- Processing 2.1.2+
- Java JDK 1.7.0_11+

Рассмотрим какие модули RealSense, мы имеем в распоряжении:

- Face Tracking and Recognition – [PXCFaceModule] модуль распознавания лица и отслеживания головы человека. Распознание лица, очень хорошо подходит для беспарольной аутентификации пользователя. Отслеживание головы также можно использовать в играх. Модуль содержит информацию о наклоне головы в двух форматах: кватернион и матрица вращения – уже вижу программу: гимнастика для шеи с RealSense.

- Hand Tracking – [PXCHandModule] – модуль отслеживания рук. Сразу нужно сказать, модуль отслеживает не только ладони, но и пальцы, и даже фаланги пальцев. В общем 22 точки на каждой кисти:

Модуль может работать в трех режимах:
- Blob (контур) – определяет только контур рук, данный режим потребляет минимум ресурсов и подходит для интерфейсов пользователя, где рука заменят курсор мыши.
- Extremities (экстремумы) – возвращает информацию о крайних точках кисти. Также определят какая это рука - левая или правая. Ресурсов ест чуть больше, чем Blob режим.
- Full Hand (Детальная рука) – режим использует больше всего ресурсов, но возвращает буквально все: информацию о суставах (положение и вращение), информацию о фалангах пальцев. А главное определяет жесты (gestures).
При определении жестов, чтобы не было ложных срабатываний, рекомендую использовать свой счетчик времени для жестов. Ложное срабатывание длится не дольше четверти секунды, а значит, если жест определен дольше секунды, можно с уверенностью запускать функцию для данного жеста.
Full Hand режим поддерживает много оптимизаций и настроек. К примеру, опция ‘EnableNormalizedJoints’ включает ‘выравнивание’ фаланг пальцев (если они у вас кривые), точнее сказать нормализует длину фаланг даже когда информации недостаточно из-за того что пальцы могут перекрываться.
В своем проекте я использовал именно Full Hand режим и, надо сказать, что на Intel® NUC D54250WYKH с процессором Intel® Core i5 4250U приложение работает превосходно. Это при том, что кроме RealSense™ модулей работали параллельно физический движок Havok Physics и графический движок Ogre3D.
- Emotion Detection – [PXCEmotion] – модуль распознания эмоций пользователя.
В первую очередь модуль полезен для распознания настроения и мимики, что займет свою нишу в игровой и развлекательной индустрии. В этот же модуль будут встроены алгоритмы распознания возраста пользователя.

- Object Tracking – [PXCTracker] – модуль отслеживания объектов. Очень интересный модуль. Задав объект для слежки, модуль передает координаты объекта, даже если объект движется относительно RealSense™ камеры. Может использоваться в приложениях дополнительной реальности как тут.

- Speech Recognition and Synthesis – [PXCSpeechRecognition] – модуль распознавания и синтеза речи.
Синтез речи на мой взгляд не очень распространенное направление. А вот за распознаванием речи – будущее. Вообще Intel® надо будет постараться, чтобы обогнать конкурентов в области распознавание человеческой речи. Но если алгоритм будет работать на встроенном в RealSense™ процессоре, это будет огромный козырь, так как ускорит распознавание слов и разгрузит центральный процессор. Источником звука для модуля может служить микрофон или звуковой файл, что удобно для отладки.
Модуль распознавания может работать в двух режимах:
1) Режим диктанта (The dictation mode) – режим определения слов с заданных словарей в RealSense™ SDK. То есть модуль пытается определить слово из всего языка. На данный момент в RealSense™ SDK есть словари трех языков: американский английский, британский английский и португальский. Словари устанавливаются опционально во время установки RealSense™ SDK.
2) Режим команд (The command and control mode) – модуль распознает слова из заданного вами списка. Понятно, что данный режим работает быстрее, чем диктант. И это идеальный режим для управления программами. Команды задаются в виде строкового списка пример:

'pxcCHAR *cmds[4]={ L"Open", L"Close", L"Exit", L"Kill" };'

'sr->BuildGrammarFromStringList(1, cmds, 0, 4);'

RealSense™ SDK генерирует звуковые отпечатки на основании произношения букв. По принципу транскрипции как на уроках английского языка. То есть вам не нужно делать эталонную звуковую запись команд.

Модуль распознавания речи еще сыроват, а может мое английское произношение картавит. Но однозначно можно сказать, что в будущем режим голосовых команд будет также встроен для каждого меню программ как сейчас комбинации клавиш, к примеру: Alt+F4, Ctr+A и т.п.

Я бы с радостью купил плагин, для Visual Studio или XCode, где по голосовой команде “Create class” автоматически добавлялись нужные файлы в проект и вставлялся шаблон программного кода.

Имейте ввиду, что SDK достаточно объёмный. Если вы не планируете увлекаться распознаванием речи, то убрав галочку в этом секторе, можно сэкономить время на скачке и установки SDK.

И, как обещал, раскрываю исходный код обработчика RealSense™ из моего проекта: The Mechanics

Видео проекта
Детальное описание проекта (англ.)
The Mechanics – программа виртуальный конструктор, в котором пользователь может строить замки и разрушать их, побить мировой рекорд в домино, или даже проводить реальные физические эксперименты. Приложение представляет спайку технологий Havok Physics + Ogre3D + RealSense. Программа отслеживает руки и пальцы в трех плоскостях, что позволяет отказаться от виртуальных перчаток и позволяет перемещать объекты руками в 3D пространстве без дополнительных проекций (так как мы это делаем в реальном мире).

Программа поддерживает два режима: навигация и редактирование. Режим навигации позволяет перемещаться в трехмерном пространстве, передвижением руки перед камерой (смотри видео). Режим редактирования позволяет перемещать сами объекты в пространстве. Переключение между режимами производится жестом Victory.

Вот исходный код (C++) главного класса для работы с RealSense. В методе init() мы инициализируем камеру и модуль распознавания рук. А метод Update() запускается в отдельном потоке и обновляет информацию о руках в реальном времени:

Показать код

#ifndef REAL_SENSE_MONOPOLYST_MAIN_H
        #define REAL_SENSE_MONOPOLYST_MAIN_H

        #include "pxcsensemanager.h"
        #include "BridgeToRealSense.h"

        // The main class of RealSense, the program must use only this class for all RealSense™ stuffs
        class RealSenseMain
        {
        public:
            RealSenseMain();
            ~RealSenseMain();
            
            bool init(BridgeRealSenseMain* ptr_bridgeRealSenseMain);
            void close();
            void Update();
            void clearBridge();
            void stopRealSense();
            bool isRealSenseStoped() { return stoped; }

        private:
            PXCSession *mSession;
            PXCSenseManager *mSenseManager;

            /////////////////////////////////
            // Hand module stuffs
            PXCHandModule* handModule;
            PXCHandData* outputHandData;
            PXCHandConfiguration* configHand;

            ////////////// Gesure stuffs
            int gestureFrameStartNumber_Navigate;   // number frame when start the gesture of enable/disable the navigate mode
            int gestureFrameStartNumber_two;
            /////////////////////////////////

            // This structure is mutual for program kernel and RealSense™ modules. Details see 'BridgeToRealSense.h'
            BridgeRealSenseMain* bridgeRealSenseMain;   // NOTICE: do not delete this pointer in this class!

            bool stoped;    // Stop loop in Update()
        };

        #endif
        

Показать код

#include "RealSenseMain.h"
        #include "../GlobalConf.h"
        //#include "../GUI/GameGUI.h"
        #include "../OgreFrameWork/AdvancedOgreFramework.hpp"

        #include "PXCHandConfiguration.h"

        // Smoothing for RealSense™ data: details see:
        // https://software.intel.com/sites/landingpage/realsense/camera-sdk/2014gold/documentation/html/index.html?pxcdatasmoothing.html
        // https://software.intel.com/en-us/forums/topic/537324
        #include "utilities/pxcdatasmoothing.h"
        #include "SmoothRealSense.h"

        RealSenseMain::RealSenseMain()
        {
            mSession=0;
            mSenseManager=0;
            handModule=0;
            outputHandData=0;
            configHand=0;
            stoped=false;   // Stop loop in Update()
            gestureFrameStartNumber_Navigate=0;
            gestureFrameStartNumber_two=0;
        }

        RealSenseMain::~RealSenseMain()
        {
        }

        // 1: pointer to structure is mutual for program kernel and RealSense™ modules. Details see 'BridgeToRealSense.h'
        bool RealSenseMain::init(BridgeRealSenseMain* ptr_bridgeRealSenseMain)
        {
            // Other word, the RealSenseMain update this structure and program kernel read data from this structure.
            bridgeRealSenseMain = ptr_bridgeRealSenseMain;
            clearBridge();

            OgreFramework::getSingletonPtr()->m_pLog->logMessage( Ogre::String("Start init RealSense") );

            // Init Seesions
            mSession = PXCSession_Create();
            if( mSession == NULL )
            {
                OgreFramework::getSingletonPtr()->m_pLog->logMessage( FNAME() + Ogre::String("Error: Do not create PXCSession by PXCSession_Create()") );

                return false;
            }

            // Create SenseManager
            mSenseManager = mSession->CreateSenseManager();
            if( !mSenseManager )
            {
                OgreFramework::getSingletonPtr()->m_pLog->logMessage( FNAME() + Ogre::String("Error: Failed to create SenseManager") );

                return false;
            }

            /* Set Module */
            pxcStatus status = mSenseManager->EnableHand(0);
            handModule=mSenseManager->QueryHand();
            if(handModule == NULL || status != pxcStatus::PXC_STATUS_NO_ERROR)
            {
                OgreFramework::getSingletonPtr()->m_pLog->logMessage( FNAME() + Ogre::String("Error: Failed to pair the Hande module with I/O") );
                return false;
            }

            if( mSenseManager->Init() < PXC_STATUS_NO_ERROR )
            {
                OgreFramework::getSingletonPtr()->m_pLog->logMessage( FNAME() + Ogre::String("Error: Failed init RealSense™ by init SenseManager.") );
                return false;
            }

            // Obtain HandData container...
            outputHandData = handModule->CreateOutput();

            ////////////////////////////////////////
            // Hand Module Configuration
            configHand = handModule->CreateActiveConfiguration();   
            configHand->EnableNormalizedJoints(true);
            configHand->SetTrackingMode(PXCHandData::TRACKING_MODE_FULL_HAND);
            // Set onu user for save calibrate data
            wchar_t* userName = L"Root";
            configHand->SetUserName(userName);
            //configHand->EnableAllAlerts();    
            //config->EnableSegmentationImage(true);    

            ////// Enable gestures
            // details: https://software.intel.com/sites/landingpage/realsense/camera-sdk/2014gold/documentation/html/index.html?manuals_pose_and_gesture_recognition.html
            //configHand->EnableGesture(L"two_fingers_pinch_open", true);
            configHand->EnableGesture(L"v_sign", true);

            ////// Enable alert for calibration
            // details: https://software.intel.com/sites/landingpage/realsense/camera-sdk/2014gold/documentation/html/index.html?manuals_hand_calibration_data.html
            configHand->EnableAlert( PXCHandData::AlertType::ALERT_HAND_CALIBRATED );

                
            configHand->ApplyChanges();
            configHand->Update();
            ////////////////////////////////////////
            
            // Init smooth details:
            // https://software.intel.com/sites/landingpage/realsense/camera-sdk/2014gold/documentation/html/index.html?pxcdatasmoothing.html
            // https://software.intel.com/en-us/forums/topic/537324
            SmoothRealSense::initSmoothers( mSession );
            ////////////////////////////////////////


            OgreFramework::getSingletonPtr()->m_pLog->logMessage( Ogre::String("Init RealSense™ complete") );

            return true;
        }

        // Clearaing all RealSense™ stuffs.
        void RealSenseMain::close()
        {
            OgreFramework::getSingletonPtr()->m_pLog->logMessage( Ogre::String("Start close RealSense") );

            SmoothRealSense::clearSmoothers();

            if( configHand )
            {
                configHand->Release();
                configHand=0;
            }

            if( outputHandData )
            {
                outputHandData->Release();
                outputHandData=0;
            }

            if( mSenseManager )
            {
                mSenseManager->Close();
                mSenseManager->Release();
                mSenseManager=0;
            }

            if( mSession )
            {
                mSession->Release();
                mSession=0;
            }

            OgreFramework::getSingletonPtr()->m_pLog->logMessage( Ogre::String("Close RealSense™ complete") );
        }

        // Thie methoâ must run in thread, and it updated info from camera, updated info in Bridge..
        // Based on example: http://www.ogre3d.org/tikiwiki/tiki-index.php?page=Threading
        void RealSenseMain::Update()
        {
            pxcStatus status;
            PXCPointF32 pointCenterMassImage;
            //  PXCPoint3DF32 pointCenterMassWorld;
            PXCHandData::IHand* handData;
            PXCHandData::JointData jointData;

            // Main loop for our thread
            while (!stoped) 
            {
                // Send 'true' mean what AcquireFrame wait result from all modules
                status = mSenseManager->AcquireFrame(false);
                // Update status of connections
                bridgeRealSenseMain->isDeviceConnected = mSenseManager->IsConnected();

                // If we connected to device
                if( bridgeRealSenseMain->isDeviceConnected ) 
                {
                    // If we not obtain the frame from SenseMeneger
                    if (status < PXC_STATUS_NO_ERROR)
                    {
                        break;
                    }

                    outputHandData->Update();   

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    ////////////////////////////////////////////////////   START HAND MODULE     ///////////////////////////////////////////////////////
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    // If detected left hand, obtain hand data
                    if(outputHandData->QueryHandData(PXCHandData::AccessOrderType::ACCESS_ORDER_LEFT_HANDS,0,handData) == PXC_STATUS_NO_ERROR)
                    {
                        bridgeRealSenseMain->ogreHandModuleMain.isLeftHandDetected=true;

                        /////////////////////////////////
                        // Update 2D center of mass point of the hand, in the depth image space
                        pointCenterMassImage = handData->QueryMassCenterImage();
                        // Make smooth palm image coordinates
                        SmoothRealSense::smootherPalmImageLeft->AddSample( pointCenterMassImage );
                        pointCenterMassImage = SmoothRealSense::smootherPalmImageLeft->GetSample();
                        // convert and store palm image coordinates
                        bridgeRealSenseMain->ogreHandModuleMain.massCenterImageLeft = Ogre::Vector2(pointCenterMassImage.x,pointCenterMassImage.y);
                        /////////////////////////////////

                        // Update 3D center of mass point of the hand, in the camera coordinate system
                        //pointCenterMassWorld = handData->QueryMassCenterWorld();
                        //bridgeRealSenseMain->ogreHandModuleMain.massCenterWorldLeft = Ogre::Vector3(pointCenterMassWorld.x,pointCenterMassWorld.y,pointCenterMassWorld.z);

                        /////////////////////////////////
                        // Extract Palm joint data
                        handData->QueryNormalizedJoint((PXCHandData::JointType)1,jointData); // Normalized!
                        if( jointData.confidence > 0 ) 
                        {
                            // Make smooth for Palm Z (depth) world coordinates, 
                            SmoothRealSense::smootherPalmWorldLeft->AddSample( jointData.positionWorld.z );
                            jointData.positionWorld.z = SmoothRealSense::smootherPalmWorldLeft->GetSample();
                            // convert and store palm JointData
                            bridgeRealSenseMain->ogreHandModuleMain.ogreJointDataLeft[1] = RsOgreHandModule::Convert::JointData_RealSenseToOgre(jointData); 
                        }
                        /////////////////////////////////

                        // Iterate Joints, obtain JointData info, convert it to OgreJointData and store in the Bridge.
                        // Notice: when 'j' start from '2', "j=2" its mean what we skip the 'wrist' and 'palm' joint data.
                        // details see: https://software.intel.com/sites/landingpage/realsense/camera-sdk/2014gold/documentation/html/index.html?manuals_programming_guide_gesture.html
                        for(int j = 2; j < PXCHandData::NUMBER_OF_JOINTS ; j++)
                        {
                            handData->QueryNormalizedJoint((PXCHandData::JointType)j,jointData); // Normalized!

                            // convert and store JointData
                            bridgeRealSenseMain->ogreHandModuleMain.ogreJointDataLeft[j] = RsOgreHandModule::Convert::JointData_RealSenseToOgre(jointData);
                        }
                            
                    }
                    else
                    {
                        bridgeRealSenseMain->ogreHandModuleMain.isLeftHandDetected=false;
                    }

                    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    // If detected right hand, obtain hand data
                    if(outputHandData->QueryHandData(PXCHandData::AccessOrderType::ACCESS_ORDER_RIGHT_HANDS,0,handData) == PXC_STATUS_NO_ERROR)
                    {
                        bridgeRealSenseMain->ogreHandModuleMain.isRightHandDetected=true;

                        /////////////////////////////////
                        // Update 2D center of mass point of the hand, in the depth image space
                        pointCenterMassImage = handData->QueryMassCenterImage();
                        // Make smooth
                        SmoothRealSense::smootherPalmImageRight->AddSample( pointCenterMassImage );
                        pointCenterMassImage = SmoothRealSense::smootherPalmImageRight->GetSample();
                        // convert and store palm image coordinates
                        bridgeRealSenseMain->ogreHandModuleMain.massCenterImageRight = Ogre::Vector2(pointCenterMassImage.x,pointCenterMassImage.y);
                        /////////////////////////////////

                        // Update 3D center of mass point of the hand, in the camera coordinate system
                        //pointCenterMassWorld = handData->QueryMassCenterWorld();
                        //bridgeRealSenseMain->ogreHandModuleMain.massCenterWorldRight = Ogre::Vector3(pointCenterMassWorld.x,pointCenterMassWorld.y,pointCenterMassWorld.z);

                        /////////////////////////////////
                        // Extract Palm joint data
                        handData->QueryNormalizedJoint((PXCHandData::JointType)1,jointData); // Normalized!
                        if( jointData.confidence > 0 )
                        {
                            // Make smooth for Palm Z (depth) world coordinates, 
                            SmoothRealSense::smootherPalmWorldRight->AddSample( jointData.positionWorld.z );
                            jointData.positionWorld.z = SmoothRealSense::smootherPalmWorldRight->GetSample();
                            // convert and store palm JointData
                            bridgeRealSenseMain->ogreHandModuleMain.ogreJointDataRight[1] = RsOgreHandModule::Convert::JointData_RealSenseToOgre(jointData);    
                        }
                        /////////////////////////////////

                        // Iterate Joints, obtain JointData info, convert it to OgreJointData and store in the Bridge.
                        // Notice: when 'j' start from '2', "j=2" its mean what we skip the 'wrist' and 'palm' joint data.
                        // details see: https://software.intel.com/sites/landingpage/realsense/camera-sdk/2014gold/documentation/html/index.html?manuals_programming_guide_gesture.html
                        for(int j = 2; j < PXCHandData::NUMBER_OF_JOINTS ; j++)
                        {
                            handData->QueryNormalizedJoint((PXCHandData::JointType)j,jointData); // Normalized!

                            // convert and store JointData
                            bridgeRealSenseMain->ogreHandModuleMain.ogreJointDataRight[j] = RsOgreHandModule::Convert::JointData_RealSenseToOgre(jointData);        
                        }
                    }
                    else
                    {
                        bridgeRealSenseMain->ogreHandModuleMain.isRightHandDetected=false;
                    }

                    ///////////////////////////////////////////////////////////////////////////////////////////////////
                    ///////////////////////////////////////// Gesture stuffs //////////////////////////////////////////
                    ///////////////////////////////////////////////////////////////////////////////////////////////////
                    // Work with gestures
                    // details: https://software.intel.com/sites/landingpage/realsense/camera-sdk/2014gold/documentation/html/index.html?manuals_pose_and_gesture_recognition.html
                    PXCHandData::GestureData gestureData;

                    // If hand detected, we use the gesture "v_sign" for switch mode Edit/Navigate.
                    if( bridgeRealSenseMain->ogreHandModuleMain.isLeftHandDetected || bridgeRealSenseMain->ogreHandModuleMain.isRightHandDetected )
                    {
                        ////////////////////////////////////////////////////////// Gesture One /////////////////////////////////////////////////////////////////
                        // how many frame must detected the gesrure before seitch mode.
                        const int frameSwitchCount = 40;
                        // If switcher 'isGestureEnabledNavigateMode' is off and detected the gesture.
                        if( !bridgeRealSenseMain->ogreHandModuleMain.isGestureEnabledNavigateMode && outputHandData->IsGestureFired(L"v_sign", gestureData) )
                        {
                            if( gestureFrameStartNumber_Navigate == 0 )
                            {
                                gestureFrameStartNumber_Navigate = gestureData.frameNumber;
                            }
                            else if( (gestureData.frameNumber - gestureFrameStartNumber_Navigate) > frameSwitchCount )
                            {
                                bridgeRealSenseMain->ogreHandModuleMain.isGestureEnabledNavigateMode = true;
                                gestureFrameStartNumber_Navigate = 0;
                            }
                        } // If switcher 'isGestureEnabledNavigateMode' is on and detected this gesture.
                        else if( bridgeRealSenseMain->ogreHandModuleMain.isGestureEnabledNavigateMode && outputHandData->IsGestureFired(L"v_sign", gestureData) )
                        {
                            if( gestureFrameStartNumber_Navigate == 0 )
                            {
                                gestureFrameStartNumber_Navigate = gestureData.frameNumber;
                            }
                            else if( (gestureData.frameNumber - gestureFrameStartNumber_Navigate) > frameSwitchCount )
                            {
                                bridgeRealSenseMain->ogreHandModuleMain.isGestureEnabledNavigateMode = false;
                                gestureFrameStartNumber_Navigate = 0;
                            }
                        }
                    }
                    ///////////////////////////////////////////////////////////////////////////////////////////////////
                    ///////////////////////////////////////////////////////////////////////////////////////////////////


                    ///////////////////////////////////////////////////////////////////////////////////////////////////
                    // Work with alert
                    // Alert calibration used for savingadapts users data
                    // details: https://software.intel.com/sites/landingpage/realsense/camera-sdk/2014gold/documentation/html/index.html?manuals_hand_calibration_data.html
                    PXCHandData::AlertData data;
                    if (outputHandData->IsAlertFired(PXCHandData::ALERT_HAND_CALIBRATED, data)) 
                    {
                        configHand->SetUserName(L"Root");
                        configHand->ApplyChanges();
                    }
                    ///////////////////////////////////////////////////////////////////////////////////////////////////


                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                    ////////////////////////////////////////////////////     END HAND MODULE     ///////////////////////////////////////////////////////
                    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                }

                mSenseManager->ReleaseFrame();
            }

            clearBridge();

            // initiate close the RealSense™ resources
            close();
        }

        // Say for thread "Update()" initiate stop the real sense.
        void RealSenseMain::stopRealSense()
        {
            stoped=true;
        }

        // We clear the structure which is mutual for program kernel and RealSense™ modules.
        void RealSenseMain::clearBridge()
        {
            ////////////////////// Clear auxiliary RealSense™ stuffs (not for modules)
            bridgeRealSenseMain->isDeviceConnected=false;

            ////////////////////// Clear HandModule
            RsOgreHandModule::clearOgreHandModuleMain( &bridgeRealSenseMain->ogreHandModuleMain );
        }
        

Поскольку данные поступают с небольшой погрешностью, то для того чтобы виртуальные руки не дергались, а перемещались плавно в RealSense™ SDK есть очень полезный модуль ‘сглаживания’ данных PXCSmoother.

Модуль сглаживания поддерживает несколько алгоритмов. Экспериментальным путем я определил, что для перемещения рук в плоскости монитора (Smoother2D: X/Z) лучше подходит Quadratic Smoother алгоритм. А для передвижения в глубину (Smoother1D: Y) я использую Spring Smoother алгоритм.

И так, моя инновация состоит в том, как перемещаться в виртуальном трехмерном пространстве с помощью одной руки. А благодаря технологии RealSense, у меня получилось реализовать эту идею.

Все это здорово, но чем отличается RealSense™ от того же Kinect*?

Да, Microsoft* тоже создала прибор по принципу Natural Interaction – Kinect*.
Во-первых, Kinect задуман для узкой специализации, а именно, игры и развлекательная индустрия. RealSense™ же позиционируется, кроме игр и развлечений, как полноценное устройство ввода для прикладных приложений. Точность определения частей тела у Kinect на порядок ниже, чем у RealSense. К примеру, стандартно Kinect может определить координаты руки и кисти. RealSense™ на одной только кисти определяет 22 точки, включая положение и направленность всех фаланг пальцев. Это предоставляет отличные возможности для распознавание жестов из пальцев, таких как дуля или Victory.

Понятно, что такая точность в Kinect не достижима, но повторюсь: Kinect позиционируется на другую нишу Natural Interaction приложений. Можно сказать, Kinect для дальнего боя, а RealSense™ для ближнего.

Второе весомое отличие это размер. На данный момент Kinect выпускается как внешнее устройство.

Слева Kinect, справа RealSense™ встраиваемая камера – размер имеет значение! Такой размер позволяет встраивать RealSense™ в ноутбуки и планшеты.

Итак, где реально уже используется технология RealSense

- Отслеживание рук и пальцев в реальном времени – одновременное отслеживание десяти пальцев и восьми жестов:

Пример аудиоредактора, где пользователь создает музыку взмахами рук.

Это пример игры, где герой бросает во врага плазмой.

- Отделение фона, а также фотографии с разным фокусом:

Программа видео-чат, которая благодаря камере глубины, распознает силуэт человека и выделяет задний фон. И пользователь простыми жестами может скрывать, размазывать или заменять фон при общении.

Вот пример фотографии с несколькими фокусами, ведь бывает – сделал снимок года, но авто-фокус лег не на тот объект, что хотелось бы, а технология RealSense™ исправит это:

- Дополнительная реальность

Поскольку в RealSense™ есть алгоритмы распознавания и отслеживания объектов, можно реализовать полувиртуальные миры, где на реальные физические объекты накладывается виртуальная среда (ясно, что из этой фразы вы ничего не поняли, но перед вставкой ссылок я должен был что-то написать).

Дополнительная реальность глазами Intel:
https://youtu.be/2sADRerJzwQ?t=390

https://www.youtube.com/watch?v=VWHmd5ZbVy4

Этот пример демонстрирует, как в дополнительной реальности также используется камера глубины, когда фермер начинает взбираться на реальный физический объект в виде горки.

Что дает технология RealSense™ для ноутбуков

Список компьютеров с уже встроенной RealSense™ 3D камерой.

Ноутбук со встроенной RealSense™ камерой

Кроме вышеперечисленных возможностей и таких экзотических, как сканирование объектов для 3D печати.

Также хочу выделить отдельное направление использования RealSense™ в ноутбуках - это удобная работа с частыми функциями, такими, как изменение громкости динамиков и яркости экрана, запуск/остановка проигрывателя.
Сейчас производители ноутбуков делают функциональные клавиши для частых функций, к примеру, Fn + F8. Но, по своему опыту замечу, что каждый раз попадать на нужные клавиши очень неудобно. На некоторых дорогих моделях есть отдельные сенсорные ползунки, но в темноте тянуться к ним тоже нелегко.
А с помощью технологии RealSense™ можно вертикальным взмахом руки менять громкость, горизонтальным – яркость экрана. С помощью простых жестов можно управлять этим вашим Winamp-ом, и все это без скольжения по тачпаду и поисков функциональных клавиш.

Сейчас в моем ноутбуке есть сканер отпечатка пальцев, что очень удобно (Я даже забыл, какой пароль у меня на ноутбуке). Но согласитесь, технология распознавания лица еще лучший вариант аутентификации пользователя. Копания Intel® разрабатывает модуль “True Key”, вот промо-ролик этой технологии.

У программистов в офисах есть даже традиция подшучивать над новичками, не приученными блокировать компьютер, когда уходят. Например, поставить фотографию розовой феи фоном рабочего стола. Но если система сама будет блокироваться, когда хозяина нет перед монитором, это существенно увеличит безопасность и сделает невозможными такие злые шутки.

Поскольку ноутбук часто используется для видеообщения, камера глубины дает прекрасные возможности для разработки приложений с вырезанием фона и управлением жестами, не думая, на каком колене разместить мышку.

Так что в Intel® поступили очень умно, реализовав RealSense™ в максимально компактном форм-факторе, и такую камеру можно встроить даже в самые тонкие ультрабуки.

А что с безопасностью?

Действительно, чем круче камера, тем качественней утечка информации. Поэтому компания Intel® разработала программу “Privacy Notification”, контролирующую приложения, которым разрешено обращаться к RealSense™ камере.
Во-первых, при запуске приложения, запрашивающего доступ к RealSense™ драйверу, Privacy Notification спрашивает у пользователя, к каким модулям данная программа хочет получить доступ. Также как в мобильных платформах iOS и Android.

Во-вторых, Privacy Notification пишет детальный журнал с указанием программы и времени использования модулей RealSense.

Все действительно так хорошо?

Технология RealSense™ только набирает обороты и есть еще не доработки:

- Камеры RealSense™ работают на Intel® процессорах начиная с четвертого поколения и Windows 8x. Компания это объясняет что для нормальной работы некоторых алгоритмов необходимые специальные инструкции процессора для работы с большими массивами данных (по аналогу с набором инструкций SSE). То есть если ваш процессор, к примеру, Core i5 выпущен до 2013-го года то камера на нем не запустится.
- Если использовать одновременно разные модули, к примеру, отслеживание рук и распознание речи, то модули начинают работать не стабильно, хотя, по некоторым источникам, на процессорах Core i7 такое не наблюдается.
- Если в модуле распознавания рук ладонь повернута внешней стороной к камере, то модуль неверно определяет это левая или правая рука. Действительно, ладони у человека зеркальны, и левая рука внешне имеет такой же контур как правая рука изнутри. Посему для определения стороны руки надо вводить дополнительные параметры (к примеру, средний палец обычно немного согнутый и когда ладонь повернута внутренней стороной к камере, то расстояние от кончика среднего пальца до камеры немного меньше, чем от самой ладони. А когда ладонь повернута внешней стороной к камере, то расстояние немного больше).
- Модуль распознавания лица не отточен на бородатых. Я использовал пример, где обводится контур головы и моя борода сливалась с рубашкой - контур моей головы в районе челюсти начинал сильно искажаться. Я думаю это легко решить, задав специальный параметр, что головы у всех приблизительно овальные и неважно сливается подбородок с туловищем или нет, овал не может быть слишком вытянутый.

Но, учитывая как Intel® взялась за технологию RealSense, можно ожидать оперативных исправлений и обновлений.

В каком направлении может развиваться технология RealSense?

Однозначно управление компьютером с помощью жестов и голоса рано или поздно будет вытеснять старые устройства ввода. Хотя, не исключаю, что клавиатура, пусть виртуальная, но будет еще очень долго.

Когда технология Intel® True Key будет отточена, забытые пароли станут архаизмом. Девиз данной технологии: “Лучший пароль это Вы”.

‘Таргетинг’ эмоций. Распознавая эмоции, рекламная площадка сможет показывать баннеры, так сказать под настроение. К примеру, если пользователь загрустил, ему показывают рекламу пляжей с пальмами, а если дюже хорошее настроение, то можно показать и социальную рекламу о вреде курения.

Можно с уверенностью сказать, что если сегодня во всех ноутбуках есть встроенная камера, то в недалеком будущем системы Natural Interaction будет во всех устройствах. И это не будет восприниматься как нечто экзотическое и узкоспециализированное, а станет обычным аксессуаром.