在 OpenNI 環境同時使用多個 Kinect

首先，先來看一下 CDeviceWindow 這個類別的內容。他基本上是用來對應 OpenNI 環境裡的個別的單一個 device（Heresy 這邊就是 Microsoft Kinect），所以裡面儲存了這個裝置的、各種有用到的 node；在這裡，就是 mDevice（device node）、mDepth（depth generator）和 mImage（image generator）。

此外，為了要使用 Qt 的 Graphics View 來做視覺上的呈現，所以也還有 qScene 和 qView 等其他的 member data，這些就等有用到再講了。

不過，這部分主要是 OpenNI 和 Qt 之間的連動，如果只是想看怎麼樣在 OpenNI 裡面同時使用多個裝置的話，可以跳過這一段，直接跳到下面 QOpenNIWindows 的部分。

而下面，就是 CDeviceWindow 這個類別的內容：

// class to handle OpenNI Device and Qt Window
class CDeviceWindow
{
public:
  // constructor
  CDeviceWindow(); 
  // destructor
  ~CDeviceWindow();
  // Update Qt graphic image from OpenNI device
  bool UpdateImage();

public:
  xn::Device         mDevice;   // OpenNI Device Node
  xn::DepthGenerator mDepth;    // OpenNI Depth Generator
  xn::ImageGenerator mImage;    // OpenNI Image Generator
  XnDepthPixel       mMaxDepth; // Keep max. depth value
 
  QGraphicsScene     qScene;    // scene of Qt
  QGraphicsView      qView;     // graphics view of Qt
 
private:
  unsigned char*      pTmpDepthImage; // temporary 8bit depth image
  xn::ImageMetaData   mColorImage;    // RGB Color image from OpenNI
  xn::DepthMetaData   mDepthImage;    // Raw depth image from OpenNI
 
  QGraphicsPixmapItem qColorImage;    // color image in Qt format
  QGraphicsPixmapItem qDepthImage;    // depth image in Qt format
};

其中，建構子的部分，主要是進行 Qt 環境的設定，不算是本文的重點，所以在這邊就先跳過了；有需要的話，請參考之前的《使用 Qt GraphicsView 顯示 OpenNI 影像資料》。

而實際上，CDeviceWindow 主要的功用除了資料的儲存外，就是 UpdateImage() 這個函式了∼在這個函式裡，會去讀取 OpenNI Image Generator（mImage）和 Depth Generator（mDepth）的資料，並把她轉換為 Qt 所需要的格式、拿來顯示。其程式碼內容如下：

// Update Qt graphic image from OpenNI device
bool UpdateImage()
{
  if( !qView.isVisible() )
    return false;

  // 1. get color image
  mImage.GetMetaData( mColorImage );
  qColorImage.setPixmap( QPixmap::fromImage(
      QImage( mColorImage.Data(),
              mColorImage.XRes(), mColorImage.YRes(),
              QImage::Format_RGB888 ) ) );

  // 2. get depth image
  mDepth.GetMetaData( mDepthImage );
  // 2a. create 8 bit depth image
  unsigned int uSize = mDepthImage.XRes() * mDepthImage.YRes();
  if( pTmpDepthImage == NULL )
    pTmpDepthImage = new unsigned char[ 4 * uSize ];
  for( unsigned int i = 0; i < uSize;    i )
  {
    unsigned char ucValue = 0;
    if( mDepthImage[i] != 0 )
      ucValue = 255 * ( mMaxDepth - mDepthImage[i] ) / mMaxDepth;
    pTmpDepthImage[ 4 * i     ] = 0;        // blue
    pTmpDepthImage[ 4 * i   1 ] = ucValue;  // green
    pTmpDepthImage[ 4 * i   2 ] = ucValue;  // red
    pTmpDepthImage[ 4 * i   3 ] = ucValue;  // alpha
  }
  // 2b. update image in Qt
  qDepthImage.setPixmap( QPixmap::fromImage(
      QImage( pTmpDepthImage,
              mDepthImage.XRes(), mDepthImage.YRes(),
              QImage::Format_ARGB32 ) ) );

  return true;
}

在上面的程式碼中，第一部分就是先透過 xn::ImageGenerator 的 GetMetaData() 函式，取得包含 metadata 的彩色影像資料，然後再把它轉型成 Qt 的 QImage、建立 QPixmap，然後讓 qColorImage 來使用。

由於 image generator 的資料格式基本上就是一般的 RGB888 的格式，所以這邊可以很方便、不用做特殊的處理，就直接把得到的資料拿來使用。

但是由於 Depth Generator 的深度資料不是一般的影像形式，所以就必須要先進行轉換，把它轉換成 8bit 的圖；而為了讓彩色的圖和深度圖可以疊在一起，所以 Heresy 這邊是把 depth map 轉換為帶有透明度（alpha）的 ARGB32 的形式。而在這裡，pTmpDepthImage 就是用來儲存轉換出來的結果的，由於是 ARGB 的形式，所以他的資料量會是點數的四倍。

在把深度資料轉換成 8bit 的計算，Heresy 這邊是用很簡單的算法：

