/*
* 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/LocalScanner.h"
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
/* */
/* ---- \ghd{ auxiliary functions } ---------------------------------------- */
/* */
/* ========================================================================= */
/* ------------------------------------------------------------------------- */
/** allocates arays */
void bbf_LocalScanner_alloc( struct bbs_Context* cpA,
struct bbf_LocalScanner* ptrA,
struct bbs_MemTbl* mtpA )
{
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 );
/* 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;
if( ptrA->minScaleExpE > 0 )
{
/* allocate working image */
bbs_UInt8Arr_create( cpA, &ptrA->workImageBufferE, ( woL >> 1 ) * ( hoL >> 1 ), espL );
bbs_UInt8Arr_fill( cpA, &ptrA->workImageBufferE, 0 );
}
/* allocate bit image */
bim_UInt32Image_create( cpA, &ptrA->bitImageE, woL, ( hoL >> 5 ) + ( ( ( hoL & 0x1F ) != 0 ) ? 1 : 0 ), espL );
bim_UInt32Image_setAllPixels( cpA, &ptrA->bitImageE, 0, 0 );
/* allocate patch buffer */
bbs_UInt32Arr_create( cpA, &ptrA->patchBufferE, ptrA->bitImageE.widthE, espL );
bbs_UInt32Arr_fill( cpA, &ptrA->patchBufferE, 0 );
/* allocate table */
bim_UInt32Image_create( cpA, &ptrA->satE, woL + pwoL, pwoL + 1, sspL );
}
/* ------------------------------------------------------------------------- */
/** downscales original image by factor 2 */
void bbf_LocalScanner_downscale0( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA )
{
int32 w0L = ptrA->origWidthE;
int32 h0L = ptrA->origHeightE;
int32 w1L = ( w0L - ptrA->xOffE ) >> 1;
int32 h1L = ( h0L - ptrA->yOffE ) >> 1;
const uint8* iArrL = ptrA->origImagePtrE + ptrA->xOffE + ptrA->yOffE * w0L;
uint8* oArrL = ptrA->workImageBufferE.arrPtrE;
int32 iL, jL;
int32 kL = 0;
bbs_UInt8Arr_size( cpA, &ptrA->workImageBufferE, w1L * h1L );
ptrA->workImagePtrE = ptrA->workImageBufferE.arrPtrE;
ptrA->workWidthE = w1L;
ptrA->workHeightE = h1L;
for( jL = 0; jL < h1L; jL++ )
{
for( iL = 0; iL < w1L; iL++ )
{
int32 idxL = jL * 2 * w0L + iL * 2;
oArrL[ kL++ ] = ( ( uint32 )iArrL[ idxL ] +
iArrL[ idxL + 1 ] +
iArrL[ idxL + w0L ] +
iArrL[ idxL + w0L + 1 ] + 2 ) >> 2;
}
}
}
/* ------------------------------------------------------------------------- */
/** downscales work image by factor 2 */
void bbf_LocalScanner_downscale1( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA )
{
int32 w0L = ptrA->workWidthE;
int32 h0L = ptrA->workHeightE;
int32 w1L = w0L >> 1;
int32 h1L = h0L >> 1;
uint8* arrL = ptrA->workImageBufferE.arrPtrE;
int32 iL, jL;
int32 kL = 0;
for( jL = 0; jL < h1L; jL++ )
{
for( iL = 0; iL < w1L; iL++ )
{
int32 idxL = jL * 2 * w0L + iL * 2;
arrL[ kL++ ] = ( ( uint32 )arrL[ idxL ] +
arrL[ idxL + 1 ] +
arrL[ idxL + w0L ] +
arrL[ idxL + w0L + 1 ] + 2 ) >> 2;
}
}
ptrA->workWidthE = w1L;
ptrA->workHeightE = h1L;
}
/* ------------------------------------------------------------------------- */
/** downscales by factor 2 */
void bbf_LocalScanner_downscale( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA )
{
uint32 iL;
if( ptrA->scaleExpE > 0 ) bbf_LocalScanner_downscale0( cpA, ptrA );
for( iL = 1; iL < ptrA->scaleExpE; iL++ ) bbf_LocalScanner_downscale1( cpA, ptrA );
}
/* ------------------------------------------------------------------------- */
/** computes bit image */
void bbf_LocalScanner_createBitImage( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA )
{
bbs_DEF_fNameL( "void bbf_LocalScanner_createBitImage( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA )" )
uint32 iL, jL;
uint32 proL = ptrA->bitParamE.outerRadiusE;
uint32 priL = ptrA->bitParamE.innerRadiusE;
uint32 pwoL = ( proL << 1 ) + 1;
uint32 pwiL = ( priL << 1 ) + 1;
/* areas of inner and outer rectangles */
uint32 poAreaL = pwoL * pwoL;
uint32 piAreaL = pwiL * pwiL;
uint32 wL, hL; /* input image size */
uint32 wsL, hsL;
uint32* satL;
uint32 satSizeL;
uint32 swi1L = 0; /* writing index */
uint32 swi2L = 0; /* writing index */
uint32 sriL = 0; /* reading index */
uint32 siL[ 8 ];
uint32 bitMaskL;
uint32* bitRowL;
if( proL <= priL )
{
bbs_ERROR1( "%s:\n outer radius <= inner radius", fNameL );
return;
}
/* input image size */
wL = ptrA->workWidthE;
hL = ptrA->workHeightE;
if( wL <= pwoL || hL <= pwoL )
{
bbs_ERROR1( "%s:\n image is too small", fNameL );
return;
}
ptrA->currentWidthE = wL;
ptrA->currentHeightE = hL;
/* reset scan region */
ptrA->workScanRegionE = bts_Int16Rect_create( 0, 0, ptrA->currentWidthE, ptrA->currentHeightE );
/* initialize bit image */
bim_UInt32Image_size( cpA, &ptrA->bitImageE, wL, ( hL >> 5 ) + ( ( ( hL & 0x1F ) != 0 ) ? 1 : 0 ) );
bim_UInt32Image_setAllPixels( cpA, &ptrA->bitImageE, 0, 0 );
bitMaskL = 1;
bitRowL = ( uint32* )ptrA->bitImageE.arrE.arrPtrE;
/* width of table */
wsL = wL + pwoL;
/* height of table */
hsL = pwoL + 1;
bim_UInt32Image_size( cpA, &ptrA->satE, wsL, hsL );
satL = ( uint32* )ptrA->satE.arrE.arrPtrE;
satSizeL = ptrA->satE.arrE.sizeE;
/* compute table and bit image */
for( iL = wsL * ( proL + 1 ); iL > 0; iL-- ) satL[ swi1L++ ] = 0;
swi2L = swi1L - wsL;
for( jL = 0; jL < hL + proL; jL++ )
{
if( jL < hL ) /* rescale area */
{
const uint8* arr0L = &ptrA->workImagePtrE[ jL * wL ];
uint32 hSumL = 0;
for( iL = 0; iL <= proL; iL++ ) satL[ swi1L++ ] = 0;
swi2L += iL;
for( iL = 0; iL < wL; iL++ ) satL[ swi1L++ ] = ( hSumL += arr0L[ iL ] ) + satL[ swi2L++ ];
for( iL = 0; iL < proL; iL++ ) satL[ swi1L++ ] = hSumL + satL[ 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 < wL; 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 += wL;
bitMaskL = 1;
}
}
}
}
/* -------------------------------------------------------------------------- */
/** inilialize patch buffer */
void bbf_LocalScanner_initPatchBuffer( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA )
{
int32 ybL = ptrA->workScanRegionE.y1E >> 5;
int32 yoL = ptrA->workScanRegionE.y1E & 0x1F;
int32 xbL = ptrA->workScanRegionE.x1E;
uint32 wsrWidthL = ptrA->workScanRegionE.x2E - ptrA->workScanRegionE.x1E;
bbs_UInt32Arr_size( cpA, &ptrA->patchBufferE, ptrA->bitImageE.widthE );
if( yoL == 0 )
{
bbs_memcpy32( ptrA->patchBufferE.arrPtrE + xbL,
ptrA->bitImageE.arrE.arrPtrE + ybL * ptrA->bitImageE.widthE + xbL,
wsrWidthL );
}
else if( ybL == ( int32 )ptrA->bitImageE.heightE - 1 )
{
uint32* dstL = ptrA->patchBufferE.arrPtrE + xbL;
const uint32* srcL = ptrA->bitImageE.arrE.arrPtrE + ybL * ptrA->bitImageE.widthE + xbL;
uint32 iL;
for( iL = 0; iL < wsrWidthL; iL++ ) dstL[ iL ] = srcL[ iL ] >> yoL;
}
else
{
uint32* dstL = ptrA->patchBufferE.arrPtrE + xbL;
const uint32* src0L = ptrA->bitImageE.arrE.arrPtrE + ybL * ptrA->bitImageE.widthE + xbL;
const uint32* src1L = src0L + ptrA->bitImageE.widthE;
uint32 iL;
uint32 slL = 32 - yoL;
for( iL = 0; iL < wsrWidthL; iL++ ) dstL[ iL ] = ( src0L[ iL ] >> yoL ) | ( src1L[ iL ] << slL );
}
}
/* ------------------------------------------------------------------------- */
/* sets work scan region from original scan region according to scale exponent */
void bbf_LocalScanner_setWorkScanRegion( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA )
{
int32 xMinL = ptrA->origScanRegionE.x1E >> ptrA->scaleExpE;
int32 yMinL = ptrA->origScanRegionE.y1E >> ptrA->scaleExpE;
int32 xMaxL = ptrA->origScanRegionE.x2E >> ptrA->scaleExpE;
int32 yMaxL = ptrA->origScanRegionE.y2E >> ptrA->scaleExpE;
ptrA->workScanRegionE.x1E = ( xMinL < 0 ) ? 0 : xMinL;
ptrA->workScanRegionE.y1E = ( yMinL < 0 ) ? 0 : yMinL;
ptrA->workScanRegionE.x2E = ( xMaxL > ( int32 )ptrA->currentWidthE ) ? ptrA->currentWidthE : xMaxL;
ptrA->workScanRegionE.y2E = ( yMaxL > ( int32 )ptrA->currentHeightE ) ? ptrA->currentHeightE : yMaxL;
}
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
/* */
/* ---- \ghd{ constructor / destructor } ----------------------------------- */
/* */
/* ========================================================================= */
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_init( struct bbs_Context* cpA,
struct bbf_LocalScanner* ptrA )
{
ptrA->xE = 0;
ptrA->yE = 0;
ptrA->xOffE = 0;
ptrA->yOffE = 0;
ptrA->currentWidthE = 0;
ptrA->currentHeightE = 0;
ptrA->workWidthE = 0;
ptrA->workHeightE = 0;
ptrA->workImagePtrE = NULL;
ptrA->origWidthE = 0;
ptrA->origHeightE = 0;
ptrA->origImagePtrE = NULL;
bbf_BitParam_init( cpA, &ptrA->bitParamE );
bbs_UInt8Arr_init( cpA, &ptrA->workImageBufferE );
bim_UInt32Image_init( cpA, &ptrA->satE );
bim_UInt32Image_init( cpA, &ptrA->bitImageE );
bbs_UInt32Arr_init( cpA, &ptrA->patchBufferE );
bts_Int16Rect_init( cpA, &ptrA->origScanRegionE );
bts_Int16Rect_init( cpA, &ptrA->workScanRegionE );
ptrA->patchWidthE = 0;
ptrA->patchHeightE = 0;
ptrA->scaleExpE = 0;
ptrA->maxImageWidthE = 0;
ptrA->maxImageHeightE = 0;
ptrA->minScaleExpE = 0;
ptrA->maxRadiusE = 0;
}
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_exit( struct bbs_Context* cpA,
struct bbf_LocalScanner* ptrA )
{
ptrA->xE = 0;
ptrA->yE = 0;
ptrA->xOffE = 0;
ptrA->yOffE = 0;
ptrA->currentWidthE = 0;
ptrA->currentHeightE = 0;
ptrA->workWidthE = 0;
ptrA->workHeightE = 0;
ptrA->workImagePtrE = NULL;
ptrA->origWidthE = 0;
ptrA->origHeightE = 0;
ptrA->origImagePtrE = NULL;
bbf_BitParam_exit( cpA, &ptrA->bitParamE );
bbs_UInt8Arr_exit( cpA, &ptrA->workImageBufferE );
bim_UInt32Image_exit( cpA, &ptrA->satE );
bim_UInt32Image_exit( cpA, &ptrA->bitImageE );
bbs_UInt32Arr_exit( cpA, &ptrA->patchBufferE );
bts_Int16Rect_exit( cpA, &ptrA->origScanRegionE );
bts_Int16Rect_exit( cpA, &ptrA->workScanRegionE );
ptrA->patchWidthE = 0;
ptrA->patchHeightE = 0;
ptrA->scaleExpE = 0;
ptrA->maxImageWidthE = 0;
ptrA->maxImageHeightE = 0;
ptrA->minScaleExpE = 0;
ptrA->maxRadiusE = 0;
}
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
/* */
/* ---- \ghd{ operators } -------------------------------------------------- */
/* */
/* ========================================================================= */
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_copy( struct bbs_Context* cpA,
struct bbf_LocalScanner* ptrA,
const struct bbf_LocalScanner* srcPtrA )
{
bbs_ERROR0( "bbf_LocalScanner_copy:\n Function is not available" );
}
/* ------------------------------------------------------------------------- */
flag bbf_LocalScanner_equal( struct bbs_Context* cpA,
const struct bbf_LocalScanner* ptrA,
const struct bbf_LocalScanner* srcPtrA )
{
bbs_ERROR0( "bbf_LocalScanner_equal:\n Function is not available" );
return FALSE;
}
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
/* */
/* ---- \ghd{ query functions } -------------------------------------------- */
/* */
/* ========================================================================= */
/* ------------------------------------------------------------------------- */
uint32 bbf_LocalScanner_positions( const struct bbf_LocalScanner* ptrA )
{
int32 wL = ptrA->workScanRegionE.x2E - ptrA->workScanRegionE.x1E - ptrA->patchWidthE;
int32 hL = ptrA->workScanRegionE.y2E - ptrA->workScanRegionE.y1E - ptrA->patchHeightE;
return ( ( wL < 0 ) ? 0 : wL ) * ( ( hL < 0 ) ? 0 : hL );
}
/* ------------------------------------------------------------------------- */
uint32 bbf_LocalScanner_scanIndex( const struct bbf_LocalScanner* ptrA )
{
int32 wL = ptrA->workScanRegionE.x2E - ptrA->workScanRegionE.x1E - ptrA->patchWidthE;
return ( ptrA->yE - ptrA->workScanRegionE.y1E ) * wL + ( ptrA->xE - ptrA->workScanRegionE.x1E );
}
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_pos( const struct bbf_LocalScanner* ptrA, int32* xPtrA, int32* yPtrA )
{
*xPtrA = ( ( ptrA->xE << ptrA->scaleExpE ) + ptrA->xOffE ) << 16;
*yPtrA = ( ( ptrA->yE << ptrA->scaleExpE ) + ptrA->yOffE ) << 16;
}
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_idxPos( const struct bbf_LocalScanner* ptrA, uint32 scanIndexA, int32* xPtrA, int32* yPtrA )
{
uint32 wL = ptrA->workScanRegionE.x2E - ptrA->workScanRegionE.x1E - ptrA->patchWidthE;
int32 xL = ( scanIndexA % wL ) + ptrA->workScanRegionE.x1E;
int32 yL = ( scanIndexA / wL ) + ptrA->workScanRegionE.y1E;
*xPtrA = ( ( xL << ptrA->scaleExpE ) + ptrA->xOffE ) << 16;
*yPtrA = ( ( yL << ptrA->scaleExpE ) + ptrA->yOffE ) << 16;
}
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
/* */
/* ---- \ghd{ modify functions } ------------------------------------------- */
/* */
/* ========================================================================= */
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_create( struct bbs_Context* cpA,
struct bbf_LocalScanner* ptrA,
uint32 patchWidthA,
uint32 patchHeightA,
uint32 scaleExpA,
uint32 maxImageWidthA,
uint32 maxImageHeightA,
uint32 minScaleExpA,
uint32 maxRadiusA,
struct bbs_MemTbl* mtpA )
{
ptrA->patchWidthE = patchWidthA;
ptrA->patchHeightE = patchHeightA;
ptrA->scaleExpE = scaleExpA;
ptrA->maxImageWidthE = maxImageWidthA;
ptrA->maxImageHeightE = maxImageHeightA;
ptrA->minScaleExpE = minScaleExpA;
ptrA->maxRadiusE = maxRadiusA;
bbf_LocalScanner_alloc( cpA, ptrA, mtpA );
}
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_bitParam( struct bbs_Context* cpA,
struct bbf_LocalScanner* ptrA,
const struct bbf_BitParam* bitParamPtrA )
{
if( !bbf_BitParam_equal( cpA, &ptrA->bitParamE, bitParamPtrA ) )
{
bbf_BitParam_copy( cpA, &ptrA->bitParamE, bitParamPtrA );
bbf_LocalScanner_createBitImage( cpA, ptrA );
}
bbf_LocalScanner_resetScan( cpA, ptrA );
}
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_origScanRegion( struct bbs_Context* cpA,
struct bbf_LocalScanner* ptrA,
const struct bts_Int16Rect* scanRegionPtrA )
{
ptrA->origScanRegionE = *scanRegionPtrA;
bbf_LocalScanner_setWorkScanRegion( cpA, ptrA );
bbf_LocalScanner_resetScan( cpA, ptrA );
}
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
/* */
/* ---- \ghd{ I/O } -------------------------------------------------------- */
/* */
/* ========================================================================= */
/* ------------------------------------------------------------------------- */
uint32 bbf_LocalScanner_memSize( struct bbs_Context* cpA,
const struct bbf_LocalScanner* ptrA )
{
uint32 memSizeL = bbs_SIZEOF16( uint32 ) +
bbs_SIZEOF16( uint32 ); /* version */
memSizeL += bbs_SIZEOF16( ptrA->patchWidthE );
memSizeL += bbs_SIZEOF16( ptrA->patchHeightE );
memSizeL += bbs_SIZEOF16( ptrA->scaleExpE );
memSizeL += bbs_SIZEOF16( ptrA->maxImageWidthE );
memSizeL += bbs_SIZEOF16( ptrA->maxImageHeightE );
memSizeL += bbs_SIZEOF16( ptrA->minScaleExpE );
memSizeL += bbs_SIZEOF16( ptrA->maxRadiusE );
return memSizeL;
}
/* ------------------------------------------------------------------------- */
uint32 bbf_LocalScanner_memWrite( struct bbs_Context* cpA,
const struct bbf_LocalScanner* ptrA,
uint16* memPtrA )
{
uint32 memSizeL = bbf_LocalScanner_memSize( cpA, ptrA );
memPtrA += bbs_memWrite32( &memSizeL, memPtrA );
memPtrA += bbs_memWriteUInt32( bbf_LOCAL_SCANNER_VERSION, memPtrA );
memPtrA += bbs_memWrite32( &ptrA->patchWidthE, memPtrA );
memPtrA += bbs_memWrite32( &ptrA->patchHeightE, memPtrA );
memPtrA += bbs_memWrite32( &ptrA->scaleExpE, memPtrA );
memPtrA += bbs_memWrite32( &ptrA->maxImageWidthE, memPtrA );
memPtrA += bbs_memWrite32( &ptrA->maxImageHeightE, memPtrA );
memPtrA += bbs_memWrite32( &ptrA->minScaleExpE, memPtrA );
memPtrA += bbs_memWrite32( &ptrA->maxRadiusE, memPtrA );
return memSizeL;
}
/* ------------------------------------------------------------------------- */
uint32 bbf_LocalScanner_memRead( struct bbs_Context* cpA,
struct bbf_LocalScanner* 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_LOCAL_SCANNER_VERSION, memPtrA );
memPtrA += bbs_memRead32( &ptrA->patchWidthE, memPtrA );
memPtrA += bbs_memRead32( &ptrA->patchHeightE, memPtrA );
memPtrA += bbs_memRead32( &ptrA->scaleExpE, memPtrA );
memPtrA += bbs_memRead32( &ptrA->maxImageWidthE, memPtrA );
memPtrA += bbs_memRead32( &ptrA->maxImageHeightE, memPtrA );
memPtrA += bbs_memRead32( &ptrA->minScaleExpE, memPtrA );
memPtrA += bbs_memRead32( &ptrA->maxRadiusE, memPtrA );
if( memSizeL != bbf_LocalScanner_memSize( cpA, ptrA ) )
{
bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bbf_LocalScanner_memRead( struct bem_ScanGradientMove* ptrA, const uint16* memPtrA ):\n"
"size mismatch" );
return 0;
}
if( bbs_Context_error( cpA ) ) return 0;
/* allocate arrays */
bbf_LocalScanner_alloc( cpA, ptrA, mtpA );
if( bbs_Context_error( cpA ) ) return 0;
return memSizeL;
}
/* ------------------------------------------------------------------------- */
/* ========================================================================= */
/* */
/* ---- \ghd{ exec functions } --------------------------------------------- */
/* */
/* ========================================================================= */
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_resetScan( struct bbs_Context* cpA,
struct bbf_LocalScanner* ptrA )
{
ptrA->xE = ptrA->workScanRegionE.x1E;
ptrA->yE = ptrA->workScanRegionE.y1E;
bbf_LocalScanner_initPatchBuffer( cpA, ptrA );
}
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_assign( struct bbs_Context* cpA,
struct bbf_LocalScanner* ptrA,
const uint8* imagePtrA,
uint32 imageWidthA,
uint32 imageHeightA,
const struct bbf_BitParam* paramPtrA )
{
if( ptrA->scaleExpE == 0 )
{
ptrA->workImagePtrE = imagePtrA;
ptrA->workWidthE = imageWidthA;
ptrA->workHeightE = imageHeightA;
}
else
{
ptrA->origImagePtrE = imagePtrA;
ptrA->origWidthE = imageWidthA;
ptrA->origHeightE = imageHeightA;
}
ptrA->bitParamE = *paramPtrA;
ptrA->xOffE = 0;
ptrA->yOffE = 0;
ptrA->origScanRegionE = bts_Int16Rect_create( 0, 0, imageWidthA, imageHeightA );
bbf_LocalScanner_downscale( cpA, ptrA );
bbf_LocalScanner_createBitImage( cpA, ptrA );
bbf_LocalScanner_resetScan( cpA, ptrA );
}
/* ------------------------------------------------------------------------- */
const uint32* bbf_LocalScanner_getPatch( const struct bbf_LocalScanner* ptrA )
{
return ptrA->patchBufferE.arrPtrE + ptrA->xE;
}
/* ------------------------------------------------------------------------- */
flag bbf_LocalScanner_next( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA )
{
if( ( ptrA->xE + 1 ) < ptrA->workScanRegionE.x2E - ( int32 )ptrA->patchWidthE )
{
ptrA->xE++;
return TRUE;
}
if( ( ptrA->yE + 1 ) >= ptrA->workScanRegionE.y2E - ( int32 )ptrA->patchHeightE ) return FALSE;
ptrA->xE = ptrA->workScanRegionE.x1E;
ptrA->yE++;
{
uint32 offL = ( ptrA->yE & 0x1F );
uint32 rowL = ( ptrA->yE >> 5 ) + ( offL > 0 ? 1 : 0 );
uint32 widthL = ptrA->bitImageE.widthE;
uint32 sizeL = ptrA->workScanRegionE.x2E - ptrA->workScanRegionE.x1E;
uint32* dstL = ( uint32* )ptrA->patchBufferE.arrPtrE + ptrA->xE;
uint32 iL;
if( rowL < ptrA->bitImageE.heightE )
{
uint32* srcL = ptrA->bitImageE.arrE.arrPtrE + rowL * widthL + ptrA->xE;
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_LocalScanner_goToXY( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA, int32 xA, int32 yA )
{
bbs_DEF_fNameL( "void bbf_LocalScanner_goToXY( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA, int32 xA, int32 yA )" )
if( xA < ptrA->workScanRegionE.x1E || xA >= ptrA->workScanRegionE.x2E - ( int32 )ptrA->patchWidthE )
{
bbs_ERROR1( "%s:\nxA out of range", fNameL );
return;
}
ptrA->xE = xA;
if( ptrA->yE == yA ) return;
if( yA < ptrA->workScanRegionE.y1E || yA >= ptrA->workScanRegionE.y2E - ( int32 )ptrA->patchHeightE )
{
bbs_ERROR1( "%s:\nyA out of range", fNameL );
return;
}
ptrA->yE = yA;
{
uint32 offL = ( ptrA->yE & 0x1F );
uint32 rowL = ( ptrA->yE >> 5 ) + ( offL > 0 ? 1 : 0 );
uint32 sizeL = ptrA->workScanRegionE.x2E - ptrA->workScanRegionE.x1E;
uint32 imgWidthL = ptrA->bitImageE.widthE;
uint32 imgOffsL = ptrA->workScanRegionE.x1E;
uint32* dstL = ptrA->patchBufferE.arrPtrE + imgOffsL;
uint32 iL;
if( rowL < ptrA->bitImageE.heightE )
{
if( offL > 0 )
{
uint32* src1L = ptrA->bitImageE.arrE.arrPtrE + rowL * imgWidthL + imgOffsL;
uint32* src0L = src1L - imgWidthL;
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 * imgWidthL + imgOffsL, sizeL );
}
}
else
{
uint32* srcL = ptrA->bitImageE.arrE.arrPtrE + ( rowL - 1 ) * imgWidthL + imgOffsL;
for( iL = 0; iL < sizeL; iL++ ) dstL[ iL ] = srcL[ iL ] >> offL;
}
}
}
/* ------------------------------------------------------------------------- */
void bbf_LocalScanner_goToIndex( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA, uint32 scanIndexA )
{
uint32 wL = ptrA->workScanRegionE.x2E - ptrA->workScanRegionE.x1E - ptrA->patchWidthE;
bbf_LocalScanner_goToXY( cpA, ptrA,
( scanIndexA % wL ) + ptrA->workScanRegionE.x1E,
( scanIndexA / wL ) + ptrA->workScanRegionE.y1E );
}
/* ------------------------------------------------------------------------- */
flag bbf_LocalScanner_nextOffset( struct bbs_Context* cpA, struct bbf_LocalScanner* ptrA )
{
int32 maxL = ( 1 << ptrA->scaleExpE );
if( ptrA->yOffE == maxL ) return FALSE;
ptrA->xOffE++;
if( ptrA->xOffE == maxL )
{
ptrA->xOffE = 0;
ptrA->yOffE++;
if( ptrA->yOffE == maxL ) return FALSE;
}
bbf_LocalScanner_downscale( cpA, ptrA );
bbf_LocalScanner_createBitImage( cpA, ptrA );
bbf_LocalScanner_setWorkScanRegion( cpA, ptrA );
bbf_LocalScanner_resetScan( cpA, ptrA );
return TRUE;
}
/* ------------------------------------------------------------------------- */
/* ========================================================================= */