/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "_cxcore.h"
/****************************************************************************************\
* MinMaxLoc *
\****************************************************************************************/
#define CV_MINMAXLOC_ENTRY( _toggle_, srctype, temptype, cn ) \
temptype min_val, max_val; \
int min_loc = 0, max_loc = 0; \
int x, loc = 0, width = size.width*(cn); \
step /= sizeof(src[0]); \
\
min_val = src[0]; \
min_val = max_val = _toggle_( min_val )
#define CV_MINMAXLOC_EXIT( _fin_cast_macro_ ) \
minLoc->x = min_loc; \
maxLoc->x = max_loc; \
minLoc->y = maxLoc->y = 0; \
*minVal = _fin_cast_macro_(min_val); \
*maxVal = _fin_cast_macro_(max_val); \
return CV_OK
#define ICV_DEF_MINMAXLOC_1D_CASE_COI( _toggle_, temptype, cn ) \
for( x = 0; x < width; x += (cn), loc++ ) \
{ \
temptype val = src[x]; \
val = _toggle_(val); \
\
if( val < min_val ) \
{ \
min_val = val; \
min_loc = loc; \
} \
else if( val > max_val ) \
{ \
max_val = val; \
max_loc = loc; \
} \
}
#define ICV_DEF_MINMAXLOC_FUNC_2D( _toggle_, _fin_cast_macro_, flavor, \
srctype, temptype, extrtype ) \
IPCVAPI_IMPL( CvStatus, \
icvMinMaxIndx_##flavor##_C1R,( const srctype* src, int step, CvSize size, \
extrtype* minVal, extrtype* maxVal, CvPoint* minLoc, CvPoint* maxLoc ), \
(src, step, size, minVal, maxVal, minLoc, maxLoc) ) \
{ \
CV_MINMAXLOC_ENTRY( _toggle_, srctype, temptype, 1 ); \
\
for( ; size.height--; src += step ) \
{ \
ICV_DEF_MINMAXLOC_1D_CASE_COI( _toggle_, temptype, 1 ); \
} \
\
CV_MINMAXLOC_EXIT( _fin_cast_macro_ ); \
}
#define ICV_DEF_MINMAXLOC_FUNC_2D_COI( _toggle_, _fin_cast_macro_, flavor, \
srctype, temptype, extrtype ) \
static CvStatus CV_STDCALL \
icvMinMaxIndx_##flavor##_CnCR( const srctype* src, int step, \
CvSize size, int cn, int coi, \
extrtype* minVal, extrtype* maxVal, \
CvPoint* minLoc, CvPoint* maxLoc ) \
{ \
(src) += coi - 1; \
CV_MINMAXLOC_ENTRY( _toggle_, srctype, temptype, cn ); \
\
for( ; size.height--; src += step ) \
{ \
ICV_DEF_MINMAXLOC_1D_CASE_COI( _toggle_, temptype, cn ); \
} \
\
CV_MINMAXLOC_EXIT( _fin_cast_macro_ ); \
}
#define ICV_DEF_MINMAXLOC_ALL_INT( flavor, srctype, \
_fin_cast_macro_, extrtype ) \
ICV_DEF_MINMAXLOC_FUNC_2D( CV_NOP, _fin_cast_macro_, flavor,\
srctype, int, extrtype ) \
ICV_DEF_MINMAXLOC_FUNC_2D_COI( CV_NOP, _fin_cast_macro_, \
flavor, srctype, int, extrtype )
CV_INLINE float minmax_to_float( int val )
{
Cv32suf v;
v.i = CV_TOGGLE_FLT(val);
return v.f;
}
CV_INLINE double minmax_to_double( int64 val )
{
Cv64suf v;
v.i = CV_TOGGLE_DBL(val);
return v.f;
}
#define ICV_DEF_MINMAXLOC_ALL_FLT( flavor, srctype, _toggle_, \
_fin_cast_macro_, extrtype ) \
\
ICV_DEF_MINMAXLOC_FUNC_2D( _toggle_, _fin_cast_macro_, flavor, \
srctype, srctype, extrtype ) \
ICV_DEF_MINMAXLOC_FUNC_2D_COI( _toggle_, _fin_cast_macro_, flavor, \
srctype, srctype, extrtype )
ICV_DEF_MINMAXLOC_ALL_INT( 8u, uchar, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_ALL_INT( 16u, ushort, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_ALL_INT( 16s, short, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_ALL_INT( 32s, int, CV_CAST_64F, double )
ICV_DEF_MINMAXLOC_ALL_FLT( 32f, int, CV_TOGGLE_FLT, minmax_to_float, float )
ICV_DEF_MINMAXLOC_ALL_FLT( 64f, int64, CV_TOGGLE_DBL, minmax_to_double, double )
/****************************************************************************************\
* MinMaxLoc with mask *
\****************************************************************************************/
#define CV_MINMAXLOC_MASK_ENTRY( _toggle_, srctype, temptype, cn ) \
temptype min_val = 0, max_val = 0; \
int min_loc = -1, max_loc = -1; \
int x = 0, y, loc = 0, width = size.width; \
step /= sizeof(src[0]); \
\
if( width*(cn) == step && width == maskStep ) \
{ \
width *= size.height; \
size.height = 1; \
} \
\
for( y = 0; y < size.height; y++, src += step, \
mask += maskStep ) \
{ \
for( x = 0; x < width; x++, loc++ ) \
if( mask[x] != 0 ) \
{ \
min_loc = max_loc = loc; \
min_val = (src)[x*(cn)]; \
min_val = max_val = _toggle_( min_val ); \
goto stop_scan; \
} \
} \
\
stop_scan:;
#define ICV_DEF_MINMAXLOC_1D_MASK_CASE_COI( _toggle_, temptype, cn ) \
for( ; x < width; x++, loc++ ) \
{ \
temptype val = src[x*(cn)]; \
int m = mask[x] != 0; \
val = _toggle_(val); \
\
if( val < min_val && m ) \
{ \
min_val = val; \
min_loc = loc; \
} \
else if( val > max_val && m ) \
{ \
max_val = val; \
max_loc = loc; \
} \
}
#define ICV_DEF_MINMAXLOC_MASK_FUNC_2D( _toggle_, _fin_cast_macro_, flavor, \
srctype, temptype, extrtype ) \
IPCVAPI_IMPL( CvStatus, \
icvMinMaxIndx_##flavor##_C1MR,( const srctype* src, int step, \
const uchar* mask, int maskStep, CvSize size, \
extrtype* minVal, extrtype* maxVal, CvPoint* minLoc, CvPoint* maxLoc ), \
( src, step, mask, maskStep, size, minVal, maxVal, minLoc, maxLoc) ) \
{ \
CV_MINMAXLOC_MASK_ENTRY( _toggle_, srctype, temptype, 1 ); \
\
for( ; y < size.height; y++, src += step, mask += maskStep ) \
{ \
ICV_DEF_MINMAXLOC_1D_MASK_CASE_COI( _toggle_, temptype, 1 ) \
x = 0; \
} \
\
CV_MINMAXLOC_EXIT( _fin_cast_macro_ ); \
}
#define ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( _toggle_, _fin_cast_macro_, \
flavor, srctype, temptype, extrtype ) \
static CvStatus CV_STDCALL \
icvMinMaxIndx_##flavor##_CnCMR( const srctype* src, int step, \
const uchar* mask, int maskStep, CvSize size, int cn, int coi, \
extrtype* minVal, extrtype* maxVal, CvPoint* minLoc, CvPoint* maxLoc ) \
{ \
(src) += coi - 1; \
CV_MINMAXLOC_MASK_ENTRY( _toggle_, srctype, temptype, cn ); \
\
for( ; y < size.height; y++, src += step, mask += maskStep ) \
{ \
ICV_DEF_MINMAXLOC_1D_MASK_CASE_COI( _toggle_, temptype, cn ) \
x = 0; \
} \
\
CV_MINMAXLOC_EXIT( _fin_cast_macro_ ); \
}
#define ICV_DEF_MINMAXLOC_MASK_ALL_INT( flavor, srctype, \
_fin_cast_macro_, extrtype ) \
ICV_DEF_MINMAXLOC_MASK_FUNC_2D( CV_NOP, _fin_cast_macro_, flavor, \
srctype, int, extrtype ) \
ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( CV_NOP, _fin_cast_macro_, flavor, \
srctype, int, extrtype )
#define ICV_DEF_MINMAXLOC_MASK_ALL_FLT( flavor, srctype, _toggle_, \
_fin_cast_macro_, extrtype ) \
ICV_DEF_MINMAXLOC_MASK_FUNC_2D( _toggle_, _fin_cast_macro_, flavor, \
srctype, srctype, extrtype ) \
ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( _toggle_, _fin_cast_macro_, flavor, \
srctype, srctype, extrtype )
ICV_DEF_MINMAXLOC_MASK_ALL_INT( 8u, uchar, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_MASK_ALL_INT( 16u, ushort, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_MASK_ALL_INT( 16s, short, CV_CAST_32F, float )
ICV_DEF_MINMAXLOC_MASK_ALL_INT( 32s, int, CV_CAST_64F, double )
ICV_DEF_MINMAXLOC_MASK_ALL_FLT( 32f, int, CV_TOGGLE_FLT, minmax_to_float, float )
ICV_DEF_MINMAXLOC_MASK_ALL_FLT( 64f, int64, CV_TOGGLE_DBL, minmax_to_double, double )
#define icvMinMaxIndx_8s_C1R 0
#define icvMinMaxIndx_8s_CnCR 0
#define icvMinMaxIndx_8s_C1MR 0
#define icvMinMaxIndx_8s_CnCMR 0
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, C1R )
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, CnCR )
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, C1MR )
CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, CnCMR )
CV_IMPL void
cvMinMaxLoc( const void* img, double* _minVal, double* _maxVal,
CvPoint* _minLoc, CvPoint* _maxLoc, const void* mask )
{
static CvFuncTable minmax_tab, minmaxcoi_tab;
static CvFuncTable minmaxmask_tab, minmaxmaskcoi_tab;
static int inittab = 0;
CV_FUNCNAME("cvMinMaxLoc");
__BEGIN__;
int type, depth, cn, coi = 0;
int mat_step, mask_step = 0, cont_flag;
CvSize size;
CvMat stub, maskstub, *mat = (CvMat*)img, *matmask = (CvMat*)mask;
CvPoint minloc, maxloc;
double minv = 0, maxv = 0;
float minvf = 0.f, maxvf = 0.f;
void *pmin = &minvf, *pmax = &maxvf;
if( !inittab )
{
icvInitMinMaxIndxC1RTable( &minmax_tab );
icvInitMinMaxIndxCnCRTable( &minmaxcoi_tab );
icvInitMinMaxIndxC1MRTable( &minmaxmask_tab );
icvInitMinMaxIndxCnCMRTable( &minmaxmaskcoi_tab );
inittab = 1;
}
if( !CV_IS_MAT(mat) )
CV_CALL( mat = cvGetMat( mat, &stub, &coi ));
type = CV_MAT_TYPE( mat->type );
depth = CV_MAT_DEPTH( type );
cn = CV_MAT_CN( type );
size = cvGetMatSize( mat );
if( cn > 1 && coi == 0 )
CV_ERROR( CV_StsBadArg, "" );
if( depth == CV_32S || depth == CV_64F )
pmin = &minv, pmax = &maxv;
mat_step = mat->step;
cont_flag = mat->type;
if( mask )
{
CV_CALL( matmask = cvGetMat( matmask, &maskstub ));
if( !CV_IS_MASK_ARR( matmask ))
CV_ERROR( CV_StsBadMask, "" );
if( !CV_ARE_SIZES_EQ( mat, matmask ))
CV_ERROR( CV_StsUnmatchedSizes, "" );
mask_step = matmask->step;
cont_flag &= matmask->type;
}
if( CV_IS_MAT_CONT(cont_flag) )
{
size.width *= size.height;
size.height = 1;
}
if( size.height == 1 )
mat_step = mask_step = CV_STUB_STEP;
if( !mask )
{
if( CV_MAT_CN(type) == 1 || coi == 0 )
{
CvFunc2D_1A4P func = (CvFunc2D_1A4P)(minmax_tab.fn_2d[depth]);
if( !func )
CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
IPPI_CALL( func( mat->data.ptr, mat_step, size,
pmin, pmax, &minloc, &maxloc ));
}
else
{
CvFunc2DnC_1A4P func = (CvFunc2DnC_1A4P)(minmaxcoi_tab.fn_2d[depth]);
if( !func )
CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
IPPI_CALL( func( mat->data.ptr, mat_step, size, cn, coi,
pmin, pmax, &minloc, &maxloc ));
}
}
else
{
if( CV_MAT_CN(type) == 1 || coi == 0 )
{
CvFunc2D_2A4P func = (CvFunc2D_2A4P)(minmaxmask_tab.fn_2d[depth]);
if( !func )
CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
IPPI_CALL( func( mat->data.ptr, mat_step, matmask->data.ptr,
mask_step, size,
pmin, pmax, &minloc, &maxloc ));
}
else
{
CvFunc2DnC_2A4P func = (CvFunc2DnC_2A4P)(minmaxmaskcoi_tab.fn_2d[depth]);
if( !func )
CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
IPPI_CALL( func( mat->data.ptr, mat_step,
matmask->data.ptr, mask_step, size, cn, coi,
pmin, pmax, &minloc, &maxloc ));
}
}
if( matmask || _minLoc || _maxLoc )
{
if( minloc.x >= mat->cols )
{
minloc.y = minloc.x / mat->cols;
minloc.x -= minloc.y * mat->cols;
}
if( maxloc.x >= mat->cols )
{
maxloc.y = maxloc.x / mat->cols;
maxloc.x -= maxloc.y * mat->cols;
}
if( matmask && ((unsigned)minloc.x >= (unsigned)mat->cols ||
(unsigned)minloc.y >= (unsigned)mat->rows ||
matmask->data.ptr[minloc.y*matmask->step + minloc.x] == 0 ||
(unsigned)maxloc.x >= (unsigned)mat->cols ||
(unsigned)maxloc.y >= (unsigned)mat->rows ||
matmask->data.ptr[maxloc.y*matmask->step + maxloc.x] == 0) )
{
minloc.x = minloc.y = maxloc.x = maxloc.y = -1;
minv = maxv = minvf = maxvf = 0;
}
if( _minLoc )
*_minLoc = minloc;
if( _maxLoc )
*_maxLoc = maxloc;
}
if( depth != CV_32S && depth != CV_64F )
{
minv = minvf;
maxv = maxvf;
}
if( _minVal )
*_minVal = minv;
if( _maxVal )
*_maxVal = maxv;
__END__;
}
/* End of file */