public Set<NodeId> toNodeIds(QuadTreeClusteringStrategy strategy, Iterable<Node> nodes) { Set<NodeId> ids = new HashSet<>(); for (Node n : nodes) { NodeId id = strategy.computeId(n); Assert.assertTrue("got duplicated node", ids.add(id)); } return ids; }
public Set<NodeId> toNodeIds(QuadTreeClusteringStrategy strategy, Iterable<Node> nodes) { Set<NodeId> ids = new HashSet<>(); for (Node n : nodes) { NodeId id = strategy.computeId(n); Assert.assertTrue("got duplicated node", ids.add(id)); } return ids; }
public void removeNodes(QuadTreeClusteringStrategy strategy, List<Node> nodes) { for (Node node : nodes) { if (!strategy.remove(node)) { NodeId nodeid = strategy.computeId(node); Assert.fail("Node " + nodeid + " was not removed"); } } }
public void removeNodes(QuadTreeClusteringStrategy strategy, List<Node> nodes) { for (Node node : nodes) { if (!strategy.remove(node)) { NodeId nodeid = strategy.computeId(node); Assert.fail("Node " + nodeid + " was not removed"); } } }
public void updateNodes(QuadTreeClusteringStrategy strategy, List<Node> oldNodes, List<Node> newNodes) { Preconditions.checkArgument(oldNodes.size() == newNodes.size()); for (int i = 0; i < oldNodes.size(); i++) { Node oldNode = oldNodes.get(i); Node newNode = newNodes.get(i); Assert.assertEquals("Nodes shall be provided in equal order", oldNode.getName(), newNode.getName()); int retCode = strategy.update(oldNode, newNode); int expected = newNode.getObjectId().isNull() ? -1 : 1; if (retCode != expected) { NodeId oldnodeid = strategy.computeId(oldNode); NodeId newnodeid = strategy.computeId(newNode); Assert.assertEquals( String.format("Node update failed %s -> %s", oldnodeid, newnodeid), expected, retCode); } } }
public void updateNodes(QuadTreeClusteringStrategy strategy, List<Node> oldNodes, List<Node> newNodes) { Preconditions.checkArgument(oldNodes.size() == newNodes.size()); for (int i = 0; i < oldNodes.size(); i++) { Node oldNode = oldNodes.get(i); Node newNode = newNodes.get(i); Assert.assertEquals("Nodes shall be provided in equal order", oldNode.getName(), newNode.getName()); int retCode = strategy.update(oldNode, newNode); int expected = newNode.getObjectId().isNull() ? -1 : 1; if (retCode != expected) { NodeId oldnodeid = strategy.computeId(oldNode); NodeId newnodeid = strategy.computeId(newNode); Assert.assertEquals( String.format("Node update failed %s -> %s", oldnodeid, newnodeid), expected, retCode); } } }
public void putNodes(QuadTreeClusteringStrategy strategy, List<Node> nodes) { for (Node node : nodes) { int retCode = strategy.put(node); if (retCode != 1) { NodeId nodeid = strategy.computeId(node); Assert.assertEquals("Node " + nodeid + " was not inserted", 1, strategy.put(node)); } } }
public void putNodes(QuadTreeClusteringStrategy strategy, List<Node> nodes) { for (Node node : nodes) { int retCode = strategy.put(node); if (retCode != 1) { NodeId nodeid = strategy.computeId(node); Assert.assertEquals("Node " + nodeid + " was not inserted", 1, strategy.put(node)); } } }
@Test public void test_level0() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); Node n = support.createNode("node", new Quadrant[] {}); NodeId quadID = quadStrategy.computeId(n); assertEquals(0, quadStrategy.quadrantsByDepth(quadID, 8).size()); assertEquals(-1, quadStrategy.bucket(quadID, 0)); }
@Test public void test_level0() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); Node n = support.createNode("node", new Quadrant[] {}); NodeId quadID = quadStrategy.computeId(n); assertEquals(0, quadStrategy.quadrantsByDepth(quadID, 8).size()); assertEquals(-1, quadStrategy.bucket(quadID, 0)); }
@Test public void test_nullEnvelope() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); Node n = support.createNode("empty envelope", new Envelope()); NodeId quadID = quadStrategy.computeId(n); assertNotNull(quadID); assertNull(quadID.value()); n = support.createNode("empty envelope", (Envelope) null); quadID = quadStrategy.computeId(n); assertNotNull(quadID); assertNull(quadID.value()); }
@Test public void test_nullEnvelope() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); Node n = support.createNode("empty envelope", new Envelope()); NodeId quadID = quadStrategy.computeId(n); assertNotNull(quadID); assertNull(quadID.value()); n = support.createNode("empty envelope", (Envelope) null); quadID = quadStrategy.computeId(n); assertNotNull(quadID); assertNull(quadID.value()); }
@Test public void test_level1() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); // create quad-sized node for each of the first level (1/4 world) quads for (Quadrant q : Quadrant.values()) { Node n = support.createNode("node", q); NodeId quadID = quadStrategy.computeId(n); // should only be one level deep (too big to go further) assertEquals(1, quadStrategy.quadrantsByDepth(quadID, 8).size()); assertEquals(q.getBucketNumber(), quadStrategy.bucket(quadID, 0)); } }
@Test public void test_overMaxlevel() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); int maxDepth = quadStrategy.getMaxDepth(); // random path to depth Random rand = new Random(); List<Quadrant> quads = new ArrayList<>(8); for (int t = 0; t < maxDepth; t++) { quads.add(Quadrant.values()[rand.nextInt(3)]); } Node n = support.createNode("node", quads); NodeId quadID = quadStrategy.computeId(n); Envelope nodeBounds = quadID.value(); assertEquals(quads.get(maxDepth - 1), quadStrategy.computeQuadrant(nodeBounds, maxDepth - 1)); assertNull(quadStrategy.computeQuadrant(nodeBounds, maxDepth)); assertNull(quadStrategy.computeQuadrant(nodeBounds, maxDepth + 1)); assertEquals(maxDepth, quadStrategy.quadrantsByDepth(quadID, maxDepth + 10).size()); for (int t = 0; t < maxDepth; t++) { assertEquals(quads.get(t).getBucketNumber(), quadStrategy.bucket(quadID, t)); } } }
@Test public void test_level1() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); // create quad-sized node for each of the first level (1/4 world) quads for (Quadrant q : Quadrant.values()) { Node n = support.createNode("node", q); NodeId quadID = quadStrategy.computeId(n); // should only be one level deep (too big to go further) assertEquals(1, quadStrategy.quadrantsByDepth(quadID, 8).size()); assertEquals(q.getBucketNumber(), quadStrategy.bucket(quadID, 0)); } }
@Test public void test_overMaxlevel() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); int maxDepth = quadStrategy.getMaxDepth(); // random path to depth Random rand = new Random(); List<Quadrant> quads = new ArrayList<>(8); for (int t = 0; t < maxDepth; t++) { quads.add(Quadrant.values()[rand.nextInt(3)]); } Node n = support.createNode("node", quads); NodeId quadID = quadStrategy.computeId(n); Envelope nodeBounds = quadID.value(); assertEquals(quads.get(maxDepth - 1), quadStrategy.computeQuadrant(nodeBounds, maxDepth - 1)); assertNull(quadStrategy.computeQuadrant(nodeBounds, maxDepth)); assertNull(quadStrategy.computeQuadrant(nodeBounds, maxDepth + 1)); assertEquals(maxDepth, quadStrategy.quadrantsByDepth(quadID, maxDepth + 10).size()); for (int t = 0; t < maxDepth; t++) { assertEquals(quads.get(t).getBucketNumber(), quadStrategy.bucket(quadID, t)); } } }
@Test public void test_level2() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); // create quad-sized node for each of the first level (1/8 world) quads for (Quadrant q1 : Quadrant.values()) { for (Quadrant q2 : Quadrant.values()) { Node n = support.createNode("node", q1, q2); NodeId quadID = quadStrategy.computeId(n); // should only be 2 levels deep (too big to go further) assertEquals(2, quadStrategy.quadrantsByDepth(quadID, 8).size()); assertEquals(q1.getBucketNumber(), quadStrategy.bucket(quadID, 0)); assertEquals(q2.getBucketNumber(), quadStrategy.bucket(quadID, 1)); } } }
@Test public void test_level2() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); // create quad-sized node for each of the first level (1/8 world) quads for (Quadrant q1 : Quadrant.values()) { for (Quadrant q2 : Quadrant.values()) { Node n = support.createNode("node", q1, q2); NodeId quadID = quadStrategy.computeId(n); // should only be 2 levels deep (too big to go further) assertEquals(2, quadStrategy.quadrantsByDepth(quadID, 8).size()); assertEquals(q1.getBucketNumber(), quadStrategy.bucket(quadID, 0)); assertEquals(q2.getBucketNumber(), quadStrategy.bucket(quadID, 1)); } } }
@Test public void test_level3() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); // create quad-sized node for each of the first level (1/16 world) quads for (Quadrant q1 : Quadrant.values()) { for (Quadrant q2 : Quadrant.values()) { for (Quadrant q3 : Quadrant.values()) { Node n = support.createNode("node", q1, q2, q3); NodeId quadID = quadStrategy.computeId(n); // should only be 3 levels deep (too big to go further) assertEquals(3, quadStrategy.quadrantsByDepth(quadID, 8).size()); assertEquals(q1.getBucketNumber(), quadStrategy.bucket(quadID, 0)); assertEquals(q2.getBucketNumber(), quadStrategy.bucket(quadID, 1)); assertEquals(q3.getBucketNumber(), quadStrategy.bucket(quadID, 2)); } } } }
@Test public void test_level3() { QuadTreeClusteringStrategy quadStrategy = support.newStrategy(); // create quad-sized node for each of the first level (1/16 world) quads for (Quadrant q1 : Quadrant.values()) { for (Quadrant q2 : Quadrant.values()) { for (Quadrant q3 : Quadrant.values()) { Node n = support.createNode("node", q1, q2, q3); NodeId quadID = quadStrategy.computeId(n); // should only be 3 levels deep (too big to go further) assertEquals(3, quadStrategy.quadrantsByDepth(quadID, 8).size()); assertEquals(q1.getBucketNumber(), quadStrategy.bucket(quadID, 0)); assertEquals(q2.getBucketNumber(), quadStrategy.bucket(quadID, 1)); assertEquals(q3.getBucketNumber(), quadStrategy.bucket(quadID, 2)); } } } }