extension of the sampling template.

Author: francoisbonneau

include/geode/stochastic/geometry/distributions.hpp

@@ -23,9 +23,10 @@
 
 #pragma once
 
+#include <geode/geometry/bounding_box.hpp>
 #include <geode/stochastic/geometry/common.hpp>
+
 #include <optional>
-#include <variant>
 
 namespace geode
 {
@@ -42,6 +43,7 @@ namespace geode
     struct Uniform
     {
         Uniform() = default;
+        // toremove
         Uniform( Type min_val, Type max_val )
             : min{ IntervalLimit< Type >{ min_val, true } },
               max{ IntervalLimit< Type >{ max_val, true } }
@@ -54,6 +56,7 @@ namespace geode
     struct Gaussian
     {
         Gaussian() = default;
+        // to remove
         Gaussian( double mean_val, double standard_deviation_val )
             : mean{ mean_val }, standard_deviation{ standard_deviation_val }
         {
@@ -75,6 +78,10 @@ namespace geode
         std::optional< double > min;
         std::optional< double > max;
     };
-    using Distribution = std::variant< Uniform< double >, Gaussian >;
+
+    struct UniformBox3D
+    {
+        geode::BoundingBox3D box;
+    };
 
 } // namespace geode

include/geode/stochastic/geometry/random_engine.hpp

@@ -28,7 +28,7 @@
 #include <geode/stochastic/geometry/distributions.hpp>
 
 #include <geode/basic/pimpl.hpp>
-
+#include <geode/geometry/point.hpp>
 namespace geode
 {
     class opengeode_stochastic_geometry_api RandomEngine
@@ -42,7 +42,7 @@ namespace geode
         void set_seed( uint64_t number );
         void set_seed( std::string_view word );
 
-        double sample( const Distribution& dist );
+        //        double sample( const Distribution& dist );
 
         template < typename Type >
         Type sample_uniform( const Uniform< Type >& law );
@@ -51,6 +51,12 @@ namespace geode
 
         bool sample_bernoulli( double probability_of_success );
 
+        geode::Point3D sample_box_uniform( const UniformBox3D& box_law )
+        {
+            geode_unused( box_law );
+            return geode::Point3D{};
+        }
+
     private:
         IMPLEMENTATION_MEMBER( impl_ );
     };

include/geode/stochastic/geometry/random_sampler.hpp

@@ -0,0 +1,57 @@
+#include <geode/stochastic/geometry/common.hpp>
+
+#include <geode/stochastic/geometry/distributions.hpp>
+#include <geode/stochastic/geometry/random_engine.hpp>
+
+#include <geode/geometry/point.hpp>
+#include <variant>
+
+namespace geode
+{
+    using DoubleDistribution = std::variant< Uniform< double >, Gaussian >;
+    using Domain = std::variant< UniformBox3D >;
+
+    // Interface générique
+    template < typename T >
+    struct Sampler;
+
+    template <>
+    struct Sampler< double >
+    {
+        static double sample(
+            RandomEngine& engine, const DoubleDistribution& dist )
+        {
+            return std::visit(
+                [&engine]( auto&& d ) -> double {
+                    using D = std::decay_t< decltype( d ) >;
+                    if constexpr( std::is_same_v< D, Uniform< double > > )
+                        return engine.sample_uniform< double >( d );
+                    else if constexpr( std::is_same_v< D, Gaussian > )
+                        return engine.sample_gaussian( d );
+                    else
+                        throw std::runtime_error(
+                            "Unsupported distribution for double" );
+                },
+                dist );
+        }
+    };
+
+    // Spécialisation pour `Point2D`
+    template <>
+    struct Sampler< geode::Point3D >
+    {
+        static geode::Point3D sample( RandomEngine& engine, const Domain& dist )
+        {
+            return std::visit(
+                [&engine]( auto&& d ) -> geode::Point3D {
+                    using D = std::decay_t< decltype( d ) >;
+                    if constexpr( std::is_same_v< D, UniformBox3D > )
+                        return engine.sample_box_uniform( d );
+                    else
+                        throw std::runtime_error(
+                            "Unsupported distribution for Point2D" );
+                },
+                dist );
+        }
+    };
+} // namespace geode

src/geode/stochastic/geometry/CMakeLists.txt

@@ -24,10 +24,12 @@ add_geode_library(
     SOURCES
         "common.cpp"
         "random_engine.cpp"
+        "random_sampler.cpp"
         "hello_world.cpp"
     PUBLIC_HEADERS
         "common.hpp"
         "random_engine.hpp"
+        "random_sampler.hpp"
         "distributions.hpp"
         "hello_world.hpp"
     PRIVATE_DEPENDENCIES

src/geode/stochastic/geometry/random_engine.cpp

@@ -69,14 +69,14 @@ namespace geode
             rand_gen_ = absl::BitGen{ create_seed_seq( word ) };
         }
 
-        double sample( const Distribution& dist )
-        {
-            return std::visit(
-                [this]( auto&& d ) {
-                    return sample_distribution( d );
-                },
-                dist );
-        }
+        //        double sample( const Distribution& dist )
+        //        {
+        //            return std::visit(
+        //                [this]( auto&& d ) {
+        //                    return sample_distribution( d );
+        //                },
+        //                dist );
+        //        }
         double sample_distribution( const Uniform< double >& law )
         {
             return absl::Uniform( absl::IntervalClosedOpen, rand_gen_,
@@ -175,10 +175,10 @@ namespace geode
         impl_->set_seed( word );
     }
 
-    double RandomEngine::sample( const Distribution& dist )
-    {
-        return impl_->sample( dist );
-    }
+    //    double RandomEngine::sample( const Distribution& dist )
+    //    {
+    //        return impl_->sample( dist );
+    //    }
 
     template < typename Type >
     Type RandomEngine::sample_uniform( const Uniform< Type >& law )