| /* |
| * 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_APIEm/Functions.h" |
| #include "b_BasicEm/Memory.h" |
| |
| |
| /* ---- related objects --------------------------------------------------- */ |
| |
| /* ---- typedefs ----------------------------------------------------------- */ |
| |
| /* ---- constants ---------------------------------------------------------- */ |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| /* ========================================================================= */ |
| /* */ |
| /* ---- \ghd{ external functions } ----------------------------------------- */ |
| /* */ |
| /* ========================================================================= */ |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| void bpi_normalizeSimilarities( struct bbs_Context* cpA, |
| const int32* rawSimArrA, |
| const int32* rawIdArrA, |
| uint32 rawSizeA, |
| const int32* refSimArrA, |
| const int32* refIdArrA, |
| uint32 refSizeA, |
| enum bpi_SimType simTypeA, |
| int32* outSimArrA ) |
| { |
| /* 8.24 */ |
| int32 refSimL = 0; |
| uint32 iL, jL, kL; |
| int32* outPtrL = outSimArrA; |
| const int32* rawPtrL = rawSimArrA; |
| |
| switch( simTypeA ) |
| { |
| case bpi_RAW_SIM: |
| { |
| /* nothing to do */ |
| } |
| break; |
| |
| case bpi_SUB_MEAN: |
| { |
| int32 shiftL = 0; |
| int32 roundL = 0; |
| refSimL = 0; |
| for( iL = 0; iL < refSizeA; iL++ ) |
| { |
| refSimL += ( refSimArrA[ iL ] + roundL ) >> shiftL; |
| if( refSimL > 0x40000000 ) |
| { |
| refSimL = ( refSimL + 1 ) >> 1; |
| shiftL++; |
| roundL = ( int32 )1 << ( shiftL - 1 ); |
| } |
| } |
| refSimL = ( refSimL / refSizeA ) << shiftL; |
| } |
| break; |
| |
| case bpi_SUB_MAX_2: |
| { |
| int32 maxL = 0; |
| uint32 maxIndexL = 0; |
| int32 idL = 0; |
| |
| /* find raw maximum */ |
| for( iL = 0; iL < rawSizeA; iL++ ) |
| { |
| if( maxL < rawSimArrA[ iL ] ) |
| { |
| maxL = refSimArrA[ iL ]; |
| maxIndexL = iL; |
| } |
| } |
| |
| /* consider id of maximum equal to probe id */ |
| idL = rawIdArrA[ maxIndexL ]; |
| |
| /* find maximum similarity in ref array of different id */ |
| for( iL = 0; iL < refSizeA; iL++ ) |
| { |
| if( refIdArrA[ iL ] != idL ) |
| { |
| refSimL = ( refSimL > refSimArrA[ iL ] ) ? refSimL : refSimArrA[ iL ]; |
| } |
| } |
| } |
| break; |
| |
| case bpi_SUB_16_MAX_2: |
| { |
| int32 maxL = 0; |
| uint32 maxIndexL = 0; |
| int32 idL = 0; |
| |
| int32 maxSimArrL[ 16 ]; |
| bbs_memset32( maxSimArrL, ( uint32 )-1, bbs_SIZEOF32( maxSimArrL ) ); |
| |
| /* find raw maximum */ |
| for( iL = 0; iL < rawSizeA; iL++ ) |
| { |
| if( maxL < rawSimArrA[ iL ] ) |
| { |
| maxL = rawSimArrA[ iL ]; |
| maxIndexL = iL; |
| } |
| } |
| |
| /* consider id of maximum equal to probe id */ |
| idL = rawIdArrA[ maxIndexL ]; |
| |
| /* find 16 maximum similarities of different id in ref array */ |
| for( iL = 0; iL < refSizeA; iL++ ) |
| { |
| if( refIdArrA[ iL ] != idL ) |
| { |
| int32 simL = refSimArrA[ iL ]; |
| for( jL = 0; jL < 16; jL++ ) |
| { |
| if( simL > maxSimArrL[ jL ] ) break; |
| } |
| for( kL = 15; kL > jL; kL-- ) |
| { |
| maxSimArrL[ kL ] = maxSimArrL[ kL - 1 ]; |
| } |
| if( jL < 16 ) maxSimArrL[ jL ] = simL; |
| } |
| } |
| |
| refSimL = 0; |
| for( jL = 0; jL < 16; jL++ ) |
| { |
| if( maxSimArrL[ jL ] == -1 ) break; |
| refSimL += maxSimArrL[ jL ]; |
| } |
| |
| if( jL > 0 ) |
| { |
| refSimL /= jL; |
| } |
| } |
| break; |
| |
| default: |
| { |
| bbs_ERROR1( "void bpi_Identifier_normalizeSimilarities(): simTypeA '%i' is handled", simTypeA ); |
| return; |
| } |
| } |
| |
| /* refSimL -= 1.0 */ |
| refSimL -= ( (uint32)1 << 24 ); |
| |
| for( iL = rawSizeA; iL > 0; iL-- ) |
| { |
| *outPtrL++ = ( *rawPtrL++ - refSimL + 1 ) >> 1; |
| } |
| |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| int32 bpi_normalizedSimilarity( struct bbs_Context* cpA, |
| int32 rawSimA, |
| int32 rawIdA, |
| const int32* refSimArrA, |
| const int32* refIdArrA, |
| uint32 refSizeA, |
| enum bpi_SimType simTypeA ) |
| { |
| /* 8.24 */ |
| int32 refSimL = 0; |
| uint32 iL, jL, kL; |
| |
| switch( simTypeA ) |
| { |
| case bpi_RAW_SIM: |
| { |
| /* nothing to do */ |
| return rawSimA; /* return without adjustment of value range */ |
| } |
| |
| case bpi_SUB_MEAN: |
| { |
| int32 shiftL = 0; |
| int32 roundL = 0; |
| refSimL = 0; |
| for( iL = 0; iL < refSizeA; iL++ ) |
| { |
| refSimL += ( refSimArrA[ iL ] + roundL ) >> shiftL; |
| if( refSimL > 0x40000000 ) |
| { |
| refSimL = ( refSimL + 1 ) >> 1; |
| shiftL++; |
| roundL = ( int32 )1 << ( shiftL - 1 ); |
| } |
| } |
| refSimL = ( refSimL / refSizeA ) << shiftL; |
| } |
| break; |
| |
| case bpi_SUB_MAX_2: |
| { |
| /* find maximum similarity in ref array of different rawIdA */ |
| for( iL = 0; iL < refSizeA; iL++ ) |
| { |
| if( refIdArrA[ iL ] != rawIdA ) |
| { |
| refSimL = ( refSimL > refSimArrA[ iL ] ) ? refSimL : refSimArrA[ iL ]; |
| } |
| } |
| } |
| break; |
| |
| case bpi_SUB_16_MAX_2: |
| { |
| int32 maxSimArrL[ 16 ]; |
| int32 idL = rawIdA; |
| bbs_memset32( maxSimArrL, ( uint32 )-1, bbs_SIZEOF32( maxSimArrL ) ); |
| |
| /* find 16 maximum similarities of different id in ref array */ |
| for( iL = 0; iL < refSizeA; iL++ ) |
| { |
| if( refIdArrA[ iL ] != idL ) |
| { |
| int32 simL = refSimArrA[ iL ]; |
| for( jL = 0; jL < 16; jL++ ) |
| { |
| if( simL > maxSimArrL[ jL ] ) break; |
| } |
| for( kL = 15; kL > jL; kL-- ) |
| { |
| maxSimArrL[ kL ] = maxSimArrL[ kL - 1 ]; |
| } |
| if( jL < 16 ) maxSimArrL[ jL ] = simL; |
| } |
| } |
| |
| refSimL = 0; |
| for( jL = 0; jL < 16; jL++ ) |
| { |
| if( maxSimArrL[ jL ] == -1 ) break; |
| refSimL += maxSimArrL[ jL ]; |
| } |
| |
| if( jL > 0 ) |
| { |
| refSimL /= jL; |
| } |
| } |
| break; |
| |
| default: |
| { |
| bbs_ERROR1( "void bpi_Identifier_normalizeSimilarities(): simTypeA '%i' is handled", simTypeA ); |
| } |
| break; |
| } |
| |
| /* refSimL -= 1.0 */ |
| refSimL -= ( (uint32)1 << 24 ); |
| return ( rawSimA - refSimL + 1 ) >> 1; |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| uint32 bpi_memWriteCsa16( uint16* memPtrA, uint32 memSizeA, uint16 chkSumA ) |
| { |
| uint16* memPtrL = memPtrA - memSizeA + 1; |
| uint32 iL; |
| uint16 sumL = 0; |
| uint16 csaL = 0; |
| |
| bbs_memWrite16( &csaL, memPtrA ); |
| for( iL = 0; iL < memSizeA; iL++ ) |
| { |
| uint16 valL = 0; |
| memPtrL += bbs_memRead16( &valL, memPtrL ); |
| sumL += valL; |
| } |
| csaL = chkSumA - sumL; |
| |
| return bbs_memWrite16( &csaL, memPtrA ); |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| uint32 bpi_memReadCsa16( const uint16* memPtrA ) |
| { |
| return bbs_SIZEOF16( uint16 ); |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |