potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-30 15:53:03 +04:00
Code Packages Releases Wiki Activity

Merge branch 'master' of git://github.com/Opencv/opencv into UserColormap

Browse Source
This commit is contained in:
LaurentBerger
2016-12-26 17:03:52 +01:00
parent 8415b907bb 7dd3723abe
commit a2f3692bff
159 changed files with 4087 additions and 2024 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/imgproc/src/deriv.cpp
+5 -10
View File
@@ -221,19 +221,14 @@ namespace cv
if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix())
return false; //Process isolated borders only
vx_border_t border;
vx_enum border;
switch (borderType & ~BORDER_ISOLATED)
{
case BORDER_CONSTANT:
border.mode = VX_BORDER_CONSTANT;
#if VX_VERSION > VX_VERSION_1_0
border.constant_value.U8 = (vx_uint8)(0);
#else
border.constant_value = (vx_uint32)(0);
#endif
border = VX_BORDER_CONSTANT;
break;
case BORDER_REPLICATE:
border.mode = VX_BORDER_REPLICATE;
border = VX_BORDER_REPLICATE;
break;
default:
return false;
@@ -259,8 +254,8 @@ namespace cv
//ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments
//since OpenVX standart says nothing about thread-safety for now
vx_border_t prevBorder = ctx.immediateBorder();
ctx.setImmediateBorder(border);
ivx::border_t prevBorder = ctx.immediateBorder();
ctx.setImmediateBorder(border, (vx_uint8)(0));
if (dtype == CV_16SC1 && ksize == 3 && ((dx | dy) == 1) && (dx + dy) == 1)
{
if(dx)
modules/imgproc/src/drawing.cpp
+34 -28
View File
@@ -1099,7 +1099,7 @@ FillConvexPoly( Mat& img, const Point2l* v, int npts, const void* color, int lin
edge[2];
int delta = 1 << shift >> 1;
int i, y, imin = 0, left = 0, right = 1;
int i, y, imin = 0;
int edges = npts;
int64 xmin, xmax, ymin, ymax;
uchar* ptr = img.ptr();
@@ -1181,44 +1181,46 @@ FillConvexPoly( Mat& img, const Point2l* v, int npts, const void* color, int lin
{
if( y >= edge[i].ye )
{
int idx = edge[i].idx, di = edge[i].di;
int64 xs = 0, xe;
int idx0 = edge[i].idx, di = edge[i].di;
int idx = idx0 + di;
if (idx >= npts) idx -= npts;
int ty = 0;
for(;;)
for (; edges-- > 0; )
{
ty = (int)((v[idx].y + delta) >> shift);
if( ty > y || edges == 0 )
if (ty > y)
{
int64 xs = v[idx0].x;
int64 xe = v[idx].x;
if (shift != XY_SHIFT)
{
xs <<= XY_SHIFT - shift;
xe <<= XY_SHIFT - shift;
}
edge[i].ye = ty;
edge[i].dx = ((xe - xs)*2 + (ty - y)) / (2 * (ty - y));
edge[i].x = xs;
edge[i].idx = idx;
break;
xs = v[idx].x;
}
idx0 = idx;
idx += di;
idx -= ((idx < npts) - 1) & npts; /* idx -= idx >= npts ? npts : 0 */
edges--;
if (idx >= npts) idx -= npts;
}
xs <<= XY_SHIFT - shift;
xe = v[idx].x << (XY_SHIFT - shift);
/* no more edges */
if( y >= ty)
return;
edge[i].ye = ty;
edge[i].dx = ((xe - xs)*2 + (ty - y)) / (2 * (ty - y));
edge[i].x = xs;
edge[i].idx = idx;
}
}
}
if( edge[left].x > edge[right].x )
if (y >= 0)
{
left ^= 1;
right ^= 1;
}
int left = 0, right = 1;
if (edge[0].x > edge[1].x)
{
left = 1, right = 0;
}
if( y >= 0 )
{
int xx1 = (int)((edge[left].x + delta1) >> XY_SHIFT);
int xx2 = (int)((edge[right].x + delta2) >> XY_SHIFT);
@@ -1231,9 +1233,13 @@ FillConvexPoly( Mat& img, const Point2l* v, int npts, const void* color, int lin
ICV_HLINE( ptr, xx1, xx2, color, pix_size );
}
}
else
{
// TODO optimize scan for negative y
}
edge[left].x += edge[left].dx;
edge[right].x += edge[right].dx;
edge[0].x += edge[0].dx;
edge[1].x += edge[1].dx;
ptr += img.step;
}
while( ++y <= (int)ymax );
modules/imgproc/src/featureselect.cpp
+95
View File
@@ -42,6 +42,8 @@
#include "precomp.hpp"
#include "opencl_kernels_imgproc.hpp"
#include "opencv2/core/openvx/ovx_defs.hpp"
#include <cstdio>
#include <vector>
#include <iostream>
@@ -262,6 +264,95 @@ static bool ocl_goodFeaturesToTrack( InputArray _image, OutputArray _corners,
#endif
#ifdef HAVE_OPENVX
struct VxKeypointsComparator
{
bool operator () (const vx_keypoint_t& a, const vx_keypoint_t& b)
{
return a.strength > b.strength;
}
};
static bool openvx_harris(Mat image, OutputArray _corners,
int _maxCorners, double _qualityLevel, double _minDistance,
int _blockSize, double _harrisK)
{
using namespace ivx;
if(image.type() != CV_8UC1) return false;
//OpenVX implementations don't have to provide other sizes
if(!(_blockSize == 3 || _blockSize == 5 || _blockSize == 7)) return false;
try
{
Context context = Context::create();
Image ovxImage = Image::createFromHandle(context, Image::matTypeToFormat(image.type()),
Image::createAddressing(image), image.data);
//The minimum threshold which to eliminate Harris Corner scores (computed using the normalized Sobel kernel).
//set to 0, we'll filter it later by threshold
ivx::Scalar strengthThresh = ivx::Scalar::create<VX_TYPE_FLOAT32>(context, 0);
//The gradient window size to use on the input.
vx_int32 gradientSize = 3;
//The block window size used to compute the harris corner score
vx_int32 blockSize = _blockSize;
//The scalar sensitivity threshold k from the Harris-Stephens equation
ivx::Scalar sensivity = ivx::Scalar::create<VX_TYPE_FLOAT32>(context, _harrisK);
//The radial Euclidean distance for non-maximum suppression
ivx::Scalar minDistance = ivx::Scalar::create<VX_TYPE_FLOAT32>(context, _minDistance);
vx_size capacity = image.cols * image.rows;
Array corners = Array::create(context, VX_TYPE_KEYPOINT, capacity);
ivx::Scalar numCorners = ivx::Scalar::create<VX_TYPE_SIZE>(context, 0);
IVX_CHECK_STATUS(vxuHarrisCorners(context, ovxImage, strengthThresh, minDistance, sensivity,
gradientSize, blockSize, corners, numCorners));
std::vector<vx_keypoint_t> vxKeypoints;
corners.copyTo(vxKeypoints);
std::sort(vxKeypoints.begin(), vxKeypoints.end(), VxKeypointsComparator());
vx_float32 maxStrength = 0.0f;
if(vxKeypoints.size() > 0)
maxStrength = vxKeypoints[0].strength;
size_t maxKeypoints = min((size_t)_maxCorners, vxKeypoints.size());
std::vector<Point2f> keypoints;
keypoints.reserve(maxKeypoints);
for(size_t i = 0; i < maxKeypoints; i++)
{
vx_keypoint_t kp = vxKeypoints[i];
if(kp.strength < maxStrength*_qualityLevel) break;
keypoints.push_back(Point2f((float)kp.x, (float)kp.y));
}
Mat(keypoints).convertTo(_corners, _corners.fixedType() ? _corners.type() : CV_32F);
#ifdef VX_VERSION_1_1
//we should take user memory back before release
//(it's not done automatically according to standard)
ovxImage.swapHandle();
#endif
}
catch (RuntimeError & e)
{
VX_DbgThrow(e.what());
}
catch (WrapperError & e)
{
VX_DbgThrow(e.what());
}
return true;
}
#endif
}
void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
@@ -285,6 +376,10 @@ void cv::goodFeaturesToTrack( InputArray _image, OutputArray _corners,
return;
}
// Disabled due to bad accuracy
CV_OVX_RUN(false && useHarrisDetector && _mask.empty(),
openvx_harris(image, _corners, maxCorners, qualityLevel, minDistance, blockSize, harrisK))
if( useHarrisDetector )
cornerHarris( image, eig, blockSize, 3, harrisK );
else
modules/imgproc/src/imgwarp.cpp
+101
View File
@@ -51,6 +51,8 @@
#include "opencl_kernels_imgproc.hpp"
#include "hal_replacement.hpp"
#include "opencv2/core/openvx/ovx_defs.hpp"
using namespace cv;
namespace cv
@@ -4750,6 +4752,94 @@ static bool ocl_logPolar(InputArray _src, OutputArray _dst,
}
#endif
#ifdef HAVE_OPENVX
static bool openvx_remap(Mat src, Mat dst, Mat map1, Mat map2, int interpolation, const Scalar& borderValue)
{
vx_interpolation_type_e inter_type;
switch (interpolation)
{
case INTER_LINEAR:
#if VX_VERSION > VX_VERSION_1_0
inter_type = VX_INTERPOLATION_BILINEAR;
#else
inter_type = VX_INTERPOLATION_TYPE_BILINEAR;
#endif
break;
case INTER_NEAREST:
/* NEAREST_NEIGHBOR mode disabled since OpenCV round half to even while OpenVX sample implementation round half up
#if VX_VERSION > VX_VERSION_1_0
inter_type = VX_INTERPOLATION_NEAREST_NEIGHBOR;
#else
inter_type = VX_INTERPOLATION_TYPE_NEAREST_NEIGHBOR;
#endif
if (!map1.empty())
for (int y = 0; y < map1.rows; ++y)
{
float* line = map1.ptr<float>(y);
for (int x = 0; x < map1.cols; ++x)
line[x] = cvRound(line[x]);
}
if (!map2.empty())
for (int y = 0; y < map2.rows; ++y)
{
float* line = map2.ptr<float>(y);
for (int x = 0; x < map2.cols; ++x)
line[x] = cvRound(line[x]);
}
break;
*/
case INTER_AREA://AREA interpolation mode is unsupported
default:
return false;
}
try
{
ivx::Context ctx = ivx::Context::create();
Mat a;
if (dst.data != src.data)
a = src;
else
src.copyTo(a);
ivx::Image
ia = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8,
ivx::Image::createAddressing(a.cols, a.rows, 1, (vx_int32)(a.step)), a.data),
ib = ivx::Image::createFromHandle(ctx, VX_DF_IMAGE_U8,
ivx::Image::createAddressing(dst.cols, dst.rows, 1, (vx_int32)(dst.step)), dst.data);
//ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments
//since OpenVX standart says nothing about thread-safety for now
ivx::border_t prevBorder = ctx.immediateBorder();
ctx.setImmediateBorder(VX_BORDER_CONSTANT, (vx_uint8)(borderValue[0]));
ivx::Remap map = ivx::Remap::create(ctx, src.cols, src.rows, dst.cols, dst.rows);
if (map1.empty()) map.setMappings(map2);
else if (map2.empty()) map.setMappings(map1);
else map.setMappings(map1, map2);
ivx::IVX_CHECK_STATUS(vxuRemap(ctx, ia, map, inter_type, ib));
#ifdef VX_VERSION_1_1
ib.swapHandle();
ia.swapHandle();
#endif
ctx.setImmediateBorder(prevBorder);
}
catch (ivx::RuntimeError & e)
{
CV_Error(CV_StsInternal, e.what());
return false;
}
catch (ivx::WrapperError & e)
{
CV_Error(CV_StsInternal, e.what());
return false;
}
return true;
}
#endif
#if defined HAVE_IPP && IPP_DISABLE_BLOCK
typedef IppStatus (CV_STDCALL * ippiRemap)(const void * pSrc, IppiSize srcSize, int srcStep, IppiRect srcRoi,
@@ -4852,6 +4942,17 @@ void cv::remap( InputArray _src, OutputArray _dst,
Mat src = _src.getMat(), map1 = _map1.getMat(), map2 = _map2.getMat();
_dst.create( map1.size(), src.type() );
Mat dst = _dst.getMat();
CV_OVX_RUN(
src.type() == CV_8UC1 && dst.type() == CV_8UC1 &&
(borderType& ~BORDER_ISOLATED) == BORDER_CONSTANT &&
((map1.type() == CV_32FC2 && map2.empty() && map1.size == dst.size) ||
(map1.type() == CV_32FC1 && map2.type() == CV_32FC1 && map1.size == dst.size && map2.size == dst.size) ||
(map1.empty() && map2.type() == CV_32FC2 && map2.size == dst.size)) &&
((borderType & BORDER_ISOLATED) != 0 || !src.isSubmatrix()),
openvx_remap(src, dst, map1, map2, interpolation, borderValue));
CV_Assert( dst.cols < SHRT_MAX && dst.rows < SHRT_MAX && src.cols < SHRT_MAX && src.rows < SHRT_MAX );
if( dst.data == src.data )
modules/imgproc/src/phasecorr.cpp
+3
View File
@@ -167,6 +167,9 @@ static void divSpectrums( InputArray _srcA, InputArray _srcB, OutputArray _dst,
_dst.create( srcA.rows, srcA.cols, type );
Mat dst = _dst.getMat();
CV_Assert(dst.data != srcA.data); // non-inplace check
CV_Assert(dst.data != srcB.data); // non-inplace check
bool is_1d = (flags & DFT_ROWS) || (rows == 1 || (cols == 1 &&
srcA.isContinuous() && srcB.isContinuous() && dst.isContinuous()));
modules/imgproc/src/pyramids.cpp
+81
View File
@@ -44,6 +44,8 @@
#include "precomp.hpp"
#include "opencl_kernels_imgproc.hpp"
#include "opencv2/core/openvx/ovx_defs.hpp"
namespace cv
{
@@ -1254,6 +1256,82 @@ static bool ipp_pyrdown( InputArray _src, OutputArray _dst, const Size& _dsz, in
}
#endif
#ifdef HAVE_OPENVX
namespace cv
{
static bool openvx_pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType )
{
using namespace ivx;
Mat srcMat = _src.getMat();
CV_Assert(!srcMat.empty());
Size ssize = _src.size();
Size acceptableSize = Size((ssize.width + 1) / 2, (ssize.height + 1) / 2);
// OpenVX limitations
if((srcMat.type() != CV_8U) ||
(borderType != BORDER_REPLICATE) ||
(_dsz != acceptableSize && _dsz.area() != 0))
return false;
// The only border mode which is supported by both cv::pyrDown() and OpenVX
// and produces predictable results
ivx::border_t borderMode;
borderMode.mode = VX_BORDER_REPLICATE;
_dst.create( acceptableSize, srcMat.type() );
Mat dstMat = _dst.getMat();
CV_Assert( ssize.width > 0 && ssize.height > 0 &&
std::abs(acceptableSize.width*2 - ssize.width) <= 2 &&
std::abs(acceptableSize.height*2 - ssize.height) <= 2 );
try
{
Context context = Context::create();
if(context.vendorID() == VX_ID_KHRONOS)
{
// This implementation performs floor-like rounding
// (OpenCV uses floor(x+0.5)-like rounding)
// and ignores border mode (and loses 1px size border)
return false;
}
Image srcImg = Image::createFromHandle(context, Image::matTypeToFormat(srcMat.type()),
Image::createAddressing(srcMat), (void*)srcMat.data);
Image dstImg = Image::createFromHandle(context, Image::matTypeToFormat(dstMat.type()),
Image::createAddressing(dstMat), (void*)dstMat.data);
ivx::Scalar kernelSize = ivx::Scalar::create<VX_TYPE_INT32>(context, 5);
Graph graph = Graph::create(context);
ivx::Node halfNode = ivx::Node::create(graph, VX_KERNEL_HALFSCALE_GAUSSIAN, srcImg, dstImg, kernelSize);
halfNode.setBorder(borderMode);
graph.verify();
graph.process();
#ifdef VX_VERSION_1_1
//we should take user memory back before release
//(it's not done automatically according to standard)
srcImg.swapHandle(); dstImg.swapHandle();
#endif
}
catch (RuntimeError & e)
{
VX_DbgThrow(e.what());
}
catch (WrapperError & e)
{
VX_DbgThrow(e.what());
}
return true;
}
}
#endif
void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borderType )
{
CV_INSTRUMENT_REGION()
@@ -1263,6 +1341,9 @@ void cv::pyrDown( InputArray _src, OutputArray _dst, const Size& _dsz, int borde
CV_OCL_RUN(_src.dims() <= 2 && _dst.isUMat(),
ocl_pyrDown(_src, _dst, _dsz, borderType))
CV_OVX_RUN(_src.dims() <= 2,
openvx_pyrDown(_src, _dst, _dsz, borderType))
Mat src = _src.getMat();
Size dsz = _dsz.area() == 0 ? Size((src.cols + 1)/2, (src.rows + 1)/2) : _dsz;
_dst.create( dsz, src.type() );
modules/imgproc/src/smooth.cpp
+9 -22
View File
@@ -1662,19 +1662,14 @@ namespace cv
if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix())
return false; //Process isolated borders only
vx_border_t border;
vx_enum border;
switch (borderType & ~BORDER_ISOLATED)
{
case BORDER_CONSTANT:
border.mode = VX_BORDER_CONSTANT;
#if VX_VERSION > VX_VERSION_1_0
border.constant_value.U8 = (vx_uint8)(0);
#else
border.constant_value = (vx_uint32)(0);
#endif
border = VX_BORDER_CONSTANT;
break;
case BORDER_REPLICATE:
border.mode = VX_BORDER_REPLICATE;
border = VX_BORDER_REPLICATE;
break;
default:
return false;
@@ -1701,7 +1696,7 @@ namespace cv
//ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments
//since OpenVX standart says nothing about thread-safety for now
ivx::border_t prevBorder = ctx.immediateBorder();
ctx.setImmediateBorder(border);
ctx.setImmediateBorder(border, (vx_uint8)(0));
if (ddepth == CV_8U && ksize.width == 3 && ksize.height == 3 && normalize)
{
ivx::IVX_CHECK_STATUS(vxuBox3x3(ctx, ia, ib));
@@ -2229,19 +2224,14 @@ static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize,
if ((borderType & BORDER_ISOLATED) == 0 && src.isSubmatrix())
return false; //Process isolated borders only
vx_border_t border;
vx_enum border;
switch (borderType & ~BORDER_ISOLATED)
{
case BORDER_CONSTANT:
border.mode = VX_BORDER_CONSTANT;
#if VX_VERSION > VX_VERSION_1_0
border.constant_value.U8 = (vx_uint8)(0);
#else
border.constant_value = (vx_uint32)(0);
#endif
border = VX_BORDER_CONSTANT;
break;
case BORDER_REPLICATE:
border.mode = VX_BORDER_REPLICATE;
border = VX_BORDER_REPLICATE;
break;
default:
return false;
@@ -2268,7 +2258,7 @@ static bool openvx_gaussianBlur(InputArray _src, OutputArray _dst, Size ksize,
//ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments
//since OpenVX standart says nothing about thread-safety for now
ivx::border_t prevBorder = ctx.immediateBorder();
ctx.setImmediateBorder(border);
ctx.setImmediateBorder(border, (vx_uint8)(0));
if (ksize.width == 3 && ksize.height == 3 && (sigma1 == 0.0 || (sigma1 - 0.8) < DBL_EPSILON) && (sigma2 == 0.0 || (sigma2 - 0.8) < DBL_EPSILON))
{
ivx::IVX_CHECK_STATUS(vxuGaussian3x3(ctx, ia, ib));
@@ -3369,9 +3359,6 @@ namespace cv
Mat src = _src.getMat();
Mat dst = _dst.getMat();
vx_border_t border;
border.mode = VX_BORDER_REPLICATE;
try
{
ivx::Context ctx = ivx::Context::create();
@@ -3395,7 +3382,7 @@ namespace cv
//ATTENTION: VX_CONTEXT_IMMEDIATE_BORDER attribute change could lead to strange issues in multi-threaded environments
//since OpenVX standart says nothing about thread-safety for now
ivx::border_t prevBorder = ctx.immediateBorder();
ctx.setImmediateBorder(border);
ctx.setImmediateBorder(VX_BORDER_REPLICATE);
#ifdef VX_VERSION_1_1
if (ksize == 3)
#endif