#include <math.h>

//-----------------------------------------------------------------------------------

bool Bitmap::ImplScaleConvolution( const double& rScaleX, const double& rScaleY, Kernel& aKernel )

{

    const long  nWidth = GetSizePixel().Width();

    const long  nHeight = GetSizePixel().Height();

    const long  nNewWidth = FRound( nWidth * rScaleX );

    const long  nNewHeight = FRound( nHeight * rScaleY );

    bool bResult;

    BitmapReadAccess* pReadAcc;

    Bitmap aNewBitmap;

    int aNumberOfContributions;

    double* pWeights;

    int* pPixels;

    int* pCount;

    // Do horizontal filtering

    ImplCalculateContributions( nWidth, nNewWidth, aNumberOfContributions, pWeights, pPixels, pCount, aKernel );

    pReadAcc = AcquireReadAccess();

    aNewBitmap = Bitmap( Size( nHeight, nNewWidth ), 24);

    bResult = ImplConvolutionPass( aNewBitmap, nNewWidth, pReadAcc, aNumberOfContributions, pWeights, pPixels, pCount );

    ReleaseAccess( pReadAcc );

    delete[] pWeights;

    delete[] pCount;

    delete[] pPixels;

    if ( !bResult )

        return bResult;

    // Swap Bitmaps

    ImplAssignWithSize( aNewBitmap );

    // Do vertical filtering

    ImplCalculateContributions( nHeight, nNewHeight, aNumberOfContributions, pWeights, pPixels, pCount, aKernel );

    pReadAcc = AcquireReadAccess();

    aNewBitmap = Bitmap( Size( nNewWidth, nNewHeight ), 24);

    bResult = ImplConvolutionPass( aNewBitmap, nNewHeight, pReadAcc, aNumberOfContributions, pWeights, pPixels, pCount );

    ReleaseAccess( pReadAcc );

    delete[] pWeights;

    delete[] pCount;

    delete[] pPixels;

    if ( !bResult )

        return bResult;

    ImplAssignWithSize( aNewBitmap );

    return true;

}

void Bitmap::ImplCalculateContributions( const int aSourceSize, const int aDestinationSize, int& aNumberOfContributions,

                                            double*& pWeights, int*& pPixels, int*& pCount, Kernel& aKernel)

{

    const double aSamplingRadius = aKernel.GetWidth();

    const double aScale = aDestinationSize / (double) aSourceSize;

    const double aScaledRadius = (aScale < 1.0) ? aSamplingRadius / aScale : aSamplingRadius;

    const double aFilterFactor = (aScale < 1.0) ? aScale : 1.0;

    aNumberOfContributions  = (int) ( 2 * ceil(aScaledRadius) + 1 );

    pWeights = new double[ aDestinationSize*aNumberOfContributions ];

    pPixels = new int[ aDestinationSize*aNumberOfContributions ];

    pCount = new int[ aDestinationSize ];

    double aWeight, aCenter;

    int aIndex, aLeft, aRight;

    int aPixelIndex, aCurrentCount;

    for ( int i = 0; i < aDestinationSize; i++ )

    {

        aIndex = i * aNumberOfContributions;

        aCurrentCount = 0;

        aCenter = i / aScale;

        aLeft  = (int) floor(aCenter - aScaledRadius);

        aRight = (int) ceil (aCenter + aScaledRadius);

        for ( int j = aLeft; j <= aRight; j++ )

        {

            aWeight = aKernel.Calculate( aFilterFactor * ( aCenter - (double) j ) );

            // Reduce calculations with ignoring weights of 0.0

            if (fabs(aWeight) < 0.0001)

                continue;

            // Handling on edges

            aPixelIndex = MinMax( j, 0, aSourceSize - 1);

            pWeights[ aIndex + aCurrentCount ] = aWeight;

            pPixels[ aIndex + aCurrentCount ] = aPixelIndex;

            aCurrentCount++;

        }

        pCount[ i ] = aCurrentCount;

    }

}

bool Bitmap::ImplConvolutionPass(Bitmap& aNewBitmap, const int nNewSize, BitmapReadAccess* pReadAcc, int aNumberOfContributions, double* pWeights, int* pPixels, int* pCount)

