#define __CVCOMMON_H_
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "cxcore.h"
#include "cv.h"
* Measure performance of classifier
*/
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "cv.h"
#include "highgui.h"
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "HOGfeatures.h"
#include "cascadeclassifier.h"
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "boost.h"
#include "cascadeclassifier.h"
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "cascadeclassifier.h"
#include <queue>
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "traincascade_features.h"
#include "cascadeclassifier.h"
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "haarfeatures.h"
#include "cascadeclassifier.h"
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "cv.h"
#include "imagestorage.h"
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "lbpfeatures.h"
#include "cascadeclassifier.h"
#include "opencv2/core.hpp"
-#include "opencv2/core/internal.hpp"
#include "cv.h"
#include "cascadeclassifier.h"
//CV_WARNING("This is a deprecated opencv header provided for compatibility. Please include a header from a corresponding opencv module")
#include "opencv2/core/core_c.h"
-#include "opencv2/core.hpp"
-#include "opencv2/core/utility.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/imgproc.hpp"
#include "opencv2/video.hpp"
#define CV_IMPL extern "C"
#endif //CV_IMPL
-#if defined(__cplusplus)
-#include "opencv2/core/internal.hpp"
-#endif //__cplusplus
-
#endif // __OPENCV_OLD_CV_H_
//#warning "This is a deprecated opencv header provided for compatibility. Please include a header from a corresponding opencv module"
//#endif
-#include <cv.h>
+#include "cv.h"
+#include "opencv2/core.hpp"
#endif
//#endif
#include "opencv2/core/core_c.h"
-#include "opencv2/core.hpp"
#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/imgproc.hpp"
#include "opencv2/video.hpp"
//#warning "This is a deprecated opencv header provided for compatibility. Please include a header from a corresponding opencv module"
//#endif
-#include <cvaux.h>
+#include "cvaux.h"
+#include "opencv2/core/utility.hpp"
#endif
//#endif
#include "opencv2/core/core_c.h"
-#include "opencv2/core.hpp"
#endif
//#warning "This is a deprecated opencv header provided for compatibility. Please include a header from a corresponding opencv module"
//#endif
-#include <cxcore.h>
+#include "cxcore.h"
+#include "opencv2/core.hpp"
#endif
#define __OPENCV_OLD_HIGHGUI_H__
#include "opencv2/core/core_c.h"
-#include "opencv2/core.hpp"
#include "opencv2/highgui/highgui_c.h"
#include "opencv2/highgui.hpp"
#define __OPENCV_OLD_ML_H__
#include "opencv2/core/core_c.h"
-#include "opencv2/core.hpp"
#include "opencv2/ml.hpp"
#endif
#ifndef __OPENCV_ALL_HPP__
#define __OPENCV_ALL_HPP__
-#include "opencv2/core/core_c.h"
#include "opencv2/core.hpp"
#include "opencv2/flann/miniflann.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/imgproc.hpp"
#include "opencv2/photo.hpp"
#include "opencv2/video.hpp"
#include "opencv2/objdetect.hpp"
#include "opencv2/calib3d.hpp"
#include "opencv2/ml.hpp"
-#include "opencv2/highgui/highgui_c.h"
#include "opencv2/highgui.hpp"
#include "opencv2/contrib.hpp"
#ifndef __OPENCV_CALIB3D_HPP__
#define __OPENCV_CALIB3D_HPP__
-#include "opencv2/core.hpp"
+#ifdef __cplusplus
+# include "opencv2/core.hpp"
+#endif
+#include "opencv2/core/core_c.h"
#include "opencv2/features2d.hpp"
#ifdef __cplusplus
__P = cvCreateMat(3,4,CV_64F);
if (matP)
{
- cvTsConvert(matP,__P);
+ cvtest::convert(cvarrToMat(matP), cvarrToMat(__P), -1);
}
else
{
__P->data.db[4] = 1;
__P->data.db[8] = 1;
}
- CvMat* __R = cvCreateMat(3,3,CV_64F);;
+ CvMat* __R = cvCreateMat(3,3,CV_64F);
if (matR)
{
cvCopy(matR,__R);
CvMat _input3 = test_mat[INPUT][3];
CvMat _input4 = test_mat[INPUT][4];
- cvTsConvert(&_input1,&_camera);
- cvTsConvert(&_input2,&_distort);
- cvTsConvert(&_input3,&_rot);
- cvTsConvert(&_input4,&_new_cam);
+ cvtest::convert(cvarrToMat(&_input1), cvarrToMat(&_camera), -1);
+ cvtest::convert(cvarrToMat(&_input2), cvarrToMat(&_distort), -1);
+ cvtest::convert(cvarrToMat(&_input3), cvarrToMat(&_rot), -1);
+ cvtest::convert(cvarrToMat(&_input4), cvarrToMat(&_new_cam), -1);
//Applying precalculated undistort rectify map
if (!useCPlus)
zero_distortion ? 0 : &_distort, zero_R ? 0 : &_rot, zero_new_cam ? &_camera : &_new_cam);
//cvTsDistortPoints(&_points,&ref_points,&_camera,&_distort,&_rot,&_new_cam);
CvMat dst = test_mat[REF_OUTPUT][0];
- cvTsConvert(&ref_points,&dst);
+ cvtest::convert(cvarrToMat(&ref_points), cvarrToMat(&dst), -1);
cvtest::copy(test_mat[INPUT][0],test_mat[OUTPUT][0]);
#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>
//! 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);
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;
};
#include "opencv2/core/operations.hpp"
#include "opencv2/core/mat.inl.hpp"
-
#include "opencv2/core/cvstd.inl.hpp"
-#endif // __cplusplus
-
-
#endif /*__OPENCV_CORE_HPP__*/
#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"
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();
# 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
#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"
#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
{
}
#endif
-#endif
#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"
#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
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]; }
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;
}
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);
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);
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]);
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);
}
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);
}
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;
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; }
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)
{
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;
nodes[root2][RANK] += rank == rank2;
root = root2;
}
- assert( nodes[root][PARENT] < 0 );
+ CV_Assert( nodes[root][PARENT] < 0 );
int k = j, parent;
{
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);
}
{
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);
}
# pragma warning(pop)
#endif
-#endif // __cplusplus
#endif
#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>
#endif
#ifdef __cplusplus
-# include "opencv2/core/types.hpp"
-# include "opencv2/core/mat.hpp"
+# include "opencv2/core.hpp"
#endif
/* CvArr* is used to pass arbitrary
#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)))
#ifdef __cplusplus
CvMat() {}
+ CvMat(const CvMat& m) { memcpy(this, &m, sizeof(CvMat));}
CvMat(const cv::Mat& m);
#endif
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 */
#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
*/
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 );
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();
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
{
}
}
+int FileNode::type() const { return !node ? NONE : (node->tag & TYPE_MASK); }
+bool FileNode::isNamed() const { return !node ? false : (node->tag & NAMED) != 0; }
+
+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();
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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();
+}
+
}
/* End of file. */
#include "cvconfig.h"
#endif
-#include "opencv2/core.hpp"
#include "opencv2/core/utility.hpp"
#include "opencv2/core/core_c.h"
#include "opencv2/core/internal.hpp"
#ifndef __OPENCV_FEATURES_2D_HPP__
#define __OPENCV_FEATURES_2D_HPP__
-#include "opencv2/core.hpp"
#include "opencv2/flann/miniflann.hpp"
#ifdef __cplusplus
+#include "opencv2/core.hpp"
#include <limits>
namespace cv
#ifndef __OPENCV_HIGHGUI_HPP__
#define __OPENCV_HIGHGUI_HPP__
-#include "opencv2/core.hpp"
#include "opencv2/highgui/highgui_c.h"
#ifdef __cplusplus
+#include "opencv2/core.hpp"
struct CvCapture;
struct CvVideoWriter;
#ifndef __OPENCV_IMGPROC_HPP__
#define __OPENCV_IMGPROC_HPP__
-#include "opencv2/core.hpp"
#include "opencv2/imgproc/types_c.h"
#ifdef __cplusplus
+#include "opencv2/core.hpp"
+
/*! \namespace cv
Namespace where all the C++ OpenCV functionality resides
*/
if( CV_MAT_DEPTH(_img->type) == CV_8U || CV_MAT_DEPTH(_img->type) == CV_32S )
{
tmp = cvCreateMat( rows, cols, CV_MAKETYPE(CV_32F,CV_MAT_CN(_img->type)) );
- cvTsConvert(_img, tmp);
+ cvtest::convert(cvarrToMat(_img), cvarrToMat(tmp), -1);
}
mask = cvCreateMat( rows + 2, cols + 2, CV_16UC1 );
if( _mask )
- cvTsConvert( _mask, mask );
+ cvtest::convert(cvarrToMat(_mask), cvarrToMat(mask), -1);
else
{
- cvTsZero( mask );
+ Mat m_mask = cvarrToMat(mask);
+ cvtest::set( m_mask, Scalar::all(0), Mat() );
cvRectangle( mask, cvPoint(0,0), cvPoint(mask->cols-1,mask->rows-1), Scalar::all(1.), 1, 8, 0 );
}
if( tmp != _img )
{
if( !mask_only )
- cvTsConvert(tmp, _img);
+ cvtest::convert(cvarrToMat(tmp), cvarrToMat(_img), -1);
cvReleaseMat( &tmp );
}
name = name + "BRISK";
break;
default:
- CV_Error( CV_StsBadArg, "Specified feature detector type is not supported." );
+ CV_Error( Error::StsBadArg, "Specified feature detector type is not supported." );
break;
}
name = "BruteForce-SL2";
break;
default:
- CV_Error( CV_StsBadArg, "Specified descriptor matcher type is not supported." );
+ CV_Error( Error::StsBadArg, "Specified descriptor matcher type is not supported." );
break;
}
name = name + "FREAK";
break;
default:
- CV_Error( CV_StsBadArg, "Specified descriptor extractor type is not supported." );
+ CV_Error( Error::StsBadArg, "Specified descriptor extractor type is not supported." );
break;
}
name = "FERN";
break;
default:
- CV_Error( CV_StsBadArg, "Specified generic descriptor matcher type is not supported." );
+ CV_Error( Error::StsBadArg, "Specified generic descriptor matcher type is not supported." );
break;
}
#ifndef __OPENCV_ML_HPP__
#define __OPENCV_ML_HPP__
-#include "opencv2/core.hpp"
+#ifdef __cplusplus
+# include "opencv2/core.hpp"
+#endif
+
+#include "opencv2/core/core_c.h"
#include <limits.h>
#ifdef __cplusplus
#ifndef __OPENCV_OBJDETECT_HPP__
#define __OPENCV_OBJDETECT_HPP__
-#include "opencv2/core.hpp"
+#ifdef __cplusplus
+# include "opencv2/core.hpp"
+#endif
+#include "opencv2/core/core_c.h"
#ifdef __cplusplus
#include <map>
CV_EXPORTS void multiply(const Mat& a, const Mat& b, Mat& c, double alpha=1);
CV_EXPORTS void divide(const Mat& a, const Mat& b, Mat& c, double alpha=1);
-CV_EXPORTS void convert(const Mat& src, Mat& dst, int dtype, double alpha=1, double beta=0);
+CV_EXPORTS void convert(const Mat& src, cv::OutputArray dst, int dtype, double alpha=1, double beta=0);
CV_EXPORTS void copy(const Mat& src, Mat& dst, const Mat& mask=Mat(), bool invertMask=false);
CV_EXPORTS void set(Mat& dst, const Scalar& gamma, const Mat& mask=Mat());
CV_EXPORTS void transpose(const Mat& src, Mat& dst);
CV_EXPORTS void erode(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
- int borderType=IPL_BORDER_CONSTANT, const Scalar& borderValue=Scalar());
+ int borderType=0, const Scalar& borderValue=Scalar());
CV_EXPORTS void dilate(const Mat& src, Mat& dst, const Mat& _kernel, Point anchor=Point(-1,-1),
- int borderType=IPL_BORDER_CONSTANT, const Scalar& borderValue=Scalar());
+ int borderType=0, const Scalar& borderValue=Scalar());
CV_EXPORTS void filter2D(const Mat& src, Mat& dst, int ddepth, const Mat& kernel,
Point anchor, double delta, int borderType,
const Scalar& borderValue=Scalar());
} //namespace cvtest
-// fills c with zeros
-CV_EXPORTS void cvTsZero( CvMat* c, const CvMat* mask=0 );
-
-// copies a to b (whole matrix or only the selected region)
-CV_EXPORTS void cvTsCopy( const CvMat* a, CvMat* b, const CvMat* mask=0 );
-
-// converts one array to another
-CV_EXPORTS void cvTsConvert( const CvMat* src, CvMat* dst );
-
-CV_EXPORTS void cvTsGEMM( const CvMat* a, const CvMat* b, double alpha,
- const CvMat* c, double beta, CvMat* d, int flags );
-
#define CV_TEST_MAIN(resourcesubdir) \
int main(int argc, char **argv) \
{ \
}
}
-void convert(const Mat& src, Mat& dst, int dtype, double alpha, double beta)
+void convert(const Mat& src, cv::OutputArray _dst, int dtype, double alpha, double beta)
{
+ if (dtype < 0) dtype = _dst.depth();
+
dtype = CV_MAKETYPE(CV_MAT_DEPTH(dtype), src.channels());
- dst.create(src.dims, &src.size[0], dtype);
+ _dst.create(src.dims, &src.size[0], dtype);
+ Mat dst = _dst.getMat();
if( alpha == 0 )
{
set( dst, Scalar::all(beta) );
}
}
-
-void cvTsConvert( const CvMat* src, CvMat* dst )
-{
- Mat _src = cvarrToMat(src), _dst = cvarrToMat(dst);
- cvtest::convert(_src, _dst, _dst.depth());
-}
-
-void cvTsZero( CvMat* dst, const CvMat* mask )
-{
- Mat _dst = cvarrToMat(dst), _mask = mask ? cvarrToMat(mask) : Mat();
- cvtest::set(_dst, Scalar::all(0), _mask);
-}
#ifndef __OPENCV_TRACKING_HPP__
#define __OPENCV_TRACKING_HPP__
-#include "opencv2/core.hpp"
+#ifdef __cplusplus
+# include "opencv2/core.hpp"
+#endif
#include "opencv2/imgproc.hpp"
#ifdef __cplusplus
#include <opencv2/core.hpp>
#include <opencv2/core/utility.hpp>
-#include <opencv2/core/internal.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/objdetect.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/core/utility.hpp>"
+#include <opencv2/core/utility.hpp>
using namespace cv; // The new C++ interface API is inside this namespace. Import it.
using namespace std;