1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 /* ---- includes ----------------------------------------------------------- */ 18 19 #include "b_BasicEm/Functions.h" 20 #include "b_BasicEm/Math.h" 21 #include "b_ImageEm/Functions.h" 22 #include "b_BitFeatureEm/LocalScanDetector.h" 23 24 /* ------------------------------------------------------------------------- */ 25 26 /* ========================================================================= */ 27 /* */ 28 /* ---- \ghd{ auxiliary functions } ---------------------------------------- */ 29 /* */ 30 /* ========================================================================= */ 31 32 /* ------------------------------------------------------------------------- */ 33 34 /** applies PCA mapping 35 * Input and output clusters may be identical 36 */ 37 void bbf_LocalScanDetector_pcaMap( struct bbs_Context* cpA, 38 const struct bbf_LocalScanDetector* ptrA, 39 const struct bts_IdCluster2D* inClusterPtrA, 40 struct bts_IdCluster2D* outClusterPtrA ) 41 { 42 bbs_DEF_fNameL( "bbf_LocalScanDetector_pcaMap" ) 43 44 struct bts_Cluster2D* tmpCl1PtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster1E; 45 struct bts_Cluster2D* tmpCl2PtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster2E; 46 struct bts_RBFMap2D* rbfPtrL = ( struct bts_RBFMap2D* )&ptrA->rbfMapE; 47 struct bts_Flt16Alt2D altL; 48 uint32 outBbpL = inClusterPtrA->clusterE.bbpE; 49 uint32 iL, jL; 50 51 /* setup two equivalent clusters holding the essential (alt-free) moves to be handled by PCA */ 52 bts_IdCluster2D_convertToEqivalentClusters( cpA, 53 inClusterPtrA, 54 &ptrA->pcaClusterE, 55 tmpCl1PtrL, 56 tmpCl2PtrL ); 57 58 altL = bts_Cluster2D_alt( cpA, tmpCl1PtrL, tmpCl2PtrL, bts_ALT_RIGID ); 59 bts_Cluster2D_transform( cpA, tmpCl1PtrL, altL ); 60 bts_RBFMap2D_compute( cpA, rbfPtrL, tmpCl2PtrL, tmpCl1PtrL ); 61 bts_RBFMap2D_mapCluster( cpA, rbfPtrL, &ptrA->pcaClusterE.clusterE, tmpCl1PtrL, 6/* ! */ ); 62 63 /* PCA projection: cluster1 -> cluster1 */ 64 { 65 /* mat elements: 8.8 */ 66 const int16* matPtrL = ptrA->pcaMatE.arrPtrE; 67 68 /* same bbp as pca cluster */ 69 const int16* avgPtrL = ptrA->pcaAvgE.arrPtrE; 70 71 struct bts_Int16Vec2D* vecArrL = tmpCl1PtrL->vecArrE; 72 73 /* projected vector */ 74 int32 prjVecL[ bpi_LOCAL_SCAN_DETECTOR_MAX_PCA_DIM ]; 75 76 /* width of matrix */ 77 uint16 matWidthL = tmpCl1PtrL->sizeE * 2; 78 79 if( ptrA->pcaDimSubSpaceE > bpi_LOCAL_SCAN_DETECTOR_MAX_PCA_DIM ) 80 { 81 bbs_ERROR1( "%s:\nbpi_RF_LANDMARKER_MAX_PCA_DIM exceeded", fNameL ); 82 return; 83 } 84 85 /* forward trafo */ 86 for( iL = 0; iL < ptrA->pcaDimSubSpaceE; iL++ ) 87 { 88 int32 sumL = 0; 89 avgPtrL = ptrA->pcaAvgE.arrPtrE; 90 for( jL = 0; jL < tmpCl1PtrL->sizeE; jL++ ) 91 { 92 sumL += matPtrL[ 0 ] * ( vecArrL[ jL ].xE - avgPtrL[ 0 ] ); 93 sumL += matPtrL[ 1 ] * ( vecArrL[ jL ].yE - avgPtrL[ 1 ] ); 94 avgPtrL += 2; 95 matPtrL += 2; 96 } 97 prjVecL[ iL ] = ( sumL + 128 ) >> 8; 98 } 99 100 matPtrL = ptrA->pcaMatE.arrPtrE; 101 avgPtrL = ptrA->pcaAvgE.arrPtrE; 102 vecArrL = tmpCl1PtrL->vecArrE; 103 104 /* backward trafo */ 105 for( jL = 0; jL < tmpCl1PtrL->sizeE; jL++ ) 106 { 107 int32 sumL = 0; 108 for( iL = 0; iL < ptrA->pcaDimSubSpaceE; iL++ ) 109 { 110 sumL += matPtrL[ iL * matWidthL + 0 ] * prjVecL[ iL ]; 111 } 112 113 vecArrL[ jL ].xE = ( ( sumL + 128 ) >> 8 ) + avgPtrL[ 0 ]; 114 115 sumL = 0; 116 for( iL = 0; iL < ptrA->pcaDimSubSpaceE; iL++ ) 117 { 118 sumL += matPtrL[ iL * matWidthL + 1 ] * prjVecL[ iL ]; 119 } 120 121 vecArrL[ jL ].yE = ( ( sumL + 128 ) >> 8 ) + avgPtrL[ 1 ]; 122 123 matPtrL += 2; 124 avgPtrL += 2; 125 } 126 } 127 128 /* ALT backtransformation */ 129 bts_IdCluster2D_copy( cpA, outClusterPtrA, &ptrA->pcaClusterE ); 130 bts_Cluster2D_copyTransform( cpA, &outClusterPtrA->clusterE, tmpCl1PtrL, bts_Flt16Alt2D_inverted( &altL ), outBbpL ); 131 } 132 133 /* ------------------------------------------------------------------------- */ 134 135 /* ========================================================================= */ 136 /* */ 137 /* ---- \ghd{ constructor / destructor } ----------------------------------- */ 138 /* */ 139 /* ========================================================================= */ 140 141 /* ------------------------------------------------------------------------- */ 142 143 void bbf_LocalScanDetector_init( struct bbs_Context* cpA, 144 struct bbf_LocalScanDetector* ptrA ) 145 { 146 bbs_memset16( ptrA->ftrPtrArrE, 0, bbs_SIZEOF16( ptrA->ftrPtrArrE ) ); 147 bts_RBFMap2D_init( cpA, &ptrA->rbfMapE ); 148 bts_Cluster2D_init( cpA, &ptrA->tmpCluster1E ); 149 bts_Cluster2D_init( cpA, &ptrA->tmpCluster2E ); 150 bts_Cluster2D_init( cpA, &ptrA->tmpCluster3E ); 151 bts_Cluster2D_init( cpA, &ptrA->tmpCluster4E ); 152 bbf_LocalScanner_init( cpA, &ptrA->scannerE ); 153 bbs_Int32Arr_init( cpA, &ptrA->actArrE ); 154 bbs_Int16Arr_init( cpA, &ptrA->idxArrE ); 155 bbs_UInt8Arr_init( cpA, &ptrA->workImageBufE ); 156 ptrA->maxImageWidthE = 0; 157 ptrA->maxImageHeightE = 0; 158 159 ptrA->patchWidthE = 0; 160 ptrA->patchHeightE = 0; 161 ptrA->scanWidthE = 0; 162 ptrA->scanHeightE = 0; 163 ptrA->scaleExpE = 0; 164 ptrA->interpolatedWarpingE = TRUE; 165 ptrA->warpScaleThresholdE = 0; 166 bts_IdCluster2D_init( cpA, &ptrA->refClusterE ); 167 bts_Cluster2D_init( cpA, &ptrA->scanClusterE ); 168 bbs_UInt16Arr_init( cpA, &ptrA->ftrDataArrE ); 169 bbf_BitParam_init( cpA, &ptrA->bitParamE ); 170 ptrA->outlierDistanceE = 0; 171 bts_IdCluster2D_init( cpA, &ptrA->pcaClusterE ); 172 bbs_Int16Arr_init( cpA, &ptrA->pcaAvgE ); 173 bbs_Int16Arr_init( cpA, &ptrA->pcaMatE ); 174 ptrA->pcaDimSubSpaceE = 0; 175 ptrA->maxImageWidthE = 0; 176 ptrA->maxImageHeightE = 0; 177 } 178 179 /* ------------------------------------------------------------------------- */ 180 181 void bbf_LocalScanDetector_exit( struct bbs_Context* cpA, 182 struct bbf_LocalScanDetector* ptrA ) 183 { 184 uint16 iL; 185 for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) bbf_featureExit( cpA, ptrA->ftrPtrArrE[ iL ] ); 186 bbs_memset16( ptrA->ftrPtrArrE, 0, bbs_SIZEOF16( ptrA->ftrPtrArrE ) ); 187 188 bts_RBFMap2D_exit( cpA, &ptrA->rbfMapE ); 189 bts_Cluster2D_exit( cpA, &ptrA->tmpCluster1E ); 190 bts_Cluster2D_exit( cpA, &ptrA->tmpCluster2E ); 191 bts_Cluster2D_exit( cpA, &ptrA->tmpCluster3E ); 192 bts_Cluster2D_exit( cpA, &ptrA->tmpCluster4E ); 193 bbf_LocalScanner_exit( cpA, &ptrA->scannerE ); 194 bbs_Int32Arr_exit( cpA, &ptrA->actArrE ); 195 bbs_Int16Arr_exit( cpA, &ptrA->idxArrE ); 196 bbs_UInt8Arr_exit( cpA, &ptrA->workImageBufE ); 197 ptrA->maxImageWidthE = 0; 198 ptrA->maxImageHeightE = 0; 199 200 ptrA->patchWidthE = 0; 201 ptrA->patchHeightE = 0; 202 ptrA->scanWidthE = 0; 203 ptrA->scanHeightE = 0; 204 ptrA->scaleExpE = 0; 205 ptrA->interpolatedWarpingE = TRUE; 206 ptrA->warpScaleThresholdE = 0; 207 bts_IdCluster2D_exit( cpA, &ptrA->refClusterE ); 208 bts_Cluster2D_exit( cpA, &ptrA->scanClusterE ); 209 bbs_UInt16Arr_exit( cpA, &ptrA->ftrDataArrE ); 210 bbf_BitParam_exit( cpA, &ptrA->bitParamE ); 211 ptrA->outlierDistanceE = 0; 212 bts_IdCluster2D_exit( cpA, &ptrA->pcaClusterE ); 213 bbs_Int16Arr_exit( cpA, &ptrA->pcaAvgE ); 214 bbs_Int16Arr_exit( cpA, &ptrA->pcaMatE ); 215 ptrA->pcaDimSubSpaceE = 0; 216 ptrA->maxImageWidthE = 0; 217 ptrA->maxImageHeightE = 0; 218 } 219 220 /* ------------------------------------------------------------------------- */ 221 222 /* ========================================================================= */ 223 /* */ 224 /* ---- \ghd{ operators } -------------------------------------------------- */ 225 /* */ 226 /* ========================================================================= */ 227 228 /* ------------------------------------------------------------------------- */ 229 230 void bbf_LocalScanDetector_copy( struct bbs_Context* cpA, 231 struct bbf_LocalScanDetector* ptrA, 232 const struct bbf_LocalScanDetector* srcPtrA ) 233 { 234 bbs_ERROR0( "bbf_LocalScanDetector_copy:\n Function is not available" ); 235 } 236 237 /* ------------------------------------------------------------------------- */ 238 239 flag bbf_LocalScanDetector_equal( struct bbs_Context* cpA, 240 const struct bbf_LocalScanDetector* ptrA, 241 const struct bbf_LocalScanDetector* srcPtrA ) 242 { 243 bbs_ERROR0( "bbf_LocalScanDetector_equal:\n Function is not available" ); 244 return TRUE; 245 } 246 247 /* ------------------------------------------------------------------------- */ 248 249 /* ========================================================================= */ 250 /* */ 251 /* ---- \ghd{ query functions } -------------------------------------------- */ 252 /* */ 253 /* ========================================================================= */ 254 255 /* ------------------------------------------------------------------------- */ 256 257 /* ========================================================================= */ 258 /* */ 259 /* ---- \ghd{ modify functions } ------------------------------------------- */ 260 /* */ 261 /* ========================================================================= */ 262 263 /* ------------------------------------------------------------------------- */ 264 265 /* ========================================================================= */ 266 /* */ 267 /* ---- \ghd{ I/O } -------------------------------------------------------- */ 268 /* */ 269 /* ========================================================================= */ 270 271 /* ------------------------------------------------------------------------- */ 272 273 uint32 bbf_LocalScanDetector_memSize( struct bbs_Context* cpA, 274 const struct bbf_LocalScanDetector* ptrA ) 275 { 276 uint32 iL; 277 uint32 memSizeL = bbs_SIZEOF16( uint32 ) + 278 bbs_SIZEOF16( uint32 ); /* version */ 279 280 memSizeL += bbs_SIZEOF16( ptrA->patchWidthE ); 281 memSizeL += bbs_SIZEOF16( ptrA->patchHeightE ); 282 memSizeL += bbs_SIZEOF16( ptrA->scanWidthE ); 283 memSizeL += bbs_SIZEOF16( ptrA->scanHeightE ); 284 memSizeL += bbs_SIZEOF16( ptrA->scaleExpE ); 285 memSizeL += bbs_SIZEOF16( ptrA->interpolatedWarpingE ); 286 memSizeL += bbs_SIZEOF16( ptrA->warpScaleThresholdE ); 287 memSizeL += bts_IdCluster2D_memSize( cpA, &ptrA->refClusterE ); 288 memSizeL += bts_Cluster2D_memSize( cpA, &ptrA->scanClusterE ); 289 memSizeL += bbf_BitParam_memSize( cpA, &ptrA->bitParamE ); 290 memSizeL += bbs_SIZEOF16( ptrA->outlierDistanceE ); 291 memSizeL += bts_IdCluster2D_memSize( cpA, &ptrA->pcaClusterE ); 292 memSizeL += bbs_Int16Arr_memSize( cpA, &ptrA->pcaAvgE ); 293 memSizeL += bbs_Int16Arr_memSize( cpA, &ptrA->pcaMatE ); 294 memSizeL += bbs_SIZEOF16( ptrA->pcaDimSubSpaceE ); 295 memSizeL += bbs_SIZEOF16( ptrA->maxImageWidthE ); 296 memSizeL += bbs_SIZEOF16( ptrA->maxImageHeightE ); 297 for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) memSizeL += bbf_featureMemSize( cpA, ptrA->ftrPtrArrE[ iL ] ); 298 299 return memSizeL; 300 } 301 302 /* ------------------------------------------------------------------------- */ 303 304 uint32 bbf_LocalScanDetector_memWrite( struct bbs_Context* cpA, 305 const struct bbf_LocalScanDetector* ptrA, 306 uint16* memPtrA ) 307 { 308 uint32 iL; 309 uint32 memSizeL = bbf_LocalScanDetector_memSize( cpA, ptrA ); 310 memPtrA += bbs_memWrite32( &memSizeL, memPtrA ); 311 memPtrA += bbs_memWriteUInt32( bbf_LOCAL_SCAN_DETECTOR_VERSION, memPtrA ); 312 313 memPtrA += bbs_memWrite32( &ptrA->patchWidthE, memPtrA ); 314 memPtrA += bbs_memWrite32( &ptrA->patchHeightE, memPtrA ); 315 memPtrA += bbs_memWrite32( &ptrA->scanWidthE, memPtrA ); 316 memPtrA += bbs_memWrite32( &ptrA->scanHeightE, memPtrA ); 317 memPtrA += bbs_memWrite32( &ptrA->scaleExpE, memPtrA ); 318 memPtrA += bbs_memWrite32( &ptrA->interpolatedWarpingE, memPtrA ); 319 memPtrA += bbs_memWrite32( &ptrA->warpScaleThresholdE, memPtrA ); 320 memPtrA += bts_IdCluster2D_memWrite( cpA, &ptrA->refClusterE, memPtrA ); 321 memPtrA += bts_Cluster2D_memWrite( cpA, &ptrA->scanClusterE, memPtrA ); 322 memPtrA += bbf_BitParam_memWrite( cpA, &ptrA->bitParamE, memPtrA ); 323 memPtrA += bbs_memWrite32( &ptrA->outlierDistanceE, memPtrA ); 324 memPtrA += bts_IdCluster2D_memWrite( cpA, &ptrA->pcaClusterE, memPtrA ); 325 memPtrA += bbs_Int16Arr_memWrite( cpA, &ptrA->pcaAvgE, memPtrA ); 326 memPtrA += bbs_Int16Arr_memWrite( cpA, &ptrA->pcaMatE, memPtrA ); 327 memPtrA += bbs_memWrite32( &ptrA->pcaDimSubSpaceE, memPtrA ); 328 memPtrA += bbs_memWrite32( &ptrA->maxImageWidthE, memPtrA ); 329 memPtrA += bbs_memWrite32( &ptrA->maxImageHeightE, memPtrA ); 330 331 for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) memPtrA += bbf_featureMemWrite( cpA, ptrA->ftrPtrArrE[ iL ], memPtrA ); 332 333 return memSizeL; 334 } 335 336 /* ------------------------------------------------------------------------- */ 337 338 uint32 bbf_LocalScanDetector_memRead( struct bbs_Context* cpA, 339 struct bbf_LocalScanDetector* ptrA, 340 const uint16* memPtrA, 341 struct bbs_MemTbl* mtpA ) 342 { 343 uint32 iL; 344 uint32 memSizeL, versionL; 345 struct bbs_MemTbl memTblL = *mtpA; 346 struct bbs_MemSeg* espL = bbs_MemTbl_segPtr( cpA, &memTblL, 0 ); 347 struct bbs_MemSeg* sspL = bbs_MemTbl_sharedSegPtr( cpA, &memTblL, 0 ); 348 if( bbs_Context_error( cpA ) ) return 0; 349 350 memPtrA += bbs_memRead32( &memSizeL, memPtrA ); 351 memPtrA += bbs_memReadVersion32( cpA, &versionL, bbf_LOCAL_SCAN_DETECTOR_VERSION, memPtrA ); 352 353 354 memPtrA += bbs_memRead32( &ptrA->patchWidthE, memPtrA ); 355 memPtrA += bbs_memRead32( &ptrA->patchHeightE, memPtrA ); 356 memPtrA += bbs_memRead32( &ptrA->scanWidthE, memPtrA ); 357 memPtrA += bbs_memRead32( &ptrA->scanHeightE, memPtrA ); 358 memPtrA += bbs_memRead32( &ptrA->scaleExpE, memPtrA ); 359 memPtrA += bbs_memRead32( &ptrA->interpolatedWarpingE, memPtrA ); 360 memPtrA += bbs_memRead32( &ptrA->warpScaleThresholdE, memPtrA ); 361 memPtrA += bts_IdCluster2D_memRead( cpA, &ptrA->refClusterE, memPtrA, espL ); 362 memPtrA += bts_Cluster2D_memRead( cpA, &ptrA->scanClusterE, memPtrA, espL ); 363 memPtrA += bbf_BitParam_memRead( cpA, &ptrA->bitParamE, memPtrA ); 364 memPtrA += bbs_memRead32( &ptrA->outlierDistanceE, memPtrA ); 365 memPtrA += bts_IdCluster2D_memRead( cpA, &ptrA->pcaClusterE, memPtrA, espL ); 366 memPtrA += bbs_Int16Arr_memRead( cpA, &ptrA->pcaAvgE, memPtrA, espL ); 367 memPtrA += bbs_Int16Arr_memRead( cpA, &ptrA->pcaMatE, memPtrA, espL ); 368 memPtrA += bbs_memRead32( &ptrA->pcaDimSubSpaceE, memPtrA ); 369 memPtrA += bbs_memRead32( &ptrA->maxImageWidthE, memPtrA ); 370 memPtrA += bbs_memRead32( &ptrA->maxImageHeightE, memPtrA ); 371 372 /* check features & allocate data buffer */ 373 { 374 const uint16* memPtrL = memPtrA; 375 uint32 dataSizeL = 0; 376 for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) 377 { 378 enum bbf_FeatureType typeL = ( enum bbf_FeatureType )bbs_memPeek32( memPtrL + 4 ); 379 dataSizeL += bbf_featureSizeOf16( cpA, typeL ); 380 memPtrL += bbs_memPeek32( memPtrL ); 381 } 382 bbs_UInt16Arr_create( cpA, &ptrA->ftrDataArrE, dataSizeL, espL ); 383 } 384 385 /* load features & initialize pointers */ 386 { 387 uint16* dataPtrL = ptrA->ftrDataArrE.arrPtrE; 388 for( iL = 0; iL < ptrA->scanClusterE.sizeE; iL++ ) 389 { 390 enum bbf_FeatureType typeL = ( enum bbf_FeatureType )bbs_memPeek32( memPtrA + 4 ); 391 ptrA->ftrPtrArrE[ iL ] = ( struct bbf_Feature* )dataPtrL; 392 bbf_featureInit( cpA, ptrA->ftrPtrArrE[ iL ], typeL ); 393 memPtrA += bbf_featureMemRead( cpA, ptrA->ftrPtrArrE[ iL ], memPtrA, &memTblL ); 394 dataPtrL += bbf_featureSizeOf16( cpA, typeL ); 395 } 396 } 397 398 if( memSizeL != bbf_LocalScanDetector_memSize( cpA, ptrA ) ) 399 { 400 bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bbf_LocalScanDetector_memRead( struct bem_ScanGradientMove* ptrA, const uint16* memPtrA ):\n" 401 "size mismatch" ); 402 return 0; 403 } 404 405 if( ptrA->maxImageWidthE * ptrA->maxImageHeightE == 0 ) 406 { 407 bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bbf_LocalScanDetector_memRead( struct bem_ScanGradientMove* ptrA, const uint16* memPtrA ):\n" 408 "maximum image width/height not set" ); 409 return 0; 410 } 411 412 /* initialize internal data */ 413 414 /* ought to be placed on shared memory later */ 415 bts_RBFMap2D_create( cpA, &ptrA->rbfMapE, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL ); 416 ptrA->rbfMapE.RBFTypeE = bts_RBF_LINEAR; 417 ptrA->rbfMapE.altTypeE = bts_ALT_RIGID; 418 419 bts_Cluster2D_create( cpA, &ptrA->tmpCluster1E, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL ); 420 bts_Cluster2D_create( cpA, &ptrA->tmpCluster2E, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL ); 421 bts_Cluster2D_create( cpA, &ptrA->tmpCluster3E, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL ); 422 bts_Cluster2D_create( cpA, &ptrA->tmpCluster4E, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL ); 423 424 bbs_Int32Arr_create( cpA, &ptrA->actArrE, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL ); 425 bbs_Int16Arr_create( cpA, &ptrA->idxArrE, bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE, sspL ); 426 427 /* working image memory */ 428 /* ought to be placed on shared memory later */ 429 bbs_UInt8Arr_create( cpA, &ptrA->workImageBufE, ptrA->maxImageWidthE * ptrA->maxImageHeightE, sspL ); 430 431 /* initialize local scanner (be aware of shared memory usage when moving this create function) */ 432 bbf_LocalScanner_create( cpA, &ptrA->scannerE, 433 ptrA->patchWidthE, 434 ptrA->patchHeightE, 435 ptrA->scaleExpE, 436 ptrA->maxImageWidthE, 437 ptrA->maxImageHeightE, 438 ptrA->scaleExpE, 439 ptrA->bitParamE.outerRadiusE, 440 &memTblL ); 441 442 return memSizeL; 443 } 444 445 /* ------------------------------------------------------------------------- */ 446 447 /* ========================================================================= */ 448 /* */ 449 /* ---- \ghd{ exec functions } --------------------------------------------- */ 450 /* */ 451 /* ========================================================================= */ 452 453 /* ------------------------------------------------------------------------- */ 454 455 int32 bbf_LocalScanDetector_process( struct bbs_Context* cpA, 456 const struct bbf_LocalScanDetector* ptrA, 457 uint8* imagePtrA, 458 uint32 imageWidthA, 459 uint32 imageHeightA, 460 const struct bts_Int16Vec2D* offsPtrA, 461 const struct bts_IdCluster2D* inClusterPtrA, 462 struct bts_IdCluster2D* outClusterPtrA ) 463 { 464 bbs_DEF_fNameL( "bbf_LocalScanDetector_process" ) 465 466 int32 pw0L = ptrA->patchWidthE; 467 int32 ph0L = ptrA->patchHeightE; 468 int32 pw1L = pw0L << ptrA->scaleExpE; 469 int32 ph1L = ph0L << ptrA->scaleExpE; 470 471 struct bts_Cluster2D* wrkClPtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster1E; 472 struct bts_Cluster2D* refClPtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster2E; 473 struct bts_Cluster2D* dstClPtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster3E; 474 struct bts_Cluster2D* tmpClPtrL = ( struct bts_Cluster2D* )&ptrA->tmpCluster4E; 475 struct bts_RBFMap2D* rbfPtrL = ( struct bts_RBFMap2D* )&ptrA->rbfMapE; 476 struct bbf_LocalScanner* scnPtrL = ( struct bbf_LocalScanner* )&ptrA->scannerE; 477 478 int32* actArrL = ( int32* )ptrA->actArrE.arrPtrE; 479 int16* idxArrL = ( int16* )ptrA->idxArrE.arrPtrE; 480 481 uint32 workImageWidthL, workImageHeightL; 482 483 struct bts_Flt16Alt2D altL; 484 485 int32 confidenceL; 486 uint32 iL; 487 uint32 sizeL = ptrA->scanClusterE.sizeE; 488 489 if( sizeL > bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE ) 490 { 491 bbs_ERROR1( "%s:\nScan cluster size exceeds bpi_LOCAL_SCAN_DETECTOR_MAX_CLUSTER_SIZE", fNameL ); 492 return 0; 493 } 494 495 /* compute equivalent clusters (matching ids) from input and reference cluster */ 496 bts_IdCluster2D_convertToEqivalentClusters( cpA, inClusterPtrA, &ptrA->refClusterE, wrkClPtrL, refClPtrL ); 497 498 /* altL: orig image -> normalized image */ 499 altL = bts_Cluster2D_alt( cpA, wrkClPtrL, refClPtrL, bts_ALT_RIGID ); 500 501 /* transorm work cluster to normalized image */ 502 bts_Cluster2D_transformBbp( cpA, wrkClPtrL, altL, 6 ); 503 504 /* map: ref cluster -> work cluster */ 505 bts_RBFMap2D_compute( cpA, rbfPtrL, refClPtrL, wrkClPtrL ); 506 507 /* copy: scanClusterE -> work cluster */ 508 bts_Cluster2D_copy( cpA, wrkClPtrL, &ptrA->scanClusterE ); 509 510 /* copy: refClusterE -> ref cluster */ 511 bts_Cluster2D_copy( cpA, refClPtrL, &ptrA->refClusterE.clusterE ); 512 513 /* apply map to work cluster */ 514 bts_Cluster2D_rbfTransform( cpA, wrkClPtrL, rbfPtrL ); 515 516 /* apply map to ref cluster */ 517 bts_Cluster2D_rbfTransform( cpA, refClPtrL, rbfPtrL ); 518 519 { 520 /* analyze boundaries; get exact dimensions of working image */ 521 int32 workBorderWL = ( ( ptrA->scanWidthE + pw1L + 1 ) >> 1 ) + 1; /* add a pixel to ensure full search area */ 522 int32 workBorderHL = ( ( ptrA->scanHeightE + ph1L + 1 ) >> 1 ) + 1; /* add a pixel to ensure full search area */ 523 struct bts_Int16Rect workAreaL = bts_Cluster2D_boundingBox( cpA, wrkClPtrL ); 524 workAreaL.x1E = workAreaL.x1E >> wrkClPtrL->bbpE; 525 workAreaL.y1E = workAreaL.y1E >> wrkClPtrL->bbpE; 526 workAreaL.x2E = workAreaL.x2E >> wrkClPtrL->bbpE; 527 workAreaL.y2E = workAreaL.y2E >> wrkClPtrL->bbpE; 528 workAreaL.x1E -= workBorderWL; 529 workAreaL.y1E -= workBorderHL; 530 workAreaL.x2E += workBorderWL; 531 workAreaL.y2E += workBorderHL; 532 533 workImageWidthL = workAreaL.x2E - workAreaL.x1E; 534 workImageHeightL = workAreaL.y2E - workAreaL.y1E; 535 536 /* truncate if necessary (should not occur in normal operation) */ 537 workImageWidthL = workImageWidthL > ptrA->maxImageWidthE ? ptrA->maxImageWidthE : workImageWidthL; 538 workImageHeightL = workImageHeightL > ptrA->maxImageHeightE ? ptrA->maxImageHeightE : workImageHeightL; 539 540 /* adjust ALT */ 541 altL.vecE.xE -= workAreaL.x1E << altL.vecE.bbpE; 542 altL.vecE.yE -= workAreaL.y1E << altL.vecE.bbpE; 543 544 /* adjust work cluster */ 545 for( iL = 0; iL < wrkClPtrL->sizeE; iL++ ) 546 { 547 wrkClPtrL->vecArrE[ iL ].xE -= workAreaL.x1E << wrkClPtrL->bbpE; 548 wrkClPtrL->vecArrE[ iL ].yE -= workAreaL.y1E << wrkClPtrL->bbpE; 549 } 550 551 /* adjust ref cluster */ 552 for( iL = 0; iL < wrkClPtrL->sizeE; iL++ ) 553 { 554 refClPtrL->vecArrE[ iL ].xE -= workAreaL.x1E << refClPtrL->bbpE; 555 refClPtrL->vecArrE[ iL ].yE -= workAreaL.y1E << refClPtrL->bbpE; 556 } 557 558 /* transform image */ 559 bim_filterWarp( cpA, 560 ptrA->workImageBufE.arrPtrE, 561 imagePtrA, imageWidthA, imageHeightA, 562 offsPtrA, 563 &altL, 564 workImageWidthL, workImageHeightL, 565 NULL, 566 ptrA->warpScaleThresholdE, 567 ptrA->interpolatedWarpingE ); 568 569 } 570 571 /* scan over all positions of work cluster; target positions are stored in *dstClPtrL*/ 572 { 573 int32 regionWHL = ( ptrA->scanWidthE + pw1L + 1 ) >> 1; 574 int32 regionHHL = ( ptrA->scanHeightE + ph1L + 1 ) >> 1; 575 struct bts_Int16Vec2D* srcVecArrL = wrkClPtrL->vecArrE; 576 struct bts_Int16Vec2D* dstVecArrL = dstClPtrL->vecArrE; 577 int32 vecBbpL = wrkClPtrL->bbpE; 578 bts_Cluster2D_size( cpA, dstClPtrL, sizeL ); 579 dstClPtrL->bbpE = vecBbpL; 580 581 /* initialize scanner */ 582 scnPtrL->patchWidthE = ptrA->patchWidthE; 583 scnPtrL->patchHeightE = ptrA->patchWidthE; 584 scnPtrL->scaleExpE = ptrA->scaleExpE; 585 586 bbf_LocalScanner_assign( cpA, scnPtrL, ptrA->workImageBufE.arrPtrE, workImageWidthL, workImageHeightL, &ptrA->bitParamE ); 587 588 bbs_memset32( actArrL, 0x80000000, sizeL ); 589 590 do 591 { 592 for( iL = 0; iL < sizeL; iL++ ) 593 { 594 int32 bestActL = 0x80000000; 595 uint32 bestIdxL = 0; 596 struct bbf_Feature* ftrPtrL = ptrA->ftrPtrArrE[ iL ]; 597 598 /* set scan region */ 599 { 600 int32 x0L = ( ( wrkClPtrL->vecArrE[ iL ].xE >> ( wrkClPtrL->bbpE - 1 ) ) + 1 ) >> 1; 601 int32 y0L = ( ( wrkClPtrL->vecArrE[ iL ].yE >> ( wrkClPtrL->bbpE - 1 ) ) + 1 ) >> 1; 602 struct bts_Int16Rect scanRegionL = bts_Int16Rect_create( x0L - regionWHL, y0L - regionHHL, x0L + regionWHL, y0L + regionHHL ); 603 bbf_LocalScanner_origScanRegion( cpA, scnPtrL, &scanRegionL ); 604 } 605 606 do 607 { 608 int32 actL = ftrPtrL->vpActivityE( ftrPtrL, bbf_LocalScanner_getPatch( scnPtrL ) ); 609 610 if( actL > bestActL ) 611 { 612 bestActL = actL; 613 bestIdxL = bbf_LocalScanner_scanIndex( scnPtrL ); 614 } 615 } 616 while( bbf_LocalScanner_next( cpA, scnPtrL ) ); 617 618 { 619 int32 xL, yL; /* 16.16 */ 620 bbf_LocalScanner_idxPos( scnPtrL, bestIdxL, &xL, &yL ); 621 xL += pw1L << 15; 622 yL += ph1L << 15; 623 if( bestActL > actArrL[ iL ] ) 624 { 625 dstVecArrL[ iL ].xE = ( ( xL >> ( 15 - vecBbpL ) ) + 1 ) >> 1; 626 dstVecArrL[ iL ].yE = ( ( yL >> ( 15 - vecBbpL ) ) + 1 ) >> 1; 627 actArrL[ iL ] = bestActL; 628 } 629 } 630 } 631 } 632 while( bbf_LocalScanner_nextOffset( cpA, scnPtrL ) ); 633 634 /* outlier analysis: outliers are disabled by setting their similarity to -1 */ 635 if( ptrA->outlierDistanceE > 0 ) 636 { 637 /* altL: work cluster -> ref cluster */ 638 struct bts_Flt16Alt2D localAltL = bts_Cluster2D_alt( cpA, wrkClPtrL, dstClPtrL, bts_ALT_RIGID ); 639 640 /* squared distance 16.16 */ 641 uint32 dist2L = ( ptrA->outlierDistanceE >> 8 ) * ( ptrA->outlierDistanceE >> 8 ); 642 643 /* analyze deviations */ 644 for( iL = 0; iL < sizeL; iL++ ) 645 { 646 struct bts_Flt16Vec2D vecL = bts_Flt16Vec2D_create32( srcVecArrL[ iL ].xE, srcVecArrL[ iL ].yE, vecBbpL ); 647 uint32 dev2L; /* squared deviation 16.16 */ 648 vecL = bts_Flt16Alt2D_mapFlt( &localAltL, &vecL ); 649 vecL = bts_Flt16Vec2D_sub( vecL, bts_Flt16Vec2D_create32( dstVecArrL[ iL ].xE, dstVecArrL[ iL ].yE, vecBbpL ) ); 650 dev2L = bbs_convertU32( bts_Flt16Vec2D_norm2( &vecL ), vecL.bbpE << 1, 16 ); 651 if( dev2L > dist2L ) actArrL[ iL ] = 0xF0000000; 652 } 653 } 654 655 /* remove undetected positions but keep at least 1/2 best positions */ 656 { 657 flag sortedL; 658 659 /* bubble sort (no speed issue in this case) */ 660 for( iL = 0; iL < sizeL; iL++ ) idxArrL[ iL ] = iL; 661 662 do 663 { 664 sortedL = TRUE; 665 for( iL = 1; iL < sizeL; iL++ ) 666 { 667 if( actArrL[ idxArrL[ iL - 1 ] ] < actArrL[ idxArrL[ iL ] ] ) 668 { 669 int16 tmpL = idxArrL[ iL - 1 ]; 670 idxArrL[ iL - 1 ] = idxArrL[ iL ]; 671 idxArrL[ iL ] = tmpL; 672 sortedL = FALSE; 673 } 674 } 675 } 676 while( !sortedL ); 677 678 for( iL = ( sizeL >> 1 ); iL < sizeL && actArrL[ idxArrL[ iL ] ] >= 0; iL++ ) 679 ; 680 681 { 682 uint32 subSizeL = iL; 683 684 /* reorder clusters */ 685 bts_Cluster2D_size( cpA, tmpClPtrL, subSizeL ); 686 { 687 struct bts_Int16Vec2D* tmpVecArrL = tmpClPtrL->vecArrE; 688 for( iL = 0; iL < subSizeL; iL++ ) tmpVecArrL[ iL ] = srcVecArrL[ idxArrL[ iL ] ]; 689 for( iL = 0; iL < subSizeL; iL++ ) srcVecArrL[ iL ] = tmpVecArrL[ iL ]; 690 for( iL = 0; iL < subSizeL; iL++ ) tmpVecArrL[ iL ] = dstVecArrL[ idxArrL[ iL ] ]; 691 for( iL = 0; iL < subSizeL; iL++ ) dstVecArrL[ iL ] = tmpVecArrL[ iL ]; 692 } 693 bts_Cluster2D_size( cpA, wrkClPtrL, subSizeL ); 694 bts_Cluster2D_size( cpA, dstClPtrL, subSizeL ); 695 } 696 } 697 698 /* compute confidence */ 699 { 700 int16* idxArrL = ptrA->idxArrE.arrPtrE; 701 int32* actArrL = ptrA->actArrE.arrPtrE; 702 int32 actSumL = 0; /* .20 */ 703 for( iL = 0; iL < sizeL; iL++ ) 704 { 705 float actL = ( actArrL[ idxArrL[ iL ] ] + 128 ) >> 8; 706 if( actL < 0 ) break; 707 actSumL += actL; 708 } 709 710 /* actSumL = average positive activity */ 711 actSumL = ( iL > 0 ) ? actSumL / iL : 0; 712 713 confidenceL = ( ( ( int32 )iL << 20 ) - ( ( ( int32 )1 << 20 ) - actSumL ) ) / sizeL; 714 715 /* adjust to 4.28 */ 716 confidenceL <<= 8; 717 } 718 719 } 720 721 /* map: wrkCluster -> dstCluster */ 722 bts_RBFMap2D_compute( cpA, rbfPtrL, wrkClPtrL, dstClPtrL ); 723 724 /* apply map to ref cluster */ 725 bts_Cluster2D_rbfTransform( cpA, refClPtrL, rbfPtrL ); 726 727 /* copy ref cluster to outCluster */ 728 bts_Cluster2D_copy( cpA, &outClusterPtrA->clusterE, refClPtrL ); 729 bbs_Int16Arr_copy( cpA, &outClusterPtrA->idArrE, &ptrA->refClusterE.idArrE ); 730 731 /* PCA Mapping */ 732 if( ptrA->pcaDimSubSpaceE > 0 ) 733 { 734 bbf_LocalScanDetector_pcaMap( cpA, ptrA, outClusterPtrA, outClusterPtrA ); 735 } 736 737 /* backtransform out cluster to original image */ 738 bts_Cluster2D_transformBbp( cpA, &outClusterPtrA->clusterE, bts_Flt16Alt2D_inverted( &altL ), inClusterPtrA->clusterE.bbpE ); 739 740 return confidenceL; 741 } 742 743 /* ------------------------------------------------------------------------- */ 744 745 /* ========================================================================= */ 746 747
