xref: /external/neven/Embedded/common/src/b_BitFeatureEm/LocalScanDetector.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_ImageEm/Functions.h"
#include "b_BitFeatureEm/LocalScanDetector.h"

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

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

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

/** applies PCA mapping
 *  Input and output clusters may be identical
 */
void bbf_LocalScanDetector_pcaMap( struct bbs_Context* cpA,
								   const struct bbf_LocalScanDetector* ptrA,
								   const struct bts_IdCluster2D* inClusterPtrA,
								   struct bts_IdCluster2D* outClusterPtrA )
{
	bbs_DEF_fNameL( "bbf_LocalScanDetector_pcaMap" )

	struct bts_Cluster2D* tmpCl1PtrL  = ( struct bts_Cluster2D* )&ptrA->tmpCluster1E;
	struct bts_Cluster2D* tmpCl2PtrL  = ( struct bts_Cluster2D* )&ptrA->tmpCluster2E;
	struct bts_RBFMap2D*  rbfPtrL     = ( struct bts_RBFMap2D* )&ptrA->rbfMapE;
	struct bts_Flt16Alt2D altL;
	uint32 outBbpL = inClusterPtrA->clusterE.bbpE;
	uint32 iL, jL;

	/* setup two equivalent clusters holding the essential (alt-free) moves to be handled by PCA */
	bts_IdCluster2D_convertToEqivalentClusters( cpA,
												inClusterPtrA,
												&ptrA->pcaClusterE,
												tmpCl1PtrL,
												tmpCl2PtrL );

	altL = bts_Cluster2D_alt( cpA, tmpCl1PtrL, tmpCl2PtrL, bts_ALT_RIGID );
	bts_Cluster2D_transform( cpA, tmpCl1PtrL, altL );
	bts_RBFMap2D_compute( cpA, rbfPtrL, tmpCl2PtrL, tmpCl1PtrL );
	bts_RBFMap2D_mapCluster( cpA, rbfPtrL, &ptrA->pcaClusterE.clusterE, tmpCl1PtrL, 6/* ! */ );

	/* PCA projection: cluster1 -> cluster1 */
	{
		/* mat elements: 8.8 */
		const int16* matPtrL = ptrA->pcaMatE.arrPtrE;

		/* same bbp as pca cluster */
		const int16* avgPtrL = ptrA->pcaAvgE.arrPtrE;

		struct bts_Int16Vec2D* vecArrL = tmpCl1PtrL->vecArrE;

		/* projected vector */
		int32 prjVecL[ bpi_LOCAL_SCAN_DETECTOR_MAX_PCA_DIM ];

		/* width of matrix */
		uint16 matWidthL = tmpCl1PtrL->sizeE * 2;

		if( ptrA->pcaDimSubSpaceE > bpi_LOCAL_SCAN_DETECTOR_MAX_PCA_DIM )
		{
			bbs_ERROR1( "%s:\nbpi_RF_LANDMARKER_MAX_PCA_DIM exceeded", fNameL );
			return;
		}

		/* forward trafo */
		for( iL = 0; iL < ptrA->pcaDimSubSpaceE; iL++ )
		{
			int32 sumL = 0;
			avgPtrL = ptrA->pcaAvgE.arrPtrE;
			for( jL = 0; jL < tmpCl1PtrL->sizeE; jL++ )
			{
				sumL += matPtrL[ 0 ] * ( vecArrL[ jL ].xE - avgPtrL[ 0 ] );
				sumL += matPtrL[ 1 ] * ( vecArrL[ jL ].yE - avgPtrL[ 1 ] );
				avgPtrL += 2;
				matPtrL += 2;
			}
			prjVecL[ iL ] = ( sumL + 128 ) >> 8;
		}

		matPtrL = ptrA->pcaMatE.arrPtrE;
		avgPtrL = ptrA->pcaAvgE.arrPtrE;
		vecArrL = tmpCl1PtrL->vecArrE;

		/* backward trafo */
		for( jL = 0; jL < tmpCl1PtrL->sizeE; jL++ )
		{
			int32 sumL = 0;
			for( iL = 0; iL < ptrA->pcaDimSubSpaceE; iL++ )
			{
				sumL += matPtrL[ iL * matWidthL + 0 ] * prjVecL[ iL ];
			}

			vecArrL[ jL ].xE = ( ( sumL + 128 ) >> 8 ) + avgPtrL[ 0 ];

			sumL = 0;
			for( iL = 0; iL < ptrA->pcaDimSubSpaceE; iL++ )
			{
				sumL += matPtrL[ iL * matWidthL + 1 ] * prjVecL[ iL ];
			}

			vecArrL[ jL ].yE = ( ( sumL + 128 ) >> 8 ) + avgPtrL[ 1 ];

			matPtrL += 2;
			avgPtrL += 2;
		}
	}

