OpenCV.lvlib:calcOpticalFlowFarneback.vi

calcOpticalFlowFarneback

prev : first 8-bit single-channel input image.

next : second input image of the same size and the same type as ``prev``.

flow : computed flow image that has the same size as ``prev`` and type ``CV_32FC2``.

pyr_scale : parameter, specifying the image scale (<1) to build pyramids for each image; ``pyr_scale=0.5`` means a classical pyramid, where each next layer is twice smaller than the previous one.

levels : number of pyramid layers including the initial image; ``levels=1`` means that no extra layers are created and only the original images are used.

winsize : averaging window size; larger values increase the algorithm robustness to image noise and give more chances for fast motion detection, but yield more blurred motion field.

iterations : number of iterations the algorithm does at each pyramid level.

poly_n : size of the pixel neighborhood used to find polynomial expansion in each pixel; larger values mean that the image will be approximated with smoother surfaces, yielding more robust algorithm and more blurred motion field, typically ``poly_n`` =5 or 7.

poly_sigma : standard deviation of the Gaussian that is used to smooth derivatives used as a basis for the polynomial expansion; for ``poly_n=5``, you can set ``poly_sigma=1.1``, for ``poly_n=7``, a good value would be ``poly_sigma=1.5``.

flags : operation flags that can be a combination of the following:

* **OPTFLOW_USE_INITIAL_FLOW** uses the input ``flow`` as an initial flow approximation.

* **OPTFLOW_FARNEBACK_GAUSSIAN** uses the Gaussian :math:`\texttt{winsize}\times\texttt{winsize}` filter instead of a box filter of the same size for optical flow estimation; usually, this option gives z more accurate flow than with a box filter, at the cost of lower speed; normally, ``winsize`` for a Gaussian window should be set to a larger value to achieve the same level of robustness.

The function finds an optical flow for each ``prev`` pixel using the [Farneback2003]_ algorithm so that

.. math::

\texttt{prev} (y,x) \sim \texttt{next} ( y + \texttt{flow} (y,x)[1], x + \texttt{flow} (y,x)[0])

OpenCV.lvlib:calcOpticalFlowFarneback.vi

cdbl

pyr_scale

double

ci32

levels

int

ci32

winsize

int

ci32

iterations

int

ci32

poly_n

int

cdbl

poly_sigma

double

ci32

flags

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Unsigned_Matrixlvclass

prev

cOpenCV_lvlib_Unsigned_Matrixlvclass

next

cOpenCV_lvlib_Matlvclass

flow

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Unsigned_Matrixlvclass

next out

i2dnclst

output array

iOpenCV_lvlib_Matlvclass

flow out

OpenCV.lvlib:calcOpticalFlowPyrLK.vi

calcOpticalFlowPyrLK

prevImg : first 8-bit input image or pyramid constructed by :ocv:func:`buildOpticalFlowPyramid`.

nextImg : second input image or pyramid of the same size and the same type as ``prevImg``.

prevPts : vector of 2D points for which the flow needs to be found; point coordinates must be single-precision floating-point numbers.

nextPts : output vector of 2D points (with single-precision floating-point coordinates) containing the calculated new positions of input features in the second image; when ``OPTFLOW_USE_INITIAL_FLOW`` flag is passed, the vector must have the same size as in the input.

status : output status vector (of unsigned chars); each element of the vector is set to 1 if the flow for the corresponding features has been found, otherwise, it is set to 0.

err : output vector of errors; each element of the vector is set to an error for the corresponding feature, type of the error measure can be set in ``flags`` parameter; if the flow wasn't found then the error is not defined (use the ``status`` parameter to find such cases).

winSize : size of the search window at each pyramid level.

maxLevel : 0-based maximal pyramid level number; if set to 0, pyramids are not used (single level), if set to 1, two levels are used, and so on; if pyramids are passed to input then algorithm will use as many levels as pyramids have but no more than ``maxLevel``.

criteria : parameter, specifying the termination criteria of the iterative search algorithm (after the specified maximum number of iterations ``criteria.maxCount`` or when the search window moves by less than ``criteria.epsilon``.

flags : operation flags:

minEigThreshold : the algorithm calculates the minimum eigen value of a 2x2 normal matrix of optical flow equations (this matrix is called a spatial gradient matrix in [Bouguet00]_), divided by number of pixels in a window; if this value is less than ``minEigThreshold``, then a corresponding feature is filtered out and its flow is not processed, so it allows to remove bad points and get a performance boost.

The function implements a sparse iterative version of the Lucas-Kanade optical flow in pyramids. See [Bouguet00]_. The function is parallelized with the TBB library.

OpenCV.lvlib:calcOpticalFlowPyrLK.vi

ci32

maxLevel

int

ci32

flags

int

cdbl

minEigThreshold

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cnclst

TermCriteria

cnclst

winSize

cOpenCV_lvlib_vecPoints2flvclass

prevPts

cOpenCV_lvlib_vecPoints2flvclass

nextPts

cOpenCV_lvlib_Unsigned_Matrixlvclass

PrevImg

cOpenCV_lvlib_Unsigned_Matrixlvclass

nextImg

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Unsigned_Matrixlvclass

nextImg

iOpenCV_lvlib_vecPoints2flvclass

nextPts

OpenCV.lvlib:drawContours.vi

drawContours

----------------------------

Draws contours outlines or filled contours.

image : Destination image.

contours : All the input contours. Each contour is stored as a point vector.

contourIdx : Parameter indicating a contour to draw. If it is negative, all the contours are drawn.

color : Color of the contours.

thickness : Thickness of lines the contours are drawn with. If it is negative (for example, ``thickness=CV_FILLED`` ), the contour interiors are

drawn.

lineType : Line connectivity. See :ocv:func:`line` for details.

hierarchy : Optional information about hierarchy. It is only needed if you want to draw only some of the contours (see ``maxLevel`` ).

maxLevel : Maximal level for drawn contours. If it is 0, only

the specified contour is drawn. If it is 1, the function draws the contour(s) and all the nested contours. If it is 2, the function draws the contours, all the nested contours, all the nested-to-nested contours, and so on. This parameter is only taken into account when there is ``hierarchy`` available.

offset : Optional contour shift parameter. Shift all the drawn contours by the specified :math:`\texttt{offset}=(dx,dy)` .

contour : Pointer to the first contour.

externalColor : Color of external contours.

holeColor : Color of internal contours (holes).

The function draws contour outlines in the image if

:math:`\texttt{thickness} \ge 0` or fills the area bounded by the contours if

:math:`\texttt{thickness}<0` . The example below shows how to retrieve connected components from the binary image and label them: ::

#include "cv.h"

#include "highgui.h"

using namespace cv;

int main( int argc, char** argv )

{

Mat src;

// the first command-line parameter must be a filename of the binary

// (black-n-white) image

if( argc != 2 || !(src=imread(argv[1], 0)).data)

return -1;

Mat dst = Mat::zeros(src.rows, src.cols, CV_8UC3);

src = src > 1;

namedWindow( "Source", 1 );

imshow( "Source", src );

vector > contours;

vector hierarchy;

findContours( src, contours, hierarchy,

CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );

// iterate through all the top-level contours,

// draw each connected component with its own random color

int idx = 0;

for( ; idx >= 0; idx = hierarchy[idx][0] )

{

Scalar color( rand()&255, rand()&255, rand()&255 );

drawContours( dst, contours, idx, color, CV_FILLED, 8, hierarchy );

}

namedWindow( "Components", 1 );

imshow( "Components", dst );

waitKey(0);

}

OpenCV.lvlib:drawContours.vi

ci32

contourIdx

int

ci32

thickness

int

ci32

lineType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

image

cOpenCV_lvlib_Contourslvclass

contours

cu32

Color

cOpenCV_lvlib_OpenCVclasslvclass

hierarchy

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

image out

OpenCV.lvlib:findContours.vi

findContours

--------------------------

Finds contours in a binary image.

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.

contours : Detected contours. Each contour is stored as a vector of points.

hierarchy : Optional output vector, containing information about the image topology. It has as many elements as the number of contours. For each i-th contour ``contours[i]`` , the elements ``hierarchy[i][0]`` , ``hiearchy[i][1]`` , ``hiearchy[i][2]`` , and ``hiearchy[i][3]`` are set to 0-based indices in ``contours`` of the next and previous contours at the same hierarchical level, the first child contour and the parent contour, respectively. If for the contour ``i`` there are no next, previous, parent, or nested contours, the corresponding elements of ``hierarchy[i]`` will be negative.

mode : Contour retrieval mode (if you use Python see also a note below).

method : Contour approximation method (if you use Python see also a note below).

offset : Optional offset by which every contour point is shifted. This is useful if the contours are extracted from the image ROI and then they should be analyzed in the whole image context.

The function retrieves contours from the binary image using the algorithm

[Suzuki85]_. The contours are a useful tool for shape analysis and object detection and recognition. See ``squares.c`` in the OpenCV sample directory.

.. note:: Source ``image`` is modified by this function. Also, the function does not take into account 1-pixel border of the image (it's filled with 0's and used for neighbor analysis in the algorithm), therefore the contours touching the image border will be clipped.

.. note:: If you use the new Python interface then the ``CV_`` prefix has to be omitted in contour retrieval mode and contour approximation method parameters (for example, use ``cv2.RETR_LIST`` and ``cv2.CHAIN_APPROX_NONE`` parameters). If you use the old Python interface then these parameters have the ``CV_`` prefix (for example, use ``cv.CV_RETR_LIST`` and ``cv.CV_CHAIN_APPROX_NONE``).

OpenCV.lvlib:findContours.vi

ci32

mode

int

ci32

method

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_ImageGraylvclass

image

cnclst

offset

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

i1dcclst

contours

i2du8

hierarchy

iOpenCV_lvlib_Contourslvclass

contours out

iOpenCV_lvlib_Unsigned_Matrixlvclass

hierarchy out

OpenCV.lvlib:putText.vi

putText

-----------------------

Draws a text string.

img : Image.

text : Text string to be drawn.

org : Bottom-left corner of the text string in the image.

font : ``CvFont`` structure initialized using :ocv:cfunc:`InitFont`.

fontFace : Font type. One of ``FONT_HERSHEY_SIMPLEX``, ``FONT_HERSHEY_PLAIN``, ``FONT_HERSHEY_DUPLEX``, ``FONT_HERSHEY_COMPLEX``, ``FONT_HERSHEY_TRIPLEX``, ``FONT_HERSHEY_COMPLEX_SMALL``, ``FONT_HERSHEY_SCRIPT_SIMPLEX``, or ``FONT_HERSHEY_SCRIPT_COMPLEX``,

where each of the font ID's can be combined with ``FONT_HERSHEY_ITALIC`` to get the slanted letters.

fontScale : Font scale factor that is multiplied by the font-specific base size.

color : Text color.

thickness : Thickness of the lines used to draw a text.

lineType : Line type. See the ``line`` for details.

bottomLeftOrigin : When true, the image data origin is at the bottom-left corner. Otherwise, it is at the top-left corner.

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

:ocv:func:`getTextSize` for a text rendering code example.

OpenCV.lvlib:putText.vi

cstr

text

int

ci32

fontFace

int

cdbl

fontScale

double

ci32

thickness

int

ci32

lineType

int

cbool

bottomLeftOrigin

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_ImageRGBlvclass

img

cnclst

org

cu32

Color

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_ImageRGBlvclass

img out

OpenCV.lvlib:rectangle.vi

rectangle

-------------------

Draws a simple, thick, or filled up-right rectangle.

img : Image.

pt1 : Vertex of the rectangle.

pt2 : Vertex of the rectangle opposite to ``pt1`` .

rec : Alternative specification of the drawn rectangle.

color : Rectangle color or brightness (grayscale image).

thickness : Thickness of lines that make up the rectangle. Negative values, like ``CV_FILLED`` , mean that the function has to draw a filled rectangle.

lineType : Type of the line. See the :ocv:func:`line` description.

shift : Number of fractional bits in the point coordinates.

The function ``rectangle`` draws a rectangle outline or a filled rectangle whose two opposite corners are ``pt1`` and ``pt2``, or ``r.tl()`` and ``r.br()-Point(1,1)``.

OpenCV.lvlib:rectangle.vi

ci32

thickness

int

ci32

lineType

int

ci32

shift

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

img

cnclst

pt1

cnclst

pt2

cu32

Color

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

img out

OpenCV.lvlib:line.vi

line

-----------------

Draws a line segment connecting two points.

img : Image.

pt1 : First point of the line segment.

pt2 : Second point of the line segment.

color : Line color.

thickness : Line thickness.

lineType : Type of the line:

shift : Number of fractional bits in the point coordinates.

The function ``line`` draws the line segment between ``pt1`` and ``pt2`` points in the image. The line is clipped by the image boundaries. For non-antialiased lines with integer coordinates, the 8-connected or 4-connected Bresenham algorithm is used. Thick lines are drawn with rounding endings.

Antialiased lines are drawn using Gaussian filtering. To specify the line color, you may use the macro ``CV_RGB(r, g, b)`` .

OpenCV.lvlib:line.vi

ci32

thickness

int

ci32

lineType

int

ci32

shift

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

img

cnclst

pt1

cnclst

pt2

cu32

Color

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

img out

OpenCV.lvlib:FillConvexPoly.vi

fillConvexPoly

------------------------

Fills a convex polygon.

img – Image.

pts – Polygon vertices.

npts – Number of polygon vertices.

color – Polygon color.

lineType – Type of the polygon boundaries. See the line() description.

shift – Number of fractional bits in the vertex coordinates.

The function fillConvexPoly draws a filled convex polygon. This function is much faster than the function fillPoly . It can fill not only convex polygons but any monotonic polygon without self-intersections, that is, a polygon whose contour intersects every horizontal line (scan line) twice at the most (though, its top-most and/or the bottom edge could be horizontal).

OpenCV.lvlib:FillConvexPoly.vi

ci32

lineType

int

ci32

shift

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

img

cu32

Color

c1dnclst

pts

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

img out

OpenCV.lvlib:ellipse.vi

ellipse

------------------

Draws a simple or thick elliptic arc or fills an ellipse sector.

img : Image.

center : Center of the ellipse.

axes : Length of the ellipse axes.

angle : Ellipse rotation angle in degrees.

startAngle : Starting angle of the elliptic arc in degrees.

endAngle : Ending angle of the elliptic arc in degrees.

box : Alternative ellipse representation via :ocv:class:`RotatedRect` or ``CvBox2D``. This means that the function draws an ellipse inscribed in the rotated rectangle.

color : Ellipse color.

thickness : Thickness of the ellipse arc outline, if positive. Otherwise, this indicates that a filled ellipse sector is to be drawn.

lineType : Type of the ellipse boundary. See the :ocv:func:`line` description.

shift : Number of fractional bits in the coordinates of the center and values of axes.

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

: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 figure below explains the meaning of the parameters.

**Figure 1. Parameters of Elliptic Arc**

.. image:: pics/ellipse.png

OpenCV.lvlib:ellipse.vi

cdbl

angle

double

cdbl

startAngle

double

cdbl

endAngle

double

ci32

thickness

int

ci32

lineType

int

ci32

shift

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

img

cnclst

center

cnclst

axes

cu32

Color

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

img out

OpenCV.lvlib:circle.vi

circle

img : Image where the circle is drawn.

center : Center of the circle.

radius : Radius of the circle.

color : Circle color.

thickness : Thickness of the circle outline, if positive. Negative thickness means that a filled circle is to be drawn.

lineType : Type of the circle boundary. See the :ocv:func:`line` description.

shift : Number of fractional bits in the coordinates of the center and in the radius value.

The function ``circle`` draws a simple or filled circle with a given center and radius.

OpenCV.lvlib:circle.vi

ci32

radius

int

ci32

thickness

int

ci32

lineType

int

ci32

shift

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

img

cnclst

center

cu32

Color

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

img out

OpenCV.lvlib:calcBackProject.vi

calcBackProject

images : Source arrays. They all should have the same depth, ``CV_8U`` or ``CV_32F`` , and the same size. Each of them can have an arbitrary number of channels.

nimages(set as 1) : Number of source images.

channels : The list of channels used to compute the back projection. The number of channels must match the histogram dimensionality. The first array channels are numerated from 0 to ``images[0].channels()-1`` , the second array channels are counted from ``images[0].channels()`` to ``images[0].channels() + images[1].channels()-1``, and so on.

hist : Input histogram that can be dense or sparse.

backProject : Destination back projection array that is a single-channel array of the same size and depth as ``images[0]`` .

ranges : Array of arrays of the histogram bin boundaries in each dimension. See :ocv:func:`calcHist` .

scale : Optional scale factor for the output back projection.

uniform : Flag indicating whether the histogram is uniform or not (see above).

The functions ``calcBackProject`` calculate the back project of the histogram. That is, similarly to ``calcHist`` , at each location ``(x, y)`` the function collects the values from the selected channels in the input images and finds the corresponding histogram bin. But instead of incrementing it, the function reads the bin value, scales it by ``scale`` , and stores in ``backProject(x,y)`` . In terms of statistics, the function computes probability of each element value in respect with the empirical probability distribution represented by the histogram. See how, for example, you can find and track a bright-colored object in a scene:

#.

Before tracking, show the object to the camera so that it covers almost the whole frame. Calculate a hue histogram. The histogram may have strong maximums, corresponding to the dominant colors in the object.

#.

When tracking, calculate a back projection of a hue plane of each input video frame using that pre-computed histogram. Threshold the back projection to suppress weak colors. It may also make sense to suppress pixels with non-sufficient color saturation and too dark or too bright pixels.

#.

Find connected components in the resulting picture and choose, for example, the largest component.

This is an approximate algorithm of the

:ocv:func:`CamShift` color object tracker.

.. seealso:: :ocv:func:`calcHist`

.. _compareHist:

OpenCV.lvlib:calcBackProject.vi

cdbl

scale

double

cbool

uniform

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

images

c1di32

channels

int

cOpenCV_lvlib_Matlvclass

hist

c2dsgl

ranges

float

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

hist out

iOpenCV_lvlib_Matlvclass

backProject out

OpenCV.lvlib:equalizeHist.vi

equalizeHist

src : Source 8-bit single channel image.

dst : Destination image of the same size and type as ``src`` .

The function equalizes the histogram of the input image using the following algorithm:

#.

Calculate the histogram

:math:`H` for ``src`` .

#.

Normalize the histogram so that the sum of histogram bins is 255.

#.

Compute the integral of the histogram:

.. math::

H'_i = \sum _{0 \le j < i} H(j)

#.

Transform the image using

:math:`H'` as a look-up table:

:math:`\texttt{dst}(x,y) = H'(\texttt{src}(x,y))`

The algorithm normalizes the brightness and increases the contrast of the image.

Extra Histogram Functions (C API)

---------------------------------

The rest of the section describes additional C functions operating on ``CvHistogram``.

OpenCV.lvlib:equalizeHist.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Unsigned_Matrixlvclass

src

cOpenCV_lvlib_Unsigned_Matrixlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Unsigned_Matrixlvclass

dst out

OpenCV.lvlib:calcHist.vi

calcHist

nimages (set as 1) : Source arrays. They all should have the same depth, ``CV_8U`` or ``CV_32F`` , and the same size. Each of them can have an arbitrary number of channels.

images : Number of source images.

channels : List of the ``dims`` channels used to compute the histogram. The first array channels are numerated from 0 to ``images[0].channels()-1`` , the second array channels are counted from ``images[0].channels()`` to ``images[0].channels() + images[1].channels()-1``, and so on.

mask : Optional mask. If the matrix is not empty, it must be an 8-bit array of the same size as ``images[i]`` . The non-zero mask elements mark the array elements counted in the histogram.

hist : Output histogram, which is a dense or sparse ``dims`` -dimensional array.

dims : Histogram dimensionality that must be positive and not greater than ``CV_MAX_DIMS`` (equal to 32 in the current OpenCV version).

histSize : Array of histogram sizes in each dimension.

ranges : Array of the ``dims`` arrays of the histogram bin boundaries in each dimension. When the histogram is uniform ( ``uniform`` =true), then for each dimension ``i`` it is enough to specify the lower (inclusive) boundary :math:`L_0` of the 0-th histogram bin and the upper (exclusive) boundary :math:`U_{\texttt{histSize}[i]-1}` for the last histogram bin ``histSize[i]-1`` . That is, in case of a uniform histogram each of ``ranges[i]`` is an array of 2 elements. When the histogram is not uniform ( ``uniform=false`` ), then each of ``ranges[i]`` contains ``histSize[i]+1`` elements: :math:`L_0, U_0=L_1, U_1=L_2, ..., U_{\texttt{histSize[i]}-2}=L_{\texttt{histSize[i]}-1}, U_{\texttt{histSize[i]}-1}` . The array elements, that are not between :math:`L_0` and :math:`U_{\texttt{histSize[i]}-1}` , are not counted in the histogram.

uniform : Flag indicating whether the histogram is uniform or not (see above).

accumulate : Accumulation flag. If it is set, the histogram is not cleared in the beginning when it is allocated. This feature enables you to compute a single histogram from several sets of arrays, or to update the histogram in time.

The functions ``calcHist`` calculate the histogram of one or more

arrays. The elements of a tuple used to increment

a histogram bin are taken from the corresponding

input arrays at the same location. The sample below shows how to compute a 2D Hue-Saturation histogram for a color image. ::

#include

#include

using namespace cv;

int main( int argc, char** argv )

{

Mat src, hsv;

if( argc != 2 || !(src=imread(argv[1], 1)).data )

return -1;

cvtColor(src, hsv, CV_BGR2HSV);

// Quantize the hue to 30 levels

// and the saturation to 32 levels

int hbins = 30, sbins = 32;

int histSize[] = {hbins, sbins};

// hue varies from 0 to 179, see cvtColor

float hranges[] = { 0, 180 };

// saturation varies from 0 (black-gray-white) to

// 255 (pure spectrum color)

float sranges[] = { 0, 256 };

const float* ranges[] = { hranges, sranges };

MatND hist;

// we compute the histogram from the 0-th and 1-st channels

int channels[] = {0, 1};

calcHist( &hsv, 1, channels, Mat(), // do not use mask

hist, 2, histSize, ranges,

true, // the histogram is uniform

false );

double maxVal=0;

minMaxLoc(hist, 0, &maxVal, 0, 0);

int scale = 10;

Mat histImg = Mat::zeros(sbins*scale, hbins*10, CV_8UC3);

for( int h = 0; h < hbins; h++ )

for( int s = 0; s < sbins; s++ )

{

float binVal = hist.at(h, s);

int intensity = cvRound(binVal*255/maxVal);

rectangle( histImg, Point(h*scale, s*scale),

Point( (h+1)*scale - 1, (s+1)*scale - 1),

Scalar::all(intensity),

CV_FILLED );

}

namedWindow( "Source", 1 );

imshow( "Source", src );

namedWindow( "H-S Histogram", 1 );

imshow( "H-S Histogram", histImg );

waitKey();

}

OpenCV.lvlib:calcHist.vi

cOpenCV_lvlib_Matlvclass

images

c1di32

channels

int

cOpenCV_lvlib_Unsigned_Matrixlvclass

mask

cOpenCV_lvlib_Matlvclass

hist

c1di32

histsize

int

c2dsgl

ranges

float

cbool

uniform

cbool

accumulate

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

i1di32

histSize

iOpenCV_lvlib_Matlvclass

hist out

OpenCV.lvlib:kmeans.vi

kmeans

------------------

Finds centers of clusters and groups input samples around the clusters.

samples – Floating-point matrix of input samples, one row per sample.

data – Data for clustering.

cluster_count – Number of clusters to split the set by.

K – Number of clusters to split the set by.

labels – Input/output integer array that stores the cluster indices for every sample.

criteria – The algorithm termination criteria, that is, the maximum number of iterations and/or the desired accuracy. The accuracy is specified as criteria.epsilon. As soon as each of the cluster centers moves by less than criteria.epsilon on some iteration, the algorithm stops.

termcrit – The algorithm termination criteria, that is, the maximum number of iterations and/or the desired accuracy.

attempts – Flag to specify the number of times the algorithm is executed using different initial labellings. The algorithm returns the labels that yield the best compactness (see the last function parameter).

rng – CvRNG state initialized by RNG().

flags –

Flag that can take the following values:

KMEANS_RANDOM_CENTERS Select random initial centers in each attempt.

KMEANS_PP_CENTERS Use kmeans++ center initialization by Arthur and Vassilvitskii [Arthur2007].

KMEANS_USE_INITIAL_LABELS During the first (and possibly the only) attempt, use the user-supplied labels instead of computing them from the initial centers. For the second and further attempts, use the random or semi-random centers. Use one of KMEANS_*_CENTERS flag to specify the exact method.

centers – Output matrix of the cluster centers, one row per each cluster center.

_centers – Output matrix of the cluster centers, one row per each cluster center.

compactness – The returned value that is described below.

The function kmeans implements a k-means algorithm that finds the centers of cluster_count clusters and groups the input samples around the clusters. As an output, \texttt{labels}_i contains a 0-based cluster index for the sample stored in the i^{th} row of the samples matrix.

The function returns the compactness measure that is computed as

\sum _i \| \texttt{samples} _i - \texttt{centers} _{ \texttt{labels} _i} \| ^2

after every attempt. The best (minimum) value is chosen and the corresponding labels and the compactness value are returned by the function. Basically, you can use only the core of the function, set the number of attempts to 1, initialize labels each time using a custom algorithm, pass them with the ( flags = KMEANS_USE_INITIAL_LABELS ) flag, and then choose the best (most-compact) clustering.

OpenCV.lvlib:kmeans.vi

c2dsgl

data

ci32

K

int

ci32

attempts

int

ci32

flags

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cnclst

Criteria

idbl

function return

double

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Float_Matrixlvclass

center

i2dsgl

centers

i1di32

Best Lebels

OpenCV.lvlib:resize.vi

resize

-------------

Resizes an image.

src – input image.

dst– output image; it has the size dsize (when it is non-zero) or the size computed from src.size(), fx, and fy; the type of dst is the same as of src.

dsize –

output image size; if it equals zero, it is computed as:

\texttt{dsize = Size(round(fx*src.cols), round(fy*src.rows))}

Either dsize or both fx and fy must be non-zero.

fx –

scale factor along the horizontal axis; when it equals 0, it is computed as

\texttt{(double)dsize.width/src.cols}

fy –

scale factor along the vertical axis; when it equals 0, it is computed as

\texttt{(double)dsize.height/src.rows}

interpolation –

interpolation method:

INTER_NEAREST - a nearest-neighbor interpolation

INTER_LINEAR - a bilinear interpolation (used by default)

INTER_AREA - resampling using pixel area relation. It may be a preferred method for image decimation, as it gives moire’-free results. But when the image is zoomed, it is similar to the INTER_NEAREST method.

INTER_CUBIC - a bicubic interpolation over 4x4 pixel neighborhood

INTER_LANCZOS4 - a Lanczos interpolation over 8x8 pixel neighborhood

The function resize resizes the image src down to or up to the specified size. Note that the initial dst type or size are not taken into account. Instead, the size and type are derived from the src,``dsize``,``fx`` , and fy . If you want to resize src so that it fits the pre-created dst , you may call the function as follows:

// explicitly specify dsize=dst.size(); fx and fy will be computed from that.

resize(src, dst, dst.size(), 0, 0, interpolation);

If you want to decimate the image by factor of 2 in each direction, you can call the function this way:

// specify fx and fy and let the function compute the destination image size.

resize(src, dst, Size(), 0.5, 0.5, interpolation);

To shrink an image, it will generally look best with CV_INTER_AREA interpolation, whereas to enlarge an image, it will generally look best with CV_INTER_CUBIC (slow) or CV_INTER_LINEAR (faster but still looks OK).

OpenCV.lvlib:resize.vi

cdbl

fx

double

cdbl

fy

double

ci32

interpolation

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

dsize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:remap.vi

Remap

---------

Applies a generic geometrical transformation to an image.

src – Source image.

dst – Destination image. It has the same size as map1 and the same type as src .

map1 – The first map of either (x,y) points or just x values having the type CV_16SC2 , CV_32FC1 , or CV_32FC2 . See convertMaps() for details on converting a floating point representation to fixed-point for speed.

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.

interpolation – Interpolation method (see resize() ). The method INTER_AREA is not supported by this function.

borderMode – Pixel extrapolation method (see 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.

borderValue – Value used in case of a constant border. By default, it is 0.

The function remap transforms the source image using the specified map:

dest(x,y) = src(map_x(x,y),may_y(x,y))

where values of pixels with non-integer coordinates are computed using one of available interpolation methods. map_x and map_y can be encoded as separate floating-point maps in map_1 and map_2 respectively, or interleaved floating-point maps of (x,y) in map_1 , or fixed-point maps created by using 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, map_1 contains pairs (cvFloor(x), cvFloor(y)) and map_2 contains indices in a table of interpolation coefficients.

This function cannot operate in-place.

OpenCV.lvlib:remap.vi

ci32

interpolation

int

ci32

borderMode

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cOpenCV_lvlib_Matlvclass

map1

cOpenCV_lvlib_Matlvclass

map2

cnclst

borderValue

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:getRotationMatrix2D.vi

getRotationMatrix2D

center : Center of the rotation in the source image.

angle : Rotation angle in degrees. Positive values mean counter-clockwise rotation (the coordinate origin is assumed to be the top-left corner).

scale : Isotropic scale factor.

map_matrix : The output affine transformation, 2x3 floating-point matrix.

The function calculates the following matrix:

.. math::

\begin{bmatrix} \alpha & \beta & (1- \alpha ) \cdot \texttt{center.x} - \beta \cdot \texttt{center.y} \\ - \beta & \alpha & \beta \cdot \texttt{center.x} + (1- \alpha ) \cdot \texttt{center.y} \end{bmatrix}

where

.. math::

\begin{array}{l} \alpha = \texttt{scale} \cdot \cos \texttt{angle} , \\ \beta = \texttt{scale} \cdot \sin \texttt{angle} \end{array}

The transformation maps the rotation center to itself. If this is not the target, adjust the shift.

.. seealso::

:ocv:func:`getAffineTransform`,

:ocv:func:`warpAffine`,

:ocv:func:`transform`

OpenCV.lvlib:getRotationMatrix2D.vi

cdbl

angle

double

cdbl

scale

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cnclst

center

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Double_Matrixlvclass

RotationMatrix2D

i2ddbl

RotationMatrix2D

OpenCV.lvlib:getRectSubPix.vi

getRectSubPix

------------------------------

Retrieves a pixel rectangle from an image with sub-pixel accuracy.

src(image) : Source image.

patchSize : Size of the extracted patch.

center : Floating point coordinates of the center of the extracted rectangle within the source image. The center must be inside the image.

dst : Extracted patch that has the size ``patchSize`` and the same number of channels as ``src`` .

patchType : Depth of the extracted pixels. By default, they have the same depth as ``src`` .

The function ``getRectSubPix`` extracts pixels from ``src`` :

.. math::

dst(x, y) = src(x + \texttt{center.x} - ( \texttt{dst.cols} -1)*0.5, y + \texttt{center.y} - ( \texttt{dst.rows} -1)*0.5)

where the values of the pixels at non-integer coordinates are retrieved

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

:ocv:func:`borderInterpolate` ) is used to extrapolate

the pixel values outside of the image.

.. seealso::

:ocv:func:`warpAffine`,

:ocv:func:`warpPerspective`

OpenCV.lvlib:getRectSubPix.vi

cOpenCV_lvlib_Matlvclass

patch

ci16

patchType

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

image

cnclst

center

cnclst

patchSize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

patch out

OpenCV.lvlib:getPerspectiveTransform[Points].vi

getPerspectiveTransform

src : Coordinates of quadrangle vertices in the source image.

dst : Coordinates of the corresponding quadrangle vertices in the destination image.

The function calculates the :math:`3 \times 3` matrix of a perspective transform so that:

.. math::

\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} = \texttt{map\_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}

