FaceTool.h

Go to the documentation of this file.

#pragma once

#include <Geom/BrepData.h>
#include <Geom/Circ.h>
#include <Geom/Pnt.h>
#include <Geom/Precision.h>
#include <Geom/Trsf.h>
#include <Topo/Clash.h>
#include <Topo/Shape.h>

class TopoDS_Face;
class FACE;

namespace Mesher
{
class ShapeTesselator;
class ShapeTesselator_OCC;
class ShapeTesselator_Acis;
class TriangleData;
class TriangleData_OCC;
class TriangleData_Acis;
}  // namespace Mesher

namespace MesherAcis
{
class ShapeTesselator_Acis;
class TriangleData_Acis;
}  // namespace MesherAcis


namespace Part
{
class SnapPointTool;
}

namespace App
{
class SurfaceStyleAssignment;
class FaceDetail;
}  // namespace App

namespace Topo
{
class LX_TOPO_EXPORT FaceTool
{
public:
    FaceTool(void);
    virtual ~FaceTool(void);

    friend class Mesher::ShapeTesselator;
    friend class Mesher::ShapeTesselator_OCC;
    friend class MesherAcis::ShapeTesselator_Acis;
    friend class Mesher::TriangleData;
    friend class Mesher::TriangleData_OCC;
    friend class MesherAcis::TriangleData_Acis;
    friend class Part::SnapPointTool;

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

    static pFace copy(pConstFace face);
    static pFace makeFace(pWire outer, double precision = Geom::Precision::linear_Resolution());
    static pFace makeFace(const Geom::Pnt& p1, const Geom::Pnt& p2, const Geom::Pnt& p3);
    static pFace makeFace(const Geom::Pnt& p1, const Geom::Pnt& p2, const Geom::Pnt& p3, const Geom::Pnt& p4);
    static pFace makeCylindricalFace(const Geom::Circ& aCircle, double aParam1, double aParam2, double aHeight);
    static pFace makePlanarFace(pWire outerWire, const std::vector<pWire>& innerWires, double precision = Geom::Precision::linear_Resolution());
    static pFace makePlanarFaceWithoutVoids(const std::vector<pWire>& wires, double precision = Geom::Precision::linear_Resolution());
    static std::vector<pFace> makePlanarFaces(pConstBrepData data);
    static pFace makeFace(pWire outerWire, const std::vector<pWire>& innerWires, double precision = Geom::Precision::linear_Resolution());
    static pFace makePolygon(const std::vector<Geom::Pnt>& points);
    static bool isValidPointForFace(const Geom::Pnt& p, pConstFace face, double precision = Geom::Precision::linear_Resolution());
    static pFace transformed(pConstFace face, const Geom::Trsf& transform);
    static bool getGeomSurfaceType(pConstFace face, Geom::SurfaceType& type);
    static bool getGeomSurfaceType(FACE* face, Geom::SurfaceType& type);
    static double getArea(pConstFace face);
    static pConstWire getOuterBoundary(pConstFace face);
    static std::vector<pConstWire> getInnerBoundaries(pConstFace face);
    static pShape makeConnectedFaceSet(const std::vector<int>& model, const std::vector<Geom::Pnt>& vertices);
    static bool isNurbs(pConstFace face);
    static pShape extrudedFace(pConstFace face, const Geom::Dir& extrudedDirection, double depth);
    static bool extendFace(pFace face, const std::vector<pConstEdge>& edges, double offset);
    static bool getCircularSurfaceParams(pConstFace face, Geom::Circ& circle);
    static bool getCylinderSurfaceParams(pConstFace face, Geom::Ax2& position, double& radius);
    static bool getCylinderSurfaceParams(FACE* face, Geom::Ax2& position, double& radius);
    static bool getConeSurfaceParams(pConstFace face, Geom::Ax2& position, double& angle, double& radius);
    static bool getConeSurfaceParams(FACE* face, Geom::Ax2& position, double& angle, double& radius);
    static Geom::Pnt getCentre(pConstFace face);
    static bool projectPointOnFace(const Geom::Pnt& p, pConstFace face, Geom::Pnt& nearest);
    static bool projectPointOnFace(const Geom::Pnt& p, pConstFace face, double& u, double& v);
    static bool isSelfIntersecting(pConstFace face);
    static void getOuterBoundaryPoints(pConstFace face, std::vector<Geom::Pnt>& pnts);
    static void getOuterBoundaryPointsFast(pConstFace face, std::vector<Geom::Pnt>& pnts);
    static bool getPointFaceDistance(const Geom::Pnt& p, pConstFace face, Geom::Pnt& nearest, double& distance);
    static bool containsFace(pConstFace outerface, pConstFace innerFace);
    static std::shared_ptr<Topo::SpecialFaceInfo> getSpecialFaceInfo(pConstFace face);
    static Topo::ToolOutcome clash(pConstFace face1, pConstFace face2, bool& hasClash);
    static Topo::ToolOutcome clashFaces(pConstFace face1, pConstFace face2, Topo::FaceClashType& clashType);
    static bool isRectangular(pConstFace face, Geom::Ax2& position, double& width, double& height);

