#504

Committed 03 Oct 2025 01:24PM UTC coverage: 91.042% (+0.2%) from 90.873%

Build # #504

Build Type

push

Committed by

Commit Message

Add Spliterator on NodesQuadTree (#243)

* Change default config for block size and default dict size

* Replace LinkedHashSet with arrays and implement spliterator

* Add multi-node edge iterator

* Refactoring to remove duplicate getNodes methods in quadtree

* Add edge iteration support in quadtree

* Add global quad tree edge iterator option

* Refactor to configure edge inout iterator locking and test all edges in quadtree spliterator

* Formatting

* Git ignore

* Non approximate support for global iterator and bugfix

* Add additional tests

* Quadtree versioning

* Tweak boundaries

* Documentation

* Update src/main/java/org/gephi/graph/impl/NodesQuadTree.java

Remove distinct from spliterator as edges can be returned twice

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Fix locking function name clash in view decorator

* Fix toArray

* Reduce memory overhead of quad node array init

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Run Details

535 of 615 new or added lines in 10 files covered. (86.99%)

1 existing line in 1 file now uncovered.

11576 of 12715 relevant lines covered (91.04%)

0.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.67

/src/main/java/org/gephi/graph/impl/SpatialIndexImpl.java

package org.gephi.graph.impl;

import java.util.function.Predicate;
import org.gephi.graph.api.Edge;
import org.gephi.graph.api.EdgeIterable;
import org.gephi.graph.api.Node;
import org.gephi.graph.api.NodeIterable;
import org.gephi.graph.api.Rect2D;
import org.gephi.graph.api.SpatialIndex;

/**
 * Graph spatial indexing interface.
 *
 * @author Eduardo Ramos
 */
public class SpatialIndexImpl implements SpatialIndex {

    protected final NodesQuadTree nodesTree;

    public SpatialIndexImpl(GraphStore store) {
        float boundaries = GraphStoreConfiguration.SPATIAL_INDEX_DIMENSION_BOUNDARY;
        this.nodesTree = new NodesQuadTree(store,
                new Rect2D(-boundaries / 2, -boundaries / 2, boundaries / 2, boundaries / 2));
    }

    @Override
    public NodeIterable getNodesInArea(Rect2D rect) {
        return nodesTree.getNodes(rect, false);
    }

    @Override
    public NodeIterable getApproximateNodesInArea(Rect2D rect) {
        return nodesTree.getNodes(rect, true);
    }

    @Override
    public EdgeIterable getEdgesInArea(Rect2D rect) {
        return nodesTree.getEdges(rect, false);
    }

    @Override
    public EdgeIterable getApproximateEdgesInArea(Rect2D rect) {
        return nodesTree.getEdges(rect, true);
    }

    @Override
    public void spatialIndexReadLock() {
        nodesTree.readLock();
    }

    @Override
    public void spatialIndexReadUnlock() {
        nodesTree.readUnlock();
    }

    public NodeIterable getNodesInArea(Rect2D rect, Predicate<? super Node> predicate) {
        return nodesTree.getNodes(rect, false, predicate);
    }

    public NodeIterable getApproximateNodesInArea(Rect2D rect, Predicate<? super Node> predicate) {
        return nodesTree.getNodes(rect, true, predicate);
    }

    public EdgeIterable getEdgesInArea(Rect2D rect, Predicate<? super Edge> predicate) {
        return nodesTree.getEdges(rect, false, predicate);
    }

    public EdgeIterable getApproximateEdgesInArea(Rect2D rect, Predicate<? super Edge> predicate) {
        return nodesTree.getEdges(rect, true, predicate);
    }

    protected void clearNodes() {
        nodesTree.clear();
    }

    protected void incrementVersion() {
        nodesTree.incrementVersion();
    }

    protected void addNode(final NodeImpl node) {
        nodesTree.addNode(node);
    }

    protected void removeNode(final NodeImpl node) {
        nodesTree.removeNode(node);
    }

    protected void moveNode(final NodeImpl node) {
        final float x = node.x();
        final float y = node.y();
        final float size = node.size();

        final float minX = x - size;
        final float minY = y - size;
        final float maxX = x + size;
        final float maxY = y + size;

        nodesTree.updateNode(node, minX, minY, maxX, maxY);
    }

    @Override
    public Rect2D getBoundaries() {
        return nodesTree.getBoundaries();
    }

    public Rect2D getBoundaries(Predicate<? super Node> predicate) {
        return nodesTree.getBoundaries(predicate);
    }

    public int getObjectCount() {
        return nodesTree.getObjectCount();
    }
}

1	package org.gephi.graph.impl;
2
3	import java.util.function.Predicate;
4	import org.gephi.graph.api.Edge;
5	import org.gephi.graph.api.EdgeIterable;
6	import org.gephi.graph.api.Node;
7	import org.gephi.graph.api.NodeIterable;
8	import org.gephi.graph.api.Rect2D;
9	import org.gephi.graph.api.SpatialIndex;
10
11	/**
12	* Graph spatial indexing interface.
13	*
14	* @author Eduardo Ramos
15	*/
16	public class SpatialIndexImpl implements SpatialIndex {
17
18	protected final NodesQuadTree nodesTree;
19
20	public SpatialIndexImpl(GraphStore store) {	1✔
21	float boundaries = GraphStoreConfiguration.SPATIAL_INDEX_DIMENSION_BOUNDARY;	1✔
22	this.nodesTree = new NodesQuadTree(store,	1✔
23	new Rect2D(-boundaries / 2, -boundaries / 2, boundaries / 2, boundaries / 2));
24	}	1✔
25
26	@Override
27	public NodeIterable getNodesInArea(Rect2D rect) {
28	return nodesTree.getNodes(rect, false);	1✔
29	}
30
31	@Override
32	public NodeIterable getApproximateNodesInArea(Rect2D rect) {
NEW 33	return nodesTree.getNodes(rect, true);	×
34	}
35
36	@Override
37	public EdgeIterable getEdgesInArea(Rect2D rect) {
38	return nodesTree.getEdges(rect, false);	1✔
39	}
40
41	@Override
42	public EdgeIterable getApproximateEdgesInArea(Rect2D rect) {
NEW 43	return nodesTree.getEdges(rect, true);	×
44	}
45
46	@Override
47	public void spatialIndexReadLock() {
NEW 48	nodesTree.readLock();	×
NEW 49	}	×
50
51	@Override
52	public void spatialIndexReadUnlock() {
NEW 53	nodesTree.readUnlock();	×
NEW 54	}	×
55
56	public NodeIterable getNodesInArea(Rect2D rect, Predicate<? super Node> predicate) {
NEW 57	return nodesTree.getNodes(rect, false, predicate);	×
58	}
59
60	public NodeIterable getApproximateNodesInArea(Rect2D rect, Predicate<? super Node> predicate) {
NEW 61	return nodesTree.getNodes(rect, true, predicate);	×
62	}
63
64	public EdgeIterable getEdgesInArea(Rect2D rect, Predicate<? super Edge> predicate) {
NEW 65	return nodesTree.getEdges(rect, false, predicate);	×
66	}
67
68	public EdgeIterable getApproximateEdgesInArea(Rect2D rect, Predicate<? super Edge> predicate) {
NEW 69	return nodesTree.getEdges(rect, true, predicate);	×
70	}
71
72	protected void clearNodes() {
73	nodesTree.clear();	1✔
74	}	1✔
75
76	protected void incrementVersion() {
77	nodesTree.incrementVersion();	1✔
78	}	1✔
79
80	protected void addNode(final NodeImpl node) {
81	nodesTree.addNode(node);	1✔
82	}	1✔
83
84	protected void removeNode(final NodeImpl node) {
85	nodesTree.removeNode(node);	×
86	}	×
87
88	protected void moveNode(final NodeImpl node) {
89	final float x = node.x();	1✔
90	final float y = node.y();	1✔
91	final float size = node.size();	1✔
92
93	final float minX = x - size;	1✔
94	final float minY = y - size;	1✔
95	final float maxX = x + size;	1✔
96	final float maxY = y + size;	1✔
97
98	nodesTree.updateNode(node, minX, minY, maxX, maxY);	1✔
99	}	1✔
100
101	@Override
102	public Rect2D getBoundaries() {
103	return nodesTree.getBoundaries();	1✔
104	}
105
106	public Rect2D getBoundaries(Predicate<? super Node> predicate) {
107	return nodesTree.getBoundaries(predicate);	1✔
108	}
109
110	public int getObjectCount() {
111	return nodesTree.getObjectCount();	1✔
112	}
113	}

gephi / graphstore / #504

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous