[Bf-blender-cvs] [b54f406638c] temp-geometry-nodes-distribute-points-cleanup: Use the correct function for the min distance

[Dalai Felinto]

Commit: b54f406638cea874f8423b7b943ef8cd4894afd0
Author: Dalai Felinto
Date:   Fri Dec 11 00:46:06 2020 +0100
Branches: temp-geometry-nodes-distribute-points-cleanup
https://developer.blender.org/rBb54f406638cea874f8423b7b943ef8cd4894afd0

Use the correct function for the min distance

===================================================================

M	source/blender/nodes/geometry/nodes/node_geo_point_distribute_poisson_disk.cc

===================================================================

diff --git a/source/blender/nodes/geometry/nodes/node_geo_point_distribute_poisson_disk.cc b/source/blender/nodes/geometry/nodes/node_geo_point_distribute_poisson_disk.cc
index f13cd8c4d14..36ef1bf6518 100644
--- a/source/blender/nodes/geometry/nodes/node_geo_point_distribute_poisson_disk.cc
+++ b/source/blender/nodes/geometry/nodes/node_geo_point_distribute_poisson_disk.cc
@@ -91,14 +91,11 @@ static void points_distance_weight_calculate(std::vector<float> *weights,
                                              const size_t point_id,
                                              Vector<float3> const *input_points,
                                              const void *kd_tree,
+                                             const size_t minimum_distance,
                                              const size_t maximum_distance,
-                                             const float3 boundbox,
                                              Heap *heap,
                                              std::vector<HeapNode *> *nodes)
 {
-  const float minimum_distance = 2.0f *
-                                 maximum_poisson_disk_radius(input_points->size(), boundbox);
-
   KDTreeNearest_3d *nearest_point = nullptr;
   int neighbors = BLI_kdtree_3d_range_search(
       (KDTree_3d *)kd_tree, input_points->data()[point_id], &nearest_point, maximum_distance);
@@ -138,11 +135,26 @@ static void points_distance_weight_calculate(std::vector<float> *weights,
   }
 }
 
+/**
+ * Returns the minimum radius fraction used by the default weight function.
+ */
+static float weight_limit_fraction_get(const size_t input_size, const size_t output_size)
+{
+  const float beta = 0.65f;
+  const float gamma = 1.5f;
+  float ratio = float(output_size) / float(input_size);
+  return (1.0f - std::pow(ratio, gamma)) * beta;
+}
+
 static void weighted_sample_elimination(Vector<float3> const *input_points,
                                         Vector<float3> *output_points,
                                         const float maximum_distance,
                                         const float3 boundbox)
 {
+  const size_t minimum_distance = maximum_distance *
+                                  weight_limit_fraction_get(input_points->size(),
+                                                            output_points->size());
+
   void *kd_tree = BLI_kdtree_3d_new(input_points->size());
   {
     std::vector<float3> tiled_points(input_points->data(),
@@ -171,12 +183,25 @@ static void weighted_sample_elimination(Vector<float3> const *input_points,
     }
     BLI_kdtree_3d_balance((KDTree_3d *)kd_tree);
   }
+#else
+  UNUSED_VARS(boundbox);
+  for (size_t i = 0; i < input_points->size(); i++) {
+    BLI_kdtree_3d_insert((KDTree_3d *)kd_tree, i, input_points->data()[i]);
+  }
+  BLI_kdtree_3d_balance((KDTree_3d *)kd_tree);
+#endif
 
   /* Assign weights to each sample. */
   std::vector<float> weights(input_points->size(), 0.0f);
   for (size_t point_id = 0; point_id < weights.size(); point_id++) {
-    points_distance_weight_calculate(
-        &weights, point_id, input_points, kd_tree, maximum_distance, boundbox, nullptr, nullptr);
+    points_distance_weight_calculate(&weights,
+                                     point_id,
+                                     input_points,
+                                     kd_tree,
+                                     minimum_distance,
+                                     maximum_distance,
+                                     nullptr,
+                                     nullptr);
   }
 
   /* Remove the points based on their weight. */
@@ -193,8 +218,14 @@ static void weighted_sample_elimination(Vector<float3> const *input_points,
     size_t point_id = POINTER_AS_INT(BLI_heap_pop_min(heap));
     nodes[point_id] = nullptr;
 
-    points_distance_weight_calculate(
-        &weights, point_id, input_points, kd_tree, maximum_distance, boundbox, heap, &nodes);
+    points_distance_weight_calculate(&weights,
+                                     point_id,
+                                     input_points,
+                                     kd_tree,
+                                     minimum_distance,
+                                     maximum_distance,
+                                     heap,
+                                     &nodes);
 
     sample_size--;
   }