public static <T, E extends Comparable<E>> List<T> getNonOverlapping( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc) { List<T> nonOverlapping = new ArrayList<>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<>(); for (T item:items) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonOverlapping(i); if (addOk) { nonOverlapping.add(item); } } return nonOverlapping; }
public static <T, E extends Comparable<E>> List<T> getNonNested( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, Comparator<? super T> compareFunc) { List<T> sorted = new ArrayList<>(items); Collections.sort(sorted, compareFunc); List<T> res = new ArrayList<>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<>(); for (T item:sorted) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonNested(i); if (addOk) { res.add(item); } else { // log.info("Discarding " + item); } } return res; }
public static <T, E extends Comparable<E>> List<T> getNonOverlapping( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc) { List<T> nonOverlapping = new ArrayList<>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<>(); for (T item:items) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonOverlapping(i); if (addOk) { nonOverlapping.add(item); } } return nonOverlapping; }
public static <T, E extends Comparable<E>> List<T> getNonOverlapping( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc) { List<T> nonOverlapping = new ArrayList<>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<>(); for (T item:items) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonOverlapping(i); if (addOk) { nonOverlapping.add(item); } } return nonOverlapping; }
public static <T, E extends Comparable<E>> List<T> getNonNested( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, Comparator<? super T> compareFunc) { List<T> sorted = new ArrayList<>(items); Collections.sort(sorted, compareFunc); List<T> res = new ArrayList<>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<>(); for (T item:sorted) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonNested(i); if (addOk) { res.add(item); } else { // log.info("Discarding " + item); } } return res; }
public static <T, E extends Comparable<E>> List<T> getNonNested( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, Comparator<? super T> compareFunc) { List<T> sorted = new ArrayList<>(items); Collections.sort(sorted, compareFunc); List<T> res = new ArrayList<>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<>(); for (T item:sorted) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonNested(i); if (addOk) { res.add(item); } else { // log.info("Discarding " + item); } } return res; }
public static <T, E extends Comparable<E>> List<T> getNonOverlapping( List<? extends T> items, Function<T,Interval<E>> toIntervalFunc) { List<T> nonOverlapping = new ArrayList<T>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<E, Interval<E>>(); for (T item:items) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonOverlapping(i); if (addOk) { nonOverlapping.add(item); } } return nonOverlapping; }
public static <T, E extends Comparable<E>> List<T> getNonOverlapping( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc) { List<T> nonOverlapping = new ArrayList<T>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<E, Interval<E>>(); for (T item:items) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonOverlapping(i); if (addOk) { nonOverlapping.add(item); } } return nonOverlapping; }
public static <T, E extends Comparable<E>> List<T> getNonOverlapping( List<? extends T> items, Function<T,Interval<E>> toIntervalFunc, Comparator<T> compareFunc) { List<T> sorted = new ArrayList<T>(items); Collections.sort(sorted, compareFunc); List<T> nonOverlapping = new ArrayList<T>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<E, Interval<E>>(); for (T item:sorted) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonOverlapping(i); if (addOk) { nonOverlapping.add(item); } else { // System.err.println("Discarding " + item); } } return nonOverlapping; }
public static <T, E extends Comparable<E>> List<T> getNonNested( List<? extends T> items, Function<? super T,Interval<E>> toIntervalFunc, Comparator<? super T> compareFunc) { List<T> sorted = new ArrayList<T>(items); Collections.sort(sorted, compareFunc); List<T> res = new ArrayList<T>(); IntervalTree<E,Interval<E>> intervals = new IntervalTree<E, Interval<E>>(); for (T item:sorted) { Interval<E> i = toIntervalFunc.apply(item); boolean addOk = intervals.addNonNested(i); if (addOk) { res.add(item); } else { // System.err.println("Discarding " + item); } } return res; }
public void add(T target) { if (target == null) return; if (value == null) { this.value = target; this.maxEnd = target.getInterval().getEnd(); this.size = 1; } else { this.maxEnd = Interval.max(maxEnd, target.getInterval().getEnd()); this.size++; if (target.getInterval().getBegin().compareTo(value.getInterval().getBegin()) <= 0) { // Should go on left if (left == null) { left = new IntervalTree<E,T>(); } left.add(target); } else { // Should go on right if (right == null) { right = new IntervalTree<E,T>(); } right.add(target); } } }