void DetectorQualityEvaluator::readDefaultRunParams (FileNode &fn) { if (! fn.empty() ) { isSaveKeypointsDefault = (int)fn[IS_SAVE_KEYPOINTS] != 0; defaultDetector->read (fn); } }
/** * Create intermediate directory to build full tree */ FileNode *FileNode::createIntermediateDir(struct zip *zip, const char *fname) { FileNode *n = new FileNode(zip, fname, NEW_NODE_INDEX); if (n == NULL) { return NULL; } n->state = NEW_DIR; n->is_dir = true; n->has_cretime = true; n->m_mtime = n->m_atime = n->m_ctime = n->cretime = time(NULL); n->m_size = 0; n->m_mode = S_IFDIR | 0775; n->parse_name(); return n; }
static inline void readVectorOrMat(const FileNode & node, std::vector<T> & v) { if (node.type() == FileNode::MAP) { Mat m; node >> m; m.copyTo(v); }
int imageDB::readKeyMap(const FileStorage& cvfs, const FileNode& node) { keypoint_map.clear(); int keypoint_id; FileNodeIterator it = node.begin(); while(it != node.end()){ vector<KeyPoint> keypt_vec; keypoint_id = (int)(*it)["keypoint_id"]; cv::read((*it)["KeyPoint"], keypt_vec); keypoint_map.insert(pair<int,KeyPoint>(keypoint_id,keypt_vec[0])); it++; } return 0; }
void CaffeClassifier::Impl::SetParams(const FileNode& params_file_node) { CV_Assert(!params_file_node.isNone()); params_file_node["device_id"] >> device_id; params_file_node["net_description_file"] >> net_description_file; params_file_node["net_binary_file"] >> net_binary_file; params_file_node["output_blob_name"] >> output_blob_name; }
virtual int readRunParams( FileStorage& fs ) { int code = CV_StereoMatchingTest::readRunParams(fs); FileNode fn = fs.getFirstTopLevelNode(); assert(fn.isSeq()); for( int i = 0; i < (int)fn.size(); i+=4 ) { string caseName = fn[i], datasetName = fn[i+1]; RunParams params; string ndisp = fn[i+2]; params.ndisp = atoi(ndisp.c_str()); string iterCount = fn[i+3]; params.iterCount = atoi(iterCount.c_str()); caseNames.push_back( caseName ); caseDatasets.push_back( datasetName ); caseRunParams.push_back( params ); } return code; }
void readVectorOfVector(FileStorage &fns, string name, vector<vector<KeyPoint> > &vov) { vov.clear(); FileNode fn = fns[name]; if (fn.empty()){ return; } FileNodeIterator current = fn.begin(), it_end = fn.end(); // Go through the node for (; current != it_end; ++current) { vector<KeyPoint> tmp; FileNode item = *current; read(item, tmp); vov.push_back(tmp); } }
void read(const FileNode& node, ICFDetector& d, const ICFDetector& default_value) { if( node.empty() ) d = default_value; else d.read(node); }
bool DataSetVOC::loadBBoxes(CStr &nameNE, vector<Vec4i> &boxes, vecI &clsIdx) { string fName = format(_S(annoPathW), _S(nameNE)); FileStorage fs(fName, FileStorage::READ); FileNode fn = fs["annotation"]["object"]; boxes.clear(); clsIdx.clear(); if (fn.isSeq()){ for (FileNodeIterator it = fn.begin(), it_end = fn.end(); it != it_end; it++) loadBox(*it, boxes, clsIdx); } else loadBox(fn, boxes, clsIdx); fs.release(); return true; }
void ImageMolecule::deserialize(const cv::FileNode& fn) { FileNode atoms = fn["atoms"]; CV_Assert(atoms.type() == FileNode::SEQ); std::map<int, Ptr<ImageAtom> > a_map; for (size_t i = 0; i < atoms.size(); i++) { Ptr<ImageAtom> atom(new ImageAtom); atom->deserialize(atoms[i]); a_map[atom->uid()] = atom; //we will insert from pairs... insertAtom(atom); } FileNode pairs = fn["pairs"]; CV_Assert(pairs.type() == FileNode::SEQ); vector<AtomPair> pairs_temp; pairs_temp.resize(pairs.size()); for (size_t i = 0; i < pairs.size(); i++) { pairs_temp[i].deserialize(pairs[i]); pairs_temp[i].setAtom1(a_map[pairs_temp[i].atom1()->uid()]); pairs_temp[i].setAtom2(a_map[pairs_temp[i].atom2()->uid()]); } insertPairs(pairs_temp); }
bool load(const String &fn) { FileStorage fs(fn, FileStorage::READ); if (! fs.isOpened()) return false; bool ok = classifier->load(fs); FileNode pers = fs["persons"]; FileNodeIterator it = pers.begin(); for( ; it != pers.end(); ++it ) { int id; (*it) >> id; string s =(*it).name(); persons[id] = s; } fs.release(); return ok; }
void DescriptorQualityEvaluator::readDefaultRunParams (FileNode &fn) { if (! fn.empty() ) { commRunParamsDefault.projectKeypointsFrom1Image = (int)fn[PROJECT_KEYPOINTS_FROM_1IMAGE] != 0; commRunParamsDefault.matchFilter = (int)fn[MATCH_FILTER]; defaultDescMatcher->read (fn); } }
//============================================================================== void shape_model:: read(const FileNode& node) { assert(node.type() == FileNode::MAP); node["V"] >> V; node["e"] >> e; node["C"] >> C; node["Y"] >> Y; p = Mat::zeros(e.rows,1,CV_32F); }
void ICFDetector::read(const FileNode& node) { waldboost_ = Ptr<WaldBoost>(createWaldBoost(WaldBoostParams())); String f_temp; node["model_n_rows"] >> model_n_rows_; node["model_n_cols"] >> model_n_cols_; f_temp = (String)node["ftype"]; this->ftype_ = (string)f_temp.c_str(); waldboost_->read(node["waldboost"]); FileNode features = node["features"]; features_.clear(); vector<int> p; for( FileNodeIterator n = features.begin(); n != features.end(); ++n ) { (*n) >> p; features_.push_back(p); } }
bool f_lcc::load_rad_data() { char buf[1024]; snprintf(buf, 1024, "%s.yml", m_fmap); int size; FileStorage fs(buf, FileStorage::READ); if(!fs.isOpened()){ cerr << "Failed to open " << buf << endl; return false; }else{ FileNode fn = fs["LCCR"]; if(!fn.empty()){ fn >> size; } fn = fs["LCCAMap"]; if(!fn.empty()){ fn >> m_amap; }
void UndistortImages::loadImages( char* images_list ){ FileStorage fs; fs.open(images_list,FileStorage::READ); if( !fs.isOpened() ){ cerr << " Fail to open " << images_list << endl; exit(EXIT_FAILURE); } cout << " Images size = " << fs["images"].size() << endl; FileNode imagesPathNode = fs["images"]; for(FileNodeIterator it = imagesPathNode.begin(); it != imagesPathNode.end(); ++it){ inputImagesPaths.push_back( *it ); } fs.release(); }
virtual int readRunParams( FileStorage& fs ) { int code = CV_StereoMatchingTest::readRunParams(fs); FileNode fn = fs.getFirstTopLevelNode(); assert(fn.isSeq()); for( int i = 0; i < (int)fn.size(); i+=5 ) { string caseName = fn[i], datasetName = fn[i+1]; RunParams params; string ndisp = fn[i+2]; params.ndisp = atoi(ndisp.c_str()); string winSize = fn[i+3]; params.winSize = atoi(winSize.c_str()); string fullDP = fn[i+4]; params.fullDP = atoi(fullDP.c_str()) == 0 ? false : true; caseNames.push_back( caseName ); caseDatasets.push_back( datasetName ); caseRunParams.push_back( params ); } return code; }
int imageDB::readFeatureKptMap(const FileStorage& cvfs, const FileNode& node) { feature_KPT_map.clear(); int feature_id; featureInfo feature_info; FileNodeIterator it = node.begin(); while(it != node.end()){ feature_id = (int)(*it)["feature_id"]; feature_info.keypoint_id = (int)(*it)["keypoint_id"]; feature_info.img_id = (int)(*it)["img_id"]; feature_KPT_map.insert(pair<int, featureInfo>(feature_id,feature_info)); it++; } return 0; }
/// static function that reads the settings file /// @param[in] node FileNode to read from /// @param[out] Settings Settings to be saved from FileNode /// @param[in] default_value value by default if FileNode is empty static void read(const FileNode& node, Settings& x, const Settings& default_value = Settings()) { if (node.empty()){ x = default_value; } else{ x.read(node); } }
bool CvFeatureParams::read( const FileNode &node ) { if( node.empty() ) return false; maxCatCount = node[CC_MAX_CAT_COUNT]; featSize = node[CC_FEATURE_SIZE]; numFeatures = node[CC_NUM_FEATURES]; return ( maxCatCount >= 0 && featSize >= 1 ); }
static bool readStringList(const string &filename, vector<string> &l) { l.resize(0); FileStorage fs(filename, FileStorage::READ); if (!fs.isOpened()) return false; FileNode n = fs.getFirstTopLevelNode(); if (n.type() != FileNode::SEQ) return false; FileNodeIterator it = n.begin(), it_end = n.end(); string temp = filename; int pos = temp.find_last_of('/') + 1; temp = temp.substr(0, pos); for (; it != it_end; ++it) l.push_back(temp + (string)*it); return true; }
void FileSystemWidget::openPathIndex(const QModelIndex &index) { FileNode *node = m_model->nodeFromIndex(index); if (!node) { return; } if (node->isFile()) { QFileInfo info(node->path()); QString cmd = FileUtil::lookPathInDir(info.fileName(),LiteApi::getCurrentEnvironment(m_liteApp),info.path()); if (cmd == node->path()) { LiteApi::ILiteBuild *build = LiteApi::getLiteBuild(m_liteApp); if (build) { build->executeCommand(info.fileName(),QString(),info.path()); return; } } m_liteApp->fileManager()->openEditor(node->path(),true); } }
void loadBins(float* out){ FileStorage fs("txtDict.xml", FileStorage::READ); FileNode n = fs["binArray"]; if(n.type() != FileNode::SEQ){ cout << "incorrect filetype: " << n.type() << endl; fs.release(); return; } FileNodeIterator it = n.begin(), it_end = n.end(); int cnt =0; for(;it != it_end;++it){ out[cnt] = (float)*it; cnt++; } cout << "finished reading Bins..\n\n"; fs.release(); }
void loadTex(vector<float>& out){ FileStorage fs("txtDict.xml", FileStorage::READ); FileNode n = fs["TextonDictionary"]; if(n.type() != FileNode::SEQ){ cout << "incorrect filetype: " << n.type() << endl; fs.release(); return; } FileNodeIterator it = n.begin(), it_end = n.end(); int cnt =0; for(;it != it_end;++it){ out.push_back((float)*it); cnt++; } cout << "finished reading Textons..\n\n"; fs.release(); }
bool FileTreeFactory::CreateNote(const std::wstring strFileName, FileNode &file) { if (CreateFile(strFileName, NOTE_TYPE, file)) { std::wstring strPath; file.GetValue(FileAttributeType_strPath, strPath); return OnCreateFolder(strPath + L"\\" + strFileName); } return false; }
void PCAread(const FileNode& fs, PCA& pca) { CV_Assert( !fs.empty() ); String name = (String)fs["name"]; CV_Assert( name == "PCA" ); cv::read(fs["vectors"], pca.eigenvectors); cv::read(fs["values"], pca.eigenvalues); cv::read(fs["mean"], pca.mean); }
/// static function that reads the results file /// @param[in] node FileNode to read from /// @param[out] Results result to be saved from FileNode /// @param[in] default_value value by default if FileNode is empty static void read(const FileNode& node, Results& result,const Results& default_value = Results()) { if (node.empty()) { result = default_value; } else { result.read(node); } }
bool CvCascadeClassifier::readStages( const FileNode &node) { FileNode rnode = node[CC_STAGES]; if (!rnode.empty() || !rnode.isSeq()) return false; stageClassifiers.reserve(numStages); FileNodeIterator it = rnode.begin(); for( int i = 0; i < min( (int)rnode.size(), numStages ); i++, it++ ) { CvCascadeBoost* tempStage = new CvCascadeBoost; if ( !tempStage->read( *it, (CvFeatureEvaluator *)featureEvaluator, *((CvCascadeBoostParams*)stageParams) ) ) { delete tempStage; return false; } stageClassifiers.push_back(tempStage); } return true; }
void read(const FileNode& fn) { clear(); read_params(fn["training_params"]); fn["weights"] >> weights; fn["means"] >> means; FileNode cfn = fn["covs"]; FileNodeIterator cfn_it = cfn.begin(); int i, n = (int)cfn.size(); covs.resize(n); for( i = 0; i < n; i++, ++cfn_it ) (*cfn_it) >> covs[i]; decomposeCovs(); computeLogWeightDivDet(); }
//============================================================================== void face_tracker:: read(const FileNode& node) { assert(node.type() == FileNode::MAP); node["detector"] >> detector; node["smodel"] >> smodel; node["pmodel"] >> pmodel; node["annotations"] >> annotations; }