[needs-docs][api] Rename QgsDistanceArea methods to change "date line"

nyalldawson · nyalldawson · commit 021f5ea366a1 · 2019-01-12T05:31:00.000+10:00
to "antimeridian"

Because the date line =/= +/-180 degree longitude, which is what
we were incorrectly using it to mean.
diff --git a/python/core/auto_generated/qgsdistancearea.sip.in b/python/core/auto_generated/qgsdistancearea.sip.in
@@ -384,17 +384,17 @@ The ``interval`` parameter gives the maximum distance between points on the comp
 This argument is always specified in meters. A shorter distance results in a denser line,
 at the cost of extra computing time.
 
-If the geodesic line crosses the international date line and ``breakLine`` is true, then
-the line will be split into two parts, broken at the date line. In this case the function
-will return two lines, corresponding to the portions at either side of the date line.
+If the geodesic line crosses the antimeridian (+/- 180 degrees longitude) and ``breakLine`` is true, then
+the line will be split into two parts, broken at the antimeridian. In this case the function
+will return two lines, corresponding to the portions at either side of the antimeridian.
 
 .. versionadded:: 3.6
 %End
 
-    double latitudeGeodesicCrossesDateLine( const QgsPointXY &p1, const QgsPointXY &p2, double &fractionAlongLine /Out/ ) const;
+    double latitudeGeodesicCrossesAntimeridian( const QgsPointXY &p1, const QgsPointXY &p2, double &fractionAlongLine /Out/ ) const;
 %Docstring
 Calculates the latitude at which the geodesic line joining ``p1`` and ``p2`` crosses
-the international date line (longitude +/- 180 degrees).
+the antimeridian (longitude +/- 180 degrees).
 
 The ellipsoid settings defined on this QgsDistanceArea object will be used during the calculations.
 
@@ -404,21 +404,21 @@ will also be in this same CRS.
 :param p1: Starting point, in ellipsoidCrs()
 :param p2: Ending point, in ellipsoidCrs()
 
-:return: - the latitude at which the geodesic crosses the date line
-         - fractionAlongLine:  will be set to the fraction along the geodesic line joining ``p1`` to ``p2`` at which the date line crossing occurs.
+:return: - the latitude at which the geodesic crosses the antimeridian
+         - fractionAlongLine:  will be set to the fraction along the geodesic line joining ``p1`` to ``p2`` at which the antimeridian crossing occurs.
 
-.. seealso:: :py:func:`breakGeometryAtDateLine`
+.. seealso:: :py:func:`breakGeometryAtAntimeridian`
 
 
 .. versionadded:: 3.6
 %End
 
-    QgsGeometry splitGeometryAtDateLine( const QgsGeometry &geometry ) const;
+    QgsGeometry splitGeometryAtAntimeridian( const QgsGeometry &geometry ) const;
 %Docstring
-Splits a (Multi)LineString ``geometry`` at the international date line (longitude +/- 180 degrees).
+Splits a (Multi)LineString ``geometry`` at the antimeridian (longitude +/- 180 degrees).
 The returned geometry will always be a multi-part geometry.
 
-Whenever line segments in the input geometry cross the international date line, they will be
+Whenever line segments in the input geometry cross the antimeridian, they will be
 split into two segments, with the latitude of the breakpoint being determined using a geodesic
 line connecting the points either side of this segment.
 
@@ -428,13 +428,13 @@ The ellipsoid settings defined on this QgsDistanceArea object will be used durin
 will also be in this same CRS.
 
 If ``geometry`` contains M or Z values, these will be linearly interpolated for the new vertices
-created at the date line.
+created at the antimeridian.
 
 .. note::
 
    Non-(Multi)LineString geometries will be returned unchanged.
 
-.. seealso:: :py:func:`latitudeGeodesicCrossesDateLine`
+.. seealso:: :py:func:`latitudeGeodesicCrossesAntimeridian`
 
 .. versionadded:: 3.6
 %End
