Embedded/common/src/b_BitFeatureEm/Scanner.c

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* ---- includes ----------------------------------------------------------- */

#include "b_BasicEm/Functions.h"
#include "b_BasicEm/Math.h"
#include "b_BitFeatureEm/Scanner.h"

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ auxiliary functions } ---------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

/** multiplies a scale with a 0.32 scale factor */
uint32 bbf_Scanner_scalePrd( uint32 scaleA, uint32 factorA /*0.32 */ )\
{
	return      ( scaleA >> 16     ) * ( factorA >> 16     ) + 
			( ( ( scaleA & 0x0FFFF ) * ( factorA >> 16     ) ) >> 16 ) +
			( ( ( scaleA >> 16     ) * ( factorA & 0x0FFFF ) ) >> 16 );
}

/* ------------------------------------------------------------------------- */

/** allocates arays */
void bbf_Scanner_alloc( struct bbs_Context* cpA,
						struct bbf_Scanner* ptrA, 
						struct bbs_MemTbl* mtpA,
						flag maximizeSharedMemoryA )
{
	struct bbs_MemTbl memTblL = *mtpA;
	struct bbs_MemSeg* espL = bbs_MemTbl_segPtr( cpA, &memTblL, 0 );
	struct bbs_MemSeg* sspL = bbs_MemTbl_sharedSegPtr( cpA, &memTblL, 0 );
	struct bbs_MemSeg* mspL = maximizeSharedMemoryA ? sspL : espL;

	/* filter patch dimension */
	uint32 proL = ptrA->maxRadiusE;
	uint32 pwoL = ( proL << 1 ) + 1;

	/* output image size (bit image) */
	uint32 woL = ptrA->maxImageWidthE;
	uint32 hoL = ptrA->maxImageHeightE;

	/* extended output image size (bit image) considering borders */
	uint32 xwoL = woL + ( ptrA->borderWidthE  << 1 );
	uint32 xhoL = hoL + ( ptrA->borderHeightE << 1 );

	/* allocate working image */
	bbs_UInt16Arr_create( cpA, &ptrA->workImageE, ( ( woL >> 1 ) + ( woL & 1 ) ) * hoL, mspL );
	if( bbs_Context_error( cpA ) ) return;
	bbs_UInt16Arr_fill( cpA, &ptrA->workImageE, 0 );

	/* allocate bit image */
	bim_UInt32Image_create( cpA, &ptrA->bitImageE, xwoL, ( xhoL >> 5 ) + ( ( ( xhoL & 0x1F ) != 0 ) ? 1 : 0 ), mspL );
	if( bbs_Context_error( cpA ) ) return;
	bim_UInt32Image_setAllPixels( cpA, &ptrA->bitImageE, 0, 0 );

	/* allocate patch buffer */
	bbs_UInt32Arr_create( cpA, &ptrA->patchBufferE, ptrA->bitImageE.widthE, mspL );
	if( bbs_Context_error( cpA ) ) return;
	bbs_UInt32Arr_fill( cpA, &ptrA->patchBufferE, 0 );

	/* allocate line buffer */
	bbs_UInt16Arr_create( cpA, &ptrA->lineBufE, woL + ( woL & 1 ), sspL );

	/* allocate table */
	bim_UInt32Image_create( cpA, &ptrA->satE, woL + pwoL, pwoL + 1, sspL );

	/* allocate buffers */
	bbs_UInt32Arr_create( cpA, &ptrA->idxArrE, ptrA->bufferSizeE, mspL );
	bbs_Int32Arr_create(  cpA, &ptrA->actArrE, ptrA->bufferSizeE, mspL );

	bbs_Int32Arr_create(  cpA, &ptrA->outArrE, ptrA->bufferSizeE >> 1, espL );
}

/* ------------------------------------------------------------------------- */

/** downscales work image */
void bbf_Scanner_downscale( struct bbs_Context* cpA, struct bbf_Scanner* ptrA )
{
	uint32 w0L = ptrA->workWidthE;
	uint32 h0L = ptrA->workHeightE;
	uint32 w1L = w0L >> 1;
	uint32 h1L = h0L >> 1;
	uint32 w20L = ( w0L >> 1 ) + ( w0L & 1 );
	uint16* arrL = ptrA->workImageE.arrPtrE;

	uint32 iL, jL;
	uint32 kL = 0;
	for( jL = 0; jL < h1L; jL++ )
	{
		for( iL = 0; iL < ( w1L >> 1 ); iL++ )
		{
			uint16 loL, hiL;
			uint32 idxL = jL * 2 * w20L + iL * 2;

			loL = ( ( arrL[ idxL ] & 0x00FF ) + ( arrL[ idxL ] >> 8 ) + ( arrL[ idxL + w20L ] & 0x00FF ) + ( arrL[ idxL + w20L ] >> 8 ) + 2 ) >> 2;
			idxL++;
			hiL = ( ( arrL[ idxL ] & 0x00FF ) + ( arrL[ idxL ] >> 8 ) + ( arrL[ idxL + w20L ] & 0x00FF ) + ( arrL[ idxL + w20L ] >> 8 ) + 2 ) >> 2;

			arrL[ kL ] = loL | ( hiL << 8 );
			kL++;
		}
		if( ( w1L & 1 ) != 0 )
		{
			uint32 idxL = jL * 2 * w20L + iL;
			arrL[ kL++ ] = ( ( arrL[ idxL ] & 0x00FF ) + ( arrL[ idxL ] >> 8 ) + ( arrL[ idxL + w20L ] & 0x00FF ) + ( arrL[ idxL + w20L ] >> 8 ) + 2 ) >> 2;
		}
	}

	ptrA->workWidthE = w1L;
	ptrA->workHeightE = h1L;
	ptrA->scaleExpE++;
}

/* ------------------------------------------------------------------------- */

/** copies image
 * handling for 8 bit images is implemented 
 * 16 bit image handling for the whole class needs to be added in this function only
 */
