largeobjectdetection.cpp

超大目标检测算法

// ObjectDetection.cpp: implementation of the CObjectDetection class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "APCount.h"
#include "ObjectDetection.h"
#include "math.h"
#include "TypeDef.h"

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

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

CObjectDetection::CObjectDetection()
{
	m_dwImageWidth = m_dwImageHeight = 0;
	m_dwRowBytes   = 0;
	m_byThreshold  = 26;
//	m_pDiffHist    = NULL;

	for ( int i = 0; i < 512; ++ i )
	{
		m_pDiffHist[ i ] = 0;
	}
}

CObjectDetection::~CObjectDetection()
{
/*	if ( m_pDiffHist != NULL )
	{
		delete[] m_pDiffHist;
		m_pDiffHist = NULL;
	}*/
}


void CObjectDetection::FGObjectInit( DWORD dwImageWidth, DWORD dwImageHeight )
{
	m_dwImageWidth  = (short)dwImageWidth;
	m_dwImageHeight = (short)dwImageHeight;
	m_dwRowBytes    = (short)dwImageWidth * RAW_BYTES;

	CreateGausTab();
	CreateExpTab();

/*	m_pDiffHist = new DWORD[ 256 ];
	memset( m_pDiffHist, 0, 256 * sizeof( DWORD ) );*/
}


void CObjectDetection::GetPrimeFG( LPBYTE lpBKBits, LPBYTE lpThisBits,
		                           LPBYTE lpPre1Bits, LPBYTE lpPre2Bits,
					               LPBYTE lpThisFGBits, LPBYTE lpPreFGBits )
{
	LPBYTE pBK   = lpBKBits,
		   pThis = lpThisBits,
		   pPre1 = lpPre1Bits,
		   pPre2 = lpPre2Bits,
		   pFG1  = lpThisFGBits,
		   pFG2  = lpPreFGBits;
	DWORD  dwBigCount_1 = 0,
		   dwBigCount_2 = 0;
	BYTE   byDiff_1 = 0,
		   byDiff_2 = 0,
		   byDiff_3 = 0,
		   byDiff_4 = 0,
		   byDiff_5 = 0,
		   byDiff_6 = 0;

	for ( short h = 0; h < m_dwImageHeight; ++ h )
	{
		for ( short w = 0; w < m_dwRowBytes; w += RAW_BYTES )
		{
			dwBigCount_1 = ( ( byDiff_1 = abs( pThis[ w ] - pBK[ w ] ) ) > THRESHOLD_1 ) ? 1 : 0;
			dwBigCount_1 = ( ( byDiff_2 = abs( pPre1[ w ] - pBK[ w ] ) ) > THRESHOLD_1 ) ? ( ++ dwBigCount_1 ) : NULL;
			dwBigCount_1 = ( ( byDiff_3 = abs( pPre2[ w ] - pBK[ w ] ) ) > THRESHOLD_1 ) ? ( ++ dwBigCount_1 ) : NULL;

			dwBigCount_2 = ( ( byDiff_4 = abs( pThis[ w ] - pPre1[ w ] ) ) > THRESHOLD_2 ) ? 1 : 0;
			dwBigCount_2 = ( ( byDiff_5 = abs( pThis[ w ] - pPre2[ w ] ) ) > THRESHOLD_2 ) ? ( ++ dwBigCount_2 ) : NULL;
			dwBigCount_2 = ( ( byDiff_6 = abs( pPre1[ w ] - pPre2[ w ] ) ) > THRESHOLD_2 ) ? ( ++ dwBigCount_2 ) : NULL;

			if ( dwBigCount_1 >= 2 )
			{
				if ( dwBigCount_2 >= 2 )
				{
					pFG1[ w ] = pFG1[ w + 1 ] = pFG1[ w + 2 ] = FORE_GROUND;
				}
				else if ( pFG2[ w ] == FORE_GROUND )
				{
					pFG1[ w ] = pFG1[ w + 1 ] = pFG1[ w + 2 ] = FORE_GROUND;
				}
				else
				{
					if ( max( byDiff_1, max( byDiff_2, byDiff_3 ) )
					   + max( byDiff_4, max( byDiff_5, byDiff_6 ) ) > THRESHOLD_3 )
					{
						pFG1[ w ] = pFG1[ w + 1 ] = pFG1[ w + 2 ] = FORE_GROUND;
					}
					else
					{
						pFG1[ w ] = pFG1[ w + 1 ] = pFG1[ w + 2 ] = BACK_GROUND;
					}
				}
			}
			else if ( dwBigCount_2 >= 2 )
			{
				if ( pFG2[ w ] = FORE_GROUND )
				{
					pFG1[ w ] = pFG1[ w + 1 ] = pFG1[ w + 2 ] = FORE_GROUND;
				}
				else if ( max( byDiff_1, max( byDiff_2, byDiff_3 ) )
					    + max( byDiff_4, max( byDiff_5, byDiff_6 ) ) > THRESHOLD_3 )
				{
					pFG1[ w ] = pFG1[ w + 1 ] = pFG1[ w + 2 ] = FORE_GROUND;
				}
				else
				{
					pFG1[ w ] = pFG1[ w + 1 ] = pFG1[ w + 2 ] = BACK_GROUND;
				}
			}
			else
			{
				pFG1[ w ] = pFG1[ w + 1 ] = pFG1[ w + 2 ] = BACK_GROUND;
			}
		}

		pBK   += m_dwRowBytes;
		pThis += m_dwRowBytes;
		pPre1 += m_dwRowBytes;
		pPre2 += m_dwRowBytes;
		pFG1  += m_dwRowBytes;
		pFG2  += m_dwRowBytes;
	}
}