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__