FreeCAD / src /Mod /Mesh /App /Core /Segmentation.h

Upload folder using huggingface_hub

985c397 verified 9 months ago

12.7 kB

// SPDX-License-Identifier: LGPL-2.1-or-later

/***************************************************************************
 *   Copyright (c) 2012 Imetric 3D GmbH                                    *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  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 Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/

#ifndef MESHCORE_SEGMENTATION_H
#define MESHCORE_SEGMENTATION_H

#include <memory>
#include <vector>

#include "Curvature.h"
#include "MeshKernel.h"
#include "Visitor.h"


namespace MeshCore
{

class PlaneFit;
class CylinderFit;
class SphereFit;
class MeshFacet;
using MeshSegment = std::vector<FacetIndex>;

class MeshExport MeshSurfaceSegment
{
public:
    explicit MeshSurfaceSegment(unsigned long minFacets)
        : minFacets(minFacets)
    {}
    virtual ~MeshSurfaceSegment() = default;

    MeshSurfaceSegment(const MeshSurfaceSegment&) = delete;
    MeshSurfaceSegment(MeshSurfaceSegment&&) = delete;
    MeshSurfaceSegment& operator=(const MeshSurfaceSegment&) = delete;
    MeshSurfaceSegment& operator=(MeshSurfaceSegment&&) = delete;

    virtual bool TestFacet(const MeshFacet& rclFacet) const = 0;
    virtual const char* GetType() const = 0;
    virtual void Initialize(FacetIndex);
    virtual bool TestInitialFacet(FacetIndex) const;
    virtual void AddFacet(const MeshFacet& rclFacet);
    void AddSegment(const std::vector<FacetIndex>&);
    const std::vector<MeshSegment>& GetSegments() const
    {
        return segments;
    }
    MeshSegment FindSegment(FacetIndex) const;

private:
    std::vector<MeshSegment> segments;
    unsigned long minFacets;
};
using MeshSurfaceSegmentPtr = std::shared_ptr<MeshSurfaceSegment>;

// --------------------------------------------------------

class MeshExport MeshDistanceSurfaceSegment: public MeshSurfaceSegment
{
public:
    MeshDistanceSurfaceSegment(const MeshKernel& mesh, unsigned long minFacets, float tol)
        : MeshSurfaceSegment(minFacets)
        , kernel(mesh)
        , tolerance(tol)
    {}

protected:
    // NOLINTBEGIN
    const MeshKernel& kernel;
    float tolerance;
    // NOLINTEND
};

class MeshExport MeshDistancePlanarSegment: public MeshDistanceSurfaceSegment
{
public:
    MeshDistancePlanarSegment(const MeshKernel& mesh, unsigned long minFacets, float tol);
    ~MeshDistancePlanarSegment() override;

    MeshDistancePlanarSegment(const MeshDistancePlanarSegment&) = delete;
    MeshDistancePlanarSegment(MeshDistancePlanarSegment&&) = delete;
    MeshDistancePlanarSegment& operator=(const MeshDistancePlanarSegment&) = delete;
    MeshDistancePlanarSegment& operator=(MeshDistancePlanarSegment&&) = delete;

    bool TestFacet(const MeshFacet& face) const override;
    const char* GetType() const override
    {
        return "Plane";
    }
    void Initialize(FacetIndex) override;
    void AddFacet(const MeshFacet& face) override;

private:
    Base::Vector3f basepoint;
    Base::Vector3f normal;
    PlaneFit* fitter;
};

class MeshExport AbstractSurfaceFit
{
public:
    AbstractSurfaceFit() = default;
    virtual ~AbstractSurfaceFit() = default;

    AbstractSurfaceFit(const AbstractSurfaceFit&) = delete;
    AbstractSurfaceFit(AbstractSurfaceFit&&) = delete;
    AbstractSurfaceFit& operator=(const AbstractSurfaceFit&) = delete;
    AbstractSurfaceFit& operator=(AbstractSurfaceFit&&) = delete;

    virtual const char* GetType() const = 0;
    virtual void Initialize(const MeshGeomFacet&) = 0;
    virtual bool TestTriangle(const MeshGeomFacet&) const = 0;
    virtual void AddTriangle(const MeshGeomFacet&) = 0;
    virtual bool Done() const = 0;
    virtual float Fit() = 0;
    virtual float GetDistanceToSurface(const Base::Vector3f&) const = 0;
    virtual std::vector<float> Parameters() const = 0;
};

class MeshExport PlaneSurfaceFit: public AbstractSurfaceFit
{
public:
    PlaneSurfaceFit();
    PlaneSurfaceFit(const Base::Vector3f& b, const Base::Vector3f& n);
    ~PlaneSurfaceFit() override;

    PlaneSurfaceFit(const PlaneSurfaceFit&) = delete;
    PlaneSurfaceFit(PlaneSurfaceFit&&) = delete;
    PlaneSurfaceFit& operator=(const PlaneSurfaceFit&) = delete;
    PlaneSurfaceFit& operator=(PlaneSurfaceFit&&) = delete;

    const char* GetType() const override
    {
        return "Plane";
    }
    void Initialize(const MeshGeomFacet&) override;
    bool TestTriangle(const MeshGeomFacet&) const override;
    void AddTriangle(const MeshGeomFacet&) override;
    bool Done() const override;
    float Fit() override;
    float GetDistanceToSurface(const Base::Vector3f&) const override;
    std::vector<float> Parameters() const override;

private:
    Base::Vector3f basepoint;
    Base::Vector3f normal;
    PlaneFit* fitter;
};

class MeshExport CylinderSurfaceFit: public AbstractSurfaceFit
{
public:
    CylinderSurfaceFit();
    CylinderSurfaceFit(const Base::Vector3f& b, const Base::Vector3f& a, float r);
    ~CylinderSurfaceFit() override;

    CylinderSurfaceFit(const CylinderSurfaceFit&) = delete;
    CylinderSurfaceFit(CylinderSurfaceFit&&) = delete;
    CylinderSurfaceFit& operator=(const CylinderSurfaceFit&) = delete;
    CylinderSurfaceFit& operator=(CylinderSurfaceFit&&) = delete;

    const char* GetType() const override
    {
        return "Cylinder";
    }
    void Initialize(const MeshGeomFacet&) override;
    bool TestTriangle(const MeshGeomFacet&) const override;
    void AddTriangle(const MeshGeomFacet&) override;
    bool Done() const override;
    float Fit() override;
    float GetDistanceToSurface(const Base::Vector3f&) const override;
    std::vector<float> Parameters() const override;

private:
    Base::Vector3f basepoint;
    Base::Vector3f axis;
    float radius;
    CylinderFit* fitter;
};

class MeshExport SphereSurfaceFit: public AbstractSurfaceFit
{
public:
    SphereSurfaceFit();
    SphereSurfaceFit(const Base::Vector3f& c, float r);
    ~SphereSurfaceFit() override;

    SphereSurfaceFit(const SphereSurfaceFit&) = delete;
    SphereSurfaceFit(SphereSurfaceFit&&) = delete;
    SphereSurfaceFit& operator=(const SphereSurfaceFit&) = delete;
    SphereSurfaceFit& operator=(SphereSurfaceFit&&) = delete;

    const char* GetType() const override
    {
        return "Sphere";
    }
    void Initialize(const MeshGeomFacet&) override;
    bool TestTriangle(const MeshGeomFacet&) const override;
    void AddTriangle(const MeshGeomFacet&) override;
    bool Done() const override;
    float Fit() override;
    float GetDistanceToSurface(const Base::Vector3f&) const override;
    std::vector<float> Parameters() const override;

private:
    Base::Vector3f center;
    float radius;
    SphereFit* fitter;
};

class MeshExport MeshDistanceGenericSurfaceFitSegment: public MeshDistanceSurfaceSegment
{
public:
    MeshDistanceGenericSurfaceFitSegment(
        AbstractSurfaceFit*,
        const MeshKernel& mesh,
        unsigned long minFacets,
        float tol
    );
    ~MeshDistanceGenericSurfaceFitSegment() override;

    MeshDistanceGenericSurfaceFitSegment(const MeshDistanceGenericSurfaceFitSegment&) = delete;
    MeshDistanceGenericSurfaceFitSegment(MeshDistanceGenericSurfaceFitSegment&&) = delete;
    MeshDistanceGenericSurfaceFitSegment& operator=(
        const MeshDistanceGenericSurfaceFitSegment&
    ) = delete;
    MeshDistanceGenericSurfaceFitSegment& operator=(MeshDistanceGenericSurfaceFitSegment&&) = delete;

    bool TestFacet(const MeshFacet& face) const override;
    const char* GetType() const override
    {
        return fitter->GetType();
    }
    void Initialize(FacetIndex) override;
    bool TestInitialFacet(FacetIndex) const override;
    void AddFacet(const MeshFacet& face) override;
    std::vector<float> Parameters() const;

private:
    AbstractSurfaceFit* fitter;
};

// --------------------------------------------------------

class MeshExport MeshCurvatureSurfaceSegment: public MeshSurfaceSegment
{
public:
    MeshCurvatureSurfaceSegment(const std::vector<CurvatureInfo>& ci, unsigned long minFacets)
        : MeshSurfaceSegment(minFacets)
        , info(ci)
    {}

    const CurvatureInfo& GetInfo(std::size_t pos) const
    {
        return info.at(pos);
    }

private:
    const std::vector<CurvatureInfo>& info;
};

class MeshExport MeshCurvaturePlanarSegment: public MeshCurvatureSurfaceSegment
{
public:
    MeshCurvaturePlanarSegment(const std::vector<CurvatureInfo>& ci, unsigned long minFacets, float tol)
        : MeshCurvatureSurfaceSegment(ci, minFacets)
        , tolerance(tol)
    {}
    bool TestFacet(const MeshFacet& rclFacet) const override;
    const char* GetType() const override
    {
        return "Plane";
    }

private:
    float tolerance;
};

class MeshExport MeshCurvatureCylindricalSegment: public MeshCurvatureSurfaceSegment
{
public:
    MeshCurvatureCylindricalSegment(
        const std::vector<CurvatureInfo>& ci,
        unsigned long minFacets,
        float tolMin,
        float tolMax,
        float curv
    )
        : MeshCurvatureSurfaceSegment(ci, minFacets)
        , curvature(curv)
        , toleranceMin(tolMin)
        , toleranceMax(tolMax)
    {}
    bool TestFacet(const MeshFacet& rclFacet) const override;
    const char* GetType() const override
    {
        return "Cylinder";
    }

private:
    float curvature;
    float toleranceMin;
    float toleranceMax;
};

class MeshExport MeshCurvatureSphericalSegment: public MeshCurvatureSurfaceSegment
{
public:
    MeshCurvatureSphericalSegment(
        const std::vector<CurvatureInfo>& ci,
        unsigned long minFacets,
        float tol,
        float curv
    )
        : MeshCurvatureSurfaceSegment(ci, minFacets)
        , curvature(curv)
        , tolerance(tol)
    {}
    bool TestFacet(const MeshFacet& rclFacet) const override;
    const char* GetType() const override
    {
        return "Sphere";
    }

private:
    float curvature;
    float tolerance;
};

class MeshExport MeshCurvatureFreeformSegment: public MeshCurvatureSurfaceSegment
{
public:
    MeshCurvatureFreeformSegment(
        const std::vector<CurvatureInfo>& ci,
        unsigned long minFacets,
        float tolMin,
        float tolMax,
        float c1,
        float c2
    )
        : MeshCurvatureSurfaceSegment(ci, minFacets)
        , c1(c1)
        , c2(c2)
        , toleranceMin(tolMin)
        , toleranceMax(tolMax)
    {}
    bool TestFacet(const MeshFacet& rclFacet) const override;
    const char* GetType() const override
    {
        return "Freeform";
    }

private:
    float c1, c2;
    float toleranceMin;
    float toleranceMax;
};

class MeshExport MeshSurfaceVisitor: public MeshFacetVisitor
{
public:
    MeshSurfaceVisitor(MeshSurfaceSegment& segm, std::vector<FacetIndex>& indices);
    bool AllowVisit(
        const MeshFacet& face,
        const MeshFacet&,
        FacetIndex,
        unsigned long,
        unsigned short neighbourIndex
    ) override;
    bool Visit(const MeshFacet& face, const MeshFacet&, FacetIndex ulFInd, unsigned long) override;

private:
    std::vector<FacetIndex>& indices;
    MeshSurfaceSegment& segm;
};

class MeshExport MeshSegmentAlgorithm
{
public:
    explicit MeshSegmentAlgorithm(const MeshKernel& kernel)
        : myKernel(kernel)
    {}
    void FindSegments(std::vector<MeshSurfaceSegmentPtr>&);

private:
    const MeshKernel& myKernel;
};

}  // namespace MeshCore

#endif  // MESHCORE_SEGMENTATION_H

	// SPDX-License-Identifier: LGPL-2.1-or-later

	/***************************************************************************
	* Copyright (c) 2012 Imetric 3D GmbH *
	* *
	* This file is part of the FreeCAD CAx development system. *
	* *
	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU Library General Public *
	* License as published by the Free Software Foundation; either *
	* version 2 of the License, or (at your option) any later version. *
	* *
	* This library 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 Library General Public License for more details. *
	* *
	* You should have received a copy of the GNU Library General Public *
	* License along with this library; see the file COPYING.LIB. If not, *
	* write to the Free Software Foundation, Inc., 59 Temple Place, *
	* Suite 330, Boston, MA 02111-1307, USA *
	* *
	***************************************************************************/

	#ifndef MESHCORE_SEGMENTATION_H
	#define MESHCORE_SEGMENTATION_H

	#include <memory>
	#include <vector>

	#include "Curvature.h"
	#include "MeshKernel.h"
	#include "Visitor.h"


	namespace MeshCore
	{

	class PlaneFit;
	class CylinderFit;
	class SphereFit;
	class MeshFacet;
	using MeshSegment = std::vector<FacetIndex>;

	class MeshExport MeshSurfaceSegment
	{
	public:
	explicit MeshSurfaceSegment(unsigned long minFacets)
	: minFacets(minFacets)
	{}
	virtual ~MeshSurfaceSegment() = default;

	MeshSurfaceSegment(const MeshSurfaceSegment&) = delete;
	MeshSurfaceSegment(MeshSurfaceSegment&&) = delete;
	MeshSurfaceSegment& operator=(const MeshSurfaceSegment&) = delete;
	MeshSurfaceSegment& operator=(MeshSurfaceSegment&&) = delete;

	virtual bool TestFacet(const MeshFacet& rclFacet) const = 0;
	virtual const char* GetType() const = 0;
	virtual void Initialize(FacetIndex);
	virtual bool TestInitialFacet(FacetIndex) const;
	virtual void AddFacet(const MeshFacet& rclFacet);
	void AddSegment(const std::vector<FacetIndex>&);
	const std::vector<MeshSegment>& GetSegments() const
	{
	return segments;
	}
	MeshSegment FindSegment(FacetIndex) const;

	private:
	std::vector<MeshSegment> segments;
	unsigned long minFacets;
	};
	using MeshSurfaceSegmentPtr = std::shared_ptr<MeshSurfaceSegment>;

	// --------------------------------------------------------

	class MeshExport MeshDistanceSurfaceSegment: public MeshSurfaceSegment
	{
	public:
	MeshDistanceSurfaceSegment(const MeshKernel& mesh, unsigned long minFacets, float tol)
	: MeshSurfaceSegment(minFacets)
	, kernel(mesh)
	, tolerance(tol)
	{}

	protected:
	// NOLINTBEGIN
	const MeshKernel& kernel;
	float tolerance;
	// NOLINTEND
	};

	class MeshExport MeshDistancePlanarSegment: public MeshDistanceSurfaceSegment
	{
	public:
	MeshDistancePlanarSegment(const MeshKernel& mesh, unsigned long minFacets, float tol);
	~MeshDistancePlanarSegment() override;

	MeshDistancePlanarSegment(const MeshDistancePlanarSegment&) = delete;
	MeshDistancePlanarSegment(MeshDistancePlanarSegment&&) = delete;
	MeshDistancePlanarSegment& operator=(const MeshDistancePlanarSegment&) = delete;
	MeshDistancePlanarSegment& operator=(MeshDistancePlanarSegment&&) = delete;

	bool TestFacet(const MeshFacet& face) const override;
	const char* GetType() const override
	{
	return "Plane";
	}
	void Initialize(FacetIndex) override;
	void AddFacet(const MeshFacet& face) override;

	private:
	Base::Vector3f basepoint;
	Base::Vector3f normal;
	PlaneFit* fitter;
	};

	class MeshExport AbstractSurfaceFit
	{
	public:
	AbstractSurfaceFit() = default;
	virtual ~AbstractSurfaceFit() = default;

	AbstractSurfaceFit(const AbstractSurfaceFit&) = delete;
	AbstractSurfaceFit(AbstractSurfaceFit&&) = delete;
	AbstractSurfaceFit& operator=(const AbstractSurfaceFit&) = delete;
	AbstractSurfaceFit& operator=(AbstractSurfaceFit&&) = delete;

	virtual const char* GetType() const = 0;
	virtual void Initialize(const MeshGeomFacet&) = 0;
	virtual bool TestTriangle(const MeshGeomFacet&) const = 0;
	virtual void AddTriangle(const MeshGeomFacet&) = 0;
	virtual bool Done() const = 0;
	virtual float Fit() = 0;
	virtual float GetDistanceToSurface(const Base::Vector3f&) const = 0;
	virtual std::vector<float> Parameters() const = 0;
	};

	class MeshExport PlaneSurfaceFit: public AbstractSurfaceFit
	{
	public:
	PlaneSurfaceFit();
	PlaneSurfaceFit(const Base::Vector3f& b, const Base::Vector3f& n);
	~PlaneSurfaceFit() override;

	PlaneSurfaceFit(const PlaneSurfaceFit&) = delete;
	PlaneSurfaceFit(PlaneSurfaceFit&&) = delete;
	PlaneSurfaceFit& operator=(const PlaneSurfaceFit&) = delete;
	PlaneSurfaceFit& operator=(PlaneSurfaceFit&&) = delete;

	const char* GetType() const override
	{
	return "Plane";
	}
	void Initialize(const MeshGeomFacet&) override;
	bool TestTriangle(const MeshGeomFacet&) const override;
	void AddTriangle(const MeshGeomFacet&) override;
	bool Done() const override;
	float Fit() override;
	float GetDistanceToSurface(const Base::Vector3f&) const override;
	std::vector<float> Parameters() const override;

	private:
	Base::Vector3f basepoint;
	Base::Vector3f normal;
	PlaneFit* fitter;
	};

	class MeshExport CylinderSurfaceFit: public AbstractSurfaceFit
	{
	public:
	CylinderSurfaceFit();
	CylinderSurfaceFit(const Base::Vector3f& b, const Base::Vector3f& a, float r);
	~CylinderSurfaceFit() override;

	CylinderSurfaceFit(const CylinderSurfaceFit&) = delete;
	CylinderSurfaceFit(CylinderSurfaceFit&&) = delete;
	CylinderSurfaceFit& operator=(const CylinderSurfaceFit&) = delete;
	CylinderSurfaceFit& operator=(CylinderSurfaceFit&&) = delete;

	const char* GetType() const override
	{
	return "Cylinder";
	}
	void Initialize(const MeshGeomFacet&) override;
	bool TestTriangle(const MeshGeomFacet&) const override;
	void AddTriangle(const MeshGeomFacet&) override;
	bool Done() const override;
	float Fit() override;
	float GetDistanceToSurface(const Base::Vector3f&) const override;
	std::vector<float> Parameters() const override;

	private:
	Base::Vector3f basepoint;
	Base::Vector3f axis;
	float radius;
	CylinderFit* fitter;
	};

	class MeshExport SphereSurfaceFit: public AbstractSurfaceFit
	{
	public:
	SphereSurfaceFit();
	SphereSurfaceFit(const Base::Vector3f& c, float r);
	~SphereSurfaceFit() override;

	SphereSurfaceFit(const SphereSurfaceFit&) = delete;
	SphereSurfaceFit(SphereSurfaceFit&&) = delete;
	SphereSurfaceFit& operator=(const SphereSurfaceFit&) = delete;
	SphereSurfaceFit& operator=(SphereSurfaceFit&&) = delete;

	const char* GetType() const override
	{
	return "Sphere";
	}
	void Initialize(const MeshGeomFacet&) override;
	bool TestTriangle(const MeshGeomFacet&) const override;
	void AddTriangle(const MeshGeomFacet&) override;
	bool Done() const override;
	float Fit() override;
	float GetDistanceToSurface(const Base::Vector3f&) const override;
	std::vector<float> Parameters() const override;

	private:
	Base::Vector3f center;
	float radius;
	SphereFit* fitter;
	};

	class MeshExport MeshDistanceGenericSurfaceFitSegment: public MeshDistanceSurfaceSegment
	{
	public:
	MeshDistanceGenericSurfaceFitSegment(
	AbstractSurfaceFit*,
	const MeshKernel& mesh,
	unsigned long minFacets,
	float tol
	);
	~MeshDistanceGenericSurfaceFitSegment() override;

	MeshDistanceGenericSurfaceFitSegment(const MeshDistanceGenericSurfaceFitSegment&) = delete;
	MeshDistanceGenericSurfaceFitSegment(MeshDistanceGenericSurfaceFitSegment&&) = delete;
	MeshDistanceGenericSurfaceFitSegment& operator=(
	const MeshDistanceGenericSurfaceFitSegment&
	) = delete;
	MeshDistanceGenericSurfaceFitSegment& operator=(MeshDistanceGenericSurfaceFitSegment&&) = delete;

	bool TestFacet(const MeshFacet& face) const override;
	const char* GetType() const override
	{
	return fitter->GetType();
	}
	void Initialize(FacetIndex) override;
	bool TestInitialFacet(FacetIndex) const override;
	void AddFacet(const MeshFacet& face) override;
	std::vector<float> Parameters() const;

	private:
	AbstractSurfaceFit* fitter;
	};

	// --------------------------------------------------------

	class MeshExport MeshCurvatureSurfaceSegment: public MeshSurfaceSegment
	{
	public:
	MeshCurvatureSurfaceSegment(const std::vector<CurvatureInfo>& ci, unsigned long minFacets)
	: MeshSurfaceSegment(minFacets)
	, info(ci)
	{}

	const CurvatureInfo& GetInfo(std::size_t pos) const
	{
	return info.at(pos);
	}

	private:
	const std::vector<CurvatureInfo>& info;
	};

	class MeshExport MeshCurvaturePlanarSegment: public MeshCurvatureSurfaceSegment
	{
	public:
	MeshCurvaturePlanarSegment(const std::vector<CurvatureInfo>& ci, unsigned long minFacets, float tol)
	: MeshCurvatureSurfaceSegment(ci, minFacets)
	, tolerance(tol)
	{}
	bool TestFacet(const MeshFacet& rclFacet) const override;
	const char* GetType() const override
	{
	return "Plane";
	}

	private:
	float tolerance;
	};

	class MeshExport MeshCurvatureCylindricalSegment: public MeshCurvatureSurfaceSegment
	{
	public:
	MeshCurvatureCylindricalSegment(
	const std::vector<CurvatureInfo>& ci,
	unsigned long minFacets,
	float tolMin,
	float tolMax,
	float curv
	)
	: MeshCurvatureSurfaceSegment(ci, minFacets)
	, curvature(curv)
	, toleranceMin(tolMin)
	, toleranceMax(tolMax)
	{}
	bool TestFacet(const MeshFacet& rclFacet) const override;
	const char* GetType() const override
	{
	return "Cylinder";
	}

	private:
	float curvature;
	float toleranceMin;
	float toleranceMax;
	};

	class MeshExport MeshCurvatureSphericalSegment: public MeshCurvatureSurfaceSegment
	{
	public:
	MeshCurvatureSphericalSegment(
	const std::vector<CurvatureInfo>& ci,
	unsigned long minFacets,
	float tol,
	float curv
	)
	: MeshCurvatureSurfaceSegment(ci, minFacets)
	, curvature(curv)
	, tolerance(tol)
	{}
	bool TestFacet(const MeshFacet& rclFacet) const override;
	const char* GetType() const override
	{
	return "Sphere";
	}

	private:
	float curvature;
	float tolerance;
	};

	class MeshExport MeshCurvatureFreeformSegment: public MeshCurvatureSurfaceSegment
	{
	public:
	MeshCurvatureFreeformSegment(
	const std::vector<CurvatureInfo>& ci,
	unsigned long minFacets,
	float tolMin,
	float tolMax,
	float c1,
	float c2
	)
	: MeshCurvatureSurfaceSegment(ci, minFacets)
	, c1(c1)
	, c2(c2)
	, toleranceMin(tolMin)
	, toleranceMax(tolMax)
	{}
	bool TestFacet(const MeshFacet& rclFacet) const override;
	const char* GetType() const override
	{
	return "Freeform";
	}

	private:
	float c1, c2;
	float toleranceMin;
	float toleranceMax;
	};

	class MeshExport MeshSurfaceVisitor: public MeshFacetVisitor
	{
	public:
	MeshSurfaceVisitor(MeshSurfaceSegment& segm, std::vector<FacetIndex>& indices);
	bool AllowVisit(
	const MeshFacet& face,
	const MeshFacet&,
	FacetIndex,
	unsigned long,
	unsigned short neighbourIndex
	) override;
	bool Visit(const MeshFacet& face, const MeshFacet&, FacetIndex ulFInd, unsigned long) override;

	private:
	std::vector<FacetIndex>& indices;
	MeshSurfaceSegment& segm;
	};

	class MeshExport MeshSegmentAlgorithm
	{
	public:
	explicit MeshSegmentAlgorithm(const MeshKernel& kernel)
	: myKernel(kernel)
	{}
	void FindSegments(std::vector<MeshSurfaceSegmentPtr>&);

	private:
	const MeshKernel& myKernel;
	};

	} // namespace MeshCore

	#endif // MESHCORE_SEGMENTATION_H