#include <metadata_vec.h>

Inheritance diagram for MetaDataVec:

Collaboration diagram for MetaDataVec:

Classes
struct	MDVecIdIterator

struct	MDVecRowIterator

Public Member Functions
void	readPlain (const FileName &inFile, const String &labelsString, const String &separator=" ")

void	addPlain (const FileName &inFile, const String &labelsString, const String &separator=" ")

double	getColumnMax (MDLabel column)

double	getColumnMin (MDLabel column)

void	replace (const MDLabel label, const String &oldStr, const String &newStr)

void	randomize (const MetaData &MDin)

void	removeDuplicates (MetaData &MDin, MDLabel label=MDL_UNDEFINED)

void	sort (const MetaDataVec &MDin, const MDLabel sortLabel, bool asc=true, int limit=-1, int offset=0)

void	sort (MetaDataVec &MDin, const String &sortLabel, bool asc=true, int limit=-1, int offset=0)

void	split (size_t n, std::vector< MetaDataVec > &results, const MDLabel sortLabel=MDL_OBJID) const

void	selectRandomSubset (const MetaData &mdIn, size_t numberOfObjects, const MDLabel sortLabel=MDL_OBJID) override

void	selectPart (const MetaData &mdIn, size_t startPosition, size_t numberOfObjects, const MDLabel sortLabel=MDL_OBJID) override

void	makeAbsPath (const MDLabel label=MDL_IMAGE)

void	fillConstant (MDLabel label, const String &value) override

void	fillRandom (MDLabel label, const String &mode, double op1, double op2, double op3=0.) override

void	fillLinear (MDLabel label, double initial, double step) override

void	copyColumn (MDLabel labelDest, MDLabel labelSrc) override

void	copyColumnTo (MetaData &md, MDLabel labelDest, MDLabel labelSrc) override

void	renameColumn (MDLabel oldLabel, MDLabel newLabel) override

void	renameColumn (const std::vector< MDLabel > &oldLabel, const std::vector< MDLabel > &newLabel) override

bool	operator== (const MetaDataVec &op) const

Constructors
	MetaDataVec ()

	MetaDataVec (const std::vector< MDLabel > &labelsVector)

	MetaDataVec (const FileName &fileName, const std::vector< MDLabel > &desiredLabels)

	MetaDataVec (const FileName &fileName)

	MetaDataVec (const MetaData &md)

	MetaDataVec (const MetaDataVec &md)=default

virtual	~MetaDataVec ()

void	clear () override

Getters and setters
std::vector< MDLabel >	getActiveLabels () const override

void	writeXML (const FileName fn, const FileName blockname, WriteModeMetaData mode) const override

void	writeText (const FileName fn, const std::vector< MDLabel > *desiredLabels) const override

MetaData Manipulation
size_t	addRow (const MDRow &row) override

void	addRows (const std::vector< MDRowVec > &rows)

int	getMaxStringLength (const MDLabel thisLabel) const override

bool	setValueCol (const MDObject &mdValueIn) override

template<class T >
bool	setValueCol (const MDLabel label, const T &valueIn)

bool	setValue (const MDObject &mdValueIn, size_t id)

template<class T >
bool	setValue (const MDLabel label, const T &valueIn, size_t id)

bool	getValue (MDObject &mdValueOut, size_t id) const override

MDObject &	getValue (MDLabel, size_t id)

const MDObject &	getValue (MDLabel, size_t id) const

template<class T >
bool	getValue (const MDLabel label, T &valueOut, size_t id) const

template<class T >
T	getValue (const MDLabel label, size_t id)

template<class T >
const T	getValue (const MDLabel label, size_t id) const

std::unique_ptr< MDRow >	getRow (size_t id) override

std::unique_ptr< const MDRow >	getRow (size_t id) const override

MDRowVec	getRowVec (size_t id)

const MDRowVec	getRowVec (size_t id) const

void	getRow (MDRowVec &row, size_t id)

bool	getRowValues (size_t id, std::vector< MDObject > &values) const override

size_t	getRowId (size_t i) const

void	getColumnValues (const MDLabel label, std::vector< MDObject > &valuesOut) const override

void	setColumnValues (const std::vector< MDObject > &valuesIn) override

template<class T >
void	setColumnValues (const MDLabel label, const std::vector< T > &valuesIn)

bool	setRow (const MDRow &row, size_t id)

template<class T >
std::vector< T >	getColumnValues (const MDLabel label) const

template<class T >
void	getColumnValues (const MDLabel label, std::vector< T > &valuesOut) const

bool	isEmpty () const override

size_t	size () const override

bool	containsLabel (const MDLabel label) const override

size_t	firstRowId () const override

size_t	firstObject (const MDQuery &) const override

size_t	lastRowId () const override

bool	addLabel (const MDLabel label, int pos=-1) override

bool	removeLabel (const MDLabel label) override

size_t	addObject () override

void	importObject (const MetaData &md, const size_t id, bool doClear=true) override

void	importObjects (const MetaData &md, const std::vector< size_t > &objectsToAdd, bool doClear=true) override

void	importObjects (const MetaData &md, const MDQuery &query, bool doClear=true) override

bool	removeObject (size_t id) override

void	removeObjects (const std::vector< size_t > &toRemove) override

int	removeObjects () override

int	removeObjects (const MDQuery &) override

Search operations
void	findObjects (std::vector< size_t > &objectsOut, const MDQuery &query) const override

void	findObjects (std::vector< size_t > &objectsOut, int limit=-1) const override

size_t	countObjects (const MDQuery &) const override

bool	containsObject (size_t objectId) const override

bool	containsObject (const MDQuery &) const override

bool	containsObject (size_t objectId)

I/O functions
void	_writeRows (std::ostream &os) const override

void	write (const FileName &outFile, WriteModeMetaData mode=MD_OVERWRITE) const

void	write (std::ostream &os, const String &blockName="", WriteModeMetaData mode=MD_OVERWRITE) const

void	readXML (const FileName &inFile, const std::vector< MDLabel > *desiredLabels=nullptr, const String &blockRegExp=DEFAULT_BLOCK_NAME, bool decomposeStack=true)

void	read (const FileName &inFile, const std::vector< MDLabel > *desiredLabels=nullptr, bool decomposeStack=true) override

Iterators
iterator	begin () override

iterator	end () override

const_iterator	begin () const override

const_iterator	end () const override

id_iterator	id_begin () override

id_iterator	id_end () override

id_const_iterator	id_begin () const override

id_const_iterator	id_end () const override

Public Member Functions inherited from MetaData
virtual bool	nextBlock (mdBuffer &buffer, mdBlock &block)

	MetaData ()=default

virtual	~MetaData ()

virtual bool	isColumnFormat () const

virtual void	setMaxRows (size_t maxRows=0)

virtual size_t	getParsedLines ()

virtual void	setPrecission (int _precision)

virtual void	setColumnFormat (bool column)

virtual void	writeStar (const FileName &outFile, const String &blockName, WriteModeMetaData mode) const

virtual String	getComment () const

virtual void	setComment (const String &newComment="No comment")

virtual FileName	getFilename () const

virtual void	setFilename (const FileName &_filename)

template<class T >
bool	setValueCol (const MDLabel label, const T &valueIn)

template<class T >
bool	setValue (const MDLabel label, const T &valueIn, size_t id)

MetaData &	operator= (const MetaData &md)

template<class T >
T	getValue (const MDLabel label, size_t id) const

template<class T >
bool	getValue (const MDLabel label, T &valueOut, size_t id) const

template<class T >
const T &	getValueOrAbort (const MDLabel label, size_t id) const

template<class T >
T &	getValueOrAbort (const MDLabel label, size_t id)

template<class T >
void	getValueOrAbort (const MDLabel label, T &valueOut, size_t id) const

template<typename T >
const T	getValueOrDefault (const MDLabel label, size_t id, const T &_default) const

template<typename T >
T	getValueOrDefault (const MDLabel label, size_t id, T &_default)

template<typename T , typename T1 >
void	getValueOrDefault (const MDLabel label, T &valueOut, size_t id, const T1 &_default) const

template<class T >
std::vector< T >	getColumnValues (const MDLabel label) const

template<class T >
void	getColumnValues (const MDLabel label, std::vector< T > &out) const

template<class T >
void	setColumnValues (const MDLabel label, const std::vector< T > &valuesIn)

virtual bool	setValueFromStr (const MDLabel label, const String &value, size_t id)

virtual bool	getStrFromValue (const MDLabel label, String &strOut, size_t id) const

void	keepLabels (const std::vector< MDLabel > &labels)

virtual void	print () const

void	append (const FileName &outFile) const

virtual void	removeDisabled ()

virtual IdIteratorProxy< false >	ids ()

virtual IdIteratorProxy< true >	ids () const

Protected Member Functions
void	init (const std::vector< MDLabel > &labelsVector)

void	_clear (bool onlyData=false)

std::vector< MDObject >	getObjectsForActiveLabels () const

int	_labelIndex (MDLabel label) const

