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 #include "_cv.h" 42 43 #if 0 44 45 IPCVAPI(CvStatus, icvCalcContrastHist8uC1R, ( uchar** img, int step, CvSize size, 46 CvHistogram* hist, int dont_clear )) 47 48 IPCVAPI(CvStatus, icvCalcContrastHistMask8uC1R, ( uchar** img, int step, 49 uchar* mask, int mask_step, CvSize size, 50 CvHistogram* hist, int dont_clear )) 51 52 /*F/////////////////////////////////////////////////////////////////////////////////////// 53 // Name: icvCalcContrastHist8uC1R 54 // Purpose: Calculating the histogram of contrast from one-channel images 55 // Context: 56 // Parameters: 57 // Returns: 58 // Notes: if dont_clear parameter is NULL then histogram clearing before 59 // calculating (all values sets to NULL) 60 //F*/ 61 static CvStatus CV_STDCALL 62 icvCalcContrastHist8uC1R( uchar** img, int step, CvSize size, 63 CvHistogram* hist, int dont_clear ) 64 { 65 int i, j, t, x = 0, y = 0; 66 int dims; 67 68 if( !hist || !img ) 69 return CV_NULLPTR_ERR; 70 71 dims = hist->c_dims; 72 if( dims != 1 ) 73 return CV_BADSIZE_ERR; 74 75 if( hist->type != CV_HIST_ARRAY ) 76 return CV_BADFLAG_ERR; 77 78 for( i = 0; i < dims; i++ ) 79 if( !img[i] ) 80 return CV_NULLPTR_ERR; 81 82 for( i = 0; i < hist->c_dims; i++ ) 83 { 84 if( !hist->thresh[i] ) 85 return CV_NULLPTR_ERR; 86 assert( hist->chdims[i] ); 87 } 88 89 j = hist->dims[0] * hist->mdims[0]; 90 91 int *n = (int *)cvAlloc( (size_t)hist->dims[0] * sizeof( int )); 92 93 if( hist->type == CV_HIST_ARRAY ) 94 { 95 if( !dont_clear ) 96 for( i = 0; i < j; i++ ) 97 { 98 hist->array[i] = 0; 99 n[i] = 0; 100 } 101 102 switch (hist->c_dims) 103 { 104 case 1: 105 { 106 uchar *data0 = img[0]; 107 int *array = (int *) hist->array; 108 int *chdims = hist->chdims[0]; 109 110 for( i = 0; i < j; i++ ) 111 array[i] = cvRound( hist->array[i] ); 112 113 for( y = 0; y < size.height; y++, data0 += step ) 114 { 115 for( x = 0; x <= size.width - 1; x += 2 ) 116 { 117 int v1_r = MIN( data0[x], data0[x + 1] ); 118 int v2_r = MAX( data0[x], data0[x + 1] ); 119 120 // calculate contrast for the right-left pair 121 for( t = v1_r; t < v2_r; t++ ) 122 { 123 int val0 = chdims[t + 128]; 124 125 array[val0] += MIN( t - v1_r, v2_r - t ); 126 n[val0]++; 127 } 128 129 if( y < size.height - 1 ) 130 { 131 int v1_d = MIN( data0[x], data0[x + step] ); 132 int v2_d = MAX( data0[x], data0[x + step] ); 133 134 // calculate contrast for the top-down pair 135 for( t = v1_d; t < v2_d; t++ ) 136 { 137 int val0 = chdims[t + 128]; 138 139 array[val0] += MIN( t - v1_d, v2_d - t ); 140 n[val0]++; 141 } 142 } 143 } 144 } 145 146 // convert int to float 147 for( i = 0; i < j; i++ ) 148 { 149 if( n[i] != 0 ) 150 hist->array[i] = (float) array[i] / n[i]; 151 else 152 hist->array[i] = 0; 153 } 154 } 155 break; 156 default: 157 return CV_BADSIZE_ERR; 158 } 159 } 160 161 cvFree( &n ); 162 return CV_NO_ERR; 163 } 164 165 /*F/////////////////////////////////////////////////////////////////////////////////////// 166 // Name: icvCalcContrastHistMask8uC1R 167 // Purpose: Calculating the mask histogram of contrast from one-channel images 168 // Context: 169 // Parameters: 170 // Returns: 171 // Notes: if dont_clear parameter is NULL then histogram clearing before 172 // calculating (all values sets to NULL) 173 //F*/ 174 static CvStatus CV_STDCALL 175 icvCalcContrastHistMask8uC1R( uchar** img, int step, uchar* mask, int mask_step, 176 CvSize size, CvHistogram * hist, int dont_clear ) 177 { 178 int i, j, t, x = 0, y = 0; 179 int dims; 180 181 182 if( !hist || !img || !mask ) 183 return CV_NULLPTR_ERR; 184 185 dims = hist->c_dims; 186 if( dims != 1 ) 187 return CV_BADSIZE_ERR; 188 189 if( hist->type != CV_HIST_ARRAY ) 190 return CV_BADFLAG_ERR; 191 192 for( i = 0; i < dims; i++ ) 193 if( !img[i] ) 194 return CV_NULLPTR_ERR; 195 196 for( i = 0; i < hist->c_dims; i++ ) 197 { 198 if( !hist->thresh[i] ) 199 return CV_NULLPTR_ERR; 200 assert( hist->chdims[i] ); 201 } 202 203 j = hist->dims[0] * hist->mdims[0]; 204 205 int *n = (int *)cvAlloc( (size_t) hist->dims[0] * sizeof( int )); 206 207 if( hist->type == CV_HIST_ARRAY ) 208 { 209 if( !dont_clear ) 210 for( i = 0; i < j; i++ ) 211 { 212 hist->array[i] = 0; 213 n[i] = 0; 214 } 215 216 switch (hist->c_dims) 217 { 218 case 1: 219 { 220 uchar *data0 = img[0]; 221 uchar *maskp = mask; 222 int *array = (int *) hist->array; 223 int *chdims = hist->chdims[0]; 224 225 for( i = 0; i < j; i++ ) 226 array[i] = cvRound( hist->array[i] ); 227 228 for( y = 0; y < size.height; y++, data0 += step, maskp += mask_step ) 229 { 230 for( x = 0; x <= size.width - 2; x++ ) 231 { 232 if( maskp[x] ) 233 { 234 if( maskp[x + 1] ) 235 { 236 int v1_r = MIN( data0[x], data0[x + 1] ); 237 int v2_r = MAX( data0[x], data0[x + 1] ); 238 239 240 // calculate contrast for the right-left pair 241 for( t = v1_r; t < v2_r; t++ ) 242 { 243 int val0 = chdims[t + 128]; 244 245 array[val0] += MIN( t - v1_r, v2_r - t ); 246 n[val0]++; 247 248 } 249 } 250 251 if( y < size.height - 1 ) 252 { 253 if( maskp[x + mask_step] ) 254 { 255 int v1_d = MIN( data0[x], data0[x + step] ); 256 int v2_d = MAX( data0[x], data0[x + step] ); 257 258 // calculate contrast for the top-down pair 259 for( t = v1_d; t < v2_d; t++ ) 260 { 261 int val0 = chdims[t + 128]; 262 263 array[val0] += MIN( t - v1_d, v2_d - t ); 264 n[val0]++; 265 266 } 267 } 268 } 269 } 270 } 271 } 272 273 // convert int to float 274 for( i = 0; i < j; i++ ) 275 { 276 if( n[i] != 0 ) 277 hist->array[i] = (float) array[i] / n[i]; 278 else 279 hist->array[i] = 0; 280 } 281 } 282 break; 283 default: 284 return CV_BADSIZE_ERR; 285 } 286 } 287 288 cvFree( &n ); 289 return CV_NO_ERR; 290 } 291 292 /* 293 CV_IMPL void cvCalcContrastHist( IplImage** img, CvHistogram* hist, int dont_clear ) 294 { 295 CV_FUNCNAME( "cvCalcContrastHist" ); 296 uchar* data[CV_HIST_MAX_DIM]; 297 int step = 0; 298 CvSize roi = {0,0}; 299 300 __BEGIN__; 301 302 {for( int i = 0; i < hist->c_dims; i++ ) 303 CV_CALL( CV_CHECK_IMAGE( img[i] ) );} 304 305 {for( int i = 0; i < hist->c_dims; i++ ) 306 cvGetImageRawData( img[i], &data[i], &step, &roi );} 307 308 if(img[0]->nChannels != 1) 309 CV_ERROR( IPL_BadNumChannels, "bad channels numbers" ); 310 311 if(img[0]->depth != IPL_DEPTH_8U) 312 CV_ERROR( IPL_BadDepth, "bad image depth" ); 313 314 switch(img[0]->depth) 315 { 316 case IPL_DEPTH_8U: 317 IPPI_CALL( icvCalcContrastHist8uC1R( data, step, roi, hist, dont_clear ) ); 318 break; 319 default: CV_ERROR( IPL_BadDepth, "bad image depth" ); 320 } 321 322 __CLEANUP__; 323 __END__; 324 } 325 */ 326 327 CV_IMPL void 328 cvCalcContrastHist( IplImage ** img, CvHistogram * hist, int dont_clear, IplImage * mask ) 329 { 330 CV_FUNCNAME( "cvCalcContrastHist" ); 331 uchar *data[CV_HIST_MAX_DIM]; 332 uchar *mask_data = 0; 333 int step = 0; 334 int mask_step = 0; 335 CvSize roi = { 0, 0 }; 336 337 __BEGIN__; 338 339 { 340 for( int i = 0; i < hist->c_dims; i++ ) 341 CV_CALL( CV_CHECK_IMAGE( img[i] )); 342 } 343 if( mask ) 344 { 345 CV_CALL( CV_CHECK_IMAGE( mask )); 346 if( mask->depth != IPL_DEPTH_8U ) 347 CV_ERROR( CV_BadDepth, "bad mask depth" ); 348 cvGetImageRawData( mask, &mask_data, &mask_step, 0 ); 349 } 350 351 352 { 353 for( int i = 0; i < hist->c_dims; i++ ) 354 cvGetImageRawData( img[i], &data[i], &step, &roi ); 355 } 356 357 if( img[0]->nChannels != 1 ) 358 CV_ERROR( CV_BadNumChannels, "bad channels numbers" ); 359 360 if( img[0]->depth != IPL_DEPTH_8U ) 361 CV_ERROR( CV_BadDepth, "bad image depth" ); 362 363 364 switch (img[0]->depth) 365 { 366 case IPL_DEPTH_8U: 367 if( !mask ) 368 { 369 IPPI_CALL( icvCalcContrastHist8uC1R( data, step, roi, hist, dont_clear )); 370 } 371 else 372 { 373 IPPI_CALL( icvCalcContrastHistMask8uC1R( data, step, mask_data, 374 mask_step, roi, hist, dont_clear )); 375 } 376 break; 377 default: 378 CV_ERROR( CV_BadDepth, "bad image depth" ); 379 } 380 381 __CLEANUP__; 382 __END__; 383 } 384 385 #endif 386