/*
 *   Copyright (C) =USTC= Fu Li
 *
 *   Author   :  Fu Li
 *   Create   :  2005-7-29
 *   Home     :  http://www.crazy-bit.com/
 *   Mail     :  crazybit@263.net
 *   History  :  
 */
#ifndef __FOO_PIXEL_PROCESSOR_BASE__2005_07_29__H__
#define __FOO_PIXEL_PROCESSOR_BASE__2005_07_29__H__
#include "../FHistogram.h"

//class FCInterface_PixelProcess ;
class FCSinglePixelProcessBase ;
    class FCPixelConvertTo16Bit ; // 1, 4, 8, 24, 32 ==> 16
    class FCPixelConvertTo8BitGray ; // 1, 4, 8, 16, 24, 32 ==> 8bit gray
    class FCPixelGrayscale ; // gray scale (>=24 bit)
    class FCPixelFillColor ; // fill color (>=24 bit)
    class FCPixelFillPattern ; // fill pattern (32 bit)
    class FCPixelCombineColor ; // combine color (32 bit)
    class FCPixelHueSaturation ; // hue saturation (>=24 bit)]
    class FCPixelMirror ; // mirror (>=8 bit)
    class FCPixelFlip ; // flip (>=8 bit)
    class FCPixelShift ; // shift (>=24 bit)
    class FCPixelAutoContrast ; // auto contrast (>=24 bit)
    class FCPixelAutoColorEnhance ; // auto color enhance (>=24 bit)
    class FCPixelEmboss ; // emboss (>=24 bit)
    class FCPixelIllusion ; // illusion (>=24 bit)
    class FCPixelBlinds ; // blinds (>=24 bit)
    class FCPixelMosaic ; // mosaic (32 bit)
    class FCPixelFill3DSolidFrame ; // fill 3D solid frame (>=24 bit)
    class FCPixelAdjustRGB ; // adjust RGB (>=24 bit)
    class FCPixelColorLevel ; // color level (>=24 bit)
    class FCPixelThreshold ; // threshold (>=24 bit)
    class FCPixelRotate90 ; // clockwise rotate 90' (>=8 bit)
        class FCPixelRotate270 ; // clockwise rotate 270' (>=8 bit)
    class FCPixelDeinterlace ; // de-interlace (32 bit)
    class FCPixelHalftoneM3 ; // halftone (>=24 bit)
    class FCPixelOilPaint ; // oil paint (>=24 bit)
    class FCPixelColorTone ; // color tone (>=24 bit)
    class FCPixelAddRandomNoise ; // add random noise (>=24 bit)
    class FCPixelSplash ; // splash (>=24 bit)
    class FCPixelVideo ; // video (>=24 bit)
    class FCPixelColorBalance ; // color balance (>=24 bit)
    class FCPixelFillGrid ; // fill grid (>=24 bit)
    class FCPixel3DGrid ; // add 3D grid (>=24 bit)
    class FCPixelMedianFilter ; // Median filter (>=24 bit)
    class FCPixelSpliteChannel_RGB ; // splite RGB channel (>=24 bit)
    class FCPixelCombineChannel_RGB ; // combine RGB channel (>=24 bit)
    class FCPixelConvolute ; // image convolute (>= 24 bit)
        class FCPixelGaussianBlur3x3 ; // Standard 3x3 gaussian blur (>=24 bit)
        class FCPixelGaussianBlur5x5 ; // Standard 5x5 gaussian blur (>=24 bit)
        class FCPixelDetectEdges ; // Detect edges (>=24 bit)
        class FCPixelSharp ; // Sharp (laplacian template) (>=24 bit)
    class FCPixelGradientBase ; // base class of gradient fill (>=24 bit)
        class FCPixelGradientLine ; // gradient fill linear (>=24 bit)
            class FCPixelGradientBiLine ; // gradient fill bilinear (>=24 bit)
            class FCPixelGradientConicalSym ; // gradient fill symmetric conical (>=24 bit)
            class FCPixelGradientConicalASym ; // gradient fill Anti-symmetric conical (>=24 bit)
        class FCPixelGradientRect ; // gradient fill rect (>=24 bit)
        class FCPixelGradientRadial ; // gradient fill radial (>=24 bit)
    class FCPixelBilinearDistord ; // bilinear distord (>=24 bit)
        class FCPixelCylinder ; // cylinder (>=24 bit)
        class FCPixelWave ; // wave (>=24 bit)
        class FCPixelWhirlPinch ; // whirl & pinch (>=24 bit)
        class FCPixelFractalTrace ; // Fractal trace (>=24 bit)
        class FCPixelLens ; // lens (>=24 bit)
        class FCPixelSkew ; // skew transform (>=24 bit)
        class FCPixelPerspective ; // perspective transform (>=24 bit)
        class FCPixelRotate ; // rotate (>=24 bit)
        class FCPixelRibbon ; // ribbon (>=24 bit)
        class FCPixelRipple ; // ripple (>=24 bit)
        class FCPixelSmallTile ; // tile (>=24 bit)
    class FCPixelLUTRoutine ; // LUT(look up table) routine (>=24 bit)
        class FCPixelBrightness ; // adjust brightness (>=24 bit)
        class FCPixelContrast ; // adjust contrast (>=24 bit)
        class FCPixelGamma ; // adjust gamma (>=24 bit)
        class FCPixelInvert ; // negate (>=24 bit)
        class FCPixelSolarize ; // Solarize (>=24 bit)
        class FCPixelPosterize ; // posterize (>=24 bit)
    class FCPixelColorsCount ; // count image's number of color (>=24 bit)
        class FCPixelGetKeyColor ; // Find a color unused in image (>=24 bit)
    class FCPixelWholeImageBase ; // process whole image.
        class FCPixelExportAscII ; // save a ASCII text file (>=24 bit)
        class FCPixelConvertQuantize ; // quantize (Need FREEIMAGE)
        class FCPixelGlasstile ; // glasstile (>=24 bit)
        class FCPixelBlur_Box ; // box smooth (>=24 bit)
        class FCPixelBlur_Zoom ; // blur zoom (>=24 bit)
        class FCPixelBlur_Radial ; // blur radial (>=24 bit)
        class FCPixelBlur_Motion ; // blur motion (>=24 bit)
        class FCPixelBlur_Gauss_IIR ; // blur IIR gauss (>=24 bit)
        class FCPixelInnerBevel ; // add inner bevel frame (>=24 bit)
        class FCPixelSmoothEdge ; // smooth edge (32 bit)
        class FCPixelAddShadow ; // add shadow (32 bit)

//=============================================================================
/**
 *  Base class of processor.
 */
class FCSinglePixelProcessBase : public FCInterface_PixelProcess
{
public:
    FCSinglePixelProcessBase() : m_pImgOld(0) {}
    virtual ~FCSinglePixelProcessBase() {if(m_pImgOld)  delete m_pImgOld;}

    /// whether the image can be disposed by this processor.
    /// default test image's bpp >= 24
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() >= 24) ;
    }

protected:
    void SetBackupImage (const FCObjImage* pImg)
    {
        if (pImg)
        {
            if (m_pImgOld)
                delete m_pImgOld ;
            m_pImgOld = new FCObjImage(*pImg) ;
        }
    }
    FCObjImage* GetBackupImage() const {return m_pImgOld;}

private:
    FCObjImage  * m_pImgOld ; // backup image
};