where

.. math::

dst(i)=(x'_i,y'_i),

src(i)=(x_i, y_i),

i=0,1,2,3

.. seealso::

:ocv:func:`findHomography`,

:ocv:func:`warpPerspective`,

:ocv:func:`perspectiveTransform`

OpenCV.lvlib:getPerspectiveTransform[Points].vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

c1dnclst

src

c1dnclst

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

i2ddbl

value

iOpenCV_lvlib_Double_Matrixlvclass

OpenCV.lvlib:Double Matrix.lvclass

OpenCV.lvlib:getPerspectiveTransform[Matrix].vi

getPerspectiveTransform

src : Coordinates of quadrangle vertices in the source image.

dst : Coordinates of the corresponding quadrangle vertices in the destination image.

The function calculates the :math:`3 \times 3` matrix of a perspective transform so that:

.. math::

\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} = \texttt{map\_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}

where

.. math::

dst(i)=(x'_i,y'_i),

src(i)=(x_i, y_i),

i=0,1,2,3

.. seealso::

:ocv:func:`findHomography`,

:ocv:func:`warpPerspective`,

:ocv:func:`perspectiveTransform`

OpenCV.lvlib:getPerspectiveTransform[Matrix].vi

c2dsgl

dst

c2dsgl

src

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

i2ddbl

value

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Double_Matrixlvclass

PerspectiveTransform

OpenCV.lvlib:getPerspectiveTransform[Mat].vi

getPerspectiveTransform

src : Coordinates of quadrangle vertices in the source image.

dst : Coordinates of the corresponding quadrangle vertices in the destination image.

The function calculates the :math:`3 \times 3` matrix of a perspective transform so that:

.. math::

\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} = \texttt{map\_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}

where

.. math::

dst(i)=(x'_i,y'_i),

src(i)=(x_i, y_i),

i=0,1,2,3

.. seealso::

:ocv:func:`findHomography`,

:ocv:func:`warpPerspective`,

:ocv:func:`perspectiveTransform`

OpenCV.lvlib:getPerspectiveTransform[Mat].vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Double_Matrixlvclass

PerspectiveTransform

OpenCV.lvlib:getPerspectiveTransform.vi

getPerspectiveTransform

-----------------------------

Calculates a perspective transform from four pairs of the corresponding points.

src : Coordinates of quadrangle vertices in the source image.

dst : Coordinates of the corresponding quadrangle vertices in the destination image.

The function calculates the :math:`3 \times 3` matrix of a perspective transform so that:

.. math::

\begin{bmatrix} t_i x'_i \\ t_i y'_i \\ t_i \end{bmatrix} = \texttt{map\_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}

where

.. math::

dst(i)=(x'_i,y'_i),

src(i)=(x_i, y_i),

i=0,1,2,3

.. seealso::

:ocv:func:`findHomography`,

:ocv:func:`warpPerspective`,

:ocv:func:`perspectiveTransform`

OpenCV.lvlib:getPerspectiveTransform.vi


OpenCV.lvlib:warpPerspective[Matrix].vi

warpPerspective

src : input image.

dst : output image that has the size ``dsize`` and the same type as ``src`` .

M : :math:`3\times 3` transformation matrix.

dsize : size of the output image.

flags : combination of interpolation methods (``INTER_LINEAR`` or ``INTER_NEAREST``) and the optional flag ``WARP_INVERSE_MAP``, that sets ``M`` as the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ).

borderMode : pixel extrapolation method (``BORDER_CONSTANT`` or ``BORDER_REPLICATE``).

borderValue : value used in case of a constant border; by default, it equals 0.

The function ``warpPerspective`` transforms the source image using the specified matrix:

.. math::

\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} ,

\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

:ocv:func:`invert` and then put in the formula above instead of ``M`` .

The function cannot operate in-place.

.. seealso::

:ocv:func:`warpAffine`,

:ocv:func:`resize`,

:ocv:func:`remap`,

:ocv:func:`getRectSubPix`,

:ocv:func:`perspectiveTransform`

OpenCV.lvlib:warpPerspective[Matrix].vi

ci32

flags

int

ci32

borderMode

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

dsize

cnclst

borderValue

c2ddbl

M

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:warpPerspective[Mat].vi

warpPerspective

src : input image.

dst : output image that has the size ``dsize`` and the same type as ``src`` .

M : :math:`3\times 3` transformation matrix.

dsize : size of the output image.

flags : combination of interpolation methods (``INTER_LINEAR`` or ``INTER_NEAREST``) and the optional flag ``WARP_INVERSE_MAP``, that sets ``M`` as the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ).

borderMode : pixel extrapolation method (``BORDER_CONSTANT`` or ``BORDER_REPLICATE``).

borderValue : value used in case of a constant border; by default, it equals 0.

The function ``warpPerspective`` transforms the source image using the specified matrix:

.. math::

\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} ,

\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

:ocv:func:`invert` and then put in the formula above instead of ``M`` .

The function cannot operate in-place.

.. seealso::

:ocv:func:`warpAffine`,

:ocv:func:`resize`,

:ocv:func:`remap`,

:ocv:func:`getRectSubPix`,

:ocv:func:`perspectiveTransform`

OpenCV.lvlib:warpPerspective[Mat].vi

ci32

flags

int

ci32

borderMode

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cOpenCV_lvlib_Double_Matrixlvclass

M

cnclst

dsize

cnclst

borderValue

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:warpPerspective.vi

warpPerspective

src : input image.

dst : output image that has the size ``dsize`` and the same type as ``src`` .

M : :math:`3\times 3` transformation matrix.

dsize : size of the output image.

flags : combination of interpolation methods (``INTER_LINEAR`` or ``INTER_NEAREST``) and the optional flag ``WARP_INVERSE_MAP``, that sets ``M`` as the inverse transformation ( :math:`\texttt{dst}\rightarrow\texttt{src}` ).

borderMode : pixel extrapolation method (``BORDER_CONSTANT`` or ``BORDER_REPLICATE``).

borderValue : value used in case of a constant border; by default, it equals 0.

The function ``warpPerspective`` transforms the source image using the specified matrix:

.. math::

\texttt{dst} (x,y) = \texttt{src} \left ( \frac{M_{11} x + M_{12} y + M_{13}}{M_{31} x + M_{32} y + M_{33}} ,

\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

:ocv:func:`invert` and then put in the formula above instead of ``M`` .

The function cannot operate in-place.

.. seealso::

:ocv:func:`warpAffine`,

:ocv:func:`resize`,

:ocv:func:`remap`,

:ocv:func:`getRectSubPix`,

:ocv:func:`perspectiveTransform`

OpenCV.lvlib:warpPerspective.vi


OpenCV.lvlib:getAffineTransform[Pointes].vi

getAffineTransform

src : Coordinates of triangle vertices in the source image.

dst : Coordinates of the corresponding triangle vertices in the destination image.

The function calculates the :math:`2 \times 3` matrix of an affine transform so that:

.. math::

\begin{bmatrix} x'_i \\ y'_i \end{bmatrix} = \texttt{map\_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}

where

.. math::

dst(i)=(x'_i,y'_i),

src(i)=(x_i, y_i),

i=0,1,2

.. seealso::

:ocv:func:`warpAffine`,

:ocv:func:`transform`

OpenCV.lvlib:getAffineTransform[Pointes].vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

c1dnclst

src

c1dnclst

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

i2ddbl

AffineTransform matrix

iOpenCV_lvlib_Double_Matrixlvclass

AffineTransform

OpenCV.lvlib:getAffineTransform[Mat].vi

getAffineTransform

src : Coordinates of triangle vertices in the source image.

dst : Coordinates of the corresponding triangle vertices in the destination image.

The function calculates the :math:`2 \times 3` matrix of an affine transform so that:

.. math::

\begin{bmatrix} x'_i \\ y'_i \end{bmatrix} = \texttt{map\_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}

where

.. math::

dst(i)=(x'_i,y'_i),

src(i)=(x_i, y_i),

i=0,1,2

.. seealso::

:ocv:func:`warpAffine`,

:ocv:func:`transform`

OpenCV.lvlib:getAffineTransform[Mat].vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

c2ddbl

dst

c2ddbl

src

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

i2ddbl

AffineTransform matrix

iOpenCV_lvlib_Double_Matrixlvclass

AffineTransform

OpenCV.lvlib:getAffineTransform.vi

getAffineTransform

src : Coordinates of triangle vertices in the source image.

dst : Coordinates of the corresponding triangle vertices in the destination image.

The function calculates the :math:`2 \times 3` matrix of an affine transform so that:

.. math::

\begin{bmatrix} x'_i \\ y'_i \end{bmatrix} = \texttt{map\_matrix} \cdot \begin{bmatrix} x_i \\ y_i \\ 1 \end{bmatrix}

where

.. math::

dst(i)=(x'_i,y'_i),

src(i)=(x_i, y_i),

i=0,1,2

.. seealso::

:ocv:func:`warpAffine`,

:ocv:func:`transform`

OpenCV.lvlib:getAffineTransform.vi


OpenCV.lvlib:warpAffine[Mat].vi

warpAffine

src : input image.

dst : output image that has the size ``dsize`` and the same type as ``src`` .

M : :math:`2\times 3` transformation matrix.

dsize : size of the output image.

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}` ).

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.

borderValue : value used in case of a constant border; by default, it is 0.

The function ``warpAffine`` transforms the source image using the specified matrix:

.. math::

\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

:ocv:func:`invertAffineTransform` and then put in the formula above instead of ``M`` .

The function cannot operate in-place.

.. seealso::

:ocv:func:`warpPerspective`,

:ocv:func:`resize`,

:ocv:func:`remap`,

:ocv:func:`getRectSubPix`,

:ocv:func:`transform`

.. note:: ``cvGetQuadrangleSubPix`` is similar to ``cvWarpAffine``, but the outliers are extrapolated using replication border mode.

OpenCV.lvlib:warpAffine[Mat].vi

ci32

flags

int

ci32

borderMode

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cOpenCV_lvlib_Double_Matrixlvclass

M

cnclst

dsize

cnclst

borderValue

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:warpAffine[Matrix].vi

warpAffine

src : input image.

dst : output image that has the size ``dsize`` and the same type as ``src`` .

M : :math:`2\times 3` transformation matrix.

dsize : size of the output image.

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}` ).

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.

borderValue : value used in case of a constant border; by default, it is 0.

The function ``warpAffine`` transforms the source image using the specified matrix:

.. math::

\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

:ocv:func:`invertAffineTransform` and then put in the formula above instead of ``M`` .

The function cannot operate in-place.

.. seealso::

:ocv:func:`warpPerspective`,

:ocv:func:`resize`,

:ocv:func:`remap`,

:ocv:func:`getRectSubPix`,

:ocv:func:`transform`

.. note:: ``cvGetQuadrangleSubPix`` is similar to ``cvWarpAffine``, but the outliers are extrapolated using replication border mode.

OpenCV.lvlib:warpAffine[Matrix].vi

ci32

flags

int

ci32

borderMode

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

dsize

cnclst

borderValue

c2ddbl

M

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:warpAffine.vi

warpAffine

-----------------------

Applies an affine transformation to an image.

src : input image.

dst : output image that has the size ``dsize`` and the same type as ``src`` .

M : :math:`2\times 3` transformation matrix.

