public String toString() { return getSequence() + ":" + start + "-" + end; }
/** Returns true if this interval overlaps the other interval, otherwise false. */ public boolean abuts(final Interval other) { return this.getSequence().equals(other.getSequence()) && (this.start == other.end + 1 || other.start == this.end + 1); }
/** Returns true if this interval overlaps the other interval, otherwise false. */ public boolean intersects(final Interval other) { return (this.getSequence().equals(other.getSequence()) && CoordMath.overlaps(this.start, this.end, other.start, other.end)); }
private void advanceInterval() { if (intervals.hasNext()) { currentInterval = intervals.next(); currentSequenceIndex = samHeader.getSequenceIndex(currentInterval.getSequence()); } else { currentInterval = null; } }
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); }
/** Return true if the sequence/position lie in the provided interval. */ public static boolean contains(final Interval interval, final String sequenceName, final long position) { return interval.getSequence().equals(sequenceName) && (position >= interval.getStart() && position <= interval.getEnd()); }
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 boolean containsKey(final Interval key) { final IntervalTree<T> tree = mSequenceMap.get(key.getSequence()); if (tree == null) { return false; } return (tree.find(key.getStart(), key.getEnd()) != null); }
public T remove(final Interval key) { final IntervalTree<T> tree = mSequenceMap.get(key.getSequence()); if (tree == null) { return null; } return tree.remove(key.getStart(), key.getEnd()); }
/** Gets the collection of objects that overlap the provided mapping. */ public Collection<T> getOverlaps(Interval rhs) { Collection<T> matches = new ArrayList<T>(); Object seqId = rhs.getSequence(); IntervalTree<Set<T>> tree = this.cache.get(seqId); int start = rhs.getStart() + this.rhsBuffer; int end = rhs.getEnd() - this.rhsBuffer; if (tree != null && start <= end) { Iterator<IntervalTree.Node<Set<T>>> it = tree.overlappers(start, end); while (it.hasNext()) { IntervalTree.Node<Set<T>> node = it.next(); matches.addAll(node.getValue()); } } return matches; } }
/** Merges a sorted collection of intervals and optionally concatenates unique names or takes the first name. */ static Interval merge(final SortedSet<Interval> intervals, final boolean concatenateNames) { final String chrom = intervals.first().getSequence(); int start = intervals.first().getStart(); int end = intervals.last().getEnd(); final boolean neg = intervals.first().isNegativeStrand(); final LinkedHashSet<String> names = new LinkedHashSet<String>(); final String name; for (final Interval i : intervals) { if (i.getName() != null) names.add(i.getName()); start = Math.min(start, i.getStart()); end = Math.max(end, i.getEnd()); } if (concatenateNames) { name = StringUtil.join("|", names); } else { name = names.iterator().next(); } return new Interval(chrom, start, end, neg, name); }
public T get(final Interval key) { final IntervalTree<T> tree = mSequenceMap.get(key.getSequence()); if (tree == null) { return null; } final IntervalTree.Node<T> node = tree.find(key.getStart(), key.getEnd()); if (node == null) { return null; } return node.getValue(); }
/** 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); } } }
/** * Throws RuntimeException if the given intervals are not locus ordered and non-overlapping * @param intervals * @param sequenceDictionary used to determine order of sequences */ public static void assertOrderedNonOverlapping(final Iterator<Interval> intervals, final SAMSequenceDictionary sequenceDictionary) { if (!intervals.hasNext()) { return; } Interval prevInterval = intervals.next(); int prevSequenceIndex = sequenceDictionary.getSequenceIndex(prevInterval.getSequence()); while (intervals.hasNext()) { final Interval interval = intervals.next(); if (prevInterval.intersects(interval)) { throw new SAMException("Intervals should not overlap: " + prevInterval + "; " + interval); } final int thisSequenceIndex = sequenceDictionary.getSequenceIndex(interval.getSequence()); if (prevSequenceIndex > thisSequenceIndex || (prevSequenceIndex == thisSequenceIndex && prevInterval.compareTo(interval) >= 0)) { throw new SAMException("Intervals not in order: " + prevInterval + "; " + interval); } prevInterval = interval; prevSequenceIndex = thisSequenceIndex; } } }
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; }
public IntervalListReferenceSequenceMask(final IntervalList intervalList) { this.header = intervalList.getHeader(); if (intervalList.getHeader().getSortOrder() != SAMFileHeader.SortOrder.coordinate) { intervalList.sort(); } final List<Interval> uniqueIntervals = intervalList.getUniqueIntervals(); if (uniqueIntervals.isEmpty()) { lastSequenceIndex = -1; lastPosition = 0; } else { final Interval lastInterval = uniqueIntervals.get(uniqueIntervals.size() - 1); lastSequenceIndex = header.getSequenceIndex((lastInterval.getSequence())); lastPosition = lastInterval.getEnd(); } intervalIterator = new PeekableIterator<Interval>(uniqueIntervals.iterator()); }
/** * Test if this contains an object that is contained by 'key' * @param key the interval * @return true if it contains an object is contained by 'key' */ public boolean containsContained(final Interval key) { final IntervalTree<T> tree = mSequenceMap.get(key.getSequence()); 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 void ensureSequenceLoaded(final int sequenceIndex) { if (sequenceIndex < this.currentSequenceIndex) { throw new IllegalArgumentException("Cannot look at an earlier sequence. Current: " + this.currentSequenceIndex + "; requested: " + sequenceIndex); } if (sequenceIndex > currentSequenceIndex) { currentBitSet.clear(); while (intervalIterator.hasNext()) { final Interval interval = intervalIterator.peek(); final int nextSequenceIndex = header.getSequenceIndex(interval.getSequence()); if (nextSequenceIndex < sequenceIndex) { intervalIterator.next(); } else if (nextSequenceIndex == sequenceIndex) { currentBitSet.set(interval.getStart(), interval.getEnd() + 1); intervalIterator.next(); } else { break; } } currentSequenceIndex = sequenceIndex; } }
public int compare(final Interval lhs, final Interval rhs) { final int lhsIndex = this.header.getSequenceIndex(lhs.getSequence()); final int rhsIndex = this.header.getSequenceIndex(rhs.getSequence()); int retval = lhsIndex - rhsIndex; if (retval == 0) retval = lhs.getStart() - rhs.getStart(); if (retval == 0) retval = lhs.getEnd() - rhs.getEnd(); if (retval == 0) { if (lhs.isPositiveStrand() && rhs.isNegativeStrand()) retval = -1; else if (lhs.isNegativeStrand() && rhs.isPositiveStrand()) retval = 1; } if (retval == 0) { if (lhs.getName() == null) { if (rhs.getName() == null) return 0; else return -1; } else if (rhs.getName() == null) { return 1; } else { return lhs.getName().compareTo(rhs.getName()); } } return retval; } }