void bbf_Scanner_copyImage( struct bbs_Context* cpA, struct bbf_Scanner* ptrA, const void* imagePtrA, uint32 imageWidthA, uint32 imageHeightA, const struct bts_Int16Rect* roiPtrA )
{
	bbs_DEF_fNameL( "void bbf_Scanner_copyImage( struct bbs_Context* cpA, struct bbf_Scanner* ptrA, const struct bim_UInt16ByteImage* imagePtrA, const struct bts_Int16Rect* roiPtrA )" )

	if( imageWidthA > ptrA->maxImageWidthE || imageHeightA > ptrA->maxImageHeightE ) 
	{
		bbs_ERROR5( "%s:\n Input image (%ix%i)is too large; Scanner is configured for maximal (%ix%i)", 
			fNameL, imageWidthA, imageHeightA, ptrA->maxImageWidthE, ptrA->maxImageHeightE );
		return;
	}

	if( roiPtrA == 0 )
	{
		uint32 iL, jL;
		const uint8*  srcL = ( uint8* )imagePtrA;
		uint16* dstL = ptrA->workImageE.arrPtrE;
		ptrA->workWidthE  = imageWidthA;
		ptrA->workHeightE = imageHeightA;
		for( iL = 0; iL < ptrA->workHeightE; iL++ )
		{
			for( jL = ptrA->workWidthE >> 1; jL > 0; jL-- )
			{
				*dstL++ = ( uint16 )srcL[ 0 ] | ( uint16 )srcL[ 1 ] << 8;
				srcL += 2;
			}

			/* uneven width */
			if( ptrA->workWidthE & 1 ) *dstL++ = *srcL++;
		}
	}
	else
	{
		uint32 iL, jL;
		const uint8* srcL = ( uint8* )imagePtrA + roiPtrA->y1E * imageWidthA + roiPtrA->x1E;
		uint16* dstL = ptrA->workImageE.arrPtrE;

		if( roiPtrA->x2E <= roiPtrA->x1E || roiPtrA->y2E <= roiPtrA->y1E )
		{
			bbs_ERROR1( "%s:\n ROI is invalid or zero", fNameL );
			return;
		}
		if( roiPtrA->x1E < 0 || roiPtrA->y1E < 0 || roiPtrA->x2E > ( int32 )imageWidthA || roiPtrA->y2E > ( int32 )imageHeightA )
		{
			bbs_ERROR1( "%s:\n ROI exceeds image boundary", fNameL );
			return;
		}

		ptrA->workWidthE  = roiPtrA->x2E - roiPtrA->x1E;
		ptrA->workHeightE = roiPtrA->y2E - roiPtrA->y1E;
		for( iL = 0; iL < ptrA->workHeightE; iL++ )
		{
			for( jL = ptrA->workWidthE >> 1; jL > 0; jL-- )
			{
				*dstL++ = ( uint16 )srcL[ 0 ] | ( uint16 )srcL[ 1 ] << 8;
				srcL += 2;
			}

			/* uneven width */
			if( ptrA->workWidthE & 1 ) *dstL++ = *srcL++;

			srcL += imageWidthA - ptrA->workWidthE;
		}
	}
}

/* ------------------------------------------------------------------------- */

