generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Completely separate C and C++ API of OpenCV core

Browse Source
This commit is contained in:
Andrey Kamaev
2013-03-29 12:59:55 +04:00
parent 715fa3303e
commit 2b1ef95415
46 changed files with 201 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
modules/core/include/opencv2/core.hpp
View File

@@ -46,21 +46,25 @@
#ifndef __OPENCV_CORE_HPP__
#define __OPENCV_CORE_HPP__
#ifndef __cplusplus
# error core.hpp header must be compiled as C++
#endif
#include "opencv2/core/cvdef.h"
#include "opencv2/core/version.hpp"
#ifdef __cplusplus
// Used by FileStorage
typedef struct CvFileStorage CvFileStorage;
struct CvFileNode;
struct CvSeq;
struct CvSeqBlock;
#include "opencv2/core/base.hpp"
#include "opencv2/core/cvstd.hpp"
#include "opencv2/core/traits.hpp"
#include "opencv2/core/matx.hpp"
#include "opencv2/core/types.hpp"
#include "opencv2/core/mat.hpp"
#endif
#include "opencv2/core/types_c.h"
#ifdef __cplusplus
#ifndef SKIP_INCLUDES
#include <limits.h>
@@ -215,11 +219,6 @@ CV_EXPORTS BinaryFunc getCopyMaskFunc(size_t esz);
//! swaps two matrices
CV_EXPORTS void swap(Mat& a, Mat& b);
//! extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
CV_EXPORTS void extractImageCOI(const CvArr* arr, OutputArray coiimg, int coi=-1);
//! inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
CV_EXPORTS void insertImageCOI(InputArray coiimg, CvArr* arr, int coi=-1);
//! adds one matrix to another (dst = src1 + src2)
CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst,
InputArray mask=noArray(), int dtype=-1);
@@ -1583,9 +1582,21 @@ public:
FileNodeIterator& readRaw( const String& fmt, uchar* vec,
size_t maxCount=(size_t)INT_MAX );
struct SeqReader
{
int header_size;
CvSeq* seq; /* sequence, beign read */
CvSeqBlock* block; /* current block */
schar* ptr; /* pointer to element be read next */
schar* block_min; /* pointer to the beginning of block */
schar* block_max; /* pointer to the end of block */
int delta_index;/* = seq->first->start_index */
schar* prev_elem; /* pointer to previous element */
};
const CvFileStorage* fs;
const CvFileNode* container;
CvSeqReader reader;
SeqReader reader;
size_t remaining;
};
@@ -1873,10 +1884,6 @@ template<> struct ParamType<uchar>
#include "opencv2/core/operations.hpp"
#include "opencv2/core/mat.inl.hpp"
#include "opencv2/core/cvstd.inl.hpp"
#endif // __cplusplus
#endif /*__OPENCV_CORE_HPP__*/

4
modules/core/include/opencv2/core/base.hpp
View File

@@ -44,6 +44,10 @@
#ifndef __OPENCV_CORE_BASE_HPP__
#define __OPENCV_CORE_BASE_HPP__
#ifndef __cplusplus
# error base.hpp header must be compiled as C++
#endif
#include <climits>
#include "opencv2/core/cvdef.h"

24
modules/core/include/opencv2/core/core_c.h
View File

@@ -1842,12 +1842,32 @@ struct CV_EXPORTS CvType
static CvTypeInfo* last;
};
#include "opencv2/core.hpp"
#include "opencv2/core/utility.hpp"
namespace cv
{
//// specializied implementations of Ptr::delete_obj() for classic OpenCV types
/////////////////////////////////////////// glue ///////////////////////////////////////////
//! converts array (CvMat or IplImage) to cv::Mat
CV_EXPORTS Mat cvarrToMat(const CvArr* arr, bool copyData=false,
bool allowND=true, int coiMode=0,
AutoBuffer<double>* buf=0);
static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMode=0)
{
return cvarrToMat(arr, copyData, true, coiMode);
}
//! extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
CV_EXPORTS void extractImageCOI(const CvArr* arr, OutputArray coiimg, int coi=-1);
//! inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
CV_EXPORTS void insertImageCOI(InputArray coiimg, CvArr* arr, int coi=-1);
//////// specializied implementations of Ptr::delete_obj() for classic OpenCV types ////////
template<> CV_EXPORTS void Ptr<CvMat>::delete_obj();
template<> CV_EXPORTS void Ptr<IplImage>::delete_obj();