ucValue = 255 * ( mMaxDepth - mDepthImage[i] ) / mMaxDepth;

也就是先記下 depth generator 的最大深度值（mMaxDepth，可透過 depth generator 的 GetDeviceMaxDepth() 取得），然後以此把每一個像素的資料，都以線性調整的方法，轉換成 0 – 255 之間的值。（註 1）

而當處理完成整張深度圖後，接下來就可以和處理彩色影像時一樣，把它轉換成 qDepthImage 可以使用的 QPixmap 的形式了。

由於在這個程式裡，Heresy 只用了一個 xn::Context 來做 OpenNI 的管理，所以這邊也建立了一個 QOpenNIWindows 的類別來對應，作為 OpenNI context 以及所有 device 的統一管理；基本上，他在程式裡只會有一個物件，而在 main() 裡，也只會對 QOpenNIWindows 這個類別的物件進行操作，不會直接碰到內部的 CDeviceWindow 。

而實際上在 OpenNI 裡，控制控制電腦同時去存取多個裝置的程式，也就是這一部分。

他的內容基本上如下：

// class for OpenNI context and qt windows manager
class QOpenNIWindows: public QObject
{
public:
  // destructor
  ~QOpenNIWindows();
  // initial OpenNI, enumerate device
  bool Initial(); 
  // create OpenNI nodes and Qt window
  bool CreateDeviceAndWindow();
  // start timer to update image
  bool Start( int iInterval = 33 );
 
private:
  XnStatus                m_eResult;
  xn::Context             m_xContext;
  xn::NodeInfoList        m_xDeviceList;
  vector<CDeviceWindow*>  m_vDevWinList;
 
private:
  bool CheckOpenNIError( const string& sStatus );
  // timer to update data
  void timerEvent( QTimerEvent *event ); 
  // release OpenNI nodes and qt resource
  void Release();
};

QOpenNIWindows 為了使用 QT 裡的 QObject::timerEvent() 來做定時的更新（註 2），所以必須繼承 QObject；而在 member data 的部分，除了 m_xContext 是 OpenNI 的 xn::Context 外，還包含了透過 EnumerateProductionTrees() 所列舉出來的 device 的資訊列表 m_xDeviceList，以及自己建立出來的 CDeviceWindow 清單：m_vDevWinList。

而在 member function 的部分，Initial() 就是在進行 OpenNI 環境的初始化、並且透過 xn::Context 提供的 EnumerateProductionTrees() 這個函式，進行裝置的查詢，並將其結果儲存於 m_xDeviceList 內。其程式碼內容如下：

// initial OpenNI, enumerate device
bool Initial()
{
  // 1. initial context
  m_eResult = m_xContext.Init();
  if( CheckOpenNIError( "Context initialization" ) )
    return false;

  // 2. Enumerate Device
  m_eResult = m_xContext.EnumerateProductionTrees( XN_NODE_TYPE_DEVICE, NULL, m_xDeviceList );
  if( CheckOpenNIError( "Enumerate device" ) )
    return false;

  // 3. check if there is device existed
  if( m_xDeviceList.IsEmpty() )
  {
    cerr << "No OpenNI device found" << endl;
    return false;
  }

  return true;
}

而 CreateDeviceAndWindow() 所做的事，就是去把 m_xDeviceList 裡的每一個 device node 都建立出來，並建立出對應的 depth generator 以及 image generator；最後，則是以 CDeviceWindow 的形式，儲存在 m_vDevWinList 裡，拿來做之後的操作、管理。

他的程式碼如下：

// create OpenNI nodes and Qt window
bool CreateDeviceAndWindow()
{
  // check if there is already Device window existed
  if( !m_vDevWinList.empty() )
  {
    Release();
  }

  // create nodes and window for each device
  for( xn::NodeInfoList::Iterator itDev = m_xDeviceList.Begin();
        itDev != m_xDeviceList.End();    itDev )
  {
    CDeviceWindow*  pDevWin = new CDeviceWindow();
    xn::NodeInfo  mNodeInfo = *itDev;

    // 1. create and initial OpenNI nodes
    {
      // a. create device
      m_eResult = m_xContext.CreateProductionTree( mNodeInfo, pDevWin->mDevice );
      if( CheckOpenNIError( "Create Device" ) )
        break;

      // b. build query rule for given device
      xn::Query mQuery;
      mQuery.AddNeededNode( mNodeInfo.GetInstanceName() );

      // c. create depth generator
      m_eResult = pDevWin->mDepth.Create( m_xContext, &mQuery );
      if( CheckOpenNIError( "Create Depth Generator" ) )
      {
        pDevWin->mDevice.Release();
        delete pDevWin;
        break;
      }
      pDevWin->mMaxDepth = pDevWin->mDepth.GetDeviceMaxDepth();

      // d. create image generator
      m_eResult = pDevWin->mImage.Create( m_xContext, &mQuery );
      if( CheckOpenNIError( "Create Image Generator" ) )
      {
        pDevWin->mDepth.Release();
        pDevWin->mDevice.Release();
        delete pDevWin;
        break;
      }

      // e. Set Alternative View Point
      pDevWin->mDepth.GetAlternativeViewPointCap().SetViewPoint( pDevWin->mImage );
    }

    // 2. Qt Setting
    pDevWin->qView.setWindowTitle( mNodeInfo.GetInstanceName() );
    pDevWin->qView.show();

    m_vDevWinList.push_back( pDevWin );
  }

  // check result
  if( m_vDevWinList.empty() )
    return false;
  return true;
}