/** creates bit image */
void bbf_Scanner_createBitImage( struct bbs_Context* cpA, struct bbf_Scanner* ptrA )
{
	bbs_DEF_fNameL( "void bbf_Scanner_createBitImage( struct bbs_Context* cpA, struct bbf_Scanner* ptrA )" )


	/* declarations */
	uint32 proL, priL, pwoL, pwiL;
	uint32 wiL, wi2L, hiL, woL, hoL, xwoL, xhoL; /* image size specifies */
	uint32 stepL;    /* scan step (16.16) */
	uint32 bitMaskL; /* current bit mask */
	uint32* bitRowL; /* pointer to bit-row */
	uint32 wsL, hsL; /* size of summed area table (ringbuffer) */
	uint32 satSizeL; 
	uint32* satL;     /* pointer to summed area table */
	uint16* lBufL;	  /* pointer to line buffer */
	uint32 yfL;       /* fixed point y-coordinate (16.16) */
	uint32 iL, jL;

	uint32 swi1L; /* table writing index */
	uint32 swi2L; /* table writing index */
	uint32 sriL;  /* table reading index */

	uint32 poAreaL, piAreaL; /* areas of inner and outer rectangles */
	uint32 siL[ 8 ]; /* table indices */


	proL = ptrA->bitParamE.outerRadiusE;
	priL = ptrA->bitParamE.innerRadiusE;
	pwoL = ( proL << 1 ) + 1;
	pwiL = ( priL << 1 ) + 1;

	if( ptrA->borderHeightE >= 32 )
	{
		bbs_ERROR1( "%s:\n borderHeightE >= 32", fNameL );
		return;
	}

	if( proL <= priL )
	{
		bbs_ERROR1( "%s:\n outer radius <= inner radius", fNameL );
		return;
	}

	/* input image size (bit image) */
	wiL = ptrA->workWidthE;
	hiL = ptrA->workHeightE;
	wi2L = ( wiL >> 1 ) + ( wiL & 1 );

	/* 16.16 */
	stepL = ptrA->scaleE >> ( ptrA->scaleExpE + 4 );

	/* output image size (bit image) */
	woL = ( wiL << 16 ) / stepL;
	hoL = ( hiL << 16 ) / stepL;

	if( woL <= pwoL || hoL <= pwoL )
	{
		bbs_ERROR1( "%s:\n scaled image is too small", fNameL );
		return;
	}

	if( woL * stepL >= ( wiL << 16 ) ) woL--;
	if( hoL * stepL >= ( hiL << 16 ) ) hoL--;

	/* extended output image size (bit image) considering borders */
	xwoL = woL + ( ptrA->borderWidthE  << 1 );
	xhoL = hoL + ( ptrA->borderHeightE << 1 );

	ptrA->currentWidthE  = xwoL;
	ptrA->currentHeightE = xhoL;

	/* initialize bit image */
	bim_UInt32Image_size( cpA, &ptrA->bitImageE, xwoL, ( xhoL >> 5 ) + ( ( ( xhoL & 0x1F ) != 0 ) ? 1 : 0 ) );
	bim_UInt32Image_setAllPixels( cpA, &ptrA->bitImageE, 0, 0 );

	bitMaskL = ( uint32 )1 << ptrA->borderHeightE;
	bitRowL = ( uint32* )ptrA->bitImageE.arrE.arrPtrE + ptrA->borderWidthE;

	/* width of table */
	wsL = woL + pwoL;

	/* height of table */
	hsL = pwoL + 1;

	bim_UInt32Image_size( cpA, &ptrA->satE, wsL, hsL );

	satL = ptrA->satE.arrE.arrPtrE;
	satSizeL = wsL * hsL;

	lBufL = ptrA->lineBufE.arrPtrE;

	yfL = 0; /* fixed point y-coordinate ( 16.16 )*/

	swi1L = 0; /* table writing index */
	swi2L = 0; /* table writing index */
	sriL = 0;  /* table reading index */

	/* areas of inner and outer rectangles */
	poAreaL = pwoL * pwoL;
	piAreaL = pwiL * pwiL;

	/* interpolate pixels; compute table and bit image */

	for( iL = wsL * ( proL + 1 ); iL > 0; iL-- ) satL[ swi1L++ ] = 0;
	swi2L = swi1L - wsL;

	for( jL = 0; jL < hoL + proL; jL++ )
	{
		if( jL < hoL ) /* rescale area */
		{
			uint32 ypL = ( yfL >> 16 );
			uint32 yoff1L = yfL & 0x0FFFF;
			uint32 yoff0L = 0x010000 - yoff1L;
			const uint16* arr0L = ptrA->workImageE.arrPtrE + ypL * wi2L;
			const uint16* arr1L = arr0L + wi2L;

			
			uint32 xfL   = 0; /* fixed point x-coordinate (16.16) */
			uint32 hSumL = 0;

			yfL += stepL;

			for( iL = 0; iL <= proL; iL++ ) satL[ swi1L++ ] = 0;
			swi2L += iL;

			/* fill line buffer */
			for( iL = 0; iL < wi2L; iL++ )
			{
				lBufL[ iL * 2     ] = ( ( ( arr0L[ iL ] & 0x0FF ) * yoff0L ) + ( ( arr1L[ iL ] & 0x0FF ) * yoff1L ) ) >> 10;
				lBufL[ iL * 2 + 1 ] = ( ( ( arr0L[ iL ] >> 8    ) * yoff0L ) + ( ( arr1L[ iL ] >> 8    ) * yoff1L ) ) >> 10;
			}

			for( iL = 0; iL < woL; iL++ )
			{
				uint32 xpL = ( xfL >> 16 );
				uint32 xoff1L = xfL & 0x0FFFF;
				uint16 pixL = ( lBufL[ xpL ] * ( 0x010000 - xoff1L ) + lBufL[ xpL + 1 ] * xoff1L ) >> 22;
				satL[ swi1L ] = ( hSumL += pixL ) + satL[ swi2L ];
				xfL += stepL;
				swi1L++;
				swi2L++;
			}

			for( iL = 0; iL < proL; iL++ )
			{
				satL[ swi1L ] = hSumL + satL[ swi2L ];
				swi1L++;
				swi2L++;
			}
		}
		else /* image is processed - fill in 0s */
		{
			for( iL = 0; iL < wsL; iL++ ) satL[ swi1L++ ] = satL[ swi2L++ ];
		}

		swi1L = ( swi1L < satSizeL ) ? swi1L : 0;
		swi2L = ( swi2L < satSizeL ) ? swi2L : 0;

		/* fill line in bit image */
		if( jL >= proL ) 
		{
			const uint32* rSatL = satL;

			/* table coordinate indices for outer rectangle */
			siL[ 0 ] = sriL;
			siL[ 1 ] = siL[ 0 ] + pwoL;
			siL[ 2 ] = siL[ 0 ] + pwoL * wsL;
			siL[ 2 ] -= ( siL[ 2 ] >= satSizeL ) ? satSizeL : 0;
			siL[ 3 ] = siL[ 2 ] + pwoL;

			/* table coordinate indices for inner rectangle */
			siL[ 4 ] = siL[ 0 ] + ( proL - priL ) * wsL + ( proL - priL );
			siL[ 4 ] -= ( siL[ 4 ] >= satSizeL ) ? satSizeL : 0;
			siL[ 5 ] = siL[ 4 ] + pwiL;
			siL[ 6 ] = siL[ 4 ] + pwiL * wsL;
			siL[ 6 ] -= ( siL[ 6 ] >= satSizeL ) ? satSizeL : 0;
			siL[ 7 ] = siL[ 6 ] + pwiL;
			sriL += wsL;
			if( sriL == satSizeL ) sriL = 0;

			for( iL = 0; iL < woL; iL++ )
			{
				uint32 oAvgL = ( rSatL[ siL[ 0 ] ] - rSatL[ siL[ 1 ] ] - rSatL[ siL[ 2 ] ] + rSatL[ siL[ 3 ] ] ) * piAreaL;
				uint32 iAvgL = ( rSatL[ siL[ 4 ] ] - rSatL[ siL[ 5 ] ] - rSatL[ siL[ 6 ] ] + rSatL[ siL[ 7 ] ] ) * poAreaL;
				bitRowL[ iL ] |= ( iAvgL > oAvgL ) ? bitMaskL : 0;
				rSatL++;
			}
			if( ( bitMaskL <<= 1 ) == 0 )
			{
				bitRowL += xwoL;
				bitMaskL = 1;
			}
		}
	}
}

/* ------------------------------------------------------------------------- */

/** initialize patch buffer */
void bbf_Scanner_initPatchBuffer( struct bbs_Context* cpA, struct bbf_Scanner* ptrA )
{
	bbs_UInt32Arr_size( cpA, &ptrA->patchBufferE, ptrA->bitImageE.widthE );	
	bbs_memcpy32( ptrA->patchBufferE.arrPtrE, ptrA->bitImageE.arrE.arrPtrE, ptrA->bitImageE.widthE );
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ constructor / destructor } ----------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

void bbf_Scanner_init( struct bbs_Context* cpA,
					   struct bbf_Scanner* ptrA )
{
	ptrA->scaleExpE = 0;
	ptrA->scaleE = 0;
	ptrA->xE = 0;
	ptrA->yE = 0;
	ptrA->effMaxScaleE = 0;
	ptrA->currentWidthE = 0;
	ptrA->currentHeightE = 0;
	ptrA->workWidthE = 0;
	ptrA->workHeightE = 0;
	bbf_BitParam_init( cpA, &ptrA->bitParamE );
	bbs_UInt16Arr_init( cpA, &ptrA->workImageE );
	bim_UInt32Image_init( cpA, &ptrA->satE );
	bim_UInt32Image_init( cpA, &ptrA->bitImageE );
	bbs_UInt32Arr_init( cpA, &ptrA->patchBufferE );
	bbs_UInt16Arr_init( cpA, &ptrA->lineBufE );

	bbs_UInt32Arr_init( cpA, &ptrA->idxArrE );
	bbs_Int32Arr_init( cpA, &ptrA->actArrE );
	bbs_Int32Arr_init( cpA, &ptrA->outArrE );
	ptrA->outCountE = 0;
	ptrA->intCountE = 0;
	ptrA->bufferSizeE = 1024;

	ptrA->maxImageWidthE = 0;
	ptrA->maxImageHeightE = 0;
	ptrA->maxRadiusE = 0;
	ptrA->patchWidthE = 0;
	ptrA->patchHeightE = 0;
	ptrA->minScaleE = 0;
	ptrA->maxScaleE = 0;
	ptrA->scaleStepE = 0;
	ptrA->borderWidthE = 0;
	ptrA->borderHeightE = 0;
}

/* ------------------------------------------------------------------------- */

