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