Merge branch 'main' into scpeters/line2_template_api

Author: scpeters

.github/workflows/bazel_repeat_flaky_tests.yml

@@ -0,0 +1,14 @@
+name: Bazel repeat flaky tests
+on:
+  schedule:
+    # GitHub caches are purged after 7 days of inactivity, so
+    # running twice a week helps protect the bazel cache
+    # Run at 16:00 UTC, Monday and Friday
+    - cron: '0 16 * * 1,5'
+
+jobs:
+  repeat-flaky-tests:
+    uses: ./.github/workflows/bazel_repeat_tests.yml
+    with:
+      flaky: 1
+      runs_per_test: 10

.github/workflows/bazel_repeat_non_flaky_tests.yml

@@ -0,0 +1,14 @@
+name: Bazel repeat non-flaky tests
+on:
+  schedule:
+    # GitHub caches are purged after 7 days of inactivity, so
+    # running twice a week helps protect the bazel cache
+    # Run at 17:00 UTC, Monday and Friday
+    - cron: '0 17 * * 1,5'
+
+jobs:
+  repeat-non-flaky-tests:
+    uses: ./.github/workflows/bazel_repeat_tests.yml
+    with:
+      flaky: 0
+      runs_per_test: 10

.github/workflows/bazel_repeat_tests.yml

@@ -0,0 +1,38 @@
+name: Bazel repeat tests
+on:
+  workflow_call:
+    inputs: &shared_inputs
+      flaky:
+        description: "0 to execute non-flaky tests, 1 to execute flaky tests"
+        default: 0
+        required: false
+        type: string
+      runs_per_test:
+        description: "Number of times to repeat each test"
+        default: 10
+        required: false
+        type: string
+  workflow_dispatch:
+    inputs: *shared_inputs
+
+jobs:
+  repeat-tests:
+    uses: bazel-contrib/.github/.github/workflows/bazel.yaml@v7.7.0
+    with:
+      folders: |
+        [
+          "."
+        ]
+      exclude: |
+        [
+          {"folder": ".", "bzlmodEnabled": false}
+        ]
+      exclude_windows: true
+      bazel_test_command: |
+        # Exit with success code 0 if no targets match the query
+        # `grep -q '^' fails if the query output is empty
+        bazel query "attr(flaky, ${{ inputs.flaky }}, tests(//...))" \
+            | grep -q '^' || exit 0
+        bazel test --runs_per_test=${{ inputs.runs_per_test }} \
+            --test_output=errors \
+            $(bazel query "attr(flaky, ${{ inputs.flaky }}, tests(//...))")

include/gz/math/Line3.hh

@@ -48,8 +48,8 @@ namespace gz::math
     /// \param[in] _y1 Y coordinate of the start point.
     /// \param[in] _x2 X coordinate of the end point.
     /// \param[in] _y2 Y coordinate of the end point.
-    public: Line3(const double _x1, const double _y1,
-      const double _x2, const double _y2)
+    public: Line3(const T _x1, const T _y1,
+      const T _x2, const T _y2)
     {
       this->Set(_x1, _y1, _x2, _y2);
     }
@@ -61,9 +61,9 @@ namespace gz::math
     /// \param[in] _x2 X coordinate of the end point.
     /// \param[in] _y2 Y coordinate of the end point.
     /// \param[in] _z2 Z coordinate of the end point.
-    public: Line3(const double _x1, const double _y1,
-      const double _z1, const double _x2,
-      const double _y2, const double _z2)
+    public: Line3(const T _x1, const T _y1,
+      const T _z1, const T _x2,
+      const T _y2, const T _z2)
     {
       this->Set(_x1, _y1, _z1, _x2, _y2, _z2);
     }
@@ -100,9 +100,9 @@ namespace gz::math
     /// \param[in] _y2 Y coordinate of the end point.
     /// \param[in] _z Z coordinate of both points,
     /// by default _z is set to 0.
