1 /*M/////////////////////////////////////////////////////////////////////////////////////// 2 // 3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. 4 // 5 // By downloading, copying, installing or using the software you agree to this license. 6 // If you do not agree to this license, do not download, install, 7 // copy or use the software. 8 // 9 // 10 // Intel License Agreement 11 // For Open Source Computer Vision Library 12 // 13 // Copyright (C) 2000, Intel Corporation, all rights reserved. 14 // Third party copyrights are property of their respective owners. 15 // 16 // Redistribution and use in source and binary forms, with or without modification, 17 // are permitted provided that the following conditions are met: 18 // 19 // * Redistribution's of source code must retain the above copyright notice, 20 // this list of conditions and the following disclaimer. 21 // 22 // * Redistribution's in binary form must reproduce the above copyright notice, 23 // this list of conditions and the following disclaimer in the documentation 24 // and/or other materials provided with the distribution. 25 // 26 // * The name of Intel Corporation may not be used to endorse or promote products 27 // derived from this software without specific prior written permission. 28 // 29 // This software is provided by the copyright holders and contributors "as is" and 30 // any express or implied warranties, including, but not limited to, the implied 31 // warranties of merchantability and fitness for a particular purpose are disclaimed. 32 // In no event shall the Intel Corporation or contributors be liable for any direct, 33 // indirect, incidental, special, exemplary, or consequential damages 34 // (including, but not limited to, procurement of substitute goods or services; 35 // loss of use, data, or profits; or business interruption) however caused 36 // and on any theory of liability, whether in contract, strict liability, 37 // or tort (including negligence or otherwise) arising in any way out of 38 // the use of this software, even if advised of the possibility of such damage. 39 // 40 //M*/ 41 42 #include "_cxcore.h" 43 44 /****************************************************************************************\ 45 * MinMaxLoc * 46 \****************************************************************************************/ 47 48 #define CV_MINMAXLOC_ENTRY( _toggle_, srctype, temptype, cn ) \ 49 temptype min_val, max_val; \ 50 int min_loc = 0, max_loc = 0; \ 51 int x, loc = 0, width = size.width*(cn); \ 52 step /= sizeof(src[0]); \ 53 \ 54 min_val = src[0]; \ 55 min_val = max_val = _toggle_( min_val ) 56 57 58 #define CV_MINMAXLOC_EXIT( _fin_cast_macro_ ) \ 59 minLoc->x = min_loc; \ 60 maxLoc->x = max_loc; \ 61 minLoc->y = maxLoc->y = 0; \ 62 *minVal = _fin_cast_macro_(min_val); \ 63 *maxVal = _fin_cast_macro_(max_val); \ 64 return CV_OK 65 66 67 #define ICV_DEF_MINMAXLOC_1D_CASE_COI( _toggle_, temptype, cn ) \ 68 for( x = 0; x < width; x += (cn), loc++ ) \ 69 { \ 70 temptype val = src[x]; \ 71 val = _toggle_(val); \ 72 \ 73 if( val < min_val ) \ 74 { \ 75 min_val = val; \ 76 min_loc = loc; \ 77 } \ 78 else if( val > max_val ) \ 79 { \ 80 max_val = val; \ 81 max_loc = loc; \ 82 } \ 83 } 84 85 86 #define ICV_DEF_MINMAXLOC_FUNC_2D( _toggle_, _fin_cast_macro_, flavor, \ 87 srctype, temptype, extrtype ) \ 88 IPCVAPI_IMPL( CvStatus, \ 89 icvMinMaxIndx_##flavor##_C1R,( const srctype* src, int step, CvSize size, \ 90 extrtype* minVal, extrtype* maxVal, CvPoint* minLoc, CvPoint* maxLoc ), \ 91 (src, step, size, minVal, maxVal, minLoc, maxLoc) ) \ 92 { \ 93 CV_MINMAXLOC_ENTRY( _toggle_, srctype, temptype, 1 ); \ 94 \ 95 for( ; size.height--; src += step ) \ 96 { \ 97 ICV_DEF_MINMAXLOC_1D_CASE_COI( _toggle_, temptype, 1 ); \ 98 } \ 99 \ 100 CV_MINMAXLOC_EXIT( _fin_cast_macro_ ); \ 101 } 102 103 104 #define ICV_DEF_MINMAXLOC_FUNC_2D_COI( _toggle_, _fin_cast_macro_, flavor, \ 105 srctype, temptype, extrtype ) \ 106 static CvStatus CV_STDCALL \ 107 icvMinMaxIndx_##flavor##_CnCR( const srctype* src, int step, \ 108 CvSize size, int cn, int coi, \ 109 extrtype* minVal, extrtype* maxVal, \ 110 CvPoint* minLoc, CvPoint* maxLoc ) \ 111 { \ 112 (src) += coi - 1; \ 113 CV_MINMAXLOC_ENTRY( _toggle_, srctype, temptype, cn ); \ 114 \ 115 for( ; size.height--; src += step ) \ 116 { \ 117 ICV_DEF_MINMAXLOC_1D_CASE_COI( _toggle_, temptype, cn ); \ 118 } \ 119 \ 120 CV_MINMAXLOC_EXIT( _fin_cast_macro_ ); \ 121 } 122 123 124 #define ICV_DEF_MINMAXLOC_ALL_INT( flavor, srctype, \ 125 _fin_cast_macro_, extrtype ) \ 126 ICV_DEF_MINMAXLOC_FUNC_2D( CV_NOP, _fin_cast_macro_, flavor,\ 127 srctype, int, extrtype ) \ 128 ICV_DEF_MINMAXLOC_FUNC_2D_COI( CV_NOP, _fin_cast_macro_, \ 129 flavor, srctype, int, extrtype ) 130 131 CV_INLINE float minmax_to_float( int val ) 132 { 133 Cv32suf v; 134 v.i = CV_TOGGLE_FLT(val); 135 return v.f; 136 } 137 138 CV_INLINE double minmax_to_double( int64 val ) 139 { 140 Cv64suf v; 141 v.i = CV_TOGGLE_DBL(val); 142 return v.f; 143 } 144 145 #define ICV_DEF_MINMAXLOC_ALL_FLT( flavor, srctype, _toggle_, \ 146 _fin_cast_macro_, extrtype ) \ 147 \ 148 ICV_DEF_MINMAXLOC_FUNC_2D( _toggle_, _fin_cast_macro_, flavor, \ 149 srctype, srctype, extrtype ) \ 150 ICV_DEF_MINMAXLOC_FUNC_2D_COI( _toggle_, _fin_cast_macro_, flavor, \ 151 srctype, srctype, extrtype ) 152 153 ICV_DEF_MINMAXLOC_ALL_INT( 8u, uchar, CV_CAST_32F, float ) 154 ICV_DEF_MINMAXLOC_ALL_INT( 16u, ushort, CV_CAST_32F, float ) 155 ICV_DEF_MINMAXLOC_ALL_INT( 16s, short, CV_CAST_32F, float ) 156 ICV_DEF_MINMAXLOC_ALL_INT( 32s, int, CV_CAST_64F, double ) 157 ICV_DEF_MINMAXLOC_ALL_FLT( 32f, int, CV_TOGGLE_FLT, minmax_to_float, float ) 158 ICV_DEF_MINMAXLOC_ALL_FLT( 64f, int64, CV_TOGGLE_DBL, minmax_to_double, double ) 159 160 161 /****************************************************************************************\ 162 * MinMaxLoc with mask * 163 \****************************************************************************************/ 164 165 #define CV_MINMAXLOC_MASK_ENTRY( _toggle_, srctype, temptype, cn ) \ 166 temptype min_val = 0, max_val = 0; \ 167 int min_loc = -1, max_loc = -1; \ 168 int x = 0, y, loc = 0, width = size.width; \ 169 step /= sizeof(src[0]); \ 170 \ 171 if( width*(cn) == step && width == maskStep ) \ 172 { \ 173 width *= size.height; \ 174 size.height = 1; \ 175 } \ 176 \ 177 for( y = 0; y < size.height; y++, src += step, \ 178 mask += maskStep ) \ 179 { \ 180 for( x = 0; x < width; x++, loc++ ) \ 181 if( mask[x] != 0 ) \ 182 { \ 183 min_loc = max_loc = loc; \ 184 min_val = (src)[x*(cn)]; \ 185 min_val = max_val = _toggle_( min_val ); \ 186 goto stop_scan; \ 187 } \ 188 } \ 189 \ 190 stop_scan:; 191 192 193 #define ICV_DEF_MINMAXLOC_1D_MASK_CASE_COI( _toggle_, temptype, cn ) \ 194 for( ; x < width; x++, loc++ ) \ 195 { \ 196 temptype val = src[x*(cn)]; \ 197 int m = mask[x] != 0; \ 198 val = _toggle_(val); \ 199 \ 200 if( val < min_val && m ) \ 201 { \ 202 min_val = val; \ 203 min_loc = loc; \ 204 } \ 205 else if( val > max_val && m ) \ 206 { \ 207 max_val = val; \ 208 max_loc = loc; \ 209 } \ 210 } 211 212 213 #define ICV_DEF_MINMAXLOC_MASK_FUNC_2D( _toggle_, _fin_cast_macro_, flavor, \ 214 srctype, temptype, extrtype ) \ 215 IPCVAPI_IMPL( CvStatus, \ 216 icvMinMaxIndx_##flavor##_C1MR,( const srctype* src, int step, \ 217 const uchar* mask, int maskStep, CvSize size, \ 218 extrtype* minVal, extrtype* maxVal, CvPoint* minLoc, CvPoint* maxLoc ), \ 219 ( src, step, mask, maskStep, size, minVal, maxVal, minLoc, maxLoc) ) \ 220 { \ 221 CV_MINMAXLOC_MASK_ENTRY( _toggle_, srctype, temptype, 1 ); \ 222 \ 223 for( ; y < size.height; y++, src += step, mask += maskStep ) \ 224 { \ 225 ICV_DEF_MINMAXLOC_1D_MASK_CASE_COI( _toggle_, temptype, 1 ) \ 226 x = 0; \ 227 } \ 228 \ 229 CV_MINMAXLOC_EXIT( _fin_cast_macro_ ); \ 230 } 231 232 233 #define ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( _toggle_, _fin_cast_macro_, \ 234 flavor, srctype, temptype, extrtype ) \ 235 static CvStatus CV_STDCALL \ 236 icvMinMaxIndx_##flavor##_CnCMR( const srctype* src, int step, \ 237 const uchar* mask, int maskStep, CvSize size, int cn, int coi, \ 238 extrtype* minVal, extrtype* maxVal, CvPoint* minLoc, CvPoint* maxLoc ) \ 239 { \ 240 (src) += coi - 1; \ 241 CV_MINMAXLOC_MASK_ENTRY( _toggle_, srctype, temptype, cn ); \ 242 \ 243 for( ; y < size.height; y++, src += step, mask += maskStep ) \ 244 { \ 245 ICV_DEF_MINMAXLOC_1D_MASK_CASE_COI( _toggle_, temptype, cn ) \ 246 x = 0; \ 247 } \ 248 \ 249 CV_MINMAXLOC_EXIT( _fin_cast_macro_ ); \ 250 } 251 252 253 254 #define ICV_DEF_MINMAXLOC_MASK_ALL_INT( flavor, srctype, \ 255 _fin_cast_macro_, extrtype ) \ 256 ICV_DEF_MINMAXLOC_MASK_FUNC_2D( CV_NOP, _fin_cast_macro_, flavor, \ 257 srctype, int, extrtype ) \ 258 ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( CV_NOP, _fin_cast_macro_, flavor, \ 259 srctype, int, extrtype ) 260 261 #define ICV_DEF_MINMAXLOC_MASK_ALL_FLT( flavor, srctype, _toggle_, \ 262 _fin_cast_macro_, extrtype ) \ 263 ICV_DEF_MINMAXLOC_MASK_FUNC_2D( _toggle_, _fin_cast_macro_, flavor, \ 264 srctype, srctype, extrtype ) \ 265 ICV_DEF_MINMAXLOC_MASK_FUNC_2D_COI( _toggle_, _fin_cast_macro_, flavor, \ 266 srctype, srctype, extrtype ) 267 268 ICV_DEF_MINMAXLOC_MASK_ALL_INT( 8u, uchar, CV_CAST_32F, float ) 269 ICV_DEF_MINMAXLOC_MASK_ALL_INT( 16u, ushort, CV_CAST_32F, float ) 270 ICV_DEF_MINMAXLOC_MASK_ALL_INT( 16s, short, CV_CAST_32F, float ) 271 ICV_DEF_MINMAXLOC_MASK_ALL_INT( 32s, int, CV_CAST_64F, double ) 272 ICV_DEF_MINMAXLOC_MASK_ALL_FLT( 32f, int, CV_TOGGLE_FLT, minmax_to_float, float ) 273 ICV_DEF_MINMAXLOC_MASK_ALL_FLT( 64f, int64, CV_TOGGLE_DBL, minmax_to_double, double ) 274 275 #define icvMinMaxIndx_8s_C1R 0 276 #define icvMinMaxIndx_8s_CnCR 0 277 #define icvMinMaxIndx_8s_C1MR 0 278 #define icvMinMaxIndx_8s_CnCMR 0 279 280 CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, C1R ) 281 CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, CnCR ) 282 CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, C1MR ) 283 CV_DEF_INIT_FUNC_TAB_2D( MinMaxIndx, CnCMR ) 284 285 286 CV_IMPL void 287 cvMinMaxLoc( const void* img, double* _minVal, double* _maxVal, 288 CvPoint* _minLoc, CvPoint* _maxLoc, const void* mask ) 289 { 290 static CvFuncTable minmax_tab, minmaxcoi_tab; 291 static CvFuncTable minmaxmask_tab, minmaxmaskcoi_tab; 292 static int inittab = 0; 293 294 CV_FUNCNAME("cvMinMaxLoc"); 295 296 __BEGIN__; 297 298 int type, depth, cn, coi = 0; 299 int mat_step, mask_step = 0, cont_flag; 300 CvSize size; 301 CvMat stub, maskstub, *mat = (CvMat*)img, *matmask = (CvMat*)mask; 302 CvPoint minloc, maxloc; 303 double minv = 0, maxv = 0; 304 float minvf = 0.f, maxvf = 0.f; 305 void *pmin = &minvf, *pmax = &maxvf; 306 307 if( !inittab ) 308 { 309 icvInitMinMaxIndxC1RTable( &minmax_tab ); 310 icvInitMinMaxIndxCnCRTable( &minmaxcoi_tab ); 311 icvInitMinMaxIndxC1MRTable( &minmaxmask_tab ); 312 icvInitMinMaxIndxCnCMRTable( &minmaxmaskcoi_tab ); 313 inittab = 1; 314 } 315 316 if( !CV_IS_MAT(mat) ) 317 CV_CALL( mat = cvGetMat( mat, &stub, &coi )); 318 319 type = CV_MAT_TYPE( mat->type ); 320 depth = CV_MAT_DEPTH( type ); 321 cn = CV_MAT_CN( type ); 322 size = cvGetMatSize( mat ); 323 324 if( cn > 1 && coi == 0 ) 325 CV_ERROR( CV_StsBadArg, "" ); 326 327 if( depth == CV_32S || depth == CV_64F ) 328 pmin = &minv, pmax = &maxv; 329 330 mat_step = mat->step; 331 cont_flag = mat->type; 332 333 if( mask ) 334 { 335 CV_CALL( matmask = cvGetMat( matmask, &maskstub )); 336 337 if( !CV_IS_MASK_ARR( matmask )) 338 CV_ERROR( CV_StsBadMask, "" ); 339 340 if( !CV_ARE_SIZES_EQ( mat, matmask )) 341 CV_ERROR( CV_StsUnmatchedSizes, "" ); 342 343 mask_step = matmask->step; 344 cont_flag &= matmask->type; 345 } 346 347 if( CV_IS_MAT_CONT(cont_flag) ) 348 { 349 size.width *= size.height; 350 size.height = 1; 351 } 352 353 if( size.height == 1 ) 354 mat_step = mask_step = CV_STUB_STEP; 355 356 if( !mask ) 357 { 358 if( CV_MAT_CN(type) == 1 || coi == 0 ) 359 { 360 CvFunc2D_1A4P func = (CvFunc2D_1A4P)(minmax_tab.fn_2d[depth]); 361 362 if( !func ) 363 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat ); 364 365 IPPI_CALL( func( mat->data.ptr, mat_step, size, 366 pmin, pmax, &minloc, &maxloc )); 367 } 368 else 369 { 370 CvFunc2DnC_1A4P func = (CvFunc2DnC_1A4P)(minmaxcoi_tab.fn_2d[depth]); 371 372 if( !func ) 373 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat ); 374 375 IPPI_CALL( func( mat->data.ptr, mat_step, size, cn, coi, 376 pmin, pmax, &minloc, &maxloc )); 377 } 378 } 379 else 380 { 381 if( CV_MAT_CN(type) == 1 || coi == 0 ) 382 { 383 CvFunc2D_2A4P func = (CvFunc2D_2A4P)(minmaxmask_tab.fn_2d[depth]); 384 385 if( !func ) 386 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat ); 387 388 IPPI_CALL( func( mat->data.ptr, mat_step, matmask->data.ptr, 389 mask_step, size, 390 pmin, pmax, &minloc, &maxloc )); 391 } 392 else 393 { 394 CvFunc2DnC_2A4P func = (CvFunc2DnC_2A4P)(minmaxmaskcoi_tab.fn_2d[depth]); 395 396 if( !func ) 397 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat ); 398 399 IPPI_CALL( func( mat->data.ptr, mat_step, 400 matmask->data.ptr, mask_step, size, cn, coi, 401 pmin, pmax, &minloc, &maxloc )); 402 } 403 } 404 405 if( matmask || _minLoc || _maxLoc ) 406 { 407 if( minloc.x >= mat->cols ) 408 { 409 minloc.y = minloc.x / mat->cols; 410 minloc.x -= minloc.y * mat->cols; 411 } 412 413 if( maxloc.x >= mat->cols ) 414 { 415 maxloc.y = maxloc.x / mat->cols; 416 maxloc.x -= maxloc.y * mat->cols; 417 } 418 419 if( matmask && ((unsigned)minloc.x >= (unsigned)mat->cols || 420 (unsigned)minloc.y >= (unsigned)mat->rows || 421 matmask->data.ptr[minloc.y*matmask->step + minloc.x] == 0 || 422 (unsigned)maxloc.x >= (unsigned)mat->cols || 423 (unsigned)maxloc.y >= (unsigned)mat->rows || 424 matmask->data.ptr[maxloc.y*matmask->step + maxloc.x] == 0) ) 425 { 426 minloc.x = minloc.y = maxloc.x = maxloc.y = -1; 427 minv = maxv = minvf = maxvf = 0; 428 } 429 430 if( _minLoc ) 431 *_minLoc = minloc; 432 433 if( _maxLoc ) 434 *_maxLoc = maxloc; 435 } 436 437 if( depth != CV_32S && depth != CV_64F ) 438 { 439 minv = minvf; 440 maxv = maxvf; 441 } 442 443 if( _minVal ) 444 *_minVal = minv; 445 446 if( _maxVal ) 447 *_maxVal = maxv; 448 449 __END__; 450 } 451 452 /* End of file */ 453
