TYTopographie.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_TOPOGRAPHIE__
#define __TY_TOPOGRAPHIE__
 
#include <memory>
 
#include "Tympan/models/common/3d.h"
#include "Tympan/models/business/topography/TYPlanEau.h"
#include "Tympan/models/business/topography/TYCoursEau.h"
#include "Tympan/models/business/topography/TYAltimetrie.h"
#include "Tympan/models/business/material/TYSol.h"
 
typedef struct
{
    OSegment3D _segment;
    TYTerrain* _terrain;
} TYStructSegPtrTer;
 
typedef std::vector<TYStructSegPtrTer> TYTabStructSegPtrTer;
 
typedef enum
{
    TYTERRAIN,
    TYPLANEAU
} typeTerrain;
typedef struct
{
    LPTYElement pElement; // Pointeur sur l'element
    OPoint3D* pTabPoints; // Pointeur sur un tableau de points
    OBox box;             // Boite englobante de l'ensemble des points
    OVector3D normale;    // Normale au plan du terrain;
    typeTerrain ter;      // Type de terrain
    short nbPts;          // Nombre de points dans le tableau
} TYStructElemPts;
 
class TYTopographie : public TYElement
{
    OPROTODECL(TYTopographie)
    TY_EXTENSION_DECL_ONLY(TYTopographie)
    TY_EXT_GRAPHIC_DECL_ONLY(TYTopographie)
 
    // Methodes
 
public:
    TYTopographie();
    TYTopographie(const TYTopographie& other);
    virtual ~TYTopographie();
 
    TYTopographie& operator=(const TYTopographie& other);
    bool operator==(const TYTopographie& other) const;
    bool operator!=(const TYTopographie& 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);
 
    virtual void setIsGeometryModified(bool isModified);
 
 
 
    virtual void updateCurrentCalcul(TYListID& listID, bool recursif = true);
 
    virtual void reparent();
 
    void purge();
 
    void concatTopo(const TYTopographie* pTopo, bool emprise = true);
 
    TYTabPlanEauGeoNode& getListPlanEau()
    {
        return _listPlanEau;
    }
    const TYTabPlanEauGeoNode& getListPlanEau() const
    {
        return _listPlanEau;
    }
    void setListPlanEau(const TYTabPlanEauGeoNode& list)
    {
        _listPlanEau = list;
        setIsGeometryModified(true);
    }
    bool addPlanEau(LPTYPlanEauGeoNode pPlanEauGeoNode);
    bool addPlanEau(LPTYPlanEau pPlanEau);
    bool remPlanEau(const LPTYPlanEauGeoNode pPlanEauGeoNode);
    bool remPlanEau(const LPTYPlanEau pPlanEau);
    bool remPlanEau(QString idPlanEau);
    void remAllPlanEau();
    LPTYPlanEau getPlanEau(int index)
    {
        return TYPlanEau::safeDownCast(_listPlanEau.at(index)->getElement());
    }
    LPTYPlanEauGeoNode findPlanEau(const LPTYPlanEau pPlanEau);
 
    TYTabCoursEauGeoNode& getListCrsEau()
    {
        return _listCrsEau;
    }
    const TYTabCoursEauGeoNode& getListCrsEau() const
    {
        return _listCrsEau;
    }
    void setListCrsEau(const TYTabCoursEauGeoNode& list)
    {
        _listCrsEau = list;
        setIsGeometryModified(true);
    }
    bool addCrsEau(LPTYCoursEauGeoNode pCoursEauGeoNode);
    bool addCrsEau(LPTYCoursEau pCoursEau);
    bool remCrsEau(const LPTYCoursEauGeoNode pCoursEauGeoNode);
    bool remCrsEau(const LPTYCoursEau pCoursEau);
    bool remCrsEau(QString idCrsEau);
    void remAllCrsEau();
    LPTYCoursEau getCrsEau(int index)
    {
        return TYCoursEau::safeDownCast(_listCrsEau.at(index)->getElement());
    }
    LPTYCoursEauGeoNode findCrsEau(const LPTYCoursEau pCrsEau);
 
