Merge pull request #263 from SimonRohou/codac2_dev

Various updates.. tubes, graphics, and minor corrections

Author: SimonRohou

doc/manual/manual/visualization/functions.rst

@@ -131,8 +131,8 @@ Geometric shapes
 .. doxygenfunction:: codac2::Figure2D::draw_ellipsoid(const Ellipsoid&, const StyleProperties&)
   :project: codac
 
-Trajectories
-------------
+Trajectories and tubes
+----------------------
 
 .. doxygenfunction:: codac2::Figure2D::draw_trajectory(const SampledTraj<Vector>&, const StyleProperties&)
   :project: codac
@@ -148,6 +148,12 @@ Trajectories can be drawn with a ColorMap instead of the classic StyleProperties
 .. doxygenfunction:: codac2::Figure2D::draw_trajectory(const AnalyticTraj<VectorType>&, const ColorMap&)
   :project: codac
 
+.. doxygenfunction:: codac2::Figure2D::draw_tube(const SlicedTube<IntervalVector>&, const StyleProperties&)
+  :project: codac
+
+.. doxygenfunction:: codac2::Figure2D::draw_tube(const SlicedTube<IntervalVector>&, const ColorMap&)
+  :project: codac
+
 Vehicles
 --------
 

python/src/core/codac2_py_cast.h

@@ -12,6 +12,7 @@
 
 #include <pybind11/pybind11.h>
 #include <codac2_AnalyticTraj.h>
+#include <codac2_SlicedTube.h>
 
 namespace py = pybind11;
 using namespace pybind11::literals;
@@ -103,4 +104,25 @@ namespace codac2
       const py::object& f_ = x.attr("f");
       return f_.cast<const T&>();
     }
+
+    template<typename T>
+      requires (std::is_same_v<SlicedTube<Interval>,T>
+        || std::is_same_v<SlicedTube<IntervalVector>,T>
+        || std::is_same_v<SlicedTube<IntervalMatrix>,T>)
+    bool is_instance(const py::object& x)
+    {
+      const py::object& x_ = x.attr("tube");
+      return x_ && py::isinstance<T>(x_);
+    }
+
+    template<typename T>
+      requires (std::is_same_v<SlicedTube<Interval>,T>
+        || std::is_same_v<SlicedTube<IntervalVector>,T>
+        || std::is_same_v<SlicedTube<IntervalMatrix>,T>)
+    const T& cast(const py::object& x)
+    {
+      assert(is_instance<T>(x));
+      const py::object& x_ = x.attr("tube");
+      return x_.cast<const T&>();
+    }
 }

python/src/core/paver/codac2_py_pave.cpp

@@ -10,6 +10,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/operators.h>
 #include <pybind11/stl.h>
+#include <pybind11/functional.h>
 #include <codac2_pave.h>
 #include "codac2_py_pave_docs.h" // Generated file from Doxygen XML (doxygen2docstring.py):
 #include "codac2_py_cast.h"
@@ -29,7 +30,7 @@ void export_pave(py::module& m)
     PAVINGINOUT_PAVE_CONST_INTERVALVECTOR_REF_CONST_SEPBASE_REF_DOUBLE_BOOL,
     "x"_a, "s"_a, "eps"_a, "verbose"_a=false);
 
