Loading...
Searching...
No Matches
meshquadquality.h
Go to the documentation of this file.
1
19
20#ifndef OPENSWMMVIS_MESH_MESHQUADQUALITY_H
21#define OPENSWMMVIS_MESH_MESHQUADQUALITY_H
22
23#include "mesh/meshresult.h"
24
25#include <QPointF>
26#include <QVector>
27#include <algorithm>
28#include <cmath>
29#include <limits>
30
31namespace mesh
32{
33
38 double minAngleDeg = 60.0;
39 double maxAngleDeg = 120.0;
42 double minScaledJacobian = 0.866;
43 double maxAspect = 2.0;
44};
45
49 double minAngleDeg = 0.0;
50 double maxAngleDeg = 0.0;
51 double scaledJacobian = 0.0;
52 double rectangularity = 0.0;
53 double aspect = 1.0;
54 double skew =
55 0.0;
56 double area = 0.0;
57 bool convex = false;
58};
59
78inline QuadQuality quadQuality(const QPointF &a, const QPointF &b, const QPointF &c,
79 const QPointF &d)
80{
82 const QPointF p[4] = {a, b, c, d};
83 QPointF local[4];
84 double xScale = 0.0, yScale = 0.0;
85 for (int i = 0; i < 4; ++i) {
86 if (!std::isfinite(p[i].x()) || !std::isfinite(p[i].y()))
87 return {};
88 local[i] = p[i] - a;
89 if (!std::isfinite(local[i].x()) || !std::isfinite(local[i].y()))
90 return {};
91 xScale = std::max(xScale, std::abs(local[i].x()));
92 yScale = std::max(yScale, std::abs(local[i].y()));
93 }
94 if (!(xScale > 0.0) || !(yScale > 0.0))
95 return {};
96 // Local coordinates remove origin cancellation. Independent axis scales
97 // keep products finite even for representable highly anisotropic quads.
98 const auto areaCross = [&](int i, int j) {
99 return (local[i].x() / xScale) * (local[j].y() / yScale) -
100 (local[i].y() / yScale) * (local[j].x() / xScale);
101 };
102 const double area2 = areaCross(1, 2) + areaCross(2, 3);
103 if (area2 == 0.0 || !std::isfinite(area2))
104 return {};
105 const double orient = area2 > 0.0 ? 1.0 : -1.0;
106 // Rescale through exponents: neither xScale*yScale nor twice the final
107 // area needs to be representable as an intermediate value.
108 int areaExponent = 0, xExponent = 0, yExponent = 0;
109 const double areaMantissa = std::frexp(std::abs(area2), &areaExponent);
110 const double xMantissa = std::frexp(xScale, &xExponent);
111 const double yMantissa = std::frexp(yScale, &yExponent);
112 q.area =
113 std::scalbn(areaMantissa * xMantissa * yMantissa, areaExponent + xExponent + yExponent - 1);
114 if (!(q.area > 0.0) || !std::isfinite(q.area))
115 return {};
116
117 q.minAngleDeg = 360.0;
118 q.maxAngleDeg = 0.0;
119 q.scaledJacobian = 1.0;
120 q.convex = true;
121 double maxDev = 0.0;
122 double side[4];
123 for (int i = 0; i < 4; ++i) {
124 const QPointF e1 = p[(i + 3) % 4] - p[i], e2 = p[(i + 1) % 4] - p[i];
125 const double l1 = std::hypot(e1.x(), e1.y()), l2 = std::hypot(e2.x(), e2.y());
126 if (!(l1 > 0.0) || !(l2 > 0.0) || !std::isfinite(l1) || !std::isfinite(l2))
127 return {};
128 side[i] = l2;
129 const QPointF u1 = e1 / l1, u2 = e2 / l2;
130 // Normalize first; raw cross/dot products and length products may
131 // overflow or underflow even when the angular metrics are well-defined.
132 const double cross = std::clamp(u2.x() * u1.y() - u2.y() * u1.x(), -1.0, 1.0);
133 const double dot = std::clamp(u1.x() * u2.x() + u1.y() * u2.y(), -1.0, 1.0);
134 const double ang = std::atan2(std::abs(cross), dot) * 180.0 / M_PI;
135 const double sj = cross * orient;
136 if (sj <= 0.0)
137 q.convex = false;
138 q.scaledJacobian = std::min(q.scaledJacobian, sj);
139 q.minAngleDeg = std::min(q.minAngleDeg, ang);
140 q.maxAngleDeg = std::max(q.maxAngleDeg, ang);
141 maxDev = std::max(maxDev, std::abs(ang - 90.0));
142 }
143 q.rectangularity = std::clamp(1.0 - maxDev / 90.0, 0.0, 1.0);
144 const double s02 = 0.5 * side[0] + 0.5 * side[2];
145 const double s13 = 0.5 * side[1] + 0.5 * side[3];
146 const double lo = std::min(s02, s13), hi = std::max(s02, s13);
147 if (!(lo > 0.0))
148 return {};
149 q.aspect = hi / lo;
150 if (!std::isfinite(q.aspect))
151 return {};
152 const QPointF d1 = c - a, d2 = d - b;
153 const double ld1 = std::hypot(d1.x(), d1.y()), ld2 = std::hypot(d2.x(), d2.y());
154 if (!(ld1 > 0.0) || !(ld2 > 0.0) || !std::isfinite(ld1) || !std::isfinite(ld2))
155 return {};
156 const QPointF ud1 = d1 / ld1, ud2 = d2 / ld2;
157 q.skew = std::clamp(std::abs(ud1.x() * ud2.x() + ud1.y() * ud2.y()), 0.0, 1.0);
158 return q;
159}
160
173inline QuadQuality quadQuality(const QVector<MeshVertex> &vertices, const MeshTriangle &t)
174{
175 return quadQuality(vertices[t.v0].xy, vertices[t.v1].xy, vertices[t.v2].xy, vertices[t.v3].xy);
176}
177
178namespace quadquality_detail
179{
189inline bool validMetrics(const QuadQuality &q)
190{
191 // These checks also protect callers constructing QuadQuality manually.
192 return q.convex && std::isfinite(q.area) && q.area > 0.0 && std::isfinite(q.minAngleDeg) &&
193 std::isfinite(q.maxAngleDeg) && q.minAngleDeg > 0.0 && q.maxAngleDeg < 180.0 &&
194 q.minAngleDeg <= q.maxAngleDeg && std::isfinite(q.scaledJacobian) &&
195 q.scaledJacobian > 0.0 && q.scaledJacobian <= 1.0 && std::isfinite(q.rectangularity) &&
196 q.rectangularity >= 0.0 && q.rectangularity <= 1.0 && std::isfinite(q.aspect) &&
197 q.aspect >= 1.0 && std::isfinite(q.skew) && q.skew >= 0.0 && q.skew <= 1.0;
198}
199
207inline bool finiteBounds(const QuadQualityBounds &b)
208{
209 return std::isfinite(b.minAngleDeg) && std::isfinite(b.maxAngleDeg) &&
210 std::isfinite(b.minScaledJacobian) && std::isfinite(b.maxAspect);
211}
212} // namespace quadquality_detail
213
227inline bool quadAcceptable(const QuadQuality &q, const QuadQualityBounds &b)
228{
230 return false;
232 return false;
234 return false;
235 if (b.maxAspect > 0.0 && q.aspect > b.maxAspect)
236 return false;
237 return true;
238}
239
254inline double quadScore(const QuadQuality &q, const QuadQualityBounds &b)
255{
257 return 0.0;
258 const double aspectTerm =
259 (b.maxAspect > 0.0 && q.aspect > b.maxAspect) ? b.maxAspect / q.aspect : 1.0;
260 return std::clamp(q.scaledJacobian * q.rectangularity * aspectTerm, 0.0, 1.0);
261}
262
278inline double triangleScaledJacobian(const QPointF &a, const QPointF &b, const QPointF &c)
279{
280 const QPointF p[3] = {a, b, c};
281 double mn = 2.0;
282 double area2 = (b.x() - a.x()) * (c.y() - a.y()) - (c.x() - a.x()) * (b.y() - a.y());
283 const double orient = area2 >= 0.0 ? 1.0 : -1.0;
284 for (int i = 0; i < 3; ++i) {
285 const QPointF e1 = p[(i + 2) % 3] - p[i], e2 = p[(i + 1) % 3] - p[i];
286 const double l1 = std::hypot(e1.x(), e1.y()), l2 = std::hypot(e2.x(), e2.y());
287 if (l1 <= 0.0 || l2 <= 0.0)
288 return 0.0;
289 mn = std::min(mn, (e2.x() * e1.y() - e2.y() * e1.x()) * orient / (l1 * l2));
290 }
291 return std::min(mn, 1.0);
292}
293
305inline double cellCornerAngleDeg(const QVector<MeshVertex> &v, const MeshTriangle &t, int i)
306{
307 const int n = t.vertexCount();
308 const QPointF &prev = v[t.vertex((i + n - 1) % n)].xy;
309 const QPointF &cur = v[t.vertex(i)].xy;
310 const QPointF &next = v[t.vertex((i + 1) % n)].xy;
311 const QPointF e1 = prev - cur, e2 = next - cur;
312 return std::atan2(std::abs(e2.x() * e1.y() - e2.y() * e1.x()),
313 e1.x() * e2.x() + e1.y() * e2.y()) *
314 180.0 / M_PI;
315}
316
317} // namespace mesh
318
319#endif // OPENSWMMVIS_MESH_MESHQUADQUALITY_H
value types for the 2D mesh generator.
bool validMetrics(const QuadQuality &q)
Check the internal finite/range/convexity invariants required before acceptance or scoring.
Definition meshquadquality.h:189
bool finiteBounds(const QuadQualityBounds &b)
Check every supplied quality threshold is finite.
Definition meshquadquality.h:207
The Qt-facing MeshKit API (meshkit::core_qt, meshkit::model_qt, meshkit::io_qt): mesh value types and...
QuadQuality quadQuality(const QPointF &a, const QPointF &b, const QPointF &c, const QPointF &d)
Measure one quadrilateral using cyclic corners and translation/scale-resistant planar arithmetic.
Definition meshquadquality.h:78
bool quadAcceptable(const QuadQuality &q, const QuadQualityBounds &b)
Apply inclusive hard angle/Jacobian/aspect limits to a valid convex metric record.
Definition meshquadquality.h:227
double quadScore(const QuadQuality &q, const QuadQualityBounds &b)
Rank valid convex quads by Jacobian, rectangularity and a soft aspect penalty.
Definition meshquadquality.h:254
double cellCornerAngleDeg(const QVector< MeshVertex > &v, const MeshTriangle &t, int i)
Compute the unsigned corner angle of a triangle or quad.
Definition meshquadquality.h:305
double triangleScaledJacobian(const QPointF &a, const QPointF &b, const QPointF &c)
Compute the minimum orientation-normalized corner sine of a triangle.
Definition meshquadquality.h:278
A cell in the mesh — a triangle or (since the engine's mixed tri-quad meshes, workplans/TRI_QUAD_MESH...
Definition meshresult.h:64
int v2
Third corner, cyclically after v1.
Definition meshresult.h:71
int v1
Second corner, cyclically after v0.
Definition meshresult.h:71
int vertex(int k) const noexcept
Fetch one stored corner identifier without a vertex-array lookup.
Definition meshresult.h:115
int v3
Fourth vertex of a quadrilateral; -1 = triangle.
Definition meshresult.h:72
int vertexCount() const noexcept
Report the logical corner count selected by the fourth-vertex sentinel.
Definition meshresult.h:105
int v0
First corner: index into MeshResult::vertices (not range-checked here).
Definition meshresult.h:71
Acceptance bounds shared by pairing, cleanup, smoothing and the legacy tri-pair merge.
Definition meshquadquality.h:37
double minAngleDeg
Smallest allowed interior angle, degrees (inclusive).
Definition meshquadquality.h:38
double maxAspect
longest / shortest side (opposite-side means). <= 0 = unbounded.
Definition meshquadquality.h:43
double maxAngleDeg
Largest allowed interior angle, degrees (inclusive).
Definition meshquadquality.h:39
double minScaledJacobian
Smallest allowed scaled Jacobian (min corner sine, inclusive).
Definition meshquadquality.h:42
Shape metrics of one quadrilateral, as computed by quadQuality().
Definition meshquadquality.h:48
bool convex
all four cross products share the sign of the total area.
Definition meshquadquality.h:57
double aspect
mean(s0,s2) vs mean(s1,s3), >= 1.
Definition meshquadquality.h:53
double scaledJacobian
min_i sin(theta_i), signed (negative = folded).
Definition meshquadquality.h:51
double maxAngleDeg
Largest unsigned interior angle, degrees.
Definition meshquadquality.h:50
double rectangularity
1 - max_i |theta_i - 90| / 90.
Definition meshquadquality.h:52
double skew
|cos(angle between diagonals)|; zero for perpendicular diagonals (e.g. squares/rhombi),...
Definition meshquadquality.h:54
double minAngleDeg
Smallest unsigned interior angle, degrees.
Definition meshquadquality.h:49
double area
positive finite area, evaluated in local coordinates.
Definition meshquadquality.h:56