summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--game/network/network.cpp88
-rw-r--r--game/network/network.h45
-rw-r--r--game/network/network.impl.h102
-rw-r--r--game/network/rail.cpp55
-rw-r--r--game/network/rail.h1
-rw-r--r--lib/maths.cpp23
-rw-r--r--lib/maths.h136
-rw-r--r--test/test-maths.cpp24
-rw-r--r--test/test-network.cpp189
9 files changed, 241 insertions, 422 deletions
diff --git a/game/network/network.cpp b/game/network/network.cpp
index a9c9372..ae4865a 100644
--- a/game/network/network.cpp
+++ b/game/network/network.cpp
@@ -107,7 +107,7 @@ Network::add(GeoData * geoData, const std::span<const Link::Ptr> links)
}
void
-Network::terrainSplitAt(GenLinkDef & previous, GenLinkDef & next, GlobalPosition3D pos)
+Network::connectAt(GenLinkDef & previous, GenLinkDef & next, GlobalPosition3D pos)
{
std::visit(
[pos](auto & typedDefPrevious, auto & typedDefNext) {
@@ -125,7 +125,7 @@ Network::terrainSplit(const GeoData * geoData, const GenStraightDef & def) const
if (step.previous.is_valid() && geoData->getSurface(step.current) != geoData->getSurface(step.previous)) {
const auto surfaceEdgePosition = geoData->positionAt(GeoData::PointFace(step.exitPosition, step.current));
out.emplace_back(out.back());
- terrainSplitAt(*out.rbegin(), *++out.rbegin(), surfaceEdgePosition);
+ connectAt(*out.rbegin(), *++out.rbegin(), surfaceEdgePosition);
}
});
return out;
@@ -161,26 +161,35 @@ Network::terrainSplit(const GeoData * geoData, const GenCurveDef & def) const
GenLinksDef out {def};
std::ranges::for_each(++points.begin(), --points.end(), [&out](const auto pos) {
out.emplace_back(out.back());
- terrainSplitAt(*out.rbegin(), *++out.rbegin(), pos);
+ connectAt(*out.rbegin(), *++out.rbegin(), pos);
});
return out;
}
-GenCurveDef
-Network::genCurveDef(const GlobalPosition3D & start, const GlobalPosition3D & end, float startDir)
+GenLinksDef
+Network::genDef(const GlobalPosition3D & start, const GlobalPosition3D & end)
+{
+ return {GenStraightDef {start, end}};
+}
+
+GenLinksDef
+Network::genDef(const GlobalPosition3D & start, const GlobalPosition3D & end, Angle startDir)
{
const auto dir = pi + startDir;
const auto flatStart = start.xy(), flatEnd = end.xy();
const auto centre = find_arc_centre(flatStart, dir, flatEnd);
- if (centre.second) { // right hand arc
- return {end, start, centre.first};
+ if (centre.second > 0.1F) {
+ return {GenCurveDef {end, start, centre.first}};
+ }
+ if (centre.second < -0.1F) {
+ return {GenCurveDef {start, end, centre.first}};
}
- return {start, end, centre.first};
+ return {GenStraightDef {start, end}};
}
-std::pair<GenCurveDef, GenCurveDef>
-Network::genCurveDef(const GlobalPosition3D & start, const GlobalPosition3D & end, float startDir, float endDir)
+GenLinksDef
+Network::genDef(const GlobalPosition3D & start, const GlobalPosition3D & end, Angle startDir, Angle endDir)
{
// Based on formula/code from https://www.ryanjuckett.com/biarc-interpolation/
const auto startVec = -sincos(startDir);
@@ -194,7 +203,7 @@ Network::genCurveDef(const GlobalPosition3D & start, const GlobalPosition3D & en
if (equalTangents && perpT1) {
const auto joint = start + (diff * 0.5F);
- return {genCurveDef(start, joint, startDir), genCurveDef(end, joint, endDir)};
+ return genDef(start, joint, startDir) + genDef(end, joint, endDir);
}
const auto vDotT = glm::dot(diff.xy(), endsVecTotal);
@@ -210,16 +219,41 @@ Network::genCurveDef(const GlobalPosition3D & start, const GlobalPosition3D & en
const auto joint = (start + end + ((difference(startVec, endVec) * extLen1) || 0.F)) / 2;
- return {genCurveDef(start, joint, startDir), genCurveDef(end, joint, endDir)};
+ return genDef(start, joint, startDir) + genDef(end, joint, endDir);
+}
+
+namespace {
+ struct MergeEq {
+ bool
+ operator()(GenCurveDef & lhs, const GenCurveDef & rhs) const
+ {
+ if (distance(std::get<2>(lhs), std::get<2>(rhs)) < 100.F) { // LHS.centre near RHS.centre
+ if (std::get<1>(lhs) == std::get<0>(rhs)) { // LHS.end == RHS.start
+ std::get<1>(lhs) = std::get<1>(rhs);
+ }
+ else if (std::get<0>(lhs) == std::get<1>(rhs)) { // LHS.start == RHS.end
+ std::get<0>(lhs) = std::get<0>(rhs);
+ }
+ else {
+ return false;
+ }
+ std::get<2>(lhs) = midpoint(std::get<2>(lhs), std::get<2>(rhs));
+ return true;
+ }
+ return false;
+ }
+
+ bool
+ operator()(const auto &, const auto &) const
+ {
+ return false;
+ }
+ };
}
Link::Collection
Network::create(const GeoData * geoData, const CreationDefinition & def)
{
- // TODO
- // Where to make a straight to join because angles align?
- // Where to drop part of S curve pair if a single curve works?
-
const auto linkDefs = [&def]() -> GenLinksDef {
if (!def.fromEnd.direction && !def.toEnd.direction) {
// No specific directions at either end, straight link
@@ -228,15 +262,13 @@ Network::create(const GeoData * geoData, const CreationDefinition & def)
if (def.fromEnd.direction) {
if (def.toEnd.direction) {
// Two specific directions at both ends, S curves
- const auto curves = genCurveDef(
- def.fromEnd.position, def.toEnd.position, *def.fromEnd.direction, *def.toEnd.direction);
- return {curves.first, curves.second};
+ return genDef(def.fromEnd.position, def.toEnd.position, *def.fromEnd.direction, *def.toEnd.direction);
}
// One specific direction, single curve from there
- return {genCurveDef(def.fromEnd.position, def.toEnd.position, *def.fromEnd.direction)};
+ return genDef(def.fromEnd.position, def.toEnd.position, *def.fromEnd.direction);
}
// One specific direction, single curve from the other
- return {genCurveDef(def.toEnd.position, def.fromEnd.position, *def.toEnd.direction)};
+ return genDef(def.toEnd.position, def.fromEnd.position, *def.toEnd.direction);
};
const auto splitDefs = [&linkDefs, this, geoData]() {
return std::ranges::fold_left(linkDefs(), GenLinksDef {}, [this, geoData](auto && existing, const auto & def) {
@@ -247,8 +279,20 @@ Network::create(const GeoData * geoData, const CreationDefinition & def)
def);
});
};
+ // Merge adjacent pairs where possible
+ auto linkDefsGen = geoData ? splitDefs() : linkDefs();
+ if (!linkDefsGen.empty()) {
+ for (auto lhsIter = linkDefsGen.begin(), rhsIter = lhsIter + 1; rhsIter != linkDefsGen.end();) {
+ if (std::visit(MergeEq {}, *lhsIter, *rhsIter)) {
+ rhsIter = linkDefsGen.erase(rhsIter);
+ }
+ else {
+ lhsIter = rhsIter++;
+ }
+ }
+ }
Link::Collection links;
- std::ranges::transform(geoData ? splitDefs() : linkDefs(), std::back_inserter(links), [this](const auto & def) {
+ std::ranges::transform(linkDefsGen, std::back_inserter(links), [this](const auto & def) {
return std::visit(
[this](const auto & typedDef) {
return this->create(typedDef);
diff --git a/game/network/network.h b/game/network/network.h
index adaae5f..d3370b3 100644
--- a/game/network/network.h
+++ b/game/network/network.h
@@ -8,7 +8,6 @@
#include "sorting.h"
#include "special_members.h"
#include <glm/glm.hpp>
-#include <memory>
#include <set>
#include <string>
#include <utility>
@@ -55,13 +54,6 @@ public:
[[nodiscard]] Link::Nexts routeFromTo(const Link::End &, GlobalPosition3D) const;
[[nodiscard]] static Link::Nexts routeFromTo(const Link::End &, const Node::Ptr &);
- virtual Link::CCollection candidateStraight(GlobalPosition3D, GlobalPosition3D) = 0;
- virtual Link::CCollection candidateJoins(GlobalPosition3D, GlobalPosition3D) = 0;
- virtual Link::CCollection candidateExtend(GlobalPosition3D, GlobalPosition3D) = 0;
- virtual Link::CCollection addStraight(const GeoData *, GlobalPosition3D, GlobalPosition3D) = 0;
- virtual Link::CCollection addJoins(const GeoData *, GlobalPosition3D, GlobalPosition3D) = 0;
- virtual Link::CCollection addExtend(const GeoData *, GlobalPosition3D, GlobalPosition3D) = 0;
-
[[nodiscard]] virtual float findNodeDirection(Node::AnyCPtr) const = 0;
[[nodiscard]] Link::Collection create(const GeoData *, const CreationDefinition &);
@@ -74,13 +66,14 @@ public:
protected:
static void joinLinks(const Link::Ptr & link, const Link::Ptr & oldLink);
- static GenCurveDef genCurveDef(const GlobalPosition3D & start, const GlobalPosition3D & end, float startDir);
- static std::pair<GenCurveDef, GenCurveDef> genCurveDef(
- const GlobalPosition3D & start, const GlobalPosition3D & end, float startDir, float endDir);
+ static GenLinksDef genDef(const GlobalPosition3D & start, const GlobalPosition3D & end);
+ static GenLinksDef genDef(const GlobalPosition3D & start, const GlobalPosition3D & end, Angle startDir);
+ static GenLinksDef genDef(
+ const GlobalPosition3D & start, const GlobalPosition3D & end, Angle startDir, Angle endDir);
[[nodiscard]] GenLinksDef terrainSplit(const GeoData *, const GenStraightDef &) const;
[[nodiscard]] GenLinksDef terrainSplit(const GeoData *, const GenCurveDef &) const;
- static void terrainSplitAt(GenLinkDef & previous, GenLinkDef & next, GlobalPosition3D pos);
+ static void connectAt(GenLinkDef & previous, GenLinkDef & next, GlobalPosition3D pos);
[[nodiscard]] virtual Link::Ptr create(const GenStraightDef &) = 0;
[[nodiscard]] virtual Link::Ptr create(const GenCurveDef &) = 0;
@@ -109,33 +102,6 @@ protected:
[[nodiscard]] Link::Ptr intersectRayLinks(const Ray<GlobalPosition3D> &) const override;
public:
- template<typename L, typename... Params>
- std::shared_ptr<L>
- candidateLink(GlobalPosition3D positionA, GlobalPosition3D positionB, Params &&... params)
- requires std::is_base_of_v<T, L>
- {
- const auto node1 = candidateNodeAt(positionA).first, node2 = candidateNodeAt(positionB).first;
- return std::make_shared<L>(*this, node1, node2, std::forward<Params>(params)...);
- }
-
- template<typename L, typename... Params>
- std::shared_ptr<L>
- addLink(GlobalPosition3D positionA, GlobalPosition3D positionB, Params &&... params)
- requires std::is_base_of_v<T, L>
- {
- const auto node1 = nodeAt(positionA), node2 = nodeAt(positionB);
- auto newLink = links.template create<L>(*this, node1, node2, std::forward<Params>(params)...);
- joinLinks(newLink);
- return std::move(newLink);
- }
-
- Link::CCollection candidateStraight(GlobalPosition3D, GlobalPosition3D) override;
- Link::CCollection candidateJoins(GlobalPosition3D, GlobalPosition3D) override;
- Link::CCollection candidateExtend(GlobalPosition3D, GlobalPosition3D) override;
- Link::CCollection addStraight(const GeoData *, GlobalPosition3D, GlobalPosition3D) override;
- Link::CCollection addJoins(const GeoData *, GlobalPosition3D, GlobalPosition3D) override;
- Link::CCollection addExtend(const GeoData *, GlobalPosition3D, GlobalPosition3D) override;
-
[[nodiscard]] float findNodeDirection(Node::AnyCPtr) const override;
using Network::create;
[[nodiscard]] Link::Ptr create(const GenStraightDef &) override;
@@ -144,6 +110,5 @@ public:
void add(GeoData *, const Link::Ptr &) override;
protected:
- Link::CCollection addCurve(const GeoData *, const GenCurveDef &);
[[nodiscard]] bool anyLinks() const;
};
diff --git a/game/network/network.impl.h b/game/network/network.impl.h
index 04c5d7c..dda4974 100644
--- a/game/network/network.impl.h
+++ b/game/network/network.impl.h
@@ -1,4 +1,3 @@
-#include "collections.h"
#include "network.h"
#include <game/geoData.h>
#include <gfx/gl/sceneShader.h>
@@ -44,107 +43,6 @@ NetworkOf<T, Links...>::findNodeDirection(Node::AnyCPtr n) const
}
template<typename T, typename... Links>
-Link::CCollection
-NetworkOf<T, Links...>::candidateStraight(GlobalPosition3D positionA, GlobalPosition3D positionB)
-{
- return {candidateLink<typename T::StraightLink>(positionA, positionB)};
-}
-
-template<typename T, typename... Links>
-Link::CCollection
-NetworkOf<T, Links...>::candidateJoins(GlobalPosition3D start, GlobalPosition3D end)
-{
- static constexpr auto MIN_DISTANCE = 2000.F;
- if (::distance(start, end) < MIN_DISTANCE) {
- return {};
- }
- const auto defs = genCurveDef(
- start, end, findNodeDirection(candidateNodeAt(start).first), findNodeDirection(candidateNodeAt(end).first));
- const auto & [c1s, c1e, c1c] = defs.first;
- const auto & [c2s, c2e, c2c] = defs.second;
- return {candidateLink<typename T::CurveLink>(c1s, c1e, c1c), candidateLink<typename T::CurveLink>(c2s, c2e, c2c)};
-}
-
-template<typename T, typename... Links>
-Link::CCollection
-NetworkOf<T, Links...>::candidateExtend(GlobalPosition3D start, GlobalPosition3D end)
-{
- const auto [cstart, cend, centre] = genCurveDef(start, end, findNodeDirection(candidateNodeAt(start).first));
- return {candidateLink<typename T::CurveLink>(cstart, cend, centre)};
-}
-
-template<typename T, typename... Links>
-Link::CCollection
-NetworkOf<T, Links...>::addStraight(const GeoData * geoData, GlobalPosition3D positionA, GlobalPosition3D positionB)
-{
- Link::CCollection out;
- geoData->walk(positionA.xy(), positionB, [geoData, &out, this, &positionA](const GeoData::WalkStep & step) {
- if (step.previous.is_valid() && geoData->getSurface(step.current) != geoData->getSurface(step.previous)) {
- const auto surfaceEdgePosition = geoData->positionAt(GeoData::PointFace(step.exitPosition, step.current));
- out.emplace_back(addLink<typename T::StraightLink>(positionA, surfaceEdgePosition));
- positionA = surfaceEdgePosition;
- }
- });
- out.emplace_back(addLink<typename T::StraightLink>(positionA, positionB));
- return out;
-}
-
-template<typename T, typename... Links>
-Link::CCollection
-NetworkOf<T, Links...>::addCurve(const GeoData * geoData, const GenCurveDef & curve)
-{
- static constexpr auto MIN_DISTANCE = 2000.F;
- auto [cstart, cend, centre] = curve;
- Link::CCollection out;
- std::set<GeoData::WalkStepCurve, SortedBy<&GeoData::WalkStepCurve::angle>> breaks;
- const auto radiusMid = ::distance(cstart.xy(), centre);
- for (const auto radiusOffset : {-getBaseWidth() / 2.F, 0.F, getBaseWidth() / 2.F}) {
- const auto radius = radiusOffset + radiusMid;
- const auto start = centre + (difference(cstart.xy(), centre) * radius) / radiusMid;
- const auto end = centre + (difference(cend.xy(), centre) * radius) / radiusMid;
- geoData->walk(start, end, centre, [geoData, &breaks](const GeoData::WalkStepCurve & step) {
- if (step.previous.is_valid() && geoData->getSurface(step.current) != geoData->getSurface(step.previous)) {
- breaks.insert(step);
- }
- });
- }
- std::vector<GlobalPosition3D> points;
- points.reserve(breaks.size() + 2);
- points.push_back(cstart);
- std::ranges::transform(
- breaks, std::back_inserter(points), [geoData, centre, radiusMid](const GeoData::WalkStepCurve & step) {
- return (centre + (sincos(step.angle) * radiusMid))
- || geoData->positionAt(GeoData::PointFace(step.exitPosition, step.current)).z;
- });
- points.push_back(cend);
- mergeClose(points, ::distance<3, GlobalDistance>, ::midpoint<3, GlobalDistance>, MIN_DISTANCE);
- std::ranges::transform(points | std::views::pairwise, std::back_inserter(out), [this, centre](const auto pair) {
- const auto [a, b] = pair;
- return this->addLink<typename T::CurveLink>(a, b, centre);
- });
- return out;
-}
-
-template<typename T, typename... Links>
-Link::CCollection
-NetworkOf<T, Links...>::addJoins(const GeoData * geoData, GlobalPosition3D start, GlobalPosition3D end)
-{
- static constexpr auto MIN_DISTANCE = 2000.F;
- if (::distance(start, end) < MIN_DISTANCE) {
- return {};
- }
- const auto defs = genCurveDef(start, end, findNodeDirection(nodeAt(start)), findNodeDirection(nodeAt(end)));
- return addCurve(geoData, defs.first) + addCurve(geoData, defs.second);
-}
-
-template<typename T, typename... Links>
-Link::CCollection
-NetworkOf<T, Links...>::addExtend(const GeoData * geoData, GlobalPosition3D start, GlobalPosition3D end)
-{
- return addCurve(geoData, genCurveDef(start, end, findNodeDirection(nodeAt(start))));
-}
-
-template<typename T, typename... Links>
Link::Ptr
NetworkOf<T, Links...>::create(const GenStraightDef & def)
{
diff --git a/game/network/rail.cpp b/game/network/rail.cpp
index 37eb7df..342a2ad 100644
--- a/game/network/rail.cpp
+++ b/game/network/rail.cpp
@@ -18,61 +18,6 @@ RailLinks::tick(TickDuration)
{
}
-std::shared_ptr<RailLink>
-RailLinks::addLinksBetween(GlobalPosition3D start, GlobalPosition3D end)
-{
- auto node1ins = newNodeAt(start), node2ins = newNodeAt(end);
- if (node1ins.second == NodeIs::NotInNetwork && node2ins.second == NodeIs::NotInNetwork) {
- // Both nodes are new, direct link, easy
- return addLink<RailLinkStraight>(start, end);
- }
- if (node1ins.second == NodeIs::NotInNetwork && node2ins.second == NodeIs::InNetwork) {
- // node1 is new, node2 exists, but we build from existing outwards
- std::swap(node1ins, node2ins);
- std::swap(start, end);
- }
- // Find start link/end - opposite entry dir to existing link; so pi +...
- const Angle dir = pi + findNodeDirection(node1ins.first);
- if (dir == vector_yaw(difference(end, start))) {
- return addLink<RailLinkStraight>(start, end);
- }
- const auto flatStart {start.xy()}, flatEnd {end.xy()};
- if (node2ins.second == NodeIs::InNetwork) {
- auto midheight = [&](auto mid) {
- const auto startToMid = ::distance<2>(flatStart, mid);
- const auto endToMid = ::distance<2>(flatEnd, mid);
- return start.z + GlobalDistance(RelativeDistance(end.z - start.z) * (startToMid / (startToMid + endToMid)));
- };
- const float dir2 = pi + findNodeDirection(node2ins.first);
- const auto radii = find_arcs_radius(flatStart, dir, flatEnd, dir2);
- if (radii.first < radii.second) {
- const auto radius = radii.first;
- const auto centre1 = flatStart + (sincos(dir + half_pi) * radius);
- const auto centre2 = flatEnd + (sincos(dir2 + half_pi) * radius);
- const auto mid = (centre1 + centre2) / 2;
- const auto midh = mid || midheight(mid);
- addLink<RailLinkCurve>(start, midh, centre1);
- return addLink<RailLinkCurve>(end, midh, centre2);
- }
- const auto radius = radii.second;
- const auto centre1 = flatStart + (sincos(dir - half_pi) * radius);
- const auto centre2 = flatEnd + (sincos(dir2 - half_pi) * radius);
- const auto mid = (centre1 + centre2) / 2;
- const auto midh = mid || midheight(mid);
- addLink<RailLinkCurve>(midh, start, centre1);
- return addLink<RailLinkCurve>(midh, end, centre2);
- }
- const auto diff = difference(end, start);
- const auto yaw = vector_yaw(diff);
- const auto n2ed = (yaw * 2) - dir - pi;
- const auto centre = find_arc_centre(flatStart, dir, flatEnd, n2ed);
-
- if (centre.second) { // right hand arc
- std::swap(start, end);
- }
- return addLink<RailLinkCurve>(start, end, centre.first);
-}
-
namespace {
constexpr const std::array<RelativePosition3D, RAIL_CROSSSECTION_VERTICES> RAIL_CROSS_SECTION {{
{-1330.F, 0.F, 0},
diff --git a/game/network/rail.h b/game/network/rail.h
index 4aef9e3..15b9ae4 100644
--- a/game/network/rail.h
+++ b/game/network/rail.h
@@ -74,7 +74,6 @@ class RailLinks : public NetworkOf<RailLink, RailLinkStraight, RailLinkCurve>, p
public:
RailLinks();
- std::shared_ptr<RailLink> addLinksBetween(GlobalPosition3D start, GlobalPosition3D end);
void render(const SceneShader &, const Frustum &) const override;
[[nodiscard]] const Surface * getBaseSurface() const override;
diff --git a/lib/maths.cpp b/lib/maths.cpp
index 12e0681..7dd313e 100644
--- a/lib/maths.cpp
+++ b/lib/maths.cpp
@@ -1,5 +1,6 @@
#include "maths.h"
#include <cmath>
+#include <functional>
#include <glm/glm.hpp>
#include <glm/gtx/rotate_vector.hpp>
#include <glm/gtx/transform.hpp>
@@ -19,6 +20,7 @@ flat_orientation(const Direction3D & diff)
return (std::isnan(e[0][0])) ? oneeighty : e;
}
+// NOLINTBEGIN(readability-magic-numbers)
static_assert(pow(1, 0) == 1);
static_assert(pow(1, 1) == 1);
static_assert(pow(1, 2) == 1);
@@ -31,6 +33,27 @@ static_assert(pow(3, 1) == 3);
static_assert(pow(3, 2) == 9);
static_assert(pow(pi, 3) == 31.006278991699219F);
+#ifndef __clang__
+static_assert(!linesIntersectAt<int>({0, 10}, {10, 10}, {10, 0}, {0, 0}).has_value());
+static_assert(*linesIntersectAt<int>({0, 0}, {10, 10}, {10, 0}, {0, 10}) == GlobalPosition2D {5, 5});
+static_assert(*linesIntersectAt<int>({300'000'000, 400'000'00}, {300'010'000, 400'010'00}, {310'010'000, 410'000'00},
+ {310'000'000, 410'010'00})
+ == GlobalPosition2D {310'005'000, 410'005'00});
+
+constexpr auto NORTH2D = RelativePosition2D(north);
+constexpr auto EAST2D = RelativePosition2D(east);
+static_assert(!linesIntersectAtDirs<int>({0, 0}, NORTH2D, {10, 10}, NORTH2D).has_value());
+static_assert(linesIntersectAtDirs<int>({0, 0}, NORTH2D, {10, 10}, EAST2D) == GlobalPosition2D {0, 10});
+static_assert(linesIntersectAtDirs<int>({0, 0}, EAST2D, {10, 10}, NORTH2D) == GlobalPosition2D {10, 0});
+
+static_assert(find_arc_centre<int>({0, 0}, -NORTH2D, {10, 10}) == std::make_pair<GlobalPosition2D>({10, 0}, 10.F));
+static_assert(find_arc_centre<int>({20, 0}, -NORTH2D, {10, 10}) == std::make_pair<GlobalPosition2D>({10, 0}, -10.F));
+static_assert(find_arc_centre<int>({10, 0}, -NORTH2D, {10, 10}).second == 0.F);
+static_assert(isWithinLimit(find_arc_centre<int>({0, 0}, pi + quarter_pi, {1000, 1000}).second, 0.F, 0.1F));
+#endif
+
+// NOLINTEND(readability-magic-numbers)
+
float
operator""_mph(const long double v)
{
diff --git a/lib/maths.h b/lib/maths.h
index 2999d01..09af048 100644
--- a/lib/maths.h
+++ b/lib/maths.h
@@ -77,11 +77,23 @@ constexpr auto degreesToRads = pi / 180.F;
constexpr auto earthMeanRadius = 6371.01F; // In km
constexpr auto astronomicalUnit = 149597890.F; // In km
-template<glm::length_t D>
+// GLM round is not constexpr :( And we can use lround to convert at the same time
+template<glm::length_t D, std::floating_point T, glm::qualifier Q>
+[[nodiscard]] constexpr glm::vec<D, long, Q>
+lround(const glm::vec<D, T, Q> & value)
+{
+ glm::vec<D, long, Q> out;
+ for (glm::length_t axis = 0; axis < D; ++axis) {
+ out[axis] = std::lround(value[axis]);
+ }
+ return out;
+}
+
+template<glm::length_t D, std::floating_point T, glm::qualifier Q>
constexpr GlobalPosition<D>
-operator+(const GlobalPosition<D> & global, const RelativePosition<D> & relative)
+operator+(const GlobalPosition<D> & global, const glm::vec<D, T, Q> & relative)
{
- return global + GlobalPosition<D>(glm::round(relative));
+ return global + GlobalPosition<D> {lround(relative)};
}
template<glm::length_t D>
@@ -91,11 +103,11 @@ operator+(const GlobalPosition<D> & global, const CalcPosition<D> & relative)
return global + GlobalPosition<D>(relative);
}
-template<glm::length_t D>
+template<glm::length_t D, std::floating_point T, glm::qualifier Q>
constexpr GlobalPosition<D>
-operator-(const GlobalPosition<D> & global, const RelativePosition<D> & relative)
+operator-(const GlobalPosition<D> & global, const glm::vec<D, T, Q> & relative)
{
- return global - GlobalPosition<D>(glm::round(relative));
+ return global - GlobalPosition<D> {lround(relative)};
}
template<glm::length_t D>
@@ -387,112 +399,62 @@ normalize(T ang)
return ang;
}
-template<Arithmetic T, glm::qualifier Q = glm::defaultp>
+template<Arithmetic T, std::floating_point D, glm::qualifier Q = glm::defaultp>
[[nodiscard]] constexpr std::optional<glm::vec<2, T, Q>>
-linesIntersectAt(const glm::vec<2, T, Q> Aabs, const glm::vec<2, T, Q> Babs, const glm::vec<2, T, Q> Cabs,
- const glm::vec<2, T, Q> Dabs)
+linesIntersectAtDirs(const glm::vec<2, T, Q> Aabs, const glm::vec<2, D, Q> Adir, const glm::vec<2, T, Q> Cabs,
+ const glm::vec<2, D, Q> Cdir)
{
- using CT = CalcType<T>;
- using CVec = glm::vec<2, CT, Q>;
- // Line AB represented as a1x + b1y = c1
- const CVec Brel = Babs - Aabs;
- const CT a1 = Brel.y;
- const CT b1 = -Brel.x;
-
- // Line CD represented as a2x + b2y = c2
- const CVec Crel = Cabs - Aabs, Del = Dabs - Aabs;
- const CT a2 = Del.y - Crel.y;
- const CT b2 = Crel.x - Del.x;
- const CT c2 = (a2 * Crel.x) + (b2 * Crel.y);
-
- const auto determinant = (a1 * b2) - (a2 * b1);
+ const auto abNormal = vector_normal(Adir);
+ const auto cdNormal = vector_normal(Cdir);
+ const auto determinant = (abNormal.x * cdNormal.y) - (cdNormal.x * abNormal.y);
if (determinant == 0) {
return std::nullopt;
}
- return Aabs + CVec {(b1 * c2) / -determinant, (a1 * c2) / determinant};
+ const auto Crel = difference(Cabs, Aabs);
+ const auto c2 = (cdNormal.x * Crel.x) + (cdNormal.y * Crel.y);
+ return Aabs + vector_normal((abNormal * c2) / determinant);
+}
+
+template<Arithmetic T, glm::qualifier Q = glm::defaultp>
+[[nodiscard]] constexpr std::optional<glm::vec<2, T, Q>>
+linesIntersectAt(const glm::vec<2, T, Q> Aabs, const glm::vec<2, T, Q> Babs, const glm::vec<2, T, Q> Cabs,
+ const glm::vec<2, T, Q> Dabs)
+{
+ return linesIntersectAtDirs(Aabs, difference(Babs, Aabs), Cabs, difference(Dabs, Cabs));
}
template<std::floating_point T> constexpr auto EPSILON = 0.0001F;
template<std::floating_point T>
-auto
+[[nodiscard]] constexpr auto
isWithinLimit(T lhs, T rhs, T limit = EPSILON<T>)
{
return std::abs(lhs - rhs) <= limit;
}
-template<Arithmetic T, glm::qualifier Q = glm::defaultp>
-std::pair<glm::vec<2, T, Q>, bool>
-find_arc_centre(glm::vec<2, T, Q> start, Rotation2D startDir, glm::vec<2, T, Q> end, Rotation2D endDir)
-{
- const auto det = endDir.x * startDir.y - endDir.y * startDir.x;
- if (det != 0) { // near parallel line will yield noisy results
- const glm::vec<2, RelativeDistance, Q> d = end - start;
- const auto u = (d.y * endDir.x - d.x * endDir.y) / det;
- return {start + glm::vec<2, T, Q>(startDir * u), u < 0};
- }
- throw std::runtime_error("no intersection");
-}
-
-template<Arithmetic T, glm::qualifier Q = glm::defaultp>
-std::pair<glm::vec<2, T, Q>, bool>
-find_arc_centre(glm::vec<2, T, Q> start, Angle entrys, glm::vec<2, T, Q> end, Angle entrye)
-{
- if (start == end) {
- return {start, false};
- }
- return find_arc_centre(start, sincos(entrys + half_pi), end, sincos(entrye - half_pi));
-}
-
-template<Arithmetic T, glm::qualifier Q = glm::defaultp>
-std::pair<glm::vec<2, T, Q>, bool>
-find_arc_centre(glm::vec<2, T, Q> start, Angle entrys, glm::vec<2, T, Q> end)
+template<Arithmetic T, std::floating_point D, glm::qualifier Q = glm::defaultp>
+constexpr std::pair<glm::vec<2, T, Q>, D>
+find_arc_centre(glm::vec<2, T, Q> start, glm::vec<2, D, Q> entrys, glm::vec<2, T, Q> end)
{
if (start == end) {
- return {start, false};
+ return {start, 0};
}
- const auto startNormal = vector_normal(sincos(entrys) * 10'000.F);
const auto diffEnds = difference(end, start);
+ const auto offset = entrys.x * diffEnds.y - entrys.y * diffEnds.x;
+ if (offset == 0.F) {
+ return {start, offset};
+ }
const auto midEnds = start + ((end - start) / 2);
- const auto diffNormal = vector_normal(diffEnds);
- const auto centre = linesIntersectAt(start, start + startNormal, midEnds, midEnds + diffNormal);
- return {*centre, normalize(vector_yaw(diffEnds) - entrys) < 0};
-}
-
-template<Arithmetic T, glm::qualifier Q = glm::defaultp>
-Angle
-find_arcs_radius(glm::vec<2, T, Q> start, Rotation2D ad, glm::vec<2, T, Q> end, Rotation2D bd)
-{
- using std::sqrt;
-
- // Calculates path across both arcs along the normals... pythagorean theorem... for some known radius r
- // (2r)^2 = ((m + (X*r)) - (o + (Z*r)))^2 + ((n + (Y*r)) - (p + (W*r)))^2
- // According to symbolabs.com equation tool, that solves for r to give:
- // r=(-2 m X+2 X o+2 m Z-2 o Z-2 n Y+2 Y p+2 n W-2 p W-sqrt((2 m X-2 X o-2 m Z+2 o Z+2 n Y-2 Y p-2 n W+2 p W)^(2)-4
- // (X^(2)-2 X Z+Z^(2)+Y^(2)-2 Y W+W^(2)-4) (m^(2)-2 m o+o^(2)+n^(2)-2 n p+p^(2))))/(2 (X^(2)-2 X Z+Z^(2)+Y^(2)-2 Y
- // W+W^(2)-4))
- // Locally simplified to work relative, removing one half of the problem and operating on relative positions.
-
- // These exist cos limitations of online formula rearrangement, and I'm OK with that.
- const RelativePosition2D diff {end - start};
- const auto &o {diff.x}, &p {diff.y};
- const auto &X {ad.x}, &Y {ad.y}, &Z {bd.x}, &W {bd.y};
-
- return (-2 * X * o + 2 * o * Z - 2 * Y * p + 2 * p * W
- - sqrt(sq(2 * X * o - 2 * o * Z + 2 * Y * p - 2 * p * W)
- - (4 * (sq(X) - 2 * X * Z + sq(Z) + sq(Y) - 2 * Y * W + sq(W) - 4) * (sq(o) + sq(p)))))
- / (2 * (sq(X) - 2 * X * Z + sq(Z) + sq(Y) - 2 * Y * W + sq(W) - 4));
+ const auto centre = linesIntersectAtDirs(start, vector_normal(entrys), midEnds, vector_normal(diffEnds));
+ return {*centre, offset};
}
template<Arithmetic T, glm::qualifier Q = glm::defaultp>
-std::pair<Angle, Angle>
-find_arcs_radius(glm::vec<2, T, Q> start, Angle entrys, glm::vec<2, T, Q> end, Angle entrye)
+constexpr std::pair<glm::vec<2, T, Q>, float>
+find_arc_centre(glm::vec<2, T, Q> start, Angle entrys, glm::vec<2, T, Q> end)
{
- const auto getrad = [&](auto leftOrRight) {
- return find_arcs_radius(start, sincos(entrys + leftOrRight), end, sincos(entrye + leftOrRight));
- };
- return {getrad(-half_pi), getrad(half_pi)};
+ return find_arc_centre(start, sincos(entrys), end);
}
template<Arithmetic T>
diff --git a/test/test-maths.cpp b/test/test-maths.cpp
index c181686..98a7b1e 100644
--- a/test/test-maths.cpp
+++ b/test/test-maths.cpp
@@ -151,30 +151,6 @@ BOOST_DATA_TEST_CASE(TestCreateArc,
BOOST_CHECK_CLOSE(arc.second, expAngles.second, 1.F);
}
-using FindArcCentreData = std::tuple<glm::vec2, float, glm::vec2, float, glm::vec2, bool>;
-
-BOOST_DATA_TEST_CASE(TestFindArcCentre,
- boost::unit_test::data::make<FindArcCentreData>({
- {{2, 2}, pi, {3, 3}, half_pi, {3, 2}, true},
- {{2, 2}, pi, {1, 3}, -half_pi, {1, 2}, false},
- {{-1100, -1000}, pi, {-900, -800}, half_pi, {-900, -1000}, true},
- {{1100, 1000}, 0, {1050, 900}, pi + 0.92F, {973, 1000}, true},
- {{1050, 900}, 0.92F, {1000, 800}, pi, {1127, 800}, false},
- }),
- startPoint, startEntryAngle, endPoint, endEntryAngle, expCentre, leftRight)
-{
- const auto centre = find_arc_centre(startPoint, startEntryAngle, endPoint, endEntryAngle);
- BOOST_CHECK_CLOSE(expCentre.x, centre.first.x, 1);
- BOOST_CHECK_CLOSE(expCentre.y, centre.first.y, 1);
- BOOST_CHECK_EQUAL(leftRight, centre.second);
-}
-
-BOOST_AUTO_TEST_CASE(TestFindArcsRadius)
-{
- BOOST_CHECK_CLOSE(
- find_arcs_radius(RelativePosition2D {10.32, 26.71}, {0.4, .92}, {2.92, 22.41}, {-0.89, -0.45}), 2.29, 1);
-}
-
namespace {
struct TestLinkStraight : public LinkStraight {
explicit TestLinkStraight(glm::vec3 entryVector) :
diff --git a/test/test-network.cpp b/test/test-network.cpp
index a5e4f75..9a9ceb3 100644
--- a/test/test-network.cpp
+++ b/test/test-network.cpp
@@ -102,21 +102,25 @@ namespace {
struct TestNetwork : public EmptyNetwork {
TestNetwork()
{
- /* 0 1 2
- / -> p000 <-> p100 <-> p200 <-> p300
- / / / \.
- / 3 5 4
- / \ / /
- / --> p110 <------------- */
+ /*
+ * 4--> p110 <---------6-------
+ * / 8 \.
+ * 3 7 5
+ * \ \ /
+ * -> p000 <-0-> p100 <-1-> p200 <-2-> p300 */
+ // 0, 1 and 2 - 3 straight links between 4 nodes
add(nullptr, createChain(nullptr, std::array {P000, P100, P200, P300}));
+ // 3 and 4 - RH biarc from p000 to p110
add(nullptr,
create(nullptr,
{.fromEnd = {.position = P000, .direction = -half_pi},
.toEnd = {.position = P110, .direction = -half_pi}}));
+ // 5 and 6 - LH biarc from p200 to p110
add(nullptr,
create(nullptr,
{.fromEnd = {.position = P200, .direction = half_pi},
.toEnd = {.position = P110, .direction = half_pi}}));
+ // 7 and 8 - RL S biarc from p100 to p110
add(nullptr,
create(nullptr,
{.fromEnd = {.position = P100, .direction = -half_pi},
@@ -182,21 +186,25 @@ BOOST_AUTO_TEST_CASE(NetworkJoins)
// Join 0 <-> 1
BOOST_REQUIRE_EQUAL(links[0]->ends[1].nexts.size(), 2);
BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[0].first.lock().get(), links[1].get());
- BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[0].second, 1);
+ BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[0].second, 0);
BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[1].first.lock().get(), links[7].get());
BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[1].second, 1);
BOOST_REQUIRE_EQUAL(links[1]->ends[0].nexts.size(), 2);
- BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[0].first.lock().get(), links[2].get());
- BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[0].second, 0);
- BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[1].first.lock().get(), links[5].get());
- BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[1].second, 0);
+ BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[0].first.lock().get(), links[0].get());
+ BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[0].second, 1);
+ BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[1].first.lock().get(), links[7].get());
+ BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[1].second, 1);
// Join 1 <-> 2
BOOST_REQUIRE_EQUAL(links[1]->ends[1].nexts.size(), 2);
- BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[0].first.lock().get(), links[0].get());
- BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[0].second, 1);
+ BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[0].first.lock().get(), links[2].get());
+ BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[0].second, 0);
+ BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[1].first.lock().get(), links[5].get());
+ BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[1].second, 0);
BOOST_REQUIRE_EQUAL(links[2]->ends[0].nexts.size(), 2);
BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[0].first.lock().get(), links[1].get());
- BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[0].second, 0);
+ BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[0].second, 1);
+ BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[1].first.lock().get(), links[5].get());
+ BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[1].second, 0);
}
BOOST_DATA_TEST_CASE(RouteToNodeNotInNetwork, INVALID_NODES, dest)
@@ -274,7 +282,10 @@ BOOST_DATA_TEST_CASE(GenCurveDefs,
}),
start, end, startDir, exp)
{
- BOOST_CHECK_EQUAL(genCurveDef(start, end, startDir), exp);
+ const auto defs = genDef(start, end, startDir);
+ BOOST_REQUIRE_EQUAL(defs.size(), 1);
+ BOOST_REQUIRE_EQUAL(defs.front().index(), 1);
+ BOOST_CHECK_EQUAL(std::get<GenCurveDef>(defs.front()), exp);
}
BOOST_AUTO_TEST_CASE(NetworkCreateStraight)
@@ -299,6 +310,54 @@ BOOST_AUTO_TEST_CASE(NetworkCreateStraight)
BOOST_CHECK_EQUAL(nodes.size(), 2);
}
+BOOST_AUTO_TEST_CASE(NetworkCreateExtendingStraight)
+{
+ const auto link = create(nullptr,
+ CreationDefinition {
+ .fromEnd = {.position = {0, 0, 0}, .direction = pi + quarter_pi},
+ .toEnd = {.position = {1000, 1000, 0}, .direction = {}},
+ });
+ BOOST_REQUIRE_EQUAL(link.size(), 1);
+ BOOST_CHECK(links.empty());
+ BOOST_CHECK(nodes.empty());
+
+ BOOST_CHECK_IF(straight, std::dynamic_pointer_cast<TestLinkS>(link.front())) {
+ BOOST_CHECK_CLOSE(straight->length, 1414, 1);
+ BOOST_CHECK_CLOSE_VECI(straight->ends.front().node->pos, GlobalPosition3D(0, 0, 0));
+ BOOST_CHECK_CLOSE(straight->ends.front().dir, quarter_pi - pi, 1);
+ BOOST_CHECK_CLOSE_VECI(straight->ends.back().node->pos, GlobalPosition3D(1000, 1000, 0));
+ BOOST_CHECK_CLOSE(straight->ends.back().dir, quarter_pi, 1);
+ }
+
+ add(nullptr, link.front());
+ BOOST_CHECK_EQUAL(links.size(), 1);
+ BOOST_CHECK_EQUAL(nodes.size(), 2);
+}
+
+BOOST_AUTO_TEST_CASE(NetworkCreateExtendeeStraight)
+{
+ const auto link = create(nullptr,
+ CreationDefinition {
+ .fromEnd = {.position = {0, 0, 0}, .direction = {}},
+ .toEnd = {.position = {1000, 1000, 0}, .direction = quarter_pi},
+ });
+ BOOST_REQUIRE_EQUAL(link.size(), 1);
+ BOOST_CHECK(links.empty());
+ BOOST_CHECK(nodes.empty());
+
+ BOOST_CHECK_IF(straight, std::dynamic_pointer_cast<TestLinkS>(link.front())) {
+ BOOST_CHECK_CLOSE(straight->length, 1414, 1);
+ BOOST_CHECK_CLOSE_VECI(straight->ends.front().node->pos, GlobalPosition3D(1000, 1000, 0));
+ BOOST_CHECK_CLOSE(straight->ends.front().dir, quarter_pi, 1);
+ BOOST_CHECK_CLOSE_VECI(straight->ends.back().node->pos, GlobalPosition3D(0, 0, 0));
+ BOOST_CHECK_CLOSE(straight->ends.back().dir, quarter_pi - pi, 1);
+ }
+
+ add(nullptr, link.front());
+ BOOST_CHECK_EQUAL(links.size(), 1);
+ BOOST_CHECK_EQUAL(nodes.size(), 2);
+}
+
BOOST_AUTO_TEST_CASE(NetworkCreateExtendingCurve)
{
const auto link = create(nullptr,
@@ -393,24 +452,41 @@ BOOST_AUTO_TEST_CASE(NetworkCreateBiarcPair)
BOOST_CHECK_EQUAL(link.back()->ends.back().nexts.front().first.lock(), link.front());
}
-BOOST_AUTO_TEST_CASE(NetworkCreateBiarcPairEqTan)
+BOOST_AUTO_TEST_CASE(NetworkCreateBiarcPairEqTanLH)
{
- // This could be achieved with a single curve, but not there yet
+ // Creates a biarc pair and then merges them into a single curve
const auto link = create(nullptr,
CreationDefinition {
- .fromEnd = {.position = {0, 0, 0}, .direction = 0},
- .toEnd = {.position = {1000, 0, 0}, .direction = 0},
+ .fromEnd = {.position = {1000, 0, 0}, .direction = 0},
+ .toEnd = {.position = {0, 0, 0}, .direction = 0},
});
- BOOST_REQUIRE_EQUAL(link.size(), 2);
+ BOOST_REQUIRE_EQUAL(link.size(), 1);
BOOST_CHECK(links.empty());
BOOST_CHECK(nodes.empty());
BOOST_CHECK_IF(firstCurve, std::dynamic_pointer_cast<TestLinkC>(link.front())) {
+ BOOST_CHECK_CLOSE_VECI(firstCurve->ends.front().node->pos, GlobalPosition3D(1000, 0, 0));
+ BOOST_CHECK_CLOSE_VECI(firstCurve->ends.back().node->pos, GlobalPosition3D(0, 0, 0));
BOOST_CHECK_CLOSE_VECI(firstCurve->centreBase, GlobalPosition3D(500, 0, 0));
}
+}
- BOOST_CHECK_IF(secondCurve, std::dynamic_pointer_cast<TestLinkC>(link.back())) {
- BOOST_CHECK_CLOSE_VECI(secondCurve->centreBase, GlobalPosition3D(500, 0, 0));
+BOOST_AUTO_TEST_CASE(NetworkCreateBiarcPairEqTanRH)
+{
+ // Creates a biarc pair and then merges them into a single curve
+ const auto link = create(nullptr,
+ CreationDefinition {
+ .fromEnd = {.position = {0, 0, 0}, .direction = 0},
+ .toEnd = {.position = {1000, 0, 0}, .direction = 0},
+ });
+ BOOST_REQUIRE_EQUAL(link.size(), 1);
+ BOOST_CHECK(links.empty());
+ BOOST_CHECK(nodes.empty());
+
+ BOOST_CHECK_IF(firstCurve, std::dynamic_pointer_cast<TestLinkC>(link.front())) {
+ BOOST_CHECK_CLOSE_VECI(firstCurve->ends.front().node->pos, GlobalPosition3D(1000, 0, 0));
+ BOOST_CHECK_CLOSE_VECI(firstCurve->ends.back().node->pos, GlobalPosition3D(0, 0, 0));
+ BOOST_CHECK_CLOSE_VECI(firstCurve->centreBase, GlobalPosition3D(500, 0, 0));
}
}
@@ -436,72 +512,3 @@ BOOST_AUTO_TEST_CASE(NetworkCreateBiarcPairEqTanPerp)
}
BOOST_AUTO_TEST_SUITE_END()
-
-BOOST_FIXTURE_TEST_CASE(TestRailNetwork, RailLinks)
-{
- // 0 1 2
- // --p000 <-> p100 <-> p200 <-> p300 \ x
- // / ?----- \ x
- // / / \ |
- // | / 4 /
- // 3 p110 \ /
- // \ | \ /
- // \ / ------/
- // --------
- auto link0 = addLinksBetween(P000, P100);
- BOOST_CHECK(dynamic_cast<RailLinkStraight *>(link0.get()));
- BOOST_CHECK_EQUAL(link0->length, ::distance(P000, P100));
- BOOST_CHECK_CLOSE(link0->ends[0].dir, half_pi, 0.1F);
- BOOST_CHECK_CLOSE(link0->ends[1].dir, -half_pi, 0.1F);
- BOOST_CHECK(link0->ends[0].nexts.empty());
- BOOST_CHECK(link0->ends[1].nexts.empty());
-
- auto link1 = addLinksBetween(P200, P100);
- BOOST_CHECK(dynamic_cast<RailLinkStraight *>(link1.get()));
- BOOST_CHECK_EQUAL(link1->length, ::distance(P200, P100));
- BOOST_CHECK_CLOSE(link1->ends[0].dir, half_pi, 0.1F);
- BOOST_CHECK_CLOSE(link1->ends[1].dir, -half_pi, 0.1F);
- BOOST_CHECK(link0->ends[0].nexts.empty());
- BOOST_CHECK_EQUAL(link0->ends[1].nexts.at(0).first.lock(), link1);
- BOOST_CHECK_EQUAL(link0->ends[1].nexts.at(0).second, 0);
- BOOST_CHECK_EQUAL(link1->ends[0].nexts.at(0).first.lock(), link0);
- BOOST_CHECK_EQUAL(link1->ends[0].nexts.at(0).second, 1);
- BOOST_CHECK(link1->ends[1].nexts.empty());
-
- auto link2 = addLinksBetween(P200, P300);
- BOOST_CHECK(dynamic_cast<RailLinkStraight *>(link2.get()));
- BOOST_CHECK_EQUAL(link2->length, ::distance(P200, P300));
- BOOST_CHECK_CLOSE(link2->ends[0].dir, half_pi, 0.1F);
- BOOST_CHECK_CLOSE(link2->ends[1].dir, -half_pi, 0.1F);
- BOOST_CHECK(link0->ends[0].nexts.empty());
- BOOST_CHECK_EQUAL(link1->ends[1].nexts.at(0).first.lock(), link2);
- BOOST_CHECK_EQUAL(link1->ends[1].nexts.at(0).second, 0);
- BOOST_CHECK_EQUAL(link2->ends[0].nexts.at(0).first.lock(), link1);
- BOOST_CHECK_EQUAL(link2->ends[0].nexts.at(0).second, 1);
- BOOST_CHECK(link2->ends[1].nexts.empty());
-
- BOOST_CHECK_IF(link3, addLinksBetween(P000, P110)) {
- BOOST_CHECK_IF(link3c, dynamic_cast<RailLinkCurve *>(link3.get())) {
- BOOST_CHECK_CLOSE(link3c->radius, 10'300.F, 0.1F);
- BOOST_CHECK_CLOSE(link3c->arc.length(), pi + half_pi, 0.5F);
- BOOST_CHECK_CLOSE(link3->length, 48'563.F, 0.1F);
- BOOST_CHECK_CLOSE(link3->ends[0].dir, -half_pi, 0.5F);
- BOOST_CHECK_CLOSE(link3->ends[1].dir, -0.0097F, 0.5F);
- BOOST_CHECK_EQUAL(link0->ends[0].nexts.at(0).first.lock(), link3);
- BOOST_CHECK_EQUAL(link0->ends[0].nexts.at(0).second, 0);
- BOOST_CHECK_EQUAL(link3->ends[0].nexts.at(0).first.lock(), link0);
- BOOST_CHECK_EQUAL(link3->ends[0].nexts.at(0).second, 0);
- BOOST_CHECK(link3->ends[1].nexts.empty());
- }
- }
-
- BOOST_CHECK_IF(link4, addLinksBetween(P110, P300)) {
- BOOST_CHECK_IF(link4c, dynamic_cast<RailLinkCurve *>(link4.get())) {
- BOOST_CHECK_CLOSE(link4c->radius, 6950.F, 0.1F);
- BOOST_CHECK_CLOSE(link4c->arc.length(), 4.456F, 0.1F);
- BOOST_CHECK_CLOSE(link4->length, 30'981.F, 0.1F);
- BOOST_CHECK_BETWEEN(link4->ends[0].dir, .25F, .26F);
- BOOST_CHECK_CLOSE(link4->ends[1].dir, half_pi, 0.1F);
- }
- }
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-01 00:12:07 +0000