void bbf_Scanner_exit( struct bbs_Context* cpA,
				       struct bbf_Scanner* ptrA )
{
	ptrA->scaleExpE = 0;
	ptrA->scaleE = 0;
	ptrA->xE = 0;
	ptrA->yE = 0;
	ptrA->effMaxScaleE = 0;
	ptrA->currentWidthE = 0;
	ptrA->currentHeightE = 0;
	ptrA->workWidthE = 0;
	ptrA->workHeightE = 0;
	bbf_BitParam_exit( cpA, &ptrA->bitParamE );
	bbs_UInt16Arr_exit( cpA, &ptrA->workImageE );
	bim_UInt32Image_exit( cpA, &ptrA->satE );
	bim_UInt32Image_exit( cpA, &ptrA->bitImageE );
	bbs_UInt32Arr_exit( cpA, &ptrA->patchBufferE );
	bbs_UInt16Arr_exit( cpA, &ptrA->lineBufE );

	bbs_UInt32Arr_exit( cpA, &ptrA->idxArrE );
	bbs_Int32Arr_exit( cpA, &ptrA->actArrE );
	bbs_Int32Arr_exit( cpA, &ptrA->outArrE );
	ptrA->outCountE = 0;
	ptrA->intCountE = 0;
	ptrA->bufferSizeE = 1024;

	ptrA->maxImageWidthE = 0;
	ptrA->maxImageHeightE = 0;
	ptrA->maxRadiusE = 0;
	ptrA->patchWidthE = 0;
	ptrA->patchHeightE = 0;
	ptrA->minScaleE = 0;
	ptrA->maxScaleE = 0;
	ptrA->scaleStepE = 0;
	ptrA->borderWidthE = 0;
	ptrA->borderHeightE = 0;
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ operators } -------------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

void bbf_Scanner_copy( struct bbs_Context* cpA,
				       struct bbf_Scanner* ptrA, 
					   const struct bbf_Scanner* srcPtrA )
{
	ptrA->scaleExpE = srcPtrA->scaleExpE;
	ptrA->scaleE = srcPtrA->scaleE;
	ptrA->xE = srcPtrA->xE;
	ptrA->yE = srcPtrA->yE;
	ptrA->effMaxScaleE = srcPtrA->effMaxScaleE;
	ptrA->currentWidthE = srcPtrA->currentWidthE;
	ptrA->currentHeightE = srcPtrA->currentHeightE;
	ptrA->workWidthE = srcPtrA->workWidthE;
	ptrA->workHeightE = srcPtrA->workHeightE;

	bbf_BitParam_copy( cpA, &ptrA->bitParamE, &srcPtrA->bitParamE );
	bbs_UInt16Arr_copy( cpA, &ptrA->workImageE, &srcPtrA->workImageE );
	bim_UInt32Image_copy( cpA, &ptrA->satE, &srcPtrA->satE );
	bim_UInt32Image_copy( cpA, &ptrA->bitImageE, &srcPtrA->bitImageE );
	bbs_UInt32Arr_copy( cpA, &ptrA->patchBufferE, &srcPtrA->patchBufferE );
	bbs_UInt16Arr_copy( cpA, &ptrA->lineBufE, &srcPtrA->lineBufE );

	ptrA->maxImageWidthE = srcPtrA->maxImageWidthE;
	ptrA->maxImageHeightE = srcPtrA->maxImageHeightE;
	ptrA->maxRadiusE = srcPtrA->maxRadiusE;
	ptrA->patchWidthE = srcPtrA->patchWidthE;
	ptrA->patchHeightE = srcPtrA->patchHeightE;
	ptrA->minScaleE = srcPtrA->minScaleE;
	ptrA->maxScaleE = srcPtrA->maxScaleE;
	ptrA->scaleStepE = srcPtrA->scaleStepE;
	ptrA->borderWidthE = srcPtrA->borderWidthE;
	ptrA->borderHeightE = srcPtrA->borderHeightE;
}

/* ------------------------------------------------------------------------- */

flag bbf_Scanner_equal( struct bbs_Context* cpA,
				        const struct bbf_Scanner* ptrA, 
						const struct bbf_Scanner* srcPtrA )
{
	if( ptrA->maxImageWidthE != srcPtrA->maxImageWidthE ) return FALSE;
	if( ptrA->maxImageHeightE != srcPtrA->maxImageHeightE ) return FALSE;
	if( ptrA->maxRadiusE != srcPtrA->maxRadiusE ) return FALSE;
	if( ptrA->patchWidthE != srcPtrA->patchWidthE ) return FALSE;
	if( ptrA->patchHeightE != srcPtrA->patchHeightE ) return FALSE;
	if( ptrA->minScaleE != srcPtrA->minScaleE ) return FALSE;
	if( ptrA->maxScaleE != srcPtrA->maxScaleE ) return FALSE;
	if( ptrA->scaleStepE != srcPtrA->scaleStepE ) return FALSE;
	if( ptrA->borderWidthE != srcPtrA->borderWidthE ) return FALSE;
	if( ptrA->borderHeightE != srcPtrA->borderHeightE ) return FALSE;
	return TRUE;
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ query functions } -------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */

uint32 bbf_Scanner_positions( const struct bbf_Scanner* ptrA )
{
	int32 wL = ( int32 )ptrA->currentWidthE - ptrA->patchWidthE;
	int32 hL = ( int32 )ptrA->currentHeightE - ptrA->patchHeightE;
	return ( wL >= 0 ? wL : 0 ) * ( hL >= 0 ? hL : 0 );
}

/* ------------------------------------------------------------------------- */

uint32 bbf_Scanner_scanIndex( const struct bbf_Scanner* ptrA )
{
	return ptrA->yE * ptrA->currentWidthE + ptrA->xE;
}

/* ------------------------------------------------------------------------- */

void bbf_Scanner_pos( const struct bbf_Scanner* ptrA, 
					  int32* xPtrA, int32* yPtrA, uint32* scalePtrA )
{
	/* 16.16 */
	*xPtrA = ( int32 )( ptrA->xE - ptrA->borderWidthE ) * ( int32 )( ptrA->scaleE >> 4 );

	/* 16.16 */
	*yPtrA = ( int32 )( ptrA->yE - ptrA->borderHeightE ) * ( int32 )( ptrA->scaleE >> 4 );

	/* 12.20 */
	*scalePtrA = ptrA->scaleE;
}

/* ------------------------------------------------------------------------- */