    static void getOuterBoundaryPointsFast(FACE*, std::vector<Geom::Pnt>& pnt);

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

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

    static void __setDefaultFaceTool__(Topo::FaceTool* tool) { _defaultTool = tool; }
    static void __setAcisShapeTool__(Topo::FaceTool* tool) { _acisTool = tool; }
    static bool isPlanarFace(pConstFace face);

protected:
    static bool getTopoDS_Face(pConstFace face, TopoDS_Face& topoFace);

    virtual pFace _copy(pConstFace face);
    virtual pFace _makeFace(pWire outer, double precision);
    virtual pFace _makeFace(pWire outerWire, const std::vector<pWire>& innerWires, double precision);
    virtual pFace _makePolygon(const std::vector<Geom::Pnt>& points);
    virtual bool _isValidPointForFace(const Geom::Pnt& p, pConstFace face, double precision = Geom::Precision::linear_Resolution());
    virtual pFace _transformed(pConstFace face, const Geom::Trsf& transform);
    virtual bool _getGeomSurfaceType(pConstFace face, Geom::SurfaceType& type);
    virtual bool _getGeomSurfaceType(FACE* , Geom::SurfaceType& type);
    virtual double _getArea(pConstFace face);
    virtual bool _getTopoDS_Face(pConstFace face, TopoDS_Face& topoFace);
    virtual pConstWire _getOuterBoundary(pConstFace face);
    virtual std::vector<pConstWire> _getInnerBoundaries(pConstFace face);
    virtual pShape _makeConnectedFaceSet(const std::vector<int>& model, const std::vector<Geom::Pnt>& vertices);
    virtual pShape _extrudedFace(pConstFace face, const Geom::Dir& extrudedDirection, double depth);
    virtual bool _extendFace(pFace face, const std::vector<pConstEdge>& edges, double offset);
    virtual bool _getCylinderSurfaceParams(FACE* face, Geom::Ax2& position, double& radius);
    virtual bool _getCylinderSurfaceParams(pConstFace face, Geom::Ax2& position, double& radius);
    virtual bool _getConeSurfaceParams(FACE*  face, Geom::Ax2& position, double& angle, double& radius);
    virtual bool _getConeSurfaceParams(pConstFace face, Geom::Ax2& position, double& angle, double& radius);
    virtual Geom::Pnt _getCentre(pConstFace face);
    virtual bool _projectPointOnFace(const Geom::Pnt& p, pConstFace face, Geom::Pnt& nearest);
    virtual bool _projectPointOnFace(const Geom::Pnt& p, pConstFace face, double& u, double& v);
    virtual bool _isSelfIntersecting(pConstFace face);
    virtual pFace _makePlanarFace(pWire outerWire, const std::vector<pWire>& innerWires, double precision);
    virtual pFace _makePlanarFaceWithoutVoids(const std::vector<pWire>& wires, double precision);
    virtual std::vector<pFace> _makePlanarFaces(pConstBrepData data);
    virtual void _getOuterBoundaryPoints(pConstFace face, std::vector<Geom::Pnt>& pnts);
    virtual void _getOuterBoundaryPointsFast(pConstFace face, std::vector<Geom::Pnt>& pnts);
    virtual void _getOuterBoundaryPointsFast(FACE*, std::vector<Geom::Pnt>& pnts);
    virtual bool _getPointFaceDistance(const Geom::Pnt& p, pConstFace face, Geom::Pnt& nearest, double& distance);
    virtual bool _containsFace(pConstFace outerface, pConstFace innerFace);
    virtual bool _createTextureCoordinates(pConstFace face,
                                           const Geom::Bnd_Box& bbox,
                                           const App::SurfaceStyleAssignment* ssa,
                                           std::vector<Geom::Pnt2d>& coord);
    virtual bool _isPlanarFace(pConstFace face);
    virtual Topo::ToolOutcome _clash(pConstFace face1, pConstFace face2, bool& hasClash);
    virtual Topo::ToolOutcome _clashFaces(pConstFace face1, pConstFace face2, Topo::FaceClashType& clashType);
    static Topo::FaceTool* _defaultTool;
    static Topo::FaceTool* _acisTool;

#endif
};


}  // namespace Topo