Merge remote-tracking branch 'master' into stitch-fix
* 'master' of github.com:itseez/opencv: (82 commits)
moved part of video to contrib/{outflow, bgsegm}; moved matlab to contrib
added some basic functionality needed by the new face module (moved from the old "contrib")
moved to the new opencv_contrib/face module
fixed various warnings and obvious errors reported by clang compiler and the coverity tool.
Fixed review comment from Vadim Pisarevsky
modified farneback sample to use T-API
ECC patch by the author (G. Evangelidis); fixed some OCL Farneback optical flow test failures on Mac
small fix for GaussianBlur ocl test
fix binary package build
small fix for ocl_resize
fix IOS framework
fixed test ocl_MatchTemplate for sparse matrix
Fixed typos
fixing error, wrong template method param.
fixing Mac build
some formal changes (generally adding constness)
Fixed choice of kercn and rowsPerWI for non-Intel device.
fixed nDiffs for CalcBackProject
fixed tests for ocl_filter2d, ocl_matchTemplate, ocl_histogram.cpp
Fixed issue: Mat::copyTo(UMat) if device copy is obsolete. Added test.
...
Conflicts:
modules/core/include/opencv2/core/mat.inl.hpp
This commit is contained in:
mshabunin
commit
c54b8f9b00
@ -337,6 +337,9 @@ if(DEFINED CMAKE_DEBUG_POSTFIX)
|
||||
set(OPENCV_DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
|
||||
endif()
|
||||
|
||||
if(INSTALL_CREATE_DISTRIB AND BUILD_SHARED_LIBS AND NOT DEFINED BUILD_opencv_world)
|
||||
set(BUILD_opencv_world ON CACHE INTERNAL "")
|
||||
endif()
|
||||
|
||||
# ----------------------------------------------------------------------------
|
||||
# Path for build/platform -specific headers
|
||||
@ -554,7 +557,6 @@ endif()
|
||||
# ----------------------------------------------------------------------------
|
||||
# Finalization: generate configuration-based files
|
||||
# ----------------------------------------------------------------------------
|
||||
ocv_track_build_dependencies()
|
||||
|
||||
# Generate platform-dependent and configuration-dependent headers
|
||||
include(cmake/OpenCVGenHeaders.cmake)
|
||||
@ -999,18 +1001,34 @@ endif()
|
||||
|
||||
# ========================== python ==========================
|
||||
status("")
|
||||
status(" Python:")
|
||||
status(" Interpreter:" PYTHONINTERP_FOUND THEN "${PYTHON_EXECUTABLE} (ver ${PYTHON_VERSION_STRING})" ELSE NO)
|
||||
if(BUILD_opencv_python)
|
||||
if(PYTHONLIBS_VERSION_STRING)
|
||||
status(" Libraries:" HAVE_opencv_python THEN "${PYTHON_LIBRARIES} (ver ${PYTHONLIBS_VERSION_STRING})" ELSE NO)
|
||||
status(" Python 2:")
|
||||
status(" Interpreter:" PYTHON2INTERP_FOUND THEN "${PYTHON2_EXECUTABLE} (ver ${PYTHON2_VERSION_STRING})" ELSE NO)
|
||||
if(BUILD_opencv_python2)
|
||||
if(PYTHON2LIBS_VERSION_STRING)
|
||||
status(" Libraries:" HAVE_opencv_python2 THEN "${PYTHON2_LIBRARIES} (ver ${PYTHON2LIBS_VERSION_STRING})" ELSE NO)
|
||||
else()
|
||||
status(" Libraries:" HAVE_opencv_python THEN "${PYTHON_LIBRARIES}" ELSE NO)
|
||||
status(" Libraries:" HAVE_opencv_python2 THEN "${PYTHON2_LIBRARIES}" ELSE NO)
|
||||
endif()
|
||||
status(" numpy:" PYTHON_NUMPY_INCLUDE_DIRS THEN "${PYTHON_NUMPY_INCLUDE_DIRS} (ver ${PYTHON_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)")
|
||||
status(" packages path:" PYTHON_EXECUTABLE THEN "${PYTHON_PACKAGES_PATH}" ELSE "-")
|
||||
status(" numpy:" PYTHON2_NUMPY_INCLUDE_DIRS THEN "${PYTHON2_NUMPY_INCLUDE_DIRS} (ver ${PYTHON2_NUMPY_VERSION})" ELSE "NO (Python wrappers can not be generated)")
|
||||
status(" packages path:" PYTHON2_EXECUTABLE THEN "${PYTHON2_PACKAGES_PATH}" ELSE "-")
|
||||
endif()
|
||||
|
||||
status("")
|
||||
status(" Python 3:")
|
||||
status(" Interpreter:" PYTHON3INTERP_FOUND THEN "${PYTHON3_EXECUTABLE} (ver ${PYTHON3_VERSION_STRING})" ELSE NO)
|
||||
if(BUILD_opencv_python3)
|
||||
if(PYTHON3LIBS_VERSION_STRING)
|
||||
status(" Libraries:" HAVE_opencv_python3 THEN "${PYTHON3_LIBRARIES} (ver ${PYTHON3LIBS_VERSION_STRING})" ELSE NO)
|
||||
else()
|
||||
status(" Libraries:" HAVE_opencv_python3 THEN "${PYTHON3_LIBRARIES}" ELSE NO)
|
||||
endif()
|
||||
status(" numpy:" PYTHON3_NUMPY_INCLUDE_DIRS THEN "${PYTHON3_NUMPY_INCLUDE_DIRS} (ver ${PYTHON3_NUMPY_VERSION})" ELSE "NO (Python3 wrappers can not be generated)")
|
||||
status(" packages path:" PYTHON3_EXECUTABLE THEN "${PYTHON3_PACKAGES_PATH}" ELSE "-")
|
||||
endif()
|
||||
|
||||
status("")
|
||||
status(" Python (for build):" PYTHON_DEFAULT_AVAILABLE THEN "${PYTHON_DEFAULT_EXECUTABLE}" ELSE NO)
|
||||
|
||||
# ========================== java ==========================
|
||||
status("")
|
||||
status(" Java:")
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
set(OPENCV_TRAINCASCADE_DEPS opencv_core opencv_ml opencv_imgproc opencv_photo opencv_objdetect opencv_imgcodecs opencv_videoio opencv_highgui opencv_calib3d opencv_video opencv_features2d)
|
||||
set(OPENCV_TRAINCASCADE_DEPS opencv_core opencv_imgproc opencv_objdetect opencv_imgcodecs opencv_highgui opencv_calib3d opencv_features2d)
|
||||
ocv_check_dependencies(${OPENCV_TRAINCASCADE_DEPS})
|
||||
|
||||
if(NOT OCV_DEPENDENCIES_FOUND)
|
||||
@ -6,21 +6,18 @@ if(NOT OCV_DEPENDENCIES_FOUND)
|
||||
endif()
|
||||
|
||||
project(traincascade)
|
||||
|
||||
ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}" "${OpenCV_SOURCE_DIR}/include/opencv")
|
||||
ocv_include_modules(${OPENCV_TRAINCASCADE_DEPS})
|
||||
|
||||
set(traincascade_files traincascade.cpp
|
||||
cascadeclassifier.cpp cascadeclassifier.h
|
||||
boost.cpp boost.h features.cpp traincascade_features.h
|
||||
haarfeatures.cpp haarfeatures.h
|
||||
lbpfeatures.cpp lbpfeatures.h
|
||||
HOGfeatures.cpp HOGfeatures.h
|
||||
imagestorage.cpp imagestorage.h)
|
||||
|
||||
set(the_target opencv_traincascade)
|
||||
add_executable(${the_target} ${traincascade_files})
|
||||
target_link_libraries(${the_target} ${OPENCV_TRAINCASCADE_DEPS})
|
||||
|
||||
ocv_target_include_directories(${the_target} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}" "${OpenCV_SOURCE_DIR}/include/opencv")
|
||||
ocv_target_include_modules(${the_target} ${OPENCV_TRAINCASCADE_DEPS})
|
||||
|
||||
file(GLOB SRCS *.cpp)
|
||||
file(GLOB HDRS *.h*)
|
||||
|
||||
set(traincascade_files ${SRCS} ${HDRS})
|
||||
|
||||
ocv_add_executable(${the_target} ${traincascade_files})
|
||||
ocv_target_link_libraries(${the_target} ${OPENCV_TRAINCASCADE_DEPS})
|
||||
|
||||
set_target_properties(${the_target} PROPERTIES
|
||||
DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
#define _OPENCV_BOOST_H_
|
||||
|
||||
#include "traincascade_features.h"
|
||||
#include "ml.h"
|
||||
#include "old_ml.hpp"
|
||||
|
||||
struct CvCascadeBoostParams : CvBoostParams
|
||||
{
|
||||
|
||||
@ -7,8 +7,6 @@
|
||||
#include "lbpfeatures.h"
|
||||
#include "HOGfeatures.h" //new
|
||||
#include "boost.h"
|
||||
#include "cv.h"
|
||||
#include "cxcore.h"
|
||||
|
||||
#define CC_CASCADE_FILENAME "cascade.xml"
|
||||
#define CC_PARAMS_FILENAME "params.xml"
|
||||
|
||||
2165
apps/traincascade/old_ml.hpp
Normal file
2165
apps/traincascade/old_ml.hpp
Normal file
File diff suppressed because it is too large
Load Diff
2162
apps/traincascade/old_ml_boost.cpp
Normal file
2162
apps/traincascade/old_ml_boost.cpp
Normal file
File diff suppressed because it is too large
Load Diff
792
apps/traincascade/old_ml_data.cpp
Normal file
792
apps/traincascade/old_ml_data.cpp
Normal file
@ -0,0 +1,792 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
//
|
||||
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of Intel Corporation may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "old_ml_precomp.hpp"
|
||||
#include <ctype.h>
|
||||
|
||||
#define MISS_VAL FLT_MAX
|
||||
#define CV_VAR_MISS 0
|
||||
|
||||
CvTrainTestSplit::CvTrainTestSplit()
|
||||
{
|
||||
train_sample_part_mode = CV_COUNT;
|
||||
train_sample_part.count = -1;
|
||||
mix = false;
|
||||
}
|
||||
|
||||
CvTrainTestSplit::CvTrainTestSplit( int _train_sample_count, bool _mix )
|
||||
{
|
||||
train_sample_part_mode = CV_COUNT;
|
||||
train_sample_part.count = _train_sample_count;
|
||||
mix = _mix;
|
||||
}
|
||||
|
||||
CvTrainTestSplit::CvTrainTestSplit( float _train_sample_portion, bool _mix )
|
||||
{
|
||||
train_sample_part_mode = CV_PORTION;
|
||||
train_sample_part.portion = _train_sample_portion;
|
||||
mix = _mix;
|
||||
}
|
||||
|
||||
////////////////
|
||||
|
||||
CvMLData::CvMLData()
|
||||
{
|
||||
values = missing = var_types = var_idx_mask = response_out = var_idx_out = var_types_out = 0;
|
||||
train_sample_idx = test_sample_idx = 0;
|
||||
header_lines_number = 0;
|
||||
sample_idx = 0;
|
||||
response_idx = -1;
|
||||
|
||||
train_sample_count = -1;
|
||||
|
||||
delimiter = ',';
|
||||
miss_ch = '?';
|
||||
//flt_separator = '.';
|
||||
|
||||
rng = &cv::theRNG();
|
||||
}
|
||||
|
||||
CvMLData::~CvMLData()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
void CvMLData::free_train_test_idx()
|
||||
{
|
||||
cvReleaseMat( &train_sample_idx );
|
||||
cvReleaseMat( &test_sample_idx );
|
||||
sample_idx = 0;
|
||||
}
|
||||
|
||||
void CvMLData::clear()
|
||||
{
|
||||
class_map.clear();
|
||||
|
||||
cvReleaseMat( &values );
|
||||
cvReleaseMat( &missing );
|
||||
cvReleaseMat( &var_types );
|
||||
cvReleaseMat( &var_idx_mask );
|
||||
|
||||
cvReleaseMat( &response_out );
|
||||
cvReleaseMat( &var_idx_out );
|
||||
cvReleaseMat( &var_types_out );
|
||||
|
||||
free_train_test_idx();
|
||||
|
||||
total_class_count = 0;
|
||||
|
||||
response_idx = -1;
|
||||
|
||||
train_sample_count = -1;
|
||||
}
|
||||
|
||||
|
||||
void CvMLData::set_header_lines_number( int idx )
|
||||
{
|
||||
header_lines_number = std::max(0, idx);
|
||||
}
|
||||
|
||||
int CvMLData::get_header_lines_number() const
|
||||
{
|
||||
return header_lines_number;
|
||||
}
|
||||
|
||||
static char *fgets_chomp(char *str, int n, FILE *stream)
|
||||
{
|
||||
char *head = fgets(str, n, stream);
|
||||
if( head )
|
||||
{
|
||||
for(char *tail = head + strlen(head) - 1; tail >= head; --tail)
|
||||
{
|
||||
if( *tail != '\r' && *tail != '\n' )
|
||||
break;
|
||||
*tail = '\0';
|
||||
}
|
||||
}
|
||||
return head;
|
||||
}
|
||||
|
||||
|
||||
int CvMLData::read_csv(const char* filename)
|
||||
{
|
||||
const int M = 1000000;
|
||||
const char str_delimiter[3] = { ' ', delimiter, '\0' };
|
||||
FILE* file = 0;
|
||||
CvMemStorage* storage;
|
||||
CvSeq* seq;
|
||||
char *ptr;
|
||||
float* el_ptr;
|
||||
CvSeqReader reader;
|
||||
int cols_count = 0;
|
||||
uchar *var_types_ptr = 0;
|
||||
|
||||
clear();
|
||||
|
||||
file = fopen( filename, "rt" );
|
||||
|
||||
if( !file )
|
||||
return -1;
|
||||
|
||||
std::vector<char> _buf(M);
|
||||
char* buf = &_buf[0];
|
||||
|
||||
// skip header lines
|
||||
for( int i = 0; i < header_lines_number; i++ )
|
||||
{
|
||||
if( fgets( buf, M, file ) == 0 )
|
||||
{
|
||||
fclose(file);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
// read the first data line and determine the number of variables
|
||||
if( !fgets_chomp( buf, M, file ))
|
||||
{
|
||||
fclose(file);
|
||||
return -1;
|
||||
}
|
||||
|
||||
ptr = buf;
|
||||
while( *ptr == ' ' )
|
||||
ptr++;
|
||||
for( ; *ptr != '\0'; )
|
||||
{
|
||||
if(*ptr == delimiter || *ptr == ' ')
|
||||
{
|
||||
cols_count++;
|
||||
ptr++;
|
||||
while( *ptr == ' ' ) ptr++;
|
||||
}
|
||||
else
|
||||
ptr++;
|
||||
}
|
||||
|
||||
cols_count++;
|
||||
|
||||
if ( cols_count == 0)
|
||||
{
|
||||
fclose(file);
|
||||
return -1;
|
||||
}
|
||||
|
||||
// create temporary memory storage to store the whole database
|
||||
el_ptr = new float[cols_count];
|
||||
storage = cvCreateMemStorage();
|
||||
seq = cvCreateSeq( 0, sizeof(*seq), cols_count*sizeof(float), storage );
|
||||
|
||||
var_types = cvCreateMat( 1, cols_count, CV_8U );
|
||||
cvZero( var_types );
|
||||
var_types_ptr = var_types->data.ptr;
|
||||
|
||||
for(;;)
|
||||
{
|
||||
char *token = NULL;
|
||||
int type;
|
||||
token = strtok(buf, str_delimiter);
|
||||
if (!token)
|
||||
break;
|
||||
for (int i = 0; i < cols_count-1; i++)
|
||||
{
|
||||
str_to_flt_elem( token, el_ptr[i], type);
|
||||
var_types_ptr[i] |= type;
|
||||
token = strtok(NULL, str_delimiter);
|
||||
if (!token)
|
||||
{
|
||||
fclose(file);
|
||||
delete [] el_ptr;
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
str_to_flt_elem( token, el_ptr[cols_count-1], type);
|
||||
var_types_ptr[cols_count-1] |= type;
|
||||
cvSeqPush( seq, el_ptr );
|
||||
if( !fgets_chomp( buf, M, file ) )
|
||||
break;
|
||||
}
|
||||
fclose(file);
|
||||
|
||||
values = cvCreateMat( seq->total, cols_count, CV_32FC1 );
|
||||
missing = cvCreateMat( seq->total, cols_count, CV_8U );
|
||||
var_idx_mask = cvCreateMat( 1, values->cols, CV_8UC1 );
|
||||
cvSet( var_idx_mask, cvRealScalar(1) );
|
||||
train_sample_count = seq->total;
|
||||
|
||||
cvStartReadSeq( seq, &reader );
|
||||
for(int i = 0; i < seq->total; i++ )
|
||||
{
|
||||
const float* sdata = (float*)reader.ptr;
|
||||
float* ddata = values->data.fl + cols_count*i;
|
||||
uchar* dm = missing->data.ptr + cols_count*i;
|
||||
|
||||
for( int j = 0; j < cols_count; j++ )
|
||||
{
|
||||
ddata[j] = sdata[j];
|
||||
dm[j] = ( fabs( MISS_VAL - sdata[j] ) <= FLT_EPSILON );
|
||||
}
|
||||
CV_NEXT_SEQ_ELEM( seq->elem_size, reader );
|
||||
}
|
||||
|
||||
if ( cvNorm( missing, 0, CV_L1 ) <= FLT_EPSILON )
|
||||
cvReleaseMat( &missing );
|
||||
|
||||
cvReleaseMemStorage( &storage );
|
||||
delete []el_ptr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
const CvMat* CvMLData::get_values() const
|
||||
{
|
||||
return values;
|
||||
}
|
||||
|
||||
const CvMat* CvMLData::get_missing() const
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::get_missing" );
|
||||
__BEGIN__;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
|
||||
__END__;
|
||||
|
||||
return missing;
|
||||
}
|
||||
|
||||
const std::map<cv::String, int>& CvMLData::get_class_labels_map() const
|
||||
{
|
||||
return class_map;
|
||||
}
|
||||
|
||||
void CvMLData::str_to_flt_elem( const char* token, float& flt_elem, int& type)
|
||||
{
|
||||
|
||||
char* stopstring = NULL;
|
||||
flt_elem = (float)strtod( token, &stopstring );
|
||||
assert( stopstring );
|
||||
type = CV_VAR_ORDERED;
|
||||
if ( *stopstring == miss_ch && strlen(stopstring) == 1 ) // missed value
|
||||
{
|
||||
flt_elem = MISS_VAL;
|
||||
type = CV_VAR_MISS;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( (*stopstring != 0) && (*stopstring != '\n') && (strcmp(stopstring, "\r\n") != 0) ) // class label
|
||||
{
|
||||
int idx = class_map[token];
|
||||
if ( idx == 0)
|
||||
{
|
||||
total_class_count++;
|
||||
idx = total_class_count;
|
||||
class_map[token] = idx;
|
||||
}
|
||||
flt_elem = (float)idx;
|
||||
type = CV_VAR_CATEGORICAL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CvMLData::set_delimiter(char ch)
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::set_delimited" );
|
||||
__BEGIN__;
|
||||
|
||||
if (ch == miss_ch /*|| ch == flt_separator*/)
|
||||
CV_ERROR(CV_StsBadArg, "delimited, miss_character and flt_separator must be different");
|
||||
|
||||
delimiter = ch;
|
||||
|
||||
__END__;
|
||||
}
|
||||
|
||||
char CvMLData::get_delimiter() const
|
||||
{
|
||||
return delimiter;
|
||||
}
|
||||
|
||||
void CvMLData::set_miss_ch(char ch)
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::set_miss_ch" );
|
||||
__BEGIN__;
|
||||
|
||||
if (ch == delimiter/* || ch == flt_separator*/)
|
||||
CV_ERROR(CV_StsBadArg, "delimited, miss_character and flt_separator must be different");
|
||||
|
||||
miss_ch = ch;
|
||||
|
||||
__END__;
|
||||
}
|
||||
|
||||
char CvMLData::get_miss_ch() const
|
||||
{
|
||||
return miss_ch;
|
||||
}
|
||||
|
||||
void CvMLData::set_response_idx( int idx )
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::set_response_idx" );
|
||||
__BEGIN__;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
|
||||
if ( idx >= values->cols)
|
||||
CV_ERROR( CV_StsBadArg, "idx value is not correct" );
|
||||
|
||||
if ( response_idx >= 0 )
|
||||
chahge_var_idx( response_idx, true );
|
||||
if ( idx >= 0 )
|
||||
chahge_var_idx( idx, false );
|
||||
response_idx = idx;
|
||||
|
||||
__END__;
|
||||
}
|
||||
|
||||
int CvMLData::get_response_idx() const
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::get_response_idx" );
|
||||
__BEGIN__;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
__END__;
|
||||
return response_idx;
|
||||
}
|
||||
|
||||
void CvMLData::change_var_type( int var_idx, int type )
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::change_var_type" );
|
||||
__BEGIN__;
|
||||
|
||||
int var_count = 0;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
|
||||
var_count = values->cols;
|
||||
|
||||
if ( var_idx < 0 || var_idx >= var_count)
|
||||
CV_ERROR( CV_StsBadArg, "var_idx is not correct" );
|
||||
|
||||
if ( type != CV_VAR_ORDERED && type != CV_VAR_CATEGORICAL)
|
||||
CV_ERROR( CV_StsBadArg, "type is not correct" );
|
||||
|
||||
assert( var_types );
|
||||
if ( var_types->data.ptr[var_idx] == CV_VAR_CATEGORICAL && type == CV_VAR_ORDERED)
|
||||
CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
|
||||
var_types->data.ptr[var_idx] = (uchar)type;
|
||||
|
||||
__END__;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void CvMLData::set_var_types( const char* str )
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::set_var_types" );
|
||||
__BEGIN__;
|
||||
|
||||
const char* ord = 0, *cat = 0;
|
||||
int var_count = 0, set_var_type_count = 0;
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
|
||||
var_count = values->cols;
|
||||
|
||||
assert( var_types );
|
||||
|
||||
ord = strstr( str, "ord" );
|
||||
cat = strstr( str, "cat" );
|
||||
if ( !ord && !cat )
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
|
||||
if ( !ord && strlen(cat) == 3 ) // str == "cat"
|
||||
{
|
||||
cvSet( var_types, cvScalarAll(CV_VAR_CATEGORICAL) );
|
||||
return;
|
||||
}
|
||||
|
||||
if ( !cat && strlen(ord) == 3 ) // str == "ord"
|
||||
{
|
||||
cvSet( var_types, cvScalarAll(CV_VAR_ORDERED) );
|
||||
return;
|
||||
}
|
||||
|
||||
if ( ord ) // parse ord str
|
||||
{
|
||||
char* stopstring = NULL;
|
||||
if ( ord[3] != '[')
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
|
||||
ord += 4; // pass "ord["
|
||||
do
|
||||
{
|
||||
int b1 = (int)strtod( ord, &stopstring );
|
||||
if ( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
ord = stopstring + 1;
|
||||
if ( (stopstring[0] == ',') || (stopstring[0] == ']'))
|
||||
{
|
||||
if ( var_types->data.ptr[b1] == CV_VAR_CATEGORICAL)
|
||||
CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
|
||||
var_types->data.ptr[b1] = CV_VAR_ORDERED;
|
||||
set_var_type_count++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( stopstring[0] == '-')
|
||||
{
|
||||
int b2 = (int)strtod( ord, &stopstring);
|
||||
if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
ord = stopstring + 1;
|
||||
for (int i = b1; i <= b2; i++)
|
||||
{
|
||||
if ( var_types->data.ptr[i] == CV_VAR_CATEGORICAL)
|
||||
CV_ERROR( CV_StsBadArg, "it`s impossible to assign CV_VAR_ORDERED type to categorical variable" );
|
||||
var_types->data.ptr[i] = CV_VAR_ORDERED;
|
||||
}
|
||||
set_var_type_count += b2 - b1 + 1;
|
||||
}
|
||||
else
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
|
||||
}
|
||||
}
|
||||
while (*stopstring != ']');
|
||||
|
||||
if ( stopstring[1] != '\0' && stopstring[1] != ',')
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
}
|
||||
|
||||
if ( cat ) // parse cat str
|
||||
{
|
||||
char* stopstring = NULL;
|
||||
if ( cat[3] != '[')
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
|
||||
cat += 4; // pass "cat["
|
||||
do
|
||||
{
|
||||
int b1 = (int)strtod( cat, &stopstring );
|
||||
if ( *stopstring == 0 || (*stopstring != ',' && *stopstring != ']' && *stopstring != '-') )
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
cat = stopstring + 1;
|
||||
if ( (stopstring[0] == ',') || (stopstring[0] == ']'))
|
||||
{
|
||||
var_types->data.ptr[b1] = CV_VAR_CATEGORICAL;
|
||||
set_var_type_count++;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( stopstring[0] == '-')
|
||||
{
|
||||
int b2 = (int)strtod( cat, &stopstring);
|
||||
if ( (*stopstring == 0) || (*stopstring != ',' && *stopstring != ']') )
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
cat = stopstring + 1;
|
||||
for (int i = b1; i <= b2; i++)
|
||||
var_types->data.ptr[i] = CV_VAR_CATEGORICAL;
|
||||
set_var_type_count += b2 - b1 + 1;
|
||||
}
|
||||
else
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
|
||||
}
|
||||
}
|
||||
while (*stopstring != ']');
|
||||
|
||||
if ( stopstring[1] != '\0' && stopstring[1] != ',')
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
}
|
||||
|
||||
if (set_var_type_count != var_count)
|
||||
CV_ERROR( CV_StsBadArg, "types string is not correct" );
|
||||
|
||||
__END__;
|
||||
}
|
||||
|
||||
const CvMat* CvMLData::get_var_types()
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::get_var_types" );
|
||||
__BEGIN__;
|
||||
|
||||
uchar *var_types_out_ptr = 0;
|
||||
int avcount, vt_size;
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
|
||||
assert( var_idx_mask );
|
||||
|
||||
avcount = cvFloor( cvNorm( var_idx_mask, 0, CV_L1 ) );
|
||||
vt_size = avcount + (response_idx >= 0);
|
||||
|
||||
if ( avcount == values->cols || (avcount == values->cols-1 && response_idx == values->cols-1) )
|
||||
return var_types;
|
||||
|
||||
if ( !var_types_out || ( var_types_out && var_types_out->cols != vt_size ) )
|
||||
{
|
||||
cvReleaseMat( &var_types_out );
|
||||
var_types_out = cvCreateMat( 1, vt_size, CV_8UC1 );
|
||||
}
|
||||
|
||||
var_types_out_ptr = var_types_out->data.ptr;
|
||||
for( int i = 0; i < var_types->cols; i++)
|
||||
{
|
||||
if (i == response_idx || !var_idx_mask->data.ptr[i]) continue;
|
||||
*var_types_out_ptr = var_types->data.ptr[i];
|
||||
var_types_out_ptr++;
|
||||
}
|
||||
if ( response_idx >= 0 )
|
||||
*var_types_out_ptr = var_types->data.ptr[response_idx];
|
||||
|
||||
__END__;
|
||||
|
||||
return var_types_out;
|
||||
}
|
||||
|
||||
int CvMLData::get_var_type( int var_idx ) const
|
||||
{
|
||||
return var_types->data.ptr[var_idx];
|
||||
}
|
||||
|
||||
const CvMat* CvMLData::get_responses()
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::get_responses_ptr" );
|
||||
__BEGIN__;
|
||||
|
||||
int var_count = 0;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
var_count = values->cols;
|
||||
|
||||
if ( response_idx < 0 || response_idx >= var_count )
|
||||
return 0;
|
||||
if ( !response_out )
|
||||
response_out = cvCreateMatHeader( values->rows, 1, CV_32FC1 );
|
||||
else
|
||||
cvInitMatHeader( response_out, values->rows, 1, CV_32FC1);
|
||||
cvGetCol( values, response_out, response_idx );
|
||||
|
||||
__END__;
|
||||
|
||||
return response_out;
|
||||
}
|
||||
|
||||
void CvMLData::set_train_test_split( const CvTrainTestSplit * spl)
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::set_division" );
|
||||
__BEGIN__;
|
||||
|
||||
int sample_count = 0;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
|
||||
sample_count = values->rows;
|
||||
|
||||
float train_sample_portion;
|
||||
|
||||
if (spl->train_sample_part_mode == CV_COUNT)
|
||||
{
|
||||
train_sample_count = spl->train_sample_part.count;
|
||||
if (train_sample_count > sample_count)
|
||||
CV_ERROR( CV_StsBadArg, "train samples count is not correct" );
|
||||
train_sample_count = train_sample_count<=0 ? sample_count : train_sample_count;
|
||||
}
|
||||
else // dtype.train_sample_part_mode == CV_PORTION
|
||||
{
|
||||
train_sample_portion = spl->train_sample_part.portion;
|
||||
if ( train_sample_portion > 1)
|
||||
CV_ERROR( CV_StsBadArg, "train samples count is not correct" );
|
||||
train_sample_portion = train_sample_portion <= FLT_EPSILON ||
|
||||
1 - train_sample_portion <= FLT_EPSILON ? 1 : train_sample_portion;
|
||||
train_sample_count = std::max(1, cvFloor( train_sample_portion * sample_count ));
|
||||
}
|
||||
|
||||
if ( train_sample_count == sample_count )
|
||||
{
|
||||
free_train_test_idx();
|
||||
return;
|
||||
}
|
||||
|
||||
if ( train_sample_idx && train_sample_idx->cols != train_sample_count )
|
||||
free_train_test_idx();
|
||||
|
||||
if ( !sample_idx)
|
||||
{
|
||||
int test_sample_count = sample_count- train_sample_count;
|
||||
sample_idx = (int*)cvAlloc( sample_count * sizeof(sample_idx[0]) );
|
||||
for (int i = 0; i < sample_count; i++ )
|
||||
sample_idx[i] = i;
|
||||
train_sample_idx = cvCreateMatHeader( 1, train_sample_count, CV_32SC1 );
|
||||
*train_sample_idx = cvMat( 1, train_sample_count, CV_32SC1, &sample_idx[0] );
|
||||
|
||||
CV_Assert(test_sample_count > 0);
|
||||
test_sample_idx = cvCreateMatHeader( 1, test_sample_count, CV_32SC1 );
|
||||
*test_sample_idx = cvMat( 1, test_sample_count, CV_32SC1, &sample_idx[train_sample_count] );
|
||||
}
|
||||
|
||||
mix = spl->mix;
|
||||
if ( mix )
|
||||
mix_train_and_test_idx();
|
||||
|
||||
__END__;
|
||||
}
|
||||
|
||||
const CvMat* CvMLData::get_train_sample_idx() const
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::get_train_sample_idx" );
|
||||
__BEGIN__;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
__END__;
|
||||
|
||||
return train_sample_idx;
|
||||
}
|
||||
|
||||
const CvMat* CvMLData::get_test_sample_idx() const
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::get_test_sample_idx" );
|
||||
__BEGIN__;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
__END__;
|
||||
|
||||
return test_sample_idx;
|
||||
}
|
||||
|
||||
void CvMLData::mix_train_and_test_idx()
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::mix_train_and_test_idx" );
|
||||
__BEGIN__;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
__END__;
|
||||
|
||||
if ( !sample_idx)
|
||||
return;
|
||||
|
||||
if ( train_sample_count > 0 && train_sample_count < values->rows )
|
||||
{
|
||||
int n = values->rows;
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
int a = (*rng)(n);
|
||||
int b = (*rng)(n);
|
||||
int t;
|
||||
CV_SWAP( sample_idx[a], sample_idx[b], t );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const CvMat* CvMLData::get_var_idx()
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::get_var_idx" );
|
||||
__BEGIN__;
|
||||
|
||||
int avcount = 0;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
|
||||
assert( var_idx_mask );
|
||||
|
||||
avcount = cvFloor( cvNorm( var_idx_mask, 0, CV_L1 ) );
|
||||
int* vidx;
|
||||
|
||||
if ( avcount == values->cols )
|
||||
return 0;
|
||||
|
||||
if ( !var_idx_out || ( var_idx_out && var_idx_out->cols != avcount ) )
|
||||
{
|
||||
cvReleaseMat( &var_idx_out );
|
||||
var_idx_out = cvCreateMat( 1, avcount, CV_32SC1);
|
||||
if ( response_idx >=0 )
|
||||
var_idx_mask->data.ptr[response_idx] = 0;
|
||||
}
|
||||
|
||||
vidx = var_idx_out->data.i;
|
||||
|
||||
for(int i = 0; i < var_idx_mask->cols; i++)
|
||||
if ( var_idx_mask->data.ptr[i] )
|
||||
{
|
||||
*vidx = i;
|
||||
vidx++;
|
||||
}
|
||||
|
||||
__END__;
|
||||
|
||||
return var_idx_out;
|
||||
}
|
||||
|
||||
void CvMLData::chahge_var_idx( int vi, bool state )
|
||||
{
|
||||
change_var_idx( vi, state );
|
||||
}
|
||||
|
||||
void CvMLData::change_var_idx( int vi, bool state )
|
||||
{
|
||||
CV_FUNCNAME( "CvMLData::change_var_idx" );
|
||||
__BEGIN__;
|
||||
|
||||
int var_count = 0;
|
||||
|
||||
if ( !values )
|
||||
CV_ERROR( CV_StsInternal, "data is empty" );
|
||||
|
||||
var_count = values->cols;
|
||||
|
||||
if ( vi < 0 || vi >= var_count)
|
||||
CV_ERROR( CV_StsBadArg, "variable index is not correct" );
|
||||
|
||||
assert( var_idx_mask );
|
||||
var_idx_mask->data.ptr[vi] = state;
|
||||
|
||||
__END__;
|
||||
}
|
||||
|
||||
/* End of file. */
|
||||
1879
apps/traincascade/old_ml_inner_functions.cpp
Normal file
1879
apps/traincascade/old_ml_inner_functions.cpp
Normal file
File diff suppressed because it is too large
Load Diff
376
apps/traincascade/old_ml_precomp.hpp
Normal file
376
apps/traincascade/old_ml_precomp.hpp
Normal file
@ -0,0 +1,376 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
//
|
||||
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of Intel Corporation may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#ifndef __OPENCV_PRECOMP_H__
|
||||
#define __OPENCV_PRECOMP_H__
|
||||
|
||||
#include "opencv2/core.hpp"
|
||||
#include "old_ml.hpp"
|
||||
#include "opencv2/core/core_c.h"
|
||||
#include "opencv2/core/utility.hpp"
|
||||
|
||||
#include "opencv2/core/private.hpp"
|
||||
|
||||
#include <assert.h>
|
||||
#include <float.h>
|
||||
#include <limits.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
#define ML_IMPL CV_IMPL
|
||||
#define __BEGIN__ __CV_BEGIN__
|
||||
#define __END__ __CV_END__
|
||||
#define EXIT __CV_EXIT__
|
||||
|
||||
#define CV_MAT_ELEM_FLAG( mat, type, comp, vect, tflag ) \
|
||||
(( tflag == CV_ROW_SAMPLE ) \
|
||||
? (CV_MAT_ELEM( mat, type, comp, vect )) \
|
||||
: (CV_MAT_ELEM( mat, type, vect, comp )))
|
||||
|
||||
/* Convert matrix to vector */
|
||||
#define ICV_MAT2VEC( mat, vdata, vstep, num ) \
|
||||
if( MIN( (mat).rows, (mat).cols ) != 1 ) \
|
||||
CV_ERROR( CV_StsBadArg, "" ); \
|
||||
(vdata) = ((mat).data.ptr); \
|
||||
if( (mat).rows == 1 ) \
|
||||
{ \
|
||||
(vstep) = CV_ELEM_SIZE( (mat).type ); \
|
||||
(num) = (mat).cols; \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
(vstep) = (mat).step; \
|
||||
(num) = (mat).rows; \
|
||||
}
|
||||
|
||||
/* get raw data */
|
||||
#define ICV_RAWDATA( mat, flags, rdata, sstep, cstep, m, n ) \
|
||||
(rdata) = (mat).data.ptr; \
|
||||
if( CV_IS_ROW_SAMPLE( flags ) ) \
|
||||
{ \
|
||||
(sstep) = (mat).step; \
|
||||
(cstep) = CV_ELEM_SIZE( (mat).type ); \
|
||||
(m) = (mat).rows; \
|
||||
(n) = (mat).cols; \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
(cstep) = (mat).step; \
|
||||
(sstep) = CV_ELEM_SIZE( (mat).type ); \
|
||||
(n) = (mat).rows; \
|
||||
(m) = (mat).cols; \
|
||||
}
|
||||
|
||||
#define ICV_IS_MAT_OF_TYPE( mat, mat_type) \
|
||||
(CV_IS_MAT( mat ) && CV_MAT_TYPE( mat->type ) == (mat_type) && \
|
||||
(mat)->cols > 0 && (mat)->rows > 0)
|
||||
|
||||
/*
|
||||
uchar* data; int sstep, cstep; - trainData->data
|
||||
uchar* classes; int clstep; int ncl;- trainClasses
|
||||
uchar* tmask; int tmstep; int ntm; - typeMask
|
||||
uchar* missed;int msstep, mcstep; -missedMeasurements...
|
||||
int mm, mn; == m,n == size,dim
|
||||
uchar* sidx;int sistep; - sampleIdx
|
||||
uchar* cidx;int cistep; - compIdx
|
||||
int k, l; == n,m == dim,size (length of cidx, sidx)
|
||||
int m, n; == size,dim
|
||||
*/
|
||||
#define ICV_DECLARE_TRAIN_ARGS() \
|
||||
uchar* data; \
|
||||
int sstep, cstep; \
|
||||
uchar* classes; \
|
||||
int clstep; \
|
||||
int ncl; \
|
||||
uchar* tmask; \
|
||||
int tmstep; \
|
||||
int ntm; \
|
||||
uchar* missed; \
|
||||
int msstep, mcstep; \
|
||||
int mm, mn; \
|
||||
uchar* sidx; \
|
||||
int sistep; \
|
||||
uchar* cidx; \
|
||||
int cistep; \
|
||||
int k, l; \
|
||||
int m, n; \
|
||||
\
|
||||
data = classes = tmask = missed = sidx = cidx = NULL; \
|
||||
sstep = cstep = clstep = ncl = tmstep = ntm = msstep = mcstep = mm = mn = 0; \
|
||||
sistep = cistep = k = l = m = n = 0;
|
||||
|
||||
#define ICV_TRAIN_DATA_REQUIRED( param, flags ) \
|
||||
if( !ICV_IS_MAT_OF_TYPE( (param), CV_32FC1 ) ) \
|
||||
{ \
|
||||
CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
ICV_RAWDATA( *(param), (flags), data, sstep, cstep, m, n ); \
|
||||
k = n; \
|
||||
l = m; \
|
||||
}
|
||||
|
||||
#define ICV_TRAIN_CLASSES_REQUIRED( param ) \
|
||||
if( !ICV_IS_MAT_OF_TYPE( (param), CV_32FC1 ) ) \
|
||||
{ \
|
||||
CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
ICV_MAT2VEC( *(param), classes, clstep, ncl ); \
|
||||
if( m != ncl ) \
|
||||
{ \
|
||||
CV_ERROR( CV_StsBadArg, "Unmatched sizes" ); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define ICV_ARG_NULL( param ) \
|
||||
if( (param) != NULL ) \
|
||||
{ \
|
||||
CV_ERROR( CV_StsBadArg, #param " parameter must be NULL" ); \
|
||||
}
|
||||
|
||||
#define ICV_MISSED_MEASUREMENTS_OPTIONAL( param, flags ) \
|
||||
if( param ) \
|
||||
{ \
|
||||
if( !ICV_IS_MAT_OF_TYPE( param, CV_8UC1 ) ) \
|
||||
{ \
|
||||
CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
ICV_RAWDATA( *(param), (flags), missed, msstep, mcstep, mm, mn ); \
|
||||
if( mm != m || mn != n ) \
|
||||
{ \
|
||||
CV_ERROR( CV_StsBadArg, "Unmatched sizes" ); \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
#define ICV_COMP_IDX_OPTIONAL( param ) \
|
||||
if( param ) \
|
||||
{ \
|
||||
if( !ICV_IS_MAT_OF_TYPE( param, CV_32SC1 ) ) \
|
||||
{ \
|
||||
CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
ICV_MAT2VEC( *(param), cidx, cistep, k ); \
|
||||
if( k > n ) \
|
||||
CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define ICV_SAMPLE_IDX_OPTIONAL( param ) \
|
||||
if( param ) \
|
||||
{ \
|
||||
if( !ICV_IS_MAT_OF_TYPE( param, CV_32SC1 ) ) \
|
||||
{ \
|
||||
CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
ICV_MAT2VEC( *sampleIdx, sidx, sistep, l ); \
|
||||
if( l > m ) \
|
||||
CV_ERROR( CV_StsBadArg, "Invalid " #param " parameter" ); \
|
||||
} \
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
#define ICV_CONVERT_FLOAT_ARRAY_TO_MATRICE( array, matrice ) \
|
||||
{ \
|
||||
CvMat a, b; \
|
||||
int dims = (matrice)->cols; \
|
||||
int nsamples = (matrice)->rows; \
|
||||
int type = CV_MAT_TYPE((matrice)->type); \
|
||||
int i, offset = dims; \
|
||||
\
|
||||
CV_ASSERT( type == CV_32FC1 || type == CV_64FC1 ); \
|
||||
offset *= ((type == CV_32FC1) ? sizeof(float) : sizeof(double));\
|
||||
\
|
||||
b = cvMat( 1, dims, CV_32FC1 ); \
|
||||
cvGetRow( matrice, &a, 0 ); \
|
||||
for( i = 0; i < nsamples; i++, a.data.ptr += offset ) \
|
||||
{ \
|
||||
b.data.fl = (float*)array[i]; \
|
||||
CV_CALL( cvConvert( &b, &a ) ); \
|
||||
} \
|
||||
}
|
||||
|
||||
/****************************************************************************************\
|
||||
* Auxiliary functions declarations *
|
||||
\****************************************************************************************/
|
||||
|
||||
/* Generates a set of classes centers in quantity <num_of_clusters> that are generated as
|
||||
uniform random vectors in parallelepiped, where <data> is concentrated. Vectors in
|
||||
<data> should have horizontal orientation. If <centers> != NULL, the function doesn't
|
||||
allocate any memory and stores generated centers in <centers>, returns <centers>.
|
||||
If <centers> == NULL, the function allocates memory and creates the matrice. Centers
|
||||
are supposed to be oriented horizontally. */
|
||||
CvMat* icvGenerateRandomClusterCenters( int seed,
|
||||
const CvMat* data,
|
||||
int num_of_clusters,
|
||||
CvMat* centers CV_DEFAULT(0));
|
||||
|
||||
/* Fills the <labels> using <probs> by choosing the maximal probability. Outliers are
|
||||
fixed by <oulier_tresh> and have cluster label (-1). Function also controls that there
|
||||
weren't "empty" clusters by filling empty clusters with the maximal probability vector.
|
||||
If probs_sums != NULL, filles it with the sums of probabilities for each sample (it is
|
||||
useful for normalizing probabilities' matrice of FCM) */
|
||||
void icvFindClusterLabels( const CvMat* probs, float outlier_thresh, float r,
|
||||
const CvMat* labels );
|
||||
|
||||
typedef struct CvSparseVecElem32f
|
||||
{
|
||||
int idx;
|
||||
float val;
|
||||
}
|
||||
CvSparseVecElem32f;
|
||||
|
||||
/* Prepare training data and related parameters */
|
||||
#define CV_TRAIN_STATMODEL_DEFRAGMENT_TRAIN_DATA 1
|
||||
#define CV_TRAIN_STATMODEL_SAMPLES_AS_ROWS 2
|
||||
#define CV_TRAIN_STATMODEL_SAMPLES_AS_COLUMNS 4
|
||||
#define CV_TRAIN_STATMODEL_CATEGORICAL_RESPONSE 8
|
||||
#define CV_TRAIN_STATMODEL_ORDERED_RESPONSE 16
|
||||
#define CV_TRAIN_STATMODEL_RESPONSES_ON_OUTPUT 32
|
||||
#define CV_TRAIN_STATMODEL_ALWAYS_COPY_TRAIN_DATA 64
|
||||
#define CV_TRAIN_STATMODEL_SPARSE_AS_SPARSE 128
|
||||
|
||||
int
|
||||
cvPrepareTrainData( const char* /*funcname*/,
|
||||
const CvMat* train_data, int tflag,
|
||||
const CvMat* responses, int response_type,
|
||||
const CvMat* var_idx,
|
||||
const CvMat* sample_idx,
|
||||
bool always_copy_data,
|
||||
const float*** out_train_samples,
|
||||
int* _sample_count,
|
||||
int* _var_count,
|
||||
int* _var_all,
|
||||
CvMat** out_responses,
|
||||
CvMat** out_response_map,
|
||||
CvMat** out_var_idx,
|
||||
CvMat** out_sample_idx=0 );
|
||||
|
||||
void
|
||||
cvSortSamplesByClasses( const float** samples, const CvMat* classes,
|
||||
int* class_ranges, const uchar** mask CV_DEFAULT(0) );
|
||||
|
||||
void
|
||||
cvCombineResponseMaps (CvMat* _responses,
|
||||
const CvMat* old_response_map,
|
||||
CvMat* new_response_map,
|
||||
CvMat** out_response_map);
|
||||
|
||||
void
|
||||
cvPreparePredictData( const CvArr* sample, int dims_all, const CvMat* comp_idx,
|
||||
int class_count, const CvMat* prob, float** row_sample,
|
||||
int as_sparse CV_DEFAULT(0) );
|
||||
|
||||
/* copies clustering [or batch "predict"] results
|
||||
(labels and/or centers and/or probs) back to the output arrays */
|
||||
void
|
||||
cvWritebackLabels( const CvMat* labels, CvMat* dst_labels,
|
||||
const CvMat* centers, CvMat* dst_centers,
|
||||
const CvMat* probs, CvMat* dst_probs,
|
||||
const CvMat* sample_idx, int samples_all,
|
||||
const CvMat* comp_idx, int dims_all );
|
||||
#define cvWritebackResponses cvWritebackLabels
|
||||
|
||||
#define XML_FIELD_NAME "_name"
|
||||
CvFileNode* icvFileNodeGetChild(CvFileNode* father, const char* name);
|
||||
CvFileNode* icvFileNodeGetChildArrayElem(CvFileNode* father, const char* name,int index);
|
||||
CvFileNode* icvFileNodeGetNext(CvFileNode* n, const char* name);
|
||||
|
||||
|
||||
void cvCheckTrainData( const CvMat* train_data, int tflag,
|
||||
const CvMat* missing_mask,
|
||||
int* var_all, int* sample_all );
|
||||
|
||||
CvMat* cvPreprocessIndexArray( const CvMat* idx_arr, int data_arr_size, bool check_for_duplicates=false );
|
||||
|
||||
CvMat* cvPreprocessVarType( const CvMat* type_mask, const CvMat* var_idx,
|
||||
int var_all, int* response_type );
|
||||
|
||||
CvMat* cvPreprocessOrderedResponses( const CvMat* responses,
|
||||
const CvMat* sample_idx, int sample_all );
|
||||
|
||||
CvMat* cvPreprocessCategoricalResponses( const CvMat* responses,
|
||||
const CvMat* sample_idx, int sample_all,
|
||||
CvMat** out_response_map, CvMat** class_counts=0 );
|
||||
|
||||
const float** cvGetTrainSamples( const CvMat* train_data, int tflag,
|
||||
const CvMat* var_idx, const CvMat* sample_idx,
|
||||
int* _var_count, int* _sample_count,
|
||||
bool always_copy_data=false );
|
||||
|
||||
namespace cv
|
||||
{
|
||||
struct DTreeBestSplitFinder
|
||||
{
|
||||
DTreeBestSplitFinder(){ splitSize = 0, tree = 0; node = 0; }
|
||||
DTreeBestSplitFinder( CvDTree* _tree, CvDTreeNode* _node);
|
||||
DTreeBestSplitFinder( const DTreeBestSplitFinder& finder, Split );
|
||||
virtual ~DTreeBestSplitFinder() {}
|
||||
virtual void operator()(const BlockedRange& range);
|
||||
void join( DTreeBestSplitFinder& rhs );
|
||||
Ptr<CvDTreeSplit> bestSplit;
|
||||
Ptr<CvDTreeSplit> split;
|
||||
int splitSize;
|
||||
CvDTree* tree;
|
||||
CvDTreeNode* node;
|
||||
};
|
||||
|
||||
struct ForestTreeBestSplitFinder : DTreeBestSplitFinder
|
||||
{
|
||||
ForestTreeBestSplitFinder() : DTreeBestSplitFinder() {}
|
||||
ForestTreeBestSplitFinder( CvForestTree* _tree, CvDTreeNode* _node );
|
||||
ForestTreeBestSplitFinder( const ForestTreeBestSplitFinder& finder, Split );
|
||||
virtual void operator()(const BlockedRange& range);
|
||||
};
|
||||
}
|
||||
|
||||
#endif /* __ML_H__ */
|
||||
4151
apps/traincascade/old_ml_tree.cpp
Normal file
4151
apps/traincascade/old_ml_tree.cpp
Normal file
File diff suppressed because it is too large
Load Diff
@ -1,6 +1,4 @@
|
||||
#include "opencv2/core.hpp"
|
||||
|
||||
#include "cv.h"
|
||||
#include "cascadeclassifier.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
@ -2,9 +2,6 @@
|
||||
#define _OPENCV_FEATURES_H_
|
||||
|
||||
#include "imagestorage.h"
|
||||
#include "cxcore.h"
|
||||
#include "cv.h"
|
||||
#include "ml.h"
|
||||
#include <stdio.h>
|
||||
|
||||
#define FEATURES "features"
|
||||
|
||||
@ -280,9 +280,6 @@ macro(add_android_project target path)
|
||||
string(REGEX REPLACE "LOCAL_MODULE[ ]*:=[ ]*([a-zA-Z_][a-zA-Z_0-9]*)[ ]*" "\\1" JNI_LIB_NAME "${JNI_LIB_NAME}")
|
||||
|
||||
if(JNI_LIB_NAME)
|
||||
ocv_include_modules_recurse(${android_proj_NATIVE_DEPS})
|
||||
ocv_include_directories("${path}/jni")
|
||||
|
||||
if(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)
|
||||
@ -291,7 +288,9 @@ macro(add_android_project target path)
|
||||
endif()
|
||||
|
||||
add_library(${JNI_LIB_NAME} MODULE ${android_proj_jni_files})
|
||||
target_link_libraries(${JNI_LIB_NAME} ${OPENCV_LINKER_LIBS} ${android_proj_NATIVE_DEPS})
|
||||
ocv_target_include_modules_recurse(${JNI_LIB_NAME} ${android_proj_NATIVE_DEPS})
|
||||
ocv_target_include_directories(${JNI_LIB_NAME} "${path}/jni")
|
||||
ocv_target_link_libraries(${JNI_LIB_NAME} ${OPENCV_LINKER_LIBS} ${android_proj_NATIVE_DEPS})
|
||||
|
||||
set_target_properties(${JNI_LIB_NAME} PROPERTIES
|
||||
OUTPUT_NAME "${JNI_LIB_NAME}"
|
||||
|
||||
@ -1,101 +1,240 @@
|
||||
if(WIN32 AND NOT PYTHON_EXECUTABLE)
|
||||
# search for executable with the same bitness as resulting binaries
|
||||
# standard FindPythonInterp always prefers executable from system path
|
||||
# this is really important because we are using the interpreter for numpy search and for choosing the install location
|
||||
foreach(_CURRENT_VERSION ${Python_ADDITIONAL_VERSIONS} 2.7 "${MIN_VER_PYTHON}")
|
||||
find_host_program(PYTHON_EXECUTABLE
|
||||
NAMES python${_CURRENT_VERSION} python
|
||||
PATHS
|
||||
[HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Python\\\\PythonCore\\\\${_CURRENT_VERSION}\\\\InstallPath]
|
||||
[HKEY_CURRENT_USER\\\\SOFTWARE\\\\Python\\\\PythonCore\\\\${_CURRENT_VERSION}\\\\InstallPath]
|
||||
NO_SYSTEM_ENVIRONMENT_PATH
|
||||
)
|
||||
endforeach()
|
||||
endif()
|
||||
find_host_package(PythonInterp 2.7)
|
||||
if(NOT PYTHONINTERP_FOUND)
|
||||
find_host_package(PythonInterp "${MIN_VER_PYTHON}")
|
||||
# Find specified Python version
|
||||
# Arguments:
|
||||
# preferred_version (value): Version to check for first
|
||||
# min_version (value): Minimum supported version
|
||||
# library_env (value): Name of Python library ENV variable to check
|
||||
# include_dir_env (value): Name of Python include directory ENV variable to check
|
||||
# found (variable): Set if interpreter found
|
||||
# executable (variable): Output of executable found
|
||||
# version_string (variable): Output of found version
|
||||
# version_major (variable): Output of found major version
|
||||
# version_minor (variable): Output of found minor version
|
||||
# libs_found (variable): Set if libs found
|
||||
# libs_version_string (variable): Output of found libs version
|
||||
# libraries (variable): Output of found Python libraries
|
||||
# library (variable): Output of found Python library
|
||||
# debug_libraries (variable): Output of found Python debug libraries
|
||||
# debug_library (variable): Output of found Python debug library
|
||||
# include_path (variable): Output of found Python include path
|
||||
# include_dir (variable): Output of found Python include dir
|
||||
# include_dir2 (variable): Output of found Python include dir2
|
||||
# packages_path (variable): Output of found Python packages path
|
||||
# numpy_include_dirs (variable): Output of found Python Numpy include dirs
|
||||
# numpy_version (variable): Output of found Python Numpy version
|
||||
function(find_python preferred_version min_version library_env include_dir_env
|
||||
found executable version_string version_major version_minor
|
||||
libs_found libs_version_string libraries library debug_libraries
|
||||
debug_library include_path include_dir include_dir2 packages_path
|
||||
numpy_include_dirs numpy_version)
|
||||
|
||||
ocv_check_environment_variables(${executable})
|
||||
if(${executable})
|
||||
set(PYTHON_EXECUTABLE "${${executable}}")
|
||||
endif()
|
||||
|
||||
if(WIN32 AND NOT ${executable})
|
||||
# search for executable with the same bitness as resulting binaries
|
||||
# standard FindPythonInterp always prefers executable from system path
|
||||
# this is really important because we are using the interpreter for numpy search and for choosing the install location
|
||||
foreach(_CURRENT_VERSION ${Python_ADDITIONAL_VERSIONS} "${preferred_version}" "${min_version}")
|
||||
find_host_program(executable
|
||||
NAMES python${_CURRENT_VERSION} python
|
||||
PATHS
|
||||
[HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Python\\\\PythonCore\\\\${_CURRENT_VERSION}\\\\InstallPath]
|
||||
[HKEY_CURRENT_USER\\\\SOFTWARE\\\\Python\\\\PythonCore\\\\${_CURRENT_VERSION}\\\\InstallPath]
|
||||
NO_SYSTEM_ENVIRONMENT_PATH
|
||||
)
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
find_host_package(PythonInterp "${preferred_version}")
|
||||
if(NOT PYTHONINTERP_FOUND)
|
||||
find_host_package(PythonInterp "${min_version}")
|
||||
endif()
|
||||
|
||||
if(PYTHONINTERP_FOUND)
|
||||
# Copy outputs
|
||||
set(_found ${PYTHONINTERP_FOUND})
|
||||
set(_executable ${PYTHON_EXECUTABLE})
|
||||
set(_version_string ${PYTHON_VERSION_STRING})
|
||||
set(_version_major ${PYTHON_VERSION_MAJOR})
|
||||
set(_version_minor ${PYTHON_VERSION_MINOR})
|
||||
set(_version_patch ${PYTHON_VERSION_PATCH})
|
||||
|
||||
# Clear find_host_package side effects
|
||||
unset(PYTHONINTERP_FOUND)
|
||||
unset(PYTHON_EXECUTABLE CACHE)
|
||||
unset(PYTHON_VERSION_STRING)
|
||||
unset(PYTHON_VERSION_MAJOR)
|
||||
unset(PYTHON_VERSION_MINOR)
|
||||
unset(PYTHON_VERSION_PATCH)
|
||||
endif()
|
||||
|
||||
if(_found)
|
||||
set(_version_major_minor "${_version_major}.${_version_minor}")
|
||||
|
||||
if(NOT ANDROID AND NOT IOS)
|
||||
ocv_check_environment_variables(${library_env} ${include_dir_env})
|
||||
if(${library})
|
||||
set(PYTHON_LIBRARY "${${library_env}}")
|
||||
endif()
|
||||
if(${include_dir})
|
||||
set(PYTHON_INCLUDE_DIR "${${include_dir_env}}")
|
||||
endif()
|
||||
|
||||
# not using _version_string here, because it might not conform to the CMake version format
|
||||
find_host_package(PythonLibs "${_version_major_minor}.${_version_patch}" EXACT)
|
||||
|
||||
if(PYTHONLIBS_FOUND)
|
||||
# Copy outputs
|
||||
set(_libs_found ${PYTHONLIBS_FOUND})
|
||||
set(_libraries ${PYTHON_LIBRARIES})
|
||||
set(_include_path ${PYTHON_INCLUDE_PATH})
|
||||
set(_include_dirs ${PYTHON_INCLUDE_DIRS})
|
||||
set(_debug_libraries ${PYTHON_DEBUG_LIBRARIES})
|
||||
set(_libs_version_string ${PYTHONLIBS_VERSION_STRING})
|
||||
set(_debug_library ${PYTHON_DEBUG_LIBRARY})
|
||||
set(_library ${PYTHON_LIBRARY})
|
||||
set(_library_debug ${PYTHON_LIBRARY_DEBUG})
|
||||
set(_library_release ${PYTHON_LIBRARY_RELEASE})
|
||||
set(_include_dir ${PYTHON_INCLUDE_DIR})
|
||||
set(_include_dir2 ${PYTHON_INCLUDE_DIR2})
|
||||
|
||||
# Clear find_host_package side effects
|
||||
unset(PYTHONLIBS_FOUND)
|
||||
unset(PYTHON_LIBRARIES)
|
||||
unset(PYTHON_INCLUDE_PATH)
|
||||
unset(PYTHON_INCLUDE_DIRS)
|
||||
unset(PYTHON_DEBUG_LIBRARIES)
|
||||
unset(PYTHONLIBS_VERSION_STRING)
|
||||
unset(PYTHON_DEBUG_LIBRARY CACHE)
|
||||
unset(PYTHON_LIBRARY)
|
||||
unset(PYTHON_LIBRARY_DEBUG)
|
||||
unset(PYTHON_LIBRARY_RELEASE)
|
||||
unset(PYTHON_LIBRARY CACHE)
|
||||
unset(PYTHON_LIBRARY_DEBUG CACHE)
|
||||
unset(PYTHON_LIBRARY_RELEASE CACHE)
|
||||
unset(PYTHON_INCLUDE_DIR CACHE)
|
||||
unset(PYTHON_INCLUDE_DIR2 CACHE)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(NOT ANDROID AND NOT IOS)
|
||||
if(CMAKE_HOST_UNIX)
|
||||
execute_process(COMMAND ${_executable} -c "from distutils.sysconfig import *; print(get_python_lib())"
|
||||
RESULT_VARIABLE _cvpy_process
|
||||
OUTPUT_VARIABLE _std_packages_path
|
||||
OUTPUT_STRIP_TRAILING_WHITESPACE)
|
||||
if("${_std_packages_path}" MATCHES "site-packages")
|
||||
set(_packages_path "python${_version_major_minor}/site-packages")
|
||||
else() #debian based assumed, install to the dist-packages.
|
||||
set(_packages_path "python${_version_major_minor}/dist-packages")
|
||||
endif()
|
||||
if(EXISTS "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/${${packages_path}}")
|
||||
set(_packages_path "lib${LIB_SUFFIX}/${_packages_path}")
|
||||
else()
|
||||
set(_packages_path "lib/${_packages_path}")
|
||||
endif()
|
||||
elseif(CMAKE_HOST_WIN32)
|
||||
get_filename_component(_path "${_executable}" PATH)
|
||||
file(TO_CMAKE_PATH "${_path}" _path)
|
||||
if(NOT EXISTS "${_path}/Lib/site-packages")
|
||||
unset(_path)
|
||||
get_filename_component(_path "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${_version_major_minor}\\InstallPath]" ABSOLUTE)
|
||||
if(NOT _path)
|
||||
get_filename_component(_path "[HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${_version_major_minor}\\InstallPath]" ABSOLUTE)
|
||||
endif()
|
||||
file(TO_CMAKE_PATH "${_path}" _path)
|
||||
endif()
|
||||
set(_packages_path "${_path}/Lib/site-packages")
|
||||
unset(_path)
|
||||
endif()
|
||||
|
||||
set(_numpy_include_dirs ${${numpy_include_dirs}})
|
||||
|
||||
if(NOT _numpy_include_dirs)
|
||||
if(CMAKE_CROSSCOMPILING)
|
||||
message(STATUS "Cannot probe for Python/Numpy support (because we are cross-compiling OpenCV)")
|
||||
message(STATUS "If you want to enable Python/Numpy support, set the following variables:")
|
||||
message(STATUS " PYTHON2_INCLUDE_PATH")
|
||||
message(STATUS " PYTHON2_LIBRARIES")
|
||||
message(STATUS " PYTHON2_NUMPY_INCLUDE_DIRS")
|
||||
message(STATUS " PYTHON3_INCLUDE_PATH")
|
||||
message(STATUS " PYTHON3_LIBRARIES")
|
||||
message(STATUS " PYTHON3_NUMPY_INCLUDE_DIRS")
|
||||
else()
|
||||
# Attempt to discover the NumPy include directory. If this succeeds, then build python API with NumPy
|
||||
execute_process(COMMAND "${_executable}" -c "import os; os.environ['DISTUTILS_USE_SDK']='1'; import numpy.distutils; print(os.pathsep.join(numpy.distutils.misc_util.get_numpy_include_dirs()))"
|
||||
RESULT_VARIABLE _numpy_process
|
||||
OUTPUT_VARIABLE _numpy_include_dirs
|
||||
OUTPUT_STRIP_TRAILING_WHITESPACE)
|
||||
|
||||
if(NOT _numpy_process EQUAL 0)
|
||||
unset(_numpy_include_dirs)
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(_numpy_include_dirs)
|
||||
file(TO_CMAKE_PATH "${_numpy_include_dirs}" _numpy_include_dirs)
|
||||
if(CMAKE_CROSSCOMPILING)
|
||||
if(NOT _numpy_version)
|
||||
set(_numpy_version "undefined - cannot be probed because of the cross-compilation")
|
||||
endif()
|
||||
else()
|
||||
execute_process(COMMAND "${_executable}" -c "import numpy; print(numpy.version.version)"
|
||||
RESULT_VARIABLE _numpy_process
|
||||
OUTPUT_VARIABLE _numpy_version
|
||||
OUTPUT_STRIP_TRAILING_WHITESPACE)
|
||||
endif()
|
||||
endif()
|
||||
endif(NOT ANDROID AND NOT IOS)
|
||||
endif()
|
||||
|
||||
# Export return values
|
||||
set(${found} "${_found}" PARENT_SCOPE)
|
||||
set(${executable} "${_executable}" CACHE FILEPATH "Path to Python interpretor")
|
||||
set(${version_string} "${_version_string}" PARENT_SCOPE)
|
||||
set(${version_major} "${_version_major}" PARENT_SCOPE)
|
||||
set(${version_minor} "${_version_minor}" PARENT_SCOPE)
|
||||
set(${libs_found} "${_libs_found}" PARENT_SCOPE)
|
||||
set(${libs_version_string} "${_libs_version_string}" PARENT_SCOPE)
|
||||
set(${libraries} "${_libraries}" PARENT_SCOPE)
|
||||
set(${library} "${_library}" CACHE FILEPATH "Path to Python library")
|
||||
set(${debug_libraries} "${_debug_libraries}" PARENT_SCOPE)
|
||||
set(${debug_library} "${_debug_library}" CACHE FILEPATH "Path to Python debug")
|
||||
set(${include_path} "${_include_path}" PARENT_SCOPE)
|
||||
set(${include_dir} "${_include_dir}" CACHE PATH "Python include dir")
|
||||
set(${include_dir2} "${_include_dir2}" CACHE PATH "Python include dir 2")
|
||||
set(${packages_path} "${_packages_path}" CACHE PATH "Where to install the python packages.")
|
||||
set(${numpy_include_dirs} ${_numpy_include_dirs} CACHE PATH "Path to numpy headers")
|
||||
set(${numpy_version} "${_numpy_version}" PARENT_SCOPE)
|
||||
endfunction(find_python)
|
||||
|
||||
find_python(2.7 "${MIN_VER_PYTHON2}" PYTHON2_LIBRARY PYTHON2_INCLUDE_DIR
|
||||
PYTHON2INTERP_FOUND PYTHON2_EXECUTABLE PYTHON2_VERSION_STRING
|
||||
PYTHON2_VERSION_MAJOR PYTHON2_VERSION_MINOR PYTHON2LIBS_FOUND
|
||||
PYTHON2LIBS_VERSION_STRING PYTHON2_LIBRARIES PYTHON2_LIBRARY
|
||||
PYTHON2_DEBUG_LIBRARIES PYTHON2_LIBRARY_DEBUG PYTHON2_INCLUDE_PATH
|
||||
PYTHON2_INCLUDE_DIR PYTHON2_INCLUDE_DIR2 PYTHON2_PACKAGES_PATH
|
||||
PYTHON2_NUMPY_INCLUDE_DIRS PYTHON2_NUMPY_VERSION)
|
||||
|
||||
find_python(3.4 "${MIN_VER_PYTHON3}" PYTHON3_LIBRARY PYTHON3_INCLUDE_DIR
|
||||
PYTHON3INTERP_FOUND PYTHON3_EXECUTABLE PYTHON3_VERSION_STRING
|
||||
PYTHON3_VERSION_MAJOR PYTHON3_VERSION_MINOR PYTHON3LIBS_FOUND
|
||||
PYTHON3LIBS_VERSION_STRING PYTHON3_LIBRARIES PYTHON3_LIBRARY
|
||||
PYTHON3_DEBUG_LIBRARIES PYTHON3_LIBRARY_DEBUG PYTHON3_INCLUDE_PATH
|
||||
PYTHON3_INCLUDE_DIR PYTHON3_INCLUDE_DIR2 PYTHON3_PACKAGES_PATH
|
||||
PYTHON3_NUMPY_INCLUDE_DIRS PYTHON3_NUMPY_VERSION)
|
||||
|
||||
# Use Python 2 as default Python interpreter
|
||||
if(PYTHON2LIBS_FOUND)
|
||||
set(PYTHON_DEFAULT_AVAILABLE "TRUE")
|
||||
set(PYTHON_DEFAULT_EXECUTABLE "${PYTHON2_EXECUTABLE}")
|
||||
endif()
|
||||
|
||||
unset(HAVE_SPHINX CACHE)
|
||||
|
||||
if(PYTHONINTERP_FOUND)
|
||||
set(PYTHON_VERSION_MAJOR_MINOR "${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}")
|
||||
|
||||
if(NOT ANDROID AND NOT IOS)
|
||||
ocv_check_environment_variables(PYTHON_LIBRARY PYTHON_INCLUDE_DIR)
|
||||
# not using PYTHON_VERSION_STRING here, because it might not conform to the CMake version format
|
||||
find_host_package(PythonLibs "${PYTHON_VERSION_MAJOR_MINOR}.${PYTHON_VERSION_PATCH}" EXACT)
|
||||
endif()
|
||||
|
||||
if(NOT ANDROID AND NOT IOS)
|
||||
if(CMAKE_HOST_UNIX)
|
||||
execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "from distutils.sysconfig import *; print(get_python_lib())"
|
||||
RESULT_VARIABLE PYTHON_CVPY_PROCESS
|
||||
OUTPUT_VARIABLE PYTHON_STD_PACKAGES_PATH
|
||||
OUTPUT_STRIP_TRAILING_WHITESPACE)
|
||||
if("${PYTHON_STD_PACKAGES_PATH}" MATCHES "site-packages")
|
||||
set(_PYTHON_PACKAGES_PATH "python${PYTHON_VERSION_MAJOR_MINOR}/site-packages")
|
||||
else() #debian based assumed, install to the dist-packages.
|
||||
set(_PYTHON_PACKAGES_PATH "python${PYTHON_VERSION_MAJOR_MINOR}/dist-packages")
|
||||
endif()
|
||||
if(EXISTS "${CMAKE_INSTALL_PREFIX}/lib${LIB_SUFFIX}/${PYTHON_PACKAGES_PATH}")
|
||||
set(_PYTHON_PACKAGES_PATH "lib${LIB_SUFFIX}/${_PYTHON_PACKAGES_PATH}")
|
||||
else()
|
||||
set(_PYTHON_PACKAGES_PATH "lib/${_PYTHON_PACKAGES_PATH}")
|
||||
endif()
|
||||
elseif(CMAKE_HOST_WIN32)
|
||||
get_filename_component(PYTHON_PATH "${PYTHON_EXECUTABLE}" PATH)
|
||||
file(TO_CMAKE_PATH "${PYTHON_PATH}" PYTHON_PATH)
|
||||
if(NOT EXISTS "${PYTHON_PATH}/Lib/site-packages")
|
||||
unset(PYTHON_PATH)
|
||||
get_filename_component(PYTHON_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Python\\PythonCore\\${PYTHON_VERSION_MAJOR_MINOR}\\InstallPath]" ABSOLUTE)
|
||||
if(NOT PYTHON_PATH)
|
||||
get_filename_component(PYTHON_PATH "[HKEY_CURRENT_USER\\SOFTWARE\\Python\\PythonCore\\${PYTHON_VERSION_MAJOR_MINOR}\\InstallPath]" ABSOLUTE)
|
||||
endif()
|
||||
file(TO_CMAKE_PATH "${PYTHON_PATH}" PYTHON_PATH)
|
||||
endif()
|
||||
set(_PYTHON_PACKAGES_PATH "${PYTHON_PATH}/Lib/site-packages")
|
||||
endif()
|
||||
SET(PYTHON_PACKAGES_PATH "${_PYTHON_PACKAGES_PATH}" CACHE PATH "Where to install the python packages.")
|
||||
|
||||
if(NOT PYTHON_NUMPY_INCLUDE_DIRS)
|
||||
if(CMAKE_CROSSCOMPILING)
|
||||
message(STATUS "Cannot probe for Python/Numpy support (because we are cross-compiling OpenCV)")
|
||||
message(STATUS "If you want to enable Python/Numpy support, set the following variables:")
|
||||
message(STATUS " PYTHON_INCLUDE_PATH")
|
||||
message(STATUS " PYTHON_LIBRARIES")
|
||||
message(STATUS " PYTHON_NUMPY_INCLUDE_DIRS")
|
||||
else()
|
||||
# Attempt to discover the NumPy include directory. If this succeeds, then build python API with NumPy
|
||||
execute_process(COMMAND "${PYTHON_EXECUTABLE}" -c "import os; os.environ['DISTUTILS_USE_SDK']='1'; import numpy.distutils; print(os.pathsep.join(numpy.distutils.misc_util.get_numpy_include_dirs()))"
|
||||
RESULT_VARIABLE PYTHON_NUMPY_PROCESS
|
||||
OUTPUT_VARIABLE PYTHON_NUMPY_INCLUDE_DIRS
|
||||
OUTPUT_STRIP_TRAILING_WHITESPACE)
|
||||
|
||||
if(NOT PYTHON_NUMPY_PROCESS EQUAL 0)
|
||||
unset(PYTHON_NUMPY_INCLUDE_DIRS)
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(PYTHON_NUMPY_INCLUDE_DIRS)
|
||||
file(TO_CMAKE_PATH "${PYTHON_NUMPY_INCLUDE_DIRS}" _PYTHON_NUMPY_INCLUDE_DIRS)
|
||||
set(PYTHON_NUMPY_INCLUDE_DIRS ${_PYTHON_NUMPY_INCLUDE_DIRS} CACHE PATH "Path to numpy headers")
|
||||
if(CMAKE_CROSSCOMPILING)
|
||||
if(NOT PYTHON_NUMPY_VERSION)
|
||||
set(PYTHON_NUMPY_VERSION "undefined - cannot be probed because of the cross-compilation")
|
||||
endif()
|
||||
else()
|
||||
execute_process(COMMAND "${PYTHON_EXECUTABLE}" -c "import numpy; print(numpy.version.version)"
|
||||
RESULT_VARIABLE PYTHON_NUMPY_PROCESS
|
||||
OUTPUT_VARIABLE PYTHON_NUMPY_VERSION
|
||||
OUTPUT_STRIP_TRAILING_WHITESPACE)
|
||||
endif()
|
||||
endif()
|
||||
endif(NOT ANDROID AND NOT IOS)
|
||||
endif()
|
||||
|
||||
if(BUILD_DOCS)
|
||||
find_host_program(SPHINX_BUILD sphinx-build)
|
||||
find_host_program(PLANTUML plantuml)
|
||||
|
||||
@ -1,5 +1,6 @@
|
||||
set(MIN_VER_CMAKE 2.8.7)
|
||||
set(MIN_VER_CUDA 4.2)
|
||||
set(MIN_VER_PYTHON 2.6)
|
||||
set(MIN_VER_PYTHON2 2.6)
|
||||
set(MIN_VER_PYTHON3 3.2)
|
||||
set(MIN_VER_ZLIB 1.2.3)
|
||||
set(MIN_VER_GTK 2.18.0)
|
||||
|
||||
@ -6,16 +6,19 @@
|
||||
# Global variables:
|
||||
#
|
||||
# OPENCV_MODULE_${the_module}_LOCATION
|
||||
# OPENCV_MODULE_${the_module}_BINARY_DIR
|
||||
# OPENCV_MODULE_${the_module}_DESCRIPTION
|
||||
# OPENCV_MODULE_${the_module}_CLASS - PUBLIC|INTERNAL|BINDINGS
|
||||
# OPENCV_MODULE_${the_module}_HEADERS
|
||||
# OPENCV_MODULE_${the_module}_SOURCES
|
||||
# OPENCV_MODULE_${the_module}_DEPS - final flattened set of module dependencies
|
||||
# OPENCV_MODULE_${the_module}_DEPS_TO_LINK - differs from above for world build only
|
||||
# OPENCV_MODULE_${the_module}_DEPS_EXT - non-module dependencies
|
||||
# OPENCV_MODULE_${the_module}_REQ_DEPS
|
||||
# OPENCV_MODULE_${the_module}_OPT_DEPS
|
||||
# OPENCV_MODULE_${the_module}_PRIVATE_REQ_DEPS
|
||||
# OPENCV_MODULE_${the_module}_PRIVATE_OPT_DEPS
|
||||
# OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD
|
||||
# HAVE_${the_module} - for fast check of module availability
|
||||
|
||||
# To control the setup of the module you could also set:
|
||||
@ -53,6 +56,7 @@ foreach(mod ${OPENCV_MODULES_BUILD} ${OPENCV_MODULES_DISABLED_USER} ${OPENCV_MOD
|
||||
unset(OPENCV_MODULE_${mod}_OPT_DEPS CACHE)
|
||||
unset(OPENCV_MODULE_${mod}_PRIVATE_REQ_DEPS CACHE)
|
||||
unset(OPENCV_MODULE_${mod}_PRIVATE_OPT_DEPS CACHE)
|
||||
unset(OPENCV_MODULE_${mod}_LINK_DEPS CACHE)
|
||||
endforeach()
|
||||
|
||||
# clean modules info which needs to be recalculated
|
||||
@ -61,6 +65,7 @@ set(OPENCV_MODULES_BUILD "" CACHE INTERNAL "List of OpenCV modules incl
|
||||
set(OPENCV_MODULES_DISABLED_USER "" CACHE INTERNAL "List of OpenCV modules explicitly disabled by user")
|
||||
set(OPENCV_MODULES_DISABLED_AUTO "" CACHE INTERNAL "List of OpenCV modules implicitly disabled due to dependencies")
|
||||
set(OPENCV_MODULES_DISABLED_FORCE "" CACHE INTERNAL "List of OpenCV modules which can not be build in current configuration")
|
||||
unset(OPENCV_WORLD_MODULES CACHE)
|
||||
|
||||
# adds dependencies to OpenCV module
|
||||
# Usage:
|
||||
@ -68,6 +73,7 @@ set(OPENCV_MODULES_DISABLED_FORCE "" CACHE INTERNAL "List of OpenCV modules whic
|
||||
# Notes:
|
||||
# * <list of dependencies> - can include full names of modules or full pathes to shared/static libraries or cmake targets
|
||||
macro(ocv_add_dependencies full_modname)
|
||||
ocv_debug_message("ocv_add_dependencies(" ${full_modname} ${ARGN} ")")
|
||||
#we don't clean the dependencies here to allow this macro several times for every module
|
||||
foreach(d "REQUIRED" ${ARGN})
|
||||
if(d STREQUAL "REQUIRED")
|
||||
@ -105,6 +111,7 @@ endmacro()
|
||||
# Example:
|
||||
# ocv_add_module(yaom INTERNAL opencv_core opencv_highgui opencv_flann OPTIONAL opencv_cuda)
|
||||
macro(ocv_add_module _name)
|
||||
ocv_debug_message("ocv_add_module(" ${_name} ${ARGN} ")")
|
||||
string(TOLOWER "${_name}" name)
|
||||
string(REGEX REPLACE "^opencv_" "" ${name} "${name}")
|
||||
set(the_module opencv_${name})
|
||||
@ -134,6 +141,8 @@ macro(ocv_add_module _name)
|
||||
set(OPENCV_MODULE_${the_module}_DESCRIPTION "${the_description}" CACHE INTERNAL "Brief description of ${the_module} module")
|
||||
set(OPENCV_MODULE_${the_module}_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "Location of ${the_module} module sources")
|
||||
|
||||
set(OPENCV_MODULE_${the_module}_LINK_DEPS "" CACHE INTERNAL "")
|
||||
|
||||
# parse list of dependencies
|
||||
if("${ARGV1}" STREQUAL "INTERNAL" OR "${ARGV1}" STREQUAL "BINDINGS")
|
||||
set(OPENCV_MODULE_${the_module}_CLASS "${ARGV1}" CACHE INTERNAL "The category of the module")
|
||||
@ -150,8 +159,14 @@ macro(ocv_add_module _name)
|
||||
endif()
|
||||
|
||||
# add self to the world dependencies
|
||||
if(NOT DEFINED OPENCV_MODULE_IS_PART_OF_WORLD AND NOT OPENCV_MODULE_${the_module}_CLASS STREQUAL "BINDINGS" OR OPENCV_MODULE_IS_PART_OF_WORLD)
|
||||
if((NOT DEFINED OPENCV_MODULE_IS_PART_OF_WORLD AND NOT OPENCV_MODULE_${the_module}_CLASS STREQUAL "BINDINGS"
|
||||
AND NOT OPENCV_PROCESSING_EXTRA_MODULES)
|
||||
OR OPENCV_MODULE_IS_PART_OF_WORLD
|
||||
)
|
||||
set(OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD ON CACHE INTERNAL "")
|
||||
ocv_add_dependencies(opencv_world OPTIONAL ${the_module})
|
||||
else()
|
||||
set(OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD OFF CACHE INTERNAL "")
|
||||
endif()
|
||||
|
||||
if(BUILD_${the_module})
|
||||
@ -164,12 +179,15 @@ macro(ocv_add_module _name)
|
||||
|
||||
# stop processing of current file
|
||||
return()
|
||||
else(OPENCV_INITIAL_PASS)
|
||||
else()
|
||||
set(OPENCV_MODULE_${the_module}_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}" CACHE INTERNAL "")
|
||||
if(NOT BUILD_${the_module})
|
||||
return() # extra protection from redefinition
|
||||
endif()
|
||||
project(${the_module})
|
||||
endif(OPENCV_INITIAL_PASS)
|
||||
if((NOT OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD AND NOT ${the_module} STREQUAL opencv_world) OR NOT ${BUILD_opencv_world})
|
||||
project(${the_module})
|
||||
endif()
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
# excludes module from current configuration
|
||||
@ -200,7 +218,11 @@ macro(ocv_glob_modules)
|
||||
|
||||
# collect modules
|
||||
set(OPENCV_INITIAL_PASS ON)
|
||||
set(OPENCV_PROCESSING_EXTRA_MODULES 0)
|
||||
foreach(__path ${ARGN})
|
||||
if("${__path}" STREQUAL "EXTRA")
|
||||
set(OPENCV_PROCESSING_EXTRA_MODULES 1)
|
||||
endif()
|
||||
get_filename_component(__path "${__path}" ABSOLUTE)
|
||||
|
||||
list(FIND __directories_observed "${__path}" __pathIdx)
|
||||
@ -222,16 +244,7 @@ macro(ocv_glob_modules)
|
||||
endif()
|
||||
list(APPEND __directories_observed "${__modpath}")
|
||||
|
||||
if(OCV_MODULE_RELOCATE_ON_INITIAL_PASS)
|
||||
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
|
||||
file(COPY "${__modpath}/CMakeLists.txt" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
|
||||
add_subdirectory("${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}" "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
|
||||
if("${OPENCV_MODULE_opencv_${mod}_LOCATION}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
|
||||
set(OPENCV_MODULE_opencv_${mod}_LOCATION "${__modpath}" CACHE PATH "" FORCE)
|
||||
endif()
|
||||
else()
|
||||
add_subdirectory("${__modpath}" "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
|
||||
endif()
|
||||
add_subdirectory("${__modpath}" "${CMAKE_CURRENT_BINARY_DIR}/${mod}/.${mod}")
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
@ -244,15 +257,31 @@ macro(ocv_glob_modules)
|
||||
# create modules
|
||||
set(OPENCV_INITIAL_PASS OFF PARENT_SCOPE)
|
||||
set(OPENCV_INITIAL_PASS OFF)
|
||||
foreach(m ${OPENCV_MODULES_BUILD})
|
||||
if(m MATCHES "^opencv_")
|
||||
string(REGEX REPLACE "^opencv_" "" __shortname "${m}")
|
||||
add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")
|
||||
else()
|
||||
message(WARNING "Check module name: ${m}")
|
||||
add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")
|
||||
endif()
|
||||
endforeach()
|
||||
if(${BUILD_opencv_world})
|
||||
add_subdirectory("${OPENCV_MODULE_opencv_world_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/world")
|
||||
foreach(m ${OPENCV_MODULES_BUILD})
|
||||
if(NOT OPENCV_MODULE_${m}_IS_PART_OF_WORLD AND NOT ${m} STREQUAL opencv_world)
|
||||
message(STATUS "Processing module ${m}...")
|
||||
if(m MATCHES "^opencv_")
|
||||
string(REGEX REPLACE "^opencv_" "" __shortname "${m}")
|
||||
add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")
|
||||
else()
|
||||
message(WARNING "Check module name: ${m}")
|
||||
add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")
|
||||
endif()
|
||||
endif()
|
||||
endforeach()
|
||||
else()
|
||||
foreach(m ${OPENCV_MODULES_BUILD})
|
||||
if(m MATCHES "^opencv_")
|
||||
string(REGEX REPLACE "^opencv_" "" __shortname "${m}")
|
||||
add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${__shortname}")
|
||||
else()
|
||||
message(WARNING "Check module name: ${m}")
|
||||
add_subdirectory("${OPENCV_MODULE_${m}_LOCATION}" "${CMAKE_CURRENT_BINARY_DIR}/${m}")
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
unset(__shortname)
|
||||
endmacro()
|
||||
|
||||
@ -394,11 +423,36 @@ function(__ocv_resolve_dependencies)
|
||||
__ocv_sort_modules_by_deps(OPENCV_MODULE_${m}_DEPS)
|
||||
ocv_list_sort(OPENCV_MODULE_${m}_DEPS_EXT)
|
||||
|
||||
set(LINK_DEPS ${OPENCV_MODULE_${m}_DEPS})
|
||||
|
||||
# process world
|
||||
if(BUILD_opencv_world)
|
||||
if(OPENCV_MODULE_${m}_IS_PART_OF_WORLD)
|
||||
list(APPEND OPENCV_WORLD_MODULES ${m})
|
||||
endif()
|
||||
foreach(m2 ${OPENCV_MODULES_BUILD})
|
||||
if(OPENCV_MODULE_${m2}_IS_PART_OF_WORLD)
|
||||
if(";${LINK_DEPS};" MATCHES ";${m2};")
|
||||
list(REMOVE_ITEM LINK_DEPS ${m2})
|
||||
if(NOT (";${LINK_DEPS};" MATCHES ";opencv_world;") AND NOT (${m} STREQUAL opencv_world))
|
||||
list(APPEND LINK_DEPS opencv_world)
|
||||
endif()
|
||||
endif()
|
||||
if(${m} STREQUAL opencv_world)
|
||||
list(APPEND OPENCV_MODULE_opencv_world_DEPS_EXT ${OPENCV_MODULE_${m2}_DEPS_EXT})
|
||||
endif()
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
set(OPENCV_MODULE_${m}_DEPS ${OPENCV_MODULE_${m}_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module")
|
||||
set(OPENCV_MODULE_${m}_DEPS_EXT ${OPENCV_MODULE_${m}_DEPS_EXT} CACHE INTERNAL "Extra dependencies of ${m} module")
|
||||
set(OPENCV_MODULE_${m}_DEPS_TO_LINK ${LINK_DEPS} CACHE INTERNAL "Flattened dependencies of ${m} module (for linker)")
|
||||
|
||||
# message(STATUS " module deps: ${OPENCV_MODULE_${m}_DEPS}")
|
||||
# message(STATUS " extra deps: ${OPENCV_MODULE_${m}_DEPS_EXT}")
|
||||
# message(STATUS " module deps of ${m}: ${OPENCV_MODULE_${m}_DEPS}")
|
||||
# message(STATUS " module link deps of ${m}: ${OPENCV_MODULE_${m}_DEPS_TO_LINK}")
|
||||
# message(STATUS " extra deps of ${m}: ${OPENCV_MODULE_${m}_DEPS_EXT}")
|
||||
# message(STATUS "")
|
||||
endforeach()
|
||||
|
||||
__ocv_sort_modules_by_deps(OPENCV_MODULES_BUILD)
|
||||
@ -406,6 +460,7 @@ function(__ocv_resolve_dependencies)
|
||||
set(OPENCV_MODULES_PUBLIC ${OPENCV_MODULES_PUBLIC} CACHE INTERNAL "List of OpenCV modules marked for export")
|
||||
set(OPENCV_MODULES_BUILD ${OPENCV_MODULES_BUILD} CACHE INTERNAL "List of OpenCV modules included into the build")
|
||||
set(OPENCV_MODULES_DISABLED_AUTO ${OPENCV_MODULES_DISABLED_AUTO} CACHE INTERNAL "List of OpenCV modules implicitly disabled due to dependencies")
|
||||
set(OPENCV_WORLD_MODULES ${OPENCV_WORLD_MODULES} CACHE INTERNAL "List of OpenCV modules included into the world")
|
||||
endfunction()
|
||||
|
||||
|
||||
@ -422,18 +477,31 @@ macro(ocv_include_modules)
|
||||
endforeach()
|
||||
endmacro()
|
||||
|
||||
# setup include paths for the list of passed modules and recursively add dependent modules
|
||||
macro(ocv_include_modules_recurse)
|
||||
# setup include paths for the list of passed modules
|
||||
macro(ocv_target_include_modules target)
|
||||
foreach(d ${ARGN})
|
||||
if(d MATCHES "^opencv_" AND HAVE_${d})
|
||||
if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")
|
||||
ocv_include_directories("${OPENCV_MODULE_${d}_LOCATION}/include")
|
||||
endif()
|
||||
if(OPENCV_MODULE_${d}_DEPS)
|
||||
ocv_include_modules(${OPENCV_MODULE_${d}_DEPS})
|
||||
ocv_target_include_directories(${target} "${OPENCV_MODULE_${d}_LOCATION}/include")
|
||||
endif()
|
||||
elseif(EXISTS "${d}")
|
||||
ocv_include_directories("${d}")
|
||||
ocv_target_include_directories(${target} "${d}")
|
||||
endif()
|
||||
endforeach()
|
||||
endmacro()
|
||||
|
||||
# setup include paths for the list of passed modules and recursively add dependent modules
|
||||
macro(ocv_target_include_modules_recurse target)
|
||||
foreach(d ${ARGN})
|
||||
if(d MATCHES "^opencv_" AND HAVE_${d})
|
||||
if (EXISTS "${OPENCV_MODULE_${d}_LOCATION}/include")
|
||||
ocv_target_include_directories(${target} "${OPENCV_MODULE_${d}_LOCATION}/include")
|
||||
endif()
|
||||
if(OPENCV_MODULE_${d}_DEPS)
|
||||
ocv_target_include_modules(${target} ${OPENCV_MODULE_${d}_DEPS})
|
||||
endif()
|
||||
elseif(EXISTS "${d}")
|
||||
ocv_target_include_directories(${target} "${d}")
|
||||
endif()
|
||||
endforeach()
|
||||
endmacro()
|
||||
@ -441,11 +509,12 @@ endmacro()
|
||||
# setup include path for OpenCV headers for specified module
|
||||
# ocv_module_include_directories(<extra include directories/extra include modules>)
|
||||
macro(ocv_module_include_directories)
|
||||
ocv_include_directories("${OPENCV_MODULE_${the_module}_LOCATION}/include"
|
||||
"${OPENCV_MODULE_${the_module}_LOCATION}/src"
|
||||
"${CMAKE_CURRENT_BINARY_DIR}" # for precompiled headers
|
||||
)
|
||||
ocv_include_modules(${OPENCV_MODULE_${the_module}_DEPS} ${ARGN})
|
||||
ocv_target_include_directories(${the_module}
|
||||
"${OPENCV_MODULE_${the_module}_LOCATION}/include"
|
||||
"${OPENCV_MODULE_${the_module}_LOCATION}/src"
|
||||
"${CMAKE_CURRENT_BINARY_DIR}" # for precompiled headers
|
||||
)
|
||||
ocv_target_include_modules(${the_module} ${OPENCV_MODULE_${the_module}_DEPS} ${ARGN})
|
||||
endmacro()
|
||||
|
||||
|
||||
@ -454,6 +523,8 @@ endmacro()
|
||||
# Usage:
|
||||
# ocv_set_module_sources([HEADERS] <list of files> [SOURCES] <list of files>)
|
||||
macro(ocv_set_module_sources)
|
||||
ocv_debug_message("ocv_set_module_sources(" ${ARGN} ")")
|
||||
|
||||
set(OPENCV_MODULE_${the_module}_HEADERS "")
|
||||
set(OPENCV_MODULE_${the_module}_SOURCES "")
|
||||
|
||||
@ -481,31 +552,50 @@ endmacro()
|
||||
# Usage:
|
||||
# ocv_glob_module_sources([EXCLUDE_CUDA] <extra sources&headers in the same format as used in ocv_set_module_sources>)
|
||||
macro(ocv_glob_module_sources)
|
||||
ocv_debug_message("ocv_glob_module_sources(" ${ARGN} ")")
|
||||
set(_argn ${ARGN})
|
||||
list(FIND _argn "EXCLUDE_CUDA" exclude_cuda)
|
||||
if(NOT exclude_cuda EQUAL -1)
|
||||
list(REMOVE_AT _argn ${exclude_cuda})
|
||||
endif()
|
||||
|
||||
file(GLOB_RECURSE lib_srcs "src/*.cpp")
|
||||
file(GLOB_RECURSE lib_int_hdrs "src/*.hpp" "src/*.h")
|
||||
file(GLOB lib_hdrs "include/opencv2/*.hpp" "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h")
|
||||
file(GLOB lib_hdrs_detail "include/opencv2/${name}/detail/*.hpp" "include/opencv2/${name}/detail/*.h")
|
||||
file(GLOB_RECURSE lib_srcs_apple "src/*.mm")
|
||||
file(GLOB_RECURSE lib_srcs
|
||||
"${CMAKE_CURRENT_LIST_DIR}/src/*.cpp"
|
||||
)
|
||||
file(GLOB_RECURSE lib_int_hdrs
|
||||
"${CMAKE_CURRENT_LIST_DIR}/src/*.hpp"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/src/*.h"
|
||||
)
|
||||
file(GLOB lib_hdrs
|
||||
"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/*.hpp"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.hpp"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/*.h"
|
||||
)
|
||||
file(GLOB lib_hdrs_detail
|
||||
"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/detail/*.hpp"
|
||||
"${CMAKE_CURRENT_LIST_DIR}/include/opencv2/${name}/detail/*.h"
|
||||
)
|
||||
if (APPLE)
|
||||
file(GLOB_RECURSE lib_srcs_apple
|
||||
"${CMAKE_CURRENT_LIST_DIR}/src/*.mm"
|
||||
)
|
||||
list(APPEND lib_srcs ${lib_srcs_apple})
|
||||
endif()
|
||||
|
||||
ocv_source_group("Src" DIRBASE "${CMAKE_CURRENT_SOURCE_DIR}/src" FILES ${lib_srcs} ${lib_int_hdrs})
|
||||
ocv_source_group("Include" DIRBASE "${CMAKE_CURRENT_SOURCE_DIR}/include" FILES ${lib_hdrs} ${lib_hdrs_detail})
|
||||
ocv_source_group("Src" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/src" FILES ${lib_srcs} ${lib_int_hdrs})
|
||||
ocv_source_group("Include" DIRBASE "${CMAKE_CURRENT_LIST_DIR}/include" FILES ${lib_hdrs} ${lib_hdrs_detail})
|
||||
|
||||
if (exclude_cuda EQUAL -1)
|
||||
file(GLOB lib_cuda_srcs "src/cuda/*.cu")
|
||||
file(GLOB lib_cuda_srcs
|
||||
"${CMAKE_CURRENT_LIST_DIR}/src/cuda/*.cu"
|
||||
)
|
||||
set(cuda_objs "")
|
||||
set(lib_cuda_hdrs "")
|
||||
if(HAVE_CUDA)
|
||||
ocv_include_directories(${CUDA_INCLUDE_DIRS})
|
||||
file(GLOB lib_cuda_hdrs "src/cuda/*.hpp")
|
||||
file(GLOB lib_cuda_hdrs
|
||||
"${CMAKE_CURRENT_LIST_DIR}/src/cuda/*.hpp"
|
||||
)
|
||||
|
||||
ocv_cuda_compile(cuda_objs ${lib_cuda_srcs} ${lib_cuda_hdrs})
|
||||
source_group("Src\\Cuda" FILES ${lib_cuda_srcs} ${lib_cuda_hdrs})
|
||||
@ -516,17 +606,19 @@ macro(ocv_glob_module_sources)
|
||||
set(lib_cuda_hdrs "")
|
||||
endif()
|
||||
|
||||
file(GLOB cl_kernels "src/opencl/*.cl")
|
||||
file(GLOB cl_kernels
|
||||
"${CMAKE_CURRENT_LIST_DIR}/src/opencl/*.cl"
|
||||
)
|
||||
if(cl_kernels)
|
||||
set(OCL_NAME opencl_kernels_${name})
|
||||
ocv_include_directories(${OPENCL_INCLUDE_DIRS})
|
||||
string(REGEX REPLACE "opencv_" "" the_module_barename "${the_module}")
|
||||
add_custom_command(
|
||||
OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.cpp" "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.hpp"
|
||||
COMMAND ${CMAKE_COMMAND} -DMODULE_NAME="${the_module_barename}" -DCL_DIR="${CMAKE_CURRENT_SOURCE_DIR}/src/opencl" -DOUTPUT="${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.cpp" -P "${OpenCV_SOURCE_DIR}/cmake/cl2cpp.cmake"
|
||||
OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp"
|
||||
COMMAND ${CMAKE_COMMAND} -DMODULE_NAME="${name}" -DCL_DIR="${CMAKE_CURRENT_LIST_DIR}/src/opencl" -DOUTPUT="${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" -P "${OpenCV_SOURCE_DIR}/cmake/cl2cpp.cmake"
|
||||
DEPENDS ${cl_kernels} "${OpenCV_SOURCE_DIR}/cmake/cl2cpp.cmake")
|
||||
ocv_source_group("Src\\opencl\\kernels" FILES ${cl_kernels})
|
||||
ocv_source_group("Src\\opencl\\kernels\\autogenerated" FILES "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.cpp" "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.hpp")
|
||||
list(APPEND lib_srcs ${cl_kernels} "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.cpp" "${CMAKE_CURRENT_BINARY_DIR}/opencl_kernels.hpp")
|
||||
ocv_source_group("Src\\opencl\\kernels\\autogenerated" FILES "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp")
|
||||
list(APPEND lib_srcs ${cl_kernels} "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.cpp" "${CMAKE_CURRENT_BINARY_DIR}/${OCL_NAME}.hpp")
|
||||
endif()
|
||||
|
||||
ocv_set_module_sources(${_argn} HEADERS ${lib_hdrs} ${lib_hdrs_detail}
|
||||
@ -537,29 +629,39 @@ endmacro()
|
||||
# creates new target, configures standard dependencies, compilers flags, install rules
|
||||
# Usage:
|
||||
# ocv_create_module(<extra link dependencies>)
|
||||
# ocv_create_module(SKIP_LINK)
|
||||
# ocv_create_module()
|
||||
macro(ocv_create_module)
|
||||
ocv_debug_message("ocv_create_module(" ${ARGN} ")")
|
||||
set(OPENCV_MODULE_${the_module}_LINK_DEPS "${OPENCV_MODULE_${the_module}_LINK_DEPS};${ARGN}" CACHE INTERNAL "")
|
||||
if(${BUILD_opencv_world} AND OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD)
|
||||
# nothing
|
||||
set(the_module_target opencv_world)
|
||||
else()
|
||||
_ocv_create_module(${ARGN})
|
||||
set(the_module_target ${the_module})
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
macro(_ocv_create_module)
|
||||
# The condition we ought to be testing here is whether ocv_add_precompiled_headers will
|
||||
# be called at some point in the future. We can't look into the future, though,
|
||||
# so this will have to do.
|
||||
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp")
|
||||
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/src/precomp.hpp" AND NOT ${the_module} STREQUAL opencv_world)
|
||||
get_native_precompiled_header(${the_module} precomp.hpp)
|
||||
endif()
|
||||
|
||||
add_library(${the_module} ${OPENCV_MODULE_TYPE} ${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES}
|
||||
ocv_add_library(${the_module} ${OPENCV_MODULE_TYPE} ${OPENCV_MODULE_${the_module}_HEADERS} ${OPENCV_MODULE_${the_module}_SOURCES}
|
||||
"${OPENCV_CONFIG_FILE_INCLUDE_DIR}/cvconfig.h" "${OPENCV_CONFIG_FILE_INCLUDE_DIR}/opencv2/opencv_modules.hpp"
|
||||
${${the_module}_pch})
|
||||
if(NOT the_module STREQUAL opencv_ts)
|
||||
set_target_properties(${the_module} PROPERTIES COMPILE_DEFINITIONS OPENCV_NOSTL)
|
||||
endif()
|
||||
|
||||
if(NOT "${ARGN}" STREQUAL "SKIP_LINK")
|
||||
target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS})
|
||||
target_link_libraries(${the_module} LINK_INTERFACE_LIBRARIES ${OPENCV_MODULE_${the_module}_DEPS})
|
||||
target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS_EXT} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
|
||||
if (HAVE_CUDA)
|
||||
target_link_libraries(${the_module} ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
|
||||
endif()
|
||||
ocv_target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK})
|
||||
ocv_target_link_libraries(${the_module} LINK_INTERFACE_LIBRARIES ${OPENCV_MODULE_${the_module}_DEPS_TO_LINK})
|
||||
ocv_target_link_libraries(${the_module} ${OPENCV_MODULE_${the_module}_DEPS_EXT} ${OPENCV_LINKER_LIBS} ${IPP_LIBS} ${ARGN})
|
||||
if (HAVE_CUDA)
|
||||
ocv_target_link_libraries(${the_module} ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
|
||||
endif()
|
||||
|
||||
add_dependencies(opencv_modules ${the_module})
|
||||
@ -614,13 +716,16 @@ macro(ocv_create_module)
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
_ocv_add_precompiled_headers(${the_module})
|
||||
endmacro()
|
||||
|
||||
# opencv precompiled headers macro (can add pch to modules and tests)
|
||||
# this macro must be called after any "add_definitions" commands, otherwise precompiled headers will not work
|
||||
# Usage:
|
||||
# ocv_add_precompiled_headers(${the_module})
|
||||
macro(ocv_add_precompiled_headers the_target)
|
||||
macro(_ocv_add_precompiled_headers the_target)
|
||||
ocv_debug_message("ocv_add_precompiled_headers(" ${the_target} ${ARGN} ")")
|
||||
|
||||
if("${the_target}" MATCHES "^opencv_test_.*$")
|
||||
SET(pch_path "test/test_")
|
||||
elseif("${the_target}" MATCHES "^opencv_perf_.*$")
|
||||
@ -637,6 +742,7 @@ endmacro()
|
||||
# Usage:
|
||||
# ocv_define_module(module_name [INTERNAL] [EXCLUDE_CUDA] [REQUIRED] [<list of dependencies>] [OPTIONAL <list of optional dependencies>])
|
||||
macro(ocv_define_module module_name)
|
||||
ocv_debug_message("ocv_define_module(" ${module_name} ${ARGN} ")")
|
||||
set(_argn ${ARGN})
|
||||
set(exclude_cuda "")
|
||||
foreach(arg ${_argn})
|
||||
@ -647,10 +753,9 @@ macro(ocv_define_module module_name)
|
||||
endforeach()
|
||||
|
||||
ocv_add_module(${module_name} ${_argn})
|
||||
ocv_module_include_directories()
|
||||
ocv_glob_module_sources(${exclude_cuda})
|
||||
ocv_module_include_directories()
|
||||
ocv_create_module()
|
||||
ocv_add_precompiled_headers(${the_module})
|
||||
|
||||
ocv_add_accuracy_tests()
|
||||
ocv_add_perf_tests()
|
||||
@ -685,7 +790,7 @@ macro(__ocv_parse_test_sources tests_type)
|
||||
set(__file_group_name "")
|
||||
set(__file_group_sources "")
|
||||
elseif(arg STREQUAL "DEPENDS_ON")
|
||||
set(__currentvar "OPENCV_TEST_${the_module}_DEPS")
|
||||
set(__currentvar "OPENCV_${tests_type}_${the_module}_DEPS")
|
||||
elseif("${__currentvar}" STREQUAL "__file_group_sources" AND NOT __file_group_name)
|
||||
set(__file_group_name "${arg}")
|
||||
else()
|
||||
@ -700,20 +805,20 @@ endmacro()
|
||||
# this is a command for adding OpenCV performance tests to the module
|
||||
# ocv_add_perf_tests(<extra_dependencies>)
|
||||
function(ocv_add_perf_tests)
|
||||
set(perf_path "${CMAKE_CURRENT_SOURCE_DIR}/perf")
|
||||
ocv_debug_message("ocv_add_perf_tests(" ${ARGN} ")")
|
||||
|
||||
set(perf_path "${CMAKE_CURRENT_LIST_DIR}/perf")
|
||||
if(BUILD_PERF_TESTS AND EXISTS "${perf_path}")
|
||||
__ocv_parse_test_sources(PERF ${ARGN})
|
||||
|
||||
# opencv_imgcodecs is required for imread/imwrite
|
||||
set(perf_deps ${the_module} opencv_ts opencv_imgcodecs ${OPENCV_PERF_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
|
||||
set(perf_deps ${the_module} opencv_ts opencv_imgcodecs ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
|
||||
ocv_check_dependencies(${perf_deps})
|
||||
|
||||
if(OCV_DEPENDENCIES_FOUND)
|
||||
set(the_target "opencv_perf_${name}")
|
||||
# project(${the_target})
|
||||
|
||||
ocv_module_include_directories(${perf_deps} "${perf_path}")
|
||||
|
||||
if(NOT OPENCV_PERF_${the_module}_SOURCES)
|
||||
file(GLOB_RECURSE perf_srcs "${perf_path}/*.cpp")
|
||||
file(GLOB_RECURSE perf_hdrs "${perf_path}/*.hpp" "${perf_path}/*.h")
|
||||
@ -722,10 +827,13 @@ function(ocv_add_perf_tests)
|
||||
set(OPENCV_PERF_${the_module}_SOURCES ${perf_srcs} ${perf_hdrs})
|
||||
endif()
|
||||
|
||||
get_native_precompiled_header(${the_target} perf_precomp.hpp)
|
||||
if(NOT BUILD_opencv_world)
|
||||
get_native_precompiled_header(${the_target} perf_precomp.hpp)
|
||||
endif()
|
||||
|
||||
add_executable(${the_target} ${OPENCV_PERF_${the_module}_SOURCES} ${${the_target}_pch})
|
||||
target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${perf_deps} ${OPENCV_LINKER_LIBS})
|
||||
ocv_add_executable(${the_target} ${OPENCV_PERF_${the_module}_SOURCES} ${${the_target}_pch})
|
||||
ocv_target_include_modules(${the_target} ${perf_deps} "${perf_path}")
|
||||
ocv_target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${perf_deps} ${OPENCV_LINKER_LIBS})
|
||||
add_dependencies(opencv_perf_tests ${the_target})
|
||||
|
||||
# Additional target properties
|
||||
@ -738,8 +846,9 @@ function(ocv_add_perf_tests)
|
||||
set_target_properties(${the_target} PROPERTIES FOLDER "tests performance")
|
||||
endif()
|
||||
|
||||
ocv_add_precompiled_headers(${the_target})
|
||||
|
||||
if(NOT BUILD_opencv_world)
|
||||
_ocv_add_precompiled_headers(${the_target})
|
||||
endif()
|
||||
else(OCV_DEPENDENCIES_FOUND)
|
||||
# TODO: warn about unsatisfied dependencies
|
||||
endif(OCV_DEPENDENCIES_FOUND)
|
||||
@ -752,21 +861,19 @@ endfunction()
|
||||
# this is a command for adding OpenCV accuracy/regression tests to the module
|
||||
# ocv_add_accuracy_tests([FILES <source group name> <list of sources>] [DEPENDS_ON] <list of extra dependencies>)
|
||||
function(ocv_add_accuracy_tests)
|
||||
set(test_path "${CMAKE_CURRENT_SOURCE_DIR}/test")
|
||||
ocv_check_dependencies(${test_deps})
|
||||
ocv_debug_message("ocv_add_accuracy_tests(" ${ARGN} ")")
|
||||
|
||||
set(test_path "${CMAKE_CURRENT_LIST_DIR}/test")
|
||||
if(BUILD_TESTS AND EXISTS "${test_path}")
|
||||
__ocv_parse_test_sources(TEST ${ARGN})
|
||||
|
||||
# opencv_imgcodecs is required for imread/imwrite
|
||||
set(test_deps ${the_module} opencv_ts opencv_imgcodecs opencv_videoio ${OPENCV_TEST_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
|
||||
set(test_deps ${the_module} opencv_ts opencv_imgcodecs opencv_videoio ${OPENCV_MODULE_${the_module}_DEPS} ${OPENCV_MODULE_opencv_ts_DEPS})
|
||||
ocv_check_dependencies(${test_deps})
|
||||
|
||||
if(OCV_DEPENDENCIES_FOUND)
|
||||
set(the_target "opencv_test_${name}")
|
||||
# project(${the_target})
|
||||
|
||||
ocv_module_include_directories(${test_deps} "${test_path}")
|
||||
|
||||
if(NOT OPENCV_TEST_${the_module}_SOURCES)
|
||||
file(GLOB_RECURSE test_srcs "${test_path}/*.cpp")
|
||||
file(GLOB_RECURSE test_hdrs "${test_path}/*.hpp" "${test_path}/*.h")
|
||||
@ -775,10 +882,13 @@ function(ocv_add_accuracy_tests)
|
||||
set(OPENCV_TEST_${the_module}_SOURCES ${test_srcs} ${test_hdrs})
|
||||
endif()
|
||||
|
||||
get_native_precompiled_header(${the_target} test_precomp.hpp)
|
||||
add_executable(${the_target} ${OPENCV_TEST_${the_module}_SOURCES} ${${the_target}_pch})
|
||||
if(NOT BUILD_opencv_world)
|
||||
get_native_precompiled_header(${the_target} test_precomp.hpp)
|
||||
endif()
|
||||
|
||||
target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${test_deps} ${OPENCV_LINKER_LIBS})
|
||||
ocv_add_executable(${the_target} ${OPENCV_TEST_${the_module}_SOURCES} ${${the_target}_pch})
|
||||
ocv_target_include_modules(${the_target} ${test_deps} "${test_path}")
|
||||
ocv_target_link_libraries(${the_target} ${OPENCV_MODULE_${the_module}_DEPS} ${test_deps} ${OPENCV_LINKER_LIBS})
|
||||
add_dependencies(opencv_tests ${the_target})
|
||||
|
||||
# Additional target properties
|
||||
@ -795,7 +905,9 @@ function(ocv_add_accuracy_tests)
|
||||
get_target_property(LOC ${the_target} LOCATION)
|
||||
add_test(${the_target} "${LOC}")
|
||||
|
||||
ocv_add_precompiled_headers(${the_target})
|
||||
if(NOT BUILD_opencv_world)
|
||||
_ocv_add_precompiled_headers(${the_target})
|
||||
endif()
|
||||
else(OCV_DEPENDENCIES_FOUND)
|
||||
# TODO: warn about unsatisfied dependencies
|
||||
endif(OCV_DEPENDENCIES_FOUND)
|
||||
@ -807,6 +919,8 @@ function(ocv_add_accuracy_tests)
|
||||
endfunction()
|
||||
|
||||
function(ocv_add_samples)
|
||||
ocv_debug_message("ocv_add_samples(" ${ARGN} ")")
|
||||
|
||||
set(samples_path "${CMAKE_CURRENT_SOURCE_DIR}/samples")
|
||||
string(REGEX REPLACE "^opencv_" "" module_id ${the_module})
|
||||
|
||||
@ -816,15 +930,14 @@ function(ocv_add_samples)
|
||||
|
||||
if(OCV_DEPENDENCIES_FOUND)
|
||||
file(GLOB sample_sources "${samples_path}/*.cpp")
|
||||
ocv_include_modules(${OPENCV_MODULE_${the_module}_DEPS})
|
||||
|
||||
foreach(source ${sample_sources})
|
||||
get_filename_component(name "${source}" NAME_WE)
|
||||
set(the_target "example_${module_id}_${name}")
|
||||
|
||||
add_executable(${the_target} "${source}")
|
||||
target_link_libraries(${the_target} ${samples_deps})
|
||||
|
||||
ocv_add_executable(${the_target} "${source}")
|
||||
ocv_target_include_modules(${the_target} ${samples_deps})
|
||||
ocv_target_link_libraries(${the_target} ${samples_deps})
|
||||
set_target_properties(${the_target} PROPERTIES PROJECT_LABEL "(sample) ${name}")
|
||||
|
||||
if(ENABLE_SOLUTION_FOLDERS)
|
||||
@ -847,82 +960,3 @@ function(ocv_add_samples)
|
||||
PERMISSIONS OWNER_READ GROUP_READ WORLD_READ COMPONENT samples)
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
# internal macro; finds all link dependencies of the module
|
||||
# should be used at the end of CMake processing
|
||||
macro(__ocv_track_module_link_dependencies the_module optkind)
|
||||
set(${the_module}_MODULE_DEPS_${optkind} "")
|
||||
set(${the_module}_EXTRA_DEPS_${optkind} "")
|
||||
|
||||
get_target_property(__module_type ${the_module} TYPE)
|
||||
if(__module_type STREQUAL "STATIC_LIBRARY")
|
||||
#in case of static library we have to inherit its dependencies (in right order!!!)
|
||||
if(NOT DEFINED ${the_module}_LIB_DEPENDS_${optkind})
|
||||
ocv_split_libs_list(${the_module}_LIB_DEPENDS ${the_module}_LIB_DEPENDS_DBG ${the_module}_LIB_DEPENDS_OPT)
|
||||
endif()
|
||||
|
||||
set(__resolved_deps "")
|
||||
set(__mod_depends ${${the_module}_LIB_DEPENDS_${optkind}})
|
||||
set(__has_cycle FALSE)
|
||||
|
||||
while(__mod_depends)
|
||||
list(GET __mod_depends 0 __dep)
|
||||
list(REMOVE_AT __mod_depends 0)
|
||||
if(__dep STREQUAL the_module)
|
||||
set(__has_cycle TRUE)
|
||||
else()#if("${OPENCV_MODULES_BUILD}" MATCHES "(^|;)${__dep}(;|$)")
|
||||
ocv_regex_escape(__rdep "${__dep}")
|
||||
if(__resolved_deps MATCHES "(^|;)${__rdep}(;|$)")
|
||||
#all dependencies of this module are already resolved
|
||||
list(APPEND ${the_module}_MODULE_DEPS_${optkind} "${__dep}")
|
||||
else()
|
||||
get_target_property(__module_type ${__dep} TYPE)
|
||||
if(__module_type STREQUAL "STATIC_LIBRARY")
|
||||
if(NOT DEFINED ${__dep}_LIB_DEPENDS_${optkind})
|
||||
ocv_split_libs_list(${__dep}_LIB_DEPENDS ${__dep}_LIB_DEPENDS_DBG ${__dep}_LIB_DEPENDS_OPT)
|
||||
endif()
|
||||
list(INSERT __mod_depends 0 ${${__dep}_LIB_DEPENDS_${optkind}} ${__dep})
|
||||
list(APPEND __resolved_deps "${__dep}")
|
||||
elseif(NOT __module_type)
|
||||
list(APPEND ${the_module}_EXTRA_DEPS_${optkind} "${__dep}")
|
||||
endif()
|
||||
endif()
|
||||
#else()
|
||||
# get_target_property(__dep_location "${__dep}" LOCATION)
|
||||
endif()
|
||||
endwhile()
|
||||
|
||||
ocv_list_unique(${the_module}_MODULE_DEPS_${optkind})
|
||||
#ocv_list_reverse(${the_module}_MODULE_DEPS_${optkind})
|
||||
ocv_list_unique(${the_module}_EXTRA_DEPS_${optkind})
|
||||
#ocv_list_reverse(${the_module}_EXTRA_DEPS_${optkind})
|
||||
|
||||
if(__has_cycle)
|
||||
# not sure if it can work
|
||||
list(APPEND ${the_module}_MODULE_DEPS_${optkind} "${the_module}")
|
||||
endif()
|
||||
|
||||
unset(__dep_location)
|
||||
unset(__mod_depends)
|
||||
unset(__resolved_deps)
|
||||
unset(__has_cycle)
|
||||
unset(__rdep)
|
||||
endif()#STATIC_LIBRARY
|
||||
unset(__module_type)
|
||||
|
||||
#message("${the_module}_MODULE_DEPS_${optkind}")
|
||||
#message(" ${${the_module}_MODULE_DEPS_${optkind}}")
|
||||
#message(" ${OPENCV_MODULE_${the_module}_DEPS}")
|
||||
#message("")
|
||||
#message("${the_module}_EXTRA_DEPS_${optkind}")
|
||||
#message(" ${${the_module}_EXTRA_DEPS_${optkind}}")
|
||||
#message("")
|
||||
endmacro()
|
||||
|
||||
# creates lists of build dependencies needed for external projects
|
||||
macro(ocv_track_build_dependencies)
|
||||
foreach(m ${OPENCV_MODULES_BUILD})
|
||||
__ocv_track_module_link_dependencies("${m}" OPT)
|
||||
__ocv_track_module_link_dependencies("${m}" DBG)
|
||||
endforeach()
|
||||
endmacro()
|
||||
|
||||
@ -68,6 +68,15 @@ MACRO(_PCH_GET_COMPILE_FLAGS _out_compile_flags)
|
||||
endif()
|
||||
ENDFOREACH(item)
|
||||
|
||||
get_target_property(DIRINC ${_PCH_current_target} INCLUDE_DIRECTORIES )
|
||||
FOREACH(item ${DIRINC})
|
||||
if(item MATCHES "^${OpenCV_SOURCE_DIR}/modules/")
|
||||
LIST(APPEND ${_out_compile_flags} "${_PCH_include_prefix}\"${item}\"")
|
||||
else()
|
||||
LIST(APPEND ${_out_compile_flags} "${_PCH_isystem_prefix}\"${item}\"")
|
||||
endif()
|
||||
ENDFOREACH(item)
|
||||
|
||||
GET_DIRECTORY_PROPERTY(_directory_flags DEFINITIONS)
|
||||
GET_DIRECTORY_PROPERTY(_global_definitions DIRECTORY ${OpenCV_SOURCE_DIR} DEFINITIONS)
|
||||
#MESSAGE("_directory_flags ${_directory_flags} ${_global_definitions}" )
|
||||
@ -254,6 +263,9 @@ MACRO(ADD_PRECOMPILED_HEADER _targetName _input)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
get_target_property(DIRINC ${_targetName} INCLUDE_DIRECTORIES)
|
||||
set_target_properties(${_targetName}_pch_dephelp PROPERTIES INCLUDE_DIRECTORIES "${DIRINC}")
|
||||
|
||||
#MESSAGE("_compile_FLAGS: ${_compile_FLAGS}")
|
||||
#message("COMMAND ${CMAKE_CXX_COMPILER} ${_compile_FLAGS} -x c++-header -o ${_output} ${_input}")
|
||||
|
||||
|
||||
@ -42,6 +42,11 @@ macro(ocv_assert)
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
macro(ocv_debug_message)
|
||||
# string(REPLACE ";" " " __msg "${ARGN}")
|
||||
# message(STATUS "${__msg}")
|
||||
endmacro()
|
||||
|
||||
macro(ocv_check_environment_variables)
|
||||
foreach(_var ${ARGN})
|
||||
if(NOT DEFINED ${_var} AND DEFINED ENV{${_var}})
|
||||
@ -53,8 +58,18 @@ macro(ocv_check_environment_variables)
|
||||
endforeach()
|
||||
endmacro()
|
||||
|
||||
# rename modules target to world if needed
|
||||
macro(_ocv_fix_target target_var)
|
||||
if(BUILD_opencv_world)
|
||||
if(OPENCV_MODULE_${${target_var}}_IS_PART_OF_WORLD)
|
||||
set(${target_var} opencv_world)
|
||||
endif()
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
# adds include directories in such way that directories from the OpenCV source tree go first
|
||||
function(ocv_include_directories)
|
||||
ocv_debug_message("ocv_include_directories( ${ARGN} )")
|
||||
set(__add_before "")
|
||||
foreach(dir ${ARGN})
|
||||
get_filename_component(__abs_dir "${dir}" ABSOLUTE)
|
||||
@ -67,6 +82,30 @@ function(ocv_include_directories)
|
||||
include_directories(BEFORE ${__add_before})
|
||||
endfunction()
|
||||
|
||||
# adds include directories in such way that directories from the OpenCV source tree go first
|
||||
function(ocv_target_include_directories target)
|
||||
_ocv_fix_target(target)
|
||||
set(__params "")
|
||||
foreach(dir ${ARGN})
|
||||
get_filename_component(__abs_dir "${dir}" ABSOLUTE)
|
||||
if("${__abs_dir}" MATCHES "^${OpenCV_SOURCE_DIR}" OR "${__abs_dir}" MATCHES "^${OpenCV_BINARY_DIR}")
|
||||
list(APPEND __params "${__abs_dir}")
|
||||
else()
|
||||
list(APPEND __params "${dir}")
|
||||
endif()
|
||||
endforeach()
|
||||
if(CMAKE_VERSION VERSION_LESS 2.8.11)
|
||||
include_directories(${__params})
|
||||
else()
|
||||
if(TARGET ${target})
|
||||
target_include_directories(${target} PRIVATE ${__params})
|
||||
else()
|
||||
set(__new_inc "${OCV_TARGET_INCLUDE_DIRS_${target}};${__params}")
|
||||
set(OCV_TARGET_INCLUDE_DIRS_${target} "${__new_inc}" CACHE INTERNAL "")
|
||||
endif()
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
# clears all passed variables
|
||||
macro(ocv_clear_vars)
|
||||
foreach(_var ${ARGN})
|
||||
@ -295,8 +334,8 @@ endfunction()
|
||||
|
||||
macro(ocv_finalize_status)
|
||||
if(NOT OPENCV_SKIP_STATUS_FINALIZATION)
|
||||
if(TARGET opencv_core)
|
||||
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${OPENCV_BUILD_INFO_FILE}" "${opencv_core_BINARY_DIR}/version_string.inc" OUTPUT_QUIET)
|
||||
if(DEFINED OPENCV_MODULE_opencv_core_BINARY_DIR)
|
||||
execute_process(COMMAND ${CMAKE_COMMAND} -E copy_if_different "${OPENCV_BUILD_INFO_FILE}" "${OPENCV_MODULE_opencv_core_BINARY_DIR}/version_string.inc" OUTPUT_QUIET)
|
||||
endif()
|
||||
endif()
|
||||
endmacro()
|
||||
@ -533,16 +572,20 @@ function(ocv_install_target)
|
||||
|
||||
# message(STATUS "Process ${__target} dst=${__dst}...")
|
||||
if(DEFINED __dst)
|
||||
get_target_property(fname ${__target} LOCATION_DEBUG)
|
||||
if(fname MATCHES "\\.lib$")
|
||||
string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
|
||||
install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Debug)
|
||||
endif()
|
||||
if(CMAKE_VERSION VERSION_LESS 2.8.12)
|
||||
get_target_property(fname ${__target} LOCATION_DEBUG)
|
||||
if(fname MATCHES "\\.lib$")
|
||||
string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
|
||||
install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Debug)
|
||||
endif()
|
||||
|
||||
get_target_property(fname ${__target} LOCATION_RELEASE)
|
||||
if(fname MATCHES "\\.lib$")
|
||||
string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
|
||||
install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Release)
|
||||
get_target_property(fname ${__target} LOCATION_RELEASE)
|
||||
if(fname MATCHES "\\.lib$")
|
||||
string(REGEX REPLACE "\\.lib$" ".pdb" fname "${fname}")
|
||||
install(FILES ${fname} DESTINATION ${__dst} CONFIGURATIONS Release)
|
||||
endif()
|
||||
else()
|
||||
# CMake 2.8.12 brokes PDB support in STATIC libraries for MSVS
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
@ -637,6 +680,9 @@ endmacro()
|
||||
################################################################################################
|
||||
# short command to setup source group
|
||||
function(ocv_source_group group)
|
||||
if(BUILD_opencv_world AND OPENCV_MODULE_${the_module}_IS_PART_OF_WORLD)
|
||||
set(group "${the_module}\\${group}")
|
||||
endif()
|
||||
cmake_parse_arguments(SG "" "DIRBASE" "GLOB;GLOB_RECURSE;FILES" ${ARGN})
|
||||
set(files "")
|
||||
if(SG_FILES)
|
||||
@ -669,3 +715,39 @@ function(ocv_source_group group)
|
||||
source_group(${group} FILES ${files})
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
function(ocv_target_link_libraries target)
|
||||
_ocv_fix_target(target)
|
||||
set(LINK_DEPS ${ARGN})
|
||||
# process world
|
||||
if(BUILD_opencv_world)
|
||||
foreach(m ${OPENCV_MODULES_BUILD})
|
||||
if(OPENCV_MODULE_${m}_IS_PART_OF_WORLD)
|
||||
if(";${LINK_DEPS};" MATCHES ";${m};")
|
||||
list(REMOVE_ITEM LINK_DEPS ${m})
|
||||
if(NOT (";${LINK_DEPS};" MATCHES ";opencv_world;"))
|
||||
list(APPEND LINK_DEPS opencv_world)
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
endforeach()
|
||||
endif()
|
||||
target_link_libraries(${target} ${LINK_DEPS})
|
||||
endfunction()
|
||||
|
||||
function(_ocv_append_target_includes target)
|
||||
if(DEFINED OCV_TARGET_INCLUDE_DIRS_${target})
|
||||
target_include_directories(${target} PRIVATE ${OCV_TARGET_INCLUDE_DIRS_${target}})
|
||||
unset(OCV_TARGET_INCLUDE_DIRS_${target} CACHE)
|
||||
endif()
|
||||
endfunction()
|
||||
|
||||
function(ocv_add_executable target)
|
||||
add_executable(${target} ${ARGN})
|
||||
_ocv_append_target_includes(${target})
|
||||
endfunction()
|
||||
|
||||
function(ocv_add_library target)
|
||||
add_library(${target} ${ARGN})
|
||||
_ocv_append_target_includes(${target})
|
||||
endfunction()
|
||||
@ -141,6 +141,7 @@ SET(OpenCV_VERSION_STATUS "@OPENCV_VERSION_STATUS@")
|
||||
# ====================================================================
|
||||
|
||||
SET(OpenCV_LIB_COMPONENTS @OPENCV_MODULES_CONFIGCMAKE@)
|
||||
SET(OpenCV_WORLD_COMPONENTS @OPENCV_WORLD_MODULES@)
|
||||
|
||||
# ==============================================================
|
||||
# Extra include directories, needed by OpenCV 2 new structure
|
||||
@ -200,8 +201,8 @@ foreach(__cvcomponent ${OpenCV_FIND_COMPONENTS})
|
||||
message(WARNING "${__cvcomponent} is required but was not found")
|
||||
endif()
|
||||
#indicate that module is NOT found
|
||||
string(TOUPPER "${__cvcomponent}" __cvcomponent)
|
||||
set(${__cvcomponent}_FOUND "${__cvcomponent}_FOUND-NOTFOUND")
|
||||
string(TOUPPER "${__cvcomponent}" __cvcomponentUP)
|
||||
set(${__cvcomponentUP}_FOUND "${__cvcomponentUP}_FOUND-NOTFOUND")
|
||||
else()
|
||||
list(APPEND OpenCV_FIND_COMPONENTS_ ${__cvcomponent})
|
||||
# Not using list(APPEND) here, because OpenCV_LIBS may not exist yet.
|
||||
@ -209,8 +210,31 @@ foreach(__cvcomponent ${OpenCV_FIND_COMPONENTS})
|
||||
# to find_package(OpenCV) with different component lists add up.
|
||||
set(OpenCV_LIBS ${OpenCV_LIBS} "${__cvcomponent}")
|
||||
#indicate that module is found
|
||||
string(TOUPPER "${__cvcomponent}" __cvcomponent)
|
||||
set(${__cvcomponent}_FOUND 1)
|
||||
string(TOUPPER "${__cvcomponent}" __cvcomponentUP)
|
||||
set(${__cvcomponentUP}_FOUND 1)
|
||||
endif()
|
||||
if(OpenCV_SHARED AND ";${OpenCV_WORLD_COMPONENTS};" MATCHES ";${__cvcomponent};" AND NOT TARGET ${__cvcomponent})
|
||||
get_target_property(__implib_dbg opencv_world IMPORTED_IMPLIB_DEBUG)
|
||||
get_target_property(__implib_release opencv_world IMPORTED_IMPLIB_RELEASE)
|
||||
get_target_property(__location_dbg opencv_world IMPORTED_LOCATION_DEBUG)
|
||||
get_target_property(__location_release opencv_world IMPORTED_LOCATION_RELEASE)
|
||||
add_library(${__cvcomponent} SHARED IMPORTED)
|
||||
if(__location_dbg)
|
||||
set_property(TARGET ${__cvcomponent} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
|
||||
set_target_properties(${__cvcomponent} PROPERTIES
|
||||
IMPORTED_IMPLIB_DEBUG "${__implib_dbg}"
|
||||
IMPORTED_LINK_INTERFACE_LIBRARIES_DEBUG ""
|
||||
IMPORTED_LOCATION_DEBUG "${__location_dbg}"
|
||||
)
|
||||
endif()
|
||||
if(__location_release)
|
||||
set_property(TARGET ${__cvcomponent} APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
|
||||
set_target_properties(${__cvcomponent} PROPERTIES
|
||||
IMPORTED_IMPLIB_RELEASE "${__implib_release}"
|
||||
IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE ""
|
||||
IMPORTED_LOCATION_RELEASE "${__location_release}"
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
endforeach()
|
||||
set(OpenCV_FIND_COMPONENTS ${OpenCV_FIND_COMPONENTS_})
|
||||
@ -321,6 +345,7 @@ macro(ocv_check_dependencies)
|
||||
set(OCV_DEPENDENCIES_FOUND TRUE)
|
||||
foreach(d ${ARGN})
|
||||
if(NOT TARGET ${d})
|
||||
message(WARNING "OpenCV: Can't resolve dependency: ${d}")
|
||||
set(OCV_DEPENDENCIES_FOUND FALSE)
|
||||
break()
|
||||
endif()
|
||||
@ -346,6 +371,10 @@ macro(ocv_include_modules)
|
||||
include_directories(BEFORE "${OpenCV_INCLUDE_DIRS}")
|
||||
endmacro()
|
||||
|
||||
macro(ocv_target_link_libraries)
|
||||
target_link_libraries(${ARGN})
|
||||
endmacro()
|
||||
|
||||
# remove all matching elements from the list
|
||||
macro(ocv_list_filterout lst regex)
|
||||
foreach(item ${${lst}})
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -105,8 +105,8 @@ if(BUILD_DOCS AND HAVE_SPHINX)
|
||||
COMMAND ${SPHINX_BUILD} ${BUILD_PLANTUML} -b latex -c "${CMAKE_CURRENT_SOURCE_DIR}" "${DOC_FAKE_ROOT}" .
|
||||
COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/pics ${CMAKE_CURRENT_BINARY_DIR}/doc/opencv1/pics
|
||||
COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/mymath.sty ${CMAKE_CURRENT_BINARY_DIR}
|
||||
COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2refman.tex
|
||||
COMMAND ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2manager.tex
|
||||
COMMAND ${PYTHON_DEFAULT_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2refman.tex
|
||||
COMMAND ${PYTHON_DEFAULT_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/patch_refman_latex.py" opencv2manager.tex
|
||||
COMMAND ${CMAKE_COMMAND} -E echo "Generating opencv2refman.pdf"
|
||||
COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv2refman.tex
|
||||
COMMAND ${PDFLATEX_COMPILER} -interaction=batchmode opencv2refman.tex
|
||||
|
||||
@ -4,4 +4,4 @@ if(NOT OPENCV_MODULES_PATH)
|
||||
set(OPENCV_MODULES_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
|
||||
endif()
|
||||
|
||||
ocv_glob_modules(${OPENCV_MODULES_PATH} ${OPENCV_EXTRA_MODULES_PATH})
|
||||
ocv_glob_modules(${OPENCV_MODULES_PATH} EXTRA ${OPENCV_EXTRA_MODULES_PATH})
|
||||
|
||||
@ -46,7 +46,7 @@ ADD_LIBRARY(${the_target} SHARED camera_wrapper.h camera_wrapper.cpp)
|
||||
string(REGEX REPLACE "[.]" "_" LIBRARY_DEF ${ANDROID_VERSION})
|
||||
add_definitions(-DANDROID_r${LIBRARY_DEF})
|
||||
|
||||
target_link_libraries(${the_target} c m dl utils camera_client binder log)
|
||||
ocv_target_link_libraries(${the_target} c m dl utils camera_client binder log)
|
||||
|
||||
if(NOT ANDROID_VERSION VERSION_LESS "3.0.0")
|
||||
target_link_libraries(${the_target} gui )
|
||||
|
||||
@ -760,6 +760,27 @@ They are
|
||||
:math:`[R_2, -t]`.
|
||||
By decomposing ``E``, you can only get the direction of the translation, so the function returns unit ``t``.
|
||||
|
||||
decomposeHomographyMat
|
||||
--------------------------
|
||||
Decompose a homography matrix to rotation(s), translation(s) and plane normal(s).
|
||||
|
||||
.. ocv:function:: int decomposeHomographyMat( InputArray H, InputArray K, OutputArrayOfArrays rotations, OutputArrayOfArrays translations, OutputArrayOfArrays normals)
|
||||
|
||||
:param H: The input homography matrix between two images.
|
||||
|
||||
:param K: The input intrinsic camera calibration matrix.
|
||||
|
||||
:param rotations: Array of rotation matrices.
|
||||
|
||||
:param translations: Array of translation matrices.
|
||||
|
||||
:param normals: Array of plane normal matrices.
|
||||
|
||||
This function extracts relative camera motion between two views observing a planar object from the homography ``H`` induced by the plane.
|
||||
The intrinsic camera matrix ``K`` must also be provided. The function may return up to four mathematical solution sets. At least two of the
|
||||
solutions may further be invalidated if point correspondences are available by applying positive depth constraint (all points must be in front of the camera).
|
||||
The decomposition method is described in detail in [Malis]_.
|
||||
|
||||
|
||||
recoverPose
|
||||
---------------
|
||||
@ -1876,3 +1897,5 @@ Performs stereo calibration
|
||||
.. [Slabaugh] Slabaugh, G.G. Computing Euler angles from a rotation matrix. http://www.soi.city.ac.uk/~sbbh653/publications/euler.pdf (verified: 2013-04-15)
|
||||
|
||||
.. [Zhang2000] Z. Zhang. A Flexible New Technique for Camera Calibration. IEEE Transactions on Pattern Analysis and Machine Intelligence, 22(11):1330-1334, 2000.
|
||||
|
||||
.. [Malis] Malis, E. and Vargas, M. Deeper understanding of the homography decomposition for vision-based control, Research Report 6303, INRIA (2007)
|
||||
|
||||
@ -315,6 +315,11 @@ CV_EXPORTS_W int estimateAffine3D(InputArray src, InputArray dst,
|
||||
double ransacThreshold = 3, double confidence = 0.99);
|
||||
|
||||
|
||||
CV_EXPORTS_W int decomposeHomographyMat(InputArray H,
|
||||
InputArray K,
|
||||
OutputArrayOfArrays rotations,
|
||||
OutputArrayOfArrays translations,
|
||||
OutputArrayOfArrays normals);
|
||||
|
||||
class CV_EXPORTS_W StereoMatcher : public Algorithm
|
||||
{
|
||||
|
||||
@ -40,7 +40,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -40,6 +40,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "circlesgrid.hpp"
|
||||
#include <limits>
|
||||
//#define DEBUG_CIRCLES
|
||||
|
||||
482
modules/calib3d/src/homography_decomp.cpp
Normal file
482
modules/calib3d/src/homography_decomp.cpp
Normal file
@ -0,0 +1,482 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// This is a homography decomposition implementation contributed to OpenCV
|
||||
// by Samson Yilma. It implements the homography decomposition algorithm
|
||||
// descriped in the research report:
|
||||
// Malis, E and Vargas, M, "Deeper understanding of the homography decomposition
|
||||
// for vision-based control", Research Report 6303, INRIA (2007)
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2014, Samson Yilma¸ (samson_yilma@yahoo.com), all rights reserved.
|
||||
//
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include <memory>
|
||||
|
||||
namespace cv
|
||||
{
|
||||
|
||||
namespace HomographyDecomposition
|
||||
{
|
||||
|
||||
//struct to hold solutions of homography decomposition
|
||||
typedef struct _CameraMotion {
|
||||
cv::Matx33d R; //!< rotation matrix
|
||||
cv::Vec3d n; //!< normal of the plane the camera is looking at
|
||||
cv::Vec3d t; //!< translation vector
|
||||
} CameraMotion;
|
||||
|
||||
inline int signd(const double x)
|
||||
{
|
||||
return ( x >= 0 ? 1 : -1 );
|
||||
}
|
||||
|
||||
class HomographyDecomp {
|
||||
|
||||
public:
|
||||
HomographyDecomp() {}
|
||||
virtual ~HomographyDecomp() {}
|
||||
virtual void decomposeHomography(const cv::Matx33d& H, const cv::Matx33d& K,
|
||||
std::vector<CameraMotion>& camMotions);
|
||||
bool isRotationValid(const cv::Matx33d& R, const double epsilon=0.01);
|
||||
|
||||
protected:
|
||||
bool passesSameSideOfPlaneConstraint(CameraMotion& motion);
|
||||
virtual void decompose(std::vector<CameraMotion>& camMotions) = 0;
|
||||
const cv::Matx33d& getHnorm() const {
|
||||
return _Hnorm;
|
||||
}
|
||||
|
||||
private:
|
||||
cv::Matx33d normalize(const cv::Matx33d& H, const cv::Matx33d& K);
|
||||
void removeScale();
|
||||
cv::Matx33d _Hnorm;
|
||||
};
|
||||
|
||||
class HomographyDecompZhang : public HomographyDecomp {
|
||||
|
||||
public:
|
||||
HomographyDecompZhang():HomographyDecomp() {}
|
||||
virtual ~HomographyDecompZhang() {}
|
||||
|
||||
private:
|
||||
virtual void decompose(std::vector<CameraMotion>& camMotions);
|
||||
bool findMotionFrom_tstar_n(const cv::Vec3d& tstar, const cv::Vec3d& n, CameraMotion& motion);
|
||||
};
|
||||
|
||||
class HomographyDecompInria : public HomographyDecomp {
|
||||
|
||||
public:
|
||||
HomographyDecompInria():HomographyDecomp() {}
|
||||
virtual ~HomographyDecompInria() {}
|
||||
|
||||
private:
|
||||
virtual void decompose(std::vector<CameraMotion>& camMotions);
|
||||
double oppositeOfMinor(const cv::Matx33d& M, const int row, const int col);
|
||||
void findRmatFrom_tstar_n(const cv::Vec3d& tstar, const cv::Vec3d& n, const double v, cv::Matx33d& R);
|
||||
};
|
||||
|
||||
// normalizes homography with intrinsic camera parameters
|
||||
Matx33d HomographyDecomp::normalize(const Matx33d& H, const Matx33d& K)
|
||||
{
|
||||
return K.inv() * H * K;
|
||||
}
|
||||
|
||||
void HomographyDecomp::removeScale()
|
||||
{
|
||||
Mat W;
|
||||
SVD::compute(_Hnorm, W);
|
||||
_Hnorm = _Hnorm * (1.0/W.at<double>(1));
|
||||
}
|
||||
|
||||
/*! This checks that the input is a pure rotation matrix 'm'.
|
||||
* The conditions for this are: R' * R = I and det(R) = 1 (proper rotation matrix)
|
||||
*/
|
||||
bool HomographyDecomp::isRotationValid(const Matx33d& R, const double epsilon)
|
||||
{
|
||||
Matx33d RtR = R.t() * R;
|
||||
Matx33d I(1,0,0, 0,1,0, 0,0,1);
|
||||
if (norm(RtR, I, NORM_INF) > epsilon)
|
||||
return false;
|
||||
return (fabs(determinant(R) - 1.0) < epsilon);
|
||||
}
|
||||
|
||||
bool HomographyDecomp::passesSameSideOfPlaneConstraint(CameraMotion& motion)
|
||||
{
|
||||
typedef Matx<double, 1, 1> Matx11d;
|
||||
Matx31d t = Matx31d(motion.t);
|
||||
Matx31d n = Matx31d(motion.n);
|
||||
Matx11d proj = n.t() * motion.R.t() * t;
|
||||
if ( (1 + proj(0, 0) ) <= 0 )
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
//!main routine to decompose homography
|
||||
void HomographyDecomp::decomposeHomography(const Matx33d& H, const cv::Matx33d& K,
|
||||
std::vector<CameraMotion>& camMotions)
|
||||
{
|
||||
//normalize homography matrix with intrinsic camera matrix
|
||||
_Hnorm = normalize(H, K);
|
||||
//remove scale of the normalized homography
|
||||
removeScale();
|
||||
//apply decomposition
|
||||
decompose(camMotions);
|
||||
}
|
||||
|
||||
/* function computes R&t from tstar, and plane normal(n) using
|
||||
R = H * inv(I + tstar*transpose(n) );
|
||||
t = R * tstar;
|
||||
returns true if computed R&t is a valid solution
|
||||
*/
|
||||
bool HomographyDecompZhang::findMotionFrom_tstar_n(const cv::Vec3d& tstar, const cv::Vec3d& n, CameraMotion& motion)
|
||||
{
|
||||
Matx31d tstar_m = Mat(tstar);
|
||||
Matx31d n_m = Mat(n);
|
||||
Matx33d temp = tstar_m * n_m.t();
|
||||
temp(0, 0) += 1.0;
|
||||
temp(1, 1) += 1.0;
|
||||
temp(2, 2) += 1.0;
|
||||
motion.R = getHnorm() * temp.inv();
|
||||
motion.t = motion.R * tstar;
|
||||
motion.n = n;
|
||||
return passesSameSideOfPlaneConstraint(motion);
|
||||
}
|
||||
|
||||
void HomographyDecompZhang::decompose(std::vector<CameraMotion>& camMotions)
|
||||
{
|
||||
Mat W, U, Vt;
|
||||
SVD::compute(getHnorm(), W, U, Vt);
|
||||
double lambda1=W.at<double>(0);
|
||||
double lambda3=W.at<double>(2);
|
||||
double lambda1m3 = (lambda1-lambda3);
|
||||
double lambda1m3_2 = lambda1m3*lambda1m3;
|
||||
double lambda1t3 = lambda1*lambda3;
|
||||
|
||||
double t1 = 1.0/(2.0*lambda1t3);
|
||||
double t2 = sqrt(1.0+4.0*lambda1t3/lambda1m3_2);
|
||||
double t12 = t1*t2;
|
||||
|
||||
double e1 = -t1 + t12; //t1*(-1.0f + t2 );
|
||||
double e3 = -t1 - t12; //t1*(-1.0f - t2);
|
||||
double e1_2 = e1*e1;
|
||||
double e3_2 = e3*e3;
|
||||
|
||||
double nv1p = sqrt(e1_2*lambda1m3_2 + 2*e1*(lambda1t3-1) + 1.0);
|
||||
double nv3p = sqrt(e3_2*lambda1m3_2 + 2*e3*(lambda1t3-1) + 1.0);
|
||||
double v1p[3], v3p[3];
|
||||
|
||||
v1p[0]=Vt.at<double>(0)*nv1p, v1p[1]=Vt.at<double>(1)*nv1p, v1p[2]=Vt.at<double>(2)*nv1p;
|
||||
v3p[0]=Vt.at<double>(6)*nv3p, v3p[1]=Vt.at<double>(7)*nv3p, v3p[2]=Vt.at<double>(8)*nv3p;
|
||||
|
||||
/*The eight solutions are
|
||||
(A): tstar = +- (v1p - v3p)/(e1 -e3), n = +- (e1*v3p - e3*v1p)/(e1-e3)
|
||||
(B): tstar = +- (v1p + v3p)/(e1 -e3), n = +- (e1*v3p + e3*v1p)/(e1-e3)
|
||||
*/
|
||||
double v1pmv3p[3], v1ppv3p[3];
|
||||
double e1v3me3v1[3], e1v3pe3v1[3];
|
||||
double inv_e1me3 = 1.0/(e1-e3);
|
||||
|
||||
for(int kk=0;kk<3;++kk){
|
||||
v1pmv3p[kk] = v1p[kk]-v3p[kk];
|
||||
v1ppv3p[kk] = v1p[kk]+v3p[kk];
|
||||
}
|
||||
|
||||
for(int kk=0; kk<3; ++kk){
|
||||
double e1v3 = e1*v3p[kk];
|
||||
double e3v1=e3*v1p[kk];
|
||||
e1v3me3v1[kk] = e1v3-e3v1;
|
||||
e1v3pe3v1[kk] = e1v3+e3v1;
|
||||
}
|
||||
|
||||
Vec3d tstar_p, tstar_n;
|
||||
Vec3d n_p, n_n;
|
||||
|
||||
///Solution group A
|
||||
for(int kk=0; kk<3; ++kk) {
|
||||
tstar_p[kk] = v1pmv3p[kk]*inv_e1me3;
|
||||
tstar_n[kk] = -tstar_p[kk];
|
||||
n_p[kk] = e1v3me3v1[kk]*inv_e1me3;
|
||||
n_n[kk] = -n_p[kk];
|
||||
}
|
||||
|
||||
CameraMotion cmotion;
|
||||
//(A) Four different combinations for solution A
|
||||
// (i) (+, +)
|
||||
if (findMotionFrom_tstar_n(tstar_p, n_p, cmotion))
|
||||
camMotions.push_back(cmotion);
|
||||
|
||||
// (ii) (+, -)
|
||||
if (findMotionFrom_tstar_n(tstar_p, n_n, cmotion))
|
||||
camMotions.push_back(cmotion);
|
||||
|
||||
// (iii) (-, +)
|
||||
if (findMotionFrom_tstar_n(tstar_n, n_p, cmotion))
|
||||
camMotions.push_back(cmotion);
|
||||
|
||||
// (iv) (-, -)
|
||||
if (findMotionFrom_tstar_n(tstar_n, n_n, cmotion))
|
||||
camMotions.push_back(cmotion);
|
||||
//////////////////////////////////////////////////////////////////
|
||||
///Solution group B
|
||||
for(int kk=0;kk<3;++kk){
|
||||
tstar_p[kk] = v1ppv3p[kk]*inv_e1me3;
|
||||
tstar_n[kk] = -tstar_p[kk];
|
||||
n_p[kk] = e1v3pe3v1[kk]*inv_e1me3;
|
||||
n_n[kk] = -n_p[kk];
|
||||
}
|
||||
|
||||
//(B) Four different combinations for solution B
|
||||
// (i) (+, +)
|
||||
if (findMotionFrom_tstar_n(tstar_p, n_p, cmotion))
|
||||
camMotions.push_back(cmotion);
|
||||
|
||||
// (ii) (+, -)
|
||||
if (findMotionFrom_tstar_n(tstar_p, n_n, cmotion))
|
||||
camMotions.push_back(cmotion);
|
||||
|
||||
// (iii) (-, +)
|
||||
if (findMotionFrom_tstar_n(tstar_n, n_p, cmotion))
|
||||
camMotions.push_back(cmotion);
|
||||
|
||||
// (iv) (-, -)
|
||||
if (findMotionFrom_tstar_n(tstar_n, n_n, cmotion))
|
||||
camMotions.push_back(cmotion);
|
||||
}
|
||||
|
||||
double HomographyDecompInria::oppositeOfMinor(const Matx33d& M, const int row, const int col)
|
||||
{
|
||||
int x1 = col == 0 ? 1 : 0;
|
||||
int x2 = col == 2 ? 1 : 2;
|
||||
int y1 = row == 0 ? 1 : 0;
|
||||
int y2 = row == 2 ? 1 : 2;
|
||||
|
||||
return (M(y1, x2) * M(y2, x1) - M(y1, x1) * M(y2, x2));
|
||||
}
|
||||
|
||||
//computes R = H( I - (2/v)*te_star*ne_t )
|
||||
void HomographyDecompInria::findRmatFrom_tstar_n(const cv::Vec3d& tstar, const cv::Vec3d& n, const double v, cv::Matx33d& R)
|
||||
{
|
||||
Matx31d tstar_m = Matx31d(tstar);
|
||||
Matx31d n_m = Matx31d(n);
|
||||
Matx33d I(1.0, 0.0, 0.0,
|
||||
0.0, 1.0, 0.0,
|
||||
0.0, 0.0, 1.0);
|
||||
|
||||
R = getHnorm() * (I - (2/v) * tstar_m * n_m.t() );
|
||||
}
|
||||
|
||||
void HomographyDecompInria::decompose(std::vector<CameraMotion>& camMotions)
|
||||
{
|
||||
const double epsilon = 0.001;
|
||||
Matx33d S;
|
||||
|
||||
//S = H'H - I
|
||||
S = getHnorm().t() * getHnorm();
|
||||
S(0, 0) -= 1.0;
|
||||
S(1, 1) -= 1.0;
|
||||
S(2, 2) -= 1.0;
|
||||
|
||||
//check if H is rotation matrix
|
||||
if( norm(S, NORM_INF) < epsilon) {
|
||||
CameraMotion motion;
|
||||
motion.R = Matx33d(getHnorm());
|
||||
motion.t = Vec3d(0, 0, 0);
|
||||
motion.n = Vec3d(0, 0, 0);
|
||||
camMotions.push_back(motion);
|
||||
return;
|
||||
}
|
||||
|
||||
//! Compute nvectors
|
||||
Vec3d npa, npb;
|
||||
|
||||
double M00 = oppositeOfMinor(S, 0, 0);
|
||||
double M11 = oppositeOfMinor(S, 1, 1);
|
||||
double M22 = oppositeOfMinor(S, 2, 2);
|
||||
|
||||
double rtM00 = sqrt(M00);
|
||||
double rtM11 = sqrt(M11);
|
||||
double rtM22 = sqrt(M22);
|
||||
|
||||
double M01 = oppositeOfMinor(S, 0, 1);
|
||||
double M12 = oppositeOfMinor(S, 1, 2);
|
||||
double M02 = oppositeOfMinor(S, 0, 2);
|
||||
|
||||
int e12 = signd(M12);
|
||||
int e02 = signd(M02);
|
||||
int e01 = signd(M01);
|
||||
|
||||
double nS00 = abs(S(0, 0));
|
||||
double nS11 = abs(S(1, 1));
|
||||
double nS22 = abs(S(2, 2));
|
||||
|
||||
//find max( |Sii| ), i=0, 1, 2
|
||||
int indx = 0;
|
||||
if(nS00 < nS11){
|
||||
indx = 1;
|
||||
if( nS11 < nS22 )
|
||||
indx = 2;
|
||||
}
|
||||
else {
|
||||
if(nS00 < nS22 )
|
||||
indx = 2;
|
||||
}
|
||||
|
||||
switch (indx) {
|
||||
case 0:
|
||||
npa[0] = S(0, 0), npb[0] = S(0, 0);
|
||||
npa[1] = S(0, 1) + rtM22, npb[1] = S(0, 1) - rtM22;
|
||||
npa[2] = S(0, 2) + e12 * rtM11, npb[2] = S(0, 2) - e12 * rtM11;
|
||||
break;
|
||||
case 1:
|
||||
npa[0] = S(0, 1) + rtM22, npb[0] = S(0, 1) - rtM22;
|
||||
npa[1] = S(1, 1), npb[1] = S(1, 1);
|
||||
npa[2] = S(1, 2) - e02 * rtM00, npb[2] = S(1, 2) + e02 * rtM00;
|
||||
break;
|
||||
case 2:
|
||||
npa[0] = S(0, 2) + e01 * rtM11, npb[0] = S(0, 2) - e01 * rtM11;
|
||||
npa[1] = S(1, 2) + rtM00, npb[1] = S(1, 2) - rtM00;
|
||||
npa[2] = S(2, 2), npb[2] = S(2, 2);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
double traceS = S(0, 0) + S(1, 1) + S(2, 2);
|
||||
double v = 2.0 * sqrt(1 + traceS - M00 - M11 - M22);
|
||||
|
||||
double ESii = signd(S(indx, indx)) ;
|
||||
double r_2 = 2 + traceS + v;
|
||||
double nt_2 = 2 + traceS - v;
|
||||
|
||||
double r = sqrt(r_2);
|
||||
double n_t = sqrt(nt_2);
|
||||
|
||||
Vec3d na = npa / norm(npa);
|
||||
Vec3d nb = npb / norm(npb);
|
||||
|
||||
double half_nt = 0.5 * n_t;
|
||||
double esii_t_r = ESii * r;
|
||||
|
||||
Vec3d ta_star = half_nt * (esii_t_r * nb - n_t * na);
|
||||
Vec3d tb_star = half_nt * (esii_t_r * na - n_t * nb);
|
||||
|
||||
camMotions.resize(4);
|
||||
|
||||
Matx33d Ra, Rb;
|
||||
Vec3d ta, tb;
|
||||
|
||||
//Ra, ta, na
|
||||
findRmatFrom_tstar_n(ta_star, na, v, Ra);
|
||||
ta = Ra * ta_star;
|
||||
|
||||
camMotions[0].R = Ra;
|
||||
camMotions[0].t = ta;
|
||||
camMotions[0].n = na;
|
||||
|
||||
//Ra, -ta, -na
|
||||
camMotions[1].R = Ra;
|
||||
camMotions[1].t = -ta;
|
||||
camMotions[1].n = -na;
|
||||
|
||||
//Rb, tb, nb
|
||||
findRmatFrom_tstar_n(tb_star, nb, v, Rb);
|
||||
tb = Rb * tb_star;
|
||||
|
||||
camMotions[2].R = Rb;
|
||||
camMotions[2].t = tb;
|
||||
camMotions[2].n = nb;
|
||||
|
||||
//Rb, -tb, -nb
|
||||
camMotions[3].R = Rb;
|
||||
camMotions[3].t = -tb;
|
||||
camMotions[3].n = -nb;
|
||||
}
|
||||
|
||||
} //namespace HomographyDecomposition
|
||||
|
||||
// function decomposes image-to-image homography to rotation and translation matrices
|
||||
int decomposeHomographyMat(InputArray _H,
|
||||
InputArray _K,
|
||||
OutputArrayOfArrays _rotations,
|
||||
OutputArrayOfArrays _translations,
|
||||
OutputArrayOfArrays _normals)
|
||||
{
|
||||
using namespace std;
|
||||
using namespace HomographyDecomposition;
|
||||
|
||||
Mat H = _H.getMat().reshape(1, 3);
|
||||
CV_Assert(H.cols == 3 && H.rows == 3);
|
||||
|
||||
Mat K = _K.getMat().reshape(1, 3);
|
||||
CV_Assert(K.cols == 3 && K.rows == 3);
|
||||
|
||||
auto_ptr<HomographyDecomp> hdecomp(new HomographyDecompInria);
|
||||
|
||||
vector<CameraMotion> motions;
|
||||
hdecomp->decomposeHomography(H, K, motions);
|
||||
|
||||
int nsols = static_cast<int>(motions.size());
|
||||
int depth = CV_64F; //double precision matrices used in CameraMotion struct
|
||||
|
||||
if (_rotations.needed()) {
|
||||
_rotations.create(nsols, 1, depth);
|
||||
for (int k = 0; k < nsols; ++k ) {
|
||||
_rotations.getMatRef(k) = Mat(motions[k].R);
|
||||
}
|
||||
}
|
||||
|
||||
if (_translations.needed()) {
|
||||
_translations.create(nsols, 1, depth);
|
||||
for (int k = 0; k < nsols; ++k ) {
|
||||
_translations.getMatRef(k) = Mat(motions[k].t);
|
||||
}
|
||||
}
|
||||
|
||||
if (_normals.needed()) {
|
||||
_normals.create(nsols, 1, depth);
|
||||
for (int k = 0; k < nsols; ++k ) {
|
||||
_normals.getMatRef(k) = Mat(motions[k].n);
|
||||
}
|
||||
}
|
||||
|
||||
return nsols;
|
||||
}
|
||||
|
||||
} //namespace cv
|
||||
@ -139,11 +139,13 @@ namespace cv
|
||||
CameraParameters camera;
|
||||
};
|
||||
|
||||
template <typename OpointType, typename IpointType>
|
||||
static void pnpTask(const std::vector<char>& pointsMask, const Mat& objectPoints, const Mat& imagePoints,
|
||||
const Parameters& params, std::vector<int>& inliers, Mat& rvec, Mat& tvec,
|
||||
const Mat& rvecInit, const Mat& tvecInit, Mutex& resultsMutex)
|
||||
{
|
||||
Mat modelObjectPoints(1, MIN_POINTS_COUNT, CV_32FC3), modelImagePoints(1, MIN_POINTS_COUNT, CV_32FC2);
|
||||
Mat modelObjectPoints(1, MIN_POINTS_COUNT, CV_MAKETYPE(DataDepth<OpointType>::value, 3));
|
||||
Mat modelImagePoints(1, MIN_POINTS_COUNT, CV_MAKETYPE(DataDepth<IpointType>::value, 2));
|
||||
for (int i = 0, colIndex = 0; i < (int)pointsMask.size(); i++)
|
||||
{
|
||||
if (pointsMask[i])
|
||||
@ -162,7 +164,7 @@ namespace cv
|
||||
for (int i = 0; i < MIN_POINTS_COUNT; i++)
|
||||
for (int j = i + 1; j < MIN_POINTS_COUNT; j++)
|
||||
{
|
||||
if (norm(modelObjectPoints.at<Vec3f>(0, i) - modelObjectPoints.at<Vec3f>(0, j)) < eps)
|
||||
if (norm(modelObjectPoints.at<Vec<OpointType,3> >(0, i) - modelObjectPoints.at<Vec<OpointType,3> >(0, j)) < eps)
|
||||
num_same_points++;
|
||||
}
|
||||
if (num_same_points > 0)
|
||||
@ -176,7 +178,7 @@ namespace cv
|
||||
params.useExtrinsicGuess, params.flags);
|
||||
|
||||
|
||||
std::vector<Point2f> projected_points;
|
||||
std::vector<Point_<OpointType> > projected_points;
|
||||
projected_points.resize(objectPoints.cols);
|
||||
projectPoints(objectPoints, localRvec, localTvec, params.camera.intrinsics, params.camera.distortion, projected_points);
|
||||
|
||||
@ -186,9 +188,11 @@ namespace cv
|
||||
std::vector<int> localInliers;
|
||||
for (int i = 0; i < objectPoints.cols; i++)
|
||||
{
|
||||
Point2f p(imagePoints.at<Vec2f>(0, i)[0], imagePoints.at<Vec2f>(0, i)[1]);
|
||||
//Although p is a 2D point it needs the same type as the object points to enable the norm calculation
|
||||
Point_<OpointType> p((OpointType)imagePoints.at<Vec<IpointType,2> >(0, i)[0],
|
||||
(OpointType)imagePoints.at<Vec<IpointType,2> >(0, i)[1]);
|
||||
if ((norm(p - projected_points[i]) < params.reprojectionError)
|
||||
&& (rotatedPoints.at<Vec3f>(0, i)[2] > 0)) //hack
|
||||
&& (rotatedPoints.at<Vec<OpointType,3> >(0, i)[2] > 0)) //hack
|
||||
{
|
||||
localInliers.push_back(i);
|
||||
}
|
||||
@ -208,6 +212,30 @@ namespace cv
|
||||
}
|
||||
}
|
||||
|
||||
static void pnpTask(const std::vector<char>& pointsMask, const Mat& objectPoints, const Mat& imagePoints,
|
||||
const Parameters& params, std::vector<int>& inliers, Mat& rvec, Mat& tvec,
|
||||
const Mat& rvecInit, const Mat& tvecInit, Mutex& resultsMutex)
|
||||
{
|
||||
CV_Assert(objectPoints.depth() == CV_64F || objectPoints.depth() == CV_32F);
|
||||
CV_Assert(imagePoints.depth() == CV_64F || imagePoints.depth() == CV_32F);
|
||||
const bool objectDoublePrecision = objectPoints.depth() == CV_64F;
|
||||
const bool imageDoublePrecision = imagePoints.depth() == CV_64F;
|
||||
if(objectDoublePrecision)
|
||||
{
|
||||
if(imageDoublePrecision)
|
||||
pnpTask<double, double>(pointsMask, objectPoints, imagePoints, params, inliers, rvec, tvec, rvecInit, tvecInit, resultsMutex);
|
||||
else
|
||||
pnpTask<double, float>(pointsMask, objectPoints, imagePoints, params, inliers, rvec, tvec, rvecInit, tvecInit, resultsMutex);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(imageDoublePrecision)
|
||||
pnpTask<float, double>(pointsMask, objectPoints, imagePoints, params, inliers, rvec, tvec, rvecInit, tvecInit, resultsMutex);
|
||||
else
|
||||
pnpTask<float, float>(pointsMask, objectPoints, imagePoints, params, inliers, rvec, tvec, rvecInit, tvecInit, resultsMutex);
|
||||
}
|
||||
}
|
||||
|
||||
class PnPSolver
|
||||
{
|
||||
public:
|
||||
@ -283,10 +311,10 @@ void cv::solvePnPRansac(InputArray _opoints, InputArray _ipoints,
|
||||
Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat();
|
||||
|
||||
CV_Assert(opoints.isContinuous());
|
||||
CV_Assert(opoints.depth() == CV_32F);
|
||||
CV_Assert(opoints.depth() == CV_32F || opoints.depth() == CV_64F);
|
||||
CV_Assert((opoints.rows == 1 && opoints.channels() == 3) || opoints.cols*opoints.channels() == 3);
|
||||
CV_Assert(ipoints.isContinuous());
|
||||
CV_Assert(ipoints.depth() == CV_32F);
|
||||
CV_Assert(ipoints.depth() == CV_32F || ipoints.depth() == CV_64F);
|
||||
CV_Assert((ipoints.rows == 1 && ipoints.channels() == 2) || ipoints.cols*ipoints.channels() == 2);
|
||||
|
||||
_rvec.create(3, 1, CV_64FC1);
|
||||
@ -322,7 +350,7 @@ void cv::solvePnPRansac(InputArray _opoints, InputArray _ipoints,
|
||||
if (flags != P3P)
|
||||
{
|
||||
int i, pointsCount = (int)localInliers.size();
|
||||
Mat inlierObjectPoints(1, pointsCount, CV_32FC3), inlierImagePoints(1, pointsCount, CV_32FC2);
|
||||
Mat inlierObjectPoints(1, pointsCount, CV_MAKE_TYPE(opoints.depth(), 3)), inlierImagePoints(1, pointsCount, CV_MAKE_TYPE(ipoints.depth(), 2));
|
||||
for (i = 0; i < pointsCount; i++)
|
||||
{
|
||||
int index = localInliers[i];
|
||||
|
||||
@ -48,7 +48,7 @@
|
||||
#include "precomp.hpp"
|
||||
#include <stdio.h>
|
||||
#include <limits>
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_calib3d.hpp"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
|
||||
@ -40,7 +40,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
#include "../test_precomp.hpp"
|
||||
#include "cvconfig.h"
|
||||
#include "opencv2/ts/ocl_test.hpp"
|
||||
|
||||
|
||||
138
modules/calib3d/test/test_homography_decomp.cpp
Normal file
138
modules/calib3d/test/test_homography_decomp.cpp
Normal file
@ -0,0 +1,138 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// This is a test file for the function decomposeHomography contributed to OpenCV
|
||||
// by Samson Yilma.
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2014, Samson Yilma¸ (samson_yilma@yahoo.com), all rights reserved.
|
||||
//
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
#include "opencv2/calib3d.hpp"
|
||||
#include <vector>
|
||||
|
||||
using namespace cv;
|
||||
using namespace std;
|
||||
|
||||
class CV_HomographyDecompTest: public cvtest::BaseTest {
|
||||
|
||||
public:
|
||||
CV_HomographyDecompTest()
|
||||
{
|
||||
buildTestDataSet();
|
||||
}
|
||||
|
||||
protected:
|
||||
void run(int)
|
||||
{
|
||||
vector<Mat> rotations;
|
||||
vector<Mat> translations;
|
||||
vector<Mat> normals;
|
||||
|
||||
decomposeHomographyMat(_H, _K, rotations, translations, normals);
|
||||
|
||||
//there should be at least 1 solution
|
||||
ASSERT_GT(static_cast<int>(rotations.size()), 0);
|
||||
ASSERT_GT(static_cast<int>(translations.size()), 0);
|
||||
ASSERT_GT(static_cast<int>(normals.size()), 0);
|
||||
|
||||
ASSERT_EQ(rotations.size(), normals.size());
|
||||
ASSERT_EQ(translations.size(), normals.size());
|
||||
|
||||
ASSERT_TRUE(containsValidMotion(rotations, translations, normals));
|
||||
|
||||
decomposeHomographyMat(_H, _K, rotations, noArray(), noArray());
|
||||
ASSERT_GT(static_cast<int>(rotations.size()), 0);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
void buildTestDataSet()
|
||||
{
|
||||
_K = Matx33d(640, 0.0, 320,
|
||||
0, 640, 240,
|
||||
0, 0, 1);
|
||||
|
||||
_H = Matx33d(2.649157564634028, 4.583875997496426, 70.694447785121326,
|
||||
-1.072756858861583, 3.533262150437228, 1513.656999614321649,
|
||||
0.001303887589576, 0.003042206876298, 1.000000000000000
|
||||
);
|
||||
|
||||
//expected solution for the given homography and intrinsic matrices
|
||||
_R = Matx33d(0.43307983549125, 0.545749113549648, -0.717356090899523,
|
||||
-0.85630229674426, 0.497582023798831, -0.138414255706431,
|
||||
0.281404038139784, 0.67421809131173, 0.682818960388909);
|
||||
|
||||
_t = Vec3d(1.826751712278038, 1.264718492450820, 0.195080809998819);
|
||||
_n = Vec3d(0.244875830334816, 0.480857890778889, 0.841909446789566);
|
||||
}
|
||||
|
||||
bool containsValidMotion(std::vector<Mat>& rotations,
|
||||
std::vector<Mat>& translations,
|
||||
std::vector<Mat>& normals
|
||||
)
|
||||
{
|
||||
double max_error = 1.0e-3;
|
||||
|
||||
vector<Mat>::iterator riter = rotations.begin();
|
||||
vector<Mat>::iterator titer = translations.begin();
|
||||
vector<Mat>::iterator niter = normals.begin();
|
||||
|
||||
for (;
|
||||
riter != rotations.end() && titer != translations.end() && niter != normals.end();
|
||||
++riter, ++titer, ++niter) {
|
||||
|
||||
double rdist = norm(*riter, _R, NORM_INF);
|
||||
double tdist = norm(*titer, _t, NORM_INF);
|
||||
double ndist = norm(*niter, _n, NORM_INF);
|
||||
|
||||
if ( rdist < max_error
|
||||
&& tdist < max_error
|
||||
&& ndist < max_error )
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
Matx33d _R, _K, _H;
|
||||
Vec3d _t, _n;
|
||||
};
|
||||
|
||||
TEST(Calib3d_DecomposeHomography, regression) { CV_HomographyDecompTest test; test.safe_run(); }
|
||||
@ -1,6 +1,5 @@
|
||||
set(the_description "The Core Functionality")
|
||||
ocv_add_module(core PRIVATE_REQUIRED ${ZLIB_LIBRARIES} "${OPENCL_LIBRARIES}" OPTIONAL opencv_cudev)
|
||||
ocv_module_include_directories(${ZLIB_INCLUDE_DIRS})
|
||||
|
||||
if(HAVE_WINRT_CX)
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /ZW")
|
||||
@ -19,11 +18,11 @@ file(GLOB lib_cuda_hdrs_detail "include/opencv2/${name}/cuda/detail/*.hpp" "incl
|
||||
source_group("Cuda Headers" FILES ${lib_cuda_hdrs})
|
||||
source_group("Cuda Headers\\Detail" FILES ${lib_cuda_hdrs_detail})
|
||||
|
||||
ocv_glob_module_sources(SOURCES "${opencv_core_BINARY_DIR}/version_string.inc"
|
||||
ocv_glob_module_sources(SOURCES "${OPENCV_MODULE_opencv_core_BINARY_DIR}/version_string.inc"
|
||||
HEADERS ${lib_cuda_hdrs} ${lib_cuda_hdrs_detail})
|
||||
|
||||
ocv_module_include_directories(${the_module} ${ZLIB_INCLUDE_DIRS})
|
||||
ocv_create_module()
|
||||
ocv_add_precompiled_headers(${the_module})
|
||||
|
||||
ocv_add_accuracy_tests()
|
||||
ocv_add_perf_tests()
|
||||
|
||||
@ -845,7 +845,6 @@ For convenience, the following types from the OpenCV C API already have such a s
|
||||
that calls the appropriate release function:
|
||||
|
||||
* ``CvCapture``
|
||||
* :ocv:struct:`CvDTreeSplit`
|
||||
* :ocv:struct:`CvFileStorage`
|
||||
* ``CvHaarClassifierCascade``
|
||||
* :ocv:struct:`CvMat`
|
||||
@ -2326,6 +2325,69 @@ Returns the matrix iterator and sets it to the after-last matrix element.
|
||||
|
||||
The methods return the matrix read-only or read-write iterators, set to the point following the last matrix element.
|
||||
|
||||
|
||||
Mat::forEach
|
||||
------------
|
||||
Invoke with arguments functor, and runs the functor over all matrix element.
|
||||
|
||||
.. ocv:function:: template<typename _Tp, typename Functor> void Mat::forEach(Functor operation)
|
||||
|
||||
.. ocv:function:: template<typename _Tp, typename Functor> void Mat::forEach(Functor operation) const
|
||||
|
||||
The methos runs operation in parallel. Operation is passed by arguments. Operation have to be a function pointer, a function object or a lambda(C++11).
|
||||
|
||||
All of below operation is equal. Put 0xFF to first channel of all matrix elements. ::
|
||||
|
||||
Mat image(1920, 1080, CV_8UC3);
|
||||
typedef cv::Point3_<uint8_t> Pixel;
|
||||
|
||||
// first. raw pointer access.
|
||||
for (int r = 0; r < image.rows; ++r) {
|
||||
Pixel* ptr = image.ptr<Pixel>(0, r);
|
||||
const Pixel* ptr_end = ptr + image.cols;
|
||||
for (; ptr != ptr_end; ++ptr) {
|
||||
ptr->x = 255;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Using MatIterator. (Simple but there are a Iterator's overhead)
|
||||
for (Pixel &p : cv::Mat_<Pixel>(image)) {
|
||||
p.x = 255;
|
||||
}
|
||||
|
||||
|
||||
// Parallel execution with function object.
|
||||
struct Operator {
|
||||
void operator ()(Pixel &pixel, const int * position) {
|
||||
pixel.x = 255;
|
||||
}
|
||||
};
|
||||
image.forEach<Pixel>(Operator());
|
||||
|
||||
|
||||
// Parallel execution using C++11 lambda.
|
||||
image.forEach<Pixel>([](Pixel &p, const int * position) -> void {
|
||||
p.x = 255;
|
||||
});
|
||||
|
||||
position parameter is index of current pixel. ::
|
||||
|
||||
// Creating 3D matrix (255 x 255 x 255) typed uint8_t,
|
||||
// and initialize all elements by the value which equals elements position.
|
||||
// i.e. pixels (x,y,z) = (1,2,3) is (b,g,r) = (1,2,3).
|
||||
|
||||
int sizes[] = { 255, 255, 255 };
|
||||
typedef cv::Point3_<uint8_t> Pixel;
|
||||
|
||||
Mat_<Pixel> image = Mat::zeros(3, sizes, CV_8UC3);
|
||||
|
||||
image.forEachWithPosition([&](Pixel& pixel, const int position[]) -> void{
|
||||
pixel.x = position[0];
|
||||
pixel.y = position[1];
|
||||
pixel.z = position[2];
|
||||
});
|
||||
|
||||
Mat\_
|
||||
-----
|
||||
.. ocv:class:: Mat_
|
||||
|
||||
@ -690,7 +690,61 @@ public:
|
||||
Mat mean; //!< mean value subtracted before the projection and added after the back projection
|
||||
};
|
||||
|
||||
// Linear Discriminant Analysis
|
||||
class CV_EXPORTS LDA
|
||||
{
|
||||
public:
|
||||
// Initializes a LDA with num_components (default 0) and specifies how
|
||||
// samples are aligned (default dataAsRow=true).
|
||||
explicit LDA(int num_components = 0);
|
||||
|
||||
// Initializes and performs a Discriminant Analysis with Fisher's
|
||||
// Optimization Criterion on given data in src and corresponding labels
|
||||
// in labels. If 0 (or less) number of components are given, they are
|
||||
// automatically determined for given data in computation.
|
||||
LDA(InputArrayOfArrays src, InputArray labels, int num_components = 0);
|
||||
|
||||
// Serializes this object to a given filename.
|
||||
void save(const String& filename) const;
|
||||
|
||||
// Deserializes this object from a given filename.
|
||||
void load(const String& filename);
|
||||
|
||||
// Serializes this object to a given cv::FileStorage.
|
||||
void save(FileStorage& fs) const;
|
||||
|
||||
// Deserializes this object from a given cv::FileStorage.
|
||||
void load(const FileStorage& node);
|
||||
|
||||
// Destructor.
|
||||
~LDA();
|
||||
|
||||
//! Compute the discriminants for data in src and labels.
|
||||
void compute(InputArrayOfArrays src, InputArray labels);
|
||||
|
||||
// Projects samples into the LDA subspace.
|
||||
Mat project(InputArray src);
|
||||
|
||||
// Reconstructs projections from the LDA subspace.
|
||||
Mat reconstruct(InputArray src);
|
||||
|
||||
// Returns the eigenvectors of this LDA.
|
||||
Mat eigenvectors() const { return _eigenvectors; }
|
||||
|
||||
// Returns the eigenvalues of this LDA.
|
||||
Mat eigenvalues() const { return _eigenvalues; }
|
||||
|
||||
static Mat subspaceProject(InputArray W, InputArray mean, InputArray src);
|
||||
static Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src);
|
||||
|
||||
protected:
|
||||
bool _dataAsRow;
|
||||
int _num_components;
|
||||
Mat _eigenvectors;
|
||||
Mat _eigenvalues;
|
||||
|
||||
void lda(InputArrayOfArrays src, InputArray labels);
|
||||
};
|
||||
|
||||
/*!
|
||||
Singular Value Decomposition class
|
||||
|
||||
@ -261,8 +261,8 @@ public:
|
||||
int* refcount;
|
||||
|
||||
//! helper fields used in locateROI and adjustROI
|
||||
uchar* datastart;
|
||||
uchar* dataend;
|
||||
const uchar* datastart;
|
||||
const uchar* dataend;
|
||||
|
||||
//! allocator
|
||||
Allocator* allocator;
|
||||
@ -349,8 +349,8 @@ public:
|
||||
uchar* data;
|
||||
int* refcount;
|
||||
|
||||
uchar* datastart;
|
||||
uchar* dataend;
|
||||
const uchar* datastart;
|
||||
const uchar* dataend;
|
||||
|
||||
AllocType alloc_type;
|
||||
};
|
||||
|
||||
@ -395,7 +395,7 @@ struct CV_EXPORTS UMatData
|
||||
|
||||
struct CV_EXPORTS UMatDataAutoLock
|
||||
{
|
||||
UMatDataAutoLock(UMatData* u);
|
||||
explicit UMatDataAutoLock(UMatData* u);
|
||||
~UMatDataAutoLock();
|
||||
UMatData* u;
|
||||
};
|
||||
@ -403,7 +403,7 @@ struct CV_EXPORTS UMatDataAutoLock
|
||||
|
||||
struct CV_EXPORTS MatSize
|
||||
{
|
||||
MatSize(int* _p);
|
||||
explicit MatSize(int* _p);
|
||||
Size operator()() const;
|
||||
const int& operator[](int i) const;
|
||||
int& operator[](int i);
|
||||
@ -417,7 +417,7 @@ struct CV_EXPORTS MatSize
|
||||
struct CV_EXPORTS MatStep
|
||||
{
|
||||
MatStep();
|
||||
MatStep(size_t s);
|
||||
explicit MatStep(size_t s);
|
||||
const size_t& operator[](int i) const;
|
||||
size_t& operator[](int i);
|
||||
operator size_t() const;
|
||||
@ -900,6 +900,11 @@ public:
|
||||
template<typename _Tp> MatConstIterator_<_Tp> begin() const;
|
||||
template<typename _Tp> MatConstIterator_<_Tp> end() const;
|
||||
|
||||
//! template methods for for operation over all matrix elements.
|
||||
// the operations take care of skipping gaps in the end of rows (if any)
|
||||
template<typename _Tp, typename Functor> void forEach(const Functor& operation);
|
||||
template<typename _Tp, typename Functor> void forEach(const Functor& operation) const;
|
||||
|
||||
enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
|
||||
enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
|
||||
|
||||
@ -918,9 +923,9 @@ public:
|
||||
uchar* data;
|
||||
|
||||
//! helper fields used in locateROI and adjustROI
|
||||
uchar* datastart;
|
||||
uchar* dataend;
|
||||
uchar* datalimit;
|
||||
const uchar* datastart;
|
||||
const uchar* dataend;
|
||||
const uchar* datalimit;
|
||||
|
||||
//! custom allocator
|
||||
MatAllocator* allocator;
|
||||
@ -934,6 +939,7 @@ public:
|
||||
MatStep step;
|
||||
|
||||
protected:
|
||||
template<typename _Tp, typename Functor> void forEach_impl(const Functor& operation);
|
||||
};
|
||||
|
||||
|
||||
@ -1043,6 +1049,11 @@ public:
|
||||
const_iterator begin() const;
|
||||
const_iterator end() const;
|
||||
|
||||
//! template methods for for operation over all matrix elements.
|
||||
// the operations take care of skipping gaps in the end of rows (if any)
|
||||
template<typename Functor> void forEach(const Functor& operation);
|
||||
template<typename Functor> void forEach(const Functor& operation) const;
|
||||
|
||||
//! equivalent to Mat::create(_rows, _cols, DataType<_Tp>::type)
|
||||
void create(int _rows, int _cols);
|
||||
//! equivalent to Mat::create(_size, DataType<_Tp>::type)
|
||||
@ -1804,9 +1815,9 @@ public:
|
||||
//! copy operator
|
||||
MatConstIterator& operator = (const MatConstIterator& it);
|
||||
//! returns the current matrix element
|
||||
uchar* operator *() const;
|
||||
const uchar* operator *() const;
|
||||
//! returns the i-th matrix element, relative to the current
|
||||
uchar* operator [](ptrdiff_t i) const;
|
||||
const uchar* operator [](ptrdiff_t i) const;
|
||||
|
||||
//! shifts the iterator forward by the specified number of elements
|
||||
MatConstIterator& operator += (ptrdiff_t ofs);
|
||||
@ -1831,9 +1842,9 @@ public:
|
||||
|
||||
const Mat* m;
|
||||
size_t elemSize;
|
||||
uchar* ptr;
|
||||
uchar* sliceStart;
|
||||
uchar* sliceEnd;
|
||||
const uchar* ptr;
|
||||
const uchar* sliceStart;
|
||||
const uchar* sliceEnd;
|
||||
};
|
||||
|
||||
|
||||
@ -1917,9 +1928,9 @@ public:
|
||||
//! constructor that sets the iterator to the specified element of the matrix
|
||||
MatIterator_(Mat_<_Tp>* _m, int _row, int _col=0);
|
||||
//! constructor that sets the iterator to the specified element of the matrix
|
||||
MatIterator_(const Mat_<_Tp>* _m, Point _pt);
|
||||
MatIterator_(Mat_<_Tp>* _m, Point _pt);
|
||||
//! constructor that sets the iterator to the specified element of the matrix
|
||||
MatIterator_(const Mat_<_Tp>* _m, const int* _idx);
|
||||
MatIterator_(Mat_<_Tp>* _m, const int* _idx);
|
||||
//! copy constructor
|
||||
MatIterator_(const MatIterator_& it);
|
||||
//! copy operator
|
||||
|
||||
@ -438,7 +438,7 @@ Mat::Mat(const std::vector<_Tp>& vec, bool copyData)
|
||||
if( !copyData )
|
||||
{
|
||||
step[0] = step[1] = sizeof(_Tp);
|
||||
data = datastart = (uchar*)&vec[0];
|
||||
datastart = data = (uchar*)&vec[0];
|
||||
datalimit = dataend = datastart + rows * step[0];
|
||||
}
|
||||
else
|
||||
@ -453,7 +453,7 @@ Mat::Mat(const Vec<_Tp, n>& vec, bool copyData)
|
||||
if( !copyData )
|
||||
{
|
||||
step[0] = step[1] = sizeof(_Tp);
|
||||
data = datastart = (uchar*)vec.val;
|
||||
datastart = data = (uchar*)vec.val;
|
||||
datalimit = dataend = datastart + rows * step[0];
|
||||
}
|
||||
else
|
||||
@ -470,7 +470,7 @@ Mat::Mat(const Matx<_Tp,m,n>& M, bool copyData)
|
||||
{
|
||||
step[0] = cols * sizeof(_Tp);
|
||||
step[1] = sizeof(_Tp);
|
||||
data = datastart = (uchar*)M.val;
|
||||
datastart = data = (uchar*)M.val;
|
||||
datalimit = dataend = datastart + rows * step[0];
|
||||
}
|
||||
else
|
||||
@ -485,7 +485,7 @@ Mat::Mat(const Point_<_Tp>& pt, bool copyData)
|
||||
if( !copyData )
|
||||
{
|
||||
step[0] = step[1] = sizeof(_Tp);
|
||||
data = datastart = (uchar*)&pt.x;
|
||||
datastart = data = (uchar*)&pt.x;
|
||||
datalimit = dataend = datastart + rows * step[0];
|
||||
}
|
||||
else
|
||||
@ -504,7 +504,7 @@ Mat::Mat(const Point3_<_Tp>& pt, bool copyData)
|
||||
if( !copyData )
|
||||
{
|
||||
step[0] = step[1] = sizeof(_Tp);
|
||||
data = datastart = (uchar*)&pt.x;
|
||||
datastart = data = (uchar*)&pt.x;
|
||||
datalimit = dataend = datastart + rows * step[0];
|
||||
}
|
||||
else
|
||||
@ -642,7 +642,7 @@ inline void Mat::release()
|
||||
if( u && CV_XADD(&u->refcount, -1) == 1 )
|
||||
deallocate();
|
||||
u = NULL;
|
||||
data = datastart = dataend = datalimit = 0;
|
||||
datastart = dataend = datalimit = data = 0;
|
||||
for(int i = 0; i < dims; i++)
|
||||
size.p[i] = 0;
|
||||
}
|
||||
@ -1000,6 +1000,17 @@ MatIterator_<_Tp> Mat::end()
|
||||
return it;
|
||||
}
|
||||
|
||||
template<typename _Tp, typename Functor> inline
|
||||
void Mat::forEach(const Functor& operation) {
|
||||
this->forEach_impl<_Tp>(operation);
|
||||
};
|
||||
|
||||
template<typename _Tp, typename Functor> inline
|
||||
void Mat::forEach(const Functor& operation) const {
|
||||
// call as not const
|
||||
(const_cast<Mat*>(this))->forEach<const _Tp>(operation);
|
||||
};
|
||||
|
||||
template<typename _Tp> inline
|
||||
Mat::operator std::vector<_Tp>() const
|
||||
{
|
||||
@ -1045,7 +1056,7 @@ void Mat::push_back(const _Tp& elem)
|
||||
}
|
||||
CV_Assert(DataType<_Tp>::type == type() && cols == 1
|
||||
/* && dims == 2 (cols == 1 implies dims == 2) */);
|
||||
uchar* tmp = dataend + step[0];
|
||||
const uchar* tmp = dataend + step[0];
|
||||
if( !isSubmatrix() && isContinuous() && tmp <= datalimit )
|
||||
{
|
||||
*(_Tp*)(data + (size.p[0]++) * step.p[0]) = elem;
|
||||
@ -1585,6 +1596,15 @@ MatIterator_<_Tp> Mat_<_Tp>::end()
|
||||
return Mat::end<_Tp>();
|
||||
}
|
||||
|
||||
template<typename _Tp> template<typename Functor> inline
|
||||
void Mat_<_Tp>::forEach(const Functor& operation) {
|
||||
Mat::forEach<_Tp, Functor>(operation);
|
||||
}
|
||||
|
||||
template<typename _Tp> template<typename Functor> inline
|
||||
void Mat_<_Tp>::forEach(const Functor& operation) const {
|
||||
Mat::forEach<_Tp, Functor>(operation);
|
||||
}
|
||||
|
||||
///////////////////////////// SparseMat /////////////////////////////
|
||||
|
||||
@ -2149,7 +2169,7 @@ MatConstIterator& MatConstIterator::operator = (const MatConstIterator& it )
|
||||
}
|
||||
|
||||
inline
|
||||
uchar* MatConstIterator::operator *() const
|
||||
const uchar* MatConstIterator::operator *() const
|
||||
{
|
||||
return ptr;
|
||||
}
|
||||
@ -2282,7 +2302,7 @@ MatConstIterator operator - (const MatConstIterator& a, ptrdiff_t ofs)
|
||||
|
||||
|
||||
inline
|
||||
uchar* MatConstIterator::operator [](ptrdiff_t i) const
|
||||
const uchar* MatConstIterator::operator [](ptrdiff_t i) const
|
||||
{
|
||||
return *(*this + i);
|
||||
}
|
||||
@ -2454,12 +2474,12 @@ MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, int _row, int _col)
|
||||
{}
|
||||
|
||||
template<typename _Tp> inline
|
||||
MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, Point _pt)
|
||||
MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, Point _pt)
|
||||
: MatConstIterator_<_Tp>(_m, _pt)
|
||||
{}
|
||||
|
||||
template<typename _Tp> inline
|
||||
MatIterator_<_Tp>::MatIterator_(const Mat_<_Tp>* _m, const int* _idx)
|
||||
MatIterator_<_Tp>::MatIterator_(Mat_<_Tp>* _m, const int* _idx)
|
||||
: MatConstIterator_<_Tp>(_m, _idx)
|
||||
{}
|
||||
|
||||
@ -2593,7 +2613,7 @@ inline SparseMatConstIterator& SparseMatConstIterator::operator = (const SparseM
|
||||
template<typename _Tp> inline
|
||||
const _Tp& SparseMatConstIterator::value() const
|
||||
{
|
||||
return *(_Tp*)ptr;
|
||||
return *(const _Tp*)ptr;
|
||||
}
|
||||
|
||||
inline
|
||||
|
||||
@ -636,6 +636,9 @@ protected:
|
||||
|
||||
CV_EXPORTS MatAllocator* getOpenCLAllocator();
|
||||
|
||||
CV_EXPORTS_W bool isPerformanceCheckBypassed();
|
||||
#define OCL_PERFORMANCE_CHECK(condition) (cv::ocl::isPerformanceCheckBypassed() || (condition))
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
|
||||
@ -274,6 +274,102 @@ public:
|
||||
|
||||
CV_EXPORTS void parallel_for_(const Range& range, const ParallelLoopBody& body, double nstripes=-1.);
|
||||
|
||||
/////////////////////////////// forEach method of cv::Mat ////////////////////////////
|
||||
template<typename _Tp, typename Functor> inline
|
||||
void Mat::forEach_impl(const Functor& operation) {
|
||||
if (false) {
|
||||
operation(*reinterpret_cast<_Tp*>(0), reinterpret_cast<int*>(NULL));
|
||||
// If your compiler fail in this line.
|
||||
// Please check that your functor signature is
|
||||
// (_Tp&, const int*) <- multidimential
|
||||
// or (_Tp&, void*) <- in case of you don't need current idx.
|
||||
}
|
||||
|
||||
CV_Assert(this->total() / this->size[this->dims - 1] <= INT_MAX);
|
||||
const int LINES = static_cast<int>(this->total() / this->size[this->dims - 1]);
|
||||
|
||||
class PixelOperationWrapper :public ParallelLoopBody
|
||||
{
|
||||
public:
|
||||
PixelOperationWrapper(Mat_<_Tp>* const frame, const Functor& _operation)
|
||||
: mat(frame), op(_operation) {};
|
||||
virtual ~PixelOperationWrapper(){};
|
||||
// ! Overloaded virtual operator
|
||||
// convert range call to row call.
|
||||
virtual void operator()(const Range &range) const {
|
||||
const int DIMS = mat->dims;
|
||||
const int COLS = mat->size[DIMS - 1];
|
||||
if (DIMS <= 2) {
|
||||
for (int row = range.start; row < range.end; ++row) {
|
||||
this->rowCall2(row, COLS);
|
||||
}
|
||||
} else {
|
||||
std::vector<int> idx(COLS); /// idx is modified in this->rowCall
|
||||
idx[DIMS - 2] = range.start - 1;
|
||||
|
||||
for (int line_num = range.start; line_num < range.end; ++line_num) {
|
||||
idx[DIMS - 2]++;
|
||||
for (int i = DIMS - 2; i >= 0; --i) {
|
||||
if (idx[i] >= mat->size[i]) {
|
||||
idx[i - 1] += idx[i] / mat->size[i];
|
||||
idx[i] %= mat->size[i];
|
||||
continue; // carry-over;
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
this->rowCall(&idx[0], COLS, DIMS);
|
||||
}
|
||||
}
|
||||
};
|
||||
private:
|
||||
Mat_<_Tp>* const mat;
|
||||
const Functor op;
|
||||
// ! Call operator for each elements in this row.
|
||||
inline void rowCall(int* const idx, const int COLS, const int DIMS) const {
|
||||
int &col = idx[DIMS - 1];
|
||||
col = 0;
|
||||
_Tp* pixel = &(mat->template at<_Tp>(idx));
|
||||
|
||||
while (col < COLS) {
|
||||
op(*pixel, const_cast<const int*>(idx));
|
||||
pixel++; col++;
|
||||
}
|
||||
col = 0;
|
||||
}
|
||||
// ! Call operator for each elements in this row. 2d mat special version.
|
||||
inline void rowCall2(const int row, const int COLS) const {
|
||||
union Index{
|
||||
int body[2];
|
||||
operator const int*() const {
|
||||
return reinterpret_cast<const int*>(this);
|
||||
}
|
||||
int& operator[](const int i) {
|
||||
return body[i];
|
||||
}
|
||||
} idx = {{row, 0}};
|
||||
// Special union is needed to avoid
|
||||
// "error: array subscript is above array bounds [-Werror=array-bounds]"
|
||||
// when call the functor `op` such that access idx[3].
|
||||
|
||||
_Tp* pixel = &(mat->template at<_Tp>(idx));
|
||||
const _Tp* const pixel_end = pixel + COLS;
|
||||
while(pixel < pixel_end) {
|
||||
op(*pixel++, static_cast<const int*>(idx));
|
||||
idx[1]++;
|
||||
}
|
||||
};
|
||||
PixelOperationWrapper& operator=(const PixelOperationWrapper &) {
|
||||
CV_Assert(false);
|
||||
// We can not remove this implementation because Visual Studio warning C4822.
|
||||
return *this;
|
||||
};
|
||||
};
|
||||
|
||||
parallel_for_(cv::Range(0, LINES), PixelOperationWrapper(reinterpret_cast<Mat_<_Tp>*>(this), operation));
|
||||
};
|
||||
|
||||
/////////////////////////// Synchronization Primitives ///////////////////////////////
|
||||
|
||||
class CV_EXPORTS Mutex
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
//
|
||||
// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
|
||||
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
//
|
||||
// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
|
||||
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -47,7 +47,7 @@
|
||||
// */
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_core.hpp"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
@ -1607,7 +1607,7 @@ static void arithm_op(InputArray _src1, InputArray _src2, OutputArray _dst,
|
||||
Size sz1 = dims1 <= 2 ? psrc1->size() : Size();
|
||||
Size sz2 = dims2 <= 2 ? psrc2->size() : Size();
|
||||
#ifdef HAVE_OPENCL
|
||||
bool use_opencl = _dst.isUMat() && dims1 <= 2 && dims2 <= 2;
|
||||
bool use_opencl = OCL_PERFORMANCE_CHECK(_dst.isUMat()) && dims1 <= 2 && dims2 <= 2;
|
||||
#endif
|
||||
bool src1Scalar = checkScalar(*psrc1, type2, kind1, kind2);
|
||||
bool src2Scalar = checkScalar(*psrc2, type1, kind2, kind1);
|
||||
@ -2440,6 +2440,34 @@ addWeighted8u( const uchar* src1, size_t step1,
|
||||
_mm_storel_epi64((__m128i*)(dst + x), u);
|
||||
}
|
||||
}
|
||||
#elif CV_NEON
|
||||
float32x4_t g = vdupq_n_f32 (gamma);
|
||||
|
||||
for( ; x <= size.width - 8; x += 8 )
|
||||
{
|
||||
uint8x8_t in1 = vld1_u8(src1+x);
|
||||
uint16x8_t in1_16 = vmovl_u8(in1);
|
||||
float32x4_t in1_f_l = vcvtq_f32_u32(vmovl_u16(vget_low_u16(in1_16)));
|
||||
float32x4_t in1_f_h = vcvtq_f32_u32(vmovl_u16(vget_high_u16(in1_16)));
|
||||
|
||||
uint8x8_t in2 = vld1_u8(src2+x);
|
||||
uint16x8_t in2_16 = vmovl_u8(in2);
|
||||
float32x4_t in2_f_l = vcvtq_f32_u32(vmovl_u16(vget_low_u16(in2_16)));
|
||||
float32x4_t in2_f_h = vcvtq_f32_u32(vmovl_u16(vget_high_u16(in2_16)));
|
||||
|
||||
float32x4_t out_f_l = vaddq_f32(vmulq_n_f32(in1_f_l, alpha), vmulq_n_f32(in2_f_l, beta));
|
||||
float32x4_t out_f_h = vaddq_f32(vmulq_n_f32(in1_f_h, alpha), vmulq_n_f32(in2_f_h, beta));
|
||||
out_f_l = vaddq_f32(out_f_l, g);
|
||||
out_f_h = vaddq_f32(out_f_h, g);
|
||||
|
||||
uint16x4_t out_16_l = vqmovun_s32(vcvtq_s32_f32(out_f_l));
|
||||
uint16x4_t out_16_h = vqmovun_s32(vcvtq_s32_f32(out_f_h));
|
||||
|
||||
uint16x8_t out_16 = vcombine_u16(out_16_l, out_16_h);
|
||||
uint8x8_t out = vqmovn_u16(out_16);
|
||||
|
||||
vst1_u8(dst+x, out);
|
||||
}
|
||||
#endif
|
||||
#if CV_ENABLE_UNROLLED
|
||||
for( ; x <= size.width - 4; x += 4 )
|
||||
@ -2650,6 +2678,14 @@ static void cmp8u(const uchar* src1, size_t step1, const uchar* src2, size_t ste
|
||||
|
||||
}
|
||||
}
|
||||
#elif CV_NEON
|
||||
uint8x16_t mask = code == CMP_GT ? vdupq_n_u8(0) : vdupq_n_u8(255);
|
||||
|
||||
for( ; x <= size.width - 16; x += 16 )
|
||||
{
|
||||
vst1q_u8(dst+x, veorq_u8(vcgtq_u8(vld1q_u8(src1+x), vld1q_u8(src2+x)), mask));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
for( ; x < size.width; x++ ){
|
||||
@ -2674,6 +2710,13 @@ static void cmp8u(const uchar* src1, size_t step1, const uchar* src2, size_t ste
|
||||
_mm_storeu_si128((__m128i*)(dst + x), r00);
|
||||
}
|
||||
}
|
||||
#elif CV_NEON
|
||||
uint8x16_t mask = code == CMP_EQ ? vdupq_n_u8(0) : vdupq_n_u8(255);
|
||||
|
||||
for( ; x <= size.width - 16; x += 16 )
|
||||
{
|
||||
vst1q_u8(dst+x, veorq_u8(vceqq_u8(vld1q_u8(src1+x), vld1q_u8(src2+x)), mask));
|
||||
}
|
||||
#endif
|
||||
for( ; x < size.width; x++ )
|
||||
dst[x] = (uchar)(-(src1[x] == src2[x]) ^ m);
|
||||
@ -2759,6 +2802,22 @@ static void cmp16s(const short* src1, size_t step1, const short* src2, size_t st
|
||||
x += 8;
|
||||
}
|
||||
}
|
||||
#elif CV_NEON
|
||||
uint8x16_t mask = code == CMP_GT ? vdupq_n_u8(0) : vdupq_n_u8(255);
|
||||
|
||||
for( ; x <= size.width - 16; x += 16 )
|
||||
{
|
||||
int16x8_t in1 = vld1q_s16(src1 + x);
|
||||
int16x8_t in2 = vld1q_s16(src2 + x);
|
||||
uint8x8_t t1 = vmovn_u16(vcgtq_s16(in1, in2));
|
||||
|
||||
in1 = vld1q_s16(src1 + x + 8);
|
||||
in2 = vld1q_s16(src2 + x + 8);
|
||||
uint8x8_t t2 = vmovn_u16(vcgtq_s16(in1, in2));
|
||||
|
||||
vst1q_u8(dst+x, veorq_u8(vcombine_u8(t1, t2), mask));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
for( ; x < size.width; x++ ){
|
||||
@ -2797,6 +2856,21 @@ static void cmp16s(const short* src1, size_t step1, const short* src2, size_t st
|
||||
x += 8;
|
||||
}
|
||||
}
|
||||
#elif CV_NEON
|
||||
uint8x16_t mask = code == CMP_EQ ? vdupq_n_u8(0) : vdupq_n_u8(255);
|
||||
|
||||
for( ; x <= size.width - 16; x += 16 )
|
||||
{
|
||||
int16x8_t in1 = vld1q_s16(src1 + x);
|
||||
int16x8_t in2 = vld1q_s16(src2 + x);
|
||||
uint8x8_t t1 = vmovn_u16(vceqq_s16(in1, in2));
|
||||
|
||||
in1 = vld1q_s16(src1 + x + 8);
|
||||
in2 = vld1q_s16(src2 + x + 8);
|
||||
uint8x8_t t2 = vmovn_u16(vceqq_s16(in1, in2));
|
||||
|
||||
vst1q_u8(dst+x, veorq_u8(vcombine_u8(t1, t2), mask));
|
||||
}
|
||||
#endif
|
||||
for( ; x < size.width; x++ )
|
||||
dst[x] = (uchar)(-(src1[x] == src2[x]) ^ m);
|
||||
@ -2982,7 +3056,7 @@ void cv::compare(InputArray _src1, InputArray _src2, OutputArray _dst, int op)
|
||||
haveScalar = true;
|
||||
}
|
||||
|
||||
CV_OCL_RUN(_src1.dims() <= 2 && _src2.dims() <= 2 && _dst.isUMat(),
|
||||
CV_OCL_RUN(_src1.dims() <= 2 && _src2.dims() <= 2 && OCL_PERFORMANCE_CHECK(_dst.isUMat()),
|
||||
ocl_compare(_src1, _src2, _dst, op, haveScalar))
|
||||
|
||||
int kind1 = _src1.kind(), kind2 = _src2.kind();
|
||||
@ -3085,7 +3159,7 @@ namespace cv
|
||||
{
|
||||
|
||||
template <typename T>
|
||||
struct InRange_SSE
|
||||
struct InRange_SIMD
|
||||
{
|
||||
int operator () (const T *, const T *, const T *, uchar *, int) const
|
||||
{
|
||||
@ -3096,7 +3170,7 @@ struct InRange_SSE
|
||||
#if CV_SSE2
|
||||
|
||||
template <>
|
||||
struct InRange_SSE<uchar>
|
||||
struct InRange_SIMD<uchar>
|
||||
{
|
||||
int operator () (const uchar * src1, const uchar * src2, const uchar * src3,
|
||||
uchar * dst, int len) const
|
||||
@ -3121,7 +3195,7 @@ struct InRange_SSE<uchar>
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SSE<schar>
|
||||
struct InRange_SIMD<schar>
|
||||
{
|
||||
int operator () (const schar * src1, const schar * src2, const schar * src3,
|
||||
uchar * dst, int len) const
|
||||
@ -3146,7 +3220,7 @@ struct InRange_SSE<schar>
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SSE<ushort>
|
||||
struct InRange_SIMD<ushort>
|
||||
{
|
||||
int operator () (const ushort * src1, const ushort * src2, const ushort * src3,
|
||||
uchar * dst, int len) const
|
||||
@ -3172,7 +3246,7 @@ struct InRange_SSE<ushort>
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SSE<short>
|
||||
struct InRange_SIMD<short>
|
||||
{
|
||||
int operator () (const short * src1, const short * src2, const short * src3,
|
||||
uchar * dst, int len) const
|
||||
@ -3198,7 +3272,7 @@ struct InRange_SSE<short>
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SSE<int>
|
||||
struct InRange_SIMD<int>
|
||||
{
|
||||
int operator () (const int * src1, const int * src2, const int * src3,
|
||||
uchar * dst, int len) const
|
||||
@ -3230,7 +3304,7 @@ struct InRange_SSE<int>
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SSE<float>
|
||||
struct InRange_SIMD<float>
|
||||
{
|
||||
int operator () (const float * src1, const float * src2, const float * src3,
|
||||
uchar * dst, int len) const
|
||||
@ -3261,6 +3335,160 @@ struct InRange_SSE<float>
|
||||
}
|
||||
};
|
||||
|
||||
#elif CV_NEON
|
||||
|
||||
template <>
|
||||
struct InRange_SIMD<uchar>
|
||||
{
|
||||
int operator () (const uchar * src1, const uchar * src2, const uchar * src3,
|
||||
uchar * dst, int len) const
|
||||
{
|
||||
int x = 0;
|
||||
|
||||
for ( ; x <= len - 16; x += 16 )
|
||||
{
|
||||
uint8x16_t values = vld1q_u8(src1 + x);
|
||||
uint8x16_t low = vld1q_u8(src2 + x);
|
||||
uint8x16_t high = vld1q_u8(src3 + x);
|
||||
|
||||
vst1q_u8(dst + x, vandq_u8(vcgeq_u8(values, low), vcgeq_u8(high, values)));
|
||||
}
|
||||
return x;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SIMD<schar>
|
||||
{
|
||||
int operator () (const schar * src1, const schar * src2, const schar * src3,
|
||||
uchar * dst, int len) const
|
||||
{
|
||||
int x = 0;
|
||||
|
||||
for ( ; x <= len - 16; x += 16 )
|
||||
{
|
||||
int8x16_t values = vld1q_s8(src1 + x);
|
||||
int8x16_t low = vld1q_s8(src2 + x);
|
||||
int8x16_t high = vld1q_s8(src3 + x);
|
||||
|
||||
vst1q_u8(dst + x, vandq_u8(vcgeq_s8(values, low), vcgeq_s8(high, values)));
|
||||
}
|
||||
return x;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SIMD<ushort>
|
||||
{
|
||||
int operator () (const ushort * src1, const ushort * src2, const ushort * src3,
|
||||
uchar * dst, int len) const
|
||||
{
|
||||
int x = 0;
|
||||
|
||||
for ( ; x <= len - 16; x += 16 )
|
||||
{
|
||||
uint16x8_t values = vld1q_u16((const uint16_t*)(src1 + x));
|
||||
uint16x8_t low = vld1q_u16((const uint16_t*)(src2 + x));
|
||||
uint16x8_t high = vld1q_u16((const uint16_t*)(src3 + x));
|
||||
uint8x8_t r1 = vmovn_u16(vandq_u16(vcgeq_u16(values, low), vcgeq_u16(high, values)));
|
||||
|
||||
values = vld1q_u16((const uint16_t*)(src1 + x + 8));
|
||||
low = vld1q_u16((const uint16_t*)(src2 + x + 8));
|
||||
high = vld1q_u16((const uint16_t*)(src3 + x + 8));
|
||||
uint8x8_t r2 = vmovn_u16(vandq_u16(vcgeq_u16(values, low), vcgeq_u16(high, values)));
|
||||
|
||||
vst1q_u8(dst + x, vcombine_u8(r1, r2));
|
||||
}
|
||||
return x;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SIMD<short>
|
||||
{
|
||||
int operator () (const short * src1, const short * src2, const short * src3,
|
||||
uchar * dst, int len) const
|
||||
{
|
||||
int x = 0;
|
||||
|
||||
for ( ; x <= len - 16; x += 16 )
|
||||
{
|
||||
int16x8_t values = vld1q_s16((const int16_t*)(src1 + x));
|
||||
int16x8_t low = vld1q_s16((const int16_t*)(src2 + x));
|
||||
int16x8_t high = vld1q_s16((const int16_t*)(src3 + x));
|
||||
uint8x8_t r1 = vmovn_u16(vandq_u16(vcgeq_s16(values, low), vcgeq_s16(high, values)));
|
||||
|
||||
values = vld1q_s16((const int16_t*)(src1 + x + 8));
|
||||
low = vld1q_s16((const int16_t*)(src2 + x + 8));
|
||||
high = vld1q_s16((const int16_t*)(src3 + x + 8));
|
||||
uint8x8_t r2 = vmovn_u16(vandq_u16(vcgeq_s16(values, low), vcgeq_s16(high, values)));
|
||||
|
||||
vst1q_u8(dst + x, vcombine_u8(r1, r2));
|
||||
}
|
||||
return x;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SIMD<int>
|
||||
{
|
||||
int operator () (const int * src1, const int * src2, const int * src3,
|
||||
uchar * dst, int len) const
|
||||
{
|
||||
int x = 0;
|
||||
|
||||
for ( ; x <= len - 8; x += 8 )
|
||||
{
|
||||
int32x4_t values = vld1q_s32((const int32_t*)(src1 + x));
|
||||
int32x4_t low = vld1q_s32((const int32_t*)(src2 + x));
|
||||
int32x4_t high = vld1q_s32((const int32_t*)(src3 + x));
|
||||
|
||||
uint16x4_t r1 = vmovn_u32(vandq_u32(vcgeq_s32(values, low), vcgeq_s32(high, values)));
|
||||
|
||||
values = vld1q_s32((const int32_t*)(src1 + x + 4));
|
||||
low = vld1q_s32((const int32_t*)(src2 + x + 4));
|
||||
high = vld1q_s32((const int32_t*)(src3 + x + 4));
|
||||
|
||||
uint16x4_t r2 = vmovn_u32(vandq_u32(vcgeq_s32(values, low), vcgeq_s32(high, values)));
|
||||
|
||||
uint16x8_t res_16 = vcombine_u16(r1, r2);
|
||||
|
||||
vst1_u8(dst + x, vmovn_u16(res_16));
|
||||
}
|
||||
return x;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct InRange_SIMD<float>
|
||||
{
|
||||
int operator () (const float * src1, const float * src2, const float * src3,
|
||||
uchar * dst, int len) const
|
||||
{
|
||||
int x = 0;
|
||||
|
||||
for ( ; x <= len - 8; x += 8 )
|
||||
{
|
||||
float32x4_t values = vld1q_f32((const float32_t*)(src1 + x));
|
||||
float32x4_t low = vld1q_f32((const float32_t*)(src2 + x));
|
||||
float32x4_t high = vld1q_f32((const float32_t*)(src3 + x));
|
||||
|
||||
uint16x4_t r1 = vmovn_u32(vandq_u32(vcgeq_f32(values, low), vcgeq_f32(high, values)));
|
||||
|
||||
values = vld1q_f32((const float32_t*)(src1 + x + 4));
|
||||
low = vld1q_f32((const float32_t*)(src2 + x + 4));
|
||||
high = vld1q_f32((const float32_t*)(src3 + x + 4));
|
||||
|
||||
uint16x4_t r2 = vmovn_u32(vandq_u32(vcgeq_f32(values, low), vcgeq_f32(high, values)));
|
||||
|
||||
uint16x8_t res_16 = vcombine_u16(r1, r2);
|
||||
|
||||
vst1_u8(dst + x, vmovn_u16(res_16));
|
||||
}
|
||||
return x;
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
template <typename T>
|
||||
@ -3272,7 +3500,7 @@ static void inRange_(const T* src1, size_t step1, const T* src2, size_t step2,
|
||||
step2 /= sizeof(src2[0]);
|
||||
step3 /= sizeof(src3[0]);
|
||||
|
||||
InRange_SSE<T> vop;
|
||||
InRange_SIMD<T> vop;
|
||||
|
||||
for( ; size.height--; src1 += step1, src2 += step2, src3 += step3, dst += step )
|
||||
{
|
||||
@ -3500,7 +3728,7 @@ void cv::inRange(InputArray _src, InputArray _lowerb,
|
||||
InputArray _upperb, OutputArray _dst)
|
||||
{
|
||||
CV_OCL_RUN(_src.dims() <= 2 && _lowerb.dims() <= 2 &&
|
||||
_upperb.dims() <= 2 && _dst.isUMat(),
|
||||
_upperb.dims() <= 2 && OCL_PERFORMANCE_CHECK(_dst.isUMat()),
|
||||
ocl_inRange(_src, _lowerb, _upperb, _dst))
|
||||
|
||||
int skind = _src.kind(), lkind = _lowerb.kind(), ukind = _upperb.kind();
|
||||
|
||||
@ -41,7 +41,7 @@
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_core.hpp"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
@ -50,6 +50,71 @@ namespace cv
|
||||
* split & merge *
|
||||
\****************************************************************************************/
|
||||
|
||||
#if CV_NEON
|
||||
template<typename T> struct VSplit2;
|
||||
template<typename T> struct VSplit3;
|
||||
template<typename T> struct VSplit4;
|
||||
|
||||
#define SPLIT2_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func) \
|
||||
template<> \
|
||||
struct name<data_type>{ \
|
||||
void operator()(const data_type* src, data_type* dst0, data_type* dst1){ \
|
||||
reg_type r = load_func(src); \
|
||||
store_func(dst0, r.val[0]); \
|
||||
store_func(dst1, r.val[1]); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define SPLIT3_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func) \
|
||||
template<> \
|
||||
struct name<data_type>{ \
|
||||
void operator()(const data_type* src, data_type* dst0, data_type* dst1, \
|
||||
data_type* dst2){ \
|
||||
reg_type r = load_func(src); \
|
||||
store_func(dst0, r.val[0]); \
|
||||
store_func(dst1, r.val[1]); \
|
||||
store_func(dst2, r.val[2]); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define SPLIT4_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func) \
|
||||
template<> \
|
||||
struct name<data_type>{ \
|
||||
void operator()(const data_type* src, data_type* dst0, data_type* dst1, \
|
||||
data_type* dst2, data_type* dst3){ \
|
||||
reg_type r = load_func(src); \
|
||||
store_func(dst0, r.val[0]); \
|
||||
store_func(dst1, r.val[1]); \
|
||||
store_func(dst2, r.val[2]); \
|
||||
store_func(dst3, r.val[3]); \
|
||||
} \
|
||||
}
|
||||
|
||||
SPLIT2_KERNEL_TEMPLATE(VSplit2, uchar , uint8x16x2_t, vld2q_u8 , vst1q_u8 );
|
||||
SPLIT2_KERNEL_TEMPLATE(VSplit2, schar , int8x16x2_t, vld2q_s8 , vst1q_s8 );
|
||||
SPLIT2_KERNEL_TEMPLATE(VSplit2, ushort, uint16x8x2_t, vld2q_u16, vst1q_u16);
|
||||
SPLIT2_KERNEL_TEMPLATE(VSplit2, short , int16x8x2_t, vld2q_s16, vst1q_s16);
|
||||
SPLIT2_KERNEL_TEMPLATE(VSplit2, int , int32x4x2_t, vld2q_s32, vst1q_s32);
|
||||
SPLIT2_KERNEL_TEMPLATE(VSplit2, float , float32x4x2_t, vld2q_f32, vst1q_f32);
|
||||
SPLIT2_KERNEL_TEMPLATE(VSplit2, int64 , int64x1x2_t, vld2_s64 , vst1_s64 );
|
||||
|
||||
SPLIT3_KERNEL_TEMPLATE(VSplit3, uchar , uint8x16x3_t, vld3q_u8 , vst1q_u8 );
|
||||
SPLIT3_KERNEL_TEMPLATE(VSplit3, schar , int8x16x3_t, vld3q_s8 , vst1q_s8 );
|
||||
SPLIT3_KERNEL_TEMPLATE(VSplit3, ushort, uint16x8x3_t, vld3q_u16, vst1q_u16);
|
||||
SPLIT3_KERNEL_TEMPLATE(VSplit3, short , int16x8x3_t, vld3q_s16, vst1q_s16);
|
||||
SPLIT3_KERNEL_TEMPLATE(VSplit3, int , int32x4x3_t, vld3q_s32, vst1q_s32);
|
||||
SPLIT3_KERNEL_TEMPLATE(VSplit3, float , float32x4x3_t, vld3q_f32, vst1q_f32);
|
||||
SPLIT3_KERNEL_TEMPLATE(VSplit3, int64 , int64x1x3_t, vld3_s64 , vst1_s64 );
|
||||
|
||||
SPLIT4_KERNEL_TEMPLATE(VSplit4, uchar , uint8x16x4_t, vld4q_u8 , vst1q_u8 );
|
||||
SPLIT4_KERNEL_TEMPLATE(VSplit4, schar , int8x16x4_t, vld4q_s8 , vst1q_s8 );
|
||||
SPLIT4_KERNEL_TEMPLATE(VSplit4, ushort, uint16x8x4_t, vld4q_u16, vst1q_u16);
|
||||
SPLIT4_KERNEL_TEMPLATE(VSplit4, short , int16x8x4_t, vld4q_s16, vst1q_s16);
|
||||
SPLIT4_KERNEL_TEMPLATE(VSplit4, int , int32x4x4_t, vld4q_s32, vst1q_s32);
|
||||
SPLIT4_KERNEL_TEMPLATE(VSplit4, float , float32x4x4_t, vld4q_f32, vst1q_f32);
|
||||
SPLIT4_KERNEL_TEMPLATE(VSplit4, int64 , int64x1x4_t, vld4_s64 , vst1_s64 );
|
||||
#endif
|
||||
|
||||
template<typename T> static void
|
||||
split_( const T* src, T** dst, int len, int cn )
|
||||
{
|
||||
@ -58,13 +123,34 @@ split_( const T* src, T** dst, int len, int cn )
|
||||
if( k == 1 )
|
||||
{
|
||||
T* dst0 = dst[0];
|
||||
for( i = j = 0; i < len; i++, j += cn )
|
||||
dst0[i] = src[j];
|
||||
|
||||
if(cn == 1)
|
||||
{
|
||||
memcpy(dst0, src, len * sizeof(T));
|
||||
}
|
||||
else
|
||||
{
|
||||
for( i = 0, j = 0 ; i < len; i++, j += cn )
|
||||
dst0[i] = src[j];
|
||||
}
|
||||
}
|
||||
else if( k == 2 )
|
||||
{
|
||||
T *dst0 = dst[0], *dst1 = dst[1];
|
||||
for( i = j = 0; i < len; i++, j += cn )
|
||||
i = j = 0;
|
||||
|
||||
#if CV_NEON
|
||||
if(cn == 2)
|
||||
{
|
||||
int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
|
||||
int inc_j = 2 * inc_i;
|
||||
|
||||
VSplit2<T> vsplit;
|
||||
for( ; i < len - inc_i; i += inc_i, j += inc_j)
|
||||
vsplit(src + j, dst0 + i, dst1 + i);
|
||||
}
|
||||
#endif
|
||||
for( ; i < len; i++, j += cn )
|
||||
{
|
||||
dst0[i] = src[j];
|
||||
dst1[i] = src[j+1];
|
||||
@ -73,7 +159,20 @@ split_( const T* src, T** dst, int len, int cn )
|
||||
else if( k == 3 )
|
||||
{
|
||||
T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2];
|
||||
for( i = j = 0; i < len; i++, j += cn )
|
||||
i = j = 0;
|
||||
|
||||
#if CV_NEON
|
||||
if(cn == 3)
|
||||
{
|
||||
int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
|
||||
int inc_j = 3 * inc_i;
|
||||
|
||||
VSplit3<T> vsplit;
|
||||
for( ; i < len - inc_i; i += inc_i, j += inc_j)
|
||||
vsplit(src + j, dst0 + i, dst1 + i, dst2 + i);
|
||||
}
|
||||
#endif
|
||||
for( ; i < len; i++, j += cn )
|
||||
{
|
||||
dst0[i] = src[j];
|
||||
dst1[i] = src[j+1];
|
||||
@ -83,7 +182,20 @@ split_( const T* src, T** dst, int len, int cn )
|
||||
else
|
||||
{
|
||||
T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2], *dst3 = dst[3];
|
||||
for( i = j = 0; i < len; i++, j += cn )
|
||||
i = j = 0;
|
||||
|
||||
#if CV_NEON
|
||||
if(cn == 4)
|
||||
{
|
||||
int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
|
||||
int inc_j = 4 * inc_i;
|
||||
|
||||
VSplit4<T> vsplit;
|
||||
for( ; i < len - inc_i; i += inc_i, j += inc_j)
|
||||
vsplit(src + j, dst0 + i, dst1 + i, dst2 + i, dst3 + i);
|
||||
}
|
||||
#endif
|
||||
for( ; i < len; i++, j += cn )
|
||||
{
|
||||
dst0[i] = src[j]; dst1[i] = src[j+1];
|
||||
dst2[i] = src[j+2]; dst3[i] = src[j+3];
|
||||
@ -101,6 +213,77 @@ split_( const T* src, T** dst, int len, int cn )
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#if CV_NEON
|
||||
template<typename T> struct VMerge2;
|
||||
template<typename T> struct VMerge3;
|
||||
template<typename T> struct VMerge4;
|
||||
|
||||
#define MERGE2_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func) \
|
||||
template<> \
|
||||
struct name<data_type>{ \
|
||||
void operator()(const data_type* src0, const data_type* src1, \
|
||||
data_type* dst){ \
|
||||
reg_type r; \
|
||||
r.val[0] = load_func(src0); \
|
||||
r.val[1] = load_func(src1); \
|
||||
store_func(dst, r); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define MERGE3_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func) \
|
||||
template<> \
|
||||
struct name<data_type>{ \
|
||||
void operator()(const data_type* src0, const data_type* src1, \
|
||||
const data_type* src2, data_type* dst){ \
|
||||
reg_type r; \
|
||||
r.val[0] = load_func(src0); \
|
||||
r.val[1] = load_func(src1); \
|
||||
r.val[2] = load_func(src2); \
|
||||
store_func(dst, r); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define MERGE4_KERNEL_TEMPLATE(name, data_type, reg_type, load_func, store_func) \
|
||||
template<> \
|
||||
struct name<data_type>{ \
|
||||
void operator()(const data_type* src0, const data_type* src1, \
|
||||
const data_type* src2, const data_type* src3, \
|
||||
data_type* dst){ \
|
||||
reg_type r; \
|
||||
r.val[0] = load_func(src0); \
|
||||
r.val[1] = load_func(src1); \
|
||||
r.val[2] = load_func(src2); \
|
||||
r.val[3] = load_func(src3); \
|
||||
store_func(dst, r); \
|
||||
} \
|
||||
}
|
||||
|
||||
MERGE2_KERNEL_TEMPLATE(VMerge2, uchar , uint8x16x2_t, vld1q_u8 , vst2q_u8 );
|
||||
MERGE2_KERNEL_TEMPLATE(VMerge2, schar , int8x16x2_t, vld1q_s8 , vst2q_s8 );
|
||||
MERGE2_KERNEL_TEMPLATE(VMerge2, ushort, uint16x8x2_t, vld1q_u16, vst2q_u16);
|
||||
MERGE2_KERNEL_TEMPLATE(VMerge2, short , int16x8x2_t, vld1q_s16, vst2q_s16);
|
||||
MERGE2_KERNEL_TEMPLATE(VMerge2, int , int32x4x2_t, vld1q_s32, vst2q_s32);
|
||||
MERGE2_KERNEL_TEMPLATE(VMerge2, float , float32x4x2_t, vld1q_f32, vst2q_f32);
|
||||
MERGE2_KERNEL_TEMPLATE(VMerge2, int64 , int64x1x2_t, vld1_s64 , vst2_s64 );
|
||||
|
||||
MERGE3_KERNEL_TEMPLATE(VMerge3, uchar , uint8x16x3_t, vld1q_u8 , vst3q_u8 );
|
||||
MERGE3_KERNEL_TEMPLATE(VMerge3, schar , int8x16x3_t, vld1q_s8 , vst3q_s8 );
|
||||
MERGE3_KERNEL_TEMPLATE(VMerge3, ushort, uint16x8x3_t, vld1q_u16, vst3q_u16);
|
||||
MERGE3_KERNEL_TEMPLATE(VMerge3, short , int16x8x3_t, vld1q_s16, vst3q_s16);
|
||||
MERGE3_KERNEL_TEMPLATE(VMerge3, int , int32x4x3_t, vld1q_s32, vst3q_s32);
|
||||
MERGE3_KERNEL_TEMPLATE(VMerge3, float , float32x4x3_t, vld1q_f32, vst3q_f32);
|
||||
MERGE3_KERNEL_TEMPLATE(VMerge3, int64 , int64x1x3_t, vld1_s64 , vst3_s64 );
|
||||
|
||||
MERGE4_KERNEL_TEMPLATE(VMerge4, uchar , uint8x16x4_t, vld1q_u8 , vst4q_u8 );
|
||||
MERGE4_KERNEL_TEMPLATE(VMerge4, schar , int8x16x4_t, vld1q_s8 , vst4q_s8 );
|
||||
MERGE4_KERNEL_TEMPLATE(VMerge4, ushort, uint16x8x4_t, vld1q_u16, vst4q_u16);
|
||||
MERGE4_KERNEL_TEMPLATE(VMerge4, short , int16x8x4_t, vld1q_s16, vst4q_s16);
|
||||
MERGE4_KERNEL_TEMPLATE(VMerge4, int , int32x4x4_t, vld1q_s32, vst4q_s32);
|
||||
MERGE4_KERNEL_TEMPLATE(VMerge4, float , float32x4x4_t, vld1q_f32, vst4q_f32);
|
||||
MERGE4_KERNEL_TEMPLATE(VMerge4, int64 , int64x1x4_t, vld1_s64 , vst4_s64 );
|
||||
#endif
|
||||
|
||||
template<typename T> static void
|
||||
merge_( const T** src, T* dst, int len, int cn )
|
||||
{
|
||||
@ -115,7 +298,19 @@ merge_( const T** src, T* dst, int len, int cn )
|
||||
else if( k == 2 )
|
||||
{
|
||||
const T *src0 = src[0], *src1 = src[1];
|
||||
for( i = j = 0; i < len; i++, j += cn )
|
||||
i = j = 0;
|
||||
#if CV_NEON
|
||||
if(cn == 2)
|
||||
{
|
||||
int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
|
||||
int inc_j = 2 * inc_i;
|
||||
|
||||
VMerge2<T> vmerge;
|
||||
for( ; i < len - inc_i; i += inc_i, j += inc_j)
|
||||
vmerge(src0 + i, src1 + i, dst + j);
|
||||
}
|
||||
#endif
|
||||
for( ; i < len; i++, j += cn )
|
||||
{
|
||||
dst[j] = src0[i];
|
||||
dst[j+1] = src1[i];
|
||||
@ -124,7 +319,19 @@ merge_( const T** src, T* dst, int len, int cn )
|
||||
else if( k == 3 )
|
||||
{
|
||||
const T *src0 = src[0], *src1 = src[1], *src2 = src[2];
|
||||
for( i = j = 0; i < len; i++, j += cn )
|
||||
i = j = 0;
|
||||
#if CV_NEON
|
||||
if(cn == 3)
|
||||
{
|
||||
int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
|
||||
int inc_j = 3 * inc_i;
|
||||
|
||||
VMerge3<T> vmerge;
|
||||
for( ; i < len - inc_i; i += inc_i, j += inc_j)
|
||||
vmerge(src0 + i, src1 + i, src2 + i, dst + j);
|
||||
}
|
||||
#endif
|
||||
for( ; i < len; i++, j += cn )
|
||||
{
|
||||
dst[j] = src0[i];
|
||||
dst[j+1] = src1[i];
|
||||
@ -134,7 +341,19 @@ merge_( const T** src, T* dst, int len, int cn )
|
||||
else
|
||||
{
|
||||
const T *src0 = src[0], *src1 = src[1], *src2 = src[2], *src3 = src[3];
|
||||
for( i = j = 0; i < len; i++, j += cn )
|
||||
i = j = 0;
|
||||
#if CV_NEON
|
||||
if(cn == 4)
|
||||
{
|
||||
int inc_i = (sizeof(T) == 8)? 1: 16/sizeof(T);
|
||||
int inc_j = 4 * inc_i;
|
||||
|
||||
VMerge4<T> vmerge;
|
||||
for( ; i < len - inc_i; i += inc_i, j += inc_j)
|
||||
vmerge(src0 + i, src1 + i, src2 + i, src3 + i, dst + j);
|
||||
}
|
||||
#endif
|
||||
for( ; i < len; i++, j += cn )
|
||||
{
|
||||
dst[j] = src0[i]; dst[j+1] = src1[i];
|
||||
dst[j+2] = src2[i]; dst[j+3] = src3[i];
|
||||
|
||||
@ -46,7 +46,7 @@
|
||||
// */
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_core.hpp"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
|
||||
@ -42,7 +42,7 @@
|
||||
#include "precomp.hpp"
|
||||
#include "opencv2/core/opencl/runtime/opencl_clamdfft.hpp"
|
||||
#include "opencv2/core/opencl/runtime/opencl_core.hpp"
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_core.hpp"
|
||||
#include <map>
|
||||
|
||||
namespace cv
|
||||
@ -1801,11 +1801,11 @@ private:
|
||||
UMat twiddles;
|
||||
String buildOptions;
|
||||
int thread_count;
|
||||
bool status;
|
||||
int dft_size;
|
||||
bool status;
|
||||
|
||||
public:
|
||||
OCL_FftPlan(int _size): dft_size(_size), status(true)
|
||||
OCL_FftPlan(int _size) : dft_size(_size), status(true)
|
||||
{
|
||||
int min_radix;
|
||||
std::vector<int> radixes, blocks;
|
||||
@ -2635,8 +2635,8 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
|
||||
|
||||
for( i = 0; i < nonzero_rows; i++ )
|
||||
{
|
||||
uchar* sptr = src.data + i*src.step;
|
||||
uchar* dptr0 = dst.data + i*dst.step;
|
||||
const uchar* sptr = src.ptr(i);
|
||||
uchar* dptr0 = dst.ptr(i);
|
||||
uchar* dptr = dptr0;
|
||||
|
||||
if( tmp_buf )
|
||||
@ -2649,7 +2649,7 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
|
||||
|
||||
for( ; i < count; i++ )
|
||||
{
|
||||
uchar* dptr0 = dst.data + i*dst.step;
|
||||
uchar* dptr0 = dst.ptr(i);
|
||||
memset( dptr0, 0, dst_full_len );
|
||||
}
|
||||
|
||||
@ -2661,7 +2661,7 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
|
||||
{
|
||||
int a = 0, b = count;
|
||||
uchar *buf0, *buf1, *dbuf0, *dbuf1;
|
||||
uchar* sptr0 = src.data;
|
||||
const uchar* sptr0 = src.data;
|
||||
uchar* dptr0 = dst.data;
|
||||
buf0 = ptr;
|
||||
ptr += len*complex_elem_size;
|
||||
@ -2800,7 +2800,7 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
|
||||
int n = dst.cols;
|
||||
if( elem_size == (int)sizeof(float) )
|
||||
{
|
||||
float* p0 = (float*)dst.data;
|
||||
float* p0 = dst.ptr<float>();
|
||||
size_t dstep = dst.step/sizeof(p0[0]);
|
||||
for( i = 0; i < len; i++ )
|
||||
{
|
||||
@ -2816,7 +2816,7 @@ void cv::dft( InputArray _src0, OutputArray _dst, int flags, int nonzero_rows )
|
||||
}
|
||||
else
|
||||
{
|
||||
double* p0 = (double*)dst.data;
|
||||
double* p0 = dst.ptr<double>();
|
||||
size_t dstep = dst.step/sizeof(p0[0]);
|
||||
for( i = 0; i < len; i++ )
|
||||
{
|
||||
|
||||
@ -955,10 +955,10 @@ double cv::invert( InputArray _src, OutputArray _dst, int method )
|
||||
SVD::compute(src, w, u, vt);
|
||||
SVD::backSubst(w, u, vt, Mat(), _dst);
|
||||
return type == CV_32F ?
|
||||
(((float*)w.data)[0] >= FLT_EPSILON ?
|
||||
((float*)w.data)[n-1]/((float*)w.data)[0] : 0) :
|
||||
(((double*)w.data)[0] >= DBL_EPSILON ?
|
||||
((double*)w.data)[n-1]/((double*)w.data)[0] : 0);
|
||||
(w.ptr<float>()[0] >= FLT_EPSILON ?
|
||||
w.ptr<float>()[n-1]/w.ptr<float>()[0] : 0) :
|
||||
(w.ptr<double>()[0] >= DBL_EPSILON ?
|
||||
w.ptr<double>()[n-1]/w.ptr<double>()[0] : 0);
|
||||
}
|
||||
|
||||
CV_Assert( m == n );
|
||||
@ -975,10 +975,10 @@ double cv::invert( InputArray _src, OutputArray _dst, int method )
|
||||
transpose(vt, u);
|
||||
SVD::backSubst(w, u, vt, Mat(), _dst);
|
||||
return type == CV_32F ?
|
||||
(((float*)w.data)[0] >= FLT_EPSILON ?
|
||||
((float*)w.data)[n-1]/((float*)w.data)[0] : 0) :
|
||||
(((double*)w.data)[0] >= DBL_EPSILON ?
|
||||
((double*)w.data)[n-1]/((double*)w.data)[0] : 0);
|
||||
(w.ptr<float>()[0] >= FLT_EPSILON ?
|
||||
w.ptr<float>()[n-1]/w.ptr<float>()[0] : 0) :
|
||||
(w.ptr<double>()[0] >= DBL_EPSILON ?
|
||||
w.ptr<double>()[n-1]/w.ptr<double>()[0] : 0);
|
||||
}
|
||||
|
||||
CV_Assert( method == DECOMP_LU || method == DECOMP_CHOLESKY );
|
||||
@ -988,7 +988,7 @@ double cv::invert( InputArray _src, OutputArray _dst, int method )
|
||||
|
||||
if( n <= 3 )
|
||||
{
|
||||
uchar* srcdata = src.data;
|
||||
const uchar* srcdata = src.data;
|
||||
uchar* dstdata = dst.data;
|
||||
size_t srcstep = src.step;
|
||||
size_t dststep = dst.step;
|
||||
@ -1212,8 +1212,8 @@ bool cv::solve( InputArray _src, InputArray _src2arg, OutputArray _dst, int meth
|
||||
#define bf(y) ((float*)(bdata + y*src2step))[0]
|
||||
#define bd(y) ((double*)(bdata + y*src2step))[0]
|
||||
|
||||
uchar* srcdata = src.data;
|
||||
uchar* bdata = _src2.data;
|
||||
const uchar* srcdata = src.data;
|
||||
const uchar* bdata = _src2.data;
|
||||
uchar* dstdata = dst.data;
|
||||
size_t srcstep = src.step;
|
||||
size_t src2step = _src2.step;
|
||||
@ -1557,13 +1557,17 @@ static void _SVDcompute( InputArray _aarr, OutputArray _w,
|
||||
{
|
||||
if( !at )
|
||||
{
|
||||
transpose(temp_u, _u);
|
||||
temp_v.copyTo(_vt);
|
||||
if( _u.needed() )
|
||||
transpose(temp_u, _u);
|
||||
if( _vt.needed() )
|
||||
temp_v.copyTo(_vt);
|
||||
}
|
||||
else
|
||||
{
|
||||
transpose(temp_v, _u);
|
||||
temp_u.copyTo(_vt);
|
||||
if( _u.needed() )
|
||||
transpose(temp_v, _u);
|
||||
if( _vt.needed() )
|
||||
temp_u.copyTo(_vt);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1705,7 +1709,7 @@ cvEigenVV( CvArr* srcarr, CvArr* evectsarr, CvArr* evalsarr, double,
|
||||
eigen(src, evals, evects);
|
||||
if( evects0.data != evects.data )
|
||||
{
|
||||
uchar* p = evects0.data;
|
||||
const uchar* p = evects0.data;
|
||||
evects.convertTo(evects0, evects0.type());
|
||||
CV_Assert( p == evects0.data );
|
||||
}
|
||||
@ -1714,7 +1718,7 @@ cvEigenVV( CvArr* srcarr, CvArr* evectsarr, CvArr* evalsarr, double,
|
||||
eigen(src, evals);
|
||||
if( evals0.data != evals.data )
|
||||
{
|
||||
uchar* p = evals0.data;
|
||||
const uchar* p = evals0.data;
|
||||
if( evals0.size() == evals.size() )
|
||||
evals.convertTo(evals0, evals0.type());
|
||||
else if( evals0.type() == evals.type() )
|
||||
|
||||
1119
modules/core/src/lda.cpp
Normal file
1119
modules/core/src/lda.cpp
Normal file
File diff suppressed because it is too large
Load Diff
@ -41,7 +41,7 @@
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_core.hpp"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
|
||||
@ -41,7 +41,7 @@
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_core.hpp"
|
||||
#include "opencv2/core/opencl/runtime/opencl_clamdblas.hpp"
|
||||
|
||||
namespace cv
|
||||
@ -3295,7 +3295,6 @@ void cv::PCABackProject(InputArray data, InputArray mean,
|
||||
pca.backProject(data, result);
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************************\
|
||||
* Earlier API *
|
||||
\****************************************************************************************/
|
||||
|
||||
@ -41,7 +41,7 @@
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_core.hpp"
|
||||
|
||||
#include "bufferpool.impl.hpp"
|
||||
|
||||
@ -346,7 +346,7 @@ static void finalizeHdr(Mat& m)
|
||||
if( d > 2 )
|
||||
m.rows = m.cols = -1;
|
||||
if(m.u)
|
||||
m.data = m.datastart = m.u->data;
|
||||
m.datastart = m.data = m.u->data;
|
||||
if( m.data )
|
||||
{
|
||||
m.datalimit = m.datastart + m.size[0]*m.step[0];
|
||||
@ -510,7 +510,7 @@ Mat::Mat(int _dims, const int* _sizes, int _type, void* _data, const size_t* _st
|
||||
datalimit(0), allocator(0), u(0), size(&rows)
|
||||
{
|
||||
flags |= CV_MAT_TYPE(_type);
|
||||
data = datastart = (uchar*)_data;
|
||||
datastart = data = (uchar*)_data;
|
||||
setSize(*this, _dims, _sizes, _steps, true);
|
||||
finalizeHdr(*this);
|
||||
}
|
||||
@ -549,7 +549,7 @@ static Mat cvMatNDToMat(const CvMatND* m, bool copyData)
|
||||
|
||||
if( !m )
|
||||
return thiz;
|
||||
thiz.data = thiz.datastart = m->data.ptr;
|
||||
thiz.datastart = thiz.data = m->data.ptr;
|
||||
thiz.flags |= CV_MAT_TYPE(m->type);
|
||||
int _sizes[CV_MAX_DIM];
|
||||
size_t _steps[CV_MAX_DIM];
|
||||
@ -587,7 +587,7 @@ static Mat cvMatToMat(const CvMat* m, bool copyData)
|
||||
thiz.dims = 2;
|
||||
thiz.rows = m->rows;
|
||||
thiz.cols = m->cols;
|
||||
thiz.data = thiz.datastart = m->data.ptr;
|
||||
thiz.datastart = thiz.data = m->data.ptr;
|
||||
size_t esz = CV_ELEM_SIZE(m->type), minstep = thiz.cols*esz, _step = m->step;
|
||||
if( _step == 0 )
|
||||
_step = minstep;
|
||||
@ -597,7 +597,7 @@ static Mat cvMatToMat(const CvMat* m, bool copyData)
|
||||
}
|
||||
else
|
||||
{
|
||||
thiz.data = thiz.datastart = thiz.dataend = 0;
|
||||
thiz.datastart = thiz.dataend = thiz.data = 0;
|
||||
Mat(m->rows, m->cols, m->type, m->data.ptr, m->step).copyTo(thiz);
|
||||
}
|
||||
|
||||
@ -636,7 +636,7 @@ static Mat iplImageToMat(const IplImage* img, bool copyData)
|
||||
m.rows = img->roi->height;
|
||||
m.cols = img->roi->width;
|
||||
esz = CV_ELEM_SIZE(m.flags);
|
||||
m.data = m.datastart = (uchar*)img->imageData +
|
||||
m.datastart = m.data = (uchar*)img->imageData +
|
||||
(selectedPlane ? (img->roi->coi - 1)*m.step*img->height : 0) +
|
||||
img->roi->yOffset*m.step[0] + img->roi->xOffset*esz;
|
||||
}
|
||||
@ -2758,15 +2758,18 @@ namespace cv {
|
||||
|
||||
static bool ocl_setIdentity( InputOutputArray _m, const Scalar& s )
|
||||
{
|
||||
int type = _m.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type), kercn = cn;
|
||||
if (cn == 1)
|
||||
int type = _m.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type), kercn = cn, rowsPerWI = 1;
|
||||
int sctype = CV_MAKE_TYPE(depth, cn == 3 ? 4 : cn);
|
||||
if (ocl::Device::getDefault().isIntel())
|
||||
{
|
||||
kercn = std::min(ocl::predictOptimalVectorWidth(_m), 4);
|
||||
if (kercn != 4)
|
||||
kercn = 1;
|
||||
rowsPerWI = 4;
|
||||
if (cn == 1)
|
||||
{
|
||||
kercn = std::min(ocl::predictOptimalVectorWidth(_m), 4);
|
||||
if (kercn != 4)
|
||||
kercn = 1;
|
||||
}
|
||||
}
|
||||
int sctype = CV_MAKE_TYPE(depth, cn == 3 ? 4 : cn),
|
||||
rowsPerWI = ocl::Device::getDefault().isIntel() ? 4 : 1;
|
||||
|
||||
ocl::Kernel k("setIdentity", ocl::core::set_identity_oclsrc,
|
||||
format("-D T=%s -D T1=%s -D cn=%d -D ST=%s -D kercn=%d -D rowsPerWI=%d",
|
||||
@ -5529,14 +5532,14 @@ double norm( const SparseMat& src, int normType )
|
||||
{
|
||||
if( normType == NORM_INF )
|
||||
for( i = 0; i < N; i++, ++it )
|
||||
result = std::max(result, std::abs((double)*(const float*)it.ptr));
|
||||
result = std::max(result, std::abs((double)it.value<float>()));
|
||||
else if( normType == NORM_L1 )
|
||||
for( i = 0; i < N; i++, ++it )
|
||||
result += std::abs(*(const float*)it.ptr);
|
||||
result += std::abs(it.value<float>());
|
||||
else
|
||||
for( i = 0; i < N; i++, ++it )
|
||||
{
|
||||
double v = *(const float*)it.ptr;
|
||||
double v = it.value<float>();
|
||||
result += v*v;
|
||||
}
|
||||
}
|
||||
@ -5544,14 +5547,14 @@ double norm( const SparseMat& src, int normType )
|
||||
{
|
||||
if( normType == NORM_INF )
|
||||
for( i = 0; i < N; i++, ++it )
|
||||
result = std::max(result, std::abs(*(const double*)it.ptr));
|
||||
result = std::max(result, std::abs(it.value<double>()));
|
||||
else if( normType == NORM_L1 )
|
||||
for( i = 0; i < N; i++, ++it )
|
||||
result += std::abs(*(const double*)it.ptr);
|
||||
result += std::abs(it.value<double>());
|
||||
else
|
||||
for( i = 0; i < N; i++, ++it )
|
||||
{
|
||||
double v = *(const double*)it.ptr;
|
||||
double v = it.value<double>();
|
||||
result += v*v;
|
||||
}
|
||||
}
|
||||
@ -5575,7 +5578,7 @@ void minMaxLoc( const SparseMat& src, double* _minval, double* _maxval, int* _mi
|
||||
float minval = FLT_MAX, maxval = -FLT_MAX;
|
||||
for( i = 0; i < N; i++, ++it )
|
||||
{
|
||||
float v = *(const float*)it.ptr;
|
||||
float v = it.value<float>();
|
||||
if( v < minval )
|
||||
{
|
||||
minval = v;
|
||||
@ -5597,7 +5600,7 @@ void minMaxLoc( const SparseMat& src, double* _minval, double* _maxval, int* _mi
|
||||
double minval = DBL_MAX, maxval = -DBL_MAX;
|
||||
for( i = 0; i < N; i++, ++it )
|
||||
{
|
||||
double v = *(const double*)it.ptr;
|
||||
double v = it.value<double>();
|
||||
if( v < minval )
|
||||
{
|
||||
minval = v;
|
||||
|
||||
@ -57,6 +57,28 @@
|
||||
# endif
|
||||
#endif
|
||||
|
||||
|
||||
// TODO Move to some common place
|
||||
static bool getBoolParameter(const char* name, bool defaultValue)
|
||||
{
|
||||
const char* envValue = getenv(name);
|
||||
if (envValue == NULL)
|
||||
{
|
||||
return defaultValue;
|
||||
}
|
||||
cv::String value = envValue;
|
||||
if (value == "1" || value == "True" || value == "true" || value == "TRUE")
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (value == "0" || value == "False" || value == "false" || value == "FALSE")
|
||||
{
|
||||
return false;
|
||||
}
|
||||
CV_ErrorNoReturn(cv::Error::StsBadArg, cv::format("Invalid value for %s parameter: %s", name, value.c_str()));
|
||||
}
|
||||
|
||||
|
||||
// TODO Move to some common place
|
||||
static size_t getConfigurationParameterForSize(const char* name, size_t defaultValue)
|
||||
{
|
||||
@ -1305,7 +1327,18 @@ OCL_FUNC(cl_int, clReleaseEvent, (cl_event event), (event))
|
||||
#ifdef _DEBUG
|
||||
#define CV_OclDbgAssert CV_DbgAssert
|
||||
#else
|
||||
#define CV_OclDbgAssert(expr) (void)(expr)
|
||||
static bool isRaiseError()
|
||||
{
|
||||
static bool initialized = false;
|
||||
static bool value = false;
|
||||
if (!initialized)
|
||||
{
|
||||
value = getBoolParameter("OPENCV_OPENCL_RAISE_ERROR", false);
|
||||
initialized = true;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
#define CV_OclDbgAssert(expr) do { if (isRaiseError()) { CV_Assert(expr); } else { (void)(expr); } } while ((void)0, 0)
|
||||
#endif
|
||||
|
||||
namespace cv { namespace ocl {
|
||||
@ -4711,4 +4744,16 @@ void* Image2D::ptr() const
|
||||
return p ? p->handle : 0;
|
||||
}
|
||||
|
||||
bool isPerformanceCheckBypassed()
|
||||
{
|
||||
static bool initialized = false;
|
||||
static bool value = false;
|
||||
if (!initialized)
|
||||
{
|
||||
value = getBoolParameter("OPENCV_OPENCL_PERF_CHECK_BYPASS", false);
|
||||
initialized = true;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
@ -424,7 +424,7 @@ void fft_radix3_B3(__local float2* smem, __global const float2* twiddles, const
|
||||
const int x3 = x2 + t/3;
|
||||
float2 a0, a1, a2, a3, a4, a5, a6, a7, a8;
|
||||
|
||||
if (x1 < t/2)
|
||||
if (x1 < t/3)
|
||||
{
|
||||
a0 = smem[x1]; a1 = smem[x1+t]; a2 = smem[x1+2*t];
|
||||
a3 = smem[x2]; a4 = smem[x2+t]; a5 = smem[x2+2*t];
|
||||
@ -433,7 +433,7 @@ void fft_radix3_B3(__local float2* smem, __global const float2* twiddles, const
|
||||
|
||||
barrier(CLK_LOCAL_MEM_FENCE);
|
||||
|
||||
if (x1 < t/2)
|
||||
if (x1 < t/3)
|
||||
{
|
||||
butterfly3(a0, a1, a2, smem, twiddles, x1, block_size);
|
||||
butterfly3(a3, a4, a5, smem, twiddles, x2, block_size);
|
||||
|
||||
@ -59,7 +59,7 @@ __kernel void meanStdDev(__global const uchar * srcptr, int src_step, int src_of
|
||||
for (int grain = groups * WGS; id < total; id += grain)
|
||||
{
|
||||
#ifdef HAVE_MASK
|
||||
#ifdef HAVE_SRC_CONT
|
||||
#ifdef HAVE_MASK_CONT
|
||||
int mask_index = id;
|
||||
#else
|
||||
int mask_index = mad24(id / cols, mask_step, id % cols);
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "../../precomp.hpp"
|
||||
|
||||
#ifdef HAVE_CLAMDBLAS
|
||||
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "../../precomp.hpp"
|
||||
|
||||
#ifdef HAVE_CLAMDFFT
|
||||
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "../../precomp.hpp"
|
||||
|
||||
#if defined(HAVE_OPENCL) && !defined(HAVE_OPENCL_STATIC)
|
||||
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
#include <climits>
|
||||
#include <limits>
|
||||
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_core.hpp"
|
||||
|
||||
namespace cv
|
||||
{
|
||||
@ -568,7 +568,7 @@ cv::Scalar cv::sum( InputArray _src )
|
||||
{
|
||||
#ifdef HAVE_OPENCL
|
||||
Scalar _res;
|
||||
CV_OCL_RUN_(_src.isUMat() && _src.dims() <= 2,
|
||||
CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
|
||||
ocl_sum(_src, _res, OCL_OP_SUM),
|
||||
_res)
|
||||
#endif
|
||||
@ -719,7 +719,7 @@ int cv::countNonZero( InputArray _src )
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
int res = -1;
|
||||
CV_OCL_RUN_(_src.isUMat() && _src.dims() <= 2,
|
||||
CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
|
||||
ocl_countNonZero(_src, res),
|
||||
res)
|
||||
#endif
|
||||
@ -782,7 +782,7 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
|
||||
int type = src.type();
|
||||
if( !mask.empty() )
|
||||
{
|
||||
typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *);
|
||||
typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC1)(const void *, int, const void *, int, IppiSize, Ipp64f *);
|
||||
ippiMaskMeanFuncC1 ippFuncC1 =
|
||||
type == CV_8UC1 ? (ippiMaskMeanFuncC1)ippiMean_8u_C1MR :
|
||||
type == CV_16UC1 ? (ippiMaskMeanFuncC1)ippiMean_16u_C1MR :
|
||||
@ -795,7 +795,7 @@ cv::Scalar cv::mean( InputArray _src, InputArray _mask )
|
||||
return Scalar(res);
|
||||
setIppErrorStatus();
|
||||
}
|
||||
typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *);
|
||||
typedef IppStatus (CV_STDCALL* ippiMaskMeanFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *);
|
||||
ippiMaskMeanFuncC3 ippFuncC3 =
|
||||
type == CV_8UC3 ? (ippiMaskMeanFuncC3)ippiMean_8u_C3CMR :
|
||||
type == CV_16UC3 ? (ippiMaskMeanFuncC3)ippiMean_16u_C3CMR :
|
||||
@ -918,7 +918,8 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv
|
||||
{
|
||||
int type = _src.type(), depth = CV_MAT_DEPTH(type), cn = CV_MAT_CN(type);
|
||||
bool doubleSupport = ocl::Device::getDefault().doubleFPConfig() > 0,
|
||||
isContinuous = _src.isContinuous();
|
||||
isContinuous = _src.isContinuous(),
|
||||
isMaskContinuous = _mask.isContinuous();
|
||||
const ocl::Device &defDev = ocl::Device::getDefault();
|
||||
int groups = defDev.maxComputeUnits();
|
||||
if (defDev.isIntel())
|
||||
@ -943,13 +944,14 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv
|
||||
|
||||
char cvt[2][40];
|
||||
String opts = format("-D srcT=%s -D srcT1=%s -D dstT=%s -D dstT1=%s -D sqddepth=%d"
|
||||
" -D sqdstT=%s -D sqdstT1=%s -D convertToSDT=%s -D cn=%d%s"
|
||||
" -D sqdstT=%s -D sqdstT1=%s -D convertToSDT=%s -D cn=%d%s%s"
|
||||
" -D convertToDT=%s -D WGS=%d -D WGS2_ALIGNED=%d%s%s",
|
||||
ocl::typeToStr(type), ocl::typeToStr(depth),
|
||||
ocl::typeToStr(dtype), ocl::typeToStr(ddepth), sqddepth,
|
||||
ocl::typeToStr(sqdtype), ocl::typeToStr(sqddepth),
|
||||
ocl::convertTypeStr(depth, sqddepth, cn, cvt[0]),
|
||||
cn, isContinuous ? " -D HAVE_SRC_CONT" : "",
|
||||
isMaskContinuous ? " -D HAVE_MASK_CONT" : "",
|
||||
ocl::convertTypeStr(depth, ddepth, cn, cvt[1]),
|
||||
(int)wgs, wgs2_aligned, haveMask ? " -D HAVE_MASK" : "",
|
||||
doubleSupport ? " -D DOUBLE_SUPPORT" : "");
|
||||
@ -1025,7 +1027,7 @@ static bool ocl_meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv
|
||||
|
||||
void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, InputArray _mask )
|
||||
{
|
||||
CV_OCL_RUN(_src.isUMat() && _src.dims() <= 2,
|
||||
CV_OCL_RUN(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
|
||||
ocl_meanStdDev(_src, _mean, _sdv, _mask))
|
||||
|
||||
Mat src = _src.getMat(), mask = _mask.getMat();
|
||||
@ -1069,7 +1071,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
|
||||
int type = src.type();
|
||||
if( !mask.empty() )
|
||||
{
|
||||
typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC1)(const void *, int, void *, int, IppiSize, Ipp64f *, Ipp64f *);
|
||||
typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC1)(const void *, int, const void *, int, IppiSize, Ipp64f *, Ipp64f *);
|
||||
ippiMaskMeanStdDevFuncC1 ippFuncC1 =
|
||||
type == CV_8UC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_8u_C1MR :
|
||||
type == CV_16UC1 ? (ippiMaskMeanStdDevFuncC1)ippiMean_StdDev_16u_C1MR :
|
||||
@ -1081,7 +1083,7 @@ void cv::meanStdDev( InputArray _src, OutputArray _mean, OutputArray _sdv, Input
|
||||
return;
|
||||
setIppErrorStatus();
|
||||
}
|
||||
typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC3)(const void *, int, void *, int, IppiSize, int, Ipp64f *, Ipp64f *);
|
||||
typedef IppStatus (CV_STDCALL* ippiMaskMeanStdDevFuncC3)(const void *, int, const void *, int, IppiSize, int, Ipp64f *, Ipp64f *);
|
||||
ippiMaskMeanStdDevFuncC3 ippFuncC3 =
|
||||
type == CV_8UC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_8u_C3CMR :
|
||||
type == CV_16UC3 ? (ippiMaskMeanStdDevFuncC3)ippiMean_StdDev_16u_C3CMR :
|
||||
@ -1571,7 +1573,7 @@ void cv::minMaxIdx(InputArray _src, double* minVal,
|
||||
CV_Assert( (cn == 1 && (_mask.empty() || _mask.type() == CV_8U)) ||
|
||||
(cn > 1 && _mask.empty() && !minIdx && !maxIdx) );
|
||||
|
||||
CV_OCL_RUN(_src.isUMat() && _src.dims() <= 2 && (_mask.empty() || _src.size() == _mask.size()),
|
||||
CV_OCL_RUN(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2 && (_mask.empty() || _src.size() == _mask.size()),
|
||||
ocl_minMaxIdx(_src, minVal, maxVal, minIdx, maxIdx, _mask))
|
||||
|
||||
Mat src = _src.getMat(), mask = _mask.getMat();
|
||||
@ -2234,7 +2236,7 @@ double cv::norm( InputArray _src, int normType, InputArray _mask )
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
double _result = 0;
|
||||
CV_OCL_RUN_(_src.isUMat() && _src.dims() <= 2,
|
||||
CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src.isUMat()) && _src.dims() <= 2,
|
||||
ocl_norm(_src, normType, _mask, _result),
|
||||
_result)
|
||||
#endif
|
||||
@ -2594,7 +2596,7 @@ double cv::norm( InputArray _src1, InputArray _src2, int normType, InputArray _m
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
double _result = 0;
|
||||
CV_OCL_RUN_(_src1.isUMat(),
|
||||
CV_OCL_RUN_(OCL_PERFORMANCE_CHECK(_src1.isUMat()),
|
||||
ocl_norm(_src1, _src2, normType, _mask, _result),
|
||||
_result)
|
||||
#endif
|
||||
|
||||
@ -41,7 +41,7 @@
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_core.hpp"
|
||||
|
||||
///////////////////////////////// UMat implementation ///////////////////////////////
|
||||
|
||||
@ -582,7 +582,7 @@ Mat UMat::getMat(int accessFlags) const
|
||||
hdr.flags = flags;
|
||||
hdr.u = u;
|
||||
hdr.datastart = u->data;
|
||||
hdr.data = hdr.datastart + offset;
|
||||
hdr.data = u->data + offset;
|
||||
hdr.datalimit = hdr.dataend = u->data + u->size;
|
||||
CV_XADD(&hdr.u->refcount, 1);
|
||||
return hdr;
|
||||
@ -593,15 +593,16 @@ void* UMat::handle(int accessFlags) const
|
||||
if( !u )
|
||||
return 0;
|
||||
|
||||
if ((accessFlags & ACCESS_WRITE) != 0)
|
||||
u->markHostCopyObsolete(true);
|
||||
|
||||
// check flags: if CPU copy is newer, copy it back to GPU.
|
||||
if( u->deviceCopyObsolete() )
|
||||
{
|
||||
CV_Assert(u->refcount == 0);
|
||||
u->currAllocator->unmap(u);
|
||||
}
|
||||
|
||||
if ((accessFlags & ACCESS_WRITE) != 0)
|
||||
u->markHostCopyObsolete(true);
|
||||
|
||||
return u->handle;
|
||||
}
|
||||
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
#include "../test_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_test.hpp"
|
||||
|
||||
#include <cmath>
|
||||
@ -157,6 +157,7 @@ PARAM_TEST_CASE(ArithmTestBase, MatDepth, Channels, bool)
|
||||
Border maskBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
|
||||
randomSubMat(mask, mask_roi, roiSize, maskBorder, CV_8UC1, 0, 2);
|
||||
cv::threshold(mask, mask, 0.5, 255., CV_8UC1);
|
||||
*mask.ptr(0) = 255; // prevent test case with mask filled 0 only
|
||||
|
||||
val = cv::Scalar(rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0),
|
||||
rng.uniform(-100.0, 100.0), rng.uniform(-100.0, 100.0));
|
||||
@ -1419,7 +1420,7 @@ OCL_TEST_P(UMatDot, Mat)
|
||||
OCL_OFF(const double cpuRes = src1_roi.dot(src2_roi));
|
||||
OCL_ON(const double gpuRes = usrc1_roi.dot(usrc2_roi));
|
||||
|
||||
EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-6);
|
||||
EXPECT_PRED3(relativeError, cpuRes, gpuRes, 1e-5);
|
||||
}
|
||||
}
|
||||
|
||||
@ -1749,7 +1750,7 @@ OCL_TEST_P(ReduceAvg, Mat)
|
||||
OCL_OFF(cv::reduce(src_roi, dst_roi, dim, CV_REDUCE_AVG, dtype));
|
||||
OCL_ON(cv::reduce(usrc_roi, udst_roi, dim, CV_REDUCE_AVG, dtype));
|
||||
|
||||
double eps = ddepth <= CV_32S ? 1 : 5e-6;
|
||||
double eps = ddepth <= CV_32S ? 1 : 6e-6;
|
||||
OCL_EXPECT_MATS_NEAR(dst, eps);
|
||||
}
|
||||
}
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
#include "../test_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_test.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
@ -105,6 +105,7 @@ PARAM_TEST_CASE(Merge, MatDepth, int, bool)
|
||||
UMAT_UPLOAD_INPUT_PARAMETER(src3);
|
||||
UMAT_UPLOAD_INPUT_PARAMETER(src4);
|
||||
|
||||
src_roi.clear(); usrc_roi.clear(); // for test_loop_times > 1
|
||||
src_roi.push_back(src1_roi), usrc_roi.push_back(usrc1_roi);
|
||||
if (nsrc >= 2)
|
||||
src_roi.push_back(src2_roi), usrc_roi.push_back(usrc2_roi);
|
||||
|
||||
@ -43,7 +43,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
#include "../test_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_test.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
@ -108,7 +108,7 @@ OCL_TEST_P(Dft, Mat)
|
||||
{
|
||||
generateTestData();
|
||||
|
||||
int nonzero_rows = hint ? src.cols - randomInt(1, src.rows-1) : 0;
|
||||
int nonzero_rows = hint ? src.rows - randomInt(1, src.rows-1) : 0;
|
||||
OCL_OFF(cv::dft(src, dst, dft_flags, nonzero_rows));
|
||||
OCL_ON(cv::dft(usrc, udst, dft_flags, nonzero_rows));
|
||||
|
||||
@ -175,7 +175,7 @@ OCL_TEST_P(MulSpectrums, Mat)
|
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(OCL_ImgProc, MulSpectrums, testing::Combine(Bool(), Bool()));
|
||||
|
||||
OCL_INSTANTIATE_TEST_CASE_P(Core, Dft, Combine(Values(cv::Size(10, 10), cv::Size(36, 36), cv::Size(512, 1), cv::Size(1280, 768)),
|
||||
OCL_INSTANTIATE_TEST_CASE_P(Core, Dft, Combine(Values(cv::Size(45, 72), cv::Size(36, 36), cv::Size(512, 1), cv::Size(1280, 768)),
|
||||
Values((OCL_FFT_TYPE) R2C, (OCL_FFT_TYPE) C2C, (OCL_FFT_TYPE) R2R, (OCL_FFT_TYPE) C2R),
|
||||
Bool(), // DFT_INVERSE
|
||||
Bool(), // DFT_ROWS
|
||||
|
||||
@ -42,7 +42,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
#include "../test_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_test.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -5,7 +5,7 @@
|
||||
// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
#include "../test_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_test.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -44,7 +44,7 @@
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
#include "../test_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_test.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
@ -96,7 +96,7 @@ OCL_TEST_P(ConvertTo, Accuracy)
|
||||
OCL_OFF(src_roi.convertTo(dst_roi, dstType, alpha, beta));
|
||||
OCL_ON(usrc_roi.convertTo(udst_roi, dstType, alpha, beta));
|
||||
|
||||
double eps = src_depth >= CV_32F || CV_MAT_DEPTH(dstType) >= CV_32F ? 1e-4 : 1;
|
||||
double eps = CV_MAT_DEPTH(dstType) >= CV_32F ? 2e-4 : 1;
|
||||
OCL_EXPECT_MATS_NEAR(dst, eps);
|
||||
}
|
||||
}
|
||||
@ -121,7 +121,7 @@ PARAM_TEST_CASE(CopyTo, MatDepth, Channels, bool, bool)
|
||||
use_mask = GET_PARAM(3);
|
||||
}
|
||||
|
||||
void generateTestData()
|
||||
void generateTestData(bool one_cn_mask = false)
|
||||
{
|
||||
const int type = CV_MAKE_TYPE(depth, cn);
|
||||
|
||||
@ -132,9 +132,11 @@ PARAM_TEST_CASE(CopyTo, MatDepth, Channels, bool, bool)
|
||||
if (use_mask)
|
||||
{
|
||||
Border maskBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
|
||||
int mask_cn = randomDouble(0.0, 2.0) > 1.0 ? cn : 1;
|
||||
int mask_cn = 1;
|
||||
if (!one_cn_mask && randomDouble(0.0, 2.0) > 1.0)
|
||||
mask_cn = cn;
|
||||
randomSubMat(mask, mask_roi, roiSize, maskBorder, CV_8UC(mask_cn), 0, 2);
|
||||
cv::threshold(mask, mask, 0.5, 255., CV_8UC1);
|
||||
cv::threshold(mask, mask, 0.5, 255., THRESH_BINARY);
|
||||
}
|
||||
|
||||
Border dstBorder = randomBorder(0, use_roi ? MAX_VALUE : 0);
|
||||
@ -177,7 +179,7 @@ OCL_TEST_P(SetTo, Accuracy)
|
||||
{
|
||||
for (int j = 0; j < test_loop_times; j++)
|
||||
{
|
||||
generateTestData();
|
||||
generateTestData(true); // see modules/core/src/umatrix.cpp Ln:791 => CV_Assert( mask.size() == size() && mask.type() == CV_8UC1 );
|
||||
|
||||
if (use_mask)
|
||||
{
|
||||
|
||||
@ -649,6 +649,16 @@ static void setValue(SparseMat& M, const int* idx, double value, RNG& rng)
|
||||
CV_Error(CV_StsUnsupportedFormat, "");
|
||||
}
|
||||
|
||||
template<typename Pixel>
|
||||
struct InitializerFunctor{
|
||||
/// Initializer for cv::Mat::forEach test
|
||||
void operator()(Pixel & pixel, const int * idx) const {
|
||||
pixel.x = idx[0];
|
||||
pixel.y = idx[1];
|
||||
pixel.z = idx[2];
|
||||
}
|
||||
};
|
||||
|
||||
void Core_ArrayOpTest::run( int /* start_from */)
|
||||
{
|
||||
int errcount = 0;
|
||||
@ -686,6 +696,45 @@ void Core_ArrayOpTest::run( int /* start_from */)
|
||||
errcount++;
|
||||
}
|
||||
}
|
||||
// test cv::Mat::forEach
|
||||
{
|
||||
const int dims[3] = { 101, 107, 7 };
|
||||
typedef cv::Point3i Pixel;
|
||||
|
||||
cv::Mat a = cv::Mat::zeros(3, dims, CV_32SC3);
|
||||
InitializerFunctor<Pixel> initializer;
|
||||
|
||||
a.forEach<Pixel>(initializer);
|
||||
|
||||
uint64 total = 0;
|
||||
bool error_reported = false;
|
||||
for (int i0 = 0; i0 < dims[0]; ++i0) {
|
||||
for (int i1 = 0; i1 < dims[1]; ++i1) {
|
||||
for (int i2 = 0; i2 < dims[2]; ++i2) {
|
||||
Pixel& pixel = a.at<Pixel>(i0, i1, i2);
|
||||
if (pixel.x != i0 || pixel.y != i1 || pixel.z != i2) {
|
||||
if (!error_reported) {
|
||||
ts->printf(cvtest::TS::LOG, "forEach is not correct.\n"
|
||||
"First error detected at (%d, %d, %d).\n", pixel.x, pixel.y, pixel.z);
|
||||
error_reported = true;
|
||||
}
|
||||
errcount++;
|
||||
}
|
||||
total += pixel.x;
|
||||
total += pixel.y;
|
||||
total += pixel.z;
|
||||
}
|
||||
}
|
||||
}
|
||||
uint64 total2 = 0;
|
||||
for (size_t i = 0; i < sizeof(dims) / sizeof(dims[0]); ++i) {
|
||||
total2 += ((dims[i] - 1) * dims[i] / 2) * dims[0] * dims[1] * dims[2] / dims[i];
|
||||
}
|
||||
if (total != total2) {
|
||||
ts->printf(cvtest::TS::LOG, "forEach is not correct because total is invalid.\n");
|
||||
errcount++;
|
||||
}
|
||||
}
|
||||
|
||||
RNG rng;
|
||||
const int MAX_DIM = 5, MAX_DIM_SZ = 10;
|
||||
|
||||
@ -745,6 +745,24 @@ TEST(UMat, Sync)
|
||||
EXPECT_EQ(0, cvtest::norm(um.getMat(ACCESS_READ), cv::Mat(um.size(), um.type(), 19), NORM_INF));
|
||||
}
|
||||
|
||||
TEST(UMat, CopyToIfDeviceCopyIsObsolete)
|
||||
{
|
||||
UMat um(7, 2, CV_8UC1);
|
||||
Mat m(um.size(), um.type());
|
||||
m.setTo(Scalar::all(0));
|
||||
|
||||
{
|
||||
// make obsolete device copy of UMat
|
||||
Mat temp = um.getMat(ACCESS_WRITE);
|
||||
temp.setTo(Scalar::all(10));
|
||||
}
|
||||
|
||||
m.copyTo(um);
|
||||
um.setTo(Scalar::all(17));
|
||||
|
||||
EXPECT_EQ(0, cvtest::norm(um.getMat(ACCESS_READ), Mat(um.size(), um.type(), 17), NORM_INF));
|
||||
}
|
||||
|
||||
TEST(UMat, setOpenCL)
|
||||
{
|
||||
// save the current state
|
||||
|
||||
@ -23,7 +23,5 @@ endif()
|
||||
|
||||
ocv_create_module(${extra_libs})
|
||||
|
||||
ocv_add_precompiled_headers(${the_module})
|
||||
|
||||
ocv_add_accuracy_tests(DEPENDS_ON opencv_imgproc)
|
||||
ocv_add_perf_tests(DEPENDS_ON opencv_imgproc)
|
||||
|
||||
@ -23,7 +23,5 @@ endif()
|
||||
|
||||
ocv_create_module(${extra_libs})
|
||||
|
||||
ocv_add_precompiled_headers(${the_module})
|
||||
|
||||
ocv_add_accuracy_tests()
|
||||
ocv_add_perf_tests()
|
||||
|
||||
@ -6,4 +6,4 @@ set(the_description "CUDA-accelerated Optical Flow")
|
||||
|
||||
ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4127 /wd4324 /wd4512 -Wundef -Wmissing-declarations)
|
||||
|
||||
ocv_define_module(cudaoptflow opencv_video opencv_legacy opencv_cudaarithm opencv_cudawarping opencv_cudaimgproc OPTIONAL opencv_cudalegacy)
|
||||
ocv_define_module(cudaoptflow opencv_video opencv_cudaarithm opencv_cudawarping opencv_cudaimgproc OPTIONAL opencv_cudalegacy)
|
||||
|
||||
@ -41,7 +41,6 @@
|
||||
//M*/
|
||||
|
||||
#include "perf_precomp.hpp"
|
||||
#include "opencv2/legacy.hpp"
|
||||
|
||||
using namespace std;
|
||||
using namespace testing;
|
||||
@ -389,24 +388,6 @@ PERF_TEST_P(ImagePair, OpticalFlowDual_TVL1,
|
||||
//////////////////////////////////////////////////////
|
||||
// OpticalFlowBM
|
||||
|
||||
void calcOpticalFlowBM(const cv::Mat& prev, const cv::Mat& curr,
|
||||
cv::Size bSize, cv::Size shiftSize, cv::Size maxRange, int usePrevious,
|
||||
cv::Mat& velx, cv::Mat& vely)
|
||||
{
|
||||
cv::Size sz((curr.cols - bSize.width + shiftSize.width)/shiftSize.width, (curr.rows - bSize.height + shiftSize.height)/shiftSize.height);
|
||||
|
||||
velx.create(sz, CV_32FC1);
|
||||
vely.create(sz, CV_32FC1);
|
||||
|
||||
CvMat cvprev = prev;
|
||||
CvMat cvcurr = curr;
|
||||
|
||||
CvMat cvvelx = velx;
|
||||
CvMat cvvely = vely;
|
||||
|
||||
cvCalcOpticalFlowBM(&cvprev, &cvcurr, bSize, shiftSize, maxRange, usePrevious, &cvvelx, &cvvely);
|
||||
}
|
||||
|
||||
PERF_TEST_P(ImagePair, OpticalFlowBM,
|
||||
Values<pair_string>(make_pair("gpu/opticalflow/frame0.png", "gpu/opticalflow/frame1.png")))
|
||||
{
|
||||
@ -435,12 +416,7 @@ PERF_TEST_P(ImagePair, OpticalFlowBM,
|
||||
}
|
||||
else
|
||||
{
|
||||
cv::Mat u, v;
|
||||
|
||||
TEST_CYCLE() calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, u, v);
|
||||
|
||||
CPU_SANITY_CHECK(u);
|
||||
CPU_SANITY_CHECK(v);
|
||||
FAIL_NO_CPU();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -41,7 +41,6 @@
|
||||
//M*/
|
||||
|
||||
#include "test_precomp.hpp"
|
||||
#include "opencv2/legacy.hpp"
|
||||
|
||||
#ifdef HAVE_CUDA
|
||||
|
||||
@ -370,65 +369,6 @@ INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, OpticalFlowDual_TVL1, testing::Combine(
|
||||
ALL_DEVICES,
|
||||
WHOLE_SUBMAT));
|
||||
|
||||
//////////////////////////////////////////////////////
|
||||
// OpticalFlowBM
|
||||
|
||||
namespace
|
||||
{
|
||||
void calcOpticalFlowBM(const cv::Mat& prev, const cv::Mat& curr,
|
||||
cv::Size bSize, cv::Size shiftSize, cv::Size maxRange, int usePrevious,
|
||||
cv::Mat& velx, cv::Mat& vely)
|
||||
{
|
||||
cv::Size sz((curr.cols - bSize.width + shiftSize.width)/shiftSize.width, (curr.rows - bSize.height + shiftSize.height)/shiftSize.height);
|
||||
|
||||
velx.create(sz, CV_32FC1);
|
||||
vely.create(sz, CV_32FC1);
|
||||
|
||||
CvMat cvprev = prev;
|
||||
CvMat cvcurr = curr;
|
||||
|
||||
CvMat cvvelx = velx;
|
||||
CvMat cvvely = vely;
|
||||
|
||||
cvCalcOpticalFlowBM(&cvprev, &cvcurr, bSize, shiftSize, maxRange, usePrevious, &cvvelx, &cvvely);
|
||||
}
|
||||
}
|
||||
|
||||
struct OpticalFlowBM : testing::TestWithParam<cv::cuda::DeviceInfo>
|
||||
{
|
||||
};
|
||||
|
||||
CUDA_TEST_P(OpticalFlowBM, Accuracy)
|
||||
{
|
||||
cv::cuda::DeviceInfo devInfo = GetParam();
|
||||
cv::cuda::setDevice(devInfo.deviceID());
|
||||
|
||||
cv::Mat frame0 = readImage("opticalflow/rubberwhale1.png", cv::IMREAD_GRAYSCALE);
|
||||
ASSERT_FALSE(frame0.empty());
|
||||
cv::resize(frame0, frame0, cv::Size(), 0.5, 0.5);
|
||||
|
||||
cv::Mat frame1 = readImage("opticalflow/rubberwhale2.png", cv::IMREAD_GRAYSCALE);
|
||||
ASSERT_FALSE(frame1.empty());
|
||||
cv::resize(frame1, frame1, cv::Size(), 0.5, 0.5);
|
||||
|
||||
cv::Size block_size(8, 8);
|
||||
cv::Size shift_size(1, 1);
|
||||
cv::Size max_range(8, 8);
|
||||
|
||||
cv::cuda::GpuMat d_velx, d_vely, buf;
|
||||
cv::cuda::calcOpticalFlowBM(loadMat(frame0), loadMat(frame1),
|
||||
block_size, shift_size, max_range, false,
|
||||
d_velx, d_vely, buf);
|
||||
|
||||
cv::Mat velx, vely;
|
||||
calcOpticalFlowBM(frame0, frame1, block_size, shift_size, max_range, false, velx, vely);
|
||||
|
||||
EXPECT_MAT_NEAR(velx, d_velx, 0);
|
||||
EXPECT_MAT_NEAR(vely, d_vely, 0);
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_CASE_P(CUDA_OptFlow, OpticalFlowBM, ALL_DEVICES);
|
||||
|
||||
//////////////////////////////////////////////////////
|
||||
// FastOpticalFlowBM
|
||||
|
||||
|
||||
@ -29,7 +29,7 @@ if(OCV_DEPENDENCIES_FOUND)
|
||||
endforeach()
|
||||
|
||||
CUDA_ADD_EXECUTABLE(${the_target} ${OPENCV_TEST_${the_module}_SOURCES})
|
||||
target_link_libraries(${the_target} ${test_deps} ${OPENCV_LINKER_LIBS} ${CUDA_LIBRARIES})
|
||||
ocv_target_link_libraries(${the_target} ${test_deps} ${OPENCV_LINKER_LIBS} ${CUDA_LIBRARIES})
|
||||
add_dependencies(opencv_tests ${the_target})
|
||||
|
||||
# Additional target properties
|
||||
|
||||
@ -43,7 +43,7 @@
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
#include "perf_precomp.hpp"
|
||||
#include "../perf_precomp.hpp"
|
||||
#include "opencv2/ts/ocl_perf.hpp"
|
||||
|
||||
#ifdef HAVE_OPENCL
|
||||
|
||||
@ -427,7 +427,7 @@ BRISK::smoothedIntensity(const cv::Mat& image, const cv::Mat& integral, const fl
|
||||
if (dx + dy > 2)
|
||||
{
|
||||
// now the calculation:
|
||||
uchar* ptr = image.data + x_left + imagecols * y_top;
|
||||
const uchar* ptr = image.data + x_left + imagecols * y_top;
|
||||
// first the corners:
|
||||
ret_val = A * int(*ptr);
|
||||
ptr += dx + 1;
|
||||
@ -475,7 +475,7 @@ BRISK::smoothedIntensity(const cv::Mat& image, const cv::Mat& integral, const fl
|
||||
}
|
||||
|
||||
// now the calculation:
|
||||
uchar* ptr = image.data + x_left + imagecols * y_top;
|
||||
const uchar* ptr = image.data + x_left + imagecols * y_top;
|
||||
// first row:
|
||||
ret_val = A * int(*ptr);
|
||||
ptr++;
|
||||
@ -487,7 +487,7 @@ BRISK::smoothedIntensity(const cv::Mat& image, const cv::Mat& integral, const fl
|
||||
ret_val += B * int(*ptr);
|
||||
// middle ones:
|
||||
ptr += imagecols - dx - 1;
|
||||
uchar* end_j = ptr + dy * imagecols;
|
||||
const uchar* end_j = ptr + dy * imagecols;
|
||||
for (; ptr < end_j; ptr += imagecols - dx - 1)
|
||||
{
|
||||
ret_val += r_x_1_i * int(*ptr);
|
||||
@ -607,7 +607,7 @@ BRISK::computeDescriptorsAndOrOrientation(InputArray _image, InputArray _mask, s
|
||||
int t2;
|
||||
|
||||
// the feature orientation
|
||||
uchar* ptr = descriptors.data;
|
||||
const uchar* ptr = descriptors.data;
|
||||
for (size_t k = 0; k < ksize; k++)
|
||||
{
|
||||
cv::KeyPoint& kp = keypoints[k];
|
||||
@ -1070,7 +1070,7 @@ BriskScaleSpace::isMax2D(const int layer, const int x_layer, const int y_layer)
|
||||
{
|
||||
const cv::Mat& scores = pyramid_[layer].scores();
|
||||
const int scorescols = scores.cols;
|
||||
uchar* data = scores.data + y_layer * scorescols + x_layer;
|
||||
const uchar* data = scores.data + y_layer * scorescols + x_layer;
|
||||
// decision tree:
|
||||
const uchar center = (*data);
|
||||
data--;
|
||||
@ -2140,7 +2140,7 @@ BriskLayer::value(const cv::Mat& mat, float xf, float yf, float scale_in) const
|
||||
const int r_y = (int)((yf - y) * 1024);
|
||||
const int r_x_1 = (1024 - r_x);
|
||||
const int r_y_1 = (1024 - r_y);
|
||||
uchar* ptr = image.data + x + y * imagecols;
|
||||
const uchar* ptr = image.data + x + y * imagecols;
|
||||
// just interpolate:
|
||||
ret_val = (r_x_1 * r_y_1 * int(*ptr));
|
||||
ptr++;
|
||||
@ -2186,7 +2186,7 @@ BriskLayer::value(const cv::Mat& mat, float xf, float yf, float scale_in) const
|
||||
const int r_y1_i = (int)(r_y1 * scaling);
|
||||
|
||||
// now the calculation:
|
||||
uchar* ptr = image.data + x_left + imagecols * y_top;
|
||||
const uchar* ptr = image.data + x_left + imagecols * y_top;
|
||||
// first row:
|
||||
ret_val = A * int(*ptr);
|
||||
ptr++;
|
||||
@ -2198,7 +2198,7 @@ BriskLayer::value(const cv::Mat& mat, float xf, float yf, float scale_in) const
|
||||
ret_val += B * int(*ptr);
|
||||
// middle ones:
|
||||
ptr += imagecols - dx - 1;
|
||||
uchar* end_j = ptr + dy * imagecols;
|
||||
const uchar* end_j = ptr + dy * imagecols;
|
||||
for (; ptr < end_j; ptr += imagecols - dx - 1)
|
||||
{
|
||||
ret_val += r_x_1_i * int(*ptr);
|
||||
|
||||
@ -43,7 +43,7 @@ The references are:
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include "fast_score.hpp"
|
||||
#include "opencl_kernels.hpp"
|
||||
#include "opencl_kernels_features2d.hpp"
|
||||
|
||||
#if defined _MSC_VER
|
||||
# pragma warning( disable : 4127)
|
||||
|
||||
@ -45,7 +45,6 @@ namespace cv
|
||||
{
|
||||
|
||||
static const double FREAK_SQRT2 = 1.4142135623731;
|
||||
static const double FREAK_INV_SQRT2 = 1.0 / FREAK_SQRT2;
|
||||
static const double FREAK_LOG2 = 0.693147180559945;
|
||||
static const int FREAK_NB_ORIENTATION = 256;
|
||||
static const int FREAK_NB_POINTS = 43;
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
|
||||
/* ************************************************************************* */
|
||||
// OpenCV
|
||||
#include "precomp.hpp"
|
||||
#include "../precomp.hpp"
|
||||
#include <opencv2/features2d.hpp>
|
||||
|
||||
/* ************************************************************************* */
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
|
||||
/* ************************************************************************* */
|
||||
// Includes
|
||||
#include "precomp.hpp"
|
||||
#include "../precomp.hpp"
|
||||
#include "AKAZEConfig.h"
|
||||
#include "TEvolution.h"
|
||||
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
#define __OPENCV_FEATURES_2D_AKAZE_CONFIG_H__
|
||||
|
||||
// OpenCV Includes
|
||||
#include "precomp.hpp"
|
||||
#include "../precomp.hpp"
|
||||
#include <opencv2/features2d.hpp>
|
||||
|
||||
//*************************************************************************************
|
||||
|
||||
@ -28,7 +28,7 @@
|
||||
* DAGM, 2010
|
||||
*
|
||||
*/
|
||||
#include "precomp.hpp"
|
||||
#include "../precomp.hpp"
|
||||
#include "fed.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user