void bbf_Scanner_idxPos( const struct bbf_Scanner* ptrA, uint32 scanIndexA,
					     int32* xPtrA, int32* yPtrA, uint32* scalePtrA )
{
	int32 yL = scanIndexA / ptrA->currentWidthE;
	int32 xL = scanIndexA - ( yL * ptrA->currentWidthE );

	/* 16.16 */
	*xPtrA = ( int32 )( xL - ptrA->borderWidthE  ) * ( int32 )( ptrA->scaleE >> 4 );

	/* 16.16 */
	*yPtrA = ( int32 )( yL - ptrA->borderHeightE ) * ( int32 )( ptrA->scaleE >> 4 );

	*scalePtrA = ptrA->scaleE;
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ modify functions } ------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
	
void bbf_Scanner_create( struct bbs_Context* cpA,
						 struct bbf_Scanner* ptrA, 
						 flag maximizeSharedMemoryA,
						 uint32 maxImageWidthA,
					 	 uint32 maxImageHeightA,
						 uint32 maxRadiusA,
						 uint32 patchWidthA,
						 uint32 patchHeightA,
						 uint32 minScaleA,
						 uint32 maxScaleA,
						 uint32 scaleStepA,
						 uint32 borderWidthA,
						 uint32 borderHeightA,
						 uint32 bufferSizeA,
						 struct bbs_MemTbl* mtpA )
{
	ptrA->maxImageWidthE = maxImageWidthA;
	ptrA->maxImageHeightE = maxImageHeightA;
	ptrA->maxRadiusE = maxRadiusA;
	ptrA->patchWidthE = patchWidthA;
	ptrA->patchHeightE = patchHeightA;
	ptrA->minScaleE = minScaleA;
	ptrA->maxScaleE = maxScaleA;
	ptrA->scaleStepE = scaleStepA;
	ptrA->borderWidthE = borderWidthA;
	ptrA->borderHeightE = borderHeightA;
	ptrA->bufferSizeE = bufferSizeA;
	bbf_Scanner_alloc( cpA, ptrA, mtpA, maximizeSharedMemoryA );
}

/* ------------------------------------------------------------------------- */
	
void bbf_Scanner_bitParam( struct bbs_Context* cpA,
						   struct bbf_Scanner* ptrA,
						   const struct bbf_BitParam* bitParamPtrA )
{
	if( !bbf_BitParam_equal( cpA, &ptrA->bitParamE, bitParamPtrA ) )
	{
		bbf_BitParam_copy( cpA, &ptrA->bitParamE, bitParamPtrA );
		bbf_Scanner_createBitImage( cpA, ptrA );
	}

	bbf_Scanner_resetScan( cpA, ptrA );
}

/* ------------------------------------------------------------------------- */
	
/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ I/O } -------------------------------------------------------- */
/*                                                                           */
/* ========================================================================= */

/* ------------------------------------------------------------------------- */
	
uint32 bbf_Scanner_memSize( struct bbs_Context* cpA,
							const struct bbf_Scanner* ptrA )
{
	uint32 memSizeL = bbs_SIZEOF16( uint32 ) +
					  bbs_SIZEOF16( uint32 ); /* version */
	memSizeL += bbs_SIZEOF16( ptrA->maxImageWidthE );
	memSizeL += bbs_SIZEOF16( ptrA->maxImageHeightE );
	memSizeL += bbs_SIZEOF16( ptrA->maxRadiusE );
	memSizeL += bbs_SIZEOF16( ptrA->patchWidthE );
	memSizeL += bbs_SIZEOF16( ptrA->patchHeightE );
	memSizeL += bbs_SIZEOF16( ptrA->minScaleE );
	memSizeL += bbs_SIZEOF16( ptrA->maxScaleE );
	memSizeL += bbs_SIZEOF16( ptrA->scaleStepE );
	memSizeL += bbs_SIZEOF16( ptrA->borderWidthE );
	memSizeL += bbs_SIZEOF16( ptrA->borderHeightE );
	return memSizeL; 
}

/* ------------------------------------------------------------------------- */
	
uint32 bbf_Scanner_memWrite( struct bbs_Context* cpA,
						     const struct bbf_Scanner* ptrA, 
						     uint16* memPtrA )
{
	uint32 memSizeL = bbf_Scanner_memSize( cpA, ptrA );
	memPtrA += bbs_memWrite32( &memSizeL, memPtrA );
	memPtrA += bbs_memWriteUInt32( bbf_SCANNER_VERSION, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->maxImageWidthE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->maxImageHeightE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->maxRadiusE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->patchWidthE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->patchHeightE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->minScaleE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->maxScaleE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->scaleStepE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->borderWidthE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->borderHeightE, memPtrA );
	return memSizeL;
}

/* ------------------------------------------------------------------------- */

uint32 bbf_Scanner_memRead( struct bbs_Context* cpA,
						    struct bbf_Scanner* ptrA, 
						    const uint16* memPtrA, 
						    struct bbs_MemTbl* mtpA )
{
	uint32 memSizeL, versionL;

	if( bbs_Context_error( cpA ) ) return 0;
	memPtrA += bbs_memRead32( &memSizeL, memPtrA );
	memPtrA += bbs_memReadVersion32( cpA, &versionL, bbf_SCANNER_VERSION, memPtrA );

	memPtrA += bbs_memRead32( &ptrA->maxImageWidthE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->maxImageHeightE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->maxRadiusE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->patchWidthE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->patchHeightE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->minScaleE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->maxScaleE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->scaleStepE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->borderWidthE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->borderHeightE, memPtrA );

	if( memSizeL != bbf_Scanner_memSize( cpA, ptrA ) )
	{
		bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bbf_Scanner_memRead( struct bem_ScanGradientMove* ptrA, const uint16* memPtrA ):\n"
			        "size mismatch" );
		return 0;
	}

	if( bbs_Context_error( cpA ) ) return 0;

	/* allocate arrays */
	bbf_Scanner_alloc( cpA, ptrA, mtpA, FALSE );

	if( bbs_Context_error( cpA ) ) return 0;

	return memSizeL;
}

/* ------------------------------------------------------------------------- */
	
/* ========================================================================= */
/*                                                                           */
/* ---- \ghd{ exec functions } --------------------------------------------- */
/*                                                                           */
/* ========================================================================= */
	
/* ------------------------------------------------------------------------- */

void bbf_Scanner_resetScan( struct bbs_Context* cpA, struct bbf_Scanner* ptrA )
{
	ptrA->xE = 0;
	ptrA->yE = 0;
	bbf_Scanner_initPatchBuffer( cpA, ptrA );
}

/* ------------------------------------------------------------------------- */

