datacontainer.h

/******************************************************************************
 *   Copyright (C) 2006-2024 by the GIMLi development team                    *
 *   Carsten Rücker carsten@resistivity.net                                   *
 *                                                                            *
 *   Licensed under the Apache License, Version 2.0 (the "License");          *
 *   you may not use this file except in compliance with the License.         *
 *   You may obtain a copy of the License at                                  *
 *                                                                            *
 *       http://www.apache.org/licenses/LICENSE-2.0                           *
 *                                                                            *
 *   Unless required by applicable law or agreed to in writing, software      *
 *   distributed under the License is distributed on an "AS IS" BASIS,        *
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *   See the License for the specific language governing permissions and      *
 *   limitations under the License.                                           *
 *                                                                            *
 ******************************************************************************/
 
#ifndef _GIMLI_DATACONTAINER__H
#define _GIMLI_DATACONTAINER__H
 
#include "gimli.h"
#include "baseentity.h"
#include "pos.h"
#include "vector.h"
 
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <fstream>
 
namespace GIMLI{


 
class DLLEXPORT DataContainer{
public:
    DataContainer();
    
    DataContainer(const std::string & fileName,
                  bool sensorIndicesFromOne=true,
                  bool removeInvalid=true);

    DataContainer(const std::string & fileName,
                  const std::string & sensorTokens,
                  bool sensorIndicesFromOne=true,
                  bool removeInvalid=true);

    DataContainer(const DataContainer & data);

    virtual ~DataContainer();

    DataContainer & operator=(const DataContainer & data);

    inline const RVector & operator() (const std::string & token) const { return get(token); }

    inline RVector & operator() (const std::string & token) { return *ref(token); }

    inline const RVector & operator[] (const std::string & token) const { return get(token); }

    inline RVector & operator[] (const std::string & token) { return *ref(token); }
 

    void initDefaults();

    virtual void init();

    virtual void initTokenTranslator();

    bool haveTranslationForAlias(const std::string & alias) const;

    std::string translateAlias(const std::string & alias) const;

    virtual void clear();

    inline Index size() const { return dataMap_.find("valid")->second.size(); }

    inline const std::map< std::string, RVector > & dataMap() const { return dataMap_; }

    inline const std::map< std::string, std::string > & dataDescription() const { return dataDescription_; }

    void add(const DataContainer & data, double snap=1e-3);
 
    // START Sensor related section
    void setSensorPositions(const RVector & sensors);

    void setSensorPositions(const PosVector & sensors);
 
    // will be remove on 1.1
#define GIMLI_USE_POSVECTOR
    inline const PosVector & sensorPositions() const { return sensorPoints_; }

    void setSensorPosition(Index i, const RVector3 & pos);
 
//         /*! Return a single sensor position. */
//     inline const RVector3 & sensorPosition(Index i) const {
//         return sensorPoints_[i]; }

    inline const RVector3 & sensorPosition(double i) const {
        return sensorPoints_[(Index)i]; }
    inline const RVector3 & sensorPosition(double i) const  {…}

    inline const R3Vector & sensors() const { return sensorPositions(); }

    inline const RVector3 & sensor(Index i) const {
        ASSERT_RANGE(i, 0, this->sensorCount())
        return sensorPoints_[i];
    }
    inline const RVector3 & sensor(Index i) const  {…}

    inline void setSensor(Index i, const RVector3 & pos) {
        this->setSensorPosition(i, pos);
    }
    inline void setSensor(Index i, const RVector3 & pos) {…}

    SIndex createSensor(const RVector3 & pos, double tolerance=1e-3);

    Index sensorCount() const { return sensorPoints_.size(); }

    void registerSensorIndex(const std::string & token);

    bool isSensorIndex(const std::string & token) const ;

    const std::set< std::string > sensorIdx() const { return dataSensorIdx_; }

    void setSensorIndexOnFileFromOne(bool indexFromOne) { sensorIndexOnFileFromOne_ = indexFromOne; }

    bool sensorIndexOnFileFromOne() const { return sensorIndexOnFileFromOne_ ;}

    IndexArray findSensorIndex(const RVector & d) const;
 

    void markInvalidSensorIndices();

    void removeSensorIdx(Index idx);

    void removeSensorIdx(const IndexArray & idx);

    inline const std::string & formatStringSensors() const { return inputFormatStringSensors_; }

    void sortSensorsX(bool incX=true, bool incY=true, bool incZ=true);

    void translate(const RVector3 & trans);

    void scale(const RVector3 & scale);
 
    IndexArray dataIndex();

    IndexArray sortSensorsIndex();
 
    // END Sensor related section