//=============================================================================
/**
 *  1, 4, 8, 24, 32 ==> 16.
@verbatim
    example:
        FCPixelConvertTo16Bit   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelConvertTo16Bit : public FCSinglePixelProcessBase
{
    virtual bool ValidateColorBits (const FCObjImage* pImg) {return pImg->IsValidImage() && (pImg->ColorBits() != 16) ;}
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage(pImg) ;

        // make it easier, now we only need 24(32) ==> 16
        if (pImg->ColorBits() <= 8)
            GetBackupImage()->ConvertTo24Bit() ;
        pImg->Create (pImg->Width(), pImg->Height(), 16) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        *(WORD*)pPixel = Combine16Bit_555 (GetBackupImage()->GetBits(x,y)) ; // 24,32 ==> 16
    }
    static WORD Combine16Bit_555 (const void* pRGB)
    {
        const WORD   wR = ((PCL_R(pRGB) >> 3) << 10),
                     wG = ((PCL_G(pRGB) >> 3) << 5),
                     wB =  (PCL_B(pRGB) >> 3) ;
        return (wR | wG | wB) ;
    }
};

//=============================================================================
/**
 *  1, 4, 8, 16, 24, 32 ==> 8bit gray.
@verbatim
    example:
        FCPixelConvertTo8BitGray   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelConvertTo8BitGray : public FCSinglePixelProcessBase
{
    virtual bool ValidateColorBits (const FCObjImage* pImg) {return pImg->IsValidImage();}
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage(pImg) ;

        // make it easier, now we only need 24(32) ==> 8bit gray
        if (pImg->ColorBits() <= 16)
            GetBackupImage()->ConvertTo24Bit() ;
        pImg->Create (pImg->Width(), pImg->Height(), 8) ; // default to set a gray palette
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        *pPixel = FCColor::GetGrayscale (GetBackupImage()->GetBits(x,y)) ;
    }
};

//=============================================================================
/**
 *  Gray scale image (>=24 bit).
 *  all channel are same after process.
@verbatim
    example:
        FCPixelGrayscale   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGrayscale : public FCSinglePixelProcessBase
{
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        PCL_R(pPixel) = PCL_G(pPixel) = PCL_B(pPixel) = FCColor::GetGrayscale(pPixel) ;
    }
};

//=============================================================================
/**
 *  Fill color (>=24 bit).
@verbatim
    example:
        const RGBQUAD      cr = PCL_RGBA(0,0,255) ;
        FCPixelFillColor   aCmd (cr, 192) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelFillColor : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    /// @param nAlpha == -1, not fill alpha
    FCPixelFillColor (RGBQUAD crFill, int nAlpha=-1) : m_crFill(crFill), m_nAlpha(nAlpha), m_bIsFillAlpha(false) {}
private:
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        if (pImg->IsValidImage() && (pImg->ColorBits() >= 24))
        {
            m_bIsFillAlpha = ((m_nAlpha != -1) && (pImg->ColorBits() == 32)) ;
            PCL_A(&m_crFill) = m_bIsFillAlpha ? FClamp0255(m_nAlpha) : 0 ;
            return true ;
        }
        return false ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        FCColor::CopyPixel (pPixel, &m_crFill, m_bIsFillAlpha ? 4 : 3) ;
    }

    RGBQUAD   m_crFill ;
    int       m_nAlpha ;
    bool      m_bIsFillAlpha ;
};

//=============================================================================
/**
 *  Fill pattern image (32 bit).
@verbatim
    example:
        FCObjImage           * pMask = new FCObjImage ("c:\\test.jpg") ;
        FCPixelFillPattern   aCmd (pMask, 192, false) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelFillPattern : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelFillPattern (FCObjImage* pPattern, int nAlpha, bool bOnlyTexture) : m_pPattern(pPattern), m_nAlpha(FClamp0255(nAlpha)), m_bOnlyTexture(bOnlyTexture)
    {
        if (pPattern)
            pPattern->ConvertTo24Bit() ;
    }
private:
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() == 32) && m_pPattern.get() && (m_pPattern->ColorBits() >= 24) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        BYTE   * pPat = m_pPattern->GetBits (x % m_pPattern->Width(), y % m_pPattern->Height()) ;
        if (m_bOnlyTexture)
        {
            // calculate texture
            int   n = (PCL_B(pPat)+PCL_G(pPat)+PCL_R(pPat) - 384) * m_nAlpha / 765 ;
            PCL_B(pPixel) = FClamp0255 (PCL_B(pPixel) - n) ;
            PCL_G(pPixel) = FClamp0255 (PCL_G(pPixel) - n) ;
            PCL_R(pPixel) = FClamp0255 (PCL_R(pPixel) - n) ;
        }
        else
        {
            FCColor::CombineAlphaPixel ((RGBQUAD*)pPixel, *(RGBQUAD*)pPixel, pPat, m_nAlpha) ;
        }
    }

    std::auto_ptr<FCObjImage>   m_pPattern ; // 24bit or 32bit
    int      m_nAlpha ;
    bool     m_bOnlyTexture ;
};

//=============================================================================
/**
 *  Combine color (32 bit).
@verbatim
    example:
        const RGBQUAD        cr = PCL_RGBA(0,0,255,128) ;
        FCPixelCombineColor  aCmd (cr) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelCombineColor : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelCombineColor (RGBQUAD crFill) : m_crFill(crFill) {}
private:
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() == 32) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        RGBQUAD     * p = (RGBQUAD*)pPixel ;
        FCColor::CombineAlphaPixel (p, *p, &m_crFill, PCL_A(&m_crFill)) ;
    }
    RGBQUAD	    m_crFill ;
};

//=============================================================================
/**
 *  Adjust image's hue & saturation (>=24 bit).
@verbatim
    example:
        FCPixelHueSaturation   aCmd (100, 150) ; // not change hue, add 50% saturation
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelHueSaturation : public FCSinglePixelProcessBase
{
public:
    /// Constructor (param's unit is percentage).
    /// nPercentHue range is (0,200)
    FCPixelHueSaturation (int nPercentHue, int nPercentSat) : m_nPercentHue(FMax(0,nPercentHue)), m_nPercentSat(FMax(0,nPercentSat)) {}
protected:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        double      H, L, S ;
        FCColor::RGBtoHLS (pPixel, &H, &L, &S) ;
        if (m_nPercentHue != 100)
        {
            if (m_nPercentHue > 100)
            {
                H = H + (1.0 - H) * (m_nPercentHue-100) / 100 ;
            }
            else
            {
                H = H - H * (100-m_nPercentHue) / 100 ;
            }
        }

        if (m_nPercentSat != 100)
        {
            S = S * m_nPercentSat / 100 ;
        }
        RGBQUAD   cr = FCColor::HLStoRGB (H, L, S) ;
        FCColor::CopyPixel (pPixel, &cr, 3) ;
    }

    int   m_nPercentHue, m_nPercentSat ;
};

//=============================================================================
/**
 *  Left-Right mirror image (>=8 bit).
@verbatim
    example:
        FCPixelMirror   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelMirror : public FCSinglePixelProcessBase
{
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() >= 8) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        if (x < pImg->Width()/2)
        {
            BYTE   * pRight = pImg->GetBits (pImg->Width()-1-x, y) ;
            for (int i=0 ; i < pImg->ColorBits()/8 ; i++)
                FSwap (pPixel[i], pRight[i]) ; // bytes of per pixel
        }
    }
};

//=============================================================================
/**
 *  Top-Bottom flip image (>=8 bit).
@verbatim
    example:
        FCPixelFlip   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelFlip : public FCSinglePixelProcessBase
{
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() >= 8) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        if (y < pImg->Height()/2)
        {
            BYTE   * pBottom = pImg->GetBits (x, pImg->Height()-1-y) ;
            for (int i=0 ; i < pImg->ColorBits()/8 ; i++)
                FSwap (pPixel[i], pBottom[i]) ; // bytes of per pixel
        }
    }
};

//=============================================================================
/**
 *  Shift (>=24 bit).
@verbatim
    example:
        FCPixelShift   aCmd(5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelShift : public FCSinglePixelProcessBase
{
public:
    FCPixelShift (int nAmount) : m_nAmount (FMax(0,nAmount)) {srand((unsigned int)time(0));}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        const int    nSpan = pImg->ColorBits() / 8 ;
        int          nShift = rand() % (m_nAmount+1) ;

        // first pixel every line
        if (x || !m_nAmount || !nShift)
            return ;

        BYTE     crLeft[4], crRight[4] ; // L/R edge pixel color
        FCColor::CopyPixel (crLeft, pImg->GetBits(y), nSpan) ;
        FCColor::CopyPixel (crRight, pImg->GetBits(pImg->Width()-1,y), nSpan) ;
        if (rand() % 2)
        {
            // shift right
            if (pImg->Width() > nShift)
                memmove (pImg->GetBits(nShift,y), pPixel, (pImg->Width()-nShift)*nSpan) ;
            else
                nShift = pImg->Width() ;
            for (int i=0 ; i < nShift ; i++, pPixel+=nSpan)
                FCColor::CopyPixel (pPixel, crLeft, nSpan) ;
        }
        else
        {
            // shift left
            if (pImg->Width() > nShift)
                memmove (pPixel, pImg->GetBits(nShift,y), (pImg->Width()-nShift)*nSpan) ;
            else
                nShift = pImg->Width() ;
            pPixel = pImg->GetBits(pImg->Width()-1, y) ;
            for (int i=0 ; i < nShift ; i++, pPixel-=nSpan)
                FCColor::CopyPixel (pPixel, crRight, nSpan) ;
        }
    }

    int     m_nAmount ; // max shift pixel
};

//=============================================================================
/**
 *  Auto contrast (>=24 bit).
@verbatim
    example:
        FCPixelAutoContrast   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelAutoContrast : public FCSinglePixelProcessBase
{
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        BYTE     byCmin[3] = {255, 255, 255},
                 byCmax[3] = {0, 0, 0} ;

        // Get minimum and maximum values for each channel
        for (int y=0 ; y < pImg->Height() ; y++)
            for (int x=0 ; x < pImg->Width() ; x++)
            {
                BYTE   * pPixel = pImg->GetBits(x,y) ;
                for (int b=0 ; b < 3 ; b++)
                {
                    if (pPixel[b] < byCmin[b])  byCmin[b] = pPixel[b] ;
                    if (pPixel[b] > byCmax[b])  byCmax[b] = pPixel[b] ;
                }
            }

        // Calculate LUTs with stretched contrast
        for (int b=0 ; b < 3 ; b++)
        {
            const int     nRange = byCmax[b] - byCmin[b] ;
            if (nRange)
            {
                for (int x=byCmin[b] ; x <= byCmax[b] ; x++)
                    m_byLut[x][b] = 255 * (x - byCmin[b]) / nRange ;
            }
            else
                m_byLut[byCmin[b]][b] = byCmin[b] ;
        }
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        for (int b=0 ; b < 3 ; b++)
            pPixel[b] = m_byLut[pPixel[b]][b] ;
    }

    BYTE     m_byLut[256][3] ;
};

//=============================================================================
/**
 *  Auto color enhance (>=24 bit).
@verbatim
    example:
        FCPixelAutoColorEnhance   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelAutoColorEnhance : public FCSinglePixelProcessBase
{
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        m_vhi = 0.0 ; m_vlo = 1.0 ;

        // Get minimum and maximum values
        for (int y=0 ; y < pImg->Height() ; y++)
            for (int x=0 ; x < pImg->Width() ; x++)
            {
                BYTE    * pPixel = pImg->GetBits(x,y) ;
                int     c = 255 - PCL_B(pPixel),
                        m = 255 - PCL_G(pPixel),
                        y = 255 - PCL_R(pPixel),
                        k = c ;
                if (m < k)  k = m ;
                if (y < k)  k = y ;

                BYTE    byMap[4] = { c-k, m-k, y-k } ;
                double  h, z, v ;
                FCColor::RGBtoHSV (byMap, &h, &z, &v) ;
                if (v > m_vhi)  m_vhi = v ;
                if (v < m_vlo)  m_vlo = v ;
            }
    }
    virtual void ProcessPixel (FCObjImage* pImg, int nx, int ny, BYTE* pPixel)
    {
        int     c = 255 - PCL_B(pPixel),
                m = 255 - PCL_G(pPixel),
                y = 255 - PCL_R(pPixel),
                k = c ;
        if (m < k)  k = m ;
        if (y < k)  k = y ;

        BYTE    byMap[4] = { c-k, m-k, y-k } ;
        double  h, z, v ;
        FCColor::RGBtoHSV (byMap, &h, &z, &v) ;
        if (m_vhi != m_vlo)
            v = (v-m_vlo) / (m_vhi-m_vlo) ;
        *(RGBQUAD*)byMap = FCColor::HSVtoRGB (h, z, v) ;
        c = byMap[0] ; m = byMap[1] ; y = byMap[2] ;
        c += k ; if (c > 255)  c = 255 ;
        m += k ; if (m > 255)  m = 255 ;
        y += k ; if (y > 255)  y = 255 ;
        PCL_B(pPixel) = 255 - c ;
        PCL_G(pPixel) = 255 - m ;
        PCL_R(pPixel) = 255 - y ;
    }

    double     m_vhi, m_vlo ;
};

//=============================================================================
/**
 *  Emboss effect (>=24 bit).
@verbatim
    example:
        FCPixelEmboss   aCmd(5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelEmboss : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelEmboss (int nLevel) : m_nLevel(nLevel) {}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        int     nGray ;
        if (x == pImg->Width()-1)
            nGray = 128 ; // the last right col pixel
        else
        {
            BYTE  * pNext = pImg->GetBits (x+1, y) ;
            int   nSum = PCL_R(pPixel) + PCL_G(pPixel) + PCL_B(pPixel),
                  nSumNx = PCL_R(pNext) + PCL_G(pNext) + PCL_B(pNext) ;
            nGray = FClamp0255 (m_nLevel * (nSum - nSumNx) / 3 + 128) ;
        }
        PCL_R(pPixel) = PCL_G(pPixel) = PCL_B(pPixel) = nGray ;
    }

    int     m_nLevel ;
};

//=============================================================================
/**
 *  Illusion effect (>=24 bit).
@verbatim
    example:
        FCPixelIllusion   aCmd(3) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelIllusion : public FCSinglePixelProcessBase
{
public:
    FCPixelIllusion (int nAmount) : m_nAmount(nAmount) {}
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;

        m_fScale = FHypot ((double)pImg->Width(),(double)pImg->Height()) / 2.0 ;
        m_fOffset = (int)(m_fScale / 2.0) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        const double   fXCen = pImg->Width() / 2.0,
                       fYCen = pImg->Height() / 2.0,
                       cx = (x - fXCen) / m_fScale,
                       cy = (y - fYCen) / m_fScale,
                       fTmp = LIB_PI / (double)m_nAmount ;

        double   angle = floor (atan2(cy,cx) / 2.0 / fTmp) * 2.0 * fTmp + fTmp ;
        double   radius = FHypot (cx, cy) ;
        
        int   xx = (int)(x - m_fOffset * cos (angle)),
              yy = (int)(y - m_fOffset * sin (angle)) ;
        xx = FClamp (xx, 0, pImg->Width()-1) ;
        yy = FClamp (yy, 0, pImg->Height()-1) ;

        const BYTE   * pPixel2 = GetBackupImage()->GetBits (xx, yy) ;
        for (int i=0 ; i < pImg->ColorBits()/8 ; i++)
            pPixel[i] = FClamp0255 (pPixel[i] + (int)(radius * (pPixel2[i] - pPixel[i]))) ;
    }

    int     m_nAmount ;
    double  m_fScale, m_fOffset ;
};

//=============================================================================
/**
 *  Blind effect (>=24 bit).
@verbatim
    example:
        FCPixelBlinds   aCmd(AXIS_X, 10, 50, PCL_RGBA(0,0,255)) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelBlinds : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    /// @param nOpacity : percentage [1,100]
    FCPixelBlinds (AXIS_SYS nDirect, int nWidth, int nOpacity, RGBQUAD crBlind) : m_nWidth(nWidth), m_crBlind(crBlind)
    {
        m_nOpacity = FClamp (nOpacity, 1, 100) ;
        m_nDirect = nDirect ;
        if ((m_nDirect != AXIS_X) && (m_nDirect != AXIS_Y))
            m_nDirect = AXIS_X ;
    }
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        int     nMaxWidth = FMax (pImg->Width(), pImg->Height()) ;
        m_nWidth = FClamp (m_nWidth, 2, nMaxWidth) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        int     nMod ;
        if (m_nDirect == AXIS_X) // horizontal direction
            nMod = y % m_nWidth ;
        else if (m_nDirect == AXIS_Y) // vertical direction
            nMod = x % m_nWidth ;

        double     fAlphaAdd = 255.0 * m_nOpacity/100.0 / (m_nWidth-1.0) ;
        FCColor::AlphaBlendPixel (pPixel, (BYTE*)&m_crBlind, FClamp0255((int)(nMod * fAlphaAdd))) ;
    }

    AXIS_SYS    m_nDirect ;
    int         m_nWidth ;
    int         m_nOpacity ;
    RGBQUAD     m_crBlind ;
};

//=============================================================================
/**
 *  Mosaic effect (32 bit).
@verbatim
    example:
        FCPixelMosaic   aCmd(5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelMosaic : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    /// @param nBlock : pixel width of block
    FCPixelMosaic (int nBlock) : m_nBlock(FMax(2,nBlock)) {}
private:
    virtual bool ValidateColorBits (const FCObjImage* pImg) {return pImg->IsValidImage() && (pImg->ColorBits() == 32);}
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        if ((x % m_nBlock == 0) && (y % m_nBlock == 0))
        {
            RGBQUAD   cr = GetBlockAverage(x, y) ;
            FCColor::CopyPixel (pPixel, &cr, 4) ;
        }
        else
            FCColor::CopyPixel (pPixel, pImg->GetBits(x/m_nBlock*m_nBlock, y/m_nBlock*m_nBlock), 4) ;
    }
    RGBQUAD GetBlockAverage (int x, int y)
    {
        RECT   rc = {x, y, x+m_nBlock, y+m_nBlock} ;
        GetBackupImage()->BoundRect(rc) ;

        int      nNum = RECTWIDTH(rc) * RECTHEIGHT(rc) ;
        double   nSumR=0, nSumG=0, nSumB=0, nSumA=0 ;
        for (int yy=rc.top ; yy < rc.bottom ; yy++)
        {
            for (int xx=rc.left ; xx < rc.right ; xx++)
            {
                BYTE   * p = GetBackupImage()->GetBits (xx, yy) ;
                nSumB += PCL_B(p)*PCL_A(p) ; nSumG += PCL_G(p)*PCL_A(p) ;
                nSumR += PCL_R(p)*PCL_A(p) ; nSumA += PCL_A(p) ;
            }
        }
        return PCL_RGBA (nSumA ? (int)(nSumR / nSumA) : 0,
                         nSumA ? (int)(nSumG / nSumA) : 0,
                         nSumA ? (int)(nSumB / nSumA) : 0,
                         nNum ? (int)(nSumA / nNum) : 0xFF) ;
    }

private:
    int     m_nBlock ;
};

//=============================================================================
/**
 *  Fill a 3D solid frame (>=24 bit).
@verbatim
    example:
        FCPixelFill3DSolidFrame   aCmd (5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelFill3DSolidFrame : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelFill3DSolidFrame (int nWidth) : m_nWidth(FMax(3,nWidth)) {}
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        m_rcOut.left = m_rcOut.top = 0 ;
        m_rcOut.right = pImg->Width() ;
        m_rcOut.bottom = pImg->Height() ;

        const int     nShadow = (int)ceil(m_nWidth / 4.0),
                      nMid = m_nWidth - 2*nShadow ;
        m_rcO = m_rcOut ; InflateRect (&m_rcO, -nShadow, -nShadow) ;
        m_rcI = m_rcO ; InflateRect (&m_rcI, -nMid, -nMid) ;
        m_rcIn = m_rcI ; InflateRect (&m_rcIn, -nShadow, -nShadow) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        const POINT     ptPixel = {x,y} ;
        if (PtInRect (&m_rcIn, ptPixel))
            return ; // in frame, just return

        static RGBQUAD   crMain = {192,192,192,255},
                         crHighlight = FCColor::crWhite(),
                         crShadow = {128,128,128,255} ;

        RGBQUAD     crFill ;
        if (PtInRect (&m_rcI, ptPixel))
        {
            crFill = __pcl_CalcRoundColor (ptPixel, m_rcI, m_rcIn, crShadow, crHighlight) ;
        }
        else if (PtInRect (&m_rcO, ptPixel))
            crFill = crMain ;
        else if (PtInRect (&m_rcOut, ptPixel))
        {
            crFill = __pcl_CalcRoundColor (ptPixel, m_rcOut, m_rcO, crHighlight, crShadow) ;
        }
        FCColor::CopyPixel (pPixel, &crFill, pImg->ColorBits()/8) ;
    }
    static RGBQUAD __pcl_CalcRoundColor (const POINT& pt, const RECT& rcOut, const RECT& rcIn, RGBQUAD crLT, RGBQUAD crRB)
    {
        if (pt.x < rcIn.left)
            return (pt.y - rcOut.top < RECTHEIGHT(rcOut) + rcOut.left - pt.x) ? crLT : crRB ;
        if (pt.x >= rcIn.right)
            return (pt.y - rcOut.top < rcOut.right - pt.x) ? crLT : crRB ;
        if (pt.y < rcIn.top)
            return crLT ;
        return crRB ; // pt.y >= rcIn.bottom
    }

    int     m_nWidth ; // >=3
    RECT    m_rcOut, m_rcO, m_rcI, m_rcIn ;
};

//=============================================================================
/**
 *  Adjust image's RGB value (>=24 bit).
@verbatim
    example:
        FCPixelAdjustRGB   aCmd (-100, 50, 220) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelAdjustRGB : public FCSinglePixelProcessBase
{
public:
    /// Constructor (param's unit is delta).
    FCPixelAdjustRGB (int nR, int nG, int nB) : m_R(nR), m_G(nG), m_B(nB) {}
    void AdjustRGB (BYTE* pPixel)
    {
        PCL_B(pPixel) = FClamp0255 (PCL_B(pPixel) + m_B) ;
        PCL_G(pPixel) = FClamp0255 (PCL_G(pPixel) + m_G) ;
        PCL_R(pPixel) = FClamp0255 (PCL_R(pPixel) + m_R) ;
    }
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        AdjustRGB (pPixel) ;
    }
    int   m_R, m_G, m_B ;
};

//=============================================================================
/**
 *  Color level (>=24 bit).
@verbatim
    example:
        FCPixelColorLevel   aCmd (false, 20, 230) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelColorLevel : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelColorLevel (bool bAuto, int nInLow, int nInHigh, IMAGE_CHANNEL nChannel = CHANNEL_RGB)
    {
        m_bAuto = bAuto ;
        m_nInputLow[0] = m_nInputLow[1] = m_nInputLow[2] = FClamp0255(nInLow) ;
        m_nInputHigh[0] = m_nInputHigh[1] = m_nInputHigh[2] = FClamp0255(nInHigh) ;
        m_nOutputLow = 0 ; m_nOutputHigh = 255 ;
        m_bChannelR = (nChannel & CHANNEL_RED) ? true : false ;
        m_bChannelG = (nChannel & CHANNEL_GREEN) ? true : false ;
        m_bChannelB = (nChannel & CHANNEL_BLUE) ? true : false ;
    }
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;
        if (m_bAuto)
        {
            FCHistogram     histo(*pImg) ;
            this->AutoColorLevelChannel (histo, CHANNEL_RED) ;
            this->AutoColorLevelChannel (histo, CHANNEL_GREEN) ;
            this->AutoColorLevelChannel (histo, CHANNEL_BLUE) ;
        }
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        double      fInten ;
        if (m_bChannelB)
        {
            fInten = PCL_B(pPixel) - m_nInputLow[0] ;
            if (m_nInputHigh[0] != m_nInputLow[0])
                fInten /= (double)(m_nInputHigh[0] - m_nInputLow[0]) ;
            PCL_B(pPixel) = FClamp0255(FRound(fInten * 255.0)) ;
        }
        if (m_bChannelG)
        {
            fInten = PCL_G(pPixel) - m_nInputLow[1] ;
            if (m_nInputHigh[1] != m_nInputLow[1])
                fInten /= (double)(m_nInputHigh[1] - m_nInputLow[1]) ;
            PCL_G(pPixel) = FClamp0255(FRound(fInten * 255.0)) ;
        }
        if (m_bChannelR)
        {
            fInten = PCL_R(pPixel) - m_nInputLow[2] ;
            if (m_nInputHigh[2] != m_nInputLow[2])
                fInten /= (double)(m_nInputHigh[2] - m_nInputLow[2]) ;
            PCL_R(pPixel) = FClamp0255(FRound(fInten * 255.0)) ;
        }
    }
    void AutoColorLevelChannel (const FCHistogram& histo, IMAGE_CHANNEL nChannel)
    {
        int     nIndex = 0 ;
        switch (nChannel)
        {
            case CHANNEL_RED   : nIndex = 2 ; break ;
            case CHANNEL_GREEN : nIndex = 1 ; break ;
            case CHANNEL_BLUE  : nIndex = 0 ; break ;
            default : assert(false) ; break ;
        }

        const int     nCount = histo.GetCount (nChannel) ;
        if (nCount == 0)
        {
            m_nInputLow[nIndex] = m_nInputHigh[nIndex] = 0 ;
        }
        else
        {
            m_nInputLow[nIndex] = 0 ;
            m_nInputHigh[nIndex] = 255 ;
            // Set the low input
            int     new_count = 0, i ;
            for (i=0 ; i < 255 ; i++)
            {
                new_count += histo.GetValueCount (i, nChannel) ;
                double   percentage = new_count / (double)nCount ;
                double   next_percentage = (new_count + histo.GetValueCount (i+1, nChannel)) / (double)nCount ;
                if (fabs (percentage - 0.006) < fabs (next_percentage - 0.006))
                {
                    m_nInputLow[nIndex] = i + 1 ;
                    break ;
                }
            }
            // Set the high input
            new_count = 0 ;
            for (i=255 ; i > 0 ; i--)
            {
                new_count += histo.GetValueCount (i, nChannel) ;
                double   percentage = new_count / (double)nCount ;
                double   next_percentage = (new_count + histo.GetValueCount (i-1, nChannel)) / (double)nCount ;
                if (fabs (percentage - 0.006) < fabs (next_percentage - 0.006))
                {
                    m_nInputHigh[nIndex] = i - 1 ;
                    break ;
                }
            }
        }
    }
private:
    int      m_nInputLow[3], m_nInputHigh[3] ;
    int      m_nOutputLow, m_nOutputHigh ;
    bool     m_bAuto, m_bChannelR, m_bChannelG, m_bChannelB ;
};

//=============================================================================
/**
 *  Threshold image (>=24 bit).
@verbatim
    example:
        FCPixelThreshold   aCmd (128) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelThreshold : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelThreshold (int nLevel) : m_nLevel(FClamp0255(nLevel)) {}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        RGBQUAD   cr = (FCColor::GetGrayscale(pPixel) > m_nLevel) ? FCColor::crWhite() : FCColor::crBlack() ;
        FCColor::CopyPixel (pPixel, &cr, 3) ;
    }
    int     m_nLevel ;
};

//=============================================================================
/**
 *  Clockwise rotate 90' (>=8 bit).
@verbatim
    example:
        FCPixelRotate90   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelRotate90 : public FCSinglePixelProcessBase
{
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() >= 8) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        FCColor::CopyPixel (pPixel,
                            GetBackupImage()->GetBits (y, pImg->Width()-1-x),
                            pImg->ColorBits()/8) ;
    }
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;

        // create new rotated image
        pImg->Create (pImg->Height(), pImg->Width(), pImg->ColorBits()) ;
        if (pImg->ColorBits() <= 8)
            pImg->CopyPalette(*GetBackupImage()) ;
    }
};

//=============================================================================
/**
 *  Clockwise rotate 270' (>=8 bit).
@verbatim
    example:
        FCPixelRotate270   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelRotate270 : public FCPixelRotate90
{
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        FCColor::CopyPixel (pPixel,
                            GetBackupImage()->GetBits (pImg->Height()-1-y, x),
                            pImg->ColorBits()/8) ;
    }
};

//=============================================================================
/**
 *  De-interlace (32 bit).
@verbatim
    example:
        FCPixelDeinterlace   aCmd (FCPixelDeinterlace::SCAN_EVEN) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelDeinterlace : public FCSinglePixelProcessBase
{
public:
    enum SCAN_FIELDS { SCAN_EVEN=0, SCAN_ODD=1 };
    /// Constructor.
    /// @param EliminateFields : SCAN_EVEN rebuild even line / SCAN_ODD rebuild odd line.
    FCPixelDeinterlace (SCAN_FIELDS EliminateFields) : m_Fields(EliminateFields) {}
private:
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() == 32) ;
    }
    // adapted from GIMP v1.2.5 --- code v1.00
    //   Deinterlace is useful for processing images from video capture cards.
    //   When only the odd or even fields get captured, deinterlace can be used to
    //   interpolate between the existing fields to correct this.
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        if ((y == 0) || (y == pImg->Height()-1))
            return ;

        if (y % 2 == m_Fields)
        {
            BYTE    * pUp = pImg->GetBits (x, y-1),
                    * pDown = pImg->GetBits (x, y+1) ;
            int     nSumA = PCL_A(pUp) + PCL_A(pDown) ;
            PCL_A(pPixel) = nSumA / 2 ;
            if (PCL_A(pPixel))
                for (int i=0 ; i < 3 ; i++)
                    pPixel[i] = (pUp[i]*PCL_A(pUp) + pDown[i]*PCL_A(pDown)) / nSumA ;
        }
    }
    SCAN_FIELDS     m_Fields ;
};

//=============================================================================
/**
 *  Halftone (>=24 bit), use Limb Pattern M3 algorithm.
@verbatim
    example:
        FCPixelHalftoneM3   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelHalftoneM3 : public FCSinglePixelProcessBase
{
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        static const BYTE  BayerPattern[8][8] = // 64 level gray
        {
            0,32,8,40,2,34,10,42,
            48,16,56,24,50,18,58,26,
            12,44,4,36,14,46,6,38,
            60,28,52,20,62,30,54,22,
            3,35,11,43,1,33,9,41,
            51,19,59,27,49,17,57,25,
            15,47,7,39,13,45,5,37,
            63,31,55,23,61,29,53,21
        };
        const BYTE     gr = FCColor::GetGrayscale (pPixel) ;
        PCL_R(pPixel) = PCL_G(pPixel) = PCL_B(pPixel) = (((gr>>2) > BayerPattern[y&7][x&7]) ? 0xFF : 0) ;
    }
};

//=============================================================================
/**
 *  Oil paint (>=24 bit).
@verbatim
    example:
        FCPixelOilPaint   aCmd (2) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelOilPaint : public FCSinglePixelProcessBase
{
public:
    /// Constructor (nRadius >= 1).
    FCPixelOilPaint (int nRadius)
    {
        m_nRadius = FMax(1,nRadius) ;
        m_nLength = 2*m_nRadius + 1 ; // Stat. block
    }
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;
        GetBackupImage()->ExpandFrame (true, m_nRadius, m_nRadius, m_nRadius, m_nRadius) ;

        // calculate block gray
        m_ImgGray = *GetBackupImage() ;
        FCPixelConvertTo8BitGray   aCmd ;
        m_ImgGray.SinglePixelProcessProc(aCmd) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        BYTE    * pSelPixel = NULL ;
        int     nMaxNum = 0,
                pHistogram[256] ;
        memset (pHistogram, 0, sizeof(int) * 256) ;

        // replace every pixel use most frequency
        for (int ny=0 ; ny < m_nLength ; ny++)
        {
            BYTE   * pGray = m_ImgGray.GetBits (x, y+ny) ;
            for (int i=0 ; i < m_nLength ; i++, pGray++)
                if (++pHistogram[*pGray] > nMaxNum)
                {
                    nMaxNum = pHistogram[*pGray] ;
                    pSelPixel = GetBackupImage()->GetBits (x+i, y+ny) ;
                }
        }
        FCColor::CopyPixel (pPixel, pSelPixel, 3) ; // leave alpha=channel
    }

    int     m_nRadius ; // >= 1
    int     m_nLength ; // 2*m_nRadius + 1
    FCObjImage   m_ImgGray ;
};

//=============================================================================
/**
 *  Color tone (>=24 bit).
@verbatim
    example:
        FCPixelColorTone   aCmd (PCL_RGBA(0,0,255)) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelColorTone : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelColorTone (RGBQUAD crTone)
    {
        double   L, S ;
        FCColor::RGBtoHLS (&crTone, &m_nHue, &L, &S) ;
    }
    FCPixelColorTone (RGBQUAD crTone, double saturation)
    {
        double   L, S ;
		m_saturation=saturation,
        FCColor::RGBtoHLS (&crTone, &m_nHue, &L, &S) ;
    }
    FCPixelColorTone (double crTone, double saturation)
    {
		m_saturation=saturation;
		m_nHue=crTone;
    }
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        int   n = FCColor::GetGrayscale(pPixel) ;
        PCL_B(pPixel) = (BYTE)(255 * pow(n/255.0, 1.2)) ;
        PCL_G(pPixel) = (BYTE)(255 * pow(n/255.0, 1)) ;
        PCL_R(pPixel) = (BYTE)(255 * pow(n/255.0, 0.8)) ;

        double   H, L, S ;
        FCColor::RGBtoHLS (pPixel, &H, &L, &S) ;
		if(1)//m_saturation)
		{
        RGBQUAD   cr = FCColor::HLStoRGB (m_nHue, L, S * m_saturation) ;
        FCColor::CopyPixel (pPixel, &cr, 3) ;
		}
		else
		{
        RGBQUAD   cr = FCColor::HLStoRGB (m_nHue, L, S * 150 / 100) ;
        FCColor::CopyPixel (pPixel, &cr, 3) ;
		}
    }
    double   m_nHue ;
    double   m_saturation ;
};

//=============================================================================
/**
 *  Add random noise (>=24 bit).
@verbatim
    example:
        FCPixelAddRandomNoise   aCmd (5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelAddRandomNoise : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelAddRandomNoise (int nLevel) : m_nLevel(nLevel) {srand((unsigned int)time(NULL));}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        int     nDelta[3] ;
        for (int i=0 ; i < 3 ; i++)
        {
            nDelta[i] = FRound ((rand()/(double)RAND_MAX - 0.5) * m_nLevel) ;
        }
        PCL_B(pPixel) = FClamp0255 (PCL_B(pPixel) + nDelta[0]) ;
        PCL_G(pPixel) = FClamp0255 (PCL_G(pPixel) + nDelta[1]) ;
        PCL_R(pPixel) = FClamp0255 (PCL_R(pPixel) + nDelta[2]) ;
    }

    int     m_nLevel ;
};

//=============================================================================
/**
 *  Noisify (>=24 bit).
@verbatim
    example:
        FCPixelNoisify   aCmd (5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelNoisify : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    /// @param nLevel : level (0 <= nLevel <= 100).
    FCPixelNoisify (int nLevel) : m_nLevel(FClamp(nLevel,0,100)) {srand((unsigned int)time(NULL));}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        int     nNoise = (int)(m_nLevel * GenGauss() * 127.0 / 100.0) ;
        PCL_B(pPixel) = FClamp0255 (PCL_B(pPixel) + nNoise) ;
        PCL_G(pPixel) = FClamp0255 (PCL_G(pPixel) + nNoise) ;
        PCL_R(pPixel) = FClamp0255 (PCL_R(pPixel) + nNoise) ;
    }
    static double GenGauss()
    {
        return (rand() + rand() + rand() + rand()) * 5.28596089837e-5 - 3.46410161514 ;
    }

    int     m_nLevel ;
};

//=============================================================================
/**
 *  Splash image (>=24 bit).
@verbatim
    example:
        FCPixelSplash   aCmd (5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelSplash : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    /// @param nBlock : splash level (>=3).
    FCPixelSplash (int nBlock)
    {
        m_nBlock = FMax (3, nBlock) ;
        srand((unsigned int)time(0)) ;
    }
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        int   xCopy = x - m_nBlock/2 + (rand() % m_nBlock),
              yCopy = y - m_nBlock/2 + (rand() % m_nBlock) ;
        xCopy = FClamp (xCopy, 0, pImg->Width()-1) ;
        yCopy = FClamp (yCopy, 0, pImg->Height()-1) ;
        BYTE   * pSrc = GetBackupImage()->GetBits(xCopy,yCopy) ;
        FCColor::CopyPixel (pPixel, pSrc, pImg->ColorBits()/8) ;
    }
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;
    }
    int     m_nBlock ;
};

//=============================================================================
/**
 *  Video (>=24 bit).
@verbatim
    example:
        FCPixelVideo   aCmd (FCPixelVideo::VIDEO_STAGGERED) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelVideo : public FCSinglePixelProcessBase
{
public:
    enum VIDEO_TYPE {VIDEO_STAGGERED=0, VIDEO_TRIPED=1, VIDEO_3X3=2, VIDEO_DOTS=3} ;
    /// Constructor.
    /// @param nVideoType : VIDEO_STAGGERED, VIDEO_TRIPED, VIDEO_3X3, VIDEO_DOTS
    FCPixelVideo (VIDEO_TYPE nVideoType) : m_VideoType(nVideoType)
    {
        assert(nVideoType>=VIDEO_STAGGERED && nVideoType<=VIDEO_DOTS);
    }
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        static const int   pattern_width[] = {2, 1, 3, 5} ;
        static const int   pattern_height[] = {6, 3, 3, 15} ;
        static const int   video_pattern[4][15 * 5/* max pattern size */] =
        {
            {
                0, 1,
                0, 2,
                1, 2,
                1, 0,
                2, 0,
                2, 1,
            },
            {
                0,
                1,
                2,
            },
            {
                0, 1, 2,
                2, 0, 1,
                1, 2, 0,
            },
            {
                0, 1, 2, 0, 0,
                1, 1, 1, 2, 0,
                0, 1, 2, 2, 2,
                0, 0, 1, 2, 0,
                0, 1, 1, 1, 2,
                2, 0, 1, 2, 2,
                0, 0, 0, 1, 2,
                2, 0, 1, 1, 1,
                2, 2, 0, 1, 2,
                2, 0, 0, 0, 1,
                1, 2, 0, 1, 1,
                2, 2, 2, 0, 1,
                1, 2, 0, 0, 0,
                1, 1, 2, 0, 1,
                1, 2, 2, 2, 0,
            }
        };

        const int   nWidth = pattern_width[m_VideoType],
                    nHeight = pattern_height[m_VideoType] ;
        for (int i=0 ; i < 3 ; i++)
            if (video_pattern[m_VideoType][nWidth * (y%nHeight) + (x%nWidth)] == i)
                pPixel[i] = FClamp0255 (2 * pPixel[i]) ;
    }

    VIDEO_TYPE   m_VideoType ;
};