	/* ALT backtransformation */
	bts_IdCluster2D_copy( cpA, outClusterPtrA, &ptrA->pcaClusterE );
	bts_Cluster2D_copyTransform( cpA, &outClusterPtrA->clusterE, tmpCl1PtrL, bts_Flt16Alt2D_inverted( &altL ), outBbpL );
}

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

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

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

void bbf_LocalScanDetector_init( struct bbs_Context* cpA,
							     struct bbf_LocalScanDetector* ptrA )
{
	bbs_memset16( ptrA->ftrPtrArrE, 0, bbs_SIZEOF16( ptrA->ftrPtrArrE ) );
	bts_RBFMap2D_init( cpA, &ptrA->rbfMapE );
	bts_Cluster2D_init( cpA, &ptrA->tmpCluster1E );
	bts_Cluster2D_init( cpA, &ptrA->tmpCluster2E );
	bts_Cluster2D_init( cpA, &ptrA->tmpCluster3E );
	bts_Cluster2D_init( cpA, &ptrA->tmpCluster4E );
	bbf_LocalScanner_init( cpA, &ptrA->scannerE );
	bbs_Int32Arr_init( cpA, &ptrA->actArrE );
	bbs_Int16Arr_init( cpA, &ptrA->idxArrE );
	bbs_UInt8Arr_init( cpA, &ptrA->workImageBufE );
	ptrA->maxImageWidthE = 0;
	ptrA->maxImageHeightE = 0;

	ptrA->patchWidthE = 0;
	ptrA->patchHeightE = 0;
	ptrA->scanWidthE = 0;
	ptrA->scanHeightE = 0;
	ptrA->scaleExpE = 0;
	ptrA->interpolatedWarpingE = TRUE;
	ptrA->warpScaleThresholdE = 0;
	bts_IdCluster2D_init( cpA, &ptrA->refClusterE );
	bts_Cluster2D_init( cpA, &ptrA->scanClusterE );
	bbs_UInt16Arr_init( cpA, &ptrA->ftrDataArrE );
	bbf_BitParam_init( cpA, &ptrA->bitParamE );
	ptrA->outlierDistanceE = 0;
	bts_IdCluster2D_init( cpA, &ptrA->pcaClusterE );
	bbs_Int16Arr_init( cpA, &ptrA->pcaAvgE );
	bbs_Int16Arr_init( cpA, &ptrA->pcaMatE );
	ptrA->pcaDimSubSpaceE = 0;
	ptrA->maxImageWidthE = 0;
	ptrA->maxImageHeightE = 0;
}

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