const MDObject &	_getObject (size_t i, MDLabel label) const

MDObject &	_getObject (size_t i, MDLabel label)

const MDObject &	_getObject (const MetaDataVecRow &, MDLabel) const

MDObject &	_getObject (MetaDataVecRow &, MDLabel) const

int	_rowIndex (size_t id) const

size_t	_rowIndexSafe (size_t id) const

void	_setRow (const MDRow &row, size_t index)

bool	_match (const MetaDataVecRow &, const MDQuery &) const

size_t	getRowId (const MetaDataVecRow &) const

void	_expand (MetaDataVecRow &, const MDLabel)

void	_expand (MetaDataVecRow &, size_t labeli)

void	_parseObjects (std::istream &is, std::vector< MDObject > &columnValues, const std::vector< MDLabel > desiredLabels, bool firstTime) override

void	_recalc_id_to_index ()

bool	_contains (const std::vector< MetaDataVecRow > &, const MetaDataVecRow &) const

bool	_rowsEq (const MetaDataVecRow &a, const MetaDataVecRow &b) const

Protected Member Functions inherited from MetaData
void	copyInfo (const MetaData &md)

double	precision () const

virtual void	readStar (const FileName &filename, const std::vector< MDLabel > *desiredLabels, const String &blockRegExp, bool decomposeStack)

virtual void	_readColumns (std::istream &is, std::vector< MDObject > &columnValues, const std::vector< MDLabel > desiredLabels=nullptr)

virtual void	_readColumnsStar (mdBlock &block, std::vector< MDObject > &columnValues, const std::vector< MDLabel > desiredLabels, bool addColumns=true, size_t id=BAD_OBJID)

virtual void	_parseObject (std::istream &is, MDObject &object, size_t id=BAD_OBJID)

virtual void	_readRows (std::istream &is, std::vector< MDObject *> &columnValues, bool useCommentAsImage)

virtual void	_readRowsStar (mdBlock &block, std::vector< MDObject > &columnValues, const std::vector< MDLabel > desiredLabels)

Protected Attributes
std::vector< MetaDataVecRow >	_rows

std::array< int, MDL_LAST_LABEL >	_label_to_col

std::vector< MDLabel >	_col_to_label

size_t	_no_columns = 0

std::unordered_map< size_t, size_t >	_id_to_index

size_t	_next_id = 1

Protected Attributes inherited from MetaData
std::map< String, size_t >	_fastStringSearch

MDLabel	_fastStringSearchLabel

String	_comment

int	_precision = 1000

FileName	_inFile

size_t	_maxRows = 0

size_t	_parsedLines = 0

Additional Inherited Members
Public Types inherited from MetaData
using	iterator = rowIterator< false >

using	const_iterator = rowIterator< true >

using	id_iterator = idIterator< false >

using	id_const_iterator = idIterator< true >

Public Attributes inherited from MetaData
bool	isMetadataFile

Detailed Description

Fast in-memory storage of metadata in std::vector. MetaDataVec implements MetaData API (see metadata_base.h).

Notes

It's fast to iterate either over rows or over ids.

Definition at line 46 of file metadata_vec.h.

Constructor & Destructor Documentation

◆ MetaDataVec() [1/6]

MetaDataVec::MetaDataVec ( )

Empty Constructor.

The MetaData is created with no data stored on it. You can fill in it programmatically or by a later reading from a MetaData file or old Xmipp formatted type. if labels vectors is passed this labels are created on metadata

Definition at line 42 of file metadata_vec.cpp.

                          {
     init({});
 }

◆ MetaDataVec() [2/6]

MetaDataVec::MetaDataVec ( const std::vector< MDLabel > & labelsVector )

Definition at line 46 of file metadata_vec.cpp.

                                                                {
     init(labelsVector);
 }

◆ MetaDataVec() [3/6]

MetaDataVec::MetaDataVec	(	const FileName &	fileName,
		const std::vector< MDLabel > &	desiredLabels
	)

From File Constructor.

The MetaData is created and data is read from provided FileName. Optionally, a vector of labels can be provided to read just those required labels

Definition at line 50 of file metadata_vec.cpp.

                                                                                           {
     init(desiredLabels);
     read(fileName);
 }

◆ MetaDataVec() [4/6]

MetaDataVec::MetaDataVec ( const FileName & fileName )

Definition at line 55 of file metadata_vec.cpp.

                                                  {
     init({});
     read(fileName);
 }

◆ MetaDataVec() [5/6]

MetaDataVec::MetaDataVec ( const MetaData & md )

Copy constructor

Created a new metadata by copying all data from an existing MetaData object.

Definition at line 60 of file metadata_vec.cpp.

                                            {
     init({});
     MetaData::operator=(md);
 }

◆ MetaDataVec() [6/6]

MetaDataVec::MetaDataVec ( const MetaDataVec & md )

default

◆ ~MetaDataVec()

virtual MetaDataVec::~MetaDataVec ( )

inlinevirtual

Definition at line 121 of file metadata_vec.h.

121 {}

Member Function Documentation

◆ _clear()

void MetaDataVec::_clear ( bool onlyData = false )

protected

clear data and table structure

◆ _contains()

bool MetaDataVec::_contains	(	const std::vector< MetaDataVecRow > &	rows,
		const MetaDataVecRow &	row
	)		const

protected

Definition at line 765 of file metadata_vec.cpp.

                                                                                                   {
     for (const auto& _row : rows)
         if (this->_rowsEq(row, _row))
             return true;
     return false;
 }

◆ _expand() [1/2]

void MetaDataVec::_expand	(	MetaDataVecRow &	row,
		const MDLabel	label
	)

protected

Definition at line 870 of file metadata_vec.cpp.

                                                                   {
     int labeli = this->_labelIndex(label);
     if (labeli < 0)
         this->addLabel(label);
     this->_expand(row,  this->_labelIndex(label));
 }

◆ _expand() [2/2]

void MetaDataVec::_expand	(	MetaDataVecRow &	row,
		size_t	labeli
	)

protected

Definition at line 877 of file metadata_vec.cpp.

                                                             {
     // In assert: all labels to labeli (including) must be present in
     // this->_col_to_label.
 
     if (labeli < row.size())
         return; // space for label already present
 
     for (size_t i = row.size(); i <= labeli; i++)
         row.emplace_back(MDObject(this->_col_to_label.at(i)));
 }

◆ _getObject() [1/4]

const MDObject & MetaDataVec::_getObject	(	size_t	i,
		MDLabel	label
	)		const

protected

Definition at line 85 of file metadata_vec.cpp.

                                                                      {
     return this->_getObject(this->_rows.at(i), label);
 }

◆ _getObject() [2/4]

MDObject & MetaDataVec::_getObject	(	size_t	i,
		MDLabel	label
	)

protected

Definition at line 89 of file metadata_vec.cpp.

                                                          {
     return this->_getObject(this->_rows.at(i), label);
 }

◆ _getObject() [3/4]

const MDObject & MetaDataVec::_getObject	(	const MetaDataVecRow &	row,
		MDLabel	label
	)		const

protected

Definition at line 93 of file metadata_vec.cpp.

                                                                                       {
     int labelIndex = this->_labelIndex(label);
     if ((labelIndex < 0) || (static_cast<size_t>(labelIndex) >= row.size()))
         throw ColumnDoesNotExist(label, getFilename());
     return row.at(labelIndex);
 }

◆ _getObject() [4/4]

MDObject & MetaDataVec::_getObject	(	MetaDataVecRow &	row,
		MDLabel	label
	)		const

protected

Definition at line 100 of file metadata_vec.cpp.

                                                                           {
     int labelIndex = this->_labelIndex(label);
     if (labelIndex < 0)
         throw ColumnDoesNotExist(label, getFilename());
     return row.at(labelIndex);
 }

◆ _labelIndex()

int MetaDataVec::_labelIndex ( MDLabel label ) const

protected

Definition at line 81 of file metadata_vec.cpp.

                                                 {
     return this->_label_to_col[label];
 }

◆ _match()

bool MetaDataVec::_match	(	const MetaDataVecRow &	row,
		const MDQuery &	query
	)		const

protected

