/** 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 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) {
protected void remove(IntervalTree<List<VariantEvidenceSupport>> lookup, int start, int end, VariantEvidenceSupport ves) { Node<List<VariantEvidenceSupport>> node = lookup.find(start, end); if (node != null) { List<VariantEvidenceSupport> list = node.getValue(); if (!list.remove(ves)) { String msg = String.format("Attempting to remove %s which does not exist on interval (%d, %d)", ves.location, start, end); throw new IllegalStateException(msg); } node.getValue().remove(ves); if (node.getValue().isEmpty()) { lookup.remove(start, end); } } else { String msg = String.format("Attempting to remove %s from non-existant interval (%d, %d)", ves.location, start, end); throw new IllegalStateException(msg); } } /**
protected void add(IntervalTree<List<VariantEvidenceSupport>> lookup, int start, int end, VariantEvidenceSupport ves) { Node<List<VariantEvidenceSupport>> node = lookup.find(start, end); if (node != null) { node.getValue().add(ves); } else { ArrayList<VariantEvidenceSupport> list = new ArrayList<>(2); list.add(ves); lookup.put(start, end, list); } } protected void remove(IntervalTree<List<VariantEvidenceSupport>> lookup, int start, int end, VariantEvidenceSupport ves) {
@BeforeMethod public void init(){ //due to the destructive nature of removeMany test... intervalTree.clear(); // each interval has a "name:length" intervalTree.put(1, 10, "foo1:10"); intervalTree.put(2, 9, "foo2:8"); intervalTree.put(3, 8, "foo3:6"); intervalTree.put(4, 7, "foo4:4"); intervalTree.put(5, 6, "foo5:2"); intervalTree.put(1, 9, "foo6:9"); }
@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."); }
this.zeroDepthIntervals.put(chrom, new IntervalTree()); this.zeroDepthIntervals.get(chrom).clear(); for(int pos= this.getGc().getFrom(); pos <= this.getGc().getTo(); pos++){ if( ! this.loci.get(chrom).containsKey(pos) && ! this.zeroDepthIntervals.get(chrom).overlappers(pos, pos).hasNext()){ missingPos.add(pos); this.zeroDepthIntervals.get(chrom).put(z.get(0), z.get(1), null);
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; }
{46391117, 46391351}, }; IntervalTree<String> intervalTree = new IntervalTree<String>(); for (int[] add : adds) { intervalTree.put(add[0], add[1], "frob"); Assert.assertEquals(intervalTree.remove(46402360, 46402594), "frob"); intervalTree.checkMaxEnds();
/** * 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) {
@Override public int size() { // Note: We should think about caching the size to avoid having to recompute it. int size = 0; for (final IntervalTree<T> tree : mSequenceMap.values()) { size += tree.size(); } return size; } /**
public boolean containsKey(final Interval key) { final IntervalTree<T> tree = mSequenceMap.get(key.getContig()); if (tree == null) { return false; } return (tree.find(key.getStart(), key.getEnd()) != null); }
@Test public void testRemoveMany() { Iterator<IntervalTree.Node<String>> iterator = intervalTree.reverseIterator(); Iterable<IntervalTree.Node<String>> iterable = () -> iterator; for (IntervalTree.Node<String> node : iterable) { intervalTree.removeNode(node); } Assert.assertEquals(intervalTree.size(), 0); }
public T remove(final Interval key) { final IntervalTree<T> tree = mSequenceMap.get(key.getContig()); if (tree == null) { return null; } return tree.remove(key.getStart(), key.getEnd()); }
@Test public void testTotalRevIterator() { int count = 0; Iterator<IntervalTree.Node<String>> iterator = intervalTree.reverseIterator(); Iterable<IntervalTree.Node<String>> iterable = () -> iterator; for (IntervalTree.Node<String> ignored : iterable) { count++; } Assert.assertEquals(count, intervalTree.size()); // foobar1, foobar2, and foobar6 }
/** * Return an iterator over the entire tree that returns intervals in reverse order. * @return An iterator. */ public Iterator<Node<V>> reverseIterator() { return new RevIterator(max()); }
/** * Return an iterator over all intervals greater than or equal to the specified interval. * @param start The interval's start. * @param end The interval's end. * @return An iterator. */ public Iterator<Node<V>> iterator( final int start, final int end ) { return new FwdIterator(min(start,end)); }
@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."); }
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; }
@Override public boolean isEmpty() { for (final IntervalTree<T> tree : mSequenceMap.values()) { if (tree.size() > 0) { return false; } } return true; }