void bbf_Scanner_assign( struct bbs_Context* cpA, struct bbf_Scanner* ptrA,
					     const void* imagePtrA,
						 uint32 imageWidthA,
						 uint32 imageHeightA,
						 const struct bts_Int16Rect* roiPtrA,
						 const struct bbf_BitParam* paramPtrA )
{
	/* copy image */
	bbf_Scanner_copyImage( cpA, ptrA, imagePtrA, imageWidthA, imageHeightA, roiPtrA );

	ptrA->scaleE = ptrA->minScaleE;
	bbf_BitParam_copy( cpA, &ptrA->bitParamE, paramPtrA );

	/* compute effective max scale */
	{
		/* 16.16 */
		uint32 maxHScaleL = ( ptrA->workWidthE << 16 ) / ( ptrA->patchWidthE + 1 );
		uint32 maxVScaleL = ( ptrA->workHeightE << 16 ) / ( ptrA->patchHeightE + 1 );

		/* 12.20 */
		ptrA->effMaxScaleE = maxHScaleL < maxVScaleL ? ( maxHScaleL << 4 ) : ( maxVScaleL << 4 );
		
		if( ptrA->maxScaleE > 0 ) ptrA->effMaxScaleE = ptrA->effMaxScaleE < ptrA->maxScaleE ? ptrA->effMaxScaleE : ptrA->maxScaleE;
	}

	ptrA->scaleExpE = 0;

	/* downscale work image if necessary */
	while( ptrA->scaleE > ( ( uint32 )( 2 << ptrA->scaleExpE ) << 20 ) ) bbf_Scanner_downscale( cpA, ptrA );

	bbf_Scanner_createBitImage( cpA, ptrA );
	bbf_Scanner_resetScan( cpA, ptrA );
}

/* ------------------------------------------------------------------------- */

flag bbf_Scanner_nextScale( struct bbs_Context* cpA, struct bbf_Scanner* ptrA )
{
	if( ptrA->scaleE + bbf_Scanner_scalePrd( ptrA->scaleE, ptrA->scaleStepE ) >= ptrA->effMaxScaleE ) return FALSE;
	ptrA->scaleE += bbf_Scanner_scalePrd( ptrA->scaleE, ptrA->scaleStepE );

	/* downscale work image if necessary */
	while( ptrA->scaleE > ( ( uint32 )( 2 << ptrA->scaleExpE ) << 20 ) ) bbf_Scanner_downscale( cpA, ptrA );

	bbf_Scanner_createBitImage( cpA, ptrA );
	bbf_Scanner_resetScan( cpA, ptrA );
	return TRUE;
}

/* ------------------------------------------------------------------------- */

const uint32* bbf_Scanner_getPatch( const struct bbf_Scanner* ptrA )
{
	return ptrA->patchBufferE.arrPtrE + ptrA->xE;
}

/* ------------------------------------------------------------------------- */

flag bbf_Scanner_next( struct bbs_Context* cpA, struct bbf_Scanner* ptrA )
{
	if( ( ptrA->xE + 1 ) < ( int32 )( ptrA->currentWidthE - ptrA->patchWidthE ) )
	{
		ptrA->xE++;
		return TRUE;
	}

	if( ( ptrA->yE + 1 ) >= ( int32 )( ptrA->currentHeightE - ptrA->patchHeightE ) ) return FALSE;

	ptrA->xE = 0;
	ptrA->yE++;

	{
		uint32 offL = ( ptrA->yE & 0x1F );
		uint32 rowL = ( ptrA->yE >> 5 ) + ( offL > 0 ? 1 : 0 );

		uint32 sizeL = ptrA->bitImageE.widthE;
		uint32* dstL = ptrA->patchBufferE.arrPtrE;
		uint32 iL;

		if( rowL < ptrA->bitImageE.heightE )
		{
			uint32* srcL = ( uint32* )ptrA->bitImageE.arrE.arrPtrE + rowL * sizeL;
			if( offL > 0 )
			{
				uint32 shlL = 32 - offL;
				for( iL = 0; iL < sizeL; iL++ ) dstL[ iL ] = ( dstL[ iL ] >> 1 ) | ( srcL[ iL ] << shlL );
			}
			else
			{
				bbs_memcpy32( dstL, srcL, sizeL );
			}
		}
		else
		{
			for( iL = 0; iL < sizeL; iL++ ) dstL[ iL ] >>= 1;
		}
	}

	return TRUE;
}

/* ------------------------------------------------------------------------- */

void bbf_Scanner_goToXY( struct bbs_Context* cpA, struct bbf_Scanner* ptrA, int32 xA, int32 yA )
{
	bbs_DEF_fNameL( "void bbf_Scanner_goToXY( struct bbs_Context* cpA, struct bbf_Scanner* ptrA, int32 xA, int32 yA )" )

	if( xA > ( int32 )( ptrA->currentWidthE - ptrA->patchWidthE ) )
	{
		bbs_ERROR1( "%s:\nyA out of range", fNameL );
		return;
	}

	ptrA->xE = xA;

	if( ptrA->yE == yA ) return;

	if( yA >= ( int32 )( ptrA->currentHeightE - ptrA->patchHeightE ) )
	{
		bbs_ERROR1( "%s:\nyA out of range", fNameL );
		return;
	}

	if( yA == ptrA->yE + 1 )
	{
		uint32 offL, rowL;
		uint32 sizeL;
		uint32* dstL;
		uint32 iL;

		ptrA->yE = yA;
		offL = ( ptrA->yE & 0x1F );
		rowL = ( ptrA->yE >> 5 ) + ( offL > 0 ? 1 : 0 );

		sizeL = ptrA->bitImageE.widthE;
		dstL = ptrA->patchBufferE.arrPtrE;

		if( rowL < ptrA->bitImageE.heightE )
		{
			uint32* srcL = ptrA->bitImageE.arrE.arrPtrE + rowL * sizeL;
			if( offL > 0 )
			{
				uint32 shlL = 32 - offL;
				for( iL = 0; iL < sizeL; iL++ ) dstL[ iL ] = ( dstL[ iL ] >> 1 ) | ( srcL[ iL ] << shlL );
			}
			else
			{
				bbs_memcpy32( dstL, srcL, sizeL );
			}
		}
		else
		{
			for( iL = 0; iL < sizeL; iL++ ) dstL[ iL ] >>= 1;
		}
	}
	else
	{
		uint32 offL, rowL;
		uint32 sizeL;
		uint32* dstL;
		uint32 iL;

		ptrA->yE = yA;
		offL = ( ptrA->yE & 0x1F );
		rowL = ( ptrA->yE >> 5 ) + ( offL > 0 ? 1 : 0 );

		sizeL = ptrA->bitImageE.widthE;
		dstL = ptrA->patchBufferE.arrPtrE;

		if( rowL < ptrA->bitImageE.heightE )
		{
			if( offL > 0 )
			{
				uint32* src1L = ptrA->bitImageE.arrE.arrPtrE + rowL * sizeL;
				uint32* src0L = src1L - sizeL;
				uint32 shlL = 32 - offL;
				for( iL = 0; iL < sizeL; iL++ ) dstL[ iL ] = ( src0L[ iL ] >> offL ) | ( src1L[ iL ] << shlL );
			}
			else
			{
				bbs_memcpy32( dstL, ptrA->bitImageE.arrE.arrPtrE + rowL * sizeL, sizeL );
			}
		}
		else
		{
			uint32* srcL = ptrA->bitImageE.arrE.arrPtrE + ( rowL - 1 ) * sizeL;
			for( iL = 0; iL < sizeL; iL++ ) dstL[ iL ] = srcL[ iL ] >> offL;
		}
	}
}

