# -*- mode: text; coding: utf-8; tab-width: 4 -*-
# ============================================================
# imgproc. Image Processing: Histograms
# ============================================================
MODULE = Cv PACKAGE = Cv::Histogram
# ====================
int
type(CvHistogram* hist)
CODE:
RETVAL = hist->type;
OUTPUT:
RETVAL
CvArr*
bins(CvHistogram* hist)
CODE:
RETVAL = hist->bins;
OUTPUT:
RETVAL
AV*
thresh(CvHistogram* hist)
CODE:
RETVAL = newAV();
int dims = cvGetDims(&hist->mat, NULL); int i;
for (i = 0; i < dims; i++) {
AV* av = newAV();
av_push(av, newSViv(hist->thresh[i][0]));
av_push(av, newSViv(hist->thresh[i][1]));
av_push(RETVAL, newRV_inc(sv_2mortal((SV*)av)));
}
OUTPUT:
RETVAL
AV*
sizes(CvHistogram* hist)
CODE:
int sizes[CV_MAX_DIM];
int dims = cvGetDims(&hist->mat, sizes); int i;
RETVAL = newAV();
for (i = 0; i < dims; i++) {
av_push(RETVAL, newSViv(sizes[i]));
}
OUTPUT:
RETVAL
MODULE = Cv PACKAGE = Cv::Histogram
# ====================
void
cvCalcBackProject(const CvHistogram* hist, IplImage** images, CvArr* back_project)
C_ARGS: images, back_project, hist
POSTCALL:
ST(0) = ST(2);
XSRETURN(1);
void
cvCalcBackProjectPatch(CvHistogram* hist, IplImage** images, CvArr* dst, CvSize patch_size, int method, double factor)
C_ARGS: images, dst, patch_size, hist, method, factor
POSTCALL:
ST(0) = ST(2);
XSRETURN(1);
void
cvCalcHist(CvHistogram* hist, IplImage** image, int accumulate=0, const CvArr* mask=NULL)
C_ARGS: image, hist, accumulate, mask
POSTCALL:
XSRETURN(1);
void
cvCalcProbDensity(const CvHistogram* hist1, const CvHistogram* hist2, CvHistogram* dst_hist, double scale=255)
POSTCALL:
XSRETURN(1);
void
cvClearHist(CvHistogram* hist)
POSTCALL:
XSRETURN(1);
double
cvCompareHist(const CvHistogram* hist1, const CvHistogram* hist2, int method)
void
cvCopyHist(const CvHistogram* src, CvHistogram* dst)
C_ARGS: src, &dst
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
MODULE = Cv PACKAGE = Cv
# ====================
CvHistogram*
cvCreateHist(int* sizes, int type, float** ranges=NULL, int uniform=1)
C_ARGS: length(sizes), sizes, type, ranges=NULL, uniform
MODULE = Cv PACKAGE = Cv::Histogram
# ====================
double
cvGetHistValue_1D(CvHistogram* hist, int idx0)
CODE:
RETVAL = *(float*)cvPtr1D(hist->bins, idx0, 0);
OUTPUT:
RETVAL
double
cvGetHistValue_2D(CvHistogram* hist, int idx0, int idx1)
CODE:
RETVAL = *(float*)cvPtr2D(hist->bins, idx0, idx1, 0);
OUTPUT:
RETVAL
double
cvGetHistValue_3D(CvHistogram* hist, int idx0, int idx1, int idx2)
CODE:
RETVAL = *(float*)cvPtr3D(hist->bins, idx0, idx1, idx2, 0);
OUTPUT:
RETVAL
double
cvGetHistValue_ND(CvHistogram* hist, int* idx)
CODE:
RETVAL = *(float*)cvPtrND(hist->bins, idx, NULL, 1, NULL);
OUTPUT:
RETVAL
void
cvGetMinMaxHistValue(const CvHistogram* hist, min_value, max_value, min_idx = NO_INIT, max_idx = NO_INIT)
INPUT:
float &min_value = NO_INIT
float &max_value = NO_INIT
int &min_idx = NO_INIT
int &max_idx = NO_INIT
POSTCALL:
if (items >= 4) sv_setiv(ST(3), min_idx);
if (items >= 5) sv_setiv(ST(4), max_idx);
OUTPUT:
min_value
max_value
MODULE = Cv PACKAGE = Cv
# ====================
#TBD# CvHistogram* cvMakeHistHeaderForArray(int dims, int* sizes, CvHistogram* hist, float* data, float** ranges=NULL, int uniform=1)
MODULE = Cv PACKAGE = Cv::Histogram
# ====================
void
cvNormalizeHist(CvHistogram* hist, double factor)
POSTCALL:
XSRETURN(1);
float
cvQueryHistValue_1D(CvHistogram* hist, int idx0)
float
cvQueryHistValue_2D(CvHistogram* hist, int idx0, int idx1)
float
cvQueryHistValue_3D(CvHistogram* hist, int idx0, int idx1, int idx2)
float
cvQueryHistValue_nD(CvHistogram* hist, int* idx)
void
cvReleaseHist(CvHistogram* &hist)
ALIAS: Cv::Histogram::DESTROY = 1
void
cvSetHistBinRanges(CvHistogram* hist, float** ranges, int uniform=1)
void
cvThreshHist(CvHistogram* hist, double threshold)
POSTCALL:
XSRETURN(1);
# ============================================================
# imgproc. Image Processing: Image Filtering
# ============================================================
MODULE = Cv PACKAGE = Cv::Arr
# ====================
void
cvCopyMakeBorder(const CvArr* src, CvArr* dst, CvPoint offset, int bordertype, CvScalar value=cvScalarAll(0))
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
MODULE = Cv PACKAGE = Cv
# ====================
IplConvKernel*
cvCreateStructuringElementEx(int cols, int rows, int anchorX, int anchorY, int shape, int* values=NULL)
MODULE = Cv PACKAGE = Cv::Arr
# ====================
void
cvDilate(const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int iterations=1)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvErode(const CvArr* src, CvArr* dst, IplConvKernel* element=NULL, int iterations=1)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvFilter2D(const CvArr* src, CvArr* dst, const CvMat* kernel, CvPoint anchor=cvPoint(-1, -1))
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvLaplace(const CvArr* src, CvArr* dst, int apertureSize=3)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvMorphologyEx(const CvArr* src, CvArr* dst, CvArr* temp, IplConvKernel* element, int operation, int iterations=1)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvPyrDown(const CvArr* src, CvArr* dst, int filter=CV_GAUSSIAN_5x5)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvPyrUp(const CvArr* src, CvArr* dst, int filter=CV_GAUSSIAN_5x5)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
MODULE = Cv PACKAGE = Cv::ConvKernel
# ====================
void
cvReleaseStructuringElement(IplConvKernel* &element)
ALIAS: Cv::ConvKernel::DESTROY = 1
MODULE = Cv PACKAGE = Cv::Arr
# ====================
void
cvSmooth(const CvArr* src, CvArr* dst, int smoothType=CV_GAUSSIAN, int param1=3, int param2=0, double param3=0, double param4=0)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvSobel(const CvArr* src, CvArr* dst, int xorder, int yorder, int apertureSize=3)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
# ============================================================
# imgproc. Image Processing: Geometric Image Transformations
# ============================================================
MODULE = Cv PACKAGE = Cv
# ====================
CvMat*
cv2DRotationMatrix(CvPoint2D32f center, double angle, double scale, CvMat* mapMatrix)
CvMat*
cvGetAffineTransform(const CvPoint2D32f* src, const CvPoint2D32f* dst, CvMat* mapMatrix)
CvMat*
cvGetPerspectiveTransform(const CvPoint2D32f* src, const CvPoint2D32f* dst, CvMat* mapMatrix)
MODULE = Cv PACKAGE = Cv::Arr
# ====================
void
cvGetQuadrangleSubPix(const CvArr* src, CvArr* dst, const CvMat* mapMatrix)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvGetRectSubPix(const CvArr* src, CvArr* dst, CvPoint2D32f center)
void
cvLogPolar(const CvArr* src, CvArr* dst, CvPoint2D32f center, double M, int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
#if (CV_MAJOR_VERSION * 1000 + CV_MINOR_VERSION) >= 2000
void
cvLinearPolar(const CvArr* src, CvArr* dst, CvPoint2D32f center, double maxRadius, int flags = CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS);
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
#endif
void
cvRemap(const CvArr* src, CvArr* dst, const CvArr* mapx, const CvArr* mapy, int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, CvScalar fillval=cvScalarAll(0))
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvResize(const CvArr* src, CvArr* dst, int interpolation=CV_INTER_LINEAR)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvWarpAffine(const CvArr* src, CvArr* dst, const CvMat* mapMatrix, int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, CvScalar fillval=cvScalarAll(0))
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvWarpPerspective(const CvArr* src, CvArr* dst, const CvMat* mapMatrix, int flags=CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, CvScalar fillval=cvScalarAll(0))
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
# ============================================================
# imgproc. Image Processing: Miscellaneous Image Transformations
# ============================================================
MODULE = Cv PACKAGE = Cv::Arr
# ====================
void
cvAdaptiveThreshold(const CvArr* src, CvArr* dst, double maxValue, int adaptive_method=CV_ADAPTIVE_THRESH_MEAN_C, int thresholdType=CV_THRESH_BINARY, int blockSize=3, double param1=5)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvCvtColor(const CvArr* src, CvArr* dst, int code)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvDistTransform(const CvArr* src, CvArr* dst, int distance_type=CV_DIST_L2, int mask_size=3, float* mask=NULL, CvArr* labels=NULL)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvEqualizeHist(const CvArr* src, CvArr* dst);
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvFloodFill(CvArr* image, CvPoint seed_point, CvScalar new_val, CvScalar lo_diff=cvScalarAll(0), CvScalar up_diff=cvScalarAll(0), comp = NO_INIT, int flags=4, CvArr* mask=NULL)
INPUT:
CvConnectedComp &comp = NO_INIT
POSTCALL:
if (items >= 6) XS_pack_CvConnectedComp(ST(5), comp);
void
cvWatershed(const CvArr* image, CvArr* markers)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvInpaint(const CvArr* src, const CvArr* mask, CvArr* dst, double inpaintRadius, int flags)
POSTCALL:
ST(0) = ST(2);
XSRETURN(1);
void
cvIntegral(const CvArr* image, CvArr* sum, CvArr* sqsum=NULL, CvArr* tiltedSum=NULL)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvPyrMeanShiftFiltering(const CvArr* src, CvArr* dst, double sp, double sr, int max_level=1, CvTermCriteria termcrit= cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS, 5, 1))
void
cvPyrSegmentation(IplImage* src, IplImage* dst, CvMemStorage* storage, comp, int level, double threshold1, double threshold2)
INPUT:
CvSeq* &comp = NO_INIT
OUTPUT:
comp
NO_OUTPUT double
cvThreshold(const CvArr* src, CvArr* dst, double threshold, double maxValue, int thresholdType)
POSTCALL:
if (thresholdType == CV_THRESH_OTSU) {
/* SvREFCNT_dec(ST(2)); */
sv_setnv(ST(2), RETVAL);
}
/* SvREFCNT_dec(ST(1)); */
ST(0) = ST(1);
XSRETURN(1);
# ============================================================
# imgproc. Image Processing: Structural Analysis and Shape Descriptors
# ============================================================
MODULE = Cv PACKAGE = Cv::Seq
# ====================
CvSeq*
cvApproxChains(CvSeq* src_seq, CvMemStorage* storage, int method=CV_CHAIN_APPROX_SIMPLE, double parameter=0, int minimal_perimeter=0, int recursive=0)
MODULE = Cv PACKAGE = Cv::Arr
# ====================
CvSeq*
cvApproxPoly(const void* src_seq, int header_size, CvMemStorage* storage, int method, double parameter, int parameter2=0)
OUTPUT: RETVAL bless(ST(0), "Cv::Seq::Point", RETVAL);
double
cvArcLength(const void* curve, CvSlice slice=CV_WHOLE_SEQ, int isClosed=-1)
CvRect
cvBoundingRect(CvArr* points, int update=0)
MODULE = Cv PACKAGE = Cv
# ====================
void
cvBoxPoints(CvBox2D box)
PPCODE:
CvPoint2D32f pts[4]; int i;
cvBoxPoints(box, pts);
EXTEND(SP, 4);
for (i = 0; i < 4; i++) {
SV* sv = sv_newmortal();
XS_pack_CvPoint2D32f(sv, pts[i]);
PUSHs(sv);
}
MODULE = Cv PACKAGE = Cv::Seq
# ====================
void
cvCalcPGH(const CvSeq* contour, CvHistogram* hist)
#TBD# float cvCalcEMD2(const CvArr* signature1, const CvArr* signature2, int distance_type, CvDistanceFunction distance_func=NULL, const CvArr* cost_matrix=NULL, CvArr* flow=NULL, float* lower_bound=NULL, void* userdata=NULL)
MODULE = Cv PACKAGE = Cv::Arr
# ====================
int
cvCheckContourConvexity(const CvArr* contour)
#if (CV_MAJOR_VERSION * 1000 + CV_MINOR_VERSION) >= 2000
double
cvContourArea(const CvArr* contour, CvSlice slice=CV_WHOLE_SEQ, int oriented=0)
#else
double
cvContourArea(const CvArr* contour, CvSlice slice=CV_WHOLE_SEQ)
#endif
#if defined __cplusplus || (CV_MAJOR_VERSION * 1000 + CV_MINOR_VERSION) <= 2001
MODULE = Cv PACKAGE = Cv::ContourTree
# ====================
CvSeq*
cvContourFromContourTree(const CvContourTree* tree, CvMemStorage* storage, CvTermCriteria criteria)
#endif
MODULE = Cv PACKAGE = Cv::Arr
# ====================
CvSeq*
cvConvexHull2(const CvArr* input, void* storage=NULL, int orientation=CV_CLOCKWISE, int return_points=1)
OUTPUT: RETVAL bless(ST(0), "Cv::Seq::Point", RETVAL);
CvSeq*
cvConvexityDefects(const CvArr* contour, const CvArr* convexhull, CvMemStorage* storage=NULL)
#if defined __cplusplus || (CV_MAJOR_VERSION * 1000 + CV_MINOR_VERSION) <= 2001
MODULE = Cv PACKAGE = Cv::Seq
# ====================
CvContourTree*
cvCreateContourTree(const CvSeq* contour, CvMemStorage* storage, double threshold)
#endif
#TBD# CvSeq* cvEndFindContours(CvContourScanner* scanner)
MODULE = Cv PACKAGE = Cv::Arr
# ====================
int
cvFindContours(CvArr* image, CvMemStorage* storage, first_contour, int header_size=sizeof(CvContour), int mode=CV_RETR_LIST, int method=CV_CHAIN_APPROX_SIMPLE, CvPoint offset=cvPoint(0, 0))
INPUT:
CvSeq* &first_contour = NO_INIT
OUTPUT:
RETVAL
first_contour
#TBD# CvSeq* cvFindNextContour(CvContourScanner scanner)
MODULE = Cv PACKAGE = Cv::Arr
# ====================
CvBox2D
cvFitEllipse2(const CvArr* points)
ALIAS: Cv::Arr::cvFitEllipse = 1
void
cvFitLine(const CvArr* points, int dist_type, double param, double reps, double aeps, float* line)
MODULE = Cv PACKAGE = Cv::Moments
# ====================
double
cvGetCentralMoment(CvMoments* moments, int x_order, int y_order)
CvHuMoments*
cvGetHuMoments(CvMoments* moments)
INIT:
Newx(RETVAL, 1, CvHuMoments);
CODE:
cvGetHuMoments(moments, RETVAL);
OUTPUT:
RETVAL
double
cvGetNormalizedCentralMoment(CvMoments* moments, int x_order, int y_order)
double
cvGetSpatialMoment(CvMoments* moments, int x_order, int y_order)
double
m00(const CvMoments* moments)
CODE:
RETVAL = moments->m00;
OUTPUT:
RETVAL
double
m10(const CvMoments* moments)
CODE:
RETVAL = moments->m10;
OUTPUT:
RETVAL
double
m01(const CvMoments* moments)
CODE:
RETVAL = moments->m01;
OUTPUT:
RETVAL
double
m20(const CvMoments* moments)
CODE:
RETVAL = moments->m20;
OUTPUT:
RETVAL
double
m11(const CvMoments* moments)
CODE:
RETVAL = moments->m11;
OUTPUT:
RETVAL
double
m02(const CvMoments* moments)
CODE:
RETVAL = moments->m02;
OUTPUT:
RETVAL
double
m30(const CvMoments* moments)
CODE:
RETVAL = moments->m30;
OUTPUT:
RETVAL
double
m21(const CvMoments* moments)
CODE:
RETVAL = moments->m21;
OUTPUT:
RETVAL
double
m12(const CvMoments* moments)
CODE:
RETVAL = moments->m12;
OUTPUT:
RETVAL
double
m03(const CvMoments* moments)
CODE:
RETVAL = moments->m03;
OUTPUT:
RETVAL
double
inv_sqrt_m00(const CvMoments* moments)
CODE:
RETVAL = moments->inv_sqrt_m00;
OUTPUT:
RETVAL
MODULE = Cv PACKAGE = Cv::HuMoments
# ====================
void
DESTROY(CvHuMoments* hu_moments)
CODE:
safefree(hu_moments);
double
hu1(const CvHuMoments* hu_moments)
CODE:
RETVAL = hu_moments->hu1;
OUTPUT:
RETVAL
double
hu2(const CvHuMoments* hu_moments)
CODE:
RETVAL = hu_moments->hu2;
OUTPUT:
RETVAL
double
hu3(const CvHuMoments* hu_moments)
CODE:
RETVAL = hu_moments->hu3;
OUTPUT:
RETVAL
double
hu4(const CvHuMoments* hu_moments)
CODE:
RETVAL = hu_moments->hu4;
OUTPUT:
RETVAL
double
hu5(const CvHuMoments* hu_moments)
CODE:
RETVAL = hu_moments->hu5;
OUTPUT:
RETVAL
double
hu6(const CvHuMoments* hu_moments)
CODE:
RETVAL = hu_moments->hu6;
OUTPUT:
RETVAL
double
hu7(const CvHuMoments* hu_moments)
CODE:
RETVAL = hu_moments->hu7;
OUTPUT:
RETVAL
#if defined __cplusplus || (CV_MAJOR_VERSION * 1000 + CV_MINOR_VERSION) <= 2001
MODULE = Cv PACKAGE = Cv::ContourTree
# ====================
double
cvMatchContourTrees(const CvContourTree* tree1, const CvContourTree* tree2, int method, double threshold)
#endif
MODULE = Cv PACKAGE = Cv::Arr
# ====================
double
cvMatchShapes(const void* object1, const void* object2, int method, double parameter=0)
CvBox2D
cvMinAreaRect2(const CvArr* points, CvMemStorage* storage=NULL)
ALIAS: Cv::Arr::cvMinAreaRect = 1
CvSeq*
cvHoughCircles(CvArr* image, CvMemStorage* circleStorage, int method, double dp, double minDist, double param1=100, double param2=100, int minRadius=0, int maxRadius=0)
OUTPUT: RETVAL bless(ST(0), "Cv::Seq::Circle", RETVAL);
int
cvMinEnclosingCircle(const CvArr* points, center, radius)
INPUT:
CvPoint2D32f ¢er = NO_INIT
float &radius = NO_INIT
OUTPUT:
center
radius
CvMoments*
cvMoments(const CvArr* arr, int binary=0)
INIT:
Newx(RETVAL, 1, CvMoments);
CODE:
int type = cvGetElemType(arr);
int channels = CV_MAT_CN(type);
int coi = cvGetImageCOI((IplImage*)arr);
if (channels == 1 || coi != 0) {
cvMoments(arr, RETVAL, binary);
} else {
cvSetImageCOI((IplImage*)arr, 1);
cvMoments(arr, RETVAL, binary);
cvSetImageCOI((IplImage*)arr, coi);
}
OUTPUT:
RETVAL
MODULE = Cv PACKAGE = Cv::Moments
# ====================
void
DESTROY(CvMoments* moments)
CODE:
safefree(moments);
MODULE = Cv PACKAGE = Cv::Arr
# ====================
double
cvPointPolygonTest(const CvArr* contour, CvPoint2D32f pt, int measure_dist)
MODULE = Cv PACKAGE = Cv
# ====================
CvSeq*
cvPointSeqFromMat(int seq_kind, const CvArr* mat, CvContour* contour_header, CvSeqBlock* block)
MODULE = Cv PACKAGE = Cv::ChainPtReader
# ====================
CvPoint
cvReadChainPoint(CvChainPtReader* reader)
#TBD# CvContourScanner cvStartFindContours(CvArr* image, CvMemStorage* storage, int header_size=sizeof(CvContour), int mode=CV_RETR_LIST, int method=CV_CHAIN_APPROX_SIMPLE, CvPoint offset=cvPoint(0, 0))
MODULE = Cv PACKAGE = Cv::Chain
# ====================
void
cvStartReadChainPoints(CvChain* chain, CvChainPtReader* reader)
#TBD# void cvSubstituteContour(CvContourScanner scanner, CvSeq* new_contour)
# ============================================================
# imgproc. Image Processing: Planar Subdivisions
# ============================================================
MODULE = Cv PACKAGE = Cv::Subdiv2D
# ====================
CvSeq*
edges(CvSubdiv2D* subdiv)
CODE:
RETVAL = (CvSeq*)subdiv->edges;
OUTPUT:
RETVAL
void
cvCalcSubdivVoronoi2D(CvSubdiv2D* subdiv)
void
cvClearSubdivVoronoi2D(CvSubdiv2D* subdiv)
MODULE = Cv PACKAGE = Cv
# ====================
CvSubdiv2D*
cvCreateSubdivDelaunay2D(CvRect rect, CvMemStorage* storage)
MODULE = Cv PACKAGE = Cv::Subdiv2D
# ====================
CvSubdiv2DPoint
cvFindNearestPoint2D(CvSubdiv2D* subdiv, CvPoint2D32f pt)
CODE:
CvSubdiv2DPoint* p = cvFindNearestPoint2D(subdiv, pt);
if (p) RETVAL = *p; else XSRETURN_UNDEF;
OUTPUT:
RETVAL
MODULE = Cv PACKAGE = Cv
# ====================
CvSubdiv2DPoint
cvSubdiv2DEdgeOrg(CvSubdiv2DEdge edge)
CODE:
CvSubdiv2DPoint* p = cvSubdiv2DEdgeOrg(edge);
if (p) RETVAL = *p; else XSRETURN_UNDEF;
OUTPUT:
RETVAL
CvSubdiv2DPoint
cvSubdiv2DEdgeDst(CvSubdiv2DEdge edge)
CODE:
CvSubdiv2DPoint* p = cvSubdiv2DEdgeDst(edge);
if (p) RETVAL = *p; else XSRETURN_UNDEF;
OUTPUT:
RETVAL
CvSubdiv2DEdge
cvSubdiv2DGetEdge(CvSubdiv2DEdge edge, CvNextEdgeType type)
CvSubdiv2DEdge
cvSubdiv2DNextEdge(CvSubdiv2DEdge edge)
CvSubdiv2DPointLocation
cvSubdiv2DLocate(CvSubdiv2D* subdiv, CvPoint2D32f pt, edge, vertex = NO_INIT)
ALIAS: Cv::Subdiv2D::cvSubdiv2DLocate = 1
INPUT:
CvSubdiv2DEdge &edge = NO_INIT
CvSubdiv2DPoint* &vertex = NO_INIT
CODE:
if (items <= 3) {
RETVAL = cvSubdiv2DLocate(subdiv, pt, &edge, NULL);
} else {
vertex = NULL;
RETVAL = cvSubdiv2DLocate(subdiv, pt, &edge, &vertex);
if (vertex) XS_pack_CvSubdiv2DPoint(ST(3), *vertex);
else ST(3) = &PL_sv_undef;
}
OUTPUT:
edge
CvSubdiv2DEdge
cvSubdiv2DRotateEdge(CvSubdiv2DEdge edge, int rotate)
MODULE = Cv PACKAGE = Cv::Subdiv2D
# ====================
CvSubdiv2DPoint
cvSubdivDelaunay2DInsert(CvSubdiv2D* subdiv, CvPoint2D32f pt)
CODE:
CvSubdiv2DPoint* p = cvSubdivDelaunay2DInsert(subdiv, pt);
if (p) RETVAL = *p; else XSRETURN_UNDEF;
OUTPUT:
RETVAL
# ============================================================
# imgproc. Image Processing: Motion Analysis and Object Tracking
# ============================================================
MODULE = Cv PACKAGE = Cv::Arr
# ====================
void
cvAcc(const CvArr* image, CvArr* sum, const CvArr* mask=NULL)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvMultiplyAcc(const CvArr* image1, const CvArr* image2, CvArr* acc, const CvArr* mask=NULL)
void
cvRunningAvg(const CvArr* image, CvArr* acc, double alpha, const CvArr* mask=NULL)
void
cvSquareAcc(const CvArr* image, CvArr* sqsum, const CvArr* mask=NULL)
# ============================================================
# imgproc. Image Processing: Feature Detection
# ============================================================
MODULE = Cv PACKAGE = Cv::Arr
# ====================
void
cvCanny(const CvArr* image, CvArr* edges, double threshold1, double threshold2, int aperture_size=3)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvCornerEigenValsAndVecs(const CvArr* image, CvArr* eigenvv, int blockSize, int aperture_size=3)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvCornerHarris(const CvArr* image, CvArr* harris_dst, int blockSize, int aperture_size=3, double k=0.04)
POSTCALL:
ST(0) = ST(1);
XSRETURN(1);
void
cvCornerMinEigenVal(const CvArr* image, CvArr* eigenval, int blockSize, int aperture_size=3)
void
cvFindCornerSubPix(const CvArr* image, CvPoint2D32f* corners, CvSize win, CvSize zero_zone, CvTermCriteria criteria)
C_ARGS:
image, corners, length(corners), win, zero_zone, criteria
OUTPUT:
corners
void
cvGoodFeaturesToTrack(const CvArr* image, CvArr* eigImage, CvArr* tempImage, corners, int cornerCount, double qualityLevel, double minDistance, const CvArr* mask=NULL, int blockSize=3, int useHarris=0, double k=0.04)
INPUT:
CvPoint2D32f* corners = NO_INIT
INIT:
int length(corners) = cornerCount;
corners = (CvPoint2D32f*)alloca(sizeof(CvPoint2D32f) * cornerCount);
C_ARGS:
image, eigImage, tempImage, corners, &length(corners), qualityLevel, minDistance, mask, blockSize, useHarris, k
OUTPUT:
corners
CvSeq*
cvHoughLines2(CvArr* image, void* storage, int method, double rho, double theta, int threshold, double param1=0, double param2=0)
void
cvPreCornerDetect(const CvArr* image, CvArr* corners, int apertureSize=3)
int
cvSampleLine(const CvArr* image, CvPoint pt1, CvPoint pt2, void* buffer, int connectivity=8)
# ============================================================
# imgproc. Image Processing: Object Detection
# ============================================================
MODULE = Cv PACKAGE = Cv::Arr
# ====================
void
cvMatchTemplate(const CvArr* image, const CvArr* templ, CvArr* result, int method)
POSTCALL:
ST(0) = ST(2);
XSRETURN(1);