mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-24 19:20:28 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

More fixes for documentation.

Browse Source
This commit is contained in:
Andrey Kamaev 2012-05-28 20:11:38 +00:00
parent bc929a7d46
commit 6ca618277c
35 changed files with 532 additions and 574 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
doc/check_docs2.py
View File

@ -30,22 +30,31 @@ doc_signatures_whitelist = [
# templates # templates
"Matx", "Vec", "SparseMat_", "Scalar_", "Mat_", "Ptr", "Size_", "Point_", "Rect_", "Point3_", "Matx", "Vec", "SparseMat_", "Scalar_", "Mat_", "Ptr", "Size_", "Point_", "Rect_", "Point3_",
"DataType", "detail::RotationWarperBase", "flann::Index_", "CalonderDescriptorExtractor", "DataType", "detail::RotationWarperBase", "flann::Index_", "CalonderDescriptorExtractor",
"gpu::DevMem2D_", "gpu::PtrStep_", "gpu::PtrElemStep_",
# black boxes # black boxes
"CvArr", "CvFileStorage", "CvArr", "CvFileStorage",
# the following classes reside in core but documented in gpu. It's no good ]
"gpu::DevMem2D_", "gpu::PtrStep_", "gpu::PtrElemStep_",
# these are even non-template
"gpu::DeviceInfo", "gpu::GpuMat", "gpu::TargetArchs", "gpu::FeatureSet"]
defines = ["cvGraphEdgeIdx", "cvFree", "CV_Assert", "cvSqrt", "cvGetGraphVtx", "cvGraphVtxIdx", defines = ["cvGraphEdgeIdx", "cvFree", "CV_Assert", "cvSqrt", "cvGetGraphVtx", "cvGraphVtxIdx",
"cvCaptureFromFile", "cvCaptureFromCAM", "cvCalcBackProjectPatch", "cvCalcBackProject",
"cvGetHistValue_1D", "cvGetHistValue_2D", "cvGetHistValue_3D", "cvGetHistValue_nD",
"cvQueryHistValue_1D", "cvQueryHistValue_2D", "cvQueryHistValue_3D", "cvQueryHistValue_nD",
# not a real function but behaves as function # not a real function but behaves as function
"Mat.size" "Mat::size",
# ugly "virtual" functions from ml module
"CvStatModel::train", "CvStatModel::predict",
# TODO:
"cvExtractSURF"
] ]
synonims = { synonims = {
"StarDetector" : ["StarFeatureDetector"], "StarDetector" : ["StarFeatureDetector"],
"MSER" : ["MserFeatureDetector"], "MSER" : ["MserFeatureDetector"],
"GFTTDetector" : ["GoodFeaturesToTrackDetector"] "GFTTDetector" : ["GoodFeaturesToTrackDetector"],
"cvCaptureFromFile" : ["cvCreateFileCapture"],
"cvCaptureFromCAM" : ["cvCreateCameraCapture"],
"cvCalcArrBackProjectPatch" : ["cvCalcBackProjectPatch"],
"cvCalcArrBackProject" : ["cvCalcBackProject"],
} }
if do_python_crosscheck: if do_python_crosscheck:
@ -80,10 +89,9 @@ def compareSignatures(f, s):
# return type # return type
stype = (s[1] or "void") stype = (s[1] or "void")
ftype = f[1] ftype = f[1]
if stype.startswith("cv::"): stype = re.sub(r"\b(cv|std)::", "", stype)
stype = stype[4:] if ftype:
if ftype and ftype.startswith("cv::"): ftype = re.sub(r"\b(cv|std)::", "", ftype)
ftype = ftype[4:]
if ftype and ftype != stype: if ftype and ftype != stype:
return False, "return type mismatch" return False, "return type mismatch"
if ("\C" in f[2]) ^ ("\C" in s[2]): if ("\C" in f[2]) ^ ("\C" in s[2]):
@ -168,6 +176,10 @@ def process_module(module, path):
hdrlist = glob.glob(os.path.join(path, "include", "opencv2", module, "*.h*")) hdrlist = glob.glob(os.path.join(path, "include", "opencv2", module, "*.h*"))
hdrlist.extend(glob.glob(os.path.join(path, "include", "opencv2", module, "detail", "*.h*"))) hdrlist.extend(glob.glob(os.path.join(path, "include", "opencv2", module, "detail", "*.h*")))
if module == "gpu":
hdrlist.append(os.path.join(path, "..", "core", "include", "opencv2", "core", "devmem2d.hpp"))
hdrlist.append(os.path.join(path, "..", "core", "include", "opencv2", "core", "gpumat.hpp"))
decls = [] decls = []
for hname in hdrlist: for hname in hdrlist:
if not "ts_gtest.h" in hname: if not "ts_gtest.h" in hname:
@ -196,8 +208,6 @@ def process_module(module, path):
namespaces.append(namespace) namespaces.append(namespace)
else: else:
funcs.append(decl) funcs.append(decl)
# if "RNG" in decl[0]:
# print decl
clsnamespaces = [] clsnamespaces = []
# process classes # process classes
@ -385,21 +395,19 @@ def process_module(module, path):
logerror(ERROR_005_MISSINGPYFUNC, "could not load documented member of " + parent + " class: cv2." + pname, doc) logerror(ERROR_005_MISSINGPYFUNC, "could not load documented member of " + parent + " class: cv2." + pname, doc)
else: else:
logerror(ERROR_005_MISSINGPYFUNC, "could not load documented function cv2." + pname, doc) logerror(ERROR_005_MISSINGPYFUNC, "could not load documented function cv2." + pname, doc)
signature.append(DOCUMENTED_MARKER) # stop subsequent errors
continue continue
docstrings = [docprefix + s.replace("([, ", "([") for s in docstr.split(" or ")] docstrings = [docprefix + s.replace("([, ", "([") for s in docstr.split(" or ")]
if not signature[1] in docstrings: if not signature[1] in docstrings:
pydocs = "\npydoc: ".join(docstrings) pydocs = "\npydoc: ".join(docstrings)
logerror(ERROR_007_INVALIDPYDOC, "documentation differs from pydoc\npydoc: " + pydocs + "\ncvdoc: " + signature[1], doc) logerror(ERROR_007_INVALIDPYDOC, "documentation differs from pydoc\npydoc: " + pydocs + "\ncvdoc: " + signature[1], doc)
else: signature.append(DOCUMENTED_MARKER)
signature.append(DOCUMENTED_MARKER)
# verify C/C++ signatures # verify C/C++ signatures
for name, doc in rst.iteritems(): for name, doc in rst.iteritems():
decls = doc.get("decls") decls = doc.get("decls")
if not decls: if not decls:
continue continue
# if "RNG" in name:
# print name, decls
for signature in decls: for signature in decls:
if signature[0] == "C" or signature[0] == "C++": if signature[0] == "C" or signature[0] == "C++":
if "template" in (signature[2][1] or ""): if "template" in (signature[2][1] or ""):
@ -431,6 +439,7 @@ def process_module(module, path):
if signature[-1] != DOCUMENTED_MARKER: if signature[-1] != DOCUMENTED_MARKER:
candidates = "\n\t".join([formatSignature(f[3]) for f in fd]) candidates = "\n\t".join([formatSignature(f[3]) for f in fd])
logerror(ERROR_009_OVERLOADNOTFOUND, signature[0] + " function " + signature[2][0].replace(".","::") + " is documented but misses in headers (" + error + ").\nDocumented as:\n\t" + signature[1] + "\nCandidates are:\n\t" + candidates, doc) logerror(ERROR_009_OVERLOADNOTFOUND, signature[0] + " function " + signature[2][0].replace(".","::") + " is documented but misses in headers (" + error + ").\nDocumented as:\n\t" + signature[1] + "\nCandidates are:\n\t" + candidates, doc)
signature.append(DOCUMENTED_MARKER) # to stop subsequent error on this function
# verify that all signatures was found in the library headers # verify that all signatures was found in the library headers
for name, doc in rst.iteritems(): for name, doc in rst.iteritems():
@ -443,11 +452,18 @@ def process_module(module, path):
for d in doc.get("decls", []): for d in doc.get("decls", []):
if d[-1] != DOCUMENTED_MARKER: if d[-1] != DOCUMENTED_MARKER:
if d[0] == "C" or d[0] =="C++" or (do_python_crosscheck and d[0].startswith("Python")): if d[0] == "C" or d[0] =="C++" or (do_python_crosscheck and d[0].startswith("Python")):
if d[0][0] == 'C' and d[2][0][3:] in defines: if d[0][0] == 'C':
#TODO: need to find a way to verify #define's sname = d[2][0][3:].replace(".", "::")
if sname in defines:
#TODO: need to find a way to verify #define's
continue
else:
sname = d[1][:d[1].find("(")]
prefixes = [x for x in doc_signatures_whitelist if sname.startswith(x)]
if prefixes:
# TODO: member of template class
continue continue
logerror(ERROR_011_UNKNOWNFUNC, d[0] + " function is documented but is not found in OpenCV headers. It is documented as:\n\t" + d[1], doc) logerror(ERROR_011_UNKNOWNFUNC, d[0] + " function " + sname + " is documented but is not found in OpenCV headers. It is documented as:\n\t" + d[1], doc)
#print d[2][0][3:]
# end of process_module # end of process_module
if __name__ == "__main__": if __name__ == "__main__":

10
modules/core/doc/basic_structures.rst
View File

@ -889,16 +889,6 @@ Provides matrix assignment operators.
These are available assignment operators. Since they all are very different, make sure to read the operator parameters description. These are available assignment operators. Since they all are very different, make sure to read the operator parameters description.
Mat::operator MatExpr
-------------------------
Provides a ``Mat`` -to- ``MatExpr`` cast operator.
.. ocv:function:: Mat::operator MatExpr_<Mat, Mat>() const
The cast operator should not be called explicitly. It is used internally by the
:ref:`MatrixExpressions` engine.
Mat::row Mat::row
------------ ------------
Creates a matrix header for the specified matrix row. Creates a matrix header for the specified matrix row.

82
modules/core/doc/drawing_functions.rst
View File

@ -473,6 +473,88 @@ Draws several polygonal curves.
The function ``polylines`` draws one or more polygonal curves. The function ``polylines`` draws one or more polygonal curves.
drawContours
----------------
Draws contours outlines or filled contours.
.. ocv:function:: void drawContours( InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar& color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point() )
.. ocv:pyfunction:: cv2.drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]]) -> None
.. ocv:cfunction:: void cvDrawContours( CvArr * img, CvSeq* contour, CvScalar external_color, CvScalar hole_color, int max_level, int thickness=1, int line_type=8, CvPoint offset=cvPoint(0,0) )
.. ocv:pyoldfunction:: cv.DrawContours(img, contour, external_color, hole_color, max_level, thickness=1, lineType=8, offset=(0, 0))-> None
:param image: Destination image.
:param contours: All the input contours. Each contour is stored as a point vector.
:param contourIdx: Parameter indicating a contour to draw. If it is negative, all the contours are drawn.
:param color: Color of the contours.
:param thickness: Thickness of lines the contours are drawn with. If it is negative (for example, ``thickness=CV_FILLED`` ), the contour interiors are
drawn.
:param lineType: Line connectivity. See :ocv:func:`line` for details.
:param hierarchy: Optional information about hierarchy. It is only needed if you want to draw only some of the contours (see ``maxLevel`` ).
:param maxLevel: Maximal level for drawn contours. If it is 0, only
the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is ``hierarchy`` available.
:param offset: Optional contour shift parameter. Shift all the drawn contours by the specified :math:`\texttt{offset}=(dx,dy)` .
:param contour: Pointer to the first contour.
:param externalColor: Color of external contours.
:param holeColor: Color of internal contours (holes).
The function draws contour outlines in the image if
:math:`\texttt{thickness} \ge 0` or fills the area bounded by the contours if
:math:`\texttt{thickness}<0` . The example below shows how to retrieve connected components from the binary image and label them: ::
#include "cv.h"
#include "highgui.h"
using namespace cv;
int main( int argc, char** argv )
{
Mat src;
// the first command-line parameter must be a filename of the binary
// (black-n-white) image
if( argc != 2 || !(src=imread(argv[1], 0)).data)
return -1;
Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);
src = src > 1;
namedWindow( "Source", 1 );
imshow( "Source", src );
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
findContours( src, contours, hierarchy,
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
// iterate through all the top-level contours,
// draw each connected component with its own random color
int idx = 0;
for( ; idx >= 0; idx = hierarchy[idx][0] )
{
Scalar color( rand()&255, rand()&255, rand()&255 );
drawContours( dst, contours, idx, color, CV_FILLED, 8, hierarchy );
}
namedWindow( "Components", 1 );
imshow( "Components", dst );
waitKey(0);
}
putText putText
----------- -----------

7
modules/core/include/opencv2/core/core.hpp
View File

@ -2538,6 +2538,13 @@ CV_EXPORTS_W void polylines(InputOutputArray img, InputArrayOfArrays pts,
bool isClosed, const Scalar& color, bool isClosed, const Scalar& color,
int thickness=1, int lineType=8, int shift=0 ); int thickness=1, int lineType=8, int shift=0 );
//! draws contours in the image
CV_EXPORTS_W void drawContours( InputOutputArray image, InputArrayOfArrays contours,
int contourIdx, const Scalar& color,
int thickness=1, int lineType=8,
InputArray hierarchy=noArray(),
int maxLevel=INT_MAX, Point offset=Point() );
//! clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height) //! clips the line segment by the rectangle Rect(0, 0, imgSize.width, imgSize.height)
CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2); CV_EXPORTS bool clipLine(Size imgSize, CV_IN_OUT Point& pt1, CV_IN_OUT Point& pt2);

208
modules/core/src/drawing.cpp
View File