-    public: void Set(const double _x1, const double _y1,
-      const double _x2, const double _y2,
-      const double _z = 0)
+    public: void Set(const T _x1, const T _y1,
+      const T _x2, const T _y2,
+      const T _z = 0)
     {
       this->pts[0].Set(_x1, _y1, _z);
       this->pts[1].Set(_x2, _y2, _z);
@@ -115,9 +115,9 @@ namespace gz::math
     /// \param[in] _x2 X coordinate of the end point.
     /// \param[in] _y2 Y coordinate of the end point.
     /// \param[in] _z2 Z coordinate of the end point.
-    public: void Set(const double _x1, const double _y1,
-      const double _z1, const double _x2,
-      const double _y2, const double _z2)
+    public: void Set(const T _x1, const T _y1,
+      const T _z1, const T _x2,
+      const T _y2, const T _z2)
     {
       this->pts[0].Set(_x1, _y1, _z1);
       this->pts[1].Set(_x2, _y2, _z2);
@@ -134,7 +134,7 @@ namespace gz::math
     /// \return The length of the line.
     public: T Length() const
     {
-      return this->pts[0].Distance(this->pts[1]);
+      return static_cast<T>(this->pts[0].Distance(this->pts[1]));
     }
 
     /// \brief Get the shortest line between this line and the
@@ -214,7 +214,8 @@ namespace gz::math
       double mua = clamp(numer / denom, 0.0, 1.0);
       double mub = clamp((d1343 + d4321 * mua) / d4343, 0.0, 1.0);
 
-      _result.Set(this->pts[0] + (p21 * mua), _line[0] + (p43 * mub));
+      _result.Set(this->pts[0] + (p21 * static_cast<T>(mua)),
+                  _line[0] + (p43 * static_cast<T>(mub)));
 
       return true;
     }
@@ -229,13 +230,13 @@ namespace gz::math
       auto ptTo1 = _pt - this->pts[1];
 
       // Point is projected beyond pt0 or the line has length 0
-      if (ptTo0.Dot(line) <= 0.0)
+      if (ptTo0.Dot(line) <= static_cast<T>(0))
       {
         return ptTo0.Length();
       }
 
       // Point is projected beyond pt1
-      if (ptTo1.Dot(line) >= 0.0)
+      if (ptTo1.Dot(line) >= static_cast<T>(0))
       {
         return ptTo1.Length();
       }
@@ -341,18 +342,19 @@ namespace gz::math
     public: bool Within(const math::Vector3<T> &_pt,
                         double _epsilon = 1e-6) const
     {
+      auto eps = static_cast<T>(_epsilon);
       return _pt.X() <= std::max(this->pts[0].X(),
-                                 this->pts[1].X()) + _epsilon &&
+                                 this->pts[1].X()) + eps &&
              _pt.X() >= std::min(this->pts[0].X(),
-                                 this->pts[1].X()) - _epsilon &&
+                                 this->pts[1].X()) - eps &&
              _pt.Y() <= std::max(this->pts[0].Y(),
-                                 this->pts[1].Y()) + _epsilon &&
+                                 this->pts[1].Y()) + eps &&
              _pt.Y() >= std::min(this->pts[0].Y(),
-                                 this->pts[1].Y()) - _epsilon &&
+                                 this->pts[1].Y()) - eps &&
              _pt.Z() <= std::max(this->pts[0].Z(),
-                                 this->pts[1].Z()) + _epsilon &&
+                                 this->pts[1].Z()) + eps &&
              _pt.Z() >= std::min(this->pts[0].Z(),
-                                 this->pts[1].Z()) - _epsilon;
+                                 this->pts[1].Z()) - eps;
     }
 
     /// \brief Equality operator.

src/Line3_TEST.cc