dsize : size of the output image.

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}` ).

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.

borderValue : value used in case of a constant border; by default, it is 0.

The function ``warpAffine`` transforms the source image using the specified matrix:

.. math::

\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

:ocv:func:`invertAffineTransform` and then put in the formula above instead of ``M`` .

The function cannot operate in-place.

.. seealso::

:ocv:func:`warpPerspective`,

:ocv:func:`resize`,

:ocv:func:`remap`,

:ocv:func:`getRectSubPix`,

:ocv:func:`transform`

.. note:: ``cvGetQuadrangleSubPix`` is similar to ``cvWarpAffine``, but the outliers are extrapolated using replication border mode.

OpenCV.lvlib:warpAffine.vi


OpenCV.lvlib:VideoCapture.vi

VideoCapture

class:: VideoCapture

Class for video capturing from video files or cameras.

The class provides C++ API for capturing video from cameras or for reading video files. Here is how the class can be used: ::

#include "opencv2/opencv.hpp"

using namespace cv;

int main(int, char**)

{

VideoCapture cap(0); // open the default camera

if(!cap.isOpened()) // check if we succeeded

return -1;

Mat edges;

namedWindow("edges",1);

for(;;)

{

Mat frame;

cap >> frame; // get a new frame from camera

cvtColor(frame, edges, CV_BGR2GRAY);

GaussianBlur(edges, edges, Size(7,7), 1.5, 1.5);

Canny(edges, edges, 0, 30, 3);

imshow("edges", edges);

if(waitKey(30) >= 0) break;

}

// the camera will be deinitialized automatically in VideoCapture destructor

return 0;

}

.. note:: In C API the black-box structure ``CvCapture`` is used instead of ``VideoCapture``.

OpenCV.lvlib:VideoCapture.vi

cpath

filename

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_VideoCapturelvclass

VideoCapture

OpenCV.lvlib:VideoCaptureread.vi

VideoCapture::open

---------------------

Open video file or a capturing device for video capturing

The methods/functions combine VideoCapture::grab() and VideoCapture::retrieve() in one call. This is the most convenient method for reading video files or capturing data from decode and return the just grabbed frame. If no frames has been grabbed (camera has been disconnected, or there are no more frames in video file), the methods return false and the functions return NULL pointer.

OpenCV.lvlib:VideoCaptureread.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_VideoCapturelvclass

videoCaptureRead

cOpenCV_lvlib_Matlvclass

image

ibool

function return

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_VideoCapturelvclass

videoCaptureRead

iOpenCV_lvlib_Matlvclass

image

OpenCV.lvlib:imwrite.vi

imwrite

------------------

Saves an image to a specified file.

filename(path) : Name of the file.

image(img) : Image to be saved

params : Format-specific save parameters encoded as pairs ``paramId_1, paramValue_1, paramId_2, paramValue_2, ...`` . The following parameters are currently supported:

* For JPEG, it can be a quality ( ``CV_IMWRITE_JPEG_QUALITY`` ) from 0 to 100 (the higher is the better). Default value is 95.

* For PNG, it can be the compression level ( ``CV_IMWRITE_PNG_COMPRESSION`` ) from 0 to 9. A higher value means a smaller size and longer compression time. Default value is 3.

* For PPM, PGM, or PBM, it can be a binary format flag ( ``CV_IMWRITE_PXM_BINARY`` ), 0 or 1. Default value is 1.

The function ``imwrite`` saves the image to the specified file. The image format is chosen based on the ``filename`` extension (see

:ocv:func:`imread` for the list of extensions). Only 8-bit (or 16-bit unsigned (``CV_16U``) in case of PNG, JPEG 2000, and TIFF) single-channel or 3-channel (with 'BGR' channel order) images can be saved using this function. If the format, depth or channel order is different, use

:ocv:func:`Mat::convertTo` , and

:ocv:func:`cvtColor` to convert it before saving. Or, use the universal XML I/O functions to save the image to XML or YAML format.

It is possible to store PNG images with an alpha channel using this function. To do this, create 8-bit (or 16-bit) 4-channel image BGRA, where the alpha channel goes last. Fully transparent pixels should have alpha set to 0, fully opaque pixels should have alpha set to 255/65535. The sample below shows how to create such a BGRA image and store to PNG file. It also demonstrates how to set custom compression parameters ::

#include

#include

#include

using namespace cv;

using namespace std;

void createAlphaMat(Mat &mat)

{

for (int i = 0; i < mat.rows; ++i) {

for (int j = 0; j < mat.cols; ++j) {

Vec4b& rgba = mat.at(i, j);

rgba[0] = UCHAR_MAX;

rgba[1] = saturate_cast((float (mat.cols - j)) / ((float)mat.cols) * UCHAR_MAX);

rgba[2] = saturate_cast((float (mat.rows - i)) / ((float)mat.rows) * UCHAR_MAX);

rgba[3] = saturate_cast(0.5 * (rgba[1] + rgba[2]));

}

}

}

int main(int argv, char **argc)

{

// Create mat with alpha channel

Mat mat(480, 640, CV_8UC4);

createAlphaMat(mat);

vector compression_params;

compression_params.push_back(CV_IMWRITE_PNG_COMPRESSION);

compression_params.push_back(9);

try {

imwrite("alpha.png", mat, compression_params);

}

catch (runtime_error& ex) {

fprintf(stderr, "Exception converting image to PNG format: %s\n", ex.what());

return 1;

}

fprintf(stdout, "Saved PNG file with alpha data.\n");

return 0;

}

OpenCV.lvlib:imwrite.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

img

cpath

path

c1dnclst

params

ibool

function return

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.


OpenCV.lvlib:imread.vi

imread

------

Loads an image from a file.

filename(path): Name of file to be loaded.

flags: Flags specifying the color type of a loaded image:

* CV_LOAD_IMAGE_ANYDEPTH - If set, return 16-bit/32-bit image when the input has the corresponding depth, otherwise convert it to 8-bit.

* CV_LOAD_IMAGE_COLOR - If set, always convert image to the color one

* CV_LOAD_IMAGE_GRAYSCALE - If set, always convert image to the grayscale one

* **>0** Return a 3-channel color image.

.. note:: In the current implementation the alpha channel, if any, is stripped from the output image. Use negative value if you need the alpha channel.

* **=0** Return a grayscale image.

* **<0** Return the loaded image as is (with alpha channel).

The function ``imread`` loads an image from the specified file and returns it. If the image cannot be read (because of missing file, improper permissions, unsupported or invalid format), the function returns an empty matrix ( ``Mat::data==NULL`` ). Currently, the following file formats are supported:

* Windows bitmaps - ``*.bmp, *.dib`` (always supported)

* JPEG files - ``*.jpeg, *.jpg, *.jpe`` (see the *Notes* section)

* JPEG 2000 files - ``*.jp2`` (see the *Notes* section)

* Portable Network Graphics - ``*.png`` (see the *Notes* section)

* Portable image format - ``*.pbm, *.pgm, *.ppm`` (always supported)

* Sun rasters - ``*.sr, *.ras`` (always supported)

* TIFF files - ``*.tiff, *.tif`` (see the *Notes* section)

.. note::

* The function determines the type of an image by the content, not by the file extension.

* On Microsoft Windows* OS and MacOSX*, the codecs shipped with an OpenCV image (libjpeg, libpng, libtiff, and libjasper) are used by default. So, OpenCV can always read JPEGs, PNGs, and TIFFs. On MacOSX, there is also an option to use native MacOSX image readers. But beware that currently these native image loaders give images with different pixel values because of the color management embedded into MacOSX.

* On Linux*, BSD flavors and other Unix-like open-source operating systems, OpenCV looks for codecs supplied with an OS image. Install the relevant packages (do not forget the development files, for example, "libjpeg-dev", in Debian* and Ubuntu*) to get the codec support or turn on the ``OPENCV_BUILD_3RDPARTY_LIBS`` flag in CMake.

.. note:: In the case of color images, the decoded images will have the channels stored in ``B G R`` order.

OpenCV.lvlib:imread.vi

ci32

flags

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cpath

path

cOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass in

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass out

OpenCV.lvlib:HoughLinesP.vi

HoughLinesP

---------------------

Finds line segments in a binary image using the probabilistic Hough transform.

image – 8-bit, single-channel binary source image. The image may be modified by the function.

lines – Output vector of lines. Each line is represented by a 4-element vector (x_1, y_1, x_2, y_2) , where (x_1,y_1) and (x_2, y_2) are the ending points of each detected line segment.

rho – Distance resolution of the accumulator in pixels.

theta – Angle resolution of the accumulator in radians.

threshold – Accumulator threshold parameter. Only those lines are returned that get enough votes ( >\texttt{threshold} ).

minLineLength – Minimum line length. Line segments shorter than that are rejected.

maxLineGap – Maximum allowed gap between points on the same line to link them.

OpenCV.lvlib:HoughLinesP.vi

cdbl

rho

double

cdbl

theta

double

ci32

threshold

int

cdbl

minLineLength

double

cdbl

maxLineGap

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

image

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

Lines

i1dcclst

Lines

OpenCV.lvlib:HoughLines.vi

HoughLines

-------------------

Finds lines in a binary image using the standard Hough transform.

image : 8-bit, single-channel binary source image. The image may be modified by the function.

lines : Output vector of lines. Each line is represented by a two-element vector :math:`(\rho, \theta)` . :math:`\rho` is the distance from the coordinate origin :math:`(0,0)` (top-left corner of the image). :math:`\theta` is the line rotation angle in radians ( :math:`0 \sim \textrm{vertical line}, \pi/2 \sim \textrm{horizontal line}` ).

rho : Distance resolution of the accumulator in pixels.

theta : Angle resolution of the accumulator in radians.

threshold : Accumulator threshold parameter. Only those lines are returned that get enough votes ( :math:`>\texttt{threshold}` ).

srn : For the multi-scale Hough transform, it is a divisor for the distance resolution ``rho`` . The coarse accumulator distance resolution is ``rho`` and the accurate accumulator resolution is ``rho/srn`` . If both ``srn=0`` and ``stn=0`` , the classical Hough transform is used. Otherwise, both these parameters should be positive.

stn : For the multi-scale Hough transform, it is a divisor for the distance resolution ``theta``.

method : One of the following Hough transform variants:

* CV_HOUGH_STANDARD classical or standard Hough transform. Every line is represented by two floating-point numbers (\rho, \theta) , where \rho is a distance between (0,0) point and the line, and \theta is the angle between x-axis and the normal to the line. Thus, the matrix must be (the created sequence will be) of CV_32FC2 type

* CV_HOUGH_PROBABILISTIC probabilistic Hough transform (more efficient in case if the picture contains a few long linear segments). It returns line segments rather than the whole line. Each segment is represented by starting and ending points, and the matrix must be (the created sequence will be) of the CV_32SC4 type.

* CV_HOUGH_MULTI_SCALE multi-scale variant of the classical Hough transform. The lines are encoded the same way as CV_HOUGH_STANDARD.

param1 : First method-dependent parameter:

* For the classical Hough transform, it is not used (0).

* For the probabilistic Hough transform, it is the minimum line length.

* For the multi-scale Hough transform, it is srn.

param2 : Second method-dependent parameter:

* For the classical Hough transform, it is not used (0).

* For the probabilistic Hough transform, it is the maximum gap between line segments lying on the same line to treat them as a single line segment (that is, to join them).

* For the multi-scale Hough transform, it is ``stn``.

The function implements the standard or standard multi-scale Hough transform algorithm for line detection. See http://homepages.inf.ed.ac.uk/rbf/HIPR2/hough.htm for a good explanation of Hough transform.

See also the example in :ocv:func:`HoughLinesP` description.

OpenCV.lvlib:HoughLines.vi

cdbl

rho

double

cdbl

theta

double

ci32

threshold

int

cdbl

srn

double

cdbl

stn

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

image

iOpenCV_lvlib_vecVec2flvclass

Lines

i1dnclst

Lines

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.


OpenCV.lvlib:HoughCircles.vi

HoughCircles

image : 8-bit, single-channel, grayscale input image.

circles : Output vector of found circles. Each vector is encoded as a 3-element floating-point vector :math:`(x, y, radius)`.

method : Detection method to use. Currently, the only implemented method is ``CV_HOUGH_GRADIENT`` , which is basically *21HT* , described in [Yuen90]_.

dp : Inverse ratio of the accumulator resolution to the image resolution. For example, if ``dp=1`` , the accumulator has the same resolution as the input image. If ``dp=2`` , the accumulator has half as big width and height.

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.

param1 : 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).

param2 : 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.

minRadius : Minimum circle radius.

maxRadius : Maximum circle radius.

The function finds circles in a grayscale image using a modification of the Hough transform.

Example: ::

#include

#include

#include

using namespace cv;

int main(int argc, char** argv)

{

Mat img, gray;

if( argc != 2 && !(img=imread(argv[1], 1)).data)

return -1;

cvtColor(img, gray, CV_BGR2GRAY);

// smooth it, otherwise a lot of false circles may be detected

GaussianBlur( gray, gray, Size(9, 9), 2, 2 );

vector circles;

HoughCircles(gray, circles, CV_HOUGH_GRADIENT,

2, gray->rows/4, 200, 100 );

for( size_t i = 0; i < circles.size(); i++ )

{

Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));

int radius = cvRound(circles[i][2]);

// draw the circle center

circle( img, center, 3, Scalar(0,255,0), -1, 8, 0 );

// draw the circle outline

circle( img, center, radius, Scalar(0,0,255), 3, 8, 0 );

}

namedWindow( "circles", 1 );

imshow( "circles", img );

return 0;

}

.. 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.

.. seealso::

:ocv:func:`fitEllipse`,

:ocv:func:`minEnclosingCircle`

OpenCV.lvlib:HoughCircles.vi

ci32

method

int

cdbl

dp

double

cdbl

minDist

double

cdbl

param1

double

cdbl

param2

double

ci32

minRadius

int

ci32

maxRadius

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_ImageGraylvclass

image

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

circles

i1dnclst

circles

OpenCV.lvlib:goodFeaturesToTrack.vi

goodFeaturesToTrack

image : Input 8-bit or floating-point 32-bit, single-channel image.

corners : Output vector of detected corners.

maxCorners : Maximum number of corners to return. If there are more corners than are found, the strongest of them is returned.

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.

minDistance : Minimum possible Euclidean distance between the returned corners.

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.

blockSize : Size of an average block for computing a derivative covariation matrix over each pixel neighborhood. See :ocv:func:`cornerEigenValsAndVecs` .

useHarrisDetector : Parameter indicating whether to use a Harris detector (see :ocv:func:`cornerHarris`) or :ocv:func:`cornerMinEigenVal`.

k : Free parameter of the Harris detector.

The function finds the most prominent corners in the image or in the specified image region, as described in [Shi94]_:

#.

Function calculates the corner quality measure at every source image pixel using the

:ocv:func:`cornerMinEigenVal` or

:ocv:func:`cornerHarris` .

#.

Function performs a non-maximum suppression (the local maximums in *3 x 3* neighborhood are retained).

#.

The corners with the minimal eigenvalue less than

:math:`\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)` are rejected.

#.

The remaining corners are sorted by the quality measure in the descending order.

#.

Function throws away each corner for which there is a stronger corner at a distance less than ``maxDistance``.

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`` .

.. seealso::

:ocv:func:`cornerMinEigenVal`,

:ocv:func:`cornerHarris`,

:ocv:func:`calcOpticalFlowPyrLK`,

:ocv:func:`estimateRigidTransform`,

OpenCV.lvlib:goodFeaturesToTrack.vi

cOpenCV_lvlib_Matlvclass

image

ci32

maxCorners

int

cdbl

qualityLevel

double

cdbl

minDistance

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cdbl

k

ci8

useHarrisDetector

ci32

blockSise

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

i1dnclst

Array

iOpenCV_lvlib_vecPoints2flvclass

corners

OpenCV.lvlib:cornerSubPix.vi

cornerSubPix

Refines the corner locations.

image : Input image.

corners : Initial coordinates of the input corners and refined coordinates provided for output.

winSize(size) : Half of the side length of the search window. For example, if ``winSize=Size(5,5)`` , then a :math:`5*2+1 \times 5*2+1 = 11 \times 11` search window is used.

zeroZone : Half of the size of the dead region in the middle of the search zone over which the summation in the formula below is not done. It is used sometimes to avoid possible singularities of the autocorrelation matrix. The value of (-1,-1) indicates that there is no such a size.

criteria(TermCriteria): Criteria for termination of the iterative process of corner refinement. That is, the process of corner position refinement stops either after ``criteria.maxCount`` iterations or when the corner position moves by less than ``criteria.epsilon`` on some iteration.

The function iterates to find the sub-pixel accurate location of corners or radial saddle points, as shown on the figure below.

.. image:: pics/cornersubpix.png

Sub-pixel accurate corner locator is based on the observation that every vector from the center

:math:`q` to a point

:math:`p` located within a neighborhood of

:math:`q` is orthogonal to the image gradient at

:math:`p` subject to image and measurement noise. Consider the expression:

.. math::

\epsilon _i = {DI_{p_i}}^T \cdot (q - p_i)

where

:math:`{DI_{p_i}}` is an image gradient at one of the points

:math:`p_i` in a neighborhood of

:math:`q` . The value of

:math:`q` is to be found so that

:math:`\epsilon_i` is minimized. A system of equations may be set up with

:math:`\epsilon_i` set to zero:

.. math::

\sum _i(DI_{p_i} \cdot {DI_{p_i}}^T) - \sum _i(DI_{p_i} \cdot {DI_{p_i}}^T \cdot p_i)

where the gradients are summed within a neighborhood ("search window") of

:math:`q` . Calling the first gradient term

:math:`G` and the second gradient term

:math:`b` gives:

.. math::

q = G^{-1} \cdot b

The algorithm sets the center of the neighborhood window at this new center

:math:`q` and then iterates until the center stays within a set threshold.

OpenCV.lvlib:cornerSubPix.vi

cOpenCV_lvlib_Matlvclass

image

cOpenCV_lvlib_vecPoints2flvclass

corners

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cnclst

winSize

cnclst

criteria

cnclst

zeroZone

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

i1dnclst

corners

iOpenCV_lvlib_vecPoints2flvclass

corners

OpenCV.lvlib:cornerMinEigenVal.vi

cornerMinEigenVal

-----------------

Calculates the minimal eigenvalue of gradient matrices for corner detection.

src: Input single-channel 8-bit or floating-point image.

dst: Image to store the minimal eigenvalues. It has the type ``CV_32FC1`` and the same size as ``src`` .

blockSize: Neighborhood size (see the details on :ocv:func:`cornerEigenValsAndVecs` ).

ksize: Aperture parameter for the :ocv:func:`Sobel` operator.

borderType: Pixel extrapolation method. See :ocv:func:`borderInterpolate` .

The function is similar to cornerEigenValsAndVecs() but it calculates and stores only the minimal eigenvalue of the covariance matrix of derivatives, that is, \min(\lambda_1, \lambda_2) in terms of the formulae in the cornerEigenValsAndVecs() description.

OpenCV.lvlib:cornerMinEigenVal.vi

ci32

blockSize

int

ci32

ksize

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

ci32

borderType

int

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Float_Matrixlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Float_Matrixlvclass

dst out

OpenCV.lvlib:cornerHarris.vi

cornerHarris

src : Input single-channel 8-bit or floating-point image.

dst : Image to store the Harris detector responses. It has the type ``CV_32FC1`` and the same size as ``src`` .

blockSize : Neighborhood size (see the details on :ocv:func:`cornerEigenValsAndVecs` ).

ksize : Aperture parameter for the :ocv:func:`Sobel` operator.

k : Harris detector free parameter. See the formula below.

borderType : Pixel extrapolation method. See :ocv:func:`borderInterpolate` .

The function runs the Harris edge detector on the image. Similarly to `cornerMinEigenVal` and `cornerEigenValsAndVecs` , for each pixel (x, y) it calculates a 2x2 gradient covariance matrix M^{(x,y)} over a blockSize x blockSize neighborhood. Then, it computes the following characteristic:

dst (x,y) = det M^{(x,y)} - k * (tr M^{(x,y)})^2

Corners in the image can be found as the local maxima of this response map.

OpenCV.lvlib:cornerHarris.vi

ci32

blockSize

int

ci32

ksize

int

cdbl

k

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

ci32

borderType

int

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Float_Matrixlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Float_Matrixlvclass

dst out

OpenCV.lvlib:cornerEigenValsAndVecs.vi

cornerEigenValsAndVecs

Calculates eigenvalues and eigenvectors of image blocks for corner detection.

src : Input single-channel 8-bit or floating-point image.

dst : Image to store the results. It has the same size as ``src`` and the type ``CV_32FC(6)`` .

blockSize : Neighborhood size (see details below).

ksize : Aperture parameter for the :ocv:func:`Sobel` operator.

borderType : Pixel extrapolation method. See :ocv:func:`borderInterpolate` .

For every pixel

:math:`p` , the function ``cornerEigenValsAndVecs`` considers a ``blockSize`` :math:`\times` ``blockSize`` neighborhood

:math:`S(p)` . It calculates the covariation matrix of derivatives over the neighborhood as:

.. math::

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

:ocv:func:`Sobel` operator.

After that, it finds eigenvectors and eigenvalues of

:math:`M` and stores them in the destination image as

:math:`(\lambda_1, \lambda_2, x_1, y_1, x_2, y_2)` where

* :math:`\lambda_1, \lambda_2` are the non-sorted eigenvalues of :math:`M`

* :math:`x_1, y_1` are the eigenvectors corresponding to :math:`\lambda_1`

* :math:`x_2, y_2` are the eigenvectors corresponding to :math:`\lambda_2`

The output of the function can be used for robust edge or corner detection.

.. seealso::

:ocv:func:`cornerMinEigenVal`,

:ocv:func:`cornerHarris`,

:ocv:func:`preCornerDetect`

OpenCV.lvlib:cornerEigenValsAndVecs.vi

ci32

blockSize

int

ci32

ksize

int

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:Canny.vi

Canny

Finds edges in an image using the [Canny86] algorithm.

image : single-channel 8-bit input image.

edges : output edge map; it has the same size and type as ``image`` .

threshold1 : first threshold for the hysteresis procedure.

threshold2 : second threshold for the hysteresis procedure.

apertureSize : aperture size for the :ocv:func:`Sobel` operator.

L2gradient : a flag, indicating whether a more accurate :math:`L_2` norm :math:`=\sqrt{(dI/dx)^2 + (dI/dy)^2}` should be used to calculate the image gradient magnitude ( ``L2gradient=true`` ), or whether the default :math:`L_1` norm :math:`=|dI/dx|+|dI/dy|` is enough ( ``L2gradient=false`` ).

The function finds edges in the input image ``image`` and marks them in the output map ``edges`` using the Canny algorithm. The smallest value between ``threshold1`` and ``threshold2`` is used for edge linking. The largest value is used to find initial segments of strong edges. See

http://en.wikipedia.org/wiki/Canny_edge_detector

OpenCV.lvlib:Canny.vi

cdbl

threshold1

double

cdbl

threshold2

double

ci32

apertureSize

int

cbool

L2gradient

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

image

cOpenCV_lvlib_Matlvclass

edge

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

edge out

OpenCV.lvlib:ImageResize.vi

OpenCV.lvlib:ImageResize.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cOpenCV_lvlib_Sizelvclass

OpenCV.lvlib:Size.lvclass

cnclst

size

cdbl

fx

cdbl

fy

ci32

interpolation

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:lv Kalman measurementMatrix.vi

int lv_KalmanFilterpredict(int kf,int control);

int lv_KalmanFilterpredict(int kf,int control,int * err);

OpenCV.lvlib:lv Kalman measurementMatrix.vi

cu64

kf

int

cu64

measurementMatrix

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.


OpenCV.lvlib:distance_transform.vi

Calculates the distance to the closest zero pixel for each pixel of the source image.

Parameters:

src – 8-bit, single-channel (binary) source image.

dst – Output image with calculated distances. It is a 32-bit floating-point, single-channel image of the same size as src .

distanceType – Type of distance. It can be CV_DIST_L1, CV_DIST_L2 , or CV_DIST_C .

maskSize – Size of the distance transform mask. It can be 3, 5, or CV_DIST_MASK_PRECISE (the latter option is only supported by the first function). In case of the CV_DIST_L1 or CV_DIST_C distance type, the parameter is forced to 3 because a 3\times 3 mask gives the same result as 5\times 5 or any larger aperture.

labels – Optional output 2D array of labels (the discrete Voronoi diagram). It has the type CV_32SC1 and the same size as src . See the details below.

labelType – Type of the label array to build. If labelType==DIST_LABEL_CCOMP then each connected component of zeros in src (as well as all the non-zero pixels closest to the connected component) will be assigned the same label. If labelType==DIST_LABEL_PIXEL then each zero pixel (and all the non-zero pixels closest to it) gets its own label.

The functions distanceTransform calculate the approximate or precise distance from every binary image pixel to the nearest zero pixel. For zero image pixels, the distance will obviously be zero.

When maskSize == CV_DIST_MASK_PRECISE and distanceType == CV_DIST_L2 , the function runs the algorithm described in [Felzenszwalb04]. This algorithm is parallelized with the TBB library.

In other cases, the algorithm [Borgefors86] is used. This means that for a pixel the function finds the shortest path to the nearest zero pixel consisting of basic shifts: horizontal, vertical, diagonal, or knight’s move (the latest is available for a 5\times 5 mask). The overall distance is calculated as a sum of these basic distances. Since the distance function should be symmetric, all of the horizontal and vertical shifts must have the same cost (denoted as a ), all the diagonal shifts must have the same cost (denoted as b ), and all knight’s moves must have the same cost (denoted as c ). For the CV_DIST_C and CV_DIST_L1 types, the distance is calculated precisely, whereas for CV_DIST_L2 (Euclidean distance) the distance can be calculated only with a relative error (a 5\times 5 mask gives more accurate results). For a,``b`` , and c , OpenCV uses the values suggested in the original paper:

CV_DIST_C (3 X 3) a = 1, b = 1

CV_DIST_L1 (3 X 3) a = 1, b = 2

CV_DIST_L2 (3 X 3) a=0.955, b=1.3693

CV_DIST_L2 (5 X 5) a=1, b=1.4, c=2.1969

Typically, for a fast, coarse distance estimation CV_DIST_L2, a 3\times 3 mask is used. For a more accurate distance estimation CV_DIST_L2 , a 5\times 5 mask or the precise algorithm is used. Note that both the precise and the approximate algorithms are linear on the number of pixels.

The second variant of the function does not only compute the minimum distance for each pixel (x, y) but also identifies the nearest connected component consisting of zero pixels (labelType==DIST_LABEL_CCOMP) or the nearest zero pixel (labelType==DIST_LABEL_PIXEL). Index of the component/pixel is stored in \texttt{labels}(x, y) . When labelType==DIST_LABEL_CCOMP, the function automatically finds connected components of zero pixels in the input image and marks them with distinct labels. When labelType==DIST_LABEL_CCOMP, the function scans through the input image and marks all the zero pixels with distinct labels.

In this mode, the complexity is still linear. That is, the function provides a very fast way to compute the Voronoi diagram for a binary image.

OpenCV.lvlib:distance_transform.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

ci32

distanceType

ci32

maskSize

cOpenCV_lvlib_Float_Matrixlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

src out

iOpenCV_lvlib_Float_Matrixlvclass

dst

OpenCV.lvlib:floodFill.vi

Fills a connected component with the given color

Parameters:

image –

Input/output 1- or 3-channel, 8-bit, or floating-point image. It is modified by the function unless the FLOODFILL_MASK_ONLY flag is set in the second variant of the function. See the details below.

mask –

Operation mask that should be a single-channel 8-bit image, 2 pixels wider and 2 pixels taller than image. Since this is both an input and output parameter, you must take responsibility of initializing it. Flood-filling cannot go across non-zero pixels in the input mask. For example, an edge detector output can be used as a mask to stop filling at edges. On output, pixels in the mask corresponding to filled pixels in the image are set to 1 or to the a value specified in flags as described below. It is therefore possible to use the same mask in multiple calls to the function to make sure the filled areas do not overlap.

Note Since the mask is larger than the filled image, a pixel (x, y) in image corresponds to the pixel (x+1, y+1) in the mask .

seedPoint –

Starting point.

newVal –

New value of the repainted domain pixels.

loDiff –

Maximal lower brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.

upDiff –

Maximal upper brightness/color difference between the currently observed pixel and one of its neighbors belonging to the component, or a seed pixel being added to the component.

rect – Optional output parameter set by the function to the minimum bounding rectangle of the repainted domain.

flags –

Operation flags. The first 8 bits contain a connectivity value. The default value of 4 means that only the four nearest neighbor pixels (those that share an edge) are considered. A connectivity value of 8 means that the eight nearest neighbor pixels (those that share a corner) will be considered. The next 8 bits (8-16) contain a value between 1 and 255 with which to fill the mask (the default value is 1). For example, 4 | ( 255 << 8 ) will consider 4 nearest neighbours and fill the mask with a value of 255. The following additional options occupy higher bits and therefore may be further combined with the connectivity and mask fill values using bit-wise or (|):

FLOODFILL_FIXED_RANGE If set, the difference between the current pixel and seed pixel is considered. Otherwise, the difference between neighbor pixels is considered (that is, the range is floating).

FLOODFILL_MASK_ONLY If set, the function does not change the image ( newVal is ignored), and only fills the mask with the value specified in bits 8-16 of flags as described above. This option only make sense in function variants that have the mask parameter.

The functions floodFill fill a connected component starting from the seed point with the specified color. The connectivity is determined by the color/brightness closeness of the neighbor pixels.

OpenCV.lvlib:floodFill.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_ImageGraylvclass

mask

cnclst

rect

ci32

flags

cnclst

loDiff

cnclst

upDiff

cnclst

newVal

cnclst

seedPoint

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

src out

OpenCV.lvlib:threshold.vi

threshold

src : input array (single-channel, 8-bit or 32-bit floating point).

dst : output array of the same size and type as ``src``.

thresh : threshold value.

maxval : maximum value to use with the ``THRESH_BINARY`` and ``THRESH_BINARY_INV`` thresholding types.

type : thresholding type (see the details below).

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 (

: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 ``type`` :

* **THRESH_BINARY**

.. math::

\texttt{dst} (x,y) = \fork{\texttt{maxval}}{if $\texttt{src}(x,y) > \texttt{thresh}$}{0}{otherwise}

* **THRESH_BINARY_INV**

.. math::

\texttt{dst} (x,y) = \fork{0}{if $\texttt{src}(x,y) > \texttt{thresh}$}{\texttt{maxval}}{otherwise}

* **THRESH_TRUNC**

.. math::

\texttt{dst} (x,y) = \fork{\texttt{threshold}}{if $\texttt{src}(x,y) > \texttt{thresh}$}{\texttt{src}(x,y)}{otherwise}

* **THRESH_TOZERO**

.. math::

\texttt{dst} (x,y) = \fork{\texttt{src}(x,y)}{if $\texttt{src}(x,y) > \texttt{thresh}$}{0}{otherwise}

* **THRESH_TOZERO_INV**

.. math::

\texttt{dst} (x,y) = \fork{0}{if $\texttt{src}(x,y) > \texttt{thresh}$}{\texttt{src}(x,y)}{otherwise}

Also, the special value ``THRESH_OTSU`` may be combined with

one of the above values. In this case, the function determines the optimal threshold

value using the Otsu's algorithm and uses it instead of the specified ``thresh`` .

The function returns the computed threshold value.

Currently, the Otsu's method is implemented only for 8-bit images.

.. image:: pics/threshold.png

.. seealso::

:ocv:func:`adaptiveThreshold`,

:ocv:func:`findContours`,

:ocv:func:`compare`,

:ocv:func:`min`,

:ocv:func:`max`

OpenCV.lvlib:threshold.vi

cdbl

thresh

double

cdbl

maxval

double

ci32

Type

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

idbl

function return

double

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:cvtColor.vi

cvtColor

Converts an image from one color space to another.

src : input image: 8-bit unsigned, 16-bit unsigned ( ``CV_16UC...`` ), or single-precision floating-point.

dst : output image of the same size and depth as ``src``.

code : color space conversion code (see the description below).

dstCn : number of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from ``src`` and ``code`` .

The function converts an input image from one color

space to another. In case of a transformation to-from RGB color space, the order of the channels should be specified explicitly (RGB or BGR).

Note that the default color format in OpenCV is often referred to as RGB but it is actually BGR (the bytes are reversed). So the first byte in a standard (24-bit) color image will be an 8-bit Blue component, the second byte will be Green, and the third byte will be Red. The fourth, fifth, and sixth bytes would then be the second pixel (Blue, then Green, then Red), and so on.

The conventional ranges for R, G, and B channel values are:

*

0 to 255 for ``CV_8U`` images

*

0 to 65535 for ``CV_16U`` images

*

0 to 1 for ``CV_32F`` images

In case of linear transformations, the range does not matter.

But in case of a non-linear transformation, an input RGB image should be normalized to the proper value range to get the correct results, for example, for RGB

:math:`\rightarrow` L*u*v* transformation. For example, if you have a 32-bit floating-point image directly converted from an 8-bit image without any scaling, then it will have the 0..255 value range instead of 0..1 assumed by the function. So, before calling ``cvtColor`` , you need first to scale the image down: ::

img *= 1./255;

cvtColor(img, img, CV_BGR2Luv);

If you use ``cvtColor`` with 8-bit images, the conversion will have some information lost. For many applications, this will not be noticeable but it is recommended to use 32-bit images in applications that need the full range of colors or that convert an image before an operation and then convert back.

The function can do the following transformations:

*

RGB :math:`\leftrightarrow` GRAY ( ``CV_BGR2GRAY, CV_RGB2GRAY, CV_GRAY2BGR, CV_GRAY2RGB`` )

Transformations within RGB space like adding/removing the alpha channel, reversing the channel order, conversion to/from 16-bit RGB color (R5:G6:B5 or R5:G5:B5), as well as conversion to/from grayscale using:

.. math::

\text{RGB[A] to Gray:} \quad Y \leftarrow 0.299 \cdot R + 0.587 \cdot G + 0.114 \cdot B

and

.. math::

\text{Gray to RGB[A]:} \quad R \leftarrow Y, G \leftarrow Y, B \leftarrow Y, A \leftarrow 0

The conversion from a RGB image to gray is done with:

::

cvtColor(src, bwsrc, CV_RGB2GRAY);

..

More advanced channel reordering can also be done with

:ocv:func:`mixChannels` .

*

RGB

:math:`\leftrightarrow` CIE XYZ.Rec 709 with D65 white point ( ``CV_BGR2XYZ, CV_RGB2XYZ, CV_XYZ2BGR, CV_XYZ2RGB`` ):

.. math::

\begin{bmatrix} X \\ Y \\ Z

\end{bmatrix} \leftarrow \begin{bmatrix} 0.412453 & 0.357580 & 0.180423 \\ 0.212671 & 0.715160 & 0.072169 \\ 0.019334 & 0.119193 & 0.950227

\end{bmatrix} \cdot \begin{bmatrix} R \\ G \\ B

\end{bmatrix}

.. math::

\begin{bmatrix} R \\ G \\ B

\end{bmatrix} \leftarrow \begin{bmatrix} 3.240479 & -1.53715 & -0.498535 \\ -0.969256 & 1.875991 & 0.041556 \\ 0.055648 & -0.204043 & 1.057311

\end{bmatrix} \cdot \begin{bmatrix} X \\ Y \\ Z

\end{bmatrix}

:math:`X`, :math:`Y` and

:math:`Z` cover the whole value range (in case of floating-point images,

:math:`Z` may exceed 1).

*

RGB

:math:`\leftrightarrow` YCrCb JPEG (or YCC) ( ``CV_BGR2YCrCb, CV_RGB2YCrCb, CV_YCrCb2BGR, CV_YCrCb2RGB`` )

.. math::

Y \leftarrow 0.299 \cdot R + 0.587 \cdot G + 0.114 \cdot B

.. math::

Cr \leftarrow (R-Y) \cdot 0.713 + delta

.. math::

Cb \leftarrow (B-Y) \cdot 0.564 + delta

.. math::

R \leftarrow Y + 1.403 \cdot (Cr - delta)

.. math::

G \leftarrow Y - 0.714 \cdot (Cr - delta) - 0.344 \cdot (Cb - delta)

.. math::

B \leftarrow Y + 1.773 \cdot (Cb - delta)

where

.. math::

delta = \left \{ \begin{array}{l l} 128 & \mbox{for 8-bit images} \\ 32768 & \mbox{for 16-bit images} \\ 0.5 & \mbox{for floating-point images} \end{array} \right .

Y, Cr, and Cb cover the whole value range.

*

RGB :math:`\leftrightarrow` HSV ( ``CV_BGR2HSV, CV_RGB2HSV, CV_HSV2BGR, CV_HSV2RGB`` )

In case of 8-bit and 16-bit images,

R, G, and B are converted to the floating-point format and scaled to fit the 0 to 1 range.

.. math::

V \leftarrow max(R,G,B)

.. math::

S \leftarrow \fork{\frac{V-min(R,G,B)}{V}}{if $V \neq 0$}{0}{otherwise}

.. math::

H \leftarrow \forkthree{{60(G - B)}/{(V-min(R,G,B))}}{if $V=R$}{{120+60(B - R)}/{(V-min(R,G,B))}}{if $V=G$}{{240+60(R - G)}/{(V-min(R,G,B))}}{if $V=B$}

If

:math:`H<0` then

:math:`H \leftarrow H+360` . On output

:math:`0 \leq V \leq 1`, :math:`0 \leq S \leq 1`, :math:`0 \leq H \leq 360` .

The values are then converted to the destination data type:

* 8-bit images

.. math::

V \leftarrow 255 V, S \leftarrow 255 S, H \leftarrow H/2 \text{(to fit to 0 to 255)}

* 16-bit images (currently not supported)

.. math::

V <- 65535 V, S <- 65535 S, H <- H

* 32-bit images

H, S, and V are left as is

*

RGB :math:`\leftrightarrow` HLS ( ``CV_BGR2HLS, CV_RGB2HLS, CV_HLS2BGR, CV_HLS2RGB`` ).

In case of 8-bit and 16-bit images,

R, G, and B are converted to the floating-point format and scaled to fit the 0 to 1 range.

.. math::

V_{max} \leftarrow {max}(R,G,B)

.. math::

V_{min} \leftarrow {min}(R,G,B)

.. math::

L \leftarrow \frac{V_{max} + V_{min}}{2}

.. math::

S \leftarrow \fork { \frac{V_{max} - V_{min}}{V_{max} + V_{min}} }{if $L < 0.5$ }

{ \frac{V_{max} - V_{min}}{2 - (V_{max} + V_{min})} }{if $L \ge 0.5$ }

.. math::

H \leftarrow \forkthree {{60(G - B)}/{S}}{if $V_{max}=R$ }

{{120+60(B - R)}/{S}}{if $V_{max}=G$ }

{{240+60(R - G)}/{S}}{if $V_{max}=B$ }

If

:math:`H<0` then

:math:`H \leftarrow H+360` . On output

:math:`0 \leq L \leq 1`, :math:`0 \leq S \leq 1`, :math:`0 \leq H \leq 360` .

The values are then converted to the destination data type:

* 8-bit images

.. math::

V \leftarrow 255 \cdot V, S \leftarrow 255 \cdot S, H \leftarrow H/2 \; \text{(to fit to 0 to 255)}

* 16-bit images (currently not supported)

.. math::

V <- 65535 \cdot V, S <- 65535 \cdot S, H <- H

* 32-bit images

H, S, V are left as is

*

RGB :math:`\leftrightarrow` CIE L*a*b* ( ``CV_BGR2Lab, CV_RGB2Lab, CV_Lab2BGR, CV_Lab2RGB`` ).

In case of 8-bit and 16-bit images,

R, G, and B are converted to the floating-point format and scaled to fit the 0 to 1 range.

.. math::

\vecthree{X}{Y}{Z} \leftarrow \vecthreethree{0.412453}{0.357580}{0.180423}{0.212671}{0.715160}{0.072169}{0.019334}{0.119193}{0.950227} \cdot \vecthree{R}{G}{B}

.. math::

X \leftarrow X/X_n, \text{where} X_n = 0.950456

.. math::

Z \leftarrow Z/Z_n, \text{where} Z_n = 1.088754

.. math::

L \leftarrow \fork{116*Y^{1/3}-16}{for $Y>0.008856$}{903.3*Y}{for $Y \le 0.008856$}

.. math::

a \leftarrow 500 (f(X)-f(Y)) + delta

.. math::

b \leftarrow 200 (f(Y)-f(Z)) + delta

where

.. math::

f(t)= \fork{t^{1/3}}{for $t>0.008856$}{7.787 t+16/116}{for $t\leq 0.008856$}

and

.. math::

delta = \fork{128}{for 8-bit images}{0}{for floating-point images}

This outputs

:math:`0 \leq L \leq 100`, :math:`-127 \leq a \leq 127`, :math:`-127 \leq b \leq 127` . The values are then converted to the destination data type:

* 8-bit images

.. math::

L \leftarrow L*255/100, \; a \leftarrow a + 128, \; b \leftarrow b + 128

* 16-bit images

(currently not supported)

* 32-bit images

L, a, and b are left as is

*

RGB :math:`\leftrightarrow` CIE L*u*v* ( ``CV_BGR2Luv, CV_RGB2Luv, CV_Luv2BGR, CV_Luv2RGB`` ).

In case of 8-bit and 16-bit images,

R, G, and B are converted to the floating-point format and scaled to fit 0 to 1 range.

.. math::

\vecthree{X}{Y}{Z} \leftarrow \vecthreethree{0.412453}{0.357580}{0.180423}{0.212671}{0.715160}{0.072169}{0.019334}{0.119193}{0.950227} \cdot \vecthree{R}{G}{B}

.. math::

L \leftarrow \fork{116 Y^{1/3}}{for $Y>0.008856$}{903.3 Y}{for $Y\leq 0.008856$}

.. math::

u' \leftarrow 4*X/(X + 15*Y + 3 Z)

.. math::

v' \leftarrow 9*Y/(X + 15*Y + 3 Z)

.. math::

u \leftarrow 13*L*(u' - u_n) \quad \text{where} \quad u_n=0.19793943

.. math::

v \leftarrow 13*L*(v' - v_n) \quad \text{where} \quad v_n=0.46831096

This outputs

:math:`0 \leq L \leq 100`, :math:`-134 \leq u \leq 220`, :math:`-140 \leq v \leq 122` .

The values are then converted to the destination data type:

* 8-bit images

.. math::

L \leftarrow 255/100 L, \; u \leftarrow 255/354 (u + 134), \; v \leftarrow 255/256 (v + 140)

* 16-bit images

(currently not supported)

* 32-bit images

L, u, and v are left as is

The above formulae for converting RGB to/from various color spaces have been taken from multiple sources on the web, primarily from the Charles Poynton site

http://www.poynton.com/ColorFAQ.html

*

Bayer :math:`\rightarrow` RGB ( ``CV_BayerBG2BGR, CV_BayerGB2BGR, CV_BayerRG2BGR, CV_BayerGR2BGR, CV_BayerBG2RGB, CV_BayerGB2RGB, CV_BayerRG2RGB, CV_BayerGR2RGB`` ). The Bayer pattern is widely used in CCD and CMOS cameras. It enables you to get color pictures from a single plane where R,G, and B pixels (sensors of a particular component) are interleaved as follows:

.. image:: pics/bayer.png

The output RGB components of a pixel are interpolated from 1, 2, or

4 neighbors of the pixel having the same color. There are several

modifications of the above pattern that can be achieved by shifting

the pattern one pixel left and/or one pixel up. The two letters

:math:`C_1` and

:math:`C_2` in the conversion constants ``CV_Bayer`` :math:`C_1 C_2` ``2BGR`` and ``CV_Bayer`` :math:`C_1 C_2` ``2RGB`` indicate the particular pattern

type. These are components from the second row, second and third

columns, respectively. For example, the above pattern has a very

popular "BG" type.

OpenCV.lvlib:cvtColor.vi

cu16

code

ci32

dstCn

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:adaptiveThreshold.vi

adaptiveThreshold

src : Source 8-bit single-channel image.

dst : Destination image of the same size and the same type as ``src`` .

maxValue : Non-zero value assigned to the pixels for which the condition is satisfied. See the details below.

adaptiveMethod : Adaptive thresholding algorithm to use, ``ADAPTIVE_THRESH_MEAN_C`` or ``ADAPTIVE_THRESH_GAUSSIAN_C`` . See the details below.

thresholdType : Thresholding type that must be either ``THRESH_BINARY`` or ``THRESH_BINARY_INV`` .

blockSize : Size of a pixel neighborhood that is used to calculate a threshold value for the pixel: 3, 5, 7, and so on.

C : Constant subtracted from the mean or weighted mean (see the details below). Normally, it is positive but may be zero or negative as well.

The function transforms a grayscale image to a binary image according to the formulae:

* **THRESH_BINARY**

.. math::

dst(x,y) = \fork{\texttt{maxValue}}{if $src(x,y) > T(x,y)$}{0}{otherwise}

* **THRESH_BINARY_INV**

.. math::

dst(x,y) = \fork{0}{if $src(x,y) > T(x,y)$}{\texttt{maxValue}}{otherwise}

where

:math:`T(x,y)` is a threshold calculated individually for each pixel.

*

For the method ``ADAPTIVE_THRESH_MEAN_C`` , the threshold value

:math:`T(x,y)` is a mean of the

:math:`\texttt{blockSize} \times \texttt{blockSize}` neighborhood of

:math:`(x, y)` minus ``C`` .

*

For the method ``ADAPTIVE_THRESH_GAUSSIAN_C`` , the threshold value

: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

:ocv:func:`getGaussianKernel` .

The function can process the image in-place.

.. seealso::

:ocv:func:`threshold`,

:ocv:func:`blur`,

:ocv:func:`GaussianBlur`

OpenCV.lvlib:adaptiveThreshold.vi

cdbl

maxValue

double

ci32

adaptiveMethod

int

ci32

thresholdType

int

ci32

blockSize

int

cdbl

C

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:Integral.vi

Integral

Calculates the integral of an image.

src input Image

dest output Image

ring required output depth

The functions calculate one or more integral images for the source image.

Using these integral images, you can calculate sum, mean, and standard deviation over a specific up-right or rotated rectangular region of the image in a constant time.

OpenCV.lvlib:Integral.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ci16

Ring

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:Sobel.vi

Sobel

-----

Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.

src: input image.

dst: output image of the same size and the same number of channels as ``src`` .

ddepth: output image depth; the following combinations of ``src.depth()`` and ``ddepth`` are supported:

* ``src.depth()`` = ``CV_8U``, ``ddepth`` = -1/``CV_16S``/``CV_32F``/``CV_64F``

* ``src.depth()`` = ``CV_16U``/``CV_16S``, ``ddepth`` = -1/``CV_32F``/``CV_64F``

* ``src.depth()`` = ``CV_32F``, ``ddepth`` = -1/``CV_32F``/``CV_64F``

* ``src.depth()`` = ``CV_64F``, ``ddepth`` = -1/``CV_64F``

when ``ddepth=-1``, the destination image will have the same depth as the source; in the case of 8-bit input images it will result in truncated derivatives.

xorder: order of the derivative x.

yorder: order of the derivative y.

ksize: size of the extended Sobel kernel; it must be 1, 3, 5, or 7.

scale: optional scale factor for the computed derivative values; by default, no scaling is applied (see :ocv:func:`getDerivKernels` for details).

delta: optional delta value that is added to the results prior to storing them in ``dst``.

borderType: pixel extrapolation method (see :ocv:func:`borderInterpolate` for details).

In all cases except one, the ksize * ksize separable kernel is used to calculate the derivative. When ksize = 1, the 3 x 1 or 1 x 3 kernel is used (that is, no Gaussian smoothing is done). ksize = 1 can only be used for the first or the second x- or y- derivatives.

There is also the special value ksize = CV_SCHARR (-1) that corresponds to the 3x3 Scharr filter that may give more accurate results than the 3x3 Sobel. The Scharr aperture is

\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}

for the x-derivative, or transposed for the y-derivative.

The function calculates an image derivative by convolving the image with the appropriate kernel:

\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}

The Sobel operators combine Gaussian smoothing and differentiation, so the result is more or less resistant to the noise. Most often, the function is called with ( xorder = 1, yorder = 0, ksize = 3) or ( xorder = 0, yorder = 1, ksize = 3) to calculate the first x- or y- image derivative. The first case corresponds to a kernel of:

\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}

The second case corresponds to a kernel of:

\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}

OpenCV.lvlib:Sobel.vi

ci16

ddepth

ci32

dx

int

ci32

dy

int

cdbl

scale

double

cdbl

delta

double

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ci32

ksize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:sepFilter2D.vi

sepFilter2D

src : Source image.

dst : Destination image of the same size and the same number of channels as ``src`` .

ddepth : Destination image depth. The following combination of ``src.depth()`` and ``ddepth`` are supported:

* ``src.depth()`` = ``CV_8U``, ``ddepth`` = -1/``CV_16S``/``CV_32F``/``CV_64F``

* ``src.depth()`` = ``CV_16U``/``CV_16S``, ``ddepth`` = -1/``CV_32F``/``CV_64F``

* ``src.depth()`` = ``CV_32F``, ``ddepth`` = -1/``CV_32F``/``CV_64F``

* ``src.depth()`` = ``CV_64F``, ``ddepth`` = -1/``CV_64F``

kernelX : Coefficients for filtering each row.

kernelY : Coefficients for filtering each column.

anchor : Anchor position within the kernel. The default value :math:`(-1, 1)` means that the anchor is at the kernel center.

delta : Value added to the filtered results before storing them.

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 ``kernelX`` . Then, every column of the result is filtered with the 1D kernel ``kernelY`` . The final result shifted by ``delta`` is stored in ``dst`` .

.. seealso::

:ocv:func:`createSeparableLinearFilter`,

:ocv:func:`filter2D`,

:ocv:func:`Sobel`,

:ocv:func:`GaussianBlur`,

:ocv:func:`boxFilter`,

:ocv:func:`blur`

OpenCV.lvlib:sepFilter2D.vi

ci16

ddepth

cdbl

delta

double

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_ImageGraylvclass

src

cOpenCV_lvlib_ImageGraylvclass

dst

cnclst

anchor

c1ddbl

kernelX

int

c1ddbl

kernelY

int

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_ImageGraylvclass

dst

OpenCV.lvlib:pyrMeanShiftFiltering.vi

pyrMeanShiftFiltering

Performs initial step of meanshift segmentation of an image.

src : The source 8-bit, 3-channel image.

dst : The destination image of the same format and the same size as the source.

sp : The spatial window radius.

sr : The color window radius.

maxLevel : Maximum level of the pyramid for the segmentation.

termcrit : Termination criteria: when to stop meanshift iterations.

The function implements the filtering stage of meanshift segmentation, that is, the output of the function is the filtered "posterized" image with color gradients and fine-grain texture flattened. At every pixel

``(X,Y)`` of the input image (or down-sized input image, see below) the function executes meanshift

iterations, that is, the pixel ``(X,Y)`` neighborhood in the joint space-color hyperspace is considered:

(x,y): X- sp <= x <= X+ sp , Y- sp <= y <= Y+ sp , ||(R,G,B)-(r,g,b)|| <= sr

where ``(R,G,B)`` and ``(r,g,b)`` are the vectors of color components at ``(X,Y)`` and ``(x,y)``, respectively (though, the algorithm does not depend on the color space used, so any 3-component color space can be used instead). Over the neighborhood the average spatial value ``(X',Y')`` and average color vector ``(R',G',B')`` are found and they act as the neighborhood center on the next iteration:

.. math::

(X,Y)~(X',Y'), (R,G,B)~(R',G',B').

After the iterations over, the color components of the initial pixel (that is, the pixel from where the iterations started) are set to the final value (average color at the last iteration):

.. math::

I(X,Y) <- (R*,G*,B*)

When ``maxLevel > 0``, the gaussian pyramid of ``maxLevel+1`` levels is built, and the above procedure is run on the smallest layer first. After that, the results are propagated to the larger layer and the iterations are run again only on those pixels where the layer colors differ by more than ``sr`` from the lower-resolution layer of the pyramid. That makes boundaries of color regions sharper. Note that the results will be actually different from the ones obtained by running the meanshift procedure on the whole original image (i.e. when ``maxLevel==0``).

OpenCV.lvlib:pyrMeanShiftFiltering.vi

cdbl

sp

double

cdbl

sr

double

ci32

maxLevel

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:pyrUp.vi

pyrUp

-----

Upsamples an image and then blurs it.

src: input image.

dst: output image. It has the specified size and the same type as ``src`` .

dstsize (ksize): size of the output image; by default, it is computed as ``Size(src.cols*2, (src.rows*2)``, but in any case, the following conditions should be satisfied:

.. math::

|dstsize.width - src.cols*2| <= (dstsize.width mod 2)

|dstsize.height - src.rows*2| <= (dstsize.height mod 2)

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

:ocv:func:`pyrDown` multiplied by 4.

OpenCV.lvlib:pyrUp.vi

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

dstsize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:pyrDown.vi

pyrDown

src : input image.

dst : output image; it has the specified size and the same type as ``src``.

dstsize : size of the output image; by default, it is computed as ``Size((src.cols+1)/2, (src.rows+1)/2)``, but in any case, the following conditions should be satisfied:

.. math::

\begin{array}{l}

| \texttt{dstsize.width} *2-src.cols| \leq 2 \\ | \texttt{dstsize.height} *2-src.rows| \leq 2 \end{array}

The function performs the downsampling step of the Gaussian pyramid construction. First, it convolves the source image with the kernel:

.. math::

\frac{1}{256} \begin{bmatrix} 1 & 4 & 6 & 4 & 1 \\ 4 & 16 & 24 & 16 & 4 \\ 6 & 24 & 36 & 24 & 6 \\ 4 & 16 & 24 & 16 & 4 \\ 1 & 4 & 6 & 4 & 1 \end{bmatrix}

Then, it downsamples the image by rejecting even rows and columns.

OpenCV.lvlib:pyrDown.vi

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

dssize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:Laplacian.vi

Laplacian

src : Source image.

dst : Destination image of the same size and the same number of channels as ``src`` .

ddepth : Desired depth of the destination image.

ksize : Aperture size used to compute the second-derivative filters. See :ocv:func:`getDerivKernels` for details. The size must be positive and odd.

scale : Optional scale factor for the computed Laplacian values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details.

delta : Optional delta value that is added to the results prior to storing them in ``dst`` .

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:

.. math::

\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}

This is done when ``ksize > 1`` . When ``ksize == 1`` , the Laplacian is computed by filtering the image with the following

:math:`3 \times 3` aperture:

.. math::

\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}

.. seealso::

:ocv:func:`Sobel`,

:ocv:func:`Scharr`

OpenCV.lvlib:Laplacian.vi

ci16

ddepth

cdbl

scale

double

cdbl

delta

double

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ci32

ksize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:morphologyEx.vi

morphologyEx

src : Source image. The number of channels can be arbitrary. The depth should be one of ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32F` or ``CV_64F``.