//=============================================================================
/**
 *  Color balance (>=24 bit).
@verbatim
    example:
        FCPixelColorBalance   aCmd (true, TONE_SHADOWS, -30, 20, 30) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelColorBalance : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelColorBalance (bool bPreLum, TONE_REGION ToneRgn, int cyan_red, int magenta_green, int yellow_blue)
    {
        m_bPreserveLuminosity = bPreLum ;

        int     cyan_red_rgn[3] = {0,0,0},
                magenta_green_rgn[3] = {0,0,0},
                yellow_blue_rgn[3] = {0,0,0} ;
        cyan_red_rgn[ToneRgn] = cyan_red ;
        magenta_green_rgn[ToneRgn] = magenta_green ;
        yellow_blue_rgn[ToneRgn] = yellow_blue ;

        // add for lightening, sub for darkening
        PCL_array<double>  highlights_add(256), midtones_add(256), shadows_add(256),
                           highlights_sub(256), midtones_sub(256), shadows_sub(256) ;
        int     i ;
        for (i=0 ; i < 256 ; i++)
        {
            highlights_add[i] = shadows_sub[255 - i] = (1.075 - 1 / (i / 16.0 + 1)) ;
            midtones_add[i] = midtones_sub[i] = 0.667 * (1 - FSquare ((i - 127.0) / 127.0)) ;
            shadows_add[i] = highlights_sub[i] = 0.667 * (1 - FSquare ((i - 127.0) / 127.0)) ;
        }

        // Set the transfer arrays (for speed)
        double   * cyan_red_transfer[3], * magenta_green_transfer[3], * yellow_blue_transfer[3] ;
        cyan_red_transfer[TONE_SHADOWS] = (cyan_red_rgn[TONE_SHADOWS] > 0) ? shadows_add.get() : shadows_sub.get() ;
        cyan_red_transfer[TONE_MIDTONES] = (cyan_red_rgn[TONE_MIDTONES] > 0) ? midtones_add.get() : midtones_sub.get() ;
        cyan_red_transfer[TONE_HIGHLIGHTS] = (cyan_red_rgn[TONE_HIGHLIGHTS] > 0) ? highlights_add.get() : highlights_sub.get() ;
        magenta_green_transfer[TONE_SHADOWS] = (magenta_green_rgn[TONE_SHADOWS] > 0) ? shadows_add.get() : shadows_sub.get() ;
        magenta_green_transfer[TONE_MIDTONES] = (magenta_green_rgn[TONE_MIDTONES] > 0) ? midtones_add.get() : midtones_sub.get() ;
        magenta_green_transfer[TONE_HIGHLIGHTS] = (magenta_green_rgn[TONE_HIGHLIGHTS] > 0) ? highlights_add.get() : highlights_sub.get() ;
        yellow_blue_transfer[TONE_SHADOWS] = (yellow_blue_rgn[TONE_SHADOWS] > 0) ? shadows_add.get() : shadows_sub.get() ;
        yellow_blue_transfer[TONE_MIDTONES] = (yellow_blue_rgn[TONE_MIDTONES] > 0) ? midtones_add.get() : midtones_sub.get() ;
        yellow_blue_transfer[TONE_HIGHLIGHTS] = (yellow_blue_rgn[TONE_HIGHLIGHTS] > 0) ? highlights_add.get() : highlights_sub.get() ;

        for (i=0 ; i < 256 ; i++)
        {
            int     r_n = i, g_n = i, b_n = i ;

            r_n += (int)(cyan_red_rgn[TONE_SHADOWS] * cyan_red_transfer[TONE_SHADOWS][r_n]);        r_n = FClamp0255(r_n);
            r_n += (int)(cyan_red_rgn[TONE_MIDTONES] * cyan_red_transfer[TONE_MIDTONES][r_n]);      r_n = FClamp0255(r_n);
            r_n += (int)(cyan_red_rgn[TONE_HIGHLIGHTS] * cyan_red_transfer[TONE_HIGHLIGHTS][r_n]);  r_n = FClamp0255(r_n);

            g_n += (int)(magenta_green_rgn[TONE_SHADOWS] * magenta_green_transfer[TONE_SHADOWS][g_n]);        g_n = FClamp0255(g_n);
            g_n += (int)(magenta_green_rgn[TONE_MIDTONES] * magenta_green_transfer[TONE_MIDTONES][g_n]);      g_n = FClamp0255(g_n);
            g_n += (int)(magenta_green_rgn[TONE_HIGHLIGHTS] * magenta_green_transfer[TONE_HIGHLIGHTS][g_n]);  g_n = FClamp0255(g_n);

            b_n += (int)(yellow_blue_rgn[TONE_SHADOWS] * yellow_blue_transfer[TONE_SHADOWS][b_n]);        b_n = FClamp0255(b_n);
            b_n += (int)(yellow_blue_rgn[TONE_MIDTONES] * yellow_blue_transfer[TONE_MIDTONES][b_n]);      b_n = FClamp0255(b_n);
            b_n += (int)(yellow_blue_rgn[TONE_HIGHLIGHTS] * yellow_blue_transfer[TONE_HIGHLIGHTS][b_n]);  b_n = FClamp0255(b_n);

            m_pLookupR[i] = r_n ;
            m_pLookupG[i] = g_n ;
            m_pLookupB[i] = b_n ;
        }
    }
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        RGBQUAD     rgb ;
        PCL_B(&rgb) = m_pLookupB[PCL_B(pPixel)] ;
        PCL_G(&rgb) = m_pLookupG[PCL_G(pPixel)] ;
        PCL_R(&rgb) = m_pLookupR[PCL_R(pPixel)] ;
        if (m_bPreserveLuminosity) // preserve luminosity
        {
            double   H, L, S ;
            FCColor::RGBtoHLS (&rgb, &H, &L, &S) ;

            // calculate L value
            int   cmax = FMax (PCL_R(pPixel), FMax (PCL_G(pPixel), PCL_B(pPixel))),
                  cmin = FMin (PCL_R(pPixel), FMin (PCL_G(pPixel), PCL_B(pPixel))) ;
            L = (cmax+cmin) / 2.0 / 255.0 ;

            rgb = FCColor::HLStoRGB (H, L, S) ;
        }
        PCL_B(pPixel) = PCL_B(&rgb) ;
        PCL_G(pPixel) = PCL_G(&rgb) ;
        PCL_R(pPixel) = PCL_R(&rgb) ;
    }

    BYTE     m_pLookupR[256], m_pLookupG[256], m_pLookupB[256] ;
    bool     m_bPreserveLuminosity ;
};

//=============================================================================
/**
 *  Fill grid (>=24 bit).
@verbatim
    example:
        FCPixelFillGrid   aCmd (PCL_RGBA(0,255,0), PCL_RGBA(0,0,255), 5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelFillGrid : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    /// @param nPitch : width of grid.
    FCPixelFillGrid (RGBQUAD cr1, RGBQUAD cr2, int nPitch) : m_cr1(cr1), m_cr2(cr2), m_nPitch(FMax(1,nPitch)) {}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        int     nX = x / m_nPitch, nY = y / m_nPitch ;
        FCColor::CopyPixel (pPixel, ((nX + nY) % 2 == 0) ? &m_cr1 : &m_cr2, 3) ;
    }
    RGBQUAD   m_cr1, m_cr2 ;
    int       m_nPitch ;
};

//=============================================================================
/**
 *  Add 3D grid (>=24 bit).
@verbatim
    example:
        FCPixel3DGrid   aCmd (32, 60) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixel3DGrid : public FCSinglePixelProcessBase
{
public:
    FCPixel3DGrid (int nSize, int nDepth) : m_nSize(FMax(1,nSize)), m_nDepth(nDepth) {}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        int     nDelta = 0 ;
        if (((y-1) % m_nSize == 0) && (x % m_nSize != 0) && ((x+1) % m_nSize != 0))
            nDelta = -m_nDepth ; // top
        else if (((y+2) % m_nSize == 0) && (x % m_nSize != 0) && ((x+1) % m_nSize != 0))
            nDelta = m_nDepth ; // bottom
        else if (((x-1) % m_nSize == 0) && (y % m_nSize != 0) && ((y+1) % m_nSize != 0))
            nDelta = m_nDepth ; // left
        else if (((x+2) % m_nSize == 0) && (y % m_nSize != 0) && ((y+1) % m_nSize != 0))
            nDelta = -m_nDepth ; // right

        PCL_R(pPixel) = FClamp0255 (PCL_R(pPixel) + nDelta) ;
        PCL_G(pPixel) = FClamp0255 (PCL_G(pPixel) + nDelta) ;
        PCL_B(pPixel) = FClamp0255 (PCL_B(pPixel) + nDelta) ;
    }

    int     m_nSize, m_nDepth ;
};

//=============================================================================
/**
 *  Median filter (>=24 bit).
@verbatim
    example:
        FCPixelMedianFilter   aCmd (3) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelMedianFilter : public FCSinglePixelProcessBase
{
public:
    /// Constructor (nSize >= 2).
    FCPixelMedianFilter (int nSize) : m_nSize(nSize), m_pBlock(0), m_nBlockNum(FSquare(nSize)) {}
    virtual ~FCPixelMedianFilter() {if(m_pBlock) delete[] m_pBlock;}
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        m_pBlock = new BlockElem[m_nBlockNum] ;
        SetBackupImage (pImg) ;

        // duplicate edge
        int     nLeftTop = m_nSize/2,
                nRightDown = nLeftTop ;
        GetBackupImage()->ExpandFrame (true, nLeftTop, nLeftTop, nRightDown, nRightDown) ;

        m_BakImage = *GetBackupImage() ;
        // calculate gray
        FCPixelConvertTo8BitGray   aCmd ;
        GetBackupImage()->SinglePixelProcessProc (aCmd) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        int     i = 0 ;
        for (int m=0 ; m < m_nSize ; m++)
            for (int n=0 ; n < m_nSize ; n++)
            {
                m_pBlock[i].nGray = *GetBackupImage()->GetBits (x+n, y+m) ;
                FCColor::CopyPixel (&m_pBlock[i].crOrigin, m_BakImage.GetBits(x+n, y+m), 3) ;
                i++ ;
            }

        ::qsort (m_pBlock, m_nBlockNum, sizeof(BlockElem), __CompareGray) ;
        FCColor::CopyPixel (pPixel, &m_pBlock[m_nBlockNum/2], 3) ;
    }

    struct BlockElem
    {
        RGBQUAD   crOrigin ;
        int       nGray ;
    };

    static int __CompareGray (const void* arg1, const void* arg2)
    {
        return ((BlockElem*)arg1)->nGray - ((BlockElem*)arg2)->nGray ;
    }

    int         m_nSize ;
    int         m_nBlockNum ;
    BlockElem   * m_pBlock ;
    FCObjImage  m_BakImage ;
};

//=============================================================================
/**
 *  Splite RGB channel (>=24 bit).
@verbatim
    example:
        FCObjImage                 imgBlue, imgGreen ;
        FCPixelSpliteChannel_RGB   aCmd (NULL, &imgGreen, &imgBlue) ; // get green & blue channel
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelSpliteChannel_RGB : public FCSinglePixelProcessBase
{
public:
    /// Constructor (the received image's bpp is 32).
    /// if you needn't some channel, set the param to NULL.
    FCPixelSpliteChannel_RGB (FCObjImage* pImgR, FCObjImage* pImgG, FCObjImage* pImgB) : m_pImgR(pImgR), m_pImgG(pImgG), m_pImgB(pImgB) {}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        if (m_pImgB)  *(RGBQUAD*)m_pImgB->GetBits(x,y) = PCL_RGBA(PCL_B(pPixel),PCL_B(pPixel),PCL_B(pPixel),PCL_A(pPixel)) ;
        if (m_pImgG)  *(RGBQUAD*)m_pImgG->GetBits(x,y) = PCL_RGBA(PCL_G(pPixel),PCL_G(pPixel),PCL_G(pPixel),PCL_A(pPixel)) ;
        if (m_pImgR)  *(RGBQUAD*)m_pImgR->GetBits(x,y) = PCL_RGBA(PCL_R(pPixel),PCL_R(pPixel),PCL_R(pPixel),PCL_A(pPixel)) ;
    }
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        if (m_pImgR) m_pImgR->Create (pImg->Width(), pImg->Height(), 32) ;
        if (m_pImgG) m_pImgG->Create (pImg->Width(), pImg->Height(), 32) ;
        if (m_pImgB) m_pImgB->Create (pImg->Width(), pImg->Height(), 32) ;
    }
    FCObjImage     * m_pImgR, * m_pImgG, * m_pImgB ;
};

//=============================================================================
/**
 *  Combine RGB channel (>=24 bit).
 *  all channel image must same width & height, bpp == 8.
@verbatim
    example:
        FCPixelCombineChannel_RGB  aCmd (&imgRed, &imgGreen, &imgBlue) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelCombineChannel_RGB : public FCSinglePixelProcessBase
{
public:
    FCPixelCombineChannel_RGB (FCObjImage* pImgR, FCObjImage* pImgG, FCObjImage* pImgB) : m_pImgR(pImgR), m_pImgG(pImgG), m_pImgB(pImgB) {}
private:
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        bool b=m_pImgR && m_pImgG && m_pImgB &&
               (m_pImgR->ColorBits() == 8) && (m_pImgG->ColorBits() == 8) && (m_pImgB->ColorBits() == 8) &&
               (m_pImgR->Width() == m_pImgG->Width()) && (m_pImgR->Width() == m_pImgB->Width()) &&
               (m_pImgR->Height() == m_pImgG->Height()) && (m_pImgR->Height() == m_pImgB->Height()) ;
        if (b)
            const_cast<FCObjImage*>(pImg)->Create (m_pImgR->Width(), m_pImgR->Height(), 32) ;
        return b ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        PCL_B(pPixel) = *m_pImgB->GetBits(x,y) ;
        PCL_G(pPixel) = *m_pImgG->GetBits(x,y) ;
        PCL_R(pPixel) = *m_pImgR->GetBits(x,y) ;
        PCL_A(pPixel) = 0xFF ;
    }
    FCObjImage     * m_pImgR, * m_pImgG, * m_pImgB ;
};

//=============================================================================
/// Image convolute (>= 24 bit)
class FCPixelConvolute : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelConvolute() : m_pElement(0)
    {
        m_iBlock=0 ; m_nOffset=0 ; m_iDivisor=1 ;
    }
    virtual ~FCPixelConvolute()
    {
        if (m_pElement)
            delete[] m_pElement ;
    }

    /**
     *  Set convolute kernel.
     *  @param nElements : array from top-left of matrix.
     *  @param iBlockLen : width of matrix.
     */
    void SetKernel (const int* nElements, int iBlockLen, int iDivisor, int nOffset=0)
    {
        if (!nElements || (iBlockLen < 1))
            {assert(false); return;}

        if (m_pElement)
            delete[] m_pElement ;
        m_pElement = new int[FSquare(iBlockLen)] ;

        for (int i=0 ; i < FSquare(iBlockLen) ; i++)
            m_pElement[i] = nElements[i] ;

        m_iBlock = iBlockLen ;
        m_iDivisor = FMax(1,iDivisor) ;
        m_nOffset = nOffset ;
    }

