mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-29 05:29:54 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #824 from taka-no-me:reduce_c_api_deps

Browse Source
This commit is contained in:
Andrey Kamaev 2013-04-17 11:09:16 +04:00 committed by OpenCV Buildbot
commit 974f1f4895
45 changed files with 184 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmake/OpenCVDetectAndroidSDK.cmake
View File

@ -275,7 +275,7 @@ macro(add_android_project target path)
ocv_include_modules_recurse(${android_proj_NATIVE_DEPS}) ocv_include_modules_recurse(${android_proj_NATIVE_DEPS})
ocv_include_directories("${path}/jni") ocv_include_directories("${path}/jni")
if (NATIVE_APP_GLUE) if (NATIVE_APP_GLUE AND 0)
include_directories(${ANDROID_NDK}/sources/android/native_app_glue) include_directories(${ANDROID_NDK}/sources/android/native_app_glue)
list(APPEND android_proj_jni_files ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c) list(APPEND android_proj_jni_files ${ANDROID_NDK}/sources/android/native_app_glue/android_native_app_glue.c)
ocv_warnings_disable(CMAKE_C_FLAGS -Wstrict-prototypes -Wunused-parameter -Wmissing-prototypes) ocv_warnings_disable(CMAKE_C_FLAGS -Wstrict-prototypes -Wunused-parameter -Wmissing-prototypes)

3
doc/tutorials/core/adding_images/adding_images.rst
View File

@ -35,8 +35,7 @@ As usual, after the not-so-lengthy explanation, let's go to the code:
.. code-block:: cpp .. code-block:: cpp
#include <cv.h> #include <opencv2/opencv.hpp>
#include <highgui.h>
#include <iostream> #include <iostream>
using namespace cv; using namespace cv;

3
doc/tutorials/core/basic_linear_transform/basic_linear_transform.rst
View File

@ -72,8 +72,7 @@ Code
.. code-block:: cpp .. code-block:: cpp
#include <cv.h> #include <opencv2/opencv.hpp>
#include <highgui.h>
#include <iostream> #include <iostream>
using namespace cv; using namespace cv;

48
doc/tutorials/highgui/trackbar/trackbar.rst
View File

@ -28,9 +28,7 @@ Let's modify the program made in the tutorial :ref:`Adding_Images`. We will let
.. code-block:: cpp .. code-block:: cpp
#include <cv.h> #include <opencv2/opencv.hpp>
#include <highgui.h>
using namespace cv; using namespace cv;
/// Global Variables /// Global Variables
@ -50,41 +48,41 @@ Let's modify the program made in the tutorial :ref:`Adding_Images`. We will let
*/ */
void on_trackbar( int, void* ) void on_trackbar( int, void* )
{ {
alpha = (double) alpha_slider/alpha_slider_max ; alpha = (double) alpha_slider/alpha_slider_max ;
beta = ( 1.0 - alpha ); beta = ( 1.0 - alpha );
addWeighted( src1, alpha, src2, beta, 0.0, dst); addWeighted( src1, alpha, src2, beta, 0.0, dst);
imshow( "Linear Blend", dst ); imshow( "Linear Blend", dst );
} }
int main( int argc, char** argv ) int main( int argc, char** argv )
{ {
/// Read image ( same size, same type ) /// Read image ( same size, same type )
src1 = imread("../../images/LinuxLogo.jpg"); src1 = imread("../../images/LinuxLogo.jpg");
src2 = imread("../../images/WindowsLogo.jpg"); src2 = imread("../../images/WindowsLogo.jpg");
if( !src1.data ) { printf("Error loading src1 \n"); return -1; } if( !src1.data ) { printf("Error loading src1 \n"); return -1; }
if( !src2.data ) { printf("Error loading src2 \n"); return -1; } if( !src2.data ) { printf("Error loading src2 \n"); return -1; }
/// Initialize values /// Initialize values
alpha_slider = 0; alpha_slider = 0;
/// Create Windows /// Create Windows
namedWindow("Linear Blend", 1); namedWindow("Linear Blend", 1);
/// Create Trackbars /// Create Trackbars
char TrackbarName[50]; char TrackbarName[50];
sprintf( TrackbarName, "Alpha x %d", alpha_slider_max ); sprintf( TrackbarName, "Alpha x %d", alpha_slider_max );
createTrackbar( TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar ); createTrackbar( TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar );
/// Show some stuff /// Show some stuff
on_trackbar( alpha_slider, 0 ); on_trackbar( alpha_slider, 0 );
/// Wait until user press some key /// Wait until user press some key
waitKey(0); waitKey(0);
return 0; return 0;
} }

26
doc/tutorials/introduction/linux_eclipse/linux_eclipse.rst
View File

@ -65,8 +65,7 @@ Making a project
.. code-block:: cpp .. code-block:: cpp
#include <cv.h> #include <opencv2/opencv.hpp>
#include <highgui.h>
using namespace cv; using namespace cv;
@ -81,7 +80,7 @@ Making a project
return -1; return -1;
} }
namedWindow( "Display Image", CV_WINDOW_AUTOSIZE ); namedWindow( "Display Image", WINDOW_AUTOSIZE );
imshow( "Display Image", image ); imshow( "Display Image", image );
waitKey(0); waitKey(0);
@ -206,22 +205,15 @@ Say you have or create a new file, *helloworld.cpp* in a directory called *foo*:
.. code-block:: cpp .. code-block:: cpp
#include <cv.h> #include <opencv2/opencv.hpp>
#include <highgui.h> using namespace cv;
int main ( int argc, char **argv ) int main ( int argc, char **argv )
{ {
cvNamedWindow( "My Window", 1 ); Mat img(480, 640, CV_8U);
IplImage *img = cvCreateImage( cvSize( 640, 480 ), IPL_DEPTH_8U, 1 ); putText(img, "Hello World!", Point( 200, 400 ), FONT_HERSHEY_SIMPLEX | FONT_ITALIC, 1.0, Scalar( 255, 255, 0 ));
CvFont font; imshow("My Window", img);
double hScale = 1.0; waitKey();
double vScale = 1.0;
int lineWidth = 1;
cvInitFont( &font, CV_FONT_HERSHEY_SIMPLEX | CV_FONT_ITALIC,
hScale, vScale, 0, lineWidth );
cvPutText( img, "Hello World!", cvPoint( 200, 400 ), &font,
cvScalar( 255, 255, 0 ) );
cvShowImage( "My Window", img );
cvWaitKey();
return 0; return 0;
} }

9
doc/tutorials/introduction/load_save_image/load_save_image.rst
View File

@ -26,8 +26,7 @@ Here it is:
.. code-block:: cpp .. code-block:: cpp
:linenos: :linenos:
#include <cv.h> #include <opencv2/opencv.hpp>
#include <highgui.h>
using namespace cv; using namespace cv;
@ -45,12 +44,12 @@ Here it is:
} }
Mat gray_image; Mat gray_image;
cvtColor( image, gray_image, CV_BGR2GRAY ); cvtColor( image, gray_image, COLOR_BGR2GRAY );
imwrite( "../../images/Gray_Image.jpg", gray_image ); imwrite( "../../images/Gray_Image.jpg", gray_image );
namedWindow( imageName, CV_WINDOW_AUTOSIZE ); namedWindow( imageName, WINDOW_AUTOSIZE );
namedWindow( "Gray image", CV_WINDOW_AUTOSIZE ); namedWindow( "Gray image", WINDOW_AUTOSIZE );
imshow( imageName, image ); imshow( imageName, image );
imshow( "Gray image", gray_image ); imshow( "Gray image", gray_image );

3
include/opencv2/opencv.hpp
View File