{

    BitmapWriteAccess* pWriteAcc = aNewBitmap.AcquireWriteAccess();

    if (!pReadAcc || !pWriteAcc)

        return false;

    const int nHeight = GetSizePixel().Height();

    BitmapColor aColor;

    double aValueRed, aValueGreen, aValueBlue;

    double aSum, aWeight;

    int aBaseIndex, aIndex;

    for ( int y = 0; y < nHeight; y++ )

    {

        for ( int x = 0; x < nNewSize; x++ )

        {

            aBaseIndex = x * aNumberOfContributions;

            aSum = aValueRed = aValueGreen = aValueBlue = 0.0;

            for ( int j=0; j < pCount[x]; j++ )

            {

                aIndex = aBaseIndex + j;

                aSum += aWeight = pWeights[ aIndex ];

                aColor = pReadAcc->GetPixel( y, pPixels[ aIndex ] );

                if( pReadAcc->HasPalette() )

                    aColor = pReadAcc->GetPaletteColor( aColor );

                aValueRed   += aWeight * aColor.GetRed();

                aValueGreen += aWeight * aColor.GetGreen();

                aValueBlue  += aWeight * aColor.GetBlue();

            }

            BitmapColor aResultColor(

                (sal_uInt8) MinMax( aValueRed   / aSum, 0, 255 ),

                (sal_uInt8) MinMax( aValueGreen / aSum, 0, 255 ),

                (sal_uInt8) MinMax( aValueBlue  / aSum, 0, 255 ) );

            pWriteAcc->SetPixel( x, y, aResultColor );

        }

    }

    aNewBitmap.ReleaseAccess( pWriteAcc );

    return true;

}

// --------------------

// Resample Kernels

// --------------------

class Kernel

{

public:

    Kernel () {}

    virtual ~Kernel() {}

    virtual double GetWidth() = 0;

    virtual double Calculate( double x ) = 0;

};

class Lanczos3Kernel : public Kernel

{

public:

    virtual double GetWidth() { return 3.0; }

    virtual double Calculate (double x)

    {

        return (-3.0 <= x && x < 3.0) ? SincFilter(x) * SincFilter( x / 3.0 ) : 0.0;

    }

    inline double SincFilter(double x)

    {

        if (x == 0.0)

        {

            return 1.0;

        }

        x = x * M_PI;

        return sin(x) / x;

    }

};

class BicubicKernel : public Kernel {

    virtual double GetWidth() { return 2.0; }

    virtual double Calculate (double x)

    {

        if (x < 0.0)

        {

            x = -x;

        }

        if (x <= 1.0)

        {

            return (1.5 * x - 2.5) * x * x + 1.0;

        }

        else if (x < 2.0)

        {

            return ((-0.5 * x + 2.5) * x - 4) * x + 2;

        }

        return 0.0;

    }

};

class BilinearKernel : public Kernel {

    virtual double GetWidth() { return 1.0; }

    virtual double Calculate (double x)

    {

        if (x < 0.0)

        {

            x = -x;

        }

        if (x < 1.0)

        {

            return 1.0-x;

        }

        return 0.0;

    }

};

class BoxKernel : public Kernel {

    virtual double GetWidth() { return 0.5; }

    virtual double Calculate (double x)

    {

        if (-0.5 <= x && x < 0.5)

            return 1.0;

        return 0.0;

    }

};

    SAL_DLLPRIVATE bool                 ImplScaleConvolution( const double& rScaleX, const double& rScaleY, Kernel& aKernel);

    SAL_DLLPRIVATE bool                 ImplTransformAveraging( const double& rScaleX, const double& rScaleY,

                                                const Rectangle& rRotatedRectangle, const long nAngle10, const Color& rFillColor );

    SAL_DLLPRIVATE bool                 ImplTransformBilinearFiltering( const double& rScaleX, const double& rScaleY,

                                                const Rectangle& rRotatedRectangle, const long nAngle10, const Color& rFillColor );

    SAL_DLLPRIVATE static void          ImplCalculateContributions( const int aSourceSize, const int aDestinationSize,

                                                int& aNumberOfContributions, double*& pWeights, int*& pPixels, int*& pCount,

                                                Kernel& aKernel );

    SAL_DLLPRIVATE bool                 ImplConvolutionPass( Bitmap& aNewBitmap, const int nNewSize, BitmapReadAccess* pReadAcc,

                                                int aNumberOfContributions, double* pWeights, int* pPixels, int* pCount );