private int putAll(final int size, final Stream<Node> nodes, final RevTreeBuilder b) { int count = 0, s = 0; final int step = size / 100; Node n = null; for (Iterator<Node> it = nodes.iterator(); it.hasNext();) { n = it.next(); count++; s++; b.put(n); if (s == step) { s = 0; System.err.print('#'); } } System.err.println(); return count; }
private void addNode(RevTreeBuilder tree, int i) { Node ref = createNode(i); tree.put(ref); }
private RevTreeBuilder createFeaturesTree(final String parentPath, final int numEntries) { RevTreeBuilder tree = RevTreeBuilder.builder(odb); for (int i = 0; i < numEntries; i++) { tree.put(featureRef(parentPath, i)); } return tree; }
private RevTreeBuilder createQuadTree(Envelope maxBounds, final Iterable<Node> nodes, final ObjectStore objectStore) { RevTreeBuilder qtree = RevTreeBuilder.quadBuilder(objectStore, objectStore, RevTree.EMPTY, maxBounds); for (Node node : nodes) { assertTrue(qtree.put(node)); } return qtree; } }
public Node put(final ObjectId revFeatureId, final Feature feature) { final RevTreeBuilder treeBuilder = getTreeBuilder(feature); String fid = feature.getIdentifier().getID(); // System.err.printf("%s -> %s\n", fid, treeBuilder); BoundingBox bounds = feature.getBounds(); FeatureType type = feature.getType(); final Node node = createFeatureNode(revFeatureId, fid, bounds, type); treeBuilder.put(node); return node; }
private RevTree createTree(String... blobs) { RevTreeBuilder builder = RevTreeBuilder.builder(odb); for (String blob : blobs) { builder.put(blob(blob)); } RevTree tree = builder.build(); return tree; }
public @Test void testRemoveWorldPoints() { List<Node> nodes = IndexTestSupport.createWorldPointsNodes(5); final RevTreeBuilder builder = createBuiler(); nodes.forEach((n) -> assertTrue(builder.put(n))); RevTree tree = builder.build(); assertEquals(nodes.size(), tree.size()); List<Node> removes = nodes.subList(0, nodes.size() / 2); final RevTreeBuilder builder2 = createBuiler(tree); removes.forEach((n) -> assertTrue(builder2.remove(n))); RevTree tree2 = builder2.build(); assertEquals(nodes.size() - removes.size(), tree2.size()); }
protected ObjectId createAndSaveTree(final List<Node> nodes, final boolean insertInListOrder) throws Exception { List<Node> insert = nodes; if (!insertInListOrder) { insert = new ArrayList<>(nodes); Collections.shuffle(insert); } RevTreeBuilder treeBuilder = createBuiler(); nodes.forEach((n) -> treeBuilder.put(n)); RevTree tree = treeBuilder.build(); assertTrue(objectStore.exists(tree.getId())); assertEquals(nodes.size(), tree.size()); return tree.getId(); }
private RevTree createTree(int numChildren) { RevTreeBuilder rtb = RevTreeBuilder.builder(odb); for (int i = 0; i < numChildren; i++) { String key = FEATURE_PREFIX + i; Node ref = RevObjectFactory.defaultInstance().createNode(key, FAKE_ID, FAKE_ID, TYPE.FEATURE, null, null); rtb.put(ref); } return rtb.build(); }
private RevTree tree(int nFeatures, ObjectDatabase db) { RevTreeBuilder b = RevTreeBuilder.builder(db); for (int i = 0; i < nFeatures; i++) { b.put(feature(i)); } RevTree tree = b.build(); db.put(tree); return tree; }
private void createFeatureTypesTree(RevTreeBuilder rootBuilder, String treePath, RevTree childTree) { odb.put(childTree); Node childRef = RevObjectFactory.defaultInstance().createNode(treePath, childTree.getId(), ObjectId.NULL, TYPE.TREE, null, null); rootBuilder.put(childRef); }
public RevTree build(ObjectStore store) { final ObjectId treeId = this.node.getObjectId(); final RevTree original = EMPTY_TREE_ID.equals(treeId) ? EMPTY : store.getTree(treeId); RevTreeBuilder builder = RevTreeBuilder.builder(store, original); ImmutableList<Node> currentTrees = original.trees(); currentTrees.forEach(builder::remove); for (MutableTree childTree : this.childTrees.values()) { childTree.build(store); Node newNode = childTree.node; builder.put(newNode); } final Node oldNode = this.node; RevTree newTree = builder.build(); Envelope newBounds = SpatialOps.boundsOf(newTree); Node newNode = oldNode.update(newTree.getId(), newBounds); this.node = newNode; return newTree; }
public RevTreeBuilder createFeaturesTreeBuilder(ObjectStore source, final String namePrefix, final int numEntries, final int startIndex, boolean randomIds) { RevTreeBuilder builder; if (spatialTrees) { Envelope maxBounds = getMaxBounds(); builder = RevTreeBuilder.quadBuilder(source, source, RevTree.EMPTY, maxBounds); } else { builder = RevTreeBuilder.builder(source); } for (int i = startIndex; i < startIndex + numEntries; i++) { builder.put(featureNode(namePrefix, i, randomIds)); } return builder; }
public RevTreeBuilder createLargeFeaturesTreeBuilder(ObjectDatabase source, final String namePrefix, final int numEntries, final int startIndex, boolean randomIds) { RevTreeBuilder builder; if (spatialTrees) { Envelope maxBounds = getMaxBounds(); builder = RevTreeBuilder.quadBuilder(source, source, RevTree.EMPTY, maxBounds); } else { builder = RevTreeBuilder.builder(source); } for (int i = startIndex; i < startIndex + numEntries; i++) { builder.put(featureNode(namePrefix, i, randomIds)); } return builder; }
public @Test void testRemoveWorldPointsWholeQuadrant() { List<Node> nodes = IndexTestSupport.createWorldPointsNodes(5); final RevTreeBuilder builder = createBuiler(); nodes.forEach((n) -> assertTrue(builder.put(n))); RevTree tree = builder.build(); assertEquals(nodes.size(), tree.size()); final Envelope NEBounds = new Envelope(0, 180, 0, 90); List<Node> removes = new ArrayList<>(); for (Node n : nodes) { if (NEBounds.contains(n.bounds().orNull())) { removes.add(n); } } final RevTreeBuilder builder2 = createBuiler(tree); removes.forEach((n) -> assertTrue(builder2.remove(n))); RevTree tree2 = builder2.build(); assertEquals(nodes.size() - removes.size(), tree2.size()); } }
private RevTree createRoot(ObjectDatabase db, final RevTree tree1, final RevTree tree2) { RevTreeBuilder rootBuilder = RevTreeBuilder.builder(db); rootBuilder.put(RevObjectFactory.defaultInstance().createNode("tree1", tree1.getId(), metadataId, TYPE.TREE, SpatialOps.boundsOf(tree1), null)); rootBuilder.put(RevObjectFactory.defaultInstance().createNode("tree2", tree2.getId(), metadataId, TYPE.TREE, SpatialOps.boundsOf(tree2), null)); RevTree root = rootBuilder.build(); db.put(root); return root; }
@Test public void testTrees() { assertEquals(0, list(emptyTree, Strategy.TREES_ONLY).size()); assertEquals(0, list(featuresLeafTree, Strategy.TREES_ONLY).size()); assertEquals(100, list(treesLeafTree, Strategy.TREES_ONLY).size()); assertEquals(10, list(mixedLeafTree, Strategy.TREES_ONLY).size()); assertEquals(0, list(featuresBucketsTree, Strategy.TREES_ONLY).size()); int numSubTrees = CanonicalNodeNameOrder.normalizedSizeLimit(0) + 1; int featuresPerTree = CanonicalNodeNameOrder.normalizedSizeLimit(0) + 1; RevTreeBuilder builder = RevObjectTestSupport.INSTANCE.createTreesTreeBuilder(source, numSubTrees, featuresPerTree, metadataId); for (int i = 0; i < 25000; i++) { builder.put(featureNode("f", i)); } RevTree mixedBucketsTree = builder.build(); assertEquals(numSubTrees, list(mixedBucketsTree, Strategy.TREES_ONLY).size()); }
public RevTreeBuilder createTreesTreeBuilder(ObjectStore source, int numSubTrees, int featuresPerSubtre, ObjectId metadataId) { RevTreeBuilder builder = RevTreeBuilder.builder(source); for (int treeN = 0; treeN < numSubTrees; treeN++) { RevTree subtree = createFeaturesTreeBuilder(source, "subtree" + treeN, featuresPerSubtre).build(); source.put(subtree); builder.put(RevObjectFactory.defaultInstance().createNode("subtree" + treeN, subtree.getId(), metadataId, TYPE.TREE, null, null)); } return builder; }
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()); }
private void checkTreeBounds(int size) { RevTreeBuilder b = createBuiler(); List<Node> nodes = createNodes(size); Envelope expectedBounds = new Envelope(); for (Node n : nodes) { b.put(n); n.expand(expectedBounds); } expectedBounds = RevObjects.makePrecise(expectedBounds); RevTree tree = b.build(); assertEquals(size, tree.size()); Envelope bounds = SpatialOps.boundsOf(tree); bounds = RevObjects.makePrecise(bounds); assertEquals(expectedBounds, bounds); }