private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;

        // duplicate edge, easier to processs
        int   nLeftTop = m_iBlock/2,
              nRightDown = nLeftTop ;
        GetBackupImage()->ExpandFrame (true, nLeftTop, nLeftTop, nRightDown, nRightDown) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        // calculate the sum of sub-block
        int      nSumR=0, nSumG=0, nSumB=0, i=0 ;
        for (int iy=0 ; iy < m_iBlock ; iy++)
            for (int ix=0 ; ix < m_iBlock ; ix++, i++)
            {
                BYTE   * pOld = GetBackupImage()->GetBits (x+ix,y+iy) ;
                nSumB += PCL_B(pOld) * m_pElement[i] ;
                nSumG += PCL_G(pOld) * m_pElement[i] ;
                nSumR += PCL_R(pOld) * m_pElement[i] ;
            }
        // set pixel
        PCL_B(pPixel) = FClamp0255 (m_nOffset + nSumB / m_iDivisor) ;
        PCL_G(pPixel) = FClamp0255 (m_nOffset + nSumG / m_iDivisor) ;
        PCL_R(pPixel) = FClamp0255 (m_nOffset + nSumR / m_iDivisor) ;
    }

    int     * m_pElement ;
    int     m_iBlock, m_iDivisor, m_nOffset ;
};

//=============================================================================
/**
 *  Standard 3x3 gaussian blur (>=24 bit).
@verbatim
    example:
        FCPixelGaussianBlur3x3   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGaussianBlur3x3 : public FCPixelConvolute
{
public:
    FCPixelGaussianBlur3x3()
    {
        int   arKernel[] = {1,2,1,2,4,2,1,2,1},
              nBlock = 3,
              nDivisor = 16,
              nOffset = 0 ;
        SetKernel (arKernel, nBlock, nDivisor, nOffset) ;
    }
};

//=============================================================================
/**
 *  Standard 5x5 gaussian blur (>=24 bit).
@verbatim
    example:
        FCPixelGaussianBlur5x5   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGaussianBlur5x5 : public FCPixelConvolute
{
public:
    FCPixelGaussianBlur5x5 ()
    {
        int   arKernel[] = {0,1,2,1,0,1,3,4,3,1,2,4,8,4,2,1,3,4,3,1,0,1,2,1,0},
              nBlock = 5,
              nDivisor = 52,
              nOffset = 0 ;
        SetKernel (arKernel, nBlock, nDivisor, nOffset) ;
    }
};

//=============================================================================
/**
 *  Detect edges (>=24 bit).
@verbatim
    example:
        FCPixelDetectEdges   aCmd(3) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelDetectEdges : public FCPixelConvolute
{
public:
    /// Constructor (nRadius >= 1).
    FCPixelDetectEdges (int nRadius = 3)
    {
        int   nBlock = 2*FMax(1,nRadius) + 1,
              nDivisor = 1,
              nOffset = 0,
              nWidth = nBlock * nBlock ;

        PCL_array<int>   pKernel (nWidth) ;
        for (int i=0 ; i < nWidth ; i++)
            pKernel[i] = -1 ;
        pKernel[nWidth/2] = nWidth - 1 ;
        SetKernel (pKernel.get(), nBlock, nDivisor, nOffset) ;
    }
};

//=============================================================================
/**
 *  Sharp (laplacian template) (>=24 bit).
@verbatim
    example:
        FCPixelSharp   aCmd(3) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelSharp : public FCPixelConvolute
{
public:
    /// Constructor (nStep >= 1).
    FCPixelSharp (int nStep)
    {
        int   arKernel[] = {-1,-1,-1,-1,8+nStep,-1,-1,-1,-1},
              nBlock = 3,
              nDivisor = FMax (1,nStep),
              nOffset = 0 ;
        SetKernel (arKernel, nBlock, nDivisor, nOffset) ;
    }
};

//=============================================================================
/// Base class of gradient fill (>=24 bit)
class FCPixelGradientBase : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    FCPixelGradientBase (RGBQUAD crStart, RGBQUAD crEnd, REPEAT_MODE nRepeat=REPEAT_NONE) : m_crStart(crStart), m_crEnd(crEnd), m_nRepeat(nRepeat) {}
protected:
    /// calculate factor of point(x,y)
    virtual double CalculateFactor (int nX, int nY) =0 ;
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        double     fFac = this->CalculateFactor (x, y) ;
        switch (m_nRepeat)
        {
        case REPEAT_NONE : fFac = FClamp (fFac, 0.0, 1.0); break;
        case REPEAT_SAWTOOTH :
            if (fFac < 0.0)
                fFac = 1.0 - FDoubleMod1 (-fFac) ;
            else
                fFac = FDoubleMod1 (fFac) ;
            break ;
        case REPEAT_TRIANGULAR :
            if (fFac < 0.0)
                fFac = -fFac ;
            if ( ((int)fFac) & 1 )
                fFac = 1.0 - FDoubleMod1 (fFac) ;
            else
                fFac = FDoubleMod1 (fFac) ;
            break ;
        }
        PCL_B(pPixel) = (BYTE)(PCL_B(&m_crStart) + (PCL_B(&m_crEnd)-PCL_B(&m_crStart)) * fFac) ;
        PCL_G(pPixel) = (BYTE)(PCL_G(&m_crStart) + (PCL_G(&m_crEnd)-PCL_G(&m_crStart)) * fFac) ;
        PCL_R(pPixel) = (BYTE)(PCL_R(&m_crStart) + (PCL_R(&m_crEnd)-PCL_R(&m_crStart)) * fFac) ;
    }
    double FDoubleMod1 (const double &x)
    {
        // the function <fmod> is extreme slow :-(, so we just do it.
        // the function == fmod (x, 1.0)
        return x - (int)x ;
    }

    RGBQUAD      m_crStart, m_crEnd ;
    REPEAT_MODE  m_nRepeat ; // type of repeat
};

//=============================================================================
/**
 *  Gradient fill linear (>=24 bit).
@verbatim
    example:
        POINT     ptStart={0,0}, ptEnd={100,100} ;
        FCPixelGradientLine  aCmd (ptStart, ptEnd, PCL_RGBA(0,0,0), PCL_RGBA(0,0,255), REPEAT_NONE) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGradientLine : public FCPixelGradientBase
{
public:
    /**
     *  Constructor.
     *  @param ptStart : start coordinate on image.
     *  @param ptEnd : end coordinate on image.
     *  @param nRepeat : REPEAT_NONE, REPEAT_SAWTOOTH, REPEAT_TRIANGULAR
     */
    FCPixelGradientLine (POINT ptStart, POINT ptEnd, RGBQUAD crStart, RGBQUAD crEnd, REPEAT_MODE nRepeat = REPEAT_NONE) : FCPixelGradientBase (crStart, crEnd, nRepeat)
    {
        m_ptStart = ptStart; m_ptEnd = ptEnd;
        m_fDist = FHypot ((double)(m_ptStart.x-m_ptEnd.x), (double)(m_ptStart.y-m_ptEnd.y)) ;
        m_fRatX = (m_ptEnd.x-m_ptStart.x) / m_fDist ;
        m_fRatY = (m_ptEnd.y-m_ptStart.y) / m_fDist ;
    }
protected:
    virtual double CalculateFactor (int nX, int nY)
    {
        double   rat = m_fRatX * (nX-m_ptStart.x) + m_fRatY * (nY-m_ptStart.y) ;
        rat = rat / m_fDist ;
        return (rat < 0.0) ? 0.0 : rat ;
    }
protected:
    POINT      m_ptStart, m_ptEnd ; // coordinate on image
    double     m_fRatX, m_fRatY ;
    double     m_fDist ;
};

//=============================================================================
/**
 *  Gradient fill bilinear (>=24 bit).
@verbatim
    example:
        POINT     ptStart={0,0}, ptEnd={100,100} ;
        FCPixelGradientBiLine  aCmd (ptStart, ptEnd, PCL_RGBA(0,0,0), PCL_RGBA(0,0,255), REPEAT_NONE) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGradientBiLine : public FCPixelGradientLine
{
public:
    /**
     *  Constructor.
     *  @param ptStart : start coordinate on image.
     *  @param ptEnd : end coordinate on image.
     *  @param nRepeat : REPEAT_NONE, REPEAT_SAWTOOTH, REPEAT_TRIANGULAR
     */
    FCPixelGradientBiLine (POINT ptStart, POINT ptEnd, RGBQUAD crStart, RGBQUAD crEnd, REPEAT_MODE nRepeat = REPEAT_NONE) : FCPixelGradientLine (ptStart, ptEnd, crStart, crEnd, nRepeat) {}
protected:
    virtual double CalculateFactor (int nX, int nY)
    {
        double   rat = m_fRatX * (nX-m_ptStart.x) + m_fRatY * (nY-m_ptStart.y) ;
        rat = rat / m_fDist ;
        return fabs(rat) ;
    }
};

//=============================================================================
/**
 *  Gradient fill symmetric conical (>=24 bit).
@verbatim
    example:
        POINT     ptStart={0,0}, ptEnd={100,100} ;
        FCPixelGradientConicalSym  aCmd (ptStart, ptEnd, PCL_RGBA(0,0,0), PCL_RGBA(0,0,255), REPEAT_NONE) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGradientConicalSym : public FCPixelGradientLine
{
public:
    /**
     *  Constructor.
     *  @param ptStart : start coordinate on image.
     *  @param ptEnd : end coordinate on image.
     *  @param nRepeat : REPEAT_NONE, REPEAT_SAWTOOTH, REPEAT_TRIANGULAR
     */
    FCPixelGradientConicalSym (POINT ptStart, POINT ptEnd, RGBQUAD crStart, RGBQUAD crEnd, REPEAT_MODE nRepeat = REPEAT_NONE) : FCPixelGradientLine (ptStart, ptEnd, crStart, crEnd, nRepeat) {}
protected:
    virtual double CalculateFactor (int nX, int nY)
    {
        double   rat ;
        double   dx = nX-m_ptStart.x, dy = nY-m_ptStart.y ;
        if ((dx != 0) || (dy != 0))
        {
            double    dr = FHypot (dx, dy) ;
            rat = m_fRatX * dx / dr + m_fRatY * dy / dr ;
            rat = FClamp (rat, -1.0, 1.0) ;
            rat = acos(rat) / LIB_PI ;
            rat = FClamp (rat, 0.0, 1.0) ;
        }
        else
            rat = 0.5 ;
        return rat ;
    }
};

//=============================================================================
/**
 *  Gradient fill Anti-symmetric conical (>=24 bit).
@verbatim
    example:
        POINT     ptStart={0,0}, ptEnd={100,100} ;
        FCPixelGradientConicalSym  aCmd (ptStart, ptEnd, PCL_RGBA(0,0,0), PCL_RGBA(0,0,255), REPEAT_NONE) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGradientConicalASym : public FCPixelGradientLine
{
public:
    /**
     *  Constructor.
     *  @param ptStart : start coordinate on image.
     *  @param ptEnd : end coordinate on image.
     *  @param nRepeat : REPEAT_NONE, REPEAT_SAWTOOTH, REPEAT_TRIANGULAR
     */
    FCPixelGradientConicalASym (POINT ptStart, POINT ptEnd, RGBQUAD crStart, RGBQUAD crEnd, REPEAT_MODE nRepeat = REPEAT_NONE) : FCPixelGradientLine (ptStart, ptEnd, crStart, crEnd, nRepeat) {}
