private RevTree createLeafTree(Collection<Node> featureNodes) { int childTreeCount = 0; ImmutableList<Node> trees = null; List<Node> sorted = new ArrayList<Node>(featureNodes); Collections.sort(sorted, CanonicalNodeOrder.INSTANCE); ImmutableList<Node> features = ImmutableList.copyOf(sorted); ImmutableSortedMap<Integer, Bucket> buckets = null; int size = features.size(); RevTree tree = RevTreeBuilder.build(size, childTreeCount, trees, features, buckets); return tree; }
public static RevTree createFeaturesTree(ObjectStore source, final String namePrefix, final int numEntries, final int startIndex, boolean randomIds) { RevTree tree = createFeaturesTreeBuilder(source, namePrefix, numEntries, startIndex, randomIds).build(); source.put(tree); return tree; }
public static RevTree createTreesTree(ObjectStore source, int numSubTrees, int featuresPerSubtre, ObjectId metadataId) { RevTree tree = createTreesTreeBuilder(source, numSubTrees, featuresPerSubtre, metadataId) .build(); source.put(tree); return tree; }
public static RevTree createLargeFeaturesTree(ObjectDatabase source, final String namePrefix, final int numEntries, final int startIndex, boolean randomIds) { RevTreeBuilder builder = createLargeFeaturesTreeBuilder(source, namePrefix, numEntries, startIndex, randomIds); RevTree tree = builder.build(); source.put(tree); return tree; }
public static RevTree createFeaturesTree(ObjectStore source, final String namePrefix, final int numEntries) { RevTree tree = createFeaturesTreeBuilder(source, namePrefix, numEntries).build(); source.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 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(); }
@Test public void testSameRootTree() { RevTree left = createFeaturesTreeBuilder(leftSource, "f", 10).build(); RevTree right = left; leftSource.put(left); rightSource.put(right); PostOrderDiffWalk visitor = new PostOrderDiffWalk(left, right, leftSource, rightSource); Consumer consumer = mock(Consumer.class); visitor.walk(consumer); verifyNoMoreInteractions(consumer); }
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(); }
@Test public void testSameChildTree() { RevTree left = createFeaturesTreeBuilder(leftSource, "f", 10).build(); RevTree right = left; leftSource.put(left); rightSource.put(right); PostOrderDiffWalk visitor = new PostOrderDiffWalk(left, right, leftSource, rightSource); Consumer consumer = mock(Consumer.class); visitor.walk(consumer); verifyNoMoreInteractions(consumer); }
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; }
@Test public void testSimple() { RevTree left = createFeaturesTreeBuilder(leftSource, "f", 1).build(); RevTree right = createFeaturesTreeBuilder(rightSource, "f", 2).build(); leftSource.put(left); rightSource.put(right); PostOrderDiffWalk visitor = new PostOrderDiffWalk(left, right, leftSource, rightSource); List<? extends Bounded> expectedLeft = newArrayList(null, nodeFor(left)); List<? extends Bounded> expectedRight = newArrayList(featureNodeRef("f", 1), nodeFor(right)); visitor.walk(testConsumer); assertEquals(expectedLeft, testConsumer.orderedLeft); assertEquals(expectedRight, testConsumer.orderedRight); }
private void testResultingTreeSize(int numEntries) { objectStore.close(); objectStore = new HeapObjectDatabase(); objectStore.open(); RevTreeBuilder builder = createTree(numEntries, true); RevTree tree = builder.build(); final long declaredSize = tree.size(); Iterator<NodeRef> it = new DepthTreeIterator("", ObjectId.NULL, tree, objectStore, Strategy.RECURSIVE_FEATURES_ONLY); long itSize = 0; while (it.hasNext()) { it.next(); itSize++; } assertEquals(numEntries, declaredSize); assertEquals(numEntries, itSize); }
@Test public void testLeafLeafTwoAdds() { // two leaf trees RevTree left = createFeaturesTreeBuilder(leftSource, "f", 3).build(); RevTree right = createFeaturesTreeBuilder(rightSource, "f", 5).build(); leftSource.put(left); rightSource.put(right); PostOrderDiffWalk visitor = new PostOrderDiffWalk(left, right, leftSource, rightSource); List<? extends Bounded> expectedLeft = newArrayList(// null, // null, // nodeFor(left)); List<? extends Bounded> expectedRight = newArrayList(// featureNodeRef("f", 3), // featureNodeRef("f", 4), // nodeFor(right)); visitor.walk(testConsumer); assertEquals(expectedLeft, testConsumer.orderedLeft); assertEquals(expectedRight, testConsumer.orderedRight); }
private RevTree forceTreeId(RevTreeBuilder b, ObjectId treeId) { RevTree tree = b.build(); long size = tree.size(); int childTreeCount = tree.numTrees(); ImmutableList<Node> trees = tree.trees(); ImmutableList<Node> features = tree.features(); SortedMap<Integer, Bucket> buckets = tree.buckets(); RevTree fakenId = RevTreeBuilder.create(treeId, size, childTreeCount, trees, features, buckets); return fakenId; }
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 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()); }
@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()); }
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; }
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); }