TYMaillage.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#ifndef __TY_Maillage__
#define __TY_Maillage__


#include "Tympan/core/defines.h"
#include "Tympan/models/business/geometry/TYGeometryNode.h"
#include "Tympan/models/business/TYPointCalcul.h"
#include "Tympan/models/business/TYPalette.h"
#include "Tympan/models/business/TYPanel.h"

class TYCalcul;

static const double TY_MAILLAGE_DEFAULT_DENSITE = 0.1; // 1 point tous les 10m

struct MPoint
{
    OVector3D  pt;
    TYPalette::values_type scalar;
};

struct MTriangle
{
    MPoint pts[3];
};

class TYMaillage: public TYElement
{
    OPROTODECL(TYMaillage)
    TY_EXTENSION_DECL_ONLY(TYMaillage)

    // Methodes
public:
    TYMaillage();

    TYMaillage(const TYMaillage& other);

    virtual ~TYMaillage();

    TYMaillage& operator=(const TYMaillage& other);

    bool operator==(const TYMaillage& other) const;

    bool operator!=(const TYMaillage& other) const;

    virtual bool deepCopy(const TYElement* pOther, bool copyId = true, bool pUseCopyTag = false);

    virtual std::string toString() const;

    virtual DOM_Element toXML(DOM_Element& domElement);
    virtual int fromXML(DOM_Element domElement);

     void exportCSV(const std::string& fileName); 

    virtual void clearResult();

    virtual void updateFromCalcul(LPTYCalcul pCalcul);

    TYTabLPPointCalcul& getPtsCalcul() { return _ptsCalcul; }

    const TYTabLPPointCalcul& getPtsCalcul() const { return _ptsCalcul; }

    void setPtsCalcul(const TYTabLPPointCalcul& list) { _ptsCalcul = list; setIsGeometryModified(true); }

    bool addPointCalcul(LPTYPointCalcul pPtCalcul);

    bool remPointCalcul(const LPTYPointCalcul pPtCalcul);

    bool remPointCalcul(QString idPtCalcul);

    void remAllPointCalcul();

    void setHauteur(double hauteur) { _hauteur = hauteur; setIsGeometryModified(true); }

    double getHauteur() const { return _hauteur; }

    void setComputeAlti(bool state) { _computeAlti = state; setIsGeometryModified(true); }

    bool getComputeAlti() const { return _computeAlti; }

    void setDataType(int type) { _dataType = type; setIsGeometryModified(true); }
    int getDataType() { return _dataType; }

    void setDataFreq(float freq) { _dataFreq = freq; setIsGeometryModified(true); }
    float getDataFreq() { return _dataFreq; }

    void setPalette(LPTYPalette pPalette) { _pPalette = pPalette; }
    LPTYPalette getPalette() { return _pPalette; }

    void setPanel(LPTYPanel pPanel) { _pPanel = pPanel; }

    LPTYPanel getPanel() { return _pPanel; }

    void make(const TYTabPoint& points);

    enum MaillageDataType
    {
        ValGlobalDBA,
        ValGlobalDBLin,
        DataFreq
    };

    enum MaillageState
    {
        Actif,
        Inactif
    };

    static bool checkSimilar(const TYMaillage* const pMaillage1, const TYMaillage* const pMaillage2);

    void computeMesh(std::vector<MTriangle> &mesh) const;

    MTriangle computeTriangle(TYPointCalcul& pt1, TYPointCalcul& pt2, TYPointCalcul& pt3) const;

    double getSpectrumValue(TYPointCalcul& pt) const;

    void computeIsoCurve(std::vector<MTriangle> &mesh, std::vector<MPoint> &isoCurve) const;

    bool computeIsoPoint(const OHPlane3D& plane, const MPoint& pt1, const MPoint& pt2, MPoint& mp) const;

    virtual int getIndexPtCalcul(int x, int y) const {return 0;}

    virtual void getDimensions(int& x, int& y) const {}

    virtual void setEtat(const TYUUID& id_calc, bool etat);
    virtual bool etat();
    virtual bool etat(const TYUUID& id_calc);
    virtual bool etat(const TYCalcul* pCalc);

    void copyEtats(TYMaillage* pOther);

    void duplicateEtat(const TYUUID& idCalculRef, const TYUUID& idCalculNew);

    bool remEtat(TYCalcul* pCalcul);

    // Membres
protected:
    TYTabLPPointCalcul _ptsCalcul;

    TYMapIdBool _tabEtats;

    double _hauteur;

    bool _computeAlti;

    int _dataType;

    float _dataFreq;

    LPTYPalette _pPalette;

    LPTYPanel _pPanel;
};


typedef TYGeometryNode TYMaillageGeoNode;
typedef SmartPtr<TYMaillageGeoNode> LPTYMaillageGeoNode;
typedef std::vector<LPTYMaillageGeoNode> TYTabMaillageGeoNode;
typedef std::vector<LPTYMaillage> TYTabLPMaillage;


#endif // __TY_Maillage__