F:/My Projects/LSEngine/Modules/LSImageLib/Src/Resampler/LSIResampler.h

#ifndef __LSI_RESAMPLER_H__
#define __LSI_RESAMPLER_H__

#include "../LSIImageLib.h"

namespace lsi {

        class CResampler {
        public :
                // == Various constructors.
                LSE_CALLCTOR                                                            CResampler();
                LSE_CALLCTOR                                                            ~CResampler();


                // == Enumerations.
                enum {
                        LSI_MAX_SCANLINE                                                = 16384
                };


                // == Types.
                typedef struct LSI_CONTRIB {
                        LSFLOAT                                                                 fWeight;

                        LSUINT16                                                                ui16Value;
                } * LPLSI_CONTRIB, * const LPCLSI_CONTRIB;

                typedef struct LSI_CONTRIB_EX {
                        LSI_CONTRIB *                                                   pcValues;

                        LSUINT32                                                                ui32N;
                } * LPLSI_CONTRIB_EX, * const LPCLSI_CONTRIB_EX;

                typedef struct LSI_CONTRIB_LIST {
                        CVectorPoD<LSI_CONTRIB, LSUINT32>               vPool;

                        CVectorPoD<LSI_CONTRIB_EX, LSUINT32>    vList;
                } * LPLSI_CONTRIB_LIST, * const LPCLSI_CONTRIB_LIST;

                typedef struct LSI_SCANLINE {
                        LSFLOAT *                                                               pfScanBufL[LSI_MAX_SCANLINE];

                        LSINT32                                                                 i32ScanBufY[LSI_MAX_SCANLINE];
                } * LPLSI_SCANLINE, * const LPCLSI_SCANLINE;

                typedef LSFLOAT (LSE_CALL *                                     PfFilterFunc)( LSFLOAT _fT );

                typedef struct LSI_FILTER {
                        const LSCHAR *                                                  pcName;

                        PfFilterFunc                                                    pfFunc;

                        LSFLOAT                                                                 pfSupport;
                } * LPLSI_FILTER, * const LPCLSI_FILTER;


                // == Functions.
                LSSTD_ERRORS LSE_CALL                                           InitResampler( LSUINT32 _ui32SrcWidth, LSUINT32 _ui32SrcHeight,
                        LSUINT32 _ui32DstWidth, LSUINT32 _ui32DstHeight,
                        LSFLOAT _fSampleLow = 0.0f, LSFLOAT _fSampleHi = 1.0f,
                        const LSCHAR * _pcFilter = "lanczos4",
                        LSI_CONTRIB_LIST * _pclContX = NULL,
                        LSI_CONTRIB_LIST * _pclContY = NULL,
                        LSFLOAT _fFilterScaleX = 1.0f,
                        LSFLOAT _fFilterScaleY = 1.0f,
                        CVectorPoD<LSFLOAT, LSUINT32> * _pvDstBuffer = NULL );

                LSI_CONTRIB_LIST * LSE_CALL                                     GetContribX();

                LSI_CONTRIB_LIST * LSE_CALL                                     GetContribY();

                LSBOOL LSE_CALL                                                         AddScanLine( const LSFLOAT * _pfScanline );

                const CVectorPoD<LSFLOAT, LSUINT32> * LSE_CALL
                                                                                                        GetScanLine();


        protected :
                // == Types.
                typedef struct LSI_CONTRIB_BOUNDS {
                        LSFLOAT                                                                 fCenter;

                        LSINT32                                                                 i32Left;

                        LSINT32                                                                 i32Right;
                } * LPLSI_CONTRIB_BOUNDS, * const LPCLSI_CONTRIB_BOUNDS;
                
                // == Members.
                LSI_CONTRIB_LIST *                                                      m_pclContribsX;

                LSI_CONTRIB_LIST *                                                      m_pclContribsY;

                LSI_FILTER *                                                            m_pfFilter;

                LSBOOL                                                                          m_bBorrowedX;

                LSBOOL                                                                          m_bBorrowedY;

                LSFLOAT                                                                         m_fLow;

                LSFLOAT                                                                         m_fHi;

                LSUINT32                                                                        m_ui32SrcWidth;

                LSUINT32                                                                        m_ui32SrcHeight;

                LSUINT32                                                                        m_ui32DstWidth;

                LSUINT32                                                                        m_ui32DstHeight;

                LSUINT32                                                                        m_ui32CurSrcY;

                LSUINT32                                                                        m_ui32CurDstY;

                LSUINT32                                                                        m_ui32IntermX;

                LSBOOL                                                                          m_bDelayX;

                mutable CVectorPoD<LSINT32, LSUINT32>           m_vSrcCountY;

                mutable CVectorPoD<LSUINT8, LSUINT32>           m_vSrcFlagsY;

                CVectorPoD<LSFLOAT, LSUINT32> *                         m_pvDstBuffer;

                mutable CVectorPoD<LSFLOAT, LSUINT32>           m_vTempBuffer;

                LSI_SCANLINE *                                                          m_psScanBuffer;

                CVectorPoD<LSFLOAT, LSUINT32>                           m_vScanBufferChunk;

                LSUINT32                                                                        m_ui32ScanChunkPos;

                LSUINT32                                                                        m_ui32LastSearchPos;

                static LSI_FILTER                                                       m_fFilters[];


                // == Functions.
                LSVOID LSE_CALL                                                         ResampleX( LSFLOAT * _pfDst, const LSFLOAT * _pfSrc ) const;

