introduced connected intervals

Author: Torsten-Mumme

src/main/java/net/itarray/automotion/internal/geometry/ConnectedIntervals.java

@@ -0,0 +1,45 @@
+package net.itarray.automotion.internal.geometry;
+
+import com.google.common.collect.Lists;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import static java.lang.String.format;
+
+public class ConnectedIntervals {
+    private final List<Interval> components;
+
+    public ConnectedIntervals(List<Interval> intervals) {
+        this.components = Lists.newArrayList();
+        ArrayList<Interval> sorted = new ArrayList<>(intervals);
+        Comparator<Interval> comparator = Interval.comparator();
+        Collections.sort(sorted, comparator);
+        int i = 0;
+        while (i < sorted.size()) {
+            Interval interval = sorted.get(i);
+            i++;
+            while (i < sorted.size() && !interval.intersect(sorted.get(i)).isEmpty()) {
+                interval = interval.span(sorted.get(i));
+                i++;
+            }
+            components.add(interval);
+        }
+    }
+
+    public int size() {
+        return components.size();
+    }
+
+    public int indexOf(Interval interval) {
+        for (int i = 0; i < components.size(); i++) {
+            Interval component = components.get(i);
+            if (!component.intersect(interval).isEmpty()) {
+                return i;
+            }
+        }
+        throw new RuntimeException(format("interval %s is not in connected intervals", interval));
+    }
+}

src/main/java/net/itarray/automotion/internal/geometry/Interval.java

@@ -1,5 +1,8 @@
 package net.itarray.automotion.internal.geometry;
 
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Comparator;
 import java.util.Objects;
 
 import static net.itarray.automotion.internal.geometry.Scalar.scalar;
@@ -43,6 +46,15 @@ private static String format(String begin, String end) {
 
     public abstract Interval spanWithNonEmpty(NonEmpty interval);
 
+    public static Comparator<Interval> comparator() {
+        return new Comparator<Interval>() {
+            @Override
+            public int compare(Interval o1, Interval o2) {
+                return ((NonEmpty)o1).compareTo((NonEmpty)o2);
+            }
+        };
+    }
+
     private static class Empty extends Interval {
         private Empty() {
         }
@@ -85,7 +97,7 @@ public Interval spanWithNonEmpty(NonEmpty interval) {
         }
     }
 
-    private static class NonEmpty extends Interval {
+    private static class NonEmpty extends Interval implements Comparable<NonEmpty> {
         private final Scalar begin;
         private final Scalar end;
 
@@ -140,5 +152,14 @@ public Interval spanWithNonEmpty(NonEmpty interval) {
                     begin.min(interval.begin),
                     end.max(interval.end));
         }
+
+        @Override
+        public int compareTo(NonEmpty other) {
+            int c = begin.compareTo(other.begin);
+            if (c != 0) {
+                return c;
+            }
+            return end.compareTo(other.end);
+        }
     }
 }

src/test/java/net/itarray/automotion/tests/geometry/DisjointIntervalsTest.java

@@ -1,8 +1,11 @@
 package net.itarray.automotion.tests.geometry;
 
+import net.itarray.automotion.internal.geometry.ConnectedIntervals;
 import net.itarray.automotion.internal.geometry.Interval;
 import org.junit.Test;
 
+import java.util.List;
+
 import static net.itarray.automotion.internal.geometry.Interval.interval;
 import static org.assertj.core.api.Assertions.assertThat;
 
@@ -27,4 +30,13 @@ public void haveSpanFromSmallestBeginToLargestEnd() {
         assertThat(right().span(left())).isEqualTo(span);
         assertThat(left().span(right())).isEqualTo(span);
     }
+
+    @Test
+    public void areNotConnected() {
+        assertComponentIndex(leftAndRight(), left(), 0);
+        assertComponentIndex(leftAndRight(), right(), 1);
+        assertComponentIndex(rightAndLeft(), left(), 0);
+        assertComponentIndex(rightAndLeft(), right(), 1);
+    }
+
 }

src/test/java/net/itarray/automotion/tests/geometry/OverlappingIntervalsTest.java

@@ -26,4 +26,14 @@ public void haveSpanFromSmallestBeginToLargestEnd() {
         assertThat(right().span(left())).isEqualTo(span);
         assertThat(left().span(right())).isEqualTo(span);
     }
+
+
+    @Test
+    public void areNotConnected() {
+        assertComponentIndex(leftAndRight(), left(), 0);
+        assertComponentIndex(leftAndRight(), right(), 0);
+        assertComponentIndex(rightAndLeft(), left(), 0);
+        assertComponentIndex(rightAndLeft(), right(), 0);
+    }
+
 }

src/test/java/net/itarray/automotion/tests/geometry/TwoIntervalsTest.java

@@ -1,9 +1,13 @@
 package net.itarray.automotion.tests.geometry;
 
+import com.google.common.collect.Lists;
+import net.itarray.automotion.internal.geometry.ConnectedIntervals;
 import net.itarray.automotion.internal.geometry.Interval;
 import net.itarray.automotion.internal.geometry.Scalar;
 import org.junit.Test;
 
+import java.util.List;
+
 import static org.assertj.core.api.Assertions.assertThat;
 
 public abstract class TwoIntervalsTest {
@@ -12,6 +16,14 @@ public abstract class TwoIntervalsTest {
 
     public abstract Interval right();
 
+    public List<Interval> leftAndRight() {
+        return Lists.newArrayList(left(), right());
+    }
+
+    public List<Interval> rightAndLeft() {
+        return Lists.newArrayList(right(), left());
+    }
+
     @Test
     public void intersectIsSymmetric() {
         assertThat(left().intersect(right())).isEqualTo(right().intersect(left()));
@@ -21,4 +33,11 @@ public void intersectIsSymmetric() {
     public void spanIsSymmetric() {
         assertThat(left().span(right())).isEqualTo(right().span(left()));
     }
+
+    protected void assertComponentIndex(List<Interval> intervals, Interval interval, int expected) {
+        ConnectedIntervals connectedIntervals = new ConnectedIntervals(intervals);
+        int leftIndex = connectedIntervals.indexOf(interval);
+        assertThat(leftIndex).isEqualTo(expected);
+    }
+
 }