dst : Destination image of the same size and type as ``src`` .

element : Structuring element.

op : Type of a morphological operation that can be one of the following:

Type of a morphological operation that can be one of the following:

MORPH_OPEN - an opening operation

MORPH_CLOSE - a closing operation

MORPH_GRADIENT - a morphological gradient

MORPH_TOPHAT - “top hat”

MORPH_BLACKHAT - “black hat”

iterations : Number of times erosion and dilation are applied.

borderType : Pixel extrapolation method. See :ocv:func:`borderInterpolate` for details.

borderValue : Border value in case of a constant border. The default value has a special meaning. See :ocv:func:`createMorphologyFilter` for details.

The function can perform advanced morphological transformations using an erosion and dilation as basic operations.

Opening operation:

dst = open( src, element )=dilate( erode(src , element))

Closing operation:

dst = close( src , element )= erode(dilate( src , element ))

Morphological gradient:

dst =morph_grad(src , element)= dilate( src, element)- erode( src , element)

"Top hat":

dst = tophat(src , element )= src -open( src , element )

"Black hat":

dst = blackhat(src , element )= close( src , element )- src

Any of the operations can be done in-place. In case of multi-channel images, each channel is processed independently.

.. seealso::

:ocv:func:`dilate`,

:ocv:func:`erode`,