這邊的工作，就是先透過 iterator 去掃過整個 m_xDeviceList，針對裡面的每一個 NodeInfo 來做處理；而最主要的部分，自然就是針對 NodeInfo 來建立對應的 OpenNI production node 了∼

首先，在 a 的部分，這裡還是一樣使用 xn::Context 的 CreateProductionTree() 這個函式，透過指定 xn::NodeInfo 的方法，來建立出所需要的 device node（pDevWin->mDevice）。

而在 device node 建立完成後， 接著就是使用他的 instance name，來做為後續其他 production node 的使用條件。所以在這邊是先建立一個 xn::Query 的物件 mQuery、代表一個查詢的條件；然後再透過他的 AddNeededNode() 函式，要求「一定要使用給定的 node」，而這邊的判斷條件，就是靠 NodeIfno 的 instance name 了∼

接下來在 c、d 的部分，就是要建立 depth generator 和 image generator 的 production node 了。雖然在論壇上的範例是使用 xn::Context 的 CreateAnyProductionTree() 這個函式來建立 production node，不過實際上每個 node 都有的 Create() 函式，也是可以透過附加指定 xn::Query 的方法，來做到有條件的 production node 的建立的∼它的用法就是：

pDevWin->mDepth.Create( m_xContext, &mQuery );

也就是在呼叫的時候，加上第二個參數，把設定好的 xn::Query 的物件的指標傳進去，這樣他就會去 m_xContext 裡面尋找、建立符合條件的 node 了∼（註 3）

而當 OpenNI 的這些 node 都建立完成後，接下來就是進行 Qt 的最後設定（拿 Instance name 當視窗標題）、並且把視窗顯示出來了∼

當然，為了之後的操作與管理，這裡也把建立出來的 CDeviceWindow 物件（pDevWin），存放到 m_vDevWinList 內。

而最後，就是設定 Qt 的 timer，讓程式可以自動去更新畫面了∼前面已經有提到了，Heresy 在這邊是使用 QT 的 QObject::timerEvent() 來實作這一部分的。

首先，是 Start() 這個函式。這個函式主要是給外部控制，開始 OpenNI 以及 Qt 的更新用的（目前沒有寫 stop），內容主要就是在呼叫 OpenNI context 的 StartGeneratingAll() 後，再去呼叫 Qt QObject 的 startTimer()，來要求 Qt 在每隔一段時間（iInterval、單位毫秒）後，就自動去執行 timerEvent() 這個 callback function，以進行更新。

由於做的事不多，所以 Start() 的內容也不長，它的原始碼就只有下面這幾行：

// start timer to update image
bool Start( int iInterval = 33 )
{
  // start generating OpenNI data
  m_eResult = m_xContext.StartGeneratingAll();
  if( CheckOpenNIError( "Start Generating" ) )
    return false;

  // start Qt timer
  startTimer( iInterval );
  return true;
}

而在 timerEvent() 的部分，它就是實際上每隔一段時間，就會被自動執行的程式了∼他所做的是有兩件，第一個是去呼叫 OpenNI Context 的 WaitAndUpdateAll()、要求 OpenNI 更新所有 production node 的資料。等到資料都更新完後，接下來就是 iterator 掃過整個 m_vDevWinList，呼叫每個建立出來的 CDeviceWindow 的 UpdateImage() 函式、以進行視窗畫面的更新。

// timer to update data
void timerEvent( QTimerEvent *event )
{
  // request OpenNI to update data
  m_eResult = m_xContext.WaitAndUpdateAll();
  if( CheckOpenNIError( "Update data" ) )
    return;

  // update data for each device and window
  for( vector<CDeviceWindow*>::iterator itDev = m_vDevWinList.begin();
        itDev != m_vDevWinList.end();    itDev )
    (*itDev)->UpdateImage();
}

1. 把深度圖轉換成 8bit 的方法有很多種，可以視自己的需要做修改。像 Heresy 之前的方法，就是每個畫面都各自去找最大值，然後再做線性調整，效率會比較差一點。

2. QObject::timerEvent() 的詳細說明請參考官網。
   雖然 Qt 本身也有提供更高階的 QTimer 可以用（官方介紹），但是由於一定得搭配 Qt 自己的 signal / slot 來使用，會比較麻煩，所以這邊不採用這個方案。

3. 在 CreateDeviceAndWindow() 裡建立 image generator 和 depth generator 時（c、d），Heresy 都加上了失敗時的錯誤處理（CheckOpenNIError() 的部分），主要是用來把已建立的資源釋放掉。