diff --git a/CMakeLists.txt b/CMakeLists.txt index c79338bc20..bc84df4a34 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -659,7 +659,7 @@ if(HAVE_CUDA) set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CUDA_cufft_LIBRARY}) endif() foreach(p ${CUDA_LIBS_PATH}) - set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} -L${p}) + set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${CMAKE_LIBRARY_PATH_FLAG}${p}) endforeach() endif() # ---------------------------------------------------------------------------- diff --git a/cmake/OpenCVUtils.cmake b/cmake/OpenCVUtils.cmake index 33f3dd8454..309aad9d0b 100644 --- a/cmake/OpenCVUtils.cmake +++ b/cmake/OpenCVUtils.cmake @@ -84,14 +84,10 @@ macro(ocv_check_environment_variables) endforeach() endmacro() -macro(ocv_path_join result_var P1 P2) - string(REGEX REPLACE "^[/]+" "" P2 "${P2}") - if("${P1}" STREQUAL "") - if("${P2}" STREQUAL "") - set(${result_var} ".") - else() - set(${result_var} "${P2}") - endif() +macro(ocv_path_join result_var P1 P2_) + string(REGEX REPLACE "^[/]+" "" P2 "${P2_}") + if("${P1}" STREQUAL "" OR "${P1}" STREQUAL ".") + set(${result_var} "${P2}") elseif("${P1}" STREQUAL "/") set(${result_var} "/${P2}") elseif("${P2}" STREQUAL "") @@ -99,6 +95,11 @@ macro(ocv_path_join result_var P1 P2) else() set(${result_var} "${P1}/${P2}") endif() + string(REGEX REPLACE "([/\\]?)[\\.][/\\]" "\\1" ${result_var} "${${result_var}}") + if("${${result_var}}" STREQUAL "") + set(${result_var} ".") + endif() + #message(STATUS "'${P1}' '${P2_}' => '${${result_var}}'") endmacro() # rename modules target to world if needed diff --git a/doc/pattern_tools/gen_pattern.py b/doc/pattern_tools/gen_pattern.py index ebeeb123fe..85b3ea4955 100755 --- a/doc/pattern_tools/gen_pattern.py +++ b/doc/pattern_tools/gen_pattern.py @@ -61,7 +61,7 @@ class PatternMaker: def save(self): c = canvas(self.g,width="%d%s"%(self.width,self.units),height="%d%s"%(self.height,self.units),viewBox="0 0 %d %d"%(self.width,self.height)) - c.inkview(self.output) + c.save(self.output) def main(): diff --git a/modules/core/include/opencv2/core/persistence.hpp b/modules/core/include/opencv2/core/persistence.hpp index 15454165ad..65a1ff4c4c 100644 --- a/modules/core/include/opencv2/core/persistence.hpp +++ b/modules/core/include/opencv2/core/persistence.hpp @@ -89,6 +89,8 @@ the extension of the opened file, ".xml" for XML files and ".yml" or ".yaml" for */ typedef struct CvFileStorage CvFileStorage; typedef struct CvFileNode CvFileNode; +typedef struct CvMat CvMat; +typedef struct CvMatND CvMatND; //! @} core_c @@ -1238,6 +1240,17 @@ inline String::String(const FileNode& fn): cstr_(0), len_(0) { read(fn, *this, * //! @endcond + +CV_EXPORTS void cvStartWriteRawData_Base64(::CvFileStorage * fs, const char* name, int len, const char* dt); + +CV_EXPORTS void cvWriteRawData_Base64(::CvFileStorage * fs, const void* _data, int len); + +CV_EXPORTS void cvEndWriteRawData_Base64(::CvFileStorage * fs); + +CV_EXPORTS void cvWriteMat_Base64(::CvFileStorage* fs, const char* name, const ::CvMat* mat); + +CV_EXPORTS void cvWriteMatND_Base64(::CvFileStorage* fs, const char* name, const ::CvMatND* mat); + } // cv -#endif // __OPENCV_CORE_PERSISTENCE_HPP__ +#endif // __OPENCV_CORE_PERSISTENCE_HPP__ \ No newline at end of file diff --git a/modules/core/include/opencv2/core/types.hpp b/modules/core/include/opencv2/core/types.hpp index e166556af7..2feedfcca8 100644 --- a/modules/core/include/opencv2/core/types.hpp +++ b/modules/core/include/opencv2/core/types.hpp @@ -231,7 +231,11 @@ public: //! conversion to another data type template operator Point3_<_Tp2>() const; //! conversion to cv::Vec<> +#if OPENCV_ABI_COMPATIBILITY > 300 + template operator Vec<_Tp2, 3>() const; +#else operator Vec<_Tp, 3>() const; +#endif //! dot product _Tp dot(const Point3_& pt) const; @@ -1326,11 +1330,19 @@ Point3_<_Tp>::operator Point3_<_Tp2>() const return Point3_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y), saturate_cast<_Tp2>(z)); } +#if OPENCV_ABI_COMPATIBILITY > 300 +template template inline +Point3_<_Tp>::operator Vec<_Tp2, 3>() const +{ + return Vec<_Tp2, 3>(x, y, z); +} +#else template inline Point3_<_Tp>::operator Vec<_Tp, 3>() const { return Vec<_Tp, 3>(x, y, z); } +#endif template inline Point3_<_Tp>& Point3_<_Tp>::operator = (const Point3_& pt) diff --git a/modules/core/include/opencv2/core/utility.hpp b/modules/core/include/opencv2/core/utility.hpp index 60b2d3a064..7e7a8b2b51 100644 --- a/modules/core/include/opencv2/core/utility.hpp +++ b/modules/core/include/opencv2/core/utility.hpp @@ -817,10 +817,10 @@ AutoBuffer<_Tp, fixed_size>::allocate(size_t _size) return; } deallocate(); + sz = _size; if(_size > fixed_size) { ptr = new _Tp[_size]; - sz = _size; } } diff --git a/modules/core/src/persistence.cpp b/modules/core/src/persistence.cpp index 8f9a42abe6..2fc4f9f5bb 100644 --- a/modules/core/src/persistence.cpp +++ b/modules/core/src/persistence.cpp @@ -44,6 +44,8 @@ #include #include +#include +#include #include #define USE_ZLIB 1 @@ -181,6 +183,8 @@ typedef struct CvXMLStackRecord } CvXMLStackRecord; +namespace base64 { class Base64Writer; } + #define CV_XML_OPENING_TAG 1 #define CV_XML_CLOSING_TAG 2 #define CV_XML_EMPTY_TAG 3 @@ -238,10 +242,96 @@ typedef struct CvFileStorage size_t strbufsize, strbufpos; std::deque* outbuf; + base64::Base64Writer * base64_writer; + bool is_opened; } CvFileStorage; +namespace base64 +{ + static const size_t HEADER_SIZE = 24U; + static const size_t ENCODED_HEADER_SIZE = 32U; + + /* base64 */ + + typedef uchar uint8_t; + + extern uint8_t const base64_padding; + extern uint8_t const base64_mapping[65]; + extern uint8_t const base64_demapping[127]; + + size_t base64_encode(uint8_t const * src, uint8_t * dst, size_t off, size_t cnt); + size_t base64_encode( char const * src, char * dst, size_t off = 0U, size_t cnt = 0U); + + size_t base64_decode(uint8_t const * src, uint8_t * dst, size_t off, size_t cnt); + size_t base64_decode( char const * src, char * dst, size_t off = 0U, size_t cnt = 0U); + + bool base64_valid (uint8_t const * src, size_t off, size_t cnt); + bool base64_valid ( char const * src, size_t off = 0U, size_t cnt = 0U); + + size_t base64_encode_buffer_size(size_t cnt); + + size_t base64_decode_buffer_size(size_t cnt); + + /* binary */ + + template inline size_t to_binary(_uint_t val, uchar * cur); + template<> inline size_t to_binary(double val, uchar * cur); + template<> inline size_t to_binary(float val, uchar * cur); + template inline size_t to_binary(uchar const * val, uchar * cur); + + template inline size_t binary_to(uchar const * cur, _uint_t & val); + template<> inline size_t binary_to(uchar const * cur, double & val); + template<> inline size_t binary_to(uchar const * cur, float & val); + template inline size_t binary_to(uchar const * cur, uchar * val); + + class MatToBinaryConvertor; + class RawDataToBinaryConvertor; + + class BinaryToCvSeqConvertor; + + /* class */ + + class Base64ContextParser + { + public: + explicit Base64ContextParser(uchar * buffer, size_t size); + ~Base64ContextParser(); + Base64ContextParser & read(const uchar * beg, const uchar * end); + bool flush(); + private: + static const size_t BUFFER_LEN = 120U; + uchar * dst_cur; + uchar * dst_end; + std::vector base64_buffer; + uchar * src_beg; + uchar * src_cur; + uchar * src_end; + std::vector binary_buffer; + }; + + class Base64ContextEmitter; + + /* other */ + + std::string make_base64_header(int byte_size, const char * dt); + + bool read_base64_header(std::string const & header, int & byte_size, std::string & dt); + + void make_seq(void * binary_data, int elem_cnt, const char * dt, CvSeq & seq); + + /* sample */ + + void cvStartWriteRawData_Base64(::CvFileStorage * fs, const char* name, int len, const char* dt); + void cvWriteRawData_Base64(::CvFileStorage * fs, const void* _data, int len); + void cvEndWriteRawData_Base64(::CvFileStorage * fs); + + void cvWriteRawData_Base64(::cv::FileStorage & fs, const void* _data, int len, const char* dt); + void cvWriteMat_Base64(CvFileStorage * fs, const char * name, ::cv::Mat const & mat); +} + + static void icvPuts( CvFileStorage* fs, const char* str ) { if( fs->outbuf ) @@ -995,6 +1085,95 @@ icvYMLSkipSpaces( CvFileStorage* fs, char* ptr, int min_indent, int max_comment_ } +static void icvYMLGetMultilineStringContent(CvFileStorage* fs, + char* ptr, int indent, char* &beg, char* &end) +{ + ptr = icvYMLSkipSpaces(fs, ptr, 0, INT_MAX); + beg = ptr; + end = ptr; + if (fs->dummy_eof) + return ; /* end of file */ + + if (ptr - fs->buffer_start != indent) + return ; /* end of string */ + + /* find end */ + while(cv_isprint(*ptr)) /* no check for base64 string */ + ++ ptr; + if (*ptr == '\0') + CV_PARSE_ERROR("Unexpected end of line"); + + end = ptr; +} + +static int icvCalcStructSize( const char* dt, int initial_size ); + +static char* icvYMLParseBase64(CvFileStorage* fs, char* ptr, int indent, CvFileNode * node) +{ + char * beg = 0; + char * end = 0; + + icvYMLGetMultilineStringContent(fs, ptr, indent, beg, end); + if (beg >= end) + return end; // CV_PARSE_ERROR("Empty Binary Data"); + + /* calc (decoded) total_byte_size from header */ + std::string dt; + int total_byte_size = -1; + { + if (end - beg < static_cast(base64::ENCODED_HEADER_SIZE)) + CV_PARSE_ERROR("Unrecognized Base64 header"); + + std::vector header(base64::HEADER_SIZE + 1, ' '); + base64::base64_decode(beg, header.data(), 0U, base64::ENCODED_HEADER_SIZE); + std::istringstream iss(header.data()); + + if (!(iss >> total_byte_size) || total_byte_size < 0) + CV_PARSE_ERROR("Cannot parse size in Base64 header"); + if (!(iss >> dt) || dt.empty()) + CV_PARSE_ERROR("Cannot parse dt in Base64 header"); + + beg += base64::ENCODED_HEADER_SIZE; + } + + /* buffer for decoded data(exclude header) */ + std::vector buffer(total_byte_size + 4); + { + base64::Base64ContextParser parser(buffer.data(), total_byte_size + 4); + + /* decoding */ + while(beg < end) + { + /* save this part [beg, end) */ + parser.read((const uchar *)beg, (const uchar *)end); + + beg = end; + + /* find next part */ + icvYMLGetMultilineStringContent(fs, beg, indent, beg, end); + } + } + /* save as CvSeq */ + int elem_size = ::icvCalcStructSize(dt.c_str(), 0); + if (total_byte_size % elem_size != 0) + CV_PARSE_ERROR("Byte size not match elememt size"); + int elem_cnt = total_byte_size / elem_size; + + node->tag = CV_NODE_NONE; + int struct_flags = CV_NODE_FLOW + CV_NODE_SEQ; /* after icvFSCreateCollection, node->tag == struct_flags */ + icvFSCreateCollection(fs, struct_flags, node); + base64::make_seq(buffer.data(), elem_cnt, dt.c_str(), *node->data.seq); + + if (fs->dummy_eof) { + /* end of file */ + return fs->buffer_start; + } else { + /* end of line */ + return end; + } +} + + static char* icvYMLParseKey( CvFileStorage* fs, char* ptr, CvFileNode* map_node, CvFileNode** value_placeholder ) @@ -1038,6 +1217,7 @@ icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node, int is_parent_flow = CV_NODE_IS_FLOW(parent_flags); int value_type = CV_NODE_NONE; int len; + bool is_binary_string = false; memset( node, 0, sizeof(*node) ); @@ -1074,6 +1254,27 @@ icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node, if( memcmp( ptr, "float", 5 ) == 0 ) value_type = CV_NODE_REAL; } + else if (len == 6 && CV_NODE_IS_USER(value_type)) + { + if( memcmp( ptr, "binary", 6 ) == 0 ) { + value_type = CV_NODE_SEQ; + is_binary_string = true; + + /* for ignore '|' */ + + /**** operation with endptr ****/ + *endptr = d; + + do { + d = *++endptr; + if (d == '|') + break; + } while (d == ' '); + + d = *++endptr; + *endptr = '\0'; + } + } else if( CV_NODE_IS_USER(value_type) ) { node->info = cvFindType( ptr ); @@ -1088,7 +1289,7 @@ icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node, if( !CV_NODE_IS_USER(value_type) ) { - if( value_type == CV_NODE_STRING && c != '\'' && c != '\"' ) + if (value_type == CV_NODE_STRING && c != '\'' && c != '\"') goto force_string; if( value_type == CV_NODE_INT ) goto force_int; @@ -1097,7 +1298,13 @@ icvYMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node, } } - if( cv_isdigit(c) || + if (is_binary_string) + { + /* for base64 string */ + int indent = static_cast(ptr - fs->buffer_start); + ptr = icvYMLParseBase64(fs, ptr, indent, node); + } + else if( cv_isdigit(c) || ((c == '-' || c == '+') && (cv_isdigit(d) || d == '.')) || (c == '.' && cv_isalnum(d))) // a number { @@ -1355,8 +1562,9 @@ icvYMLParse( CvFileStorage* fs ) if( *ptr == '%' ) { - if( memcmp( ptr, "%YAML:", 6 ) == 0 && - memcmp( ptr, "%YAML:1.", 8 ) != 0 ) + if( memcmp( ptr, "%YAML", 5 ) == 0 && + memcmp( ptr, "%YAML:1.", 8 ) != 0 && + memcmp( ptr, "%YAML 1.", 8 ) != 0) CV_PARSE_ERROR( "Unsupported YAML version (it must be 1.x)" ); *ptr = '\0'; } @@ -1521,7 +1729,14 @@ icvYMLStartWriteStruct( CvFileStorage* fs, const char* key, int struct_flags, CV_Error( CV_StsBadArg, "Some collection type - CV_NODE_SEQ or CV_NODE_MAP, must be specified" ); - if( CV_NODE_IS_FLOW(struct_flags) ) + if (type_name && memcmp(type_name, "binary", 6) == 0) + { + /* reset struct flag. in order not to print ']' */ + struct_flags = CV_NODE_SEQ; + sprintf(buf, "!!binary |"); + data = buf; + } + else if( CV_NODE_IS_FLOW(struct_flags)) { char c = CV_NODE_IS_MAP(struct_flags) ? '{' : '['; struct_flags |= CV_NODE_FLOW; @@ -1813,6 +2028,92 @@ icvXMLSkipSpaces( CvFileStorage* fs, char* ptr, int mode ) } +static void icvXMLGetMultilineStringContent(CvFileStorage* fs, + char* ptr, char* &beg, char* &end) +{ + ptr = icvXMLSkipSpaces(fs, ptr, CV_XML_INSIDE_TAG); + beg = ptr; + end = ptr; + if (fs->dummy_eof) + return ; /* end of file */ + + if (*beg == '<') + return; /* end of string */ + + /* find end */ + while(cv_isprint(*ptr)) /* no check for base64 string */ + ++ ptr; + if (*ptr == '\0') + CV_PARSE_ERROR("Unexpected end of line"); + + end = ptr; +} + + +static char* icvXMLParseBase64(CvFileStorage* fs, char* ptr, CvFileNode * node) +{ + char * beg = 0; + char * end = 0; + + icvXMLGetMultilineStringContent(fs, ptr, beg, end); + if (beg >= end) + return end; // CV_PARSE_ERROR("Empty Binary Data"); + + /* calc (decoded) total_byte_size from header */ + std::string dt; + int total_byte_size = -1; + { + if (end - beg < static_cast(base64::ENCODED_HEADER_SIZE)) + CV_PARSE_ERROR("Unrecognized Base64 header"); + + std::vector header(base64::HEADER_SIZE + 1, ' '); + base64::base64_decode(beg, header.data(), 0U, base64::ENCODED_HEADER_SIZE); + std::istringstream iss(header.data()); + if (!(iss >> total_byte_size) || total_byte_size < 0) + CV_PARSE_ERROR("Cannot parse size in Base64 header"); + if (!(iss >> dt) || dt.empty()) + CV_PARSE_ERROR("Cannot parse dt in Base64 header"); + + beg += base64::ENCODED_HEADER_SIZE; + } + + /* alloc buffer for all decoded data(include header) */ + std::vector buffer(total_byte_size + 4); + { + base64::Base64ContextParser parser(buffer.data(), total_byte_size + 4); + + /* decoding */ + while(beg < end) + { + /* save this part [beg, end) */ + parser.read((const uchar *)beg, (const uchar *)end); + beg = end; + /* find next part */ + icvXMLGetMultilineStringContent(fs, beg, beg, end); + } + } + + /* save as CvSeq */ + int elem_size = ::icvCalcStructSize(dt.c_str(), 0); + if (total_byte_size % elem_size != 0) + CV_PARSE_ERROR("Byte size not match elememt size"); + int elem_cnt = total_byte_size / elem_size; + + node->tag = CV_NODE_NONE; + int struct_flags = CV_NODE_SEQ; /* after icvFSCreateCollection, node->tag == struct_flags */ + icvFSCreateCollection(fs, struct_flags, node); + base64::make_seq(buffer.data(), elem_cnt, dt.c_str(), *node->data.seq); + + if (fs->dummy_eof) { + /* end of file */ + return fs->buffer_start; + } else { + /* end of line */ + return end; + } +} + + static char* icvXMLParseTag( CvFileStorage* fs, char* ptr, CvStringHashNode** _tag, CvAttrList** _list, int* _tag_type ); @@ -1864,6 +2165,9 @@ icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node, assert( tag_type == CV_XML_OPENING_TAG ); + /* for base64 string */ + bool is_binary_string = false; + type_name = list ? cvAttrValue( list, "type_id" ) : 0; if( type_name ) { @@ -1873,6 +2177,11 @@ icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node, elem_type = CV_NODE_MAP; else if( strcmp( type_name, "seq" ) == 0 ) elem_type = CV_NODE_SEQ; + else if (strcmp(type_name, "binary") == 0) + { + elem_type = CV_NODE_NONE; + is_binary_string = true; + } else { info = cvFindType( type_name ); @@ -1895,7 +2204,14 @@ icvXMLParseValue( CvFileStorage* fs, char* ptr, CvFileNode* node, else elem = cvGetFileNode( fs, node, key, 1 ); - ptr = icvXMLParseValue( fs, ptr, elem, elem_type); + if (!is_binary_string) + ptr = icvXMLParseValue( fs, ptr, elem, elem_type); + else { + /* for base64 string */ + ptr = icvXMLParseBase64( fs, ptr, elem); + ptr = icvXMLSkipSpaces( fs, ptr, 0 ); + } + if( !is_noname ) elem->tag |= CV_NODE_NAMED; is_simple &= !CV_NODE_IS_COLLECTION(elem->tag); @@ -2832,7 +3148,7 @@ cvOpenFileStorage( const char* filename, CvMemStorage* dststorage, int flags, co else { if( !append ) - icvPuts( fs, "%YAML:1.0\n" ); + icvPuts( fs, "%YAML 1.0\n---\n" ); else icvPuts( fs, "...\n---\n" ); fs->start_write_struct = icvYMLStartWriteStruct; @@ -2853,7 +3169,7 @@ cvOpenFileStorage( const char* filename, CvMemStorage* dststorage, int flags, co } size_t buf_size = 1 << 20; - const char* yaml_signature = "%YAML:"; + const char* yaml_signature = "%YAML"; char buf[16]; icvGets( fs, buf, sizeof(buf)-2 ); fs->fmt = strncmp( buf, yaml_signature, strlen(yaml_signature) ) == 0 ? @@ -3074,6 +3390,29 @@ icvCalcElemSize( const char* dt, int initial_size ) } +static int +icvCalcStructSize( const char* dt, int initial_size ) +{ + int size = icvCalcElemSize( dt, initial_size ); + size_t elem_max_size = 0; + for ( const char * type = dt; *type != '\0'; type++ ) { + switch ( *type ) + { + case 'u': { if (elem_max_size < sizeof(uchar)) elem_max_size = sizeof(uchar); break; } + case 'c': { if (elem_max_size < sizeof(schar)) elem_max_size = sizeof(schar); break; } + case 'w': { if (elem_max_size < sizeof(ushort)) elem_max_size = sizeof(ushort); break; } + case 's': { if (elem_max_size < sizeof(short)) elem_max_size = sizeof(short); break; } + case 'i': { if (elem_max_size < sizeof(int)) elem_max_size = sizeof(int); break; } + case 'f': { if (elem_max_size < sizeof(float)) elem_max_size = sizeof(float); break; } + case 'd': { if (elem_max_size < sizeof(double)) elem_max_size = sizeof(double); break; } + default: break; + } + } + size = cvAlign( size, static_cast(elem_max_size) ); + return size; +} + + static int icvDecodeSimpleFormat( const char* dt ) { @@ -3166,7 +3505,7 @@ cvWriteRawData( CvFileStorage* fs, const void* _data, int len, const char* dt ) data += sizeof(size_t); break; default: - assert(0); + CV_Error( CV_StsUnsupportedFormat, "Unsupported type" ); return; } @@ -3288,7 +3627,7 @@ cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader, data += sizeof(size_t); break; default: - assert(0); + CV_Error( CV_StsUnsupportedFormat, "Unsupported type" ); return; } } @@ -3338,7 +3677,7 @@ cvReadRawDataSlice( const CvFileStorage* fs, CvSeqReader* reader, data += sizeof(size_t); break; default: - assert(0); + CV_Error( CV_StsUnsupportedFormat, "Unsupported type" ); return; } } @@ -3534,7 +3873,7 @@ static int icvFileNodeSeqLen( CvFileNode* node ) { return CV_NODE_IS_COLLECTION(node->tag) ? node->data.seq->total : - CV_NODE_TYPE(node->tag) != CV_NODE_NONE; + CV_NODE_TYPE(node->tag) != CV_NODE_NONE; } @@ -5680,4 +6019,1113 @@ void read(const FileNode& node, String& value, const String& default_value) } + + + + + + + + +/**************************************************************************** + * Newly added for Base64 + * + * + ***************************************************************************/ + + +/**************************************************************************** + * constant + ***************************************************************************/ + +#if CHAR_BIT != 8 +#error "`char` should be 8 bit." +#endif + +base64::uint8_t const base64::base64_mapping[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789+/"; + +base64::uint8_t const base64::base64_padding = '='; + +base64::uint8_t const base64::base64_demapping[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, + 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 0, 0, 26, 27, 28, + 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 0, 0, 0, 0, +}; + +/* `base64_demapping` above is generated in this way: + * ````````````````````````````````````````````````````````````````````` + * std::string mapping((const char *)base64_mapping); + * for (auto ch = 0; ch < 127; ch++) { + * auto i = mapping.find(ch); + * printf("%3u, ", (i != std::string::npos ? i : 0)); + * } + * putchar('\n'); + * ````````````````````````````````````````````````````````````````````` + */ + +/**************************************************************************** + * function + ***************************************************************************/ + +size_t base64::base64_encode(uint8_t const * src, uint8_t * dst, size_t off, size_t cnt) +{ + if (!src || !dst || !cnt) + return 0; + + /* initialize beginning and end */ + uint8_t * dst_beg = dst; + uint8_t * dst_cur = dst_beg; + + uint8_t const * src_beg = src + off; + uint8_t const * src_cur = src_beg; + uint8_t const * src_end = src_cur + cnt / 3U * 3U; + + /* integer multiples part */ + while (src_cur < src_end) { + uint8_t _2 = *src_cur++; + uint8_t _1 = *src_cur++; + uint8_t _0 = *src_cur++; + *dst_cur++ = base64_mapping[ _2 >> 2U]; + *dst_cur++ = base64_mapping[(_1 & 0xF0U) >> 4U | (_2 & 0x03U) << 4U]; + *dst_cur++ = base64_mapping[(_0 & 0xC0U) >> 6U | (_1 & 0x0FU) << 2U]; + *dst_cur++ = base64_mapping[ _0 & 0x3FU]; + } + + /* remainder part */ + size_t rst = src_beg + cnt - src_cur; + if (rst == 1U) { + uint8_t _2 = *src_cur++; + *dst_cur++ = base64_mapping[ _2 >> 2U]; + *dst_cur++ = base64_mapping[(_2 & 0x03U) << 4U]; + } else if (rst == 2U) { + uint8_t _2 = *src_cur++; + uint8_t _1 = *src_cur++; + *dst_cur++ = base64_mapping[ _2 >> 2U]; + *dst_cur++ = base64_mapping[(_2 & 0x03U) << 4U | (_1 & 0xF0U) >> 4U]; + *dst_cur++ = base64_mapping[(_1 & 0x0FU) << 2U]; + } + + /* padding */ + switch (rst) + { + case 1U: *dst_cur++ = base64_padding; + case 2U: *dst_cur++ = base64_padding; + default: *dst_cur = 0; + break; + } + + return static_cast(dst_cur - dst_beg); +} + +size_t base64::base64_encode(char const * src, char * dst, size_t off, size_t cnt) +{ + if (cnt == 0U) + cnt = std::strlen(src); + + return base64_encode + ( + reinterpret_cast(src), + reinterpret_cast(dst), + off, + cnt + ); +} + +size_t base64::base64_decode(uint8_t const * src, uint8_t * dst, size_t off, size_t cnt) +{ + /* check parameters */ + if (!src || !dst || !cnt) + return 0U; + if (cnt & 0x3U) + return 0U; + + /* initialize beginning and end */ + uint8_t * dst_beg = dst; + uint8_t * dst_cur = dst_beg; + + uint8_t const * src_beg = src + off; + uint8_t const * src_cur = src_beg; + uint8_t const * src_end = src_cur + cnt; + + /* start decoding */ + while (src_cur < src_end) { + uint8_t d50 = base64_demapping[*src_cur++]; + uint8_t c50 = base64_demapping[*src_cur++]; + uint8_t b50 = base64_demapping[*src_cur++]; + uint8_t a50 = base64_demapping[*src_cur++]; + + uint8_t b10 = b50 & 0x03U; + uint8_t b52 = b50 & 0x3CU; + uint8_t c30 = c50 & 0x0FU; + uint8_t c54 = c50 & 0x30U; + + *dst_cur++ = (d50 << 2U) | (c54 >> 4U); + *dst_cur++ = (c30 << 4U) | (b52 >> 2U); + *dst_cur++ = (b10 << 6U) | (a50 >> 0U); + } + + *dst_cur = 0; + return size_t(dst_cur - dst_beg); +} + +size_t base64::base64_decode(char const * src, char * dst, size_t off, size_t cnt) +{ + if (cnt == 0U) + cnt = std::strlen(src); + + return base64_decode + ( + reinterpret_cast(src), + reinterpret_cast(dst), + off, + cnt + ); +} + +bool base64::base64_valid(uint8_t const * src, size_t off, size_t cnt) +{ + /* check parameters */ + if (src == 0 || src + off == 0) + return false; + if (cnt == 0U) + cnt = std::strlen(reinterpret_cast(src)); + if (cnt & 0x3U) + return false; + + /* initialize beginning and end */ + uint8_t const * beg = src + off; + uint8_t const * end = beg + cnt; + + /* skip padding */ + if (*(end - 1U) == base64_padding) { + end--; + if (*(end - 1U) == base64_padding) + end--; + } + + /* find illegal characters */ + for (uint8_t const * iter = beg; iter < end; iter++) + if (*iter > 126U || (!base64_demapping[(uint8_t)*iter] && *iter != base64_mapping[0])) + return false; + + return true; +} + +bool base64::base64_valid(char const * src, size_t off, size_t cnt) +{ + if (cnt == 0U) + cnt = std::strlen(src); + + return base64_valid(reinterpret_cast(src), off, cnt); +} + +size_t base64::base64_encode_buffer_size(size_t cnt) +{ + return size_t((cnt + 2U) / 3U * 4U + 1U); +} + +size_t base64::base64_decode_buffer_size(size_t cnt) +{ + return size_t(cnt / 4U * 3U + 1U); +} + +/**************************************************************************** + * to_binary && binary_to + ***************************************************************************/ + +template inline size_t base64:: +to_binary(_uint_t val, uchar * cur) +{ + size_t delta = CHAR_BIT; + size_t cnt = sizeof(_uint_t); + while (cnt --> static_cast(0U)) { + *cur++ = static_cast(val); + val >>= delta; + } + return sizeof(_uint_t); +} + +template<> inline size_t base64::to_binary(double val, uchar * cur) +{ + Cv64suf bit64; + bit64.f = val; + return to_binary(bit64.u, cur); +} + +template<> inline size_t base64::to_binary(float val, uchar * cur) +{ + Cv32suf bit32; + bit32.f = val; + return to_binary(bit32.u, cur); +} + +template inline size_t base64:: +to_binary(uchar const * val, uchar * cur) +{ + return to_binary<_primitive_t>(*reinterpret_cast<_primitive_t const *>(val), cur); +} + + +template inline size_t base64:: +binary_to(uchar const * cur, _uint_t & val) +{ + val = static_cast<_uint_t>(0); + for (size_t i = static_cast(0U); i < sizeof(_uint_t); i++) + val |= (static_cast<_uint_t>(*cur++) << (i * CHAR_BIT)); + return sizeof(_uint_t); +} + +template<> inline size_t base64::binary_to(uchar const * cur, double & val) +{ + Cv64suf bit64; + binary_to(cur, bit64.u); + val = bit64.f; + return sizeof(val); +} + +template<> inline size_t base64::binary_to(uchar const * cur, float & val) +{ + Cv32suf bit32; + binary_to(cur, bit32.u); + val = bit32.f; + return sizeof(val); +} + +template inline size_t base64:: +binary_to(uchar const * cur, uchar * val) +{ + return binary_to<_primitive_t>(cur, *reinterpret_cast<_primitive_t *>(val)); +} + +/**************************************************************************** + * others + ***************************************************************************/ + +std::string base64::make_base64_header(int byte_size, const char * dt) +{ + int size = byte_size; + + std::ostringstream oss; + oss << size << ' ' + << dt << ' '; + std::string buffer(oss.str()); + CV_Assert(buffer.size() < HEADER_SIZE); + + buffer.reserve(HEADER_SIZE); + while (buffer.size() < HEADER_SIZE) + buffer += ' '; + + return buffer; +} + +bool base64::read_base64_header(std::string const & header, int & byte_size, std::string & dt) +{ + std::istringstream iss(header); + return static_cast(iss >> byte_size >> dt); +} + +/**************************************************************************** + * Parser + ***************************************************************************/ + +base64::Base64ContextParser::Base64ContextParser(uchar * buffer, size_t size) + : dst_cur(buffer) + , dst_end(buffer + size) + , base64_buffer(BUFFER_LEN) + , src_beg(0) + , src_cur(0) + , src_end(0) + , binary_buffer(base64_encode_buffer_size(BUFFER_LEN)) +{ + src_beg = binary_buffer.data(); + src_cur = src_beg; + src_end = src_beg + BUFFER_LEN; +} + +base64::Base64ContextParser::~Base64ContextParser() +{ + if (src_cur != src_beg) { + /* encode the rest binary data to base64 buffer */ + flush(); + } +} + +base64::Base64ContextParser & base64::Base64ContextParser:: +read(const uchar * beg, const uchar * end) +{ + if (beg >= end) + return *this; + + while (beg < end) { + /* collect binary data and copy to binary buffer */ + size_t len = std::min(end - beg, src_end - src_cur); + std::memcpy(src_cur, beg, len); + beg += len; + src_cur += len; + + if (src_cur >= src_end) { + /* binary buffer is full. */ + /* decode it send result to dst */ + + CV_Assert(flush()); /* check for base64_valid */ + } + } + + return *this; +} + +bool base64::Base64ContextParser::flush() +{ + if (!base64_valid(src_beg, 0U, src_cur - src_beg)) + return false; + + uchar * buffer = binary_buffer.data(); + size_t len = base64_decode(src_beg, buffer, 0U, src_cur - src_beg); + src_cur = src_beg; + + /* unexpected error */ + CV_Assert(len != 0); + + /* buffer is full */ + CV_Assert(dst_cur + len < dst_end); + + if (dst_cur + len < dst_end) { + /* send data to dst */ + std::memcpy(dst_cur, buffer, len); + dst_cur += len; + } + + return true; +} + +/**************************************************************************** + * Emitter + ***************************************************************************/ + +/* A decorator for CvFileStorage + * - no copyable + * - not safe for now + * - move constructor may be needed if C++11 + */ +class base64::Base64ContextEmitter +{ +public: + explicit Base64ContextEmitter(CvFileStorage * fs) + : file_storage(fs) + , binary_buffer(BUFFER_LEN) + , base64_buffer(base64_encode_buffer_size(BUFFER_LEN)) + , src_beg(0) + , src_cur(0) + , src_end(0) + { + src_beg = binary_buffer.data(); + src_end = src_beg + BUFFER_LEN; + src_cur = src_beg; + + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + + ::icvFSFlush(file_storage); + } + + ~Base64ContextEmitter() + { + /* cleaning */ + if (src_cur != src_beg) + flush(); /* encode the rest binary data to base64 buffer */ + } + + Base64ContextEmitter & write(const uchar * beg, const uchar * end) + { + if (beg >= end) + return *this; + + while (beg < end) { + /* collect binary data and copy to binary buffer */ + size_t len = std::min(end - beg, src_end - src_cur); + std::memcpy(src_cur, beg, len); + beg += len; + src_cur += len; + + if (src_cur >= src_end) { + /* binary buffer is full. */ + /* encode it to base64 and send result to fs */ + flush(); + } + } + + return *this; + } + + /* + * a convertor must provide : + * - `operator >> (uchar * & dst)` for writting current binary data to `dst` and moving to next data. + * - `operator bool` for checking if current loaction is valid and not the end. + */ + template inline + Base64ContextEmitter & write(_to_binary_convertor_t & convertor) + { + static const size_t BUFFER_MAX_LEN = 1024U; + + std::vector buffer(BUFFER_MAX_LEN); + uchar * beg = buffer.data(); + uchar * end = beg; + + while (convertor) { + convertor >> end; + write(beg, end); + end = beg; + } + + return *this; + } + + bool flush() + { + /* controll line width, so on. */ + size_t len = base64_encode(src_beg, base64_buffer.data(), 0U, src_cur - src_beg); + if (len == 0U) + return false; + + src_cur = src_beg; + { + // TODO: better solutions. + const char newline[] = "\n"; + char space[80]; + + int ident = file_storage->struct_indent; + memset(space, ' ', ident); + space[ident] = '\0'; + + ::icvPuts(file_storage, space); + ::icvPuts(file_storage, (const char*)base64_buffer.data()); + ::icvPuts(file_storage, newline); + ::icvFSFlush(file_storage); + } + + return true; + } + +private: + /* because of Base64, we must keep its length a multiple of 3 */ + static const size_t BUFFER_LEN = 51U; + // static_assert(BUFFER_LEN % 3 == 0, "BUFFER_LEN is invalid"); + +private: + CvFileStorage * file_storage; + + std::vector binary_buffer; + std::vector base64_buffer; + uchar * src_beg; + uchar * src_cur; + uchar * src_end; +}; + +class base64::MatToBinaryConvertor +{ +public: + + explicit MatToBinaryConvertor(const cv::Mat & src) + : y (0) + , y_max(0) + , x(0) + , x_max(0) + { + /* make sure each mat `mat.dims == 2` */ + if (src.dims > 2) { + const cv::Mat * arrays[] = { &src, 0 }; + cv::Mat plane; + cv::NAryMatIterator it(arrays, &plane, 1); + + CV_Assert(it.nplanes > 0U); /* make sure mats not empty */ + mats.reserve(it.nplanes); + for (size_t i = 0U; i < it.nplanes; ++i, ++it) + mats.push_back(*it.planes); + } else { + mats.push_back(src); + } + + /* set all to beginning */ + mat_iter = mats.begin(); + y_max = (mat_iter)->rows; + x_max = (mat_iter)->cols * (mat_iter)->elemSize(); + row_begin = (mat_iter)->ptr(0); + step = (mat_iter)->elemSize1(); + + /* choose a function */ + switch ((mat_iter)->depth()) + { + case CV_8U : + case CV_8S : { to_binary_func = to_binary ; break; } + case CV_16U: + case CV_16S: { to_binary_func = to_binary; break; } + case CV_32S: { to_binary_func = to_binary ; break; } + case CV_32F: { to_binary_func = to_binary ; break; } + case CV_64F: { to_binary_func = to_binary; break; } + case CV_USRTYPE1: + default: { CV_Assert(!"mat type is invalid"); break; } + }; + + /* check if empty */ + if (mats.empty() || mats.front().empty() || mats.front().data == 0) { + mat_iter = mats.end(); + CV_Assert(!(*this)); + } + + } + + inline MatToBinaryConvertor & operator >> (uchar * & dst) + { + CV_DbgAssert(*this); + + /* copy to dst */ + dst += to_binary_func(row_begin + x, dst); + + /* move to next */ + x += step; + if (x >= x_max) { + /* when x arrive end, reset it and increase y */ + x = 0U; + ++ y; + if (y >= y_max) { + /* when y arrive end, reset it and increase iter */ + y = 0U; + ++ mat_iter; + if (mat_iter == mats.end()) { + ;/* when iter arrive end, all done */ + } else { + /* usually x_max and y_max won't change */ + y_max = (mat_iter)->rows; + x_max = (mat_iter)->cols * (mat_iter)->elemSize(); + row_begin = (mat_iter)->ptr(static_cast(y)); + } + } else + row_begin = (mat_iter)->ptr(static_cast(y)); + } + + return *this; + } + + inline operator bool() const + { + return mat_iter != mats.end(); + } + +private: + + size_t y; + size_t y_max; + size_t x; + size_t x_max; + std::vector::iterator mat_iter; + std::vector mats; + + size_t step; + const uchar * row_begin; + + typedef size_t(*to_binary_t)(const uchar *, uchar *); + to_binary_t to_binary_func; +}; + +class base64::RawDataToBinaryConvertor +{ +public: + + RawDataToBinaryConvertor(const void* src, int len, const char* dt) + : beg(reinterpret_cast(src)) + , cur(0) + , end(0) + { + CV_Assert(src); + CV_Assert(dt); + CV_Assert(len > 0); + + /* calc step and to_binary_funcs */ + make_to_binary_funcs(dt); + + end = beg; + cur = beg; + + step = ::icvCalcStructSize(dt, 0); + end = beg + step * static_cast(len); + } + + inline RawDataToBinaryConvertor & operator >>(uchar * & dst) + { + CV_DbgAssert(*this); + + for (size_t i = 0U, n = to_binary_funcs.size(); i < n; i++) { + elem_to_binary_t & pack = to_binary_funcs[i]; + pack.func(cur + pack.offset, dst + pack.offset); + } + cur += step; + dst += step; + + return *this; + } + + inline operator bool() const + { + return cur < end; + } + +private: + typedef size_t(*to_binary_t)(const uchar *, uchar *); + struct elem_to_binary_t + { + size_t offset; + to_binary_t func; + }; + +private: + void make_to_binary_funcs(const char* dt) + { + size_t cnt = 0; + size_t offset = 0; + char type = '\0'; + + std::istringstream iss(dt); + while (!iss.eof()) { + if (!(iss >> cnt)) { + iss.clear(); + cnt = 1; + } + CV_Assert(cnt > 0U); + if (!(iss >> type)) + break; + + while (cnt-- > 0) + { + elem_to_binary_t pack; + + size_t size = 0; + switch (type) + { + case 'u': + case 'c': + size = sizeof(uchar); + pack.func = to_binary; + break; + case 'w': + case 's': + size = sizeof(ushort); + pack.func = to_binary; + break; + case 'i': + size = sizeof(uint); + pack.func = to_binary; + break; + case 'f': + size = sizeof(float); + pack.func = to_binary; + break; + case 'd': + size = sizeof(double); + pack.func = to_binary; + break; + case 'r': + default: { CV_Assert(!"type not support"); break; } + }; + + offset = static_cast(cvAlign(static_cast(offset), static_cast(size))); + pack.offset = offset; + offset += size; + + to_binary_funcs.push_back(pack); + } + } + + CV_Assert(iss.eof()); + } + +private: + const uchar * beg; + const uchar * cur; + const uchar * end; + + size_t step; + std::vector to_binary_funcs; +}; + +class base64::BinaryToCvSeqConvertor +{ +public: + BinaryToCvSeqConvertor(const void* src, int len, const char* dt) + : cur(reinterpret_cast(src)) + , beg(reinterpret_cast(src)) + , end(reinterpret_cast(src)) + { + CV_Assert(src); + CV_Assert(dt); + CV_Assert(len >= 0); + + /* calc binary_to_funcs */ + make_funcs(dt); + functor_iter = binary_to_funcs.begin(); + + step = ::icvCalcStructSize(dt, 0); + end = beg + step * static_cast(len); + } + + inline BinaryToCvSeqConvertor & operator >> (CvFileNode & dst) + { + CV_DbgAssert(*this); + + /* get current data */ + union + { + uchar mem[sizeof(double)]; + uchar u; + char b; + ushort w; + short s; + int i; + float f; + double d; + } buffer; /* for GCC -Wstrict-aliasing */ + std::memset(buffer.mem, 0, sizeof(buffer)); + functor_iter->func(cur + functor_iter->offset, buffer.mem); + + /* set node::data */ + switch (functor_iter->cv_type) + { + case CV_8U : { dst.data.i = cv::saturate_cast (buffer.u); break;} + case CV_8S : { dst.data.i = cv::saturate_cast (buffer.b); break;} + case CV_16U: { dst.data.i = cv::saturate_cast (buffer.w); break;} + case CV_16S: { dst.data.i = cv::saturate_cast (buffer.s); break;} + case CV_32S: { dst.data.i = cv::saturate_cast (buffer.i); break;} + case CV_32F: { dst.data.f = cv::saturate_cast(buffer.f); break;} + case CV_64F: { dst.data.f = cv::saturate_cast(buffer.d); break;} + default: break; + } + + /* set node::tag */ + switch (functor_iter->cv_type) + { + case CV_8U : + case CV_8S : + case CV_16U: + case CV_16S: + case CV_32S: { dst.tag = CV_NODE_INT; /*std::printf("%i,", dst.data.i);*/ break; } + case CV_32F: + case CV_64F: { dst.tag = CV_NODE_REAL; /*std::printf("%.1f,", dst.data.f);*/ break; } + default: break; + } + + /* check if end */ + if (++functor_iter == binary_to_funcs.end()) { + functor_iter = binary_to_funcs.begin(); + cur += step; + } + + return *this; + } + + inline operator bool() const + { + return cur < end; + } + +private: + typedef size_t(*binary_to_t)(uchar const *, uchar *); + struct binary_to_filenode_t + { + size_t cv_type; + size_t offset; + binary_to_t func; + }; + +private: + void make_funcs(const char* dt) + { + size_t cnt = 0; + char type = '\0'; + size_t offset = 0; + + std::istringstream iss(dt); + while (!iss.eof()) { + if (!(iss >> cnt)) { + iss.clear(); + cnt = 1; + } + CV_Assert(cnt > 0U); + if (!(iss >> type)) + break; + + while (cnt-- > 0) + { + binary_to_filenode_t pack; + + /* set func and offset */ + size_t size = 0; + switch (type) + { + case 'u': + case 'c': + size = sizeof(uchar); + pack.func = binary_to; + break; + case 'w': + case 's': + size = sizeof(ushort); + pack.func = binary_to; + break; + case 'i': + size = sizeof(uint); + pack.func = binary_to; + break; + case 'f': + size = sizeof(float); + pack.func = binary_to; + break; + case 'd': + size = sizeof(double); + pack.func = binary_to; + break; + case 'r': + default: { CV_Assert(!"type not support"); break; } + }; // need a better way for outputting error. + + offset = static_cast(cvAlign(static_cast(offset), static_cast(size))); + pack.offset = offset; + offset += size; + + /* set type */ + switch (type) + { + case 'u': { pack.cv_type = CV_8U ; break; } + case 'c': { pack.cv_type = CV_8S ; break; } + case 'w': { pack.cv_type = CV_16U; break; } + case 's': { pack.cv_type = CV_16S; break; } + case 'i': { pack.cv_type = CV_32S; break; } + case 'f': { pack.cv_type = CV_32F; break; } + case 'd': { pack.cv_type = CV_64F; break; } + case 'r': + default: { CV_Assert(!"type is not support"); break; } + } // need a better way for outputting error. + + binary_to_funcs.push_back(pack); + } + } + + CV_Assert(iss.eof()); + CV_Assert(binary_to_funcs.size()); + } + +private: + + const uchar * cur; + const uchar * beg; + const uchar * end; + + size_t step; + std::vector binary_to_funcs; + std::vector::iterator functor_iter; +}; + + + +/**************************************************************************** + * Wapper + ***************************************************************************/ + +class base64::Base64Writer +{ +public: + + Base64Writer(::CvFileStorage * fs, const char * name, int len, const char* dt) + : file_storage(fs) + , emitter(fs) + , remaining_data_length(len) + , data_type_string(dt) + { + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + + cvStartWriteStruct(fs, name, CV_NODE_SEQ, "binary"); + icvFSFlush(fs); + + /* output header */ + + /* total byte size(before encode) */ + int size = len * ::icvCalcStructSize(dt, 0); + + std::string buffer = make_base64_header(size, dt); + const uchar * beg = reinterpret_cast(buffer.data()); + const uchar * end = beg + buffer.size(); + + emitter.write(beg, end); + } + + void write(const void* _data, int len) + { + CV_Assert(len >= 0); + CV_Assert(remaining_data_length >= static_cast(len)); + remaining_data_length -= static_cast(len); + + RawDataToBinaryConvertor convertor(_data, len, data_type_string); + emitter.write(convertor); + } + + template inline + void write(_to_binary_convertor_t & convertor, int data_length_of_convertor) + { + CV_Assert(data_length_of_convertor >= 0); + CV_Assert(remaining_data_length >= static_cast(data_length_of_convertor)); + remaining_data_length -= static_cast(data_length_of_convertor); + + emitter.write(convertor); + } + + ~Base64Writer() + { + CV_Assert(remaining_data_length == 0U); + emitter.flush(); + cvEndWriteStruct(file_storage); + icvFSFlush(file_storage); + } + +private: + + ::CvFileStorage * file_storage; + Base64ContextEmitter emitter; + size_t remaining_data_length; + const char* data_type_string; +}; + +void base64::make_seq(void * binary, int elem_cnt, const char * dt, ::CvSeq & seq) +{ + ::CvFileNode node; + node.info = 0; + BinaryToCvSeqConvertor convertor(binary, elem_cnt, dt); + while (convertor) { + convertor >> node; + cvSeqPush(&seq, &node); + } +} + +void base64::cvStartWriteRawData_Base64(::CvFileStorage * fs, const char* name, int len, const char* dt) +{ + CV_Assert(fs); + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + CV_Assert(fs->base64_writer == 0); + fs->base64_writer = new Base64Writer(fs, name, len, dt); +} + +void base64::cvWriteRawData_Base64(::CvFileStorage * fs, const void* _data, int len) +{ + CV_Assert(fs); + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + CV_Assert(fs->base64_writer != 0); + fs->base64_writer->write(_data, len); +} + +void base64::cvEndWriteRawData_Base64(::CvFileStorage * fs) +{ + CV_Assert(fs); + CV_CHECK_OUTPUT_FILE_STORAGE(fs); + CV_Assert(fs->base64_writer != 0); + delete fs->base64_writer; + fs->base64_writer = 0; +} + +void base64::cvWriteRawData_Base64(::cv::FileStorage & fs, const void* _data, int len, const char* dt) +{ + cvStartWriteStruct(*fs, fs.elname.c_str(), CV_NODE_SEQ, "binary"); + { + Base64ContextEmitter emitter(*fs); + { /* header */ + /* total byte size(before encode) */ + int size = len * ::icvCalcStructSize(dt, 0); + std::string buffer = make_base64_header(size, dt); + const uchar * beg = reinterpret_cast(buffer.data()); + const uchar * end = beg + buffer.size(); + + emitter.write(beg, end); + } + { /* body */ + RawDataToBinaryConvertor convert(_data, len, dt); + emitter.write(convert); + } + } + cvEndWriteStruct(*fs); +} + +void base64::cvWriteMat_Base64(::CvFileStorage * fs, const char * name, ::cv::Mat const & mat) +{ + char dt[4]; + ::icvEncodeFormat(CV_MAT_TYPE(mat.type()), dt); + + { /* [1]output other attr */ + + if (mat.dims <= 2) { + cvStartWriteStruct(fs, name, CV_NODE_MAP, CV_TYPE_NAME_MAT); + + cvWriteInt(fs, "rows", mat.rows ); + cvWriteInt(fs, "cols", mat.cols ); + } else { + cvStartWriteStruct(fs, name, CV_NODE_MAP, CV_TYPE_NAME_MATND); + + cvStartWriteStruct(fs, "sizes", CV_NODE_SEQ | CV_NODE_FLOW); + cvWriteRawData(fs, mat.size.p, mat.dims, "i"); + cvEndWriteStruct(fs); + } + cvWriteString(fs, "dt", ::icvEncodeFormat(CV_MAT_TYPE(mat.type()), dt ), 0 ); + } + + { /* [2]deal with matrix's data */ + int len = static_cast(mat.total()); + MatToBinaryConvertor convertor(mat); + + cvStartWriteRawData_Base64(fs, "data", len, dt); + fs->base64_writer->write(convertor, len); + cvEndWriteRawData_Base64(fs); + } + + { /* [3]output end */ + cvEndWriteStruct(fs); + } +} + +/**************************************************************************** + * Interface + ***************************************************************************/ + +namespace cv +{ + void cvWriteMat_Base64(::CvFileStorage* fs, const char* name, const ::CvMat* mat) + { + ::cv::Mat holder = ::cv::cvarrToMat(mat); + ::base64::cvWriteMat_Base64(fs, name, holder); + } + + void cvWriteMatND_Base64(::CvFileStorage* fs, const char* name, const ::CvMatND* mat) + { + ::cv::Mat holder = ::cv::cvarrToMat(mat); + ::base64::cvWriteMat_Base64(fs, name, holder); + } + + void cvStartWriteRawData_Base64(::CvFileStorage * fs, const char* name, int len, const char* dt) + { + ::base64::cvStartWriteRawData_Base64(fs, name, len, dt); + } + + void cvWriteRawData_Base64(::CvFileStorage * fs, const void* _data, int len) + { + ::base64::cvWriteRawData_Base64(fs, _data, len); + } + + void cvEndWriteRawData_Base64(::CvFileStorage * fs) + { + ::base64::cvEndWriteRawData_Base64(fs); + } + +} + + /* End of file. */ diff --git a/modules/core/test/test_io.cpp b/modules/core/test/test_io.cpp index b53c43c83b..1367776f2d 100644 --- a/modules/core/test/test_io.cpp +++ b/modules/core/test/test_io.cpp @@ -574,6 +574,153 @@ TEST(Core_InputOutput, FileStorageKey) EXPECT_NO_THROW(f << "key1" << "value1"); EXPECT_NO_THROW(f << "_key2" << "value2"); EXPECT_NO_THROW(f << "key_3" << "value3"); - const std::string expected = "%YAML:1.0\nkey1: value1\n_key2: value2\nkey_3: value3\n"; + const std::string expected = "%YAML 1.0\n---\nkey1: value1\n_key2: value2\nkey_3: value3\n"; ASSERT_STREQ(f.releaseAndGetString().c_str(), expected.c_str()); } + +TEST(Core_InputOutput, filestorage_yml_compatibility) +{ + // TODO: +} + +class CV_Base64IOTest : public cvtest::BaseTest +{ +private: + std::string file_name; + + struct data_t + { + uchar u1, u2; + int i1, i2, i3; + double d1, d2; + int i4; + }; + +public: + CV_Base64IOTest(std::string const & test_file_name) + : file_name(test_file_name) {} + ~CV_Base64IOTest() {} +protected: + void run(int) + { + try + { + std::vector rawdata; + + cv::Mat _em_out, _em_in; + cv::Mat _2d_out, _2d_in; + cv::Mat _nd_out, _nd_in; + + { /* init */ + + /* normal mat */ + _2d_out = cv::Mat(100, 100, CV_8UC3, cvScalar(1U, 2U, 127U)); + for (int i = 0; i < _2d_out.rows; ++i) + for (int j = 0; j < _2d_out.cols; ++j) + _2d_out.at(i, j)[1] = (i + j) % 256; + + /* 4d mat */ + const int Size[] = {4, 4, 4, 4}; + cv::Mat _4d(4, Size, CV_64FC4, cvScalar(0.888, 0.111, 0.666, 0.444)); + const cv::Range ranges[] = { + cv::Range(0, 2), + cv::Range(0, 2), + cv::Range(1, 2), + cv::Range(0, 2) }; + _nd_out = _4d(ranges); + + /* raw data */ + for (int i = 0; i < 1000; i++) { + data_t tmp; + tmp.u1 = 1; + tmp.u2 = 2; + tmp.i1 = 1; + tmp.i2 = 2; + tmp.i3 = 3; + tmp.d1 = 0.1; + tmp.d2 = 0.2; + tmp.i4 = i; + rawdata.push_back(tmp); + } + } + + { /* write */ + cv::FileStorage fs(file_name, cv::FileStorage::WRITE); + CvMat holder = _2d_out; + cv::cvWriteMat_Base64(*fs, "normal_2d_mat", &holder); + CvMatND holder_nd = _nd_out; + cv::cvWriteMatND_Base64(*fs, "normal_nd_mat", &holder_nd); + holder = _em_out; + cv::cvWriteMat_Base64(*fs, "empty_2d_mat", &holder); + + cv::cvStartWriteRawData_Base64(*fs, "rawdata", static_cast(rawdata.size()), "2u3i2di"); + for (int i = 0; i < 10; i++) + cv::cvWriteRawData_Base64(*fs, rawdata.data() + i * 100, 100); + cv::cvEndWriteRawData_Base64(*fs); + + fs.release(); + } + + { /* read */ + cv::FileStorage fs(file_name, cv::FileStorage::READ); + + /* mat */ + fs["empty_2d_mat"] >> _em_in; + fs["normal_2d_mat"] >> _2d_in; + fs["normal_nd_mat"] >> _nd_in; + + /* raw data */ + std::vector(1000).swap(rawdata); + cvReadRawData(*fs, fs["rawdata"].node, rawdata.data(), "2u3i2di"); + + fs.release(); + } + + for (int i = 0; i < 1000; i++) { + // TODO: Solve this bug in `cvReadRawData` + //EXPECT_EQ(rawdata[i].u1, 1); + //EXPECT_EQ(rawdata[i].u2, 2); + //EXPECT_EQ(rawdata[i].i1, 1); + //EXPECT_EQ(rawdata[i].i2, 2); + //EXPECT_EQ(rawdata[i].i3, 3); + //EXPECT_EQ(rawdata[i].d1, 0.1); + //EXPECT_EQ(rawdata[i].d2, 0.2); + //EXPECT_EQ(rawdata[i].i4, i); + } + + EXPECT_EQ(_em_in.rows , _em_out.rows); + EXPECT_EQ(_em_in.cols , _em_out.cols); + EXPECT_EQ(_em_in.dims , _em_out.dims); + EXPECT_EQ(_em_in.depth(), _em_out.depth()); + EXPECT_TRUE(_em_in.empty()); + + EXPECT_EQ(_2d_in.rows , _2d_in.rows); + EXPECT_EQ(_2d_in.cols , _2d_in.cols); + EXPECT_EQ(_2d_in.dims , _2d_in.dims); + EXPECT_EQ(_2d_in.depth(), _2d_in.depth()); + for(int i = 0; i < _2d_in.rows; ++i) + for (int j = 0; j < _2d_in.cols; ++j) + EXPECT_EQ(_2d_in.at(i, j), _2d_out.at(i, j)); + + EXPECT_EQ(_nd_in.rows , _nd_in.rows); + EXPECT_EQ(_nd_in.cols , _nd_in.cols); + EXPECT_EQ(_nd_in.dims , _nd_in.dims); + EXPECT_EQ(_nd_in.depth(), _nd_in.depth()); + EXPECT_EQ(cv::countNonZero(cv::mean(_nd_in != _nd_out)), 0); + } + catch(...) + { + ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH); + } + } +}; + +TEST(Core_InputOutput, filestorage_yml_base64) +{ + CV_Base64IOTest test("base64_test_tmp_file.yml"); test.safe_run(); +} + +TEST(Core_InputOutput, filestorage_xml_base64) +{ + CV_Base64IOTest test("base64_test_tmp_file.xml"); test.safe_run(); +} diff --git a/modules/core/test/test_utils.cpp b/modules/core/test/test_utils.cpp index 18b0a5a7ea..a527ba6f28 100644 --- a/modules/core/test/test_utils.cpp +++ b/modules/core/test/test_utils.cpp @@ -27,6 +27,7 @@ TEST(CommandLineParser, testFailure) parser.get("h"); EXPECT_FALSE(parser.check()); } + TEST(CommandLineParser, testHas_noValues) { const char* argv[] = {"", "-h", "--info"}; @@ -218,4 +219,17 @@ TEST(CommandLineParser, positional_regression_5074_equal_sign) EXPECT_TRUE(parser.check()); } + +TEST(AutoBuffer, allocate_test) +{ + AutoBuffer abuf(2); + EXPECT_EQ(2, abuf.size()); + + abuf.allocate(4); + EXPECT_EQ(4, abuf.size()); + + abuf.allocate(6); + EXPECT_EQ(6, abuf.size()); +} + } // namespace diff --git a/modules/imgcodecs/include/opencv2/imgcodecs.hpp b/modules/imgcodecs/include/opencv2/imgcodecs.hpp index ac0fd24ee9..ce827a7e0f 100644 --- a/modules/imgcodecs/include/opencv2/imgcodecs.hpp +++ b/modules/imgcodecs/include/opencv2/imgcodecs.hpp @@ -84,7 +84,7 @@ enum ImwriteFlags { IMWRITE_JPEG_RST_INTERVAL = 4, //!< JPEG restart interval, 0 - 65535, default is 0 - no restart. IMWRITE_JPEG_LUMA_QUALITY = 5, //!< Separate luma quality level, 0 - 100, default is 0 - don't use. IMWRITE_JPEG_CHROMA_QUALITY = 6, //!< Separate chroma quality level, 0 - 100, default is 0 - don't use. - IMWRITE_PNG_COMPRESSION = 16, //!< For PNG, it can be the compression level from 0 to 9. A higher value means a smaller size and longer compression time. Default value is 3. + IMWRITE_PNG_COMPRESSION = 16, //!< For PNG, it can be the compression level from 0 to 9. A higher value means a smaller size and longer compression time. Default value is 3. Also strategy is changed to IMWRITE_PNG_STRATEGY_DEFAULT (Z_DEFAULT_STRATEGY). IMWRITE_PNG_STRATEGY = 17, //!< One of cv::ImwritePNGFlags, default is IMWRITE_PNG_STRATEGY_DEFAULT. IMWRITE_PNG_BILEVEL = 18, //!< Binary level PNG, 0 or 1, default is 0. IMWRITE_PXM_BINARY = 32, //!< For PPM, PGM, or PBM, it can be a binary format flag, 0 or 1. Default value is 1. diff --git a/modules/imgcodecs/src/grfmt_png.cpp b/modules/imgcodecs/src/grfmt_png.cpp index d5d175f89e..e672e0cc96 100644 --- a/modules/imgcodecs/src/grfmt_png.cpp +++ b/modules/imgcodecs/src/grfmt_png.cpp @@ -370,22 +370,23 @@ bool PngEncoder::write( const Mat& img, const std::vector& params ) } int compression_level = -1; // Invalid value to allow setting 0-9 as valid - int compression_strategy = Z_RLE; // Default strategy + int compression_strategy = IMWRITE_PNG_STRATEGY_RLE; // Default strategy bool isBilevel = false; for( size_t i = 0; i < params.size(); i += 2 ) { - if( params[i] == CV_IMWRITE_PNG_COMPRESSION ) + if( params[i] == IMWRITE_PNG_COMPRESSION ) { + compression_strategy = IMWRITE_PNG_STRATEGY_DEFAULT; // Default strategy compression_level = params[i+1]; compression_level = MIN(MAX(compression_level, 0), Z_BEST_COMPRESSION); } - if( params[i] == CV_IMWRITE_PNG_STRATEGY ) + if( params[i] == IMWRITE_PNG_STRATEGY ) { compression_strategy = params[i+1]; compression_strategy = MIN(MAX(compression_strategy, 0), Z_FIXED); } - if( params[i] == CV_IMWRITE_PNG_BILEVEL ) + if( params[i] == IMWRITE_PNG_BILEVEL ) { isBilevel = params[i+1] != 0; } diff --git a/modules/imgproc/src/smooth.cpp b/modules/imgproc/src/smooth.cpp index f401a679d5..dc19f7b169 100644 --- a/modules/imgproc/src/smooth.cpp +++ b/modules/imgproc/src/smooth.cpp @@ -229,6 +229,8 @@ struct ColumnSum : #if CV_SSE2 bool haveSSE2 = checkHardwareSupport(CV_CPU_SSE2); + #elif CV_NEON + bool haveNEON = checkHardwareSupport(CV_CPU_NEON); #endif if( width != (int)sum.size() ) @@ -256,8 +258,11 @@ struct ColumnSum : } } #elif CV_NEON - for( ; i <= width - 4; i+=4 ) - vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + if(haveNEON) + { + for( ; i <= width - 4; i+=4 ) + vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + } #endif for( ; i < width; i++ ) SUM[i] += Sp[i]; @@ -303,20 +308,23 @@ struct ColumnSum : } } #elif CV_NEON - float32x4_t v_scale = vdupq_n_f32((float)_scale); - for( ; i <= width-8; i+=8 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); + float32x4_t v_scale = vdupq_n_f32((float)_scale); + for( ; i <= width-8; i+=8 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); - uint32x4_t v_s0d = cv_vrndq_u32_f32(vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); - uint32x4_t v_s01d = cv_vrndq_u32_f32(vmulq_f32(vcvtq_f32_s32(v_s01), v_scale)); + uint32x4_t v_s0d = cv_vrndq_u32_f32(vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); + uint32x4_t v_s01d = cv_vrndq_u32_f32(vmulq_f32(vcvtq_f32_s32(v_s01), v_scale)); - uint16x8_t v_dst = vcombine_u16(vqmovn_u32(v_s0d), vqmovn_u32(v_s01d)); - vst1_u8(D + i, vqmovn_u16(v_dst)); + uint16x8_t v_dst = vcombine_u16(vqmovn_u32(v_s0d), vqmovn_u32(v_s01d)); + vst1_u8(D + i, vqmovn_u16(v_dst)); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); - vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + } } #endif for( ; i < width; i++ ) @@ -351,16 +359,19 @@ struct ColumnSum : } } #elif CV_NEON - for( ; i <= width-8; i+=8 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); + for( ; i <= width-8; i+=8 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); - uint16x8_t v_dst = vcombine_u16(vqmovun_s32(v_s0), vqmovun_s32(v_s01)); - vst1_u8(D + i, vqmovn_u16(v_dst)); + uint16x8_t v_dst = vcombine_u16(vqmovun_s32(v_s0), vqmovun_s32(v_s01)); + vst1_u8(D + i, vqmovn_u16(v_dst)); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); - vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + } } #endif @@ -404,6 +415,8 @@ struct ColumnSum : #if CV_SSE2 bool haveSSE2 = checkHardwareSupport(CV_CPU_SSE2); + #elif CV_NEON + bool haveNEON = checkHardwareSupport(CV_CPU_NEON); #endif if( width != (int)sum.size() ) @@ -411,6 +424,7 @@ struct ColumnSum : sum.resize(width); sumCount = 0; } + SUM = &sum[0]; if( sumCount == 0 ) { @@ -430,8 +444,11 @@ struct ColumnSum : } } #elif CV_NEON - for( ; i <= width - 4; i+=4 ) - vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + if(haveNEON) + { + for( ; i <= width - 4; i+=4 ) + vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + } #endif for( ; i < width; i++ ) SUM[i] += Sp[i]; @@ -475,18 +492,21 @@ struct ColumnSum : } } #elif CV_NEON - float32x4_t v_scale = vdupq_n_f32((float)_scale); - for( ; i <= width-8; i+=8 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); + float32x4_t v_scale = vdupq_n_f32((float)_scale); + for( ; i <= width-8; i+=8 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); - int32x4_t v_s0d = cv_vrndq_s32_f32(vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); - int32x4_t v_s01d = cv_vrndq_s32_f32(vmulq_f32(vcvtq_f32_s32(v_s01), v_scale)); - vst1q_s16(D + i, vcombine_s16(vqmovn_s32(v_s0d), vqmovn_s32(v_s01d))); + int32x4_t v_s0d = cv_vrndq_s32_f32(vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); + int32x4_t v_s01d = cv_vrndq_s32_f32(vmulq_f32(vcvtq_f32_s32(v_s01), v_scale)); + vst1q_s16(D + i, vcombine_s16(vqmovn_s32(v_s0d), vqmovn_s32(v_s01d))); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); - vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + } } #endif for( ; i < width; i++ ) @@ -520,15 +540,18 @@ struct ColumnSum : } } #elif CV_NEON - for( ; i <= width-8; i+=8 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); + for( ; i <= width-8; i+=8 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); - vst1q_s16(D + i, vcombine_s16(vqmovn_s32(v_s0), vqmovn_s32(v_s01))); + vst1q_s16(D + i, vcombine_s16(vqmovn_s32(v_s0), vqmovn_s32(v_s01))); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); - vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + } } #endif @@ -570,8 +593,11 @@ struct ColumnSum : int* SUM; bool haveScale = scale != 1; double _scale = scale; + #if CV_SSE2 - bool haveSSE2 = checkHardwareSupport(CV_CPU_SSE2); + bool haveSSE2 = checkHardwareSupport(CV_CPU_SSE2); + #elif CV_NEON + bool haveNEON = checkHardwareSupport(CV_CPU_NEON); #endif if( width != (int)sum.size() ) @@ -579,6 +605,7 @@ struct ColumnSum : sum.resize(width); sumCount = 0; } + SUM = &sum[0]; if( sumCount == 0 ) { @@ -590,16 +617,19 @@ struct ColumnSum : #if CV_SSE2 if(haveSSE2) { - for( ; i < width-4; i+=4 ) + for( ; i <= width-4; i+=4 ) { __m128i _sum = _mm_loadu_si128((const __m128i*)(SUM+i)); __m128i _sp = _mm_loadu_si128((const __m128i*)(Sp+i)); - _mm_storeu_si128((__m128i*)(SUM+i), _mm_add_epi32(_sum, _sp)); + _mm_storeu_si128((__m128i*)(SUM+i),_mm_add_epi32(_sum, _sp)); } } #elif CV_NEON - for( ; i <= width - 4; i+=4 ) - vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + if(haveNEON) + { + for( ; i <= width - 4; i+=4 ) + vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + } #endif for( ; i < width; i++ ) SUM[i] += Sp[i]; @@ -642,18 +672,21 @@ struct ColumnSum : } } #elif CV_NEON - float32x4_t v_scale = vdupq_n_f32((float)_scale); - for( ; i <= width-8; i+=8 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); + float32x4_t v_scale = vdupq_n_f32((float)_scale); + for( ; i <= width-8; i+=8 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); - uint32x4_t v_s0d = cv_vrndq_u32_f32(vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); - uint32x4_t v_s01d = cv_vrndq_u32_f32(vmulq_f32(vcvtq_f32_s32(v_s01), v_scale)); - vst1q_u16(D + i, vcombine_u16(vqmovn_u32(v_s0d), vqmovn_u32(v_s01d))); + uint32x4_t v_s0d = cv_vrndq_u32_f32(vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); + uint32x4_t v_s01d = cv_vrndq_u32_f32(vmulq_f32(vcvtq_f32_s32(v_s01), v_scale)); + vst1q_u16(D + i, vcombine_u16(vqmovn_u32(v_s0d), vqmovn_u32(v_s01d))); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); - vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + } } #endif for( ; i < width; i++ ) @@ -686,15 +719,18 @@ struct ColumnSum : } } #elif CV_NEON - for( ; i <= width-8; i+=8 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); + for( ; i <= width-8; i+=8 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); - vst1q_u16(D + i, vcombine_u16(vqmovun_s32(v_s0), vqmovun_s32(v_s01))); + vst1q_u16(D + i, vcombine_u16(vqmovun_s32(v_s0), vqmovun_s32(v_s01))); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); - vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + } } #endif @@ -738,6 +774,8 @@ struct ColumnSum : #if CV_SSE2 bool haveSSE2 = checkHardwareSupport(CV_CPU_SSE2); + #elif CV_NEON + bool haveNEON = checkHardwareSupport(CV_CPU_NEON); #endif if( width != (int)sum.size() ) @@ -745,6 +783,7 @@ struct ColumnSum : sum.resize(width); sumCount = 0; } + SUM = &sum[0]; if( sumCount == 0 ) { @@ -764,8 +803,11 @@ struct ColumnSum : } } #elif CV_NEON - for( ; i <= width - 4; i+=4 ) - vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + if(haveNEON) + { + for( ; i <= width - 4; i+=4 ) + vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + } #endif for( ; i < width; i++ ) SUM[i] += Sp[i]; @@ -803,15 +845,18 @@ struct ColumnSum : } } #elif CV_NEON - float32x4_t v_scale = vdupq_n_f32((float)_scale); - for( ; i <= width-4; i+=4 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + float32x4_t v_scale = vdupq_n_f32((float)_scale); + for( ; i <= width-4; i+=4 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - int32x4_t v_s0d = cv_vrndq_s32_f32(vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); - vst1q_s32(D + i, v_s0d); + int32x4_t v_s0d = cv_vrndq_s32_f32(vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); + vst1q_s32(D + i, v_s0d); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + } } #endif for( ; i < width; i++ ) @@ -838,12 +883,15 @@ struct ColumnSum : } } #elif CV_NEON - for( ; i <= width-4; i+=4 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + for( ; i <= width-4; i+=4 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - vst1q_s32(D + i, v_s0); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(D + i, v_s0); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + } } #endif @@ -887,7 +935,9 @@ struct ColumnSum : double _scale = scale; #if CV_SSE2 - bool haveSSE2 = checkHardwareSupport(CV_CPU_SSE2); + bool haveSSE2 = checkHardwareSupport(CV_CPU_SSE2); + #elif CV_NEON + bool haveNEON = checkHardwareSupport(CV_CPU_NEON); #endif if( width != (int)sum.size() ) @@ -899,26 +949,27 @@ struct ColumnSum : SUM = &sum[0]; if( sumCount == 0 ) { - memset((void *)SUM, 0, sizeof(int) * width); - + memset((void*)SUM, 0, width*sizeof(int)); for( ; sumCount < ksize - 1; sumCount++, src++ ) { const int* Sp = (const int*)src[0]; i = 0; - #if CV_SSE2 if(haveSSE2) { - for( ; i < width-4; i+=4 ) + for( ; i <= width-4; i+=4 ) { __m128i _sum = _mm_loadu_si128((const __m128i*)(SUM+i)); __m128i _sp = _mm_loadu_si128((const __m128i*)(Sp+i)); - _mm_storeu_si128((__m128i*)(SUM+i), _mm_add_epi32(_sum, _sp)); + _mm_storeu_si128((__m128i*)(SUM+i),_mm_add_epi32(_sum, _sp)); } } #elif CV_NEON - for( ; i <= width - 4; i+=4 ) - vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + if(haveNEON) + { + for( ; i <= width - 4; i+=4 ) + vst1q_s32(SUM + i, vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i))); + } #endif for( ; i < width; i++ ) @@ -956,17 +1007,20 @@ struct ColumnSum : } } #elif CV_NEON - float32x4_t v_scale = vdupq_n_f32((float)_scale); - for( ; i <= width-8; i+=8 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); + float32x4_t v_scale = vdupq_n_f32((float)_scale); + for( ; i <= width-8; i+=8 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); - vst1q_f32(D + i, vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); - vst1q_f32(D + i + 4, vmulq_f32(vcvtq_f32_s32(v_s01), v_scale)); + vst1q_f32(D + i, vmulq_f32(vcvtq_f32_s32(v_s0), v_scale)); + vst1q_f32(D + i + 4, vmulq_f32(vcvtq_f32_s32(v_s01), v_scale)); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); - vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + } } #endif @@ -995,16 +1049,19 @@ struct ColumnSum : } } #elif CV_NEON - for( ; i <= width-8; i+=8 ) + if(haveNEON) { - int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); - int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); + for( ; i <= width-8; i+=8 ) + { + int32x4_t v_s0 = vaddq_s32(vld1q_s32(SUM + i), vld1q_s32(Sp + i)); + int32x4_t v_s01 = vaddq_s32(vld1q_s32(SUM + i + 4), vld1q_s32(Sp + i + 4)); - vst1q_f32(D + i, vcvtq_f32_s32(v_s0)); - vst1q_f32(D + i + 4, vcvtq_f32_s32(v_s01)); + vst1q_f32(D + i, vcvtq_f32_s32(v_s0)); + vst1q_f32(D + i + 4, vcvtq_f32_s32(v_s01)); - vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); - vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + vst1q_s32(SUM + i, vsubq_s32(v_s0, vld1q_s32(Sm + i))); + vst1q_s32(SUM + i + 4, vsubq_s32(v_s01, vld1q_s32(Sm + i + 4))); + } } #endif diff --git a/modules/python/src2/cv2.cpp b/modules/python/src2/cv2.cpp index 3bb98e4f8c..4b07e60fa4 100644 --- a/modules/python/src2/cv2.cpp +++ b/modules/python/src2/cv2.cpp @@ -1268,6 +1268,52 @@ static PyObject *pycvCreateTrackbar(PyObject*, PyObject *args) ERRWRAP2(createTrackbar(trackbar_name, window_name, value, count, OnChange, Py_BuildValue("OO", on_change, Py_None))); Py_RETURN_NONE; } + +static void OnButtonChange(int state, void *param) +{ + PyGILState_STATE gstate; + gstate = PyGILState_Ensure(); + + PyObject *o = (PyObject*)param; + PyObject *args; + if(PyTuple_GetItem(o, 1) != NULL) + { + args = Py_BuildValue("(iO)", state, PyTuple_GetItem(o,1)); + } + else + { + args = Py_BuildValue("(i)", state); + } + + PyObject *r = PyObject_Call(PyTuple_GetItem(o, 0), args, NULL); + if (r == NULL) + PyErr_Print(); + Py_DECREF(args); + PyGILState_Release(gstate); +} + +static PyObject *pycvCreateButton(PyObject*, PyObject *args, PyObject *kw) +{ + const char* keywords[] = {"buttonName", "onChange", "userData", "buttonType", "initialButtonState", NULL}; + PyObject *on_change; + PyObject *userdata = NULL; + char* button_name; + int button_type = 0; + bool initial_button_state = false; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "sO|Oii", (char**)keywords, &button_name, &on_change, &userdata, &button_type, &initial_button_state)) + return NULL; + if (!PyCallable_Check(on_change)) { + PyErr_SetString(PyExc_TypeError, "onChange must be callable"); + return NULL; + } + if (userdata == NULL) { + userdata = Py_None; + } + + ERRWRAP2(createButton(button_name, OnButtonChange, Py_BuildValue("OO", on_change, userdata), button_type, initial_button_state)); + Py_RETURN_NONE; +} #endif /////////////////////////////////////////////////////////////////////////////////////// @@ -1300,6 +1346,7 @@ static int convert_to_char(PyObject *o, char *dst, const char *name = "no_name") static PyMethodDef special_methods[] = { #ifdef HAVE_OPENCV_HIGHGUI {"createTrackbar", pycvCreateTrackbar, METH_VARARGS, "createTrackbar(trackbarName, windowName, value, count, onChange) -> None"}, + {"createButton", (PyCFunction)pycvCreateButton, METH_VARARGS | METH_KEYWORDS, "createButton(buttonName, onChange [, userData, buttonType, initialButtonState]) -> None"}, {"setMouseCallback", (PyCFunction)pycvSetMouseCallback, METH_VARARGS | METH_KEYWORDS, "setMouseCallback(windowName, onMouse [, param]) -> None"}, #endif {NULL, NULL}, diff --git a/modules/videoio/include/opencv2/videoio.hpp b/modules/videoio/include/opencv2/videoio.hpp index 6b3b97b6af..0acb3d3f1e 100644 --- a/modules/videoio/include/opencv2/videoio.hpp +++ b/modules/videoio/include/opencv2/videoio.hpp @@ -65,60 +65,71 @@ namespace cv //! @addtogroup videoio //! @{ -// Camera API -enum { CAP_ANY = 0, // autodetect - CAP_VFW = 200, // platform native - CAP_V4L = 200, - CAP_V4L2 = CAP_V4L, - CAP_FIREWARE = 300, // IEEE 1394 drivers - CAP_FIREWIRE = CAP_FIREWARE, - CAP_IEEE1394 = CAP_FIREWARE, - CAP_DC1394 = CAP_FIREWARE, - CAP_CMU1394 = CAP_FIREWARE, - CAP_QT = 500, // QuickTime - CAP_UNICAP = 600, // Unicap drivers - CAP_DSHOW = 700, // DirectShow (via videoInput) - CAP_PVAPI = 800, // PvAPI, Prosilica GigE SDK - CAP_OPENNI = 900, // OpenNI (for Kinect) - CAP_OPENNI_ASUS = 910, // OpenNI (for Asus Xtion) - CAP_ANDROID = 1000, // Android - not used - CAP_XIAPI = 1100, // XIMEA Camera API - CAP_AVFOUNDATION = 1200, // AVFoundation framework for iOS (OS X Lion will have the same API) - CAP_GIGANETIX = 1300, // Smartek Giganetix GigEVisionSDK - CAP_MSMF = 1400, // Microsoft Media Foundation (via videoInput) - CAP_WINRT = 1410, // Microsoft Windows Runtime using Media Foundation - CAP_INTELPERC = 1500, // Intel Perceptual Computing SDK - CAP_OPENNI2 = 1600, // OpenNI2 (for Kinect) - CAP_OPENNI2_ASUS = 1610, // OpenNI2 (for Asus Xtion and Occipital Structure sensors) - CAP_GPHOTO2 = 1700, // gPhoto2 connection - CAP_GSTREAMER = 1800, // GStreamer - CAP_FFMPEG = 1900, // FFMPEG - CAP_IMAGES = 2000 // OpenCV Image Sequence (e.g. img_%02d.jpg) +/** @brief Capture API backends. + +Select preferred API for a capture object. +To be used in the constructor VideoCapture::VideoCapture or VideoCapture::open + +@note Backends are available only if they have been built with your OpenCV binaries.
+Check in cvconfig.h to know which APIs are currently available (e.g. HAVE_MSMF, HAVE_VFW, HAVE_LIBV4L). +To enable/disable APIs, you have to: + 1. re-configure OpenCV using the appropriates CMake switches + (e.g. -DWITH_MSMF=ON -DWITH_VFW=ON ... ) or checking related switch in cmake-gui + 2. rebuild OpenCV itself +*/ +enum { CAP_ANY = 0, //!< Auto detect + CAP_VFW = 200, //!< Video For Windows (platform native) + CAP_V4L = 200, //!< V4L/V4L2 capturing support via libv4l + CAP_V4L2 = CAP_V4L, //!< Same as CAP_V4L + CAP_FIREWIRE = 300, //!< IEEE 1394 drivers + CAP_FIREWARE = CAP_FIREWIRE, //!< Same as CAP_FIREWIRE + CAP_IEEE1394 = CAP_FIREWIRE, //!< Same as CAP_FIREWIRE + CAP_DC1394 = CAP_FIREWIRE, //!< Same as CAP_FIREWIRE + CAP_CMU1394 = CAP_FIREWIRE, //!< Same as CAP_FIREWIRE + CAP_QT = 500, //!< QuickTime + CAP_UNICAP = 600, //!< Unicap drivers + CAP_DSHOW = 700, //!< DirectShow (via videoInput) + CAP_PVAPI = 800, //!< PvAPI, Prosilica GigE SDK + CAP_OPENNI = 900, //!< OpenNI (for Kinect) + CAP_OPENNI_ASUS = 910, //!< OpenNI (for Asus Xtion) + CAP_ANDROID = 1000, //!< Android - not used + CAP_XIAPI = 1100, //!< XIMEA Camera API + CAP_AVFOUNDATION = 1200, //!< AVFoundation framework for iOS (OS X Lion will have the same API) + CAP_GIGANETIX = 1300, //!< Smartek Giganetix GigEVisionSDK + CAP_MSMF = 1400, //!< Microsoft Media Foundation (via videoInput) + CAP_WINRT = 1410, //!< Microsoft Windows Runtime using Media Foundation + CAP_INTELPERC = 1500, //!< Intel Perceptual Computing SDK + CAP_OPENNI2 = 1600, //!< OpenNI2 (for Kinect) + CAP_OPENNI2_ASUS = 1610, //!< OpenNI2 (for Asus Xtion and Occipital Structure sensors) + CAP_GPHOTO2 = 1700, //!< gPhoto2 connection + CAP_GSTREAMER = 1800, //!< GStreamer + CAP_FFMPEG = 1900, //!< FFMPEG + CAP_IMAGES = 2000 //!< OpenCV Image Sequence (e.g. img_%02d.jpg) }; -// generic properties (based on DC1394 properties) -enum { CAP_PROP_POS_MSEC =0, - CAP_PROP_POS_FRAMES =1, - CAP_PROP_POS_AVI_RATIO =2, - CAP_PROP_FRAME_WIDTH =3, - CAP_PROP_FRAME_HEIGHT =4, - CAP_PROP_FPS =5, - CAP_PROP_FOURCC =6, - CAP_PROP_FRAME_COUNT =7, - CAP_PROP_FORMAT =8, - CAP_PROP_MODE =9, - CAP_PROP_BRIGHTNESS =10, - CAP_PROP_CONTRAST =11, - CAP_PROP_SATURATION =12, - CAP_PROP_HUE =13, - CAP_PROP_GAIN =14, - CAP_PROP_EXPOSURE =15, - CAP_PROP_CONVERT_RGB =16, - CAP_PROP_WHITE_BALANCE_BLUE_U =17, - CAP_PROP_RECTIFICATION =18, +//! generic properties (based on DC1394 properties) +enum { CAP_PROP_POS_MSEC =0, //!< Current position of the video file in milliseconds. + CAP_PROP_POS_FRAMES =1, //!< 0-based index of the frame to be decoded/captured next. + CAP_PROP_POS_AVI_RATIO =2, //!< Relative position of the video file: 0=start of the film, 1=end of the film. + CAP_PROP_FRAME_WIDTH =3, //!< Width of the frames in the video stream. + CAP_PROP_FRAME_HEIGHT =4, //!< Height of the frames in the video stream. + CAP_PROP_FPS =5, //!< Frame rate. + CAP_PROP_FOURCC =6, //!< 4-character code of codec. see VideoWriter::fourcc . + CAP_PROP_FRAME_COUNT =7, //!< Number of frames in the video file. + CAP_PROP_FORMAT =8, //!< Format of the %Mat objects returned by VideoCapture::retrieve(). + CAP_PROP_MODE =9, //!< Backend-specific value indicating the current capture mode. + CAP_PROP_BRIGHTNESS =10, //!< Brightness of the image (only for cameras). + CAP_PROP_CONTRAST =11, //!< Contrast of the image (only for cameras). + CAP_PROP_SATURATION =12, //!< Saturation of the image (only for cameras). + CAP_PROP_HUE =13, //!< Hue of the image (only for cameras). + CAP_PROP_GAIN =14, //!< Gain of the image (only for cameras). + CAP_PROP_EXPOSURE =15, //!< Exposure (only for cameras). + CAP_PROP_CONVERT_RGB =16, //!< Boolean flags indicating whether images should be converted to RGB. + CAP_PROP_WHITE_BALANCE_BLUE_U =17, //!< Currently unsupported. + CAP_PROP_RECTIFICATION =18, //!< Rectification flag for stereo cameras (note: only supported by DC1394 v 2.x backend currently). CAP_PROP_MONOCHROME =19, CAP_PROP_SHARPNESS =20, - CAP_PROP_AUTO_EXPOSURE =21, // DC1394: exposure control done by camera, user can adjust refernce level using this feature + CAP_PROP_AUTO_EXPOSURE =21, //!< DC1394: exposure control done by camera, user can adjust reference level using this feature. CAP_PROP_GAMMA =22, CAP_PROP_TEMPERATURE =23, CAP_PROP_TRIGGER =24, @@ -139,40 +150,43 @@ enum { CAP_PROP_POS_MSEC =0, }; -// Generic camera output modes. -// Currently, these are supported through the libv4l interface only. -enum { CAP_MODE_BGR = 0, // BGR24 (default) - CAP_MODE_RGB = 1, // RGB24 - CAP_MODE_GRAY = 2, // Y8 - CAP_MODE_YUYV = 3 // YUYV +//! @brief Generic camera output modes. +//! @note Currently, these are supported through the libv4l interface only. +enum { CAP_MODE_BGR = 0, //!< BGR24 (default) + CAP_MODE_RGB = 1, //!< RGB24 + CAP_MODE_GRAY = 2, //!< Y8 + CAP_MODE_YUYV = 3 //!< YUYV }; -// DC1394 only -// modes of the controlling registers (can be: auto, manual, auto single push, absolute Latter allowed with any other mode) -// every feature can have only one mode turned on at a time -enum { CAP_PROP_DC1394_OFF = -4, //turn the feature off (not controlled manually nor automatically) - CAP_PROP_DC1394_MODE_MANUAL = -3, //set automatically when a value of the feature is set by the user +/** @brief DC1394 only + +modes of the controlling registers (can be: auto, manual, auto single push, absolute Latter allowed with any other mode) +every feature can have only one mode turned on at a time +*/ +enum { CAP_PROP_DC1394_OFF = -4, //!< turn the feature off (not controlled manually nor automatically). + CAP_PROP_DC1394_MODE_MANUAL = -3, //!< set automatically when a value of the feature is set by the user. CAP_PROP_DC1394_MODE_AUTO = -2, CAP_PROP_DC1394_MODE_ONE_PUSH_AUTO = -1, CAP_PROP_DC1394_MAX = 31 }; -// OpenNI map generators +//! OpenNI map generators enum { CAP_OPENNI_DEPTH_GENERATOR = 1 << 31, CAP_OPENNI_IMAGE_GENERATOR = 1 << 30, - CAP_OPENNI_GENERATORS_MASK = CAP_OPENNI_DEPTH_GENERATOR + CAP_OPENNI_IMAGE_GENERATOR + CAP_OPENNI_IR_GENERATOR = 1 << 29, + CAP_OPENNI_GENERATORS_MASK = CAP_OPENNI_DEPTH_GENERATOR + CAP_OPENNI_IMAGE_GENERATOR + CAP_OPENNI_IR_GENERATOR }; -// Properties of cameras available through OpenNI interfaces +//! Properties of cameras available through OpenNI interfaces enum { CAP_PROP_OPENNI_OUTPUT_MODE = 100, - CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101, // in mm - CAP_PROP_OPENNI_BASELINE = 102, // in mm - CAP_PROP_OPENNI_FOCAL_LENGTH = 103, // in pixels - CAP_PROP_OPENNI_REGISTRATION = 104, // flag that synchronizes the remapping depth map to image map - // by changing depth generator's view point (if the flag is "on") or - // sets this view point to its normal one (if the flag is "off"). + CAP_PROP_OPENNI_FRAME_MAX_DEPTH = 101, //!< In mm + CAP_PROP_OPENNI_BASELINE = 102, //!< In mm + CAP_PROP_OPENNI_FOCAL_LENGTH = 103, //!< In pixels + CAP_PROP_OPENNI_REGISTRATION = 104, //!< Flag that synchronizes the remapping depth map to image map + //!< by changing depth generator's view point (if the flag is "on") or + //!< sets this view point to its normal one (if the flag is "off"). CAP_PROP_OPENNI_REGISTRATION_ON = CAP_PROP_OPENNI_REGISTRATION, CAP_PROP_OPENNI_APPROX_FRAME_SYNC = 105, CAP_PROP_OPENNI_MAX_BUFFER_SIZE = 106, @@ -183,28 +197,31 @@ enum { CAP_PROP_OPENNI_OUTPUT_MODE = 100, CAP_PROP_OPENNI2_MIRROR = 111 }; -// OpenNI shortcats +//! OpenNI shortcuts enum { CAP_OPENNI_IMAGE_GENERATOR_PRESENT = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT, CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = CAP_OPENNI_IMAGE_GENERATOR + CAP_PROP_OPENNI_OUTPUT_MODE, + CAP_OPENNI_DEPTH_GENERATOR_PRESENT = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT, CAP_OPENNI_DEPTH_GENERATOR_BASELINE = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_BASELINE, CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_FOCAL_LENGTH, CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = CAP_OPENNI_DEPTH_GENERATOR + CAP_PROP_OPENNI_REGISTRATION, - CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION + CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION, + CAP_OPENNI_IR_GENERATOR_PRESENT = CAP_OPENNI_IR_GENERATOR + CAP_PROP_OPENNI_GENERATOR_PRESENT, }; -// OpenNI data given from depth generator -enum { CAP_OPENNI_DEPTH_MAP = 0, // Depth values in mm (CV_16UC1) - CAP_OPENNI_POINT_CLOUD_MAP = 1, // XYZ in meters (CV_32FC3) - CAP_OPENNI_DISPARITY_MAP = 2, // Disparity in pixels (CV_8UC1) - CAP_OPENNI_DISPARITY_MAP_32F = 3, // Disparity in pixels (CV_32FC1) - CAP_OPENNI_VALID_DEPTH_MASK = 4, // CV_8UC1 +//! OpenNI data given from depth generator +enum { CAP_OPENNI_DEPTH_MAP = 0, //!< Depth values in mm (CV_16UC1) + CAP_OPENNI_POINT_CLOUD_MAP = 1, //!< XYZ in meters (CV_32FC3) + CAP_OPENNI_DISPARITY_MAP = 2, //!< Disparity in pixels (CV_8UC1) + CAP_OPENNI_DISPARITY_MAP_32F = 3, //!< Disparity in pixels (CV_32FC1) + CAP_OPENNI_VALID_DEPTH_MASK = 4, //!< CV_8UC1 - // Data given from RGB image generator - CAP_OPENNI_BGR_IMAGE = 5, - CAP_OPENNI_GRAY_IMAGE = 6 + CAP_OPENNI_BGR_IMAGE = 5, //!< Data given from RGB image generator + CAP_OPENNI_GRAY_IMAGE = 6, //!< Data given from RGB image generator + + CAP_OPENNI_IR_IMAGE = 7 //!< Data given from IR image generator }; -// Supported output modes of OpenNI image generator +//! Supported output modes of OpenNI image generator enum { CAP_OPENNI_VGA_30HZ = 0, CAP_OPENNI_SXGA_15HZ = 1, CAP_OPENNI_SXGA_30HZ = 2, @@ -213,202 +230,202 @@ enum { CAP_OPENNI_VGA_30HZ = 0, }; -// GStreamer -enum { CAP_PROP_GSTREAMER_QUEUE_LENGTH = 200 // default is 1 +//! GStreamer +enum { CAP_PROP_GSTREAMER_QUEUE_LENGTH = 200 //!< Default is 1 }; -// PVAPI -enum { CAP_PROP_PVAPI_MULTICASTIP = 300, // ip for anable multicast master mode. 0 for disable multicast - CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301, // FrameStartTriggerMode: Determines how a frame is initiated - CAP_PROP_PVAPI_DECIMATIONHORIZONTAL = 302, // Horizontal sub-sampling of the image - CAP_PROP_PVAPI_DECIMATIONVERTICAL = 303, // Vertical sub-sampling of the image - CAP_PROP_PVAPI_BINNINGX = 304, // Horizontal binning factor - CAP_PROP_PVAPI_BINNINGY = 305, // Vertical binning factor - CAP_PROP_PVAPI_PIXELFORMAT = 306 // Pixel format +//! PVAPI +enum { CAP_PROP_PVAPI_MULTICASTIP = 300, //!< IP for enable multicast master mode. 0 for disable multicast. + CAP_PROP_PVAPI_FRAMESTARTTRIGGERMODE = 301, //!< FrameStartTriggerMode: Determines how a frame is initiated. + CAP_PROP_PVAPI_DECIMATIONHORIZONTAL = 302, //!< Horizontal sub-sampling of the image. + CAP_PROP_PVAPI_DECIMATIONVERTICAL = 303, //!< Vertical sub-sampling of the image. + CAP_PROP_PVAPI_BINNINGX = 304, //!< Horizontal binning factor. + CAP_PROP_PVAPI_BINNINGY = 305, //!< Vertical binning factor. + CAP_PROP_PVAPI_PIXELFORMAT = 306 //!< Pixel format. }; -// PVAPI: FrameStartTriggerMode -enum { CAP_PVAPI_FSTRIGMODE_FREERUN = 0, // Freerun - CAP_PVAPI_FSTRIGMODE_SYNCIN1 = 1, // SyncIn1 - CAP_PVAPI_FSTRIGMODE_SYNCIN2 = 2, // SyncIn2 - CAP_PVAPI_FSTRIGMODE_FIXEDRATE = 3, // FixedRate - CAP_PVAPI_FSTRIGMODE_SOFTWARE = 4 // Software +//! PVAPI: FrameStartTriggerMode +enum { CAP_PVAPI_FSTRIGMODE_FREERUN = 0, //!< Freerun + CAP_PVAPI_FSTRIGMODE_SYNCIN1 = 1, //!< SyncIn1 + CAP_PVAPI_FSTRIGMODE_SYNCIN2 = 2, //!< SyncIn2 + CAP_PVAPI_FSTRIGMODE_FIXEDRATE = 3, //!< FixedRate + CAP_PVAPI_FSTRIGMODE_SOFTWARE = 4 //!< Software }; -// PVAPI: DecimationHorizontal, DecimationVertical -enum { CAP_PVAPI_DECIMATION_OFF = 1, // Off - CAP_PVAPI_DECIMATION_2OUTOF4 = 2, // 2 out of 4 decimation - CAP_PVAPI_DECIMATION_2OUTOF8 = 4, // 2 out of 8 decimation - CAP_PVAPI_DECIMATION_2OUTOF16 = 8 // 2 out of 16 decimation +//! PVAPI: DecimationHorizontal, DecimationVertical +enum { CAP_PVAPI_DECIMATION_OFF = 1, //!< Off + CAP_PVAPI_DECIMATION_2OUTOF4 = 2, //!< 2 out of 4 decimation + CAP_PVAPI_DECIMATION_2OUTOF8 = 4, //!< 2 out of 8 decimation + CAP_PVAPI_DECIMATION_2OUTOF16 = 8 //!< 2 out of 16 decimation }; -// PVAPI: PixelFormat -enum { CAP_PVAPI_PIXELFORMAT_MONO8 = 1, // Mono8 - CAP_PVAPI_PIXELFORMAT_MONO16 = 2, // Mono16 - CAP_PVAPI_PIXELFORMAT_BAYER8 = 3, // Bayer8 - CAP_PVAPI_PIXELFORMAT_BAYER16 = 4, // Bayer16 - CAP_PVAPI_PIXELFORMAT_RGB24 = 5, // Rgb24 - CAP_PVAPI_PIXELFORMAT_BGR24 = 6, // Bgr24 - CAP_PVAPI_PIXELFORMAT_RGBA32 = 7, // Rgba32 - CAP_PVAPI_PIXELFORMAT_BGRA32 = 8, // Bgra32 +//! PVAPI: PixelFormat +enum { CAP_PVAPI_PIXELFORMAT_MONO8 = 1, //!< Mono8 + CAP_PVAPI_PIXELFORMAT_MONO16 = 2, //!< Mono16 + CAP_PVAPI_PIXELFORMAT_BAYER8 = 3, //!< Bayer8 + CAP_PVAPI_PIXELFORMAT_BAYER16 = 4, //!< Bayer16 + CAP_PVAPI_PIXELFORMAT_RGB24 = 5, //!< Rgb24 + CAP_PVAPI_PIXELFORMAT_BGR24 = 6, //!< Bgr24 + CAP_PVAPI_PIXELFORMAT_RGBA32 = 7, //!< Rgba32 + CAP_PVAPI_PIXELFORMAT_BGRA32 = 8, //!< Bgra32 }; - // Properties of cameras available through XIMEA SDK interface -enum { CAP_PROP_XI_DOWNSAMPLING = 400, // Change image resolution by binning or skipping. - CAP_PROP_XI_DATA_FORMAT = 401, // Output data format. - CAP_PROP_XI_OFFSET_X = 402, // Horizontal offset from the origin to the area of interest (in pixels). - CAP_PROP_XI_OFFSET_Y = 403, // Vertical offset from the origin to the area of interest (in pixels). - CAP_PROP_XI_TRG_SOURCE = 404, // Defines source of trigger. - CAP_PROP_XI_TRG_SOFTWARE = 405, // Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE. - CAP_PROP_XI_GPI_SELECTOR = 406, // Selects general purpose input - CAP_PROP_XI_GPI_MODE = 407, // Set general purpose input mode - CAP_PROP_XI_GPI_LEVEL = 408, // Get general purpose level - CAP_PROP_XI_GPO_SELECTOR = 409, // Selects general purpose output - CAP_PROP_XI_GPO_MODE = 410, // Set general purpose output mode - CAP_PROP_XI_LED_SELECTOR = 411, // Selects camera signalling LED - CAP_PROP_XI_LED_MODE = 412, // Define camera signalling LED functionality - CAP_PROP_XI_MANUAL_WB = 413, // Calculates White Balance(must be called during acquisition) - CAP_PROP_XI_AUTO_WB = 414, // Automatic white balance - CAP_PROP_XI_AEAG = 415, // Automatic exposure/gain - CAP_PROP_XI_EXP_PRIORITY = 416, // Exposure priority (0.5 - exposure 50%, gain 50%). - CAP_PROP_XI_AE_MAX_LIMIT = 417, // Maximum limit of exposure in AEAG procedure - CAP_PROP_XI_AG_MAX_LIMIT = 418, // Maximum limit of gain in AEAG procedure - CAP_PROP_XI_AEAG_LEVEL = 419, // Average intensity of output signal AEAG should achieve(in %) - CAP_PROP_XI_TIMEOUT = 420, // Image capture timeout in milliseconds - CAP_PROP_XI_EXPOSURE = 421, // Exposure time in microseconds - CAP_PROP_XI_EXPOSURE_BURST_COUNT = 422, // Sets the number of times of exposure in one frame. - CAP_PROP_XI_GAIN_SELECTOR = 423, // Gain selector for parameter Gain allows to select different type of gains. - CAP_PROP_XI_GAIN = 424, // Gain in dB - CAP_PROP_XI_DOWNSAMPLING_TYPE = 426, // Change image downsampling type. - CAP_PROP_XI_BINNING_SELECTOR = 427, // Binning engine selector. - CAP_PROP_XI_BINNING_VERTICAL = 428, // Vertical Binning - number of vertical photo-sensitive cells to combine together. - CAP_PROP_XI_BINNING_HORIZONTAL = 429, // Horizontal Binning - number of horizontal photo-sensitive cells to combine together. - CAP_PROP_XI_BINNING_PATTERN = 430, // Binning pattern type. - CAP_PROP_XI_DECIMATION_SELECTOR = 431, // Decimation engine selector. - CAP_PROP_XI_DECIMATION_VERTICAL = 432, // Vertical Decimation - vertical sub-sampling of the image - reduces the vertical resolution of the image by the specified vertical decimation factor. - CAP_PROP_XI_DECIMATION_HORIZONTAL = 433, // Horizontal Decimation - horizontal sub-sampling of the image - reduces the horizontal resolution of the image by the specified vertical decimation factor. - CAP_PROP_XI_DECIMATION_PATTERN = 434, // Decimation pattern type. - CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587, // Selects which test pattern generator is controlled by the TestPattern feature. - CAP_PROP_XI_TEST_PATTERN = 588, // Selects which test pattern type is generated by the selected generator. - CAP_PROP_XI_IMAGE_DATA_FORMAT = 435, // Output data format. - CAP_PROP_XI_SHUTTER_TYPE = 436, // Change sensor shutter type(CMOS sensor). - CAP_PROP_XI_SENSOR_TAPS = 437, // Number of taps - CAP_PROP_XI_AEAG_ROI_OFFSET_X = 439, // Automatic exposure/gain ROI offset X - CAP_PROP_XI_AEAG_ROI_OFFSET_Y = 440, // Automatic exposure/gain ROI offset Y - CAP_PROP_XI_AEAG_ROI_WIDTH = 441, // Automatic exposure/gain ROI Width - CAP_PROP_XI_AEAG_ROI_HEIGHT = 442, // Automatic exposure/gain ROI Height - CAP_PROP_XI_BPC = 445, // Correction of bad pixels - CAP_PROP_XI_WB_KR = 448, // White balance red coefficient - CAP_PROP_XI_WB_KG = 449, // White balance green coefficient - CAP_PROP_XI_WB_KB = 450, // White balance blue coefficient - CAP_PROP_XI_WIDTH = 451, // Width of the Image provided by the device (in pixels). - CAP_PROP_XI_HEIGHT = 452, // Height of the Image provided by the device (in pixels). - CAP_PROP_XI_REGION_SELECTOR = 589, // Selects Region in Multiple ROI which parameters are set by width, height, ... ,region mode - CAP_PROP_XI_REGION_MODE = 595, // Activates/deactivates Region selected by Region Selector - CAP_PROP_XI_LIMIT_BANDWIDTH = 459, // Set/get bandwidth(datarate)(in Megabits) - CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH = 460, // Sensor output data bit depth. - CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH = 461, // Device output data bit depth. - CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH = 462, // bitdepth of data returned by function xiGetImage - CAP_PROP_XI_OUTPUT_DATA_PACKING = 463, // Device output data packing (or grouping) enabled. Packing could be enabled if output_data_bit_depth > 8 and packing capability is available. - CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE = 464, // Data packing type. Some cameras supports only specific packing type. - CAP_PROP_XI_IS_COOLED = 465, // Returns 1 for cameras that support cooling. - CAP_PROP_XI_COOLING = 466, // Start camera cooling. - CAP_PROP_XI_TARGET_TEMP = 467, // Set sensor target temperature for cooling. - CAP_PROP_XI_CHIP_TEMP = 468, // Camera sensor temperature - CAP_PROP_XI_HOUS_TEMP = 469, // Camera housing tepmerature - CAP_PROP_XI_HOUS_BACK_SIDE_TEMP = 590, // Camera housing back side tepmerature - CAP_PROP_XI_SENSOR_BOARD_TEMP = 596, // Camera sensor board temperature - CAP_PROP_XI_CMS = 470, // Mode of color management system. - CAP_PROP_XI_APPLY_CMS = 471, // Enable applying of CMS profiles to xiGetImage (see XI_PRM_INPUT_CMS_PROFILE, XI_PRM_OUTPUT_CMS_PROFILE). - CAP_PROP_XI_IMAGE_IS_COLOR = 474, // Returns 1 for color cameras. - CAP_PROP_XI_COLOR_FILTER_ARRAY = 475, // Returns color filter array type of RAW data. - CAP_PROP_XI_GAMMAY = 476, // Luminosity gamma - CAP_PROP_XI_GAMMAC = 477, // Chromaticity gamma - CAP_PROP_XI_SHARPNESS = 478, // Sharpness Strenght - CAP_PROP_XI_CC_MATRIX_00 = 479, // Color Correction Matrix element [0][0] - CAP_PROP_XI_CC_MATRIX_01 = 480, // Color Correction Matrix element [0][1] - CAP_PROP_XI_CC_MATRIX_02 = 481, // Color Correction Matrix element [0][2] - CAP_PROP_XI_CC_MATRIX_03 = 482, // Color Correction Matrix element [0][3] - CAP_PROP_XI_CC_MATRIX_10 = 483, // Color Correction Matrix element [1][0] - CAP_PROP_XI_CC_MATRIX_11 = 484, // Color Correction Matrix element [1][1] - CAP_PROP_XI_CC_MATRIX_12 = 485, // Color Correction Matrix element [1][2] - CAP_PROP_XI_CC_MATRIX_13 = 486, // Color Correction Matrix element [1][3] - CAP_PROP_XI_CC_MATRIX_20 = 487, // Color Correction Matrix element [2][0] - CAP_PROP_XI_CC_MATRIX_21 = 488, // Color Correction Matrix element [2][1] - CAP_PROP_XI_CC_MATRIX_22 = 489, // Color Correction Matrix element [2][2] - CAP_PROP_XI_CC_MATRIX_23 = 490, // Color Correction Matrix element [2][3] - CAP_PROP_XI_CC_MATRIX_30 = 491, // Color Correction Matrix element [3][0] - CAP_PROP_XI_CC_MATRIX_31 = 492, // Color Correction Matrix element [3][1] - CAP_PROP_XI_CC_MATRIX_32 = 493, // Color Correction Matrix element [3][2] - CAP_PROP_XI_CC_MATRIX_33 = 494, // Color Correction Matrix element [3][3] - CAP_PROP_XI_DEFAULT_CC_MATRIX = 495, // Set default Color Correction Matrix - CAP_PROP_XI_TRG_SELECTOR = 498, // Selects the type of trigger. - CAP_PROP_XI_ACQ_FRAME_BURST_COUNT = 499, // Sets number of frames acquired by burst. This burst is used only if trigger is set to FrameBurstStart - CAP_PROP_XI_DEBOUNCE_EN = 507, // Enable/Disable debounce to selected GPI - CAP_PROP_XI_DEBOUNCE_T0 = 508, // Debounce time (x * 10us) - CAP_PROP_XI_DEBOUNCE_T1 = 509, // Debounce time (x * 10us) - CAP_PROP_XI_DEBOUNCE_POL = 510, // Debounce polarity (pol = 1 t0 - falling edge, t1 - rising edge) - CAP_PROP_XI_LENS_MODE = 511, // Status of lens control interface. This shall be set to XI_ON before any Lens operations. - CAP_PROP_XI_LENS_APERTURE_VALUE = 512, // Current lens aperture value in stops. Examples: 2.8, 4, 5.6, 8, 11 - CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE = 513, // Lens current focus movement value to be used by XI_PRM_LENS_FOCUS_MOVE in motor steps. - CAP_PROP_XI_LENS_FOCUS_MOVE = 514, // Moves lens focus motor by steps set in XI_PRM_LENS_FOCUS_MOVEMENT_VALUE. - CAP_PROP_XI_LENS_FOCUS_DISTANCE = 515, // Lens focus distance in cm. - CAP_PROP_XI_LENS_FOCAL_LENGTH = 516, // Lens focal distance in mm. - CAP_PROP_XI_LENS_FEATURE_SELECTOR = 517, // Selects the current feature which is accessible by XI_PRM_LENS_FEATURE. - CAP_PROP_XI_LENS_FEATURE = 518, // Allows access to lens feature value currently selected by XI_PRM_LENS_FEATURE_SELECTOR. - CAP_PROP_XI_DEVICE_MODEL_ID = 521, // Return device model id - CAP_PROP_XI_DEVICE_SN = 522, // Return device serial number - CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA = 529, // The alpha channel of RGB32 output image format. - CAP_PROP_XI_IMAGE_PAYLOAD_SIZE = 530, // Buffer size in bytes sufficient for output image returned by xiGetImage - CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT = 531, // Current format of pixels on transport layer. - CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ = 532, // Sensor clock frequency in Hz. - CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX = 533, // Sensor clock frequency index. Sensor with selected frequencies have possibility to set the frequency only by this index. - CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT = 534, // Number of output channels from sensor used for data transfer. - CAP_PROP_XI_FRAMERATE = 535, // Define framerate in Hz - CAP_PROP_XI_COUNTER_SELECTOR = 536, // Select counter - CAP_PROP_XI_COUNTER_VALUE = 537, // Counter status - CAP_PROP_XI_ACQ_TIMING_MODE = 538, // Type of sensor frames timing. - CAP_PROP_XI_AVAILABLE_BANDWIDTH = 539, // Calculate and return available interface bandwidth(int Megabits) - CAP_PROP_XI_BUFFER_POLICY = 540, // Data move policy - CAP_PROP_XI_LUT_EN = 541, // Activates LUT. - CAP_PROP_XI_LUT_INDEX = 542, // Control the index (offset) of the coefficient to access in the LUT. - CAP_PROP_XI_LUT_VALUE = 543, // Value at entry LUTIndex of the LUT - CAP_PROP_XI_TRG_DELAY = 544, // Specifies the delay in microseconds (us) to apply after the trigger reception before activating it. - CAP_PROP_XI_TS_RST_MODE = 545, // Defines how time stamp reset engine will be armed - CAP_PROP_XI_TS_RST_SOURCE = 546, // Defines which source will be used for timestamp reset. Writing this parameter will trigger settings of engine (arming) - CAP_PROP_XI_IS_DEVICE_EXIST = 547, // Returns 1 if camera connected and works properly. - CAP_PROP_XI_ACQ_BUFFER_SIZE = 548, // Acquisition buffer size in buffer_size_unit. Default bytes. - CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT = 549, // Acquisition buffer size unit in bytes. Default 1. E.g. Value 1024 means that buffer_size is in KiBytes - CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE = 550, // Acquisition transport buffer size in bytes - CAP_PROP_XI_BUFFERS_QUEUE_SIZE = 551, // Queue of field/frame buffers - CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT = 552, // Number of buffers to commit to low level - CAP_PROP_XI_RECENT_FRAME = 553, // GetImage returns most recent frame - CAP_PROP_XI_DEVICE_RESET = 554, // Resets the camera to default state. - CAP_PROP_XI_COLUMN_FPN_CORRECTION = 555, // Correction of column FPN - CAP_PROP_XI_ROW_FPN_CORRECTION = 591, // Correction of row FPN - CAP_PROP_XI_SENSOR_MODE = 558, // Current sensor mode. Allows to select sensor mode by one integer. Setting of this parameter affects: image dimensions and downsampling. - CAP_PROP_XI_HDR = 559, // Enable High Dynamic Range feature. - CAP_PROP_XI_HDR_KNEEPOINT_COUNT = 560, // The number of kneepoints in the PWLR. - CAP_PROP_XI_HDR_T1 = 561, // position of first kneepoint(in % of XI_PRM_EXPOSURE) - CAP_PROP_XI_HDR_T2 = 562, // position of second kneepoint (in % of XI_PRM_EXPOSURE) - CAP_PROP_XI_KNEEPOINT1 = 563, // value of first kneepoint (% of sensor saturation) - CAP_PROP_XI_KNEEPOINT2 = 564, // value of second kneepoint (% of sensor saturation) - CAP_PROP_XI_IMAGE_BLACK_LEVEL = 565, // Last image black level counts. Can be used for Offline processing to recall it. - CAP_PROP_XI_HW_REVISION = 571, // Returns hardware revision number. - CAP_PROP_XI_DEBUG_LEVEL = 572, // Set debug level - CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION = 573, // Automatic bandwidth calculation, - CAP_PROP_XI_FFS_FILE_ID = 594, // File number. - CAP_PROP_XI_FFS_FILE_SIZE = 580, // Size of file. - CAP_PROP_XI_FREE_FFS_SIZE = 581, // Size of free camera FFS. - CAP_PROP_XI_USED_FFS_SIZE = 582, // Size of used camera FFS. - CAP_PROP_XI_FFS_ACCESS_KEY = 583, // Setting of key enables file operations on some cameras. - CAP_PROP_XI_SENSOR_FEATURE_SELECTOR = 585, // Selects the current feature which is accessible by XI_PRM_SENSOR_FEATURE_VALUE. - CAP_PROP_XI_SENSOR_FEATURE_VALUE = 586, // Allows access to sensor feature value currently selected by XI_PRM_SENSOR_FEATURE_SELECTOR. +//! Properties of cameras available through XIMEA SDK interface +enum { CAP_PROP_XI_DOWNSAMPLING = 400, //!< Change image resolution by binning or skipping. + CAP_PROP_XI_DATA_FORMAT = 401, //!< Output data format. + CAP_PROP_XI_OFFSET_X = 402, //!< Horizontal offset from the origin to the area of interest (in pixels). + CAP_PROP_XI_OFFSET_Y = 403, //!< Vertical offset from the origin to the area of interest (in pixels). + CAP_PROP_XI_TRG_SOURCE = 404, //!< Defines source of trigger. + CAP_PROP_XI_TRG_SOFTWARE = 405, //!< Generates an internal trigger. PRM_TRG_SOURCE must be set to TRG_SOFTWARE. + CAP_PROP_XI_GPI_SELECTOR = 406, //!< Selects general purpose input. + CAP_PROP_XI_GPI_MODE = 407, //!< Set general purpose input mode. + CAP_PROP_XI_GPI_LEVEL = 408, //!< Get general purpose level. + CAP_PROP_XI_GPO_SELECTOR = 409, //!< Selects general purpose output. + CAP_PROP_XI_GPO_MODE = 410, //!< Set general purpose output mode. + CAP_PROP_XI_LED_SELECTOR = 411, //!< Selects camera signalling LED. + CAP_PROP_XI_LED_MODE = 412, //!< Define camera signalling LED functionality. + CAP_PROP_XI_MANUAL_WB = 413, //!< Calculates White Balance(must be called during acquisition). + CAP_PROP_XI_AUTO_WB = 414, //!< Automatic white balance. + CAP_PROP_XI_AEAG = 415, //!< Automatic exposure/gain. + CAP_PROP_XI_EXP_PRIORITY = 416, //!< Exposure priority (0.5 - exposure 50%, gain 50%). + CAP_PROP_XI_AE_MAX_LIMIT = 417, //!< Maximum limit of exposure in AEAG procedure. + CAP_PROP_XI_AG_MAX_LIMIT = 418, //!< Maximum limit of gain in AEAG procedure. + CAP_PROP_XI_AEAG_LEVEL = 419, //!< Average intensity of output signal AEAG should achieve(in %). + CAP_PROP_XI_TIMEOUT = 420, //!< Image capture timeout in milliseconds. + CAP_PROP_XI_EXPOSURE = 421, //!< Exposure time in microseconds. + CAP_PROP_XI_EXPOSURE_BURST_COUNT = 422, //!< Sets the number of times of exposure in one frame. + CAP_PROP_XI_GAIN_SELECTOR = 423, //!< Gain selector for parameter Gain allows to select different type of gains. + CAP_PROP_XI_GAIN = 424, //!< Gain in dB. + CAP_PROP_XI_DOWNSAMPLING_TYPE = 426, //!< Change image downsampling type. + CAP_PROP_XI_BINNING_SELECTOR = 427, //!< Binning engine selector. + CAP_PROP_XI_BINNING_VERTICAL = 428, //!< Vertical Binning - number of vertical photo-sensitive cells to combine together. + CAP_PROP_XI_BINNING_HORIZONTAL = 429, //!< Horizontal Binning - number of horizontal photo-sensitive cells to combine together. + CAP_PROP_XI_BINNING_PATTERN = 430, //!< Binning pattern type. + CAP_PROP_XI_DECIMATION_SELECTOR = 431, //!< Decimation engine selector. + CAP_PROP_XI_DECIMATION_VERTICAL = 432, //!< Vertical Decimation - vertical sub-sampling of the image - reduces the vertical resolution of the image by the specified vertical decimation factor. + CAP_PROP_XI_DECIMATION_HORIZONTAL = 433, //!< Horizontal Decimation - horizontal sub-sampling of the image - reduces the horizontal resolution of the image by the specified vertical decimation factor. + CAP_PROP_XI_DECIMATION_PATTERN = 434, //!< Decimation pattern type. + CAP_PROP_XI_TEST_PATTERN_GENERATOR_SELECTOR = 587, //!< Selects which test pattern generator is controlled by the TestPattern feature. + CAP_PROP_XI_TEST_PATTERN = 588, //!< Selects which test pattern type is generated by the selected generator. + CAP_PROP_XI_IMAGE_DATA_FORMAT = 435, //!< Output data format. + CAP_PROP_XI_SHUTTER_TYPE = 436, //!< Change sensor shutter type(CMOS sensor). + CAP_PROP_XI_SENSOR_TAPS = 437, //!< Number of taps. + CAP_PROP_XI_AEAG_ROI_OFFSET_X = 439, //!< Automatic exposure/gain ROI offset X. + CAP_PROP_XI_AEAG_ROI_OFFSET_Y = 440, //!< Automatic exposure/gain ROI offset Y. + CAP_PROP_XI_AEAG_ROI_WIDTH = 441, //!< Automatic exposure/gain ROI Width. + CAP_PROP_XI_AEAG_ROI_HEIGHT = 442, //!< Automatic exposure/gain ROI Height. + CAP_PROP_XI_BPC = 445, //!< Correction of bad pixels. + CAP_PROP_XI_WB_KR = 448, //!< White balance red coefficient. + CAP_PROP_XI_WB_KG = 449, //!< White balance green coefficient. + CAP_PROP_XI_WB_KB = 450, //!< White balance blue coefficient. + CAP_PROP_XI_WIDTH = 451, //!< Width of the Image provided by the device (in pixels). + CAP_PROP_XI_HEIGHT = 452, //!< Height of the Image provided by the device (in pixels). + CAP_PROP_XI_REGION_SELECTOR = 589, //!< Selects Region in Multiple ROI which parameters are set by width, height, ... ,region mode. + CAP_PROP_XI_REGION_MODE = 595, //!< Activates/deactivates Region selected by Region Selector. + CAP_PROP_XI_LIMIT_BANDWIDTH = 459, //!< Set/get bandwidth(datarate)(in Megabits). + CAP_PROP_XI_SENSOR_DATA_BIT_DEPTH = 460, //!< Sensor output data bit depth. + CAP_PROP_XI_OUTPUT_DATA_BIT_DEPTH = 461, //!< Device output data bit depth. + CAP_PROP_XI_IMAGE_DATA_BIT_DEPTH = 462, //!< bitdepth of data returned by function xiGetImage. + CAP_PROP_XI_OUTPUT_DATA_PACKING = 463, //!< Device output data packing (or grouping) enabled. Packing could be enabled if output_data_bit_depth > 8 and packing capability is available. + CAP_PROP_XI_OUTPUT_DATA_PACKING_TYPE = 464, //!< Data packing type. Some cameras supports only specific packing type. + CAP_PROP_XI_IS_COOLED = 465, //!< Returns 1 for cameras that support cooling. + CAP_PROP_XI_COOLING = 466, //!< Start camera cooling. + CAP_PROP_XI_TARGET_TEMP = 467, //!< Set sensor target temperature for cooling. + CAP_PROP_XI_CHIP_TEMP = 468, //!< Camera sensor temperature. + CAP_PROP_XI_HOUS_TEMP = 469, //!< Camera housing temperature. + CAP_PROP_XI_HOUS_BACK_SIDE_TEMP = 590, //!< Camera housing back side temperature. + CAP_PROP_XI_SENSOR_BOARD_TEMP = 596, //!< Camera sensor board temperature. + CAP_PROP_XI_CMS = 470, //!< Mode of color management system. + CAP_PROP_XI_APPLY_CMS = 471, //!< Enable applying of CMS profiles to xiGetImage (see XI_PRM_INPUT_CMS_PROFILE, XI_PRM_OUTPUT_CMS_PROFILE). + CAP_PROP_XI_IMAGE_IS_COLOR = 474, //!< Returns 1 for color cameras. + CAP_PROP_XI_COLOR_FILTER_ARRAY = 475, //!< Returns color filter array type of RAW data. + CAP_PROP_XI_GAMMAY = 476, //!< Luminosity gamma. + CAP_PROP_XI_GAMMAC = 477, //!< Chromaticity gamma. + CAP_PROP_XI_SHARPNESS = 478, //!< Sharpness Strength. + CAP_PROP_XI_CC_MATRIX_00 = 479, //!< Color Correction Matrix element [0][0]. + CAP_PROP_XI_CC_MATRIX_01 = 480, //!< Color Correction Matrix element [0][1]. + CAP_PROP_XI_CC_MATRIX_02 = 481, //!< Color Correction Matrix element [0][2]. + CAP_PROP_XI_CC_MATRIX_03 = 482, //!< Color Correction Matrix element [0][3]. + CAP_PROP_XI_CC_MATRIX_10 = 483, //!< Color Correction Matrix element [1][0]. + CAP_PROP_XI_CC_MATRIX_11 = 484, //!< Color Correction Matrix element [1][1]. + CAP_PROP_XI_CC_MATRIX_12 = 485, //!< Color Correction Matrix element [1][2]. + CAP_PROP_XI_CC_MATRIX_13 = 486, //!< Color Correction Matrix element [1][3]. + CAP_PROP_XI_CC_MATRIX_20 = 487, //!< Color Correction Matrix element [2][0]. + CAP_PROP_XI_CC_MATRIX_21 = 488, //!< Color Correction Matrix element [2][1]. + CAP_PROP_XI_CC_MATRIX_22 = 489, //!< Color Correction Matrix element [2][2]. + CAP_PROP_XI_CC_MATRIX_23 = 490, //!< Color Correction Matrix element [2][3]. + CAP_PROP_XI_CC_MATRIX_30 = 491, //!< Color Correction Matrix element [3][0]. + CAP_PROP_XI_CC_MATRIX_31 = 492, //!< Color Correction Matrix element [3][1]. + CAP_PROP_XI_CC_MATRIX_32 = 493, //!< Color Correction Matrix element [3][2]. + CAP_PROP_XI_CC_MATRIX_33 = 494, //!< Color Correction Matrix element [3][3]. + CAP_PROP_XI_DEFAULT_CC_MATRIX = 495, //!< Set default Color Correction Matrix. + CAP_PROP_XI_TRG_SELECTOR = 498, //!< Selects the type of trigger. + CAP_PROP_XI_ACQ_FRAME_BURST_COUNT = 499, //!< Sets number of frames acquired by burst. This burst is used only if trigger is set to FrameBurstStart. + CAP_PROP_XI_DEBOUNCE_EN = 507, //!< Enable/Disable debounce to selected GPI. + CAP_PROP_XI_DEBOUNCE_T0 = 508, //!< Debounce time (x * 10us). + CAP_PROP_XI_DEBOUNCE_T1 = 509, //!< Debounce time (x * 10us). + CAP_PROP_XI_DEBOUNCE_POL = 510, //!< Debounce polarity (pol = 1 t0 - falling edge, t1 - rising edge). + CAP_PROP_XI_LENS_MODE = 511, //!< Status of lens control interface. This shall be set to XI_ON before any Lens operations. + CAP_PROP_XI_LENS_APERTURE_VALUE = 512, //!< Current lens aperture value in stops. Examples: 2.8, 4, 5.6, 8, 11. + CAP_PROP_XI_LENS_FOCUS_MOVEMENT_VALUE = 513, //!< Lens current focus movement value to be used by XI_PRM_LENS_FOCUS_MOVE in motor steps. + CAP_PROP_XI_LENS_FOCUS_MOVE = 514, //!< Moves lens focus motor by steps set in XI_PRM_LENS_FOCUS_MOVEMENT_VALUE. + CAP_PROP_XI_LENS_FOCUS_DISTANCE = 515, //!< Lens focus distance in cm. + CAP_PROP_XI_LENS_FOCAL_LENGTH = 516, //!< Lens focal distance in mm. + CAP_PROP_XI_LENS_FEATURE_SELECTOR = 517, //!< Selects the current feature which is accessible by XI_PRM_LENS_FEATURE. + CAP_PROP_XI_LENS_FEATURE = 518, //!< Allows access to lens feature value currently selected by XI_PRM_LENS_FEATURE_SELECTOR. + CAP_PROP_XI_DEVICE_MODEL_ID = 521, //!< Return device model id. + CAP_PROP_XI_DEVICE_SN = 522, //!< Return device serial number. + CAP_PROP_XI_IMAGE_DATA_FORMAT_RGB32_ALPHA = 529, //!< The alpha channel of RGB32 output image format. + CAP_PROP_XI_IMAGE_PAYLOAD_SIZE = 530, //!< Buffer size in bytes sufficient for output image returned by xiGetImage. + CAP_PROP_XI_TRANSPORT_PIXEL_FORMAT = 531, //!< Current format of pixels on transport layer. + CAP_PROP_XI_SENSOR_CLOCK_FREQ_HZ = 532, //!< Sensor clock frequency in Hz. + CAP_PROP_XI_SENSOR_CLOCK_FREQ_INDEX = 533, //!< Sensor clock frequency index. Sensor with selected frequencies have possibility to set the frequency only by this index. + CAP_PROP_XI_SENSOR_OUTPUT_CHANNEL_COUNT = 534, //!< Number of output channels from sensor used for data transfer. + CAP_PROP_XI_FRAMERATE = 535, //!< Define framerate in Hz. + CAP_PROP_XI_COUNTER_SELECTOR = 536, //!< Select counter. + CAP_PROP_XI_COUNTER_VALUE = 537, //!< Counter status. + CAP_PROP_XI_ACQ_TIMING_MODE = 538, //!< Type of sensor frames timing. + CAP_PROP_XI_AVAILABLE_BANDWIDTH = 539, //!< Calculate and return available interface bandwidth(int Megabits). + CAP_PROP_XI_BUFFER_POLICY = 540, //!< Data move policy. + CAP_PROP_XI_LUT_EN = 541, //!< Activates LUT. + CAP_PROP_XI_LUT_INDEX = 542, //!< Control the index (offset) of the coefficient to access in the LUT. + CAP_PROP_XI_LUT_VALUE = 543, //!< Value at entry LUTIndex of the LUT. + CAP_PROP_XI_TRG_DELAY = 544, //!< Specifies the delay in microseconds (us) to apply after the trigger reception before activating it. + CAP_PROP_XI_TS_RST_MODE = 545, //!< Defines how time stamp reset engine will be armed. + CAP_PROP_XI_TS_RST_SOURCE = 546, //!< Defines which source will be used for timestamp reset. Writing this parameter will trigger settings of engine (arming). + CAP_PROP_XI_IS_DEVICE_EXIST = 547, //!< Returns 1 if camera connected and works properly. + CAP_PROP_XI_ACQ_BUFFER_SIZE = 548, //!< Acquisition buffer size in buffer_size_unit. Default bytes. + CAP_PROP_XI_ACQ_BUFFER_SIZE_UNIT = 549, //!< Acquisition buffer size unit in bytes. Default 1. E.g. Value 1024 means that buffer_size is in KiBytes. + CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_SIZE = 550, //!< Acquisition transport buffer size in bytes. + CAP_PROP_XI_BUFFERS_QUEUE_SIZE = 551, //!< Queue of field/frame buffers. + CAP_PROP_XI_ACQ_TRANSPORT_BUFFER_COMMIT = 552, //!< Number of buffers to commit to low level. + CAP_PROP_XI_RECENT_FRAME = 553, //!< GetImage returns most recent frame. + CAP_PROP_XI_DEVICE_RESET = 554, //!< Resets the camera to default state. + CAP_PROP_XI_COLUMN_FPN_CORRECTION = 555, //!< Correction of column FPN. + CAP_PROP_XI_ROW_FPN_CORRECTION = 591, //!< Correction of row FPN. + CAP_PROP_XI_SENSOR_MODE = 558, //!< Current sensor mode. Allows to select sensor mode by one integer. Setting of this parameter affects: image dimensions and downsampling. + CAP_PROP_XI_HDR = 559, //!< Enable High Dynamic Range feature. + CAP_PROP_XI_HDR_KNEEPOINT_COUNT = 560, //!< The number of kneepoints in the PWLR. + CAP_PROP_XI_HDR_T1 = 561, //!< Position of first kneepoint(in % of XI_PRM_EXPOSURE). + CAP_PROP_XI_HDR_T2 = 562, //!< Position of second kneepoint (in % of XI_PRM_EXPOSURE). + CAP_PROP_XI_KNEEPOINT1 = 563, //!< Value of first kneepoint (% of sensor saturation). + CAP_PROP_XI_KNEEPOINT2 = 564, //!< Value of second kneepoint (% of sensor saturation). + CAP_PROP_XI_IMAGE_BLACK_LEVEL = 565, //!< Last image black level counts. Can be used for Offline processing to recall it. + CAP_PROP_XI_HW_REVISION = 571, //!< Returns hardware revision number. + CAP_PROP_XI_DEBUG_LEVEL = 572, //!< Set debug level. + CAP_PROP_XI_AUTO_BANDWIDTH_CALCULATION = 573, //!< Automatic bandwidth calculation. + CAP_PROP_XI_FFS_FILE_ID = 594, //!< File number. + CAP_PROP_XI_FFS_FILE_SIZE = 580, //!< Size of file. + CAP_PROP_XI_FREE_FFS_SIZE = 581, //!< Size of free camera FFS. + CAP_PROP_XI_USED_FFS_SIZE = 582, //!< Size of used camera FFS. + CAP_PROP_XI_FFS_ACCESS_KEY = 583, //!< Setting of key enables file operations on some cameras. + CAP_PROP_XI_SENSOR_FEATURE_SELECTOR = 585, //!< Selects the current feature which is accessible by XI_PRM_SENSOR_FEATURE_VALUE. + CAP_PROP_XI_SENSOR_FEATURE_VALUE = 586, //!< Allows access to sensor feature value currently selected by XI_PRM_SENSOR_FEATURE_SELECTOR. }; -// Properties of cameras available through AVFOUNDATION interface +//! Properties of cameras available through AVFOUNDATION interface enum { CAP_PROP_IOS_DEVICE_FOCUS = 9001, CAP_PROP_IOS_DEVICE_EXPOSURE = 9002, CAP_PROP_IOS_DEVICE_FLASH = 9003, @@ -417,7 +434,7 @@ enum { CAP_PROP_IOS_DEVICE_FOCUS = 9001, }; -// Properties of cameras available through Smartek Giganetix Ethernet Vision interface +//! Properties of cameras available through Smartek Giganetix Ethernet Vision interface /* --- Vladimir Litvinenko (litvinenko.vladimir@gmail.com) --- */ enum { CAP_PROP_GIGA_FRAME_OFFSET_X = 10001, CAP_PROP_GIGA_FRAME_OFFSET_Y = 10002, @@ -436,36 +453,39 @@ enum { CAP_PROP_INTELPERC_PROFILE_COUNT = 11001, CAP_PROP_INTELPERC_DEPTH_FOCAL_LENGTH_VERT = 11007 }; -// Intel PerC streams +//! Intel PerC streams enum { CAP_INTELPERC_DEPTH_GENERATOR = 1 << 29, CAP_INTELPERC_IMAGE_GENERATOR = 1 << 28, CAP_INTELPERC_GENERATORS_MASK = CAP_INTELPERC_DEPTH_GENERATOR + CAP_INTELPERC_IMAGE_GENERATOR }; -enum { CAP_INTELPERC_DEPTH_MAP = 0, // Each pixel is a 16-bit integer. The value indicates the distance from an object to the camera's XY plane or the Cartesian depth. - CAP_INTELPERC_UVDEPTH_MAP = 1, // Each pixel contains two 32-bit floating point values in the range of 0-1, representing the mapping of depth coordinates to the color coordinates. - CAP_INTELPERC_IR_MAP = 2, // Each pixel is a 16-bit integer. The value indicates the intensity of the reflected laser beam. +enum { CAP_INTELPERC_DEPTH_MAP = 0, //!< Each pixel is a 16-bit integer. The value indicates the distance from an object to the camera's XY plane or the Cartesian depth. + CAP_INTELPERC_UVDEPTH_MAP = 1, //!< Each pixel contains two 32-bit floating point values in the range of 0-1, representing the mapping of depth coordinates to the color coordinates. + CAP_INTELPERC_IR_MAP = 2, //!< Each pixel is a 16-bit integer. The value indicates the intensity of the reflected laser beam. CAP_INTELPERC_IMAGE = 3 }; -enum { VIDEOWRITER_PROP_QUALITY = 1, // Quality (0..100%) of the videostream encoded - VIDEOWRITER_PROP_FRAMEBYTES = 2, // (Read-only): Size of just encoded video frame - VIDEOWRITER_PROP_NSTRIPES = 3 // Number of stripes for parallel encoding. -1 for auto detection +enum { VIDEOWRITER_PROP_QUALITY = 1, //!< Current quality (0..100%) of the encoded videostream. Can be adjusted dynamically in some codecs. + VIDEOWRITER_PROP_FRAMEBYTES = 2, //!< (Read-only): Size of just encoded video frame. Note that the encoding order may be different from representation order. + VIDEOWRITER_PROP_NSTRIPES = 3 //!< Number of stripes for parallel encoding. -1 for auto detection. }; -// gPhoto2 properties, if propertyId is less than 0 then work on widget with that __additive inversed__ camera setting ID -// Get IDs by using CAP_PROP_GPHOTO2_WIDGET_ENUMERATE. -// @see CvCaptureCAM_GPHOTO2 for more info -enum { CAP_PROP_GPHOTO2_PREVIEW = 17001, // Capture only preview from liveview mode. - CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002, // Readonly, returns (const char *). - CAP_PROP_GPHOTO2_RELOAD_CONFIG = 17003, // Trigger, only by set. Reload camera settings. - CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004, // Reload all settings on set. - CAP_PROP_GPHOTO2_COLLECT_MSGS = 17005, // Collect messages with details. - CAP_PROP_GPHOTO2_FLUSH_MSGS = 17006, // Readonly, returns (const char *). - CAP_PROP_SPEED = 17007, // Exposure speed. Can be readonly, depends on camera program. - CAP_PROP_APERTURE = 17008, // Aperture. Can be readonly, depends on camera program. - CAP_PROP_EXPOSUREPROGRAM = 17009, // Camera exposure program. - CAP_PROP_VIEWFINDER = 17010 // Enter liveview mode. +/** @brief gPhoto2 properties + +if propertyId is less than 0 then work on widget with that __additive inversed__ camera setting ID +Get IDs by using CAP_PROP_GPHOTO2_WIDGET_ENUMERATE. +@see CvCaptureCAM_GPHOTO2 for more info +*/ +enum { CAP_PROP_GPHOTO2_PREVIEW = 17001, //!< Capture only preview from liveview mode. + CAP_PROP_GPHOTO2_WIDGET_ENUMERATE = 17002, //!< Readonly, returns (const char *). + CAP_PROP_GPHOTO2_RELOAD_CONFIG = 17003, //!< Trigger, only by set. Reload camera settings. + CAP_PROP_GPHOTO2_RELOAD_ON_CHANGE = 17004, //!< Reload all settings on set. + CAP_PROP_GPHOTO2_COLLECT_MSGS = 17005, //!< Collect messages with details. + CAP_PROP_GPHOTO2_FLUSH_MSGS = 17006, //!< Readonly, returns (const char *). + CAP_PROP_SPEED = 17007, //!< Exposure speed. Can be readonly, depends on camera program. + CAP_PROP_APERTURE = 17008, //!< Aperture. Can be readonly, depends on camera program. + CAP_PROP_EXPOSUREPROGRAM = 17009, //!< Camera exposure program. + CAP_PROP_VIEWFINDER = 17010 //!< Enter liveview mode. }; //enum { @@ -537,13 +557,13 @@ public: img_%02d.jpg, which will read samples like img_00.jpg, img_01.jpg, img_02.jpg, ...) @param apiPreference preferred Capture API to use. Can be used to enforce a specific reader - implementation if multiple are available: e.g. CAP_FFMPEG or CAP_IMAGES + implementation if multiple are available: e.g. cv::CAP_FFMPEG or cv::CAP_IMAGES */ CV_WRAP VideoCapture(const String& filename, int apiPreference); /** @overload @param index = camera_id + domain_offset (CAP_*). id of the video capturing device to open. If there is a single - camera connected, just pass 0. Advanced Usage: to open Camera 1 using the MS Media Foundation API: index = 1 + CAP_MSMF + camera connected, just pass 0. Advanced Usage: to open Camera 1 using the MS Media Foundation API: index = 1 + cv::CAP_MSMF */ CV_WRAP VideoCapture(int index); @@ -560,7 +580,7 @@ public: /** @overload @param index = camera_id + domain_offset (CAP_*). id of the video capturing device to open. If there is a single - camera connected, just pass 0. Advanced Usage: to open Camera 1 using the MS Media Foundation API: index = 1 + CAP_MSMF + camera connected, just pass 0. Advanced Usage: to open Camera 1 using the MS Media Foundation API: index = 1 + cv::CAP_MSMF */ CV_WRAP virtual bool open(int index); @@ -628,28 +648,26 @@ public: /** @brief Sets a property in the VideoCapture. @param propId Property identifier. It can be one of the following: - - **CAP_PROP_POS_MSEC** Current position of the video file in milliseconds. - - **CAP_PROP_POS_FRAMES** 0-based index of the frame to be decoded/captured next. - - **CAP_PROP_POS_AVI_RATIO** Relative position of the video file: 0 - start of the - film, 1 - end of the film. - - **CAP_PROP_FRAME_WIDTH** Width of the frames in the video stream. - - **CAP_PROP_FRAME_HEIGHT** Height of the frames in the video stream. - - **CAP_PROP_FPS** Frame rate. - - **CAP_PROP_FOURCC** 4-character code of codec. - - **CAP_PROP_FRAME_COUNT** Number of frames in the video file. - - **CAP_PROP_FORMAT** Format of the Mat objects returned by retrieve() . - - **CAP_PROP_MODE** Backend-specific value indicating the current capture mode. - - **CAP_PROP_BRIGHTNESS** Brightness of the image (only for cameras). - - **CAP_PROP_CONTRAST** Contrast of the image (only for cameras). - - **CAP_PROP_SATURATION** Saturation of the image (only for cameras). - - **CAP_PROP_HUE** Hue of the image (only for cameras). - - **CAP_PROP_GAIN** Gain of the image (only for cameras). - - **CAP_PROP_EXPOSURE** Exposure (only for cameras). - - **CAP_PROP_CONVERT_RGB** Boolean flags indicating whether images should be converted - to RGB. - - **CAP_PROP_WHITE_BALANCE** Currently unsupported - - **CAP_PROP_RECTIFICATION** Rectification flag for stereo cameras (note: only supported - by DC1394 v 2.x backend currently) + - cv::CAP_PROP_POS_MSEC @copydoc cv::CAP_PROP_POS_MSEC + - cv::CAP_PROP_POS_FRAMES @copydoc CAP_PROP_POS_FRAMES + - cv::CAP_PROP_POS_AVI_RATIO @copydoc cv::CAP_PROP_POS_AVI_RATIO + - cv::CAP_PROP_FRAME_WIDTH @copydoc cv::CAP_PROP_FRAME_WIDTH + - cv::CAP_PROP_FRAME_HEIGHT @copydoc cv::CAP_PROP_FRAME_HEIGHT + - cv::CAP_PROP_FPS @copydoc cv::CAP_PROP_FPS + - cv::CAP_PROP_FOURCC @copydoc cv::CAP_PROP_FOURCC + - cv::CAP_PROP_FRAME_COUNT @copydoc cv::CAP_PROP_FRAME_COUNT + - cv::CAP_PROP_FORMAT @copydoc cv::CAP_PROP_FORMAT + - cv::CAP_PROP_MODE @copydoc cv::CAP_PROP_MODE + - cv::CAP_PROP_BRIGHTNESS @copydoc cv::CAP_PROP_BRIGHTNESS + - cv::CAP_PROP_CONTRAST @copydoc cv::CAP_PROP_CONTRAST + - cv::CAP_PROP_SATURATION @copydoc cv::CAP_PROP_SATURATION + - cv::CAP_PROP_HUE @copydoc cv::CAP_PROP_HUE + - cv::CAP_PROP_GAIN @copydoc cv::CAP_PROP_GAIN + - cv::CAP_PROP_EXPOSURE @copydoc cv::CAP_PROP_EXPOSURE + - cv::CAP_PROP_CONVERT_RGB @copydoc cv::CAP_PROP_CONVERT_RGB + - cv::CAP_PROP_WHITE_BALANCE_BLUE_U @copydoc cv::CAP_PROP_WHITE_BALANCE_BLUE_U + - cv::CAP_PROP_WHITE_BALANCE_RED_V @copydoc cv::CAP_PROP_WHITE_BALANCE_RED_V + - cv::CAP_PROP_RECTIFICATION @copydoc cv::CAP_PROP_RECTIFICATION @param value Value of the property. */ CV_WRAP virtual bool set(int propId, double value); @@ -657,29 +675,26 @@ public: /** @brief Returns the specified VideoCapture property @param propId Property identifier. It can be one of the following: - - **CAP_PROP_POS_MSEC** Current position of the video file in milliseconds or video - capture timestamp. - - **CAP_PROP_POS_FRAMES** 0-based index of the frame to be decoded/captured next. - - **CAP_PROP_POS_AVI_RATIO** Relative position of the video file: 0 - start of the - film, 1 - end of the film. - - **CAP_PROP_FRAME_WIDTH** Width of the frames in the video stream. - - **CAP_PROP_FRAME_HEIGHT** Height of the frames in the video stream. - - **CAP_PROP_FPS** Frame rate. - - **CAP_PROP_FOURCC** 4-character code of codec. - - **CAP_PROP_FRAME_COUNT** Number of frames in the video file. - - **CAP_PROP_FORMAT** Format of the Mat objects returned by retrieve() . - - **CAP_PROP_MODE** Backend-specific value indicating the current capture mode. - - **CAP_PROP_BRIGHTNESS** Brightness of the image (only for cameras). - - **CAP_PROP_CONTRAST** Contrast of the image (only for cameras). - - **CAP_PROP_SATURATION** Saturation of the image (only for cameras). - - **CAP_PROP_HUE** Hue of the image (only for cameras). - - **CAP_PROP_GAIN** Gain of the image (only for cameras). - - **CAP_PROP_EXPOSURE** Exposure (only for cameras). - - **CAP_PROP_CONVERT_RGB** Boolean flags indicating whether images should be converted - to RGB. - - **CAP_PROP_WHITE_BALANCE** Currently not supported - - **CAP_PROP_RECTIFICATION** Rectification flag for stereo cameras (note: only supported - by DC1394 v 2.x backend currently) + - cv::CAP_PROP_POS_MSEC @copydoc cv::CAP_PROP_POS_MSEC + - cv::CAP_PROP_POS_FRAMES @copydoc CAP_PROP_POS_FRAMES + - cv::CAP_PROP_POS_AVI_RATIO @copydoc cv::CAP_PROP_POS_AVI_RATIO + - cv::CAP_PROP_FRAME_WIDTH @copydoc cv::CAP_PROP_FRAME_WIDTH + - cv::CAP_PROP_FRAME_HEIGHT @copydoc cv::CAP_PROP_FRAME_HEIGHT + - cv::CAP_PROP_FPS @copydoc cv::CAP_PROP_FPS + - cv::CAP_PROP_FOURCC @copydoc cv::CAP_PROP_FOURCC + - cv::CAP_PROP_FRAME_COUNT @copydoc cv::CAP_PROP_FRAME_COUNT + - cv::CAP_PROP_FORMAT @copydoc cv::CAP_PROP_FORMAT + - cv::CAP_PROP_MODE @copydoc cv::CAP_PROP_MODE + - cv::CAP_PROP_BRIGHTNESS @copydoc cv::CAP_PROP_BRIGHTNESS + - cv::CAP_PROP_CONTRAST @copydoc cv::CAP_PROP_CONTRAST + - cv::CAP_PROP_SATURATION @copydoc cv::CAP_PROP_SATURATION + - cv::CAP_PROP_HUE @copydoc cv::CAP_PROP_HUE + - cv::CAP_PROP_GAIN @copydoc cv::CAP_PROP_GAIN + - cv::CAP_PROP_EXPOSURE @copydoc cv::CAP_PROP_EXPOSURE + - cv::CAP_PROP_CONVERT_RGB @copydoc cv::CAP_PROP_CONVERT_RGB + - cv::CAP_PROP_WHITE_BALANCE_BLUE_U @copydoc cv::CAP_PROP_WHITE_BALANCE_BLUE_U + - cv::CAP_PROP_WHITE_BALANCE_RED_V @copydoc cv::CAP_PROP_WHITE_BALANCE_RED_V + - cv::CAP_PROP_RECTIFICATION @copydoc cv::CAP_PROP_RECTIFICATION @note When querying a property that is not supported by the backend used by the VideoCapture class, value 0 is returned. @@ -692,7 +707,7 @@ public: img_%02d.jpg, which will read samples like img_00.jpg, img_01.jpg, img_02.jpg, ...) @param apiPreference preferred Capture API to use. Can be used to enforce a specific reader - implementation if multiple are available: e.g. CAP_FFMPEG or CAP_IMAGES + implementation if multiple are available: e.g. cv::CAP_FFMPEG or cv::CAP_IMAGES The methods first call VideoCapture::release to close the already opened file or camera. */ @@ -767,8 +782,8 @@ public: /** @brief Sets a property in the VideoWriter. @param propId Property identifier. It can be one of the following: - - **VIDEOWRITER_PROP_QUALITY** Quality (0..100%) of the videostream encoded. Can be adjusted dynamically in some codecs. - - **VIDEOWRITER_PROP_NSTRIPES** Number of stripes for parallel encoding + - cv::VIDEOWRITER_PROP_QUALITY @copydoc cv::VIDEOWRITER_PROP_QUALITY + - cv::VIDEOWRITER_PROP_NSTRIPES @copydoc cv::VIDEOWRITER_PROP_NSTRIPES @param value Value of the property. */ CV_WRAP virtual bool set(int propId, double value); @@ -776,9 +791,9 @@ public: /** @brief Returns the specified VideoWriter property @param propId Property identifier. It can be one of the following: - - **VIDEOWRITER_PROP_QUALITY** Current quality of the encoded videostream. - - **VIDEOWRITER_PROP_FRAMEBYTES** (Read-only) Size of just encoded video frame; note that the encoding order may be different from representation order. - - **VIDEOWRITER_PROP_NSTRIPES** Number of stripes for parallel encoding + - cv::VIDEOWRITER_PROP_QUALITY @copydoc cv::VIDEOWRITER_PROP_QUALITY + - cv::VIDEOWRITER_PROP_FRAMEBYTES @copydoc VIDEOWRITER_PROP_FRAMEBYTES + - cv::VIDEOWRITER_PROP_NSTRIPES @copydoc cv::VIDEOWRITER_PROP_NSTRIPES @note When querying a property that is not supported by the backend used by the VideoWriter class, value 0 is returned. diff --git a/modules/videoio/include/opencv2/videoio/videoio_c.h b/modules/videoio/include/opencv2/videoio/videoio_c.h index 91d26ea5ae..e502c7be83 100644 --- a/modules/videoio/include/opencv2/videoio/videoio_c.h +++ b/modules/videoio/include/opencv2/videoio/videoio_c.h @@ -200,7 +200,8 @@ enum // OpenNI map generators CV_CAP_OPENNI_DEPTH_GENERATOR = 1 << 31, CV_CAP_OPENNI_IMAGE_GENERATOR = 1 << 30, - CV_CAP_OPENNI_GENERATORS_MASK = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_OPENNI_IMAGE_GENERATOR, + CV_CAP_OPENNI_IR_GENERATOR = 1 << 29, + CV_CAP_OPENNI_GENERATORS_MASK = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_OPENNI_IR_GENERATOR, // Properties of cameras available through OpenNI interfaces CV_CAP_PROP_OPENNI_OUTPUT_MODE = 100, @@ -222,10 +223,12 @@ enum CV_CAP_OPENNI_IMAGE_GENERATOR_PRESENT = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT, CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE = CV_CAP_OPENNI_IMAGE_GENERATOR + CV_CAP_PROP_OPENNI_OUTPUT_MODE, + CV_CAP_OPENNI_DEPTH_GENERATOR_PRESENT = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT, CV_CAP_OPENNI_DEPTH_GENERATOR_BASELINE = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_BASELINE, CV_CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_FOCAL_LENGTH, CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION = CV_CAP_OPENNI_DEPTH_GENERATOR + CV_CAP_PROP_OPENNI_REGISTRATION, CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION_ON = CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION, + CV_CAP_OPENNI_IR_GENERATOR_PRESENT = CV_CAP_OPENNI_IR_GENERATOR + CV_CAP_PROP_OPENNI_GENERATOR_PRESENT, // Properties of cameras available through GStreamer interface CV_CAP_GSTREAMER_QUEUE_LENGTH = 200, // default is 1 @@ -454,7 +457,10 @@ enum // Data given from RGB image generator. CV_CAP_OPENNI_BGR_IMAGE = 5, - CV_CAP_OPENNI_GRAY_IMAGE = 6 + CV_CAP_OPENNI_GRAY_IMAGE = 6, + + // Data given from IR image generator. + CV_CAP_OPENNI_IR_IMAGE = 7 }; // Supported output modes of OpenNI image generator diff --git a/modules/videoio/src/cap_ffmpeg_impl.hpp b/modules/videoio/src/cap_ffmpeg_impl.hpp index 8ac33d749d..4a725bc20b 100644 --- a/modules/videoio/src/cap_ffmpeg_impl.hpp +++ b/modules/videoio/src/cap_ffmpeg_impl.hpp @@ -971,7 +971,8 @@ bool CvCapture_FFMPEG::grabFrame() { //picture_pts = picture->best_effort_timestamp; if( picture_pts == AV_NOPTS_VALUE_ ) - picture_pts = packet.pts != AV_NOPTS_VALUE_ && packet.pts != 0 ? packet.pts : packet.dts; + picture_pts = picture->pkt_pts != AV_NOPTS_VALUE_ && picture->pkt_pts != 0 ? picture->pkt_pts : picture->pkt_dts; + frame_number++; valid = true; } diff --git a/modules/videoio/src/cap_images.cpp b/modules/videoio/src/cap_images.cpp index 00d5af47d1..e379561593 100644 --- a/modules/videoio/src/cap_images.cpp +++ b/modules/videoio/src/cap_images.cpp @@ -124,7 +124,7 @@ bool CvCapture_Images::grabFrame() } cvReleaseImage(&frame); - frame = cvLoadImage(str, CV_LOAD_IMAGE_ANYDEPTH | CV_LOAD_IMAGE_ANYCOLOR); + frame = cvLoadImage(str, CV_LOAD_IMAGE_UNCHANGED); if( frame ) currentframe++; diff --git a/modules/videoio/src/cap_openni2.cpp b/modules/videoio/src/cap_openni2.cpp index 12faa297f2..aebf1889a1 100644 --- a/modules/videoio/src/cap_openni2.cpp +++ b/modules/videoio/src/cap_openni2.cpp @@ -65,8 +65,10 @@ #define CV_STREAM_TIMEOUT 2000 -#define CV_DEPTH_STREAM 0 -#define CV_COLOR_STREAM 1 +#define CV_DEPTH_STREAM 0 +#define CV_COLOR_STREAM 1 +#define CV_IR_STREAM 2 +#define CV_MAX_NUM_STREAMS 3 #include "OpenNI.h" #include "PS1080.h" @@ -109,10 +111,9 @@ protected: IplImage iplHeader; }; - static const int outputMapsTypesCount = 7; + static const int outputMapsTypesCount = 8; - static openni::VideoMode defaultColorOutputMode(); - static openni::VideoMode defaultDepthOutputMode(); + static openni::VideoMode defaultStreamOutputMode(int stream); IplImage* retrieveDepthMap(); IplImage* retrievePointCloudMap(); @@ -121,13 +122,17 @@ protected: IplImage* retrieveValidDepthMask(); IplImage* retrieveBGRImage(); IplImage* retrieveGrayImage(); + IplImage* retrieveIrImage(); + openni::Status toggleStream(int stream, bool toggle); bool readCamerasParams(); double getDepthGeneratorProperty(int propIdx) const; bool setDepthGeneratorProperty(int propIdx, double propVal); double getImageGeneratorProperty(int propIdx) const; bool setImageGeneratorProperty(int propIdx, double propVal); + double getIrGeneratorProperty(int propIdx) const; + bool setIrGeneratorProperty(int propIdx, double propVal); double getCommonProperty(int propIdx) const; bool setCommonProperty(int propIdx, double propVal); @@ -137,9 +142,9 @@ protected: openni::Recorder recorder; // Data generators with its metadata - openni::VideoStream depth, color, **streams; - openni::VideoFrameRef depthFrame, colorFrame; - cv::Mat depthImage, colorImage; + openni::VideoStream streams[CV_MAX_NUM_STREAMS]; + openni::VideoFrameRef streamFrames[CV_MAX_NUM_STREAMS]; + cv::Mat streamImages[CV_MAX_NUM_STREAMS]; int maxBufferSize, maxTimeDuration; // for approx sync bool isCircleBuffer; @@ -157,9 +162,6 @@ protected: // The value for pixels without a valid disparity measurement int noSampleValue; - int currentStream; - - int numStream; std::vector outputMaps; }; @@ -177,27 +179,28 @@ bool CvCapture_OpenNI2::isOpened() const return isContextOpened; } -openni::VideoMode CvCapture_OpenNI2::defaultColorOutputMode() +openni::VideoMode CvCapture_OpenNI2::defaultStreamOutputMode(int stream) { openni::VideoMode mode; mode.setResolution(640, 480); mode.setFps(30); - mode.setPixelFormat(openni::PIXEL_FORMAT_RGB888); - return mode; -} - -openni::VideoMode CvCapture_OpenNI2::defaultDepthOutputMode() -{ - openni::VideoMode mode; - mode.setResolution(640, 480); - mode.setFps(30); - mode.setPixelFormat(openni::PIXEL_FORMAT_DEPTH_1_MM); + switch (stream) + { + case CV_DEPTH_STREAM: + mode.setPixelFormat(openni::PIXEL_FORMAT_DEPTH_1_MM); + break; + case CV_COLOR_STREAM: + mode.setPixelFormat(openni::PIXEL_FORMAT_RGB888); + break; + case CV_IR_STREAM: + mode.setPixelFormat(openni::PIXEL_FORMAT_GRAY16); + break; + } return mode; } CvCapture_OpenNI2::CvCapture_OpenNI2( int index ) { - numStream = 2; const char* deviceURI = openni::ANY_DEVICE; openni::Status status; int deviceType = DEVICE_DEFAULT; @@ -215,13 +218,6 @@ CvCapture_OpenNI2::CvCapture_OpenNI2( int index ) index %= 10; } - // Asus XTION and Occipital Structure Sensor do not have an image generator - if (deviceType == DEVICE_ASUS_XTION) - numStream = 1; - - if( deviceType > DEVICE_MAX ) - return; - // Initialize and configure the context. status = openni::OpenNI::initialize(); @@ -247,72 +243,22 @@ CvCapture_OpenNI2::CvCapture_OpenNI2( int index ) return; } - //device.setDepthColorSyncEnabled(true); - - - status = depth.create(device, openni::SENSOR_DEPTH); - if (status == openni::STATUS_OK) + status = toggleStream(CV_DEPTH_STREAM, true); + // Asus XTION and Occipital Structure Sensor do not have an image generator + if (deviceType != DEVICE_ASUS_XTION) + status = openni::Status(status | toggleStream(CV_COLOR_STREAM, true)); + if (status != openni::STATUS_OK) { - if (depth.isValid()) - { - CV_Assert(depth.setVideoMode(defaultDepthOutputMode()) == openni::STATUS_OK); // xn::DepthGenerator supports VGA only! (Jan 2011) - } - - status = depth.start(); - if (status != openni::STATUS_OK) - { - CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::CvCapture_OpenNI2 : Couldn't start depth stream: %s\n", openni::OpenNI::getExtendedError())); - depth.destroy(); - return; - } - } - else - { - CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::CvCapture_OpenNI2 : Couldn't find depth stream:: %s\n", openni::OpenNI::getExtendedError())); + openni::OpenNI::shutdown(); return; } - streams = new openni::VideoStream*[numStream]; - streams[CV_DEPTH_STREAM] = &depth; - - // create a color object - status = color.create(device, openni::SENSOR_COLOR); - if (status == openni::STATUS_OK) - { - // Set map output mode. - if (color.isValid()) - { - CV_Assert(color.setVideoMode(defaultColorOutputMode()) == openni::STATUS_OK); - } - status = color.start(); - if (status != openni::STATUS_OK) - { - CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::CvCapture_OpenNI2 : Couldn't start color stream: %s\n", openni::OpenNI::getExtendedError())); - color.destroy(); - return; - } - streams[CV_COLOR_STREAM] = &color; - } - else if (numStream == 2) - { - CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::CvCapture_OpenNI2 : Couldn't find color stream: %s\n", openni::OpenNI::getExtendedError())); - return; - } - - if( !readCamerasParams() ) + if (!readCamerasParams()) { CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::CvCapture_OpenNI2 : Could not read cameras parameters\n")); return; } -// if( deviceType == DEVICE_ASUS_XTION ) -// { -// //ps/asus specific -// imageGenerator.SetIntProperty("InputFormat", 1 /*XN_IO_IMAGE_FORMAT_YUV422*/); -// imageGenerator.SetPixelFormat(XN_PIXEL_FORMAT_RGB24); -// depthGenerator.SetIntProperty("RegistrationType", 1 /*XN_PROCESSING_HARDWARE*/); -// } - outputMaps.resize( outputMapsTypesCount ); @@ -321,9 +267,74 @@ CvCapture_OpenNI2::CvCapture_OpenNI2( int index ) setProperty(CV_CAP_PROP_OPENNI_REGISTRATION, 1.0); } +openni::Status CvCapture_OpenNI2::toggleStream(int stream, bool toggle) +{ + openni::Status status; + + // for logging + static const char* stream_names[CV_MAX_NUM_STREAMS] = { + "depth", + "color", + "IR" + }; + + static const openni::SensorType stream_sensor_types[CV_MAX_NUM_STREAMS] = { + openni::SENSOR_DEPTH, + openni::SENSOR_COLOR, + openni::SENSOR_IR + }; + + if (toggle) // want to open stream + { + // already opened + if (streams[stream].isValid()) + return openni::STATUS_OK; + + // open stream + status = streams[stream].create(device, stream_sensor_types[stream]); + if (status == openni::STATUS_OK) + { + // set video mode + status = streams[stream].setVideoMode(defaultStreamOutputMode(stream)); // xn::DepthGenerator supports VGA only! (Jan 2011) + if (status != openni::STATUS_OK) + { + CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::CvCapture_OpenNI2 : Couldn't set %s stream output mode: %s\n", + stream_names[stream], + openni::OpenNI::getExtendedError())); + streams[stream].destroy(); + return status; + } + + // start stream + status = streams[stream].start(); + if (status != openni::STATUS_OK) + { + CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::CvCapture_OpenNI2 : Couldn't start %s stream: %s\n", + stream_names[stream], + openni::OpenNI::getExtendedError())); + streams[stream].destroy(); + return status; + } + } + else + { + CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::CvCapture_OpenNI2 : Couldn't find %s stream:: %s\n", + stream_names[stream], + openni::OpenNI::getExtendedError())); + return status; + } + } + else if (streams[stream].isValid()) // want to close stream + { + streams[stream].stop(); + streams[stream].destroy(); + } + + return openni::STATUS_OK; +} + CvCapture_OpenNI2::CvCapture_OpenNI2(const char * filename) { - numStream = 2; openni::Status status; isContextOpened = false; @@ -348,6 +359,13 @@ CvCapture_OpenNI2::CvCapture_OpenNI2(const char * filename) return; } + status = openni::Status(toggleStream(CV_DEPTH_STREAM, true) | toggleStream(CV_COLOR_STREAM, true)); + if (status != openni::STATUS_OK) + { + openni::OpenNI::shutdown(); + return; + } + if( !readCamerasParams() ) { CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::CvCapture_OpenNI2 : Could not read cameras parameters\n")); @@ -361,17 +379,20 @@ CvCapture_OpenNI2::CvCapture_OpenNI2(const char * filename) CvCapture_OpenNI2::~CvCapture_OpenNI2() { - this->depthFrame.release(); - this->colorFrame.release(); - this->depth.stop(); - this->color.stop(); + for (int i = 0; i < CV_MAX_NUM_STREAMS; ++i) + { + streamFrames[i].release(); + streams[i].stop(); + streams[i].destroy(); + } + device.close(); openni::OpenNI::shutdown(); } bool CvCapture_OpenNI2::readCamerasParams() { double pixelSize = 0; - if (depth.getProperty(XN_STREAM_PROPERTY_ZERO_PLANE_PIXEL_SIZE, &pixelSize) != openni::STATUS_OK) + if (streams[CV_DEPTH_STREAM].getProperty(XN_STREAM_PROPERTY_ZERO_PLANE_PIXEL_SIZE, &pixelSize) != openni::STATUS_OK) { CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::readCamerasParams : Could not read pixel size!\n")); return false; @@ -382,13 +403,13 @@ bool CvCapture_OpenNI2::readCamerasParams() // focal length of IR camera in pixels for VGA resolution int zeroPlanDistance; // in mm - if (depth.getProperty(XN_STREAM_PROPERTY_ZERO_PLANE_DISTANCE, &zeroPlanDistance) != openni::STATUS_OK) + if (streams[CV_DEPTH_STREAM].getProperty(XN_STREAM_PROPERTY_ZERO_PLANE_DISTANCE, &zeroPlanDistance) != openni::STATUS_OK) { CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::readCamerasParams : Could not read virtual plane distance!\n")); return false; } - if (depth.getProperty(XN_STREAM_PROPERTY_EMITTER_DCMOS_DISTANCE, &baseline) != openni::STATUS_OK) + if (streams[CV_DEPTH_STREAM].getProperty(XN_STREAM_PROPERTY_EMITTER_DCMOS_DISTANCE, &baseline) != openni::STATUS_OK) { CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::readCamerasParams : Could not read base line!\n")); return false; @@ -419,6 +440,10 @@ double CvCapture_OpenNI2::getProperty( int propIdx ) const { propValue = getDepthGeneratorProperty( purePropIdx ); } + else if ((propIdx & CV_CAP_OPENNI_GENERATORS_MASK) == CV_CAP_OPENNI_IR_GENERATOR) + { + propValue = getIrGeneratorProperty(purePropIdx); + } else { propValue = getCommonProperty( purePropIdx ); @@ -443,6 +468,10 @@ bool CvCapture_OpenNI2::setProperty( int propIdx, double propValue ) { isSet = setDepthGeneratorProperty( purePropIdx, propValue ); } + else if ((propIdx & CV_CAP_OPENNI_GENERATORS_MASK) == CV_CAP_OPENNI_IR_GENERATOR) + { + isSet = setIrGeneratorProperty(purePropIdx, propValue); + } else { isSet = setCommonProperty( purePropIdx, propValue ); @@ -458,12 +487,6 @@ double CvCapture_OpenNI2::getCommonProperty( int propIdx ) const switch( propIdx ) { - // There is a set of properties that correspond to depth generator by default - // (is they are pass without particular generator flag). Two reasons of this: - // 1) We can assume that depth generator is the main one for depth sensor. - // 2) In the initial vertions of OpenNI integration to OpenCV the value of - // flag CV_CAP_OPENNI_DEPTH_GENERATOR was 0 (it isn't zero now). - case CV_CAP_PROP_OPENNI_GENERATOR_PRESENT : case CV_CAP_PROP_FRAME_WIDTH : case CV_CAP_PROP_FRAME_HEIGHT : case CV_CAP_PROP_FPS : @@ -477,7 +500,9 @@ double CvCapture_OpenNI2::getCommonProperty( int propIdx ) const propValue = const_cast(this)->device.getDepthColorSyncEnabled(); case CV_CAP_PROP_OPENNI2_MIRROR: { - bool isMirroring = color.getMirroringEnabled() && depth.getMirroringEnabled(); + bool isMirroring = false; + for (int i = 0; i < CV_MAX_NUM_STREAMS; ++i) + isMirroring |= streams[i].getMirroringEnabled(); propValue = isMirroring ? 1.0 : 0.0; break; } @@ -497,8 +522,11 @@ bool CvCapture_OpenNI2::setCommonProperty( int propIdx, double propValue ) case CV_CAP_PROP_OPENNI2_MIRROR: { bool mirror = propValue > 0.0 ? true : false; - isSet = color.setMirroringEnabled(mirror) == openni::STATUS_OK; - isSet = depth.setMirroringEnabled(mirror) == openni::STATUS_OK; + for (int i = 0; i < CV_MAX_NUM_STREAMS; ++i) + { + if (streams[i].isValid()) + isSet |= streams[i].setMirroringEnabled(mirror) == openni::STATUS_OK; + } } break; // There is a set of properties that correspond to depth generator by default @@ -509,6 +537,7 @@ bool CvCapture_OpenNI2::setCommonProperty( int propIdx, double propValue ) case CV_CAP_PROP_OPENNI2_SYNC: isSet = device.setDepthColorSyncEnabled(propValue > 0.0) == openni::STATUS_OK; break; + default: CV_Error( CV_StsBadArg, cv::format("Such parameter (propIdx=%d) isn't supported for setting.\n", propIdx) ); } @@ -519,29 +548,28 @@ bool CvCapture_OpenNI2::setCommonProperty( int propIdx, double propValue ) double CvCapture_OpenNI2::getDepthGeneratorProperty( int propIdx ) const { double propValue = 0; - if( !depth.isValid() ) + if( !streams[CV_DEPTH_STREAM].isValid() ) return propValue; openni::VideoMode mode; switch( propIdx ) { - case CV_CAP_PROP_OPENNI_GENERATOR_PRESENT : - CV_DbgAssert(depth.isValid()); - propValue = 1.; + case CV_CAP_PROP_OPENNI_GENERATOR_PRESENT: + propValue = streams[CV_DEPTH_STREAM].isValid(); break; case CV_CAP_PROP_FRAME_WIDTH : - propValue = depth.getVideoMode().getResolutionX(); + propValue = streams[CV_DEPTH_STREAM].getVideoMode().getResolutionX(); break; case CV_CAP_PROP_FRAME_HEIGHT : - propValue = depth.getVideoMode().getResolutionY(); + propValue = streams[CV_DEPTH_STREAM].getVideoMode().getResolutionY(); break; case CV_CAP_PROP_FPS : - mode = depth.getVideoMode(); + mode = streams[CV_DEPTH_STREAM].getVideoMode(); propValue = mode.getFps(); break; case CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH : - propValue = depth.getMaxPixelValue(); + propValue = streams[CV_DEPTH_STREAM].getMaxPixelValue(); break; case CV_CAP_PROP_OPENNI_BASELINE : propValue = baseline; @@ -553,10 +581,10 @@ double CvCapture_OpenNI2::getDepthGeneratorProperty( int propIdx ) const propValue = device.getImageRegistrationMode(); break; case CV_CAP_PROP_POS_MSEC : - propValue = (double)depthFrame.getTimestamp(); + propValue = (double)streamFrames[CV_DEPTH_STREAM].getTimestamp(); break; case CV_CAP_PROP_POS_FRAMES : - propValue = depthFrame.getFrameIndex(); + propValue = streamFrames[CV_DEPTH_STREAM].getFrameIndex(); break; default : CV_Error( CV_StsBadArg, cv::format("Depth generator does not support such parameter (propIdx=%d) for getting.\n", propIdx) ); @@ -569,17 +597,20 @@ bool CvCapture_OpenNI2::setDepthGeneratorProperty( int propIdx, double propValue { bool isSet = false; - CV_Assert( depth.isValid() ); - switch( propIdx ) { + case CV_CAP_PROP_OPENNI_GENERATOR_PRESENT: + if (isContextOpened) + isSet = toggleStream(CV_DEPTH_STREAM, propValue > 0.0) == openni::STATUS_OK; + break; case CV_CAP_PROP_OPENNI_REGISTRATION: { + CV_Assert(streams[CV_DEPTH_STREAM].isValid()); if( propValue != 0.0 ) // "on" { // if there isn't image generator (i.e. ASUS XtionPro doesn't have it) // then the property isn't avaliable - if ( color.isValid() ) + if ( streams[CV_COLOR_STREAM].isValid() ) { openni::ImageRegistrationMode mode = propValue != 0.0 ? openni::IMAGE_REGISTRATION_DEPTH_TO_COLOR : openni::IMAGE_REGISTRATION_OFF; if( !device.getImageRegistrationMode() == mode ) @@ -619,30 +650,29 @@ bool CvCapture_OpenNI2::setDepthGeneratorProperty( int propIdx, double propValue double CvCapture_OpenNI2::getImageGeneratorProperty( int propIdx ) const { double propValue = 0.; - if( !color.isValid() ) + if( !streams[CV_COLOR_STREAM].isValid() ) return propValue; openni::VideoMode mode; switch( propIdx ) { - case CV_CAP_PROP_OPENNI_GENERATOR_PRESENT : - CV_DbgAssert( color.isValid() ); - propValue = 1.; + case CV_CAP_PROP_OPENNI_GENERATOR_PRESENT: + propValue = streams[CV_COLOR_STREAM].isValid(); break; case CV_CAP_PROP_FRAME_WIDTH : - propValue = color.getVideoMode().getResolutionX(); + propValue = streams[CV_COLOR_STREAM].getVideoMode().getResolutionX(); break; case CV_CAP_PROP_FRAME_HEIGHT : - propValue = color.getVideoMode().getResolutionY(); + propValue = streams[CV_COLOR_STREAM].getVideoMode().getResolutionY(); break; case CV_CAP_PROP_FPS : - propValue = color.getVideoMode().getFps(); + propValue = streams[CV_COLOR_STREAM].getVideoMode().getFps(); break; case CV_CAP_PROP_POS_MSEC : - propValue = (double)colorFrame.getTimestamp(); + propValue = (double)streamFrames[CV_COLOR_STREAM].getTimestamp(); break; case CV_CAP_PROP_POS_FRAMES : - propValue = (double)colorFrame.getFrameIndex(); + propValue = (double)streamFrames[CV_COLOR_STREAM].getFrameIndex(); break; default : CV_Error( CV_StsBadArg, cv::format("Image generator does not support such parameter (propIdx=%d) for getting.\n", propIdx) ); @@ -654,14 +684,18 @@ double CvCapture_OpenNI2::getImageGeneratorProperty( int propIdx ) const bool CvCapture_OpenNI2::setImageGeneratorProperty(int propIdx, double propValue) { bool isSet = false; - if( !color.isValid() ) - return isSet; switch( propIdx ) { + case CV_CAP_PROP_OPENNI_GENERATOR_PRESENT: + if (isContextOpened) + isSet = toggleStream(CV_COLOR_STREAM, propValue > 0.0) == openni::STATUS_OK; + break; case CV_CAP_PROP_OPENNI_OUTPUT_MODE : { - openni::VideoMode mode = color.getVideoMode(); + if (!streams[CV_COLOR_STREAM].isValid()) + return isSet; + openni::VideoMode mode = streams[CV_COLOR_STREAM].getVideoMode(); switch( cvRound(propValue) ) { @@ -689,7 +723,7 @@ bool CvCapture_OpenNI2::setImageGeneratorProperty(int propIdx, double propValue) CV_Error( CV_StsBadArg, "Unsupported image generator output mode.\n"); } - openni::Status status = color.setVideoMode( mode ); + openni::Status status = streams[CV_COLOR_STREAM].setVideoMode( mode ); if( status != openni::STATUS_OK ) CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::setImageGeneratorProperty : %s\n", openni::OpenNI::getExtendedError())); else @@ -703,6 +737,96 @@ bool CvCapture_OpenNI2::setImageGeneratorProperty(int propIdx, double propValue) return isSet; } +double CvCapture_OpenNI2::getIrGeneratorProperty(int propIdx) const +{ + double propValue = 0.; + if (!streams[CV_IR_STREAM].isValid()) + return propValue; + + openni::VideoMode mode; + switch (propIdx) + { + case CV_CAP_PROP_OPENNI_GENERATOR_PRESENT: + propValue = streams[CV_IR_STREAM].isValid(); + break; + case CV_CAP_PROP_FRAME_WIDTH: + propValue = streams[CV_IR_STREAM].getVideoMode().getResolutionX(); + break; + case CV_CAP_PROP_FRAME_HEIGHT: + propValue = streams[CV_IR_STREAM].getVideoMode().getResolutionY(); + break; + case CV_CAP_PROP_FPS: + propValue = streams[CV_IR_STREAM].getVideoMode().getFps(); + break; + case CV_CAP_PROP_POS_MSEC: + propValue = (double)streamFrames[CV_IR_STREAM].getTimestamp(); + break; + case CV_CAP_PROP_POS_FRAMES: + propValue = (double)streamFrames[CV_IR_STREAM].getFrameIndex(); + break; + default: + CV_Error(CV_StsBadArg, cv::format("Image generator does not support such parameter (propIdx=%d) for getting.\n", propIdx)); + } + + return propValue; +} + +bool CvCapture_OpenNI2::setIrGeneratorProperty(int propIdx, double propValue) +{ + bool isSet = false; + + switch (propIdx) + { + case CV_CAP_PROP_OPENNI_GENERATOR_PRESENT: + if (isContextOpened) + isSet = toggleStream(CV_IR_STREAM, propValue > 0.0) == openni::STATUS_OK; + break; + case CV_CAP_PROP_OPENNI_OUTPUT_MODE: + { + if (!streams[CV_IR_STREAM].isValid()) + return isSet; + openni::VideoMode mode = streams[CV_IR_STREAM].getVideoMode(); + + switch (cvRound(propValue)) + { + case CV_CAP_OPENNI_VGA_30HZ: + mode.setResolution(640, 480); + mode.setFps(30); + break; + case CV_CAP_OPENNI_SXGA_15HZ: + mode.setResolution(1280, 960); + mode.setFps(15); + break; + case CV_CAP_OPENNI_SXGA_30HZ: + mode.setResolution(1280, 960); + mode.setFps(30); + break; + case CV_CAP_OPENNI_QVGA_30HZ: + mode.setResolution(320, 240); + mode.setFps(30); + break; + case CV_CAP_OPENNI_QVGA_60HZ: + mode.setResolution(320, 240); + mode.setFps(60); + break; + default: + CV_Error(CV_StsBadArg, "Unsupported image generator output mode.\n"); + } + + openni::Status status = streams[CV_IR_STREAM].setVideoMode(mode); + if (status != openni::STATUS_OK) + CV_Error(CV_StsError, cv::format("CvCapture_OpenNI2::setImageGeneratorProperty : %s\n", openni::OpenNI::getExtendedError())); + else + isSet = true; + break; + } + default: + CV_Error(CV_StsBadArg, cv::format("Image generator does not support such parameter (propIdx=%d) for setting.\n", propIdx)); + } + + return isSet; +} + bool CvCapture_OpenNI2::grabFrame() { if( !isOpened() ) @@ -710,14 +834,22 @@ bool CvCapture_OpenNI2::grabFrame() bool isGrabbed = false; - openni::Status status = openni::OpenNI::waitForAnyStream(streams, numStream, ¤tStream, CV_STREAM_TIMEOUT); + int numActiveStreams = 0; + openni::VideoStream* streamPtrs[CV_MAX_NUM_STREAMS]; + for (int i = 0; i < CV_MAX_NUM_STREAMS; ++i) { + streamPtrs[numActiveStreams++] = &streams[i]; + } + + int currentStream; + openni::Status status = openni::OpenNI::waitForAnyStream(streamPtrs, numActiveStreams, ¤tStream, CV_STREAM_TIMEOUT); if( status != openni::STATUS_OK ) return false; - if( depth.isValid() ) - depth.readFrame(&depthFrame); - if (color.isValid()) - color.readFrame(&colorFrame); + for (int i = 0; i < CV_MAX_NUM_STREAMS; ++i) + { + if (streams[i].isValid()) + streams[i].readFrame(&streamFrames[i]); + } isGrabbed = true; return isGrabbed; @@ -736,25 +868,25 @@ inline void getDepthMapFromMetaData(const openni::VideoFrameRef& depthMetaData, IplImage* CvCapture_OpenNI2::retrieveDepthMap() { - if( !depth.isValid() ) + if( !streamFrames[CV_DEPTH_STREAM].isValid() ) return 0; - getDepthMapFromMetaData( depthFrame, outputMaps[CV_CAP_OPENNI_DEPTH_MAP].mat, noSampleValue, shadowValue ); + getDepthMapFromMetaData(streamFrames[CV_DEPTH_STREAM], outputMaps[CV_CAP_OPENNI_DEPTH_MAP].mat, noSampleValue, shadowValue ); return outputMaps[CV_CAP_OPENNI_DEPTH_MAP].getIplImagePtr(); } IplImage* CvCapture_OpenNI2::retrievePointCloudMap() { - if( !depthFrame.isValid() ) + if( !streamFrames[CV_DEPTH_STREAM].isValid() ) return 0; cv::Mat depthImg; - getDepthMapFromMetaData(depthFrame, depthImg, noSampleValue, shadowValue); + getDepthMapFromMetaData(streamFrames[CV_DEPTH_STREAM], depthImg, noSampleValue, shadowValue); const int badPoint = INVALID_PIXEL_VAL; const float badCoord = INVALID_COORDINATE_VAL; - int cols = depthFrame.getWidth(), rows = depthFrame.getHeight(); + int cols = streamFrames[CV_DEPTH_STREAM].getWidth(), rows = streamFrames[CV_DEPTH_STREAM].getHeight(); cv::Mat pointCloud_XYZ( rows, cols, CV_32FC3, cv::Scalar::all(badPoint) ); float worldX, worldY, worldZ; @@ -762,7 +894,7 @@ IplImage* CvCapture_OpenNI2::retrievePointCloudMap() { for (int x = 0; x < cols; x++) { - openni::CoordinateConverter::convertDepthToWorld(depth, x, y, depthImg.at(y, x), &worldX, &worldY, &worldZ); + openni::CoordinateConverter::convertDepthToWorld(streams[CV_DEPTH_STREAM], x, y, depthImg.at(y, x), &worldX, &worldY, &worldZ); if (depthImg.at(y, x) == badPoint) // not valid pointCloud_XYZ.at(y, x) = cv::Point3f(badCoord, badCoord, badCoord); @@ -803,11 +935,11 @@ static void computeDisparity_32F( const openni::VideoFrameRef& depthMetaData, cv IplImage* CvCapture_OpenNI2::retrieveDisparityMap() { - if (!depthFrame.isValid()) + if (!streamFrames[CV_DEPTH_STREAM].isValid()) return 0; cv::Mat disp32; - computeDisparity_32F(depthFrame, disp32, baseline, depthFocalLength_VGA, noSampleValue, shadowValue); + computeDisparity_32F(streamFrames[CV_DEPTH_STREAM], disp32, baseline, depthFocalLength_VGA, noSampleValue, shadowValue); disp32.convertTo( outputMaps[CV_CAP_OPENNI_DISPARITY_MAP].mat, CV_8UC1 ); @@ -816,21 +948,21 @@ IplImage* CvCapture_OpenNI2::retrieveDisparityMap() IplImage* CvCapture_OpenNI2::retrieveDisparityMap_32F() { - if (!depthFrame.isValid()) + if (!streamFrames[CV_DEPTH_STREAM].isValid()) return 0; - computeDisparity_32F(depthFrame, outputMaps[CV_CAP_OPENNI_DISPARITY_MAP_32F].mat, baseline, depthFocalLength_VGA, noSampleValue, shadowValue); + computeDisparity_32F(streamFrames[CV_DEPTH_STREAM], outputMaps[CV_CAP_OPENNI_DISPARITY_MAP_32F].mat, baseline, depthFocalLength_VGA, noSampleValue, shadowValue); return outputMaps[CV_CAP_OPENNI_DISPARITY_MAP_32F].getIplImagePtr(); } IplImage* CvCapture_OpenNI2::retrieveValidDepthMask() { - if (!depthFrame.isValid()) + if (!streamFrames[CV_DEPTH_STREAM].isValid()) return 0; cv::Mat d; - getDepthMapFromMetaData(depthFrame, d, noSampleValue, shadowValue); + getDepthMapFromMetaData(streamFrames[CV_DEPTH_STREAM], d, noSampleValue, shadowValue); outputMaps[CV_CAP_OPENNI_VALID_DEPTH_MASK].mat = d != CvCapture_OpenNI2::INVALID_PIXEL_VAL; @@ -850,30 +982,58 @@ inline void getBGRImageFromMetaData( const openni::VideoFrameRef& imageMetaData, cv::cvtColor(bufferImage, bgrImage, cv::COLOR_RGB2BGR); } +inline void getGrayImageFromMetaData(const openni::VideoFrameRef& imageMetaData, cv::Mat& grayImage) +{ + if (imageMetaData.getVideoMode().getPixelFormat() == openni::PIXEL_FORMAT_GRAY8) + { + grayImage.create(imageMetaData.getHeight(), imageMetaData.getWidth(), CV_8UC1); + grayImage.data = (uchar*)imageMetaData.getData(); + } + else if (imageMetaData.getVideoMode().getPixelFormat() == openni::PIXEL_FORMAT_GRAY16) + { + grayImage.create(imageMetaData.getHeight(), imageMetaData.getWidth(), CV_16UC1); + grayImage.data = (uchar*)imageMetaData.getData(); + } + else + { + CV_Error(CV_StsUnsupportedFormat, "Unsupported format of grabbed image\n"); + } +} + IplImage* CvCapture_OpenNI2::retrieveBGRImage() { - if( !color.isValid() ) + if( !streamFrames[CV_COLOR_STREAM].isValid() ) return 0; - getBGRImageFromMetaData( colorFrame, outputMaps[CV_CAP_OPENNI_BGR_IMAGE].mat ); + getBGRImageFromMetaData(streamFrames[CV_COLOR_STREAM], outputMaps[CV_CAP_OPENNI_BGR_IMAGE].mat ); return outputMaps[CV_CAP_OPENNI_BGR_IMAGE].getIplImagePtr(); } IplImage* CvCapture_OpenNI2::retrieveGrayImage() { - if (!colorFrame.isValid()) + if (!streamFrames[CV_COLOR_STREAM].isValid()) return 0; - CV_Assert(colorFrame.getVideoMode().getPixelFormat() == openni::PIXEL_FORMAT_RGB888); // RGB + CV_Assert(streamFrames[CV_COLOR_STREAM].getVideoMode().getPixelFormat() == openni::PIXEL_FORMAT_RGB888); // RGB cv::Mat rgbImage; - getBGRImageFromMetaData(colorFrame, rgbImage); + getBGRImageFromMetaData(streamFrames[CV_COLOR_STREAM], rgbImage); cv::cvtColor( rgbImage, outputMaps[CV_CAP_OPENNI_GRAY_IMAGE].mat, CV_BGR2GRAY ); return outputMaps[CV_CAP_OPENNI_GRAY_IMAGE].getIplImagePtr(); } +IplImage* CvCapture_OpenNI2::retrieveIrImage() +{ + if (!streamFrames[CV_IR_STREAM].isValid()) + return 0; + + getGrayImageFromMetaData(streamFrames[CV_IR_STREAM], outputMaps[CV_CAP_OPENNI_IR_IMAGE].mat); + + return outputMaps[CV_CAP_OPENNI_IR_IMAGE].getIplImagePtr(); +} + IplImage* CvCapture_OpenNI2::retrieveFrame( int outputType ) { IplImage* image = 0; @@ -907,6 +1067,10 @@ IplImage* CvCapture_OpenNI2::retrieveFrame( int outputType ) { image = retrieveGrayImage(); } + else if( outputType == CV_CAP_OPENNI_IR_IMAGE ) + { + image = retrieveIrImage(); + } return image; } diff --git a/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp b/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp index 9fd8494b2f..7d198dc53e 100644 --- a/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp +++ b/samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include diff --git a/samples/android/tutorial-2-mixedprocessing/jni/jni_part.cpp b/samples/android/tutorial-2-mixedprocessing/jni/jni_part.cpp index 2c09961563..72fa0b24ab 100644 --- a/samples/android/tutorial-2-mixedprocessing/jni/jni_part.cpp +++ b/samples/android/tutorial-2-mixedprocessing/jni/jni_part.cpp @@ -1,7 +1,7 @@ #include -#include -#include -#include +#include +#include +#include #include using namespace std; diff --git a/samples/cpp/3calibration.cpp b/samples/cpp/3calibration.cpp index 12f2c81fca..7079b6d062 100644 --- a/samples/cpp/3calibration.cpp +++ b/samples/cpp/3calibration.cpp @@ -2,10 +2,10 @@ * 3calibration.cpp -- Calibrate 3 cameras in a horizontal line together. */ -#include "opencv2/calib3d/calib3d.hpp" -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/imgcodecs/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/calib3d.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/imgcodecs.hpp" +#include "opencv2/highgui.hpp" #include "opencv2/core/utility.hpp" #include diff --git a/samples/cpp/CMakeLists.txt b/samples/cpp/CMakeLists.txt index d93d0196a2..c75a5c73e2 100644 --- a/samples/cpp/CMakeLists.txt +++ b/samples/cpp/CMakeLists.txt @@ -31,7 +31,8 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND) endif() if(CMAKE_COMPILER_IS_GNUCXX AND NOT ENABLE_NOISY_WARNINGS) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function -Wno-missing-declarations") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-function -Wno-missing-declarations") endif() # --------------------------------------------- @@ -57,8 +58,10 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND) ocv_target_link_libraries(${the_target} opencv_cudaarithm opencv_cudafilters) endif() - if(HAVE_opencv_ocl) - ocv_target_link_libraries(${the_target} opencv_ocl) + if("${srcs}" MATCHES "viz/" AND VTK_USE_FILE) + include(${VTK_USE_FILE}) + ocv_target_link_libraries(${the_target} ${VTK_LIBRARIES}) + add_definitions(-DUSE_VTK) endif() set_target_properties(${the_target} PROPERTIES @@ -88,7 +91,9 @@ if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND) ocv_list_filterout(cpp_samples "/gpu/") endif() - ocv_list_filterout(cpp_samples "viz") + if(NOT TARGET opencv_viz) + ocv_list_filterout(cpp_samples "/viz/") + endif() if(NOT HAVE_IPP_A) ocv_list_filterout(cpp_samples "/ippasync/") diff --git a/samples/cpp/contours2.cpp b/samples/cpp/contours2.cpp index c5a1fa70f5..437f76cb24 100644 --- a/samples/cpp/contours2.cpp +++ b/samples/cpp/contours2.cpp @@ -1,5 +1,5 @@ -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/highgui.hpp" #include #include diff --git a/samples/cpp/convexhull.cpp b/samples/cpp/convexhull.cpp index 36e5544548..fd2275645d 100644 --- a/samples/cpp/convexhull.cpp +++ b/samples/cpp/convexhull.cpp @@ -1,6 +1,5 @@ -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/highgui/highgui.hpp" -#include +#include "opencv2/imgproc.hpp" +#include "opencv2/highgui.hpp" #include using namespace cv; diff --git a/samples/cpp/cout_mat.cpp b/samples/cpp/cout_mat.cpp index bf1dfb2a41..ed2cd71c86 100644 --- a/samples/cpp/cout_mat.cpp +++ b/samples/cpp/cout_mat.cpp @@ -5,7 +5,7 @@ * */ -#include "opencv2/core/core.hpp" +#include "opencv2/core.hpp" #include using namespace std; diff --git a/samples/cpp/dbt_face_detection.cpp b/samples/cpp/dbt_face_detection.cpp index d7409bf5b5..920ae001d8 100644 --- a/samples/cpp/dbt_face_detection.cpp +++ b/samples/cpp/dbt_face_detection.cpp @@ -1,11 +1,11 @@ #if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(ANDROID) -#include // Gaussian Blur -#include // Basic OpenCV structures (cv::Mat, Scalar) -#include -#include // OpenCV window I/O -#include -#include +#include // Gaussian Blur +#include // Basic OpenCV structures (cv::Mat, Scalar) +#include +#include // OpenCV window I/O +#include +#include #include #include diff --git a/samples/cpp/delaunay2.cpp b/samples/cpp/delaunay2.cpp index a370feb2a7..4807cd373f 100644 --- a/samples/cpp/delaunay2.cpp +++ b/samples/cpp/delaunay2.cpp @@ -1,5 +1,5 @@ -#include -#include +#include +#include #include using namespace cv; diff --git a/samples/cpp/facedetect.cpp b/samples/cpp/facedetect.cpp index 2cfe524a18..8f6a45666f 100644 --- a/samples/cpp/facedetect.cpp +++ b/samples/cpp/facedetect.cpp @@ -177,7 +177,7 @@ void detectAndDraw( Mat& img, CascadeClassifier& cascade, resize( gray, smallImg, Size(), fx, fx, INTER_LINEAR ); equalizeHist( smallImg, smallImg ); - t = (double)cvGetTickCount(); + t = (double)getTickCount(); cascade.detectMultiScale( smallImg, faces, 1.1, 2, 0 //|CASCADE_FIND_BIGGEST_OBJECT @@ -198,8 +198,8 @@ void detectAndDraw( Mat& img, CascadeClassifier& cascade, faces.push_back(Rect(smallImg.cols - r->x - r->width, r->y, r->width, r->height)); } } - t = (double)cvGetTickCount() - t; - printf( "detection time = %g ms\n", t/((double)cvGetTickFrequency()*1000.) ); + t = (double)getTickCount() - t; + printf( "detection time = %g ms\n", t*1000/getTickFrequency()); for ( size_t i = 0; i < faces.size(); i++ ) { Rect r = faces[i]; diff --git a/samples/cpp/facial_features.cpp b/samples/cpp/facial_features.cpp index f46fa3fb56..3ed6a442f9 100644 --- a/samples/cpp/facial_features.cpp +++ b/samples/cpp/facial_features.cpp @@ -6,9 +6,9 @@ * */ -#include "opencv2/objdetect/objdetect.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/objdetect.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include #include diff --git a/samples/cpp/fback.cpp b/samples/cpp/fback.cpp index 5fbec6913c..a044844023 100644 --- a/samples/cpp/fback.cpp +++ b/samples/cpp/fback.cpp @@ -1,7 +1,7 @@ #include "opencv2/video/tracking.hpp" -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/videoio/videoio.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/videoio.hpp" +#include "opencv2/highgui.hpp" #include diff --git a/samples/cpp/ffilldemo.cpp b/samples/cpp/ffilldemo.cpp index 93bdd672bd..d10d72e0eb 100644 --- a/samples/cpp/ffilldemo.cpp +++ b/samples/cpp/ffilldemo.cpp @@ -1,7 +1,7 @@ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/videoio/videoio.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/videoio.hpp" +#include "opencv2/highgui.hpp" #include diff --git a/samples/cpp/filestorage.cpp b/samples/cpp/filestorage.cpp index 60ea51acab..46b4da2414 100644 --- a/samples/cpp/filestorage.cpp +++ b/samples/cpp/filestorage.cpp @@ -2,7 +2,7 @@ * filestorage_sample demonstrate the usage of the opencv serialization functionality */ -#include "opencv2/core/core.hpp" +#include "opencv2/core.hpp" #include #include diff --git a/samples/cpp/fitellipse.cpp b/samples/cpp/fitellipse.cpp index b83f617c1d..0cd6c4a6db 100644 --- a/samples/cpp/fitellipse.cpp +++ b/samples/cpp/fitellipse.cpp @@ -14,10 +14,11 @@ * * ********************************************************************************/ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include + using namespace cv; using namespace std; diff --git a/samples/cpp/grabcut.cpp b/samples/cpp/grabcut.cpp index b6b406000b..726906c6ff 100644 --- a/samples/cpp/grabcut.cpp +++ b/samples/cpp/grabcut.cpp @@ -1,6 +1,6 @@ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include diff --git a/samples/cpp/houghcircles.cpp b/samples/cpp/houghcircles.cpp index bdafffec30..26c4dbae08 100644 --- a/samples/cpp/houghcircles.cpp +++ b/samples/cpp/houghcircles.cpp @@ -1,6 +1,6 @@ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include diff --git a/samples/cpp/houghlines.cpp b/samples/cpp/houghlines.cpp index ddeb3bd751..94eec86eeb 100644 --- a/samples/cpp/houghlines.cpp +++ b/samples/cpp/houghlines.cpp @@ -1,6 +1,6 @@ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include diff --git a/samples/cpp/image.cpp b/samples/cpp/image.cpp index b5925c69af..fc57738a77 100644 --- a/samples/cpp/image.cpp +++ b/samples/cpp/image.cpp @@ -1,7 +1,7 @@ #include #include -#include -#include +#include +#include #include using namespace cv; // all the new API is put into "cv" namespace. Export its content diff --git a/samples/cpp/image_sequence.cpp b/samples/cpp/image_sequence.cpp index 14b63e39c4..6a84fab4bd 100644 --- a/samples/cpp/image_sequence.cpp +++ b/samples/cpp/image_sequence.cpp @@ -1,6 +1,6 @@ -#include -#include -#include +#include +#include +#include #include diff --git a/samples/cpp/imagelist_creator.cpp b/samples/cpp/imagelist_creator.cpp index bdb023187b..5b2dc38d47 100644 --- a/samples/cpp/imagelist_creator.cpp +++ b/samples/cpp/imagelist_creator.cpp @@ -1,9 +1,9 @@ /*this creates a yaml or xml list of files from the command line args */ -#include "opencv2/core/core.hpp" +#include "opencv2/core.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include #include diff --git a/samples/cpp/inpaint.cpp b/samples/cpp/inpaint.cpp index 62d7521932..86e6e37416 100644 --- a/samples/cpp/inpaint.cpp +++ b/samples/cpp/inpaint.cpp @@ -1,7 +1,7 @@ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/photo/photo.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/photo.hpp" #include diff --git a/samples/cpp/intelperc_capture.cpp b/samples/cpp/intelperc_capture.cpp index daae4420fb..d8a1c32241 100644 --- a/samples/cpp/intelperc_capture.cpp +++ b/samples/cpp/intelperc_capture.cpp @@ -1,8 +1,8 @@ // testOpenCVCam.cpp : Defines the entry point for the console application. // -#include "opencv2/videoio/videoio.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/videoio.hpp" +#include "opencv2/highgui.hpp" #include diff --git a/samples/cpp/kalman.cpp b/samples/cpp/kalman.cpp index 8f9adc6c27..501a749124 100644 --- a/samples/cpp/kalman.cpp +++ b/samples/cpp/kalman.cpp @@ -1,5 +1,5 @@ #include "opencv2/video/tracking.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include diff --git a/samples/cpp/laplace.cpp b/samples/cpp/laplace.cpp index b33b49cbdb..462f62804e 100644 --- a/samples/cpp/laplace.cpp +++ b/samples/cpp/laplace.cpp @@ -1,6 +1,6 @@ -#include "opencv2/videoio/videoio.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/videoio.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include #include diff --git a/samples/cpp/letter_recog.cpp b/samples/cpp/letter_recog.cpp index 3d7e34ab7a..0eb67d1e42 100644 --- a/samples/cpp/letter_recog.cpp +++ b/samples/cpp/letter_recog.cpp @@ -1,5 +1,5 @@ -#include "opencv2/core/core.hpp" -#include "opencv2/ml/ml.hpp" +#include "opencv2/core.hpp" +#include "opencv2/ml.hpp" #include #include diff --git a/samples/cpp/lkdemo.cpp b/samples/cpp/lkdemo.cpp index 3881aa8650..5e57aa84a4 100644 --- a/samples/cpp/lkdemo.cpp +++ b/samples/cpp/lkdemo.cpp @@ -1,7 +1,7 @@ #include "opencv2/video/tracking.hpp" -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/videoio/videoio.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/videoio.hpp" +#include "opencv2/highgui.hpp" #include #include diff --git a/samples/cpp/lsd_lines.cpp b/samples/cpp/lsd_lines.cpp index 4c8c7e0a41..e0db6c3669 100644 --- a/samples/cpp/lsd_lines.cpp +++ b/samples/cpp/lsd_lines.cpp @@ -1,11 +1,8 @@ #include -#include -#include "opencv2/core/core.hpp" -#include "opencv2/core/utility.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" using namespace std; using namespace cv; @@ -23,6 +20,9 @@ int main(int argc, char** argv) Mat image = imread(in, IMREAD_GRAYSCALE); + if( image.empty() ) + { return -1; } + #if 0 Canny(image, image, 50, 200, 3); // Apply canny edge #endif diff --git a/samples/cpp/minarea.cpp b/samples/cpp/minarea.cpp index 91ad5a37bf..ac79db5e5a 100644 --- a/samples/cpp/minarea.cpp +++ b/samples/cpp/minarea.cpp @@ -1,5 +1,5 @@ -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include diff --git a/samples/cpp/morphology2.cpp b/samples/cpp/morphology2.cpp index 04e916c64a..8439080b2b 100644 --- a/samples/cpp/morphology2.cpp +++ b/samples/cpp/morphology2.cpp @@ -1,6 +1,6 @@ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include #include #include @@ -66,7 +66,7 @@ int main( int argc, char** argv ) return 0; } std::string filename = parser.get("@image"); - if( (src = imread(filename,1)).empty() ) + if( (src = imread(filename,IMREAD_COLOR)).empty() ) { help(); return -1; diff --git a/samples/cpp/openni_capture.cpp b/samples/cpp/openni_capture.cpp index 70d4a7c610..0d0a967226 100644 --- a/samples/cpp/openni_capture.cpp +++ b/samples/cpp/openni_capture.cpp @@ -1,6 +1,6 @@ #include "opencv2/videoio/videoio.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include @@ -21,6 +21,8 @@ static void help() "2.) Data given from RGB image generator\n" " CAP_OPENNI_BGR_IMAGE - color image (CV_8UC3)\n" " CAP_OPENNI_GRAY_IMAGE - gray image (CV_8UC1)\n" + "2.) Data given from IR image generator\n" + " CAP_OPENNI_IR_IMAGE - gray image (CV_16UC1)\n" << endl; } @@ -92,8 +94,8 @@ static void printCommandLineParams() cout << "-mode= image mode: resolution and fps, supported three values: 0 - CAP_OPENNI_VGA_30HZ, 1 - CAP_OPENNI_SXGA_15HZ," << endl; cout << " 2 - CAP_OPENNI_SXGA_30HZ (0 by default). Ignored if rgb image or gray image are not selected to show." << endl; cout << "-m= Mask to set which output images are need. It is a string of size 5. Each element of this is '0' or '1' and" << endl; - cout << " determine: is depth map, disparity map, valid pixels mask, rgb image, gray image need or not (correspondently)?" << endl ; - cout << " By default -m=01010 i.e. disparity map and rgb image will be shown." << endl ; + cout << " determine: is depth map, disparity map, valid pixels mask, rgb image, gray image need or not (correspondently), ir image" << endl ; + cout << " By default -m=010100 i.e. disparity map and rgb image will be shown." << endl ; cout << "-r= Filename of .oni video file. The data will grabbed from it." << endl ; } @@ -101,7 +103,7 @@ static void parseCommandLine( int argc, char* argv[], bool& isColorizeDisp, bool string& filename, bool& isFileReading ) { filename.clear(); - cv::CommandLineParser parser(argc, argv, "{h help||}{cd|1|}{fmd|0|}{mode|0|}{m|01010|}{r||}"); + cv::CommandLineParser parser(argc, argv, "{h help||}{cd|1|}{fmd|0|}{mode|-1|}{m|010100|}{r||}"); if (parser.has("h")) { help(); @@ -121,14 +123,14 @@ static void parseCommandLine( int argc, char* argv[], bool& isColorizeDisp, bool help(); exit(-1); } - if (flags % 100000 == 0) + if (flags % 1000000 == 0) { cout << "No one output image is selected." << endl; exit(0); } - for (int i = 0; i < 5; i++) + for (int i = 0; i < 6; i++) { - retrievedImageFlags[4 - i] = (flags % 10 != 0); + retrievedImageFlags[5 - i] = (flags % 10 != 0); flags /= 10; } } @@ -141,7 +143,7 @@ int main( int argc, char* argv[] ) { bool isColorizeDisp, isFixedMaxDisp; int imageMode; - bool retrievedImageFlags[5]; + bool retrievedImageFlags[6]; string filename; bool isVideoReading; parseCommandLine( argc, argv, isColorizeDisp, isFixedMaxDisp, imageMode, retrievedImageFlags, filename, isVideoReading ); @@ -165,7 +167,7 @@ int main( int argc, char* argv[] ) return -1; } - if( !isVideoReading ) + if( !isVideoReading && imageMode >= 0 ) { bool modeRes=false; switch ( imageMode ) @@ -193,13 +195,35 @@ int main( int argc, char* argv[] ) cout << "\nThis image mode is not supported by the device, the default value (CV_CAP_OPENNI_SXGA_15HZ) will be used.\n" << endl; } + // turn on depth, color and IR if needed + if (retrievedImageFlags[0] || retrievedImageFlags[1] || retrievedImageFlags[2]) + capture.set(CAP_OPENNI_DEPTH_GENERATOR_PRESENT, true); + else + capture.set(CAP_OPENNI_DEPTH_GENERATOR_PRESENT, false); + if (retrievedImageFlags[3] || retrievedImageFlags[4]) + capture.set(CAP_OPENNI_IMAGE_GENERATOR_PRESENT, true); + else + capture.set(CAP_OPENNI_IMAGE_GENERATOR_PRESENT, false); + if (retrievedImageFlags[5]) + capture.set(CAP_OPENNI_IR_GENERATOR_PRESENT, true); + else + capture.set(CAP_OPENNI_IR_GENERATOR_PRESENT, false); + // Print some avalible device settings. - cout << "\nDepth generator output mode:" << endl << - "FRAME_WIDTH " << capture.get( CAP_PROP_FRAME_WIDTH ) << endl << - "FRAME_HEIGHT " << capture.get( CAP_PROP_FRAME_HEIGHT ) << endl << - "FRAME_MAX_DEPTH " << capture.get( CAP_PROP_OPENNI_FRAME_MAX_DEPTH ) << " mm" << endl << - "FPS " << capture.get( CAP_PROP_FPS ) << endl << - "REGISTRATION " << capture.get( CAP_PROP_OPENNI_REGISTRATION ) << endl; + if (capture.get(CAP_OPENNI_DEPTH_GENERATOR_PRESENT)) + { + cout << "\nDepth generator output mode:" << endl << + "FRAME_WIDTH " << capture.get(CAP_PROP_FRAME_WIDTH) << endl << + "FRAME_HEIGHT " << capture.get(CAP_PROP_FRAME_HEIGHT) << endl << + "FRAME_MAX_DEPTH " << capture.get(CAP_PROP_OPENNI_FRAME_MAX_DEPTH) << " mm" << endl << + "FPS " << capture.get(CAP_PROP_FPS) << endl << + "REGISTRATION " << capture.get(CAP_PROP_OPENNI_REGISTRATION) << endl; + } + else + { + cout << "\nDevice doesn't contain depth generator or it is not selected." << endl; + } + if( capture.get( CAP_OPENNI_IMAGE_GENERATOR_PRESENT ) ) { cout << @@ -210,9 +234,20 @@ int main( int argc, char* argv[] ) } else { - cout << "\nDevice doesn't contain image generator." << endl; - if (!retrievedImageFlags[0] && !retrievedImageFlags[1] && !retrievedImageFlags[2]) - return 0; + cout << "\nDevice doesn't contain image generator or it is not selected." << endl; + } + + if( capture.get(CAP_OPENNI_IR_GENERATOR_PRESENT) ) + { + cout << + "\nIR generator output mode:" << endl << + "FRAME_WIDTH " << capture.get(CAP_OPENNI_IR_GENERATOR + CAP_PROP_FRAME_WIDTH) << endl << + "FRAME_HEIGHT " << capture.get(CAP_OPENNI_IR_GENERATOR + CAP_PROP_FRAME_HEIGHT) << endl << + "FPS " << capture.get(CAP_OPENNI_IR_GENERATOR + CAP_PROP_FPS) << endl; + } + else + { + cout << "\nDevice doesn't contain IR generator or it is not selected." << endl; } for(;;) @@ -222,6 +257,7 @@ int main( int argc, char* argv[] ) Mat disparityMap; Mat bgrImage; Mat grayImage; + Mat irImage; if( !capture.grab() ) { @@ -261,6 +297,13 @@ int main( int argc, char* argv[] ) if( retrievedImageFlags[4] && capture.retrieve( grayImage, CAP_OPENNI_GRAY_IMAGE ) ) imshow( "gray image", grayImage ); + + if( retrievedImageFlags[5] && capture.retrieve( irImage, CAP_OPENNI_IR_IMAGE ) ) + { + Mat ir8; + irImage.convertTo(ir8, CV_8U, 256.0 / 3500, 0.0); + imshow("IR image", ir8); + } } if( waitKey( 30 ) >= 0 ) diff --git a/samples/cpp/pca.cpp b/samples/cpp/pca.cpp index 35fd0c1a04..b33a463211 100644 --- a/samples/cpp/pca.cpp +++ b/samples/cpp/pca.cpp @@ -42,9 +42,9 @@ #include #include -#include +#include #include "opencv2/imgcodecs.hpp" -#include +#include using namespace cv; using namespace std; diff --git a/samples/cpp/phase_corr.cpp b/samples/cpp/phase_corr.cpp index 5e8685fcfa..c3120fe084 100644 --- a/samples/cpp/phase_corr.cpp +++ b/samples/cpp/phase_corr.cpp @@ -1,7 +1,7 @@ -#include "opencv2/core/core.hpp" -#include "opencv2/videoio/videoio.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/core.hpp" +#include "opencv2/videoio.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" using namespace cv; diff --git a/samples/cpp/polar_transforms.cpp b/samples/cpp/polar_transforms.cpp index 872dda8c3f..3cbc431c3c 100644 --- a/samples/cpp/polar_transforms.cpp +++ b/samples/cpp/polar_transforms.cpp @@ -1,94 +1,75 @@ -#include "opencv2/imgproc/imgproc_c.h" -#include "opencv2/videoio/videoio_c.h" -#include "opencv2/highgui/highgui_c.h" -#include "opencv2/core/utility.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include -#include -#include +using namespace cv; static void help( void ) { printf("\nThis program illustrates Linear-Polar and Log-Polar image transforms\n" "Usage :\n" - "./polar_transforms [[camera number -- Default 0],[AVI path_filename]]\n\n" - ); + "./polar_transforms [[camera number -- Default 0],[path_to_filename]]\n\n"); } + int main( int argc, char** argv ) { - CvCapture* capture = 0; - IplImage* log_polar_img = 0; - IplImage* lin_polar_img = 0; - IplImage* recovered_img = 0; + VideoCapture capture; + Mat log_polar_img, lin_polar_img, recovered_log_polar, recovered_lin_polar_img; help(); - cv::CommandLineParser parser(argc, argv, "{help h||}{@input|0|}"); - if (parser.has("help")) - { - help(); - return 0; - } + + CommandLineParser parser(argc, argv, "{@input|0|}"); std::string arg = parser.get("@input"); + if( arg.size() == 1 && isdigit(arg[0]) ) - capture = cvCaptureFromCAM( arg[0] - '0' ); + capture.open( arg[0] - '0' ); else - capture = cvCaptureFromAVI( arg.c_str() ); - if( !capture ) + capture.open( arg.c_str() ); + + if( !capture.isOpened() ) { const char* name = argv[0]; fprintf(stderr,"Could not initialize capturing...\n"); fprintf(stderr,"Usage: %s , or \n %s \n", name, name); - help(); return -1; } - cvNamedWindow( "Linear-Polar", 0 ); - cvNamedWindow( "Log-Polar", 0 ); - cvNamedWindow( "Recovered image", 0 ); + namedWindow( "Linear-Polar", WINDOW_NORMAL ); + namedWindow( "Log-Polar", WINDOW_NORMAL ); + namedWindow( "Recovered Linear-Polar", WINDOW_NORMAL ); + namedWindow( "Recovered Log-Polar", WINDOW_NORMAL ); - cvMoveWindow( "Linear-Polar", 20,20 ); - cvMoveWindow( "Log-Polar", 700,20 ); - cvMoveWindow( "Recovered image", 20,700 ); + moveWindow( "Linear-Polar", 20,20 ); + moveWindow( "Log-Polar", 700,20 ); + moveWindow( "Recovered Linear-Polar", 20, 350 ); + moveWindow( "Recovered Log-Polar", 700, 350 ); for(;;) { - IplImage* frame = 0; + Mat frame; + capture >> frame; - frame = cvQueryFrame( capture ); - if( !frame ) + if( frame.empty() ) break; - if( !log_polar_img ) - { - log_polar_img = cvCreateImage( cvSize(frame->width,frame->height), IPL_DEPTH_8U, frame->nChannels ); - lin_polar_img = cvCreateImage( cvSize(frame->width,frame->height), IPL_DEPTH_8U, frame->nChannels ); - recovered_img = cvCreateImage( cvSize(frame->width,frame->height), IPL_DEPTH_8U, frame->nChannels ); - } + Point2f center( (float)frame.cols / 2, (float)frame.rows / 2 ); + double M = (double)frame.cols / 8; - cvLogPolar(frame,log_polar_img,cvPoint2D32f(frame->width >> 1,frame->height >> 1),70, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS); - cvLinearPolar(frame,lin_polar_img,cvPoint2D32f(frame->width >> 1,frame->height >> 1),70, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS); + logPolar(frame,log_polar_img, center, M, INTER_LINEAR + WARP_FILL_OUTLIERS); + linearPolar(frame,lin_polar_img, center, M, INTER_LINEAR + WARP_FILL_OUTLIERS); -#if 0 - cvLogPolar(log_polar_img,recovered_img,cvPoint2D32f(frame->width >> 1,frame->height >> 1),70, CV_WARP_INVERSE_MAP+CV_INTER_LINEAR); -#else - cvLinearPolar(lin_polar_img,recovered_img,cvPoint2D32f(frame->width >> 1,frame->height >> 1),70, CV_WARP_INVERSE_MAP+CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS); -#endif + logPolar(log_polar_img, recovered_log_polar, center, M, WARP_INVERSE_MAP + INTER_LINEAR); + linearPolar(lin_polar_img, recovered_lin_polar_img, center, M, WARP_INVERSE_MAP + INTER_LINEAR + WARP_FILL_OUTLIERS); - cvShowImage("Log-Polar", log_polar_img ); - cvShowImage("Linear-Polar", lin_polar_img ); - cvShowImage("Recovered image", recovered_img ); + imshow("Log-Polar", log_polar_img ); + imshow("Linear-Polar", lin_polar_img ); + imshow("Recovered Linear-Polar", recovered_lin_polar_img ); + imshow("Recovered Log-Polar", recovered_log_polar ); - if( cvWaitKey(10) >= 0 ) + if( waitKey(10) >= 0 ) break; } - cvReleaseCapture( &capture ); - cvDestroyWindow("Linear-Polar"); - cvDestroyWindow("Log-Polar"); - cvDestroyWindow("Recovered image"); - + waitKey(0); return 0; } - -#ifdef _EiC -main(1,"laplace.c"); -#endif diff --git a/samples/cpp/segment_objects.cpp b/samples/cpp/segment_objects.cpp index 3c217f679d..916283124f 100644 --- a/samples/cpp/segment_objects.cpp +++ b/samples/cpp/segment_objects.cpp @@ -1,6 +1,6 @@ -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/videoio/videoio.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/videoio.hpp" +#include "opencv2/highgui.hpp" #include "opencv2/video/background_segm.hpp" #include #include diff --git a/samples/cpp/squares.cpp b/samples/cpp/squares.cpp index f53e931e75..df8459caa4 100644 --- a/samples/cpp/squares.cpp +++ b/samples/cpp/squares.cpp @@ -2,10 +2,10 @@ // It loads several images sequentially and tries to find squares in // each image -#include "opencv2/core/core.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/core.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include #include @@ -23,8 +23,8 @@ static void help() "Returns sequence of squares detected on the image.\n" "the sequence is stored in the specified memory storage\n" "Call:\n" - "./squares\n" - "Using OpenCV version %s\n" << CV_VERSION << "\n" << endl; + "./squares [file_name (optional)]\n" + "Using OpenCV version " << CV_VERSION << "\n" << endl; } @@ -140,11 +140,18 @@ static void drawSquares( Mat& image, const vector >& squares ) } -int main(int /*argc*/, char** /*argv*/) +int main(int argc, char** argv) { static const char* names[] = { "../data/pic1.png", "../data/pic2.png", "../data/pic3.png", "../data/pic4.png", "../data/pic5.png", "../data/pic6.png", 0 }; help(); + + if( argc > 1) + { + names[0] = argv[1]; + names[1] = "0"; + } + namedWindow( wndname, 1 ); vector > squares; diff --git a/samples/cpp/starter_imagelist.cpp b/samples/cpp/starter_imagelist.cpp index 89df0cc1b5..6f4f71466c 100644 --- a/samples/cpp/starter_imagelist.cpp +++ b/samples/cpp/starter_imagelist.cpp @@ -9,7 +9,7 @@ * easy as CV_PI right? */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include #include diff --git a/samples/cpp/starter_video.cpp b/samples/cpp/starter_video.cpp index d6bf1b7664..2839b03d7e 100644 --- a/samples/cpp/starter_video.cpp +++ b/samples/cpp/starter_video.cpp @@ -12,8 +12,8 @@ */ #include -#include -#include +#include +#include #include #include diff --git a/samples/cpp/stereo_calib.cpp b/samples/cpp/stereo_calib.cpp index 23dfffd417..025e1d3b60 100644 --- a/samples/cpp/stereo_calib.cpp +++ b/samples/cpp/stereo_calib.cpp @@ -22,10 +22,10 @@ GitHub: https://github.com/Itseez/opencv/ ************************************************** */ -#include "opencv2/calib3d/calib3d.hpp" +#include "opencv2/calib3d.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include #include diff --git a/samples/cpp/stereo_match.cpp b/samples/cpp/stereo_match.cpp index e88b139a16..4868a63950 100644 --- a/samples/cpp/stereo_match.cpp +++ b/samples/cpp/stereo_match.cpp @@ -8,9 +8,9 @@ */ #include "opencv2/calib3d/calib3d.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include "opencv2/core/utility.hpp" #include diff --git a/samples/cpp/tree_engine.cpp b/samples/cpp/tree_engine.cpp index 4412588753..96b2adf837 100644 --- a/samples/cpp/tree_engine.cpp +++ b/samples/cpp/tree_engine.cpp @@ -1,5 +1,5 @@ -#include "opencv2/ml/ml.hpp" -#include "opencv2/core/core.hpp" +#include "opencv2/ml.hpp" +#include "opencv2/core.hpp" #include "opencv2/core/utility.hpp" #include #include diff --git a/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp b/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp index 9e04dd912e..93a7b48b19 100644 --- a/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp +++ b/samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp @@ -5,7 +5,7 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include using namespace cv; diff --git a/samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp b/samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp index 213850f995..1834e35e22 100644 --- a/samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp +++ b/samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp @@ -6,7 +6,7 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" using namespace cv; diff --git a/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp index 45db5854e5..80d4d4645b 100644 --- a/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp +++ b/samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp @@ -5,10 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include using namespace cv; using namespace std; @@ -24,10 +23,10 @@ int main( int, char** argv ) const char* equalized_window = "Equalized Image"; /// Load image - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) - { cout<<"Usage: ./Histogram_Demo "<"< -#include using namespace std; using namespace cv; @@ -27,11 +26,24 @@ void MatchingMethod( int, void* ); /** * @function main */ -int main( int, char** argv ) +int main( int argc, char** argv ) { + if (argc < 3) + { + cout << "Not enough parameters" << endl; + cout << "Usage:\n./MatchTemplate_Demo " << endl; + return -1; + } + /// Load image and template - img = imread( argv[1], 1 ); - templ = imread( argv[2], 1 ); + img = imread( argv[1], IMREAD_COLOR ); + templ = imread( argv[2], IMREAD_COLOR ); + + if(img.empty() || templ.empty()) + { + cout << "Can't read one of the images" << endl; + return -1; + } /// Create windows namedWindow( image_window, WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp index ce0e911237..1e2fe928f7 100644 --- a/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp +++ b/samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp @@ -4,9 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include @@ -27,7 +27,13 @@ void Hist_and_Backproj(int, void* ); int main( int, char** argv ) { /// Read the image - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); + + if( src.empty() ) + { cout<<"Usage: ./calcBackProject_Demo1 "< @@ -30,7 +30,7 @@ void pickPoint (int event, int x, int y, int, void* ); int main( int, char** argv ) { /// Read the image - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); /// Transform it to HSV cvtColor( src, hsv, COLOR_BGR2HSV ); diff --git a/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp index 1540cd85da..27e21e76b2 100644 --- a/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp +++ b/samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp @@ -4,11 +4,10 @@ * @author */ -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include -#include using namespace std; using namespace cv; @@ -16,12 +15,19 @@ using namespace cv; /** * @function main */ -int main( int, char** argv ) +int main(int argc, char** argv) { Mat src, dst; /// Load image - src = imread( argv[1], 1 ); + String imageName( "../data/lena.jpg" ); // by default + + if (argc > 1) + { + imageName = argv[1]; + } + + src = imread( imageName, IMREAD_COLOR ); if( src.empty() ) { return -1; } diff --git a/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp b/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp index 122e19bebc..4d0123b247 100644 --- a/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp +++ b/samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp @@ -5,10 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include using namespace std; using namespace cv; @@ -26,13 +25,19 @@ int main( int argc, char** argv ) /// Load three images with different environment settings if( argc < 4 ) { - printf("** Error. Usage: ./compareHist_Demo \n"); + printf("** Error. Usage: ./compareHist_Demo \n"); return -1; } - src_base = imread( argv[1], 1 ); - src_test1 = imread( argv[2], 1 ); - src_test2 = imread( argv[3], 1 ); + src_base = imread( argv[1], IMREAD_COLOR ); + src_test1 = imread( argv[2], IMREAD_COLOR ); + src_test2 = imread( argv[3], IMREAD_COLOR ); + + if(src_base.empty() || src_test1.empty() || src_test2.empty()) + { + cout << "Can't read one of the images" << endl; + return -1; + } /// Convert to HSV cvtColor( src_base, hsv_base, COLOR_BGR2HSV ); diff --git a/samples/cpp/tutorial_code/ImgProc/AddingImages.cpp b/samples/cpp/tutorial_code/ImgProc/AddingImages.cpp index 32ce10f4b2..20b09ec32b 100644 --- a/samples/cpp/tutorial_code/ImgProc/AddingImages.cpp +++ b/samples/cpp/tutorial_code/ImgProc/AddingImages.cpp @@ -5,7 +5,7 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include using namespace cv; diff --git a/samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp b/samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp index 9ffe1563de..b24451de35 100644 --- a/samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp +++ b/samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp @@ -5,7 +5,7 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include using namespace cv; diff --git a/samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp b/samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp index e8fac91300..626bd8b960 100644 --- a/samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp +++ b/samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp @@ -4,11 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include -#include +#include "opencv2/highgui.hpp" using namespace cv; @@ -32,7 +30,7 @@ void Dilation( int, void* ); int main( int, char** argv ) { /// Load an image - src = imread( argv[1] ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) { return -1; } diff --git a/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp b/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp index 3f43eeeedb..97304a4612 100644 --- a/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp +++ b/samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp @@ -4,11 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include -#include +#include "opencv2/highgui.hpp" using namespace cv; @@ -34,7 +32,7 @@ void Morphology_Operations( int, void* ); int main( int, char** argv ) { /// Load an image - src = imread( argv[1] ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) { return -1; } @@ -67,7 +65,6 @@ int main( int, char** argv ) */ void Morphology_Operations( int, void* ) { - // Since MORPH_X : 2,3,4,5 and 6 int operation = morph_operator + 2; diff --git a/samples/cpp/tutorial_code/ImgProc/Pyramids.cpp b/samples/cpp/tutorial_code/ImgProc/Pyramids.cpp index c52c0e04f4..e4b7096e6d 100644 --- a/samples/cpp/tutorial_code/ImgProc/Pyramids.cpp +++ b/samples/cpp/tutorial_code/ImgProc/Pyramids.cpp @@ -4,12 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include -#include -#include +#include "opencv2/highgui.hpp" using namespace cv; diff --git a/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp b/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp index e7ac4d40f5..6a84da073b 100644 --- a/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp +++ b/samples/cpp/tutorial_code/ImgProc/Smoothing.cpp @@ -3,13 +3,10 @@ * brief Sample code for simple filters * author OpenCV team */ -#include -#include -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/features2d/features2d.hpp" +#include "opencv2/highgui.hpp" using namespace std; using namespace cv; @@ -35,7 +32,7 @@ int main( void ) namedWindow( window_name, WINDOW_AUTOSIZE ); /// Load the source image - src = imread( "../data/lena.jpg", 1 ); + src = imread( "../data/lena.jpg", IMREAD_COLOR ); if( display_caption( "Original Image" ) != 0 ) { return 0; } diff --git a/samples/cpp/tutorial_code/ImgProc/Threshold.cpp b/samples/cpp/tutorial_code/ImgProc/Threshold.cpp index 0944f6cd3b..36943028d9 100644 --- a/samples/cpp/tutorial_code/ImgProc/Threshold.cpp +++ b/samples/cpp/tutorial_code/ImgProc/Threshold.cpp @@ -4,11 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include -#include +#include "opencv2/highgui.hpp" using namespace cv; @@ -35,10 +33,13 @@ void Threshold_Demo( int, void* ); int main( int, char** argv ) { /// Load an image - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); + + if( src.empty() ) + { return -1; } /// Convert the image to Gray - cvtColor( src, src_gray, COLOR_RGB2GRAY ); + cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Create a window to display results namedWindow( window_name, WINDOW_AUTOSIZE ); diff --git a/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp index 92e10e4b0d..8b94bb3207 100644 --- a/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp @@ -4,11 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include -#include +#include "opencv2/highgui.hpp" using namespace cv; @@ -50,7 +48,7 @@ static void CannyThreshold(int, void*) int main( int, char** argv ) { /// Load an image - src = imread( argv[1] ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) { return -1; } diff --git a/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp index 00184a3f87..edbb1e7387 100644 --- a/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp @@ -5,10 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include using namespace cv; using namespace std; @@ -31,7 +30,7 @@ int main( int, char** argv ) Mat src, warp_dst, warp_rotate_dst; /// Load the image - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); /// Set the dst image the same type and size as src warp_dst = Mat::zeros( src.rows, src.cols, src.type() ); diff --git a/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp index 02f03813f2..81bb3f8895 100644 --- a/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp @@ -5,8 +5,8 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include using namespace std; @@ -63,7 +63,7 @@ int main(int argc, char** argv) } // Read the image - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) { diff --git a/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp index 2d9b7b6454..5610cfefe5 100644 --- a/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp @@ -5,10 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include using namespace cv; using namespace std; @@ -39,7 +38,7 @@ void Probabilistic_Hough( int, void* ); int main( int, char** argv ) { /// Read the image - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) { help(); diff --git a/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp index f0d45e715b..386b26da74 100644 --- a/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp @@ -4,11 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include -#include +#include "opencv2/highgui.hpp" using namespace cv; @@ -26,7 +24,7 @@ int main( int, char** argv ) const char* window_name = "Laplace Demo"; /// Load an image - src = imread( argv[1] ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) { return -1; } diff --git a/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp index 49727e9cf0..b5a76faa47 100644 --- a/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp @@ -5,10 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include using namespace cv; @@ -27,7 +26,7 @@ void update_map( void ); int main( int, char** argv ) { /// Load the image - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); /// Create dst, map_x and map_y with the same size as src: dst.create( src.size(), src.type() ); diff --git a/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp b/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp index 7d57e8ec6c..efe4c71691 100644 --- a/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp @@ -4,11 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include -#include +#include "opencv2/highgui.hpp" using namespace cv; @@ -26,7 +24,7 @@ int main( int, char** argv ) int ddepth = CV_16S; /// Load an image - src = imread( argv[1] ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) { return -1; } diff --git a/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp b/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp index 5f786d568f..6da2b296b2 100644 --- a/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp @@ -4,11 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include -#include +#include "opencv2/highgui.hpp" using namespace cv; @@ -28,7 +26,7 @@ int main( int, char** argv ) int c; /// Load an image - src = imread( argv[1] ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) { diff --git a/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp b/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp index 3c580bb216..6fc04d8f41 100644 --- a/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp +++ b/samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp @@ -4,11 +4,9 @@ * @author OpenCV team */ -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include -#include +#include "opencv2/highgui.hpp" using namespace cv; @@ -30,7 +28,7 @@ int main ( int, char** argv ) int c; /// Load an image - src = imread( argv[1] ); + src = imread( argv[1], IMREAD_COLOR ); if( src.empty() ) { return -1; } diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp index 6a6de95394..b831441b33 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp @@ -5,11 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; @@ -28,7 +26,7 @@ void thresh_callback(int, void* ); int main( int, char** argv ) { /// Load source image - src = imread(argv[1]); + src = imread(argv[1], IMREAD_COLOR); if (src.empty()) { cerr << "No image supplied ..." << endl; diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp index a9c22e60fc..29d75515cf 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp @@ -5,11 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; @@ -28,7 +26,7 @@ void thresh_callback(int, void* ); int main( int, char** argv ) { /// Load source image and convert it to gray - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); /// Convert image to gray and blur it cvtColor( src, src_gray, COLOR_BGR2GRAY ); diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp index c6fd379328..742c6cf0a9 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp @@ -5,11 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; @@ -28,7 +26,7 @@ void thresh_callback(int, void* ); int main( int, char** argv ) { /// Load source image and convert it to gray - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); /// Convert image to gray and blur it cvtColor( src, src_gray, COLOR_BGR2GRAY ); diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp index 0b354291a9..7fe5b71f98 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp @@ -5,11 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; @@ -28,7 +26,7 @@ void thresh_callback(int, void* ); int main( int, char** argv ) { /// Load source image and convert it to gray - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); /// Convert image to gray and blur it cvtColor( src, src_gray, COLOR_BGR2GRAY ); diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp index c3a5cbf60a..4064048df7 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp @@ -5,11 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; @@ -28,7 +26,7 @@ void thresh_callback(int, void* ); int main( int, char** argv ) { /// Load source image and convert it to gray - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); /// Convert image to gray and blur it cvtColor( src, src_gray, COLOR_BGR2GRAY ); diff --git a/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp b/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp index f55f8f6879..757b8dc0f8 100644 --- a/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp +++ b/samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp @@ -4,11 +4,9 @@ * @author OpenCV team */ -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; diff --git a/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp index c5dceab48b..52d7561522 100644 --- a/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp +++ b/samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp @@ -3,12 +3,11 @@ * @brief Demo code for detecting corners using OpenCV built-in functions * @author OpenCV team */ + #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; @@ -40,7 +39,7 @@ void myHarris_function( int, void* ); int main( int, char** argv ) { /// Load source image and convert it to gray - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Set some parameters diff --git a/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp index 4314a97e26..4f1df4b844 100644 --- a/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp +++ b/samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp @@ -5,11 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; @@ -31,7 +29,7 @@ void cornerHarris_demo( int, void* ); int main( int, char** argv ) { /// Load source image and convert it to gray - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Create a window and a trackbar diff --git a/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp index 775e566ce7..8e4876bcee 100644 --- a/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp +++ b/samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp @@ -5,11 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; @@ -32,7 +30,7 @@ void goodFeaturesToTrack_Demo( int, void* ); int main( int, char** argv ) { /// Load source image and convert it to gray - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Create Window diff --git a/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp b/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp index cff59f5390..da357e7407 100644 --- a/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp +++ b/samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp @@ -5,11 +5,9 @@ */ #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" #include -#include -#include using namespace cv; using namespace std; @@ -32,7 +30,7 @@ void goodFeaturesToTrack_Demo( int, void* ); int main( int, char** argv ) { /// Load source image and convert it to gray - src = imread( argv[1], 1 ); + src = imread( argv[1], IMREAD_COLOR ); cvtColor( src, src_gray, COLOR_BGR2GRAY ); /// Create Window diff --git a/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp b/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp index 0322519839..580fe73792 100644 --- a/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp +++ b/samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp @@ -21,7 +21,7 @@ using namespace std; static void help() { cout << "This is a camera calibration sample." << endl - << "Usage: calibration configurationFile" << endl + << "Usage: camera_calibration [configuration_file -- default ./default.xml]" << endl << "Near the sample file you'll find the configuration file, which has detailed help of " "how to edit it. It may be any OpenCV supported file format XML/YAML." << endl; } @@ -415,7 +415,7 @@ int main(int argc, char* argv[]) for(size_t i = 0; i < s.imageList.size(); i++ ) { - view = imread(s.imageList[i], 1); + view = imread(s.imageList[i], IMREAD_COLOR); if(view.empty()) continue; remap(view, rview, map1, map2, INTER_LINEAR); diff --git a/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp b/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp index fa2bad442e..b548bed463 100644 --- a/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp +++ b/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp @@ -11,8 +11,8 @@ #include "ModelRegistration.h" #include "Utils.h" -#include -#include +#include +#include // For text int fontFace = cv::FONT_ITALIC; diff --git a/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_detection.cpp b/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_detection.cpp index 6de590e684..4808e64135 100644 --- a/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_detection.cpp +++ b/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_detection.cpp @@ -2,11 +2,11 @@ #include #include // OpenCV -#include +#include #include -#include -#include -#include +#include +#include +#include #include // PnP Tutorial #include "Mesh.h" diff --git a/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_registration.cpp b/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_registration.cpp index da775a063e..5ddb83f0da 100644 --- a/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_registration.cpp +++ b/samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_registration.cpp @@ -1,10 +1,10 @@ // C++ #include // OpenCV -#include -#include -#include -#include +#include +#include +#include +#include // PnP Tutorial #include "Mesh.h" #include "Model.h" diff --git a/samples/cpp/tutorial_code/calib3d/stereoBM/SBM_Sample.cpp b/samples/cpp/tutorial_code/calib3d/stereoBM/SBM_Sample.cpp index 90fa2801be..d114a9582f 100644 --- a/samples/cpp/tutorial_code/calib3d/stereoBM/SBM_Sample.cpp +++ b/samples/cpp/tutorial_code/calib3d/stereoBM/SBM_Sample.cpp @@ -4,12 +4,10 @@ * @author A. Huaman */ -#include #include -#include "opencv2/calib3d/calib3d.hpp" -#include "opencv2/core/core.hpp" +#include "opencv2/calib3d.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" using namespace cv; diff --git a/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp b/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp index dbebeea923..e23ab1c326 100644 --- a/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp +++ b/samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp @@ -1,7 +1,7 @@ -#include "opencv2/core/core.hpp" -#include "opencv2/imgproc/imgproc.hpp" +#include "opencv2/core.hpp" +#include "opencv2/imgproc.hpp" #include "opencv2/imgcodecs.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/highgui.hpp" #include diff --git a/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp b/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp index 8fc722df78..faeacfb967 100644 --- a/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp +++ b/samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include diff --git a/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp b/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp index c673c66592..47a5547837 100644 --- a/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp +++ b/samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp @@ -16,7 +16,7 @@ static void help() << " we take an input image and divide the native color palette (255) with the " << endl << "input. Shows C operator[] method, iterators and at function for on-the-fly item address calculation."<< endl << "Usage:" << endl - << "./howToScanImages imageNameToUse divideWith [G]" << endl + << "./how_to_scan_images [G]" << endl << "if you add a G parameter the image is processed in gray scale" << endl << "--------------------------------------------------------------------------" << endl << endl; diff --git a/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp b/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp index b6aa6131de..79e7c99d85 100644 --- a/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp +++ b/samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp @@ -1,12 +1,9 @@ //! [head] -#include #include -#include -#include +#include #include "opencv2/imgcodecs.hpp" -#include -#include +#include using namespace cv; // The new C++ interface API is inside this namespace. Import it. using namespace std; diff --git a/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp b/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp index f0cbca1695..8eb9ca7efd 100644 --- a/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp +++ b/samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp @@ -1,5 +1,3 @@ -#include -#include #include #include #include @@ -25,38 +23,44 @@ int main( int argc, char* argv[]) help(argv[0]); const char* filename = argc >=2 ? argv[1] : "../data/lena.jpg"; - Mat I, J, K; + Mat src, dst0, dst1; if (argc >= 3 && !strcmp("G", argv[2])) - I = imread( filename, IMREAD_GRAYSCALE); + src = imread( filename, IMREAD_GRAYSCALE); else - I = imread( filename, IMREAD_COLOR); + src = imread( filename, IMREAD_COLOR); + + if (src.empty()) + { + cerr << "Can't open image [" << filename << "]" << endl; + return -1; + } namedWindow("Input", WINDOW_AUTOSIZE); namedWindow("Output", WINDOW_AUTOSIZE); - imshow("Input", I); + imshow( "Input", src ); double t = (double)getTickCount(); - Sharpen(I, J); + Sharpen( src, dst0 ); t = ((double)getTickCount() - t)/getTickFrequency(); cout << "Hand written function times passed in seconds: " << t << endl; - imshow("Output", J); - waitKey(0); + imshow( "Output", dst0 ); + waitKey(); - Mat kern = (Mat_(3,3) << 0, -1, 0, + Mat kernel = (Mat_(3,3) << 0, -1, 0, -1, 5, -1, 0, -1, 0); t = (double)getTickCount(); - filter2D(I, K, I.depth(), kern ); + filter2D( src, dst1, src.depth(), kernel ); t = ((double)getTickCount() - t)/getTickFrequency(); cout << "Built-in filter2D time passed in seconds: " << t << endl; - imshow("Output", K); + imshow( "Output", dst1 ); - waitKey(0); + waitKey(); return 0; } void Sharpen(const Mat& myImage,Mat& Result) diff --git a/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp b/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp index 7fb060bddd..77ea93827f 100644 --- a/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp +++ b/samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp @@ -1,6 +1,6 @@ /* For description look into the help() function. */ -#include "opencv2/core/core.hpp" +#include "opencv2/core.hpp" #include using namespace std; @@ -15,7 +15,7 @@ static void help() << "That is, cv::Mat M(...); M.create and cout << M. " << endl << "Shows how output can be formated to OpenCV, python, numpy, csv and C styles." << endl << "Usage:" << endl - << "./cvout_sample" << endl + << "./mat_the_basic_image_container" << endl << "--------------------------------------------------------------------------" << endl << endl; } diff --git a/samples/cpp/tutorial_code/imgcodecs/GDAL_IO/gdal-image.cpp b/samples/cpp/tutorial_code/imgcodecs/GDAL_IO/gdal-image.cpp index 6e7c950a26..66084df78a 100644 --- a/samples/cpp/tutorial_code/imgcodecs/GDAL_IO/gdal-image.cpp +++ b/samples/cpp/tutorial_code/imgcodecs/GDAL_IO/gdal-image.cpp @@ -3,9 +3,9 @@ */ // OpenCV Headers -#include "opencv2/core/core.hpp" -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/highgui/highgui.hpp" +#include "opencv2/core.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/highgui.hpp" // C++ Standard Libraries #include @@ -159,8 +159,8 @@ int main( int argc, char* argv[] ){ * Check input arguments */ if( argc < 3 ){ - cout << "usage: " << argv[0] << " " << endl; - return 1; + cout << "usage: " << argv[0] << " " << endl; + return -1; } // load the image (note that we don't have the projection information. You will diff --git a/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp b/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp index 558cb66d55..456286741e 100644 --- a/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp +++ b/samples/cpp/tutorial_code/introduction/display_image/display_image.cpp @@ -1,7 +1,7 @@ //! [includes] -#include +#include #include -#include +#include #include #include @@ -16,7 +16,7 @@ using namespace std; int main( int argc, char** argv ) { //! [load] - string imageName("../data/HappyFish.jpg"); // by default + String imageName( "../data/HappyFish.jpg" ); // by default if( argc > 1) { imageName = argv[1]; @@ -28,7 +28,7 @@ int main( int argc, char** argv ) //! [mat] //! [imread] - image = imread(imageName.c_str(), IMREAD_COLOR); // Read the file + image = imread( imageName, IMREAD_COLOR ); // Read the file //! [imread] if( image.empty() ) // Check for invalid input diff --git a/samples/cpp/tutorial_code/photo/decolorization/decolor.cpp b/samples/cpp/tutorial_code/photo/decolorization/decolor.cpp index 067bad1178..13c1b0c5f7 100644 --- a/samples/cpp/tutorial_code/photo/decolorization/decolor.cpp +++ b/samples/cpp/tutorial_code/photo/decolorization/decolor.cpp @@ -27,13 +27,13 @@ using namespace cv; int main(int argc, char *argv[]) { CV_Assert(argc == 2); - Mat I; - I = imread(argv[1]); + Mat src; + src = imread(argv[1], IMREAD_COLOR); - Mat gray = Mat(I.size(),CV_8UC1); - Mat color_boost = Mat(I.size(),CV_8UC3); + Mat gray = Mat(src.size(),CV_8UC1); + Mat color_boost = Mat(src.size(),CV_8UC3); - decolor(I,gray,color_boost); + decolor(src,gray,color_boost); imshow("grayscale",gray); imshow("color_boost",color_boost); waitKey(0); diff --git a/samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp b/samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp index f81204c88b..8a24ddb7e6 100644 --- a/samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp +++ b/samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp @@ -35,9 +35,9 @@ int main(int argc, char* argv[]) int num,type; - Mat I = imread(argv[1]); + Mat src = imread(argv[1], IMREAD_COLOR); - if(I.empty()) + if(src.empty()) { cout << "Image not found" << endl; exit(0); @@ -71,25 +71,25 @@ int main(int argc, char* argv[]) cin >> type; - edgePreservingFilter(I,img,type); + edgePreservingFilter(src,img,type); imshow("Edge Preserve Smoothing",img); } else if(num == 2) { - detailEnhance(I,img); + detailEnhance(src,img); imshow("Detail Enhanced",img); } else if(num == 3) { Mat img1; - pencilSketch(I,img1, img, 10 , 0.1f, 0.03f); + pencilSketch(src,img1, img, 10 , 0.1f, 0.03f); imshow("Pencil Sketch",img1); imshow("Color Pencil Sketch",img); } else if(num == 4) { - stylization(I,img); + stylization(src,img); imshow("Stylization",img); } waitKey(0); diff --git a/samples/cpp/tutorial_code/video/bg_sub.cpp b/samples/cpp/tutorial_code/video/bg_sub.cpp index d37c7bd0f9..94799f388b 100644 --- a/samples/cpp/tutorial_code/video/bg_sub.cpp +++ b/samples/cpp/tutorial_code/video/bg_sub.cpp @@ -38,9 +38,9 @@ void help() << " OpenCV. You can process both videos (-vid) and images (-img)." << endl << endl << "Usage:" << endl - << "./bs {-vid