Pull out specific 2D geometry code

geo/src/main/java/org/odk/collect/geo/geopoly/GeoPolyUtils.kt

@@ -2,8 +2,6 @@ package org.odk.collect.geo.geopoly
 
 import org.odk.collect.geo.GeoUtils.parseGeometryPoint
 import org.odk.collect.maps.MapPoint
-import kotlin.math.max
-import kotlin.math.min
 
 object GeoPolyUtils {
 
@@ -21,122 +19,4 @@ object GeoPolyUtils {
 
         return points
     }
-
-    /**
-     * Returns `true` if any segment of the trace intersects with any other and `false` otherwise.
-     */
-    fun intersects(trace: List<MapPoint>): Boolean {
-        return if (trace.size >= 3) {
-            val isClosed = trace.first() == trace.last()
-            val segments = trace.zipWithNext()
-
-            return if (segments.size == 2) {
-                val orientation = orientation(segments[1].second, segments[0].first, segments[0].second)
-                return orientation == Orientation.Collinear && within(segments[1].second, segments[0])
-            } else {
-                segments.filterIndexed { line1Index, line1 ->
-                    segments.filterIndexed { line2Index, line2 ->
-                        if (isClosed && line1Index == 0 && line2Index == segments.size - 1) {
-                            false
-                        } else if (line2Index >= line1Index + 2) {
-                            intersects(line1, line2)
-                        } else {
-                            false
-                        }
-                    }.isNotEmpty()
-                }.isNotEmpty()
-            }
-        } else {
-            false
-        }
-    }
-
-    /**
-     * Check if a point is within the bounding box of a line
-     */
-    fun within(
-        point: MapPoint,
-        line: Pair<MapPoint, MapPoint>
-    ): Boolean {
-        val lineLatMin = min(line.first.latitude, line.second.latitude)
-        val lineLatMax = max(line.first.latitude, line.second.latitude)
-        val lineLongMin = min(line.first.longitude, line.second.longitude)
-        val lineLongMax = max(line.first.longitude, line.second.longitude)
-        val latRange = lineLatMin..lineLatMax
-        val longRange = lineLongMin..lineLongMax
-
-        return point.latitude in latRange && point.longitude in longRange
-    }
-
-    /**
-     * Work out whether two line segments intersect by calculating if the endpoints of one segment
-     * are on opposite sides (or touching of the other segment **and** vice versa. This is
-     * determined by finding the orientation of endpoints relative to the other line.
-     */
-    private fun intersects(
-        aB: Pair<MapPoint, MapPoint>,
-        cD: Pair<MapPoint, MapPoint>
-    ): Boolean {
-        val (a, b) = aB
-        val (c, d) = cD
-
-        val orientationA = orientation(a, c, d)
-        val orientationB = orientation(b, c, d)
-        val orientationC = orientation(a, b, c)
-        val orientationD = orientation(a, b, d)
-
-        return if (orientationA.isOpposing(orientationB) && orientationC.isOpposing(orientationD)) {
-            true
-        } else if (orientationA == Orientation.Collinear && within(a, cD)) {
-            true
-        } else {
-            false
-        }
-    }
-
-    /**
-     * Calculate the "orientation" (or "direction") of three points using the cross product of the
-     * vectors of the pairs of points (see
-     * [here](https://en.wikipedia.org/wiki/Cross_product#Computational_geometry)). This can
-     * either be clockwise, anticlockwise or collinear (the three points form a straight line).
-     *
-     */
-    private fun orientation(a: MapPoint, b: MapPoint, c: MapPoint): Orientation {
-        val ab = Pair(b.latitude - a.latitude, b.longitude - a.longitude)
-        val ac = Pair(c.latitude - a.latitude, c.longitude - a.longitude)
-        val crossProduct = crossProduct(ab, ac)
-
-        return if (crossProduct > 0) {
-            Orientation.AntiClockwise
-        } else if (crossProduct < 0) {
-            Orientation.Clockwise
-        } else {
-            Orientation.Collinear
-        }
-    }
-
-    /**
-     * [https://en.wikipedia.org/wiki/Cross_product](https://en.wikipedia.org/wiki/Cross_product)
-     */
-    private fun crossProduct(x: Pair<Double, Double>, y: Pair<Double, Double>): Double {
-        return (x.first * y.second) - (y.first * x.second)
-    }
-
-    private enum class Orientation {
-        Collinear,
-        Clockwise,
-        AntiClockwise;
-
-        fun isOpposing(other: Orientation): Boolean {
-            return if (this == Collinear) {
-                false
-            } else if (this == Clockwise && other == AntiClockwise) {
-                true
-            } else if (this == AntiClockwise && other == Clockwise) {
-                true
-            } else {
-                false
-            }
-        }
-    }
 }

geo/src/main/java/org/odk/collect/geo/javarosa/IntersectsFunctionHandler.kt

@@ -3,8 +3,10 @@ package org.odk.collect.geo.javarosa
 import org.javarosa.core.model.condition.EvaluationContext
 import org.javarosa.core.model.condition.IFunctionHandler
 import org.javarosa.xpath.XPathTypeMismatchException
-import org.odk.collect.geo.geopoly.GeoPolyUtils.intersects
 import org.odk.collect.geo.geopoly.GeoPolyUtils.parseGeometry
