Change the childrenNodeIdFlatten to directly return all index that are not NO_CHILDREN

Signed-off-by: Nathan Dissoubray <nathan.dissoubray@rte-france.com>

Author: NathanDissoubray

diagram-util/src/main/java/com/powsybl/diagram/util/layout/forces/RepulsionForceDegreeBasedLinearBarnesHut.java

@@ -105,15 +105,12 @@ private void generatePointInteractionList(
         } else {
             Quadtree.QuadtreeNode thisNode = quadtree.getNodes()[nodeIndex];
             double childNodeWidth = nodeWidth / 2;
-            int numberOfChild = 0;
-            for (int index : thisNode.getChildrenNodeIdFlatten()) {
-                if (index != Quadtree.NO_CHILDREN) {
-                    ++numberOfChild;
-                    generatePointInteractionList(index, point, childNodeWidth, pointsToInteractWith);
-                }
+            int[] realChildrenId = thisNode.getRealChildrenNodeIndex();
+            for (int index : realChildrenId) {
+                generatePointInteractionList(index, point, childNodeWidth, pointsToInteractWith);
             }
             // if the list is empty, it means we are a leaf node, need to add self to the list and return
-            if (numberOfChild == 0) {
+            if (realChildrenId.length == 0) {
                 pointsToInteractWith.add(barycenter);
             }
         }

diagram-util/src/main/java/com/powsybl/diagram/util/layout/geometry/Quadtree.java

@@ -12,6 +12,7 @@
 import java.util.List;
 import java.util.function.Predicate;
 import java.util.function.ToDoubleFunction;
+import java.util.stream.Stream;
 
 /**
  * A quadtree is a structure that recursively divides a space in 4 until only a given number of points reside in each subdivided area. In this case,
@@ -23,18 +24,23 @@
 public class Quadtree {
     public static class QuadtreeNode {
         // package private
-        int[][] childrenNodeId = {
+        int[][] childrenNodeIndex = {
                 {NO_CHILDREN, NO_CHILDREN},
                 {NO_CHILDREN, NO_CHILDREN}
         };
 
-        public int[] getChildrenNodeIdFlatten() {
-            return new int[] {
-                childrenNodeId[0][0],
-                childrenNodeId[0][1],
-                childrenNodeId[1][0],
-                childrenNodeId[1][1]
-            };
+        /**
+         * @return all the index of children that actually exists (ie all quadrants that have at least a point in them)
+         */
+        public int[] getRealChildrenNodeIndex() {
+            return Stream.of(
+                childrenNodeIndex[0][0],
+                childrenNodeIndex[0][1],
+                childrenNodeIndex[1][0],
+                childrenNodeIndex[1][1]
+            ).filter(id -> id != NO_CHILDREN)
+            .mapToInt(Integer::intValue)
+            .toArray();
         }
     }
 
@@ -158,10 +164,10 @@ private int buildQuadtree(
         BoundingBox topLeftBb = new BoundingBox(boundingBox.left(), boundingBox.top(), boundingBoxCenter.getX(), boundingBoxCenter.getY());
         BoundingBox topRightBb = new BoundingBox(boundingBoxCenter.getX(), boundingBox.top(), boundingBox.right(), boundingBoxCenter.getY());
 
-        nodesList.get(newNodeIndex).childrenNodeId[0][0] = buildQuadtree(nodesList, barycentersList, points, bottomLeftBb, firstIndex, xLowerSplitIndex, massGetter, firstIndex, lastIndex, remainingDepth - 1);
-        nodesList.get(newNodeIndex).childrenNodeId[0][1] = buildQuadtree(nodesList, barycentersList, points, bottomRightBb, xLowerSplitIndex, ySplitIndex, massGetter, firstIndex, lastIndex, remainingDepth - 1);
-        nodesList.get(newNodeIndex).childrenNodeId[1][0] = buildQuadtree(nodesList, barycentersList, points, topLeftBb, ySplitIndex, xUpperSplitIndex, massGetter, firstIndex, lastIndex, remainingDepth - 1);
-        nodesList.get(newNodeIndex).childrenNodeId[1][1] = buildQuadtree(nodesList, barycentersList, points, topRightBb, xUpperSplitIndex, lastIndex, massGetter, firstIndex, lastIndex, remainingDepth - 1);
+        nodesList.get(newNodeIndex).childrenNodeIndex[0][0] = buildQuadtree(nodesList, barycentersList, points, bottomLeftBb, firstIndex, xLowerSplitIndex, massGetter, firstIndex, lastIndex, remainingDepth - 1);
+        nodesList.get(newNodeIndex).childrenNodeIndex[0][1] = buildQuadtree(nodesList, barycentersList, points, bottomRightBb, xLowerSplitIndex, ySplitIndex, massGetter, firstIndex, lastIndex, remainingDepth - 1);
+        nodesList.get(newNodeIndex).childrenNodeIndex[1][0] = buildQuadtree(nodesList, barycentersList, points, topLeftBb, ySplitIndex, xUpperSplitIndex, massGetter, firstIndex, lastIndex, remainingDepth - 1);
+        nodesList.get(newNodeIndex).childrenNodeIndex[1][1] = buildQuadtree(nodesList, barycentersList, points, topRightBb, xUpperSplitIndex, lastIndex, massGetter, firstIndex, lastIndex, remainingDepth - 1);
         setNodeBarycenter(barycentersList, nodesList.get(newNodeIndex), nodeBarycenter);
 
         return newNodeIndex;
@@ -234,19 +240,16 @@ private void setLeafBarycenter(Point[] points, Point nodeBarycenter, int startIn
      * @param nodeBarycenter the barycenter of the node, the one we are setting the mass and position of
      */
     private void setNodeBarycenter(List<Point> barycentersList, QuadtreeNode node, Point nodeBarycenter) {
-        int[] barycenterIndex = node.getChildrenNodeIdFlatten();
+        int[] barycenterIndex = node.getRealChildrenNodeIndex();
         Vector2D barycenterPosition = new Vector2D();
         double totalBarycenterMass = 0;
         for (int index : barycenterIndex) {
-            // index is only -1 in the case of nothing being there
-            if (index != NO_CHILDREN) {
-                // get the mass / position of each quadrant and do a weighted sum (quite literally)
-                Point quadrantBarycenter = barycentersList.get(index);
-                // do not use the massGetter, that's only for leaf nodes, quadrants contain leaf which already have their correct mass set
-                double quadrantMass = quadrantBarycenter.getMass();
-                barycenterPosition.addScaled(quadrantBarycenter.getPosition(), quadrantMass);
-                totalBarycenterMass += quadrantMass;
-            }
+            // get the mass / position of each quadrant and do a weighted sum (quite literally)
+            Point quadrantBarycenter = barycentersList.get(index);
+            // do not use the massGetter, that's only for leaf nodes, quadrants contain leaf which already have their correct mass set
+            double quadrantMass = quadrantBarycenter.getMass();
+            barycenterPosition.addScaled(quadrantBarycenter.getPosition(), quadrantMass);
+            totalBarycenterMass += quadrantMass;
         }
         barycenterPosition.divideBy(totalBarycenterMass);
         nodeBarycenter.setPosition(barycenterPosition);

diagram-util/src/test/java/com/powsybl/diagram/util/layout/geometry/QuadtreeTest.java

@@ -102,12 +102,10 @@ private void checkChildBarycenter(
     ) {
         double delta = 1e-3;
         Quadtree.QuadtreeNode thisNode = nodes[parentNodeIndex];
-        int[] subAreaIndexList = thisNode.getChildrenNodeIdFlatten();
+        int[] subAreaIndexList = thisNode.getRealChildrenNodeIndex();
         // check all child areas
         for (int subAreaIndex : subAreaIndexList) {
-            if (subAreaIndex != Quadtree.NO_CHILDREN) {
-                checkChildBarycenter(subAreaIndex, nodes, barycenters, expectedBarycenters);
-            }
+            checkChildBarycenter(subAreaIndex, nodes, barycenters, expectedBarycenters);
         }
         // now check this node
         Point barycenter = barycenters[parentNodeIndex];