Polygon across Dateline and Intersection

[sindizzy]

So I have an ellipse (a polygon geometry) that spans the Dateline. If I build the polygon with the coordinates as-is (namely the longitudes are in the range -180 to +180) it then results with the geometry being Invalid and thus when I intersect the polygon with the points I get the error:

found non-noded intersection between LINESTRING(-155.32030939830221 83.16240616001781, -153.83095758124398 83.120852884772134) and LINESTRING(178.6792290990447 83.116588616289192, -179.84787091746912 83.158205372008268) [ (-155.06664425130143, 83.155328841178274, NaN, NaN) ]

To alleviate this I take the polygon x values in the range -180 to +180 and shift them to the range 0 to 360. This gives me a valid geometry and the Intersection produces no exceptions. However the intersection only gives me points in the eastern hemisphere and the points in the western hemisphere are ignored.

Is this expected behavior? Is there anything I can do to process this data properly? Is the only solution to shift the points as well? I'm stumped as to how to proceed.

[FObermaier]

You need to use a MULTIPOLYGON composed of parts on the eastern and parts of the western hemisphere. One way to achieve that is to

1. Translate your polygons vertices +180°,
2. Build the POLYGON
3. Split your POLYGON using a LINESTRING(180 100, 180 -100) and build a MULTIPOLYGON of the parts (see this).
4. Translate the vertices of that MULTIPOLYGON -180° and use it for your intersection tests.

[sindizzy]

It has taken me some to finally get back to this but I finally was able to implement this algorithm. I tested one set of points and seems like it wanted to work but not quite there. I also tried cutting at the 360 line with no joy. It seems to be wanting to stretch the outer ring to the prime meridian. here is what it looks like for a sample set of points:

I am going to test on a regular set of points that doesn't cross the dateline. I will report back with results.

[sindizzy]

Ok I took a polygon in the eastern hemisphere and cut it along the 60E line and it seems to work as designed. The squares are the original vertices and the red dots are the results of the Split function. Any other things I could try for those that cross the dateline?

[sindizzy]

Ok I added some more tweaks and it works great now. The main issue was the coordinates along the dateline. You have to make sure that once you unshift the coordinates then use the appropriate dateline values. if your polygon sits in the eastern hemisphere then it should be +180, else if polygon is on the western hemisphere then it should be -180.

[FObermaier]

Perhaps you can share your code?

[sindizzy]

Apologies, I wasn't checking my email. But yes , let me clean it up a bit and post the code. It uses DotSpatial as its main framework but many of the functions come from NTS.

[michaelonz]

sindizzy - did you manage to share your solution - I am facing similar issue.....i also need a way to identify if the polygon does cross the dateline (as opposed to a polygon going around the world in the opposite direction)

[sindizzy]

I almost forgot about this. Let me get the code and post it here.

[sindizzy]

Ok here is my code. it is written in VB but could be translated to C# fairly easily. I use DotSpatial so there may be some DS specific functions. I think it can be converted to a pure NTS routine fairly easily as well. If there are any missing routines please let me know. The routine was tested on airspace polygons so it may not work for all scenarios. It is based on geographic coordinates (specifically WGS84) so projected coordinates may need to be translated first before using the routine. Please give me any feedback on enhancing the routine.

The routine returns a collection of polygon geometries. What you do with that collection is up to you. You can either create a multi-part feature or split the geometries up into individual features.

Calling the routine

'create a geometry (a polygon -OR- polygons) from the vertices
Dim pGeomEx As GeometryEx = GeneratePolygonEx(vertices, Double.NaN, True)

The logic meat

Public Class GeometryEx
    Public Inputs As New InputEx
    Public Results As New ResultsEx
End Class

Public Class InputEx
    Public OriginalCoords As List(Of Coordinate) = Nothing
    Public NormalizedCoords As List(Of Coordinate) = Nothing
    Public IsCrossesDateline As Boolean = False
    Public ShiftedCoords As List(Of Coordinate) = Nothing
End Class

Public Class ResultsEx
    Public Geom As IGeometry = Nothing
    Public NumGeomParts As Integer = -1
    Public HemiList As List(Of Hemishpere)
End Class

Public Enum Hemishpere
    Unknown = 0
    Western = 1
    Eastern = 2
    Northern = 3
    Southern = 4
