File indexing completed on 2025-01-05 03:58:43

 // SPDX-FileCopyrightText: 2010 Jens-Michael Hoffmann <jmho@c-xx.com>
 //
 // SPDX-License-Identifier: LGPL-2.1-or-later
 
 #include "SunLightBlending.h"
 
 #include <cmath>
 
 #include <QImage>
 #include <QColor>
 
 #include "SunLocator.h"
 #include "TextureTile.h"
 #include "TileLoaderHelper.h"
 #include "MarbleGlobal.h"
 
 #include "digikam_debug.h"
 
 namespace Marble
 {
 
 SunLightBlending::SunLightBlending( const SunLocator * sunLocator )
     : Blending(),
       m_sunLocator( sunLocator ),
       m_levelZeroColumns( 0 ),
       m_levelZeroRows( 0 )
 {
 }
 
 SunLightBlending::~SunLightBlending()
 {
 }
 
 void SunLightBlending::blend( QImage * const tileImage, TextureTile const * const top ) const
 {
     if ( tileImage->depth() != 32 )
         return;
 
     // TODO add support for 8-bit maps?
     // add sun shading
     const TileId id = top->id();
     const qreal  global_width  = tileImage->width()
         * TileLoaderHelper::levelToColumn( m_levelZeroColumns, id.zoomLevel() );
     const qreal  global_height = tileImage->height()
         * TileLoaderHelper::levelToRow( m_levelZeroRows, id.zoomLevel() );
     const qreal lon_scale = 2*M_PI / global_width;
     const qreal lat_scale = -M_PI / global_height;
     const int tileHeight = tileImage->height();
     const int tileWidth = tileImage->width();
 
     // First we determine the supporting point interval for the interpolation.
     const int n = maxDivisor( 30, tileWidth );
     const int ipRight = n * (int)( tileWidth / n );
 
     const QImage *nighttile = top->image();
 
     for ( int cur_y = 0; cur_y < tileHeight; ++cur_y ) {
         const qreal lat = lat_scale * ( id.y() * tileHeight + cur_y ) - 0.5*M_PI;
         const qreal a = sin( ( lat+DEG2RAD * m_sunLocator->getLat() )/2.0 );
         const qreal c = cos(lat)*cos( -DEG2RAD * m_sunLocator->getLat() );
 
         QRgb* scanline  = (QRgb*)tileImage->scanLine( cur_y );
         const QRgb* nscanline = (QRgb*)nighttile->scanLine( cur_y );
 
         qreal lastShade = -10.0;
 
         int cur_x = 0;
 
         while ( cur_x < tileWidth ) {
 
             const bool interpolate = ( cur_x != 0 && cur_x < ipRight && cur_x + n < tileWidth );
 
             qreal shade = 0;
 
             if ( interpolate ) {
                 const int check = cur_x + n;
                 const qreal checklon   = lon_scale * ( id.x() * tileWidth + check );
                 shade = m_sunLocator->shading( checklon, a, c );
 
                 // if the shading didn't change across the interpolation
                 // interval move on and don't change anything.
                 if ( shade == lastShade && shade == 1.0 ) {
                     scanline += n;
                     nscanline += n;
                     cur_x += n;
                     continue;
                 }
                 if ( shade == lastShade && shade == 0.0 ) {
                     for ( int t = 0; t < n; ++t ) {
                         SunLocator::shadePixelComposite(*scanline, *nscanline, shade);
                         ++scanline;
                         ++nscanline;
                     }
                     cur_x += n;
                     continue;
                 }
 
                 qreal lon = lon_scale * (id.x() * tileWidth + cur_x);
                 for ( int t = 0; t < n ; ++t ) {
                     shade = m_sunLocator->shading( lon, a, c );
                     SunLocator::shadePixelComposite(*scanline, *nscanline, shade);
                     ++scanline;
                     ++nscanline;
                     lon += lon_scale;
                 }
                 cur_x += n;
             }
 
             else {
                 // Make sure we don't exceed the image memory
                 if ( cur_x < tileWidth ) {
                     qreal lon   = lon_scale * ( id.x() * tileWidth + cur_x );
                     shade = m_sunLocator->shading( lon, a, c );
                     SunLocator::shadePixelComposite(*scanline, *nscanline, shade);
                     ++scanline;
                     ++nscanline;
                     ++cur_x;
                 }
             }
             lastShade = shade;
         }
     }
 }
 
 void SunLightBlending::setLevelZeroLayout( int levelZeroColumns, int levelZeroRows )
 {
     m_levelZeroColumns = levelZeroColumns;
     m_levelZeroRows = levelZeroRows;
 }
 
 // TODO: This should likely go into a math class in the future ...
 int SunLightBlending::maxDivisor( int maximum, int fullLength )
 {
     // Find the optimal interpolation interval n for the
     // current image canvas width
     int best = 2;
 
     int nEvalMin = fullLength;
     for ( int it = 1; it <= maximum; ++it ) {
         // The optimum is the interval which results in the least amount
         // supporting points taking into account the rest which can't
         // get used for interpolation.
         int nEval = fullLength / it + fullLength % it;
         if ( nEval < nEvalMin ) {
             nEvalMin = nEval;
             best = it;
         }
     }
     return best;
 }
 
 }