OpenCV453
mat.hpp
1/*M///////////////////////////////////////////////////////////////////////////////////////
2//
3// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4//
5// By downloading, copying, installing or using the software you agree to this license.
6// If you do not agree to this license, do not download, install,
7// copy or use the software.
8//
9//
10// License Agreement
11// For Open Source Computer Vision Library
12//
13// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
14// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
15// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
16// Third party copyrights are property of their respective owners.
17//
18// Redistribution and use in source and binary forms, with or without modification,
19// are permitted provided that the following conditions are met:
20//
21// * Redistribution's of source code must retain the above copyright notice,
22// this list of conditions and the following disclaimer.
23//
24// * Redistribution's in binary form must reproduce the above copyright notice,
25// this list of conditions and the following disclaimer in the documentation
26// and/or other materials provided with the distribution.
27//
28// * The name of the copyright holders may not be used to endorse or promote products
29// derived from this software without specific prior written permission.
30//
31// This software is provided by the copyright holders and contributors "as is" and
32// any express or implied warranties, including, but not limited to, the implied
33// warranties of merchantability and fitness for a particular purpose are disclaimed.
34// In no event shall the Intel Corporation or contributors be liable for any direct,
35// indirect, incidental, special, exemplary, or consequential damages
36// (including, but not limited to, procurement of substitute goods or services;
37// loss of use, data, or profits; or business interruption) however caused
38// and on any theory of liability, whether in contract, strict liability,
39// or tort (including negligence or otherwise) arising in any way out of
40// the use of this software, even if advised of the possibility of such damage.
41//
42//M*/
43
44#ifndef OPENCV_CORE_MAT_HPP
45#define OPENCV_CORE_MAT_HPP
46
47#ifndef __cplusplus
48# error mat.hpp header must be compiled as C++
49#endif
50
51#include "opencv2/core/matx.hpp"
52#include "opencv2/core/types.hpp"
53
54#include "opencv2/core/bufferpool.hpp"
55
56#include <type_traits>
57
58namespace cv
59{
60
63
64enum AccessFlag { ACCESS_READ=1<<24, ACCESS_WRITE=1<<25,
65 ACCESS_RW=3<<24, ACCESS_MASK=ACCESS_RW, ACCESS_FAST=1<<26 };
66CV_ENUM_FLAGS(AccessFlag)
67__CV_ENUM_FLAGS_BITWISE_AND(AccessFlag, int, AccessFlag)
68
69CV__DEBUG_NS_BEGIN
70
71class CV_EXPORTS _OutputArray;
72
74
158class CV_EXPORTS _InputArray
159{
160public:
161 enum KindFlag {
162 KIND_SHIFT = 16,
163 FIXED_TYPE = 0x8000 << KIND_SHIFT,
164 FIXED_SIZE = 0x4000 << KIND_SHIFT,
165 KIND_MASK = 31 << KIND_SHIFT,
166
167 NONE = 0 << KIND_SHIFT,
168 MAT = 1 << KIND_SHIFT,
169 MATX = 2 << KIND_SHIFT,
170 STD_VECTOR = 3 << KIND_SHIFT,
171 STD_VECTOR_VECTOR = 4 << KIND_SHIFT,
172 STD_VECTOR_MAT = 5 << KIND_SHIFT,
173#if OPENCV_ABI_COMPATIBILITY < 500
174 EXPR = 6 << KIND_SHIFT,
175#endif
176 OPENGL_BUFFER = 7 << KIND_SHIFT,
177 CUDA_HOST_MEM = 8 << KIND_SHIFT,
178 CUDA_GPU_MAT = 9 << KIND_SHIFT,
179 UMAT =10 << KIND_SHIFT,
180 STD_VECTOR_UMAT =11 << KIND_SHIFT,
181 STD_BOOL_VECTOR =12 << KIND_SHIFT,
182 STD_VECTOR_CUDA_GPU_MAT = 13 << KIND_SHIFT,
183#if OPENCV_ABI_COMPATIBILITY < 500
184 STD_ARRAY =14 << KIND_SHIFT,
185#endif
186 STD_ARRAY_MAT =15 << KIND_SHIFT
187 };
188
189 _InputArray();
190 _InputArray(int _flags, void* _obj);
191 _InputArray(const Mat& m);
192 _InputArray(const MatExpr& expr);
193 _InputArray(const std::vector<Mat>& vec);
194 template<typename _Tp> _InputArray(const Mat_<_Tp>& m);
195 template<typename _Tp> _InputArray(const std::vector<_Tp>& vec);
196 _InputArray(const std::vector<bool>& vec);
197 template<typename _Tp> _InputArray(const std::vector<std::vector<_Tp> >& vec);
198 _InputArray(const std::vector<std::vector<bool> >&) = delete; // not supported
199 template<typename _Tp> _InputArray(const std::vector<Mat_<_Tp> >& vec);
200 template<typename _Tp> _InputArray(const _Tp* vec, int n);
201 template<typename _Tp, int m, int n> _InputArray(const Matx<_Tp, m, n>& matx);
202 _InputArray(const double& val);
203 _InputArray(const cuda::GpuMat& d_mat);
204 _InputArray(const std::vector<cuda::GpuMat>& d_mat_array);
205 _InputArray(const ogl::Buffer& buf);
206 _InputArray(const cuda::HostMem& cuda_mem);
207 template<typename _Tp> _InputArray(const cudev::GpuMat_<_Tp>& m);
208 _InputArray(const UMat& um);
209 _InputArray(const std::vector<UMat>& umv);
210
211 template<typename _Tp, std::size_t _Nm> _InputArray(const std::array<_Tp, _Nm>& arr);
212 template<std::size_t _Nm> _InputArray(const std::array<Mat, _Nm>& arr);
213
214 template<typename _Tp> static _InputArray rawIn(const std::vector<_Tp>& vec);
215 template<typename _Tp, std::size_t _Nm> static _InputArray rawIn(const std::array<_Tp, _Nm>& arr);
216
217 Mat getMat(int idx=-1) const;
218 Mat getMat_(int idx=-1) const;
219 UMat getUMat(int idx=-1) const;
220 void getMatVector(std::vector<Mat>& mv) const;
221 void getUMatVector(std::vector<UMat>& umv) const;
222 void getGpuMatVector(std::vector<cuda::GpuMat>& gpumv) const;
223 cuda::GpuMat getGpuMat() const;
224 ogl::Buffer getOGlBuffer() const;
225
226 int getFlags() const;
227 void* getObj() const;
228 Size getSz() const;
229
230 _InputArray::KindFlag kind() const;
231 int dims(int i=-1) const;
232 int cols(int i=-1) const;
233 int rows(int i=-1) const;
234 Size size(int i=-1) const;
235 int sizend(int* sz, int i=-1) const;
236 bool sameSize(const _InputArray& arr) const;
237 size_t total(int i=-1) const;
238 int type(int i=-1) const;
239 int depth(int i=-1) const;
240 int channels(int i=-1) const;
241 bool isContinuous(int i=-1) const;
242 bool isSubmatrix(int i=-1) const;
243 bool empty() const;
244 void copyTo(const _OutputArray& arr) const;
245 void copyTo(const _OutputArray& arr, const _InputArray & mask) const;
246 size_t offset(int i=-1) const;
247 size_t step(int i=-1) const;
248 bool isMat() const;
249 bool isUMat() const;
250 bool isMatVector() const;
251 bool isUMatVector() const;
252 bool isMatx() const;
253 bool isVector() const;
254 bool isGpuMat() const;
255 bool isGpuMatVector() const;
256 ~_InputArray();
257
258protected:
259 int flags;
260 void* obj;
261 Size sz;
262
263 void init(int _flags, const void* _obj);
264 void init(int _flags, const void* _obj, Size _sz);
265};
266CV_ENUM_FLAGS(_InputArray::KindFlag)
267__CV_ENUM_FLAGS_BITWISE_AND(_InputArray::KindFlag, int, _InputArray::KindFlag)
268
269
294class CV_EXPORTS _OutputArray : public _InputArray
295{
296public:
297 enum DepthMask
298 {
299 DEPTH_MASK_8U = 1 << CV_8U,
300 DEPTH_MASK_8S = 1 << CV_8S,
301 DEPTH_MASK_16U = 1 << CV_16U,
302 DEPTH_MASK_16S = 1 << CV_16S,
303 DEPTH_MASK_32S = 1 << CV_32S,
304 DEPTH_MASK_32F = 1 << CV_32F,
305 DEPTH_MASK_64F = 1 << CV_64F,
306 DEPTH_MASK_16F = 1 << CV_16F,
307 DEPTH_MASK_ALL = (DEPTH_MASK_64F<<1)-1,
308 DEPTH_MASK_ALL_BUT_8S = DEPTH_MASK_ALL & ~DEPTH_MASK_8S,
309 DEPTH_MASK_ALL_16F = (DEPTH_MASK_16F<<1)-1,
310 DEPTH_MASK_FLT = DEPTH_MASK_32F + DEPTH_MASK_64F
311 };
312
313 _OutputArray();
314 _OutputArray(int _flags, void* _obj);
315 _OutputArray(Mat& m);
316 _OutputArray(std::vector<Mat>& vec);
317 _OutputArray(cuda::GpuMat& d_mat);
318 _OutputArray(std::vector<cuda::GpuMat>& d_mat);
319 _OutputArray(ogl::Buffer& buf);
320 _OutputArray(cuda::HostMem& cuda_mem);
321 template<typename _Tp> _OutputArray(cudev::GpuMat_<_Tp>& m);
322 template<typename _Tp> _OutputArray(std::vector<_Tp>& vec);
323 _OutputArray(std::vector<bool>& vec) = delete; // not supported
324 template<typename _Tp> _OutputArray(std::vector<std::vector<_Tp> >& vec);
325 _OutputArray(std::vector<std::vector<bool> >&) = delete; // not supported
326 template<typename _Tp> _OutputArray(std::vector<Mat_<_Tp> >& vec);
327 template<typename _Tp> _OutputArray(Mat_<_Tp>& m);
328 template<typename _Tp> _OutputArray(_Tp* vec, int n);
329 template<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
330 _OutputArray(UMat& m);
331 _OutputArray(std::vector<UMat>& vec);
332
333 _OutputArray(const Mat& m);
334 _OutputArray(const std::vector<Mat>& vec);
335 _OutputArray(const cuda::GpuMat& d_mat);
336 _OutputArray(const std::vector<cuda::GpuMat>& d_mat);
337 _OutputArray(const ogl::Buffer& buf);
338 _OutputArray(const cuda::HostMem& cuda_mem);
339 template<typename _Tp> _OutputArray(const cudev::GpuMat_<_Tp>& m);
340 template<typename _Tp> _OutputArray(const std::vector<_Tp>& vec);
341 template<typename _Tp> _OutputArray(const std::vector<std::vector<_Tp> >& vec);
342 template<typename _Tp> _OutputArray(const std::vector<Mat_<_Tp> >& vec);
343 template<typename _Tp> _OutputArray(const Mat_<_Tp>& m);
344 template<typename _Tp> _OutputArray(const _Tp* vec, int n);
345 template<typename _Tp, int m, int n> _OutputArray(const Matx<_Tp, m, n>& matx);
346 _OutputArray(const UMat& m);
347 _OutputArray(const std::vector<UMat>& vec);
348
349 template<typename _Tp, std::size_t _Nm> _OutputArray(std::array<_Tp, _Nm>& arr);
350 template<typename _Tp, std::size_t _Nm> _OutputArray(const std::array<_Tp, _Nm>& arr);
351 template<std::size_t _Nm> _OutputArray(std::array<Mat, _Nm>& arr);
352 template<std::size_t _Nm> _OutputArray(const std::array<Mat, _Nm>& arr);
353
354 template<typename _Tp> static _OutputArray rawOut(std::vector<_Tp>& vec);
355 template<typename _Tp, std::size_t _Nm> static _OutputArray rawOut(std::array<_Tp, _Nm>& arr);
356
357 bool fixedSize() const;
358 bool fixedType() const;
359 bool needed() const;
360 Mat& getMatRef(int i=-1) const;
361 UMat& getUMatRef(int i=-1) const;
362 cuda::GpuMat& getGpuMatRef() const;
363 std::vector<cuda::GpuMat>& getGpuMatVecRef() const;
364 ogl::Buffer& getOGlBufferRef() const;
365 cuda::HostMem& getHostMemRef() const;
366 void create(Size sz, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast<_OutputArray::DepthMask>(0)) const;
367 void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast<_OutputArray::DepthMask>(0)) const;
368 void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, _OutputArray::DepthMask fixedDepthMask=static_cast<_OutputArray::DepthMask>(0)) const;
369 void createSameSize(const _InputArray& arr, int mtype) const;
370 void release() const;
371 void clear() const;
372 void setTo(const _InputArray& value, const _InputArray & mask = _InputArray()) const;
373
374 void assign(const UMat& u) const;
375 void assign(const Mat& m) const;
376
377 void assign(const std::vector<UMat>& v) const;
378 void assign(const std::vector<Mat>& v) const;
379
380 void move(UMat& u) const;
381 void move(Mat& m) const;
382};
383
384
385class CV_EXPORTS _InputOutputArray : public _OutputArray
386{
387public:
388 _InputOutputArray();
389 _InputOutputArray(int _flags, void* _obj);
390 _InputOutputArray(Mat& m);
391 _InputOutputArray(std::vector<Mat>& vec);
392 _InputOutputArray(cuda::GpuMat& d_mat);
393 _InputOutputArray(ogl::Buffer& buf);
394 _InputOutputArray(cuda::HostMem& cuda_mem);
395 template<typename _Tp> _InputOutputArray(cudev::GpuMat_<_Tp>& m);
396 template<typename _Tp> _InputOutputArray(std::vector<_Tp>& vec);
397 _InputOutputArray(std::vector<bool>& vec) = delete; // not supported
398 template<typename _Tp> _InputOutputArray(std::vector<std::vector<_Tp> >& vec);
399 template<typename _Tp> _InputOutputArray(std::vector<Mat_<_Tp> >& vec);
400 template<typename _Tp> _InputOutputArray(Mat_<_Tp>& m);
401 template<typename _Tp> _InputOutputArray(_Tp* vec, int n);
402 template<typename _Tp, int m, int n> _InputOutputArray(Matx<_Tp, m, n>& matx);
403 _InputOutputArray(UMat& m);
404 _InputOutputArray(std::vector<UMat>& vec);
405
406 _InputOutputArray(const Mat& m);
407 _InputOutputArray(const std::vector<Mat>& vec);
408 _InputOutputArray(const cuda::GpuMat& d_mat);
409 _InputOutputArray(const std::vector<cuda::GpuMat>& d_mat);
410 _InputOutputArray(const ogl::Buffer& buf);
411 _InputOutputArray(const cuda::HostMem& cuda_mem);
412 template<typename _Tp> _InputOutputArray(const cudev::GpuMat_<_Tp>& m);
413 template<typename _Tp> _InputOutputArray(const std::vector<_Tp>& vec);
414 template<typename _Tp> _InputOutputArray(const std::vector<std::vector<_Tp> >& vec);
415 template<typename _Tp> _InputOutputArray(const std::vector<Mat_<_Tp> >& vec);
416 template<typename _Tp> _InputOutputArray(const Mat_<_Tp>& m);
417 template<typename _Tp> _InputOutputArray(const _Tp* vec, int n);
418 template<typename _Tp, int m, int n> _InputOutputArray(const Matx<_Tp, m, n>& matx);
419 _InputOutputArray(const UMat& m);
420 _InputOutputArray(const std::vector<UMat>& vec);
421
422 template<typename _Tp, std::size_t _Nm> _InputOutputArray(std::array<_Tp, _Nm>& arr);
423 template<typename _Tp, std::size_t _Nm> _InputOutputArray(const std::array<_Tp, _Nm>& arr);
424 template<std::size_t _Nm> _InputOutputArray(std::array<Mat, _Nm>& arr);
425 template<std::size_t _Nm> _InputOutputArray(const std::array<Mat, _Nm>& arr);
426
427 template<typename _Tp> static _InputOutputArray rawInOut(std::vector<_Tp>& vec);
428 template<typename _Tp, std::size_t _Nm> _InputOutputArray rawInOut(std::array<_Tp, _Nm>& arr);
429
430};
431
433template<typename _Tp> static inline _InputArray rawIn(_Tp& v);
435template<typename _Tp> static inline _OutputArray rawOut(_Tp& v);
437template<typename _Tp> static inline _InputOutputArray rawInOut(_Tp& v);
438
439CV__DEBUG_NS_END
440
441typedef const _InputArray& InputArray;
442typedef InputArray InputArrayOfArrays;
443typedef const _OutputArray& OutputArray;
444typedef OutputArray OutputArrayOfArrays;
445typedef const _InputOutputArray& InputOutputArray;
446typedef InputOutputArray InputOutputArrayOfArrays;
447
448CV_EXPORTS InputOutputArray noArray();
449
451
453enum UMatUsageFlags
454{
455 USAGE_DEFAULT = 0,
456
457 // buffer allocation policy is platform and usage specific
458 USAGE_ALLOCATE_HOST_MEMORY = 1 << 0,
459 USAGE_ALLOCATE_DEVICE_MEMORY = 1 << 1,
460 USAGE_ALLOCATE_SHARED_MEMORY = 1 << 2, // It is not equal to: USAGE_ALLOCATE_HOST_MEMORY | USAGE_ALLOCATE_DEVICE_MEMORY
461
462 __UMAT_USAGE_FLAGS_32BIT = 0x7fffffff // Binary compatibility hint
463};
464
465struct CV_EXPORTS UMatData;
466
469class CV_EXPORTS MatAllocator
470{
471public:
472 MatAllocator() {}
473 virtual ~MatAllocator() {}
474
475 // let's comment it off for now to detect and fix all the uses of allocator
476 //virtual void allocate(int dims, const int* sizes, int type, int*& refcount,
477 // uchar*& datastart, uchar*& data, size_t* step) = 0;
478 //virtual void deallocate(int* refcount, uchar* datastart, uchar* data) = 0;
479 virtual UMatData* allocate(int dims, const int* sizes, int type,
480 void* data, size_t* step, AccessFlag flags, UMatUsageFlags usageFlags) const = 0;
481 virtual bool allocate(UMatData* data, AccessFlag accessflags, UMatUsageFlags usageFlags) const = 0;
482 virtual void deallocate(UMatData* data) const = 0;
483 virtual void map(UMatData* data, AccessFlag accessflags) const;
484 virtual void unmap(UMatData* data) const;
485 virtual void download(UMatData* data, void* dst, int dims, const size_t sz[],
486 const size_t srcofs[], const size_t srcstep[],
487 const size_t dststep[]) const;
488 virtual void upload(UMatData* data, const void* src, int dims, const size_t sz[],
489 const size_t dstofs[], const size_t dststep[],
490 const size_t srcstep[]) const;
491 virtual void copy(UMatData* srcdata, UMatData* dstdata, int dims, const size_t sz[],
492 const size_t srcofs[], const size_t srcstep[],
493 const size_t dstofs[], const size_t dststep[], bool sync) const;
494
495 // default implementation returns DummyBufferPoolController
496 virtual BufferPoolController* getBufferPoolController(const char* id = NULL) const;
497};
498
499
501
514template<typename _Tp> class MatCommaInitializer_
515{
516public:
518 MatCommaInitializer_(Mat_<_Tp>* _m);
520 template<typename T2> MatCommaInitializer_<_Tp>& operator , (T2 v);
522 operator Mat_<_Tp>() const;
523protected:
524 MatIterator_<_Tp> it;
525};
526
527
529
530// note that umatdata might be allocated together
531// with the matrix data, not as a separate object.
532// therefore, it does not have constructor or destructor;
533// it should be explicitly initialized using init().
534struct CV_EXPORTS UMatData
535{
536 enum MemoryFlag { COPY_ON_MAP=1, HOST_COPY_OBSOLETE=2,
537 DEVICE_COPY_OBSOLETE=4, TEMP_UMAT=8, TEMP_COPIED_UMAT=24,
538 USER_ALLOCATED=32, DEVICE_MEM_MAPPED=64,
539 ASYNC_CLEANUP=128
540 };
541 UMatData(const MatAllocator* allocator);
542 ~UMatData();
543
544 // provide atomic access to the structure
545 void lock();
546 void unlock();
547
548 bool hostCopyObsolete() const;
549 bool deviceCopyObsolete() const;
550 bool deviceMemMapped() const;
551 bool copyOnMap() const;
552 bool tempUMat() const;
553 bool tempCopiedUMat() const;
554 void markHostCopyObsolete(bool flag);
555 void markDeviceCopyObsolete(bool flag);
556 void markDeviceMemMapped(bool flag);
557
558 const MatAllocator* prevAllocator;
559 const MatAllocator* currAllocator;
560 int urefcount;
561 int refcount;
562 uchar* data;
563 uchar* origdata;
564 size_t size;
565
566 UMatData::MemoryFlag flags;
567 void* handle;
568 void* userdata;
569 int allocatorFlags_;
570 int mapcount;
571 UMatData* originalUMatData;
572 std::shared_ptr<void> allocatorContext;
573};
574CV_ENUM_FLAGS(UMatData::MemoryFlag)
575
576
577struct CV_EXPORTS MatSize
578{
579 explicit MatSize(int* _p) CV_NOEXCEPT;
580 int dims() const CV_NOEXCEPT;
581 Size operator()() const;
582 const int& operator[](int i) const;
583 int& operator[](int i);
584 operator const int*() const CV_NOEXCEPT; // TODO OpenCV 4.0: drop this
585 bool operator == (const MatSize& sz) const CV_NOEXCEPT;
586 bool operator != (const MatSize& sz) const CV_NOEXCEPT;
587
588 int* p;
589};
590
591struct CV_EXPORTS MatStep
592{
593 MatStep() CV_NOEXCEPT;
594 explicit MatStep(size_t s) CV_NOEXCEPT;
595 const size_t& operator[](int i) const CV_NOEXCEPT;
596 size_t& operator[](int i) CV_NOEXCEPT;
597 operator size_t() const;
598 MatStep& operator = (size_t s);
599
600 size_t* p;
601 size_t buf[2];
602protected:
603 MatStep& operator = (const MatStep&);
604};
605
801class CV_EXPORTS Mat
802{
803public:
810 Mat() CV_NOEXCEPT;
811
818 Mat(int rows, int cols, int type);
819
826 Mat(Size size, int type);
827
837 Mat(int rows, int cols, int type, const Scalar& s);
838
848 Mat(Size size, int type, const Scalar& s);
849
856 Mat(int ndims, const int* sizes, int type);
857
863 Mat(const std::vector<int>& sizes, int type);
864
874 Mat(int ndims, const int* sizes, int type, const Scalar& s);
875
884 Mat(const std::vector<int>& sizes, int type, const Scalar& s);
885
886
894 Mat(const Mat& m);
895
910 Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
911
926 Mat(Size size, int type, void* data, size_t step=AUTO_STEP);
927
941 Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0);
942
955 Mat(const std::vector<int>& sizes, int type, void* data, const size_t* steps=0);
956
967 Mat(const Mat& m, const Range& rowRange, const Range& colRange=Range::all());
968
977 Mat(const Mat& m, const Rect& roi);
978
987 Mat(const Mat& m, const Range* ranges);
988
997 Mat(const Mat& m, const std::vector<Range>& ranges);
998
1015 template<typename _Tp> explicit Mat(const std::vector<_Tp>& vec, bool copyData=false);
1016
1019 template<typename _Tp, typename = typename std::enable_if<std::is_arithmetic<_Tp>::value>::type>
1020 explicit Mat(const std::initializer_list<_Tp> list);
1021
1024 template<typename _Tp> explicit Mat(const std::initializer_list<int> sizes, const std::initializer_list<_Tp> list);
1025
1028 template<typename _Tp, size_t _Nm> explicit Mat(const std::array<_Tp, _Nm>& arr, bool copyData=false);
1029
1032 template<typename _Tp, int n> explicit Mat(const Vec<_Tp, n>& vec, bool copyData=true);
1033
1036 template<typename _Tp, int m, int n> explicit Mat(const Matx<_Tp, m, n>& mtx, bool copyData=true);
1037
1040 template<typename _Tp> explicit Mat(const Point_<_Tp>& pt, bool copyData=true);
1041
1044 template<typename _Tp> explicit Mat(const Point3_<_Tp>& pt, bool copyData=true);
1045
1048 template<typename _Tp> explicit Mat(const MatCommaInitializer_<_Tp>& commaInitializer);
1049
1051 explicit Mat(const cuda::GpuMat& m);
1052
1054 ~Mat();
1055
1064 Mat& operator = (const Mat& m);
1065
1073 Mat& operator = (const MatExpr& expr);
1074
1076 UMat getUMat(AccessFlag accessFlags, UMatUsageFlags usageFlags = USAGE_DEFAULT) const;
1077
1111 Mat row(int y) const;
1112
1120 Mat col(int x) const;
1121
1129 Mat rowRange(int startrow, int endrow) const;
1130
1134 Mat rowRange(const Range& r) const;
1135
1143 Mat colRange(int startcol, int endcol) const;
1144
1148 Mat colRange(const Range& r) const;
1149
1184 Mat diag(int d=0) const;
1185
1191 static Mat diag(const Mat& d);
1192
1198 Mat clone() const CV_NODISCARD;
1199
1215 void copyTo( OutputArray m ) const;
1216
1223 void copyTo( OutputArray m, InputArray mask ) const;
1224
1238 void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
1239
1246 void assignTo( Mat& m, int type=-1 ) const;
1247
1251 Mat& operator = (const Scalar& s);
1252
1260 Mat& setTo(InputArray value, InputArray mask=noArray());
1261
1286 Mat reshape(int cn, int rows=0) const;
1287
1289 Mat reshape(int cn, int newndims, const int* newsz) const;
1290
1292 Mat reshape(int cn, const std::vector<int>& newshape) const;
1293
1304 MatExpr t() const;
1305
1313 MatExpr inv(int method=DECOMP_LU) const;
1314
1327 MatExpr mul(InputArray m, double scale=1) const;
1328
1336 Mat cross(InputArray m) const;
1337
1346 double dot(InputArray m) const;
1347
1362 static MatExpr zeros(int rows, int cols, int type);
1363
1368 static MatExpr zeros(Size size, int type);
1369
1375 static MatExpr zeros(int ndims, const int* sz, int type);
1376
1393 static MatExpr ones(int rows, int cols, int type);
1394
1399 static MatExpr ones(Size size, int type);
1400
1406 static MatExpr ones(int ndims, const int* sz, int type);
1407
1422 static MatExpr eye(int rows, int cols, int type);
1423
1428 static MatExpr eye(Size size, int type);
1429
1463 void create(int rows, int cols, int type);
1464
1469 void create(Size size, int type);
1470
1476 void create(int ndims, const int* sizes, int type);
1477
1482 void create(const std::vector<int>& sizes, int type);
1483
1493 void addref();
1494
1508 void release();
1509
1511 void deallocate();
1513 void copySize(const Mat& m);
1514
1522 void reserve(size_t sz);
1523
1530 void reserveBuffer(size_t sz);
1531
1539 void resize(size_t sz);
1540
1545 void resize(size_t sz, const Scalar& s);
1546
1548 void push_back_(const void* elem);
1549
1557 template<typename _Tp> void push_back(const _Tp& elem);
1558
1562 template<typename _Tp> void push_back(const Mat_<_Tp>& elem);
1563
1567 template<typename _Tp> void push_back(const std::vector<_Tp>& elem);
1568
1572 void push_back(const Mat& m);
1573
1580 void pop_back(size_t nelems=1);
1581
1593 void locateROI( Size& wholeSize, Point& ofs ) const;
1594
1622 Mat& adjustROI( int dtop, int dbottom, int dleft, int dright );
1623
1635 Mat operator()( Range rowRange, Range colRange ) const;
1636
1640 Mat operator()( const Rect& roi ) const;
1641
1645 Mat operator()( const Range* ranges ) const;
1646
1650 Mat operator()(const std::vector<Range>& ranges) const;
1651
1652 template<typename _Tp> operator std::vector<_Tp>() const;
1653 template<typename _Tp, int n> operator Vec<_Tp, n>() const;
1654 template<typename _Tp, int m, int n> operator Matx<_Tp, m, n>() const;
1655
1656 template<typename _Tp, std::size_t _Nm> operator std::array<_Tp, _Nm>() const;
1657
1732 bool isContinuous() const;
1733
1735 bool isSubmatrix() const;
1736
1742 size_t elemSize() const;
1743
1749 size_t elemSize1() const;
1750
1756 int type() const;
1757
1771 int depth() const;
1772
1777 int channels() const;
1778
1784 size_t step1(int i=0) const;
1785
1791 bool empty() const;
1792
1798 size_t total() const;
1799
1804 size_t total(int startDim, int endDim=INT_MAX) const;
1805
1827 int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
1828
1835 uchar* ptr(int i0=0);
1837 const uchar* ptr(int i0=0) const;
1838
1843 uchar* ptr(int row, int col);
1848 const uchar* ptr(int row, int col) const;
1849
1851 uchar* ptr(int i0, int i1, int i2);
1853 const uchar* ptr(int i0, int i1, int i2) const;
1854
1856 uchar* ptr(const int* idx);
1858 const uchar* ptr(const int* idx) const;
1860 template<int n> uchar* ptr(const Vec<int, n>& idx);
1862 template<int n> const uchar* ptr(const Vec<int, n>& idx) const;
1863
1865 template<typename _Tp> _Tp* ptr(int i0=0);
1867 template<typename _Tp> const _Tp* ptr(int i0=0) const;
1872 template<typename _Tp> _Tp* ptr(int row, int col);
1877 template<typename _Tp> const _Tp* ptr(int row, int col) const;
1879 template<typename _Tp> _Tp* ptr(int i0, int i1, int i2);
1881 template<typename _Tp> const _Tp* ptr(int i0, int i1, int i2) const;
1883 template<typename _Tp> _Tp* ptr(const int* idx);
1885 template<typename _Tp> const _Tp* ptr(const int* idx) const;
1887 template<typename _Tp, int n> _Tp* ptr(const Vec<int, n>& idx);
1889 template<typename _Tp, int n> const _Tp* ptr(const Vec<int, n>& idx) const;
1890
1921 template<typename _Tp> _Tp& at(int i0=0);
1925 template<typename _Tp> const _Tp& at(int i0=0) const;
1930 template<typename _Tp> _Tp& at(int row, int col);
1935 template<typename _Tp> const _Tp& at(int row, int col) const;
1936
1942 template<typename _Tp> _Tp& at(int i0, int i1, int i2);
1948 template<typename _Tp> const _Tp& at(int i0, int i1, int i2) const;
1949
1953 template<typename _Tp> _Tp& at(const int* idx);
1957 template<typename _Tp> const _Tp& at(const int* idx) const;
1958
1960 template<typename _Tp, int n> _Tp& at(const Vec<int, n>& idx);
1962 template<typename _Tp, int n> const _Tp& at(const Vec<int, n>& idx) const;
1963
1968 template<typename _Tp> _Tp& at(Point pt);
1973 template<typename _Tp> const _Tp& at(Point pt) const;
1974
2011 template<typename _Tp> MatIterator_<_Tp> begin();
2012 template<typename _Tp> MatConstIterator_<_Tp> begin() const;
2013
2016 template<typename _Tp> std::reverse_iterator<MatIterator_<_Tp>> rbegin();
2017 template<typename _Tp> std::reverse_iterator<MatConstIterator_<_Tp>> rbegin() const;
2018
2024 template<typename _Tp> MatIterator_<_Tp> end();
2025 template<typename _Tp> MatConstIterator_<_Tp> end() const;
2026
2029 template<typename _Tp> std::reverse_iterator< MatIterator_<_Tp>> rend();
2030 template<typename _Tp> std::reverse_iterator< MatConstIterator_<_Tp>> rend() const;
2031
2032
2087 template<typename _Tp, typename Functor> void forEach(const Functor& operation);
2089 template<typename _Tp, typename Functor> void forEach(const Functor& operation) const;
2090
2091 Mat(Mat&& m);
2092 Mat& operator = (Mat&& m);
2093
2094 enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
2095 enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
2096
2103 int flags;
2105 int dims;
2107 int rows, cols;
2109 uchar* data;
2110
2112 const uchar* datastart;
2113 const uchar* dataend;
2114 const uchar* datalimit;
2115
2117 MatAllocator* allocator;
2119 static MatAllocator* getStdAllocator();
2120 static MatAllocator* getDefaultAllocator();
2121 static void setDefaultAllocator(MatAllocator* allocator);
2122
2124 void updateContinuityFlag();
2125
2127 UMatData* u;
2128
2129 MatSize size;
2130 MatStep step;
2131
2132protected:
2133 template<typename _Tp, typename Functor> void forEach_impl(const Functor& operation);
2134};
2135
2136
2138
2198template<typename _Tp> class Mat_ : public Mat
2199{
2200public:
2201 typedef _Tp value_type;
2202 typedef typename DataType<_Tp>::channel_type channel_type;
2203 typedef MatIterator_<_Tp> iterator;
2204 typedef MatConstIterator_<_Tp> const_iterator;
2205
2207 Mat_() CV_NOEXCEPT;
2209 Mat_(int _rows, int _cols);
2211 Mat_(int _rows, int _cols, const _Tp& value);
2213 explicit Mat_(Size _size);
2215 Mat_(Size _size, const _Tp& value);
2217 Mat_(int _ndims, const int* _sizes);
2219 Mat_(int _ndims, const int* _sizes, const _Tp& value);
2221 Mat_(const Mat& m);
2223 Mat_(const Mat_& m);
2225 Mat_(int _rows, int _cols, _Tp* _data, size_t _step=AUTO_STEP);
2227 Mat_(int _ndims, const int* _sizes, _Tp* _data, const size_t* _steps=0);
2229 Mat_(const Mat_& m, const Range& rowRange, const Range& colRange=Range::all());
2231 Mat_(const Mat_& m, const Rect& roi);
2233 Mat_(const Mat_& m, const Range* ranges);
2235 Mat_(const Mat_& m, const std::vector<Range>& ranges);
2237 explicit Mat_(const MatExpr& e);
2239 explicit Mat_(const std::vector<_Tp>& vec, bool copyData=false);
2240 template<int n> explicit Mat_(const Vec<typename DataType<_Tp>::channel_type, n>& vec, bool copyData=true);
2241 template<int m, int n> explicit Mat_(const Matx<typename DataType<_Tp>::channel_type, m, n>& mtx, bool copyData=true);
2242 explicit Mat_(const Point_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
2243 explicit Mat_(const Point3_<typename DataType<_Tp>::channel_type>& pt, bool copyData=true);
2244 explicit Mat_(const MatCommaInitializer_<_Tp>& commaInitializer);
2245
2246 Mat_(std::initializer_list<_Tp> values);
2247 explicit Mat_(const std::initializer_list<int> sizes, const std::initializer_list<_Tp> values);
2248
2249 template <std::size_t _Nm> explicit Mat_(const std::array<_Tp, _Nm>& arr, bool copyData=false);
2250
2251 Mat_& operator = (const Mat& m);
2252 Mat_& operator = (const Mat_& m);
2254 Mat_& operator = (const _Tp& s);
2256 Mat_& operator = (const MatExpr& e);
2257
2259 iterator begin();
2260 iterator end();
2261 const_iterator begin() const;
2262 const_iterator end() const;
2263
2264 //reverse iterators
2265 std::reverse_iterator<iterator> rbegin();
2266 std::reverse_iterator<iterator> rend();
2267 std::reverse_iterator<const_iterator> rbegin() const;
2268 std::reverse_iterator<const_iterator> rend() const;
2269
2271 // the operations take care of skipping gaps in the end of rows (if any)
2272 template<typename Functor> void forEach(const Functor& operation);
2273 template<typename Functor> void forEach(const Functor& operation) const;
2274
2276 void create(int _rows, int _cols);
2278 void create(Size _size);
2280 void create(int _ndims, const int* _sizes);
2282 void release();
2284 Mat_ cross(const Mat_& m) const;
2286 template<typename T2> operator Mat_<T2>() const;
2288 Mat_ row(int y) const;
2289 Mat_ col(int x) const;
2290 Mat_ diag(int d=0) const;
2291 Mat_ clone() const CV_NODISCARD;
2292
2294 size_t elemSize() const;
2295 size_t elemSize1() const;
2296 int type() const;
2297 int depth() const;
2298 int channels() const;
2299 size_t step1(int i=0) const;
2301 size_t stepT(int i=0) const;
2302
2304 static MatExpr zeros(int rows, int cols);
2305 static MatExpr zeros(Size size);
2306 static MatExpr zeros(int _ndims, const int* _sizes);
2307 static MatExpr ones(int rows, int cols);
2308 static MatExpr ones(Size size);
2309 static MatExpr ones(int _ndims, const int* _sizes);
2310 static MatExpr eye(int rows, int cols);
2311 static MatExpr eye(Size size);
2312
2314 Mat_& adjustROI( int dtop, int dbottom, int dleft, int dright );
2315 Mat_ operator()( const Range& rowRange, const Range& colRange ) const;
2316 Mat_ operator()( const Rect& roi ) const;
2317 Mat_ operator()( const Range* ranges ) const;
2318 Mat_ operator()(const std::vector<Range>& ranges) const;
2319
2321 _Tp* operator [](int y);
2322 const _Tp* operator [](int y) const;
2323
2325 _Tp& operator ()(const int* idx);
2327 const _Tp& operator ()(const int* idx) const;
2328
2330 template<int n> _Tp& operator ()(const Vec<int, n>& idx);
2332 template<int n> const _Tp& operator ()(const Vec<int, n>& idx) const;
2333
2335 _Tp& operator ()(int idx0);
2337 const _Tp& operator ()(int idx0) const;
2339 _Tp& operator ()(int row, int col);
2341 const _Tp& operator ()(int row, int col) const;
2343 _Tp& operator ()(int idx0, int idx1, int idx2);
2345 const _Tp& operator ()(int idx0, int idx1, int idx2) const;
2346
2347 _Tp& operator ()(Point pt);
2348 const _Tp& operator ()(Point pt) const;
2349
2351 operator std::vector<_Tp>() const;
2352
2354 template<std::size_t _Nm> operator std::array<_Tp, _Nm>() const;
2355
2357 template<int n> operator Vec<typename DataType<_Tp>::channel_type, n>() const;
2359 template<int m, int n> operator Matx<typename DataType<_Tp>::channel_type, m, n>() const;
2360
2361 Mat_(Mat_&& m);
2362 Mat_& operator = (Mat_&& m);
2363
2364 Mat_(Mat&& m);
2365 Mat_& operator = (Mat&& m);
2366
2367 Mat_(MatExpr&& e);
2368};
2369
2370typedef Mat_<uchar> Mat1b;
2371typedef Mat_<Vec2b> Mat2b;
2372typedef Mat_<Vec3b> Mat3b;
2373typedef Mat_<Vec4b> Mat4b;
2374
2375typedef Mat_<short> Mat1s;
2376typedef Mat_<Vec2s> Mat2s;
2377typedef Mat_<Vec3s> Mat3s;
2378typedef Mat_<Vec4s> Mat4s;
2379
2380typedef Mat_<ushort> Mat1w;
2381typedef Mat_<Vec2w> Mat2w;
2382typedef Mat_<Vec3w> Mat3w;
2383typedef Mat_<Vec4w> Mat4w;
2384
2385typedef Mat_<int> Mat1i;
2386typedef Mat_<Vec2i> Mat2i;
2387typedef Mat_<Vec3i> Mat3i;
2388typedef Mat_<Vec4i> Mat4i;
2389
2390typedef Mat_<float> Mat1f;
2391typedef Mat_<Vec2f> Mat2f;
2392typedef Mat_<Vec3f> Mat3f;
2393typedef Mat_<Vec4f> Mat4f;
2394
2395typedef Mat_<double> Mat1d;
2396typedef Mat_<Vec2d> Mat2d;
2397typedef Mat_<Vec3d> Mat3d;
2398typedef Mat_<Vec4d> Mat4d;
2399
2401class CV_EXPORTS UMat
2402{
2403public:
2405 UMat(UMatUsageFlags usageFlags = USAGE_DEFAULT) CV_NOEXCEPT;
2407 // (_type is CV_8UC1, CV_64FC3, CV_32SC(12) etc.)
2408 UMat(int rows, int cols, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2409 UMat(Size size, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2411 UMat(int rows, int cols, int type, const Scalar& s, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2412 UMat(Size size, int type, const Scalar& s, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2413
2415 UMat(int ndims, const int* sizes, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2416 UMat(int ndims, const int* sizes, int type, const Scalar& s, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2417
2419 UMat(const UMat& m);
2420
2422 UMat(const UMat& m, const Range& rowRange, const Range& colRange=Range::all());
2423 UMat(const UMat& m, const Rect& roi);
2424 UMat(const UMat& m, const Range* ranges);
2425 UMat(const UMat& m, const std::vector<Range>& ranges);
2426
2427 // FIXIT copyData=false is not implemented, drop this in favor of cv::Mat (OpenCV 5.0)
2429 template<typename _Tp> explicit UMat(const std::vector<_Tp>& vec, bool copyData=false);
2430
2432 ~UMat();
2434 UMat& operator = (const UMat& m);
2435
2436 Mat getMat(AccessFlag flags) const;
2437
2439 UMat row(int y) const;
2441 UMat col(int x) const;
2443 UMat rowRange(int startrow, int endrow) const;
2444 UMat rowRange(const Range& r) const;
2446 UMat colRange(int startcol, int endcol) const;
2447 UMat colRange(const Range& r) const;
2452 UMat diag(int d=0) const;
2454 static UMat diag(const UMat& d, UMatUsageFlags usageFlags /*= USAGE_DEFAULT*/);
2455 static UMat diag(const UMat& d) { return diag(d, USAGE_DEFAULT); } // OpenCV 5.0: remove abi compatibility overload
2456
2458 UMat clone() const CV_NODISCARD;
2460 // It calls m.create(this->size(), this->type()).
2461 void copyTo( OutputArray m ) const;
2463 void copyTo( OutputArray m, InputArray mask ) const;
2465 void convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const;
2466
2467 void assignTo( UMat& m, int type=-1 ) const;
2468
2470 UMat& operator = (const Scalar& s);
2472 UMat& setTo(InputArray value, InputArray mask=noArray());
2474 // number of channels and/or different number of rows. see cvReshape.
2475 UMat reshape(int cn, int rows=0) const;
2476 UMat reshape(int cn, int newndims, const int* newsz) const;
2477
2479 UMat t() const;
2481 UMat inv(int method=DECOMP_LU) const;
2483 UMat mul(InputArray m, double scale=1) const;
2484
2486 double dot(InputArray m) const;
2487
2489 static UMat zeros(int rows, int cols, int type, UMatUsageFlags usageFlags /*= USAGE_DEFAULT*/);
2490 static UMat zeros(Size size, int type, UMatUsageFlags usageFlags /*= USAGE_DEFAULT*/);
2491 static UMat zeros(int ndims, const int* sz, int type, UMatUsageFlags usageFlags /*= USAGE_DEFAULT*/);
2492 static UMat zeros(int rows, int cols, int type) { return zeros(rows, cols, type, USAGE_DEFAULT); } // OpenCV 5.0: remove abi compatibility overload
2493 static UMat zeros(Size size, int type) { return zeros(size, type, USAGE_DEFAULT); } // OpenCV 5.0: remove abi compatibility overload
2494 static UMat zeros(int ndims, const int* sz, int type) { return zeros(ndims, sz, type, USAGE_DEFAULT); } // OpenCV 5.0: remove abi compatibility overload
2495 static UMat ones(int rows, int cols, int type, UMatUsageFlags usageFlags /*= USAGE_DEFAULT*/);
2496 static UMat ones(Size size, int type, UMatUsageFlags usageFlags /*= USAGE_DEFAULT*/);
2497 static UMat ones(int ndims, const int* sz, int type, UMatUsageFlags usageFlags /*= USAGE_DEFAULT*/);
2498 static UMat ones(int rows, int cols, int type) { return ones(rows, cols, type, USAGE_DEFAULT); } // OpenCV 5.0: remove abi compatibility overload
2499 static UMat ones(Size size, int type) { return ones(size, type, USAGE_DEFAULT); } // OpenCV 5.0: remove abi compatibility overload
2500 static UMat ones(int ndims, const int* sz, int type) { return ones(ndims, sz, type, USAGE_DEFAULT); } // OpenCV 5.0: remove abi compatibility overload
2501 static UMat eye(int rows, int cols, int type, UMatUsageFlags usageFlags /*= USAGE_DEFAULT*/);
2502 static UMat eye(Size size, int type, UMatUsageFlags usageFlags /*= USAGE_DEFAULT*/);
2503 static UMat eye(int rows, int cols, int type) { return eye(rows, cols, type, USAGE_DEFAULT); } // OpenCV 5.0: remove abi compatibility overload
2504 static UMat eye(Size size, int type) { return eye(size, type, USAGE_DEFAULT); } // OpenCV 5.0: remove abi compatibility overload
2505
2507 // previous data is unreferenced if needed.
2508 void create(int rows, int cols, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2509 void create(Size size, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2510 void create(int ndims, const int* sizes, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2511 void create(const std::vector<int>& sizes, int type, UMatUsageFlags usageFlags = USAGE_DEFAULT);
2512
2514 void addref();
2516 // deallocates the data when reference counter reaches 0.
2517 void release();
2518
2520 void deallocate();
2522 void copySize(const UMat& m);
2523
2525 void locateROI( Size& wholeSize, Point& ofs ) const;
2527 UMat& adjustROI( int dtop, int dbottom, int dleft, int dright );
2529 // (this is a generalized form of row, rowRange etc.)
2530 UMat operator()( Range rowRange, Range colRange ) const;
2531 UMat operator()( const Rect& roi ) const;
2532 UMat operator()( const Range* ranges ) const;
2533 UMat operator()(const std::vector<Range>& ranges) const;
2534
2536 // (i.e. when there are no gaps between successive rows).
2537 // similar to CV_IS_MAT_CONT(cvmat->type)
2538 bool isContinuous() const;
2539
2541 bool isSubmatrix() const;
2542
2544 // similar to CV_ELEM_SIZE(cvmat->type)
2545 size_t elemSize() const;
2547 size_t elemSize1() const;
2549 int type() const;
2551 int depth() const;
2553 int channels() const;
2555 size_t step1(int i=0) const;
2557 bool empty() const;
2559 size_t total() const;
2560
2562 int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const;
2563
2564 UMat(UMat&& m);
2565 UMat& operator = (UMat&& m);
2566
2571 void* handle(AccessFlag accessFlags) const;
2572 void ndoffset(size_t* ofs) const;
2573
2574 enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG };
2575 enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 };
2576
2583 int flags;
2584
2586 int dims;
2587
2589 int rows;
2590
2592 int cols;
2593
2595 MatAllocator* allocator;
2596
2598 UMatUsageFlags usageFlags;
2599
2601 static MatAllocator* getStdAllocator();
2602
2604 void updateContinuityFlag();
2605
2607 UMatData* u;
2608
2610 size_t offset;
2611
2613 MatSize size;
2614
2616 MatStep step;
2617
2618protected:
2619};
2620
2621
2623
2703class CV_EXPORTS SparseMat
2704{
2705public:
2706 typedef SparseMatIterator iterator;
2707 typedef SparseMatConstIterator const_iterator;
2708
2709 enum { MAGIC_VAL=0x42FD0000, MAX_DIM=32, HASH_SCALE=0x5bd1e995, HASH_BIT=0x80000000 };
2710
2712 struct CV_EXPORTS Hdr
2713 {
2714 Hdr(int _dims, const int* _sizes, int _type);
2715 void clear();
2716 int refcount;
2717 int dims;
2718 int valueOffset;
2719 size_t nodeSize;
2720 size_t nodeCount;
2721 size_t freeList;
2722 std::vector<uchar> pool;
2723 std::vector<size_t> hashtab;
2724 int size[MAX_DIM];
2725 };
2726
2728 struct CV_EXPORTS Node
2729 {
2731 size_t hashval;
2733 size_t next;
2735 int idx[MAX_DIM];
2736 };
2737
2740 SparseMat();
2741
2747 SparseMat(int dims, const int* _sizes, int _type);
2748
2753 SparseMat(const SparseMat& m);
2754
2759 explicit SparseMat(const Mat& m);
2760
2762 ~SparseMat();
2763
2765 SparseMat& operator = (const SparseMat& m);
2767 SparseMat& operator = (const Mat& m);
2768
2770 SparseMat clone() const CV_NODISCARD;
2771
2773 void copyTo( SparseMat& m ) const;
2775 void copyTo( Mat& m ) const;
2777 void convertTo( SparseMat& m, int rtype, double alpha=1 ) const;
2779
2788 void convertTo( Mat& m, int rtype, double alpha=1, double beta=0 ) const;
2789
2790 // not used now
2791 void assignTo( SparseMat& m, int type=-1 ) const;
2792
2794
2799 void create(int dims, const int* _sizes, int _type);
2801 void clear();
2803 void addref();
2804 // decrements the header reference counter. When the counter reaches 0, the header and all the underlying data are deallocated.
2805 void release();
2806
2808 //operator CvSparseMat*() const;
2810 size_t elemSize() const;
2812 size_t elemSize1() const;
2813
2815 int type() const;
2817 int depth() const;
2819 int channels() const;
2820
2822 const int* size() const;
2824 int size(int i) const;
2826 int dims() const;
2828 size_t nzcount() const;
2829
2831 size_t hash(int i0) const;
2833 size_t hash(int i0, int i1) const;
2835 size_t hash(int i0, int i1, int i2) const;
2837 size_t hash(const int* idx) const;
2838
2840
2851 uchar* ptr(int i0, bool createMissing, size_t* hashval=0);
2853 uchar* ptr(int i0, int i1, bool createMissing, size_t* hashval=0);
2855 uchar* ptr(int i0, int i1, int i2, bool createMissing, size_t* hashval=0);
2857 uchar* ptr(const int* idx, bool createMissing, size_t* hashval=0);
2859
2861
2869 template<typename _Tp> _Tp& ref(int i0, size_t* hashval=0);
2871 template<typename _Tp> _Tp& ref(int i0, int i1, size_t* hashval=0);
2873 template<typename _Tp> _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
2875 template<typename _Tp> _Tp& ref(const int* idx, size_t* hashval=0);
2877
2879
2890 template<typename _Tp> _Tp value(int i0, size_t* hashval=0) const;
2892 template<typename _Tp> _Tp value(int i0, int i1, size_t* hashval=0) const;
2894 template<typename _Tp> _Tp value(int i0, int i1, int i2, size_t* hashval=0) const;
2896 template<typename _Tp> _Tp value(const int* idx, size_t* hashval=0) const;
2898
2900
2908 template<typename _Tp> const _Tp* find(int i0, size_t* hashval=0) const;
2910 template<typename _Tp> const _Tp* find(int i0, int i1, size_t* hashval=0) const;
2912 template<typename _Tp> const _Tp* find(int i0, int i1, int i2, size_t* hashval=0) const;
2914 template<typename _Tp> const _Tp* find(const int* idx, size_t* hashval=0) const;
2916
2918 void erase(int i0, int i1, size_t* hashval=0);
2920 void erase(int i0, int i1, int i2, size_t* hashval=0);
2922 void erase(const int* idx, size_t* hashval=0);
2923
2925
2929 SparseMatIterator begin();
2931 template<typename _Tp> SparseMatIterator_<_Tp> begin();
2933 SparseMatConstIterator begin() const;
2935 template<typename _Tp> SparseMatConstIterator_<_Tp> begin() const;
2937
2941 SparseMatIterator end();
2943 SparseMatConstIterator end() const;
2945 template<typename _Tp> SparseMatIterator_<_Tp> end();
2947 template<typename _Tp> SparseMatConstIterator_<_Tp> end() const;
2948
2950 template<typename _Tp> _Tp& value(Node* n);
2952 template<typename _Tp> const _Tp& value(const Node* n) const;
2953
2955 Node* node(size_t nidx);
2956 const Node* node(size_t nidx) const;
2957
2958 uchar* newNode(const int* idx, size_t hashval);
2959 void removeNode(size_t hidx, size_t nidx, size_t previdx);
2960 void resizeHashTab(size_t newsize);
2961
2962 int flags;
2963 Hdr* hdr;
2964};
2965
2966
2967
2969
2981template<typename _Tp> class SparseMat_ : public SparseMat
2982{
2983public:
2984 typedef SparseMatIterator_<_Tp> iterator;
2985 typedef SparseMatConstIterator_<_Tp> const_iterator;
2986
2988 SparseMat_();
2990 SparseMat_(int dims, const int* _sizes);
2992 SparseMat_(const SparseMat& m);
2994 SparseMat_(const SparseMat_& m);
2996 SparseMat_(const Mat& m);
2998 //SparseMat_(const CvSparseMat* m);
3000 SparseMat_& operator = (const SparseMat& m);
3002 SparseMat_& operator = (const SparseMat_& m);
3004 SparseMat_& operator = (const Mat& m);
3005
3007 SparseMat_ clone() const CV_NODISCARD;
3009 void create(int dims, const int* _sizes);
3011 //operator CvSparseMat*() const;
3012
3014 int type() const;
3016 int depth() const;
3018 int channels() const;
3019
3021 _Tp& ref(int i0, size_t* hashval=0);
3023 _Tp& ref(int i0, int i1, size_t* hashval=0);
3025 _Tp& ref(int i0, int i1, int i2, size_t* hashval=0);
3027 _Tp& ref(const int* idx, size_t* hashval=0);
3028
3030 _Tp operator()(int i0, size_t* hashval=0) const;
3032 _Tp operator()(int i0, int i1, size_t* hashval=0) const;
3034 _Tp operator()(int i0, int i1, int i2, size_t* hashval=0) const;
3036 _Tp operator()(const int* idx, size_t* hashval=0) const;
3037
3039 SparseMatIterator_<_Tp> begin();
3041 SparseMatConstIterator_<_Tp> begin() const;
3043 SparseMatIterator_<_Tp> end();
3045 SparseMatConstIterator_<_Tp> end() const;
3046};
3047
3048
3049
3051
3052class CV_EXPORTS MatConstIterator
3053{
3054public:
3055 typedef uchar* value_type;
3056 typedef ptrdiff_t difference_type;
3057 typedef const uchar** pointer;
3058 typedef uchar* reference;
3059
3060 typedef std::random_access_iterator_tag iterator_category;
3061
3063 MatConstIterator();
3065 MatConstIterator(const Mat* _m);
3067 MatConstIterator(const Mat* _m, int _row, int _col=0);
3069 MatConstIterator(const Mat* _m, Point _pt);
3071 MatConstIterator(const Mat* _m, const int* _idx);
3073 MatConstIterator(const MatConstIterator& it);
3074
3076 MatConstIterator& operator = (const MatConstIterator& it);
3078 const uchar* operator *() const;
3080 const uchar* operator [](ptrdiff_t i) const;
3081
3083 MatConstIterator& operator += (ptrdiff_t ofs);
3085 MatConstIterator& operator -= (ptrdiff_t ofs);
3087 MatConstIterator& operator --();
3089 MatConstIterator operator --(int);
3091 MatConstIterator& operator ++();
3093 MatConstIterator operator ++(int);
3095 Point pos() const;
3097 void pos(int* _idx) const;
3098
3099 ptrdiff_t lpos() const;
3100 void seek(ptrdiff_t ofs, bool relative = false);
3101 void seek(const int* _idx, bool relative = false);
3102
3103 const Mat* m;
3104 size_t elemSize;
3105 const uchar* ptr;
3106 const uchar* sliceStart;
3107 const uchar* sliceEnd;
3108};
3109
3110
3111
3113
3116template<typename _Tp>
3117class MatConstIterator_ : public MatConstIterator
3118{
3119public:
3120 typedef _Tp value_type;
3121 typedef ptrdiff_t difference_type;
3122 typedef const _Tp* pointer;
3123 typedef const _Tp& reference;
3124
3125 typedef std::random_access_iterator_tag iterator_category;
3126
3128 MatConstIterator_();
3130 MatConstIterator_(const Mat_<_Tp>* _m);
3132 MatConstIterator_(const Mat_<_Tp>* _m, int _row, int _col=0);
3134 MatConstIterator_(const Mat_<_Tp>* _m, Point _pt);
3136 MatConstIterator_(const Mat_<_Tp>* _m, const int* _idx);
3138 MatConstIterator_(const MatConstIterator_& it);
3139
3141 MatConstIterator_& operator = (const MatConstIterator_& it);
3143 const _Tp& operator *() const;
3145 const _Tp& operator [](ptrdiff_t i) const;
3146
3148 MatConstIterator_& operator += (ptrdiff_t ofs);
3150 MatConstIterator_& operator -= (ptrdiff_t ofs);
3152 MatConstIterator_& operator --();
3154 MatConstIterator_ operator --(int);
3156 MatConstIterator_& operator ++();
3158 MatConstIterator_ operator ++(int);
3160 Point pos() const;
3161};
3162
3163
3164
3166
3169template<typename _Tp>
3170class MatIterator_ : public MatConstIterator_<_Tp>
3171{
3172public:
3173 typedef _Tp* pointer;
3174 typedef _Tp& reference;
3175
3176 typedef std::random_access_iterator_tag iterator_category;
3177
3179 MatIterator_();
3181 MatIterator_(Mat_<_Tp>* _m);
3183 MatIterator_(Mat_<_Tp>* _m, int _row, int _col=0);
3185 MatIterator_(Mat_<_Tp>* _m, Point _pt);
3187 MatIterator_(Mat_<_Tp>* _m, const int* _idx);
3189 MatIterator_(const MatIterator_& it);
3191 MatIterator_& operator = (const MatIterator_<_Tp>& it );
3192
3194 _Tp& operator *() const;
3196 _Tp& operator [](ptrdiff_t i) const;
3197
3199 MatIterator_& operator += (ptrdiff_t ofs);
3201 MatIterator_& operator -= (ptrdiff_t ofs);
3203 MatIterator_& operator --();
3205 MatIterator_ operator --(int);
3207 MatIterator_& operator ++();
3209 MatIterator_ operator ++(int);
3210};
3211
3212
3213
3215
3228class CV_EXPORTS SparseMatConstIterator
3229{
3230public:
3232 SparseMatConstIterator();
3234 SparseMatConstIterator(const SparseMat* _m);
3236 SparseMatConstIterator(const SparseMatConstIterator& it);
3237
3239 SparseMatConstIterator& operator = (const SparseMatConstIterator& it);
3240
3242 template<typename _Tp> const _Tp& value() const;
3244 const SparseMat::Node* node() const;
3245
3247 SparseMatConstIterator& operator --();
3249 SparseMatConstIterator operator --(int);
3251 SparseMatConstIterator& operator ++();
3253 SparseMatConstIterator operator ++(int);
3254
3256 void seekEnd();
3257
3258 const SparseMat* m;
3259 size_t hashidx;
3260 uchar* ptr;
3261};
3262
3263
3264
3266
3272class CV_EXPORTS SparseMatIterator : public SparseMatConstIterator
3273{
3274public:
3276 SparseMatIterator();
3278 SparseMatIterator(SparseMat* _m);
3280 SparseMatIterator(SparseMat* _m, const int* idx);
3282 SparseMatIterator(const SparseMatIterator& it);
3283
3285 SparseMatIterator& operator = (const SparseMatIterator& it);
3287 template<typename _Tp> _Tp& value() const;
3289 SparseMat::Node* node() const;
3290
3292 SparseMatIterator& operator ++();
3294 SparseMatIterator operator ++(int);
3295};
3296
3297
3298
3300
3306template<typename _Tp> class SparseMatConstIterator_ : public SparseMatConstIterator
3307{
3308public:
3309
3310 typedef std::forward_iterator_tag iterator_category;
3311
3313 SparseMatConstIterator_();
3315 SparseMatConstIterator_(const SparseMat_<_Tp>* _m);
3316 SparseMatConstIterator_(const SparseMat* _m);
3318 SparseMatConstIterator_(const SparseMatConstIterator_& it);
3319
3321 SparseMatConstIterator_& operator = (const SparseMatConstIterator_& it);
3323 const _Tp& operator *() const;
3324
3326 SparseMatConstIterator_& operator ++();
3328 SparseMatConstIterator_ operator ++(int);
3329};
3330
3331
3332
3334
3340template<typename _Tp> class SparseMatIterator_ : public SparseMatConstIterator_<_Tp>
3341{
3342public:
3343
3344 typedef std::forward_iterator_tag iterator_category;
3345
3347 SparseMatIterator_();
3349 SparseMatIterator_(SparseMat_<_Tp>* _m);
3350 SparseMatIterator_(SparseMat* _m);
3352 SparseMatIterator_(const SparseMatIterator_& it);
3353
3355 SparseMatIterator_& operator = (const SparseMatIterator_& it);
3357 _Tp& operator *() const;
3358
3360 SparseMatIterator_& operator ++();
3362 SparseMatIterator_ operator ++(int);
3363};
3364
3365
3366
3368
3429class CV_EXPORTS NAryMatIterator
3430{
3431public:
3433 NAryMatIterator();
3435 NAryMatIterator(const Mat** arrays, uchar** ptrs, int narrays=-1);
3437 NAryMatIterator(const Mat** arrays, Mat* planes, int narrays=-1);
3439 void init(const Mat** arrays, Mat* planes, uchar** ptrs, int narrays=-1);
3440
3442 NAryMatIterator& operator ++();
3444 NAryMatIterator operator ++(int);
3445
3447 const Mat** arrays;
3449 Mat* planes;
3451 uchar** ptrs;
3453 int narrays;
3455 size_t nplanes;
3457 size_t size;
3458protected:
3459 int iterdepth;
3460 size_t idx;
3461};
3462
3463
3464
3466
3467class CV_EXPORTS MatOp
3468{
3469public:
3470 MatOp();
3471 virtual ~MatOp();
3472
3473 virtual bool elementWise(const MatExpr& expr) const;
3474 virtual void assign(const MatExpr& expr, Mat& m, int type=-1) const = 0;
3475 virtual void roi(const MatExpr& expr, const Range& rowRange,
3476 const Range& colRange, MatExpr& res) const;
3477 virtual void diag(const MatExpr& expr, int d, MatExpr& res) const;
3478 virtual void augAssignAdd(const MatExpr& expr, Mat& m) const;
3479 virtual void augAssignSubtract(const MatExpr& expr, Mat& m) const;
3480 virtual void augAssignMultiply(const MatExpr& expr, Mat& m) const;
3481 virtual void augAssignDivide(const MatExpr& expr, Mat& m) const;
3482 virtual void augAssignAnd(const MatExpr& expr, Mat& m) const;
3483 virtual void augAssignOr(const MatExpr& expr, Mat& m) const;
3484 virtual void augAssignXor(const MatExpr& expr, Mat& m) const;
3485
3486 virtual void add(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
3487 virtual void add(const MatExpr& expr1, const Scalar& s, MatExpr& res) const;
3488
3489 virtual void subtract(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
3490 virtual void subtract(const Scalar& s, const MatExpr& expr, MatExpr& res) const;
3491
3492 virtual void multiply(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
3493 virtual void multiply(const MatExpr& expr1, double s, MatExpr& res) const;
3494
3495 virtual void divide(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res, double scale=1) const;
3496 virtual void divide(double s, const MatExpr& expr, MatExpr& res) const;
3497
3498 virtual void abs(const MatExpr& expr, MatExpr& res) const;
3499
3500 virtual void transpose(const MatExpr& expr, MatExpr& res) const;
3501 virtual void matmul(const MatExpr& expr1, const MatExpr& expr2, MatExpr& res) const;
3502 virtual void invert(const MatExpr& expr, int method, MatExpr& res) const;
3503
3504 virtual Size size(const MatExpr& expr) const;
3505 virtual int type(const MatExpr& expr) const;
3506};
3507
3554class CV_EXPORTS MatExpr
3555{
3556public:
3557 MatExpr();
3558 explicit MatExpr(const Mat& m);
3559
3560 MatExpr(const MatOp* _op, int _flags, const Mat& _a = Mat(), const Mat& _b = Mat(),
3561 const Mat& _c = Mat(), double _alpha = 1, double _beta = 1, const Scalar& _s = Scalar());
3562
3563 operator Mat() const;
3564 template<typename _Tp> operator Mat_<_Tp>() const;
3565
3566 Size size() const;
3567 int type() const;
3568
3569 MatExpr row(int y) const;
3570 MatExpr col(int x) const;
3571 MatExpr diag(int d = 0) const;
3572 MatExpr operator()( const Range& rowRange, const Range& colRange ) const;
3573 MatExpr operator()( const Rect& roi ) const;
3574
3575 MatExpr t() const;
3576 MatExpr inv(int method = DECOMP_LU) const;
3577 MatExpr mul(const MatExpr& e, double scale=1) const;
3578 MatExpr mul(const Mat& m, double scale=1) const;
3579
3580 Mat cross(const Mat& m) const;
3581 double dot(const Mat& m) const;
3582
3583 void swap(MatExpr& b);
3584
3585 const MatOp* op;
3586 int flags;
3587
3588 Mat a, b, c;
3589 double alpha, beta;
3590 Scalar s;
3591};
3592
3594
3597CV_EXPORTS MatExpr operator + (const Mat& a, const Mat& b);
3598CV_EXPORTS MatExpr operator + (const Mat& a, const Scalar& s);
3599CV_EXPORTS MatExpr operator + (const Scalar& s, const Mat& a);
3600CV_EXPORTS MatExpr operator + (const MatExpr& e, const Mat& m);
3601CV_EXPORTS MatExpr operator + (const Mat& m, const MatExpr& e);
3602CV_EXPORTS MatExpr operator + (const MatExpr& e, const Scalar& s);
3603CV_EXPORTS MatExpr operator + (const Scalar& s, const MatExpr& e);
3604CV_EXPORTS MatExpr operator + (const MatExpr& e1, const MatExpr& e2);
3605template<typename _Tp, int m, int n> static inline
3606MatExpr operator + (const Mat& a, const Matx<_Tp, m, n>& b) { return a + Mat(b); }
3607template<typename _Tp, int m, int n> static inline
3608MatExpr operator + (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) + b; }
3609
3610CV_EXPORTS MatExpr operator - (const Mat& a, const Mat& b);
3611CV_EXPORTS MatExpr operator - (const Mat& a, const Scalar& s);
3612CV_EXPORTS MatExpr operator - (const Scalar& s, const Mat& a);
3613CV_EXPORTS MatExpr operator - (const MatExpr& e, const Mat& m);
3614CV_EXPORTS MatExpr operator - (const Mat& m, const MatExpr& e);
3615CV_EXPORTS MatExpr operator - (const MatExpr& e, const Scalar& s);
3616CV_EXPORTS MatExpr operator - (const Scalar& s, const MatExpr& e);
3617CV_EXPORTS MatExpr operator - (const MatExpr& e1, const MatExpr& e2);
3618template<typename _Tp, int m, int n> static inline
3619MatExpr operator - (const Mat& a, const Matx<_Tp, m, n>& b) { return a - Mat(b); }
3620template<typename _Tp, int m, int n> static inline
3621MatExpr operator - (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) - b; }
3622
3623CV_EXPORTS MatExpr operator - (const Mat& m);
3624CV_EXPORTS MatExpr operator - (const MatExpr& e);
3625
3626CV_EXPORTS MatExpr operator * (const Mat& a, const Mat& b);
3627CV_EXPORTS MatExpr operator * (const Mat& a, double s);
3628CV_EXPORTS MatExpr operator * (double s, const Mat& a);
3629CV_EXPORTS MatExpr operator * (const MatExpr& e, const Mat& m);
3630CV_EXPORTS MatExpr operator * (const Mat& m, const MatExpr& e);
3631CV_EXPORTS MatExpr operator * (const MatExpr& e, double s);
3632CV_EXPORTS MatExpr operator * (double s, const MatExpr& e);
3633CV_EXPORTS MatExpr operator * (const MatExpr& e1, const MatExpr& e2);
3634template<typename _Tp, int m, int n> static inline
3635MatExpr operator * (const Mat& a, const Matx<_Tp, m, n>& b) { return a * Mat(b); }
3636template<typename _Tp, int m, int n> static inline
3637MatExpr operator * (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) * b; }
3638
3639CV_EXPORTS MatExpr operator / (const Mat& a, const Mat& b);
3640CV_EXPORTS MatExpr operator / (const Mat& a, double s);
3641CV_EXPORTS MatExpr operator / (double s, const Mat& a);
3642CV_EXPORTS MatExpr operator / (const MatExpr& e, const Mat& m);
3643CV_EXPORTS MatExpr operator / (const Mat& m, const MatExpr& e);
3644CV_EXPORTS MatExpr operator / (const MatExpr& e, double s);
3645CV_EXPORTS MatExpr operator / (double s, const MatExpr& e);
3646CV_EXPORTS MatExpr operator / (const MatExpr& e1, const MatExpr& e2);
3647template<typename _Tp, int m, int n> static inline
3648MatExpr operator / (const Mat& a, const Matx<_Tp, m, n>& b) { return a / Mat(b); }
3649template<typename _Tp, int m, int n> static inline
3650MatExpr operator / (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) / b; }
3651
3652CV_EXPORTS MatExpr operator < (const Mat& a, const Mat& b);
3653CV_EXPORTS MatExpr operator < (const Mat& a, double s);
3654CV_EXPORTS MatExpr operator < (double s, const Mat& a);
3655template<typename _Tp, int m, int n> static inline
3656MatExpr operator < (const Mat& a, const Matx<_Tp, m, n>& b) { return a < Mat(b); }
3657template<typename _Tp, int m, int n> static inline
3658MatExpr operator < (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) < b; }
3659
3660CV_EXPORTS MatExpr operator <= (const Mat& a, const Mat& b);
3661CV_EXPORTS MatExpr operator <= (const Mat& a, double s);
3662CV_EXPORTS MatExpr operator <= (double s, const Mat& a);
3663template<typename _Tp, int m, int n> static inline
3664MatExpr operator <= (const Mat& a, const Matx<_Tp, m, n>& b) { return a <= Mat(b); }
3665template<typename _Tp, int m, int n> static inline
3666MatExpr operator <= (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) <= b; }
3667
3668CV_EXPORTS MatExpr operator == (const Mat& a, const Mat& b);
3669CV_EXPORTS MatExpr operator == (const Mat& a, double s);
3670CV_EXPORTS MatExpr operator == (double s, const Mat& a);
3671template<typename _Tp, int m, int n> static inline
3672MatExpr operator == (const Mat& a, const Matx<_Tp, m, n>& b) { return a == Mat(b); }
3673template<typename _Tp, int m, int n> static inline
3674MatExpr operator == (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) == b; }
3675
3676CV_EXPORTS MatExpr operator != (const Mat& a, const Mat& b);
3677CV_EXPORTS MatExpr operator != (const Mat& a, double s);
3678CV_EXPORTS MatExpr operator != (double s, const Mat& a);
3679template<typename _Tp, int m, int n> static inline
3680MatExpr operator != (const Mat& a, const Matx<_Tp, m, n>& b) { return a != Mat(b); }
3681template<typename _Tp, int m, int n> static inline
3682MatExpr operator != (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) != b; }
3683
3684CV_EXPORTS MatExpr operator >= (const Mat& a, const Mat& b);
3685CV_EXPORTS MatExpr operator >= (const Mat& a, double s);
3686CV_EXPORTS MatExpr operator >= (double s, const Mat& a);
3687template<typename _Tp, int m, int n> static inline
3688MatExpr operator >= (const Mat& a, const Matx<_Tp, m, n>& b) { return a >= Mat(b); }
3689template<typename _Tp, int m, int n> static inline
3690MatExpr operator >= (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) >= b; }
3691
3692CV_EXPORTS MatExpr operator > (const Mat& a, const Mat& b);
3693CV_EXPORTS MatExpr operator > (const Mat& a, double s);
3694CV_EXPORTS MatExpr operator > (double s, const Mat& a);
3695template<typename _Tp, int m, int n> static inline
3696MatExpr operator > (const Mat& a, const Matx<_Tp, m, n>& b) { return a > Mat(b); }
3697template<typename _Tp, int m, int n> static inline
3698MatExpr operator > (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) > b; }
3699
3700CV_EXPORTS MatExpr operator & (const Mat& a, const Mat& b);
3701CV_EXPORTS MatExpr operator & (const Mat& a, const Scalar& s);
3702CV_EXPORTS MatExpr operator & (const Scalar& s, const Mat& a);
3703template<typename _Tp, int m, int n> static inline
3704MatExpr operator & (const Mat& a, const Matx<_Tp, m, n>& b) { return a & Mat(b); }
3705template<typename _Tp, int m, int n> static inline
3706MatExpr operator & (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) & b; }
3707
3708CV_EXPORTS MatExpr operator | (const Mat& a, const Mat& b);
3709CV_EXPORTS MatExpr operator | (const Mat& a, const Scalar& s);
3710CV_EXPORTS MatExpr operator | (const Scalar& s, const Mat& a);
3711template<typename _Tp, int m, int n> static inline
3712MatExpr operator | (const Mat& a, const Matx<_Tp, m, n>& b) { return a | Mat(b); }
3713template<typename _Tp, int m, int n> static inline
3714MatExpr operator | (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) | b; }
3715
3716CV_EXPORTS MatExpr operator ^ (const Mat& a, const Mat& b);
3717CV_EXPORTS MatExpr operator ^ (const Mat& a, const Scalar& s);
3718CV_EXPORTS MatExpr operator ^ (const Scalar& s, const Mat& a);
3719template<typename _Tp, int m, int n> static inline
3720MatExpr operator ^ (const Mat& a, const Matx<_Tp, m, n>& b) { return a ^ Mat(b); }
3721template<typename _Tp, int m, int n> static inline
3722MatExpr operator ^ (const Matx<_Tp, m, n>& a, const Mat& b) { return Mat(a) ^ b; }
3723
3724CV_EXPORTS MatExpr operator ~(const Mat& m);
3725
3726CV_EXPORTS MatExpr min(const Mat& a, const Mat& b);
3727CV_EXPORTS MatExpr min(const Mat& a, double s);
3728CV_EXPORTS MatExpr min(double s, const Mat& a);
3729template<typename _Tp, int m, int n> static inline
3730MatExpr min (const Mat& a, const Matx<_Tp, m, n>& b) { return min(a, Mat(b)); }
3731template<typename _Tp, int m, int n> static inline
3732MatExpr min (const Matx<_Tp, m, n>& a, const Mat& b) { return min(Mat(a), b); }
3733
3734CV_EXPORTS MatExpr max(const Mat& a, const Mat& b);
3735CV_EXPORTS MatExpr max(const Mat& a, double s);
3736CV_EXPORTS MatExpr max(double s, const Mat& a);
3737template<typename _Tp, int m, int n> static inline
3738MatExpr max (const Mat& a, const Matx<_Tp, m, n>& b) { return max(a, Mat(b)); }
3739template<typename _Tp, int m, int n> static inline
3740MatExpr max (const Matx<_Tp, m, n>& a, const Mat& b) { return max(Mat(a), b); }
3741
3755CV_EXPORTS MatExpr abs(const Mat& m);
3759CV_EXPORTS MatExpr abs(const MatExpr& e);
3761
3762} // cv
3763
3764#include "opencv2/core/mat.inl.hpp"
3765
3766#endif // OPENCV_CORE_MAT_HPP
cv::_InputArray
This is the proxy class for passing read-only input arrays into OpenCV functions.
Definition: mat.hpp:159
cv::_InputArray::KindFlag
KindFlag
Definition: mat.hpp:161
cv::_InputOutputArray
Definition: mat.hpp:386
cv::_OutputArray
This type is very similar to InputArray except that it is used for input/output and output function p...
Definition: mat.hpp:295
cv::BufferPoolController
Definition: bufferpool.hpp:22
cv::DataType
Template "trait" class for OpenCV primitive data types.
Definition: traits.hpp:113
cv::Mat_
Template matrix class derived from Mat
Definition: mat.hpp:2199
cv::Mat_::forEach
void forEach(const Functor &operation)
template methods for for operation over all matrix elements.
cv::Mat_::Mat_
Mat_() CV_NOEXCEPT
default constructor
cv::Mat_::row
Mat_ row(int y) const
overridden forms of Mat::row() etc.
cv::Mat_::operator[]
_Tp * operator[](int y)
more convenient forms of row and element access operators
cv::Mat_::elemSize
size_t elemSize() const
overridden forms of Mat::elemSize() etc.
cv::Mat_::begin
iterator begin()
iterators; they are smart enough to skip gaps in the end of rows
cv::Mat_::zeros
static MatExpr zeros(int rows, int cols)
overridden forms of Mat::zeros() etc. Data type is omitted, of course
cv::Mat_::cross
Mat_ cross(const Mat_ &m) const
cross-product
cv::Mat_::release
void release()
equivalent to Mat::release()
cv::Mat_::stepT
size_t stepT(int i=0) const
returns step()/sizeof(_Tp)
cv::Mat_::create
void create(int _rows, int _cols)
equivalent to Mat::create(_rows, _cols, DataType<_Tp>::type)
cv::Mat_::adjustROI
Mat_ & adjustROI(int dtop, int dbottom, int dleft, int dright)
some more overridden methods
cv::MatAllocator
Custom array allocator
Definition: mat.hpp:470
cv::MatCommaInitializer_
Comma-separated Matrix Initializer
Definition: mat.hpp:515
cv::MatCommaInitializer_::MatCommaInitializer_
MatCommaInitializer_(Mat_< _Tp > *_m)
the constructor, created by "matrix << firstValue" operator, where matrix is cv::Mat
cv::MatCommaInitializer_::operator,
MatCommaInitializer_< _Tp > & operator,(T2 v)
the operator that takes the next value and put it to the matrix
cv::MatConstIterator_
Matrix read-only iterator
Definition: mat.hpp:3118
cv::MatConstIterator_::MatConstIterator_
MatConstIterator_()
default constructor
cv::MatConstIterator_::MatConstIterator_
MatConstIterator_(const Mat_< _Tp > *_m, Point _pt)
constructor that sets the iterator to the specified element of the matrix
cv::MatConstIterator_::MatConstIterator_
MatConstIterator_(const MatConstIterator_ &it)
copy constructor
cv::MatConstIterator_::MatConstIterator_
MatConstIterator_(const Mat_< _Tp > *_m, int _row, int _col=0)
constructor that sets the iterator to the specified element of the matrix
cv::MatConstIterator_::MatConstIterator_
MatConstIterator_(const Mat_< _Tp > *_m, const int *_idx)
constructor that sets the iterator to the specified element of the matrix
cv::MatConstIterator_::pos
Point pos() const
returns the current iterator position
cv::MatConstIterator_::MatConstIterator_
MatConstIterator_(const Mat_< _Tp > *_m)
constructor that sets the iterator to the beginning of the matrix
cv::MatConstIterator
Definition: mat.hpp:3053
cv::MatConstIterator::MatConstIterator
MatConstIterator(const Mat *_m, const int *_idx)
constructor that sets the iterator to the specified element of the matrix
cv::MatConstIterator::MatConstIterator
MatConstIterator()
default constructor
cv::MatConstIterator::pos
Point pos() const
returns the current iterator position
cv::MatConstIterator::MatConstIterator
MatConstIterator(const Mat *_m, Point _pt)
constructor that sets the iterator to the specified element of the matrix
cv::MatConstIterator::MatConstIterator
MatConstIterator(const MatConstIterator &it)
copy constructor
cv::MatConstIterator::pos
void pos(int *_idx) const
returns the current iterator position
cv::MatConstIterator::MatConstIterator
MatConstIterator(const Mat *_m, int _row, int _col=0)
constructor that sets the iterator to the specified element of the matrix
cv::MatConstIterator::MatConstIterator
MatConstIterator(const Mat *_m)
constructor that sets the iterator to the beginning of the matrix
cv::MatExpr
Matrix expression representation This is a list of implemented matrix operations that can be combined...
Definition: mat.hpp:3555
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Mat::setTo
Mat & setTo(InputArray value, InputArray mask=noArray())
Sets all or some of the array elements to the specified value.
cv::Mat::inv
MatExpr inv(int method=DECOMP_LU) const
Inverses a matrix.
cv::Mat::dot
double dot(InputArray m) const
Computes a dot-product of two vectors.
cv::Mat::u
UMatData * u
interaction with UMat
Definition: mat.hpp:2127
cv::Mat::Mat
Mat() CV_NOEXCEPT
cv::Mat::copyTo
void copyTo(OutputArray m) const
Copies the matrix to another one.
cv::Mat::updateContinuityFlag
void updateContinuityFlag()
internal use method: updates the continuity flag
cv::Mat::mul
MatExpr mul(InputArray m, double scale=1) const
Performs an element-wise multiplication or division of the two matrices.
cv::Mat::dims
int dims
the matrix dimensionality, >= 2
Definition: mat.hpp:2105
cv::Mat::allocator
MatAllocator * allocator
custom allocator
Definition: mat.hpp:2117
cv::Mat::data
uchar * data
pointer to the data
Definition: mat.hpp:2109
cv::Mat::reshape
Mat reshape(int cn, int rows=0) const
Changes the shape and/or the number of channels of a 2D matrix without copying the data.
cv::Mat::ptr
uchar * ptr(int i0=0)
Returns a pointer to the specified matrix row.
cv::Mat::addref
void addref()
Increments the reference counter.
cv::Mat::rowRange
Mat rowRange(int startrow, int endrow) const
Creates a matrix header for the specified row span.
cv::Mat::assignTo
void assignTo(Mat &m, int type=-1) const
Provides a functional form of convertTo.
cv::Mat::t
MatExpr t() const
Transposes a matrix.
cv::Mat::colRange
Mat colRange(int startcol, int endcol) const
Creates a matrix header for the specified column span.
cv::Mat::rows
int rows
the number of rows and columns or (-1, -1) when the matrix has more than 2 dimensions
Definition: mat.hpp:2107
cv::Mat::convertTo
void convertTo(OutputArray m, int rtype, double alpha=1, double beta=0) const
Converts an array to another data type with optional scaling.
cv::Mat::getStdAllocator
static MatAllocator * getStdAllocator()
and the standard allocator
cv::Mat::datastart
const uchar * datastart
helper fields used in locateROI and adjustROI
Definition: mat.hpp:2112
cv::Mat::flags
int flags
Definition: mat.hpp:2103
cv::MatIterator_
Matrix read-write iterator
Definition: mat.hpp:3171
cv::MatIterator_::MatIterator_
MatIterator_(Mat_< _Tp > *_m, int _row, int _col=0)
constructor that sets the iterator to the specified element of the matrix
cv::MatIterator_::MatIterator_
MatIterator_(Mat_< _Tp > *_m, Point _pt)
constructor that sets the iterator to the specified element of the matrix
cv::MatIterator_::MatIterator_
MatIterator_()
the default constructor
cv::MatIterator_::MatIterator_
MatIterator_(Mat_< _Tp > *_m, const int *_idx)
constructor that sets the iterator to the specified element of the matrix
cv::MatIterator_::MatIterator_
MatIterator_(const MatIterator_ &it)
copy constructor
cv::MatIterator_::MatIterator_
MatIterator_(Mat_< _Tp > *_m)
constructor that sets the iterator to the beginning of the matrix
cv::MatOp
Definition: mat.hpp:3468
cv::Matx
Template class for small matrices whose type and size are known at compilation time
Definition: matx.hpp:100
cv::NAryMatIterator
n-ary multi-dimensional array iterator.
Definition: mat.hpp:3430
cv::NAryMatIterator::arrays
const Mat ** arrays
the iterated arrays
Definition: mat.hpp:3447
cv::NAryMatIterator::size
size_t size
the size of each segment (in elements)
Definition: mat.hpp:3457
cv::NAryMatIterator::nplanes
size_t nplanes
the number of hyper-planes that the iterator steps through
Definition: mat.hpp:3455
cv::NAryMatIterator::NAryMatIterator
NAryMatIterator(const Mat **arrays, uchar **ptrs, int narrays=-1)
the full constructor taking arbitrary number of n-dim matrices
cv::NAryMatIterator::ptrs
uchar ** ptrs
data pointers
Definition: mat.hpp:3451
cv::NAryMatIterator::NAryMatIterator
NAryMatIterator(const Mat **arrays, Mat *planes, int narrays=-1)
the full constructor taking arbitrary number of n-dim matrices
cv::NAryMatIterator::init
void init(const Mat **arrays, Mat *planes, uchar **ptrs, int narrays=-1)
the separate iterator initialization method
cv::NAryMatIterator::planes
Mat * planes
the current planes
Definition: mat.hpp:3449
cv::NAryMatIterator::NAryMatIterator
NAryMatIterator()
the default constructor
cv::NAryMatIterator::narrays
int narrays
the number of arrays
Definition: mat.hpp:3453
cv::Point3_
Template class for 3D points specified by its coordinates x, y and z.
Definition: core/types.hpp:240
cv::Point_
Template class for 2D points specified by its coordinates x and y.
Definition: core/types.hpp:158
cv::Range
Template class specifying a continuous subsequence (slice) of a sequence.
Definition: core/types.hpp:590
cv::Rect_
Template class for 2D rectangles
Definition: core/types.hpp:421
cv::Scalar_< double >
cv::Size_
Template class for specifying the size of an image or rectangle.
Definition: core/types.hpp:316
cv::SparseMat_
Template sparse n-dimensional array class derived from SparseMat
Definition: mat.hpp:2982
cv::SparseMat_::SparseMat_
SparseMat_(const Mat &m)
converts dense matrix to the sparse form
cv::SparseMat_::SparseMat_
SparseMat_()
the default constructor
cv::SparseMat_::SparseMat_
SparseMat_(const SparseMat_ &m)
the copy constructor. This is O(1) operation - no data is copied
cv::SparseMat_::SparseMat_
SparseMat_(const SparseMat &m)
the copy constructor. If DataType<_Tp>.type != m.type(), the m elements are converted
cv::SparseMat_::clone
SparseMat_ clone() const CV_NODISCARD
makes full copy of the matrix. All the elements are duplicated
cv::SparseMat_::SparseMat_
SparseMat_(int dims, const int *_sizes)
the full constructor equivalent to SparseMat(dims, _sizes, DataType<_Tp>::type)
cv::SparseMatConstIterator_
Template Read-Only Sparse Matrix Iterator Class.
Definition: mat.hpp:3307
cv::SparseMatConstIterator_::SparseMatConstIterator_
SparseMatConstIterator_(const SparseMatConstIterator_ &it)
the copy constructor
cv::SparseMatConstIterator_::SparseMatConstIterator_
SparseMatConstIterator_(const SparseMat_< _Tp > *_m)
the full constructor setting the iterator to the first sparse matrix element
cv::SparseMatConstIterator_::SparseMatConstIterator_
SparseMatConstIterator_()
the default constructor
cv::SparseMatConstIterator
Read-Only Sparse Matrix Iterator.
Definition: mat.hpp:3229
cv::SparseMatConstIterator::value
const _Tp & value() const
template method returning the current matrix element
cv::SparseMatConstIterator::SparseMatConstIterator
SparseMatConstIterator(const SparseMat *_m)
the full constructor setting the iterator to the first sparse matrix element
cv::SparseMatConstIterator::SparseMatConstIterator
SparseMatConstIterator(const SparseMatConstIterator &it)
the copy constructor
cv::SparseMatConstIterator::node
const SparseMat::Node * node() const
returns the current node of the sparse matrix. it.node->idx is the current element index
cv::SparseMatConstIterator::seekEnd
void seekEnd()
moves iterator to the element after the last element
cv::SparseMatConstIterator::SparseMatConstIterator
SparseMatConstIterator()
the default constructor
cv::SparseMat
The class SparseMat represents multi-dimensional sparse numerical arrays.
Definition: mat.hpp:2704
cv::SparseMat::~SparseMat
~SparseMat()
the destructor
cv::SparseMat::clone
SparseMat clone() const CV_NODISCARD
creates full copy of the matrix
cv::SparseMat::SparseMat
SparseMat(int dims, const int *_sizes, int _type)
cv::SparseMat::SparseMat
SparseMat(const SparseMat &m)
cv::SparseMat::SparseMat
SparseMat()
Various SparseMat constructors.
cv::SparseMat::SparseMat
SparseMat(const Mat &m)
cv::SparseMatIterator_
Template Read-Write Sparse Matrix Iterator Class.
Definition: mat.hpp:3341
cv::SparseMatIterator_::SparseMatIterator_
SparseMatIterator_()
the default constructor
cv::SparseMatIterator_::SparseMatIterator_
SparseMatIterator_(const SparseMatIterator_ &it)
the copy constructor
cv::SparseMatIterator_::SparseMatIterator_
SparseMatIterator_(SparseMat_< _Tp > *_m)
the full constructor setting the iterator to the first sparse matrix element
cv::SparseMatIterator
Read-write Sparse Matrix Iterator
Definition: mat.hpp:3273
cv::SparseMatIterator::SparseMatIterator
SparseMatIterator(SparseMat *_m, const int *idx)
the full constructor setting the iterator to the specified sparse matrix element
cv::SparseMatIterator::SparseMatIterator
SparseMatIterator()
the default constructor
cv::SparseMatIterator::node
SparseMat::Node * node() const
returns pointer to the current sparse matrix node. it.node->idx is the index of the current element (...
cv::SparseMatIterator::SparseMatIterator
SparseMatIterator(const SparseMatIterator &it)
the copy constructor
cv::SparseMatIterator::SparseMatIterator
SparseMatIterator(SparseMat *_m)
the full constructor setting the iterator to the first sparse matrix element
cv::SparseMatIterator::value
_Tp & value() const
returns read-write reference to the current sparse matrix element
cv::UMat
Definition: mat.hpp:2402
cv::UMat::updateContinuityFlag
void updateContinuityFlag()
internal use method: updates the continuity flag
cv::UMat::UMat
UMat(const std::vector< _Tp > &vec, bool copyData=false)
builds matrix from std::vector with or without copying the data
cv::UMat::UMat
UMat(int rows, int cols, int type, const Scalar &s, UMatUsageFlags usageFlags=USAGE_DEFAULT)
constructs 2D matrix and fills it with the specified value _s.
cv::UMat::cols
int cols
number of columns in the matrix; -1 when the matrix has more than 2 dimensions
Definition: mat.hpp:2592
cv::UMat::allocator
MatAllocator * allocator
custom allocator
Definition: mat.hpp:2595
cv::UMat::getStdAllocator
static MatAllocator * getStdAllocator()
and the standard allocator
cv::UMat::adjustROI
UMat & adjustROI(int dtop, int dbottom, int dleft, int dright)
moves/resizes the current matrix ROI inside the parent matrix.
cv::UMat::copySize
void copySize(const UMat &m)
internal use function; properly re-allocates _size, _step arrays
cv::UMat::elemSize1
size_t elemSize1() const
returns the size of element channel in bytes.
cv::UMat::elemSize
size_t elemSize() const
returns element size in bytes,
cv::UMat::checkVector
int checkVector(int elemChannels, int depth=-1, bool requireContinuous=true) const
returns N if the matrix is 1-channel (N x ptdim) or ptdim-channel (1 x N) or (N x 1); negative number...
cv::UMat::diag
UMat diag(int d=0) const
cv::UMat::row
UMat row(int y) const
returns a new matrix header for the specified row
cv::UMat::UMat
UMat(UMatUsageFlags usageFlags=USAGE_DEFAULT) CV_NOEXCEPT
default constructor
cv::UMat::channels
int channels() const
returns element type, similar to CV_MAT_CN(cvmat->type)
cv::UMat::step1
size_t step1(int i=0) const
returns step/elemSize1()
cv::UMat::type
int type() const
returns element type, similar to CV_MAT_TYPE(cvmat->type)
cv::UMat::locateROI
void locateROI(Size &wholeSize, Point &ofs) const
locates matrix header within a parent matrix. See below
cv::UMat::UMat
UMat(const UMat &m)
copy constructor
cv::UMat::size
MatSize size
dimensional size of the matrix; accessible in various formats
Definition: mat.hpp:2613
cv::UMat::dims
int dims
the matrix dimensionality, >= 2
Definition: mat.hpp:2586
cv::UMat::rows
int rows
number of rows in the matrix; -1 when the matrix has more than 2 dimensions
Definition: mat.hpp:2589
cv::UMat::rowRange
UMat rowRange(int startrow, int endrow) const
... for the specified row span
cv::UMat::operator()
UMat operator()(Range rowRange, Range colRange) const
extracts a rectangular sub-matrix
cv::UMat::depth
int depth() const
returns element type, similar to CV_MAT_DEPTH(cvmat->type)
cv::UMat::deallocate
void deallocate()
deallocates the matrix data
cv::UMat::empty
bool empty() const
returns true if matrix data is NULL
cv::UMat::step
MatStep step
number of bytes each matrix element/row/plane/dimension occupies
Definition: mat.hpp:2616
cv::UMat::diag
static UMat diag(const UMat &d, UMatUsageFlags usageFlags)
constructs a square diagonal matrix which main diagonal is vector "d"
cv::UMat::addref
void addref()
increases the reference counter; use with care to avoid memleaks
cv::UMat::handle
void * handle(AccessFlag accessFlags) const
cv::UMat::usageFlags
UMatUsageFlags usageFlags
usage flags for allocator; recommend do not set directly, instead set during construct/create/getUMat
Definition: mat.hpp:2598
cv::UMat::release
void release()
decreases reference counter;
cv::UMat::col
UMat col(int x) const
returns a new matrix header for the specified column
cv::UMat::clone
UMat clone() const CV_NODISCARD
returns deep copy of the matrix, i.e. the data is copied
cv::UMat::total
size_t total() const
returns the total number of matrix elements
cv::UMat::~UMat
~UMat()
destructor - calls release()
cv::UMat::isSubmatrix
bool isSubmatrix() const
returns true if the matrix is a submatrix of another matrix
cv::UMat::u
UMatData * u
black-box container of UMat data
Definition: mat.hpp:2607
cv::UMat::flags
int flags
Definition: mat.hpp:2583
cv::UMat::colRange
UMat colRange(int startcol, int endcol) const
... for the specified column span
cv::UMat::UMat
UMat(int rows, int cols, int type, UMatUsageFlags usageFlags=USAGE_DEFAULT)
constructs 2D matrix of the specified size and type
cv::UMat::offset
size_t offset
offset of the submatrix (or 0)
Definition: mat.hpp:2610
cv::UMat::UMat
UMat(int ndims, const int *sizes, int type, UMatUsageFlags usageFlags=USAGE_DEFAULT)
constructs n-dimensional matrix
cv::UMat::isContinuous
bool isContinuous() const
returns true iff the matrix data is continuous
cv::UMat::create
void create(int rows, int cols, int type, UMatUsageFlags usageFlags=USAGE_DEFAULT)
allocates new matrix data unless the matrix already has specified size and type.
cv::UMat::UMat
UMat(const UMat &m, const Range &rowRange, const Range &colRange=Range::all())
creates a matrix header for a part of the bigger matrix
cv::Vec
Template class for short numerical vectors, a partial case of Matx
Definition: matx.hpp:342
cv::cuda::GpuMat
Base storage class for GPU memory with reference counting.
Definition: core/cuda.hpp:106
cv::cuda::HostMem
Class with reference counting wrapping special memory type allocation functions from CUDA.
Definition: core/cuda.hpp:731
cv::ogl::Buffer
Smart pointer for OpenGL buffer object with reference counting.
Definition: opengl.hpp:80
cv::copyTo
void CV_EXPORTS_W copyTo(InputArray src, OutputArray dst, InputArray mask)
This is an overloaded member function, provided for convenience (python) Copies the matrix to another...
cv::max
CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst)
Calculates per-element maximum of two arrays or an array and a scalar.
cv::invert
CV_EXPORTS_W double invert(InputArray src, OutputArray dst, int flags=DECOMP_LU)
Finds the inverse or pseudo-inverse of a matrix.
cv::transpose
CV_EXPORTS_W void transpose(InputArray src, OutputArray dst)
Transposes a matrix.
cv::min
CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst)
Calculates per-element minimum of two arrays or an array and a scalar.
cv::add
CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
Calculates the per-element sum of two arrays or an array and a scalar.
cv::divide
CV_EXPORTS_W void divide(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
Performs per-element division of two arrays or a scalar by an array.
cv::multiply
CV_EXPORTS_W void multiply(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
Calculates the per-element scaled product of two arrays.
cv::subtract
CV_EXPORTS_W void subtract(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1)
Calculates the per-element difference between two arrays or array and a scalar.
cv::DECOMP_LU
@ DECOMP_LU
Definition: base.hpp:135
cv::rawInOut
static _InputOutputArray rawInOut(_Tp &v)
cv::rawIn
static _InputArray rawIn(_Tp &v)
cv::UMatUsageFlags
UMatUsageFlags
Usage flags for allocator
Definition: mat.hpp:454
cv::rawOut
static _OutputArray rawOut(_Tp &v)
cv::operator|
CV_INLINE v_reg< _Tp, n > operator|(const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
Bitwise OR
cv::operator&
CV_INLINE v_reg< _Tp, n > operator&(const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
Bitwise AND
cv::operator/
CV_INLINE v_reg< _Tp, n > operator/(const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
Divide values
cv::operator~
CV_INLINE v_reg< _Tp, n > operator~(const v_reg< _Tp, n > &a)
Bitwise NOT
cv::operator^
CV_INLINE v_reg< _Tp, n > operator^(const v_reg< _Tp, n > &a, const v_reg< _Tp, n > &b)
Bitwise XOR
cv::abs
softfloat abs(softfloat a)
Absolute value
Definition: softfloat.hpp:444
cv::swap
CV_EXPORTS void swap(Mat &a, Mat &b)
Swaps two matrices
cv::resize
CV_EXPORTS_W void resize(InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)
Resizes an image.
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::inv
DualQuat< T > inv(const DualQuat< T > &dq, QuatAssumeType assumeUnit=QUAT_ASSUME_NOT_UNIT)
Definition: dualquaternion.inl.hpp:187
cv::MatSize
Definition: mat.hpp:578
cv::MatStep
Definition: mat.hpp:592
cv::SparseMat::Hdr
the sparse matrix header
Definition: mat.hpp:2713
cv::SparseMat::Node
sparse matrix node - element of a hash table
Definition: mat.hpp:2729
cv::SparseMat::Node::hashval
size_t hashval
hash value
Definition: mat.hpp:2731
cv::SparseMat::Node::next
size_t next
index of the next node in the same hash table entry
Definition: mat.hpp:2733
cv::UMatData
Definition: mat.hpp:535
構築: doxygen 1.9.2