Definition at line 516 of file metadata_vec.cpp.

                                                                               {
     if (dynamic_cast<const MDMultiQuery*>(&query) != nullptr) {
         // Process MDMultiQuery
         const MDMultiQuery& mq = dynamic_cast<const MDMultiQuery&>(query);
         if (mq.operations.size() == 0)
             return true; // emptuy query matches always
         String operation = mq.operations[0];
         for (const auto& op : mq.operations)
             assert(op == operation); // support only all same operations
         for (const auto& q : mq.queries) {
             if ((operation == "AND") && (!this->_match(row, *q)))
                 return false;
             else if ((operation == "OR") && (this->_match(row, *q)))
                 return true;
         }
         return (operation == "AND"); // false for "OR", true for "AND"
     }
 
     if (dynamic_cast<const MDValueRelational*>(&query) == nullptr)
         throw NotImplemented("_match for this type of query not implemented");
             // MDValueRange, MDExpression, MDMultiQuery not implemented yet
             // MDExpression will probably never be supported as it is raw SQL expression
 
     const MDValueRelational& rel = dynamic_cast<const MDValueRelational&>(query);
 
     if (rel.value == nullptr)
         return false;
 
     size_t labeli = this->_labelIndex(rel.value->label);
     if (labeli >= row.size())
         return false;
 
     const MDObject& mdObj = row[labeli];
 
     if (rel.op == RelationalOp::EQ)
         return *(rel.value) == mdObj;
     if (rel.op == RelationalOp::NE)
         return *(rel.value) != mdObj;
     if (rel.op == RelationalOp::GT) // FIXME: check if < & > are not swapped
         return *(rel.value) < mdObj;
     if (rel.op == RelationalOp::GE)
         return *(rel.value) <= mdObj;
     if (rel.op == RelationalOp::LT)
         return *(rel.value) > mdObj;
     if (rel.op == RelationalOp::LE)
         return *(rel.value) >= mdObj;
 
     throw std::logic_error("MetaDataVec::_match: unknown operator");
 }

◆ _parseObjects()

void MetaDataVec::_parseObjects	(	std::istream &	is,
		std::vector< MDObject *> &	columnValues,
		const std::vector< MDLabel > *	desiredLabels,
		bool	firstTime
	)

overrideprotectedvirtual

Implements MetaData.

Definition at line 669 of file metadata_vec.cpp.

                                                                                          {
     for (size_t i = 0; i < columnValues.size(); i++) {
         columnValues[i]->fromStream(is);
 
         if (is.fail()) {
            String errorMsg = formatString("MetaData: Error parsing column '%s' value.",
                                           MDL::label2Str(columnValues[i]->label).c_str());
            columnValues[i]->failed = true;
            std::cerr << "WARNING: " << errorMsg << std::endl;
            //REPORT_ERROR(ERR_MD_BADLABEL, (String)"read: Error parsing data column, expecting " + MDL::label2Str(object.label));
         } else if (firstTime) {
             // Check if current column label exists.
             if (columnValues[i]->label != MDL_UNDEFINED) {
                 // If there are no desired labels then add all.
                 bool reallyAdd=false;
                 if (desiredLabels == NULL) {
                     reallyAdd = true;
                 } else {
                     // Check if current column belongs to desired labels.
                     for (size_t j = 0; j < desiredLabels->size(); ++j) {
                         if ((*desiredLabels)[j] == columnValues[i]->label) {
                             reallyAdd = true;
                             break;
                         }
                     }
                 }
 
                 // Add label if not exists.
                 if (reallyAdd)
                     this->addLabel(columnValues[i]->label);
             }
         }
     }
 
     // Insert elements in DB.
     MDRowVec newRow;
     for (size_t i = 0; i < columnValues.size(); i++)
         if (columnValues[i] != nullptr)
             newRow.setValue(*columnValues[i]);
     this->addRow(newRow);
 }

◆ _recalc_id_to_index()

void MetaDataVec::_recalc_id_to_index ( )

protected

Definition at line 749 of file metadata_vec.cpp.

                                       {
     this->_id_to_index.clear();
     for (size_t i = 0; i < this->_rows.size(); i++)
         this->_id_to_index[this->getRowId(i)] = i;
 }

◆ _rowIndex()

int MetaDataVec::_rowIndex ( size_t id ) const

protected

Definition at line 107 of file metadata_vec.cpp.

                                           {
     if (this->_id_to_index.find(id) == this->_id_to_index.end())
         return -1;
     return this->_id_to_index.at(id);
 }

◆ _rowIndexSafe()

size_t MetaDataVec::_rowIndexSafe ( size_t id ) const

protected

Definition at line 113 of file metadata_vec.cpp.

                                                  {
     int i = this->_rowIndex(id);
     if (i == -1)
         throw ObjectDoesNotExist(id, getFilename());
     return i;
 }

◆ _rowsEq()

bool MetaDataVec::_rowsEq	(	const MetaDataVecRow &	a,
		const MetaDataVecRow &	b
	)		const

protected

Definition at line 772 of file metadata_vec.cpp.

                                                                                 {
     for (size_t label = 0; label < MDL_LAST_LABEL; label++) {
         if ((label == MDL_COMMENT) || (label == MDL_OBJID))
             continue;
 
         int labeli = this->_labelIndex(static_cast<MDLabel>(label));
         if (labeli > -1) { // label is active
             if ((static_cast<size_t>(labeli) < a.size()) !=
                 (static_cast<size_t>(labeli) < b.size()))
                 return false; // item present in one row, but not other
             if (static_cast<size_t>(labeli) >= a.size())
                 continue; // label not present in both rows
             if (!a[labeli].eq(b[labeli], this->precision()))
                 return false; // MDObjects are diffrent
         }
     }
     return true;
 }

◆ _setRow()

void MetaDataVec::_setRow	(	const MDRow &	row,
		size_t	index
	)

protected

Definition at line 180 of file metadata_vec.cpp.

                                                         {
     if (dynamic_cast<const MDRowVec*>(&row) != nullptr) {
         // No not change same row
         const MDRowVec& mdRowVec = dynamic_cast<const MDRowVec&>(row);
         if ((mdRowVec._in_metadata) && (mdRowVec._rowi == index) && (mdRowVec._row == &this->_rows[index]))
             return;
     }
 
     size_t newRowSize = 0;
     for (size_t labeli = 0; labeli < MDL_LAST_LABEL; ++labeli) {
         MDLabel label = static_cast<MDLabel>(labeli);
         if (row.containsLabel(label)) {
             if (!this->containsLabel(label))
                 newRowSize = this->size();
             else if (this->_label_to_col[label]+1 > newRowSize)
                 newRowSize = this->_label_to_col[label]+1;
         }
     }
 
     for (size_t column = 0; (column < this->_col_to_label.size()) && (column < newRowSize); ++column)
         if ((this->_col_to_label[column] != MDL_OBJID) && (!row.containsLabel(this->_col_to_label[column])))
             throw ColumnDoesNotExist("New row does not contain required MetaData column: "+
                                      MDL::label2Str(this->_col_to_label[column])+"!");
 
     for (size_t labeli = 0; labeli < MDL_LAST_LABEL; ++labeli) {
         MDLabel label = static_cast<MDLabel>(labeli);
         if (row.containsLabel(label) && !this->containsLabel(label))
             this->addLabel(label);
     }
 
     MetaDataVecRow& editRow = this->_rows[index];
     editRow.clear();
 
     for (size_t coli = 0; coli < this->_no_columns; coli++)
         editRow.push_back({this->_col_to_label[coli]});
 
     for (size_t labeli = 0; labeli < MDL_LAST_LABEL; ++labeli) {
         MDLabel label = static_cast<MDLabel>(labeli);
         if (row.containsLabel(label)) {
             size_t ourCol = _label_to_col[label];
             row.getValue(editRow[ourCol]);
         }
     }
 }

◆ _writeRows()

void MetaDataVec::_writeRows ( std::ostream & os ) const

overridevirtual

Write rows data to disk.

Implements MetaData.

Definition at line 612 of file metadata_vec.cpp.

                                                  {
     for (const MetaDataVecRow& row : this->_rows) {
         for (size_t i = 0; i < MDL_LAST_LABEL; i++) {
             const MDLabel label = static_cast<MDLabel>(i);
             if ((label != MDL_STAR_COMMENT) && (label != MDL_OBJID) && (this->_label_to_col[i] > -1)) {
                 os.width(1);
                 if (this->_labelIndex(label) < static_cast<int>(row.size()))
                     this->_getObject(row, label).toStream(os, true);
                 else
                     throw ColumnDoesNotExist(label, getFilename());
                 os << " ";
             }
         }
         os << '\n';
     }
 }

◆ addLabel()

bool MetaDataVec::addLabel	(	const MDLabel	label,
		int	pos = `-1`
	)

overridevirtual

Add a new label to the metadata. By default the label is added at the end, if the position is specified and is between 0 and n-1 the new label is inserted at that position.

Implements MetaData.

Definition at line 401 of file metadata_vec.cpp.

                                                        {
     if (pos != -1)
         throw NotImplemented("addLabel to -1 not implemented");
     if (this->_label_to_col[label] != -1)
         return true;
 
     this->_no_columns++;
     size_t column = this->_no_columns-1;
     this->_label_to_col[label] = column;
     this->_col_to_label.emplace_back(label);
     return true;
 }

◆ addObject()

size_t MetaDataVec::addObject ( )

overridevirtual

Adds a new, empty object to the objects map. If objectId == -1 the new ID will be that for the last object inserted + 1, else the given objectId is used. If there is already an object whose objectId == input objectId, just removes it and creates an empty one

Implements MetaData.

Definition at line 435 of file metadata_vec.cpp.

                               {
     MDRowVec row;
     row.setValue(MDObject(MDL_OBJID, this->_next_id));
     return this->addRow(row);
 }

◆ addPlain()

