@Override protected RevTreeBuilder createBuiler() { return createBuiler(RevTree.EMPTY); }
private void testPoints(final int size) { List<Node> nodes = createPointNodes(nodeRange(size)); testCreateQuadTree(maxBounds, nodes); }
private RevTreeBuilder createQuadTree(Envelope maxBounds, final Iterable<Node> nodes) { return createQuadTree(maxBounds, nodes, this.objectStore); }
private void testSmallRects(final int size) { List<Node> nodes = createSmallRectNodes(nodeRange(size), maxBounds); testCreateQuadTree(maxBounds, nodes); }
private void testRandomRects(final int size) { List<Node> nodes = createRandomRectNodes(nodeRange(size), maxBounds); testCreateQuadTree(maxBounds, nodes); }
private void testRemove(final int ncount) { final Set<Node> nodes = new HashSet<>(createPointNodes(nodeRange(ncount))); RevTreeBuilder initialTreeBuilder = createQuadTree(maxBounds, nodes); final RevTree tree = initialTreeBuilder.build(); final Set<Node> removedNodes; RevTreeBuilder builder = RevTreeBuilder.quadBuilder(objectStore, objectStore, tree, maxBounds); // collect some keys to remove { Set<Node> treeNodes = RevObjectTestSupport.getTreeNodes(tree, objectStore); assertEquals(nodes, treeNodes); List<Node> list = new ArrayList<>(treeNodes); Collections.shuffle(list); int removeCount = ncount / 10; removedNodes = ImmutableSet.copyOf(list.subList(0, removeCount)); for (Node node : removedNodes) { boolean removed = builder.remove(node); assertTrue("Not removed: " + node, removed); } assertFalse(removedNodes.isEmpty()); } final RevTree result = builder.build(); Set<Node> resultNodes = getNodes(result); SetView<Node> difference = Sets.difference(nodes, resultNodes); assertEquals(removedNodes.size(), difference.size()); assertEquals(removedNodes, difference); }
public @Test void testNullGeometriesGoToRootUnpromotablesTree() { int size = 128; List<Node> nodes = createPointNodes(nodeRange(size)); RevTreeBuilder builder = createQuadTree(maxBounds, nodes); Node nullEnvNode = createNode(10000, null); builder.put(nullEnvNode); RevTree tree = builder.build(); assertNotEquals(0, tree.bucketsSize()); List<Node> matches = findNode(nullEnvNode.getName(), tree, objectStore); assertEquals(1, matches.size()); Integer unpromotablesBucketIndex = Integer.valueOf(4); assertTrue(tree.getBucket(unpromotablesBucketIndex).isPresent()); RevTree unpromotables = objectStore .getTree(tree.getBucket(unpromotablesBucketIndex).get().getObjectId()); matches = findNode(nullEnvNode.getName(), unpromotables, objectStore); assertEquals(1, matches.size()); }
final int ncount = 1000; final List<Node> oldNodes = createPointNodes(nodeRange(ncount)); final List<Node> newNodes = new ArrayList<>(oldNodes); final Set<Node> expectedRemoves = new HashSet<>(); newNodeIds.add(ncount + i); expectedAdditions.addAll(createPointNodes(newNodeIds)); newNodes.addAll(expectedAdditions); final RevTree oldTree = createQuadTree(maxBounds, oldNodes).build(); final RevTree newTree = createQuadTree(maxBounds, newNodes).build();
private RevTree testCreateQuadTree(final Envelope maxBounds, List<Node> nodes) { RevTreeBuilder sequentialBuilder = createQuadTree(maxBounds, nodes); Collections.shuffle(nodes); RevTreeBuilder randomOrderTree = createQuadTree(maxBounds, nodes); RevTree revTreeFromSequentialQuadTree = sequentialBuilder.build(); RevTree revTreeFromRandomQuadTree = randomOrderTree.build(); assertEquals(revTreeFromSequentialQuadTree, revTreeFromRandomQuadTree); Set<Node> expectedNodes = new HashSet<>(nodes); Set<Node> actualNodes = getNodes(revTreeFromRandomQuadTree); if (!expectedNodes.equals(actualNodes)) { SetView<Node> difference = Sets.difference(expectedNodes, actualNodes); Assert.fail("Missing: " + difference); } // print(revTreeFromSequentialQuadTree); assertEquals(nodes.size(), revTreeFromSequentialQuadTree.size()); final int size = nodes.size(); final RevTree tree = revTreeFromRandomQuadTree; if (size == 0) { assertEquals(RevTree.EMPTY, tree); } else { if (size < 129) { assertEquals(0, tree.bucketsSize()); assertFalse(tree.features().isEmpty()); } else { assertNotEquals(0, tree.bucketsSize()); assertTrue(tree.features().isEmpty()); } } return revTreeFromRandomQuadTree; }
@Override protected Node createNode(int i) { Node node = createRandomSmallRectNode(i); return node; }
private Node createRandomPointNode(Integer intId) { final double minX = maxBounds.getMinX(); final double minY = maxBounds.getMinY(); double x = minX + maxBounds.getWidth() * random.nextDouble(); double y = minY + maxBounds.getHeight() * random.nextDouble(); Envelope bounds = new Envelope(x, x, y, y); Node node = createNode(intId, bounds); return node; }
private List<Node> createPointNodes(List<Integer> nodeIds) { List<Node> nodes = new ArrayList<Node>(nodeIds.size()); for (Integer intId : nodeIds) { Node node = createRandomPointNode(intId); nodes.add(node); } return nodes; }
private Set<Node> getNodes(RevTree t) { Set<Node> nodes = new TreeSet<>(); if (t.bucketsSize() == 0) { nodes.addAll(t.features()); } else { for (Bucket b : t.getBuckets()) { RevTree subtree = objectStore.getTree(b.getObjectId()); nodes.addAll(getNodes(subtree)); } } return nodes; }
@Before public void before() { maxBounds = createMaxBounds(); random = new Random(); }
private void testRemove(final int ncount) { final Set<Node> nodes = new HashSet<>(createPointNodes(nodeRange(ncount))); QuadTreeBuilder initialTreeBuilder = createQuadTree(maxBounds, nodes); initialTreeBuilder.clusteringStrategy(); final RevTree tree = initialTreeBuilder.build(); final Set<Node> removedNodes; QuadTreeBuilder builder = QuadTreeBuilder.create(objectStore, objectStore, tree, maxBounds); // collect some keys to remove { Set<Node> treeNodes = RevObjectTestSupport.getTreeNodes(tree, objectStore); assertEquals(nodes, treeNodes); List<Node> list = new ArrayList<>(treeNodes); Collections.shuffle(list); int removeCount = ncount / 10; removedNodes = ImmutableSet.copyOf(list.subList(0, removeCount)); for (Node node : removedNodes) { boolean removed = builder.remove(node); assertTrue("Not removed: " + node, removed); } assertFalse(removedNodes.isEmpty()); } final RevTree result = builder.build(); Set<Node> resultNodes = getNodes(result); SetView<Node> difference = Sets.difference(nodes, resultNodes); assertEquals(removedNodes.size(), difference.size()); assertEquals(removedNodes, difference); }
public @Test void testNullGeometriesGoToRootUnpromotablesTree() { int size = 128; List<Node> nodes = createPointNodes(nodeRange(size)); RevTreeBuilder builder = createQuadTree(maxBounds, nodes); Node nullEnvNode = createNode(10000, null); builder.put(nullEnvNode); RevTree tree = builder.build(); assertFalse(tree.buckets().isEmpty()); List<Node> matches = findNode(nullEnvNode.getName(), tree, objectStore); assertEquals(1, matches.size()); Integer unpromotablesBucketIndex = Integer.valueOf(4); assertTrue(tree.buckets().keySet().contains(unpromotablesBucketIndex)); RevTree unpromotables = objectStore .getTree(tree.buckets().get(unpromotablesBucketIndex).getObjectId()); matches = findNode(nullEnvNode.getName(), unpromotables, objectStore); assertEquals(1, matches.size()); }
private void testSmallRects(final int size) { List<Node> nodes = createSmallRectNodes(nodeRange(size), maxBounds); testCreateQuadTree(maxBounds, nodes); }
private void testRandomRects(final int size) { List<Node> nodes = createRandomRectNodes(nodeRange(size), maxBounds); testCreateQuadTree(maxBounds, nodes); }
final int ncount = 1000; final List<Node> oldNodes = createPointNodes(nodeRange(ncount)); final List<Node> newNodes = new ArrayList<>(oldNodes); final Set<Node> expectedRemoves = new HashSet<>(); newNodeIds.add(ncount + i); expectedAdditions.addAll(createPointNodes(newNodeIds)); newNodes.addAll(expectedAdditions); final RevTree oldTree = createQuadTree(maxBounds, oldNodes).build(); final RevTree newTree = createQuadTree(maxBounds, newNodes).build();
private RevTree testCreateQuadTree(final Envelope maxBounds, List<Node> nodes) { RevTreeBuilder sequentialBuilder = createQuadTree(maxBounds, nodes); Collections.shuffle(nodes); RevTreeBuilder randomOrderTree = createQuadTree(maxBounds, nodes); RevTree revTreeFromSequentialQuadTree = sequentialBuilder.build(); RevTree revTreeFromRandomQuadTree = randomOrderTree.build(); assertEquals(revTreeFromSequentialQuadTree, revTreeFromRandomQuadTree); Set<Node> expectedNodes = new HashSet<>(nodes); Set<Node> actualNodes = getNodes(revTreeFromRandomQuadTree); if (!expectedNodes.equals(actualNodes)) { SetView<Node> difference = Sets.difference(expectedNodes, actualNodes); Assert.fail("Missing: " + difference); } // print(revTreeFromSequentialQuadTree); assertEquals(nodes.size(), revTreeFromSequentialQuadTree.size()); final int size = nodes.size(); final RevTree tree = revTreeFromRandomQuadTree; if (size == 0) { assertEquals(RevTree.EMPTY, tree); } else { if (size < 129) { assertTrue(tree.buckets().isEmpty()); assertFalse(tree.features().isEmpty()); } else { assertFalse(tree.buckets().isEmpty()); assertTrue(tree.features().isEmpty()); } } return revTreeFromRandomQuadTree; }