Improve polygon serde logic

Sullivan-Patrick · Sullivan-Patrick · commit a7697b447a1e · 2025-11-20T16:01:11.000-08:00
diff --git a/presto-geospatial-toolkit/src/main/java/com/facebook/presto/geospatial/serde/JtsGeometrySerde.java b/presto-geospatial-toolkit/src/main/java/com/facebook/presto/geospatial/serde/JtsGeometrySerde.java
@@ -179,24 +179,37 @@ private static Geometry readPolygon(SliceInput input, boolean multitype)
         try {
             for (int i = 0; i < partCount; i++) {
                 Coordinate[] coordinates = readCoordinates(input, partLengths[i]);
-                if (isClockwise(coordinates)) {
-                    // next polygon has started
-                    if (shell != null) {
+                ClockwiseResult isClockwiseFlag = isClockwise(coordinates);
+                if (multitype) {
+                    if (isClockwiseFlag == ClockwiseResult.ZERO_AREA) {
+                        // When serializing a MultiPolygon, we should throw a user error if
+                        // there is a zero-area ring. This should only get hit due to a bug in
+                        // our serde logic.
+                        //todo: how to distinguish this as internal error?
+                        throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Unexpected zero-area ring in MultiPolygon deserialization.");
+                    }
+
+                    if ((shell != null) && (isClockwiseFlag == ClockwiseResult.CW)) {
+                        // Next polygon has started
                         polygons.add(GEOMETRY_FACTORY.createPolygon(shell, holes.toArray(new LinearRing[0])));
                         holes.clear();
+                        shell = null;
                     }
+                }
+
+                if (shell == null) {
                     shell = GEOMETRY_FACTORY.createLinearRing(coordinates);
                 }
                 else {
                     holes.add(GEOMETRY_FACTORY.createLinearRing(coordinates));
                 }
             }
-            polygons.add(GEOMETRY_FACTORY.createPolygon(shell, holes.toArray(new LinearRing[0])));
         }
         catch (IllegalArgumentException e) {
             throw new TopologyException("Error constructing Polygon: " + e.getMessage());
         }
 
+        polygons.add(GEOMETRY_FACTORY.createPolygon(shell, holes.toArray(new LinearRing[0])));
         if (multitype) {
             return GEOMETRY_FACTORY.createMultiPolygon(polygons.toArray(new Polygon[0]));
         }
@@ -411,7 +424,10 @@ private static void writePolygon(Geometry geometry, SliceOutput output, boolean
         }
 
         Coordinate[] coordinates = geometry.getCoordinates();
-        canonicalizePolygonCoordinates(coordinates, partIndexes, shellPart);
+        boolean zeroAreaRingEncountered = canonicalizePolygonCoordinates(coordinates, partIndexes, shellPart);
+        if (zeroAreaRingEncountered && multitype) {
+            throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Input MultiPolygon contains one or more zero-area rings.");
+        }
         writeCoordinates(coordinates, output);
     }
 
@@ -462,32 +478,44 @@ private static void writeEnvelope(Geometry geometry, SliceOutput output)
         output.writeDouble(envelope.getMaxY());
     }
 
-    private static void canonicalizePolygonCoordinates(Coordinate[] coordinates, int[] partIndexes, boolean[] shellPart)
+    private static boolean canonicalizePolygonCoordinates(Coordinate[] coordinates, int[] partIndexes, boolean[] shellPart)
     {
+        boolean zeroAreaRingEncountered = false;
         for (int part = 0; part < partIndexes.length - 1; part++) {
-            canonicalizePolygonCoordinates(coordinates, partIndexes[part], partIndexes[part + 1], shellPart[part]);
+            zeroAreaRingEncountered |= canonicalizePolygonCoordinates(coordinates, partIndexes[part], partIndexes[part + 1], shellPart[part]);
         }
         if (partIndexes.length > 0) {
-            canonicalizePolygonCoordinates(coordinates, partIndexes[partIndexes.length - 1], coordinates.length, shellPart[partIndexes.length - 1]);
+            zeroAreaRingEncountered |= canonicalizePolygonCoordinates(coordinates, partIndexes[partIndexes.length - 1], coordinates.length, shellPart[partIndexes.length - 1]);
         }
+        return zeroAreaRingEncountered;
     }
 
