/** * Creates an IntervalTree lookup for each reference contig and direction */ protected List<IntervalTree<List<VariantEvidenceSupport>>> createByReferenceIndexDirectionLookup(int referenceSequenceCount) { return IntStream.range(0, referenceSequenceCount * 2) .mapToObj(i -> new IntervalTree<List<VariantEvidenceSupport>>()) .collect(Collectors.toList()); } protected VariantEvidenceSupport findBestOverlapping(BreakendSummary breakend, Iterator<VariantEvidenceSupport> it) {
/** Adds a Locatable to the set of Locatables against which to match candidates. */ public void addLhs(final T object, final Locatable interval) { if (object == null) { throw new IllegalArgumentException("null object"); } if (interval == null) { throw new IllegalArgumentException("null interval"); } final String seqId = interval.getContig(); IntervalTree<Set<T>> tree = this.cache.get(seqId); if (tree == null) { tree = new IntervalTree<>(); this.cache.put(seqId, tree); } final int start = interval.getStart() + this.lhsBuffer; final int end = interval.getEnd() - this.lhsBuffer; final Set<T> objects = new HashSet<>(1); objects.add(object); if (start <= end) { // Don't put in sequences that have no overlappable bases final Set<T> alreadyThere = tree.put(start, end, objects); if (alreadyThere != null) { alreadyThere.add(object); tree.put(start, end, alreadyThere); } } }
@Override public T put(final Interval key, final T value) { IntervalTree<T> tree = mSequenceMap.get(key.getContig()); if (tree == null) { tree = new IntervalTree<T>(); mSequenceMap.put(key.getContig(), tree); } return tree.put(key.getStart(), key.getEnd(), value); }
public T put(final Interval key, final T value) { IntervalTree<T> tree = mSequenceMap.get(key.getSequence()); if (tree == null) { tree = new IntervalTree<T>(); mSequenceMap.put(key.getSequence(), tree); } return tree.put(key.getStart(), key.getEnd(), value); }
/** Adds a Locatable to the set of Locatables against which to match candidates. */ public void addLhs(final T object, final Locatable interval) { if (object == null) { throw new IllegalArgumentException("null object"); } if (interval == null) { throw new IllegalArgumentException("null interval"); } final String seqId = interval.getContig(); IntervalTree<Set<T>> tree = this.cache.get(seqId); if (tree == null) { tree = new IntervalTree<>(); this.cache.put(seqId, tree); } final int start = interval.getStart() + this.lhsBuffer; final int end = interval.getEnd() - this.lhsBuffer; final Set<T> objects = new HashSet<>(1); objects.add(object); if (start <= end) { // Don't put in sequences that have no overlappable bases final Set<T> alreadyThere = tree.put(start, end, objects); if (alreadyThere != null) { alreadyThere.add(object); tree.put(start, end, alreadyThere); } } }
@Override public T put(final Interval key, final T value) { IntervalTree<T> tree = mSequenceMap.get(key.getContig()); if (tree == null) { tree = new IntervalTree<T>(); mSequenceMap.put(key.getContig(), tree); } return tree.put(key.getStart(), key.getEnd(), value); }
/** Adds a mapping to the set of mappings against which to match candidates. */ public void addLhs(T object, Interval interval) { Object seqId = interval.getSequence(); IntervalTree<Set<T>> tree = this.cache.get(seqId); if (tree == null) { tree = new IntervalTree<Set<T>>(); this.cache.put(seqId, tree); } int start = interval.getStart() + this.lhsBuffer; int end = interval.getEnd() - this.lhsBuffer; Set<T> objects = new HashSet<T>(); objects.add(object); if (start <= end) // Don't put in sequences that have no overlappable bases { Set<T> alreadyThere = tree.put(start, end, objects); if (alreadyThere != null) { alreadyThere.add(object); tree.put(start, end, alreadyThere); } } }
public final Map<String, IntervalTree<GenomeLoc>> createIntervalTreeByContig(final IntervalBinding<Feature> intervals) { final Map<String, IntervalTree<GenomeLoc>> byContig = new HashMap<String, IntervalTree<GenomeLoc>>(); final List<GenomeLoc> locs = intervals.getIntervals(getToolkit().getGenomeLocParser()); // set up the map from contig -> interval tree for ( final String contig : getContigNames() ) byContig.put(contig, new IntervalTree<GenomeLoc>()); for ( final GenomeLoc loc : locs ) { byContig.get(loc.getContig()).put(loc.getStart(), loc.getStop(), loc); } return byContig; }
@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."); }
this.zeroDepthIntervals.put(chrom, new IntervalTree());
private IntervalTree<Annotation> retrieveTranscripts(Genomics genomics, StreamVariantsRequest request) { Stopwatch stopwatch = Stopwatch.createStarted(); IntervalTree<Annotation> transcripts = new IntervalTree<>(); Iterable<Annotation> transcriptIter = Paginator.Annotations.create(genomics, ShardBoundary.Requirement.OVERLAPS).search( new SearchAnnotationsRequest() .setAnnotationSetIds(transcriptSetIds) .setReferenceName(canonicalizeRefName(request.getReferenceName())) .setStart(request.getStart()) .setEnd(request.getEnd())); for (Annotation annotation : transcriptIter) { transcripts.put(annotation.getStart().intValue(), annotation.getEnd().intValue(), annotation); } LOG.info(String.format("read %d transcripts in %s (%.2f / s)", transcripts.size(), stopwatch, (double)transcripts.size() / stopwatch.elapsed(TimeUnit.SECONDS))); return transcripts; }
private IntervalTree<Annotation> retrieveTranscripts(Genomics genomics, StreamVariantsRequest request) { Stopwatch stopwatch = Stopwatch.createStarted(); IntervalTree<Annotation> transcripts = new IntervalTree<>(); Iterable<Annotation> transcriptIter = Paginator.Annotations.create(genomics, ShardBoundary.Requirement.OVERLAPS).search( new SearchAnnotationsRequest() .setAnnotationSetIds(transcriptSetIds) .setReferenceName(canonicalizeRefName(request.getReferenceName())) .setStart(request.getStart()) .setEnd(request.getEnd())); for (Annotation annotation : transcriptIter) { transcripts.put(annotation.getStart().intValue(), annotation.getEnd().intValue(), annotation); } LOG.info(String.format("read %d transcripts in %s (%.2f / s)", transcripts.size(), stopwatch, (double)transcripts.size() / stopwatch.elapsed(TimeUnit.SECONDS))); return transcripts; }
@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 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)"); }
@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")); }
{46391117, 46391351}, }; IntervalTree<String> intervalTree = new IntervalTree<String>(); for (int[] add : adds) { intervalTree.put(add[0], add[1], "frob");
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); } }