public Iterator<VariantEvidenceSupport> findAllOverlapping(BreakendSummary breakend) { IntervalTree<List<VariantEvidenceSupport>> tree = localLookup.get(getIndex(breakend.referenceIndex, breakend.direction)); Iterator<Node<List<VariantEvidenceSupport>>> nodeit = tree.overlappers(breakend.start, breakend.end); return new VariantEvidenceSupportNodeListIterator(nodeit, breakend); } public VariantEvidenceSupport findBestOverlapping(BreakendSummary breakend) {
public Collection<T> getOverlapping(final Locatable key) { final List<T> result = new ArrayList<T>(); final IntervalTree<T> tree = mSequenceMap.get(key.getContig()); if (tree != null) { final Iterator<IntervalTree.Node<T>> iterator = tree.overlappers(key.getStart(), key.getEnd()); while (iterator.hasNext()) { result.add(iterator.next().getValue()); } } return result; } /**
public Collection<T> getOverlapping(final Interval key) { final List<T> result = new ArrayList<T>(); final IntervalTree<T> tree = mSequenceMap.get(key.getSequence()); if (tree != null) { final Iterator<IntervalTree.Node<T>> iterator = tree.overlappers(key.getStart(), key.getEnd()); while (iterator.hasNext()) { result.add(iterator.next().getValue()); } } return result; } /**
/** * Test overlapping interval * @param key the interval * @return true if it contains an object overlapping the interval */ public boolean containsOverlapping(final Interval key) { final IntervalTree<T> tree = mSequenceMap.get(key.getSequence()); return tree!=null && tree.overlappers(key.getStart(), key.getEnd()).hasNext(); }
public Collection<T> getOverlapping(final Locatable key) { final List<T> result = new ArrayList<T>(); final IntervalTree<T> tree = mSequenceMap.get(key.getContig()); if (tree != null) { final Iterator<IntervalTree.Node<T>> iterator = tree.overlappers(key.getStart(), key.getEnd()); while (iterator.hasNext()) { result.add(iterator.next().getValue()); } } return result; } /**
/** * Test overlapping interval * @param key the Locatable * @return true if it contains an object overlapping the interval */ public boolean containsOverlapping(final Locatable key) { final IntervalTree<T> tree = mSequenceMap.get(key.getContig()); return tree!=null && tree.overlappers(key.getStart(), key.getEnd()).hasNext(); }
/** * Test overlapping interval * @param key the Locatable * @return true if it contains an object overlapping the interval */ public boolean containsOverlapping(final Locatable key) { final IntervalTree<T> tree = mSequenceMap.get(key.getContig()); return tree!=null && tree.overlappers(key.getStart(), key.getEnd()).hasNext(); }
public VariantEvidenceSupport findBestOverlapping(BreakpointSummary breakend) { IntervalTree<List<VariantEvidenceSupport>> tree = remoteLookup.get(getIndex(breakend.referenceIndex2, breakend.direction2)); Iterator<Node<List<VariantEvidenceSupport>>> nodeit = tree.overlappers(breakend.start2, breakend.end2); Iterator<VariantEvidenceSupport> it = new VariantEvidenceSupportNodeListIterator(nodeit, breakend); return findBestOverlapping(breakend, it); } @Override
@Test public void testNearEnds() { final IntervalTree<String> intervalTree = new IntervalTree<String>(); intervalTree.put(10, 20, "foo"); Assert.assertEquals(countElements(intervalTree.overlappers(10, 10)), 1, "Test overlap (no buffers) at near end exactly"); Assert.assertEquals(countElements(intervalTree.overlappers(9, 10)), 1, "Test overlap (no buffers) at near end exactly"); Assert.assertEquals(countElements(intervalTree.overlappers(9, 9)), 0, "Test just before overlap (no buffers)"); Assert.assertEquals(countElements(intervalTree.overlappers(20, 20)), 1, "Test overlap (no buffers) at far end exactly"); Assert.assertEquals(countElements(intervalTree.overlappers(20, 21)), 1, "Test overlap (no buffers) at far end exactly"); Assert.assertEquals(countElements(intervalTree.overlappers(21, 21)), 0, "Test just beyond overlap (no buffers)"); }
public Collection<T> getContained(final Locatable key) { final List<T> result = new ArrayList<T>(); final IntervalTree<T> tree = mSequenceMap.get(key.getContig()); if (tree != null) { final Iterator<IntervalTree.Node<T>> iterator = tree.overlappers(key.getStart(), key.getEnd()); while (iterator.hasNext()) { final IntervalTree.Node<T> node = iterator.next(); if (node.getStart() >= key.getStart() && node.getEnd() <= key.getEnd()) { result.add(node.getValue()); } } } return result; }
public Collection<T> getContained(final Locatable key) { final List<T> result = new ArrayList<T>(); final IntervalTree<T> tree = mSequenceMap.get(key.getContig()); if (tree != null) { final Iterator<IntervalTree.Node<T>> iterator = tree.overlappers(key.getStart(), key.getEnd()); while (iterator.hasNext()) { final IntervalTree.Node<T> node = iterator.next(); if (node.getStart() >= key.getStart() && node.getEnd() <= key.getEnd()) { result.add(node.getValue()); } } } return result; }
@Test public void testMatches() { // Single match Assert.assertEquals(countElements(intervalTree.overlappers(10, 10)), 1, "Test single overlap"); Assert.assertTrue(iteratorContains(intervalTree.overlappers(10, 10), "foo1:10"), "Test single overlap for correct overlapee"); // Multiple matches Assert.assertEquals(countElements(intervalTree.overlappers(7, 8)), 5, "Test multiple overlap"); Assert.assertTrue( iteratorContains(intervalTree.overlappers(7, 8), "foo1:10"), "Test multiple overlap for correct overlapees"); Assert.assertTrue( iteratorContains(intervalTree.overlappers(7, 8), "foo2:8"), "Test multiple overlap for correct overlapees"); Assert.assertTrue( iteratorContains(intervalTree.overlappers(7, 8), "foo3:6"), "Test multiple overlap for correct overlapees"); Assert.assertTrue( iteratorContains(intervalTree.overlappers(7, 8), "foo4:4"), "Test multiple overlap for correct overlapees"); Assert.assertTrue( iteratorContains(intervalTree.overlappers(7, 8), "foo6:9"), "Test multiple overlap for correct overlapees"); Assert.assertTrue(!iteratorContains(intervalTree.overlappers(7, 8), "foo5:2"), "Test multiple overlap for correct overlapees"); }
public Collection<T> getContained(final Interval key) { final List<T> result = new ArrayList<T>(); final IntervalTree<T> tree = mSequenceMap.get(key.getSequence()); if (tree != null) { final Iterator<IntervalTree.Node<T>> iterator = tree.overlappers(key.getStart(), key.getEnd()); while (iterator.hasNext()) { final IntervalTree.Node<T> node = iterator.next(); if (node.getStart() >= key.getStart() && node.getEnd() <= key.getEnd()) { result.add(node.getValue()); } } } return result; }
@Test public void performanceTest() { final IntervalTree<String> intervalTree = new IntervalTree<String>(); final long start = System.currentTimeMillis(); for (int i = 1; i <= 50000; i++) intervalTree.put(i, i, "frob"); System.out.println("Time to construct a tree with 50000 nodes: " + (System.currentTimeMillis() - start) + " milliseconds" ); final long end = System.currentTimeMillis() + 10000; int count = 0; while (System.currentTimeMillis() < end) { intervalTree.overlappers(17000, 17099); ++count; } System.out.println("Queried for the same 100-length mapping " + count + " times in 10 seconds."); }
/** * Test if this contains an object that is contained by 'key' * @param key the Locatable * @return true if it contains an object is contained by 'key' */ public boolean containsContained(final Locatable key) { final IntervalTree<T> tree = mSequenceMap.get(key.getContig()); if(tree==null) return false; final Iterator<IntervalTree.Node<T>> iterator = tree.overlappers(key.getStart(), key.getEnd()); while (iterator.hasNext()) { final IntervalTree.Node<T> node = iterator.next(); if (node.getStart() >= key.getStart() && node.getEnd() <= key.getEnd()) { return true; } } return false; }
private boolean overlapsKnownCNV(VariantContext cnv) { if ( knownCNVs != null ) { final GenomeLoc loc = getWalker().getToolkit().getGenomeLocParser().createGenomeLoc(cnv); IntervalTree<GenomeLoc> intervalTree = knownCNVs.get(loc.getContig()); final Iterator<IntervalTree.Node<GenomeLoc>> nodeIt = intervalTree.overlappers(loc.getStart(), loc.getStop()); while ( nodeIt.hasNext() ) { final double overlapP = loc.reciprocialOverlapFraction(nodeIt.next().getValue()); if ( overlapP > MIN_CNV_OVERLAP ) return true; } } return false; }
@Test public void testHandlingOfDuplicateMappings() { final IntervalTree<String> intervalTree = new IntervalTree<String>(); intervalTree.put(1, 10, "foo1"); // This call replaces foo1 with foo2 Assert.assertEquals(intervalTree.put(1, 10, "foo2"), "foo1"); intervalTree.put(2, 8, "foo3"); Assert.assertEquals(countElements(intervalTree.overlappers(3, 5)), 2); Assert.assertFalse(iteratorContains(intervalTree.overlappers(3, 5), "foo1")); Assert.assertTrue(iteratorContains(intervalTree.overlappers(3, 5), "foo2")); Assert.assertTrue(iteratorContains(intervalTree.overlappers(3, 5), "foo3")); }
@Test public void testNoMatches() { // Test empty tree final IntervalTree<String> intervalTree = new IntervalTree<String>(); Iterator<IntervalTree.Node<String>> results = intervalTree.overlappers(1, 500); Assert.assertEquals(countElements(results), 0, "Testing with no left-hand set failed."); // Test no matches at all intervalTree.put(1, 400, "foo"); intervalTree.put(600, 800, "foo2"); results = intervalTree.overlappers(450, 599); Assert.assertEquals(countElements(results), 0, "Testing with no overlaps at all."); }
@Test public void testOverlapIterator() { final IntervalTree.Node<String> testNode = new IntervalTree.Node<>(3, 4, "foobar1"); int count = 0; Iterator<IntervalTree.Node<String>> iterator = intervalTree.overlappers(testNode.getStart(), testNode.getEnd()); Iterable<IntervalTree.Node<String>> iterable = () -> iterator; for (IntervalTree.Node<String> node : iterable) { Assert.assertTrue( (testNode.getRelationship(node) & HAS_OVERLAPPING_PART) != 0, String.format("%s with %s = %d", node.toString(), testNode.toString(), node.getRelationship(testNode))); count++; } Assert.assertEquals(count, 5); // foobar1, foobar2, foobar3, foobar4, and foobar6 }
private void testOverlapping(List<Block> exons) { IntervalTree<Block> intervalTree = new IntervalTree<>(); for (Block exon : exons) { Iterator<IntervalTree.Node<Block>> nodeIterator = intervalTree.overlappers(exon.getStartIndex(), exon.getEndIndex()); Assert.assertFalse("Should be no overlapping exons", nodeIterator.hasNext()); intervalTree.put(exon.getStartIndex(), exon.getEndIndex(), exon); } }