/* ------------------------------------------------------------------------- */

void bbf_Scanner_goToIndex( struct bbs_Context* cpA, struct bbf_Scanner* ptrA, uint32 scanIndexA )
{
	int32 yL = scanIndexA / ptrA->currentWidthE; 
	int32 xL = scanIndexA - yL * ptrA->currentWidthE;
	bbf_Scanner_goToXY( cpA, ptrA, xL, yL ); 
}

/* ------------------------------------------------------------------------- */

void bbf_Scanner_goToUls( struct bbs_Context* cpA, struct bbf_Scanner* ptrA, 
						  int32 xA, int32 yA, uint32 scaleA )
{
	int32 xL = ( xA / ( int32 )( ptrA->scaleE >> 4 ) ) + ptrA->borderWidthE;
	int32 yL = ( yA / ( int32 )( ptrA->scaleE >> 4 ) ) + ptrA->borderHeightE;

	if( ptrA->scaleE != scaleA )
	{
		bbs_ERROR0( "bbf_Scanner_goToUls:\nScales no not match" );
		return;
	}

	bbf_Scanner_goToXY( cpA, ptrA, xL, yL );
}

/* ------------------------------------------------------------------------- */

/* resets output positions */
void bbf_Scanner_resetOutPos( struct bbs_Context* cpA, struct bbf_Scanner* ptrA ) 
{
	ptrA->outCountE = 0;
}

/* ------------------------------------------------------------------------- */

/* resets internal positions */
void bbf_Scanner_resetIntPos( struct bbs_Context* cpA, struct bbf_Scanner* ptrA )
{
	ptrA->intCountE = 0;
}

/* ------------------------------------------------------------------------- */

/* add internal position */
void bbf_Scanner_addIntPos( struct bbs_Context* cpA, 
							struct bbf_Scanner* ptrA,
							uint32 idxA,
							int32 actA )
{
	if( ptrA->intCountE < ptrA->idxArrE.sizeE )
	{
        ptrA->idxArrE.arrPtrE[ ptrA->intCountE ] = idxA;
        ptrA->actArrE.arrPtrE[ ptrA->intCountE ] = actA;
		ptrA->intCountE++;
	}
	else
	{
		/* When buffer is full then replace lowest confidence-entry with new input 
		 * This fallback solution causes soft degradation of performance when the buffer limit is reached.
		 */
		int32 minActL = 0x7FFFFFFF;
		uint32 minIdxL = 0;
		uint32 iL;
		int32* actArrL = ptrA->actArrE.arrPtrE;
		for( iL = 0; iL < ptrA->intCountE; iL++ )
		{
			if( actArrL[ iL ] < minActL ) 
			{
				minActL = actArrL[ iL ];
				minIdxL = iL;
			}
		}

		if( actA > minActL )
		{
			ptrA->idxArrE.arrPtrE[ minIdxL ] = idxA;
			ptrA->actArrE.arrPtrE[ minIdxL ] = actA;
		}
	}
}

/* ------------------------------------------------------------------------- */

/* add external position */
void bbf_Scanner_addOutPos( struct bbs_Context* cpA, 
							struct bbf_Scanner* ptrA, 
							int32 xA, 
							int32 yA, 
							uint32 scaleA, 
							int32 actA )
{
	if( ( ptrA->outCountE * 4 + 3 ) < ptrA->outArrE.sizeE )
	{
        ptrA->outArrE.arrPtrE[ ptrA->outCountE * 4 + 0 ] = xA;
        ptrA->outArrE.arrPtrE[ ptrA->outCountE * 4 + 1 ] = yA;
        ptrA->outArrE.arrPtrE[ ptrA->outCountE * 4 + 2 ] = scaleA;
        ptrA->outArrE.arrPtrE[ ptrA->outCountE * 4 + 3 ] = actA;
		ptrA->outCountE++;
	}
	else
	{
		/* When buffer is full then replace lowest confidence-entry with new input 
		 * This fallback solution causes soft degradation of performance when the buffer limit is reached.
		 */
		int32 minActL = 0x7FFFFFFF;
		uint32 minIdxL = 0;
		uint32 iL;
		int32* outArrL = ptrA->outArrE.arrPtrE;
		for( iL = 0; iL < ptrA->outCountE; iL++ )
		{
			if( outArrL[ iL * 4 + 3 ] < minActL ) 
			{
				minActL = outArrL[ iL * 4 + 3 ];
				minIdxL = iL;
			}
		}

		if( actA > minActL )
		{
			ptrA->idxArrE.arrPtrE[ minIdxL * 4 + 0 ] = xA;
			ptrA->idxArrE.arrPtrE[ minIdxL * 4 + 1 ] = yA;
			ptrA->idxArrE.arrPtrE[ minIdxL * 4 + 2 ] = scaleA;
			ptrA->idxArrE.arrPtrE[ minIdxL * 4 + 3 ] = actA;
		}
	}
}

/* ------------------------------------------------------------------------- */