protected:
    virtual double CalculateFactor (int nX, int nY)
    {
        double   rat ;
        double   dx = nX-m_ptStart.x, dy = nY-m_ptStart.y ;
        if ((dx != 0) || (dy != 0))
        {
            double   ang0, ang1, ang ;
            ang0 = atan2 (m_fRatX, m_fRatY) + LIB_PI ;
            ang1 = atan2 (dx, dy) + LIB_PI ;
            ang = ang1 - ang0 ;
            if (ang < 0.0)
                ang += LIB_2PI ;

            rat = ang / LIB_2PI ;
            rat = FClamp (rat, 0.0, 1.0) ;
        }
        else
            rat = 0.5 ;
        return rat ;
    }
};

//=============================================================================
/**
 *  Gradient fill rect (>=24 bit).
@verbatim
    example:
        RECT     rc = {0, 0, 100, 100} ;
        FCPixelGradientRect  aCmd (rc, PCL_RGBA(0,0,0), PCL_RGBA(0,0,255), REPEAT_NONE) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGradientRect : public FCPixelGradientBase
{
public:
    /**
     *  Constructor.
     *  @param rcRect : rect on image.
     *  @param nRepeat : REPEAT_NONE, REPEAT_SAWTOOTH, REPEAT_TRIANGULAR
     */
    FCPixelGradientRect (RECT rcRect, RGBQUAD crStart, RGBQUAD crEnd, REPEAT_MODE nRepeat = REPEAT_NONE) : FCPixelGradientBase (crStart, crEnd, nRepeat)
    {
        assert (!IsRectEmpty(&rcRect)) ;
        m_fCenX = (rcRect.left + rcRect.right) / 2.0 ;
        m_fCenY = (rcRect.top + rcRect.bottom) / 2.0 ;
        m_fRadiusX = RECTWIDTH(rcRect) / 2.0 ;
        m_fRadiusY = RECTHEIGHT(rcRect) / 2.0 ;
    }
protected:
    virtual double CalculateFactor (int nX, int nY)
    {
        double   ratX = fabs((nX-m_fCenX) / m_fRadiusX),
                 ratY = fabs((nY-m_fCenY) / m_fRadiusY) ;
        return FMax(ratX, ratY) ;
    }
protected:
    double     m_fCenX, m_fCenY ;
    double     m_fRadiusX, m_fRadiusY ;
};

//=============================================================================
/**
 *  Gradient fill radial (>=24 bit).
@verbatim
    example:
        RECT     rc = {0, 0, 100, 100} ;
        FCPixelGradientRadial  aCmd (rc, PCL_RGBA(0,0,0), PCL_RGBA(0,0,255), REPEAT_NONE) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGradientRadial : public FCPixelGradientBase
{
public:
    /**
     *  Constructor.
     *  @param rcEllipse : rect on image.
     *  @param nRepeat : REPEAT_NONE, REPEAT_SAWTOOTH, REPEAT_TRIANGULAR
     */
    FCPixelGradientRadial (RECT rcEllipse, RGBQUAD crStart, RGBQUAD crEnd, REPEAT_MODE nRepeat = REPEAT_NONE) : FCPixelGradientBase (crStart, crEnd, nRepeat)
    {
        assert (!IsRectEmpty(&rcEllipse)) ;
        m_fCenX = (rcEllipse.left + rcEllipse.right) / 2.0 ;
        m_fCenY = (rcEllipse.top + rcEllipse.bottom) / 2.0 ;
        m_fRadiusX = RECTWIDTH(rcEllipse) / 2.0 ;
        m_fRadiusY = RECTHEIGHT(rcEllipse) / 2.0 ;
    }
protected:
    virtual double CalculateFactor (int nX, int nY)
    {
        double   rat = FHypot((nX-m_fCenX)/m_fRadiusX, (nY-m_fCenY)/m_fRadiusY) ;
        return rat ;
    }
private:
    double     m_fCenX, m_fCenY ;
    double     m_fRadiusX, m_fRadiusY ;
};

//=============================================================================
/// Bilinear distord (>=24 bit).
/// if derived class override OnEnterProcess, it must call OnEnterProcess of base.
class FCPixelBilinearDistord : public FCSinglePixelProcessBase
{
protected:
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return FCSinglePixelProcessBase::ValidateColorBits(pImg) && (pImg->Width() >= 2) && (pImg->Height() >= 2) ;
    }
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        double     un_x, un_y ;
        if (!calc_undistorted_coord (x, y, un_x, un_y))
            return ;
        un_x = FClamp (un_x, 0.0, GetBackupImage()->Width() - 1.1) ;
        un_y = FClamp (un_y, 0.0, GetBackupImage()->Height() - 1.1) ;

        const int     nSrcX = (int)un_x, nSrcY = (int)un_y,
                      nSrcX_1 = nSrcX+1, nSrcY_1 = nSrcY+1 ;
        const BYTE    * pcrPixel[4] =
        {
            GetBackupImage()->GetBits(nSrcX,nSrcY),
            GetBackupImage()->GetBits(nSrcX_1,nSrcY),
            GetBackupImage()->GetBits(nSrcX,nSrcY_1),
            GetBackupImage()->GetBits(nSrcX_1,nSrcY_1)
        } ;
        RGBQUAD   cr = FCColor::Get_Bilinear_Pixel (un_x-nSrcX, un_y-nSrcY, pImg->ColorBits() == 32, pcrPixel) ;
        FCColor::CopyPixel (pPixel, &cr, pImg->ColorBits()/8) ;
    }

    // returned bool variable to declare continue or not
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const =0 ;
};

//=============================================================================
/**
 *  Cylinder (>=24 bit).
@verbatim
    example:
        FCPixelCylinder  aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelCylinder : public FCPixelBilinearDistord
{
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        FCPixelBilinearDistord::OnEnterProcess(pImg) ;

        // pos in origin image.
        double   R = pImg->Width() / 2.0 ;
        for (int x=0 ; x < pImg->Width() ; x++)
        {
            double   fIndex = pImg->Width() * acos ((R-x)/R) / LIB_PI ;
            m_ColIndex.push_back (fIndex) ;
        }
    }
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        un_x = m_ColIndex[x] ;
        un_y = y ;
        return true ;
    }
    std::deque<double>   m_ColIndex ;
};

//=============================================================================
/**
 *  Wave (>=24 bit).
@verbatim
    example:
        FCPixelWave  aCmd (25, 30) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelWave : public FCPixelBilinearDistord
{
public:
    /// Constructor.
    FCPixelWave (int nWavelength, int nAmplitude, double fPhase=0) : m_nWavelength(2*FMax(1,nWavelength)), m_nAmplitude(FMax(1,nAmplitude)), m_fPhase(fPhase) {}
private:
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        const int  nImgWidth = GetBackupImage()->Width(),
                   nImgHeight = GetBackupImage()->Height() ;
        double     fScaleX = 1.0, fScaleY = 1.0 ;
        if (nImgWidth < nImgHeight)
            fScaleX = nImgHeight / (double)nImgWidth ;
        else if (nImgWidth > nImgHeight)
            fScaleY = nImgWidth / (double)nImgHeight ;

        // Distances to center, scaled
        double   fCenX = GetBackupImage()->Width() / 2.0,
                 fCenY = GetBackupImage()->Height() / 2.0,
                 dx = (x - fCenX) * fScaleX,
                 dy = (y - fCenY) * fScaleY,
                 amnt = m_nAmplitude * sin (LIB_2PI * FHypot(dx,dy) / (double)m_nWavelength + m_fPhase) ;
        un_x = (amnt + dx) / fScaleX + fCenX ;
        un_y = (amnt + dy) / fScaleY + fCenY ;
        return true ;
    }

    double  m_fPhase ; // [0..2n]
    int     m_nAmplitude ;
    int     m_nWavelength ;
};

//=============================================================================
/**
 *  Whirl & Pinch (>=24 bit).
@verbatim
    example:
        FCPixelWhirlPinch  aCmd (1.5, 0.5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelWhirlPinch : public FCPixelBilinearDistord
{
public:
    /// Constructor.
    /// @param fWhirl : [-2n,2n]
    /// @param fPinch : [-1.0,1.0]
    FCPixelWhirlPinch (double fWhirl, double fPinch)
    {
        m_fWhirl = FClamp (fWhirl, -LIB_2PI, LIB_2PI) ;
        m_fPinch = FClamp (fPinch, -1.0, 1.0) ;
    }
private:
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        
        int      nImgWidth = GetBackupImage()->Width(),
                 nImgHeight = GetBackupImage()->Height() ;
        double   fScaleX = 1.0, fScaleY = 1.0 ;
        if (nImgWidth < nImgHeight)
            fScaleX = nImgHeight / (double)nImgWidth ;
        else if (nImgWidth > nImgHeight)
            fScaleY = nImgWidth / (double)nImgHeight ;

        // Distances to center, scaled
        double   fCenX = GetBackupImage()->Width() / 2.0,
                 fCenY = GetBackupImage()->Height() / 2.0,
                 fRadius = FMax (fCenX, fCenY),
                 dx = (x - fCenX) * fScaleX,
                 dy = (y - fCenY) * fScaleY ;
        double   d = dx*dx + dy*dy ; // Distance^2 to center of *circle* (scaled ellipse)
        double   fSqrtD = sqrt (d) ;

        // If we are inside circle, then distort, else, just return the same position
        bool     bInside = (fSqrtD < fRadius) ;
        // exclude center point
        if (fSqrtD < FLT_EPSILON)
            bInside = false ;
        if (bInside)
        {
            //        double  fDist = sqrt (d / m_fRadiusScale) / m_fRadius ;
            double  fDist = fSqrtD / fRadius ;

            // Pinch
            double  fFactor = pow (sin (LIB_PI / 2.0 * fDist), -m_fPinch) ;
            dx *= fFactor ; dy *= fFactor ;

            // Whirl
            double   fAng = m_fWhirl * FSquare (1.0 - fDist) ;
            double   sina = sin (fAng), cosa = cos (fAng) ;
            un_x = (cosa * dx - sina * dy) / fScaleX + fCenX ;
            un_y = (sina * dx + cosa * dy) / fScaleY + fCenY ;
        }
        else
        {
            un_x = x ; un_y = y ;
        }
        return bInside;
    }

    double  m_fWhirl ; // radian of whirl
    double  m_fPinch ; // [-1.0, 1.0]
    //    double  m_fRadiusScale ; // [0.0, 2.0]
};

//=============================================================================
/**
 *  Fractal trace (>=24 bit).
@verbatim
    example:
        FCPixelFractalTrace  aCmd (2) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelFractalTrace : public FCPixelBilinearDistord
{
public:
    /// Constructor (nDepth >= 1).
    FCPixelFractalTrace (int nDepth) : m_nDepth(FMax(1,nDepth)) {}
private:
    void mandelbrot (const double& x, const double& y, double* u, double* v) const
    {
        int     iter = 0 ;
        double  xx = x, yy = y ;
        double  x2 = xx * xx,
                y2 = yy * yy ;

        while (iter++ < m_nDepth)
        {
            const double   tmp = x2 - y2 + x ;
            yy = 2 * xx * yy + y ;
            xx = tmp ;
            x2 = xx * xx ;
            y2 = yy * yy ;
        }
        *u = xx ; *v = yy ;
    }
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        double   fImgWidth = GetBackupImage()->Width(),
                 fImgHeight = GetBackupImage()->Height(),
                 fScaleX = 1.5 / fImgWidth,
                 fScaleY = 2.0 / fImgHeight,
                 cy = -1.0 + y * fScaleY,
                 cx = -1.0 + x * fScaleX,
                 px, py ;
        mandelbrot (cx, cy, &px, &py) ;
        un_x = (px + 1.0) / fScaleX ;
        un_y = (py + 1.0) / fScaleY ;

        if ( !(0 <= un_x && un_x < fImgWidth && 0 <= un_y && un_y < fImgHeight) )
        {
            un_x = fmod (un_x, fImgWidth) ;
            un_y = fmod (un_y, fImgHeight) ;
            if (un_x < 0.0)  un_x += fImgWidth ;
            if (un_y < 0.0)  un_y += fImgHeight ;
        }
        return true ;
    }
    int     m_nDepth ; // >=1
};

//=============================================================================
/**
 *  Lens (>=24 bit).
@verbatim
    example:
        FCPixelLens  aCmd (1.5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelLens : public FCPixelBilinearDistord
{
public:
    /// Constructor (fRefraction >= 1.0).
    FCPixelLens (double fRefraction, bool bKeepBk) : m_fRefraction(FMax(1.0,fRefraction)), m_bKeepBk(bKeepBk) {}
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        FCPixelBilinearDistord::OnEnterProcess (pImg) ;

        // clear background ?
        if (!m_bKeepBk)
            memset (pImg->GetMemStart(), 0, pImg->GetPitch()*pImg->Height()) ;
    }
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        const double   fCenX = GetBackupImage()->Width() / 2.0,
                       fCenY = GetBackupImage()->Height() / 2.0,
                       asqr = fCenX * fCenX,
                       bsqr = fCenY * fCenY,
                       csqr = FSquare(FMin(fCenX,fCenY)),
                       dy = fCenY - y,
                       ysqr = FSquare(dy),
                       dx = x - fCenX,
                       xsqr = FSquare(dx) ;
        if (ysqr < (bsqr - (bsqr * xsqr) / asqr))
        {
            double  fTmp = sqrt ((1 - xsqr/asqr - ysqr/bsqr) * csqr) ;
            double  fTmpsqr = FSquare(fTmp) ;

            double  nxangle = acos (dx / sqrt(xsqr+fTmpsqr)) ;
            double  theta2 = asin (sin (LIB_PI/2.0 - nxangle) / m_fRefraction) ;
            theta2 = LIB_PI/2.0 - nxangle - theta2 ;
            double  xx = dx - tan (theta2) * fTmp ;

            double  nyangle = acos (dy / sqrt(ysqr+fTmpsqr)) ;
            theta2 = asin (sin (LIB_PI/2.0 - nyangle) / m_fRefraction) ;
            theta2 = LIB_PI/2.0 - nyangle - theta2 ;
            double  yy = dy - tan (theta2) * fTmp ;

            un_x = xx + fCenX ;
            un_y = fCenY - yy ;
            return true ;
        }
        return false ;
    }
    double   m_fRefraction ; // >= 1.0
    bool     m_bKeepBk ;
};

//=============================================================================
/**
 *  Skew transform (>=24 bit).
 */
class FCPixelSkew : public FCPixelBilinearDistord
{
public:
    /// Constructor.
    /// @param ptPos, order by LT, RT, RB, LB
    FCPixelSkew (const POINT ptPos[4])
    {
        memcpy (m_ptNewPos, ptPos, sizeof(POINT) * 4) ;
    }
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        FCPixelBilinearDistord::OnEnterProcess (pImg) ;

        // create skewed image
        m_nNewWidth = FMax (abs(m_ptNewPos[0].x-m_ptNewPos[2].x), abs(m_ptNewPos[1].x-m_ptNewPos[3].x)) ;
        m_nNewHeight = FMax (abs(m_ptNewPos[0].y-m_ptNewPos[2].y), abs(m_ptNewPos[1].y-m_ptNewPos[3].y)) ;
        pImg->Create (m_nNewWidth, m_nNewHeight, pImg->ColorBits()) ;
    }
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        if (m_ptNewPos[0].x != m_ptNewPos[3].x)
        {
            // x axis slope
            const int      nDelta = m_ptNewPos[0].x - m_ptNewPos[3].x ;
            un_x = x - ((nDelta > 0) ? (m_nNewHeight - y) : y) * abs(nDelta) / (double)m_nNewHeight ;
            un_y = y * GetBackupImage()->Height() / (double)m_nNewHeight ;
        }
        else if (m_ptNewPos[0].y != m_ptNewPos[1].y)
        {
            // y axis slope
            const int     nDelta = m_ptNewPos[0].y - m_ptNewPos[1].y ;
            un_x = x * GetBackupImage()->Width() / (double)m_nNewWidth ;
            un_y = y - ((nDelta > 0) ? (m_nNewWidth - x) : x) * abs(nDelta) / (double)m_nNewWidth ;
        }
        else
        {
            un_x=x ; un_y=y;
        }

        if (un_x<0.0 || un_x>GetBackupImage()->Width()-1 || un_y<0.0 || un_y>GetBackupImage()->Height()-1)
            return false ;
        else
            return true ;
    }
private:
    POINT     m_ptNewPos[4] ; // LT, RT, RB, LB
    int       m_nNewWidth ;
    int       m_nNewHeight ;
};

//=============================================================================
/**
 *  Perspective transform (>=24 bit).
 */
class FCPixelPerspective : public FCPixelBilinearDistord
{
public:
    /// Constructor.
    /// @param ptPos, order by LT, RT, RB, LB
    FCPixelPerspective (const POINT ptPos[4])
    {
        memcpy (m_ptNewPos, ptPos, sizeof(POINT) * 4) ;
    }
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        FCPixelBilinearDistord::OnEnterProcess (pImg) ;

        // create sloped image
        m_nNewWidth = FMax (abs(m_ptNewPos[0].x-m_ptNewPos[1].x), abs(m_ptNewPos[2].x-m_ptNewPos[3].x)) ;
        m_nNewHeight = FMax (abs(m_ptNewPos[0].y-m_ptNewPos[3].y), abs(m_ptNewPos[1].y-m_ptNewPos[2].y)) ;
        pImg->Create (m_nNewWidth, m_nNewHeight, pImg->ColorBits()) ;
    }
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        if (m_ptNewPos[0].y != m_ptNewPos[1].y)
        {
            // y axis perspective
            int     nDelta = abs(m_ptNewPos[0].y-m_ptNewPos[3].y) - abs(m_ptNewPos[1].y-m_ptNewPos[2].y) ;
            double  fOffset = fabs(nDelta * ((nDelta > 0) ? x : (m_nNewWidth-x)) / (2.0 * m_nNewWidth)) ;
            un_y = GetBackupImage()->Height() * (y - fOffset) / (m_nNewHeight - 2.0 * fOffset) ;
            un_x = GetBackupImage()->Width() * x / (double)m_nNewWidth ;
        }
        else if (m_ptNewPos[0].x != m_ptNewPos[3].x)
        {
            // x axis perspective
            int     nDelta = abs(m_ptNewPos[0].x-m_ptNewPos[1].x) - abs(m_ptNewPos[2].x-m_ptNewPos[3].x) ;
            double  fOffset = fabs(nDelta * ((nDelta > 0) ? y : (m_nNewHeight-y)) / (2.0 * m_nNewHeight)) ;
            un_x = GetBackupImage()->Width() * (x - fOffset) / (m_nNewWidth - 2.0 * fOffset) ;
            un_y = GetBackupImage()->Height() * y / (double)m_nNewHeight ;
        }
        else
        {
            un_x = x ; un_y = y ;
        }

        if (un_x<0.0 || un_x>GetBackupImage()->Width()-1 || un_y<0.0 || un_y>GetBackupImage()->Height()-1)
            return false ;
        else
            return true ;
    }
