fuzzybackgroundprobmodel.cpp

基于模糊理论的概率背景模型检测图象中的概率背景算法程序

// Fuzzy.cpp: implementation of the CFuzzy class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "APCount.h"
#include "Fuzzy.h"
#include "math.h"

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

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

CFuzzy::CFuzzy()
{
	m_bInitStatus = FALSE;

	m_snImageWidth = m_snRowBytes = m_snImageHeight = 0;

	m_pFuzzyProb   = NULL;
	m_pDiffHist    = NULL;
}

CFuzzy::~CFuzzy()
{
	DeleteMem();
}


void  CFuzzy::DeleteMem()
{
	if ( m_pFuzzyProb != NULL )
	{
		delete[] m_pFuzzyProb;
		m_pFuzzyProb = NULL;
	}

	if ( m_pDiffHist != NULL )
	{
		delete[] m_pDiffHist;
		m_pDiffHist = NULL;
	}
}


void  CFuzzy::ParamInit( short snImageWidth, short snImageHeight )
{
	if ( FALSE == m_bInitStatus )
	{
		DeleteMem();

		m_snImageWidth  = snImageWidth;
		m_snRowBytes    = snImageWidth * RAW_BYTES;
		m_snImageHeight = snImageHeight;

		CreateFuzzyTab();
		CreateSimilarTab();
		CreateCompareTab();

		int nFzProbSize = m_snImageHeight / 2 * m_snImageWidth / 2 * 16;
		m_pFuzzyProb = new int[ nFzProbSize ];
		if ( m_pFuzzyProb == NULL )
		{
			return;
		}
		memset( m_pFuzzyProb, 0, sizeof(int) * nFzProbSize );

		m_pDiffHist = new DWORD[ 256 ];
		if ( m_pDiffHist == NULL )
		{
			return;
		}
		memset( m_pDiffHist, 0, sizeof(DWORD) * 256 );

		m_FuzzyLabel.ParamInit( snImageWidth, snImageHeight );

		m_bInitStatus = TRUE;
	}
}


void  CFuzzy::CreateFuzzyTab( )
{
	const BYTE byMeanVal[ 16 ] = { 8,   24,  40,  56,  72,  88, 104, 120,
		                          136, 152, 168, 184, 200, 216, 232, 248 };

	int nGausCoff[ 96 ] = {0};
	double dbCoff_0 = 255,
		   dbCoff_1 = 0.001953125;
	for ( int x = 0; x < 64; ++ x )
	{
		nGausCoff[ x ] = (int)( dbCoff_0 * exp( -x * x * dbCoff_1 ) + 0.5 );
	}

	int   nReside[ 16 ] = {0},
		  nDist         = 0;

	for ( int i = 0; i < 16; ++ i )
	{
		for ( int j = 0; j < 256; ++ j )
		{
			nDist = abs( byMeanVal[ i ] - j );
			if ( nDist < 48 )
			{
				m_nFuzzyTab[ j ][ i ] = nGausCoff[ nDist ];//32 - nDist;
			}
			else if ( nDist < 64 )
			{
				m_nFuzzyTab[ j ][ i ] = 0;
			}
			else
			{
				m_nFuzzyTab[ j ][ i ] = 64 - nDist;
			}
		}
	}

	int   nPosSum    = 0,
		  nNegSum    = 0;
	int   nPosStat   = 0,
		  nNegStat   = 0;
	int   nFuzzyVal  = 0,
		  nMaxReside = 0,
		  nMaxNo     = 0;

	for ( i = 0; i < 256; ++ i )
	{
		nPosSum = nNegSum = nPosStat = nNegStat = 0;
		for ( int j = 0; j < 16; ++ j )
		{
			if ( m_nFuzzyTab[ i ][ j ] > 0 )
			{
				nPosSum += m_nFuzzyTab[ i ][ j ];
			}
			else if ( m_nFuzzyTab[ i ][ j ] < 0 )
			{
				nNegSum -= m_nFuzzyTab[ i ][ j ];
			}
		}

		for ( j = 0; j < 16; ++ j )
		{
			if ( m_nFuzzyTab[ i ][ j ] > 0 )
			{
				nFuzzyVal    = m_nFuzzyTab[ i ][ j ] * 16 / nPosSum;
				nReside[ j ] = m_nFuzzyTab[ i ][ j ] - nFuzzyVal * nPosSum / 16;
				m_nFuzzyTab[ i ][ j ] = nFuzzyVal;
				nPosStat             += nFuzzyVal;
			}
			else if ( m_nFuzzyTab[ i ][ j] < 0 )
			{
				nFuzzyVal    = m_nFuzzyTab[ i ][ j ] * 16 / nNegSum;
				nReside[ j ] = m_nFuzzyTab[ i ][ j ] - nFuzzyVal * nNegSum / 16; 
				m_nFuzzyTab[ i ][ j ] = nFuzzyVal;
				nNegStat             -= nFuzzyVal;
			}
			else
			{
				nReside[ j ] = 0;
			}
		}

		if ( nPosStat < 16 )
		{
			while ( nPosStat < 16 )
			{
				nMaxReside = nMaxNo = 0;
				for ( j = 0; j < 16; ++ j )
				{
					if ( m_nFuzzyTab[ i ][ j ] >= 0 )
					{
						if ( nMaxReside < nReside[ j ] )
						{
							nMaxReside = nReside[ j ];
							nMaxNo     = j;
						}
					}
				}

				nReside[ nMaxNo ] = 0;
				++m_nFuzzyTab[ i ][ nMaxNo ];
				++nPosStat;
			}
		}

		if ( nNegStat < 16 )
		{
			while ( nNegStat < 16 )
			{
				nMaxReside = nMaxNo = 0;
				for ( j = 0; j < 16; ++ j )
				{
					if ( m_nFuzzyTab[ i ][ j ] <= 0 )
					{
						if ( nMaxReside > nReside[ j ] )
						{
							nMaxReside = nReside[ j ];
							nMaxNo     = j;
						}
					}
				}

				nReside[ nMaxNo ] = 0;
				--m_nFuzzyTab[ i ][ nMaxNo ];
				++nNegStat;
			}
		}
	}
}