:ocv:func:`createMorphologyFilter`

OpenCV.lvlib:morphologyEx.vi

ci32

op

int

ci32

iterations

int

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

borderValue

c2du8

kernel

int

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:medianBlur.vi

medianBlur

src : input 1-, 3-, or 4-channel image; when ``ksize`` is 3 or 5, the image depth should be ``CV_8U``, ``CV_16U``, or ``CV_32F``, for larger aperture sizes, it can only be ``CV_8U``.

dst : destination array of the same size and type as ``src``.

ksize : aperture linear size; it must be odd and greater than 1, for example: 3, 5, 7 ...

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.

.. seealso::

:ocv:func:`bilateralFilter`,

:ocv:func:`blur`,

:ocv:func:`boxFilter`,

:ocv:func:`GaussianBlur`

OpenCV.lvlib:medianBlur.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ci32

ksize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:dilate.vi

dilate

------

Dilates an image by using a specific structuring element.

:param src: input image; the number of channels can be arbitrary, but the depth should be one of ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32F` or ``CV_64F``.

:param dst: output image of the same size and type as ``src``.

:param element: structuring element used for dilation; if ``element=Mat()`` , a ``3 x 3`` rectangular structuring element is used.

:param anchor: position of the anchor within the element; default value ``(-1, -1)`` means that the anchor is at the element center.

:param iterations: number of times dilation is applied.

:param borderType: pixel extrapolation method (see :ocv:func:`borderInterpolate` for details).

:param borderValue: border value in case of a constant border (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:

.. math::

\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')

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.

OpenCV.lvlib:dilate.vi

ci32

iterations

int

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

anchor

cnclst

borderValue

c2du8

kernel

int

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:erode.vi

erode

-----

Erodes an image by using a specific structuring element.

src: input image; the number of channels can be arbitrary, but the depth should be one of ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32F` or ``CV_64F``.

dst: output image of the same size and type as ``src``.

element: structuring element used for erosion; if ``element=Mat()`` , a ``3 x 3`` rectangular structuring element is used.

anchor: position of the anchor within the element; default value ``(-1, -1)`` means that the anchor is at the element center.

iterations: number of times erosion is applied.

borderType: pixel extrapolation method (see :ocv:func:`borderInterpolate` for details).

borderValue: border value in case of a constant border (see :ocv:func:`createMorphologyFilter` 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:

.. math::

\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')

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.

OpenCV.lvlib:erode.vi

ci32

iterations

int

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

anchor

c2du8

kernel

int

cnclst

borderValue

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:GaussianBlur.vi

GaussianBlur

Blurs an image using a Gaussian filter.

src : input image; the image can have any number of channels, which are processed independently, but the depth should be ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32F`` or ``CV_64F``.

dst : output image of the same size and type as ``src``.

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*`` .

sigmaX : Gaussian kernel standard deviation in X direction.

sigmaY : Gaussian kernel standard deviation in Y direction; if ``sigmaY`` is zero, it is set to be equal to ``sigmaX``, if both sigmas are 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``.

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.

.. seealso::

:ocv:func:`sepFilter2D`,

:ocv:func:`filter2D`,

:ocv:func:`blur`,

:ocv:func:`boxFilter`,

:ocv:func:`bilateralFilter`,

:ocv:func:`medianBlur`

OpenCV.lvlib:GaussianBlur.vi

cdbl

sigmaX

double

cdbl

sigmaY

double

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

ksize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:filter2D.vi

filter2D

src : input image.

dst : output image of the same size and the same number of channels as ``src``.

ddepth : desired depth of the destination image; if it is negative, it will be the same as ``src.depth()``; the following combinations of ``src.depth()`` and ``ddepth`` are supported:

* ``src.depth()`` = ``CV_8U``, ``ddepth`` = -1/``CV_16S``/``CV_32F``/``CV_64F``

* ``src.depth()`` = ``CV_16U``/``CV_16S``, ``ddepth`` = -1/``CV_32F``/``CV_64F``

* ``src.depth()`` = ``CV_32F``, ``ddepth`` = -1/``CV_32F``/``CV_64F``

* ``src.depth()`` = ``CV_64F``, ``ddepth`` = -1/``CV_64F``

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.

anchor : anchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.

delta : optional value added to the filtered pixels before storing them in ``dst``.

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.

The function does actually compute correlation, not the convolution:

.. math::

\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

: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 :ocv:func:`createLinearFilter` ) for small kernels.

.. seealso::

:ocv:func:`sepFilter2D`,

:ocv:func:`createLinearFilter`,

:ocv:func:`dft`,

:ocv:func:`matchTemplate`

OpenCV.lvlib:filter2D.vi

ci16

ddepth

c2dsgl

kernel

int

cdbl

delta

double

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

anchor

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:copyMakeBorder.vi

copyMakeBorder

src : Source image.

dst : Destination image of the same type as ``src`` and the size ``Size(src.cols+left+right, src.rows+top+bottom)`` .

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.

borderType : Border type. See :ocv:func:`borderInterpolate` for details.

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