-  m.def("pave", &codac2::regular_pave,
+  m.def("regular_pave", &codac2::regular_pave,
     PAVINGINOUT_REGULAR_PAVE_CONST_INTERVALVECTOR_REF_CONST_FUNCTION_BOOLINTERVAL_CONST_INTERVALVECTOR_REF__REF_DOUBLE_BOOL,
     "x"_a, "test"_a, "eps"_a, "verbose"_a=false);
 

python/src/graphics/figures/codac2_py_Figure2D.cpp

@@ -79,7 +79,7 @@ void export_Figure2D(py::module& m)
       CONST_VECTOR_FIGUREAXIS_REF_FIGURE2D_AXES_CONST)
 
     .def("set_axes", &Figure2D::set_axes,
-      VOID_FIGURE2D_SET_AXES_CONST_FIGUREAXIS_REF_CONST_FIGUREAXIS_REF,
+      FIGURE2D_REF_FIGURE2D_SET_AXES_CONST_FIGUREAXIS_REF_CONST_FIGUREAXIS_REF,
       "axis1"_a, "axis2"_a)
 
     .def("i", &Figure2D::i,
@@ -213,6 +213,27 @@ void export_Figure2D(py::module& m)
       VOID_FIGURE2D_PLOT_TRAJECTORY_CONST_SAMPLEDTRAJ_DOUBLE_REF_CONST_STYLEPROPERTIES_REF,
       "x"_a, "s"_a=StyleProperties())
 
+    .def("draw_tube", [](Figure2D& fig, const py::object& x, const StyleProperties& s)
+        {
+          if(!is_instance<SlicedTube<IntervalVector>>(x)) {
+            assert_release("draw_tube: invalid function type");
+          }
+
+          fig.draw_tube(cast<SlicedTube<IntervalVector>>(x), s);
+        },
+      VOID_FIGURE2D_DRAW_TUBE_CONST_SLICEDTUBE_INTERVALVECTOR_REF_CONST_STYLEPROPERTIES_REF,
+      "x"_a, "s"_a)
+
+    .def("draw_tube", [](Figure2D& fig, const py::object& x, const ColorMap& cmap)
+        {
+          if(!is_instance<SlicedTube<IntervalVector>>(x)) {
+            assert_release("draw_tube: invalid function type");
+          }
+
+          fig.draw_tube(cast<SlicedTube<IntervalVector>>(x), cmap);
+        },
+      VOID_FIGURE2D_DRAW_TUBE_CONST_SLICEDTUBE_INTERVALVECTOR_REF_CONST_COLORMAP_REF,
+      "x"_a, "cmap"_a)
 
     // Robots
 
@@ -253,14 +274,15 @@ void export_Figure2D(py::module& m)
 
     .def(py::init<>()) // for using static methods in Matlab
 
-    .def_static("selected_fig", &DefaultFigure::selected_fig,
+    .def_static("selected_fig", &DefaultFigure::selected_fig, py::return_value_policy::reference,
       STATIC_SHARED_PTR_FIGURE2D_DEFAULTFIGURE_SELECTED_FIG)
 
     .def_static("set", &DefaultFigure::set,
       STATIC_VOID_DEFAULTFIGURE_SET_SHARED_PTR_FIGURE2D)
 
-    .def_static("set_axes", &DefaultFigure::set_axes,
-      STATIC_VOID_DEFAULTFIGURE_SET_AXES_CONST_FIGUREAXIS_REF_CONST_FIGUREAXIS_REF)
+    .def_static("set_axes", &DefaultFigure::set_axes, py::return_value_policy::reference,
+      STATIC_FIGURE2D_REF_DEFAULTFIGURE_SET_AXES_CONST_FIGUREAXIS_REF_CONST_FIGUREAXIS_REF,
+      "axis1"_a, "axis2"_a)
 
     .def_static("set_window_properties", &DefaultFigure::set_window_properties,
       STATIC_VOID_DEFAULTFIGURE_SET_WINDOW_PROPERTIES_CONST_VECTOR_REF_CONST_VECTOR_REF)
@@ -357,6 +379,28 @@ void export_Figure2D(py::module& m)
       STATIC_VOID_DEFAULTFIGURE_DRAW_TRAJECTORY_CONST_ANALYTICTRAJ_VECTORTYPE_REF_CONST_COLORMAP_REF,
       "x"_a, "cmap"_a)
 
