featuregeometry.h

Go to the documentation of this file.

 
#ifndef FEATUREGEOMETRY_H
#define FEATUREGEOMETRY_H
 
#include <QPointF>
#include <QPolygonF>
#include <QRectF>
#include <QString>
#include <QVector>
 
class OGRGeometry;
class OGRSpatialReference;
 
namespace openswmmvis::feature {
 
enum class GeometryType
{
    None = 0,
    Point,
    LineString,
    Polygon,
    MultiPoint,
    MultiLineString,
    MultiPolygon
};
 
[[nodiscard]] QString geometryTypeLabel(GeometryType t);
 
[[nodiscard]] QString geometryTypeToken(GeometryType t);
 
[[nodiscard]] GeometryType geometryTypeFromToken(const QString &token);
 
[[nodiscard]] bool isMultiType(GeometryType t);
 
[[nodiscard]] GeometryType toMultiType(GeometryType t);
 
struct Ring
{
    QVector<QPointF> pts;
    QVector<double>  z;
 
    [[nodiscard]] bool isEmpty()  const { return pts.isEmpty(); }
    [[nodiscard]] int  size()     const { return pts.size(); }
 
    [[nodiscard]] bool hasZ() const
    { return !pts.isEmpty() && z.size() == pts.size(); }
 
    [[nodiscard]] double zAt(int i) const;
 
    void syncZLength();
 
    void clearZ() { z.clear(); }
 
    void ensureZ();
 
    [[nodiscard]] QPolygonF toPolygon() const;
    [[nodiscard]] QRectF    boundingRect() const;
 
    [[nodiscard]] double signedArea() const;
 
    [[nodiscard]] double length2D() const;
 
    [[nodiscard]] bool isSimpleRing() const;
 
    void normalizeCCW();
 
    [[nodiscard]] bool containsPoint(const QPointF &p) const;
 
    void insertVertex(int index, const QPointF &p, double zVal);
 
    void removeVertex(int index);
 
    void moveVertex(int index, const QPointF &p);
 
    int densify(double spacing);
 
    [[nodiscard]] bool operator==(const Ring &o) const;
    [[nodiscard]] bool operator!=(const Ring &o) const { return !(*this == o); }
};
 
struct Part
{
    Ring          exterior;
    QVector<Ring> holes;     
 
    [[nodiscard]] bool isEmpty() const { return exterior.isEmpty(); }
    [[nodiscard]] QRectF boundingRect() const;
 
    [[nodiscard]] double netArea() const;
 
    [[nodiscard]] bool containsPoint(const QPointF &p) const;
 
    void normalizeOrientation();
 
    [[nodiscard]] bool operator==(const Part &o) const;
    [[nodiscard]] bool operator!=(const Part &o) const { return !(*this == o); }
};
 
class FeatureGeometry
{
public:
    FeatureGeometry() = default;
    explicit FeatureGeometry(GeometryType type) : m_type(type) {}
 
    [[nodiscard]] GeometryType type() const { return m_type; }
    void setType(GeometryType t) { m_type = t; }
 
    [[nodiscard]] bool isEmpty() const;
    [[nodiscard]] bool isValid() const { return m_type != GeometryType::None && !isEmpty(); }
 
    [[nodiscard]] const QVector<Part> &parts() const { return m_parts; }
    [[nodiscard]] QVector<Part> &parts() { return m_parts; }
    [[nodiscard]] int partCount() const { return m_parts.size(); }
 
    void addPart(const Part &p) { m_parts.append(p); }
    void clear() { m_parts.clear(); }
 
    [[nodiscard]] int vertexCount() const;
 
    [[nodiscard]] bool hasZ() const;
 
    [[nodiscard]] int unsampledZCount() const;
 
    [[nodiscard]] bool zRange(double &minZ, double &maxZ) const;
 
    [[nodiscard]] QRectF boundingRect() const;
 
    [[nodiscard]] double area() const;
 
    [[nodiscard]] double length() const;
 
    void setHasZ(bool on);
 
    int densify(double spacing);
 
    void normalizeOrientation();
 
    [[nodiscard]] bool validate(GeometryType expected, QString *reason = nullptr) const;
 
    // ----- OGR bridge -----------------------------------------------------
 
    [[nodiscard]] static FeatureGeometry fromOGR(const OGRGeometry *g);
 
    [[nodiscard]] OGRGeometry *toOGR(OGRSpatialReference *srs = nullptr) const;
 
    [[nodiscard]] static int ogrTypeFor(GeometryType t, bool withZ);
 
    [[nodiscard]] bool operator==(const FeatureGeometry &o) const;
    [[nodiscard]] bool operator!=(const FeatureGeometry &o) const { return !(*this == o); }
 
private:
    GeometryType  m_type = GeometryType::None;
    QVector<Part> m_parts;
};
 
}   // namespace openswmmvis::feature
 
#endif // FEATUREGEOMETRY_H