private:
    POINT     m_ptNewPos[4] ; // LT, RT, RB, LB
    int       m_nNewWidth ;
    int       m_nNewHeight ;
};

//=============================================================================
/**
 *  Rotate (>=24 bit).
@verbatim
    example:
        FCPixelRotate   aCmd (37) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelRotate : public FCPixelBilinearDistord
{
public:
    /// Constructor.
    FCPixelRotate (int nAngle)
    {
        nAngle %= 360 ;
        while (nAngle < 0)
            nAngle += 360 ;

        m_fAngle = AngleToRadian(nAngle) ;
        m_fInvAngle = AngleToRadian(360 - nAngle) ;
    }
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        FCPixelBilinearDistord::OnEnterProcess (pImg) ;

        // calculate new width & height
        const POINT_F   ptCenter = {pImg->Width()/2.0, pImg->Height()/2.0} ;
        const POINT     ptLT = {0,0}, ptRT = {pImg->Width(),0},
                        ptLB = {0,pImg->Height()}, ptRB = {pImg->Width(), pImg->Height()} ;
        POINT           ptR[4] ;
        ptR[0] = FClockwisePoint (ptLT, ptCenter, m_fAngle) ;
        ptR[1] = FClockwisePoint (ptRT, ptCenter, m_fAngle) ;
        ptR[2] = FClockwisePoint (ptLB, ptCenter, m_fAngle) ;
        ptR[3] = FClockwisePoint (ptRB, ptCenter, m_fAngle) ;
        int     L = FMin(ptR[0].x,FMin(ptR[1].x,FMin(ptR[2].x,ptR[3].x))),
                T = FMin(ptR[0].y,FMin(ptR[1].y,FMin(ptR[2].y,ptR[3].y))),
                R = FMax(ptR[0].x,FMax(ptR[1].x,FMax(ptR[2].x,ptR[3].x))),
                B = FMax(ptR[0].y,FMax(ptR[1].y,FMax(ptR[2].y,ptR[3].y))) ;

        m_nNewWidth = R - L ;
        m_nNewHeight = B - T ;
        pImg->Create (m_nNewWidth, m_nNewHeight, pImg->ColorBits()) ;
    }
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        const POINT     ptRot = {x, y} ;
        const POINT_F   ptCenter = {(m_nNewWidth-1)/2.0, (m_nNewHeight-1)/2.0} ;
        POINT           ptR = FClockwisePoint (ptRot, ptCenter, m_fInvAngle) ;
        un_x = ptR.x ;
        un_y = ptR.y ;

        const double   fOffX = (m_nNewWidth - GetBackupImage()->Width()) / 2.0,
                       fOffY = (m_nNewHeight - GetBackupImage()->Height()) / 2.0 ;
        un_x -= fOffX ;
        un_y -= fOffY ;

        if (un_x<0.0 || un_x>GetBackupImage()->Width()-1 || un_y<0.0 || un_y>GetBackupImage()->Height()-1)
            return false ;
        else
            return true ;
    }

    double   m_fAngle, m_fInvAngle ;
    int      m_nNewWidth, m_nNewHeight ;
};

//=============================================================================
/**
 *  Ribbon (>=24 bit).
@verbatim
    example:
        FCPixelRibbon   aCmd (80, 30) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelRibbon : public FCPixelBilinearDistord
{
public:
    /// Constructor.
    /// @param nSwing : [0..100],  percentage
    /// @param nFrequency : >=0,  a pi every 10
    FCPixelRibbon (int nSwing, int nFrequency)
    {
        m_nSwing = FClamp (nSwing, 0, 100) ;
        m_nFreq = FMax (nFrequency, 0) ;
    }
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        FCPixelBilinearDistord::OnEnterProcess (pImg) ;
        
        // clear image
        memset (pImg->GetMemStart(), 0, pImg->GetPitch()*pImg->Height()) ;

        m_nDelta = m_nSwing * pImg->Height() * 75/100/100 ; // upper, max 75%
        const double   fAngleSpan = m_nFreq * LIB_PI / pImg->Width() / 10.0 ;
        for (int x=0 ; x < pImg->Width() ; x++)
        {
            int   nPush = FRound ((1.0-cos(x * fAngleSpan)) * m_nDelta / 2.0) ;
            m_ShiftDown.push_back (nPush) ;
        }
    }
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        un_x = x ;
        un_y = y + m_nDelta - m_ShiftDown[x] ;
        if ((un_y < m_nDelta) || (un_y > GetBackupImage()->Height()-1))
            return false ;
        return true ;
    }

    int               m_nSwing, m_nFreq ;
    int               m_nDelta ;
    std::deque<int>   m_ShiftDown ;
};

//=============================================================================
/**
 *  Ripple (>=24 bit).
@verbatim
    example:
        FCPixelRipple   aCmd (10, 30) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelRipple : public FCPixelBilinearDistord
{
public:
    /// Constructor.
    FCPixelRipple (int nWavelength, int nAmplitude, bool bSinType = true)
    {
        m_nWavelength = FMax (1, nWavelength) ;
        m_nAmplitude = FMax (1, nAmplitude) ;
        m_bSinType = bSinType ;
    }
private:
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        const double   fWidth = GetBackupImage()->Width() ;
        un_x = fmod (x + fWidth + shift_amount(y), fWidth) ;
        un_y = y ;
        return true ;
    }
    double  shift_amount (int nPos) const
    {
        if (m_bSinType)
            return m_nAmplitude * sin(nPos*LIB_2PI/(double)m_nWavelength) ;
        else
            return floor (m_nAmplitude * (fabs ((((nPos % m_nWavelength) / (double)m_nWavelength) * 4) - 2) - 1)) ;
    }

    int     m_nWavelength ;
    int     m_nAmplitude ;
    bool    m_bSinType ;
};

//=============================================================================
/**
 *  Tile (>=24 bit).
@verbatim
    example:
        FCPixelSmallTile   aCmd (2,2) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelSmallTile : public FCPixelBilinearDistord
{
public:
    /// Constructor.
    FCPixelSmallTile (int nXNum, int nYNum) : m_nXNum(FMax(1,nXNum)), m_nYNum(FMax(1,nYNum)) {}
private:
    virtual bool calc_undistorted_coord (int x, int y, double& un_x, double& un_y) const
    {
        un_x = (x * m_nXNum) % GetBackupImage()->Width() ;
        un_y = (y * m_nYNum) % GetBackupImage()->Height() ;
        return true ;
    }

    int     m_nXNum ;
    int     m_nYNum ;
};

//=============================================================================
/// LUT(look up table) routine (>=24 bit)
class FCPixelLUTRoutine : public FCSinglePixelProcessBase
{
public:
    /// Constructor.
    /// @param nChannel : process channel, use OR to combine
    FCPixelLUTRoutine (IMAGE_CHANNEL nChannel = CHANNEL_RGB)
    {
        m_bChannelR = nChannel & CHANNEL_RED ;
        m_bChannelG = nChannel & CHANNEL_GREEN ;
        m_bChannelB = nChannel & CHANNEL_BLUE ;
    }
protected:
    /// Initialize LUT.
    virtual int InitLUTtable (int nLUTIndex) =0 ;
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        for (int i=0 ; i <= 0xFF ; i++)
            m_LUT[i] = this->InitLUTtable (i) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        if (m_bChannelB)  PCL_B(pPixel) = m_LUT[PCL_B(pPixel)] ;
        if (m_bChannelG)  PCL_G(pPixel) = m_LUT[PCL_G(pPixel)] ;
        if (m_bChannelR)  PCL_R(pPixel) = m_LUT[PCL_R(pPixel)] ;
    }
private:
    int     m_LUT[256] ;
    int     m_bChannelR, m_bChannelG, m_bChannelB ;
};

//=============================================================================
/**
 *  Adjust brightness (>=24 bit).
@verbatim
    example:
        FCPixelBrightness   aCmd (150) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelBrightness : public FCPixelLUTRoutine
{
public:
    /// Constructor (param's unit is percentage).
    FCPixelBrightness (int nPercent, IMAGE_CHANNEL nChannel = CHANNEL_RGB) : FCPixelLUTRoutine(nChannel), m_nPercent(FMax(0,nPercent)) {}
private:
    virtual int InitLUTtable (int nLUTIndex)
    {
        return FClamp0255 (nLUTIndex * m_nPercent / 100) ;
    }
    int     m_nPercent ;
};

//=============================================================================
/**
 *  Adjust contrast (>=24 bit).
@verbatim
    example:
        FCPixelContrast   aCmd (150) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelContrast : public FCPixelLUTRoutine
{
public:
    /// Constructor (param's unit is percentage).
    FCPixelContrast (int nPercent, IMAGE_CHANNEL nChannel = CHANNEL_RGB) : FCPixelLUTRoutine(nChannel), m_nPercent(FMax(0,nPercent)) {}
private:
    virtual int InitLUTtable (int nLUTIndex)
    {
        return FClamp0255 (128 + (nLUTIndex - 128) * m_nPercent / 100) ;
    }
    int     m_nPercent ;
};

//=============================================================================
/**
 *  Adjust gamma (>=24 bit).
@verbatim
    example:
        FCPixelGamma   aCmd (0.5) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGamma : public FCPixelLUTRoutine
{
public:
    /// Constructor (param must >= 0.0).
    FCPixelGamma (double fGamma, IMAGE_CHANNEL nChannel = CHANNEL_RGB) : FCPixelLUTRoutine(nChannel)
    {
        fGamma = FMax (0.0, fGamma) ;
        m_fInvGamma = 1.0 / fGamma ;
    }
private:
    virtual int InitLUTtable (int nLUTIndex)
    {
        double   fMax = pow (255.0, m_fInvGamma) / 255.0 ;
        return FClamp0255 (FRound (pow((double)nLUTIndex, m_fInvGamma) / fMax)) ;
    }
    double     m_fInvGamma ;
};

//=============================================================================
/**
 *  Negate image(>=24 bit).
@verbatim
    example:
        FCPixelInvert   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelInvert : public FCPixelLUTRoutine
{
public:
    FCPixelInvert (IMAGE_CHANNEL nChannel = CHANNEL_RGB) : FCPixelLUTRoutine(nChannel) {}
private:
    virtual int InitLUTtable (int nLUTIndex)
    {
        return (255 - nLUTIndex) ;
    }
};

//=============================================================================
/**
 *  Solarize image(>=24 bit).
@verbatim
    example:
        FCPixelSolarize   aCmd (128) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelSolarize : public FCPixelLUTRoutine
{
public:
    /// Constructor (nThreshold in [0-255]).
    FCPixelSolarize (int nThreshold, IMAGE_CHANNEL nChannel = CHANNEL_RGB) : FCPixelLUTRoutine(nChannel), m_nThreshold(FClamp0255(nThreshold)) {}
private:
    virtual int InitLUTtable (int nLUTIndex)
    {
        return (nLUTIndex >= m_nThreshold) ? (255 - nLUTIndex) : nLUTIndex ;
    }
    int     m_nThreshold ;
};

//=============================================================================
/**
 *  Posterize image(>=24 bit).
@verbatim
    example:
        FCPixelPosterize   aCmd (2) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelPosterize : public FCPixelLUTRoutine
{
public:
    /// Constructor (nLevel >= 2).
    FCPixelPosterize (int nLevel, IMAGE_CHANNEL nChannel = CHANNEL_RGB) : FCPixelLUTRoutine(nChannel), m_nLevel(FMax(2,nLevel)) {}
private:
    virtual int InitLUTtable (int nLUTIndex)
    {
        double   du1 = 255.0 / (m_nLevel - 1.0) ;
        return FClamp0255 (FRound (du1 * FRound (nLUTIndex / du1))) ;
    }
    int     m_nLevel ;
};

//=============================================================================
/**
*  Count image's number of color (>=24 bit).
@verbatim
    example:
        FCPixelColorsCount   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
        aCmd.GetColorsNumber() ;
@endverbatim
 */
class FCPixelColorsCount : public FCSinglePixelProcessBase
{
public:
    FCPixelColorsCount() : m_pMap(0), m_nCount(0) {}
    virtual ~FCPixelColorsCount() {if(m_pMap) delete[] m_pMap;}
    /// Get used number of color.
    unsigned int GetColorsNumber() const {return m_nCount;}
protected:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        int     iMaxColor = 1 << 24 ;
        m_pMap = new BYTE[iMaxColor+1] ;
        memset (m_pMap, 0, iMaxColor+1) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        DWORD     i = 0 ;
        FCColor::CopyPixel (&i, pPixel, 3) ;
        if (m_pMap[i] == 0)
        {
            m_pMap[i] = 1 ;
            m_nCount++ ;
        }
    }

    unsigned int  m_nCount ;
    BYTE          * m_pMap ;
};

//=============================================================================
/**
*  Find a color unused in image (>=24 bit).
@verbatim
    example:
        FCPixelGetKeyColor   aCmd ;
        img.SinglePixelProcessProc (aCmd) ;
        aCmd.IsFind() ;
        aCmd.GetKeyColor() ;
@endverbatim
 */
class FCPixelGetKeyColor : public FCPixelColorsCount
{
public:
    /// Is found a color unused in image.
    bool IsFind() const {return m_bFind;}
    /// Get the color unused in image.
    RGBQUAD GetKeyColor() const {return m_crKey;}
private:
    virtual void OnLeaveProcess (FCObjImage* pImg)
    {
        m_bFind = false ;
        for (int i=0 ; i <= 0xFFFFFF ; i++)
            if (m_pMap[i] == 0)
            {
                *(DWORD*)&m_crKey = i ;
                m_bFind = true ;
                break ;
            }
    }

    RGBQUAD   m_crKey ;
    bool      m_bFind ;
};

//=============================================================================
/// Base class to process whole image.
class FCPixelWholeImageBase : public FCSinglePixelProcessBase
{
    virtual PROCESS_TYPE QueryProcessType() {return PROCESS_TYPE_WHOLE;}
private:
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel) {assert(false);}
};