+    .def_static("draw_tube", [](const py::object& x, const StyleProperties& s)
+        {
+          if(!is_instance<SlicedTube<IntervalVector>>(x)) {
+            assert_release("draw_tube: invalid function type");
+          }
+
+          DefaultFigure::draw_tube(cast<SlicedTube<IntervalVector>>(x), s);
+        },
+      STATIC_VOID_DEFAULTFIGURE_DRAW_TUBE_CONST_SLICEDTUBE_INTERVALVECTOR_REF_CONST_STYLEPROPERTIES_REF,
+      "x"_a, "s"_a)
+
+    .def_static("draw_tube", [](const py::object& x, const ColorMap& cmap)
+        {
+          if(!is_instance<SlicedTube<IntervalVector>>(x)) {
+            assert_release("draw_tube: invalid function type");
+          }
+
+          DefaultFigure::draw_tube(cast<SlicedTube<IntervalVector>>(x), cmap);
+        },
+      STATIC_VOID_DEFAULTFIGURE_DRAW_TUBE_CONST_SLICEDTUBE_INTERVALVECTOR_REF_CONST_COLORMAP_REF,
+      "x"_a, "cmap"_a)
+
     // Robots
 
     .def_static("draw_tank", &DefaultFigure::draw_tank,

src/core/matrices/eigen/MatrixBase_addons/codac2_MatrixBase_addons_IntervalMatrixBase.h

@@ -116,8 +116,19 @@ inline auto diam() const
   degenerate_mat(diam);
 }
 
+inline bool contains(const Matrix<double,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _contains(x);
+}
+
 template<typename OtherDerived>
 inline bool contains(const MatrixBase<OtherDerived>& x) const
+{
+  return _contains(x);
+}
+
+template<typename T>
+inline bool _contains(const T& x) const
 {
   assert_release(x.size() == this->size());
 
@@ -132,8 +143,19 @@ inline bool contains(const MatrixBase<OtherDerived>& x) const
   return true;
 }
 
+inline bool interior_contains(const Matrix<double,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _interior_contains(x);
+}
+
 template<typename OtherDerived>
 inline bool interior_contains(const MatrixBase<OtherDerived>& x) const
+{
+  return _interior_contains(x);
+}
+
+template<typename T>
+inline bool _interior_contains(const T& x) const
 {
   assert_release(x.size() == this->size());
 
@@ -177,8 +199,19 @@ inline bool is_flat() const
   return false;
 }
 
+inline bool intersects(const Matrix<codac2::Interval,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _intersects(x);
+}
+
 template<typename OtherDerived>
 inline bool intersects(const MatrixBase<OtherDerived>& x) const
+{
+  return _intersects(x);
+}
+
+template<typename OtherDerived>
+inline bool _intersects(const MatrixBase<OtherDerived>& x) const
 {
   assert_release(this->size() == x.size());
 
@@ -193,8 +226,19 @@ inline bool intersects(const MatrixBase<OtherDerived>& x) const
   return true;
 }
 
+inline bool is_disjoint(const Matrix<codac2::Interval,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _is_disjoint(x);
+}
+
 template<typename OtherDerived>
 inline bool is_disjoint(const MatrixBase<OtherDerived>& x) const
+{
+  return _is_disjoint(x);
+}
+
+template<typename OtherDerived>
+inline bool _is_disjoint(const MatrixBase<OtherDerived>& x) const
 {
   assert_release(this->size() == x.size());
 
@@ -209,8 +253,19 @@ inline bool is_disjoint(const MatrixBase<OtherDerived>& x) const
   return false;
 }
 
+inline bool overlaps(const Matrix<codac2::Interval,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _overlaps(x);
+}
+
 template<typename OtherDerived>
 inline bool overlaps(const MatrixBase<OtherDerived>& x) const
+{
+  return _overlaps(x);
+}
+
+template<typename OtherDerived>
+inline bool _overlaps(const MatrixBase<OtherDerived>& x) const
 {
   assert_release(this->size() == x.size());
 
@@ -225,8 +280,19 @@ inline bool overlaps(const MatrixBase<OtherDerived>& x) const
   return true;
 }
 