    TYTabTerrainGeoNode& getListTerrain()
    {
        return _listTerrain;
    }
    const TYTabTerrainGeoNode& getListTerrain() const
    {
        return _listTerrain;
    }
    void setTerrain(const TYTabTerrainGeoNode& list)
    {
        _listTerrain = list;
        setIsGeometryModified(true);
    }
    bool addTerrain(LPTYTerrainGeoNode pTerGeoNode);
    bool addTerrain(LPTYTerrain pTer);
    bool remTerrain(const LPTYTerrainGeoNode pTerGeoNode);
    bool remTerrain(const LPTYTerrain pTer);
    bool remTerrain(QString idTerrain);
    void remAllTerrain();
    LPTYTerrain getTerrain(int index)
    {
        return TYTerrain::safeDownCast(_listTerrain.at(index)->getElement());
    }
    LPTYTerrainGeoNode findTerrain(const LPTYTerrain pTerrain);
 
    TYTabCourbeNiveauGeoNode& getListCrbNiv()
    {
        return _listCrbNiv;
    }
    const TYTabCourbeNiveauGeoNode& getListCrbNiv() const
    {
        return _listCrbNiv;
    }
    void setListCrbNiv(const TYTabCourbeNiveauGeoNode& list)
    {
        _listCrbNiv = list;
        setIsGeometryModified(true);
    }
    bool addCrbNiv(LPTYCourbeNiveauGeoNode pCrbNivGeoNode);
    bool addCrbNiv(LPTYCourbeNiveau pCrbNiv);
    bool remCrbNiv(const LPTYCourbeNiveauGeoNode pCrbNivGeoNode);
    bool remCrbNiv(const LPTYCourbeNiveau pCrbNiv);
    bool remCrbNiv(QString idCrbNiv);
    void remAllCrbNiv();
    LPTYCourbeNiveau getCrbNiv(int index)
    {
        return TYCourbeNiveau::safeDownCast(_listCrbNiv.at(index)->getElement());
    }
    LPTYCourbeNiveauGeoNode findCrbNiv(const LPTYCourbeNiveau pCrbNiv);
 
    int getDefTerrainIdx()
    {
        return _DefTerrainIdx;
    }
    void setDefTerrainIdx(const int& defTerrainIdx)
    {
        _DefTerrainIdx = defTerrainIdx;
    }
    TYTerrain* getDefTerrain();
    void setDefTerrain(int defTerrainIdx);
 
    TYTabPoint& getEmprise()
    {
        return _emprise;
    }
    const TYTabPoint& getEmprise() const
    {
        return _emprise;
    }
    void setEmprise(const TYTabPoint& pts, const bool& defTerrain = true);
    void addPointEmprise(TYPoint pt)
    {
        _emprise.push_back(pt);
        setIsGeometryModified(true);
    }
    TYPoint& getPointEmprise(int index)
    {
        return _emprise[index];
    }
    const TYPoint& getPointEmprise(int index) const
    {
        return _emprise[index];
    }
    void resetEmprise()
    {
        _emprise.clear();
        setIsGeometryModified(true);
    }
 
    LPTYAltimetrie getAltimetrie()
    {
        return _pAltimetrie;
    }
    const LPTYAltimetrie getAltimetrie() const
    {
        return _pAltimetrie;
    }
    void setAltimetrie(const LPTYAltimetrie pAltimetrie)
    {
        _pAltimetrie = pAltimetrie;
        _pAltimetrie->setParent(this);
        setIsGeometryModified(true);
    }
 
    double getTopoSize(OSegment3D& segDiagonale);
 
    void sortTerrainsBySurface();
 
    void setEmpriseColor(const OColor& color)
    {
        _empriseColor = color;
    };
    OColor getEmpriseColor() const
    {
        return _empriseColor;
    };
 
    void exportMesh(std::deque<OPoint3D>& points, std::deque<OTriangle>& triangles,
                    std::deque<LPTYSol>& materials);
 
private:
    // Membres
protected:
    TYTabCourbeNiveauGeoNode _listCrbNiv;
 
    LPTYAltimetrie _pAltimetrie;
 
    int _DefTerrainIdx;
 
    TYTabTerrainGeoNode _listTerrain;
 
    TYTabCoursEauGeoNode _listCrsEau;
 
    TYTabPlanEauGeoNode _listPlanEau;
 
    TYTabPoint _emprise;
    OColor _empriseColor;
 
    TYTerrainGeoNode** _pSortedTerrains;
 
private:
    std::vector<TYStructElemPts> _tabElemPts; // Tableau des terrains
    short _lastIndice;
};
 
typedef TYGeometryNode TYTopographieGeoNode;
typedef SmartPtr<TYTopographieGeoNode> LPTYTopographieGeoNode;
typedef std::vector<LPTYTopographieGeoNode> TYTabTopographieGeoNode;
 
#endif // __TY_TOPOGRAPHIE__