void MetaDataVec::addPlain	(	const FileName &	inFile,
		const String &	labelsString,
		const String &	separator = `" "`
	)

Same as readPlain, but instead of cleanning data, the readed values will be added. If there are common columns in metadata and the plain text, the lattest will be setted

Definition at line 721 of file metadata_vec.cpp.

                                                                                                       {
     // TODO
     throw NotImplemented("addPlain not implemented");
 }

◆ addRow()

size_t MetaDataVec::addRow ( const MDRow & row )

overridevirtual

Implements MetaData.

Definition at line 225 of file metadata_vec.cpp.

                                            {
     /* Id:
      * When ‹row› does not contain MDL_OBJID column, it is created from ‹this->_nextId›
      * When ‹row› contains id which is NOT present in Metadata, id is kept.
      * When ‹row› contains id which IS present in Metadata, id is changed from ‹this->_nextId›.
      * When ‹this->_nextId› is present in MetaData, assert fails. This should not happen.
     */
 
     MetaDataVecRow newRow;
     _rows.emplace_back(newRow);
     this->_setRow(row, _rows.size()-1);
 
     if ((!row.containsLabel(MDL_OBJID)) || (row.getValue<size_t>(MDL_OBJID) == BAD_OBJID)) {
         MetaDataVecRow& _row = this->_rows[_rows.size()-1];
         if (!this->containsLabel(MDL_OBJID))
             this->addLabel(MDL_OBJID);
         this->_expand(_row, MDL_OBJID);
         _row[this->_labelIndex(MDL_OBJID)] = MDObject(MDL_OBJID, this->_next_id);
     }
 
     size_t rowId = getRowId(_rows.size()-1);
 
     if (this->_id_to_index.find(rowId) != this->_id_to_index.end()) {
         MetaDataVecRow& _row = this->_rows[_rows.size()-1];
         _row[this->_labelIndex(MDL_OBJID)] = MDObject(MDL_OBJID, this->_next_id);
         rowId = this->_next_id;
     }
 
     assert(this->_id_to_index.find(rowId) == this->_id_to_index.end());
 
     if (rowId >= this->_next_id)
         this->_next_id = rowId+1;
     this->_id_to_index[rowId] = _rows.size()-1;
     return rowId;
 }

◆ addRows()

void MetaDataVec::addRows ( const std::vector< MDRowVec > & rows )

Definition at line 261 of file metadata_vec.cpp.

                                                          {
     for (const auto row : rows)
         this->addRow(row);
 }

◆ begin() [1/2]

iterator MetaDataVec::begin ( )

inlineoverridevirtual

Implements MetaData.

Definition at line 501 of file metadata_vec.h.

                               {
         return {memoryUtils::make_unique<MDVecRowIterator<false>>(*this, 0)};
     }

◆ begin() [2/2]

const_iterator MetaDataVec::begin ( ) const

inlineoverridevirtual

Implements MetaData.

Definition at line 508 of file metadata_vec.h.

                                           {
         return {memoryUtils::make_unique<MDVecRowIterator<true>>(*this, 0)};
     }

◆ clear()

void MetaDataVec::clear ( )

overridevirtual

Clear all data

Reimplemented from MetaData.

Definition at line 170 of file metadata_vec.cpp.

                         {
     MetaData::clear();
     this->_rows.clear();
     std::fill(this->_label_to_col.begin(), this->_label_to_col.end(), -1);
     this->_col_to_label.clear();
     this->_id_to_index.clear();
     this->_no_columns = 0;
     this->_next_id = 1;
 }

◆ containsLabel()

bool MetaDataVec::containsLabel ( const MDLabel label ) const

overridevirtual

Check whether a label is contained in metadata.

Implements MetaData.

Definition at line 397 of file metadata_vec.cpp.

                                                          {
     return this->_labelIndex(label) > -1;
 }

◆ containsObject() [1/3]

bool MetaDataVec::containsObject ( size_t objectId ) const

overridevirtual

Implements MetaData.

Definition at line 596 of file metadata_vec.cpp.

                                                       {
     return this->_rowIndex(objectId) > -1;
 }

◆ containsObject() [2/3]

bool MetaDataVec::containsObject ( const MDQuery & query ) const

overridevirtual

Implements MetaData.

Definition at line 600 of file metadata_vec.cpp.

                                                            {
     for (const MetaDataVecRow& row : this->_rows)
         if (this->_match(row, query))
             return true;
     return false;
 }

◆ containsObject() [3/3]

bool MetaDataVec::containsObject ( size_t objectId )

Find if the object with this id is present in the metadata

Definition at line 607 of file metadata_vec.cpp.

                                                 {
     return this->_id_to_index.find(objectId) != this->_id_to_index.end();
 }

◆ copyColumn()

void MetaDataVec::copyColumn	(	MDLabel	labelDest,
		MDLabel	labelSrc
	)

overridevirtual

Copy all values from one column to another. Source column should exist

Implements MetaData.

Definition at line 888 of file metadata_vec.cpp.

                                                                 {
     int labelsrci = this->_labelIndex(labelSrc);
     int labeldesti = this->_labelIndex(labelDest);
     if (labelsrci < 0)
         return;
     if (labeldesti < 0)
         this->addLabel(labelDest);
     labeldesti = this->_labelIndex(labelDest);
 
     for (MetaDataVecRow& row : this->_rows) {
         if (static_cast<size_t>(labeldesti) >= row.size())
             this->_expand(row, labeldesti);
 
         if (static_cast<size_t>(labelsrci) < row.size()) {
             row[labeldesti] = row[labelsrci];
             row[labeldesti].label = labelDest;
         }
         // else row[labeldesti] is empty MDObject (from previous if)
     }
 }

◆ copyColumnTo()

void MetaDataVec::copyColumnTo	(	MetaData &	md,
		MDLabel	labelDest,
		MDLabel	labelSrc
	)

overridevirtual

Same as previous, but copy to another metadata

Implements MetaData.

Definition at line 909 of file metadata_vec.cpp.

                                                                                 {
     // TODO
     throw NotImplemented("copyColumnTo not implemented");
 }

◆ countObjects()

size_t MetaDataVec::countObjects ( const MDQuery & query ) const

overridevirtual

Implements MetaData.

Definition at line 588 of file metadata_vec.cpp.

                                                            {
     size_t count = 0;
     for (const MetaDataVecRow& row : this->_rows)
         if (this->_match(row, query))
             count++;
     return count;
 }

◆ end() [1/2]

iterator MetaDataVec::end ( )

inlineoverridevirtual

Implements MetaData.

Definition at line 504 of file metadata_vec.h.

                             {
         return {memoryUtils::make_unique<MDVecRowIterator<false>>(*this, this->size())};
     }

◆ end() [2/2]

const_iterator MetaDataVec::end ( ) const

inlineoverridevirtual

Implements MetaData.

Definition at line 511 of file metadata_vec.h.

                                         {
         return {memoryUtils::make_unique<MDVecRowIterator<true>>(*this, this->size())};
     }

◆ fillConstant()

void MetaDataVec::fillConstant	(	MDLabel	label,
		const String &	value
	)

overridevirtual

Fill column with constant value

Implements MetaData.

Definition at line 849 of file metadata_vec.cpp.

                                                                  {
     // FIXME: move to MetaData and use common MDGenerator?
     MDConstGenerator generator(value);
     generator.label = label;
     generator.fill(*this);
 }

◆ fillLinear()

void MetaDataVec::fillLinear	(	MDLabel	label,
		double	initial,
		double	step
	)

overridevirtual

Fill lineal, starting at some value and with some step

Implements MetaData.

Definition at line 863 of file metadata_vec.cpp.

                                                                        {
     // FIXME: move to MetaData and use common MDGenerator?
     MDLinealGenerator generator(initial, step);
     generator.label = label;
     generator.fill(*this);
 }

◆ fillRandom()

void MetaDataVec::fillRandom	(	MDLabel	label,
		const String &	mode,
		double	op1,
		double	op2,
		double	op3 = `0.`
	)

overridevirtual

Fill column with random value mode should be: uniform, gaussian or student op1, op2 and op2 are interpreted for each mode: uniform: op1 and op2 are the limits of the interval gaussian: op1 and op2 are mean and std student: same as gaussian and use op3

Implements MetaData.

Definition at line 856 of file metadata_vec.cpp.

                                                                                                   {
     // FIXME: move to MetaData and use common MDGenerator?
     MDRandGenerator generator(op1, op2, mode, op3);
     generator.label = label;
     generator.fill(*this);
 }

◆ findObjects() [1/2]

void MetaDataVec::findObjects	(	std::vector< size_t > &	objectsOut,
		const MDQuery &	query
	)		const

overridevirtual

Find all objects that match a query. if called without query, all objects are returned if limit is provided only return a maximun of 'limit'

Implements MetaData.

Definition at line 574 of file metadata_vec.cpp.

                                                                                        {
     // FIXME: should first be first in _rows order or ids order?
     objectsOut.clear();
     for (const MetaDataVecRow& row : this->_rows)
         if (this->_match(row, query))
             objectsOut.emplace_back(this->getRowId(row));
 }

