C++ xn::NodeInfoList类代码示例

/**
 * @brief	Initializes the Scene Analyzer (_scene_analyzer).
 *
 * @retval	true if the Scene Analyzer was successfully created.
 * @retval	false if some error occurred.
 */
bool NIKinect::init_scene_analyzer(int index){
	static xn::NodeInfoList depth_nodes;
	XnStatus rc;
	rc = this->_context->EnumerateProductionTrees (XN_NODE_TYPE_SCENE, NULL, depth_nodes, NULL);

	int counter = 0;
	for (xn::NodeInfoList::Iterator nodeIt =depth_nodes.Begin(); nodeIt != depth_nodes.End(); ++nodeIt, counter++) {
		if(counter == 0){
			xn::NodeInfo info = *nodeIt;
			const XnProductionNodeDescription& description = info.GetDescription();

			rc = this->_context->CreateProductionTree (info);

			rc = info.GetInstance (this->_scene_analyzer);
		
			if (rc != XN_STATUS_OK)
			{
				printf("The Depth Node could not be created.%s\n",xnGetStatusString(rc));
				this->_flags[NIKinect::SCENE_A] = false;

			}
			else{
				this->_flags[NIKinect::SCENE_A] = true;
			}

			break;
		}
	}
	
	if(this->_flags[NIKinect::SCENE_A]){
		this->_scene_analyzer.GetMetaData(this->_scene_md);
	}

	//XnStatus rc = 1;
	////rc = _context->FindExistingNode(XN_NODE_TYPE_SCENE,this->_scene_analyzer);
	////If the generator was already created, don't create it again.
	//if (rc != XN_STATUS_OK)
	//{
	//	rc = _scene_analyzer.Create(_context);

	//	if (rc != XN_STATUS_OK)
	//	{
	//		printf("The Scene Analyzer Node could not be created.%s\n",xnGetStatusString(rc));
	//		this->_flags[NIKinect::SCENE_A] = false;
	//	}
	//	else{
	//		this->_flags[NIKinect::SCENE_A] = true;
	//	}
	//}
	//else{
	//	this->_flags[NIKinect::SCENE_A] = true;
	//}
	
	return this->_flags[NIKinect::SCENE_A];
}

XnStatus XnExportedSensorGenerator::EnumerateProductionTrees(xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* pErrors)
{
	XnStatus nRetVal = XN_STATUS_OK;

	XnProductionNodeDescription Description;
	GetDescription(&Description);

	// perform a query to be sure the device we'll find is the same one exported from this DLL.
	xn::Query query;
	query.SetVendor(XN_VENDOR_PRIMESENSE);
	query.SetName(XN_DEVICE_NAME);
	query.SetMinVersion(Description.Version);
	query.SetMaxVersion(Description.Version);

	nRetVal = context.AutoEnumerateOverSingleInput(TreesList, Description, NULL, XN_NODE_TYPE_DEVICE, pErrors, &query);
	XN_IS_STATUS_OK(nRetVal);

	if (!m_bIsAvailableInLowBand)
	{
		xn::NodeInfoList::Iterator it = TreesList.Begin();
		while (it != TreesList.End())
		{
			xn::NodeInfoList::Iterator curr = it;
			it++;

			xn::NodeInfo node = *curr;

			// take sensor node
			xn::NodeInfo sensorNode = *node.GetNeededNodes().Begin();

			XnBool bIsLowBand;
			nRetVal = XnSensorIO::IsSensorLowBandwidth(sensorNode.GetCreationInfo(), &bIsLowBand);
			XN_IS_STATUS_OK(nRetVal);

			if (bIsLowBand)
			{
				// sensor is low band
				nRetVal = TreesList.Remove(curr);
				XN_IS_STATUS_OK(nRetVal);
			}
		}

		if (TreesList.IsEmpty())
		{
			return XN_STATUS_NO_NODE_PRESENT;
		}
	}
	
	return (XN_STATUS_OK);
}

