Filter Library

Camera

Interface Physics

ScanFilterKuwahara.cpp

//#define USE_ORIG_KUWAHARA



// ScanFilterKuwahara.cpp: implementation of the CScanFilterKuwahara class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "resource.h"
#include <Camera/InterfaceDll.h>                                // Interface Dll definitions
#include "ScanBaseBuffer.h"                      
#include "ScanFilter.h"                                            // Include overall FilterBaseClass
#include "ScanFilterKuwahara.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CScanFilterKuwahara::CScanFilterKuwahara()
{       
        m_csFilterName = m_lpcsFilterName;
}

CScanFilterKuwahara::~CScanFilterKuwahara()
{

}

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

LPCTSTR CScanFilterKuwahara::m_lpcsFilterName = _T("Kuwahara");
                                        // this filter's short name
LPCTSTR CScanFilterKuwahara::m_lpcsShortFilterName = CScanFilterKuwahara::m_lpcsFilterName;
IMPLEMENT_SERIAL(CScanFilterKuwahara, CScanFilter, 0)

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

void CScanFilterKuwahara::Serialize(CArchive& ar)
{    
        CScanFilter::Serialize( ar );    
};

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

BOOL CScanFilterKuwahara::SetParameters( LPCTSTR lpParameters )
{
   /*
    * we do not expect any parameters, so say so:
    */
   if ( Q_INVALID( NULL != lpParameters && "CScanFilterKuwahara (SetParameters): no parameters expected." ) )
   {
      return FALSE;
   }

   return TRUE;
}

LPCTSTR CScanFilterKuwahara::GetParameters() const
{
        return NULL;
}

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

BOOL CScanFilterKuwahara::Apply()
{
        ASSERT(m_lpsbIn);
        ASSERT(m_lpsbOut);

   /*
    * copy the filter settings (not the data):
    */
   Q_RETURN( m_lpsbOut->CreateOutputBufferFor( *m_lpsbIn ) );

        m_lpsbOut->m_csBufferName.Format( _T("%s - %s"),m_lpsbIn->m_csBufferName, m_lpcsShortFilterName );

        // Process first part (L2R)
        Kuwahara(0);

        // If we have a double buffer, L2R and R2L, process that part too.
        if ((m_lpsbIn->m_dwFlags & SPM_SDBF_RIGHT2LEFT) && (m_lpsbIn->m_dwFlags & SPM_SDBF_LEFT2RIGHT))
                Kuwahara(m_lpsbIn->m_dwSizeX * m_lpsbIn->m_dwSizeY);

        return TRUE;
}
        
//-------------------------------------------------------------------------------//

