mirror of https://github.com/opencv/opencv.git
Andrey Kamaev
13 years ago
parent
77717e1abc
commit
3a1f85d4e8
41 changed files with 2401 additions and 4806 deletions
@ -1 +1 @@ |
||||
#include "cap_ffmpeg_impl_v2.hpp" |
||||
#include "cap_ffmpeg_impl.hpp" |
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -1,161 +1,161 @@ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other GpuMaterials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#ifndef __OPENCV_CORE_DevMem2D_HPP__ |
||||
#define __OPENCV_CORE_DevMem2D_HPP__ |
||||
|
||||
#ifdef __cplusplus |
||||
|
||||
#ifdef __CUDACC__ |
||||
#define __CV_GPU_HOST_DEVICE__ __host__ __device__ __forceinline__ |
||||
#else |
||||
#define __CV_GPU_HOST_DEVICE__ |
||||
#endif |
||||
|
||||
namespace cv |
||||
{ |
||||
namespace gpu |
||||
{ |
||||
// Simple lightweight structures that encapsulates information about an image on device.
|
||||
// It is intended to pass to nvcc-compiled code. GpuMat depends on headers that nvcc can't compile
|
||||
|
||||
template <bool expr> struct StaticAssert; |
||||
template <> struct StaticAssert<true> {static __CV_GPU_HOST_DEVICE__ void check(){}}; |
||||
|
||||
template<typename T> struct DevPtr |
||||
{ |
||||
typedef T elem_type; |
||||
typedef int index_type; |
||||
|
||||
enum { elem_size = sizeof(elem_type) }; |
||||
|
||||
T* data; |
||||
|
||||
__CV_GPU_HOST_DEVICE__ DevPtr() : data(0) {} |
||||
__CV_GPU_HOST_DEVICE__ DevPtr(T* data_) : data(data_) {} |
||||
|
||||
__CV_GPU_HOST_DEVICE__ size_t elemSize() const { return elem_size; } |
||||
__CV_GPU_HOST_DEVICE__ operator T*() { return data; } |
||||
__CV_GPU_HOST_DEVICE__ operator const T*() const { return data; } |
||||
}; |
||||
|
||||
template<typename T> struct PtrSz : public DevPtr<T> |
||||
{ |
||||
__CV_GPU_HOST_DEVICE__ PtrSz() : size(0) {} |
||||
__CV_GPU_HOST_DEVICE__ PtrSz(T* data_, size_t size_) : DevPtr<T>(data_), size(size_) {} |
||||
|
||||
size_t size; |
||||
}; |
||||
|
||||
template<typename T> struct PtrStep : public DevPtr<T> |
||||
{ |
||||
__CV_GPU_HOST_DEVICE__ PtrStep() : step(0) {} |
||||
__CV_GPU_HOST_DEVICE__ PtrStep(T* data_, size_t step_) : DevPtr<T>(data_), step(step_) {} |
||||
|
||||
/** \brief stride between two consecutive rows in bytes. Step is stored always and everywhere in bytes!!! */ |
||||
size_t step; |
||||
|
||||
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0) { return ( T*)( ( char*)DevPtr<T>::data + y * step); } |
||||
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const { return (const T*)( (const char*)DevPtr<T>::data + y * step); } |
||||
|
||||
__CV_GPU_HOST_DEVICE__ T& operator ()(int y, int x) { return ptr(y)[x]; } |
||||
__CV_GPU_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; } |
||||
}; |
||||
|
||||
template <typename T> struct PtrStepSz : public PtrStep<T> |
||||
{ |
||||
__CV_GPU_HOST_DEVICE__ PtrStepSz() : cols(0), rows(0) {} |
||||
__CV_GPU_HOST_DEVICE__ PtrStepSz(int rows_, int cols_, T* data_, size_t step_) |
||||
: PtrStep<T>(data_, step_), cols(cols_), rows(rows_) {} |
||||
|
||||
int cols; |
||||
int rows; |
||||
}; |
||||
|
||||
template <typename T> struct DevMem2D_ : public PtrStepSz<T> |
||||
{ |
||||
DevMem2D_() {} |
||||
DevMem2D_(int rows_, int cols_, T* data_, size_t step_) : PtrStepSz<T>(rows_, cols_, data_, step_) {} |
||||
|
||||
template <typename U> |
||||
explicit DevMem2D_(const DevMem2D_<U>& d) : PtrStepSz<T>(d.rows, d.cols, (T*)d.data, d.step) {} |
||||
}; |
||||
|
||||
template<typename T> struct PtrElemStep_ : public PtrStep<T> |
||||
{ |
||||
PtrElemStep_(const DevMem2D_<T>& mem) : PtrStep<T>(mem.data, mem.step) |
||||
{ |
||||
StaticAssert<256 % sizeof(T) == 0>::check(); |
||||
|
||||
PtrStep<T>::step /= PtrStep<T>::elem_size; |
||||
} |
||||
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0) { return PtrStep<T>::data + y * PtrStep<T>::step; } |
||||
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const { return PtrStep<T>::data + y * PtrStep<T>::step; } |
||||
|
||||
__CV_GPU_HOST_DEVICE__ T& operator ()(int y, int x) { return ptr(y)[x]; } |
||||
__CV_GPU_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; } |
||||
}; |
||||
|
||||
template<typename T> struct PtrStep_ : public PtrStep<T> |
||||
{ |
||||
PtrStep_() {} |
||||
PtrStep_(const DevMem2D_<T>& mem) : PtrStep<T>(mem.data, mem.step) {} |
||||
}; |
||||
|
||||
typedef DevMem2D_<unsigned char> DevMem2Db; |
||||
typedef DevMem2Db DevMem2D; |
||||
typedef DevMem2D_<float> DevMem2Df; |
||||
typedef DevMem2D_<int> DevMem2Di; |
||||
|
||||
typedef PtrStep<unsigned char> PtrStepb; |
||||
typedef PtrStep<float> PtrStepf; |
||||
typedef PtrStep<int> PtrStepi; |
||||
|
||||
typedef PtrElemStep_<unsigned char> PtrElemStep; |
||||
typedef PtrElemStep_<float> PtrElemStepf; |
||||
typedef PtrElemStep_<int> PtrElemStepi; |
||||
} |
||||
} |
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif /* __OPENCV_GPU_DevMem2D_HPP__ */ |
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other GpuMaterials provided with the distribution.
|
||||
//
|
||||
// * The name of the copyright holders may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#ifndef __OPENCV_CORE_DevMem2D_HPP__ |
||||
#define __OPENCV_CORE_DevMem2D_HPP__ |
||||
|
||||
#ifdef __cplusplus |
||||
|
||||
#ifdef __CUDACC__ |
||||
#define __CV_GPU_HOST_DEVICE__ __host__ __device__ __forceinline__ |
||||
#else |
||||
#define __CV_GPU_HOST_DEVICE__ |
||||
#endif |
||||
|
||||
namespace cv |
||||
{ |
||||
namespace gpu |
||||
{ |
||||
// Simple lightweight structures that encapsulates information about an image on device.
|
||||
// It is intended to pass to nvcc-compiled code. GpuMat depends on headers that nvcc can't compile
|
||||
|
||||
template <bool expr> struct StaticAssert; |
||||
template <> struct StaticAssert<true> {static __CV_GPU_HOST_DEVICE__ void check(){}}; |
||||
|
||||
template<typename T> struct DevPtr |
||||
{ |
||||
typedef T elem_type; |
||||
typedef int index_type; |
||||
|
||||
enum { elem_size = sizeof(elem_type) }; |
||||
|
||||
T* data; |
||||
|
||||
__CV_GPU_HOST_DEVICE__ DevPtr() : data(0) {} |
||||
__CV_GPU_HOST_DEVICE__ DevPtr(T* data_) : data(data_) {} |
||||
|
||||
__CV_GPU_HOST_DEVICE__ size_t elemSize() const { return elem_size; } |
||||
__CV_GPU_HOST_DEVICE__ operator T*() { return data; } |
||||
__CV_GPU_HOST_DEVICE__ operator const T*() const { return data; } |
||||
}; |
||||
|
||||
template<typename T> struct PtrSz : public DevPtr<T> |
||||
{ |
||||
__CV_GPU_HOST_DEVICE__ PtrSz() : size(0) {} |
||||
__CV_GPU_HOST_DEVICE__ PtrSz(T* data_, size_t size_) : DevPtr<T>(data_), size(size_) {} |
||||
|
||||
size_t size; |
||||
}; |
||||
|
||||
template<typename T> struct PtrStep : public DevPtr<T> |
||||
{ |
||||
__CV_GPU_HOST_DEVICE__ PtrStep() : step(0) {} |
||||
__CV_GPU_HOST_DEVICE__ PtrStep(T* data_, size_t step_) : DevPtr<T>(data_), step(step_) {} |
||||
|
||||
/** \brief stride between two consecutive rows in bytes. Step is stored always and everywhere in bytes!!! */ |
||||
size_t step; |
||||
|
||||
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0) { return ( T*)( ( char*)DevPtr<T>::data + y * step); } |
||||
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const { return (const T*)( (const char*)DevPtr<T>::data + y * step); } |
||||
|
||||
__CV_GPU_HOST_DEVICE__ T& operator ()(int y, int x) { return ptr(y)[x]; } |
||||
__CV_GPU_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; } |
||||
}; |
||||
|
||||
template <typename T> struct PtrStepSz : public PtrStep<T> |
||||
{ |
||||
__CV_GPU_HOST_DEVICE__ PtrStepSz() : cols(0), rows(0) {} |
||||
__CV_GPU_HOST_DEVICE__ PtrStepSz(int rows_, int cols_, T* data_, size_t step_) |
||||
: PtrStep<T>(data_, step_), cols(cols_), rows(rows_) {} |
||||
|
||||
int cols; |
||||
int rows; |
||||
}; |
||||
|
||||
template <typename T> struct DevMem2D_ : public PtrStepSz<T> |
||||
{ |
||||
DevMem2D_() {} |
||||
DevMem2D_(int rows_, int cols_, T* data_, size_t step_) : PtrStepSz<T>(rows_, cols_, data_, step_) {} |
||||
|
||||
template <typename U> |
||||
explicit DevMem2D_(const DevMem2D_<U>& d) : PtrStepSz<T>(d.rows, d.cols, (T*)d.data, d.step) {} |
||||
}; |
||||
|
||||
template<typename T> struct PtrElemStep_ : public PtrStep<T> |
||||
{ |
||||
PtrElemStep_(const DevMem2D_<T>& mem) : PtrStep<T>(mem.data, mem.step) |
||||
{ |
||||
StaticAssert<256 % sizeof(T) == 0>::check(); |
||||
|
||||
PtrStep<T>::step /= PtrStep<T>::elem_size; |
||||
} |
||||
__CV_GPU_HOST_DEVICE__ T* ptr(int y = 0) { return PtrStep<T>::data + y * PtrStep<T>::step; } |
||||
__CV_GPU_HOST_DEVICE__ const T* ptr(int y = 0) const { return PtrStep<T>::data + y * PtrStep<T>::step; } |
||||
|
||||
__CV_GPU_HOST_DEVICE__ T& operator ()(int y, int x) { return ptr(y)[x]; } |
||||
__CV_GPU_HOST_DEVICE__ const T& operator ()(int y, int x) const { return ptr(y)[x]; } |
||||
}; |
||||
|
||||
template<typename T> struct PtrStep_ : public PtrStep<T> |
||||
{ |
||||
PtrStep_() {} |
||||
PtrStep_(const DevMem2D_<T>& mem) : PtrStep<T>(mem.data, mem.step) {} |
||||
}; |
||||
|
||||
typedef DevMem2D_<unsigned char> DevMem2Db; |
||||
typedef DevMem2Db DevMem2D; |
||||
typedef DevMem2D_<float> DevMem2Df; |
||||
typedef DevMem2D_<int> DevMem2Di; |
||||
|
||||
typedef PtrStep<unsigned char> PtrStepb; |
||||
typedef PtrStep<float> PtrStepf; |
||||
typedef PtrStep<int> PtrStepi; |
||||
|
||||
typedef PtrElemStep_<unsigned char> PtrElemStep; |
||||
typedef PtrElemStep_<float> PtrElemStepf; |
||||
typedef PtrElemStep_<int> PtrElemStepi; |
||||
} |
||||
} |
||||
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif /* __OPENCV_GPU_DevMem2D_HPP__ */ |
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,325 +0,0 @@ |
||||
Planar Subdivisions (C API) |
||||
============================ |
||||
|
||||
.. highlight:: c |
||||
|
||||
CvSubdiv2D |
||||
---------- |
||||
|
||||
.. ocv:struct:: CvSubdiv2D |
||||
|
||||
Planar subdivision. |
||||
|
||||
:: |
||||
|
||||
#define CV_SUBDIV2D_FIELDS() \ |
||||
CV_GRAPH_FIELDS() \ |
||||
int quad_edges; \ |
||||
int is_geometry_valid; \ |
||||
CvSubdiv2DEdge recent_edge; \ |
||||
CvPoint2D32f topleft; \ |
||||
CvPoint2D32f bottomright; |
||||
|
||||
typedef struct CvSubdiv2D |
||||
{ |
||||
CV_SUBDIV2D_FIELDS() |
||||
} |
||||
CvSubdiv2D; |
||||
|
||||
.. |
||||
|
||||
Planar subdivision is the subdivision of a plane into a set of |
||||
non-overlapped regions (facets) that cover the whole plane. The above |
||||
structure describes a subdivision built on a 2D point set, where the points |
||||
are linked together and form a planar graph, which, together with a few |
||||
edges connecting the exterior subdivision points (namely, convex hull points) |
||||
with infinity, subdivides a plane into facets by its edges. |
||||
|
||||
For every subdivision, there is a dual subdivision in which facets and |
||||
points (subdivision vertices) swap their roles. This means that a facet is |
||||
treated as a vertex (called a virtual point below) of the dual subdivision and |
||||
the original subdivision vertices become facets. In the figure below, the |
||||
original subdivision is marked with solid lines and dual subdivision - |
||||
with dotted lines. |
||||
|
||||
.. image:: pics/subdiv.png |
||||
|
||||
OpenCV subdivides a plane into triangles using the Delaunay's |
||||
algorithm. Subdivision is built iteratively starting from a dummy |
||||
triangle that includes all the subdivision points for sure. In this |
||||
case, the dual subdivision is a Voronoi diagram of the input 2D point set. The |
||||
subdivisions can be used for the 3D piece-wise transformation of a plane, |
||||
morphing, fast location of points on the plane, building special graphs |
||||
(such as NNG,RNG), and so forth. |
||||
|
||||
CvQuadEdge2D |
||||
------------ |
||||
|
||||
.. ocv:struct:: CvQuadEdge2D |
||||
|
||||
Quad-edge of a planar subdivision. |
||||
|
||||
:: |
||||
|
||||
/* one of edges within quad-edge, lower 2 bits is index (0..3) |
||||
and upper bits are quad-edge pointer */ |
||||
typedef long CvSubdiv2DEdge; |
||||
|
||||
/* quad-edge structure fields */ |
||||
#define CV_QUADEDGE2D_FIELDS() \ |
||||
int flags; \ |
||||
struct CvSubdiv2DPoint* pt[4]; \ |
||||
CvSubdiv2DEdge next[4]; |
||||
|
||||
typedef struct CvQuadEdge2D |
||||
{ |
||||
CV_QUADEDGE2D_FIELDS() |
||||
} |
||||
CvQuadEdge2D; |
||||
|
||||
.. |
||||
|
||||
Quad-edge is a basic element of a subdivision containing four edges (e, eRot, reversed e, and reversed eRot): |
||||
|
||||
.. image:: pics/quadedge.png |
||||
|
||||
CvSubdiv2DPoint |
||||
--------------- |
||||
|
||||
.. ocv:struct:: CvSubdiv2DPoint |
||||
|
||||
Point of an original or dual subdivision. |
||||
|
||||
:: |
||||
|
||||
#define CV_SUBDIV2D_POINT_FIELDS()\ |
||||
int flags; \ |
||||
CvSubdiv2DEdge first; \ |
||||
CvPoint2D32f pt; \ |
||||
int id; |
||||
|
||||
#define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30) |
||||
|
||||
typedef struct CvSubdiv2DPoint |
||||
{ |
||||
CV_SUBDIV2D_POINT_FIELDS() |
||||
} |
||||
CvSubdiv2DPoint; |
||||
|
||||
.. |
||||
|
||||
* id |
||||
This integer can be used to index auxiliary data associated with each vertex of the planar subdivision. |
||||
|
||||
CalcSubdivVoronoi2D |
||||
------------------- |
||||
Calculates the coordinates of the Voronoi diagram cells. |
||||
|
||||
.. ocv:cfunction:: void cvCalcSubdivVoronoi2D( CvSubdiv2D* subdiv ) |
||||
.. ocv:pyoldfunction:: cv.CalcSubdivVoronoi2D(subdiv)-> None |
||||
|
||||
:param subdiv: Delaunay subdivision, in which all the points are already added. |
||||
|
||||
The function calculates the coordinates |
||||
of virtual points. All virtual points corresponding to a vertex of the |
||||
original subdivision form (when connected together) a boundary of the Voronoi |
||||
cell at that point. |
||||
|
||||
ClearSubdivVoronoi2D |
||||
-------------------- |
||||
Removes all virtual points. |
||||
|
||||
.. ocv:cfunction:: void cvClearSubdivVoronoi2D( CvSubdiv2D* subdiv ) |
||||
.. ocv:pyoldfunction:: cv.ClearSubdivVoronoi2D(subdiv)-> None |
||||
|
||||
:param subdiv: Delaunay subdivision. |
||||
|
||||
The function removes all of the virtual points. It |
||||
is called internally in |
||||
:ocv:cfunc:`CalcSubdivVoronoi2D` |
||||
if the subdivision |
||||
was modified after the previous call to the function. |
||||
|
||||
CreateSubdivDelaunay2D |
||||
---------------------- |
||||
Creates an empty Delaunay triangulation. |
||||
|
||||
.. ocv:cfunction:: CvSubdiv2D* cvCreateSubdivDelaunay2D( CvRect rect, CvMemStorage* storage ) |
||||
.. ocv:pyoldfunction:: cv.CreateSubdivDelaunay2D(rect, storage)-> emptyDelaunayTriangulation |
||||
|
||||
:param rect: Rectangle that includes all of the 2D points that are to be added to the subdivision. |
||||
|
||||
:param storage: Container for the subdivision. |
||||
|
||||
The function creates an empty Delaunay |
||||
subdivision where 2D points can be added using the function |
||||
:ocv:cfunc:`SubdivDelaunay2DInsert` |
||||
. All of the points to be added must be within |
||||
the specified rectangle, otherwise a runtime error is raised. |
||||
|
||||
Note that the triangulation is a single large triangle that covers the given rectangle. Hence the three vertices of this triangle are outside the rectangle |
||||
``rect`` |
||||
. |
||||
|
||||
FindNearestPoint2D |
||||
------------------ |
||||
Finds the subdivision vertex closest to the given point. |
||||
|
||||
.. ocv:cfunction:: CvSubdiv2DPoint* cvFindNearestPoint2D( CvSubdiv2D* subdiv, CvPoint2D32f pt ) |
||||
.. ocv:pyoldfunction:: cv.FindNearestPoint2D(subdiv, pt)-> point |
||||
|
||||
:param subdiv: Delaunay or another subdivision. |
||||
|
||||
:param pt: Input point. |
||||
|
||||
The function is another function that |
||||
locates the input point within the subdivision. It finds the subdivision vertex that |
||||
is the closest to the input point. It is not necessarily one of vertices |
||||
of the facet containing the input point, though the facet (located using |
||||
:ocv:cfunc:`Subdiv2DLocate` |
||||
) is used as a starting |
||||
point. The function returns a pointer to the found subdivision vertex. |
||||
|
||||
Subdiv2DEdgeDst |
||||
--------------- |
||||
Returns the edge destination. |
||||
|
||||
.. ocv:cfunction:: CvSubdiv2DPoint* cvSubdiv2DEdgeDst( CvSubdiv2DEdge edge ) |
||||
.. ocv:pyoldfunction:: cv.Subdiv2DEdgeDst(edge)-> point |
||||
|
||||
:param edge: Subdivision edge (not a quad-edge). |
||||
|
||||
The function returns the edge destination. The |
||||
returned pointer may be NULL if the edge is from a dual subdivision and |
||||
the virtual point coordinates are not calculated yet. The virtual points |
||||
can be calculated using the function |
||||
:ocv:cfunc:`CalcSubdivVoronoi2D`. |
||||
|
||||
Subdiv2DGetEdge |
||||
--------------- |
||||
Returns one of the edges related to the given edge. |
||||
|
||||
.. ocv:cfunction:: CvSubdiv2DEdge cvSubdiv2DGetEdge( CvSubdiv2DEdge edge, CvNextEdgeType type ) |
||||
.. ocv:pyoldfunction:: cv.Subdiv2DGetEdge(edge, type)-> CvSubdiv2DEdge |
||||
|
||||
:param edge: Subdivision edge (not a quad-edge). |
||||
|
||||
:param type: Parameter specifying which of the related edges to return. The following values are possible: |
||||
|
||||
* **CV_NEXT_AROUND_ORG** next around the edge origin ( ``eOnext`` on the picture below if ``e`` is the input edge) |
||||
|
||||
* **CV_NEXT_AROUND_DST** next around the edge vertex ( ``eDnext`` ) |
||||
|
||||
* **CV_PREV_AROUND_ORG** previous around the edge origin (reversed ``eRnext`` ) |
||||
|
||||
* **CV_PREV_AROUND_DST** previous around the edge destination (reversed ``eLnext`` ) |
||||
|
||||
* **CV_NEXT_AROUND_LEFT** next around the left facet ( ``eLnext`` ) |
||||
|
||||
* **CV_NEXT_AROUND_RIGHT** next around the right facet ( ``eRnext`` ) |
||||
|
||||
* **CV_PREV_AROUND_LEFT** previous around the left facet (reversed ``eOnext`` ) |
||||
|
||||
* **CV_PREV_AROUND_RIGHT** previous around the right facet (reversed ``eDnext`` ) |
||||
|
||||
.. image:: pics/quadedge.png |
||||
|
||||
The function returns one of the edges related to the input edge. |
||||
|
||||
Subdiv2DNextEdge |
||||
---------------- |
||||
Returns next edge around the edge origin. |
||||
|
||||
.. ocv:cfunction:: CvSubdiv2DEdge cvSubdiv2DNextEdge( CvSubdiv2DEdge edge ) |
||||
.. ocv:pyoldfunction:: cv.Subdiv2DNextEdge(edge)-> CvSubdiv2DEdge |
||||
|
||||
:param edge: Subdivision edge (not a quad-edge). |
||||
|
||||
The function returns the next edge around the edge origin: |
||||
``eOnext`` |
||||
on the picture above if |
||||
``e`` |
||||
is the input edge). |
||||
|
||||
Subdiv2DLocate |
||||
-------------- |
||||
Returns the location of a point within a Delaunay triangulation. |
||||
|
||||
.. ocv:cfunction:: CvSubdiv2DPointLocation cvSubdiv2DLocate( CvSubdiv2D* subdiv, CvPoint2D32f pt, CvSubdiv2DEdge* edge, CvSubdiv2DPoint** vertex=NULL ) |
||||
.. ocv:pyoldfunction:: cv.Subdiv2DLocate(subdiv, pt) -> (loc, where) |
||||
|
||||
:param subdiv: Delaunay or another subdivision. |
||||
|
||||
:param pt: Point to locate. |
||||
|
||||
:param edge: Output edge that the point belongs to or is located to the right of it. |
||||
|
||||
:param vertex: Optional output vertex double pointer the input point coincides with. |
||||
|
||||
The function locates the input point within the subdivision. There are five cases: |
||||
|
||||
* |
||||
The point falls into some facet. The function returns |
||||
``CV_PTLOC_INSIDE`` |
||||
and |
||||
``*edge`` |
||||
will contain one of edges of the facet. |
||||
|
||||
* |
||||
The point falls onto the edge. The function returns |
||||
``CV_PTLOC_ON_EDGE`` |
||||
and |
||||
``*edge`` |
||||
will contain this edge. |
||||
|
||||
* |
||||
The point coincides with one of the subdivision vertices. The function returns |
||||
``CV_PTLOC_VERTEX`` |
||||
and |
||||
``*vertex`` |
||||
will contain a pointer to the vertex. |
||||
|
||||
* |
||||
The point is outside the subdivision reference rectangle. The function returns |
||||
``CV_PTLOC_OUTSIDE_RECT`` |
||||
and no pointers are filled. |
||||
|
||||
* |
||||
One of input arguments is invalid. A runtime error is raised or, if silent or "parent" error processing mode is selected, |
||||
``CV_PTLOC_ERROR`` |
||||
is returnd. |
||||
|
||||
Subdiv2DRotateEdge |
||||
------------------ |
||||
Returns another edge of the same quad-edge. |
||||
|
||||
.. ocv:cfunction:: CvSubdiv2DEdge cvSubdiv2DRotateEdge( CvSubdiv2DEdge edge, int rotate ) |
||||
.. ocv:pyoldfunction:: cv.Subdiv2DRotateEdge(edge, rotate)-> CvSubdiv2DEdge |
||||
|
||||
:param edge: Subdivision edge (not a quad-edge). |
||||
|
||||
:param rotate: Parameter specifying which of the edges of the same quad-edge as the input one to return. The following values are possible: |
||||
|
||||
* **0** the input edge ( ``e`` on the picture below if ``e`` is the input edge) |
||||
|
||||
* **1** the rotated edge ( ``eRot`` ) |
||||
|
||||
* **2** the reversed edge (reversed ``e`` (in green)) |
||||
|
||||
* **3** the reversed rotated edge (reversed ``eRot`` (in green)) |
||||
|
||||
The function returns one of the edges of the same quad-edge as the input edge. |
||||
|
||||
SubdivDelaunay2DInsert |
||||
---------------------- |
||||
Inserts a single point into a Delaunay triangulation. |
||||
|
||||
.. ocv:cfunction:: CvSubdiv2DPoint* cvSubdivDelaunay2DInsert( CvSubdiv2D* subdiv, CvPoint2D32f pt) |
||||
.. ocv:pyoldfunction:: cv.SubdivDelaunay2DInsert(subdiv, pt)-> point |
||||
|
||||
:param subdiv: Delaunay subdivision created by the function :ocv:cfunc:`CreateSubdivDelaunay2D`. |
||||
|
||||
:param pt: Inserted point. |
||||
|
||||
The function inserts a single point into a subdivision and modifies the subdivision topology appropriately. If a point with the same coordinates exists already, no new point is added. The function returns a pointer to the allocated point. No virtual point coordinates are calculated at this stage. |
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,457 +1,442 @@ |
||||
#include "converters.h" |
||||
|
||||
#ifdef DEBUG |
||||
#include <android/log.h> |
||||
#define MODULE_LOG_TAG "OpenCV.converters" |
||||
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__)) |
||||
#else //DEBUG
|
||||
#define LOGD(...) |
||||
#endif //DEBUG
|
||||
|
||||
using namespace cv; |
||||
|
||||
#define CHECK_MAT(cond) if(!(cond)){ LOGD("FAILED: " #cond); return; } |
||||
|
||||
|
||||
// vector_int
|
||||
|
||||
void Mat_to_vector_int(Mat& mat, vector<int>& v_int) |
||||
{ |
||||
v_int.clear(); |
||||
CHECK_MAT(mat.type()==CV_32SC1 && mat.cols==1); |
||||
v_int = (vector<int>) mat; |
||||
} |
||||
|
||||
void vector_int_to_Mat(vector<int>& v_int, Mat& mat) |
||||
{ |
||||
mat = Mat(v_int, true); |
||||
} |
||||
|
||||
|
||||
//vector_double
|
||||
|
||||
void Mat_to_vector_double(Mat& mat, vector<double>& v_double) |
||||
{ |
||||
v_double.clear(); |
||||
CHECK_MAT(mat.type()==CV_64FC1 && mat.cols==1); |
||||
v_double = (vector<double>) mat; |
||||
} |
||||
|
||||
void vector_double_to_Mat(vector<double>& v_double, Mat& mat) |
||||
{ |
||||
mat = Mat(v_double, true); |
||||
} |
||||
|
||||
|
||||
// vector_float
|
||||
|
||||
void Mat_to_vector_float(Mat& mat, vector<float>& v_float) |
||||
{ |
||||
v_float.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC1 && mat.cols==1); |
||||
v_float = (vector<float>) mat; |
||||
} |
||||
|
||||
void vector_float_to_Mat(vector<float>& v_float, Mat& mat) |
||||
{ |
||||
mat = Mat(v_float, true); |
||||
} |
||||
|
||||
|
||||
//vector_uchar
|
||||
|
||||
void Mat_to_vector_uchar(Mat& mat, vector<uchar>& v_uchar) |
||||
{ |
||||
v_uchar.clear(); |
||||
CHECK_MAT(mat.type()==CV_8UC1 && mat.cols==1); |
||||
v_uchar = (vector<uchar>) mat; |
||||
} |
||||
|
||||
void vector_uchar_to_Mat(vector<uchar>& v_uchar, Mat& mat) |
||||
{ |
||||
mat = Mat(v_uchar, true); |
||||
} |
||||
|
||||
void Mat_to_vector_char(Mat& mat, vector<char>& v_char) |
||||
{ |
||||
v_char.clear(); |
||||
CHECK_MAT(mat.type()==CV_8SC1 && mat.cols==1); |
||||
v_char = (vector<char>) mat; |
||||
} |
||||
|
||||
void vector_char_to_Mat(vector<char>& v_char, Mat& mat) |
||||
{ |
||||
mat = Mat(v_char, true); |
||||
} |
||||
|
||||
|
||||
//vector_Rect
|
||||
|
||||
void Mat_to_vector_Rect(Mat& mat, vector<Rect>& v_rect) |
||||
{ |
||||
v_rect.clear(); |
||||
CHECK_MAT(mat.type()==CV_32SC4 && mat.cols==1); |
||||
v_rect = (vector<Rect>) mat; |
||||
} |
||||
|
||||
void vector_Rect_to_Mat(vector<Rect>& v_rect, Mat& mat) |
||||
{ |
||||
mat = Mat(v_rect, true); |
||||
} |
||||
|
||||
|
||||
//vector_Point
|
||||
void Mat_to_vector_Point(Mat& mat, vector<Point>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_32SC2 && mat.cols==1); |
||||
v_point = (vector<Point>) mat; |
||||
} |
||||
|
||||
//vector_Point2f
|
||||
void Mat_to_vector_Point2f(Mat& mat, vector<Point2f>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC2 && mat.cols==1); |
||||
v_point = (vector<Point2f>) mat; |
||||
} |
||||
|
||||
//vector_Point2d
|
||||
void Mat_to_vector_Point2d(Mat& mat, vector<Point2d>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_64FC2 && mat.cols==1); |
||||
v_point = (vector<Point2d>) mat; |
||||
} |
||||
|
||||
|
||||
//vector_Point3i
|
||||
void Mat_to_vector_Point3i(Mat& mat, vector<Point3i>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_32SC3 && mat.cols==1); |
||||
v_point = (vector<Point3i>) mat; |
||||
} |
||||
|
||||
//vector_Point3f
|
||||
void Mat_to_vector_Point3f(Mat& mat, vector<Point3f>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC3 && mat.cols==1); |
||||
v_point = (vector<Point3f>) mat; |
||||
} |
||||
|
||||
//vector_Point3d
|
||||
void Mat_to_vector_Point3d(Mat& mat, vector<Point3d>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_64FC3 && mat.cols==1); |
||||
v_point = (vector<Point3d>) mat; |
||||
} |
||||
|
||||
|
||||
void vector_Point_to_Mat(vector<Point>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point2f_to_Mat(vector<Point2f>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point2d_to_Mat(vector<Point2d>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point3i_to_Mat(vector<Point3i>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point3f_to_Mat(vector<Point3f>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point3d_to_Mat(vector<Point3d>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D |
||||
//vector_KeyPoint
|
||||
void Mat_to_vector_KeyPoint(Mat& mat, vector<KeyPoint>& v_kp) |
||||
{ |
||||
v_kp.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC(7) && mat.cols==1); |
||||
for(int i=0; i<mat.rows; i++) |
||||
{ |
||||
Vec<float, 7> v = mat.at< Vec<float, 7> >(i, 0); |
||||
KeyPoint kp(v[0], v[1], v[2], v[3], v[4], (int)v[5], (int)v[6]); |
||||
v_kp.push_back(kp); |
||||
} |
||||
return; |
||||
} |
||||
|
||||
|
||||
void vector_KeyPoint_to_Mat(vector<KeyPoint>& v_kp, Mat& mat) |
||||
{ |
||||
int count = v_kp.size(); |
||||
mat.create(count, 1, CV_32FC(7)); |
||||
for(int i=0; i<count; i++) |
||||
{ |
||||
KeyPoint kp = v_kp[i]; |
||||
mat.at< Vec<float, 7> >(i, 0) = Vec<float, 7>(kp.pt.x, kp.pt.y, kp.size, kp.angle, kp.response, kp.octave, kp.class_id); |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
|
||||
//vector_Mat
|
||||
void Mat_to_vector_Mat(cv::Mat& mat, std::vector<cv::Mat>& v_mat) |
||||
{ |
||||
v_mat.clear(); |
||||
if(mat.type() == CV_32SC2 && mat.cols == 1) |
||||
{ |
||||
v_mat.reserve(mat.rows); |
||||
for(int i=0; i<mat.rows; i++) |
||||
{ |
||||
Vec<int, 2> a = mat.at< Vec<int, 2> >(i, 0); |
||||
long long addr = (((long long)a[0])<<32) | a[1]; |
||||
Mat& m = *( (Mat*) addr ); |
||||
v_mat.push_back(m); |
||||
} |
||||
} else { |
||||
LOGD("Mat_to_vector_Mat() FAILED: mat.type() == CV_32SC2 && mat.cols == 1"); |
||||
} |
||||
} |
||||
|
||||
|
||||
void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat) |
||||
{ |
||||
int count = v_mat.size(); |
||||
mat.create(count, 1, CV_32SC2); |
||||
for(int i=0; i<count; i++) |
||||
{ |
||||
long long addr = (long long) new Mat(v_mat[i]); |
||||
mat.at< Vec<int, 2> >(i, 0) = Vec<int, 2>(addr>>32, addr&0xffffffff); |
||||
} |
||||
} |
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D |
||||
//vector_DMatch
|
||||
void Mat_to_vector_DMatch(Mat& mat, vector<DMatch>& v_dm) |
||||
{ |
||||
v_dm.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC4 && mat.cols==1); |
||||
for(int i=0; i<mat.rows; i++) |
||||
{ |
||||
Vec<float, 4> v = mat.at< Vec<float, 4> >(i, 0); |
||||
DMatch dm((int)v[0], (int)v[1], (int)v[2], v[3]); |
||||
v_dm.push_back(dm); |
||||
} |
||||
return; |
||||
} |
||||
|
||||
|
||||
void vector_DMatch_to_Mat(vector<DMatch>& v_dm, Mat& mat) |
||||
{ |
||||
int count = v_dm.size(); |
||||
mat.create(count, 1, CV_32FC4); |
||||
for(int i=0; i<count; i++) |
||||
{ |
||||
DMatch dm = v_dm[i]; |
||||
mat.at< Vec<float, 4> >(i, 0) = Vec<float, 4>(dm.queryIdx, dm.trainIdx, dm.imgIdx, dm.distance); |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
void Mat_to_vector_vector_Point(Mat& mat, vector< vector< Point > >& vv_pt) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<Point> vpt; |
||||
Mat_to_vector_Point(vm[i], vpt); |
||||
vv_pt.push_back(vpt); |
||||
} |
||||
} |
||||
|
||||
void Mat_to_vector_vector_Point2f(Mat& mat, vector< vector< Point2f > >& vv_pt) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<Point2f> vpt; |
||||
Mat_to_vector_Point2f(vm[i], vpt); |
||||
vv_pt.push_back(vpt); |
||||
} |
||||
} |
||||
|
||||
void Mat_to_vector_vector_Point3f(Mat& mat, vector< vector< Point3f > >& vv_pt) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<Point3f> vpt; |
||||
Mat_to_vector_Point3f(vm[i], vpt); |
||||
vv_pt.push_back(vpt); |
||||
} |
||||
} |
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D |
||||
void Mat_to_vector_vector_KeyPoint(Mat& mat, vector< vector< KeyPoint > >& vv_kp) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<KeyPoint> vkp; |
||||
Mat_to_vector_KeyPoint(vm[i], vkp); |
||||
vv_kp.push_back(vkp); |
||||
} |
||||
} |
||||
|
||||
void vector_vector_KeyPoint_to_Mat(vector< vector< KeyPoint > >& vv_kp, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_kp.size() ); |
||||
for(size_t i=0; i<vv_kp.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_KeyPoint_to_Mat(vv_kp[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
void Mat_to_vector_vector_DMatch(Mat& mat, vector< vector< DMatch > >& vv_dm) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<DMatch> vdm; |
||||
Mat_to_vector_DMatch(vm[i], vdm); |
||||
vv_dm.push_back(vdm); |
||||
} |
||||
} |
||||
|
||||
void vector_vector_DMatch_to_Mat(vector< vector< DMatch > >& vv_dm, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_dm.size() ); |
||||
for(size_t i=0; i<vv_dm.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_DMatch_to_Mat(vv_dm[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
#endif |
||||
|
||||
void Mat_to_vector_vector_char(Mat& mat, vector< vector< char > >& vv_ch) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<char> vch; |
||||
Mat_to_vector_char(vm[i], vch); |
||||
vv_ch.push_back(vch); |
||||
} |
||||
} |
||||
|
||||
void vector_vector_char_to_Mat(vector< vector< char > >& vv_ch, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_ch.size() ); |
||||
for(size_t i=0; i<vv_ch.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_char_to_Mat(vv_ch[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
void vector_vector_Point_to_Mat(vector< vector< Point > >& vv_pt, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_pt.size() ); |
||||
for(size_t i=0; i<vv_pt.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_Point_to_Mat(vv_pt[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
void vector_vector_Point2f_to_Mat(vector< vector< Point2f > >& vv_pt, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_pt.size() ); |
||||
for(size_t i=0; i<vv_pt.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_Point2f_to_Mat(vv_pt[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
|
||||
void vector_vector_Point_to_Mat(vector< vector< Point > >& vv_pt, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_pt.size() ); |
||||
for(size_t i=0; i<vv_pt.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_Point_to_Mat(vv_pt[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
|
||||
void vector_vector_Point3f_to_Mat(vector< vector< Point3f > >& vv_pt, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_pt.size() ); |
||||
for(size_t i=0; i<vv_pt.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_Point3f_to_Mat(vv_pt[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
void vector_Vec4i_to_Mat(vector<Vec4i>& v_vec, Mat& mat) |
||||
{ |
||||
mat = Mat(v_vec, true); |
||||
} |
||||
|
||||
void vector_Vec4f_to_Mat(vector<Vec4f>& v_vec, Mat& mat) |
||||
{ |
||||
mat = Mat(v_vec, true); |
||||
} |
||||
|
||||
void vector_Vec6f_to_Mat(vector<Vec6f>& v_vec, Mat& mat) |
||||
{ |
||||
mat = Mat(v_vec, true); |
||||
} |
||||
#include "converters.h" |
||||
|
||||
#ifdef DEBUG |
||||
#include <android/log.h> |
||||
#define MODULE_LOG_TAG "OpenCV.converters" |
||||
#define LOGD(...) ((void)__android_log_print(ANDROID_LOG_DEBUG, MODULE_LOG_TAG, __VA_ARGS__)) |
||||
#else //DEBUG
|
||||
#define LOGD(...) |
||||
#endif //DEBUG
|
||||
|
||||
using namespace cv; |
||||
|
||||
#define CHECK_MAT(cond) if(!(cond)){ LOGD("FAILED: " #cond); return; } |
||||
|
||||
|
||||
// vector_int
|
||||
|
||||
void Mat_to_vector_int(Mat& mat, vector<int>& v_int) |
||||
{ |
||||
v_int.clear(); |
||||
CHECK_MAT(mat.type()==CV_32SC1 && mat.cols==1); |
||||
v_int = (vector<int>) mat; |
||||
} |
||||
|
||||
void vector_int_to_Mat(vector<int>& v_int, Mat& mat) |
||||
{ |
||||
mat = Mat(v_int, true); |
||||
} |
||||
|
||||
|
||||
//vector_double
|
||||
|
||||
void Mat_to_vector_double(Mat& mat, vector<double>& v_double) |
||||
{ |
||||
v_double.clear(); |
||||
CHECK_MAT(mat.type()==CV_64FC1 && mat.cols==1); |
||||
v_double = (vector<double>) mat; |
||||
} |
||||
|
||||
void vector_double_to_Mat(vector<double>& v_double, Mat& mat) |
||||
{ |
||||
mat = Mat(v_double, true); |
||||
} |
||||
|
||||
|
||||
// vector_float
|
||||
|
||||
void Mat_to_vector_float(Mat& mat, vector<float>& v_float) |
||||
{ |
||||
v_float.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC1 && mat.cols==1); |
||||
v_float = (vector<float>) mat; |
||||
} |
||||
|
||||
void vector_float_to_Mat(vector<float>& v_float, Mat& mat) |
||||
{ |
||||
mat = Mat(v_float, true); |
||||
} |
||||
|
||||
|
||||
//vector_uchar
|
||||
|
||||
void Mat_to_vector_uchar(Mat& mat, vector<uchar>& v_uchar) |
||||
{ |
||||
v_uchar.clear(); |
||||
CHECK_MAT(mat.type()==CV_8UC1 && mat.cols==1); |
||||
v_uchar = (vector<uchar>) mat; |
||||
} |
||||
|
||||
void vector_uchar_to_Mat(vector<uchar>& v_uchar, Mat& mat) |
||||
{ |
||||
mat = Mat(v_uchar, true); |
||||
} |
||||
|
||||
void Mat_to_vector_char(Mat& mat, vector<char>& v_char) |
||||
{ |
||||
v_char.clear(); |
||||
CHECK_MAT(mat.type()==CV_8SC1 && mat.cols==1); |
||||
v_char = (vector<char>) mat; |
||||
} |
||||
|
||||
void vector_char_to_Mat(vector<char>& v_char, Mat& mat) |
||||
{ |
||||
mat = Mat(v_char, true); |
||||
} |
||||
|
||||
|
||||
//vector_Rect
|
||||
|
||||
void Mat_to_vector_Rect(Mat& mat, vector<Rect>& v_rect) |
||||
{ |
||||
v_rect.clear(); |
||||
CHECK_MAT(mat.type()==CV_32SC4 && mat.cols==1); |
||||
v_rect = (vector<Rect>) mat; |
||||
} |
||||
|
||||
void vector_Rect_to_Mat(vector<Rect>& v_rect, Mat& mat) |
||||
{ |
||||
mat = Mat(v_rect, true); |
||||
} |
||||
|
||||
|
||||
//vector_Point
|
||||
void Mat_to_vector_Point(Mat& mat, vector<Point>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_32SC2 && mat.cols==1); |
||||
v_point = (vector<Point>) mat; |
||||
} |
||||
|
||||
//vector_Point2f
|
||||
void Mat_to_vector_Point2f(Mat& mat, vector<Point2f>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC2 && mat.cols==1); |
||||
v_point = (vector<Point2f>) mat; |
||||
} |
||||
|
||||
//vector_Point2d
|
||||
void Mat_to_vector_Point2d(Mat& mat, vector<Point2d>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_64FC2 && mat.cols==1); |
||||
v_point = (vector<Point2d>) mat; |
||||
} |
||||
|
||||
|
||||
//vector_Point3i
|
||||
void Mat_to_vector_Point3i(Mat& mat, vector<Point3i>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_32SC3 && mat.cols==1); |
||||
v_point = (vector<Point3i>) mat; |
||||
} |
||||
|
||||
//vector_Point3f
|
||||
void Mat_to_vector_Point3f(Mat& mat, vector<Point3f>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC3 && mat.cols==1); |
||||
v_point = (vector<Point3f>) mat; |
||||
} |
||||
|
||||
//vector_Point3d
|
||||
void Mat_to_vector_Point3d(Mat& mat, vector<Point3d>& v_point) |
||||
{ |
||||
v_point.clear(); |
||||
CHECK_MAT(mat.type()==CV_64FC3 && mat.cols==1); |
||||
v_point = (vector<Point3d>) mat; |
||||
} |
||||
|
||||
|
||||
void vector_Point_to_Mat(vector<Point>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point2f_to_Mat(vector<Point2f>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point2d_to_Mat(vector<Point2d>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point3i_to_Mat(vector<Point3i>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point3f_to_Mat(vector<Point3f>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
void vector_Point3d_to_Mat(vector<Point3d>& v_point, Mat& mat) |
||||
{ |
||||
mat = Mat(v_point, true); |
||||
} |
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D |
||||
//vector_KeyPoint
|
||||
void Mat_to_vector_KeyPoint(Mat& mat, vector<KeyPoint>& v_kp) |
||||
{ |
||||
v_kp.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC(7) && mat.cols==1); |
||||
for(int i=0; i<mat.rows; i++) |
||||
{ |
||||
Vec<float, 7> v = mat.at< Vec<float, 7> >(i, 0); |
||||
KeyPoint kp(v[0], v[1], v[2], v[3], v[4], (int)v[5], (int)v[6]); |
||||
v_kp.push_back(kp); |
||||
} |
||||
return; |
||||
} |
||||
|
||||
|
||||
void vector_KeyPoint_to_Mat(vector<KeyPoint>& v_kp, Mat& mat) |
||||
{ |
||||
int count = v_kp.size(); |
||||
mat.create(count, 1, CV_32FC(7)); |
||||
for(int i=0; i<count; i++) |
||||
{ |
||||
KeyPoint kp = v_kp[i]; |
||||
mat.at< Vec<float, 7> >(i, 0) = Vec<float, 7>(kp.pt.x, kp.pt.y, kp.size, kp.angle, kp.response, kp.octave, kp.class_id); |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
|
||||
//vector_Mat
|
||||
void Mat_to_vector_Mat(cv::Mat& mat, std::vector<cv::Mat>& v_mat) |
||||
{ |
||||
v_mat.clear(); |
||||
if(mat.type() == CV_32SC2 && mat.cols == 1) |
||||
{ |
||||
v_mat.reserve(mat.rows); |
||||
for(int i=0; i<mat.rows; i++) |
||||
{ |
||||
Vec<int, 2> a = mat.at< Vec<int, 2> >(i, 0); |
||||
long long addr = (((long long)a[0])<<32) | a[1]; |
||||
Mat& m = *( (Mat*) addr ); |
||||
v_mat.push_back(m); |
||||
} |
||||
} else { |
||||
LOGD("Mat_to_vector_Mat() FAILED: mat.type() == CV_32SC2 && mat.cols == 1"); |
||||
} |
||||
} |
||||
|
||||
|
||||
void vector_Mat_to_Mat(std::vector<cv::Mat>& v_mat, cv::Mat& mat) |
||||
{ |
||||
int count = v_mat.size(); |
||||
mat.create(count, 1, CV_32SC2); |
||||
for(int i=0; i<count; i++) |
||||
{ |
||||
long long addr = (long long) new Mat(v_mat[i]); |
||||
mat.at< Vec<int, 2> >(i, 0) = Vec<int, 2>(addr>>32, addr&0xffffffff); |
||||
} |
||||
} |
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D |
||||
//vector_DMatch
|
||||
void Mat_to_vector_DMatch(Mat& mat, vector<DMatch>& v_dm) |
||||
{ |
||||
v_dm.clear(); |
||||
CHECK_MAT(mat.type()==CV_32FC4 && mat.cols==1); |
||||
for(int i=0; i<mat.rows; i++) |
||||
{ |
||||
Vec<float, 4> v = mat.at< Vec<float, 4> >(i, 0); |
||||
DMatch dm((int)v[0], (int)v[1], (int)v[2], v[3]); |
||||
v_dm.push_back(dm); |
||||
} |
||||
return; |
||||
} |
||||
|
||||
|
||||
void vector_DMatch_to_Mat(vector<DMatch>& v_dm, Mat& mat) |
||||
{ |
||||
int count = v_dm.size(); |
||||
mat.create(count, 1, CV_32FC4); |
||||
for(int i=0; i<count; i++) |
||||
{ |
||||
DMatch dm = v_dm[i]; |
||||
mat.at< Vec<float, 4> >(i, 0) = Vec<float, 4>(dm.queryIdx, dm.trainIdx, dm.imgIdx, dm.distance); |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
void Mat_to_vector_vector_Point(Mat& mat, vector< vector< Point > >& vv_pt) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<Point> vpt; |
||||
Mat_to_vector_Point(vm[i], vpt); |
||||
vv_pt.push_back(vpt); |
||||
} |
||||
} |
||||
|
||||
void Mat_to_vector_vector_Point2f(Mat& mat, vector< vector< Point2f > >& vv_pt) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<Point2f> vpt; |
||||
Mat_to_vector_Point2f(vm[i], vpt); |
||||
vv_pt.push_back(vpt); |
||||
} |
||||
} |
||||
|
||||
void Mat_to_vector_vector_Point3f(Mat& mat, vector< vector< Point3f > >& vv_pt) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<Point3f> vpt; |
||||
Mat_to_vector_Point3f(vm[i], vpt); |
||||
vv_pt.push_back(vpt); |
||||
} |
||||
} |
||||
|
||||
#ifdef HAVE_OPENCV_FEATURES2D |
||||
void Mat_to_vector_vector_KeyPoint(Mat& mat, vector< vector< KeyPoint > >& vv_kp) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<KeyPoint> vkp; |
||||
Mat_to_vector_KeyPoint(vm[i], vkp); |
||||
vv_kp.push_back(vkp); |
||||
} |
||||
} |
||||
|
||||
void vector_vector_KeyPoint_to_Mat(vector< vector< KeyPoint > >& vv_kp, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_kp.size() ); |
||||
for(size_t i=0; i<vv_kp.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_KeyPoint_to_Mat(vv_kp[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
void Mat_to_vector_vector_DMatch(Mat& mat, vector< vector< DMatch > >& vv_dm) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<DMatch> vdm; |
||||
Mat_to_vector_DMatch(vm[i], vdm); |
||||
vv_dm.push_back(vdm); |
||||
} |
||||
} |
||||
|
||||
void vector_vector_DMatch_to_Mat(vector< vector< DMatch > >& vv_dm, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_dm.size() ); |
||||
for(size_t i=0; i<vv_dm.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_DMatch_to_Mat(vv_dm[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
#endif |
||||
|
||||
void Mat_to_vector_vector_char(Mat& mat, vector< vector< char > >& vv_ch) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( mat.rows ); |
||||
Mat_to_vector_Mat(mat, vm); |
||||
for(size_t i=0; i<vm.size(); i++) |
||||
{ |
||||
vector<char> vch; |
||||
Mat_to_vector_char(vm[i], vch); |
||||
vv_ch.push_back(vch); |
||||
} |
||||
} |
||||
|
||||
void vector_vector_char_to_Mat(vector< vector< char > >& vv_ch, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_ch.size() ); |
||||
for(size_t i=0; i<vv_ch.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_char_to_Mat(vv_ch[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
void vector_vector_Point_to_Mat(vector< vector< Point > >& vv_pt, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_pt.size() ); |
||||
for(size_t i=0; i<vv_pt.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_Point_to_Mat(vv_pt[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
void vector_vector_Point2f_to_Mat(vector< vector< Point2f > >& vv_pt, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_pt.size() ); |
||||
for(size_t i=0; i<vv_pt.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_Point2f_to_Mat(vv_pt[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
void vector_vector_Point3f_to_Mat(vector< vector< Point3f > >& vv_pt, Mat& mat) |
||||
{ |
||||
vector<Mat> vm; |
||||
vm.reserve( vv_pt.size() ); |
||||
for(size_t i=0; i<vv_pt.size(); i++) |
||||
{ |
||||
Mat m; |
||||
vector_Point3f_to_Mat(vv_pt[i], m); |
||||
vm.push_back(m); |
||||
} |
||||
vector_Mat_to_Mat(vm, mat); |
||||
} |
||||
|
||||
void vector_Vec4i_to_Mat(vector<Vec4i>& v_vec, Mat& mat) |
||||
{ |
||||
mat = Mat(v_vec, true); |
||||
} |
||||
|
||||
void vector_Vec4f_to_Mat(vector<Vec4f>& v_vec, Mat& mat) |
||||
{ |
||||
mat = Mat(v_vec, true); |
||||
} |
||||
|
||||
void vector_Vec6f_to_Mat(vector<Vec6f>& v_vec, Mat& mat) |
||||
{ |
||||
mat = Mat(v_vec, true); |
||||
} |
||||
|
||||
Loading…
Reference in new issue