void bbf_LocalScanDetector_exit( struct bbs_Context* cpA,
							     struct bbf_LocalScanDetector* ptrA )
{
	uint16 iL;
	for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) bbf_featureExit( cpA, ptrA->ftrPtrArrE[ iL ] );
	bbs_memset16( ptrA->ftrPtrArrE, 0, bbs_SIZEOF16( ptrA->ftrPtrArrE ) );

	bts_RBFMap2D_exit( cpA, &ptrA->rbfMapE );
	bts_Cluster2D_exit( cpA, &ptrA->tmpCluster1E );
	bts_Cluster2D_exit( cpA, &ptrA->tmpCluster2E );
	bts_Cluster2D_exit( cpA, &ptrA->tmpCluster3E );
	bts_Cluster2D_exit( cpA, &ptrA->tmpCluster4E );
	bbf_LocalScanner_exit( cpA, &ptrA->scannerE );
	bbs_Int32Arr_exit( cpA, &ptrA->actArrE );
	bbs_Int16Arr_exit( cpA, &ptrA->idxArrE );
	bbs_UInt8Arr_exit( cpA, &ptrA->workImageBufE );
	ptrA->maxImageWidthE = 0;
	ptrA->maxImageHeightE = 0;

	ptrA->patchWidthE = 0;
	ptrA->patchHeightE = 0;
	ptrA->scanWidthE = 0;
	ptrA->scanHeightE = 0;
	ptrA->scaleExpE = 0;
	ptrA->interpolatedWarpingE = TRUE;
	ptrA->warpScaleThresholdE = 0;
	bts_IdCluster2D_exit( cpA, &ptrA->refClusterE );
	bts_Cluster2D_exit( cpA, &ptrA->scanClusterE );
	bbs_UInt16Arr_exit( cpA, &ptrA->ftrDataArrE );
	bbf_BitParam_exit( cpA, &ptrA->bitParamE );
	ptrA->outlierDistanceE = 0;
	bts_IdCluster2D_exit( cpA, &ptrA->pcaClusterE );
	bbs_Int16Arr_exit( cpA, &ptrA->pcaAvgE );
	bbs_Int16Arr_exit( cpA, &ptrA->pcaMatE );
	ptrA->pcaDimSubSpaceE = 0;
	ptrA->maxImageWidthE = 0;
	ptrA->maxImageHeightE = 0;
}

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

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

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

void bbf_LocalScanDetector_copy( struct bbs_Context* cpA,
						    struct bbf_LocalScanDetector* ptrA,
						    const struct bbf_LocalScanDetector* srcPtrA )
{
	bbs_ERROR0( "bbf_LocalScanDetector_copy:\n Function is not available" );
}

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

flag bbf_LocalScanDetector_equal( struct bbs_Context* cpA,
						     const struct bbf_LocalScanDetector* ptrA,
						     const struct bbf_LocalScanDetector* srcPtrA )
{
	bbs_ERROR0( "bbf_LocalScanDetector_equal:\n Function is not available" );
	return TRUE;
}

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

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

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

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

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

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

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

uint32 bbf_LocalScanDetector_memSize( struct bbs_Context* cpA,
								      const struct bbf_LocalScanDetector* ptrA )
{
	uint32 iL;
	uint32 memSizeL = bbs_SIZEOF16( uint32 ) +
					  bbs_SIZEOF16( uint32 ); /* version */

	memSizeL += bbs_SIZEOF16( ptrA->patchWidthE );
	memSizeL += bbs_SIZEOF16( ptrA->patchHeightE );
	memSizeL += bbs_SIZEOF16( ptrA->scanWidthE );
	memSizeL += bbs_SIZEOF16( ptrA->scanHeightE );
	memSizeL += bbs_SIZEOF16( ptrA->scaleExpE );
	memSizeL += bbs_SIZEOF16( ptrA->interpolatedWarpingE );
	memSizeL += bbs_SIZEOF16( ptrA->warpScaleThresholdE );
	memSizeL += bts_IdCluster2D_memSize( cpA, &ptrA->refClusterE );
	memSizeL += bts_Cluster2D_memSize( cpA, &ptrA->scanClusterE );
	memSizeL += bbf_BitParam_memSize( cpA, &ptrA->bitParamE );
	memSizeL += bbs_SIZEOF16( ptrA->outlierDistanceE );
	memSizeL += bts_IdCluster2D_memSize( cpA, &ptrA->pcaClusterE );
	memSizeL += bbs_Int16Arr_memSize( cpA, &ptrA->pcaAvgE );
	memSizeL += bbs_Int16Arr_memSize( cpA, &ptrA->pcaMatE );
	memSizeL += bbs_SIZEOF16( ptrA->pcaDimSubSpaceE );
	memSizeL += bbs_SIZEOF16( ptrA->maxImageWidthE );
	memSizeL += bbs_SIZEOF16( ptrA->maxImageHeightE );
	for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) memSizeL += bbf_featureMemSize( cpA, ptrA->ftrPtrArrE[ iL ] );

	return memSizeL;
}

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