@@ -25,6 +25,10 @@ using namespace gz;
 /////////////////////////////////////////////////
 TEST(Line3Test, Constructor)
 {
+  math::Line3d lineDefault;
+  EXPECT_EQ(lineDefault[0], math::Vector3d::Zero);
+  EXPECT_EQ(lineDefault[1], math::Vector3d::Zero);
+
   math::Line3d lineA(0, 0, 10, 10);
   EXPECT_DOUBLE_EQ(lineA[0].X(), 0.0);
   EXPECT_DOUBLE_EQ(lineA[0].Y(), 0.0);
@@ -88,6 +92,10 @@ TEST(Line3Test, Set)
   EXPECT_DOUBLE_EQ(lineA[1].X(), 5.0);
   EXPECT_DOUBLE_EQ(lineA[1].Y(), 6.0);
   EXPECT_DOUBLE_EQ(lineA[1].Z(), 7.0);
+
+  lineA.Set(math::Vector3d(20, 21, 22), math::Vector3d(23, 24, 25));
+  EXPECT_EQ(lineA[0], math::Vector3d(20, 21, 22));
+  EXPECT_EQ(lineA[1], math::Vector3d(23, 24, 25));
 }
 
 /////////////////////////////////////////////////
@@ -344,6 +352,17 @@ TEST(Line3Test, Intersect)
 
   EXPECT_TRUE(line.Intersect(math::Line3d(0, -1, 0, 0, 0.1, 0)));
   EXPECT_TRUE(line.Intersect(math::Line3d(0, 1, 0, 0, 1.1, 0)));
+
+  // Parallel non-overlapping lines
+  EXPECT_FALSE(line.Intersect(math::Line3d(0, 2, 0, 0, 3, 0)));
+  EXPECT_FALSE(line.Intersect(math::Line3d(0, 2, 0, 0, 3, 0), pt));
+
+  // Parallel overlapping line where _line[0] is within this line
+  EXPECT_TRUE(line.Intersect(math::Line3d(0, 0.5, 0, 0, 2, 0), pt));
+  EXPECT_EQ(pt, math::Vector3d(0, 0.5, 0));
+
+  // Skew non-intersecting lines
+  EXPECT_FALSE(line.Intersect(math::Line3d(1, 0, 1, 1, 1, 1), pt));
 }
 
 /////////////////////////////////////////////////
@@ -371,3 +390,17 @@ TEST(Line3Test, Coplanar)
   EXPECT_FALSE(line.Coplanar(math::Line3d(1, 0, 0, 1, 1, 1)));
   EXPECT_FALSE(line.Coplanar(math::Line3d(1, 0, 1, 2, 0, 0)));
 }
+
+/////////////////////////////////////////////////
+TEST(Line3Test, TemplateTypes)
+{
+  math::Line3i lineI(0, 0, 0, 10, 10, 10);
+  EXPECT_EQ(lineI[0], math::Vector3i(0, 0, 0));
+  EXPECT_EQ(lineI[1], math::Vector3i(10, 10, 10));
+
+  math::Line3f lineF(0.0f, 0.0f, 0.0f, 10.0f, 10.0f, 10.0f);
+  EXPECT_FLOAT_EQ(lineF[0].X(), 0.0f);
+  EXPECT_FLOAT_EQ(lineF[1].Y(), 10.0f);
+  EXPECT_NEAR(lineF.Length(), 17.320508f, 1e-4f);
+}
+

src/python_pybind11/src/Line3.hh

@@ -60,10 +60,10 @@ void helpDefineMathLine3(py::module &m, const std::string &typestr)
     .def(py::init<const gz::math::Vector3<T>&,
                   const gz::math::Vector3<T>&>(),
          "Constructor")
