TYAltimetrie.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_ALTIMETRIE__
#define __TY_ALTIMETRIE__
 
#include <deque>
 
#include <gtest/gtest_prod.h>
 
#include "Tympan/models/business/geometry/TYGeometryNode.h"
#include "Tympan/models/business/geometry/TYPolygon.h"
#include "Tympan/models/business/exceptions.h"
#include "Tympan/models/common/delaunay_maker.h"
#include "Tympan/models/common/3d.h"
 
class TYAltimetrie : public TYElement
{
    OPROTODECL(TYAltimetrie)
    TY_EXTENSION_DECL_ONLY(TYAltimetrie)
    TY_EXT_GRAPHIC_DECL_ONLY(TYAltimetrie)
 
    // Methodes
public:
    static const double invalid_altitude;
    TYAltimetrie();
 
    TYAltimetrie(const TYAltimetrie& other);
 
    virtual ~TYAltimetrie();
 
    TYAltimetrie& operator=(const TYAltimetrie& other);
 
    bool operator==(const TYAltimetrie& other) const;
 
    bool operator!=(const TYAltimetrie& 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);
 
    //  XXX is being refactored to enable plugin back AltimetryBuilder result.
    //    /**
    //     * Calcul l'altimetrie a partir d'une collection de points.
    //     * L'altimetrie est le resultat de la triangulation de Delaunay calculee
    //     * a partir des points passes.
    //     *
    //     * @param points Les points pour calculer l'altimetrie.
    //     */
    //    virtual void compute(const TYTabPoint& points, const double& delaunay);
 
    //  XXX Is being replaced by the new triangulation builder
    //      from the SolverDataModel component
    //    /**
    //     * Calcul l'altimetrie a partir d'une collection de points et de segments.
    //     * L'altimetrie est le resultat de la triangulation de Delaunay contrainte calculee
    //     * a partir des points passes et des segments.
    //     *
    //     */
    //    void computeWithConstraint(OConstraintDelaunayMaker& oConstraintDelaunayMaker);
 
    void plugBackTriangulation(const std::deque<OPoint3D>& points, std::deque<OTriangle>& triangles,
                               const std::deque<LPTYSol>& materials);
 
    TYTabLPPolygon& getListFaces()
    {
        return _listFaces;
    }
 
    const TYTabLPPolygon& getListFaces() const
    {
        return _listFaces;
    }
 
    void setListFaces(const TYTabLPPolygon& list)
    {
        _listFaces = list;
    }
 
    bool addFace(LPTYPolygon pFace);
 
    bool remFace(const LPTYPolygon pFace);
 
    bool remFace(QString idFace);
 
    LPTYPolygon getFace(int index)
    {
        return _listFaces[index];
    }
    const TYPolygon* getFace(int index) const
    {
        return _listFaces[index];
    }
 
    double altitude(const OPoint3D& pt);
 
    bool updateAltitude(OPoint3D& pt) const;
 
    OPoint3D projection(const OPoint3D& pt) const;
 
    double HauteurMoyenne(TYTabPoint& pts);
 
    double PremiereHauteurPositiveOuNulle(TYTabPoint& ptsIn);
 
    LPTYPolygon getFaceUnder(OPoint3D pt);
 
    unsigned int getFacesInBox(const OBox2& box, TYTabLPPolygon& tabPolygon);
 
    unsigned int getPointsInBox(const OPoint3D& pt0, const OPoint3D& pt1, const OPoint3D& pt2,
                                const OPoint3D& pt3, TYTabPoint& tabPolygon);
 
    struct grid_index
    {
        unsigned pi, qi;
    };
 
    void exportMesh(std::deque<OPoint3D>& vertices, std::deque<OTriangle>& faces,
                    std::deque<LPTYSol>& materials);
 
    bool containsData()
    {
        return (_gridSX != 0) && (_gridSY != 0);
    }
 
protected:
    FRIEND_TEST(TYAltimetryTest, dummy_grid);
    FRIEND_TEST(TYAltimetryTest, simple_grid);
    FRIEND_TEST(TYAltimetryTest, simple_terrain);
 
    bool getGridIndices(const OPoint3D& pt, grid_index& indXY) const;
 
    bool getGridIndices(const OPoint3D* pts, unsigned int* iMinMax) const;
 
    bool getGridIndices(const OBox2& box, unsigned int* iMinMax) const;
 
    void getFacesinIndices(unsigned int& minX, unsigned int& maxX, unsigned int& minY, unsigned int& maxY,
                           TYTabLPPolygon& faces);
 
private:
    inline bool IsInsideFace(const TYTabPoint& pts, OPoint3D& pt) const;
 
    // Membres
protected:
    TYTabLPPolygon _listFaces;
 
    OBox _bbox;
 
    // The members below handle the accelerating grid : this could / should be a disctinc class
 
    void initNullGrid();
 
    void clearAcceleratingGrid();
 
    void initAcceleratingGrid(unsigned to_be_reserved = 0);
 
    void copyAcceleratingGrid(const TYAltimetrie& other);
 
    // Grille accélératrice contenant une liste de polygones pour chaque case
    TYTabLPPolygon** _pSortedFaces;
 
    unsigned _gridSX;
    unsigned _gridSY;
 
    double _gridDX;
    double _gridDY;
 
    // Altimetry mesh
    std::deque<OPoint3D> _vertices;
    std::deque<OTriangle> _faces;
    std::deque<LPTYSol> _materials;
};
 
typedef TYGeometryNode TYAltimetrieGeoNode;
 
#endif // __TY_ALTIMETRIE__