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); SortedSet<Bucket> buckets = null; int size = features.size(); RevTree tree = RevTreeBuilder.build(size, childTreeCount, trees, features, buckets); return tree; }
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 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; }
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(); }
public RevTree createFeaturesTree(ObjectStore source, final String namePrefix, final int numEntries) { RevTree tree = createFeaturesTreeBuilder(source, namePrefix, numEntries).build(); source.put(tree); return tree; }
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; }
public 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 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 RevTree createTreesTree(ObjectStore source, int numSubTrees, int featuresPerSubtre, ObjectId metadataId) { RevTree tree = createTreesTreeBuilder(source, numSubTrees, featuresPerSubtre, metadataId) .build(); source.put(tree); return tree; }
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; }
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()); }
@Test public void testSameChildTree() { RevTree left = RevObjectTestSupport.INSTANCE.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); }
@Test public void testSameRootTree() { RevTree left = RevObjectTestSupport.INSTANCE.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 testSimple() { RevTree left = RevObjectTestSupport.INSTANCE.createFeaturesTreeBuilder(leftSource, "f", 1) .build(); RevTree right = RevObjectTestSupport.INSTANCE.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 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(); SortedSet<Bucket> buckets = ImmutableSortedSet.copyOf(tree.getBuckets()); RevObjectFactory factory = RevObjectFactory.defaultInstance(); RevTree fakenId; if (buckets.isEmpty()) { fakenId = factory.createTree(treeId, size, trees, features); } else { fakenId = factory.createTree(treeId, size, childTreeCount, buckets); } return fakenId; }
@Before public void setUp() { odb = new HeapObjectDatabase(); odb.open(); { RevTreeBuilder builder = createFeaturesTree("", 10); this.childrenFeatureTree = builder.build(); odb.put(childrenFeatureTree); } { RevTreeBuilder builder = createFeaturesTree("", 2 * CanonicalNodeNameOrder.normalizedSizeLimit(0)); this.bucketsFeatureTree = builder.build(); assertNotEquals(0, bucketsFeatureTree.bucketsSize()); odb.put(bucketsFeatureTree); } }
@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 @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); }