-    .def(py::init<const double, const double, const double, const double>(),
+    .def(py::init<const T, const T, const T, const T>(),
          "2D Constructor where Z coordinates are 0")
-    .def(py::init<const double, const double, const double, const double,
-                  const double, const double>(),
+    .def(py::init<const T, const T, const T, const T,
+                  const T, const T>(),
          "Constructor")
     .def(py::self != py::self)
     .def(py::self == py::self)
@@ -78,15 +78,15 @@ void helpDefineMathLine3(py::module &m, const std::string &typestr)
          &Class::SetB,
          "Set the end point of the line segment")
     .def("set",
-         py::overload_cast<const double, const double, const double,
-                           const double, const double>(&Class::Set),
+         py::overload_cast<const T, const T, const T,
+                           const T, const T>(&Class::Set),
          py::arg("_x1"), py::arg("_y1"), py::arg("_x2"),
-         py::arg("_y2"), py::arg("_z") = 0,
+         py::arg("_y2"), py::arg("_z") = static_cast<T>(0),
          "Set the start and end point of the line segment, assuming that "
          "both points have the same height.")
     .def("set",
-         py::overload_cast<const double, const double, const double,
-                           const double, const double, const double>(
+         py::overload_cast<const T, const T, const T,
+                           const T, const T, const T>(
                              &Class::Set),
          "Set the start and end point of the line segment")
     .def("direction",

src/python_pybind11/test/Line3_TEST.py

@@ -15,7 +15,11 @@
 import math
 import unittest
 from gz.math import Line3d
+from gz.math import Line3f
+from gz.math import Line3i
 from gz.math import Vector3d
+from gz.math import Vector3f
+from gz.math import Vector3i
 
 
 class TestLine3d(unittest.TestCase):
@@ -80,6 +84,10 @@ def test_set(self):
         self.assertAlmostEqual(line_a[1].y(), 6.0)
         self.assertAlmostEqual(line_a[1].z(), 7.0)
 
+        line_a.set(Vector3d(20, 21, 22), Vector3d(23, 24, 25))
+        self.assertEqual(line_a[0], Vector3d(20, 21, 22))
+        self.assertEqual(line_a[1], Vector3d(23, 24, 25))
+
     def test_length(self):
         line_a = Line3d(0, 0, 0, 10, 10, 10)
         self.assertAlmostEqual(line_a.length(), math.sqrt(300), delta=1e-10)
@@ -225,6 +233,17 @@ def test_interesct(self):
         self.assertTrue(line.intersect(Line3d(0, -1, 0, 0, 0.1, 0)))
         self.assertTrue(line.intersect(Line3d(0, 1, 0, 0, 1.1, 0)))
 
+        # Parallel non-overlapping lines
+        self.assertFalse(line.intersect(Line3d(0, 2, 0, 0, 3, 0)))
+        self.assertFalse(line.intersect(Line3d(0, 2, 0, 0, 3, 0), pt))
+
+        # Parallel overlapping line where _line[0] is within this line
+        self.assertTrue(line.intersect(Line3d(0, 0.5, 0, 0, 2, 0), pt))
+        self.assertEqual(pt, Vector3d(0, 0.5, 0))
+
+        # Skew non-intersecting lines
+        self.assertFalse(line.intersect(Line3d(1, 0, 1, 1, 1, 1), pt))
+
     def test_parallel(self):
         line = Line3d(0, 0, 0, 0, 1, 0)
         self.assertTrue(line.parallel(Line3d(1, 0, 0, 1, 1, 0)))
@@ -245,6 +264,17 @@ def test_coplanar(self):
         self.assertFalse(line.coplanar(Line3d(1, 0, 0, 1, 1, 1)))
         self.assertFalse(line.coplanar(Line3d(1, 0, 1, 2, 0, 0)))
 
+    def test_template_types(self):
+        line_i = Line3i(0, 0, 0, 10, 10, 10)
+        self.assertEqual(line_i[0], Vector3i(0, 0, 0))
+        self.assertEqual(line_i[1], Vector3i(10, 10, 10))
+
+        line_f = Line3f(0.0, 0.0, 0.0, 10.0, 10.0, 10.0)
+        self.assertAlmostEqual(line_f[0].x(), 0.0)
+        self.assertAlmostEqual(line_f[1].y(), 10.0)
+        self.assertAlmostEqual(line_f.length(), 17.320508, delta=1e-4)
+
 
 if __name__ == '__main__':
     unittest.main()
+