cmake_minimum_required(VERSION "${MIN_VER_CMAKE}" FATAL_ERROR)
endif()
+set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
+
# Following block can break build in case of cross-compilng
# but CMAKE_CROSSCOMPILING variable will be set only on project(OpenCV) command
# so we will try to detect cross-compiling by presense of CMAKE_TOOLCHAIN_FILE
OCV_OPTION(ENABLE_INSTRUMENTATION "Instrument functions to collect calls trace and performance" OFF )
OCV_OPTION(ENABLE_GNU_STL_DEBUG "Enable GNU STL Debug mode (defines _GLIBCXX_DEBUG)" OFF IF ((NOT CMAKE_VERSION VERSION_LESS "2.8.11") AND CMAKE_COMPILER_IS_GNUCXX) )
OCV_OPTION(ENABLE_BUILD_HARDENING "Enable hardening of the resulting binaries (against security attacks, detects memory corruption, etc)" OFF)
+OCV_OPTION(ENABLE_LTO "Enable Link Time Optimization" OFF IF CMAKE_COMPILER_IS_GNUCXX OR MSVC)
OCV_OPTION(GENERATE_ABI_DESCRIPTOR "Generate XML file for abi_compliance_checker tool" OFF IF UNIX)
OCV_OPTION(CV_ENABLE_INTRINSICS "Use intrinsic-based optimized code" ON )
OCV_OPTION(CV_DISABLE_OPTIMIZATION "Disable explicit optimized code (dispatched code/intrinsics/loop unrolling/etc)" OFF )
};
/****************************************************************************************\
-* Auxilary functions declarations *
-\****************************************************************************************/
-
-/* Generates <sample> from multivariate normal distribution, where <mean> - is an
- average row vector, <cov> - symmetric covariation matrix */
-CVAPI(void) cvRandMVNormal( CvMat* mean, CvMat* cov, CvMat* sample,
- CvRNG* rng CV_DEFAULT(0) );
-
-/* Generates sample from gaussian mixture distribution */
-CVAPI(void) cvRandGaussMixture( CvMat* means[],
- CvMat* covs[],
- float weights[],
- int clsnum,
- CvMat* sample,
- CvMat* sampClasses CV_DEFAULT(0) );
-
-#define CV_TS_CONCENTRIC_SPHERES 0
-
-/* creates test set */
-CVAPI(void) cvCreateTestSet( int type, CvMat** samples,
- int num_samples,
- int num_features,
- CvMat** responses,
- int num_classes, ... );
-
-/****************************************************************************************\
* Data *
\****************************************************************************************/
OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::write", "" );
}
-
void CvStatModel::read( CvFileStorage*, CvFileNode* )
{
OPENCV_ERROR( CV_StsNotImplemented, "CvStatModel::read", "" );
}
-
-/* Calculates upper triangular matrix S, where A is a symmetrical matrix A=S'*S */
-static void cvChol( CvMat* A, CvMat* S )
-{
- int dim = A->rows;
-
- int i, j, k;
- float sum;
-
- for( i = 0; i < dim; i++ )
- {
- for( j = 0; j < i; j++ )
- CV_MAT_ELEM(*S, float, i, j) = 0;
-
- sum = 0;
- for( k = 0; k < i; k++ )
- sum += CV_MAT_ELEM(*S, float, k, i) * CV_MAT_ELEM(*S, float, k, i);
-
- CV_MAT_ELEM(*S, float, i, i) = (float)sqrt(CV_MAT_ELEM(*A, float, i, i) - sum);
-
- for( j = i + 1; j < dim; j++ )
- {
- sum = 0;
- for( k = 0; k < i; k++ )
- sum += CV_MAT_ELEM(*S, float, k, i) * CV_MAT_ELEM(*S, float, k, j);
-
- CV_MAT_ELEM(*S, float, i, j) =
- (CV_MAT_ELEM(*A, float, i, j) - sum) / CV_MAT_ELEM(*S, float, i, i);
-
- }
- }
-}
-
-/* Generates <sample> from multivariate normal distribution, where <mean> - is an
- average row vector, <cov> - symmetric covariation matrix */
-CV_IMPL void cvRandMVNormal( CvMat* mean, CvMat* cov, CvMat* sample, CvRNG* rng )
-{
- int dim = sample->cols;
- int amount = sample->rows;
-
- CvRNG state = rng ? *rng : cvRNG( cvGetTickCount() );
- cvRandArr(&state, sample, CV_RAND_NORMAL, cvScalarAll(0), cvScalarAll(1) );
-
- CvMat* utmat = cvCreateMat(dim, dim, sample->type);
- CvMat* vect = cvCreateMatHeader(1, dim, sample->type);
-
- cvChol(cov, utmat);
-
- int i;
- for( i = 0; i < amount; i++ )
- {
- cvGetRow(sample, vect, i);
- cvMatMulAdd(vect, utmat, mean, vect);
- }
-
- cvReleaseMat(&vect);
- cvReleaseMat(&utmat);
-}
-
-
-/* Generates <sample> of <amount> points from a discrete variate xi,
- where Pr{xi = k} == probs[k], 0 < k < len - 1. */
-static void cvRandSeries( float probs[], int len, int sample[], int amount )
-{
- CvMat* univals = cvCreateMat(1, amount, CV_32FC1);
- float* knots = (float*)cvAlloc( len * sizeof(float) );
-
- int i, j;
-
- CvRNG state = cvRNG(-1);
- cvRandArr(&state, univals, CV_RAND_UNI, cvScalarAll(0), cvScalarAll(1) );
-
- knots[0] = probs[0];
- for( i = 1; i < len; i++ )
- knots[i] = knots[i - 1] + probs[i];
-
- for( i = 0; i < amount; i++ )
- for( j = 0; j < len; j++ )
- {
- if ( CV_MAT_ELEM(*univals, float, 0, i) <= knots[j] )
- {
- sample[i] = j;
- break;
- }
- }
-
- cvFree(&knots);
-}
-
-/* Generates <sample> from gaussian mixture distribution */
-CV_IMPL void cvRandGaussMixture( CvMat* means[],
- CvMat* covs[],
- float weights[],
- int clsnum,
- CvMat* sample,
- CvMat* sampClasses )
-{
- int dim = sample->cols;
- int amount = sample->rows;
-
- int i, clss;
-
- int* sample_clsnum = (int*)cvAlloc( amount * sizeof(int) );
- CvMat** utmats = (CvMat**)cvAlloc( clsnum * sizeof(CvMat*) );
- CvMat* vect = cvCreateMatHeader(1, dim, CV_32FC1);
-
- CvMat* classes;
- if( sampClasses )
- classes = sampClasses;
- else
- classes = cvCreateMat(1, amount, CV_32FC1);
-
- CvRNG state = cvRNG(-1);
- cvRandArr(&state, sample, CV_RAND_NORMAL, cvScalarAll(0), cvScalarAll(1));
-
- cvRandSeries(weights, clsnum, sample_clsnum, amount);
-
- for( i = 0; i < clsnum; i++ )
- {
- utmats[i] = cvCreateMat(dim, dim, CV_32FC1);
- cvChol(covs[i], utmats[i]);
- }
-
- for( i = 0; i < amount; i++ )
- {
- CV_MAT_ELEM(*classes, float, 0, i) = (float)sample_clsnum[i];
- cvGetRow(sample, vect, i);
- clss = sample_clsnum[i];
- cvMatMulAdd(vect, utmats[clss], means[clss], vect);
- }
-
- if( !sampClasses )
- cvReleaseMat(&classes);
- for( i = 0; i < clsnum; i++ )
- cvReleaseMat(&utmats[i]);
- cvFree(&utmats);
- cvFree(&sample_clsnum);
- cvReleaseMat(&vect);
-}
-
-
CvMat* icvGenerateRandomClusterCenters ( int seed, const CvMat* data,
int num_of_clusters, CvMat* _centers )
{
return _centers ? _centers : centers;
} // end of icvGenerateRandomClusterCenters
-// By S. Dilman - begin -
-
-#define ICV_RAND_MAX 4294967296 // == 2^32
-
-// static void cvRandRoundUni (CvMat* center,
-// float radius_small,
-// float radius_large,
-// CvMat* desired_matrix,
-// CvRNG* rng_state_ptr)
-// {
-// float rad, norm, coefficient;
-// int dim, size, i, j;
-// CvMat *cov, sample;
-// CvRNG rng_local;
-
-// CV_FUNCNAME("cvRandRoundUni");
-// __BEGIN__
-
-// rng_local = *rng_state_ptr;
-
-// CV_ASSERT ((radius_small >= 0) &&
-// (radius_large > 0) &&
-// (radius_small <= radius_large));
-// CV_ASSERT (center && desired_matrix && rng_state_ptr);
-// CV_ASSERT (center->rows == 1);
-// CV_ASSERT (center->cols == desired_matrix->cols);
-
-// dim = desired_matrix->cols;
-// size = desired_matrix->rows;
-// cov = cvCreateMat (dim, dim, CV_32FC1);
-// cvSetIdentity (cov);
-// cvRandMVNormal (center, cov, desired_matrix, &rng_local);
-
-// for (i = 0; i < size; i++)
-// {
-// rad = (float)(cvRandReal(&rng_local)*(radius_large - radius_small) + radius_small);
-// cvGetRow (desired_matrix, &sample, i);
-// norm = (float) cvNorm (&sample, 0, CV_L2);
-// coefficient = rad / norm;
-// for (j = 0; j < dim; j++)
-// CV_MAT_ELEM (sample, float, 0, j) *= coefficient;
-// }
-
-// __END__
-
-// }
-
-// By S. Dilman - end -
-
static int CV_CDECL
icvCmpIntegers( const void* a, const void* b )
{
namespace cv
{
-template<> CV_EXPORTS void DefaultDeleter<CvDTreeSplit>::operator ()(CvDTreeSplit* obj) const
+template<> void DefaultDeleter<CvDTreeSplit>::operator ()(CvDTreeSplit* obj) const
{
fastFree(obj);
}
OPENCV_EXTRA_FLAGS_RELEASE OPENCV_EXTRA_FLAGS_DEBUG OPENCV_EXTRA_C_FLAGS OPENCV_EXTRA_CXX_FLAGS)
string(REPLACE "-fomit-frame-pointer" "" ${flags} "${${flags}}")
string(REPLACE "-ffunction-sections" "" ${flags} "${${flags}}")
+ string(REPLACE "-fdata-sections" "" ${flags} "${${flags}}")
endforeach()
elseif(NOT ((IOS OR ANDROID) AND NOT BUILD_SHARED_LIBS))
# Remove unreferenced functions: function level linking
add_extra_compiler_option(-ffunction-sections)
+ add_extra_compiler_option(-fdata-sections)
+ if(NOT APPLE)
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
+ endif()
endif()
if(ENABLE_COVERAGE)
set(WITH_VTK OFF) # There are issues with VTK 6.0
endif()
+ if(ENABLE_LTO)
+ add_extra_compiler_option(-flto)
+ endif()
+
set(OPENCV_EXTRA_FLAGS_RELEASE "${OPENCV_EXTRA_FLAGS_RELEASE} -DNDEBUG")
if(NOT " ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG} " MATCHES "-O")
set(OPENCV_EXTRA_FLAGS_DEBUG "${OPENCV_EXTRA_FLAGS_DEBUG} -O0")
if(OPENCV_WARNINGS_ARE_ERRORS)
set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /WX")
endif()
+
+ if(ENABLE_LTO)
+ set(OPENCV_EXTRA_FLAGS "${OPENCV_EXTRA_FLAGS} /GL")
+ set(OPENCV_EXTRA_EXE_LINKER_FLAGS "${OPENCV_EXTRA_EXE_LINKER_FLAGS} /LTCG")
+ endif()
+
endif()
if(MSVC12 AND NOT CMAKE_GENERATOR MATCHES "Visual Studio")
set(OPENCV_EXTRA_CXX_FLAGS "${OPENCV_EXTRA_CXX_FLAGS} /AI\$(WindowsSDK_MetadataPath)")
endif()
-# Extra link libs if the user selects building static libs:
-if(NOT BUILD_SHARED_LIBS AND CMAKE_COMPILER_IS_GNUCXX AND NOT ANDROID)
- # Android does not need these settings because they are already set by toolchain file
- if(NOT MINGW)
- set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} stdc++)
- endif()
- set(OPENCV_EXTRA_FLAGS "-fPIC ${OPENCV_EXTRA_FLAGS}")
-endif()
-
include(cmake/OpenCVCompilerOptimizations.cmake)
if(COMMAND ocv_compiler_optimization_options)
${${the_module}_pch}
${_VS_VERSION_FILE}
)
-
set_target_properties(${the_module} PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};Module")
set_source_files_properties(${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES} ${${the_module}_pch}
PROPERTIES LABELS "${OPENCV_MODULE_${the_module}_LABEL};Module")
COMPILE_PDB_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+ DEFINE_SYMBOL CVAPI_EXPORTS
)
+ if(ANDROID AND BUILD_FAT_JAVA_LIB)
+ target_compile_definitions(${the_module} PRIVATE CVAPI_EXPORTS)
+ endif()
+
# For dynamic link numbering convenions
if(NOT ANDROID)
# Android SDK build scripts can include only .so files into final .apk
)
endif()
- if((NOT DEFINED OPENCV_MODULE_TYPE AND BUILD_SHARED_LIBS)
- OR (DEFINED OPENCV_MODULE_TYPE AND OPENCV_MODULE_TYPE STREQUAL SHARED))
- set_target_properties(${the_module} PROPERTIES DEFINE_SYMBOL CVAPI_EXPORTS)
- endif()
-
if (ENABLE_GNU_STL_DEBUG)
target_compile_definitions(${the_module} PUBLIC _GLIBCXX_DEBUG)
endif()
# define DISABLE_OPENCV_24_COMPATIBILITY
#endif
-#if (defined _WIN32 || defined WINCE || defined __CYGWIN__) && defined CVAPI_EXPORTS
-# define CV_EXPORTS __declspec(dllexport)
-#elif defined __GNUC__ && __GNUC__ >= 4
-# define CV_EXPORTS __attribute__ ((visibility ("default")))
+#ifdef CVAPI_EXPORTS
+# if (defined _WIN32 || defined WINCE || defined __CYGWIN__)
+# define CV_EXPORTS __declspec(dllexport)
+# elif defined __GNUC__ && __GNUC__ >= 4
+# define CV_EXPORTS __attribute__ ((visibility ("default")))
+# endif
+#endif
+
+#ifndef CV_EXPORTS
+# define CV_EXPORTS
+#endif
+
+#ifdef _MSC_VER
+# define CV_EXPORTS_TEMPLATE
#else
-# define CV_EXPORTS
+# define CV_EXPORTS_TEMPLATE CV_EXPORTS
#endif
#ifndef CV_DEPRECATED
//! Allocate all memory buffers which will not be freed, ease filtering memcheck issues
template <typename T>
-CV_EXPORTS T* allocSingleton(size_t count) { return static_cast<T*>(fastMalloc(sizeof(T) * count)); }
+T* allocSingleton(size_t count) { return static_cast<T*>(fastMalloc(sizeof(T) * count)); }
}
// property implementation macros
#include <iostream>
#include "opencv2/ts.hpp"
+#include "opencv2/ts/ocl_test.hpp"
#include "opencv2/core/core_c.h"
#include "opencv2/core/cvdef.h"
* Euclidean distance functor
*/
template<class T>
-struct CV_EXPORTS L2
+struct L2
{
enum { normType = NORM_L2 };
typedef T ValueType;
* Manhattan distance (city block distance) functor
*/
template<class T>
-struct CV_EXPORTS L1
+struct L1
{
enum { normType = NORM_L1 };
typedef T ValueType;
namespace cvflann
{
-#if (defined _WIN32 || defined WINCE) && defined CVAPI_EXPORTS
-__declspec(dllexport)
-#endif
-void dummyfunc();
+CV_DEPRECATED inline void dummyfunc() {}
}
flann_distance_type_ = distance_type;
}
- void dummyfunc() {}
}
#include "opencv2/flann/params.h"
#include "opencv2/flann/saving.h"
#include "opencv2/flann/general.h"
-#include "opencv2/flann/dummy.h"
// index types
#include "opencv2/flann/all_indices.h"
ocv_add_library(${the_module} SHARED ${handwritten_h_sources} ${handwritten_cpp_sources} ${generated_cpp_sources}
- ${copied_files}
- "${JAR_FILE}" "${JAR_FILE}.dephelper")
+ ${copied_files}
+ "${JAR_FILE}" "${JAR_FILE}.dephelper")
if(BUILD_FAT_JAVA_LIB)
set(__deps ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULES_BUILD})
ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH}
RUNTIME_OUTPUT_DIRECTORY ${EXECUTABLE_OUTPUT_PATH}
+ DEFINE_SYMBOL CVAPI_EXPORTS
)
if(ANDROID)
set_target_properties(${the_module} PROPERTIES
LIBRARY_OUTPUT_DIRECTORY "${LIBRARY_OUTPUT_PATH}/${MODULE_INSTALL_SUBDIR}"
ARCHIVE_OUTPUT_NAME ${the_module} # prevent name conflict for python2/3 outputs
+ DEFINE_SYMBOL CVAPI_EXPORTS
PREFIX ""
OUTPUT_NAME cv2
SUFFIX ${CVPY_SUFFIX})
/** @brief Base class for rotation-based warper using a detail::ProjectorBase_ derived class.
*/
template <class P>
-class CV_EXPORTS RotationWarperBase : public RotationWarper
+class CV_EXPORTS_TEMPLATE RotationWarperBase : public RotationWarper
{
public:
Point2f warpPoint(const Point2f &pt, InputArray K, InputArray R);
};
-struct SphericalPortraitProjector : ProjectorBase
+struct CV_EXPORTS SphericalPortraitProjector : ProjectorBase
{
void mapForward(float x, float y, float &u, float &v);
void mapBackward(float u, float v, float &x, float &y);
void detectResultRoi(Size src_size, Point &dst_tl, Point &dst_br);
};
-struct CylindricalPortraitProjector : ProjectorBase
+struct CV_EXPORTS CylindricalPortraitProjector : ProjectorBase
{
void mapForward(float x, float y, float &u, float &v);
void mapBackward(float u, float v, float &x, float &y);
}
};
-struct PlanePortraitProjector : ProjectorBase
+struct CV_EXPORTS PlanePortraitProjector : ProjectorBase
{
void mapForward(float x, float y, float &u, float &v);
void mapBackward(float u, float v, float &x, float &y);
SkipTestException(const cv::String& message) : dummy(0) { this->msg = message; }
};
-class CV_EXPORTS TS;
+class TS;
-CV_EXPORTS int64 readSeed(const char* str);
+int64 readSeed(const char* str);
-CV_EXPORTS void randUni( RNG& rng, Mat& a, const Scalar& param1, const Scalar& param2 );
+void randUni( RNG& rng, Mat& a, const Scalar& param1, const Scalar& param2 );
inline unsigned randInt( RNG& rng )
{
}
-CV_EXPORTS const char* getTypeName( int type );
-CV_EXPORTS int typeByName( const char* type_name );
+const char* getTypeName( int type );
+int typeByName( const char* type_name );
-CV_EXPORTS string vec2str(const string& sep, const int* v, size_t nelems);
+string vec2str(const string& sep, const int* v, size_t nelems);
inline int clipInt( int val, int min_val, int max_val )
{
return val;
}
-CV_EXPORTS double getMinVal(int depth);
-CV_EXPORTS double getMaxVal(int depth);
+double getMinVal(int depth);
+double getMaxVal(int depth);
-CV_EXPORTS Size randomSize(RNG& rng, double maxSizeLog);
-CV_EXPORTS void randomSize(RNG& rng, int minDims, int maxDims, double maxSizeLog, vector<int>& sz);
-CV_EXPORTS int randomType(RNG& rng, int typeMask, int minChannels, int maxChannels);
-CV_EXPORTS Mat randomMat(RNG& rng, Size size, int type, double minVal, double maxVal, bool useRoi);
-CV_EXPORTS Mat randomMat(RNG& rng, const vector<int>& size, int type, double minVal, double maxVal, bool useRoi);
-CV_EXPORTS void add(const Mat& a, double alpha, const Mat& b, double beta,
+Size randomSize(RNG& rng, double maxSizeLog);
+void randomSize(RNG& rng, int minDims, int maxDims, double maxSizeLog, vector<int>& sz);
+int randomType(RNG& rng, int typeMask, int minChannels, int maxChannels);
+Mat randomMat(RNG& rng, Size size, int type, double minVal, double maxVal, bool useRoi);
+Mat randomMat(RNG& rng, const vector<int>& size, int type, double minVal, double maxVal, bool useRoi);
+void add(const Mat& a, double alpha, const Mat& b, double beta,
Scalar gamma, Mat& c, int ctype, bool calcAbs=false);
-CV_EXPORTS void multiply(const Mat& a, const Mat& b, Mat& c, double alpha=1);
-CV_EXPORTS void divide(const Mat& a, const Mat& b, Mat& c, double alpha=1);
+void multiply(const Mat& a, const Mat& b, Mat& c, double alpha=1);
+void divide(const Mat& a, const Mat& b, Mat& c, double alpha=1);
-CV_EXPORTS void convert(const Mat& src, cv::OutputArray dst, int dtype, double alpha=1, double beta=0);
-CV_EXPORTS void copy(const Mat& src, Mat& dst, const Mat& mask=Mat(), bool invertMask=false);
-CV_EXPORTS void set(Mat& dst, const Scalar& gamma, const Mat& mask=Mat());
+void convert(const Mat& src, cv::OutputArray dst, int dtype, double alpha=1, double beta=0);
+void copy(const Mat& src, Mat& dst, const Mat& mask=Mat(), bool invertMask=false);
+void set(Mat& dst, const Scalar& gamma, const Mat& mask=Mat());
// working with multi-channel arrays
-CV_EXPORTS void extract( const Mat& a, Mat& plane, int coi );
-CV_EXPORTS void insert( const Mat& plane, Mat& a, int coi );
+void extract( const Mat& a, Mat& plane, int coi );
+void insert( const Mat& plane, Mat& a, int coi );
// checks that the array does not have NaNs and/or Infs and all the elements are
// within [min_val,max_val). idx is the index of the first "bad" element.
-CV_EXPORTS int check( const Mat& data, double min_val, double max_val, vector<int>* idx );
+int check( const Mat& data, double min_val, double max_val, vector<int>* idx );
// modifies values that are close to zero
-CV_EXPORTS void patchZeros( Mat& mat, double level );
+void patchZeros( Mat& mat, double level );
-CV_EXPORTS void transpose(const Mat& src, Mat& dst);
-CV_EXPORTS void erode(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
+void transpose(const Mat& src, Mat& dst);
+void erode(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
int borderType=0, const Scalar& borderValue=Scalar());
-CV_EXPORTS void dilate(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
+void dilate(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
int borderType=0, const Scalar& borderValue=Scalar());
-CV_EXPORTS void filter2D(const Mat& src, Mat& dst, int ddepth, const Mat& kernel,
+void filter2D(const Mat& src, Mat& dst, int ddepth, const Mat& kernel,
Point anchor, double delta, int borderType,
const Scalar& borderValue=Scalar());
-CV_EXPORTS void copyMakeBorder(const Mat& src, Mat& dst, int top, int bottom, int left, int right,
+void copyMakeBorder(const Mat& src, Mat& dst, int top, int bottom, int left, int right,
int borderType, const Scalar& borderValue=Scalar());
-CV_EXPORTS Mat calcSobelKernel2D( int dx, int dy, int apertureSize, int origin=0 );
-CV_EXPORTS Mat calcLaplaceKernel2D( int aperture_size );
+Mat calcSobelKernel2D( int dx, int dy, int apertureSize, int origin=0 );
+Mat calcLaplaceKernel2D( int aperture_size );
-CV_EXPORTS void initUndistortMap( const Mat& a, const Mat& k, Size sz, Mat& mapx, Mat& mapy );
+void initUndistortMap( const Mat& a, const Mat& k, Size sz, Mat& mapx, Mat& mapy );
-CV_EXPORTS void minMaxLoc(const Mat& src, double* minval, double* maxval,
+void minMaxLoc(const Mat& src, double* minval, double* maxval,
vector<int>* minloc, vector<int>* maxloc, const Mat& mask=Mat());
-CV_EXPORTS double norm(InputArray src, int normType, InputArray mask=noArray());
-CV_EXPORTS double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray());
-CV_EXPORTS Scalar mean(const Mat& src, const Mat& mask=Mat());
-CV_EXPORTS double PSNR(InputArray src1, InputArray src2);
+double norm(InputArray src, int normType, InputArray mask=noArray());
+double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray());
+Scalar mean(const Mat& src, const Mat& mask=Mat());
+double PSNR(InputArray src1, InputArray src2);
-CV_EXPORTS bool cmpUlps(const Mat& data, const Mat& refdata, int expMaxDiff, double* realMaxDiff, vector<int>* idx);
+bool cmpUlps(const Mat& data, const Mat& refdata, int expMaxDiff, double* realMaxDiff, vector<int>* idx);
// compares two arrays. max_diff is the maximum actual difference,
// success_err_level is maximum allowed difference, idx is the index of the first
// element for which difference is >success_err_level
// (or index of element with the maximum difference)
-CV_EXPORTS int cmpEps( const Mat& data, const Mat& refdata, double* max_diff,
+int cmpEps( const Mat& data, const Mat& refdata, double* max_diff,
double success_err_level, vector<int>* idx,
bool element_wise_relative_error );
// a wrapper for the previous function. in case of error prints the message to log file.
-CV_EXPORTS int cmpEps2( TS* ts, const Mat& data, const Mat& refdata, double success_err_level,
+int cmpEps2( TS* ts, const Mat& data, const Mat& refdata, double success_err_level,
bool element_wise_relative_error, const char* desc );
-CV_EXPORTS int cmpEps2_64f( TS* ts, const double* val, const double* refval, int len,
+int cmpEps2_64f( TS* ts, const double* val, const double* refval, int len,
double eps, const char* param_name );
-CV_EXPORTS void logicOp(const Mat& src1, const Mat& src2, Mat& dst, char c);
-CV_EXPORTS void logicOp(const Mat& src, const Scalar& s, Mat& dst, char c);
-CV_EXPORTS void min(const Mat& src1, const Mat& src2, Mat& dst);
-CV_EXPORTS void min(const Mat& src, double s, Mat& dst);
-CV_EXPORTS void max(const Mat& src1, const Mat& src2, Mat& dst);
-CV_EXPORTS void max(const Mat& src, double s, Mat& dst);
+void logicOp(const Mat& src1, const Mat& src2, Mat& dst, char c);
+void logicOp(const Mat& src, const Scalar& s, Mat& dst, char c);
+void min(const Mat& src1, const Mat& src2, Mat& dst);
+void min(const Mat& src, double s, Mat& dst);
+void max(const Mat& src1, const Mat& src2, Mat& dst);
+void max(const Mat& src, double s, Mat& dst);
-CV_EXPORTS void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop);
-CV_EXPORTS void compare(const Mat& src, double s, Mat& dst, int cmpop);
-CV_EXPORTS void gemm(const Mat& src1, const Mat& src2, double alpha,
+void compare(const Mat& src1, const Mat& src2, Mat& dst, int cmpop);
+void compare(const Mat& src, double s, Mat& dst, int cmpop);
+void gemm(const Mat& src1, const Mat& src2, double alpha,
const Mat& src3, double beta, Mat& dst, int flags);
-CV_EXPORTS void transform( const Mat& src, Mat& dst, const Mat& transmat, const Mat& shift );
-CV_EXPORTS double crossCorr(const Mat& src1, const Mat& src2);
-CV_EXPORTS void threshold( const Mat& src, Mat& dst, double thresh, double maxval, int thresh_type );
-CV_EXPORTS void minMaxIdx( InputArray _img, double* minVal, double* maxVal,
+void transform( const Mat& src, Mat& dst, const Mat& transmat, const Mat& shift );
+double crossCorr(const Mat& src1, const Mat& src2);
+void threshold( const Mat& src, Mat& dst, double thresh, double maxval, int thresh_type );
+void minMaxIdx( InputArray _img, double* minVal, double* maxVal,
Point* minLoc, Point* maxLoc, InputArray _mask );
-struct CV_EXPORTS MatInfo
+struct MatInfo
{
MatInfo(const Mat& _m) : m(&_m) {}
const Mat* m;
};
-CV_EXPORTS std::ostream& operator << (std::ostream& out, const MatInfo& m);
+std::ostream& operator << (std::ostream& out, const MatInfo& m);
-struct CV_EXPORTS MatComparator
+struct MatComparator
{
public:
MatComparator(double maxdiff, int context);
class BaseTest;
class TS;
-class CV_EXPORTS BaseTest
+class BaseTest
{
public:
// constructor(s) and destructor
\*****************************************************************************************/
// common parameters:
-struct CV_EXPORTS TSParams
+struct TSParams
{
TSParams();
};
-class CV_EXPORTS TS
+class TS
{
public:
// constructor(s) and destructor
* Subclass of BaseTest for testing functions that process dense arrays *
\*****************************************************************************************/
-class CV_EXPORTS ArrayTest : public BaseTest
+class ArrayTest : public BaseTest
{
public:
// constructor(s) and destructor
};
-class CV_EXPORTS BadArgTest : public BaseTest
+class BadArgTest : public BaseTest
{
public:
// constructor(s) and destructor
extern uint64 param_seed;
-struct CV_EXPORTS DefaultRngAuto
+struct DefaultRngAuto
{
const uint64 old_state;
// test images generation functions
-CV_EXPORTS void fillGradient(Mat& img, int delta = 5);
-CV_EXPORTS void smoothBorder(Mat& img, const Scalar& color, int delta = 3);
+void fillGradient(Mat& img, int delta = 5);
+void smoothBorder(Mat& img, const Scalar& color, int delta = 3);
-CV_EXPORTS void printVersionInfo(bool useStdOut = true);
+void printVersionInfo(bool useStdOut = true);
// Utility functions
-CV_EXPORTS void addDataSearchPath(const std::string& path);
-CV_EXPORTS void addDataSearchSubDirectory(const std::string& subdir);
+void addDataSearchPath(const std::string& path);
+void addDataSearchSubDirectory(const std::string& subdir);
/*! @brief Try to find requested data file
- modulename from TS::init()
*/
-CV_EXPORTS std::string findDataFile(const std::string& relative_path, bool required = true);
+std::string findDataFile(const std::string& relative_path, bool required = true);
#ifndef __CV_TEST_EXEC_ARGS
SANITY_CHECK(cpu_##mat, ## __VA_ARGS__); \
} while(0)
- CV_EXPORTS cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
+ cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
struct CvtColorInfo
{
CvtColorInfo() {}
explicit CvtColorInfo(int scn_, int dcn_, int code_) : scn(scn_), dcn(dcn_), code(code_) {}
};
- CV_EXPORTS void PrintTo(const CvtColorInfo& info, std::ostream* os);
+ void PrintTo(const CvtColorInfo& info, std::ostream* os);
- CV_EXPORTS void printCudaInfo();
+ void printCudaInfo();
- CV_EXPORTS void sortKeyPoints(std::vector<cv::KeyPoint>& keypoints, cv::InputOutputArray _descriptors = cv::noArray());
+ void sortKeyPoints(std::vector<cv::KeyPoint>& keypoints, cv::InputOutputArray _descriptors = cv::noArray());
#ifdef HAVE_CUDA
#define CV_PERF_TEST_CUDA_MAIN(modulename) \
//////////////////////////////////////////////////////////////////////
// random generators
- CV_EXPORTS int randomInt(int minVal, int maxVal);
- CV_EXPORTS double randomDouble(double minVal, double maxVal);
- CV_EXPORTS cv::Size randomSize(int minVal, int maxVal);
- CV_EXPORTS cv::Scalar randomScalar(double minVal, double maxVal);
- CV_EXPORTS cv::Mat randomMat(cv::Size size, int type, double minVal = 0.0, double maxVal = 255.0);
+ int randomInt(int minVal, int maxVal);
+ double randomDouble(double minVal, double maxVal);
+ cv::Size randomSize(int minVal, int maxVal);
+ cv::Scalar randomScalar(double minVal, double maxVal);
+ cv::Mat randomMat(cv::Size size, int type, double minVal = 0.0, double maxVal = 255.0);
//////////////////////////////////////////////////////////////////////
// GpuMat create
- CV_EXPORTS cv::cuda::GpuMat createMat(cv::Size size, int type, bool useRoi = false);
- CV_EXPORTS cv::cuda::GpuMat loadMat(const cv::Mat& m, bool useRoi = false);
+ cv::cuda::GpuMat createMat(cv::Size size, int type, bool useRoi = false);
+ cv::cuda::GpuMat loadMat(const cv::Mat& m, bool useRoi = false);
//////////////////////////////////////////////////////////////////////
// Image load
//! read image from testdata folder
- CV_EXPORTS cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
+ cv::Mat readImage(const std::string& fileName, int flags = cv::IMREAD_COLOR);
//! read image from testdata folder and convert it to specified type
- CV_EXPORTS cv::Mat readImageType(const std::string& fname, int type);
+ cv::Mat readImageType(const std::string& fname, int type);
//////////////////////////////////////////////////////////////////////
// Gpu devices
//! return true if device supports specified feature and gpu module was built with support the feature.
- CV_EXPORTS bool supportFeature(const cv::cuda::DeviceInfo& info, cv::cuda::FeatureSet feature);
+ bool supportFeature(const cv::cuda::DeviceInfo& info, cv::cuda::FeatureSet feature);
- class CV_EXPORTS DeviceManager
+ class DeviceManager
{
public:
static DeviceManager& instance();
//////////////////////////////////////////////////////////////////////
// Additional assertion
- CV_EXPORTS void minMaxLocGold(const cv::Mat& src, double* minVal_, double* maxVal_ = 0, cv::Point* minLoc_ = 0, cv::Point* maxLoc_ = 0, const cv::Mat& mask = cv::Mat());
+ void minMaxLocGold(const cv::Mat& src, double* minVal_, double* maxVal_ = 0, cv::Point* minLoc_ = 0, cv::Point* maxLoc_ = 0, const cv::Mat& mask = cv::Mat());
- CV_EXPORTS cv::Mat getMat(cv::InputArray arr);
+ cv::Mat getMat(cv::InputArray arr);
- CV_EXPORTS testing::AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, cv::InputArray m1, cv::InputArray m2, double eps);
+ testing::AssertionResult assertMatNear(const char* expr1, const char* expr2, const char* eps_expr, cv::InputArray m1, cv::InputArray m2, double eps);
#undef EXPECT_MAT_NEAR
#define EXPECT_MAT_NEAR(m1, m2, eps) EXPECT_PRED_FORMAT3(cvtest::assertMatNear, m1, m2, eps)
ASSERT_NEAR(p1.z, p2.z, eps); \
}
- CV_EXPORTS double checkSimilarity(cv::InputArray m1, cv::InputArray m2);
+ double checkSimilarity(cv::InputArray m1, cv::InputArray m2);
#undef EXPECT_MAT_SIMILAR
#define EXPECT_MAT_SIMILAR(mat1, mat2, eps) \
using perf::MatType;
//! return vector with types from specified range.
- CV_EXPORTS std::vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end);
+ std::vector<MatType> types(int depth_start, int depth_end, int cn_start, int cn_end);
//! return vector with all types (depth: CV_8U-CV_64F, channels: 1-4).
- CV_EXPORTS const std::vector<MatType>& all_types();
+ const std::vector<MatType>& all_types();
#define ALL_TYPES testing::ValuesIn(all_types())
#define TYPES(depth_start, depth_end, cn_start, cn_end) testing::ValuesIn(types(depth_start, depth_end, cn_start, cn_end))
bool val_;
};
- CV_EXPORTS void PrintTo(const UseRoi& useRoi, std::ostream* os);
+ void PrintTo(const UseRoi& useRoi, std::ostream* os);
#define WHOLE_SUBMAT testing::Values(UseRoi(false), UseRoi(true))
bool val_;
};
- CV_EXPORTS void PrintTo(const Inverse& useRoi, std::ostream* os);
+ void PrintTo(const Inverse& useRoi, std::ostream* os);
#define DIRECT_INVERSE testing::Values(Inverse(false), Inverse(true))
//////////////////////////////////////////////////////////////////////
// Features2D
- CV_EXPORTS testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char* actual_expr, std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual);
+ testing::AssertionResult assertKeyPointsEquals(const char* gold_expr, const char* actual_expr, std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual);
#define ASSERT_KEYPOINTS_EQ(gold, actual) EXPECT_PRED_FORMAT2(assertKeyPointsEquals, gold, actual)
- CV_EXPORTS int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual);
- CV_EXPORTS int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std::vector<cv::KeyPoint>& keypoints2, const std::vector<cv::DMatch>& matches);
+ int getMatchedPointsCount(std::vector<cv::KeyPoint>& gold, std::vector<cv::KeyPoint>& actual);
+ int getMatchedPointsCount(const std::vector<cv::KeyPoint>& keypoints1, const std::vector<cv::KeyPoint>& keypoints2, const std::vector<cv::DMatch>& matches);
//////////////////////////////////////////////////////////////////////
// Other
- CV_EXPORTS void dumpImage(const std::string& fileName, const cv::Mat& image);
- CV_EXPORTS void showDiff(cv::InputArray gold, cv::InputArray actual, double eps);
+ void dumpImage(const std::string& fileName, const cv::Mat& image);
+ void showDiff(cv::InputArray gold, cv::InputArray actual, double eps);
- CV_EXPORTS void parseCudaDeviceOptions(int argc, char **argv);
- CV_EXPORTS void printCudaInfo();
+ void parseCudaDeviceOptions(int argc, char **argv);
+ void printCudaInfo();
}
namespace cv { namespace cuda
{
- CV_EXPORTS void PrintTo(const DeviceInfo& info, std::ostream* os);
+ void PrintTo(const DeviceInfo& info, std::ostream* os);
}}
#ifdef HAVE_CUDA
namespace perf {
// Check for current device limitation
-CV_EXPORTS void checkDeviceMaxMemoryAllocSize(const Size& size, int type, int factor = 1);
+void checkDeviceMaxMemoryAllocSize(const Size& size, int type, int factor = 1);
// Initialize Mat with random numbers. Range is depends on the data type.
// TODO Parameter type is actually OutputArray
-CV_EXPORTS void randu(InputOutputArray dst);
+void randu(InputOutputArray dst);
inline void safeFinish()
{
#define EXPECT_MAT_NEAR_RELATIVE(mat1, mat2, eps) \
do \
{ \
- ASSERT_EQ(mat1.type(), mat2.type()); \
- ASSERT_EQ(mat1.size(), mat2.size()); \
- EXPECT_LE(TestUtils::checkNormRelative(mat1, mat2), eps) \
- << "Size: " << mat1.size() << std::endl; \
+ ASSERT_EQ((mat1).type(), (mat2).type()); \
+ ASSERT_EQ((mat1).size(), (mat2).size()); \
+ EXPECT_LE(TestUtils::checkNormRelative((mat1), (mat2)), eps) \
+ << "Size: " << (mat1).size() << std::endl; \
} while ((void)0, 0)
#define EXPECT_MAT_N_DIFF(mat1, mat2, num) \
#define OCL_RNG_SEED 123456
-struct CV_EXPORTS TestUtils
+struct TestUtils
{
cv::RNG rng;
#define UMAT_UPLOAD_OUTPUT_PARAMETER(name) UMAT_UPLOAD_INPUT_PARAMETER(name)
template <typename T>
-struct CV_EXPORTS TSTestWithParam : public TestUtils, public ::testing::TestWithParam<T>
+struct TSTestWithParam : public TestUtils, public ::testing::TestWithParam<T>
{
};
#endif // _MSC_VER
#ifndef GTEST_API_
-# define GTEST_API_ CV_EXPORTS
+# define GTEST_API_
#endif
#ifdef __GNUC__
ERROR_RELATIVE = 1
};
-class CV_EXPORTS Regression
+class Regression
{
public:
static Regression& add(TestBase* test, const std::string& name, cv::InputArray array, double eps = DBL_EPSILON, ERROR_TYPE err = ERROR_ABSOLUTE);
#define SANITY_CHECK_MATCHES(array, ...) ::perf::Regression::addMatches(this, #array, array , ## __VA_ARGS__)
#define SANITY_CHECK_NOTHING() this->setVerified()
-class CV_EXPORTS GpuPerf
+class GpuPerf
{
public:
static bool targetDevice();
/*****************************************************************************************\
* Container for performance metrics *
\*****************************************************************************************/
-typedef struct CV_EXPORTS performance_metrics
+typedef struct performance_metrics
{
size_t bytesIn;
size_t bytesOut;
};
#endif
-class CV_EXPORTS TestBase: public ::testing::Test
+class TestBase: public ::testing::Test
{
public:
TestBase();
static cv::Size getSize(cv::InputArray a);
static void declareArray(SizeVector& sizes, cv::InputOutputArray a, WarmUpType wtype);
- class CV_EXPORTS _declareHelper
+ class _declareHelper
{
public:
_declareHelper& in(cv::InputOutputArray a1, WarmUpType wtype = WARMUP_READ);
/*****************************************************************************************\
* Print functions for googletest *
\*****************************************************************************************/
-CV_EXPORTS void PrintTo(const MatType& t, std::ostream* os);
+void PrintTo(const MatType& t, std::ostream* os);
} //namespace perf
namespace cv
{
-CV_EXPORTS void PrintTo(const String& str, ::std::ostream* os);
-CV_EXPORTS void PrintTo(const Size& sz, ::std::ostream* os);
+void PrintTo(const String& str, ::std::ostream* os);
+void PrintTo(const Size& sz, ::std::ostream* os);
} //namespace cv
{
template<typename T>
-struct CV_EXPORTS RectLess_ :
+struct RectLess_ :
public std::binary_function<cv::Rect_<T>, cv::Rect_<T>, bool>
{
bool operator()(const cv::Rect_<T>& r1, const cv::Rect_<T>& r2) const
typedef RectLess_<int> RectLess;
-struct CV_EXPORTS KeypointGreater :
+struct KeypointGreater :
public std::binary_function<cv::KeyPoint, cv::KeyPoint, bool>
{
bool operator()(const cv::KeyPoint& kp1, const cv::KeyPoint& kp2) const
} //namespace comparators
-void CV_EXPORTS sort(std::vector<cv::KeyPoint>& pts, cv::InputOutputArray descriptors);
+void sort(std::vector<cv::KeyPoint>& pts, cv::InputOutputArray descriptors);
} //namespace perf
#endif //OPENCV_TS_PERF_HPP
namespace perf
{
- CV_EXPORTS void printCudaInfo();
+ void printCudaInfo();
}
namespace cvtest
#endif
}
-CV_EXPORTS void addDataSearchPath(const std::string& path)
+void addDataSearchPath(const std::string& path)
{
if (isDirectory(path))
TS::ptr()->data_search_path.push_back(path);
}
-CV_EXPORTS void addDataSearchSubDirectory(const std::string& subdir)
+void addDataSearchSubDirectory(const std::string& subdir)
{
TS::ptr()->data_search_subdir.push_back(subdir);
}
projects / platform / upstream / opencv.git / commitdiff