uint32 bbf_LocalScanDetector_memWrite( struct bbs_Context* cpA,
									   const struct bbf_LocalScanDetector* ptrA,
									   uint16* memPtrA )
{
	uint32 iL;
	uint32 memSizeL = bbf_LocalScanDetector_memSize( cpA, ptrA );
	memPtrA += bbs_memWrite32( &memSizeL, memPtrA );
	memPtrA += bbs_memWriteUInt32( bbf_LOCAL_SCAN_DETECTOR_VERSION, memPtrA );

	memPtrA += bbs_memWrite32( &ptrA->patchWidthE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->patchHeightE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->scanWidthE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->scanHeightE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->scaleExpE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->interpolatedWarpingE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->warpScaleThresholdE, memPtrA );
	memPtrA += bts_IdCluster2D_memWrite( cpA, &ptrA->refClusterE, memPtrA );
	memPtrA += bts_Cluster2D_memWrite( cpA, &ptrA->scanClusterE, memPtrA );
	memPtrA += bbf_BitParam_memWrite( cpA, &ptrA->bitParamE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->outlierDistanceE, memPtrA );
	memPtrA += bts_IdCluster2D_memWrite( cpA, &ptrA->pcaClusterE, memPtrA );
	memPtrA += bbs_Int16Arr_memWrite( cpA, &ptrA->pcaAvgE, memPtrA );
	memPtrA += bbs_Int16Arr_memWrite( cpA, &ptrA->pcaMatE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->pcaDimSubSpaceE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->maxImageWidthE, memPtrA );
	memPtrA += bbs_memWrite32( &ptrA->maxImageHeightE, memPtrA );

	for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) memPtrA += bbf_featureMemWrite( cpA, ptrA->ftrPtrArrE[ iL ], memPtrA );

	return memSizeL;
}

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

uint32 bbf_LocalScanDetector_memRead( struct bbs_Context* cpA,
									  struct bbf_LocalScanDetector* ptrA,
									  const uint16* memPtrA,
									  struct bbs_MemTbl* mtpA )
{
	uint32 iL;
	uint32 memSizeL, versionL;
	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 );
	if( bbs_Context_error( cpA ) ) return 0;

	memPtrA += bbs_memRead32( &memSizeL, memPtrA );
	memPtrA += bbs_memReadVersion32( cpA, &versionL, bbf_LOCAL_SCAN_DETECTOR_VERSION, memPtrA );


	memPtrA += bbs_memRead32( &ptrA->patchWidthE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->patchHeightE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->scanWidthE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->scanHeightE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->scaleExpE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->interpolatedWarpingE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->warpScaleThresholdE, memPtrA );
	memPtrA += bts_IdCluster2D_memRead( cpA, &ptrA->refClusterE, memPtrA, espL );
	memPtrA += bts_Cluster2D_memRead( cpA, &ptrA->scanClusterE, memPtrA, espL );
	memPtrA += bbf_BitParam_memRead( cpA, &ptrA->bitParamE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->outlierDistanceE, memPtrA );
	memPtrA += bts_IdCluster2D_memRead( cpA, &ptrA->pcaClusterE, memPtrA, espL );
	memPtrA += bbs_Int16Arr_memRead( cpA, &ptrA->pcaAvgE, memPtrA, espL );
	memPtrA += bbs_Int16Arr_memRead( cpA, &ptrA->pcaMatE, memPtrA, espL );
	memPtrA += bbs_memRead32( &ptrA->pcaDimSubSpaceE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->maxImageWidthE, memPtrA );
	memPtrA += bbs_memRead32( &ptrA->maxImageHeightE, memPtrA );

	/* check features & allocate data buffer */
	{
		const uint16* memPtrL = memPtrA;
		uint32 dataSizeL = 0;
		for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ )
		{
			enum bbf_FeatureType typeL = ( enum bbf_FeatureType )bbs_memPeek32( memPtrL + 4 );
			dataSizeL += bbf_featureSizeOf16( cpA, typeL );
			memPtrL += bbs_memPeek32( memPtrL );
		}
		bbs_UInt16Arr_create( cpA, &ptrA->ftrDataArrE, dataSizeL, espL );
	}

	/* load features & initialize pointers */
	{
		uint16* dataPtrL = ptrA->ftrDataArrE.arrPtrE;
		for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ )
		{
			enum bbf_FeatureType typeL = ( enum bbf_FeatureType )bbs_memPeek32( memPtrA + 4 );
			ptrA->ftrPtrArrE[ iL ] = ( struct bbf_Feature* )dataPtrL;
			bbf_featureInit( cpA, ptrA->ftrPtrArrE[ iL ], typeL );
			memPtrA += bbf_featureMemRead( cpA, ptrA->ftrPtrArrE[ iL ], memPtrA, &memTblL );
			dataPtrL += bbf_featureSizeOf16( cpA, typeL );
		}
	}

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

	if( ptrA->maxImageWidthE * ptrA->maxImageHeightE == 0 )
	{
		bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bbf_LocalScanDetector_memRead( struct bem_ScanGradientMove* ptrA, const uint16* memPtrA ):\n"
								        "maximum image width/height not set" );
		return 0;
	}

	/* initialize internal data */

	/* ought to be placed on shared memory later */
	bts_RBFMap2D_create( cpA, &ptrA->rbfMapE, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL );
	ptrA->rbfMapE.RBFTypeE = bts_RBF_LINEAR;
	ptrA->rbfMapE.altTypeE = bts_ALT_RIGID;

	bts_Cluster2D_create( cpA, &ptrA->tmpCluster1E, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL );
	bts_Cluster2D_create( cpA, &ptrA->tmpCluster2E, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL );
	bts_Cluster2D_create( cpA, &ptrA->tmpCluster3E, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL );
	bts_Cluster2D_create( cpA, &ptrA->tmpCluster4E, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL );

	bbs_Int32Arr_create( cpA, &ptrA->actArrE, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL );
	bbs_Int16Arr_create( cpA, &ptrA->idxArrE, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL );

	/* working image memory */
	/* ought to be placed on shared memory later */
	bbs_UInt8Arr_create( cpA, &ptrA->workImageBufE, ptrA->maxImageWidthE * ptrA->maxImageHeightE, sspL );

	/* initialize local scanner (be aware of shared memory usage when moving this create function) */
	bbf_LocalScanner_create( cpA, &ptrA->scannerE,
							 ptrA->patchWidthE,
							 ptrA->patchHeightE,
							 ptrA->scaleExpE,
							 ptrA->maxImageWidthE,
							 ptrA->maxImageHeightE,
							 ptrA->scaleExpE,
							 ptrA->bitParamE.outerRadiusE,
							 &memTblL );

	return memSizeL;
}

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

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

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

