Provides useful wrappers around many filesystem related functionality, including reading writing certain common data structures as well as common operations (ex. More...

Data Structures
struct	cvmat_header

Functions
bool	file_exists (const std::string &name)
	Returns true if file exists at location, else returns false. More...

void	create_file_directory (const std::string &absfilepath)
	Recursively creates all directories if needed up to the specified file. More...

bool	write_cvmat (const std::string &fname, const cv::Mat &data)
	Writes a cv::Mat structure to the specified location. More...

bool	load_cvmat (const std::string &fname, cv::Mat &data)
	Loads a cv::Mat structure from the specified location. More...

bool	write_sparse_vector (const std::string &fname, const std::vector< std::pair< uint32_t, float > > &data)
	Writes the BoW feature to the specified location. More...

bool	load_sparse_vector (const std::string &fname, std::vector< std::pair< uint32_t, float > > &data)
	Loads the BoW feature from the specified location. More...

std::vector< std::string >	list_files (const std::string &path, const std::string &ext="", bool recursive=true)
	Lists all files in the given directory with an optional extension. More...

std::string	basename (const std::string &path, bool include_extension=false)
	Returns the basename of the input filepath, including or not including the extension. More...

bool	write_text (const std::string &fname, const std::string &text)
	Writes a text file to the input file location given the input string. More...

Detailed Description

Provides useful wrappers around many filesystem related functionality, including reading writing certain common data structures as well as common operations (ex.

file_exists).

Function Documentation

std::string filesystem::basename	(	const std::string &	path,
		bool	include_extension
	)

Returns the basename of the input filepath, including or not including the extension.

Definition at line 100 of file filesystem.cxx.

                                                                           {
                 if (!include_extension) return boost::filesystem::basename(boost::filesystem::path(path));
 
                 return boost::filesystem::basename(boost::filesystem::path(path)) + boost::filesystem::extension(path);
         }

void filesystem::create_file_directory ( const std::string & absfilepath )

Recursively creates all directories if needed up to the specified file.

Definition at line 17 of file filesystem.cxx.

Referenced by benchmark_dataset(), compute_bow(), compute_bow_features(), compute_features(), main(), BagOfWords::save(), MatchesPage::write(), and SimpleDataset::write().

                                                                  {
                 boost::filesystem::path p(absfilepath.c_str());
                 boost::filesystem::path d = p.parent_path();
                 if(!boost::filesystem::exists(d)) {
                         boost::filesystem::create_directories(d);
                 }
         }

bool filesystem::file_exists ( const std::string & name )

Returns true if file exists at location, else returns false.

Definition at line 12 of file filesystem.cxx.

Referenced by BagOfWords::BagOfWords(), compute_bow(), compute_bow_features(), compute_features(), InvertedIndex::InvertedIndex(), load_cvmat(), load_sparse_vector(), main(), SimpleDataset::read(), VocabTree::search(), InvertedIndex::search(), SimpleDataset::SimpleDataset(), VocabTree::train(), InvertedIndex::train(), BagOfWords::train(), and MatchesPage::write().

                                                 {
           struct stat buffer;
           return (stat (name.c_str(), &buffer) == 0);
         }

std::vector< std::string > filesystem::list_files	(	const std::string &	path,
		const std::string &	ext = `""`,
		bool	recursive = `true`
	)

Lists all files in the given directory with an optional extension.

The extension must include the dot (ie. ext=".txt"). If recursive is true (default), will recursively enter all directories

Definition at line 71 of file filesystem.cxx.

Referenced by SimpleDataset::construct_dataset().

                                                                                                      {
                 boost::filesystem::path input_path(path);
                 std::vector<std::string> file_list;
                 if (boost::filesystem::exists(input_path) && boost::filesystem::is_directory(input_path)) {
                         if(recursive) {
                                 boost::filesystem::recursive_directory_iterator end;
                                 for (boost::filesystem::recursive_directory_iterator it(input_path); it != end; ++it) {
                                         if (!boost::filesystem::is_directory(*it)) {
                                                 if ((ext.length() > 0 && boost::filesystem::extension(*it) == boost::filesystem::path(ext)) ||
                                                         ext.length() == 0) {
                                                                 file_list.push_back(it->path().string());
                                                 }
                                         }
                                 }
                         } else {
                                 boost::filesystem::directory_iterator end;
                                 for (boost::filesystem::directory_iterator it(input_path); it != end; ++it) {
                                         if (!boost::filesystem::is_directory(*it)) {
                                                 if ((ext.length() > 0 && boost::filesystem::extension(*it) == boost::filesystem::path(ext)) ||
                                                         ext.length() == 0) {
                                                                 file_list.push_back(it->path().string());
                                                 }
                                         }
                                 }
                         }
                 }
                 return file_list;
         }

bool filesystem::load_cvmat	(	const std::string &	fname,
		cv::Mat &	data
	)

Loads a cv::Mat structure from the specified location.

Returns true if file exists, false otherwise.

Definition at line 42 of file filesystem.cxx.

References file_exists().

Referenced by bench_oxford(), benchmark_dataset(), compute_bow(), compute_bow_features(), BagOfWords::load(), main(), VocabTree::search(), VocabTree::train(), and BagOfWords::train().

                                                              {
                 if(!file_exists(fname)) return false;
                 std::ifstream ifs(fname.c_str(), std::ios::binary);
                 cvmat_header h;
                 ifs.read((char *)&h, sizeof(cvmat_header));
                 if (h.rows == 0 || h.cols == 0) return false;
                 data.create(h.rows, h.cols, h.elem_type);
                 ifs.read((char *)data.ptr(), h.rows * h.cols * h.elem_size);
                 return (ifs.rdstate() & std::ifstream::failbit) == 0;
         }

bool filesystem::load_sparse_vector	(	const std::string &	fname,
		std::vector< std::pair< uint32_t, float > > &	data
	)

Loads the BoW feature from the specified location.

First dimension of data is cluster index, second dimension is TF score.

Definition at line 61 of file filesystem.cxx.

References file_exists().

Referenced by InvertedIndex::search(), and InvertedIndex::train().

                                                                                                      {
                 if(!file_exists(fname)) return false;
                 std::ifstream ifs(fname.c_str(), std::ios::binary);
                 uint32_t dim0;
                 ifs.read((char *)&dim0, sizeof(uint32_t));
                 data.resize(dim0);
                 ifs.read((char *)&data[0], sizeof(std::pair<uint32_t, float >) * dim0);
                 return (ifs.rdstate() & std::ifstream::failbit) == 0;
         }

bool filesystem::write_cvmat	(	const std::string &	fname,
		const cv::Mat &	data
	)

Writes a cv::Mat structure to the specified location.

Definition at line 30 of file filesystem.cxx.

References filesystem::cvmat_header::elem_size.

Referenced by compute_features(), main(), and BagOfWords::save().

                                                                     {
                 std::ofstream ofs(fname.c_str(), std::ios::binary | std::ios::trunc);
                 cvmat_header h;
                 h.elem_size = data.elemSize();
                 h.elem_type = data.type();
                 h.rows = data.rows;
                 h.cols = data.cols;
                 ofs.write((char *)&h, sizeof(cvmat_header));
                 ofs.write((char *)data.ptr(), h.rows * h.cols * h.elem_size);
                 return (ofs.rdstate() & std::ofstream::failbit) == 0;
         }

bool filesystem::write_sparse_vector	(	const std::string &	fname,
		const std::vector< std::pair< uint32_t, float > > &	data
	)

Writes the BoW feature to the specified location.

First dimension of data is cluster index, second dimension is TF score.

Definition at line 53 of file filesystem.cxx.

Referenced by compute_bow(), compute_bow_features(), and main().

                                                                                                             {
                 std::ofstream ofs(fname.c_str(), std::ios::binary | std::ios::trunc);
                 uint32_t dim0 = data.size();
                 ofs.write((char *)&dim0, sizeof(uint32_t));
                 ofs.write((char *)&data[0], sizeof(std::pair<uint32_t, float >) * dim0);
                 return (ofs.rdstate() & std::ofstream::failbit) == 0;
         }

bool filesystem::write_text	(	const std::string &	fname,
		const std::string &	text
	)

Writes a text file to the input file location given the input string.

Returns true if success, false otherwise.

Definition at line 106 of file filesystem.cxx.

Referenced by MatchesPage::write().

                                                                        {
                 std::ofstream ofs(fname, std::ios::trunc);
                 ofs.write(text.c_str(), text.size());
                 return (ofs.rdstate() & std::ofstream::failbit) == 0;
         }

Data Structures

Functions

Detailed Description

Function Documentation