Mat tvec;
#ifdef HAVE_TBB
- // limit concurrency to get determenistic result
+ // limit concurrency to get deterministic result
cv::Ptr<tbb::task_scheduler_init> one_thread = new tbb::task_scheduler_init(1);
#endif
Mat tvec1, tvec2;
{
- // limit concurrency to get determenistic result
+ // limit concurrency to get deterministic result
cv::theRNG().state = 20121010;
cv::Ptr<tbb::task_scheduler_init> one_thread = new tbb::task_scheduler_init(1);
solvePnPRansac(object, image, camera_mat, dist_coef, rvec1, tvec1);
//std::cout<<"ImageLogPolProjection::Starting cortex projection"<<std::endl;
// compute transformation, get theta and Radius in reagrd of the output sampled pixel
- double diagonalLenght=sqrt((double)(_outputNBcolumns*_outputNBcolumns+_outputNBrows*_outputNBrows));
+ double diagonalLength=sqrt((double)(_outputNBcolumns*_outputNBcolumns+_outputNBrows*_outputNBrows));
for (unsigned int radiusIndex=0;radiusIndex<_outputNBcolumns;++radiusIndex)
for(unsigned int orientationIndex=0;orientationIndex<_outputNBrows;++orientationIndex)
{
double x=1.0+sinh(radiusAxis[radiusIndex])*cos(orientationAxis[orientationIndex]);
double y=sinh(radiusAxis[radiusIndex])*sin(orientationAxis[orientationIndex]);
// get the input picture coordinate
- double R=diagonalLenght*sqrt(x*x+y*y)/(5.0+sqrt(x*x+y*y));
+ double R=diagonalLength*sqrt(x*x+y*y)/(5.0+sqrt(x*x+y*y));
double theta=atan2(y,x);
// convert input polar coord into cartesian/C compatble coordinate
unsigned int columnIndex=(unsigned int)(cos(theta)*R)+halfInputColumns;
string error_message = format("Wrong mean shape for the given eigenvector matrix. Expected %d, but was %d.", W.cols, mean.total());
CV_Error(CV_StsBadArg, error_message);
}
- // initalize temporary matrices
+ // initialize temporary matrices
Mat X, Y;
// copy data & make sure we are using the correct type
src.convertTo(Y, W.type());
for (unsigned int i=0;i<this->size();++i)
{
- double curentValue=(double)*(bufferPTR++);
+ double currentValue=(double)*(bufferPTR++);
// updating "closest to the high threshold" pixel value
- double highValueTest=maxThreshold-curentValue;
+ double highValueTest=maxThreshold-currentValue;
if (highValueTest>0)
{
if (deltaH>highValueTest)
{
deltaH=highValueTest;
- updatedHighValue=curentValue;
+ updatedHighValue=currentValue;
}
}
// updating "closest to the low threshold" pixel value
- double lowValueTest=curentValue-minThreshold;
+ double lowValueTest=currentValue-minThreshold;
if (lowValueTest>0)
{
if (deltaL>lowValueTest)
{
deltaL=lowValueTest;
- updatedLowValue=curentValue;
+ updatedLowValue=currentValue;
}
}
}
/* Retrieves image ROI */
CVAPI(CvRect) cvGetImageROI( const IplImage* image );
-/* Allocates and initalizes CvMat header */
+/* Allocates and initializes CvMat header */
CVAPI(CvMat*) cvCreateMatHeader( int rows, int cols, int type );
#define CV_AUTOSTEP 0x7fffffff
}
-// initalize IplImage header, allocated by the user
+// initialize IplImage header, allocated by the user
CV_IMPL IplImage*
cvInitImageHeader( IplImage * image, CvSize size, int depth,
int channels, int origin, int align )
----
Detects corners using the FAST algorithm
-.. ocv:function:: void FAST( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSupression=true )
+.. ocv:function:: void FAST( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSuppression=true )
-.. ocv:function:: void FASTX( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSupression, int type )
+.. ocv:function:: void FASTX( InputArray image, vector<KeyPoint>& keypoints, int threshold, bool nonmaxSuppression, int type )
:param image: grayscale image where keypoints (corners) are detected.
:param threshold: threshold on difference between intensity of the central pixel and pixels of a circle around this pixel.
- :param nonmaxSupression: if true, non-maximum suppression is applied to detected corners (keypoints).
+ :param nonmaxSuppression: if true, non-maximum suppression is applied to detected corners (keypoints).
:param type: one of the three neighborhoods as defined in the paper: ``FastFeatureDetector::TYPE_9_16``, ``FastFeatureDetector::TYPE_7_12``, ``FastFeatureDetector::TYPE_5_8``
//! detects corners using FAST algorithm by E. Rosten
CV_EXPORTS void FAST( InputArray image, CV_OUT vector<KeyPoint>& keypoints,
- int threshold, bool nonmaxSupression=true );
+ int threshold, bool nonmaxSuppression=true );
CV_EXPORTS void FASTX( InputArray image, CV_OUT vector<KeyPoint>& keypoints,
- int threshold, bool nonmaxSupression, int type );
+ int threshold, bool nonmaxSuppression, int type );
class CV_EXPORTS_W FastFeatureDetector : public FeatureDetector
{
Point2f center;
Scalar ellipse; // 3 elements a, b, c: ax^2+2bxy+cy^2=1
- Size_<float> axes; // half lenght of elipse axes
+ Size_<float> axes; // half length of ellipse axes
Size_<float> boundingBox; // half sizes of bounding box which sides are parallel to the coordinate axes
};
// all features have same size
static const int FEATURE_SIZE = 7;
- explicit FAST_GPU(int threshold, bool nonmaxSupression = true,
+ explicit FAST_GPU(int threshold, bool nonmaxSuppression = true,
double keypointsRatio = 0.05);
void operator ()(const GpuMat& image, const GpuMat& mask, GpuMat& keypoints);
void release();
- bool nonmaxSupression;
+ bool nonmaxSuppression;
int threshold;
-------------------------------------
Constructor.
-.. ocv:function:: gpu::FAST_GPU::FAST_GPU(int threshold, bool nonmaxSupression = true, double keypointsRatio = 0.05)
+.. ocv:function:: gpu::FAST_GPU::FAST_GPU(int threshold, bool nonmaxSuppression = true, double keypointsRatio = 0.05)
:param threshold: Threshold on difference between intensity of the central pixel and pixels on a circle around this pixel.
- :param nonmaxSupression: If it is true, non-maximum suppression is applied to detected corners (keypoints).
+ :param nonmaxSuppression: If it is true, non-maximum suppression is applied to detected corners (keypoints).
:param keypointsRatio: Inner buffer size for keypoints store is determined as (keypointsRatio * image_width * image_height).
gpu::FAST_GPU::calcKeyPointsLocation
-------------------------------------
-Find keypoints and compute it's response if ``nonmaxSupression`` is true.
+Find keypoints and compute it's response if ``nonmaxSuppression`` is true.
.. ocv:function:: int gpu::FAST_GPU::calcKeyPointsLocation(const GpuMat& image, const GpuMat& mask)
int descriptorSize() const;
void setParams(size_t n_features, const ORB::CommonParams& detector_params);
- void setFastParams(int threshold, bool nonmaxSupression = true);
+ void setFastParams(int threshold, bool nonmaxSuppression = true);
void release();
// all features have same size
static const int FEATURE_SIZE = 7;
- explicit FAST_GPU(int threshold, bool nonmaxSupression = true, double keypointsRatio = 0.05);
+ explicit FAST_GPU(int threshold, bool nonmaxSuppression = true, double keypointsRatio = 0.05);
//! finds the keypoints using FAST detector
//! supports only CV_8UC1 images
//! release temporary buffer's memory
void release();
- bool nonmaxSupression;
+ bool nonmaxSuppression;
int threshold;
//! max keypoints = keypointsRatio * img.size().area()
double keypointsRatio;
- //! find keypoints and compute it's response if nonmaxSupression is true
+ //! find keypoints and compute it's response if nonmaxSuppression is true
//! return count of detected keypoints
int calcKeyPointsLocation(const GpuMat& image, const GpuMat& mask);
//! get final array of keypoints
- //! performs nonmax supression if needed
+ //! performs nonmax suppression if needed
//! return final count of keypoints
int getKeyPoints(GpuMat& keypoints);
//! returns the descriptor size in bytes
inline int descriptorSize() const { return kBytes; }
- inline void setFastParams(int threshold, bool nonmaxSupression = true)
+ inline void setFastParams(int threshold, bool nonmaxSuppression = true)
{
fastDetector_.threshold = threshold;
- fastDetector_.nonmaxSupression = nonmaxSupression;
+ fastDetector_.nonmaxSuppression = nonmaxSuppression;
}
//! release temporary buffer's memory
//////////////////////////////////////////////////////////////////////
// FAST
-DEF_PARAM_TEST(Image_Threshold_NonMaxSupression, string, int, bool);
+DEF_PARAM_TEST(Image_Threshold_NonMaxSuppression, string, int, bool);
-PERF_TEST_P(Image_Threshold_NonMaxSupression, Features2D_FAST,
+PERF_TEST_P(Image_Threshold_NonMaxSuppression, Features2D_FAST,
Combine(Values<string>("gpu/perf/aloe.png"),
Values(20),
Bool()))
const float rho = 1.0f;
const float theta = static_cast<float>(CV_PI / 180.0);
const int threshold = 100;
- const int minLineLenght = 50;
+ const int minLineLength = 50;
const int maxLineGap = 5;
const cv::Mat image = cv::imread(fileName, cv::IMREAD_GRAYSCALE);
cv::gpu::GpuMat d_lines;
cv::gpu::HoughLinesBuf d_buf;
- TEST_CYCLE() cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+ TEST_CYCLE() cv::gpu::HoughLinesP(d_mask, d_lines, d_buf, rho, theta, minLineLength, maxLineGap);
cv::Mat gpu_lines(d_lines);
cv::Vec4i* begin = gpu_lines.ptr<cv::Vec4i>();
{
std::vector<cv::Vec4i> cpu_lines;
- TEST_CYCLE() cv::HoughLinesP(mask, cpu_lines, rho, theta, threshold, minLineLenght, maxLineGap);
+ TEST_CYCLE() cv::HoughLinesP(mask, cpu_lines, rho, theta, threshold, minLineLength, maxLineGap);
SANITY_CHECK(cpu_lines);
}
const float rho = 1.f;
const float theta = 1.f;
const int threshold = 40;
- const int minLineLenght = 20;
+ const int minLineLength = 20;
const int maxLineGap = 5;
cv::Mat image = cv::imread(fileName, cv::IMREAD_GRAYSCALE);
cv::gpu::GpuMat d_lines;
cv::gpu::HoughLinesBuf d_buf;
- cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+ cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLength, maxLineGap);
TEST_CYCLE()
{
- cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLenght, maxLineGap);
+ cv::gpu::HoughLinesP(d_image, d_lines, d_buf, rho, theta, minLineLength, maxLineGap);
}
}
else
cv::Canny(image, mask, 50, 100);
std::vector<cv::Vec4i> lines;
- cv::HoughLinesP(mask, lines, rho, theta, threshold, minLineLenght, maxLineGap);
+ cv::HoughLinesP(mask, lines, rho, theta, threshold, minLineLength, maxLineGap);
TEST_CYCLE()
{
- cv::HoughLinesP(mask, lines, rho, theta, threshold, minLineLenght, maxLineGap);
+ cv::HoughLinesP(mask, lines, rho, theta, threshold, minLineLength, maxLineGap);
}
}
}
///////////////////////////////////////////////////////////////////////////
- // nonmaxSupression
+ // nonmaxSuppression
- __global__ void nonmaxSupression(const short2* kpLoc, int count, const PtrStepSzi scoreMat, short2* locFinal, float* responseFinal)
+ __global__ void nonmaxSuppression(const short2* kpLoc, int count, const PtrStepSzi scoreMat, short2* locFinal, float* responseFinal)
{
#if defined(__CUDA_ARCH__) && (__CUDA_ARCH__ >= 110)
#endif
}
- int nonmaxSupression_gpu(const short2* kpLoc, int count, PtrStepSzi score, short2* loc, float* response)
+ int nonmaxSuppression_gpu(const short2* kpLoc, int count, PtrStepSzi score, short2* loc, float* response)
{
void* counter_ptr;
cudaSafeCall( cudaGetSymbolAddress(&counter_ptr, g_counter) );
cudaSafeCall( cudaMemset(counter_ptr, 0, sizeof(unsigned int)) );
- nonmaxSupression<<<grid, block>>>(kpLoc, count, score, loc, response);
+ nonmaxSuppression<<<grid, block>>>(kpLoc, count, score, loc, response);
cudaSafeCall( cudaGetLastError() );
cudaSafeCall( cudaDeviceSynchronize() );
#else /* !defined (HAVE_CUDA) */
-cv::gpu::FAST_GPU::FAST_GPU(int _threshold, bool _nonmaxSupression, double _keypointsRatio) :
- nonmaxSupression(_nonmaxSupression), threshold(_threshold), keypointsRatio(_keypointsRatio), count_(0)
+cv::gpu::FAST_GPU::FAST_GPU(int _threshold, bool _nonmaxSuppression, double _keypointsRatio) :
+ nonmaxSuppression(_nonmaxSuppression), threshold(_threshold), keypointsRatio(_keypointsRatio), count_(0)
{
}
namespace fast
{
int calcKeypoints_gpu(PtrStepSzb img, PtrStepSzb mask, short2* kpLoc, int maxKeypoints, PtrStepSzi score, int threshold);
- int nonmaxSupression_gpu(const short2* kpLoc, int count, PtrStepSzi score, short2* loc, float* response);
+ int nonmaxSuppression_gpu(const short2* kpLoc, int count, PtrStepSzi score, short2* loc, float* response);
}
}}}
ensureSizeIsEnough(1, maxKeypoints, CV_16SC2, kpLoc_);
- if (nonmaxSupression)
+ if (nonmaxSuppression)
{
ensureSizeIsEnough(img.size(), CV_32SC1, score_);
score_.setTo(Scalar::all(0));
}
- count_ = calcKeypoints_gpu(img, mask, kpLoc_.ptr<short2>(), maxKeypoints, nonmaxSupression ? score_ : PtrStepSzi(), threshold);
+ count_ = calcKeypoints_gpu(img, mask, kpLoc_.ptr<short2>(), maxKeypoints, nonmaxSuppression ? score_ : PtrStepSzi(), threshold);
count_ = std::min(count_, maxKeypoints);
return count_;
ensureSizeIsEnough(ROWS_COUNT, count_, CV_32FC1, keypoints);
- if (nonmaxSupression)
- return nonmaxSupression_gpu(kpLoc_.ptr<short2>(), count_, score_, keypoints.ptr<short2>(LOCATION_ROW), keypoints.ptr<float>(RESPONSE_ROW));
+ if (nonmaxSuppression)
+ return nonmaxSuppression_gpu(kpLoc_.ptr<short2>(), count_, score_, keypoints.ptr<short2>(LOCATION_ROW), keypoints.ptr<float>(RESPONSE_ROW));
GpuMat locRow(1, count_, kpLoc_.type(), keypoints.ptr(0));
kpLoc_.colRange(0, count_).copyTo(locRow);
namespace
{
IMPLEMENT_PARAM_CLASS(FAST_Threshold, int)
- IMPLEMENT_PARAM_CLASS(FAST_NonmaxSupression, bool)
+ IMPLEMENT_PARAM_CLASS(FAST_NonmaxSuppression, bool)
}
-PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSupression)
+PARAM_TEST_CASE(FAST, cv::gpu::DeviceInfo, FAST_Threshold, FAST_NonmaxSuppression)
{
cv::gpu::DeviceInfo devInfo;
int threshold;
- bool nonmaxSupression;
+ bool nonmaxSuppression;
virtual void SetUp()
{
devInfo = GET_PARAM(0);
threshold = GET_PARAM(1);
- nonmaxSupression = GET_PARAM(2);
+ nonmaxSuppression = GET_PARAM(2);
cv::gpu::setDevice(devInfo.deviceID());
}
ASSERT_FALSE(image.empty());
cv::gpu::FAST_GPU fast(threshold);
- fast.nonmaxSupression = nonmaxSupression;
+ fast.nonmaxSuppression = nonmaxSuppression;
if (!supportFeature(devInfo, cv::gpu::GLOBAL_ATOMICS))
{
fast(loadMat(image), cv::gpu::GpuMat(), keypoints);
std::vector<cv::KeyPoint> keypoints_gold;
- cv::FAST(image, keypoints_gold, threshold, nonmaxSupression);
+ cv::FAST(image, keypoints_gold, threshold, nonmaxSuppression);
ASSERT_KEYPOINTS_EQ(keypoints_gold, keypoints);
}
INSTANTIATE_TEST_CASE_P(GPU_Features2D, FAST, testing::Combine(
ALL_DEVICES,
testing::Values(FAST_Threshold(25), FAST_Threshold(50)),
- testing::Values(FAST_NonmaxSupression(false), FAST_NonmaxSupression(true))));
+ testing::Values(FAST_NonmaxSuppression(false), FAST_NonmaxSuppression(true))));
/////////////////////////////////////////////////////////////////////////////////////////////////
// ORB
setWindowTitle(name);
setObjectName(name);
- setFocus( Qt::PopupFocusReason ); //#1695 arrow keys are not recieved without the explicit focus
+ setFocus( Qt::PopupFocusReason ); //#1695 arrow keys are not received without the explicit focus
resize(400, 300);
setMinimumSize(1, 1);
//pad size maxvalue in pixel
Point qdSize;
- char valueinchar[strlen(trackbar_name)+1 +1 +1+nbDigit+1];//lenght+\n +space +(+nbDigit+)
+ char valueinchar[strlen(trackbar_name)+1 +1 +1+nbDigit+1];//length+\n +space +(+nbDigit+)
sprintf(valueinchar, "%s (%d)",trackbar_name, trackbar->maxval);
SInt16 baseline;
CFStringRef text = CFStringCreateWithCString(NULL,valueinchar,kCFStringEncodingASCII);
.. ocv:pyfunction:: cv2.cornerHarris(src, blockSize, ksize, k[, dst[, borderType]]) -> dst
-.. ocv:cfunction:: void cvCornerHarris( const CvArr* image, CvArr* harris_responce, int block_size, int aperture_size=3, double k=0.04 )
+.. ocv:cfunction:: void cvCornerHarris( const CvArr* image, CvArr* harris_response, int block_size, int aperture_size=3, double k=0.04 )
.. ocv:pyoldfunction:: cv.CornerHarris(image, harris_dst, blockSize, aperture_size=3, k=0.04) -> None
int method CV_DEFAULT(CV_CHAIN_APPROX_SIMPLE),
CvPoint offset CV_DEFAULT(cvPoint(0,0)));
-/* Initalizes contour retrieving process.
+/* Initializes contour retrieving process.
Calls cvStartFindContours.
Calls cvFindNextContour until null pointer is returned
or some other condition becomes true.
int minimal_perimeter CV_DEFAULT(0),
int recursive CV_DEFAULT(0));
-/* Initalizes Freeman chain reader.
+/* Initializes Freeman chain reader.
The reader is used to iteratively get coordinates of all the chain points.
If the Freeman codes should be read as is, a simple sequence reader should be used */
CVAPI(void) cvStartReadChainPoints( CvChain* chain, CvChainPtReader* reader );
/* Harris corner detector:
Calculates det(M) - k*(trace(M)^2), where M is 2x2 gradient covariation matrix for each pixel */
-CVAPI(void) cvCornerHarris( const CvArr* image, CvArr* harris_responce,
+CVAPI(void) cvCornerHarris( const CvArr* image, CvArr* harris_response,
int block_size, int aperture_size CV_DEFAULT(3),
double k CV_DEFAULT(0.04) );
current = temp.next;
/* Pass 2.
- Performs non-maxima supression */
+ Performs non-maxima suppression */
do
{
int k2 = current->k >> 1;
#define CANNY_PUSH(d) *(d) = uchar(2), *stack_top++ = (d)
#define CANNY_POP(d) (d) = *--stack_top
- // calculate magnitude and angle of gradient, perform non-maxima supression.
+ // calculate magnitude and angle of gradient, perform non-maxima suppression.
// fill the map with one of the following values:
// 0 - the pixel might belong to an edge
// 1 - the pixel can not belong to an edge
(SumL[M0(n0.x)+lcl_off] - SumL[M1(n0.x)+lcl_off] - SumL[M0(n0.y)+lcl_off] + SumL[M1(n0.y)+lcl_off]) * as_float(n1.z) +
(SumL[M0(n0.z)+lcl_off] - SumL[M1(n0.z)+lcl_off] - SumL[M0(n0.w)+lcl_off] + SumL[M1(n0.w)+lcl_off]) * as_float(n1.w) +
(SumL[M0(n1.x)+lcl_off] - SumL[M1(n1.x)+lcl_off] - SumL[M0(n1.y)+lcl_off] + SumL[M1(n1.y)+lcl_off]) * as_float(n2.x);
- //accumulate stage responce
+ //accumulate stage response
stage_sum += (classsum >= nodethreshold) ? as_float(n2.w) : as_float(n2.z);
}
result = (stage_sum >= stagethreshold);
// processing time (in this case there should be possibility to interrupt such a function
FAIL_HANG=-13,
- // unexpected responce on passing bad arguments to the tested function
+ // unexpected response on passing bad arguments to the tested function
// (the function crashed, proceed succesfully (while it should not), or returned
// error code that is different from what is expected)
FAIL_BAD_ARG_CHECK=-14,
{
public:
//! create default cone, oriented along x-axis with center of its base located at origin
- WCone(double lenght, double radius, int resolution = 6.0, const Color &color = Color::white());
+ WCone(double length, double radius, int resolution = 6.0, const Color &color = Color::white());
//! creates repositioned cone
WCone(double radius, const Point3d& center, const Point3d& tip, int resolution = 6.0, const Color &color = Color::white());
}
});
- mPackageChangeReciever = new BroadcastReceiver() {
+ mPackageChangeReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
- Log.d("OpenCVManager/Reciever", "Bradcast message " + intent.getAction() + " reciever");
- Log.d("OpenCVManager/Reciever", "Filling package list on broadcast message");
+ Log.d("OpenCVManager/Receiver", "Broadcast message " + intent.getAction() + " receiver");
+ Log.d("OpenCVManager/Receiver", "Filling package list on broadcast message");
if (!bindService(new Intent("org.opencv.engine.BIND"), new OpenCVEngineServiceConnection(), Context.BIND_AUTO_CREATE))
{
TextView EngineVersionView = (TextView)findViewById(R.id.EngineVersionValue);
filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
filter.addAction(Intent.ACTION_PACKAGE_REPLACED);
- registerReceiver(mPackageChangeReciever, filter);
+ registerReceiver(mPackageChangeReceiver, filter);
}
@Override
protected void onDestroy() {
super.onDestroy();
- if (mPackageChangeReciever != null)
- unregisterReceiver(mPackageChangeReciever);
+ if (mPackageChangeReceiver != null)
+ unregisterReceiver(mPackageChangeReceiver);
}
@Override
protected int ManagerApiLevel = 0;
protected String ManagerVersion;
- protected BroadcastReceiver mPackageChangeReciever = null;
+ protected BroadcastReceiver mPackageChangeReceiver = null;
protected class OpenCVEngineServiceConnection implements ServiceConnection
{
printf("\nShow off image morphology: erosion, dialation, open and close\n"
"Call:\n morphology2 [image]\n"
- "This program also shows use of rect, elipse and cross kernels\n\n");
+ "This program also shows use of rect, ellipse and cross kernels\n\n");
printf( "Hot keys: \n"
"\tESC - quit the program\n"
"\tr - use rectangle structuring element\n"
printf("\nShow off image morphology: erosion, dialation, open and close\n"
"Call:\n morphology2 [image]\n"
- "This program also shows use of rect, elipse and cross kernels\n\n");
+ "This program also shows use of rect, ellipse and cross kernels\n\n");
printf( "Hot keys: \n"
"\tESC - quit the program\n"
"\tr - use rectangle structuring element\n"
projects / profile / ivi / opencv.git / commitdiff