//=============================================================================
/**
 *  Save a ASCII text file (>=24 bit).
@verbatim
    example:
        FCPixelExportAscII   aCmd ("c:\\PhoXo.txt") ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelExportAscII : public FCPixelWholeImageBase
{
public:
    /// Constructor.
    FCPixelExportAscII (const char* szFileName)
    {
#ifdef VC60
        m_pFile = fopen (szFileName, "wb") ; assert(m_pFile);
#else
		_tfopen_s(&m_pFile, szFileName, _T("wb"));
		assert(m_pFile);
#endif

        char   ch[95] =
        {
            ' ',
            '`','1','2','3','4','5','6','7','8','9','0','-','=','\\',
            'q','w','e','r','t','y','u','i','o','p','[',']',
            'a','s','d','f','g','h','j','k','l',';','\'',
            'z','x','c','v','b','n','m',',','.','/',
            '~','!','@','#','$','%','^','&','*','(',')','_','+','|',
            'Q','W','E','R','T','Y','U','I','O','P','{','}',
            'A','S','D','F','G','H','J','K','L',':','"',
            'Z','X','C','V','B','N','M','<','>','?'
        };
        int   gr[95] =
        {
            0,
            7,22,28,31,31,27,32,22,38,32,40, 6,12,20,38,32,26,20,24,40,
            29,24,28,38,32,32,26,22,34,24,44,33,32,32,24,16, 6,22,26,22,
            26,34,29,35,10, 6,20,14,22,47,42,34,40,10,35,21,22,22,16,14,
            26,40,39,29,38,22,28,36,22,36,30,22,22,36,26,36,25,34,38,24,
            36,22,12,12,26,30,30,34,39,42,41,18,18,22
        };

        // Bubble Sort
        for (int i=0 ; i < 94 ; i++)
            for (int j=i+1 ; j < 95 ; j++)
                if (gr[i] > gr[j])
                {
                    FSwap (ch[i], ch[j]) ;
                    FSwap (gr[i], gr[j]) ;
                }

        memcpy (m_chIndex, ch, 95*sizeof(char)) ;
        memcpy (m_nGray, gr, 95*sizeof(int)) ;
    }
    virtual ~FCPixelExportAscII()
    {
        if (m_pFile)
            fclose(m_pFile) ;
    }
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;
    }
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        FCPixelInvert     aCmd ; // most of image is brightness
        GetBackupImage()->SinglePixelProcessProc (aCmd) ;
        FCPixelConvertTo8BitGray   aGray ;
        GetBackupImage()->SinglePixelProcessProc (aGray) ;

        const int     nTransWidth = pImg->Width() / 8,
                      nTransHeight = pImg->Height() / 16 ;
        for (int y=0 ; y < nTransHeight ; y++)
        {
            for (int x=0 ; x < nTransWidth ; x++)
            {
                int     nGray = 0 ;
                for (int k=0 ; k < 16 ; k++)
                    for(int h=0 ; h < 8 ; h++)
                    {
                        BYTE   * pGray = GetBackupImage()->GetBits (8*x+h, y*16+k) ;
                        nGray += *pGray ;
                    }
                    nGray /= 16*8 ;
                    nGray = m_nGray[94] * nGray / 255 ;
                    int   t = 0 ;
                    while (m_nGray[t+1] < nGray)
                        t++ ;
                    fwrite (&m_chIndex[t], 1, sizeof(char), m_pFile) ;
            }
            char    tchar = (char)0x0D ;
            fwrite (&tchar, 1, sizeof(char), m_pFile) ;
            tchar = (char)0x0A ;
            fwrite (&tchar, 1, sizeof(char), m_pFile) ;
        }
    }

    char     m_chIndex[95] ;
    int      m_nGray[95] ;
    FILE     * m_pFile ;
};

//=============================================================================
#ifdef PCL_3RD_LIBRARY_USE_FREEIMAGE
#include "../FreeImage_Helper.h"
/**
 *  Quantize image.
@verbatim
    example:
        FCPixelConvertQuantize   aCmd (8) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelConvertQuantize : public FCPixelWholeImageBase
{
public:
    /// Constructor (nBPP = 1 or 4 or 8).
    FCPixelConvertQuantize (int nBPP) : m_nBPP(nBPP),m_nTransparency(-1) {}
    int GetTransparencyIndex() {return m_nTransparency;}
private:
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        if ((m_nBPP == 1) || (m_nBPP == 4) || (m_nBPP == 8))
            return pImg->IsValidImage() ;
        assert(false) ;
        return false ;
    }
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        if (pImg->ColorBits() == 32)
        {
            // find a key color
            FCPixelGetKeyColor   aCmd ;
            pImg->SinglePixelProcessProc (aCmd) ;
            const RGBQUAD        cr = aCmd.GetKeyColor() ;

            // set pixel (alpha=0) key color
            for (int y=0 ; y < pImg->Height() ; y++)
                for (int x=0 ; x < pImg->Width() ; x++)
                {
                    BYTE   * p = pImg->GetBits(x,y) ;
                    if (PCL_A(p) == 0)
                    {
                        FCColor::CopyPixel (p, &cr, 3) ;
                        m_pt.x=x ; m_pt.y=y ;
                        m_nTransparency = 1 ;
                    }
                }
        }

        SetBackupImage (pImg) ;
        GetBackupImage()->ConvertTo24Bit() ; // easy to handle
    }
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        FIBITMAP   * pFI = __pcl_AllocateFreeImage (*GetBackupImage()) ;
        if (pFI)
        {
            FIBITMAP   * pQu = FreeImage_ColorQuantizeEx (pFI, FIQ_NNQUANT, 1<<m_nBPP) ;
            if (pQu)
            {
                __pcl_FreeImage_to_PCLImage (pQu, *pImg) ;
                FreeImage_Unload (pQu) ;
            }
            FreeImage_Unload (pFI) ;
        }

        // set transparency
        if (pImg->IsValidImage() && (m_nTransparency == 1) && pImg->IsInside(m_pt.x,m_pt.y))
        {
            m_nTransparency = (int)pImg->GetPixelData(m_pt.x,m_pt.y) ;
        }
    }

    POINT   m_pt ;
    int     m_nBPP ;
    int     m_nTransparency ;
};
#endif // PCL_3RD_LIBRARY_USE_FREEIMAGE

//=============================================================================
/**
 *  Glass tile (>=24 bit).
@verbatim
    example:
        FCPixelGlasstile   aCmd (6, 6) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelGlasstile : public FCPixelWholeImageBase
{
public:
    /// Constructor (account of X/Y tile).
    FCPixelGlasstile (int nXTile, int nYTile)
    {
        m_nXTile = FMax(2, nXTile) ;
        m_nYTile = FMax(2, nYTile) ;
    }
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;
    }
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        int     xhalv = m_nXTile / 2, yhalv = m_nYTile / 2 ;
        int     xplus = m_nXTile % 2, yplus = m_nYTile  % 2 ;
        int     ymitt = 0, yoffs = 0 ;
        for (int y=0 ; y < pImg->Height() ; y++)
        {
            int   ypixel2 = FClamp (ymitt + yoffs*2, 0, pImg->Height()-1) ;

            yoffs++ ;
            if (yoffs == yhalv) 
            {
                ymitt += m_nYTile ;
                yoffs = -(yhalv + yplus) ;
            }

            int     xmitt = 0, xoffs = 0 ;
            for (int x=0 ; x < pImg->Width() ; x++)
            {
                int   xpixel2 = FClamp (xmitt + xoffs*2, 0, pImg->Width()-1) ;
                FCColor::CopyPixel (pImg->GetBits(x,y), GetBackupImage()->GetBits(xpixel2,ypixel2), pImg->ColorBits()/8) ;
                xoffs++ ;
                if (xoffs == xhalv) 
                {
                    xmitt += m_nXTile ;
                    xoffs = -(xhalv + xplus) ;
                }
            }
            if (pProgress)
                pProgress->SetProgress (100 * y / pImg->Height()) ;
        }
    }

    int     m_nXTile, m_nYTile ; // >=2
};

//=============================================================================
/**
 *  Box smooth (>=24 bit).
@verbatim
    example:
        FCPixelBlur_Box   aCmd (5, true) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelBlur_Box : public FCPixelWholeImageBase
{
public:
    /// Constructor.
    FCPixelBlur_Box (int iBlockLen, bool bCopyEdge)
    {
        m_iBlock = FMax(2, iBlockLen) ;
        m_bCopyEdge = bCopyEdge ;
    }
private:
    // if m_iBlock>200, the sum maybe exceed int32
    void in_UpdateSum (int& R, int& G, int& B, int& A, const void* pAdd, const void* pSub)
    {
        int   nAddA = (GetBackupImage()->ColorBits() == 32) ? PCL_A(pAdd) : 0xFF,
              nSubA = (GetBackupImage()->ColorBits() == 32) ? PCL_A(pSub) : 0xFF ;
        B = B + PCL_B(pAdd)*nAddA - PCL_B(pSub)*nSubA ;
        G = G + PCL_G(pAdd)*nAddA - PCL_G(pSub)*nSubA ;
        R = R + PCL_R(pAdd)*nAddA - PCL_R(pSub)*nSubA ;
        A = A + nAddA - nSubA ;
    }
    void in_SetPixel (int R, int G, int B, int A, void* pPixel)
    {
        PCL_B(pPixel) = A ? (B/A) : 0 ;
        PCL_G(pPixel) = A ? (G/A) : 0 ;
        PCL_R(pPixel) = A ? (R/A) : 0 ;
        if (GetBackupImage()->ColorBits() == 32)
            PCL_A(pPixel) = A / FSquare(m_iBlock) ; // pixel number of block
    }
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;

        // expand edge
        int   nLeftTop = m_iBlock/2, // left & top
              nRightDown = nLeftTop; // right & bottom :  -((m_iBlock % 2)^1)
        GetBackupImage()->ExpandFrame (m_bCopyEdge, nLeftTop, nLeftTop, nRightDown, nRightDown) ;
    }
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        // RGBA sum of every scanline start
        int     iFirstR=0, iFirstG=0, iFirstB=0, iFirstA=0 ;
        for (int y=0 ; y < pImg->Height() ; y++)
        {
            if (y == 0) // first line
            {
                for (int ny=0 ; ny < m_iBlock ; ny++)
                    for (int nx=0 ; nx < m_iBlock ; nx++)
                    {
                        BYTE   * pPixel = GetBackupImage()->GetBits (nx,ny) ;
                        int    nA = (GetBackupImage()->ColorBits() == 32) ? PCL_A(pPixel) : 0xFF ;
                        iFirstB += PCL_B(pPixel) * nA ;
                        iFirstG += PCL_G(pPixel) * nA ;
                        iFirstR += PCL_R(pPixel) * nA ;
                        iFirstA += nA ;
                    }
            }
            else // Y move down
            {
                // sub up line & add down line
                for (int i=0 ; i < m_iBlock ; i++)
                    in_UpdateSum (iFirstR, iFirstG, iFirstB, iFirstA,
                                  GetBackupImage()->GetBits (i, y-1+m_iBlock),
                                  GetBackupImage()->GetBits (i, y-1)) ;
            }

            // set first pixel per scanline
            in_SetPixel (iFirstR, iFirstG, iFirstB, iFirstA, pImg->GetBits(y)) ;

            // X move
            int     iCurrR=iFirstR, iCurrG=iFirstG, iCurrB=iFirstB, iCurrA=iFirstA ;
            for (int x=1 ; x < pImg->Width() ; x++)
            {
                // sub left pixel & add right pixel
                for (int i=0 ; i < m_iBlock ; i++)
                    in_UpdateSum (iCurrR, iCurrG, iCurrB, iCurrA,
                                  GetBackupImage()->GetBits (x-1+m_iBlock, y+i),
                                  GetBackupImage()->GetBits (x-1, y+i)) ;

                in_SetPixel (iCurrR, iCurrG, iCurrB, iCurrA, pImg->GetBits(x,y)) ;
            }
            if (pProgress)
                pProgress->SetProgress ((y+1) * 100 / pImg->Height()) ;
        } // end of for(Y)
    }

    int     m_iBlock ; // >=2
    bool    m_bCopyEdge ;
};

//=============================================================================
/**
 *  Blur zoom (>=24 bit).
@verbatim
    example:
        FCPixelBlur_Zoom   aCmd (15) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelBlur_Zoom : public FCPixelWholeImageBase
{
public:
    /// Constructor.
    FCPixelBlur_Zoom (int nLength) : m_nLength(FMax(0,nLength)) {}
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;
    }
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        for (int y=0 ; y < pImg->Height() ; y++)
        {
            for (int x=0 ; x < pImg->Width() ; x++)
            {
                // Stat.
                int     nSumB=0, nSumG=0, nSumR=0, nSumA=0,
                        i=0 ;
                for (i=0 ; i < m_nLength ; i++)
                {
                    int     nCenX = pImg->Width()/2, nCenY = pImg->Height()/2,
                            xx = (int)(nCenX + (x-nCenX) * (1.0 + 0.02 * i)),
                            yy = (int)(nCenY + (y-nCenY) * (1.0 + 0.02 * i)) ;
                    if (!GetBackupImage()->IsInside(xx,yy))
                        break ;

                    BYTE   * p = GetBackupImage()->GetBits (xx, yy) ;
                    int    nA = (pImg->ColorBits() == 32) ? PCL_A(p) : 0xFF ;
                    nSumA += nA ;
                    nSumB += nA * PCL_B(p) ;
                    nSumG += nA * PCL_G(p) ;
                    nSumR += nA * PCL_R(p) ;
                }

                // set pixel
                BYTE   * pWrite = pImg->GetBits(x,y) ;
                if (nSumA)
                {
                    PCL_B(pWrite) = nSumB/nSumA ;
                    PCL_G(pWrite) = nSumG/nSumA ;
                    PCL_R(pWrite) = nSumR/nSumA ;
                }
                if ((pImg->ColorBits() == 32) && i)
                    PCL_A(pWrite) = nSumA/i ;
            }
            if (pProgress)
                pProgress->SetProgress (100 * (y+1) / pImg->Height()) ;
        }
    }

    int     m_nLength ;
};

//=============================================================================
/**
 *  Blur radial (>=24 bit).
@verbatim
    example:
        FCPixelBlur_Radial   aCmd (30) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelBlur_Radial : public FCPixelWholeImageBase
{
public:
    /// Constructor.
    FCPixelBlur_Radial (int nAngle) : m_nAngle(abs(nAngle) % 360) {}
private:
    virtual void OnEnterProcess (FCObjImage* pImg)
    {
        SetBackupImage (pImg) ;
    }
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        int   nCenX = pImg->Width()/2, nCenY = pImg->Height()/2,
              R = (int)FHypot ((double)FMax(nCenX,pImg->Width()-nCenX), (double)FMax(nCenY,pImg->Height()-nCenY)),
              n = (int)(4 * AngleToRadian(m_nAngle) * sqrt((double)R) + 2) ;

        PCL_array<double>   ct(n),
                            st(n) ;
        double   theta = (double)AngleToRadian(m_nAngle) / ((double)(n - 1)),
                 offset = double(theta * (n - 1) / 2.0) ;
        for (int i=0 ; i < n ; i++)
        {
            ct[i] = cos (theta * i - offset) ;
            st[i] = sin (theta * i - offset) ;
        }

        for (int y=0 ; y < pImg->Height() ; y++)
        {
            for (int x=0 ; x < pImg->Width() ; x++)
            {
                int   xr = x - nCenX, yr = y - nCenY,
                      r = (int)sqrt ((double)FSquare(xr) + (double)FSquare(yr)),
                      nStep ;
                if (r == 0)
                    nStep = 1 ;
                else
                {
                    nStep = R/r ;
                    if (nStep == 0)
                        nStep = 1 ;
                    else
                        if (nStep > n-1)
                            nStep = n-1 ;
                }

                // Stat.
                int     nSumB=0, nSumG=0, nSumR=0, nSumA=0,
                        nCount = 0 ;
                for (int i=0 ; i < n ; i += nStep)
                {
                    int     xx = (int)(nCenX + xr * ct[i] - yr * st[i]),
                            yy = (int)(nCenY + xr * st[i] + yr * ct[i]) ;
                    if (!GetBackupImage()->IsInside(xx,yy))
                        continue ;

                    nCount++ ;

                    BYTE   * p = GetBackupImage()->GetBits (xx,yy) ;
                    int    nA = (pImg->ColorBits() == 32) ? PCL_A(p) : 0xFF ;
                    nSumA += nA ;
                    nSumB += nA * PCL_B(p) ;
                    nSumG += nA * PCL_G(p) ;
                    nSumR += nA * PCL_R(p) ;
                }

                // set pixel
                BYTE   * pWrite = pImg->GetBits(x,y) ;
                if (nSumA)
                {
                    PCL_B(pWrite) = nSumB/nSumA ;
                    PCL_G(pWrite) = nSumG/nSumA ;
                    PCL_R(pWrite) = nSumR/nSumA ;
                }
                if ((pImg->ColorBits() == 32) && nCount)
                    PCL_A(pWrite) = nSumA/nCount ;
            }
            if (pProgress)
                pProgress->SetProgress (100 * (y+1) / pImg->Height()) ;
        }
    }

    int     m_nAngle ; // [0, 360]
};

//=============================================================================
/**
 *  Blur motion (>=24 bit).
@verbatim
    example:
        FCPixelBlur_Motion   aCmd (15, DIRECT_LEFT) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelBlur_Motion : public FCPixelWholeImageBase
{
public:
    /// Constructor.
    FCPixelBlur_Motion (int nStep, DIRECT_SYS Direct) : m_nStep(nStep), m_Direct(Direct) {}
private:
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        if (pImg->Width() < 5)
            return ;

        m_nStep = FClamp (m_nStep, 2, (int)pImg->Width()-2) ;

        for (int y=0 ; y < pImg->Height() ; y++)
        {
            int       nCurrX = 0,
                      nSpanX = 1 ;
            RGBQUAD   rgb ; // pixel at edge
            switch (m_Direct)
            {
                case DIRECT_LEFT :
                    FCColor::CopyPixel (&rgb, pImg->GetBits(pImg->Width()-1, y), pImg->ColorBits()/8) ;
                    nCurrX = 0 ;
                    nSpanX = 1 ;
                    break ;
                case DIRECT_RIGHT :
                    FCColor::CopyPixel (&rgb, pImg->GetBits(0, y), pImg->ColorBits()/8) ;
                    nCurrX = pImg->Width()-1 ;
                    nSpanX = -1 ;
                    break ;
            }

            // first block
            int     B=0, G=0, R=0, A=0, i=0 ;
            for (i=0 ; i < m_nStep ; i++)
            {
                BYTE   * p = pImg->GetBits (nCurrX + i*nSpanX, y) ;
                B += PCL_B(p) ;
                G += PCL_G(p) ;
                R += PCL_R(p) ;
                A += PCL_A(p) ;
            }

            // move block
            for (i=0 ; i < pImg->Width() - 2 ; i++, nCurrX+=nSpanX) // leave 2 pixel edge
            {
                int     newB = FClamp0255 (B / m_nStep), // don't set pixel current
                        newG = FClamp0255 (G / m_nStep),
                        newR = FClamp0255 (R / m_nStep),
                        newA = FClamp0255 (A / m_nStep) ;
                BYTE    * p = pImg->GetBits (nCurrX, y) ;

                // step
                if (i >= pImg->Width() - m_nStep) // edge
                {
                    B = B - PCL_B(p) + PCL_B(&rgb) ;
                    G = G - PCL_G(p) + PCL_G(&rgb) ;
                    R = R - PCL_R(p) + PCL_R(&rgb) ;
                    if (pImg->ColorBits() == 32)
                        A = A - PCL_A(p) + PCL_A(&rgb) ;
                }
                else
                {
                    BYTE   * pA = pImg->GetBits (nCurrX + nSpanX*m_nStep, y) ;
                    B = B - PCL_B(p) + PCL_B(pA) ;
                    G = G - PCL_G(p) + PCL_G(pA) ;
                    R = R - PCL_R(p) + PCL_R(pA) ;
                    if (pImg->ColorBits() == 32)
                        A = A - PCL_A(p) + PCL_A(pA) ;
                }
                PCL_B(p) = newB ;
                PCL_G(p) = newG ;
                PCL_R(p) = newR ;
                if (pImg->ColorBits() == 32)
                    PCL_A(p) = newA ;
            }
            if (pProgress)
                pProgress->SetProgress ((y+1) * 100 / pImg->Height()) ;
        }
    }

    DIRECT_SYS  m_Direct ;
    int         m_nStep ; // (>= 2)
};

//=============================================================================
/**
 *  Blur IIR gauss (>=24 bit).
@verbatim
    example:
        FCPixelBlur_Gauss_IIR   aCmd (10, 10) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelBlur_Gauss_IIR : public FCPixelWholeImageBase
{
public:
    FCPixelBlur_Gauss_IIR (int nHorz, int nVert)
    {
        m_nHorz = FMax(1,nHorz) ;
        m_nVert = FMax(1,nVert) ;
    }
private:
    static void find_constants (double n_p[], double n_m[], double d_p[], double d_m[], double bd_p[], double bd_m[], double std_dev)
    {
        // The constants used in the implemenation of a casual sequence
        // using a 4th order approximation of the gaussian operator
        const double   div = sqrt(LIB_2PI) * std_dev ;
        const double   constants [8] =
        {
            -1.783/std_dev, -1.723/std_dev, 0.6318/std_dev, 1.997/std_dev,
            1.6803/div,     3.735/div,      -0.6803/div,    -0.2598/div
        } ;

        n_p[0] = constants[4] + constants[6] ;
        n_p[1] = exp(constants[1]) * (constants[7] * sin(constants[3]) - (constants[6] + 2*constants[4]) * cos(constants[3])) + exp(constants[0]) * (constants[5] * sin (constants[2]) - (2 * constants[6] + constants[4]) * cos(constants[2])) ;
        n_p[2] = 2 * exp (constants[0] + constants[1]) * ((constants[4] + constants[6]) * cos (constants[3]) * cos (constants[2]) - constants[5] * cos (constants[3]) * sin (constants[2]) - constants[7] * cos (constants[2]) * sin (constants[3]))
                 + constants[6] * exp (2 * constants[0]) + constants[4] * exp (2 * constants[1]) ;
        n_p[3] = exp (constants[1] + 2 * constants[0]) * (constants[7] * sin (constants[3]) - constants[6] * cos (constants[3])) + exp (constants[0] + 2 * constants[1]) * (constants[5] * sin (constants[2]) - constants[4] * cos (constants[2])) ;
        n_p[4] = 0.0 ;
        d_p[0] = 0.0 ;
        d_p[1] = -2 * exp (constants[1]) * cos (constants[3]) - 2 * exp (constants[0]) * cos (constants[2]) ;
        d_p[2] = 4 * cos (constants[3]) * cos (constants[2]) * exp (constants[0] + constants[1]) + exp (2 * constants[1]) + exp (2 * constants[0]) ;
        d_p[3] = -2 * cos (constants[2]) * exp (constants[0] + 2 * constants[1]) - 2 * cos (constants[3]) * exp (constants[1] + 2 * constants[0]) ;
        d_p[4] = exp (2 * constants[0] + 2 * constants[1]) ;

        int      i ;
        for (i=0 ; i <= 4 ; i++)
        {
            d_m[i] = d_p[i] ;
        }

        n_m[0] = 0.0 ;
        for (i=1 ; i <= 4 ; i++)
        {
            n_m[i] = n_p[i] - d_p[i] * n_p[0] ;
        }

        double     sum_n_p=0.0, sum_n_m=0.0, sum_d=0.0 ;
        for (i=0 ; i <= 4 ; i++)
        {
            sum_n_p += n_p[i] ;
            sum_n_m += n_m[i] ;
            sum_d += d_p[i] ;
        }

        const double   a = sum_n_p / (1.0 + sum_d),
                       b = sum_n_m / (1.0 + sum_d) ;
        for (i = 0; i <= 4; i++)
        {
            bd_p[i] = d_p[i] * a; 
            bd_m[i] = d_m[i] * b ;
        }
    }
    void GaussIIRBlurImage (FCObjImage& img, int nLength, FCObjProgress* pProgress)
    {
        int i, j, b;
        double n_p[5], n_m[5], d_p[5], d_m[5], bd_p[5], bd_m[5];

        nLength = FMax (2, nLength + 1) ;
        double  std_dev = sqrt (-(nLength * nLength) / (2 * log (1.0 / 255.0)));
        // derive the constants for calculating the gaussian from the std dev
        find_constants (n_p, n_m, d_p, d_m, bd_p, bd_m, std_dev);

        FCObjImage         imgOld(img) ;
        int                nSpan = img.ColorBits() / 8 ; // 3, 4
        PCL_array<double>  val_p(img.Width() * 3),
                           val_m(img.Width() * 3) ;
        for (int y=0 ; y < img.Height() ; y++)
        {
            memset(val_p.get(), 0, val_p.GetArrayBytes());
            memset(val_m.get(), 0, val_m.GetArrayBytes());

            BYTE    * sp_p = imgOld.GetBits(y) ;
            BYTE    * sp_m = imgOld.GetBits(img.Width()-1, y) ;
            double  * vp = val_p.get();
            double  * vm = val_m.get() + (img.Width() - 1) * 3;

            // Set up the first vals
            int     initial_p[3], initial_m[3];
            for (i = 0; i < 3; i++)
            {
                initial_p[i] = sp_p[i];
                initial_m[i] = sp_m[i];
            }

            for (int x=0 ; x < img.Width() ; x++)
            {
                double  *vpptr, *vmptr;
                int     terms = (x < 4) ? x : 4;

                for (b = 0; b < 3; b++)
                {
                    vpptr = vp + b; vmptr = vm + b;
                    for (i = 0; i <= terms; i++)
                    {
                        *vpptr += n_p[i] * sp_p[(-i * nSpan) + b] - d_p[i] * vp[(-i * 3) + b];
                        *vmptr += n_m[i] * sp_m[(i * nSpan) + b] - d_m[i] * vm[(i * 3) + b];
                    }
                    for (j = i; j <= 4; j++)
                    {
                        *vpptr += (n_p[j] - bd_p[j]) * initial_p[b];
                        *vmptr += (n_m[j] - bd_m[j]) * initial_m[b];
                    }
                }
                sp_p += nSpan ; sp_m -= nSpan ;
                vp += 3 ; vm -= 3 ;
            }

            double  * pTmp_p = val_p.get(), * pTmp_m = val_m.get() ;
            for (int mm=0 ; mm < img.Width() ; mm++)
            {
                BYTE   * p = img.GetBits (mm, y) ;
                p[0] = FClamp0255 (int(*pTmp_p + *pTmp_m)) ; pTmp_p++ ; pTmp_m++ ;
                p[1] = FClamp0255 (int(*pTmp_p + *pTmp_m)) ; pTmp_p++ ; pTmp_m++ ;
                p[2] = FClamp0255 (int(*pTmp_p + *pTmp_m)) ; pTmp_p++ ; pTmp_m++ ;
            }
            if (pProgress)
                pProgress->SetProgress ((y+1) * 100 / img.Height()) ;
        }
    }
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        GaussIIRBlurImage (*pImg, m_nHorz, 0) ;
        FCPixelRotate90     aImg90 ;
        pImg->SinglePixelProcessProc (aImg90) ;
        GaussIIRBlurImage (*pImg, m_nVert, pProgress) ;
        FCPixelRotate270    aImg270 ;
        pImg->SinglePixelProcessProc (aImg270) ;
    }

    int   m_nHorz, m_nVert ;
};

//=============================================================================
/**
 *  Add inner bevel frame (>=24 bit).
@verbatim
    example:
        FCPixelInnerBevel   aCmd (20, 10) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelInnerBevel : public FCPixelWholeImageBase
{
public:
    FCPixelInnerBevel (int nSize, int nSmooth)
    {
        m_nSize = FMax (1, nSize) ;
        m_nSmooth = nSmooth ;
    }
private:

    // the temporary object adjust brightness
    class __FCPixelFillInnerBevel : public FCSinglePixelProcessBase
    {
    public :
        __FCPixelFillInnerBevel (FCObjImage* pImg) : m_pImgBright(pImg) {}
    private:
        virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
        {
            BYTE   * p = m_pImgBright->GetBits(x,y) ;
            PCL_B(pPixel) = FClamp0255 (PCL_B(pPixel) * PCL_A(p) / 100) ;
            PCL_G(pPixel) = FClamp0255 (PCL_G(pPixel) * PCL_A(p) / 100) ;
            PCL_R(pPixel) = FClamp0255 (PCL_R(pPixel) * PCL_A(p) / 100) ;
        }
        FCObjImage   * m_pImgBright ;
    };

    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        // image brightness
        const int    nLeft=160, nTop=160,
                     nRight=40, nBottom=40 ;
        FCObjImage   imgBright (pImg->Width(), pImg->Height(), 32) ;
        for (int y=0 ; y < imgBright.Height() ; y++)
            for (int x=0 ; x < imgBright.Width() ; x++)
            {
                BYTE   * p = imgBright.GetBits(x,y) ;
                if ((x < m_nSize) && (y < imgBright.Height()-x) && (y > x))
                    PCL_A(p) = nLeft ;
                else if ((y < m_nSize) && (x < imgBright.Width()-y) && (x > y))
                    PCL_A(p) = nTop ;
                else if ((x > imgBright.Width()-m_nSize) && (y > imgBright.Width()-x) && (y < imgBright.Height()+x-imgBright.Width()))
                    PCL_A(p) = nRight ;
                else if (y > imgBright.Height()-m_nSize)
                    PCL_A(p) = nBottom ;
                else
                    PCL_A(p) = 100 ;
            }

            FCPixelBlur_Box   cmdBlur (m_nSmooth, true) ;
            imgBright.SinglePixelProcessProc (cmdBlur) ;

            __FCPixelFillInnerBevel   cmdBevel (&imgBright) ;
            pImg->SinglePixelProcessProc (cmdBevel, pProgress) ;
    }
    int   m_nSize, m_nSmooth ;
};

//=============================================================================
/**
 *  Smooth edge (32 bit).
@verbatim
    example:
        FCPixelSmoothEdge   aCmd (15) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelSmoothEdge : public FCPixelWholeImageBase
{
public:
    FCPixelSmoothEdge (int iBlock) : m_iBlock(FMax(1,iBlock)) {}
private:
    int     m_iBlock ; // >=1
private:
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() == 32) ;
    }
    static void RecordHaloPoint (const FCObjImage& imgAlpha, std::deque<POINT>& listHalo)
    {
        // expand edge to search easily
        FCObjImage   imgSearch (imgAlpha.Width()+2, imgAlpha.Height()+2, imgAlpha.ColorBits()) ;
        imgSearch.CoverBlock (imgAlpha, 1, 1) ;

        // record halo point
        FCObjImage   imgRecord (imgSearch.Width(), imgSearch.Height(), 8) ;
        POINT        nDirect[4] = {{0,-1}, {0,1}, {-1,0}, {1,0}} ; // up-down-left-right
        for (int y=1 ; y < imgSearch.Height()-1 ; y++)
            for (int x=1 ; x < imgSearch.Width()-1 ; x++)
            {
                BYTE   * p = imgSearch.GetBits(x,y) ;
                for (int i=0 ; i < 4 ; i++)
                {
                    // direction
                    int    nDX = x + nDirect[i].x,
                           nDY = y + nDirect[i].y ;
                    BYTE   * pTmp = imgSearch.GetBits (nDX, nDY) ;
                    if (*pTmp == *p)
                        continue ;

                    // draw halo at smaller alpha
                    POINT   pt ;
                    if (*pTmp < *p)
                    {
                        pt.x=nDX ; pt.y=nDY ;
                    }
                    else
                    {
                        pt.x=x ; pt.y=y ;
                    }
                    *imgRecord.GetBits (pt.x, pt.y) = 0xFF ;
                }
            }

            // halo point
            listHalo.clear() ;
            {
                for (int y=0 ; y < imgRecord.Height() ; y++)
                    for (int x=0 ; x < imgRecord.Width() ; x++)
                        if (*imgRecord.GetBits(x,y) == 0xFF)
                        {
                            POINT   pt = {x-1, y-1} ; // remember -1
                            listHalo.push_back (pt) ;
                        }
            }
    }
    void DrawHalo (FCObjImage& imgDest, FCObjImage& imgAlpha, FCObjImage& imgHalo, POINT ptCenter)
    {
        int    nLT = (imgHalo.Width()-1) / 2 ;
        RECT   rcHalo = {ptCenter.x-nLT, ptCenter.y-nLT, ptCenter.x+nLT+1, ptCenter.y+nLT+1},
               rcAlpha = {0,0,imgAlpha.Width(),imgAlpha.Height()}, rcDest ;
        if (::IntersectRect (&rcDest, &rcHalo, &rcAlpha) == 0)
            return ;

        int    nCenter = 0 ;
        if (imgAlpha.IsInside (ptCenter.x, ptCenter.y))
            nCenter = *imgAlpha.GetBits (ptCenter.x, ptCenter.y) ;

        for (int y=rcDest.top ; y < rcDest.bottom ; y++)
            for (int x=rcDest.left ; x < rcDest.right ; x++)
            {
                BYTE   * pDest = imgDest.GetBits (x, y),
                       * pAlpha = imgAlpha.GetBits (x, y),
                       * pHalo = imgHalo.GetBits (x-rcHalo.left, y-rcHalo.top) ;
                // calculate percentage
                int    nNew = FMax (nCenter, *pAlpha * *pHalo / 0xFF) ;
                if (nNew < *pDest)
                    *pDest = nNew ;
            }
    }
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        // get alpha channel
        FCObjImage   imgAlpha ;
        pImg->GetAlphaChannel (&imgAlpha) ;

        // get draw halo point
        std::deque<POINT>   listHalo ;
        RecordHaloPoint (imgAlpha, listHalo) ;
        if (listHalo.empty())
            return ;

        // create halo image
        FCObjImage          imgHalo ;
        FCPixelCreateHalo   aCmdCreateHalo(m_iBlock, 0, 0xFF) ;
        imgHalo.SinglePixelProcessProc (aCmdCreateHalo) ;

        // make alpha image
        FCObjImage   imgDest = imgAlpha ;
        for (size_t i=0 ; i < listHalo.size() ; i++)
        {
            DrawHalo (imgDest, imgAlpha, imgHalo, listHalo[i]) ;
            if (pProgress)
                pProgress->SetProgress (100*i/listHalo.size()) ;
        }
        pImg->AppendAlphaChannel (imgDest) ;
    }
private:
    class FCPixelCreateHalo : public FCSinglePixelProcessBase
    {
    public:
        FCPixelCreateHalo (int nRadius, int crCenter, int crEdge) : m_crCenter(crCenter), m_crEdge(crEdge)
        {
            m_fRadius = FMax (1, nRadius) ;
            m_fRadius += 1.0 ;
            m_ptCenter.x = (int)m_fRadius ; m_ptCenter.y = (int)m_fRadius ;
        }
    private:
        virtual bool ValidateColorBits (const FCObjImage* pImg) {return true;}
        virtual void OnEnterProcess (FCObjImage* pImg)
        {
            int     nWidth = (int)(2*m_fRadius + 1) ;
            pImg->Create (nWidth, nWidth, 8) ;
        }
        virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
        {
            double   fDist = FHypot((double)(x-m_ptCenter.x), (double)(y-m_ptCenter.y)) ;
            if (fDist <= m_fRadius)
                *pPixel = FRound (m_crCenter + (m_crEdge-m_crCenter)*fDist/m_fRadius) ;
            else
                *pPixel = m_crEdge ;
        }
        double   m_fRadius ;
        int      m_crCenter, m_crEdge ;
        POINT    m_ptCenter ;
    };
};

//=============================================================================
/// Calculate optimized image's rect.
class FCPixelGetOptimizedRect : public FCSinglePixelProcessBase
{
public:
    FCPixelGetOptimizedRect()
    {
        memset (&m_rcOptimized, 0, sizeof(m_rcOptimized)) ;
        m_bFirst = true ;
    }
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() == 32) ;
    }
    virtual void ProcessPixel (FCObjImage* pImg, int x, int y, BYTE* pPixel)
    {
        if (PCL_A(pPixel))
            if (m_bFirst)
            {
                m_rcOptimized.left = x ;
                m_rcOptimized.right = x+1 ;
                m_rcOptimized.top = y ;
                m_rcOptimized.bottom = y+1 ;
                m_bFirst = false ;
            }
            else
            {
                if (x < m_rcOptimized.left)    m_rcOptimized.left = x ;
                if (x+1 > m_rcOptimized.right)   m_rcOptimized.right = x+1 ;
                if (y < m_rcOptimized.top)     m_rcOptimized.top = y ;
                if (y+1 > m_rcOptimized.bottom)  m_rcOptimized.bottom = y+1 ;
            }
    }
public:
    RECT     m_rcOptimized ;
    bool     m_bFirst ;
};

//=============================================================================
/**
 *  Add shadow (32 bit).
@verbatim
    example:
		SHADOWDATA    ShData ;
        ShData.crShadow = FCColor::crWhite() ;
        ShData.nAlpha = 75 ;
        ShData.nSmooth = 10 ;
        ShData.nOffsetX = 5 ;
        ShData.nOffsetY = 5 ;
        FCPixelAddShadow   aCmd (ShData) ;
        img.SinglePixelProcessProc (aCmd) ;
@endverbatim
 */