                LSVOID LSE_CALL                                                         ResampleY( CVectorPoD<LSFLOAT, LSUINT32> &_vDst ) const;

                static LSVOID LSE_CALL                                          ScaleY( CVectorPoD<LSFLOAT, LSUINT32> &_pfDst, const LSFLOAT * _pfSrc, LSFLOAT _fScale, LSUINT32 _ui32Total );

                static LSVOID LSE_CALL                                          ScaleYAdd( CVectorPoD<LSFLOAT, LSUINT32> &_pfDst, const LSFLOAT * _pfSrc, LSFLOAT _fScale, LSUINT32 _ui32Total );

                static LSVOID LSE_CALL                                          ClampSamples( LSFLOAT * _pfSamples, LSUINT32 _ui32Total, LSFLOAT _fLo, LSFLOAT _fHi );

                static LSI_CONTRIB_LIST *                                       CreateContribList( LSUINT32 _ui32SrcSize, LSUINT32 _ui32DstSize,
                        PfFilterFunc _pfFilter, LSFLOAT _fFilterSupport, LSFLOAT _fFilterScale );

                static LSINT32 LSE_CALL                                         ClampTexel( LSINT32 _i32TexelPos, LSUINT32 _ui32Size );

                static LSUINT32 LSE_CALL                                        CountOps( const LSI_CONTRIB_LIST &_clList );

                static LSE_INLINE LSFLOAT LSE_CALL                      Clean( LSDOUBLE _dVal );

                static LSE_INLINE LSDOUBLE LSE_CALL                     KaiserHelper( LSDOUBLE _dAlpha, LSDOUBLE _dHalfWidth, LSDOUBLE _dX );

                static LSE_INLINE LSFLOAT LSE_CALL                      MitchellFilterHelper( LSFLOAT _fT, LSFLOAT _fB, LSFLOAT _fC );

                static LSE_INLINE LSDOUBLE LSE_CALL                     Bessel0( LSDOUBLE _dX );

                static LSE_INLINE LSDOUBLE LSE_CALL                     SinC( LSDOUBLE _dX );

                static LSFLOAT LSE_CALL                                         BoxFilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         BilinearFilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         KaiserFilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         Lanczos3FilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         Lanczos4FilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         Lanczos6FilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         Lanczos8FilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         Lanczos12FilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         Lanczos64FilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         MitchellFilterFunc( LSFLOAT _fT );

                static LSFLOAT LSE_CALL                                         CatmullRomFilterFunc( LSFLOAT _fT );
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Functions.
         LSE_INLINE LSFLOAT LSE_CALL CResampler::Clean( LSDOUBLE _dVal ) {
                 static const LSDOUBLE dEps = 0.0000125;
                 return ::fabs( _dVal ) >= dEps ? static_cast<LSFLOAT>(_dVal) : 0.0f;
         }

         LSE_INLINE LSDOUBLE LSE_CALL CResampler::KaiserHelper( LSDOUBLE _dAlpha, LSDOUBLE _dHalfWidth, LSDOUBLE _dX ) {
                const LSDOUBLE dRatio = _dX / _dHalfWidth;
                return Bessel0( _dAlpha * ::sqrt( 1.0 - dRatio * dRatio ) ) / Bessel0( _dAlpha );
         }

         LSE_INLINE LSFLOAT LSE_CALL CResampler::MitchellFilterHelper( LSFLOAT _fT, LSFLOAT _fB, LSFLOAT _fC ) {

                LSFLOAT fTt = _fT * _fT;
                _fT = ::fabsf( _fT );
                if ( _fT < 1.0f ) {
                        _fT = (((12.0f - 9.0f * _fB - 6.0f * _fC) * (_fT * fTt))
                                + ((-18.0f + 12.0f * _fB + 6.0f * _fC) * fTt)
                                + (6.0f - 2.0f * _fB));
                        return _fT / 6.0f;
                }
                else if ( _fT < 2.0f ) {
                        _fT = (((-1.0f * _fB - 6.0f * _fC) * (_fT * fTt))
                                + ((6.0f * _fB + 30.0f * _fC) * fTt)
                                + ((-12.0f * _fB - 48.0f * _fC) * _fT)
                                + (8.0f * _fB + 24.0f * _fC));

                        return (_fT / 6.0f);
                }

                return 0.0f;
         }

         LSE_INLINE LSDOUBLE LSE_CALL CResampler::Bessel0( LSDOUBLE _dX ) {
                 static const LSDOUBLE dEspiRatio = 1.0e-16;
                 LSDOUBLE dSum = 1.0, dPow = 1.0, dDs = 1.0, dXh = _dX * 0.5;
                 LSUINT32 ui32K = 0;

                 while ( dDs > dSum * dEspiRatio ) {
                        ++ui32K;
                        dPow *= (dXh / ui32K);
                        dDs = dPow * dPow;
                        dSum += dDs;
                 }

                 return dSum;
         }

         LSE_INLINE LSDOUBLE LSE_CALL CResampler::SinC( LSDOUBLE _dX ) {
                _dX *= LSM_PI_DOUBLE;
                if ( _dX < 0.01 && _dX > -0.01 ) {
                        return 1.0 + _dX * _dX * (-1.0 / 6.0 + _dX * _dX * 1.0 / 120.0);
                }

                return ::sin( _dX ) / _dX;
         }

}       // namespace lsi

#endif  // __LSI_RESAMPLER_H__