    inline void setAdditionalPoints(const PosVector & a ){ topoPoints_ = a; }
    
    inline const PosVector & additionalPoints() const { return topoPoints_; }

    inline void setAdditionalPoint(Index i, const Pos & p) { 
        ASSERT_SIZE(topoPoints_, i)
        topoPoints_[i] = p; 
    }
    inline void setAdditionalPoint(Index i, const Pos & p) {…}

    inline void addAdditionalPoint(const Pos & p) { 
        topoPoints_.push_back(p); 
    }
    inline void addAdditionalPoint(const Pos & p) {…}

    inline bool allNonZero(const std::string & token) const {
        if (exists(token)) return (min(abs(dataMap_.find(token)->second)) > TOLERANCE);
        return false;
    }
    inline bool allNonZero(const std::string & token) const  {…}

    inline bool haveData(const std::string & token) const {
        if (exists(token) && dataMap_.find(token)->second.size() > 0) 
            return !zero(dataMap_.find(token)->second);
        return false;
    }
    inline bool haveData(const std::string & token) const  {…}

    inline bool exists(const std::string & token) const {
        return dataMap_.count(token) != 0; }
    inline bool exists(const std::string & token) const  {…}

    inline const std::map< std::string, std::string > & tokenTranslator() const { return tT_; }

    virtual int load(const std::string & fileName,
                     bool sensorIndicesFromOne=true,
                     bool removeInvalid=true);

    virtual int save(const std::string & fileName,
                     const std::string & fmtData,
                     const std::string & fmtSensor,
                     bool noFilter=false,
                     bool verbose=false) const;

    inline int save(const std::string & fileName,
                    const std::string & formatData="all",
                    bool noFilter=false,
                    bool verbose=false) const {
        return save(fileName, formatData, "x y z", noFilter, verbose); }
    inline int save(const std::string & fileName, {…}
 
    virtual int write(std::fstream & os,
                     const std::string & fmtData,
                     const std::string & fmtSensor,
                     bool noFilter=false,
                     bool verbose=false) const;
    void showInfos() const ;

    void resize(Index size);

    std::string tokenList(bool withAnnotation=true) const;

    void add(const std::string & token, const RVector & data, const std::string & description = "");

    void add(const std::string & token){ add(token, RVector(this->size(), 0.0)); }

    void set(const std::string & token, const RVector & data);

    const RVector & get(const std::string & token) const ;

    const IndexArray id(const std::string & token) const ;

    RVector * ref(const std::string & token);

    void setDataDescription(const std::string & token, const std::string & description);

    std::string dataDescription(const std::string & token) const;

    virtual void remove(const IndexArray & idx);

    inline void remove(const BVector & bvec){ remove(find(bvec)); }

    inline void markValid(const BVector & bvec, bool valid=true){
        dataMap_["valid"].setVal(valid, find(bvec));
    }
    inline void markValid(const BVector & bvec, bool valid=true) {…}

    inline void markValid(const IndexArray & idx, bool valid=true){
        dataMap_["valid"].setVal(valid, idx);
    }
    inline void markValid(const IndexArray & idx, bool valid=true) {…}

    inline void markValid(Index idx, bool valid=true){
        dataMap_["valid" ].setVal(valid, idx);
    }
    inline void markValid(Index idx, bool valid=true) {…}

    inline void markInvalid(const BVector & bvec){ markValid(find(bvec), false); }

    inline void markInvalid(const IndexArray & idx){ markValid(idx, false); }

    inline void markInvalid(Index idx){ markValid(idx, false); }

    void checkDataValidity(bool remove=true);

    virtual void checkDataValidityLocal(){}

    void removeInvalid();

    void removeUnusedSensors(bool verbose=false);

    inline void setInputFormatString(const std::string & inputFormatString){
        inputFormatString_=inputFormatString; }
    inline void setInputFormatString(const std::string & inputFormatString) {…}

    inline const std::string & inputFormatString() const {
        return inputFormatString_; }
    inline const std::string & inputFormatString() const  {…}

    Index hash() const;
 
protected:
    virtual void copy_(const DataContainer & data);
 
    std::string inputFormatStringSensors_;
 
    std::string inputFormatString_;


    std::map< std::string, RVector > dataMap_;


    PosVector sensorPoints_;


    std::set< std::string > dataSensorIdx_;


    std::map< std::string, std::string > dataDescription_;

    PosVector topoPoints_;

    std::map< std::string, std::string > tT_;

    bool sensorIndexOnFileFromOne_;
 
 
}; // class DataContainer
class DLLEXPORT DataContainer {…};
 
} // namespace GIMLI
 
#endif // DATACONTAINER__H