◆ findObjects() [2/2]

void MetaDataVec::findObjects	(	std::vector< size_t > &	objectsOut,
		int	limit = `-1`
	)		const

overridevirtual

Implements MetaData.

Definition at line 582 of file metadata_vec.cpp.

                                                                             {
     objectsOut.clear();
     for (size_t i = 0; i < std::min<size_t>(limit, this->size()); i++)
         objectsOut.emplace_back(this->getRowId(this->_rows[i]));
 }

◆ firstObject()

size_t MetaDataVec::firstObject ( const MDQuery & query ) const

overridevirtual

Implements MetaData.

Definition at line 566 of file metadata_vec.cpp.

                                                           {
     // FIXME: should first be first in _rows order or ids order?
     for (const MetaDataVecRow& row : this->_rows)
         if (this->_match(row, query))
             return this->getRowId(row);
     return BAD_OBJID;
 }

◆ firstRowId()

size_t MetaDataVec::firstRowId ( ) const

overridevirtual

Return the object id of the first element in metadata.

Implements MetaData.

Definition at line 508 of file metadata_vec.cpp.

                                      {
     return this->getRowId(0);
 }

◆ getActiveLabels()

std::vector< MDLabel > MetaDataVec::getActiveLabels ( ) const

overridevirtual

Get safe access to active labels.

Implements MetaData.

Definition at line 969 of file metadata_vec.cpp.

                                                       {
     std::vector<MDLabel> out;
     for (size_t i = MDL_GATHER_ID; i < MDL_LAST_LABEL; i++) // ignore MDL_FIRST_LABEL = MDL_OBJID
         if (this->_label_to_col[i] > -1)
             out.emplace_back(static_cast<MDLabel>(i));
     return out;
 }

◆ getColumnMax()

double MetaDataVec::getColumnMax ( MDLabel column )

Returns Max and Min values from a column in metadata These functions can only be used for labels of type double

Definition at line 726 of file metadata_vec.cpp.

                                                {
     // TODO
     throw NotImplemented("getColumnMax not implemented");
 }

◆ getColumnMin()

double MetaDataVec::getColumnMin ( MDLabel column )

Definition at line 731 of file metadata_vec.cpp.

                                                {
     // TODO
     throw NotImplemented("getColumnMin not implemented");
 }

◆ getColumnValues() [1/3]

void MetaDataVec::getColumnValues	(	const MDLabel	label,
		std::vector< MDObject > &	valuesOut
	)		const

overridevirtual

Get all values of a column as a vector.

Implements MetaData.

Definition at line 362 of file metadata_vec.cpp.

                                                                                            {
     valuesOut.clear();
     int labelIndex = this->_labelIndex(label);
     if (labelIndex < 0)
         throw ColumnDoesNotExist(label, getFilename());
     for (const auto& vecRow : this->_rows)
         valuesOut.emplace_back(vecRow.at(labelIndex));
 }

◆ getColumnValues() [2/3]

template<class T >

std::vector<T> MetaDataVec::getColumnValues ( const MDLabel label ) const

inline

Definition at line 217 of file metadata_vec.h.

                                                             {
         return MetaData::getColumnValues<T>(label);
     }

◆ getColumnValues() [3/3]

template<class T >

void MetaDataVec::getColumnValues	(	const MDLabel	label,
		std::vector< T > &	valuesOut
	)		const

inline

Definition at line 222 of file metadata_vec.h.

                                                                              {
         return MetaData::getColumnValues(label, valuesOut);
     }

◆ getMaxStringLength()

int MetaDataVec::getMaxStringLength ( const MDLabel thisLabel ) const

overridevirtual

Get maximum string length of column values.

Implements MetaData.

Definition at line 266 of file metadata_vec.cpp.

                                                                  {
     return 255;
 }

◆ getObjectsForActiveLabels()

std::vector<MDObject> MetaDataVec::getObjectsForActiveLabels ( ) const

protected

Get a vector of (empty) objects for each active label

◆ getRow() [1/3]

std::unique_ptr< MDRow > MetaDataVec::getRow ( size_t id )

overridevirtual

Implements MetaData.

Definition at line 310 of file metadata_vec.cpp.

                                                   {
     int i = this->_rowIndex(id);
     if (i < 0)
         return nullptr;
     return memoryUtils::make_unique<MDRowVec>(
         this->_rows[i], i, this->_label_to_col, this->_col_to_label, this->_no_columns
     );
 }

◆ getRow() [2/3]

std::unique_ptr< const MDRow > MetaDataVec::getRow ( size_t id ) const

overridevirtual

Implements MetaData.

Definition at line 319 of file metadata_vec.cpp.

                                                               {
     int i = this->_rowIndex(id);
     if (i < 0)
         return nullptr;
     return memoryUtils::make_unique<MDRowVec>(
         this->_rows[i], i, this->_label_to_col, this->_col_to_label, this->_no_columns
     );
 }

◆ getRow() [3/3]

void MetaDataVec::getRow	(	MDRowVec &	row,
		size_t	id
	)

Definition at line 338 of file metadata_vec.cpp.

                                                  {
     size_t i = this->_rowIndexSafe(id);
     row = MDRowVec(this->_rows[i], i, this->_label_to_col, this->_col_to_label, this->_no_columns);
 }

◆ getRowId() [1/2]

size_t MetaDataVec::getRowId ( const MetaDataVecRow & row ) const

protected

Definition at line 355 of file metadata_vec.cpp.

                                                             {
     int labelIndex = _labelIndex(MDL_OBJID);
     if (labelIndex < 0)
         throw ColumnDoesNotExist(MDL_OBJID, getFilename());
     return row.at(labelIndex).getValue2(size_t());
 }

◆ getRowId() [2/2]

size_t MetaDataVec::getRowId ( size_t i ) const

Definition at line 351 of file metadata_vec.cpp.

                                            {
     return this->_getObject(i, MDL_OBJID).getValue2(size_t());
 }

◆ getRowValues()

bool MetaDataVec::getRowValues	(	size_t	id,
		std::vector< MDObject > &	values
	)		const

overridevirtual

Implements MetaData.

Definition at line 343 of file metadata_vec.cpp.

                                                                            {
     int i = this->_rowIndex(id);
     if (i < 0)
         return false;
     values = this->_rows[i];
     return true;
 }

◆ getRowVec() [1/2]

MDRowVec MetaDataVec::getRowVec ( size_t id )

Definition at line 328 of file metadata_vec.cpp.

                                          {
     size_t i = this->_rowIndexSafe(id);
     return MDRowVec(this->_rows[i], i, this->_label_to_col, this->_col_to_label, this->_no_columns);
 }

◆ getRowVec() [2/2]

const MDRowVec MetaDataVec::getRowVec ( size_t id ) const

Definition at line 333 of file metadata_vec.cpp.

                                                      {
     size_t i = this->_rowIndexSafe(id);
     return MDRowVec(this->_rows[i], i, this->_label_to_col, this->_col_to_label, this->_no_columns);
 }

◆ getValue() [1/6]

bool MetaDataVec::getValue	(	MDObject &	mdValueOut,
		size_t	id
	)		const

overridevirtual

Implements MetaData.

Definition at line 293 of file metadata_vec.cpp.

                                                                 {
     try {
         mdValueOut = this->_getObject(this->_rowIndexSafe(id), mdValueOut.label);
     } catch (const ColumnDoesNotExist&) {
         return false;
     }
     return true;
 }

◆ getValue() [2/6]

MDObject & MetaDataVec::getValue	(	MDLabel	label,
		size_t	id
	)

Definition at line 302 of file metadata_vec.cpp.

                                                         {
     return this->_getObject(this->_rowIndexSafe(id), label);
 }

◆ getValue() [3/6]

const MDObject & MetaDataVec::getValue	(	MDLabel	label,
		size_t	id
	)		const

Definition at line 306 of file metadata_vec.cpp.

                                                                     {
     return this->_getObject(this->_rowIndexSafe(id), label);
 }

◆ getValue() [4/6]

template<class T >

bool MetaDataVec::getValue	(	const MDLabel	label,
		T &	valueOut,
		size_t	id
	)		const

inline

Definition at line 182 of file metadata_vec.h.

                                                                      {
         return MetaData::getValue(label, valueOut, id);
     }

◆ getValue() [5/6]

template<class T >

T MetaDataVec::getValue	(	const MDLabel	label,
		size_t	id
	)

inline

Definition at line 187 of file metadata_vec.h.

                                                {
         return this->getValue(label, id).getValue2(T());
     }

◆ getValue() [6/6]

template<class T >

const T MetaDataVec::getValue	(	const MDLabel	label,
		size_t	id
	)		const

inline

Definition at line 192 of file metadata_vec.h.

                                                            {
         return this->getValue(label, id).getValue2(T());
     }

◆ id_begin() [1/2]

id_iterator MetaDataVec::id_begin ( )

inlineoverridevirtual

Implements MetaData.