+import org.odk.collect.maps.toPoint
+import org.odk.collect.shared.geometry.Trace
+import org.odk.collect.shared.geometry.intersects
 
 class IntersectsFunctionHandler : IFunctionHandler {
     override fun getName(): String {
@@ -28,8 +30,9 @@ class IntersectsFunctionHandler : IFunctionHandler {
         ec: EvaluationContext
     ): Any {
         try {
-            val trace = parseGeometry(args[0] as String, strict = true)
-            return intersects(trace)
+            val mapPoints = parseGeometry(args[0] as String, strict = true)
+            val trace = Trace(mapPoints.map { it.toPoint() })
+            return trace.intersects()
         } catch (_: IllegalArgumentException) {
             throw XPathTypeMismatchException()
         }

geo/src/test/java/org/odk/collect/geo/geopoly/GeoPolyUtilsTest.kt

@@ -8,132 +8,6 @@ import org.odk.collect.maps.MapPoint
 
 class GeoPolyUtilsTest {
 
-    @Test
-    fun `#intersects returns false for an empty list`() {
-        assertThat(GeoPolyUtils.intersects(emptyList()), equalTo(false))
-    }
-
-    @Test
-    fun `#intersects returns false when there is only one point`() {
-        val trace = listOf(MapPoint(0.0, 0.0))
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(false))
-    }
-
-    @Test
-    fun `#intersects returns false when there is only one segment`() {
-        val trace = listOf(MapPoint(0.0, 0.0), MapPoint(1.0, 0.0))
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(false))
-    }
-
-    @Test
-    fun `#intersects returns false when no segment intersects with another`() {
-        val trace = listOf(
-            MapPoint(0.0, 0.0),
-            MapPoint(1.0, 1.0),
-            MapPoint(2.0, 0.0)
-        )
-
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(false))
-    }
-
-    @Test
-    fun `#intersects returns false when no segment intersects with another in a closed trace`() {
-        val trace = listOf(
-            MapPoint(0.0, 0.0),
-            MapPoint(1.0, 1.0),
-            MapPoint(2.0, 0.0),
-            MapPoint(0.0, 0.0)
-        )
-
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(false))
-    }
-
-    @Test
-    fun `#intersects returns true when a segment intersects with another`() {
-        val trace = listOf(
-            MapPoint(1.0, 1.0),
-            MapPoint(1.0, 3.0),
-            MapPoint(2.0, 3.0),
-            MapPoint(2.0, 2.0),
-            MapPoint(0.0, 2.0)
-        )
-
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(true))
-    }
-
-    @Test
-    fun `#intersects returns true when a segment intersects with another in a closed trace`() {
-        val trace = listOf(
-            MapPoint(1.0, 1.0),
-            MapPoint(1.0, 3.0),
-            MapPoint(2.0, 3.0),
-            MapPoint(2.0, 2.0),
-            MapPoint(0.0, 2.0),
-            MapPoint(1.0, 1.0)
-        )
-
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(true))
-    }
-
-    @Test
-    fun `#intersects returns false when a segment's end points are both on different sides of another, but the segments do not intersect`() {
-        val trace = listOf(
-            MapPoint(1.0, 1.0),
-            MapPoint(1.0, 2.0),
-            MapPoint(3.0, 3.0),
-            MapPoint(0.0, 3.0)
-        )
-
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(false))
-    }
-
-    @Test
-    fun `#intersects returns true when just an endpoint touches another segment`() {
-        val trace = listOf(
-            MapPoint(0.0, 0.0),
-            MapPoint(1.0, 1.0),
-            MapPoint(2.0, 0.0),
-            MapPoint(-1.0, 0.0)
-        )
-
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(true))
-    }
-
-    @Test
-    fun `#intersects returns true when a segment is collinear and within another`() {
-        val trace = listOf(
-            MapPoint(0.0, 0.0),
-            MapPoint(0.0, 1.0),
-            MapPoint(0.0, 0.5)
-        )
-
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(true))
-    }
-
-    @Test
-    fun `#intersects returns true when the trace closes on a non-origin vertex`() {
-        val trace = listOf(
-            MapPoint(0.0, 0.0),
-            MapPoint(0.0, 1.0), // Close back on this point
-            MapPoint(0.0, 2.0),
-            MapPoint(1.0, 2.0),
-            MapPoint(0.0, 1.0)
-        )
-
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(true))
-    }
-
-    @Test
-    fun `#intersects returns false for right angled triangle`() {
-        val trace = listOf(
-            MapPoint(0.0, 0.0),
-            MapPoint(10.0, 10.0),
-            MapPoint(0.0, 10.0)
-        )
-
-        assertThat(GeoPolyUtils.intersects(trace), equalTo(false))
-    }
-
     @Test
     fun parseGeometryTest() {
         assertThat(parseGeometry("1.0 2.0 3 4"), equalTo(listOf(MapPoint(1.0, 2.0, 3.0, 4.0))))

maps/src/main/java/org/odk/collect/maps/MapPoint.kt

@@ -15,6 +15,7 @@ package org.odk.collect.maps
 
 import android.os.Parcelable
 import kotlinx.parcelize.Parcelize
+import org.odk.collect.shared.geometry.Point
 
 @Parcelize
 data class MapPoint @JvmOverloads constructor(
@@ -23,3 +24,7 @@ data class MapPoint @JvmOverloads constructor(
     @JvmField val altitude: Double = 0.0,
     @JvmField val accuracy: Double = 0.0
 ) : Parcelable
+
+fun MapPoint.toPoint(): Point {
+    return Point(latitude, longitude)
+}