1 /*M///////////////////////////////////////////////////////////////////////////////////////
3 // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
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.
10 // Intel License Agreement
11 // For Open Source Computer Vision Library
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
19 // * Redistribution's of source code must retain the above copyright notice,
20 // this list of conditions and the following disclaimer.
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.
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.
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.
44 static const CvSize filter_sizes[] = {{30,30}, {320, 240}, {720,480}, {-1,-1}};
45 static const CvSize filter_whole_sizes[] = {{320,240}, {320, 240}, {720,480}, {-1,-1}};
46 static const int filter_depths[] = { CV_8U, CV_16U, CV_32F, -1 };
47 static const int filter_channels[] = { 1, 3, 4, -1 };
49 class CV_FilterBaseTestImpl : public CvArrTest
52 CV_FilterBaseTestImpl( const char* test_name, const char* test_funcs, bool _fp_kernel );
55 int prepare_test_case( int test_case_idx );
56 void prepare_to_validation( int /*test_case_idx*/ );
57 int read_params( CvFileStorage* fs );
58 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
59 void get_minmax_bounds( int i, int j, int type, CvScalar* low, CvScalar* high );
60 int write_default_params(CvFileStorage* fs);
63 int max_aperture_size;
69 CV_FilterBaseTestImpl::CV_FilterBaseTestImpl( const char* test_name, const char* test_funcs, bool _fp_kernel )
70 : CvArrTest( test_name, test_funcs, "" ), fp_kernel(_fp_kernel)
72 test_array[INPUT].push(NULL);
73 test_array[INPUT].push(NULL);
74 test_array[TEMP].push(NULL);
75 test_array[OUTPUT].push(NULL);
76 test_array[REF_OUTPUT].push(NULL);
77 max_aperture_size = 13;
79 aperture_size = cvSize(0,0);
80 anchor = cvPoint(0,0);
81 element_wise_relative_error = false;
83 size_list = filter_sizes;
84 whole_size_list = filter_whole_sizes;
85 depth_list = filter_depths;
86 cn_list = filter_channels;
90 int CV_FilterBaseTestImpl::read_params( CvFileStorage* fs )
92 int code = CvArrTest::read_params( fs );
96 if( ts->get_testing_mode() == CvTS::CORRECTNESS_CHECK_MODE )
98 max_aperture_size = cvReadInt( find_param( fs, "max_aperture_size" ), max_aperture_size );
99 max_aperture_size = cvTsClipInt( max_aperture_size, 1, 100 );
106 int CV_FilterBaseTestImpl::write_default_params( CvFileStorage* fs )
108 int code = CvArrTest::write_default_params( fs );
112 if( ts->get_testing_mode() == CvTS::CORRECTNESS_CHECK_MODE )
114 write_param( fs, "max_aperture_size", max_aperture_size );
121 void CV_FilterBaseTestImpl::get_minmax_bounds( int i, int j, int type, CvScalar* low, CvScalar* high )
123 CvArrTest::get_minmax_bounds( i, j, type, low, high );
130 if( ts->get_testing_mode() == CvTS::TIMING_MODE )
132 *low = cvScalarAll(-1);
133 *high = cvScalarAll(1);
137 CvRNG* rng = ts->get_rng();
138 double val = exp( cvTsRandReal(rng)*10 - 4 );
139 *low = cvScalarAll(-val);
140 *high = cvScalarAll(val);
145 *low = cvScalarAll(0);
146 *high = cvScalarAll(2);
149 else if( CV_MAT_DEPTH(type) == CV_32F )
151 *low = cvScalarAll(-10.);
152 *high = cvScalarAll(10.);
158 void CV_FilterBaseTestImpl::get_test_array_types_and_sizes( int test_case_idx,
159 CvSize** sizes, int** types )
161 CvRNG* rng = ts->get_rng();
162 int depth = cvTsRandInt(rng) % CV_32F;
163 int cn = cvTsRandInt(rng) % 3 + 1;
164 CvArrTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
165 depth += depth == CV_8S;
168 types[INPUT][0] = types[OUTPUT][0] = types[REF_OUTPUT][0] = types[TEMP][0] = CV_MAKETYPE(depth, cn);
170 aperture_size.width = cvTsRandInt(rng) % max_aperture_size + 1;
171 aperture_size.height = cvTsRandInt(rng) % max_aperture_size + 1;
172 anchor.x = cvTsRandInt(rng) % aperture_size.width;
173 anchor.y = cvTsRandInt(rng) % aperture_size.height;
175 types[INPUT][1] = fp_kernel ? CV_32FC1 : CV_8UC1;
176 sizes[INPUT][1] = aperture_size;
177 sizes[TEMP][0].width += aperture_size.width - 1;
178 sizes[TEMP][0].height += aperture_size.height - 1;
180 inplace = cvTsRandInt(rng) % 2 != 0;
184 int CV_FilterBaseTestImpl::prepare_test_case( int test_case_idx )
186 int code = CvArrTest::prepare_test_case( test_case_idx );
189 if( inplace && CV_ARE_TYPES_EQ(&test_mat[INPUT][0],&test_mat[OUTPUT][0]))
190 cvTsCopy( &test_mat[INPUT][0], &test_mat[OUTPUT][0] );
198 void CV_FilterBaseTestImpl::prepare_to_validation( int /*test_case_idx*/ )
200 CvMat* src = &test_mat[INPUT][0];
202 if( !CV_ARE_TYPES_EQ( src, &test_mat[TEMP][0] ))
204 cvTsConvert( src, &test_mat[REF_OUTPUT][0] );
205 src = &test_mat[REF_OUTPUT][0];
207 cvTsPrepareToFilter( src, &test_mat[TEMP][0],
208 anchor, CV_TS_BORDER_REPLICATE );
212 CV_FilterBaseTestImpl filter_base( "filter", "", false );
215 class CV_FilterBaseTest : public CV_FilterBaseTestImpl
218 CV_FilterBaseTest( const char* test_name, const char* test_funcs, bool _fp_kernel );
222 CV_FilterBaseTest::CV_FilterBaseTest( const char* test_name, const char* test_funcs, bool _fp_kernel )
223 : CV_FilterBaseTestImpl( test_name, test_funcs, _fp_kernel )
232 /////////////////////////
234 static const char* morph_param_names[] = { "mask_size", "shape", "size", "channels", "depth", 0 };
235 static const int morph_depths[] = { CV_8U, CV_32F, -1 };
236 static const int morph_mask_size[] = { 3, 5, 11 };
237 static const char* morph_mask_shape[] = { "rect", "ellipse", 0 };
239 class CV_MorphologyBaseTestImpl : public CV_FilterBaseTest
242 CV_MorphologyBaseTestImpl( const char* test_name, const char* test_funcs, int optype );
245 void prepare_to_validation( int test_case_idx );
246 int prepare_test_case( int test_case_idx );
247 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
248 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
249 CvSize** whole_sizes, bool *are_images );
250 void print_timing_params( int test_case_idx, char* ptr, int params_left );
251 double get_success_error_level( int test_case_idx, int i, int j );
252 int write_default_params(CvFileStorage* fs);
255 IplConvKernel* element;
259 CV_MorphologyBaseTestImpl::CV_MorphologyBaseTestImpl( const char* test_name, const char* test_funcs, int _optype )
260 : CV_FilterBaseTest( test_name, test_funcs, false ), optype(_optype)
264 size_list = filter_sizes;
265 whole_size_list = filter_whole_sizes;
266 depth_list = morph_depths;
267 cn_list = filter_channels;
273 int CV_MorphologyBaseTestImpl::write_default_params( CvFileStorage* fs )
275 int code = CV_FilterBaseTest::write_default_params( fs );
276 if( code >= 0 && ts->get_testing_mode() == CvTS::TIMING_MODE && strcmp(tested_functions,"") == 0 )
278 start_write_param( fs );
279 write_int_list( fs, "mask_size", morph_mask_size, CV_DIM(morph_mask_size) );
280 write_string_list( fs, "shape", morph_mask_shape );
286 void CV_MorphologyBaseTestImpl::get_test_array_types_and_sizes( int test_case_idx,
287 CvSize** sizes, int** types )
289 CvRNG* rng = ts->get_rng();
290 CV_FilterBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
291 int depth = cvTsRandInt(rng) % 2 ? CV_32F : CV_8U;
292 int cn = CV_MAT_CN(types[INPUT][0]);
294 types[INPUT][0] = types[OUTPUT][0] = types[REF_OUTPUT][0] = types[TEMP][0] = CV_MAKETYPE(depth, cn);
295 shape = cvTsRandInt(rng) % 4;
297 shape = CV_SHAPE_CUSTOM;
299 sizes[INPUT][1] = cvSize(0,0);
303 void CV_MorphologyBaseTestImpl::get_timing_test_array_types_and_sizes( int test_case_idx,
304 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
306 CV_FilterBaseTest::get_timing_test_array_types_and_sizes( test_case_idx, sizes, types,
307 whole_sizes, are_images );
308 const char* shape_str = cvReadString( find_timing_param( "shape" ), "rect" );
309 shape = strcmp( shape_str, "rect" ) == 0 ? CV_SHAPE_RECT : CV_SHAPE_ELLIPSE;
310 aperture_size.width = cvReadInt( find_timing_param( "mask_size" ), 3 );
311 aperture_size.height = aperture_size.width;
312 anchor.x = anchor.y = aperture_size.width / 2;
316 void CV_MorphologyBaseTestImpl::print_timing_params( int test_case_idx, char* ptr, int params_left )
318 sprintf( ptr, "%dx%d,", aperture_size.width, aperture_size.height );
320 sprintf( ptr, "%s,", shape == CV_SHAPE_RECT ? "rect" : "ellipse" );
324 CV_FilterBaseTest::print_timing_params( test_case_idx, ptr, params_left );
328 double CV_MorphologyBaseTestImpl::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
334 int CV_MorphologyBaseTestImpl::prepare_test_case( int test_case_idx )
336 int code = CV_FilterBaseTest::prepare_test_case( test_case_idx );
342 if( shape == CV_SHAPE_CUSTOM )
344 eldata = (int*)alloca( aperture_size.width*aperture_size.height*sizeof(eldata[0]) );
345 uchar* src = test_mat[INPUT][1].data.ptr;
346 int srcstep = test_mat[INPUT][1].step;
347 int i, j, nonzero = 0;
349 for( i = 0; i < aperture_size.height; i++ )
351 for( j = 0; j < aperture_size.width; j++ )
353 eldata[i*aperture_size.width + j] = src[i*srcstep + j];
354 nonzero += src[i*srcstep + j] != 0;
359 eldata[anchor.y*aperture_size.width + anchor.x] = 1;
362 cvReleaseStructuringElement( &element );
363 element = cvCreateStructuringElementEx( aperture_size.width, aperture_size.height,
364 anchor.x, anchor.y, shape, eldata );
369 void CV_MorphologyBaseTestImpl::prepare_to_validation( int test_case_idx )
371 CV_FilterBaseTest::prepare_to_validation( test_case_idx );
372 cvTsMinMaxFilter( &test_mat[TEMP][0], &test_mat[REF_OUTPUT][0], element, optype );
373 cvReleaseStructuringElement( &element );
377 CV_MorphologyBaseTestImpl morph( "morph", "", -1 );
380 class CV_MorphologyBaseTest : public CV_MorphologyBaseTestImpl
383 CV_MorphologyBaseTest( const char* test_name, const char* test_funcs, int optype );
387 CV_MorphologyBaseTest::CV_MorphologyBaseTest( const char* test_name, const char* test_funcs, int _optype )
388 : CV_MorphologyBaseTestImpl( test_name, test_funcs, _optype )
390 default_timing_param_names = morph_param_names;
397 /////////////// erode ///////////////
399 class CV_ErodeTest : public CV_MorphologyBaseTest
408 CV_ErodeTest::CV_ErodeTest()
409 : CV_MorphologyBaseTest( "morph-erode", "cvErode", CV_TS_MIN )
414 void CV_ErodeTest::run_func()
416 cvErode( inplace ? test_array[OUTPUT][0] : test_array[INPUT][0],
417 test_array[OUTPUT][0], element, 1 );
420 CV_ErodeTest erode_test;
423 /////////////// dilate ///////////////
425 class CV_DilateTest : public CV_MorphologyBaseTest
434 CV_DilateTest::CV_DilateTest()
435 : CV_MorphologyBaseTest( "morph-dilate", "cvDilate", CV_TS_MAX )
440 void CV_DilateTest::run_func()
442 cvDilate( inplace ? test_array[OUTPUT][0] : test_array[INPUT][0],
443 test_array[OUTPUT][0], element, 1 );
446 CV_DilateTest dilate_test;
449 /////////////// generic filter ///////////////
451 static const char* filter_generic_param_names[] = { "mask_size", "size", "channels", "depth", 0 };
453 class CV_FilterTest : public CV_FilterBaseTest
459 void prepare_to_validation( int test_case_idx );
461 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
462 double get_success_error_level( int test_case_idx, int i, int j );
464 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
465 CvSize** whole_sizes, bool *are_images );
466 void print_timing_params( int test_case_idx, char* ptr, int params_left );
467 int write_default_params(CvFileStorage* fs);
471 CV_FilterTest::CV_FilterTest()
472 : CV_FilterBaseTest( "filter-generic", "cvFilter2D", true )
474 default_timing_param_names = filter_generic_param_names;
478 int CV_FilterTest::write_default_params( CvFileStorage* fs )
480 int code = CV_FilterBaseTest::write_default_params( fs );
481 if( code >= 0 && ts->get_testing_mode() == CvTS::TIMING_MODE )
483 start_write_param( fs );
484 write_int_list( fs, "mask_size", morph_mask_size, CV_DIM(morph_mask_size) );
490 void CV_FilterTest::get_test_array_types_and_sizes( int test_case_idx,
491 CvSize** sizes, int** types )
493 CV_FilterBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
494 CvRNG* rng = ts->get_rng();
495 int depth = cvTsRandInt(rng)%3;
496 int cn = CV_MAT_CN(types[INPUT][0]);
497 depth = depth == 0 ? CV_8U : depth == 1 ? CV_16U : CV_32F;
498 types[INPUT][0] = types[OUTPUT][0] = types[REF_OUTPUT][0] = types[TEMP][0] = CV_MAKETYPE(depth, cn);
502 void CV_FilterTest::get_timing_test_array_types_and_sizes( int test_case_idx,
503 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
505 CV_FilterBaseTest::get_timing_test_array_types_and_sizes( test_case_idx, sizes, types,
506 whole_sizes, are_images );
507 aperture_size.width = cvReadInt( find_timing_param( "mask_size" ), 3 );
508 aperture_size.height = aperture_size.width;
509 anchor.x = anchor.y = aperture_size.width / 2;
510 sizes[INPUT][1] = aperture_size;
511 types[INPUT][1] = CV_32FC1;
515 void CV_FilterTest::print_timing_params( int test_case_idx, char* ptr, int params_left )
517 sprintf( ptr, "%dx%d,", aperture_size.width, aperture_size.height );
521 CV_FilterBaseTest::print_timing_params( test_case_idx, ptr, params_left );
525 double CV_FilterTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
527 int depth = CV_MAT_DEPTH(test_mat[INPUT][0].type);
528 return depth <= CV_8S ? 2 : depth <= CV_32S ? 32 :
529 depth == CV_32F ? 1e-5 : 1e-10;
533 void CV_FilterTest::run_func()
535 cvFilter2D( inplace ? test_array[OUTPUT][0] : test_array[INPUT][0],
536 test_array[OUTPUT][0], &test_mat[INPUT][1], anchor );
540 void CV_FilterTest::prepare_to_validation( int test_case_idx )
542 CV_FilterBaseTest::prepare_to_validation( test_case_idx );
543 cvTsConvolve2D( &test_mat[TEMP][0], &test_mat[REF_OUTPUT][0], &test_mat[INPUT][1], anchor );
546 CV_FilterTest filter;
549 ////////////////////////
551 static const int laplace_aperture[] = { 3, 5, 7 };
552 static const int sobel_aperture[] = { -1, 3, 5, 7 };
553 static const char* laplace_param_names[] = { "aperture", "size", "depth", 0 };
554 static const char* sobel_param_names[] = { "deriv_type", "aperture", "size", "depth", 0 };
555 static const char* sobel_deriv_type[] = { "dx", "dy", "d2x", "d2y", "dxdy", 0 };
557 class CV_DerivBaseTest : public CV_FilterBaseTest
560 CV_DerivBaseTest( const char* test_name, const char* test_funcs );
562 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
563 double get_success_error_level( int test_case_idx, int i, int j );
564 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
565 CvSize** whole_sizes, bool *are_images );
570 CV_DerivBaseTest::CV_DerivBaseTest( const char* test_name, const char* test_funcs )
571 : CV_FilterBaseTest( test_name, test_funcs, true )
573 max_aperture_size = 7;
574 depth_list = morph_depths;
579 void CV_DerivBaseTest::get_test_array_types_and_sizes( int test_case_idx,
580 CvSize** sizes, int** types )
582 CvRNG* rng = ts->get_rng();
583 CV_FilterBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
584 int depth = cvTsRandInt(rng) % 2;
585 depth = depth == 0 ? CV_8U : CV_32F;
586 types[INPUT][0] = CV_MAKETYPE(depth,1);
587 types[TEMP][0] = types[OUTPUT][0] = types[REF_OUTPUT][0] = CV_MAKETYPE(depth==CV_8U?CV_16S:CV_32F,1);
588 _aperture_size = (cvTsRandInt(rng)%5)*2 - 1;
589 sizes[INPUT][1] = aperture_size = cvSize(_aperture_size, _aperture_size);
593 double CV_DerivBaseTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
595 int depth = CV_MAT_DEPTH(test_mat[INPUT][0].type);
596 return depth <= CV_8S ? 1 : 5e-4;
600 void CV_DerivBaseTest::get_timing_test_array_types_and_sizes( int test_case_idx,
601 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
603 CV_FilterBaseTest::get_timing_test_array_types_and_sizes( test_case_idx, sizes, types,
604 whole_sizes, are_images );
605 _aperture_size = cvReadInt( find_timing_param( "aperture" ), 3 );
606 aperture_size.width = aperture_size.height = _aperture_size < 0 ? 3 : _aperture_size;
607 anchor.x = anchor.y = aperture_size.width / 2;
608 sizes[INPUT][1] = aperture_size;
609 types[INPUT][1] = CV_32FC1;
610 types[OUTPUT][0] = types[INPUT][0] == CV_8UC1 ? CV_16SC1 : types[INPUT][0];
614 /////////////// sobel ///////////////
616 class CV_SobelTest : public CV_DerivBaseTest
622 int prepare_test_case( int test_case_idx );
623 void prepare_to_validation( int test_case_idx );
625 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
626 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
627 CvSize** whole_sizes, bool *are_images );
628 int write_default_params( CvFileStorage* fs );
629 void print_timing_params( int test_case_idx, char* ptr, int params_left );
636 CV_SobelTest::CV_SobelTest() : CV_DerivBaseTest( "filter-sobel", "cvSobel" )
639 default_timing_param_names = sobel_param_names;
643 int CV_SobelTest::write_default_params( CvFileStorage* fs )
645 int code = CV_DerivBaseTest::write_default_params( fs );
646 if( code >= 0 && ts->get_testing_mode() == CvTS::TIMING_MODE )
648 start_write_param( fs );
649 write_int_list( fs, "aperture", sobel_aperture, CV_DIM(sobel_aperture) );
650 write_string_list( fs, "deriv_type", sobel_deriv_type );
656 void CV_SobelTest::get_test_array_types_and_sizes( int test_case_idx,
657 CvSize** sizes, int** types )
659 CvRNG* rng = ts->get_rng();
660 CV_DerivBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
661 int max_d = _aperture_size > 0 ? 2 : 1;
662 origin = cvTsRandInt(rng) % 2;
663 dx = cvTsRandInt(rng) % (max_d + 1);
664 dy = cvTsRandInt(rng) % (max_d + 1 - dx);
665 if( dx == 0 && dy == 0 )
667 if( cvTsRandInt(rng) % 2 )
670 CV_SWAP( dx, dy, t );
673 if( _aperture_size < 0 )
674 aperture_size = cvSize(3, 3);
675 else if( _aperture_size == 1 )
678 aperture_size = cvSize(1, 3);
680 aperture_size = cvSize(3, 1);
684 aperture_size = cvSize(3, 3);
688 aperture_size = cvSize(_aperture_size, _aperture_size);
690 sizes[INPUT][1] = aperture_size;
691 sizes[TEMP][0].width = sizes[INPUT][0].width + aperture_size.width - 1;
692 sizes[TEMP][0].height = sizes[INPUT][0].height + aperture_size.height - 1;
693 anchor.x = aperture_size.width / 2;
694 anchor.y = aperture_size.height / 2;
698 void CV_SobelTest::get_timing_test_array_types_and_sizes( int test_case_idx,
699 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
701 CV_DerivBaseTest::get_timing_test_array_types_and_sizes( test_case_idx, sizes, types,
702 whole_sizes, are_images );
703 //_aperture_size = cvReadInt( find_timing_param( "mask_size" ), 3 );
704 const char* mask_type = cvReadString( find_timing_param( "deriv_type" ), "dx" );
705 if( strcmp( mask_type, "dx" ) == 0 )
707 else if( strcmp( mask_type, "dy" ) == 0 )
709 else if( strcmp( mask_type, "d2x" ) == 0 )
711 else if( strcmp( mask_type, "d2y" ) == 0 )
717 aperture_size.width = aperture_size.height = _aperture_size < 0 ? 3 : _aperture_size;
718 anchor.x = anchor.y = aperture_size.width / 2;
719 sizes[INPUT][1] = aperture_size;
720 types[INPUT][1] = CV_32FC1;
721 types[OUTPUT][0] = types[INPUT][0] == CV_8UC1 ? CV_16SC1 : types[INPUT][0];
725 int CV_SobelTest::prepare_test_case( int test_case_idx )
727 int code = CV_DerivBaseTest::prepare_test_case( test_case_idx );
731 if( _aperture_size < 0 && ((dx != 1 || dy != 0) && (dx != 0 || dy != 1)) )
736 src = inplace ? &test_mat[OUTPUT][0] : &test_mat[INPUT][0];
737 cvGetImage( src, &img );
742 src = inplace ? test_array[OUTPUT][0] : test_array[INPUT][0];
748 void CV_SobelTest::print_timing_params( int test_case_idx, char* ptr, int params_left )
750 const char* mask_type = cvReadString( find_timing_param( "deriv_type" ), "dx" );
751 sprintf( ptr, "%dx%d,%s_%s,", aperture_size.width, aperture_size.height,
752 _aperture_size > 0 ? "Sobel" : "Scharr", mask_type );
756 CV_DerivBaseTest::print_timing_params( test_case_idx, ptr, params_left );
760 void CV_SobelTest::run_func()
762 cvSobel( src, test_array[OUTPUT][0], dx, dy, _aperture_size );
766 static void cvTsCalcSobelKernel1D( int order, int _aperture_size, int size, int* kernel )
768 int i, j, oldval, newval;
770 if( _aperture_size < 0 )
772 static const int scharr[] = { 3, 10, 3, -1, 0, 1 };
774 memcpy( kernel, scharr + order*3, 3*sizeof(scharr[0]));
778 memset( kernel + 1, 0, size * sizeof(kernel[0]));
781 for( i = 0; i < size - order - 1; i++ )
784 for( j = 1; j <= size; j++ )
786 newval = kernel[j] + kernel[j-1];
787 kernel[j-1] = oldval;
792 for( i = 0; i < order; i++ )
795 for( j = 1; j <= size; j++ )
797 newval = kernel[j-1] - kernel[j];
798 kernel[j-1] = oldval;
805 void cvTsCalcSobelKernel2D( int dx, int dy, int _aperture_size, int origin, CvMat* kernel )
808 int* kx = (int*)alloca( (kernel->cols+1)*sizeof(kx[0]) );
809 int* ky = (int*)alloca( (kernel->rows+1)*sizeof(ky[0]) );
811 assert( CV_MAT_TYPE(kernel->type) == CV_32F );
813 cvTsCalcSobelKernel1D( dx, _aperture_size, kernel->cols, kx );
814 cvTsCalcSobelKernel1D( dy, _aperture_size, kernel->rows, ky );
816 for( i = 0; i < kernel->rows; i++ )
818 float* kdata = (float*)(kernel->data.ptr + i*kernel->step);
819 float ay = (float)ky[i]*(origin && (dy & 1) ? -1 : 1);
820 for( j = 0; j < kernel->cols; j++ )
828 void CV_SobelTest::prepare_to_validation( int test_case_idx )
830 CV_DerivBaseTest::prepare_to_validation( test_case_idx );
831 cvTsCalcSobelKernel2D( dx, dy, _aperture_size, origin, &test_mat[INPUT][1] );
832 cvTsConvolve2D( &test_mat[TEMP][0], &test_mat[REF_OUTPUT][0], &test_mat[INPUT][1], anchor );
835 CV_SobelTest sobel_test;
838 /////////////// laplace ///////////////
840 class CV_LaplaceTest : public CV_DerivBaseTest
846 int prepare_test_case( int test_case_idx );
847 void prepare_to_validation( int test_case_idx );
849 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
850 int write_default_params( CvFileStorage* fs );
851 void print_timing_params( int test_case_idx, char* ptr, int params_left );
855 CV_LaplaceTest::CV_LaplaceTest() : CV_DerivBaseTest( "filter-laplace", "cvLaplace" )
857 default_timing_param_names = laplace_param_names;
861 int CV_LaplaceTest::write_default_params( CvFileStorage* fs )
863 int code = CV_DerivBaseTest::write_default_params( fs );
864 if( code >= 0 && ts->get_testing_mode() == CvTS::TIMING_MODE )
866 start_write_param( fs );
867 write_int_list( fs, "aperture", laplace_aperture, CV_DIM(laplace_aperture) );
873 void CV_LaplaceTest::get_test_array_types_and_sizes( int test_case_idx,
874 CvSize** sizes, int** types )
876 CV_DerivBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
877 if( _aperture_size <= 1 )
879 if( _aperture_size < 0 )
881 aperture_size = cvSize(3, 3);
884 aperture_size = cvSize(_aperture_size, _aperture_size);
886 sizes[INPUT][1] = aperture_size;
887 sizes[TEMP][0].width = sizes[INPUT][0].width + aperture_size.width - 1;
888 sizes[TEMP][0].height = sizes[INPUT][0].height + aperture_size.height - 1;
889 anchor.x = aperture_size.width / 2;
890 anchor.y = aperture_size.height / 2;
894 void CV_LaplaceTest::run_func()
896 cvLaplace( inplace ? test_array[OUTPUT][0] : test_array[INPUT][0],
897 test_array[OUTPUT][0], _aperture_size );
901 static void cvTsCalcLaplaceKernel2D( int _aperture_size, CvMat* kernel )
904 int* kx = (int*)alloca( (kernel->cols+1)*sizeof(kx[0]) );
905 int* ky = (int*)alloca( (kernel->rows+1)*sizeof(ky[0]) );
907 cvTsCalcSobelKernel1D( 2, _aperture_size, kernel->cols, kx );
908 if( _aperture_size > 1 )
909 cvTsCalcSobelKernel1D( 0, _aperture_size, kernel->rows, ky );
911 ky[0] = ky[2] = 0, ky[1] = 1;
913 for( i = 0; i < kernel->rows; i++ )
915 float* kdata = (float*)(kernel->data.ptr + i*kernel->step);
916 for( j = 0; j < kernel->cols; j++ )
918 kdata[j] = (float)(kx[j]*ky[i] + kx[i]*ky[j]);
924 int CV_LaplaceTest::prepare_test_case( int test_case_idx )
926 int code = CV_DerivBaseTest::prepare_test_case( test_case_idx );
927 return _aperture_size < 0 ? 0 : code;
931 void CV_LaplaceTest::print_timing_params( int test_case_idx, char* ptr, int params_left )
933 sprintf( ptr, "%dx%d,", aperture_size.width, aperture_size.height );
937 CV_DerivBaseTest::print_timing_params( test_case_idx, ptr, params_left );
941 void CV_LaplaceTest::prepare_to_validation( int test_case_idx )
943 CV_DerivBaseTest::prepare_to_validation( test_case_idx );
944 cvTsCalcLaplaceKernel2D( _aperture_size, &test_mat[INPUT][1] );
945 cvTsConvolve2D( &test_mat[TEMP][0], &test_mat[REF_OUTPUT][0], &test_mat[INPUT][1], anchor );
949 CV_LaplaceTest laplace_test;
952 ////////////////////////////////////////////////////////////
954 static const char* smooth_param_names[] = { "mask_size", "size", "channels", "depth", 0 };
955 static const int smooth_depths[] = { CV_8U, CV_32F, -1 };
957 class CV_SmoothBaseTest : public CV_FilterBaseTest
960 CV_SmoothBaseTest( const char* test_name, const char* test_funcs );
963 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
964 double get_success_error_level( int test_case_idx, int i, int j );
965 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
966 CvSize** whole_sizes, bool *are_images );
967 int write_default_params( CvFileStorage* fs );
968 void print_timing_params( int test_case_idx, char* ptr, int params_left );
969 const char* smooth_type;
973 CV_SmoothBaseTest::CV_SmoothBaseTest( const char* test_name, const char* test_funcs )
974 : CV_FilterBaseTest( test_name, test_funcs, true )
976 default_timing_param_names = smooth_param_names;
977 depth_list = smooth_depths;
982 int CV_SmoothBaseTest::write_default_params( CvFileStorage* fs )
984 int code = CV_FilterBaseTest::write_default_params( fs );
985 if( code >= 0 && ts->get_testing_mode() == CvTS::TIMING_MODE )
987 start_write_param( fs );
988 write_int_list( fs, "mask_size", morph_mask_size, CV_DIM(morph_mask_size) );
993 void CV_SmoothBaseTest::get_test_array_types_and_sizes( int test_case_idx,
994 CvSize** sizes, int** types )
996 CvRNG* rng = ts->get_rng();
997 CV_FilterBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
998 int depth = cvTsRandInt(rng) % 2;
999 int cn = CV_MAT_CN(types[INPUT][0]);
1000 depth = depth == 0 ? CV_8U : CV_32F;
1001 types[INPUT][0] = types[TEMP][0] =
1002 types[OUTPUT][0] = types[REF_OUTPUT][0] = CV_MAKETYPE(depth,cn);
1003 anchor.x = cvTsRandInt(rng)%(max_aperture_size/2+1);
1004 anchor.y = cvTsRandInt(rng)%(max_aperture_size/2+1);
1005 aperture_size.width = anchor.x*2 + 1;
1006 aperture_size.height = anchor.y*2 + 1;
1007 sizes[INPUT][1] = aperture_size;
1008 sizes[TEMP][0].width = sizes[INPUT][0].width + aperture_size.width - 1;
1009 sizes[TEMP][0].height = sizes[INPUT][0].height + aperture_size.height - 1;
1013 double CV_SmoothBaseTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
1015 int depth = CV_MAT_DEPTH(test_mat[INPUT][0].type);
1016 return depth <= CV_8S ? 1 : 1e-5;
1020 void CV_SmoothBaseTest::get_timing_test_array_types_and_sizes( int test_case_idx,
1021 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
1023 CV_FilterBaseTest::get_timing_test_array_types_and_sizes( test_case_idx,
1024 sizes, types, whole_sizes, are_images );
1026 aperture_size.width = aperture_size.height = cvReadInt( find_timing_param( "mask_size" ), 3 );
1027 anchor.x = anchor.y = aperture_size.width / 2;
1028 sizes[INPUT][1] = aperture_size;
1029 types[INPUT][1] = CV_32FC1;
1033 void CV_SmoothBaseTest::print_timing_params( int test_case_idx, char* ptr, int params_left )
1035 sprintf( ptr, "%dx%d,%s,", aperture_size.width, aperture_size.height, smooth_type );
1039 CV_FilterBaseTest::print_timing_params( test_case_idx, ptr, params_left );
1043 /////////////// blur ///////////////
1045 static const char* blur_param_names[] = { "normalize", "mask_size", "size", "channels", "depth", 0 };
1046 static const int blur_normalize[] = { 0, 1 };
1048 class CV_BlurTest : public CV_SmoothBaseTest
1054 int prepare_test_case( int test_case_idx );
1055 void prepare_to_validation( int test_case_idx );
1057 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
1058 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
1059 CvSize** whole_sizes, bool *are_images );
1060 int write_default_params( CvFileStorage* fs );
1065 CV_BlurTest::CV_BlurTest() : CV_SmoothBaseTest( "filter-blur", "cvSmooth" )
1067 default_timing_param_names = blur_param_names;
1071 void CV_BlurTest::get_test_array_types_and_sizes( int test_case_idx,
1072 CvSize** sizes, int** types )
1074 CvRNG* rng = ts->get_rng();
1075 CV_SmoothBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
1076 normalize = cvTsRandInt(rng) % 2 != 0;
1079 int depth = CV_MAT_DEPTH(types[INPUT][0]);
1080 types[INPUT][0] = CV_MAKETYPE(depth, 1);
1081 types[TEMP][0] = types[OUTPUT][0] =
1082 types[REF_OUTPUT][0] = CV_MAKETYPE(depth==CV_8U?CV_16S:CV_32F,1);
1087 int CV_BlurTest::write_default_params( CvFileStorage* fs )
1089 int code = CV_SmoothBaseTest::write_default_params( fs );
1090 if( code >= 0 && ts->get_testing_mode() == CvTS::TIMING_MODE )
1092 write_int_list( fs, "normalize", blur_normalize, CV_DIM(blur_normalize) );
1098 void CV_BlurTest::get_timing_test_array_types_and_sizes( int test_case_idx,
1099 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
1101 CV_SmoothBaseTest::get_timing_test_array_types_and_sizes( test_case_idx,
1102 sizes, types, whole_sizes, are_images );
1103 normalize = cvReadInt( find_timing_param( "normalize" ), 1 ) != 0;
1104 smooth_type = normalize ? "Blur" : "Blur_NoScale";
1105 sizes[INPUT][1] = aperture_size;
1106 types[INPUT][1] = CV_32FC1;
1107 if( !normalize && types[INPUT][0] == CV_8UC1 )
1108 types[OUTPUT][0] = CV_16SC1;
1112 void CV_BlurTest::run_func()
1114 cvSmooth( inplace ? test_array[OUTPUT][0] : test_array[INPUT][0],
1115 test_array[OUTPUT][0], normalize ? CV_BLUR : CV_BLUR_NO_SCALE,
1116 aperture_size.width, aperture_size.height );
1120 int CV_BlurTest::prepare_test_case( int test_case_idx )
1122 int code = CV_SmoothBaseTest::prepare_test_case( test_case_idx );
1123 return code > 0 && !normalize && CV_MAT_CN(test_mat[INPUT][0].type) > 1 ? 0 : code;
1127 void CV_BlurTest::prepare_to_validation( int test_case_idx )
1129 CvMat* kernel = &test_mat[INPUT][1];
1130 CV_SmoothBaseTest::prepare_to_validation( test_case_idx );
1131 cvTsAdd( 0, cvScalarAll(0.), 0, cvScalarAll(0.),
1132 cvScalarAll(normalize ? 1./(kernel->rows*kernel->cols) : 1.), kernel, 0 );
1133 cvTsConvolve2D( &test_mat[TEMP][0], &test_mat[REF_OUTPUT][0], kernel, anchor );
1137 CV_BlurTest blur_test;
1140 /////////////// gaussian ///////////////
1142 class CV_GaussianBlurTest : public CV_SmoothBaseTest
1145 CV_GaussianBlurTest();
1148 void prepare_to_validation( int test_case_idx );
1150 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
1151 double get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ );
1152 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
1153 CvSize** whole_sizes, bool *are_images );
1159 CV_GaussianBlurTest::CV_GaussianBlurTest() : CV_SmoothBaseTest( "filter-gaussian", "cvSmooth" )
1162 smooth_type = "Gaussian";
1166 double CV_GaussianBlurTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
1168 int depth = CV_MAT_DEPTH(test_mat[INPUT][0].type);
1169 return depth <= CV_8S ? 8 : 1e-5;
1173 void CV_GaussianBlurTest::get_test_array_types_and_sizes( int test_case_idx,
1174 CvSize** sizes, int** types )
1176 CvRNG* rng = ts->get_rng();
1177 int kernel_case = cvTsRandInt(rng) % 2;
1178 CV_SmoothBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
1179 anchor = cvPoint(aperture_size.width/2,aperture_size.height/2);
1180 sizes[TEMP][0].width = sizes[INPUT][0].width + aperture_size.width - 1;
1181 sizes[TEMP][0].height = sizes[INPUT][0].height + aperture_size.height - 1;
1183 sigma = exp(cvTsRandReal(rng)*5-2);
1184 param1 = aperture_size.width;
1185 param2 = aperture_size.height;
1187 if( kernel_case == 0 )
1189 /*else if( kernel_case == 2 )
1191 int depth = CV_MAT_DEPTH(types[INPUT][0]);
1192 // !!! Copied from cvSmooth, if this formula is changed in cvSmooth,
1193 // make sure to update this one too.
1194 aperture_size.width = cvRound(sigma*(depth == CV_8U ? 3 : 4)*2 + 1)|1;
1195 aperture_size.width = MIN( aperture_size.width, 31 );
1196 aperture_size.height = aperture_size.width;
1197 anchor.x = aperture_size.width / 2;
1198 anchor.y = aperture_size.height / 2;
1199 sizes[INPUT][1] = aperture_size;
1200 sizes[TEMP][0].width = sizes[INPUT][0].width + aperture_size.width - 1;
1201 sizes[TEMP][0].height = sizes[INPUT][0].height + aperture_size.height - 1;
1202 param1 = aperture_size.width; param2 = aperture_size.height;
1207 void CV_GaussianBlurTest::get_timing_test_array_types_and_sizes( int test_case_idx,
1208 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
1210 CV_SmoothBaseTest::get_timing_test_array_types_and_sizes( test_case_idx,
1211 sizes, types, whole_sizes, are_images );
1212 param1 = aperture_size.width;
1213 param2 = aperture_size.height;
1217 void CV_GaussianBlurTest::run_func()
1219 cvSmooth( inplace ? test_array[OUTPUT][0] : test_array[INPUT][0],
1220 test_array[OUTPUT][0], CV_GAUSSIAN, param1, param2, sigma );
1224 // !!! Copied from cvSmooth, if the code is changed in cvSmooth,
1225 // make sure to update this one too.
1226 #define SMALL_GAUSSIAN_SIZE 7
1228 icvCalcGaussianKernel( int n, double sigma, float* kernel )
1230 static const float small_gaussian_tab[][SMALL_GAUSSIAN_SIZE] =
1233 {0.25f, 0.5f, 0.25f},
1234 {0.0625f, 0.25f, 0.375f, 0.25f, 0.0625f},
1235 {0.03125, 0.109375, 0.21875, 0.28125, 0.21875, 0.109375, 0.03125}
1238 if( n <= SMALL_GAUSSIAN_SIZE && sigma <= 0 )
1241 memcpy( kernel, small_gaussian_tab[n>>1], n*sizeof(kernel[0]));
1245 double sigmaX = sigma > 0 ? sigma : (n/2 - 1)*0.3 + 0.8;
1246 double scale2X = -0.5/(sigmaX*sigmaX);
1249 sum = kernel[n/2] = 1.f;
1251 for( i = 1; i <= n/2; i++ )
1253 kernel[n/2+i] = kernel[n/2-i] = (float)exp(scale2X*i*i);
1254 sum += kernel[n/2+i]*2;
1258 for( i = 0; i <= n/2; i++ )
1259 kernel[n/2+i] = kernel[n/2-i] = (float)(kernel[n/2+i]*sum);
1264 static void cvTsCalcGaussianKernel2D( double sigma, CvMat* kernel )
1267 float* kx = (float*)alloca( kernel->cols*sizeof(kx[0]) );
1268 float* ky = (float*)alloca( kernel->rows*sizeof(ky[0]) );
1270 icvCalcGaussianKernel( kernel->cols, sigma, kx );
1271 icvCalcGaussianKernel( kernel->rows, sigma, ky );
1273 for( i = 0; i < kernel->rows; i++ )
1275 float* kdata = (float*)(kernel->data.ptr + i*kernel->step);
1276 for( j = 0; j < kernel->cols; j++ )
1277 kdata[j] = kx[j]*ky[i];
1282 void CV_GaussianBlurTest::prepare_to_validation( int test_case_idx )
1284 CvMat* kernel = &test_mat[INPUT][1];
1285 CV_SmoothBaseTest::prepare_to_validation( test_case_idx );
1286 cvTsCalcGaussianKernel2D( sigma, &test_mat[INPUT][1] );
1287 cvTsConvolve2D( &test_mat[TEMP][0], &test_mat[REF_OUTPUT][0], kernel, anchor );
1291 CV_GaussianBlurTest gaussianblur_test;
1294 /////////////// median ///////////////
1296 static const int smooth_median_depths[] = { CV_8U, -1 };
1298 class CV_MedianBlurTest : public CV_SmoothBaseTest
1301 CV_MedianBlurTest();
1304 void prepare_to_validation( int test_case_idx );
1305 double get_success_error_level( int test_case_idx, int i, int j );
1307 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
1311 CV_MedianBlurTest::CV_MedianBlurTest() : CV_SmoothBaseTest( "filter-median", "cvSmooth" )
1313 test_array[TEMP].push(NULL);
1314 smooth_type = "Median";
1315 depth_list = smooth_median_depths;
1319 void CV_MedianBlurTest::get_test_array_types_and_sizes( int test_case_idx,
1320 CvSize** sizes, int** types )
1322 CV_SmoothBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
1324 int cn = CV_MAT_CN(types[INPUT][0]);
1325 types[INPUT][0] = types[TEMP][0] = types[OUTPUT][0] = types[REF_OUTPUT][0] = CV_MAKETYPE(depth,cn);
1326 types[INPUT][1] = types[TEMP][0] = types[TEMP][1] = CV_MAKETYPE(depth,1);
1328 aperture_size.height = aperture_size.width;
1329 anchor.x = anchor.y = aperture_size.width / 2;
1330 sizes[INPUT][1] = cvSize(aperture_size.width,aperture_size.height);
1332 sizes[OUTPUT][0] = sizes[INPUT][0];
1333 sizes[REF_OUTPUT][0] = sizes[INPUT][0];
1335 sizes[TEMP][0].width = sizes[INPUT][0].width + aperture_size.width - 1;
1336 sizes[TEMP][0].height = sizes[INPUT][0].height + aperture_size.height - 1;
1338 sizes[TEMP][1] = cn > 1 ? sizes[INPUT][0] : cvSize(0,0);
1343 double CV_MedianBlurTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
1349 void CV_MedianBlurTest::run_func()
1351 cvSmooth( test_array[INPUT][0], test_array[OUTPUT][0],
1352 CV_MEDIAN, aperture_size.width );
1361 median_pair( int _col, int _val ) : col(_col), val(_val) {};
1365 static void cvTsMedianFilter( const CvMat* src, CvMat* dst, int m )
1367 int i, j, k, l, m2 = m*m, n;
1368 int* col_buf = (int*)cvAlloc( (m+1)*sizeof(col_buf[0]));
1369 median_pair* buf0 = (median_pair*)cvAlloc( (m*m+1)*sizeof(buf0[0]));
1370 median_pair* buf1 = (median_pair*)cvAlloc( (m*m+1)*sizeof(buf1[0]));
1372 int step = src->step/CV_ELEM_SIZE(src->type);
1374 assert( src->rows == dst->rows + m - 1 && src->cols == dst->cols + m - 1 &&
1375 CV_ARE_TYPES_EQ(src,dst) && CV_MAT_TYPE(src->type) == CV_8UC1 );
1377 for( i = 0; i < dst->rows; i++ )
1379 uchar* dst1 = (uchar*)(dst->data.ptr + dst->step*i);
1380 for( k = 0; k < m; k++ )
1382 const uchar* src1 = (const uchar*)(src->data.ptr + (i+k)*src->step);
1383 for( j = 0; j < m-1; j++ )
1384 *buf0++ = median_pair(j, src1[j]);
1389 for( k = n-1; k > 0; k-- )
1392 for( j = 0; j < k; j++ )
1394 if( buf0[j].val > buf0[j+1].val )
1397 CV_SWAP( buf0[j], buf0[j+1], t );
1405 for( j = 0; j < dst->cols; j++ )
1407 int ins_col = j + m - 1;
1408 int del_col = j - 1;
1409 const uchar* src1 = (const uchar*)(src->data.ptr + src->step*i) + ins_col;
1410 for( k = 0; k < m; k++, src1 += step )
1412 col_buf[k] = src1[0];
1413 for( l = k-1; l >= 0; l-- )
1416 if( col_buf[l] < col_buf[l+1] )
1418 CV_SWAP( col_buf[l], col_buf[l+1], t );
1422 col_buf[m] = INT_MAX;
1424 for( k = 0, l = 0; k < n; )
1426 if( buf0[k].col == del_col )
1428 else if( buf0[k].val < col_buf[l] )
1429 *buf1++ = buf0[k++];
1432 assert( col_buf[l] < INT_MAX );
1433 *buf1++ = median_pair(ins_col,col_buf[l++]);
1438 *buf1++ = median_pair(ins_col,col_buf[l]);
1444 dst1[j] = (uchar)buf1[n/2].val;
1445 CV_SWAP( buf0, buf1, tbuf );
1455 void CV_MedianBlurTest::prepare_to_validation( int /*test_case_idx*/ )
1457 // CV_SmoothBaseTest::prepare_to_validation( test_case_idx );
1458 CvMat* src0 = &test_mat[INPUT][0];
1459 CvMat* dst0 = &test_mat[REF_OUTPUT][0];
1460 int i, cn = CV_MAT_CN(src0->type);
1461 CvMat* src = &test_mat[TEMP][0], *dst = dst0;
1463 dst = &test_mat[TEMP][1];
1465 for( i = 0; i < cn; i++ )
1470 cvTsExtract( src0, dst, i );
1473 cvTsPrepareToFilter( ptr, src, anchor, CV_TS_BORDER_REPLICATE );
1474 cvTsMedianFilter( src, dst, aperture_size.width );
1476 cvTsInsert( dst, dst0, i );
1481 CV_MedianBlurTest medianblur_test;
1484 /////////////// pyramid tests ///////////////
1486 static const char* pyramid_param_names[] = { "size", "channels", "depth", 0 };
1487 static int pyramid_channels[] = { 1, 3, -1 };
1489 class CV_PyramidBaseTest : public CV_FilterBaseTest
1492 CV_PyramidBaseTest( const char* test_name, const char* test_funcs, bool downsample );
1495 int prepare_test_case( int test_case_idx );
1496 double get_success_error_level( int test_case_idx, int i, int j );
1497 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
1498 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
1499 CvSize** whole_sizes, bool *are_images );
1504 CV_PyramidBaseTest::CV_PyramidBaseTest( const char* test_name, const char* test_funcs, bool _downsample )
1505 : CV_FilterBaseTest( test_name, test_funcs, true ), downsample(_downsample)
1507 test_array[TEMP].push(NULL);
1508 size_list = filter_sizes;
1509 depth_list = smooth_depths;
1510 cn_list = pyramid_channels;
1511 default_timing_param_names = 0;
1512 if( strcmp( test_funcs, "" ) != 0 )
1514 default_timing_param_names = pyramid_param_names;
1522 double CV_PyramidBaseTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
1524 int depth = CV_MAT_DEPTH(test_mat[INPUT][0].type);
1525 return depth <= CV_8S ? 1 : 1e-5;
1529 void CV_PyramidBaseTest::get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types )
1531 CvRNG* rng = ts->get_rng();
1533 CV_FilterBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
1535 int depth = cvTsRandInt(rng) % 2 ? CV_32F : CV_8U;
1536 int cn = cvTsRandInt(rng) & 1 ? 3 : 1;
1538 aperture_size = cvSize(5,5);
1539 anchor = cvPoint(aperture_size.width/2, aperture_size.height/2);
1541 types[INPUT][0] = types[OUTPUT][0] = types[REF_OUTPUT][0] =
1542 types[TEMP][0] = types[TEMP][1] = CV_MAKETYPE(depth, cn);
1544 sz.width = MAX( sizes[INPUT][0].width/2, 1 );
1545 sz.height = MAX( sizes[INPUT][0].height/2, 1 );
1549 sizes[OUTPUT][0] = sizes[REF_OUTPUT][0] = sz;
1552 sizes[INPUT][0] = sizes[TEMP][1] = sz;
1556 sizes[INPUT][0] = sz;
1559 sizes[OUTPUT][0] = sizes[REF_OUTPUT][0] = sz;
1560 sizes[TEMP][1] = cvSize(0,0);
1563 sizes[INPUT][1] = aperture_size;
1564 sizes[TEMP][0].width = sz.width + aperture_size.width - 1;
1565 sizes[TEMP][0].height = sz.height + aperture_size.height - 1;
1570 void CV_PyramidBaseTest::get_timing_test_array_types_and_sizes( int test_case_idx,
1571 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
1573 CV_FilterBaseTest::get_timing_test_array_types_and_sizes( test_case_idx,
1574 sizes, types, whole_sizes, are_images );
1575 CvSize sz = sizes[INPUT][0];
1579 sizes[OUTPUT][0] = sz;
1581 sizes[INPUT][0] = sz;
1582 aperture_size.width = aperture_size.height = 5;
1583 anchor.x = anchor.y = aperture_size.width / 2;
1584 sizes[INPUT][1] = aperture_size;
1585 types[INPUT][1] = CV_32FC1;
1589 int CV_PyramidBaseTest::prepare_test_case( int test_case_idx )
1591 static const float kdata[] = { 1.f, 4.f, 6.f, 4.f, 1.f };
1593 double scale = 1./256;
1595 int code = CV_FilterBaseTest::prepare_test_case( test_case_idx );
1603 kernel = &test_mat[INPUT][1];
1605 for( i = 0; i < aperture_size.height; i++ )
1607 float* krow = (float*)(kernel->data.ptr + i*kernel->step);
1608 for( j = 0; j < aperture_size.width; j++ )
1609 krow[j] = (float)(scale*kdata[i]*kdata[j]);
1615 CV_PyramidBaseTest pyr_base( "pyramid", "", false );
1618 /////// pyrdown ////////
1620 static void cvTsDownsample( const CvMat* src, CvMat* dst )
1623 int elem_size = CV_ELEM_SIZE(src->type);
1624 int ncols = dst->cols*elem_size;
1625 int is_dword = elem_size % sizeof(int) == 0;
1629 elem_size /= sizeof(int);
1630 ncols /= sizeof(int);
1633 for( i = 0; i < dst->rows; i++ )
1635 const uchar* src_row = src->data.ptr + i*2*src->step;
1636 uchar* dst_row = dst->data.ptr + i*dst->step;
1640 for( j = 0; j < ncols; j += elem_size )
1642 for( k = 0; k < elem_size; k++ )
1643 dst_row[j+k] = src_row[j*2+k];
1648 for( j = 0; j < ncols; j += elem_size )
1650 for( k = 0; k < elem_size; k++ )
1651 ((int*)dst_row)[j+k] = ((const int*)src_row)[j*2+k];
1658 class CV_PyramidDownTest : public CV_PyramidBaseTest
1661 CV_PyramidDownTest();
1665 void prepare_to_validation( int );
1669 CV_PyramidDownTest::CV_PyramidDownTest()
1670 : CV_PyramidBaseTest( "pyramid-down", "cvPyrDown", true )
1675 void CV_PyramidDownTest::run_func()
1677 cvPyrDown( test_array[INPUT][0], test_array[OUTPUT][0], CV_GAUSSIAN_5x5 );
1681 void CV_PyramidDownTest::prepare_to_validation( int /*test_case_idx*/ )
1683 cvTsPrepareToFilter( &test_mat[INPUT][0], &test_mat[TEMP][0],
1684 anchor, CV_TS_BORDER_REFLECT );
1685 cvTsConvolve2D( &test_mat[TEMP][0], &test_mat[TEMP][1],
1686 &test_mat[INPUT][1], anchor );
1687 cvTsDownsample( &test_mat[TEMP][1], &test_mat[REF_OUTPUT][0] );
1691 CV_PyramidDownTest pyrdown;
1694 /////// pyrup ////////
1696 static void cvTsUpsample( const CvMat* src, CvMat* dst )
1699 int elem_size = CV_ELEM_SIZE(src->type);
1700 int ncols = src->cols*elem_size;
1701 int is_dword = elem_size % sizeof(int) == 0;
1705 elem_size /= sizeof(int);
1706 ncols /= sizeof(int);
1709 for( i = 0; i < src->rows; i++ )
1711 const uchar* src_row = src->data.ptr + i*src->step;
1712 uchar* dst_row = dst->data.ptr + i*2*dst->step;
1716 memset( dst_row + dst->step, 0, dst->cols*elem_size );
1717 for( j = 0; j < ncols; j += elem_size )
1719 for( k = 0; k < elem_size; k++ )
1721 dst_row[j*2+k] = src_row[j+k];
1722 dst_row[j*2+k+elem_size] = 0;
1728 memset( dst_row + dst->step, 0, dst->cols*elem_size*sizeof(int) );
1729 for( j = 0; j < ncols; j += elem_size )
1731 for( k = 0; k < elem_size; k++ )
1733 ((int*)dst_row)[j*2+k] = ((const int*)src_row)[j+k];
1734 ((int*)dst_row)[j*2+k+elem_size] = 0;
1742 class CV_PyramidUpTest : public CV_PyramidBaseTest
1749 void prepare_to_validation( int );
1753 CV_PyramidUpTest::CV_PyramidUpTest()
1754 : CV_PyramidBaseTest( "pyramid-up", "cvPyrUp", false )
1759 void CV_PyramidUpTest::run_func()
1761 cvPyrUp( test_array[INPUT][0], test_array[OUTPUT][0], CV_GAUSSIAN_5x5 );
1765 void CV_PyramidUpTest::prepare_to_validation( int /*test_case_idx*/ )
1769 cvTsUpsample( &test_mat[INPUT][0], &test_mat[REF_OUTPUT][0] );
1770 cvTsPrepareToFilter( &test_mat[REF_OUTPUT][0], &test_mat[TEMP][0],
1771 anchor, CV_TS_BORDER_REFLECT );
1772 cvTsConvolve2D( &test_mat[TEMP][0], &test_mat[REF_OUTPUT][0],
1773 &test_mat[INPUT][1], anchor );
1774 // currently IPP and OpenCV process right/bottom part of the image differently, so
1775 // we just patch the last two rows/columns to have consistent test results.
1776 sz = cvGetMatSize( &test_mat[REF_OUTPUT][0]);
1777 cvTsSelect( &test_mat[REF_OUTPUT][0], &src2, cvRect(sz.width-2,0,2,sz.height) );
1778 cvTsSelect( &test_mat[OUTPUT][0], &dst2, cvRect(sz.width-2,0,2,sz.height) );
1779 cvTsCopy( &src2, &dst2, 0 );
1780 cvTsSelect( &test_mat[REF_OUTPUT][0], &src2, cvRect(0,sz.height-2,sz.width,2) );
1781 cvTsSelect( &test_mat[OUTPUT][0], &dst2, cvRect(0,sz.height-2,sz.width,2) );
1782 cvTsCopy( &src2, &dst2, 0 );
1786 CV_PyramidUpTest pyrup;
1790 //////////////////////// feature selection //////////////////////////
1792 static const char* featuresel_param_names[] = { "block_size", "aperture", "size", "depth", 0 };
1793 static const int featuresel_block_size[] = { 3, 5, 11 };
1795 class CV_FeatureSelBaseTestImpl : public CvArrTest
1798 CV_FeatureSelBaseTestImpl( const char* test_name, const char* test_funcs, int width_factor );
1801 int read_params( CvFileStorage* fs );
1802 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
1803 void get_minmax_bounds( int i, int j, int type, CvScalar* low, CvScalar* high );
1804 double get_success_error_level( int test_case_idx, int i, int j );
1805 int write_default_params(CvFileStorage* fs);
1806 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
1807 CvSize** whole_sizes, bool *are_images );
1808 void print_timing_params( int test_case_idx, char* ptr, int params_left );
1809 int aperture_size, block_size;
1810 int max_aperture_size;
1816 CV_FeatureSelBaseTestImpl::CV_FeatureSelBaseTestImpl( const char* test_name, const char* test_funcs, int _width_factor )
1817 : CvArrTest( test_name, test_funcs, "" )
1819 max_aperture_size = 7;
1820 max_block_size = 21;
1821 // 1 input, 1 output, temp arrays are allocated in the reference functions
1822 test_array[INPUT].push(NULL);
1823 test_array[OUTPUT].push(NULL);
1824 test_array[REF_OUTPUT].push(NULL);
1825 element_wise_relative_error = false;
1826 width_factor = _width_factor;
1828 size_list = filter_sizes;
1829 whole_size_list = filter_whole_sizes;
1830 depth_list = morph_depths;
1835 int CV_FeatureSelBaseTestImpl::read_params( CvFileStorage* fs )
1837 int code = CvTest::read_params( fs );
1841 if( ts->get_testing_mode() == CvTS::CORRECTNESS_CHECK_MODE )
1843 max_aperture_size = cvReadInt( find_param( fs, "max_aperture_size" ), max_aperture_size );
1844 max_aperture_size = cvTsClipInt( max_aperture_size, 1, 9 );
1845 max_block_size = cvReadInt( find_param( fs, "max_block_size" ), max_block_size );
1846 max_block_size = cvTsClipInt( max_aperture_size, 1, 100 );
1853 int CV_FeatureSelBaseTestImpl::write_default_params( CvFileStorage* fs )
1855 int code = CvArrTest::write_default_params( fs );
1859 if( ts->get_testing_mode() == CvTS::CORRECTNESS_CHECK_MODE )
1861 write_param( fs, "max_aperture_size", max_aperture_size );
1862 write_param( fs, "max_block_size", max_block_size );
1864 else if( ts->get_testing_mode() == CvTS::TIMING_MODE && strcmp( tested_functions, "" ) == 0 )
1866 start_write_param( fs );
1867 write_int_list( fs, "aperture", sobel_aperture, CV_DIM(sobel_aperture) );
1868 write_int_list( fs, "block_size", featuresel_block_size, CV_DIM(featuresel_block_size) );
1875 double CV_FeatureSelBaseTestImpl::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
1877 int depth = CV_MAT_DEPTH(test_mat[INPUT][0].type);
1878 return depth <= CV_8S ? 3e-2 : depth == CV_32F ? 1e-3 : 1e-10;
1882 void CV_FeatureSelBaseTestImpl::get_minmax_bounds( int i, int j, int type, CvScalar* low, CvScalar* high )
1884 CvArrTest::get_minmax_bounds( i, j, type, low, high );
1885 if( i == INPUT && CV_MAT_DEPTH(type) == CV_32F )
1887 *low = cvScalarAll(-10.);
1888 *high = cvScalarAll(10.);
1893 void CV_FeatureSelBaseTestImpl::get_test_array_types_and_sizes( int test_case_idx,
1894 CvSize** sizes, int** types )
1896 CvRNG* rng = ts->get_rng();
1897 CvArrTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
1898 int depth = cvTsRandInt(rng) % 2, asz;
1900 depth = depth == 0 ? CV_8U : CV_32F;
1901 types[INPUT][0] = depth;
1902 types[OUTPUT][0] = types[REF_OUTPUT][0] = CV_32FC1;
1904 aperture_size = (cvTsRandInt(rng) % (max_aperture_size+2) - 1) | 1;
1905 if( aperture_size == 1 )
1907 if( depth == CV_8U )
1908 aperture_size = MIN( aperture_size, 5 );
1909 block_size = (cvTsRandInt(rng) % max_block_size + 1) | 1;
1910 if( block_size <= 3 )
1912 asz = aperture_size > 0 ? aperture_size : 3;
1914 sizes[INPUT][0].width = MAX( sizes[INPUT][0].width, asz + block_size );
1915 sizes[INPUT][0].height = MAX( sizes[INPUT][0].height, asz + block_size );
1916 sizes[OUTPUT][0].height = sizes[REF_OUTPUT][0].height = sizes[INPUT][0].height;
1917 sizes[OUTPUT][0].width = sizes[REF_OUTPUT][0].width = sizes[INPUT][0].width*width_factor;
1921 void CV_FeatureSelBaseTestImpl::get_timing_test_array_types_and_sizes( int test_case_idx,
1922 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
1924 CvArrTest::get_timing_test_array_types_and_sizes( test_case_idx, sizes, types,
1925 whole_sizes, are_images );
1926 aperture_size = cvReadInt( find_timing_param( "aperture" ), 3 );
1927 block_size = cvReadInt( find_timing_param( "block_size" ), 0 );
1928 int asz = aperture_size < 0 ? 3 : aperture_size;
1930 sizes[INPUT][0].width = MAX( sizes[INPUT][0].width, asz + block_size );
1931 sizes[INPUT][0].height = MAX( sizes[INPUT][0].height, asz + block_size );
1932 whole_sizes[INPUT][0].width = MAX( whole_sizes[INPUT][0].width, asz + block_size );
1933 whole_sizes[INPUT][0].height = MAX( whole_sizes[INPUT][0].height, asz + block_size );
1934 sizes[OUTPUT][0].height = sizes[INPUT][0].height;
1935 sizes[OUTPUT][0].width = sizes[INPUT][0].width*width_factor;
1936 whole_sizes[OUTPUT][0].height = whole_sizes[INPUT][0].height;
1937 whole_sizes[OUTPUT][0].width = MAX(whole_sizes[OUTPUT][0].width,sizes[OUTPUT][0].width);
1938 types[OUTPUT][0] = CV_32FC1;
1942 void CV_FeatureSelBaseTestImpl::print_timing_params( int test_case_idx, char* ptr, int params_left )
1944 int asz = aperture_size < 0 ? 3 : aperture_size;
1945 sprintf( ptr, "%s(%dx%d),", aperture_size < 0 ? "Scharr" : "Sobel", asz, asz );
1948 if( block_size > 0 )
1950 sprintf( ptr, "block_size=%dx%d,", block_size, block_size );
1955 CvArrTest::print_timing_params( test_case_idx, ptr, params_left );
1959 CV_FeatureSelBaseTestImpl featuresel_base( "features", "", 0 );
1963 class CV_FeatureSelBaseTest : public CV_FeatureSelBaseTestImpl
1966 CV_FeatureSelBaseTest( const char* test_name, const char* test_funcs, int width_factor );
1970 CV_FeatureSelBaseTest::CV_FeatureSelBaseTest( const char* test_name, const char* test_funcs, int _width_factor )
1971 : CV_FeatureSelBaseTestImpl( test_name, test_funcs, _width_factor )
1974 size_list = whole_size_list = 0;
1975 default_timing_param_names = featuresel_param_names;
1980 cvTsCornerEigenValsVecs( const CvMat* _src, CvMat* eigenv, CvMat* ocv_eigenv,
1981 int block_size, int _aperture_size, int mode )
1983 CvMat *dx2 = 0, *dxdy = 0, *dy2 = 0;
1984 CvMat* kernel = 0, *src2 = 0;
1985 const CvMat* src = _src;
1990 CV_FUNCNAME( "cvTsCornerEigenValsVecs" );
1995 int aperture_size = _aperture_size < 0 ? 3 : _aperture_size;
1996 CvPoint anchor = { aperture_size/2, aperture_size/2 };
1998 assert( (CV_MAT_TYPE(src->type) == CV_8UC1 ||
1999 CV_MAT_TYPE(src->type) == CV_32FC1) &&
2000 CV_MAT_TYPE(eigenv->type) == CV_32FC1 );
2002 assert( src->rows == eigenv->rows &&
2003 ((mode > 0 && src->cols == eigenv->cols) ||
2004 (mode == 0 && src->cols*6 == eigenv->cols)) );
2006 type = CV_MAT_TYPE(src->type);
2009 CV_CALL( dx2 = cvCreateMat( src->rows, src->cols, ftype ));
2010 CV_CALL( dy2 = cvCreateMat( src->rows, src->cols, ftype ));
2011 CV_CALL( dxdy = cvCreateMat( src->rows, src->cols, ftype ));
2013 CV_CALL( kernel = cvCreateMat( aperture_size, aperture_size, CV_32FC1 ));
2014 CV_CALL( src2 = cvCreateMat( src->rows + aperture_size - 1,
2015 src->cols + aperture_size - 1, ftype ));
2019 cvTsAdd( src, cvScalarAll(1./255), 0, cvScalarAll(0.), cvScalarAll(0.), dx2, 0 );
2023 cvTsPrepareToFilter( src, src2, anchor, CV_TS_BORDER_REPLICATE );
2024 cvTsCalcSobelKernel2D( 1, 0, _aperture_size, 0, kernel );
2025 cvTsConvolve2D( src2, dx2, kernel, anchor );
2026 cvTsCalcSobelKernel2D( 0, 1, _aperture_size, 0, kernel );
2027 cvTsConvolve2D( src2, dy2, kernel, anchor );
2028 cvReleaseMat( &src2 );
2029 cvReleaseMat( &kernel );
2031 denom = (1 << (aperture_size-1))*block_size;
2032 denom = denom * denom;
2033 if( _aperture_size < 0 )
2037 for( i = 0; i < src->rows; i++ )
2039 float* dxdyp = (float*)(dxdy->data.ptr + i*dxdy->step);
2040 float* dx2p = (float*)(dx2->data.ptr + i*dx2->step);
2041 float* dy2p = (float*)(dy2->data.ptr + i*dy2->step);
2043 for( j = 0; j < src->cols; j++ )
2045 double xval = dx2p[j], yval = dy2p[j];
2046 dxdyp[j] = (float)(xval*yval*denom);
2047 dx2p[j] = (float)(xval*xval*denom);
2048 dy2p[j] = (float)(yval*yval*denom);
2052 CV_CALL( src2 = cvCreateMat( src->rows + block_size - 1, src->cols + block_size - 1, CV_32F ));
2053 CV_CALL( kernel = cvCreateMat( block_size, block_size, CV_32F ));
2054 cvTsAdd( 0, cvScalarAll(0), 0, cvScalarAll(0), cvScalarAll(1./*(block_size*block_size)*/), kernel, 0 );
2055 anchor = cvPoint( block_size/2, block_size/2 );
2057 cvTsPrepareToFilter( dx2, src2, anchor, CV_TS_BORDER_REPLICATE );
2058 cvTsConvolve2D( src2, dx2, kernel, anchor );
2059 cvTsPrepareToFilter( dy2, src2, anchor, CV_TS_BORDER_REPLICATE );
2060 cvTsConvolve2D( src2, dy2, kernel, anchor );
2061 cvTsPrepareToFilter( dxdy, src2, anchor, CV_TS_BORDER_REPLICATE );
2062 cvTsConvolve2D( src2, dxdy, kernel, anchor );
2066 for( i = 0; i < src->rows; i++ )
2068 float* eigenvp = (float*)(eigenv->data.ptr + i*eigenv->step);
2069 float* ocv_eigenvp = (float*)(ocv_eigenv->data.ptr + i*ocv_eigenv->step);
2070 const float* dxdyp = (float*)(dxdy->data.ptr + i*dxdy->step);
2071 const float* dx2p = (float*)(dx2->data.ptr + i*dx2->step);
2072 const float* dy2p = (float*)(dy2->data.ptr + i*dy2->step);
2074 for( j = 0; j < src->cols; j++ )
2076 double a = dx2p[j], b = dxdyp[j], c = dy2p[j];
2077 double d = sqrt((a-c)*(a-c) + 4*b*b);
2078 double l1 = 0.5*(a + c + d);
2079 double l2 = 0.5*(a + c - d);
2080 double x1, y1, x2, y2, s;
2082 if( fabs(a - l1) + fabs(b) >= 1e-3 )
2083 x1 = b, y1 = l1 - a;
2085 x1 = l1 - c, y1 = b;
2086 s = 1./(sqrt(x1*x1+y1*y1)+DBL_EPSILON);
2089 if( fabs(a - l2) + fabs(b) >= 1e-3 )
2090 x2 = b, y2 = l2 - a;
2092 x2 = l2 - c, y2 = b;
2093 s = 1./(sqrt(x2*x2+y2*y2)+DBL_EPSILON);
2096 /* the orientation of eigen vectors might be inversed relative to OpenCV function,
2098 if( (fabs(x1) >= fabs(y1) && ocv_eigenvp[j*6+2]*x1 < 0) ||
2099 (fabs(x1) < fabs(y1) && ocv_eigenvp[j*6+3]*y1 < 0) )
2102 if( (fabs(x2) >= fabs(y2) && ocv_eigenvp[j*6+4]*x2 < 0) ||
2103 (fabs(x2) < fabs(y2) && ocv_eigenvp[j*6+5]*y2 < 0) )
2106 eigenvp[j*6] = (float)l1;
2107 eigenvp[j*6+1] = (float)l2;
2108 eigenvp[j*6+2] = (float)x1;
2109 eigenvp[j*6+3] = (float)y1;
2110 eigenvp[j*6+4] = (float)x2;
2111 eigenvp[j*6+5] = (float)y2;
2115 else if( mode == 1 )
2117 for( i = 0; i < src->rows; i++ )
2119 float* eigenvp = (float*)(eigenv->data.ptr + i*eigenv->step);
2120 const float* dxdyp = (float*)(dxdy->data.ptr + i*dxdy->step);
2121 const float* dx2p = (float*)(dx2->data.ptr + i*dx2->step);
2122 const float* dy2p = (float*)(dy2->data.ptr + i*dy2->step);
2124 for( j = 0; j < src->cols; j++ )
2126 double a = dx2p[j], b = dxdyp[j], c = dy2p[j];
2127 double d = sqrt((a-c)*(a-c) + 4*b*b);
2128 eigenvp[j] = (float)(0.5*(a + c - d));
2135 cvReleaseMat( &dx2 );
2136 cvReleaseMat( &dy2 );
2137 cvReleaseMat( &dxdy );
2138 cvReleaseMat( &src2 );
2139 cvReleaseMat( &kernel );
2144 class CV_MinEigenValTest : public CV_FeatureSelBaseTest
2147 CV_MinEigenValTest();
2151 void prepare_to_validation( int );
2155 CV_MinEigenValTest::CV_MinEigenValTest()
2156 : CV_FeatureSelBaseTest( "features-mineval", "cvCornerMinEigenVal", 1 )
2161 void CV_MinEigenValTest::run_func()
2163 cvCornerMinEigenVal( test_array[INPUT][0], test_array[OUTPUT][0],
2164 block_size, aperture_size );
2168 void CV_MinEigenValTest::prepare_to_validation( int /*test_case_idx*/ )
2170 cvTsCornerEigenValsVecs( &test_mat[INPUT][0], &test_mat[REF_OUTPUT][0],
2171 &test_mat[OUTPUT][0], block_size, aperture_size, 1 );
2175 CV_MinEigenValTest features_mineval;
2178 // eigenval's & vec's
2179 class CV_EigenValVecTest : public CV_FeatureSelBaseTest
2182 CV_EigenValVecTest();
2186 void prepare_to_validation( int );
2190 CV_EigenValVecTest::CV_EigenValVecTest()
2191 : CV_FeatureSelBaseTest( "features-evalvec", "cvCornerEigenValsAndVecs", 6 )
2196 void CV_EigenValVecTest::run_func()
2198 cvCornerEigenValsAndVecs( test_array[INPUT][0], test_array[OUTPUT][0],
2199 block_size, aperture_size );
2203 void CV_EigenValVecTest::prepare_to_validation( int /*test_case_idx*/ )
2205 cvTsCornerEigenValsVecs( &test_mat[INPUT][0], &test_mat[REF_OUTPUT][0],
2206 &test_mat[OUTPUT][0], block_size, aperture_size, 0 );
2210 CV_EigenValVecTest features_evalvec;
2214 static const char* precorner_param_names[] = { "aperture", "size", "depth", 0 };
2215 static const int precorner_aperture[] = { 3, 5, 7 };
2218 class CV_PreCornerDetectTest : public CV_FeatureSelBaseTest
2221 CV_PreCornerDetectTest();
2225 void prepare_to_validation( int );
2226 int prepare_test_case( int );
2227 int write_default_params(CvFileStorage* fs);
2231 CV_PreCornerDetectTest::CV_PreCornerDetectTest()
2232 : CV_FeatureSelBaseTest( "features-precorner", "cvPreCornerDetect", 1 )
2234 default_timing_param_names = precorner_param_names;
2238 int CV_PreCornerDetectTest::write_default_params( CvFileStorage* fs )
2240 int code = CV_FeatureSelBaseTest::write_default_params( fs );
2244 if( ts->get_testing_mode() == CvTS::TIMING_MODE )
2246 start_write_param( fs );
2247 write_int_list( fs, "aperture", precorner_aperture, CV_DIM(precorner_aperture) );
2254 void CV_PreCornerDetectTest::run_func()
2256 cvPreCornerDetect( test_array[INPUT][0], test_array[OUTPUT][0], aperture_size );
2260 int CV_PreCornerDetectTest::prepare_test_case( int test_case_idx )
2262 int code = CV_FeatureSelBaseTest::prepare_test_case( test_case_idx );
2263 if( aperture_size < 0 )
2269 void CV_PreCornerDetectTest::prepare_to_validation( int /*test_case_idx*/ )
2271 /*cvTsCornerEigenValsVecs( &test_mat[INPUT][0], &test_mat[REF_OUTPUT][0],
2272 block_size, aperture_size, 0 );*/
2273 const CvMat* src = &test_mat[INPUT][0];
2274 CvMat* dst = &test_mat[REF_OUTPUT][0];
2276 int type = CV_MAT_TYPE(src->type), ftype = CV_32FC1;
2277 CvPoint anchor = { aperture_size/2, aperture_size/2 };
2281 CvMat* dx = cvCreateMat( src->rows, src->cols, ftype );
2282 CvMat* dy = cvCreateMat( src->rows, src->cols, ftype );
2283 CvMat* d2x = cvCreateMat( src->rows, src->cols, ftype );
2284 CvMat* d2y = cvCreateMat( src->rows, src->cols, ftype );
2285 CvMat* dxy = cvCreateMat( src->rows, src->cols, ftype );
2286 CvMat* tmp = cvCreateMat( src->rows + aperture_size - 1,
2287 src->cols + aperture_size - 1, ftype );
2288 CvMat* kernel = cvCreateMat( aperture_size, aperture_size, ftype );
2292 cvTsAdd( src, cvScalarAll(1./255), 0, cvScalarAll(0.), cvScalarAll(0.), dx, 0 );
2296 cvTsPrepareToFilter( src, tmp, anchor, CV_TS_BORDER_REPLICATE );
2298 cvTsCalcSobelKernel2D( 1, 0, aperture_size, 0, kernel );
2299 cvTsConvolve2D( tmp, dx, kernel, anchor );
2300 cvTsCalcSobelKernel2D( 0, 1, aperture_size, 0, kernel );
2301 cvTsConvolve2D( tmp, dy, kernel, anchor );
2302 cvTsCalcSobelKernel2D( 2, 0, aperture_size, 0, kernel );
2303 cvTsConvolve2D( tmp, d2x, kernel, anchor );
2304 cvTsCalcSobelKernel2D( 0, 2, aperture_size, 0, kernel );
2305 cvTsConvolve2D( tmp, d2y, kernel, anchor );
2306 cvTsCalcSobelKernel2D( 1, 1, aperture_size, 0, kernel );
2307 cvTsConvolve2D( tmp, dxy, kernel, anchor );
2309 denom = 1 << (aperture_size-1);
2310 denom = denom * denom * denom;
2313 for( i = 0; i < src->rows; i++ )
2315 const float* _dx = (const float*)(dx->data.ptr + i*dx->step);
2316 const float* _dy = (const float*)(dy->data.ptr + i*dy->step);
2317 const float* _d2x = (const float*)(d2x->data.ptr + i*d2x->step);
2318 const float* _d2y = (const float*)(d2y->data.ptr + i*d2y->step);
2319 const float* _dxy = (const float*)(dxy->data.ptr + i*dxy->step);
2320 float* corner = (float*)(dst->data.ptr + i*dst->step);
2322 for( j = 0; j < src->cols; j++ )
2327 corner[j] = (float)(denom*(x*x*_d2y[j] + y*y*_d2x[j] - 2*x*y*_dxy[j]));
2331 cvReleaseMat( &dx );
2332 cvReleaseMat( &dy );
2333 cvReleaseMat( &d2x );
2334 cvReleaseMat( &d2y );
2335 cvReleaseMat( &dxy );
2336 cvReleaseMat( &tmp );
2337 cvReleaseMat( &kernel );
2341 CV_PreCornerDetectTest precorner;
2344 ///////// integral /////////
2346 static const char* integral_param_names[] = { "output", "size", "channels", "sum_depth", "depth", 0 };
2347 static const int integral_sum_depth[] = { CV_32S, CV_64F, -1 };
2348 static const int integral_block_size[] = { 3, 5, 11 };
2349 static const char* integral_output[] = { "sum", "sum+sqsum", "all", 0 };
2351 class CV_IntegralTest : public CvArrTest
2357 void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
2358 void get_minmax_bounds( int i, int j, int type, CvScalar* low, CvScalar* high );
2359 double get_success_error_level( int test_case_idx, int i, int j );
2361 void prepare_to_validation( int );
2363 int prepare_test_case( int test_case_idx );
2364 int write_default_params(CvFileStorage* fs);
2365 void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
2366 CvSize** whole_sizes, bool *are_images );
2367 void print_timing_params( int test_case_idx, char* ptr, int params_left );
2371 CV_IntegralTest::CV_IntegralTest()
2372 : CvArrTest( "integral", "cvIntegral", "" )
2374 test_array[INPUT].push(NULL);
2375 test_array[OUTPUT].push(NULL);
2376 test_array[OUTPUT].push(NULL);
2377 test_array[OUTPUT].push(NULL);
2378 test_array[REF_OUTPUT].push(NULL);
2379 test_array[REF_OUTPUT].push(NULL);
2380 test_array[REF_OUTPUT].push(NULL);
2381 test_array[TEMP].push(NULL);
2382 test_array[TEMP].push(NULL);
2383 test_array[TEMP].push(NULL);
2384 test_array[TEMP].push(NULL);
2385 test_array[TEMP].push(NULL);
2386 element_wise_relative_error = false;
2388 size_list = filter_sizes;
2389 whole_size_list = filter_whole_sizes;
2390 default_timing_param_names = integral_param_names;
2391 depth_list = morph_depths;
2392 cn_list = filter_channels;
2396 void CV_IntegralTest::get_minmax_bounds( int i, int j, int type, CvScalar* low, CvScalar* high )
2398 CvArrTest::get_minmax_bounds( i, j, type, low, high );
2399 int depth = CV_MAT_DEPTH(type);
2400 if( depth == CV_32F )
2402 *low = cvScalarAll(-10.);
2403 *high = cvScalarAll(10.);
2408 int CV_IntegralTest::write_default_params( CvFileStorage* fs )
2410 int code = CvArrTest::write_default_params( fs );
2414 if( ts->get_testing_mode() == CvTS::TIMING_MODE )
2417 start_write_param( fs );
2419 cvStartWriteStruct( fs, "sum_depth", CV_NODE_SEQ+CV_NODE_FLOW );
2420 for( i = 0; integral_sum_depth[i] >= 0; i++ )
2421 cvWriteString( fs, 0, cvTsGetTypeName(integral_sum_depth[i]) );
2422 cvEndWriteStruct(fs);
2424 write_string_list( fs, "output", integral_output );
2431 void CV_IntegralTest::get_test_array_types_and_sizes( int test_case_idx,
2432 CvSize** sizes, int** types )
2434 CvRNG* rng = ts->get_rng();
2435 int depth = cvTsRandInt(rng) % 2, sum_depth;
2436 int cn = cvTsRandInt(rng) % 3 + 1;
2437 CvArrTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
2440 depth = depth == 0 ? CV_8U : CV_32F;
2442 sum_depth = depth == CV_8U && (cvTsRandInt(rng) & 1) == 1 ? CV_32S : CV_64F;
2444 //sizes[INPUT][0].width = 1;
2446 types[INPUT][0] = CV_MAKETYPE(depth,cn);
2447 types[OUTPUT][0] = types[REF_OUTPUT][0] =
2448 types[OUTPUT][2] = types[REF_OUTPUT][2] = CV_MAKETYPE(sum_depth, cn);
2449 types[OUTPUT][1] = types[REF_OUTPUT][1] = CV_MAKETYPE(CV_64F, cn);
2451 sum_size.width = sizes[INPUT][0].width + 1;
2452 sum_size.height = sizes[INPUT][0].height + 1;
2454 sizes[OUTPUT][0] = sizes[REF_OUTPUT][0] = sum_size;
2455 sizes[OUTPUT][1] = sizes[REF_OUTPUT][1] =
2456 sizes[OUTPUT][2] = sizes[REF_OUTPUT][2] = cvSize(0,0);
2458 if( cvTsRandInt(rng) % 3 > 0 )
2460 sizes[OUTPUT][1] = sizes[REF_OUTPUT][1] = sum_size;
2461 if( cvTsRandInt(rng) % 2 > 0 )
2462 sizes[REF_OUTPUT][2] = sizes[OUTPUT][2] = sum_size;
2465 types[TEMP][0] = CV_MAKETYPE(depth,1);
2466 types[TEMP][1] = CV_MAKETYPE(CV_32F,1);
2467 types[TEMP][2] = types[TEMP][3] = types[TEMP][4] = CV_MAKETYPE(CV_64F,1);
2469 sizes[TEMP][0] = cn > 1 ? sizes[INPUT][0] : cvSize(0,0);
2470 sizes[TEMP][1] = depth == CV_8U ? sum_size : cvSize(0,0);
2472 sizes[TEMP][2] = cn > 1 || sum_depth == CV_32S ? sizes[OUTPUT][0] : cvSize(0,0);
2473 sizes[TEMP][3] = cn > 1 ? sizes[OUTPUT][1] : cvSize(0,0);
2474 sizes[TEMP][4] = cn > 1 || sum_depth == CV_32S ? sizes[OUTPUT][2] : cvSize(0,0);
2478 double CV_IntegralTest::get_success_error_level( int /*test_case_idx*/, int i, int j )
2480 int depth = CV_MAT_DEPTH(test_mat[i][j].type);
2481 return depth == CV_32S ? 0 : FLT_EPSILON;
2485 void CV_IntegralTest::get_timing_test_array_types_and_sizes( int test_case_idx,
2486 CvSize** sizes, int** types, CvSize** whole_sizes, bool *are_images )
2488 CvArrTest::get_timing_test_array_types_and_sizes( test_case_idx, sizes, types,
2489 whole_sizes, are_images );
2490 const char* output = cvReadString( find_timing_param( "output" ), "sum" );
2491 CvSize sum_size = { sizes[INPUT][0].width + 1, sizes[INPUT][0].height + 1 };
2492 const char* _sum_depth = cvReadString( find_timing_param( "sum_depth" ), "64f" );
2493 int cn = CV_MAT_CN(types[INPUT][0]);
2494 int sum_depth = strcmp( _sum_depth, "32s" ) == 0 ? CV_32S : CV_64F;
2496 sizes[OUTPUT][0] = sizes[OUTPUT][1] = sizes[OUTPUT][2] = cvSize(0,0);
2497 whole_sizes[OUTPUT][0] = whole_sizes[OUTPUT][1] = whole_sizes[OUTPUT][2] = cvSize(0,0);
2499 if( strcmp( output, "sum" ) == 0 )
2500 sizes[OUTPUT][0] = whole_sizes[OUTPUT][0] = sum_size;
2501 else if( strcmp( output, "all" ) == 0 )
2502 sizes[OUTPUT][0] = sizes[OUTPUT][1] = sizes[OUTPUT][2] =
2503 whole_sizes[OUTPUT][0] = whole_sizes[OUTPUT][1] = whole_sizes[OUTPUT][2] = sum_size;
2505 sizes[OUTPUT][0] = sizes[OUTPUT][1] =
2506 whole_sizes[OUTPUT][0] = whole_sizes[OUTPUT][1] = sum_size;
2508 sizes[TEMP][0] = sizes[TEMP][1] = sizes[TEMP][2] = sizes[TEMP][3] = sizes[TEMP][4] = cvSize(0,0);
2510 types[OUTPUT][0] = types[OUTPUT][2] = CV_MAKETYPE( sum_depth, cn );
2511 types[OUTPUT][1] = CV_MAKETYPE( CV_64F, cn );
2515 void CV_IntegralTest::print_timing_params( int test_case_idx, char* ptr, int params_left )
2517 sprintf( ptr, "%s,", cvReadString( find_timing_param( "output" ), "sum" ) );
2521 CvArrTest::print_timing_params( test_case_idx, ptr, params_left );
2525 int CV_IntegralTest::prepare_test_case( int test_case_idx )
2527 int code = CvArrTest::prepare_test_case( test_case_idx );
2528 return code > 0 && ((test_array[OUTPUT][2] && CV_MAT_CN(test_mat[OUTPUT][2].type) > 1) ||
2529 CV_MAT_DEPTH(test_mat[OUTPUT][0].type) < CV_MAT_DEPTH(test_mat[INPUT][0].type)) ? 0 : code;
2533 void CV_IntegralTest::run_func()
2535 cvIntegral( test_array[INPUT][0], test_array[OUTPUT][0],
2536 test_array[OUTPUT][1], test_array[OUTPUT][2] );
2541 cvTsIntegral( const CvMat* img, const CvMat* sum, const CvMat* sqsum, const CvMat* tilted )
2543 const float* data = img->data.fl;
2544 double* sdata = sum->data.db;
2545 double* sqdata = sqsum ? sqsum->data.db : 0;
2546 double* tdata = tilted ? tilted->data.db : 0;
2547 int step = img->step/sizeof(data[0]);
2548 int sstep = sum->step/sizeof(sdata[0]);
2549 int sqstep = sqsum ? sqsum->step/sizeof(sqdata[0]) : 0;
2550 int tstep = tilted ? tilted->step/sizeof(tdata[0]) : 0;
2551 CvSize size = cvGetMatSize( img );
2553 memset( sdata, 0, (size.width+1)*sizeof(sdata[0]) );
2555 memset( sqdata, 0, (size.width+1)*sizeof(sqdata[0]) );
2557 memset( tdata, 0, (size.width+1)*sizeof(tdata[0]) );
2559 for( ; size.height--; data += step )
2561 double s = 0, sq = 0;
2567 for( x = 0; x <= size.width; x++ )
2569 double t = x > 0 ? data[x-1] : 0, ts = t;
2573 sdata[x] = s + sdata[x - sstep];
2575 sqdata[x] = sq + sqdata[x - sqstep];
2581 ts += tdata[-tstep+1];
2584 ts += tdata[x-tstep-1];
2585 if( data > img->data.fl )
2587 ts += data[x-step-1];
2588 if( x < size.width )
2589 ts += tdata[x-tstep+1] - tdata[x-tstep*2];
2599 void CV_IntegralTest::prepare_to_validation( int /*test_case_idx*/ )
2601 CvMat* src0 = &test_mat[INPUT][0];
2602 int i, cn = CV_MAT_CN(src0->type), depth = CV_MAT_DEPTH(src0->type);
2603 CvMat* plane = cn > 1 ? &test_mat[TEMP][0] : 0;
2604 CvMat ibuf, *plane32f = 0;
2606 CvMat* sum0 = &test_mat[REF_OUTPUT][0];
2607 CvMat* sqsum0 = test_array[REF_OUTPUT][1] ? &test_mat[REF_OUTPUT][1] : 0;
2608 CvMat* tsum0 = test_array[REF_OUTPUT][2] ? &test_mat[REF_OUTPUT][2] : 0;
2610 CvMat* sum1 = test_array[TEMP][2] ? &test_mat[TEMP][2] : sum0;
2611 CvMat* sqsum1 = test_array[TEMP][3] ? &test_mat[TEMP][3] : sqsum0;
2612 CvMat* tsum1 = test_array[TEMP][4] ? &test_mat[TEMP][4] : tsum0;
2613 CvMat buf, *ptr = 0;
2615 if( depth == CV_8U )
2617 ibuf = test_mat[TEMP][1];
2621 plane32f->type &= ~CV_MAT_CONT_FLAG;
2623 if( CV_MAT_DEPTH(sum0->type) == CV_32S && cn > 1 )
2625 // in case of 8u->32s integral transform aliase the temporary output buffer with temporary input buffer
2626 buf = test_mat[TEMP][1];
2628 ptr->type = (ptr->type & ~CV_MAT_DEPTH_MASK) | CV_32S;
2632 for( i = 0; i < cn; i++ )
2638 cvTsExtract( sptr, plane, i );
2642 if( CV_MAT_DEPTH(sptr->type) != CV_32F )
2644 cvTsConvert( sptr, plane32f );
2648 cvTsIntegral( sptr, sum1, sqsum1, tsum1 );
2654 cvTsConvert( dptr, ptr );
2658 cvTsConvert( dptr, sum0 );
2660 cvTsInsert( dptr, sum0, i );
2663 if( tsum1 != tsum0 )
2668 cvTsConvert( dptr, ptr );
2672 cvTsConvert( dptr, tsum0 );
2674 cvTsInsert( dptr, tsum0, i );
2677 if( sqsum1 != sqsum0 )
2678 cvTsInsert( sqsum1, sqsum0, i );
2683 CV_IntegralTest integral_test;