File indexing completed on 2024-05-05 03:49:52

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2007-2008 Inge Wallin <ingwa@kde.org>
 // SPDX-FileCopyrightText: 2007-2012 Torsten Rahn <rahn@kde.org>
 //
 
 
 // Local
 #include "MercatorProjection.h"
 
 #include "MarbleDebug.h"
 
 // Marble
 #include "ViewportParams.h"
 #include "GeoDataLatLonAltBox.h"
 
 #include "MathHelper.h"
 #include "GeoDataPoint.h"
 #include "MarbleMath.h"
 
 #include <QIcon>
 
 using namespace Marble;
 
 MercatorProjection::MercatorProjection()
     : CylindricalProjection(),
       m_lastCenterLat(200.0),
       m_lastCenterLatInv(0.0)
 {
     setMinLat( minValidLat() );
     setMaxLat( maxValidLat() );
 }
 
 MercatorProjection::~MercatorProjection()
 {
 }
 
 QString MercatorProjection::name() const
 {
     return QObject::tr( "Mercator" );
 }
 
 QString MercatorProjection::description() const
 {
     return QObject::tr( "<p><b>Mercator Projection</b></p><p>Applications: popular standard map projection for navigation.</p>" );
 }
 
 QIcon MercatorProjection::icon() const
 {
     return QIcon(QStringLiteral(":/icons/map-mercator.png"));
 }
 
 qreal MercatorProjection::maxValidLat() const
 {
     // This is the max value where gd( lat ) is defined.
     return +85.05113 * DEG2RAD;
 }
 
 qreal MercatorProjection::minValidLat() const
 {
     // This is the min value where gd( lat ) is defined.
     return -85.05113 * DEG2RAD;
 }
 
 bool MercatorProjection::screenCoordinates( const GeoDataCoordinates &geopoint, 
                                             const ViewportParams *viewport,
                                             qreal &x, qreal &y, bool &globeHidesPoint ) const
 {
     globeHidesPoint = false;
     qreal  lon;
     qreal  originalLat;
 
     geopoint.geoCoordinates( lon, originalLat );
     qreal const lat = qBound(minLat(), originalLat, maxLat());
     const bool isLatValid = lat == originalLat;
 
     // Convenience variables
     int  radius = viewport->radius();
     qreal  width  = (qreal)(viewport->width());
     qreal  height = (qreal)(viewport->height());
 
     qreal  rad2Pixel = 2 * radius / M_PI;
 
     const qreal centerLon = viewport->centerLongitude();
     const qreal centerLat = viewport->centerLatitude();
     if (centerLat != m_lastCenterLat) {
         m_lastCenterLatInv = gdInv(centerLat);
         m_lastCenterLat = centerLat;
     }
 
     // Let (x, y) be the position on the screen of the placemark..
     x = ( width  / 2 + rad2Pixel * ( lon - centerLon ) );
     y = ( height / 2 - rad2Pixel * ( gdInv( lat ) - m_lastCenterLatInv ) );
 
     // Return true if the calculated point is inside the screen area,
     // otherwise return false.
     return isLatValid && ( ( 0 <= y && y < height )
                   && ( ( 0 <= x && x < width )
                   || ( 0 <= x - 4 * radius && x - 4 * radius < width )
                   || ( 0 <= x + 4 * radius && x + 4 * radius < width ) ) );
 }
 
 bool MercatorProjection::screenCoordinates( const GeoDataCoordinates &coordinates,
                                             const ViewportParams *viewport,
                                             qreal *x, qreal &y, int &pointRepeatNum,
                                             const QSizeF& size,
                                             bool &globeHidesPoint ) const
 {
     pointRepeatNum = 0;
     // On flat projections the observer's view onto the point won't be 
     // obscured by the target planet itself.
     globeHidesPoint = false;
 
     // Convenience variables
     int  radius = viewport->radius();
     qreal  width  = (qreal)(viewport->width());
     qreal  height = (qreal)(viewport->height());
 
     // Let (itX, y) be the first guess for one possible position on screen..
     qreal itX;
     bool visible = screenCoordinates( coordinates, viewport, itX, y);
 
     // Make sure that the requested point is within the visible y range:
     if ( 0 <= y + size.height() / 2.0 && y < height + size.height() / 2.0 ) {
         // For the repetition case the same geopoint gets displayed on 
         // the map many times.across the longitude.
 
         int xRepeatDistance = 4 * radius;
 
         // Finding the leftmost positive x value
         if ( itX + size.width() / 2.0 >= xRepeatDistance ) {
             const int repeatNum = (int)( ( itX + size.width() / 2.0 ) / xRepeatDistance );
             itX = itX - repeatNum * xRepeatDistance;
         }
         if ( itX + size.width() / 2.0 < 0 ) {
             itX += xRepeatDistance;
         }
         // the requested point is out of the visible x range:
         if ( itX > width + size.width() / 2.0 ) {
             return false;
         }
 
         // Now iterate through all visible x screen coordinates for the point 
         // from left to right.
         int itNum = 0;
         while ( itX - size.width() / 2.0 < width ) {
             *x = itX;
             ++x;
             ++itNum;
             itX += xRepeatDistance;
         }
 
         pointRepeatNum = itNum;
 
         return visible;
     }
 
     // the requested point is out of the visible y range:
     return false;
 }
 
 
 bool MercatorProjection::geoCoordinates( const int x, const int y,
                                          const ViewportParams *viewport,
                                          qreal& lon, qreal& lat,
                                          GeoDataCoordinates::Unit unit ) const
 {
     const int radius = viewport->radius();
     Q_ASSERT( radius > 0 );
 
     // Calculate translation of center point
     const qreal centerLon = viewport->centerLongitude();
     const qreal centerLat = viewport->centerLatitude();
 
     // Calculate how many pixel are being represented per radians.
     const float rad2Pixel = (qreal)( 2 * radius )/M_PI;
     const qreal pixel2Rad = M_PI / (2 * radius);
 
     {
         const int halfImageWidth = viewport->width() / 2;
         const int xPixels = x - halfImageWidth;
         lon = xPixels * pixel2Rad + centerLon;
 
         while ( lon > M_PI )  lon -= 2*M_PI;
         while ( lon < -M_PI ) lon += 2*M_PI;
 
         if ( unit == GeoDataCoordinates::Degree ) {
             lon *= RAD2DEG;
         }
     }
 
     {
         const int halfImageHeight    = viewport->height() / 2;
         const int yCenterOffset = (int)( asinh( tan( centerLat ) ) * rad2Pixel  );
         const int yTop          = halfImageHeight - 2 * radius + yCenterOffset;
         const int yBottom       = yTop + 4 * radius;
         if ( y >= yTop && y < yBottom ) {
             lat = gd( ( ( halfImageHeight + yCenterOffset ) - y)
                               * pixel2Rad );
 
             if ( unit == GeoDataCoordinates::Degree ) {
                 lat *= RAD2DEG;
             }
 
             return true; // lat successfully calculated
         }
     }
 
     return false; // lat unchanged
 }
 
 
 GeoDataLatLonAltBox MercatorProjection::latLonAltBox( const QRect& screenRect,
                                                       const ViewportParams *viewport ) const
 {
     qreal west;
     qreal north = 85*DEG2RAD;
     geoCoordinates( screenRect.left(), screenRect.top(), viewport, west, north, GeoDataCoordinates::Radian );
 
     qreal east;
     qreal south = -85*DEG2RAD;
     geoCoordinates( screenRect.right(), screenRect.bottom(), viewport, east, south, GeoDataCoordinates::Radian );
 
     // For the case where the whole viewport gets covered there is a
     // pretty dirty and generic detection algorithm:
     GeoDataLatLonAltBox latLonAltBox;
     latLonAltBox.setNorth( north, GeoDataCoordinates::Radian );
     latLonAltBox.setSouth( south, GeoDataCoordinates::Radian );
     latLonAltBox.setWest( west, GeoDataCoordinates::Radian );
     latLonAltBox.setEast( east, GeoDataCoordinates::Radian );
     latLonAltBox.setMinAltitude(      -100000000.0 );
     latLonAltBox.setMaxAltitude( 100000000000000.0 );
 
     // The remaining algorithm should be pretty generic for all kinds of 
     // flat projections:
 
     // If the whole globe is visible we can easily calculate
     // analytically the lon-/lat- range.
     // qreal pitch = GeoDataPoint::normalizeLat( viewport->planetAxis().pitch() );
 
     int xRepeatDistance = 4 * viewport->radius();
     if ( viewport->width() >= xRepeatDistance ) {
         latLonAltBox.setWest( -M_PI );
         latLonAltBox.setEast( +M_PI );
     }
 
     return latLonAltBox;
 }
 
 
 bool MercatorProjection::mapCoversViewport( const ViewportParams *viewport ) const
 {
     int           radius = viewport->radius();
     int           height = viewport->height();
 
     // Calculate translation of center point
     const qreal centerLat = viewport->centerLatitude();
 
     // Calculate how many pixel are being represented per radians.
     const float rad2Pixel = (float)( 2 * radius )/M_PI;
 
     int yCenterOffset = (int)( asinh( tan( centerLat ) ) * rad2Pixel  );
     int yTop          = height / 2 - 2 * radius + yCenterOffset;
     int yBottom       = yTop + 4 * radius;
 
     return !(yTop >= 0 || yBottom < height);
 }