void load()
{
vector<string> path_preference{
"config.yaml",
"/etc/photo-booth/config.yaml"
};
FileStorage fs;
for (string &path : path_preference)
{
fs.open(path, FileStorage::READ);
if (fs.isOpened())
{
// TODO: Debug level before reading config
//cout << "Reading configuration from " << path << endl;
break;
}
}
if (!fs.isOpened())
{
// TODO: Log search path.
throw runtime_error(string(_("Couldn't find config file.")));
}
string boolString;
fs["debug"] >> boolString;
debug = (boolString == "true");
fs["motion_interval"] >> motion_interval;
fs["frame_pause"] >> frame_pause;
fs["satisfied_pause"] >> satisfied_pause;
fs["output_dir"] >> output_dir;
fs["camera_id"] >> camera_id;
fs["countdown"] >> countdown;
fs["initial_countdown"] >> initial_countdown;
fs["minimum_area"] >> minimum_area;
fs["max_allowed_area"] >> max_allowed_area;
fs["acculum_weight"] >> acculum_weight;
fs["motion_score_threshold"] >> motion_score_threshold;
fs["sound_cmd"] >> sound_cmd;
// Expand output_dir path.
wordexp_t exp_result;
wordexp(output_dir.c_str(), &exp_result, 0);
output_dir = exp_result.we_wordv[0];
wordfree(&exp_result);
// Copy the map of soundfiles.
for (FileNode sound : fs["sounds"])
{
sounds[sound.name()] = (string)sound;
}
}
//==============================================================================
void
shape_model::
write(FileStorage &fs) const
{
assert(fs.isOpened());
fs << "{" << "V" << V << "e" << e << "C" << C << "Y"<<Y<< "}";
}
void kNNSearcher::kNNSearchWithHOG(const Mat &inputImage, const QStringList &imPath,
Mat &indexes, Mat &weights, int k)
{
//resize inputImage to the same size of training image
Mat temp = imread( imPath[0].toLocal8Bit().data(), CV_LOAD_IMAGE_GRAYSCALE );
Mat inputIm;
resize( inputImage, inputIm, temp.size() );
//compute the HOG descriptor of target image
HOGDescriptor *hogDesr = new HOGDescriptor( cvSize( 640, 480 ), cvSize( 160, 120 ), cvSize( 160,120 ), cvSize( 160, 120 ), 9 );
std::vector<float> targetDescriptor;
hogDesr->compute( inputIm, targetDescriptor, Size( 0, 0 ), Size( 0, 0) );
//###################################################################################
//load the training descriptors into descriptorMat if there exist a HOGof44blocks.yaml file
//otherwise, execute the train program
Mat descriptorMat;
QString const HOGMatfile = "HOGof44blocks.yaml";
FileStorage fs;
fs.open( HOGMatfile.toLocal8Bit().data(), FileStorage::READ );
if( fs.isOpened() ){
// the HOGof44blocks.yaml does exist
fs["HOGMat"] >> descriptorMat;
}else{
int Orbit::savePoints(std::string name)
{
FileStorage fs;
string fileName=name+"orbit.yml";
fs.open(fileName, FileStorage::WRITE);
if(fs.isOpened()==false)
{
fs.release();
return -1;
}
fs<<"orbit";
fs<<"[";
for(size_t i=0;i<robotPoints.size();i++)
{
fs<<"{";
fs<<"x"<<robotPoints[i].x;
fs<<"y"<<robotPoints[i].y;
fs<<"z"<<robotPoints[i].z;
fs<<"}";
}
fs<<"]";
fs.release();
return 0;
}
int Orbit::loadPoints(std::string name)
{
FileStorage fs;
string fileName=name+"orbit.yml";
fs.open(fileName, FileStorage::READ);
if(fs.isOpened()==false)
{
fs.release();
return -1;
}
FileNode orbitNode=fs["orbit"];
FileNodeIterator it=orbitNode.begin();
for(size_t i=0;it!=orbitNode.end();i++,it++)
{
Point3f tmp;
(*it)["x"]>>tmp.x;
(*it)["y"]>>tmp.y;
(*it)["z"]>>tmp.z;
cout<<tmp<<endl;
robotPoints.push_back(tmp);
}
fs.release();
return 0;
}
int CV_StereoMatchingTest::processStereoMatchingResults( FileStorage& fs, int caseIdx, bool isWrite,
const Mat& leftImg, const Mat& rightImg,
const Mat& trueLeftDisp, const Mat& trueRightDisp,
const Mat& leftDisp, const Mat& rightDisp,
const QualityEvalParams& qualityEvalParams )
{
// rightDisp is not used in current test virsion
int code = cvtest::TS::OK;
assert( fs.isOpened() );
assert( trueLeftDisp.type() == CV_32FC1 );
assert( trueRightDisp.empty() || trueRightDisp.type() == CV_32FC1 );
assert( leftDisp.type() == CV_32FC1 && rightDisp.type() == CV_32FC1 );
// get masks for unknown ground truth disparity values
Mat leftUnknMask, rightUnknMask;
DatasetParams params = datasetsParams[caseDatasets[caseIdx]];
absdiff( trueLeftDisp, Scalar(params.dispUnknVal), leftUnknMask );
leftUnknMask = leftUnknMask < numeric_limits<float>::epsilon();
assert(leftUnknMask.type() == CV_8UC1);
if( !trueRightDisp.empty() )
{
absdiff( trueRightDisp, Scalar(params.dispUnknVal), rightUnknMask );
rightUnknMask = rightUnknMask < numeric_limits<float>::epsilon();
assert(leftUnknMask.type() == CV_8UC1);
}
// calculate errors
vector<float> rmss, badPxlsFractions;
calcErrors( leftImg, rightImg, trueLeftDisp, trueRightDisp, leftUnknMask, rightUnknMask,
leftDisp, rightDisp, rmss, badPxlsFractions, qualityEvalParams );
if( isWrite )
{
fs << caseNames[caseIdx] << "{";
//cvWriteComment( fs.fs, RMS_STR.c_str(), 0 );
writeErrors( RMS_STR, rmss, &fs );
//cvWriteComment( fs.fs, BAD_PXLS_FRACTION_STR.c_str(), 0 );
writeErrors( BAD_PXLS_FRACTION_STR, badPxlsFractions, &fs );
fs << "}"; // datasetName
}
else // compare
{
ts->printf( cvtest::TS::LOG, "\nquality of case named %s\n", caseNames[caseIdx].c_str() );
ts->printf( cvtest::TS::LOG, "%s\n", RMS_STR.c_str() );
writeErrors( RMS_STR, rmss );
ts->printf( cvtest::TS::LOG, "%s\n", BAD_PXLS_FRACTION_STR.c_str() );
writeErrors( BAD_PXLS_FRACTION_STR, badPxlsFractions );
FileNode fn = fs.getFirstTopLevelNode()[caseNames[caseIdx]];
vector<float> validRmss, validBadPxlsFractions;
readErrors( fn, RMS_STR, validRmss );
readErrors( fn, BAD_PXLS_FRACTION_STR, validBadPxlsFractions );
int tempCode = compareErrors( rmss, validRmss, rmsEps, RMS_STR );
code = tempCode==cvtest::TS::OK ? code : tempCode;
tempCode = compareErrors( badPxlsFractions, validBadPxlsFractions, fracEps, BAD_PXLS_FRACTION_STR );
code = tempCode==cvtest::TS::OK ? code : tempCode;
}
return code;
}
void TODBaseImporter::importGroundTruth(int testImageIdx, PoseRT &model2test, bool shiftByOffset, PoseRT *offsetPtr, bool isKeyFrame) const
{
std::stringstream testPoseFilename;
if (isKeyFrame)
{
testPoseFilename << testFolder +"/image_" << std::setfill('0') << std::setw(5) << testImageIdx << ".png.pose.yaml.kf";
}
else
{
testPoseFilename << testFolder +"/image_" << std::setfill('0') << std::setw(5) << testImageIdx << ".png.pose.yaml";
}
FileStorage testPoseFS;
testPoseFS.open(testPoseFilename.str(), FileStorage::READ);
CV_Assert(testPoseFS.isOpened());
testPoseFS["pose"]["rvec"] >> model2test.rvec;
testPoseFS["pose"]["tvec"] >> model2test.tvec;
testPoseFS.release();
if (shiftByOffset || offsetPtr != 0)
{
PoseRT offset;
importOffset(offset);
if (shiftByOffset)
{
model2test = model2test * offset;
}
if (offsetPtr != 0)
{
*offsetPtr = offset;
}
}
}
Pattern::Pattern()
{
//-- Read in the file of parameters
std::string file_name = "data/book.yml";
FileStorage fs;
fs.open(file_name, FileStorage::READ);
if(fs.isOpened())
{
printf("Initializer: %s is opened for reading.\n", file_name.c_str());
fs["objWidth"] >> obj_width;
fs["objHeight"] >> obj_height;
fs["intrinsics"] >> camera.mat_intrinsics;
fs["extrinsics"] >> camera.mat_extrinsics;
fs["corners"] >> vec_corners;
fs["distCoeffs"] >> camera.mat_distCoeffs;
fs["scale"] >> scale;
fs.release();
printf("Values are\n");
std::cout << "objWidth: " << obj_width << std::endl
<< "objHeight: " << obj_height << std::endl
<< "intrinsics:\n" << camera.mat_intrinsics << std::endl
<< "extrinsics:\n" << camera.mat_extrinsics << std::endl
<< "corners: " << vec_corners << std::endl
<< "distCoeffs:\n" << camera.mat_distCoeffs << std::endl
<< "H_groundTruth:\n" << H_groundTruth << std::endl;
printf("Pattern is constructed.\n");
current_state = PATTERN_STATE_SUCCESS;
}
void RetinaImpl::write( FileStorage& fs ) const
{
if (!fs.isOpened())
return; // basic error case
fs<<"OPLandIPLparvo"<<"{";
fs << "colorMode" << _retinaParameters.OPLandIplParvo.colorMode;
fs << "normaliseOutput" << _retinaParameters.OPLandIplParvo.normaliseOutput;
fs << "photoreceptorsLocalAdaptationSensitivity" << _retinaParameters.OPLandIplParvo.photoreceptorsLocalAdaptationSensitivity;
fs << "photoreceptorsTemporalConstant" << _retinaParameters.OPLandIplParvo.photoreceptorsTemporalConstant;
fs << "photoreceptorsSpatialConstant" << _retinaParameters.OPLandIplParvo.photoreceptorsSpatialConstant;
fs << "horizontalCellsGain" << _retinaParameters.OPLandIplParvo.horizontalCellsGain;
fs << "hcellsTemporalConstant" << _retinaParameters.OPLandIplParvo.hcellsTemporalConstant;
fs << "hcellsSpatialConstant" << _retinaParameters.OPLandIplParvo.hcellsSpatialConstant;
fs << "ganglionCellsSensitivity" << _retinaParameters.OPLandIplParvo.ganglionCellsSensitivity;
fs << "}";
fs<<"IPLmagno"<<"{";
fs << "normaliseOutput" << _retinaParameters.IplMagno.normaliseOutput;
fs << "parasolCells_beta" << _retinaParameters.IplMagno.parasolCells_beta;
fs << "parasolCells_tau" << _retinaParameters.IplMagno.parasolCells_tau;
fs << "parasolCells_k" << _retinaParameters.IplMagno.parasolCells_k;
fs << "amacrinCellsTemporalCutFrequency" << _retinaParameters.IplMagno.amacrinCellsTemporalCutFrequency;
fs << "V0CompressionParameter" << _retinaParameters.IplMagno.V0CompressionParameter;
fs << "localAdaptintegration_tau" << _retinaParameters.IplMagno.localAdaptintegration_tau;
fs << "localAdaptintegration_k" << _retinaParameters.IplMagno.localAdaptintegration_k;
fs<<"}";
}
//=============================================================================
void
ft_data::
write(FileStorage &fs) const
{
assert(fs.isOpened());
fs << "{";
fs << "n_connections" << (int)connections.size();
for(int i = 0; i < int(connections.size()); i++){
char str[256]; const char* ss;
sprintf(str,"connections %d 0",i); ss = str; fs << ss << connections[i][0];
sprintf(str,"connections %d 1",i); ss = str; fs << ss << connections[i][1];
}
fs << "n_symmetry" << (int)symmetry.size();
for(int i = 0; i < int(symmetry.size()); i++){
char str[256]; const char* ss;
sprintf(str,"symmetry %d",i); ss = str; fs << ss << symmetry[i];
}
fs << "n_images" << (int)imnames.size();
for(int i = 0; i < int(imnames.size()); i++){
char str[256]; const char* ss;
sprintf(str,"image %d",i); ss = str; fs << ss << imnames[i];
}
int n = points[0].size(),N = points.size();
Mat X(2*n,N,CV_32F); X = -1;
for(int i = 0; i < N; i++){
if(int(points[i].size()) == n){
for(int j = 0; j < n; j++){
X.at<float>(2*j ,i) = points[i][j].x;
X.at<float>(2*j+1,i) = points[i][j].y;
}
}
}
fs << "shapes" << X << "}";
}
inline void writeKeypoints( FileStorage& fs, const vector<KeyPoint>& keypoints, int imgIdx )
{
if( fs.isOpened() )
{
stringstream imgName; imgName << "img" << imgIdx;
write( fs, imgName.str(), keypoints );
}
}
void DetectorQualityEvaluator::openToWriteKeypointsFile( FileStorage& fs, int datasetIdx )
{
string filename = data_path + KEYPOINTS_DIR + algName + "_"+ DATASET_NAMES[datasetIdx] + ".xml.gz" ;
fs.open(filename, FileStorage::WRITE);
if( !fs.isOpened() )
printf( "keypoints can not be written in file %s because this file can not be opened\n", filename.c_str() );
}
void readKeypointsAndDesc( char* ymlpath , std::vector<KeyPoint>& ref_keypoints , Mat& ref_desc ){
FileStorage fs ;
fs.open( ymlpath , FileStorage::READ);
if(fs.isOpened()){
read(fs["desc"], ref_keypoints );
read(fs["kps"], ref_desc);
}
fs.release();
}
void PCAwrite(FileStorage& fs, PCA& pca)
{
CV_Assert( fs.isOpened() );
fs << "name" << "PCA";
fs << "vectors" << pca.eigenvectors;
fs << "values" << pca.eigenvalues;
fs << "mean" << pca.mean;
}
int CV_StereoMatchingTest::readRunParams( FileStorage& fs )
{
if( !fs.isOpened() )
{
ts->printf( CvTS::LOG, "runParams can not be read " );
return CvTS::FAIL_INVALID_TEST_DATA;
}
caseNames.clear();;
caseDatasets.clear();
return CvTS::OK;
}
void loaddistancematrix(){
tic();
FileStorage fs;
printf("Opening data file...\n");
fs.open("distances.yml", FileStorage::READ);
if(fs.isOpened()){
//file already computed, load it
printf("Loading data...\n");
fs["distances"] >> distances;
fs["freespace"] >> freespace;
}
//==============================================================================
void
face_tracker::
write(FileStorage &fs) const
{
assert(fs.isOpened());
fs << "{"
<< "annotations" << annotations
<< "detector" << detector
<< "smodel" << smodel
<< "pmodel" << pmodel
<< "}";
}
Mat Utility::readFromFile(string fileName) {
FileStorage f;
Mat matrix;
f.open(fileName, FileStorage::READ);
if(!f.isOpened()) {
throw string("Unable to open the file");
}
f["cameraMatrix"] >> matrix;
f.release();
return matrix;
}
//==============================================================================
void
face_detector::
write(FileStorage &fs) const
{
assert(fs.isOpened());
fs << "{"
<< "fname" << detector_fname
<< "x offset" << detector_offset[0]
<< "y offset" << detector_offset[1]
<< "z offset" << detector_offset[2]
<< "reference" << reference
<< "}";
}
//==============================================================================
void
patch_models::
write(FileStorage &fs) const
{
assert(fs.isOpened());
fs << "{" << "reference" << reference;
fs << "n_patches" << (int)patches.size();
for(int i = 0; i < int(patches.size()); i++){
char str[256]; const char* ss;
sprintf(str,"patch %d",i); ss = str; fs << ss << patches[i];
}
fs << "}";
}
stereocam1() {
printf("Constructor called!\n");
M1 = Mat::eye(3, 3, CV_64F);
M2 = Mat::eye(3, 3, CV_64F);
fsL.open(intrinsic_filename, FileStorage::READ);
if (fsL.isOpened()) {
fsL["M1"] >> M1;
fsL["D1"] >> D1;
fsL["M2"] >> M2;
fsL["D2"] >> D2;
fsL.release();
}
Mat SegmentTrack::readBOWDict()
{
FileStorage fs;
fs.open(OUTPUT_FOLDER+string(BOW_DICT_NAME), FileStorage::READ);
if (!fs.isOpened())
{
qDebug() << "Failed to open dict file";
}
Mat dict;
fs["Dict"] >> dict;
qDebug() << "Dict size is" << dict.size().height;
return dict;
}
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();
}
/**
* @brief This constructor loads the different calibration parameters
* @param calibration_name Path where the calibration file is located
*/
D_Ldb::D_Ldb(char* calibration_name){
//The calibration file is opened
FileStorage fs;
fs.open(calibration_name, FileStorage::READ);
if (!fs.isOpened()){
cout << "Couldn't open the calibration file. Check its location." << endl;
}
// Obtaining the calibration parameters
fs["ML"] >> ML;
fs["MR"] >> MR;
fs["DL"] >> DL;
fs["DR"] >> DR;
fs["R"] >> R;
fs["T"] >> T;
fs["colormap"] >> colormap;
fs["use_log"] >> use_log;
Fx=ML.at<double>(0,0);
Fy=ML.at<double>(1,1);
u0=ML.at<double>(0,2);
v0=ML.at<double>(1,2);
B=-T.at<double>(0,0);
fs.release();
prefilter_size = 11;
prefilter_cap = 31;
sad_window_size = 11;
min_disparity = 0;
max_disparity = 128;
uniqueness_ratio = 10;
texture_threshold = 10;
speckle_window_size = 0;
speckle_range = 15;
min_disp=min_disparity;
max_disp=max_disparity;
}
//==============================================================================
void
face_tracker_params::
write(FileStorage &fs) const
{
assert(fs.isOpened()); fs << "{";
fs << "nlevels" << int(ssize.size());
for(int i = 0; i < int(ssize.size()); i++){ char str[256]; const char* ss;
sprintf(str,"w %d",i); ss = str; fs << ss << ssize[i].width;
sprintf(str,"h %d",i); ss = str; fs << ss << ssize[i].height;
}
fs << "robust" << robust
<< "itol" << itol
<< "ftol" << ftol
<< "scaleFactor" << scaleFactor
<< "minNeighbours" << minNeighbours
<< "minWidth" << minSize.width
<< "minHeight" << minSize.height
<< "}";
}
// Read a YAML file with the camera parameters (cameraMatrix and distCoeffs)
void UndistortImages::readCameraParameters( char* yml_filename ){
FileStorage fs;
fs.open(yml_filename, FileStorage::READ);
if( !fs.isOpened() ){
cerr << " Fail to open " << yml_filename << endl;
exit(EXIT_FAILURE);
}
// Get camera parameters
fs["camera_matrix"] >> cameraMatrix;
fs["distortion_coefficients"] >> distCoeffs;
// Print out the camera parameters
cout << "\n -- Camera parameters -- " << endl;
cout << "\n CameraMatrix = " << endl << " " << cameraMatrix << endl << endl;
cout << " Distortion coefficients = " << endl << " " << distCoeffs << endl << endl;
fs.release();
}
int main(int argc, const char * argv[]) {
const char * camMatrixXMLFile = "default.xml";
if (argv[1]) {
camMatrixXMLFile = argv[1];
cout << "camMatrixXMLFile: " << argv[1] << "\n";
} else {
cout << "No camMatrixXMLFile specified! \n";
}
FileStorage fs;
fs.open(camMatrixXMLFile, FileStorage::READ);
if (!fs.isOpened())
{
cout << "Could not open XML file : \""<< camMatrixXMLFile << "\"" << endl;
return -1;
}
// first method: use (type) operator on FileNode.
int frameCount = (int)fs["nrOfFrames"];
std::string date;
// second method: use FileNode::operator >>
fs["calibration_Time"] >> date;
Mat cameraMatrix2, distCoeffs2;
fs["Camera_Matrix"] >> cameraMatrix2;
fs["Distortion_Coefficients"] >> distCoeffs2;
cout << "frameCount: " << frameCount << endl
<< "calibration date: " << date << endl
<< "camera matrix: " << cameraMatrix2 << endl
<< "distortion coeffs: " << distCoeffs2 << endl;
fs.release();
//camMatrix = cm.cam_mat_data;
//cout << camMatrix;
return 0;
}
int CV_StereoMatchingTest::readDatasetsParams( FileStorage& fs )
{
if( !fs.isOpened() )
{
ts->printf( CvTS::LOG, "datasetsParams can not be read " );
return CvTS::FAIL_INVALID_TEST_DATA;
}
datasetsParams.clear();
FileNode fn = fs.getFirstTopLevelNode();
assert(fn.isSeq());
for( int i = 0; i < (int)fn.size(); i+=3 )
{
string name = fn[i];
DatasetParams params;
string sf = fn[i+1]; params.dispScaleFactor = atoi(sf.c_str());
string uv = fn[i+2]; params.dispUnknVal = atoi(uv.c_str());
datasetsParams[name] = params;
}
return CvTS::OK;
}
int CV_DetectorTest::prepareData( FileStorage& _fs )
{
if( !_fs.isOpened() )
test_case_count = -1;
else
{
FileNode fn = _fs.getFirstTopLevelNode();
fn[DIST_E] >> eps.dist;
fn[S_E] >> eps.s;
fn[NO_PAIR_E] >> eps.noPair;
// fn[TOTAL_NO_PAIR_E] >> eps.totalNoPair;
// read detectors
if( fn[DETECTOR_NAMES].size() != 0 )
{
FileNodeIterator it = fn[DETECTOR_NAMES].begin();
for( ; it != fn[DETECTOR_NAMES].end(); )
{
String _name;
it >> _name;
detectorNames.push_back(_name);
readDetector(fn[DETECTORS][_name]);
}
}
test_case_count = (int)detectorNames.size();
// read images filenames and images
string dataPath = ts->get_data_path();
if( fn[IMAGE_FILENAMES].size() != 0 )
{
for( FileNodeIterator it = fn[IMAGE_FILENAMES].begin(); it != fn[IMAGE_FILENAMES].end(); )
{
String filename;
it >> filename;
imageFilenames.push_back(filename);
Mat img = imread( dataPath+filename, 1 );
images.push_back( img );
}
}
}
void CvScan::LoadANNModel(string s){
ann.clear();
//ann.load(s.c_str(), "ann");
//return;
FileStorage fs;
fs.open(s, FileStorage::READ);
if (fs.isOpened()){
cout<<"File is opened:"<<s<<endl;
}
Mat TrainingData;
Mat Classes;
fs["TrainingDataF15"]>>TrainingData;
fs["classes"]>>Classes;
fs.release();
//cout << trainingDataF5 << endl;
train(TrainingData, Classes, 10);
//*/
}
