[Domain] Add fire and smoke hazard foundation

CMakeLists.txt

@@ -79,6 +79,8 @@ add_library(safecrowd_domain STATIC
     src/domain/DemoLayouts.h
     src/domain/DemoLayouts.cpp
     src/domain/Geometry2D.h
+    src/domain/GeometryQueries.h
+    src/domain/GeometryQueries.cpp
     src/domain/PopulationSpec.h
     src/domain/ScenarioAuthoring.h
     src/domain/ScenarioAuthoring.cpp
@@ -159,6 +161,7 @@ if (BUILD_TESTING)
         tests/ScenarioSimulationRunnerTests.cpp
         tests/ScenarioAuthoringTests.cpp
         tests/ScenarioBatchRunnerTests.cpp
+        tests/GeometryQueriesTests.cpp
     )
 
     target_include_directories(safecrowd_tests

src/application/LayoutNavigationPanelWidget.cpp

@@ -1,5 +1,7 @@
 #include "application/LayoutNavigationPanelWidget.h"
 
+#include "domain/GeometryQueries.h"
+
 #include <algorithm>
 #include <cmath>
 #include <limits>
@@ -19,6 +21,9 @@ constexpr double kGeometryEpsilon = 1e-4;
 const QColor kExitAccentColor("#2d8f5b");
 const QColor kDoorAccentColor("#ff8c00");
 
+using safecrowd::domain::distanceToPolygonBoundary;
+using safecrowd::domain::pointInPolygon;
+
 QString floorActionId(const std::string& floorId) {
     return QString("floor:%1").arg(QString::fromStdString(floorId));
 }
@@ -112,79 +117,6 @@ NavigationTreeNode makeSection(const QString& label, std::vector<NavigationTreeN
     };
 }
 
-double distancePointToSegment(
-    const safecrowd::domain::Point2D& point,
-    const safecrowd::domain::Point2D& start,
-    const safecrowd::domain::Point2D& end) {
-    const auto dx = end.x - start.x;
-    const auto dy = end.y - start.y;
-    const auto lengthSquared = (dx * dx) + (dy * dy);
-    if (lengthSquared <= kGeometryEpsilon) {
-        return std::hypot(point.x - start.x, point.y - start.y);
-    }
-
-    const auto t = std::clamp(
-        (((point.x - start.x) * dx) + ((point.y - start.y) * dy)) / lengthSquared,
-        0.0,
-        1.0);
-    return std::hypot(point.x - (start.x + (dx * t)), point.y - (start.y + (dy * t)));
-}
-
-double distanceToPolygonBoundary(
-    const safecrowd::domain::Polygon2D& polygon,
-    const safecrowd::domain::Point2D& point) {
-    double best = std::numeric_limits<double>::max();
-    const auto checkRing = [&](const std::vector<safecrowd::domain::Point2D>& ring) {
-        if (ring.size() < 2) {
-            return;
-        }
-        for (std::size_t index = 0; index < ring.size(); ++index) {
-            best = std::min(best, distancePointToSegment(point, ring[index], ring[(index + 1) % ring.size()]));
-        }
-    };
-
-    checkRing(polygon.outline);
-    for (const auto& hole : polygon.holes) {
-        checkRing(hole);
-    }
-    return best;
-}
-
-bool pointInRing(
-    const std::vector<safecrowd::domain::Point2D>& ring,
-    const safecrowd::domain::Point2D& point) {
-    if (ring.size() < 3) {
-        return false;
-    }
-
-    bool inside = false;
-    for (std::size_t i = 0, j = ring.size() - 1; i < ring.size(); j = i++) {
-        const auto& a = ring[i];
-        const auto& b = ring[j];
-        const auto intersects = ((a.y > point.y) != (b.y > point.y))
-            && (point.x < ((b.x - a.x) * (point.y - a.y) / ((b.y - a.y) == 0.0 ? 1e-9 : (b.y - a.y)) + a.x));
-        if (intersects) {
-            inside = !inside;
-        }
-    }
-    return inside;
-}
-
-bool pointInPolygon(
-    const safecrowd::domain::Polygon2D& polygon,
-    const safecrowd::domain::Point2D& point) {
-    if (!pointInRing(polygon.outline, point)) {
-        return false;
-    }
-
-    for (const auto& hole : polygon.holes) {
-        if (pointInRing(hole, point)) {
-            return false;
-        }
-    }
-    return true;
-}
-
 double overlapLength(double firstStart, double firstEnd, double secondStart, double secondEnd) {
     const auto firstMin = std::min(firstStart, firstEnd);
     const auto firstMax = std::max(firstStart, firstEnd);

src/application/ProjectPersistence.cpp

@@ -12,6 +12,7 @@
 #include <QJsonArray>
 #include <QJsonDocument>
 #include <QJsonObject>
+#include <QJsonValue>
 #include <QStandardPaths>
 #include <QStorageInfo>
 
@@ -720,20 +721,117 @@ safecrowd::domain::PopulationSpec populationFromJson(const QJsonObject& object)
     return population;
 }
 