:ocv:class:`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: ::

// let border be the same in all directions

int border=2;

// constructs a larger image to fit both the image and the border

Mat gray_buf(rgb.rows + border*2, rgb.cols + border*2, rgb.depth());

// select the middle part of it w/o copying data

Mat gray(gray_canvas, Rect(border, border, rgb.cols, rgb.rows));

// convert image from RGB to grayscale

cvtColor(rgb, gray, CV_RGB2GRAY);

// form a border in-place

copyMakeBorder(gray, gray_buf, border, border,

border, border, BORDER_REPLICATE);

// now do some custom filtering ...

...

.. note::

When the source image is a part (ROI) of a bigger image, the function will try to use the pixels outside of the ROI to form a border. To disable this feature and always do extrapolation, as if ``src`` was not a ROI, use ``borderType | BORDER_ISOLATED``.

.. seealso::

:ocv:func:`borderInterpolate`

OpenCV.lvlib:copyMakeBorder.vi

ci32

top

int

ci32

bottom

int

ci32

left

int

ci32

right

int

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

value

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:blur.vi

blur

----

Blurs an image using the normalized box filter.

src: input image; it can have any number of channels, which are processed independently, but the depth should be ``CV_8U``, ``CV_16U``, ``CV_16S``, ``CV_32F`` or ``CV_64F``.

dst: output image of the same size and type as ``src``.

ksize: blurring kernel size.

anchor: anchor point; default value ``Point(-1,-1)`` means that the anchor is at the kernel center.

borderType: border mode used to extrapolate pixels outside of the image.

The function smoothes an image using the kernel:

K = (1/(ksize.width*ksize.height)) * {matrix of ones}

The call ``blur(src, dst, ksize, anchor, borderType)`` is equivalent to ``boxFilter(src, dst, src.type(), anchor, true, borderType)`` .

OpenCV.lvlib:blur.vi

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

anchor

cnclst

ksize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:boxFilter.vi

boxFilter

src : input image.

dst : output image of the same size and type as ``src``.

ddepth : the output image depth (-1 to use ``src.depth()``).

ksize : blurring kernel size.

anchor : anchor point; default value ``Point(-1,-1)`` means that the anchor is at the kernel center.

normalize : flag, specifying whether the kernel is normalized by its area or not.

borderType : border mode used to extrapolate pixels outside of the image.

The function smoothes an image using the kernel:

.. math::

\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}

where

.. math::

\alpha = \fork{\frac{1}{\texttt{ksize.width*ksize.height}}}{when \texttt{normalize=true}}{1}{otherwise}

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 :ocv:func:`integral` .

.. seealso::

:ocv:func:`blur`,

:ocv:func:`bilateralFilter`,

:ocv:func:`GaussianBlur`,

:ocv:func:`medianBlur`,

:ocv:func:`integral`

OpenCV.lvlib:boxFilter.vi

ci16

ddepth

cbool

normalize

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cnclst

anchor

cnclst

ksize

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:bilateralFilter.vi

bilateralFilter

src : Source 8-bit or floating-point, 1-channel or 3-channel image.

dst : Destination image of the same size and type as ``src`` .

d : Diameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from ``sigmaSpace`` .

sigmaColor : Filter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see ``sigmaSpace`` ) will be mixed together, resulting in larger areas of semi-equal color.

sigmaSpace : Filter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see ``sigmaColor`` ). When ``d>0`` , it specifies the neighborhood size regardless of ``sigmaSpace`` . Otherwise, ``d`` is proportional to ``sigmaSpace`` .

borderType : border mode used to extrapolate pixels outside of the image.

The function applies bilateral filtering to the input image, as described in

http://www.dai.ed.ac.uk/CVonline/LOCAL\_COPIES/MANDUCHI1/Bilateral\_Filtering.html

``bilateralFilter`` can reduce unwanted noise very well while keeping edges fairly sharp. However, it is very slow compared to most filters.

*Sigma values*: For simplicity, you can set the 2 sigma values to be the same. If they are small (< 10), the filter will not have much effect, whereas if they are large (> 150), they will have a very strong effect, making the image look "cartoonish".

*Filter size*: Large filters (d > 5) are very slow, so it is recommended to use d=5 for real-time applications, and perhaps d=9 for offline applications that need heavy noise filtering.

This filter does not work inplace.

OpenCV.lvlib:bilateralFilter.vi

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ci32

d

int

cdbl

sigmaColor

double

cdbl

sigmaSpace

double

ci32

borderType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:Split.vi

split

-----

Divides a multi-channel array into several single-channel arrays.

src: input multi-channel array.

The functions ``split`` split a multi-channel array into separate single-channel arrays

OpenCV.lvlib:Split.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_VecMatlvclass

VecMat

OpenCV.lvlib:setIdentity.vi

setIdentity

----

Initializes a scaled identity matrix.

src: matrix to initialize (not necessarily square).

scalar: value to assign to diagonal elements.

The function 'setIdentity' initializes a scaled identity matrix.

OpenCV.lvlib:setIdentity.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Float_Matrixlvclass

src

cnclst

Scalar

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Float_Matrixlvclass

src out

OpenCV.lvlib:sort.vi

sort

----

Sorts each row or each column of a matrix.

src: input single-channel array.

dst: output array of the same size and type as ``src``.

flags: operation flags, a combination of the following values:

* **CV_SORT_EVERY_ROW** each matrix row is sorted independently.

* **CV_SORT_EVERY_COLUMN** each matrix column is sorted independently; this flag and the previous one are mutually exclusive.

* **CV_SORT_ASCENDING** each matrix row is sorted in the ascending order.

* **CV_SORT_DESCENDING** each matrix row is sorted in the descending order; this flag and the previous one are also mutually exclusive.

The function ``sort`` sorts each matrix row or each matrix column in ascending or descending order. So you should pass two operation flags to get desired behaviour. If you want to sort matrix rows or columns lexicographically, you can use STL ``std::sort`` generic function with the proper comparison predicate.

OpenCV.lvlib:sort.vi

ci32

flags

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Double_Matrixlvclass

src

cOpenCV_lvlib_Double_Matrixlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Double_Matrixlvclass

dst out

OpenCV.lvlib:subtract.vi

Calculates the per-element sum of two arrays or an array and a scalar.

Parameters:

src1 – first input array .

src2 – second input array or a scalar.

src – single input array.

value – scalar value.

dst – output array that has the same size and number of channels as the input array(s); the depth is defined by dtype or src1/src2.

mask – optional operation mask - 8-bit single channel array, that specifies elements of the output array to be changed.

In case of multi-channel arrays, each channel is processed independently.

OpenCV.lvlib:subtract.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

src1

cOpenCV_lvlib_OpenCVclasslvclass

src2

cOpenCV_lvlib_OpenCVclasslvclass

dst

cOpenCV_lvlib_OpenCVclasslvclass

mask

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

dst out

OpenCV.lvlib:absMat.vi

abs

Calculates an absolute value of each matrix element.

m (src): matrix.

``abs`` is a meta-function that is expanded to one of :ocv:func:`absdiff` or :ocv:func:`convertScaleAbs` forms:

*dst = abs(src)``

The output matrix has the same size and the same type as the input one.

OpenCV.lvlib:absMat.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst

OpenCV.lvlib:phase.vi

Phase

Calculates the rotation angle of 2D vectors

x : floating-point array of x-coordinates of the vectors.

y : floating-point array of y-coordinates of the vectors; it must have the same size as ``x``.

dst (the angles in radians) : output array of the same size and type as ``x``.

The function phase calculates the rotation angle of each 2D vector that is formed from the corresponding elements of x and y :

angle(I) = atan2(y(I),x(I))

The angle estimation accuracy is about 0.3 degrees (about 0.005 radians). When x(I)=y(I)=0 , the corresponding angle(I) is set to 0.

OpenCV.lvlib:phase.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

x

cOpenCV_lvlib_Matlvclass

dst

cOpenCV_lvlib_Matlvclass

y

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:transpose.vi

transpose

src : input array.

dst : output array of the same type as ``src``.

The function `transpose` transposes the matrix ``src`` :

dst(i,j) = src(j,i)

.. note:: No complex conjugation is done in case of a complex matrix. It it should be done separately if needed.

OpenCV.lvlib:transpose.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:sum.vi

sum

---

Calculates the sum of array elements.

src: input array that must have from 1 to 4 channels.

The functions ``sum`` calculate and return the sum of array elements, independently for each channel.

OpenCV.lvlib:sum.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

inclst

Sum

OpenCV.lvlib:sqrt.vi

sqrt

----

Calculates a square root of array elements.

src: input floating-point array.

dst: output array of the same size and type as ``src``.

The functions ``sqrt`` calculate a square root of each input array element. In case of multi-channel arrays, each channel is processed independently. The accuracy is approximately the same as of the built-in ``std::sqrt``

OpenCV.lvlib:sqrt.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:repeat.vi

repeat

------

Fills the output array with repeated copies of the input array.

src: input array to replicate.

dst: output array of the same type as ``src``.

ny: Flag to specify how many times the ``src`` is repeated along the vertical axis.

nx: Flag to specify how many times the ``src`` is repeated along the horizontal axis.

The functions

:ocv:func:`repeat` duplicate the input array one or more times along each of the two axes:

dst _{ij}= src _{i mod src.rows, j mod src.cols}

OpenCV.lvlib:repeat.vi

ci32

ny

int

ci32

nx

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:reduce.vi

reduce

------

Reduces a matrix to a vector.

src: input 2D matrix.

dst: output vector. Its size and type is defined by ``dim`` and ``dtype`` parameters.

dim: dimension index along which the matrix is reduced. 0 means that the matrix is reduced to a single row. 1 means that the matrix is reduced to a single column.

rtype: reduction operation that could be one of the following:

* **CV_REDUCE_SUM**: the output is the sum of all rows/columns of the matrix.

* **CV_REDUCE_AVG**: the output is the mean vector of all rows/columns of the matrix.

* **CV_REDUCE_MAX**: the output is the maximum (column/row-wise) of all rows/columns of the matrix.

* **CV_REDUCE_MIN**: the output is the minimum (column/row-wise) of all rows/columns of the matrix.

The output vector will have the same type as the input matrix.

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.

OpenCV.lvlib:reduce.vi

ci32

dim

int

ci32

rtype

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:pow.vi

pow

---

Raises every array element to a power.

src: input array.

power: exponent of power.

dst: output array of the same size and type as ``src``.

The function ``pow`` raises every element of the input array to ``power`` :

dst(I) = { src(I)^power if power is integer

{|src(I)|^power otherwise

So, for a non-integer power exponent, the absolute values of input array elements are used. However, it is possible to get true values for negative values using some extra operations. In the example below, computing the 5th root of array ``src`` shows: ::

Mat mask = src < 0;

pow(src, 1./5, dst);

subtract(Scalar::all(0), dst, dst, mask);

For some values of ``power`` , such as integer values, 0.5 and -0.5, specialized faster algorithms are used.

Special values (NaN, Inf) are not handled.

OpenCV.lvlib:pow.vi

cdbl

power

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:normalize.vi

normalize

src : input array.

dst : output array of the same size as ``src`` .

alpha : norm value to normalize to or the lower range boundary in case of the range normalization.

beta : upper range boundary in case of the range normalization; it is not used for the norm normalization.

normType : normalization type (see the details below).

dtype : when negative, the output array has the same type as ``src``; otherwise, it has the same number of channels as ``src`` and the depth ``=CV_MAT_DEPTH(dtype)``.

mask : optional operation mask.

The functions ``normalize`` scale and shift the input array elements so that

||dst||{L_p}= alpha

(where p=Inf, 1 or 2) when ``normType=NORM_INF``, ``NORM_L1``, or ``NORM_L2``, respectively; or so that

min_I dst(I) = alpha, max _I dst(I) = beta

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 calculated over the sub-array, and then this sub-array is modified to be normalized. If you want to only use the mask to calculate the norm or min-max but modify the whole array, you can use

: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::

:ocv:func:`norm`,

:ocv:func:`Mat::convertTo`,

:ocv:func:`SparseMat::convertTo`

OpenCV.lvlib:normalize.vi

cdbl

alpha

double

cdbl

beta

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Unsigned_Matrixlvclass

mask

cOpenCV_lvlib_Matlvclass

dst

ci32

normType

int

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:norm.vi

norm

----

Calculates an absolute array norm, an absolute difference norm, or a relative difference norm.

src: first input array.

normType: type of the norm (see the details below).

mask: optional operation mask; it must have the same size as ``src`` and ``CV_8UC1`` type.

The functions ``norm`` calculate an absolute norm of ``src``:

.. math::

norm = \forkthree{\|\texttt{src1}\|_{L_{\infty}} = \max _I | \texttt{src1} (I)|}{if $\texttt{normType} = \texttt{NORM\_INF}$ }

{ \| \texttt{src1} \| _{L_1} = \sum _I | \texttt{src1} (I)|}{if $\texttt{normType} = \texttt{NORM\_L1}$ }

{ \| \texttt{src1} \| _{L_2} = \sqrt{\sum_I \texttt{src1}(I)^2} }{if $\texttt{normType} = \texttt{NORM\_L2}$ }

The functions ``norm`` return the calculated norm.

When the ``mask`` parameter is specified and it is not empty, the norm is calculated only over the region specified by the mask.

A multi-channel input arrays are treated as a single-channel, that is, the results for all channels are combined.

OpenCV.lvlib:norm.vi

ci32

normType

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

idbl

value

double

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.


OpenCV.lvlib:mulTransposed.vi

mulTransposed

src : input single-channel matrix. Note that unlike :ocv:func:`gemm`, the function can multiply not only floating-point matrices.

dst : output square matrix.

aTa : Flag specifying the multiplication ordering. See the description below.

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 output matrix. See the ``dtype`` parameter description below.

scale : Optional scale factor for the matrix product.

dtype : Optional type of the output matrix. When it is negative, the output matrix will have the same type as ``src`` . Otherwise, it will be ``type=CV_MAT_DEPTH(dtype)`` that should be either ``CV_32F`` or ``CV_64F`` .

The function ``mulTransposed`` calculates the product of ``src`` and its transposition:

dst = scale ( src - delta )^T ( src -delta )

if ``aTa=true`` , and

dst = scale ( src - delta ) ( src - delta )^T

otherwise. The function is used to calculate the covariance matrix. With zero delta, it can be used as a faster substitute for general matrix product ``A*B`` when ``B=A'``

.. seealso::

:ocv:func:`calcCovarMatrix`,

:ocv:func:`gemm`,

:ocv:func:`repeat`,

:ocv:func:`reduce`

OpenCV.lvlib:mulTransposed.vi

cbool

aTa

cu64

delta

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cdbl

scale

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:multiply.vi

multiply

src1 : first input array.

src2 : second input array of the same size and the same type as ``src1``.

dst : output array of the same size and type as ``src1``.

scale : optional scale factor.

The function ``multiply`` calculates the per-element product of two arrays:

dst(I) = saturate ( scale * src1 (I) * src2(I))

There is also a :ref:`MatrixExpressions` -friendly variant of the first function. See

:ocv:func:`Mat::mul` .

For a not-per-element matrix product, see

:ocv:func:`gemm` .

.. note:: Saturation is not applied when the output array has the depth ``CV_32S``. You may even get result of an incorrect sign in the case of overflow.

.. seealso::

:ocv:func:`add`,

:ocv:func:`subtract`,

:ocv:func:`divide`,

:ref:`MatrixExpressions`,

:ocv:func:`scaleAdd`,

:ocv:func:`addWeighted`,

:ocv:func:`accumulate`,

:ocv:func:`accumulateProduct`,

:ocv:func:`accumulateSquare`,

:ocv:func:`Mat::convertTo`

OpenCV.lvlib:multiply.vi

cdbl

scale

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src1

cOpenCV_lvlib_Matlvclass

src2

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:minMatToDouble.vi

min

---

Calculates per-element minimum of two arrays or an array and a scalar.

:param src1: first input array.

:param src2: second input array of the same size and type as ``src1``.

:param value: real scalar value.

:param dst: output array of the same size and type as ``src1``.

The functions ``min`` calculate the per-element minimum of two arrays:

dst(I)= min (src1 (I), src2 (I))

or array and a scalar:

dst(I)= min ( src1 (I), value )

In the second variant, when the input array is multi-channel, each channel is compared with ``value`` independently.

The first three variants of the function listed above are actually a part of

:ref:`MatrixExpressions` . They return the expression object that can be further either transformed/assigned to a matrix, or passed to a function, and so on.

OpenCV.lvlib:minMatToDouble.vi

cdbl

src2

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src1

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:minMat.vi

min

---

Calculates per-element minimum of two arrays or an array and a scalar.

:param src1: first input array.

:param src2: second input array of the same size and type as ``src1``.

:param value: real scalar value.

:param dst: output array of the same size and type as ``src1``.

The functions ``min`` calculate the per-element minimum of two arrays:

dst(I)= min (src1 (I), src2 (I))

or array and a scalar:

dst(I)= min ( src1 (I), value )

In the second variant, when the input array is multi-channel, each channel is compared with ``value`` independently.

The first three variants of the function listed above are actually a part of

:ref:`MatrixExpressions` . They return the expression object that can be further either transformed/assigned to a matrix, or passed to a function, and so on.

OpenCV.lvlib:minMat.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src1

cOpenCV_lvlib_Matlvclass

src2

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:meanStdDev.vi

meanStdDev

src : input array that should have from 1 to 4 channels so that the results can be stored in :ocv:class:`Scalar_` 's.

mean : output parameter: calculated mean value.

stddev : output parameter: calculateded standard deviation.

mask : optional operation mask.

The function ``meanStdDev`` calculates the mean and the standard deviation ``M`` of array elements independently for each channel and returns it via the output parameters:

N = sum_{I,mask (I) =/=0 } 1

mean _c = ( sum_{ I: mask(I) =/= 0} src (I)_c ) / N

stddev _c = sqrt(sum_{ I: mask(I) =/= 0} (src(I)_c - mean _c )^2 / N )

When all the mask elements are 0's, the functions return ``mean=stddev=Scalar::all(0)`` .

.. note:: The calculated 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::

:ocv:func:`countNonZero`,

:ocv:func:`mean`,

:ocv:func:`norm`,

:ocv:func:`minMaxLoc`,

:ocv:func:`calcCovarMatrix`

OpenCV.lvlib:meanStdDev.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

mask

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

inclst

Mean

inclst

Std

OpenCV.lvlib:mean.vi

mean

----

Calculates an average (mean) of array elements.

:param src: input array that should have from 1 to 4 channels so that the result can be stored in :ocv:class:`Scalar_` .

:param mask: optional operation mask.

The function ``mean`` calculates the mean value ``M`` of array elements, independently for each channel, and return it:

N = sum _{I: mask(I) =/= 0} 1

M_c = ( sum _{I: mask(I) =/= 0} mtx(I)_c) /N

When all the mask elements are 0's, the functions return ``Scalar::all(0)`` .

OpenCV.lvlib:mean.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

mask

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

inclst

Mean

iOpenCV_lvlib_Scalarlvclass

Scalar out

OpenCV.lvlib:maxMatToDouble.vi

max

---

Calculates per-element maximum of two arrays or an array and a scalar.

:param src1: first input array.

:param src2: second input array of the same size and type as ``src1`` .

:param value: real scalar value.

:param dst: output array of the same size and type as ``src1``.

The functions ``max`` calculate the per-element maximum of two arrays:

dst(I)= max (src1(I), src2(I))

or array and a scalar:

dst(I)= max (src1(I), value)

In the second variant, when the input array is multi-channel, each channel is compared with ``value`` independently.

OpenCV.lvlib:maxMatToDouble.vi

cdbl

src2

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src1

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:maxMat.vi

max

---

Calculates per-element maximum of two arrays or an array and a scalar.

:param src1: first input array.

:param src2: second input array of the same size and type as ``src1`` .

:param value: real scalar value.

:param dst: output array of the same size and type as ``src1``.

The functions ``max`` calculate the per-element maximum of two arrays:

dst(I)= max (src1(I), src2(I))

or array and a scalar:

dst(I)= max (src1(I), value)

In the second variant, when the input array is multi-channel, each channel is compared with ``value`` independently.

OpenCV.lvlib:maxMat.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src1

cOpenCV_lvlib_Matlvclass

src2

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:magnitude.vi

magnitude

x : floating-point array of x-coordinates of the vectors.

y : floating-point array of y-coordinates of the vectors; it must have the same size as ``x``.

magnitude : output array of the same size and type as ``x``.

The function ``magnitude`` calculates the magnitude of 2D vectors formed from the corresponding elements of ``x`` and ``y`` arrays:

dst (I) = sqrt(x(I)^2 + y(I)^2)

See also:

:ocv:func:`cartToPolar`,

:ocv:func:`polarToCart`,

:ocv:func:`phase`,

:ocv:func:`sqrt`

OpenCV.lvlib:magnitude.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

x

cOpenCV_lvlib_Matlvclass

dst

cOpenCV_lvlib_Matlvclass

y

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:LUT.vi

LUT

---

Performs a look-up table transform of an array.

:param src: input array of 8-bit elements.

:param lut: look-up table of 256 elements; in case of multi-channel input array, the table should either have a single channel (in this case the same table is used for all channels) or the same number of channels as in the input array.

:param dst: output array of the same size and number of channels as ``src``, and the same depth as ``lut``.

The function ``LUT`` fills the output array with values from the look-up table. Indices of the entries are taken from the input array. That is, the function processes each element of ``src`` as follows:

dst(I) <- lut(src(I) + d)

where

d = { 0 if src has depth CV\_8U

{ 128 if src has depth CV\_8S

OpenCV.lvlib:LUT.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cOpenCV_lvlib_Matlvclass

LUT

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:log.vi

log

---

Calculates the natural logarithm of every array element.

:param src: input array.

:param dst: output array of the same size and type as ``src`` .

The function ``log`` calculates the natural logarithm of the absolute value of every element of the input array:

dst (I) = {log |src(I)| if src(I) =/= 0

{ C otherwise

where ``C`` is a large negative number (about -700 in the current implementation).

The maximum relative error is about ``7e-6`` for single-precision input and less than ``1e-10`` for double-precision input. Special values (NaN, Inf) are not handled.

OpenCV.lvlib:log.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:invert.vi

invert

------

Finds the inverse or pseudo-inverse of a matrix.

:param src: input floating-point ``M x N`` matrix.

:param dst: output matrix of ``N x M`` size and the same type as ``src``.

:param flags: inversion method :

* **DECOMP_LU** Gaussian elimination with the optimal pivot element chosen.

* **DECOMP_SVD** singular value decomposition (SVD) method.

* **DECOMP_CHOLESKY** Cholesky decomposition; the matrix must be symmetrical and positively defined.

The function ``invert`` inverts the matrix ``src`` and stores the result in ``dst`` .

When the matrix ``src`` is singular or non-square, the function calculates the pseudo-inverse matrix (the ``dst`` matrix) so that ``norm(src*dst - I)`` is minimal, where I is an identity matrix.

In case of the ``DECOMP_LU`` method, the function returns non-zero value if the inverse has been successfully calculated and 0 if ``src`` is singular.

In case of the ``DECOMP_SVD`` method, the function returns the inverse condition number of ``src`` (the ratio of the smallest singular value to the largest singular value) and 0 if ``src`` is singular. The SVD method calculates a pseudo-inverse matrix if ``src`` is singular.

Similarly to ``DECOMP_LU`` , the method ``DECOMP_CHOLESKY`` works only with non-singular square matrices that should also be symmetrical and positively defined. In this case, the function stores the inverted matrix in ``dst`` and returns non-zero. Otherwise, it returns 0.

OpenCV.lvlib:invert.vi

ci32

flags

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

idbl

function return

double

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:exp.vi

exp

---

Calculates the exponent of every array element.

:param src: input array.

:param dst: output array of the same size and type as ``src``.

The function ``exp`` calculates the exponent of every element of the input array:

dst [I] = e^( src(I) )

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.

OpenCV.lvlib:exp.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:eigen.vi

eigen

-----

Calculates eigenvalues and eigenvectors of a symmetric matrix.

:param src: input matrix that must have ``CV_32FC1`` or ``CV_64FC1`` type, square size and be symmetrical (``src`` :sup:`T` == ``src``).

:param eigenvalues: output vector of eigenvalues of the same type as ``src``; the eigenvalues are stored in the descending order.

:param eigenvectors: output matrix of eigenvectors; it has the same size and type as ``src``; the eigenvectors are stored as subsequent matrix rows, in the same order as the corresponding eigenvalues.

The functions ``eigen`` calculate just eigenvalues, or eigenvalues and eigenvectors of the symmetric matrix ``src`` :

src*eigenvectors.row(i).t() = eigenvalues.at(i)*eigenvectors.row(i).t()

.. note:: in the new and the old interfaces different ordering of eigenvalues and eigenvectors parameters is used.

.. seealso:: :ocv:func:`completeSymm` , :ocv:class:`PCA`

OpenCV.lvlib:eigen.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

eigenvalues

cOpenCV_lvlib_Matlvclass

eigenvectors

ibool

function return

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

eigenvalues out

iOpenCV_lvlib_Matlvclass

eigenvectors

OpenCV.lvlib:determinant.vi

determinant

-----------

Returns the determinant of a square floating-point matrix.

:param mtx: input matrix that must have ``CV_32FC1`` or ``CV_64FC1`` type and square size.

:param mat: input matrix that must have ``CV_32FC1`` or ``CV_64FC1`` type and square size.

The function ``determinant`` calculates 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 :ocv:func:`eigen` decomposition to calculate the determinant.

.. seealso::

:ocv:func:`trace`,

:ocv:func:`invert`,

:ocv:func:`solve`,

:ocv:func:`eigen`,

:ref:`MatrixExpressions`

OpenCV.lvlib:determinant.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

mtx

idbl

function return

double

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.


OpenCV.lvlib:divide.vi

divide

------

Performs per-element division of two arrays or a scalar by an array.

:param src1: first input array.

:param src2: second input array of the same size and type as ``src1``.

:param scale: scalar factor.

:param dst: output array of the same size and type as ``src2``.

The functions ``divide`` divide one array by another:

dst(I) = saturate(src1(I)*scale/src2(I))

or a scalar by an array when there is no ``src1`` :

dst(I) = saturate(scale/src2(I))

When ``src2(I)`` is zero, ``dst(I)`` will also be zero. Different channels of multi-channel arrays are processed independently.

.. note:: Saturation is not applied when the output array has the depth ``CV_32S``. You may even get result of an incorrect sign in the case of overflow.

.. seealso::

:ocv:func:`multiply`,

:ocv:func:`add`,

:ocv:func:`subtract`,

:ref:`MatrixExpressions`

OpenCV.lvlib:divide.vi

cdbl

scale

double

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src1

cOpenCV_lvlib_Matlvclass

src2

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:dft.vi

dft

---

Performs a forward or inverse Discrete Fourier transform of a 1D or 2D floating-point array.

:param src: input array that could be real or complex.

:param dst: output array whose size and type depends on the ``flags`` .

:param flags: transformation flags, representing a combination of the following values:

* **DFT_INVERSE** performs an inverse 1D or 2D transform instead of the default forward transform.

* **DFT_SCALE** scales the result: divide it by the number of array elements. Normally, it is combined with ``DFT_INVERSE``.

* **DFT_ROWS** performs a forward or inverse transform of every individual row of the input matrix; this flag enables you to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself) to perform 3D and higher-dimensional transformations and so forth.

* **DFT_COMPLEX_OUTPUT** performs a forward transformation of 1D or 2D real array; the result, though being a complex array, has complex-conjugate symmetry (*CCS*, see the function description below for details), and such an array can be packed into a real array of the same size as input, which is the fastest option and which is what the function does by default; however, you may wish to get a full complex array (for simpler spectrum analysis, and so on) - pass the flag to enable the function to produce a full-size complex output array.

* **DFT_REAL_OUTPUT** performs an inverse transformation of a 1D or 2D complex array; the result is normally a complex array of the same size, however, if the input array has conjugate-complex symmetry (for example, it is a result of forward transformation with ``DFT_COMPLEX_OUTPUT`` flag), the output is a real array; while the function itself does not check whether the input is symmetrical or not, you can pass the flag and then the function will assume the symmetry and produce the real output array (note that when the input is packed into a real array and inverse transformation is executed, the function treats the input as a packed complex-conjugate symmetrical array, and the output will also be a real array).

:param nonzeroRows: when the parameter is not zero, the function assumes that only the first ``nonzeroRows`` rows of the input array (``DFT_INVERSE`` is not set) or only the first ``nonzeroRows`` of the output array (``DFT_INVERSE`` is set) contain non-zeros, thus, the function can handle the rest of the rows more efficiently and save some time; this technique is very useful for calculating array cross-correlation or convolution using DFT.

The function performs one of the following:

*

Forward the Fourier transform of a 1D vector of ``N`` elements:

Y = F^(N) * X,

where

F_jk^(N)=exp(-2\pi * i * j * k/N) and i=sqrt{-1}

*

Inverse the Fourier transform of a 1D vector of ``N`` elements:

X'= (F^(N) )^(-1) * Y = (F^(N) )^(*) * y

X = (1/N) * X,

where

F^(*)=(Re(F^(N))-Im(F^(N)))^T

*

Forward the 2D Fourier transform of a ``M x N`` matrix:

Y = F^(M) * X * F^(N)

*

Inverse the 2D Fourier transform of a ``M x N`` matrix:

X'= (F^(M))^(*) * Y * (F^(N))^(*)

X = (1/(M * N)) * X'

In case of real (single-channel) data, the output spectrum of the forward Fourier transform or input spectrum of the inverse Fourier transform can be represented in a packed format called *CCS* (complex-conjugate-symmetrical). It was borrowed from IPL (Intel* Image Processing Library).

In case of 1D transform of a real vector, the output looks like the first row of the matrix above.

So, the function chooses an operation mode depending on the flags and size of the input array:

*

If DFT_ROWS is set or the input array has a single row or single column, the function performs a 1D forward or inverse transform of each row of a matrix when DFT_ROWS is set. Otherwise, it performs a 2D transform.

*

If the input array is real and DFT_INVERSE is not set, the function performs a forward 1D or 2D transform:

*When DFT_COMPLEX_OUTPUT is set, the output is a complex matrix of the same size as input.

*When DFT_COMPLEX_OUTPUT is not set, the output is a real matrix of the same size as input. In case of 2D transform, it uses the packed format as shown above. In case of a single 1D transform, it looks like the first row of the matrix above. In case of multiple 1D transforms (when using the DFT_ROWS flag), each row of the output matrix looks like the first row of the matrix above.

*

If the input array is complex and either DFT_INVERSE or DFT_REAL_OUTPUT are not set, the output is a complex array of the same size as input. The function performs a forward or inverse 1D or 2D transform of the whole input array or each row of the input array independently, depending on the flags DFT_INVERSE and DFT_ROWS.

*

When DFT_INVERSE is set and the input array is real, or it is complex but DFT_REAL_OUTPUT is set, the output is a real array of the same size as input. The function performs a 1D or 2D inverse transformation of the whole input array or each individual row, depending on the flags DFT_INVERSE and DFT_ROWS.

If DFT_SCALE is set, the scaling is done after the transformation.

Unlike 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 calculated using the getOptimalDFTSize() method.

OpenCV.lvlib:dft.vi

ci32

flags

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

cbool

INVERSE

ci32

flags 2

int

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst

OpenCV.lvlib:dct.vi

dct

---

Performs a forward or inverse discrete Cosine transform of 1D or 2D array.

:param src: input floating-point array.

:param dst: output array of the same size and type as ``src`` .

:param flags: transformation flags as a combination of the following values:

* **DCT_INVERSE** performs an inverse 1D or 2D transform instead of the default forward transform.

* **DCT_ROWS** performs a forward or inverse transform of every individual row of the input matrix. This flag enables you to transform multiple vectors simultaneously and can be used to decrease the overhead (which is sometimes several times larger than the processing itself) to perform 3D and higher-dimensional transforms and so forth.

The function ``dct`` performs a forward or inverse discrete Cosine transform (DCT) of a 1D or 2D floating-point array:

*

Forward Cosine transform of a 1D vector of ``N`` elements:

Y = C^(N) * X

where

C_jk^(N)= sqrt{alpha_j/N} * cos ( pi(2k+1)j/(2N) )

and

alpha_0=1, alpha_j=2 for *j > 0*.

*

Inverse Cosine transform of a 1D vector of ``N`` elements:

X = (C^(N) )^{-1} * Y = (C^(N) )^T * Y

(since

C^{(N)} is an orthogonal matrix,

C^(N) * (C^(N))^T = I )

*

Forward 2D Cosine transform of ``M x N`` matrix:

Y = C^(N) * X * (C^(N))^T

*

Inverse 2D Cosine transform of ``M x N`` matrix:

X = (C^(N))^T * X * C^(N)

The function chooses the mode of operation by looking at the flags and size of the input array:

*

If ``(flags & DCT_INVERSE) == 0`` , the function does a forward 1D or 2D transform. Otherwise, it is an inverse 1D or 2D transform.

*

If ``(flags & DCT_ROWS) != 0`` , the function performs a 1D transform of each row.

*

If the array is a single column or a single row, the function performs a 1D transform.

*

If none of the above is true, the function performs a 2D transform.

.. note::

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

:ocv:func:`getOptimalDFTSize` ). In the current implementation DCT of a vector of size ``N`` is calculated via DFT of a vector of size ``N/2`` . Thus, the optimal DCT size ``N1 >= N`` can be calculated as: ::

size_t getOptimalDCTSize(size_t N) { return 2*getOptimalDFTSize((N+1)/2); }

N1 = getOptimalDCTSize(N);

.. seealso:: :ocv:func:`dft` , :ocv:func:`getOptimalDFTSize` , :ocv:func:`idct`

OpenCV.lvlib:dct.vi

ci32

flags

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst

OpenCV.lvlib:countNonZero.vi

countNonZero

src : single-channel array.

The function returns the number of non-zero elements in ``src`` :

.. seealso::

:ocv:func:`mean`,

:ocv:func:`meanStdDev`,

:ocv:func:`norm`,

:ocv:func:`minMaxLoc`,

:ocv:func:`calcCovarMatrix`

OpenCV.lvlib:countNonZero.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_Matlvclass

src

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

ii32

count

OpenCV.lvlib:compare.vi

compare

Performs the per-element comparison of two arrays or an array and scalar value.

src1 : first input array , it must have a single channel.

src2 : second input array or a scalar ,when it is an array, it must have a single channel. To input a scalar you may input a 1X1 array with the required scalar value.

dst : output array that has the same size as the input arrays and type= ``CV_8UC1`` .

cmpop : a flag, that specifies correspondence between the arrays:

* **CMP_EQ** ``src1`` is equal to ``src2``.

* **CMP_GT** ``src1`` is greater than ``src2``.

* **CMP_GE** ``src1`` is greater than or equal to ``src2``.

* **CMP_LT** ``src1`` is less than ``src2``.

* **CMP_LE** ``src1`` is less than or equal to ``src2``.

* **CMP_NE** ``src1`` is unequal to ``src2``.

The function compares:

*

Elements of two arrays when ``src1`` and ``src2`` have the same size:

dst(I) = src1(I) cmpop src2(I)

*

Elements of ``src1`` with a scalar ``src2`` when ``src2`` is constructed from ``Scalar`` or has a single element:

dst(I) = src1(I) cmpop src2

*

``src1`` with elements of ``src2`` when ``src1`` is constructed from ``Scalar`` or has a single element:

dst (I) = src1 cmpop src2(I)

When the comparison result is true, the corresponding element of output array is set to 255.

The comparison operations can be replaced with the equivalent matrix expressions: ::

Mat dst1 = src1 >= src2;

Mat dst2 = src1 < 8;

...

.. seealso::

:ocv:func:`checkRange`,

:ocv:func:`min`,

:ocv:func:`max`,

:ocv:func:`threshold`,

:ref:`MatrixExpressions`

OpenCV.lvlib:compare.vi

ci32

cmpop

int

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

src1

cOpenCV_lvlib_Unsigned_Matrixlvclass

dst

cOpenCV_lvlib_OpenCVclasslvclass

src2

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Unsigned_Matrixlvclass

dst out

OpenCV.lvlib:PolarToCart.vi

polarToCart

Calculates x and y coordinates of 2D vectors from their magnitude and angle.

x : output array of x-coordinates of 2D vectors; it has the same size and type as angle.

y : output array of y-coordinates of 2D vectors; it has the same size and type as angle.

magnitude : input floating-point array of magnitudes of 2D vectors; it can be an empty matrix (=Mat()), in this case, the function assumes that all the magnitudes are =1; if it is not empty, it must have the same size and type as angle.

angle : input floating-point array of angles of 2D vectors (in radians).

The function polarToCart calculates the Cartesian coordinates of each 2D vector represented by the corresponding elements of magnitude and angle :

x(I) = magnitude(I) cos(angle(I))

y(I) = magnitude (I) sin(angle(I))

The relative accuracy of the estimated coordinates is about 1e-6.

.. seealso::

cartToPolar(), magnitude(), phase(), exp(), log(), pow(), sqrt()

OpenCV.lvlib:PolarToCart.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

x

cOpenCV_lvlib_OpenCVclasslvclass

y

cOpenCV_lvlib_OpenCVclasslvclass

magnitude

cOpenCV_lvlib_OpenCVclasslvclass

angle

coarn

ad

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

x out

iOpenCV_lvlib_OpenCVclasslvclass

y out

OpenCV.lvlib:cartToPolar.vi

cartToPolar

x : array of x-coordinates; this must be a single-precision or double-precision floating-point array.

y : array of y-coordinates, that must have the same size and same type as ``x``.

magnitude : output array of magnitudes of the same size and type as ``x``.

angle : output array of angles that has the same size and type as ``x``; the angles are measured in radians (from 0 to 2*Pi).

The function ``cartToPolar`` calculates either the magnitude, angle, or both for every 2D vector (x(I),y(I)):

magnitude (I)= sqrt{{x(I)^2+y(I)^2} ,

angle (I)= atan2 (y(I), x(I))[*180/pi]

The angles are calculated with accuracy about 0.3 degrees (about 0.005 rad). For the point (0,0), the angle is set to 0.

.. seealso::

Sobel(), Scharr()

OpenCV.lvlib:cartToPolar.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

x

cOpenCV_lvlib_OpenCVclasslvclass

y

cOpenCV_lvlib_OpenCVclasslvclass

magnitude

cOpenCV_lvlib_OpenCVclasslvclass

angle

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

magnitude out

iOpenCV_lvlib_OpenCVclasslvclass

angle out

OpenCV.lvlib:bitwise_not.vi

bitwise_not

Inverts every bit of an array.

:param src1: input array.

:param dst: output array that has the same size and type as the input array.

:param mask: optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

The function calculates per-element bit-wise inversion of the input array:

dst (I) = (neg)src (I)

In case of a floating-point input array, its machine-specific bit representation (usually IEEE754-compliant) is used for the operation. In case of multi-channel arrays, each channel is processed independently.

OpenCV.lvlib:bitwise_not.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

src1

cOpenCV_lvlib_OpenCVclasslvclass

dst

cOpenCV_lvlib_OpenCVclasslvclass

mask

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

dst out

OpenCV.lvlib:bitwise_xor.vi

bitwise_xor

-----------

Calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.

:param src1: first input array.

:param src2: second input array.

:param dst: output array that has the same size and type as the input arrays.

:param mask: optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

The function calculates the per-element bit-wise logical "exclusive-or" operation for Two arrays when ``src1`` and ``src2`` have the same size:

dst (I) = src1 (I) (oplus) src2 (I) if mask} (I) =/=0

In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the 2nd and 3rd cases above, the scalar is first converted to the array type.

OpenCV.lvlib:bitwise_xor.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

src1

cOpenCV_lvlib_OpenCVclasslvclass

src2

cOpenCV_lvlib_OpenCVclasslvclass

dst

cOpenCV_lvlib_OpenCVclasslvclass

mask

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

dst out

OpenCV.lvlib:bitwise_or.vi

bitwise_or

Calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.

:param src1: first input array .

:param src2: second input array.

:param dst: output array that has the same size and type as the input arrays.

:param mask: optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

The function calculates the per-element bit-wise logical disjunction for two arrays when ``src1`` and ``src2`` have the same size:

dst (I) = src1 (I) \/ src2} (I) if mask (I) =/=0

In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the second and third cases above, the scalar is first converted to the array type.

OpenCV.lvlib:bitwise_or.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

src1

cOpenCV_lvlib_OpenCVclasslvclass

src2

cOpenCV_lvlib_OpenCVclasslvclass

dst

cOpenCV_lvlib_OpenCVclasslvclass

mask

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

dst out

OpenCV.lvlib:bitwise_and.vi

bitwise_and

Calculates the per-element bit-wise conjunction of two arrays or an array and a scalar.

:param src1: first input array .

:param src2: second input array.

:param dst: output array that has the same size and type as the input arrays.

:param mask: optional operation mask, 8-bit single channel array, that specifies elements of the output array to be changed.

The function calculates the per-element bit-wise logical conjunction for two arrays when src1 and src2 have the same size:

dst (I) = src1 (I) /\ src2} (I) if mask} (I) =/=0

In case of floating-point arrays, their machine-specific bit representations (usually IEEE754-compliant) are used for the operation. In case of multi-channel arrays, each channel is processed independently. In the second and third cases above, the scalar is first converted to the array type.

OpenCV.lvlib:bitwise_and.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

src1

cOpenCV_lvlib_OpenCVclasslvclass

src2

cOpenCV_lvlib_OpenCVclasslvclass

dst

cOpenCV_lvlib_OpenCVclasslvclass

mask

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

dst out

OpenCV.lvlib:addArrays.vi

Calculates the per-element sum of two arrays or an array and a scalar.

Parameters:

src1 – first input array .

src2 – second input array or a scalar.

dst – output array that has the same size and number of channels as the input array(s); the depth is defined by dtype or src1/src2.

mask – optional operation mask - 8-bit single channel array, that specifies elements of the output array to be changed.

OpenCV.lvlib:addArrays.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

src1

cOpenCV_lvlib_OpenCVclasslvclass

src2

cOpenCV_lvlib_OpenCVclasslvclass

dst

cOpenCV_lvlib_OpenCVclasslvclass

mask

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

dst out

OpenCV.lvlib:absdiff.vi

absdiff

Calculates the per-element absolute difference between two arrays or between an array and a scalar.

:param src1: first input array.

:param src2: second input array or a scalar.

:param dst: output array that has the same size and type as input arrays.

The function ``absdiff`` calculates:

*

Absolute difference between two arrays when they have the same size and type:

dst(I) = saturate (|src1(I) - src2(I)|)

*

Absolute difference between an array and a scalar when the second array is constructed from ``Scalar`` or has as many elements as the number of channels in ``src1``:

dst(I) = saturate (|src1(I) - src2|)

*

Absolute difference between a scalar and an array when the first array is constructed from ``Scalar`` or has as many elements as the number of channels in ``src2``:

dst(I) = saturate (|src1 - src2(I)|)

Where ``I`` is a multi-dimensional index of array elements. In case of multi-channel arrays, each channel is processed independently.

note:: Saturation is not applied when the arrays have the depth ``CV_32S``. You may even get a negative value in the case of overflow.

.. seealso:: :ocv:func:`abs`

OpenCV.lvlib:absdiff.vi

cOpenCV_lvlib_Matlvclass

src1

cOpenCV_lvlib_OpenCVclasslvclass

src2

cOpenCV_lvlib_Matlvclass

dst

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_Matlvclass

dst out

OpenCV.lvlib:abs.vi

abs

Calculates an absolute value of each matrix element.

``abs`` is a meta-function that is expanded to one of :ocv:func:`absdiff` or :ocv:func:`convertScaleAbs` forms:

C = abs(A-B) is equivalent to absdiff(A, B, C)

C = abs(A) is equivalent to absdiff(A, Scalar::all(0), C)

C = Mat_ >(abs(A*alpha + beta)) is equivalent to convertScaleAbs(A, C, alpha, beta)

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 .

dst = abs(src)

The output matrix has the same size and the same type as the input one.

OpenCV.lvlib:abs.vi

cerrcodeclst

error in (no error)

error in can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

Right-click the error in control on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

cOpenCV_lvlib_OpenCVclasslvclass

dst

cOpenCV_lvlib_OpenCVclasslvclass

src

ierrcodeclst

error out

error out passes error or warning information out of a VI to be used by other VIs.

Right-click the error out indicator on the front panel and select Explain Error or Explain Warning from the shortcut menu for more information about the error.

iOpenCV_lvlib_OpenCVclasslvclass

dst out

OpenCV.lvlib:SuperResolution.lvclass:settemporalAreaRadius.vi

OpenCV.lvlib:SuperResolution.lvclass:settemporalAreaRadius.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cu16

temporalAreaRadius

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:settau.vi

OpenCV.lvlib:SuperResolution.lvclass:settau.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cdbl

tau

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:SetScale.vi

OpenCV.lvlib:SuperResolution.lvclass:SetScale.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cu16

Scale

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:setOptFlow.vi

OpenCV.lvlib:SuperResolution.lvclass:setOptFlow.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cu16

OptFlow

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:setlambda.vi

OpenCV.lvlib:SuperResolution.lvclass:setlambda.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cdbl

lambda

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:setiterations.vi

OpenCV.lvlib:SuperResolution.lvclass:setiterations.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cu16

iterations

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:setInput.vi

OpenCV.lvlib:SuperResolution.lvclass:setInput.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cOpenCV_lvlib_FrameSourcelvclass

FrameSource

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:setbtvKernelSize.vi

OpenCV.lvlib:SuperResolution.lvclass:setbtvKernelSize.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cu16

btvKernelSize

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:setblurSigma.vi

OpenCV.lvlib:SuperResolution.lvclass:setblurSigma.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cdbl

blurSigma

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:setblurKernelSize.vi

OpenCV.lvlib:SuperResolution.lvclass:setblurKernelSize.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cu16

blurKernelSize

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:setalpha.vi

OpenCV.lvlib:SuperResolution.lvclass:setalpha.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cdbl

alpha

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:nextFrame.vi

OpenCV.lvlib:SuperResolution.lvclass:nextFrame.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

cOpenCV_lvlib_Matlvclass

frame

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:Garbage.vi

OpenCV.lvlib:SuperResolution.lvclass:Garbage.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:SuperResolution.lvclass:createSuperResolution_BTVL1.vi

OpenCV.lvlib:SuperResolution.lvclass:createSuperResolution_BTVL1.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_SuperResolutionlvclass

SuperResolution in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_SuperResolutionlvclass

SuperResolution out

OpenCV.lvlib:FrameSource.lvclass:reset.vi

OpenCV.lvlib:FrameSource.lvclass:reset.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_FrameSourcelvclass

FrameSource in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_FrameSourcelvclass

FrameSource out

OpenCV.lvlib:FrameSource.lvclass:nextFrame.vi

OpenCV.lvlib:FrameSource.lvclass:nextFrame.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_FrameSourcelvclass

FrameSource in

cOpenCV_lvlib_Matlvclass

frame

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_FrameSourcelvclass

FrameSource out

OpenCV.lvlib:FrameSource.lvclass:createFrameSource_Video.vi

OpenCV.lvlib:FrameSource.lvclass:createFrameSource_Video.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_FrameSourcelvclass

FrameSource in

cpath

Video

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_FrameSourcelvclass

FrameSource out

OpenCV.lvlib:FrameSource.lvclass:createFrameSource_Empty.vi

OpenCV.lvlib:FrameSource.lvclass:createFrameSource_Empty.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_FrameSourcelvclass

FrameSource in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_FrameSourcelvclass

FrameSource out

OpenCV.lvlib:FrameSource.lvclass:createFrameSource_Camera.vi

OpenCV.lvlib:FrameSource.lvclass:createFrameSource_Camera.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_FrameSourcelvclass

FrameSource in

ci32

device

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_FrameSourcelvclass

FrameSource out

OpenCV.lvlib:Size[float].lvclass:set.vi

OpenCV.lvlib:Size[float].lvclass:set.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Size[float]lvclass

Size[float] in

cnclst

size

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Size[float]lvclass

Size[float] out

OpenCV.lvlib:Size[float].lvclass:get.vi

OpenCV.lvlib:Size[float].lvclass:get.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Size[float]lvclass

Size[float] in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Size[float]lvclass

Size[float] out

inclst

size

OpenCV.lvlib:Size.lvclass:get.vi

OpenCV.lvlib:Size.lvclass:get.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Sizelvclass

size in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Sizelvclass

size out

inclst

size

OpenCV.lvlib:Size.lvclass:set.vi

OpenCV.lvlib:Size.lvclass:set.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Sizelvclass

size in

cnclst

size

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Sizelvclass

size out

OpenCV.lvlib:Scalar.lvclass:Scalar get.vi

OpenCV.lvlib:Scalar.lvclass:Scalar get.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Scalarlvclass

Scalar in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Scalarlvclass

Scalar out

inclst

Scalar

OpenCV.lvlib:Scalar.lvclass:Scalar Create.vi

OpenCV.lvlib:Scalar.lvclass:Scalar Create.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Scalarlvclass

Scalar in

cnclst

Scalar

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Scalarlvclass

Scalar out

OpenCV.lvlib:RotatedRect.lvclass:set.vi

OpenCV.lvlib:RotatedRect.lvclass:set.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_RotatedRectlvclass

RotatedRect in

ccclst

RotatedRect

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_RotatedRectlvclass

RotatedRect out

OpenCV.lvlib:RotatedRect.lvclass:get.vi

OpenCV.lvlib:RotatedRect.lvclass:get.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_RotatedRectlvclass

RotatedRect in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_RotatedRectlvclass

RotatedRect out

icclst

RotatedRect

OpenCV.lvlib:RotatedRect.lvclass:boundingRect.vi

OpenCV.lvlib:RotatedRect.lvclass:boundingRect.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_RotatedRectlvclass

RotatedRect in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_RotatedRectlvclass

RotatedRect out

iOpenCV_lvlib_Rectlvclass

Rect

inclst

Rect

OpenCV.lvlib:TermCriteria.lvclass:set.vi

OpenCV.lvlib:TermCriteria.lvclass:set.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_TermCriterialvclass

TermCriteria in

cnclst

TermCriteria

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_TermCriterialvclass

TermCriteria out

OpenCV.lvlib:TermCriteria.lvclass:get.vi

OpenCV.lvlib:TermCriteria.lvclass:get.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_TermCriterialvclass

TermCriteria in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_TermCriterialvclass

TermCriteria out

OpenCV.lvlib:Range.lvclass:set.vi

OpenCV.lvlib:Range.lvclass:set.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Rangelvclass

Range in

cnclst

Range

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Rangelvclass

Range out

OpenCV.lvlib:Range.lvclass:get.vi

OpenCV.lvlib:Range.lvclass:get.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Rangelvclass

Range in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Rangelvclass

Range out

inclst

Range

OpenCV.lvlib:Point2f.lvclass:set.vi

OpenCV.lvlib:Point2f.lvclass:set.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Point2flvclass

Point_ in

cnclst

Point

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Point2flvclass

Point_ out

OpenCV.lvlib:Point2f.lvclass:get.vi

OpenCV.lvlib:Point2f.lvclass:get.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Point2flvclass

Point_ in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Point2flvclass

Point_ out

inclst

Point

OpenCV.lvlib:Point2f.lvclass:scale[s].vi

OpenCV.lvlib:Point2f.lvclass:scale[s].vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Point2flvclass

Point_ in

cdbl

a

double

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Point2flvclass

Point_ out

OpenCV.lvlib:Point2f.lvclass:creatPoint.vi

OpenCV.lvlib:Point2f.lvclass:creatPoint.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Point2flvclass

Point_ in

cnclst

Point

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Point2flvclass

Point_ out

OpenCV.lvlib:Point2f.lvclass:inside.vi

OpenCV.lvlib:Point2f.lvclass:inside.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Point2flvclass

Point_ in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Point2flvclass

Point_ out

ii32

inside

int


OpenCV.lvlib:Point.lvclass:destroy.vi

clear OpenCV refernce

OpenCV.lvlib:Point.lvclass:destroy.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Pointlvclass

Point in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Pointlvclass

Point out

OpenCV.lvlib:Point.lvclass:set.vi

OpenCV.lvlib:Point.lvclass:set.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Pointlvclass

Point_ in

cnclst

Point

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Pointlvclass

Point_ out

OpenCV.lvlib:Point.lvclass:get.vi

OpenCV.lvlib:Point.lvclass:get.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Pointlvclass

Point_ in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Pointlvclass

Point_ out

inclst

Point

OpenCV.lvlib:Point.lvclass:scale[s].vi

OpenCV.lvlib:Point.lvclass:scale[s].vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Pointlvclass

Point_ in

cdbl

a

double

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Pointlvclass

Point_ out

OpenCV.lvlib:Point.lvclass:creatPoint.vi

OpenCV.lvlib:Point.lvclass:creatPoint.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Pointlvclass

Point_ in

cnclst

Point

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Pointlvclass

Point_ out

OpenCV.lvlib:Point.lvclass:inside.vi

OpenCV.lvlib:Point.lvclass:inside.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Pointlvclass

Point_ in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Pointlvclass

Point_ out

ii32

inside

int


OpenCV.lvlib:OpenCVclass.lvclass:Read ptr.vi

OpenCV.lvlib:OpenCVclass.lvclass:Read ptr.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass out

iu64

ptr

OpenCV.lvlib:OpenCVclass.lvclass:destroy.vi

clear OpenCV refernce

OpenCV.lvlib:OpenCVclass.lvclass:destroy.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass out

OpenCV.lvlib:OpenCVclass.lvclass:Write ptr.vi

OpenCV.lvlib:OpenCVclass.lvclass:Write ptr.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass in

cu64

ptr

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass out

OpenCV.lvlib:OpenCVclass.lvclass:ImportData.vi

Import data from OpenCV to Labview

OpenCV.lvlib:OpenCVclass.lvclass:ImportData.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass in

ci32

SizeOf

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass out

i1du8

Array

ienum

Type

OpenCV.lvlib:OpenCVclass.lvclass:Create.vi

OpenCV.lvlib:OpenCVclass.lvclass:Create.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass in

cnclst

Scalar

ci32

high

int

ci32

width

int

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass out

OpenCV.lvlib:OpenCVclass.lvclass:ExportData.vi

download data from labview to opencv

OpenCV.lvlib:OpenCVclass.lvclass:ExportData.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass in

c1du8

Array

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass out

OpenCV.lvlib:OpenCVclass.lvclass:GetType.vi

OpenCV.lvlib:OpenCVclass.lvclass:GetType.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_OpenCVclasslvclass

OpenCVclass out

iu8

typeID

OpenCV.lvlib:OpenCVclass.lvclass:Cast.vi

OpenCV.lvlib:OpenCVclass.lvclass:Cast.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_OpenCVclasslvclass

dst

cOpenCV_lvlib_OpenCVclasslvclass

src

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_OpenCVclasslvclass

dst

OpenCV.lvlib:KalmanFilter.lvclass:correct.vi

OpenCV.lvlib:KalmanFilter.lvclass:correct.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter out

OpenCV.lvlib:KalmanFilter.lvclass:predict.vi

OpenCV.lvlib:KalmanFilter.lvclass:predict.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter in

cOpenCV_lvlib_Matlvclass

control

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter out

iOpenCV_lvlib_Matlvclass

Predict Mat

OpenCV.lvlib:KalmanFilter.lvclass:KalmanFilter.vi

KalmanFilter

class:: KalmanFilter

Kalman filter class.

The class implements a standard Kalman filter

http://en.wikipedia.org/wiki/Kalman_filter, [Welch95]_. However, you can modify ``transitionMatrix``, ``controlMatrix``, and ``measurementMatrix`` to get an extended Kalman filter functionality. See the OpenCV sample ``kalman.cpp`` .

OpenCV.lvlib:KalmanFilter.lvclass:KalmanFilter.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter in

ci32

dynamParams

int

ci32

measureParams

int

ci32

controlParams

int

ci32

type

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter out

OpenCV.lvlib:KalmanFilter.lvclass:transitionMatrix.vi

OpenCV.lvlib:KalmanFilter.lvclass:transitionMatrix.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter in

cOpenCV_lvlib_Float_Matrixlvclass

transitionMatrix

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter out

OpenCV.lvlib:KalmanFilter.lvclass:measurementMatrix.vi

OpenCV.lvlib:KalmanFilter.lvclass:measurementMatrix.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter in

cOpenCV_lvlib_Float_Matrixlvclass

measurementMatrix

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter out

OpenCV.lvlib:KalmanFilter.lvclass:Property.vi

OpenCV.lvlib:KalmanFilter.lvclass:Property.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_KalmanFilterlvclass

KalmanFilter out

iOpenCV_lvlib_Float_Matrixlvclass

errorCovPos

iOpenCV_lvlib_Float_Matrixlvclass

measurementNoiseCov

iOpenCV_lvlib_Float_Matrixlvclass

processNoiseCov

iOpenCV_lvlib_Float_Matrixlvclass

measurementMatrix

OpenCV.lvlib:Contours.lvclass:get contours.vi

OpenCV.lvlib:Contours.lvclass:get contours.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Contourslvclass

contours in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Contourslvclass

contours out

i1dcclst

contours

OpenCV.lvlib:Contours.lvclass:destroy.vi

clear OpenCV refernce

OpenCV.lvlib:Contours.lvclass:destroy.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Contourslvclass

Contours in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Contourslvclass

Contours out

OpenCV.lvlib:DescriptorMatcher.lvclass:match.vi

OpenCV.lvlib:DescriptorMatcher.lvclass:match.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_DescriptorMatcherlvclass

DescriptorMatcher in

cOpenCV_lvlib_Double_Matrixlvclass

descriptors1

cOpenCV_lvlib_Double_Matrixlvclass

descriptors2

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_DescriptorMatcherlvclass

DescriptorMatcher out

i1di32

queryIdx

i1di32

trainIdx

i1dsgl

distance

OpenCV.lvlib:DescriptorMatcher.lvclass:DescriptorMatcher[Create].vi

DescriptorMatcher

class:: DescriptorMatcher : public Algorithm

Abstract base class for matching keypoint descriptors. It has two groups

of match methods: for matching descriptors of an image with another image or

with an image set. ::

class DescriptorMatcher

{

public:

virtual ~DescriptorMatcher();

virtual void add( const vector& descriptors );

const vector& getTrainDescriptors() const;

virtual void clear();

bool empty() const;

virtual bool isMaskSupported() const = 0;

virtual void train();

/*

* Group of methods to match descriptors from an image pair.

*/

void match( const Mat& queryDescriptors, const Mat& trainDescriptors,

vector& matches, const Mat& mask=Mat() ) const;

void knnMatch( const Mat& queryDescriptors, const Mat& trainDescriptors,

vector >& matches, int k,

const Mat& mask=Mat(), bool compactResult=false ) const;

void radiusMatch( const Mat& queryDescriptors, const Mat& trainDescriptors,

vector >& matches, float maxDistance,

const Mat& mask=Mat(), bool compactResult=false ) const;

/*

* Group of methods to match descriptors from one image to an image set.

*/

void match( const Mat& queryDescriptors, vector& matches,

const vector& masks=vector() );

void knnMatch( const Mat& queryDescriptors, vector >& matches,

int k, const vector& masks=vector(),

bool compactResult=false );

void radiusMatch( const Mat& queryDescriptors, vector >& matches,

float maxDistance, const vector& masks=vector(),

bool compactResult=false );

virtual void read( const FileNode& );

virtual void write( FileStorage& ) const;

virtual Ptr clone( bool emptyTrainData=false ) const = 0;

static Ptr create( const string& descriptorMatcherType );

protected:

vector trainDescCollection;

...

};

OpenCV.lvlib:DescriptorMatcher.lvclass:DescriptorMatcher[Create].vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_DescriptorMatcherlvclass

DescriptorMatcher in

cstr

MatcherType

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_DescriptorMatcherlvclass

DescriptorMatcher out

OpenCV.lvlib:DescriptorExtractor.lvclass:DescriptorExtractor[Create].vi

DescriptorExtractor

class:: DescriptorExtractor : public Algorithm

Abstract base class for computing descriptors for image keypoints. ::

class CV_EXPORTS DescriptorExtractor

{

public:

virtual ~DescriptorExtractor();

void compute( const Mat& image, vector& keypoints,

Mat& descriptors ) const;

void compute( const vector& images, vector >& keypoints,

vector& descriptors ) const;

virtual void read( const FileNode& );

virtual void write( FileStorage& ) const;

virtual int descriptorSize() const = 0;

virtual int descriptorType() const = 0;

static Ptr create( const string& descriptorExtractorType );

protected:

...

};

In this interface, a keypoint descriptor can be represented as a

dense, fixed-dimension vector of a basic type. Most descriptors

follow this pattern as it simplifies computing

distances between descriptors. Therefore, a collection of

descriptors is represented as

:ocv:class:`Mat` , where each row is a keypoint descriptor.

OpenCV.lvlib:DescriptorExtractor.lvclass:DescriptorExtractor[Create].vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_DescriptorExtractorlvclass

DescriptorExtractor in

cstr

ExtractorType

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_DescriptorExtractorlvclass

DescriptorExtractor out

OpenCV.lvlib:DescriptorExtractor.lvclass:compute.vi

OpenCV.lvlib:DescriptorExtractor.lvclass:compute.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_DescriptorExtractorlvclass

DescriptorExtractor in

cOpenCV_lvlib_ImageGraylvclass

image

cOpenCV_lvlib_vecKeyPointlvclass

vecKeyPoint

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_DescriptorExtractorlvclass

DescriptorExtractor out

iOpenCV_lvlib_Double_Matrixlvclass

descriptors

OpenCV.lvlib:FeatureDetector.lvclass:FeatureDetector[Create].vi

FeatureDetector

class:: FeatureDetector : public Algorithm

Abstract base class for 2D image feature detectors. ::

class CV_EXPORTS FeatureDetector

{

public:

virtual ~FeatureDetector();

void detect( const Mat& image, vector& keypoints,

const Mat& mask=Mat() ) const;

void detect( const vector& images,

vector >& keypoints,

const vector& masks=vector() ) const;

virtual void read(const FileNode&);

virtual void write(FileStorage&) const;

static Ptr create( const string& detectorType );

protected:

...

};

OpenCV.lvlib:FeatureDetector.lvclass:FeatureDetector[Create].vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_FeatureDetectorlvclass

FeatureDetector in

cstr

detectorType

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_FeatureDetectorlvclass

FeatureDetector out

OpenCV.lvlib:FeatureDetector.lvclass:Detect.vi

OpenCV.lvlib:FeatureDetector.lvclass:Detect.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_FeatureDetectorlvclass

FeatureDetector in

cOpenCV_lvlib_Unsigned_Matrixlvclass

mask

cOpenCV_lvlib_ImageGraylvclass

image

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_FeatureDetectorlvclass

FeatureDetector out

iOpenCV_lvlib_vecKeyPointlvclass

vecKeypoints

OpenCV.lvlib:ocl Mat.lvclass:Write ptr.vi

OpenCV.lvlib:ocl Mat.lvclass:Write ptr.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_ocl_Matlvclass

ocl Mat in

cu64

ptr

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_ocl_Matlvclass

ocl Mat out

OpenCV.lvlib:ocl Mat.lvclass:ocl upload.vi

Upload Data from GPU to OpenCV Mat

OpenCV.lvlib:ocl Mat.lvclass:ocl upload.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_ocl_Matlvclass

ocl Mat in

cOpenCV_lvlib_Matlvclass

src

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_ocl_Matlvclass

ocl Mat out

OpenCV.lvlib:ocl Mat.lvclass:ocl Mat[2].vi

Create OpenCL(ocl) Mat

OpenCV.lvlib:ocl Mat.lvclass:ocl Mat[2].vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_ocl_Matlvclass

ocl Mat in

ci32

_rows

int

ci32

_cols

int

cenum

Type

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_ocl_Matlvclass

ocl Mat out

OpenCV.lvlib:ocl Mat.lvclass:ocl Mat.vi

Create OpenCL(ocl) Mat

OpenCV.lvlib:ocl Mat.lvclass:ocl Mat.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_ocl_Matlvclass

ocl Mat in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_ocl_Matlvclass

ocl Mat out

OpenCV.lvlib:ocl Mat.lvclass:ocl Download.vi

Download Data from OpenCV mat to GPU

OpenCV.lvlib:ocl Mat.lvclass:ocl Download.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_ocl_Matlvclass

ocl Mat in

cOpenCV_lvlib_Matlvclass

dst

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_ocl_Matlvclass

ocl Mat out

iOpenCV_lvlib_Matlvclass

src out

OpenCV.lvlib:ocl Mat.lvclass:ImportData.vi

OpenCV.lvlib:ocl Mat.lvclass:ImportData.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_ocl_Matlvclass

ocl Mat in

ci32

SizeOf

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_ocl_Matlvclass

ocl Mat out

i1du8

Array

ienum

Type

OpenCV.lvlib:BackgroundSubtractorMOG2.lvclass:ConstructMOG2.vi

OpenCV.lvlib:BackgroundSubtractorMOG2.lvclass:ConstructMOG2.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_BackgroundSubtractorMOG2lvclass

BackgroundSubtractorMOG2 in

ci32

history

int

cdbl

varThreshold

double

cbool

bShadowDetection

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_BackgroundSubtractorMOG2lvclass

BackgroundSubtractorMOG2 out

OpenCV.lvlib:BackgroundSubtractorMOG.lvclass:ConstructMOG.vi

OpenCV.lvlib:BackgroundSubtractorMOG.lvclass:ConstructMOG.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_BackgroundSubtractorMOGlvclass

BackgroundSubtractorMOG in

ci32

history

int

ci32

nmixtures

int

cdbl

noiseSigma

double

cdbl

backgroundRatio

double

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_BackgroundSubtractorMOGlvclass

BackgroundSubtractorMOG out

OpenCV.lvlib:BackgroundSubtractor.lvclass:Write type.vi

OpenCV.lvlib:BackgroundSubtractor.lvclass:Write type.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor in

cu16

type

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor out

OpenCV.lvlib:BackgroundSubtractor.lvclass:Read type.vi

OpenCV.lvlib:BackgroundSubtractor.lvclass:Read type.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor out

iu16

type

OpenCV.lvlib:BackgroundSubtractor.lvclass:getBackgroundImage.vi

OpenCV.lvlib:BackgroundSubtractor.lvclass:getBackgroundImage.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor in

cOpenCV_lvlib_Unsigned_Matrixlvclass

backgroundImage

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor out

iOpenCV_lvlib_Unsigned_Matrixlvclass

backgroundImage out

OpenCV.lvlib:BackgroundSubtractor.lvclass:Construct.vi

OpenCV.lvlib:BackgroundSubtractor.lvclass:Construct.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor out

OpenCV.lvlib:BackgroundSubtractor.lvclass:apply.vi

OpenCV.lvlib:BackgroundSubtractor.lvclass:apply.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor in

cOpenCV_lvlib_Matlvclass

image

cOpenCV_lvlib_Matlvclass

mask

cdbl

learningRate

double

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_BackgroundSubtractorlvclass

BackgroundSubtractor out

iOpenCV_lvlib_Matlvclass

mask out

OpenCV.lvlib:CascadeClassifier.lvclass:detectMultiScale.vi

OpenCV.lvlib:CascadeClassifier.lvclass:detectMultiScale.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_CascadeClassifierlvclass

CascadeClassifier in

cOpenCV_lvlib_ImageGraylvclass

image

cdbl

scaleFactor

ci32

minNeighbors

cOpenCV_lvlib_Sizelvclass

minSize

cOpenCV_lvlib_Sizelvclass

maxSize

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_CascadeClassifierlvclass

CascadeClassifier out

iOpenCV_lvlib_vecRectlvclass

objs

OpenCV.lvlib:CascadeClassifier.lvclass:CascadeClassifier[Create].vi

CascadeClassifier

class:: CascadeClassifier

Cascade classifier class for object detection.

OpenCV.lvlib:CascadeClassifier.lvclass:CascadeClassifier[Create].vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_CascadeClassifierlvclass

CascadeClassifier in

cpath

Path

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_CascadeClassifierlvclass

CascadeClassifier out

OpenCV.lvlib:Color.lvclass:Set Color.vi

OpenCV.lvlib:Color.lvclass:Set Color.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Colorlvclass

Color in

cu32

Color

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Colorlvclass

Color out

OpenCV.lvlib:Color.lvclass:Color.vi

OpenCV.lvlib:Color.lvclass:Color.vi

iOpenCV_lvlib_Colorlvclass

OpenCV.lvlib:Color.lvclass

OpenCV.lvlib:KeyPoint.lvclass:Property.vi

OpenCV.lvlib:KeyPoint.lvclass:Property.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_KeyPointlvclass

KeyPoint in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_KeyPointlvclass

KeyPoint out

inclst

Point2f

OpenCV.lvlib:Point2d.lvclass:set.vi

OpenCV.lvlib:Point2d.lvclass:set.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Point2dlvclass

Point_ in

cnclst

Point

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Point2dlvclass

Point_ out

OpenCV.lvlib:Point2d.lvclass:get.vi

OpenCV.lvlib:Point2d.lvclass:get.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Point2dlvclass

Point_ in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Point2dlvclass

Point_ out

inclst

Point

OpenCV.lvlib:Point2d.lvclass:creatPoint.vi

OpenCV.lvlib:Point2d.lvclass:creatPoint.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Point2dlvclass

Point_ in

cnclst

Point

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

iOpenCV_lvlib_Point2dlvclass

Point_ out

OpenCV.lvlib:Point2d.lvclass:inside.vi

OpenCV.lvlib:Point2d.lvclass:inside.vi

cerrcodeclst

error in (no error)

The error in cluster can accept error information wired from VIs previously called. Use this information to decide if any functionality should be bypassed in the event of errors from other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.

cOpenCV_lvlib_Point2dlvclass

Point_ in

ierrcodeclst

error out

The error out cluster passes error or warning information out of a VI to be used by other VIs.

The pop-up option Explain Error (or Explain Warning) gives more information about the error displayed.