meshgenerator.h

Go to the documentation of this file.

 
#ifndef OPENSWMMVIS_MESH_MESHGENERATOR_H
#define OPENSWMMVIS_MESH_MESHGENERATOR_H
 
#include "meshresult.h"
#include "meshpatch.h"
#include "meshquadmerge.h"
#include "meshquadcleanup.h"
#include "meshquadmatch.h"
#include "meshquadregion.h"
#include "trirefinehook.h"
 
#include <QHash>
#include <QPointF>
#include <QPolygonF>
#include <QString>
#include <QVector>
 
namespace mesh {
 
struct ConstraintSegment
{
    QVector<QPointF> path;     
    int              marker = 0; 
    QString          tag;      
};
 
struct SteinerPoint
{
    QPointF xy;
    int     marker = 0;        
    QString tag;               
    double  z      = 0.0;      
    bool    hasZ   = false;    
};
 
struct RegionMarker
{
    QPointF xy;                
    double  attribute = 0.0;   
    double  maxArea   = -1.0;  
    QString tag;               
};
 
struct GenerationOptions
{
    double maxArea     = 0.0;     
    double minAngle    = 26.0;    
    bool   allowSteiner = true;   
    bool   conformingDelaunay = false; 
    int    maxSteinerPoints   = -1; 
    bool   quiet       = true;    
    QString customSwitchString;   
 
    // ── Mixed tri-quad output (TRI_QUAD_MESHING_PLAN §3) ──────────────
    bool             mergeTrianglePairs = false;
    QuadMergeOptions quadMerge;
    double           patchSnapEps = 0.0;
 
    // ── Quad regions (QUAD_MESHING_REDESIGN_PLAN_2026-09-06.md §3–§4) ──
    QuadQualityBounds quadRegionBounds;
    QuadCleanupOptions quadCleanup;
    double quadRegionDefaultSpacing = 0.0;
};
 
struct QuadRegionReport
{
    int            index = -1;
    QuadRegionMode requested = QuadRegionMode::Auto;
    QuadRegionMode resolved  = QuadRegionMode::Free;   
    double  spacing = 0.0;
    int     quads = 0, triangles = 0;                    
    int     templateQuads = 0, gapQuads = 0;
    int     generatedPoints = 0, droppedSteiners = 0;    
    int     doubletsRemoved = 0, diagonalSwaps = 0, verticesMoved = 0;
    double  minScaledJacobian = 1.0, medianRectangularity = 0.0;
    QString message;                                     
};
 
class MeshGenerator
{
public:
    MeshGenerator() = default;
 
    void setDomain(const QPolygonF &outerBoundary);
 
    void setDomains(const QVector<QPolygonF> &outerBoundaries);
 
    void addDomain(const QPolygonF &outerBoundary);
 
    void addConstraintSegment(const ConstraintSegment &seg);
    void addSteinerPoint(const SteinerPoint &pt);
    void reserveSteinerPoints(qsizetype additional);
    void addHole(const QPointF &interiorPointInsideHole);
    void addRegion(const RegionMarker &region);
    void addPatch(const PatchMesh &patch);
    void addQuadRegion(const QuadRegion &region);
    [[nodiscard]] const QVector<QuadRegionReport> &quadRegionReports() const { return m_quadReports; }
    void setOptions(const GenerationOptions &opts);
 
    void setRefineHook(const RefineHook &hook);
 
    [[nodiscard]] MeshResult generate() const;
 
    [[nodiscard]] QString tagForVertexMarker(int marker) const;
    [[nodiscard]] QString tagForEdgeMarker(int marker) const;
 
private:
    QVector<QPolygonF>         m_domains;
    QVector<ConstraintSegment> m_segments;
    QVector<SteinerPoint>      m_steiners;
    QVector<QPointF>           m_holes;
    QVector<RegionMarker>      m_regions;
    QVector<PatchMesh>         m_patches;
    QVector<QuadRegion>        m_quadRegions;
    mutable QVector<QuadRegionReport> m_quadReports;
    GenerationOptions          m_opts;
    RefineHook                 m_refineHook;
 
    // Filled in during generate(); exposed so callers don't have to maintain
    // a parallel marker→tag map. mutable: generate() is logically const for
    // the Inputs but builds these tables.
    mutable QHash<int, QString>     m_vertexTagByMarker;
    mutable QHash<int, QString>     m_edgeTagByMarker;
    mutable QHash<int, QString>     m_triangleTagByRegionId;
};
 
} // namespace mesh
 
#endif // OPENSWMMVIS_MESH_MESHGENERATOR_H