int32 bbf_LocalScanDetector_process( struct bbs_Context* cpA,
									 const struct bbf_LocalScanDetector* ptrA,
                                     uint8* imagePtrA,
									 uint32 imageWidthA,
									 uint32 imageHeightA,
									 const struct bts_Int16Vec2D*  offsPtrA,
									 const struct bts_IdCluster2D* inClusterPtrA,
									 struct bts_IdCluster2D* outClusterPtrA )
{
	bbs_DEF_fNameL( "bbf_LocalScanDetector_process" )

	int32 pw0L = ptrA->patchWidthE;
	int32 ph0L = ptrA->patchHeightE;
	int32 pw1L = pw0L << ptrA->scaleExpE;
	int32 ph1L = ph0L << ptrA->scaleExpE;

	struct bts_Cluster2D* wrkClPtrL  = ( struct bts_Cluster2D* )&ptrA->tmpCluster1E;
	struct bts_Cluster2D* refClPtrL  = ( struct bts_Cluster2D* )&ptrA->tmpCluster2E;
	struct bts_Cluster2D* dstClPtrL  = ( struct bts_Cluster2D* )&ptrA->tmpCluster3E;
	struct bts_Cluster2D* tmpClPtrL  = ( struct bts_Cluster2D* )&ptrA->tmpCluster4E;
	struct bts_RBFMap2D*  rbfPtrL    = ( struct bts_RBFMap2D* )&ptrA->rbfMapE;
	struct bbf_LocalScanner* scnPtrL = ( struct bbf_LocalScanner* )&ptrA->scannerE;

	int32* actArrL = ( int32* )ptrA->actArrE.arrPtrE;
	int16* idxArrL = ( int16* )ptrA->idxArrE.arrPtrE;

	uint32 workImageWidthL, workImageHeightL;

	struct bts_Flt16Alt2D altL;

	int32 confidenceL;
	uint32 iL;
	uint32 sizeL = ptrA->scanClusterE.sizeE;

