/** * @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 bus@address 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/%hx@%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 getDeviceInfos (); #endif // build serial number -> device index map for (size_t deviceIdx = 0; deviceIdx < device_context_.size (); ++deviceIdx) { std::string serial_number = getSerialNumber (deviceIdx); if (!serial_number.empty ()) serial_map_[serial_number] = deviceIdx; } // redundant, but needed for Windows right now and also for Xtion for (const auto &device : device_context_) { unsigned short product_id; unsigned short vendor_id; getDeviceType(device.device_node.GetCreationInfo (), vendor_id, product_id ); #if _WIN32 if (vendor_id == 0x45e) { strcpy (const_cast<char*> (device_context_[device].device_node.GetDescription ().strVendor), "Microsoft"); strcpy (const_cast<char*> (device_context_[device].device_node.GetDescription ().strName), "Xbox NUI Camera"); } else #endif if (vendor_id == 0x1d27 && device.image_node.get () == 0) { strcpy (const_cast<char*> (device.device_node.GetDescription ().strVendor), "ASUS"); strcpy (const_cast<char*> (device.device_node.GetDescription ().strName), "Xtion Pro"); } } return (static_cast<unsigned int> (device_context_.size ())); }
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); } }