8
modules/core/include/opencv2/core/cvdef.h
View File

@@ -335,6 +335,14 @@ typedef signed char schar;
# include <math.h>
#endif
#ifndef MIN
# define MIN(a,b) ((a) > (b) ? (b) : (a))
#endif
#ifndef MAX
# define MAX(a,b) ((a) < (b) ? (b) : (a))
#endif
#ifdef HAVE_TEGRA_OPTIMIZATION
# include "tegra_round.hpp"
#endif

4
modules/core/include/opencv2/core/mat.hpp
View File

@@ -44,6 +44,10 @@
#ifndef __OPENCV_CORE_MAT_HPP__
#define __OPENCV_CORE_MAT_HPP__
#ifndef __cplusplus
# error mat.hpp header must be compiled as C++
#endif
#include "opencv2/core/matx.hpp"
#include "opencv2/core/types.hpp"

7
modules/core/include/opencv2/core/mat.inl.hpp
View File

@@ -43,13 +43,15 @@
#ifndef __OPENCV_CORE_MATRIX_OPERATIONS_HPP__
#define __OPENCV_CORE_MATRIX_OPERATIONS_HPP__
#ifndef __cplusplus
# error mat.inl.hpp header must be compiled as C++
#endif
#ifndef SKIP_INCLUDES
#include <limits.h>
#include <string.h>
#endif // SKIP_INCLUDES
#ifdef __cplusplus
namespace cv
{
@@ -2588,4 +2590,3 @@ SparseMatIterator_<_Tp>::operator ++(int)
}
#endif
#endif

4
modules/core/include/opencv2/core/matx.hpp
View File

@@ -44,6 +44,10 @@
#ifndef __OPENCV_CORE_MATX_HPP__
#define __OPENCV_CORE_MATX_HPP__
#ifndef __cplusplus
# error matx.hpp header must be compiled as C++
#endif
#include "opencv2/core/cvdef.h"
#include "opencv2/core/base.hpp"
#include "opencv2/core/traits.hpp"

87
modules/core/include/opencv2/core/operations.hpp
View File

