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 * Mean and StdDev calculation *
46 \****************************************************************************************/
47
48 #define ICV_MEAN_SDV_COI_CASE( worktype, sqsumtype, \
49 sqr_macro, len, cn ) \
50 for( ; x <= (len) - 4*(cn); x += 4*(cn))\
51 { \
52 worktype t0 = src[x]; \
53 worktype t1 = src[x + (cn)]; \
54 \
55 s0 += t0 + t1; \
56 sq0 += (sqsumtype)(sqr_macro(t0)) + \
57 (sqsumtype)(sqr_macro(t1)); \
58 \
59 t0 = src[x + 2*(cn)]; \
60 t1 = src[x + 3*(cn)]; \
61 \
62 s0 += t0 + t1; \
63 sq0 += (sqsumtype)(sqr_macro(t0)) + \
64 (sqsumtype)(sqr_macro(t1)); \
65 } \
66 \
67 for( ; x < (len); x += (cn) ) \
68 { \
69 worktype t0 = src[x]; \
70 \
71 s0 += t0; \
72 sq0 += (sqsumtype)(sqr_macro(t0)); \
73 }
74
75
76 #define ICV_MEAN_SDV_CASE_C1( worktype, sqsumtype, sqr_macro, len ) \
77 ICV_MEAN_SDV_COI_CASE( worktype, sqsumtype, sqr_macro, len, 1 )
78
79
80 #define ICV_MEAN_SDV_CASE_C2( worktype, sqsumtype, \
81 sqr_macro, len ) \
82 for( ; x < (len); x += 2 ) \
83 { \
84 worktype t0 = (src)[x]; \
85 worktype t1 = (src)[x + 1]; \
86 \
87 s0 += t0; \
88 sq0 += (sqsumtype)(sqr_macro(t0)); \
89 s1 += t1; \
90 sq1 += (sqsumtype)(sqr_macro(t1)); \
91 }
92
93
94 #define ICV_MEAN_SDV_CASE_C3( worktype, sqsumtype, \
95 sqr_macro, len ) \
96 for( ; x < (len); x += 3 ) \
97 { \
98 worktype t0 = (src)[x]; \
99 worktype t1 = (src)[x + 1]; \
100 worktype t2 = (src)[x + 2]; \
101 \
102 s0 += t0; \
103 sq0 += (sqsumtype)(sqr_macro(t0)); \
104 s1 += t1; \
105 sq1 += (sqsumtype)(sqr_macro(t1)); \
106 s2 += t2; \
107 sq2 += (sqsumtype)(sqr_macro(t2)); \
108 }
109
110
111 #define ICV_MEAN_SDV_CASE_C4( worktype, sqsumtype, \
112 sqr_macro, len ) \
113 for( ; x < (len); x += 4 ) \
114 { \
115 worktype t0 = (src)[x]; \
116 worktype t1 = (src)[x + 1]; \
117 \
118 s0 += t0; \
119 sq0 += (sqsumtype)(sqr_macro(t0)); \
120 s1 += t1; \
121 sq1 += (sqsumtype)(sqr_macro(t1)); \
122 \
123 t0 = (src)[x + 2]; \
124 t1 = (src)[x + 3]; \
125 \
126 s2 += t0; \
127 sq2 += (sqsumtype)(sqr_macro(t0)); \
128 s3 += t1; \
129 sq3 += (sqsumtype)(sqr_macro(t1)); \
130 }
131
132
133 #define ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqsumtype, \
134 sqr_macro, len, cn ) \
135 for( ; x <= (len) - 4; x += 4 ) \
136 { \
137 worktype t0; \
138 if( mask[x] ) \
139 { \
140 t0 = src[x*(cn)]; pix++; \
141 s0 += t0; \
142 sq0 += sqsumtype(sqr_macro(t0)); \
143 } \
144 \
145 if( mask[x+1] ) \
146 { \
147 t0 = src[(x+1)*(cn)]; pix++; \
148 s0 += t0; \
149 sq0 += sqsumtype(sqr_macro(t0)); \
150 } \
151 \
152 if( mask[x+2] ) \
153 { \
154 t0 = src[(x+2)*(cn)]; pix++; \
155 s0 += t0; \
156 sq0 += sqsumtype(sqr_macro(t0)); \
157 } \
158 \
159 if( mask[x+3] ) \
160 { \
161 t0 = src[(x+3)*(cn)]; pix++; \
162 s0 += t0; \
163 sq0 += sqsumtype(sqr_macro(t0)); \
164 } \
165 } \
166 \
167 for( ; x < (len); x++ ) \
168 { \
169 if( mask[x] ) \
170 { \
171 worktype t0 = src[x*(cn)]; pix++; \
172 s0 += t0; \
173 sq0 += sqsumtype(sqr_macro(t0)); \
174 } \
175 }
176
177
178 #define ICV_MEAN_SDV_MASK_CASE_C1( worktype, sqsumtype, sqr_macro, len ) \
179 ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqsumtype, sqr_macro, len, 1 )
180
181
182 #define ICV_MEAN_SDV_MASK_CASE_C2( worktype, sqsumtype,\
183 sqr_macro, len ) \
184 for( ; x < (len); x++ ) \
185 { \
186 if( mask[x] ) \
187 { \
188 worktype t0 = src[x*2]; \
189 worktype t1 = src[x*2+1]; \
190 pix++; \
191 s0 += t0; \
192 sq0 += sqsumtype(sqr_macro(t0)); \
193 s1 += t1; \
194 sq1 += sqsumtype(sqr_macro(t1)); \
195 } \
196 }
197
198
199 #define ICV_MEAN_SDV_MASK_CASE_C3( worktype, sqsumtype,\
200 sqr_macro, len ) \
201 for( ; x < (len); x++ ) \
202 { \
203 if( mask[x] ) \
204 { \
205 worktype t0 = src[x*3]; \
206 worktype t1 = src[x*3+1]; \
207 worktype t2 = src[x*3+2]; \
208 pix++; \
209 s0 += t0; \
210 sq0 += sqsumtype(sqr_macro(t0)); \
211 s1 += t1; \
212 sq1 += sqsumtype(sqr_macro(t1)); \
213 s2 += t2; \
214 sq2 += sqsumtype(sqr_macro(t2)); \
215 } \
216 }
217
218
219 #define ICV_MEAN_SDV_MASK_CASE_C4( worktype, sqsumtype,\
220 sqr_macro, len ) \
221 for( ; x < (len); x++ ) \
222 { \
223 if( mask[x] ) \
224 { \
225 worktype t0 = src[x*4]; \
226 worktype t1 = src[x*4+1]; \
227 pix++; \
228 s0 += t0; \
229 sq0 += sqsumtype(sqr_macro(t0)); \
230 s1 += t1; \
231 sq1 += sqsumtype(sqr_macro(t1)); \
232 t0 = src[x*4+2]; \
233 t1 = src[x*4+3]; \
234 s2 += t0; \
235 sq2 += sqsumtype(sqr_macro(t0)); \
236 s3 += t1; \
237 sq3 += sqsumtype(sqr_macro(t1)); \
238 } \
239 }
240
241
242 ////////////////////////////////////// entry macros //////////////////////////////////////
243
244 #define ICV_MEAN_SDV_ENTRY_COMMON() \
245 int pix; \
246 double scale, tmp; \
247 step /= sizeof(src[0])
248
249 #define ICV_MEAN_SDV_ENTRY_C1( sumtype, sqsumtype ) \
250 sumtype s0 = 0; \
251 sqsumtype sq0 = 0; \
252 ICV_MEAN_SDV_ENTRY_COMMON()
253
254 #define ICV_MEAN_SDV_ENTRY_C2( sumtype, sqsumtype ) \
255 sumtype s0 = 0, s1 = 0; \
256 sqsumtype sq0 = 0, sq1 = 0; \
257 ICV_MEAN_SDV_ENTRY_COMMON()
258
259 #define ICV_MEAN_SDV_ENTRY_C3( sumtype, sqsumtype ) \
260 sumtype s0 = 0, s1 = 0, s2 = 0; \
261 sqsumtype sq0 = 0, sq1 = 0, sq2 = 0; \
262 ICV_MEAN_SDV_ENTRY_COMMON()
263
264 #define ICV_MEAN_SDV_ENTRY_C4( sumtype, sqsumtype ) \
265 sumtype s0 = 0, s1 = 0, s2 = 0, s3 = 0; \
266 sqsumtype sq0 = 0, sq1 = 0, sq2 = 0, sq3 = 0; \
267 ICV_MEAN_SDV_ENTRY_COMMON()
268
269
270 #define ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size ) \
271 int remaining = block_size; \
272 ICV_MEAN_SDV_ENTRY_COMMON()
273
274 #define ICV_MEAN_SDV_ENTRY_BLOCK_C1( sumtype, sqsumtype, \
275 worktype, sqworktype, block_size ) \
276 sumtype sum0 = 0; \
277 sqsumtype sqsum0 = 0; \
278 worktype s0 = 0; \
279 sqworktype sq0 = 0; \
280 ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
281
282 #define ICV_MEAN_SDV_ENTRY_BLOCK_C2( sumtype, sqsumtype, \
283 worktype, sqworktype, block_size ) \
284 sumtype sum0 = 0, sum1 = 0; \
285 sqsumtype sqsum0 = 0, sqsum1 = 0; \
286 worktype s0 = 0, s1 = 0; \
287 sqworktype sq0 = 0, sq1 = 0; \
288 ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
289
290 #define ICV_MEAN_SDV_ENTRY_BLOCK_C3( sumtype, sqsumtype, \
291 worktype, sqworktype, block_size ) \
292 sumtype sum0 = 0, sum1 = 0, sum2 = 0; \
293 sqsumtype sqsum0 = 0, sqsum1 = 0, sqsum2 = 0; \
294 worktype s0 = 0, s1 = 0, s2 = 0; \
295 sqworktype sq0 = 0, sq1 = 0, sq2 = 0; \
296 ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
297
298 #define ICV_MEAN_SDV_ENTRY_BLOCK_C4( sumtype, sqsumtype, \
299 worktype, sqworktype, block_size ) \
300 sumtype sum0 = 0, sum1 = 0, sum2 = 0, sum3 = 0; \
301 sqsumtype sqsum0 = 0, sqsum1 = 0, sqsum2 = 0, sqsum3 = 0; \
302 worktype s0 = 0, s1 = 0, s2 = 0, s3 = 0; \
303 sqworktype sq0 = 0, sq1 = 0, sq2 = 0, sq3 = 0; \
304 ICV_MEAN_SDV_ENTRY_BLOCK_COMMON( block_size )
305
306
307 /////////////////////////////////////// exit macros //////////////////////////////////////
308
309 #define ICV_MEAN_SDV_EXIT_COMMON() \
310 scale = pix ? 1./pix : 0
311
312 #define ICV_MEAN_SDV_EXIT_CN( total, sqtotal, idx ) \
313 ICV_MEAN_SDV_EXIT_COMMON(); \
314 mean[idx] = tmp = scale*(double)total##idx; \
315 tmp = scale*(double)sqtotal##idx - tmp*tmp; \
316 sdv[idx] = sqrt(MAX(tmp,0.))
317
318 #define ICV_MEAN_SDV_EXIT_C1( total, sqtotal ) \
319 ICV_MEAN_SDV_EXIT_COMMON(); \
320 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 )
321
322 #define ICV_MEAN_SDV_EXIT_C2( total, sqtotal ) \
323 ICV_MEAN_SDV_EXIT_COMMON(); \
324 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 ); \
325 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 1 )
326
327 #define ICV_MEAN_SDV_EXIT_C3( total, sqtotal ) \
328 ICV_MEAN_SDV_EXIT_COMMON(); \
329 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 ); \
330 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 1 ); \
331 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 2 )
332
333 #define ICV_MEAN_SDV_EXIT_C4( total, sqtotal ) \
334 ICV_MEAN_SDV_EXIT_COMMON(); \
335 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 0 ); \
336 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 1 ); \
337 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 2 ); \
338 ICV_MEAN_SDV_EXIT_CN( total, sqtotal, 3 )
339
340 ////////////////////////////////////// update macros /////////////////////////////////////
341
342 #define ICV_MEAN_SDV_UPDATE_COMMON( block_size )\
343 remaining = block_size
344
345 #define ICV_MEAN_SDV_UPDATE_C1( block_size ) \
346 ICV_MEAN_SDV_UPDATE_COMMON( block_size ); \
347 sum0 += s0; sqsum0 += sq0; \
348 s0 = 0; sq0 = 0
349
350 #define ICV_MEAN_SDV_UPDATE_C2( block_size ) \
351 ICV_MEAN_SDV_UPDATE_COMMON( block_size ); \
352 sum0 += s0; sqsum0 += sq0; \
353 sum1 += s1; sqsum1 += sq1; \
354 s0 = s1 = 0; sq0 = sq1 = 0
355
356 #define ICV_MEAN_SDV_UPDATE_C3( block_size ) \
357 ICV_MEAN_SDV_UPDATE_COMMON( block_size ); \
358 sum0 += s0; sqsum0 += sq0; \
359 sum1 += s1; sqsum1 += sq1; \
360 sum2 += s2; sqsum2 += sq2; \
361 s0 = s1 = s2 = 0; sq0 = sq1 = sq2 = 0
362
363 #define ICV_MEAN_SDV_UPDATE_C4( block_size ) \
364 ICV_MEAN_SDV_UPDATE_COMMON( block_size ); \
365 sum0 += s0; sqsum0 += sq0; \
366 sum1 += s1; sqsum1 += sq1; \
367 sum2 += s2; sqsum2 += sq2; \
368 sum3 += s3; sqsum3 += sq3; \
369 s0 = s1 = s2 = s3 = 0; sq0 = sq1 = sq2 = sq3 = 0
370
371
372
373 #define ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, cn, arrtype, \
374 sumtype, sqsumtype, worktype, \
375 sqworktype, block_size, sqr_macro ) \
376 IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##R, \
377 ( const arrtype* src, int step, \
378 CvSize size, double* mean, double* sdv ), \
379 (src, step, size, mean, sdv) ) \
380 { \
381 ICV_MEAN_SDV_ENTRY_BLOCK_C##cn( sumtype, sqsumtype, \
382 worktype, sqworktype, (block_size)*(cn) ); \
383 pix = size.width * size.height; \
384 size.width *= (cn); \
385 \
386 for( ; size.height--; src += step ) \
387 { \
388 int x = 0; \
389 while( x < size.width ) \
390 { \
391 int limit = MIN( remaining, size.width - x ); \
392 remaining -= limit; \
393 limit += x; \
394 ICV_MEAN_SDV_CASE_C##cn( worktype, sqworktype, \
395 sqr_macro, limit ); \
396 if( remaining == 0 ) \
397 { \
398 ICV_MEAN_SDV_UPDATE_C##cn( (block_size)*(cn) ); \
399 } \
400 } \
401 } \
402 \
403 ICV_MEAN_SDV_UPDATE_C##cn(0); \
404 ICV_MEAN_SDV_EXIT_C##cn( sum, sqsum ); \
405 return CV_OK; \
406 }
407
408
409 #define ICV_DEF_MEAN_SDV_FUNC_2D( flavor, cn, arrtype, \
410 sumtype, sqsumtype, worktype ) \
411 IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##R, \
412 ( const arrtype* src, int step, \
413 CvSize size, double* mean, double* sdv ), \
414 (src, step, size, mean, sdv) ) \
415 { \
416 ICV_MEAN_SDV_ENTRY_C##cn( sumtype, sqsumtype ); \
417 pix = size.width * size.height; \
418 size.width *= (cn); \
419 \
420 for( ; size.height--; src += step ) \
421 { \
422 int x = 0; \
423 ICV_MEAN_SDV_CASE_C##cn( worktype, sqsumtype, \
424 CV_SQR, size.width ); \
425 } \
426 \
427 ICV_MEAN_SDV_EXIT_C##cn( s, sq ); \
428 return CV_OK; \
429 }
430
431
432 #define ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D_COI( flavor, arrtype, \
433 sumtype, sqsumtype, worktype, \
434 sqworktype, block_size, sqr_macro ) \
435 static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCR \
436 ( const arrtype* src, int step, \
437 CvSize size, int cn, int coi, \
438 double* mean, double* sdv ) \
439 { \
440 ICV_MEAN_SDV_ENTRY_BLOCK_C1( sumtype, sqsumtype, \
441 worktype, sqworktype, (block_size)*(cn) ); \
442 pix = size.width * size.height; \
443 size.width *= (cn); \
444 src += coi - 1; \
445 \
446 for( ; size.height--; src += step ) \
447 { \
448 int x = 0; \
449 while( x < size.width ) \
450 { \
451 int limit = MIN( remaining, size.width - x ); \
452 remaining -= limit; \
453 limit += x; \
454 ICV_MEAN_SDV_COI_CASE( worktype, sqworktype, \
455 sqr_macro, limit, cn); \
456 if( remaining == 0 ) \
457 { \
458 ICV_MEAN_SDV_UPDATE_C1( (block_size)*(cn) ); \
459 } \
460 } \
461 } \
462 \
463 ICV_MEAN_SDV_UPDATE_C1(0); \
464 ICV_MEAN_SDV_EXIT_C1( sum, sqsum ); \
465 return CV_OK; \
466 }
467
468
469 #define ICV_DEF_MEAN_SDV_FUNC_2D_COI( flavor, arrtype, \
470 sumtype, sqsumtype, worktype )\
471 static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCR \
472 ( const arrtype* src, int step, CvSize size,\
473 int cn, int coi, double* mean, double* sdv )\
474 { \
475 ICV_MEAN_SDV_ENTRY_C1( sumtype, sqsumtype ); \
476 pix = size.width * size.height; \
477 size.width *= (cn); \
478 src += coi - 1; \
479 \
480 for( ; size.height--; src += step ) \
481 { \
482 int x = 0; \
483 ICV_MEAN_SDV_COI_CASE( worktype, sqsumtype, \
484 CV_SQR, size.width, cn ); \
485 } \
486 \
487 ICV_MEAN_SDV_EXIT_C1( s, sq ); \
488 return CV_OK; \
489 }
490
491
492 #define ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, cn, \
493 arrtype, sumtype, sqsumtype, worktype, \
494 sqworktype, block_size, sqr_macro ) \
495 IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##MR, \
496 ( const arrtype* src, int step, \
497 const uchar* mask, int maskstep, \
498 CvSize size, double* mean, double* sdv ), \
499 (src, step, mask, maskstep, size, mean, sdv))\
500 { \
501 ICV_MEAN_SDV_ENTRY_BLOCK_C##cn( sumtype, sqsumtype, \
502 worktype, sqworktype, block_size ); \
503 pix = 0; \
504 \
505 for( ; size.height--; src += step, mask += maskstep ) \
506 { \
507 int x = 0; \
508 while( x < size.width ) \
509 { \
510 int limit = MIN( remaining, size.width - x ); \
511 remaining -= limit; \
512 limit += x; \
513 ICV_MEAN_SDV_MASK_CASE_C##cn( worktype, sqworktype, \
514 sqr_macro, limit ); \
515 if( remaining == 0 ) \
516 { \
517 ICV_MEAN_SDV_UPDATE_C##cn( block_size ); \
518 } \
519 } \
520 } \
521 \
522 ICV_MEAN_SDV_UPDATE_C##cn(0); \
523 ICV_MEAN_SDV_EXIT_C##cn( sum, sqsum ); \
524 return CV_OK; \
525 }
526
527
528 #define ICV_DEF_MEAN_SDV_MASK_FUNC_2D( flavor, cn, arrtype, \
529 sumtype, sqsumtype, worktype)\
530 IPCVAPI_IMPL( CvStatus, icvMean_StdDev_##flavor##_C##cn##MR, \
531 ( const arrtype* src, int step, \
532 const uchar* mask, int maskstep, \
533 CvSize size, double* mean, double* sdv ), \
534 (src, step, mask, maskstep, size, mean, sdv))\
535 { \
536 ICV_MEAN_SDV_ENTRY_C##cn( sumtype, sqsumtype ); \
537 pix = 0; \
538 \
539 for( ; size.height--; src += step, mask += maskstep ) \
540 { \
541 int x = 0; \
542 ICV_MEAN_SDV_MASK_CASE_C##cn( worktype, sqsumtype, \
543 CV_SQR, size.width ); \
544 } \
545 \
546 ICV_MEAN_SDV_EXIT_C##cn( s, sq ); \
547 return CV_OK; \
548 }
549
550
551 #define ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D_COI( flavor, \
552 arrtype, sumtype, sqsumtype, worktype, \
553 sqworktype, block_size, sqr_macro ) \
554 static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCMR \
555 ( const arrtype* src, int step, \
556 const uchar* mask, int maskstep, \
557 CvSize size, int cn, int coi, \
558 double* mean, double* sdv ) \
559 { \
560 ICV_MEAN_SDV_ENTRY_BLOCK_C1( sumtype, sqsumtype, \
561 worktype, sqworktype, block_size ); \
562 pix = 0; \
563 src += coi - 1; \
564 \
565 for( ; size.height--; src += step, mask += maskstep ) \
566 { \
567 int x = 0; \
568 while( x < size.width ) \
569 { \
570 int limit = MIN( remaining, size.width - x ); \
571 remaining -= limit; \
572 limit += x; \
573 ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqworktype, \
574 sqr_macro, limit, cn ); \
575 if( remaining == 0 ) \
576 { \
577 ICV_MEAN_SDV_UPDATE_C1( block_size ); \
578 } \
579 } \
580 } \
581 \
582 ICV_MEAN_SDV_UPDATE_C1(0); \
583 ICV_MEAN_SDV_EXIT_C1( sum, sqsum ); \
584 return CV_OK; \
585 }
586
587
588 #define ICV_DEF_MEAN_SDV_MASK_FUNC_2D_COI( flavor, arrtype, \
589 sumtype, sqsumtype, worktype ) \
590 static CvStatus CV_STDCALL icvMean_StdDev_##flavor##_CnCMR \
591 ( const arrtype* src, int step, \
592 const uchar* mask, int maskstep, \
593 CvSize size, int cn, int coi, \
594 double* mean, double* sdv ) \
595 { \
596 ICV_MEAN_SDV_ENTRY_C1( sumtype, sqsumtype ); \
597 pix = 0; \
598 src += coi - 1; \
599 \
600 for( ; size.height--; src += step, mask += maskstep ) \
601 { \
602 int x = 0; \
603 ICV_MEAN_SDV_MASK_COI_CASE( worktype, sqsumtype, \
604 CV_SQR, size.width, cn ); \
605 } \
606 \
607 ICV_MEAN_SDV_EXIT_C1( s, sq ); \
608 return CV_OK; \
609 }
610
611
612 #define ICV_DEF_MEAN_SDV_BLOCK_ALL( flavor, arrtype, sumtype, sqsumtype,\
613 worktype, sqworktype, block_size, sqr_macro)\
614 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 1, arrtype, sumtype, sqsumtype, \
615 worktype, sqworktype, block_size, sqr_macro)\
616 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 2, arrtype, sumtype, sqsumtype, \
617 worktype, sqworktype, block_size, sqr_macro)\
618 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 3, arrtype, sumtype, sqsumtype, \
619 worktype, sqworktype, block_size, sqr_macro)\
620 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D( flavor, 4, arrtype, sumtype, sqsumtype, \
621 worktype, sqworktype, block_size, sqr_macro)\
622 ICV_DEF_MEAN_SDV_BLOCK_FUNC_2D_COI( flavor, arrtype, sumtype, sqsumtype,\
623 worktype, sqworktype, block_size, sqr_macro)\
624 \
625 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 1, arrtype, sumtype, \
626 sqsumtype, worktype, sqworktype, block_size, sqr_macro ) \
627 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 2, arrtype, sumtype, \
628 sqsumtype, worktype, sqworktype, block_size, sqr_macro ) \
629 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 3, arrtype, sumtype, \
630 sqsumtype, worktype, sqworktype, block_size, sqr_macro ) \
631 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D( flavor, 4, arrtype, sumtype, \
632 sqsumtype, worktype, sqworktype, block_size, sqr_macro ) \
633 ICV_DEF_MEAN_SDV_MASK_BLOCK_FUNC_2D_COI( flavor, arrtype, sumtype, \
634 sqsumtype, worktype, sqworktype, block_size, sqr_macro )
635
636 #define ICV_DEF_MEAN_SDV_ALL( flavor, arrtype, sumtype, sqsumtype, worktype ) \
637 ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 1, arrtype, sumtype, sqsumtype, worktype ) \
638 ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 2, arrtype, sumtype, sqsumtype, worktype ) \
639 ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 3, arrtype, sumtype, sqsumtype, worktype ) \
640 ICV_DEF_MEAN_SDV_FUNC_2D( flavor, 4, arrtype, sumtype, sqsumtype, worktype ) \
641 ICV_DEF_MEAN_SDV_FUNC_2D_COI( flavor, arrtype, sumtype, sqsumtype, worktype ) \
642 \
643 ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 1, arrtype, sumtype, sqsumtype, worktype) \
644 ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 2, arrtype, sumtype, sqsumtype, worktype) \
645 ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 3, arrtype, sumtype, sqsumtype, worktype) \
646 ICV_DEF_MEAN_SDV_MASK_FUNC_2D(flavor, 4, arrtype, sumtype, sqsumtype, worktype) \
647 ICV_DEF_MEAN_SDV_MASK_FUNC_2D_COI( flavor, arrtype, sumtype, sqsumtype, worktype )
648
649
650 ICV_DEF_MEAN_SDV_BLOCK_ALL( 8u, uchar, int64, int64, unsigned, unsigned, 1 << 16, CV_SQR_8U )
651 ICV_DEF_MEAN_SDV_BLOCK_ALL( 16u, ushort, int64, int64, unsigned, int64, 1 << 16, CV_SQR )
652 ICV_DEF_MEAN_SDV_BLOCK_ALL( 16s, short, int64, int64, int, int64, 1 << 16, CV_SQR )
653
654 ICV_DEF_MEAN_SDV_ALL( 32s, int, double, double, double )
655 ICV_DEF_MEAN_SDV_ALL( 32f, float, double, double, double )
656 ICV_DEF_MEAN_SDV_ALL( 64f, double, double, double, double )
657
658 #define icvMean_StdDev_8s_C1R 0
659 #define icvMean_StdDev_8s_C2R 0
660 #define icvMean_StdDev_8s_C3R 0
661 #define icvMean_StdDev_8s_C4R 0
662 #define icvMean_StdDev_8s_CnCR 0
663
664 #define icvMean_StdDev_8s_C1MR 0
665 #define icvMean_StdDev_8s_C2MR 0
666 #define icvMean_StdDev_8s_C3MR 0
667 #define icvMean_StdDev_8s_C4MR 0
668 #define icvMean_StdDev_8s_CnCMR 0
669
CV_DEF_INIT_BIG_FUNC_TAB_2D(Mean_StdDev,R)670 CV_DEF_INIT_BIG_FUNC_TAB_2D( Mean_StdDev, R )
671 CV_DEF_INIT_FUNC_TAB_2D( Mean_StdDev, CnCR )
672 CV_DEF_INIT_BIG_FUNC_TAB_2D( Mean_StdDev, MR )
673 CV_DEF_INIT_FUNC_TAB_2D( Mean_StdDev, CnCMR )
674
675 CV_IMPL void
676 cvAvgSdv( const CvArr* img, CvScalar* _mean, CvScalar* _sdv, const void* mask )
677 {
678 CvScalar mean = {{0,0,0,0}};
679 CvScalar sdv = {{0,0,0,0}};
680
681 static CvBigFuncTable meansdv_tab;
682 static CvFuncTable meansdvcoi_tab;
683 static CvBigFuncTable meansdvmask_tab;
684 static CvFuncTable meansdvmaskcoi_tab;
685 static int inittab = 0;
686
687 CV_FUNCNAME("cvMean_StdDev");
688
689 __BEGIN__;
690
691 int type, coi = 0;
692 int mat_step, mask_step = 0;
693 CvSize size;
694 CvMat stub, maskstub, *mat = (CvMat*)img, *matmask = (CvMat*)mask;
695
696 if( !inittab )
697 {
698 icvInitMean_StdDevRTable( &meansdv_tab );
699 icvInitMean_StdDevCnCRTable( &meansdvcoi_tab );
700 icvInitMean_StdDevMRTable( &meansdvmask_tab );
701 icvInitMean_StdDevCnCMRTable( &meansdvmaskcoi_tab );
702 inittab = 1;
703 }
704
705 if( !CV_IS_MAT(mat) )
706 CV_CALL( mat = cvGetMat( mat, &stub, &coi ));
707
708 type = CV_MAT_TYPE( mat->type );
709
710 if( CV_MAT_CN(type) > 4 && coi == 0 )
711 CV_ERROR( CV_StsOutOfRange, "The input array must have at most 4 channels unless COI is set" );
712
713 size = cvGetMatSize( mat );
714 mat_step = mat->step;
715
716 if( !mask )
717 {
718 if( CV_IS_MAT_CONT( mat->type ))
719 {
720 size.width *= size.height;
721 size.height = 1;
722 mat_step = CV_STUB_STEP;
723 }
724
725 if( CV_MAT_CN(type) == 1 || coi == 0 )
726 {
727 CvFunc2D_1A2P func = (CvFunc2D_1A2P)(meansdv_tab.fn_2d[type]);
728
729 if( !func )
730 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
731
732 IPPI_CALL( func( mat->data.ptr, mat_step, size, mean.val, sdv.val ));
733 }
734 else
735 {
736 CvFunc2DnC_1A2P func = (CvFunc2DnC_1A2P)
737 (meansdvcoi_tab.fn_2d[CV_MAT_DEPTH(type)]);
738
739 if( !func )
740 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
741
742 IPPI_CALL( func( mat->data.ptr, mat_step, size,
743 CV_MAT_CN(type), coi, mean.val, sdv.val ));
744 }
745 }
746 else
747 {
748 CV_CALL( matmask = cvGetMat( matmask, &maskstub ));
749
750 mask_step = matmask->step;
751
752 if( !CV_IS_MASK_ARR( matmask ))
753 CV_ERROR( CV_StsBadMask, "" );
754
755 if( !CV_ARE_SIZES_EQ( mat, matmask ))
756 CV_ERROR( CV_StsUnmatchedSizes, "" );
757
758 if( CV_IS_MAT_CONT( mat->type & matmask->type ))
759 {
760 size.width *= size.height;
761 size.height = 1;
762 mat_step = mask_step = CV_STUB_STEP;
763 }
764
765 if( CV_MAT_CN(type) == 1 || coi == 0 )
766 {
767 CvFunc2D_2A2P func = (CvFunc2D_2A2P)(meansdvmask_tab.fn_2d[type]);
768
769 if( !func )
770 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
771
772 IPPI_CALL( func( mat->data.ptr, mat_step, matmask->data.ptr,
773 mask_step, size, mean.val, sdv.val ));
774 }
775 else
776 {
777 CvFunc2DnC_2A2P func = (CvFunc2DnC_2A2P)
778 (meansdvmaskcoi_tab.fn_2d[CV_MAT_DEPTH(type)]);
779
780 if( !func )
781 CV_ERROR( CV_StsBadArg, cvUnsupportedFormat );
782
783 IPPI_CALL( func( mat->data.ptr, mat_step,
784 matmask->data.ptr, mask_step,
785 size, CV_MAT_CN(type), coi, mean.val, sdv.val ));
786 }
787 }
788
789 __END__;
790
791 if( _mean )
792 *_mean = mean;
793
794 if( _sdv )
795 *_sdv = sdv;
796 }
797
798
799 /* End of file */
800