Package | Description |
---|---|
org.bytedeco.opencv.global | |
org.bytedeco.opencv.helper | |
org.bytedeco.opencv.opencv_core |
Modifier and Type | Method and Description |
---|---|
static CvArr |
opencv_core.cvRange(CvArr mat,
double start,
double end)
Fills matrix with given range of numbers
|
static CvArr |
opencv_core.cvReshapeMatND(CvArr arr,
int sizeof_header,
CvArr header,
int new_cn,
int new_dims,
int[] new_sizes) |
static CvArr |
opencv_core.cvReshapeMatND(CvArr arr,
int sizeof_header,
CvArr header,
int new_cn,
int new_dims,
IntBuffer new_sizes) |
static CvArr |
opencv_core.cvReshapeMatND(CvArr arr,
int sizeof_header,
CvArr header,
int new_cn,
int new_dims,
IntPointer new_sizes)
\brief Changes the shape of a multi-dimensional array without copying the data.
|
Modifier and Type | Method and Description |
---|---|
static void |
opencv_core.cvAbsDiff(CvArr src1,
CvArr src2,
CvArr dst)
dst(x,y,c) = abs(src1(x,y,c) - src2(x,y,c))
|
static void |
opencv_core.cvAbsDiffS(CvArr src,
CvArr dst,
CvScalar value)
dst(x,y,c) = abs(src(x,y,c) - value(c))
|
static void |
opencv_imgproc.cvAcc(CvArr image,
CvArr sum) |
static void |
opencv_imgproc.cvAcc(CvArr image,
CvArr sum,
CvArr mask)
\brief Adds image to accumulator
|
static void |
opencv_imgproc.cvAdaptiveThreshold(CvArr src,
CvArr dst,
double max_value) |
static void |
opencv_imgproc.cvAdaptiveThreshold(CvArr src,
CvArr dst,
double max_value,
int adaptive_method,
int threshold_type,
int block_size,
double param1)
\brief Applies adaptive threshold to grayscale image.
|
static void |
opencv_core.cvAdd(CvArr src1,
CvArr src2,
CvArr dst) |
static void |
opencv_core.cvAdd(CvArr src1,
CvArr src2,
CvArr dst,
CvArr mask)
dst(mask) = src1(mask) + src2(mask)
|
static void |
opencv_core.cvAddS(CvArr src,
CvScalar value,
CvArr dst) |
static void |
opencv_core.cvAddS(CvArr src,
CvScalar value,
CvArr dst,
CvArr mask)
dst(mask) = src(mask) + value
|
static void |
opencv_highgui.cvAddText(CvArr img,
BytePointer text,
CvPoint org,
CvFont arg2) |
static void |
opencv_highgui.cvAddText(CvArr img,
BytePointer text,
int[] org,
CvFont arg2) |
static void |
opencv_highgui.cvAddText(CvArr img,
BytePointer text,
IntBuffer org,
CvFont arg2) |
static void |
opencv_highgui.cvAddText(CvArr img,
String text,
CvPoint org,
CvFont arg2) |
static void |
opencv_highgui.cvAddText(CvArr img,
String text,
int[] org,
CvFont arg2) |
static void |
opencv_highgui.cvAddText(CvArr img,
String text,
IntBuffer org,
CvFont arg2) |
static void |
opencv_core.cvAddWeighted(CvArr src1,
double alpha,
CvArr src2,
double beta,
double gamma,
CvArr dst)
dst = src1 * alpha + src2 * beta + gamma
|
static void |
opencv_core.cvAnd(CvArr src1,
CvArr src2,
CvArr dst) |
static void |
opencv_core.cvAnd(CvArr src1,
CvArr src2,
CvArr dst,
CvArr mask)
dst(idx) = src1(idx) & src2(idx)
|
static void |
opencv_core.cvAndS(CvArr src,
CvScalar value,
CvArr dst) |
static void |
opencv_core.cvAndS(CvArr src,
CvScalar value,
CvArr dst,
CvArr mask)
dst(idx) = src(idx) & value
|
static Mat |
opencv_core.cvarrToMat(CvArr arr) |
static Mat |
opencv_core.cvarrToMat(CvArr arr,
boolean copyData,
boolean allowND,
int coiMode,
Pointer buf)
\addtogroup core_c_glue
\{
|
static Mat |
opencv_core.cvarrToMatND(CvArr arr) |
static Mat |
opencv_core.cvarrToMatND(CvArr arr,
boolean copyData,
int coiMode) |
static CvScalar |
opencv_core.cvAvg(CvArr arr) |
static CvScalar |
opencv_core.cvAvg(CvArr arr,
CvArr mask)
Calculates mean value of array elements
|
static void |
opencv_core.cvAvgSdv(CvArr arr,
CvScalar mean,
CvScalar std_dev) |
static void |
opencv_core.cvAvgSdv(CvArr arr,
CvScalar mean,
CvScalar std_dev,
CvArr mask)
Calculates mean and standard deviation of pixel values
|
static void |
opencv_core.cvBackProjectPCA(CvArr proj,
CvArr mean,
CvArr eigenvects,
CvArr result) |
static CvRect |
opencv_imgproc.cvBoundingRect(CvArr points) |
static CvRect |
opencv_imgproc.cvBoundingRect(CvArr points,
int update)
\brief Calculates contour bounding rectangle (update=1) or
just retrieves pre-calculated rectangle (update=0)
|
static void |
opencv_imgproc.cvCalcArrBackProject(CvArr image,
CvArr dst,
CvHistogram hist) |
static void |
opencv_imgproc.cvCalcArrBackProject(PointerPointer image,
CvArr dst,
CvHistogram hist)
\brief Calculates back project
|
static void |
opencv_imgproc.cvCalcArrBackProjectPatch(CvArr image,
CvArr dst,
CvSize range,
CvHistogram hist,
int method,
double factor) |
static void |
opencv_imgproc.cvCalcArrBackProjectPatch(PointerPointer image,
CvArr dst,
CvSize range,
CvHistogram hist,
int method,
double factor)
\brief Locates a template within an image by using a histogram comparison.
|
static void |
opencv_imgproc.cvCalcArrHist(CvArr arr,
CvHistogram hist) |
static void |
opencv_imgproc.cvCalcArrHist(CvArr arr,
CvHistogram hist,
int accumulate,
CvArr mask) |
static void |
opencv_imgproc.cvCalcArrHist(PointerPointer arr,
CvHistogram hist,
int accumulate,
CvArr mask)
\brief Calculates array histogram
|
static void |
opencv_imgproc.cvCalcBackProject(IplImage image,
CvArr dst,
CvHistogram hist) |
static void |
opencv_imgproc.cvCalcBackProject(PointerPointer image,
CvArr dst,
CvHistogram hist) |
static void |
opencv_imgproc.cvCalcBackProjectPatch(IplImage image,
CvArr dst,
CvSize range,
CvHistogram hist,
int method,
double factor) |
static void |
opencv_imgproc.cvCalcBackProjectPatch(PointerPointer image,
CvArr dst,
CvSize range,
CvHistogram hist,
int method,
double factor) |
static void |
opencv_core.cvCalcCovarMatrix(CvArr vects,
int count,
CvArr cov_mat,
CvArr avg,
int flags) |
static void |
opencv_core.cvCalcCovarMatrix(PointerPointer vects,
int count,
CvArr cov_mat,
CvArr avg,
int flags)
Calculates covariation matrix for a set of vectors
|
static float |
opencv_imgproc.cvCalcEMD2(CvArr signature1,
CvArr signature2,
int distance_type) |
static float |
opencv_imgproc.cvCalcEMD2(CvArr signature1,
CvArr signature2,
int distance_type,
CvDistanceFunction distance_func,
CvArr cost_matrix,
CvArr flow,
float[] lower_bound,
Pointer userdata) |
static float |
opencv_imgproc.cvCalcEMD2(CvArr signature1,
CvArr signature2,
int distance_type,
CvDistanceFunction distance_func,
CvArr cost_matrix,
CvArr flow,
FloatBuffer lower_bound,
Pointer userdata) |
static float |
opencv_imgproc.cvCalcEMD2(CvArr signature1,
CvArr signature2,
int distance_type,
CvDistanceFunction distance_func,
CvArr cost_matrix,
CvArr flow,
FloatPointer lower_bound,
Pointer userdata)
\brief Computes earth mover distance between
two weighted point sets (called signatures)
|
static void |
opencv_imgproc.cvCalcHist(IplImage image,
CvHistogram hist,
int accumulate,
CvArr mask) |
static void |
opencv_imgproc.cvCalcHist(PointerPointer image,
CvHistogram hist,
int accumulate,
CvArr mask)
\overload
|
static void |
opencv_core.cvCalcPCA(CvArr data,
CvArr mean,
CvArr eigenvals,
CvArr eigenvects,
int flags) |
static void |
opencv_imgproc.cvCanny(CvArr image,
CvArr edges,
double threshold1,
double threshold2) |
static void |
opencv_imgproc.cvCanny(CvArr image,
CvArr edges,
double threshold1,
double threshold2,
int aperture_size)
\brief Runs canny edge detector
|
static void |
opencv_core.cvCartToPolar(CvArr x,
CvArr y,
CvArr magnitude) |
static void |
opencv_core.cvCartToPolar(CvArr x,
CvArr y,
CvArr magnitude,
CvArr angle,
int angle_in_degrees)
Does cartesian->polar coordinates conversion.
|
static int |
opencv_core.cvCheckArr(CvArr arr) |
static int |
opencv_core.cvCheckArr(CvArr arr,
int flags,
double min_val,
double max_val)
Checks array values for NaNs, Infs or simply for too large numbers
(if CV_CHECK_RANGE is set).
|
static int |
opencv_core.cvCheckArray(CvArr arg1,
int arg2,
double arg3,
double arg4) |
static int |
opencv_imgproc.cvCheckContourConvexity(CvArr contour)
\brief Checks whether the contour is convex or not (returns 1 if convex, 0 if not)
|
static void |
opencv_imgproc.cvCircle(CvArr img,
CvPoint center,
int radius,
CvScalar color) |
static void |
opencv_imgproc.cvCircle(CvArr img,
CvPoint center,
int radius,
CvScalar color,
int thickness,
int line_type,
int shift)
\brief Draws a circle with specified center and radius.
|
static void |
opencv_imgproc.cvCircle(CvArr img,
int[] center,
int radius,
CvScalar color) |
static void |
opencv_imgproc.cvCircle(CvArr img,
int[] center,
int radius,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvCircle(CvArr img,
IntBuffer center,
int radius,
CvScalar color) |
static void |
opencv_imgproc.cvCircle(CvArr img,
IntBuffer center,
int radius,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_core.cvClearND(CvArr arr,
int[] idx) |
static void |
opencv_core.cvClearND(CvArr arr,
IntBuffer idx) |
static void |
opencv_core.cvClearND(CvArr arr,
IntPointer idx)
clears element of ND dense array,
in case of sparse arrays it deletes the specified node
|
static void |
opencv_core.cvCmp(CvArr src1,
CvArr src2,
CvArr dst,
int cmp_op)
dst(idx) = src1(idx) _cmp_op_ src2(idx)
|
static void |
opencv_core.cvCmpS(CvArr src,
double value,
CvArr dst,
int cmp_op)
dst(idx) = src1(idx) _cmp_op_ value
|
static double |
opencv_imgproc.cvContourArea(CvArr contour) |
static double |
opencv_imgproc.cvContourArea(CvArr contour,
CvSlice slice,
int oriented)
\brief Calculates area of a contour or contour segment
|
static void |
opencv_core.cvConvert(CvArr src,
CvArr dst) |
static void |
opencv_imgproc.cvConvertMaps(CvArr mapx,
CvArr mapy,
CvArr mapxy,
CvArr mapalpha)
\brief Converts mapx & mapy from floating-point to integer formats for cvRemap
|
static void |
opencv_core.cvConvertScale(CvArr src,
CvArr dst) |
static void |
opencv_core.cvConvertScale(CvArr src,
CvArr dst,
double scale,
double shift)
\brief Converts one array to another with optional linear transformation.
|
static void |
opencv_core.cvConvertScaleAbs(CvArr src,
CvArr dst) |
static void |
opencv_core.cvConvertScaleAbs(CvArr src,
CvArr dst,
double scale,
double shift)
Performs linear transformation on every source array element,
stores absolute value of the result:
dst(x,y,c) = abs(scale*src(x,y,c)+shift).
|
static CvSeq |
opencv_imgproc.cvConvexHull2(CvArr input) |
static CvSeq |
opencv_imgproc.cvConvexHull2(CvArr input,
Pointer hull_storage,
int orientation,
int return_points)
\brief Calculates exact convex hull of 2d point set
|
static CvSeq |
opencv_imgproc.cvConvexityDefects(CvArr contour,
CvArr convexhull) |
static CvSeq |
opencv_imgproc.cvConvexityDefects(CvArr contour,
CvArr convexhull,
CvMemStorage storage)
\brief Finds convexity defects for the contour
|
static void |
opencv_core.cvCopy(CvArr src,
CvArr dst) |
static void |
opencv_core.cvCopy(CvArr src,
CvArr dst,
CvArr mask)
\brief Copies one array to another.
|
static void |
opencv_imgproc.cvCopyMakeBorder(CvArr src,
CvArr dst,
CvPoint offset,
int bordertype) |
static void |
opencv_imgproc.cvCopyMakeBorder(CvArr src,
CvArr dst,
CvPoint offset,
int bordertype,
CvScalar value)
Copies source 2D array inside of the larger destination array and
makes a border of the specified type (IPL_BORDER_*) around the copied area.
|
static void |
opencv_imgproc.cvCopyMakeBorder(CvArr src,
CvArr dst,
int[] offset,
int bordertype) |
static void |
opencv_imgproc.cvCopyMakeBorder(CvArr src,
CvArr dst,
int[] offset,
int bordertype,
CvScalar value) |
static void |
opencv_imgproc.cvCopyMakeBorder(CvArr src,
CvArr dst,
IntBuffer offset,
int bordertype) |
static void |
opencv_imgproc.cvCopyMakeBorder(CvArr src,
CvArr dst,
IntBuffer offset,
int bordertype,
CvScalar value) |
static void |
opencv_imgproc.cvCornerEigenValsAndVecs(CvArr image,
CvArr eigenvv,
int block_size) |
static void |
opencv_imgproc.cvCornerEigenValsAndVecs(CvArr image,
CvArr eigenvv,
int block_size,
int aperture_size)
\brief Calculates eigen values and vectors of 2x2
gradient covariation matrix at every image pixel
|
static void |
opencv_imgproc.cvCornerHarris(CvArr image,
CvArr harris_response,
int block_size) |
static void |
opencv_imgproc.cvCornerHarris(CvArr image,
CvArr harris_response,
int block_size,
int aperture_size,
double k)
\brief Harris corner detector:
|
static void |
opencv_imgproc.cvCornerMinEigenVal(CvArr image,
CvArr eigenval,
int block_size) |
static void |
opencv_imgproc.cvCornerMinEigenVal(CvArr image,
CvArr eigenval,
int block_size,
int aperture_size)
\brief Calculates minimal eigenvalue for 2x2 gradient covariation matrix at
every image pixel
|
static int |
opencv_core.cvCountNonZero(CvArr arr)
Calculates number of non-zero pixels
|
static void |
opencv_core.cvCreateData(CvArr arr)
\brief Allocates array data
|
static CvMat |
opencv_imgproc.cvCreatePyramid(CvArr img,
int extra_layers,
double rate) |
static PointerPointer |
opencv_imgproc.cvCreatePyramid(CvArr img,
int extra_layers,
double rate,
CvSize layer_sizes,
CvArr bufarr,
int calc,
int filter)
\brief Builds pyramid for an image
|
static void |
opencv_core.cvCrossProduct(CvArr src1,
CvArr src2,
CvArr dst)
\brief Calculates the cross product of two 3D vectors.
|
static void |
opencv_imgproc.cvCvtColor(CvArr src,
CvArr dst,
int code)
\brief Converts input array pixels from one color space to another
|
static void |
opencv_core.cvCvtScale(CvArr arg1,
CvArr arg2,
double arg3,
double arg4) |
static void |
opencv_core.cvCvtScaleAbs(CvArr arg1,
CvArr arg2,
double arg3,
double arg4) |
static void |
opencv_core.cvDCT(CvArr src,
CvArr dst,
int flags)
Discrete Cosine Transform
|
static void |
opencv_core.cvDecRefData(CvArr arr)
\brief Decrements an array data reference counter.
|
static double |
opencv_core.cvDet(CvArr mat)
Calculates determinant of input matrix
|
static void |
opencv_core.cvDFT(CvArr src,
CvArr dst,
int flags) |
static void |
opencv_core.cvDFT(CvArr src,
CvArr dst,
int flags,
int nonzero_rows)
Discrete Fourier Transform:
complex->complex,
real->ccs (forward),
ccs->real (inverse)
|
static void |
opencv_imgproc.cvDilate(CvArr src,
CvArr dst) |
static void |
opencv_imgproc.cvDilate(CvArr src,
CvArr dst,
IplConvKernel element,
int iterations)
\brief dilates input image (applies maximum filter) one or more times.
|
static void |
opencv_imgproc.cvDistTransform(CvArr src,
CvArr dst) |
static void |
opencv_imgproc.cvDistTransform(CvArr src,
CvArr dst,
int distance_type,
int mask_size,
float[] mask,
CvArr labels,
int labelType) |
static void |
opencv_imgproc.cvDistTransform(CvArr src,
CvArr dst,
int distance_type,
int mask_size,
FloatBuffer mask,
CvArr labels,
int labelType) |
static void |
opencv_imgproc.cvDistTransform(CvArr src,
CvArr dst,
int distance_type,
int mask_size,
FloatPointer mask,
CvArr labels,
int labelType)
\brief Applies distance transform to binary image
|
static void |
opencv_core.cvDiv(CvArr src1,
CvArr src2,
CvArr dst) |
static void |
opencv_core.cvDiv(CvArr src1,
CvArr src2,
CvArr dst,
double scale)
element-wise division/inversion with scaling:
dst(idx) = src1(idx) * scale / src2(idx)
or dst(idx) = scale / src2(idx) if src1 == 0
|
static double |
opencv_core.cvDotProduct(CvArr src1,
CvArr src2)
\brief Calculates the dot product of two arrays in Euclidean metrics.
|
static void |
opencv_imgproc.cvDrawCircle(CvArr arg1,
CvPoint arg2,
int arg3,
CvScalar arg4,
int arg5,
int arg6,
int arg7) |
static void |
opencv_imgproc.cvDrawCircle(CvArr arg1,
int[] arg2,
int arg3,
CvScalar arg4,
int arg5,
int arg6,
int arg7) |
static void |
opencv_imgproc.cvDrawCircle(CvArr arg1,
IntBuffer arg2,
int arg3,
CvScalar arg4,
int arg5,
int arg6,
int arg7) |
static void |
opencv_imgproc.cvDrawContours(CvArr img,
CvSeq contour,
CvScalar external_color,
CvScalar hole_color,
int max_level) |
static void |
opencv_imgproc.cvDrawContours(CvArr img,
CvSeq contour,
CvScalar external_color,
CvScalar hole_color,
int max_level,
int thickness,
int line_type,
CvPoint offset)
\brief Draws contour outlines or filled interiors on the image
|
static void |
opencv_imgproc.cvDrawContours(CvArr img,
CvSeq contour,
CvScalar external_color,
CvScalar hole_color,
int max_level,
int thickness,
int line_type,
int[] offset) |
static void |
opencv_imgproc.cvDrawContours(CvArr img,
CvSeq contour,
CvScalar external_color,
CvScalar hole_color,
int max_level,
int thickness,
int line_type,
IntBuffer offset) |
static void |
opencv_imgproc.cvDrawEllipse(CvArr arg1,
CvPoint arg2,
CvSize arg3,
double arg4,
double arg5,
double arg6,
CvScalar arg7,
int arg8,
int arg9,
int arg10) |
static void |
opencv_imgproc.cvDrawEllipse(CvArr arg1,
int[] arg2,
CvSize arg3,
double arg4,
double arg5,
double arg6,
CvScalar arg7,
int arg8,
int arg9,
int arg10) |
static void |
opencv_imgproc.cvDrawEllipse(CvArr arg1,
IntBuffer arg2,
CvSize arg3,
double arg4,
double arg5,
double arg6,
CvScalar arg7,
int arg8,
int arg9,
int arg10) |
static void |
opencv_imgproc.cvDrawLine(CvArr arg1,
CvPoint arg2,
CvPoint arg3,
CvScalar arg4,
int arg5,
int arg6,
int arg7) |
static void |
opencv_imgproc.cvDrawLine(CvArr arg1,
int[] arg2,
int[] arg3,
CvScalar arg4,
int arg5,
int arg6,
int arg7) |
static void |
opencv_imgproc.cvDrawLine(CvArr arg1,
IntBuffer arg2,
IntBuffer arg3,
CvScalar arg4,
int arg5,
int arg6,
int arg7) |
static void |
opencv_imgproc.cvDrawPolyLine(CvArr arg1,
CvPoint arg2,
IntPointer arg3,
int arg4,
int arg5,
CvScalar arg6,
int arg7,
int arg8,
int arg9) |
static void |
opencv_imgproc.cvDrawPolyLine(CvArr arg1,
int[] arg2,
int[] arg3,
int arg4,
int arg5,
CvScalar arg6,
int arg7,
int arg8,
int arg9) |
static void |
opencv_imgproc.cvDrawPolyLine(CvArr arg1,
IntBuffer arg2,
IntBuffer arg3,
int arg4,
int arg5,
CvScalar arg6,
int arg7,
int arg8,
int arg9) |
static void |
opencv_imgproc.cvDrawPolyLine(CvArr arg1,
PointerPointer arg2,
IntPointer arg3,
int arg4,
int arg5,
CvScalar arg6,
int arg7,
int arg8,
int arg9) |
static void |
opencv_imgproc.cvDrawRect(CvArr arg1,
CvPoint arg2,
CvPoint arg3,
CvScalar arg4,
int arg5,
int arg6,
int arg7) |
static void |
opencv_imgproc.cvDrawRect(CvArr arg1,
int[] arg2,
int[] arg3,
CvScalar arg4,
int arg5,
int arg6,
int arg7) |
static void |
opencv_imgproc.cvDrawRect(CvArr arg1,
IntBuffer arg2,
IntBuffer arg3,
CvScalar arg4,
int arg5,
int arg6,
int arg7) |
static void |
opencv_core.cvEigenVV(CvArr mat,
CvArr evects,
CvArr evals) |
static void |
opencv_core.cvEigenVV(CvArr mat,
CvArr evects,
CvArr evals,
double eps,
int lowindex,
int highindex)
Finds eigen values and vectors of a symmetric matrix
|
static void |
opencv_imgproc.cvEllipse(CvArr img,
CvPoint center,
CvSize axes,
double angle,
double start_angle,
double end_angle,
CvScalar color) |
static void |
opencv_imgproc.cvEllipse(CvArr img,
CvPoint center,
CvSize axes,
double angle,
double start_angle,
double end_angle,
CvScalar color,
int thickness,
int line_type,
int shift)
\brief Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector
|
static void |
opencv_imgproc.cvEllipse(CvArr img,
int[] center,
CvSize axes,
double angle,
double start_angle,
double end_angle,
CvScalar color) |
static void |
opencv_imgproc.cvEllipse(CvArr img,
int[] center,
CvSize axes,
double angle,
double start_angle,
double end_angle,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvEllipse(CvArr img,
IntBuffer center,
CvSize axes,
double angle,
double start_angle,
double end_angle,
CvScalar color) |
static void |
opencv_imgproc.cvEllipse(CvArr img,
IntBuffer center,
CvSize axes,
double angle,
double start_angle,
double end_angle,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvEllipseBox(CvArr img,
CvBox2D box,
CvScalar color) |
static void |
opencv_imgproc.cvEllipseBox(CvArr img,
CvBox2D box,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvEqualizeHist(CvArr src,
CvArr dst)
\brief equalizes histogram of 8-bit single-channel image
|
static void |
opencv_imgproc.cvErode(CvArr src,
CvArr dst) |
static void |
opencv_imgproc.cvErode(CvArr src,
CvArr dst,
IplConvKernel element,
int iterations)
\brief erodes input image (applies minimum filter) one or more times.
|
static void |
opencv_core.cvExp(CvArr src,
CvArr dst)
Does exponention: dst(idx) = exp(src(idx)).
|
static void |
opencv_core.cvFFT(CvArr arg1,
CvArr arg2,
int arg3,
int arg4) |
static void |
opencv_imgproc.cvFillConvexPoly(CvArr img,
CvPoint pts,
int npts,
CvScalar color) |
static void |
opencv_imgproc.cvFillConvexPoly(CvArr img,
CvPoint pts,
int npts,
CvScalar color,
int line_type,
int shift)
\brief Fills convex or monotonous polygon.
|
static void |
opencv_imgproc.cvFillConvexPoly(CvArr img,
int[] pts,
int npts,
CvScalar color) |
static void |
opencv_imgproc.cvFillConvexPoly(CvArr img,
int[] pts,
int npts,
CvScalar color,
int line_type,
int shift) |
static void |
opencv_imgproc.cvFillConvexPoly(CvArr img,
IntBuffer pts,
int npts,
CvScalar color) |
static void |
opencv_imgproc.cvFillConvexPoly(CvArr img,
IntBuffer pts,
int npts,
CvScalar color,
int line_type,
int shift) |
static void |
opencv_imgproc.cvFillPoly(CvArr img,
CvPoint pts,
IntPointer npts,
int contours,
CvScalar color) |
static void |
opencv_imgproc.cvFillPoly(CvArr img,
CvPoint pts,
IntPointer npts,
int contours,
CvScalar color,
int line_type,
int shift) |
static void |
opencv_imgproc.cvFillPoly(CvArr img,
int[] pts,
int[] npts,
int contours,
CvScalar color) |
static void |
opencv_imgproc.cvFillPoly(CvArr img,
int[] pts,
int[] npts,
int contours,
CvScalar color,
int line_type,
int shift) |
static void |
opencv_imgproc.cvFillPoly(CvArr img,
IntBuffer pts,
IntBuffer npts,
int contours,
CvScalar color) |
static void |
opencv_imgproc.cvFillPoly(CvArr img,
IntBuffer pts,
IntBuffer npts,
int contours,
CvScalar color,
int line_type,
int shift) |
static void |
opencv_imgproc.cvFillPoly(CvArr img,
PointerPointer pts,
IntPointer npts,
int contours,
CvScalar color,
int line_type,
int shift)
\brief Fills an area bounded by one or more arbitrary polygons
|
static void |
opencv_imgproc.cvFilter2D(CvArr src,
CvArr dst,
CvMat kernel) |
static void |
opencv_imgproc.cvFilter2D(CvArr src,
CvArr dst,
CvMat kernel,
CvPoint anchor)
\brief Convolves an image with the kernel.
|
static void |
opencv_imgproc.cvFilter2D(CvArr src,
CvArr dst,
CvMat kernel,
int[] anchor) |
static void |
opencv_imgproc.cvFilter2D(CvArr src,
CvArr dst,
CvMat kernel,
IntBuffer anchor) |
static int |
opencv_imgproc.cvFindContours(CvArr image,
CvMemStorage storage,
CvSeq first_contour) |
static int |
opencv_imgproc.cvFindContours(CvArr image,
CvMemStorage storage,
CvSeq first_contour,
int header_size,
int mode,
int method,
CvPoint offset) |
static int |
opencv_imgproc.cvFindContours(CvArr image,
CvMemStorage storage,
CvSeq first_contour,
int header_size,
int mode,
int method,
int[] offset) |
static int |
opencv_imgproc.cvFindContours(CvArr image,
CvMemStorage storage,
CvSeq first_contour,
int header_size,
int mode,
int method,
IntBuffer offset) |
static int |
opencv_imgproc.cvFindContours(CvArr image,
CvMemStorage storage,
PointerPointer first_contour,
int header_size,
int mode,
int method,
CvPoint offset)
\brief Retrieves outer and optionally inner boundaries of white (non-zero) connected
components in the black (zero) background
|
static void |
opencv_imgproc.cvFindCornerSubPix(CvArr image,
CvPoint2D32f corners,
int count,
CvSize win,
CvSize zero_zone,
CvTermCriteria criteria)
\brief Adjust corner position using some sort of gradient search
|
static void |
opencv_imgproc.cvFindCornerSubPix(CvArr image,
float[] corners,
int count,
CvSize win,
CvSize zero_zone,
CvTermCriteria criteria) |
static void |
opencv_imgproc.cvFindCornerSubPix(CvArr image,
FloatBuffer corners,
int count,
CvSize win,
CvSize zero_zone,
CvTermCriteria criteria) |
static CvBox2D |
opencv_imgproc.cvFitEllipse2(CvArr points)
\brief Fits ellipse into a set of 2d points
|
static void |
opencv_imgproc.cvFitLine(CvArr points,
int dist_type,
double param,
double reps,
double aeps,
float[] line) |
static void |
opencv_imgproc.cvFitLine(CvArr points,
int dist_type,
double param,
double reps,
double aeps,
FloatBuffer line) |
static void |
opencv_imgproc.cvFitLine(CvArr points,
int dist_type,
double param,
double reps,
double aeps,
FloatPointer line)
\brief Fits a line into set of 2d or 3d points in a robust way (M-estimator technique)
|
static void |
opencv_core.cvFlip(CvArr src) |
static void |
opencv_core.cvFlip(CvArr src,
CvArr dst,
int flip_mode)
Mirror array data around horizontal (flip=0),
vertical (flip=1) or both(flip=-1) axises:
cvFlip(src) flips images vertically and sequences horizontally (inplace)
|
static void |
opencv_imgproc.cvFloodFill(CvArr image,
CvPoint seed_point,
CvScalar new_val) |
static void |
opencv_imgproc.cvFloodFill(CvArr image,
CvPoint seed_point,
CvScalar new_val,
CvScalar lo_diff,
CvScalar up_diff,
CvConnectedComp comp,
int flags,
CvArr mask)
\brief Fills the connected component until the color difference gets large enough
|
static void |
opencv_imgproc.cvFloodFill(CvArr image,
int[] seed_point,
CvScalar new_val) |
static void |
opencv_imgproc.cvFloodFill(CvArr image,
int[] seed_point,
CvScalar new_val,
CvScalar lo_diff,
CvScalar up_diff,
CvConnectedComp comp,
int flags,
CvArr mask) |
static void |
opencv_imgproc.cvFloodFill(CvArr image,
IntBuffer seed_point,
CvScalar new_val) |
static void |
opencv_imgproc.cvFloodFill(CvArr image,
IntBuffer seed_point,
CvScalar new_val,
CvScalar lo_diff,
CvScalar up_diff,
CvConnectedComp comp,
int flags,
CvArr mask) |
static void |
opencv_core.cvGEMM(CvArr src1,
CvArr src2,
double alpha,
CvArr src3,
double beta,
CvArr dst) |
static void |
opencv_core.cvGEMM(CvArr src1,
CvArr src2,
double alpha,
CvArr src3,
double beta,
CvArr dst,
int tABC)
Extended matrix transform:
dst = alpha*op(A)*op(B) + beta*op(C), where op(X) is X or X^T
|
static CvScalar |
opencv_core.cvGet1D(CvArr arr,
int idx0)
\brief Return a specific array element.
|
static CvScalar |
opencv_core.cvGet2D(CvArr arr,
int idx0,
int idx1)
\overload
|
static CvScalar |
opencv_core.cvGet3D(CvArr arr,
int idx0,
int idx1,
int idx2)
\overload
|
static CvMat |
opencv_core.cvGetCol(CvArr arr,
CvMat submat,
int col)
\overload
|
static CvMat |
opencv_core.cvGetCols(CvArr arr,
CvMat submat,
int start_col,
int end_col)
\brief Returns one of more array columns.
|
static CvMat |
opencv_core.cvGetDiag(CvArr arr,
CvMat submat) |
static CvMat |
opencv_core.cvGetDiag(CvArr arr,
CvMat submat,
int diag)
\brief Returns one of array diagonals.
|
static int |
opencv_core.cvGetDims(CvArr arr) |
static int |
opencv_core.cvGetDims(CvArr arr,
int[] sizes) |
static int |
opencv_core.cvGetDims(CvArr arr,
IntBuffer sizes) |
static int |
opencv_core.cvGetDims(CvArr arr,
IntPointer sizes)
\brief Return number of array dimensions
|
static int |
opencv_core.cvGetDimSize(CvArr arr,
int index)
\brief Returns array size along the specified dimension.
|
static int |
opencv_core.cvGetElemType(CvArr arr)
\brief Returns type of array elements.
|
static IplImage |
opencv_core.cvGetImage(CvArr arr,
IplImage image_header)
\brief Returns image header for arbitrary array.
|
static CvMat |
opencv_core.cvGetMat(CvArr arr,
CvMat header) |
static CvMat |
opencv_core.cvGetMat(CvArr arr,
CvMat header,
int[] coi,
int allowND) |
static CvMat |
opencv_core.cvGetMat(CvArr arr,
CvMat header,
IntBuffer coi,
int allowND) |
static CvMat |
opencv_core.cvGetMat(CvArr arr,
CvMat header,
IntPointer coi,
int allowND)
\brief Returns matrix header for arbitrary array.
|
static CvScalar |
opencv_core.cvGetND(CvArr arr,
int[] idx) |
static CvScalar |
opencv_core.cvGetND(CvArr arr,
IntBuffer idx) |
static CvScalar |
opencv_core.cvGetND(CvArr arr,
IntPointer idx)
\overload
|
static void |
opencv_imgproc.cvGetQuadrangleSubPix(CvArr src,
CvArr dst,
CvMat map_matrix)
\brief Retrieves quadrangle from the input array.
|
static void |
opencv_core.cvGetRawData(CvArr arr,
byte[] data) |
static void |
opencv_core.cvGetRawData(CvArr arr,
byte[] data,
int[] step,
CvSize roi_size) |
static void |
opencv_core.cvGetRawData(CvArr arr,
ByteBuffer data) |
static void |
opencv_core.cvGetRawData(CvArr arr,
ByteBuffer data,
IntBuffer step,
CvSize roi_size) |
static void |
opencv_core.cvGetRawData(CvArr arr,
BytePointer data) |
static void |
opencv_core.cvGetRawData(CvArr arr,
BytePointer data,
IntPointer step,
CvSize roi_size) |
static void |
opencv_core.cvGetRawData(CvArr arr,
PointerPointer data,
IntPointer step,
CvSize roi_size)
\brief Retrieves low-level information about the array.
|
static double |
opencv_core.cvGetReal1D(CvArr arr,
int idx0)
\brief Return a specific element of single-channel 1D, 2D, 3D or nD array.
|
static double |
opencv_core.cvGetReal2D(CvArr arr,
int idx0,
int idx1)
\overload
|
static double |
opencv_core.cvGetReal3D(CvArr arr,
int idx0,
int idx1,
int idx2)
\overload
|
static double |
opencv_core.cvGetRealND(CvArr arr,
int[] idx) |
static double |
opencv_core.cvGetRealND(CvArr arr,
IntBuffer idx) |
static double |
opencv_core.cvGetRealND(CvArr arr,
IntPointer idx)
\overload
|
static void |
opencv_imgproc.cvGetRectSubPix(CvArr src,
CvArr dst,
CvPoint2D32f center)
\brief Retrieves the rectangular image region with specified center from the input array.
|
static void |
opencv_imgproc.cvGetRectSubPix(CvArr src,
CvArr dst,
float[] center) |
static void |
opencv_imgproc.cvGetRectSubPix(CvArr src,
CvArr dst,
FloatBuffer center) |
static CvMat |
opencv_core.cvGetRow(CvArr arr,
CvMat submat,
int row)
\overload
|
static CvMat |
opencv_core.cvGetRows(CvArr arr,
CvMat submat,
int start_row,
int end_row) |
static CvMat |
opencv_core.cvGetRows(CvArr arr,
CvMat submat,
int start_row,
int end_row,
int delta_row)
\brief Returns array row or row span.
|
static CvSize |
opencv_core.cvGetSize(CvArr arr)
\brief Returns size of matrix or image ROI.
|
static CvMat |
opencv_core.cvGetSubArr(CvArr arg1,
CvMat arg2,
CvRect arg3) |
static CvMat |
opencv_core.cvGetSubRect(CvArr arr,
CvMat submat,
CvRect rect)
\brief Returns matrix header corresponding to the rectangular sub-array of input image or matrix.
|
static void |
opencv_imgproc.cvGoodFeaturesToTrack(CvArr image,
CvArr eig_image,
CvArr temp_image,
CvPoint2D32f corners,
IntPointer corner_count,
double quality_level,
double min_distance) |
static void |
opencv_imgproc.cvGoodFeaturesToTrack(CvArr image,
CvArr eig_image,
CvArr temp_image,
CvPoint2D32f corners,
IntPointer corner_count,
double quality_level,
double min_distance,
CvArr mask,
int block_size,
int use_harris,
double k)
\brief Finds a sparse set of points within the selected region
that seem to be easy to track
|
static void |
opencv_imgproc.cvGoodFeaturesToTrack(CvArr image,
CvArr eig_image,
CvArr temp_image,
float[] corners,
int[] corner_count,
double quality_level,
double min_distance) |
static void |
opencv_imgproc.cvGoodFeaturesToTrack(CvArr image,
CvArr eig_image,
CvArr temp_image,
float[] corners,
int[] corner_count,
double quality_level,
double min_distance,
CvArr mask,
int block_size,
int use_harris,
double k) |
static void |
opencv_imgproc.cvGoodFeaturesToTrack(CvArr image,
CvArr eig_image,
CvArr temp_image,
FloatBuffer corners,
IntBuffer corner_count,
double quality_level,
double min_distance) |
static void |
opencv_imgproc.cvGoodFeaturesToTrack(CvArr image,
CvArr eig_image,
CvArr temp_image,
FloatBuffer corners,
IntBuffer corner_count,
double quality_level,
double min_distance,
CvArr mask,
int block_size,
int use_harris,
double k) |
static CvSeq |
opencv_imgproc.cvHoughCircles(CvArr image,
Pointer circle_storage,
int method,
double dp,
double min_dist) |
static CvSeq |
opencv_imgproc.cvHoughCircles(CvArr image,
Pointer circle_storage,
int method,
double dp,
double min_dist,
double param1,
double param2,
int min_radius,
int max_radius)
\brief Finds circles in the image
|
static CvSeq |
opencv_imgproc.cvHoughLines2(CvArr image,
Pointer line_storage,
int method,
double rho,
double theta,
int threshold) |
static CvSeq |
opencv_imgproc.cvHoughLines2(CvArr image,
Pointer line_storage,
int method,
double rho,
double theta,
int threshold,
double param1,
double param2,
double min_theta,
double max_theta)
\brief Finds lines on binary image using one of several methods.
|
static int |
opencv_core.cvIncRefData(CvArr arr)
\brief Increments array data reference counter.
|
static int |
opencv_imgproc.cvInitLineIterator(CvArr image,
CvPoint pt1,
CvPoint pt2,
CvLineIterator line_iterator) |
static int |
opencv_imgproc.cvInitLineIterator(CvArr image,
CvPoint pt1,
CvPoint pt2,
CvLineIterator line_iterator,
int connectivity,
int left_to_right)
\brief Initializes line iterator.
|
static int |
opencv_imgproc.cvInitLineIterator(CvArr image,
int[] pt1,
int[] pt2,
CvLineIterator line_iterator) |
static int |
opencv_imgproc.cvInitLineIterator(CvArr image,
int[] pt1,
int[] pt2,
CvLineIterator line_iterator,
int connectivity,
int left_to_right) |
static int |
opencv_imgproc.cvInitLineIterator(CvArr image,
IntBuffer pt1,
IntBuffer pt2,
CvLineIterator line_iterator) |
static int |
opencv_imgproc.cvInitLineIterator(CvArr image,
IntBuffer pt1,
IntBuffer pt2,
CvLineIterator line_iterator,
int connectivity,
int left_to_right) |
static int |
opencv_core.cvInitNArrayIterator(int count,
CvArr arrs,
CvArr mask,
CvMatND stubs,
CvNArrayIterator array_iterator) |
static int |
opencv_core.cvInitNArrayIterator(int count,
CvArr arrs,
CvArr mask,
CvMatND stubs,
CvNArrayIterator array_iterator,
int flags) |
static int |
opencv_core.cvInitNArrayIterator(int count,
PointerPointer arrs,
CvArr mask,
CvMatND stubs,
CvNArrayIterator array_iterator,
int flags)
initializes iterator that traverses through several arrays simultaneously
(the function together with cvNextArraySlice is used for
N-ari element-wise operations)
|
static void |
opencv_core.cvInRange(CvArr src,
CvArr lower,
CvArr upper,
CvArr dst)
dst(idx) = lower(idx) <= src(idx) < upper(idx)
|
static void |
opencv_core.cvInRangeS(CvArr src,
CvScalar lower,
CvScalar upper,
CvArr dst)
dst(idx) = lower <= src(idx) < upper
|
static void |
opencv_imgproc.cvIntegral(CvArr image,
CvArr sum) |
static void |
opencv_imgproc.cvIntegral(CvArr image,
CvArr sum,
CvArr sqsum,
CvArr tilted_sum)
\brief Finds integral image: SUM(X,Y) = sum(x |
static void |
opencv_core.cvInv(CvArr arg1,
CvArr arg2,
int arg3) |
static double |
opencv_core.cvInvert(CvArr src,
CvArr dst) |
static double |
opencv_core.cvInvert(CvArr src,
CvArr dst,
int method)
Inverts matrix
|
static int |
opencv_core.cvKMeans2(CvArr samples,
int cluster_count,
CvArr labels,
CvTermCriteria termcrit) |
static int |
opencv_core.cvKMeans2(CvArr samples,
int cluster_count,
CvArr labels,
CvTermCriteria termcrit,
int attempts,
long[] rng,
int flags,
CvArr _centers,
double[] compactness) |
static int |
opencv_core.cvKMeans2(CvArr samples,
int cluster_count,
CvArr labels,
CvTermCriteria termcrit,
int attempts,
LongBuffer rng,
int flags,
CvArr _centers,
DoubleBuffer compactness) |
static int |
opencv_core.cvKMeans2(CvArr samples,
int cluster_count,
CvArr labels,
CvTermCriteria termcrit,
int attempts,
LongPointer rng,
int flags,
CvArr _centers,
DoublePointer compactness) |
static void |
opencv_imgproc.cvLaplace(CvArr src,
CvArr dst) |
static void |
opencv_imgproc.cvLaplace(CvArr src,
CvArr dst,
int aperture_size)
\brief Calculates the image Laplacian: (d2/dx + d2/dy)I
|
static void |
opencv_imgproc.cvLine(CvArr img,
CvPoint pt1,
CvPoint pt2,
CvScalar color) |
static void |
opencv_imgproc.cvLine(CvArr img,
CvPoint pt1,
CvPoint pt2,
CvScalar color,
int thickness,
int line_type,
int shift)
\brief Draws 4-connected, 8-connected or antialiased line segment connecting two points
|
static void |
opencv_imgproc.cvLine(CvArr img,
int[] pt1,
int[] pt2,
CvScalar color) |
static void |
opencv_imgproc.cvLine(CvArr img,
int[] pt1,
int[] pt2,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvLine(CvArr img,
IntBuffer pt1,
IntBuffer pt2,
CvScalar color) |
static void |
opencv_imgproc.cvLine(CvArr img,
IntBuffer pt1,
IntBuffer pt2,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvLinearPolar(CvArr src,
CvArr dst,
CvPoint2D32f center,
double maxRadius) |
static void |
opencv_imgproc.cvLinearPolar(CvArr src,
CvArr dst,
CvPoint2D32f center,
double maxRadius,
int flags)
Performs forward or inverse linear-polar image transform
|
static void |
opencv_imgproc.cvLinearPolar(CvArr src,
CvArr dst,
float[] center,
double maxRadius) |
static void |
opencv_imgproc.cvLinearPolar(CvArr src,
CvArr dst,
float[] center,
double maxRadius,
int flags) |
static void |
opencv_imgproc.cvLinearPolar(CvArr src,
CvArr dst,
FloatBuffer center,
double maxRadius) |
static void |
opencv_imgproc.cvLinearPolar(CvArr src,
CvArr dst,
FloatBuffer center,
double maxRadius,
int flags) |
static void |
opencv_core.cvLog(CvArr src,
CvArr dst)
Calculates natural logarithms: dst(idx) = log(abs(src(idx))).
|
static void |
opencv_imgproc.cvLogPolar(CvArr src,
CvArr dst,
CvPoint2D32f center,
double M) |
static void |
opencv_imgproc.cvLogPolar(CvArr src,
CvArr dst,
CvPoint2D32f center,
double M,
int flags)
\brief Performs forward or inverse log-polar image transform
|
static void |
opencv_imgproc.cvLogPolar(CvArr src,
CvArr dst,
float[] center,
double M) |
static void |
opencv_imgproc.cvLogPolar(CvArr src,
CvArr dst,
float[] center,
double M,
int flags) |
static void |
opencv_imgproc.cvLogPolar(CvArr src,
CvArr dst,
FloatBuffer center,
double M) |
static void |
opencv_imgproc.cvLogPolar(CvArr src,
CvArr dst,
FloatBuffer center,
double M,
int flags) |
static void |
opencv_core.cvLUT(CvArr src,
CvArr dst,
CvArr lut)
Does look-up transformation.
|
static double |
opencv_core.cvMahalanobis(CvArr vec1,
CvArr vec2,
CvArr mat)
Calculates Mahalanobis(weighted) distance
|
static double |
opencv_core.cvMahalonobis(CvArr arg1,
CvArr arg2,
CvArr arg3) |
static void |
opencv_imgproc.cvMatchTemplate(CvArr image,
CvArr templ,
CvArr result,
int method)
\brief Measures similarity between template and overlapped windows in the source image
and fills the resultant image with the measurements
|
static void |
opencv_core.cvMatMul(CvArr src1,
CvArr src2,
CvArr dst) |
static void |
opencv_core.cvMatMulAdd(CvArr src1,
CvArr src2,
CvArr src3,
CvArr dst)
Matrix transform: dst = A*B + C, C is optional
|
static void |
opencv_core.cvMatMulAddEx(CvArr arg1,
CvArr arg2,
double arg3,
CvArr arg4,
double arg5,
CvArr arg6,
int arg7) |
static void |
opencv_core.cvMatMulAddS(CvArr arg1,
CvArr arg2,
CvMat arg3,
CvMat arg4) |
static void |
opencv_core.cvMax(CvArr src1,
CvArr src2,
CvArr dst)
dst(idx) = max(src1(idx),src2(idx))
|
static void |
opencv_core.cvMaxS(CvArr src,
double value,
CvArr dst)
dst(idx) = max(src(idx),value)
|
static void |
opencv_core.cvMerge(CvArr src0,
CvArr src1,
CvArr src2,
CvArr src3,
CvArr dst)
Merges a set of single-channel arrays into the single multi-channel array
or inserts one particular [color] plane to the array
|
static void |
opencv_core.cvMin(CvArr src1,
CvArr src2,
CvArr dst)
dst(idx) = min(src1(idx),src2(idx))
|
static CvBox2D |
opencv_imgproc.cvMinAreaRect2(CvArr points) |
static CvBox2D |
opencv_imgproc.cvMinAreaRect2(CvArr points,
CvMemStorage storage)
\brief Finds minimum area rotated rectangle bounding a set of points
|
static int |
opencv_imgproc.cvMinEnclosingCircle(CvArr points,
CvPoint2D32f center,
FloatPointer radius)
\brief Finds minimum enclosing circle for a set of points
|
static int |
opencv_imgproc.cvMinEnclosingCircle(CvArr points,
float[] center,
float[] radius) |
static int |
opencv_imgproc.cvMinEnclosingCircle(CvArr points,
FloatBuffer center,
FloatBuffer radius) |
static void |
opencv_core.cvMinMaxLoc(CvArr arr,
double[] min_val,
double[] max_val) |
static void |
opencv_core.cvMinMaxLoc(CvArr arr,
double[] min_val,
double[] max_val,
int[] min_loc,
int[] max_loc,
CvArr mask) |
static void |
opencv_core.cvMinMaxLoc(CvArr arr,
DoubleBuffer min_val,
DoubleBuffer max_val) |
static void |
opencv_core.cvMinMaxLoc(CvArr arr,
DoubleBuffer min_val,
DoubleBuffer max_val,
IntBuffer min_loc,
IntBuffer max_loc,
CvArr mask) |
static void |
opencv_core.cvMinMaxLoc(CvArr arr,
DoublePointer min_val,
DoublePointer max_val) |
static void |
opencv_core.cvMinMaxLoc(CvArr arr,
DoublePointer min_val,
DoublePointer max_val,
CvPoint min_loc,
CvPoint max_loc,
CvArr mask)
Finds global minimum, maximum and their positions
|
static void |
opencv_core.cvMinS(CvArr src,
double value,
CvArr dst)
dst(idx) = min(src(idx),value)
|
static void |
opencv_core.cvMirror(CvArr arg1,
CvArr arg2,
int arg3) |
static void |
opencv_core.cvMixChannels(CvArr src,
int src_count,
CvArr dst,
int dst_count,
int[] from_to,
int pair_count) |
static void |
opencv_core.cvMixChannels(CvArr src,
int src_count,
CvArr dst,
int dst_count,
IntBuffer from_to,
int pair_count) |
static void |
opencv_core.cvMixChannels(CvArr src,
int src_count,
CvArr dst,
int dst_count,
IntPointer from_to,
int pair_count) |
static void |
opencv_imgproc.cvMoments(CvArr arr,
CvMoments moments) |
static void |
opencv_imgproc.cvMoments(CvArr arr,
CvMoments moments,
int binary)
\brief Calculates all spatial and central moments up to the 3rd order
|
static void |
opencv_imgproc.cvMorphologyEx(CvArr src,
CvArr dst,
CvArr temp,
IplConvKernel element,
int operation) |
static void |
opencv_imgproc.cvMorphologyEx(CvArr src,
CvArr dst,
CvArr temp,
IplConvKernel element,
int operation,
int iterations)
\brief Performs complex morphological transformation
|
static void |
opencv_core.cvMul(CvArr src1,
CvArr src2,
CvArr dst) |
static void |
opencv_core.cvMul(CvArr src1,
CvArr src2,
CvArr dst,
double scale)
dst(idx) = src1(idx) * src2(idx) * scale
(scaled element-wise multiplication of 2 arrays)
|
static void |
opencv_core.cvMulSpectrums(CvArr src1,
CvArr src2,
CvArr dst,
int flags)
Multiply results of DFTs: DFT(X)*DFT(Y) or DFT(X)*conj(DFT(Y))
|
static void |
opencv_imgproc.cvMultiplyAcc(CvArr image1,
CvArr image2,
CvArr acc) |
static void |
opencv_imgproc.cvMultiplyAcc(CvArr image1,
CvArr image2,
CvArr acc,
CvArr mask)
\brief Adds a product of two images to accumulator
|
static void |
opencv_core.cvMulTransposed(CvArr src,
CvArr dst,
int order) |
static void |
opencv_core.cvMulTransposed(CvArr src,
CvArr dst,
int order,
CvArr delta,
double scale)
Calculates (A-delta)*(A-delta)^T (order=0) or (A-delta)^T*(A-delta) (order=1)
|
static double |
opencv_core.cvNorm(CvArr arr1) |
static double |
opencv_core.cvNorm(CvArr arr1,
CvArr arr2,
int norm_type,
CvArr mask)
Finds norm, difference norm or relative difference norm for an array (or two arrays)
|
static void |
opencv_core.cvNormalize(CvArr src,
CvArr dst) |
static void |
opencv_core.cvNormalize(CvArr src,
CvArr dst,
double a,
double b,
int norm_type,
CvArr mask) |
static void |
opencv_core.cvNot(CvArr src,
CvArr dst)
dst(idx) = ~src(idx)
|
static void |
opencv_core.cvOr(CvArr src1,
CvArr src2,
CvArr dst) |
static void |
opencv_core.cvOr(CvArr src1,
CvArr src2,
CvArr dst,
CvArr mask)
dst(idx) = src1(idx) | src2(idx)
|
static void |
opencv_core.cvOrS(CvArr src,
CvScalar value,
CvArr dst) |
static void |
opencv_core.cvOrS(CvArr src,
CvScalar value,
CvArr dst,
CvArr mask)
dst(idx) = src(idx) | value
|
static void |
opencv_core.cvPerspectiveTransform(CvArr src,
CvArr dst,
CvMat mat)
Does perspective transform on every element of input array
|
static double |
opencv_imgproc.cvPointPolygonTest(CvArr contour,
CvPoint2D32f pt,
int measure_dist)
\brief Checks whether the point is inside polygon, outside, on an edge (at a vertex).
|
static double |
opencv_imgproc.cvPointPolygonTest(CvArr contour,
float[] pt,
int measure_dist) |
static double |
opencv_imgproc.cvPointPolygonTest(CvArr contour,
FloatBuffer pt,
int measure_dist) |
static CvSeq |
opencv_imgproc.cvPointSeqFromMat(int seq_kind,
CvArr mat,
CvContour contour_header,
CvSeqBlock block)
\brief Initializes sequence header for a matrix (column or row vector) of points
|
static void |
opencv_core.cvPolarToCart(CvArr magnitude,
CvArr angle,
CvArr x,
CvArr y) |
static void |
opencv_core.cvPolarToCart(CvArr magnitude,
CvArr angle,
CvArr x,
CvArr y,
int angle_in_degrees)
Does polar->cartesian coordinates conversion.
|
static void |
opencv_imgproc.cvPolyLine(CvArr img,
CvPoint pts,
IntPointer npts,
int contours,
int is_closed,
CvScalar color) |
static void |
opencv_imgproc.cvPolyLine(CvArr img,
CvPoint pts,
IntPointer npts,
int contours,
int is_closed,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvPolyLine(CvArr img,
int[] pts,
int[] npts,
int contours,
int is_closed,
CvScalar color) |
static void |
opencv_imgproc.cvPolyLine(CvArr img,
int[] pts,
int[] npts,
int contours,
int is_closed,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvPolyLine(CvArr img,
IntBuffer pts,
IntBuffer npts,
int contours,
int is_closed,
CvScalar color) |
static void |
opencv_imgproc.cvPolyLine(CvArr img,
IntBuffer pts,
IntBuffer npts,
int contours,
int is_closed,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvPolyLine(CvArr img,
PointerPointer pts,
IntPointer npts,
int contours,
int is_closed,
CvScalar color,
int thickness,
int line_type,
int shift)
\brief Draws one or more polygonal curves
|
static void |
opencv_core.cvPow(CvArr src,
CvArr dst,
double power)
Does powering: dst(idx) = src(idx)^power
|
static void |
opencv_imgproc.cvPreCornerDetect(CvArr image,
CvArr corners) |
static void |
opencv_imgproc.cvPreCornerDetect(CvArr image,
CvArr corners,
int aperture_size)
\brief Calculates constraint image for corner detection
|
static void |
opencv_core.cvProjectPCA(CvArr data,
CvArr mean,
CvArr eigenvects,
CvArr result) |
static BytePointer |
opencv_core.cvPtr1D(CvArr arr,
int idx0) |
static byte[] |
opencv_core.cvPtr1D(CvArr arr,
int idx0,
int[] type) |
static ByteBuffer |
opencv_core.cvPtr1D(CvArr arr,
int idx0,
IntBuffer type) |
static BytePointer |
opencv_core.cvPtr1D(CvArr arr,
int idx0,
IntPointer type)
\brief Return pointer to a particular array element.
|
static BytePointer |
opencv_core.cvPtr2D(CvArr arr,
int idx0,
int idx1) |
static byte[] |
opencv_core.cvPtr2D(CvArr arr,
int idx0,
int idx1,
int[] type) |
static ByteBuffer |
opencv_core.cvPtr2D(CvArr arr,
int idx0,
int idx1,
IntBuffer type) |
static BytePointer |
opencv_core.cvPtr2D(CvArr arr,
int idx0,
int idx1,
IntPointer type)
\overload
|
static BytePointer |
opencv_core.cvPtr3D(CvArr arr,
int idx0,
int idx1,
int idx2) |
static byte[] |
opencv_core.cvPtr3D(CvArr arr,
int idx0,
int idx1,
int idx2,
int[] type) |
static ByteBuffer |
opencv_core.cvPtr3D(CvArr arr,
int idx0,
int idx1,
int idx2,
IntBuffer type) |
static BytePointer |
opencv_core.cvPtr3D(CvArr arr,
int idx0,
int idx1,
int idx2,
IntPointer type)
\overload
|
static byte[] |
opencv_core.cvPtrND(CvArr arr,
int[] idx) |
static byte[] |
opencv_core.cvPtrND(CvArr arr,
int[] idx,
int[] type,
int create_node,
int[] precalc_hashval) |
static ByteBuffer |
opencv_core.cvPtrND(CvArr arr,
IntBuffer idx) |
static ByteBuffer |
opencv_core.cvPtrND(CvArr arr,
IntBuffer idx,
IntBuffer type,
int create_node,
IntBuffer precalc_hashval) |
static BytePointer |
opencv_core.cvPtrND(CvArr arr,
IntPointer idx) |
static BytePointer |
opencv_core.cvPtrND(CvArr arr,
IntPointer idx,
IntPointer type,
int create_node,
IntPointer precalc_hashval)
\overload
|
static void |
opencv_imgproc.cvPutText(CvArr img,
BytePointer text,
CvPoint org,
CvFont font,
CvScalar color)
\brief Renders text stroke with specified font and color at specified location.
|
static void |
opencv_imgproc.cvPutText(CvArr img,
BytePointer text,
int[] org,
CvFont font,
CvScalar color) |
static void |
opencv_imgproc.cvPutText(CvArr img,
BytePointer text,
IntBuffer org,
CvFont font,
CvScalar color) |
static void |
opencv_imgproc.cvPutText(CvArr img,
String text,
CvPoint org,
CvFont font,
CvScalar color) |
static void |
opencv_imgproc.cvPutText(CvArr img,
String text,
int[] org,
CvFont font,
CvScalar color) |
static void |
opencv_imgproc.cvPutText(CvArr img,
String text,
IntBuffer org,
CvFont font,
CvScalar color) |
static void |
opencv_imgproc.cvPyrDown(CvArr src,
CvArr dst) |
static void |
opencv_imgproc.cvPyrDown(CvArr src,
CvArr dst,
int filter)
\brief Smoothes the input image with gaussian kernel and then down-samples it.
|
static void |
opencv_imgproc.cvPyrMeanShiftFiltering(CvArr src,
CvArr dst,
double sp,
double sr) |
static void |
opencv_imgproc.cvPyrMeanShiftFiltering(CvArr src,
CvArr dst,
double sp,
double sr,
int max_level,
CvTermCriteria termcrit)
\brief Filters image using meanshift algorithm
|
static void |
opencv_imgproc.cvPyrUp(CvArr src,
CvArr dst) |
static void |
opencv_imgproc.cvPyrUp(CvArr src,
CvArr dst,
int filter)
\brief Up-samples image and smoothes the result with gaussian kernel.
|
static void |
opencv_core.cvRandArr(long[] rng,
CvArr arr,
int dist_type,
CvScalar param1,
CvScalar param2) |
static void |
opencv_core.cvRandArr(LongBuffer rng,
CvArr arr,
int dist_type,
CvScalar param1,
CvScalar param2) |
static void |
opencv_core.cvRandArr(LongPointer rng,
CvArr arr,
int dist_type,
CvScalar param1,
CvScalar param2)
\brief Fills an array with random numbers and updates the RNG state.
|
static void |
opencv_core.cvRandShuffle(CvArr mat,
long[] rng) |
static void |
opencv_core.cvRandShuffle(CvArr mat,
long[] rng,
double iter_factor) |
static void |
opencv_core.cvRandShuffle(CvArr mat,
LongBuffer rng) |
static void |
opencv_core.cvRandShuffle(CvArr mat,
LongBuffer rng,
double iter_factor) |
static void |
opencv_core.cvRandShuffle(CvArr mat,
LongPointer rng) |
static void |
opencv_core.cvRandShuffle(CvArr mat,
LongPointer rng,
double iter_factor) |
static CvArr |
opencv_core.cvRange(CvArr mat,
double start,
double end)
Fills matrix with given range of numbers
|
static void |
opencv_imgproc.cvRectangle(CvArr img,
CvPoint pt1,
CvPoint pt2,
CvScalar color) |
static void |
opencv_imgproc.cvRectangle(CvArr img,
CvPoint pt1,
CvPoint pt2,
CvScalar color,
int thickness,
int line_type,
int shift)
\brief Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2)
|
static void |
opencv_imgproc.cvRectangle(CvArr img,
int[] pt1,
int[] pt2,
CvScalar color) |
static void |
opencv_imgproc.cvRectangle(CvArr img,
int[] pt1,
int[] pt2,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvRectangle(CvArr img,
IntBuffer pt1,
IntBuffer pt2,
CvScalar color) |
static void |
opencv_imgproc.cvRectangle(CvArr img,
IntBuffer pt1,
IntBuffer pt2,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvRectangleR(CvArr img,
CvRect r,
CvScalar color) |
static void |
opencv_imgproc.cvRectangleR(CvArr img,
CvRect r,
CvScalar color,
int thickness,
int line_type,
int shift)
\brief Draws a rectangle specified by a CvRect structure
|
static void |
opencv_core.cvReduce(CvArr src,
CvArr dst) |
static void |
opencv_core.cvReduce(CvArr src,
CvArr dst,
int dim,
int op) |
static void |
opencv_core.cvReleaseData(CvArr arr)
\brief Releases array data.
|
static void |
opencv_imgproc.cvRemap(CvArr src,
CvArr dst,
CvArr mapx,
CvArr mapy) |
static void |
opencv_imgproc.cvRemap(CvArr src,
CvArr dst,
CvArr mapx,
CvArr mapy,
int flags,
CvScalar fillval)
\brief Performs generic geometric transformation using the specified coordinate maps
|
static void |
opencv_core.cvRepeat(CvArr src,
CvArr dst)
Repeats source 2d array several times in both horizontal and
vertical direction to fill destination array
|
static CvMat |
opencv_core.cvReshape(CvArr arr,
CvMat header,
int new_cn) |
static CvMat |
opencv_core.cvReshape(CvArr arr,
CvMat header,
int new_cn,
int new_rows)
\brief Changes shape of matrix/image without copying data.
|
static CvArr |
opencv_core.cvReshapeMatND(CvArr arr,
int sizeof_header,
CvArr header,
int new_cn,
int new_dims,
int[] new_sizes) |
static CvArr |
opencv_core.cvReshapeMatND(CvArr arr,
int sizeof_header,
CvArr header,
int new_cn,
int new_dims,
IntBuffer new_sizes) |
static CvArr |
opencv_core.cvReshapeMatND(CvArr arr,
int sizeof_header,
CvArr header,
int new_cn,
int new_dims,
IntPointer new_sizes)
\brief Changes the shape of a multi-dimensional array without copying the data.
|
static void |
opencv_imgproc.cvResize(CvArr src,
CvArr dst) |
static void |
opencv_imgproc.cvResize(CvArr src,
CvArr dst,
int interpolation)
\brief Resizes image (input array is resized to fit the destination array)
|
static void |
opencv_imgproc.cvRunningAvg(CvArr image,
CvArr acc,
double alpha) |
static void |
opencv_imgproc.cvRunningAvg(CvArr image,
CvArr acc,
double alpha,
CvArr mask)
\brief Adds image to accumulator with weights: acc = acc*(1-alpha) + image*alpha
|
static int |
opencv_imgproc.cvSampleLine(CvArr image,
CvPoint pt1,
CvPoint pt2,
Pointer buffer) |
static int |
opencv_imgproc.cvSampleLine(CvArr image,
CvPoint pt1,
CvPoint pt2,
Pointer buffer,
int connectivity)
\brief Fetches pixels that belong to the specified line segment and stores them to the buffer.
|
static int |
opencv_imgproc.cvSampleLine(CvArr image,
int[] pt1,
int[] pt2,
Pointer buffer) |
static int |
opencv_imgproc.cvSampleLine(CvArr image,
int[] pt1,
int[] pt2,
Pointer buffer,
int connectivity) |
static int |
opencv_imgproc.cvSampleLine(CvArr image,
IntBuffer pt1,
IntBuffer pt2,
Pointer buffer) |
static int |
opencv_imgproc.cvSampleLine(CvArr image,
IntBuffer pt1,
IntBuffer pt2,
Pointer buffer,
int connectivity) |
static void |
opencv_core.cvScale(CvArr arg1,
CvArr arg2,
double arg3,
double arg4) |
static void |
opencv_core.cvScaleAdd(CvArr src1,
CvScalar scale,
CvArr src2,
CvArr dst)
dst = src1 * scale + src2
|
static void |
opencv_core.cvSeqInsertSlice(CvSeq seq,
int before_index,
CvArr from_arr)
Inserts a sequence or array into another sequence
|
static void |
opencv_core.cvSet(CvArr arr,
CvScalar value) |
static void |
opencv_core.cvSet(CvArr arr,
CvScalar value,
CvArr mask)
\brief Sets every element of an array to a given value.
|
static void |
opencv_core.cvSet1D(CvArr arr,
int idx0,
CvScalar value)
\brief Change the particular array element.
|
static void |
opencv_core.cvSet2D(CvArr arr,
int idx0,
int idx1,
CvScalar value)
\overload
|
static void |
opencv_core.cvSet3D(CvArr arr,
int idx0,
int idx1,
int idx2,
CvScalar value)
\overload
|
static void |
opencv_core.cvSetData(CvArr arr,
Pointer data,
int step)
\brief Assigns user data to the array header.
|
static void |
opencv_core.cvSetIdentity(CvArr mat) |
static void |
opencv_core.cvSetIdentity(CvArr mat,
CvScalar value)
Makes an identity matrix (mat_ij = i == j)
|
static void |
opencv_core.cvSetND(CvArr arr,
int[] idx,
CvScalar value) |
static void |
opencv_core.cvSetND(CvArr arr,
IntBuffer idx,
CvScalar value) |
static void |
opencv_core.cvSetND(CvArr arr,
IntPointer idx,
CvScalar value)
\overload
|
static void |
opencv_core.cvSetReal1D(CvArr arr,
int idx0,
double value)
\brief Change a specific array element.
|
static void |
opencv_core.cvSetReal2D(CvArr arr,
int idx0,
int idx1,
double value)
\overload
|
static void |
opencv_core.cvSetReal3D(CvArr arr,
int idx0,
int idx1,
int idx2,
double value)
\overload
|
static void |
opencv_core.cvSetRealND(CvArr arr,
int[] idx,
double value) |
static void |
opencv_core.cvSetRealND(CvArr arr,
IntBuffer idx,
double value) |
static void |
opencv_core.cvSetRealND(CvArr arr,
IntPointer idx,
double value)
\overload
|
static void |
opencv_core.cvSetZero(CvArr arr)
\brief Clears the array.
|
static void |
opencv_highgui.cvShowImage(BytePointer name,
CvArr image) |
static void |
opencv_highgui.cvShowImage(String name,
CvArr image) |
static void |
opencv_imgproc.cvSmooth(CvArr src,
CvArr dst) |
static void |
opencv_imgproc.cvSmooth(CvArr src,
CvArr dst,
int smoothtype,
int size1,
int size2,
double sigma1,
double sigma2)
\brief Smooths the image in one of several ways.
|
static void |
opencv_imgproc.cvSobel(CvArr src,
CvArr dst,
int xorder,
int yorder) |
static void |
opencv_imgproc.cvSobel(CvArr src,
CvArr dst,
int xorder,
int yorder,
int aperture_size)
\brief Calculates an image derivative using generalized Sobel
|
static int |
opencv_core.cvSolve(CvArr src1,
CvArr src2,
CvArr dst) |
static int |
opencv_core.cvSolve(CvArr src1,
CvArr src2,
CvArr dst,
int method)
Solves linear system (src1)*(dst) = (src2)
(returns 0 if src1 is a singular and CV_LU method is used)
|
static void |
opencv_core.cvSort(CvArr src) |
static void |
opencv_core.cvSort(CvArr src,
CvArr dst,
CvArr idxmat,
int flags) |
static void |
opencv_core.cvSplit(CvArr src,
CvArr dst0,
CvArr dst1,
CvArr dst2,
CvArr dst3)
Splits a multi-channel array into the set of single-channel arrays or
extracts particular [color] plane
|
static void |
opencv_imgproc.cvSquareAcc(CvArr image,
CvArr sqsum) |
static void |
opencv_imgproc.cvSquareAcc(CvArr image,
CvArr sqsum,
CvArr mask)
\brief Adds squared image to accumulator
|
static CvContourScanner |
opencv_imgproc.cvStartFindContours(CvArr image,
CvMemStorage storage) |
static CvContourScanner |
opencv_imgproc.cvStartFindContours(CvArr image,
CvMemStorage storage,
int header_size,
int mode,
int method,
CvPoint offset)
\brief Initializes contour retrieving process.
|
static CvContourScanner |
opencv_imgproc.cvStartFindContours(CvArr image,
CvMemStorage storage,
int header_size,
int mode,
int method,
int[] offset) |
static CvContourScanner |
opencv_imgproc.cvStartFindContours(CvArr image,
CvMemStorage storage,
int header_size,
int mode,
int method,
IntBuffer offset) |
static void |
opencv_core.cvSub(CvArr src1,
CvArr src2,
CvArr dst) |
static void |
opencv_core.cvSub(CvArr src1,
CvArr src2,
CvArr dst,
CvArr mask)
dst(mask) = src1(mask) - src2(mask)
|
static void |
opencv_core.cvSubRS(CvArr src,
CvScalar value,
CvArr dst) |
static void |
opencv_core.cvSubRS(CvArr src,
CvScalar value,
CvArr dst,
CvArr mask)
dst(mask) = value - src(mask)
|
static void |
opencv_core.cvSubS(CvArr src,
CvScalar value,
CvArr dst) |
static void |
opencv_core.cvSubS(CvArr src,
CvScalar value,
CvArr dst,
CvArr mask)
dst(mask) = src(mask) - value = src(mask) + (-value)
|
static CvScalar |
opencv_core.cvSum(CvArr arr)
Finds sum of array elements
|
static void |
opencv_core.cvSVBkSb(CvArr W,
CvArr U,
CvArr V,
CvArr B,
CvArr X,
int flags)
Performs Singular Value Back Substitution (solves A*X = B):
flags must be the same as in cvSVD
|
static void |
opencv_core.cvSVD(CvArr A,
CvArr W) |
static void |
opencv_core.cvSVD(CvArr A,
CvArr W,
CvArr U,
CvArr V,
int flags)
Performs Singular Value Decomposition of a matrix
|
static void |
opencv_core.cvT(CvArr arg1,
CvArr arg2) |
static double |
opencv_imgproc.cvThreshold(CvArr src,
CvArr dst,
double threshold,
double max_value,
int threshold_type)
\brief Applies fixed-level threshold to grayscale image.
|
static CvScalar |
opencv_core.cvTrace(CvArr mat)
Calculates trace of the matrix (sum of elements on the main diagonal)
|
static void |
opencv_core.cvTransform(CvArr src,
CvArr dst,
CvMat transmat) |
static void |
opencv_core.cvTransform(CvArr src,
CvArr dst,
CvMat transmat,
CvMat shiftvec)
Transforms each element of source array and stores
resultant vectors in destination array
|
static void |
opencv_core.cvTranspose(CvArr src,
CvArr dst)
Transposes matrix.
|
static void |
opencv_highgui.cvvShowImage(BytePointer arg1,
CvArr arg2) |
static void |
opencv_highgui.cvvShowImage(String arg1,
CvArr arg2) |
static void |
opencv_imgproc.cvWarpAffine(CvArr src,
CvArr dst,
CvMat map_matrix) |
static void |
opencv_imgproc.cvWarpAffine(CvArr src,
CvArr dst,
CvMat map_matrix,
int flags,
CvScalar fillval)
\brief Warps image with affine transform
\note ::cvGetQuadrangleSubPix is similar to ::cvWarpAffine, but the outliers are extrapolated using
replication border mode.
|
static void |
opencv_imgproc.cvWarpPerspective(CvArr src,
CvArr dst,
CvMat map_matrix) |
static void |
opencv_imgproc.cvWarpPerspective(CvArr src,
CvArr dst,
CvMat map_matrix,
int flags,
CvScalar fillval)
\brief Warps image with perspective (projective) transform
|
static void |
opencv_imgproc.cvWatershed(CvArr image,
CvArr markers)
\brief Segments image using seed "markers"
|
static void |
opencv_core.cvXor(CvArr src1,
CvArr src2,
CvArr dst) |
static void |
opencv_core.cvXor(CvArr src1,
CvArr src2,
CvArr dst,
CvArr mask)
dst(idx) = src1(idx) ^ src2(idx)
|
static void |
opencv_core.cvXorS(CvArr src,
CvScalar value,
CvArr dst) |
static void |
opencv_core.cvXorS(CvArr src,
CvScalar value,
CvArr dst,
CvArr mask)
dst(idx) = src(idx) ^ value
|
static void |
opencv_core.cvZero(CvArr arg1) |
static void |
opencv_core.extractImageCOI(CvArr arr,
GpuMat coiimg) |
static void |
opencv_core.extractImageCOI(CvArr arr,
GpuMat coiimg,
int coi) |
static void |
opencv_core.extractImageCOI(CvArr arr,
Mat coiimg) |
static void |
opencv_core.extractImageCOI(CvArr arr,
Mat coiimg,
int coi)
extracts Channel of Interest from CvMat or IplImage and makes cv::Mat out of it.
|
static void |
opencv_core.extractImageCOI(CvArr arr,
UMat coiimg) |
static void |
opencv_core.extractImageCOI(CvArr arr,
UMat coiimg,
int coi) |
static void |
opencv_core.insertImageCOI(GpuMat coiimg,
CvArr arr) |
static void |
opencv_core.insertImageCOI(GpuMat coiimg,
CvArr arr,
int coi) |
static void |
opencv_core.insertImageCOI(Mat coiimg,
CvArr arr) |
static void |
opencv_core.insertImageCOI(Mat coiimg,
CvArr arr,
int coi)
inserts single-channel cv::Mat into a multi-channel CvMat or IplImage
|
static void |
opencv_core.insertImageCOI(UMat coiimg,
CvArr arr) |
static void |
opencv_core.insertImageCOI(UMat coiimg,
CvArr arr,
int coi) |
static void |
opencv_core.seqInsertSlice(CvSeq seq,
int before_index,
CvArr from_arr) |
Modifier and Type | Method and Description |
---|---|
static void |
opencv_imgproc.cvCalcArrBackProject(CvArr[] image,
CvArr dst,
CvHistogram hist) |
static void |
opencv_imgproc.cvCalcArrBackProject(CvArr[] image,
CvArr dst,
CvHistogram hist) |
static void |
opencv_imgproc.cvCalcArrBackProjectPatch(CvArr[] image,
CvArr dst,
CvSize range,
CvHistogram hist,
int method,
double factor) |
static void |
opencv_imgproc.cvCalcArrBackProjectPatch(CvArr[] image,
CvArr dst,
CvSize range,
CvHistogram hist,
int method,
double factor) |
static void |
opencv_imgproc.cvCalcArrHist(CvArr[] arr,
CvHistogram hist,
int accumulate,
CvArr mask) |
static void |
opencv_imgproc.cvCalcArrHist(CvArr[] arr,
CvHistogram hist,
int accumulate,
CvArr mask) |
static void |
opencv_imgproc.cvCalcBackProject(IplImage[] image,
CvArr dst,
CvHistogram hist) |
static void |
opencv_imgproc.cvCalcBackProject(IplImageArray image,
CvArr dst,
CvHistogram hist) |
static void |
opencv_imgproc.cvCalcBackProjectPatch(IplImage[] image,
CvArr dst,
CvSize range,
CvHistogram hist,
int method,
double factor) |
static void |
opencv_imgproc.cvCalcBackProjectPatch(IplImageArray image,
CvArr dst,
CvSize range,
CvHistogram hist,
int method,
double factor) |
static void |
opencv_core.cvCalcCovarMatrix(CvArr[] vects,
int count,
CvArr cov_mat,
CvArr avg,
int flags) |
static void |
opencv_core.cvCalcCovarMatrix(CvArr[] vects,
int count,
CvArr cov_mat,
CvArr avg,
int flags) |
static void |
opencv_imgproc.cvCalcHist(IplImage[] arr,
CvHistogram hist,
int accumulate,
CvArr mask) |
static void |
opencv_imgproc.cvCalcHist(IplImageArray arr,
CvHistogram hist,
int accumulate,
CvArr mask) |
static void |
opencv_imgproc.cvDrawContours(CvArr img,
CvSeq contour,
CvScalar external_color,
CvScalar hole_color,
int max_level,
int thickness,
int line_type) |
static void |
opencv_imgproc.cvDrawPolyLine(CvArr img,
CvPoint[] pts,
int[] npts,
int contours,
int is_closed,
CvScalar color,
int thickness,
int line_type,
int shift) |
static void |
opencv_imgproc.cvFillPoly(CvArr img,
CvPoint[] pts,
int[] npts,
int contours,
CvScalar color,
int line_type,
int shift) |
static int |
opencv_imgproc.cvFindContours(CvArr image,
CvMemStorage storage,
CvSeq first_contour,
int header_size,
int mode,
int method) |
static int |
opencv_core.cvInitNArrayIterator(int count,
CvArr[] arrs,
CvArr mask,
CvMatND stubs,
CvNArrayIterator array_iterator,
int flags) |
static int |
opencv_core.cvInitNArrayIterator(int count,
CvArr[] arrs,
CvArr mask,
CvMatND stubs,
CvNArrayIterator array_iterator,
int flags) |
static void |
opencv_core.cvMixChannels(CvArr[] src,
int src_count,
CvArr[] dst,
int dst_count,
int[] from_to,
int pair_count) |
static void |
opencv_core.cvMixChannels(CvArr[] src,
int src_count,
CvArr[] dst,
int dst_count,
int[] from_to,
int pair_count) |
static double |
opencv_core.cvNorm(CvArr arr1,
CvArr arr2) |
static void |
opencv_imgproc.cvPolyLine(CvArr img,
CvPoint[] pts,
int[] npts,
int contours,
int is_closed,
CvScalar color,
int thickness,
int line_type,
int shift) |
static int |
opencv_imgcodecs.cvSaveImage(String filename,
CvArr arr) |
static int |
opencv_imgcodecs.cvSaveImage(String filename,
CvArr arr,
int[] params) |
static CvContourScanner |
opencv_imgproc.cvStartFindContours(CvArr image,
CvMemStorage storage,
int header_size,
int mode,
int method) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractCvGraph |
class |
AbstractCvMat |
protected static class |
AbstractCvMat.ReleaseDeallocator |
class |
AbstractCvMatND |
protected static class |
AbstractCvMatND.ReleaseDeallocator |
class |
AbstractCvSeq |
class |
AbstractCvSet |
class |
AbstractCvSparseMat |
protected static class |
AbstractCvSparseMat.ReleaseDeallocator |
class |
AbstractIplImage |
protected static class |
AbstractIplImage.HeaderReleaseDeallocator |
protected static class |
AbstractIplImage.ReleaseDeallocator |
class |
CvChain
Chain/Contour
|
class |
CvContour |
class |
CvGraph |
class |
CvMat
Deprecated.
CvMat is now obsolete; consider using Mat instead.
|
class |
CvMatND
Deprecated.
consider using cv::Mat instead
|
class |
CvSeq |
class |
CvSet |
class |
CvSparseMat |
class |
IplImage
The IplImage is taken from the Intel Image Processing Library, in which the format is native.
|
Modifier and Type | Method and Description |
---|---|
CvArr |
CvHistogram.bins() |
CvArr |
CvArrArray.get() |
Modifier and Type | Method and Description |
---|---|
CvHistogram |
CvHistogram.bins(CvArr setter) |
IplImageArray |
IplImageArray.put(CvArr... array) |
CvMatArray |
CvMatArray.put(CvArr... array) |
CvMatNDArray |
CvMatNDArray.put(CvArr... array) |
CvArrArray |
CvArrArray.put(CvArr... array) |
IplImageArray |
IplImageArray.put(CvArr p) |
CvMatArray |
CvMatArray.put(CvArr p) |
CvMatNDArray |
CvMatNDArray.put(CvArr p) |
CvArrArray |
CvArrArray.put(CvArr p) |
Constructor and Description |
---|
CvArrArray(CvArr... array) |
Mat(CvArr arr) |
Copyright © 2020. All rights reserved.