b

Author: jcelerier

Nodes/NodesModel.hpp

@@ -142,52 +142,76 @@ class Nodes
         distances.push_back(dist);
       }
 
-      // Calculate weights based on distances with blur
+      // Find the two closest nodes for smooth transition
+      float minDist = std::numeric_limits<float>::max();
+      float secondMinDist = std::numeric_limits<float>::max();
+      int closestNode = -1;
+      int secondClosestNode = -1;
+      
+      for (int i = 0; i < m_nodes.size(); ++i)
+      {
+        if (distances[i] < minDist)
+        {
+          secondMinDist = minDist;
+          secondClosestNode = closestNode;
+          minDist = distances[i];
+          closestNode = i;
+        }
+        else if (distances[i] < secondMinDist)
+        {
+          secondMinDist = distances[i];
+          secondClosestNode = i;
+        }
+      }
+      
+      // Calculate weights with blur
       const float blurRadius = inputs.globalRadius;
 
       for (int i = 0; i < m_nodes.size(); ++i)
       {
         float weight = 0.0f;
 
-        // Check if this node could have non-zero weight
-        bool isClosest = true;
-        for (int j = 0; j < m_nodes.size(); ++j)
+        if (i == closestNode)
         {
-          if (i != j && distances[j] < distances[i] - blurRadius)
+          // Weight for closest node
+          if (secondClosestNode >= 0)
           {
-            isClosest = false;
-            break;
+            float distDiff = secondMinDist - minDist;
+            if (distDiff < 2.0f * blurRadius)
+            {
+              // We're in the transition zone
+              // When distDiff = 0, both weights should be 0.5
+              // When distDiff = 2*blurRadius, closest gets full weight
+              weight = 0.5f + (distDiff / (4.0f * blurRadius));
+              weight = std::min(1.0f, weight);
+            }
+            else
+            {
+              weight = 1.0f;
+            }
+          }
+          else
+          {
+            weight = 1.0f;
           }
         }
-        
-        if (isClosest)
+        else if (i == secondClosestNode && closestNode >= 0)
         {
-          // Calculate smooth weight based on distance differences
-          weight = 1.0f;
-          for (int j = 0; j < m_nodes.size(); ++j)
+          // Weight for second closest node
+          float distDiff = distances[i] - minDist;
+          if (distDiff < 2.0f * blurRadius)
           {
-            if (i != j)
-            {
-              float diff = distances[i] - distances[j];
-              if (diff > -blurRadius && diff < blurRadius)
-              {
-                // Smooth transition within blur radius
-                float t = (diff + blurRadius) / (2.0f * blurRadius);
-                weight *= t;
-              }
-              else if (diff >= blurRadius)
-              {
-                weight = 0.0f;
-                break;
-              }
-            }
+            // We're in the transition zone
+            weight = 0.5f - (distDiff / (4.0f * blurRadius));
+            weight = std::max(0.0f, weight);
           }
         }
+        // All other nodes get 0 weight
 
         weights.push_back(weight);
       }
 
-      // Normalize weights
+      // Normalize weights to ensure they sum to 1
       float totalWeight = 0.0f;
       for (auto w : weights)
       {

Nodes/NodesWidget.hpp

@@ -298,57 +298,65 @@ struct NodesWidget
           distances.push_back(dist);
         }
 
-        // Calculate weights for blended Voronoi
-        std::vector<float> weights(nodes.size(), 0.0f);
+        // Find the two closest nodes
+        float minDist = std::numeric_limits<float>::max();
+        float secondMinDist = std::numeric_limits<float>::max();
+        int closestNode = -1;
+        int secondClosestNode = -1;
 
         for (int i = 0; i < nodes.size(); ++i)
         {
-          float weight = 1.0f;
-          
-          for (int j = 0; j < nodes.size(); ++j)
+          if (distances[i] < minDist)
           {
-            if (i != j)
-            {
-              float diff = distances[i] - distances[j];
-              if (diff > -blurRadius && diff < blurRadius)
-              {
-                // Smooth transition within blur radius
-                float t = (diff + blurRadius) / (2.0f * blurRadius);
-                weight *= t;
-              }
-              else if (diff >= blurRadius)
-              {
-                weight = 0.0f;
-                break;
-              }
-            }
+            secondMinDist = minDist;
+            secondClosestNode = closestNode;
+            minDist = distances[i];
+            closestNode = i;
+          }
+          else if (distances[i] < secondMinDist)
+          {
+            secondMinDist = distances[i];
+            secondClosestNode = i;
           }
-          
-          weights[i] = weight;
-        }
-        
-        // Normalize weights
-        float totalWeight = 0.0f;
-        for (auto w : weights)
-        {
-          totalWeight += w;
         }
 
-        if (totalWeight > 0.0f)
+        if (closestNode >= 0)
         {
-          // Blend colors based on weights
-          float r = 0, g = 0, b = 0;
+          // Calculate colors based on weights
+          float r, g, b;
 
-          for (int i = 0; i < nodes.size(); ++i)
+          if (secondClosestNode >= 0)
           {
-            if (weights[i] > 0.0f)
+            float distDiff = secondMinDist - minDist;
+            if (distDiff < 2.0f * blurRadius)
+            {
+              // We're in the transition zone - blend colors
+              float weight1 = 0.5f + (distDiff / (4.0f * blurRadius));
+              weight1 = std::min(1.0f, weight1);
+              float weight2 = 1.0f - weight1;
+              
+              r = weight1 * ((closestNode * 67) % 128 + 40) + 
+                  weight2 * ((secondClosestNode * 67) % 128 + 40);
+              g = weight1 * ((closestNode * 149) % 128 + 40) + 
+                  weight2 * ((secondClosestNode * 149) % 128 + 40);
+              b = weight1 * ((closestNode * 211) % 128 + 40) + 
+                  weight2 * ((secondClosestNode * 211) % 128 + 40);
+            }
+            else
             {
-              float w = weights[i] / totalWeight;
-              r += w * ((i * 67) % 128 + 40);
-              g += w * ((i * 149) % 128 + 40);
-              b += w * ((i * 211) % 128 + 40);
+              // Pure closest node color
+              r = (closestNode * 67) % 128 + 40;
+              g = (closestNode * 149) % 128 + 40;
+              b = (closestNode * 211) % 128 + 40;
             }
           }
+          else
+          {
+            // Only one node - use its color
+            r = (closestNode * 67) % 128 + 40;
+            g = (closestNode * 149) % 128 + 40;
+            b = (closestNode * 211) % 128 + 40;
+          }
 
           ctx.set_fill_color({(uint8_t)r, (uint8_t)g, (uint8_t)b, 60});
           ctx.begin_path();