XnStatus XnExportedFileDevice::EnumerateProductionTrees(xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* pErrors)
{
	XnStatus nRetVal = XN_STATUS_OK;
	
	XnProductionNodeDescription Description;
	GetDescription(&Description);
	nRetVal = TreesList.Add(Description, NULL, NULL);
	XN_IS_STATUS_OK(nRetVal);

	return (XN_STATUS_OK);
}

XnStatus ExportedRecorder::EnumerateProductionTrees(xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* pErrors)
{
	XnProductionNodeDescription description;
	XnStatus nRetVal = XN_STATUS_OK;
	
	GetDescription(&description);
	nRetVal = TreesList.Add(description, CREATION_INFO, NULL);
	XN_IS_STATUS_OK(nRetVal);
		
	return XN_STATUS_OK;
}

XnStatus ExportedSampleDepth::EnumerateProductionTrees( xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* pErrors )
{
	XnStatus nRetVal = XN_STATUS_OK;

	// return one option
	XnProductionNodeDescription desc;
	GetDescription(&desc);

	nRetVal = TreesList.Add(desc, NULL, NULL);
	XN_IS_STATUS_OK(nRetVal);

	return (XN_STATUS_OK);
}

XnStatus XnExportedSensorDevice::EnumerateProductionTrees(xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* /*pErrors*/)
{
	XnStatus nRetVal = XN_STATUS_OK;

	// enumerate connected sensors
	XnUInt32 nCount = 0;

	// check if sensor is connected
	nRetVal = XnSensor::Enumerate(NULL, &nCount);
	if (nRetVal != XN_STATUS_OUTPUT_BUFFER_OVERFLOW)
	{
		// no sensor connected
		return XN_STATUS_DEVICE_NOT_CONNECTED;
	}

	// allocate according to count
	XnConnectionString* pConnStrings;
	XN_VALIDATE_CALLOC(pConnStrings, XnConnectionString, nCount);

	nRetVal = XnSensor::Enumerate(pConnStrings, &nCount);
	if (nRetVal != XN_STATUS_OK)
	{
		xnOSFree(pConnStrings);
		return (nRetVal);
	}

	XnProductionNodeDescription Description;
	GetDescription(&Description);

	for (XnUInt32 i = 0; i < nCount; ++i)
	{
		// Each connection string is a sensor. Return it if it wasn't created already.
		if (FindCreatedDevice(context.GetUnderlyingObject(), pConnStrings[i]) == m_createdDevices.End())
		{
			nRetVal = TreesList.Add(Description, pConnStrings[i], NULL);
			if (nRetVal != XN_STATUS_OK)
			{
				xnOSFree(pConnStrings);
				return (nRetVal);
			}
		}
	}

	xnOSFree(pConnStrings);
	return (XN_STATUS_OK);
}

XnStatus XnExportedSensorDevice::EnumerateProductionTrees(xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* pErrors)
{
	XnStatus nRetVal = XN_STATUS_OK;

	// enumerate connected sensors
	XnUInt32 nCount = 0;

	// check if sensor is connected
	nRetVal = XnSensor::Enumerate(NULL, &nCount);
	if (nRetVal != XN_STATUS_OUTPUT_BUFFER_OVERFLOW)
	{
		// no sensor connected
		XN_LOG_WARNING_RETURN(XN_STATUS_DEVICE_NOT_CONNECTED, XN_MASK_DEVICE_SENSOR, "No PS sensor is connected!");
	}

	// allocate according to count
	XnConnectionString* pConnStrings;
	XN_VALIDATE_CALLOC(pConnStrings, XnConnectionString, nCount);

	nRetVal = XnSensor::Enumerate(pConnStrings, &nCount);
	if (nRetVal != XN_STATUS_OK)
	{
		xnOSFree(pConnStrings);
		return (nRetVal);
	}

	XnProductionNodeDescription Description;
	GetDescription(&Description);

	// each connection string is a sensor. return it
	for (XnUInt32 i = 0; i < nCount; ++i)
	{
		nRetVal = TreesList.Add(Description, pConnStrings[i], NULL);
		if (nRetVal != XN_STATUS_OK)
		{
			xnOSFree(pConnStrings);
			return (nRetVal);
		}
	}

	xnOSFree(pConnStrings);

	return (XN_STATUS_OK);
}

