From 8d8ef596c855981e238e9199ffe61df30c315040 Mon Sep 17 00:00:00 2001 From: Vadim Pisarevsky Date: Thu, 16 Jun 2011 12:48:23 +0000 Subject: [PATCH] introduced new RST/Sphinx domain ocv. --- doc/conf.py | 4 +- doc/ocv.py | 1132 ++++++++++++++++++++ .../camera_calibration_and_3d_reconstruction.rst | 64 +- modules/core/doc/basic_structures.rst | 336 +++--- modules/core/doc/clustering.rst | 6 +- modules/core/doc/drawing_functions.rst | 64 +- modules/core/doc/operations_on_arrays.rst | 778 +++++++------- .../utility_and_system_functions_and_macros.rst | 64 +- .../common_interfaces_of_descriptor_extractors.rst | 24 +- .../common_interfaces_of_descriptor_matchers.rst | 34 +- .../doc/common_interfaces_of_feature_detectors.rst | 56 +- ...n_interfaces_of_generic_descriptor_matchers.rst | 46 +- .../drawing_function_of_keypoints_and_matches.rst | 6 +- .../doc/feature_detection_and_description.rst | 54 +- modules/features2d/doc/object_categorization.rst | 28 +- .../camera_calibration_and_3d_reconstruction.rst | 68 +- modules/gpu/doc/data_structures.rst | 54 +- .../gpu/doc/feature_detection_and_description.rst | 56 +- modules/gpu/doc/image_filtering.rst | 150 +-- modules/gpu/doc/image_processing.rst | 120 +-- modules/gpu/doc/initalization_and_information.rst | 52 +- modules/gpu/doc/introduction.rst | 12 +- modules/gpu/doc/matrix_reductions.rst | 44 +- modules/gpu/doc/object_detection.rst | 44 +- modules/gpu/doc/operations_on_matrices.rst | 64 +- modules/gpu/doc/per_element_operations.rst | 80 +- modules/highgui/doc/qt_new_functions.rst | 20 +- .../doc/reading_and_writing_images_and_video.rst | 18 +- modules/highgui/doc/user_interface.rst | 12 +- modules/imgproc/doc/feature_detection.rst | 88 +- modules/imgproc/doc/filtering.rst | 450 ++++---- modules/imgproc/doc/geometric_transformations.rst | 106 +- modules/imgproc/doc/histograms.rst | 24 +- .../imgproc/doc/miscellaneous_transformations.rst | 56 +- .../doc/motion_analysis_and_object_tracking.rst | 32 +- modules/imgproc/doc/object_detection.rst | 4 +- .../structural_analysis_and_shape_descriptors.rst | 54 +- modules/ml/doc/boosting.rst | 12 +- modules/ml/doc/decision_trees.rst | 6 +- modules/ml/doc/expectation_maximization.rst | 2 +- modules/ml/doc/k_nearest_neighbors.rst | 4 +- modules/ml/doc/neural_networks.rst | 4 +- modules/ml/doc/normal_bayes_classifier.rst | 4 +- modules/ml/doc/random_trees.rst | 8 +- modules/ml/doc/statistical_models.rst | 20 +- modules/ml/doc/support_vector_machines.rst | 12 +- modules/objdetect/doc/cascade_classification.rst | 32 +- .../doc/motion_analysis_and_object_tracking.rst | 106 +- 48 files changed, 2823 insertions(+), 1691 deletions(-) create mode 100644 doc/ocv.py diff --git a/doc/conf.py b/doc/conf.py index c2d1263..40f1d4a 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -16,7 +16,7 @@ import sys, os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. -#sys.path.insert(0, os.path.abspath('.')) +sys.path.insert(0, os.path.abspath('.')) # -- General configuration ----------------------------------------------------- @@ -25,7 +25,7 @@ import sys, os # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. -extensions = ['sphinx.ext.pngmath', 'sphinx.ext.ifconfig', 'sphinx.ext.todo', 'sphinx.ext.extlinks'] +extensions = ['sphinx.ext.pngmath', 'sphinx.ext.ifconfig', 'sphinx.ext.todo', 'sphinx.ext.extlinks', 'ocv'] doctest_test_doctest_blocks = 'block' # Add any paths that contain templates here, relative to this directory. diff --git a/doc/ocv.py b/doc/ocv.py new file mode 100644 index 0000000..5ec355a --- /dev/null +++ b/doc/ocv.py @@ -0,0 +1,1132 @@ +# -*- coding: utf-8 -*- +""" + ocv domain, a modified copy of sphinx.domains.cpp. The original copyright is below + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + The C++ language domain. + + :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. + :license: BSD, see LICENSE for details. +""" + +import re +from copy import deepcopy + +from docutils import nodes + +from sphinx import addnodes +from sphinx.roles import XRefRole +from sphinx.locale import l_, _ +from sphinx.domains import Domain, ObjType +from sphinx.directives import ObjectDescription +from sphinx.util.nodes import make_refnode +from sphinx.util.compat import Directive +from sphinx.util.docfields import Field, TypedField + +_identifier_re = re.compile(r'(~?\b[a-zA-Z_][a-zA-Z0-9_]*)\b') +_whitespace_re = re.compile(r'\s+(?u)') +_string_re = re.compile(r"[LuU8]?('([^'\\]*(?:\\.[^'\\]*)*)'" + r'|"([^"\\]*(?:\\.[^"\\]*)*)")', re.S) +_visibility_re = re.compile(r'\b(public|private|protected)\b') +_operator_re = re.compile(r'''(?x) + \[\s*\] + | \(\s*\) + | [!<>=/*%+|&^-]=? + | \+\+ | -- + | (<<|>>)=? | ~ | && | \| | \|\| + | ->\*? | \, +''') + +_id_shortwords = { + 'char': 'c', + 'signed char': 'c', + 'unsigned char': 'C', + 'int': 'i', + 'signed int': 'i', + 'unsigned int': 'U', + 'long': 'l', + 'signed long': 'l', + 'unsigned long': 'L', + 'bool': 'b', + 'size_t': 's', + 'std::string': 'ss', + 'std::ostream': 'os', + 'std::istream': 'is', + 'std::iostream': 'ios', + 'std::vector': 'v', + 'std::map': 'm', + 'operator[]': 'subscript-operator', + 'operator()': 'call-operator', + 'operator!': 'not-operator', + 'operator<': 'lt-operator', + 'operator<=': 'lte-operator', + 'operator>': 'gt-operator', + 'operator>=': 'gte-operator', + 'operator=': 'assign-operator', + 'operator/': 'div-operator', + 'operator*': 'mul-operator', + 'operator%': 'mod-operator', + 'operator+': 'add-operator', + 'operator-': 'sub-operator', + 'operator|': 'or-operator', + 'operator&': 'and-operator', + 'operator^': 'xor-operator', + 'operator&&': 'sand-operator', + 'operator||': 'sor-operator', + 'operator==': 'eq-operator', + 'operator!=': 'neq-operator', + 'operator<<': 'lshift-operator', + 'operator>>': 'rshift-operator', + 'operator-=': 'sub-assign-operator', + 'operator+=': 'add-assign-operator', + 'operator*-': 'mul-assign-operator', + 'operator/=': 'div-assign-operator', + 'operator%=': 'mod-assign-operator', + 'operator&=': 'and-assign-operator', + 'operator|=': 'or-assign-operator', + 'operator<<=': 'lshift-assign-operator', + 'operator>>=': 'rshift-assign-operator', + 'operator^=': 'xor-assign-operator', + 'operator,': 'comma-operator', + 'operator->': 'pointer-operator', + 'operator->*': 'pointer-by-pointer-operator', + 'operator~': 'inv-operator', + 'operator++': 'inc-operator', + 'operator--': 'dec-operator', + 'operator new': 'new-operator', + 'operator new[]': 'new-array-operator', + 'operator delete': 'delete-operator', + 'operator delete[]': 'delete-array-operator' +} + + +class DefinitionError(Exception): + + def __init__(self, description): + self.description = description + + def __unicode__(self): + return self.description + + def __str__(self): + return unicode(self.encode('utf-8')) + + +class DefExpr(object): + + def __unicode__(self): + raise NotImplementedError() + + def __eq__(self, other): + if type(self) is not type(other): + return False + try: + for key, value in self.__dict__.iteritems(): + if value != getattr(other, value): + return False + except AttributeError: + return False + return True + + def __ne__(self, other): + return not self.__eq__(other) + + def clone(self): + """Close a definition expression node""" + return deepcopy(self) + + def get_id(self): + """Returns the id for the node""" + return u'' + + def get_name(self): + """Returns the name. Returns either `None` or a node with + a name you might call :meth:`split_owner` on. + """ + return None + + def split_owner(self): + """Nodes returned by :meth:`get_name` can split off their + owning parent. This function returns the owner and the + name as a tuple of two items. If a node does not support + it, it returns None as owner and self as name. + """ + return None, self + + def prefix(self, prefix): + """Prefixes a name node (a node returned by :meth:`get_name`).""" + raise NotImplementedError() + + def __str__(self): + return unicode(self).encode('utf-8') + + def __repr__(self): + return '<%s %s>' % (self.__class__.__name__, self) + + +class PrimaryDefExpr(DefExpr): + + def get_name(self): + return self + + def prefix(self, prefix): + if isinstance(prefix, PathDefExpr): + prefix = prefix.clone() + prefix.path.append(self) + return prefix + return PathDefExpr([prefix, self]) + + +class NameDefExpr(PrimaryDefExpr): + + def __init__(self, name): + self.name = name + + def get_id(self): + name = _id_shortwords.get(self.name) + if name is not None: + return name + return self.name.replace(u' ', u'-') + + def __unicode__(self): + return unicode(self.name) + + +class PathDefExpr(PrimaryDefExpr): + + def __init__(self, parts): + self.path = parts + + def get_id(self): + rv = u'::'.join(x.get_id() for x in self.path) + return _id_shortwords.get(rv, rv) + + def split_owner(self): + if len(self.path) > 1: + return PathDefExpr(self.path[:-1]), self.path[-1] + return None, self + + def prefix(self, prefix): + if isinstance(prefix, PathDefExpr): + prefix = prefix.clone() + prefix.path.extend(self.path) + return prefix + return PathDefExpr([prefix] + self.path) + + def __unicode__(self): + return u'::'.join(map(unicode, self.path)) + + +class TemplateDefExpr(PrimaryDefExpr): + + def __init__(self, typename, args): + self.typename = typename + self.args = args + + def split_owner(self): + owner, typename = self.typename.split_owner() + return owner, TemplateDefExpr(typename, self.args) + + def get_id(self): + return u'%s:%s:' % (self.typename.get_id(), + u'.'.join(x.get_id() for x in self.args)) + + def __unicode__(self): + return u'%s<%s>' % (self.typename, u', '.join(map(unicode, self.args))) + + +class WrappingDefExpr(DefExpr): + + def __init__(self, typename): + self.typename = typename + + def get_name(self): + return self.typename.get_name() + + +class ModifierDefExpr(WrappingDefExpr): + + def __init__(self, typename, modifiers): + WrappingDefExpr.__init__(self, typename) + self.modifiers = modifiers + + def get_id(self): + pieces = [_id_shortwords.get(unicode(x), unicode(x)) + for x in self.modifiers] + pieces.append(self.typename.get_id()) + return u'-'.join(pieces) + + def __unicode__(self): + return u' '.join(map(unicode, list(self.modifiers) + [self.typename])) + + +class PtrDefExpr(WrappingDefExpr): + + def get_id(self): + return self.typename.get_id() + u'P' + + def __unicode__(self): + return u'%s*' % self.typename + + +class RefDefExpr(WrappingDefExpr): + + def get_id(self): + return self.typename.get_id() + u'R' + + def __unicode__(self): + return u'%s&' % self.typename + + +class ConstDefExpr(WrappingDefExpr): + + def __init__(self, typename, prefix=False): + WrappingDefExpr.__init__(self, typename) + self.prefix = prefix + + def get_id(self): + return self.typename.get_id() + u'C' + + def __unicode__(self): + return (self.prefix and u'const %s' or u'%s const') % self.typename + + +class CastOpDefExpr(PrimaryDefExpr): + + def __init__(self, typename): + self.typename = typename + + def get_id(self): + return u'castto-%s-operator' % self.typename.get_id() + + def __unicode__(self): + return u'operator %s' % self.typename + + +class ArgumentDefExpr(DefExpr): + + def __init__(self, type, name, default=None): + self.name = name + self.type = type + self.default = default + + def get_name(self): + return self.name.get_name() + + def get_id(self): + if self.type is None: + return 'X' + return self.type.get_id() + + def __unicode__(self): + return (u'%s %s' % (self.type or u'', self.name or u'')).strip() + \ + (self.default is not None and u'=%s' % self.default or u'') + + +class NamedDefExpr(DefExpr): + + def __init__(self, name, visibility, static): + self.name = name + self.visibility = visibility + self.static = static + + def get_name(self): + return self.name.get_name() + + def get_modifiers(self): + rv = [] + if self.visibility != 'public': + rv.append(self.visibility) + if self.static: + rv.append(u'static') + return rv + + +class TypeObjDefExpr(NamedDefExpr): + + def __init__(self, name, visibility, static, typename): + NamedDefExpr.__init__(self, name, visibility, static) + self.typename = typename + + def get_id(self): + if self.typename is None: + return self.name.get_id() + return u'%s__%s' % (self.name.get_id(), self.typename.get_id()) + + def __unicode__(self): + buf = self.get_modifiers() + if self.typename is None: + buf.append(unicode(self.name)) + else: + buf.extend(map(unicode, (self.typename, self.name))) + return u' '.join(buf) + + +class MemberObjDefExpr(NamedDefExpr): + + def __init__(self, name, visibility, static, typename, value): + NamedDefExpr.__init__(self, name, visibility, static) + self.typename = typename + self.value = value + + def get_id(self): + return u'%s__%s' % (self.name.get_id(), self.typename.get_id()) + + def __unicode__(self): + buf = self.get_modifiers() + buf.append(u'%s %s' % (self.typename, self.name)) + if self.value is not None: + buf.append(u'= %s' % self.value) + return u' '.join(buf) + + +class FuncDefExpr(NamedDefExpr): + + def __init__(self, name, visibility, static, explicit, rv, + signature, const, pure_virtual): + NamedDefExpr.__init__(self, name, visibility, static) + self.rv = rv + self.signature = signature + self.explicit = explicit + self.const = const + self.pure_virtual = pure_virtual + + def get_id(self): + return u'%s%s%s' % ( + self.name.get_id(), + self.signature and u'__' + + u'.'.join(x.get_id() for x in self.signature) or u'', + self.const and u'C' or u'' + ) + + def __unicode__(self): + buf = self.get_modifiers() + if self.explicit: + buf.append(u'explicit') + if self.rv is not None: + buf.append(unicode(self.rv)) + buf.append(u'%s(%s)' % (self.name, u', '.join( + map(unicode, self.signature)))) + if self.const: + buf.append(u'const') + if self.pure_virtual: + buf.append(u'= 0') + return u' '.join(buf) + + +class ClassDefExpr(NamedDefExpr): + + def __init__(self, name, visibility, static): + NamedDefExpr.__init__(self, name, visibility, static) + + def get_id(self): + return self.name.get_id() + + def __unicode__(self): + buf = self.get_modifiers() + buf.append(unicode(self.name)) + return u' '.join(buf) + + +class DefinitionParser(object): + + # mapping of valid type modifiers. if the set is None it means + # the modifier can prefix all types, otherwise only the types + # (actually more keywords) in the set. Also check + # _guess_typename when changing this. + _modifiers = { + 'volatile': None, + 'register': None, + 'mutable': None, + 'const': None, + 'typename': None, + 'unsigned': set(('char', 'short', 'int', 'long')), + 'signed': set(('char', 'short', 'int', 'long')), + 'short': set(('int',)), + 'long': set(('int', 'long', 'double')) + } + + def __init__(self, definition): + self.definition = definition.strip() + self.pos = 0 + self.end = len(self.definition) + self.last_match = None + self._previous_state = (0, None) + + def fail(self, msg): + raise DefinitionError('Invalid definition: %s [error at %d]\n %s' % + (msg, self.pos, self.definition)) + + def match(self, regex): + match = regex.match(self.definition, self.pos) + if match is not None: + self._previous_state = (self.pos, self.last_match) + self.pos = match.end() + self.last_match = match + return True + return False + + def backout(self): + self.pos, self.last_match = self._previous_state + + def skip_string(self, string): + strlen = len(string) + if self.definition[self.pos:self.pos + strlen] == string: + self.pos += strlen + return True + return False + + def skip_word(self, word): + return self.match(re.compile(r'\b%s\b' % re.escape(word))) + + def skip_ws(self): + return self.match(_whitespace_re) + + @property + def eof(self): + return self.pos >= self.end + + @property + def current_char(self): + try: + return self.definition[self.pos] + except IndexError: + return 'EOF' + + @property + def matched_text(self): + if self.last_match is not None: + return self.last_match.group() + + def _parse_operator(self): + self.skip_ws() + # thank god, a regular operator definition + if self.match(_operator_re): + return NameDefExpr('operator' + + _whitespace_re.sub('', self.matched_text)) + + # new/delete operator? + for allocop in 'new', 'delete': + if not self.skip_word(allocop): + continue + self.skip_ws() + if self.skip_string('['): + self.skip_ws() + if not self.skip_string(']'): + self.fail('expected "]" for ' + allocop) + allocop += '[]' + return NameDefExpr('operator ' + allocop) + + # oh well, looks like a cast operator definition. + # In that case, eat another type. + type = self._parse_type() + return CastOpDefExpr(type) + + def _parse_name(self): + if not self.match(_identifier_re): + self.fail('expected name') + identifier = self.matched_text + + # strictly speaking, operators are not regular identifiers + # but because operator is a keyword, it might not be used + # for variable names anyways, so we can safely parse the + # operator here as identifier + if identifier == 'operator': + return self._parse_operator() + + return NameDefExpr(identifier) + + def _guess_typename(self, path): + if not path: + return [], 'int' + # for the long type, we don't want the int in there + if 'long' in path: + path = [x for x in path if x != 'int'] + # remove one long + path.remove('long') + return path, 'long' + if path[-1] in ('int', 'char'): + return path[:-1], path[-1] + return path, 'int' + + def _attach_crefptr(self, expr, is_const=False): + if is_const: + expr = ConstDefExpr(expr, prefix=True) + while 1: + self.skip_ws() + if self.skip_word('const'): + expr = ConstDefExpr(expr) + elif self.skip_string('*'): + expr = PtrDefExpr(expr) + elif self.skip_string('&'): + expr = RefDefExpr(expr) + else: + return expr + + def _peek_const(self, path): + try: + path.remove('const') + return True + except ValueError: + return False + + def _parse_builtin(self, modifier): + path = [modifier] + following = self._modifiers[modifier] + while 1: + self.skip_ws() + if not self.match(_identifier_re): + break + identifier = self.matched_text + if identifier in following: + path.append(identifier) + following = self._modifiers[modifier] + assert following + else: + self.backout() + break + + is_const = self._peek_const(path) + modifiers, typename = self._guess_typename(path) + rv = ModifierDefExpr(NameDefExpr(typename), modifiers) + return self._attach_crefptr(rv, is_const) + + def _parse_type_expr(self): + typename = self._parse_name() + self.skip_ws() + if not self.skip_string('<'): + return typename + + args = [] + while 1: + self.skip_ws() + if self.skip_string('>'): + break + if args: + if not self.skip_string(','): + self.fail('"," or ">" in template expected') + self.skip_ws() + args.append(self._parse_type(True)) + return TemplateDefExpr(typename, args) + + def _parse_type(self, in_template=False): + self.skip_ws() + result = [] + modifiers = [] + + if self.match(re.compile(r'template\w*<([^>]*)>')): + args = self.last_match.group(1).split(',') + args = [a.strip() for a in args] + modifiers.append(TemplateDefExpr('template', args)) + + # if there is a leading :: or not, we don't care because we + # treat them exactly the same. Buf *if* there is one, we + # don't have to check for type modifiers + if not self.skip_string('::'): + self.skip_ws() + while self.match(_identifier_re): + modifier = self.matched_text + if modifier in self._modifiers: + following = self._modifiers[modifier] + # if the set is not none, there is a limited set + # of types that might follow. It is technically + # impossible for a template to follow, so what + # we do is go to a different function that just + # eats types + if following is not None: + return self._parse_builtin(modifier) + modifiers.append(modifier) + else: + self.backout() + break + + while 1: + self.skip_ws() + if (in_template and self.current_char in ',>') or \ + (result and not self.skip_string('::')) or \ + self.eof: + break + result.append(self._parse_type_expr()) + + if not result: + self.fail('expected type') + if len(result) == 1: + rv = result[0] + else: + rv = PathDefExpr(result) + is_const = self._peek_const(modifiers) + if modifiers: + rv = ModifierDefExpr(rv, modifiers) + return self._attach_crefptr(rv, is_const) + + def _parse_default_expr(self): + self.skip_ws() + if self.match(_string_re): + return self.matched_text + paren_stack_depth = 0 + max_pos = len(self.definition) + rv_start = self.pos + while 1: + idx0 = self.definition.find('(', self.pos) + idx1 = self.definition.find(',', self.pos) + idx2 = self.definition.find(')', self.pos) + if idx0 < 0: + idx0 = max_pos + if idx1 < 0: + idx1 = max_pos + if idx2 < 0: + idx2 = max_pos + idx = min(idx0, idx1, idx2) + if idx >= max_pos: + self.fail('unexpected end in default expression') + if idx == idx0: + paren_stack_depth += 1 + elif idx == idx2: + paren_stack_depth -= 1 + if paren_stack_depth < 0: + break + elif paren_stack_depth == 0: + break + self.pos = idx+1 + + rv = self.definition[rv_start:idx] + self.pos = idx + return rv + + def _parse_signature(self): + self.skip_ws() + if not self.skip_string('('): + self.fail('expected parentheses for function') + + args = [] + while 1: + self.skip_ws() + if self.eof: + self.fail('missing closing parentheses') + if self.skip_string(')'): + break + if args: + if not self.skip_string(','): + self.fail('expected comma between arguments') + self.skip_ws() + + argtype = self._parse_type() + argname = default = None + self.skip_ws() + if self.skip_string('='): + self.pos += 1 + default = self._parse_default_expr() + elif self.current_char not in ',)': + argname = self._parse_name() + self.skip_ws() + if self.skip_string('='): + default = self._parse_default_expr() + + args.append(ArgumentDefExpr(argtype, argname, default)) + self.skip_ws() + const = self.skip_word('const') + if const: + self.skip_ws() + if self.skip_string('='): + self.skip_ws() + if not (self.skip_string('0') or \ + self.skip_word('NULL') or \ + self.skip_word('nullptr')): + self.fail('pure virtual functions must be defined with ' + 'either 0, NULL or nullptr, other macros are ' + 'not allowed') + pure_virtual = True + else: + pure_virtual = False + return args, const, pure_virtual + + def _parse_visibility_static(self): + visibility = 'public' + if self.match(_visibility_re): + visibility = self.matched_text + static = self.skip_word('static') + return visibility, static + + def parse_type(self): + return self._parse_type() + + def parse_type_object(self): + visibility, static = self._parse_visibility_static() + typename = self._parse_type() + self.skip_ws() + if not self.eof: + name = self._parse_type() + else: + name = typename + typename = None + return TypeObjDefExpr(name, visibility, static, typename) + + def parse_member_object(self): + visibility, static = self._parse_visibility_static() + typename = self._parse_type() + name = self._parse_type() + self.skip_ws() + if self.skip_string('='): + value = self.read_rest().strip() + else: + value = None + return MemberObjDefExpr(name, visibility, static, typename, value) + + def parse_function(self): + visibility, static = self._parse_visibility_static() + if self.skip_word('explicit'): + explicit = True + self.skip_ws() + else: + explicit = False + rv = self._parse_type() + self.skip_ws() + # some things just don't have return values + if self.current_char == '(': + name = rv + rv = None + else: + name = self._parse_type() + return FuncDefExpr(name, visibility, static, explicit, rv, + *self._parse_signature()) + + def parse_class(self): + visibility, static = self._parse_visibility_static() + return ClassDefExpr(self._parse_type(), visibility, static) + + def read_rest(self): + rv = self.definition[self.pos:] + self.pos = self.end + return rv + + def assert_end(self): + self.skip_ws() + if not self.eof: + self.fail('expected end of definition, got %r' % + self.definition[self.pos:]) + + +class OCVObject(ObjectDescription): + """Description of a C++ language object.""" + + doc_field_types = [ + TypedField('parameter', label=l_('Parameters'), + names=('param', 'parameter', 'arg', 'argument'), + typerolename='type', typenames=('type',)), + Field('returnvalue', label=l_('Returns'), has_arg=False, + names=('returns', 'return')), + Field('returntype', label=l_('Return type'), has_arg=False, + names=('rtype',)), + ] + + def attach_name(self, node, name): + owner, name = name.split_owner() + varname = unicode(name) + if owner is not None: + owner = unicode(owner) + '::' + node += addnodes.desc_addname(owner, owner) + node += addnodes.desc_name(varname, varname) + + def attach_type(self, node, type): + # XXX: link to c? + text = unicode(type) + pnode = addnodes.pending_xref( + '', refdomain='ocv', reftype='type', + reftarget=text, modname=None, classname=None) + pnode['ocv:parent'] = self.env.temp_data.get('ocv:parent') + pnode += nodes.Text(text) + node += pnode + + def attach_modifiers(self, node, obj): + if obj.visibility != 'public': + node += addnodes.desc_annotation(obj.visibility, + obj.visibility) + node += nodes.Text(' ') + if obj.static: + node += addnodes.desc_annotation('static', 'static') + node += nodes.Text(' ') + + def add_target_and_index(self, sigobj, sig, signode): + theid = sigobj.get_id() + name = unicode(sigobj.name) + if theid not in self.state.document.ids: + signode['names'].append(theid) + signode['ids'].append(theid) + signode['first'] = (not self.names) + self.state.document.note_explicit_target(signode) + + self.env.domaindata['ocv']['objects'].setdefault(name, + (self.env.docname, self.objtype, theid)) + + indextext = self.get_index_text(name) + if indextext: + self.indexnode['entries'].append(('single', indextext, theid, name)) + + def before_content(self): + lastname = self.names and self.names[-1] + if lastname and not self.env.temp_data.get('ocv:parent'): + assert isinstance(lastname, NamedDefExpr) + self.env.temp_data['ocv:parent'] = lastname.name + self.parentname_set = True + else: + self.parentname_set = False + + def after_content(self): + if self.parentname_set: + self.env.temp_data['ocv:parent'] = None + + def parse_definition(self, parser): + raise NotImplementedError() + + def describe_signature(self, signode, arg): + raise NotImplementedError() + + def handle_signature(self, sig, signode): + parser = DefinitionParser(sig) + try: + rv = self.parse_definition(parser) + parser.assert_end() + except DefinitionError, e: + self.env.warn(self.env.docname, + e.description, self.lineno) + raise ValueError + self.describe_signature(signode, rv) + + parent = self.env.temp_data.get('ocv:parent') + if parent is not None: + rv = rv.clone() + rv.name = rv.name.prefix(parent) + return rv + + +class OCVClassObject(OCVObject): + + def get_index_text(self, name): + return _('%s (C++ class)') % name + + def parse_definition(self, parser): + return parser.parse_class() + + def describe_signature(self, signode, cls): + #self.attach_modifiers(signode, cls) + #signode += addnodes.desc_annotation('class ', 'class ') + #self.attach_name(signode, cls.name) + pass + + +class OCVTypeObject(OCVObject): + + def get_index_text(self, name): + if self.objtype == 'type': + return _('%s (C++ type)') % name + return '' + + def parse_definition(self, parser): + return parser.parse_type_object() + + def describe_signature(self, signode, obj): + self.attach_modifiers(signode, obj) + signode += addnodes.desc_annotation('type ', 'type ') + if obj.typename is not None: + self.attach_type(signode, obj.typename) + signode += nodes.Text(' ') + self.attach_name(signode, obj.name) + + +class OCVMemberObject(OCVObject): + + def get_index_text(self, name): + if self.objtype == 'member': + return _('%s (C++ member)') % name + return '' + + def parse_definition(self, parser): + return parser.parse_member_object() + + def describe_signature(self, signode, obj): + self.attach_modifiers(signode, obj) + self.attach_type(signode, obj.typename) + signode += nodes.Text(' ') + self.attach_name(signode, obj.name) + if obj.value is not None: + signode += nodes.Text(u' = ' + obj.value) + + +class OCVFunctionObject(OCVObject): + + def attach_function(self, node, func): + owner, name = func.name.split_owner() + if owner is not None: + owner = unicode(owner) + '::' + node += addnodes.desc_addname(owner, owner) + + # cast operator is special. in this case the return value + # is reversed. + if isinstance(name, CastOpDefExpr): + node += addnodes.desc_name('operator', 'operator') + node += nodes.Text(u' ') + self.attach_type(node, name.typename) + else: + funcname = unicode(name) + node += addnodes.desc_name(funcname, funcname) + + paramlist = addnodes.desc_parameterlist() + for arg in func.signature: + param = addnodes.desc_parameter('', '', noemph=True) + if arg.type is not None: + self.attach_type(param, arg.type) + param += nodes.Text(u' ') + param += nodes.emphasis(unicode(arg.name), unicode(arg.name)) + if arg.default is not None: + def_ = u'=' + unicode(arg.default) + param += nodes.emphasis(def_, def_) + paramlist += param + + node += paramlist + if func.const: + node += addnodes.desc_addname(' const', ' const') + if func.pure_virtual: + node += addnodes.desc_addname(' = 0', ' = 0') + + def get_index_text(self, name): + return _('%s (C++ function)') % name + + def parse_definition(self, parser): + return parser.parse_function() + + def describe_signature(self, signode, func): + self.attach_modifiers(signode, func) + if func.explicit: + signode += addnodes.desc_annotation('explicit', 'explicit') + signode += nodes.Text(' ') + # return value is None for things with a reverse return value + # such as casting operator definitions or constructors + # and destructors. + if func.rv is not None: + self.attach_type(signode, func.rv) + signode += nodes.Text(u' ') + self.attach_function(signode, func) + + +class OCVCurrentNamespace(Directive): + """This directive is just to tell Sphinx that we're documenting + stuff in namespace foo. + """ + + has_content = False + required_arguments = 1 + optional_arguments = 0 + final_argument_whitespace = True + option_spec = {} + + def run(self): + env = self.state.document.settings.env + if self.arguments[0].strip() in ('NULL', '0', 'nullptr'): + env.temp_data['ocv:prefix'] = None + else: + parser = DefinitionParser(self.arguments[0]) + try: + prefix = parser.parse_type() + parser.assert_end() + except DefinitionError, e: + self.env.warn(self.env.docname, + e.description, self.lineno) + else: + env.temp_data['ocv:prefix'] = prefix + return [] + + +class OCVXRefRole(XRefRole): + + def process_link(self, env, refnode, has_explicit_title, title, target): + refnode['ocv:parent'] = env.temp_data.get('ocv:parent') + if not has_explicit_title: + target = target.lstrip('~') # only has a meaning for the title + # if the first character is a tilde, don't display the module/class + # parts of the contents + if title[:1] == '~': + title = title[1:] + dcolon = title.rfind('::') + if dcolon != -1: + title = title[dcolon + 2:] + return title, target + + +class OCVDomain(Domain): + """OpenCV C++ language domain.""" + name = 'ocv' + label = 'C++' + object_types = { + 'class': ObjType(l_('class'), 'class'), + 'function': ObjType(l_('function'), 'func', 'funcx'), + 'member': ObjType(l_('member'), 'member'), + 'type': ObjType(l_('type'), 'type') + } + + directives = { + 'class': OCVClassObject, + 'function': OCVFunctionObject, + 'member': OCVMemberObject, + 'type': OCVTypeObject, + 'namespace': OCVCurrentNamespace + } + roles = { + 'class': OCVXRefRole(), + 'func' : OCVXRefRole(fix_parens=True), + 'funcx' : OCVXRefRole(), + 'member': OCVXRefRole(), + 'type': OCVXRefRole() + } + initial_data = { + 'objects': {}, # fullname -> docname, objtype + } + + def clear_doc(self, docname): + for fullname, (fn, _, _) in self.data['objects'].items(): + if fn == docname: + del self.data['objects'][fullname] + + def resolve_xref(self, env, fromdocname, builder, + typ, target, node, contnode): + def _create_refnode(expr): + name = unicode(expr) + if name not in self.data['objects']: + return None + obj = self.data['objects'][name] + if obj[1] not in self.objtypes_for_role(typ): + return None + return make_refnode(builder, fromdocname, obj[0], obj[2], + contnode, name) + + parser = DefinitionParser(target) + try: + expr = parser.parse_type().get_name() + parser.skip_ws() + if not parser.eof or expr is None: + raise DefinitionError('') + except DefinitionError: + refdoc = node.get('refdoc', fromdocname) + env.warn(refdoc, 'unparseable C++ definition: %r' % target, + node.line) + return None + + parent = node['ocv:parent'] + + rv = _create_refnode(expr) + if rv is not None or parent is None: + return rv + parent = parent.get_name() + + rv = _create_refnode(expr.prefix(parent)) + if rv is not None: + return rv + + parent, name = parent.split_owner() + return _create_refnode(expr.prefix(parent)) + + def get_objects(self): + for refname, (docname, type, theid) in self.data['objects'].iteritems(): + yield (refname, refname, type, docname, refname, 1) + +def setup(app): + app.add_domain(OCVDomain) diff --git a/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst b/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst index 702d323..f0ecc2b 100644 --- a/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst +++ b/modules/calib3d/doc/camera_calibration_and_3d_reconstruction.rst @@ -106,7 +106,7 @@ The functions below use the above model to do the following: calibrateCamera --------------- -.. cpp:function:: double calibrateCamera( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArray rvecs, OutputArray tvecs, int flags=0 ) +.. ocv:function:: double calibrateCamera( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, InputOutputArray cameraMatrix, InputOutputArray distCoeffs, OutputArray rvecs, OutputArray tvecs, int flags=0 ) Finds the camera intrinsic and extrinsic parameters from several views of a calibration pattern. @@ -186,7 +186,7 @@ See Also: calibrationMatrixValues ----------------------- -.. cpp:function:: void calibrationMatrixValues( InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double& fovx, double& fovy, double& focalLength, Point2d& principalPoint, double& aspectRatio ) +.. ocv:function:: void calibrationMatrixValues( InputArray cameraMatrix, Size imageSize, double apertureWidth, double apertureHeight, double& fovx, double& fovy, double& focalLength, Point2d& principalPoint, double& aspectRatio ) Computes useful camera characteristics from the camera matrix. @@ -215,7 +215,7 @@ The function computes various useful camera characteristics from the previously composeRT ------------- -.. cpp:function:: void composeRT( InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray() ) +.. ocv:function:: void composeRT( InputArray rvec1, InputArray tvec1, InputArray rvec2, InputArray tvec2, OutputArray rvec3, OutputArray tvec3, OutputArray dr3dr1=noArray(), OutputArray dr3dt1=noArray(), OutputArray dr3dr2=noArray(), OutputArray dr3dt2=noArray(), OutputArray dt3dr1=noArray(), OutputArray dt3dt1=noArray(), OutputArray dt3dr2=noArray(), OutputArray dt3dt2=noArray() ) Combines two rotation-and-shift transformations. @@ -249,7 +249,7 @@ The functions are used inside :ref:`stereoCalibrate` but can also be used in you computeCorrespondEpilines ----------------------------- -.. cpp:function:: void computeCorrespondEpilines( InputArray points, int whichImage, InputArray F, OutputArray lines ) +.. ocv:function:: void computeCorrespondEpilines( InputArray points, int whichImage, InputArray F, OutputArray lines ) For points in an image of a stereo pair, computes the corresponding epilines in the other image. @@ -291,7 +291,7 @@ Line coefficients are defined up to a scale. They are normalized so that convertPointsToHomogeneous ------------------------ -.. cpp:function:: void convertPointsToHomogeneous( InputArray src, OutputArray dst ) +.. ocv:function:: void convertPointsToHomogeneous( InputArray src, OutputArray dst ) Converts points from Euclidean to homogeneous space. @@ -306,7 +306,7 @@ The function converts points from Euclidean to homogeneous space by appending 1' convertPointsFromHomogeneous ------------------------ -.. cpp:function:: void convertPointsFromHomogeneous( InputArray src, OutputArray dst ) +.. ocv:function:: void convertPointsFromHomogeneous( InputArray src, OutputArray dst ) Converts points from homogeneous to Euclidean space. @@ -321,7 +321,7 @@ The function converts points homogeneous to Euclidean space using perspective pr convertPointsHomogeneous ------------------------ -.. cpp:function:: void convertPointsHomogeneous( InputArray src, OutputArray dst ) +.. ocv:function:: void convertPointsHomogeneous( InputArray src, OutputArray dst ) Converts points to/from homogeneous coordinates. @@ -329,7 +329,7 @@ convertPointsHomogeneous :param dst: Output vector of 2D, 3D or 4D points. -The function converts 2D or 3D points from/to homogeneous coordinates by calling either :cpp:func:`convertPointsToHomogeneous` or :cpp:func:`convertPointsFromHomogeneous`. The function is obsolete; use one of the previous two instead. +The function converts 2D or 3D points from/to homogeneous coordinates by calling either :ocv:func:`convertPointsToHomogeneous` or :ocv:func:`convertPointsFromHomogeneous`. The function is obsolete; use one of the previous two instead. .. index:: decomposeProjectionMatrix @@ -337,7 +337,7 @@ The function converts 2D or 3D points from/to homogeneous coordinates by calling decomposeProjectionMatrix ----------------------------- -.. cpp:function:: void decomposeProjectionMatrix( InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray() ) +.. ocv:function:: void decomposeProjectionMatrix( InputArray projMatrix, OutputArray cameraMatrix, OutputArray rotMatrix, OutputArray transVect, OutputArray rotMatrixX=noArray(), OutputArray rotMatrixY=noArray(), OutputArray rotMatrixZ=noArray(), OutputArray eulerAngles=noArray() ) Decomposes a projection matrix into a rotation matrix and a camera matrix. @@ -368,7 +368,7 @@ The function is based on drawChessboardCorners ------------------------- -.. cpp:function:: void drawChessboardCorners( InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound ) +.. ocv:function:: void drawChessboardCorners( InputOutputArray image, Size patternSize, InputArray corners, bool patternWasFound ) Renders the detected chessboard corners. @@ -378,7 +378,7 @@ drawChessboardCorners :param corners: Array of detected corners, the output of ``findChessboardCorners``. - :param patternWasFound: Parameter indicating whether the complete board was found or not. The return value of :cpp:func:`findChessboardCorners` should be passed here. + :param patternWasFound: Parameter indicating whether the complete board was found or not. The return value of :ocv:func:`findChessboardCorners` should be passed here. The function draws individual chessboard corners detected either as red circles if the board was not found, or as colored corners connected with lines if the board was found. @@ -386,7 +386,7 @@ The function draws individual chessboard corners detected either as red circles findChessboardCorners ------------------------- -.. cpp:function:: bool findChessboardCorners( InputArray image, Size patternSize, OutputArray corners, int flags=CV_CALIB_CB_ADAPTIVE_THRESH+CV_CALIB_CB_NORMALIZE_IMAGE ) +.. ocv:function:: bool findChessboardCorners( InputArray image, Size patternSize, OutputArray corners, int flags=CV_CALIB_CB_ADAPTIVE_THRESH+CV_CALIB_CB_NORMALIZE_IMAGE ) Finds the positions of internal corners of the chessboard. @@ -444,7 +444,7 @@ The function requires white space (like a square-thick border, the wider the bet findCirclesGrid ------------------- -.. cpp:function:: bool findCirclesGrid( InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr &blobDetector = new SimpleBlobDetector() ) +.. ocv:function:: bool findCirclesGrid( InputArray image, Size patternSize, OutputArray centers, int flags=CALIB_CB_SYMMETRIC_GRID, const Ptr &blobDetector = new SimpleBlobDetector() ) Finds the centers in the grid of circles. @@ -489,7 +489,7 @@ The function requires white space (like a square-thick border, the wider the bet solvePnP ------------ -.. cpp:function:: void solvePnP( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false ) +.. ocv:function:: void solvePnP( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false ) Finds an object pose from 3D-2D point correspondences. @@ -515,7 +515,7 @@ The function estimates the object pose given a set of object points, their corre solvePnPRansac ------------------ -.. cpp:function:: void solvePnPRansac( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount = 100, float reprojectionError = 8.0, int minInliersCount = 100, OutputArray inliers = noArray() ) +.. ocv:function:: void solvePnPRansac( InputArray objectPoints, InputArray imagePoints, InputArray cameraMatrix, InputArray distCoeffs, OutputArray rvec, OutputArray tvec, bool useExtrinsicGuess=false, int iterationsCount = 100, float reprojectionError = 8.0, int minInliersCount = 100, OutputArray inliers = noArray() ) Finds an object pose from 3D-2D point correspondences using the RANSAC scheme. @@ -548,7 +548,7 @@ The function estimates an object pose given a set of object points, their corres findFundamentalMat ---------------------- -.. cpp:function:: Mat findFundamentalMat( InputArray points1, InputArray points2, int method=FM_RANSAC, double param1=3., double param2=0.99, OutputArray mask=noArray() ) +.. ocv:function:: Mat findFundamentalMat( InputArray points1, InputArray points2, int method=FM_RANSAC, double param1=3., double param2=0.99, OutputArray mask=noArray() ) Calculates a fundamental matrix from the corresponding points in two images. @@ -608,7 +608,7 @@ corresponding to the specified points. It can also be passed to findHomography ------------------ -.. cpp:function:: Mat findHomography( InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray() ) +.. ocv:function:: Mat findHomography( InputArray srcPoints, InputArray dstPoints, int method=0, double ransacReprojThreshold=3, OutputArray mask=noArray() ) Finds a perspective transformation between two planes. @@ -687,7 +687,7 @@ See Also: estimateAffine3D -------------------- -.. cpp:function:: int estimateAffine3D(InputArray srcpt, InputArray dstpt, OutputArray out, OutputArray outliers, double ransacThreshold = 3.0, double confidence = 0.99) +.. ocv:function:: int estimateAffine3D(InputArray srcpt, InputArray dstpt, OutputArray out, OutputArray outliers, double ransacThreshold = 3.0, double confidence = 0.99) Computes an optimal affine transformation between two 3D point sets. @@ -710,7 +710,7 @@ The function estimates an optimal 3D affine transformation between two 3D point getOptimalNewCameraMatrix ----------------------------- -.. cpp:function:: Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImageSize=Size(), Rect* validPixROI=0) +.. ocv:function:: Mat getOptimalNewCameraMatrix( InputArray cameraMatrix, InputArray distCoeffs, Size imageSize, double alpha, Size newImageSize=Size(), Rect* validPixROI=0) Returns the new camera matrix based on the free scaling parameter. @@ -737,7 +737,7 @@ the optimal new camera matrix based on the free scaling parameter. By varying t initCameraMatrix2D ---------------------- -.. cpp:function:: Mat initCameraMatrix2D( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.) +.. ocv:function:: Mat initCameraMatrix2D( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints, Size imageSize, double aspectRatio=1.) Finds an initial camera matrix from 3D-2D point correspondences. @@ -757,7 +757,7 @@ Currently, the function only supports planar calibration patterns, which are pat matMulDeriv --------------- -.. cpp:function:: void matMulDeriv( InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB ) +.. ocv:function:: void matMulDeriv( InputArray A, InputArray B, OutputArray dABdA, OutputArray dABdB ) Computes partial derivatives of the matrix product for each multiplied matrix. @@ -778,7 +778,7 @@ The function computes partial derivatives of the elements of the matrix product projectPoints ----------------- -.. cpp:function:: void projectPoints( InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0 ) +.. ocv:function:: void projectPoints( InputArray objectPoints, InputArray rvec, InputArray tvec, InputArray cameraMatrix, InputArray distCoeffs, OutputArray imagePoints, OutputArray jacobian=noArray(), double aspectRatio=0 ) Projects 3D points to an image plane. @@ -820,7 +820,7 @@ By setting ``rvec=tvec=(0,0,0)`` or by setting ``cameraMatrix`` to a 3x3 identi reprojectImageTo3D ---------------------- -.. cpp:function:: void reprojectImageTo3D( InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int depth=-1 ) +.. ocv:function:: void reprojectImageTo3D( InputArray disparity, OutputArray _3dImage, InputArray Q, bool handleMissingValues=false, int depth=-1 ) Reprojects a disparity image to 3D space. @@ -850,7 +850,7 @@ The matrix ``Q`` can be an arbitrary RQDecomp3x3 --------------- -.. cpp:function:: Vec3d RQDecomp3x3( InputArray M, OutputArray R, OutputArray Q, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray() ) +.. ocv:function:: Vec3d RQDecomp3x3( InputArray M, OutputArray R, OutputArray Q, OutputArray Qx=noArray(), OutputArray Qy=noArray(), OutputArray Qz=noArray() ) Computes an RQ decomposition of 3x3 matrices. @@ -877,7 +877,7 @@ that could be used in OpenGL. Rodrigues ------------- -.. cpp:function:: void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=noArray()) +.. ocv:function:: void Rodrigues(InputArray src, OutputArray dst, OutputArray jacobian=noArray()) Converts a rotation matrix to a rotation vector or vice versa. @@ -944,7 +944,7 @@ The class is a C++ wrapper for the associated functions. In particular, ``Stereo StereoBM::operator () ----------------------- -.. cpp:function:: void StereoBM::operator()(InputArray left, InputArray right, OutputArray disp, int disptype=CV_16S ) +.. ocv:function:: void StereoBM::operator()(InputArray left, InputArray right, OutputArray disp, int disptype=CV_16S ) Computes disparity using the BM algorithm for a rectified stereo pair. @@ -1008,9 +1008,9 @@ The class implements the modified H. Hirschmuller algorithm HH08 that differs fr StereoSGBM::StereoSGBM -------------------------- -.. cpp:function:: StereoSGBM::StereoSGBM() +.. ocv:function:: StereoSGBM::StereoSGBM() -.. cpp:function:: StereoSGBM::StereoSGBM( int minDisparity, int numDisparities, int SADWindowSize, int P1=0, int P2=0, int disp12MaxDiff=0, int preFilterCap=0, int uniquenessRatio=0, int speckleWindowSize=0, int speckleRange=0, bool fullDP=false) +.. ocv:function:: StereoSGBM::StereoSGBM( int minDisparity, int numDisparities, int SADWindowSize, int P1=0, int P2=0, int disp12MaxDiff=0, int preFilterCap=0, int uniquenessRatio=0, int speckleWindowSize=0, int speckleRange=0, bool fullDP=false) The constructor. @@ -1041,7 +1041,7 @@ The first constructor initializes ``StereoSGBM`` with all the default parameters StereoSGBM::operator () ----------------------- -.. cpp:function:: void StereoSGBM::operator()(InputArray left, InputArray right, OutputArray disp) +.. ocv:function:: void StereoSGBM::operator()(InputArray left, InputArray right, OutputArray disp) Computes disparity using the SGBM algorithm for a rectified stereo pair. @@ -1061,7 +1061,7 @@ The method is not constant, so you should not use the same ``StereoSGBM`` instan stereoCalibrate ------------------- -.. cpp:function:: double stereoCalibrate( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, TermCriteria term_crit = TermCriteria(TermCriteria::COUNT+ TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC ) +.. ocv:function:: double stereoCalibrate( InputArrayOfArrays objectPoints, InputArrayOfArrays imagePoints1, InputArrayOfArrays imagePoints2, InputOutputArray cameraMatrix1, InputOutputArray distCoeffs1, InputOutputArray cameraMatrix2, InputOutputArray distCoeffs2, Size imageSize, OutputArray R, OutputArray T, OutputArray E, OutputArray F, TermCriteria term_crit = TermCriteria(TermCriteria::COUNT+ TermCriteria::EPS, 30, 1e-6), int flags=CALIB_FIX_INTRINSIC ) Calibrates the stereo camera. @@ -1148,7 +1148,7 @@ Similarly to :ref:`calibrateCamera` , the function minimizes the total re-projec stereoRectify ----------------- -.. cpp:function:: void stereoRectify( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=CALIB_ZERO_DISPARITY, double alpha, Size newImageSize=Size(), Rect* roi1=0, Rect* roi2=0 ) +.. ocv:function:: void stereoRectify( InputArray cameraMatrix1, InputArray distCoeffs1, InputArray cameraMatrix2, InputArray distCoeffs2, Size imageSize, InputArray R, InputArray T, OutputArray R1, OutputArray R2, OutputArray P1, OutputArray P2, OutputArray Q, int flags=CALIB_ZERO_DISPARITY, double alpha, Size newImageSize=Size(), Rect* roi1=0, Rect* roi2=0 ) Computes rectification transforms for each head of a calibrated stereo camera. @@ -1225,7 +1225,7 @@ See below the screenshot from the ``stereo_calib.cpp`` sample. Some red horizont stereoRectifyUncalibrated ----------------------------- -.. cpp:function:: bool stereoRectifyUncalibrated( InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5 ) +.. ocv:function:: bool stereoRectifyUncalibrated( InputArray points1, InputArray points2, InputArray F, Size imgSize, OutputArray H1, OutputArray H2, double threshold=5 ) Computes a rectification transform for an uncalibrated stereo camera. diff --git a/modules/core/doc/basic_structures.rst b/modules/core/doc/basic_structures.rst index 7e55558..d99ad58 100644 --- a/modules/core/doc/basic_structures.rst +++ b/modules/core/doc/basic_structures.rst @@ -5,10 +5,10 @@ Basic Structures DataType -------- -.. cpp:class:: DataType +.. ocv:class:: DataType Template "trait" class for OpenCV primitive data types. A primitive OpenCV data type is one of ``unsigned char``, ``bool``, ``signed char``, ``unsigned short``, ``signed short``, ``int``, ``float``, ``double``, or a tuple of values of one of these types, where all the values in the tuple have the same type. Any primitive type from the list can be defined by an identifier in the form ``CV_{U|S|F}C()``, for example: ``uchar`` ~ ``CV_8UC1``, 3-element floating-point tuple ~ ``CV_32FC3``, and so on. A universal OpenCV structure that is able to store a single instance of such a primitive data type is -:cpp:class:`Vec`. Multiple instances of such a type can be stored in a ``std::vector``, ``Mat``, ``Mat_``, ``SparseMat``, ``SparseMat_``, or any other container that is able to store ``Vec`` instances. +:ocv:class:`Vec`. Multiple instances of such a type can be stored in a ``std::vector``, ``Mat``, ``Mat_``, ``SparseMat``, ``SparseMat_``, or any other container that is able to store ``Vec`` instances. The ``DataType`` class is basically used to provide a description of such primitive data types without adding any fields or methods to the corresponding classes (and it is actually impossible to add anything to primitive C/C++ data types). This technique is known in C++ as class traits. It is not ``DataType`` itself that is used but its specialized versions, such as: :: @@ -47,7 +47,7 @@ So, such traits are used to tell OpenCV which data type you are working with, ev Point\_ ------- -.. cpp:class:: Point_ +.. ocv:class:: Point_ Template class for 2D points specified by its coordinates :math:`x` and @@ -82,7 +82,7 @@ Example: :: Point3\_ -------- -.. cpp:class:: Point3_ +.. ocv:class:: Point3_ Template class for 3D points specified by its coordinates :math:`x`, @@ -98,7 +98,7 @@ The following ``Point3_<>`` aliases are available: :: Size\_ ------ -.. cpp:class:: Size_ +.. ocv:class:: Size_ Template class for specfying the size of an image or rectangle. The class includes two members called ``width`` and ``height``. The structure can be converted to and from the old OpenCV structures ``CvSize`` and ``CvSize2D32f`` . The same set of arithmetic and comparison operations as for ``Point_`` is available. @@ -111,7 +111,7 @@ OpenCV defines the following ``Size_<>`` aliases: :: Rect\_ ------ -.. cpp:class:: Rect_ +.. ocv:class:: Rect_ Template class for 2D rectangles, described by the following parameters:: @@ -169,20 +169,20 @@ For your convenience, the ``Rect_<>`` alias is available: :: RotatedRect ----------- -.. cpp:class:: RotatedRect +.. ocv:class:: RotatedRect Template class for rotated rectangles specified by the center, size, and the rotation angle in degrees. TermCriteria ------------ -.. cpp:class:: TermCriteria +.. ocv:class:: TermCriteria Template class defining termination criteria for iterative algorithms. Matx ---- -.. cpp:class:: Matx +.. ocv:class:: Matx Template class for small matrices whose type and size are known at compilation time: :: @@ -206,7 +206,7 @@ Template class for small matrices whose type and size are known at compilation t typedef Matx Matx66f; typedef Matx Matx66d; -If you need a more flexible type, use :cpp:class:`Mat` . The elements of the matrix ``M`` are accessible using the ``M(i,j)`` notation. Most of the common matrix operations (see also +If you need a more flexible type, use :ocv:class:`Mat` . The elements of the matrix ``M`` are accessible using the ``M(i,j)`` notation. Most of the common matrix operations (see also :ref:`MatrixExpressions` ) are available. To do an operation on ``Matx`` that is not implemented, you can easily convert the matrix to ``Mat`` and backwards. :: @@ -218,9 +218,9 @@ If you need a more flexible type, use :cpp:class:`Mat` . The elements of the mat Vec --- -.. cpp:class:: Vec +.. ocv:class:: Vec -Template class for short numerical vectors, a partial case of :cpp:class:`Matx`: :: +Template class for short numerical vectors, a partial case of :ocv:class:`Matx`: :: template class Vec : public Matx<_Tp, n, 1> {...}; @@ -246,7 +246,7 @@ Template class for short numerical vectors, a partial case of :cpp:class:`Matx`: typedef Vec Vec4d; typedef Vec Vec6d; -It is possible to convert ``Vec`` to/from ``Point_``, ``Vec`` to/from ``Point3_`` , and ``Vec`` to ``CvScalar`` or :cpp:class:`Scalar`. Use ``operator[]`` to access the elements of ``Vec``. +It is possible to convert ``Vec`` to/from ``Point_``, ``Vec`` to/from ``Point3_`` , and ``Vec`` to ``CvScalar`` or :ocv:class:`Scalar`. Use ``operator[]`` to access the elements of ``Vec``. All the expected vector operations are also implemented: @@ -259,11 +259,11 @@ All the expected vector operations are also implemented: * ``v1 == v2, v1 != v2`` * ``norm(v1)`` (euclidean norm) -The ``Vec`` class is commonly used to describe pixel types of multi-channel arrays. See :cpp:class:`Mat` for details. +The ``Vec`` class is commonly used to describe pixel types of multi-channel arrays. See :ocv:class:`Mat` for details. Scalar\_ -------- -.. cpp:class:: Scalar_ +.. ocv:class:: Scalar_ Template class for a 4-element vector derived from Vec. :: @@ -275,7 +275,7 @@ Being derived from ``Vec<_Tp, 4>`` , ``Scalar_`` and ``Scalar`` can be used just Range ----- -.. cpp:class:: Range +.. ocv:class:: Range Template class specifying a continuous subsequence (slice) of a sequence. :: @@ -287,7 +287,7 @@ Template class specifying a continuous subsequence (slice) of a sequence. :: }; The class is used to specify a row or a column span in a matrix ( -:cpp:class:`Mat` ) and for many other purposes. ``Range(a,b)`` is basically the same as ``a:b`` in Matlab or ``a..b`` in Python. As in Python, ``start`` is an inclusive left boundary of the range and ``end`` is an exclusive right boundary of the range. Such a half-opened interval is usually denoted as +:ocv:class:`Mat` ) and for many other purposes. ``Range(a,b)`` is basically the same as ``a:b`` in Matlab or ``a..b`` in Python. As in Python, ``start`` is an inclusive left boundary of the range and ``end`` is an exclusive right boundary of the range. Such a half-opened interval is usually denoted as :math:`[start,end)` . The static method ``Range::all()`` returns a special variable that means "the whole sequence" or "the whole range", just like " ``:`` " in Matlab or " ``...`` " in Python. All the methods and functions in OpenCV that take ``Range`` support this special ``Range::all()`` value. But, of course, in case of your own custom processing, you will probably have to check and handle it explicitly: :: @@ -305,7 +305,7 @@ The static method ``Range::all()`` returns a special variable that means "the wh Ptr --- -.. cpp:class:: Ptr +.. ocv:class:: Ptr Template class for smart reference-counting pointers :: @@ -389,11 +389,11 @@ However, if the object is deallocated in a different way, the specialized method // the file will be closed automatically by the Ptr destructor. -.. note:: The reference increment/decrement operations are implemented as atomic operations, and therefore it is normally safe to use the classes in multi-threaded applications. The same is true for :cpp:class:`Mat` and other C++ OpenCV classes that operate on the reference counters. +.. note:: The reference increment/decrement operations are implemented as atomic operations, and therefore it is normally safe to use the classes in multi-threaded applications. The same is true for :ocv:class:`Mat` and other C++ OpenCV classes that operate on the reference counters. Mat --- -.. cpp:class:: Mat +.. ocv:class:: Mat OpenCV C++ n-dimensional dense array class :: @@ -588,7 +588,7 @@ There are many different ways to create a ``Mat`` object. The most popular optio .. - With this approach, you first call a constructor of the :cpp:class:`Mat_` class with the proper parameters, and then you just put ``<<`` operator followed by comma-separated values that can be constants, variables, expressions, and so on. Also, note the extra parentheses required to avoid compilation errors. + With this approach, you first call a constructor of the :ocv:class:`Mat_` class with the proper parameters, and then you just put ``<<`` operator followed by comma-separated values that can be constants, variables, expressions, and so on. Also, note the extra parentheses required to avoid compilation errors. Once the array is created, it is automatically managed via a reference-counting mechanism. If the array header is built on top of user-allocated data, you should handle the data by yourself. The array data is deallocated when no one points to it. If you want to release the data pointed by a array header before the array destructor is called, use ``Mat::release()`` . @@ -688,7 +688,7 @@ for a scalar ( ``Scalar`` ), any function of matrix or matrices and scalars that returns a matrix or a scalar, such as ``norm``, ``mean``, ``sum``, ``countNonZero``, ``trace``, ``determinant``, ``repeat``, and others. * - Matrix initializers ( ``eye(), zeros(), ones()`` ), matrix comma-separated initializers, matrix constructors and operators that extract sub-matrices (see :cpp:class:`Mat` description). + Matrix initializers ( ``eye(), zeros(), ones()`` ), matrix comma-separated initializers, matrix constructors and operators that extract sub-matrices (see :ocv:class:`Mat` description). * ``Mat_()`` constructors to cast the result to the proper type. @@ -699,45 +699,45 @@ Below is the formal description of the ``Mat`` methods. Mat::Mat ------------ -.. cpp:function:: Mat::Mat() +.. ocv:function:: Mat::Mat() -.. cpp:function:: Mat::Mat(int rows, int cols, int type) +.. ocv:function:: Mat::Mat(int rows, int cols, int type) -.. cpp:function:: Mat::Mat(Size size, int type) +.. ocv:function:: Mat::Mat(Size size, int type) -.. cpp:function:: Mat::Mat(int rows, int cols, int type, const Scalar& s) +.. ocv:function:: Mat::Mat(int rows, int cols, int type, const Scalar& s) -.. cpp:function:: Mat::Mat(Size size, int type, const Scalar& s) +.. ocv:function:: Mat::Mat(Size size, int type, const Scalar& s) -.. cpp:function:: Mat::Mat(const Mat& m) +.. ocv:function:: Mat::Mat(const Mat& m) -.. cpp:function:: Mat::Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP) +.. ocv:function:: Mat::Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP) -.. cpp:function:: Mat::Mat(Size size, int type, void* data, size_t step=AUTO_STEP) +.. ocv:function:: Mat::Mat(Size size, int type, void* data, size_t step=AUTO_STEP) -.. cpp:function:: Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) +.. ocv:function:: Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) -.. cpp:function:: Mat::Mat(const Mat& m, const Rect& roi) +.. ocv:function:: Mat::Mat(const Mat& m, const Rect& roi) -.. cpp:function:: Mat::Mat(const CvMat* m, bool copyData=false) +.. ocv:function:: Mat::Mat(const CvMat* m, bool copyData=false) -.. cpp:function:: Mat::Mat(const IplImage* img, bool copyData=false) +.. ocv:function:: Mat::Mat(const IplImage* img, bool copyData=false) -.. cpp:function:: template explicit Mat::Mat(const Vec& vec, bool copyData=true) +.. ocv:function:: template explicit Mat::Mat(const Vec& vec, bool copyData=true) -.. cpp:function:: template explicit Mat::Mat(const Matx& vec, bool copyData=true) +.. ocv:function:: template explicit Mat::Mat(const Matx& vec, bool copyData=true) -.. cpp:function:: template explicit Mat::Mat(const vector& vec, bool copyData=false) +.. ocv:function:: template explicit Mat::Mat(const vector& vec, bool copyData=false) -.. cpp:function:: Mat::Mat(const MatExpr& expr) +.. ocv:function:: Mat::Mat(const MatExpr& expr) -.. cpp:function:: Mat::Mat(int ndims, const int* sizes, int type) +.. ocv:function:: Mat::Mat(int ndims, const int* sizes, int type) -.. cpp:function:: Mat::Mat(int ndims, const int* sizes, int type, const Scalar& s) +.. ocv:function:: Mat::Mat(int ndims, const int* sizes, int type, const Scalar& s) -.. cpp:function:: Mat::Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0) +.. ocv:function:: Mat::Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0) -.. cpp:function:: Mat::Mat(const Mat& m, const Range* ranges) +.. ocv:function:: Mat::Mat(const Mat& m, const Range* ranges) Provides various array constructors. @@ -757,7 +757,7 @@ Mat::Mat :param data: Pointer to the user data. Matrix constructors that take ``data`` and ``step`` parameters do not allocate matrix data. Instead, they just initialize the matrix header that points to the specified data, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically deallocated, so you should take care of it. - :param step: Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to ``AUTO_STEP`` ), no padding is assumed and the actual step is calculated as ``cols*elemSize()`` . See :cpp:func:`Mat::elemSize` . + :param step: Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to ``AUTO_STEP`` ), no padding is assumed and the actual step is calculated as ``cols*elemSize()`` . See :ocv:func:`Mat::elemSize` . :param steps: Array of ``ndims-1`` steps in case of a multi-dimensional array (the last step is always set to the element size). If not specified, the matrix is assumed to be continuous. @@ -765,7 +765,7 @@ Mat::Mat :param img: Pointer to the old-style ``IplImage`` image structure. By default, the data is shared between the original image and the new matrix. But when ``copyData`` is set, the full copy of the image data is created. - :param vec: STL vector whose elements form the matrix. The matrix has a single column and the number of rows equal to the number of vector elements. Type of the matrix matches the type of vector elements. The constructor can handle arbitrary types, for which there is a properly declared :cpp:class:`DataType` . This means that the vector elements must be primitive numbers or uni-type numerical tuples of numbers. Mixed-type structures are not supported. The corresponding constructor is explicit. Since STL vectors are not automatically converted to ``Mat`` instances, you should write ``Mat(vec)`` explicitly. Unless you copy the data into the matrix ( ``copyData=true`` ), no new elements will be added to the vector because it can potentially yield vector data reallocation, and, thus, the matrix data pointer will be invalid. + :param vec: STL vector whose elements form the matrix. The matrix has a single column and the number of rows equal to the number of vector elements. Type of the matrix matches the type of vector elements. The constructor can handle arbitrary types, for which there is a properly declared :ocv:class:`DataType` . This means that the vector elements must be primitive numbers or uni-type numerical tuples of numbers. Mixed-type structures are not supported. The corresponding constructor is explicit. Since STL vectors are not automatically converted to ``Mat`` instances, you should write ``Mat(vec)`` explicitly. Unless you copy the data into the matrix ( ``copyData=true`` ), no new elements will be added to the vector because it can potentially yield vector data reallocation, and, thus, the matrix data pointer will be invalid. :param copyData: Flag to specify whether the underlying data of the STL vector or the old-style ``CvMat`` or ``IplImage`` should be copied to (``true``) or shared with (``false``) the newly constructed matrix. When the data is copied, the allocated buffer is managed using ``Mat`` reference counting mechanism. While the data is shared, the reference counter is NULL, and you should not deallocate the data until the matrix is not destructed. @@ -779,30 +779,30 @@ Mat::Mat These are various constructors that form a matrix. As noted in the :ref:`AutomaticAllocation`, often the default constructor is enough, and the proper matrix will be allocated by an OpenCV function. The constructed matrix can further be assigned to another matrix or matrix expression or can be allocated with -:cpp:func:`Mat::create` . In the former case, the old content is de-referenced. +:ocv:func:`Mat::create` . In the former case, the old content is de-referenced. Mat::~Mat ------------ -.. cpp:function:: Mat::~Mat() +.. ocv:function:: Mat::~Mat() Provides a matrix destructor. The matrix destructor calls -:cpp:func:`Mat::release` . +:ocv:func:`Mat::release` . Mat::operator = ------------------- -.. cpp:function:: Mat& Mat::operator = (const Mat& m) +.. ocv:function:: Mat& Mat::operator = (const Mat& m) -.. cpp:function:: Mat& Mat::operator = (const MatExpr_Base& expr) +.. ocv:function:: Mat& Mat::operator = (const MatExpr_Base& expr) -.. cpp:function:: Mat& operator = (const Scalar& s) +.. ocv:function:: Mat& operator = (const Scalar& s) Provides matrix assignment operators. - :param m: Assigned, right-hand-side matrix. Matrix assignment is an O(1) operation. This means that no data is copied but the data is shared and the reference counter, if any, is incremented. Before assigning new data, the old data is de-referenced via :cpp:func:`Mat::release` . + :param m: Assigned, right-hand-side matrix. Matrix assignment is an O(1) operation. This means that no data is copied but the data is shared and the reference counter, if any, is incremented. Before assigning new data, the old data is de-referenced via :ocv:func:`Mat::release` . :param expr: Assigned matrix expression object. As opposite to the first form of the assignment operation, the second form can reuse already allocated matrix if it has the right size and type to fit the matrix expression result. It is automatically handled by the real function that the matrix expressions is expanded to. For example, ``C=A+B`` is expanded to ``add(A, B, C)`` , and :func:`add` takes care of automatic ``C`` reallocation. @@ -813,7 +813,7 @@ These are available assignment operators. Since they all are very different, mak Mat::operator MatExpr ------------------------- -.. cpp:function:: Mat::operator MatExpr_() const +.. ocv:function:: Mat::operator MatExpr_() const Provides a ``Mat`` -to- ``MatExpr`` cast operator. @@ -822,7 +822,7 @@ The cast operator should not be called explicitly. It is used internally by the Mat::row ------------ -.. cpp:function:: Mat Mat::row(int i) const +.. ocv:function:: Mat Mat::row(int i) const Creates a matrix header for the specified matrix row. @@ -846,7 +846,7 @@ The method makes a new header for the specified matrix row and returns it. This This happens because ``A.row(i)`` forms a temporary header that is further assigned to another header. Remember that each of these operations is O(1), that is, no data is copied. Thus, the above assignment is not true if you may have expected the j-th row to be copied to the i-th row. To achieve that, you should either turn this simple assignment into an expression or use the - :cpp:func:`Mat::copyTo` method: :: + :ocv:func:`Mat::copyTo` method: :: Mat A; ... @@ -858,21 +858,21 @@ The method makes a new header for the specified matrix row and returns it. This Mat::col ------------ -.. cpp:function:: Mat Mat::col(int j) const +.. ocv:function:: Mat Mat::col(int j) const Creates a matrix header for the specified matrix column. :param j: A 0-based column index. The method makes a new header for the specified matrix column and returns it. This is an O(1) operation, regardless of the matrix size. The underlying data of the new matrix is shared with the original matrix. See also the -:cpp:func:`Mat::row` description. +:ocv:func:`Mat::row` description. Mat::rowRange ----------------- -.. cpp:function:: Mat Mat::rowRange(int startrow, int endrow) const +.. ocv:function:: Mat Mat::rowRange(int startrow, int endrow) const -.. cpp:function:: Mat Mat::rowRange(const Range& r) const +.. ocv:function:: Mat Mat::rowRange(const Range& r) const Creates a matrix header for the specified row span. @@ -880,17 +880,17 @@ Mat::rowRange :param endrow: A 0-based ending index of the row span. - :param r: :cpp:class:`Range` structure containing both the start and the end indices. + :param r: :ocv:class:`Range` structure containing both the start and the end indices. The method makes a new header for the specified row span of the matrix. Similarly to -:cpp:func:`Mat::row` and -:cpp:func:`Mat::col` , this is an O(1) operation. +:ocv:func:`Mat::row` and +:ocv:func:`Mat::col` , this is an O(1) operation. Mat::colRange ----------------- -.. cpp:function:: Mat Mat::colRange(int startcol, int endcol) const +.. ocv:function:: Mat Mat::colRange(int startcol, int endcol) const -.. cpp:function:: Mat Mat::colRange(const Range& r) const +.. ocv:function:: Mat Mat::colRange(const Range& r) const Creates a matrix header for the specified row span. @@ -898,17 +898,17 @@ Mat::colRange :param endcol: A 0-based ending index of the column span. - :param r: :cpp:class:`Range` structure containing both the start and the end indices. + :param r: :ocv:class:`Range` structure containing both the start and the end indices. The method makes a new header for the specified column span of the matrix. Similarly to -:cpp:func:`Mat::row` and -:cpp:func:`Mat::col` , this is an O(1) operation. +:ocv:func:`Mat::row` and +:ocv:func:`Mat::col` , this is an O(1) operation. Mat::diag ------------- -.. cpp:function:: Mat Mat::diag(int d) const +.. ocv:function:: Mat Mat::diag(int d) const -.. cpp:function:: static Mat Mat::diag(const Mat& matD) +.. ocv:function:: static Mat Mat::diag(const Mat& matD) Extracts a diagonal from a matrix, or creates a diagonal matrix. @@ -923,12 +923,12 @@ Mat::diag :param matD: Single-column matrix that forms a diagonal matrix. The method makes a new header for the specified matrix diagonal. The new matrix is represented as a single-column matrix. Similarly to -:cpp:func:`Mat::row` and -:cpp:func:`Mat::col` , this is an O(1) operation. +:ocv:func:`Mat::row` and +:ocv:func:`Mat::col` , this is an O(1) operation. Mat::clone -------------- -.. cpp:function:: Mat Mat::clone() const +.. ocv:function:: Mat Mat::clone() const Creates a full copy of the array and the underlying data. @@ -937,8 +937,8 @@ The method creates a full copy of the array. The original ``step[]`` is not take Mat::copyTo --------------- -.. cpp:function:: void Mat::copyTo( OutputArray m ) const -.. cpp:function:: void Mat::copyTo( OutputArray m, InputArray mask ) const +.. ocv:function:: void Mat::copyTo( OutputArray m ) const +.. ocv:function:: void Mat::copyTo( OutputArray m, InputArray mask ) const Copies the matrix to another one. @@ -957,7 +957,7 @@ When the operation mask is specified, and the ``Mat::create`` call shown above r Mat::convertTo ------------------ -.. cpp:function:: void Mat::convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const +.. ocv:function:: void Mat::convertTo( OutputArray m, int rtype, double alpha=1, double beta=0 ) const Converts an array to another datatype with optional scaling. @@ -978,7 +978,7 @@ The method converts source pixel values to the target datatype. ``saturate_cast< Mat::assignTo ----------------- -.. cpp:function:: void Mat::assignTo( Mat& m, int type=-1 ) const +.. ocv:function:: void Mat::assignTo( Mat& m, int type=-1 ) const Provides a functional form of ``convertTo``. @@ -991,7 +991,7 @@ This is an internally used method called by the Mat::setTo -------------- -.. cpp:function:: Mat& Mat::setTo(const Scalar& s, InputArray mask=noArray()) +.. ocv:function:: Mat& Mat::setTo(const Scalar& s, InputArray mask=noArray()) Sets all or some of the array elements to the specified value. @@ -1002,7 +1002,7 @@ Mat::setTo Mat::reshape ---------------- -.. cpp:function:: Mat Mat::reshape(int cn, int rows=0) const +.. ocv:function:: Mat Mat::reshape(int cn, int rows=0) const Changes the shape and/or the number of channels of a 2D matrix without copying the data. @@ -1017,7 +1017,7 @@ The method makes a new matrix header for ``*this`` elements. The new matrix may * No data is copied. That is, this is an O(1) operation. Consequently, if you change the number of rows, or the operation changes the indices of elements row in some other way, the matrix must be continuous. See - :cpp:func:`Mat::isContinuous` . + :ocv:func:`Mat::isContinuous` . For example, if there is a set of 3D points stored as an STL vector, and you want to represent the points as a ``3xN`` matrix, do the following: :: @@ -1035,7 +1035,7 @@ For example, if there is a set of 3D points stored as an STL vector, and you wan Mat::t ---------- -.. cpp:function:: MatExpr Mat::t() const +.. ocv:function:: MatExpr Mat::t() const Transposes a matrix. @@ -1047,7 +1047,7 @@ The method performs matrix transposition by means of matrix expressions. It does Mat::inv ------------ -.. cpp:function:: MatExpr Mat::inv(int method=DECOMP_LU) const +.. ocv:function:: MatExpr Mat::inv(int method=DECOMP_LU) const Inverses a matrix. @@ -1064,7 +1064,7 @@ The method performs a matrix inversion by means of matrix expressions. This mean Mat::mul ------------ -.. cpp:function:: MatExpr Mat::mul(InputArray m, double scale=1) const +.. ocv:function:: MatExpr Mat::mul(InputArray m, double scale=1) const Performs an element-wise multiplication or division of the two matrices. @@ -1081,7 +1081,7 @@ Example: :: Mat::cross -------------- -.. cpp:function:: Mat Mat::cross(InputArray m) const +.. ocv:function:: Mat Mat::cross(InputArray m) const Computes a cross-product of two 3-element vectors. @@ -1092,7 +1092,7 @@ The method computes a cross-product of two 3-element vectors. The vectors must b Mat::dot ------------ -.. cpp:function:: double Mat::dot(InputArray m) const +.. ocv:function:: double Mat::dot(InputArray m) const Computes a dot-product of two vectors. @@ -1103,9 +1103,9 @@ The method computes a dot-product of two matrices. If the matrices are not singl Mat::zeros -------------- -.. cpp:function:: static MatExpr Mat::zeros(int rows, int cols, int type) -.. cpp:function:: static MatExpr Mat::zeros(Size size, int type) -.. cpp:function:: static MatExpr Mat::zeros(int ndims, const int* sizes, int type) +.. ocv:function:: static MatExpr Mat::zeros(int rows, int cols, int type) +.. ocv:function:: static MatExpr Mat::zeros(Size size, int type) +.. ocv:function:: static MatExpr Mat::zeros(int ndims, const int* sizes, int type) Returns a zero array of the specified size and type. @@ -1132,9 +1132,9 @@ In the example above, a new matrix is allocated only if ``A`` is not a 3x3 float Mat::ones ------------- -.. cpp:function:: static MatExpr Mat::ones(int rows, int cols, int type) -.. cpp:function:: static MatExpr Mat::ones(Size size, int type) -.. cpp:function:: static MatExpr Mat::ones(int ndims, const int* sizes, int type) +.. ocv:function:: static MatExpr Mat::ones(int rows, int cols, int type) +.. ocv:function:: static MatExpr Mat::ones(Size size, int type) +.. ocv:function:: static MatExpr Mat::ones(int ndims, const int* sizes, int type) Returns an array of all 1's of the specified size and type. @@ -1151,7 +1151,7 @@ Mat::ones :param type: Created matrix type. The method returns a Matlab-style 1's array initializer, similarly to -:cpp:func:`Mat::zeros`. Note that using this method you can initialize an array with an arbitrary value, using the following Matlab idiom: :: +:ocv:func:`Mat::zeros`. Note that using this method you can initialize an array with an arbitrary value, using the following Matlab idiom: :: Mat A = Mat::ones(100, 100, CV_8U)*3; // make 100x100 matrix filled with 3. @@ -1161,8 +1161,8 @@ The above operation does not form a 100x100 matrix of 1's and then multiply it b Mat::eye ------------ -.. cpp:function:: static MatExpr Mat::eye(int rows, int cols, int type) -.. cpp:function:: static MatExpr Mat::eye(Size size, int type) +.. ocv:function:: static MatExpr Mat::eye(int rows, int cols, int type) +.. ocv:function:: static MatExpr Mat::eye(Size size, int type) Returns an identity matrix of the specified size and type. @@ -1175,8 +1175,8 @@ Mat::eye :param type: Created matrix type. The method returns a Matlab-style identity matrix initializer, similarly to -:cpp:func:`Mat::zeros`. Similarly to -:cpp:func:`Mat::ones`, you can use a scale operation to create a scaled identity matrix efficiently: :: +:ocv:func:`Mat::zeros`. Similarly to +:ocv:func:`Mat::ones`, you can use a scale operation to create a scaled identity matrix efficiently: :: // make a 4x4 diagonal matrix with 0.1's on the diagonal. Mat A = Mat::eye(4, 4, CV_32F)*0.1; @@ -1184,9 +1184,9 @@ The method returns a Matlab-style identity matrix initializer, similarly to Mat::create --------------- -.. cpp:function:: void Mat::create(int rows, int cols, int type) -.. cpp:function:: void Mat::create(Size size, int type) -.. cpp:function:: void Mat::create(int ndims, const int* sizes, int type) +.. ocv:function:: void Mat::create(int rows, int cols, int type) +.. ocv:function:: void Mat::create(Size size, int type) +.. ocv:function:: void Mat::create(int ndims, const int* sizes, int type) Allocates new array data if needed. @@ -1206,7 +1206,7 @@ This is one of the key ``Mat`` methods. Most new-style OpenCV functions and meth #. If the current array shape and the type match the new ones, return immediately. Otherwise, de-reference the previous data by calling - :cpp:func:`Mat::release`. + :ocv:func:`Mat::release`. #. Initialize the new header. @@ -1238,29 +1238,29 @@ because ``cvtColor`` , as well as the most of OpenCV functions, calls ``Mat::cre Mat::addref --------------- -.. cpp:function:: void Mat::addref() +.. ocv:function:: void Mat::addref() Increments the reference counter. The method increments the reference counter associated with the matrix data. If the matrix header points to an external data set (see -:cpp:func:`Mat::Mat` ), the reference counter is NULL, and the method has no effect in this case. Normally, to avoid memory leaks, the method should not be called explicitly. It is called implicitly by the matrix assignment operator. The reference counter increment is an atomic operation on the platforms that support it. Thus, it is safe to operate on the same matrices asynchronously in different threads. +:ocv:func:`Mat::Mat` ), the reference counter is NULL, and the method has no effect in this case. Normally, to avoid memory leaks, the method should not be called explicitly. It is called implicitly by the matrix assignment operator. The reference counter increment is an atomic operation on the platforms that support it. Thus, it is safe to operate on the same matrices asynchronously in different threads. Mat::release ---------------- -.. cpp:function:: void Mat::release() +.. ocv:function:: void Mat::release() Decrements the reference counter and deallocates the matrix if needed. The method decrements the reference counter associated with the matrix data. When the reference counter reaches 0, the matrix data is deallocated and the data and the reference counter pointers are set to NULL's. If the matrix header points to an external data set (see -:cpp:func:`Mat::Mat` ), the reference counter is NULL, and the method has no effect in this case. +:ocv:func:`Mat::Mat` ), the reference counter is NULL, and the method has no effect in this case. This method can be called manually to force the matrix data deallocation. But since this method is automatically called in the destructor, or by any other method that changes the data pointer, it is usually not needed. The reference counter decrement and check for 0 is an atomic operation on the platforms that support it. Thus, it is safe to operate on the same matrices asynchronously in different threads. Mat::resize --------------- -.. cpp:function:: void Mat::resize( size_t sz ) -.. cpp:function:: void Mat::resize( size_t sz, const Scalar& s ) +.. ocv:function:: void Mat::resize( size_t sz ) +.. ocv:function:: void Mat::resize( size_t sz, const Scalar& s ) Changes the number of matrix rows. @@ -1272,7 +1272,7 @@ The methods change the number of matrix rows. If the matrix is reallocated, the Mat::reserve --------------- -.. cpp:function:: void Mat::reserve( size_t sz ) +.. ocv:function:: void Mat::reserve( size_t sz ) Reserves space for the certain number of rows. @@ -1282,8 +1282,8 @@ The method reserves space for ``sz`` rows. If the matrix already has enough spac Mat::push_back -------------- -.. cpp:function:: template void Mat::push_back(const T& elem) -.. cpp:function:: void Mat::push_back(const Mat& elem) +.. ocv:function:: template void Mat::push_back(const T& elem) +.. ocv:function:: void Mat::push_back(const Mat& elem) Adds elements to the bottom of the matrix. @@ -1293,7 +1293,7 @@ The methods add one or more elements to the bottom of the matrix. They emulate t Mat::pop_back ------------- -.. cpp:function:: template void Mat::pop_back(size_t nelems=1) +.. ocv:function:: template void Mat::pop_back(size_t nelems=1) Removes elements from the bottom of the matrix. @@ -1304,7 +1304,7 @@ The method removes one or more rows from the bottom of the matrix. Mat::locateROI ------------------ -.. cpp:function:: void Mat::locateROI( Size& wholeSize, Point& ofs ) const +.. ocv:function:: void Mat::locateROI( Size& wholeSize, Point& ofs ) const Locates the matrix header within a parent matrix. @@ -1313,15 +1313,15 @@ Mat::locateROI :param ofs: Output parameter that contains an offset of ``*this`` inside the whole matrix. After you extracted a submatrix from a matrix using -:cpp:func:`Mat::row`, -:cpp:func:`Mat::col`, -:cpp:func:`Mat::rowRange`, -:cpp:func:`Mat::colRange` , and others, the resultant submatrix points just to the part of the original big matrix. However, each submatrix contains information (represented by ``datastart`` and ``dataend`` fields) that helps reconstruct the original matrix size and the position of the extracted submatrix within the original matrix. The method ``locateROI`` does exactly that. +:ocv:func:`Mat::row`, +:ocv:func:`Mat::col`, +:ocv:func:`Mat::rowRange`, +:ocv:func:`Mat::colRange` , and others, the resultant submatrix points just to the part of the original big matrix. However, each submatrix contains information (represented by ``datastart`` and ``dataend`` fields) that helps reconstruct the original matrix size and the position of the extracted submatrix within the original matrix. The method ``locateROI`` does exactly that. Mat::adjustROI ------------------ -.. cpp:function:: Mat& Mat::adjustROI( int dtop, int dbottom, int dleft, int dright ) +.. ocv:function:: Mat& Mat::adjustROI( int dtop, int dbottom, int dleft, int dright ) Adjusts a submatrix size and position within the parent matrix. @@ -1334,7 +1334,7 @@ Mat::adjustROI :param dright: Shift of the right submatrix boundary to the right. The method is complimentary to -:cpp:func:`Mat::locateROI` . The typical use of these functions is to determine the submatrix position within the parent matrix and then shift the position somehow. Typically, it can be required for filtering operations when pixels outside of the ROI should be taken into account. When all the method parameters are positive, the ROI needs to grow in all directions by the specified amount, for example: :: +:ocv:func:`Mat::locateROI` . The typical use of these functions is to determine the submatrix position within the parent matrix and then shift the position somehow. Typically, it can be required for filtering operations when pixels outside of the ROI should be taken into account. When all the method parameters are positive, the ROI needs to grow in all directions by the specified amount, for example: :: A.adjustROI(2, 2, 2, 2); @@ -1344,19 +1344,19 @@ In this example, the matrix size is increased by 4 elements in each direction. T It is your responsibility to make sure ``adjustROI`` does not cross the parent matrix boundary. If it does, the function signals an error. The function is used internally by the OpenCV filtering functions, like -:cpp:func:`filter2D` , morphological operations, and so on. +:ocv:func:`filter2D` , morphological operations, and so on. See Also: -:cpp:func:`copyMakeBorder` +:ocv:func:`copyMakeBorder` Mat::operator() ------------------- -.. cpp:function:: Mat Mat::operator()( Range rowRange, Range colRange ) const +.. ocv:function:: Mat Mat::operator()( Range rowRange, Range colRange ) const -.. cpp:function:: Mat Mat::operator()( const Rect& roi ) const +.. ocv:function:: Mat Mat::operator()( const Rect& roi ) const -.. cpp:function:: Mat Mat::operator()( const Ranges* ranges ) const +.. ocv:function:: Mat Mat::operator()( const Ranges* ranges ) const Extracts a rectangular submatrix. @@ -1369,15 +1369,15 @@ Mat::operator() :param ranges: Array of selected ranges along each array dimension. The operators make a new header for the specified sub-array of ``*this`` . They are the most generalized forms of -:cpp:func:`Mat::row`, -:cpp:func:`Mat::col`, -:cpp:func:`Mat::rowRange`, and -:cpp:func:`Mat::colRange` . For example, ``A(Range(0, 10), Range::all())`` is equivalent to ``A.rowRange(0, 10)`` . Similarly to all of the above, the operators are O(1) operations, that is, no matrix data is copied. +:ocv:func:`Mat::row`, +:ocv:func:`Mat::col`, +:ocv:func:`Mat::rowRange`, and +:ocv:func:`Mat::colRange` . For example, ``A(Range(0, 10), Range::all())`` is equivalent to ``A.rowRange(0, 10)`` . Similarly to all of the above, the operators are O(1) operations, that is, no matrix data is copied. Mat::operator CvMat ----------------------- -.. cpp:function:: Mat::operator CvMat() const +.. ocv:function:: Mat::operator CvMat() const Creates the ``CvMat`` header for the matrix. @@ -1395,7 +1395,7 @@ where ``mycvOldFunc`` is a function written to work with OpenCV 1.x data structu Mat::operator IplImage -------------------------- -.. cpp:function:: Mat::operator IplImage() const +.. ocv:function:: Mat::operator IplImage() const Creates the ``IplImage`` header for the matrix. @@ -1403,7 +1403,7 @@ The operator creates the ``IplImage`` header for the matrix without copying the Mat::total -------------- -.. cpp:function:: size_t Mat::total() const +.. ocv:function:: size_t Mat::total() const Returns the total number of array elements. @@ -1411,14 +1411,14 @@ The method returns the number of array elements (a number of pixels if the array Mat::isContinuous --------------------- -.. cpp:function:: bool Mat::isContinuous() const +.. ocv:function:: bool Mat::isContinuous() const Reports whether the matrix is continuous or not. The method returns ``true`` if the matrix elements are stored continuously without gaps at the end of each row. Otherwise, it returns ``false``. Obviously, ``1x1`` or ``1xN`` matrices are always continuous. Matrices created with -:cpp:func:`Mat::create` are always continuous. But if you extract a part of the matrix using -:cpp:func:`Mat::col`, -:cpp:func:`Mat::diag` , and so on, or constructed a matrix header for externally allocated data, such matrices may no longer have this property. +:ocv:func:`Mat::create` are always continuous. But if you extract a part of the matrix using +:ocv:func:`Mat::col`, +:ocv:func:`Mat::diag` , and so on, or constructed a matrix header for externally allocated data, such matrices may no longer have this property. The continuity flag is stored as a bit in the ``Mat::flags`` field and is computed automatically when you construct a matrix header. Thus, the continuity check is a very fast operation, though theoretically it could be done as follows: :: @@ -1477,12 +1477,12 @@ The method is used in quite a few of OpenCV functions. The point is that element This approach, while being very simple, can boost the performance of a simple element-operation by 10-20 percents, especially if the image is rather small and the operation is quite simple. Another OpenCV idiom in this function, a call of -:cpp:func:`Mat::create` for the destination array, that allocates the destination array unless it already has the proper size and type. And while the newly allocated arrays are always continuous, you still need to check the destination array because :cpp:func:`create` does not always allocate a new matrix. +:ocv:func:`Mat::create` for the destination array, that allocates the destination array unless it already has the proper size and type. And while the newly allocated arrays are always continuous, you still need to check the destination array because :ocv:func:`create` does not always allocate a new matrix. Mat::elemSize ----------------- -.. cpp:function:: size_t Mat::elemSize(void) const +.. ocv:function:: size_t Mat::elemSize(void) const Returns the matrix element size in bytes. @@ -1491,7 +1491,7 @@ The method returns the matrix element size in bytes. For example, if the matrix Mat::elemSize1 ------------------ -.. cpp:function:: size_t Mat::elemSize() const +.. ocv:function:: size_t Mat::elemSize() const Returns the size of each matrix element channel in bytes. @@ -1500,7 +1500,7 @@ The method returns the matrix element channel size in bytes, that is, it ignores Mat::type ------------- -.. cpp:function:: int Mat::type() const +.. ocv:function:: int Mat::type() const Returns the type of a matrix element. @@ -1509,7 +1509,7 @@ The method returns a matrix element type. This is an identifier compatible with Mat::depth -------------- -.. cpp:function:: int Mat::depth() const +.. ocv:function:: int Mat::depth() const Returns the depth of a matrix element. @@ -1532,7 +1532,7 @@ The method returns the identifier of the matrix element depth (the type of each Mat::channels ----------------- -.. cpp:function:: int Mat::channels() const +.. ocv:function:: int Mat::channels() const Returns the number of matrix channels. @@ -1541,17 +1541,17 @@ The method returns the number of matrix channels. Mat::step1 -------------- -.. cpp:function:: size_t Mat::step1() const +.. ocv:function:: size_t Mat::step1() const Returns a normalized step. The method returns a matrix step divided by -:cpp:func:`Mat::elemSize1()` . It can be useful to quickly access an arbitrary matrix element. +:ocv:func:`Mat::elemSize1()` . It can be useful to quickly access an arbitrary matrix element. Mat::size ------------- -.. cpp:function:: Size Mat::size() const +.. ocv:function:: Size Mat::size() const Returns a matrix size. @@ -1560,7 +1560,7 @@ The method returns a matrix size: ``Size(cols, rows)`` . Mat::empty -------------- -.. cpp:function:: bool Mat::empty() const +.. ocv:function:: bool Mat::empty() const Returns ``true`` if the array has no elemens. @@ -1569,43 +1569,43 @@ The method returns ``true`` if ``Mat::total()`` is 0 or if ``Mat::data`` is NULL Mat::ptr ------------ -.. cpp:function:: uchar* Mat::ptr(int i=0) +.. ocv:function:: uchar* Mat::ptr(int i=0) -.. cpp:function:: const uchar* Mat::ptr(int i=0) const +.. ocv:function:: const uchar* Mat::ptr(int i=0) const -.. cpp:function:: template _Tp* Mat::ptr(int i=0) +.. ocv:function:: template _Tp* Mat::ptr(int i=0) -.. cpp:function:: template const _Tp* Mat::ptr(int i=0) const +.. ocv:function:: template const _Tp* Mat::ptr(int i=0) const Returns a pointer to the specified matrix row. :param i: A 0-based row index. The methods return ``uchar*`` or typed pointer to the specified matrix row. See the sample in -:cpp:func:`Mat::isContinuous` () to know how to use these methods. +:ocv:func:`Mat::isContinuous` () to know how to use these methods. Mat::at ----------- -.. cpp:function:: template T& Mat::at(int i) const +.. ocv:function:: template T& Mat::at(int i) const -.. cpp:function:: template const T& Mat::at(int i) const +.. ocv:function:: template const T& Mat::at(int i) const -.. cpp:function:: template T& Mat::at(int i, int j) +.. ocv:function:: template T& Mat::at(int i, int j) -.. cpp:function:: template const T& Mat::at(int i, int j) const +.. ocv:function:: template const T& Mat::at(int i, int j) const -.. cpp:function:: template T& Mat::at(Point pt) +.. ocv:function:: template T& Mat::at(Point pt) -.. cpp:function:: template const T& Mat::at(Point pt) const +.. ocv:function:: template const T& Mat::at(Point pt) const -.. cpp:function:: template T& Mat::at(int i, int j, int k) +.. ocv:function:: template T& Mat::at(int i, int j, int k) -.. cpp:function:: template const T& Mat::at(int i, int j, int k) const +.. ocv:function:: template const T& Mat::at(int i, int j, int k) const -.. cpp:function:: template T& Mat::at(const int* idx) +.. ocv:function:: template T& Mat::at(const int* idx) -.. cpp:function:: template const T& Mat::at(const int* idx) const +.. ocv:function:: template const T& Mat::at(const int* idx) const Returns a reference to the specified array element. @@ -1630,7 +1630,7 @@ The example below initializes a Hilbert matrix: :: Mat::begin -------------- -.. cpp:function:: template MatIterator_<_Tp> Mat::begin() template MatConstIterator_<_Tp> Mat::begin() const +.. ocv:function:: template MatIterator_<_Tp> Mat::begin() template MatConstIterator_<_Tp> Mat::begin() const Returns the matrix iterator and sets it to the first matrix element. @@ -1669,8 +1669,8 @@ The methods return the matrix read-only or read-write iterators. The use of matr Mat::end ------------ -.. cpp:function:: template MatIterator_<_Tp> Mat::end() -.. cpp:function:: template MatConstIterator_<_Tp> Mat::end() const +.. ocv:function:: template MatIterator_<_Tp> Mat::end() +.. ocv:function:: template MatConstIterator_<_Tp> Mat::end() const Returns the matrix iterator and sets it to the after-last matrix element. @@ -1678,10 +1678,10 @@ The methods return the matrix read-only or read-write iterators, set to the poin Mat\_ ----- -.. cpp:class:: Mat_ +.. ocv:class:: Mat_ Template matrix class derived from -:cpp:class:`Mat` . :: +:ocv:class:`Mat` . :: template class Mat_ : public Mat { @@ -1729,7 +1729,7 @@ To use ``Mat_`` for multi-channel images/matrices, pass ``Vec`` as a ``Mat_`` pa NAryMatIterator -------------- -.. cpp:class:: NAryMatIterator +.. ocv:class:: NAryMatIterator n-ary multi-dimensional array iterator. :: @@ -1800,7 +1800,7 @@ The example below illustrates how you can compute a normalized and threshold 3D SparseMat --------- -.. cpp:class:: SparseMat +.. ocv:class:: SparseMat Sparse n-dimensional array. :: @@ -1999,7 +1999,7 @@ Sparse n-dimensional array. :: The class ``SparseMat`` represents multi-dimensional sparse numerical arrays. Such a sparse array can store elements of any type that -:cpp:class:`Mat` can store. *Sparse* means that only non-zero elements are stored (though, as a result of operations on a sparse matrix, some of its stored elements can actually become 0. It is up to you to detect such elements and delete them using ``SparseMat::erase`` ). The non-zero elements are stored in a hash table that grows when it is filled so that the search time is O(1) in average (regardless of whether element is there or not). Elements can be accessed using the following methods: +:ocv:class:`Mat` can store. *Sparse* means that only non-zero elements are stored (though, as a result of operations on a sparse matrix, some of its stored elements can actually become 0. It is up to you to detect such elements and delete them using ``SparseMat::erase`` ). The non-zero elements are stored in a hash table that grows when it is filled so that the search time is O(1) in average (regardless of whether element is there or not). Elements can be accessed using the following methods: * Query operations ( ``SparseMat::ptr`` and the higher-level ``SparseMat::ref``, ``SparseMat::value`` and ``SparseMat::find`` ), for example: @@ -2020,7 +2020,7 @@ The class ``SparseMat`` represents multi-dimensional sparse numerical arrays. Su .. * - Sparse matrix iterators. They are similar to ``MatIterator`` but different from :cpp:class:`NAryMatIterator`. That is, the iteration loop is familiar to STL users: + Sparse matrix iterators. They are similar to ``MatIterator`` but different from :ocv:class:`NAryMatIterator`. That is, the iteration loop is familiar to STL users: :: @@ -2080,10 +2080,10 @@ The class ``SparseMat`` represents multi-dimensional sparse numerical arrays. Su SparseMat\_ ----------- -.. cpp:class:: SparseMat_ +.. ocv:class:: SparseMat_ Template sparse n-dimensional array class derived from -:cpp:class:`SparseMat` :: +:ocv:class:`SparseMat` :: template class SparseMat_ : public SparseMat { @@ -2133,7 +2133,7 @@ Template sparse n-dimensional array class derived from SparseMatConstIterator_<_Tp> end() const; }; -``SparseMat_`` is a thin wrapper on top of :cpp:class:`SparseMat` created in the same way as ``Mat_`` . +``SparseMat_`` is a thin wrapper on top of :ocv:class:`SparseMat` created in the same way as ``Mat_`` . It simplifies notation of some operations. :: int sz[] = {10, 20, 30}; diff --git a/modules/core/doc/clustering.rst b/modules/core/doc/clustering.rst index 403aeb6..7479d4c 100644 --- a/modules/core/doc/clustering.rst +++ b/modules/core/doc/clustering.rst @@ -10,7 +10,7 @@ Clustering kmeans ------ -.. cpp:function:: double kmeans( InputArray samples, int clusterCount, InputOutputArray labels, TermCriteria termcrit, int attempts, int flags, OutputArray centers=noArray() ) +.. ocv:function:: double kmeans( InputArray samples, int clusterCount, InputOutputArray labels, TermCriteria termcrit, int attempts, int flags, OutputArray centers=noArray() ) Finds centers of clusters and groups input samples around the clusters. @@ -57,9 +57,9 @@ attempts to 1, initialize labels each time using a custom algorithm, pass them w partition ------------- -.. cpp:function:: template int +.. ocv:function:: template int -.. cpp:function:: partition( const vector<_Tp>& vec, vector& labels, _EqPredicate predicate=_EqPredicate()) +.. ocv:function:: partition( const vector<_Tp>& vec, vector& labels, _EqPredicate predicate=_EqPredicate()) Splits an element set into equivalency classes. diff --git a/modules/core/doc/drawing_functions.rst b/modules/core/doc/drawing_functions.rst index 103dc75..86f2549 100644 --- a/modules/core/doc/drawing_functions.rst +++ b/modules/core/doc/drawing_functions.rst @@ -10,7 +10,7 @@ with ``CV_RGB`` or the :ref:`Scalar` constructor ) for color images and brightness for grayscale images. For color images, the channel ordering is normally *Blue, Green, Red*. -This is what :cpp:func:`imshow`, :cpp:func:`imread`, and :cpp:func:`imwrite` expect. +This is what :ocv:func:`imshow`, :ocv:func:`imread`, and :ocv:func:`imwrite` expect. So, if you form a color using the :ref:`Scalar` constructor, it should look like: @@ -19,7 +19,7 @@ So, if you form a color using the \texttt{Scalar} (blue \_ component, green \_ component, red \_ component[, alpha \_ component]) If you are using your own image rendering and I/O functions, you can use any channel ordering. The drawing functions process each channel independently and do not depend on the channel order or even on the used color space. The whole image can be converted from BGR to RGB or to a different color space using -:cpp:func:`cvtColor` . +:ocv:func:`cvtColor` . If a drawn figure is partially or completely outside the image, the drawing functions clip it. Also, many drawing functions can handle pixel coordinates specified with sub-pixel accuracy. This means that the coordinates can be passed as fixed-point numbers encoded as integers. The number of fractional bits is specified by the ``shift`` parameter and the real point coordinates are calculated as :math:`\texttt{Point}(x,y)\rightarrow\texttt{Point2f}(x*2^{-shift},y*2^{-shift})` . This feature is especially effective when rendering antialiased shapes. @@ -32,7 +32,7 @@ The functions do not support alpha-transparency when the target image is 4-chann circle ---------- -.. cpp:function:: void circle(Mat& img, Point center, int radius, const Scalar& color, int thickness=1, int lineType=8, int shift=0) +.. ocv:function:: void circle(Mat& img, Point center, int radius, const Scalar& color, int thickness=1, int lineType=8, int shift=0) Draws a circle. @@ -46,7 +46,7 @@ circle :param thickness: Thickness of the circle outline if positive. Negative thickness means that a filled circle is to be drawn. - :param lineType: Type of the circle boundary. See :cpp:func:`line` description. + :param lineType: Type of the circle boundary. See :ocv:func:`line` description. :param shift: Number of fractional bits in the center's coordinates and in the radius value. @@ -56,9 +56,9 @@ The function ``circle`` draws a simple or filled circle with a given center and clipLine ------------ -.. cpp:function:: bool clipLine(Size imgSize, Point& pt1, Point& pt2) +.. ocv:function:: bool clipLine(Size imgSize, Point& pt1, Point& pt2) -.. cpp:function:: bool clipLine(Rect imgRect, Point& pt1, Point& pt2) +.. ocv:function:: bool clipLine(Rect imgRect, Point& pt1, Point& pt2) Clips the line against the image rectangle. @@ -77,9 +77,9 @@ They return ``false`` if the line segment is completely outside the rectangle. O ellipse ----------- -.. cpp:function:: void ellipse(Mat& img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar& color, int thickness=1, int lineType=8, int shift=0) +.. ocv:function:: void ellipse(Mat& img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar& color, int thickness=1, int lineType=8, int shift=0) -.. cpp:function:: void ellipse(Mat& img, const RotatedRect& box, const Scalar& color, int thickness=1, int lineType=8) +.. ocv:function:: void ellipse(Mat& img, const RotatedRect& box, const Scalar& color, int thickness=1, int lineType=8) Draws a simple or thick elliptic arc or fills an ellipse sector. @@ -101,15 +101,15 @@ ellipse :param thickness: Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn. - :param lineType: Type of the ellipse boundary. See :cpp:func:`line` description. + :param lineType: Type of the ellipse boundary. See :ocv:func:`line` description. :param shift: Number of fractional bits in the center's coordinates and axes' values. The functions ``ellipse`` with less parameters draw an ellipse outline, a filled ellipse, an elliptic arc, or a filled ellipse sector. A piecewise-linear curve is used to approximate the elliptic arc boundary. If you need more control of the ellipse rendering, you can retrieve the curve using -:cpp:func:`ellipse2Poly` and then render it with -:cpp:func:`polylines` or fill it with -:cpp:func:`fillPoly` . If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass ``startAngle=0`` and ``endAngle=360`` . The picture below explains the meaning of the parameters. +:ocv:func:`ellipse2Poly` and then render it with +:ocv:func:`polylines` or fill it with +:ocv:func:`fillPoly` . If you use the first variant of the function and want to draw the whole ellipse, not an arc, pass ``startAngle=0`` and ``endAngle=360`` . The picture below explains the meaning of the parameters. **Figure 1. Parameters of Elliptic Arc** @@ -119,15 +119,15 @@ A piecewise-linear curve is used to approximate the elliptic arc boundary. If yo ellipse2Poly ---------------- -.. cpp:function:: void ellipse2Poly( Point center, Size axes, int angle, int startAngle, int endAngle, int delta, vector& pts ) +.. ocv:function:: void ellipse2Poly( Point center, Size axes, int angle, int startAngle, int endAngle, int delta, vector& pts ) Approximates an elliptic arc with a polyline. :param center: Center of the arc. - :param axes: Half-sizes of the arc. See :cpp:func:`ellipse` for details. + :param axes: Half-sizes of the arc. See :ocv:func:`ellipse` for details. - :param angle: Rotation angle of the ellipse in degrees. See :cpp:func:`ellipse` for details. + :param angle: Rotation angle of the ellipse in degrees. See :ocv:func:`ellipse` for details. :param startAngle: Starting angle of the elliptic arc in degrees. @@ -138,13 +138,13 @@ ellipse2Poly :param pts: Output vector of polyline vertices. The function ``ellipse2Poly`` computes the vertices of a polyline that approximates the specified elliptic arc. It is used by -:cpp:func:`ellipse` . +:ocv:func:`ellipse` . .. index:: fillConvexPoly fillConvexPoly ------------------ -.. cpp:function:: void fillConvexPoly(Mat& img, const Point* pts, int npts, const Scalar& color, int lineType=8, int shift=0) +.. ocv:function:: void fillConvexPoly(Mat& img, const Point* pts, int npts, const Scalar& color, int lineType=8, int shift=0) Fills a convex polygon. @@ -156,7 +156,7 @@ fillConvexPoly :param color: Polygon color. - :param lineType: Type of the polygon boundaries. See :cpp:func:`line` description. + :param lineType: Type of the polygon boundaries. See :ocv:func:`line` description. :param shift: Number of fractional bits in the vertex coordinates. @@ -168,7 +168,7 @@ that is, a polygon whose contour intersects every horizontal line (scan line) tw fillPoly ------------ -.. cpp:function:: void fillPoly(Mat& img, const Point** pts, const int* npts, int ncontours, const Scalar& color, int lineType=8, int shift=0, Point offset=Point() ) +.. ocv:function:: void fillPoly(Mat& img, const Point** pts, const int* npts, int ncontours, const Scalar& color, int lineType=8, int shift=0, Point offset=Point() ) Fills the area bounded by one or more polygons. @@ -182,7 +182,7 @@ fillPoly :param color: Polygon color. - :param lineType: Type of the polygon boundaries. See :cpp:func:`line` description. + :param lineType: Type of the polygon boundaries. See :ocv:func:`line` description. :param shift: Number of fractional bits in the vertex coordinates. @@ -193,17 +193,17 @@ areas with holes, contours with self-intersections (some of thier parts), and so getTextSize --------------- -.. cpp:function:: Size getTextSize(const string& text, int fontFace, double fontScale, int thickness, int* baseLine) +.. ocv:function:: Size getTextSize(const string& text, int fontFace, double fontScale, int thickness, int* baseLine) Calculates the width and height of a text string. :param text: Input text string. - :param fontFace: Font to use. See :cpp:func:`putText` for details. + :param fontFace: Font to use. See :ocv:func:`putText` for details. - :param fontScale: Font scale. See :cpp:func:`putText` for details. + :param fontScale: Font scale. See :ocv:func:`putText` for details. - :param thickness: Thickness of lines used to render the text. See :cpp:func:`putText` for details. + :param thickness: Thickness of lines used to render the text. See :ocv:func:`putText` for details. :param baseLine: Output parameter - y-coordinate of the baseline relative to the bottom-most text point. @@ -244,7 +244,7 @@ That is, the following code renders some text, the tight box surrounding it, and line -------- -.. cpp:function:: void line(Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness=1, int lineType=8, int shift=0) +.. ocv:function:: void line(Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness=1, int lineType=8, int shift=0) Draws a line segment connecting two points. @@ -321,9 +321,9 @@ The number of pixels along the line is stored in ``LineIterator::count`` . :: rectangle ------------- -.. cpp:function:: void rectangle(Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness=1, int lineType=8, int shift=0) +.. ocv:function:: void rectangle(Mat& img, Point pt1, Point pt2, const Scalar& color, int thickness=1, int lineType=8, int shift=0) -.. cpp:function:: void rectangle(Mat& img, Rect r, const Scalar& color, int thickness=1, int lineType=8, int shift=0) +.. ocv:function:: void rectangle(Mat& img, Rect r, const Scalar& color, int thickness=1, int lineType=8, int shift=0) Draws a simple, thick, or filled up-right rectangle. @@ -339,7 +339,7 @@ rectangle :param thickness: Thickness of lines that make up the rectangle. Negative values, like ``CV_FILLED`` , mean that the function has to draw a filled rectangle. - :param lineType: Type of the line. See :cpp:func:`line` description. + :param lineType: Type of the line. See :ocv:func:`line` description. :param shift: Number of fractional bits in the point coordinates. @@ -349,7 +349,7 @@ The function ``rectangle`` draws a rectangle outline or a filled rectangle whose polylines ------------- -.. cpp:function:: void polylines(Mat& img, const Point** pts, const int* npts, int ncontours, bool isClosed, const Scalar& color, int thickness=1, int lineType=8, int shift=0 ) +.. ocv:function:: void polylines(Mat& img, const Point** pts, const int* npts, int ncontours, bool isClosed, const Scalar& color, int thickness=1, int lineType=8, int shift=0 ) Draws several polygonal curves. @@ -367,7 +367,7 @@ polylines :param thickness: Thickness of the polyline edges. - :param lineType: Type of the line segments. See :cpp:func:`line` description. + :param lineType: Type of the line segments. See :ocv:func:`line` description. :param shift: Number of fractional bits in the vertex coordinates. @@ -377,7 +377,7 @@ The function ``polylines`` draws one or more polygonal curves. putText ----------- -.. cpp:function:: void putText( Mat& img, const string& text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=8, bool bottomLeftOrigin=false ) +.. ocv:function:: void putText( Mat& img, const string& text, Point org, int fontFace, double fontScale, Scalar color, int thickness=1, int lineType=8, bool bottomLeftOrigin=false ) Draws a text string. @@ -403,5 +403,5 @@ putText The function ``putText`` renders the specified text string in the image. Symbols that cannot be rendered using the specified font are replaced by question marks. See -:cpp:func:`getTextSize` for a text rendering code example. +:ocv:func:`getTextSize` for a text rendering code example. diff --git a/modules/core/doc/operations_on_arrays.rst b/modules/core/doc/operations_on_arrays.rst index 1afd070..f87b147 100644 --- a/modules/core/doc/operations_on_arrays.rst +++ b/modules/core/doc/operations_on_arrays.rst @@ -7,21 +7,21 @@ Operations on Arrays * - - - * - :cpp:func:`abs` (src) + * - :ocv:func:`abs` (src) - Computes an absolute value of each matrix element. - * - :cpp:func:`absdiff` (src1, src2, dst) + * - :ocv:func:`absdiff` (src1, src2, dst) - Computes the per-element absolute difference between 2 arrays or between an array and a scalar. abs --- -.. cpp:function:: MatExpr abs(const Mat& src) -.. cpp:function:: MatExpr abs(const MatExpr& src) +.. ocv:function:: MatExpr abs(const Mat& src) +.. ocv:function:: MatExpr abs(const MatExpr& src) Computes an absolute value of each matrix element. :param src: Matrix or matrix expression. -``abs`` is a meta-function that is expanded to one of :cpp:func:`absdiff` forms: +``abs`` is a meta-function that is expanded to one of :ocv:func:`absdiff` forms: * ``C = abs(A-B)`` is equivalent to ``absdiff(A, B, C)`` @@ -31,12 +31,12 @@ abs The output matrix has the same size and the same type as the input one except for the last case, where ``C`` is ``depth=CV_8U`` . - .. seealso:: :ref:`MatrixExpressions`, :cpp:func:`absdiff` + .. seealso:: :ref:`MatrixExpressions`, :ocv:func:`absdiff` absdiff ----------- -.. cpp:function:: void absdiff(InputArray src1, InputArray src2, OutputArray dst) +.. ocv:function:: void absdiff(InputArray src1, InputArray src2, OutputArray dst) Computes the per-element absolute difference between two arrays or between an array and a scalar. @@ -72,12 +72,12 @@ The function ``absdiff`` computes: where ``I`` is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently. - .. seealso:: :cpp:func:`abs` + .. seealso:: :ocv:func:`abs` add ------- -.. cpp:function:: void add(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) +.. ocv:function:: void add(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) Computes the per-element sum of two arrays or an array and a scalar. @@ -125,17 +125,17 @@ The input arrays and the destination array can all have the same or different de .. seealso:: - :cpp:func:`subtract`, - :cpp:func:`addWeighted`, - :cpp:func:`scaleAdd`, - :cpp:func:`convertScale`, + :ocv:func:`subtract`, + :ocv:func:`addWeighted`, + :ocv:func:`scaleAdd`, + :ocv:func:`convertScale`, :ref:`MatrixExpressions` addWeighted --------------- -.. cpp:function:: void addWeighted(InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1) +.. ocv:function:: void addWeighted(InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, int dtype=-1) Computes the weighted sum of two arrays. @@ -168,17 +168,17 @@ The function can be replaced with a matrix expression: :: .. seealso:: - :cpp:func:`add`, - :cpp:func:`subtract`, - :cpp:func:`scaleAdd`, - :cpp:func:`convertScale`, + :ocv:func:`add`, + :ocv:func:`subtract`, + :ocv:func:`scaleAdd`, + :ocv:func:`convertScale`, :ref:`MatrixExpressions` bitwise_and ----------- -.. cpp:function:: void bitwise_and(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) +.. ocv:function:: void bitwise_and(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar. @@ -220,7 +220,7 @@ In case of floating-point arrays, their machine-specific bit representations (us bitwise_not ----------- -.. cpp:function:: void bitwise_not(InputArray src, OutputArray dst, InputArray mask=noArray()) +.. ocv:function:: void bitwise_not(InputArray src, OutputArray dst, InputArray mask=noArray()) Inverts every bit of an array. @@ -242,7 +242,7 @@ In case of a floating-point source array, its machine-specific bit representatio bitwise_or ---------- -.. cpp:function:: void bitwise_or(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) +.. ocv:function:: void bitwise_or(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar. @@ -285,7 +285,7 @@ In case of floating-point arrays, their machine-specific bit representations (us bitwise_xor ----------- -.. cpp:function:: void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) +.. ocv:function:: void bitwise_xor(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray()) Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar. @@ -327,9 +327,9 @@ In case of floating-point arrays, their machine-specific bit representations (us calcCovarMatrix --------------- -.. cpp:function:: void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean, int flags, int ctype=CV_64F) +.. ocv:function:: void calcCovarMatrix( const Mat* samples, int nsamples, Mat& covar, Mat& mean, int flags, int ctype=CV_64F) -.. cpp:function:: void calcCovarMatrix( InputArray samples, OutputArray covar, OutputArray mean, int flags, int ctype=CV_64F) +.. ocv:function:: void calcCovarMatrix( InputArray samples, OutputArray covar, OutputArray mean, int flags, int ctype=CV_64F) Calculates the covariance matrix of a set of vectors. @@ -371,16 +371,16 @@ The functions ``calcCovarMatrix`` calculate the covariance matrix and, optionall .. seealso:: - :cpp:class:`PCA`, - :cpp:func:`mulTransposed`, - :cpp:func:`Mahalanobis` + :ocv:class:`PCA`, + :ocv:func:`mulTransposed`, + :ocv:func:`Mahalanobis` cartToPolar ----------- -.. cpp:function:: void cartToPolar(InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false) +.. ocv:function:: void cartToPolar(InputArray x, InputArray y, OutputArray magnitude, OutputArray angle, bool angleInDegrees=false) Calculates the magnitude and angle of 2D vectors. @@ -407,7 +407,7 @@ The angles are calculated with accuracy about 0.3 degrees. For the point (0,0), checkRange ---------- -.. cpp:function:: bool checkRange(InputArray src, bool quiet=true, Point* pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX) +.. ocv:function:: bool checkRange(InputArray src, bool quiet=true, Point* pos=0, double minVal=-DBL_MAX, double maxVal=DBL_MAX) Checks every element of an input array for invalid values. @@ -431,7 +431,7 @@ If some values are out of range, position of the first outlier is stored in ``po compare ------- -.. cpp:function:: void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop) +.. ocv:function:: void compare(InputArray src1, InputArray src2, OutputArray dst, int cmpop) Performs the per-element comparison of two arrays or an array and scalar value. @@ -485,10 +485,10 @@ The comparison operations can be replaced with the equivalent matrix expressions .. seealso:: - :cpp:func:`checkRange`, - :cpp:func:`min`, - :cpp:func:`max`, - :cpp:func:`threshold`, + :ocv:func:`checkRange`, + :ocv:func:`min`, + :ocv:func:`max`, + :ocv:func:`threshold`, :ref:`MatrixExpressions` @@ -496,7 +496,7 @@ The comparison operations can be replaced with the equivalent matrix expressions completeSymm ------------ -.. cpp:function:: void completeSymm(InputOutputArray mtx, bool lowerToUpper=false) +.. ocv:function:: void completeSymm(InputOutputArray mtx, bool lowerToUpper=false) Copies the lower or the upper half of a square matrix to another half. @@ -516,15 +516,15 @@ The function ``completeSymm`` copies the lower half of a square matrix to its an .. seealso:: - :cpp:func:`flip`, - :cpp:func:`transpose` + :ocv:func:`flip`, + :ocv:func:`transpose` convertScaleAbs --------------- -.. cpp:function:: void convertScaleAbs(InputArray src, OutputArray dst, double alpha=1, double beta=0) +.. ocv:function:: void convertScaleAbs(InputArray src, OutputArray dst, double alpha=1, double beta=0) Scales, computes absolute values, and converts the result to 8-bit. @@ -555,15 +555,15 @@ In case of multi-channel arrays, the function processes each channel independent .. seealso:: - :cpp:func:`Mat::convertTo`, - :cpp:func:`abs` + :ocv:func:`Mat::convertTo`, + :ocv:func:`abs` countNonZero ------------ -.. cpp:function:: int countNonZero( InputArray mtx ) +.. ocv:function:: int countNonZero( InputArray mtx ) Counts non-zero array elements. @@ -577,18 +577,18 @@ The function returns the number of non-zero elements in ``mtx`` : .. seealso:: - :cpp:func:`mean`, - :cpp:func:`meanStdDev`, - :cpp:func:`norm`, - :cpp:func:`minMaxLoc`, - :cpp:func:`calcCovarMatrix` + :ocv:func:`mean`, + :ocv:func:`meanStdDev`, + :ocv:func:`norm`, + :ocv:func:`minMaxLoc`, + :ocv:func:`calcCovarMatrix` cubeRoot -------- -.. cpp:function:: float cubeRoot(float val) +.. ocv:function:: float cubeRoot(float val) Computes the cube root of an argument. @@ -601,7 +601,7 @@ The function ``cubeRoot`` computes :math:`\sqrt[3]{\texttt{val}}`. Negative argu cvarrToMat ---------- -.. cpp:function:: Mat cvarrToMat(const CvArr* src, bool copyData=false, bool allowND=true, int coiMode=0) +.. ocv:function:: Mat cvarrToMat(const CvArr* src, bool copyData=false, bool allowND=true, int coiMode=0) Converts ``CvMat``, ``IplImage`` , or ``CvMatND`` to ``Mat``. @@ -615,10 +615,10 @@ cvarrToMat * If ``coiMode=0`` and COI is set, the function reports an error. - * If ``coiMode=1`` , the function never reports an error. Instead, it returns the header to the whole original image and you will have to check and process COI manually. See :cpp:func:`extractImageCOI` . + * If ``coiMode=1`` , the function never reports an error. Instead, it returns the header to the whole original image and you will have to check and process COI manually. See :ocv:func:`extractImageCOI` . The function ``cvarrToMat`` converts ``CvMat``, ``IplImage`` , or ``CvMatND`` header to -:cpp:class:`Mat` header, and optionally duplicates the underlying data. The constructed header is returned by the function. +:ocv:class:`Mat` header, and optionally duplicates the underlying data. The constructed header is returned by the function. When ``copyData=false`` , the conversion is done really fast (in O(1) time) and the newly created matrix header will have ``refcount=0`` , which means that no reference counting is done for the matrix data. In this case, you have to preserve the data until the new header is destructed. Otherwise, when ``copyData=true`` , the new buffer is allocated and managed as if you created a new matrix from scratch and copied the data there. That is, ``cvarrToMat(src, true)`` is equivalent to ``cvarrToMat(src, false).clone()`` (assuming that COI is not set). The function provides a uniform way of supporting ``CvArr`` paradigm in the code that is migrated to use new-style data structures internally. The reverse transformation, from @@ -643,29 +643,29 @@ Normally, the function is used to convert an old-style 2D array ( ``CvMat`` or ``IplImage`` ) to ``Mat`` . However, the function can also take ``CvMatND`` as an input and create -:cpp:func:`Mat` for it, if it is possible. And, for ``CvMatND A`` , it is possible if and only if ``A.dim[i].size*A.dim.step[i] == A.dim.step[i-1]`` for all or for all but one ``i, 0 < i < A.dims`` . That is, the matrix data should be continuous or it should be representable as a sequence of continuous matrices. By using this function in this way, you can process +:ocv:func:`Mat` for it, if it is possible. And, for ``CvMatND A`` , it is possible if and only if ``A.dim[i].size*A.dim.step[i] == A.dim.step[i-1]`` for all or for all but one ``i, 0 < i < A.dims`` . That is, the matrix data should be continuous or it should be representable as a sequence of continuous matrices. By using this function in this way, you can process ``CvMatND`` using an arbitrary element-wise function. The last parameter, ``coiMode`` , specifies how to deal with an image with COI set. By default, it is 0 and the function reports an error when an image with COI comes in. And ``coiMode=1`` means that no error is signalled. You have to check COI presence and handle it manually. The modern structures, such as -:cpp:func:`Mat` and -:cpp:func:`MatND` do not support COI natively. To process an individual channel of a new-style array, you need either to organize a loop over the array (for example, using matrix iterators) where the channel of interest will be processed, or extract the COI using -:cpp:func:`mixChannels` (for new-style arrays) or -:cpp:func:`extractImageCOI` (for old-style arrays), process this individual channel, and insert it back to the destination array if needed (using -:cpp:func:`mixChannel` or -:cpp:func:`insertImageCOI` , respectively). +:ocv:func:`Mat` and +:ocv:func:`MatND` do not support COI natively. To process an individual channel of a new-style array, you need either to organize a loop over the array (for example, using matrix iterators) where the channel of interest will be processed, or extract the COI using +:ocv:func:`mixChannels` (for new-style arrays) or +:ocv:func:`extractImageCOI` (for old-style arrays), process this individual channel, and insert it back to the destination array if needed (using +:ocv:func:`mixChannel` or +:ocv:func:`insertImageCOI` , respectively). .. seealso:: :c:func:`cvGetImage`, :c:func:`cvGetMat`, :c:func:`cvGetMatND`, - :cpp:func:`extractImageCOI`, - :cpp:func:`insertImageCOI`, - :cpp:func:`mixChannels` + :ocv:func:`extractImageCOI`, + :ocv:func:`insertImageCOI`, + :ocv:func:`mixChannels` dct ------- -.. cpp:function:: void dct(InputArray src, OutputArray dst, int flags=0) +.. ocv:function:: void dct(InputArray src, OutputArray dst, int flags=0) Performs a forward or inverse discrete Cosine transform of 1D or 2D array. @@ -743,19 +743,19 @@ The function chooses the mode of operation by looking at the flags and size of t Currently ``dct`` supports even-size arrays (2, 4, 6 ...). For data analysis and approximation, you can pad the array when necessary. Also, the function performance depends very much, and not monotonically, on the array size (see - :cpp:func:`getOptimalDFTSize` ). In the current implementation DCT of a vector of size ``N`` is computed via DFT of a vector of size ``N/2`` . Thus, the optimal DCT size ``N1 >= N`` can be computed as: :: + :ocv:func:`getOptimalDFTSize` ). In the current implementation DCT of a vector of size ``N`` is computed via DFT of a vector of size ``N/2`` . Thus, the optimal DCT size ``N1 >= N`` can be computed as: :: size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); } N1 = getOptimalDCTSize(N); -.. seealso:: :cpp:func:`dft` , :cpp:func:`getOptimalDFTSize` , :cpp:func:`idct` +.. seealso:: :ocv:func:`dft` , :ocv:func:`getOptimalDFTSize` , :ocv:func:`idct` dft --- -.. cpp:function:: void dft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0) +.. ocv:function:: void dft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0) Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array. @@ -839,7 +839,7 @@ So, the function chooses an operation mode depending on the flags and size of th If ``DFT_SCALE`` is set, the scaling is done after the transformation. -Unlike :cpp:func:`dct` , the function supports arrays of arbitrary size. But only those arrays are processed efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the current implementation). Such an efficient DFT size can be computed using the :cpp:func:`getOptimalDFTSize` method. +Unlike :ocv:func:`dct` , the function supports arrays of arbitrary size. But only those arrays are processed efficiently, whose sizes can be factorized in a product of small prime numbers (2, 3, and 5 in the current implementation). Such an efficient DFT size can be computed using the :ocv:func:`getOptimalDFTSize` method. The sample below illustrates how to compute a DFT-based convolution of two 2D real arrays: :: @@ -895,17 +895,17 @@ To optimize this sample, consider the following approaches: * If different tiles in ``C`` can be computed in parallel and, thus, the convolution is done by parts, the loop can be threaded. -All of the above improvements have been implemented in :cpp:func:`matchTemplate` and :cpp:func:`filter2D` . Therefore, by using them, you can get the performance even better than with the above theoretically optimal implementation. Though, those two functions actually compute cross-correlation, not convolution, so you need to "flip" the second convolution operand ``B`` vertically and horizontally using :cpp:func:`flip` . +All of the above improvements have been implemented in :ocv:func:`matchTemplate` and :ocv:func:`filter2D` . Therefore, by using them, you can get the performance even better than with the above theoretically optimal implementation. Though, those two functions actually compute cross-correlation, not convolution, so you need to "flip" the second convolution operand ``B`` vertically and horizontally using :ocv:func:`flip` . -.. seealso:: :cpp:func:`dct` , :cpp:func:`getOptimalDFTSize` , :cpp:func:`mulSpectrums`, :cpp:func:`filter2D` , :cpp:func:`matchTemplate` , :cpp:func:`flip` , :cpp:func:`cartToPolar` , :cpp:func:`magnitude` , :cpp:func:`phase` +.. seealso:: :ocv:func:`dct` , :ocv:func:`getOptimalDFTSize` , :ocv:func:`mulSpectrums`, :ocv:func:`filter2D` , :ocv:func:`matchTemplate` , :ocv:func:`flip` , :ocv:func:`cartToPolar` , :ocv:func:`magnitude` , :ocv:func:`phase` divide ---------- -.. cpp:function:: void divide(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1) +.. ocv:function:: void divide(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1) -.. cpp:function:: void divide(double scale, InputArray src2, OutputArray dst, int dtype=-1) +.. ocv:function:: void divide(double scale, InputArray src2, OutputArray dst, int dtype=-1) Performs per-element division of two arrays or a scalar by an array. @@ -935,9 +935,9 @@ When ``src2(I)`` is zero, ``dst(I)`` will also be zero. Different channels of mu .. seealso:: - :cpp:func:`multiply`, - :cpp:func:`add`, - :cpp:func:`subtract`, + :ocv:func:`multiply`, + :ocv:func:`add`, + :ocv:func:`subtract`, :ref:`MatrixExpressions` @@ -945,7 +945,7 @@ When ``src2(I)`` is zero, ``dst(I)`` will also be zero. Different channels of mu determinant ----------- -.. cpp:function:: double determinant(InputArray mtx) +.. ocv:function:: double determinant(InputArray mtx) Returns the determinant of a square floating-point matrix. @@ -954,14 +954,14 @@ determinant The function ``determinant`` computes and returns the determinant of the specified matrix. For small matrices ( ``mtx.cols=mtx.rows<=3`` ), the direct method is used. For larger matrices, the function uses LU factorization with partial pivoting. -For symmetric positively-determined matrices, it is also possible to use :cpp:func:`eigen` decomposition to compute the determinant. +For symmetric positively-determined matrices, it is also possible to use :ocv:func:`eigen` decomposition to compute the determinant. .. seealso:: - :cpp:func:`trace`, - :cpp:func:`invert`, - :cpp:func:`solve`, - :cpp:func:`eigen`, + :ocv:func:`trace`, + :ocv:func:`invert`, + :ocv:func:`solve`, + :ocv:func:`eigen`, :ref:`MatrixExpressions` @@ -969,9 +969,9 @@ For symmetric positively-determined matrices, it is also possible to use :cpp:fu eigen ----- -.. cpp:function:: bool eigen(InputArray src, OutputArray eigenvalues, int lowindex=-1, int highindex=-1) +.. ocv:function:: bool eigen(InputArray src, OutputArray eigenvalues, int lowindex=-1, int highindex=-1) -.. cpp:function:: bool eigen(InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1,int highindex=-1) +.. ocv:function:: bool eigen(InputArray src, OutputArray eigenvalues, OutputArray eigenvectors, int lowindex=-1,int highindex=-1) Computes eigenvalues and eigenvectors of a symmetric matrix. @@ -989,14 +989,14 @@ The functions ``eigen`` compute just eigenvalues, or eigenvalues and eigenvector src*eigenvectors.row(i).t() = eigenvalues.at(i)*eigenvectors.row(i).t() -.. seealso:: :cpp:func:`completeSymm` , :cpp:class:`PCA` +.. seealso:: :ocv:func:`completeSymm` , :ocv:class:`PCA` exp --- -.. cpp:function:: void exp(InputArray src, OutputArray dst) +.. ocv:function:: void exp(InputArray src, OutputArray dst) Calculates the exponent of every array element. @@ -1012,14 +1012,14 @@ The function ``exp`` calculates the exponent of every element of the input array The maximum relative error is about ``7e-6`` for single-precision input and less than ``1e-10`` for double-precision input. Currently, the function converts denormalized values to zeros on output. Special values (NaN, Inf) are not handled. -.. seealso:: :cpp:func:`log` , :cpp:func:`cartToPolar` , :cpp:func:`polarToCart` , :cpp:func:`phase` , :cpp:func:`pow` , :cpp:func:`sqrt` , :cpp:func:`magnitude` +.. seealso:: :ocv:func:`log` , :ocv:func:`cartToPolar` , :ocv:func:`polarToCart` , :ocv:func:`phase` , :ocv:func:`pow` , :ocv:func:`sqrt` , :ocv:func:`magnitude` extractImageCOI --------------- -.. cpp:function:: void extractImageCOI(const CvArr* src, OutputArray dst, int coi=-1) +.. ocv:function:: void extractImageCOI(const CvArr* src, OutputArray dst, int coi=-1) Extracts the selected image channel. @@ -1032,17 +1032,17 @@ extractImageCOI The function ``extractImageCOI`` is used to extract an image COI from an old-style array and put the result to the new-style C++ matrix. As usual, the destination matrix is reallocated using ``Mat::create`` if needed. To extract a channel from a new-style matrix, use -:cpp:func:`mixChannels` or -:cpp:func:`split` . +:ocv:func:`mixChannels` or +:ocv:func:`split` . -.. seealso:: :cpp:func:`mixChannels` , :cpp:func:`split` , :cpp:func:`merge` , :cpp:func:`cvarrToMat` , :cpp:func:`cvSetImageCOI` , :cpp:func:`cvGetImageCOI` +.. seealso:: :ocv:func:`mixChannels` , :ocv:func:`split` , :ocv:func:`merge` , :ocv:func:`cvarrToMat` , :ocv:func:`cvSetImageCOI` , :ocv:func:`cvGetImageCOI` fastAtan2 --------- -.. cpp:function:: float fastAtan2(float y, float x) +.. ocv:function:: float fastAtan2(float y, float x) Calculates the angle of a 2D vector in degrees. @@ -1056,7 +1056,7 @@ The function ``fastAtan2`` calculates the full-range angle of an input 2D vector flip -------- -.. cpp:function:: void flip(InputArray src, OutputArray dst, int flipCode) +.. ocv:function:: void flip(InputArray src, OutputArray dst, int flipCode) Flips a 2D array around vertical, horizontal, or both axes. @@ -1088,14 +1088,14 @@ The example scenarios of using the function are the following: * Reversing the order of point arrays (``flipCode > 0`` or ``flipCode == 0``). -.. seealso:: :cpp:func:`transpose` , :cpp:func:`repeat` , :cpp:func:`completeSymm` +.. seealso:: :ocv:func:`transpose` , :ocv:func:`repeat` , :ocv:func:`completeSymm` gemm ---- -.. cpp:function:: void gemm(InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0) +.. ocv:function:: void gemm(InputArray src1, InputArray src2, double alpha, InputArray src3, double beta, OutputArray dst, int flags=0) Performs generalized matrix multiplication. @@ -1128,16 +1128,16 @@ The function can be replaced with a matrix expression. For example, the above ca dst = alpha*src1.t()*src2 + beta*src3.t(); -.. seealso:: :cpp:func:`mulTransposed` , :cpp:func:`transform` , :ref:`MatrixExpressions` +.. seealso:: :ocv:func:`mulTransposed` , :ocv:func:`transform` , :ref:`MatrixExpressions` getConvertElem -------------- -.. cpp:function:: ConvertData getConvertElem(int fromType, int toType) +.. ocv:function:: ConvertData getConvertElem(int fromType, int toType) -.. cpp:function:: ConvertScaleData getConvertScaleElem(int fromType, int toType) +.. ocv:function:: ConvertScaleData getConvertScaleElem(int fromType, int toType) Returns a conversion function for a single pixel. @@ -1163,14 +1163,14 @@ The functions ``getConvertElem`` and ``getConvertScaleElem`` return pointers to typedef void (*ConvertScaleData)(const void* from, void* to, int cn, double alpha, double beta) -.. seealso:: :cpp:func:`Mat::convertTo` , :cpp:func:`SparseMat::convertTo` +.. seealso:: :ocv:func:`Mat::convertTo` , :ocv:func:`SparseMat::convertTo` getOptimalDFTSize ----------------- -.. cpp:function:: int getOptimalDFTSize(int vecsize) +.. ocv:function:: int getOptimalDFTSize(int vecsize) Returns the optimal DFT size for a given vector size. @@ -1185,14 +1185,14 @@ The function returns a negative number if ``vecsize`` is too large (very close t While the function cannot be used directly to estimate the optimal vector size for DCT transform (since the current DCT implementation supports only even-size vectors), it can be easily computed as ``getOptimalDFTSize((vecsize+1)/2)*2``. -.. seealso:: :cpp:func:`dft` , :cpp:func:`dct` , :cpp:func:`idft` , :cpp:func:`idct` , :cpp:func:`mulSpectrums` +.. seealso:: :ocv:func:`dft` , :ocv:func:`dct` , :ocv:func:`idft` , :ocv:func:`idct` , :ocv:func:`mulSpectrums` idct ---- -.. cpp:function:: void idct(InputArray src, OutputArray dst, int flags=0) +.. ocv:function:: void idct(InputArray src, OutputArray dst, int flags=0) Computes the inverse Discrete Cosine Transform of a 1D or 2D array. @@ -1206,17 +1206,17 @@ idct .. seealso:: - :cpp:func:`dct`, - :cpp:func:`dft`, - :cpp:func:`idft`, - :cpp:func:`getOptimalDFTSize` + :ocv:func:`dct`, + :ocv:func:`dft`, + :ocv:func:`idft`, + :ocv:func:`getOptimalDFTSize` idft ---- -.. cpp:function:: void idft(InputArray src, OutputArray dst, int flags=0, int outputRows=0) +.. ocv:function:: void idft(InputArray src, OutputArray dst, int flags=0, int outputRows=0) Computes the inverse Discrete Fourier Transform of a 1D or 2D array. @@ -1224,30 +1224,30 @@ idft :param dst: Destination array whose size and type depend on the ``flags`` . - :param flags: Operation flags. See :cpp:func:`dft` . + :param flags: Operation flags. See :ocv:func:`dft` . - :param nonzeroRows: Number of ``dst`` rows to compute. The rest of the rows have undefined content. See the convolution sample in :cpp:func:`dft` description. + :param nonzeroRows: Number of ``dst`` rows to compute. The rest of the rows have undefined content. See the convolution sample in :ocv:func:`dft` description. ``idft(src, dst, flags)`` is equivalent to ``dct(src, dst, flags | DFT_INVERSE)`` . -See :cpp:func:`dft` for details. +See :ocv:func:`dft` for details. .. note:: None of ``dft`` and ``idft`` scales the result by default. So, you should pass ``DFT_SCALE`` to one of ``dft`` or ``idft`` explicitly to make these transforms mutually inverse. .. seealso:: - :cpp:func:`dft`, - :cpp:func:`dct`, - :cpp:func:`idct`, - :cpp:func:`mulSpectrums`, - :cpp:func:`getOptimalDFTSize` + :ocv:func:`dft`, + :ocv:func:`dct`, + :ocv:func:`idct`, + :ocv:func:`mulSpectrums`, + :ocv:func:`getOptimalDFTSize` inRange ------- -.. cpp:function:: void inRange(InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst) +.. ocv:function:: void inRange(InputArray src, InputArray lowerb, InputArray upperb, OutputArray dst) Checks if array elements lie between the elements of two other arrays. @@ -1284,7 +1284,7 @@ When the lower and/or upper bounary parameters are scalars, the indexes ``(I)`` invert ------ -.. cpp:function:: double invert(InputArray src, OutputArray dst, int method=DECOMP_LU) +.. ocv:function:: double invert(InputArray src, OutputArray dst, int method=DECOMP_LU) Finds the inverse or pseudo-inverse of a matrix. @@ -1311,15 +1311,15 @@ Similarly to ``DECOMP_LU`` , the method ``DECOMP_CHOLESKY`` works only with non- .. seealso:: - :cpp:func:`solve`, - :cpp:class:`SVD` + :ocv:func:`solve`, + :ocv:class:`SVD` log --- -.. cpp:function:: void log(InputArray src, OutputArray dst) +.. ocv:function:: void log(InputArray src, OutputArray dst) Calculates the natural logarithm of every array element. @@ -1338,20 +1338,20 @@ The maximum relative error is about ``7e-6`` for single-precision input and less .. seealso:: - :cpp:func:`exp`, - :cpp:func:`cartToPolar`, - :cpp:func:`polarToCart`, - :cpp:func:`phase`, - :cpp:func:`pow`, - :cpp:func:`sqrt`, - :cpp:func:`magnitude` + :ocv:func:`exp`, + :ocv:func:`cartToPolar`, + :ocv:func:`polarToCart`, + :ocv:func:`phase`, + :ocv:func:`pow`, + :ocv:func:`sqrt`, + :ocv:func:`magnitude` LUT --- -.. cpp:function:: void LUT(InputArray src, InputArray lut, OutputArray dst) +.. ocv:function:: void LUT(InputArray src, InputArray lut, OutputArray dst) Performs a look-up table transform of an array. @@ -1375,15 +1375,15 @@ where .. seealso:: - :cpp:func:`convertScaleAbs`, - :cpp:func:`Mat::convertTo` + :ocv:func:`convertScaleAbs`, + :ocv:func:`Mat::convertTo` magnitude --------- -.. cpp:function:: void magnitude(InputArray x, InputArray y, OutputArray magnitude) +.. ocv:function:: void magnitude(InputArray x, InputArray y, OutputArray magnitude) Calculates the magnitude of 2D vectors. @@ -1401,17 +1401,17 @@ The function ``magnitude`` calculates the magnitude of 2D vectors formed from th .. seealso:: - :cpp:func:`cartToPolar`, - :cpp:func:`polarToCart`, - :cpp:func:`phase`, - :cpp:func:`sqrt` + :ocv:func:`cartToPolar`, + :ocv:func:`polarToCart`, + :ocv:func:`phase`, + :ocv:func:`sqrt` Mahalanobis ----------- -.. cpp:function:: double Mahalanobis(InputArray vec1, InputArray vec2, InputArray icovar) +.. ocv:function:: double Mahalanobis(InputArray vec1, InputArray vec2, InputArray icovar) Calculates the Mahalanobis distance between two vectors. @@ -1428,25 +1428,25 @@ The function ``Mahalonobis`` calculates and returns the weighted distance betwee d( \texttt{vec1} , \texttt{vec2} )= \sqrt{\sum_{i,j}{\texttt{icovar(i,j)}\cdot(\texttt{vec1}(I)-\texttt{vec2}(I))\cdot(\texttt{vec1(j)}-\texttt{vec2(j)})} } The covariance matrix may be calculated using the -:cpp:func:`calcCovarMatrix` function and then inverted using the -:cpp:func:`invert` function (preferably using the ``DECOMP_SVD`` method, as the most accurate). +:ocv:func:`calcCovarMatrix` function and then inverted using the +:ocv:func:`invert` function (preferably using the ``DECOMP_SVD`` method, as the most accurate). max --- -.. cpp:function:: MatExpr max(const Mat& src1, const Mat& src2) +.. ocv:function:: MatExpr max(const Mat& src1, const Mat& src2) -.. cpp:function:: MatExpr max(const Mat& src1, double value) +.. ocv:function:: MatExpr max(const Mat& src1, double value) -.. cpp:function:: MatExpr max(double value, const Mat& src1) +.. ocv:function:: MatExpr max(double value, const Mat& src1) -.. cpp:function:: void max(InputArray src1, InputArray src2, OutputArray dst) +.. ocv:function:: void max(InputArray src1, InputArray src2, OutputArray dst) -.. cpp:function:: void max(const Mat& src1, const Mat& src2, Mat& dst) +.. ocv:function:: void max(const Mat& src1, const Mat& src2, Mat& dst) -.. cpp:function:: void max(const Mat& src1, double value, Mat& dst) +.. ocv:function:: void max(const Mat& src1, double value, Mat& dst) Calculates per-element maximum of two arrays or an array and a scalar. @@ -1477,21 +1477,21 @@ The first 3 variants of the function listed above are actually a part of .. seealso:: - :cpp:func:`min`, - :cpp:func:`compare`, - :cpp:func:`inRange`, - :cpp:func:`minMaxLoc`, + :ocv:func:`min`, + :ocv:func:`compare`, + :ocv:func:`inRange`, + :ocv:func:`minMaxLoc`, :ref:`MatrixExpressions` mean ---- -.. cpp:function:: Scalar mean(InputArray mtx, InputArray mask=noArray()) +.. ocv:function:: Scalar mean(InputArray mtx, InputArray mask=noArray()) Calculates an average (mean) of array elements. - :param mtx: Source array that should have from 1 to 4 channels so that the result can be stored in :cpp:func:`Scalar` . + :param mtx: Source array that should have from 1 to 4 channels so that the result can be stored in :ocv:func:`Scalar` . :param mask: Optional operation mask. @@ -1505,21 +1505,21 @@ When all the mask elements are 0's, the functions return ``Scalar::all(0)`` . .. seealso:: - :cpp:func:`countNonZero`, - :cpp:func:`meanStdDev`, - :cpp:func:`norm`, - :cpp:func:`minMaxLoc` + :ocv:func:`countNonZero`, + :ocv:func:`meanStdDev`, + :ocv:func:`norm`, + :ocv:func:`minMaxLoc` meanStdDev ---------- -.. cpp:function:: void meanStdDev(InputArray mtx, OutputArray mean, OutputArray stddev, InputArray mask=noArray()) +.. ocv:function:: void meanStdDev(InputArray mtx, OutputArray mean, OutputArray stddev, InputArray mask=noArray()) Calculates a mean and standard deviation of array elements. - :param mtx: Source array that should have from 1 to 4 channels so that the results can be stored in :cpp:func:`Scalar` 's. + :param mtx: Source array that should have from 1 to 4 channels so that the results can be stored in :ocv:func:`Scalar` 's. :param mean: Output parameter: computed mean value. @@ -1535,24 +1535,24 @@ The function ``meanStdDev`` computes the mean and the standard deviation ``M`` o When all the mask elements are 0's, the functions return ``mean=stddev=Scalar::all(0)`` . -.. note:: The computed standard deviation is only the diagonal of the complete normalized covariance matrix. If the full matrix is needed, you can reshape the multi-channel array ``M x N`` to the single-channel array ``M*N x mtx.channels()`` (only possible when the matrix is continuous) and then pass the matrix to :cpp:func:`calcCovarMatrix` . +.. note:: The computed standard deviation is only the diagonal of the complete normalized covariance matrix. If the full matrix is needed, you can reshape the multi-channel array ``M x N`` to the single-channel array ``M*N x mtx.channels()`` (only possible when the matrix is continuous) and then pass the matrix to :ocv:func:`calcCovarMatrix` . .. seealso:: - :cpp:func:`countNonZero`, - :cpp:func:`mean`, - :cpp:func:`norm`, - :cpp:func:`minMaxLoc`, - :cpp:func:`calcCovarMatrix` + :ocv:func:`countNonZero`, + :ocv:func:`mean`, + :ocv:func:`norm`, + :ocv:func:`minMaxLoc`, + :ocv:func:`calcCovarMatrix` merge ----- -.. cpp:function:: void merge(const Mat* mv, size_t count, OutputArray dst) +.. ocv:function:: void merge(const Mat* mv, size_t count, OutputArray dst) -.. cpp:function:: void merge(const vector& mv, OutputArray dst) +.. ocv:function:: void merge(const vector& mv, OutputArray dst) Composes a multi-channel array from several single-channel arrays. @@ -1565,31 +1565,31 @@ merge The functions ``merge`` merge several arrays to make a single multi-channel array. That is, each element of the output array will be a concatenation of the elements of the input arrays, where elements of i-th input array are treated as ``mv[i].channels()``-element vectors. The function -:cpp:func:`split` does the reverse operation. If you need to shuffle channels in some other advanced way, use -:cpp:func:`mixChannels` . +:ocv:func:`split` does the reverse operation. If you need to shuffle channels in some other advanced way, use +:ocv:func:`mixChannels` . .. seealso:: - :cpp:func:`mixChannels`, - :cpp:func:`split`, - :cpp:func:`reshape` + :ocv:func:`mixChannels`, + :ocv:func:`split`, + :ocv:func:`reshape` min --- -.. cpp:function:: MatExpr min(const Mat& src1, const Mat& src2) +.. ocv:function:: MatExpr min(const Mat& src1, const Mat& src2) -.. cpp:function:: MatExpr min(const Mat& src1, double value) +.. ocv:function:: MatExpr min(const Mat& src1, double value) -.. cpp:function:: MatExpr min(double value, const Mat& src1) +.. ocv:function:: MatExpr min(double value, const Mat& src1) -.. cpp:function:: void min(InputArray src1, InputArray src2, OutputArray dst) +.. ocv:function:: void min(InputArray src1, InputArray src2, OutputArray dst) -.. cpp:function:: void min(const Mat& src1, const Mat& src2, Mat& dst) +.. ocv:function:: void min(const Mat& src1, const Mat& src2, Mat& dst) -.. cpp:function:: void min(const Mat& src1, double value, Mat& dst) +.. ocv:function:: void min(const Mat& src1, double value, Mat& dst) Calculates per-element minimum of two arrays or array and a scalar. @@ -1620,10 +1620,10 @@ The first three variants of the function listed above are actually a part of .. seealso:: - :cpp:func:`max`, - :cpp:func:`compare`, - :cpp:func:`inRange`, - :cpp:func:`minMaxLoc`, + :ocv:func:`max`, + :ocv:func:`compare`, + :ocv:func:`inRange`, + :ocv:func:`minMaxLoc`, :ref:`MatrixExpressions` @@ -1631,9 +1631,9 @@ The first three variants of the function listed above are actually a part of minMaxLoc --------- -.. cpp:function:: void minMaxLoc(InputArray src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray()) +.. ocv:function:: void minMaxLoc(InputArray src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, InputArray mask=noArray()) -.. cpp:function:: void minMaxLoc(const SparseMat& src, double* minVal, double* maxVal, int* minIdx=0, int* maxIdx=0) +.. ocv:function:: void minMaxLoc(const SparseMat& src, double* minVal, double* maxVal, int* minIdx=0, int* maxIdx=0) Finds the global minimum and maximum in a whole array or sub-array. @@ -1657,32 +1657,32 @@ The functions ``ninMaxLoc`` find the minimum and maximum element values and thei if ``mask`` is not an empty array, in the specified array region. The functions do not work with multi-channel arrays. If you need to find minimum or maximum elements across all the channels, use -:cpp:func:`reshape` first to reinterpret the array as single-channel. Or you may extract the particular channel using either -:cpp:func:`extractImageCOI` , or -:cpp:func:`mixChannels` , or -:cpp:func:`split` . +:ocv:func:`reshape` first to reinterpret the array as single-channel. Or you may extract the particular channel using either +:ocv:func:`extractImageCOI` , or +:ocv:func:`mixChannels` , or +:ocv:func:`split` . In case of a sparse matrix, the minimum is found among non-zero elements only. .. seealso:: - :cpp:func:`max`, - :cpp:func:`min`, - :cpp:func:`compare`, - :cpp:func:`inRange`, - :cpp:func:`extractImageCOI`, - :cpp:func:`mixChannels`, - :cpp:func:`split`, - :cpp:func:`reshape` + :ocv:func:`max`, + :ocv:func:`min`, + :ocv:func:`compare`, + :ocv:func:`inRange`, + :ocv:func:`extractImageCOI`, + :ocv:func:`mixChannels`, + :ocv:func:`split`, + :ocv:func:`reshape` mixChannels ----------- -.. cpp:function:: void mixChannels(const Mat* srcv, int nsrc, Mat* dstv, int ndst, const int* fromTo, size_t npairs) +.. ocv:function:: void mixChannels(const Mat* srcv, int nsrc, Mat* dstv, int ndst, const int* fromTo, size_t npairs) -.. cpp:function:: void mixChannels(const vector& srcv, vector& dstv, const int* fromTo, int npairs) +.. ocv:function:: void mixChannels(const vector& srcv, vector& dstv, const int* fromTo, int npairs) Copies specified channels from input arrays to the specified channels of output arrays. @@ -1698,9 +1698,9 @@ mixChannels The functions ``mixChannels`` provide an advanced mechanism for shuffling image channels. -:cpp:func:`split` and -:cpp:func:`merge` and some forms of -:cpp:func:`cvtColor` are partial cases of ``mixChannels`` . +:ocv:func:`split` and +:ocv:func:`merge` and some forms of +:ocv:func:`cvtColor` are partial cases of ``mixChannels`` . In the example below, the code splits a 4-channel RGBA image into a 3-channel BGR (with R and B channels swapped) and a separate alpha-channel image: :: @@ -1717,20 +1717,20 @@ In the example below, the code splits a 4-channel RGBA image into a 3-channel BG mixChannels( &rgba, 1, out, 2, from_to, 4 ); -.. note:: Unlike many other new-style C++ functions in OpenCV (see the introduction section and :cpp:func:`Mat::create` ), ``mixChannels`` requires the destination arrays to be pre-allocated before calling the function. +.. note:: Unlike many other new-style C++ functions in OpenCV (see the introduction section and :ocv:func:`Mat::create` ), ``mixChannels`` requires the destination arrays to be pre-allocated before calling the function. .. seealso:: - :cpp:func:`split`, - :cpp:func:`merge`, - :cpp:func:`cvtColor` + :ocv:func:`split`, + :ocv:func:`merge`, + :ocv:func:`cvtColor` mulSpectrums ------------ -.. cpp:function:: void mulSpectrums(InputArray src1, InputArray src2, OutputArray dst, int flags, bool conj=false) +.. ocv:function:: void mulSpectrums(InputArray src1, InputArray src2, OutputArray dst, int flags, bool conj=false) Performs the per-element multiplication of two Fourier spectrums. @@ -1747,16 +1747,16 @@ mulSpectrums The function ``mulSpectrums`` performs the per-element multiplication of the two CCS-packed or complex matrices that are results of a real or complex Fourier transform. The function, together with -:cpp:func:`dft` and -:cpp:func:`idft` , may be used to calculate convolution (pass ``conj=false`` ) or correlation (pass ``conj=false`` ) of two arrays rapidly. When the arrays are complex, they are simply multiplied (per element) with an optional conjugation of the second-array elements. When the arrays are real, they are assumed to be CCS-packed (see -:cpp:func:`dft` for details). +:ocv:func:`dft` and +:ocv:func:`idft` , may be used to calculate convolution (pass ``conj=false`` ) or correlation (pass ``conj=false`` ) of two arrays rapidly. When the arrays are complex, they are simply multiplied (per element) with an optional conjugation of the second-array elements. When the arrays are real, they are assumed to be CCS-packed (see +:ocv:func:`dft` for details). multiply -------- -.. cpp:function:: void multiply(InputArray src1, InputArray src2, OutputArray dst, double scale=1) +.. ocv:function:: void multiply(InputArray src1, InputArray src2, OutputArray dst, double scale=1) Calculates the per-element scaled product of two arrays. @@ -1776,40 +1776,40 @@ The function ``multiply`` calculates the per-element product of two arrays: There is also a :ref:`MatrixExpressions` -friendly variant of the first function. See -:cpp:func:`Mat::mul` . +:ocv:func:`Mat::mul` . For a not-per-element matrix product, see -:cpp:func:`gemm` . +:ocv:func:`gemm` . .. seealso:: - :cpp:func:`add`, - :cpp:func:`substract`, - :cpp:func:`divide`, + :ocv:func:`add`, + :ocv:func:`substract`, + :ocv:func:`divide`, :ref:`MatrixExpressions`, - :cpp:func:`scaleAdd`, - :cpp:func:`addWeighted`, - :cpp:func:`accumulate`, - :cpp:func:`accumulateProduct`, - :cpp:func:`accumulateSquare`, - :cpp:func:`Mat::convertTo` + :ocv:func:`scaleAdd`, + :ocv:func:`addWeighted`, + :ocv:func:`accumulate`, + :ocv:func:`accumulateProduct`, + :ocv:func:`accumulateSquare`, + :ocv:func:`Mat::convertTo` mulTransposed ------------- -.. cpp:function:: void mulTransposed(InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int rtype=-1) +.. ocv:function:: void mulTransposed(InputArray src, OutputArray dst, bool aTa, InputArray delta=noArray(), double scale=1, int rtype=-1) Calculates the product of a matrix and its transposition. - :param src: Source single-channel matrix. Note that unlike :cpp:func:`gemm`, the function can multiply not only floating-point matrices. + :param src: Source single-channel matrix. Note that unlike :ocv:func:`gemm`, the function can multiply not only floating-point matrices. :param dst: Destination square matrix. :param aTa: Flag specifying the multiplication ordering. See the description below. - :param delta: Optional delta matrix subtracted from ``src`` before the multiplication. When the matrix is empty ( ``delta=noArray()`` ), it is assumed to be zero, that is, nothing is subtracted. If it has the same size as ``src`` , it is simply subtracted. Otherwise, it is "repeated" (see :cpp:func:`repeat` ) to cover the full ``src`` and then subtracted. Type of the delta matrix, when it is not empty, must be the same as the type of created destination matrix. See the ``rtype`` parameter description below. + :param delta: Optional delta matrix subtracted from ``src`` before the multiplication. When the matrix is empty ( ``delta=noArray()`` ), it is assumed to be zero, that is, nothing is subtracted. If it has the same size as ``src`` , it is simply subtracted. Otherwise, it is "repeated" (see :ocv:func:`repeat` ) to cover the full ``src`` and then subtracted. Type of the delta matrix, when it is not empty, must be the same as the type of created destination matrix. See the ``rtype`` parameter description below. :param scale: Optional scale factor for the matrix product. @@ -1831,21 +1831,21 @@ otherwise. The function is used to compute the covariance matrix. With zero delt .. seealso:: - :cpp:func:`calcCovarMatrix`, - :cpp:func:`gemm`, - :cpp:func:`repeat`, - :cpp:func:`reduce` + :ocv:func:`calcCovarMatrix`, + :ocv:func:`gemm`, + :ocv:func:`repeat`, + :ocv:func:`reduce` norm ---- -.. cpp:function:: double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray()) +.. ocv:function:: double norm(InputArray src1, int normType=NORM_L2, InputArray mask=noArray()) -.. cpp:function:: double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray()) +.. ocv:function:: double norm(InputArray src1, InputArray src2, int normType, InputArray mask=noArray()) -.. cpp:function:: double norm( const SparseMat& src, int normType ) +.. ocv:function:: double norm( const SparseMat& src, int normType ) Calculates an absolute array norm, an absolute difference norm, or a relative difference norm. @@ -1892,9 +1892,9 @@ A multi-channel source arrays are treated as a single-channel, that is, the resu normalize --------- -.. cpp:function:: void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2, int rtype=-1, InputArray mask=noArray()) +.. ocv:function:: void normalize(const InputArray src, OutputArray dst, double alpha=1, double beta=0, int normType=NORM_L2, int rtype=-1, InputArray mask=noArray()) -.. cpp:function:: void normalize(const SparseMat& src, SparseMat& dst, double alpha, int normType) +.. ocv:function:: void normalize(const SparseMat& src, SparseMat& dst, double alpha, int normType) Normalizes the norm or value range of an array. @@ -1927,22 +1927,22 @@ The functions ``normalize`` scale and shift the source array elements so that when ``normType=NORM_MINMAX`` (for dense arrays only). The optional mask specifies a sub-array to be normalized. This means that the norm or min-n-max are computed over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to compute the norm or min-max but modify the whole array, you can use -:cpp:func:`norm` and -:cpp:func:`Mat::convertTo`. +:ocv:func:`norm` and +:ocv:func:`Mat::convertTo`. In case of sparse matrices, only the non-zero values are analyzed and transformed. Because of this, the range transformation for sparse matrices is not allowed since it can shift the zero level. .. seealso:: - :cpp:func:`norm`, - :cpp:func:`Mat::convertTo`, - :cpp:func:`SparseMat::convertTo` + :ocv:func:`norm`, + :ocv:func:`Mat::convertTo`, + :ocv:func:`SparseMat::convertTo` PCA --- -.. cpp:class:: PCA +.. ocv:class:: PCA Principal Component Analysis class. @@ -1988,19 +1988,19 @@ The sample below is the function that takes two matrices. The first function sto .. seealso:: - :cpp:func:`calcCovarMatrix`, - :cpp:func:`mulTransposed`, - :cpp:class:`SVD`, - :cpp:func:`dft`, - :cpp:func:`dct` + :ocv:func:`calcCovarMatrix`, + :ocv:func:`mulTransposed`, + :ocv:class:`SVD`, + :ocv:func:`dft`, + :ocv:func:`dct` PCA::PCA ------------ -.. cpp:function:: PCA::PCA() +.. ocv:function:: PCA::PCA() -.. cpp:function:: PCA::PCA(InputArray data, InputArray mean, int flags, int maxComponents=0) +.. ocv:function:: PCA::PCA(InputArray data, InputArray mean, int flags, int maxComponents=0) PCA constructors @@ -2017,14 +2017,14 @@ PCA::PCA :param maxComponents: Maximum number of components that PCA should retain. By default, all the components are retained. The default constructor initializes an empty PCA structure. The second constructor initializes the structure and calls -:cpp:func:`PCA::operator ()` . +:ocv:func:`PCA::operator ()` . PCA::operator () ---------------- -.. cpp:function:: PCA& PCA::operator()(InputArray data, InputArray mean, int flags, int maxComponents=0) +.. ocv:function:: PCA& PCA::operator()(InputArray data, InputArray mean, int flags, int maxComponents=0) Performs Principal Component Analysis of the supplied dataset. @@ -2049,9 +2049,9 @@ The computed eigenvalues are sorted from the largest to the smallest and the cor PCA::project ------------ -.. cpp:function:: Mat PCA::project(InputArray vec) const +.. ocv:function:: Mat PCA::project(InputArray vec) const -.. cpp:function:: void PCA::project(InputArray vec, OutputArray result) const +.. ocv:function:: void PCA::project(InputArray vec, OutputArray result) const Projects vector(s) to the principal component subspace. @@ -2066,9 +2066,9 @@ The methods project one or more vectors to the principal component subspace, whe PCA::backProject ---------------- -.. cpp:function:: Mat PCA::backProject(InputArray vec) const +.. ocv:function:: Mat PCA::backProject(InputArray vec) const -.. cpp:function:: void PCA::backProject(InputArray vec, OutputArray result) const +.. ocv:function:: void PCA::backProject(InputArray vec, OutputArray result) const Reconstructs vectors from their PC projections. @@ -2077,13 +2077,13 @@ PCA::backProject :param result: Reconstructed vectors. The layout and size are the same as of ``PCA::project`` input vectors. The methods are inverse operations to -:cpp:func:`PCA::project` . They take PC coordinates of projected vectors and reconstruct the original vectors. Unless all the principal components have been retained, the reconstructed vectors are different from the originals. But typically, the difference is small if the number of components is large enough (but still much smaller than the original vector dimensionality). As a result, PCA is used. +:ocv:func:`PCA::project` . They take PC coordinates of projected vectors and reconstruct the original vectors. Unless all the principal components have been retained, the reconstructed vectors are different from the originals. But typically, the difference is small if the number of components is large enough (but still much smaller than the original vector dimensionality). As a result, PCA is used. perspectiveTransform -------------------- -.. cpp:function:: void perspectiveTransform(InputArray src, OutputArray dst, InputArray mtx) +.. ocv:function:: void perspectiveTransform(InputArray src, OutputArray dst, InputArray mtx) Performs the perspective matrix transformation of vectors. @@ -2113,21 +2113,21 @@ and Here a 3D vector transformation is shown. In case of a 2D vector transformation, the ``z`` component is omitted. -.. note:: The function transforms a sparse set of 2D or 3D vectors. If you want to transform an image using perspective transformation, use :cpp:func:`warpPerspective` . If you have an inverse problem, that is, you want to compute the most probable perspective transformation out of several pairs of corresponding points, you can use :cpp:func:`getPerspectiveTransform` or :cpp:func:`findHomography` . +.. note:: The function transforms a sparse set of 2D or 3D vectors. If you want to transform an image using perspective transformation, use :ocv:func:`warpPerspective` . If you have an inverse problem, that is, you want to compute the most probable perspective transformation out of several pairs of corresponding points, you can use :ocv:func:`getPerspectiveTransform` or :ocv:func:`findHomography` . .. seealso:: - :cpp:func:`transform`, - :cpp:func:`warpPerspective`, - :cpp:func:`getPerspectiveTransform`, - :cpp:func:`findHomography` + :ocv:func:`transform`, + :ocv:func:`warpPerspective`, + :ocv:func:`getPerspectiveTransform`, + :ocv:func:`findHomography` phase ----- -.. cpp:function:: void phase(InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false) +.. ocv:function:: void phase(InputArray x, InputArray y, OutputArray angle, bool angleInDegrees=false) Calculates the rotation angle of 2D vectors. @@ -2151,7 +2151,7 @@ The angle estimation accuracy is about 0.3 degrees. When ``x(I)=y(I)=0`` , the c polarToCart ----------- -.. cpp:function:: void polarToCart(InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false) +.. ocv:function:: void polarToCart(InputArray magnitude, InputArray angle, OutputArray x, OutputArray y, bool angleInDegrees=false) Computes x and y coordinates of 2D vectors from their magnitude and angle. @@ -2175,20 +2175,20 @@ The relative accuracy of the estimated coordinates is about ``1e-6``. .. seealso:: - :cpp:func:`cartToPolar`, - :cpp:func:`magnitude`, - :cpp:func:`phase`, - :cpp:func:`exp`, - :cpp:func:`log`, - :cpp:func:`pow`, - :cpp:func:`sqrt` + :ocv:func:`cartToPolar`, + :ocv:func:`magnitude`, + :ocv:func:`phase`, + :ocv:func:`exp`, + :ocv:func:`log`, + :ocv:func:`pow`, + :ocv:func:`sqrt` pow --- -.. cpp:function:: void pow(InputArray src, double p, OutputArray dst) +.. ocv:function:: void pow(InputArray src, double p, OutputArray dst) Raises every array element to a power. @@ -2215,18 +2215,18 @@ For some values of ``p`` , such as integer values, 0.5 and -0.5, specialized fas .. seealso:: - :cpp:func:`sqrt`, - :cpp:func:`exp`, - :cpp:func:`log`, - :cpp:func:`cartToPolar`, - :cpp:func:`polarToCart` + :ocv:func:`sqrt`, + :ocv:func:`exp`, + :ocv:func:`log`, + :ocv:func:`cartToPolar`, + :ocv:func:`polarToCart` RNG --- -.. cpp:class: RNG +.. ocv:class: RNG Random number generator. It encapsulates the state (currently, a 64-bit integer) and has methods to return scalar random values and to fill arrays with random values. Currently it supports uniform and Gaussian (normal) distributions. The generator uses Multiply-With-Carry algorithm, introduced by G. Marsaglia ( http://en.wikipedia.org/wiki/Multiply-with-carry @@ -2238,9 +2238,9 @@ http://en.wikipedia.org/wiki/Ziggurat_algorithm RNG::RNG ------------ -.. cpp:function:: RNG::RNG() +.. ocv:function:: RNG::RNG() -.. cpp:function:: RNG::RNG(uint64 state) +.. ocv:function:: RNG::RNG(uint64 state) Introduces RNG constructors. @@ -2252,7 +2252,7 @@ These are the RNG constructors. The first form sets the state to some pre-define RNG::next ------------- -.. cpp:function:: unsigned RNG::next() +.. ocv:function:: unsigned RNG::next() Returns the next random number. @@ -2263,21 +2263,21 @@ The method updates the state using the MWC algorithm and returns the next 32-bit RNG::operator T --------------- -.. cpp:function:: RNG::operator uchar() +.. ocv:function:: RNG::operator uchar() -.. cpp:function:: RNG::operator schar() +.. ocv:function:: RNG::operator schar() -.. cpp:function:: RNG::operator ushort() +.. ocv:function:: RNG::operator ushort() -.. cpp:function:: RNG::operator short() +.. ocv:function:: RNG::operator short() -.. cpp:function:: RNG::operator int() +.. ocv:function:: RNG::operator int() -.. cpp:function:: RNG::operator unsigned() +.. ocv:function:: RNG::operator unsigned() -.. cpp:function:: RNG::operator float() +.. ocv:function:: RNG::operator float() -.. cpp:function:: RNG::operator double() +.. ocv:function:: RNG::operator double() Returns the next random number of the specified type. @@ -2287,26 +2287,26 @@ Each of the methods updates the state using the MWC algorithm and returns the ne RNG::operator () -------------------- -.. cpp:function:: unsigned RNG::operator ()() +.. ocv:function:: unsigned RNG::operator ()() -.. cpp:function:: unsigned RNG::operator ()(unsigned N) +.. ocv:function:: unsigned RNG::operator ()(unsigned N) Returns the next random number. :param N: Upper non-inclusive boundary of the returned random number. The methods transform the state using the MWC algorithm and return the next random number. The first form is equivalent to -:cpp:func:`RNG::next` . The second form returns the random number modulo ``N`` , which means that the result is in the range ``[0, N)`` . +:ocv:func:`RNG::next` . The second form returns the random number modulo ``N`` , which means that the result is in the range ``[0, N)`` . RNG::uniform ---------------- -.. cpp:function:: int RNG::uniform(int a, int b) +.. ocv:function:: int RNG::uniform(int a, int b) -.. cpp:function:: float RNG::uniform(float a, float b) +.. ocv:function:: float RNG::uniform(float a, float b) -.. cpp:function:: double RNG::uniform(double a, double b) +.. ocv:function:: double RNG::uniform(double a, double b) Returns the next random number sampled from the uniform distribution. @@ -2341,7 +2341,7 @@ The compiler does not take into account the type of the variable to which you as RNG::gaussian ----------------- -.. cpp:function:: double RNG::gaussian(double sigma) +.. ocv:function:: double RNG::gaussian(double sigma) Returns the next random number sampled from the Gaussian distribution. @@ -2353,11 +2353,11 @@ The method transforms the state using the MWC algorithm and returns the next ran RNG::fill ------------- -.. cpp:function:: void RNG::fill( InputOutputArray mat, int distType, InputArray a, InputArray b ) +.. ocv:function:: void RNG::fill( InputOutputArray mat, int distType, InputArray a, InputArray b ) Fills arrays with random numbers. - :param mat: 2D or N-dimensional matrix. Currently matrices with more than 4 channels are not supported by the methods. Use :cpp:func:`reshape` as a possible workaround. + :param mat: 2D or N-dimensional matrix. Currently matrices with more than 4 channels are not supported by the methods. Use :ocv:func:`reshape` as a possible workaround. :param distType: Distribution type, ``RNG::UNIFORM`` or ``RNG::NORMAL`` . @@ -2365,14 +2365,14 @@ RNG::fill :param b: Second distribution parameter. In case of the uniform distribution, this is a non-inclusive upper boundary. In case of the normal distribution, this is a standard deviation (diagonal of the standard deviation matrix or the full standard deviation matrix). -Each of the methods fills the matrix with the random values from the specified distribution. As the new numbers are generated, the RNG state is updated accordingly. In case of multiple-channel images, every channel is filled independently, which means that RNG cannot generate samples from the multi-dimensional Gaussian distribution with non-diagonal covariance matrix directly. To do that, the method generates samples from multi-dimensional standard Gaussian distribution with zero mean and identity covariation matrix, and then transforms them using :cpp:func:`transform` to get samples from the specified Gaussian distribution. +Each of the methods fills the matrix with the random values from the specified distribution. As the new numbers are generated, the RNG state is updated accordingly. In case of multiple-channel images, every channel is filled independently, which means that RNG cannot generate samples from the multi-dimensional Gaussian distribution with non-diagonal covariance matrix directly. To do that, the method generates samples from multi-dimensional standard Gaussian distribution with zero mean and identity covariation matrix, and then transforms them using :ocv:func:`transform` to get samples from the specified Gaussian distribution. randu ----- -.. cpp:function:: template _Tp randu() +.. ocv:function:: template _Tp randu() -.. cpp:function:: void randu(InputOutputArray mtx, InputArray low, InputArray high) +.. ocv:function:: void randu(InputOutputArray mtx, InputArray low, InputArray high) Generates a single uniformly-distributed random number or an array of random numbers. @@ -2383,7 +2383,7 @@ randu :param high: Exclusive upper boundary of the generated random numbers. The template functions ``randu`` generate and return the next uniformly-distributed random value of the specified type. ``randu()`` is an equivalent to ``(int)theRNG();`` , and so on. See -:cpp:class:`RNG` description. +:ocv:class:`RNG` description. The second non-template variant of the function fills the matrix ``mtx`` with uniformly-distributed random numbers from the specified range: @@ -2393,16 +2393,16 @@ The second non-template variant of the function fills the matrix ``mtx`` with un .. seealso:: - :cpp:class:`RNG`, - :cpp:func:`randn`, - :cpp:func:`theRNG` + :ocv:class:`RNG`, + :ocv:func:`randn`, + :ocv:func:`theRNG` randn ----- -.. cpp:function:: void randn(InputOutputArray mtx, InputArray mean, InputArray stddev) +.. ocv:function:: void randn(InputOutputArray mtx, InputArray mean, InputArray stddev) Fills the array with normally distributed random numbers. @@ -2416,15 +2416,15 @@ The function ``randn`` fills the matrix ``mtx`` with normally distributed random .. seealso:: - :cpp:class:`RNG`, - :cpp:func:`randu` + :ocv:class:`RNG`, + :ocv:func:`randu` randShuffle ----------- -.. cpp:function:: void randShuffle(InputOutputArray mtx, double iterFactor=1., RNG* rng=0) +.. ocv:function:: void randShuffle(InputOutputArray mtx, double iterFactor=1., RNG* rng=0) Shuffles the array elements randomly. @@ -2432,21 +2432,21 @@ randShuffle :param iterFactor: Scale factor that determines the number of random swap operations. See the details below. - :param rng: Optional random number generator used for shuffling. If it is zero, :cpp:func:`theRNG` () is used instead. + :param rng: Optional random number generator used for shuffling. If it is zero, :ocv:func:`theRNG` () is used instead. The function ``randShuffle`` shuffles the specified 1D array by randomly choosing pairs of elements and swapping them. The number of such swap operations will be ``mtx.rows*mtx.cols*iterFactor`` . .. seealso:: - :cpp:class:`RNG`, - :cpp:func:`sort` + :ocv:class:`RNG`, + :ocv:func:`sort` reduce ------ -.. cpp:function:: void reduce(InputArray mtx, OutputArray vec, int dim, int reduceOp, int dtype=-1) +.. ocv:function:: void reduce(InputArray mtx, OutputArray vec, int dim, int reduceOp, int dtype=-1) Reduces a matrix to a vector. @@ -2470,16 +2470,16 @@ reduce The function ``reduce`` reduces the matrix to a vector by treating the matrix rows/columns as a set of 1D vectors and performing the specified operation on the vectors until a single row/column is obtained. For example, the function can be used to compute horizontal and vertical projections of a raster image. In case of ``CV_REDUCE_SUM`` and ``CV_REDUCE_AVG`` , the output may have a larger element bit-depth to preserve accuracy. And multi-channel arrays are also supported in these two reduction modes. -.. seealso:: :cpp:func:`repeat` +.. seealso:: :ocv:func:`repeat` repeat ------ -.. cpp:function:: void repeat(InputArray src, int ny, int nx, OutputArray dst) +.. ocv:function:: void repeat(InputArray src, int ny, int nx, OutputArray dst) -.. cpp:function:: Mat repeat(InputArray src, int ny, int nx) +.. ocv:function:: Mat repeat(InputArray src, int ny, int nx) Fills the destination array with repeated copies of the source array. @@ -2492,7 +2492,7 @@ repeat :param nx: Flag to specify how many times the ``src`` is repeated along the horizontal axis. The functions -:cpp:func:`repeat` duplicate the source array one or more times along each of the two axes: +:ocv:func:`repeat` duplicate the source array one or more times along each of the two axes: .. math:: @@ -2503,7 +2503,7 @@ The second variant of the function is more convenient to use with .. seealso:: - :cpp:func:`reduce`, + :ocv:func:`reduce`, :ref:`MatrixExpressions` @@ -2511,7 +2511,7 @@ The second variant of the function is more convenient to use with saturate_cast ------------- -.. cpp:function:: template<...> _Tp saturate_cast(_Tp2 v) +.. ocv:function:: template<...> _Tp saturate_cast(_Tp2 v) Template function for accurate conversion from one primitive type to another. @@ -2530,18 +2530,18 @@ This operation is used in the simplest or most complex image processing function .. seealso:: - :cpp:func:`add`, - :cpp:func:`subtract`, - :cpp:func:`multiply`, - :cpp:func:`divide`, - :cpp:func:`Mat::convertTo` + :ocv:func:`add`, + :ocv:func:`subtract`, + :ocv:func:`multiply`, + :ocv:func:`divide`, + :ocv:func:`Mat::convertTo` scaleAdd -------- -.. cpp:function:: void scaleAdd(InputArray src1, double scale, InputArray src2, OutputArray dst) +.. ocv:function:: void scaleAdd(InputArray src1, double scale, InputArray src2, OutputArray dst) Calculates the sum of a scaled array and another array. @@ -2568,11 +2568,11 @@ The function can also be emulated with a matrix expression, for example: :: .. seealso:: - :cpp:func:`add`, - :cpp:func:`addWeighted`, - :cpp:func:`subtract`, - :cpp:func:`Mat::dot`, - :cpp:func:`Mat::convertTo`, + :ocv:func:`add`, + :ocv:func:`addWeighted`, + :ocv:func:`subtract`, + :ocv:func:`Mat::dot`, + :ocv:func:`Mat::convertTo`, :ref:`MatrixExpressions` @@ -2580,7 +2580,7 @@ The function can also be emulated with a matrix expression, for example: :: setIdentity ----------- -.. cpp:function:: void setIdentity(InputOutputArray dst, const Scalar& value=Scalar(1)) +.. ocv:function:: void setIdentity(InputOutputArray dst, const Scalar& value=Scalar(1)) Initializes a scaled identity matrix. @@ -2589,7 +2589,7 @@ setIdentity :param value: Value to assign to diagonal elements. The function -:cpp:func:`setIdentity` initializes a scaled identity matrix: +:ocv:func:`setIdentity` initializes a scaled identity matrix: .. math:: @@ -2603,18 +2603,18 @@ The function can also be emulated using the matrix initializers and the matrix e .. seealso:: - :cpp:func:`Mat::zeros`, - :cpp:func:`Mat::ones`, + :ocv:func:`Mat::zeros`, + :ocv:func:`Mat::ones`, :ref:`MatrixExpressions`, - :cpp:func:`Mat::setTo`, - :cpp:func:`Mat::operator=` + :ocv:func:`Mat::setTo`, + :ocv:func:`Mat::operator=` solve ----- -.. cpp:function:: bool solve(InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU) +.. ocv:function:: bool solve(InputArray src1, InputArray src2, OutputArray dst, int flags=DECOMP_LU) Solves one or more linear systems or least-squares problems. @@ -2647,19 +2647,19 @@ The function ``solve`` solves a linear system or least-squares problem (the latt If ``DECOMP_LU`` or ``DECOMP_CHOLESKY`` method is used, the function returns 1 if ``src1`` (or :math:`\texttt{src1}^T\texttt{src1}` ) is non-singular. Otherwise, it returns 0. In the latter case, ``dst`` is not valid. Other methods find a pseudo-solution in case of a singular left-hand side part. -.. note:: If you want to find a unity-norm solution of an under-defined singular system :math:`\texttt{src1}\cdot\texttt{dst}=0` , the function ``solve`` will not do the work. Use :cpp:func:`SVD::solveZ` instead. +.. note:: If you want to find a unity-norm solution of an under-defined singular system :math:`\texttt{src1}\cdot\texttt{dst}=0` , the function ``solve`` will not do the work. Use :ocv:func:`SVD::solveZ` instead. .. seealso:: - :cpp:func:`invert`, - :cpp:class:`SVD`, - :cpp:func:`eigen` + :ocv:func:`invert`, + :ocv:class:`SVD`, + :ocv:func:`eigen` solveCubic -------------- -.. cpp:function:: void solveCubic(InputArray coeffs, OutputArray roots) +.. ocv:function:: void solveCubic(InputArray coeffs, OutputArray roots) Finds the real roots of a cubic equation. @@ -2688,7 +2688,7 @@ The roots are stored in the ``roots`` array. solvePoly --------- -.. cpp:function:: void solvePoly(InputArray coeffs, OutputArray roots, int maxIters=300) +.. ocv:function:: void solvePoly(InputArray coeffs, OutputArray roots, int maxIters=300) Finds the real or complex roots of a polynomial equation. @@ -2709,7 +2709,7 @@ The function ``solvePoly`` finds real and complex roots of a polynomial equation sort ---- -.. cpp:function:: void sort(InputArray src, OutputArray dst, int flags) +.. ocv:function:: void sort(InputArray src, OutputArray dst, int flags) Sorts each row or each column of a matrix. @@ -2731,15 +2731,15 @@ The function ``sort`` sorts each matrix row or each matrix column in ascending o .. seealso:: - :cpp:func:`sortIdx`, - :cpp:func:`randShuffle` + :ocv:func:`sortIdx`, + :ocv:func:`randShuffle` sortIdx ------- -.. cpp:function:: void sortIdx(InputArray src, OutputArray dst, int flags) +.. ocv:function:: void sortIdx(InputArray src, OutputArray dst, int flags) Sorts each row or each column of a matrix. @@ -2768,17 +2768,17 @@ The function ``sortIdx`` sorts each matrix row or each matrix column in the asce .. seealso:: - :cpp:func:`sort`, - :cpp:func:`randShuffle` + :ocv:func:`sort`, + :ocv:func:`randShuffle` split ----- -.. cpp:function:: void split(const Mat& mtx, Mat* mv) +.. ocv:function:: void split(const Mat& mtx, Mat* mv) -.. cpp:function:: void split(const Mat& mtx, vector& mv) +.. ocv:function:: void split(const Mat& mtx, vector& mv) Divides a multi-channel array into several single-channel arrays. @@ -2793,20 +2793,20 @@ The functions ``split`` split a multi-channel array into separate single-channel \texttt{mv} [c](I) = \texttt{mtx} (I)_c If you need to extract a single channel or do some other sophisticated channel permutation, use -:cpp:func:`mixChannels` . +:ocv:func:`mixChannels` . .. seealso:: - :cpp:func:`merge`, - :cpp:func:`mixChannels`, - :cpp:func:`cvtColor` + :ocv:func:`merge`, + :ocv:func:`mixChannels`, + :ocv:func:`cvtColor` sqrt ---- -.. cpp:function:: void sqrt(InputArray src, OutputArray dst) +.. ocv:function:: void sqrt(InputArray src, OutputArray dst) Calculates a quare root of array elements. @@ -2818,15 +2818,15 @@ The functions ``sqrt`` calculate a square root of each source array element. In .. seealso:: - :cpp:func:`pow`, - :cpp:func:`magnitude` + :ocv:func:`pow`, + :ocv:func:`magnitude` subtract -------- -.. cpp:function:: void subtract(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) +.. ocv:function:: void subtract(InputArray src1, InputArray src2, OutputArray dst, InputArray mask=noArray(), int dtype=-1) Calculates the per-element difference between two arrays or array and a scalar. @@ -2874,17 +2874,17 @@ The input arrays and the destination array can all have the same or different de .. seealso:: - :cpp:func:`add`, - :cpp:func:`addWeighted`, - :cpp:func:`scaleAdd`, - :cpp:func:`convertScale`, + :ocv:func:`add`, + :ocv:func:`addWeighted`, + :ocv:func:`scaleAdd`, + :ocv:func:`convertScale`, :ref:`MatrixExpressions` SVD --- -.. cpp:class:: SVD +.. ocv:class:: SVD Class for computing Singular Value Decomposition of a floating-point matrix. The Singular Value Decomposition is used to solve least-square problems, under-determined linear systems, invert matrices, compute condition numbers, and so on. @@ -2892,19 +2892,19 @@ For a faster operation, you can pass ``flags=SVD::MODIFY_A|...`` to modify the d .. seealso:: - :cpp:func:`invert`, - :cpp:func:`solve`, - :cpp:func:`eigen`, - :cpp:func:`determinant` + :ocv:func:`invert`, + :ocv:func:`solve`, + :ocv:func:`eigen`, + :ocv:func:`determinant` SVD::SVD -------- -.. cpp:function:: SVD::SVD() +.. ocv:function:: SVD::SVD() -.. cpp:function:: SVD::SVD( InputArray A, int flags=0 ) +.. ocv:function:: SVD::SVD( InputArray A, int flags=0 ) Introduces SVD constructors. @@ -2919,14 +2919,14 @@ SVD::SVD * **SVD::FULL_UV** When the matrix is not square, by default the algorithm produces ``u`` and ``vt`` matrices of sufficiently large size for the further ``A`` reconstruction. If, however, ``FULL_UV`` flag is specified, ``u`` and ``vt`` will be full-size square orthogonal matrices. The first constructor initializes an empty ``SVD`` structure. The second constructor initializes an empty ``SVD`` structure and then calls -:cpp:func:`SVD::operator ()` . +:ocv:func:`SVD::operator ()` . SVD::operator () ---------------- -.. cpp:function:: SVD& SVD::operator ()( InputArray A, int flags=0 ) +.. ocv:function:: SVD& SVD::operator ()( InputArray A, int flags=0 ) Performs SVD of a matrix. @@ -2941,14 +2941,14 @@ SVD::operator () * **SVD::FULL_UV** When the matrix is not square, by default the algorithm produces ``u`` and ``vt`` matrices of sufficiently large size for the further ``A`` reconstruction. If, however, the ``FULL_UV`` flag is specified, ``u`` and ``vt`` are full-size square orthogonal matrices. The operator performs the singular value decomposition of the supplied matrix. The ``u``,``vt`` , and the vector of singular values ``w`` are stored in the structure. The same ``SVD`` structure can be reused many times with different matrices. Each time, if needed, the previous ``u``,``vt`` , and ``w`` are reclaimed and the new matrices are created, which is all handled by -:cpp:func:`Mat::create` . +:ocv:func:`Mat::create` . SVD::solveZ ----------- -.. cpp:function:: static void SVD::solveZ( InputArray A, OutputArray x ) +.. ocv:function:: static void SVD::solveZ( InputArray A, OutputArray x ) Solves an under-determined singular linear system. @@ -2968,11 +2968,11 @@ The method finds a unit-length solution ``x`` of a singular linear system SVD::backSubst -------------- -.. cpp:function:: void SVD::backSubst( InputArray rhs, OutputArray x ) const +.. ocv:function:: void SVD::backSubst( InputArray rhs, OutputArray x ) const Performs a singular value back substitution. - :param rhs: Right-hand side of a linear system ``A*x = rhs`` to be solved, where ``A`` has been previously decomposed using :cpp:func:`SVD::SVD` or :cpp:func:`SVD::operator ()` . + :param rhs: Right-hand side of a linear system ``A*x = rhs`` to be solved, where ``A`` has been previously decomposed using :ocv:func:`SVD::SVD` or :ocv:func:`SVD::operator ()` . :param x: Found solution of the system. @@ -2984,14 +2984,14 @@ The method computes a back substitution for the specified right-hand side: Using this technique you can either get a very accurate solution of the convenient linear system, or the best (in the least-squares terms) pseudo-solution of an overdetermined linear system. -.. note:: Explicit SVD with the further back substitution only makes sense if you need to solve many linear systems with the same left-hand side (for example, ``A`` ). If all you need is to solve a single system (possibly with multiple ``rhs`` immediately available), simply call :cpp:func:`solve` add pass ``DECOMP_SVD`` there. It does absolutely the same thing. +.. note:: Explicit SVD with the further back substitution only makes sense if you need to solve many linear systems with the same left-hand side (for example, ``A`` ). If all you need is to solve a single system (possibly with multiple ``rhs`` immediately available), simply call :ocv:func:`solve` add pass ``DECOMP_SVD`` there. It does absolutely the same thing. sum --- -.. cpp:function:: Scalar sum(InputArray mtx) +.. ocv:function:: Scalar sum(InputArray mtx) Calculates the sum of array elements. @@ -3001,38 +3001,38 @@ The functions ``sum`` calculate and return the sum of array elements, independen .. seealso:: - :cpp:func:`countNonZero`, - :cpp:func:`mean`, - :cpp:func:`meanStdDev`, - :cpp:func:`norm`, - :cpp:func:`minMaxLoc`, - :cpp:func:`reduce` + :ocv:func:`countNonZero`, + :ocv:func:`mean`, + :ocv:func:`meanStdDev`, + :ocv:func:`norm`, + :ocv:func:`minMaxLoc`, + :ocv:func:`reduce` theRNG ------ -.. cpp:function:: RNG& theRNG() +.. ocv:function:: RNG& theRNG() Returns the default random number generator. The function ``theRNG`` returns the default random number generator. For each thread, there is a separate random number generator, so you can use the function safely in multi-thread environments. If you just need to get a single random number using this generator or initialize an array, you can use -:cpp:func:`randu` or -:cpp:func:`randn` instead. But if you are going to generate many random numbers inside a loop, it is much faster to use this function to retrieve the generator and then use ``RNG::operator _Tp()`` . +:ocv:func:`randu` or +:ocv:func:`randn` instead. But if you are going to generate many random numbers inside a loop, it is much faster to use this function to retrieve the generator and then use ``RNG::operator _Tp()`` . .. seealso:: - :cpp:class:`RNG`, - :cpp:func:`randu`, - :cpp:func:`randn` + :ocv:class:`RNG`, + :ocv:func:`randu`, + :ocv:func:`randn` trace ----- -.. cpp:function:: Scalar trace(InputArray mtx) +.. ocv:function:: Scalar trace(InputArray mtx) Returns the trace of a matrix. @@ -3049,7 +3049,7 @@ The function ``trace`` returns the sum of the diagonal elements of the matrix `` transform --------- -.. cpp:function:: void transform(InputArray src, OutputArray dst, InputArray mtx ) +.. ocv:function:: void transform(InputArray src, OutputArray dst, InputArray mtx ) Performs the matrix transformation of every array element. @@ -3083,18 +3083,18 @@ points, arbitrary linear color space transformation (such as various kinds of RG .. seealso:: - :cpp:func:`perspectiveTransform`, - :cpp:func:`getAffineTransform`, - :cpp:func:`estimateRigidTransform`, - :cpp:func:`warpAffine`, - :cpp:func:`warpPerspective` + :ocv:func:`perspectiveTransform`, + :ocv:func:`getAffineTransform`, + :ocv:func:`estimateRigidTransform`, + :ocv:func:`warpAffine`, + :ocv:func:`warpPerspective` transpose --------- -.. cpp:function:: void transpose(InputArray src, OutputArray dst) +.. ocv:function:: void transpose(InputArray src, OutputArray dst) Transposes a matrix. @@ -3102,7 +3102,7 @@ transpose :param dst: Destination array of the same type as ``src`` . -The function :cpp:func:`transpose` transposes the matrix ``src`` : +The function :ocv:func:`transpose` transposes the matrix ``src`` : .. math:: diff --git a/modules/core/doc/utility_and_system_functions_and_macros.rst b/modules/core/doc/utility_and_system_functions_and_macros.rst index 3ce99f1..5b93ed3 100644 --- a/modules/core/doc/utility_and_system_functions_and_macros.rst +++ b/modules/core/doc/utility_and_system_functions_and_macros.rst @@ -7,7 +7,7 @@ Utility and System Functions and Macros alignPtr ------------ -.. cpp:function:: template _Tp* alignPtr(_Tp* ptr, int n=sizeof(_Tp)) +.. ocv:function:: template _Tp* alignPtr(_Tp* ptr, int n=sizeof(_Tp)) Aligns a pointer to the specified number of bytes. @@ -25,7 +25,7 @@ The function returns the aligned pointer of the same type as the input pointer: alignSize ------------- -.. cpp:function:: size_t alignSize(size_t sz, int n) +.. ocv:function:: size_t alignSize(size_t sz, int n) Aligns a buffer size to the specified number of bytes. @@ -43,7 +43,7 @@ The function returns the minimum number that is greater or equal to ``sz`` and i allocate ------------ -.. cpp:function:: template _Tp* allocate(size_t n) +.. ocv:function:: template _Tp* allocate(size_t n) Allocates an array of elements. @@ -55,7 +55,7 @@ The generic function ``allocate`` allocates a buffer for the specified number of deallocate -------------- -.. cpp:function:: template void deallocate(_Tp* ptr, size_t n) +.. ocv:function:: template void deallocate(_Tp* ptr, size_t n) Deallocates an array of elements. @@ -64,8 +64,8 @@ deallocate :param n: Number of elements in the buffer. The generic function ``deallocate`` deallocates the buffer allocated with -:cpp:func:`allocate` . The number of elements must match the number passed to -:cpp:func:`allocate` . +:ocv:func:`allocate` . The number of elements must match the number passed to +:ocv:func:`allocate` . .. index:: CV_Assert @@ -73,7 +73,7 @@ The generic function ``deallocate`` deallocates the buffer allocated with CV_Assert --------- -.. cpp:function:: CV_Assert(expr) +.. ocv:function:: CV_Assert(expr) Checks a condition at runtime. :: @@ -84,17 +84,17 @@ CV_Assert :param expr: Expression to check. The macros ``CV_Assert`` and ``CV_DbgAssert`` evaluate the specified expression. If it is 0, the macros raise an error (see -:cpp:func:`error` ). The macro ``CV_Assert`` checks the condition in both Debug and Release configurations, while ``CV_DbgAssert`` is only retained in the Debug configuration. +:ocv:func:`error` ). The macro ``CV_Assert`` checks the condition in both Debug and Release configurations, while ``CV_DbgAssert`` is only retained in the Debug configuration. .. index:: error error --------- -.. cpp:function:: void error( const Exception& exc ) +.. ocv:function:: void error( const Exception& exc ) -.. cpp:function:: #define CV_Error( code, msg ) <...> +.. ocv:function:: #define CV_Error( code, msg ) <...> -.. cpp:function:: #define CV_Error_( code, args ) <...> +.. ocv:function:: #define CV_Error_( code, args ) <...> Signals an error and raises an exception. @@ -148,13 +148,13 @@ Exception class passed to error :: }; The class ``Exception`` encapsulates all or almost all the necessary information about the error happened in the program. The exception is usually constructed and thrown implicitly via ``CV_Error`` and ``CV_Error_`` macros. See -:cpp:func:`error` . +:ocv:func:`error` . .. index:: fastMalloc fastMalloc -------------- -.. cpp:function:: void* fastMalloc(size_t size) +.. ocv:function:: void* fastMalloc(size_t size) Allocates an aligned memory buffer. @@ -166,74 +166,74 @@ The function allocates the buffer of the specified size and returns it. When the fastFree ------------ -.. cpp:function:: void fastFree(void* ptr) +.. ocv:function:: void fastFree(void* ptr) Deallocates a memory buffer. :param ptr: Pointer to the allocated buffer. The function deallocates the buffer allocated with -:cpp:func:`fastMalloc` . +:ocv:func:`fastMalloc` . If NULL pointer is passed, the function does nothing. .. index:: format format ---------- -.. cpp:function:: string format( const char* fmt, ... ) +.. ocv:function:: string format( const char* fmt, ... ) Returns a text string formatted using the ``printf`` -like expression. :param fmt: ``printf`` -compatible formatting specifiers. The function acts like ``sprintf`` but forms and returns an STL string. It can be used to form an error message in the -:cpp:func:`Exception` constructor. +:ocv:func:`Exception` constructor. .. index:: getNumThreads getNumThreads ----------------- -.. cpp:function:: int getNumThreads() +.. ocv:function:: int getNumThreads() Returns the number of threads used by OpenCV. The function returns the number of threads that is used by OpenCV. See Also: -:cpp:func:`setNumThreads`, -:cpp:func:`getThreadNum` +:ocv:func:`setNumThreads`, +:ocv:func:`getThreadNum` .. index:: getThreadNum getThreadNum ---------------- -.. cpp:function:: int getThreadNum() +.. ocv:function:: int getThreadNum() Returns the index of the currently executed thread. The function returns a 0-based index of the currently executed thread. The function is only valid inside a parallel OpenMP region. When OpenCV is built without OpenMP support, the function always returns 0. See Also: -:cpp:func:`setNumThreads`, -:cpp:func:`getNumThreads` . +:ocv:func:`setNumThreads`, +:ocv:func:`getNumThreads` . .. index:: getTickCount getTickCount ---------------- -.. cpp:function:: int64 getTickCount() +.. ocv:function:: int64 getTickCount() Returns the number of ticks. The function returns the number of ticks after the certain event (for example, when the machine was turned on). It can be used to initialize -:cpp:func:`RNG` or to measure a function execution time by reading the tick count before and after the function call. See also the tick frequency. +:ocv:func:`RNG` or to measure a function execution time by reading the tick count before and after the function call. See also the tick frequency. .. index:: getTickFrequency getTickFrequency -------------------- -.. cpp:function:: double getTickFrequency() +.. ocv:function:: double getTickFrequency() Returns the number of ticks per second. @@ -248,7 +248,7 @@ That is, the following code computes the execution time in seconds: :: getCPUTickCount ---------------- -.. cpp:function:: int64 getCPUTickCount() +.. ocv:function:: int64 getCPUTickCount() Returns the number of CPU ticks. @@ -258,7 +258,7 @@ The function returns the current number of CPU ticks on some architectures (such setNumThreads ----------------- -.. cpp:function:: void setNumThreads(int nthreads) +.. ocv:function:: void setNumThreads(int nthreads) Sets the number of threads used by OpenCV. @@ -267,14 +267,14 @@ setNumThreads The function sets the number of threads used by OpenCV in parallel OpenMP regions. If ``nthreads=0`` , the function uses the default number of threads that is usually equal to the number of the processing cores. See Also: -:cpp:func:`getNumThreads`, -:cpp:func:`getThreadNum` +:ocv:func:`getNumThreads`, +:ocv:func:`getThreadNum` .. index:: setUseOptimized setUseOptimized ----------------- -.. cpp:function:: void setUseOptimized(bool onoff) +.. ocv:function:: void setUseOptimized(bool onoff) Enables or disables the optimized code. @@ -288,7 +288,7 @@ By default, the optimized code is enabled (unless you disable it in CMake). The useOptimized ----------------- -.. cpp:function:: bool useOptimized() +.. ocv:function:: bool useOptimized() Returns status of the optimized code use diff --git a/modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst b/modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst index 84c7a6a..1ce22cb 100644 --- a/modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst +++ b/modules/features2d/doc/common_interfaces_of_descriptor_extractors.rst @@ -13,7 +13,7 @@ descriptor extractors inherit the DescriptorExtractor ------------------- -.. cpp:class:: DescriptorExtractor +.. ocv:class:: DescriptorExtractor Abstract base class for computing descriptors for image keypoints :: @@ -51,7 +51,7 @@ descriptors is represented as DescriptorExtractor::compute -------------------------------- -.. cpp:function:: void DescriptorExtractor::compute( const Mat& image, vector& keypoints, Mat& descriptors ) const +.. ocv:function:: void DescriptorExtractor::compute( const Mat& image, vector& keypoints, Mat& descriptors ) const Computes the descriptors for a set of keypoints detected in an image (first variant) or image set (second variant). @@ -61,7 +61,7 @@ DescriptorExtractor::compute :param descriptors: Descriptors. Row i is the descriptor for keypoint i. -.. cpp:function:: void DescriptorExtractor::compute( const vector& images, vector >& keypoints, vector& descriptors ) const +.. ocv:function:: void DescriptorExtractor::compute( const vector& images, vector >& keypoints, vector& descriptors ) const :param images: Image set. @@ -75,7 +75,7 @@ DescriptorExtractor::compute DescriptorExtractor::read ----------------------------- -.. cpp:function:: void DescriptorExtractor::read( const FileNode& fn ) +.. ocv:function:: void DescriptorExtractor::read( const FileNode& fn ) Reads the object of a descriptor extractor from a file node. @@ -85,7 +85,7 @@ DescriptorExtractor::read DescriptorExtractor::write ------------------------------ -.. cpp:function:: void DescriptorExtractor::write( FileStorage& fs ) const +.. ocv:function:: void DescriptorExtractor::write( FileStorage& fs ) const Writes the object of a descriptor extractor to a file storage. @@ -95,7 +95,7 @@ DescriptorExtractor::write DescriptorExtractor::create ------------------------------- -.. cpp:function:: Ptr DescriptorExtractor::create( const string& descriptorExtractorType ) +.. ocv:function:: Ptr DescriptorExtractor::create( const string& descriptorExtractorType ) Creates a descriptor extractor by name. @@ -118,7 +118,7 @@ for example: ``"OpponentSIFT"`` . SiftDescriptorExtractor ----------------------- -.. cpp:class:: SiftDescriptorExtractor +.. ocv:class:: SiftDescriptorExtractor Wrapping class for computing descriptors by using the :ref:`SIFT` class :: @@ -150,7 +150,7 @@ Wrapping class for computing descriptors by using the SurfDescriptorExtractor ----------------------- -.. cpp:class:: SurfDescriptorExtractor +.. ocv:class:: SurfDescriptorExtractor Wrapping class for computing descriptors by using the :ref:`SURF` class :: @@ -176,7 +176,7 @@ Wrapping class for computing descriptors by using the OrbDescriptorExtractor --------------------------- -.. cpp:class:: OrbDescriptorExtractor +.. ocv:class:: OrbDescriptorExtractor Wrapping class for computing descriptors by using the :ref:`ORB` class :: @@ -200,7 +200,7 @@ Wrapping class for computing descriptors by using the CalonderDescriptorExtractor --------------------------- -.. cpp:class:: CalonderDescriptorExtractor +.. ocv:class:: CalonderDescriptorExtractor Wrapping class for computing descriptors by using the :ref:`RTreeClassifier` class :: @@ -226,7 +226,7 @@ Wrapping class for computing descriptors by using the OpponentColorDescriptorExtractor -------------------------------- -.. cpp:class:: OpponentColorDescriptorExtractor +.. ocv:class:: OpponentColorDescriptorExtractor Class adapting a descriptor extractor to compute descriptors in the Opponent Color Space (refer to Van de Sande et al., CGIV 2008 *Color Descriptors for Object Category Recognition*). @@ -254,7 +254,7 @@ them into a single color descriptor. :: BriefDescriptorExtractor ------------------------ -.. cpp:class:: BriefDescriptorExtractor +.. ocv:class:: BriefDescriptorExtractor Class for computing BRIEF descriptors described in a paper of Calonder M., Lepetit V., Strecha C., Fua P. *BRIEF: Binary Robust Independent Elementary Features* , diff --git a/modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst b/modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst index ce6f79f..49f780d 100644 --- a/modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst +++ b/modules/features2d/doc/common_interfaces_of_descriptor_matchers.rst @@ -15,7 +15,7 @@ descriptor matchers inherit DMatch ------ -.. cpp:class:: DMatch +.. ocv:class:: DMatch Class for matching keypoint descriptors: query descriptor index, train descriptor index, train image index, and distance between descriptors :: @@ -108,7 +108,7 @@ with an image set. :: DescriptorMatcher::add -------------------------- -.. cpp:function:: void add( const vector& descriptors ) +.. ocv:function:: void add( const vector& descriptors ) Adds descriptors to train a descriptor collection. If the collection ``trainDescCollectionis`` is not empty, the new descriptors are added to existing train descriptors. @@ -118,7 +118,7 @@ DescriptorMatcher::add DescriptorMatcher::getTrainDescriptors ------------------------------------------ -.. cpp:function:: const vector& getTrainDescriptors() const +.. ocv:function:: const vector& getTrainDescriptors() const Returns a constant link to the train descriptor collection ``trainDescCollection`` . @@ -126,7 +126,7 @@ DescriptorMatcher::getTrainDescriptors DescriptorMatcher::clear ---------------------------- -.. cpp:function:: void DescriptorMatcher::clear() +.. ocv:function:: void DescriptorMatcher::clear() Clears the train descriptor collection. @@ -134,7 +134,7 @@ DescriptorMatcher::clear DescriptorMatcher::empty ---------------------------- -.. cpp:function:: bool DescriptorMatcher::empty() const +.. ocv:function:: bool DescriptorMatcher::empty() const Returns true if there are no train descriptors in the collection. @@ -142,7 +142,7 @@ DescriptorMatcher::empty DescriptorMatcher::isMaskSupported -------------------------------------- -.. cpp:function:: bool DescriptorMatcher::isMaskSupported() +.. ocv:function:: bool DescriptorMatcher::isMaskSupported() Returns true if the descriptor matcher supports masking permissible matches. @@ -150,7 +150,7 @@ DescriptorMatcher::isMaskSupported DescriptorMatcher::train ---------------------------- -.. cpp:function:: void DescriptorMatcher::train() +.. ocv:function:: void DescriptorMatcher::train() Trains a descriptor matcher (for example, the flann index). In all methods to match, the method ``train()`` is run every time before matching. Some descriptor matchers (for example, ``BruteForceMatcher``) have an empty implementation of this method. Other matchers really train their inner structures (for example, ``FlannBasedMatcher`` trains ``flann::Index`` ). @@ -158,9 +158,9 @@ DescriptorMatcher::train DescriptorMatcher::match ---------------------------- -.. cpp:function:: void DescriptorMatcher::match( const Mat& queryDescriptors, const Mat& trainDescriptors, vector& matches, const Mat& mask=Mat() ) const +.. ocv:function:: void DescriptorMatcher::match( const Mat& queryDescriptors, const Mat& trainDescriptors, vector& matches, const Mat& mask=Mat() ) const -.. cpp:function:: void DescriptorMatcher::match( const Mat& queryDescriptors, vector& matches, const vector& masks=vector() ) +.. ocv:function:: void DescriptorMatcher::match( const Mat& queryDescriptors, vector& matches, const vector& masks=vector() ) Finds the best match for each descriptor from a query set. @@ -180,9 +180,9 @@ In the first variant of this method, the train descriptors are passed as an inpu DescriptorMatcher::knnMatch ------------------------------- -.. cpp:function:: void DescriptorMatcher::knnMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, vector >& matches, int k, const Mat& mask=Mat(), bool compactResult=false ) const +.. ocv:function:: void DescriptorMatcher::knnMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, vector >& matches, int k, const Mat& mask=Mat(), bool compactResult=false ) const -.. cpp:function:: void DescriptorMatcher::knnMatch( const Mat& queryDescriptors, vector >& matches, int k, const vector& masks=vector(), bool compactResult=false ) +.. ocv:function:: void DescriptorMatcher::knnMatch( const Mat& queryDescriptors, vector >& matches, int k, const vector& masks=vector(), bool compactResult=false ) Finds the k best matches for each descriptor from a query set. @@ -200,15 +200,15 @@ DescriptorMatcher::knnMatch :param compactResult: Parameter that is used when the mask (or masks) is not empty. If ``compactResult`` is false, the ``matches`` vector has the same size as ``queryDescriptors`` rows. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors. -These extended variants of :cpp:func:`DescriptorMatcher::match` methods find several best matches for each query descriptor. The matches are returned in the distance increasing order. See :cpp:func:`DescriptorMatcher::match` for the details about query and train descriptors. +These extended variants of :ocv:func:`DescriptorMatcher::match` methods find several best matches for each query descriptor. The matches are returned in the distance increasing order. See :ocv:func:`DescriptorMatcher::match` for the details about query and train descriptors. .. index:: DescriptorMatcher::radiusMatch DescriptorMatcher::radiusMatch ---------------------------------- -.. cpp:function:: void DescriptorMatcher::radiusMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, vector >& matches, float maxDistance, const Mat& mask=Mat(), bool compactResult=false ) const +.. ocv:function:: void DescriptorMatcher::radiusMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, vector >& matches, float maxDistance, const Mat& mask=Mat(), bool compactResult=false ) const -.. cpp:function:: void DescriptorMatcher::radiusMatch( const Mat& queryDescriptors, vector >& matches, float maxDistance, const vector& masks=vector(), bool compactResult=false ) +.. ocv:function:: void DescriptorMatcher::radiusMatch( const Mat& queryDescriptors, vector >& matches, float maxDistance, const vector& masks=vector(), bool compactResult=false ) For each query descriptor, finds the training descriptors not farther than the specified distance. @@ -232,7 +232,7 @@ For each query descriptor, the methods find such training descriptors that the d DescriptorMatcher::clone ---------------------------- -.. cpp:function:: Ptr DescriptorMatcher::clone( bool emptyTrainData ) const +.. ocv:function:: Ptr DescriptorMatcher::clone( bool emptyTrainData ) const Clones the matcher. @@ -242,7 +242,7 @@ DescriptorMatcher::clone DescriptorMatcher::create ----------------------------- -.. cpp:function:: Ptr DescriptorMatcher::create( const string& descriptorMatcherType ) +.. ocv:function:: Ptr DescriptorMatcher::create( const string& descriptorMatcherType ) Creates a descriptor matcher of a given type with the default parameters (using default constructor). @@ -353,7 +353,7 @@ FlannBasedMatcher ----------------- .. c:type:: FlannBasedMatcher -Flann-based descriptor matcher. This matcher trains :ref:`flann::Index` on a train descriptor collection and calls its nearest search methods to find the best matches. So, this matcher may be faster when matching a large train collection than the brute force matcher. ``FlannBasedMatcher`` does not support masking permissible matches of descriptor sets because :cpp:func:`flann::Index` does not support this. :: +Flann-based descriptor matcher. This matcher trains :ref:`flann::Index` on a train descriptor collection and calls its nearest search methods to find the best matches. So, this matcher may be faster when matching a large train collection than the brute force matcher. ``FlannBasedMatcher`` does not support masking permissible matches of descriptor sets because :ocv:func:`flann::Index` does not support this. :: class FlannBasedMatcher : public DescriptorMatcher { diff --git a/modules/features2d/doc/common_interfaces_of_feature_detectors.rst b/modules/features2d/doc/common_interfaces_of_feature_detectors.rst index 86f24e7..67a7fa8 100644 --- a/modules/features2d/doc/common_interfaces_of_feature_detectors.rst +++ b/modules/features2d/doc/common_interfaces_of_feature_detectors.rst @@ -14,7 +14,7 @@ inherit the KeyPoint -------- -.. cpp:class:: KeyPoint +.. ocv:class:: KeyPoint Data structure for salient point detectors :: @@ -75,7 +75,7 @@ Data structure for salient point detectors :: FeatureDetector --------------- -.. cpp:class:: FeatureDetector +.. ocv:class:: FeatureDetector Abstract base class for 2D image feature detectors :: @@ -105,7 +105,7 @@ Abstract base class for 2D image feature detectors :: FeatureDetector::detect --------------------------- -.. cpp:function:: void FeatureDetector::detect( const Mat& image, vector& keypoints, const Mat& mask=Mat() ) const +.. ocv:function:: void FeatureDetector::detect( const Mat& image, vector& keypoints, const Mat& mask=Mat() ) const Detects keypoints in an image (first variant) or image set (second variant). @@ -115,7 +115,7 @@ FeatureDetector::detect :param mask: Mask specifying where to look for keypoints (optional). It must be a char matrix with non-zero values in the region of interest. -.. cpp:function:: void FeatureDetector::detect( const vector& images, vector >& keypoints, const vector& masks=vector() ) const +.. ocv:function:: void FeatureDetector::detect( const vector& images, vector >& keypoints, const vector& masks=vector() ) const :param images: Image set. @@ -127,7 +127,7 @@ FeatureDetector::detect FeatureDetector::read ------------------------- -.. cpp:function:: void FeatureDetector::read( const FileNode& fn ) +.. ocv:function:: void FeatureDetector::read( const FileNode& fn ) Reads a feature detector object from a file node. @@ -137,7 +137,7 @@ FeatureDetector::read FeatureDetector::write -------------------------- -.. cpp:function:: void FeatureDetector::write( FileStorage& fs ) const +.. ocv:function:: void FeatureDetector::write( FileStorage& fs ) const Writes a feature detector object to a file storage. @@ -147,7 +147,7 @@ FeatureDetector::write FeatureDetector::create --------------------------- -.. cpp:function:: Ptr FeatureDetector::create( const string& detectorType ) +.. ocv:function:: Ptr FeatureDetector::create( const string& detectorType ) Creates a feature detector by its name. @@ -175,7 +175,7 @@ for example: ``"GridFAST"``, ``"PyramidSTAR"`` . FastFeatureDetector ------------------- -.. cpp:class:: FastFeatureDetector +.. ocv:class:: FastFeatureDetector Wrapping class for feature detection using the :ref:`FAST` method :: @@ -197,7 +197,7 @@ Wrapping class for feature detection using the GoodFeaturesToTrackDetector --------------------------- -.. cpp:class:: GoodFeaturesToTrackDetector +.. ocv:class:: GoodFeaturesToTrackDetector Wrapping class for feature detection using the :ref:`goodFeaturesToTrack` function :: @@ -240,7 +240,7 @@ Wrapping class for feature detection using the MserFeatureDetector ------------------- -.. cpp:class:: MserFeatureDetector +.. ocv:class:: MserFeatureDetector Wrapping class for feature detection using the :ref:`MSER` class :: @@ -266,7 +266,7 @@ Wrapping class for feature detection using the StarFeatureDetector ------------------- -.. cpp:class:: StarFeatureDetector +.. ocv:class:: StarFeatureDetector Wrapping class for feature detection using the :ref:`StarDetector` class :: @@ -290,7 +290,7 @@ Wrapping class for feature detection using the SiftFeatureDetector ------------------- -.. cpp:class:: SiftFeatureDetector +.. ocv:class:: SiftFeatureDetector Wrapping class for feature detection using the :ref:`SIFT` class :: @@ -319,7 +319,7 @@ Wrapping class for feature detection using the SurfFeatureDetector ------------------- -.. cpp:class:: SurfFeatureDetector +.. ocv:class:: SurfFeatureDetector Wrapping class for feature detection using the :ref:`SURF` class :: @@ -342,7 +342,7 @@ Wrapping class for feature detection using the OrbFeatureDetector ------------------- -.. cpp:class:: OrbFeatureDetector +.. ocv:class:: OrbFeatureDetector Wrapping class for feature detection using the :ref:`ORB` class :: @@ -364,7 +364,7 @@ Wrapping class for feature detection using the SimpleBlobDetector ------------------- -.. cpp:class:: SimpleBlobDetector +.. ocv:class:: SimpleBlobDetector Class for extracting blobs from an image :: @@ -402,7 +402,7 @@ Class for extracting blobs from an image :: ... }; -The class implements a simple algorithm for extracting blobs from an image. It converts the source image to binary images by applying thresholding with several thresholds from ``minThreshold`` (inclusive) to ``maxThreshold`` (exclusive) with distance ``thresholdStep`` between neighboring thresholds. Then connected components are extracted from every binary image by :cpp:func:`findContours` and their centers are calculated. Centers from several binary images are grouped by their coordinates. Close centers form one group that corresponds to one blob and this is controled by the ``minDistBetweenBlobs`` parameter. Then final centers of blobs and their radiuses are estimated from these groups and returned as locations and sizes of keypoints. +The class implements a simple algorithm for extracting blobs from an image. It converts the source image to binary images by applying thresholding with several thresholds from ``minThreshold`` (inclusive) to ``maxThreshold`` (exclusive) with distance ``thresholdStep`` between neighboring thresholds. Then connected components are extracted from every binary image by :ocv:func:`findContours` and their centers are calculated. Centers from several binary images are grouped by their coordinates. Close centers form one group that corresponds to one blob and this is controled by the ``minDistBetweenBlobs`` parameter. Then final centers of blobs and their radiuses are estimated from these groups and returned as locations and sizes of keypoints. This class performs several filtrations of returned blobs. You should set ``filterBy*`` to true/false to turn on/off corresponding filtration. Available filtrations: @@ -426,7 +426,7 @@ Default values of parameters are tuned to extract dark circular blobs. GridAdaptedFeatureDetector -------------------------- -.. cpp:class:: GridAdaptedFeatureDetector +.. ocv:class:: GridAdaptedFeatureDetector Class adapting a detector to partition the source image into a grid and detect points in each cell :: @@ -456,7 +456,7 @@ Class adapting a detector to partition the source image into a grid and detect p PyramidAdaptedFeatureDetector ----------------------------- -.. cpp:class:: PyramidAdaptedFeatureDetector +.. ocv:class:: PyramidAdaptedFeatureDetector Class adapting a detector to detect points over multiple levels of a Gaussian pyramid. Consider using this class for detectors that are not inherently scaled. :: @@ -477,7 +477,7 @@ Class adapting a detector to detect points over multiple levels of a Gaussian py DynamicAdaptedFeatureDetector ----------------------------- -.. cpp:class:: DynamicAdaptedFeatureDetector +.. ocv:class:: DynamicAdaptedFeatureDetector Adaptively adjusting detector that iteratively detects features until the desired number is found :: @@ -522,7 +522,7 @@ Example of creating ``DynamicAdaptedFeatureDetector`` : :: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector ---------------------------------------------------------------- -.. cpp:function:: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector( const Ptr& adjuster, int min_features, int max_features, int max_iters ) +.. ocv:function:: DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector( const Ptr& adjuster, int min_features, int max_features, int max_iters ) Constructs the class. @@ -539,7 +539,7 @@ DynamicAdaptedFeatureDetector::DynamicAdaptedFeatureDetector AdjusterAdapter --------------- -.. cpp:class:: AdjusterAdapter +.. ocv:class:: AdjusterAdapter Class providing an interface for adjusting parameters of a feature detector. This interface is used by :ref:`DynamicAdaptedFeatureDetector` . It is a wrapper for :ref:`FeatureDetector` that enables adjusting parameters after feature detection. :: @@ -563,7 +563,7 @@ See AdjusterAdapter::tooFew --------------------------- -.. cpp:function:: void AdjusterAdapter::tooFew(int min, int n_detected) +.. ocv:function:: void AdjusterAdapter::tooFew(int min, int n_detected) Adjusts the detector parameters to detect more features. @@ -583,7 +583,7 @@ Example: :: AdjusterAdapter::tooMany ---------------------------- -.. cpp:function:: void AdjusterAdapter::tooMany(int max, int n_detected) +.. ocv:function:: void AdjusterAdapter::tooMany(int max, int n_detected) Adjusts the detector parameters to detect less features. @@ -603,7 +603,7 @@ Example: :: AdjusterAdapter::good ------------------------- -.. cpp:function:: bool AdjusterAdapter::good() const +.. ocv:function:: bool AdjusterAdapter::good() const Returns false if the detector parameters cannot be adjusted any more. @@ -620,7 +620,7 @@ Example: :: FastAdjuster ------------ -.. cpp:class:: FastAdjuster +.. ocv:class:: FastAdjuster :ref:`AdjusterAdapter` for :ref:`FastFeatureDetector`. This class decreases or increases the threshold value by 1. :: @@ -636,7 +636,7 @@ FastAdjuster StarAdjuster ------------ -.. cpp:class:: StarAdjuster +.. ocv:class:: StarAdjuster :ref:`AdjusterAdapter` for :ref:`StarFeatureDetector`. This class adjusts the ``responseThreshhold`` of ``StarFeatureDetector``. :: @@ -651,7 +651,7 @@ StarAdjuster SurfAdjuster ------------ -.. cpp:class:: SurfAdjuster +.. ocv:class:: SurfAdjuster :ref:`AdjusterAdapter` for :ref:`SurfFeatureDetector`. This class adjusts the ``hessianThreshold`` of ``SurfFeatureDetector``. :: @@ -665,7 +665,7 @@ SurfAdjuster FeatureDetector --------------- -.. cpp:class:: FeatureDetector +.. ocv:class:: FeatureDetector Abstract base class for 2D image feature detectors :: diff --git a/modules/features2d/doc/common_interfaces_of_generic_descriptor_matchers.rst b/modules/features2d/doc/common_interfaces_of_generic_descriptor_matchers.rst index b2624b3..ad5aa95 100644 --- a/modules/features2d/doc/common_interfaces_of_generic_descriptor_matchers.rst +++ b/modules/features2d/doc/common_interfaces_of_generic_descriptor_matchers.rst @@ -7,15 +7,15 @@ Matchers of keypoint descriptors in OpenCV have wrappers with a common interface between different algorithms solving the same problem. This section is devoted to matching descriptors that cannot be represented as vectors in a multidimensional space. ``GenericDescriptorMatcher`` is a more generic interface for descriptors. It does not make any assumptions about descriptor representation. Every descriptor with the -:cpp:class:`DescriptorExtractor` interface has a wrapper with the ``GenericDescriptorMatcher`` interface (see -:cpp:class:`VectorDescriptorMatcher` ). +:ocv:class:`DescriptorExtractor` interface has a wrapper with the ``GenericDescriptorMatcher`` interface (see +:ocv:class:`VectorDescriptorMatcher` ). There are descriptors such as the One-way descriptor and Ferns that have the ``GenericDescriptorMatcher`` interface implemented but do not support ``DescriptorExtractor``. .. index:: GenericDescriptorMatcher GenericDescriptorMatcher ------------------------ -.. cpp:class:: GenericDescriptorMatcher +.. ocv:class:: GenericDescriptorMatcher Abstract interface for extracting and matching a keypoint descriptor. There are also :ref:`DescriptorExtractor` and :ref:`DescriptorMatcher` for these purposes but their interfaces are intended for descriptors represented as vectors in a multidimensional space. ``GenericDescriptorMatcher`` is a more generic interface for descriptors. :ref:`DescriptorMatcher` and ``GenericDescriptorMatcher`` have two groups of match methods: for matching keypoints of an image with another image or with an image set. :: @@ -83,7 +83,7 @@ Abstract interface for extracting and matching a keypoint descriptor. There are GenericDescriptorMatcher::add --------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::add( const vector& images, vector >& keypoints ) +.. ocv:function:: void GenericDescriptorMatcher::add( const vector& images, vector >& keypoints ) Adds images and their keypoints to the training collection stored in the class instance. @@ -95,7 +95,7 @@ GenericDescriptorMatcher::add GenericDescriptorMatcher::getTrainImages -------------------------------------------- -.. cpp:function:: const vector& GenericDescriptorMatcher::getTrainImages() const +.. ocv:function:: const vector& GenericDescriptorMatcher::getTrainImages() const Returns a train image collection. @@ -103,7 +103,7 @@ GenericDescriptorMatcher::getTrainImages GenericDescriptorMatcher::getTrainKeypoints ----------------------------------------------- -.. cpp:function:: const vector >& GenericDescriptorMatcher::getTrainKeypoints() const +.. ocv:function:: const vector >& GenericDescriptorMatcher::getTrainKeypoints() const Returns a train keypoints collection. @@ -111,7 +111,7 @@ GenericDescriptorMatcher::getTrainKeypoints GenericDescriptorMatcher::clear ----------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::clear() +.. ocv:function:: void GenericDescriptorMatcher::clear() Clears a train collection (images and keypoints). @@ -119,7 +119,7 @@ GenericDescriptorMatcher::clear GenericDescriptorMatcher::train ----------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::train() +.. ocv:function:: void GenericDescriptorMatcher::train() Trains an object, for example, a tree-based structure, to extract descriptors or to optimize descriptors matching. @@ -127,7 +127,7 @@ GenericDescriptorMatcher::train GenericDescriptorMatcher::isMaskSupported --------------------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::isMaskSupported() +.. ocv:function:: void GenericDescriptorMatcher::isMaskSupported() Returns true if a generic descriptor matcher supports masking permissible matches. @@ -135,9 +135,9 @@ GenericDescriptorMatcher::isMaskSupported GenericDescriptorMatcher::classify -------------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::classify( const Mat& queryImage, vector& queryKeypoints, const Mat& trainImage, vector& trainKeypoints ) const +.. ocv:function:: void GenericDescriptorMatcher::classify( const Mat& queryImage, vector& queryKeypoints, const Mat& trainImage, vector& trainKeypoints ) const -.. cpp:function:: void GenericDescriptorMatcher::classify( const Mat& queryImage, vector& queryKeypoints ) +.. ocv:function:: void GenericDescriptorMatcher::classify( const Mat& queryImage, vector& queryKeypoints ) Classify keypoints from a query set. @@ -163,9 +163,9 @@ GenericDescriptorMatcher::classify GenericDescriptorMatcher::match ----------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::match( const Mat& queryImage, vector& queryKeypoints, const Mat& trainImage, vector& trainKeypoints, vector& matches, const Mat& mask=Mat() ) const +.. ocv:function:: void GenericDescriptorMatcher::match( const Mat& queryImage, vector& queryKeypoints, const Mat& trainImage, vector& trainKeypoints, vector& matches, const Mat& mask=Mat() ) const -.. cpp:function:: void GenericDescriptorMatcher::match( const Mat& queryImage, vector& queryKeypoints, vector& matches, const vector& masks=vector() ) +.. ocv:function:: void GenericDescriptorMatcher::match( const Mat& queryImage, vector& queryKeypoints, vector& matches, const vector& masks=vector() ) Find the best match in the training set for each keypoint from the query set. @@ -189,9 +189,9 @@ The methods find the best match for each query keypoint. In the first variant of GenericDescriptorMatcher::knnMatch -------------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::knnMatch( const Mat& queryImage, vector& queryKeypoints, const Mat& trainImage, vector& trainKeypoints, vector >& matches, int k, const Mat& mask=Mat(), bool compactResult=false ) const +.. ocv:function:: void GenericDescriptorMatcher::knnMatch( const Mat& queryImage, vector& queryKeypoints, const Mat& trainImage, vector& trainKeypoints, vector >& matches, int k, const Mat& mask=Mat(), bool compactResult=false ) const -.. cpp:function:: void GenericDescriptorMatcher::knnMatch( const Mat& queryImage, vector& queryKeypoints, vector >& matches, int k, const vector& masks=vector(), bool compactResult=false ) +.. ocv:function:: void GenericDescriptorMatcher::knnMatch( const Mat& queryImage, vector& queryKeypoints, vector >& matches, int k, const vector& masks=vector(), bool compactResult=false ) Find the ``k`` best matches for each query keypoint. @@ -201,9 +201,9 @@ The methods are extended variants of ``GenericDescriptorMatch::match``. The para GenericDescriptorMatcher::radiusMatch ----------------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::radiusMatch( const Mat& queryImage, vector& queryKeypoints, const Mat& trainImage, vector& trainKeypoints, vector >& matches, float maxDistance, const Mat& mask=Mat(), bool compactResult=false ) const +.. ocv:function:: void GenericDescriptorMatcher::radiusMatch( const Mat& queryImage, vector& queryKeypoints, const Mat& trainImage, vector& trainKeypoints, vector >& matches, float maxDistance, const Mat& mask=Mat(), bool compactResult=false ) const -.. cpp:function:: void GenericDescriptorMatcher::radiusMatch( const Mat& queryImage, vector& queryKeypoints, vector >& matches, float maxDistance, const vector& masks=vector(), bool compactResult=false ) +.. ocv:function:: void GenericDescriptorMatcher::radiusMatch( const Mat& queryImage, vector& queryKeypoints, vector >& matches, float maxDistance, const vector& masks=vector(), bool compactResult=false ) For each query keypoint, find the training keypoints not farther than the specified distance. @@ -213,7 +213,7 @@ The methods are similar to ``DescriptorMatcher::radiusM. But this class does not GenericDescriptorMatcher::read ---------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::read( const FileNode& fn ) +.. ocv:function:: void GenericDescriptorMatcher::read( const FileNode& fn ) Reads a matcher object from a file node. @@ -221,7 +221,7 @@ GenericDescriptorMatcher::read GenericDescriptorMatcher::write ----------------------------------- -.. cpp:function:: void GenericDescriptorMatcher::write( FileStorage& fs ) const +.. ocv:function:: void GenericDescriptorMatcher::write( FileStorage& fs ) const Writes a match object to a file storage. @@ -229,7 +229,7 @@ GenericDescriptorMatcher::write GenericDescriptorMatcher::clone ----------------------------------- -.. cpp:function:: Ptr GenericDescriptorMatcher::clone( bool emptyTrainData ) const +.. ocv:function:: Ptr GenericDescriptorMatcher::clone( bool emptyTrainData ) const Clones the matcher. @@ -243,7 +243,7 @@ GenericDescriptorMatcher::clone OneWayDescriptorMatcher ----------------------- -.. cpp:class:: OneWayDescriptorMatcher +.. ocv:class:: OneWayDescriptorMatcher Wrapping class for computing, matching, and classifying descriptors using the :ref:`OneWayDescriptorBase` class :: @@ -302,7 +302,7 @@ Wrapping class for computing, matching, and classifying descriptors using the FernDescriptorMatcher --------------------- -.. cpp:class:: FernDescriptorMatcher +.. ocv:class:: FernDescriptorMatcher Wrapping class for computing, matching, and classifying descriptors using the :ref:`FernClassifier` class :: @@ -361,7 +361,7 @@ Wrapping class for computing, matching, and classifying descriptors using the VectorDescriptorMatcher ----------------------- -.. cpp:class:: VectorDescriptorMatcher +.. ocv:class:: VectorDescriptorMatcher Class used for matching descriptors that can be described as vectors in a finite-dimensional space :: diff --git a/modules/features2d/doc/drawing_function_of_keypoints_and_matches.rst b/modules/features2d/doc/drawing_function_of_keypoints_and_matches.rst index 521b4cc..f51c109 100644 --- a/modules/features2d/doc/drawing_function_of_keypoints_and_matches.rst +++ b/modules/features2d/doc/drawing_function_of_keypoints_and_matches.rst @@ -6,9 +6,9 @@ Drawing Function of Keypoints and Matches drawMatches --------------- -.. cpp:function:: void drawMatches( const Mat& img1, const vector& keypoints1, const Mat& img2, const vector& keypoints2, const vector& matches1to2, Mat& outImg, const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1), const vector& matchesMask=vector(), int flags=DrawMatchesFlags::DEFAULT ) +.. ocv:function:: void drawMatches( const Mat& img1, const vector& keypoints1, const Mat& img2, const vector& keypoints2, const vector& matches1to2, Mat& outImg, const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1), const vector& matchesMask=vector(), int flags=DrawMatchesFlags::DEFAULT ) -.. cpp:function:: void drawMatches( const Mat& img1, const vector& keypoints1, const Mat& img2, const vector& keypoints2, const vector >& matches1to2, Mat& outImg, const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1), const vector>& matchesMask= vector >(), int flags=DrawMatchesFlags::DEFAULT ) +.. ocv:function:: void drawMatches( const Mat& img1, const vector& keypoints1, const Mat& img2, const vector& keypoints2, const vector >& matches1to2, Mat& outImg, const Scalar& matchColor=Scalar::all(-1), const Scalar& singlePointColor=Scalar::all(-1), const vector>& matchesMask= vector >(), int flags=DrawMatchesFlags::DEFAULT ) Draw the found matches of keypoints from two images @@ -63,7 +63,7 @@ This function draws matches of keypoints from two images in the output image. Ma drawKeypoints ----------------- -.. cpp:function:: void drawKeypoints( const Mat& image, const vector& keypoints, Mat& outImg, const Scalar& color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT ) +.. ocv:function:: void drawKeypoints( const Mat& image, const vector& keypoints, Mat& outImg, const Scalar& color=Scalar::all(-1), int flags=DrawMatchesFlags::DEFAULT ) Draws keypoints. diff --git a/modules/features2d/doc/feature_detection_and_description.rst b/modules/features2d/doc/feature_detection_and_description.rst index 92eb587..78bd200 100644 --- a/modules/features2d/doc/feature_detection_and_description.rst +++ b/modules/features2d/doc/feature_detection_and_description.rst @@ -7,7 +7,7 @@ Feature Detection and Description FAST -------- -.. cpp:function:: void FAST( const Mat& image, vector& keypoints, int threshold, bool nonmaxSupression=true ) +.. ocv:function:: void FAST( const Mat& image, vector& keypoints, int threshold, bool nonmaxSupression=true ) Detects corners using the FAST algorithm by E. Rosten (*Machine learning for high-speed corner detection*, 2006). @@ -25,7 +25,7 @@ FAST MSER ---- -.. cpp:class:: MSER +.. ocv:class:: MSER Maximally stable extremal region extractor :: @@ -54,7 +54,7 @@ http://en.wikipedia.org/wiki/Maximally_stable_extremal_regions). StarDetector ------------ -.. cpp:class:: StarDetector +.. ocv:class:: StarDetector Class implementing the Star keypoint detector :: @@ -93,7 +93,7 @@ The class implements a modified version of the ``CenSurE`` keypoint detector des SIFT ---- -.. cpp:class:: SIFT +.. ocv:class:: SIFT Class for extracting keypoints and computing descriptors using the Scale Invariant Feature Transform (SIFT) approach :: @@ -183,7 +183,7 @@ Class for extracting keypoints and computing descriptors using the Scale Invaria SURF ---- -.. cpp:class:: SURF +.. ocv:class:: SURF Class for extracting Speeded Up Robust Features from an image :: @@ -223,7 +223,7 @@ The algorithm can be used for object tracking and localization, image stitching, ORB ---- -.. cpp:class:: ORB +.. ocv:class:: ORB Class for extracting ORB features and descriptors from an image :: @@ -281,7 +281,7 @@ The class implements ORB RandomizedTree -------------- -.. cpp:class:: RandomizedTree +.. ocv:class:: RandomizedTree Class containing a base structure for ``RTreeClassifier`` :: @@ -355,11 +355,11 @@ Class containing a base structure for ``RTreeClassifier`` :: RandomizedTree::train ------------------------- -.. cpp:function:: void train(std::vector const& base_set, RNG& rng, PatchGenerator& make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits) +.. ocv:function:: void train(std::vector const& base_set, RNG& rng, PatchGenerator& make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits) Trains a randomized tree using an input set of keypoints. -.. cpp:function:: void train(std::vector const& base_set, RNG& rng, PatchGenerator& make_patch, int depth, int views, size_t reduced_num_dim, int num_quant_bits) +.. ocv:function:: void train(std::vector 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. @@ -379,9 +379,9 @@ RandomizedTree::train RandomizedTree::read ------------------------ -.. cpp:function:: read(const char* file_name, int num_quant_bits) +.. ocv:function:: read(const char* file_name, int num_quant_bits) -.. cpp:function:: read(std::istream &is, int num_quant_bits) +.. ocv:function:: read(std::istream &is, int num_quant_bits) Reads a pre-saved randomized tree from a file or stream. @@ -395,11 +395,11 @@ RandomizedTree::read RandomizedTree::write ------------------------- -.. cpp:function:: void write(const char* file_name) const +.. ocv:function:: void write(const char* file_name) const Writes the current randomized tree to a file or stream. -.. cpp:function:: void write(std::ostream \&os) const +.. ocv:function:: void write(std::ostream \&os) const :param file_name: Name of the file where randomized tree data is stored. @@ -409,7 +409,7 @@ RandomizedTree::write RandomizedTree::applyQuantization ------------------------------------- -.. cpp:function:: void applyQuantization(int num_quant_bits) +.. ocv:function:: void applyQuantization(int num_quant_bits) Applies quantization to the current randomized tree. @@ -421,7 +421,7 @@ RandomizedTree::applyQuantization RTreeNode --------- -.. cpp:class:: RTreeNode +.. ocv:class:: RTreeNode Class containing a base structure for ``RandomizedTree`` :: @@ -449,7 +449,7 @@ Class containing a base structure for ``RandomizedTree`` :: RTreeClassifier --------------- -.. cpp:class:: RTreeClassifier +.. ocv:class:: RTreeClassifier Class containing ``RTreeClassifier``. It represents the Calonder descriptor that was originally introduced by Michael Calonder. :: @@ -519,11 +519,11 @@ Class containing ``RTreeClassifier``. It represents the Calonder descriptor that RTreeClassifier::train -------------------------- -.. cpp:function:: void train(vector 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 train(vector 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) Trains a randomized tree classifier using an input set of keypoints. -.. cpp:function:: void train(vector 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 train(vector 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) :param base_set: Vector of the ``BaseKeypoint`` type. It contains image keypoints used for training. @@ -547,11 +547,11 @@ RTreeClassifier::train RTreeClassifier::getSignature --------------------------------- -.. cpp:function:: void getSignature(IplImage *patch, uchar *sig) +.. ocv:function:: void getSignature(IplImage *patch, uchar *sig) Returns a signature for an image patch. -.. cpp:function:: void getSignature(IplImage *patch, float *sig) +.. ocv:function:: void getSignature(IplImage *patch, float *sig) :param patch: Image patch to calculate the signature for. :param sig: Output signature (array dimension is ``reduced_num_dim)`` . @@ -561,7 +561,7 @@ RTreeClassifier::getSignature RTreeClassifier::getSparseSignature --------------------------------------- -.. cpp:function:: void getSparseSignature(IplImage *patch, float *sig, float thresh) +.. ocv:function:: void getSparseSignature(IplImage *patch, float *sig, float thresh) 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. @@ -575,7 +575,7 @@ RTreeClassifier::getSparseSignature RTreeClassifier::countNonZeroElements ----------------------------------------- -.. cpp:function:: static int countNonZeroElements(float *vec, int n, double tol=1e-10) +.. ocv:function:: static int countNonZeroElements(float *vec, int n, double tol=1e-10) Returns the number of non-zero elements in an input array. @@ -589,11 +589,11 @@ RTreeClassifier::countNonZeroElements RTreeClassifier::read ------------------------- -.. cpp:function:: read(const char* file_name) +.. ocv:function:: read(const char* file_name) Reads a pre-saved ``RTreeClassifier`` from a file or stream. -.. cpp:function:: read(std::istream& is) +.. ocv:function:: read(std::istream& is) :param file_name: Name of the file that contains randomized tree data. @@ -603,11 +603,11 @@ RTreeClassifier::read RTreeClassifier::write -------------------------- -.. cpp:function:: void write(const char* file_name) const +.. ocv:function:: void write(const char* file_name) const Writes the current ``RTreeClassifier`` to a file or stream. -.. cpp:function:: void write(std::ostream &os) const +.. ocv:function:: void write(std::ostream &os) const :param file_name: Name of the file where randomized tree data is stored. @@ -617,7 +617,7 @@ RTreeClassifier::write RTreeClassifier::setQuantization ------------------------------------ -.. cpp:function:: void setQuantization(int num_quant_bits) +.. ocv:function:: void setQuantization(int num_quant_bits) Applies quantization to the current randomized tree. diff --git a/modules/features2d/doc/object_categorization.rst b/modules/features2d/doc/object_categorization.rst index ad193ad..3c99038 100644 --- a/modules/features2d/doc/object_categorization.rst +++ b/modules/features2d/doc/object_categorization.rst @@ -11,7 +11,7 @@ This section describes approaches based on local 2D features and used to categor BOWTrainer ---------- -.. cpp:class:: BOWTrainer +.. ocv:class:: BOWTrainer Abstract base class for training the *bag of visual words* vocabulary from a set of descriptors. For details, see, for example, *Visual Categorization with Bags of Keypoints* by Gabriella Csurka, Christopher R. Dance, @@ -41,7 +41,7 @@ Lixin Fan, Jutta Willamowski, Cedric Bray, 2004. :: BOWTrainer::add ------------------- -.. cpp:function:: void BOWTrainer::add( const Mat& descriptors ) +.. ocv:function:: void BOWTrainer::add( const Mat& descriptors ) Adds descriptors to a training set. The training set is clustered using ``clustermethod`` to construct the vocabulary. @@ -51,7 +51,7 @@ BOWTrainer::add BOWTrainer::getDescriptors ------------------------------ -.. cpp:function:: const vector& BOWTrainer::getDescriptors() const +.. ocv:function:: const vector& BOWTrainer::getDescriptors() const Returns a training set of descriptors. @@ -59,7 +59,7 @@ BOWTrainer::getDescriptors BOWTrainer::descripotorsCount --------------------------------- -.. cpp:function:: const vector& BOWTrainer::descripotorsCount() const +.. ocv:function:: const vector& BOWTrainer::descripotorsCount() const Returns the count of all descriptors stored in the training set. @@ -67,11 +67,11 @@ BOWTrainer::descripotorsCount BOWTrainer::cluster ----------------------- -.. cpp:function:: Mat BOWTrainer::cluster() const +.. ocv:function:: Mat BOWTrainer::cluster() const Clusters train descriptors. The vocabulary consists of cluster centers. So, this method returns the vocabulary. In the first variant of the method, train descriptors stored in the object are clustered. In the second variant, input descriptors are clustered. -.. cpp:function:: Mat BOWTrainer::cluster( const Mat& descriptors ) const +.. ocv:function:: Mat BOWTrainer::cluster( const Mat& descriptors ) const :param descriptors: Descriptors to cluster. Each row of the ``descriptors`` matrix is a descriptor. Descriptors are not added to the inner train descriptor set. @@ -81,7 +81,7 @@ BOWTrainer::cluster BOWKMeansTrainer ---------------- -.. cpp:class:: BOWKMeansTrainer +.. ocv:class:: BOWKMeansTrainer :ref:`kmeans` -based class to train visual vocabulary using the *bag of visual words* approach :: @@ -111,7 +111,7 @@ arguments. BOWImgDescriptorExtractor ------------------------- -.. cpp:class:: BOWImgDescriptorExtractor +.. ocv:class:: BOWImgDescriptorExtractor Class to compute an image descriptor using the ''bag of visual words''. Such a computation consists of the following steps: @@ -146,7 +146,7 @@ Here is the class declaration :: BOWImgDescriptorExtractor::BOWImgDescriptorExtractor -------------------------------------------------------- -.. cpp:function:: BOWImgDescriptorExtractor::BOWImgDescriptorExtractor( const Ptr& dextractor, const Ptr& dmatcher ) +.. ocv:function:: BOWImgDescriptorExtractor::BOWImgDescriptorExtractor( const Ptr& dextractor, const Ptr& dmatcher ) The class constructor. @@ -158,7 +158,7 @@ BOWImgDescriptorExtractor::BOWImgDescriptorExtractor BOWImgDescriptorExtractor::setVocabulary -------------------------------------------- -.. cpp:function:: void BOWImgDescriptorExtractor::setVocabulary( const Mat& vocabulary ) +.. ocv:function:: void BOWImgDescriptorExtractor::setVocabulary( const Mat& vocabulary ) Sets a visual vocabulary. @@ -168,7 +168,7 @@ BOWImgDescriptorExtractor::setVocabulary BOWImgDescriptorExtractor::getVocabulary -------------------------------------------- -.. cpp:function:: const Mat& BOWImgDescriptorExtractor::getVocabulary() const +.. ocv:function:: const Mat& BOWImgDescriptorExtractor::getVocabulary() const Returns the set vocabulary. @@ -176,7 +176,7 @@ BOWImgDescriptorExtractor::getVocabulary BOWImgDescriptorExtractor::compute -------------------------------------- -.. cpp:function:: void BOWImgDescriptorExtractor::compute( const Mat& image, vector& keypoints, Mat& imgDescriptor, vector >* pointIdxsOfClusters=0, Mat* descriptors=0 ) +.. ocv:function:: void BOWImgDescriptorExtractor::compute( const Mat& image, vector& keypoints, Mat& imgDescriptor, vector >* pointIdxsOfClusters=0, Mat* descriptors=0 ) Computes an image descriptor using the set visual vocabulary. @@ -194,7 +194,7 @@ BOWImgDescriptorExtractor::compute BOWImgDescriptorExtractor::descriptorSize --------------------------------------------- -.. cpp:function:: int BOWImgDescriptorExtractor::descriptorSize() const +.. ocv:function:: int BOWImgDescriptorExtractor::descriptorSize() const Returns an image discriptor size if the vocabulary is set. Otherwise, it returns 0. @@ -202,7 +202,7 @@ BOWImgDescriptorExtractor::descriptorSize BOWImgDescriptorExtractor::descriptorType --------------------------------------------- -.. cpp:function:: int BOWImgDescriptorExtractor::descriptorType() const +.. ocv:function:: int BOWImgDescriptorExtractor::descriptorType() const Returns an image descriptor type. diff --git a/modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst b/modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst index bb38253..b8174bd 100644 --- a/modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst +++ b/modules/gpu/doc/camera_calibration_and_3d_reconstruction.rst @@ -7,7 +7,7 @@ Camera Calibration and 3D Reconstruction gpu::StereoBM_GPU ----------------- -.. cpp:class:: gpu::StereoBM_GPU +.. ocv:class:: gpu::StereoBM_GPU This class computes stereo correspondence (disparity map) using the block matching algorithm. :: @@ -51,9 +51,9 @@ This means that the input left image is low textured. gpu::StereoBM_GPU::StereoBM_GPU ----------------------------------- -.. cpp:function:: gpu::StereoBM_GPU::StereoBM_GPU() +.. ocv:function:: gpu::StereoBM_GPU::StereoBM_GPU() -.. cpp:function:: gpu::StereoBM_GPU::StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ) +.. ocv:function:: gpu::StereoBM_GPU::StereoBM_GPU(int preset, int ndisparities = DEFAULT_NDISP, int winSize = DEFAULT_WINSZ) Enables ``StereoBM_GPU`` constructors. @@ -73,9 +73,9 @@ gpu::StereoBM_GPU::StereoBM_GPU gpu::StereoBM_GPU::operator () ---------------------------------- -.. cpp:function:: void gpu::StereoBM_GPU::operator() (const GpuMat& left, const GpuMat& right, GpuMat& disparity) +.. ocv:function:: void gpu::StereoBM_GPU::operator() (const GpuMat& left, const GpuMat& right, GpuMat& disparity) -.. cpp:function:: void gpu::StereoBM_GPU::operator() (const GpuMat& left, const GpuMat& right, GpuMat& disparity, const Stream& stream) +.. ocv:function:: void gpu::StereoBM_GPU::operator() (const GpuMat& left, const GpuMat& right, GpuMat& disparity, const Stream& stream) Enables the stereo correspondence operator that finds the disparity for the specified rectified stereo pair. @@ -91,7 +91,7 @@ gpu::StereoBM_GPU::operator () gpu::StereoBM_GPU::checkIfGpuCallReasonable ----------------------------------------------- -.. cpp:function:: bool gpu::StereoBM_GPU::checkIfGpuCallReasonable() +.. ocv:function:: bool gpu::StereoBM_GPU::checkIfGpuCallReasonable() Uses a heuristic method to estimate whether the current GPU is faster than the CPU in this algorithm. It queries the currently active device. @@ -99,7 +99,7 @@ gpu::StereoBM_GPU::checkIfGpuCallReasonable gpu::StereoBeliefPropagation ---------------------------- -.. cpp:class:: gpu::StereoBeliefPropagation +.. ocv:class:: gpu::StereoBeliefPropagation This class computes stereo correspondence using the belief propagation algorithm. :: @@ -166,9 +166,9 @@ and for data cost storage: gpu::StereoBeliefPropagation::StereoBeliefPropagation --------------------------------------------------------- -.. cpp:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F) +.. ocv:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp = DEFAULT_NDISP, int iters = DEFAULT_ITERS, int levels = DEFAULT_LEVELS, int msg_type = CV_32F) -.. cpp:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp, int iters, int levels, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int msg_type = CV_32F) +.. ocv:function:: gpu::StereoBeliefPropagation::StereoBeliefPropagation( int ndisp, int iters, int levels, float max_data_term, float data_weight, float max_disc_term, float disc_single_jump, int msg_type = CV_32F) Enables the ``StereoBeliefPropagation`` constructors. @@ -200,7 +200,7 @@ gpu::StereoBeliefPropagation::StereoBeliefPropagation For more details, see [Pedro F. Felzenszwalb and Daniel P. Huttenlocher. Efficient belief propagation for early vision. International Journal of Computer Vision, 70(1), October 2006]. -By default, :cpp:class:`StereoBeliefPropagation` uses floating-point arithmetics and the ``CV_32FC1`` type for messages. But it can also use fixed-point arithmetics and the ``CV_16SC1`` message type for better performance. To avoid an overflow in this case, the parameters must satisfy the following requirement: +By default, :ocv:class:`StereoBeliefPropagation` uses floating-point arithmetics and the ``CV_32FC1`` type for messages. But it can also use fixed-point arithmetics and the ``CV_16SC1`` message type for better performance. To avoid an overflow in this case, the parameters must satisfy the following requirement: .. math:: @@ -211,7 +211,7 @@ By default, :cpp:class:`StereoBeliefPropagation` uses floating-point arithmetics gpu::StereoBeliefPropagation::estimateRecommendedParams ----------------------------------------------------------- -.. cpp:function:: void gpu::StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels) +.. ocv:function:: void gpu::StereoBeliefPropagation::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels) Uses a heuristic method to compute the recommended parameters (``ndisp``, ``iters`` and ``levels``) for the specified image size (``width`` and ``height``). @@ -219,9 +219,9 @@ gpu::StereoBeliefPropagation::estimateRecommendedParams gpu::StereoBeliefPropagation::operator () --------------------------------------------- -.. cpp:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity) +.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity) -.. cpp:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream) +.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream) Enables the stereo correspondence operator that finds the disparity for the specified rectified stereo pair or data cost. @@ -233,9 +233,9 @@ gpu::StereoBeliefPropagation::operator () :param stream: Stream for the asynchronous version. -.. cpp:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity) +.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity) -.. cpp:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity, Stream& stream) +.. ocv:function:: void gpu::StereoBeliefPropagation::operator()( const GpuMat& data, GpuMat& disparity, Stream& stream) :param data: The user-specified data cost, a matrix of ``msg_type`` type and ``Size(*ndisp, )`` size. @@ -247,7 +247,7 @@ gpu::StereoBeliefPropagation::operator () gpu::StereoConstantSpaceBP -------------------------- -.. cpp:class:: gpu::StereoConstantSpaceBP +.. ocv:class:: gpu::StereoConstantSpaceBP This class computes stereo correspondence using the constant space belief propagation algorithm. :: @@ -306,9 +306,9 @@ The class implements Q. Yang algorithm [Q. Yang, L. Wang, and N. Ahuja. A consta gpu::StereoConstantSpaceBP::StereoConstantSpaceBP ----------------------------------------------------- -.. cpp: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) -.. cpp: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:: 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) Enables the StereoConstantSpaceBP constructors. @@ -355,7 +355,7 @@ By default, ``StereoConstantSpaceBP`` uses floating-point arithmetics and the `` gpu::StereoConstantSpaceBP::estimateRecommendedParams --------------------------------------------------------- -.. cpp:function:: void gpu::StereoConstantSpaceBP::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels, int& nr_plane) +.. ocv:function:: void gpu::StereoConstantSpaceBP::estimateRecommendedParams( int width, int height, int& ndisp, int& iters, int& levels, int& nr_plane) Uses a heuristic method to compute parameters (ndisp, iters, levelsand nrplane) for the specified image size (widthand height). @@ -363,9 +363,9 @@ gpu::StereoConstantSpaceBP::estimateRecommendedParams gpu::StereoConstantSpaceBP::operator () ------------------------------------------- -.. cpp:function:: void gpu::StereoConstantSpaceBP::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity) +.. ocv:function:: void gpu::StereoConstantSpaceBP::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity) -.. cpp:function:: void gpu::StereoConstantSpaceBP::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream) +.. ocv:function:: void gpu::StereoConstantSpaceBP::operator()( const GpuMat& left, const GpuMat& right, GpuMat& disparity, Stream& stream) Enables the stereo correspondence operator that finds the disparity for the specified rectified stereo pair. @@ -383,7 +383,7 @@ gpu::StereoConstantSpaceBP::operator () gpu::DisparityBilateralFilter ----------------------------- -.. cpp:class:: gpu::DisparityBilateralFilter +.. ocv:class:: gpu::DisparityBilateralFilter This class refines a disparity map using joint bilateral filtering. :: @@ -416,9 +416,9 @@ The class implements Q. Yang algorithm [Q. Yang, L. Wang, and N. Ahuja. A consta gpu::DisparityBilateralFilter::DisparityBilateralFilter ----------------------------------------------------------- -.. cpp:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS) +.. ocv:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp = DEFAULT_NDISP, int radius = DEFAULT_RADIUS, int iters = DEFAULT_ITERS) -.. cpp:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range) +.. ocv:function:: gpu::DisparityBilateralFilter::DisparityBilateralFilter( int ndisp, int radius, int iters, float edge_threshold, float max_disc_threshold, float sigma_range) Enables the ``DisparityBilateralFilter`` constructors. @@ -438,9 +438,9 @@ gpu::DisparityBilateralFilter::DisparityBilateralFilter gpu::DisparityBilateralFilter::operator () ---------------------------------------------- -.. cpp:function:: void gpu::DisparityBilateralFilter::operator()( const GpuMat& disparity, const GpuMat& image, GpuMat& dst) +.. ocv:function:: void gpu::DisparityBilateralFilter::operator()( const GpuMat& disparity, const GpuMat& image, GpuMat& dst) -.. cpp:function:: void gpu::DisparityBilateralFilter::operator()( const GpuMat& disparity, const GpuMat& image, GpuMat& dst, Stream& stream) +.. ocv:function:: void gpu::DisparityBilateralFilter::operator()( const GpuMat& disparity, const GpuMat& image, GpuMat& dst, Stream& stream) Refines a disparity map using joint bilateral filtering. @@ -456,9 +456,9 @@ gpu::DisparityBilateralFilter::operator () gpu::drawColorDisp ---------------------- -.. cpp:function:: void gpu::drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp) +.. ocv:function:: void gpu::drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp) -.. cpp:function:: void gpu::drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp, const Stream& stream) +.. ocv:function:: void gpu::drawColorDisp(const GpuMat& src_disp, GpuMat& dst_disp, int ndisp, const Stream& stream) Colors a disparity image. @@ -476,9 +476,9 @@ This function draws a colored disparity map by converting disparity values from gpu::reprojectImageTo3D --------------------------- -.. cpp:function:: void gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q) +.. ocv:function:: void gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q) -.. cpp:function:: void gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, const Stream& stream) +.. ocv:function:: void gpu::reprojectImageTo3D(const GpuMat& disp, GpuMat& xyzw, const Mat& Q, const Stream& stream) Reprojects a disparity image to 3D space. @@ -490,14 +490,14 @@ gpu::reprojectImageTo3D :param stream: Stream for the asynchronous version. -See Also: :cpp:func:`reprojectImageTo3D` . +See Also: :ocv:func:`reprojectImageTo3D` . .. index:: gpu::solvePnPRansac gpu::solvePnPRansac ------------------- -.. cpp:function:: void gpu::solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat, const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess=false, int num_iters=100, float max_dist=8.0, int min_inlier_count=100, vector* inliers=NULL) +.. ocv:function:: void gpu::solvePnPRansac(const Mat& object, const Mat& image, const Mat& camera_mat, const Mat& dist_coef, Mat& rvec, Mat& tvec, bool use_extrinsic_guess=false, int num_iters=100, float max_dist=8.0, int min_inlier_count=100, vector* inliers=NULL) Finds the object pose from 3D-2D point correspondences. @@ -507,7 +507,7 @@ gpu::solvePnPRansac :param camera_mat: 3x3 matrix of intrinsic camera parameters. - :param dist_coef: Distortion coefficients. See :cpp:func:`undistortPoints` for details. + :param dist_coef: Distortion coefficients. See :ocv:func:`undistortPoints` for details. :param rvec: Output 3D rotation vector. @@ -523,5 +523,5 @@ gpu::solvePnPRansac :param inliers: Output vector of inlier indices. -See Also :cpp:func:`solvePnPRansac`. +See Also :ocv:func:`solvePnPRansac`. \ No newline at end of file diff --git a/modules/gpu/doc/data_structures.rst b/modules/gpu/doc/data_structures.rst index 9e30884..30f981e 100644 --- a/modules/gpu/doc/data_structures.rst +++ b/modules/gpu/doc/data_structures.rst @@ -7,7 +7,7 @@ Data Structures gpu::DevMem2D\_ --------------- -.. cpp:class:: gpu::DevMem2D\_ +.. ocv:class:: gpu::DevMem2D\_ This lightweight class encapsulates pitched memory on a GPU and is passed to nvcc-compiled code (CUDA kernels). Typically, it is used internally by OpenCV and by users who write device code. You can call its members from both host and device code. :: @@ -44,10 +44,10 @@ This lightweight class encapsulates pitched memory on a GPU and is passed to nvc gpu::PtrStep\_ -------------- -.. cpp:class:: gpu::PtrStep\_ +.. ocv:class:: gpu::PtrStep\_ This structure is similar to -:cpp:class:`DevMem2D_` but contains only a pointer and row step. Width and height fields are excluded due to performance reasons. The structure is intended for internal use or for users who write device code. +:ocv:class:`DevMem2D_` but contains only a pointer and row step. Width and height fields are excluded due to performance reasons. The structure is intended for internal use or for users who write device code. :: template struct PtrStep_ @@ -75,10 +75,10 @@ This structure is similar to gpu::PtrElemStrp\_ ------------------ -.. cpp:class:: gpu::PtrElemStrp\_ +.. ocv:class:: gpu::PtrElemStrp\_ This structure is similar to -:cpp:class:`DevMem2D_` but contains only pointer and row step in elements. Width and height fields are excluded due to performance reasons. This class can only be constructed if ``sizeof(T)`` is a multiple of 256. The structure is intended for internal use or for users who write device code. +:ocv:class:`DevMem2D_` but contains only pointer and row step in elements. Width and height fields are excluded due to performance reasons. This class can only be constructed if ``sizeof(T)`` is a multiple of 256. The structure is intended for internal use or for users who write device code. :: template struct PtrElemStep_ : public PtrStep_ @@ -93,7 +93,7 @@ This structure is similar to gpu::GpuMat ----------- -.. cpp:class:: gpu::GpuMat +.. ocv:class:: gpu::GpuMat This is a base storage class for GPU memory with reference counting. Its interface matches the :c:type:`Mat` interface with the following limitations: @@ -105,7 +105,7 @@ This is a base storage class for GPU memory with reference counting. Its interfa * no expression templates technique support -Beware that the latter limitation may lead to overloaded matrix operators that cause memory allocations. The ``GpuMat`` class is convertible to :cpp:class:`gpu::DevMem2D_` and :cpp:class:`gpu::PtrStep_` so it can be passed directly to kernel. +Beware that the latter limitation may lead to overloaded matrix operators that cause memory allocations. The ``GpuMat`` class is convertible to :ocv:class:`gpu::DevMem2D_` and :ocv:class:`gpu::PtrStep_` so it can be passed directly to kernel. **Note:** @@ -148,16 +148,16 @@ In contrast with :c:type:`Mat`, in most cases ``GpuMat::isContinuous() == false` You are not recommended to leave static or global ``GpuMat`` variables allocated, that is to rely on its destructor. The destruction order of such variables and CUDA context is undefined. GPU memory release function returns error if the CUDA context has been destroyed before. See Also: -:cpp:func:`Mat` +:ocv:func:`Mat` .. index:: gpu::CudaMem gpu::CudaMem ------------ -.. cpp:class:: gpu::CudaMem +.. ocv:class:: gpu::CudaMem This class with reference counting wraps special memory type allocation functions from CUDA. Its interface is also -:cpp:func:`Mat`-like but with additional memory type parameters. +:ocv:func:`Mat`-like but with additional memory type parameters. * ``ALLOC_PAGE_LOCKED``: Sets a page locked memory type, used commonly for fast and asynchronous uploading/downloading data from/to GPU. @@ -206,24 +206,24 @@ Allocation size of such memory types is usually limited. For more details, see " gpu::CudaMem::createMatHeader --------------------------------- -.. cpp:function:: Mat gpu::CudaMem::createMatHeader() const +.. ocv:function:: Mat gpu::CudaMem::createMatHeader() const - Creates a header without reference counting to :cpp:class:`gpu::CudaMem` data. + Creates a header without reference counting to :ocv:class:`gpu::CudaMem` data. .. index:: gpu::CudaMem::createGpuMatHeader gpu::CudaMem::createGpuMatHeader ------------------------------------ -.. cpp:function:: GpuMat gpu::CudaMem::createGpuMatHeader() const +.. ocv:function:: GpuMat gpu::CudaMem::createGpuMatHeader() const - Maps CPU memory to GPU address space and creates the :cpp:class:`gpu::GpuMat` header without reference counting for it. This can be done only if memory was allocated with the ``ALLOC_ZEROCOPY`` flag and if it is supported by the hardware (laptops often share video and CPU memory, so address spaces can be mapped, which eliminates an extra copy). + Maps CPU memory to GPU address space and creates the :ocv:class:`gpu::GpuMat` header without reference counting for it. This can be done only if memory was allocated with the ``ALLOC_ZEROCOPY`` flag and if it is supported by the hardware (laptops often share video and CPU memory, so address spaces can be mapped, which eliminates an extra copy). .. index:: gpu::CudaMem::canMapHostMemory gpu::CudaMem::canMapHostMemory ---------------------------------- -.. cpp:function:: static bool gpu::CudaMem::canMapHostMemory() +.. ocv:function:: static bool gpu::CudaMem::canMapHostMemory() Returns ``true`` if the current hardware supports address space mapping and ``ALLOC_ZEROCOPY`` memory allocation. @@ -231,9 +231,9 @@ gpu::CudaMem::canMapHostMemory gpu::Stream ----------- -.. cpp:class:: gpu::Stream +.. ocv:class:: gpu::Stream -This class encapsulates a queue of asynchronous calls. Some functions have overloads with the additional ``gpu::Stream`` parameter. The overloads do initialization work (allocate output buffers, upload constants, and so on), start the GPU kernel, and return before results are ready. You can check whether all operations are complete via :cpp:func:`gpu::Stream::queryIfComplete`. You can asynchronously upload/download data from/to page-locked buffers, using the :cpp:class:`gpu::CudaMem` or :c:type:`Mat` header that points to a region of :cpp:class:`gpu::CudaMem`. +This class encapsulates a queue of asynchronous calls. Some functions have overloads with the additional ``gpu::Stream`` parameter. The overloads do initialization work (allocate output buffers, upload constants, and so on), start the GPU kernel, and return before results are ready. You can check whether all operations are complete via :ocv:func:`gpu::Stream::queryIfComplete`. You can asynchronously upload/download data from/to page-locked buffers, using the :ocv:class:`gpu::CudaMem` or :c:type:`Mat` header that points to a region of :ocv:class:`gpu::CudaMem`. **Note:** @@ -279,7 +279,7 @@ Currently, you may face problems if an operation is enqueued twice with differen gpu::Stream::queryIfComplete -------------------------------- -.. cpp:function:: bool gpu::Stream::queryIfComplete() +.. ocv:function:: bool gpu::Stream::queryIfComplete() Returns ``true`` if the current stream queue is finished. Otherwise, it returns false. @@ -287,7 +287,7 @@ gpu::Stream::queryIfComplete gpu::Stream::waitForCompletion ---------------------------------- -.. cpp:function:: void gpu::Stream::waitForCompletion() +.. ocv:function:: void gpu::Stream::waitForCompletion() Blocks the current CPU thread until all operations in the stream are complete. @@ -295,9 +295,9 @@ gpu::Stream::waitForCompletion gpu::StreamAccessor ------------------- -.. cpp:class:: gpu::StreamAccessor +.. ocv:class:: gpu::StreamAccessor -This class enables getting ``cudaStream_t`` from :cpp:class:`gpu::Stream` and is declared in ``stream_accessor.hpp`` because it is the only public header that depends on the CUDA Runtime API. Including it brings a dependency to your code. +This class enables getting ``cudaStream_t`` from :ocv:class:`gpu::Stream` and is declared in ``stream_accessor.hpp`` because it is the only public header that depends on the CUDA Runtime API. Including it brings a dependency to your code. :: struct StreamAccessor @@ -310,7 +310,7 @@ This class enables getting ``cudaStream_t`` from :cpp:class:`gpu::Stream` and is gpu::createContinuous ------------------------- -.. cpp:function:: void gpu::createContinuous(int rows, int cols, int type, GpuMat& m) +.. ocv:function:: void gpu::createContinuous(int rows, int cols, int type, GpuMat& m) Creates a continuous matrix in the GPU memory. @@ -325,11 +325,11 @@ gpu::createContinuous The following wrappers are also available: - * .. cpp:function:: GpuMat gpu::createContinuous(int rows, int cols, int type) + * .. ocv:function:: GpuMat gpu::createContinuous(int rows, int cols, int type) - * .. cpp:function:: void gpu::createContinuous(Size size, int type, GpuMat& m) + * .. ocv:function:: void gpu::createContinuous(Size size, int type, GpuMat& m) - * .. cpp:function:: GpuMat gpu::createContinuous(Size size, int type) + * .. ocv:function:: GpuMat gpu::createContinuous(Size size, int type) Matrix is called continuous if its elements are stored continuously, that is without gaps in the end of each row. @@ -337,9 +337,9 @@ gpu::createContinuous gpu::ensureSizeIsEnough --------------------------- -.. cpp:function:: void gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m) +.. ocv:function:: void gpu::ensureSizeIsEnough(int rows, int cols, int type, GpuMat& m) -.. cpp:function:: void gpu::ensureSizeIsEnough(Size size, int type, GpuMat& m) +.. ocv:function:: void gpu::ensureSizeIsEnough(Size size, int type, GpuMat& m) Ensures that the size of a matrix is big enough and the matrix has a proper type. The function does not reallocate memory if the matrix has proper attributes already. diff --git a/modules/gpu/doc/feature_detection_and_description.rst b/modules/gpu/doc/feature_detection_and_description.rst index a3516f5..40fd9b6 100644 --- a/modules/gpu/doc/feature_detection_and_description.rst +++ b/modules/gpu/doc/feature_detection_and_description.rst @@ -7,7 +7,7 @@ Feature Detection and Description gpu::SURF_GPU ------------- -.. cpp:class:: gpu::SURF_GPU +.. ocv:class:: gpu::SURF_GPU This class is used for extracting Speeded Up Robust Features (SURF) from an image. :: @@ -93,7 +93,7 @@ See Also: :c:type:`SURF` gpu::BruteForceMatcher_GPU -------------------------- -.. cpp:class:: gpu::BruteForceMatcher_GPU +.. ocv:class:: gpu::BruteForceMatcher_GPU This is a brute-force descriptor matcher. For each descriptor in the first set, this matcher finds the closest descriptor in the second set by trying each one. This descriptor matcher supports masking permissible matches between descriptor sets. :: @@ -188,20 +188,20 @@ See Also: :c:type:`DescriptorMatcher`, :c:type:`BruteForceMatcher` gpu::BruteForceMatcher_GPU::match ------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::match(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector& matches, const GpuMat& mask = GpuMat()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::match(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector& matches, const GpuMat& mask = GpuMat()) -.. cpp:function:: void gpu::BruteForceMatcher_GPU::match(const GpuMat& queryDescs, std::vector& matches, const std::vector& masks = std::vector()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::match(const GpuMat& queryDescs, std::vector& matches, const std::vector& masks = std::vector()) Finds the best match for each descriptor from a query set with train descriptors. See Also: -:cpp:func:`DescriptorMatcher::match` +:ocv:func:`DescriptorMatcher::match` .. index:: gpu::BruteForceMatcher_GPU::matchSingle gpu::BruteForceMatcher_GPU::matchSingle ------------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::matchSingle(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& distance, const GpuMat& mask = GpuMat()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchSingle(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& distance, const GpuMat& mask = GpuMat()) Finds the best match for each query descriptor. Results are stored in the GPU memory. @@ -219,13 +219,13 @@ gpu::BruteForceMatcher_GPU::matchSingle gpu::BruteForceMatcher_GPU::matchCollection ----------------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::matchCollection(const GpuMat& queryDescs, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchCollection(const GpuMat& queryDescs, const GpuMat& trainCollection, GpuMat& trainIdx, GpuMat& imgIdx, GpuMat& distance, const GpuMat& maskCollection) Finds the best match for each query descriptor from train collection. Results are stored in the GPU memory. :param queryDescs: Query set of descriptors. - :param trainCollection: :cpp:class:`gpu::GpuMat` containing train collection. It can be obtained from the collection of train descriptors that was set using the ``add`` method by :cpp:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection`. Or it may contain a user-defined collection. This is a one-row matrix where each element is ``DevMem2D`` pointing out to a matrix of train descriptors. + :param trainCollection: :ocv:class:`gpu::GpuMat` containing train collection. It can be obtained from the collection of train descriptors that was set using the ``add`` method by :ocv:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection`. Or it may contain a user-defined collection. This is a one-row matrix where each element is ``DevMem2D`` pointing out to a matrix of train descriptors. :param trainIdx: The output single-row ``CV_32SC1`` matrix that contains the best train index for each query. If some query descriptors are masked out in ``maskCollection`` , it contains -1. @@ -233,47 +233,47 @@ gpu::BruteForceMatcher_GPU::matchCollection :param distance: The output single-row ``CV_32FC1`` matrix that contains the best distance for each query. If some query descriptors are masked out in ``maskCollection`` , it contains ``FLT_MAX``. - :param maskCollection: ``GpuMat`` containing a set of masks. It can be obtained from ``std::vector`` by :cpp:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection` or it may contain a user-defined mask set. This is an empty matrix or one-row matrix where each element is a ``PtrStep`` that points to one mask. + :param maskCollection: ``GpuMat`` containing a set of masks. It can be obtained from ``std::vector`` by :ocv:func:`gpu::BruteForceMatcher_GPU::makeGpuCollection` or it may contain a user-defined mask set. This is an empty matrix or one-row matrix where each element is a ``PtrStep`` that points to one mask. .. index:: gpu::BruteForceMatcher_GPU::makeGpuCollection gpu::BruteForceMatcher_GPU::makeGpuCollection ------------------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector&masks = std::vector()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::makeGpuCollection(GpuMat& trainCollection, GpuMat& maskCollection, const vector&masks = std::vector()) Performs a GPU collection of train descriptors and masks in a suitable format for the - :cpp:func:`gpu::BruteForceMatcher_GPU::matchCollection` function. + :ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` function. .. index:: gpu::BruteForceMatcher_GPU::matchDownload gpu::BruteForceMatcher_GPU::matchDownload --------------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector&matches) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector&matches) -.. cpp:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, GpuMat& imgIdx, const GpuMat& distance, std::vector&matches) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::matchDownload(const GpuMat& trainIdx, GpuMat& imgIdx, const GpuMat& distance, std::vector&matches) Downloads ``trainIdx``, ``imgIdx``, and ``distance`` matrices obtained via - :cpp:func:`gpu::BruteForceMatcher_GPU::matchSingle` or - :cpp:func:`gpu::BruteForceMatcher_GPU::matchCollection` to CPU vector with :c:type:`DMatch`. + :ocv:func:`gpu::BruteForceMatcher_GPU::matchSingle` or + :ocv:func:`gpu::BruteForceMatcher_GPU::matchCollection` to CPU vector with :c:type:`DMatch`. .. index:: gpu::BruteForceMatcher_GPU::knnMatch gpu::BruteForceMatcher_GPU::knnMatch ---------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector >&matches, int k, const GpuMat& mask = GpuMat(), bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector >&matches, int k, const GpuMat& mask = GpuMat(), bool compactResult = false) Finds the k best matches for each descriptor from a query set with train descriptors. The function returns detected k (or less if not possible) matches in the increasing order by distance. -.. cpp:function:: void knnMatch(const GpuMat& queryDescs, std::vector< std::vector >&matches, int k, const std::vector&masks = std::vector(), bool compactResult = false ) +.. ocv:function:: void knnMatch(const GpuMat& queryDescs, std::vector< std::vector >&matches, int k, const std::vector&masks = std::vector(), bool compactResult = false ) See Also: -:cpp:func:`DescriptorMatcher::knnMatch` +:ocv:func:`DescriptorMatcher::knnMatch` .. index:: gpu::BruteForceMatcher_GPU::knnMatch gpu::BruteForceMatcher_GPU::knnMatch ---------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::knnMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& distance, GpuMat& allDist, int k, const GpuMat& mask = GpuMat()) Finds the k best matches for each descriptor from a query set with train descriptors. The function returns detected k (or less if not possible) matches in the increasing order by distance. Results will be stored in the GPU memory. @@ -291,30 +291,30 @@ gpu::BruteForceMatcher_GPU::knnMatch gpu::BruteForceMatcher_GPU::knnMatchDownload ------------------------------------------------ -.. cpp:function:: void gpu::BruteForceMatcher_GPU::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector< std::vector >&matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::knnMatchDownload(const GpuMat& trainIdx, const GpuMat& distance, std::vector< std::vector >&matches, bool compactResult = false) - Downloads ``trainIdx`` and ``distance`` matrices obtained via :cpp:func:`gpu::BruteForceMatcher_GPU::knnMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors. + Downloads ``trainIdx`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::knnMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors. .. index:: gpu::BruteForceMatcher_GPU::radiusMatch gpu::BruteForceMatcher_GPU::radiusMatch ------------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector >&matches, float maxDistance, const GpuMat& mask = GpuMat(), bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, std::vector< std::vector >&matches, float maxDistance, const GpuMat& mask = GpuMat(), bool compactResult = false) For each query descriptor, finds the best matches with a distance less than a given threshold. The function returns detected matches in the increasing order by distance. -.. cpp:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, std::vector< std::vector >&matches, float maxDistance, const std::vector&masks = std::vector(), bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, std::vector< std::vector >&matches, float maxDistance, const std::vector&masks = std::vector(), bool compactResult = false) This function works only on devices with the compute capability :math:`>=` 1.1. See Also: -:cpp:func:`DescriptorMatcher::radiusMatch` +:ocv:func:`DescriptorMatcher::radiusMatch` .. index:: gpu::BruteForceMatcher_GPU::radiusMatch gpu::BruteForceMatcher_GPU::radiusMatch ------------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& nMatches, GpuMat& distance, float maxDistance, const GpuMat& mask = GpuMat()) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatch(const GpuMat& queryDescs, const GpuMat& trainDescs, GpuMat& trainIdx, GpuMat& nMatches, GpuMat& distance, float maxDistance, const GpuMat& mask = GpuMat()) For each query descriptor, finds the best matches with a distance less than a given threshold (``maxDistance``). The results are stored in the GPU memory. @@ -332,13 +332,13 @@ gpu::BruteForceMatcher_GPU::radiusMatch :param mask: Mask specifying permissible matches between the input query and train matrices of descriptors. - In contrast to :cpp:func:`gpu::BruteForceMatcher_GPU::knnMatch`, here the results are not sorted by the distance. This function works only on devices with the compute capability >= 1.1. + In contrast to :ocv:func:`gpu::BruteForceMatcher_GPU::knnMatch`, here the results are not sorted by the distance. This function works only on devices with the compute capability >= 1.1. .. index:: gpu::BruteForceMatcher_GPU::radiusMatchDownload gpu::BruteForceMatcher_GPU::radiusMatchDownload --------------------------------------------------- -.. cpp:function:: void gpu::BruteForceMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& nMatches, const GpuMat& distance, std::vector< std::vector >&matches, bool compactResult = false) +.. ocv:function:: void gpu::BruteForceMatcher_GPU::radiusMatchDownload(const GpuMat& trainIdx, const GpuMat& nMatches, const GpuMat& distance, std::vector< std::vector >&matches, bool compactResult = false) - Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :cpp:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors. + Downloads ``trainIdx``, ``nMatches`` and ``distance`` matrices obtained via :ocv:func:`gpu::BruteForceMatcher_GPU::radiusMatch` to CPU vector with :c:type:`DMatch`. If ``compactResult`` is true, the ``matches`` vector does not contain matches for fully masked-out query descriptors. diff --git a/modules/gpu/doc/image_filtering.rst b/modules/gpu/doc/image_filtering.rst index cb5cc7d..f63866d 100644 --- a/modules/gpu/doc/image_filtering.rst +++ b/modules/gpu/doc/image_filtering.rst @@ -11,7 +11,7 @@ See also: :ref:`ImageFiltering`. gpu::BaseRowFilter_GPU ---------------------- -.. cpp:class:: gpu::BaseRowFilter_GPU +.. ocv:class:: gpu::BaseRowFilter_GPU This is a base class for linear or non-linear filters that processes rows of 2D arrays. Such filters are used for the "horizontal" filtering passes in separable filters. :: @@ -27,13 +27,13 @@ This is a base class for linear or non-linear filters that processes rows of 2D **Note:** -This class does not allocate memory for a destination image. Usually this class is used inside :cpp:class:`gpu::FilterEngine_GPU`. +This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`. .. index:: gpu::BaseColumnFilter_GPU gpu::BaseColumnFilter_GPU ------------------------- -.. cpp:class:: gpu::BaseColumnFilter_GPU +.. ocv:class:: gpu::BaseColumnFilter_GPU This is a base class for linear or non-linear filters that processes columns of 2D arrays. Such filters are used for the "vertical" filtering passes in separable filters. :: @@ -49,13 +49,13 @@ This is a base class for linear or non-linear filters that processes columns of **Note:** -This class does not allocate memory for a destination image. Usually this class is used inside :cpp:class:`gpu::FilterEngine_GPU`. +This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`. .. index:: gpu::BaseFilter_GPU gpu::BaseFilter_GPU ------------------- -.. cpp:class:: gpu::BaseFilter_GPU +.. ocv:class:: gpu::BaseFilter_GPU This is a base class for non-separable 2D filters. :: @@ -72,13 +72,13 @@ This is a base class for non-separable 2D filters. :: **Note:** -This class does not allocate memory for a destination image. Usually this class is used inside :cpp:class:`gpu::FilterEngine_GPU`. +This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`. .. index:: gpu::FilterEngine_GPU gpu::FilterEngine_GPU --------------------- -.. cpp:class:: gpu::FilterEngine_GPU +.. ocv:class:: gpu::FilterEngine_GPU This is a base class for Filter Engine. :: @@ -93,7 +93,7 @@ This is a base class for Filter Engine. :: The class can be used to apply an arbitrary filtering operation to an image. It contains all the necessary intermediate buffers. Pointers to the initialized ``FilterEngine_GPU`` instances are returned by various ``create*Filter_GPU`` functions (see below), and they are used inside high-level functions such as -:cpp:func:`gpu::filter2D`, :cpp:func:`gpu::erode`, :cpp:func:`gpu::Sobel` , and others. +:ocv:func:`gpu::filter2D`, :ocv:func:`gpu::erode`, :ocv:func:`gpu::Sobel` , and others. By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary memory allocation for intermediate buffers and get much better performance: :: @@ -124,13 +124,13 @@ By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary mem The GPU filters do not support the in-place mode. -See also: :cpp:class:`gpu::BaseRowFilter_GPU`, :cpp:class:`gpu::BaseColumnFilter_GPU`, :cpp:class:`gpu::BaseFilter_GPU`, :cpp:func:`gpu::createFilter2D_GPU`, :cpp:func:`gpu::createSeparableFilter_GPU`, :cpp:func:`gpu::createBoxFilter_GPU`, :cpp:func:`gpu::createMorphologyFilter_GPU`, :cpp:func:`gpu::createLinearFilter_GPU`, :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`gpu::createDerivFilter_GPU`, :cpp:func:`gpu::createGaussianFilter_GPU`. +See also: :ocv:class:`gpu::BaseRowFilter_GPU`, :ocv:class:`gpu::BaseColumnFilter_GPU`, :ocv:class:`gpu::BaseFilter_GPU`, :ocv:func:`gpu::createFilter2D_GPU`, :ocv:func:`gpu::createSeparableFilter_GPU`, :ocv:func:`gpu::createBoxFilter_GPU`, :ocv:func:`gpu::createMorphologyFilter_GPU`, :ocv:func:`gpu::createLinearFilter_GPU`, :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`gpu::createDerivFilter_GPU`, :ocv:func:`gpu::createGaussianFilter_GPU`. .. index:: gpu::createFilter2D_GPU gpu::createFilter2D_GPU --------------------------- -.. cpp:function:: Ptr gpu::createFilter2D_GPU( const Ptr& filter2D, int srcType, int dstType) +.. ocv:function:: Ptr gpu::createFilter2D_GPU( const Ptr& filter2D, int srcType, int dstType) Creates a non-separable filter engine with the specified filter. @@ -140,13 +140,13 @@ gpu::createFilter2D_GPU :param dstType: Output image type. It must be supported by ``filter2D`` . - Usually this function is used inside such high-level functions as :cpp:func:`gpu::createLinearFilter_GPU`, :cpp:func:`gpu::createBoxFilter_GPU`. + Usually this function is used inside such high-level functions as :ocv:func:`gpu::createLinearFilter_GPU`, :ocv:func:`gpu::createBoxFilter_GPU`. .. index:: gpu::createSeparableFilter_GPU gpu::createSeparableFilter_GPU ---------------------------------- -.. cpp:function:: Ptr gpu::createSeparableFilter_GPU( const Ptr& rowFilter, const Ptr& columnFilter, int srcType, int bufType, int dstType) +.. ocv:function:: Ptr gpu::createSeparableFilter_GPU( const Ptr& rowFilter, const Ptr& columnFilter, int srcType, int bufType, int dstType) Creates a separable filter engine with the specified filters. @@ -160,13 +160,13 @@ gpu::createSeparableFilter_GPU :param dstType: Output image type. It must be supported by ``columnFilter``. - Usually this function is used inside such high-level functions as :cpp:func:`gpu::createSeparableLinearFilter_GPU`. + Usually this function is used inside such high-level functions as :ocv:func:`gpu::createSeparableLinearFilter_GPU`. .. index:: gpu::getRowSumFilter_GPU gpu::getRowSumFilter_GPU ---------------------------- -.. cpp:function:: Ptr gpu::getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1) +.. ocv:function:: Ptr gpu::getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1) Creates a horizontal 1D box filter. @@ -186,7 +186,7 @@ gpu::getRowSumFilter_GPU gpu::getColumnSumFilter_GPU ------------------------------- -.. cpp:function:: Ptr gpu::getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1) +.. ocv:function:: Ptr gpu::getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1) Creates a vertical 1D box filter. @@ -206,11 +206,11 @@ gpu::getColumnSumFilter_GPU gpu::createBoxFilter_GPU ---------------------------- -.. cpp:function:: Ptr gpu::createBoxFilter_GPU(int srcType, int dstType, const Size& ksize, const Point& anchor = Point(-1,-1)) +.. ocv:function:: Ptr gpu::createBoxFilter_GPU(int srcType, int dstType, const Size& ksize, const Point& anchor = Point(-1,-1)) Creates a normalized 2D box filter. -.. cpp:function:: Ptr getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1)) +.. ocv:function:: Ptr getBoxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1, -1)) :param srcType: Input image type. Supports ``CV_8UC1`` and ``CV_8UC4``. @@ -224,13 +224,13 @@ gpu::createBoxFilter_GPU This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`boxFilter` +See Also: :ocv:func:`boxFilter` .. index:: gpu::boxFilter gpu::boxFilter ------------------ -.. cpp:function:: void gpu::boxFilter(const GpuMat& src, GpuMat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1)) +.. ocv:function:: void gpu::boxFilter(const GpuMat& src, GpuMat& dst, int ddepth, Size ksize, Point anchor = Point(-1,-1)) Smooths the image using the normalized box filter. @@ -248,13 +248,13 @@ gpu::boxFilter This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`boxFilter` +See Also: :ocv:func:`boxFilter` .. index:: gpu::blur gpu::blur ------------- -.. cpp:function:: void gpu::blur(const GpuMat& src, GpuMat& dst, Size ksize, Point anchor = Point(-1,-1)) +.. ocv:function:: void gpu::blur(const GpuMat& src, GpuMat& dst, Size ksize, Point anchor = Point(-1,-1)) Acts as a synonym for the normalized box filter. @@ -270,17 +270,17 @@ gpu::blur This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`blur`, :cpp:func:`gpu::boxFilter` +See Also: :ocv:func:`blur`, :ocv:func:`gpu::boxFilter` .. index:: gpu::createMorphologyFilter_GPU gpu::createMorphologyFilter_GPU ----------------------------------- -.. cpp:function:: Ptr gpu::createMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Point& anchor = Point(-1,-1), int iterations = 1) +.. ocv:function:: Ptr gpu::createMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Point& anchor = Point(-1,-1), int iterations = 1) Creates a 2D morphological filter. -.. cpp:function:: Ptr getMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Size& ksize, Point anchor=Point(-1,-1)) +.. ocv:function:: Ptr getMorphologyFilter_GPU(int op, int type, const Mat& kernel, const Size& ksize, Point anchor=Point(-1,-1)) {Morphology operation id. Only ``MORPH_ERODE`` and ``MORPH_DILATE`` are supported.} @@ -296,13 +296,13 @@ gpu::createMorphologyFilter_GPU This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`createMorphologyFilter` +See Also: :ocv:func:`createMorphologyFilter` .. index:: gpu::erode gpu::erode -------------- -.. cpp:function:: void gpu::erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1) +.. ocv:function:: void gpu::erode(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1) Erodes an image by using a specific structuring element. @@ -320,13 +320,13 @@ gpu::erode This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`erode` +See Also: :ocv:func:`erode` .. index:: gpu::dilate gpu::dilate --------------- -.. cpp:function:: void gpu::dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1) +.. ocv:function:: void gpu::dilate(const GpuMat& src, GpuMat& dst, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1) Dilates an image by using a specific structuring element. @@ -344,13 +344,13 @@ gpu::dilate This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`dilate` +See Also: :ocv:func:`dilate` .. index:: gpu::morphologyEx gpu::morphologyEx --------------------- -.. cpp:function:: void gpu::morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1) +.. ocv:function:: void gpu::morphologyEx(const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, Point anchor = Point(-1, -1), int iterations = 1) Applies an advanced morphological operation to an image. @@ -381,17 +381,17 @@ gpu::morphologyEx This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`morphologyEx` +See Also: :ocv:func:`morphologyEx` .. index:: gpu::createLinearFilter_GPU gpu::createLinearFilter_GPU ------------------------------- -.. cpp:function:: Ptr gpu::createLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Point& anchor = Point(-1,-1)) +.. ocv:function:: Ptr gpu::createLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Point& anchor = Point(-1,-1)) Creates a non-separable linear filter. -.. cpp:function:: Ptr gpu::getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Size& ksize, Point anchor = Point(-1, -1)) +.. ocv:function:: Ptr gpu::getLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, const Size& ksize, Point anchor = Point(-1, -1)) :param srcType: Input image type. ``CV_8UC1`` and ``CV_8UC4`` types are supported. @@ -407,13 +407,13 @@ gpu::createLinearFilter_GPU This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`createLinearFilter` +See Also: :ocv:func:`createLinearFilter` .. index:: gpu::filter2D gpu::filter2D ----------------- -.. cpp:function:: void gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1)) +.. ocv:function:: void gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1)) Applies the non-separable 2D linear filter to an image. @@ -431,13 +431,13 @@ gpu::filter2D This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`filter2D` +See Also: :ocv:func:`filter2D` .. index:: gpu::Laplacian gpu::Laplacian ------------------ -.. cpp:function:: void gpu::Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1) +.. ocv:function:: void gpu::Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1) Applies the Laplacian operator to an image. @@ -447,21 +447,21 @@ gpu::Laplacian :param ddepth: Desired depth of the destination image. It supports only the same depth as the source image depth. - :param ksize: Aperture size used to compute the second-derivative filters (see :cpp:func:`getDerivKernels`). It must be positive and odd. Only ``ksize`` = 1 and ``ksize`` = 3 are supported. + :param ksize: Aperture size used to compute the second-derivative filters (see :ocv:func:`getDerivKernels`). It must be positive and odd. Only ``ksize`` = 1 and ``ksize`` = 3 are supported. - :param scale: Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see :cpp:func:`getDerivKernels` ). + :param scale: Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see :ocv:func:`getDerivKernels` ). **Note:** This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it. -See Also: :cpp:func:`Laplacian`,:cpp:func:`gpu::filter2D` . +See Also: :ocv:func:`Laplacian`,:ocv:func:`gpu::filter2D` . .. index:: gpu::getLinearRowFilter_GPU gpu::getLinearRowFilter_GPU ------------------------------- -.. cpp:function:: Ptr gpu::getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT) +.. ocv:function:: Ptr gpu::getLinearRowFilter_GPU(int srcType, int bufType, const Mat& rowKernel, int anchor = -1, int borderType = BORDER_CONSTANT) Creates a primitive row filter with the specified kernel. @@ -473,19 +473,19 @@ gpu::getLinearRowFilter_GPU :param anchor: Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center. - :param borderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate`. For details on limitations, see below. + :param borderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate`. For details on limitations, see below. There are two versions of the algorithm: NPP and OpenCV. * NPP version is called when ``srcType == CV_8UC1`` or ``srcType == CV_8UC4`` and ``bufType == srcType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image. * OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``,``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside the image. -See Also:,:cpp:func:`createSeparableLinearFilter` . +See Also:,:ocv:func:`createSeparableLinearFilter` . .. index:: gpu::getLinearColumnFilter_GPU gpu::getLinearColumnFilter_GPU ---------------------------------- -.. cpp:function:: Ptr gpu::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT) +.. ocv:function:: Ptr gpu::getLinearColumnFilter_GPU(int bufType, int dstType, const Mat& columnKernel, int anchor = -1, int borderType = BORDER_CONSTANT) Creates a primitive column filter with the specified kernel. @@ -497,19 +497,19 @@ gpu::getLinearColumnFilter_GPU :param anchor: Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center. - :param borderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate` . For details on limitations, see below. + :param borderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` . For details on limitations, see below. There are two versions of the algorithm: NPP and OpenCV. * NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image. * OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101``, ``BORDER_REPLICATE``, and ``BORDER_CONSTANT`` border types. It checks indices outside image. -See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`createSeparableLinearFilter` +See Also: :ocv:func:`gpu::getLinearRowFilter_GPU`, :ocv:func:`createSeparableLinearFilter` .. index:: gpu::createSeparableLinearFilter_GPU gpu::createSeparableLinearFilter_GPU ---------------------------------------- -.. cpp:function:: Ptr gpu::createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel, const Mat& columnKernel, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) +.. ocv:function:: Ptr gpu::createSeparableLinearFilter_GPU(int srcType, int dstType, const Mat& rowKernel, const Mat& columnKernel, const Point& anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) Creates a separable linear filter engine. @@ -521,16 +521,16 @@ gpu::createSeparableLinearFilter_GPU :param anchor: Anchor position within the kernel. Negative values mean that anchor is positioned at the aperture center. - :param rowBorderType, columnBorderType: Pixel extrapolation method in the horizontal and vertical directions For details, see :cpp:func:`borderInterpolate`. For details on limitations, see :cpp:func:`gpu::getLinearRowFilter_GPU`, cpp:cpp:func:`gpu::getLinearColumnFilter_GPU`. + :param rowBorderType, columnBorderType: Pixel extrapolation method in the horizontal and vertical directions For details, see :ocv:func:`borderInterpolate`. For details on limitations, see :ocv:func:`gpu::getLinearRowFilter_GPU`, cpp:ocv:func:`gpu::getLinearColumnFilter_GPU`. -See Also: :cpp:func:`gpu::getLinearRowFilter_GPU`, :cpp:func:`gpu::getLinearColumnFilter_GPU`, :cpp:func:`createSeparableLinearFilter` +See Also: :ocv:func:`gpu::getLinearRowFilter_GPU`, :ocv:func:`gpu::getLinearColumnFilter_GPU`, :ocv:func:`createSeparableLinearFilter` .. index:: gpu::sepFilter2D gpu::sepFilter2D -------------------- -.. cpp:function:: void gpu::sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) +.. ocv:function:: void gpu::sepFilter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, Point anchor = Point(-1,-1), int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) Applies a separable 2D linear filter to an image. @@ -544,15 +544,15 @@ gpu::sepFilter2D :param anchor: Anchor position within the kernel. The default value ``(-1, 1)`` means that the anchor is at the kernel center. - :param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate`. + :param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate`. -See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`sepFilter2D` +See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`sepFilter2D` .. index:: gpu::createDerivFilter_GPU gpu::createDerivFilter_GPU ------------------------------ -.. cpp:function:: Ptr createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) +.. ocv:function:: Ptr createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) Creates a filter engine for the generalized Sobel operator. @@ -564,17 +564,17 @@ gpu::createDerivFilter_GPU :param dy: Derivative order in respect of y. - :param ksize: Aperture size. See :cpp:func:`getDerivKernels` for details. + :param ksize: Aperture size. See :ocv:func:`getDerivKernels` for details. - :param rowBorderType, columnBorderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param rowBorderType, columnBorderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. -See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`createDerivFilter` +See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`createDerivFilter` .. index:: gpu::Sobel gpu::Sobel -------------- -.. cpp:function:: void gpu::Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) +.. ocv:function:: void gpu::Sobel(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize = 3, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) Applies the generalized Sobel operator to an image. @@ -590,17 +590,17 @@ gpu::Sobel :param ksize: Size of the extended Sobel kernel. Possible valies are 1, 3, 5 or 7. - :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :cpp:func:`getDerivKernels` . + :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :ocv:func:`getDerivKernels` . - :param rowBorderType, columnBorderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param rowBorderType, columnBorderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. -See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`Sobel` +See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`Sobel` .. index:: gpu::Scharr gpu::Scharr --------------- -.. cpp:function:: void gpu::Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) +.. ocv:function:: void gpu::Scharr(const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale = 1, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) Calculates the first x- or y- image derivative using the Scharr operator. @@ -614,37 +614,37 @@ gpu::Scharr :param yorder: Order of the derivative y. - :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details. + :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details. - :param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :cpp:func:`borderInterpolate` and :cpp:func:`Scharr` . + :param rowBorderType, columnBorderType: Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` and :ocv:func:`Scharr` . -See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`Scharr` +See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`Scharr` .. index:: gpu::createGaussianFilter_GPU gpu::createGaussianFilter_GPU --------------------------------- -.. cpp:function:: Ptr gpu::createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) +.. ocv:function:: Ptr gpu::createGaussianFilter_GPU(int type, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) Creates a Gaussian filter engine. :param type: Source and destination image type. ``CV_8UC1``, ``CV_8UC4``, ``CV_16SC1``, ``CV_16SC2``, ``CV_32SC1``, ``CV_32FC1`` are supported. - :param ksize: Aperture size. See :cpp:func:`getGaussianKernel` for details. + :param ksize: Aperture size. See :ocv:func:`getGaussianKernel` for details. - :param sigmaX: Gaussian sigma in the horizontal direction. See :cpp:func:`getGaussianKernel` for details. + :param sigmaX: Gaussian sigma in the horizontal direction. See :ocv:func:`getGaussianKernel` for details. :param sigmaY: Gaussian sigma in the vertical direction. If 0, then :math:`\texttt{sigmaY}\leftarrow\texttt{sigmaX}` . - :param rowBorderType, columnBorderType: Border type to use. See :cpp:func:`borderInterpolate` for details. + :param rowBorderType, columnBorderType: Border type to use. See :ocv:func:`borderInterpolate` for details. -See Also: :cpp:func:`gpu::createSeparableLinearFilter_GPU`, :cpp:func:`createGaussianFilter` +See Also: :ocv:func:`gpu::createSeparableLinearFilter_GPU`, :ocv:func:`createGaussianFilter` .. index:: gpu::GaussianBlur gpu::GaussianBlur --------------------- -.. cpp:function:: void gpu::GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) +.. ocv:function:: void gpu::GaussianBlur(const GpuMat& src, GpuMat& dst, Size ksize, double sigmaX, double sigmaY = 0, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1) Smooths an image using the Gaussian filter. @@ -654,17 +654,17 @@ gpu::GaussianBlur :param ksize: Gaussian kernel size. ``ksize.width`` and ``ksize.height`` can differ but they both must be positive and odd. If they are zeros, they are computed from ``sigmaX`` and ``sigmaY`` . - :param sigmaX, sigmaY: Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height``, respectively. See :cpp:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ``ksize``, ``sigmaX``, and ``sigmaY`` . + :param sigmaX, sigmaY: Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height``, respectively. See :ocv:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ``ksize``, ``sigmaX``, and ``sigmaY`` . - :param rowBorderType, columnBorderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param rowBorderType, columnBorderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. -See Also: :cpp:func:`gpu::createGaussianFilter_GPU`, :cpp:func:`GaussianBlur` +See Also: :ocv:func:`gpu::createGaussianFilter_GPU`, :ocv:func:`GaussianBlur` .. index:: gpu::getMaxFilter_GPU gpu::getMaxFilter_GPU ------------------------- -.. cpp:function:: Ptr gpu::getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1)) +.. ocv:function:: Ptr gpu::getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1)) Creates the maximum filter. @@ -684,7 +684,7 @@ gpu::getMaxFilter_GPU gpu::getMinFilter_GPU ------------------------- -.. cpp:function:: Ptr gpu::getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1)) +.. ocv:function:: Ptr gpu::getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1)) Creates the minimum filter. diff --git a/modules/gpu/doc/image_processing.rst b/modules/gpu/doc/image_processing.rst index 86cc3e9..0d407ea 100644 --- a/modules/gpu/doc/image_processing.rst +++ b/modules/gpu/doc/image_processing.rst @@ -7,7 +7,7 @@ Image Processing gpu::meanShiftFiltering --------------------------- -.. cpp:function:: void gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)) +.. ocv:function:: void gpu::meanShiftFiltering(const GpuMat& src, GpuMat& dst, int sp, int sr,TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)) Performs mean-shift filtering for each point of the source image. It maps each point of the source image into another point. As a result, you have a new color and new position of each point. @@ -19,13 +19,13 @@ gpu::meanShiftFiltering :param sr: Color window radius. - :param criteria: Termination criteria. See :cpp:class:`TermCriteria`. + :param criteria: Termination criteria. See :ocv:class:`TermCriteria`. .. index:: gpu::meanShiftProc gpu::meanShiftProc ---------------------- -.. cpp:function:: void gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)) +.. ocv:function:: void gpu::meanShiftProc(const GpuMat& src, GpuMat& dstr, GpuMat& dstsp, int sp, int sr, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)) Performs a mean-shift procedure and stores information about processed points (their colors and positions) in two images. @@ -39,16 +39,16 @@ gpu::meanShiftProc :param sr: Color window radius. - :param criteria: Termination criteria. See :cpp:class:`TermCriteria`. + :param criteria: Termination criteria. See :ocv:class:`TermCriteria`. See Also: -:cpp:func:`gpu::meanShiftFiltering` +:ocv:func:`gpu::meanShiftFiltering` .. index:: gpu::meanShiftSegmentation gpu::meanShiftSegmentation ------------------------------ -.. cpp:function:: void gpu::meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)) +.. ocv:function:: void gpu::meanShiftSegmentation(const GpuMat& src, Mat& dst, int sp, int sr, int minsize, TermCriteria criteria = TermCriteria(TermCriteria::MAX_ITER + TermCriteria::EPS, 5, 1)) Performs a mean-shift segmentation of the source image and eliminates small segments. @@ -62,15 +62,15 @@ gpu::meanShiftSegmentation :param minsize: Minimum segment size. Smaller segements are merged. - :param criteria: Termination criteria. See :cpp:class:`TermCriteria`. + :param criteria: Termination criteria. See :ocv:class:`TermCriteria`. .. index:: gpu::integral gpu::integral ----------------- -.. cpp:function:: void gpu::integral(const GpuMat& src, GpuMat& sum) +.. ocv:function:: void gpu::integral(const GpuMat& src, GpuMat& sum) -.. cpp:function:: void gpu::integral(const GpuMat& src, GpuMat& sum, GpuMat& sqsum) +.. ocv:function:: void gpu::integral(const GpuMat& src, GpuMat& sum, GpuMat& sqsum) Computes an integral image and a squared integral image. @@ -81,13 +81,13 @@ gpu::integral :param sqsum: Squared integral image of the ``CV_32FC1`` type. See Also: -:cpp:func:`integral` +:ocv:func:`integral` .. index:: gpu::sqrIntegral gpu::sqrIntegral -------------------- -.. cpp:function:: void gpu::sqrIntegral(const GpuMat& src, GpuMat& sqsum) +.. ocv:function:: void gpu::sqrIntegral(const GpuMat& src, GpuMat& sqsum) Computes a squared integral image. @@ -99,7 +99,7 @@ gpu::sqrIntegral gpu::columnSum ------------------ -.. cpp:function:: void gpu::columnSum(const GpuMat& src, GpuMat& sum) +.. ocv:function:: void gpu::columnSum(const GpuMat& src, GpuMat& sum) Computes a vertical (column) sum. @@ -111,7 +111,7 @@ gpu::columnSum gpu::cornerHarris --------------------- -.. cpp:function:: void gpu::cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101) +.. ocv:function:: void gpu::cornerHarris(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, double k, int borderType=BORDER_REFLECT101) Computes the Harris cornerness criteria at each image pixel. @@ -128,13 +128,13 @@ gpu::cornerHarris :param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now. See Also: -:cpp:func:`cornerHarris` +:ocv:func:`cornerHarris` .. index:: gpu::cornerMinEigenVal gpu::cornerMinEigenVal -------------------------- -.. cpp:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101) +.. ocv:function:: void gpu::cornerMinEigenVal(const GpuMat& src, GpuMat& dst, int blockSize, int ksize, int borderType=BORDER_REFLECT101) Computes the minimum eigen value of 2x2 derivative covariation matrix at each pixel (the cornerness criteria). @@ -150,13 +150,13 @@ gpu::cornerMinEigenVal :param borderType: Pixel extrapolation method. Only ``BORDER_REFLECT101`` and ``BORDER_REPLICATE`` are supported for now. -See also: :cpp:func:`cornerMinEigenVal` +See also: :ocv:func:`cornerMinEigenVal` .. index:: gpu::mulSpectrums gpu::mulSpectrums --------------------- -.. cpp:function:: void gpu::mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false) +.. ocv:function:: void gpu::mulSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, bool conjB=false) Performs a per-element multiplication of two Fourier spectrums. @@ -173,13 +173,13 @@ gpu::mulSpectrums Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now. See Also: -:cpp:func:`mulSpectrums` +:ocv:func:`mulSpectrums` .. index:: gpu::mulAndScaleSpectrums gpu::mulAndScaleSpectrums ----------------------------- -.. cpp:function:: void gpu::mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false) +.. ocv:function:: void gpu::mulAndScaleSpectrums(const GpuMat& a, const GpuMat& b, GpuMat& c, int flags, float scale, bool conjB=false) Performs a per-element multiplication of two Fourier spectrums and scales the result. @@ -198,13 +198,13 @@ gpu::mulAndScaleSpectrums Only full (not packed) ``CV_32FC2`` complex spectrums in the interleaved format are supported for now. See Also: -:cpp:func:`mulSpectrums` +:ocv:func:`mulSpectrums` .. index:: gpu::dft gpu::dft ------------ -.. cpp:function:: void gpu::dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0) +.. ocv:function:: void gpu::dft(const GpuMat& src, GpuMat& dst, Size dft_size, int flags=0) Performs a forward or inverse discrete Fourier transform (1D or 2D) of the floating point matrix. Use to handle real matrices (``CV32FC1``) and complex matrices in the interleaved format (``CV32FC2``). @@ -237,15 +237,15 @@ gpu::dft If the source matrix is real (its type is ``CV_32FC1`` ), forward DFT is performed. The result of the DFT is packed into complex ( ``CV_32FC2`` ) matrix. So, the width of the destination matrix is ``dft_size.width / 2 + 1`` . But if the source is a single column, the height is reduced instead of the width. See Also: -:cpp:func:`dft` +:ocv:func:`dft` .. index:: gpu::convolve gpu::convolve ----------------- -.. cpp:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr=false) +.. ocv:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr=false) -.. cpp:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf) +.. ocv:function:: void gpu::convolve(const GpuMat& image, const GpuMat& templ, GpuMat& result, bool ccorr, ConvolveBuf& buf) Computes a convolution (or cross-correlation) of two images. @@ -265,10 +265,10 @@ gpu::convolve gpu::ConvolveBuf ---------------- -.. cpp:class:: gpu::ConvolveBuf +.. ocv:class:: gpu::ConvolveBuf This class provides a memory buffer for the - :cpp:func:`gpu::convolve` function. + :ocv:func:`gpu::convolve` function. :: struct CV_EXPORTS ConvolveBuf @@ -287,21 +287,21 @@ This class provides a memory buffer for the gpu::ConvolveBuf::ConvolveBuf --------------------------------- -.. cpp:function:: ConvolveBuf::ConvolveBuf() +.. ocv:function:: ConvolveBuf::ConvolveBuf() Constructs an empty buffer that is properly resized after the first call of the - :cpp:func:`convolve` function. + :ocv:func:`convolve` function. -.. cpp:function:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size) +.. ocv:function:: ConvolveBuf::ConvolveBuf(Size image_size, Size templ_size) Constructs a buffer for the - :cpp:func:`convolve` function with respective arguments. + :ocv:func:`convolve` function with respective arguments. .. index:: gpu::matchTemplate gpu::matchTemplate ---------------------- -.. cpp:function:: void gpu::matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method) +.. ocv:function:: void gpu::matchTemplate(const GpuMat& image, const GpuMat& templ, GpuMat& result, int method) Computes a proximity map for a raster template and an image where the template is searched for. @@ -328,13 +328,13 @@ gpu::matchTemplate * ``CV_TM_CCORR`` See Also: -:cpp:func:`matchTemplate` +:ocv:func:`matchTemplate` .. index:: gpu::remap gpu::remap -------------- -.. cpp:function:: void gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap) +.. ocv:function:: void gpu::remap(const GpuMat& src, GpuMat& dst, const GpuMat& xmap, const GpuMat& ymap) Applies a generic geometrical transformation to an image. @@ -354,15 +354,15 @@ gpu::remap Values of pixels with non-integer coordinates are computed using bilinear the interpolation. -See Also: :cpp:func:`remap` +See Also: :ocv:func:`remap` .. index:: gpu::cvtColor gpu::cvtColor ----------------- -.. cpp:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0) +.. ocv:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn = 0) -.. cpp:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn, const Stream& stream) +.. ocv:function:: void gpu::cvtColor(const GpuMat& src, GpuMat& dst, int code, int dcn, const Stream& stream) Converts an image from one color space to another. @@ -370,7 +370,7 @@ gpu::cvtColor :param dst: Destination image with the same size and depth as ``src`` . - :param code: Color space conversion code. For details, see :cpp:func:`cvtColor` . Conversion to/from Luv and Bayer color spaces is not supported. + :param code: Color space conversion code. For details, see :ocv:func:`cvtColor` . Conversion to/from Luv and Bayer color spaces is not supported. :param dcn: Number of channels in the destination image. If the parameter is 0, the number of the channels is derived automatically from ``src`` and the ``code`` . @@ -379,15 +379,15 @@ gpu::cvtColor 3-channel color spaces (like ``HSV``, ``XYZ``, and so on) can be stored in a 4-channel image for better perfomance. See Also: -:cpp:func:`cvtColor` +:ocv:func:`cvtColor` .. index:: gpu::threshold gpu::threshold ------------------ -.. cpp:function:: double gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type) +.. ocv:function:: double gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type) -.. cpp:function:: double gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, const Stream& stream) +.. ocv:function:: double gpu::threshold(const GpuMat& src, GpuMat& dst, double thresh, double maxval, int type, const Stream& stream) Applies a fixed-level threshold to each array element. @@ -399,18 +399,18 @@ gpu::threshold :param maxVal: Maximum value to use with ``THRESH_BINARY`` and ``THRESH_BINARY_INV`` threshold types. - :param thresholdType: Threshold type. For details, see :cpp:func:`threshold` . The ``THRESH_OTSU`` threshold type is not supported. + :param thresholdType: Threshold type. For details, see :ocv:func:`threshold` . The ``THRESH_OTSU`` threshold type is not supported. :param stream: Stream for the asynchronous version. See Also: -:cpp:func:`threshold` +:ocv:func:`threshold` .. index:: gpu::resize gpu::resize --------------- -.. cpp:function:: void gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR) +.. ocv:function:: void gpu::resize(const GpuMat& src, GpuMat& dst, Size dsize, double fx=0, double fy=0, int interpolation = INTER_LINEAR) Resizes an image. @@ -439,13 +439,13 @@ gpu::resize :param interpolation: Interpolation method. Only ``INTER_NEAREST`` and ``INTER_LINEAR`` are supported. -See Also: :cpp:func:`resize` +See Also: :ocv:func:`resize` .. index:: gpu::warpAffine gpu::warpAffine ------------------- -.. cpp:function:: void gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR) +.. ocv:function:: void gpu::warpAffine(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR) Applies an affine transformation to an image. @@ -457,16 +457,16 @@ gpu::warpAffine :param dsize: Size of the destination image. - :param flags: Combination of interpolation methods (see :cpp:func:`resize`) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is an inverse transformation (``dst=>src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported. + :param flags: Combination of interpolation methods (see :ocv:func:`resize`) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is an inverse transformation (``dst=>src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported. See Also: -:cpp:func:`warpAffine` +:ocv:func:`warpAffine` .. index:: gpu::warpPerspective gpu::warpPerspective ------------------------ -.. cpp:function:: void gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR) +.. ocv:function:: void gpu::warpPerspective(const GpuMat& src, GpuMat& dst, const Mat& M, Size dsize, int flags = INTER_LINEAR) Applies a perspective transformation to an image. @@ -478,16 +478,16 @@ gpu::warpPerspective :param dsize: Size of the destination image. - :param flags: Combination of interpolation methods (see :cpp:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is the inverse transformation (``dst => src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported. + :param flags: Combination of interpolation methods (see :ocv:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` specifying that ``M`` is the inverse transformation (``dst => src``). Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` interpolation methods are supported. See Also: -:cpp:func:`warpPerspective` +:ocv:func:`warpPerspective` .. index:: gpu::rotate gpu::rotate --------------- -.. cpp:function:: void gpu::rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, int interpolation = INTER_LINEAR) +.. ocv:function:: void gpu::rotate(const GpuMat& src, GpuMat& dst, Size dsize, double angle, double xShift = 0, double yShift = 0, int interpolation = INTER_LINEAR) Rotates an image around the origin (0,0) and then shifts it. @@ -506,13 +506,13 @@ gpu::rotate :param interpolation: Interpolation method. Only ``INTER_NEAREST``, ``INTER_LINEAR``, and ``INTER_CUBIC`` are supported. See Also: -:cpp:func:`gpu::warpAffine` +:ocv:func:`gpu::warpAffine` .. index:: gpu::copyMakeBorder gpu::copyMakeBorder ----------------------- -.. cpp:function:: void gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value = Scalar()) +.. ocv:function:: void gpu::copyMakeBorder(const GpuMat& src, GpuMat& dst, int top, int bottom, int left, int right, const Scalar& value = Scalar()) Copies a 2D array to a larger destination array and pads borders with the given constant. @@ -525,13 +525,13 @@ gpu::copyMakeBorder :param value: Border value. See Also: -:cpp:func:`copyMakeBorder` +:ocv:func:`copyMakeBorder` .. index:: gpu::rectStdDev gpu::rectStdDev ------------------- -.. cpp:function:: void gpu::rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect) +.. ocv:function:: void gpu::rectStdDev(const GpuMat& src, const GpuMat& sqr, GpuMat& dst, const Rect& rect) Computes a standard deviation of integral images. @@ -547,7 +547,7 @@ gpu::rectStdDev gpu::evenLevels ------------------- -.. cpp:function:: void gpu::evenLevels(GpuMat& levels, int nLevels, int lowerLevel, int upperLevel) +.. ocv:function:: void gpu::evenLevels(GpuMat& levels, int nLevels, int lowerLevel, int upperLevel) Computes levels with even distribution. @@ -563,9 +563,9 @@ gpu::evenLevels gpu::histEven ----------------- -.. cpp:function:: void gpu::histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel) +.. ocv:function:: void gpu::histEven(const GpuMat& src, GpuMat& hist, int histSize, int lowerLevel, int upperLevel) -.. cpp:function:: void gpu::histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4]) +.. ocv:function:: void gpu::histEven(const GpuMat& src, GpuMat hist[4], int histSize[4], int lowerLevel[4], int upperLevel[4]) Calculates a histogram with evenly distributed bins. @@ -583,9 +583,9 @@ gpu::histEven gpu::histRange ------------------ -.. cpp:function:: void gpu::histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels) +.. ocv:function:: void gpu::histRange(const GpuMat& src, GpuMat& hist, const GpuMat& levels) -.. cpp:function:: void gpu::histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4]) +.. ocv:function:: void gpu::histRange(const GpuMat& src, GpuMat hist[4], const GpuMat levels[4]) Calculates a histogram with bins determined by the `levels` array. diff --git a/modules/gpu/doc/initalization_and_information.rst b/modules/gpu/doc/initalization_and_information.rst index 3c6781b..0abf0f6 100644 --- a/modules/gpu/doc/initalization_and_information.rst +++ b/modules/gpu/doc/initalization_and_information.rst @@ -7,7 +7,7 @@ Initalization and Information gpu::getCudaEnabledDeviceCount ---------------------------------- -.. cpp:function:: int getCudaEnabledDeviceCount() +.. ocv:function:: int getCudaEnabledDeviceCount() Returns the number of installed CUDA-enabled devices. Use this function before any other GPU functions calls. If OpenCV is compiled without GPU support, this function returns 0. @@ -15,7 +15,7 @@ gpu::getCudaEnabledDeviceCount gpu::setDevice ------------------ -.. cpp:function:: void setDevice(int device) +.. ocv:function:: void setDevice(int device) Sets a device and initializes it for the current thread. If the call of this function is omitted, a default device is initialized at the fist GPU usage. @@ -25,7 +25,7 @@ gpu::setDevice gpu::getDevice ------------------ -.. cpp:function:: int getDevice() +.. ocv:function:: int getDevice() Returns the current device index that was set by ``{gpu::getDevice}`` or initialized by default. @@ -33,7 +33,7 @@ gpu::getDevice gpu::GpuFeature --------------- -.. cpp:class:: gpu::GpuFeature +.. ocv:class:: gpu::GpuFeature This class provides GPU computing features. :: @@ -51,7 +51,7 @@ This class provides GPU computing features. gpu::DeviceInfo --------------- -.. cpp:class:: gpu::DeviceInfo +.. ocv:class:: gpu::DeviceInfo This class provides functionality for querying the specified GPU properties. :: @@ -82,9 +82,9 @@ This class provides functionality for querying the specified GPU properties. gpu::DeviceInfo::DeviceInfo ------------------------------- -.. cpp:function:: gpu::DeviceInfo::DeviceInfo() +.. ocv:function:: gpu::DeviceInfo::DeviceInfo() -.. cpp:function:: gpu::DeviceInfo::DeviceInfo(int device_id) +.. ocv:function:: gpu::DeviceInfo::DeviceInfo(int device_id) Constructs the ``DeviceInfo`` object for the specified device. If ``device_id`` parameter is missed, it constructs an object for the current device. @@ -94,7 +94,7 @@ gpu::DeviceInfo::DeviceInfo gpu::DeviceInfo::name ------------------------- -.. cpp:function:: string gpu::DeviceInfo::name() +.. ocv:function:: string gpu::DeviceInfo::name() Returns the device name. @@ -102,7 +102,7 @@ gpu::DeviceInfo::name gpu::DeviceInfo::majorVersion --------------------------------- -.. cpp:function:: int gpu::DeviceInfo::majorVersion() +.. ocv:function:: int gpu::DeviceInfo::majorVersion() Returns the major compute capability version. @@ -110,7 +110,7 @@ gpu::DeviceInfo::majorVersion gpu::DeviceInfo::minorVersion --------------------------------- -.. cpp:function:: int gpu::DeviceInfo::minorVersion() +.. ocv:function:: int gpu::DeviceInfo::minorVersion() Returns the minor compute capability version. @@ -118,7 +118,7 @@ gpu::DeviceInfo::minorVersion gpu::DeviceInfo::multiProcessorCount ---------------------------------------- -.. cpp:function:: int gpu::DeviceInfo::multiProcessorCount() +.. ocv:function:: int gpu::DeviceInfo::multiProcessorCount() Returns the number of streaming multiprocessors. @@ -126,7 +126,7 @@ gpu::DeviceInfo::multiProcessorCount gpu::DeviceInfo::freeMemory ------------------------------- -.. cpp:function:: size_t gpu::DeviceInfo::freeMemory() +.. ocv:function:: size_t gpu::DeviceInfo::freeMemory() Returns the amount of free memory in bytes. @@ -134,7 +134,7 @@ gpu::DeviceInfo::freeMemory gpu::DeviceInfo::totalMemory -------------------------------- -.. cpp:function:: size_t gpu::DeviceInfo::totalMemory() +.. ocv:function:: size_t gpu::DeviceInfo::totalMemory() Returns the amount of total memory in bytes. @@ -142,17 +142,17 @@ gpu::DeviceInfo::totalMemory gpu::DeviceInfo::supports ----------------------------- -.. cpp:function:: bool gpu::DeviceInfo::supports(GpuFeature feature) +.. ocv:function:: bool gpu::DeviceInfo::supports(GpuFeature feature) Provides information on GPU feature support. This function returns true if the device has the specified GPU feature. Otherwise, it returns false. - :param feature: Feature to be checked. See :cpp:class:`gpu::GpuFeature`. + :param feature: Feature to be checked. See :ocv:class:`gpu::GpuFeature`. .. index:: gpu::DeviceInfo::isCompatible gpu::DeviceInfo::isCompatible --------------------------------- -.. cpp:function:: bool gpu::DeviceInfo::isCompatible() +.. ocv:function:: bool gpu::DeviceInfo::isCompatible() Checks the GPU module and device compatibility. This function returns ``true`` if the GPU module can be run on the specified device. Otherwise, it returns false. @@ -162,31 +162,31 @@ gpu::DeviceInfo::isCompatible gpu::TargetArchs ---------------- -.. cpp:class:: gpu::TargetArchs +.. ocv:class:: gpu::TargetArchs This class provides a set of static methods to check what NVIDIA* card architecture the GPU module was built for. The following method checks whether the module was built with the support of the given feature: - .. cpp:function:: static bool gpu::TargetArchs::builtWith(GpuFeature feature) + .. ocv:function:: static bool gpu::TargetArchs::builtWith(GpuFeature feature) - :param feature: Feature to be checked. See :cpp:class:`gpu::GpuFeature`. + :param feature: Feature to be checked. See :ocv:class:`gpu::GpuFeature`. There is a set of methods to check whether the module contains intermediate (PTX) or binary GPU code for the given architecture(s): - .. cpp:function:: static bool gpu::TargetArchs::has(int major, int minor) + .. ocv:function:: static bool gpu::TargetArchs::has(int major, int minor) - .. cpp:function:: static bool gpu::TargetArchs::hasPtx(int major, int minor) + .. ocv:function:: static bool gpu::TargetArchs::hasPtx(int major, int minor) - .. cpp:function:: static bool gpu::TargetArchs::hasBin(int major, int minor) + .. ocv:function:: static bool gpu::TargetArchs::hasBin(int major, int minor) - .. cpp:function:: static bool gpu::TargetArchs::hasEqualOrLessPtx(int major, int minor) + .. ocv:function:: static bool gpu::TargetArchs::hasEqualOrLessPtx(int major, int minor) - .. cpp:function:: static bool gpu::TargetArchs::hasEqualOrGreater(int major, int minor) + .. ocv:function:: static bool gpu::TargetArchs::hasEqualOrGreater(int major, int minor) - .. cpp:function:: static bool gpu::TargetArchs::hasEqualOrGreaterPtx(int major, int minor) + .. ocv:function:: static bool gpu::TargetArchs::hasEqualOrGreaterPtx(int major, int minor) - .. cpp:function:: static bool gpu::TargetArchs::hasEqualOrGreaterBin(int major, int minor) + .. ocv:function:: static bool gpu::TargetArchs::hasEqualOrGreaterBin(int major, int minor) :param major: Major compute capability version. diff --git a/modules/gpu/doc/introduction.rst b/modules/gpu/doc/introduction.rst index 98aba9c..3179b40 100644 --- a/modules/gpu/doc/introduction.rst +++ b/modules/gpu/doc/introduction.rst @@ -15,9 +15,9 @@ The GPU module depends on the CUDA Toolkit and NVIDIA Performance Primitives lib The OpenCV GPU module is designed for ease of use and does not require any knowledge of CUDA. Though, such a knowledge will certainly be useful to handle non-trivial cases or achieve the highest performance. It is helpful to understand the cost of various operations, what the GPU does, what the preferred data formats are, and so on. The GPU module is an effective instrument for quick implementation of GPU-accelerated computer vision algorithms. However, if your algorithm involves many simple operations, then, for the best possible performance, you may still need to write your own kernels to avoid extra write and read operations on the intermediate results. To enable CUDA support, configure OpenCV using ``CMake`` with ``WITH_CUDA=ON`` . When the flag is set and if CUDA is installed, the full-featured OpenCV GPU module is built. Otherwise, the module is still built, but at runtime all functions from the module throw -:cpp:func:`Exception` with ``CV_GpuNotSupported`` error code, except for -:cpp:func:`gpu::getCudaEnabledDeviceCount()`. The latter function returns zero GPU count in this case. Building OpenCV without CUDA support does not perform device code compilation, so it does not require the CUDA Toolkit installed. Therefore, using the -:cpp:func:`gpu::getCudaEnabledDeviceCount()` function, you can implement a high-level algorithm that will detect GPU presence at runtime and choose an appropriate implementation (CPU or GPU) accordingly. +:ocv:func:`Exception` with ``CV_GpuNotSupported`` error code, except for +:ocv:func:`gpu::getCudaEnabledDeviceCount()`. The latter function returns zero GPU count in this case. Building OpenCV without CUDA support does not perform device code compilation, so it does not require the CUDA Toolkit installed. Therefore, using the +:ocv:func:`gpu::getCudaEnabledDeviceCount()` function, you can implement a high-level algorithm that will detect GPU presence at runtime and choose an appropriate implementation (CPU or GPU) accordingly. Compilation for Different NVIDIA* Platforms ------------------------------------------- @@ -34,12 +34,12 @@ By default, the OpenCV GPU module includes: PTX code for compute capabilities 1.1 and 1.3 (controlled by ``CUDA_ARCH_PTX`` in ``CMake``) This means that for devices with CC 1.3 and 2.0 binary images are ready to run. For all newer platforms, the PTX code for 1.3 is JIT'ed to a binary image. For devices with CC 1.1 and 1.2, the PTX for 1.1 is JIT'ed. For devices with CC 1.0, no code is available and the functions throw -:cpp:func:`Exception`. For platforms where JIT compilation is performed first, the run is slow. +:ocv:func:`Exception`. For platforms where JIT compilation is performed first, the run is slow. On a GPU with CC 1.0, you can still compile the GPU module and most of the functions will run flawlessly. To achieve this, add "1.0" to the list of binaries, for example, ``CUDA_ARCH_BIN="1.0 1.3 2.0"`` . The functions that cannot be run on CC 1.0 GPUs throw an exception. You can always determine at runtime whether the OpenCV GPU-built binaries (or PTX code) are compatible with your GPU. The function -:cpp:func:`gpu::DeviceInfo::isCompatible` returns the compatibility status (true/false). +:ocv:func:`gpu::DeviceInfo::isCompatible` returns the compatibility status (true/false). Threading and Multi-threading ------------------------------ @@ -57,7 +57,7 @@ In the current version, each of the OpenCV GPU algorithms can use only a single * If you use only synchronous functions, create several CPU threads (one per each GPU) and from within each thread create a CUDA context for the corresponding GPU using - :cpp:func:`gpu::setDevice()` or Driver API. Each of the threads will use the associated GPU. + :ocv:func:`gpu::setDevice()` or Driver API. Each of the threads will use the associated GPU. * If you use asynchronous functions, you can use the Driver API to create several CUDA contexts associated with different GPUs but attached to one CPU thread. Within the thread you can switch from one GPU to another by making the corresponding context "current". With non-blocking GPU calls, managing algorithm is clear. diff --git a/modules/gpu/doc/matrix_reductions.rst b/modules/gpu/doc/matrix_reductions.rst index 4d20e0a..92ac4d7 100644 --- a/modules/gpu/doc/matrix_reductions.rst +++ b/modules/gpu/doc/matrix_reductions.rst @@ -7,7 +7,7 @@ Matrix Reductions gpu::meanStdDev ------------------- -.. cpp:function:: void gpu::meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev) +.. ocv:function:: void gpu::meanStdDev(const GpuMat\& mtx, Scalar\& mean, Scalar\& stddev) Computes a mean value and a standard deviation of matrix elements. @@ -17,15 +17,15 @@ gpu::meanStdDev :param stddev: Standard deviation value. -See Also: :cpp:func:`meanStdDev` +See Also: :ocv:func:`meanStdDev` .. index:: gpu::norm gpu::norm ------------- -.. cpp:function:: double gpu::norm(const GpuMat\& src1, int normType=NORM_L2) -.. cpp:function:: double gpu::norm(const GpuMat\& src1, int normType, GpuMat\& buf) -.. cpp:function:: double norm(const GpuMat\& src1, const GpuMat\& src2, int normType=NORM_L2) +.. ocv:function:: double gpu::norm(const GpuMat\& src1, int normType=NORM_L2) +.. ocv:function:: double gpu::norm(const GpuMat\& src1, int normType, GpuMat\& buf) +.. ocv:function:: double norm(const GpuMat\& src1, const GpuMat\& src2, int normType=NORM_L2) Returns the norm of matrix (or difference of two matrices). @@ -37,15 +37,15 @@ gpu::norm :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically. -See Also: :cpp:func:`norm` +See Also: :ocv:func:`norm` .. index:: gpu::sum gpu::sum ------------ -.. cpp:function:: Scalar gpu::sum(const GpuMat\& src) +.. ocv:function:: Scalar gpu::sum(const GpuMat\& src) -.. cpp:function:: Scalar gpu::sum(const GpuMat\& src, GpuMat\& buf) +.. ocv:function:: Scalar gpu::sum(const GpuMat\& src, GpuMat\& buf) Returns the sum of matrix elements. @@ -53,15 +53,15 @@ gpu::sum :param buf: Optional buffer to avoid extra memory allocations. It is resized automatically. -See Also: :cpp:func:`sum` +See Also: :ocv:func:`sum` .. index:: gpu::absSum gpu::absSum --------------- -.. cpp:function:: Scalar gpu::absSum(const GpuMat\& src) +.. ocv:function:: Scalar gpu::absSum(const GpuMat\& src) -.. cpp:function:: Scalar gpu::absSum(const GpuMat\& src, GpuMat\& buf) +.. ocv:function:: Scalar gpu::absSum(const GpuMat\& src, GpuMat\& buf) Returns the sum of absolute values for matrix elements. @@ -73,9 +73,9 @@ gpu::absSum gpu::sqrSum --------------- -.. cpp:function:: Scalar gpu::sqrSum(const GpuMat\& src) +.. ocv:function:: Scalar gpu::sqrSum(const GpuMat\& src) -.. cpp:function:: Scalar gpu::sqrSum(const GpuMat\& src, GpuMat\& buf) +.. ocv:function:: Scalar gpu::sqrSum(const GpuMat\& src, GpuMat\& buf) Returns the squared sum of matrix elements. @@ -87,9 +87,9 @@ gpu::sqrSum gpu::minMax --------------- -.. cpp:function:: void gpu::minMax(const GpuMat\& src, double* minVal, double* maxVal=0, const GpuMat\& mask=GpuMat()) +.. ocv:function:: void gpu::minMax(const GpuMat\& src, double* minVal, double* maxVal=0, const GpuMat\& mask=GpuMat()) -.. cpp:function:: void gpu::minMax(const GpuMat\& src, double* minVal, double* maxVal, const GpuMat\& mask, GpuMat\& buf) +.. ocv:function:: void gpu::minMax(const GpuMat\& src, double* minVal, double* maxVal, const GpuMat\& mask, GpuMat\& buf) Finds global minimum and maximum matrix elements and returns their values. @@ -105,15 +105,15 @@ gpu::minMax The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3. -See Also: :cpp:func:`minMaxLoc` +See Also: :ocv:func:`minMaxLoc` .. index:: gpu::minMaxLoc gpu::minMaxLoc ------------------ -.. cpp:function:: void gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, const GpuMat& mask=GpuMat()) +.. ocv:function:: void gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal=0, Point* minLoc=0, Point* maxLoc=0, const GpuMat& mask=GpuMat()) -.. cpp:function:: void gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf) +.. ocv:function:: void gpu::minMaxLoc(const GpuMat& src, double* minVal, double* maxVal, Point* minLoc, Point* maxLoc, const GpuMat& mask, GpuMat& valbuf, GpuMat& locbuf) Finds global minimum and maximum matrix elements and returns their values with locations. @@ -135,15 +135,15 @@ gpu::minMaxLoc The function does not work with ``CV_64F`` images on GPU with the compute capability < 1.3. -See Also: :cpp:func:`minMaxLoc` +See Also: :ocv:func:`minMaxLoc` .. index:: gpu::countNonZero gpu::countNonZero --------------------- -.. cpp:function:: int gpu::countNonZero(const GpuMat\& src) +.. ocv:function:: int gpu::countNonZero(const GpuMat\& src) -.. cpp:function:: int gpu::countNonZero(const GpuMat\& src, GpuMat\& buf) +.. ocv:function:: int gpu::countNonZero(const GpuMat\& src, GpuMat\& buf) Counts non-zero matrix elements. @@ -153,4 +153,4 @@ gpu::countNonZero The function does not work with ``CV_64F`` images on GPUs with the compute capability < 1.3. - See Also: :cpp:func:`countNonZero` + See Also: :ocv:func:`countNonZero` diff --git a/modules/gpu/doc/object_detection.rst b/modules/gpu/doc/object_detection.rst index bb3c908..b738d40 100644 --- a/modules/gpu/doc/object_detection.rst +++ b/modules/gpu/doc/object_detection.rst @@ -7,7 +7,7 @@ Object Detection gpu::HOGDescriptor ------------------ -.. cpp:class:: gpu::HOGDescriptor +.. ocv:class:: gpu::HOGDescriptor This class provides a histogram of Oriented Gradients [Navneet Dalal and Bill Triggs. Histogram of oriented gradients for human detection. 2005.] descriptor and detector. :: @@ -67,7 +67,7 @@ Interfaces of all methods are kept similar to the ``CPU HOG`` descriptor and det gpu::HOGDescriptor::HOGDescriptor ------------------------------------- -.. cpp:function:: gpu::HOGDescriptor::HOGDescriptor(Size win_size=Size(64, 128), +.. ocv:function:: gpu::HOGDescriptor::HOGDescriptor(Size win_size=Size(64, 128), Size block_size=Size(16, 16), Size block_stride=Size(8, 8), Size cell_size=Size(8, 8), int nbins=9, double win_sigma=DEFAULT_WIN_SIGMA, @@ -98,7 +98,7 @@ gpu::HOGDescriptor::HOGDescriptor gpu::HOGDescriptor::getDescriptorSize ----------------------------------------- -.. cpp:function:: size_t gpu::HOGDescriptor::getDescriptorSize() const +.. ocv:function:: size_t gpu::HOGDescriptor::getDescriptorSize() const Returns the number of coefficients required for the classification. @@ -106,7 +106,7 @@ gpu::HOGDescriptor::getDescriptorSize gpu::HOGDescriptor::getBlockHistogramSize --------------------------------------------- -.. cpp:function:: size_t gpu::HOGDescriptor::getBlockHistogramSize() const +.. ocv:function:: size_t gpu::HOGDescriptor::getBlockHistogramSize() const Returns the block histogram size. @@ -114,7 +114,7 @@ gpu::HOGDescriptor::getBlockHistogramSize gpu::HOGDescriptor::setSVMDetector -------------------------------------- -.. cpp:function:: void gpu::HOGDescriptor::setSVMDetector(const vector\& detector) +.. ocv:function:: void gpu::HOGDescriptor::setSVMDetector(const vector\& detector) Sets coefficients for the linear SVM classifier. @@ -122,7 +122,7 @@ gpu::HOGDescriptor::setSVMDetector gpu::HOGDescriptor::getDefaultPeopleDetector ------------------------------------------------ -.. cpp:function:: static vector gpu::HOGDescriptor::getDefaultPeopleDetector() +.. ocv:function:: static vector gpu::HOGDescriptor::getDefaultPeopleDetector() Returns coefficients of the classifier trained for people detection (for default window size). @@ -130,7 +130,7 @@ gpu::HOGDescriptor::getDefaultPeopleDetector gpu::HOGDescriptor::getPeopleDetector48x96 ---------------------------------------------- -.. cpp:function:: static vector gpu::HOGDescriptor::getPeopleDetector48x96() +.. ocv:function:: static vector gpu::HOGDescriptor::getPeopleDetector48x96() Returns coefficients of the classifier trained for people detection (for 48x96 windows). @@ -138,7 +138,7 @@ gpu::HOGDescriptor::getPeopleDetector48x96 gpu::HOGDescriptor::getPeopleDetector64x128 ----------------------------------------------- -.. cpp:function:: static vector gpu::HOGDescriptor::getPeopleDetector64x128() +.. ocv:function:: static vector gpu::HOGDescriptor::getPeopleDetector64x128() Returns coefficients of the classifier trained for people detection (for 64x128 windows). @@ -146,7 +146,7 @@ gpu::HOGDescriptor::getPeopleDetector64x128 gpu::HOGDescriptor::detect ------------------------------ -.. cpp:function:: void gpu::HOGDescriptor::detect(const GpuMat\& img, +.. ocv:function:: void gpu::HOGDescriptor::detect(const GpuMat\& img, vector\& found_locations, double hit_threshold=0, Size win_stride=Size(), Size padding=Size()) @@ -166,18 +166,18 @@ gpu::HOGDescriptor::detect gpu::HOGDescriptor::detectMultiScale ---------------------------------------- -.. cpp:function:: void gpu::HOGDescriptor::detectMultiScale(const GpuMat\& img, +.. ocv:function:: void gpu::HOGDescriptor::detectMultiScale(const GpuMat\& img, vector\& found_locations, double hit_threshold=0, Size win_stride=Size(), Size padding=Size(), double scale0=1.05, int group_threshold=2) Performs object detection with a multi-scale window. - :param img: Source image. See :cpp:func:`gpu::HOGDescriptor::detect` for type limitations. + :param img: Source image. See :ocv:func:`gpu::HOGDescriptor::detect` for type limitations. :param found_locations: Detected objects boundaries. - :param hit_threshold: Threshold for the distance between features and SVM classifying plane. See :cpp:func:`gpu::HOGDescriptor::detect` for details. + :param hit_threshold: Threshold for the distance between features and SVM classifying plane. See :ocv:func:`gpu::HOGDescriptor::detect` for details. :param win_stride: Window stride. It must be a multiple of block stride. @@ -185,19 +185,19 @@ gpu::HOGDescriptor::detectMultiScale :param scale0: Coefficient of the detection window increase. - :param group_threshold: Coefficient to regulate the similarity threshold. When detected, some objects can be covered by many rectangles. 0 means not to perform grouping. See :cpp:func:`groupRectangles` . + :param group_threshold: Coefficient to regulate the similarity threshold. When detected, some objects can be covered by many rectangles. 0 means not to perform grouping. See :ocv:func:`groupRectangles` . .. index:: gpu::HOGDescriptor::getDescriptors gpu::HOGDescriptor::getDescriptors -------------------------------------- -.. cpp:function:: void gpu::HOGDescriptor::getDescriptors(const GpuMat\& img, +.. ocv:function:: void gpu::HOGDescriptor::getDescriptors(const GpuMat\& img, Size win_stride, GpuMat\& descriptors, int descr_format=DESCR_FORMAT_COL_BY_COL) Returns block descriptors computed for the whole image. The function is mainly used to learn the classifier. - :param img: Source image. See :cpp:func:`gpu::HOGDescriptor::detect` for type limitations. + :param img: Source image. See :ocv:func:`gpu::HOGDescriptor::detect` for type limitations. :param win_stride: Window stride. It must be a multiple of block stride. @@ -214,7 +214,7 @@ gpu::HOGDescriptor::getDescriptors gpu::CascadeClassifier_GPU -------------------------- -.. cpp:class:: gpu::CascadeClassifier_GPU +.. ocv:class:: gpu::CascadeClassifier_GPU This cascade classifier class is used for object detection. :: @@ -247,7 +247,7 @@ This cascade classifier class is used for object detection. gpu::CascadeClassifier_GPU::CascadeClassifier_GPU ----------------------------------------------------- -.. cpp:function:: gpu::CascadeClassifier_GPU(const string\& filename) +.. ocv:function:: gpu::CascadeClassifier_GPU(const string\& filename) Loads the classifier from a file. @@ -259,7 +259,7 @@ gpu::CascadeClassifier_GPU::CascadeClassifier_GPU gpu::CascadeClassifier_GPU::empty ------------------------------------- -.. cpp:function:: bool gpu::CascadeClassifier_GPU::empty() const +.. ocv:function:: bool gpu::CascadeClassifier_GPU::empty() const Checks whether the classifier is loaded or not. @@ -269,7 +269,7 @@ gpu::CascadeClassifier_GPU::empty gpu::CascadeClassifier_GPU::load ------------------------------------ -.. cpp:function:: bool gpu::CascadeClassifier_GPU::load(const string\& filename) +.. ocv:function:: bool gpu::CascadeClassifier_GPU::load(const string\& filename) Loads the classifier from a file. The previous content is destroyed. @@ -279,7 +279,7 @@ gpu::CascadeClassifier_GPU::load gpu::CascadeClassifier_GPU::release --------------------------------------- -.. cpp:function:: void gpu::CascadeClassifier_GPU::release() +.. ocv:function:: void gpu::CascadeClassifier_GPU::release() Destroys the loaded classifier. @@ -287,7 +287,7 @@ gpu::CascadeClassifier_GPU::release gpu::CascadeClassifier_GPU::detectMultiScale ------------------------------------------------ -.. cpp:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat\& image, GpuMat\& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size()) +.. ocv:function:: int gpu::CascadeClassifier_GPU::detectMultiScale(const GpuMat\& image, GpuMat\& objectsBuf, double scaleFactor=1.2, int minNeighbors=4, Size minSize=Size()) Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles. @@ -324,5 +324,5 @@ gpu::CascadeClassifier_GPU::detectMultiScale imshow("Faces", image_cpu); -See Also: :cpp:func:`CascadeClassifier::detectMultiScale` +See Also: :ocv:func:`CascadeClassifier::detectMultiScale` diff --git a/modules/gpu/doc/operations_on_matrices.rst b/modules/gpu/doc/operations_on_matrices.rst index 69dc8ba..6f91102 100644 --- a/modules/gpu/doc/operations_on_matrices.rst +++ b/modules/gpu/doc/operations_on_matrices.rst @@ -7,7 +7,7 @@ Operations on Matrices gpu::transpose ------------------ -.. cpp:function:: void gpu::transpose(const GpuMat& src, GpuMat& dst) +.. ocv:function:: void gpu::transpose(const GpuMat& src, GpuMat& dst) Transposes a matrix. @@ -16,13 +16,13 @@ gpu::transpose :param dst: Destination matrix. See Also: -:cpp:func:`transpose` +:ocv:func:`transpose` .. index:: gpu::flip gpu::flip ------------- -.. cpp:function:: void gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode) +.. ocv:function:: void gpu::flip(const GpuMat& src, GpuMat& dst, int flipCode) Flips a 2D matrix around vertical, horizontal, or both axes. @@ -40,13 +40,13 @@ gpu::flip See Also: -:cpp:func:`flip` +:ocv:func:`flip` .. index:: gpu::LUT gpu::LUT ------------ -.. cpp:function:: void gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst) +.. ocv:function:: void gpu::LUT(const GpuMat& src, const Mat& lut, GpuMat& dst) Transforms the source matrix into the destination matrix using the given look-up table: ``dst(I) = lut(src(I))`` @@ -57,19 +57,19 @@ gpu::LUT :param dst: Destination matrix with the same depth as ``lut`` and the same number of channels as ``src``. -See Also: :cpp:func:`LUT` +See Also: :ocv:func:`LUT` .. index:: gpu::merge gpu::merge -------------- -.. cpp:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst) +.. ocv:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst) -.. cpp:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, const Stream& stream) +.. ocv:function:: void gpu::merge(const GpuMat* src, size_t n, GpuMat& dst, const Stream& stream) -.. cpp:function:: void gpu::merge(const vector& src, GpuMat& dst) +.. ocv:function:: void gpu::merge(const vector& src, GpuMat& dst) -.. cpp:function:: void gpu::merge(const vector& src, GpuMat& dst, const Stream& stream) +.. ocv:function:: void gpu::merge(const vector& src, GpuMat& dst, const Stream& stream) Makes a multi-channel matrix out of several single-channel matrices. @@ -81,19 +81,19 @@ gpu::merge :param stream: Stream for the asynchronous version. -See Also: :cpp:func:`merge` +See Also: :ocv:func:`merge` .. index:: gpu::split gpu::split -------------- -.. cpp:function:: void gpu::split(const GpuMat& src, GpuMat* dst) +.. ocv:function:: void gpu::split(const GpuMat& src, GpuMat* dst) -.. cpp:function:: void gpu::split(const GpuMat& src, GpuMat* dst, const Stream& stream) +.. ocv:function:: void gpu::split(const GpuMat& src, GpuMat* dst, const Stream& stream) -.. cpp:function:: void gpu::split(const GpuMat& src, vector& dst) +.. ocv:function:: void gpu::split(const GpuMat& src, vector& dst) -.. cpp:function:: void gpu::split(const GpuMat& src, vector& dst, const Stream& stream) +.. ocv:function:: void gpu::split(const GpuMat& src, vector& dst, const Stream& stream) Copies each plane of a multi-channel matrix into an array. @@ -103,17 +103,17 @@ gpu::split :param stream: Stream for the asynchronous version. -See Also: :cpp:func:`split` +See Also: :ocv:func:`split` .. index:: gpu::magnitude gpu::magnitude ------------------ -.. cpp:function:: void gpu::magnitude(const GpuMat& xy, GpuMat& magnitude) +.. ocv:function:: void gpu::magnitude(const GpuMat& xy, GpuMat& magnitude) -.. cpp:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude) +.. ocv:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude) -.. cpp:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, const Stream& stream) +.. ocv:function:: void gpu::magnitude(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, const Stream& stream) Computes magnitudes of complex matrix elements. @@ -128,17 +128,17 @@ gpu::magnitude :param stream: Stream for the asynchronous version. See Also: -:cpp:func:`magnitude` +:ocv:func:`magnitude` .. index:: gpu::magnitudeSqr gpu::magnitudeSqr --------------------- -.. cpp:function:: void gpu::magnitudeSqr(const GpuMat& xy, GpuMat& magnitude) +.. ocv:function:: void gpu::magnitudeSqr(const GpuMat& xy, GpuMat& magnitude) -.. cpp:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude) +.. ocv:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude) -.. cpp:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, const Stream& stream) +.. ocv:function:: void gpu::magnitudeSqr(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, const Stream& stream) Computes squared magnitudes of complex matrix elements. @@ -156,9 +156,9 @@ gpu::magnitudeSqr gpu::phase -------------- -.. cpp:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees=false) +.. ocv:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees=false) -.. cpp:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees, const Stream& stream) +.. ocv:function:: void gpu::phase(const GpuMat& x, const GpuMat& y, GpuMat& angle, bool angleInDegrees, const Stream& stream) Computes polar angles of complex matrix elements. @@ -173,15 +173,15 @@ gpu::phase :param stream: Stream for the asynchronous version. See Also: -:cpp:func:`phase` +:ocv:func:`phase` .. index:: gpu::cartToPolar gpu::cartToPolar -------------------- -.. cpp:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees=false) +.. ocv:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees=false) -.. cpp:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees, const Stream& stream) +.. ocv:function:: void gpu::cartToPolar(const GpuMat& x, const GpuMat& y, GpuMat& magnitude, GpuMat& angle, bool angleInDegrees, const Stream& stream) Converts Cartesian coordinates into polar. @@ -198,15 +198,15 @@ gpu::cartToPolar :param stream: Stream for the asynchronous version. See Also: -:cpp:func:`cartToPolar` +:ocv:func:`cartToPolar` .. index:: gpu::polarToCart gpu::polarToCart -------------------- -.. cpp:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees=false) +.. ocv:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees=false) -.. cpp:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, const Stream& stream) +.. ocv:function:: void gpu::polarToCart(const GpuMat& magnitude, const GpuMat& angle, GpuMat& x, GpuMat& y, bool angleInDegrees, const Stream& stream) Converts polar coordinates into Cartesian. @@ -223,4 +223,4 @@ gpu::polarToCart :param stream: Stream for the asynchronous version. See Also: -:cpp:func:`polarToCart` +:ocv:func:`polarToCart` diff --git a/modules/gpu/doc/per_element_operations.rst b/modules/gpu/doc/per_element_operations.rst index 078b18a..f27bf0a 100644 --- a/modules/gpu/doc/per_element_operations.rst +++ b/modules/gpu/doc/per_element_operations.rst @@ -9,9 +9,9 @@ Per-element Operations. gpu::add ------------ -.. cpp:function:: void gpu::add(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) +.. ocv:function:: void gpu::add(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) -.. cpp:function:: void gpu::add(const GpuMat& src1, const Scalar& src2, GpuMat& dst) +.. ocv:function:: void gpu::add(const GpuMat& src1, const Scalar& src2, GpuMat& dst) Computes a matrix-matrix or matrix-scalar sum. @@ -21,15 +21,15 @@ gpu::add :param dst: Destination matrix with the same size and type as ``src1``. -See Also: :cpp:func:`add` +See Also: :ocv:func:`add` .. index:: gpu::subtract gpu::subtract ----------------- -.. cpp:function:: void gpu::subtract(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) +.. ocv:function:: void gpu::subtract(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) -.. cpp:function:: void gpu::subtract(const GpuMat& src1, const Scalar& src2, GpuMat& dst) +.. ocv:function:: void gpu::subtract(const GpuMat& src1, const Scalar& src2, GpuMat& dst) Computes a matrix-matrix or matrix-scalar difference. @@ -39,7 +39,7 @@ gpu::subtract :param dst: Destination matrix with the same size and type as ``src1``. -See Also: :cpp:func:`subtract` +See Also: :ocv:func:`subtract` @@ -47,9 +47,9 @@ See Also: :cpp:func:`subtract` gpu::multiply ----------------- -.. cpp:function:: void gpu::multiply(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) +.. ocv:function:: void gpu::multiply(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) -.. cpp:function:: void gpu::multiply(const GpuMat& src1, const Scalar& src2, GpuMat& dst) +.. ocv:function:: void gpu::multiply(const GpuMat& src1, const Scalar& src2, GpuMat& dst) Computes a matrix-matrix or matrix-scalar per-element product. @@ -59,16 +59,16 @@ gpu::multiply :param dst: Destination matrix with the same size and type as ``src1``. -See Also: :cpp:func:`multiply` +See Also: :ocv:func:`multiply` .. index:: gpu::divide gpu::divide --------------- -.. cpp:function:: void gpu::divide(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) +.. ocv:function:: void gpu::divide(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) -.. cpp:function:: void gpu::divide(const GpuMat& src1, const Scalar& src2, GpuMat& dst) +.. ocv:function:: void gpu::divide(const GpuMat& src1, const Scalar& src2, GpuMat& dst) Computes a matrix-matrix or matrix-scalar sum. @@ -78,9 +78,9 @@ gpu::divide :param dst: Destination matrix with the same size and type as ``src1``. - This function, in contrast to :cpp:func:`divide`, uses a round-down rounding mode. + This function, in contrast to :ocv:func:`divide`, uses a round-down rounding mode. -See Also: :cpp:func:`divide` +See Also: :ocv:func:`divide` @@ -88,7 +88,7 @@ See Also: :cpp:func:`divide` gpu::exp ------------ -.. cpp:function:: void gpu::exp(const GpuMat& src, GpuMat& dst) +.. ocv:function:: void gpu::exp(const GpuMat& src, GpuMat& dst) Computes an exponent of each matrix element. @@ -96,7 +96,7 @@ gpu::exp :param dst: Destination matrix with the same size and type as ``src``. -See Also: :cpp:func:`exp` +See Also: :ocv:func:`exp` @@ -104,7 +104,7 @@ See Also: :cpp:func:`exp` gpu::log ------------ -.. cpp:function:: void gpu::log(const GpuMat& src, GpuMat& dst) +.. ocv:function:: void gpu::log(const GpuMat& src, GpuMat& dst) Computes a natural logarithm of absolute value of each matrix element. @@ -112,7 +112,7 @@ gpu::log :param dst: Destination matrix with the same size and type as ``src``. -See Also: :cpp:func:`log` +See Also: :ocv:func:`log` @@ -120,9 +120,9 @@ See Also: :cpp:func:`log` gpu::absdiff ---------------- -.. cpp:function:: void gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) +.. ocv:function:: void gpu::absdiff(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) -.. cpp:function:: void gpu::absdiff(const GpuMat& src1, const Scalar& src2, GpuMat& dst) +.. ocv:function:: void gpu::absdiff(const GpuMat& src1, const Scalar& src2, GpuMat& dst) Computes per-element absolute difference of two matrices (or of matrix and scalar). @@ -132,13 +132,13 @@ gpu::absdiff :param dst: Destination matrix with the same size and type as ``src1``. -See Also: :cpp:func:`absdiff` +See Also: :ocv:func:`absdiff` .. index:: gpu::compare gpu::compare ---------------- -.. cpp:function:: void gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int cmpop) +.. ocv:function:: void gpu::compare(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, int cmpop) Compares elements of two matrices. @@ -157,16 +157,16 @@ gpu::compare * **CMP_LE:** ``src1(.) <= src2(.)`` * **CMP_NE:** ``src1(.) != src2(.)`` -See Also: :cpp:func:`compare` +See Also: :ocv:func:`compare` .. index:: gpu::bitwise_not gpu::bitwise_not -------------------- -.. cpp:function:: void gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask=GpuMat()) +.. ocv:function:: void gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask=GpuMat()) -.. cpp:function:: void gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask, const Stream& stream) +.. ocv:function:: void gpu::bitwise_not(const GpuMat& src, GpuMat& dst, const GpuMat& mask, const Stream& stream) Performs a per-element bitwise inversion. @@ -184,9 +184,9 @@ gpu::bitwise_not gpu::bitwise_or ------------------- -.. cpp:function:: void gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat()) +.. ocv:function:: void gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat()) -.. cpp:function:: void gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream) +.. ocv:function:: void gpu::bitwise_or(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream) Performs a per-element bitwise disjunction of two matrices. @@ -206,9 +206,9 @@ gpu::bitwise_or gpu::bitwise_and -------------------- -.. cpp:function:: void gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat()) +.. ocv:function:: void gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat()) -.. cpp:function:: void gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream) +.. ocv:function:: void gpu::bitwise_and(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream) Performs a per-element bitwise conjunction of two matrices. @@ -228,9 +228,9 @@ gpu::bitwise_and gpu::bitwise_xor -------------------- -.. cpp:function:: void gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat()) +.. ocv:function:: void gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask=GpuMat()) -.. cpp:function:: void gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream) +.. ocv:function:: void gpu::bitwise_xor(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const GpuMat& mask, const Stream& stream) Performs a per-element bitwise "exclusive or" operation of two matrices. @@ -250,13 +250,13 @@ gpu::bitwise_xor gpu::min ------------ -.. cpp:function:: void gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) +.. ocv:function:: void gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) -.. cpp:function:: void gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream) +.. ocv:function:: void gpu::min(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream) -.. cpp:function:: void gpu::min(const GpuMat& src1, double src2, GpuMat& dst) +.. ocv:function:: void gpu::min(const GpuMat& src1, double src2, GpuMat& dst) -.. cpp:function:: void gpu::min(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream) +.. ocv:function:: void gpu::min(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream) Computes the per-element minimum of two matrices (or a matrix and a scalar). @@ -268,7 +268,7 @@ gpu::min :param stream: Stream for the asynchronous version. -See Also: :cpp:func:`min` +See Also: :ocv:func:`min` @@ -276,13 +276,13 @@ See Also: :cpp:func:`min` gpu::max ------------ -.. cpp:function:: void gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) +.. ocv:function:: void gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst) -.. cpp:function:: void gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream) +.. ocv:function:: void gpu::max(const GpuMat& src1, const GpuMat& src2, GpuMat& dst, const Stream& stream) -.. cpp:function:: void gpu::max(const GpuMat& src1, double src2, GpuMat& dst) +.. ocv:function:: void gpu::max(const GpuMat& src1, double src2, GpuMat& dst) -.. cpp:function:: void gpu::max(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream) +.. ocv:function:: void gpu::max(const GpuMat& src1, double src2, GpuMat& dst, const Stream& stream) Computes the per-element maximum of two matrices (or a matrix and a scalar). @@ -294,4 +294,4 @@ gpu::max :param stream: Stream for the asynchronous version. -See Also: :cpp:func:`max` +See Also: :ocv:func:`max` diff --git a/modules/highgui/doc/qt_new_functions.rst b/modules/highgui/doc/qt_new_functions.rst index 8ba8eb6..2e6dfa6 100644 --- a/modules/highgui/doc/qt_new_functions.rst +++ b/modules/highgui/doc/qt_new_functions.rst @@ -62,7 +62,7 @@ The following code is an example used to generate the figure. :: setWindowProperty --------------------- -.. cpp:function:: void setWindowProperty(const string& name, int prop_id, double prop_value) +.. ocv:function:: void setWindowProperty(const string& name, int prop_id, double prop_value) Changes parameters of a window dynamically. @@ -96,7 +96,7 @@ The function ``setWindowProperty`` enables changing properties of a window. getWindowProperty --------------------- -.. cpp:function:: void getWindowProperty(const string& name, int prop_id) +.. ocv:function:: void getWindowProperty(const string& name, int prop_id) Provides parameters of a window. @@ -122,7 +122,7 @@ The function ``getWindowProperty`` returns properties of a window. fontQt ---------- -.. cpp:function:: CvFont fontQt(const string& nameFont, int pointSize = -1, Scalar color = Scalar::all(0), int weight = CV_FONT_NORMAL, int style = CV_STYLE_NORMAL, int spacing = 0) +.. ocv:function:: CvFont fontQt(const string& nameFont, int pointSize = -1, Scalar color = Scalar::all(0), int weight = CV_FONT_NORMAL, int style = CV_STYLE_NORMAL, int spacing = 0) Creates the font to draw a text on an image. @@ -167,7 +167,7 @@ A basic usage of this function is the following: :: addText ----------- -.. cpp:function:: void addText(const Mat& img, const string& text, Point location, CvFont *font) +.. ocv:function:: void addText(const Mat& img, const string& text, Point location, CvFont *font) Creates the font to draw a text on an image. @@ -192,7 +192,7 @@ using a specific font displayOverlay ------------------ -.. cpp:function:: void displayOverlay(const string& name, const string& text, int delay) +.. ocv:function:: void displayOverlay(const string& name, const string& text, int delay) Displays a text on a window image as an overlay for a specified duration. @@ -208,7 +208,7 @@ The function ``displayOverlay`` displays useful information/tips on top of the w displayStatusBar -------------------- -.. cpp:function:: void displayStatusBar(const string& name, const string& text, int delay) +.. ocv:function:: void displayStatusBar(const string& name, const string& text, int delay) Displays a text on the window statusbar during the specified period of time. @@ -227,7 +227,7 @@ The function ``displayOverlay`` displays useful information/tips on top of the w createOpenGLCallback ------------------------ -.. cpp:function:: void createOpenGLCallback( const string& window_name, OpenGLCallback callbackOpenGL, void* userdata CV_DEFAULT(NULL), double angle CV_DEFAULT(-1), double zmin CV_DEFAULT(-1), double zmax CV_DEFAULT(-1) +.. ocv:function:: void createOpenGLCallback( const string& window_name, OpenGLCallback callbackOpenGL, void* userdata CV_DEFAULT(NULL), double angle CV_DEFAULT(-1), double zmin CV_DEFAULT(-1), double zmax CV_DEFAULT(-1) Creates a callback function called to draw OpenGL on top the the image display by ``windowname``. @@ -279,7 +279,7 @@ The function ``createOpenGLCallback`` can be used to draw 3D data on the window. saveWindowParameters ------------------------ -.. cpp:function:: void saveWindowParameters(const string& name) +.. ocv:function:: void saveWindowParameters(const string& name) Saves parameters of the window ``windowname`` . @@ -293,7 +293,7 @@ The function ``saveWindowParameters`` saves size, location, flags, trackbars va loadWindowParameters ------------------------ -.. cpp:function:: void loadWindowParameters(const string& name) +.. ocv:function:: void loadWindowParameters(const string& name) Loads parameters of the window ``windowname`` . @@ -307,7 +307,7 @@ The function ``loadWindowParameters`` loads size, location, flags, trackbars val createButton ---------------- -.. cpp:function:: createButton( const string& button_name CV_DEFAULT(NULL),ButtonCallback on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(NULL), int button_type CV_DEFAULT(CV_PUSH_BUTTON), int initial_button_state CV_DEFAULT(0)) +.. ocv:function:: createButton( const string& button_name CV_DEFAULT(NULL),ButtonCallback on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(NULL), int button_type CV_DEFAULT(CV_PUSH_BUTTON), int initial_button_state CV_DEFAULT(0)) Attaches a button to the control panel. diff --git a/modules/highgui/doc/reading_and_writing_images_and_video.rst b/modules/highgui/doc/reading_and_writing_images_and_video.rst index 4beb482..1fe3d2e 100644 --- a/modules/highgui/doc/reading_and_writing_images_and_video.rst +++ b/modules/highgui/doc/reading_and_writing_images_and_video.rst @@ -9,7 +9,7 @@ Reading and Writing Images and Video imdecode ------------ -.. cpp:function:: Mat imdecode( InputArray buf, int flags ) +.. ocv:function:: Mat imdecode( InputArray buf, int flags ) Reads an image from a buffer in memory. @@ -29,7 +29,7 @@ See imencode ------------ -.. cpp:function:: bool imencode( const string& ext, InputArray img, vector& buf, const vector& params=vector()) +.. ocv:function:: bool imencode( const string& ext, InputArray img, vector& buf, const vector& params=vector()) Encode an image into a memory buffer. @@ -51,7 +51,7 @@ See imread ---------- -.. cpp:function:: Mat imread( const string& filename, int flags=1 ) +.. ocv:function:: Mat imread( const string& filename, int flags=1 ) Loads an image from a file. @@ -95,7 +95,7 @@ The function ``imread`` loads an image from the specified file and returns it. I imwrite ----------- -.. cpp:function:: bool imwrite( const string& filename, InputArray img, const vector& params=vector()) +.. ocv:function:: bool imwrite( const string& filename, InputArray img, const vector& params=vector()) Saves an image to a specified file. @@ -208,11 +208,11 @@ The class provides C++ video capturing API. Here is how the class can be used: : VideoCapture::VideoCapture ------------------------------ -.. cpp:function:: VideoCapture::VideoCapture() +.. ocv:function:: VideoCapture::VideoCapture() -.. cpp:function:: VideoCapture::VideoCapture(const string& filename) +.. ocv:function:: VideoCapture::VideoCapture(const string& filename) -.. cpp:function:: VideoCapture::VideoCapture(int device) +.. ocv:function:: VideoCapture::VideoCapture(int device) VideoCapture constructors. @@ -226,7 +226,7 @@ VideoCapture constructors. VideoCapture::get --------------------- -.. cpp:function:: double VideoCapture::get(int property_id) +.. ocv:function:: double VideoCapture::get(int property_id) :param property_id: Property identifier. It can be one of the following: @@ -277,7 +277,7 @@ VideoCapture::get VideoCapture::set --------------------- -.. cpp:function:: bool VideoCapture::set(int property_id, double value) +.. ocv:function:: bool VideoCapture::set(int property_id, double value) Sets a property in the VideoCapture backend. diff --git a/modules/highgui/doc/user_interface.rst b/modules/highgui/doc/user_interface.rst index bd1df5f..8d34596 100644 --- a/modules/highgui/doc/user_interface.rst +++ b/modules/highgui/doc/user_interface.rst @@ -9,7 +9,7 @@ User Interface createTrackbar ------------------ -.. cpp:function:: int createTrackbar( const string& trackbarname, const string& winname, int* value, int count, TrackbarCallback onChange=0, void* userdata=0) +.. ocv:function:: int createTrackbar( const string& trackbarname, const string& winname, int* value, int count, TrackbarCallback onChange=0, void* userdata=0) Creates a trackbar and attaches it to the specified window. @@ -45,7 +45,7 @@ Clicking the label of each trackbar enables editing the trackbar values manually getTrackbarPos ------------------ -.. cpp:function:: int getTrackbarPos( const string& trackbarname, const string& winname ) +.. ocv:function:: int getTrackbarPos( const string& trackbarname, const string& winname ) Returns the trackbar position. @@ -67,7 +67,7 @@ Qt-specific details: imshow ---------- -.. cpp:function:: void imshow( const string& winname, InputArray image ) +.. ocv:function:: void imshow( const string& winname, InputArray image ) Displays an image in the specified window. @@ -92,7 +92,7 @@ The function ``imshow`` displays an image in the specified window. If the window namedWindow --------------- -.. cpp:function:: void namedWindow( const string& winname, int flags ) +.. ocv:function:: void namedWindow( const string& winname, int flags ) Creates a window. @@ -132,7 +132,7 @@ Qt-specific details: setTrackbarPos ------------------ -.. cpp:function:: void setTrackbarPos( const string& trackbarname, const string& winname, int pos ) +.. ocv:function:: void setTrackbarPos( const string& trackbarname, const string& winname, int pos ) Sets the trackbar position. @@ -156,7 +156,7 @@ Qt-specific details: waitKey ----------- -.. cpp:function:: int waitKey(int delay=0) +.. ocv:function:: int waitKey(int delay=0) Waits for a pressed key. diff --git a/modules/imgproc/doc/feature_detection.rst b/modules/imgproc/doc/feature_detection.rst index 9784f5f..d20ba55 100644 --- a/modules/imgproc/doc/feature_detection.rst +++ b/modules/imgproc/doc/feature_detection.rst @@ -7,7 +7,7 @@ Feature Detection Canny --------- -.. cpp:function:: void Canny( InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false ) +.. ocv:function:: void Canny( InputArray image, OutputArray edges, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false ) Finds edges in an image using the Canny algorithm. @@ -19,7 +19,7 @@ Canny :param threshold2: The second threshold for the hysteresis procedure. - :param apertureSize: Aperture size for the :cpp:func:`Sobel` operator. + :param apertureSize: Aperture size for the :ocv:func:`Sobel` operator. :param L2gradient: Flag indicating whether a more accurate :math:`L_2` norm :math:`=\sqrt{(dI/dx)^2 + (dI/dy)^2}` should be used to compute the image gradient magnitude ( ``L2gradient=true`` ), or a faster default :math:`L_1` norm :math:`=|dI/dx|+|dI/dy|` is enough ( ``L2gradient=false`` ). @@ -31,7 +31,7 @@ http://en.wikipedia.org/wiki/Canny_edge_detector cornerEigenValsAndVecs ---------------------- -.. cpp:function:: void cornerEigenValsAndVecs( InputArray src, OutputArray dst, int blockSize, int apertureSize, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void cornerEigenValsAndVecs( InputArray src, OutputArray dst, int blockSize, int apertureSize, int borderType=BORDER_DEFAULT ) Calculates eigenvalues and eigenvectors of image blocks for corner detection. @@ -41,9 +41,9 @@ cornerEigenValsAndVecs :param blockSize: Neighborhood size (see details below). - :param apertureSize: Aperture parameter for the :cpp:func:`Sobel` operator. + :param apertureSize: Aperture parameter for the :ocv:func:`Sobel` operator. - :param boderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` . + :param boderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` . For every pixel :math:`p` , the function ``cornerEigenValsAndVecs`` considers a ``blockSize`` :math:`\times` ``blockSize`` neigborhood @@ -54,7 +54,7 @@ For every pixel M = \begin{bmatrix} \sum _{S(p)}(dI/dx)^2 & \sum _{S(p)}(dI/dx dI/dy)^2 \\ \sum _{S(p)}(dI/dx dI/dy)^2 & \sum _{S(p)}(dI/dy)^2 \end{bmatrix} where the derivatives are computed using the -:cpp:func:`Sobel` operator. +:ocv:func:`Sobel` operator. After that it finds eigenvectors and eigenvalues of :math:`M` and stores them in the destination image as @@ -69,16 +69,16 @@ After that it finds eigenvectors and eigenvalues of The output of the function can be used for robust edge or corner detection. See Also: -:cpp:func:`cornerMinEigenVal`, -:cpp:func:`cornerHarris`, -:cpp:func:`preCornerDetect` +:ocv:func:`cornerMinEigenVal`, +:ocv:func:`cornerHarris`, +:ocv:func:`preCornerDetect` .. index:: cornerHarris cornerHarris ------------ -.. cpp:function:: void cornerHarris( InputArray src, OutputArray dst, int blockSize, int apertureSize, double k, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void cornerHarris( InputArray src, OutputArray dst, int blockSize, int apertureSize, double k, int borderType=BORDER_DEFAULT ) Harris edge detector. @@ -86,17 +86,17 @@ cornerHarris :param dst: Image to store the Harris detector responses. It has the type ``CV_32FC1`` and the same size as ``src`` . - :param blockSize: Neighborhood size (see the details on :cpp:func:`cornerEigenValsAndVecs` ). + :param blockSize: Neighborhood size (see the details on :ocv:func:`cornerEigenValsAndVecs` ). - :param apertureSize: Aperture parameter for the :cpp:func:`Sobel` operator. + :param apertureSize: Aperture parameter for the :ocv:func:`Sobel` operator. :param k: Harris detector free parameter. See the formula below. - :param boderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` . + :param boderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` . The function runs the Harris edge detector on the image. Similarly to -:cpp:func:`cornerMinEigenVal` and -:cpp:func:`cornerEigenValsAndVecs` , for each pixel +:ocv:func:`cornerMinEigenVal` and +:ocv:func:`cornerEigenValsAndVecs` , for each pixel :math:`(x, y)` it calculates a :math:`2\times2` gradient covariation matrix :math:`M^{(x,y)}` over a @@ -113,7 +113,7 @@ Corners in the image can be found as the local maxima of this response map. cornerMinEigenVal ----------------- -.. cpp:function:: void cornerMinEigenVal( InputArray src, OutputArray dst, int blockSize, int apertureSize=3, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void cornerMinEigenVal( InputArray src, OutputArray dst, int blockSize, int apertureSize=3, int borderType=BORDER_DEFAULT ) Calculates the minimal eigenvalue of gradient matrices for corner detection. @@ -121,22 +121,22 @@ cornerMinEigenVal :param dst: Image to store the minimal eigenvalues. It has the type ``CV_32FC1`` and the same size as ``src`` . - :param blockSize: Neighborhood size (see the details on :cpp:func:`cornerEigenValsAndVecs` ). + :param blockSize: Neighborhood size (see the details on :ocv:func:`cornerEigenValsAndVecs` ). - :param apertureSize: Aperture parameter for the :cpp:func:`Sobel` operator. + :param apertureSize: Aperture parameter for the :ocv:func:`Sobel` operator. - :param boderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` . + :param boderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` . The function is similar to -:cpp:func:`cornerEigenValsAndVecs` but it calculates and stores only the minimal eigenvalue of the covariation matrix of derivatives, that is, +:ocv:func:`cornerEigenValsAndVecs` but it calculates and stores only the minimal eigenvalue of the covariation matrix of derivatives, that is, :math:`\min(\lambda_1, \lambda_2)` in terms of the formulae in the -:cpp:func:`cornerEigenValsAndVecs` description. +:ocv:func:`cornerEigenValsAndVecs` description. .. index:: cornerSubPix cornerSubPix ---------------- -.. cpp:function:: void cornerSubPix( InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria ) +.. ocv:function:: void cornerSubPix( InputArray image, InputOutputArray corners, Size winSize, Size zeroZone, TermCriteria criteria ) Refines the corner locations. @@ -193,7 +193,7 @@ The algorithm sets the center of the neighborhood window at this new center goodFeaturesToTrack ------------------- -.. cpp:function:: void goodFeaturesToTrack( InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04 ) +.. ocv:function:: void goodFeaturesToTrack( InputArray image, OutputArray corners, int maxCorners, double qualityLevel, double minDistance, InputArray mask=noArray(), int blockSize=3, bool useHarrisDetector=false, double k=0.04 ) Determines strong corners on an image. @@ -203,15 +203,15 @@ goodFeaturesToTrack :param maxCorners: Maximum number of corners to return. If there are more corners than are found, the strongest of them is returned. - :param qualityLevel: Parameter characterizing the minimal accepted quality of image corners. The parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue (see :cpp:func:`cornerMinEigenVal` ) or the Harris function response (see :cpp:func:`cornerHarris` ). The corners with the quality measure less than the product are rejected. For example, if the best corner has the quality measure = 1500, and the ``qualityLevel=0.01`` , then all the corners with the quality measure less than 15 are rejected. + :param qualityLevel: Parameter characterizing the minimal accepted quality of image corners. The parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue (see :ocv:func:`cornerMinEigenVal` ) or the Harris function response (see :ocv:func:`cornerHarris` ). The corners with the quality measure less than the product are rejected. For example, if the best corner has the quality measure = 1500, and the ``qualityLevel=0.01`` , then all the corners with the quality measure less than 15 are rejected. :param minDistance: Minimum possible Euclidean distance between the returned corners. :param mask: Optional region of interest. If the image is not empty (it needs to have the type ``CV_8UC1`` and the same size as ``image`` ), it specifies the region in which the corners are detected. - :param blockSize: Size of an average block for computing a derivative covariation matrix over each pixel neighborhood. See :cpp:func:`cornerEigenValsAndVecs` . + :param blockSize: Size of an average block for computing a derivative covariation matrix over each pixel neighborhood. See :ocv:func:`cornerEigenValsAndVecs` . - :param useHarrisDetector: Parameter indicating whether to use a Harris detector (see :cpp:func:`cornerHarris`) or :cpp:func:`cornerMinEigenVal`. + :param useHarrisDetector: Parameter indicating whether to use a Harris detector (see :ocv:func:`cornerHarris`) or :ocv:func:`cornerMinEigenVal`. :param k: Free parameter of the Harris detector. @@ -219,8 +219,8 @@ The function finds the most prominent corners in the image or in the specified i #. Function calculates the corner quality measure at every source image pixel using the - :cpp:func:`cornerMinEigenVal` or - :cpp:func:`cornerHarris` . + :ocv:func:`cornerMinEigenVal` or + :ocv:func:`cornerHarris` . #. Function performs a non-maximum suppression (the local maximums in *3 x 3* neighborhood are retained). @@ -239,19 +239,19 @@ The function can be used to initialize a point-based tracker of an object. **Note**: If the function is called with different values ``A`` and ``B`` of the parameter ``qualityLevel`` , and ``A`` > {B}, the vector of returned corners with ``qualityLevel=A`` will be the prefix of the output vector with ``qualityLevel=B`` . -See Also: :cpp:func:`cornerMinEigenVal`, -:cpp:func:`cornerHarris`, -:cpp:func:`calcOpticalFlowPyrLK`, -:cpp:func:`estimateRigidMotion`, -:cpp:func:`PlanarObjectDetector`, -:cpp:func:`OneWayDescriptor` +See Also: :ocv:func:`cornerMinEigenVal`, +:ocv:func:`cornerHarris`, +:ocv:func:`calcOpticalFlowPyrLK`, +:ocv:func:`estimateRigidMotion`, +:ocv:func:`PlanarObjectDetector`, +:ocv:func:`OneWayDescriptor` .. index:: HoughCircles HoughCircles ------------ -.. cpp:function:: void HoughCircles( InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0 ) +.. ocv:function:: void HoughCircles( InputArray image, OutputArray circles, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0 ) Finds circles in a grayscale image using the Hough transform. @@ -265,7 +265,7 @@ HoughCircles :param minDist: Minimum distance between the centers of the detected circles. If the parameter is too small, multiple neighbor circles may be falsely detected in addition to a true one. If it is too large, some circles may be missed. - :param param1: The first method-specific parameter. In case of ``CV_HOUGH_GRADIENT`` , it is the higher threshold of the two passed to the :cpp:func:`Canny` edge detector (the lower one is twice smaller). + :param param1: The first method-specific parameter. In case of ``CV_HOUGH_GRADIENT`` , it is the higher threshold of the two passed to the :ocv:func:`Canny` edge detector (the lower one is twice smaller). :param param2: The second method-specific parameter. In case of ``CV_HOUGH_GRADIENT`` , it is the accumulator threshold for the circle centers at the detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first @@ -309,15 +309,15 @@ The function finds circles in a grayscale image using a modification of the Houg **Note**: Usually the function detects the centers of circles well. However, it may fail to find correct radii. You can assist to the function by specifying the radius range ( ``minRadius`` and ``maxRadius`` ) if you know it. Or, you may ignore the returned radius, use only the center, and find the correct radius using an additional procedure. See Also: -:cpp:func:`fitEllipse`, -:cpp:func:`minEnclosingCircle` +:ocv:func:`fitEllipse`, +:ocv:func:`minEnclosingCircle` .. index:: HoughLines HoughLines ---------- -.. cpp:function:: void HoughLines( InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0 ) +.. ocv:function:: void HoughLines( InputArray image, OutputArray lines, double rho, double theta, int threshold, double srn=0, double stn=0 ) Finds lines in a binary image using the standard Hough transform. @@ -336,14 +336,14 @@ HoughLines :param stn: For the multi-scale Hough transform, it is a divisor for the distance resolution ``theta`` . The function implements the standard or standard multi-scale Hough transform algorithm for line detection. See -:cpp:func:`HoughLinesP` for the code example. +:ocv:func:`HoughLinesP` for the code example. .. index:: HoughLinesP HoughLinesP ----------- -.. cpp:function:: void HoughLinesP( InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0 ) +.. ocv:function:: void HoughLinesP( InputArray image, OutputArray lines, double rho, double theta, int threshold, double minLineLength=0, double maxLineGap=0 ) Finds line segments in a binary image using the probabilistic Hough transform. @@ -431,7 +431,7 @@ And this is the output of the above program in case of the probabilistic Hough t preCornerDetect --------------- -.. cpp:function:: void preCornerDetect( InputArray src, OutputArray dst, int apertureSize, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void preCornerDetect( InputArray src, OutputArray dst, int apertureSize, int borderType=BORDER_DEFAULT ) Calculates a feature map for corner detection. @@ -439,9 +439,9 @@ preCornerDetect :param dst: Output image that has the type ``CV_32F`` and the same size as ``src`` . - :param apertureSize: Aperture size of the :cpp:func:`Sobel` . + :param apertureSize: Aperture size of the :ocv:func:`Sobel` . - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` . + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` . The function calculates the complex spatial derivative-based function of the source image diff --git a/modules/imgproc/doc/filtering.rst b/modules/imgproc/doc/filtering.rst index 679c4e6..5b1cfe4 100644 --- a/modules/imgproc/doc/filtering.rst +++ b/modules/imgproc/doc/filtering.rst @@ -6,19 +6,19 @@ Image Filtering =============== Functions and classes described in this section are used to perform various linear or non-linear filtering operations on 2D images (represented as -:cpp:func:`Mat`'s). It means that for each pixel location +:ocv:func:`Mat`'s). It means that for each pixel location :math:`(x,y)` in the source image (normally, rectangular), its neighborhood is considered and used to compute the response. In case of a linear filter, it is a weighted sum of pixel values. In case of morphological operations, it is the minimum or maximum values, and so on. The computed response is stored in the destination image at the same location :math:`(x,y)` . It means that the output image will be of the same size as the input image. Normally, the functions support multi-channel arrays, in which case every channel is processed independently. Therefore, the output image will also have the same number of channels as the input one. Another common feature of the functions and classes described in this section is that, unlike simple arithmetic functions, they need to extrapolate values of some non-existing pixels. For example, if you want to smooth an image using a Gaussian :math:`3 \times 3` filter, then, when processing the left-most pixels in each row, you need pixels to the left of them, that is, outside of the image. You can let these pixels be the same as the left-most image pixels ("replicated border" extrapolation method), or assume that all the non-existing pixels are zeros ("contant border" extrapolation method), and so on. -OpenCV enables you to specify the extrapolation method. For details, see the function :cpp:func:`borderInterpolate` and discussion of the ``borderType`` parameter in various functions below. +OpenCV enables you to specify the extrapolation method. For details, see the function :ocv:func:`borderInterpolate` and discussion of the ``borderType`` parameter in various functions below. .. index:: BaseColumnFilter BaseColumnFilter ---------------- -.. cpp:class:: BaseColumnFilter +.. ocv:class:: BaseColumnFilter Base class for filters with single-column kernels :: @@ -53,21 +53,21 @@ The class ``BaseColumnFilter`` is a base class for filtering data using single-c where :math:`F` is a filtering function but, as it is represented as a class, it can produce any side effects, memorize previously processed data, and so on. The class only defines an interface and is not used directly. Instead, there are several functions in OpenCV (and you can add more) that return pointers to the derived classes that implement specific filtering operations. Those pointers are then passed to the -:cpp:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data. +:ocv:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data. See Also: -:cpp:func:`BaseRowFilter`, -:cpp:func:`BaseFilter`, -:cpp:func:`FilterEngine`, -:cpp:func:`getColumnSumFilter`, -:cpp:func:`getLinearColumnFilter`, -:cpp:func:`getMorphologyColumnFilter` +:ocv:func:`BaseRowFilter`, +:ocv:func:`BaseFilter`, +:ocv:func:`FilterEngine`, +:ocv:func:`getColumnSumFilter`, +:ocv:func:`getLinearColumnFilter`, +:ocv:func:`getMorphologyColumnFilter` .. index:: BaseFilter BaseFilter ---------- -.. cpp:class:: BaseFilter +.. ocv:class:: BaseFilter Base class for 2D image filters :: @@ -103,20 +103,20 @@ The class ``BaseFilter`` is a base class for filtering data using 2D kernels. Fi where :math:`F` is a filtering function. The class only defines an interface and is not used directly. Instead, there are several functions in OpenCV (and you can add more) that return pointers to the derived classes that implement specific filtering operations. Those pointers are then passed to the -:cpp:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data. +:ocv:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data. See Also: -:cpp:func:`BaseColumnFilter`, -:cpp:func:`BaseRowFilter`, -:cpp:func:`FilterEngine`, -:cpp:func:`getLinearFilter`, -:cpp:func:`getMorphologyFilter` +:ocv:func:`BaseColumnFilter`, +:ocv:func:`BaseRowFilter`, +:ocv:func:`FilterEngine`, +:ocv:func:`getLinearFilter`, +:ocv:func:`getMorphologyFilter` .. index:: BaseRowFilter BaseRowFilter ------------- -.. cpp:class:: BaseRowFilter +.. ocv:class:: BaseRowFilter Base class for filters with single-row kernels :: @@ -144,21 +144,21 @@ The class ``BaseRowFilter`` is a base class for filtering data using single-row where :math:`F` is a filtering function. The class only defines an interface and is not used directly. Instead, there are several functions in OpenCV (and you can add more) that return pointers to the derived classes that implement specific filtering operations. Those pointers are then passed to the -:cpp:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data. +:ocv:func:`FilterEngine` constructor. While the filtering operation interface uses the ``uchar`` type, a particular implementation is not limited to 8-bit data. See Also: -:cpp:func:`BaseColumnFilter`, -:cpp:func:`Filter`, -:cpp:func:`FilterEngine`, -:cpp:func:`getLinearRowFilter`, -:cpp:func:`getMorphologyRowFilter`, -:cpp:func:`getRowSumFilter` +:ocv:func:`BaseColumnFilter`, +:ocv:func:`Filter`, +:ocv:func:`FilterEngine`, +:ocv:func:`getLinearRowFilter`, +:ocv:func:`getMorphologyRowFilter`, +:ocv:func:`getRowSumFilter` .. index:: FilterEngine FilterEngine ------------ -.. cpp:class:: FilterEngine +.. ocv:class:: FilterEngine Generic image filtering class :: @@ -231,12 +231,12 @@ The class ``FilterEngine`` can be used to apply an arbitrary filtering operation It contains all the necessary intermediate buffers, computes extrapolated values of the "virtual" pixels outside of the image, and so on. Pointers to the initialized ``FilterEngine`` instances are returned by various ``create*Filter`` functions (see below) and they are used inside high-level functions such as -:cpp:func:`filter2D`, -:cpp:func:`erode`, -:cpp:func:`dilate`, and others. Thus, the class plays a key role in many of OpenCV filtering functions. +:ocv:func:`filter2D`, +:ocv:func:`erode`, +:ocv:func:`dilate`, and others. Thus, the class plays a key role in many of OpenCV filtering functions. This class makes it easier to combine filtering operations with other operations, such as color space conversions, thresholding, arithmetic operations, and others. By combining several operations together you can get much better performance because your data will stay in cache. For example, see below the implementation of the Laplace operator for floating-point images, which is a simplified implementation of -:cpp:func:`Laplacian` : :: +:ocv:func:`Laplacian` : :: void laplace_f(const Mat& src, Mat& dst) { @@ -347,7 +347,7 @@ Unlike the earlier versions of OpenCV, now the filtering operations fully suppor Explore the data types. As it was mentioned in the -:cpp:func:`BaseFilter` description, the specific filters can process data of any type, despite that ``Base*Filter::operator()`` only takes ``uchar`` pointers and no information about the actual types. To make it all work, the following rules are used: +:ocv:func:`BaseFilter` description, the specific filters can process data of any type, despite that ``Base*Filter::operator()`` only takes ``uchar`` pointers and no information about the actual types. To make it all work, the following rules are used: * In case of separable filtering, ``FilterEngine::rowFilter`` is applied first. It transforms the input image data (of type ``srcType`` ) to the intermediate results stored in the internal buffers (of type ``bufType`` ). Then, these intermediate results are processed as @@ -358,21 +358,21 @@ Explore the data types. As it was mentioned in the In case of non-separable filtering, ``bufType`` must be the same as ``srcType`` . The source data is copied to the temporary buffer, if needed, and then just passed to ``FilterEngine::filter2D`` . That is, the input type for ``filter2D`` is ``srcType`` (= ``bufType`` ) and the output type is ``dstType`` . See Also: -:cpp:func:`BaseColumnFilter`, -:cpp:func:`BaseFilter`, -:cpp:func:`BaseRowFilter`, -:cpp:func:`createBoxFilter`, -:cpp:func:`createDerivFilter`, -:cpp:func:`createGaussianFilter`, -:cpp:func:`createLinearFilter`, -:cpp:func:`createMorphologyFilter`, -:cpp:func:`createSeparableLinearFilter` +:ocv:func:`BaseColumnFilter`, +:ocv:func:`BaseFilter`, +:ocv:func:`BaseRowFilter`, +:ocv:func:`createBoxFilter`, +:ocv:func:`createDerivFilter`, +:ocv:func:`createGaussianFilter`, +:ocv:func:`createLinearFilter`, +:ocv:func:`createMorphologyFilter`, +:ocv:func:`createSeparableLinearFilter` .. index:: bilateralFilter bilateralFilter ------------------- -.. cpp:function:: void bilateralFilter( InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void bilateralFilter( InputArray src, OutputArray dst, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT ) Applies the bilateral filter to an image. @@ -393,7 +393,7 @@ http://www.dai.ed.ac.uk/CVonline/LOCAL\_COPIES/MANDUCHI1/Bilateral\_Filtering.ht blur -------- -.. cpp:function:: void blur( InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT ) +.. ocv:function:: void blur( InputArray src, OutputArray dst, Size ksize, Point anchor=Point(-1,-1), int borderType=BORDER_DEFAULT ) Smoothes an image using the normalized box filter. @@ -416,16 +416,16 @@ The function smoothes an image using the kernel: The call ``blur(src, dst, ksize, anchor, borderType)`` is equivalent to ``boxFilter(src, dst, src.type(), anchor, true, borderType)`` . See Also: -:cpp:func:`boxFilter`, -:cpp:func:`bilateralFilter`, -:cpp:func:`GaussianBlur`, -:cpp:func:`medianBlur` +:ocv:func:`boxFilter`, +:ocv:func:`bilateralFilter`, +:ocv:func:`GaussianBlur`, +:ocv:func:`medianBlur` .. index:: borderInterpolate borderInterpolate --------------------- -.. cpp:function:: int borderInterpolate( int p, int len, int borderType ) +.. ocv:function:: int borderInterpolate( int p, int len, int borderType ) Computes the source location of an extrapolated pixel. @@ -442,18 +442,18 @@ The function computes and returns the coordinate of the donor pixel, correspondi Normally, the function is not called directly. It is used inside -:cpp:func:`FilterEngine` and -:cpp:func:`copyMakeBorder` to compute tables for quick extrapolation. +:ocv:func:`FilterEngine` and +:ocv:func:`copyMakeBorder` to compute tables for quick extrapolation. See Also: -:cpp:func:`FilterEngine`, -:cpp:func:`copyMakeBorder` +:ocv:func:`FilterEngine`, +:ocv:func:`copyMakeBorder` .. index:: boxFilter boxFilter ------------- -.. cpp:function:: void boxFilter( InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void boxFilter( InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT ) Smoothes an image using the box filter. @@ -483,24 +483,24 @@ where Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms, and so on). If you need to compute pixel sums over variable-size windows, use -:cpp:func:`integral` . +:ocv:func:`integral` . See Also: -:cpp:func:`boxFilter`, -:cpp:func:`bilateralFilter`, -:cpp:func:`GaussianBlur`, -:cpp:func:`medianBlur`, -:cpp:func:`integral` +:ocv:func:`boxFilter`, +:ocv:func:`bilateralFilter`, +:ocv:func:`GaussianBlur`, +:ocv:func:`medianBlur`, +:ocv:func:`integral` .. index:: buildPyramid buildPyramid ---------------- -.. cpp:function:: void buildPyramid( InputArray src, OutputArrayOfArrays dst, int maxlevel ) +.. ocv:function:: void buildPyramid( InputArray src, OutputArrayOfArrays dst, int maxlevel ) Constructs the Gaussian pyramid for an image. - :param src: Source image. Check :cpp:func:`pyrDown` for the list of supported types. + :param src: Source image. Check :ocv:func:`pyrDown` for the list of supported types. :param dst: Destination vector of ``maxlevel+1`` images of the same type as ``src`` . ``dst[0]`` will be the same as ``src`` . ``dst[1]`` is the next pyramid layer, a smoothed and down-sized ``src`` , and so on. @@ -508,13 +508,13 @@ buildPyramid :param maxlevel: 0-based index of the last (the smallest) pyramid layer. It must be non-negative. The function constructs a vector of images and builds the Gaussian pyramid by recursively applying -:cpp:func:`pyrDown` to the previously built pyramid layers, starting from ``dst[0]==src`` . +:ocv:func:`pyrDown` to the previously built pyramid layers, starting from ``dst[0]==src`` . .. index:: copyMakeBorder copyMakeBorder ------------------ -.. cpp:function:: void copyMakeBorder( InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar& value=Scalar() ) +.. ocv:function:: void copyMakeBorder( InputArray src, OutputArray dst, int top, int bottom, int left, int right, int borderType, const Scalar& value=Scalar() ) Forms a border around an image. @@ -524,12 +524,12 @@ copyMakeBorder :param top, bottom, left, right: Parameter specifying how many pixels in each direction from the source image rectangle to extrapolate. For example, ``top=1, bottom=1, left=1, right=1`` mean that 1 pixel-wide border needs to be built. - :param borderType: Border type. See :cpp:func:`borderInterpolate` for details. + :param borderType: Border type. See :ocv:func:`borderInterpolate` for details. :param value: Border value if ``borderType==BORDER_CONSTANT`` . The function copies the source image into the middle of the destination image. The areas to the left, to the right, above and below the copied source image will be filled with extrapolated pixels. This is not what -:cpp:func:`FilterEngine` or filtering functions based on it do (they extrapolate pixels on-fly), but what other more complex functions, including your own, may do to simplify image boundary handling. +:ocv:func:`FilterEngine` or filtering functions based on it do (they extrapolate pixels on-fly), but what other more complex functions, including your own, may do to simplify image boundary handling. The function supports the mode when ``src`` is already in the middle of ``dst`` . In this case, the function does not copy ``src`` itself but simply constructs the border, for example: :: @@ -549,16 +549,16 @@ The function supports the mode when ``src`` is already in the middle of ``dst`` See Also: -:cpp:func:`borderInterpolate` +:ocv:func:`borderInterpolate` .. index:: createBoxFilter createBoxFilter ------------------- -.. cpp:function:: Ptr createBoxFilter( int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) +.. ocv:function:: Ptr createBoxFilter( int srcType, int dstType, Size ksize, Point anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT) -.. cpp:function:: Ptr getRowSumFilter(int srcType, int sumType, int ksize, int anchor=-1) +.. ocv:function:: Ptr getRowSumFilter(int srcType, int sumType, int ksize, int anchor=-1) -.. cpp:function:: Ptr getColumnSumFilter(int sumType, int dstType, int ksize, int anchor=-1, double scale=1) +.. ocv:function:: Ptr getColumnSumFilter(int sumType, int dstType, int ksize, int anchor=-1, double scale=1) Returns a box filter engine. @@ -572,31 +572,31 @@ createBoxFilter :param anchor: Anchor position with the kernel. Negative values mean that the anchor is at the kernel center. - :param normalize: Flag specifying whether the sums are normalized or not. See :cpp:func:`boxFilter` for details. + :param normalize: Flag specifying whether the sums are normalized or not. See :ocv:func:`boxFilter` for details. :param scale: Another way to specify normalization in lower-level ``getColumnSumFilter`` . - :param borderType: Border type to use. See :cpp:func:`borderInterpolate` . + :param borderType: Border type to use. See :ocv:func:`borderInterpolate` . The function is a convenience function that retrieves the horizontal sum primitive filter with -:cpp:func:`getRowSumFilter` , vertical sum filter with -:cpp:func:`getColumnSumFilter` , constructs new -:cpp:func:`FilterEngine` , and passes both of the primitive filters there. The constructed filter engine can be used for image filtering with normalized or unnormalized box filter. +:ocv:func:`getRowSumFilter` , vertical sum filter with +:ocv:func:`getColumnSumFilter` , constructs new +:ocv:func:`FilterEngine` , and passes both of the primitive filters there. The constructed filter engine can be used for image filtering with normalized or unnormalized box filter. The function itself is used by -:cpp:func:`blur` and -:cpp:func:`boxFilter` . +:ocv:func:`blur` and +:ocv:func:`boxFilter` . See Also: -:cpp:func:`FilterEngine`, -:cpp:func:`blur`, -:cpp:func:`boxFilter` +:ocv:func:`FilterEngine`, +:ocv:func:`blur`, +:ocv:func:`boxFilter` .. index:: createDerivFilter createDerivFilter --------------------- -.. cpp:function:: Ptr createDerivFilter( int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT ) +.. ocv:function:: Ptr createDerivFilter( int srcType, int dstType, int dx, int dy, int ksize, int borderType=BORDER_DEFAULT ) Returns an engine for computing image derivatives. @@ -608,57 +608,57 @@ createDerivFilter :param dy: Derivative order in respect of y. - :param ksize: Aperture size See :cpp:func:`getDerivKernels` . + :param ksize: Aperture size See :ocv:func:`getDerivKernels` . - :param borderType: Border type to use. See :cpp:func:`borderInterpolate` . + :param borderType: Border type to use. See :ocv:func:`borderInterpolate` . -The function :cpp:func:`createDerivFilter` is a small convenience function that retrieves linear filter coefficients for computing image derivatives using -:cpp:func:`getDerivKernels` and then creates a separable linear filter with -:cpp:func:`createSeparableLinearFilter` . The function is used by -:cpp:func:`Sobel` and -:cpp:func:`Scharr` . +The function :ocv:func:`createDerivFilter` is a small convenience function that retrieves linear filter coefficients for computing image derivatives using +:ocv:func:`getDerivKernels` and then creates a separable linear filter with +:ocv:func:`createSeparableLinearFilter` . The function is used by +:ocv:func:`Sobel` and +:ocv:func:`Scharr` . See Also: -:cpp:func:`createSeparableLinearFilter`, -:cpp:func:`getDerivKernels`, -:cpp:func:`Scharr`, -:cpp:func:`Sobel` +:ocv:func:`createSeparableLinearFilter`, +:ocv:func:`getDerivKernels`, +:ocv:func:`Scharr`, +:ocv:func:`Sobel` .. index:: createGaussianFilter createGaussianFilter ------------------------ -.. cpp:function:: Ptr createGaussianFilter( int type, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT) +.. ocv:function:: Ptr createGaussianFilter( int type, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT) Returns an engine for smoothing images with the Gaussian filter. :param type: Source and destination image type. - :param ksize: Aperture size. See :cpp:func:`getGaussianKernel` . + :param ksize: Aperture size. See :ocv:func:`getGaussianKernel` . - :param sigmaX: Gaussian sigma in the horizontal direction. See :cpp:func:`getGaussianKernel` . + :param sigmaX: Gaussian sigma in the horizontal direction. See :ocv:func:`getGaussianKernel` . :param sigmaY: Gaussian sigma in the vertical direction. If 0, then :math:`\texttt{sigmaY}\leftarrow\texttt{sigmaX}` . - :param borderType: Border type to use. See :cpp:func:`borderInterpolate` . + :param borderType: Border type to use. See :ocv:func:`borderInterpolate` . -The function :cpp:func:`createGaussianFilter` computes Gaussian kernel coefficients and then returns a separable linear filter for that kernel. The function is used by -:cpp:func:`GaussianBlur` . Note that while the function takes just one data type, both for input and output, you can pass this limitation by calling -:cpp:func:`getGaussianKernel` and then -:cpp:func:`createSeparableFilter` directly. +The function :ocv:func:`createGaussianFilter` computes Gaussian kernel coefficients and then returns a separable linear filter for that kernel. The function is used by +:ocv:func:`GaussianBlur` . Note that while the function takes just one data type, both for input and output, you can pass this limitation by calling +:ocv:func:`getGaussianKernel` and then +:ocv:func:`createSeparableFilter` directly. See Also: -:cpp:func:`createSeparableLinearFilter`, -:cpp:func:`getGaussianKernel`, -:cpp:func:`GaussianBlur` +:ocv:func:`createSeparableLinearFilter`, +:ocv:func:`getGaussianKernel`, +:ocv:func:`GaussianBlur` .. index:: createLinearFilter createLinearFilter ---------------------- -.. cpp:function:: Ptr createLinearFilter(int srcType, int dstType, InputArray kernel, Point _anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar& borderValue=Scalar()) +.. ocv:function:: Ptr createLinearFilter(int srcType, int dstType, InputArray kernel, Point _anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar& borderValue=Scalar()) -.. cpp:function:: Ptr getLinearFilter(int srcType, int dstType, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0) +.. ocv:function:: Ptr getLinearFilter(int srcType, int dstType, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int bits=0) Creates a non-separable linear filter engine. @@ -674,30 +674,30 @@ createLinearFilter :param bits: Number of the fractional bits. the parameter is used when the kernel is an integer matrix representing fixed-point filter coefficients. - :param rowBorderType, columnBorderType: Pixel extrapolation methods in the horizontal and vertical directions. See :cpp:func:`borderInterpolate` for details. + :param rowBorderType, columnBorderType: Pixel extrapolation methods in the horizontal and vertical directions. See :ocv:func:`borderInterpolate` for details. :param borderValue: Border vaule used in case of a constant border. The function returns a pointer to a 2D linear filter for the specified kernel, the source array type, and the destination array type. The function is a higher-level function that calls ``getLinearFilter`` and passes the retrieved 2D filter to the -:cpp:func:`FilterEngine` constructor. +:ocv:func:`FilterEngine` constructor. See Also: -:cpp:func:`createSeparableLinearFilter`, -:cpp:func:`FilterEngine`, -:cpp:func:`filter2D` +:ocv:func:`createSeparableLinearFilter`, +:ocv:func:`FilterEngine`, +:ocv:func:`filter2D` .. index:: createMorphologyFilter createMorphologyFilter -------------------------- -.. cpp:function:: Ptr createMorphologyFilter(int op, int type, InputArray element, Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, int columnBorderType=-1, const Scalar& borderValue=morphologyDefaultBorderValue()) +.. ocv:function:: Ptr createMorphologyFilter(int op, int type, InputArray element, Point anchor=Point(-1,-1), int rowBorderType=BORDER_CONSTANT, int columnBorderType=-1, const Scalar& borderValue=morphologyDefaultBorderValue()) -.. cpp:function:: Ptr getMorphologyFilter(int op, int type, InputArray element, Point anchor=Point(-1,-1)) +.. ocv:function:: Ptr getMorphologyFilter(int op, int type, InputArray element, Point anchor=Point(-1,-1)) -.. cpp:function:: Ptr getMorphologyRowFilter(int op, int type, int esize, int anchor=-1) +.. ocv:function:: Ptr getMorphologyRowFilter(int op, int type, int esize, int anchor=-1) -.. cpp:function:: Ptr getMorphologyColumnFilter(int op, int type, int esize, int anchor=-1) +.. ocv:function:: Ptr getMorphologyColumnFilter(int op, int type, int esize, int anchor=-1) -.. cpp:function:: Scalar morphologyDefaultBorderValue() +.. ocv:function:: Scalar morphologyDefaultBorderValue() Creates an engine for non-separable morphological operations. @@ -711,32 +711,32 @@ createMorphologyFilter :param anchor: Anchor position within the structuring element. Negative values mean that the anchor is at the kernel center. - :param rowBorderType, columnBorderType: Pixel extrapolation methods in the horizontal and vertical directions. See :cpp:func:`borderInterpolate` for details. + :param rowBorderType, columnBorderType: Pixel extrapolation methods in the horizontal and vertical directions. See :ocv:func:`borderInterpolate` for details. :param borderValue: Border value in case of a constant border. The default value, \ ``morphologyDefaultBorderValue`` , has a special meaning. It is transformed :math:`+\inf` for the erosion and to :math:`-\inf` for the dilation, which means that the minimum (maximum) is effectively computed only over the pixels that are inside the image. The functions construct primitive morphological filtering operations or a filter engine based on them. Normally it is enough to use -:cpp:func:`createMorphologyFilter` or even higher-level -:cpp:func:`erode`, -:cpp:func:`dilate` , or -:cpp:func:`morphologyEx` . +:ocv:func:`createMorphologyFilter` or even higher-level +:ocv:func:`erode`, +:ocv:func:`dilate` , or +:ocv:func:`morphologyEx` . Note that -:cpp:func:`createMorphologyFilter` analyzes the structuring element shape and builds a separable morphological filter engine when the structuring element is square. +:ocv:func:`createMorphologyFilter` analyzes the structuring element shape and builds a separable morphological filter engine when the structuring element is square. See Also: -:cpp:func:`erode`, -:cpp:func:`dilate`, -:cpp:func:`morphologyEx`, -:cpp:func:`FilterEngine` +:ocv:func:`erode`, +:ocv:func:`dilate`, +:ocv:func:`morphologyEx`, +:ocv:func:`FilterEngine` .. index:: createSeparableLinearFilter createSeparableLinearFilter ------------------------------- -.. cpp:function:: Ptr createSeparableLinearFilter(int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar& borderValue=Scalar()) +.. ocv:function:: Ptr createSeparableLinearFilter(int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, const Scalar& borderValue=Scalar()) -.. cpp:function:: Ptr getLinearColumnFilter(int bufType, int dstType, InputArray columnKernel, int anchor, int symmetryType, double delta=0, int bits=0) +.. ocv:function:: Ptr getLinearColumnFilter(int bufType, int dstType, InputArray columnKernel, int anchor, int symmetryType, double delta=0, int bits=0) -.. cpp:function:: Ptr getLinearRowFilter(int srcType, int bufType, InputArray rowKernel, int anchor, int symmetryType) +.. ocv:function:: Ptr getLinearRowFilter(int srcType, int bufType, InputArray rowKernel, int anchor, int symmetryType) Creates an engine for a separable linear filter. @@ -756,28 +756,28 @@ createSeparableLinearFilter :param bits: Number of the fractional bits. The parameter is used when the kernel is an integer matrix representing fixed-point filter coefficients. - :param rowBorderType, columnBorderType: Pixel extrapolation methods in the horizontal and vertical directions. See :cpp:func:`borderInterpolate` for details. + :param rowBorderType, columnBorderType: Pixel extrapolation methods in the horizontal and vertical directions. See :ocv:func:`borderInterpolate` for details. :param borderValue: Border value used in case of a constant border. - :param symmetryType: Type of each row and column kernel. See :cpp:func:`getKernelType` . + :param symmetryType: Type of each row and column kernel. See :ocv:func:`getKernelType` . The functions construct primitive separable linear filtering operations or a filter engine based on them. Normally it is enough to use -:cpp:func:`createSeparableLinearFilter` or even higher-level -:cpp:func:`sepFilter2D` . The function -:cpp:func:`createMorphologyFilter` is smart enough to figure out the ``symmetryType`` for each of the two kernels, the intermediate ``bufType`` and, if filtering can be done in integer arithmetics, the number of ``bits`` to encode the filter coefficients. If it does not work for you, it is possible to call ``getLinearColumnFilter``,``getLinearRowFilter`` directly and then pass them to the -:cpp:func:`FilterEngine` constructor. +:ocv:func:`createSeparableLinearFilter` or even higher-level +:ocv:func:`sepFilter2D` . The function +:ocv:func:`createMorphologyFilter` is smart enough to figure out the ``symmetryType`` for each of the two kernels, the intermediate ``bufType`` and, if filtering can be done in integer arithmetics, the number of ``bits`` to encode the filter coefficients. If it does not work for you, it is possible to call ``getLinearColumnFilter``,``getLinearRowFilter`` directly and then pass them to the +:ocv:func:`FilterEngine` constructor. See Also: -:cpp:func:`sepFilter2D`, -:cpp:func:`createLinearFilter`, -:cpp:func:`FilterEngine`, -:cpp:func:`getKernelType` +:ocv:func:`sepFilter2D`, +:ocv:func:`createLinearFilter`, +:ocv:func:`FilterEngine`, +:ocv:func:`getKernelType` .. index:: dilate dilate ---------- -.. cpp:function:: void dilate( InputArray src, OutputArray dst, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() ) +.. ocv:function:: void dilate( InputArray src, OutputArray dst, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() ) Dilates an image by using a specific structuring element. @@ -791,9 +791,9 @@ dilate :param iterations: Number of times dilation is applied. - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. - :param borderValue: Border value in case of a constant border. The default value has a special meaning. See :cpp:func:`createMorphologyFilter` for details. + :param borderValue: Border value in case of a constant border. The default value has a special meaning. See :ocv:func:`createMorphologyFilter` for details. The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken: @@ -804,14 +804,14 @@ The function dilates the source image using the specified structuring element th The function supports the in-place mode. Dilation can be applied several ( ``iterations`` ) times. In case of multi-channel images, each channel is processed independently. See Also: -:cpp:func:`erode`, -:cpp:func:`morphologyEx`, -:cpp:func:`createMorphologyFilter` +:ocv:func:`erode`, +:ocv:func:`morphologyEx`, +:ocv:func:`createMorphologyFilter` .. index:: erode erode --------- -.. cpp:function:: void erode( InputArray src, OutputArray dst, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() ) +.. ocv:function:: void erode( InputArray src, OutputArray dst, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() ) Erodes an image by using a specific structuring element. @@ -825,9 +825,9 @@ erode :param iterations: Number of times erosion is applied. - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. - :param borderValue: Border value in case of a constant border. The default value has a special meaning. See :cpp:func:`createMorphoogyFilter` for details. + :param borderValue: Border value in case of a constant border. The default value has a special meaning. See :ocv:func:`createMorphoogyFilter` for details. The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken: @@ -838,15 +838,15 @@ The function erodes the source image using the specified structuring element tha The function supports the in-place mode. Erosion can be applied several ( ``iterations`` ) times. In case of multi-channel images, each channel is processed independently. See Also: -:cpp:func:`dilate`, -:cpp:func:`morphologyEx`, -:cpp:func:`createMorphologyFilter` +:ocv:func:`dilate`, +:ocv:func:`morphologyEx`, +:ocv:func:`createMorphologyFilter` .. index:: filter2D filter2D ------------ -.. cpp:function:: void filter2D( InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void filter2D( InputArray src, OutputArray dst, int ddepth, InputArray kernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT ) Convolves an image with the kernel. @@ -856,13 +856,13 @@ filter2D :param ddepth: Desired depth of the destination image. If it is negative, it will be the same as ``src.depth()`` . - :param kernel: Convolution kernel (or rather a correlation kernel), a single-channel floating point matrix. If you want to apply different kernels to different channels, split the image into separate color planes using :cpp:func:`split` and process them individually. + :param kernel: Convolution kernel (or rather a correlation kernel), a single-channel floating point matrix. If you want to apply different kernels to different channels, split the image into separate color planes using :ocv:func:`split` and process them individually. :param anchor: Anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor should lie within the kernel. The special default value (-1,-1) means that the anchor is at the kernel center. :param delta: Optional value added to the filtered pixels before storing them in ``dst`` . - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. The function applies an arbitrary linear filter to an image. In-place operation is supported. When the aperture is partially outside the image, the function interpolates outlier pixel values according to the specified border mode. @@ -873,21 +873,21 @@ The function does actually compute correlation, not the convolution: \texttt{dst} (x,y) = \sum _{ \stackrel{0\leq x' < \texttt{kernel.cols},}{0\leq y' < \texttt{kernel.rows}} } \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} ) That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip the kernel using -:cpp:func:`flip` and set the new anchor to ``(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)`` . +:ocv:func:`flip` and set the new anchor to ``(kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1)`` . -The function uses the DFT-based algorithm in case of sufficiently large kernels (~``11 x 11`` or larger) and the direct algorithm (that uses the engine retrieved by :cpp:func:`createLinearFilter` ) for small kernels. +The function uses the DFT-based algorithm in case of sufficiently large kernels (~``11 x 11`` or larger) and the direct algorithm (that uses the engine retrieved by :ocv:func:`createLinearFilter` ) for small kernels. See Also: -:cpp:func:`sepFilter2D`, -:cpp:func:`createLinearFilter`, -:cpp:func:`dft`, -:cpp:func:`matchTemplate` +:ocv:func:`sepFilter2D`, +:ocv:func:`createLinearFilter`, +:ocv:func:`dft`, +:ocv:func:`matchTemplate` .. index:: GaussianBlur GaussianBlur ---------------- -.. cpp:function:: void GaussianBlur( InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void GaussianBlur( InputArray src, OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT ) Smoothes an image using a Gaussian filter. @@ -897,24 +897,24 @@ GaussianBlur :param ksize: Gaussian kernel size. ``ksize.width`` and ``ksize.height`` can differ but they both must be positive and odd. Or, they can be zero's and then they are computed from ``sigma*`` . - :param sigmaX, sigmaY: Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height`` , respectively. See :cpp:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modifications of all this semantics, it is recommended to specify all of ``ksize`` , ``sigmaX`` , and ``sigmaY`` . + :param sigmaX, sigmaY: Gaussian kernel standard deviations in X and Y direction. If ``sigmaY`` is zero, it is set to be equal to ``sigmaX`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height`` , respectively. See :ocv:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modifications of all this semantics, it is recommended to specify all of ``ksize`` , ``sigmaX`` , and ``sigmaY`` . - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. The function convolves the source image with the specified Gaussian kernel. In-place filtering is supported. See Also: -:cpp:func:`sepFilter2D`, -:cpp:func:`filter2D`, -:cpp:func:`blur`, -:cpp:func:`boxFilter`, -:cpp:func:`bilateralFilter`, -:cpp:func:`medianBlur` +:ocv:func:`sepFilter2D`, +:ocv:func:`filter2D`, +:ocv:func:`blur`, +:ocv:func:`boxFilter`, +:ocv:func:`bilateralFilter`, +:ocv:func:`medianBlur` .. index:: getDerivKernels getDerivKernels ------------------- -.. cpp:function:: void getDerivKernels( OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F ) +.. ocv:function:: void getDerivKernels( OutputArray kx, OutputArray ky, int dx, int dy, int ksize, bool normalize=false, int ktype=CV_32F ) Returns filter coefficients for computing spatial image derivatives. @@ -934,16 +934,16 @@ getDerivKernels The function computes and returns the filter coefficients for spatial image derivatives. When ``ksize=CV_SCHARR`` , the Scharr :math:`3 \times 3` kernels are generated (see -:cpp:func:`Scharr` ). Otherwise, Sobel kernels are generated (see -:cpp:func:`Sobel` ). The filters are normally passed to -:cpp:func:`sepFilter2D` or to -:cpp:func:`createSeparableLinearFilter` . +:ocv:func:`Scharr` ). Otherwise, Sobel kernels are generated (see +:ocv:func:`Sobel` ). The filters are normally passed to +:ocv:func:`sepFilter2D` or to +:ocv:func:`createSeparableLinearFilter` . .. index:: getGaussianKernel getGaussianKernel --------------------- -.. cpp:function:: Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F ) +.. ocv:function:: Mat getGaussianKernel( int ksize, double sigma, int ktype=CV_64F ) Returns Gaussian filter coefficients. @@ -965,22 +965,22 @@ where :math:`\sum_i G_i=1`. Two of such generated kernels can be passed to -:cpp:func:`sepFilter2D` or to -:cpp:func:`createSeparableLinearFilter`. Those functions automatically recognize smoothing kernels (i.e. symmetrical kernel with sum of weights = 1) and handle them accordingly. You may also use the higher-level -:cpp:func:`GaussianBlur`. +:ocv:func:`sepFilter2D` or to +:ocv:func:`createSeparableLinearFilter`. Those functions automatically recognize smoothing kernels (i.e. symmetrical kernel with sum of weights = 1) and handle them accordingly. You may also use the higher-level +:ocv:func:`GaussianBlur`. See Also: -:cpp:func:`sepFilter2D`, -:cpp:func:`createSeparableLinearFilter`, -:cpp:func:`getDerivKernels`, -:cpp:func:`getStructuringElement`, -:cpp:func:`GaussianBlur` +:ocv:func:`sepFilter2D`, +:ocv:func:`createSeparableLinearFilter`, +:ocv:func:`getDerivKernels`, +:ocv:func:`getStructuringElement`, +:ocv:func:`GaussianBlur` .. index:: getKernelType getKernelType ----------------- -.. cpp:function:: int getKernelType(InputArray kernel, Point anchor) +.. ocv:function:: int getKernelType(InputArray kernel, Point anchor) Returns the kernel type. @@ -1003,7 +1003,7 @@ The function analyzes the kernel coefficients and returns the corresponding kern getStructuringElement ------------------------- -.. cpp:function:: Mat getStructuringElement(int shape, Size esize, Point anchor=Point(-1,-1)) +.. ocv:function:: Mat getStructuringElement(int shape, Size esize, Point anchor=Point(-1,-1)) Returns a structuring element of the specified size and shape for morphological operations. @@ -1028,16 +1028,16 @@ getStructuringElement :param anchor: Anchor position within the element. The default value :math:`(-1, -1)` means that the anchor is at the center. Note that only the shape of a cross-shaped element depends on the anchor position. In other cases the anchor just regulates how much the result of the morphological operation is shifted. The function constructs and returns the structuring element that can be then passed to -:cpp:func:`createMorphologyFilter`, -:cpp:func:`erode`, -:cpp:func:`dilate` or -:cpp:func:`morphologyEx` . But you can also construct an arbitrary binary mask yourself and use it as the structuring element. +:ocv:func:`createMorphologyFilter`, +:ocv:func:`erode`, +:ocv:func:`dilate` or +:ocv:func:`morphologyEx` . But you can also construct an arbitrary binary mask yourself and use it as the structuring element. .. index:: medianBlur medianBlur -------------- -.. cpp:function:: void medianBlur( InputArray src, OutputArray dst, int ksize ) +.. ocv:function:: void medianBlur( InputArray src, OutputArray dst, int ksize ) Smoothes an image using the median filter. @@ -1051,16 +1051,16 @@ The function smoothes an image using the median filter with the :math:`\texttt{ksize} \times \texttt{ksize}` aperture. Each channel of a multi-channel image is processed independently. In-place operation is supported. See Also: -:cpp:func:`bilateralFilter`, -:cpp:func:`blur`, -:cpp:func:`boxFilter`, -:cpp:func:`GaussianBlur` +:ocv:func:`bilateralFilter`, +:ocv:func:`blur`, +:ocv:func:`boxFilter`, +:ocv:func:`GaussianBlur` .. index:: morphologyEx morphologyEx ---------------- -.. cpp:function:: void morphologyEx( InputArray src, OutputArray dst, int op, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() ) +.. ocv:function:: void morphologyEx( InputArray src, OutputArray dst, int op, InputArray element, Point anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar& borderValue=morphologyDefaultBorderValue() ) Performs advanced morphological transformations. @@ -1084,9 +1084,9 @@ morphologyEx :param iterations: Number of times erosion and dilation are applied. - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. - :param borderValue: Border value in case of a constant border. The default value has a special meaning. See :cpp:func:`createMorphoogyFilter` for details. + :param borderValue: Border value in case of a constant border. The default value has a special meaning. See :ocv:func:`createMorphoogyFilter` for details. The function can perform advanced morphological transformations using an erosion and dilation as basic operations. @@ -1123,15 +1123,15 @@ Morphological gradient: Any of the operations can be done in-place. See Also: -:cpp:func:`dilate`, -:cpp:func:`erode`, -:cpp:func:`createMorphologyFilter` +:ocv:func:`dilate`, +:ocv:func:`erode`, +:ocv:func:`createMorphologyFilter` .. index:: Laplacian Laplacian ------------- -.. cpp:function:: void Laplacian( InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void Laplacian( InputArray src, OutputArray dst, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) Calculates the Laplacian of an image. @@ -1141,13 +1141,13 @@ Laplacian :param ddepth: Desired depth of the destination image. - :param ksize: Aperture size used to compute the second-derivative filters. See :cpp:func:`getDerivKernels` for details. The size must be positive and odd. + :param ksize: Aperture size used to compute the second-derivative filters. See :ocv:func:`getDerivKernels` for details. The size must be positive and odd. - :param scale: Optional scale factor for the computed Laplacian values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details. + :param scale: Optional scale factor for the computed Laplacian values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details. :param delta: Optional delta value that is added to the results prior to storing them in ``dst`` . - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. The function calculates the Laplacian of the source image by adding up the second x and y derivatives calculated using the Sobel operator: @@ -1163,14 +1163,14 @@ This is done when ``ksize > 1`` . When ``ksize == 1`` , the Laplacian is compute \vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0} See Also: -:cpp:func:`Sobel`, -:cpp:func:`Scharr` +:ocv:func:`Sobel`, +:ocv:func:`Scharr` .. index:: pyrDown pyrDown ----------- -.. cpp:function:: void pyrDown( InputArray src, OutputArray dst, const Size& dstsize=Size()) +.. ocv:function:: void pyrDown( InputArray src, OutputArray dst, const Size& dstsize=Size()) Smoothes an image and downsamples it. @@ -1197,7 +1197,7 @@ Then, it downsamples the image by rejecting even rows and columns. pyrUp --------- -.. cpp:function:: void pyrUp( InputArray src, OutputArray dst, const Size& dstsize=Size()) +.. ocv:function:: void pyrUp( InputArray src, OutputArray dst, const Size& dstsize=Size()) Upsamples an image and then smoothes it. @@ -1213,13 +1213,13 @@ pyrUp | \texttt{dstsize.width} -src.cols*2| \leq ( \texttt{dstsize.width} \mod 2) \\ | \texttt{dstsize.height} -src.rows*2| \leq ( \texttt{dstsize.height} \mod 2) \end{array} The function performs the upsampling step of the Gaussian pyramid construction though it can actually be used to construct the Laplacian pyramid. First, it upsamples the source image by injecting even zero rows and columns and then convolves the result with the same kernel as in -:cpp:func:`pyrDown` multiplied by 4. +:ocv:func:`pyrDown` multiplied by 4. .. index:: sepFilter2D sepFilter2D --------------- -.. cpp:function:: void sepFilter2D( InputArray src, OutputArray dst, int ddepth, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void sepFilter2D( InputArray src, OutputArray dst, int ddepth, InputArray rowKernel, InputArray columnKernel, Point anchor=Point(-1,-1), double delta=0, int borderType=BORDER_DEFAULT ) Applies a separable linear filter to an image. @@ -1237,23 +1237,23 @@ sepFilter2D :param delta: Value added to the filtered results before storing them. - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. The function applies a separable linear filter to the image. That is, first, every row of ``src`` is filtered with the 1D kernel ``rowKernel`` . Then, every column of the result is filtered with the 1D kernel ``columnKernel`` . The final result shifted by ``delta`` is stored in ``dst`` . See Also: -:cpp:func:`createSeparableLinearFilter`, -:cpp:func:`filter2D`, -:cpp:func:`Sobel`, -:cpp:func:`GaussianBlur`, -:cpp:func:`boxFilter`, -:cpp:func:`blur` +:ocv:func:`createSeparableLinearFilter`, +:ocv:func:`filter2D`, +:ocv:func:`Sobel`, +:ocv:func:`GaussianBlur`, +:ocv:func:`boxFilter`, +:ocv:func:`blur` .. index:: Sobel Sobel --------- -.. cpp:function:: void Sobel( InputArray src, OutputArray dst, int ddepth, int xorder, int yorder, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void Sobel( InputArray src, OutputArray dst, int ddepth, int xorder, int yorder, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. @@ -1269,11 +1269,11 @@ Sobel :param ksize: Size of the extended Sobel kernel. It must be 1, 3, 5, or 7. - :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details. + :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details. :param delta: Optional delta value that is added to the results prior to storing them in ``dst`` . - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. In all cases except one, the :math:`\texttt{ksize} \times @@ -1316,17 +1316,17 @@ The second case corresponds to a kernel of: \vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1} See Also: -:cpp:func:`Scharr`, -:cpp:func:`Lapacian`, -:cpp:func:`sepFilter2D`, -:cpp:func:`filter2D`, -:cpp:func:`GaussianBlur` +:ocv:func:`Scharr`, +:ocv:func:`Lapacian`, +:ocv:func:`sepFilter2D`, +:ocv:func:`filter2D`, +:ocv:func:`GaussianBlur` .. index:: Scharr Scharr ---------- -.. cpp:function:: void Scharr( InputArray src, OutputArray dst, int ddepth, int xorder, int yorder, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) +.. ocv:function:: void Scharr( InputArray src, OutputArray dst, int ddepth, int xorder, int yorder, double scale=1, double delta=0, int borderType=BORDER_DEFAULT ) Calculates the first x- or y- image derivative using Scharr operator. @@ -1340,11 +1340,11 @@ Scharr :param yorder: Order of the derivative y. - :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :cpp:func:`getDerivKernels` for details. + :param scale: Optional scale factor for the computed derivative values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details. :param delta: Optional delta value that is added to the results prior to storing them in ``dst`` . - :param borderType: Pixel extrapolation method. See :cpp:func:`borderInterpolate` for details. + :param borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details. The function computes the first x- or y- spatial image derivative using the Scharr operator. The call diff --git a/modules/imgproc/doc/geometric_transformations.rst b/modules/imgproc/doc/geometric_transformations.rst index 8528c7b..1c7bec8 100644 --- a/modules/imgproc/doc/geometric_transformations.rst +++ b/modules/imgproc/doc/geometric_transformations.rst @@ -39,7 +39,7 @@ The actual implementations of the geometrical transformations, from the most gen convertMaps ----------- -.. cpp:function:: void convertMaps( InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false ) +.. ocv:function:: void convertMaps( InputArray map1, InputArray map2, OutputArray dstmap1, OutputArray dstmap2, int dstmap1type, bool nninterpolation=false ) Converts image transformation maps from one representation to another. @@ -56,11 +56,11 @@ convertMaps :param nninterpolation: Flag indicating whether the fixed-point maps are used for the nearest-neighbor or for a more complex interpolation. The function converts a pair of maps for -:cpp:func:`remap` from one representation to another. The following options ( ``(map1.type(), map2.type())`` :math:`\rightarrow` ``(dstmap1.type(), dstmap2.type())`` ) are supported: +:ocv:func:`remap` from one representation to another. The following options ( ``(map1.type(), map2.type())`` :math:`\rightarrow` ``(dstmap1.type(), dstmap2.type())`` ) are supported: * :math:`\texttt{(CV\_32FC1, CV\_32FC1)} \rightarrow \texttt{(CV\_16SC2, CV\_16UC1)}` . This is the most frequently used conversion operation, in which the original floating-point maps (see - :cpp:func:`remap` ) are converted to a more compact and much faster fixed-point representation. The first output array contains the rounded coordinates and the second array (created only when ``nninterpolation=false`` ) contains indices in the interpolation tables. + :ocv:func:`remap` ) are converted to a more compact and much faster fixed-point representation. The first output array contains the rounded coordinates and the second array (created only when ``nninterpolation=false`` ) contains indices in the interpolation tables. * :math:`\texttt{(CV\_32FC2)} \rightarrow \texttt{(CV\_16SC2, CV\_16UC1)}` . The same as above but the original maps are stored in one 2-channel matrix. @@ -69,15 +69,15 @@ The function converts a pair of maps for Reverse conversion. Obviously, the reconstructed floating-point maps will not be exactly the same as the originals. See Also: -:cpp:func:`remap`, -:cpp:func:`undisort`, -:cpp:func:`initUndistortRectifyMap` +:ocv:func:`remap`, +:ocv:func:`undisort`, +:ocv:func:`initUndistortRectifyMap` .. index:: getAffineTransform getAffineTransform ---------------------- -.. cpp:function:: Mat getAffineTransform( const Point2f src[], const Point2f dst[] ) +.. ocv:function:: Mat getAffineTransform( const Point2f src[], const Point2f dst[] ) Calculates an affine transform from three pairs of the corresponding points. @@ -100,8 +100,8 @@ where i=0,1,2 See Also: -:cpp:func:`warpAffine`, -:cpp:func:`transform` +:ocv:func:`warpAffine`, +:ocv:func:`transform` .. index:: getPerspectiveTransform @@ -110,7 +110,7 @@ See Also: getPerspectiveTransform --------------------------- -.. cpp:function:: Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] ) +.. ocv:function:: Mat getPerspectiveTransform( const Point2f src[], const Point2f dst[] ) Calculates a perspective transform from four pairs of the corresponding points. @@ -133,9 +133,9 @@ where i=0,1,2 See Also: -:cpp:func:`findHomography`, -:cpp:func:`warpPerspective`, -:cpp:func:`perspectiveTransform` +:ocv:func:`findHomography`, +:ocv:func:`warpPerspective`, +:ocv:func:`perspectiveTransform` .. index:: getRectSubPix @@ -143,7 +143,7 @@ See Also: getRectSubPix ----------------- -.. cpp:function:: void getRectSubPix( InputArray image, Size patchSize, Point2f center, OutputArray dst, int patchType=-1 ) +.. ocv:function:: void getRectSubPix( InputArray image, Size patchSize, Point2f center, OutputArray dst, int patchType=-1 ) Retrieves a pixel rectangle from an image with sub-pixel accuracy. @@ -168,12 +168,12 @@ using bilinear interpolation. Every channel of multi-channel images is processed independently. While the center of the rectangle must be inside the image, parts of the rectangle may be outside. In this case, the replication border mode (see -:cpp:func:`borderInterpolate` ) is used to extrapolate +:ocv:func:`borderInterpolate` ) is used to extrapolate the pixel values outside of the image. See Also: -:cpp:func:`warpAffine`, -:cpp:func:`warpPerspective` +:ocv:func:`warpAffine`, +:ocv:func:`warpPerspective` .. index:: getRotationMatrix2D @@ -181,7 +181,7 @@ See Also: getRotationMatrix2D ----------------------- -.. cpp:function:: Mat getRotationMatrix2D( Point2f center, double angle, double scale ) +.. ocv:function:: Mat getRotationMatrix2D( Point2f center, double angle, double scale ) Calculates an affine matrix of 2D rotation. @@ -206,9 +206,9 @@ where The transformation maps the rotation center to itself. If this is not the target, adjust the shift. See Also: -:cpp:func:`getAffineTransform`, -:cpp:func:`warpAffine`, -:cpp:func:`transform` +:ocv:func:`getAffineTransform`, +:ocv:func:`warpAffine`, +:ocv:func:`transform` .. index:: invertAffineTransform @@ -216,7 +216,7 @@ See Also: invertAffineTransform ------------------------- -.. cpp:function:: void invertAffineTransform(InputArray M, OutputArray iM) +.. ocv:function:: void invertAffineTransform(InputArray M, OutputArray iM) Inverts an affine transformation. @@ -241,20 +241,20 @@ The result is also a remap ----- -.. cpp:function:: void remap( InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar()) +.. ocv:function:: void remap( InputArray src, OutputArray dst, InputArray map1, InputArray map2, int interpolation, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar()) Applies a generic geometrical transformation to an image. :param src: Source image. :param dst: Destination image. It has the same size as ``map1`` and the same type as ``src`` . - :param map1: The first map of either ``(x,y)`` points or just ``x`` values having the type ``CV_16SC2`` , ``CV_32FC1`` , or ``CV_32FC2`` . See :cpp:func:`convertMaps` for details on converting a floating point representation to fixed-point for speed. + :param map1: The first map of either ``(x,y)`` points or just ``x`` values having the type ``CV_16SC2`` , ``CV_32FC1`` , or ``CV_32FC2`` . See :ocv:func:`convertMaps` for details on converting a floating point representation to fixed-point for speed. :param map2: The second map of ``y`` values having the type ``CV_16UC1`` , ``CV_32FC1`` , or none (empty map if ``map1`` is ``(x,y)`` points), respectively. - :param interpolation: Interpolation method (see :cpp:func:`resize` ). The method ``INTER_AREA`` is not supported by this function. + :param interpolation: Interpolation method (see :ocv:func:`resize` ). The method ``INTER_AREA`` is not supported by this function. - :param borderMode: Pixel extrapolation method (see :cpp:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function. + :param borderMode: Pixel extrapolation method (see :ocv:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function. :param borderValue: Value used in case of a constant border. By default, it is 0. @@ -272,7 +272,7 @@ where values of pixels with non-integer coordinates are computed using one of av :math:`(x,y)` in :math:`map_1` , or fixed-point maps created by using -:cpp:func:`convertMaps` . The reason you might want to convert from floating to fixed-point +:ocv:func:`convertMaps` . The reason you might want to convert from floating to fixed-point representations of a map is that they can yield much faster (~2x) remapping operations. In the converted case, :math:`map_1` contains pairs ``(cvFloor(x), cvFloor(y))`` and :math:`map_2` contains indices in a table of interpolation coefficients. @@ -286,7 +286,7 @@ This function cannot operate in-place. resize ---------- -.. cpp:function:: void resize( InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR ) +.. ocv:function:: void resize( InputArray src, OutputArray dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR ) Resizes an image. @@ -341,9 +341,9 @@ If you want to decimate the image by factor of 2 in each direction, you can call See Also: -:cpp:func:`warpAffine`, -:cpp:func:`warpPerspective`, -:cpp:func:`remap` +:ocv:func:`warpAffine`, +:ocv:func:`warpPerspective`, +:ocv:func:`remap` .. index:: warpAffine @@ -351,7 +351,7 @@ See Also: warpAffine -------------- -.. cpp:function:: void warpAffine( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar()) +.. ocv:function:: void warpAffine( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar()) Applies an affine transformation to an image. @@ -363,9 +363,9 @@ warpAffine :param dsize: Size of the destination image. - :param flags: Combination of interpolation methods (see :cpp:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` that means that ``M`` is the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ). + :param flags: Combination of interpolation methods (see :ocv:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` that means that ``M`` is the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ). - :param borderMode: Pixel extrapolation method (see :cpp:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image corresponding to the "outliers" in the source image are not modified by the function. + :param borderMode: Pixel extrapolation method (see :ocv:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image corresponding to the "outliers" in the source image are not modified by the function. :param borderValue: Value used in case of a constant border. By default, it is 0. @@ -376,21 +376,21 @@ The function ``warpAffine`` transforms the source image using the specified matr \texttt{dst} (x,y) = \texttt{src} ( \texttt{M} _{11} x + \texttt{M} _{12} y + \texttt{M} _{13}, \texttt{M} _{21} x + \texttt{M} _{22} y + \texttt{M} _{23}) when the flag ``WARP_INVERSE_MAP`` is set. Otherwise, the transformation is first inverted with -:cpp:func:`invertAffineTransform` and then put in the formula above instead of ``M`` . +:ocv:func:`invertAffineTransform` and then put in the formula above instead of ``M`` . The function cannot operate in-place. See Also: -:cpp:func:`warpPerspective`, -:cpp:func:`resize`, -:cpp:func:`remap`, -:cpp:func:`getRectSubPix`, -:cpp:func:`transform` +:ocv:func:`warpPerspective`, +:ocv:func:`resize`, +:ocv:func:`remap`, +:ocv:func:`getRectSubPix`, +:ocv:func:`transform` .. index:: warpPerspective warpPerspective ------------------- -.. cpp:function:: void warpPerspective( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar()) +.. ocv:function:: void warpPerspective( InputArray src, OutputArray dst, InputArray M, Size dsize, int flags=INTER_LINEAR, int borderMode=BORDER_CONSTANT, const Scalar& borderValue=Scalar()) Applies a perspective transformation to an image. @@ -402,9 +402,9 @@ warpPerspective :param dsize: Size of the destination image. - :param flags: Combination of interpolation methods (see :cpp:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` that means that ``M`` is the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ). + :param flags: Combination of interpolation methods (see :ocv:func:`resize` ) and the optional flag ``WARP_INVERSE_MAP`` that means that ``M`` is the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ). - :param borderMode: Pixel extrapolation method (see :cpp:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function. + :param borderMode: Pixel extrapolation method (see :ocv:func:`borderInterpolate` ). When \ ``borderMode=BORDER_TRANSPARENT`` , it means that the pixels in the destination image that corresponds to the "outliers" in the source image are not modified by the function. :param borderValue: Value used in case of a constant border. By default, it is 0. @@ -416,15 +416,15 @@ The function ``warpPerspective`` transforms the source image using the specified \frac{M_{21} x + M_{22} y + M_{23}}{M_{31} x + M_{32} y + M_{33}} \right ) when the flag ``WARP_INVERSE_MAP`` is set. Otherwise, the transformation is first inverted with -:cpp:func:`invert` and then put in the formula above instead of ``M`` . +:ocv:func:`invert` and then put in the formula above instead of ``M`` . The function cannot operate in-place. See Also: -:cpp:func:`warpAffine`, -:cpp:func:`resize`, -:cpp:func:`remap`, -:cpp:func:`getRectSubPix`, -:cpp:func:`perspectiveTransform` +:ocv:func:`warpAffine`, +:ocv:func:`resize`, +:ocv:func:`remap`, +:ocv:func:`getRectSubPix`, +:ocv:func:`perspectiveTransform` .. index:: initUndistortRectifyMap @@ -432,7 +432,7 @@ See Also: initUndistortRectifyMap --------------------------- -.. cpp:function:: void initUndistortRectifyMap( InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2 ) +.. ocv:function:: void initUndistortRectifyMap( InputArray cameraMatrix, InputArray distCoeffs, InputArray R, InputArray newCameraMatrix, Size size, int m1type, OutputArray map1, OutputArray map2 ) Computes the undistortion and rectification transformation map. @@ -486,7 +486,7 @@ where ``cameraMatrix`` can be chosen arbitrarily. getDefaultNewCameraMatrix ----------------------------- -.. cpp:function:: Mat getDefaultNewCameraMatrix(InputArray cameraMatrix, Size imgSize=Size(), bool centerPrincipalPoint=false ) +.. ocv:function:: Mat getDefaultNewCameraMatrix(InputArray cameraMatrix, Size imgSize=Size(), bool centerPrincipalPoint=false ) Returns the default new camera matrix. @@ -519,7 +519,7 @@ By default, the undistortion functions in OpenCV (see undistort ------------- -.. cpp:function:: void undistort( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray() ) +.. ocv:function:: void undistort( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray newCameraMatrix=noArray() ) Transforms an image to compensate for lens distortion. @@ -554,7 +554,7 @@ The camera matrix and the distortion parameters can be determined using undistortPoints ------------------- -.. cpp:function:: void undistortPoints( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray()) +.. ocv:function:: void undistortPoints( InputArray src, OutputArray dst, InputArray cameraMatrix, InputArray distCoeffs, InputArray R=noArray(), InputArray P=noArray()) Computes the ideal point coordinates from the observed point coordinates. diff --git a/modules/imgproc/doc/histograms.rst b/modules/imgproc/doc/histograms.rst index cba0cfa..b6e7585 100644 --- a/modules/imgproc/doc/histograms.rst +++ b/modules/imgproc/doc/histograms.rst @@ -7,9 +7,9 @@ Histograms calcHist ------------ -.. cpp:function:: void calcHist( const Mat* arrays, int narrays, const int* channels, InputArray mask, OutputArray hist, int dims, const int* histSize, const float** ranges, bool uniform=true, bool accumulate=false ) +.. ocv:function:: void calcHist( const Mat* arrays, int narrays, const int* channels, InputArray mask, OutputArray hist, int dims, const int* histSize, const float** ranges, bool uniform=true, bool accumulate=false ) -.. cpp:function:: void calcHist( const Mat* arrays, int narrays, const int* channels, InputArray mask, SparseMat& hist, int dims, const int* histSize, const float** ranges, bool uniform=true, bool accumulate=false ) +.. ocv:function:: void calcHist( const Mat* arrays, int narrays, const int* channels, InputArray mask, SparseMat& hist, int dims, const int* histSize, const float** ranges, bool uniform=true, bool accumulate=false ) Calculates a histogram of a set of arrays. @@ -99,9 +99,9 @@ input arrays at the same location. The sample below shows how to compute a 2D Hu calcBackProject ------------------- -.. cpp:function:: void calcBackProject( const Mat* arrays, int narrays, const int* channels, InputArray hist, OutputArray backProject, const float** ranges, double scale=1, bool uniform=true ) +.. ocv:function:: void calcBackProject( const Mat* arrays, int narrays, const int* channels, InputArray hist, OutputArray backProject, const float** ranges, double scale=1, bool uniform=true ) -.. cpp:function:: void calcBackProject( const Mat* arrays, int narrays, const int* channels, const SparseMat& hist, OutputArray backProject, const float** ranges, double scale=1, bool uniform=true ) +.. ocv:function:: void calcBackProject( const Mat* arrays, int narrays, const int* channels, const SparseMat& hist, OutputArray backProject, const float** ranges, double scale=1, bool uniform=true ) Calculates the back projection of a histogram. @@ -115,7 +115,7 @@ calcBackProject :param backProject: Destination back projection aray that is a single-channel array of the same size and depth as ``arrays[0]`` . - :param ranges: Array of arrays of the histogram bin boundaries in each dimension. See :cpp:func:`calcHist` . + :param ranges: Array of arrays of the histogram bin boundaries in each dimension. See :ocv:func:`calcHist` . :param scale: Optional scale factor for the output back projection. @@ -133,19 +133,19 @@ The functions ``calcBackProject`` calculate the back project of the histogram. T Find connected components in the resulting picture and choose, for example, the largest component. This is an approximate algorithm of the -:cpp:func:`CAMShift` color object tracker. +:ocv:func:`CAMShift` color object tracker. See Also: -:cpp:func:`calcHist` +:ocv:func:`calcHist` .. index:: compareHist compareHist ----------- -.. cpp:function:: double compareHist( InputArray H1, InputArray H2, int method ) +.. ocv:function:: double compareHist( InputArray H1, InputArray H2, int method ) -.. cpp:function:: double compareHist( const SparseMat& H1, const SparseMat& H2, int method ) +.. ocv:function:: double compareHist( const SparseMat& H1, const SparseMat& H2, int method ) Compares two histograms. @@ -201,14 +201,14 @@ The function returns :math:`d(H_1, H_2)` . While the function works well with 1-, 2-, 3-dimensional dense histograms, it may not be suitable for high-dimensional sparse histograms. In such histograms, because of aliasing and sampling problems, the coordinates of non-zero histogram bins can slightly shift. To compare such histograms or more general sparse configurations of weighted points, consider using the -:cpp:func:`EMD` function. +:ocv:func:`EMD` function. .. index:: EMD EMD ------ -.. cpp:function:: float EMD( InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float* lowerBound=0, OutputArray flow=noArray() ) +.. ocv:function:: float EMD( InputArray signature1, InputArray signature2, int distType, InputArray cost=noArray(), float* lowerBound=0, OutputArray flow=noArray() ) Computes the "minimal work" distance between two weighted point configurations. @@ -232,7 +232,7 @@ The function computes the earth mover distance and/or a lower boundary of the di equalizeHist ---------------- -.. cpp:function:: void equalizeHist( InputArray src, OutputArray dst ) +.. ocv:function:: void equalizeHist( InputArray src, OutputArray dst ) Equalizes the histogram of a grayscale image. diff --git a/modules/imgproc/doc/miscellaneous_transformations.rst b/modules/imgproc/doc/miscellaneous_transformations.rst index 8e534d2..24741e4 100644 --- a/modules/imgproc/doc/miscellaneous_transformations.rst +++ b/modules/imgproc/doc/miscellaneous_transformations.rst @@ -9,7 +9,7 @@ Miscellaneous Image Transformations adaptiveThreshold --------------------- -.. cpp:function:: void adaptiveThreshold( InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C ) +.. ocv:function:: void adaptiveThreshold( InputArray src, OutputArray dst, double maxValue, int adaptiveMethod, int thresholdType, int blockSize, double C ) Applies an adaptive threshold to an array. @@ -54,14 +54,14 @@ where :math:`T(x, y)` is a weighted sum (cross-correlation with a Gaussian window) of the :math:`\texttt{blockSize} \times \texttt{blockSize}` neighborhood of :math:`(x, y)` minus ``C`` . The default sigma (standard deviation) is used for the specified ``blockSize`` . See - :cpp:func:`getGaussianKernel` . + :ocv:func:`getGaussianKernel` . The function can process the image in-place. See Also: -:cpp:func:`threshold`, -:cpp:func:`blur`, -:cpp:func:`GaussianBlur` +:ocv:func:`threshold`, +:ocv:func:`blur`, +:ocv:func:`GaussianBlur` .. index:: cvtColor @@ -70,7 +70,7 @@ See Also: cvtColor ------------ -.. cpp:function:: void cvtColor( InputArray src, OutputArray dst, int code, int dstCn=0 ) +.. ocv:function:: void cvtColor( InputArray src, OutputArray dst, int code, int dstCn=0 ) Converts an image from one color space to another. @@ -127,7 +127,7 @@ The function can do the following transformations: .. More advanced channel reordering can also be done with - :cpp:func:`mixChannels` . + :ocv:func:`mixChannels` . * RGB @@ -402,9 +402,9 @@ The function can do the following transformations: distanceTransform --------------------- -.. cpp:function:: void distanceTransform( InputArray src, OutputArray dst, int distanceType, int maskSize ) +.. ocv:function:: void distanceTransform( InputArray src, OutputArray dst, int distanceType, int maskSize ) -.. cpp:function:: void distanceTransform( InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize ) +.. ocv:function:: void distanceTransform( InputArray src, OutputArray dst, OutputArray labels, int distanceType, int maskSize ) Calculates the distance to the closest zero pixel for each pixel of the source image. @@ -470,9 +470,9 @@ Currently, the second variant can use only the approximate distance transform al floodFill ------------- -.. cpp:function:: int floodFill( InputOutputArray image, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 ) +.. ocv:function:: int floodFill( InputOutputArray image, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 ) -.. cpp:function:: int floodFill( InputOutputArray image, InputOutputArray mask, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 ) +.. ocv:function:: int floodFill( InputOutputArray image, InputOutputArray mask, Point seed, Scalar newVal, Rect* rect=0, Scalar loDiff=Scalar(), Scalar upDiff=Scalar(), int flags=4 ) Fills a connected component with the given color. @@ -564,7 +564,7 @@ where Use these functions to either mark a connected component with the specified color in-place, or build a mask and then extract the contour, or copy the region to another image, and so on. Various modes of the function are demonstrated in the ``floodfill.cpp`` sample. See Also: -:cpp:func:`findContours` +:ocv:func:`findContours` .. index:: inpaint @@ -572,7 +572,7 @@ See Also: inpaint ----------- -.. cpp:function:: void inpaint( InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, int flags ) +.. ocv:function:: void inpaint( InputArray src, InputArray inpaintMask, OutputArray dst, double inpaintRadius, int flags ) Restores the selected region in an image using the region neighborhood. @@ -598,11 +598,11 @@ for more details. integral ------------ -.. cpp:function:: void integral( InputArray image, OutputArray sum, int sdepth=-1 ) +.. ocv:function:: void integral( InputArray image, OutputArray sum, int sdepth=-1 ) -.. cpp:function:: void integral( InputArray image, OutputArray sum, OutputArray sqsum, int sdepth=-1 ) +.. ocv:function:: void integral( InputArray image, OutputArray sum, OutputArray sqsum, int sdepth=-1 ) -.. cpp:function:: void integral( InputArray image, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth=-1 ) +.. ocv:function:: void integral( InputArray image, OutputArray sum, OutputArray sqsum, OutputArray tilted, int sdepth=-1 ) Calculates the integral of an image. @@ -648,7 +648,7 @@ As a practical example, the next figure shows the calculation of the integral of threshold ------------- -.. cpp:function:: double threshold( InputArray src, OutputArray dst, double thresh, double maxVal, int thresholdType ) +.. ocv:function:: double threshold( InputArray src, OutputArray dst, double thresh, double maxVal, int thresholdType ) Applies a fixed-level threshold to each array element. @@ -665,7 +665,7 @@ threshold The function applies fixed-level thresholding to a single-channel array. The function is typically used to get a bi-level (binary) image out of a grayscale image ( -:cpp:func:`compare` could +:ocv:func:`compare` could be also used for this purpose) or for removing a noise, that is, filtering out pixels with too small or too large values. There are several types of thresholding supported by the function. They are determined by ``thresholdType`` : @@ -709,17 +709,17 @@ Currently, Otsu's method is implemented only for 8-bit images. .. image:: pics/threshold.png See Also: -:cpp:func:`adaptiveThreshold`, -:cpp:func:`findContours`, -:cpp:func:`compare`, -:cpp:func:`min`, -:cpp:func:`max` +:ocv:func:`adaptiveThreshold`, +:ocv:func:`findContours`, +:ocv:func:`compare`, +:ocv:func:`min`, +:ocv:func:`max` .. index:: watershed watershed ------------- -.. cpp:function:: void watershed( InputArray image, InputOutputArray markers ) +.. ocv:function:: void watershed( InputArray image, InputOutputArray markers ) Performs a marker-based image segmentation using the watershed algrorithm. @@ -735,8 +735,8 @@ function, you have to roughly outline the desired regions in the image ``markers represented as one or more connected components with the pixel values 1, 2, 3, and so on. Such markers can be retrieved from a binary mask using -:cpp:func:`findContours` and -:cpp:func:`drawContours` (see the ``watershed.cpp`` demo). +:ocv:func:`findContours` and +:ocv:func:`drawContours` (see the ``watershed.cpp`` demo). The markers are "seeds" of the future image regions. All the other pixels in ``markers`` , whose relation to the outlined regions is not known and should be defined by the algorithm, @@ -751,14 +751,14 @@ marker image. Visual demonstration and usage example of the function can be found in the OpenCV samples directory (see the ``watershed.cpp`` demo). See Also: -:cpp:func:`findContours` +:ocv:func:`findContours` .. index:: grabCut grabCut ------- -.. cpp:function:: void grabCut(InputArray image, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode ) +.. ocv:function:: void grabCut(InputArray image, InputOutputArray mask, Rect rect, InputOutputArray bgdModel, InputOutputArray fgdModel, int iterCount, int mode ) Runs the GrabCut algorithm. diff --git a/modules/imgproc/doc/motion_analysis_and_object_tracking.rst b/modules/imgproc/doc/motion_analysis_and_object_tracking.rst index e590033..43b72eb 100644 --- a/modules/imgproc/doc/motion_analysis_and_object_tracking.rst +++ b/modules/imgproc/doc/motion_analysis_and_object_tracking.rst @@ -7,7 +7,7 @@ Motion Analysis and Object Tracking accumulate -------------- -.. cpp:function:: void accumulate( InputArray src, InputOutputArray dst, InputArray mask=noArray() ) +.. ocv:function:: void accumulate( InputArray src, InputOutputArray dst, InputArray mask=noArray() ) Adds an image to the accumulator. @@ -28,15 +28,15 @@ The function supports multi-channel images. Each channel is processed independen The functions ``accumulate*`` can be used, for example, to collect statistics of a scene background viewed by a still camera and for the further foreground-background segmentation. See Also: -:cpp:func:`accumulateSquare`, -:cpp:func:`accumulateProduct`, -:cpp:func:`accumulateWeighted` +:ocv:func:`accumulateSquare`, +:ocv:func:`accumulateProduct`, +:ocv:func:`accumulateWeighted` .. index:: accumulateSquare accumulateSquare -------------------- -.. cpp:function:: void accumulateSquare( InputArray src, InputOutputArray dst, InputArray mask=noArray() ) +.. ocv:function:: void accumulateSquare( InputArray src, InputOutputArray dst, InputArray mask=noArray() ) Adds the square of a source image to the accumulator. @@ -55,15 +55,15 @@ The function adds the input image ``src`` or its selected region, raised to powe The function supports multi-channel images Each channel is processed independently. See Also: -:cpp:func:`accumulateSquare`, -:cpp:func:`accumulateProduct`, -:cpp:func:`accumulateWeighted` +:ocv:func:`accumulateSquare`, +:ocv:func:`accumulateProduct`, +:ocv:func:`accumulateWeighted` .. index:: accumulateProduct accumulateProduct --------------------- -.. cpp:function:: void accumulateProduct( InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray() ) +.. ocv:function:: void accumulateProduct( InputArray src1, InputArray src2, InputOutputArray dst, InputArray mask=noArray() ) Adds the per-element product of two input images to the accumulator. @@ -84,15 +84,15 @@ The function adds the product of 2 images or their selected regions to the accum The function supports multi-channel images. Each channel is processed independently. See Also: -:cpp:func:`accumulate`, -:cpp:func:`accumulateSquare`, -:cpp:func:`accumulateWeighted` +:ocv:func:`accumulate`, +:ocv:func:`accumulateSquare`, +:ocv:func:`accumulateWeighted` .. index:: accumulateWeighted accumulateWeighted ---------------------- -.. cpp:function:: void accumulateWeighted( InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray() ) +.. ocv:function:: void accumulateWeighted( InputArray src, InputOutputArray dst, double alpha, InputArray mask=noArray() ) Updates a running average. @@ -114,6 +114,6 @@ That is, ``alpha`` regulates the update speed (how fast the accumulator "forgets The function supports multi-channel images. Each channel is processed independently. See Also: -:cpp:func:`accumulate`, -:cpp:func:`accumulateSquare`, -:cpp:func:`accumulateProduct` \ No newline at end of file +:ocv:func:`accumulate`, +:ocv:func:`accumulateSquare`, +:ocv:func:`accumulateProduct` \ No newline at end of file diff --git a/modules/imgproc/doc/object_detection.rst b/modules/imgproc/doc/object_detection.rst index b6f85db..5c60a14 100644 --- a/modules/imgproc/doc/object_detection.rst +++ b/modules/imgproc/doc/object_detection.rst @@ -7,7 +7,7 @@ Object Detection matchTemplate ----------------- -.. cpp:function:: void matchTemplate( InputArray image, InputArray temp, OutputArray result, int method ) +.. ocv:function:: void matchTemplate( InputArray image, InputArray temp, OutputArray result, int method ) Compares a template against overlapped image regions. @@ -69,5 +69,5 @@ image patch: R(x,y)= \frac{ \sum_{x',y'} (T'(x',y') \cdot I'(x+x',y+y')) }{ \sqrt{\sum_{x',y'}T'(x',y')^2 \cdot \sum_{x',y'} I'(x+x',y+y')^2} } After the function finishes the comparison, the best matches can be found as global minimums (when ``CV_TM_SQDIFF`` was used) or maximums (when ``CV_TM_CCORR`` or ``CV_TM_CCOEFF`` was used) using the -:cpp:func:`minMaxLoc` function. In case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels and separate mean values are used for each channel. That is, the function can take a color template and a color image. The result will still be a single-channel image, which is easier to analyze. +:ocv:func:`minMaxLoc` function. In case of a color image, template summation in the numerator and each sum in the denominator is done over all of the channels and separate mean values are used for each channel. That is, the function can take a color template and a color image. The result will still be a single-channel image, which is easier to analyze. diff --git a/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst b/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst index 3a50317..8445d5a 100644 --- a/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst +++ b/modules/imgproc/doc/structural_analysis_and_shape_descriptors.rst @@ -7,7 +7,7 @@ Structural Analysis and Shape Descriptors moments ----------- -.. cpp:function:: Moments moments( InputArray array, bool binaryImage=false ) +.. ocv:function:: Moments moments( InputArray array, bool binaryImage=false ) Calculates all of the moments up to the third order of a polygon or rasterized shape where the class ``Moments`` is defined as: :: @@ -72,18 +72,18 @@ http://en.wikipedia.org/wiki/Green_theorem ). So, due to a limited raster resolution, the moments computed for a contour are slightly different from the moments computed for the same rasterized contour. See Also: -:cpp:func:`contourArea`, -:cpp:func:`arcLength` +:ocv:func:`contourArea`, +:ocv:func:`arcLength` .. index:: HuMoments HuMoments ------------- -.. cpp:function:: void HuMoments( const Moments& moments, double h[7] ) +.. ocv:function:: void HuMoments( const Moments& moments, double h[7] ) Calculates the seven Hu invariants. - :param moments: Input moments computed with :cpp:func:`moments` . + :param moments: Input moments computed with :ocv:func:`moments` . :param h: Output Hu invariants. The function calculates the seven Hu invariants (see @@ -101,19 +101,19 @@ where These values are proved to be invariants to the image scale, rotation, and reflection except the seventh one, whose sign is changed by reflection. This invariance is proved with the assumption of infinite image resolution. In case of raster images, the computed Hu invariants for the original and transformed images are a bit different. See Also: -:cpp:func:`matchShapes` +:ocv:func:`matchShapes` .. index:: findContours findContours ---------------- -.. cpp:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point()) +.. ocv:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, OutputArray hierarchy, int mode, int method, Point offset=Point()) -.. cpp:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point()) +.. ocv:function:: void findContours( InputOutputArray image, OutputArrayOfArrays contours, int mode, int method, Point offset=Point()) Finds contours in a binary image. - :param image: Source, an 8-bit single-channel image. Non-zero pixels are treated as 1's. Zero pixels remain 0's, so the image is treated as ``binary`` . You can use :cpp:func:`compare` , :cpp:func:`inRange` , :cpp:func:`threshold` , :cpp:func:`adaptiveThreshold` , :cpp:func:`Canny` , and others to create a binary image out of a grayscale or color one. The function modifies the ``image`` while extracting the contours. + :param image: Source, an 8-bit single-channel image. Non-zero pixels are treated as 1's. Zero pixels remain 0's, so the image is treated as ``binary`` . You can use :ocv:func:`compare` , :ocv:func:`inRange` , :ocv:func:`threshold` , :ocv:func:`adaptiveThreshold` , :ocv:func:`Canny` , and others to create a binary image out of a grayscale or color one. The function modifies the ``image`` while extracting the contours. :param contours: Detected contours. Each contour is stored as a vector of points. @@ -150,7 +150,7 @@ Source ``image`` is modified by this function. drawContours ---------------- -.. cpp: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: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() ) Draws contours outlines or filled contours. @@ -165,7 +165,7 @@ drawContours :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 :cpp:func:`line` for details. + :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`` ). @@ -221,7 +221,7 @@ The function draws contour outlines in the image if approxPolyDP ---------------- -.. cpp:function:: void approxPolyDP( InputArray curve, OutputArray approxCurve, double epsilon, bool closed ) +.. ocv:function:: void approxPolyDP( InputArray curve, OutputArray approxCurve, double epsilon, bool closed ) Approximates a polygonal curve(s) with the specified precision. @@ -242,7 +242,7 @@ See http://code.ros.org/svn/opencv/trunk/opencv/samples/cpp/contours.cpp on how arcLength ------------- -.. cpp:function:: double arcLength( InputArray curve, bool closed ) +.. ocv:function:: double arcLength( InputArray curve, bool closed ) Calculates a contour perimeter or a curve length. @@ -256,7 +256,7 @@ The function computes a curve length or a closed contour perimeter. boundingRect ---------------- -.. cpp:function:: Rect boundingRect( InputArray points ) +.. ocv:function:: Rect boundingRect( InputArray points ) Calculates the up-right bounding rectangle of a point set. @@ -269,7 +269,7 @@ The function calculates and returns the minimal up-right bounding rectangle for contourArea --------------- -.. cpp:function:: double contourArea( InputArray contour, bool oriented=false ) +.. ocv:function:: double contourArea( InputArray contour, bool oriented=false ) Calculates a contour area. @@ -277,9 +277,9 @@ contourArea :param orientation: Oriented area flag. If it is true, the function returns a signed area value, depending on the contour orientation (clockwise or counter-clockwise). Using this feature you can determine orientation of a contour by taking sign of the area. By default the parameter is ``false``, which means that the absolute value is returned. The function computes a contour area. Similarly to -:cpp:func:`moments` , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using -:cpp:func:`drawContours` or -:cpp:func:`fillPoly` , can be different. +:ocv:func:`moments` , the area is computed using the Green formula. Thus, the returned area and the number of non-zero pixels, if you draw the contour using +:ocv:func:`drawContours` or +:ocv:func:`fillPoly` , can be different. Here is a short example: :: vector contour; @@ -301,7 +301,7 @@ Here is a short example: :: convexHull -------------- -.. cpp:function:: void convexHull( InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true ) +.. ocv:function:: void convexHull( InputArray points, OutputArray hull, bool clockwise=false, bool returnPoints=true ) Finds the convex hull of a point set. @@ -322,7 +322,7 @@ that has fitEllipse -------------- -.. cpp:function:: RotatedRect fitEllipse( InputArray points ) +.. ocv:function:: RotatedRect fitEllipse( InputArray points ) Fits an ellipse around a set of 2D points. @@ -334,7 +334,7 @@ The function calculates the ellipse that fits (in least-squares sense) a set of fitLine ----------- -.. cpp:function:: void fitLine( InputArray points, OutputArray line, int distType, double param, double reps, double aeps ) +.. ocv:function:: void fitLine( InputArray points, OutputArray line, int distType, double param, double reps, double aeps ) Fits a line to a 2D or 3D point set. @@ -400,7 +400,7 @@ http://en.wikipedia.org/wiki/M-estimator isContourConvex ------------------- -.. cpp:function:: bool isContourConvex( InputArray contour ) +.. ocv:function:: bool isContourConvex( InputArray contour ) Tests a contour convexity. @@ -412,7 +412,7 @@ The function tests whether the input contour is convex or not. The contour must minAreaRect --------------- -.. cpp:function:: RotatedRect minAreaRect( InputArray points ) +.. ocv:function:: RotatedRect minAreaRect( InputArray points ) Finds a rotated rectangle of the minimum area enclosing the input 2D point set. @@ -424,7 +424,7 @@ The function calculates and returns the minimum-area bounding rectangle (possibl minEnclosingCircle ---------------------- -.. cpp:function:: void minEnclosingCircle( InputArray points, Point2f& center, float& radius ) +.. ocv:function:: void minEnclosingCircle( InputArray points, Point2f& center, float& radius ) Finds a circle of the minimum area enclosing a 2D point set. @@ -440,7 +440,7 @@ The function finds the minimal enclosing circle of a 2D point set using an itera matchShapes --------------- -.. cpp:function:: double matchShapes( InputArray object1, InputArray object2, int method, double parameter=0 ) +.. ocv:function:: double matchShapes( InputArray object1, InputArray object2, int method, double parameter=0 ) Compares two shapes. @@ -454,7 +454,7 @@ matchShapes :param parameter: Method-specific parameter (not supported now). The function compares two shapes. All three implemented methods use the Hu invariants (see -:cpp:func:`HuMoments` ) as follows ( +:ocv:func:`HuMoments` ) as follows ( :math:`A` denotes ``object1``,:math:`B` denotes ``object2`` ): * method=CV\_CONTOUR\_MATCH\_I1 @@ -490,7 +490,7 @@ and pointPolygonTest -------------------- -.. cpp:function:: double pointPolygonTest( InputArray contour, Point2f pt, bool measureDist ) +.. ocv:function:: double pointPolygonTest( InputArray contour, Point2f pt, bool measureDist ) Performs a point-in-contour test. diff --git a/modules/ml/doc/boosting.rst b/modules/ml/doc/boosting.rst index bb9d7db..2238ad8 100644 --- a/modules/ml/doc/boosting.rst +++ b/modules/ml/doc/boosting.rst @@ -155,9 +155,9 @@ In case of LogitBoost and Gentle AdaBoost, each weak predictor is a regression t CvBoost ------- -.. cpp:class:: CvBoost +.. ocv:class:: CvBoost -Boosted tree classifier, derived from :cpp:class:`CvStatModel` +Boosted tree classifier, derived from :ocv:class:`CvStatModel` .. index:: CvBoost::train @@ -165,7 +165,7 @@ Boosted tree classifier, derived from :cpp:class:`CvStatModel` CvBoost::train -------------- -.. cpp:function:: bool CvBoost::train( const Mat& _train_data, int _tflag, const Mat& _responses, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(), const Mat& _missing_mask=Mat(), CvBoostParams params=CvBoostParams(), bool update=false ) +.. ocv:function:: bool CvBoost::train( const Mat& _train_data, int _tflag, const Mat& _responses, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(), const Mat& _missing_mask=Mat(), CvBoostParams params=CvBoostParams(), bool update=false ) Trains a boosted tree classifier. @@ -177,7 +177,7 @@ The train method follows the common template. The last parameter ``update`` spec CvBoost::predict ---------------- -.. cpp:function:: float CvBoost::predict( const Mat& sample, const Mat& missing=Mat(), const Range& slice=Range::all(), bool rawMode=false, bool returnSum=false ) const +.. ocv:function:: float CvBoost::predict( const Mat& sample, const Mat& missing=Mat(), const Range& slice=Range::all(), bool rawMode=false, bool returnSum=false ) const Predicts a response for an input sample. @@ -189,7 +189,7 @@ The method ``CvBoost::predict`` runs the sample through the trees in the ensembl CvBoost::prune -------------- -.. cpp:function:: void CvBoost::prune( CvSlice slice ) +.. ocv:function:: void CvBoost::prune( CvSlice slice ) Removes the specified weak classifiers. @@ -205,7 +205,7 @@ Do not confuse this method with the pruning of individual decision trees, which CvBoost::get_weak_predictors ---------------------------- -.. cpp:function:: CvSeq* CvBoost::get_weak_predictors() +.. ocv:function:: CvSeq* CvBoost::get_weak_predictors() Returns the sequence of weak tree classifiers. diff --git a/modules/ml/doc/decision_trees.rst b/modules/ml/doc/decision_trees.rst index a6d227a..ae72233 100644 --- a/modules/ml/doc/decision_trees.rst +++ b/modules/ml/doc/decision_trees.rst @@ -371,9 +371,9 @@ Decision tree :: CvDTree::train -------------- -.. cpp:function:: bool CvDTree::train( const Mat& _train_data, int _tflag, const Mat& _responses, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(), const Mat& _missing_mask=Mat(), CvDTreeParams params=CvDTreeParams() ) +.. ocv:function:: bool CvDTree::train( const Mat& _train_data, int _tflag, const Mat& _responses, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), const Mat& _var_type=Mat(), const Mat& _missing_mask=Mat(), CvDTreeParams params=CvDTreeParams() ) -.. cpp:function:: bool CvDTree::train( CvDTreeTrainData* _train_data, const Mat& _subsample_idx ) +.. ocv:function:: bool CvDTree::train( CvDTreeTrainData* _train_data, const Mat& _subsample_idx ) Trains a decision tree. @@ -391,7 +391,7 @@ There are two ``train`` methods in ``CvDTree`` : CvDTree::predict ---------------- -.. cpp:function:: CvDTreeNode* CvDTree::predict( const Mat& _sample, const Mat& _missing_data_mask=Mat(), bool raw_mode=false ) const +.. ocv:function:: CvDTreeNode* CvDTree::predict( const Mat& _sample, const Mat& _missing_data_mask=Mat(), bool raw_mode=false ) const Returns the leaf node of a decision tree corresponding to the input vector. diff --git a/modules/ml/doc/expectation_maximization.rst b/modules/ml/doc/expectation_maximization.rst index 7cb60f6..5ffa3bb 100644 --- a/modules/ml/doc/expectation_maximization.rst +++ b/modules/ml/doc/expectation_maximization.rst @@ -195,7 +195,7 @@ EM model :: CvEM::train ----------- -.. cpp:function:: void CvEM::train( const Mat& samples, const Mat& sample_idx=Mat(), CvEMParams params=CvEMParams(), Mat* labels=0 ) +.. ocv:function:: void CvEM::train( const Mat& samples, const Mat& sample_idx=Mat(), CvEMParams params=CvEMParams(), Mat* labels=0 ) Estimates the Gaussian mixture parameters from a sample set. diff --git a/modules/ml/doc/k_nearest_neighbors.rst b/modules/ml/doc/k_nearest_neighbors.rst index a06e351..b611d79 100644 --- a/modules/ml/doc/k_nearest_neighbors.rst +++ b/modules/ml/doc/k_nearest_neighbors.rst @@ -49,7 +49,7 @@ K-Nearest Neighbors model :: CvKNearest::train ----------------- -.. cpp:function:: bool CvKNearest::train( const Mat& _train_data, const Mat& _responses, const Mat& _sample_idx=Mat(), bool is_regression=false, int _max_k=32, bool _update_base=false ) +.. ocv:function:: bool CvKNearest::train( const Mat& _train_data, const Mat& _responses, const Mat& _sample_idx=Mat(), bool is_regression=false, int _max_k=32, bool _update_base=false ) Trains the model. @@ -70,7 +70,7 @@ The parameter ``_update_base`` specifies whether the model is trained from scrat CvKNearest::find_nearest ------------------------ -.. cpp:function:: float CvKNearest::find_nearest( const Mat& _samples, int k, Mat* results=0, const float** neighbors=0, Mat* neighbor_responses=0, Mat* dist=0 ) const +.. ocv:function:: float CvKNearest::find_nearest( const Mat& _samples, int k, Mat* results=0, const float** neighbors=0, Mat* neighbor_responses=0, Mat* dist=0 ) const Finds the neighbors for input vectors. diff --git a/modules/ml/doc/neural_networks.rst b/modules/ml/doc/neural_networks.rst index 7e6fb8a..e38c1cc 100644 --- a/modules/ml/doc/neural_networks.rst +++ b/modules/ml/doc/neural_networks.rst @@ -225,7 +225,7 @@ Unlike many other models in ML that are constructed and trained at once, in the CvANN_MLP::create ----------------- -.. cpp:function:: void CvANN_MLP::create( const Mat& _layer_sizes, int _activ_func=SIGMOID_SYM, double _f_param1=0, double _f_param2=0 ) +.. ocv:function:: void CvANN_MLP::create( const Mat& _layer_sizes, int _activ_func=SIGMOID_SYM, double _f_param1=0, double _f_param2=0 ) Constructs MLP with the specified topology. @@ -243,7 +243,7 @@ The method creates an MLP network with the specified topology and assigns the sa CvANN_MLP::train ---------------- -.. cpp:function:: int CvANN_MLP::train( const Mat& _inputs, const Mat& _outputs, const Mat& _sample_weights, const Mat& _sample_idx=Mat(), CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(), int flags=0 ) +.. ocv:function:: int CvANN_MLP::train( const Mat& _inputs, const Mat& _outputs, const Mat& _sample_weights, const Mat& _sample_idx=Mat(), CvANN_MLP_TrainParams _params = CvANN_MLP_TrainParams(), int flags=0 ) Trains/updates MLP. diff --git a/modules/ml/doc/normal_bayes_classifier.rst b/modules/ml/doc/normal_bayes_classifier.rst index 664646d..1107bd1 100644 --- a/modules/ml/doc/normal_bayes_classifier.rst +++ b/modules/ml/doc/normal_bayes_classifier.rst @@ -46,7 +46,7 @@ Bayes classifier for normally distributed data :: CvNormalBayesClassifier::train ------------------------------ -.. cpp:function:: bool CvNormalBayesClassifier::train( const Mat& _train_data, const Mat& _responses, const Mat& _var_idx =Mat(), const Mat& _sample_idx=Mat(), bool update=false ) +.. ocv:function:: bool CvNormalBayesClassifier::train( const Mat& _train_data, const Mat& _responses, const Mat& _var_idx =Mat(), const Mat& _sample_idx=Mat(), bool update=false ) Trains the model. @@ -65,7 +65,7 @@ In addition, there is an ``update`` flag that identifies whether the model shoul CvNormalBayesClassifier::predict -------------------------------- -.. cpp:function:: float CvNormalBayesClassifier::predict( const Mat& samples, Mat* results=0 ) const +.. ocv:function:: float CvNormalBayesClassifier::predict( const Mat& samples, Mat* results=0 ) const Predicts the response for sample(s). diff --git a/modules/ml/doc/random_trees.rst b/modules/ml/doc/random_trees.rst index ebf876b..1449280 100644 --- a/modules/ml/doc/random_trees.rst +++ b/modules/ml/doc/random_trees.rst @@ -136,7 +136,7 @@ Random trees :: CvRTrees::train --------------- -.. cpp:function:: bool CvRTrees::train( const Mat& train_data, int tflag, const Mat& responses, const Mat& comp_idx=Mat(), const Mat& sample_idx=Mat(), const Mat& var_type=Mat(), const Mat& missing_mask=Mat(), CvRTParams params=CvRTParams() ) +.. ocv:function:: bool CvRTrees::train( const Mat& train_data, int tflag, const Mat& responses, const Mat& comp_idx=Mat(), const Mat& sample_idx=Mat(), const Mat& var_type=Mat(), const Mat& missing_mask=Mat(), CvRTParams params=CvRTParams() ) Trains the Random Tree model. @@ -149,7 +149,7 @@ The method ``CvRTrees::train`` is very similar to the first form of ``CvDTree::t CvRTrees::predict ----------------- -.. cpp:function:: double CvRTrees::predict( const Mat& sample, const Mat& missing=Mat() ) const +.. ocv:function:: double CvRTrees::predict( const Mat& sample, const Mat& missing=Mat() ) const Predicts the output for an input sample. @@ -161,7 +161,7 @@ The input parameters of the prediction method are the same as in ``CvDTree::pred CvRTrees::get_var_importance ---------------------------- -.. cpp:function:: const Mat& CvRTrees::get_var_importance() const +.. ocv:function:: const Mat& CvRTrees::get_var_importance() const Retrieves the variable importance array. @@ -173,7 +173,7 @@ The method returns the variable importance vector, computed at the training stag CvRTrees::get_proximity ----------------------- -.. cpp:function:: float CvRTrees::get_proximity( const Mat& sample_1, const Mat& sample_2 ) const +.. ocv:function:: float CvRTrees::get_proximity( const Mat& sample_1, const Mat& sample_2 ) const Retrieves the proximity measure between two training samples. diff --git a/modules/ml/doc/statistical_models.rst b/modules/ml/doc/statistical_models.rst index c39e4c9..21fac34 100644 --- a/modules/ml/doc/statistical_models.rst +++ b/modules/ml/doc/statistical_models.rst @@ -46,7 +46,7 @@ In this declaration, some methods are commented off. These are methods for which CvStatModel::CvStatModel ------------------------ -.. cpp:function:: CvStatModel::CvStatModel() +.. ocv:function:: CvStatModel::CvStatModel() Serves as a default constructor. @@ -58,7 +58,7 @@ Each statistical model class in ML has a default constructor without parameters. CvStatModel::CvStatModel(...) ----------------------------- -.. cpp:function:: CvStatModel::CvStatModel( const Mat& train_data ... ) +.. ocv:function:: CvStatModel::CvStatModel( const Mat& train_data ... ) Serves as a training constructor. @@ -70,7 +70,7 @@ Most ML classes provide a single-step constructor and train constructors. This c CvStatModel::~CvStatModel ------------------------- -.. cpp:function:: CvStatModel::~CvStatModel() +.. ocv:function:: CvStatModel::~CvStatModel() Serves as a virtual destructor. @@ -93,7 +93,7 @@ Normally, the destructor of each derived class does nothing. But in this instanc CvStatModel::clear ------------------ -.. cpp:function:: void CvStatModel::clear() +.. ocv:function:: void CvStatModel::clear() Deallocates memory and resets the model state. @@ -105,7 +105,7 @@ The method ``clear`` does the same job as the destructor: it deallocates all the CvStatModel::save ----------------- -.. cpp:function:: void CvStatModel::save( const char* filename, const char* name=0 ) +.. ocv:function:: void CvStatModel::save( const char* filename, const char* name=0 ) Saves the model to a file. @@ -117,7 +117,7 @@ The method ``save`` saves the complete model state to the specified XML or YAML CvStatModel::load ----------------- -.. cpp:function:: void CvStatModel::load( const char* filename, const char* name=0 ) +.. ocv:function:: void CvStatModel::load( const char* filename, const char* name=0 ) Loads the model from a file. @@ -130,7 +130,7 @@ The method ``load`` loads the complete model state with the specified name (or d CvStatModel::write ------------------ -.. cpp:function:: void CvStatModel::write( CvFileStorage* storage, const char* name ) +.. ocv:function:: void CvStatModel::write( CvFileStorage* storage, const char* name ) Writes the model to the file storage. @@ -142,7 +142,7 @@ The method ``write`` stores the complete model state in the file storage with th CvStatModel::read ----------------- -.. cpp:function:: void CvStatMode::read( CvFileStorage* storage, CvFileNode* node ) +.. ocv:function:: void CvStatMode::read( CvFileStorage* storage, CvFileNode* node ) Reads the model from the file storage. @@ -157,7 +157,7 @@ The previous model state is cleared by ``clear()`` . CvStatModel::train ------------------ -.. cpp:function:: bool CvStatMode::train( const Mat& train_data, [int tflag,] ..., const Mat& responses, ..., [const Mat& var_idx,] ..., [const Mat& sample_idx,] ... [const Mat& var_type,] ..., [const Mat& missing_mask,] ... ) +.. ocv:function:: bool CvStatMode::train( const Mat& train_data, [int tflag,] ..., const Mat& responses, ..., [const Mat& var_idx,] ..., [const Mat& sample_idx,] ... [const Mat& var_type,] ..., [const Mat& missing_mask,] ... ) Trains the model. @@ -189,7 +189,7 @@ Usually, the previous model state is cleared by ``clear()`` before running the t CvStatModel::predict -------------------- -.. cpp:function:: float CvStatMode::predict( const Mat& sample[, ] ) const +.. ocv:function:: float CvStatMode::predict( const Mat& sample[, ] ) const Predicts the response for a sample. diff --git a/modules/ml/doc/support_vector_machines.rst b/modules/ml/doc/support_vector_machines.rst index 0ff13ba..431ed25 100644 --- a/modules/ml/doc/support_vector_machines.rst +++ b/modules/ml/doc/support_vector_machines.rst @@ -125,7 +125,7 @@ The structure must be initialized and passed to the training method of CvSVM::train ------------ -.. cpp:function:: bool CvSVM::train( const Mat& _train_data, const Mat& _responses, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), CvSVMParams _params=CvSVMParams() ) +.. ocv:function:: bool CvSVM::train( const Mat& _train_data, const Mat& _responses, const Mat& _var_idx=Mat(), const Mat& _sample_idx=Mat(), CvSVMParams _params=CvSVMParams() ) Trains SVM. @@ -145,7 +145,7 @@ All the other parameters are gathered in the CvSVM::train_auto ----------------- -.. cpp:function:: train_auto( const Mat& _train_data, const Mat& _responses, const Mat& _var_idx, const Mat& _sample_idx, CvSVMParams params, int k_fold = 10, CvParamGrid C_grid = get_default_grid(CvSVM::C), CvParamGrid gamma_grid = get_default_grid(CvSVM::GAMMA), CvParamGrid p_grid = get_default_grid(CvSVM::P), CvParamGrid nu_grid = get_default_grid(CvSVM::NU), CvParamGrid coef_grid = get_default_grid(CvSVM::COEF), CvParamGrid degree_grid = get_default_grid(CvSVM::DEGREE) ) +.. ocv:function:: train_auto( const Mat& _train_data, const Mat& _responses, const Mat& _var_idx, const Mat& _sample_idx, CvSVMParams params, int k_fold = 10, CvParamGrid C_grid = get_default_grid(CvSVM::C), CvParamGrid gamma_grid = get_default_grid(CvSVM::GAMMA), CvParamGrid p_grid = get_default_grid(CvSVM::P), CvParamGrid nu_grid = get_default_grid(CvSVM::NU), CvParamGrid coef_grid = get_default_grid(CvSVM::COEF), CvParamGrid degree_grid = get_default_grid(CvSVM::DEGREE) ) Trains SVM with optimal parameters. @@ -189,7 +189,7 @@ as well as for the regression CvSVM::get_default_grid ----------------------- -.. cpp:function:: CvParamGrid CvSVM::get_default_grid( int param_id ) +.. ocv:function:: CvParamGrid CvSVM::get_default_grid( int param_id ) Generates a grid for SVM parameters. @@ -217,7 +217,7 @@ The function generates a grid for the specified parameter of the SVM algorithm. CvSVM::get_params ----------------- -.. cpp:function:: CvSVMParams CvSVM::get_params() const +.. ocv:function:: CvSVMParams CvSVM::get_params() const Returns the current SVM parameters. @@ -229,9 +229,9 @@ This function may be used to get the optimal parameters obtained while automatic CvSVM::get_support_vector* -------------------------- -.. cpp:function:: int CvSVM::get_support_vector_count() const +.. ocv:function:: int CvSVM::get_support_vector_count() const -.. cpp:function:: const float* CvSVM::get_support_vector(int i) const +.. ocv:function:: const float* CvSVM::get_support_vector(int i) const Retrieves a number of support vectors and the particular vector. diff --git a/modules/objdetect/doc/cascade_classification.rst b/modules/objdetect/doc/cascade_classification.rst index ab126c1..be800af 100644 --- a/modules/objdetect/doc/cascade_classification.rst +++ b/modules/objdetect/doc/cascade_classification.rst @@ -34,7 +34,7 @@ Base class for computing feature values in cascade classifiers :: FeatureEvaluator::read -------------------------- -.. cpp:function:: bool FeatureEvaluator::read(const FileNode& node) +.. ocv:function:: bool FeatureEvaluator::read(const FileNode& node) Reads parameters of features from the ``FileStorage`` node. @@ -44,7 +44,7 @@ FeatureEvaluator::read FeatureEvaluator::clone --------------------------- -.. cpp:function:: Ptr FeatureEvaluator::clone() const +.. ocv:function:: Ptr FeatureEvaluator::clone() const Returns a full copy of the feature evaluator. @@ -52,7 +52,7 @@ FeatureEvaluator::clone FeatureEvaluator::getFeatureType ------------------------------------ -.. cpp:function:: int FeatureEvaluator::getFeatureType() const +.. ocv:function:: int FeatureEvaluator::getFeatureType() const Returns the feature type (``HAAR`` or ``LBP`` for now). @@ -60,7 +60,7 @@ FeatureEvaluator::getFeatureType FeatureEvaluator::setImage ------------------------------ -.. cpp:function:: bool FeatureEvaluator::setImage(const Mat& img, Size origWinSize) +.. ocv:function:: bool FeatureEvaluator::setImage(const Mat& img, Size origWinSize) Assigns an image to feature evaluator. @@ -74,7 +74,7 @@ The method assigns an image, where the features will be computed, to the feature FeatureEvaluator::setWindow ------------------------------- -.. cpp:function:: bool FeatureEvaluator::setWindow(Point p) +.. ocv:function:: bool FeatureEvaluator::setWindow(Point p) Assigns a window in the current image where the features will be computed. @@ -84,7 +84,7 @@ FeatureEvaluator::setWindow FeatureEvaluator::calcOrd ----------------------------- -.. cpp:function:: double FeatureEvaluator::calcOrd(int featureIdx) const +.. ocv:function:: double FeatureEvaluator::calcOrd(int featureIdx) const Computes the value of an ordered (numerical) feature. @@ -96,7 +96,7 @@ The function returns the computed value of an ordered feature. FeatureEvaluator::calcCat ----------------------------- -.. cpp:function:: int FeatureEvaluator::calcCat(int featureIdx) const +.. ocv:function:: int FeatureEvaluator::calcCat(int featureIdx) const Computes the value of a categorical feature. @@ -108,7 +108,7 @@ The function returns the computed label of a categorical feature, that is, the v FeatureEvaluator::create ---------------------------- -.. cpp:function:: static Ptr FeatureEvaluator::create(int type) +.. ocv:function:: static Ptr FeatureEvaluator::create(int type) Constructs the feature evaluator. @@ -195,7 +195,7 @@ The cascade classifier class for object detection :: CascadeClassifier::CascadeClassifier ---------------------------------------- -.. cpp:function:: CascadeClassifier::CascadeClassifier(const string& filename) +.. ocv:function:: CascadeClassifier::CascadeClassifier(const string& filename) Loads a classifier from a file. @@ -205,7 +205,7 @@ CascadeClassifier::CascadeClassifier CascadeClassifier::empty ---------------------------- -.. cpp:function:: bool CascadeClassifier::empty() const +.. ocv:function:: bool CascadeClassifier::empty() const Checks if the classifier has been loaded or not. @@ -213,7 +213,7 @@ CascadeClassifier::empty CascadeClassifier::load --------------------------- -.. cpp:function:: bool CascadeClassifier::load(const string& filename) +.. ocv:function:: bool CascadeClassifier::load(const string& filename) Loads a classifier from a file. The previous content is destroyed. @@ -223,7 +223,7 @@ CascadeClassifier::load CascadeClassifier::read --------------------------- -.. cpp:function:: bool CascadeClassifier::read(const FileNode& node) +.. ocv:function:: bool CascadeClassifier::read(const FileNode& node) Reads a classifier from a FileStorage node. The file may contain a new cascade classifier (trained traincascade application) only. @@ -231,7 +231,7 @@ CascadeClassifier::read CascadeClassifier::detectMultiScale --------------------------------------- -.. cpp:function:: void CascadeClassifier::detectMultiScale( const Mat& image, vector& objects, double scaleFactor=1.1, int minNeighbors=3, int flags=0, Size minSize=Size()) +.. ocv:function:: void CascadeClassifier::detectMultiScale( const Mat& image, vector& objects, double scaleFactor=1.1, int minNeighbors=3, int flags=0, Size minSize=Size()) Detects objects of different sizes in the input image. The detected objects are returned as a list of rectangles. @@ -251,7 +251,7 @@ CascadeClassifier::detectMultiScale CascadeClassifier::setImage ------------------------------- -.. cpp:function:: bool CascadeClassifier::setImage( Ptr& feval, const Mat& image ) +.. ocv:function:: bool CascadeClassifier::setImage( Ptr& feval, const Mat& image ) Sets an image for detection, which is called by ``detectMultiScale`` at each image level. @@ -263,7 +263,7 @@ CascadeClassifier::setImage CascadeClassifier::runAt ---------------------------- -.. cpp:function:: int CascadeClassifier::runAt( Ptr& feval, Point pt ) +.. ocv:function:: int CascadeClassifier::runAt( Ptr& feval, Point pt ) Runs the detector at the specified point. Use ``setImage`` to set the image that the detector is working with. @@ -278,7 +278,7 @@ Otherwise, it returns negated index of the stage at which the candidate has been groupRectangles ------------------- -.. cpp:function:: void groupRectangles(vector& rectList, int groupThreshold, double eps=0.2) +.. ocv:function:: void groupRectangles(vector& rectList, int groupThreshold, double eps=0.2) Groups the object candidate rectangles. diff --git a/modules/video/doc/motion_analysis_and_object_tracking.rst b/modules/video/doc/motion_analysis_and_object_tracking.rst index 558cb0a..2644bdd 100644 --- a/modules/video/doc/motion_analysis_and_object_tracking.rst +++ b/modules/video/doc/motion_analysis_and_object_tracking.rst @@ -7,7 +7,7 @@ Motion Analysis and Object Tracking calcOpticalFlowPyrLK ------------------------ -.. cpp:function:: void calcOpticalFlowPyrLK( InputArray prevImg, InputArray nextImg, InputArray prevPts, InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize=Size(15,15), int maxLevel=3, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), double derivLambda=0.5, int flags=0 ) +.. ocv:function:: void calcOpticalFlowPyrLK( InputArray prevImg, InputArray nextImg, InputArray prevPts, InputOutputArray nextPts, OutputArray status, OutputArray err, Size winSize=Size(15,15), int maxLevel=3, TermCriteria criteria=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01), double derivLambda=0.5, int flags=0 ) Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids. @@ -43,7 +43,7 @@ Bouguet00 calcOpticalFlowFarneback ---------------------------- -.. cpp:function:: void calcOpticalFlowFarneback( InputArray prevImg, InputArray nextImg, InputOutputArray flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, int flags ) +.. ocv:function:: void calcOpticalFlowFarneback( InputArray prevImg, InputArray nextImg, InputOutputArray flow, double pyrScale, int levels, int winsize, int iterations, int polyN, double polySigma, int flags ) Computes a dense optical flow using the Gunnar Farneback's algorithm. @@ -82,7 +82,7 @@ The function finds an optical flow for each ``prevImg`` pixel using the alorithm estimateRigidTransform -------------------------- -.. cpp:function:: Mat estimateRigidTransform( InputArray src, InputArray dst, bool fullAffine ) +.. ocv:function:: Mat estimateRigidTransform( InputArray src, InputArray dst, bool fullAffine ) Computes an optimal affine transformation between two 2D point sets. @@ -116,16 +116,16 @@ In the case of point sets, the problem is formulated in the following way. We ne when ``fullAffine=false`` . See Also: - :cpp:func:`getAffineTransform`, - :cpp:func:`getPerspectiveTransform`, - :cpp:func:`findHomography` + :ocv:func:`getAffineTransform`, + :ocv:func:`getPerspectiveTransform`, + :ocv:func:`findHomography` .. index:: updateMotionHistory updateMotionHistory ----------------------- -.. cpp:function:: void updateMotionHistory( InputArray silhouette, InputOutputArray mhi, double timestamp, double duration ) +.. ocv:function:: void updateMotionHistory( InputArray silhouette, InputOutputArray mhi, double timestamp, double duration ) Updates the motion history image by a moving silhouette. @@ -146,8 +146,8 @@ The function updates the motion history image as follows: That is, MHI pixels where the motion occurs are set to the current ``timestamp`` , while the pixels where the motion happened last time a long time ago are cleared. The function, together with -:cpp:func:`calcMotionGradient` and -:cpp:func:`calcGlobalOrientation` , implements a motion templates technique described in +:ocv:func:`calcMotionGradient` and +:ocv:func:`calcGlobalOrientation` , implements a motion templates technique described in Davis97 and Bradski00 @@ -158,7 +158,7 @@ See also the OpenCV sample ``motempl.c`` that demonstrates the use of all the mo calcMotionGradient ---------------------- -.. cpp:function:: void calcMotionGradient( InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize=3 ) +.. ocv:function:: void calcMotionGradient( InputArray mhi, OutputArray mask, OutputArray orientation, double delta1, double delta2, int apertureSize=3 ) Calculates a gradient orientation of a motion history image. @@ -174,7 +174,7 @@ calcMotionGradient \min ( \texttt{delta1} , \texttt{delta2} ) \le M(x,y)-m(x,y) \le \max ( \texttt{delta1} , \texttt{delta2} ). - :param apertureSize: Aperture size of the :cpp:func:`Sobel` operator. + :param apertureSize: Aperture size of the :ocv:func:`Sobel` operator. The function calculates a gradient orientation at each pixel :math:`(x, y)` as: @@ -184,26 +184,26 @@ The function calculates a gradient orientation at each pixel \texttt{orientation} (x,y)= \arctan{\frac{d\texttt{mhi}/dy}{d\texttt{mhi}/dx}} In fact, -:cpp:func:`fastArctan` and -:cpp:func:`phase` are used so that the computed angle is measured in degrees and covers the full range 0..360. Also, the ``mask`` is filled to indicate pixels where the computed angle is valid. +:ocv:func:`fastArctan` and +:ocv:func:`phase` are used so that the computed angle is measured in degrees and covers the full range 0..360. Also, the ``mask`` is filled to indicate pixels where the computed angle is valid. .. index:: calcGlobalOrientation calcGlobalOrientation ------------------------- -.. cpp:function:: double calcGlobalOrientation( InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration ) +.. ocv:function:: double calcGlobalOrientation( InputArray orientation, InputArray mask, InputArray mhi, double timestamp, double duration ) Calculates a global motion orientation in a selected region. - :param orientation: Motion gradient orientation image calculated by the function :cpp:func:`calcMotionGradient` . + :param orientation: Motion gradient orientation image calculated by the function :ocv:func:`calcMotionGradient` . - :param mask: Mask image. It may be a conjunction of a valid gradient mask, also calculated by :cpp:func:`calcMotionGradient` , and the mask of a region whose direction needs to be calculated. + :param mask: Mask image. It may be a conjunction of a valid gradient mask, also calculated by :ocv:func:`calcMotionGradient` , and the mask of a region whose direction needs to be calculated. - :param mhi: Motion history image calculated by :cpp:func:`updateMotionHistory` . + :param mhi: Motion history image calculated by :ocv:func:`updateMotionHistory` . - :param timestamp: Timestamp passed to :cpp:func:`updateMotionHistory` . + :param timestamp: Timestamp passed to :ocv:func:`updateMotionHistory` . - :param duration: Maximum duration of a motion track in milliseconds, passed to :cpp:func:`updateMotionHistory` . + :param duration: Maximum duration of a motion track in milliseconds, passed to :ocv:func:`updateMotionHistory` . The function calculates an average motion direction in the selected region and returns the angle between @@ -217,7 +217,7 @@ weight and the motion occurred in the past has a smaller weight, as recorded in segmentMotion ------------- -.. cpp:function:: void segmentMotion(InputArray mhi, OutputArray segmask, vector& boundingRects, double timestamp, double segThresh) +.. ocv:function:: void segmentMotion(InputArray mhi, OutputArray segmask, vector& boundingRects, double timestamp, double segThresh) Splits a motion history image into a few parts corresponding to separate independent motions (e.g. left hand, right hand). @@ -232,28 +232,28 @@ segmentMotion :param segThresh: Segmentation threshold; recommended to be equal to the interval between motion history "steps" or greater. -The function finds all of the motion segments and marks them in ``segmask`` with individual values (1,2,...). It also computes a vector with ROIs of motion connected components. After that the motion direction for every component can be calculated with :cpp:func:`calcGlobalOrientation` using the extracted mask of the particular component. +The function finds all of the motion segments and marks them in ``segmask`` with individual values (1,2,...). It also computes a vector with ROIs of motion connected components. After that the motion direction for every component can be calculated with :ocv:func:`calcGlobalOrientation` using the extracted mask of the particular component. .. index:: CamShift CamShift ------------ -.. cpp:function:: RotatedRect CamShift( InputArray probImage, Rect& window, TermCriteria criteria ) +.. ocv:function:: RotatedRect CamShift( InputArray probImage, Rect& window, TermCriteria criteria ) Finds an object center, size, and orientation. - :param probImage: Back projection of the object histogram. See :cpp:func:`calcBackProject` . + :param probImage: Back projection of the object histogram. See :ocv:func:`calcBackProject` . :param window: Initial search window. - :param criteria: Stop criteria for the underlying :cpp:func:`meanShift` . + :param criteria: Stop criteria for the underlying :ocv:func:`meanShift` . The function implements the CAMSHIFT object tracking algrorithm Bradski98 . First, it finds an object center using -:cpp:func:`meanShift` and then adjusts the window size and finds the optimal rotation. The function returns the rotated rectangle structure that includes the object position, size, and orientation. The next position of the search window can be obtained with ``RotatedRect::boundingRect()`` . +:ocv:func:`meanShift` and then adjusts the window size and finds the optimal rotation. The function returns the rotated rectangle structure that includes the object position, size, and orientation. The next position of the search window can be obtained with ``RotatedRect::boundingRect()`` . See the OpenCV sample ``camshiftdemo.c`` that tracks colored objects. @@ -261,23 +261,23 @@ See the OpenCV sample ``camshiftdemo.c`` that tracks colored objects. meanShift ------------- -.. cpp:function:: int meanShift( InputArray probImage, Rect& window, TermCriteria criteria ) +.. ocv:function:: int meanShift( InputArray probImage, Rect& window, TermCriteria criteria ) Finds an object on a back projection image. - :param probImage: Back projection of the object histogram. See :cpp:func:`calcBackProject` for details. + :param probImage: Back projection of the object histogram. See :ocv:func:`calcBackProject` for details. :param window: Initial search window. :param criteria: Stop criteria for the iterative search algorithm. The function implements the iterative object search algorithm. It takes the input back projection of an object and the initial position. The mass center in ``window`` of the back projection image is computed and the search window center shifts to the mass center. The procedure is repeated until the specified number of iterations ``criteria.maxCount`` is done or until the window center shifts by less than ``criteria.epsilon`` . The algorithm is used inside -:cpp:func:`CamShift` and, unlike -:cpp:func:`CamShift` , the search window size or orientation do not change during the search. You can simply pass the output of -:cpp:func:`calcBackProject` to this function. But better results can be obtained if you pre-filter the back projection and remove the noise (for example, by retrieving connected components with -:cpp:func:`findContours` , throwing away contours with small area ( -:cpp:func:`contourArea` ), and rendering the remaining contours with -:cpp:func:`drawContours` ). +:ocv:func:`CamShift` and, unlike +:ocv:func:`CamShift` , the search window size or orientation do not change during the search. You can simply pass the output of +:ocv:func:`calcBackProject` to this function. But better results can be obtained if you pre-filter the back projection and remove the noise (for example, by retrieving connected components with +:ocv:func:`findContours` , throwing away contours with small area ( +:ocv:func:`contourArea` ), and rendering the remaining contours with +:ocv:func:`drawContours` ). .. index:: KalmanFilter @@ -299,11 +299,11 @@ http://en.wikipedia.org/wiki/Kalman_filter KalmanFilter::KalmanFilter -------------------------- -.. cpp:function:: KalmanFilter::KalmanFilter() +.. ocv:function:: KalmanFilter::KalmanFilter() - Creates an empty object that can be initialized later by the function :cpp:func:`KalmanFilter::init`. + Creates an empty object that can be initialized later by the function :ocv:func:`KalmanFilter::init`. -.. cpp:function:: KalmanFilter::KalmanFilter(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F) +.. ocv:function:: KalmanFilter::KalmanFilter(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F) The full constructor. @@ -321,7 +321,7 @@ KalmanFilter::KalmanFilter KalmanFilter::init ------------------ -.. cpp:function:: void KalmanFilter::init(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F) +.. ocv:function:: void KalmanFilter::init(int dynamParams, int measureParams, int controlParams=0, int type=CV_32F) Re-initializes Kalman filter. The previous content is destroyed. @@ -339,7 +339,7 @@ KalmanFilter::init KalmanFilter::predict --------------------- -.. cpp:function:: const Mat& KalmanFilter::predict(const Mat& control=Mat()) +.. ocv:function:: const Mat& KalmanFilter::predict(const Mat& control=Mat()) Computes predicted state @@ -349,7 +349,7 @@ KalmanFilter::predict KalmanFilter::correct --------------------- -.. cpp:function:: const Mat& KalmanFilter::correct(const Mat& measurement) +.. ocv:function:: const Mat& KalmanFilter::correct(const Mat& measurement) Updates the predicted state from the measurement @@ -359,7 +359,7 @@ KalmanFilter::correct BackgroundSubtractor -------------------- -.. cpp:class: BackgroundSubtractor +.. ocv:class: BackgroundSubtractor The base class for background/foreground segmentation. :: @@ -380,7 +380,7 @@ The class is only used to define the common interface for the whole family of ba BackgroundSubtractor::operator() ------------------------------- -.. cpp:function:: virtual void BackgroundSubtractor::operator()(InputArray image, OutputArray fgmask, double learningRate=0) +.. ocv:function:: virtual void BackgroundSubtractor::operator()(InputArray image, OutputArray fgmask, double learningRate=0) Computes foreground mask. @@ -394,7 +394,7 @@ BackgroundSubtractor::operator() BackgroundSubtractor::getBackgroundImage ---------------------------------------- -.. cpp:function:: virtual void BackgroundSubtractor::getBackgroundImage(OutputArray backgroundImage) const +.. ocv:function:: virtual void BackgroundSubtractor::getBackgroundImage(OutputArray backgroundImage) const This method computes a background image. @@ -404,7 +404,7 @@ This method computes a background image. BackgroundSubtractorMOG ----------------------- -.. cpp:class: BackgroundSubtractorMOG : public BackgroundSubtractor +.. ocv:class: BackgroundSubtractorMOG : public BackgroundSubtractor Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm. @@ -416,9 +416,9 @@ The class implements the following algorithm: P. KadewTraKuPong and R. Bowden, A BackgroundSubtractorMOG::BackgroundSubtractorMOG ------------------------------------------------ -.. cpp:function:: BackgroundSubtractorMOG::BackgroundSubtractorMOG() +.. ocv:function:: BackgroundSubtractorMOG::BackgroundSubtractorMOG() -.. cpp:function:: BackgroundSubtractorMOG::BackgroundSubtractorMOG(int history, int nmixtures, double backgroundRatio, double noiseSigma=0) +.. ocv:function:: BackgroundSubtractorMOG::BackgroundSubtractorMOG(int history, int nmixtures, double backgroundRatio, double noiseSigma=0) :param history: The length of the history. @@ -436,7 +436,7 @@ Default constructor sets all parameters to some default values. BackgroundSubtractorMOG::operator() ----------------------------------- -.. cpp:function:: virtual void BackgroundSubtractorMOG::operator()(InputArray image, OutputArray fgmask, double learningRate=0) +.. ocv:function:: virtual void BackgroundSubtractorMOG::operator()(InputArray image, OutputArray fgmask, double learningRate=0) The update operator. @@ -446,7 +446,7 @@ BackgroundSubtractorMOG::operator() BackgroundSubtractorMOG::initialize ----------------------------------- -.. cpp:function:: virtual void BackgroundSubtractorMOG::initialize(Size frameSize, int frameType) +.. ocv:function:: virtual void BackgroundSubtractorMOG::initialize(Size frameSize, int frameType) Re-initiaization method. @@ -456,7 +456,7 @@ BackgroundSubtractorMOG::initialize BackgroundSubtractorMOG2 ------------------------ -.. cpp:class: BackgroundSubtractorMOG2 : public BackgroundSubtractor +.. ocv:class: BackgroundSubtractorMOG2 : public BackgroundSubtractor Gaussian Mixture-based Backbround/Foreground Segmentation Algorithm. @@ -472,9 +472,9 @@ The class implements the Gaussian mixture model background subtraction from: BackgroundSubtractorMOG2::BackgroundSubtractorMOG2 -------------------------------------------------- -.. cpp:function:: BackgroundSubtractorMOG2::BackgroundSubtractorMOG2() +.. ocv:function:: BackgroundSubtractorMOG2::BackgroundSubtractorMOG2() -.. cpp:function:: BackgroundSubtractorMOG2::BackgroundSubtractorMOG2(int history, float varThreshold, bool bShadowDetection=1) +.. ocv:function:: BackgroundSubtractorMOG2::BackgroundSubtractorMOG2(int history, float varThreshold, bool bShadowDetection=1) :param history: The length of the history. @@ -511,7 +511,7 @@ Also the class has several less important parameters - things you might change b BackgroundSubtractorMOG2::operator() ----------------------------------- -.. cpp:function:: virtual void BackgroundSubtractorMOG2::operator()(InputArray image, OutputArray fgmask, double learningRate=-1) +.. ocv:function:: virtual void BackgroundSubtractorMOG2::operator()(InputArray image, OutputArray fgmask, double learningRate=-1) The update operator. @@ -521,7 +521,7 @@ BackgroundSubtractorMOG2::operator() BackgroundSubtractorMOG2::initialize ------------------------------------ -.. cpp:function:: virtual void BackgroundSubtractorMOG2::initialize(Size frameSize, int frameType) +.. ocv:function:: virtual void BackgroundSubtractorMOG2::initialize(Size frameSize, int frameType) Re-initiaization method. @@ -531,7 +531,7 @@ BackgroundSubtractorMOG2::initialize BackgroundSubtractorMOG2::getBackgroundImage -------------------------------------------- -.. cpp:function:: virtual void BackgroundSubtractorMOG2::getBackgroundImage(OutputArray backgroundImage) const +.. ocv:function:: virtual void BackgroundSubtractorMOG2::getBackgroundImage(OutputArray backgroundImage) const Computes a background image which are the mean of all background gaussians. -- 2.7.4