void DetectorQualityEvaluator::readDefaultRunParams (FileNode &fn)
{
    if (! fn.empty() )
    {
        isSaveKeypointsDefault = (int)fn[IS_SAVE_KEYPOINTS] != 0;
        defaultDetector->read (fn);
    }
}
Example #2
0
/**
 * 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;
}
Example #3
0
 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;
 }
Example #7
0
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);
    }
}
Example #8
0
void read(const FileNode& node, ICFDetector& d,
    const ICFDetector& default_value)
{
    if( node.empty() )
        d = default_value;
    else
        d.read(node);
}
Example #9
0
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;
}
Example #10
0
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);

}
Example #11
0
 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);
}
Example #14
0
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);
    }
}
Example #15
0
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();
}
Example #17
0
 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);
	}
}
Example #20
0
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 );
}
Example #21
0
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;
}
Example #22
0
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();
}
Example #25
0
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;
}
Example #26
0
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);
	}
}
Example #28
0
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;
}
Example #29
0
    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;
}