MeshTool.h

Go to the documentation of this file.

#pragma once

#include <Draw/OglMaterial.h>
#include <Draw/SurfaceStyle.h>
#include <Topo/Shape.h>
#include <Topo/topo_defines.h>



/*
@brief MeshTool
[1] Boundary edges are edges shared by only one face.
*/

class TopoDS_Shape;

namespace Core
{
class CoreDocument;

}

namespace App
{
class Element;
}


namespace Topo
{
struct TOPO_EXPORT LineItem
{
    std::vector<Geom::Pnt> points;
    Draw::OglMaterial material;
};

class TOPO_EXPORT MeshTool
{
public:
    MeshTool(void);
    virtual ~MeshTool(void);

    //                                                       //
    // --------------------- BEGIN API --------------------- //
    //                                                       //
    // ATTENTION: DO NOT CHANGE ANY SIGNATURES IN THE API !  //
    //                                                       //

    static pMesh copy(pConstMesh mesh, bool deepCopy = false);
    static bool isClosed(pConstMesh mesh);
    static bool isPlanar(pConstMesh mesh);
    static pMesh triangulationToMesh(pConstShape shape);
    static pMesh triangulationToMesh(pConstShape shape, bool highQuality, std::vector<int>* newToOldFaceIdxMap = 0);
    static pShape convertMesh2Shape(pConstMesh mesh, std::vector<std::vector<Geom::Pnt>>& defectPolygons);
    static pShape convertMesh2Solid(pConstMesh aMesh, bool prefer_stiching, bool onlyClosedSolid, bool mergePlanarFaces);
    static pShape convertMesh2Polyhedral(pConstMesh mesh, std::vector<std::vector<Geom::Pnt>>& defectPolygons);
    static pShape convertMesh2Brep_by_Face_Stiching(pConstMesh mesh, std::vector<std::vector<Geom::Pnt>>& defectPolygons);
    static pShape convertMesh2Shell(pConstMesh mesh, std::vector<std::vector<Geom::Pnt>>& defectPolygons);
    static pMesh makeMeshFromBrepData(pConstBrepData data);
    static pMesh makeMesh(const std::vector<Geom::Pnt>& nodes,
                          const std::vector<int>& model,
                          const std::vector<Geom::Pnt2d>& textureCoords,
                          const std::vector<int>& textureCoordIndices);
    static pMesh makeMesh(const std::vector<Geom::Pnt>& nodes, const std::vector<int>& model);
    static std::vector<App::Element*> getElementsFromOMFFile(Core::CoreDocument* doc,
                                                             const Base::String& fileName,
                                                             double scaleFactor = 1.,
                                                             bool terrain = false);

    static bool getMesh(pConstMesh mesh,
                        std::vector<Geom::Pnt>& nodes,
                        std::vector<int>& model,
                        std::vector<Draw::SurfaceStyle>& surfaceStyles,
                        std::vector<int>& faceIndices,
                        std::vector<int>& surfaceStyleIndices,
                        std::vector<Geom::Pnt2d>& textureCoords,
                        std::vector<int>& textureCoordIndices,
                        std::vector<Topo::LineItem>* lineItems = 0);

    static bool getCreaseAngle(pConstMesh mesh, float& angle);

    //                                                       //
    // ---------------------- END API ---------------------- //
    //                                                       //

#ifndef LXAPI  // INTERFACES BELOW ARE -NOT- PART OF THE LEXOCAD API

    static std::vector<App::Element*> getElementsFromOMFFile(Core::CoreDocument* doc,
                                                             const Base::String& fileName,
                                                             double scaleFactor,
                                                             bool terrain,
                                                             std::map<std::string, Core::Variant>* properties,
                                                             bool forceTerrainFrom2dr);

#ifndef SWIG
    static std::map<int, std::array<Core::Variant, 6>> getHorizontalPointsFromOMFFile(Core::CoreDocument* doc,
                                                                                      const Base::String& fileName,
                                                                                      std::map<std::string, Core::Variant>* properties,
                                                                                      const double& scaleFactor = 1.);
    static std::map<int, std::array<Core::Variant, 4>> getVerticalPointsFromOMFFile(Core::CoreDocument* doc,
                                                                                    const Base::String& fileName,
                                                                                    std::map<std::string, Core::Variant>* properties,
                                                                                    const double& scaleFactor = 1.);
#endif

    static void getModel(pConstMesh mesh, std::vector<int>& model);
    static void getPoints(pConstMesh mesh, std::vector<Geom::Pnt>& points);


    static void __setDefaultMeshTool__(Topo::MeshTool* tool) { _defaultTool = tool; }
    static bool writeOmfFile(const std::vector<App::Element*>& elems, const Base::String& fileName);

    static bool getInventorMeshColors(pConstMesh mesh, std::vector<Base::Color>& uniqueColors, std::vector<std::string>* colorNames = 0);

protected:
#endif

private:
    virtual pMesh _copy(pConstMesh shape, bool deepCopy);
    virtual bool _isClosed(pConstMesh mesh);
    virtual pMesh _triangulationToMesh(pConstShape shape);
    virtual pMesh _triangulationToMesh(pConstShape shape, bool highQuality, std::vector<int>* newToOldFaceIdxMap);
    static Topo::MeshTool* _defaultTool;

    virtual void _getModel(pConstMesh mesh, std::vector<int>& model);
    virtual void _getPoints(pConstMesh mesh, std::vector<Geom::Pnt>& points);
    virtual pMesh _makeMeshFromBrepData(pConstBrepData data);
    virtual std::vector<App::Element*> _getElementsFromOMFFile(Core::CoreDocument* doc,
                                                               const Base::String& fileName,
                                                               double scaleFactor,
                                                               bool terrain,
                                                               std::map<std::string, Core::Variant>* properties,
                                                               bool forceTerrainFrom2dr);
    virtual std::map<int, std::array<Core::Variant, 6>> _getHorizontalPointsFromOMFFile(Core::CoreDocument* doc,
                                                                                        const Base::String& fileName,
                                                                                        std::map<std::string, Core::Variant>* properties,
                                                                                        const double& scaleFactor);
    virtual std::map<int, std::array<Core::Variant, 4>> _getVerticalPointsFromOMFFile(Core::CoreDocument* doc,
                                                                                      const Base::String& fileName,
                                                                                      std::map<std::string, Core::Variant>* properties,
                                                                                      const double& scaleFactor);
    virtual bool _writeOmfFile(const std::vector<App::Element*>& elems, const Base::String& fileName);
    virtual bool _getInventorMeshColors(pConstMesh mesh, std::vector<Base::Color>& uniqueColors, std::vector<std::string>* colorNames);
    virtual pMesh _makeMesh(const std::vector<Geom::Pnt>& nodes,
                            const std::vector<int>& model,
                            const std::vector<Geom::Pnt2d>& textureCoords,
                            const std::vector<int>& textureCoordIndices);
    virtual pMesh _makeMesh(const std::vector<Geom::Pnt>& nodes, const std::vector<int>& model);

    virtual bool _getMesh(pConstMesh mesh,
                          std::vector<Geom::Pnt>& nodes,
                          std::vector<int>& model,
                          std::vector<Draw::SurfaceStyle>& surfaceStyles,
                          std::vector<int>& faceIndices,
                          std::vector<int>& surfaceStyleIndices,
                          std::vector<Geom::Pnt2d>& textureCoords,
                          std::vector<int>& textureCoordIndices,
                          std::vector<Topo::LineItem>* lineItems = 0);

    virtual bool _getCreaseAngle(pConstMesh mesh, float& angle);

};

}  // namespace Topo