int userTracker::enumerate(xn::Context context, XnPredefinedProductionNodeType type, xn::NodeInfoList& list, std::string infoMsg) {
	//std::cout << "Enumerating " << infoMsg << endl;
	
	XnStatus status = context.EnumerateProductionTrees (type, NULL, list, NULL);

	if (status != XN_STATUS_OK && list.Begin () != list.End ()) { 
		std::cout << "Enumerating " << infoMsg << " failed. Reason: " <<  xnGetStatusString (status) << std::endl; 
		return -1;
	}
	else if (list.Begin () == list.End ()) {
		std::cout << "No " << infoMsg << " found." << std::endl;
		return -1;
	}

	int numNodes = 0;
	for (xn::NodeInfoList::Iterator nodeIt = list.Begin (); nodeIt != list.End (); ++nodeIt, numNodes++) {
		const xn::NodeInfo& info = *nodeIt;
		const XnProductionNodeDescription& description = info.GetDescription();
		printf("device %d vendor %s name %s, instance %s\n", numNodes, description.strVendor, description.strName, info.GetInstanceName());
	}

	//std::cout << "Finishing enumerating: " << infoMsg << endl;
	return numNodes;
}

XnStatus XnXmlScriptNode::Run(xn::NodeInfoList& createdNodes, xn::EnumerationErrors& errors)
{
	return RunXmlScriptImpl(m_context.GetUnderlyingObject(), &m_doc, createdNodes.GetUnderlyingObject(), errors.GetUnderlying());
}