Definition at line 542 of file metadata_vec.h.

                                     {
         return {memoryUtils::make_unique<MDVecIdIterator<false>>(*this, 0)};
     }

◆ id_begin() [2/2]

id_const_iterator MetaDataVec::id_begin ( ) const

inlineoverridevirtual

Implements MetaData.

Definition at line 550 of file metadata_vec.h.

                                                 {
         return {memoryUtils::make_unique<MDVecIdIterator<true>>(*this, 0)};
     }

◆ id_end() [1/2]

id_iterator MetaDataVec::id_end ( )

inlineoverridevirtual

Implements MetaData.

Definition at line 546 of file metadata_vec.h.

                                   {
         return {memoryUtils::make_unique<MDVecIdIterator<false>>(*this, this->size())};
     }

◆ id_end() [2/2]

id_const_iterator MetaDataVec::id_end ( ) const

inlineoverridevirtual

Implements MetaData.

Definition at line 554 of file metadata_vec.h.

                                               {
         return {memoryUtils::make_unique<MDVecIdIterator<true>>(*this, this->size())};
     }

◆ importObject()

void MetaDataVec::importObject	(	const MetaData &	md,
		const size_t	id,
		bool	doClear = `true`
	)

overridevirtual

Import objects from another metadata.

//Import object 1000 from metadata B into metadata A
A.importObject(B, 1000);
//Import all objects with rotational angle greater that 60
A.importObjects(B, MDValuesGT(MDL_ANGLE_ROT, 60));
//Import all objects
A.importObjects(B);

Implements MetaData.

Definition at line 441 of file metadata_vec.cpp.

                                                                                 {
     if (doClear) {
         this->clear();
         this->copyInfo(md);
     }
 
     std::unique_ptr<const MDRow> row = md.getRow(id);
     if (row == nullptr)
         return;
 
     MDRowVec newRow;
     for (const MDObject* obj : *row)
         if (obj->label != MDL_OBJID)
             newRow.setValue(*obj);
     this->addRow(newRow);
 }

◆ importObjects() [1/2]

void MetaDataVec::importObjects	(	const MetaData &	md,
		const std::vector< size_t > &	objectsToAdd,
		bool	doClear = `true`
	)

overridevirtual

Implements MetaData.

Definition at line 458 of file metadata_vec.cpp.

                                                                                                        {
     if (doClear) {
         this->clear();
         this->copyInfo(md);
     }
 
     for (size_t objId : objectsToAdd)
         this->importObject(md, objId, false);
 }

◆ importObjects() [2/2]

void MetaDataVec::importObjects	(	const MetaData &	md,
		const MDQuery &	query,
		bool	doClear = `true`
	)

overridevirtual

Implements MetaData.

Definition at line 468 of file metadata_vec.cpp.

                                                                                       {
     // FIXME: move this to MetaData?
     std::vector<size_t> ids;
     md.findObjects(ids, query);
     this->importObjects(md, ids, doClear);
 }

◆ init()

void MetaDataVec::init ( const std::vector< MDLabel > & labelsVector )

protected

Init, do some initializations tasks, used in constructors

Definition at line 66 of file metadata_vec.cpp.

                                                              {
     this->clear();
     _label_to_col[MDL_OBJID] = 0;
     _col_to_label.push_back(MDL_OBJID);
     size_t col = 1;
     for (const auto label : labelsVector) {
         if (label != MDL_OBJID) {
             _label_to_col[label] = col;
             _col_to_label.push_back(label);
             col++;
         }
     }
     _no_columns = col;
 }

◆ isEmpty()

bool MetaDataVec::isEmpty ( ) const

overridevirtual

Check whether the metadata is empty.

Reimplemented from MetaData.

Definition at line 389 of file metadata_vec.cpp.

                                 {
     return this->_rows.empty();
 }

◆ lastRowId()

size_t MetaDataVec::lastRowId ( ) const

overridevirtual

Goto last metadata object.

Implements MetaData.

Definition at line 512 of file metadata_vec.cpp.

                                     {
     return this->getRowId(this->size()-1);
 }

◆ makeAbsPath()

void MetaDataVec::makeAbsPath ( const MDLabel label = MDL_IMAGE )

Makes filenames with absolute paths

◆ operator==()

bool MetaDataVec::operator== ( const MetaDataVec & op ) const

Definition at line 937 of file metadata_vec.cpp.

                                                         {
     // This comparison ignores order of labels and row ids, everything else must be same.
 
     if (this->_rows.size() != op._rows.size())
         return false;
 
     for (size_t labeli = 0; labeli < MDL_LAST_LABEL; labeli++)
         if ((this->_label_to_col[labeli] > -1) != (op._label_to_col[labeli] > -1))
             return false;
 
     for (size_t i = 0; i < this->_rows.size(); i++) {
         for (size_t labeli = 0; labeli < MDL_LAST_LABEL; labeli++) {
             if ((labeli == MDL_COMMENT) || (labeli == MDL_OBJID))
                 continue;
 
             int thisLabelColI = this->_label_to_col[labeli];
             int opLabelColI = op._label_to_col[labeli];
             if (thisLabelColI > -1) {
                 if ((static_cast<size_t>(thisLabelColI) < this->_rows[i].size()) !=
                     (static_cast<size_t>(opLabelColI) < op._rows[i].size()))
                     return false; // item present in one row, but not other
                 if (static_cast<size_t>(thisLabelColI) >= this->_rows[i].size())
                     continue; // label not present in both rows
                 if (!this->_rows[i][thisLabelColI].eq(op._rows[i][opLabelColI], this->precision()))
                     return false; // MDObjects are diffrent
             }
         }
     }
 
     return true; // all rows same → ok
 }

◆ randomize()

void MetaDataVec::randomize ( const MetaData & MDin )

Randomize a metadata. MDin is input and the "randomized" result will be in the "calling" Metadata.

Definition at line 741 of file metadata_vec.cpp.

                                                 {
     *this = MDin;
     std::random_device rd;
     auto g = std::mt19937(rd());
     std::shuffle(this->_rows.begin(), this->_rows.end(), g);
     this->_recalc_id_to_index();
 }

◆ read()

void MetaDataVec::read	(	const FileName &	inFile,
		const std::vector< MDLabel > *	desiredLabels = `nullptr`,
		bool	decomposeStack = `true`
	)

overridevirtual

Read data from file. Guess the blockname from the filename

inFilename="first@md1.doc" -> filename = md1.doc, blockname = first

Implements MetaData.

Definition at line 120 of file metadata_vec.cpp.

                                                                                                              {
     String blockName;
     FileName inFile;
 
     blockName = filename.getBlockName();
     inFile = filename.removeBlockName();
     String extFile = filename.getExtension();
     blockName = escapeForRegularExpressions(blockName);
 
     this->clear();
     this->setColumnFormat(true);
 
     if (extFile == "xml")
         this->readXML(_inFile, desiredLabels, blockName, decomposeStack);
     else if (extFile == "sqlite")
         throw NotImplemented("Reading from .sqlite file into MetaDataVec not implemented!");
     else
         this->readStar(filename, desiredLabels, blockName, decomposeStack);
 }

◆ readPlain()

void MetaDataVec::readPlain	(	const FileName &	inFile,
		const String &	labelsString,
		const String &	separator = `" "`
	)

Try to read a metadata from plain text with some columns. Labels for each columns should be provided in an string separated by spaces. Return false if couldn't read

Definition at line 716 of file metadata_vec.cpp.

                                                                                                        {
     // TODO
     throw NotImplemented("readPlain not implemented");
 }

◆ readXML()

void MetaDataVec::readXML	(	const FileName &	inFile,
		const std::vector< MDLabel > *	desiredLabels = `nullptr`,
		const String &	blockRegExp = `DEFAULT_BLOCK_NAME`,
		bool	decomposeStack = `true`
	)

Read metadata from xml file

Definition at line 712 of file metadata_vec.cpp.

                                                                                                                                           {
     REPORT_ERROR(ERR_NOT_IMPLEMENTED, "readXML not implemented yet");
 }

◆ removeDuplicates()

void MetaDataVec::removeDuplicates	(	MetaData &	MDin,
		MDLabel	label = `MDL_UNDEFINED`
	)

Remove duplicate entries for attribute in label

Definition at line 755 of file metadata_vec.cpp.

                                                                 {
     *this = MDin; // FIXME: maybe join?
     std::vector<MetaDataVecRow> new_rows;
     for (const auto& row : this->_rows) {
         if (!this->_contains(new_rows, row))
             new_rows.emplace_back(row);
     }
     this->_rows = new_rows;
 }

◆ removeLabel()

bool MetaDataVec::removeLabel ( const MDLabel label )

overridevirtual

Remove a label from the metadata. The data is still in the table. If you want to remove the data, make a copy of the MetaData.

Implements MetaData.