End Enum



    ''' <summary>
    ''' This routine takes a list of Coordinates and attempts to convert them to a Polygon geometry.
    ''' </summary>
    ''' <param name="coordsInp">A list of coordinates that define a polygon.</param>
    ''' <param name="densifyResolution">The value to use to desinfy the resulting polygon(s). Double.NaN for no densification.</param>
    ''' <param name="isAttFixInvPolygons">True if attempt to fix invalid geometry, False otherwsie.</param>
    ''' <returns>
    ''' An IGeometry class that contains the result of converting the coordinates into a Polygon. Special care is taken
    ''' to determine if the polygon crosses the dateline and if it does then there is special processing to split the polygon
    ''' into several parts so that GIS can display without any issues.</returns>
    ''' <remarks>
	''' Code by Abel G. Perez 2021
    ''' https://github.com/NetTopologySuite/NetTopologySuite/discussions/496
    ''' https://github.com/NetTopologySuite/NetTopologySuite/blob/develop/test/NetTopologySuite.Samples.Console/Operation/Polygonize/SplitPolygonExample.cs
    ''' https://github.com/NetTopologySuite/NetTopologySuite/blob/84aef3c6a6cd3c2bfa5e3034ba161555cef5a117/test/NetTopologySuite.Samples.Console/Operation/Polygonize/SplitPolygonExample.cs#L24
    ''' https://github.com/nettopologysuite/nettopologysuite/issues/129
    ''' https://github.com/DotSpatial/DotSpatial/blob/e30421d6ee5b0cdf2b1fa01f95f8aabc50c1997a/Source/DotSpatial.Data/Shape.cs#L611
    ''' https://github.com/DotSpatial/DotSpatial/issues/1029
    ''' 
    ''' todo: we could perhaps return an enhanced class with the IGeometry as well as other info about the process. For example,
    ''' we can return if the input polygon crossed dateline and what hemispehere each polygon part is located in.
    ''' </remarks>
    Public Function GeneratePolygonEx(ByVal coordsInp As List(Of Coordinate), densifyResolution As Double, isAttFixInvPolygons As Boolean) As GeometryEx
        Try
            '###################################################################################################################
            'print original vertices
            '###################################################################################################################
            'Debug.Print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
            'Dim coordK As Coordinate
            'Debug.Print("kIdx,x,y")
            'For k As Integer = 0 To coordsInp.Count - 1
            '    coordK = coordsInp(k)
            '    Debug.Print("{0},{1},{2}", k, coordK.X, coordK.Y)
            'Next k
            'Debug.Print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
            Debug.Print("Initial number of coordinates={0}", coordsInp.Count)

            '###################################################################################################################
            'create a GeometryEx that will hold all of our result info
            '###################################################################################################################
            Dim geomEx As New GeometryEx
            geomEx.Inputs.OriginalCoords = coordsInp

            '###################################################################################################################
            'the first thing we do is is to create a Longitude class and normalize x values between -180° to 0° to +180°
            '###################################################################################################################
            Dim coordsNrm As New List(Of Coordinate), coordNrm As Coordinate, lonNrm As Longitude
            For Each coordInp As Coordinate In coordsInp
                lonNrm = New Longitude(coordInp.X).Normalize
                coordNrm = New Coordinate(lonNrm.DecimalDegrees, coordInp.Y, coordInp.Z, coordInp.M)
                coordsNrm.Add(coordNrm)
            Next coordInp
            geomEx.Inputs.NormalizedCoords = coordsNrm

            '###################################################################################################################
            'to create a polygon the list of coodinates must be closed. in other words the first coordinate has to be the same
            'as the last coordinate to form a closed ring. we will check that here.
            '###################################################################################################################
            Dim idxLast As Integer = coordsNrm.Count - 1
            If coordsNrm(0) IsNot coordsNrm(idxLast) Then
                coordsNrm.Add(coordsNrm(0))
            End If
            Debug.Print("Normalized number of coordinates={0}", coordsNrm.Count)

            If coordsNrm.Count < 3 Then Throw New Exception("Input list has fewer than 3 coordinates. To create a polygon, the minimum is 3 coordinates.")

            '###################################################################################################################
            'now we want to determine if the coordinates cross the dateline.
            '###################################################################################################################
            Dim IsPgnCrossesDateline As Boolean = IsPolygonCrossesDatelineEx(coordsNrm)
            geomEx.Inputs.IsCrossesDateline = IsPgnCrossesDateline
            Debug.Print("Polygon crosses dateline={0}", IsPgnCrossesDateline)

            '###################################################################################################################
            'create the polygon. if it does NOT cross the dateline then that is easy. if it does cross the dateline then we have
            'to get a bit more creative.
            '###################################################################################################################
            Dim resGeoms As IGeometry = Polygon.Empty
            Dim hemis As New List(Of Hemishpere), valOp As Valid.IsValidOp
            If Not IsPgnCrossesDateline Then
                '$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
                'the coordinates do NOT cross the dateline so create a ring and then a polygon geometry.
                '$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
                Dim pRing As New LinearRing(coordsNrm.ToArray)
                Dim pPolygon As New Polygon(pRing)
                resGeoms = pPolygon

                'determine which hemisphere this polygon is in
                Dim HasNegLons As Boolean = coordsNrm.Exists(Function(c As Coordinate) c.X < 0)
                If HasNegLons Then
                    hemis.Add(Hemishpere.Western)
                Else
                    hemis.Add(Hemishpere.Eastern)
                End If
            Else
                '$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
                'the coordinates do cross the dateline so we must get a little creative to split the polygon at the dateline to
                'create two or more polygon parts. the gist of this algorithm is to shift the entire polygon into either the positive
                'or negative hemisphere and then split it there using avaiable functions. once that is accomplished we then unshift
                'the polygon parts to where they were originally.
                '$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$

                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                'we need to find the coordinate closest to the dateline so we will calculate the
                'min postive x-coordinate in the list and the max negative x-coordinate in the list.
                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                Dim coordsPos As List(Of Coordinate) = coordsNrm.FindAll(Function(c) c.X >= 0)
                Dim xClosestToDlPos As Double = coordsPos.Min(Function(c) c.X)
                Dim coordsNeg As List(Of Coordinate) = coordsNrm.FindAll(Function(c) c.X < 0)
                Dim xClosestToDlNeg As Double = coordsNeg.Max(Function(c) c.X)
                'Debug.Print("xClosestToDlNeg={0} xClosestToDlPos={1}", xClosestToDlNeg, xClosestToDlPos)

                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                'determine which absolute value is the shortest from the dateline
                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                Dim delPos As Double = 180 - xClosestToDlPos
                Dim delNeg As Double = xClosestToDlNeg + 180
                Dim pad As Double = 0.1 'a small pad just to make sure you dont touch the dateline
                delPos += pad
                delNeg += pad
                Dim shift As Double = delPos
                If delNeg < delPos Then shift = -1 * delNeg
                'Debug.Print("delNeg={0} delPos={1} pad={2} shift={3}", delNeg, delPos, pad, shift)

                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                'shift coordinates to put them ALL in the same hemisphere
                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                Dim coordsShifted As New List(Of Coordinate)
                For q As Integer = 0 To coordsNrm.Count - 1
                    Dim qcord As Coordinate = coordsNrm(q)

                    'create a Longitude class, shift the x-coord, and normalize to a value between -180° to 0° to + 180°
                    lonNrm = New Longitude(qcord.X + shift).Normalize
                    Dim coordShifted As New Coordinate(lonNrm.DecimalDegrees, qcord.Y)

                    'add to the shifted coordinate list
                    coordsShifted.Add(coordShifted)
                Next q
                geomEx.Inputs.ShiftedCoords = coordsShifted

                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                'define the cutter line that is based on the dateline with a shift to put it in
                'the same hemisphere as the shifted polygon.
                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                Dim cutterLine As ILineString = DateLineEx(delNeg, delPos, shift)

                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                'create a polygon from the shifted coordinates
                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                Dim pRingShifted As New LinearRing(coordsShifted.ToArray)
                Dim pPolygonShifted As New Polygon(pRingShifted)

                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                'split the polygon with a polyline to get mutliple polygons
                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                Dim nodedLinework As IGeometry = pPolygonShifted.Boundary.Union(cutterLine)
                Dim polygons As IGeometry = Polygonize(nodedLinework)
                Dim output As New List(Of Geometry)()
                For i As Integer = 0 To polygons.NumGeometries - 1
                    Dim candpoly As Polygon = CType(polygons.GetGeometryN(i), Polygon)
                    If pPolygonShifted.Contains(candpoly.InteriorPoint) Then output.Add(candpoly)
                Next i
                resGeoms = pPolygonShifted.Factory.BuildGeometry(output.ToArray)

                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                'now we must take the resultant polygons and unshift them to their original location
                '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
                For w As Integer = 0 To resGeoms.NumGeometries - 1
                    Dim geom As IGeometry = resGeoms.GetGeometryN(w)

                    'cycle through all the coordinates and unshift them
                    Dim geomCoords As List(Of Coordinate) = geom.Coordinates.ToList
                    For q As Integer = 0 To geomCoords.Count - 1
                        Dim qcord As Coordinate = geomCoords(q)

                        'unshift the x-coord
                        qcord.X -= shift

                        'create a Longitude class and normalize x-coord to a value between -180° to 0° to + 180°
                        lonNrm = New Longitude(qcord.X).Normalize
                        qcord.X = lonNrm.DecimalDegrees
                    Next q

                    'now we have to "fix" the points that are exactly at the dateline. the polygon part in the east hemisphere should have
                    'these points at +180 and the polygon part in the west hemisphere should have these points at -180. so we will determine
                    'how many of the polgon part vertices are in the positive hemisphere and how many are in the negative hemisphere and also
                    'exclude the dateline points. if most are negative then make the dateline coordinate -180 else make it +180.
                    Dim coordsP As List(Of Coordinate) = geomCoords.FindAll(Function(c) c.X >= 0 And Math.Abs(c.X) <> 180)
                    Dim coordsN As List(Of Coordinate) = geomCoords.FindAll(Function(c) c.X < 0 And Math.Abs(c.X) <> 180)
                    Dim coordsAtDl As List(Of Coordinate) = geomCoords.FindAll(Function(c) Math.Abs(c.X) = 180)
                    If coordsP.Count >= coordsN.Count Then
                        coordsAtDl.ForEach(Sub(c As Coordinate) c.X = 180)
                    Else
                        coordsAtDl.ForEach(Sub(c As Coordinate) c.X = -180)
                    End If

                    'determine which hemisphere this polygon is in
                    Dim HasNegLons As Boolean = geomCoords.Exists(Function(c As Coordinate) c.X < 0)
                    If HasNegLons Then
                        hemis.Add(Hemishpere.Western)
                    Else
                        hemis.Add(Hemishpere.Eastern)
                    End If
                Next w
            End If

            '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
            'here we will densify the polygon if the resolution value is passed in.
            '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
            If Not Double.IsNaN(densifyResolution) AndAlso densifyResolution > 0 Then
                resGeoms = Densifier.Densify(resGeoms, densifyResolution)
            End If

            '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
            'finally if the option is passed in to attempt to fix invalid geometry then we will do that here
            'https://github.com/NetTopologySuite/NetTopologySuite/issues/124
            'Attempting to fix an invalid geometry by calling geometry.Buffer(0) is a common approach, and suggested in multiple places.
            'However it does not work in all cases.
            '>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
            If isAttFixInvPolygons Then
                valOp = New Valid.IsValidOp(resGeoms)

                If Not valOp.IsValid Then
                    'method 1
                    resGeoms = resGeoms.Buffer(0)

                    ''method 2
                    'Dim pm As New PrecisionModel(10000000000.0)
                    'resGeoms = New GeometryPrecisionReducer(pm).Reduce(resGeoms)
                End If
            End If

            'success so return generated polygon (it could me multi-part)
            geomEx.Results.Geom = resGeoms
            geomEx.Results.NumGeomParts = resGeoms.NumGeometries
            geomEx.Results.HemiList = hemis
            Return geomEx
        Catch ex As Exception
            Debug.Print(ex.ToString)
            Throw
        End Try
    End Function
    Public Function GeneratePolygonEx(ByVal coordsInp As List(Of Coordinate)) As GeometryEx
        Return GeneratePolygonEx(coordsInp, Double.NaN, False)
    End Function

    ''' <summary>
    ''' Determines if a polygon crosses the dateline. This is slightly different than checking a LineString as the Polygon is
    ''' closed. So a segment exists between the last vertex and the first vertex.
    ''' </summary>
    ''' <param name="coordsInp"></param>
    ''' <returns></returns>
    Public Function IsPolygonCrossesDatelineEx(ByVal coordsInp As List(Of Coordinate)) As Boolean
        Try
            'Debug.Print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
            'Dim coordIn As Coordinate
            'Debug.Print("kIdx,x,y")
            'For k As Integer = 0 To coordsInp.Count - 1
            '    coordIn = coordsInp(k)
            '    Debug.Print("{0},{1},{2}", k, coordIn.X, coordIn.Y)
            'Next k
            'Debug.Print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")

            'determine if the coordinates contain negative x-coords, positive x-coords, 0 x-coords, and +/-180 x-coords
            Dim HasNegLons As Boolean = coordsInp.Exists(Function(c As Coordinate) c.X < 0)
            Dim HasPosLons As Boolean = coordsInp.Exists(Function(c As Coordinate) c.X > 0)
            Dim Has000Lons As Boolean = coordsInp.Exists(Function(c As Coordinate) c.X = 0)
            Dim Has180Lons As Boolean = coordsInp.Exists(Function(c As Coordinate) Math.Abs(c.X) = 180)

            Debug.Print("HasNegLons={0} HasPosLons={1} Has000Lons={2} Has180Lons={3}", HasNegLons, HasPosLons, Has000Lons, Has180Lons)

            'if the longitudes are all the same sign then that means it didnt cross either the prime meridian or the date line. in this
            'case all we want is the date line crossing. if there is a mix of positive and negative longitudes then we have to determine
            'if any of those points are within +/- a delta from the date line. the delta is hard coded as 90 degrees.
            'the date line is at +180 or -180.
            If Not (HasNegLons And HasPosLons) Then
                Debug.Print("Feature does NOT cross dateline.")
                Return False
            Else
                Debug.Print("Feature MAY cross dateline. Analyzing all coordinates now...")

                'cycle through through all the vertices and determine if any segment crosses the dateline
                Dim idxLast As Integer = coordsInp.Count - 1, idxPrior As Integer
                Dim vtxCurr As Coordinate, vtxPrior As Coordinate
                For i As Integer = 0 To idxLast
                    'get the current vertex
                    vtxCurr = coordsInp(i)

                    'get the prior vertex
                    If i = 0 Then idxPrior = idxLast Else idxPrior = i - 1
                    vtxPrior = coordsInp(idxPrior)

                    'check for same or different longitude signs. this will let us know that the segment crossed the dateline -OR- the prime meridian.
                    Dim IsCrossesCriticalMeridain As Boolean = False
                    If Math.Sign(vtxCurr.X) <> Math.Sign(vtxPrior.X) Then IsCrossesCriticalMeridain = True

                    'further check if the segment crosses the dateline.
                    Dim IsCrossesDateline As Boolean = False, IsPairCxDl As Boolean = False
                    If IsCrossesCriticalMeridain Then
                        'check if the segment crosses the dateline
                        IsCrossesDateline = IsCoordPairCrossesDateline(vtxPrior, vtxCurr)
                    End If

                    'Debug.Print(" ==>i={0} vtxPrior.X={1} vtxPrior.y={2}", i, vtxPrior.X, vtxPrior.Y)
                    'Debug.Print(" ==>i={0} vtxCurr.X={1} vtxCurr.y={2}", i, vtxCurr.X, vtxCurr.Y)
                    'Debug.Print(" ==>i={0} IsCrossesCriticalMeridain={1} IsCrossesDateline={2}", i, IsCrossesCriticalMeridain, IsCrossesDateline)

                    'if it crosses the dateline then return
                    If IsCrossesDateline Then
                        Return True
                    End If
                Next i

                'if we make it to this point then that means the polygon did NOT cross the dateline
                Return False
            End If

            'if we make it to this point then that means the polygon did NOT cross the dateline
            Return False
        Catch ex As Exception
            Debug.Print(ex.ToString)
            Throw
        End Try
    End Function

    'this check calculates x distance between the two points going in opposite directions across the globe. the shortest segment wins and
    'that is the one we use to determine if the segment crosses the dateline. should work for most applications but this can be tweaked.
    Public Function IsCoordPairCrossesDateline(ByVal coordA As Coordinate, ByVal coordB As Coordinate) As Boolean
        'if longitudes are same sign then does not cross the dateline
        If Math.Sign(coordA.X) = Math.Sign(coordB.X) Then Return False

        'compute distance between points towards the prime meridian
        Dim distPm As Double = Math.Abs(coordA.X) + Math.Abs(coordB.X)

        'compute distance between points towards the dateline
        Dim distDl As Double = 360 - distPm

        'Debug.Print(" ==>distPm={0} distDl={1}", distPm, distDl)

        'if the two distances are the same then its a tough call because the distance around the globe in either
        'direction is the same. so we will opt for simplicity and choose the directon towards the prime meridian.
        If distPm < distDl Then
            Return False
        ElseIf distPm = distDl Then
            Return False
        Else
            Return True
        End If
    End Function

    Public Function Polygonize(ByVal geom As IGeometry) As Geometry
        Dim lines As ICollection(Of IGeometry) = LineStringExtracter.GetLines(geom)
        Dim pgnizer As New Polygonizer(False)
        pgnizer.Add(lines)
        Dim polys As List(Of IGeometry) = pgnizer.GetPolygons.ToList

        Dim polyArray As ICollection(Of IGeometry) = GeometryFactory.ToGeometryArray(polys)
        Return CType(geom.Factory.BuildGeometry(polyArray), Geometry)
    End Function

    'define the cutter line that is based on the dateline with a shift to put it in the same hemisphere as the polygon.
    Public Function DateLineEx(ByVal delNeg As Double, ByVal delPos As Double, ByVal shift As Double) As ILineString
        Dim lonSplit As Double = shift - 180
        If delNeg < delPos Then lonSplit = 180 + shift

        Dim cutterPtList As New List(Of Coordinate)
        cutterPtList.Add(New Coordinate(lonSplit, +100))
        cutterPtList.Add(New Coordinate(lonSplit, -100))
        Dim cutterLine As New LineString(cutterPtList.ToArray)

        'we can desnify the line but this seems to confuse the splitting routine
        'cutterLine = CType(Densifier.Densify(cutterLine, 0.1), LineString) 'densify to a specific resolution 0.1 degrees

        'return the "new" dateline that has been shifted
        Return cutterLine
    End Function