@ -140,11 +140,11 @@ bool clipLine( Rect img_rect, Point& pt1, Point& pt2 )
pt1 -= tl; pt2 -= tl; pt1 -= tl; pt2 -= tl;
bool inside = clipLine(img_rect.size(), pt1, pt2); bool inside = clipLine(img_rect.size(), pt1, pt2);
pt1 += tl; pt2 += tl; pt1 += tl; pt2 += tl;
return inside; return inside;
} }
/* /*
Initializes line iterator. Initializes line iterator.
Returns number of points on the line or negative number if error. Returns number of points on the line or negative number if error.
*/ */
@ -195,7 +195,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
step = (step ^ s) - s; step = (step ^ s) - s;
s = dy > dx ? -1 : 0; s = dy > dx ? -1 : 0;
/* conditional swaps */ /* conditional swaps */
dx ^= dy & s; dx ^= dy & s;
dy ^= dx & s; dy ^= dx & s;
@ -208,7 +208,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
if( connectivity == 8 ) if( connectivity == 8 )
{ {
assert( dx >= 0 && dy >= 0 ); assert( dx >= 0 && dy >= 0 );
err = dx - (dy + dy); err = dx - (dy + dy);
plusDelta = dx + dx; plusDelta = dx + dx;
minusDelta = -(dy + dy); minusDelta = -(dy + dy);
@ -219,7 +219,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
else /* connectivity == 4 */ else /* connectivity == 4 */
{ {
assert( dx >= 0 && dy >= 0 ); assert( dx >= 0 && dy >= 0 );
err = 0; err = 0;
plusDelta = (dx + dx) + (dy + dy); plusDelta = (dx + dx) + (dy + dy);
minusDelta = -(dy + dy); minusDelta = -(dy + dy);
@ -227,7 +227,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
minusStep = bt_pix; minusStep = bt_pix;
count = dx + dy + 1; count = dx + dy + 1;
} }
this->ptr0 = img.data; this->ptr0 = img.data;
this->step = (int)img.step; this->step = (int)img.step;
this->elemSize = bt_pix0; this->elemSize = bt_pix0;
@ -621,10 +621,10 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
tptr[1] = (uchar)cg; \ tptr[1] = (uchar)cg; \
tptr[2] = (uchar)cr; \ tptr[2] = (uchar)cr; \
} }
ICV_PUT_POINT((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT, ICV_PUT_POINT((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT,
(pt2.y + (XY_ONE >> 1)) >> XY_SHIFT); (pt2.y + (XY_ONE >> 1)) >> XY_SHIFT);
if( ax > ay ) if( ax > ay )
{ {
pt1.x >>= XY_SHIFT; pt1.x >>= XY_SHIFT;
@ -640,7 +640,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
else else
{ {
pt1.y >>= XY_SHIFT; pt1.y >>= XY_SHIFT;
while( ecount >= 0 ) while( ecount >= 0 )
{ {
ICV_PUT_POINT(pt1.x >> XY_SHIFT, pt1.y); ICV_PUT_POINT(pt1.x >> XY_SHIFT, pt1.y);
@ -664,8 +664,8 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
} }
ICV_PUT_POINT((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT, ICV_PUT_POINT((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT,
(pt2.y + (XY_ONE >> 1)) >> XY_SHIFT); (pt2.y + (XY_ONE >> 1)) >> XY_SHIFT);
if( ax > ay ) if( ax > ay )
{ {
pt1.x >>= XY_SHIFT; pt1.x >>= XY_SHIFT;
@ -681,7 +681,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
else else
{ {
pt1.y >>= XY_SHIFT; pt1.y >>= XY_SHIFT;
while( ecount >= 0 ) while( ecount >= 0 )
{ {
ICV_PUT_POINT(pt1.x >> XY_SHIFT, pt1.y); ICV_PUT_POINT(pt1.x >> XY_SHIFT, pt1.y);
@ -690,7 +690,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
ecount--; ecount--;
} }
} }
#undef ICV_PUT_POINT #undef ICV_PUT_POINT
} }
else else
@ -706,12 +706,12 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
} }
ICV_PUT_POINT((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT, ICV_PUT_POINT((pt2.x + (XY_ONE >> 1)) >> XY_SHIFT,
(pt2.y + (XY_ONE >> 1)) >> XY_SHIFT); (pt2.y + (XY_ONE >> 1)) >> XY_SHIFT);
if( ax > ay ) if( ax > ay )
{ {
pt1.x >>= XY_SHIFT; pt1.x >>= XY_SHIFT;
while( ecount >= 0 ) while( ecount >= 0 )
{ {
ICV_PUT_POINT(pt1.x, pt1.y >> XY_SHIFT); ICV_PUT_POINT(pt1.x, pt1.y >> XY_SHIFT);
@ -723,7 +723,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
else else
{ {
pt1.y >>= XY_SHIFT; pt1.y >>= XY_SHIFT;
while( ecount >= 0 ) while( ecount >= 0 )
{ {
ICV_PUT_POINT(pt1.x >> XY_SHIFT, pt1.y); ICV_PUT_POINT(pt1.x >> XY_SHIFT, pt1.y);
@ -732,7 +732,7 @@ Line2( Mat& img, Point pt1, Point pt2, const void* color )
ecount--; ecount--;
} }
} }
#undef ICV_PUT_POINT #undef ICV_PUT_POINT
} }
} }
@ -830,7 +830,7 @@ sincos( int angle, float& cosval, float& sinval )
cosval = SinTable[450 - angle]; cosval = SinTable[450 - angle];
} }
/* /*
constructs polygon that represents elliptic arc. constructs polygon that represents elliptic arc.
*/ */
void ellipse2Poly( Point center, Size axes, int angle, void ellipse2Poly( Point center, Size axes, int angle,
@ -880,7 +880,7 @@ void ellipse2Poly( Point center, Size axes, int angle,
angle = arc_end; angle = arc_end;
if( angle < 0 ) if( angle < 0 )
angle += 360; angle += 360;
x = size_a * SinTable[450-angle]; x = size_a * SinTable[450-angle];
y = size_b * SinTable[angle]; y = size_b * SinTable[angle];
Point pt; Point pt;
@ -922,7 +922,7 @@ EllipseEx( Mat& img, Point center, Size axes,
/****************************************************************************************\ /****************************************************************************************\
* Polygons filling * * Polygons filling *
\****************************************************************************************/ \****************************************************************************************/
/* helper macros: filling horizontal row */ /* helper macros: filling horizontal row */
@ -1010,7 +1010,7 @@ FillConvexPoly( Mat& img, const Point* v, int npts, const void* color, int line_
LineAA( img, p0, p, color ); LineAA( img, p0, p, color );
p0 = p; p0 = p;
} }
xmin = (xmin + delta) >> shift; xmin = (xmin + delta) >> shift;
xmax = (xmax + delta) >> shift; xmax = (xmax + delta) >> shift;
ymin = (ymin + delta) >> shift; ymin = (ymin + delta) >> shift;
@ -1118,7 +1118,7 @@ CollectPolyEdges( Mat& img, const Point* v, int count, vector<PolyEdge>& edges,
{ {
Point t0, t1; Point t0, t1;
PolyEdge edge; PolyEdge edge;
pt1 = v[i]; pt1 = v[i];
pt1.x = (pt1.x + offset.x) << (XY_SHIFT - shift); pt1.x = (pt1.x + offset.x) << (XY_SHIFT - shift);
pt1.y = (pt1.y + delta) >> shift; pt1.y = (pt1.y + delta) >> shift;
@ -1337,7 +1337,7 @@ Circle( Mat& img, Point center, int radius, const void* color, int fill )
{ {
uchar *tptr0 = ptr + y11 * step; uchar *tptr0 = ptr + y11 * step;
uchar *tptr1 = ptr + y12 * step; uchar *tptr1 = ptr + y12 * step;
if( !fill ) if( !fill )
{ {
ICV_PUT_POINT( tptr0, x11 ); ICV_PUT_POINT( tptr0, x11 );
@ -1374,7 +1374,7 @@ Circle( Mat& img, Point center, int radius, const void* color, int fill )
x11 = std::max( x11, 0 ); x11 = std::max( x11, 0 );
x12 = MIN( x12, size.width - 1 ); x12 = MIN( x12, size.width - 1 );
} }
if( (unsigned)y11 < (unsigned)size.height ) if( (unsigned)y11 < (unsigned)size.height )
{ {
uchar *tptr = ptr + y11 * step; uchar *tptr = ptr + y11 * step;
@ -1523,7 +1523,7 @@ ThickLine( Mat& img, Point p0, Point p1, const void* color,
Point center; Point center;
center.x = (p0.x + (XY_ONE>>1)) >> XY_SHIFT; center.x = (p0.x + (XY_ONE>>1)) >> XY_SHIFT;
center.y = (p0.y + (XY_ONE>>1)) >> XY_SHIFT; center.y = (p0.y + (XY_ONE>>1)) >> XY_SHIFT;
Circle( img, center, (thickness + (XY_ONE>>1)) >> XY_SHIFT, color, 1 ); Circle( img, center, (thickness + (XY_ONE>>1)) >> XY_SHIFT, color, 1 );
} }
else else
{ {
@ -1544,7 +1544,7 @@ PolyLine( Mat& img, const Point* v, int count, bool is_closed,
{ {
if( !v || count <= 0 ) if( !v || count <= 0 )
return; return;
int i = is_closed ? count - 1 : 0; int i = is_closed ? count - 1 : 0;
int flags = 2 + !is_closed; int flags = 2 + !is_closed;
Point p0; Point p0;
@ -1575,7 +1575,7 @@ void line( Mat& img, Point pt1, Point pt2, const Scalar& color,
double buf[4]; double buf[4];
scalarToRawData( color, buf, img.type(), 0 ); scalarToRawData( color, buf, img.type(), 0 );
ThickLine( img, pt1, pt2, buf, thickness, line_type, 3, shift ); ThickLine( img, pt1, pt2, buf, thickness, line_type, 3, shift );
} }
void rectangle( Mat& img, Point pt1, Point pt2, void rectangle( Mat& img, Point pt1, Point pt2,
@ -1606,7 +1606,7 @@ void rectangle( Mat& img, Point pt1, Point pt2,
FillConvexPoly( img, pt, 4, buf, lineType, shift ); FillConvexPoly( img, pt, 4, buf, lineType, shift );
} }
void rectangle( Mat& img, Rect rec, void rectangle( Mat& img, Rect rec,
const Scalar& color, int thickness, const Scalar& color, int thickness,
int lineType, int shift ) int lineType, int shift )
@ -1617,7 +1617,7 @@ void rectangle( Mat& img, Rect rec,
color, thickness, lineType, shift ); color, thickness, lineType, shift );
} }
void circle( Mat& img, Point center, int radius, void circle( Mat& img, Point center, int radius,
const Scalar& color, int thickness, int line_type, int shift ) const Scalar& color, int thickness, int line_type, int shift )
{ {
@ -1667,25 +1667,25 @@ void ellipse( Mat& img, Point center, Size axes,
EllipseEx( img, center, axes, _angle, _start_angle, EllipseEx( img, center, axes, _angle, _start_angle,
_end_angle, buf, thickness, line_type ); _end_angle, buf, thickness, line_type );
} }
void ellipse(Mat& img, const RotatedRect& box, const Scalar& color, void ellipse(Mat& img, const RotatedRect& box, const Scalar& color,
int thickness, int lineType) int thickness, int lineType)
{ {
if( lineType == CV_AA && img.depth() != CV_8U ) if( lineType == CV_AA && img.depth() != CV_8U )
lineType = 8; lineType = 8;
CV_Assert( box.size.width >= 0 && box.size.height >= 0 && CV_Assert( box.size.width >= 0 && box.size.height >= 0 &&
thickness <= 255 ); thickness <= 255 );
double buf[4]; double buf[4];
scalarToRawData(color, buf, img.type(), 0); scalarToRawData(color, buf, img.type(), 0);
int _angle = cvRound(box.angle); int _angle = cvRound(box.angle);
Point center(cvRound(box.center.x*(1 << XY_SHIFT)), Point center(cvRound(box.center.x*(1 << XY_SHIFT)),
cvRound(box.center.y*(1 << XY_SHIFT))); cvRound(box.center.y*(1 << XY_SHIFT)));
Size axes(cvRound(box.size.width*(1 << (XY_SHIFT - 1))), Size axes(cvRound(box.size.width*(1 << (XY_SHIFT - 1))),
cvRound(box.size.height*(1 << (XY_SHIFT - 1)))); cvRound(box.size.height*(1 << (XY_SHIFT - 1))));
EllipseEx( img, center, axes, _angle, 0, 360, buf, thickness, lineType ); EllipseEx( img, center, axes, _angle, 0, 360, buf, thickness, lineType );
} }
void fillConvexPoly( Mat& img, const Point* pts, int npts, void fillConvexPoly( Mat& img, const Point* pts, int npts,
@ -1875,12 +1875,12 @@ static const int HersheyScriptComplex[] = {
2662, 2663, 2664, 2665, 2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2662, 2663, 2664, 2665, 2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676,
2225, 2229, 2226, 2246 }; 2225, 2229, 2226, 2246 };
static const int* getFontData(int fontFace) static const int* getFontData(int fontFace)
{ {
bool isItalic = (fontFace & FONT_ITALIC) != 0; bool isItalic = (fontFace & FONT_ITALIC) != 0;
const int* ascii = 0; const int* ascii = 0;
switch( fontFace & 15 ) switch( fontFace & 15 )
{ {
case FONT_HERSHEY_SIMPLEX: case FONT_HERSHEY_SIMPLEX:
@ -1912,15 +1912,15 @@ static const int* getFontData(int fontFace)
} }
return ascii; return ascii;
} }
void putText( Mat& img, const string& text, Point org, void putText( Mat& img, const string& text, Point org,
int fontFace, double fontScale, Scalar color, int fontFace, double fontScale, Scalar color,
int thickness, int line_type, bool bottomLeftOrigin ) int thickness, int line_type, bool bottomLeftOrigin )
{ {
const int* ascii = getFontData(fontFace); const int* ascii = getFontData(fontFace);
double buf[4]; double buf[4];
scalarToRawData(color, buf, img.type(), 0); scalarToRawData(color, buf, img.type(), 0);
@ -1959,7 +1959,7 @@ void putText( Mat& img, const string& text, Point org,
if( *ptr == ' ' || !*ptr ) if( *ptr == ' ' || !*ptr )
{ {
if( pts.size() > 1 ) if( pts.size() > 1 )
PolyLine( img, &pts[0], (int)pts.size(), false, buf, thickness, line_type, XY_SHIFT ); PolyLine( img, &pts[0], (int)pts.size(), false, buf, thickness, line_type, XY_SHIFT );
if( !*ptr++ ) if( !*ptr++ )
break; break;
pts.resize(0); pts.resize(0);
@ -2030,7 +2030,7 @@ void cv::fillPoly(InputOutputArray _img, InputArrayOfArrays pts,
AutoBuffer<int> _npts(ncontours); AutoBuffer<int> _npts(ncontours);
Point** ptsptr = _ptsptr; Point** ptsptr = _ptsptr;
int* npts = _npts; int* npts = _npts;
for( i = 0; i < ncontours; i++ ) for( i = 0; i < ncontours; i++ )
{ {
Mat p = pts.getMat(i); Mat p = pts.getMat(i);
@ -2056,7 +2056,7 @@ void cv::polylines(InputOutputArray _img, InputArrayOfArrays pts,
AutoBuffer<int> _npts(ncontours); AutoBuffer<int> _npts(ncontours);
Point** ptsptr = _ptsptr; Point** ptsptr = _ptsptr;
int* npts = _npts; int* npts = _npts;
for( i = 0; i < ncontours; i++ ) for( i = 0; i < ncontours; i++ )
{ {
Mat p = pts.getMat(manyContours ? i : -1); Mat p = pts.getMat(manyContours ? i : -1);
@ -2069,6 +2069,116 @@ void cv::polylines(InputOutputArray _img, InputArrayOfArrays pts,
polylines(img, (const Point**)ptsptr, npts, (int)ncontours, isClosed, color, thickness, lineType, shift); polylines(img, (const Point**)ptsptr, npts, (int)ncontours, isClosed, color, thickness, lineType, shift);
} }
namespace
{
using namespace cv;
static void addChildContour(InputArrayOfArrays contours,
size_t ncontours,
const Vec4i* hierarchy,
int i, vector<CvSeq>& seq,
vector<CvSeqBlock>& block)
{
for( ; i >= 0; i = hierarchy[i][0] )
{
Mat ci = contours.getMat(i);
cvMakeSeqHeaderForArray(CV_SEQ_POLYGON, sizeof(CvSeq), sizeof(Point),
!ci.empty() ? (void*)ci.data : 0, (int)ci.total(),
&seq[i], &block[i] );
int h_next = hierarchy[i][0], h_prev = hierarchy[i][1],
v_next = hierarchy[i][2], v_prev = hierarchy[i][3];
seq[i].h_next = (size_t)h_next < ncontours ? &seq[h_next] : 0;
seq[i].h_prev = (size_t)h_prev < ncontours ? &seq[h_prev] : 0;
seq[i].v_next = (size_t)v_next < ncontours ? &seq[v_next] : 0;
seq[i].v_prev = (size_t)v_prev < ncontours ? &seq[v_prev] : 0;
if( v_next >= 0 )
addChildContour(contours, ncontours, hierarchy, v_next, seq, block);
}
}
}
void cv::drawContours( InputOutputArray _image, InputArrayOfArrays _contours,
int contourIdx, const Scalar& color, int thickness,
int lineType, InputArray _hierarchy,
int maxLevel, Point offset )
{
Mat image = _image.getMat(), hierarchy = _hierarchy.getMat();
CvMat _cimage = image;
size_t ncontours = _contours.total();
size_t i = 0, first = 0, last = ncontours;
vector<CvSeq> seq;
vector<CvSeqBlock> block;
if( !last )
return;
seq.resize(last);
block.resize(last);
for( i = first; i < last; i++ )
seq[i].first = 0;
if( contourIdx >= 0 )
{
CV_Assert( 0 <= contourIdx && contourIdx < (int)last );
first = contourIdx;
last = contourIdx + 1;
}
for( i = first; i < last; i++ )
{
Mat ci = _contours.getMat((int)i);
if( ci.empty() )
continue;
int npoints = ci.checkVector(2, CV_32S);
CV_Assert( npoints > 0 );
cvMakeSeqHeaderForArray( CV_SEQ_POLYGON, sizeof(CvSeq), sizeof(Point),
ci.data, npoints, &seq[i], &block[i] );
}
if( hierarchy.empty() || maxLevel == 0 )
for( i = first; i < last; i++ )
{
seq[i].h_next = i < last-1 ? &seq[i+1] : 0;
seq[i].h_prev = i > first ? &seq[i-1] : 0;
}
else
{
size_t count = last - first;
CV_Assert(hierarchy.total() == ncontours && hierarchy.type() == CV_32SC4 );
const Vec4i* h = hierarchy.ptr<Vec4i>();
if( count == ncontours )
{
for( i = first; i < last; i++ )
{
int h_next = h[i][0], h_prev = h[i][1],
v_next = h[i][2], v_prev = h[i][3];
seq[i].h_next = (size_t)h_next < count ? &seq[h_next] : 0;
seq[i].h_prev = (size_t)h_prev < count ? &seq[h_prev] : 0;
seq[i].v_next = (size_t)v_next < count ? &seq[v_next] : 0;
seq[i].v_prev = (size_t)v_prev < count ? &seq[v_prev] : 0;
}
}
else
{
int child = h[first][2];
if( child >= 0 )
{
addChildContour(_contours, ncontours, h, child, seq, block);
seq[first].v_next = &seq[child];
}
}
}
cvDrawContours( &_cimage, &seq[first], color, color, contourIdx >= 0 ?
-maxLevel : maxLevel, thickness, lineType, offset );
}
static const int CodeDeltas[8][2] = static const int CodeDeltas[8][2] =
{ {1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1} }; { {1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1} };
@ -2078,7 +2188,7 @@ static const int CodeDeltas[8][2] =
CV_IMPL void CV_IMPL void
cvDrawContours( void* _img, CvSeq* contour, cvDrawContours( void* _img, CvSeq* contour,
CvScalar _externalColor, CvScalar _holeColor, CvScalar _externalColor, CvScalar _holeColor,
int maxLevel, int thickness, int maxLevel, int thickness,
int line_type, CvPoint _offset ) int line_type, CvPoint _offset )
{ {
@ -2104,7 +2214,7 @@ cvDrawContours( void* _img, CvSeq* contour,
maxLevel = MAX(maxLevel, INT_MIN+2); maxLevel = MAX(maxLevel, INT_MIN+2);
maxLevel = MIN(maxLevel, INT_MAX-1); maxLevel = MIN(maxLevel, INT_MAX-1);
if( maxLevel < 0 ) if( maxLevel < 0 )
{ {
h_next = contour->h_next; h_next = contour->h_next;
@ -2148,7 +2258,7 @@ cvDrawContours( void* _img, CvSeq* contour,
pts.push_back(pt); pts.push_back(pt);
prev_pt = pt; prev_pt = pt;
} }
pt.x += CodeDeltas[(int)code][0]; pt.x += CodeDeltas[(int)code][0];
pt.y += CodeDeltas[(int)code][1]; pt.y += CodeDeltas[(int)code][1];
} }
@ -2166,7 +2276,7 @@ cvDrawContours( void* _img, CvSeq* contour,
CV_Assert( elem_type == CV_32SC2 ); CV_Assert( elem_type == CV_32SC2 );
cv::Point pt1, pt2; cv::Point pt1, pt2;
int shift = 0; int shift = 0;
count -= !CV_IS_SEQ_CLOSED(contour); count -= !CV_IS_SEQ_CLOSED(contour);
CV_READ_SEQ_ELEM( pt1, reader ); CV_READ_SEQ_ELEM( pt1, reader );
pt1 += offset; pt1 += offset;
@ -2218,7 +2328,7 @@ CV_IMPL CvScalar
cvColorToScalar( double packed_color, int type ) cvColorToScalar( double packed_color, int type )
{ {
CvScalar scalar; CvScalar scalar;
if( CV_MAT_DEPTH( type ) == CV_8U ) if( CV_MAT_DEPTH( type ) == CV_8U )
{ {
int icolor = cvRound( packed_color ); int icolor = cvRound( packed_color );

19
modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst
View File

@ -65,25 +65,6 @@ Computes the descriptors for a set of keypoints detected in an image (first vari
:param descriptors: Computed descriptors. In the second variant of the method ``descriptors[i]`` are descriptors computed for a ``keypoints[i]`. Row ``j`` is the ``keypoints`` (or ``keypoints[i]``) is the descriptor for keypoint ``j``-th keypoint. :param descriptors: Computed descriptors. In the second variant of the method ``descriptors[i]`` are descriptors computed for a ``keypoints[i]`. Row ``j`` is the ``keypoints`` (or ``keypoints[i]``) is the descriptor for keypoint ``j``-th keypoint.
DescriptorExtractor::read
-----------------------------
Reads the object of a descriptor extractor from a file node.
.. ocv:function:: void DescriptorExtractor::read( const FileNode& fn )
:param fn: File node from which the detector is read.
DescriptorExtractor::write
------------------------------
Writes the object of a descriptor extractor to a file storage.
.. ocv:function:: void DescriptorExtractor::write( FileStorage& fs ) const
:param fs: File storage where the detector is written.
DescriptorExtractor::create DescriptorExtractor::create
------------------------------- -------------------------------

16
modules/features2d/doc/common_interfaces_of_feature_detectors.rst
View File

@ -112,22 +112,6 @@ Detects keypoints in an image (first variant) or image set (second variant).
:param masks: Masks for each input image specifying where to look for keypoints (optional). ``masks[i]`` is a mask for ``images[i]``. :param masks: Masks for each input image specifying where to look for keypoints (optional). ``masks[i]`` is a mask for ``images[i]``.
FeatureDetector::read
-------------------------
Reads a feature detector object from a file node.
.. ocv:function:: void FeatureDetector::read( const FileNode& fn )
:param fn: File node from which the detector is read.
FeatureDetector::write
--------------------------
Writes a feature detector object to a file storage.
.. ocv:function:: void FeatureDetector::write( FileStorage& fs ) const
:param fs: File storage where the detector is written.
FeatureDetector::create FeatureDetector::create
--------------------------- ---------------------------
Creates a feature detector by its name. Creates a feature detector by its name.

2
modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst
View File

@ -289,7 +289,7 @@ Enables the :ocv:class:`gpu::StereoConstantSpaceBP` constructors.
.. ocv:function:: gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int nr_plane = DEFAULT_NR_PLANE, int msg_type = CV_32F) .. ocv:function:: gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int nr_plane = DEFAULT_NR_PLANE, int msg_type = CV_32F)
.. ocv:function:: StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int min_disp_th = 0, int msg_type = CV_32F) .. ocv:function:: gpu::StereoConstantSpaceBP::StereoConstantSpaceBP(int ndisp, int iters, int levels, int nr_plane, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int min_disp_th = 0, int msg_type = CV_32F)
:param ndisp: Number of disparities. :param ndisp: Number of disparities.

8
modules/gpu/doc/feature_detection_and_description.rst
View File

@ -346,19 +346,19 @@ Detects keypoints and computes descriptors for them.
gpu::ORB_GPU::downloadKeypoints gpu::ORB_GPU::downloadKeyPoints
------------------------------------- -------------------------------------
Download keypoints from GPU to CPU memory. Download keypoints from GPU to CPU memory.
.. ocv:function:: void gpu::ORB_GPU::downloadKeypoints(const GpuMat& d_keypoints, std::vector<KeyPoint>& keypoints) .. ocv:function:: void gpu::ORB_GPU::downloadKeyPoints( GpuMat& d_keypoints, std::vector<KeyPoint>& keypoints )
gpu::ORB_GPU::convertKeypoints gpu::ORB_GPU::convertKeyPoints
------------------------------------- -------------------------------------
Converts keypoints from GPU representation to vector of ``KeyPoint``. Converts keypoints from GPU representation to vector of ``KeyPoint``.
.. ocv:function:: void gpu::ORB_GPU::convertKeypoints(const Mat& h_keypoints, std::vector<KeyPoint>& keypoints) .. ocv:function:: void gpu::ORB_GPU::convertKeyPoints( Mat& d_keypoints, std::vector<KeyPoint>& keypoints )

2
modules/gpu/doc/image_filtering.rst
View File

@ -195,7 +195,7 @@ Creates a normalized 2D box filter.
.. ocv:function:: Ptr<FilterEngine_GPU> gpu::createBoxFilter_GPU(int srcType, int dstType, const Size& ksize, const Point& anchor = Point(-1,-1)) .. ocv:function:: Ptr<FilterEngine_GPU> gpu::createBoxFilter_GPU(int srcType, int dstType, const Size& ksize, const Point& anchor = Point(-1,-1))
.. ocv:function:: Ptr<BaseFilter_GPU> getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1)) .. ocv:function:: Ptr<BaseFilter_GPU> gpu::getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1))
:param srcType: Input image type supporting ``CV_8UC1`` and ``CV_8UC4`` . :param srcType: Input image type supporting ``CV_8UC1`` and ``CV_8UC4`` .

6
modules/gpu/doc/image_processing.rst
View File

@ -261,7 +261,7 @@ You can use field `user_block_size` to set specific block size for :ocv:func:`gp
gpu::ConvolveBuf::create gpu::ConvolveBuf::create
------------------------ ------------------------
.. ocv:function:: ConvolveBuf::create(Size image_size, Size templ_size) .. ocv:function:: gpu::ConvolveBuf::create(Size image_size, Size templ_size)
Constructs a buffer for :ocv:func:`gpu::convolve` function with respective arguments. Constructs a buffer for :ocv:func:`gpu::convolve` function with respective arguments.
@ -499,7 +499,7 @@ gpu::buildWarpAffineMaps
------------------------ ------------------------
Builds transformation maps for affine transformation. Builds transformation maps for affine transformation.
.. ocv:function:: void buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null()) .. ocv:function:: void gpu::buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null())
:param M: *2x3* transformation matrix. :param M: *2x3* transformation matrix.
@ -543,7 +543,7 @@ gpu::buildWarpPerspectiveMaps
----------------------------- -----------------------------
Builds transformation maps for perspective transformation. Builds transformation maps for perspective transformation.
.. ocv:function:: void buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null()) .. ocv:function:: void gpu::buildWarpAffineMaps(const Mat& M, bool inverse, Size dsize, GpuMat& xmap, GpuMat& ymap, Stream& stream = Stream::Null())
:param M: *3x3* transformation matrix. :param M: *3x3* transformation matrix.

7
modules/gpu/doc/initalization_and_information.rst
View File

@ -47,7 +47,6 @@ Any subsequent API call to this device will reinitialize the device.
gpu::FeatureSet gpu::FeatureSet
--------------- ---------------
.. ocv:class:: gpu::FeatureSet
Class providing GPU computing features. :: Class providing GPU computing features. ::
@ -74,7 +73,7 @@ Class providing a set of static methods to check what NVIDIA* card architecture
The following method checks whether the module was built with the support of the given feature: The following method checks whether the module was built with the support of the given feature:
.. ocv:function:: static bool gpu::TargetArchs::builtWith(FeatureSet feature) .. ocv:function:: static bool gpu::TargetArchs::builtWith( FeatureSet feature_set )
:param feature: Feature to be checked. See :ocv:class:`gpu::FeatureSet`. :param feature: Feature to be checked. See :ocv:class:`gpu::FeatureSet`.
@ -150,7 +149,7 @@ gpu::DeviceInfo::name
------------------------- -------------------------
Returns the device name. Returns the device name.
.. ocv:function:: string gpu::DeviceInfo::name() .. ocv:function:: string gpu::DeviceInfo::name() const
@ -198,7 +197,7 @@ gpu::DeviceInfo::supports
----------------------------- -----------------------------
Provides information on GPU feature support. Provides information on GPU feature support.
.. ocv:function:: bool gpu::DeviceInfo::supports(FeatureSet feature) .. ocv:function:: bool gpu::DeviceInfo::supports( FeatureSet feature_set ) const
:param feature: Feature to be checked. See :ocv:class:`gpu::FeatureSet`. :param feature: Feature to be checked. See :ocv:class:`gpu::FeatureSet`.

2
modules/gpu/doc/object_detection.rst
View File

@ -235,7 +235,7 @@ gpu::CascadeClassifier_GPU::CascadeClassifier_GPU
----------------------------------------------------- -----------------------------------------------------
Loads the classifier from a file. Loads the classifier from a file.
.. ocv:function:: gpu::CascadeClassifier_GPU(const string& filename) .. ocv:function:: gpu::CascadeClassifier_GPU::CascadeClassifier_GPU(const string& filename)
:param filename: Name of the file from which the classifier is loaded. Only the old ``haar`` classifier (trained by the ``haar`` training application) and NVIDIA's ``nvbin`` are supported. :param filename: Name of the file from which the classifier is loaded. Only the old ``haar`` classifier (trained by the ``haar`` training application) and NVIDIA's ``nvbin`` are supported.

2
modules/gpu/doc/operations_on_matrices.rst
View File

@ -9,7 +9,7 @@ gpu::gemm
------------------ ------------------
Performs generalized matrix multiplication. Performs generalized matrix multiplication.
.. ocv:function:: void gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const GpuMat& src3, double beta, GpuMat& dst, int flags = 0, Stream& stream = Stream::Null()) .. ocv:function:: void gpu::gemm(const GpuMat& src1, const GpuMat& src2, double alpha, const GpuMat& src3, double beta, GpuMat& dst, int flags = 0, Stream& stream = Stream::Null())
:param src1: First multiplied input matrix that should have ``CV_32FC1`` , ``CV_64FC1`` , ``CV_32FC2`` , or ``CV_64FC2`` type. :param src1: First multiplied input matrix that should have ``CV_32FC1`` , ``CV_64FC1`` , ``CV_32FC2`` , or ``CV_64FC2`` type.

2
modules/gpu/doc/video.rst
View File

@ -475,7 +475,7 @@ gpu::VideoWriter_GPU::EncoderCallBack::acquireBitStream
------------------------------------------------------- -------------------------------------------------------
Callback function to signal the start of bitstream that is to be encoded. Callback function to signal the start of bitstream that is to be encoded.
.. ocv:function:: virtual unsigned char* gpu::VideoWriter_GPU::EncoderCallBack::acquireBitStream(int* bufferSize) = 0 .. ocv:function:: virtual uchar* gpu::VideoWriter_GPU::EncoderCallBack::acquireBitStream(int* bufferSize) = 0
Callback must allocate buffer for CUDA encoder and return pointer to it and it's size. Callback must allocate buffer for CUDA encoder and return pointer to it and it's size.

2
modules/gpu/include/opencv2/gpu/gpu.hpp
View File

@ -1978,7 +1978,7 @@ public:
// callback function to signal the start of bitstream that is to be encoded // callback function to signal the start of bitstream that is to be encoded
// must return pointer to buffer // must return pointer to buffer
virtual unsigned char* acquireBitStream(int* bufferSize) = 0; virtual uchar* acquireBitStream(int* bufferSize) = 0;
// callback function to signal that the encoded bitstream is ready to be written to file // callback function to signal that the encoded bitstream is ready to be written to file
virtual void releaseBitStream(unsigned char* data, int size) = 0; virtual void releaseBitStream(unsigned char* data, int size) = 0;

18
modules/highgui/doc/qt_new_functions.rst
View File

@ -226,27 +226,21 @@ The function ``displayOverlay`` displays useful information/tips on top of the w
*delayms* *delayms*
. This information is displayed on the window statusbar (the window must be created with the ``CV_GUI_EXPANDED`` flags). . This information is displayed on the window statusbar (the window must be created with the ``CV_GUI_EXPANDED`` flags).
createOpenGLCallback setOpenGlDrawCallback
------------------------ ------------------------
Creates a callback function called to draw OpenGL on top the image display by ``windowname``. Sets a callback function to be called to draw on top of displayed image.
.. ocv:function:: void createOpenGLCallback( const string& window_name, OpenGLCallback callbackOpenGL, void* userdata =NULL, double angle=-1, double zmin=-1, double zmax=-1) .. ocv:function:: void setOpenGlDrawCallback( const string& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata=0 )
.. ocv:cfunction:: void cvCreateOpenGLCallback( const char* windowName, CvOpenGLCallback callbackOpenGL, void* userdata=NULL, double angle=-1, double zmin=-1, double zmax=-1 ) .. ocv:cfunction:: void cvSetOpenGlDrawCallback( const char* window_name, CvOpenGlDrawCallback callback, void* userdata=NULL )
:param window_name: Name of the window. :param window_name: Name of the window.
:param callbackOpenGL: Pointer to the function to be called every frame. This function should be prototyped as ``void Foo(*void);`` . :param callbackOpenGL: Pointer to the function to be called every frame. This function should be prototyped as ``void Foo(void*)`` .
:param userdata: Pointer passed to the callback function. *(Optional)* :param userdata: Pointer passed to the callback function. *(Optional)*
:param angle: Parameter specifying the field of a view angle, in degrees, in the y direction. Default value is 45 degrees. *(Optional)* The function ``setOpenGlDrawCallback`` can be used to draw 3D data on the window. See the example of callback function below: ::
:param zmin: Parameter specifying the distance from the viewer to the near clipping plane (always positive). Default value is 0.01. *(Optional)*
:param zmax: Parameter specifying the distance from the viewer to the far clipping plane (always positive). Default value is 1000. *(Optional)*
The function ``createOpenGLCallback`` can be used to draw 3D data on the window. See the example of callback use below: ::
void on_opengl(void* param) void on_opengl(void* param)
{ {

87
modules/imgproc/doc/histograms.rst
View File

@ -406,44 +406,6 @@ Creates a histogram.
The function creates a histogram of the specified size and returns a pointer to the created histogram. If the array ``ranges`` is 0, the histogram bin ranges must be specified later via the function :ocv:cfunc:`SetHistBinRanges`. Though :ocv:cfunc:`CalcHist` and :ocv:cfunc:`CalcBackProject` may process 8-bit images without setting bin ranges, they assume they are equally spaced in 0 to 255 bins. The function creates a histogram of the specified size and returns a pointer to the created histogram. If the array ``ranges`` is 0, the histogram bin ranges must be specified later via the function :ocv:cfunc:`SetHistBinRanges`. Though :ocv:cfunc:`CalcHist` and :ocv:cfunc:`CalcBackProject` may process 8-bit images without setting bin ranges, they assume they are equally spaced in 0 to 255 bins.
GetHistValue\_?D
----------------
Returns a pointer to the histogram bin.
.. ocv:cfunction:: float cvGetHistValue_1D(CvHistogram hist, int idx0)
.. ocv:cfunction:: float cvGetHistValue_2D(CvHistogram hist, int idx0, int idx1)
.. ocv:cfunction:: float cvGetHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
.. ocv:cfunction:: float cvGetHistValue_nD(CvHistogram hist, int idx)
:param hist: Histogram.
:param idx0: 0-th index.
:param idx1: 1-st index.
:param idx2: 2-nd index.
:param idx: Array of indices.
::
#define cvGetHistValue_1D( hist, idx0 )
((float*)(cvPtr1D( (hist)->bins, (idx0), 0 ))
#define cvGetHistValue_2D( hist, idx0, idx1 )
((float*)(cvPtr2D( (hist)->bins, (idx0), (idx1), 0 )))
#define cvGetHistValue_3D( hist, idx0, idx1, idx2 )
((float*)(cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0 )))
#define cvGetHistValue_nD( hist, idx )
((float*)(cvPtrND( (hist)->bins, (idx), 0 )))
..
The macros ``GetHistValue`` return a pointer to the specified bin of the 1D, 2D, 3D, or N-D histogram. In case of a sparse histogram, the function creates a new bin and sets it to 0, unless it exists already.
GetMinMaxHistValue GetMinMaxHistValue
------------------ ------------------
Finds the minimum and maximum histogram bins. Finds the minimum and maximum histogram bins.
@ -499,32 +461,6 @@ Normalizes the histogram.
The function normalizes the histogram bins by scaling them so that the sum of the bins becomes equal to ``factor``. The function normalizes the histogram bins by scaling them so that the sum of the bins becomes equal to ``factor``.
QueryHistValue*D
----------------
Queries the value of the histogram bin.
.. ocv:cfunction:: float QueryHistValue_1D(CvHistogram hist, int idx0)
.. ocv:cfunction:: float QueryHistValue_2D(CvHistogram hist, int idx0, int idx1)
.. ocv:cfunction:: float QueryHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
.. ocv:cfunction:: float QueryHistValue_nD(CvHistogram hist, const int* idx)
.. ocv:pyoldfunction:: cv.QueryHistValue_1D(hist, idx0) -> float
.. ocv:pyoldfunction:: cv.QueryHistValue_2D(hist, idx0, idx1) -> float
.. ocv:pyoldfunction:: cv.QueryHistValue_3D(hist, idx0, idx1, idx2) -> float
.. ocv:pyoldfunction:: cv.QueryHistValue_nD(hist, idx) -> float
:param hist: Histogram.
:param idx0: 0-th index.
:param idx1: 1-st index.
:param idx2: 2-nd index.
:param idx: Array of indices.
The macros return the value of the specified bin of the 1D, 2D, 3D, or N-D histogram. In case of a sparse histogram, the function returns 0. If the bin is not present in the histogram, no new bin is created.
ReleaseHist ReleaseHist
----------- -----------
Releases the histogram. Releases the histogram.
@ -565,27 +501,4 @@ Thresholds the histogram.
The function clears histogram bins that are below the specified threshold. The function clears histogram bins that are below the specified threshold.
CalcPGH
-------
Calculates a pair-wise geometrical histogram for a contour.
.. ocv:cfunction:: void cvCalcPGH( const CvSeq* contour, CvHistogram* hist )
:param contour: Input contour. Currently, only integer point coordinates are allowed.
:param hist: Calculated histogram. It must be two-dimensional.
The function calculates a 2D pair-wise geometrical histogram (PGH), described in [Iivarinen97]_ for the contour. The algorithm considers every pair of contour
edges. The angle between the edges and the minimum/maximum distances
are determined for every pair. To do this, each of the edges in turn
is taken as the base, while the function loops through all the other
edges. When the base edge and any other edge are considered, the minimum
and maximum distances from the points on the non-base edge and line of
the base edge are selected. The angle between the edges defines the row
of the histogram in which all the bins that correspond to the distance
between the calculated minimum and maximum distances are incremented
(that is, the histogram is transposed relatively to the definition in the original paper). The histogram can be used for contour matching.
.. [RubnerSept98] Y. Rubner. C. Tomasi, L.J. Guibas. *The Earth Mover’s Distance as a Metric for Image Retrieval*. Technical Report STAN-CS-TN-98-86, Department of Computer Science, Stanford University, September 1998. .. [RubnerSept98] Y. Rubner. C. Tomasi, L.J. Guibas. *The Earth Mover’s Distance as a Metric for Image Retrieval*. Technical Report STAN-CS-TN-98-86, Department of Computer Science, Stanford University, September 1998.
.. [Iivarinen97] Jukka Iivarinen, Markus Peura, Jaakko Srel, and Ari Visa. *Comparison of Combined Shape Descriptors for Irregular Objects*, 8th British Machine Vision Conference, BMVC'97. http://www.cis.hut.fi/research/IA/paper/publications/bmvc97/bmvc97.html

81
modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst
View File

@ -166,87 +166,6 @@ The function retrieves contours from the binary image using the algorithm
.. note:: If you use the new Python interface then the ``CV_`` prefix has to be omitted in contour retrieval mode and contour approximation method parameters (for example, use ``cv2.RETR_LIST`` and ``cv2.CHAIN_APPROX_NONE`` parameters). If you use the old Python interface then these parameters have the ``CV_`` prefix (for example, use ``cv.CV_RETR_LIST`` and ``cv.CV_CHAIN_APPROX_NONE``). .. note:: If you use the new Python interface then the ``CV_`` prefix has to be omitted in contour retrieval mode and contour approximation method parameters (for example, use ``cv2.RETR_LIST`` and ``cv2.CHAIN_APPROX_NONE`` parameters). If you use the old Python interface then these parameters have the ``CV_`` prefix (for example, use ``cv.CV_RETR_LIST`` and ``cv.CV_CHAIN_APPROX_NONE``).
drawContours
----------------
Draws contours outlines or filled contours.
.. ocv:function:: void drawContours( InputOutputArray image, InputArrayOfArrays contours, int contourIdx, const Scalar& color, int thickness=1, int lineType=8, InputArray hierarchy=noArray(), int maxLevel=INT_MAX, Point offset=Point() )
.. ocv:pyfunction:: cv2.drawContours(image, contours, contourIdx, color[, thickness[, lineType[, hierarchy[, maxLevel[, offset]]]]]) -> None
.. ocv:cfunction:: void cvDrawContours( CvArr *img, CvSeq* contour, CvScalar externalColor, CvScalar holeColor, int maxLevel, int thickness=1, int lineType=8 )
.. ocv:pyoldfunction:: cv.DrawContours(img, contour, external_color, hole_color, max_level, thickness=1, lineType=8, offset=(0, 0))-> None
:param image: Destination image.
:param contours: All the input contours. Each contour is stored as a point vector.
:param contourIdx: Parameter indicating a contour to draw. If it is negative, all the contours are drawn.
:param color: Color of the contours.
:param thickness: Thickness of lines the contours are drawn with. If it is negative (for example, ``thickness=CV_FILLED`` ), the contour interiors are
drawn.
:param lineType: Line connectivity. See :ocv:func:`line` for details.
:param hierarchy: Optional information about hierarchy. It is only needed if you want to draw only some of the contours (see ``maxLevel`` ).
:param maxLevel: Maximal level for drawn contours. If it is 0, only
the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is ``hierarchy`` available.
:param offset: Optional contour shift parameter. Shift all the drawn contours by the specified :math:`\texttt{offset}=(dx,dy)` .
:param contour: Pointer to the first contour.
:param externalColor: Color of external contours.
:param holeColor: Color of internal contours (holes).
The function draws contour outlines in the image if
:math:`\texttt{thickness} \ge 0` or fills the area bounded by the contours if
:math:`\texttt{thickness}<0` . The example below shows how to retrieve connected components from the binary image and label them: ::
#include "cv.h"
#include "highgui.h"
using namespace cv;
int main( int argc, char** argv )
{
Mat src;
// the first command-line parameter must be a filename of the binary
// (black-n-white) image
if( argc != 2 || !(src=imread(argv[1], 0)).data)
return -1;
Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);
src = src > 1;
namedWindow( "Source", 1 );
imshow( "Source", src );
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
findContours( src, contours, hierarchy,
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
// iterate through all the top-level contours,
// draw each connected component with its own random color
int idx = 0;
for( ; idx >= 0; idx = hierarchy[idx][0] )
{
Scalar color( rand()&255, rand()&255, rand()&255 );
drawContours( dst, contours, idx, color, CV_FILLED, 8, hierarchy );
}
namedWindow( "Components", 1 );
imshow( "Components", dst );
waitKey(0);
}
approxPolyDP approxPolyDP
---------------- ----------------

7
modules/imgproc/include/opencv2/imgproc/imgproc.hpp
View File

@ -1078,13 +1078,6 @@ CV_EXPORTS_W void findContours( InputOutputArray image, OutputArrayOfArrays cont
CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contours, CV_EXPORTS void findContours( InputOutputArray image, OutputArrayOfArrays contours,
int mode, int method, Point offset=Point()); int mode, int method, Point offset=Point());
//! draws contours in the image
CV_EXPORTS_W void drawContours( InputOutputArray image, InputArrayOfArrays contours,
int contourIdx, const Scalar& color,
int thickness=1, int lineType=8,
InputArray hierarchy=noArray(),
int maxLevel=INT_MAX, Point offset=Point() );
//! approximates contour or a curve using Douglas-Peucker algorithm //! approximates contour or a curve using Douglas-Peucker algorithm
CV_EXPORTS_W void approxPolyDP( InputArray curve, CV_EXPORTS_W void approxPolyDP( InputArray curve,
OutputArray approxCurve, OutputArray approxCurve,

214
modules/imgproc/src/contours.cpp
View File

@ -159,7 +159,7 @@ typedef struct _CvContourScanner
external contours and holes), external contours and holes),
3 - full hierarchy; 3 - full hierarchy;
4 - connected components of a multi-level image 4 - connected components of a multi-level image
*/ */
int subst_flag; int subst_flag;
int seq_type1; /* type of fetched contours */ int seq_type1; /* type of fetched contours */
int header_size1; /* hdr size of fetched contours */ int header_size1; /* hdr size of fetched contours */
@ -190,7 +190,7 @@ cvStartFindContours( void* _img, CvMemStorage* storage,
if( CV_MAT_TYPE(mat->type) == CV_32SC1 && mode == CV_RETR_CCOMP ) if( CV_MAT_TYPE(mat->type) == CV_32SC1 && mode == CV_RETR_CCOMP )
mode = CV_RETR_FLOODFILL; mode = CV_RETR_FLOODFILL;
if( !((CV_IS_MASK_ARR( mat ) && mode < CV_RETR_FLOODFILL) || if( !((CV_IS_MASK_ARR( mat ) && mode < CV_RETR_FLOODFILL) ||
(CV_MAT_TYPE(mat->type) == CV_32SC1 && mode == CV_RETR_FLOODFILL)) ) (CV_MAT_TYPE(mat->type) == CV_32SC1 && mode == CV_RETR_FLOODFILL)) )
CV_Error( CV_StsUnsupportedFormat, "[Start]FindContours support only 8uC1 and 32sC1 images" ); CV_Error( CV_StsUnsupportedFormat, "[Start]FindContours support only 8uC1 and 32sC1 images" );
@ -207,7 +207,7 @@ cvStartFindContours( void* _img, CvMemStorage* storage,
CvContourScanner scanner = (CvContourScanner)cvAlloc( sizeof( *scanner )); CvContourScanner scanner = (CvContourScanner)cvAlloc( sizeof( *scanner ));
memset( scanner, 0, sizeof(*scanner) ); memset( scanner, 0, sizeof(*scanner) );
scanner->storage1 = scanner->storage2 = storage; scanner->storage1 = scanner->storage2 = storage;
scanner->img0 = (schar *) img; scanner->img0 = (schar *) img;
scanner->img = (schar *) (img + step); scanner->img = (schar *) (img + step);
@ -805,13 +805,13 @@ icvTraceContour_32s( int *ptr, int step, int *stop_ptr, int is_hole )
const int new_flag = (int)((unsigned)INT_MIN >> 1); const int new_flag = (int)((unsigned)INT_MIN >> 1);
const int value_mask = ~(right_flag | new_flag); const int value_mask = ~(right_flag | new_flag);
const int ccomp_val = *i0 & value_mask; const int ccomp_val = *i0 & value_mask;
/* initialize local state */ /* initialize local state */
CV_INIT_3X3_DELTAS( deltas, step, 1 ); CV_INIT_3X3_DELTAS( deltas, step, 1 );
memcpy( deltas + 8, deltas, 8 * sizeof( deltas[0] )); memcpy( deltas + 8, deltas, 8 * sizeof( deltas[0] ));
s_end = s = is_hole ? 0 : 4; s_end = s = is_hole ? 0 : 4;
do do
{ {
s = (s - 1) & 7; s = (s - 1) & 7;
@ -820,9 +820,9 @@ icvTraceContour_32s( int *ptr, int step, int *stop_ptr, int is_hole )
break; break;
} }
while( s != s_end ); while( s != s_end );
i3 = i0; i3 = i0;
/* check single pixel domain */ /* check single pixel domain */
if( s != s_end ) if( s != s_end )
{ {
@ -830,17 +830,17 @@ icvTraceContour_32s( int *ptr, int step, int *stop_ptr, int is_hole )
for( ;; ) for( ;; )
{ {
s_end = s; s_end = s;
for( ;; ) for( ;; )
{ {
i4 = i3 + deltas[++s]; i4 = i3 + deltas[++s];
if( (*i4 & value_mask) == ccomp_val ) if( (*i4 & value_mask) == ccomp_val )
break; break;
} }
if( i3 == stop_ptr || (i4 == i0 && i3 == i1) ) if( i3 == stop_ptr || (i4 == i0 && i3 == i1) )
break; break;
i3 = i4; i3 = i4;
s = (s + 4) & 7; s = (s + 4) & 7;
} /* end of border following loop */ } /* end of border following loop */
@ -869,24 +869,24 @@ icvFetchContourEx_32s( int* ptr,
const int ccomp_val = *i0 & value_mask; const int ccomp_val = *i0 & value_mask;
const int nbd0 = ccomp_val | new_flag; const int nbd0 = ccomp_val | new_flag;
const int nbd1 = nbd0 | right_flag; const int nbd1 = nbd0 | right_flag;
assert( (unsigned) _method <= CV_CHAIN_APPROX_SIMPLE ); assert( (unsigned) _method <= CV_CHAIN_APPROX_SIMPLE );
/* initialize local state */ /* initialize local state */
CV_INIT_3X3_DELTAS( deltas, step, 1 ); CV_INIT_3X3_DELTAS( deltas, step, 1 );
memcpy( deltas + 8, deltas, 8 * sizeof( deltas[0] )); memcpy( deltas + 8, deltas, 8 * sizeof( deltas[0] ));
/* initialize writer */ /* initialize writer */
cvStartAppendToSeq( contour, &writer ); cvStartAppendToSeq( contour, &writer );
if( method < 0 ) if( method < 0 )
((CvChain *)contour)->origin = pt; ((CvChain *)contour)->origin = pt;
rect.x = rect.width = pt.x; rect.x = rect.width = pt.x;
rect.y = rect.height = pt.y; rect.y = rect.height = pt.y;
s_end = s = CV_IS_SEQ_HOLE( contour ) ? 0 : 4; s_end = s = CV_IS_SEQ_HOLE( contour ) ? 0 : 4;
do do
{ {
s = (s - 1) & 7; s = (s - 1) & 7;
@ -895,7 +895,7 @@ icvFetchContourEx_32s( int* ptr,
break; break;
} }
while( s != s_end ); while( s != s_end );
if( s == s_end ) /* single pixel domain */ if( s == s_end ) /* single pixel domain */
{ {
*i0 = nbd1; *i0 = nbd1;
@ -908,12 +908,12 @@ icvFetchContourEx_32s( int* ptr,
{ {
i3 = i0; i3 = i0;
prev_s = s ^ 4; prev_s = s ^ 4;
/* follow border */ /* follow border */
for( ;; ) for( ;; )
{ {
s_end = s; s_end = s;
for( ;; ) for( ;; )
{ {
i4 = i3 + deltas[++s]; i4 = i3 + deltas[++s];
@ -921,7 +921,7 @@ icvFetchContourEx_32s( int* ptr,
break; break;
} }
s &= 7; s &= 7;
/* check "right" bound */ /* check "right" bound */
if( (unsigned) (s - 1) < (unsigned) s_end ) if( (unsigned) (s - 1) < (unsigned) s_end )
{ {
@ -931,7 +931,7 @@ icvFetchContourEx_32s( int* ptr,
{ {
*i3 = nbd0; *i3 = nbd0;
} }
if( method < 0 ) if( method < 0 )
{ {
schar _s = (schar) s; schar _s = (schar) s;
@ -941,7 +941,7 @@ icvFetchContourEx_32s( int* ptr,
{ {
CV_WRITE_SEQ_ELEM( pt, writer ); CV_WRITE_SEQ_ELEM( pt, writer );
} }
if( s != prev_s ) if( s != prev_s )
{ {
/* update bounds */ /* update bounds */
@ -949,37 +949,37 @@ icvFetchContourEx_32s( int* ptr,
rect.x = pt.x; rect.x = pt.x;
else if( pt.x > rect.width ) else if( pt.x > rect.width )
rect.width = pt.x; rect.width = pt.x;
if( pt.y < rect.y ) if( pt.y < rect.y )
rect.y = pt.y; rect.y = pt.y;
else if( pt.y > rect.height ) else if( pt.y > rect.height )
rect.height = pt.y; rect.height = pt.y;
} }
prev_s = s; prev_s = s;
pt.x += icvCodeDeltas[s].x; pt.x += icvCodeDeltas[s].x;
pt.y += icvCodeDeltas[s].y; pt.y += icvCodeDeltas[s].y;
if( i4 == i0 && i3 == i1 ) break; if( i4 == i0 && i3 == i1 ) break;
i3 = i4; i3 = i4;
s = (s + 4) & 7; s = (s + 4) & 7;
} /* end of border following loop */ } /* end of border following loop */
} }
rect.width -= rect.x - 1; rect.width -= rect.x - 1;
rect.height -= rect.y - 1; rect.height -= rect.y - 1;
cvEndWriteSeq( &writer ); cvEndWriteSeq( &writer );
if( _method != CV_CHAIN_CODE ) if( _method != CV_CHAIN_CODE )
((CvContour*)contour)->rect = rect; ((CvContour*)contour)->rect = rect;
assert( (writer.seq->total == 0 && writer.seq->first == 0) || assert( (writer.seq->total == 0 && writer.seq->first == 0) ||
writer.seq->total > writer.seq->first->count || writer.seq->total > writer.seq->first->count ||
(writer.seq->first->prev == writer.seq->first && (writer.seq->first->prev == writer.seq->first &&
writer.seq->first->next == writer.seq->first) ); writer.seq->first->next == writer.seq->first) );
if( _rect ) *_rect = rect; if( _rect ) *_rect = rect;
} }
@ -1005,7 +1005,7 @@ cvFindNextContour( CvContourScanner scanner )
int nbd = scanner->nbd; int nbd = scanner->nbd;
int prev = img[x - 1]; int prev = img[x - 1];
int new_mask = -2; int new_mask = -2;
if( mode == CV_RETR_FLOODFILL ) if( mode == CV_RETR_FLOODFILL )
{ {
prev = ((int*)img)[x - 1]; prev = ((int*)img)[x - 1];
@ -1017,13 +1017,13 @@ cvFindNextContour( CvContourScanner scanner )
int* img0_i = 0; int* img0_i = 0;
int* img_i = 0; int* img_i = 0;
int p = 0; int p = 0;
if( mode == CV_RETR_FLOODFILL ) if( mode == CV_RETR_FLOODFILL )
{ {
img0_i = (int*)img0; img0_i = (int*)img0;
img_i = (int*)img; img_i = (int*)img;
} }
for( ; x < width; x++ ) for( ; x < width; x++ )
{ {
if( img_i ) if( img_i )
@ -1036,10 +1036,10 @@ cvFindNextContour( CvContourScanner scanner )
for( ; x < width && (p = img[x]) == prev; x++ ) for( ; x < width && (p = img[x]) == prev; x++ )
; ;
} }
if( x >= width ) if( x >= width )
break; break;
{ {
_CvContourInfo *par_info = 0; _CvContourInfo *par_info = 0;
_CvContourInfo *l_cinfo = 0; _CvContourInfo *l_cinfo = 0;
@ -1053,7 +1053,7 @@ cvFindNextContour( CvContourScanner scanner )
{ {
/* check hole */ /* check hole */
if( (!img_i && (p != 0 || prev < 1)) || if( (!img_i && (p != 0 || prev < 1)) ||
(img_i && ((prev & new_mask) != 0 || (p & new_mask) != 0))) (img_i && ((prev & new_mask) != 0 || (p & new_mask) != 0)))
goto resume_scan; goto resume_scan;
if( prev & new_mask ) if( prev & new_mask )
@ -1219,7 +1219,7 @@ cvFindNextContour( CvContourScanner scanner )
return l_cinfo->contour; return l_cinfo->contour;
resume_scan: resume_scan:
prev = p; prev = p;
/* update lnbd */ /* update lnbd */
if( prev & -2 ) if( prev & -2 )
@ -1663,7 +1663,7 @@ cvFindContours( void* img, CvMemStorage* storage,
if( !firstContour ) if( !firstContour )
CV_Error( CV_StsNullPtr, "NULL double CvSeq pointer" ); CV_Error( CV_StsNullPtr, "NULL double CvSeq pointer" );
*firstContour = 0; *firstContour = 0;
if( method == CV_LINK_RUNS ) if( method == CV_LINK_RUNS )
@ -1733,7 +1733,7 @@ void cv::findContours( InputOutputArray _image, OutputArrayOfArrays _contours,
{ {
_hierarchy.create(1, total, CV_32SC4, -1, true); _hierarchy.create(1, total, CV_32SC4, -1, true);
Vec4i* hierarchy = _hierarchy.getMat().ptr<Vec4i>(); Vec4i* hierarchy = _hierarchy.getMat().ptr<Vec4i>();
it = all_contours.begin(); it = all_contours.begin();
for( i = 0; i < total; i++, ++it ) for( i = 0; i < total; i++, ++it )
{ {
@ -1753,116 +1753,6 @@ void cv::findContours( InputOutputArray _image, OutputArrayOfArrays _contours,
findContours(_image, _contours, noArray(), mode, method, offset); findContours(_image, _contours, noArray(), mode, method, offset);
} }
namespace cv
{
static void addChildContour(InputArrayOfArrays contours,
size_t ncontours,
const Vec4i* hierarchy,
int i, vector<CvSeq>& seq,
vector<CvSeqBlock>& block)
{
for( ; i >= 0; i = hierarchy[i][0] )
{
Mat ci = contours.getMat(i);
cvMakeSeqHeaderForArray(CV_SEQ_POLYGON, sizeof(CvSeq), sizeof(Point),
!ci.empty() ? (void*)ci.data : 0, (int)ci.total(),
&seq[i], &block[i] );
int h_next = hierarchy[i][0], h_prev = hierarchy[i][1],
v_next = hierarchy[i][2], v_prev = hierarchy[i][3];
seq[i].h_next = (size_t)h_next < ncontours ? &seq[h_next] : 0;
seq[i].h_prev = (size_t)h_prev < ncontours ? &seq[h_prev] : 0;
seq[i].v_next = (size_t)v_next < ncontours ? &seq[v_next] : 0;
seq[i].v_prev = (size_t)v_prev < ncontours ? &seq[v_prev] : 0;
if( v_next >= 0 )
addChildContour(contours, ncontours, hierarchy, v_next, seq, block);
}
}
}
void cv::drawContours( InputOutputArray _image, InputArrayOfArrays _contours,
int contourIdx, const Scalar& color, int thickness,
int lineType, InputArray _hierarchy,
int maxLevel, Point offset )
{
Mat image = _image.getMat(), hierarchy = _hierarchy.getMat();
CvMat _cimage = image;
size_t ncontours = _contours.total();
size_t i = 0, first = 0, last = ncontours;
vector<CvSeq> seq;
vector<CvSeqBlock> block;
if( !last )
return;
seq.resize(last);
block.resize(last);
for( i = first; i < last; i++ )
seq[i].first = 0;
if( contourIdx >= 0 )
{
CV_Assert( 0 <= contourIdx && contourIdx < (int)last );
first = contourIdx;
last = contourIdx + 1;
}
for( i = first; i < last; i++ )
{
Mat ci = _contours.getMat((int)i);
if( ci.empty() )
continue;
int npoints = ci.checkVector(2, CV_32S);
CV_Assert( npoints > 0 );
cvMakeSeqHeaderForArray( CV_SEQ_POLYGON, sizeof(CvSeq), sizeof(Point),
ci.data, npoints, &seq[i], &block[i] );
}
if( hierarchy.empty() || maxLevel == 0 )
for( i = first; i < last; i++ )
{
seq[i].h_next = i < last-1 ? &seq[i+1] : 0;
seq[i].h_prev = i > first ? &seq[i-1] : 0;
}
else
{
size_t count = last - first;
CV_Assert(hierarchy.total() == ncontours && hierarchy.type() == CV_32SC4 );
const Vec4i* h = hierarchy.ptr<Vec4i>();
if( count == ncontours )
{
for( i = first; i < last; i++ )
{
int h_next = h[i][0], h_prev = h[i][1],
v_next = h[i][2], v_prev = h[i][3];
seq[i].h_next = (size_t)h_next < count ? &seq[h_next] : 0;
seq[i].h_prev = (size_t)h_prev < count ? &seq[h_prev] : 0;
seq[i].v_next = (size_t)v_next < count ? &seq[v_next] : 0;
seq[i].v_prev = (size_t)v_prev < count ? &seq[v_prev] : 0;
}
}
else
{
int child = h[first][2];
if( child >= 0 )
{
addChildContour(_contours, ncontours, h, child, seq, block);
seq[first].v_next = &seq[child];
}
}
}
cvDrawContours( &_cimage, &seq[first], color, color, contourIdx >= 0 ?
-maxLevel : maxLevel, thickness, lineType, offset );
}
void cv::approxPolyDP( InputArray _curve, OutputArray _approxCurve, void cv::approxPolyDP( InputArray _curve, OutputArray _approxCurve,
double epsilon, bool closed ) double epsilon, bool closed )
{ {
@ -1934,7 +1824,7 @@ double cv::matchShapes( InputArray _contour1,
CV_Assert(contour1.checkVector(2) >= 0 && contour2.checkVector(2) >= 0 && CV_Assert(contour1.checkVector(2) >= 0 && contour2.checkVector(2) >= 0 &&
(contour1.depth() == CV_32F || contour1.depth() == CV_32S) && (contour1.depth() == CV_32F || contour1.depth() == CV_32S) &&
contour1.depth() == contour2.depth()); contour1.depth() == contour2.depth());
CvMat c1 = Mat(contour1), c2 = Mat(contour2); CvMat c1 = Mat(contour1), c2 = Mat(contour2);
return cvMatchShapes(&c1, &c2, method, parameter); return cvMatchShapes(&c1, &c2, method, parameter);
} }
@ -1945,13 +1835,13 @@ void cv::convexHull( InputArray _points, OutputArray _hull, bool clockwise, bool
Mat points = _points.getMat(); Mat points = _points.getMat();
int nelems = points.checkVector(2), depth = points.depth(); int nelems = points.checkVector(2), depth = points.depth();
CV_Assert(nelems >= 0 && (depth == CV_32F || depth == CV_32S)); CV_Assert(nelems >= 0 && (depth == CV_32F || depth == CV_32S));
if( nelems == 0 ) if( nelems == 0 )
{ {
_hull.release(); _hull.release();
return; return;
} }
returnPoints = !_hull.fixedType() ? returnPoints : _hull.type() != CV_32S; returnPoints = !_hull.fixedType() ? returnPoints : _hull.type() != CV_32S;
Mat hull(nelems, 1, returnPoints ? CV_MAKETYPE(depth, 2) : CV_32S); Mat hull(nelems, 1, returnPoints ? CV_MAKETYPE(depth, 2) : CV_32S);
CvMat _cpoints = points, _chull = hull; CvMat _cpoints = points, _chull = hull;
@ -1970,23 +1860,23 @@ void cv::convexityDefects( InputArray _points, InputArray _hull, OutputArray _de
Mat hull = _hull.getMat(); Mat hull = _hull.getMat();
CV_Assert( hull.checkVector(1, CV_32S) > 2 ); CV_Assert( hull.checkVector(1, CV_32S) > 2 );
Ptr<CvMemStorage> storage = cvCreateMemStorage(); Ptr<CvMemStorage> storage = cvCreateMemStorage();
CvMat c_points = points, c_hull = hull; CvMat c_points = points, c_hull = hull;
CvSeq* seq = cvConvexityDefects(&c_points, &c_hull, storage); CvSeq* seq = cvConvexityDefects(&c_points, &c_hull, storage);
int i, n = seq->total; int i, n = seq->total;
if( n == 0 ) if( n == 0 )
{ {
_defects.release(); _defects.release();
return; return;
} }
_defects.create(n, 1, CV_32SC4); _defects.create(n, 1, CV_32SC4);
Mat defects = _defects.getMat(); Mat defects = _defects.getMat();
SeqIterator<CvConvexityDefect> it = Seq<CvConvexityDefect>(seq).begin(); SeqIterator<CvConvexityDefect> it = Seq<CvConvexityDefect>(seq).begin();
CvPoint* ptorg = (CvPoint*)points.data; CvPoint* ptorg = (CvPoint*)points.data;
for( i = 0; i < n; i++, ++it ) for( i = 0; i < n; i++, ++it )
{ {
CvConvexityDefect& d = *it; CvConvexityDefect& d = *it;
@ -2034,9 +1924,9 @@ void cv::fitLine( InputArray _points, OutputArray _line, int distType,
CvMat _cpoints = points.reshape(2 + (int)is3d); CvMat _cpoints = points.reshape(2 + (int)is3d);
float line[6]; float line[6];
cvFitLine(&_cpoints, distType, param, reps, aeps, &line[0]); cvFitLine(&_cpoints, distType, param, reps, aeps, &line[0]);
int out_size = (is2d)?( (is3d)? (points.channels() * points.rows * 2) : 4 ): 6; int out_size = (is2d)?( (is3d)? (points.channels() * points.rows * 2) : 4 ): 6;
_line.create(out_size, 1, CV_32F, -1, true); _line.create(out_size, 1, CV_32F, -1, true);
Mat l = _line.getMat(); Mat l = _line.getMat();
CV_Assert( l.isContinuous() ); CV_Assert( l.isContinuous() );

16
modules/legacy/doc/expectation_maximization.rst
View File

@ -75,8 +75,6 @@ Estimates the Gaussian mixture parameters from a sample set.
.. ocv:function:: bool CvEM::train( const CvMat* samples, const CvMat* sampleIdx=0, CvEMParams params=CvEMParams(), CvMat* labels=0 ) .. ocv:function:: bool CvEM::train( const CvMat* samples, const CvMat* sampleIdx=0, CvEMParams params=CvEMParams(), CvMat* labels=0 )
.. ocv:pyfunction:: cv2.EM.train(samples[, sampleIdx[, params]]) -> retval, labels
:param samples: Samples from which the Gaussian mixture model will be estimated. :param samples: Samples from which the Gaussian mixture model will be estimated.
:param sample_idx: Mask of samples to use. All samples are used by default. :param sample_idx: Mask of samples to use. All samples are used by default.
@ -107,8 +105,6 @@ Returns a mixture component index of a sample.
.. ocv:function:: float CvEM::predict( const CvMat* sample, CvMat* probs ) const .. ocv:function:: float CvEM::predict( const CvMat* sample, CvMat* probs ) const
.. ocv:pyfunction:: cv2.EM.predict(sample) -> retval, probs
:param sample: A sample for classification. :param sample: A sample for classification.
:param probs: If it is not null then the method will write posterior probabilities of each component given the sample data to this parameter. :param probs: If it is not null then the method will write posterior probabilities of each component given the sample data to this parameter.
@ -122,8 +118,6 @@ Returns the number of mixture components :math:`M` in the Gaussian mixture model
.. ocv:function:: int CvEM::get_nclusters() const .. ocv:function:: int CvEM::get_nclusters() const
.. ocv:pyfunction:: cv2.EM.getNClusters() -> retval
CvEM::getMeans CvEM::getMeans
------------------ ------------------
@ -133,8 +127,6 @@ Returns mixture means :math:`a_k`.
.. ocv:function:: const CvMat* CvEM::get_means() const .. ocv:function:: const CvMat* CvEM::get_means() const
.. ocv:pyfunction:: cv2.EM.getMeans() -> means
CvEM::getCovs CvEM::getCovs
------------- -------------
@ -144,8 +136,6 @@ Returns mixture covariance matrices :math:`S_k`.
.. ocv:function:: const CvMat** CvEM::get_covs() const .. ocv:function:: const CvMat** CvEM::get_covs() const
.. ocv:pyfunction:: cv2.EM.getCovs([covs]) -> covs
CvEM::getWeights CvEM::getWeights
---------------- ----------------
@ -155,8 +145,6 @@ Returns mixture weights :math:`\pi_k`.
.. ocv:function:: const CvMat* CvEM::get_weights() const .. ocv:function:: const CvMat* CvEM::get_weights() const
.. ocv:pyfunction:: cv2.EM.getWeights() -> weights
CvEM::getProbs CvEM::getProbs
-------------- --------------
@ -166,8 +154,6 @@ Returns vectors of probabilities for each training sample.
.. ocv:function:: const CvMat* CvEM::get_probs() const .. ocv:function:: const CvMat* CvEM::get_probs() const
.. ocv:pyfunction:: cv2.EM.getProbs() -> probs
For each training sample :math:`i` (that have been passed to the constructor or to :ocv:func:`CvEM::train`) returns probabilities :math:`p_{i,k}` to belong to a mixture component :math:`k`. For each training sample :math:`i` (that have been passed to the constructor or to :ocv:func:`CvEM::train`) returns probabilities :math:`p_{i,k}` to belong to a mixture component :math:`k`.
@ -179,8 +165,6 @@ Returns logarithm of likelihood.
.. ocv:function:: double CvEM::get_log_likelihood() const .. ocv:function:: double CvEM::get_log_likelihood() const
.. ocv:pyfunction:: cv2.EM.getLikelihood() -> likelihood
CvEM::write CvEM::write
----------- -----------

62
modules/legacy/doc/feature_detection_and_description.rst
View File

@ -81,22 +81,22 @@ RandomizedTree::train
------------------------- -------------------------
Trains a randomized tree using an input set of keypoints. Trains a randomized tree using an input set of keypoints.
.. ocv:function:: void train(std::vector<BaseKeypoint> const& base_set, RNG& rng, PatchGenerator& make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits) .. ocv:function:: void RandomizedTree::train( vector<BaseKeypoint> const& base_set, RNG & rng, int depth, int views, size_t reduced_num_dim, int num_quant_bits )
.. ocv:function:: void train(std::vector<BaseKeypoint> const& base_set, RNG& rng, PatchGenerator& make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits) .. ocv:function:: void RandomizedTree::train( vector<BaseKeypoint> const& base_set, RNG & rng, PatchGenerator & make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits )
:param base_set: Vector of the ``BaseKeypoint`` type. It contains image keypoints used for training. :param base_set: Vector of the ``BaseKeypoint`` type. It contains image keypoints used for training.
:param rng: Random-number generator used for training. :param rng: Random-number generator used for training.
:param make_patch: Patch generator used for training. :param make_patch: Patch generator used for training.
:param depth: Maximum tree depth. :param depth: Maximum tree depth.
:param views: Number of random views of each keypoint neighborhood to generate. :param views: Number of random views of each keypoint neighborhood to generate.
:param reduced_num_dim: Number of dimensions used in the compressed signature. :param reduced_num_dim: Number of dimensions used in the compressed signature.
:param num_quant_bits: Number of bits used for quantization. :param num_quant_bits: Number of bits used for quantization.
@ -105,9 +105,9 @@ RandomizedTree::read
------------------------ ------------------------
Reads a pre-saved randomized tree from a file or stream. Reads a pre-saved randomized tree from a file or stream.
.. ocv:function:: read(const char* file_name, int num_quant_bits) .. ocv:function:: RandomizedTree::read(const char* file_name, int num_quant_bits)
.. ocv:function:: read(std::istream &is, int num_quant_bits) .. ocv:function:: RandomizedTree::read(std::istream &is, int num_quant_bits)
:param file_name: Name of the file that contains randomized tree data. :param file_name: Name of the file that contains randomized tree data.
@ -121,9 +121,9 @@ RandomizedTree::write
------------------------- -------------------------
Writes the current randomized tree to a file or stream. Writes the current randomized tree to a file or stream.
.. ocv:function:: void write(const char* file_name) const .. ocv:function:: void RandomizedTree::write(const char* file_name) const
.. ocv:function:: void write(std::ostream &os) const .. ocv:function:: void RandomizedTree::write(std::ostream &os) const
:param file_name: Name of the file where randomized tree data is stored. :param file_name: Name of the file where randomized tree data is stored.
@ -133,7 +133,7 @@ Writes the current randomized tree to a file or stream.
RandomizedTree::applyQuantization RandomizedTree::applyQuantization
------------------------------------- -------------------------------------
.. ocv:function:: void applyQuantization(int num_quant_bits) .. ocv:function:: void RandomizedTree::applyQuantization(int num_quant_bits)
Applies quantization to the current randomized tree. Applies quantization to the current randomized tree.
@ -240,26 +240,26 @@ RTreeClassifier::train
-------------------------- --------------------------
Trains a randomized tree classifier using an input set of keypoints. Trains a randomized tree classifier using an input set of keypoints.
.. ocv:function:: void train(vector<BaseKeypoint> const& base_set, RNG& rng, int num_trees = RTreeClassifier::DEFAULT_TREES, int depth = DEFAULT_DEPTH, int views = DEFAULT_VIEWS, size_t reduced_num_dim = DEFAULT_REDUCED_NUM_DIM, int num_quant_bits = DEFAULT_NUM_QUANT_BITS, bool print_status = true) .. ocv:function:: void RTreeClassifier::train( vector<BaseKeypoint> const& base_set, RNG & rng, int num_trees=RTreeClassifier::DEFAULT_TREES, int depth=RandomizedTree::DEFAULT_DEPTH, int views=RandomizedTree::DEFAULT_VIEWS, size_t reduced_num_dim=RandomizedTree::DEFAULT_REDUCED_NUM_DIM, int num_quant_bits=DEFAULT_NUM_QUANT_BITS )
.. ocv:function:: void train(vector<BaseKeypoint> const& base_set, RNG& rng, PatchGenerator& make_patch, int num_trees = RTreeClassifier::DEFAULT_TREES, int depth = DEFAULT_DEPTH, int views = DEFAULT_VIEWS, size_t reduced_num_dim = DEFAULT_REDUCED_NUM_DIM, int num_quant_bits = DEFAULT_NUM_QUANT_BITS, bool print_status = true) .. ocv:function:: void RTreeClassifier::train( vector<BaseKeypoint> const& base_set, RNG & rng, PatchGenerator & make_patch, int num_trees=RTreeClassifier::DEFAULT_TREES, int depth=RandomizedTree::DEFAULT_DEPTH, int views=RandomizedTree::DEFAULT_VIEWS, size_t reduced_num_dim=RandomizedTree::DEFAULT_REDUCED_NUM_DIM, int num_quant_bits=DEFAULT_NUM_QUANT_BITS )
:param base_set: Vector of the ``BaseKeypoint`` type. It contains image keypoints used for training. :param base_set: Vector of the ``BaseKeypoint`` type. It contains image keypoints used for training.
:param rng: Random-number generator used for training. :param rng: Random-number generator used for training.
:param make_patch: Patch generator used for training. :param make_patch: Patch generator used for training.
:param num_trees: Number of randomized trees used in ``RTreeClassificator`` . :param num_trees: Number of randomized trees used in ``RTreeClassificator`` .
:param depth: Maximum tree depth. :param depth: Maximum tree depth.
:param views: Number of random views of each keypoint neighborhood to generate. :param views: Number of random views of each keypoint neighborhood to generate.
:param reduced_num_dim: Number of dimensions used in the compressed signature. :param reduced_num_dim: Number of dimensions used in the compressed signature.
:param num_quant_bits: Number of bits used for quantization. :param num_quant_bits: Number of bits used for quantization.
:param print_status: Current status of training printed on the console. :param print_status: Current status of training printed on the console.
@ -268,9 +268,9 @@ RTreeClassifier::getSignature
--------------------------------- ---------------------------------
Returns a signature for an image patch. Returns a signature for an image patch.
.. ocv:function:: void getSignature(IplImage *patch, uchar *sig) .. ocv:function:: void RTreeClassifier::getSignature(IplImage *patch, uchar *sig)
.. ocv:function:: void getSignature(IplImage *patch, float *sig) .. ocv:function:: void RTreeClassifier::getSignature(IplImage *patch, float *sig)
:param patch: Image patch to calculate the signature for. :param patch: Image patch to calculate the signature for.
:param sig: Output signature (array dimension is ``reduced_num_dim)`` . :param sig: Output signature (array dimension is ``reduced_num_dim)`` .
@ -278,15 +278,15 @@ Returns a signature for an image patch.
RTreeClassifier::getSparseSignature RTreeClassifier::getSparseSignature
--------------------------------------- ---------------------------------------
Returns a sparse signature for an image patch Returns a sparse signature for an image patch
.. ocv:function:: void getSparseSignature(IplImage *patch, float *sig, float thresh) .. ocv:function:: void RTreeClassifier::getSparseSignature(IplImage *patch, float *sig, float thresh)
:param patch: Image patch to calculate the signature for. :param patch: Image patch to calculate the signature for.
:param sig: Output signature (array dimension is ``reduced_num_dim)`` . :param sig: Output signature (array dimension is ``reduced_num_dim)`` .
:param thresh: Threshold used for compressing the signature. :param thresh: Threshold used for compressing the signature.
Returns a signature for an image patch similarly to ``getSignature`` but uses a threshold for removing all signature elements below the threshold so that the signature is compressed. Returns a signature for an image patch similarly to ``getSignature`` but uses a threshold for removing all signature elements below the threshold so that the signature is compressed.
@ -296,7 +296,7 @@ RTreeClassifier::countNonZeroElements
----------------------------------------- -----------------------------------------
Returns the number of non-zero elements in an input array. Returns the number of non-zero elements in an input array.
.. ocv:function:: static int countNonZeroElements(float *vec, int n, double tol=1e-10) .. ocv:function:: static int RTreeClassifier::countNonZeroElements(float *vec, int n, double tol=1e-10)
:param vec: Input vector containing float elements. :param vec: Input vector containing float elements.
@ -310,9 +310,9 @@ RTreeClassifier::read
------------------------- -------------------------
Reads a pre-saved ``RTreeClassifier`` from a file or stream. Reads a pre-saved ``RTreeClassifier`` from a file or stream.
.. ocv:function:: read(const char* file_name) .. ocv:function:: void RTreeClassifier::read(const char* file_name)
.. ocv:function:: read(std::istream& is) .. ocv:function:: void RTreeClassifier::read( std::istream & is )
:param file_name: Name of the file that contains randomized tree data. :param file_name: Name of the file that contains randomized tree data.
@ -324,9 +324,9 @@ RTreeClassifier::write
-------------------------- --------------------------
Writes the current ``RTreeClassifier`` to a file or stream. Writes the current ``RTreeClassifier`` to a file or stream.
.. ocv:function:: void write(const char* file_name) const .. ocv:function:: void RTreeClassifier::write(const char* file_name) const
.. ocv:function:: void write(std::ostream &os) const .. ocv:function:: void RTreeClassifier::write(std::ostream &os) const
:param file_name: Name of the file where randomized tree data is stored. :param file_name: Name of the file where randomized tree data is stored.
@ -338,7 +338,7 @@ RTreeClassifier::setQuantization
------------------------------------ ------------------------------------
Applies quantization to the current randomized tree. Applies quantization to the current randomized tree.
.. ocv:function:: void setQuantization(int num_quant_bits) .. ocv:function:: void RTreeClassifier::setQuantization(int num_quant_bits)
:param num_quant_bits: Number of bits used for quantization. :param num_quant_bits: Number of bits used for quantization.

95
modules/legacy/doc/histograms.rst Normal file
View File

@ -0,0 +1,95 @@
Histograms
==========
.. highlight:: cpp
CalcPGH
-------
Calculates a pair-wise geometrical histogram for a contour.
.. ocv:cfunction:: void cvCalcPGH( const CvSeq* contour, CvHistogram* hist )
:param contour: Input contour. Currently, only integer point coordinates are allowed.
:param hist: Calculated histogram. It must be two-dimensional.
The function calculates a 2D pair-wise geometrical histogram (PGH), described in [Iivarinen97]_ for the contour. The algorithm considers every pair of contour
edges. The angle between the edges and the minimum/maximum distances
are determined for every pair. To do this, each of the edges in turn
is taken as the base, while the function loops through all the other
edges. When the base edge and any other edge are considered, the minimum
and maximum distances from the points on the non-base edge and line of
the base edge are selected. The angle between the edges defines the row
of the histogram in which all the bins that correspond to the distance
between the calculated minimum and maximum distances are incremented
(that is, the histogram is transposed relatively to the definition in the original paper). The histogram can be used for contour matching.
.. [Iivarinen97] Jukka Iivarinen, Markus Peura, Jaakko Srel, and Ari Visa. *Comparison of Combined Shape Descriptors for Irregular Objects*, 8th British Machine Vision Conference, BMVC'97. http://www.cis.hut.fi/research/IA/paper/publications/bmvc97/bmvc97.html
QueryHistValue*D
----------------
Queries the value of the histogram bin.
.. ocv:cfunction:: float cvQueryHistValue_1D(CvHistogram hist, int idx0)
.. ocv:cfunction:: float cvQueryHistValue_2D(CvHistogram hist, int idx0, int idx1)
.. ocv:cfunction:: float cvQueryHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
.. ocv:cfunction:: float cvQueryHistValue_nD(CvHistogram hist, const int* idx)
.. ocv:pyoldfunction:: cv.QueryHistValue_1D(hist, idx0) -> float
.. ocv:pyoldfunction:: cv.QueryHistValue_2D(hist, idx0, idx1) -> float
.. ocv:pyoldfunction:: cv.QueryHistValue_3D(hist, idx0, idx1, idx2) -> float
.. ocv:pyoldfunction:: cv.QueryHistValue_nD(hist, idx) -> float
:param hist: Histogram.
:param idx0: 0-th index.
:param idx1: 1-st index.
:param idx2: 2-nd index.
:param idx: Array of indices.
The macros return the value of the specified bin of the 1D, 2D, 3D, or N-D histogram. In case of a sparse histogram, the function returns 0. If the bin is not present in the histogram, no new bin is created.
GetHistValue\_?D
----------------
Returns a pointer to the histogram bin.
.. ocv:cfunction:: float cvGetHistValue_1D(CvHistogram hist, int idx0)
.. ocv:cfunction:: float cvGetHistValue_2D(CvHistogram hist, int idx0, int idx1)
.. ocv:cfunction:: float cvGetHistValue_3D(CvHistogram hist, int idx0, int idx1, int idx2)
.. ocv:cfunction:: float cvGetHistValue_nD(CvHistogram hist, int idx)
:param hist: Histogram.
:param idx0: 0-th index.
:param idx1: 1-st index.
:param idx2: 2-nd index.
:param idx: Array of indices.
::
#define cvGetHistValue_1D( hist, idx0 )
((float*)(cvPtr1D( (hist)->bins, (idx0), 0 ))
#define cvGetHistValue_2D( hist, idx0, idx1 )
((float*)(cvPtr2D( (hist)->bins, (idx0), (idx1), 0 )))
#define cvGetHistValue_3D( hist, idx0, idx1, idx2 )
((float*)(cvPtr3D( (hist)->bins, (idx0), (idx1), (idx2), 0 )))
#define cvGetHistValue_nD( hist, idx )
((float*)(cvPtrND( (hist)->bins, (idx), 0 )))
..
The macros ``GetHistValue`` return a pointer to the specified bin of the 1D, 2D, 3D, or N-D histogram. In case of a sparse histogram, the function creates a new bin and sets it to 0, unless it exists already.

1
modules/legacy/doc/legacy.rst
View File

@ -9,6 +9,7 @@ legacy. Deprecated stuff
motion_analysis motion_analysis
expectation_maximization expectation_maximization
histograms
planar_subdivisions planar_subdivisions
feature_detection_and_description feature_detection_and_description
common_interfaces_of_descriptor_extractors common_interfaces_of_descriptor_extractors

38
modules/legacy/doc/planar_subdivisions.rst
View File

@ -19,7 +19,7 @@ Planar subdivision.
CvSubdiv2DEdge recent_edge; \ CvSubdiv2DEdge recent_edge; \
CvPoint2D32f topleft; \ CvPoint2D32f topleft; \
CvPoint2D32f bottomright; CvPoint2D32f bottomright;
typedef struct CvSubdiv2D typedef struct CvSubdiv2D
{ {
CV_SUBDIV2D_FIELDS() CV_SUBDIV2D_FIELDS()
@ -64,13 +64,13 @@ Quad-edge of a planar subdivision.
/* one of edges within quad-edge, lower 2 bits is index (0..3) /* one of edges within quad-edge, lower 2 bits is index (0..3)
and upper bits are quad-edge pointer */ and upper bits are quad-edge pointer */
typedef long CvSubdiv2DEdge; typedef long CvSubdiv2DEdge;
/* quad-edge structure fields */ /* quad-edge structure fields */
#define CV_QUADEDGE2D_FIELDS() \ #define CV_QUADEDGE2D_FIELDS() \
int flags; \ int flags; \
struct CvSubdiv2DPoint* pt[4]; \ struct CvSubdiv2DPoint* pt[4]; \
CvSubdiv2DEdge next[4]; CvSubdiv2DEdge next[4];
typedef struct CvQuadEdge2D typedef struct CvQuadEdge2D
{ {
CV_QUADEDGE2D_FIELDS() CV_QUADEDGE2D_FIELDS()
@ -97,9 +97,9 @@ Point of an original or dual subdivision.
CvSubdiv2DEdge first; \ CvSubdiv2DEdge first; \
CvPoint2D32f pt; \ CvPoint2D32f pt; \
int id; int id;
#define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30) #define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30)
typedef struct CvSubdiv2DPoint typedef struct CvSubdiv2DPoint
{ {
CV_SUBDIV2D_POINT_FIELDS() CV_SUBDIV2D_POINT_FIELDS()
@ -135,7 +135,7 @@ Removes all virtual points.
:param subdiv: Delaunay subdivision. :param subdiv: Delaunay subdivision.
The function removes all of the virtual points. It The function removes all of the virtual points. It
is called internally in is called internally in
:ocv:cfunc:`CalcSubdivVoronoi2D` :ocv:cfunc:`CalcSubdivVoronoi2D`
if the subdivision if the subdivision
was modified after the previous call to the function. was modified after the previous call to the function.
@ -145,7 +145,7 @@ CreateSubdivDelaunay2D
Creates an empty Delaunay triangulation. Creates an empty Delaunay triangulation.
.. ocv:cfunction:: CvSubdiv2D* cvCreateSubdivDelaunay2D( CvRect rect, CvMemStorage* storage ) .. ocv:cfunction:: CvSubdiv2D* cvCreateSubdivDelaunay2D( CvRect rect, CvMemStorage* storage )
.. ocv:pyoldfunction:: cv.CreateSubdivDelaunay2D(rect, storage)-> emptyDelaunayTriangulation .. ocv:pyoldfunction:: cv.CreateSubdivDelaunay2D(rect, storage) -> CvSubdiv2D
:param rect: Rectangle that includes all of the 2D points that are to be added to the subdivision. :param rect: Rectangle that includes all of the 2D points that are to be added to the subdivision.
@ -157,7 +157,7 @@ subdivision where 2D points can be added using the function
. All of the points to be added must be within . All of the points to be added must be within
the specified rectangle, otherwise a runtime error is raised. the specified rectangle, otherwise a runtime error is raised.
Note that the triangulation is a single large triangle that covers the given rectangle. Hence the three vertices of this triangle are outside the rectangle Note that the triangulation is a single large triangle that covers the given rectangle. Hence the three vertices of this triangle are outside the rectangle
``rect`` ``rect``
. .
@ -192,7 +192,7 @@ Returns the edge destination.
The function returns the edge destination. The The function returns the edge destination. The
returned pointer may be NULL if the edge is from a dual subdivision and returned pointer may be NULL if the edge is from a dual subdivision and
the virtual point coordinates are not calculated yet. The virtual points the virtual point coordinates are not calculated yet. The virtual points
can be calculated using the function can be calculated using the function
:ocv:cfunc:`CalcSubdivVoronoi2D`. :ocv:cfunc:`CalcSubdivVoronoi2D`.
Subdiv2DGetEdge Subdiv2DGetEdge
@ -235,9 +235,9 @@ Returns next edge around the edge origin.
:param edge: Subdivision edge (not a quad-edge). :param edge: Subdivision edge (not a quad-edge).
The function returns the next edge around the edge origin: The function returns the next edge around the edge origin:
``eOnext`` ``eOnext``
on the picture above if on the picture above if
``e`` ``e``
is the input edge). is the input edge).
@ -259,33 +259,33 @@ Returns the location of a point within a Delaunay triangulation.
The function locates the input point within the subdivision. There are five cases: The function locates the input point within the subdivision. There are five cases:
* *
The point falls into some facet. The function returns The point falls into some facet. The function returns
``CV_PTLOC_INSIDE`` ``CV_PTLOC_INSIDE``
and and
``*edge`` ``*edge``
will contain one of edges of the facet. will contain one of edges of the facet.
* *
The point falls onto the edge. The function returns The point falls onto the edge. The function returns
``CV_PTLOC_ON_EDGE`` ``CV_PTLOC_ON_EDGE``
and and
``*edge`` ``*edge``
will contain this edge. will contain this edge.
* *
The point coincides with one of the subdivision vertices. The function returns The point coincides with one of the subdivision vertices. The function returns
``CV_PTLOC_VERTEX`` ``CV_PTLOC_VERTEX``
and and
``*vertex`` ``*vertex``
will contain a pointer to the vertex. will contain a pointer to the vertex.
* *
The point is outside the subdivision reference rectangle. The function returns The point is outside the subdivision reference rectangle. The function returns
``CV_PTLOC_OUTSIDE_RECT`` ``CV_PTLOC_OUTSIDE_RECT``
and no pointers are filled. and no pointers are filled.
* *
One of input arguments is invalid. A runtime error is raised or, if silent or "parent" error processing mode is selected, One of input arguments is invalid. A runtime error is raised or, if silent or "parent" error processing mode is selected,
``CV_PTLOC_ERROR`` ``CV_PTLOC_ERROR``
is returnd. is returnd.

2
modules/ml/doc/expectation_maximization.rst
View File

@ -173,7 +173,7 @@ EM::predict
----------- -----------
Returns a likelihood logarithm value and an index of the most probable mixture component for the given sample. Returns a likelihood logarithm value and an index of the most probable mixture component for the given sample.
.. ocv:function:: Vec2d predict(InputArray sample, OutputArray probs=noArray()) const .. ocv:function:: Vec2d EM::predict(InputArray sample, OutputArray probs=noArray()) const
.. ocv:pyfunction:: cv2.EM.predict(sample[, probs]) -> retval, probs .. ocv:pyfunction:: cv2.EM.predict(sample[, probs]) -> retval, probs

2
modules/objdetect/doc/cascade_classification.rst
View File

@ -239,7 +239,7 @@ CascadeClassifier::runAt
---------------------------- ----------------------------
Runs the detector at the specified point. Runs the detector at the specified point.
.. ocv:function:: int CascadeClassifier::runAt( Ptr<FeatureEvaluator>& feval, Point pt ) .. ocv:function:: int CascadeClassifier::runAt( Ptr<FeatureEvaluator>& feval, Point pt, double& weight )
.. ocv:cfunction:: int cvRunHaarClassifierCascade( const CvHaarClassifierCascade* cascade, CvPoint pt, int start_stage=0 ) .. ocv:cfunction:: int cvRunHaarClassifierCascade( const CvHaarClassifierCascade* cascade, CvPoint pt, int start_stage=0 )

2
modules/objdetect/doc/latent_svm.rst
View File

@ -256,7 +256,7 @@ LatentSvmDetector::getClassCount
-------------------------------- --------------------------------
Return a count of loaded models (classes). Return a count of loaded models (classes).
.. ocv:function:: size_t getClassCount() const .. ocv:function:: size_t LatentSvmDetector::getClassCount() const
.. [Felzenszwalb2010] Felzenszwalb, P. F. and Girshick, R. B. and McAllester, D. and Ramanan, D. *Object Detection with Discriminatively Trained Part Based Models*. PAMI, vol. 32, no. 9, pp. 1627-1645, September 2010 .. [Felzenszwalb2010] Felzenszwalb, P. F. and Girshick, R. B. and McAllester, D. and Ramanan, D. *Object Detection with Discriminatively Trained Part Based Models*. PAMI, vol. 32, no. 9, pp. 1627-1645, September 2010

4
modules/objdetect/include/opencv2/objdetect/objdetect.hpp
View File

@ -425,8 +425,8 @@ protected:
template<class FEval> template<class FEval>
friend int predictCategoricalStump( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &featureEvaluator, double& weight); friend int predictCategoricalStump( CascadeClassifier& cascade, Ptr<FeatureEvaluator> &featureEvaluator, double& weight);
bool setImage( Ptr<FeatureEvaluator>&, const Mat& ); bool setImage( Ptr<FeatureEvaluator>& feval, const Mat& image);
virtual int runAt( Ptr<FeatureEvaluator>&, Point, double& weight ); virtual int runAt( Ptr<FeatureEvaluator>& feval, Point pt, double& weight );
class Data class Data
{ {

4
modules/python/src2/hdr_parser.py
View File

@ -281,7 +281,7 @@ class CppHeaderParser(object):
apos = fdecl.find("(") apos = fdecl.find("(")
if fname.endswith("operator"): if fname.endswith("operator"):
fname += "()" fname += " ()"
apos = fdecl.find("(", apos+1) apos = fdecl.find("(", apos+1)
fname = "cv." + fname.replace("::", ".") fname = "cv." + fname.replace("::", ".")
@ -600,7 +600,7 @@ class CppHeaderParser(object):
break break
w = stmt[:colon_pos].strip() w = stmt[:colon_pos].strip()
if w in ["public", "protected", "private"]: if w in ["public", "protected", "private"]:
if w == "public": if w == "public" or (not self.wrap_mode and w == "protected"):
stack_top[self.PUBLIC_SECTION] = True stack_top[self.PUBLIC_SECTION] = True
else: else:
stack_top[self.PUBLIC_SECTION] = False stack_top[self.PUBLIC_SECTION] = False

6
modules/stitching/doc/autocalib.rst
View File

@ -7,13 +7,13 @@ detail::focalsFromHomography
---------------------------- ----------------------------
Tries to estimate focal lengths from the given homography under the assumption that the camera undergoes rotations around its centre only. Tries to estimate focal lengths from the given homography under the assumption that the camera undergoes rotations around its centre only.
.. ocv:function:: void focalsFromHomography(const Mat &H, double &f0, double &f1, bool &f0_ok, bool &f1_ok) .. ocv:function:: void detail::focalsFromHomography(const Mat &H, double &f0, double &f1, bool &f0_ok, bool &f1_ok)
:param H: Homography. :param H: Homography.
:param f0: Estimated focal length along X axis. :param f0: Estimated focal length along X axis.
:param f1: Estimated focal length along Y axis. :param f1: Estimated focal length along Y axis.
:param f0_ok: True, if f0 was estimated successfully, false otherwise. :param f0_ok: True, if f0 was estimated successfully, false otherwise.
@ -23,7 +23,7 @@ detail::estimateFocal
--------------------- ---------------------
Estimates focal lengths for each given camera. Estimates focal lengths for each given camera.
.. ocv:function:: void estimateFocal(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches, std::vector<double> &focals) .. ocv:function:: void detail::estimateFocal(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches, std::vector<double> &focals)
:param features: Features of images. :param features: Features of images.

4
modules/stitching/doc/matching.rst
View File

@ -64,7 +64,7 @@ detail::FeaturesFinder::find
This method must implement features finding logic in order to make the wrappers `detail::FeaturesFinder::operator()`_ work. This method must implement features finding logic in order to make the wrappers `detail::FeaturesFinder::operator()`_ work.
.. ocv:function:: void find(const Mat &image, ImageFeatures &features) .. ocv:function:: void detail::FeaturesFinder::find(const Mat &image, ImageFeatures &features)
:param image: Source image :param image: Source image
@ -171,7 +171,7 @@ Performs images matching.
:param matches_info: Found matches :param matches_info: Found matches
.. ocv:function:: void detail::FeaturesMatcher::operator ()(const std::vector<ImageFeatures> &features, std::vector<MatchesInfo> &pairwise_matches, const Mat &mask) .. ocv:function:: void detail::FeaturesMatcher::operator ()( const std::vector<ImageFeatures> & features, std::vector<MatchesInfo> & pairwise_matches, const Mat & mask=Mat() )
:param features: Features of the source images :param features: Features of the source images

30
modules/stitching/doc/motion_estimation.rst
View File

@ -7,9 +7,9 @@ detail::Estimator
----------------- -----------------
.. ocv:class:: detail::Estimator .. ocv:class:: detail::Estimator
Rotation estimator base class. It takes features of all images, pairwise matches between all images and estimates rotations of all cameras. Rotation estimator base class. It takes features of all images, pairwise matches between all images and estimates rotations of all cameras.
.. note:: The coordinate system origin is implementation-dependent, but you can always normalize the rotations in respect to the first camera, for instance. .. note:: The coordinate system origin is implementation-dependent, but you can always normalize the rotations in respect to the first camera, for instance.
:: ::
@ -18,12 +18,12 @@ Rotation estimator base class. It takes features of all images, pairwise matches
public: public:
virtual ~Estimator() {} virtual ~Estimator() {}
void operator ()(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches, void operator ()(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches,
std::vector<CameraParams> &cameras) std::vector<CameraParams> &cameras)
{ estimate(features, pairwise_matches, cameras); } { estimate(features, pairwise_matches, cameras); }
protected: protected:
virtual void estimate(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches, virtual void estimate(const std::vector<ImageFeatures> &features, const std::vector<MatchesInfo> &pairwise_matches,
std::vector<CameraParams> &cameras) = 0; std::vector<CameraParams> &cameras) = 0;
}; };
@ -79,10 +79,10 @@ Base class for all camera parameters refinement methods. ::
{ {
public: public:
const Mat refinementMask() const { return refinement_mask_.clone(); } const Mat refinementMask() const { return refinement_mask_.clone(); }
void setRefinementMask(const Mat &mask) void setRefinementMask(const Mat &mask)
{ {
CV_Assert(mask.type() == CV_8U && mask.size() == Size(3, 3)); CV_Assert(mask.type() == CV_8U && mask.size() == Size(3, 3));
refinement_mask_ = mask.clone(); refinement_mask_ = mask.clone();
} }
double confThresh() const { return conf_thresh_; } double confThresh() const { return conf_thresh_; }
@ -92,17 +92,17 @@ Base class for all camera parameters refinement methods. ::
void setTermCriteria(const CvTermCriteria& term_criteria) { term_criteria_ = term_criteria; } void setTermCriteria(const CvTermCriteria& term_criteria) { term_criteria_ = term_criteria; }
protected: protected:
BundleAdjusterBase(int num_params_per_cam, int num_errs_per_measurement) BundleAdjusterBase(int num_params_per_cam, int num_errs_per_measurement)
: num_params_per_cam_(num_params_per_cam), : num_params_per_cam_(num_params_per_cam),
num_errs_per_measurement_(num_errs_per_measurement) num_errs_per_measurement_(num_errs_per_measurement)
{ {
setRefinementMask(Mat::ones(3, 3, CV_8U)); setRefinementMask(Mat::ones(3, 3, CV_8U));
setConfThresh(1.); setConfThresh(1.);
setTermCriteria(cvTermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 1000, DBL_EPSILON)); setTermCriteria(cvTermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 1000, DBL_EPSILON));
} }
// Runs bundle adjustment // Runs bundle adjustment
virtual void estimate(const std::vector<ImageFeatures> &features, virtual void estimate(const std::vector<ImageFeatures> &features,
const std::vector<MatchesInfo> &pairwise_matches, const std::vector<MatchesInfo> &pairwise_matches,
std::vector<CameraParams> &cameras); std::vector<CameraParams> &cameras);
@ -146,7 +146,7 @@ Construct a bundle adjuster base instance.
.. ocv:function:: detail::BundleAdjusterBase::BundleAdjusterBase(int num_params_per_cam, int num_errs_per_measurement) .. ocv:function:: detail::BundleAdjusterBase::BundleAdjusterBase(int num_params_per_cam, int num_errs_per_measurement)
:param num_params_per_cam: Number of parameters per camera :param num_params_per_cam: Number of parameters per camera
:param num_errs_per_measurement: Number of error terms (components) per match :param num_errs_per_measurement: Number of error terms (components) per match
detail::BundleAdjusterBase::setUpInitialCameraParams detail::BundleAdjusterBase::setUpInitialCameraParams
@ -234,7 +234,7 @@ detail::waveCorrect
------------------- -------------------
Tries to make panorama more horizontal (or vertical). Tries to make panorama more horizontal (or vertical).
.. ocv:function:: void waveCorrect(std::vector<Mat> &rmats, WaveCorrectKind kind) .. ocv:function:: void detail::waveCorrect(std::vector<Mat> &rmats, WaveCorrectKind kind)
:param rmats: Camera rotation matrices. :param rmats: Camera rotation matrices.

2
modules/stitching/doc/warpers.rst
View File

@ -66,7 +66,7 @@ detail::RotationWarper::warp
Projects the image. Projects the image.
.. ocv:function:: Point detal::RotationWarper::warp(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode, Mat &dst) .. ocv:function:: Point detail::RotationWarper::warp(const Mat &src, const Mat &K, const Mat &R, int interp_mode, int border_mode, Mat &dst)
:param src: Source image :param src: Source image