-    private static void canonicalizePolygonCoordinates(Coordinate[] coordinates, int start, int end, boolean isShell)
+    /**
+     * Ensures that a polygon ring has the canonical orientation:
+     * Exterior rings (shells) must be clockwise.
+     * Interior rings (holes) must be counter-clockwise.
+     * A return value of true indicates a zero-area ring was encountered
+     */
+    private static boolean canonicalizePolygonCoordinates(Coordinate[] coordinates, int start, int end, boolean isShell)
     {
-        boolean isClockwise = isClockwise(coordinates, start, end);
+        ClockwiseResult clockwiseResult = isClockwise(coordinates, start, end);
+        if (clockwiseResult == ClockwiseResult.ZERO_AREA) {
+            return true;
+        }
 
-        if ((isShell && !isClockwise) || (!isShell && isClockwise)) {
+        if ((isShell && clockwiseResult == ClockwiseResult.CCW) || (!isShell && clockwiseResult == ClockwiseResult.CW)) {
             // shell has to be counter clockwise
             reverse(coordinates, start, end);
         }
+        return false;
     }
 
-    private static boolean isClockwise(Coordinate[] coordinates)
+    private static ClockwiseResult isClockwise(Coordinate[] coordinates)
     {
         return isClockwise(coordinates, 0, coordinates.length);
     }
 
-    private static boolean isClockwise(Coordinate[] coordinates, int start, int end)
+    private static ClockwiseResult isClockwise(Coordinate[] coordinates, int start, int end)
     {
         // Sum over the edges: (x2 − x1) * (y2 + y1).
         // If the result is positive the curve is clockwise,
@@ -497,7 +525,10 @@ private static boolean isClockwise(Coordinate[] coordinates, int start, int end)
             area += (coordinates[i].x - coordinates[i - 1].x) * (coordinates[i].y + coordinates[i - 1].y);
         }
         area += (coordinates[start].x - coordinates[end - 1].x) * (coordinates[start].y + coordinates[end - 1].y);
-        return area > 0;
+        if (area == 0.0) {
+            return ClockwiseResult.ZERO_AREA;
+        }
+        return area > 0.0 ? ClockwiseResult.CW : ClockwiseResult.CCW;
     }
 
     private static void reverse(Coordinate[] coordinates, int start, int end)
@@ -510,6 +541,13 @@ private static void reverse(Coordinate[] coordinates, int start, int end)
         }
     }
 
