Core/Surfaces/BoundaryToleranceTests.cpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #include <boost/test/execution_monitor.hpp>
0010 #include <boost/test/unit_test.hpp>
0011
0012 #include "Acts/Definitions/Algebra.hpp"
0013 #include "Acts/Surfaces/BoundaryTolerance.hpp"
0014 #include "Acts/Surfaces/ConvexPolygonBounds.hpp"
0015 #include "Acts/Surfaces/PlanarBounds.hpp"
0016
0017 namespace Acts::Test {
0018
0019 BOOST_AUTO_TEST_SUITE(Surfaces)
0020
0021 BOOST_AUTO_TEST_CASE(BoundaryToleranceConstructors) {
0022   using enum BoundaryTolerance::ToleranceMode;
0023   {
0024     // Test None constructor
0025     BoundaryTolerance tolerance = BoundaryTolerance::None();
0026     BOOST_CHECK(tolerance.toleranceMode() == None);
0027   }
0028
0029   // Test AbsoluteEuclidean constructor
0030   {
0031     // Valid positive tolerance
0032     auto tolerance = BoundaryTolerance::AbsoluteEuclidean(1.0);
0033     BOOST_CHECK_EQUAL(tolerance.asAbsoluteEuclidean().tolerance, 1.0);
0034     BOOST_CHECK(tolerance.toleranceMode() == Extend);
0035     BOOST_CHECK(BoundaryTolerance::AbsoluteEuclidean(0.0).toleranceMode() ==
0036                 None);
0037
0038     // Valid negative tolerance
0039     tolerance = BoundaryTolerance::AbsoluteEuclidean(-1.0);
0040     BOOST_CHECK_EQUAL(tolerance.asAbsoluteEuclidean().tolerance, -1.0);
0041     BOOST_CHECK(tolerance.toleranceMode() == Shrink);
0042   }
0043
0044   // Test Chi2Bound constructor
0045   {
0046     SquareMatrix2 cov;
0047     cov << 1, 0.5, 0.5, 2;
0048
0049     // Valid positive chi2 bound
0050     auto tolerance = BoundaryTolerance::Chi2Bound(cov, 3.0);
0051     BOOST_CHECK_EQUAL(tolerance.asChi2Bound().maxChi2, 3.0);
0052     BOOST_CHECK(tolerance.toleranceMode() == Extend);
0053     BOOST_CHECK(BoundaryTolerance::Chi2Bound(cov, 0.0).toleranceMode() == None);
0054
0055     // Valid negative chi2 bound
0056     tolerance = BoundaryTolerance::Chi2Bound(cov, -3.0);
0057     BOOST_CHECK_EQUAL(tolerance.asChi2Bound().maxChi2, -3.0);
0058     BOOST_CHECK(tolerance.toleranceMode() == Shrink);
0059   }
0060
0061   // Test None constructor
0062   BoundaryTolerance::None();
0063 }
0064
0065 // See: https://en.wikipedia.org/wiki/Bounding_volume
0066 //
0067 // Aligned box w/ simple check
0068 BOOST_AUTO_TEST_CASE(BoundaryCheckBoxSimple) {
0069   Vector2 ll(-1, -1);
0070   Vector2 ur(1, 1);
0071   RectangleBounds bounds(ll, ur);
0072   auto tolerance = BoundaryTolerance::None();
0073   BOOST_CHECK(bounds.inside({0, 0}, tolerance));
0074   BOOST_CHECK(!bounds.inside({2, 2}, tolerance));
0075   BOOST_CHECK(!bounds.inside({0, 2}, tolerance));
0076   BOOST_CHECK(!bounds.inside({2, 0}, tolerance));
0077 }
0078
0079 // Aligned box w/ covariance check
0080 BOOST_AUTO_TEST_CASE(BoundaryCheckBoxCovariance) {
0081   SquareMatrix2 cov;
0082   cov << 1, 0.5, 0.5, 2;
0083   Vector2 ll(-1, -1);
0084   Vector2 ur(1, 1);
0085   RectangleBounds bounds(ll, ur);
0086   auto tolerance = BoundaryTolerance::Chi2Bound(cov.inverse(), 4);
0087   BOOST_CHECK(bounds.inside({0, 0}, tolerance));
0088   BOOST_CHECK(bounds.inside({2, 2}, tolerance));
0089   BOOST_CHECK(!bounds.inside({4, 4}, tolerance));
0090   BOOST_CHECK(bounds.inside({0, 3}, tolerance));
0091   BOOST_CHECK(bounds.inside({3, 0}, tolerance));
0092 }
0093
0094 // Triangle w/ simple check
0095 BOOST_AUTO_TEST_CASE(BoundaryCheckTriangleSimple) {
0096   ConvexPolygonBounds<PolygonDynamic> poly({{-2, 0}, {2, 0}, {0, 2}});
0097   auto tolerance = BoundaryTolerance::None();
0098   BOOST_CHECK(poly.inside({0, 0}, tolerance));
0099   BOOST_CHECK(poly.inside({0, 1}, tolerance));
0100   BOOST_CHECK(!poly.inside({2, 2}, tolerance));
0101   BOOST_CHECK(!poly.inside({0, -1}, tolerance));
0102 }
0103 // Triangle w/ covariance check
0104 BOOST_AUTO_TEST_CASE(BoundaryCheckTriangleCovariance) {
0105   ConvexPolygonBounds<PolygonDynamic> poly({{-2, 0}, {2, 0}, {0, 2}});
0106   SquareMatrix2 cov;
0107   cov << 0.5, 0, 0, 0.5;
0108   auto tolerance = BoundaryTolerance::Chi2Bound(cov.inverse(), 8);
0109   BOOST_CHECK(poly.inside({0, 0}, tolerance));
0110   BOOST_CHECK(poly.inside({0, 1}, tolerance));
0111   BOOST_CHECK(poly.inside({0, 2}, tolerance));
0112   BOOST_CHECK(poly.inside({0, 3}, tolerance));
0113   BOOST_CHECK(poly.inside({0, 4}, tolerance));
0114   BOOST_CHECK(!poly.inside({0, 5}, tolerance));
0115 }
0116
0117 BOOST_AUTO_TEST_CASE(BoundaryCheckDifferentTolerances) {
0118   Vector2 ll(-1, -1);
0119   Vector2 ur(1, 1);
0120   RectangleBounds bounds(ll, ur);
0121
0122   {
0123     auto tolerance = BoundaryTolerance::None();
0124     BOOST_CHECK(bounds.inside({0, 0}, tolerance));
0125     BOOST_CHECK(!bounds.inside({2, 2}, tolerance));
0126     BOOST_CHECK(!bounds.inside({0, 2}, tolerance));
0127     BOOST_CHECK(!bounds.inside({2, 0}, tolerance));
0128   }
0129
0130   {
0131     auto tolerance = BoundaryTolerance::Infinite();
0132     BOOST_CHECK(bounds.inside({0, 0}, tolerance));
0133     BOOST_CHECK(bounds.inside({2, 2}, tolerance));
0134     BOOST_CHECK(bounds.inside({0, 2}, tolerance));
0135     BOOST_CHECK(bounds.inside({2, 0}, tolerance));
0136   }
0137
0138   {
0139     auto tolerance = BoundaryTolerance::AbsoluteEuclidean(1.1);
0140     BOOST_CHECK(bounds.inside({0, 0}, tolerance));
0141     BOOST_CHECK(!bounds.inside({2, 2}, tolerance));
0142     BOOST_CHECK(bounds.inside({0, 2}, tolerance));
0143     BOOST_CHECK(bounds.inside({2, 0}, tolerance));
0144   }
0145
0146   {
0147     auto tolerance = BoundaryTolerance::Chi2Bound(SquareMatrix2::Identity(), 2);
0148     BOOST_CHECK(bounds.inside({0, 0}, tolerance));
0149     BOOST_CHECK(bounds.inside({2, 2}, tolerance));
0150     BOOST_CHECK(bounds.inside({0, 2}, tolerance));
0151     BOOST_CHECK(bounds.inside({2, 0}, tolerance));
0152     BOOST_CHECK(!bounds.inside({3, 3}, tolerance));
0153   }
0154 }
0155
0156 BOOST_AUTO_TEST_CASE(BoundaryCheckNegativeToleranceRect) {
0157   // Test points for boundary check with euclidean tolerance
0158   Vector2 ll(1, 1);
0159   Vector2 ur(3, 3);
0160   RectangleBounds bounds(ll, ur);
0161
0162   auto check = [&bounds](const BoundaryTolerance& tolerance,
0163                          const Vector2& point) {
0164     return bounds.inside(point, tolerance);
0165   };
0166
0167   {
0168     auto tolerance = BoundaryTolerance::AbsoluteEuclidean(-0.25);
0169
0170     BOOST_CHECK(!check(tolerance, {2.8, 2}));
0171     BOOST_CHECK(!check(tolerance, {3.1, 2}));
0172     BOOST_CHECK(check(tolerance, {2.7, 2}));
0173     BOOST_CHECK(!check(tolerance, {2, 3.1}));
0174     BOOST_CHECK(!check(tolerance, {2, 2.8}));
0175     BOOST_CHECK(check(tolerance, {2, 2.7}));
0176
0177     BOOST_CHECK(!check(tolerance, {0.8, 2}));
0178     BOOST_CHECK(!check(tolerance, {1.2, 2}));
0179     BOOST_CHECK(check(tolerance, {1.5, 2}));
0180     BOOST_CHECK(!check(tolerance, {2, 0.8}));
0181     BOOST_CHECK(!check(tolerance, {2, 1.2}));
0182     BOOST_CHECK(check(tolerance, {2, 1.5}));
0183   }
0184
0185   {
0186     auto tolerance =
0187         BoundaryTolerance::Chi2Bound(SquareMatrix2::Identity(), -0.2);
0188
0189     BOOST_CHECK(!check(tolerance, {2.8, 2}));
0190     BOOST_CHECK(!check(tolerance, {3.1, 2}));
0191     BOOST_CHECK(check(tolerance, {2.5, 2}));
0192     BOOST_CHECK(!check(tolerance, {2, 3.1}));
0193     BOOST_CHECK(!check(tolerance, {2, 2.8}));
0194     BOOST_CHECK(check(tolerance, {2, 2.5}));
0195
0196     BOOST_CHECK(!check(tolerance, {0.8, 2}));
0197     BOOST_CHECK(!check(tolerance, {1.4, 2}));
0198     BOOST_CHECK(check(tolerance, {1.5, 2}));
0199     BOOST_CHECK(!check(tolerance, {2, 0.8}));
0200     BOOST_CHECK(!check(tolerance, {2, 1.4}));
0201     BOOST_CHECK(check(tolerance, {2, 1.5}));
0202   }
0203 }
0204
0205 BOOST_AUTO_TEST_CASE(BoundaryCheckNegativeToleranceTrap) {
0206   ConvexPolygonBounds<PolygonDynamic> bounds(
0207       {{1.5, 1}, {2.5, 1}, {3, 3}, {1, 3}});
0208
0209   auto check = [&bounds](const BoundaryTolerance& tolerance,
0210                          const Vector2& point) {
0211     return bounds.inside(point, tolerance);
0212   };
0213
0214   {
0215     auto tolerance = BoundaryTolerance::AbsoluteEuclidean(0.25);
0216     // Axes
0217     BOOST_CHECK(!check(tolerance, {3.1, 2}));
0218     BOOST_CHECK(check(tolerance, {2.75, 2}));
0219     BOOST_CHECK(check(tolerance, {2.5, 2}));
0220     BOOST_CHECK(check(tolerance, {2.25, 2}));
0221     BOOST_CHECK(check(tolerance, {2, 3.1}));
0222     BOOST_CHECK(check(tolerance, {2, 2.75}));
0223     BOOST_CHECK(check(tolerance, {2, 2.5}));
0224     BOOST_CHECK(check(tolerance, {2, 2.25}));
0225     BOOST_CHECK(check(tolerance, {2, 2}));
0226
0227     // Corners
0228     BOOST_CHECK(check(tolerance, {3.1, 3.2}));
0229     BOOST_CHECK(check(tolerance, {0.9, 3.2}));
0230     BOOST_CHECK(check(tolerance, {1.5, 0.8}));
0231     BOOST_CHECK(check(tolerance, {2.5, 0.8}));
0232   }
0233
0234   {
0235     auto tolerance = BoundaryTolerance::AbsoluteEuclidean(-0.25);
0236     // Axes
0237     BOOST_CHECK(!check(tolerance, {3.0, 2}));
0238     BOOST_CHECK(!check(tolerance, {2.5, 2}));
0239     BOOST_CHECK(check(tolerance, {2.25, 2}));
0240     BOOST_CHECK(!check(tolerance, {2, 3.1}));
0241     BOOST_CHECK(!check(tolerance, {2, 2.9}));
0242     BOOST_CHECK(check(tolerance, {2, 2.7}));
0243
0244     // Corners
0245     BOOST_CHECK(!check(tolerance, {2.7, 2.9}));
0246     BOOST_CHECK(check(tolerance, {2.4, 2.6}));
0247     BOOST_CHECK(!check(tolerance, {1.3, 2.9}));
0248     BOOST_CHECK(check(tolerance, {1.6, 2.6}));
0249     BOOST_CHECK(!check(tolerance, {2.4, 1.1}));
0250     BOOST_CHECK(check(tolerance, {1.75, 1.4}));
0251     BOOST_CHECK(!check(tolerance, {1.6, 1.1}));
0252     BOOST_CHECK(check(tolerance, {2.25, 1.4}));
0253   }
0254 }
0255
0256 BOOST_AUTO_TEST_SUITE_END()
0257
0258 }  // namespace Acts::Test