+inline bool is_subset(const Matrix<codac2::Interval,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _is_subset(x);
+}
+
 template<typename OtherDerived>
 inline bool is_subset(const MatrixBase<OtherDerived>& x) const
+{
+  return _is_subset(x);
+}
+
+template<typename T>
+inline bool _is_subset(const T& x) const
 {
   assert_release(this->size() == x.size());
 
@@ -241,8 +307,19 @@ inline bool is_subset(const MatrixBase<OtherDerived>& x) const
   return true;
 }
 
+inline bool is_strict_subset(const Matrix<codac2::Interval,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _is_strict_subset(x);
+}
+
 template<typename OtherDerived>
 inline bool is_strict_subset(const MatrixBase<OtherDerived>& x) const
+{
+  return _is_strict_subset(x);
+}
+
+template<typename T>
+inline bool _is_strict_subset(const T& x) const
 {
   assert_release(this->size() == x.size());
 
@@ -260,8 +337,19 @@ inline bool is_strict_subset(const MatrixBase<OtherDerived>& x) const
   return false;
 }
 
+inline bool is_interior_subset(const Matrix<codac2::Interval,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _is_interior_subset(x);
+}
+
 template<typename OtherDerived>
 inline bool is_interior_subset(const MatrixBase<OtherDerived>& x) const
+{
+  return _is_interior_subset(x);
+}
+
+template<typename OtherDerived>
+inline bool _is_interior_subset(const MatrixBase<OtherDerived>& x) const
 {
   assert_release(this->size() == x.size());
 
@@ -276,8 +364,19 @@ inline bool is_interior_subset(const MatrixBase<OtherDerived>& x) const
   return true;
 }
 
+inline bool is_strict_interior_subset(const Matrix<codac2::Interval,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _is_strict_interior_subset(x);
+}
+
 template<typename OtherDerived>
 inline bool is_strict_interior_subset(const MatrixBase<OtherDerived>& x) const
+{
+  return _is_strict_interior_subset(x);
+}
+
+template<typename OtherDerived>
+inline bool _is_strict_interior_subset(const MatrixBase<OtherDerived>& x) const
 {
   assert_release(this->size() == x.size());
 
@@ -292,8 +391,19 @@ inline bool is_strict_interior_subset(const MatrixBase<OtherDerived>& x) const
   return true;
 }
 
+inline bool is_superset(const Matrix<codac2::Interval,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _is_superset(x);
+}
+
 template<typename OtherDerived>
 inline bool is_superset(const MatrixBase<OtherDerived>& x) const
+{
+  return _is_superset(x);
+}
+
+template<typename OtherDerived>
+inline bool _is_superset(const MatrixBase<OtherDerived>& x) const
 {
   assert_release(this->size() == x.size());
 
@@ -308,8 +418,19 @@ inline bool is_superset(const MatrixBase<OtherDerived>& x) const
   return true;
 }
 
+inline bool is_strict_superset(const Matrix<codac2::Interval,RowsAtCompileTime,ColsAtCompileTime>& x) const
+{
+  return _is_strict_superset(x);
+}
+
 template<typename OtherDerived>
 inline bool is_strict_superset(const MatrixBase<OtherDerived>& x) const
+{
+  return _is_strict_superset(x);
+}
+
+template<typename OtherDerived>
+inline bool _is_strict_superset(const MatrixBase<OtherDerived>& x) const
 {
   assert_release(this->size() == x.size());
 

src/graphics/figures/codac2_Figure2D.cpp

@@ -48,11 +48,12 @@ const std::vector<FigureAxis>& Figure2D::axes() const
   return _axes;
 }
 
-void Figure2D::set_axes(const FigureAxis& axis1, const FigureAxis& axis2)
+Figure2D& Figure2D::set_axes(const FigureAxis& axis1, const FigureAxis& axis2)
 {
   _axes = { axis1, axis2 };
   for(const auto& output_fig : _output_figures)
     output_fig->update_axes();
+  return *this;
 }
 
 const Index& Figure2D::i() const