+    enum ClockwiseResult
+    {
+        CW,
+        CCW,
+        ZERO_AREA
+    }
+
     /**
      * Shape type codes from ERSI's specification
      * https://www.esri.com/library/whitepapers/pdfs/shapefile.pdf
diff --git a/presto-main-base/src/test/java/com/facebook/presto/geospatial/TestGeoFunctions.java b/presto-main-base/src/test/java/com/facebook/presto/geospatial/TestGeoFunctions.java
@@ -454,7 +454,7 @@ public void testGeometryInvalidReason()
         // invalid geometries
         assertInvalidReason("MULTIPOINT ((0 0), (0 1), (1 1), (0 1))", "[MultiPoint] Repeated point: (0.0 1.0)");
         assertInvalidReason("LINESTRING (0 0, -1 0.5, 0 1, 1 1, 1 0, 0 1, 0 0)", "[LineString] Self-intersection at or near: (0.0 1.0)");
-        assertInvalidReason("POLYGON ((0 0, 1 1, 0 1, 1 0, 0 0))", "Error constructing Polygon: shell is empty but holes are not");
+        assertInvalidReason("POLYGON ((0 0, 1 1, 0 1, 1 0, 0 0))", "Self-intersection");
         assertInvalidReason("POLYGON ((0 0, 0 1, 0 1, 1 1, 1 0, 0 0), (2 2, 2 3, 3 3, 3 2, 2 2))", "Hole lies outside shell");
         assertInvalidReason("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0), (2 2, 2 3, 3 3, 3 2, 2 2))", "Hole lies outside shell");
         assertInvalidReason("POLYGON ((0 0, 0 1, 2 1, 1 1, 1 0, 0 0))", "Ring Self-intersection");
@@ -1372,6 +1372,124 @@ private void assertInvalidGeometryJson(String json)
         assertInvalidFunction("geometry_from_geojson('" + json + "')", "Invalid GeoJSON:.*");
     }
 
+    @Test
+    public void testDegeneratePolygons()
+    {
+        // Single polygon with CCW orientation - should orient to CW
+        testDegeneratePolygonsFunc(
+                "POLYGON ((1 2, 3 4, 5 7, 1 2))",
+                "POLYGON ((1 2, 5 7, 3 4, 1 2))");
+
+        // Single polygons with no area- should not reverse these
+        testDegeneratePolygonsFunc(
+                "POLYGON ((1 2, 5 6, 3 4, 1 2))", "POLYGON ((1 2, 5 6, 3 4, 1 2))");
+        testDegeneratePolygonsFunc(
+                "POLYGON ((1 2, 3 4, 5 6, 1 2))", "POLYGON ((1 2, 3 4, 5 6, 1 2))");
+
+        // Single polygons with interior rings- should canonicalize so any shells have
+        // CW orientation and holes have CCW orientation.
+        testDegeneratePolygonsFunc(
+                "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3))",
+                "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3))");
+        testDegeneratePolygonsFunc(
+                "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3))",
+                "POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3))");
+
+        // Multipolygons where polygons after the first are CCW for shell or CW for
+        // hole. These should be correctly oriented after serde.
+
+        // First polygon has CW shell and CCW hole, second polygon has CCW
+        // shell and CCW hole -> second polygon shell should be reoriented
+        testDegeneratePolygonsFunc(
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+        // First polygon has CW shell and CW hole, second polygon has CCW
+        // shell and CCW hole -> first polygon hole and second polygon shell should be
+        // reoriented
+        testDegeneratePolygonsFunc(
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+        // First polygon has CCW shell and CW hole, second polygon has CCW
+        // shell and CW hole -> both polygons should have shell and hole reoriented
+        testDegeneratePolygonsFunc(
+                "MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 6 14, 14 14, 14 6, 6 6)))",
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+        // First polygon has CCW shell and CCW hole, second polygon has CCW
+        // shell and CCW hole -> both polygons should have shells reoriented
+        testDegeneratePolygonsFunc(
+                "MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 20 0, 20 20, 0 20, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))",
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+        // First polygon has CW shell and CW hole, second polygon has CW
+        // shell and CW hole -> both polygons should have holes reoriented
+        testDegeneratePolygonsFunc(
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 3 7, 7 7, 7 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 6 14, 14 14, 14 6, 6 6)))",
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+
+        // MultiPolygons with zero-area rings. These need to fail because our
+        // serialization format holds MultiPolygons as single vectors that rely on
+        // orientation for determining shell start points.
+
+        // Second polygon is zero area
+        testDegeneratePolygonsFuncInvalid("MULTIPOLYGON (((1 1, 2 1, 2 2, 1 1)), ((1 1, 2 2, 3 3, 2 2, 1 1)))");
+
+        // Single polygon with zero area
+        testDegeneratePolygonsFuncInvalid(
+                        "MULTIPOLYGON (((5 10, 25 30, 15 20, 5 10)))");
+        testDegeneratePolygonsFuncInvalid(
+                "MULTIPOLYGON (((1 1, 1 2, 1 3, 1 1)))");
+
+        // First polygon has CW shell and CCW hole, second polygon has CW shell and
+        // zero-area hole
+        testDegeneratePolygonsFuncInvalid(
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 6 6)))");
+
+        // First polygon has CW shell and CCW hole, second polygon has zero-area shell
+        // and CCW hole
+        testDegeneratePolygonsFuncInvalid(
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 0 10, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+        // First polygon has CW shell and CCW hole, second polygon has CW shell
+        // and zero-area hole
+        testDegeneratePolygonsFuncInvalid(
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 9 9, 14 14, 9 9, 6 6)))");
+
+
+        // First polygon has CW shell and CCW hole, second polygon has zero-area shell
+        // and zero-area hole
+        testDegeneratePolygonsFuncInvalid(
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 0 10, 0 0), (6 6, 9 9, 14 14, 6 6)))");
+
+        // First polygon has zero-area shell and CCW hole, second polygon has CW shell
+        // and CCW hole
+        testDegeneratePolygonsFuncInvalid(
+                "MULTIPOLYGON (((0 0, 0 10, 0 15, 0 0), (3 3, 7 3, 7 7, 3 7, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6))))");
+
+        // First polygon has CW shell and zero-area hole, second polygon has CW shell
+        // and CCW hole
+        testDegeneratePolygonsFuncInvalid(
+                "MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+
+        // First polygon has zero-area shell and zero-area hole, second polygon has CW
+        // shell and CCW hole
+        testDegeneratePolygonsFuncInvalid(
+                "MULTIPOLYGON (((0 0, 0 10, 0 5, 0 10, 0 0), (3 3, 7 3, 9 3, 3 3)), ((0 0, 0 20, 20 20, 20 0, 0 0), (6 6, 14 6, 14 14, 6 14, 6 6)))");
+    }
+
+    private void testDegeneratePolygonsFunc(String wkt, String expected)
+    {
+        assertFunction(format("ST_ASText(ST_GeometryFromText('%s'))", wkt), VARCHAR, expected);
+    }
+
+    private void testDegeneratePolygonsFuncInvalid(String wkt)
+    {
+        assertInvalidFunction(format("ST_ASText(ST_GeometryFromText('%s'))", wkt), "Input MultiPolygon contains one or more zero-area rings.");
+    }
+
     @Test
     public void testGooglePolylineDecode()
     {

Original file line number	Diff line number	Diff line change
`@@ -179,24 +179,37 @@ private static Geometry readPolygon(SliceInput input, boolean multitype)`
`179`	`179`	`try {`
`180`	`180`	`for (int i = 0; i < partCount; i++) {`
`181`	`181`	`Coordinate[] coordinates = readCoordinates(input, partLengths[i]);`
`182`		`- if (isClockwise(coordinates)) {`
`183`		`- // next polygon has started`
`184`		`- if (shell != null) {`
	`182`	`+ ClockwiseResult isClockwiseFlag = isClockwise(coordinates);`
	`183`	`+ if (multitype) {`
	`184`	`+ if (isClockwiseFlag == ClockwiseResult.ZERO_AREA) {`
	`185`	`+ // When serializing a MultiPolygon, we should throw a user error if`
	`186`	`+ // there is a zero-area ring. This should only get hit due to a bug in`
	`187`	`+ // our serde logic.`
	`188`	`+ //todo: how to distinguish this as internal error?`
	`189`	`+ throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Unexpected zero-area ring in MultiPolygon deserialization.");`
	`190`	`+ }`
	`191`	`+`
	`192`	`+ if ((shell != null) && (isClockwiseFlag == ClockwiseResult.CW)) {`
	`193`	`+ // Next polygon has started`
`185`	`194`	`polygons.add(GEOMETRY_FACTORY.createPolygon(shell, holes.toArray(new LinearRing[0])));`
`186`	`195`	`holes.clear();`
	`196`	`+ shell = null;`
`187`	`197`	`}`
	`198`	`+ }`
	`199`	`+`
	`200`	`+ if (shell == null) {`
`188`	`201`	`shell = GEOMETRY_FACTORY.createLinearRing(coordinates);`
`189`	`202`	`}`
`190`	`203`	`else {`
`191`	`204`	`holes.add(GEOMETRY_FACTORY.createLinearRing(coordinates));`
`192`	`205`	`}`
`193`	`206`	`}`
`194`		`- polygons.add(GEOMETRY_FACTORY.createPolygon(shell, holes.toArray(new LinearRing[0])));`
`195`	`207`	`}`
`196`	`208`	`catch (IllegalArgumentException e) {`
`197`	`209`	`throw new TopologyException("Error constructing Polygon: " + e.getMessage());`
`198`	`210`	`}`
`199`	`211`
	`212`	`+ polygons.add(GEOMETRY_FACTORY.createPolygon(shell, holes.toArray(new LinearRing[0])));`
`200`	`213`	`if (multitype) {`
`201`	`214`	`return GEOMETRY_FACTORY.createMultiPolygon(polygons.toArray(new Polygon[0]));`
`202`	`215`	`}`
`@@ -411,7 +424,10 @@ private static void writePolygon(Geometry geometry, SliceOutput output, boolean`
`411`	`424`	`}`
`412`	`425`
`413`	`426`	`Coordinate[] coordinates = geometry.getCoordinates();`
`414`		`- canonicalizePolygonCoordinates(coordinates, partIndexes, shellPart);`
	`427`	`+ boolean zeroAreaRingEncountered = canonicalizePolygonCoordinates(coordinates, partIndexes, shellPart);`
	`428`	`+ if (zeroAreaRingEncountered && multitype) {`
	`429`	`+ throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "Input MultiPolygon contains one or more zero-area rings.");`
	`430`	`+ }`
`415`	`431`	`writeCoordinates(coordinates, output);`
`416`	`432`	`}`
`417`	`433`
`@@ -462,32 +478,44 @@ private static void writeEnvelope(Geometry geometry, SliceOutput output)`
`462`	`478`	`output.writeDouble(envelope.getMaxY());`
`463`	`479`	`}`
`464`	`480`
`465`		`- private static void canonicalizePolygonCoordinates(Coordinate[] coordinates, int[] partIndexes, boolean[] shellPart)`
	`481`	`+ private static boolean canonicalizePolygonCoordinates(Coordinate[] coordinates, int[] partIndexes, boolean[] shellPart)`
`466`	`482`	`{`
	`483`	`+ boolean zeroAreaRingEncountered = false;`
`467`	`484`	`for (int part = 0; part < partIndexes.length - 1; part++) {`
`468`		`- canonicalizePolygonCoordinates(coordinates, partIndexes[part], partIndexes[part + 1], shellPart[part]);`
	`485`	`+ zeroAreaRingEncountered \|= canonicalizePolygonCoordinates(coordinates, partIndexes[part], partIndexes[part + 1], shellPart[part]);`
`469`	`486`	`}`
`470`	`487`	`if (partIndexes.length > 0) {`
`471`		`- canonicalizePolygonCoordinates(coordinates, partIndexes[partIndexes.length - 1], coordinates.length, shellPart[partIndexes.length - 1]);`
	`488`	`+ zeroAreaRingEncountered \|= canonicalizePolygonCoordinates(coordinates, partIndexes[partIndexes.length - 1], coordinates.length, shellPart[partIndexes.length - 1]);`
`472`	`489`	`}`
	`490`	`+ return zeroAreaRingEncountered;`
`473`	`491`	`}`
`474`	`492`
`475`		`- private static void canonicalizePolygonCoordinates(Coordinate[] coordinates, int start, int end, boolean isShell)`
	`493`	`+ /**`
	`494`	`+ * Ensures that a polygon ring has the canonical orientation:`
	`495`	`+ * Exterior rings (shells) must be clockwise.`
	`496`	`+ * Interior rings (holes) must be counter-clockwise.`
	`497`	`+ * A return value of true indicates a zero-area ring was encountered`
	`498`	`+ */`
	`499`	`+ private static boolean canonicalizePolygonCoordinates(Coordinate[] coordinates, int start, int end, boolean isShell)`
`476`	`500`	`{`
`477`		`- boolean isClockwise = isClockwise(coordinates, start, end);`
	`501`	`+ ClockwiseResult clockwiseResult = isClockwise(coordinates, start, end);`
	`502`	`+ if (clockwiseResult == ClockwiseResult.ZERO_AREA) {`
	`503`	`+ return true;`
	`504`	`+ }`
`478`	`505`
`479`		`- if ((isShell && !isClockwise) \|\| (!isShell && isClockwise)) {`
	`506`	`+ if ((isShell && clockwiseResult == ClockwiseResult.CCW) \|\| (!isShell && clockwiseResult == ClockwiseResult.CW)) {`
`480`	`507`	`// shell has to be counter clockwise`
`481`	`508`	`reverse(coordinates, start, end);`
`482`	`509`	`}`
	`510`	`+ return false;`
`483`	`511`	`}`
`484`	`512`
`485`		`- private static boolean isClockwise(Coordinate[] coordinates)`
	`513`	`+ private static ClockwiseResult isClockwise(Coordinate[] coordinates)`
`486`	`514`	`{`
`487`	`515`	`return isClockwise(coordinates, 0, coordinates.length);`
`488`	`516`	`}`
`489`	`517`
`490`		`- private static boolean isClockwise(Coordinate[] coordinates, int start, int end)`
	`518`	`+ private static ClockwiseResult isClockwise(Coordinate[] coordinates, int start, int end)`
`491`	`519`	`{`
`492`	`520`	`// Sum over the edges: (x2 − x1) * (y2 + y1).`
`493`	`521`	`// If the result is positive the curve is clockwise,`
`@@ -497,7 +525,10 @@ private static boolean isClockwise(Coordinate[] coordinates, int start, int end)`
`497`	`525`	`area += (coordinates[i].x - coordinates[i - 1].x) * (coordinates[i].y + coordinates[i - 1].y);`
`498`	`526`	`}`
`499`	`527`	`area += (coordinates[start].x - coordinates[end - 1].x) * (coordinates[start].y + coordinates[end - 1].y);`
`500`		`- return area > 0;`
	`528`	`+ if (area == 0.0) {`
	`529`	`+ return ClockwiseResult.ZERO_AREA;`
	`530`	`+ }`
	`531`	`+ return area > 0.0 ? ClockwiseResult.CW : ClockwiseResult.CCW;`
`501`	`532`	`}`
`502`	`533`
`503`	`534`	`private static void reverse(Coordinate[] coordinates, int start, int end)`
`@@ -510,6 +541,13 @@ private static void reverse(Coordinate[] coordinates, int start, int end)`
`510`	`541`	`}`
`511`	`542`	`}`
`512`	`543`
	`544`	`+ enum ClockwiseResult`
	`545`	`+ {`
	`546`	`+ CW,`
	`547`	`+ CCW,`
	`548`	`+ ZERO_AREA`
	`549`	`+ }`
	`550`	`+`
`513`	`551`	`/**`
`514`	`552`	`* Shape type codes from ERSI's specification`
`515`	`553`	`* https://www.esri.com/library/whitepapers/pdfs/shapefile.pdf`