don't return different types; wrappers dont return nb types

Author: alecjacobson

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.16.0)
 project(pyigl)
 
-# use C++20
+# use C++20 (we need at least C++17 for return value optimization)
 set(CMAKE_CXX_STANDARD 20)
 
 if (CMAKE_VERSION VERSION_LESS 3.18)
@@ -32,7 +32,7 @@ FetchContent_MakeAvailable(nanobind)
 FetchContent_Declare(
   libigl
   GIT_REPOSITORY https://github.com/libigl/libigl.git
-  GIT_TAG 0e504e1b331e6696b485258a9aac779f0f20c5b0
+  GIT_TAG 1410ad43dff78bfaf8d8103de422fa64adfa35d5
 )
 FetchContent_MakeAvailable(libigl)
 

missing.sh

@@ -3,6 +3,9 @@
 already=$(ls src/*.cpp | sed -e "s/src\/\(.*\).cpp$/\1/g")
 skip="igl_inline
 EPS
+sparse
+setdiff
+rotation_matrix_from_directions
 verbose
 colon
 min_quad_with_fixed.impl

src/AABB.cpp

@@ -20,7 +20,7 @@ namespace pyigl
     tree.init(V,Ele);
   }
   template <typename AABB>
-  nb::object find(
+  auto find(
     AABB &tree,
     const nb::DRef<const Eigen::MatrixXN> &V,
     const nb::DRef<const Eigen::MatrixXI> &Ele,
@@ -33,80 +33,61 @@ namespace pyigl
     }
     std::vector<int> vec_int = tree.find(V,Ele,q,first);
     std::vector<Integer> vec(vec_int.begin(),vec_int.end());
-    if(first)
-    {
-      return vec.size() ? nb::cast(vec[0]) : nb::none();
-    }else
-    {
-      return nb::cast(std::move(vec));
-    }
+    return vec;
   }
 
   template <typename AABB>
-  nb::object squared_distance(
+  auto squared_distance(
     AABB &tree,
     const nb::DRef<const Eigen::MatrixXN> &V,
     const nb::DRef<const Eigen::MatrixXI> &Ele,
-    const nb::DRef<const Eigen::MatrixXN> &P,
-    const bool return_I,
-    const bool return_C)
+    const nb::DRef<const Eigen::MatrixXN> &P)
   {
     Eigen::VectorXN sqrD;
     Eigen::VectorXI I;
     Eigen::MatrixXN C;
     tree.squared_distance(V,Ele,P,sqrD,I,C);
-    if(return_I && return_C)
-    {
-      return nb::make_tuple(sqrD,I,C);
-    }else if(return_I)
-    {
-      return nb::make_tuple(sqrD,I);
-    }else if(return_C)
-    {
-      return nb::make_tuple(sqrD,C);
-    }
-    return nb::cast(std::move(sqrD));
+    return std::make_tuple(sqrD,I,C);
   }
 
   template <typename AABB>
-  nb::object intersect_ray(
+  auto intersect_ray_first(
     AABB &tree,
     const nb::DRef<const Eigen::MatrixXN> &V,
     const nb::DRef<const Eigen::MatrixXI> &Ele,
     const nb::DRef<const Eigen::MatrixXN> &orig,
     const nb::DRef<const Eigen::MatrixXN> &dir,
-    const Numeric min_t,
-    const bool first)
+    const Numeric min_t)
   {
-    if(first)
-    {
+    Eigen::VectorXI I;
+    Eigen::VectorXN T;
+    Eigen::MatrixXN UV;
+    tree.intersect_ray(V,Ele,orig,dir,min_t,I,T,UV);
+    return std::make_tuple(I,T,UV);
+  }
 
-      Eigen::VectorXI I;
-      Eigen::VectorXN T;
-      Eigen::MatrixXN UV;
-      tree.intersect_ray(V,Ele,orig,dir,min_t,I,T,UV);
-      return nb::make_tuple(I,T,UV);
-    }else
+  template <typename AABB>
+  auto intersect_ray(
+    AABB &tree,
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &Ele,
+    const nb::DRef<const Eigen::MatrixXN> &orig,
+    const nb::DRef<const Eigen::MatrixXN> &dir)
+  {
+    std::vector<std::vector<igl::Hit<Numeric>>> hits;
+    tree.intersect_ray(V,Ele,orig,dir,hits);
+    std::vector<std::vector<std::tuple<Integer,Numeric,Numeric,Numeric>>> out;
+    for(const auto &hit : hits)
     {
-      if(std::isfinite(min_t))
-      {
-        throw std::runtime_error("intersect_ray: min_t only supported for first=true");
-      }
-      std::vector<std::vector<igl::Hit<Numeric>>> hits;
-      tree.intersect_ray(V,Ele,orig,dir,hits);
-      std::vector<std::vector<std::tuple<Integer,Numeric,Numeric,Numeric>>> out;
-      for(const auto &hit : hits)
+      std::vector<std::tuple<Integer,Numeric,Numeric,Numeric>> hit_out;
+      for(const auto &h : hit)
       {
-        std::vector<std::tuple<Integer,Numeric,Numeric,Numeric>> hit_out;
-        for(const auto &h : hit)
-        {
-          hit_out.push_back(std::make_tuple(h.id,h.t,h.u,h.v));
-        }
-        out.push_back(hit_out);
+        hit_out.push_back(std::make_tuple(h.id,h.t,h.u,h.v));
       }
-
-      return nb::cast(std::move(out));
+      out.push_back(hit_out);
     }
+
+    return out;
   }
 }
 
@@ -118,8 +99,9 @@ void bind_AABB(nb::module_ &m)
     .def(nb::init<>())
     .def("init", &pyigl::init<AABBN3>, "V"_a, "Ele"_a)
     .def("find", &pyigl::find<AABBN3>, "V"_a, "Ele"_a, "q"_a, "first"_a=false)
-    .def("squared_distance", &pyigl::squared_distance<AABBN3>, "V"_a, "Ele"_a, "P"_a, "return_I"_a=false,"return_C"_a=false)
-    .def("intersect_ray",&pyigl::intersect_ray<AABBN3>, "V"_a, "Ele"_a, "orig"_a, "dir"_a, "min_t"_a=std::numeric_limits<Numeric>::infinity(), "first"_a=false)
+    .def("squared_distance", &pyigl::squared_distance<AABBN3>, "V"_a, "Ele"_a, "P"_a)
+    .def("intersect_ray_first",&pyigl::intersect_ray_first<AABBN3>, "V"_a, "Ele"_a, "orig"_a, "dir"_a, "min_t"_a=std::numeric_limits<Numeric>::infinity())
+    .def("intersect_ray",&pyigl::intersect_ray<AABBN3>, "V"_a, "Ele"_a, "orig"_a, "dir"_a)
     ;
 }
 

src/average_from_edges_onto_vertices.cpp

@@ -9,15 +9,15 @@ using namespace nb::literals;
 
 namespace pyigl
 {
-  nb::object average_from_edges_onto_vertices(
+  auto average_from_edges_onto_vertices(
     const nb::DRef<const Eigen::MatrixXI> &F,
     const nb::DRef<const Eigen::MatrixXI> &E,
     const nb::DRef<const Eigen::MatrixXI> &oE,
     const nb::DRef<const Eigen::VectorXN> &uE)
   {
     Eigen::VectorXN uV;
     igl::average_from_edges_onto_vertices(F, E, oE, uE, uV);
-    return nb::cast(std::move(uV));
+    return uV;
   }
 }
 

src/barycenter.cpp

@@ -10,13 +10,13 @@ using namespace nb::literals;
 namespace pyigl
 {
   // Wrapper for barycenter function
-  nb::object barycenter(
+  auto barycenter(
     const nb::DRef<const Eigen::MatrixXN> &V,
     const nb::DRef<const Eigen::MatrixXI> &F)
   {
     Eigen::MatrixXN BC;
     igl::barycenter(V, F, BC);
-    return nb::cast(std::move(BC));
+    return BC;
   }
 }
 

src/barycentric_coordinates.cpp

@@ -11,17 +11,17 @@ using namespace nb::literals;
 namespace pyigl
 {
   // Wrapper for barycentric_coordinates function
-  nb::object barycentric_coordinates_PABC(
+  auto barycentric_coordinates_PABC(
     const nb::DRef<const Eigen::MatrixXN> &P,
     const nb::DRef<const Eigen::MatrixXN> &A,
     const nb::DRef<const Eigen::MatrixXN> &B,
     const nb::DRef<const Eigen::MatrixXN> &C)
   {
     Eigen::MatrixXN L;
     igl::barycentric_coordinates(P, A, B, C, L);
-    return nb::cast(std::move(L));
+    return L;
   }
-  nb::object barycentric_coordinates_PABCD(
+  auto barycentric_coordinates_PABCD(
     const nb::DRef<const Eigen::MatrixXN> &P,
     const nb::DRef<const Eigen::MatrixXN> &A,
     const nb::DRef<const Eigen::MatrixXN> &B,
@@ -30,7 +30,7 @@ namespace pyigl
   {
     Eigen::MatrixXN L;
     igl::barycentric_coordinates(P, A, B, C, D, L);
-    return nb::cast(std::move(L));
+    return L;
   }
 }
 

src/bbw.cpp

@@ -11,7 +11,7 @@ using namespace nb::literals;
 namespace pyigl
 {
   // Wrapper for bbw function
-  nb::object bbw(
+  auto bbw(
     const nb::DRef<const Eigen::MatrixXN> &V,
     const nb::DRef<const Eigen::MatrixXI> &Ele,
     const nb::DRef<const Eigen::VectorXI> &b,
@@ -38,7 +38,7 @@ namespace pyigl
     {
       throw std::runtime_error("bbw: failed to compute weights");
     }
-    return nb::cast(std::move(W));
+    return W;
   }
 }
 

src/boundary_facets.cpp

@@ -4,32 +4,20 @@
 #include <nanobind/ndarray.h>
 #include <nanobind/eigen/dense.h>
 #include <nanobind/eigen/sparse.h>
+#include <nanobind/stl/tuple.h>
 
 namespace nb = nanobind;
 using namespace nb::literals;
 
 namespace pyigl
 {
-  nb::object boundary_facets(
-    const nb::DRef<const Eigen::MatrixXI> &T,
-    bool return_J,
-    bool return_K)
+  auto boundary_facets( const nb::DRef<const Eigen::MatrixXI> &T)
   {
     Eigen::MatrixXI F;
     Eigen::VectorXI J;
     Eigen::VectorXI K;
     igl::boundary_facets(T,F,J,K);
-    if(return_J && return_K)
-    {
-      return nb::make_tuple(F,J,K);
-    }else if(return_J)
-    {
-      return nb::make_tuple(F,J);
-    }else if(return_K)
-    {
-      return nb::make_tuple(F,K);
-    }
-    return nb::cast(std::move(F));
+    return std::make_tuple(F,J,K);
   }
 }
 
@@ -40,8 +28,6 @@ void bind_boundary_facets(nb::module_ &m)
     "boundary_facets",
     &pyigl::boundary_facets, 
     "T"_a,
-    "return_J"_a=false,
-    "return_K"_a=false,
 R"(Determine boundary faces (edges) of tetrahedra (triangles) stored in T
 (analogous to qptoolbox's `outline` and `boundary_faces`).
 

src/circulation.cpp

@@ -0,0 +1,50 @@
+#include "default_types.h"
+#include <igl/circulation.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto circulation(
+    const int e,
+    const bool ccw,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const nb::DRef<const Eigen::VectorXI> &EMAP,
+    const nb::DRef<const Eigen::MatrixXI> &EF,
+    const nb::DRef<const Eigen::MatrixXI> &EI)
+  {
+    std::vector<int> Nv, Nf;
+    igl::circulation(e, ccw, F, EMAP, EF, EI, Nv, Nf);
+    return std::make_tuple(Nv, Nf);
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_circulation(nb::module_ &m)
+{
+  m.def(
+    "circulation",
+    &pyigl::circulation,
+    "e"_a,
+    "ccw"_a,
+    "F"_a,
+    "EMAP"_a,
+    "EF"_a,
+    "EI"_a,
+    R"(Return lists of "next" vertex indices (Nv) and face indices (Nf) for circulation.
+
+    @param[in] e  index of edge to circulate
+    @param[in] ccw  circulate in ccw direction
+    @param[in] F  #F by 3 list of mesh faces
+    @param[in] EMAP #F*3 list of indices mapping each directed edge to a unique edge in E
+    @param[in] EF  #E by 2 list of edge flaps
+    @param[in] EI  #E by 2 list of edge flap corners
+    @return Tuple containing Nv (next vertex indices) and Nf (face indices))"
+  );
+}

src/connected_components.cpp

@@ -3,42 +3,20 @@
 #include <nanobind/nanobind.h>
 #include <nanobind/eigen/sparse.h>
 #include <nanobind/ndarray.h>
+#include <nanobind/stl/tuple.h>
 
 namespace nb = nanobind;
 using namespace nb::literals;
 
 namespace pyigl
 {
   // Wrapper for connected_components
-  nb::object connected_components(
-    const Eigen::SparseMatrix<Integer> &A,
-    const bool return_C = false,
-    const bool return_K = false)
+  auto connected_components( const Eigen::SparseMatrix<Integer> &A)
   {
-    int num_components;
     Eigen::VectorXI C;
     Eigen::VectorXI K;
-
-    if (return_C && return_K)
-    {
-      num_components = igl::connected_components(A, C, K);
-      return nb::make_tuple(num_components, C, K);
-    }
-    else if (return_C)
-    {
-      num_components = igl::connected_components(A, C, K);
-      return nb::make_tuple(num_components, C);
-    }
-    else if (return_K)
-    {
-      num_components = igl::connected_components(A, C, K);
-      return nb::make_tuple(num_components, K);
-    }
-    else
-    {
-      num_components = igl::connected_components(A, C, K);
-      return nb::cast(num_components);
-    }
+    Integer num_components = (Integer)igl::connected_components(A, C, K);
+    return std::make_tuple(num_components, C, K);
   }
 }
 
@@ -49,8 +27,6 @@ void bind_connected_components(nb::module_ &m)
     "connected_components",
     &pyigl::connected_components,
     "A"_a,
-    "return_C"_a = false,
-    "return_K"_a = false,
 R"(Determine the connected components of a graph described by the input adjacency matrix.
 
 @param[in] A  #A by #A adjacency matrix (treated as describing a directed graph)