metadata_vec.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:     Jan Horacek (xhorace4@fi.muni.cz)
 *
 * Institute of Computer Science MUNI
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307  USA
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'xmipp@cnb.csic.es'
 ***************************************************************************/

#ifndef VEC_METADATA_H
#define VEC_METADATA_H

#include <memory>
#include <exception>
#include <unordered_map>
#include "memory.h"
#include "metadata_base.h"
#include "metadata_base_it.h"
#include "utils/memory_utils.h"

using MetaDataVecRow = std::vector<MDObject>;


class MetaDataVec: public MetaData {
protected:
    std::vector<MetaDataVecRow> _rows;
    std::array<int, MDL_LAST_LABEL> _label_to_col; // -1 = no mapping
    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;

    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;

    // Expand row to fit label in.
    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;

public:
    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;
    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;

    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) {
        return MetaData::setValueCol(label, valueIn);
    }

    bool setValue(const MDObject &mdValueIn, size_t id);

    template<class T>
    bool setValue(const MDLabel label, const T &valueIn, size_t id) {
        return MetaData::setValue(label, valueIn, 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 {
        return MetaData::getValue(label, valueOut, id);
    }

    template<class T>
    T getValue(const MDLabel label, size_t id) {
        return this->getValue(label, id).getValue2(T());
    }

    template<class T>
    const T getValue(const MDLabel label, size_t id) const {
        return this->getValue(label, id).getValue2(T());
    }

    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); // FIXME: deprecated, use getRow above

    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) {
        return MetaData::setColumnValues(label, valuesIn);
    }

    bool setRow(const MDRow &row, size_t id);

    template<class T>
    std::vector<T> getColumnValues(const MDLabel label) const {
        return MetaData::getColumnValues<T>(label);
    }

    template<class T>
    void getColumnValues(const MDLabel label, std::vector<T> &valuesOut) const {
        return MetaData::getColumnValues(label, valuesOut);
    }

    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;

    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);

    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;
    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);

    /*
    * Sort a Metadata by a label.
    * Sort the content of MDin comparing
    * the label supplied, the result will
    * be in the "calling" MetaData.
    * Limit fixes the maximum number of returned rows
    * Offset skips the first N rows
    */
    void sort(const MetaDataVec &MDin,
              const MDLabel sortLabel,
              bool asc=true,
              int limit=-1,
              int offset=0);


    /*
    * Sort a Metadata by a label.
    * Sort the content of MDin comparing
    * the label supplied, the result will
    * be in the "calling" MetaData.
    * If the input label is a vector field,
    * you may supply label:col, to sort by that column,
    * e.g., NMADisplacements:0
    * Limit fixes the maximum number of returned rows
    * Offset skips the first N rows
    *
    */
    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);

    template <bool IsConst>
    struct MDVecRowIterator : public MDBaseRowIterator<IsConst> {
    private:
        typename TypeHelpers::choose<IsConst, const MetaDataVec&, MetaDataVec&>::type _mdv;
        size_t _i;
        using RowType = typename TypeHelpers::choose<IsConst, const MDRowVec, MDRowVec>::type;
        std::unique_ptr<RowType> _row;

    public:
        MDVecRowIterator(typename TypeHelpers::choose<IsConst, const MetaDataVec&, MetaDataVec&>::type &mdv, size_t i)
            : _mdv(mdv), _i(i) {
                if (_i < _mdv.size())
                    _row.reset(new RowType(mdv._rows.at(i), i, mdv._label_to_col, mdv._col_to_label, mdv._no_columns));
                else
                    _row = nullptr;
            }

        std::unique_ptr<MDBaseRowIterator<IsConst>> clone() override {
            return memoryUtils::make_unique<MDVecRowIterator<IsConst>>(_mdv, _i);
        }

        void increment() override {
            _i++;
            if (_i < _mdv.size())
                _row.reset(new RowType(_mdv._rows.at(_i), _i, _mdv._label_to_col, _mdv._col_to_label, _mdv._no_columns));
            else
                _row = nullptr;
        }

        bool operator==(const MDBaseRowIterator<IsConst>& other) const override {
            const MDVecRowIterator* vri = dynamic_cast<const MDVecRowIterator<IsConst>*>(&other);
            if (vri != nullptr)
                return _i == vri->_i;
            return false;
        }

        typename TypeHelpers::choose<IsConst, const MDRowVec&, MDRowVec&>::type operator*() override { return *_row; }
    };

    iterator begin() override {
        return {memoryUtils::make_unique<MDVecRowIterator<false>>(*this, 0)};
    }
    iterator end() override {
        return {memoryUtils::make_unique<MDVecRowIterator<false>>(*this, this->size())};
    }

    const_iterator begin() const override {
        return {memoryUtils::make_unique<MDVecRowIterator<true>>(*this, 0)};
    }
    const_iterator end() const override {
        return {memoryUtils::make_unique<MDVecRowIterator<true>>(*this, this->size())};
    }


    template <bool IsConst>
    struct MDVecIdIterator : public MDBaseIdIterator<IsConst> {
    private:
        const MetaDataVec& _mdv;
        size_t _i;

    public:
        MDVecIdIterator(const MetaDataVec& mdv, size_t i)
            : _mdv(mdv), _i(i) {}

        bool operator==(const MDBaseIdIterator<IsConst>& other) const override {
            const MDVecIdIterator<IsConst>* dri = dynamic_cast<const MDVecIdIterator<IsConst>*>(&other);
            if (dri != nullptr)
                return this->_i == dri->_i;
            return false;
        }

        size_t operator*() override { return _mdv.getRowId(_i); }

        void increment() override { this->_i++; }

        std::unique_ptr<MDBaseIdIterator<IsConst>> clone() override {
            return memoryUtils::make_unique<MDVecIdIterator<IsConst>>(_mdv, _i);
        }
    };

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

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

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

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

    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;
};//class MetaDataVec

std::ostream& operator<<(std::ostream& o, const MetaDataVec& md);

#endif