fix(Bounding Box): add method to get the largest axe of the BBox

bindings/python/src/geometry/bounding_box.cpp

@@ -48,7 +48,9 @@
         .def( "max", &BoundingBox##dimension##D::max )                         \
         .def( "center", &BoundingBox##dimension##D::center )                   \
         .def( "diagonal", &BoundingBox##dimension##D::diagonal )               \
-        .def( "smallest_length", &BoundingBox##dimension##D::smallest_length )
+        .def( "smallest_length", &BoundingBox##dimension##D::smallest_length ) \
+        .def(                                                                  \
+            "largest_length", &BoundingBox##dimension##D::largest_dimension )
 
 namespace geode
 {

include/geode/basic/algorithm.hpp

@@ -113,6 +113,14 @@ namespace geode
         in.erase( last, in.end() );
     }
 
+    template < typename Container, typename Comparison >
+    void sort_unique( Container& in, Comparison comp )
+    {
+        absl::c_sort( in, comp );
+        const auto last = std::unique( in.begin(), in.end(), comp );
+        in.erase( last, in.end() );
+    }
+
     /*!
      * Concatenate tuples into a single tuple.
      */

include/geode/geometry/bounding_box.hpp

@@ -101,7 +101,9 @@ namespace geode
 
         Vector< dimension > diagonal() const;
 
-        double smallest_length() const;
+        std::tuple< local_index_t, double > smallest_length() const;
+
+        std::tuple< local_index_t, double > largest_length() const;
 
     private:
         Point< dimension > min_;

src/geode/geometry/bounding_box.cpp

@@ -98,6 +98,24 @@ namespace
         }
         return line.origin().value( 0 ) > box.max().value( 0 );
     }
+
+    template < geode::index_t dimension, typename Condition >
+    std::tuple< geode::local_index_t, double > test_axes(
+        const geode::Vector< dimension >& diagonal,
+        double length,
+        Condition predicate )
+    {
+        geode::local_index_t axis{ 0 };
+        for( const auto i : geode::LRange{ dimension } )
+        {
+            if( predicate( diagonal.value( i ), length ) )
+            {
+                length = diagonal.value( i );
+                axis = i;
+            }
+        }
+        return std::make_tuple( axis, length );
+    }
 } // namespace
 
 namespace geode
@@ -408,15 +426,25 @@ namespace geode
     }
 
     template < index_t dimension >
-    double BoundingBox< dimension >::smallest_length() const
+    std::tuple< local_index_t, double >
+        BoundingBox< dimension >::smallest_length() const
     {
         auto length = std::numeric_limits< double >::max();
-        const auto diag = diagonal();
-        for( const auto i : LRange{ dimension } )
-        {
-            length = std::min( length, diag.value( i ) );
-        }
-        return length;
+        return test_axes(
+            diagonal(), length, []( double diagonal_value, double min_value ) {
+                return diagonal_value < min_value;
+            } );
+    }
+
+    template < index_t dimension >
+    std::tuple< local_index_t, double >
+        BoundingBox< dimension >::largest_length() const
+    {
+        double length{ 0 };
+        return test_axes(
+            diagonal(), length, []( double diagonal_value, double max_value ) {
+                return diagonal_value > max_value;
+            } );
     }
 
     template < index_t dimension >