void CScanFilterKuwahara::Kuwahara(DWORD dwOffset)
{
        // Check: can only handle completed frames
        ASSERT(m_lpsbIn->m_dwPixelOffset == 0);
        ASSERT(m_lpsbIn->m_dwPixelCount == m_lpsbIn->m_dwSizeX * m_lpsbIn->m_dwSizeY);
        
        DWORD ptr = dwOffset;
        int nStrideX = m_lpsbIn->m_dwSizeX;     

        for (DWORD y=0; y<m_lpsbIn->m_dwSizeY; y++)
                for (DWORD x=0; x<(DWORD)nStrideX; x++)
                {                               
                        DWORD dwCount;
                        
                        double dSum, dSum2;
                        double dRegionAvg[4];
                        double dRegionSdv[4];

                        // loop through 3x3 pixel area (Region 1)
                        dwCount = 0;
                        dSum = dSum2 = 0.0;
                        {for (int yi=max(0,(int)y-2); yi<min((int)m_lpsbIn->m_dwSizeY,(int)y+1); yi++)
                        {
                                for (int xi=max(0,(int)x-2); xi<min((int)nStrideX,(int)x+1); xi++)
                                {
                                        short sValue = m_lpsbIn->m_pwData[dwOffset + yi*nStrideX + xi];
                                        dSum += sValue;
                                        dSum2 += sValue * sValue;
                                        dwCount++;
                                }
                        }}

                        if (dwCount > 1)
                        {
                                dRegionAvg[0] = dSum / dwCount;
#ifdef USE_ORIG_KUWAHARA
                                dRegionSdv[0] = sqrt( dSum2 - ((dSum*dSum/dwCount) / (dwCount-1)) );
#else
                                dRegionSdv[0] = dwCount * dSum2 - dSum * dSum;
#endif
                        }
                        else dRegionSdv[0] = 1E20;      // set big number

                        // loop through 3x3 pixel area (Region 2)
                        dwCount = 0;
                        dSum = dSum2 = 0.0;
                        {for (int yi=max(0,(int)y-2); yi<min((int)m_lpsbIn->m_dwSizeY,(int)y+1); yi++)
                        {
                                for (int xi=max(0,(int)x); xi<min((int)nStrideX,(int)x+3); xi++)
                                {
                                        short sValue = m_lpsbIn->m_pwData[dwOffset + yi*nStrideX + xi];
                                        dSum += sValue;
                                        dSum2 += sValue * sValue;
                                        dwCount++;
                                }
                        }}

                        if (dwCount > 1)
                        {
                                dRegionAvg[1] = dSum / dwCount;
#ifdef USE_ORIG_KUWAHARA
                                dRegionSdv[1] = sqrt( dSum2 - ((dSum*dSum/dwCount) / (dwCount-1)) );
#else
                                dRegionSdv[1] = dwCount * dSum2 - dSum * dSum;
#endif
                        }
                        else dRegionSdv[1] = 1E20;      // set big number


                        // loop through 3x3 pixel area (Region 3)
                        dwCount = 0;
                        dSum = dSum2 = 0.0;
                        {for (int yi=max(0,(int)y); yi<min((int)m_lpsbIn->m_dwSizeY,(int)y+3); yi++)
                        {
                                for (int xi=max(0,(int)x-2); xi<min((int)nStrideX,(int)x+1); xi++)
                                {
                                        short sValue = m_lpsbIn->m_pwData[dwOffset + yi*nStrideX + xi];
                                        dSum += sValue;
                                        dSum2 += sValue * sValue;
                                        dwCount++;
                                }
                        }}

                        if (dwCount > 1)
                        {
                                dRegionAvg[2] = dSum / dwCount;
#ifdef USE_ORIG_KUWAHARA
                                dRegionSdv[2] = sqrt( dSum2 - ((dSum*dSum/dwCount) / (dwCount-1)) );
#else
                                dRegionSdv[2] = dwCount * dSum2 - dSum * dSum;
#endif
                        }
                        else dRegionSdv[2] = 1E20;      // set big number

                        // loop through 3x3 pixel area (Region 4)
                        dwCount = 0;
                        dSum = dSum2 = 0.0;
                        {for (int yi=max(0,(int)y); yi<min((int)m_lpsbIn->m_dwSizeY,(int)y+3); yi++)
                        {
                                for (int xi=max(0,(int)x); xi<min((int)nStrideX,(int)x+3); xi++)
                                {
                                        short sValue = m_lpsbIn->m_pwData[dwOffset + yi*nStrideX + xi];
                                        dSum += sValue;
                                        dSum2 += sValue * sValue;
                                        dwCount++;
                                }
                        }}

                        if (dwCount > 1)
                        {
                                dRegionAvg[3] = dSum / dwCount;
#ifdef USE_ORIG_KUWAHARA
                                dRegionSdv[3] = sqrt( dSum2 - ((dSum*dSum/dwCount) / (dwCount-1)) );
#else
                                dRegionSdv[3] = dwCount * dSum2 - dSum * dSum;
#endif
                        }
                        else dRegionSdv[3] = 1E20;      // set big number

                        // Find Region with lowest std-diviation
                        int iRegionSelect = 0;
                        double dMin = dRegionSdv[0];
                        for (int i=1; i<4; i++) if (dRegionSdv[i] < dMin) { dMin = dRegionSdv[i]; iRegionSelect = i; };

                        // Set avg of that value
                        m_lpsbOut->m_pwData[ptr++] = (short)dRegionAvg[iRegionSelect];

                }

}

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

---