Vitaliy Lyudvichenko
10 years ago
parent
983823468d
commit
0ebe30a362
17 changed files with 431 additions and 333 deletions
@ -0,0 +1,240 @@ |
||||
#ifndef __OPENCV_DNN_DNN_BLOB_HPP__ |
||||
#define __OPENCV_DNN_DNN_BLOB_HPP__ |
||||
#include <opencv2/core.hpp> |
||||
#include <vector> |
||||
|
||||
namespace cv |
||||
{ |
||||
namespace dnn |
||||
{ |
||||
/** @brief provides convenient methods for continuous n-dimensional array processing, dedicated for convolution neural networks
|
||||
It's realized as wrapper over \ref cv::Mat and \ref cv::UMat and will support methods for CPU/GPU switching |
||||
*/ |
||||
class CV_EXPORTS Blob |
||||
{ |
||||
public: |
||||
explicit Blob(); |
||||
explicit Blob(InputArray in); |
||||
|
||||
void create(int ndims, const int *sizes, int type = CV_32F); |
||||
void create(Vec4i shape, int type = CV_32F); |
||||
void create(int num, int cn, int rows, int cols, int type = CV_32F); |
||||
|
||||
void fill(InputArray in); |
||||
void fill(int ndims, const int *sizes, int type, void *data, bool deepCopy = true); |
||||
|
||||
Mat& getMatRef(); |
||||
const Mat& getMatRef() const; |
||||
Mat getMat(); |
||||
Mat getMat(int n, int cn); |
||||
|
||||
//shape getters
|
||||
///returns real count of blob dimensions
|
||||
int dims() const; |
||||
|
||||
/** @brief returns size of corresponding dimension (axis)
|
||||
@param axis dimension index |
||||
Python-like indexing is supported, so \p axis can be negative, i. e. -1 is last dimension. |
||||
Supposed that size of non-existing dimensions equal to 1, so the method always finished. |
||||
*/ |
||||
int size(int axis) const; |
||||
|
||||
/** @brief returns size of corresponding dimension (axis)
|
||||
@param axis dimension index |
||||
Python-like indexing is supported, so \p axis can be negative, i. e. -1 is last dimension. |
||||
@note Unlike ::size, if \p axis points to non-existing dimension then an error will be generated. |
||||
*/ |
||||
int sizeAt(int axis) const; |
||||
|
||||
/** @brief returns number of elements
|
||||
@param startAxis starting axis (inverse indexing can be used) |
||||
@param endAxis ending (excluded) axis |
||||
@see ::canonicalAxis |
||||
*/ |
||||
size_t total(int startAxis = 0, int endAxis = -1) const; |
||||
|
||||
/** @brief converts axis index to canonical format (where 0 <= axis <= ::dims)
|
||||
*/ |
||||
int canonicalAxis(int axis) const; |
||||
|
||||
/** @brief returns real shape of the blob
|
||||
*/ |
||||
std::vector<int> shape() const; |
||||
|
||||
//shape getters, oriented for 4-dim Blobs processing
|
||||
int cols() const; |
||||
int rows() const; |
||||
int channels() const; |
||||
int num() const; |
||||
Size size2() const; |
||||
Vec4i shape4() const; |
||||
|
||||
//CPU data pointer functions
|
||||
int offset(int n = 0, int cn = 0, int row = 0, int col = 0) const; |
||||
uchar *ptrRaw(int n = 0, int cn = 0, int row = 0, int col = 0); |
||||
float *ptrf(int n = 0, int cn = 0, int row = 0, int col = 0); |
||||
template<typename TFloat> |
||||
TFloat *ptr(int n = 0, int cn = 0, int row = 0, int col = 0); |
||||
|
||||
int type() const; |
||||
bool isFloat() const; |
||||
bool isDouble() const; |
||||
|
||||
private: |
||||
const int *sizes() const; |
||||
|
||||
Mat m; |
||||
}; |
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
inline int Blob::canonicalAxis(int axis) const |
||||
{ |
||||
CV_Assert(-dims() <= axis && axis < dims()); |
||||
|
||||
if (axis < 0) |
||||
{ |
||||
return dims() + axis; |
||||
} |
||||
return axis; |
||||
} |
||||
|
||||
inline int Blob::size(int axis) const |
||||
{ |
||||
if (axis < 0) |
||||
axis += dims(); |
||||
|
||||
if (axis < 0 || axis >= dims()) |
||||
return 1; |
||||
|
||||
return sizes()[axis]; |
||||
} |
||||
|
||||
inline int Blob::sizeAt(int axis) const |
||||
{ |
||||
CV_Assert(-dims() <= axis && axis < dims()); |
||||
|
||||
if (axis < 0) |
||||
axis += dims(); |
||||
|
||||
return sizes()[axis]; |
||||
} |
||||
|
||||
inline size_t Blob::total(int startAxis, int endAxis) const |
||||
{ |
||||
startAxis = canonicalAxis(startAxis); |
||||
|
||||
if (endAxis == -1) |
||||
endAxis = dims(); |
||||
|
||||
CV_Assert(startAxis <= endAxis && endAxis <= dims()); |
||||
|
||||
size_t size = 1; //assume that blob isn't empty
|
||||
for (int i = startAxis; i < endAxis; i++) |
||||
size *= (size_t)sizes()[i]; |
||||
|
||||
return size; |
||||
} |
||||
|
||||
inline int Blob::offset(int n, int cn, int row, int col) const |
||||
{ |
||||
CV_DbgAssert(0 <= n && n < num() && 0 <= cn && cn < channels() && 0 <= row && row < rows() && 0 <= col && col < cols()); |
||||
return ((n*channels() + cn)*rows() + row)*cols() + col; |
||||
} |
||||
|
||||
inline float *Blob::ptrf(int n, int cn, int row, int col) |
||||
{ |
||||
CV_Assert(type() == CV_32F); |
||||
return (float*)m.data + offset(n, cn, row, col); |
||||
} |
||||
|
||||
inline uchar *Blob::ptrRaw(int n, int cn, int row, int col) |
||||
{ |
||||
return m.data + m.elemSize() * offset(n, cn, row, col); |
||||
} |
||||
|
||||
template<typename TFloat> |
||||
inline TFloat* Blob::ptr(int n, int cn, int row, int col) |
||||
{ |
||||
CV_Assert(type() == cv::DataDepth<TFloat>::value); |
||||
return (TFloat*) ptrRaw(n, cn, row, col); |
||||
} |
||||
|
||||
inline std::vector<int> Blob::shape() const |
||||
{ |
||||
return std::vector<int>(sizes(), sizes() + dims()); |
||||
} |
||||
|
||||
inline Mat& Blob::getMatRef() |
||||
{ |
||||
return m; |
||||
} |
||||
|
||||
inline const Mat& Blob::getMatRef() const |
||||
{ |
||||
return m; |
||||
} |
||||
|
||||
inline Mat Blob::getMat() |
||||
{ |
||||
return m; |
||||
} |
||||
|
||||
inline Mat Blob::getMat(int n, int cn) |
||||
{ |
||||
return Mat(rows(), cols(), m.type(), this->ptrRaw(n, cn)); |
||||
} |
||||
|
||||
inline int Blob::cols() const |
||||
{ |
||||
return size(-1); |
||||
} |
||||
|
||||
inline int Blob::rows() const |
||||
{ |
||||
return size(-2); |
||||
} |
||||
|
||||
inline Size Blob::size2() const |
||||
{ |
||||
return Size(cols(), rows()); |
||||
} |
||||
|
||||
inline int Blob::channels() const |
||||
{ |
||||
return size(-3); |
||||
} |
||||
|
||||
inline int Blob::num() const |
||||
{ |
||||
return size(-4); |
||||
} |
||||
|
||||
inline int Blob::type() const |
||||
{ |
||||
return m.depth(); |
||||
} |
||||
|
||||
inline bool Blob::isFloat() const |
||||
{ |
||||
return (type() == CV_32F); |
||||
} |
||||
|
||||
inline bool Blob::isDouble() const |
||||
{ |
||||
return (type() == CV_32F); |
||||
} |
||||
|
||||
inline const int * Blob::sizes() const |
||||
{ |
||||
return &m.size[0]; |
||||
} |
||||
|
||||
inline int Blob::dims() const |
||||
{ |
||||
return m.dims; |
||||
} |
||||
} |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,132 @@ |
||||
#include "precomp.hpp" |
||||
|
||||
namespace cv |
||||
{ |
||||
namespace dnn |
||||
{ |
||||
|
||||
Blob::Blob() |
||||
{ |
||||
int zeros[4] = { 0, 0, 0, 0 }; |
||||
m = Mat(4, zeros, CV_32F, NULL); |
||||
} |
||||
|
||||
Blob::Blob(InputArray in) |
||||
{ |
||||
CV_Assert(in.isMat() || in.isUMat()); |
||||
|
||||
if (in.isMat()) |
||||
{ |
||||
Mat mat = in.getMat(); |
||||
|
||||
CV_Assert(mat.dims == 2); |
||||
int rows = mat.rows; |
||||
int cols = mat.cols; |
||||
int cn = mat.channels(); |
||||
int type = mat.type(); |
||||
int dstType = CV_MAKE_TYPE(CV_MAT_DEPTH(type), 1); |
||||
|
||||
int size[3] = { cn, rows, cols }; |
||||
this->create(3, size, dstType); |
||||
uchar *data = m.data; |
||||
int step = rows * cols * CV_ELEM_SIZE(dstType); |
||||
|
||||
if (cn == 1) |
||||
{ |
||||
Mat wrapper2D(rows, cols, dstType, m.data); |
||||
mat.copyTo(wrapper2D); |
||||
} |
||||
else |
||||
{ |
||||
std::vector<Mat> wrappers(cn); |
||||
for (int i = 0; i < cn; i++) |
||||
{ |
||||
wrappers[i] = Mat(rows, cols, dstType, data); |
||||
data += step; |
||||
} |
||||
|
||||
cv::split(mat, wrappers); |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
CV_Error(cv::Error::StsNotImplemented, "Not Implemented"); |
||||
} |
||||
} |
||||
|
||||
inline void squeezeShape_(const int srcDims, const int *srcSizes, const int dstDims, int *dstSizes) |
||||
{ |
||||
const int m = std::min(dstDims, srcDims); |
||||
|
||||
//copy common(last) dimensions
|
||||
for (int i = 0; i < m; i++) |
||||
dstSizes[dstDims - 1 - i] = srcSizes[srcDims - 1 - i]; |
||||
|
||||
//either flatten extra dimensions
|
||||
for (int i = m; i < srcDims; i++) |
||||
dstSizes[0] *= srcSizes[srcDims - 1 - i]; |
||||
|
||||
//either fill gaps
|
||||
for (int i = m; i < dstDims; i++) |
||||
dstSizes[dstDims - 1 - i] = 1; |
||||
} |
||||
|
||||
static Vec4i squeezeShape4(const int ndims, const int *sizes) |
||||
{ |
||||
Vec4i res; |
||||
squeezeShape_(ndims, sizes, 4, &res[0]); |
||||
return res; |
||||
} |
||||
|
||||
void Blob::fill(int ndims, const int *sizes, int type, void *data, bool deepCopy) |
||||
{ |
||||
CV_Assert(type == CV_32F || type == CV_64F); |
||||
|
||||
Vec4i shape = squeezeShape4(ndims, sizes); |
||||
|
||||
if (deepCopy) |
||||
{ |
||||
m.create(4, &shape[0], type); |
||||
size_t dataSize = m.total() * m.elemSize(); |
||||
memcpy(m.data, data, dataSize); |
||||
} |
||||
else |
||||
{ |
||||
m = Mat(shape.channels, &shape[0], type, data); |
||||
} |
||||
} |
||||
|
||||
void Blob::fill(InputArray in) |
||||
{ |
||||
CV_Assert(in.isMat() || in.isMatVector()); |
||||
|
||||
//TODO
|
||||
*this = Blob(in); |
||||
} |
||||
|
||||
void Blob::create(int ndims, const int *sizes, int type) |
||||
{ |
||||
CV_Assert(type == CV_32F || type == CV_64F); |
||||
Vec4i shape = squeezeShape4(ndims, sizes); |
||||
m.create(shape.channels, &shape[0], type); |
||||
} |
||||
|
||||
void Blob::create(Vec4i shape, int type) |
||||
{ |
||||
m.create(shape.channels, &shape[0], type); |
||||
} |
||||
|
||||
void Blob::create(int num, int cn, int rows, int cols, int type) |
||||
{ |
||||
Vec4i shape(num, cn, rows, cols); |
||||
create(4, &shape[0], type); |
||||
} |
||||
|
||||
Vec4i Blob::shape4() const |
||||
{ |
||||
return squeezeShape4(dims(), sizes()); |
||||
} |
||||
|
||||
|
||||
} |
||||
} |
||||
Loading…
Reference in new issue