Loading...
Searching...
No Matches
meshresolution.h
Go to the documentation of this file.
1// SPDX-License-Identifier: Apache-2.0
2
11
12#ifndef OPENSWMM_MESH_RESOLUTION_H
13#define OPENSWMM_MESH_RESOLUTION_H
14
15#include <QJsonObject>
16#include "terrainpolicy.h"
17#include <QString>
18#include <algorithm>
19#include <cmath>
20#include <optional>
21
22namespace mesh
23{
24
25// Shared by project settings, Preferences and the generation dialog.
26// Physical lengths are SI; absence means no maximum, inherit minimum,
27// automatic tolerance, or match-minimum averaging respectively.
35 double minimumM = 6.096;
54 int coarsenPasses = 0;
56 double transition = 2.0;
77 std::optional<double> minimumEdgeM;
80 CoarseningOrder coarseningOrder=CoarseningOrder::LegacyFlatness;
83 TerrainTolerancePolicy terrainTolerancePolicy; // SI metres, independent of display units.
84
89 bool refineFeatures = false, alignTerrain = true;
109
119 QString validate() const
120 {
121 auto positive = [](double v) { return std::isfinite(v) && v > 0 && v <= 1e12; };
122 if (int(sizing) < 0 || int(sizing) > 2)
123 return QStringLiteral("Invalid sizing rules version or mode.");
124 if(int(cellPlanning)<0 || int(cellPlanning)>1)
125 return QStringLiteral("Invalid cell planning policy.");
127 return QStringLiteral("Unified cell planning requires verified or strict sizing rules.");
128 if(coarseningOrder!=CoarseningOrder::LegacyFlatness && coarseningOrder!=CoarseningOrder::ResolutionAware)
129 return QStringLiteral("Invalid coarsening policy version or order.");
130 if(!terrainTolerancePolicy.valid() || terrainTolerancePolicy.referenceSize>1e12 || terrainTolerancePolicy.minimumTolerance>1e12 || terrainTolerancePolicy.maximumTolerance>1e12)
131 return QStringLiteral("Invalid resolution-weighted terrain tolerance policy.");
132 if((coarseningOrder==CoarseningOrder::ResolutionAware || terrainTolerancePolicy.mode==TerrainToleranceMode::TargetSize) && sizing==Sizing::Legacy)
133 return QStringLiteral("Resolution-weighted terrain or coarsening requires verified sizing.");
134 if(terrainTolerancePolicy.mode==TerrainToleranceMode::TargetSize) {
135 if(terrain!=Terrain::Adaptive)return QStringLiteral("Size-weighted tolerance requires adaptive terrain refinement.");
136 if(toleranceM && !std::isfinite(terrainTolerancePolicy.tolerance(*toleranceM,terrainTolerancePolicy.referenceSize)))
137 return QStringLiteral("The terrain tolerance floor exceeds its resolved cap.");
138 }
139 if (minimumEdgeM && !positive(*minimumEdgeM))
140 return QStringLiteral("The separate minimum edge requirement must be a positive finite length.");
142 return QStringLiteral("Choose verified or strict sizing to request a minimum edge length.");
143 if (!positive(minimumM))
144 return QStringLiteral("Minimum target cell size must be a positive finite length.");
147 if (v && !positive(*v))
148 return QStringLiteral(
149 "Specified sizes and tolerances must be positive finite lengths.");
151 return QStringLiteral("Coarsening passes must be between 0 and 10.");
153 return QStringLiteral("Terrain breakline count is out of range.");
154 if (maximumM && *maximumM < minimumM)
155 return QStringLiteral(
156 "Maximum target cell size must be at least the minimum target size.");
158 return QStringLiteral("Feature target size must be at least the minimum target size.");
160 return QStringLiteral(
161 "Feature target size exceeds the maximum target size. Increase the maximum or reduce the feature target.");
162 if (!std::isfinite(transition) || transition < 1.05)
163 return QStringLiteral("Size transition rate must be finite and at least 1.05.");
164 return {};
165 }
166
174 QJsonObject toJson() const
175 {
176 auto value = [](std::optional<double> v) {
177 return v ? QJsonValue(*v) : QJsonValue(QJsonValue::Null);
178 };
179 return {{"coarseningPolicy",QJsonObject{{"version",1},{"order",int(coarseningOrder)}}},
180 {"terrainTolerancePolicy",QJsonObject{{"version",1},{"mode",int(terrainTolerancePolicy.mode)},
181 {"referenceSizeM",terrainTolerancePolicy.referenceSize},{"minimumM",terrainTolerancePolicy.minimumTolerance},
182 {"maximumM",terrainTolerancePolicy.maximumTolerance}}}, {"sizingVersion", 1}, {"sizingMode", int(sizing)},
183 {"cellPlanningVersion",1},{"cellPlanningMode",int(cellPlanning)},
184 {"minimumEdgeM", value(minimumEdgeM)}, {"coarsenPasses", coarsenPasses},
185 {"minimumM", minimumM},
186 {"maximumM", value(maximumM)},
187 {"featureM", value(featureM)},
188 {"elevationToleranceM", value(toleranceM)},
189 {"breaklineToleranceM", value(breaklineToleranceM)},
190 {"averagingM", value(averagingM)},
191 {"minimumBreaklineLengthM", value(minimumBreaklineLengthM)},
192 {"maxBreaklines", maxBreaklines},
193 {"transition", transition},
194 {"refineFeatures", refineFeatures},
195 {"alignTerrain", alignTerrain},
196 {"terrain", terrain == Terrain::Adaptive ? "adaptive"
197 : terrain == Terrain::Legacy ? "legacy"
198 : "off"},
199 {"reference", reference == Reference::Averaged ? "averaged"
200 : reference == Reference::Full ? "full"
201 : "direct"}};
202 }
203
214 static ResolutionSettings fromJson(const QJsonObject &o)
215 {
217 auto value = [&](const char *key) -> std::optional<double> {
218 const auto v = o.value(QLatin1String(key));
219 return v.isDouble() ? std::optional<double>(v.toDouble()) : std::nullopt;
220 };
221 r.coarsenPasses = o.value("coarsenPasses").toInt(0);
222 const auto coarsening=o.value("coarseningPolicy").toObject();
223 r.coarseningOrder=CoarseningOrder(coarsening.value("order").toInt(0));
224 if(!coarsening.isEmpty() && coarsening.value("version").toInt()!=1)r.coarseningOrder=CoarseningOrder(-1);
225 const auto tolerancePolicy=o.value("terrainTolerancePolicy").toObject();
226 r.terrainTolerancePolicy.mode=TerrainToleranceMode(tolerancePolicy.value("mode").toInt(0));
227 if(!tolerancePolicy.isEmpty() && tolerancePolicy.value("version").toInt()!=1)r.terrainTolerancePolicy.mode=TerrainToleranceMode(-1);
228 r.terrainTolerancePolicy.referenceSize=tolerancePolicy.value("referenceSizeM").toDouble(10);
229 r.terrainTolerancePolicy.minimumTolerance=tolerancePolicy.value("minimumM").toDouble(0);
230 r.terrainTolerancePolicy.maximumTolerance=tolerancePolicy.value("maximumM").toDouble(0);
231
232 r.sizing = Sizing(o.value("sizingMode").toInt(0));
233 r.cellPlanning=CellPlanning(o.value("cellPlanningMode").toInt(0));
234 if(o.contains("cellPlanningVersion") && o.value("cellPlanningVersion").toInt()!=1)r.cellPlanning=CellPlanning(-1);
235 if (o.contains("sizingVersion") && o.value("sizingVersion").toInt() != 1)
236 r.sizing = Sizing(-1);
237 r.minimumEdgeM = value("minimumEdgeM");
238 r.minimumM = o.value("minimumM").toDouble(r.minimumM);
239 r.maximumM = value("maximumM");
240 r.featureM = value("featureM");
241 r.toleranceM = value("elevationToleranceM");
242 r.breaklineToleranceM = value("breaklineToleranceM");
243 r.minimumBreaklineLengthM = value("minimumBreaklineLengthM");
244 r.maxBreaklines = o.value("maxBreaklines").toInt(0);
245 r.averagingM = value("averagingM");
246 r.transition = o.value("transition").toDouble(r.transition);
247 r.refineFeatures = o.value("refineFeatures").toBool(false);
248 r.alignTerrain = o.value("alignTerrain").toBool(true);
249 const QString mode = o.value("terrain").toString(), ref = o.value("reference").toString();
250 r.terrain = mode == "off" ? Terrain::Off
251 : mode == "legacy" ? Terrain::Legacy
253 r.reference = ref == "direct" ? Reference::Direct
254 : ref == "full" ? Reference::Full
256 return r;
257 }
258
259 // Version 1 stored distance controls in metres and combo choices as indices.
275 static ResolutionSettings migrate(const QJsonObject &c, ResolutionSettings r, double extentM)
276 {
277 r.coarsenPasses = 0;
278 r.coarseningOrder=CoarseningOrder::LegacyFlatness;
282 r.minimumEdgeM.reset();
283 double feature = c.value("meshCellSizeSpin").toDouble(r.featureM.value_or(r.minimumM));
284 if (feature <= 0)
285 feature = extentM > 0 ? extentM / 100.0 : 1.0;
286 r.featureM = feature;
287 r.minimumM = c.value("meshMinCellSizeSpin").toDouble(r.minimumM);
288 if (r.minimumM <= 0)
289 r.minimumM = feature / 4;
290 r.maximumM = feature * c.value("meshCoarsenSpin").toDouble(1000.0);
291 const double tol = c.value("meshTerrainTolSpin").toDouble(r.toleranceM.value_or(0));
292 r.toleranceM = tol > 0 ? std::optional<double>(tol) : std::nullopt;
294 r.refineFeatures = c.value("meshRefineFeaturesBox").toBool(r.refineFeatures);
295 r.alignTerrain = c.value("meshTerrainBreaklinesBox").toBool(r.alignTerrain);
296 r.maxBreaklines = c.value("meshMaxBreaklinesSpin").toInt(0);
297 r.transition = c.value("meshSizeRatioSpin").toDouble(r.transition);
298 const int mode = c.value("meshTerrainModeCombo").toInt(0),
299 ref = c.value("meshTerrainReferenceCombo").toInt(0);
300 r.terrain = mode == 2 ? Terrain::Off : mode == 1 ? Terrain::Legacy : Terrain::Adaptive;
301 r.reference = ref == 2 ? Reference::Direct
302 : ref == 1 ? Reference::Full
304 // Legacy zero explicitly disabled refinement, unlike adaptive auto.
305 if (r.terrain == Terrain::Legacy && !r.toleranceM)
307 return r;
308 }
309};
310}
311#endif
The Qt-facing MeshKit API (meshkit::core_qt, meshkit::model_qt, meshkit::io_qt): mesh value types and...
CoarseningOrder
Order in which terrain coarsening tries to remove free vertices.
Definition terrainpolicy.hpp:10
TerrainToleranceMode
How TerrainTolerancePolicy::tolerance() derives a footprint's terrain tolerance.
Definition terrainpolicy.hpp:19
Unit-independent mesh resolution choices (lengths in SI metres) with JSON round-trip,...
Definition meshresolution.h:33
CellPlanning
Quad patch planning: Legacy per-region routing, or Unified joint planning.
Definition meshresolution.h:72
@ Legacy
Per-region quad routing.
Definition meshresolution.h:73
@ Unified
Joint planning of all quad patches.
Definition meshresolution.h:74
enum mesh::ResolutionSettings::CellPlanning cellPlanning
Patch planning policy (default Legacy); Unified requires non-Legacy sizing.
Reference
Terrain reference: Averaged DEM, Full DEM, or Direct (full DEM read without a local copy).
Definition meshresolution.h:104
@ Averaged
Averaged DEM.
Definition meshresolution.h:105
@ Full
Full-resolution DEM.
Definition meshresolution.h:106
@ Direct
Full DEM read directly, without a local copy.
Definition meshresolution.h:107
enum mesh::ResolutionSettings::Reference reference
Terrain reference DEM (default Averaged).
std::optional< double > toleranceM
Terrain elevation tolerance, vertical metres (JSON "elevationToleranceM"); absent = automatic estimat...
Definition meshresolution.h:50
Sizing
Sizing rules: Legacy targets; Verified sizes (report exceptions); Strict sizes (refuse unmet limits).
Definition meshresolution.h:63
@ Legacy
Legacy size targets.
Definition meshresolution.h:64
@ Strict
Verified sizes; unmet limits refuse the mesh.
Definition meshresolution.h:66
@ Verified
Verified sizes; unmet limits are reported as exceptions.
Definition meshresolution.h:65
QJsonObject toJson() const
Serialize every resolution field into the current project JSON schema.
Definition meshresolution.h:174
double minimumM
Minimum target cell size, metres (default 6.096 m = 20 ft); finite in (0, 1e12].
Definition meshresolution.h:35
double transition
Size transition (growth) rate between neighbouring targets; finite and >= 1.05.
Definition meshresolution.h:56
QString validate() const
Check numeric mesh-resolution settings without modifying or normalizing them.
Definition meshresolution.h:119
bool alignTerrain
Detect terrain break lines and align mesh edges to them (default true).
Definition meshresolution.h:89
TerrainTolerancePolicy terrainTolerancePolicy
Terrain tolerance rule (constant or scaled with target size); its sizes and tolerances are metres.
Definition meshresolution.h:83
enum mesh::ResolutionSettings::Sizing sizing
Sizing rules in force (default Legacy).
CoarseningOrder coarseningOrder
Coarsening removal order (default LegacyFlatness); ResolutionAware needs non-Legacy sizing.
Definition meshresolution.h:80
std::optional< double > minimumEdgeM
Separate floor on delivered edge length, metres; absent = none. Needs non-Legacy sizing.
Definition meshresolution.h:77
std::optional< double > breaklineToleranceM
Terrain break-line detection tolerance, vertical metres; absent = automatic.
Definition meshresolution.h:50
std::optional< double > minimumBreaklineLengthM
Shortest terrain break line to keep, metres; absent = the caller's default.
Definition meshresolution.h:51
static ResolutionSettings fromJson(const QJsonObject &o)
Decode current-schema resolution fields using defaults for missing or mismatched values.
Definition meshresolution.h:214
std::optional< double > maximumM
Maximum target cell size, metres; absent = no limit, else >= minimumM.
Definition meshresolution.h:50
std::optional< double > featureM
Target size near selected features when refineFeatures; absent = minimumM.
Definition meshresolution.h:50
int maxBreaklines
Cap on terrain break lines, 0..10,000,000; 0 = let the caller choose automatically.
Definition meshresolution.h:53
enum mesh::ResolutionSettings::Terrain terrain
Terrain refinement method (default Adaptive); TargetSize tolerance needs Adaptive.
int coarsenPasses
Absent in older projects: retain their original mesh behaviour.
Definition meshresolution.h:54
bool refineFeatures
Refine to featureM near selected features (default false).
Definition meshresolution.h:89
Terrain
Terrain refinement method: Adaptive elevation error, Legacy block sizing, or Off.
Definition meshresolution.h:94
@ Legacy
Legacy block-based terrain sizing.
Definition meshresolution.h:96
@ Adaptive
Refine by elevation error against the terrain.
Definition meshresolution.h:95
@ Off
No terrain refinement.
Definition meshresolution.h:97
static ResolutionSettings migrate(const QJsonObject &c, ResolutionSettings r, double extentM)
Overlay version-1 generation-dialog controls onto a supplied settings value.
Definition meshresolution.h:275
std::optional< double > averagingM
DEM averaging scale for the Averaged reference, metres; absent = minimumM.
Definition meshresolution.h:50
Maps a reference terrain tolerance and a footprint target size to the tolerance used there.
Definition terrainpolicy.hpp:36
double minimumTolerance
Lower clamp, in Z units, for TargetSize mode; finite and >= 0 (0 = no floor).
Definition terrainpolicy.hpp:43
TerrainToleranceMode mode
Tolerance mode; Constant (the default) ignores the other fields except for validation.
Definition terrainpolicy.hpp:38
double referenceSize
Target size, in XY units, at which the scaled tolerance equals the reference tolerance; must be posit...
Definition terrainpolicy.hpp:41
double maximumTolerance
Upper clamp, in Z units, for TargetSize mode; finite and >= 0, and >= minimumTolerance unless 0.
Definition terrainpolicy.hpp:46