	if( sizeL > bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE )
	{
		bbs_ERROR1( "%s:\nScan cluster size exceeds bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE", fNameL );
		return 0;
	}

	/* compute equivalent clusters (matching ids) from input and reference cluster */
	bts_IdCluster2D_convertToEqivalentClusters( cpA, inClusterPtrA, &ptrA->refClusterE, wrkClPtrL, refClPtrL );

	/* altL: orig image -> normalized image */
	altL = bts_Cluster2D_alt( cpA, wrkClPtrL, refClPtrL, bts_ALT_RIGID );

	/* transorm work cluster to normalized image */
	bts_Cluster2D_transformBbp( cpA, wrkClPtrL, altL, 6 );

	/* map: ref cluster -> work cluster */
	bts_RBFMap2D_compute( cpA, rbfPtrL, refClPtrL, wrkClPtrL );

	/* copy: scanClusterE -> work cluster */
	bts_Cluster2D_copy( cpA, wrkClPtrL, &ptrA->scanClusterE );

	/* copy: refClusterE -> ref cluster */
	bts_Cluster2D_copy( cpA, refClPtrL, &ptrA->refClusterE.clusterE );

	/* apply map to work cluster */
	bts_Cluster2D_rbfTransform( cpA, wrkClPtrL, rbfPtrL );

	/* apply map to ref cluster */
	bts_Cluster2D_rbfTransform( cpA, refClPtrL, rbfPtrL );

	{
		/* analyze boundaries; get exact dimensions of working image */
		int32 workBorderWL = ( ( ptrA->scanWidthE  + pw1L + 1 ) >> 1 ) + 1; /* add a pixel to ensure full search area */
		int32 workBorderHL = ( ( ptrA->scanHeightE + ph1L + 1 ) >> 1 ) + 1; /* add a pixel to ensure full search area */
		struct bts_Int16Rect workAreaL = bts_Cluster2D_boundingBox( cpA, wrkClPtrL );
		workAreaL.x1E = workAreaL.x1E >> wrkClPtrL->bbpE;
		workAreaL.y1E = workAreaL.y1E >> wrkClPtrL->bbpE;
		workAreaL.x2E = workAreaL.x2E >> wrkClPtrL->bbpE;
		workAreaL.y2E = workAreaL.y2E >> wrkClPtrL->bbpE;
		workAreaL.x1E -= workBorderWL;
		workAreaL.y1E -= workBorderHL;
		workAreaL.x2E += workBorderWL;
		workAreaL.y2E += workBorderHL;

		workImageWidthL  = workAreaL.x2E - workAreaL.x1E;
		workImageHeightL = workAreaL.y2E - workAreaL.y1E;

		/* truncate if necessary (should not occur in normal operation) */
		workImageWidthL = workImageWidthL > ptrA->maxImageWidthE ? ptrA->maxImageWidthE : workImageWidthL;
		workImageHeightL = workImageHeightL > ptrA->maxImageHeightE ? ptrA->maxImageHeightE : workImageHeightL;

		/* adjust ALT */
		altL.vecE.xE -= workAreaL.x1E << altL.vecE.bbpE;
		altL.vecE.yE -= workAreaL.y1E << altL.vecE.bbpE;

		/* adjust work cluster */
		for( iL = 0; iL < wrkClPtrL->sizeE; iL++ )
		{
			wrkClPtrL->vecArrE[ iL ].xE -= workAreaL.x1E << wrkClPtrL->bbpE;
			wrkClPtrL->vecArrE[ iL ].yE -= workAreaL.y1E << wrkClPtrL->bbpE;
		}

		/* adjust ref cluster */
		for( iL = 0; iL < wrkClPtrL->sizeE; iL++ )
		{
			refClPtrL->vecArrE[ iL ].xE -= workAreaL.x1E << refClPtrL->bbpE;
			refClPtrL->vecArrE[ iL ].yE -= workAreaL.y1E << refClPtrL->bbpE;
		}

		/* transform image */
		bim_filterWarp( cpA,
					    ptrA->workImageBufE.arrPtrE,
						imagePtrA, imageWidthA, imageHeightA,
						offsPtrA,
						&altL,
						workImageWidthL, workImageHeightL,
						NULL,
						ptrA->warpScaleThresholdE,
						ptrA->interpolatedWarpingE );

	}

