void read_from_yaml(cv::FileNode node, bool& b)
{
ntk_throw_exception_if(node.empty(), "Could not read " + node.name() + " from yaml file.");
int i = cvReadInt(*node, -1);
ntk_assert(i >= 0 && i <= 1, "Invalid boolean value");
b = i;
}
void RFS::read(const cv::FileNode &fn)
{
rtrees.clear();
for (auto it = fn.begin(); it != fn.end(); ++it)
{
RTree rfs;
*it >> rfs;
rtrees.push_back(rfs);
}
}
cv::Ptr<Camera> Camera::read( const cv::FileNode& node )
{
std::string myName=node.name( );
if( myName != "Camera" )
{
std::string error = "Camera FileNode is not correct!\nExpected \"Camera\", got ";
error += node.name();
CV_Error( CV_StsError, error.c_str() );
}
//nothing to do as we are a fake camera...
return cv::Ptr<Camera>( NULL );
}
bool ConfigurationDataReader::loadConfigurationFromFileNode(const cv::FileNode &dataFileNode)
{
bool success = true;
cv::FileNodeIterator itEnd = dataFileNode.end();
for (cv::FileNodeIterator it = dataFileNode.begin(); it != itEnd && success; it++)
{
const char *newDataValueName = (*it).name().c_str();
success = success && loadNodeFromFileNode(dataFileNode, newDataValueName);
}
return success;
}
inline void read(const cv::FileNode& node, LabelInfo& x, const LabelInfo& default_value = LabelInfo())
{
if(node.empty())
x = default_value;
else
x.read(node);
}
void read(const cv::FileNode &fn, BikeFeatures &bf, const BikeFeatures & default_value) {
if (fn.empty()) {
bf = default_value;
} else {
bf.read(fn);
}
}
void read(const cv::FileNode& node, ImageSourceSettings& settings,
const ImageSourceSettings& default_settings)
{
if(node.empty())
settings = default_settings;
else
settings.read(node);
}
void read(const cv::FileNode& node, MeshLoadingSettings& settings,
const MeshLoadingSettings& default_settings)
{
if(node.empty())
settings = default_settings;
else
settings.read(node);
}
void read(const cv::FileNode& node, TrackerSettings& settings,
const TrackerSettings& default_settings)
{
if(node.empty())
settings = default_settings;
else
settings.read(node);
}
// Following must be defined for the serialization in FileStorage to work
static void read(
const cv::FileNode &node, FeatureTrackerOptions &x,
const FeatureTrackerOptions &default_value = FeatureTrackerOptions()) {
if (node.empty())
x = default_value;
else
x.read(node);
}
void read(const cv::FileNode& node, RFS &f, const RFS& default_value)
{
if (node.empty())
{
f = default_value;
cout << "! One default Regressor." << endl;
}
else
f.read(node);
}
void read(const cv::FileNode& node, Regressor& r, const Regressor& default_value)
{
if (node.empty())
{
r = default_value;
cout << "One default Regressor. Model file is corrupt!" << endl;
}
else
r.read(node);
}
static void read(const cv::FileNode& node, observation& x,
const observation& default_value = observation()) {
if (node.empty()) {
x = default_value;
} else {
x.cam_id = (int) node["cam_id"];
x.point_id = (int) node["point_id"];
x.coord[0] = (float) node["coord0"];
x.coord[1] = (float) node["coord1"];
}
}
void read(const cv::FileNode& node, vector<vector< pair<int, int> > >& termPair)
{
cv::FileNodeIterator it = node.begin(), it_end = node.end();
for( ; it != it_end; ++it)
{
vector<int> first_part;
vector<int> second_part;
(*it)["first"] >> first_part;
(*it)["second"] >> second_part;
vector<pair<int, int> > first_second;
first_second.resize(first_part.size());
for(int j = 0; j < first_part.size(); ++j)
{
first_second[j].first = first_part[j];
first_second[j].second = second_part[j];
}
termPair.push_back(first_second);
}
}
bool AnnotationRect::read(cv::FileNode& obj) {
if (!obj.isMap())
return false;
cv::FileNodeIterator it;
cv::Point2f center;
cv::Size2f size;
float angle;
obj["targetWidth"] >> targetWidth;
obj["targetHeight"] >> targetHeight;
obj["targetHeight"] >> targetHeight;
obj["annotationAngle"] >> angle;
it = obj["annotationCenter"].begin();
it >> center.x >> center.y;
it = obj["annotationSize"].begin();
it >> size.width >> size.height;
obj["id"] >> id;
annotation = cv::RotatedRect(center, size, angle);
return true;
}
void read ( const cv::FileNode& node, map< string, V >&result)
{
bool node_type_ok = (node.type() & FileNode::MAP) > 0;
if(!node_type_ok)
{
cout << node.type() << endl;
cout << (node.type() & FileNode::MAP) << endl;
cout << ((node.type() & FileNode::MAP) > 0) << endl;
assert(node_type_ok);
}
for(FileNodeIterator iter = node.begin(); iter != node.end(); ++iter)
{
string node_name = (*iter).name();
V value;
//iter >> value;
deformable_depth::read_in_map(*iter,value);
result[node_name] = value;
}
}
void SequenceAnalyzer::read( const cv::FileNode& node, SequenceAnalyzer& me )
{
std::string myName=node.name( );
if( myName != "SequenceAnalyzer" )
{
std::string error = "FileNode is not correct!\nExpected \"SequenceAnalyzer\", got ";
error += node.name();
CV_Error( CV_StsError, error.c_str() );
}
if( node.empty( ) || !node.isMap( ) )
CV_Error( CV_StsError, "SequenceAnalyzer FileNode is not correct!" );
int nb_pictures = ( int ) node[ "nbPictures" ];
//initialisation of all empty vectors
for( int i=0; i<nb_pictures; i++ )
{
Ptr<PointsToTrack> ptt;
if( i<me.images_.size() )
{
ptt = Ptr<PointsToTrack>(
new PointsToTrackWithImage( i, me.images_[i] ));
}
else
{
ptt = Ptr<PointsToTrack>( new PointsToTrack( i ));
}
me.points_to_track_.push_back( ptt );
Ptr<PointsMatcher> p_m = Ptr<PointsMatcher>( new PointsMatcher(
*me.match_algorithm_ ) );
p_m->add( ptt );
me.matches_.push_back( p_m );
}
cv::FileNode node_TrackPoints = node[ "TrackPoints" ];
//tracks are stored in the following form:
//list of track where a track is stored like this:
// nbPoints idImage1 point1 idImage2 point2 ...
if( node_TrackPoints.empty( ) || !node_TrackPoints.isSeq() )
CV_Error( CV_StsError, "SequenceAnalyzer FileNode is not correct!" );
cv::FileNodeIterator it = node_TrackPoints.begin( ),
it_end = node_TrackPoints.end( );
while( it != it_end )
{
cv::FileNode it_track = ( *it )[ 0 ];
int nbPoints,track_consistance;
it_track[ "nbPoints" ] >> nbPoints;
it_track[ "track_consistance" ] >> track_consistance;
bool has_3d_point = false;
it_track[ "has_3d_position" ] >> has_3d_point;
TrackOfPoints track;
if( has_3d_point )
{
cv::Vec3d point;
point[ 0 ] = it_track[ "point3D_triangulated" ][ 0 ];
point[ 1 ] = it_track[ "point3D_triangulated" ][ 1 ];
point[ 2 ] = it_track[ "point3D_triangulated" ][ 2 ];
track.point3D = Ptr<cv::Vec3d>( new cv::Vec3d( point ) );
}
int color;
it_track[ "color" ] >> color;
track.setColor( *((unsigned int*)&color) );
cv::FileNodeIterator itPoints = it_track[ "list_of_points" ].begin( ),
itPoints_end = it_track[ "list_of_points" ].end( );
while( itPoints != itPoints_end )
{
int idImage;
cv::KeyPoint kpt;
idImage = ( *itPoints )[ 0 ];
itPoints++;
kpt.pt.x = ( *itPoints )[ 0 ];
kpt.pt.y = ( *itPoints )[ 1 ];
kpt.size = ( *itPoints )[ 2 ];
kpt.angle = ( *itPoints )[ 3 ];
kpt.response = ( *itPoints )[ 4 ];
kpt.octave = ( *itPoints )[ 5 ];
kpt.class_id = ( *itPoints )[ 6 ];
unsigned int point_index = me.points_to_track_[ idImage ]->
addKeypoint( kpt );
track.addMatch( idImage,point_index );
itPoints++;
}
track.track_consistance = track_consistance;
me.tracks_.push_back( track );
it++;
}
}
persistStore();
}
void ViolenceModel::storeInit(cv::FileStorage &file, std::string exampleStoreName, cv::Mat &exampleStore,
std::string classStoreName, cv::Mat &classStore,
std::string indexCacheName, std::map<std::string, time_t> &indexCache)
{
// Read the data structures in from the training store.
file[exampleStoreName] >> exampleStore;
std::cout << exampleStoreName << " loaded. size: " << exampleStore.size() << "\n";
file[classStoreName] >> classStore;
std::cout << classStoreName << " loaded. size: " << classStore.size() << "\n";
cv::FileNode indexedFilePaths = file[indexCacheName];
cv::FileNodeIterator iter = indexedFilePaths.begin(), end = indexedFilePaths.end();
while ( iter != end )
{
std::string path = (*iter)[VIOLENCE_MODEL_TRAINING_EXAMPLE_PATH];
//std::cout << "found path: " << path << "\n";
int modTime = (int)(*iter)[VIOLENCE_MODEL_TRAINING_EXAMPLE_MOD_DATE];
indexCache[path] = (time_t)modTime;
iter++;
}
// Ensure we go no further the height (rows) are not equivalent.
std::cout << "classes: " << classStore.size().height << " examples: " << exampleStore.size().height << " indices: " << indexCache.size() << "\n";
assert(classStore.size().height == exampleStore.size().height && classStore.size().height == indexCache.size());
}
void Regression::verify(cv::FileNode node, cv::InputArray array, double eps, ERROR_TYPE err)
{
int expected_kind = (int)node["kind"];
int expected_type = (int)node["type"];
ASSERT_EQ(expected_kind, array.kind()) << " Argument \"" << node.name() << "\" has unexpected kind";
ASSERT_EQ(expected_type, array.type()) << " Argument \"" << node.name() << "\" has unexpected type";
cv::FileNode valnode = node["val"];
if (isVector(array))
{
int expected_length = (int)node["len"];
ASSERT_EQ(expected_length, (int)array.total()) << " Vector \"" << node.name() << "\" has unexpected length";
int idx = node["idx"];
cv::Mat actual = array.getMat(idx);
if (valnode.isNone())
{
ASSERT_LE((size_t)26, actual.total() * (size_t)actual.channels())
<< " \"" << node.name() << "[" << idx << "]\" has unexpected number of elements";
verify(node, actual, eps, cv::format("%s[%d]", node.name().c_str(), idx), err);
}
else
{
cv::Mat expected;
valnode >> expected;
if(expected.empty())
{
ASSERT_TRUE(actual.empty())
<< " expected empty " << node.name() << "[" << idx<< "]";
}
else
{
ASSERT_EQ(expected.size(), actual.size())
<< " " << node.name() << "[" << idx<< "] has unexpected size";
cv::Mat diff;
cv::absdiff(expected, actual, diff);
if (err == ERROR_ABSOLUTE)
{
if (!cv::checkRange(diff, true, 0, 0, eps))
{
if(expected.total() * expected.channels() < 12)
std::cout << " Expected: " << std::endl << expected << std::endl << " Actual:" << std::endl << actual << std::endl;
double max;
cv::minMaxIdx(diff.reshape(1), 0, &max);
FAIL() << " Absolute difference (=" << max << ") between argument \""
<< node.name() << "[" << idx << "]\" and expected value is greater than " << eps;
}
}
else if (err == ERROR_RELATIVE)
{
double maxv, maxa;
int violations = countViolations(expected, actual, diff, eps, &maxv, &maxa);
if (violations > 0)
{
FAIL() << " Relative difference (" << maxv << " of " << maxa << " allowed) between argument \""
<< node.name() << "[" << idx << "]\" and expected value is greater than " << eps << " in " << violations << " points";
}
}
}
}
}
else
{
if (valnode.isNone())
void read_from_yaml(cv::FileNode node, int& i)
{
ntk_throw_exception_if(node.empty(), "Could not read " + node.name() + " from yaml file.");
i = cvReadInt(*node, -1);
}
void read_from_yaml(cv::FileNode node, double& b)
{
ntk_throw_exception_if(node.empty(), "Could not read " + node.name() + " from yaml file.");
b = cvReadReal(*node, 0);
}
void read_from_yaml(cv::FileNode node, cv::Mat& matrix)
{
CvMat* m = (CvMat*)node.readObj();
ntk_throw_exception_if(!m, std::string("Could not read field ") + node.name() + " from yml file.");
matrix = m;
}