@ -44,15 +44,14 @@
#define __OPENCV_ALL_HPP__ #define __OPENCV_ALL_HPP__
#include "opencv2/core.hpp" #include "opencv2/core.hpp"
#include "opencv2/flann/miniflann.hpp"
#include "opencv2/imgproc.hpp" #include "opencv2/imgproc.hpp"
#include "opencv2/photo.hpp" #include "opencv2/photo.hpp"
#include "opencv2/video.hpp" #include "opencv2/video.hpp"
#include "opencv2/features2d.hpp" #include "opencv2/features2d.hpp"
#include "opencv2/objdetect.hpp" #include "opencv2/objdetect.hpp"
#include "opencv2/calib3d.hpp" #include "opencv2/calib3d.hpp"
#include "opencv2/ml.hpp"
#include "opencv2/highgui.hpp" #include "opencv2/highgui.hpp"
#include "opencv2/contrib.hpp" #include "opencv2/contrib.hpp"
#include "opencv2/ml.hpp"
#endif #endif

9
modules/core/doc/drawing_functions.rst
View File

@ -507,10 +507,11 @@ The function draws contour outlines in the image if
:math:`\texttt{thickness} \ge 0` or fills the area bounded by the contours if :math:`\texttt{thickness} \ge 0` or fills the area bounded by the contours if
:math:`\texttt{thickness}<0` . The example below shows how to retrieve connected components from the binary image and label them: :: :math:`\texttt{thickness}<0` . The example below shows how to retrieve connected components from the binary image and label them: ::
#include "cv.h" #include "opencv2/imgproc.hpp"
#include "highgui.h" #include "opencv2/highgui.hpp"
using namespace cv; using namespace cv;
using namespace std;
int main( int argc, char** argv ) int main( int argc, char** argv )
{ {
@ -530,7 +531,7 @@ The function draws contour outlines in the image if
vector<Vec4i> hierarchy; vector<Vec4i> hierarchy;
findContours( src, contours, hierarchy, findContours( src, contours, hierarchy,
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE ); RETR_CCOMP, CHAIN_APPROX_SIMPLE );
// iterate through all the top-level contours, // iterate through all the top-level contours,
// draw each connected component with its own random color // draw each connected component with its own random color
@ -538,7 +539,7 @@ The function draws contour outlines in the image if
for( ; idx >= 0; idx = hierarchy[idx][0] ) for( ; idx >= 0; idx = hierarchy[idx][0] )
{ {
Scalar color( rand()&255, rand()&255, rand()&255 ); Scalar color( rand()&255, rand()&255, rand()&255 );
drawContours( dst, contours, idx, color, CV_FILLED, 8, hierarchy ); drawContours( dst, contours, idx, color, FILLED, 8, hierarchy );
} }
namedWindow( "Components", 1 ); namedWindow( "Components", 1 );

6
modules/core/doc/intro.rst
View File

@ -104,8 +104,8 @@ OpenCV deallocates the memory automatically, as well as automatically allocates
Example: :: Example: ::
#include "cv.h" #include "opencv2/imgproc.hpp"
#include "highgui.h" #include "opencv2/highgui.hpp"
using namespace cv; using namespace cv;
@ -119,7 +119,7 @@ Example: ::
for(;;) for(;;)
{ {
cap >> frame; cap >> frame;
cvtColor(frame, edges, CV_BGR2GRAY); cvtColor(frame, edges, COLOR_BGR2GRAY);
GaussianBlur(edges, edges, Size(7,7), 1.5, 1.5); GaussianBlur(edges, edges, Size(7,7), 1.5, 1.5);
Canny(edges, edges, 0, 30, 3); Canny(edges, edges, 0, 30, 3);
imshow("edges", edges); imshow("edges", edges);

1
modules/gpu/app/nv_perf_test/main.cpp
View File

@ -4,7 +4,6 @@
#include <opencv2/gpu.hpp> #include <opencv2/gpu.hpp>
#include <opencv2/highgui.hpp> #include <opencv2/highgui.hpp>
#include <opencv2/video.hpp> #include <opencv2/video.hpp>
#include <opencv2/legacy.hpp>
#include <opencv2/ts.hpp> #include <opencv2/ts.hpp>
static void printOsInfo() static void printOsInfo()

6
modules/gpu/perf/perf_core.cpp
View File

@ -1305,7 +1305,9 @@ PERF_TEST_P(Sz_3Depth, Core_AddWeighted,
// GEMM // GEMM
CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T) CV_FLAGS(GemmFlags, 0, cv::GEMM_1_T, cv::GEMM_2_T, cv::GEMM_3_T)
#define ALL_GEMM_FLAGS Values(0, CV_GEMM_A_T, CV_GEMM_B_T, CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T, CV_GEMM_A_T | CV_GEMM_C_T, CV_GEMM_A_T | CV_GEMM_B_T | CV_GEMM_C_T) #define ALL_GEMM_FLAGS Values(0, (int)cv::GEMM_1_T, (int)cv::GEMM_2_T, (int)cv::GEMM_3_T, \
(int)cv::GEMM_1_T | cv::GEMM_2_T, (int)cv::GEMM_1_T | cv::GEMM_3_T, \
(int)cv::GEMM_1_T | cv::GEMM_2_T | cv::GEMM_3_T)
DEF_PARAM_TEST(Sz_Type_Flags, cv::Size, MatType, GemmFlags); DEF_PARAM_TEST(Sz_Type_Flags, cv::Size, MatType, GemmFlags);
@ -2071,7 +2073,7 @@ PERF_TEST_P(Sz_Depth, Core_CountNonZero,
////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////
// Reduce // Reduce
CV_ENUM(ReduceCode, CV_REDUCE_SUM, CV_REDUCE_AVG, CV_REDUCE_MAX, CV_REDUCE_MIN) CV_ENUM(ReduceCode, cv::REDUCE_SUM, cv::REDUCE_AVG, cv::REDUCE_MAX, cv::REDUCE_MIN)
#define ALL_REDUCE_CODES ValuesIn(ReduceCode::all()) #define ALL_REDUCE_CODES ValuesIn(ReduceCode::all())
enum {Rows = 0, Cols = 1}; enum {Rows = 0, Cols = 1};

4
modules/gpu/perf/perf_imgproc.cpp
View File

@ -1794,7 +1794,7 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles,
cv::gpu::GpuMat d_circles; cv::gpu::GpuMat d_circles;
cv::gpu::HoughCirclesBuf d_buf; cv::gpu::HoughCirclesBuf d_buf;
TEST_CYCLE() cv::gpu::HoughCircles(d_src, d_circles, d_buf, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius); TEST_CYCLE() cv::gpu::HoughCircles(d_src, d_circles, d_buf, cv::HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
cv::Mat gpu_circles(d_circles); cv::Mat gpu_circles(d_circles);
cv::Vec3f* begin = gpu_circles.ptr<cv::Vec3f>(0); cv::Vec3f* begin = gpu_circles.ptr<cv::Vec3f>(0);
@ -1806,7 +1806,7 @@ PERF_TEST_P(Sz_Dp_MinDist, ImgProc_HoughCircles,
{ {
std::vector<cv::Vec3f> cpu_circles; std::vector<cv::Vec3f> cpu_circles;
TEST_CYCLE() cv::HoughCircles(src, cpu_circles, CV_HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius); TEST_CYCLE() cv::HoughCircles(src, cpu_circles, cv::HOUGH_GRADIENT, dp, minDist, cannyThreshold, votesThreshold, minRadius, maxRadius);
SANITY_CHECK(cpu_circles); SANITY_CHECK(cpu_circles);
} }

1
modules/gpu/perf/perf_precomp.hpp
View File

@ -63,7 +63,6 @@
#include "opencv2/calib3d.hpp" #include "opencv2/calib3d.hpp"
#include "opencv2/imgproc.hpp" #include "opencv2/imgproc.hpp"
#include "opencv2/video.hpp" #include "opencv2/video.hpp"
#include "opencv2/legacy.hpp"
#include "opencv2/photo.hpp" #include "opencv2/photo.hpp"
#include "opencv2/core/gpu_private.hpp" #include "opencv2/core/gpu_private.hpp"

1
modules/gpu/perf/perf_video.cpp
View File

@ -41,6 +41,7 @@
//M*/ //M*/
#include "perf_precomp.hpp" #include "perf_precomp.hpp"
#include "opencv2/legacy.hpp"
using namespace std; using namespace std;
using namespace testing; using namespace testing;

1
modules/gpu/perf4au/main.cpp
View File

@ -49,7 +49,6 @@
#include "opencv2/gpu.hpp" #include "opencv2/gpu.hpp"
#include "opencv2/highgui.hpp" #include "opencv2/highgui.hpp"
#include "opencv2/video.hpp" #include "opencv2/video.hpp"
#include "opencv2/legacy.hpp"
#include "opencv2/ts.hpp" #include "opencv2/ts.hpp"
#include "opencv2/ts/gpu_perf.hpp" #include "opencv2/ts/gpu_perf.hpp"

1
modules/gpu/test/test_precomp.hpp
View File

@ -73,7 +73,6 @@
#include "opencv2/ts.hpp" #include "opencv2/ts.hpp"
#include "opencv2/ts/gpu_test.hpp" #include "opencv2/ts/gpu_test.hpp"
#include "opencv2/gpu.hpp" #include "opencv2/gpu.hpp"
#include "opencv2/legacy.hpp"
#include "interpolation.hpp" #include "interpolation.hpp"
#include "main_test_nvidia.h" #include "main_test_nvidia.h"

15
modules/imgproc/doc/feature_detection.rst
View File

@ -306,8 +306,8 @@ The function finds circles in a grayscale image using a modification of the Houg
Example: :: Example: ::
#include <cv.h> #include <opencv2/imgproc.hpp>
#include <highgui.h> #include <opencv2/highgui.hpp>
#include <math.h> #include <math.h>
using namespace cv; using namespace cv;
@ -317,11 +317,11 @@ Example: ::
Mat img, gray; Mat img, gray;
if( argc != 2 && !(img=imread(argv[1], 1)).data) if( argc != 2 && !(img=imread(argv[1], 1)).data)
return -1; return -1;
cvtColor(img, gray, CV_BGR2GRAY); cvtColor(img, gray, COLOR_BGR2GRAY);
// smooth it, otherwise a lot of false circles may be detected // smooth it, otherwise a lot of false circles may be detected
GaussianBlur( gray, gray, Size(9, 9), 2, 2 ); GaussianBlur( gray, gray, Size(9, 9), 2, 2 );
vector<Vec3f> circles; vector<Vec3f> circles;
HoughCircles(gray, circles, CV_HOUGH_GRADIENT, HoughCircles(gray, circles, HOUGH_GRADIENT,
2, gray->rows/4, 200, 100 ); 2, gray->rows/4, 200, 100 );
for( size_t i = 0; i < circles.size(); i++ ) for( size_t i = 0; i < circles.size(); i++ )
{ {
@ -426,9 +426,8 @@ The function implements the probabilistic Hough transform algorithm for line det
/* This is a standalone program. Pass an image name as the first parameter /* This is a standalone program. Pass an image name as the first parameter
of the program. Switch between standard and probabilistic Hough transform of the program. Switch between standard and probabilistic Hough transform
by changing "#if 1" to "#if 0" and back */ by changing "#if 1" to "#if 0" and back */
#include <cv.h> #include <opencv2/imgproc.hpp>
#include <highgui.h> #include <opencv2/highgui.hpp>
#include <math.h>
using namespace cv; using namespace cv;
@ -439,7 +438,7 @@ The function implements the probabilistic Hough transform algorithm for line det
return -1; return -1;
Canny( src, dst, 50, 200, 3 ); Canny( src, dst, 50, 200, 3 );
cvtColor( dst, color_dst, CV_GRAY2BGR ); cvtColor( dst, color_dst, COLOR_GRAY2BGR );
#if 0 #if 0
vector<Vec2f> lines; vector<Vec2f> lines;

6
modules/imgproc/doc/histograms.rst
View File

@ -42,8 +42,8 @@ arrays. The elements of a tuple used to increment
a histogram bin are taken from the corresponding a histogram bin are taken from the corresponding
input arrays at the same location. The sample below shows how to compute a 2D Hue-Saturation histogram for a color image. :: input arrays at the same location. The sample below shows how to compute a 2D Hue-Saturation histogram for a color image. ::
#include <cv.h> #include <opencv2/imgproc.hpp>
#include <highgui.h> #include <opencv2/highgui.hpp>
using namespace cv; using namespace cv;
@ -53,7 +53,7 @@ input arrays at the same location. The sample below shows how to compute a 2D Hu
if( argc != 2 || !(src=imread(argv[1], 1)).data ) if( argc != 2 || !(src=imread(argv[1], 1)).data )
return -1; return -1;
cvtColor(src, hsv, CV_BGR2HSV); cvtColor(src, hsv, COLOR_BGR2HSV);
// Quantize the hue to 30 levels // Quantize the hue to 30 levels
// and the saturation to 32 levels // and the saturation to 32 levels

1
modules/imgproc/include/opencv2/imgproc/imgproc_c.h
View File

@ -43,7 +43,6 @@
#ifndef __OPENCV_IMGPROC_IMGPROC_C_H__ #ifndef __OPENCV_IMGPROC_IMGPROC_C_H__
#define __OPENCV_IMGPROC_IMGPROC_C_H__ #define __OPENCV_IMGPROC_IMGPROC_C_H__
#include "opencv2/core/core_c.h"
#include "opencv2/imgproc/types_c.h" #include "opencv2/imgproc/types_c.h"
#ifdef __cplusplus #ifdef __cplusplus

8
modules/legacy/include/opencv2/legacy/compat.hpp
View File

@ -39,14 +39,6 @@
// //
//M*/ //M*/
/*
A few macros and definitions for backward compatibility
with the previous versions of OpenCV. They are obsolete and
are likely to be removed in future. To check whether your code
uses any of these, define CV_NO_BACKWARD_COMPATIBILITY before
including cv.h.
*/
#ifndef __OPENCV_COMPAT_HPP__ #ifndef __OPENCV_COMPAT_HPP__
#define __OPENCV_COMPAT_HPP__ #define __OPENCV_COMPAT_HPP__

5
modules/legacy/src/corrimages.cpp
View File

@ -40,11 +40,6 @@
//M*/ //M*/
#include "precomp.hpp" #include "precomp.hpp"
//#include "cvtypes.h"
//#include <float.h>
//#include <limits.h>
//#include "cv.h"
//#include "highgui.h"
#if 0 #if 0
#include <stdio.h> #include <stdio.h>

3
modules/legacy/src/levmarprojbandle.cpp
View File

@ -41,11 +41,8 @@
#include "precomp.hpp" #include "precomp.hpp"
//#include "cvtypes.h"
#include <float.h> #include <float.h>
#include <limits.h> #include <limits.h>
//#include "cv.h"
#include <stdio.h> #include <stdio.h>
void icvReconstructPoints4DStatus(CvMat** projPoints, CvMat **projMatrs, CvMat** presPoints, CvMat *points4D,int numImages,CvMat **projError=0); void icvReconstructPoints4DStatus(CvMat** projPoints, CvMat **projMatrs, CvMat** presPoints, CvMat *points4D,int numImages,CvMat **projError=0);

4
modules/legacy/src/trifocal.cpp
View File

@ -42,12 +42,8 @@
#include "precomp.hpp" #include "precomp.hpp"
#include "opencv2/calib3d/calib3d_c.h" #include "opencv2/calib3d/calib3d_c.h"
//#include "cvtypes.h"
#include <float.h> #include <float.h>
#include <limits.h> #include <limits.h>
//#include "cv.h"
//#include "windows.h"
#include <stdio.h> #include <stdio.h>
/* Valery Mosyagin */ /* Valery Mosyagin */

1
modules/softcascade/src/octave.cpp
View File

@ -41,6 +41,7 @@
//M*/ //M*/
#include "precomp.hpp" #include "precomp.hpp"
#include "opencv2/ml.hpp"
#include <queue> #include <queue>
using cv::InputArray; using cv::InputArray;

1
modules/softcascade/src/precomp.hpp
View File

@ -45,7 +45,6 @@
#include "opencv2/softcascade.hpp" #include "opencv2/softcascade.hpp"
#include "opencv2/imgproc.hpp" #include "opencv2/imgproc.hpp"
#include "opencv2/ml.hpp"
#include "opencv2/core/private.hpp" #include "opencv2/core/private.hpp"
#include "opencv2/core/gpu_private.hpp" #include "opencv2/core/gpu_private.hpp"

18
modules/softcascade/src/softcascade_init.cpp
View File

@ -63,22 +63,4 @@ bool initModule_softcascade(void)
return (sc1->info() != 0) && (sc->info() != 0); return (sc1->info() != 0) && (sc->info() != 0);
} }
namespace internal {
void error(const char *error_string, const char *file, const int line, const char *func)
{
int code = CV_GpuApiCallError;
if (std::uncaught_exception())
{
const char* errorStr = cvErrorStr(code);
const char* function = func ? func : "unknown function";
std::cerr << "OpenCV Error: " << errorStr << "(" << error_string << ") in " << function << ", file " << file << ", line " << line;
std::cerr.flush();
}
else
cv::error( cv::Exception(code, error_string, func, file, line) );
}
}
} } } }

3
modules/ts/src/precomp.hpp
View File

@ -1,8 +1,5 @@
#include "opencv2/ts.hpp" #include "opencv2/ts.hpp"
#include "opencv2/core/core_c.h"
#include "opencv2/core/utility.hpp" #include "opencv2/core/utility.hpp"
#include "opencv2/core/private.hpp" #include "opencv2/core/private.hpp"
#ifdef GTEST_LINKED_AS_SHARED_LIBRARY #ifdef GTEST_LINKED_AS_SHARED_LIBRARY

2
modules/ts/src/ts.cpp
View File

@ -40,6 +40,8 @@
//M*/ //M*/
#include "precomp.hpp" #include "precomp.hpp"
#include "opencv2/core/core_c.h"
#include <ctype.h> #include <ctype.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdlib.h> #include <stdlib.h>

1
modules/ts/src/ts_arrtest.cpp
View File

@ -40,6 +40,7 @@
//M*/ //M*/
#include "precomp.hpp" #include "precomp.hpp"
#include "opencv2/core/core_c.h"
namespace cvtest namespace cvtest
{ {

50
modules/ts/src/ts_func.cpp
View File

@ -645,7 +645,7 @@ void erode(const Mat& _src, Mat& dst, const Mat& _kernel, Point anchor,
} }
if( anchor == Point(-1,-1) ) if( anchor == Point(-1,-1) )
anchor = Point(kernel.cols/2, kernel.rows/2); anchor = Point(kernel.cols/2, kernel.rows/2);
if( borderType == IPL_BORDER_CONSTANT ) if( borderType == BORDER_CONSTANT )
borderValue = getMaxVal(src.depth()); borderValue = getMaxVal(src.depth());
copyMakeBorder(_src, src, anchor.y, kernel.rows - anchor.y - 1, copyMakeBorder(_src, src, anchor.y, kernel.rows - anchor.y - 1,
anchor.x, kernel.cols - anchor.x - 1, anchor.x, kernel.cols - anchor.x - 1,
@ -702,7 +702,7 @@ void dilate(const Mat& _src, Mat& dst, const Mat& _kernel, Point anchor,
} }
if( anchor == Point(-1,-1) ) if( anchor == Point(-1,-1) )
anchor = Point(kernel.cols/2, kernel.rows/2); anchor = Point(kernel.cols/2, kernel.rows/2);
if( borderType == IPL_BORDER_CONSTANT ) if( borderType == BORDER_CONSTANT )
borderValue = getMinVal(src.depth()); borderValue = getMinVal(src.depth());
copyMakeBorder(_src, src, anchor.y, kernel.rows - anchor.y - 1, copyMakeBorder(_src, src, anchor.y, kernel.rows - anchor.y - 1,
anchor.x, kernel.cols - anchor.x - 1, anchor.x, kernel.cols - anchor.x - 1,
@ -778,7 +778,7 @@ void filter2D(const Mat& _src, Mat& dst, int ddepth, const Mat& kernel,
CV_Assert( kernel.type() == CV_32F || kernel.type() == CV_64F ); CV_Assert( kernel.type() == CV_32F || kernel.type() == CV_64F );
if( anchor == Point(-1,-1) ) if( anchor == Point(-1,-1) )
anchor = Point(kernel.cols/2, kernel.rows/2); anchor = Point(kernel.cols/2, kernel.rows/2);
if( borderType == IPL_BORDER_CONSTANT ) if( borderType == BORDER_CONSTANT )
borderValue = getMinVal(src.depth()); borderValue = getMinVal(src.depth());
copyMakeBorder(_src, src, anchor.y, kernel.rows - anchor.y - 1, copyMakeBorder(_src, src, anchor.y, kernel.rows - anchor.y - 1,
anchor.x, kernel.cols - anchor.x - 1, anchor.x, kernel.cols - anchor.x - 1,
@ -830,11 +830,11 @@ static int borderInterpolate( int p, int len, int borderType )
{ {
if( (unsigned)p < (unsigned)len ) if( (unsigned)p < (unsigned)len )
; ;
else if( borderType == IPL_BORDER_REPLICATE ) else if( borderType == BORDER_REPLICATE )
p = p < 0 ? 0 : len - 1; p = p < 0 ? 0 : len - 1;
else if( borderType == IPL_BORDER_REFLECT || borderType == IPL_BORDER_REFLECT_101 ) else if( borderType == BORDER_REFLECT || borderType == BORDER_REFLECT_101 )
{ {
int delta = borderType == IPL_BORDER_REFLECT_101; int delta = borderType == BORDER_REFLECT_101;
if( len == 1 ) if( len == 1 )
return 0; return 0;
do do
@ -846,17 +846,17 @@ static int borderInterpolate( int p, int len, int borderType )
} }
while( (unsigned)p >= (unsigned)len ); while( (unsigned)p >= (unsigned)len );
} }
else if( borderType == IPL_BORDER_WRAP ) else if( borderType == BORDER_WRAP )
{ {
if( p < 0 ) if( p < 0 )
p -= ((p-len+1)/len)*len; p -= ((p-len+1)/len)*len;
if( p >= len ) if( p >= len )
p %= len; p %= len;
} }
else if( borderType == IPL_BORDER_CONSTANT ) else if( borderType == BORDER_CONSTANT )
p = -1; p = -1;
else else
CV_Error( CV_StsBadArg, "Unknown/unsupported border type" ); CV_Error( Error::StsBadArg, "Unknown/unsupported border type" );
return p; return p;
} }
@ -868,7 +868,7 @@ void copyMakeBorder(const Mat& src, Mat& dst, int top, int bottom, int left, int
int i, j, k, esz = (int)src.elemSize(); int i, j, k, esz = (int)src.elemSize();
int width = src.cols*esz, width1 = dst.cols*esz; int width = src.cols*esz, width1 = dst.cols*esz;
if( borderType == IPL_BORDER_CONSTANT ) if( borderType == BORDER_CONSTANT )
{ {
vector<uchar> valvec((src.cols + left + right)*esz); vector<uchar> valvec((src.cols + left + right)*esz);
uchar* val = &valvec[0]; uchar* val = &valvec[0];
@ -1304,7 +1304,7 @@ double norm(const Mat& src, int normType, const Mat& mask)
result = norm_((const double*)sptr, total, cn, normType, result, mptr); result = norm_((const double*)sptr, total, cn, normType, result, mptr);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
}; };
} }
if( normType0 == NORM_L2 ) if( normType0 == NORM_L2 )
@ -1382,7 +1382,7 @@ double norm(const Mat& src1, const Mat& src2, int normType, const Mat& mask)
result = norm_((const double*)sptr1, (const double*)sptr2, total, cn, normType, result, mptr); result = norm_((const double*)sptr1, (const double*)sptr2, total, cn, normType, result, mptr);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
}; };
} }
if( normType0 == NORM_L2 ) if( normType0 == NORM_L2 )
@ -1441,7 +1441,7 @@ double crossCorr(const Mat& src1, const Mat& src2)
result += crossCorr_((const double*)sptr1, (const double*)sptr2, total); result += crossCorr_((const double*)sptr1, (const double*)sptr2, total);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
}; };
} }
return result; return result;
@ -1574,7 +1574,7 @@ compare_(const _Tp* src1, const _Tp* src2, uchar* dst, size_t total, int cmpop)
dst[i] = src1[i] > src2[i] ? 255 : 0; dst[i] = src1[i] > src2[i] ? 255 : 0;
break; break;
default: default:
CV_Error(CV_StsBadArg, "Unknown comparison operation"); CV_Error(Error::StsBadArg, "Unknown comparison operation");
} }
} }
@ -1610,7 +1610,7 @@ compareS_(const _Tp* src1, _WTp value, uchar* dst, size_t total, int cmpop)
dst[i] = src1[i] > value ? 255 : 0; dst[i] = src1[i] > value ? 255 : 0;
break; break;
default: default:
CV_Error(CV_StsBadArg, "Unknown comparison operation"); CV_Error(Error::StsBadArg, "Unknown comparison operation");
} }
} }
@ -1657,7 +1657,7 @@ void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop)
compare_((const double*)sptr1, (const double*)sptr2, dptr, total, cmpop); compare_((const double*)sptr1, (const double*)sptr2, dptr, total, cmpop);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }
} }
} }
@ -1704,7 +1704,7 @@ void compare(const Mat& src, double value, Mat& dst, int cmpop)
compareS_((const double*)sptr, value, dptr, total, cmpop); compareS_((const double*)sptr, value, dptr, total, cmpop);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }
} }
} }
@ -1836,7 +1836,7 @@ bool cmpUlps(const Mat& src1, const Mat& src2, int imaxDiff, double* _realmaxdif
realmaxdiff = cmpUlpsFlt_((const int64*)sptr1, (const int64*)sptr2, total, imaxDiff, startidx, idx); realmaxdiff = cmpUlpsFlt_((const int64*)sptr1, (const int64*)sptr2, total, imaxDiff, startidx, idx);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }
if(_realmaxdiff) if(_realmaxdiff)
@ -1925,7 +1925,7 @@ int check( const Mat& a, double fmin, double fmax, vector<int>* _idx )
checkFlt_((const double*)aptr, total, fmin, fmax, startidx, idx); checkFlt_((const double*)aptr, total, fmin, fmax, startidx, idx);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }
if( idx != 0 ) if( idx != 0 )
@ -2344,7 +2344,7 @@ void transform( const Mat& src, Mat& dst, const Mat& transmat, const Mat& _shift
transform_((const double*)sptr, (double*)dptr, total, scn, dcn, mat); transform_((const double*)sptr, (double*)dptr, total, scn, dcn, mat);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }
} }
} }
@ -2401,7 +2401,7 @@ static void minmax(const Mat& src1, const Mat& src2, Mat& dst, char op)
minmax_((const double*)sptr1, (const double*)sptr2, (double*)dptr, total, op); minmax_((const double*)sptr1, (const double*)sptr2, (double*)dptr, total, op);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }
} }
} }
@ -2469,7 +2469,7 @@ static void minmax(const Mat& src1, double val, Mat& dst, char op)
minmax_((const double*)sptr1, saturate_cast<double>(val), (double*)dptr, total, op); minmax_((const double*)sptr1, saturate_cast<double>(val), (double*)dptr, total, op);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }
} }
} }
@ -2541,7 +2541,7 @@ static void muldiv(const Mat& src1, const Mat& src2, Mat& dst, double scale, cha
muldiv_((const double*)sptr1, (const double*)sptr2, (double*)dptr, total, scale, op); muldiv_((const double*)sptr1, (const double*)sptr2, (double*)dptr, total, scale, op);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }
} }
} }
@ -2626,7 +2626,7 @@ Scalar mean(const Mat& src, const Mat& mask)
mean_((const double*)sptr, mptr, total, cn, sum, nz); mean_((const double*)sptr, mptr, total, cn, sum, nz);
break; break;
default: default:
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }
} }
@ -2863,7 +2863,7 @@ static void writeElems(std::ostream& out, const void* data, int nelems, int dept
out.precision(pp); out.precision(pp);
} }
else else
CV_Error(CV_StsUnsupportedFormat, ""); CV_Error(Error::StsUnsupportedFormat, "");
} }

