\************************************************************************************/
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include "circlesgrid.hpp"
#include <stdarg.h>
//M*/
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include <stdio.h>
#include <iterator>
//M*/
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include <vector>
#include <algorithm>
const Scalar holeColor = Scalar(0, 255, 0);
if (srcImage.channels() == 1)
- cvtColor(srcImage, drawImage, CV_GRAY2RGB);
+ cvtColor(srcImage, drawImage, COLOR_GRAY2RGB);
else
srcImage.copyTo(drawImage);
#include "opencv2/calib3d.hpp"
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/features2d.hpp"
#include "opencv2/core/utility.hpp"
#include <math.h>
-//#define _SUBPIX_VERBOSE
-
-#undef max
-
namespace cv {
-
-// static void drawCircles(Mat& img, const std::vector<Point2f>& corners, const std::vector<float>& radius)
-// {
-// for(size_t i = 0; i < corners.size(); i++)
-// {
-// circle(img, corners[i], cvRound(radius[i]), CV_RGB(255, 0, 0));
-// }
-// }
-
-// static int histQuantile(const Mat& hist, float quantile)
-// {
-// if(hist.dims > 1) return -1; // works for 1D histograms only
-
-// float cur_sum = 0;
-// float total_sum = (float)sum(hist).val[0];
-// float quantile_sum = total_sum*quantile;
-// for(int j = 0; j < hist.size[0]; j++)
-// {
-// cur_sum += (float)hist.at<float>(j);
-// if(cur_sum > quantile_sum)
-// {
-// return j;
-// }
-// }
-
-// return hist.size[0] - 1;
-// }
-
inline bool is_smaller(const std::pair<int, float>& p1, const std::pair<int, float>& p2)
{
return p1.second < p2.second;
cross_point = origin1 + dir1*alpha;
}
-// static void findCorner(const std::vector<Point>& contour, Point2f point, Point2f& corner)
-// {
-// // find the nearest point
-// double min_dist = std::numeric_limits<double>::max();
-// int min_idx = -1;
-
-// // find corner idx
-// for(size_t i = 0; i < contour.size(); i++)
-// {
-// double dist = norm(Point2f((float)contour[i].x, (float)contour[i].y) - point);
-// if(dist < min_dist)
-// {
-// min_dist = dist;
-// min_idx = (int)i;
-// }
-// }
-// assert(min_idx >= 0);
-
-// // temporary solution, have to make something more precise
-// corner = contour[min_idx];
-// return;
-// }
-
static void findCorner(const std::vector<Point2f>& contour, Point2f point, Point2f& corner)
{
// find the nearest point
static int segment_hist_max(const Mat& hist, int& low_thresh, int& high_thresh)
{
Mat bw;
- //const double max_bell_width = 20; // we expect two bells with width bounded above
- //const double min_bell_width = 5; // and below
-
double total_sum = sum(hist).val[0];
- //double thresh = total_sum/(2*max_bell_width)*0.25f; // quarter of a bar inside a bell
-
-// threshold(hist, bw, thresh, 255.0, CV_THRESH_BINARY);
double quantile_sum = 0.0;
//double min_quantile = 0.2;
const float* _ranges = ranges;
Mat hist;
-#if defined(_SUBPIX_VERBOSE)
- std::vector<float> radius;
- radius.assign(corners.size(), 0.0f);
-#endif //_SUBPIX_VERBOSE
-
-
Mat black_comp, white_comp;
for(int i = 0; i < ncorners; i++)
{
Mat img_roi = img(roi);
calcHist(&img_roi, 1, &channels, Mat(), hist, 1, &nbins, &_ranges);
-#if 0
- int black_thresh = histQuantile(hist, 0.45f);
- int white_thresh = histQuantile(hist, 0.55f);
-#else
int black_thresh = 0, white_thresh = 0;
segment_hist_max(hist, black_thresh, white_thresh);
-#endif
- threshold(img, black_comp, black_thresh, 255.0, CV_THRESH_BINARY_INV);
- threshold(img, white_comp, white_thresh, 255.0, CV_THRESH_BINARY);
+ threshold(img, black_comp, black_thresh, 255.0, THRESH_BINARY_INV);
+ threshold(img, white_comp, white_thresh, 255.0, THRESH_BINARY);
const int erode_count = 1;
erode(black_comp, black_comp, Mat(), Point(-1, -1), erode_count);
erode(white_comp, white_comp, Mat(), Point(-1, -1), erode_count);
-#if defined(_SUBPIX_VERBOSE)
- namedWindow("roi", 1);
- imshow("roi", img_roi);
- imwrite("test.jpg", img);
- namedWindow("black", 1);
- imshow("black", black_comp);
- namedWindow("white", 1);
- imshow("white", white_comp);
- cvWaitKey(0);
- imwrite("black.jpg", black_comp);
- imwrite("white.jpg", white_comp);
-#endif
-
-
std::vector<std::vector<Point> > white_contours, black_contours;
std::vector<Vec4i> white_hierarchy, black_hierarchy;
- findContours(black_comp, black_contours, black_hierarchy, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
- findContours(white_comp, white_contours, white_hierarchy, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
+ findContours(black_comp, black_contours, black_hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE);
+ findContours(white_comp, white_contours, white_hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE);
if(black_contours.size() < 5 || white_contours.size() < 5) continue;
Point2f quad_corners[4];
for(int k = 0; k < 4; k++)
{
-#if 1
std::vector<Point2f> temp;
for(size_t j = 0; j < quads[k]->size(); j++) temp.push_back((*quads[k])[j]);
approxPolyDP(Mat(temp), quads_approx[k], 0.5, true);
findCorner(quads_approx[k], corners[i], quad_corners[k]);
-#else
- findCorner(*quads[k], corners[i], quad_corners[k]);
-#endif
quad_corners[k] += Point2f(0.5f, 0.5f);
}
if(cvIsNaN(angle) || cvIsInf(angle) || angle < 0.5 || angle > CV_PI - 0.5) continue;
findLinesCrossPoint(origin1, dir1, origin2, dir2, corners[i]);
-
-#if defined(_SUBPIX_VERBOSE)
- radius[i] = norm(corners[i] - ground_truth_corners[ground_truth_idx])*6;
-
-#if 1
- Mat test(img.size(), CV_32FC3);
- cvtColor(img, test, CV_GRAY2RGB);
-// line(test, quad_corners[0] - corners[i] + Point2f(30, 30), quad_corners[1] - corners[i] + Point2f(30, 30), cvScalar(0, 255, 0));
-// line(test, quad_corners[2] - corners[i] + Point2f(30, 30), quad_corners[3] - corners[i] + Point2f(30, 30), cvScalar(0, 255, 0));
- std::vector<std::vector<Point> > contrs;
- contrs.resize(1);
- for(int k = 0; k < 4; k++)
- {
- //contrs[0] = quads_approx[k];
- contrs[0].clear();
- for(size_t j = 0; j < quads_approx[k].size(); j++) contrs[0].push_back(quads_approx[k][j]);
- drawContours(test, contrs, 0, CV_RGB(0, 0, 255), 1, 1, std::vector<Vec4i>(), 2);
- circle(test, quad_corners[k], 0.5, CV_RGB(255, 0, 0));
- }
- Mat test1 = test(Rect(corners[i].x - 30, corners[i].y - 30, 60, 60));
- namedWindow("1", 1);
- imshow("1", test1);
- imwrite("test.jpg", test);
- waitKey(0);
-#endif
-#endif //_SUBPIX_VERBOSE
-
}
-#if defined(_SUBPIX_VERBOSE)
- Mat test(img.size(), CV_32FC3);
- cvtColor(img, test, CV_GRAY2RGB);
- drawCircles(test, corners, radius);
-
- namedWindow("corners", 1);
- imshow("corners", test);
- waitKey();
-#endif //_SUBPIX_VERBOSE
-
return true;
}
for(size_t i = 0; i < brdsNum; ++i)
{
Mat gray;
- cvtColor(boards[i], gray, CV_BGR2GRAY);
+ cvtColor(boards[i], gray, COLOR_BGR2GRAY);
vector<Point2f> tmp = imagePoints_findCb[i];
cornerSubPix(gray, tmp, Size(5, 5), Size(-1,-1), tc);
imagePoints.push_back(tmp);
for(size_t i = 0; i < brdsNum; ++i)
{
Mat gray;
- cvtColor(boards[i], gray, CV_BGR2GRAY);
+ cvtColor(boards[i], gray, COLOR_BGR2GRAY);
vector<Point2f> tmp = imagePoints_findCb[i];
find4QuadCornerSubpix(gray, tmp, Size(5, 5));
imagePoints.push_back(tmp);
//M*/
#include "test_precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
class CV_ChessboardDetectorTimingTest : public cvtest::BaseTest
{
//M*/
#include "test_precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include <limits>
#include "test_chessboardgenerator.hpp"
#include <iostream>
#include "opencv2/ts.hpp"
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/calib3d.hpp"
#include "opencv2/highgui.hpp"
Mat img = _img;
if( _img.channels() > 1)
{
- Mat tmp; cvtColor( _img, tmp, CV_BGR2GRAY ); img = tmp;
+ Mat tmp; cvtColor( _img, tmp, COLOR_BGR2GRAY ); img = tmp;
}
Mat dxI; Sobel( img, dxI, CV_32FC1, 1, 0, 3 );
Mat dxI2; pow( dxI / 8.f/*normalize*/, 2, dxI2 );
RunParams params = caseRunParams[caseIdx];
assert( params.ndisp%16 == 0 );
assert( _leftImg.type() == CV_8UC3 && _rightImg.type() == CV_8UC3 );
- Mat leftImg; cvtColor( _leftImg, leftImg, CV_BGR2GRAY );
- Mat rightImg; cvtColor( _rightImg, rightImg, CV_BGR2GRAY );
+ Mat leftImg; cvtColor( _leftImg, leftImg, COLOR_BGR2GRAY );
+ Mat rightImg; cvtColor( _rightImg, rightImg, COLOR_BGR2GRAY );
Ptr<StereoBM> bm = createStereoBM( params.ndisp, params.winSize );
Mat tempDisp;
//M*/
#include "test_precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
using namespace cv;
using namespace std;
//M*/
#include "test_precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
class CV_UndistortPointsBadArgTest : public cvtest::BadArgTest
{
//M*/
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#define ASD_INTENSITY_SET_PIXEL(pointer, qq) {(*pointer) = (unsigned char)qq;}
}
// Turn into a BGR matrix into its grayscale representation.
if(src.type() == CV_8UC3)
- cvtColor(src.clone(), src, CV_BGR2GRAY);
- cvtColor(src.clone(), src, CV_GRAY2BGR);
+ cvtColor(src.clone(), src, COLOR_BGR2GRAY);
+ cvtColor(src.clone(), src, COLOR_GRAY2BGR);
// Apply the ColorMap.
LUT(src, _lut, _dst);
}
minDist = DBL_MAX;
minClass = -1;
for(size_t sampleIdx = 0; sampleIdx < _histograms.size(); sampleIdx++) {
- double dist = compareHist(_histograms[sampleIdx], query, CV_COMP_CHISQR);
+ double dist = compareHist(_histograms[sampleIdx], query, HISTCMP_CHISQR);
if((dist < minDist) && (dist < _threshold)) {
minDist = dist;
minClass = _labels.at<int>((int) sampleIdx);
// Convert the colors set to Lab space.
// Distances between colors in this space correspond a human perception.
Mat lab;
- cvtColor( bgr, lab, CV_BGR2Lab);
+ cvtColor( bgr, lab, COLOR_BGR2Lab);
// Subsample colors from the generated set so that
// to maximize the minimum distances between each other.
// Convert subsampled colors back to RGB
Mat bgr_subset;
- cvtColor( lab_subset, bgr_subset, CV_Lab2BGR );
+ cvtColor( lab_subset, bgr_subset, COLOR_Lab2BGR );
CV_Assert( bgr_subset.total() == count );
for( size_t i = 0; i < count; i++ )
#include "opencv2/features2d.hpp"
#include "opencv2/objdetect.hpp"
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/core/utility.hpp"
#include "opencv2/core/private.hpp"
int endx = (x + 1) * sz + x;
Mat color;
- cvtColor(spins[pos++], color, CV_GRAY2BGR);
+ cvtColor(spins[pos++], color, COLOR_GRAY2BGR);
Mat roi = result(Range(starty, endy), Range(startx, endx));
color.copyTo(roi);
}
// Preprocessing
Mat leftgray, rightgray;
if (left.type() != CV_8UC1) {
- cvtColor(left, leftgray, CV_BGR2GRAY);
- cvtColor(right, rightgray, CV_BGR2GRAY);
+ cvtColor(left, leftgray, COLOR_BGR2GRAY);
+ cvtColor(right, rightgray, COLOR_BGR2GRAY);
} else {
left.copyTo(leftgray);
right.copyTo(rightgray);
//! swaps two matrices
CV_EXPORTS void swap(Mat& a, Mat& b);
+//! 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.
+CV_EXPORTS_W int borderInterpolate(int p, int len, int borderType);
+
+//! copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode
+CV_EXPORTS_W void copyMakeBorder(InputArray src, OutputArray dst,
+ int top, int bottom, int left, int right,
+ int borderType, const Scalar& value = Scalar() );
+
//! adds one matrix to another (dst = src1 + src2)
CV_EXPORTS_W void add(InputArray src1, InputArray src2, OutputArray dst,
InputArray mask = noArray(), int dtype = -1);
CV_EXPORTS_W double norm(InputArray src1, InputArray src2,
int normType = NORM_L2, InputArray mask = noArray());
+//! computes PSNR image/video quality metric
+CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2);
+
//! computes norm of a sparse matrix
CV_EXPORTS double norm( const SparseMat& src, int normType );
DCT_ROWS = DFT_ROWS
};
+//! Various border types, image boundaries are denoted with '|'
+enum {
+ BORDER_CONSTANT = 0, // iiiiii|abcdefgh|iiiiiii with some specified 'i'
+ BORDER_REPLICATE = 1, // aaaaaa|abcdefgh|hhhhhhh
+ BORDER_REFLECT = 2, // fedcba|abcdefgh|hgfedcb
+ BORDER_WRAP = 3, // cdefgh|abcdefgh|abcdefg
+ BORDER_REFLECT_101 = 4, // gfedcb|abcdefgh|gfedcba
+ BORDER_TRANSPARENT = 5, // uvwxyz|absdefgh|ijklmno
+
+ BORDER_REFLECT101 = BORDER_REFLECT_101,
+ BORDER_DEFAULT = BORDER_REFLECT_101,
+ BORDER_ISOLATED = 16 // do not look outside of ROI
+ };
+
//////////////// static assert /////////////////
+///////////////////////// raster image moments //////////////////////////
+
+class CV_EXPORTS_W_MAP Moments
+{
+public:
+ //! the default constructor
+ Moments();
+ //! the full constructor
+ Moments(double m00, double m10, double m01, double m20, double m11,
+ double m02, double m30, double m21, double m12, double m03 );
+ ////! the conversion from CvMoments
+ //Moments( const CvMoments& moments );
+ ////! the conversion to CvMoments
+ //operator CvMoments() const;
+
+ //! spatial moments
+ CV_PROP_RW double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
+ //! central moments
+ CV_PROP_RW double mu20, mu11, mu02, mu30, mu21, mu12, mu03;
+ //! central normalized moments
+ CV_PROP_RW double nu20, nu11, nu02, nu30, nu21, nu12, nu03;
+};
+
+/*!
+ traits
+*/
+template<> class DataType<Moments>
+{
+public:
+ typedef Moments value_type;
+ typedef double work_type;
+ typedef double channel_type;
+
+ enum { generic_type = 0,
+ depth = DataType<channel_type>::depth,
+ channels = (int)(sizeof(value_type)/sizeof(channel_type)), // 24
+ fmt = DataType<channel_type>::fmt + ((channels - 1) << 8),
+ type = CV_MAKETYPE(depth, channels)
+ };
+
+ typedef Vec<channel_type, channels> vec_type;
+};
+
+
+
/////////////////////////////////////////////////////////////////////////
///////////////////////////// Implementation ////////////////////////////
/////////////////////////////////////////////////////////////////////////
return dst;
}
+
+} // cv
+
+
+/*
+ Various border types, image boundaries are denoted with '|'
+
+ * BORDER_REPLICATE: aaaaaa|abcdefgh|hhhhhhh
+ * BORDER_REFLECT: fedcba|abcdefgh|hgfedcb
+ * BORDER_REFLECT_101: gfedcb|abcdefgh|gfedcba
+ * BORDER_WRAP: cdefgh|abcdefgh|abcdefg
+ * BORDER_CONSTANT: iiiiii|abcdefgh|iiiiiii with some specified 'i'
+ */
+int cv::borderInterpolate( int p, int len, int borderType )
+{
+ if( (unsigned)p < (unsigned)len )
+ ;
+ else if( borderType == BORDER_REPLICATE )
+ p = p < 0 ? 0 : len - 1;
+ else if( borderType == BORDER_REFLECT || borderType == BORDER_REFLECT_101 )
+ {
+ int delta = borderType == BORDER_REFLECT_101;
+ if( len == 1 )
+ return 0;
+ do
+ {
+ if( p < 0 )
+ p = -p - 1 + delta;
+ else
+ p = len - 1 - (p - len) - delta;
+ }
+ while( (unsigned)p >= (unsigned)len );
+ }
+ else if( borderType == BORDER_WRAP )
+ {
+ if( p < 0 )
+ p -= ((p-len+1)/len)*len;
+ if( p >= len )
+ p %= len;
+ }
+ else if( borderType == BORDER_CONSTANT )
+ p = -1;
+ else
+ CV_Error( CV_StsBadArg, "Unknown/unsupported border type" );
+ return p;
+}
+
+namespace
+{
+
+void copyMakeBorder_8u( const uchar* src, size_t srcstep, cv::Size srcroi,
+ uchar* dst, size_t dststep, cv::Size dstroi,
+ int top, int left, int cn, int borderType )
+{
+ const int isz = (int)sizeof(int);
+ int i, j, k, elemSize = 1;
+ bool intMode = false;
+
+ if( (cn | srcstep | dststep | (size_t)src | (size_t)dst) % isz == 0 )
+ {
+ cn /= isz;
+ elemSize = isz;
+ intMode = true;
+ }
+
+ cv::AutoBuffer<int> _tab((dstroi.width - srcroi.width)*cn);
+ int* tab = _tab;
+ int right = dstroi.width - srcroi.width - left;
+ int bottom = dstroi.height - srcroi.height - top;
+
+ for( i = 0; i < left; i++ )
+ {
+ j = cv::borderInterpolate(i - left, srcroi.width, borderType)*cn;
+ for( k = 0; k < cn; k++ )
+ tab[i*cn + k] = j + k;
+ }
+
+ for( i = 0; i < right; i++ )
+ {
+ j = cv::borderInterpolate(srcroi.width + i, srcroi.width, borderType)*cn;
+ for( k = 0; k < cn; k++ )
+ tab[(i+left)*cn + k] = j + k;
+ }
+
+ srcroi.width *= cn;
+ dstroi.width *= cn;
+ left *= cn;
+ right *= cn;
+
+ uchar* dstInner = dst + dststep*top + left*elemSize;
+
+ for( i = 0; i < srcroi.height; i++, dstInner += dststep, src += srcstep )
+ {
+ if( dstInner != src )
+ memcpy(dstInner, src, srcroi.width*elemSize);
+
+ if( intMode )
+ {
+ const int* isrc = (int*)src;
+ int* idstInner = (int*)dstInner;
+ for( j = 0; j < left; j++ )
+ idstInner[j - left] = isrc[tab[j]];
+ for( j = 0; j < right; j++ )
+ idstInner[j + srcroi.width] = isrc[tab[j + left]];
+ }
+ else
+ {
+ for( j = 0; j < left; j++ )
+ dstInner[j - left] = src[tab[j]];
+ for( j = 0; j < right; j++ )
+ dstInner[j + srcroi.width] = src[tab[j + left]];
+ }
+ }
+
+ dstroi.width *= elemSize;
+ dst += dststep*top;
+
+ for( i = 0; i < top; i++ )
+ {
+ j = cv::borderInterpolate(i - top, srcroi.height, borderType);
+ memcpy(dst + (i - top)*dststep, dst + j*dststep, dstroi.width);
+ }
+
+ for( i = 0; i < bottom; i++ )
+ {
+ j = cv::borderInterpolate(i + srcroi.height, srcroi.height, borderType);
+ memcpy(dst + (i + srcroi.height)*dststep, dst + j*dststep, dstroi.width);
+ }
+}
+
+
+void copyMakeConstBorder_8u( const uchar* src, size_t srcstep, cv::Size srcroi,
+ uchar* dst, size_t dststep, cv::Size dstroi,
+ int top, int left, int cn, const uchar* value )
+{
+ int i, j;
+ cv::AutoBuffer<uchar> _constBuf(dstroi.width*cn);
+ uchar* constBuf = _constBuf;
+ int right = dstroi.width - srcroi.width - left;
+ int bottom = dstroi.height - srcroi.height - top;
+
+ for( i = 0; i < dstroi.width; i++ )
+ {
+ for( j = 0; j < cn; j++ )
+ constBuf[i*cn + j] = value[j];
+ }
+
+ srcroi.width *= cn;
+ dstroi.width *= cn;
+ left *= cn;
+ right *= cn;
+
+ uchar* dstInner = dst + dststep*top + left;
+
+ for( i = 0; i < srcroi.height; i++, dstInner += dststep, src += srcstep )
+ {
+ if( dstInner != src )
+ memcpy( dstInner, src, srcroi.width );
+ memcpy( dstInner - left, constBuf, left );
+ memcpy( dstInner + srcroi.width, constBuf, right );
+ }
+
+ dst += dststep*top;
+
+ for( i = 0; i < top; i++ )
+ memcpy(dst + (i - top)*dststep, constBuf, dstroi.width);
+
+ for( i = 0; i < bottom; i++ )
+ memcpy(dst + (i + srcroi.height)*dststep, constBuf, dstroi.width);
+}
+
+}
+
+void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
+ int left, int right, int borderType, const Scalar& value )
+{
+ Mat src = _src.getMat();
+ CV_Assert( top >= 0 && bottom >= 0 && left >= 0 && right >= 0 );
+
+ if( src.isSubmatrix() && (borderType & BORDER_ISOLATED) == 0 )
+ {
+ Size wholeSize;
+ Point ofs;
+ src.locateROI(wholeSize, ofs);
+ int dtop = std::min(ofs.y, top);
+ int dbottom = std::min(wholeSize.height - src.rows - ofs.y, bottom);
+ int dleft = std::min(ofs.x, left);
+ int dright = std::min(wholeSize.width - src.cols - ofs.x, right);
+ src.adjustROI(dtop, dbottom, dleft, dright);
+ top -= dtop;
+ left -= dleft;
+ bottom -= dbottom;
+ right -= dright;
+ }
+
+ _dst.create( src.rows + top + bottom, src.cols + left + right, src.type() );
+ Mat dst = _dst.getMat();
+
+ if(top == 0 && left == 0 && bottom == 0 && right == 0)
+ {
+ if(src.data != dst.data || src.step != dst.step)
+ src.copyTo(dst);
+ return;
+ }
+
+ borderType &= ~BORDER_ISOLATED;
+
+ if( borderType != BORDER_CONSTANT )
+ copyMakeBorder_8u( src.data, src.step, src.size(),
+ dst.data, dst.step, dst.size(),
+ top, left, (int)src.elemSize(), borderType );
+ else
+ {
+ int cn = src.channels(), cn1 = cn;
+ AutoBuffer<double> buf(cn);
+ if( cn > 4 )
+ {
+ CV_Assert( value[0] == value[1] && value[0] == value[2] && value[0] == value[3] );
+ cn1 = 1;
+ }
+ scalarToRawData(value, buf, CV_MAKETYPE(src.depth(), cn1), cn);
+ copyMakeConstBorder_8u( src.data, src.step, src.size(),
+ dst.data, dst.step, dst.size(),
+ top, left, (int)src.elemSize(), (uchar*)(double*)buf );
+ }
}
/* dst = src */
//M*/
#include "precomp.hpp"
+#include <limits>
using namespace cv;
using namespace cv::gpu;
//M*/
#include "precomp.hpp"
+#include <limits>
#if defined _M_IX86 && defined _MSC_VER && _MSC_VER < 1700
#pragma float_control(precise, on)
#undef min
#undef max
#undef abs
+#else
+ #include <pthread.h>
#endif
#if defined __SSE2__ || (defined _M_IX86_FP && 2 == _M_IX86_FP)
}
}
+double cv::PSNR(InputArray _src1, InputArray _src2)
+{
+ Mat src1 = _src1.getMat(), src2 = _src2.getMat();
+ CV_Assert( src1.depth() == CV_8U );
+ double diff = std::sqrt(norm(src1, src2, NORM_L2SQR)/(src1.total()*src1.channels()));
+ return 20*log10(255./(diff+DBL_EPSILON));
+}
+
CV_IMPL CvScalar cvSum( const CvArr* srcarr )
{
std::vector < std::vector<Point> > contours;
Mat tmpBinaryImage = binaryImage.clone();
- findContours(tmpBinaryImage, contours, CV_RETR_LIST, CV_CHAIN_APPROX_NONE);
+ findContours(tmpBinaryImage, contours, RETR_LIST, CHAIN_APPROX_NONE);
#ifdef DEBUG_BLOB_DETECTOR
// Mat keypointsImage;
if (ratio < params.minConvexity || ratio >= params.maxConvexity)
continue;
}
-
+
center.location = Point2d(moms.m10 / moms.m00, moms.m01 / moms.m00);
if (params.filterByColor)
keypoints.clear();
Mat grayscaleImage;
if (image.channels() == 3)
- cvtColor(image, grayscaleImage, CV_BGR2GRAY);
+ cvtColor(image, grayscaleImage, COLOR_BGR2GRAY);
else
grayscaleImage = image;
test_fn_ = pixelTests64;
break;
default:
- CV_Error(CV_StsBadArg, "bytes must be 16, 32, or 64");
+ CV_Error(Error::StsBadArg, "bytes must be 16, 32, or 64");
}
}
test_fn_ = pixelTests64;
break;
default:
- CV_Error(CV_StsBadArg, "descriptorSize must be 16, 32, or 64");
+ CV_Error(Error::StsBadArg, "descriptorSize must be 16, 32, or 64");
}
bytes_ = dSize;
}
Mat sum;
Mat grayImage = image;
- if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
+ if( image.type() != CV_8U ) cvtColor( image, grayImage, COLOR_BGR2GRAY );
///TODO allow the user to pass in a precomputed integral image
//if(image.type() == CV_32S)
// get the total number of points
const int rings = (int)radiusList.size();
- assert(radiusList.size()!=0&&radiusList.size()==numberList.size());
+ CV_Assert(radiusList.size() != 0 && radiusList.size() == numberList.size());
points_ = 0; // remember the total number of points
for (int ring = 0; ring < rings; ring++)
{
else if (norm_sq < dMax_sq)
{
// save to short pairs
- assert(noShortPairs_<indSize);
+ CV_Assert(noShortPairs_ < indSize);
// make sure the user passes something sensible
BriskShortPair& shortPair = shortPairs_[indexChange[noShortPairs_]];
shortPair.j = j;
{
Mat image = _image.getMat(), mask = _mask.getMat();
if( image.type() != CV_8UC1 )
- cvtColor(image, image, CV_BGR2GRAY);
+ cvtColor(image, image, COLOR_BGR2GRAY);
if (!useProvidedKeypoints)
{
{
Mat image = _image.getMat(), mask = _mask.getMat();
if( image.type() != CV_8UC1 )
- cvtColor(_image, image, CV_BGR2GRAY);
+ cvtColor(_image, image, COLOR_BGR2GRAY);
BriskScaleSpace briskScaleSpace(octaves);
briskScaleSpace.constructPyramid(image);
inline int
BriskScaleSpace::getScoreAbove(const int layer, const int x_layer, const int y_layer) const
{
- assert(layer<layers_-1);
+ CV_Assert(layer < layers_-1);
const BriskLayer& l = pyramid_[layer + 1];
if (layer % 2 == 0)
{ // octave
inline int
BriskScaleSpace::getScoreBelow(const int layer, const int x_layer, const int y_layer) const
{
- assert(layer);
+ CV_Assert(layer);
const BriskLayer& l = pyramid_[layer - 1];
int sixth_x;
int quarter_x;
float y1;
// the layer above
- assert(layer+1<layers_);
+ CV_Assert(layer + 1 < layers_);
const BriskLayer& layerAbove = pyramid_[layer + 1];
if (layer % 2 == 0)
}
// the layer below
- assert(layer>0);
+ CV_Assert(layer > 0);
const BriskLayer& layerBelow = pyramid_[layer - 1];
// check the first row
inline int
BriskLayer::value(const cv::Mat& mat, float xf, float yf, float scale_in) const
{
- assert(!mat.empty());
+ CV_Assert(!mat.empty());
// get the position
const int x = cvFloor(xf);
const int y = cvFloor(yf);
BriskLayer::halfsample(const cv::Mat& srcimg, cv::Mat& dstimg)
{
// make sure the destination image is of the right size:
- assert(srcimg.cols/2==dstimg.cols);
- assert(srcimg.rows/2==dstimg.rows);
+ CV_Assert(srcimg.cols / 2 == dstimg.cols);
+ CV_Assert(srcimg.rows / 2 == dstimg.rows);
//Â handle non-SSE case
resize(srcimg, dstimg, dstimg.size(), 0, 0, INTER_AREA);
BriskLayer::twothirdsample(const cv::Mat& srcimg, cv::Mat& dstimg)
{
// make sure the destination image is of the right size:
- assert((srcimg.cols/3)*2==dstimg.cols);
- assert((srcimg.rows/3)*2==dstimg.rows);
+ CV_Assert((srcimg.cols / 3) * 2 == dstimg.cols);
+ CV_Assert((srcimg.rows / 3) * 2 == dstimg.rows);
resize(srcimg, dstimg, dstimg.size(), 0, 0, INTER_AREA);
}
static void convertBGRImageToOpponentColorSpace( const Mat& bgrImage, std::vector<Mat>& opponentChannels )
{
if( bgrImage.type() != CV_8UC3 )
- CV_Error( CV_StsBadArg, "input image must be an BGR image of type CV_8UC3" );
+ CV_Error( Error::StsBadArg, "input image must be an BGR image of type CV_8UC3" );
// Prepare opponent color space storage matrices.
opponentChannels.resize( 3 );
void GFTTDetector::detectImpl( const Mat& image, std::vector<KeyPoint>& keypoints, const Mat& mask) const
{
Mat grayImage = image;
- if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
+ if( image.type() != CV_8U ) cvtColor( image, grayImage, COLOR_BGR2GRAY );
std::vector<Point2f> corners;
goodFeaturesToTrack( grayImage, corners, nfeatures, qualityLevel, minDistance, mask,
src = dst;
if( !mask.empty() )
- resize( dilated_mask, src_mask, src.size(), 0, 0, CV_INTER_AREA );
+ resize( dilated_mask, src_mask, src.size(), 0, 0, INTER_AREA );
}
}
int radius = cvRound(p.size/2 * draw_multiplier); // KeyPoint::size is a diameter
// draw the circles around keypoints with the keypoints size
- circle( img, center, radius, color, 1, CV_AA, draw_shift_bits );
+ circle( img, center, radius, color, 1, LINE_AA, draw_shift_bits );
// draw orientation of the keypoint, if it is applicable
if( p.angle != -1 )
Point orient( cvRound(cos(srcAngleRad)*radius ),
cvRound(sin(srcAngleRad)*radius )
);
- line( img, center, center+orient, color, 1, CV_AA, draw_shift_bits );
+ line( img, center, center+orient, color, 1, LINE_AA, draw_shift_bits );
}
#if 0
else
{
// draw center with R=1
int radius = 1 * draw_multiplier;
- circle( img, center, radius, color, 1, CV_AA, draw_shift_bits );
+ circle( img, center, radius, color, 1, LINE_AA, draw_shift_bits );
}
#endif
}
{
// draw center with R=3
int radius = 3 * draw_multiplier;
- circle( img, center, radius, color, 1, CV_AA, draw_shift_bits );
+ circle( img, center, radius, color, 1, LINE_AA, draw_shift_bits );
}
}
}
else if( image.type() == CV_8UC1 )
{
- cvtColor( image, outImage, CV_GRAY2BGR );
+ cvtColor( image, outImage, COLOR_GRAY2BGR );
}
else
{
- CV_Error( CV_StsBadArg, "Incorrect type of input image.\n" );
+ CV_Error( Error::StsBadArg, "Incorrect type of input image.\n" );
}
}
if( flags & DrawMatchesFlags::DRAW_OVER_OUTIMG )
{
if( size.width > outImg.cols || size.height > outImg.rows )
- CV_Error( CV_StsBadSize, "outImg has size less than need to draw img1 and img2 together" );
+ CV_Error( Error::StsBadSize, "outImg has size less than need to draw img1 and img2 together" );
outImg1 = outImg( Rect(0, 0, img1.cols, img1.rows) );
outImg2 = outImg( Rect(img1.cols, 0, img2.cols, img2.rows) );
}
outImg2 = outImg( Rect(img1.cols, 0, img2.cols, img2.rows) );
if( img1.type() == CV_8U )
- cvtColor( img1, outImg1, CV_GRAY2BGR );
+ cvtColor( img1, outImg1, COLOR_GRAY2BGR );
else
img1.copyTo( outImg1 );
if( img2.type() == CV_8U )
- cvtColor( img2, outImg2, CV_GRAY2BGR );
+ cvtColor( img2, outImg2, COLOR_GRAY2BGR );
else
img2.copyTo( outImg2 );
}
line( outImg,
Point(cvRound(pt1.x*draw_multiplier), cvRound(pt1.y*draw_multiplier)),
Point(cvRound(dpt2.x*draw_multiplier), cvRound(dpt2.y*draw_multiplier)),
- color, 1, CV_AA, draw_shift_bits );
+ color, 1, LINE_AA, draw_shift_bits );
}
void drawMatches( const Mat& img1, const std::vector<KeyPoint>& keypoints1,
const std::vector<char>& matchesMask, int flags )
{
if( !matchesMask.empty() && matchesMask.size() != matches1to2.size() )
- CV_Error( CV_StsBadSize, "matchesMask must have the same size as matches1to2" );
+ CV_Error( Error::StsBadSize, "matchesMask must have the same size as matches1to2" );
Mat outImg1, outImg2;
_prepareImgAndDrawKeypoints( img1, keypoints1, img2, keypoints2,
const std::vector<std::vector<char> >& matchesMask, int flags )
{
if( !matchesMask.empty() && matchesMask.size() != matches1to2.size() )
- CV_Error( CV_StsBadSize, "matchesMask must have the same size as matches1to2" );
+ CV_Error( Error::StsBadSize, "matchesMask must have the same size as matches1to2" );
Mat outImg1, outImg2;
_prepareImgAndDrawKeypoints( img1, keypoints1, img2, keypoints2,
for( size_t i = 0; i < src.size(); i++ )
{
float rad = src[i].size/2;
- assert( rad );
+ CV_Assert( rad );
float fac = 1.f/(rad*rad);
dst[i] = EllipticKeyPoint( src[i].pt, Scalar(fac, 0, fac) );
}
{
if( !src.empty() )
{
- assert( !H.empty() && H.cols == 3 && H.rows == 3);
+ CV_Assert( !H.empty() && H.cols == 3 && H.rows == 3);
dst.resize(src.size());
std::vector<EllipticKeyPoint>::const_iterator srcIt = src.begin();
std::vector<EllipticKeyPoint>::iterator dstIt = dst.begin();
keypoints2 = _keypoints2 != 0 ? _keypoints2 : &buf2;
if( (keypoints1->empty() || keypoints2->empty()) && fdetector.empty() )
- CV_Error( CV_StsBadArg, "fdetector must not be empty when keypoints1 or keypoints2 is empty" );
+ CV_Error( Error::StsBadArg, "fdetector must not be empty when keypoints1 or keypoints2 is empty" );
if( keypoints1->empty() )
fdetector->detect( img1, *keypoints1 );
correctMatches1to2Mask = _correctMatches1to2Mask != 0 ? _correctMatches1to2Mask : &buf2;
if( keypoints1.empty() )
- CV_Error( CV_StsBadArg, "keypoints1 must not be empty" );
+ CV_Error( Error::StsBadArg, "keypoints1 must not be empty" );
if( matches1to2->empty() && dmatcher.empty() )
- CV_Error( CV_StsBadArg, "dmatch must not be empty when matches1to2 is empty" );
+ CV_Error( Error::StsBadArg, "dmatch must not be empty when matches1to2 is empty" );
bool computeKeypoints2ByPrj = keypoints2.empty();
if( computeKeypoints2ByPrj )
{
- assert(0);
+ CV_Error(Error::StsNotImplemented, "");
// TODO: add computing keypoints2 from keypoints1 using H1to2
}
void FastFeatureDetector::detectImpl( const Mat& image, std::vector<KeyPoint>& keypoints, const Mat& mask ) const
{
Mat grayImage = image;
- if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
+ if( image.type() != CV_8U ) cvtColor( image, grayImage, COLOR_BGR2GRAY );
FAST( grayImage, keypoints, threshold, nonmaxSuppression, type );
KeyPointsFilter::runByPixelsMask( keypoints, mask );
}
descriptionPairs[i] = allPairs[selectedPairs0.at(i)];
}
else {
- CV_Error(CV_StsVecLengthErr, "Input vector does not match the required size");
+ CV_Error(Error::StsVecLengthErr, "Input vector does not match the required size");
}
}
else { // default selected pairs
int idxB = pairStat[m].idx;
double corr(0);
// compute correlation between 2 pairs
- corr = fabs(compareHist(descriptorsFloat.col(idxA), descriptorsFloat.col(idxB), CV_COMP_CORREL));
+ corr = fabs(compareHist(descriptorsFloat.col(idxA), descriptorsFloat.col(idxB), HISTCMP_CORREL));
if( corr > corrMax ) {
corrMax = corr;
else {
if( verbose )
std::cout << "correlation threshold too small (restrictive)" << std::endl;
- CV_Error(CV_StsError, "correlation threshold too small (restrictive)");
+ CV_Error(Error::StsError, "correlation threshold too small (restrictive)");
}
extAll = false;
return idxBestPairs;
dim = descriptors[0].cols;
type = descriptors[0].type();
}
- assert( dim > 0 );
+ CV_Assert( dim > 0 );
int count = startIdxs[imageCount-1] + descriptors[imageCount-1].rows;
dm = new BFMatcher(NORM_HAMMING2);
}
else
- CV_Error( CV_StsBadArg, "Unknown matcher name" );
+ CV_Error( Error::StsBadArg, "Unknown matcher name" );
return dm;
}
FlannBasedMatcher* matcher = new FlannBasedMatcher(indexParams, searchParams);
if( !emptyTrainData )
{
- CV_Error( CV_StsNotImplemented, "deep clone functionality is not implemented, because "
+ CV_Error( Error::StsNotImplemented, "deep clone functionality is not implemented, because "
"Flann::Index has not copy constructor or clone method ");
//matcher->flannIndex;
matcher->addedDescCount = addedDescCount;
*/
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
namespace cv
{
}
}
else
- CV_Error( CV_StsBadSize, "Wrong WTA_K. It can be only 2, 3 or 4." );
+ CV_Error( Error::StsBadSize, "Wrong WTA_K. It can be only 2, 3 or 4." );
#undef GET_VALUE
}
Mat image = _image.getMat(), mask = _mask.getMat();
if( image.type() != CV_8UC1 )
- cvtColor(_image, image, CV_BGR2GRAY);
+ cvtColor(_image, image, COLOR_BGR2GRAY);
int levelsNum = this->nlevels;
#include "opencv2/features2d.hpp"
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/core/utility.hpp"
#include "opencv2/core/private.hpp"
#if CV_SSE2
__m128 invSizes4[MAX_PATTERN][2];
__m128 sizes1_4[MAX_PATTERN];
- Cv32suf absmask;
+ union { int i; float f; } absmask;
absmask.i = 0x7fffffff;
volatile bool useSIMD = cv::checkHardwareSupport(CV_CPU_SSE2);
#endif
void StarDetector::detectImpl( const Mat& image, std::vector<KeyPoint>& keypoints, const Mat& mask ) const
{
Mat grayImage = image;
- if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
+ if( image.type() != CV_8U ) cvtColor( image, grayImage, COLOR_BGR2GRAY );
(*this)(grayImage, keypoints);
KeyPointsFilter::runByPixelsMask( keypoints, mask );
}
Mat gray1, gray2;
- cvtColor(image1, gray1, CV_BGR2GRAY);
- cvtColor(image2, gray2, CV_BGR2GRAY);
+ cvtColor(image1, gray1, COLOR_BGR2GRAY);
+ cvtColor(image2, gray2, COLOR_BGR2GRAY);
Ptr<FeatureDetector> detector = Algorithm::create<FeatureDetector>("Feature2D.BRISK");
size_t elements_read4 = fread( (void*)&dataSize, sizeof(int), 1, f );
CV_Assert(elements_read1 == 1 && elements_read2 == 1 && elements_read3 == 1 && elements_read4 == 1);
- uchar* data = (uchar*)cvAlloc(dataSize);
- size_t elements_read = fread( (void*)data, 1, dataSize, f );
+ size_t step = dataSize / rows / CV_ELEM_SIZE(type);
+ CV_Assert(step >= (size_t)cols);
+
+ Mat m = Mat( rows, step, type).colRange(0, cols);
+
+ size_t elements_read = fread( m.ptr(), 1, dataSize, f );
CV_Assert(elements_read == (size_t)(dataSize));
fclose(f);
- return Mat( rows, cols, type, data );
+ return m;
}
return Mat();
}
double t = (double)getTickCount();
dextractor->compute( img, keypoints, calcDescriptors );
t = getTickCount() - t;
- ts->printf(cvtest::TS::LOG, "\nAverage time of computing one descriptor = %g ms.\n", t/((double)cvGetTickFrequency()*1000.)/calcDescriptors.rows);
+ ts->printf(cvtest::TS::LOG, "\nAverage time of computing one descriptor = %g ms.\n", t/((double)getTickFrequency()*1000.)/calcDescriptors.rows);
if( calcDescriptors.rows != (int)keypoints.size() )
{
}
Mat gray1, gray2;
- cvtColor(image1, gray1, CV_BGR2GRAY);
- cvtColor(image2, gray2, CV_BGR2GRAY);
+ cvtColor(image1, gray1, COLOR_BGR2GRAY);
+ cvtColor(image2, gray2, COLOR_BGR2GRAY);
vector<KeyPoint> keypoints1;
vector<KeyPoint> keypoints2;
for(size_t i = 0; i < keypoints1.size(); ++i)
{
const KeyPoint& kp = keypoints1[i];
- cv::circle(image1, kp.pt, cvRound(kp.size/2), CV_RGB(255, 0, 0));
+ cv::circle(image1, kp.pt, cvRound(kp.size/2), Scalar(255, 0, 0));
}
for(size_t i = 0; i < keypoints2.size(); ++i)
{
const KeyPoint& kp = keypoints2[i];
- cv::circle(image2, kp.pt, cvRound(kp.size/2), CV_RGB(255, 0, 0));
+ cv::circle(image2, kp.pt, cvRound(kp.size/2), Scalar(255, 0, 0));
}
Mat kps1(1, (int)(keypoints1.size() * sizeof(KeyPoint)), CV_8U, &keypoints1[0]);
//M*/
#include "test_precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include <vector>
#include <string>
#include "opencv2/ts.hpp"
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/features2d.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
vector<KeyPoint> keypoints0;
featureDetector->detect(image0, keypoints0);
if(keypoints0.size() < 15)
- CV_Error(CV_StsAssert, "Detector gives too few points in a test image\n");
+ CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
const int maxAngle = 360, angleStep = 15;
for(int angle = 0; angle < maxAngle; angle += angleStep)
float angle0 = keypoints0[matches[m].queryIdx].angle;
float angle1 = keypoints1[matches[m].trainIdx].angle;
if(angle0 == -1 || angle1 == -1)
- CV_Error(CV_StsBadArg, "Given FeatureDetector is not rotation invariant, it can not be tested here.\n");
+ CV_Error(Error::StsBadArg, "Given FeatureDetector is not rotation invariant, it can not be tested here.\n");
CV_Assert(angle0 >= 0.f && angle0 < 360.f);
CV_Assert(angle1 >= 0.f && angle1 < 360.f);
Mat descriptors0;
featureDetector->detect(image0, keypoints0);
if(keypoints0.size() < 15)
- CV_Error(CV_StsAssert, "Detector gives too few points in a test image\n");
+ CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
descriptorExtractor->compute(image0, keypoints0, descriptors0);
BFMatcher bfmatcher(normType);
vector<KeyPoint> keypoints0;
featureDetector->detect(image0, keypoints0);
if(keypoints0.size() < 15)
- CV_Error(CV_StsAssert, "Detector gives too few points in a test image\n");
+ CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
for(int scaleIdx = 1; scaleIdx <= 3; scaleIdx++)
{
vector<KeyPoint> keypoints1, osiKeypoints1; // osi - original size image
featureDetector->detect(image1, keypoints1);
if(keypoints1.size() < 15)
- CV_Error(CV_StsAssert, "Detector gives too few points in a test image\n");
+ CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
if(keypoints1.size() > keypoints0.size())
{
vector<KeyPoint> keypoints0;
featureDetector->detect(image0, keypoints0);
if(keypoints0.size() < 15)
- CV_Error(CV_StsAssert, "Detector gives too few points in a test image\n");
+ CV_Error(Error::StsAssert, "Detector gives too few points in a test image\n");
Mat descriptors0;
descriptorExtractor->compute(image0, keypoints0, descriptors0);
#include "opencv2/core/utility.hpp"
#include "opencv2/gpu.hpp"
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/calib3d.hpp"
#include "opencv2/video.hpp"
#define __HIGHGUI_H_
#include "opencv2/highgui.hpp"
-#include "opencv2/highgui/highgui_c.h"
-#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/core/utility.hpp"
#include "opencv2/core/private.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/highgui/highgui_c.h"
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
namespace cv
{
-//! Various border types, image boundaries are denoted with '|'
-enum {
- BORDER_CONSTANT = 0, // iiiiii|abcdefgh|iiiiiii with some specified 'i'
- BORDER_REPLICATE = 1, // aaaaaa|abcdefgh|hhhhhhh
- BORDER_REFLECT = 2, // fedcba|abcdefgh|hgfedcb
- BORDER_WRAP = 3, // cdefgh|abcdefgh|abcdefg
- BORDER_REFLECT_101 = 4, // gfedcb|abcdefgh|gfedcba
- BORDER_TRANSPARENT = 5, // uvwxyz|absdefgh|ijklmno
-
- BORDER_REFLECT101 = BORDER_REFLECT_101,
- BORDER_DEFAULT = BORDER_REFLECT_101,
- BORDER_ISOLATED = 16 // do not look outside of ROI
- };
-
//! type of the kernel
enum { KERNEL_GENERAL = 0, // the kernel is generic. No any type of symmetry or other properties.
KERNEL_SYMMETRICAL = 1, // kernel[i] == kernel[ksize-i-1] , and the anchor is at the center
};
-//! raster image moments
-class CV_EXPORTS_W_MAP Moments
-{
-public:
- //! the default constructor
- Moments();
- //! the full constructor
- Moments(double m00, double m10, double m01, double m20, double m11,
- double m02, double m30, double m21, double m12, double m03 );
- ////! the conversion from CvMoments
- //Moments( const CvMoments& moments );
- ////! the conversion to CvMoments
- //operator CvMoments() const;
-
- //! spatial moments
- CV_PROP_RW double m00, m10, m01, m20, m11, m02, m30, m21, m12, m03;
- //! central moments
- CV_PROP_RW double mu20, mu11, mu02, mu30, mu21, mu12, mu03;
- //! central normalized moments
- CV_PROP_RW double nu20, nu11, nu02, nu30, nu21, nu12, nu03;
-};
-
-
class CV_EXPORTS_W Subdiv2D
{
public:
//! returns structuring element of the specified shape and size
CV_EXPORTS_W Mat getStructuringElement(int shape, Size ksize, Point anchor = Point(-1,-1));
-//! 1D interpolation function: returns coordinate of the "donor" pixel for the specified location p.
-CV_EXPORTS_W int borderInterpolate( int p, int len, int borderType );
-
-//! copies 2D array to a larger destination array with extrapolation of the outer part of src using the specified border mode
-CV_EXPORTS_W void copyMakeBorder( InputArray src, OutputArray dst,
- int top, int bottom, int left, int right,
- int borderType, const Scalar& value = Scalar() );
-
//! smooths the image using median filter.
CV_EXPORTS_W void medianBlur( InputArray src, OutputArray dst, int ksize );
CV_EXPORTS_W void accumulateWeighted( InputArray src, InputOutputArray dst,
double alpha, InputArray mask = noArray() );
-//! computes PSNR image/video quality metric
-CV_EXPORTS_W double PSNR(InputArray src1, InputArray src2);
-
CV_EXPORTS_W Point2d phaseCorrelate(InputArray src1, InputArray src2,
InputArray window = noArray(), CV_OUT double* response = 0);
#include "opencv2/core/core_c.h"
#ifdef __cplusplus
-# include "opencv2/imgproc.hpp"
-#endif
-
-#ifdef __cplusplus
extern "C" {
#endif
Base Image Filter
\****************************************************************************************/
-/*
- Various border types, image boundaries are denoted with '|'
-
- * BORDER_REPLICATE: aaaaaa|abcdefgh|hhhhhhh
- * BORDER_REFLECT: fedcba|abcdefgh|hgfedcb
- * BORDER_REFLECT_101: gfedcb|abcdefgh|gfedcba
- * BORDER_WRAP: cdefgh|abcdefgh|abcdefg
- * BORDER_CONSTANT: iiiiii|abcdefgh|iiiiiii with some specified 'i'
- */
-int cv::borderInterpolate( int p, int len, int borderType )
-{
- if( (unsigned)p < (unsigned)len )
- ;
- else if( borderType == BORDER_REPLICATE )
- p = p < 0 ? 0 : len - 1;
- else if( borderType == BORDER_REFLECT || borderType == BORDER_REFLECT_101 )
- {
- int delta = borderType == BORDER_REFLECT_101;
- if( len == 1 )
- return 0;
- do
- {
- if( p < 0 )
- p = -p - 1 + delta;
- else
- p = len - 1 - (p - len) - delta;
- }
- while( (unsigned)p >= (unsigned)len );
- }
- else if( borderType == BORDER_WRAP )
- {
- if( p < 0 )
- p -= ((p-len+1)/len)*len;
- if( p >= len )
- p %= len;
- }
- else if( borderType == BORDER_CONSTANT )
- p = -1;
- else
- CV_Error( CV_StsBadArg, "Unknown/unsupported border type" );
- return p;
-}
-
-
namespace cv
{
#include "precomp.hpp"
#include <functional>
+#include <limits>
using namespace cv;
#ifndef __OPENCV_PRECOMP_H__
#define __OPENCV_PRECOMP_H__
-
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
-
#include "opencv2/core/utility.hpp"
+
+#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/core/private.hpp"
#include <math.h>
return (CvSeq*)contour_header;
}
-namespace cv
-{
-
-static void copyMakeBorder_8u( const uchar* src, size_t srcstep, Size srcroi,
- uchar* dst, size_t dststep, Size dstroi,
- int top, int left, int cn, int borderType )
-{
- const int isz = (int)sizeof(int);
- int i, j, k, elemSize = 1;
- bool intMode = false;
-
- if( (cn | srcstep | dststep | (size_t)src | (size_t)dst) % isz == 0 )
- {
- cn /= isz;
- elemSize = isz;
- intMode = true;
- }
-
- AutoBuffer<int> _tab((dstroi.width - srcroi.width)*cn);
- int* tab = _tab;
- int right = dstroi.width - srcroi.width - left;
- int bottom = dstroi.height - srcroi.height - top;
-
- for( i = 0; i < left; i++ )
- {
- j = borderInterpolate(i - left, srcroi.width, borderType)*cn;
- for( k = 0; k < cn; k++ )
- tab[i*cn + k] = j + k;
- }
-
- for( i = 0; i < right; i++ )
- {
- j = borderInterpolate(srcroi.width + i, srcroi.width, borderType)*cn;
- for( k = 0; k < cn; k++ )
- tab[(i+left)*cn + k] = j + k;
- }
-
- srcroi.width *= cn;
- dstroi.width *= cn;
- left *= cn;
- right *= cn;
-
- uchar* dstInner = dst + dststep*top + left*elemSize;
-
- for( i = 0; i < srcroi.height; i++, dstInner += dststep, src += srcstep )
- {
- if( dstInner != src )
- memcpy(dstInner, src, srcroi.width*elemSize);
-
- if( intMode )
- {
- const int* isrc = (int*)src;
- int* idstInner = (int*)dstInner;
- for( j = 0; j < left; j++ )
- idstInner[j - left] = isrc[tab[j]];
- for( j = 0; j < right; j++ )
- idstInner[j + srcroi.width] = isrc[tab[j + left]];
- }
- else
- {
- for( j = 0; j < left; j++ )
- dstInner[j - left] = src[tab[j]];
- for( j = 0; j < right; j++ )
- dstInner[j + srcroi.width] = src[tab[j + left]];
- }
- }
-
- dstroi.width *= elemSize;
- dst += dststep*top;
-
- for( i = 0; i < top; i++ )
- {
- j = borderInterpolate(i - top, srcroi.height, borderType);
- memcpy(dst + (i - top)*dststep, dst + j*dststep, dstroi.width);
- }
-
- for( i = 0; i < bottom; i++ )
- {
- j = borderInterpolate(i + srcroi.height, srcroi.height, borderType);
- memcpy(dst + (i + srcroi.height)*dststep, dst + j*dststep, dstroi.width);
- }
-}
-
-
-static void copyMakeConstBorder_8u( const uchar* src, size_t srcstep, Size srcroi,
- uchar* dst, size_t dststep, Size dstroi,
- int top, int left, int cn, const uchar* value )
-{
- int i, j;
- AutoBuffer<uchar> _constBuf(dstroi.width*cn);
- uchar* constBuf = _constBuf;
- int right = dstroi.width - srcroi.width - left;
- int bottom = dstroi.height - srcroi.height - top;
-
- for( i = 0; i < dstroi.width; i++ )
- {
- for( j = 0; j < cn; j++ )
- constBuf[i*cn + j] = value[j];
- }
-
- srcroi.width *= cn;
- dstroi.width *= cn;
- left *= cn;
- right *= cn;
-
- uchar* dstInner = dst + dststep*top + left;
-
- for( i = 0; i < srcroi.height; i++, dstInner += dststep, src += srcstep )
- {
- if( dstInner != src )
- memcpy( dstInner, src, srcroi.width );
- memcpy( dstInner - left, constBuf, left );
- memcpy( dstInner + srcroi.width, constBuf, right );
- }
-
- dst += dststep*top;
-
- for( i = 0; i < top; i++ )
- memcpy(dst + (i - top)*dststep, constBuf, dstroi.width);
-
- for( i = 0; i < bottom; i++ )
- memcpy(dst + (i + srcroi.height)*dststep, constBuf, dstroi.width);
-}
-
-}
-
-void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
- int left, int right, int borderType, const Scalar& value )
-{
- Mat src = _src.getMat();
- CV_Assert( top >= 0 && bottom >= 0 && left >= 0 && right >= 0 );
-
- if( src.isSubmatrix() && (borderType & BORDER_ISOLATED) == 0 )
- {
- Size wholeSize;
- Point ofs;
- src.locateROI(wholeSize, ofs);
- int dtop = std::min(ofs.y, top);
- int dbottom = std::min(wholeSize.height - src.rows - ofs.y, bottom);
- int dleft = std::min(ofs.x, left);
- int dright = std::min(wholeSize.width - src.cols - ofs.x, right);
- src.adjustROI(dtop, dbottom, dleft, dright);
- top -= dtop;
- left -= dleft;
- bottom -= dbottom;
- right -= dright;
- }
-
- _dst.create( src.rows + top + bottom, src.cols + left + right, src.type() );
- Mat dst = _dst.getMat();
-
- if(top == 0 && left == 0 && bottom == 0 && right == 0)
- {
- if(src.data != dst.data || src.step != dst.step)
- src.copyTo(dst);
- return;
- }
-
- borderType &= ~BORDER_ISOLATED;
-
- if( borderType != BORDER_CONSTANT )
- copyMakeBorder_8u( src.data, src.step, src.size(),
- dst.data, dst.step, dst.size(),
- top, left, (int)src.elemSize(), borderType );
- else
- {
- int cn = src.channels(), cn1 = cn;
- AutoBuffer<double> buf(cn);
- if( cn > 4 )
- {
- CV_Assert( value[0] == value[1] && value[0] == value[2] && value[0] == value[3] );
- cn1 = 1;
- }
- scalarToRawData(value, buf, CV_MAKETYPE(src.depth(), cn1), cn);
- copyMakeConstBorder_8u( src.data, src.step, src.size(),
- dst.data, dst.step, dst.size(),
- top, left, (int)src.elemSize(), (uchar*)(double*)buf );
- }
-}
-
-
-double cv::PSNR(InputArray _src1, InputArray _src2)
-{
- Mat src1 = _src1.getMat(), src2 = _src2.getMat();
- CV_Assert( src1.depth() == CV_8U );
- double diff = std::sqrt(norm(src1, src2, NORM_L2SQR)/(src1.total()*src1.channels()));
- return 20*log10(255./(diff+DBL_EPSILON));
-}
-
-
CV_IMPL void
cvCopyMakeBorder( const CvArr* srcarr, CvArr* dstarr, CvPoint offset,
int borderType, CvScalar value )
}
+ public void testCopyMakeBorderMatMatIntIntIntIntInt() {
+ Mat src = new Mat(2, 2, CvType.CV_32F, new Scalar(1));
+ int border = 2;
+
+ Core.copyMakeBorder(src, dst, border, border, border, border, Core.BORDER_REPLICATE);
+
+ truth = new Mat(6, 6, CvType.CV_32F, new Scalar(1));
+ assertMatEqual(truth, dst, EPS);
+ }
+
+ public void testCopyMakeBorderMatMatIntIntIntIntIntScalar() {
+ Mat src = new Mat(2, 2, CvType.CV_32F, new Scalar(1));
+
+ Scalar value = new Scalar(0);
+ int border = 2;
+
+ Core.copyMakeBorder(src, dst, border, border, border, border, Core.BORDER_REPLICATE, value);
+ // TODO_: write better test (use Core.BORDER_CONSTANT)
+
+ truth = new Mat(6, 6, CvType.CV_32F, new Scalar(1));
+ assertMatEqual(truth, dst, EPS);
+ }
+
+ public void testBorderInterpolate() {
+ float val1 = Core.borderInterpolate(100, 150, Core.BORDER_REFLECT_101);
+ assertEquals(100f, val1);
+
+ float val2 = Core.borderInterpolate(-5, 10, Core.BORDER_WRAP);
+ assertEquals(5f, val2);
+ }
+
}
}
public void testBilateralFilterMatMatIntDoubleDoubleInt() {
- Imgproc.bilateralFilter(gray255, dst, 5, 10, 5, Imgproc.BORDER_REFLECT);
+ Imgproc.bilateralFilter(gray255, dst, 5, 10, 5, Core.BORDER_REFLECT);
assertMatEqual(gray255, dst);
// TODO_: write better test
}
public void testBlurMatMatSizePointInt() {
- Imgproc.blur(gray0, dst, size, anchorPoint, Imgproc.BORDER_REFLECT);
+ Imgproc.blur(gray0, dst, size, anchorPoint, Core.BORDER_REFLECT);
assertMatEqual(gray0, dst);
// TODO_: write better test
}
- public void testBorderInterpolate() {
- float val1 = Imgproc.borderInterpolate(100, 150, Imgproc.BORDER_REFLECT_101);
- assertEquals(100f, val1);
-
- float val2 = Imgproc.borderInterpolate(-5, 10, Imgproc.BORDER_WRAP);
- assertEquals(5f, val2);
- }
-
public void testBoundingRect() {
MatOfPoint points = new MatOfPoint(new Point(0, 0), new Point(0, 4), new Point(4, 0), new Point(4, 4));
Point p1 = new Point(1, 1);
}
public void testBoxFilterMatMatIntSizePointBooleanInt() {
- Imgproc.boxFilter(gray255, dst, 8, size, anchorPoint, false, Imgproc.BORDER_REFLECT);
+ Imgproc.boxFilter(gray255, dst, 8, size, anchorPoint, false, Core.BORDER_REFLECT);
assertMatEqual(gray255, dst);
// TODO_: write better test
}
assertMatEqual(new MatOfInt4(3, 0, 5, 3620), convexityDefects);
}
- public void testCopyMakeBorderMatMatIntIntIntIntInt() {
- Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(1));
- int border = 2;
-
- Imgproc.copyMakeBorder(src, dst, border, border, border, border, Imgproc.BORDER_REPLICATE);
-
- truth = new Mat(6, 6, CvType.CV_32F, new Scalar(1));
- assertMatEqual(truth, dst, EPS);
- }
-
- public void testCopyMakeBorderMatMatIntIntIntIntIntScalar() {
- Mat src = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(1));
-
- Scalar value = new Scalar(0);
- int border = 2;
-
- Imgproc.copyMakeBorder(src, dst, border, border, border, border, Imgproc.BORDER_REPLICATE, value);
- // TODO_: write better test (use Imgproc.BORDER_CONSTANT)
-
- truth = new Mat(6, 6, CvType.CV_32F, new Scalar(1));
- assertMatEqual(truth, dst, EPS);
- }
-
public void testCornerEigenValsAndVecsMatMatIntInt() {
fail("Not yet implemented");
// TODO: write better test
truth = new Mat(4, 4, CvType.CV_32FC(6), new Scalar(0));
- Imgproc.cornerEigenValsAndVecs(src, dst, blockSize, ksize, Imgproc.BORDER_REFLECT);
+ Imgproc.cornerEigenValsAndVecs(src, dst, blockSize, ksize, Core.BORDER_REFLECT);
assertMatEqual(truth, dst, EPS);
}
int blockSize = 5;
int ksize = 7;
double k = 0.1;
- Imgproc.cornerHarris(gray255, dst, blockSize, ksize, k, Imgproc.BORDER_REFLECT);
+ Imgproc.cornerHarris(gray255, dst, blockSize, ksize, k, Core.BORDER_REFLECT);
assertMatEqual(truth, dst, EPS);
}
int blockSize = 3;
int ksize = 5;
- Imgproc.cornerMinEigenVal(src, dst, blockSize, ksize, Imgproc.BORDER_REFLECT);
+ Imgproc.cornerMinEigenVal(src, dst, blockSize, ksize, Core.BORDER_REFLECT);
truth = new Mat(3, 3, CvType.CV_32FC1) {
{
Mat kernel = new Mat();
Scalar sc = new Scalar(3, 3);
- Imgproc.erode(src, dst, kernel, anchorPoint, 10, Imgproc.BORDER_REFLECT, sc);
+ Imgproc.erode(src, dst, kernel, anchorPoint, 10, Core.BORDER_REFLECT, sc);
truth = new Mat(3, 3, CvType.CV_8U, new Scalar(8));
assertMatEqual(truth, dst);
Mat kernel = new Mat(imgprocSz, imgprocSz, CvType.CV_32F, new Scalar(0));
Point point = new Point(0, 0);
- Imgproc.filter2D(gray128, dst, -1, kernel, point, 2, Imgproc.BORDER_CONSTANT);
+ Imgproc.filter2D(gray128, dst, -1, kernel, point, 2, Core.BORDER_CONSTANT);
assertMatEqual(gray2, dst);
}
}
public void testGaussianBlurMatMatSizeDoubleDoubleInt() {
- Imgproc.GaussianBlur(gray2, dst, size, 1, 3, Imgproc.BORDER_REFLECT);
+ Imgproc.GaussianBlur(gray2, dst, size, 1, 3, Core.BORDER_REFLECT);
assertMatEqual(gray2, dst);
// TODO_: write better test
public void testLaplacianMatMatIntIntDoubleDoubleInt() {
Mat src = new Mat(3, 3, CvType.CV_32F, new Scalar(2));
- Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2, EPS, Imgproc.BORDER_REFLECT);
+ Imgproc.Laplacian(src, dst, CvType.CV_32F, 1, 2, EPS, Core.BORDER_REFLECT);
truth = new Mat(3, 3, CvType.CV_32F, new Scalar(0.00099945068));
assertMatEqual(truth, dst, EPS);
Point point = new Point(1, 1);
Scalar sc = new Scalar(3, 3);
- Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel, point, 10, Imgproc.BORDER_REFLECT, sc);
+ Imgproc.morphologyEx(src, dst, Imgproc.MORPH_TOPHAT, kernel, point, 10, Core.BORDER_REFLECT, sc);
truth = new Mat(imgprocSz, imgprocSz, CvType.CV_8U) {
{
put(0, 0, 1, 0);
Mat src = new Mat(4, 4, CvType.CV_32F, new Scalar(1));
int ksize = 3;
- Imgproc.preCornerDetect(src, dst, ksize, Imgproc.BORDER_REFLECT);
+ Imgproc.preCornerDetect(src, dst, ksize, Core.BORDER_REFLECT);
truth = new Mat(4, 4, CvType.CV_32F, new Scalar(0));
assertMatEqual(truth, dst, EPS);
truth = new Mat(1, 3, CvType.CV_32F, new Scalar(2));
- Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR, Imgproc.BORDER_REFLECT, sc);
+ Imgproc.remap(src, dst, map1, map2, Imgproc.INTER_LINEAR, Core.BORDER_REFLECT, sc);
assertMatEqual(truth, dst, EPS);
}
public void testScharrMatMatIntIntIntDoubleDoubleInt() {
Mat src = Mat.eye(3, 3, CvType.CV_32F);
- Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0, 1.5, 0, Imgproc.BORDER_REFLECT);
+ Imgproc.Scharr(src, dst, CvType.CV_32F, 1, 0, 1.5, 0, Core.BORDER_REFLECT);
truth = new Mat(3, 3, CvType.CV_32F) {
{
Mat kernelY = new Mat(1, 3, CvType.CV_32FC1);
kernelY.put(0, 0, 1, 1, 1);
- Imgproc.sepFilter2D(gray0, dst, CvType.CV_32F, kernelX, kernelY, anchorPoint, weakEPS, Imgproc.BORDER_REFLECT);
+ Imgproc.sepFilter2D(gray0, dst, CvType.CV_32F, kernelX, kernelY, anchorPoint, weakEPS, Core.BORDER_REFLECT);
truth = new Mat(10, 10, CvType.CV_32F, new Scalar(weakEPS));
assertMatEqual(truth, dst, EPS);
}
};
- Imgproc.Sobel(src, dst, CvType.CV_32F, 1, 0, 3, 2, 0, Imgproc.BORDER_REPLICATE);
+ Imgproc.Sobel(src, dst, CvType.CV_32F, 1, 0, 3, 2, 0, Core.BORDER_REPLICATE);
truth = new Mat(3, 3, CvType.CV_32F) {
{
if( grayImage.channels() > 1 )
{
Mat temp;
- cvtColor(grayImage, temp, CV_BGR2GRAY);
+ cvtColor(grayImage, temp, COLOR_BGR2GRAY);
grayImage = temp;
}
continue;
Mat scaledImage( scaledImageSize, CV_8U, imageBuffer.data );
- resize( grayImage, scaledImage, scaledImageSize, 0, 0, CV_INTER_LINEAR );
+ resize( grayImage, scaledImage, scaledImageSize, 0, 0, INTER_LINEAR );
int yStep;
if( getFeatureType() == cv::FeatureEvaluator::HOG )
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include <deque>
#include <algorithm>
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include "_latentsvm.h"
#include "_lsvm_resizeimg.h"
/* Haar features calculation */
#include "precomp.hpp"
-#include "stdio.h"
+#include "opencv2/imgproc/imgproc_c.h"
+#include <stdio.h>
#if CV_SSE2
# if 1 /*!CV_SSE4_1 && !CV_SSE4_2*/
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include "_lsvmparser.h"
#include "_lsvm_matching.h"
if (!mask.empty())
{
Mat next_mask;
- resize(mask, next_mask, size, 0.0, 0.0, CV_INTER_NN);
+ resize(mask, next_mask, size, 0.0, 0.0, INTER_NEAREST);
mask = next_mask;
}
{
dst = Mat::zeros(src.size(), CV_8U);
- IplImage src_ipl = src;
- IplImage* ap_depth_data = &src_ipl;
- IplImage dst_ipl = dst;
- IplImage* dst_ipl_ptr = &dst_ipl;
- IplImage** m_dep = &dst_ipl_ptr;
+ const unsigned short * lp_depth = src.ptr<ushort>();
+ unsigned char * lp_normals = dst.ptr<uchar>();
- unsigned short * lp_depth = (unsigned short *)ap_depth_data->imageData;
- unsigned char * lp_normals = (unsigned char *)m_dep[0]->imageData;
-
- const int l_W = ap_depth_data->width;
- const int l_H = ap_depth_data->height;
+ const int l_W = src.cols;
+ const int l_H = src.rows;
const int l_r = 5; // used to be 7
const int l_offset0 = -l_r - l_r * l_W;
for (int l_y = l_r; l_y < l_H - l_r - 1; ++l_y)
{
- unsigned short * lp_line = lp_depth + (l_y * l_W + l_r);
+ const unsigned short * lp_line = lp_depth + (l_y * l_W + l_r);
unsigned char * lp_norm = lp_normals + (l_y * l_W + l_r);
for (int l_x = l_r; l_x < l_W - l_r - 1; ++l_x)
++lp_norm;
}
}
- cvSmooth(m_dep[0], m_dep[0], CV_MEDIAN, 5, 5);
+ medianBlur(dst, dst, 5);
}
class DepthNormalPyramid : public QuantizedPyramid
// In this case, NN-downsample the quantized image
Mat next_normal;
Size size(normal.cols / 2, normal.rows / 2);
- resize(normal, next_normal, size, 0.0, 0.0, CV_INTER_NN);
+ resize(normal, next_normal, size, 0.0, 0.0, INTER_NEAREST);
normal = next_normal;
if (!mask.empty())
{
Mat next_mask;
- resize(mask, next_mask, size, 0.0, 0.0, CV_INTER_NN);
+ resize(mask, next_mask, size, 0.0, 0.0, INTER_NEAREST);
mask = next_mask;
}
}
temp.setTo(1 << i, local_mask);
bitwise_and(temp, normal, temp);
// temp is now non-zero at pixels in the mask with quantized orientation i
- distanceTransform(temp, distances[i], CV_DIST_C, 3);
+ distanceTransform(temp, distances[i], DIST_C, 3);
}
// Count how many features taken for each label
#include "opencv2/objdetect.hpp"
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/core/core_c.h"
#include "opencv2/core/utility.hpp"
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include "_lsvm_resizeimg.h"
#include <stdio.h>
#include <assert.h>
switch (code)
{
/*
- case CV_BGR2BGRA: case CV_RGB2BGRA: case CV_BGRA2BGR:
- case CV_RGBA2BGR: case CV_RGB2BGR: case CV_BGRA2RGBA:
- case CV_BGR2BGR565: case CV_BGR2BGR555: case CV_RGB2BGR565: case CV_RGB2BGR555:
- case CV_BGRA2BGR565: case CV_BGRA2BGR555: case CV_RGBA2BGR565: case CV_RGBA2BGR555:
- case CV_BGR5652BGR: case CV_BGR5552BGR: case CV_BGR5652RGB: case CV_BGR5552RGB:
- case CV_BGR5652BGRA: case CV_BGR5552BGRA: case CV_BGR5652RGBA: case CV_BGR5552RGBA:
+ case COLOR_BGR2BGRA: case COLOR_RGB2BGRA: case COLOR_BGRA2BGR:
+ case COLOR_RGBA2BGR: case COLOR_RGB2BGR: case COLOR_BGRA2RGBA:
+ case COLOR_BGR2BGR565: case COLOR_BGR2BGR555: case COLOR_RGB2BGR565: case COLOR_RGB2BGR555:
+ case COLOR_BGRA2BGR565: case COLOR_BGRA2BGR555: case COLOR_RGBA2BGR565: case COLOR_RGBA2BGR555:
+ case COLOR_BGR5652BGR: case COLOR_BGR5552BGR: case COLOR_BGR5652RGB: case COLOR_BGR5552RGB:
+ case COLOR_BGR5652BGRA: case COLOR_BGR5552BGRA: case COLOR_BGR5652RGBA: case COLOR_BGR5552RGBA:
*/
- case CV_BGR2GRAY:
- case CV_BGRA2GRAY:
- case CV_RGB2GRAY:
- case CV_RGBA2GRAY:
+ case COLOR_BGR2GRAY:
+ case COLOR_BGRA2GRAY:
+ case COLOR_RGB2GRAY:
+ case COLOR_RGBA2GRAY:
{
CV_Assert(scn == 3 || scn == 4);
- bidx = code == CV_BGR2GRAY || code == CV_BGRA2GRAY ? 0 : 2;
+ bidx = code == COLOR_BGR2GRAY || code == COLOR_BGRA2GRAY ? 0 : 2;
dst.create(sz, CV_MAKETYPE(depth, 1));
RGB2Gray_caller(src, dst, bidx);
break;
}
- case CV_GRAY2BGR:
- case CV_GRAY2BGRA:
+ case COLOR_GRAY2BGR:
+ case COLOR_GRAY2BGRA:
{
CV_Assert(scn == 1);
- dcn = code == CV_GRAY2BGRA ? 4 : 3;
+ dcn = code == COLOR_GRAY2BGRA ? 4 : 3;
dst.create(sz, CV_MAKETYPE(depth, dcn));
Gray2RGB_caller(src, dst);
break;
}
- case CV_BGR2YUV:
- case CV_RGB2YUV:
+ case COLOR_BGR2YUV:
+ case COLOR_RGB2YUV:
{
CV_Assert(scn == 3 || scn == 4);
- bidx = code == CV_BGR2YUV ? 0 : 2;
+ bidx = code == COLOR_BGR2YUV ? 0 : 2;
dst.create(sz, CV_MAKETYPE(depth, 3));
RGB2YUV_caller(src, dst, bidx);
break;
}
- case CV_YUV2BGR:
- case CV_YUV2RGB:
+ case COLOR_YUV2BGR:
+ case COLOR_YUV2RGB:
{
CV_Assert(scn == 3 || scn == 4);
- bidx = code == CV_YUV2BGR ? 0 : 2;
+ bidx = code == COLOR_YUV2BGR ? 0 : 2;
dst.create(sz, CV_MAKETYPE(depth, 3));
YUV2RGB_caller(src, dst, bidx);
break;
}
- case CV_YUV2RGB_NV12:
- case CV_YUV2BGR_NV12:
- case CV_YUV2RGBA_NV12:
- case CV_YUV2BGRA_NV12:
+ case COLOR_YUV2RGB_NV12:
+ case COLOR_YUV2BGR_NV12:
+ case COLOR_YUV2RGBA_NV12:
+ case COLOR_YUV2BGRA_NV12:
{
CV_Assert(scn == 1);
CV_Assert( sz.width % 2 == 0 && sz.height % 3 == 0 && depth == CV_8U );
- dcn = code == CV_YUV2BGRA_NV12 || code == CV_YUV2RGBA_NV12 ? 4 : 3;
- bidx = code == CV_YUV2BGRA_NV12 || code == CV_YUV2BGR_NV12 ? 0 : 2;
+ dcn = code == COLOR_YUV2BGRA_NV12 || code == COLOR_YUV2RGBA_NV12 ? 4 : 3;
+ bidx = code == COLOR_YUV2BGRA_NV12 || code == COLOR_YUV2BGR_NV12 ? 0 : 2;
Size dstSz(sz.width, sz.height * 2 / 3);
dst.create(dstSz, CV_MAKETYPE(depth, dcn));
YUV2RGB_NV12_caller(src, dst, bidx);
break;
}
- case CV_BGR2YCrCb:
- case CV_RGB2YCrCb:
+ case COLOR_BGR2YCrCb:
+ case COLOR_RGB2YCrCb:
{
CV_Assert(scn == 3 || scn == 4);
- bidx = code == CV_BGR2YCrCb ? 0 : 2;
+ bidx = code == COLOR_BGR2YCrCb ? 0 : 2;
dst.create(sz, CV_MAKETYPE(depth, 3));
RGB2YCrCb_caller(src, dst, bidx);
break;
}
- case CV_YCrCb2BGR:
- case CV_YCrCb2RGB:
+ case COLOR_YCrCb2BGR:
+ case COLOR_YCrCb2RGB:
{
break;
}
/*
- case CV_BGR5652GRAY: case CV_BGR5552GRAY:
- case CV_GRAY2BGR565: case CV_GRAY2BGR555:
- case CV_BGR2YCrCb: case CV_RGB2YCrCb:
- case CV_BGR2XYZ: case CV_RGB2XYZ:
- case CV_XYZ2BGR: case CV_XYZ2RGB:
- case CV_BGR2HSV: case CV_RGB2HSV: case CV_BGR2HSV_FULL: case CV_RGB2HSV_FULL:
- case CV_BGR2HLS: case CV_RGB2HLS: case CV_BGR2HLS_FULL: case CV_RGB2HLS_FULL:
- case CV_HSV2BGR: case CV_HSV2RGB: case CV_HSV2BGR_FULL: case CV_HSV2RGB_FULL:
- case CV_HLS2BGR: case CV_HLS2RGB: case CV_HLS2BGR_FULL: case CV_HLS2RGB_FULL:
+ case COLOR_BGR5652GRAY: case COLOR_BGR5552GRAY:
+ case COLOR_GRAY2BGR565: case COLOR_GRAY2BGR555:
+ case COLOR_BGR2YCrCb: case COLOR_RGB2YCrCb:
+ case COLOR_BGR2XYZ: case COLOR_RGB2XYZ:
+ case COLOR_XYZ2BGR: case COLOR_XYZ2RGB:
+ case COLOR_BGR2HSV: case COLOR_RGB2HSV: case COLOR_BGR2HSV_FULL: case COLOR_RGB2HSV_FULL:
+ case COLOR_BGR2HLS: case COLOR_RGB2HLS: case COLOR_BGR2HLS_FULL: case COLOR_RGB2HLS_FULL:
+ case COLOR_HSV2BGR: case COLOR_HSV2RGB: case COLOR_HSV2BGR_FULL: case COLOR_HSV2RGB_FULL:
+ case COLOR_HLS2BGR: case COLOR_HLS2RGB: case COLOR_HLS2BGR_FULL: case COLOR_HLS2RGB_FULL:
*/
default:
CV_Error( CV_StsBadFlag, "Unknown/unsupported color conversion code" );
erode(src, temp, kernel, anchor, iterations, borderType, borderValue);
dilate(temp, dst, kernel, anchor, iterations, borderType, borderValue);
break;
- case CV_MOP_CLOSE:
+ case MORPH_CLOSE:
dilate(src, temp, kernel, anchor, iterations, borderType, borderValue);
erode(temp, dst, kernel, anchor, iterations, borderType, borderValue);
break;
- case CV_MOP_GRADIENT:
+ case MORPH_GRADIENT:
erode(src, temp, kernel, anchor, iterations, borderType, borderValue);
dilate(src, dst, kernel, anchor, iterations, borderType, borderValue);
subtract(dst, temp, dst);
break;
- case CV_MOP_TOPHAT:
+ case MORPH_TOPHAT:
erode(src, dst, kernel, anchor, iterations, borderType, borderValue);
dilate(dst, temp, kernel, anchor, iterations, borderType, borderValue);
subtract(src, temp, dst);
break;
- case CV_MOP_BLACKHAT:
+ case MORPH_BLACKHAT:
dilate(src, dst, kernel, anchor, iterations, borderType, borderValue);
erode(dst, temp, kernel, anchor, iterations, borderType, borderValue);
subtract(temp, src, dst);
if( CV_MAT_CN(gimg.type()) > 1 )
{
- cvtColor( gimg, gtemp, CV_BGR2GRAY );
+ cvtColor( gimg, gtemp, COLOR_BGR2GRAY );
gimg = gtemp;
}
CV_Assert(src.type() == CV_8UC1);
CV_Assert(src.cols < std::numeric_limits<unsigned short>::max());
CV_Assert(src.rows < std::numeric_limits<unsigned short>::max());
- CV_Assert(method == CV_HOUGH_GRADIENT);
+ CV_Assert(method == HOUGH_GRADIENT);
CV_Assert(dp > 0);
CV_Assert(minRadius > 0 && maxRadius > minRadius);
CV_Assert(cannyThreshold > 0);
const oclMat &image, const oclMat &templ, oclMat &result, MatchTemplateBuf & buf)
{
result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
- if (useNaive(CV_TM_SQDIFF, image.depth(), templ.size()))
+ if (useNaive(TM_SQDIFF, image.depth(), templ.size()))
{
matchTemplateNaive_SQDIFF(image, templ, result, image.oclchannels());
return;
const oclMat &image, const oclMat &templ, oclMat &result, MatchTemplateBuf &buf)
{
result.create(image.rows - templ.rows + 1, image.cols - templ.cols + 1, CV_32F);
- if (useNaive(CV_TM_CCORR, image.depth(), templ.size()))
+ if (useNaive(TM_CCORR, image.depth(), templ.size()))
{
matchTemplateNaive_CCORR(image, templ, result, image.oclchannels());
return;
//
//M*/
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
#include <iostream>
+
+
namespace cv
{
namespace ocl
#include <stdio.h>
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/core/core_c.h"
#include "opencv2/objdetect.hpp"
#include "opencv2/ocl.hpp"
channels.create(h * N_CHANNELS, w, CV_8UC1);
channels.setTo(0);
- cvtColor(frame, gray, CV_BGR2GRAY);
+ cvtColor(frame, gray, cv::COLOR_BGR2GRAY);
cv::Mat df_dx, df_dy, mag, angle;
cv::Sobel(gray, df_dx, CV_32F, 1, 0);
}
cv::Mat luv, shrunk;
- cv::cvtColor(frame, luv, CV_BGR2Luv);
+ cv::cvtColor(frame, luv, cv::COLOR_BGR2Luv);
std::vector<cv::Mat> splited;
for (int i = 0; i < 3; ++i)
splited.push_back(channels(cv::Rect(0, h * (7 + i), w, h)));
split(luv, splited);
- cv::resize(channels, shrunk, cv::Size(integrals.cols - 1, integrals.rows - 1), -1 , -1, CV_INTER_AREA);
+ cv::resize(channels, shrunk, cv::Size(integrals.cols - 1, integrals.rows - 1), -1 , -1, cv::INTER_AREA);
cv::integral(shrunk, integrals, cv::noArray(), CV_32S);
}
};
#include "opencv2/softcascade.hpp"
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/core/core_c.h"
#include "opencv2/ml.hpp"
#include "opencv2/core/private.hpp"
# include "opencv2/imgproc.hpp"
#endif
-#include "opencv2/imgproc/imgproc_c.h"
+#include "opencv2/imgproc/types_c.h"
#ifdef __cplusplus
extern "C" {
//M*/
#include "precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
// to be moved to legacy
*/
#include "precomp.hpp"
+#include <limits>
namespace cv
{
minVal_ = maxVal_ = 0;
name_ = "BackgroundSubtractor.GMG";
}
-
+
~BackgroundSubtractorGMGImpl()
{
}
#define __OPENCV_PRECOMP_H__
#include "opencv2/video.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/core/utility.hpp"
+#include "opencv2/core/utility.hpp"
#include "opencv2/core/private.hpp"
#include <list>
*/
#include "precomp.hpp"
+#include <limits>
using namespace cv;
//M*/
#include "test_precomp.hpp"
+#include "opencv2/imgproc/imgproc_c.h"
using namespace cv;
using namespace std;
#include <iostream>
#include "opencv2/ts.hpp"
#include "opencv2/imgproc.hpp"
-#include "opencv2/imgproc/imgproc_c.h"
#include "opencv2/video.hpp"
#include "opencv2/highgui.hpp"
#include <opencv2/core/core_c.h>
#include <opencv2/imgproc/imgproc_c.h>
#include <opencv2/legacy/compat.hpp>
-#include <opencv2/calib3d.hpp>
+#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
+#include <opencv2/calib3d.hpp>
#if defined WIN32 || defined _WIN32 || defined WINCE
#include <windows.h>
//MgrayImage = MgrayImage.clone();//deep copy
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
- findContours(MgrayImage, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_NONE);
+ findContours(MgrayImage, contours, hierarchy, RETR_EXTERNAL, CHAIN_APPROX_NONE);
Point p;
vector<CvPoint2D32f> srcImagePoints_temp(4,cvPoint2D32f(0,0));
projects / platform / upstream / opencv.git / commitdiff