unsigned 
openni_wrapper::OpenNIDriver::updateDeviceList ()
{
  // clear current list of devices
  device_context_.clear ();
  // clear maps
  bus_map_.clear ();
  serial_map_.clear ();
  connection_string_map_.clear ();

  // enumerate all devices
  static xn::NodeInfoList node_info_list;
  XnStatus status = context_.EnumerateProductionTrees (XN_NODE_TYPE_DEVICE, NULL, node_info_list);
  if (status != XN_STATUS_OK && node_info_list.Begin () != node_info_list.End ())
    THROW_OPENNI_EXCEPTION ("enumerating devices failed. Reason: %s", xnGetStatusString (status));
  else if (node_info_list.Begin () == node_info_list.End ())
    return 0; // no exception

  for (xn::NodeInfoList::Iterator nodeIt = node_info_list.Begin (); nodeIt != node_info_list.End (); ++nodeIt)
  {
    connection_string_map_[(*nodeIt).GetCreationInfo ()] = static_cast<unsigned int> (device_context_.size ());
    device_context_.emplace_back(*nodeIt);
  }

  // enumerate depth nodes
  static xn::NodeInfoList depth_nodes;
  status = context_.EnumerateProductionTrees (XN_NODE_TYPE_DEPTH, NULL, depth_nodes, NULL);
  if (status != XN_STATUS_OK)
    THROW_OPENNI_EXCEPTION ("enumerating depth generators failed. Reason: %s", xnGetStatusString (status));

  for (xn::NodeInfoList::Iterator nodeIt = depth_nodes.Begin (); nodeIt != depth_nodes.End (); ++nodeIt)
  {
    // check if to which device this node is assigned to
    for (xn::NodeInfoList::Iterator neededIt = (*nodeIt).GetNeededNodes ().Begin (); neededIt != (*nodeIt).GetNeededNodes ().End (); ++neededIt)
    {
      if ( connection_string_map_.count ((*neededIt).GetCreationInfo ()) )
      {
        unsigned device_index = connection_string_map_[(*neededIt).GetCreationInfo ()];
        device_context_[device_index].depth_node.reset (new xn::NodeInfo(*nodeIt));
      }
    }
  }

  // enumerate image nodes
  static xn::NodeInfoList image_nodes;
  status = context_.EnumerateProductionTrees (XN_NODE_TYPE_IMAGE, NULL, image_nodes, NULL);


  // Suat: This is an ugly ASUS Xtion workaround.
  if (status == XN_STATUS_OK)
  {
    //THROW_OPENNI_EXCEPTION ("enumerating image generators failed. Reason: %s", xnGetStatusString (status));

    for (xn::NodeInfoList::Iterator nodeIt = image_nodes.Begin (); nodeIt != image_nodes.End (); ++nodeIt)
    {
      // check to which device this node is assigned to
      for (xn::NodeInfoList::Iterator neededIt = (*nodeIt).GetNeededNodes ().Begin (); neededIt != (*nodeIt).GetNeededNodes ().End (); ++neededIt)
      {
        if ( connection_string_map_.count ((*neededIt).GetCreationInfo ()) )
        {
          unsigned device_index = connection_string_map_[(*neededIt).GetCreationInfo ()];
          device_context_[device_index].image_node.reset (new xn::NodeInfo(*nodeIt));
        }
      }
    }
  }

  // enumerate IR nodes
  static xn::NodeInfoList ir_nodes;
  status = context_.EnumerateProductionTrees (XN_NODE_TYPE_IR, NULL, ir_nodes, NULL);
  if (status != XN_STATUS_OK)
    THROW_OPENNI_EXCEPTION ("enumerating IR generators failed. Reason: %s", xnGetStatusString (status));

  for (xn::NodeInfoList::Iterator nodeIt = ir_nodes.Begin (); nodeIt != ir_nodes.End (); ++nodeIt)
  {
    // check if to which device this node is assigned to
    for (xn::NodeInfoList::Iterator neededIt = (*nodeIt).GetNeededNodes ().Begin (); neededIt != (*nodeIt).GetNeededNodes ().End (); ++neededIt)
    {
      if ( connection_string_map_.count ((*neededIt).GetCreationInfo ()) )
      {
        unsigned device_index = connection_string_map_[(*neededIt).GetCreationInfo ()];
        device_context_[device_index].ir_node.reset (new xn::NodeInfo(*nodeIt));
      }
    }
  }

#ifndef _WIN32
  // add context object for each found device
  for (size_t deviceIdx = 0; deviceIdx < device_context_.size (); ++deviceIdx)
  {
    // register [email protected] to the corresponding context object
    unsigned short vendor_id;
    unsigned short product_id;
    unsigned char bus;
    unsigned char address;
    sscanf (device_context_[deviceIdx].device_node.GetCreationInfo (), "%hx/%[email protected]%hhu/%hhu", &vendor_id, &product_id, &bus, &address);
    bus_map_ [bus][address] = deviceIdx;
  }

  // get additional info about connected devices like serial number, vendor name and prduct name
//.........这里部分代码省略.........

XnStatus XnExportedSensorImageGenerator::EnumerateProductionTrees(xn::Context& context, xn::NodeInfoList& TreesList, xn::EnumerationErrors* pErrors)
{
	XnStatus nRetVal = XN_STATUS_OK;
	
	nRetVal = XnExportedSensorGenerator::EnumerateProductionTrees(context, TreesList, pErrors);
	XN_IS_STATUS_OK(nRetVal);

	XnStringToBoolHash Devices;

	// make sure device has image CMOS
	xn::NodeInfoList::Iterator it = TreesList.Begin();
	while (it != TreesList.End())
	{
		xn::NodeInfoList::Iterator curr = it;
		it++;

		xn::NodeInfo node = *curr;

		// take sensor node
		xn::NodeInfo sensorNode = *node.GetNeededNodes().Begin();

		XnBool bHasImageCMOS = TRUE;

		if (XN_STATUS_OK != Devices.Get(sensorNode.GetCreationInfo(), bHasImageCMOS))
		{
			// wasn't checked yet. check it now
			xn::Device sensor;
			nRetVal = sensorNode.GetInstance(sensor);
			XN_IS_STATUS_OK(nRetVal);

			XnBool bShouldCreated = (!sensor.IsValid());

			if (bShouldCreated)
			{
				nRetVal = context.CreateProductionTree(sensorNode);
				XN_IS_STATUS_OK(nRetVal);

				nRetVal = sensorNode.GetInstance(sensor);
				XN_IS_STATUS_OK(nRetVal);
			}

			// This is an ugly patch to find out if this sensor has an image CMOS. It will be fixed
			// in future firmwares so we can just ask.
			XnCmosBlankingUnits units;
			units.nCmosID = XN_CMOS_TYPE_IMAGE;
			nRetVal = sensor.GetGeneralProperty(XN_MODULE_PROPERTY_CMOS_BLANKING_UNITS, sizeof(units), &units);
			if (nRetVal != XN_STATUS_OK || units.nUnits == 0)
			{
				// Failed. this means no image CMOS
				bHasImageCMOS = FALSE;
			}

			if (bShouldCreated)
			{
				sensor.Release();
			}

			// add to checked list
			Devices.Set(sensorNode.GetCreationInfo(), bHasImageCMOS);
		}

		if (!bHasImageCMOS)
		{
			// remove it from enumeration
			nRetVal = TreesList.Remove(curr);
			XN_IS_STATUS_OK(nRetVal);
		}
	}

	if (TreesList.IsEmpty())
	{
		return XN_STATUS_NO_NODE_PRESENT;
	}
	
	return (XN_STATUS_OK);
}

/**
 * @brief	Initializes the Image Generator (_image_generator).
 *
 * @retval	true if the generator was successfully created.
 * @retval	false if some error occurred.
 */
bool NIKinect::init_image_generator(int index){
	static xn::NodeInfoList image_nodes;
	XnStatus rc;
	rc = this->_context->EnumerateProductionTrees (XN_NODE_TYPE_IMAGE, NULL, image_nodes, NULL);

	int counter = 0;
	for (xn::NodeInfoList::Iterator nodeIt =image_nodes.Begin(); nodeIt != image_nodes.End(); ++nodeIt, counter++) {
		if(counter == 0){
			xn::NodeInfo info = *nodeIt;
			const XnProductionNodeDescription& description = info.GetDescription();

			rc = this->_context->CreateProductionTree (info);

			this->_image_generator = new xn::ImageGenerator();
			rc = info.GetInstance (*this->_image_generator);
		
			if (rc != XN_STATUS_OK)
			{
				printf("The Depth Node could not be created.%s\n",xnGetStatusString(rc));
				this->_flags[NIKinect::IMAGE_G] = false;
				this->_flags_processing[NIKinect::IMAGE_P] = false;

			}
			else{
				this->_flags[NIKinect::IMAGE_G] = true;
				this->_flags_processing[NIKinect::IMAGE_P] = true;
			}

			this->_image_generator->SetMapOutputMode(_image_mode);
			//this->_image_generator->GetMetaData(this->_image_md);
			this->_image_generator->StartGenerating();

			break;
		}
	}

	if(this->_flags[NIKinect::IMAGE_G]){
		this->_image_generator->GetMetaData(this->_image_md);	
		//if(this->_flags[NIKinect::DEPTH_G]){
		//	this->_depth_generator->GetAlternativeViewPointCap().SetViewPoint(*this->_image_generator);
		//}
	}

	//XnStatus rc;
	//rc = _context->FindExistingNode(XN_NODE_TYPE_IMAGE,this->_image_generator);
	////If the generator was already created, don't create it again.
	//if (rc != XN_STATUS_OK)
	//{
	//	rc = _image_generator->Create(_context);

	//	if (rc != XN_STATUS_OK)
	//	{
	//		printf("The Image Node could not be created.%s\n",xnGetStatusString(rc));
	//		this->_flags[NIKinect::IMAGE_G] = false;
	//		this->_flags_processing[NIKinect::IMAGE_P] = false;
	//	}
	//	else{
	//		this->_flags[NIKinect::IMAGE_G] = true;
	//		this->_flags_processing[NIKinect::IMAGE_P] = true;
	//	}
	//}
	//else{
	//	this->_flags[NIKinect::IMAGE_G] = true;
	//	this->_flags_processing[NIKinect::IMAGE_P] = true;
	//}

	//if(this->_flags[NIKinect::IMAGE_G]){
	//	this->_image_generator->GetMetaData(this->_image_md);		
	//	this->_depth_generator->GetAlternativeViewPointCap().SetViewPoint(this->_image_generator);
	//}

	return this->_flags[NIKinect::IMAGE_G];
}

/**
 * @brief	Initializes the Depth Generator (_depth_generator).
 *
 * @retval	true if the generator was successfully created.
 * @retval	false if some error occurred.
 */
bool NIKinect::init_depth_generator(int index){
	static xn::NodeInfoList depth_nodes;
	XnStatus rc;
	rc = this->_context->EnumerateProductionTrees (XN_NODE_TYPE_DEPTH, NULL, depth_nodes, NULL);

	int counter = 0;
	for (xn::NodeInfoList::Iterator nodeIt =depth_nodes.Begin(); nodeIt != depth_nodes.End(); ++nodeIt, counter++) {
		if(counter == index){
			xn::NodeInfo info = *nodeIt;
			const XnProductionNodeDescription& description = info.GetDescription();
	
			XnMapOutputMode mode;
			mode.nXRes	= 640;
			mode.nYRes	= 480;
			mode.nFPS	= 30;

			rc = this->_context->CreateProductionTree (info);
		
			this->_depth_generator = new xn::DepthGenerator();
			//DepthMetaData* g_depthMD = new DepthMetaData();

			rc = info.GetInstance (*this->_depth_generator);
		
			if (rc != XN_STATUS_OK)
			{
				printf("The Depth Node could not be created.%s\n",xnGetStatusString(rc));
				this->_flags[NIKinect::DEPTH_G] = false;
				this->_flags_processing[NIKinect::DEPTH_P] = false;
				this->_flags_processing[NIKinect::MASK_P] = false;

			}
			else{
				this->_flags[NIKinect::DEPTH_G] = true;
				this->_flags_processing[NIKinect::DEPTH_P] = true;
				this->_flags_processing[NIKinect::MASK_P] = true;
			}

			this->_depth_generator->SetMapOutputMode(mode);
			//this->_depth_generator->GetMetaData(this->_depth_md);
			this->_depth_generator->StartGenerating();

			break;
		}
	}

	if(this->_flags[NIKinect::DEPTH_G]){
		this->_depth_generator->GetMetaData(this->_depth_md);
	}

	//rc = _context->FindExistingNode(XN_NODE_TYPE_DEPTH,this->_depth_generator);
	////If the generator was already created, don't create it again.
	//if (rc != XN_STATUS_OK)
	//{
	//	rc = _depth_generator->Create(_context);

	//	if (rc != XN_STATUS_OK)
	//	{
	//		printf("The Depth Node could not be created.%s\n",xnGetStatusString(rc));
	//		this->_flags[NIKinect::DEPTH_G] = false;
	//		this->_flags_processing[NIKinect::DEPTH_P] = false;
	//		this->_flags_processing[NIKinect::MASK_P] = false;

	//	}
	//	else{
	//		this->_flags[NIKinect::DEPTH_G] = true;
	//		this->_flags_processing[NIKinect::DEPTH_P] = true;
	//		this->_flags_processing[NIKinect::MASK_P] = true;
	//	}
	//}
	//else{
	//	this->_flags[NIKinect::DEPTH_G] = true;
	//	this->_flags_processing[NIKinect::DEPTH_P] = true;
	//	this->_flags_processing[NIKinect::MASK_P] = true;
	//}

	return this->_flags[NIKinect::DEPTH_G];
}

// most code came from: http://groups.google.com/group/openni-dev/browse_thread/thread/cde3217c242a3687/3c1463337f6f2951?lnk=gst&q=multiple#3c1463337f6f2951
void MultipleKinects::init() {
	printf("MultipleKinects.init()\n");

	XnStatus returnCode;

	printf("Initializing context ...\n");
	returnCode = this->context.Init();
	if(returnCode != XN_STATUS_OK) { THROW_XN_EXCEPTION("Initialisation failed!", returnCode); }

	printf("Looking for connected devices...\n");
	static xn::NodeInfoList deviceInfoList;
	returnCode = this->context.EnumerateProductionTrees(XN_NODE_TYPE_DEVICE, NULL, deviceInfoList);
	if(returnCode != XN_STATUS_OK) { THROW_XN_EXCEPTION("Enumerating device nodes failed!", returnCode); }

	if(deviceInfoList.Begin() == deviceInfoList.End()) {
		std::string errorMsg = "Device node list is empty! (Probably no devices connected?!)";
		throw errorMsg;
	}
	std::vector<xn::NodeInfo> deviceInfos;
	int c = 0; // i'd like to have a "c++" ;)
	for (xn::NodeInfoList::Iterator it = deviceInfoList.Begin(); it != deviceInfoList.End(); ++it) {
		deviceInfos.push_back(*it);
		c++; // yeah!!! :)))
	}
	printf("Connected devices: %i\n", c);

//	printf("Looking for available depth generators...\n");
//	static xn::NodeInfoList depth_nodes;
//	status = context_.EnumerateProductionTrees (XN_NODE_TYPE_DEPTH, NULL, depth_nodes, NULL);
//	if(returnCode != XN_STATUS_OK) { THROW_XN_EXCEPTION("Enumerating depth generator nodes failed!", returnCode); }
//	vector<xn::NodeInfo> depth_info;
//	for (xn::NodeInfoList::Iterator nodeIt = depth_nodes.Begin (); nodeIt != depth_nodes.End (); ++nodeIt) {
//		depth_info.push_back (*nodeIt);
//	}

	printf("Looking for available image generators...\n");
	static xn::NodeInfoList imageInfoList;
	returnCode = this->context.EnumerateProductionTrees(XN_NODE_TYPE_IMAGE, NULL,imageInfoList, NULL);
	if(returnCode != XN_STATUS_OK) { THROW_XN_EXCEPTION("Enumerating image nodes failed!", returnCode); }

	std::vector<xn::NodeInfo> imageInfos;
	for (xn::NodeInfoList::Iterator it = imageInfoList.Begin(); it != imageInfoList.End(); ++it) {
		imageInfos.push_back(*it);
	}

	if(deviceInfos.size() != imageInfos.size() /* || dev.size != depth.size */) {
		std::string errorMsg = "Number of devices does not match number of image streams!";
		throw errorMsg;
	}

	for (unsigned i = 0; i < deviceInfos.size(); i++) {
		printf("Processing device number %i#.\n", (i+1));
		xn::NodeInfo deviceInfo = deviceInfos[i];
		xn::NodeInfo imageInfo = imageInfos[i];

	//	returnCode = this->context.CreateProductionTree(const_cast<xn::NodeInfo&>(deviceInfo));
	//	if(returnCode != XN_STATUS_OK) { THROW_XN_EXCEPTION("Creating depth generator failed!", returnCode); }

		printf("Creating image generator production node...\n");
		returnCode = this->context.CreateProductionTree(const_cast<xn::NodeInfo&>(imageInfo));
		if(returnCode != XN_STATUS_OK) { THROW_XN_EXCEPTION("Creating image generator instance failed!", returnCode); }

		// get production node instances
	//	returnCode = depth_node.GetInstance(depth_generator_);
	//	if(returnCode != XN_STATUS_OK) { THROW_XN_EXCEPTION("Creating depth generator instance failed!", returnCode); }

		xn::ImageGenerator imageGenerator;
		returnCode = imageInfo.GetInstance (imageGenerator);
		if(returnCode != XN_STATUS_OK) { THROW_XN_EXCEPTION("Creating image generator instance failed!", returnCode); }

		NiDevice* device = new NiDevice(deviceInfo, imageInfo, imageGenerator, this->imageSaver);
		device->printToString();
		device->init();
		this->devices.push_back(device);
	}
}