Changes from Review

stefannikolei · stefannikolei · commit 1766c4ba2c8e · 2025-07-06T08:40:18.000+02:00
* some cosmetic changes
* Added Aggressive Inlining and removed the need for func (lessIf)
diff --git a/src/PolygonClipper/PolygonClipper.cs b/src/PolygonClipper/PolygonClipper.cs
@@ -140,11 +140,6 @@ public Polygon Run()
         for (int i = 0; i < clipping.ContourCount; i++)
         {
             Contour contour = clipping[i];
-            bool exterior = operation != BooleanOperation.Difference;
-            if (exterior)
-            {
-                contourId++;
-            }
 
             for (int j = 0; j < contour.VertexCount - 1; j++)
             {
@@ -696,7 +691,6 @@ private static void DivideSegment(
         // Prevent from corner case 1
         if (p.X == le.Point.X && p.Y < le.Point.Y)
         {
-            // TODO: enabling this line makes a single test issue76.geojson fail.
             // The files are different in the two reference repositories but both fail.
             p = new Vertex(p.X.NextAfter(double.PositiveInfinity), p.Y);
         }
@@ -1029,7 +1023,7 @@ private static int NextPos(
             {
                 // Entire group is already processed?
                 found = false;
-                return Int32.MinValue;
+                return int.MinValue;
             }
 
             if (!processed[pos])
diff --git a/src/PolygonClipper/SegmentComparer.cs b/src/PolygonClipper/SegmentComparer.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 
 namespace PolygonClipper;
 
@@ -34,19 +35,19 @@ public int Compare(SweepEvent? x, SweepEvent? y)
         }
 
         SweepEvent perhapsInversedX, perhapsInversedY;
-        Func<bool, int> lessIf;
+        bool inversed = false;
 
         if (x.IsBefore(y))
         {
             perhapsInversedX = x;
             perhapsInversedY = y;
-            lessIf = LessIf;
+            inversed = false;
         }
         else
         {
             perhapsInversedX = y;
             perhapsInversedY = x;
-            lessIf = LessIfInversed;
+            inversed = true;
         }
 
         // Check if the segments are collinear by comparing their signed areas
@@ -59,26 +60,26 @@ public int Compare(SweepEvent? x, SweepEvent? y)
             // If they share their left endpoint, use the right endpoint to sort
             if (perhapsInversedX.Point == perhapsInversedY.Point)
             {
-                return lessIf(perhapsInversedX.Below(perhapsInversedY.OtherEvent.Point));
+                return LessIf(perhapsInversedX.Below(perhapsInversedY.OtherEvent.Point), inversed);
             }
 
             // Different left endpoints: use the y-coordinate to sort if x-coordinates are the same
             if (perhapsInversedX.Point.X == perhapsInversedY.Point.X)
             {
-                return lessIf(perhapsInversedX.Point.Y < perhapsInversedY.Point.Y);
+                return LessIf(perhapsInversedX.Point.Y < perhapsInversedY.Point.Y, inversed);
             }
 
             // If `x` and `y` lie on the same side of the reference segment,
             // no intersection check is necessary.
             if ((area1 > 0) == (area2 > 0))
             {
-                return lessIf(area1 > 0);
+                return LessIf(area1 > 0, inversed);
             }
 
             // If `x` lies on the reference segment, compare based on `y`.
             if (area1 == 0)
             {
-                return lessIf(area2 > 0);
+                return LessIf(area2 > 0, inversed);
             }
 
             // Form segments from the events.
@@ -91,17 +92,17 @@ public int Compare(SweepEvent? x, SweepEvent? y)
             if (interResult == 0)
             {
                 // No unique intersection found: decide based on area1.
-                return lessIf(area1 > 0);
+                return LessIf(area1 > 0, inversed);
             }
             else if (interResult == 1)
             {
                 // Unique intersection found.
                 if (pi0 == y.Point)
                 {
-                    return lessIf(area2 > 0);
+                    return LessIf(area2 > 0, inversed);
                 }
 
-                return lessIf(area1 > 0);
+                return LessIf(area1 > 0, inversed);
             }
 
             // If interResult is neither 0 nor 1, fall through to collinear logic.
@@ -114,16 +115,16 @@ public int Compare(SweepEvent? x, SweepEvent? y)
             if (perhapsInversedX.Point == perhapsInversedY.Point)
             {
                 // When left endpoints are identical, order by contour id.
-                return lessIf(perhapsInversedX.ContourId < perhapsInversedY.ContourId);
+                return LessIf(perhapsInversedX.ContourId < perhapsInversedY.ContourId, inversed);
             }
 
             // If left endpoints differ, the Rust version simply returns "less" (i.e. the one inserted earlier).
             // Here we mimic that by always returning -1.
-            return lessIf(true);
+            return LessIf(true, inversed);
         }
 
         // Segments are collinear but belong to different polygons.
-        return lessIf(perhapsInversedX.PolygonType == PolygonType.Subject);
+        return LessIf(perhapsInversedX.PolygonType == PolygonType.Subject, inversed);
     }
 
     /// <inheritdoc/>
@@ -152,14 +153,8 @@ public int Compare(object? x, object? y)
     /// Returns -1 if the condition is true, 1 if false.
     /// </summary>
     /// <param name="condition">The boolean condition to evaluate.</param>
+    /// <param name="inversed">Should the result be inversed.</param>
     /// <returns>-1 if condition is true, 1 if false.</returns>
-    public static int LessIf(bool condition) => condition ? -1 : 1;
-
-    /// <summary>
-    /// Converts a boolean comparison result to an inversed ordering value.
-    /// Returns 1 if the condition is true, -1 if false.
-    /// </summary>
-    /// <param name="condition">The boolean condition to evaluate.</param>
-    /// <returns>1 if condition is true, -1 if false.</returns>
-    public static int LessIfInversed(bool condition) => condition ? 1 : -1;
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static int LessIf(bool condition, bool inversed = false) => condition ^ inversed ? -1 : 1;
 }
