TYSiteNode.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) 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 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) 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 Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
/*
 *
 */
 
#ifndef __TY_SITENODE__
#define __TY_SITENODE__
 
#include "Tympan/models/business/infrastructure/TYTopographie.h"
#include "Tympan/models/business/infrastructure/TYInfrastructure.h"
#include "Tympan/models/business/TYCalcul.h"
 
typedef enum
{
    TYMPAN,
    LAMBERTIIe,
    GPS
} systemSIG;
 
typedef TYGeometryNode TYSiteNodeGeoNode;
typedef SmartPtr<TYSiteNodeGeoNode> LPTYSiteNodeGeoNode;
typedef std::vector<LPTYSiteNodeGeoNode> TYTabSiteNodeGeoNode;
 
class TYSiteNode : public TYElement
{
    OPROTODECL(TYSiteNode)
    TY_EXTENSION_DECL_ONLY(TYSiteNode)
    TY_EXT_GRAPHIC_DECL_ONLY(TYSiteNode)
 
    
    TYSiteNode();
    TYSiteNode(const TYSiteNode& other);
    virtual ~TYSiteNode();
 
    virtual TYSiteNode& operator=(const TYSiteNode& other);
    virtual bool operator==(const TYSiteNode& other) const;
    virtual bool operator!=(const TYSiteNode& 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 getChilds(LPTYElementArray& childs, bool recursif = true);
 
    virtual void setIsGeometryModified(bool isModified);
 
    void purge()
    {
        _listSiteNode.clear();
    }
 
 
    TYProjet* getProjet()
    {
        return _pProjet;
    }
    const TYProjet* getProjet() const
    {
        return _pProjet;
    }
 
    void setProjet(const LPTYProjet pProjet);
 
    bool getUseEmpriseAsCrbNiv() const
    {
        return _bEmpriseAsCrbNiv;
    }
    void setUseEmpriseAsCrbNiv(bool b)
    {
        _bEmpriseAsCrbNiv = b;
    }
 
    void setAltiEmprise(const double& altiEmprise)
    {
        _altiEmprise = altiEmprise;
        _pTopographie->updateEmpriseAltitude(_altiEmprise);
    }
    const double getAltiEmprise() const
    {
        return _altiEmprise;
    }
 
    LPTYTopographie getTopographie()
    {
        return _pTopographie;
    }
    const LPTYTopographie getTopographie() const
    {
        return _pTopographie;
    }
 
    void setTopographie(const LPTYTopographie pTopo)
    {
        _pTopographie = pTopo;
        _pTopographie->setParent(this);
        setIsGeometryModified(true);
    }
 
    LPTYInfrastructure getInfrastructure()
    {
        return _pInfrastructure;
    }
    const LPTYInfrastructure getInfrastructure() const
    {
        return _pInfrastructure;
    }
    void setInfrastructure(const LPTYInfrastructure& pInfra)
    {
        _pInfrastructure = pInfra;
        _pInfrastructure->setParent(this);
        setIsGeometryModified(true);
    }
 
    bool getUseTopoFile() const
    {
        return _useTopoFile;
    }
    void setUseTopoFile(bool flag)
    {
        _useTopoFile = flag;
    }
 
    QString getTopoFile() const
    {
        return _topoFile;
    }
    void setTopoFile(const QString& fileName)
    {
        _topoFile = fileName;
    }
    QString getTopoFileExtension() const
    {
        return _topoFileExtension;
    }
    void setTopoFileExtension(const QString& ext)
    {
        _topoFileExtension = ext;
    }
    QString getTopoFileName() const
    {
        return _topoFileName;
    }
    void setTopoFileName(const QString& name)
    {
        _topoFileName = name;
    }
    static const QString& getTopoFilePath();
    static void setTopoFilePath(const QString& path);
 
    void loadTopoFile(const QString& fileName);
    void loadTopoFile();
 
    const QString& getMeshFilePath();
    void setMeshFilePath(const QString& path);
 
    float getEchelle() const
    {
        return _echelle;
    }
    void setEchelle(float e)
    {
        _echelle = e;
        setIsGeometryModified(true);
    }
 
    TYSegment getOrientation() const
    {
        return _orientation;
    }
    void setOrientation(TYSegment seg)
    {
        _orientation = seg;
        setIsGeometryModified(true);
    }
 
    TYPoint getPosition() const
    {
        return _position;
    }
 
    bool getRoot() const
    {
        return _root;
    }
 
    void setRoot(bool b)
    {
        _root = b;
    }
 
    void setPosition(TYPoint pt)
    {
        _position = pt;
        setIsGeometryModified(true);
    }
 
    TYTabSiteNodeGeoNode& getListSiteNode()
    {
        return _listSiteNode;
    }
 
    const TYTabSiteNodeGeoNode& getListSiteNode() const
    {
        return _listSiteNode;
    }
 
    void setEmprise(TYTabPoint points)
    {
        _pTopographie->setEmprise(points);
    }
 
    bool addSiteNode(LPTYSiteNodeGeoNode pSiteNodeGeoNode);
 
    bool addSiteNode(LPTYSiteNode pSiteNode);
 
    bool remSiteNode(const LPTYSiteNodeGeoNode pSiteNodeGeoNode);
 
    bool remSiteNode(const LPTYSiteNode pSiteNode);
 
    bool remSiteNode(QString idSiteNode);
 
    LPTYSiteNodeGeoNode findSiteNode(const LPTYSiteNode pSiteNode);
 
    void setListSiteNode(const TYTabSiteNodeGeoNode& list)
    {
        _listSiteNode = list;
        setIsGeometryModified(true);
    }
 
    virtual void setChildsNotInCurrentCalcul();
 
    TYTabSiteNodeGeoNode collectSites(bool include = true) const;
 
    // 3. -ELEMENT PROPRE AU CALCUL
    LPTYSiteNode merge();
 
    virtual void reparent();
 
    virtual void updateCurrentCalcul(TYListID& listID, bool recursif = true);
 
    virtual bool addToCalcul();
 
    virtual bool remFromCalcul();
 
    virtual bool updateAltimetrie(QString resultMeshFilePath);
 
    void uuid2tysol(const std::deque<std::string>& material_ids, std::deque<LPTYSol>& materials);
 
protected:
    virtual void do_updateAltimetrie(QString resultMeshFilePath);
 
public:
    /*
     * Reads a mesh from 'filename' ply file, and puts it in 'points', 'triangles'
     * and 'materials'.
     *
     * @return true if operations succeeds else false
     */
    bool readMesh(std::deque<OPoint3D>& points, std::deque<OTriangle>& triangles,
                  std::deque<LPTYSol>& materials, const QString& meshFilePath);
 
    virtual void updateAltiInfra();
 
    virtual void updateAcoustique(const bool& force = false);
 
    void update(const bool& force = false);
 
    bool update(TYElement* pElem);
 
    // XXX The process is being rewritten and this function removed
    // virtual TYTabPoint collectPointsForAltimetrie() const;
 
    double getDelaunay();
 
    void getListFaces(TYTabAcousticSurfaceGeoNode& tabFaces, unsigned int& nbFaceInfra,
                      std::vector<bool>& EstUnIndexDeFaceEcran) const;
    void getListFacesWithoutFloor(TYTabAcousticSurfaceGeoNode& tabFaces, unsigned int& nbFaceInfra,
                                  std::vector<bool>& EstUnIndexDeFaceEcran,
                                  std::vector<std::pair<int, int>>& indices, std::vector<int>& etages) const;
 
    void getFacesOnGround(std::map<TYUUID, std::deque<TYTabPoint3D>>& contours) const;
 
    void groundBasedFaces(const TYTabAcousticVolumeGeoNode& volumes, const OMatrix& global_matrix,
                          std::map<TYUUID, std::deque<TYTabPoint3D>>& contours) const;
 
    int getSIGType()
    {
        return _SIGType;
    }
    const int getSIGType() const
    {
        return _SIGType;
    }
    void setSIGType(int SIGType)
    {
        _SIGType = (systemSIG)SIGType;
    }
 
    double getSIG_X()
    {
        return _SIG_X;
    }
    const double getSIG_X() const
    {
        return _SIG_X;
    }
    void setSIG_X(const double& SIG_X)
    {
        _SIG_X = SIG_X;
    }
 
    double getSIG_Y()
    {
        return _SIG_Y;
    }
    const double getSIG_Y() const
    {
        return _SIG_Y;
    }
    void setSIG_Y(const double& SIG_Y)
    {
        _SIG_Y = SIG_Y;
    }
 
    double getSIG_OFFSET()
    {
        return _SIG_OFFSET;
    }
    const double getSIG_OFFSET() const
    {
        return _SIG_OFFSET;
    }
    void setSIG_OFFSET(const double& SIG_OFFSET)
    {
        _SIG_OFFSET = SIG_OFFSET;
    }
 
    virtual void exportCSV(std::ofstream& ofs);
 
    /* Return the site altimetry (retrieved from the rootsite of the hierarchy,
     * which can be the current site node or one of its parents
     */
    LPTYAltimetrie getAltimetry() const;
 
    /* Transform matrix allowing to move the site to a global frame.
     * If the site is the root site, this matrix should be equal to the identity
     * matrix.
     */
    OMatrix getGlobalMatrix() const;
 
protected:
    void appendSite(LPTYSiteNode pSiteFrom, const OMatrix& matrix, LPTYSiteNode pSiteTo);
 
    // Membres
private:
    static QString _topoFilePath;
 
protected:
    LPTYProjet _pProjet;
 
    bool _bEmpriseAsCrbNiv;
 
    double _altiEmprise;
 
    LPTYTopographie _pTopographie;
 
    LPTYInfrastructure _pInfrastructure;
 
    bool _useTopoFile;
 
    QString _topoFileName;
 
    QString _meshFilePath;
 
    QString _topoFile;
 
    QString _topoFileExtension;
 
    float _echelle;
    TYSegment _orientation;
    TYPoint _position;
 
    unsigned int _nbFaceInfra;
 
    unsigned int _nbFaces; // Nombre de faces total
 
    bool _root;
 
    systemSIG _SIGType;
 
    double _SIG_X;
    double _SIG_Y;
    double _SIG_OFFSET;
 
    TYTabSiteNodeGeoNode _listSiteNode;
 
    bool _isTopoFileModified;
};
 
#endif // __TY_SITENODE__