/* remove overlaps */
uint32 bbf_Scanner_removeOutOverlaps( struct bbs_Context* cpA, 
							          struct bbf_Scanner* ptrA,
									  uint32 overlapThrA )
{
	uint32 begIdxL = 0;				   /* begin index */
	uint32 endIdxL = ptrA->outCountE;  /* end index */
	uint32 iL;
	uint32 rw0L = ptrA->patchWidthE;
	uint32 rh0L = ptrA->patchHeightE;
	int32* outArrL = ptrA->outArrE.arrPtrE;

	if( overlapThrA >= 0x010000 ) return ptrA->outCountE;

	while( endIdxL - begIdxL > 1 )
	{
		int32 x1L, y1L, s1L, a1L;
		int32 r1wL, r1hL;
		uint32 r1aL;

		/* find maximum activity */
		uint32 maxIdxL  = 0;

		{
			int32 maxActL = ( int32 )0x80000000;
			for( iL = begIdxL; iL < endIdxL; iL++ )
			{
				if( outArrL[ iL * 4 + 3 ] > maxActL )
				{
					maxActL = outArrL[ iL * 4 + 3 ];
					maxIdxL = iL;
				}
			}
		}

		/* swap with position 0 */
		x1L = outArrL[ maxIdxL * 4 + 0 ];
		y1L = outArrL[ maxIdxL * 4 + 1 ];
		s1L = outArrL[ maxIdxL * 4 + 2 ];
		a1L = outArrL[ maxIdxL * 4 + 3 ];

		outArrL[ maxIdxL * 4 + 0 ] = outArrL[ begIdxL * 4 + 0 ];
		outArrL[ maxIdxL * 4 + 1 ] = outArrL[ begIdxL * 4 + 1 ];
		outArrL[ maxIdxL * 4 + 2 ] = outArrL[ begIdxL * 4 + 2 ];
		outArrL[ maxIdxL * 4 + 3 ] = outArrL[ begIdxL * 4 + 3 ];

		outArrL[ begIdxL * 4 + 0 ] = x1L;
		outArrL[ begIdxL * 4 + 1 ] = y1L;
		outArrL[ begIdxL * 4 + 2 ] = s1L;
		outArrL[ begIdxL * 4 + 3 ] = a1L;

		/* rectangle */
		r1wL = ( rw0L * ( s1L >> 12 ) + 128 ) >> 8;
		r1hL = ( rh0L * ( s1L >> 12 ) + 128 ) >> 8;
		r1aL = ( uint32 )r1wL * ( uint32 )r1hL;

		/* remove coordinate fractions */
		x1L = ( x1L + ( 1 << 15 ) ) >> 16;
		y1L = ( y1L + ( 1 << 15 ) ) >> 16;

		/* compare to other rectangles and remove overlaps */
		for( iL = endIdxL - 1; iL > begIdxL; iL-- )
		{
			int32* x2pL = &outArrL[ iL * 4 + 0 ];
			int32* y2pL = &outArrL[ iL * 4 + 1 ];
			int32* s2pL = &outArrL[ iL * 4 + 2 ];
			int32* a2pL = &outArrL[ iL * 4 + 3 ];

			int32 x2L = ( *x2pL + ( 1 << 15 ) ) >> 16;
			int32 y2L = ( *y2pL + ( 1 << 15 ) ) >> 16;

			/* rectangle */
			int32 r2wL = ( rw0L * ( *s2pL >> 12 ) + 128 ) >> 8;
			int32 r2hL = ( rh0L * ( *s2pL >> 12 ) + 128 ) >> 8;
			uint32 r2aL = r2wL * r2hL;

			/* intersection */
			int32 rx1L = x1L > x2L ? x1L : x2L;
			int32 rx2L = ( x1L + r1wL ) < ( x2L + r2wL ) ? ( x1L + r1wL ) : ( x2L + r2wL );
			int32 ry1L = y1L > y2L ? y1L : y2L;
			int32 ry2L = ( y1L + r1hL ) < ( y2L + r2hL ) ? ( y1L + r1hL ) : ( y2L + r2hL );
			uint32 riwL;

			rx2L = ( rx2L > rx1L ) ? rx2L : rx1L;
			ry2L = ( ry2L > ry1L ) ? ry2L : ry1L;
			riwL = ( uint32 )( rx2L - rx1L ) * ( uint32 )( ry2L - ry1L );

			if( riwL > ( ( ( overlapThrA >> 8 ) * ( r1aL < r2aL ? r1aL : r2aL ) ) >> 8 ) )
			{
				endIdxL--;
				*x2pL = outArrL[ endIdxL * 4 + 0 ];
				*y2pL = outArrL[ endIdxL * 4 + 1 ];
				*s2pL = outArrL[ endIdxL * 4 + 2 ];
				*a2pL = outArrL[ endIdxL * 4 + 3 ];
			}
		}

		begIdxL++;
	}

	ptrA->outCountE = endIdxL;

	return endIdxL;
}

/* ------------------------------------------------------------------------- */

/* remove internal overlaps */
uint32 bbf_Scanner_removeIntOverlaps( struct bbs_Context* cpA, 
								      struct bbf_Scanner* ptrA,
									  uint32 overlapThrA )
{
    uint32 begIdxL = 0;		 /* begin index */
    uint32 endIdxL = ptrA->intCountE;  /* end index */
	uint32 iL;
	uint32 rw0L   = ptrA->patchWidthE;
	uint32 rh0L   = ptrA->patchHeightE;
	int32 minAreaL = ( overlapThrA * rw0L * rh0L ) >> 16;

	int32*  actArrL = ptrA->actArrE.arrPtrE;
	uint32* idxArrL = ptrA->idxArrE.arrPtrE;

	if( overlapThrA >= 0x010000 ) return ptrA->intCountE;

	while( endIdxL - begIdxL > 1 )
	{
		/* find maximum activity */
		int32 a1L = ( int32 )0x80000000;
		uint32 i1L = 0;
		uint32 maxIdxL  = 0;
		int32 x1L, y1L;

		for( iL = begIdxL; iL < endIdxL; iL++ )
		{
            if( actArrL[ iL ] > a1L )
			{
				a1L = actArrL[ iL ];
				maxIdxL = iL;
			}
		}

		/* swap with position 0 */
		i1L = idxArrL[ maxIdxL ];
		idxArrL[ maxIdxL ] = idxArrL[ begIdxL ];
		actArrL[ maxIdxL ] = actArrL[ begIdxL ];
		idxArrL[ begIdxL ] = i1L;
		actArrL[ begIdxL ] = a1L;

		/* upper left coordinates */
		y1L = i1L / ptrA->currentWidthE;
		x1L = i1L - ( y1L * ptrA->currentWidthE );

		/* compare to other rectangles and remove overlaps */
		for( iL = endIdxL - 1; iL > begIdxL; iL-- )
		{
			int32*  a2pL = &actArrL[ iL ];
			uint32* i2pL = &idxArrL[ iL ];

			int32 y2L = *i2pL / ptrA->currentWidthE;
			int32 x2L = *i2pL - ( y2L * ptrA->currentWidthE );

			int32 dxL = rw0L - ( x1L > x2L ? x1L - x2L : x2L - x1L );
			int32 dyL = rh0L - ( y1L > y2L ? y1L - y2L : y2L - y1L );

			dxL = dxL > 0 ? dxL : 0;
			dyL = dyL > 0 ? dyL : 0;

			if( dxL * dyL > minAreaL )
			{
				endIdxL--;
				*a2pL = actArrL[ endIdxL ];
				*i2pL = idxArrL[ endIdxL ];
			}
		}

		begIdxL++;
	}

	ptrA->intCountE = endIdxL;

	return ptrA->intCountE;
}

/* ------------------------------------------------------------------------- */

/* ========================================================================= */