Definition at line 414 of file metadata_vec.cpp.

                                                  {
     if (this->_label_to_col[label] == -1)
         return false;
     int column = this->_label_to_col[label];
 
     for (auto& vecRow : this->_rows)
         if (static_cast<int>(vecRow.size()) > column)
             vecRow.erase(vecRow.begin()+column); // this is expensive
 
     // FIXME: test this properly
     this->_label_to_col[label] = -1;
     for (size_t i = 0; i < MDL_LAST_LABEL; i++) {
         if (this->_label_to_col[i] > column) {
             this->_label_to_col[i]--;
             this->_col_to_label[this->_label_to_col[i]] = MDLabel(i);
         }
     }
     this->_no_columns--;
     return true;
 }

◆ removeObject()

bool MetaDataVec::removeObject ( size_t id )

overridevirtual

Remove the object with this id. Returns true if the object was removed or false if the object did not exist

Implements MetaData.

Definition at line 475 of file metadata_vec.cpp.

                                         {
     int i = this->_rowIndex(id);
     if (i < 0)
         return false;
 
     this->_id_to_index.erase(id);
     this->_rows.erase(this->_rows.begin()+i);
 
     for (size_t j = i; j < this->_rows.size(); j++)
         this->_id_to_index[this->getRowId(j)]--;
 
     return true;
 }

◆ removeObjects() [1/3]

void MetaDataVec::removeObjects ( const std::vector< size_t > & toRemove )

overridevirtual

Removes the collection of objects of given vector id's NOTE: The iterator will point to the first object after any of these operations

Implements MetaData.

Definition at line 489 of file metadata_vec.cpp.

                                                                  {
     for (size_t id : toRemove)
         this->removeObject(id);
 }

◆ removeObjects() [2/3]

int MetaDataVec::removeObjects ( )

overridevirtual

Removes objects from metadata. return the number of deleted rows if not query, all objectes are removed Queries can be used in the same way as in the importObjects function

Implements MetaData.

Definition at line 494 of file metadata_vec.cpp.

                                {
     size_t count = this->size();
     this->clear();
     return count;
 }

◆ removeObjects() [3/3]

int MetaDataVec::removeObjects ( const MDQuery & )

overridevirtual

Removes objects from metadata. return the number of deleted rows if not query, all objectes are removed Queries can be used in the same way as in the importObjects function

Implements MetaData.

Definition at line 500 of file metadata_vec.cpp.

                                                    {
     // FIXME: move this to MetaData?
     std::vector<size_t> ids;
     this->findObjects(ids, query);
     this->removeObjects(ids);
     return true;
 }

◆ renameColumn() [1/2]

void MetaDataVec::renameColumn	(	MDLabel	oldLabel,
		MDLabel	newLabel
	)

overridevirtual

Rename column.

Implements MetaData.

Definition at line 914 of file metadata_vec.cpp.

                                                                  {
     assert(!this->containsLabel(newLabel));
     int labeloldi = this->_labelIndex(oldLabel);
     if (labeloldi < 0)
         throw ColumnDoesNotExist(oldLabel, getFilename());
 
     this->_label_to_col[newLabel] = labeloldi;
     this->_label_to_col[oldLabel] = -1;
     this->_col_to_label[labeloldi] = newLabel;
 
     for (auto& row : this->_rows) {
         if (labeloldi < static_cast<int>(row.size()))
             row[labeloldi].label = newLabel;
     }
 }

◆ renameColumn() [2/2]

void MetaDataVec::renameColumn	(	const std::vector< MDLabel > &	oldLabel,
		const std::vector< MDLabel > &	newLabel
	)

overridevirtual

Rename several columns. This is an expensive operations so if several columns need to be changed do it using this function instead one by one

Implements MetaData.

Definition at line 930 of file metadata_vec.cpp.

                                                                    {
     // TODO
     throw NotImplemented("renameColumn not implemented");
 }

◆ replace()

void MetaDataVec::replace	(	const MDLabel	label,
		const String &	oldStr,
		const String &	newStr
	)

Replace an string in some column(label). The type of the column should be string. This function is a shortcut of the more genereal function operate

Definition at line 736 of file metadata_vec.cpp.

                                                                                          {
     // TODO
     throw NotImplemented("replace not implemented");
 }

◆ selectPart()

void MetaDataVec::selectPart	(	const MetaData &	mdIn,
		size_t	startPosition,
		size_t	numberOfObjects,
		const MDLabel	sortLabel = `MDL_OBJID`
	)

overridevirtual

Select some part from Metadata. Select elements from input Metadata at some starting position if the numberOfObjects is -1, all objects will be returned from startPosition to the end.

Implements MetaData.

Definition at line 841 of file metadata_vec.cpp.

                                                       {
     this->sort(mdIn, sortLabel, true, numberOfObjects, startPosition);
 }

◆ selectRandomSubset()

void MetaDataVec::selectRandomSubset	(	const MetaData &	mdIn,
		size_t	numberOfObjects,
		const MDLabel	sortLabel = `MDL_OBJID`
	)

overridevirtual

Select random subset

Implements MetaData.

Definition at line 836 of file metadata_vec.cpp.

                                                                                                           {
     // TODO
     throw NotImplemented("selectRandomSubset not implemented");
 }

◆ setColumnValues() [1/2]

void MetaDataVec::setColumnValues ( const std::vector< MDObject > & valuesIn )

overridevirtual

Implements MetaData.

Definition at line 371 of file metadata_vec.cpp.

                                                                      {
     for (size_t i = 0; i < std::min(valuesIn.size(), this->_rows.size()); i++) {
         int labelIndex = this->_labelIndex(valuesIn[i].label);
         if (labelIndex < 0)
             this->addLabel(valuesIn[i].label);
         labelIndex = this->_labelIndex(valuesIn[i].label);
         if (labelIndex < 0)
             throw ColumnDoesNotExist(valuesIn[i].label, getFilename());
         this->_expand(this->_rows[i], valuesIn[i].label);
         this->_rows[i][labelIndex] = valuesIn[i];
     }
 }

◆ setColumnValues() [2/2]

template<class T >

void MetaDataVec::setColumnValues	(	const MDLabel	label,
		const std::vector< T > &	valuesIn
	)

inline

Definition at line 210 of file metadata_vec.h.

                                                                             {
         return MetaData::setColumnValues(label, valuesIn);
     }

◆ setRow()

bool MetaDataVec::setRow	(	const MDRow &	row,
		size_t	id
	)

Definition at line 384 of file metadata_vec.cpp.

                                                     {
     this->_setRow(row, this->_rowIndexSafe(id));
     return true;
 }

◆ setValue() [1/2]

bool MetaDataVec::setValue	(	const MDObject &	mdValueIn,
		size_t	id
	)

virtual

This functions are using MDObject for set real values there is an explicit function signature foreach type supported in Metadata. This is done for some type checking of Metadata labels and values

Implements MetaData.

Definition at line 282 of file metadata_vec.cpp.

                                                                {
     if (!this->containsLabel(mdValueIn.label))
         this->addLabel(mdValueIn.label);
 
     MetaDataVecRow& row = this->_rows[this->_rowIndexSafe(id)];
     this->_expand(row, mdValueIn.label);
 
     row[this->_labelIndex(mdValueIn.label)] = mdValueIn;
     return true;
 }

◆ setValue() [2/2]

template<class T >

bool MetaDataVec::setValue	(	const MDLabel	label,
		const T &	valueIn,
		size_t	id
	)

inline

Definition at line 173 of file metadata_vec.h.

                                                                     {
         return MetaData::setValue(label, valueIn, id);
     }

◆ setValueCol() [1/2]

bool MetaDataVec::setValueCol ( const MDObject & mdValueIn )

overridevirtual

Set the value of all objects in an specified column (both value and column are specified in mdValueIn)

Implements MetaData.

Definition at line 270 of file metadata_vec.cpp.

                                                        {
     const auto &label = mdValueIn.label;
     int labelIndex = this->_labelIndex(label);
     if (labelIndex < 0) {
         this->addLabel(label);
         labelIndex = this->_labelIndex(label);
         for (auto &r : _rows) _expand(r, labelIndex);
     }
     for (auto &r : _rows) r[labelIndex] = mdValueIn;
     return true;
 }

◆ setValueCol() [2/2]

template<class T >

bool MetaDataVec::setValueCol	(	const MDLabel	label,
		const T &	valueIn
	)

inline

Definition at line 160 of file metadata_vec.h.

                                                             {
         return MetaData::setValueCol(label, valueIn);
     }

◆ size()

size_t MetaDataVec::size ( void ) const

overridevirtual

Number of objects contained in the metadata.

Implements MetaData.

Definition at line 393 of file metadata_vec.cpp.

                                {
     return this->_rows.size();
 }

◆ sort() [1/2]

void MetaDataVec::sort	(	const MetaDataVec &	MDin,
		const MDLabel	sortLabel,
		bool	asc = `true`,
		int	limit = `-1`,
		int	offset = `0`
	)

