private void addNode(RevTreeBuilder tree, int i) { Node ref = createNode(i); tree.put(ref); }
public static RevTreeBuilder createFeaturesTreeBuilder(ObjectStore source, final String namePrefix, final int numEntries, final int startIndex, boolean randomIds) { RevTreeBuilder tree = CanonicalTreeBuilder.create(source); for (int i = startIndex; i < startIndex + numEntries; i++) { tree.put(featureNode(namePrefix, i, randomIds)); } return tree; }
public static RevTreeBuilder createLargeFeaturesTreeBuilder(ObjectDatabase source, final String namePrefix, final int numEntries, final int startIndex, boolean randomIds) { RevTreeBuilder tree = CanonicalTreeBuilder.create(source); for (int i = startIndex; i < startIndex + numEntries; i++) { tree.put(featureNode(namePrefix, i, randomIds)); } return tree; }
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(int numChildren) { RevTreeBuilder rtb = CanonicalTreeBuilder.create(odb); for (int i = 0; i < numChildren; i++) { String key = FEATURE_PREFIX + i; Node ref = Node.create(key, FAKE_ID, FAKE_ID, TYPE.FEATURE, null); rtb.put(ref); } return rtb.build(); }
private void createFeatureTypesTree(RevTreeBuilder rootBuilder, String treePath, RevTree childTree) { odb.put(childTree); Node childRef = Node.create(treePath, childTree.getId(), ObjectId.NULL, TYPE.TREE, null); rootBuilder.put(childRef); }
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 tree(int nFeatures, ObjectDatabase db) { RevTreeBuilder b = CanonicalTreeBuilder.create(db); for (int i = 0; i < nFeatures; i++) { b.put(feature(i)); } RevTree tree = b.build(); db.put(tree); 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()); }
private RevTree createRoot(ObjectDatabase db, final RevTree tree1, final RevTree tree2) { RevTreeBuilder rootBuilder = CanonicalTreeBuilder.create(db); rootBuilder.put(Node.create("tree1", tree1.getId(), metadataId, TYPE.TREE, SpatialOps.boundsOf(tree1))); rootBuilder.put(Node.create("tree2", tree2.getId(), metadataId, TYPE.TREE, SpatialOps.boundsOf(tree2))); RevTree root = rootBuilder.build(); db.put(root); return root; }
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()); } }
public static RevTreeBuilder createTreesTreeBuilder(ObjectStore source, int numSubTrees, int featuresPerSubtre, ObjectId metadataId) { RevTreeBuilder builder = CanonicalTreeBuilder.create(source); for (int treeN = 0; treeN < numSubTrees; treeN++) { RevTree subtree = createFeaturesTreeBuilder(source, "subtree" + treeN, featuresPerSubtre).build(); source.put(subtree); builder.put( Node.create("subtree" + treeN, subtree.getId(), metadataId, TYPE.TREE, null)); } return builder; }
@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 = 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()); }
@Test public void testRecursiveTreesOnly() { assertEquals(0, list(emptyTree, Strategy.RECURSIVE_TREES_ONLY).size()); assertEquals(0, list(featuresLeafTree, Strategy.RECURSIVE_TREES_ONLY).size()); assertEquals(treesLeafTree.numTrees(), list(treesLeafTree, Strategy.RECURSIVE_TREES_ONLY).size()); assertEquals(mixedLeafTree.numTrees(), list(mixedLeafTree, Strategy.RECURSIVE_TREES_ONLY).size()); assertEquals(0, list(featuresBucketsTree, Strategy.RECURSIVE_TREES_ONLY).size()); int numSubTrees = CanonicalNodeNameOrder.normalizedSizeLimit(0) + 1; int featuresPerTree = CanonicalNodeNameOrder.normalizedSizeLimit(0) + 1; RevTreeBuilder builder = 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.RECURSIVE_TREES_ONLY).size()); }
private RevTree addTree(RevTree root, final String treePath, String... singleNodeNames) { Context mockInjector = mock(Context.class); when(mockInjector.objectDatabase()).thenReturn(odb); RevTreeBuilder subTreeBuilder = CanonicalTreeBuilder.create(mockInjector.objectDatabase()); if (singleNodeNames != null) { for (String singleNodeName : singleNodeNames) { String nodePath = NodeRef.appendChild(treePath, singleNodeName); ObjectId fakeFeatureOId = RevObjectTestSupport.hashString(nodePath); ObjectId fakeTypeOId = ObjectId.NULL;// forString(treePath); subTreeBuilder.put(Node.create(singleNodeName, fakeFeatureOId, fakeTypeOId, TYPE.FEATURE, null)); } } RevTree subtree = subTreeBuilder.build(); NodeRef childTreeNode = NodeRef.tree(treePath, subtree.getId(), fakeTreeMetadataId); RevTree newRoot = fakeGeogig.command(UpdateTree.class).setRoot(root).setChild(childTreeNode) .call(); return newRoot; }
@Test public void testRecursiveFeaturesOnly() { assertEquals(0, list(emptyTree, Strategy.RECURSIVE_FEATURES_ONLY).size()); assertEquals(100, list(featuresLeafTree, Strategy.RECURSIVE_FEATURES_ONLY).size()); assertEquals(treesLeafTree.size(), list(treesLeafTree, Strategy.RECURSIVE_FEATURES_ONLY).size()); assertEquals(mixedLeafTree.size(), list(mixedLeafTree, Strategy.RECURSIVE_FEATURES_ONLY).size()); assertEquals(featuresBucketsTree.size(), list(featuresBucketsTree, Strategy.RECURSIVE_FEATURES_ONLY).size()); int numSubTrees = CanonicalNodeNameOrder.normalizedSizeLimit(0) + 1; int featuresPerTree = CanonicalNodeNameOrder.normalizedSizeLimit(0) + 1; RevTreeBuilder builder = createTreesTreeBuilder(source, numSubTrees, featuresPerTree, metadataId); for (int i = 0; i < 25000; i++) { builder.put(featureNode("f", i)); } RevTree mixedBucketsTree = builder.build(); assertEquals(mixedBucketsTree.size(), list(mixedBucketsTree, Strategy.RECURSIVE_FEATURES_ONLY).size()); }
@Test public void testRecursive() { assertEquals(0, list(emptyTree, Strategy.RECURSIVE).size()); assertEquals(100, list(featuresLeafTree, Strategy.RECURSIVE).size()); assertEquals(treesLeafTree.size() + treesLeafTree.numTrees(), list(treesLeafTree, Strategy.RECURSIVE).size()); assertEquals(mixedLeafTree.size() + mixedLeafTree.numTrees(), list(mixedLeafTree, Strategy.RECURSIVE).size()); assertEquals(featuresBucketsTree.size(), list(featuresBucketsTree, Strategy.RECURSIVE).size()); int numSubTrees = CanonicalNodeNameOrder.normalizedSizeLimit(0) + 1; int featuresPerTree = CanonicalNodeNameOrder.normalizedSizeLimit(0) + 1; RevTreeBuilder builder = createTreesTreeBuilder(source, numSubTrees, featuresPerTree, metadataId); for (int i = 0; i < 25000; i++) { builder.put(featureNode("f", i)); } RevTree mixedBucketsTree = builder.build(); assertEquals(mixedBucketsTree.size() + mixedBucketsTree.numTrees(), list(mixedBucketsTree, Strategy.RECURSIVE).size()); }
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 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 = Node.makePrecise(expectedBounds); RevTree tree = b.build(); assertEquals(size, tree.size()); Envelope bounds = SpatialOps.boundsOf(tree); bounds = Node.makePrecise(bounds); assertEquals(expectedBounds, bounds); }
@Test public void testBucketBucketAdd() { RevTreeBuilder builder = CanonicalTreeBuilder.create(odb, bucketsFeatureTree); final int initialSize = (int) bucketsFeatureTree.size(); final int added = 1 + 2 * CanonicalNodeNameOrder.normalizedSizeLimit(0); for (int i = initialSize; i < (initialSize + added); i++) { builder.put(featureRef("", i)); } RevTree changed = builder.build(); odb.put(changed); assertEquals(initialSize + added, changed.size()); assertEquals(added, count(bucketsFeatureTree, changed).featureCount()); assertEquals(added, count(changed, bucketsFeatureTree).featureCount()); assertEquals(added, count(bucketsFeatureTree, changed).getFeaturesAdded()); assertEquals(0, count(bucketsFeatureTree, changed).getFeaturesChanged()); assertEquals(0, count(bucketsFeatureTree, changed).getFeaturesRemoved()); // invert the comparison assertEquals(0, count(changed, bucketsFeatureTree).getFeaturesAdded()); assertEquals(added, count(changed, bucketsFeatureTree).getFeaturesRemoved()); assertEquals(0, count(changed, bucketsFeatureTree).getFeaturesChanged()); }