class FCPixelAddShadow : public FCPixelWholeImageBase
{
public:
    FCPixelAddShadow (SHADOWDATA ShData)
    {
        m_ShadowData = ShData ;
        m_ShadowData.nSmooth = FMax (2, (int)m_ShadowData.nSmooth) ;
        m_ShadowData.nAlpha = FClamp ((int)m_ShadowData.nAlpha, 1, 100) ;
    }
private:
    virtual bool ValidateColorBits (const FCObjImage* pImg)
    {
        return pImg->IsValidImage() && (pImg->ColorBits() == 32) ;
    }
    virtual void ProcessWholeImage (FCObjImage* pImg, FCObjProgress* pProgress)
    {
        // backup image
        const FCObjImage   imgOld(*pImg) ;

        // calculate new image size
        RECT    rcImg = {0, 0, pImg->Width(), pImg->Height()},
                rcShadowOffset = rcImg ;
        ::OffsetRect (&rcShadowOffset, m_ShadowData.nOffsetX, m_ShadowData.nOffsetY) ;
        RECT     rcShadow = rcShadowOffset ;
        ::InflateRect (&rcShadow, m_ShadowData.nSmooth, m_ShadowData.nSmooth) ;
        RECT     rcResult ;
        ::UnionRect (&rcResult, &rcImg, &rcShadow) ;

        // create shadow background and box-blur it
        pImg->Create (RECTWIDTH(rcResult), RECTHEIGHT(rcResult), 32) ;
        int     nStartX = rcShadowOffset.left - rcResult.left,
                nStartY = rcShadowOffset.top - rcResult.top ;
        for (int y=0 ; y < imgOld.Height() ; y++)
            for (int x=0 ; x < imgOld.Width() ; x++)
            {
                RGBQUAD   cr = m_ShadowData.crShadow ;
                PCL_A(&cr) = PCL_A(imgOld.GetBits(x,y)) * m_ShadowData.nAlpha / 100 ;
                *(RGBQUAD*)pImg->GetBits (nStartX + x, nStartY + y) = cr ;
            }

        // box-blur alpha-channel
        FCPixelBlur_Box   cmdSmooth (m_ShadowData.nSmooth, false) ;
        pImg->SinglePixelProcessProc (cmdSmooth, pProgress) ;

        // combine origin image
        pImg->CombineImage (imgOld, rcImg.left-rcResult.left, rcImg.top-rcResult.top) ;

        // adjust new img's position
        pImg->SetGraphObjPos (imgOld.GetGraphObjPos().x - rcImg.left + rcResult.left,
                              imgOld.GetGraphObjPos().y - rcImg.top + rcResult.top) ;
    }
private:
    SHADOWDATA   m_ShadowData ;
};

//=============================================================================
// inline Implement
//=============================================================================

#endif