editgeometry.h

Go to the documentation of this file.

 
#ifndef EDITGEOMETRY_H
#define EDITGEOMETRY_H
 
#include <QPointF>
#include <QVector>
 
namespace EditGeometry
{
 
constexpr double kCoincidenceTol = 1e-6;
 
[[nodiscard]] QVector<QPointF> cleanPolyline(const QVector<QPointF> &v,
                                             double tol = kCoincidenceTol);
 
[[nodiscard]] QVector<QPointF> cleanPolygonRing(const QVector<QPointF> &v,
                                                double tol = kCoincidenceTol);
 
[[nodiscard]] QVector<QPointF> orientInteriorToEndpoints(
    QVector<QPointF> interior, const QPointF &from, const QPointF &to);
 
[[nodiscard]] double polylineLength(const QVector<QPointF> &vertices);
 
[[nodiscard]] QVector<QPointF> replacedAt(const QVector<QPointF> &vertices,
                                          int index,
                                          const QPointF &newPt);
 
[[nodiscard]] QVector<QPointF> insertedAt(const QVector<QPointF> &vertices,
                                          int index,
                                          const QPointF &newPt);
 
[[nodiscard]] QVector<QPointF> removedAt(const QVector<QPointF> &vertices,
                                         int index);
 
[[nodiscard]] double distanceToPolyline(const QVector<QPointF> &vertices,
                                        const QPointF &point,
                                        int *segmentIndex = nullptr,
                                        QPointF *closestPoint = nullptr);
 
[[nodiscard]] double polygonArea(const QVector<QPointF> &polygon);
 
// ===========================================================================
// Multi-ring polygons (polygons with holes)
// ===========================================================================
//
// A shared value type for a polygon that owns one exterior ring plus zero or
// more interior rings (holes). Rings are stored OPEN (no repeated closing
// vertex), matching cleanPolygonRing() and the SWMM [POLYGONS] convention.
// This is the single geometry representation consumed by rendering, meshing,
// editing, and I/O so there is no parallel hole encoding.
 
struct RingPolygon
{
    QVector<QPointF>          exterior;   
    QVector<QVector<QPointF>> interiors;  
 
    [[nodiscard]] bool isEmpty()   const { return exterior.size() < 3; }
    [[nodiscard]] int  holeCount() const { return static_cast<int>(interiors.size()); }
};
 
[[nodiscard]] double signedRingArea(const QVector<QPointF> &ring);
 
[[nodiscard]] bool pointInRing(const QVector<QPointF> &ring, const QPointF &pt);
 
[[nodiscard]] RingPolygon normalizeRingPolygon(RingPolygon p,
                                               double tol = kCoincidenceTol);
 
[[nodiscard]] double netArea(const RingPolygon &p);
 
[[nodiscard]] bool containsPoint(const RingPolygon &p, const QPointF &pt);
 
[[nodiscard]] QPointF interiorPoint(const QVector<QPointF> &ring);
 
enum class RingValidity
{
    Ok,
    TooFewVertices,      
    SelfIntersecting,    
    HoleOutsideExterior, 
    HolesOverlap         
};
 
[[nodiscard]] RingValidity validateRingPolygon(const RingPolygon &p);
 
} // namespace EditGeometry
 
#endif // EDITGEOMETRY_H