// setup from cv::Filestorage object
void TransientAreasSegmentationModuleImpl::setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure)
{
try
{
// read parameters file if it exists or apply default setup if asked for
if (!fs.isOpened())
{
std::cout<<"Retina::setup: provided parameters file could not be open... skeeping configuration"<<std::endl;
return;
// implicit else case : retinaParameterFile could be open (it exists at least)
}
// OPL and Parvo init first... update at the same time the parameters structure and the retina core
cv::FileNode rootFn = fs.root(), currFn=rootFn["SegmentationModuleSetup"];
currFn["thresholdON"]>>_segmentationParameters.thresholdON;
currFn["thresholdOFF"]>>_segmentationParameters.thresholdOFF;
currFn["localEnergy_temporalConstant"]>>_segmentationParameters.localEnergy_temporalConstant;
currFn["localEnergy_spatialConstant"]>>_segmentationParameters.localEnergy_spatialConstant;
currFn["neighborhoodEnergy_temporalConstant"]>>_segmentationParameters.neighborhoodEnergy_temporalConstant;
currFn["neighborhoodEnergy_spatialConstant"]>>_segmentationParameters.neighborhoodEnergy_spatialConstant;
currFn["contextEnergy_temporalConstant"]>>_segmentationParameters.contextEnergy_temporalConstant;
currFn["contextEnergy_spatialConstant"]>>_segmentationParameters.contextEnergy_spatialConstant;
setup(_segmentationParameters);
}catch(const cv::Exception &e)
{
std::cout<<"Retina::setup: resetting retina with default parameters"<<std::endl;
if (applyDefaultSetupOnFailure)
{
struct cv::bioinspired::SegmentationParameters defaults;
setup(defaults);
}
std::cout<<"SegmentationModule::setup: wrong/unappropriate xml parameter file : error report :`n=>"<<e.what()<<std::endl;
std::cout<<"=> keeping current parameters"<<std::endl;
}
}
void RetinaImpl::setup(cv::FileStorage &fs, const bool applyDefaultSetupOnFailure)
{
try
{
// read parameters file if it exists or apply default setup if asked for
if (!fs.isOpened())
{
printf("Retina::setup: provided parameters file could not be open... skeeping configuration\n");
return;
// implicit else case : retinaParameterFile could be open (it exists at least)
}
// OPL and Parvo init first... update at the same time the parameters structure and the retina core
cv::FileNode rootFn = fs.root(), currFn=rootFn["OPLandIPLparvo"];
currFn["colorMode"]>>_retinaParameters.OPLandIplParvo.colorMode;
currFn["normaliseOutput"]>>_retinaParameters.OPLandIplParvo.normaliseOutput;
currFn["photoreceptorsLocalAdaptationSensitivity"]>>_retinaParameters.OPLandIplParvo.photoreceptorsLocalAdaptationSensitivity;
currFn["photoreceptorsTemporalConstant"]>>_retinaParameters.OPLandIplParvo.photoreceptorsTemporalConstant;
currFn["photoreceptorsSpatialConstant"]>>_retinaParameters.OPLandIplParvo.photoreceptorsSpatialConstant;
currFn["horizontalCellsGain"]>>_retinaParameters.OPLandIplParvo.horizontalCellsGain;
currFn["hcellsTemporalConstant"]>>_retinaParameters.OPLandIplParvo.hcellsTemporalConstant;
currFn["hcellsSpatialConstant"]>>_retinaParameters.OPLandIplParvo.hcellsSpatialConstant;
currFn["ganglionCellsSensitivity"]>>_retinaParameters.OPLandIplParvo.ganglionCellsSensitivity;
setupOPLandIPLParvoChannel(_retinaParameters.OPLandIplParvo.colorMode, _retinaParameters.OPLandIplParvo.normaliseOutput, _retinaParameters.OPLandIplParvo.photoreceptorsLocalAdaptationSensitivity, _retinaParameters.OPLandIplParvo.photoreceptorsTemporalConstant, _retinaParameters.OPLandIplParvo.photoreceptorsSpatialConstant, _retinaParameters.OPLandIplParvo.horizontalCellsGain, _retinaParameters.OPLandIplParvo.hcellsTemporalConstant, _retinaParameters.OPLandIplParvo.hcellsSpatialConstant, _retinaParameters.OPLandIplParvo.ganglionCellsSensitivity);
// init retina IPL magno setup... update at the same time the parameters structure and the retina core
currFn=rootFn["IPLmagno"];
currFn["normaliseOutput"]>>_retinaParameters.IplMagno.normaliseOutput;
currFn["parasolCells_beta"]>>_retinaParameters.IplMagno.parasolCells_beta;
currFn["parasolCells_tau"]>>_retinaParameters.IplMagno.parasolCells_tau;
currFn["parasolCells_k"]>>_retinaParameters.IplMagno.parasolCells_k;
currFn["amacrinCellsTemporalCutFrequency"]>>_retinaParameters.IplMagno.amacrinCellsTemporalCutFrequency;
currFn["V0CompressionParameter"]>>_retinaParameters.IplMagno.V0CompressionParameter;
currFn["localAdaptintegration_tau"]>>_retinaParameters.IplMagno.localAdaptintegration_tau;
currFn["localAdaptintegration_k"]>>_retinaParameters.IplMagno.localAdaptintegration_k;
setupIPLMagnoChannel(_retinaParameters.IplMagno.normaliseOutput, _retinaParameters.IplMagno.parasolCells_beta, _retinaParameters.IplMagno.parasolCells_tau, _retinaParameters.IplMagno.parasolCells_k, _retinaParameters.IplMagno.amacrinCellsTemporalCutFrequency,_retinaParameters.IplMagno.V0CompressionParameter, _retinaParameters.IplMagno.localAdaptintegration_tau, _retinaParameters.IplMagno.localAdaptintegration_k);
}
catch(Exception &e)
{
printf("RetinaImpl::setup: resetting retina with default parameters\n");
if (applyDefaultSetupOnFailure)
{
setupOPLandIPLParvoChannel();
setupIPLMagnoChannel();
}
printf("Retina::setup: wrong/unappropriate xml parameter file : error report :`n=>%s\n", e.what());
printf("=> keeping current parameters\n");
}
// report current configuration
printf("%s\n", printSetup().c_str());
}
bool MarkupEditor::readSessionData(
cv::FileStorage& fs,
vector< FrameData >& frames,
int& start_frame
)
{
if (!fs.isOpened())
return __false("Attempt to read from not open storage");
cv::FileNode last_session_node = fs["LastMarkupSession"];
if (!last_session_node.empty())
{
if (start_frame < 0)
try {
last_session_node["LastVisitedFrame"] >> start_frame;
}
catch (...)
{
cout << "no StartFrame specified" << endl;
start_frame = -1;
}
string activeObjectType;
last_session_node[ "ActiveObjectType" ] >> activeObjectType;
if (!activeObjectType.empty()) // setup iObjType
for (iObjType = int(afoTypes.objTypes.size()-1); iObjType >=0; iObjType-- ) // if not found -- set to 0
if ( afoTypes.objTypes[iObjType] == activeObjectType )
break;
}
return true;
}
void readFile(cv::FileStorage &fs) {
if (!fs.isOpened()) {
std::cout << "Empty File..." << std::endl;
return;
}
cv::FileNode n = fs["TrainerInfo"];
std::string ttype = n["trainer_type"];
std::string tpath = n["trainer_path"];
std::cout << ttype << std::endl;
std::cout << tpath << std::endl;
n = fs["FeatureInfo"];
int hog = n["HOG"];
int lbp = n["LBP"];
std::cout << hog << std::endl;
std::cout << lbp << std::endl;
n = fs["SlidingWindowInfo"];
int swindow_x = static_cast<int>(n["window_x"]);
int swindow_y = static_cast<int>(n["window_y"]);
n = fs["TrainingDatasetDirectory"];
std::string pfile = n["object_dataset"];
std::string nfile = n["nonobject_dataset"];
std::cout << swindow_x << " " << swindow_y << std::endl;
std::cout << pfile << " \n" << nfile << std::endl;
}
void EventType::writeKeypoints(cv::FileStorage outfile) throw(runtime_error) {
if(outfile.isOpened()) {
outfile << getId() + "_pts" << getKeypoints();
} else {
throw runtime_error("File is not open for writing");
}
}
void EventType::writeDescriptors(cv::FileStorage outfile) throw(runtime_error) {
if(outfile.isOpened()) {
outfile << getId() + "_desc" << getDescriptors();
} else {
throw runtime_error("File is not open for writing");
}
}
void TransientAreasSegmentationModuleImpl::write( cv::FileStorage& fs ) const
{
if (!fs.isOpened())
return; // basic error case
fs <<"SegmentationModuleSetup"<<"{";
fs <<"thresholdON" << _segmentationParameters.thresholdON;
fs <<"thresholdOFF" << _segmentationParameters.thresholdOFF;
fs <<"localEnergy_temporalConstant" << _segmentationParameters.localEnergy_temporalConstant;
fs <<"localEnergy_spatialConstant" << _segmentationParameters.localEnergy_spatialConstant;
fs <<"neighborhoodEnergy_temporalConstant" << _segmentationParameters.neighborhoodEnergy_temporalConstant;
fs <<"neighborhoodEnergy_spatialConstant" << _segmentationParameters.neighborhoodEnergy_spatialConstant;
fs <<"contextEnergy_temporalConstant" << _segmentationParameters.contextEnergy_temporalConstant;
fs <<"contextEnergy_spatialConstant" << _segmentationParameters.contextEnergy_spatialConstant;
fs <<"}";
}
bool MarkupEditor::writeSessionData(
cv::FileStorage& fs,
vector< FrameData >& frames,
int start_frame
)
{
if (!fs.isOpened())
return __false("Attempt to write to not open storage");
fs << "LastMarkupSession" << "{";
fs << "LastVisitedFrame" << start_frame;
fs << "ActiveObjectType" << objType();
fs << "}";
return true;
}
void readImageToVector(
cv::FileStorage imageListFs,
std::vector<cv::Mat> &images
) {
cv::FileNode n = imageListFs.getFirstTopLevelNode();
if (n.type() != cv::FileNode::SEQ) {
std::cout << "Image List file is not sequential.\n";
exit(0);
}
cv::FileNodeIterator it = n.begin();
cv::FileNodeIterator it_end = n.end();
for (; it != it_end; it++) {
cv::Mat tempImage = cv::imread(std::string(*it));
cv::Mat tempGrayImage;
cv::cvtColor(tempImage, tempGrayImage, cv::COLOR_BGR2GRAY);
images.push_back(tempGrayImage);
}
}
void EventType::read(cv::FileStorage infile, cv::Rect_<float> bounds) throw(runtime_error) {
cv::Mat descriptors, new_descriptors;
vector<cv::Point2f> keypoints, new_keypoints;
if(infile.isOpened()) {
cv::read(infile[getId() + "_desc"], descriptors); // infile[getId()] >> descriptors;
cv::read(infile[getId() + "_pts"], keypoints); // infile[getId()] >> keypoints;
if(keypoints.size() > 0) {
for(int i=0; i<keypoints.size(); i++) {
if(bounds.contains(keypoints[i])) {
new_descriptors.push_back(descriptors.row(i));
new_keypoints.push_back(keypoints.at(i));
}
}
addDescriptors(new_descriptors);
addKeypoints(new_keypoints);
} else {
addDescriptors(descriptors);
addKeypoints(keypoints);
}
} else {
throw runtime_error("File is not open for reading");
}
}
void write_to_yaml(cv::FileStorage& output_file, const std::string& name, const cv::Mat& matrix)
{
CvMat m = matrix;
output_file.writeObj(name, &m);
}