	/* scan over all positions of work cluster; target positions are stored in *dstClPtrL*/
	{
		int32 regionWHL = ( ptrA->scanWidthE  + pw1L + 1 ) >> 1;
		int32 regionHHL = ( ptrA->scanHeightE + ph1L + 1 ) >> 1;
		struct bts_Int16Vec2D* srcVecArrL = wrkClPtrL->vecArrE;
		struct bts_Int16Vec2D* dstVecArrL = dstClPtrL->vecArrE;
		int32 vecBbpL = wrkClPtrL->bbpE;
		bts_Cluster2D_size( cpA, dstClPtrL, sizeL );
		dstClPtrL->bbpE = vecBbpL;

		/* initialize scanner */
		scnPtrL->patchWidthE = ptrA->patchWidthE;
		scnPtrL->patchHeightE = ptrA->patchWidthE;
		scnPtrL->scaleExpE = ptrA->scaleExpE;

		bbf_LocalScanner_assign( cpA, scnPtrL, ptrA->workImageBufE.arrPtrE, workImageWidthL, workImageHeightL, &ptrA->bitParamE );

		bbs_memset32( actArrL, 0x80000000, sizeL );

		do
		{
			for( iL = 0; iL < sizeL; iL++ )
			{
				int32 bestActL = 0x80000000;
				uint32 bestIdxL = 0;
				struct bbf_Feature* ftrPtrL = ptrA->ftrPtrArrE[ iL ];

				/* set scan region */
				{
					int32 x0L = ( ( wrkClPtrL->vecArrE[ iL ].xE >> ( wrkClPtrL->bbpE - 1 ) ) + 1 ) >> 1;
					int32 y0L = ( ( wrkClPtrL->vecArrE[ iL ].yE >> ( wrkClPtrL->bbpE - 1 ) ) + 1 ) >> 1;
					struct bts_Int16Rect scanRegionL = bts_Int16Rect_create( x0L - regionWHL, y0L - regionHHL, x0L + regionWHL, y0L + regionHHL );
					bbf_LocalScanner_origScanRegion( cpA, scnPtrL, &scanRegionL );
				}

				do
				{
					int32 actL = ftrPtrL->vpActivityE( ftrPtrL, bbf_LocalScanner_getPatch( scnPtrL ) );

					if( actL > bestActL )
					{
						bestActL = actL;
						bestIdxL = bbf_LocalScanner_scanIndex( scnPtrL );
					}
				}
				while( bbf_LocalScanner_next( cpA, scnPtrL ) );

				{
					int32 xL, yL; /* 16.16 */
					bbf_LocalScanner_idxPos( scnPtrL, bestIdxL, &xL, &yL );
					xL += pw1L << 15;
					yL += ph1L << 15;
					if( bestActL > actArrL[ iL ] )
					{
						dstVecArrL[ iL ].xE = ( ( xL >> ( 15 - vecBbpL ) ) + 1 ) >> 1;
						dstVecArrL[ iL ].yE = ( ( yL >> ( 15 - vecBbpL ) ) + 1 ) >> 1;
						actArrL[ iL ] = bestActL;
					}
				}
			}
		}
		while( bbf_LocalScanner_nextOffset( cpA, scnPtrL ) );

		/* outlier analysis: outliers are disabled by setting their similarity to -1 */
		if( ptrA->outlierDistanceE > 0 )
		{
			/* altL: work cluster -> ref cluster */
			struct bts_Flt16Alt2D localAltL = bts_Cluster2D_alt( cpA, wrkClPtrL, dstClPtrL, bts_ALT_RIGID );

			/* squared distance 16.16 */
			uint32 dist2L = ( ptrA->outlierDistanceE >> 8 ) * ( ptrA->outlierDistanceE >> 8 );

			/* analyze deviations */
			for( iL = 0; iL < sizeL; iL++ )
			{
				struct bts_Flt16Vec2D vecL = bts_Flt16Vec2D_create32( srcVecArrL[ iL ].xE, srcVecArrL[ iL ].yE, vecBbpL );
				uint32 dev2L; /* squared deviation 16.16 */
				vecL = bts_Flt16Alt2D_mapFlt( &localAltL, &vecL );
				vecL = bts_Flt16Vec2D_sub( vecL, bts_Flt16Vec2D_create32( dstVecArrL[ iL ].xE, dstVecArrL[ iL ].yE, vecBbpL ) );
				dev2L = bbs_convertU32( bts_Flt16Vec2D_norm2( &vecL ), vecL.bbpE << 1, 16 );
				if( dev2L > dist2L ) actArrL[ iL ] = 0xF0000000;
			}
		}

		/* remove undetected positions but keep at least 1/2 best positions */
		{
			flag sortedL;

			/* bubble sort (no speed issue in this case) */
			for( iL = 0; iL < sizeL; iL++ ) idxArrL[ iL ] = iL;

			do
			{
				sortedL = TRUE;
				for( iL = 1; iL < sizeL; iL++ )
				{
					if( actArrL[ idxArrL[ iL - 1 ] ] < actArrL[ idxArrL[ iL ] ] )
					{
						int16 tmpL = idxArrL[ iL - 1 ];
						idxArrL[ iL - 1 ] = idxArrL[ iL ];
						idxArrL[ iL ] = tmpL;
						sortedL = FALSE;
					}
				}
			}
			while( !sortedL );

			for( iL = ( sizeL >> 1 ); iL < sizeL && actArrL[ idxArrL[ iL ] ] >= 0; iL++ )
				;

			{
				uint32 subSizeL = iL;

				/* reorder clusters */
				bts_Cluster2D_size( cpA, tmpClPtrL, subSizeL );
				{
					struct bts_Int16Vec2D* tmpVecArrL = tmpClPtrL->vecArrE;
					for( iL = 0; iL < subSizeL; iL++ ) tmpVecArrL[ iL ] = srcVecArrL[ idxArrL[ iL ] ];
					for( iL = 0; iL < subSizeL; iL++ ) srcVecArrL[ iL ] = tmpVecArrL[ iL ];
					for( iL = 0; iL < subSizeL; iL++ ) tmpVecArrL[ iL ] = dstVecArrL[ idxArrL[ iL ] ];
					for( iL = 0; iL < subSizeL; iL++ ) dstVecArrL[ iL ] = tmpVecArrL[ iL ];
				}
				bts_Cluster2D_size( cpA, wrkClPtrL, subSizeL );
				bts_Cluster2D_size( cpA, dstClPtrL, subSizeL );
			}
		}

		/* compute confidence */
		{
			int16* idxArrL = ptrA->idxArrE.arrPtrE;
			int32* actArrL = ptrA->actArrE.arrPtrE;
			int32 actSumL = 0; /* .20 */
			for( iL = 0; iL < sizeL; iL++ )
			{
				float actL = ( actArrL[ idxArrL[ iL ] ] + 128 ) >> 8;
				if( actL < 0 ) break;
				actSumL += actL;
			}

			/* actSumL = average positive activity */
			actSumL = ( iL > 0 ) ? actSumL / iL : 0;

			confidenceL = ( ( ( int32 )iL << 20 ) - ( ( ( int32 )1 << 20 ) - actSumL ) ) / sizeL;

			/* adjust to 4.28 */
			confidenceL <<= 8;
		}

	}

	/* map: wrkCluster -> dstCluster */
	bts_RBFMap2D_compute( cpA, rbfPtrL, wrkClPtrL, dstClPtrL );

	/* apply map to ref cluster */
	bts_Cluster2D_rbfTransform( cpA, refClPtrL, rbfPtrL );

	/* copy ref cluster to outCluster */
	bts_Cluster2D_copy( cpA, &outClusterPtrA->clusterE, refClPtrL );
	bbs_Int16Arr_copy( cpA, &outClusterPtrA->idArrE, &ptrA->refClusterE.idArrE );

	/* PCA Mapping */
	if( ptrA->pcaDimSubSpaceE > 0 )
	{
		bbf_LocalScanDetector_pcaMap( cpA, ptrA, outClusterPtrA, outClusterPtrA );
	}

	/* backtransform out cluster to original image */
	bts_Cluster2D_transformBbp( cpA, &outClusterPtrA->clusterE, bts_Flt16Alt2D_inverted( &altL ), inClusterPtrA->clusterE.bbpE );

	return confidenceL;
}

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

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