diff --git a/tests/PolygonClipper.Tests/GenericTestCases.cs b/tests/PolygonClipper.Tests/GenericTestCases.cs
@@ -16,12 +16,9 @@ namespace PolygonClipper.Tests;
 
 public class GenericTestCases
 {
-    private readonly ITestOutputHelper _testOutputHelper;
+    private readonly ITestOutputHelper testOutputHelper;
 
-    public GenericTestCases(ITestOutputHelper testOutputHelper)
-    {
-        _testOutputHelper = testOutputHelper;
-    }
+    public GenericTestCases(ITestOutputHelper testOutputHelper) => this.testOutputHelper = testOutputHelper;
 
     public static IEnumerable<object[]> GetTestCases()
         => TestData.Generic.GetFileNames().Select(x => new object[] { x });
@@ -73,7 +70,7 @@ public void GenericTestCase(string testCaseFile)
             for (int i = 0; i < expected.ContourCount; i++)
             {
                 // We don't test for holes here as the reference tests do not do so.
-                this._testOutputHelper.WriteLine($"Current Countour {i}");
+                this.testOutputHelper.WriteLine($"Current Countour {i}");
 
                 Assert.Equal(expected[i].VertexCount, actual[i].VertexCount);
                 for (int j = 0; j < expected[i].VertexCount; j++)
@@ -153,7 +150,8 @@ private static List<ExpectedResult> ExtractExpectedResults(List<Feature> feature
             {
                 return new ExpectedResult
                 {
-                    Operation = operation, Coordinates = ConvertToPolygon(feature.Geometry as GeoPolygon)
+                    Operation = operation,
+                    Coordinates = ConvertToPolygon(feature.Geometry as GeoPolygon)
                 };
             }
 
diff --git a/tests/PolygonClipper.Tests/SegmentComparerTests.cs b/tests/PolygonClipper.Tests/SegmentComparerTests.cs
@@ -54,7 +54,7 @@ public void NotCollinear_EventsOrderInSweepLine()
         Assert.False(se2.Below(se1.Point));
         Assert.True(se2.Above(se1.Point));
 
-        AssertOrder(se1,se2, Ordering.Less);
+        AssertOrder(se1,se2, true);
 
         Assert.Equal(1, eventComparer.Compare(se3, se4));
         Assert.False(se4.Above(se3.Point));
@@ -126,49 +126,47 @@ public void TShapedCases()
         //        /\
         var (se1, _) = this.MakeSimple(0, 0.0, 0.0, 1.0, 1.0, true);
         var (se2, _) = this.MakeSimple(0, 0.5, 0.5, 1.0, 0.0, true);
-        this.AssertOrder(se1, se2, Ordering.Greater);
+        this.AssertOrder(se1, se2, false);
 
         // shape: \/
         //         \
         (se1, _) = this.MakeSimple(0, 0.0, 1.0, 1.0, 0.0, true);
         (se2, _) = this.MakeSimple(0, 0.5, 0.5, 1.0, 1.0, true);
-        this.AssertOrder(se1, se2, Ordering.Less);
+        this.AssertOrder(se1, se2, true);
 
         // shape: T
         (se1, _) = this.MakeSimple(0, 0.0, 1.0, 1.0, 1.0, true);
         (se2, _) = this.MakeSimple(0, 0.5, 0.0, 0.5, 1.0, true);
-        this.AssertOrder(se1, se2, Ordering.Greater);
+        this.AssertOrder(se1, se2, false);
 
         // shape: T upside down
         (se1, _) = this.MakeSimple(0, 0.0, 0.0, 1.0, 0.0, true);
         (se2, _) = this.MakeSimple(0, 0.5, 0.0, 0.5, 1.0, true);
-        this.AssertOrder(se1, se2, Ordering.Less);
+        this.AssertOrder(se1, se2, true);
     }
 
     [Fact]
     public void VerticalSegment()
     {
-        // Vertikales Referenzsegment bei x = 0, von y = -1 bis +1
+        // Vertical Referencesegment at x = 0, from y = -1 to +1
         var (se1, _) = this.MakeSimple(0, 0.0, -1.0, 0.0, 1.0, true);
 
-        // "above" Fälle
-        this.AssertOrder(se1, this.MakeSimple(0, -1.0, 1.0, 0.0, 1.0, true).se1, Ordering.Less);
-        this.AssertOrder(se1, this.MakeSimple(0, 0.0, 1.0, 1.0, 1.0, true).se1, Ordering.Less);
-        this.AssertOrder(se1, this.MakeSimple(0, -1.0, 2.0, 0.0, 2.0, true).se1, Ordering.Less);
-        this.AssertOrder(se1, this.MakeSimple(0, 0.0, 2.0, 1.0, 2.0, true).se1, Ordering.Less);
-        this.AssertOrder(se1, this.MakeSimple(0, 0.0, 1.0, 0.0, 2.0, true).se1, Ordering.Less);
-
-        // "below" Fälle
-        this.AssertOrder(se1, this.MakeSimple(0, -1.0, -1.0, 0.0, -1.0, true).se1, Ordering.Greater);
-        this.AssertOrder(se1, this.MakeSimple(0, 0.0, -1.0, 1.0, -1.0, true).se1, Ordering.Greater);
-        this.AssertOrder(se1, this.MakeSimple(0, -1.0, -2.0, 0.0, -2.0, true).se1, Ordering.Greater);
-        this.AssertOrder(se1, this.MakeSimple(0, 0.0, -2.0, 1.0, -2.0, true).se1, Ordering.Greater);
-        this.AssertOrder(se1, this.MakeSimple(0, 0.0, -2.0, 0.0, -1.0, true).se1, Ordering.Greater);
-
-        // Überlappungen
-        this.AssertOrder(se1, this.MakeSimple(0, 0.0, -0.5, 0.0, 0.5, true).se1, Ordering.Less);
-        // Der folgende Fall ist im Rust-Test auskommentiert, da die Ordnung nicht anti-symmetrisch ist.
-        // this.AssertOrder(se1, this.MakeSimple(0, 0.0, -1.0, 0.0, 0.0, true).se1, Ordering.Less);
+        // "above" Cases
+        this.AssertOrder(se1, this.MakeSimple(0, -1.0, 1.0, 0.0, 1.0, true).se1, true);
+        this.AssertOrder(se1, this.MakeSimple(0, 0.0, 1.0, 1.0, 1.0, true).se1, true);
+        this.AssertOrder(se1, this.MakeSimple(0, -1.0, 2.0, 0.0, 2.0, true).se1, true);
+        this.AssertOrder(se1, this.MakeSimple(0, 0.0, 2.0, 1.0, 2.0, true).se1, true);
+        this.AssertOrder(se1, this.MakeSimple(0, 0.0, 1.0, 0.0, 2.0, true).se1, true);
+
+        // "below" Cases
+        this.AssertOrder(se1, this.MakeSimple(0, -1.0, -1.0, 0.0, -1.0, true).se1, false);
+        this.AssertOrder(se1, this.MakeSimple(0, 0.0, -1.0, 1.0, -1.0, true).se1, false);
+        this.AssertOrder(se1, this.MakeSimple(0, -1.0, -2.0, 0.0, -2.0, true).se1, false);
+        this.AssertOrder(se1, this.MakeSimple(0, 0.0, -2.0, 1.0, -2.0, true).se1, false);
+        this.AssertOrder(se1, this.MakeSimple(0, 0.0, -2.0, 0.0, -1.0, true).se1, false);
+
+        // Overlapping Cases
+        this.AssertOrder(se1, this.MakeSimple(0, 0.0, -0.5, 0.0, 0.5, true).se1, true);
     }
 
     private (SweepEvent se1, SweepEvent se2) MakeSimple(int contourId, double x1, double y1, double x2, double y2,
@@ -187,16 +185,11 @@ public void VerticalSegment()
         return (se1, se2);
     }
 
-    private void AssertOrder(SweepEvent se1, SweepEvent se2, Ordering order)
+    private void AssertOrder(SweepEvent se1, SweepEvent se2, bool less)
     {
-        Ordering inverseOrder = order == Ordering.Less ? Ordering.Greater : Ordering.Less;
-        Assert.Equal((int)order, this.segmentComparer.Compare(se1, se2));
-        Assert.Equal((int)inverseOrder, this.segmentComparer.Compare(se2, se1));
-    }
-
-    public enum Ordering
-    {
-        Less = -1,
-        Greater = 1,
+        int order = less ? -1 : 1;
+        int inverseOrder = less ? 1 : -1;
+        Assert.Equal(order, this.segmentComparer.Compare(se1, se2));
+        Assert.Equal(inverseOrder, this.segmentComparer.Compare(se2, se1));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -140,11 +140,6 @@ public Polygon Run()`
`140`	`140`	`for (int i = 0; i < clipping.ContourCount; i++)`
`141`	`141`	`{`
`142`	`142`	`Contour contour = clipping[i];`
`143`		`- bool exterior = operation != BooleanOperation.Difference;`
`144`		`- if (exterior)`
`145`		`- {`
`146`		`- contourId++;`
`147`		`- }`
`148`	`143`
`149`	`144`	`for (int j = 0; j < contour.VertexCount - 1; j++)`
`150`	`145`	`{`
`@@ -696,7 +691,6 @@ private static void DivideSegment(`
`696`	`691`	`// Prevent from corner case 1`
`697`	`692`	`if (p.X == le.Point.X && p.Y < le.Point.Y)`
`698`	`693`	`{`
`699`		`- // TODO: enabling this line makes a single test issue76.geojson fail.`
`700`	`694`	`// The files are different in the two reference repositories but both fail.`
`701`	`695`	`p = new Vertex(p.X.NextAfter(double.PositiveInfinity), p.Y);`
`702`	`696`	`}`
`@@ -1029,7 +1023,7 @@ private static int NextPos(`
`1029`	`1023`	`{`
`1030`	`1024`	`// Entire group is already processed?`
`1031`	`1025`	`found = false;`
`1032`		`- return Int32.MinValue;`
	`1026`	`+ return int.MinValue;`
`1033`	`1027`	`}`
`1034`	`1028`
`1035`	`1029`	`if (!processed[pos])`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System;`
`5`	`5`	`using System.Collections;`
`6`	`6`	`using System.Collections.Generic;`
	`7`	`+using System.Runtime.CompilerServices;`
`7`	`8`
`8`	`9`	`namespace PolygonClipper;`
`9`	`10`
`@@ -34,19 +35,19 @@ public int Compare(SweepEvent? x, SweepEvent? y)`
`34`	`35`	`}`
`35`	`36`
`36`	`37`	`SweepEvent perhapsInversedX, perhapsInversedY;`
`37`		`- Func<bool, int> lessIf;`
	`38`	`+ bool inversed = false;`
`38`	`39`
`39`	`40`	`if (x.IsBefore(y))`
`40`	`41`	`{`
`41`	`42`	`perhapsInversedX = x;`
`42`	`43`	`perhapsInversedY = y;`
`43`		`- lessIf = LessIf;`
	`44`	`+ inversed = false;`
`44`	`45`	`}`
`45`	`46`	`else`
`46`	`47`	`{`
`47`	`48`	`perhapsInversedX = y;`
`48`	`49`	`perhapsInversedY = x;`
`49`		`- lessIf = LessIfInversed;`
	`50`	`+ inversed = true;`
`50`	`51`	`}`
`51`	`52`
`52`	`53`	`// Check if the segments are collinear by comparing their signed areas`
`@@ -59,26 +60,26 @@ public int Compare(SweepEvent? x, SweepEvent? y)`
`59`	`60`	`// If they share their left endpoint, use the right endpoint to sort`
`60`	`61`	`if (perhapsInversedX.Point == perhapsInversedY.Point)`
`61`	`62`	`{`
`62`		`- return lessIf(perhapsInversedX.Below(perhapsInversedY.OtherEvent.Point));`
	`63`	`+ return LessIf(perhapsInversedX.Below(perhapsInversedY.OtherEvent.Point), inversed);`
`63`	`64`	`}`
`64`	`65`
`65`	`66`	`// Different left endpoints: use the y-coordinate to sort if x-coordinates are the same`
`66`	`67`	`if (perhapsInversedX.Point.X == perhapsInversedY.Point.X)`
`67`	`68`	`{`
`68`		`- return lessIf(perhapsInversedX.Point.Y < perhapsInversedY.Point.Y);`
	`69`	`+ return LessIf(perhapsInversedX.Point.Y < perhapsInversedY.Point.Y, inversed);`
`69`	`70`	`}`
`70`	`71`
`71`	`72`	// If `x` and `y` lie on the same side of the reference segment,
`72`	`73`	`// no intersection check is necessary.`
`73`	`74`	`if ((area1 > 0) == (area2 > 0))`
`74`	`75`	`{`
`75`		`- return lessIf(area1 > 0);`
	`76`	`+ return LessIf(area1 > 0, inversed);`
`76`	`77`	`}`
`77`	`78`
`78`	`79`	// If `x` lies on the reference segment, compare based on `y`.
`79`	`80`	`if (area1 == 0)`
`80`	`81`	`{`
`81`		`- return lessIf(area2 > 0);`
	`82`	`+ return LessIf(area2 > 0, inversed);`
`82`	`83`	`}`
`83`	`84`
`84`	`85`	`// Form segments from the events.`
`@@ -91,17 +92,17 @@ public int Compare(SweepEvent? x, SweepEvent? y)`
`91`	`92`	`if (interResult == 0)`
`92`	`93`	`{`
`93`	`94`	`// No unique intersection found: decide based on area1.`
`94`		`- return lessIf(area1 > 0);`
	`95`	`+ return LessIf(area1 > 0, inversed);`
`95`	`96`	`}`
`96`	`97`	`else if (interResult == 1)`
`97`	`98`	`{`
`98`	`99`	`// Unique intersection found.`
`99`	`100`	`if (pi0 == y.Point)`
`100`	`101`	`{`
`101`		`- return lessIf(area2 > 0);`
	`102`	`+ return LessIf(area2 > 0, inversed);`
`102`	`103`	`}`
`103`	`104`
`104`		`- return lessIf(area1 > 0);`
	`105`	`+ return LessIf(area1 > 0, inversed);`
`105`	`106`	`}`
`106`	`107`
`107`	`108`	`// If interResult is neither 0 nor 1, fall through to collinear logic.`
`@@ -114,16 +115,16 @@ public int Compare(SweepEvent? x, SweepEvent? y)`
`114`	`115`	`if (perhapsInversedX.Point == perhapsInversedY.Point)`
`115`	`116`	`{`
`116`	`117`	`// When left endpoints are identical, order by contour id.`
`117`		`- return lessIf(perhapsInversedX.ContourId < perhapsInversedY.ContourId);`
	`118`	`+ return LessIf(perhapsInversedX.ContourId < perhapsInversedY.ContourId, inversed);`
`118`	`119`	`}`
`119`	`120`
`120`	`121`	`// If left endpoints differ, the Rust version simply returns "less" (i.e. the one inserted earlier).`
`121`	`122`	`// Here we mimic that by always returning -1.`
`122`		`- return lessIf(true);`
	`123`	`+ return LessIf(true, inversed);`
`123`	`124`	`}`
`124`	`125`
`125`	`126`	`// Segments are collinear but belong to different polygons.`
`126`		`- return lessIf(perhapsInversedX.PolygonType == PolygonType.Subject);`
	`127`	`+ return LessIf(perhapsInversedX.PolygonType == PolygonType.Subject, inversed);`
`127`	`128`	`}`
`128`	`129`
`129`	`130`	`/// <inheritdoc/>`
`@@ -152,14 +153,8 @@ public int Compare(object? x, object? y)`
`152`	`153`	`/// Returns -1 if the condition is true, 1 if false.`
`153`	`154`	`/// </summary>`
`154`	`155`	`/// <param name="condition">The boolean condition to evaluate.</param>`
	`156`	`+ /// <param name="inversed">Should the result be inversed.</param>`
`155`	`157`	`/// <returns>-1 if condition is true, 1 if false.</returns>`
`156`		`- public static int LessIf(bool condition) => condition ? -1 : 1;`
`157`		`-`
`158`		`- /// <summary>`
`159`		`- /// Converts a boolean comparison result to an inversed ordering value.`
`160`		`- /// Returns 1 if the condition is true, -1 if false.`
`161`		`- /// </summary>`
`162`		`- /// <param name="condition">The boolean condition to evaluate.</param>`
`163`		`- /// <returns>1 if condition is true, -1 if false.</returns>`
`164`		`- public static int LessIfInversed(bool condition) => condition ? 1 : -1;`
	`158`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`159`	`+ private static int LessIf(bool condition, bool inversed = false) => condition ^ inversed ? -1 : 1;`
`165`	`160`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,12 +16,9 @@ namespace PolygonClipper.Tests;`
`16`	`16`
`17`	`17`	`public class GenericTestCases`
`18`	`18`	`{`
`19`		`- private readonly ITestOutputHelper _testOutputHelper;`
	`19`	`+ private readonly ITestOutputHelper testOutputHelper;`
`20`	`20`
`21`		`- public GenericTestCases(ITestOutputHelper testOutputHelper)`
`22`		`- {`
`23`		`- _testOutputHelper = testOutputHelper;`
`24`		`- }`
	`21`	`+ public GenericTestCases(ITestOutputHelper testOutputHelper) => this.testOutputHelper = testOutputHelper;`
`25`	`22`
`26`	`23`	`public static IEnumerable<object[]> GetTestCases()`
`27`	`24`	`=> TestData.Generic.GetFileNames().Select(x => new object[] { x });`
`@@ -73,7 +70,7 @@ public void GenericTestCase(string testCaseFile)`
`73`	`70`	`for (int i = 0; i < expected.ContourCount; i++)`
`74`	`71`	`{`
`75`	`72`	`// We don't test for holes here as the reference tests do not do so.`
`76`		`- this._testOutputHelper.WriteLine($"Current Countour {i}");`
	`73`	`+ this.testOutputHelper.WriteLine($"Current Countour {i}");`
`77`	`74`
`78`	`75`	`Assert.Equal(expected[i].VertexCount, actual[i].VertexCount);`
`79`	`76`	`for (int j = 0; j < expected[i].VertexCount; j++)`
`@@ -153,7 +150,8 @@ private static List<ExpectedResult> ExtractExpectedResults(List<Feature> feature`
`153`	`150`	`{`
`154`	`151`	`return new ExpectedResult`
`155`	`152`	`{`
`156`		`- Operation = operation, Coordinates = ConvertToPolygon(feature.Geometry as GeoPolygon)`
	`153`	`+ Operation = operation,`
	`154`	`+ Coordinates = ConvertToPolygon(feature.Geometry as GeoPolygon)`
`157`	`155`	`};`
`158`	`156`	`}`
`159`	`157`