/*mexFunction handles the argument processing*/ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { double *weight, *epsilon, *trainpats; long *orderind; mxLogical *pos, *neg; unsigned int *seed; int *scalardims; int numfeat, numex, numclass; long *feat; double *thresh, *conf; /*check that the appropriate number of arguments have been passed*/ if (nrhs != 7) mexErrMsgTxt("Weight, pos, neg, sortedix, epsilon, trainpats, seed required."); if (nlhs != 3) mexErrMsgTxt("Outputs: feat, threshind, conf"); /*validate the type of pos and neg (they will need to become mxLogical)*/ if (!mxIsLogical(prhs[1])) mexErrMsgTxt("pos is not logical."); if (!mxIsLogical(prhs[2])) mexErrMsgTxt("neg is not logical."); /*collect the arguments*/ weight = mxGetData(prhs[0]); pos = mxGetLogicals(prhs[1]); neg = mxGetLogicals(prhs[2]); orderind = (long*)mxGetData(prhs[3]); epsilon = mxGetData(prhs[4]); trainpats = mxGetData(prhs[5]); seed = mxGetData(prhs[6]); /*determine the dataset dimenions using the weight and sortedix matrices (see matrix sizes above - matrix dimensions are M x N)*/ numclass = mxGetM(prhs[0]); numex = mxGetN(prhs[0]); numfeat = mxGetN(prhs[3]); /*create the output arguments*/ /*feat is an index and will be returned as a 32-bit int set up the matrix size for feat*/ scalardims = mxCalloc(2,sizeof(int)); scalardims[0] = scalardims[1] = 1; plhs[0] = mxCreateNumericArray(2,scalardims,mxINT32_CLASS,mxREAL); /*create the thresh and conf output arguments*/ plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL); plhs[2] = mxCreateDoubleMatrix(numclass,2,mxREAL); mxFree(scalardims); feat = (long *)mxGetPr(plhs[0]); thresh = (double *)mxGetPr(plhs[1]); conf = mxGetPr(plhs[2]); /*place the call the calculation function*/ dstump(weight, pos, neg, orderind, trainpats, numfeat, numex, numclass, epsilon, feat, thresh, conf, seed); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { int dim, i; if (nrhs<6) mexErrMsgTxt("Number of arguments must be 6!"); // Get input const double* T = static_cast<double*>(mxGetData(prhs[0])); const double* omega = static_cast<double*>(mxGetData(prhs[1])); const double* m = static_cast<double*>(mxGetData(prhs[2])); const double* X = static_cast<double*>(mxGetData(prhs[3])); bool doDerivative = (bool) *mxGetLogicals(prhs[4]); bool boundary = (bool) *mxGetLogicals(prhs[5]); // get dimension, h and number of elements N dim = mxGetN(prhs[1]) / 2; double h[3]; //h[dim]; for (i=0; i<dim; i++) { h[i] = (omega[2*i+1]-omega[2*i]) / m[i]; } const int N = mxGetM(prhs[3])/dim; //Allocate Tc mwSize dims[2]; dims[0] = N; dims[1] = 1; plhs[0] = mxCreateNumericArray(2,dims,mxDOUBLE_CLASS, mxREAL); double* Tc = static_cast<double*>(mxGetData(plhs[0])); double* dT = 0; //Allocate dT if (doDerivative) { dims[1] = dim; plhs[1] = mxCreateNumericArray(2,dims,mxDOUBLE_CLASS, mxREAL); dT = static_cast<double*>(mxGetData(plhs[1])); } else { dims[0] = 1; dims[1] = 1; plhs[1] = mxCreateNumericArray(2,dims,mxDOUBLE_CLASS, mxREAL); dT = static_cast<double*>(mxGetData(plhs[1])); } switch (dim) { case 1: splineInter1D(Tc,dT,T,omega,m,N,X,h,doDerivative, boundary); break; case 2: splineInter2D(Tc,dT,T,omega,m,N,X,h,doDerivative, boundary); break; case 3: splineInter3D(Tc,dT,T,omega,m,N,X,h,doDerivative, boundary); break; default: break; } }
void mexFunction(int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs) { /* Initialize some variables */ double *appearance, *newCoordsX, *newCoordsY, *size_aam, *warped_appear; int i, appear_height, height, width; bool *in; /* Retrieve inputs */ appearance = mxGetPr(prhs[0]); newCoordsX = mxGetPr(prhs[1]); newCoordsY = mxGetPr(prhs[2]); in = mxGetLogicals(prhs[3]); size_aam = mxGetPr(prhs[4]); appear_height = mxGetM(prhs[0]); height = (int) size_aam[0]; width = (int) size_aam[1]; /* Construct output matrix */ plhs[0] = mxCreateDoubleMatrix(height, width, mxREAL); warped_appear = mxGetPr(plhs[0]); /* Fill result image */ for(i = 0; i < height * width; i++) { if(in[i]) { warped_appear[i] = appearance[(int) newCoordsY[i] - 1 + ((int) newCoordsX[i] - 1) * appear_height]; } } }
/* PsychSetStructArrayBooleanElement() Note: The variable "index" is zero-indexed. */ void PsychSetStructArrayBooleanElement( char *fieldName, int index, boolean state, PsychGenericScriptType *pStruct) { int fieldNumber, numElements; boolean isStruct; mxArray *mxFieldValue; char errmsg[256]; //check for bogus arguments numElements=mxGetM(pStruct) *mxGetN(pStruct); if(index>=numElements) PsychErrorExitMsg(PsychError_internal, "Attempt to set a structure field at an out-of-bounds index"); fieldNumber=mxGetFieldNumber(pStruct, fieldName); if(fieldNumber==-1) { sprintf(errmsg, "Attempt to set a non-existent structure name field: %s", fieldName); PsychErrorExitMsg(PsychError_internal, errmsg); } isStruct= mxIsStruct(pStruct); if(!isStruct) PsychErrorExitMsg(PsychError_internal, "Attempt to set a field within a non-existent structure."); //do stuff mxFieldValue=mxCreateLogicalMatrix(1, 1); mxGetLogicals(mxFieldValue)[0]= state; mxSetField(pStruct, index, fieldName, mxFieldValue); if (PSYCH_LANGUAGE == PSYCH_OCTAVE) mxDestroyArray(mxFieldValue); }
void MxArray::fromVector(const std::vector<bool>& v) { p_ = mxCreateLogicalMatrix(1, v.size()); if (!p_) mexErrMsgIdAndTxt("mexopencv:error", "Allocation error"); std::copy(v.begin(), v.end(), mxGetLogicals(p_)); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { int i, dimLocal, n = 1, nn = 1, mLocal[3]; if (nrhs<4) mexErrMsgTxt("Number of arguments must be 4!"); // Get input const double *yc = static_cast<double*>(mxGetData(prhs[0])); const double *m = static_cast<double*>(mxGetData(prhs[1])); const double *dim = static_cast<double*>(mxGetData(prhs[2])); bool mode = (bool) *mxGetLogicals(prhs[3]); dimLocal = (int) dim[0]; for (i=0; i<dimLocal; i++) { mLocal[i] = (int) m[i]; n *= mLocal[i]; nn *= mLocal[i]+1; } mwSize dims[2]; if (mode) { dims[0] = nn*dimLocal; dims[1] = 1; plhs[0] = mxCreateNumericArray(2, dims, mxDOUBLE_CLASS, mxREAL); double *yOut = static_cast<double*>(mxGetData(plhs[0])); center2nodal(yOut, yc, mLocal, dimLocal); } else { dims[0] = n*dimLocal; dims[1] = 1; plhs[0] = mxCreateNumericArray(2, dims, mxDOUBLE_CLASS, mxREAL); double *yOut = static_cast<double*>(mxGetData(plhs[0])); nodal2center(yOut, yc, mLocal, dimLocal); } }
void eng_make_SparseLogical(int *ir, int irlen, int *jc, int jclen, short *list, int len, int m, int n) { mxArray *var = mxCreateSparseLogicalMatrix(m, n, len); std::copy(ir, ir + irlen, mxGetIr(var)); std::copy(jc, jc + jclen, mxGetJc(var)); std::copy(list, list+len, mxGetLogicals(var)); returnHandle(var); }
/* main matab function */ void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { /* b = fast_inseg( seg, t ) */ /* current t in current seg? start while block until out of seg, then next seg * current t before seg start? binsearch for next t in seg, start while block, next seg * current t after seg end? go to next seg */ double *seg, *t; mxLogical *pout; int s, current_t, idx; int nseg, nt; if (nrhs!=2) mexErrMsgIdAndTxt("fast_inseg:invalidArguments", "Expecting two arguments"); if ( mxGetNumberOfDimensions(prhs[0])!=2 || mxGetN(prhs[0])!=2 ) mexErrMsgIdAndTxt("fast_inseg:invalidArguments", "Invalid segments"); seg = mxGetPr( prhs[0] ); t = mxGetPr( prhs[1] ); nseg = mxGetM( prhs[0] ); nt = mxGetNumberOfElements(prhs[1]); plhs[0] = mxCreateLogicalMatrix( nt, 1 ); if (nseg==0 || nt==0) return; pout = mxGetLogicals( plhs[0] ); current_t = 0; for (s=0; s<nseg; s++) { if ( t[current_t]<seg[s] ) { /* binsearch for next t in seg */ idx = (int) ceil( bsearchi( &(t[current_t]), nt-current_t, seg[s] ) ); if (idx==-1) break; current_t += idx; } else if ( t[current_t]>seg[s+nseg] ) { continue; } while ( t[current_t]<=seg[s+nseg] && current_t<nt ) { pout[current_t] = 1; current_t++; } if (current_t>=nt) break; } }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { mxLogical *image, *outImage; mwSize w, h; if (nrhs != 1){ mexErrMsgIdAndTxt( "MATLAB:borderFill:wrongInputCount", "One input (image) expected."); } /* The input must be a logical.*/ if(!mxIsLogical(prhs[0])){ mexErrMsgIdAndTxt( "MATLAB:borderFill:inputNotLogical", "Input must be a logical."); } h = mxGetM(prhs[0]); w = mxGetN(prhs[0]); image = mxGetLogicals(prhs[0]); /* Create matrix for the return argument. */ plhs[0] = mxCreateLogicalMatrix(h, w); outImage = mxGetLogicals(plhs[0]); /* first and last column */ for (int y = 0; y < h; y++){ if (!outImage[y]){ fill(image, h, w, y, 0, image[y], outImage); } if (!outImage[h * (w - 1) + y]){ fill(image, h, w, y, w - 1, image[h * (w - 1) + y], outImage); } } /* first and last row */ for (int x = 1; x < w - 1; x++){ if (!outImage[x * h]){ fill(image, h, w, 0, x, image[x * h], outImage); } if (!outImage[x * h + h - 1]){ fill(image, h, w, h - 1, x, image[x * h + h - 1], outImage); } } }
void eng_make_Logical(short *list, int len, int *mmDims, int depth) { std::vector<mwSize> mbDimsVec(depth); std::reverse_copy(mmDims, mmDims+depth, mbDimsVec.begin()); mwSize *mbDims = &mbDimsVec[0]; mxArray *var = mxCreateLogicalArray(depth, mbDims); std::copy(list, list+len, mxGetLogicals(var)); returnHandle(var); }
static boolean_T r_emlrt_marshallIn(const emlrtStack *sp, const mxArray *src, const emlrtMsgIdentifier *msgId) { boolean_T ret; emlrtCheckBuiltInR2012b(sp, msgId, src, "logical", false, 0U, 0); ret = *mxGetLogicals(src); emlrtDestroyArray(&src); return ret; }
bool CMatlabInterface::get_bool() { const mxArray* b=get_arg_increment(); if (mxIsLogical(b) && mxGetN(b)==1 && mxGetM(b)==1) return mxGetLogicals(b)[0]; else if (mxIsNumeric(b)) return (mxGetScalar(b)!=0); else SG_ERROR("Expected Scalar Boolean as argument %d\n", m_rhs_counter); return false; }
void mexFunction(int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs) { /* Initialize some variables */ double *z, *tri, *w, *zi, *xi, *max; int i, j, no_pixels, no_tri; bool *in; /* Get inputs */ no_pixels = mxGetM(prhs[1]); no_tri = mxGetN(prhs[1]); z = mxGetPr(prhs[0]); tri = mxGetPr(prhs[1]); w = mxGetPr(prhs[2]); in = mxGetLogicals(prhs[3]); xi = mxGetPr(prhs[4]); max = mxGetPr(prhs[5]); /* Allocate memory for the output matrix */ plhs[0] = mxCreateDoubleMatrix(no_pixels, 1, mxREAL); zi = mxGetPr(plhs[0]); /* Compute pixel displacements */ for(j = 0; j < no_tri; j++) { for(i = 0; i < no_pixels; i++) { if(in[i]) { zi[i] += (z[(int) tri[i + j * no_pixels] - 1] * w[i + j * no_pixels]); } } } /* Compute where to take pixels from */ for(i = 0; i < no_pixels; i++) { if(in[i]) { /* Subtract displacements from original coordinates */ zi[i] = xi[i] - zi[i]; /* Check whether none of the assignments is out of range, and round */ if(zi[i] < 1.0) { zi[i] = 1.0; } else if(zi[i] > max[0]) { zi[i] = max[0]; } else { zi[i] = floor(zi[i]+0.5); } /* Excluding the round makes thing a lot faster, but a bit inaccurate */ } } }
int mxIsLogicalScalarTrue(const mxArray *ptr) { if (mxIsLogicalScalar(ptr) == false) { return 0; } if (*mxGetLogicals(ptr) == 0) { return 0; } return 1; }
int readMxLogicalDataFromBytes(mxArray *mx, mxGramInfo *info, int nBytes) { int ii; int numel = info->dataM * info->dataN; mxLogical *mxData = mxGetLogicals(mx); const char *gramData = info->dataBytes; if (nBytes >= mxGetElementSize(mx)*numel) { for(ii=0; ii<numel; ii++) { mxData[ii] = (mxLogical)*gramData; gramData += info->dataSize; } return(info->dataSize*numel); } else return(-1); }
int writeMxLogicalDataToBytes(const mxArray *mx, mxGramInfo *info, int nBytes) { int ii; int numel = info->dataM * info->dataN; mxLogical *mxData = mxGetLogicals(mx); char *gramData = info->dataBytes; if (nBytes >= info->dataSize*numel) { for(ii=0; ii<numel; ii++) { *((mxLogical*)gramData) = mxData[ii]; gramData += info->dataSize; } return(info->dataSize*numel); } else return(-1); }
fcvimage * mxArray2fcv(const mxArray *img) { int w, h, d, type, dim; const int *dims=0; int islogical; char *ptr; fcvimage *ret; const mxArray *mx_img = img; type = mex2fcvType(mxGetClassID(mx_img)); if(type == -1) return NULL; dim = mxGetNumberOfDimensions(mx_img); if (dim < 3) { w = mxGetM(mx_img); h = mxGetN(mx_img); d = 1; } else if (dim == 3) { dims = (int *)mxGetDimensions(mx_img); if (dims == 0){ fcv_error("mx2fcv","Cant get dimensions."); return NULL; } w = dims[0]; h = dims[1]; d = dims[2]; } else { fcv_error("mx2fcv","Invalid dimensions."); return NULL; } islogical = mxIsLogical(mx_img); if (islogical) { ptr = (char *)mxGetLogicals(mx_img); } else { ptr = (char *)mxGetPr(mx_img); } ret = fcv_createimagestructure(w, h, d, type,FCV_RTAG_RLOCAL,islogical,FCV_MATLAB_DEFAULT_RASTER_ARANGE); if(ret == 0){ fcv_error("mx2fcv","cant create image."); return NULL; } ret->imagedata = ptr; return ret; }
/* ********************************************************** */ void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { int mrows, ncols, i, j, jcol; double *inputD64; unsigned char *inputU8; mxLogical *output; /* ************* ACCESS MATLAB VARIABLES ************* */ mrows = mxGetM(prhs[0]); ncols = mxGetN(prhs[0]); /* Create an array to hold the output. */ plhs[0] = mxCreateLogicalMatrix(mrows, ncols); output = mxGetLogicals(plhs[0]); /* ********************* COMPUTE ********************* */ switch (mxGetClassID(prhs[0])) { case (mxDOUBLE_CLASS): inputD64 = (double *) mxGetPr(prhs[0]); for (j = 0; j < ncols; j++) { jcol = j*mrows; output[0+jcol] = (inputD64[0+jcol] != 0); for (i = 1; i < mrows; i++) { output[i+jcol] = inputD64[i+jcol] && !inputD64[(i-1)+jcol]; } } break; case(mxUINT8_CLASS): case(mxLOGICAL_CLASS): inputU8 = (unsigned char *) mxGetData(prhs[0]); for (j = 0; j < ncols; j++) { jcol = j*mrows; output[0+jcol] = (inputU8[0+jcol] != 0); for (i = 1; i < mrows; i++) { output[i+jcol] = inputU8[i+jcol] && !inputU8[(i-1)+jcol]; } } break; default: mexErrMsgTxt("Invalid Data Type.\n"); } /* ********************* CLEAN UP ******************** */ }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { mexPrintf("Running m3f_tib_sampleOffsets\n"); omp_set_num_threads(MAX_NUM_THREADS); // Extract input information const mxArray* data = prhs[0]; uint32_t* users = (uint32_t*)mxGetData(mxGetField(data, 0, "users")); uint32_t* items = (uint32_t*)mxGetData(mxGetField(data, 0, "items")); const mxArray* exampsByUser = mxGetField(data, 0, "exampsByUser"); const mxArray* exampsByItem = mxGetField(data, 0, "exampsByItem"); const mxArray* model = prhs[1]; int KU = (*mxGetPr(mxGetField(model, 0, "KU"))) + .5; int KM = (*mxGetPr(mxGetField(model, 0, "KM"))) + .5; int numUsers = (*mxGetPr(mxGetField(model, 0, "numUsers"))) + .5; int numItems = (*mxGetPr(mxGetField(model, 0, "numItems"))) + .5; double invSigmaSqd = 1.0/(*mxGetPr(mxGetField(model, 0, "sigmaSqd"))); double invSigmaSqd0 = 1.0/(*mxGetPr(mxGetField(model, 0, "sigmaSqd0"))); double c0 = (*mxGetPr(mxGetField(model, 0, "c0"))); double d0 = (*mxGetPr(mxGetField(model, 0, "d0"))); const mxArray* samp = prhs[2]; double* c = mxGetPr(mxGetField(samp, 0, "c")); // KM x numUsers double* d = mxGetPr(mxGetField(samp, 0, "d")); // KU x numItems uint32_t* zU = (uint32_t*)mxGetData(prhs[3]); uint32_t* zM = (uint32_t*)mxGetData(prhs[4]); double* resids = mxGetPr(prhs[5]); mxLogical* sampParams = NULL; if(nrhs > 6){ sampParams = mxGetLogicals(prhs[6]); } // Sample c offsets if((KM > 0) && ((sampParams == NULL) || sampParams[0])){ sampleOffsets(users, items, exampsByUser, KU, KM, numUsers, invSigmaSqd, invSigmaSqd0, c0, c, d, zU, zM, resids); } // Sample d offsets if((KU > 0) && ((sampParams == NULL) || sampParams[1])){ sampleOffsets(items, users, exampsByItem, KM, KU, numItems, invSigmaSqd, invSigmaSqd0, d0, d, c, zM, zU, resids); } }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[] ) { double *W = mxGetPr(prhs[0]); double *p = mxGetPr(prhs[1]); int wm = mxGetM(prhs[0]); int wn = mxGetN(prhs[0]); int k = mxGetScalar(prhs[2]); plhs[0] = mxDuplicateArray(prhs[3]);/* lemasolom a tombot, mert az input parameter const */ double *x = mxGetPr(plhs[0]); bool *freePixels = mxGetLogicals(prhs[4]); double *beta = mxGetPr(prhs[5]); double *gamma = mxGetPr(prhs[6]); int numIters = mxGetScalar(prhs[7]); SART(W,wm,wn,p,k,x,freePixels,beta,gamma, numIters); }
void parseGeneralInputs(int nrhs, const mxArray *prhs[], bool *registerTF, TaskHandle *taskID) { assert(nrhs>=1); const mxArray *task = prhs[0]; TaskHandle *taskIDPtr; //Get TaskHandle taskIDPtr = (TaskHandle*)mxGetData(mxGetProperty(prhs[0],0, "taskID")); *taskID = (TaskHandle)*taskIDPtr; //Process argument 2 - registerTF if ((nrhs < 2) || mxIsEmpty(prhs[1])) { *registerTF = true; } else { mxLogical *registerTFTemp = mxGetLogicals(prhs[1]); *registerTF = (bool) *registerTFTemp; } }
void mexFunction(int nlhs_m, mxArray *plhs_m[], int nrhs_m, const mxArray *prhs_m[]) { if (nlhs_m > 1) { printf("Error, only one ouput parameter allowed!\n"); return; } if (nrhs_m != 1) { printf("Error, only one input parameter allowed!\n"); return; } plhs_m[0] = mxCreateLogicalMatrix(1,1); *(mxGetLogicals(plhs_m[0])) = mxIsComplex(prhs_m[0]); return; }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { double *phi; mxLogical *contour; int iWidth, iHeight; /* The input must be a noncomplex scalar double.*/ iHeight = mxGetM(prhs[0]); iWidth = mxGetN(prhs[0]); /* Create matrix for the return argument. */ plhs[0] = mxCreateLogicalMatrix(iHeight,iWidth); /* Assign pointers to each input and output. */ phi = mxGetPr(prhs[0]); contour = mxGetLogicals(plhs[0]); for (int i = 0; i < iWidth; i++) { for (int j = 0; j < iHeight; j++) { if (phi[i*iHeight+j] >= 0) { bool bIsNeighbourBelowZero = false; for (int k = -1; k <= 1; k++) { for (int l = -1; l <= 1; l++) { if (i+k >= 0 && i+k < iWidth && j+l >= 0 && j+l < iHeight && phi[(i+k)*iHeight+j+l] < 0) { if (-phi[(i+k)*iHeight+j+l] < phi[i*iHeight+j]) { contour[(i+k)*iHeight+j+l] = true; } else { contour[i*iHeight+j] = true; } } } } } } } }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { mexPrintf("Running sampleTopicParams\n"); omp_set_num_threads(MAX_NUM_THREADS); // Extract input information const mxArray* data = prhs[0]; const mxArray* exampsByUser = mxGetField(data, 0, "exampsByUser"); const mxArray* exampsByItem = mxGetField(data, 0, "exampsByItem"); const mxArray* model = prhs[1]; int KU = (*mxGetPr(mxGetField(model, 0, "KU"))) + .5; int KM = (*mxGetPr(mxGetField(model, 0, "KM"))) + .5; int numUsers = (*mxGetPr(mxGetField(model, 0, "numUsers"))) + .5; int numItems = (*mxGetPr(mxGetField(model, 0, "numItems"))) + .5; double alpha = (*mxGetPr(mxGetField(model, 0, "alpha"))); const mxArray* samp = prhs[2]; double* logthetaU = mxGetPr(mxGetField(samp, 0, "logthetaU")); // KU x numUsers double* logthetaM = mxGetPr(mxGetField(samp, 0, "logthetaM")); // KM x numItems uint32_t* zU = (uint32_t*)mxGetData(prhs[3]); uint32_t* zM = (uint32_t*)mxGetData(prhs[4]); mxLogical* sampParams = NULL; if(nrhs > 5){ sampParams = mxGetLogicals(prhs[5]); } // Sample user topic parameters if((KU > 1) && ((sampParams == NULL) || sampParams[0])){ sampleTopicParams(exampsByUser, KU, numUsers, alpha, logthetaU, zU); } // Sample item topic parameters if((KM > 1) && ((sampParams == NULL) || sampParams[1])){ sampleTopicParams(exampsByItem, KM, numItems, alpha, logthetaM, zM); } }
/* Gateway function with Matlab */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { char *cmd; /* If no input argument, print out the usage */ if (nrhs == 0) { mexErrMsgTxt("Usage: messenger('init|listen|respond', extra1, extra2, ...)"); } /* Get the input command */ if(!(cmd = mxArrayToString(prhs[0]))) { mexErrMsgTxt("Cannot read the command"); } /* Initialize a new server session */ if (strcmp(cmd, "init") == 0) { char *socket_addr; mxLogical *p; /* Check if the input format is valid */ if (nrhs != 2) { mexErrMsgTxt("Missing argument: socket address"); } if (!(socket_addr = mxArrayToString(prhs[1]))) { mexErrMsgTxt("Cannot read socket address"); } plhs[0] = mxCreateLogicalMatrix(1, 1); p = mxGetLogicals(plhs[0]); if (!initialized) { if (!initialize(socket_addr)) { p[0] = 1; mexPrintf("Socket created at: %s\n", socket_addr); } else { p[0] = 0; mexErrMsgTxt("Socket creation failed."); } } else { mexErrMsgTxt("One socket has already been initialized."); } return; /* Listen over an existing socket */ } else if (strcmp(cmd, "listen") == 0) { char *recv_buffer = mxCalloc(BUFLEN, sizeof(char)); int byte_recvd = listen_zmq(recv_buffer, BUFLEN); while (byte_recvd == -1 && errno == EAGAIN) { mexCallMATLAB(0, NULL, 0, NULL, "drawnow"); byte_recvd = listen_zmq(recv_buffer, BUFLEN); } /* Check if the received data is complete and correct */ if ((byte_recvd > -1) && (byte_recvd <= BUFLEN)) { plhs[0] = mxCreateString(recv_buffer); } else if (byte_recvd > BUFLEN){ mexErrMsgTxt("Receiver buffer overflow. Message truncated"); } else { sprintf(recv_buffer, "Failed to receive a message due to ZMQ error %s", strerror(errno)); mexErrMsgTxt(recv_buffer); } return; /* Send a message out */ } else if (strcmp(cmd, "respond") == 0) { size_t msglen; char *msg_out; mxLogical *p; /* Check if the input format is valid */ if (nrhs != 2) { mexErrMsgTxt("Please provide the message to send"); } msglen = mxGetNumberOfElements(prhs[1]); msg_out = mxArrayToString(prhs[1]); plhs[0] = mxCreateLogicalMatrix(1, 1); p = mxGetLogicals(plhs[0]); if (msglen == respond(msg_out, msglen)) { p[0] = 1; } else { p[0] = 0; mexErrMsgTxt("Failed to send message due to ZMQ error"); } return; /* Close the socket and context */ } else if (strcmp(cmd, "exit") == 0) { cleanup(); return; } else { mexErrMsgTxt("Unidentified command"); } }
void mexFunction(int nout, mxArray *out[], int nin, const mxArray *in[]) { enum {IN_I = 0, IN_END} ; enum {OUT_FRAMES=0, OUT_DESCRIPTORS, OUT_INFO, OUT_END} ; int verbose = 0 ; int opt ; int next = IN_END ; mxArray const *optarg ; VlEnumerator *pair ; float const *image ; vl_size numCols, numRows ; VlCovDetMethod method = VL_COVDET_METHOD_DOG; vl_bool estimateAffineShape = VL_FALSE ; vl_bool estimateOrientation = VL_FALSE ; vl_bool doubleImage = VL_TRUE ; vl_index octaveResolution = -1 ; double edgeThreshold = -1 ; double peakThreshold = -1 ; double lapPeakThreshold = -1 ; int descriptorType = -1 ; vl_index patchResolution = -1 ; double patchRelativeExtent = -1 ; double patchRelativeSmoothing = -1 ; float *patch = NULL ; float *patchXY = NULL ; vl_int liopNumSpatialBins = 6; vl_int liopNumNeighbours = 4; float liopRadius = 6.0; float liopIntensityThreshold = VL_NAN_F ; double boundaryMargin = 2.0 ; double * userFrames = NULL ; vl_size userFrameDimension = 0 ; vl_size numUserFrames = 0 ; VL_USE_MATLAB_ENV ; /* ----------------------------------------------------------------- * Check the arguments * -------------------------------------------------------------- */ if (nin < IN_END) { vlmxError(vlmxErrNotEnoughInputArguments, 0) ; } else if (nout > OUT_END) { vlmxError(vlmxErrTooManyOutputArguments, 0) ; } if (mxGetNumberOfDimensions(IN(I)) != 2 || mxGetClassID(IN(I)) != mxSINGLE_CLASS){ vlmxError(vlmxErrInvalidArgument, "I must be a matrix of class SINGLE.") ; } image = (float*) mxGetData(IN(I)) ; numRows = mxGetM(IN(I)) ; numCols = mxGetN(IN(I)) ; while ((opt = vlmxNextOption (in, nin, options, &next, &optarg)) >= 0) { switch (opt) { case opt_verbose : ++ verbose ; break ; case opt_method: pair = vlmxDecodeEnumeration(optarg, vlCovdetMethods, VL_TRUE) ; if (pair == NULL) { vlmxError(vlmxErrInvalidArgument, "METHOD is not a supported detection method.") ; } method = (VlCovDetMethod)pair->value ; break; case opt_descriptor: pair = vlmxDecodeEnumeration(optarg, vlCovDetDescriptorTypes, VL_TRUE) ; if (pair == NULL) { vlmxError(vlmxErrInvalidArgument, "DESCRIPTOR is not a supported descriptor.") ; } descriptorType = (VlCovDetDescriptorType)pair->value ; break; case opt_estimate_affine_shape: if (!mxIsLogicalScalar(optarg)) { vlmxError(vlmxErrInvalidArgument, "ESTIMATEAFFINESHAPE must be a logical scalar value.") ; } else { estimateAffineShape = *mxGetLogicals(optarg) ; } break ; case opt_estimate_orientation: if (!mxIsLogicalScalar(optarg)) { vlmxError(vlmxErrInvalidArgument, "ESTIMATEORIENTATION must be a logical scalar value.") ; } else { estimateOrientation = *mxGetLogicals(optarg); } break ; case opt_double_image: if (!mxIsLogicalScalar(optarg)) { vlmxError(vlmxErrInvalidArgument, "DOUBLEIMAGE must be a logical scalar value.") ; } else { doubleImage = *mxGetLogicals(optarg); } break ; case opt_octave_resolution : if (!vlmxIsPlainScalar(optarg) || (octaveResolution = (vl_index)*mxGetPr(optarg)) < 1) { vlmxError(vlmxErrInvalidArgument, "OCTAVERESOLUTION must be an integer not smaller than 1.") ; } break ; case opt_edge_threshold : if (!vlmxIsPlainScalar(optarg) || (edgeThreshold = *mxGetPr(optarg)) < 1) { vlmxError(vlmxErrInvalidArgument, "EDGETHRESHOLD must be a real not smaller than 1.") ; } break ; case opt_peak_threshold : if (!vlmxIsPlainScalar(optarg) || (peakThreshold = *mxGetPr(optarg)) < 0) { vlmxError(vlmxErrInvalidArgument, "PEAKTHRESHOLD must be a non-negative real.") ; } break ; case opt_laplacian_peak_threshold : if (!vlmxIsPlainScalar(optarg) || (lapPeakThreshold = *mxGetPr(optarg)) < 0) { vlmxError(vlmxErrInvalidArgument, "LAPLACIANPEAKTHRESHOLD must be a non-negative real.") ; } break ; case opt_patch_relative_smoothing : if (!vlmxIsPlainScalar(optarg) || (patchRelativeSmoothing = *mxGetPr(optarg)) < 0) { vlmxError(vlmxErrInvalidArgument, "PATCHRELATIVESMOOTHING must be a non-negative real.") ; } break ; case opt_patch_relative_extent : if (!vlmxIsPlainScalar(optarg) || (patchRelativeExtent = *mxGetPr(optarg)) <= 0) { vlmxError(vlmxErrInvalidArgument, "PATCHRELATIVEEXTENT must be a posiive real.") ; } break ; case opt_patch_resolution : if (!vlmxIsPlainScalar(optarg) || (patchResolution = (vl_index)*mxGetPr(optarg)) <= 0) { vlmxError(vlmxErrInvalidArgument, "PATCHRESOLUTION must be a positive integer.") ; } break ; case opt_liop_bins : if (!vlmxIsPlainScalar(optarg) || (liopNumSpatialBins = (vl_int)*mxGetPr(optarg)) <= 0) { vlmxError(vlmxErrInvalidArgument, "number of LIOPNUMSPATIALBINS is not a positive scalar.") ; } break ; case opt_liop_neighbours : if (!vlmxIsPlainScalar(optarg) || (liopNumNeighbours = (vl_int)*mxGetPr(optarg)) <= 0) { vlmxError(vlmxErrInvalidArgument, "number of LIOPNUMNEIGHBOURS is not a positive scalar.") ; } break ; case opt_liop_radius : if (!vlmxIsPlainScalar(optarg) || (liopRadius = (float)*mxGetPr(optarg)) <= 0) { vlmxError(vlmxErrInvalidArgument, "LIOPRADIUS must is not a positive scalar.") ; } break ; case opt_liop_threshold : if (!vlmxIsPlainScalar(optarg)) { vlmxError(vlmxErrInvalidArgument, "LIOPINTENSITYTHRESHOLD is not a scalar.") ; } liopIntensityThreshold = *mxGetPr(optarg) ; break ; case opt_frames: if (!vlmxIsPlainMatrix(optarg,-1,-1)) { vlmxError(vlmxErrInvalidArgument, "FRAMES must be a palin matrix.") ; } numUserFrames = mxGetN (optarg) ; userFrameDimension = mxGetM (optarg) ; userFrames = mxGetPr (optarg) ; switch (userFrameDimension) { case 2: case 3: case 4: case 5: case 6: /* ok */ break ; default: vlmxError(vlmxErrInvalidArgument, "FRAMES of dimensions %d are not recognised", userFrameDimension); ; } break ; default : abort() ; } } if (descriptorType < 0) descriptorType = VL_COVDET_DESC_SIFT ; switch (descriptorType) { case VL_COVDET_DESC_NONE : break ; case VL_COVDET_DESC_PATCH : if (patchResolution < 0) patchResolution = 20 ; if (patchRelativeExtent < 0) patchRelativeExtent = 6 ; if (patchRelativeSmoothing < 0) patchRelativeSmoothing = 1 ; break ; case VL_COVDET_DESC_SIFT : /* the patch parameters are selected to match the SIFT descriptor geometry */ if (patchResolution < 0) patchResolution = 15 ; if (patchRelativeExtent < 0) patchRelativeExtent = 7.5 ; if (patchRelativeSmoothing < 0) patchRelativeSmoothing = 1 ; break ; case VL_COVDET_DESC_LIOP : if (patchResolution < 0) patchResolution = 20 ; if (patchRelativeExtent < 0) patchRelativeExtent = 4 ; if (patchRelativeSmoothing < 0) patchRelativeSmoothing = 0.5 ; break ; } if (patchResolution > 0) { vl_size w = 2*patchResolution + 1 ; patch = mxMalloc(sizeof(float) * w * w); patchXY = mxMalloc(2 * sizeof(float) * w * w); } if (descriptorType == VL_COVDET_DESC_LIOP && liopRadius > patchResolution) { vlmxError(vlmxErrInconsistentData, "LIOPRADIUS is larger than PATCHRESOLUTION.") ; } /* ----------------------------------------------------------------- * Detector * -------------------------------------------------------------- */ { VlCovDet * covdet = vl_covdet_new(method) ; /* set covdet parameters */ vl_covdet_set_transposed(covdet, VL_TRUE) ; vl_covdet_set_first_octave(covdet, doubleImage ? -1 : 0) ; if (octaveResolution >= 0) vl_covdet_set_octave_resolution(covdet, octaveResolution) ; if (peakThreshold >= 0) vl_covdet_set_peak_threshold(covdet, peakThreshold) ; if (edgeThreshold >= 0) vl_covdet_set_edge_threshold(covdet, edgeThreshold) ; if (lapPeakThreshold >= 0) vl_covdet_set_laplacian_peak_threshold(covdet, lapPeakThreshold) ; if (verbose) { VL_PRINTF("vl_covdet: doubling image: %s\n", VL_YESNO(vl_covdet_get_first_octave(covdet) < 0)) ; } /* process the image */ vl_covdet_put_image(covdet, image, numRows, numCols) ; /* fill with frames: eitehr run the detector of poure them in */ if (numUserFrames > 0) { vl_index k ; if (verbose) { mexPrintf("vl_covdet: sourcing %d frames\n", numUserFrames) ; } for (k = 0 ; k < (signed)numUserFrames ; ++k) { double const * uframe = userFrames + userFrameDimension * k ; double a11, a21, a12, a22 ; VlCovDetFeature feature ; feature.peakScore = VL_INFINITY_F ; feature.edgeScore = 1.0 ; feature.frame.x = (float)uframe[1] - 1 ; feature.frame.y = (float)uframe[0] - 1 ; switch (userFrameDimension) { case 2: a11 = 1.0 ; a21 = 0.0 ; a12 = 0.0 ; a22 = 1.0 ; break ; case 3: a11 = uframe[2] ; a21 = 0.0 ; a12 = 0.0 ; a22 = uframe[2] ; break ; case 4: { double sigma = uframe[2] ; double c = cos(uframe[3]) ; double s = sin(uframe[3]) ; a11 = sigma * c ; a21 = sigma * s ; a12 = sigma * (-s) ; a22 = sigma * c ; break ; } case 5: { double d2 ; if (uframe[2] < 0) { vlmxError(vlmxErrInvalidArgument, "FRAMES(:,%d) does not have a PSD covariance.", k+1) ; } a11 = sqrt(uframe[2]) ; a21 = uframe[3] / VL_MAX(a11, 1e-10) ; a12 = 0.0 ; d2 = uframe[4] - a21*a21 ; if (d2 < 0) { vlmxError(vlmxErrInvalidArgument, "FRAMES(:,%d) does not have a PSD covariance.", k+1) ; } a22 = sqrt(d2) ; break ; } case 6: { a11 = uframe[2] ; a21 = uframe[3] ; a12 = uframe[4] ; a22 = uframe[5] ; break ; } default: a11 = 0 ; a21 = 0 ; a12 = 0 ; a22 = 0 ; assert(0) ; } feature.frame.a11 = (float)a22 ; feature.frame.a21 = (float)a12 ; feature.frame.a12 = (float)a21 ; feature.frame.a22 = (float)a11 ; vl_covdet_append_feature(covdet, &feature) ; } } else { if (verbose) { mexPrintf("vl_covdet: detector: %s\n", vl_enumeration_get_by_value(vlCovdetMethods, method)->name) ; mexPrintf("vl_covdet: peak threshold: %g, edge threshold: %g\n", vl_covdet_get_peak_threshold(covdet), vl_covdet_get_edge_threshold(covdet)) ; } vl_covdet_detect(covdet) ; if (verbose) { vl_index i ; vl_size numFeatures = vl_covdet_get_num_features(covdet) ; mexPrintf("vl_covdet: %d features suppressed as duplicate (threshold: %g)\n", vl_covdet_get_num_non_extrema_suppressed(covdet), vl_covdet_get_non_extrema_suppression_threshold(covdet)) ; switch (method) { case VL_COVDET_METHOD_HARRIS_LAPLACE: case VL_COVDET_METHOD_HESSIAN_LAPLACE: { vl_size numScales ; vl_size const * numFeaturesPerScale ; numFeaturesPerScale = vl_covdet_get_laplacian_scales_statistics (covdet, &numScales) ; mexPrintf("vl_covdet: Laplacian scales:") ; for (i = 0 ; i <= (signed)numScales ; ++i) { mexPrintf("%d with %d scales;", numFeaturesPerScale[i], i) ; } mexPrintf("\n") ; } break ; default: break ; } mexPrintf("vl_covdet: detected %d features\n", numFeatures) ; } if (boundaryMargin > 0) { vl_covdet_drop_features_outside (covdet, boundaryMargin) ; if (verbose) { vl_size numFeatures = vl_covdet_get_num_features(covdet) ; mexPrintf("vl_covdet: kept %d inside the boundary margin (%g)\n", numFeatures, boundaryMargin) ; } } } /* affine adaptation if needed */ if (estimateAffineShape) { if (verbose) { vl_size numFeaturesBefore = vl_covdet_get_num_features(covdet) ; mexPrintf("vl_covdet: estimating affine shape for %d features\n", numFeaturesBefore) ; } vl_covdet_extract_affine_shape(covdet) ; if (verbose) { vl_size numFeaturesAfter = vl_covdet_get_num_features(covdet) ; mexPrintf("vl_covdet: %d features passed affine adaptation\n", numFeaturesAfter) ; } } /* orientation estimation if needed */ if (estimateOrientation) { vl_size numFeaturesBefore = vl_covdet_get_num_features(covdet) ; vl_size numFeaturesAfter ; vl_covdet_extract_orientations(covdet) ; numFeaturesAfter = vl_covdet_get_num_features(covdet) ; if (verbose && numFeaturesAfter > numFeaturesBefore) { mexPrintf("vl_covdet: %d duplicate features were crated due to ambiguous " "orientation detection (%d total)\n", numFeaturesAfter - numFeaturesBefore, numFeaturesAfter) ; } } /* store results back */ { vl_index i ; vl_size numFeatures = vl_covdet_get_num_features(covdet) ; VlCovDetFeature const * feature = vl_covdet_get_features(covdet); double * pt ; OUT(FRAMES) = mxCreateDoubleMatrix (6, numFeatures, mxREAL) ; pt = mxGetPr(OUT(FRAMES)) ; for (i = 0 ; i < (signed)numFeatures ; ++i) { /* save the transposed frame, adjust origin to MATLAB's*/ *pt++ = feature[i].frame.y + 1 ; *pt++ = feature[i].frame.x + 1 ; *pt++ = feature[i].frame.a22 ; *pt++ = feature[i].frame.a12 ; *pt++ = feature[i].frame.a21 ; *pt++ = feature[i].frame.a11 ; } } if (nout >= 2) { switch (descriptorType) { case VL_COVDET_DESC_NONE: OUT(DESCRIPTORS) = mxCreateDoubleMatrix(0,0,mxREAL); break ; case VL_COVDET_DESC_PATCH: { vl_size numFeatures ; VlCovDetFeature const * feature ; vl_index i ; vl_size w = 2*patchResolution + 1 ; float * desc ; if (verbose) { mexPrintf("vl_covdet: descriptors: type=patch, " "resolution=%d, extent=%g, smoothing=%g\n", patchResolution, patchRelativeExtent, patchRelativeSmoothing); } numFeatures = vl_covdet_get_num_features(covdet) ; feature = vl_covdet_get_features(covdet); OUT(DESCRIPTORS) = mxCreateNumericMatrix(w*w, numFeatures, mxSINGLE_CLASS, mxREAL) ; desc = mxGetData(OUT(DESCRIPTORS)) ; for (i = 0 ; i < (signed)numFeatures ; ++i) { vl_covdet_extract_patch_for_frame(covdet, desc, patchResolution, patchRelativeExtent, patchRelativeSmoothing, feature[i].frame) ; desc += w*w ; } break ; } case VL_COVDET_DESC_SIFT: { vl_size numFeatures = vl_covdet_get_num_features(covdet) ; VlCovDetFeature const * feature = vl_covdet_get_features(covdet); VlSiftFilt * sift = vl_sift_new(16, 16, 1, 3, 0) ; vl_index i ; vl_size dimension = 128 ; vl_size patchSide = 2 * patchResolution + 1 ; double patchStep = (double)patchRelativeExtent / patchResolution ; float tempDesc [128] ; float * desc ; if (verbose) { mexPrintf("vl_covdet: descriptors: type=sift, " "resolution=%d, extent=%g, smoothing=%g\n", patchResolution, patchRelativeExtent, patchRelativeSmoothing); } OUT(DESCRIPTORS) = mxCreateNumericMatrix(dimension, numFeatures, mxSINGLE_CLASS, mxREAL) ; desc = mxGetData(OUT(DESCRIPTORS)) ; vl_sift_set_magnif(sift, 3.0) ; for (i = 0 ; i < (signed)numFeatures ; ++i) { vl_covdet_extract_patch_for_frame(covdet, patch, patchResolution, patchRelativeExtent, patchRelativeSmoothing, feature[i].frame) ; vl_imgradient_polar_f (patchXY, patchXY +1, 2, 2 * patchSide, patch, patchSide, patchSide, patchSide) ; /* Note: the patch is transposed, so that x and y are swapped. However, if NBO is not divisible by 4, then the configuration of the SIFT orientations is not symmetric by rotations of pi/2. Hence the only option is to rotate the descriptor further by an angle we need to compute the descriptor rotaed by an additional pi/2 angle. In this manner, x concides and y is flipped. */ vl_sift_calc_raw_descriptor (sift, patchXY, tempDesc, (int)patchSide, (int)patchSide, (double)(patchSide-1) / 2, (double)(patchSide-1) / 2, (double)patchRelativeExtent / (3.0 * (4 + 1) / 2) / patchStep, VL_PI / 2) ; flip_descriptor (desc, tempDesc) ; desc += dimension ; } vl_sift_delete(sift) ; break ; } case VL_COVDET_DESC_LIOP : { /* TODO: get parameters form input */ vl_size numFeatures = vl_covdet_get_num_features(covdet) ; vl_size dimension ; VlCovDetFeature const * feature = vl_covdet_get_features(covdet); vl_index i ; vl_size patchSide = 2 * patchResolution + 1 ; float * desc ; VlLiopDesc * liop = vl_liopdesc_new(liopNumNeighbours, liopNumSpatialBins, liopRadius, (vl_size)patchSide) ; if (!vl_is_nan_f(liopIntensityThreshold)) { vl_liopdesc_set_intensity_threshold(liop, liopIntensityThreshold) ; } dimension = vl_liopdesc_get_dimension(liop) ; if (verbose) { mexPrintf("vl_covdet: descriptors: type=liop, " "resolution=%d, extent=%g, smoothing=%g\n", patchResolution, patchRelativeExtent, patchRelativeSmoothing); } OUT(DESCRIPTORS) = mxCreateNumericMatrix(dimension, numFeatures, mxSINGLE_CLASS, mxREAL); desc = mxGetData(OUT(DESCRIPTORS)) ; vl_tic(); for(i = 0; i < (signed)numFeatures; i++){ vl_covdet_extract_patch_for_frame(covdet, patch, patchResolution, patchRelativeExtent, patchRelativeSmoothing, feature[i].frame); vl_liopdesc_process(liop, desc, patch); desc += dimension; } mexPrintf("time: %f\n",vl_toc()); mexPrintf("threshold: %f\n",liop->intensityThreshold); break; } default: assert(0) ; /* descriptor type */ } } if (nout >= 3) { vl_index i ; vl_size numFeatures = vl_covdet_get_num_features(covdet) ; VlCovDetFeature const * feature = vl_covdet_get_features(covdet); const char* names[] = { "gss", "css", "peakScores", "edgeScores", "orientationScore", "laplacianScaleScore" }; mxArray * gss_array = _createArrayFromScaleSpace(vl_covdet_get_gss(covdet)) ; mxArray * css_array = _createArrayFromScaleSpace(vl_covdet_get_css(covdet)) ; mxArray * peak_array = mxCreateNumericMatrix(1,numFeatures,mxSINGLE_CLASS,mxREAL) ; mxArray * edge_array = mxCreateNumericMatrix(1,numFeatures,mxSINGLE_CLASS,mxREAL) ; mxArray * orientation_array = mxCreateNumericMatrix(1,numFeatures,mxSINGLE_CLASS,mxREAL) ; mxArray * laplacian_array = mxCreateNumericMatrix(1,numFeatures,mxSINGLE_CLASS,mxREAL) ; float * peak = mxGetData(peak_array) ; float * edge = mxGetData(edge_array) ; float * orientation = mxGetData(orientation_array) ; float * laplacian = mxGetData(laplacian_array) ; for (i = 0 ; i < (signed)numFeatures ; ++i) { peak[i] = feature[i].peakScore ; edge[i] = feature[i].edgeScore ; orientation[i] = feature[i].orientationScore ; laplacian[i] = feature[i].laplacianScaleScore ; } OUT(INFO) = mxCreateStructMatrix(1, 1, 6, names) ; mxSetFieldByNumber(OUT(INFO), 0, 0, gss_array) ; mxSetFieldByNumber(OUT(INFO), 0, 1, css_array) ; mxSetFieldByNumber(OUT(INFO), 0, 2, peak_array) ; mxSetFieldByNumber(OUT(INFO), 0, 3, edge_array) ; mxSetFieldByNumber(OUT(INFO), 0, 4, orientation_array) ; mxSetFieldByNumber(OUT(INFO), 0, 5, laplacian_array) ; } /* cleanup */ vl_covdet_delete (covdet) ; } if (patchXY) mxFree(patchXY) ; if (patch) mxFree(patch) ; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { bool isError; thread_policy_flavor_t flavorConstant; int flavorPolicySize, flavorPolicySizeBytes, kernError; task_t threadID; thread_policy_t threadPolicy; mach_msg_type_number_t policySizeFilled; boolean_t isDefault, getDefault; char commandString[COMMAND_STRING_LENGTH]; // for return structure // ...outer const char *outerNames[] = {"threadID", "flavor", "policy", "policySize", "policyFillSize", "getDefault", "isDefault"}; int numOuterDims=2, numOuterFields=7; int outerDims[2]={1,1}; // ...inner const char *standardNames[] = {"no_data"}; int numInnerFieldsStandard= 1; /* const char *extendedNames[] = {"timeshare"}; int numInnerFieldsExtended= 1; */ const char *timeConstraintNames[]= {"period", "computation", "constraint", "preemptible"}; int numInnerFieldsTimeConstraint= 4; const char *precedenceNames[]= {"imporantance"}; int numInnerFieldsPrecedence= 1; int numInnerDims=2; int innerDims[2]={1,1}; // ...both mxArray *tempFieldValue, *innerStruct, *outerStruct; //get the policy flavor constant specified by the user and the getDefault argument if(nrhs<2 || nrhs > 2) mexErrMsgTxt("MachGetPriorityMex requires two input arguments. See help MachGetPriorityMex."); if(!mxIsChar(prhs[0])) mexErrMsgTxt("First input argument is not a string. See help MachGetPriorityMex."); mxGetString(prhs[0], commandString, COMMAND_STRING_LENGTH); isError=GetFlavorConstantFromFlavorString(commandString, mxGetM(prhs[0]) * mxGetN(prhs[0]), &flavorConstant); //case sensitive. if(isError) mexErrMsgTxt("Unrecognized command. See help MachGetPriorityMex."); if(!(mxIsDouble(prhs[1]) || mxIsLogical(prhs[1])) || mxGetN(prhs[1]) * mxGetM(prhs[1]) != 1) mexErrMsgTxt("Second argument must be 1x1 logical or double value. See help MachGetPriorityMex."); if(mxIsLogical(prhs[1])) getDefault= (boolean_t)mxGetLogicals(prhs[1])[0]; if(mxIsDouble(prhs[1])) getDefault= (boolean_t)mxGetPr(prhs[1])[0]; //read the priority settings switch(flavorConstant){ case THREAD_STANDARD_POLICY: flavorPolicySizeBytes=sizeof(thread_standard_policy_data_t); flavorPolicySize=THREAD_STANDARD_POLICY_COUNT; break; case THREAD_TIME_CONSTRAINT_POLICY: flavorPolicySizeBytes=sizeof(thread_time_constraint_policy_data_t); flavorPolicySize=THREAD_TIME_CONSTRAINT_POLICY_COUNT; break; case THREAD_PRECEDENCE_POLICY: flavorPolicySizeBytes=sizeof(thread_precedence_policy_data_t); flavorPolicySize=THREAD_PRECEDENCE_POLICY_COUNT; break; } threadPolicy=(thread_policy_t)malloc(flavorPolicySizeBytes); threadID= mach_thread_self(); policySizeFilled=flavorPolicySize; isDefault=getDefault; kernError=thread_policy_get(threadID, flavorConstant, threadPolicy, &policySizeFilled, &isDefault); //create and populate the return structure outerStruct= mxCreateStructArray(numOuterDims, outerDims, numOuterFields, outerNames); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]=(double)threadID; mxSetField(outerStruct, 0, "threadID", tempFieldValue); tempFieldValue= mxCreateString(commandString); mxSetField(outerStruct, 0, "flavor", tempFieldValue); switch(flavorConstant){ case THREAD_STANDARD_POLICY: innerStruct= mxCreateStructArray(numInnerDims, innerDims, numInnerFieldsStandard, standardNames); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]= (double)((thread_standard_policy_t)threadPolicy)->no_data; mxSetField(innerStruct, 0, "no_data", tempFieldValue); break; /* THREAD_EXTENDED_POLICY is equal to THREAD_STANDARD_POLICY. Also, THREAD_EXTENDED_POLICY is undocumented. So we ignore it. case THREAD_EXTENDED_POLICY: innerStruct= mxCreateStructArray(numInnerDims, innerDims, numInnerFieldsExtended, extendedNames); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]= (double)((thread_extended_policy_t)threadPolicy)->timeshare; mxSetField(innerStruct, 1, "timeshare", tempFieldValue); break; */ case THREAD_TIME_CONSTRAINT_POLICY: innerStruct= mxCreateStructArray(numInnerDims, innerDims, numInnerFieldsTimeConstraint, timeConstraintNames); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]= (double)((thread_time_constraint_policy_t)threadPolicy)->period; mxSetField(innerStruct, 0, "period", tempFieldValue); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]= (double)((thread_time_constraint_policy_t)threadPolicy)->computation; mxSetField(innerStruct, 0, "computation", tempFieldValue); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]= (double)((thread_time_constraint_policy_t)threadPolicy)->constraint; mxSetField(innerStruct, 0, "constraint", tempFieldValue); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]= (double)((thread_time_constraint_policy_t)threadPolicy)->preemptible; mxSetField(innerStruct, 0, "preemptible", tempFieldValue); break; case THREAD_PRECEDENCE_POLICY: innerStruct= mxCreateStructArray(numInnerDims, innerDims, numInnerFieldsPrecedence, precedenceNames); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]= (double)((thread_precedence_policy_t)threadPolicy)->importance; mxSetField(innerStruct, 0, "imporantance", tempFieldValue); break; } mxSetField(outerStruct,0, "policy", innerStruct); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]=flavorPolicySize; mxSetField(outerStruct, 0, "policySize", tempFieldValue); tempFieldValue= mxCreateDoubleMatrix(1,1,mxREAL); mxGetPr(tempFieldValue)[0]=policySizeFilled; mxSetField(outerStruct, 0, "policyFillSize", tempFieldValue); tempFieldValue= mxCreateLogicalMatrix(1, 1); mxGetLogicals(tempFieldValue)[0]=(bool)getDefault; mxSetField(outerStruct, 0, "getDefault", tempFieldValue); tempFieldValue= mxCreateLogicalMatrix(1, 1); mxGetLogicals(tempFieldValue)[0]=(bool)isDefault; mxSetField(outerStruct, 0, "isDefault", tempFieldValue); plhs[0]=outerStruct; free((void*)threadPolicy); }
/** the gateway function */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* [t, b] = ddm_rand_full(mu, sig2, b_lo, b_up, delta_t, n[, inv_leak[, seed]]) */ /* Check argument number */ if (nlhs != 2) { mexErrMsgIdAndTxt("ddm_rand_full:WrongOutputs", "Wrong number of output arguments"); } if (nrhs < 6) { mexErrMsgIdAndTxt("ddm_rand_full:WrongInputs", "Too few input arguments"); } /* Process first 8 arguments */ if (!MEX_ARGIN_IS_REAL_VECTOR(0)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "First input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(1)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Second input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(2)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Third input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(3)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Fourth input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_DOUBLE(4)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Fifth input argument expected to be a double"); if (!MEX_ARGIN_IS_REAL_DOUBLE(5)) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "Sixth input argument expected to be a double"); if (nrhs >= 7 && !MEX_ARGIN_IS_REAL_DOUBLE(6)) mexErrMsgIdAndTxt("ddm_rand_sym:WrongInput", "Seventh input argument expected to be a double"); if (nrhs >= 8 && !MEX_ARGIN_IS_REAL_DOUBLE(7)) mexErrMsgIdAndTxt("ddm_rand_sym:WrongInput", "Eighth input argument expected to be a double"); int mu_size = std::max(mxGetN(prhs[0]), mxGetM(prhs[0])); int sig2_size = std::max(mxGetN(prhs[1]), mxGetM(prhs[1])); int b_lo_size = std::max(mxGetN(prhs[2]), mxGetM(prhs[2])); int b_up_size = std::max(mxGetN(prhs[3]), mxGetM(prhs[3])); ExtArray mu(ExtArray::shared_noowner(mxGetPr(prhs[0])), mu_size); ExtArray sig2(ExtArray::shared_noowner(mxGetPr(prhs[1])), sig2_size); ExtArray b_lo(ExtArray::shared_noowner(mxGetPr(prhs[2])), b_lo_size); ExtArray b_up(ExtArray::shared_noowner(mxGetPr(prhs[3])), b_up_size); ExtArray b_lo_deriv = ExtArray::const_array(0.0); ExtArray b_up_deriv = ExtArray::const_array(0.0); double delta_t = mxGetScalar(prhs[4]); int n = (int) mxGetScalar(prhs[5]); if (delta_t <= 0.0) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "delta_t needs to be larger than 0.0"); if (n <= 0) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "n needs to be larger than 1"); bool has_leak = false; double inv_leak = 0.0; if (nrhs >= 7) { inv_leak = mxGetScalar(prhs[6]); has_leak = (inv_leak != 0.0); if (inv_leak < 0.0) mexErrMsgIdAndTxt("ddm_rand_full:WrongInput", "inv_leak needs to be non-negative"); } int rngseed = 0; if (nrhs >= 8) rngseed = (int) mxGetScalar(prhs[7]); if (nrhs > 8) mexErrMsgIdAndTxt("ddm_rand_full:WrongInputs", "Too many input arguments"); /* reserve space for output */ plhs[0] = mxCreateDoubleMatrix(1, n, mxREAL); plhs[1] = mxCreateLogicalMatrix(1, n); double* t = mxGetPr(plhs[0]); mxLogical* b = mxGetLogicals(plhs[1]); /* perform sampling */ DMBase* dm = nullptr; if (has_leak) dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t, inv_leak); else dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t); DMBase::rngeng_t rngeng; if (rngseed == 0) rngeng.seed(std::random_device()()); else rngeng.seed(rngseed); for (int i = 0; i < n; ++i) { DMSample s = dm->rand(rngeng); t[i] = s.t(); b[i] = s.upper_bound() ? 1 : 0; } delete dm; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { omp_set_num_threads(MAX_NUM_THREADS); // Extract input information uint32_t* users = (uint32_t*)mxGetData(prhs[0]); mwSize numExamples = mxGetM(prhs[0]); uint32_t* items = (uint32_t*)mxGetData(prhs[1]); const mxArray* samples = prhs[2]; // Extract number of samples mwSize numSamples = mxGetM(samples); mwSize dimN = mxGetN(samples); if(dimN > numSamples) numSamples = dimN; int KU = mxGetM(mxGetField(samples, 0, "logthetaU")); int KM = mxGetM(mxGetField(samples, 0, "logthetaM")); int numFacs = mxGetM(mxGetField(samples, 0, "a")); int numUsers = mxGetN(mxGetField(samples, 0, "a")); int numItems = mxGetN(mxGetField(samples, 0, "b")); int numTopicFacs = mxGetM(mxGetField(samples, 0, "LambdaTildeU")); uint32_t* zU = (uint32_t*)mxGetData(prhs[3]); uint32_t* zM = (uint32_t*)mxGetData(prhs[4]); mxLogical* add = mxGetLogicals(prhs[5]); mxLogical addBase = add[0]; mxLogical addTopicFactors = add[1]; mxLogical addBiases = add[2]; // Prepare output // New array auto-initialized to zeros plhs[0] = mxCreateDoubleMatrix(numExamples, 1, mxREAL); double* preds = mxGetPr(plhs[0]); int blasStride = 1; for(int t = 0; t < numSamples; t++){ double* logthetaU = mxGetPr(mxGetField(samples, t, "logthetaU")); double* logthetaM = mxGetPr(mxGetField(samples, t, "logthetaM")); double* a = mxGetPr(mxGetField(samples, t, "a")); double* b = mxGetPr(mxGetField(samples, t, "b")); double* c = mxGetPr(mxGetField(samples, t, "c")); double* d = mxGetPr(mxGetField(samples, t, "d")); double* xi = mxGetPr(mxGetField(samples, t, "xi")); double* chi = mxGetPr(mxGetField(samples, t, "chi")); // Incorporate MF prediction and biases #pragma omp parallel for for(mwSize e = 0; e < numExamples; e++){ int u = users[e]-1; int j = items[e]-1; double* cVec = c + numTopicFacs*u; double* dVec = d + numTopicFacs*j; int numTopicFacsTimesNumUsers = numTopicFacs*numUsers; int numTopicFacsTimesNumItems = numTopicFacs*numItems; // Form prediction if(addBase){ preds[e] += ddot(&numFacs, a + numFacs*u, &blasStride, b + numFacs*j, &blasStride); } if(addTopicFactors && (numTopicFacs > 0) && (KU > 0) && (KM > 0)){ if(zU != NULL && zM != NULL){ // Use provided topics preds[e] += ddot(&numTopicFacs, cVec+ numTopicFacsTimesNumUsers*(zM[e]-1), &blasStride, dVec+numTopicFacsTimesNumItems*(zU[e]-1), &blasStride); } else{ // Integrate over topics preds[e] += integrateFactorVectors(cVec, dVec, logthetaU + u*KU, logthetaM + j*KM, numTopicFacs, numTopicFacsTimesNumUsers, numTopicFacsTimesNumItems, KU, KM); } } if(addBiases){ preds[e] += xi[u] + chi[j]; } } } if(numSamples > 1){ // Average over all sample predictions for(mwSize e = 0; e < numExamples; e++) preds[e] /= numSamples; } }
//------------------------------------------------------------------- void mexFunction(int POutputCount, mxArray* POutput[], int PInputCount, const mxArray *PInputs[]) { const int *SZ; double* LInput; double* LInputI; double* LOutputSum; double* LOutputSumI; double* LOutputCount; double* LOutputSum2; double* LOutputSum4; double x, x2; unsigned long LCount, LCountI; double LSum, LSum2, LSum4; unsigned DIM = 0; unsigned long D1, D2, D3; // NN; // unsigned ND, ND2; // number of dimensions: input, output unsigned long ix1, ix2; // index to input and output unsigned j, k, l; // running indices int *SZ2; // size of output // check for proper number of input and output arguments if ((PInputCount <= 0) || (PInputCount > 2)) mexErrMsgTxt("SumSkipNan.MEX requires 1 or 2 arguments."); if (POutputCount > 4) mexErrMsgTxt("SumSkipNan.MEX has 1 to 4 output arguments."); // get 1st argument if(mxIsDouble(PInputs[0])) LInput = mxGetPr(PInputs[0]); else mexErrMsgTxt("First argument must be DOUBLE."); if(mxIsLogical(PInputs[0])) LInput = (double*)mxGetLogicals(PInputs[0]); else if(mxIsNumeric(PInputs[0])) LInput = mxGetPr(PInputs[0]); else if(mxIsSparse(PInputs[0])) LInput = mxGetPr(PInputs[0]); else if(mxIsInt8(PInputs[0])) LInput = (double *)mxGetData(PInputs[0]); else if(mxIsUint8(PInputs[0])) LInput = (double *)mxGetData(PInputs[0]); else if(mxIsInt16(PInputs[0])) LInput = (double *)mxGetData(PInputs[0]); else if(mxIsUint16(PInputs[0])) LInput = (double *)mxGetData(PInputs[0]); else if(mxIsInt32(PInputs[0])) LInput = (double *)mxGetData(PInputs[0]); else if(mxIsUint32(PInputs[0])) LInput = (double *)mxGetData(PInputs[0]); else mexErrMsgTxt("First argument must be NUMERIC."); if(mxIsComplex(PInputs[0])) LInputI = mxGetPi(PInputs[0]); if(mxIsComplex(PInputs[0]) & (POutputCount > 3)) mexErrMsgTxt("More than 3 output arguments only supported for REAL data "); // get 2nd argument if (PInputCount == 2){ switch (mxGetNumberOfElements(PInputs[1])) { case 0: x = 0.0; // accept empty element break; case 1: x = (mxIsNumeric(PInputs[1]) ? mxGetScalar(PInputs[1]) : -1.0); break; default:x = -1.0; // invalid } if ((x < 0) || (x > 65535) || (x != floor(x))) mexErrMsgTxt("Error SUMSKIPNAN.MEX: DIM-argument must be a positive integer scalar"); DIM = (unsigned)floor(x); } // get size ND = mxGetNumberOfDimensions(PInputs[0]); // NN = mxGetNumberOfElements(PInputs[0]); SZ = mxGetDimensions(PInputs[0]); // if DIM==0 (undefined), look for first dimension with more than 1 element. for (k = 0; (DIM < 1) && (k < ND); k++) if (SZ[k]>1) DIM = k+1; if (DIM < 1) DIM=1; // in case DIM is still undefined ND2 = (ND>DIM ? ND : DIM); // number of dimensions of output SZ2 = (int*)mxCalloc(ND2, sizeof(int)); // allocate memory for output size for (j=0; j<ND; j++) // copy size of input; SZ2[j] = SZ[j]; for (j=ND; j<ND2; j++) // in case DIM > ND, add extra elements 1 SZ2[j] = 1; for (j=0, D1=1; j<DIM-1; D1=D1*SZ2[j++]); // D1 is the number of elements between two elements along dimension DIM D2 = SZ2[DIM-1]; // D2 contains the size along dimension DIM for (j=DIM, D3=1; j<ND; D3=D3*SZ2[j++]); // D3 is the number of blocks containing D1*D2 elements SZ2[DIM-1] = 1; // size of output is same as size of input but SZ(DIM)=1; // create outputs #define TYP mxDOUBLE_CLASS if(mxIsComplex(PInputs[0])) { POutput[0] = mxCreateNumericArray(ND2, SZ2, TYP, mxCOMPLEX); LOutputSum = mxGetPr(POutput[0]); LOutputSumI= mxGetPi(POutput[0]); } else { POutput[0] = mxCreateNumericArray(ND2, SZ2, TYP, mxREAL); LOutputSum = mxGetPr(POutput[0]); } if (POutputCount >= 2){ POutput[1] = mxCreateNumericArray(ND2, SZ2, TYP, mxREAL); LOutputCount = mxGetPr(POutput[1]); } if (POutputCount >= 3){ POutput[2] = mxCreateNumericArray(ND2, SZ2, TYP, mxREAL); LOutputSum2 = mxGetPr(POutput[2]); } if (POutputCount >= 4){ POutput[3] = mxCreateNumericArray(ND2, SZ2, TYP, mxREAL); LOutputSum4 = mxGetPr(POutput[3]); } mxFree(SZ2); // OUTER LOOP: along dimensions > DIM for (l = 0; l<D3; l++) { ix2 = l*D1; // index for output ix1 = ix2*D2; // index for input // Inner LOOP: along dimensions < DIM for (k = 0; k<D1; k++, ix1++, ix2++) { LCount = 0; LSum = 0.0; LSum2 = 0.0; LSum4 = 0.0; // LOOP along dimension DIM for (j=0; j<D2; j++) { x = LInput[ix1 + j*D1]; if (!mxIsNaN(x)) { LCount++; LSum += x; x2 = x*x; LSum2 += x2; LSum4 += x2*x2; } } LOutputSum[ix2] = LSum; if (POutputCount >= 2) LOutputCount[ix2] = (double)LCount; if (POutputCount >= 3) LOutputSum2[ix2] = LSum2; if (POutputCount >= 4) LOutputSum4[ix2] = LSum4; if(mxIsComplex(PInputs[0])) { LSum = 0.0; LCountI = 0; LSum2 = 0.0; for (j=0; j<D2; j++) { x = LInputI[ix1 + j*D1]; if (!mxIsNaN(x)) { LCountI++; LSum += x; LSum2 += x*x; } } LOutputSumI[ix2] = LSum; if (LCount != LCountI) mexErrMsgTxt("Number of NaNs is different for REAL and IMAG part"); if (POutputCount >= 3) LOutputSum2[ix2] += LSum2; } } } }