@@ -43,14 +43,16 @@
#ifndef __OPENCV_CORE_OPERATIONS_HPP__
#define __OPENCV_CORE_OPERATIONS_HPP__
#ifndef __cplusplus
# error operations.hpp header must be compiled as C++
#endif
#ifndef SKIP_INCLUDES
#include <string.h>
#include <limits.h>
#endif // SKIP_INCLUDES
#ifdef __cplusplus
#include <limits>
#ifdef _MSC_VER
@@ -330,8 +332,8 @@ public:
dst[i] = src[i];
}
operator CvMat() const
{ return cvMat((int)size(), 1, type(), (void*)hdr.data); }
// operator CvMat() const
// { return cvMat((int)size(), 1, type(), (void*)hdr.data); }
_Tp& operator [] (size_t i) { CV_DbgAssert( i < size() ); return hdr.data[i]; }
const _Tp& operator [] (size_t i) const { CV_DbgAssert( i < size() ); return hdr.data[i]; }
@@ -453,7 +455,7 @@ inline RNG::RNG() { state = 0xffffffff; }
inline RNG::RNG(uint64 _state) { state = _state ? _state : 0xffffffff; }
inline unsigned RNG::next()
{
state = (uint64)(unsigned)state*CV_RNG_COEFF + (unsigned)(state >> 32);
state = (uint64)(unsigned)state* /*CV_RNG_COEFF*/ 4164903690U + (unsigned)(state >> 32);
return (unsigned)state;
}
@@ -597,14 +599,14 @@ public:
template<typename _Tp> inline void write(FileStorage& fs, const String& name, const Point_<_Tp>& pt )
{
WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
write(fs, pt.x);
write(fs, pt.y);
}
template<typename _Tp> inline void write(FileStorage& fs, const String& name, const Point3_<_Tp>& pt )
{
WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
write(fs, pt.x);
write(fs, pt.y);
write(fs, pt.z);
@@ -612,21 +614,21 @@ template<typename _Tp> inline void write(FileStorage& fs, const String& name, co
template<typename _Tp> inline void write(FileStorage& fs, const String& name, const Size_<_Tp>& sz )
{
WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
write(fs, sz.width);
write(fs, sz.height);
}
template<typename _Tp> inline void write(FileStorage& fs, const String& name, const Complex<_Tp>& c )
{
WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
write(fs, c.re);
write(fs, c.im);
}
template<typename _Tp> inline void write(FileStorage& fs, const String& name, const Rect_<_Tp>& r )
{
WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
write(fs, r.x);
write(fs, r.y);
write(fs, r.width);
@@ -635,14 +637,14 @@ template<typename _Tp> inline void write(FileStorage& fs, const String& name, co
template<typename _Tp, int cn> inline void write(FileStorage& fs, const String& name, const Vec<_Tp, cn>& v )
{
WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
for(int i = 0; i < cn; i++)
write(fs, v.val[i]);
}
template<typename _Tp> inline void write(FileStorage& fs, const String& name, const Scalar_<_Tp>& s )
{
WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
write(fs, s.val[0]);
write(fs, s.val[1]);
write(fs, s.val[2]);
@@ -651,7 +653,7 @@ template<typename _Tp> inline void write(FileStorage& fs, const String& name, co
inline void write(FileStorage& fs, const String& name, const Range& r )
{
WriteStructContext ws(fs, name, CV_NODE_SEQ+CV_NODE_FLOW);
WriteStructContext ws(fs, name, FileNode::SEQ+FileNode::FLOW);
write(fs, r.start);
write(fs, r.end);
}
@@ -691,7 +693,7 @@ template<typename _Tp> static inline void write( FileStorage& fs, const std::vec
template<typename _Tp> static inline void write( FileStorage& fs, const String& name,
const std::vector<_Tp>& vec )
{
WriteStructContext ws(fs, name, CV_NODE_SEQ+(DataType<_Tp>::fmt != 0 ? CV_NODE_FLOW : 0));
WriteStructContext ws(fs, name, FileNode::SEQ+(DataType<_Tp>::fmt != 0 ? FileNode::FLOW : 0));
write(fs, vec);
}
@@ -703,7 +705,7 @@ template<typename _Tp> static inline FileStorage& operator << (FileStorage& fs,
if( !fs.isOpened() )
return fs;
if( fs.state == FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP )
CV_Error( CV_StsError, "No element name has been given" );
CV_Error( Error::StsError, "No element name has been given" );
write( fs, fs.elname, value );
if( fs.state & FileStorage::INSIDE_MAP )
fs.state = FileStorage::NAME_EXPECTED + FileStorage::INSIDE_MAP;
@@ -724,7 +726,6 @@ inline FileNode::FileNode(const CvFileStorage* _fs, const CvFileNode* _node)
inline FileNode::FileNode(const FileNode& _node) : fs(_node.fs), node(_node.node) {}
inline int FileNode::type() const { return !node ? NONE : (node->tag & TYPE_MASK); }
inline bool FileNode::empty() const { return node == 0; }
inline bool FileNode::isNone() const { return type() == NONE; }
inline bool FileNode::isSeq() const { return type() == SEQ; }
@@ -732,23 +733,19 @@ inline bool FileNode::isMap() const { return type() == MAP; }
inline bool FileNode::isInt() const { return type() == INT; }
inline bool FileNode::isReal() const { return type() == REAL; }
inline bool FileNode::isString() const { return type() == STR; }
inline bool FileNode::isNamed() const { return !node ? false : (node->tag & NAMED) != 0; }
inline size_t FileNode::size() const
{
int t = type();
return t == MAP ? (size_t)((CvSet*)node->data.map)->active_count :
t == SEQ ? (size_t)node->data.seq->total : (size_t)!isNone();
}
inline CvFileNode* FileNode::operator *() { return (CvFileNode*)node; }
inline const CvFileNode* FileNode::operator* () const { return node; }
static inline void read(const FileNode& node, int& value, int default_value)
{
value = !node.node ? default_value :
CV_NODE_IS_INT(node.node->tag) ? node.node->data.i :
CV_NODE_IS_REAL(node.node->tag) ? cvRound(node.node->data.f) : 0x7fffffff;
}
CV_EXPORTS void read(const FileNode& node, int& value, int default_value);
CV_EXPORTS void read(const FileNode& node, float& value, float default_value);
CV_EXPORTS void read(const FileNode& node, double& value, double default_value);
CV_EXPORTS void read(const FileNode& node, String& value, const String& default_value);
CV_EXPORTS void read(const FileNode& node, SparseMat& mat, const SparseMat& default_mat=SparseMat() );
CV_EXPORTS_W void read(const FileNode& node, Mat& mat, const Mat& default_mat=Mat() );
CV_EXPORTS void read(const FileNode& node, std::vector<KeyPoint>& keypoints);
CV_EXPORTS void write(FileStorage& fs, const String& objname, const std::vector<KeyPoint>& keypoints);
static inline void read(const FileNode& node, bool& value, bool default_value)
{
@@ -780,31 +777,6 @@ static inline void read(const FileNode& node, short& value, short default_value)
value = saturate_cast<short>(temp);
}
static inline void read(const FileNode& node, float& value, float default_value)
{
value = !node.node ? default_value :
CV_NODE_IS_INT(node.node->tag) ? (float)node.node->data.i :
CV_NODE_IS_REAL(node.node->tag) ? (float)node.node->data.f : 1e30f;
}
static inline void read(const FileNode& node, double& value, double default_value)
{
value = !node.node ? default_value :
CV_NODE_IS_INT(node.node->tag) ? (double)node.node->data.i :
CV_NODE_IS_REAL(node.node->tag) ? node.node->data.f : 1e300;
}
static inline void read(const FileNode& node, String& value, const String& default_value)
{
value = !node.node ? default_value : CV_NODE_IS_STRING(node.node->tag) ? String(node.node->data.str.ptr) : String();
}
CV_EXPORTS_W void read(const FileNode& node, Mat& mat, const Mat& default_mat=Mat() );
CV_EXPORTS void read(const FileNode& node, SparseMat& mat, const SparseMat& default_mat=SparseMat() );
CV_EXPORTS void read(const FileNode& node, std::vector<KeyPoint>& keypoints);
CV_EXPORTS void write(FileStorage& fs, const String& objname, const std::vector<KeyPoint>& keypoints);
inline FileNode::operator int() const
{
int value;
@@ -1022,7 +994,7 @@ partition( const std::vector<_Tp>& _vec, std::vector<int>& labels,
nodes[root2][RANK] += rank == rank2;
root = root2;
}
assert( nodes[root][PARENT] < 0 );
CV_Assert( nodes[root][PARENT] < 0 );
int k = j, parent;
@@ -1224,7 +1196,7 @@ inline void Algorithm::set(const char* _name, const Ptr<_Tp>& value)
{
Ptr<Algorithm> algo_ptr = value. template ptr<cv::Algorithm>();
if (algo_ptr.empty()) {
CV_Error( CV_StsUnsupportedFormat, "unknown/unsupported Ptr type of the second parameter of the method Algorithm::set");
CV_Error( Error::StsUnsupportedFormat, "unknown/unsupported Ptr type of the second parameter of the method Algorithm::set");
}
info()->set(this, _name, ParamType<Algorithm>::type, &algo_ptr);
}
@@ -1240,7 +1212,7 @@ inline void Algorithm::setAlgorithm(const char* _name, const Ptr<_Tp>& value)
{
Ptr<Algorithm> algo_ptr = value. template ptr<cv::Algorithm>();
if (algo_ptr.empty()) {
CV_Error( CV_StsUnsupportedFormat, "unknown/unsupported Ptr type of the second parameter of the method Algorithm::set");
CV_Error( Error::StsUnsupportedFormat, "unknown/unsupported Ptr type of the second parameter of the method Algorithm::set");
}
info()->set(this, _name, ParamType<Algorithm>::type, &algo_ptr);
}
@@ -1289,5 +1261,4 @@ template<typename _Tp> inline void AlgorithmInfo::addParam(Algorithm& algo, cons
# pragma warning(pop)
#endif
#endif // __cplusplus
#endif

4
modules/core/include/opencv2/core/types.hpp
View File

@@ -44,6 +44,10 @@
#ifndef __OPENCV_CORE_TYPES_HPP__
#define __OPENCV_CORE_TYPES_HPP__
#ifndef __cplusplus
# error types.hpp header must be compiled as C++
#endif
#include <climits>
#include <cfloat>
#include <vector>

17
modules/core/include/opencv2/core/types_c.h
View File

@@ -93,8 +93,7 @@
#endif
#ifdef __cplusplus
# include "opencv2/core/types.hpp"
# include "opencv2/core/mat.hpp"
# include "opencv2/core.hpp"
#endif
/* CvArr* is used to pass arbitrary
@@ -182,14 +181,6 @@ enum {
#define CV_SWAP(a,b,t) ((t) = (a), (a) = (b), (b) = (t))
#ifndef MIN
# define MIN(a,b) ((a) > (b) ? (b) : (a))
#endif
#ifndef MAX
# define MAX(a,b) ((a) < (b) ? (b) : (a))
#endif
/* min & max without jumps */
#define CV_IMIN(a, b) ((a) ^ (((a)^(b)) & (((a) < (b)) - 1)))
@@ -426,6 +417,7 @@ typedef struct CvMat
#ifdef __cplusplus
CvMat() {}
CvMat(const CvMat& m) { memcpy(this, &m, sizeof(CvMat));}
CvMat(const cv::Mat& m);
#endif
@@ -1465,12 +1457,15 @@ CvSeqWriter;
int delta_index;/* = seq->first->start_index */ \
schar* prev_elem; /* pointer to previous element */
#ifdef __cplusplus
typedef cv::FileNodeIterator::SeqReader CvSeqReader;
#else
typedef struct CvSeqReader
{
CV_SEQ_READER_FIELDS()
}
CvSeqReader;
#endif
/****************************************************************************************/
/* Operations on sequences */

19
modules/core/include/opencv2/core/utility.hpp
View File

@@ -44,6 +44,10 @@
#ifndef __OPENCV_CORE_UTILITY_H__
#define __OPENCV_CORE_UTILITY_H__
#ifndef __cplusplus
# error utility.hpp header must be compiled as C++
#endif
#include "opencv2/core.hpp"
namespace cv
@@ -126,7 +130,7 @@ protected:
*/
CV_EXPORTS bool setBreakOnError(bool flag);
typedef int (CV_CDECL *ErrorCallback)( int status, const char* func_name,
extern "C" typedef int (*ErrorCallback)( int status, const char* func_name,
const char* err_msg, const char* file_name,
int line, void* userdata );
@@ -144,7 +148,7 @@ typedef int (CV_CDECL *ErrorCallback)( int status, const char* func_name,
CV_EXPORTS ErrorCallback redirectError( ErrorCallback errCallback, void* userdata=0, void** prevUserdata=0);
CV_EXPORTS String format( const char* fmt, ... );
CV_EXPORTS String tempfile( const char* suffix CV_DEFAULT(0));
CV_EXPORTS String tempfile( const char* suffix = 0);
CV_EXPORTS void glob(String pattern, std::vector<String>& result, bool recursive = false);
CV_EXPORTS void setNumThreads(int nthreads);
CV_EXPORTS int getNumThreads();
@@ -443,17 +447,6 @@ template<typename _Tp, size_t fixed_size> inline
AutoBuffer<_Tp, fixed_size>::operator const _Tp* () const
{ return ptr; }
// TODO: move them to core_c.h
//! converts array (CvMat or IplImage) to cv::Mat
CV_EXPORTS Mat cvarrToMat(const CvArr* arr, bool copyData=false,
bool allowND=true, int coiMode=0,
AutoBuffer<double>* buf=0);
static inline Mat cvarrToMatND(const CvArr* arr, bool copyData=false, int coiMode=0)
{
return cvarrToMat(arr, copyData, true, coiMode);
}
#ifndef OPENCV_NOSTL
template<> inline std::string CommandLineParser::get<std::string>(int index, bool space_delete) const
{