[sindizzy]

I actually refactored into c# so it's ready to be added and tested. Just let me know where to put it.

[sindizzy]

@FObermaier I can add it to my fork with a test. I've done some small modifications since I posted this code. Where should I add it?

[FObermaier]

@sindizzy, I think test/NetTopologySuite.Samples.Console/Technique is a good place. Along with a wiki-page that explains what is being done and how it is used.

[sindizzy]

Sounds good

[sindizzy]

@FObermaier So started my code and when I compiled I get this error which is beyond my knowledge base:

ApiCompat failed for 'C:\Users\Dude\Documents\GitHub\NetTopologySuite\src\NetTopologySuite\bin\Debug\netstandard2.0\NetTopologySuite.dll"

[michaelonz]

It would be great if this was added to the product - it will solve an issue I have right now …. Please update this ticket once it’s added and I willl update and give it a try.

…

On 30/11/2021, at 4:38 AM, Felix Obermaier ***@***.***> wrote:  @sindizzy thank you very much I'll look at the code asap — You are receiving this because you commented. Reply to this email directly, view it on GitHub, or unsubscribe. Triage notifications on the go with GitHub Mobile for iOS or Android.

[sindizzy]

I have a beta in my fork. Please take a look, test, critique, suggest,
https://github.com/sindizzy/NetTopologySuite/tree/Perez-DatelinePolygons

[FObermaier]

@sindizzy the workflow is that you create a pull request, then we have the tools to comment on your contribution

[sindizzy]

Ok I will do that next. I have some further tweaks so will do a couple more commits to the branch.

[DGuidi]

I will do a check to the PR as soon as I get back to work

[sindizzy]

Ok Ive done the PR with a pretty decent writeup (will probably put most of that in the wiki). Please take a look and test, critique, and suggest,

[sindizzy]

#580