03 ----- COMPUTREE PLATFORM ----- » A - Computree Platform Core » ComputreeDevTools

    readers/headers/ct_xybheader.h \

    readers/headers/ct_larchiheader.h

    readers/headers/ct_xybheader.cpp \

    readers/headers/ct_larchiheader.cpp

    _LarchiHeader = new CT_LARCHIHEADER();

            QString err;

            _LarchiHeader = (CT_LARCHIHEADER*)protectedReadHeader(stream,err);

            if(_LarchiHeader!=NULL) {

            QString err;

            _LarchiHeader = (CT_LARCHIHEADER*)protectedReadHeader(stream,err);

            if(_LarchiHeader!=NULL) {

                Eigen::Vector3d min = _LarchiHeader->get_Min();

                Eigen::Vector3d res = _LarchiHeader->get_Res();

                EigenVector3ui64 dim = _LarchiHeader->get_Dim();

                int nMat = _LarchiHeader->get_nMat();

                QMap<QString, int>  matNames = _LarchiHeader->get_matNames();

CT_FileHeader* CT_Reader_LArchitect_Grid::protectedReadHeader(QTextStream &stream, QString &error) const

    Q_UNUSED(error)

    CT_LARCHIHEADER *header = new CT_LARCHIHEADER();

    header->setFile(filepath());

        return header;

    header->set_xMin(values.at(0).toDouble(&ok[0]));

    header->set_yMin(values.at(1).toDouble(&ok[1]));

    header->set_zMin(values.at(2).toDouble(&ok[2]));

    header->set_xMax(values.at(3).toDouble(&ok[3]));

    header->set_yMax(values.at(4).toDouble(&ok[4]));

    header->set_zMax(values.at(5).toDouble(&ok[5]));

    header->set_Res(values.at(0).toDouble(&ok[0]),0);

    header->set_Res(values.at(1).toDouble(&ok[1]),1);

    header->set_Res(values.at(2).toDouble(&ok[2]),2);

    if ((header->get_Res(0) != header->get_Res(1)) || (header->get_Res(0) != header->get_Res(2)))

    header->set_xDim(values.at(0).toUInt(&ok[0]));

    header->set_yDim(values.at(1).toUInt(&ok[1]));

    header->set_zDim(values.at(2).toUInt(&ok[2]));

        header->set_nMat(values.at(0).toInt(&ok[0]));

        if (!ok[0] || (header->get_nMat() <= 0) || (size < (2*header->get_nMat()+1)))

        for (int i = 0 ; i < header->get_nMat(); ++i)

            header->set_matNames(matName.toUpper(), matid);

    return header;

#include "headers/ct_larchiheader.h"

    CT_LARCHIHEADER* getHeader(){return _LarchiHeader;}

    CT_LARCHIHEADER* _LarchiHeader;

    CT_FileHeader*  protectedReadHeader(QTextStream &stream, QString &error) const;

#include "ct_larchiheader.h"

CT_DEFAULT_IA_INIT(CT_LARCHIHEADER)

CT_LARCHIHEADER::CT_LARCHIHEADER() : CT_FileHeader()

{

    _min[0] = 0.0;

    _min[1] = 0.0;

    _min[2] = 0.0;

    _max[0] = 0.0;

    _max[1] = 0.0;

    _max[2] = 0.0;

    _res[0]=0.0;

    _res[1]=0.0;

    _res[2]=0.0;

    _dim[0]=0;

    _dim[1]=0;

    _dim[2]=0;

    _nMat = 0;

    _matNames["none"] = 0;

}

CT_LARCHIHEADER::CT_LARCHIHEADER(const CT_OutAbstractSingularItemModel *model, const CT_AbstractResult *result) : CT_FileHeader(model, result)

{

CT_LARCHIHEADER();

}

CT_LARCHIHEADER::CT_LARCHIHEADER(const QString &modelName, const CT_AbstractResult *result) : CT_FileHeader(modelName, result)

{

CT_LARCHIHEADER();

}

CT_AbstractItemDrawable *CT_LARCHIHEADER::copy(const CT_OutAbstractItemModel *model, const CT_AbstractResult *result, CT_ResultCopyModeList copyModeList)

{

    Q_UNUSED(copyModeList);

    CT_LARCHIHEADER *cpy =  new CT_LARCHIHEADER((CT_OutAbstractSingularItemModel*) model, result);

    cpy->setFile(_fileInfo.filePath());

    cpy->set_Min(_min);

    cpy->set_Max(_max);

    cpy->set_Res(_res);

    cpy->set_Dim(_dim);

    cpy->set_nMat(_nMat);

    cpy->set_matNames(_matNames);

    return cpy;

}

#ifndef CT_LARCHIHEADER_H

#define CT_LARCHIHEADER_H

#include "ctlibio/ctlibio_global.h"

#include "ct_itemdrawable/ct_fileheader.h"

class CTLIBIO_EXPORT CT_LARCHIHEADER : public CT_FileHeader

{

    Q_OBJECT

    CT_TYPE_IMPL_MACRO(CT_LARCHIHEADER, CT_FileHeader, XYB Header)

protected :

        typedef Eigen::Matrix<size_t, 3, 1> EigenVector3ui64;

public:

        CT_LARCHIHEADER();

        CT_LARCHIHEADER(const CT_OutAbstractSingularItemModel *model,

                         const CT_AbstractResult *result);

        CT_LARCHIHEADER(const QString &modelName,

                         const CT_AbstractResult *result);

        virtual bool hasBoundingBox() const {return false;}

        virtual CT_AbstractItemDrawable* copy(const CT_OutAbstractItemModel *model, const CT_AbstractResult *result, CT_ResultCopyModeList copyModeList);

        // Global getters

        inline Eigen::Vector3d get_Min() const {return _min;}

        inline Eigen::Vector3d get_Max() const {return _max;}

        inline Eigen::Vector3d get_Res() const {return _res;}

        inline EigenVector3ui64 get_Dim() const {return _dim;}

        inline int get_nMat() const {return _nMat;}

        inline QMap<QString, int> get_matNames() const {return _matNames;}

        //  Getters

        inline double get_xMin() const {return _min[0];}

        inline double get_yMin() const {return _min[1];}

        inline double get_zMin() const {return _min[2];}

        inline double get_xMax() const {return _max[0];}

        inline double get_yMax() const {return _max[1];}

        inline double get_zMax() const {return _max[2];}

        inline double get_Res(int i) const {return _res[i];}

        inline size_t get_xDim() const {return _dim[0];}

        inline size_t get_yDim() const {return _dim[1];}

        inline size_t get_zDim() const {return _dim[2];}

        // Global setters

        inline void set_Min(Eigen::Vector3d min){_min = min;}

        inline void set_Max(Eigen::Vector3d max){_max = max;}

        inline void set_Res(Eigen::Vector3d res){_res = res;}

        inline void set_Dim(EigenVector3ui64 dim){_dim = dim;}

        //  Setters

        inline void set_xMin(double x) {_min[0]=x;}

        inline void set_yMin(double y) {_min[1]=y;}

        inline void set_zMin(double z) {_min[2]=z;}

        inline void set_xMax(double x) {_max[0]=x;}

        inline void set_yMax(double y) {_max[1]=y;}

        inline void set_zMax(double z) {_max[2]=z;}

        inline void set_Res(double res, short n) {_res[n]=res;}

        inline void set_xDim(size_t xDim) {_dim[0]=xDim;}

        inline void set_yDim(size_t yDim) {_dim[1]=yDim;}

        inline void set_zDim(size_t zDim) {_dim[2]=zDim;}

        inline void set_nMat(int nMat){_nMat = nMat;}

        inline void set_matNames(QMap<QString, int> matNames){_matNames = matNames ;}

        inline void set_matNames(QString key, int value){_matNames.insert(key,value);}

    private:

        Eigen::Vector3d _min;

        Eigen::Vector3d _max;

        Eigen::Vector3d _res;

        EigenVector3ui64 _dim;

        int _nMat;

        QMap<QString, int>  _matNames;

        CT_DEFAULT_IA_BEGIN(CT_LARCHIHEADER)

        CT_DEFAULT_IA_V3(CT_LARCHIHEADER, CT_AbstractCategory::staticInitDataValue(), &CT_LARCHIHEADER::get_Min, QObject::tr("Grid minimum coordinates"), "Minxyz")

        CT_DEFAULT_IA_V3(CT_LARCHIHEADER, CT_AbstractCategory::staticInitDataValue(), &CT_LARCHIHEADER::get_Max, QObject::tr("Grid maximum coordinates"), "Maxxyz")

        CT_DEFAULT_IA_V3(CT_LARCHIHEADER, CT_AbstractCategory::staticInitDataValue(), &CT_LARCHIHEADER::get_Res, QObject::tr("Grid resolution"), "Gres")

        CT_DEFAULT_IA_V3(CT_LARCHIHEADER, CT_AbstractCategory::staticInitDataValue(), &CT_LARCHIHEADER::get_Dim, QObject::tr("Grid dimension"), "Gdim")

        CT_DEFAULT_IA_V3(CT_LARCHIHEADER, CT_AbstractCategory::staticInitDataValue(), &CT_LARCHIHEADER::get_nMat, QObject::tr("Number of matrix"), "Nmat")

        //CT_DEFAULT_IA_V3(CT_LARCHIHEADER, CT_AbstractCategory::staticInitDataValue(), &CT_LARCHIHEADER::get_matNames, QObject::tr("Matrix names"), "Mnames") // To-fix : QMap toString() error in "numerictostringconversion.h"

        CT_DEFAULT_IA_END(CT_LARCHIHEADER)

};

#endif // CT_LARCHIHEADER_H