void CFuzzy::FuzzyProbModel( LPBYTE lpThisBits, LPBYTE lpFGBits )
{
	const BYTE byMeanVal[ 16 ] = { 8,   24,  40,  56,  72,  88,  104, 120,
		                           136, 152, 168, 184, 200, 216, 232, 248 };
	int   *pProb = m_pFuzzyProb;
	LPBYTE pSrc = lpThisBits,
		   pFG  = lpFGBits;
	short  snDbRawBytes = RAW_BYTES * 2;
	BYTE   byThisVal_1 = 0,
		   byThisVal_2 = 0,
		   byThisVal_3 = 0,
		   byThisVal_4 = 0;

	for ( short h = 0; h < m_snImageHeight; h += 2 )
	{
		for ( short w = 0; w < m_snRowBytes; w += snDbRawBytes )
		{
			register int dwDiffCount = 0,
				         dwDiffSum   = 0;

			if ( pProb[ 0 ] > 0 )
			{
				dwDiffCount += pProb[ 0 ];
				dwDiffSum   += pProb[ 0 ] * byMeanVal[ 0 ];
			}
			if ( pProb[ 1 ] > 0 )
			{
				dwDiffCount += pProb[ 1 ];
				dwDiffSum   += pProb[ 1 ] * byMeanVal[ 1 ];
			}
			if ( pProb[ 2 ] > 0 )
			{
				dwDiffCount += pProb[ 2 ];
				dwDiffSum   += pProb[ 2 ] * byMeanVal[ 2 ];
			}
			if ( pProb[ 3 ] > 0 )
			{
				dwDiffCount += pProb[ 3 ];
				dwDiffSum   += pProb[ 3 ] * byMeanVal[ 3 ];
			}
			if ( pProb[ 4 ] > 0 )
			{
				dwDiffCount += pProb[ 4 ];
				dwDiffSum   += pProb[ 4 ] * byMeanVal[ 4 ];
			}
			if ( pProb[ 5 ] > 0 )
			{
				dwDiffCount += pProb[ 5 ];
				dwDiffSum   += pProb[ 5 ] * byMeanVal[ 5 ];
			}
			if ( pProb[ 6 ] > 0 )
			{
				dwDiffCount += pProb[ 6 ];
				dwDiffSum   += pProb[ 6 ] * byMeanVal[ 6 ];
			}
			if ( pProb[ 7 ] > 0 )
			{
				dwDiffCount += pProb[ 7 ];
				dwDiffSum   += pProb[ 7 ] * byMeanVal[ 7 ];
			}
			if ( pProb[ 8 ] > 0 )
			{
				dwDiffCount += pProb[ 8 ];
				dwDiffSum   += pProb[ 8 ] * byMeanVal[ 8 ];
			}
			if ( pProb[ 9 ] > 0 )
			{
				dwDiffCount += pProb[ 9 ];
				dwDiffSum   += pProb[ 9 ] * byMeanVal[ 9 ];
			}
			if ( pProb[ 10 ] > 0 )
			{
				dwDiffCount += pProb[ 10 ];
				dwDiffSum   += pProb[ 10 ] * byMeanVal[ 10 ];
			}
			if ( pProb[ 11 ] > 0 )
			{
				dwDiffCount += pProb[ 11 ];
				dwDiffSum   += pProb[ 11 ] * byMeanVal[ 11 ];
			}
			if ( pProb[ 12 ] > 0 )
			{
				dwDiffCount += pProb[ 12 ];
				dwDiffSum   += pProb[ 12 ] * byMeanVal[ 12 ];
			}
			if ( pProb[ 13 ] > 0 )
			{
				dwDiffCount += pProb[ 13 ];
				dwDiffSum   += pProb[ 13 ] * byMeanVal[ 13 ];
			}
			if ( pProb[ 14 ] > 0 )
			{
				dwDiffCount += pProb[ 14 ];
				dwDiffSum   += pProb[ 14 ] * byMeanVal[ 14 ];
			}
			if ( pProb[ 15 ] > 0 )
			{
				dwDiffCount += pProb[ 15 ];
				dwDiffSum   += pProb[ 15 ] * byMeanVal[ 15 ];
			}

			byThisVal_1 = pSrc[ w ];
			byThisVal_2 = pSrc[ w + RAW_BYTES ];
			byThisVal_3 = pSrc[ w + m_snRowBytes ];
			byThisVal_4 = pSrc[ w + m_snRowBytes + RAW_BYTES ];

			if ( dwDiffCount > 0 )
			{
				register BYTE byMeanVal = (BYTE)( dwDiffSum / dwDiffCount );
				if ( byThisVal_1 > byMeanVal )
				{
					pFG[ w ] = pFG[ w + 1 ] = byThisVal_1 - byMeanVal;
					pFG[ w + 2 ] = 0;
				}
				else
				{
					pFG[ w ] = pFG[ w + 1 ] = 0;
					pFG[ w + 2 ] = byMeanVal - byThisVal_1;
				}

				if ( byThisVal_2 > byMeanVal )
				{
					pFG[ w + RAW_BYTES ] = pFG[ w  + RAW_BYTES + 1 ] = byThisVal_2 - byMeanVal;
					pFG[ w + RAW_BYTES + 2 ] = 0;
				}
				else
				{
					pFG[ w + RAW_BYTES ] = pFG[ w  + RAW_BYTES + 1 ] = 0;
					pFG[ w + RAW_BYTES + 2 ] = byMeanVal - byThisVal_2;
				}

				if ( byThisVal_3 > byMeanVal )
				{
					pFG[ w + m_snRowBytes ] = pFG[ w + m_snRowBytes + 1 ] = byThisVal_3 - byMeanVal;
					pFG[ w + m_snRowBytes + 2 ] = 0;
				}
				else
				{
					pFG[ w + m_snRowBytes ] = pFG[ w + m_snRowBytes + 1 ] = 0;
					pFG[ w + m_snRowBytes + 2 ] = byMeanVal - byThisVal_3;
				}
					           
				if ( byThisVal_4 > byMeanVal )
				{
					pFG[ w + m_snRowBytes + RAW_BYTES ] = pFG[ w + m_snRowBytes + RAW_BYTES + 1 ] = byThisVal_4 - byMeanVal;
					pFG[ w + m_snRowBytes + RAW_BYTES + 2 ] = 0;
				}
				else
				{
					pFG[ w + m_snRowBytes + RAW_BYTES ] = pFG[ w + m_snRowBytes + RAW_BYTES + 1 ] = 0;
					pFG[ w + m_snRowBytes + RAW_BYTES + 2 ] = byMeanVal - byThisVal_4;
				}
			}
			else
			{
				pFG[ w ]                                      = pFG[ w + 1 ] 
					= pFG[ w + 2 ]                            = 0;
				pFG[ w + RAW_BYTES ]                          = pFG[ w  + RAW_BYTES + 1 ]
					= pFG[ w + RAW_BYTES + 2 ]                = 0;
				pFG[ w + m_snRowBytes ]                       = pFG[ w + m_snRowBytes + 1 ]
					= pFG[ w + m_snRowBytes + 2 ]             = 0;
				pFG[ w + m_snRowBytes + RAW_BYTES ]           = pFG[ w + m_snRowBytes + RAW_BYTES + 1 ] 
					= pFG[ w + m_snRowBytes + RAW_BYTES + 2 ] = 0;
			}

			pProb[ 0 ] += m_nFuzzyTab[ byThisVal_1 ][ 0 ] + m_nFuzzyTab[ byThisVal_2 ][ 0 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 0 ] + m_nFuzzyTab[ byThisVal_4 ][ 0 ];
			pProb[ 1 ] += m_nFuzzyTab[ byThisVal_1 ][ 1 ] + m_nFuzzyTab[ byThisVal_2 ][ 1 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 1 ] + m_nFuzzyTab[ byThisVal_4 ][ 1 ];
			pProb[ 2 ] += m_nFuzzyTab[ byThisVal_1 ][ 2 ] + m_nFuzzyTab[ byThisVal_2 ][ 2 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 2 ] + m_nFuzzyTab[ byThisVal_4 ][ 2 ];
			pProb[ 3 ] += m_nFuzzyTab[ byThisVal_1 ][ 3 ] + m_nFuzzyTab[ byThisVal_2 ][ 3 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 3 ] + m_nFuzzyTab[ byThisVal_4 ][ 3 ];
			pProb[ 4 ] += m_nFuzzyTab[ byThisVal_1 ][ 4 ] + m_nFuzzyTab[ byThisVal_2 ][ 4 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 4 ] + m_nFuzzyTab[ byThisVal_4 ][ 4 ];
			pProb[ 5 ] += m_nFuzzyTab[ byThisVal_1 ][ 5 ] + m_nFuzzyTab[ byThisVal_2 ][ 5 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 5 ] + m_nFuzzyTab[ byThisVal_4 ][ 5 ];
			pProb[ 6 ] += m_nFuzzyTab[ byThisVal_1 ][ 6 ] + m_nFuzzyTab[ byThisVal_2 ][ 6 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 6 ] + m_nFuzzyTab[ byThisVal_4 ][ 6 ];
			pProb[ 7 ] += m_nFuzzyTab[ byThisVal_1 ][ 7 ] + m_nFuzzyTab[ byThisVal_2 ][ 7 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 7 ] + m_nFuzzyTab[ byThisVal_4 ][ 7 ];
			pProb[ 8 ] += m_nFuzzyTab[ byThisVal_1 ][ 8 ] + m_nFuzzyTab[ byThisVal_2 ][ 8 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 8 ] + m_nFuzzyTab[ byThisVal_4 ][ 8 ];
			pProb[ 9 ] += m_nFuzzyTab[ byThisVal_1 ][ 9 ] + m_nFuzzyTab[ byThisVal_2 ][ 9 ]
				        + m_nFuzzyTab[ byThisVal_3 ][ 9 ] + m_nFuzzyTab[ byThisVal_4 ][ 9 ];
			pProb[ 10 ] += m_nFuzzyTab[ byThisVal_1 ][ 10 ] + m_nFuzzyTab[ byThisVal_2 ][ 10 ]
				         + m_nFuzzyTab[ byThisVal_3 ][ 10 ] + m_nFuzzyTab[ byThisVal_4 ][ 10 ];
			pProb[ 11 ] += m_nFuzzyTab[ byThisVal_1 ][ 11 ] + m_nFuzzyTab[ byThisVal_2 ][ 11 ]
				         + m_nFuzzyTab[ byThisVal_3 ][ 11 ] + m_nFuzzyTab[ byThisVal_4 ][ 11 ];
			pProb[ 12 ] += m_nFuzzyTab[ byThisVal_1 ][ 12 ] + m_nFuzzyTab[ byThisVal_2 ][ 12 ]
				         + m_nFuzzyTab[ byThisVal_3 ][ 12 ] + m_nFuzzyTab[ byThisVal_4 ][ 12 ];
			pProb[ 13 ] += m_nFuzzyTab[ byThisVal_1 ][ 13 ] + m_nFuzzyTab[ byThisVal_2 ][ 13 ]
				         + m_nFuzzyTab[ byThisVal_3 ][ 13 ] + m_nFuzzyTab[ byThisVal_4 ][ 13 ];
			pProb[ 14 ] += m_nFuzzyTab[ byThisVal_1 ][ 14 ] + m_nFuzzyTab[ byThisVal_2 ][ 14 ]
				         + m_nFuzzyTab[ byThisVal_3 ][ 14 ] + m_nFuzzyTab[ byThisVal_4 ][ 14 ];
			pProb[ 15 ] += m_nFuzzyTab[ byThisVal_1 ][ 15 ] + m_nFuzzyTab[ byThisVal_2 ][ 15 ]
				         + m_nFuzzyTab[ byThisVal_3 ][ 15 ] + m_nFuzzyTab[ byThisVal_4 ][ 15 ];

			pProb += 16;
		}

		pSrc += m_snRowBytes * 2;
		pFG  += m_snRowBytes * 2;
	}
}