|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include <math.h> |
|
|
#include "mex.h" |
|
|
#include <cv.h> |
|
|
|
|
|
#define TRUE 1 |
|
|
#define FALSE 0
|
|
|
|
|
|
struct CV_CTRL {
|
|
|
|
|
|
struct UInt8 {
|
|
|
int active;
|
|
|
unsigned char *img_out, *img_in, *tmp_img_in, *tmp_img_out;
|
|
|
} UInt8;
|
|
|
struct Int8 {
|
|
|
int active;
|
|
|
char *img_out, *img_in, *tmp_img_in, *tmp_img_out;
|
|
|
} Int8;
|
|
|
struct UInt16 {
|
|
|
int active;
|
|
|
unsigned short int *img_out, *img_in, *tmp_img_in, *tmp_img_out;
|
|
|
} UInt16;
|
|
|
struct Int16 {
|
|
|
int active;
|
|
|
short int *img_out, *img_in, *tmp_img_in, *tmp_img_out;
|
|
|
} Int16;
|
|
|
struct Int32 {
|
|
|
int active;
|
|
|
int *img_out, *img_in, *tmp_img_in, *tmp_img_out;
|
|
|
} Int32;
|
|
|
struct Float {
|
|
|
int active;
|
|
|
float *img_out, *img_in, *tmp_img_in, *tmp_img_out;
|
|
|
} Float;
|
|
|
struct Double {
|
|
|
int active;
|
|
|
double *img_out, *img_in, *tmp_img_in, *tmp_img_out;
|
|
|
} Double;
|
|
|
}; |
|
|
|
|
|
void JapproxPoly(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void Jresize(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void Jfloodfill(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void JgoodFeatures(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void JhoughLines2(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void JhoughCircles(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void Jedge(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *method); |
|
|
void JerodeDilate(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *method); |
|
|
void JmorphologyEx(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void Jcolor(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void Jarithm(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *op); |
|
|
void JaddWeighted(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void Jflip(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void JGetQuadrangleSubPix(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void Jfilter(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void Jsmooth(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void Jegipt(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *op); |
|
|
void Jshapes(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *op); |
|
|
void Jinpaint(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
|
|
|
void Set_pt_Ctrl_in (struct CV_CTRL *Ctrl, const mxArray *pi , mxArray *pit, int interl); |
|
|
void Set_pt_Ctrl_out1 ( struct CV_CTRL *Ctrl, mxArray *pi ); |
|
|
void Set_pt_Ctrl_out2 (struct CV_CTRL *Ctrl, mxArray *po, int interl); |
|
|
int getNK(const mxArray *p, int which); |
|
|
|
|
|
void interleave(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir); |
|
|
void interleaveUI8(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir); |
|
|
void interleaveI8(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir); |
|
|
void interleaveUI16(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir); |
|
|
void interleaveI16(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir); |
|
|
void interleaveI32(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir); |
|
|
void interleaveF32(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir); |
|
|
void interleaveF64(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir); |
|
|
void interleaveBlind(unsigned char in[], unsigned char out[], int nx, int ny, int nBands, int dir); |
|
|
void interleaveDouble(double in[], double out[], int nx, int ny); |
|
|
void localSetData(struct CV_CTRL *Ctrl, IplImage* img, int dir, int step); |
|
|
void getDataType(struct CV_CTRL *Ctrl, const mxArray *prhs[], int *nBytes, int *img_depth); |
|
|
void cvResizeUsage(), floodFillUsage(), goodFeaturesUsage(), houghLines2Usage(); |
|
|
void cannyUsage(), sobelUsage(), laplaceUsage(), erodeUsage(), dilateUsage(); |
|
|
void morphologyexUsage(), colorUsage(), flipUsage(), filterUsage(), findContoursUsage(); |
|
|
void JfindContours(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]); |
|
|
void arithmUsage(), addWeightedUsage(), pyrDUsage(), pyrUUsage(), houghCirclesUsage(); |
|
|
void smoothUsage(), lineUsage(), plineUsage(), rectUsage(), circUsage(), eBoxUsage(); |
|
|
void inpaintUsage(), fillConvUsage(), fillPlineUsage(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void mexFunction(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
const char *funName; |
|
|
|
|
|
if (n_in == 0) { |
|
|
mexPrintf("List of currently coded OPENCV functions (original name in parentesis):\n"); |
|
|
mexPrintf("To get a short online help type cvlib_mex(funname)\n"); |
|
|
mexPrintf("E.G. cvlib_mex('resize')\n\n"); |
|
|
mexPrintf("\tadd (cvAdd)\n"); |
|
|
mexPrintf("\taddS (cvAddS)\n"); |
|
|
mexPrintf("\taddweighted (cvAddWeighted)\n"); |
|
|
|
|
|
mexPrintf("\tcanny (cvCanny)\n"); |
|
|
mexPrintf("\tcircle (cvCircle)\n"); |
|
|
mexPrintf("\tcolor (cvCvtColor)\n"); |
|
|
mexPrintf("\tcontours (cvFindContours)\n"); |
|
|
mexPrintf("\tdilate (cvDilate)\n"); |
|
|
mexPrintf("\tdiv (cvDiv)\n"); |
|
|
mexPrintf("\teBox (cvEllipseBox)\n"); |
|
|
mexPrintf("\terode (cvErode)\n"); |
|
|
mexPrintf("\tfilter (cvFilter2D)\n"); |
|
|
mexPrintf("\tfillpoly (cvFillPoly)\n"); |
|
|
mexPrintf("\tflip (cvFlip)\n"); |
|
|
mexPrintf("\tfloodfill (cvFloodFill)\n"); |
|
|
mexPrintf("\tgoodfeatures (cvGoodFeaturesToTrack)\n"); |
|
|
mexPrintf("\thoughlines2 (cvHoughLines2)\n"); |
|
|
mexPrintf("\thoughcircles (cvHoughCircles)\n"); |
|
|
mexPrintf("\tinpaint (cvInpaint)\n"); |
|
|
mexPrintf("\tlaplace (cvLaplace)\n"); |
|
|
mexPrintf("\tline (cvLine)\n"); |
|
|
mexPrintf("\tmorphologyex (cvMorphologyEx)\n"); |
|
|
mexPrintf("\tmul (cvMul)\n"); |
|
|
mexPrintf("\tpyrD (cvPyrDown)\n"); |
|
|
mexPrintf("\tpyrU (cvPyrUp)\n"); |
|
|
mexPrintf("\trectangle (cvRectangle)\n"); |
|
|
mexPrintf("\tresize (cvResize)\n"); |
|
|
mexPrintf("\tsmooth (cvSmooth)\n"); |
|
|
mexPrintf("\tsobel (cvSobel)\n"); |
|
|
mexPrintf("\tsub (cvSub)\n"); |
|
|
mexPrintf("\tsubS (cvSubS)\n"); |
|
|
return; |
|
|
} |
|
|
|
|
|
if(!mxIsChar(prhs[0])) |
|
|
mexErrMsgTxt("CVLIB_MEX: First argument must be a string with the function to call!"); |
|
|
else |
|
|
funName = (char *)mxArrayToString(prhs[0]); |
|
|
|
|
|
if (!strcmp(funName,"resize")) |
|
|
Jresize(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"dp")) |
|
|
JapproxPoly(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"floodfill")) |
|
|
Jfloodfill(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strncmp(funName,"lin",3) || !strncmp(funName,"rec",3) || !strncmp(funName,"cir",3) || |
|
|
!strcmp(funName,"eBox")) |
|
|
Jshapes(n_out, plhs, n_in, prhs, funName); |
|
|
|
|
|
|
|
|
else if (!strcmp(funName,"goodfeatures")) |
|
|
JgoodFeatures(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"houghlines2")) |
|
|
JhoughLines2(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"houghcircles")) |
|
|
JhoughCircles(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"inpaint")) |
|
|
Jinpaint(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"contours")) |
|
|
JfindContours(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"sobel") || !strcmp(funName,"laplace") || !strcmp(funName,"canny")) |
|
|
Jedge(n_out, plhs, n_in, prhs, funName); |
|
|
|
|
|
else if (!strcmp(funName,"erode") || !strcmp(funName,"dilate")) |
|
|
JerodeDilate(n_out, plhs, n_in, prhs, funName); |
|
|
|
|
|
else if (!strcmp(funName,"morphologyex")) |
|
|
JmorphologyEx(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"color")) |
|
|
Jcolor(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"affine2")) |
|
|
JGetQuadrangleSubPix(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if ( !strcmp(funName,"add") || !strcmp(funName,"sub") || !strcmp(funName,"mul") || |
|
|
!strcmp(funName,"div") || !strcmp(funName,"addS") || !strcmp(funName,"subS") ) |
|
|
Jarithm(n_out, plhs, n_in, prhs, funName); |
|
|
|
|
|
else if (!strcmp(funName,"addweighted")) |
|
|
JaddWeighted(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"flip")) |
|
|
Jflip(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"filter")) |
|
|
Jfilter(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"smooth")) |
|
|
Jsmooth(n_out, plhs, n_in, prhs); |
|
|
|
|
|
else if (!strcmp(funName,"pyrU") || !strcmp(funName,"pyrD") ) |
|
|
Jegipt(n_out, plhs, n_in, prhs, funName); |
|
|
|
|
|
else |
|
|
mexErrMsgTxt("CVLIB_MEX: unrecognized function name!"); |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void Jresize(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, nBands, out_dims[3], nx_out, ny_out, nBytes, isMN, img_depth; |
|
|
int cv_code = CV_INTER_LINEAR; |
|
|
double *ptr_d, size_fac; |
|
|
const char *interpMethod; |
|
|
IplImage* src_img = 0; |
|
|
IplImage* dst_img = 0; |
|
|
mxArray *ptr_in, *ptr_out; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { cvResizeUsage(); return; } |
|
|
if (n_out > 2) |
|
|
mexErrMsgTxt("RESIZE returns only one argument!"); |
|
|
if (n_in < 3 || n_in > 4 ) |
|
|
mexErrMsgTxt("RESIZE needs two or three input arguments!"); |
|
|
|
|
|
ptr_d = mxGetPr(prhs[2]); |
|
|
if (mxGetM(prhs[2]) * mxGetN(prhs[2]) == 2) { |
|
|
ny_out = (int)ptr_d[0]; nx_out = (int)ptr_d[1]; |
|
|
isMN = 1; |
|
|
} |
|
|
else if (mxGetM(prhs[2]) * mxGetN(prhs[2]) == 1) { |
|
|
size_fac = *ptr_d; |
|
|
isMN = 0; |
|
|
} |
|
|
else |
|
|
mexErrMsgTxt("RESIZE: second argument must be a scalar or a two elements vector!"); |
|
|
|
|
|
if (n_in == 4) { |
|
|
if(!mxIsChar(prhs[3])) |
|
|
mexErrMsgTxt("RESIZE: Third argument must be a valid string!"); |
|
|
else |
|
|
interpMethod = (char *)mxArrayToString(prhs[3]); |
|
|
if (!strcmp(interpMethod,"nearest")) |
|
|
cv_code = CV_INTER_NN; |
|
|
else if (!strcmp(interpMethod,"bilinear")) |
|
|
cv_code = CV_INTER_LINEAR; |
|
|
else if (!strcmp(interpMethod,"bicubic")) |
|
|
cv_code = CV_INTER_CUBIC; |
|
|
else if (!strcmp(interpMethod,"area")) |
|
|
cv_code = CV_INTER_AREA; |
|
|
else |
|
|
mexErrMsgTxt("RESIZE: Unknow interpolation method!"); |
|
|
} |
|
|
|
|
|
if ( cv_code != CV_INTER_NN && !(mxIsLogical(prhs[1]) || mxIsUint8(prhs[1]) || |
|
|
mxIsUint16(prhs[1]) || mxIsSingle(prhs[1])) ) { |
|
|
mexPrintf("RESIZE ERROR: Interpolation methods other than nearest-neighbor accept only\n"); |
|
|
mexErrMsgTxt(" the folloowing input data types: logical, uint8, uint16 & single.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
if (!isMN) { |
|
|
nx_out = cvRound(nx * size_fac); |
|
|
ny_out = cvRound(ny * size_fac); |
|
|
} |
|
|
out_dims[0] = ny_out; |
|
|
out_dims[1] = nx_out; |
|
|
out_dims[2] = nBands; |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
ptr_out = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
out_dims, mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_out ); |
|
|
|
|
|
dst_img = cvCreateImageHeader(cvSize(nx_out, ny_out), img_depth , nBands ); |
|
|
localSetData( Ctrl, dst_img, 2, nx_out * nBands * nBytes ); |
|
|
|
|
|
cvResize(src_img,dst_img,cv_code); |
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
out_dims, mxGetClassID(prhs[1]), mxREAL); |
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
|
|
|
cvReleaseImageHeader( &dst_img );
|
|
|
|
|
|
mxDestroyArray(ptr_out); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void Jfloodfill(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
unsigned char *mask_img, *tmp_mask; |
|
|
int nx, ny, nx2, ny2, nBands, m, n, nx_var, c = 0, nBytes, img_depth; |
|
|
|
|
|
int lo, up, flags, r, g, b, x, y; |
|
|
int ffill_case = 1; |
|
|
int lo_diff = 20, up_diff; |
|
|
int connectivity = 4; |
|
|
int is_mask = 0; |
|
|
int new_mask_val = 255; |
|
|
double *ptr_d; |
|
|
IplImage* src_img = 0; |
|
|
IplImage* mask = 0; |
|
|
CvPoint seed; |
|
|
CvConnectedComp comp; |
|
|
CvScalar color; |
|
|
CvScalar brightness; |
|
|
CvSize roi = {0,0}; |
|
|
mxArray *ptr_in, *mx_ptr; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { floodFillUsage(); return; } |
|
|
else if (n_out > 2 || n_out == 0) |
|
|
mexErrMsgTxt("FLOODFILL returns one or two output arguments!"); |
|
|
else if (n_out == 2) |
|
|
is_mask = 1; |
|
|
|
|
|
|
|
|
|
|
|
if (!mxIsUint8(prhs[1])) |
|
|
mexErrMsgTxt("FLOODFILL ERROR: Invalid input data type. Only valid type is: UInt8.\n"); |
|
|
|
|
|
if (n_in != 3) |
|
|
mexErrMsgTxt("FLOODFILL requires 2 input arguments!"); |
|
|
|
|
|
else if (mxIsStruct(prhs[2])) { |
|
|
mx_ptr = mxGetField(prhs[2], 0, "Point"); |
|
|
if (mx_ptr == NULL) |
|
|
mexErrMsgTxt("FLOODFILL 'Point' field not provided"); |
|
|
ptr_d = mxGetPr(mx_ptr); |
|
|
x = (int)ptr_d[0]; y = (int)ptr_d[1]; |
|
|
|
|
|
mx_ptr = mxGetField(prhs[2], 0, "Tolerance"); |
|
|
if (mx_ptr != NULL) { |
|
|
ptr_d = mxGetPr(mx_ptr); |
|
|
lo_diff = (int)ptr_d[0]; |
|
|
} |
|
|
|
|
|
mx_ptr = mxGetField(prhs[2], 0, "Connect"); |
|
|
if (mx_ptr != NULL) { |
|
|
ptr_d = mxGetPr(mx_ptr); |
|
|
connectivity = (int)ptr_d[0]; |
|
|
} |
|
|
|
|
|
mx_ptr = mxGetField(prhs[2], 0, "FillColor"); |
|
|
if (mx_ptr != NULL) { |
|
|
ptr_d = mxGetPr(mx_ptr); |
|
|
r = (int)ptr_d[0]; |
|
|
g = (int)ptr_d[1]; |
|
|
b = (int)ptr_d[2]; |
|
|
} |
|
|
else { |
|
|
b = rand() & 255, g = rand() & 255, r = rand() & 255; |
|
|
} |
|
|
} |
|
|
else { |
|
|
if (mxGetM(prhs[2]) * mxGetN(prhs[2]) != 2) |
|
|
mexErrMsgTxt("FLOODFILL: Seed point error. Must be a 2 elements vector."); |
|
|
ptr_d = mxGetPr(prhs[2]); |
|
|
x = (int)ptr_d[0]; y = (int)ptr_d[1]; |
|
|
b = rand() & 255, g = rand() & 255, r = rand() & 255; |
|
|
} |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
up_diff = lo_diff; |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
|
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
if( is_mask ) { |
|
|
nx2 = nx + 2; ny2 = ny + 2; |
|
|
mask = cvCreateImage( cvSize(nx2, ny2), IPL_DEPTH_8U, 1 ); |
|
|
cvZero( mask ); |
|
|
} |
|
|
|
|
|
seed = cvPoint(x,y); |
|
|
lo = ffill_case == 0 ? 0 : lo_diff; |
|
|
up = ffill_case == 0 ? 0 : up_diff; |
|
|
flags = connectivity + (new_mask_val << 8) + (ffill_case == 1 ? CV_FLOODFILL_FIXED_RANGE : 0); |
|
|
|
|
|
if( nBands == 3 ) { |
|
|
color = CV_RGB( r, g, b ); |
|
|
cvFloodFill( src_img, seed, color, CV_RGB( lo, lo, lo ), |
|
|
CV_RGB( up, up, up ), &comp, flags, is_mask ? mask : NULL ); |
|
|
} |
|
|
else { |
|
|
brightness = cvRealScalar((r*2 + g*7 + b + 5)/10); |
|
|
cvFloodFill( src_img, seed, brightness, cvRealScalar(lo), |
|
|
cvRealScalar(up), &comp, flags, is_mask ? mask : NULL ); |
|
|
} |
|
|
|
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
interleaveBlind (Ctrl->UInt8.tmp_img_in, (unsigned char *)mxGetData(plhs[0]), nx, ny, nBands, -1); |
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
|
|
|
if ( is_mask ) { |
|
|
nx_var = mask->widthStep; |
|
|
tmp_mask = (unsigned char *)mxCalloc((nx*ny),sizeof(char)); |
|
|
|
|
|
|
|
|
for (m = 1, c = 0; m < ny+1; m++) |
|
|
for (n = 1; n < nx+1; n++) |
|
|
tmp_mask[c++] = (unsigned char)(mask->imageData[m*nx_var + n] & 1); |
|
|
|
|
|
plhs[1] = mxCreateNumericMatrix(ny, nx, mxLOGICAL_CLASS, mxREAL); |
|
|
mask_img = mxGetData(plhs[1]); |
|
|
|
|
|
interleaveBlind (tmp_mask, mask_img, nx, ny, 1, -1); |
|
|
mxFree((void *)tmp_mask); |
|
|
cvReleaseImage( &mask ); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void Jshapes(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *method) { |
|
|
int nx, ny, nBands, nBytes, img_depth, inplace = FALSE; |
|
|
int r, g, b, radius = 0, thickness = 1, line_type = 8; |
|
|
int ind_opt = 4; |
|
|
double *ptr_d; |
|
|
IplImage *src_img = 0, *dst = 0; |
|
|
CvPoint pt1, pt2; |
|
|
CvScalar color; |
|
|
CvBox2D box; |
|
|
mxArray *ptr_in, *mx_ptr; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { |
|
|
if (!strncmp(method,"lin",3)) lineUsage(); |
|
|
else if (!strncmp(method,"rec",3)) rectUsage(); |
|
|
else if (!strncmp(method,"cir",3)) circUsage(); |
|
|
else if (!strcmp(method,"eBox")) eBoxUsage(); |
|
|
return; |
|
|
} |
|
|
else if (n_out > 1 ) |
|
|
mexErrMsgTxt("SHAPES returns either one or zero arguments!"); |
|
|
|
|
|
|
|
|
if (!mxIsUint8(prhs[1])) |
|
|
mexErrMsgTxt("SHAPES ERROR: Invalid input data type. Only valid type is: UInt8.\n"); |
|
|
|
|
|
if (!strcmp(method,"eBox") && n_in < 3) |
|
|
mexErrMsgTxt("EllipseBox requires at least 2 input arguments!"); |
|
|
else if (strcmp(method,"eBox") && n_in < 4) |
|
|
mexErrMsgTxt("SHAPES requires at least 3 input arguments!"); |
|
|
|
|
|
if (!strncmp(method,"lin",3) || !strncmp(method,"rec",3)) { |
|
|
|
|
|
if (mxGetM(prhs[2]) * mxGetN(prhs[2]) != 2) |
|
|
mexErrMsgTxt("SHAPES: First point error. Must be a 2 elements vector."); |
|
|
if (mxGetM(prhs[3]) * mxGetN(prhs[3]) != 2) |
|
|
mexErrMsgTxt("SHAPES: Second point error. Must be a 2 elements vector."); |
|
|
|
|
|
|
|
|
ptr_d = (double *)mxGetData(prhs[2]); |
|
|
pt1.x = (int)ptr_d[0]; pt1.y = (int)ptr_d[1]; |
|
|
ptr_d = (double *)mxGetData(prhs[3]); |
|
|
pt2.x = (int)ptr_d[0]; pt2.y = (int)ptr_d[1]; |
|
|
} |
|
|
else if (!strncmp(method,"cir",3)) { |
|
|
if (mxGetM(prhs[2]) * mxGetN(prhs[2]) != 2) |
|
|
mexErrMsgTxt("CIRCLE: First point error - the CENTER. Must be a 2 elements vector."); |
|
|
ptr_d = (double *)mxGetData(prhs[2]); |
|
|
pt1.x = (int)ptr_d[0]; pt1.y = (int)ptr_d[1]; |
|
|
ptr_d = (double *)mxGetData(prhs[3]); |
|
|
radius = (int)ptr_d[0]; |
|
|
} |
|
|
else if (!strcmp(method,"eBox")) { |
|
|
if (mxIsStruct(prhs[2])) { |
|
|
mx_ptr = mxGetField(prhs[2], 0, "center"); |
|
|
if (mx_ptr == NULL) |
|
|
mexErrMsgTxt("EllipseBox 'center' field not provided"); |
|
|
if (mxGetM(mxGetField(prhs[2],0,"center")) * mxGetN(mxGetField(prhs[2],0,"center")) != 2) |
|
|
mexErrMsgTxt("EllipseBox: 'center' must contain a 2 elements vector"); |
|
|
ptr_d = mxGetPr(mx_ptr); |
|
|
box.center.x = (float)ptr_d[0]; |
|
|
box.center.y = (float)ptr_d[1]; |
|
|
|
|
|
mx_ptr = mxGetField(prhs[2], 0, "size"); |
|
|
if (ptr_d == NULL) |
|
|
mexErrMsgTxt("EllipseBox 'size' field not provided"); |
|
|
if (mxGetM(mxGetField(prhs[2],0,"size")) * mxGetN(mxGetField(prhs[2],0,"size")) != 2) |
|
|
mexErrMsgTxt("EllipseBox: 'size' must contain a 2 elements vector"); |
|
|
ptr_d = mxGetPr(mx_ptr); |
|
|
box.size.width = (float)ptr_d[1]; |
|
|
box.size.height = (float)ptr_d[0]; |
|
|
|
|
|
mx_ptr = mxGetField(prhs[2], 0, "angle"); |
|
|
if (mx_ptr == NULL) |
|
|
box.angle = 0.0f; |
|
|
else { |
|
|
ptr_d = mxGetPr(mx_ptr); |
|
|
box.angle = (float)ptr_d[0]; |
|
|
} |
|
|
|
|
|
n_in++; |
|
|
ind_opt = 3; |
|
|
} |
|
|
else |
|
|
mexErrMsgTxt("EllipseBox: Second argument must be a structure."); |
|
|
} |
|
|
|
|
|
color = cvScalarAll(255); |
|
|
|
|
|
if (n_in > 4 && !mxIsEmpty(prhs[ind_opt])) { |
|
|
ptr_d = (double *)mxGetData(prhs[ind_opt]); |
|
|
if (mxGetM(prhs[ind_opt]) * mxGetN(prhs[ind_opt]) == 1) { |
|
|
r = (int)ptr_d[0]; |
|
|
color = CV_RGB( r, r, r ); |
|
|
} |
|
|
else if (mxGetM(prhs[ind_opt]) * mxGetN(prhs[ind_opt]) == 3) { |
|
|
r = (int)ptr_d[0]; g = (int)ptr_d[1]; b = (int)ptr_d[2]; |
|
|
color = CV_RGB( r, g, b ); |
|
|
} |
|
|
else |
|
|
mexErrMsgTxt("LINE: Fourth argument must be a 1 or a 3 elements vector."); |
|
|
|
|
|
ind_opt++; |
|
|
} |
|
|
if (n_in > 5 && !mxIsEmpty(prhs[ind_opt])) |
|
|
thickness = (int)(*mxGetPr(prhs[ind_opt++])); |
|
|
if (n_in > 6 && !mxIsEmpty(prhs[ind_opt])) |
|
|
line_type = (int)(*mxGetPr(prhs[ind_opt])); |
|
|
|
|
|
if (thickness < 0) thickness = -1; |
|
|
|
|
|
if (n_out == 0) |
|
|
inplace = TRUE; |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
|
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
if (!inplace) { |
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
dst = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
cvSetImageData( dst, (void *)mxGetData(plhs[0]), nx * nBytes * nBands ); |
|
|
localSetData( Ctrl, dst, 1, nx * nBands * nBytes ); |
|
|
if (!strncmp(method,"lin",3)) |
|
|
cvLine( dst, pt1, pt2, color, thickness, line_type, 0 ); |
|
|
else if (!strncmp(method,"rec",3)) |
|
|
cvRectangle( dst, pt1, pt2, color, thickness, line_type, 0 ); |
|
|
else if (!strncmp(method,"cir",3)) |
|
|
cvCircle( dst, pt1, radius, color, thickness, line_type, 0 ); |
|
|
else if (!strcmp(method,"eBox")) |
|
|
cvEllipseBox( dst, box, color, thickness, line_type, 0 ); |
|
|
interleaveBlind (Ctrl->UInt8.tmp_img_in, (unsigned char *)mxGetData(plhs[0]), nx, ny, nBands, -1); |
|
|
cvReleaseImageHeader( &dst ); |
|
|
} |
|
|
else { |
|
|
if (!strncmp(method,"lin",3)) |
|
|
cvLine( src_img, pt1, pt2, color, thickness, line_type, 0 ); |
|
|
else if (!strncmp(method,"rec",3)) |
|
|
cvRectangle( src_img, pt1, pt2, color, thickness, line_type, 0 ); |
|
|
else if (!strncmp(method,"cir",3)) |
|
|
cvCircle( src_img, pt1, radius, color, thickness, line_type, 0 ); |
|
|
else if (!strcmp(method,"eBox")) |
|
|
cvEllipseBox( src_img, box, color, thickness, line_type, 0 ); |
|
|
|
|
|
interleaveBlind (Ctrl->UInt8.tmp_img_in, (unsigned char *)mxGetData(prhs[1]), nx, ny, nBands, -1); |
|
|
} |
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void JgoodFeatures(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
const int max_features = 100000; |
|
|
int nx, ny, n, i, nBytes, img_depth, nBands, corner_count, nOut_corners = max_features; |
|
|
unsigned char *ptr_gray; |
|
|
|
|
|
double *ptr_d, quality_level = 0.1, min_distance = 10; |
|
|
IplImage *src_img = 0, *eig_image, *temp_image, *src_gray; |
|
|
CvSize roi = {0,0}; |
|
|
CvPoint2D32f* corners; |
|
|
mxArray *ptr_in; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { goodFeaturesUsage(); return; } |
|
|
|
|
|
if ( !mxIsUint8(prhs[1]) ) |
|
|
mexErrMsgTxt("GOODFEATURES: Invalid input data type. Valid type is: UInt8.\n"); |
|
|
if (n_out > 1) |
|
|
mexErrMsgTxt("GOODFEATURES returns only one output argument!"); |
|
|
|
|
|
if (n_in >= 3 && !mxIsEmpty(prhs[2])) |
|
|
nOut_corners = (int)(*mxGetPr(prhs[2])); |
|
|
if (n_in >= 4 && !mxIsEmpty(prhs[3])) |
|
|
quality_level = *mxGetPr(prhs[3]); |
|
|
if (n_in >= 5 && !mxIsEmpty(prhs[4])) |
|
|
min_distance = *mxGetPr(prhs[4]); |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
|
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
if (nBands == 3) { |
|
|
src_gray = cvCreateImageHeader( cvSize(nx, ny), 8, 1 ); |
|
|
ptr_gray = (unsigned char *)mxCalloc (nx*ny, sizeof (unsigned char)); |
|
|
cvSetImageData( src_gray, (void *)ptr_gray, nx ); |
|
|
cvCvtColor(src_img, src_gray, CV_BGR2GRAY); |
|
|
for (i = 0; i < nx*ny; i++) |
|
|
Ctrl->UInt8.tmp_img_in[i] = ptr_gray[i]; |
|
|
mxFree(ptr_gray); |
|
|
cvReleaseImageHeader( &src_gray ); |
|
|
|
|
|
|
|
|
src_img->nChannels = 1; |
|
|
src_img->widthStep = nx * nBytes; |
|
|
src_img->imageSize = ny * src_img->widthStep; |
|
|
} |
|
|
|
|
|
eig_image = cvCreateImage( cvSize(nx, ny), 32, 1 ); |
|
|
temp_image = cvCreateImage( cvSize(nx, ny), 32, 1 ); |
|
|
|
|
|
corners = (CvPoint2D32f*)cvAlloc(max_features*sizeof(corners)); |
|
|
|
|
|
quality_level = 0.1; |
|
|
corner_count = max_features; |
|
|
cvGoodFeaturesToTrack( src_img, eig_image, temp_image, corners, |
|
|
&corner_count, quality_level, min_distance, NULL, 3, 0, 0.04 ); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cvReleaseImage( &eig_image ); |
|
|
cvReleaseImage( &temp_image ); |
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
|
|
|
nOut_corners = MIN(nOut_corners,corner_count); |
|
|
plhs[0] = mxCreateNumericMatrix(nOut_corners, 2, mxDOUBLE_CLASS, mxREAL); |
|
|
ptr_d = mxGetPr(plhs[0]); |
|
|
for ( n = 0; n < nOut_corners; n++ ) { |
|
|
ptr_d[n] = corners[n].x + 1; |
|
|
ptr_d[n+nOut_corners] = corners[n].y + 1; |
|
|
} |
|
|
cvFree((void **)&corners ); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void JhoughLines2(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, i, nBytes, img_depth, nBands, np, method = CV_HOUGH_PROBABILISTIC, thresh = 50; |
|
|
unsigned char *ptr_gray; |
|
|
const char *method_s; |
|
|
|
|
|
double *ptr_d, *lineS, rho = 1, theta = CV_PI/180, par1 = 50, par2 = 15, a, b, x0, y0; |
|
|
IplImage *src_img = 0, *dst_img, *src_gray; |
|
|
CvPoint *line; |
|
|
CvSeq* lines = 0; |
|
|
CvMemStorage* storage; |
|
|
mxArray *ptr_in, *ptr_out, *mx_ptr; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { houghLines2Usage(); return; } |
|
|
|
|
|
if ( !(mxIsUint8(prhs[1]) || mxIsLogical(prhs[1])) ) |
|
|
mexErrMsgTxt("HOUGHLINES2: Invalid input data type. Valid types are: UInt8 OR Logical.\n"); |
|
|
|
|
|
if (n_out != 1) |
|
|
mexErrMsgTxt("HOUGHLINES2 returns one (and one only) output!"); |
|
|
|
|
|
if (n_in > 2) { |
|
|
if(!mxIsChar(prhs[2])) |
|
|
mexErrMsgTxt("CVLIB_MEX: Third argument must contain the METHOD string!"); |
|
|
else |
|
|
method_s = (char *)mxArrayToString(prhs[2]); |
|
|
if (strcmp(method_s,"standard") && strcmp(method_s,"probabilistic")) |
|
|
mexErrMsgTxt("CVLIB_MEX: Unknown METHOD!"); |
|
|
if (!strcmp(method_s,"standard")) |
|
|
method = CV_HOUGH_STANDARD; |
|
|
if (n_in == 8) { |
|
|
ptr_d = (double *)(mxGetData(prhs[3])); rho = ptr_d[0]; |
|
|
ptr_d = (double *)(mxGetData(prhs[4])); theta = ptr_d[0]; |
|
|
ptr_d = (double *)(mxGetData(prhs[5])); thresh = (int)ptr_d[0]; |
|
|
ptr_d = (double *)(mxGetData(prhs[6])); par1 = ptr_d[0]; |
|
|
ptr_d = (double *)(mxGetData(prhs[7])); par2 = ptr_d[0]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
if (!mxIsLogical(prhs[1])) |
|
|
ptr_out = mxCreateNumericMatrix(ny, nx, mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
|
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), 8, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
if (nBands == 3) { |
|
|
src_gray = cvCreateImageHeader( cvSize(nx, ny), 8, 1 ); |
|
|
ptr_gray = (unsigned char *)mxCalloc (nx*ny, sizeof (unsigned char)); |
|
|
cvSetImageData( src_gray, (void *)ptr_gray, nx ); |
|
|
cvCvtColor(src_img, src_gray, CV_BGR2GRAY); |
|
|
for (i = 0; i < nx*ny; i++) |
|
|
Ctrl->UInt8.tmp_img_in[i] = ptr_gray[i]; |
|
|
mxFree(ptr_gray); |
|
|
cvReleaseImageHeader( &src_gray ); |
|
|
|
|
|
|
|
|
src_img->nChannels = 1; |
|
|
src_img->widthStep = nx * nBytes; |
|
|
src_img->imageSize = ny * src_img->widthStep; |
|
|
} |
|
|
|
|
|
storage = cvCreateMemStorage(0); |
|
|
|
|
|
if (!mxIsLogical(prhs[1])) { |
|
|
dst_img = cvCreateImageHeader( cvSize(nx, ny), 8, 1 ); |
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_out ); |
|
|
localSetData( Ctrl, dst_img, 2, nx * nBytes ); |
|
|
|
|
|
cvCanny( src_img, dst_img, 50, 200, 3 ); |
|
|
|
|
|
lines = cvHoughLines2( dst_img, storage, method, rho, theta, thresh, par1, par2 ); |
|
|
cvReleaseImageHeader( &dst_img ); |
|
|
mxDestroyArray(ptr_out); |
|
|
} |
|
|
else |
|
|
lines = cvHoughLines2( src_img, storage, method, rho, theta, thresh, par1, par2 ); |
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
|
|
|
np = lines->total; |
|
|
|
|
|
plhs[0] = mxCreateCellMatrix(np, 1); |
|
|
mx_ptr = mxCreateNumericMatrix(2, 2, mxDOUBLE_CLASS, mxREAL); |
|
|
ptr_d = mxGetPr(mx_ptr); |
|
|
if (method == CV_HOUGH_PROBABILISTIC) { |
|
|
for( i = 0; i < np; i++ ) { |
|
|
line = (CvPoint *)cvGetSeqElem(lines,i); |
|
|
ptr_d[0] = (double)line[0].y + 1; |
|
|
ptr_d[1] = (double)line[1].y + 1; |
|
|
ptr_d[2] = (double)line[0].x + 1; |
|
|
ptr_d[3] = (double)line[1].x + 1; |
|
|
mxSetCell(plhs[0],i,mxDuplicateArray(mx_ptr)); |
|
|
} |
|
|
} |
|
|
else { |
|
|
for( i = 0; i < np; i++ ) { |
|
|
lineS = (double *)cvGetSeqElem(lines,i); |
|
|
a = cos(lineS[1]), b = sin(lineS[1]); |
|
|
x0 = a*lineS[0], y0 = b*lineS[0]; |
|
|
|
|
|
ptr_d[0] = cvRound(y0 + 1000*(a)); |
|
|
ptr_d[1] = cvRound(y0 - 1000*(a)); |
|
|
ptr_d[2] = cvRound(x0 + 1000*(-b)); |
|
|
ptr_d[3] = cvRound(x0 - 1000*(-b)); |
|
|
mxSetCell(plhs[0],i,mxDuplicateArray(mx_ptr)); |
|
|
} |
|
|
} |
|
|
mxDestroyArray(mx_ptr); |
|
|
|
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void JhoughCircles(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, i, nBytes, img_depth, nBands, np, thresh = 50, min_radius = 5, max_radius=0; |
|
|
unsigned char *ptr_gray; |
|
|
|
|
|
float *circ; |
|
|
double *ptr_d, dp = 1, min_dist = 20, par1 = 50, par2 = 60; |
|
|
IplImage *src_img = 0, *src_gray; |
|
|
IplConvKernel *element = 0; |
|
|
CvSeq* circles = 0; |
|
|
CvMemStorage* storage; |
|
|
mxArray *ptr_in; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { houghCirclesUsage(); return; } |
|
|
|
|
|
if ( !(mxIsUint8(prhs[1]) || mxIsLogical(prhs[1])) ) |
|
|
mexErrMsgTxt("HOUGHCIRCLES: Invalid input data type. Valid types are: Logical or UInt8.\n"); |
|
|
|
|
|
if (n_out != 1) |
|
|
mexErrMsgTxt("HOUGHCIRCLES returns one (and one only) output!"); |
|
|
|
|
|
if (n_in >= 3 && !mxIsEmpty(prhs[2])) |
|
|
dp = *mxGetPr(prhs[2]); |
|
|
if (n_in >= 4 && !mxIsEmpty(prhs[3])) |
|
|
min_dist = *mxGetPr(prhs[3]); |
|
|
if (n_in >= 5 && !mxIsEmpty(prhs[4])) |
|
|
par1 = *mxGetPr(prhs[4]); |
|
|
if (n_in >= 6 && !mxIsEmpty(prhs[5])) |
|
|
par2 = *mxGetPr(prhs[5]); |
|
|
if (n_in >= 7 && !mxIsEmpty(prhs[6])) |
|
|
min_radius = (int)*mxGetPr(prhs[6]); |
|
|
if (n_in >= 8 && !mxIsEmpty(prhs[7])) |
|
|
max_radius = (int)*mxGetPr(prhs[7]); |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
|
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), 8, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
|
|
|
element = cvCreateStructuringElementEx( 4*2+1, 4*2+1, 4, 4, CV_SHAPE_ELLIPSE, 0 ); |
|
|
cvErode(src_img,src_img,element,1); |
|
|
cvDilate(src_img,src_img,element,1); |
|
|
|
|
|
if (nBands == 3) { |
|
|
src_gray = cvCreateImageHeader( cvSize(nx, ny), 8, 1 ); |
|
|
ptr_gray = (unsigned char *)mxCalloc (nx*ny, sizeof (unsigned char)); |
|
|
cvSetImageData( src_gray, (void *)ptr_gray, nx ); |
|
|
cvCvtColor(src_img, src_gray, CV_BGR2GRAY); |
|
|
for (i = 0; i < nx*ny; i++) |
|
|
Ctrl->UInt8.tmp_img_in[i] = ptr_gray[i]; |
|
|
mxFree(ptr_gray); |
|
|
cvReleaseImageHeader( &src_gray ); |
|
|
|
|
|
|
|
|
src_img->nChannels = 1; |
|
|
src_img->widthStep = nx * nBytes; |
|
|
src_img->imageSize = ny * src_img->widthStep; |
|
|
} |
|
|
|
|
|
storage = cvCreateMemStorage(0); |
|
|
|
|
|
|
|
|
cvSmooth( src_img, src_img, CV_GAUSSIAN, 5, 5, 0, 0 ); |
|
|
circles = cvHoughCircles( src_img, storage, CV_HOUGH_GRADIENT, dp, min_dist, |
|
|
par1, par2, min_radius, max_radius ); |
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
|
|
|
np = circles->total; |
|
|
|
|
|
plhs[0] = mxCreateNumericMatrix(np, 3, mxDOUBLE_CLASS, mxREAL); |
|
|
ptr_d = mxGetPr(plhs[0]); |
|
|
for( i = 0; i < np; i++ ) { |
|
|
circ = (float *)cvGetSeqElem(circles,i); |
|
|
ptr_d[i] = (double)circ[0] + 1; |
|
|
ptr_d[i+np] = (double)circ[1] + 1; |
|
|
ptr_d[i+2*np] = (double)circ[2]; |
|
|
} |
|
|
|
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void JfindContours(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, i, j, nBytes, img_depth, nBands, np, ncont = 0; |
|
|
unsigned char *ptr_gray; |
|
|
|
|
|
double *ptr_d; |
|
|
IplImage *src_img = 0, *dst_img, *src_gray; |
|
|
CvPoint *PointArray; |
|
|
CvSeq *contours = 0, *cont = 0; |
|
|
CvMemStorage* storage; |
|
|
mxArray *ptr_in, *ptr_out, *mx_ptr; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { findContoursUsage(); return; } |
|
|
|
|
|
if ( !(mxIsUint8(prhs[1]) || mxIsLogical(prhs[1])) ) |
|
|
mexErrMsgTxt("FINDCONTOURS: Invalid input data type. Valid types are: UInt8 OR Logical.\n"); |
|
|
|
|
|
if (n_out != 1) |
|
|
mexErrMsgTxt("FINDCONTOURS returns one (and one only) output!"); |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
if (!mxIsLogical(prhs[1])) |
|
|
ptr_out = mxCreateNumericMatrix(ny, nx, mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
|
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), 8, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
storage = cvCreateMemStorage(0); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
ncont = cvFindContours( src_img, storage, &contours, sizeof(CvContour),
|
|
|
CV_RETR_LIST, CV_CHAIN_APPROX_NONE, cvPoint(1,1) );
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
plhs[0] = mxCreateCellMatrix(ncont, 1);
|
|
|
for( i = 0; i < ncont; i++ ) {
|
|
|
np = contours->total;
|
|
|
PointArray = (CvPoint*)malloc( np*sizeof(CvPoint) );
|
|
|
cvCvtSeqToArray(contours, PointArray, CV_WHOLE_SEQ);
|
|
|
mx_ptr = mxCreateNumericMatrix(np, 2, mxDOUBLE_CLASS, mxREAL);
|
|
|
ptr_d = mxGetPr(mx_ptr);
|
|
|
for( j = 0; j < np; j++ ) {
|
|
|
ptr_d[j] = (double)PointArray[j].y;
|
|
|
ptr_d[j+np] = (double)PointArray[j].x;
|
|
|
}
|
|
|
|
|
|
mxSetCell(plhs[0],i,mxDuplicateArray(mx_ptr));
|
|
|
mxDestroyArray(mx_ptr);
|
|
|
free(PointArray);
|
|
|
contours = contours->h_next;
|
|
|
} |
|
|
|
|
|
|
|
|
cvReleaseMemStorage(&storage); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void JapproxPoly(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, i, j, nBytes, nz, np, ncont = 0; |
|
|
|
|
|
double *ptr_d, par1 = 3; |
|
|
CvMat *map_matrix = 0, *cont = 0; |
|
|
CvMemStorage* storage = cvCreateMemStorage(0); |
|
|
mxArray *ptr_in, *ptr_out, *mx_ptr; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { findContoursUsage(); return; } |
|
|
ptr_d = mxGetPr(prhs[1]); |
|
|
if (n_in == 3) |
|
|
par1 = *mxGetPr(prhs[2]); |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nz = getNK(prhs[1],2); |
|
|
|
|
|
map_matrix = cvCreateMatHeader( ny, nx, CV_64FC1 ); |
|
|
cvSetData( map_matrix, (void *)ptr_d, nx*8 ); |
|
|
|
|
|
cont = cvApproxPoly( map_matrix, sizeof(CvMat), storage, CV_POLY_APPROX_DP, par1, 0 ); |
|
|
return; |
|
|
|
|
|
|
|
|
np = cont->rows; |
|
|
|
|
|
plhs[0] = mxCreateNumericMatrix(np, nx, mxGetClassID(prhs[1]), mxREAL); |
|
|
ptr_d = mxGetPr(plhs[0]); |
|
|
|
|
|
ptr_d = cont->data.db; |
|
|
|
|
|
cvReleaseMatHeader( &map_matrix ); |
|
|
} |
|
|
|
|
|
|
|
|
void Jedge(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *method) { |
|
|
int nx, ny, nBands, i, nBytes, img_depth, kernel = 3, xord = 1, yord = 0; |
|
|
unsigned char *ptr_gray; |
|
|
double thresh1 = 40, thresh2 = 200, *ptr_d; |
|
|
|
|
|
IplImage *src_img = 0, *dst_img, *src_gray, *dst_16; |
|
|
mxArray *ptr_in, *ptr_out, *ptr_16; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (!strcmp(method,"canny")) { |
|
|
if (n_in == 1) { cannyUsage(); return; } |
|
|
if (!(mxIsUint8(prhs[1]) || mxIsLogical(prhs[1]))) |
|
|
mexErrMsgTxt("CANNY requires that input image is of uint8 or logical type!"); |
|
|
if (n_in == 5) { |
|
|
ptr_d = mxGetPr(prhs[2]); thresh1 = (double)ptr_d[0]; |
|
|
ptr_d = mxGetPr(prhs[3]); thresh2 = (double)ptr_d[0]; |
|
|
ptr_d = mxGetPr(prhs[4]); kernel = (int)ptr_d[0]; |
|
|
} |
|
|
} |
|
|
else if (!strcmp(method,"sobel")) { |
|
|
if (n_in == 1) { sobelUsage(); return; } |
|
|
if ( !( mxIsUint8(prhs[1]) || mxIsSingle(prhs[1]) ) ) |
|
|
mexErrMsgTxt("SOBEL requires image of uint8 or single type!"); |
|
|
if (n_in == 5) { |
|
|
ptr_d = mxGetPr(prhs[2]); xord = (int)ptr_d[0]; |
|
|
ptr_d = mxGetPr(prhs[3]); yord = (int)ptr_d[0]; |
|
|
ptr_d = mxGetPr(prhs[4]); kernel = (int)ptr_d[0]; |
|
|
} |
|
|
} |
|
|
else { |
|
|
if (n_in == 1) { laplaceUsage(); return; } |
|
|
if ( !( mxIsUint8(prhs[1]) || mxIsSingle(prhs[1]) ) ) |
|
|
mexErrMsgTxt("LAPLACE requires image of uint8 or single type!"); |
|
|
if (n_in == 3) { |
|
|
ptr_d = mxGetPr(prhs[2]); kernel = (int)ptr_d[0]; |
|
|
} |
|
|
} |
|
|
if (!(kernel == -1 || kernel == 1 || kernel == 3 || kernel == 5 || kernel == 7) ) |
|
|
mexErrMsgTxt("CANNY/SOBEL/LAPLACE: Wrong kernel size!"); |
|
|
|
|
|
if (n_out != 1) { |
|
|
mexPrintf("%s returns one (and one only) output\n", method); |
|
|
mexErrMsgTxt(""); |
|
|
} |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
ptr_out = mxCreateNumericMatrix(ny, nx, mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
|
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
if (nBands == 3) { |
|
|
src_gray = cvCreateImageHeader( cvSize(nx, ny), 8, 1 ); |
|
|
ptr_gray = (unsigned char *)mxCalloc (nx*ny, sizeof (unsigned char)); |
|
|
cvSetImageData( src_gray, (void *)ptr_gray, nx ); |
|
|
cvCvtColor(src_img, src_gray, CV_BGR2GRAY); |
|
|
for (i = 0; i < nx*ny; i++) |
|
|
Ctrl->UInt8.tmp_img_in[i] = ptr_gray[i]; |
|
|
mxFree(ptr_gray); |
|
|
cvReleaseImageHeader( &src_gray ); |
|
|
|
|
|
|
|
|
src_img->nChannels = 1; |
|
|
src_img->widthStep = nx * nBytes; |
|
|
src_img->imageSize = ny * src_img->widthStep; |
|
|
} |
|
|
|
|
|
dst_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, 1 ); |
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_out ); |
|
|
localSetData( Ctrl, dst_img, 2, nx * nBytes ); |
|
|
|
|
|
if (!strcmp(method,"canny")) |
|
|
cvCanny(src_img,dst_img, thresh1, thresh2, kernel); |
|
|
else if (Ctrl->UInt8.active) { |
|
|
Ctrl->UInt8.active = FALSE; |
|
|
Ctrl->Int16.active = TRUE; |
|
|
ptr_16 = mxCreateNumericMatrix(ny, nx, mxINT16_CLASS, mxREAL); |
|
|
dst_16 = cvCreateImageHeader( cvSize(nx, ny), IPL_DEPTH_16S, 1 ); |
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_16 ); |
|
|
localSetData( Ctrl, dst_16, 2, nx * 2 ); |
|
|
if (!strcmp(method,"laplace")) |
|
|
cvLaplace(src_img,dst_16, kernel); |
|
|
else |
|
|
cvSobel(src_img,dst_16, xord, yord, kernel); |
|
|
|
|
|
cvConvertScaleAbs(dst_16, dst_img, 1, 0); |
|
|
cvReleaseImageHeader( &dst_16 ); |
|
|
mxDestroyArray(ptr_16); |
|
|
Ctrl->UInt8.active = TRUE; |
|
|
Ctrl->Int16.active = FALSE; |
|
|
} |
|
|
else if (!strcmp(method,"laplace")) |
|
|
cvLaplace(src_img,dst_img, kernel); |
|
|
else if (!strcmp(method,"sobel")) |
|
|
cvSobel(src_img,dst_img, xord, yord, kernel); |
|
|
|
|
|
|
|
|
if (Ctrl->UInt8.active == TRUE ) { |
|
|
for (i = 0; i < nx*ny; i++) |
|
|
Ctrl->UInt8.tmp_img_out[i] = Ctrl->UInt8.tmp_img_out[i] & 1; |
|
|
} |
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
if (Ctrl->UInt8.active == TRUE ) |
|
|
plhs[0] = mxCreateNumericMatrix(ny, nx, mxLOGICAL_CLASS, mxREAL); |
|
|
else |
|
|
plhs[0] = mxCreateNumericMatrix(ny, nx, mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
|
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
cvReleaseImageHeader( &dst_img ); |
|
|
mxDestroyArray(ptr_out); |
|
|
} |
|
|
|
|
|
|
|
|
void JmorphologyEx(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, nBands, nBytes, img_depth, cv_code, iterations = 1; |
|
|
const char *operation; |
|
|
double *ptr_d; |
|
|
|
|
|
IplImage *src_img = 0, *dst_img, *tmp_img; |
|
|
mxArray *ptr_in, *ptr_out; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { morphologyexUsage(); return; } |
|
|
|
|
|
if ( !( mxIsUint8(prhs[1]) || mxIsSingle(prhs[1]) || mxIsLogical(prhs[1]) ) ) |
|
|
mexErrMsgTxt("MORPHOLOGYEX requires image of uint8 or single type!"); |
|
|
|
|
|
if (n_in < 3) |
|
|
mexErrMsgTxt("MORPHOLOGYEX requires at least 2 input arguments!"); |
|
|
|
|
|
if(!mxIsChar(prhs[2])) |
|
|
mexErrMsgTxt("MORPHOLOGYEX: Second argument must be a valid string!"); |
|
|
else |
|
|
operation = (char *)mxArrayToString(prhs[2]); |
|
|
|
|
|
if (!strcmp(operation,"open")) |
|
|
cv_code = CV_MOP_OPEN; |
|
|
else if (!strcmp(operation,"close")) |
|
|
cv_code = CV_MOP_CLOSE; |
|
|
else if (!strcmp(operation,"gradient")) |
|
|
cv_code = CV_MOP_GRADIENT; |
|
|
else if (!strcmp(operation,"tophat")) |
|
|
cv_code = CV_MOP_TOPHAT; |
|
|
else if (!strcmp(operation,"blackhat")) |
|
|
cv_code = CV_MOP_BLACKHAT; |
|
|
else |
|
|
mexErrMsgTxt("MORPHOLOGYEX: Unknow operation!"); |
|
|
|
|
|
if (n_out != 1) |
|
|
mexErrMsgTxt("MORPHOLOGYEX: returns one (and one only) output"); |
|
|
|
|
|
if (n_in == 4) { |
|
|
ptr_d = mxGetPr(prhs[3]); iterations = (int)ptr_d[0]; |
|
|
} |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
ptr_out = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_out ); |
|
|
dst_img = cvCreateImage(cvSize(nx, ny), img_depth , nBands ); |
|
|
localSetData( Ctrl, dst_img, 2, nx * nBands * nBytes ); |
|
|
|
|
|
if (cv_code == CV_MOP_GRADIENT || (iterations > 1 && (cv_code == CV_MOP_TOPHAT || cv_code == CV_MOP_BLACKHAT) )) { |
|
|
tmp_img = cvCreateImage( cvSize(nx, ny), img_depth, nBands ); |
|
|
} |
|
|
else |
|
|
tmp_img = NULL; |
|
|
|
|
|
cvMorphologyEx(src_img,dst_img,tmp_img,NULL,cv_code,iterations); |
|
|
|
|
|
if (cv_code == CV_MOP_GRADIENT || (iterations > 1 && (cv_code == CV_MOP_TOPHAT || cv_code == CV_MOP_BLACKHAT) )) |
|
|
cvReleaseImage( &tmp_img ); |
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
|
|
|
cvReleaseImageHeader( &dst_img ); |
|
|
mxDestroyArray(ptr_out); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void JerodeDilate(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *method) { |
|
|
int nx, ny, nBands, nBytes, img_depth, kernel = 3, iterations = 1; |
|
|
double *ptr_d; |
|
|
|
|
|
IplImage *src_img = 0, *dst_img; |
|
|
mxArray *ptr_in; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (!strcmp(method,"erode")) |
|
|
if (n_in == 1) { erodeUsage(); return; } |
|
|
else if (!strcmp(method,"dilate")) |
|
|
if (n_in == 1) { dilateUsage(); return; } |
|
|
|
|
|
if ( !( mxIsUint8(prhs[1]) || mxIsSingle(prhs[1]) || mxIsLogical(prhs[1])) ) { |
|
|
mexPrintf("%s requires image of uint8 or single type!\n", method); |
|
|
mexErrMsgTxt(""); |
|
|
} |
|
|
|
|
|
if (n_out != 1) |
|
|
mexErrMsgTxt("ERODE/DILATE: returns one (and one only) output"); |
|
|
|
|
|
if (n_in == 3) { |
|
|
ptr_d = mxGetPr(prhs[2]); iterations = (int)ptr_d[0]; |
|
|
} |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_in ); |
|
|
dst_img = cvCreateImage(cvSize(nx, ny), img_depth , nBands ); |
|
|
localSetData( Ctrl, dst_img, 2, nx * nBands * nBytes ); |
|
|
|
|
|
if (!strcmp(method,"erode")) |
|
|
cvErode(src_img,dst_img,NULL,iterations); |
|
|
else |
|
|
cvDilate(src_img,dst_img,NULL,iterations); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
cvReleaseImageHeader( &dst_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void Jcolor(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, nBands, nBands_out, nBytes, img_depth, cv_code, out_dims[3]; |
|
|
char *argv; |
|
|
|
|
|
IplImage *src_img = 0, *dst_img; |
|
|
mxArray *ptr_in, *ptr_out; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { colorUsage(); return; } |
|
|
if (n_out > 1) |
|
|
mexErrMsgTxt("COLOR returns only one output argument!"); |
|
|
if (n_in != 3) |
|
|
mexErrMsgTxt("COLOR requires 2 input arguments!"); |
|
|
|
|
|
if(!mxIsChar(prhs[2])) |
|
|
mexErrMsgTxt("COLOR Second argument must be a valid string!"); |
|
|
else { |
|
|
argv = (char *)mxArrayToString(prhs[2]); |
|
|
|
|
|
if (!strcmp(argv,"rgb2lab")) |
|
|
cv_code = CV_BGR2Lab; |
|
|
else if (!strcmp(argv,"lab2rgb")) |
|
|
cv_code = CV_Lab2BGR; |
|
|
|
|
|
else if (!strcmp(argv,"rgb2luv")) |
|
|
cv_code = CV_BGR2Luv; |
|
|
else if (!strcmp(argv,"luv2rgb")) |
|
|
cv_code = CV_Luv2BGR; |
|
|
|
|
|
else if (!strcmp(argv,"rgb2xyz")) |
|
|
cv_code = CV_BGR2XYZ; |
|
|
else if (!strcmp(argv,"xyz2rgb")) |
|
|
cv_code = CV_XYZ2BGR; |
|
|
|
|
|
else if (!strcmp(argv,"rgb2yiq") || !strcmp(argv,"rgb2gray")) |
|
|
cv_code = CV_BGR2GRAY; |
|
|
|
|
|
else if (!strcmp(argv,"rgb2hsv")) |
|
|
cv_code = CV_BGR2HSV; |
|
|
else if (!strcmp(argv,"hsv2rgb")) |
|
|
cv_code = CV_HSV2BGR; |
|
|
|
|
|
else if (!strcmp(argv,"rgb2hls")) |
|
|
cv_code = CV_BGR2HLS; |
|
|
else if (!strcmp(argv,"hls2rgb")) |
|
|
cv_code = CV_HLS2BGR; |
|
|
|
|
|
else if (!strcmp(argv,"rgb2YCrCb")) |
|
|
cv_code = CV_BGR2YCrCb; |
|
|
else if (!strcmp(argv,"YCrCb2rgb")) |
|
|
cv_code = CV_YCrCb2BGR; |
|
|
|
|
|
else { |
|
|
mexPrintf("CVCOLOR ERROR: Unknown conversion type string.\n"); |
|
|
mexPrintf("Valid types: rgb2lab,lab2rgb, rgb2luv,luv2rgb, rgb2xyz,xyz2rgb\n"); |
|
|
mexPrintf(" rgb2yiq,yiq2rgb, rgb2hsv,luv2hsv, rgb2gray,gray2rgb\n"); |
|
|
mexErrMsgTxt(" rgb2hsl,hsl2rgb, rgb2YCrCb,YCrCb2rgb.\n"); |
|
|
} |
|
|
} |
|
|
|
|
|
if ( !(mxIsUint8(prhs[1]) || mxIsUint16(prhs[1]) || mxIsSingle(prhs[1])) ) |
|
|
mexErrMsgTxt("COLOR ERROR: Invalid type. Valid types are: uint8, uint16 or single.\n"); |
|
|
if (n_out != 1) |
|
|
mexErrMsgTxt("COLOR: returns one (and one only) output"); |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
if (nBands == 1) |
|
|
mexErrMsgTxt("COLOR ERROR: input must be a MxNx3 array.\n"); |
|
|
|
|
|
out_dims[0] = ny; out_dims[1] = nx; |
|
|
if (cv_code == CV_RGB2GRAY || cv_code == CV_BGR2GRAY) { |
|
|
nBands_out = 1; |
|
|
out_dims[2] = nBands_out; |
|
|
} |
|
|
else { |
|
|
nBands_out = nBands; |
|
|
out_dims[2] = nBands_out; |
|
|
} |
|
|
|
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
ptr_out = mxCreateNumericArray((nBands_out == 1) ? 2 : 3, |
|
|
out_dims, mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
src_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src_img, 1, nx * nBands * nBytes ); |
|
|
|
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_out ); |
|
|
dst_img = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands_out ); |
|
|
localSetData( Ctrl, dst_img, 2, nx * nBands_out * nBytes ); |
|
|
|
|
|
cvCvtColor(src_img, dst_img, cv_code); |
|
|
|
|
|
cvReleaseImageHeader( &src_img ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), out_dims, mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
|
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
cvReleaseImageHeader( &dst_img ); |
|
|
mxDestroyArray(ptr_out); |
|
|
} |
|
|
|
|
|
|
|
|
void JGetQuadrangleSubPix(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, nBands, nBytes, img_depth; |
|
|
double *ptr_d; |
|
|
|
|
|
IplImage *src, *dst; |
|
|
CvMat *map_matrix; |
|
|
mxArray *ptr_in, *ptr_out; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
ptr_d = mxGetPr(prhs[2]); |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
ptr_out = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
src = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src, 1, nx * nBands * nBytes ); |
|
|
|
|
|
map_matrix = cvCreateMatHeader( 2, 3, CV_64FC1 ); |
|
|
|
|
|
cvSetData( map_matrix, (void *)ptr_d, 3*8 ); |
|
|
|
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_out ); |
|
|
dst = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, dst, 2, nx * nBands * nBytes ); |
|
|
|
|
|
|
|
|
cvWarpAffine( src, dst, map_matrix,CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,cvScalarAll(0) ); |
|
|
|
|
|
cvReleaseImageHeader( &src ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
|
|
|
cvReleaseImageHeader( &dst ); |
|
|
mxDestroyArray(ptr_out); |
|
|
cvReleaseMatHeader( &map_matrix ); |
|
|
|
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void Jfilter(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, nBands, nBytes, img_depth, nFiltRows, nFiltCols; |
|
|
double *ptr_d, *kernel; |
|
|
|
|
|
IplImage *src, *dst; |
|
|
CvMat *filter; |
|
|
mxArray *ptr_in; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { filterUsage(); return; } |
|
|
if (n_in != 3) |
|
|
mexErrMsgTxt("FILTER: requires 2 input arguments!"); |
|
|
ptr_d = mxGetPr(prhs[2]); |
|
|
if ( mxIsDouble(prhs[1]) || mxIsInt8(prhs[1]) || mxIsInt32(prhs[1]) ) |
|
|
mexErrMsgTxt("FILTER: IMG type not supported (supported: uint8, int16, uint16 or single)!"); |
|
|
if ( !mxIsDouble(prhs[2]) ) |
|
|
mexErrMsgTxt("FILTER: second argument must be a double!"); |
|
|
if (n_out != 1) |
|
|
mexErrMsgTxt("FILTER: returns one (and one only) output"); |
|
|
nFiltRows = mxGetM(prhs[2]); |
|
|
nFiltCols = mxGetN(prhs[2]); |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
kernel = (double *)mxCalloc(nFiltCols * nFiltRows, sizeof(double)); |
|
|
interleaveDouble(ptr_d, kernel, nFiltCols, nFiltRows); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
src = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src, 1, nx * nBands * nBytes ); |
|
|
|
|
|
filter = cvCreateMatHeader( nFiltRows, nFiltCols, CV_64FC1 ); |
|
|
cvSetData( filter, (void *)kernel, nFiltCols*8 ); |
|
|
|
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_in ); |
|
|
dst = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, dst, 2, nx * nBands * nBytes ); |
|
|
|
|
|
cvFilter2D( src, dst, filter, cvPoint(-1,-1) ); |
|
|
|
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
|
|
|
cvReleaseImageHeader( &dst ); |
|
|
cvReleaseImageHeader( &src ); |
|
|
cvReleaseMatHeader( &filter ); |
|
|
mxFree((void *)kernel); |
|
|
mxDestroyArray(ptr_in); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void Jsmooth(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, nBands, nBytes, img_depth, par1 = 5, par2 = 0, method = CV_GAUSSIAN; |
|
|
double par3 = 0, par4 = 0; |
|
|
const char *method_s; |
|
|
IplImage *src, *dst; |
|
|
mxArray *ptr_in; |
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { smoothUsage(); return; } |
|
|
|
|
|
if (n_in > 2) { |
|
|
if(!mxIsChar(prhs[2])) |
|
|
mexErrMsgTxt("CVLIB_MEX: Third argument must contain the smoothtype METHOD string!"); |
|
|
else |
|
|
method_s = (char *)mxArrayToString(prhs[2]); |
|
|
|
|
|
if (!strcmp(method_s,"blur")) |
|
|
method = CV_BLUR; |
|
|
else if (!strcmp(method_s,"gaussian")) |
|
|
method = CV_GAUSSIAN; |
|
|
else if (!strcmp(method_s,"median")) |
|
|
method = CV_MEDIAN; |
|
|
else if (!strcmp(method_s,"bilateral")) |
|
|
method = CV_BILATERAL; |
|
|
else |
|
|
mexErrMsgTxt("SMOOTH: Unknown METHOD!"); |
|
|
|
|
|
if (n_in >= 4 && !mxIsEmpty(prhs[3])) |
|
|
par1 = (int)(*mxGetPr(prhs[3])); |
|
|
if (n_in >= 5 && !mxIsEmpty(prhs[4])) |
|
|
par2 = (int)(*mxGetPr(prhs[4])); |
|
|
if (n_in >= 6 && !mxIsEmpty(prhs[5])) |
|
|
par3 = *mxGetPr(prhs[5]); |
|
|
if (n_in == 7 && !mxIsEmpty(prhs[6])) |
|
|
par4 = *mxGetPr(prhs[6]); |
|
|
} |
|
|
|
|
|
if ( !(mxIsSingle(prhs[1]) || mxIsUint8(prhs[1]) || mxIsLogical(prhs[1])) ) |
|
|
mexErrMsgTxt("SMOOTH: IMG type not supported (supported: logical, uint8 or single)!"); |
|
|
|
|
|
if ( !(mxIsUint8(prhs[1]) || mxIsLogical(prhs[1])) && (method == CV_MEDIAN || method == CV_BILATERAL) ) |
|
|
mexErrMsgTxt("SMOOTH: When smoothingtype is 'median' or 'bilateral' IMG type must be logical or uint8!"); |
|
|
|
|
|
if (n_out != 1) |
|
|
mexErrMsgTxt("SMOOTH: returns one (and one only) output"); |
|
|
|
|
|
if ( method == CV_BILATERAL && par1 == 5 && par2 == 0 ) |
|
|
par2 = 50; |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
src = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src, 1, nx * nBands * nBytes ); |
|
|
|
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_in ); |
|
|
dst = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, dst, 2, nx * nBands * nBytes ); |
|
|
|
|
|
cvSmooth( src, dst, method, par1, par2, par3, par4 ); |
|
|
|
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
|
|
|
cvReleaseImageHeader( &dst ); |
|
|
cvReleaseImageHeader( &src ); |
|
|
mxDestroyArray(ptr_in); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void Jegipt(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *op) { |
|
|
int nx, ny, nxOut, nyOut, nBands, nBytes, img_depth, out_dims[3]; |
|
|
|
|
|
IplImage *src, *dst; |
|
|
mxArray *ptr_in, *ptr_out; |
|
|
|
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (!strcmp(op,"pyrU")) |
|
|
if (n_in == 1) { pyrUUsage(); return; } |
|
|
else if (!strcmp(op,"pyrD")) |
|
|
if (n_in == 1) { pyrDUsage(); return; } |
|
|
|
|
|
if ( mxIsInt8(prhs[1]) || mxIsUint32(prhs[1]) || mxIsInt32(prhs[1]) ) |
|
|
mexErrMsgTxt("EGIPT: IMG type not supported (supported: uint8, uint16, int16, single or double)!"); |
|
|
if (n_out != 1) |
|
|
mexErrMsgTxt("EGIPT: returns one (and one only) output"); |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in ( Ctrl, prhs[1], ptr_in, 1 ); |
|
|
src = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src, 1, nx * nBands * nBytes ); |
|
|
|
|
|
if (!strcmp(op,"pyrU")) { |
|
|
nxOut = 2*nx; nyOut = 2*ny; |
|
|
} |
|
|
else { |
|
|
nxOut = (int)(nx/2); nyOut = (int)(ny/2); |
|
|
} |
|
|
|
|
|
|
|
|
out_dims[0] = nyOut; out_dims[1] = nxOut; out_dims[2] = nBands; |
|
|
ptr_out = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
out_dims, mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_out ); |
|
|
dst = cvCreateImageHeader(cvSize(nxOut, nyOut), img_depth, nBands ); |
|
|
localSetData( Ctrl, dst, 2, nxOut * nBands * nBytes ); |
|
|
|
|
|
if (!strcmp(op,"pyrU")) |
|
|
cvPyrUp(src, dst, CV_GAUSSIAN_5x5); |
|
|
else |
|
|
cvPyrDown(src, dst, CV_GAUSSIAN_5x5); |
|
|
|
|
|
cvReleaseImageHeader( &src ); |
|
|
mxDestroyArray(ptr_in); |
|
|
|
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
out_dims, mxGetClassID(prhs[1]), mxREAL); |
|
|
|
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
|
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
cvReleaseImageHeader( &dst ); |
|
|
mxDestroyArray(ptr_out); |
|
|
} |
|
|
|
|
|
|
|
|
void Jarithm(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[], const char *op) { |
|
|
int nx, nx2, ny, ny2, nBands, nBands2, nBytes, img_depth, inplace = FALSE, error = 0; |
|
|
IplImage *src1, *src2, *dst; |
|
|
CvScalar value; |
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { arithmUsage(); return; } |
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
ny2 = mxGetM(prhs[2]); nx2 = getNK(prhs[2],1); nBands2 = getNK(prhs[2],2); |
|
|
if (nx*ny == 1) |
|
|
mexErrMsgTxt("CVLIB_MEX: First argument cannot be a scalar!"); |
|
|
if (ny != ny2 && ny2 != 1) error++; |
|
|
if (nx != nx2 && nx2 != 1) error++; |
|
|
if (error) |
|
|
mexErrMsgTxt("CVLIB_MEX: Matrix dimensions must agree!"); |
|
|
|
|
|
if (nx2*ny2 == 1 && (strcmp(op,"addS") && strcmp(op,"subS")) ) |
|
|
mexErrMsgTxt("CVLIB_MEX: only 'addS' or 'subS' are allowed when second arg is a scalar!"); |
|
|
|
|
|
if (n_out == 0) |
|
|
inplace = TRUE; |
|
|
|
|
|
|
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
src1 = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
cvSetImageData( src1, (void *)mxGetData(prhs[1]), nx * nBytes * nBands ); |
|
|
if (nx2*ny2 != 1) { |
|
|
src2 = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
cvSetImageData( src2, (void *)mxGetData(prhs[2]), nx * nBytes * nBands ); |
|
|
} |
|
|
else |
|
|
value.val[0] = *(double *)mxGetData(prhs[2]); |
|
|
|
|
|
if (!inplace) { |
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
dst = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
cvSetImageData( dst, (void *)mxGetData(plhs[0]), nx * nBytes * nBands ); |
|
|
if (!strcmp(op,"add")) |
|
|
cvAdd( src1, src2, dst, NULL ); |
|
|
else if (!strcmp(op,"addS")) |
|
|
cvAddS( src1, value, dst, NULL ); |
|
|
else if (!strcmp(op,"sub")) |
|
|
cvSub( src1, src2, dst, NULL ); |
|
|
else if (!strcmp(op,"subS")) |
|
|
cvSubS( src1, value, dst, NULL ); |
|
|
else if (!strcmp(op,"mul")) |
|
|
cvMul( src1, src2, dst, 1 ); |
|
|
else if (!strcmp(op,"div")) |
|
|
cvDiv( src1, src2, dst, 1 ); |
|
|
|
|
|
cvReleaseImageHeader( &dst ); |
|
|
} |
|
|
else { |
|
|
if (!strcmp(op,"add")) |
|
|
cvAdd( src1, src2, src1, NULL ); |
|
|
else if (!strcmp(op,"addS")) |
|
|
cvAddS( src1, value, src1, NULL ); |
|
|
else if (!strcmp(op,"sub")) |
|
|
cvSub( src1, src2, src1, NULL ); |
|
|
else if (!strcmp(op,"subS")) |
|
|
cvSubS( src1, value, src1, NULL ); |
|
|
else if (!strcmp(op,"mul")) |
|
|
cvMul( src1, src2, src1, 1 ); |
|
|
else if (!strcmp(op,"div")) |
|
|
cvDiv( src1, src2, src1, 1 ); |
|
|
} |
|
|
|
|
|
cvReleaseImageHeader( &src1 ); |
|
|
if (nx2*ny2 != 1) |
|
|
cvReleaseImageHeader( &src2 ); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void JaddWeighted(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, nx2, ny2, nz2, nBands, nBytes, img_depth, inplace = FALSE; |
|
|
double *ptr_d, alpha, beta, gamma = 0; |
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
IplImage *src1, *src2, *dst; |
|
|
|
|
|
|
|
|
if (n_in == 1) { addWeightedUsage(); return; } |
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
ny2 = mxGetM(prhs[3]); nx2 = getNK(prhs[3],1); nz2 = getNK(prhs[3],2); |
|
|
if (nx != nx2 || ny != ny2 || nBands != nz2) |
|
|
mexErrMsgTxt("ADDWEIGHTED ERROR: Matrix dimensions must agree!"); |
|
|
if (n_in < 5) |
|
|
mexErrMsgTxt("ADDWEIGHTED ERROR: not enough input arguments!"); |
|
|
ptr_d = (double *)mxGetData(prhs[2]); alpha = ptr_d[0]; |
|
|
ptr_d = (double *)mxGetData(prhs[4]); beta = ptr_d[0]; |
|
|
if (n_in == 6) { |
|
|
ptr_d = (double *)mxGetData(prhs[5]); gamma = ptr_d[0]; |
|
|
} |
|
|
if (n_out == 0) |
|
|
inplace = TRUE; |
|
|
|
|
|
|
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
src1 = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
cvSetImageData( src1, (void *)mxGetData(prhs[1]), nx * nBytes * nBands ); |
|
|
src2 = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
cvSetImageData( src2, (void *)mxGetData(prhs[3]), nx * nBytes * nBands ); |
|
|
|
|
|
if (!inplace) { |
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
dst = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
cvSetImageData( dst, (void *)mxGetData(plhs[0]), nx * nBytes * nBands ); |
|
|
cvAddWeighted( src1, alpha, src2, beta, gamma, dst ); |
|
|
cvReleaseImageHeader( &dst ); |
|
|
} |
|
|
else |
|
|
cvAddWeighted( src1, alpha, src2, beta, gamma, src1 ); |
|
|
|
|
|
cvReleaseImageHeader( &src1 ); |
|
|
cvReleaseImageHeader( &src2 ); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void Jinpaint(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, nx2, ny2, nBands, nBytes, img_depth, inplace = FALSE; |
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
mxArray *ptr_in1, *ptr_in2; |
|
|
IplImage *src1, *src2, *dst; |
|
|
|
|
|
|
|
|
if (n_in == 1) { inpaintUsage(); return; } |
|
|
|
|
|
|
|
|
if (!mxIsUint8(prhs[1])) |
|
|
mexErrMsgTxt("INPAINT ERROR: Invalid first input. Data type must be: UInt8.\n"); |
|
|
if ( !(mxIsUint8(prhs[2]) || mxIsLogical(prhs[2])) ) |
|
|
mexErrMsgTxt("INPAINT ERROR: Invalid second input. Data type must be Uint8 or Logical.\n"); |
|
|
|
|
|
if (n_in < 3) |
|
|
mexErrMsgTxt("INPAINT ERROR: not enough input arguments!"); |
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
ny2 = mxGetM(prhs[2]); nx2 = getNK(prhs[2],1); |
|
|
if (nx != nx2 || ny != ny2) |
|
|
mexErrMsgTxt("INPAINT ERROR: Matrix dimensions must agree!"); |
|
|
if (getNK(prhs[2],2) != 1) |
|
|
mexErrMsgTxt("INPAINT ERROR: Second arg must be a mask array, that is with only two dimensions!"); |
|
|
|
|
|
if (n_out == 0) |
|
|
inplace = TRUE; |
|
|
|
|
|
|
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
|
|
|
ptr_in1 = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
ptr_in2 = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[2]), |
|
|
mxGetDimensions(prhs[2]), mxGetClassID(prhs[2]), mxREAL); |
|
|
|
|
|
|
|
|
Set_pt_Ctrl_in( Ctrl, prhs[1], ptr_in1, 1 ); |
|
|
src1 = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
localSetData( Ctrl, src1, 1, nx * nBands * nBytes ); |
|
|
|
|
|
Set_pt_Ctrl_in( Ctrl, prhs[2], ptr_in2, 1 ); |
|
|
src2 = cvCreateImageHeader( cvSize(nx, ny), img_depth, 1 ); |
|
|
localSetData( Ctrl, src2, 1, nx * nBytes ); |
|
|
|
|
|
if (!inplace) { |
|
|
Set_pt_Ctrl_out1 ( Ctrl, ptr_in1 ); |
|
|
dst = cvCreateImage(cvSize(nx, ny), img_depth , nBands ); |
|
|
localSetData( Ctrl, dst, 2, nx * nBands * nBytes ); |
|
|
cvInpaint( src1, src2, dst, 3, CV_INPAINT_TELEA); |
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
Set_pt_Ctrl_out2 ( Ctrl, plhs[0], 1 ); |
|
|
} |
|
|
else { |
|
|
cvInpaint( src1, src2, src1, 3, CV_INPAINT_TELEA); |
|
|
} |
|
|
|
|
|
cvReleaseImageHeader( &src1 ); |
|
|
cvReleaseImageHeader( &src2 ); |
|
|
mxDestroyArray(ptr_in1); |
|
|
mxDestroyArray(ptr_in2); |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void Jflip(int n_out, mxArray *plhs[], int n_in, const mxArray *prhs[]) { |
|
|
int nx, ny, nBands, nBytes, img_depth, inplace = FALSE, flip_mode = 1; |
|
|
char *argv; |
|
|
IplImage *src, *dst; |
|
|
struct CV_CTRL *Ctrl; |
|
|
void *New_Cv_Ctrl (), Free_Cv_Ctrl (struct CV_CTRL *C); |
|
|
|
|
|
|
|
|
if (n_in == 1) { flipUsage(); return; } |
|
|
if(!mxIsChar(prhs[2])) |
|
|
mexErrMsgTxt("FLIP Second argument must be a valid string!"); |
|
|
else { |
|
|
argv = (char *)mxArrayToString(prhs[2]); |
|
|
if (!strcmp(argv,"ud") || !strcmp(argv,"UD")) |
|
|
flip_mode = 1; |
|
|
else if (!strcmp(argv,"lr") || !strcmp(argv,"LR")) |
|
|
flip_mode = 0; |
|
|
else if (!strcmp(argv,"both")) |
|
|
flip_mode = -1; |
|
|
else |
|
|
mexErrMsgTxt("FLIP ERROR: unknown flipping type string.\n"); |
|
|
} |
|
|
if (n_out == 0) |
|
|
inplace = TRUE; |
|
|
|
|
|
|
|
|
ny = mxGetM(prhs[1]); nx = getNK(prhs[1],1); nBands = getNK(prhs[1],2); |
|
|
|
|
|
|
|
|
Ctrl = (struct CV_CTRL *) New_Cv_Ctrl (); |
|
|
getDataType(Ctrl, prhs, &nBytes, &img_depth); |
|
|
|
|
|
src = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
cvSetImageData( src, (void *)mxGetData(prhs[1]), nx * nBytes * nBands ); |
|
|
|
|
|
if (!inplace) { |
|
|
plhs[0] = mxCreateNumericArray(mxGetNumberOfDimensions(prhs[1]), |
|
|
mxGetDimensions(prhs[1]), mxGetClassID(prhs[1]), mxREAL); |
|
|
dst = cvCreateImageHeader( cvSize(nx, ny), img_depth, nBands ); |
|
|
cvSetImageData( dst, (void *)mxGetData(plhs[0]), nx * nBytes * nBands ); |
|
|
cvFlip( src, dst, flip_mode ); |
|
|
cvReleaseImageHeader( &src ); |
|
|
} |
|
|
else { |
|
|
cvFlip( src, NULL, flip_mode ); |
|
|
} |
|
|
Free_Cv_Ctrl (Ctrl); |
|
|
} |
|
|
|
|
|
|
|
|
void localSetData(struct CV_CTRL *Ctrl, IplImage* img, int dir, int step) { |
|
|
if (Ctrl->UInt8.active == TRUE) |
|
|
if (dir == 1) |
|
|
cvSetImageData( img, (void *)Ctrl->UInt8.tmp_img_in, step ); |
|
|
else |
|
|
cvSetImageData( img, (void *)Ctrl->UInt8.tmp_img_out, step ); |
|
|
else if (Ctrl->Int8.active == TRUE) |
|
|
if (dir == 1) |
|
|
cvSetImageData( img, (void *)Ctrl->Int8.tmp_img_in, step ); |
|
|
else |
|
|
cvSetImageData( img, (void *)Ctrl->Int8.tmp_img_out, step ); |
|
|
else if (Ctrl->UInt16.active == TRUE) |
|
|
if (dir == 1) |
|
|
cvSetImageData( img, (void *)Ctrl->UInt16.tmp_img_in, step ); |
|
|
else |
|
|
cvSetImageData( img, (void *)Ctrl->UInt16.tmp_img_out, step ); |
|
|
else if (Ctrl->Int16.active == TRUE) |
|
|
if (dir == 1) |
|
|
cvSetImageData( img, (void *)Ctrl->Int16.tmp_img_in, step ); |
|
|
else |
|
|
cvSetImageData( img, (void *)Ctrl->Int16.tmp_img_out, step ); |
|
|
else if (Ctrl->Int32.active == TRUE) |
|
|
if (dir == 1) |
|
|
cvSetImageData( img, (void *)Ctrl->Int32.tmp_img_in, step ); |
|
|
else |
|
|
cvSetImageData( img, (void *)Ctrl->Int32.tmp_img_out, step ); |
|
|
else if (Ctrl->Float.active == TRUE) |
|
|
if (dir == 1) |
|
|
cvSetImageData( img, (void *)Ctrl->Float.tmp_img_in, step ); |
|
|
else |
|
|
cvSetImageData( img, (void *)Ctrl->Float.tmp_img_out, step ); |
|
|
else if (Ctrl->Double.active == TRUE) |
|
|
if (dir == 1) |
|
|
cvSetImageData( img, (void *)Ctrl->Double.tmp_img_in, step ); |
|
|
else |
|
|
cvSetImageData( img, (void *)Ctrl->Double.tmp_img_out, step ); |
|
|
} |
|
|
|
|
|
|
|
|
void interleave(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir) { |
|
|
if (Ctrl->UInt8.active == TRUE) |
|
|
interleaveUI8(Ctrl, nx, ny, nBands, dir); |
|
|
else if (Ctrl->Int8.active == TRUE) |
|
|
interleaveI8(Ctrl, nx, ny, nBands, dir); |
|
|
else if (Ctrl->UInt16.active == TRUE) |
|
|
interleaveUI16(Ctrl, nx, ny, nBands, dir); |
|
|
else if (Ctrl->Int16.active == TRUE) |
|
|
interleaveI16(Ctrl, nx, ny, nBands, dir); |
|
|
else if (Ctrl->Int32.active == TRUE) |
|
|
interleaveI32(Ctrl, nx, ny, nBands, dir); |
|
|
else if (Ctrl->Float.active == TRUE) |
|
|
interleaveF32(Ctrl, nx, ny, nBands, dir); |
|
|
else if (Ctrl->Double.active == TRUE) |
|
|
interleaveF64(Ctrl, nx, ny, nBands, dir); |
|
|
} |
|
|
|
|
|
|
|
|
void interleaveDouble(double in[], double out[], int nx, int ny) { |
|
|
|
|
|
int m, n, c = 0; |
|
|
|
|
|
for (m = 0; m < ny; m++) |
|
|
for (n = 0; n < nx; n++) |
|
|
out[c++] = in[m + n*ny]; |
|
|
} |
|
|
|
|
|
|
|
|
void interleaveBlind(unsigned char in[], unsigned char out[], int nx, int ny, int nBands, int dir) { |
|
|
|
|
|
int n_xy, m, n, k, i, c = 0; |
|
|
|
|
|
if (dir == 1) { |
|
|
n_xy = nx*ny; |
|
|
for (m = 0; m < ny; m++) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
out[c++] = in[m + n*ny + i*n_xy]; |
|
|
} |
|
|
else { |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (m = 0; m < ny; m++) |
|
|
out[c++] = in[nBands * (n + m*nx) + i]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void interleaveUI8(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir) { |
|
|
int n_xy, m, n, k, i, c = 0; |
|
|
|
|
|
if (dir == 1) { |
|
|
n_xy = nx*ny; |
|
|
for (m = 0; m < ny; m++) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
Ctrl->UInt8.tmp_img_in[c++] = Ctrl->UInt8.img_in[m + n*ny + i*n_xy]; |
|
|
} |
|
|
else { |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (m = 0; m < ny; m++) |
|
|
Ctrl->UInt8.img_out[c++] = Ctrl->UInt8.tmp_img_out[nBands * (n + m*nx) + i]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void interleaveI8(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir) { |
|
|
int n_xy, m, n, k, i, c = 0; |
|
|
|
|
|
if (dir == 1) { |
|
|
n_xy = nx*ny; |
|
|
for (m = 0; m < ny; m++) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
Ctrl->Int8.tmp_img_in[c++] = Ctrl->Int8.img_in[m + n*ny + i*n_xy]; |
|
|
} |
|
|
else { |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (m = 0; m < ny; m++) |
|
|
Ctrl->Int8.img_out[c++] = Ctrl->Int8.tmp_img_out[nBands * (n + m*nx) + i]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void interleaveUI16(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir) { |
|
|
int n_xy, m, n, k, i, c = 0; |
|
|
|
|
|
if (dir == 1) { |
|
|
n_xy = nx*ny; |
|
|
for (m = 0; m < ny; m++) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
Ctrl->UInt16.tmp_img_in[c++] = Ctrl->UInt16.img_in[(m + n*ny + i*n_xy)]; |
|
|
} |
|
|
else { |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (m = 0; m < ny; m++) |
|
|
Ctrl->UInt16.img_out[c++] = Ctrl->UInt16.tmp_img_out[nBands * (n + m*nx) + i]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void interleaveI16(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir) { |
|
|
int n_xy, m, n, k, i, c = 0; |
|
|
|
|
|
if (dir == 1) { |
|
|
n_xy = nx*ny; |
|
|
for (m = 0; m < ny; m++) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
Ctrl->Int16.tmp_img_in[c++] = Ctrl->Int16.img_in[(m + n*ny + i*n_xy)]; |
|
|
} |
|
|
else { |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (m = 0; m < ny; m++) |
|
|
Ctrl->Int16.img_out[c++] = Ctrl->Int16.tmp_img_out[nBands * (n + m*nx) + i]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void interleaveI32(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir) { |
|
|
int n_xy, m, n, k, i, c = 0; |
|
|
|
|
|
if (dir == 1) { |
|
|
n_xy = nx*ny; |
|
|
for (m = 0; m < ny; m++) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
Ctrl->Int32.tmp_img_in[c++] = Ctrl->Int32.img_in[(m + n*ny + i*n_xy)]; |
|
|
} |
|
|
else { |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (m = 0; m < ny; m++) |
|
|
Ctrl->Int32.img_out[c++] = Ctrl->Int32.tmp_img_out[nBands * (n + m*nx) + i]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void interleaveF32(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir) { |
|
|
int n_xy, m, n, k, i, c = 0; |
|
|
|
|
|
if (dir == 1) { |
|
|
n_xy = nx*ny; |
|
|
for (m = 0; m < ny; m++) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
Ctrl->Float.tmp_img_in[c++] = Ctrl->Float.img_in[(m + n*ny + i*n_xy)]; |
|
|
} |
|
|
else { |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (m = 0; m < ny; m++) |
|
|
Ctrl->Float.img_out[c++] = Ctrl->Float.tmp_img_out[nBands * (n + m*nx) + i]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void interleaveF64(struct CV_CTRL *Ctrl, int nx, int ny, int nBands, int dir) { |
|
|
int n_xy, m, n, k, i, c = 0; |
|
|
|
|
|
if (dir == 1) { |
|
|
n_xy = nx*ny; |
|
|
for (m = 0; m < ny; m++) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
Ctrl->Double.tmp_img_in[c++] = Ctrl->Double.img_in[(m + n*ny + i*n_xy)]; |
|
|
} |
|
|
else { |
|
|
for (k = 0, i = nBands-1; k < nBands; k++, i--) |
|
|
for (n = 0; n < nx; n++) |
|
|
for (m = 0; m < ny; m++) |
|
|
Ctrl->Double.img_out[c++] = Ctrl->Double.tmp_img_out[nBands * (n + m*nx) + i]; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void *New_Cv_Ctrl () { |
|
|
struct CV_CTRL *C; |
|
|
|
|
|
C = (struct CV_CTRL *) mxCalloc (1, sizeof (struct CV_CTRL)); |
|
|
return ((void *)C); |
|
|
} |
|
|
|
|
|
|
|
|
void Free_Cv_Ctrl (struct CV_CTRL *C) { |
|
|
mxFree ((void *)C); |
|
|
} |
|
|
|
|
|
|
|
|
void Set_pt_Ctrl_in (struct CV_CTRL *Ctrl, const mxArray *pi, mxArray *pit, int interl) { |
|
|
|
|
|
if (Ctrl->UInt8.active == TRUE) { |
|
|
Ctrl->UInt8.img_in = (unsigned char *)mxGetData(pi); |
|
|
Ctrl->UInt8.tmp_img_in = (unsigned char *)mxGetData(pit); |
|
|
} |
|
|
else if (Ctrl->Int8.active == TRUE) { |
|
|
Ctrl->Int8.img_in = (char *)mxGetData(pi); |
|
|
Ctrl->Int8.tmp_img_in = (char *)mxGetData(pit); |
|
|
} |
|
|
else if (Ctrl->UInt16.active == TRUE) { |
|
|
Ctrl->UInt16.img_in = (unsigned short int *)mxGetData(pi); |
|
|
Ctrl->UInt16.tmp_img_in = (unsigned short int *)mxGetData(pit); |
|
|
} |
|
|
else if (Ctrl->Int16.active == TRUE) { |
|
|
Ctrl->Int16.img_in = (short int *)mxGetData(pi); |
|
|
Ctrl->Int16.tmp_img_in = (short int *)mxGetData(pit); |
|
|
} |
|
|
else if (Ctrl->Int32.active == TRUE) { |
|
|
Ctrl->Int32.img_in = (int *)mxGetData(pi); |
|
|
Ctrl->Int32.tmp_img_in = (int *)mxGetData(pit); |
|
|
} |
|
|
else if (Ctrl->Float.active == TRUE) { |
|
|
Ctrl->Float.img_in = (float *)mxGetData(pi); |
|
|
Ctrl->Float.tmp_img_in = (float *)mxGetData(pit); |
|
|
} |
|
|
else if (Ctrl->Double.active == TRUE) { |
|
|
Ctrl->Double.img_in = (double *)mxGetData(pi); |
|
|
Ctrl->Double.tmp_img_in = (double *)mxGetData(pit); |
|
|
} |
|
|
|
|
|
if (interl) |
|
|
interleave (Ctrl, getNK(pi,1), mxGetM(pi), getNK(pi,2), 1); |
|
|
} |
|
|
|
|
|
|
|
|
void Set_pt_Ctrl_out1 ( struct CV_CTRL *Ctrl, mxArray *pi ) { |
|
|
|
|
|
if (Ctrl->UInt8.active == TRUE) { |
|
|
Ctrl->UInt8.tmp_img_out = (unsigned char *)mxGetData(pi); |
|
|
} |
|
|
else if (Ctrl->Int8.active == TRUE) { |
|
|
Ctrl->Int8.tmp_img_out = (char *)mxGetData(pi); |
|
|
} |
|
|
else if (Ctrl->UInt16.active == TRUE) { |
|
|
Ctrl->UInt16.tmp_img_out = (unsigned short int *)mxGetData(pi); |
|
|
} |
|
|
else if (Ctrl->Int16.active == TRUE) { |
|
|
Ctrl->Int16.tmp_img_out = (short int *)mxGetData(pi); |
|
|
} |
|
|
else if (Ctrl->Int32.active == TRUE) { |
|
|
Ctrl->Int32.tmp_img_out = (int *)mxGetData(pi); |
|
|
} |
|
|
else if (Ctrl->Float.active == TRUE) { |
|
|
Ctrl->Float.tmp_img_out = (float *)mxGetData(pi); |
|
|
} |
|
|
else if (Ctrl->Double.active == TRUE) { |
|
|
Ctrl->Double.tmp_img_out = (double *)mxGetData(pi); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
void Set_pt_Ctrl_out2 (struct CV_CTRL *Ctrl, mxArray *po, int interl) { |
|
|
|
|
|
if (Ctrl->UInt8.active == TRUE) { |
|
|
Ctrl->UInt8.img_out = (unsigned char *)mxGetData(po); |
|
|
} |
|
|
else if (Ctrl->Int8.active == TRUE) { |
|
|
Ctrl->Int8.img_out = (char *)mxGetData(po); |
|
|
} |
|
|
else if (Ctrl->UInt16.active == TRUE) { |
|
|
Ctrl->UInt16.img_out = (unsigned short int *)mxGetData(po); |
|
|
} |
|
|
else if (Ctrl->Int16.active == TRUE) { |
|
|
Ctrl->Int16.img_out = (short int *)mxGetData(po); |
|
|
} |
|
|
else if (Ctrl->Int32.active == TRUE) { |
|
|
Ctrl->Int32.img_out = (int *)mxGetData(po); |
|
|
} |
|
|
else if (Ctrl->Float.active == TRUE) { |
|
|
Ctrl->Float.img_out = (float *)mxGetData(po); |
|
|
} |
|
|
else if (Ctrl->Double.active == TRUE) { |
|
|
Ctrl->Double.img_out = (double *)mxGetData(po); |
|
|
} |
|
|
|
|
|
if (interl) |
|
|
interleave (Ctrl, getNK(po,1), mxGetM(po), getNK(po,2), -1); |
|
|
} |
|
|
|
|
|
|
|
|
int getNK(const mxArray *p, int which) { |
|
|
|
|
|
int nx, nBands, nDims; |
|
|
const int *dim_array; |
|
|
|
|
|
nDims = mxGetNumberOfDimensions(p); |
|
|
dim_array = mxGetDimensions(p); |
|
|
nx = dim_array[1]; |
|
|
nBands = dim_array[2]; |
|
|
if (nDims == 2) |
|
|
nBands = 1; |
|
|
|
|
|
if (which == 1) |
|
|
return(nx); |
|
|
else if (which == 2) |
|
|
return(nBands); |
|
|
else |
|
|
mexErrMsgTxt("getNK: Bad dimension number!"); |
|
|
} |
|
|
|
|
|
|
|
|
void getDataType(struct CV_CTRL *Ctrl, const mxArray *prhs[], int *nBytes, int *img_depth) { |
|
|
|
|
|
int error = 0; |
|
|
|
|
|
if (mxIsComplex(prhs[1]) || mxIsSparse(prhs[1])) |
|
|
mexErrMsgTxt("Input image must be a real matrix"); |
|
|
|
|
|
if (mxIsLogical(prhs[1])) { |
|
|
*img_depth = IPL_DEPTH_8U; |
|
|
*nBytes = 1; |
|
|
Ctrl->UInt8.active = TRUE; |
|
|
} |
|
|
else if (mxIsUint8(prhs[1])) { |
|
|
*img_depth = IPL_DEPTH_8U; |
|
|
*nBytes = 1; |
|
|
Ctrl->UInt8.active = TRUE; |
|
|
} |
|
|
else if (mxIsInt8(prhs[1])) { |
|
|
*img_depth = IPL_DEPTH_8S; |
|
|
*nBytes = 1; |
|
|
Ctrl->Int8.active = TRUE; |
|
|
error++; |
|
|
} |
|
|
else if (mxIsUint16(prhs[1])) { |
|
|
*img_depth = IPL_DEPTH_16U; |
|
|
*nBytes = 2; |
|
|
Ctrl->UInt16.active = TRUE; |
|
|
} |
|
|
else if (mxIsInt16(prhs[1])) { |
|
|
*img_depth = IPL_DEPTH_16S; |
|
|
*nBytes = 2; |
|
|
Ctrl->Int16.active = TRUE; |
|
|
error++; |
|
|
} |
|
|
else if (mxIsInt32(prhs[1])) { |
|
|
*img_depth = IPL_DEPTH_32S; |
|
|
*nBytes = 4; |
|
|
Ctrl->Int32.active = TRUE; |
|
|
error++; |
|
|
} |
|
|
else if (mxIsSingle(prhs[1])) { |
|
|
*img_depth = IPL_DEPTH_32F; |
|
|
*nBytes = 4; |
|
|
Ctrl->Float.active = TRUE; |
|
|
} |
|
|
else if (mxIsDouble(prhs[1])) { |
|
|
*img_depth = IPL_DEPTH_64F; |
|
|
*nBytes = 8; |
|
|
Ctrl->Double.active = TRUE; |
|
|
error++; |
|
|
} |
|
|
else { |
|
|
mexPrintf("CVLIB_MEX ERROR: Invalid input data type.\n"); |
|
|
mexErrMsgTxt("Valid types are: double, single, Int32, UInt16, Int16, and Uint8.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
void cvResizeUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('resize',A,M,METHOD);\n"); |
|
|
mexPrintf(" returns an image that is M times the size of A.\n"); |
|
|
mexPrintf(" If M is between 0 and 1.0, B is smaller than A. If\n"); |
|
|
mexPrintf(" M is greater than 1.0, B is larger than A. If METHOD is\n"); |
|
|
mexPrintf(" omitted, the bilinear interpolation is used.\n\n"); |
|
|
|
|
|
mexPrintf("B = cvlib_mex('resize',A,[MROWS MCOLS],METHOD) returns an image of size\n"); |
|
|
mexPrintf(" MROWS-by-MCOLS. The available METHODS are:\n"); |
|
|
mexPrintf(" 'bilinear' (default) bilinear interpolation\n"); |
|
|
mexPrintf(" 'bicubic' bicubic interpolation\n"); |
|
|
mexPrintf(" 'nearest' nearest neighbor interpolation\n"); |
|
|
mexPrintf(" 'area' resampling using pixel area relation. It is preferred method\n"); |
|
|
mexPrintf(" for image decimation that gives moire-free results.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: The finest example of OpenCV data type support mess:\n"); |
|
|
mexPrintf(" If interpolation METHOD is 'nearest' all data types are supported:\n"); |
|
|
mexPrintf(" Otherwise: logical, uint8, uint16 and single!\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and 1 copy of B.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void floodFillUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('floodfill',IMG,PARAMS_STRUCT);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image:\n"); |
|
|
mexPrintf(" PARAMS_STRUCT is a structure with the following fields (only Point is mandatory):\n"); |
|
|
mexPrintf(" Point -> a 1x2 vector with the X,Y coordinates (in the pixel\n"); |
|
|
mexPrintf(" reference frame) of the selected image point\n"); |
|
|
mexPrintf(" Tolerance -> a scalar in the [0 255] interval [Default is 20]\n"); |
|
|
mexPrintf(" Connect -> a scalar with the connectivity, either 4 or 8 [Default is 4]\n"); |
|
|
mexPrintf(" FillColor -> a 1x3 vector with the fill color [default picks a random color]\n\n"); |
|
|
mexPrintf(" Alternatively you may also call cvfill_mex in this way:\n"); |
|
|
mexPrintf(" B = cvfill_mex('floodfill',IMG,POINT);\n"); |
|
|
mexPrintf(" where POINT is a 1x2 vector with the X,Y coordinates as described above\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: logical or uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void lineUsage() { |
|
|
mexPrintf("Usage: cvlib_mex('line',IMG,PT1,PT2,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image:\n"); |
|
|
mexPrintf(" draws, inplace, the line segment between PT1 and PT2 points in the image.\n"); |
|
|
mexPrintf(" IM2 = cvlib_mex('line',IMG,PT1,PT2,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" Returns the drawing in the the new array IM2.\n\n"); |
|
|
mexPrintf(" Terms inside brakets are optional and can be empty,\n"); |
|
|
mexPrintf(" e.g (...,[],[],LINE_TYPE) or (...,[],5) are allowed.\n"); |
|
|
mexPrintf(" PT1 & PT2 -> Start and end points of the line segment. Note PT is a 1x2 vector e.g [x y]\n"); |
|
|
mexPrintf(" COLOR -> Line color. Can be a 1x3 vector, e.g. the default [255 255 255], or a scalar (gray).\n"); |
|
|
mexPrintf(" THICK -> Line thickness (default 1)\n"); |
|
|
mexPrintf(" LINE_TYPE -> Type of line. 8 - 8-connected line (default), 4 - 4-connected, 16 - antialiased.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void rectUsage() { |
|
|
mexPrintf("Usage: cvlib_mex('rectangle',IMG,PT1,PT2,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image:\n"); |
|
|
mexPrintf(" draws, inplace, a rectangle between the oposit corners PT1 and PT2 in the image.\n"); |
|
|
mexPrintf(" IM2 = cvlib_mex('rectangle',IMG,PT1,PT2,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" Returns the drawing in the the new array IM2.\n\n"); |
|
|
mexPrintf(" Terms inside brakets are optional and can be empty,\n"); |
|
|
mexPrintf(" e.g (...,[],[],LINE_TYPE) or (...,[],5) are allowed.\n"); |
|
|
mexPrintf(" PT1 & PT2 -> Oposit rectangle vertices. Note PT is a 1x2 vector e.g [x y]\n"); |
|
|
mexPrintf(" COLOR -> Line color. Can be a 1x3 vector, e.g. the default [255 255 255], or a scalar (gray).\n"); |
|
|
mexPrintf(" THICK -> Line thickness (default 1). If negative a filled rectangle is drawn.\n"); |
|
|
mexPrintf(" LINE_TYPE -> Type of line. 8 - 8-connected line (default), 4 - 4-connected, 16 - antialiased.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
void circUsage() { |
|
|
mexPrintf("Usage: cvlib_mex('circle',IMG,CENTER,RADIUS,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image:\n"); |
|
|
mexPrintf(" draws, inplace, a simple or filled circle with given center and radius.\n"); |
|
|
mexPrintf(" IM2 = cvlib_mex('circle',IMG,CENTER,RADIUS,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" Returns the drawing in the the new array IM2.\n\n"); |
|
|
mexPrintf(" Terms inside brakets are optional and can be empty,\n"); |
|
|
mexPrintf(" e.g (...,[],[],LINE_TYPE) or (...,[],5) are allowed.\n"); |
|
|
mexPrintf(" CENTER & RADIUS -> Note, they are both 1x2 vectors e.g [x y]\n"); |
|
|
mexPrintf(" COLOR -> Line color. Can be a 1x3 vector, e.g. the default [255 255 255], or a scalar (gray).\n"); |
|
|
mexPrintf(" THICK -> Line thickness (default 1). If negative a filled circle is drawn.\n"); |
|
|
mexPrintf(" LINE_TYPE -> Type of line. 8 - 8-connected line (default), 4 - 4-connected, 16 - antialiased.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void eBoxUsage() { |
|
|
mexPrintf("Usage: cvlib_mex('eBox',IMG,BOX,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image:\n"); |
|
|
mexPrintf(" draws, inplace, draws a simple or thick ellipse outline, or fills an ellipse.\n"); |
|
|
mexPrintf(" BOX -> Structure with the following fields;\n"); |
|
|
mexPrintf(" 'center' -> a 2 element vector with the ellipse center coords (decimal pixeis);\n"); |
|
|
mexPrintf(" 'size' -> a 2 element vector with the ellipse WIDTH and HEIGHT (decimal pixeis);\n"); |
|
|
mexPrintf(" 'angle' -> the angle between the horizontal axis and the WIDTH (degrees);\n"); |
|
|
mexPrintf(" If this field is not present, angle defaults to zero.\n"); |
|
|
mexPrintf(" IM2 = cvlib_mex('eBox',IMG,BOX,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" Returns the drawing in the the new array IM2.\n\n"); |
|
|
mexPrintf(" Terms inside brakets are optional and can be empty,\n"); |
|
|
mexPrintf(" e.g (...,[],[],LINE_TYPE) or (...,[],5) are allowed.\n"); |
|
|
mexPrintf(" COLOR -> Line color. Can be a 1x3 vector, e.g. the default [255 255 255], or a scalar (gray).\n"); |
|
|
mexPrintf(" THICK -> Line thickness (default 1). If negative a filled ellipse is drawn.\n"); |
|
|
mexPrintf(" LINE_TYPE -> Type of line. 8 - 8-connected line (default), 4 - 4-connected, 16 - antialiased.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void plineUsage() { |
|
|
mexPrintf("Usage: cvlib_mex('polyline',IMG,PT,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image:\n"); |
|
|
mexPrintf(" draws, inplace, the polyline whose vertex are contained in the Mx2 or 2xN PT array.\n"); |
|
|
mexPrintf(" If PT is a cell vector with N elements, draws N polylines in the image.\n"); |
|
|
mexPrintf(" Each cell element must contain a Mx2 OR 2xN array with the x,y pixel coords\n"); |
|
|
mexPrintf(" of the polyline to be ploted.\n"); |
|
|
mexPrintf(" IM2 = cvlib_mex('polyline',IMG,PT,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" Returns the drawing in the the new array IM2.\n\n"); |
|
|
mexPrintf(" Terms inside brakets are optional and can be empty,\n"); |
|
|
mexPrintf(" e.g (...,[],[],LINE_TYPE) or (...,[],5) are allowed.\n"); |
|
|
mexPrintf(" COLOR -> Line color. Can be a 1x3 vector, e.g. the default [255 255 255], or a scalar (gray).\n"); |
|
|
mexPrintf(" THICK -> Line thickness (default 1)\n"); |
|
|
mexPrintf(" LINE_TYPE -> Type of line. 8 - 8-connected line (default), 4 - 4-connected, 16 - antialiased.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void fillPlineUsage() { |
|
|
mexPrintf("Usage: cvlib_mex('fillpoly',IMG,PT,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image:\n"); |
|
|
mexPrintf(" fills an area bounded by several polygonal contours inplace.\n"); |
|
|
mexPrintf(" The polyligonal contour vertex are contained in the Mx2 or 2xN PT array.\n"); |
|
|
mexPrintf(" If PT is a cell vector with N elements, fills N polygons in the image.\n"); |
|
|
mexPrintf(" Each cell element must contain a Mx2 OR 2xN array with the x,y pixel coords\n"); |
|
|
mexPrintf(" of the polygon to be filled.\n"); |
|
|
mexPrintf(" IM2 = cvlib_mex('polyline',IMG,PT,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" Returns the drawing in the the new array IM2.\n\n"); |
|
|
mexPrintf(" Terms inside brakets are optional and can be empty,\n"); |
|
|
mexPrintf(" e.g (...,[],[],LINE_TYPE) or (...,[],5) are allowed.\n"); |
|
|
mexPrintf(" COLOR -> Line color. Can be a 1x3 vector, e.g. the default [255 255 255], or a scalar (gray).\n"); |
|
|
mexPrintf(" THICK -> Line thickness (default 1)\n"); |
|
|
mexPrintf(" LINE_TYPE -> Type of line. 8 - 8-connected line (default), 4 - 4-connected, 16 - antialiased.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void fillConvUsage() { |
|
|
mexPrintf("Usage: cvlib_mex('fillconvex',IMG,PT,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image:\n"); |
|
|
mexPrintf(" fills an area bounded by a convex polygonal interior inplace.\n"); |
|
|
mexPrintf(" The polyligonal contour vertex are contained in the Mx2 or 2xN PT array.\n"); |
|
|
mexPrintf(" IM2 = cvlib_mex('polyline',IMG,PT,[COLOR,THICK,LINE_TYPE]);\n"); |
|
|
mexPrintf(" Returns the drawing in the the new array IM2.\n\n"); |
|
|
mexPrintf(" Terms inside brakets are optional and can be empty,\n"); |
|
|
mexPrintf(" e.g (...,[],[],LINE_TYPE) or (...,[],5) are allowed.\n"); |
|
|
mexPrintf(" COLOR -> Line color. Can be a 1x3 vector, e.g. the default [255 255 255], or a scalar (gray).\n"); |
|
|
mexPrintf(" THICK -> Line thickness (default 1)\n"); |
|
|
mexPrintf(" LINE_TYPE -> Type of line. 8 - 8-connected line (default), 4 - 4-connected, 16 - antialiased.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void goodFeaturesUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('goodfeatures',IMG,[,M,QUALITY,DIST]);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 or a MxN intensity image:\n"); |
|
|
mexPrintf(" returns strong corners on image.\n"); |
|
|
mexPrintf(" Terms inside brakets are optional and can be empty,\n"); |
|
|
mexPrintf(" e.g (...,[],[],DIST) is allowed.\n"); |
|
|
mexPrintf(" M - number of maximum output corners [default is all up to 10000]\n"); |
|
|
mexPrintf(" QUALITY - only those corners are selected, which minimal eigen value is\n"); |
|
|
mexPrintf(" non-less than maximum of minimal eigen values on the image,\n"); |
|
|
mexPrintf(" multiplied by quality_level. For example, quality_level = 0.1\n"); |
|
|
mexPrintf(" means that selected corners must be at least 1/10 as good as\n"); |
|
|
mexPrintf(" the best corner. [Default is 0.1]\n"); |
|
|
mexPrintf(" DIST - The selected corners(after thresholding using quality_level)\n"); |
|
|
mexPrintf(" are rerified such that pair-wise distance between them is\n"); |
|
|
mexPrintf(" non-less than min_distance [Default is 10]\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 2 arrays (single) with size MxN.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void houghLines2Usage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('houghlines2',IMG);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 or MxN intensity image OR a MxN logical (mask):\n"); |
|
|
mexPrintf(" B is a P-by-1 cell array where P is the number of detected lines.\n"); |
|
|
mexPrintf(" Each cell in the cell array contains a 2x2 matrix. Each row in the\n"); |
|
|
mexPrintf(" matrix contains the row and column pixel coordinates of the line.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: logical or uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and, if IMG is not of type logical, a MxN.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void houghCirclesUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('houghcircles',IMG [,DP,MIN_DIST,PAR1,PAR2,R0,R1]);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 or MxN intensity image.\n"); |
|
|
mexPrintf(" B is a P-by-3 matrix where P is the number of detected circles.\n"); |
|
|
mexPrintf(" and each row of B contains (x,y,radius)\n"); |
|
|
mexPrintf(" With the options below you may provide empties ([]) to use the default value.\n"); |
|
|
mexPrintf(" DP -> Resolution of the accumulator used to detect centers of the circles. For example\n"); |
|
|
mexPrintf(" if it is 1, the accumulator will have the same resolution as the input image,\n"); |
|
|
mexPrintf(" if it is 2 - accumulator will have twice smaller width and height, etc. [Default = 1]\n"); |
|
|
mexPrintf(" MIN_DIST -> Minimum distance between centers of the detected circles. If the parameter\n"); |
|
|
mexPrintf(" is too small, multiple neighbor circles may be falsely detected in addition\n"); |
|
|
mexPrintf(" to a true one. If it is too large, some circles may be missed [Default = 20]\n"); |
|
|
mexPrintf(" PAR1 -> higher threshold of the two passed to Canny edge detector [Default = 50]\n"); |
|
|
mexPrintf(" PAR2 -> accumulator threshold at the center detection stage. The smaller it is,\n"); |
|
|
mexPrintf(" the more false circles may be detected. Circles, corresponding to the\n"); |
|
|
mexPrintf(" larger accumulator values, will be returned first. [Default = 60]\n\n"); |
|
|
mexPrintf(" R0 -> Minimal radius of the circles to search for (pixels) [Default = 5]\n"); |
|
|
mexPrintf(" R1 -> Maximal radius of the circles to search for. By default the maximal radius\n"); |
|
|
mexPrintf(" is set to max(image_width, image_height). [Default = 0]\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void findContoursUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('contours',IMG);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 or MxN intensity image OR a MxN logical (mask):\n"); |
|
|
mexPrintf(" B is a P-by-1 cell array where P is the number of detected lines.\n"); |
|
|
mexPrintf(" Each cell in the cell array contains a Qx2 matrix. Each row in the\n"); |
|
|
mexPrintf(" matrix contains the row and column pixel coordinates of the line.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: logical or uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and, if IMG is not of type logical, a MxN.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void cannyUsage() { |
|
|
mexPrintf("Usage: C = cvlib_mex('canny',IMG);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image:\n"); |
|
|
mexPrintf(" C = cvlib_mex('canny',IMG,threshold1,threshold2,aperture_size);\n"); |
|
|
mexPrintf(" If not provided threshold1 = 40, threshold2 = 200, aperture_size = 3;\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and a MxN uint8 matrix.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void sobelUsage() { |
|
|
mexPrintf("Usage: C = cvlib_mex('sobel',IMG);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image OR a MxN single:\n"); |
|
|
mexPrintf(" C = cvlib_mex('sobel',IMG,xorder,yorder,aperture_size);\n"); |
|
|
mexPrintf(" If not provided xorder = 1, yorder = 0, aperture_size = 3;\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8 or single.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and a MxN matrix of the same type as IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void laplaceUsage() { |
|
|
mexPrintf("Usage: C = cvlib_mex('laplace',IMG);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image OR a MxN single:\n"); |
|
|
mexPrintf(" C = cvlib_mex('laplace',IMG,aperture_size);\n"); |
|
|
mexPrintf(" If not provided aperture_size = 3;\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8 or single.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and a MxN matrix of the same type as IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void erodeUsage() { |
|
|
mexPrintf("Usage: C = cvlib_mex('erode',IMG);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image OR a MxN single:\n"); |
|
|
mexPrintf(" C = cvlib_mex('erode',IMG,iterations);\n"); |
|
|
mexPrintf(" If not provided iterations = 1;\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: logical, uint8 or single.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void dilateUsage() { |
|
|
mexPrintf("Usage: C = cvlib_mex('dilate',IMG);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image OR a MxN single:\n"); |
|
|
mexPrintf(" C = cvlib_mex('dilate',IMG,iterations);\n"); |
|
|
mexPrintf(" If not provided iterations = 1;\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: logical, uint8 or single.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void morphologyexUsage() { |
|
|
mexPrintf("Usage: C = cvlib_mex('morphologyex',IMG,OPERATION);\n"); |
|
|
mexPrintf(" where IMG is a uint8 MxNx3 rgb OR a MxN intensity image OR a MxN single:\n"); |
|
|
mexPrintf(" The available OPERATIONS are:\n"); |
|
|
mexPrintf(" 'open'\n"); |
|
|
mexPrintf(" 'close'\n"); |
|
|
mexPrintf(" 'gradient' dilate - erode\n"); |
|
|
mexPrintf(" 'tophat' IMG - open\n"); |
|
|
mexPrintf(" 'blackhat' close - IMG\n\n"); |
|
|
mexPrintf(" C = cvlib_mex('morphologyex',IMG,OPERATION,iterations);\n"); |
|
|
mexPrintf(" If not provided iterations = 1;\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: logical, uint8 or single.\n"); |
|
|
mexPrintf(" Memory overhead: 2 copies of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void colorUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('color',IMG,'TRF');\n"); |
|
|
mexPrintf(" where IMG is a MxNx3 image of type: uint8, uint16 OR single (0..1 interval).\n"); |
|
|
mexPrintf(" TRF is a string controling the transformation. Possibilities are:\n"); |
|
|
mexPrintf(" rgb2lab,lab2rgb, rgb2luv,luv2rgb, rgb2xyz,xyz2rgb\n"); |
|
|
mexPrintf(" rgb2yiq,yiq2rgb, rgb2hsv,luv2hsv, rgb2hsl,hsl2rgb, rgb2YCrCb,YCrCb2rgb\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8, uint16 or single.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and 1 copy of B.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void flipUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('flip',IMG,'DIR');\n"); |
|
|
mexPrintf(" Flip a 2D array around vertical, horizontall or both axis\n"); |
|
|
mexPrintf(" where IMG is an array of any type and DIR = 'ud', 'lr' or 'both'\n"); |
|
|
mexPrintf(" for Up-Down, Left-Right or Both.\n\n"); |
|
|
mexPrintf(" cvlib_mex('flip',IMG,'DIR');\n"); |
|
|
mexPrintf(" Flips IMG inplace.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void filterUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('filter',IMG,FILTER);\n"); |
|
|
mexPrintf(" Convolves image IMG with the kernel FILTER\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8, int16, uint16 or single.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and 1 copy of FILTER.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void smoothUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('smooth',IMG [,TYPE,PAR1,PAR2,PAR3,PAR4]);\n"); |
|
|
mexPrintf(" Smooths the MxNx3 or MxN IMG in one of several ways\n"); |
|
|
mexPrintf(" The available TYPE of smoothing are:\n"); |
|
|
mexPrintf(" 'blur' summation over a pixel PAR1�PAR2 neighborhood with subsequent scaling by 1/(PAR1xPAR2).\n"); |
|
|
mexPrintf(" 'gaussian' convolves image with PAR1�PAR2 Gaussian kernel [Default].\n"); |
|
|
mexPrintf(" 'median' finding median of PAR1�PAR1 neighborhood (i.e. the neighborhood is square)\n"); |
|
|
mexPrintf(" 'bilateral' apply bilateral 3x3 filtering with color sigma=PAR1 and space sigma=PAR2\n"); |
|
|
mexPrintf(" If PAR1 & PAR2 are not provided they default to 5 and 50.\n"); |
|
|
mexPrintf(" Information about bilateral filtering can be found at.\n"); |
|
|
mexPrintf(" www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html\n"); |
|
|
mexPrintf(" PAR1 -> The first parameter of smoothing operation [Default = 5]\n"); |
|
|
mexPrintf(" PAR2 -> The second parameter of smoothing operation [Default = PAR1]\n"); |
|
|
mexPrintf(" PAR3 -> In case of Gaussian kernel this parameter may specify Gaussian sigma\n"); |
|
|
mexPrintf(" (standard deviation). If it is zero, it is calculated from the kernel size\n"); |
|
|
mexPrintf(" PAR4 -> In case of non-square Gaussian kernel the parameter may be used to specify\n"); |
|
|
mexPrintf(" a different (from param3) sigma in the vertical direction.\n\n"); |
|
|
mexPrintf(" B = cvlib_mex('smooth',IMG);\n"); |
|
|
mexPrintf(" Does a gaussian filtering with a 5x5 kernel.\n"); |
|
|
|
|
|
mexPrintf(" Class support: logical, uint8 or single.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void pyrUUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('pyrU',IMG);\n"); |
|
|
mexPrintf(" performs up-sampling step of Gaussian pyramid decomposition.\n"); |
|
|
mexPrintf(" First it upsamples the source image by injecting even zero rows and\n"); |
|
|
mexPrintf(" and then convolves result with a 5x5 Gaussian filter multiplied by 4\n"); |
|
|
mexPrintf(" for interpolation. So the destination image is four times larger than\n"); |
|
|
mexPrintf(" the source image.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: logical, uint8, uint16, int16, single or double.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and 1 copy of B.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void pyrDUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('pyrD',IMG);\n"); |
|
|
mexPrintf(" performs downsampling step of Gaussian pyramid decomposition.\n"); |
|
|
mexPrintf(" First it convolves source image with a 5x5 Gaussian filter and then\n"); |
|
|
mexPrintf(" downsamples the image by rejecting even rows and columns\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: logical, uint8, uint16, int16, single or double.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and 1 copy of B.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void arithmUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex(OP,IMG1,IMG2);\n"); |
|
|
mexPrintf(" Apply per element arithmetics betweem IMG1 & IMG2. OP can be one of:\n"); |
|
|
mexPrintf(" add -> B = IMG1 + IMG2\n"); |
|
|
mexPrintf(" sub -> B = IMG1 - IMG2\n"); |
|
|
mexPrintf(" mul -> B = IMG1 * IMG2\n"); |
|
|
mexPrintf(" div -> B = IMG1 / IMG2\n\n"); |
|
|
mexPrintf(" If IMG2 is a scalar than OP can also take these values:\n"); |
|
|
mexPrintf(" addS -> B = IMG1 + IMG2\n"); |
|
|
mexPrintf(" subS -> B = IMG1 - IMG2\n\n"); |
|
|
|
|
|
mexPrintf("The form (that is, with no output)\n: cvlib_mex(OP,IMG1,IMG2);\n"); |
|
|
mexPrintf(" does the above operation in-place and stores the result in IMG1\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: all but uint32.\n"); |
|
|
mexPrintf(" Memory overhead: none.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void addWeightedUsage() { |
|
|
mexPrintf("Usage: B = cvlib_mex('addweighted',IMG1,alpha,IMG2,beta[,gamma]);\n"); |
|
|
mexPrintf(" The function addweighted calculates weighted sum of two arrays as following:\n"); |
|
|
mexPrintf(" B(i) = img1(i)*alpha + img2(i)*beta + gamma\n"); |
|
|
mexPrintf(" If gamma is not provided, gamma = 0\n\n"); |
|
|
mexPrintf("The form (that is, with no output)\n: cvlib_mex('addweighted',IMG1,alpha,IMG2,beta[,gamma]);\n"); |
|
|
mexPrintf(" does the above operation in-place and stores the result in IMG1\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: all but uint32.\n"); |
|
|
mexPrintf(" Memory overhead: none.\n"); |
|
|
} |
|
|
|
|
|
|
|
|
void inpaintUsage() { |
|
|
mexPrintf("Usage: cvlib_mex('inpaint',IMG1,IMG2);\n"); |
|
|
mexPrintf(" The function inpaint reconstructs IMG1 image area from the pixel near the area boundary.\n"); |
|
|
mexPrintf(" The function may be used to remove scratches or undesirable objects from images:\n"); |
|
|
mexPrintf(" IMG1 is a uint8 MxNx3 rgb OR a MxN intensity image and IMG2 is a mask array\n"); |
|
|
mexPrintf(" of the same size (MxN) of IMG1. It can be a logical array or a uint8 array.\n"); |
|
|
mexPrintf(" IMG = cvlib_mex('polyline',IMG1,IMG2);\n"); |
|
|
mexPrintf(" Returns the drawing in the the new array IMG.\n\n"); |
|
|
|
|
|
mexPrintf(" Class support: uint8.\n"); |
|
|
mexPrintf(" Memory overhead: 1 copy of IMG and a MxN matrix of the same type as IMG.\n"); |
|
|
} |
|
|
|