2
modules/video/src/optflowgf.cpp
View File

@ -56,7 +56,7 @@ FarnebackPolyExp( const Mat& src, Mat& dst, int n, double sigma )
{ {
int k, x, y; int k, x, y;
assert( src.type() == CV_32FC1 ); CV_Assert( src.type() == CV_32FC1 );
int width = src.cols; int width = src.cols;
int height = src.rows; int height = src.rows;
AutoBuffer<float> kbuf(n*6 + 3), _row((width + n*2)*3); AutoBuffer<float> kbuf(n*6 + 3), _row((width + n*2)*3);

2
modules/video/src/precomp.hpp
View File

@ -44,8 +44,6 @@
#define __OPENCV_PRECOMP_H__ #define __OPENCV_PRECOMP_H__
#include "opencv2/video.hpp" #include "opencv2/video.hpp"
#include "opencv2/video/tracking_c.h"
#include "opencv2/core/utility.hpp" #include "opencv2/core/utility.hpp"
#include "opencv2/core/private.hpp" #include "opencv2/core/private.hpp"

8
samples/cpp/OpenEXRimages_HighDynamicRange_Retina_toneMapping.cpp
View File

@ -10,7 +10,8 @@
#include <iostream> #include <iostream>
#include <cstring> #include <cstring>
#include "opencv2/opencv.hpp" #include "opencv2/contrib.hpp"
#include "opencv2/highgui.hpp"
static void help(std::string errorMessage) static void help(std::string errorMessage)
{ {
@ -28,7 +29,7 @@ static void drawPlot(const cv::Mat curve, const std::string figureTitle, const i
cv::Mat displayedCurveImage = cv::Mat::ones(200, curve.size().height, CV_8U); cv::Mat displayedCurveImage = cv::Mat::ones(200, curve.size().height, CV_8U);
cv::Mat windowNormalizedCurve; cv::Mat windowNormalizedCurve;
normalize(curve, windowNormalizedCurve, 0, 200, CV_MINMAX, CV_32F); normalize(curve, windowNormalizedCurve, 0, 200, cv::NORM_MINMAX, CV_32F);
displayedCurveImage = cv::Scalar::all(255); // set a white background displayedCurveImage = cv::Scalar::all(255); // set a white background
int binW = cvRound((double)displayedCurveImage.cols/curve.size().height); int binW = cvRound((double)displayedCurveImage.cols/curve.size().height);
@ -80,8 +81,7 @@ static void drawPlot(const cv::Mat curve, const std::string figureTitle, const i
normalize(hist, normalizedHist, 1, 0, cv::NORM_L1, CV_32F); // normalize histogram so that its sum equals 1 normalize(hist, normalizedHist, 1, 0, cv::NORM_L1, CV_32F); // normalize histogram so that its sum equals 1
double min_val, max_val; double min_val, max_val;
CvMat histArr(normalizedHist); minMaxLoc(normalizedHist, &min_val, &max_val);
cvMinMaxLoc(&histArr, &min_val, &max_val);
//std::cout<<"Hist max,min = "<<max_val<<", "<<min_val<<std::endl; //std::cout<<"Hist max,min = "<<max_val<<", "<<min_val<<std::endl;
// compute density probability // compute density probability

5
samples/cpp/OpenEXRimages_HighDynamicRange_Retina_toneMapping_video.cpp
View File

@ -14,7 +14,8 @@
#include <stdio.h> #include <stdio.h>
#include <cstring> #include <cstring>
#include "opencv2/opencv.hpp" #include "opencv2/contrib.hpp"
#include "opencv2/highgui.hpp"
static void help(std::string errorMessage) static void help(std::string errorMessage)
{ {
@ -38,7 +39,7 @@ static void drawPlot(const cv::Mat curve, const std::string figureTitle, const i
cv::Mat displayedCurveImage = cv::Mat::ones(200, curve.size().height, CV_8U); cv::Mat displayedCurveImage = cv::Mat::ones(200, curve.size().height, CV_8U);
cv::Mat windowNormalizedCurve; cv::Mat windowNormalizedCurve;
normalize(curve, windowNormalizedCurve, 0, 200, CV_MINMAX, CV_32F); normalize(curve, windowNormalizedCurve, 0, 200, cv::NORM_MINMAX, CV_32F);
displayedCurveImage = cv::Scalar::all(255); // set a white background displayedCurveImage = cv::Scalar::all(255); // set a white background
int binW = cvRound((double)displayedCurveImage.cols/curve.size().height); int binW = cvRound((double)displayedCurveImage.cols/curve.size().height);

3
samples/cpp/bgfg_gmg.cpp
View File

@ -5,7 +5,8 @@
* Author: Andrew B. Godbehere * Author: Andrew B. Godbehere
*/ */
#include <opencv2/opencv.hpp> #include "opencv2/video.hpp"
#include "opencv2/highgui.hpp"
#include <opencv2/core/utility.hpp> #include <opencv2/core/utility.hpp>
#include <iostream> #include <iostream>

14
samples/cpp/detector_descriptor_evaluation.cpp
View File

@ -39,10 +39,10 @@
// //
//M*/ //M*/
#include "opencv2/imgproc/imgproc.hpp" #include "opencv2/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp" #include "opencv2/highgui.hpp"
#include "opencv2/features2d/features2d.hpp" #include "opencv2/features2d.hpp"
#include "opencv2/legacy/legacy.hpp" #include "opencv2/legacy.hpp"
#include <limits> #include <limits>
#include <cstdio> #include <cstdio>
@ -93,7 +93,7 @@ static void calcKeyPointProjections( const vector<KeyPoint>& src, const Mat_<dou
{ {
if( !src.empty() ) if( !src.empty() )
{ {
assert( !H.empty() && H.cols == 3 && H.rows == 3); CV_Assert( !H.empty() && H.cols == 3 && H.rows == 3);
dst.resize(src.size()); dst.resize(src.size());
vector<KeyPoint>::const_iterator srcIt = src.begin(); vector<KeyPoint>::const_iterator srcIt = src.begin();
vector<KeyPoint>::iterator dstIt = dst.begin(); vector<KeyPoint>::iterator dstIt = dst.begin();
@ -109,7 +109,7 @@ static void calcKeyPointProjections( const vector<KeyPoint>& src, const Mat_<dou
Mat_<double> Aff; linearizeHomographyAt(H, srcIt->pt, Aff); Mat_<double> Aff; linearizeHomographyAt(H, srcIt->pt, Aff);
Mat_<double> dstM; invert(Aff*invM*Aff.t(), dstM); Mat_<double> dstM; invert(Aff*invM*Aff.t(), dstM);
Mat_<double> eval; eigen( dstM, eval ); Mat_<double> eval; eigen( dstM, eval );
assert( eval(0,0) && eval(1,0) ); CV_Assert( eval(0,0) && eval(1,0) );
float dstSize = (float)pow(1./(eval(0,0)*eval(1,0)), 0.25); float dstSize = (float)pow(1./(eval(0,0)*eval(1,0)), 0.25);
// TODO: check angle projection // TODO: check angle projection
@ -526,7 +526,7 @@ inline void writeKeypoints( FileStorage& fs, const vector<KeyPoint>& keypoints,
inline void readKeypoints( FileStorage& fs, vector<KeyPoint>& keypoints, int imgIdx ) inline void readKeypoints( FileStorage& fs, vector<KeyPoint>& keypoints, int imgIdx )
{ {
assert( fs.isOpened() ); CV_Assert( fs.isOpened() );
stringstream imgName; imgName << "img" << imgIdx; stringstream imgName; imgName << "img" << imgIdx;
read( fs[imgName.str()], keypoints); read( fs[imgName.str()], keypoints);
} }

10
samples/cpp/em.cpp
View File

@ -1,5 +1,5 @@
#include "opencv2/legacy/legacy.hpp" #include "opencv2/highgui.hpp"
#include "opencv2/highgui/highgui.hpp" #include "opencv2/legacy.hpp"
using namespace cv; using namespace cv;
@ -45,7 +45,7 @@ int main( int /*argc*/, char** /*argv*/ )
params.start_step = CvEM::START_AUTO_STEP; params.start_step = CvEM::START_AUTO_STEP;
params.term_crit.max_iter = 300; params.term_crit.max_iter = 300;
params.term_crit.epsilon = 0.1; params.term_crit.epsilon = 0.1;
params.term_crit.type = CV_TERMCRIT_ITER|CV_TERMCRIT_EPS; params.term_crit.type = TermCriteria::COUNT|TermCriteria::EPS;
// cluster the data // cluster the data
em_model.train( samples, Mat(), params, &labels ); em_model.train( samples, Mat(), params, &labels );
@ -76,7 +76,7 @@ int main( int /*argc*/, char** /*argv*/ )
int response = cvRound(em_model.predict( sample )); int response = cvRound(em_model.predict( sample ));
Scalar c = colors[response]; Scalar c = colors[response];
circle( img, Point(j, i), 1, c*0.75, CV_FILLED ); circle( img, Point(j, i), 1, c*0.75, FILLED );
} }
} }
@ -84,7 +84,7 @@ int main( int /*argc*/, char** /*argv*/ )
for( i = 0; i < nsamples; i++ ) for( i = 0; i < nsamples; i++ )
{ {
Point pt(cvRound(samples.at<float>(i, 0)), cvRound(samples.at<float>(i, 1))); Point pt(cvRound(samples.at<float>(i, 0)), cvRound(samples.at<float>(i, 1)));
circle( img, pt, 1, colors[labels.at<int>(i)], CV_FILLED ); circle( img, pt, 1, colors[labels.at<int>(i)], FILLED );
} }
imshow( "EM-clustering result", img ); imshow( "EM-clustering result", img );

6
samples/cpp/fabmap_sample.cpp
View File

@ -49,9 +49,11 @@
// //
//M*/ //M*/
#include <iostream>
#include "opencv2/opencv.hpp" #include "opencv2/contrib.hpp"
#include "opencv2/nonfree/nonfree.hpp" #include "opencv2/highgui.hpp"
#include "opencv2/nonfree.hpp"
using namespace cv; using namespace cv;
using namespace std; using namespace std;

5
samples/cpp/freak_demo.cpp
View File

@ -43,7 +43,6 @@
#include <opencv2/highgui.hpp> #include <opencv2/highgui.hpp>
#include <opencv2/features2d.hpp> #include <opencv2/features2d.hpp>
#include <opencv2/nonfree.hpp> #include <opencv2/nonfree.hpp>
#include <opencv2/legacy.hpp>
using namespace cv; using namespace cv;
@ -95,9 +94,9 @@ int main( int argc, char** argv ) {
// MATCHER // MATCHER
// The standard Hamming distance can be used such as // The standard Hamming distance can be used such as
// BruteForceMatcher<Hamming> matcher; // BFMatcher matcher(NORM_HAMMING);
// or the proposed cascade of hamming distance using SSSE3 // or the proposed cascade of hamming distance using SSSE3
BruteForceMatcher<Hamming> matcher; BFMatcher matcher(NORM_HAMMING);
// detect // detect
double t = (double)getTickCount(); double t = (double)getTickCount();

4
samples/cpp/hybridtrackingsample.cpp
View File

@ -11,10 +11,6 @@
* *
*/ */
//#include <cv.h>
//#include <ml.h>
//#include <cvaux.h>
//#include <highgui.h>
#include <stdio.h> #include <stdio.h>
#include <time.h> #include <time.h>
#include <iostream> #include <iostream>

4
samples/cpp/logpolar_bsm.cpp
View File

@ -6,7 +6,9 @@
* PSPC-lab - University of Genoa * PSPC-lab - University of Genoa
*/ */
#include "opencv2/opencv.hpp" #include "opencv2/contrib.hpp"
#include "opencv2/highgui.hpp"
#include <iostream> #include <iostream>
#include <cmath> #include <cmath>

2
samples/cpp/morphology2.cpp
View File

@ -1,5 +1,3 @@
#define CV_NO_BACKWARD_COMPATIBILITY
#include "opencv2/imgproc/imgproc.hpp" #include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp" #include "opencv2/highgui/highgui.hpp"
#include <stdlib.h> #include <stdlib.h>

3
samples/cpp/retinaDemo.cpp
View File

@ -9,7 +9,8 @@
#include <iostream> #include <iostream>
#include <cstring> #include <cstring>
#include "opencv2/opencv.hpp" #include "opencv2/contrib.hpp"
#include "opencv2/highgui.hpp"
static void help(std::string errorMessage) static void help(std::string errorMessage)
{ {

3
samples/cpp/tutorial_code/contrib/retina_tutorial.cpp
View File

@ -9,7 +9,8 @@
#include <iostream> #include <iostream>
#include <cstring> #include <cstring>
#include "opencv2/opencv.hpp" #include "opencv2/contrib.hpp"
#include "opencv2/highgui.hpp"
static void help(std::string errorMessage) static void help(std::string errorMessage)
{ {

109
samples/gpu/performance/tests.cpp
View File

@ -1,10 +1,11 @@
#include <stdexcept> #include <stdexcept>
#include "opencv2/imgproc/imgproc.hpp" #include "opencv2/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp" #include "opencv2/highgui.hpp"
#include "opencv2/calib3d/calib3d.hpp" #include "opencv2/calib3d.hpp"
#include "opencv2/video/video.hpp" #include "opencv2/video.hpp"
#include "opencv2/gpu/gpu.hpp" #include "opencv2/gpu.hpp"
#include "opencv2/legacy/legacy.hpp"
#include "opencv2/legacy.hpp"
#include "performance.h" #include "performance.h"
#include "opencv2/opencv_modules.hpp" #include "opencv2/opencv_modules.hpp"
@ -21,7 +22,7 @@ static void InitMatchTemplate()
Mat src; gen(src, 500, 500, CV_32F, 0, 1); Mat src; gen(src, 500, 500, CV_32F, 0, 1);
Mat templ; gen(templ, 500, 500, CV_32F, 0, 1); Mat templ; gen(templ, 500, 500, CV_32F, 0, 1);
gpu::GpuMat d_src(src), d_templ(templ), d_dst; gpu::GpuMat d_src(src), d_templ(templ), d_dst;
gpu::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); gpu::matchTemplate(d_src, d_templ, d_dst, TM_CCORR);
} }
@ -39,17 +40,17 @@ TEST(matchTemplate)
SUBTEST << src.cols << 'x' << src.rows << ", 32FC1" << ", templ " << templ_size << 'x' << templ_size << ", CCORR"; SUBTEST << src.cols << 'x' << src.rows << ", 32FC1" << ", templ " << templ_size << 'x' << templ_size << ", CCORR";
gen(templ, templ_size, templ_size, CV_32F, 0, 1); gen(templ, templ_size, templ_size, CV_32F, 0, 1);
matchTemplate(src, templ, dst, CV_TM_CCORR); matchTemplate(src, templ, dst, TM_CCORR);
CPU_ON; CPU_ON;
matchTemplate(src, templ, dst, CV_TM_CCORR); matchTemplate(src, templ, dst, TM_CCORR);
CPU_OFF; CPU_OFF;
d_templ.upload(templ); d_templ.upload(templ);
gpu::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); gpu::matchTemplate(d_src, d_templ, d_dst, TM_CCORR);
GPU_ON; GPU_ON;
gpu::matchTemplate(d_src, d_templ, d_dst, CV_TM_CCORR); gpu::matchTemplate(d_src, d_templ, d_dst, TM_CCORR);
GPU_OFF; GPU_OFF;
} }
} }
@ -604,120 +605,120 @@ TEST(cvtColor)
gen(src, 4000, 4000, CV_8UC1, 0, 255); gen(src, 4000, 4000, CV_8UC1, 0, 255);
d_src.upload(src); d_src.upload(src);
SUBTEST << "4000x4000, 8UC1, CV_GRAY2BGRA"; SUBTEST << "4000x4000, 8UC1, COLOR_GRAY2BGRA";
cvtColor(src, dst, CV_GRAY2BGRA, 4); cvtColor(src, dst, COLOR_GRAY2BGRA, 4);
CPU_ON; CPU_ON;
cvtColor(src, dst, CV_GRAY2BGRA, 4); cvtColor(src, dst, COLOR_GRAY2BGRA, 4);
CPU_OFF; CPU_OFF;
gpu::cvtColor(d_src, d_dst, CV_GRAY2BGRA, 4); gpu::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
GPU_ON; GPU_ON;
gpu::cvtColor(d_src, d_dst, CV_GRAY2BGRA, 4); gpu::cvtColor(d_src, d_dst, COLOR_GRAY2BGRA, 4);
GPU_OFF; GPU_OFF;
cv::swap(src, dst); cv::swap(src, dst);
d_src.swap(d_dst); d_src.swap(d_dst);
SUBTEST << "4000x4000, 8UC3 vs 8UC4, CV_BGR2YCrCb"; SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2YCrCb";
cvtColor(src, dst, CV_BGR2YCrCb); cvtColor(src, dst, COLOR_BGR2YCrCb);
CPU_ON; CPU_ON;
cvtColor(src, dst, CV_BGR2YCrCb); cvtColor(src, dst, COLOR_BGR2YCrCb);
CPU_OFF; CPU_OFF;
gpu::cvtColor(d_src, d_dst, CV_BGR2YCrCb, 4); gpu::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
GPU_ON; GPU_ON;
gpu::cvtColor(d_src, d_dst, CV_BGR2YCrCb, 4); gpu::cvtColor(d_src, d_dst, COLOR_BGR2YCrCb, 4);
GPU_OFF; GPU_OFF;
cv::swap(src, dst); cv::swap(src, dst);
d_src.swap(d_dst); d_src.swap(d_dst);
SUBTEST << "4000x4000, 8UC4, CV_YCrCb2BGR"; SUBTEST << "4000x4000, 8UC4, COLOR_YCrCb2BGR";
cvtColor(src, dst, CV_YCrCb2BGR, 4); cvtColor(src, dst, COLOR_YCrCb2BGR, 4);
CPU_ON; CPU_ON;
cvtColor(src, dst, CV_YCrCb2BGR, 4); cvtColor(src, dst, COLOR_YCrCb2BGR, 4);
CPU_OFF; CPU_OFF;
gpu::cvtColor(d_src, d_dst, CV_YCrCb2BGR, 4); gpu::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
GPU_ON; GPU_ON;
gpu::cvtColor(d_src, d_dst, CV_YCrCb2BGR, 4); gpu::cvtColor(d_src, d_dst, COLOR_YCrCb2BGR, 4);
GPU_OFF; GPU_OFF;
cv::swap(src, dst); cv::swap(src, dst);
d_src.swap(d_dst); d_src.swap(d_dst);
SUBTEST << "4000x4000, 8UC3 vs 8UC4, CV_BGR2XYZ"; SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2XYZ";
cvtColor(src, dst, CV_BGR2XYZ); cvtColor(src, dst, COLOR_BGR2XYZ);
CPU_ON; CPU_ON;
cvtColor(src, dst, CV_BGR2XYZ); cvtColor(src, dst, COLOR_BGR2XYZ);
CPU_OFF; CPU_OFF;
gpu::cvtColor(d_src, d_dst, CV_BGR2XYZ, 4); gpu::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
GPU_ON; GPU_ON;
gpu::cvtColor(d_src, d_dst, CV_BGR2XYZ, 4); gpu::cvtColor(d_src, d_dst, COLOR_BGR2XYZ, 4);
GPU_OFF; GPU_OFF;
cv::swap(src, dst); cv::swap(src, dst);
d_src.swap(d_dst); d_src.swap(d_dst);
SUBTEST << "4000x4000, 8UC4, CV_XYZ2BGR"; SUBTEST << "4000x4000, 8UC4, COLOR_XYZ2BGR";
cvtColor(src, dst, CV_XYZ2BGR, 4); cvtColor(src, dst, COLOR_XYZ2BGR, 4);
CPU_ON; CPU_ON;
cvtColor(src, dst, CV_XYZ2BGR, 4); cvtColor(src, dst, COLOR_XYZ2BGR, 4);
CPU_OFF; CPU_OFF;
gpu::cvtColor(d_src, d_dst, CV_XYZ2BGR, 4); gpu::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
GPU_ON; GPU_ON;
gpu::cvtColor(d_src, d_dst, CV_XYZ2BGR, 4); gpu::cvtColor(d_src, d_dst, COLOR_XYZ2BGR, 4);
GPU_OFF; GPU_OFF;
cv::swap(src, dst); cv::swap(src, dst);
d_src.swap(d_dst); d_src.swap(d_dst);
SUBTEST << "4000x4000, 8UC3 vs 8UC4, CV_BGR2HSV"; SUBTEST << "4000x4000, 8UC3 vs 8UC4, COLOR_BGR2HSV";
cvtColor(src, dst, CV_BGR2HSV); cvtColor(src, dst, COLOR_BGR2HSV);
CPU_ON; CPU_ON;
cvtColor(src, dst, CV_BGR2HSV); cvtColor(src, dst, COLOR_BGR2HSV);
CPU_OFF; CPU_OFF;
gpu::cvtColor(d_src, d_dst, CV_BGR2HSV, 4); gpu::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
GPU_ON; GPU_ON;
gpu::cvtColor(d_src, d_dst, CV_BGR2HSV, 4); gpu::cvtColor(d_src, d_dst, COLOR_BGR2HSV, 4);
GPU_OFF; GPU_OFF;
cv::swap(src, dst); cv::swap(src, dst);
d_src.swap(d_dst); d_src.swap(d_dst);
SUBTEST << "4000x4000, 8UC4, CV_HSV2BGR"; SUBTEST << "4000x4000, 8UC4, COLOR_HSV2BGR";
cvtColor(src, dst, CV_HSV2BGR, 4); cvtColor(src, dst, COLOR_HSV2BGR, 4);
CPU_ON; CPU_ON;
cvtColor(src, dst, CV_HSV2BGR, 4); cvtColor(src, dst, COLOR_HSV2BGR, 4);
CPU_OFF; CPU_OFF;
gpu::cvtColor(d_src, d_dst, CV_HSV2BGR, 4); gpu::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
GPU_ON; GPU_ON;
gpu::cvtColor(d_src, d_dst, CV_HSV2BGR, 4); gpu::cvtColor(d_src, d_dst, COLOR_HSV2BGR, 4);
GPU_OFF; GPU_OFF;
cv::swap(src, dst); cv::swap(src, dst);
@ -1093,30 +1094,30 @@ TEST(reduce)
SUBTEST << size << 'x' << size << ", dim = 0"; SUBTEST << size << 'x' << size << ", dim = 0";
reduce(src, dst0, 0, CV_REDUCE_MIN); reduce(src, dst0, 0, REDUCE_MIN);
CPU_ON; CPU_ON;
reduce(src, dst0, 0, CV_REDUCE_MIN); reduce(src, dst0, 0, REDUCE_MIN);
CPU_OFF; CPU_OFF;
gpu::reduce(d_src, d_dst0, 0, CV_REDUCE_MIN); gpu::reduce(d_src, d_dst0, 0, REDUCE_MIN);
GPU_ON; GPU_ON;
gpu::reduce(d_src, d_dst0, 0, CV_REDUCE_MIN); gpu::reduce(d_src, d_dst0, 0, REDUCE_MIN);
GPU_OFF; GPU_OFF;
SUBTEST << size << 'x' << size << ", dim = 1"; SUBTEST << size << 'x' << size << ", dim = 1";
reduce(src, dst1, 1, CV_REDUCE_MIN); reduce(src, dst1, 1, REDUCE_MIN);
CPU_ON; CPU_ON;
reduce(src, dst1, 1, CV_REDUCE_MIN); reduce(src, dst1, 1, REDUCE_MIN);
CPU_OFF; CPU_OFF;
gpu::reduce(d_src, d_dst1, 1, CV_REDUCE_MIN); gpu::reduce(d_src, d_dst1, 1, REDUCE_MIN);
GPU_ON; GPU_ON;
gpu::reduce(d_src, d_dst1, 1, CV_REDUCE_MIN); gpu::reduce(d_src, d_dst1, 1, REDUCE_MIN);
GPU_OFF; GPU_OFF;
} }
} }