diff --git a/src/core/qgsdistancearea.cpp b/src/core/qgsdistancearea.cpp
@@ -457,7 +457,7 @@ QgsPointXY QgsDistanceArea::computeSpheroidProject(
   return QgsPointXY( RAD2DEG( lambda2 ), RAD2DEG( lat2 ) );
 }
 
-double QgsDistanceArea::latitudeGeodesicCrossesDateLine( const QgsPointXY &pp1, const QgsPointXY &pp2, double &fractionAlongLine ) const
+double QgsDistanceArea::latitudeGeodesicCrossesAntimeridian( const QgsPointXY &pp1, const QgsPointXY &pp2, double &fractionAlongLine ) const
 {
   QgsPointXY p1 = pp1;
   QgsPointXY p2 = pp2;
@@ -487,7 +487,7 @@ double QgsDistanceArea::latitudeGeodesicCrossesDateLine( const QgsPointXY &pp1,
 
   int iterations = 0;
   double t = 0;
-  // iterate until our intersection candidate is within ~1 mm of the date line (or too many iterations happened)
+  // iterate until our intersection candidate is within ~1 mm of the antimeridian (or too many iterations happened)
   while ( std::fabs( lon - 180.0 ) > 0.00000001 && iterations < 100 )
   {
     if ( iterations > 0 && std::fabs( p2x - p1x ) > 5 )
@@ -516,7 +516,7 @@ double QgsDistanceArea::latitudeGeodesicCrossesDateLine( const QgsPointXY &pp1,
       intersectionDist *= ( 180.0 - p1x ) / ( lon - p1x );
     }
 
-    // now work out the point on the geodesic this far from p1 - this becomes our new candidate for crossing the date line
+    // now work out the point on the geodesic this far from p1 - this becomes our new candidate for crossing the antimeridian
 
     geod_position( &line, intersectionDist, &lat, &lon, &t );
     // we don't want to wrap longitudes > 180 around)
@@ -533,7 +533,7 @@ double QgsDistanceArea::latitudeGeodesicCrossesDateLine( const QgsPointXY &pp1,
   return lat;
 }
 
-QgsGeometry QgsDistanceArea::splitGeometryAtDateLine( const QgsGeometry &geometry ) const
+QgsGeometry QgsDistanceArea::splitGeometryAtAntimeridian( const QgsGeometry &geometry ) const
 {
   if ( QgsWkbTypes::geometryType( geometry.wkbType() ) != QgsWkbTypes::LineGeometry )
     return geometry;
@@ -585,14 +585,14 @@ QgsGeometry QgsDistanceArea::splitGeometryAtDateLine( const QgsGeometry &geometr
         lat = y;
         mCoordTransform.transformInPlace( lon, lat, z );
 
-        //test if we crossed the dateline in this segment
+        //test if we crossed the antimeridian in this segment
         if ( i > 0 && ( ( prevLon < -120 && lon > 120 ) || ( prevLon > 120 && lon  < -120 ) ) )
         {
           // we did!
           // when crossing the antimeridian, we need to calculate the latitude
           // at which the geodesic intersects the antimeridian
           double fract = 0;
-          double lat180 = latitudeGeodesicCrossesDateLine( QgsPointXY( prevLon, prevLat ), QgsPointXY( lon, lat ), fract );
+          double lat180 = latitudeGeodesicCrossesAntimeridian( QgsPointXY( prevLon, prevLat ), QgsPointXY( lon, lat ), fract );
           if ( line->is3D() )
           {
             z = prevZ + ( p.z() - prevZ ) * fract;
@@ -711,11 +711,11 @@ QVector< QVector<QgsPointXY> > QgsDistanceArea::geodesicLine( const QgsPointXY &
 
     if ( breakLine && ( ( prevLon < -120 && lon > 120 ) || ( prevLon > 120 && lon < -120 ) ) )
     {
-      // when breaking the geodesic at the date line, we need to calculate the latitude
-      // at which the geodesic intersects the date line, and add points to both line segments at this latitude
-      // on the date line.
+      // when breaking the geodesic at the antimeridian, we need to calculate the latitude
+      // at which the geodesic intersects the antimeridian, and add points to both line segments at this latitude
+      // on the antimeridian.
       double fraction;
-      double lat180 = latitudeGeodesicCrossesDateLine( QgsPointXY( prevLon, prevLat ), QgsPointXY( lon, lat ), fraction );
+      double lat180 = latitudeGeodesicCrossesAntimeridian( QgsPointXY( prevLon, prevLat ), QgsPointXY( lon, lat ), fraction );
 
       try
       {
diff --git a/src/core/qgsdistancearea.h b/src/core/qgsdistancearea.h
@@ -311,17 +311,17 @@ class CORE_EXPORT QgsDistanceArea
      * This argument is always specified in meters. A shorter distance results in a denser line,
      * at the cost of extra computing time.
      *
-     * If the geodesic line crosses the international date line and \a breakLine is true, then
-     * the line will be split into two parts, broken at the date line. In this case the function
-     * will return two lines, corresponding to the portions at either side of the date line.
+     * If the geodesic line crosses the antimeridian (+/- 180 degrees longitude) and \a breakLine is true, then
+     * the line will be split into two parts, broken at the antimeridian. In this case the function
+     * will return two lines, corresponding to the portions at either side of the antimeridian.
      *
      * \since QGIS 3.6
      */
     QVector<QVector<QgsPointXY> > geodesicLine( const QgsPointXY &p1, const QgsPointXY &p2, double interval, bool breakLine = false ) const;
 
     /**
      * Calculates the latitude at which the geodesic line joining \a p1 and \a p2 crosses
-     * the international date line (longitude +/- 180 degrees).
+     * the antimeridian (longitude +/- 180 degrees).
      *
      * The ellipsoid settings defined on this QgsDistanceArea object will be used during the calculations.
      *
@@ -330,20 +330,20 @@ class CORE_EXPORT QgsDistanceArea
      *
      * \param p1 Starting point, in ellipsoidCrs()
      * \param p2 Ending point, in ellipsoidCrs()
-     * \param fractionAlongLine will be set to the fraction along the geodesic line joining \a p1 to \a p2 at which the date line crossing occurs.
+     * \param fractionAlongLine will be set to the fraction along the geodesic line joining \a p1 to \a p2 at which the antimeridian crossing occurs.
      *
-     * \returns the latitude at which the geodesic crosses the date line
-     * \see breakGeometryAtDateLine()
+     * \returns the latitude at which the geodesic crosses the antimeridian
+     * \see breakGeometryAtAntimeridian()
      *
      * \since QGIS 3.6
      */
-    double latitudeGeodesicCrossesDateLine( const QgsPointXY &p1, const QgsPointXY &p2, double &fractionAlongLine SIP_OUT ) const;
+    double latitudeGeodesicCrossesAntimeridian( const QgsPointXY &p1, const QgsPointXY &p2, double &fractionAlongLine SIP_OUT ) const;
 
     /**
-     * Splits a (Multi)LineString \a geometry at the international date line (longitude +/- 180 degrees).
+     * Splits a (Multi)LineString \a geometry at the antimeridian (longitude +/- 180 degrees).
      * The returned geometry will always be a multi-part geometry.
      *
-     * Whenever line segments in the input geometry cross the international date line, they will be
+     * Whenever line segments in the input geometry cross the antimeridian, they will be
      * split into two segments, with the latitude of the breakpoint being determined using a geodesic
      * line connecting the points either side of this segment.
      *
@@ -353,14 +353,14 @@ class CORE_EXPORT QgsDistanceArea
      * will also be in this same CRS.
      *
      * If \a geometry contains M or Z values, these will be linearly interpolated for the new vertices
-     * created at the date line.
+     * created at the antimeridian.
      *
      * \note Non-(Multi)LineString geometries will be returned unchanged.
      *
-     * \see latitudeGeodesicCrossesDateLine()
+     * \see latitudeGeodesicCrossesAntimeridian()
      * \since QGIS 3.6
      */
-    QgsGeometry splitGeometryAtDateLine( const QgsGeometry &geometry ) const;
+    QgsGeometry splitGeometryAtAntimeridian( const QgsGeometry &geometry ) const;
 
   private:
 
diff --git a/tests/src/python/test_qgsdistancearea.py b/tests/src/python/test_qgsdistancearea.py

Original file line number	Diff line number	Diff line change
`@@ -311,17 +311,17 @@ class CORE_EXPORT QgsDistanceArea`
`311`	`311`	`* This argument is always specified in meters. A shorter distance results in a denser line,`
`312`	`312`	`* at the cost of extra computing time.`
`313`	`313`	`*`
`314`		`- * If the geodesic line crosses the international date line and \a breakLine is true, then`
`315`		`- * the line will be split into two parts, broken at the date line. In this case the function`
`316`		`- * will return two lines, corresponding to the portions at either side of the date line.`
	`314`	`+ * If the geodesic line crosses the antimeridian (+/- 180 degrees longitude) and \a breakLine is true, then`
	`315`	`+ * the line will be split into two parts, broken at the antimeridian. In this case the function`
	`316`	`+ * will return two lines, corresponding to the portions at either side of the antimeridian.`
`317`	`317`	`*`
`318`	`318`	`* \since QGIS 3.6`
`319`	`319`	`*/`
`320`	`320`	`QVector<QVector<QgsPointXY> > geodesicLine( const QgsPointXY &p1, const QgsPointXY &p2, double interval, bool breakLine = false ) const;`
`321`	`321`
`322`	`322`	`/**`
`323`	`323`	`* Calculates the latitude at which the geodesic line joining \a p1 and \a p2 crosses`
`324`		`- * the international date line (longitude +/- 180 degrees).`
	`324`	`+ * the antimeridian (longitude +/- 180 degrees).`
`325`	`325`	`*`
`326`	`326`	`* The ellipsoid settings defined on this QgsDistanceArea object will be used during the calculations.`
`327`	`327`	`*`
`@@ -330,20 +330,20 @@ class CORE_EXPORT QgsDistanceArea`
`330`	`330`	`*`
`331`	`331`	`* \param p1 Starting point, in ellipsoidCrs()`
`332`	`332`	`* \param p2 Ending point, in ellipsoidCrs()`
`333`		`- * \param fractionAlongLine will be set to the fraction along the geodesic line joining \a p1 to \a p2 at which the date line crossing occurs.`
	`333`	`+ * \param fractionAlongLine will be set to the fraction along the geodesic line joining \a p1 to \a p2 at which the antimeridian crossing occurs.`
`334`	`334`	`*`
`335`		`- * \returns the latitude at which the geodesic crosses the date line`
`336`		`- * \see breakGeometryAtDateLine()`
	`335`	`+ * \returns the latitude at which the geodesic crosses the antimeridian`
	`336`	`+ * \see breakGeometryAtAntimeridian()`
`337`	`337`	`*`
`338`	`338`	`* \since QGIS 3.6`
`339`	`339`	`*/`
`340`		`- double latitudeGeodesicCrossesDateLine( const QgsPointXY &p1, const QgsPointXY &p2, double &fractionAlongLine SIP_OUT ) const;`
	`340`	`+ double latitudeGeodesicCrossesAntimeridian( const QgsPointXY &p1, const QgsPointXY &p2, double &fractionAlongLine SIP_OUT ) const;`
`341`	`341`
`342`	`342`	`/**`
`343`		`- * Splits a (Multi)LineString \a geometry at the international date line (longitude +/- 180 degrees).`
	`343`	`+ * Splits a (Multi)LineString \a geometry at the antimeridian (longitude +/- 180 degrees).`
`344`	`344`	`* The returned geometry will always be a multi-part geometry.`
`345`	`345`	`*`
`346`		`- * Whenever line segments in the input geometry cross the international date line, they will be`
	`346`	`+ * Whenever line segments in the input geometry cross the antimeridian, they will be`
`347`	`347`	`* split into two segments, with the latitude of the breakpoint being determined using a geodesic`
`348`	`348`	`* line connecting the points either side of this segment.`
`349`	`349`	`*`
`@@ -353,14 +353,14 @@ class CORE_EXPORT QgsDistanceArea`
`353`	`353`	`* will also be in this same CRS.`
`354`	`354`	`*`
`355`	`355`	`* If \a geometry contains M or Z values, these will be linearly interpolated for the new vertices`
`356`		`- * created at the date line.`
	`356`	`+ * created at the antimeridian.`
`357`	`357`	`*`
`358`	`358`	`* \note Non-(Multi)LineString geometries will be returned unchanged.`
`359`	`359`	`*`
`360`		`- * \see latitudeGeodesicCrossesDateLine()`
	`360`	`+ * \see latitudeGeodesicCrossesAntimeridian()`
`361`	`361`	`* \since QGIS 3.6`
`362`	`362`	`*/`
`363`		`- QgsGeometry splitGeometryAtDateLine( const QgsGeometry &geometry ) const;`
	`363`	`+ QgsGeometry splitGeometryAtAntimeridian( const QgsGeometry &geometry ) const;`
`364`	`364`
`365`	`365`	`private:`
`366`	`366`
-Original file line number
+Diff line change
         self.assertEqual(QgsDistanceArea.formatDistance(1.0, 1, QgsUnitTypes.DistanceUnknownUnit, False), '1.0')
         QLocale.setDefault(QLocale.system())
 -    def testGeodesicIntersectionAtDateLine(self):
 +    def testGeodesicIntersectionAtAntimeridian(self):
         da = QgsDistanceArea()
         crs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
         da.setSourceCrs(crs, QgsProject.instance().transformContext())
         da.setEllipsoid("WGS84")
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(0, 0), QgsPointXY(-170, 0))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(0, 0), QgsPointXY(-170, 0))
         self.assertAlmostEqual(lat, 0, 5)
         self.assertAlmostEqual(fract, 0, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(-170, 0), QgsPointXY(170, 0))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(-170, 0), QgsPointXY(170, 0))
         self.assertAlmostEqual(lat, 0, 5)
         self.assertAlmostEqual(fract, 0.5, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(179, 0), QgsPointXY(181, 0))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(179, 0), QgsPointXY(181, 0))
         self.assertAlmostEqual(lat, 0, 5)
         self.assertAlmostEqual(fract, 0.5, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(-170, 0), QgsPointXY(170, 0))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(-170, 0), QgsPointXY(170, 0))
         self.assertAlmostEqual(lat, 0, 5)
         self.assertAlmostEqual(fract, 0.5, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(180, 0), QgsPointXY(180, 0))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(180, 0), QgsPointXY(180, 0))
         self.assertAlmostEqual(lat, 0, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(180, -10), QgsPointXY(180, -10))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(180, -10), QgsPointXY(180, -10))
         self.assertAlmostEqual(lat, -10, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(138.26237, -20.314687), QgsPointXY(-151.6, -77.8))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(138.26237, -20.314687), QgsPointXY(-151.6, -77.8))
         self.assertAlmostEqual(lat, -73.89148222666744914, 5)
         self.assertAlmostEqual(fract, 0.007113545719515548, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(138.26237, -20.314687), QgsPointXY(-151.6 + 360, -77.8))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(138.26237, -20.314687), QgsPointXY(-151.6 + 360, -77.8))
         self.assertAlmostEqual(lat, -73.89148222666744914, 5)
         self.assertAlmostEqual(fract, 0.007113545719515548, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(-151.6, -77.8), QgsPointXY(138.26237, -20.314687))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(-151.6, -77.8), QgsPointXY(138.26237, -20.314687))
         self.assertAlmostEqual(lat, -73.89148222666744914, 5)
         self.assertAlmostEqual(fract, 0.007113545719515548, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(170.60188754234980024, -70.81368329001529105),
 -                                                        QgsPointXY(-164.61259948055175073, -76.66761193248410677))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(170.60188754234980024, -70.81368329001529105),
 +                                                            QgsPointXY(-164.61259948055175073, -76.66761193248410677))
         self.assertAlmostEqual(lat, -73.89148222666744914, 5)
         self.assertAlmostEqual(fract, 0.0879577697523441, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(-164.61259948055175073, -76.66761193248410677),
 -                                                        QgsPointXY(170.60188754234980024,
 -                                                                   -70.81368329001529105))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(-164.61259948055175073, -76.66761193248410677),
 +                                                            QgsPointXY(170.60188754234980024,
 +                                                                       -70.81368329001529105))
         self.assertAlmostEqual(lat, -73.89148222666744914, 5)
         self.assertAlmostEqual(fract, 0.0879577697523441, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(178.44469761238570982, -73.47820480021761114),
 -                                                        QgsPointXY(-179.21026002627399976, -74.08952948682963324))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(178.44469761238570982, -73.47820480021761114),
 +                                                            QgsPointXY(-179.21026002627399976, -74.08952948682963324))
         self.assertAlmostEqual(lat, -73.89148222666744914, 5)
         self.assertAlmostEqual(fract, 0.6713541474159178, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(-179.21026002627399976, -74.08952948682963324),
 -                                                        QgsPointXY(178.44469761238570982,
 -                                                                   -73.47820480021761114))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(-179.21026002627399976, -74.08952948682963324),
 +                                                            QgsPointXY(178.44469761238570982,
 +                                                                       -73.47820480021761114))
         self.assertAlmostEqual(lat, -73.89148222666744914, 5)
         self.assertAlmostEqual(fract, 0.6713541474159178, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(179.83103440731269984, -73.8481044794813215),
 -                                                        QgsPointXY(-179.93191793815378787, -73.90885909527753483))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(179.83103440731269984, -73.8481044794813215),
 +                                                            QgsPointXY(-179.93191793815378787, -73.90885909527753483))
         self.assertAlmostEqual(lat, -73.89148222666744914, 5)
         self.assertAlmostEqual(fract, 0.7135414998986486, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(-179.93191793815378787, -73.90885909527753483),
 -                                                        QgsPointXY(179.83103440731269984, -73.8481044794813215))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(-179.93191793815378787, -73.90885909527753483),
 +                                                            QgsPointXY(179.83103440731269984, -73.8481044794813215))
         self.assertAlmostEqual(lat, -73.89148222666744914, 5)
         self.assertAlmostEqual(fract, 0.7135414998986486, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(179.92498611649580198, 7.24703528617311754),
 -                                                        QgsPointXY(-178.20070563806575592, 16.09649962419504732))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(179.92498611649580198, 7.24703528617311754),
 +                                                            QgsPointXY(-178.20070563806575592, 16.09649962419504732))
         self.assertAlmostEqual(lat, 7.6112109902580265, 5)
         self.assertAlmostEqual(fract, 0.04111771567489498, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(-178.20070563806575592, 16.09649962419504732),
 -                                                        QgsPointXY(179.92498611649580198, 7.24703528617311754))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(-178.20070563806575592, 16.09649962419504732),
 +                                                            QgsPointXY(179.92498611649580198, 7.24703528617311754))
         self.assertAlmostEqual(lat, 7.6112109902580265, 5)
         self.assertAlmostEqual(fract, 0.04111771567489498, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(360 - 178.20070563806575592, 16.09649962419504732),
 -                                                        QgsPointXY(179.92498611649580198, 7.24703528617311754))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(360 - 178.20070563806575592, 16.09649962419504732),
 +                                                            QgsPointXY(179.92498611649580198, 7.24703528617311754))
         self.assertAlmostEqual(lat, 7.6112109902580265, 5)
         self.assertAlmostEqual(fract, 0.04111771567489498, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(175.76717768974583578, 8.93749416467257873),
 -                                                        QgsPointXY(-175.15030911497356669, 8.59851183021221033))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(175.76717768974583578, 8.93749416467257873),
 +                                                            QgsPointXY(-175.15030911497356669, 8.59851183021221033))
         self.assertAlmostEqual(lat, 8.80683758146703966, 5)
         self.assertAlmostEqual(fract, 0.46581637044475815, 5)
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(-175.15030911497356669, 8.59851183021221033),
 -                                                        QgsPointXY(175.76717768974583578,
 -                                                                   8.93749416467257873))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(-175.15030911497356669, 8.59851183021221033),
 +                                                            QgsPointXY(175.76717768974583578,
 +                                                                       8.93749416467257873))
         self.assertAlmostEqual(lat, 8.80683758146703966, 5)
         self.assertAlmostEqual(fract, 0.46581637044475815, 5)
         # calculation should be ellipsoid dependent!
         da.setEllipsoid("Phobos2000")
 -        lat, fract = da.latitudeGeodesicCrossesDateLine(QgsPointXY(-175.15030911497356669, 8.59851183021221033),
 -                                                        QgsPointXY(175.76717768974583578,
 -                                                                   8.93749416467257873))
 +        lat, fract = da.latitudeGeodesicCrossesAntimeridian(QgsPointXY(-175.15030911497356669, 8.59851183021221033),
 +                                                            QgsPointXY(175.76717768974583578,
 +                                                                       8.93749416467257873))
         self.assertAlmostEqual(lat, 8.836479503936307, 5)
         self.assertAlmostEqual(fract, 0.46593364650414865, 5)
         self.assertEqual(g.asWkt(0),
                          'MultiLineString ((-13536427 14138932, -16514348 11691516, -17948849 9406595, -18744235 7552985, -19255354 6014890, -19622372 4688888, -19909239 3505045, -20037508 2933522),(20037508 2933522, 19925702 2415579, 19712755 1385803, 19513769 388441, 19318507 -600065, 19117459 -1602293, 18899973 -2642347, 18651869 -3748726, 18351356 -4958346, 17960498 -6322823, 17404561 -7918366, 16514601 -9855937, 14851845 -12232940, 13760912 -13248201))')
 -    def testSplitGeometryAtDateline(self):
 +    def testSplitGeometryAtAntimeridian(self):
         da = QgsDistanceArea()
         crs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.EpsgCrsId)
         da.setSourceCrs(crs, QgsProject.instance().transformContext())
         da.setEllipsoid("WGS84")
         # noops
 -        g = da.splitGeometryAtDateLine(QgsGeometry())
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry())
         self.assertTrue(g.isNull())
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('Point(1 2)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('Point(1 2)'))
         self.assertEqual(g.asWkt(), 'Point (1 2)')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('MultiPoint(1 2, 3 4)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('MultiPoint(1 2, 3 4)'))
         self.assertEqual(g.asWkt(), 'MultiPoint ((1 2),(3 4))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('PointZ(1 2 3)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('PointZ(1 2 3)'))
         self.assertEqual(g.asWkt(), 'PointZ (1 2 3)')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('PointM(1 2 3)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('PointM(1 2 3)'))
         self.assertEqual(g.asWkt(), 'PointM (1 2 3)')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString()'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString()'))
         self.assertEqual(g.asWkt(), 'MultiLineString ()')
         # lines
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString(0 0, -170 0)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString(0 0, -170 0)'))
         self.assertEqual(g.asWkt(), 'MultiLineString ((0 0, -170 0))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString(-170 0, 0 0)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString(-170 0, 0 0)'))
         self.assertEqual(g.asWkt(), 'MultiLineString ((-170 0, 0 0))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString(179 0, -179 0)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString(179 0, -179 0)'))
         self.assertEqual(g.asWkt(), 'MultiLineString ((179 0, 180 0),(-180 0, -179 0))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString(179 0, 181 0)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString(179 0, 181 0)'))
         self.assertEqual(g.asWkt(), 'MultiLineString ((179 0, 180 0),(-180 0, -179 0))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString(-179 0, 179 0)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString(-179 0, 179 0)'))
         self.assertEqual(g.asWkt(), 'MultiLineString ((-179 0, -180 0),(180 0, 179 0))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString(181 0, 179 0)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString(181 0, 179 0)'))
         self.assertEqual(g.asWkt(), 'MultiLineString ((-179 0, -180 0),(180 0, 179 0))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString(179 10, -179 -20)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString(179 10, -179 -20)'))
         self.assertEqual(g.asWkt(3), 'MultiLineString ((179 10, 180 -5.362),(-180 -5.362, -179 -20))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString(179 -80, -179 70)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString(179 -80, -179 70)'))
         self.assertEqual(g.asWkt(3), 'MultiLineString ((179 -80, 180 -55.685),(-180 -55.685, -179 70))')
         # multiline input
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('MultiLineString((1 10, 50 30),(179 -80, -179 70))'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('MultiLineString((1 10, 50 30),(179 -80, -179 70))'))
         self.assertEqual(g.asWkt(3), 'MultiLineString ((1 10, 50 30),(179 -80, 180 -55.685),(-180 -55.685, -179 70))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('MultiLineString((1 10, 50 30),(179 -80, 179.99 70))'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('MultiLineString((1 10, 50 30),(179 -80, 179.99 70))'))
         self.assertEqual(g.asWkt(3), 'MultiLineString ((1 10, 50 30),(179 -80, 179.99 70))')
         # with z/m
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineStringZ(179 -80 1, -179 70 10)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineStringZ(179 -80 1, -179 70 10)'))
         self.assertEqual(g.asWkt(3), 'MultiLineStringZ ((179 -80 1, 180 -55.685 2.466),(-180 -55.685 2.466, -179 70 10))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineStringM(179 -80 1, -179 70 10)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineStringM(179 -80 1, -179 70 10)'))
         self.assertEqual(g.asWkt(3), 'MultiLineStringM ((179 -80 1, 180 -55.685 2.466),(-180 -55.685 2.466, -179 70 10))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineStringZM(179 -80 1 -4, -179 70 10 -30)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineStringZM(179 -80 1 -4, -179 70 10 -30)'))
         self.assertEqual(g.asWkt(3), 'MultiLineStringZM ((179 -80 1 -4, 180 -55.685 2.466 -8.234),(-180 -55.685 2.466 -8.234, -179 70 10 -30))')
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('MultiLineStringZ((179 -80 1, -179 70 10),(-170 -5 1, -181 10 5))'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('MultiLineStringZ((179 -80 1, -179 70 10),(-170 -5 1, -181 10 5))'))
         self.assertEqual(g.asWkt(3), 'MultiLineStringZ ((179 -80 1, 180 -55.685 2.466),(-180 -55.685 2.466, -179 70 10),(-170 -5 1, -181 10 5))')
         # different ellipsoid - should change intersection latitude
         da.setEllipsoid("Phobos2000")
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString(179 10, -179 -20)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString(179 10, -179 -20)'))
         self.assertEqual(g.asWkt(3), 'MultiLineString ((179 10, 180 -5.459),(-180 -5.459, -179 -20))')
         # with reprojection
         da.setEllipsoid("WGS84")
         # with reprojection
         da.setSourceCrs(QgsCoordinateReferenceSystem('EPSG:3857'), QgsProject.instance().transformContext())
 -        g = da.splitGeometryAtDateLine(QgsGeometry.fromWkt('LineString( -13536427 14138932, 13760912 -13248201)'))
 +        g = da.splitGeometryAtAntimeridian(QgsGeometry.fromWkt('LineString( -13536427 14138932, 13760912 -13248201)'))
         self.assertEqual(g.asWkt(1), 'MultiLineString ((-13536427 14138932, -20037508.3 2933521.7),(20037508.3 2933521.7, 13760912 -13248201))')