Definition at line 791 of file metadata_vec.cpp.

                                                                                                         {
     *this = MDin;
 
     int label_index = this->_labelIndex(sortLabel);
     if (label_index > -1) {
         std::sort(this->_rows.begin(), this->_rows.end(),
             [label_index, asc](const MetaDataVecRow &a, const MetaDataVecRow &b) {
                 if (asc)
                     return a[label_index] < b[label_index];
                 return a[label_index] > b[label_index];
             }
         );
 
         this->_rows.erase(this->_rows.begin(), this->_rows.begin()+offset);
         if ((limit > 0) && (limit < this->_rows.size()))
             this->_rows.erase(this->_rows.begin()+limit, this->_rows.end());
 
         this->_recalc_id_to_index();
 
     }
 }

◆ sort() [2/2]

void MetaDataVec::sort	(	MetaDataVec &	MDin,
		const String &	sortLabel,
		bool	asc = `true`,
		int	limit = `-1`,
		int	offset = `0`
	)

Definition at line 813 of file metadata_vec.cpp.

                                                                                                   {
     // TODO
     throw NotImplemented("sort not implemented");
 }

◆ split()

void MetaDataVec::split	(	size_t	n,
		std::vector< MetaDataVec > &	results,
		const MDLabel	sortLabel = `MDL_OBJID`
	)		const

Split Metadata in several Metadatas. The Metadata will be divided in 'n' almost equally parts and the result will be a vector of Metadatas. The "calling" Metadata will no be modified.

// Divide the images metadata in 10 metadatas.
std::vector<MetaData> imagesGroups;
imageMD.split(10, imagesGroups);

Definition at line 818 of file metadata_vec.cpp.

                                                                                                     {
     if (parts > this->size())
         REPORT_ERROR(ERR_MD, "MetaDataDb::split: Couldn't split a metadata in more parts than its size");
 
     MetaDataVec sorted;
     sorted.sort(*this, sortLabel);
 
     results.clear();
     results.resize(parts);
     for (size_t i = 0; i < parts; i++) {
         MetaDataVec &md = results[i];
         size_t firsti, lasti;
         divide_equally(sorted.size(), parts, i, firsti, lasti);
         for (size_t j = firsti; j <= lasti; j++)
             md.addRow(sorted.getRowVec(sorted.getRowId(j)));
     }
 }

◆ write() [1/2]

void MetaDataVec::write	(	const FileName &	outFile,
		WriteModeMetaData	mode = `MD_OVERWRITE`
	)		const

virtual

Write metadata to disk. Guess blockname from filename

outFilename="first@md1.doc" -> filename = md1.doc, blockname = first

Implements MetaData.

Definition at line 140 of file metadata_vec.cpp.

                                                                              {
     String blockName;
     FileName extFile;
     FileName _outFile;
 
     blockName = outFile.getBlockName();
     if (blockName.empty())
         blockName = DEFAULT_BLOCK_NAME;
     _outFile = outFile.removeBlockName();
     extFile = outFile.getExtension();
 
     if (extFile == "xml") {
         writeXML(_outFile, blockName, mode);
     } else if (extFile == "sqlite") {
         throw NotImplemented("Writing to .sqlite file from MetaDataVec not implemented!");
     } else {
         writeStar(_outFile, blockName, mode);
     }
 }

◆ write() [2/2]

void MetaDataVec::write	(	std::ostream &	os,
		const String &	blockName = `""`,
		WriteModeMetaData	mode = `MD_OVERWRITE`
	)		const

virtual

Write metadata to out stream

Implements MetaData.

Definition at line 629 of file metadata_vec.cpp.

                                                                                              {
     if (mode==MD_OVERWRITE)
         os << FileNameVersion << " * "// << (isColumnFormat ? "column" : "row")
         << '\n' // write which type of format (column or row) and the path;
         << WordWrap(this->_comment, line_max);     // write md comment in the 2nd comment line of header
 
     // write data block
     String _szBlockName("data_");
     _szBlockName += blockName;
 
     if (this->isColumnFormat()) {
         // write md columns in 3rd comment line of the header
         os << _szBlockName << '\n';
         os << "loop_" << '\n';
         for (size_t i = 0; i < MDL_LAST_LABEL; i++)
             if ((i != MDL_STAR_COMMENT) && (i != MDL_OBJID) && (this->_label_to_col[i] > -1))
                 os << " _" << MDL::label2Str(static_cast<MDLabel>(i)) << '\n';
         _writeRows(os);
 
         //Put the activeObject to the first, if exists
     } else { // row format
         os << _szBlockName << '\n';
 
         // Print single object
         assert(this->_rows.size() == 1);
 
         for (size_t i = 0; i < MDL_LAST_LABEL; i++) {
             const MDLabel label = static_cast<MDLabel>(i);
             if ((label != MDL_STAR_COMMENT) && (label != MDL_OBJID) && (this->_label_to_col[i] > -1)) {
                 os << " _" << MDL::label2Str(label) << " ";
                 if (this->_labelIndex(label) < static_cast<int>(this->_rows[0].size()))
                     this->_getObject(this->_rows[0], label).toStream(os);
                 else
                     throw ColumnDoesNotExist(label, getFilename());
                 os << '\n';
             }
         }
     }
 }

◆ writeText()

void MetaDataVec::writeText	(	const FileName	fn,
		const std::vector< MDLabel > *	desiredLabels
	)		const

overridevirtual

Write metadata in text file as plain data without header.

Implements MetaData.

Definition at line 165 of file metadata_vec.cpp.

                                                                                              {
     // FIXME: implement
     throw NotImplemented("writeText not immplemented");
 }

◆ writeXML()

void MetaDataVec::writeXML	(	const FileName	fn,
		const FileName	blockname,
		WriteModeMetaData	mode
	)		const

overridevirtual

Export medatada to xml file.

Implements MetaData.

Definition at line 160 of file metadata_vec.cpp.

                                                                                                     {
     // FIXME: implement
     throw NotImplemented("writeXML not implemented");
 }

Member Data Documentation

◆ _col_to_label

std::vector<MDLabel> MetaDataVec::_col_to_label

protected

Definition at line 50 of file metadata_vec.h.

◆ _id_to_index

std::unordered_map<size_t, size_t> MetaDataVec::_id_to_index

protected

Definition at line 52 of file metadata_vec.h.

◆ _label_to_col

std::array<int, MDL_LAST_LABEL> MetaDataVec::_label_to_col

protected

Definition at line 49 of file metadata_vec.h.

◆ _next_id

size_t MetaDataVec::_next_id = 1

protected

Definition at line 53 of file metadata_vec.h.

◆ _no_columns

size_t MetaDataVec::_no_columns = 0

protected

Definition at line 51 of file metadata_vec.h.

◆ _rows

std::vector<MetaDataVecRow> MetaDataVec::_rows

protected

Definition at line 48 of file metadata_vec.h.

The documentation for this class was generated from the following files:

xmippCore/core/metadata_vec.h
xmippCore/core/metadata_vec.cpp

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Notes

Constructor & Destructor Documentation

◆ MetaDataVec() [1/6]

◆ MetaDataVec() [2/6]

◆ MetaDataVec() [3/6]

◆ MetaDataVec() [4/6]

◆ MetaDataVec() [5/6]

◆ MetaDataVec() [6/6]

◆ ~MetaDataVec()

Member Function Documentation

◆ _clear()

◆ _contains()

◆ _expand() [1/2]

◆ _expand() [2/2]

◆ _getObject() [1/4]

◆ _getObject() [2/4]

◆ _getObject() [3/4]

◆ _getObject() [4/4]

◆ _labelIndex()

◆ _match()

◆ _parseObjects()

◆ _recalc_id_to_index()

◆ _rowIndex()

◆ _rowIndexSafe()

◆ _rowsEq()

◆ _setRow()

◆ _writeRows()

◆ addLabel()

◆ addObject()

◆ addPlain()

◆ addRow()

◆ addRows()

◆ begin() [1/2]

◆ begin() [2/2]

◆ clear()

◆ containsLabel()

◆ containsObject() [1/3]

◆ containsObject() [2/3]

◆ containsObject() [3/3]

◆ copyColumn()

◆ copyColumnTo()

◆ countObjects()

◆ end() [1/2]

◆ end() [2/2]

◆ fillConstant()

◆ fillLinear()

◆ fillRandom()

◆ findObjects() [1/2]

◆ findObjects() [2/2]

◆ firstObject()

◆ firstRowId()

◆ getActiveLabels()

◆ getColumnMax()

◆ getColumnMin()

◆ getColumnValues() [1/3]

◆ getColumnValues() [2/3]

◆ getColumnValues() [3/3]

◆ getMaxStringLength()

◆ getObjectsForActiveLabels()

◆ getRow() [1/3]

◆ getRow() [2/3]

◆ getRow() [3/3]

◆ getRowId() [1/2]

◆ getRowId() [2/2]

◆ getRowValues()

◆ getRowVec() [1/2]

◆ getRowVec() [2/2]

◆ getValue() [1/6]

◆ getValue() [2/6]

◆ getValue() [3/6]

◆ getValue() [4/6]

◆ getValue() [5/6]

◆ getValue() [6/6]

◆ id_begin() [1/2]