+QString hazardKindToJson(safecrowd::domain::EnvironmentHazardKind kind) {
+    switch (kind) {
+    case safecrowd::domain::EnvironmentHazardKind::Smoke:
+        return "Smoke";
+    case safecrowd::domain::EnvironmentHazardKind::Fire:
+    default:
+        return "Fire";
+    }
+}
+
+safecrowd::domain::EnvironmentHazardKind hazardKindFromJson(const QJsonValue& value) {
+    if (value.isDouble()) {
+        return value.toInt() == static_cast<int>(safecrowd::domain::EnvironmentHazardKind::Smoke)
+            ? safecrowd::domain::EnvironmentHazardKind::Smoke
+            : safecrowd::domain::EnvironmentHazardKind::Fire;
+    }
+
+    const auto raw = value.toString().toLower();
+    if (raw == "smoke") {
+        return safecrowd::domain::EnvironmentHazardKind::Smoke;
+    }
+    return safecrowd::domain::EnvironmentHazardKind::Fire;
+}
+
+QString severityToJson(safecrowd::domain::ScenarioElementSeverity severity) {
+    switch (severity) {
+    case safecrowd::domain::ScenarioElementSeverity::Low:
+        return "Low";
+    case safecrowd::domain::ScenarioElementSeverity::High:
+        return "High";
+    case safecrowd::domain::ScenarioElementSeverity::Medium:
+    default:
+        return "Medium";
+    }
+}
+
+safecrowd::domain::ScenarioElementSeverity severityFromJson(const QJsonValue& value) {
+    if (value.isDouble()) {
+        const auto raw = value.toInt();
+        if (raw == static_cast<int>(safecrowd::domain::ScenarioElementSeverity::Low)) {
+            return safecrowd::domain::ScenarioElementSeverity::Low;
+        }
+        if (raw == static_cast<int>(safecrowd::domain::ScenarioElementSeverity::High)) {
+            return safecrowd::domain::ScenarioElementSeverity::High;
+        }
+        return safecrowd::domain::ScenarioElementSeverity::Medium;
+    }
+
+    const auto raw = value.toString().toLower();
+    if (raw == "low") {
+        return safecrowd::domain::ScenarioElementSeverity::Low;
+    }
+    if (raw == "high") {
+        return safecrowd::domain::ScenarioElementSeverity::High;
+    }
+    return safecrowd::domain::ScenarioElementSeverity::Medium;
+}
+
+QJsonObject hazardToJson(const safecrowd::domain::EnvironmentHazardDraft& hazard) {
+    QJsonObject object;
+    object["id"] = QString::fromStdString(hazard.id);
+    object["kind"] = hazardKindToJson(hazard.kind);
+    object["name"] = QString::fromStdString(hazard.name);
+    object["affectedZoneId"] = QString::fromStdString(hazard.affectedZoneId);
+    object["floorId"] = QString::fromStdString(hazard.floorId);
+    object["position"] = pointArray(hazard.position);
+    object["startSeconds"] = hazard.startSeconds;
+    object["endSeconds"] = hazard.endSeconds;
+    object["severity"] = severityToJson(hazard.severity);
+    object["note"] = QString::fromStdString(hazard.note);
+    return object;
+}
+
+safecrowd::domain::EnvironmentHazardDraft hazardFromJson(const QJsonObject& object) {
+    return {
+        .id = object.value("id").toString().toStdString(),
+        .kind = hazardKindFromJson(object.value("kind")),
+        .name = object.value("name").toString().toStdString(),
+        .affectedZoneId = object.value("affectedZoneId").toString().toStdString(),
+        .floorId = object.value("floorId").toString().toStdString(),
+        .position = pointFromJson(object.value("position")),
+        .startSeconds = object.value("startSeconds").toDouble(0.0),
+        .endSeconds = object.value("endSeconds").toDouble(0.0),
+        .severity = severityFromJson(object.value("severity")),
+        .note = object.value("note").toString().toStdString(),
+    };
+}
+
 QJsonObject environmentToJson(const safecrowd::domain::EnvironmentState& environment) {
     QJsonObject object;
     object["reducedVisibility"] = environment.reducedVisibility;
     object["familiarityProfile"] = QString::fromStdString(environment.familiarityProfile);
     object["guidanceProfile"] = QString::fromStdString(environment.guidanceProfile);
+    QJsonArray hazards;
+    for (const auto& hazard : environment.hazards) {
+        hazards.append(hazardToJson(hazard));
+    }
+    object["hazards"] = hazards;
     return object;
 }
 
 safecrowd::domain::EnvironmentState environmentFromJson(const QJsonObject& object) {
-    return {
+    safecrowd::domain::EnvironmentState environment{
         .reducedVisibility = object.value("reducedVisibility").toBool(false),
         .familiarityProfile = object.value("familiarityProfile").toString().toStdString(),
         .guidanceProfile = object.value("guidanceProfile").toString().toStdString(),
     };
+    for (const auto& value : object.value("hazards").toArray()) {
+        environment.hazards.push_back(hazardFromJson(value.toObject()));
+    }
+    return environment;
 }
 
 QJsonObject eventToJson(const safecrowd::domain::OperationalEventDraft& event) {