unsigned int sf_Automat_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3346104985U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2292149139U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(896709456U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3686958539U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2089999033U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(941296165U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3620454784U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(665239257U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_Automat_get_check_sum(mxArray *plhs[]); sf_c1_Automat_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3564696471U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(678668628U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1090454852U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3896867807U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3437021989U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1199552135U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2842795639U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(692071385U); } return 1; #else return 0; #endif }
void mexFunction(int nlhs,mxArray *plhs[],int nrhs,const mxArray *prhs[]) { short fh; WORD chan; long maxpoints; TSTime sTime; TSTime eTime; TpFilterMask pFltMask=NULL; TFilterMask FilterMask; long npoints=0; TMarker Markers[32767]; short levLow; unsigned char *ptr; int dim[2]={1,1}; double *p; long *ret; int i,j; //Used for filter int m,n; const int *empty[2]={0,0}; if (nrhs<5) mexErrMsgTxt("SONGetMarkData: Too few arguments\n"); //Get input arguments fh=mxGetScalar(prhs[0]); //File handle chan=mxGetScalar(prhs[1]); //Channel number maxpoints=mxGetScalar(prhs[2]); //maxpoints if ((maxpoints>32767) || (maxpoints<=0)) maxpoints=32767; sTime=mxGetScalar(prhs[3]); //Start time for data search eTime=mxGetScalar(prhs[4]); //End Time for data search //Get and set up the filter mask if (nrhs==6 && mxIsStruct(prhs[5])==1){ GetFilterMask(prhs[5], &FilterMask); pFltMask=&FilterMask; } else pFltMask=NULL; //Load and get pointer to the library SON32.DLL// hinstLib = LoadLibrary(SON32); if (hinstLib == NULL){ mexPrintf("%s not found",SON32); plhs[0]=mxCreateNumericArray(2, dim, mxINT32_CLASS, mxREAL); p=mxGetData(plhs[0]); p[0]=SON_BAD_PARAM; return; } //Call DLL npoints=_SONGetMarkData(fh, chan, &Markers, maxpoints, sTime, eTime, pFltMask); fFreeResult = FreeLibrary(hinstLib); //return results. This one goes in ans if no arguments dim[0]=1; dim[1]=1; plhs[0]=mxCreateNumericArray(2, dim, mxINT32_CLASS, mxREAL); ret=mxGetData(plhs[0]); *ret=npoints; if (nlhs>=2) { dim[0]=max(0,npoints); plhs[1]=mxCreateNumericArray(2, dim, mxINT32_CLASS, mxREAL); ret=mxGetData(plhs[1]); for (i=0; i<npoints; i++) *ret++=Markers[i].mark; } if (nlhs==3) { dim[1]=4; dim[0]=max(0,npoints); plhs[2]=mxCreateNumericArray(2, dim, mxUINT8_CLASS, mxREAL); ptr=mxGetData(plhs[2]); for (j=0; j<4; j++) for(i=0; i<npoints; i++) *ptr++=Markers[i].mvals[j]; } }
unsigned int sf_mainSim_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(13515316U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(833989788U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2260018523U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(850705350U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(888113858U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2849162545U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(124305733U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1606849013U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_mainSim_get_check_sum(mxArray *plhs[]); sf_c1_mainSim_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3564696471U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(678668628U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1090454852U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3896867807U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3921995900U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2346178767U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2268642723U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2571770906U); } return 1; #else return 0; #endif }
// [E,ind,segs] = mexFunction(model,I,chns,chnsSs) - helper for edgesDetect.m void mexFunction( int nl, mxArray *pl[], int nr, const mxArray *pr[] ) { // get inputs mxArray *model = (mxArray*) pr[0]; float *I = (float*) mxGetData(pr[1]); float *chns = (float*) mxGetData(pr[2]); float *chnsSs = (float*) mxGetData(pr[3]); // extract relevant fields from model and options float *thrs = (float*) mxGetData(mxGetField(model,0,"thrs")); uint32 *fids = (uint32*) mxGetData(mxGetField(model,0,"fids")); uint32 *child = (uint32*) mxGetData(mxGetField(model,0,"child")); uint8 *segs = (uint8*) mxGetData(mxGetField(pr[0],0,"segs")); uint8 *nSegs = (uint8*) mxGetData(mxGetField(pr[0],0,"nSegs")); uint16 *eBins = (uint16*) mxGetData(mxGetField(model,0,"eBins")); uint32 *eBnds = (uint32*) mxGetData(mxGetField(model,0,"eBnds")); mxArray *opts = mxGetField(model,0,"opts"); const int shrink = (int) mxGetScalar(mxGetField(opts,0,"shrink")); const int imWidth = (int) mxGetScalar(mxGetField(opts,0,"imWidth")); const int gtWidth = (int) mxGetScalar(mxGetField(opts,0,"gtWidth")); const int nChns = (int) mxGetScalar(mxGetField(opts,0,"nChns")); const int nCells = (int) mxGetScalar(mxGetField(opts,0,"nCells")); const uint32 nChnFtrs = (uint32) mxGetScalar(mxGetField(opts,0,"nChnFtrs")); const int stride = (int) mxGetScalar(mxGetField(opts,0,"stride")); const int nTreesEval = (int) mxGetScalar(mxGetField(opts,0,"nTreesEval")); int sharpen = (int) mxGetScalar(mxGetField(opts,0,"sharpen")); int nThreads = (int) mxGetScalar(mxGetField(opts,0,"nThreads")); const int nBnds = int(mxGetNumberOfElements(mxGetField(model,0,"eBnds"))-1)/ int(mxGetNumberOfElements(mxGetField(model,0,"thrs"))); const char *msgSharpen="Model supports sharpening of at most %i pixels!\n"; if( sharpen>nBnds-1 ) { sharpen=nBnds-1; mexPrintf(msgSharpen,sharpen); } // get dimensions and constants const mwSize *imgSize = mxGetDimensions(pr[1]); const int h = (int) imgSize[0]; const int w = (int) imgSize[1]; const int Z = mxGetNumberOfDimensions(pr[1])<=2 ? 1 : imgSize[2]; const mwSize *fidsSize = mxGetDimensions(mxGetField(model,0,"fids")); const int nTreeNodes = (int) fidsSize[0]; const int nTrees = (int) fidsSize[1]; const int h1 = (int) ceil(double(h-imWidth)/stride); const int w1 = (int) ceil(double(w-imWidth)/stride); const int h2 = h1*stride+gtWidth; const int w2 = w1*stride+gtWidth; const int imgDims[3] = {h,w,Z}; const int chnDims[3] = {h/shrink,w/shrink,nChns}; const int indDims[3] = {h1,w1,nTreesEval}; const int outDims[3] = {h2,w2,1}; const int segDims[5] = {gtWidth,gtWidth,h1,w1,nTreesEval}; // construct lookup tables uint32 *iids, *eids, *cids, *cids1, *cids2; iids = buildLookup( (int*)imgDims, gtWidth ); eids = buildLookup( (int*)outDims, gtWidth ); cids = buildLookup( (int*)chnDims, imWidth/shrink ); buildLookupSs( cids1, cids2, (int*)chnDims, imWidth/shrink, nCells ); // create outputs pl[0] = mxCreateNumericArray(3,outDims,mxSINGLE_CLASS,mxREAL); float *E = (float*) mxGetData(pl[0]); pl[1] = mxCreateNumericArray(3,indDims,mxUINT32_CLASS,mxREAL); uint32 *ind = (uint32*) mxGetData(pl[1]); if(nl>2) pl[2] = mxCreateNumericArray(5,segDims,mxUINT8_CLASS,mxREAL); uint8 *segsOut; if(nl>2) segsOut = (uint8*) mxGetData(pl[2]); // apply forest to all patches and store leaf inds #ifdef USEOMP nThreads = min(nThreads,omp_get_max_threads()); #pragma omp parallel for num_threads(nThreads) #endif for( int c=0; c<w1; c++ ) for( int t=0; t<nTreesEval; t++ ) { for( int r0=0; r0<2; r0++ ) for( int r=r0; r<h1; r+=2 ) { int o = (r*stride/shrink) + (c*stride/shrink)*h/shrink; // select tree to evaluate int t1 = ((r+c)%2*nTreesEval+t)%nTrees; uint32 k = t1*nTreeNodes; while( child[k] ) { // compute feature (either channel or self-similarity feature) uint32 f = fids[k]; float ftr; if( f<nChnFtrs ) ftr = chns[cids[f]+o]; else ftr = chnsSs[cids1[f-nChnFtrs]+o]-chnsSs[cids2[f-nChnFtrs]+o]; // compare ftr to threshold and move left or right accordingly if( ftr < thrs[k] ) k = child[k]-1; else k = child[k]; k += t1*nTreeNodes; } // store leaf index and update edge maps ind[ r + c*h1 + t*h1*w1 ] = k; } } // compute edge maps (avoiding collisions from parallel executions) if( !sharpen ) for( int c0=0; c0<gtWidth/stride; c0++ ) { #ifdef USEOMP #pragma omp parallel for num_threads(nThreads) #endif for( int c=c0; c<w1; c+=gtWidth/stride ) { for( int r=0; r<h1; r++ ) for( int t=0; t<nTreesEval; t++ ) { uint32 k = ind[ r + c*h1 + t*h1*w1 ]; float *E1 = E + (r*stride) + (c*stride)*h2; int b0=eBnds[k*nBnds], b1=eBnds[k*nBnds+1]; if(b0==b1) continue; for( int b=b0; b<b1; b++ ) E1[eids[eBins[b]]]++; if(nl>2) memcpy(segsOut+(r+c*h1+t*h1*w1)*gtWidth*gtWidth, segs+k*gtWidth*gtWidth,gtWidth*gtWidth*sizeof(uint8)); } } } // computed sharpened edge maps, snapping to local color values if( sharpen ) { // compute neighbors array const int g=gtWidth; uint16 N[4096*4]; for( int c=0; c<g; c++ ) for( int r=0; r<g; r++ ) { int i=c*g+r; uint16 *N1=N+i*4; N1[0] = c>0 ? i-g : i; N1[1] = c<g-1 ? i+g : i; N1[2] = r>0 ? i-1 : i; N1[3] = r<g-1 ? i+1 : i; } #ifdef USEOMP #pragma omp parallel for num_threads(nThreads) #endif for( int c=0; c<w1; c++ ) for( int r=0; r<h1; r++ ) { for( int t=0; t<nTreesEval; t++ ) { // get current segment and copy into S uint32 k = ind[ r + c*h1 + t*h1*w1 ]; int m = nSegs[k]; if( m==1 ) continue; uint8 S0[4096], *S=(nl<=2) ? S0 : segsOut+(r+c*h1+t*h1*w1)*g*g; memcpy(S,segs+k*g*g, g*g*sizeof(uint8)); // compute color model for each segment using every other pixel int ci, ri, s, z; float ns[100], mus[1000]; const float *I1 = I+(c*stride+(imWidth-g)/2)*h+r*stride+(imWidth-g)/2; for( s=0; s<m; s++ ) { ns[s]=0; for( z=0; z<Z; z++ ) mus[s*Z+z]=0; } for( ci=0; ci<g; ci+=2 ) for( ri=0; ri<g; ri+=2 ) { s = S[ci*g+ri]; ns[s]++; for( z=0; z<Z; z++ ) mus[s*Z+z]+=I1[z*h*w+ci*h+ri]; } for(s=0; s<m; s++) for( z=0; z<Z; z++ ) mus[s*Z+z]/=ns[s]; // update segment S according to local color values int b0=eBnds[k*nBnds], b1=eBnds[k*nBnds+sharpen]; for( int b=b0; b<b1; b++ ) { float vs[10], d, e, eBest=1e10f; int i, sBest=-1, ss[4]; for( i=0; i<4; i++ ) ss[i]=S[N[eBins[b]*4+i]]; for( z=0; z<Z; z++ ) vs[z]=I1[iids[eBins[b]]+z*h*w]; for( i=0; i<4; i++ ) { s=ss[i]; if(s==sBest) continue; e=0; for( z=0; z<Z; z++ ) { d=mus[s*Z+z]-vs[z]; e+=d*d; } if( e<eBest ) { eBest=e; sBest=s; } } S[eBins[b]]=sBest; } // convert mask to edge maps (examining expanded set of pixels) float *E1 = E + c*stride*h2 + r*stride; b1=eBnds[k*nBnds+sharpen+1]; for( int b=b0; b<b1; b++ ) { int i=eBins[b]; uint8 s=S[i]; uint16 *N1=N+i*4; if( s!=S[N1[0]] || s!=S[N1[1]] || s!=S[N1[2]] || s!=S[N1[3]] ) E1[eids[i]]++; } } } } // free memory delete [] iids; delete [] eids; delete [] cids; delete [] cids1; delete [] cids2; }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { // get inputs float *chns = (float*) mxGetData(prhs[0]); float *chnsSs = (float*) mxGetData(prhs[1]); float *thrs = (float*) mxGetData(prhs[2]); uint32 *fids = (uint32*) mxGetData(prhs[3]); uint32 *child = (uint32*) mxGetData(prhs[4]); float *distr = (float*) mxGetData(prhs[5]);// uint32 *cids1 = (uint32*) mxGetData(prhs[6]); uint32 *cids2 = (uint32*) mxGetData(prhs[7]); const int stride = (int) mxGetScalar(prhs[8]);// 2 const int rad = (int) mxGetScalar(prhs[9]);//17 const int nChnFtrs = (int) mxGetScalar(prhs[10]);//17150 // get dimensions and constants const mwSize *chnsSize = mxGetDimensions(prhs[0]); const int height = (int) chnsSize[0];//634 const int width = (int) chnsSize[1];//434 const mwSize *distrSize = mxGetDimensions(prhs[5]); const int nTokens = (int) distrSize[0];// const int nTreeNodes = (int) distrSize[1];// const int nTrees = (int) distrSize[2];// const int heightOut = (int) ceil((height-rad*2.0)/stride); const int widthOut = (int) ceil((width-rad*2.0)/stride); // create output const int outDims[3]={nTokens,heightOut,widthOut}; float *S = (float*) mxCalloc(nTokens*heightOut*widthOut,sizeof(float)); plhs[0] = mxCreateNumericMatrix(0,0,mxSINGLE_CLASS,mxREAL); mxSetData(plhs[0],S); mxSetDimensions(plhs[0],outDims,3); // apply forest to each patch #pragma omp parallel for for( int c=0; c<widthOut; c++ ) { for( int r=0; r<heightOut; r++ ) { // classify a single patch using all trees float *chns1 = chns + (r*stride) + (c*stride)*height; float *chnsSs1 = chnsSs + (r*stride) + (c*stride)*height; for( int t = 0; t < nTrees; t++ ) { uint32 k = t*nTreeNodes, res; while( child[k] ) { // compute feature (either lookup in channel or self-similarity feature) uint32 f = fids[k], cid1 = cids1[f], cid2 = cids2[f]; float ftr; if( f<nChnFtrs ) ftr = chns1[cid1]; else ftr = chnsSs1[cid1] - chnsSs1[cid2]; // compare ftr to threshold and move left or right accordingly if( ftr < thrs[k] ) k = child[k]-1; else k = child[k]; res = k; k += t*nTreeNodes; } // lookup probability and store results for( int i = 0; i < nTokens; i++ ) { S[r*nTokens + c*heightOut*nTokens + i] += distr[t*nTreeNodes*nTokens + res*nTokens + i]; } } } } }
/* The gateway function */ void mexFunction(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[]) { /* process input from matlab */ /* format: id, r[M][N]; id = the order of the target agent in all input agents In matrix r, each row: (px, py, vx, vy, prx, pry) */ int id; double * arr; double * pr; int row, col; id = mxGetScalar(prhs[0]); row = mxGetM(prhs[1]); col = mxGetN(prhs[1]); arr = mxGetPr(prhs[1]); pr = mxGetPr(prhs[2]); //printf("row = %d\n", row); for (int r = 0; r < row; r ++) { int c = 0; pv elem; elem.x = arr[r + row*(c++)]; elem.y = arr[r + row*(c++)]; elem.vx = arr[r + row*(c++)]; elem.vy = arr[r + row*(c++)]; elem.prx = arr[r + row*(c++)]; elem.pry = arr[r + row*(c++)]; pvList.push_back(elem); } for (int i = 0; i < NUM_PARAM; i ++) { param[i] = pr[i]; } init(); float x, y, vx, vy; rvo_sim(); // Change name plz! // Get the simualtion results RVO::Vector2 pos, vel, prv; double * o; plhs[0] = mxCreateDoubleMatrix(1, 4*row, mxREAL); o = mxGetPr(plhs[0]); for (int r = 0; r < row; r ++) { // access RVO for results pos = sim->getAgentPosition(r); vel = sim->getAgentVelocity(r); prv = sim->getAgentPrefVelocity(r); x = pos.x(); y = pos.y(); vx = vel.x(); vy = vel.y(); // load output arrays int baseInd = r * 4; o[baseInd] = x; o[baseInd+1] = y; o[baseInd+2] = vx; o[baseInd+3] = vy; } // // Previous code // plhs[0] = mxCreateDoubleMatrix(1, 4, mxREAL); // double * o; // o = mxGetPr(plhs[0]); // o[0] = x; // o[1] = y; // o[2] = vx; // o[3] = vy; destroy(); }
unsigned int sf_test_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2879395541U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3292577648U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3796445781U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3615203250U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2590014158U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3891542480U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2125734249U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1519912872U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_test_get_check_sum(mxArray *plhs[]); sf_c1_test_get_check_sum(plhs); break; } case 2: { extern void sf_c2_test_get_check_sum(mxArray *plhs[]); sf_c2_test_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3061339410U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1991824845U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3599338742U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2357874978U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(4167789182U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(252419955U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3494262876U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(711935334U); } return 1; #else return 0; #endif }
unsigned int sf_IntelligentFlightSystem_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1029893756U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1718458764U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2541882730U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2540130192U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1673257343U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(713078858U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1079295166U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3391332431U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 2: { extern void sf_c2_IntelligentFlightSystem_get_check_sum(mxArray *plhs[]); sf_c2_IntelligentFlightSystem_get_check_sum(plhs); break; } case 6: { extern void sf_c6_IntelligentFlightSystem_get_check_sum(mxArray *plhs[]); sf_c6_IntelligentFlightSystem_get_check_sum(plhs); break; } case 9: { extern void sf_c9_IntelligentFlightSystem_get_check_sum(mxArray *plhs[]); sf_c9_IntelligentFlightSystem_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2515920432U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3908508645U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2530489944U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2924353608U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2793743795U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2713150621U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2962262553U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2433145717U); } return 1; #else return 0; #endif }
/***********************************************************************//** * \brief mexFunction to append a stack to an existing em-file. **************************************************************************/ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) { size_t filename_length = 0; #define __MAX_FILENAME_LENGTH__ ((int)2048) char filename[__MAX_FILENAME_LENGTH__+1]; #define __MAX_S__LENGTH__ (__MAX_FILENAME_LENGTH__+1024) char s[__MAX_S__LENGTH__+1]; tom_io_em_header header; #define __BUFFERLENGTH_SYNOPSIS__ 1024 char synopsis[__BUFFERLENGTH_SYNOPSIS__]; void *data; mxArray *mxData; size_t sizex, sizey, sizez; mxClassID mxType; mxComplexity mxIsComplexVolume; size_t i; int res; int header_read; int allow_conversion = 1; mxArray *plhs_tmp[5] = { NULL, NULL, NULL, NULL, NULL }; snprintf(synopsis, __BUFFERLENGTH_SYNOPSIS__, "[size, magic, comment, emdata, userdata] = %s(filename, volume, [allow_conversion])", mexFunctionName()); if (nrhs==0 && nlhs==0) { /* Print help */ mexPrintf("SYNOPSIS: %s\n", synopsis); mexPrintf("mex-file compiled from file \"" __FILE__ "\" at " __DATE__ ", " __TIME__ ".\n"); return; } if (nrhs < 2 || nrhs > 3) { snprintf(s, __MAX_S__LENGTH__, "%s: call function with up to 3 parameters: %s.", mexFunctionName(), synopsis); mexErrMsgTxt(s); } if (nlhs>5) { snprintf(s, __MAX_S__LENGTH__, "%s: Too many output parameters: %s.", mexFunctionName(), synopsis); mexErrMsgTxt(s); } { const mxArray *PRHS_FILENAME = prhs[0]; const mxArray *PRHS_VOLUME = prhs[1]; const mwSize *size; /* Check input parameters! */ if (!mxIsChar(PRHS_FILENAME) || mxGetNumberOfDimensions(PRHS_FILENAME)!=2 || mxGetM(PRHS_FILENAME)!=1 || (filename_length=mxGetN(PRHS_FILENAME))<1) { snprintf(s, __MAX_S__LENGTH__, "%s: needs the file name as first parameter: %s.", mexFunctionName(), synopsis); mexErrMsgTxt(s); } if (filename_length >= __MAX_FILENAME_LENGTH__) { snprintf(s, __MAX_S__LENGTH__, "%s: Maximal length of file name exceeded. (Recompile with larger buffer :)", mexFunctionName()); mexErrMsgTxt(s); } mxGetString(PRHS_FILENAME, filename, __MAX_FILENAME_LENGTH__); if (!mxIsNumeric(PRHS_VOLUME) || mxGetNumberOfDimensions(PRHS_VOLUME)>3) { snprintf(s, __MAX_S__LENGTH__, "%s: needs a numerical volume as second parameter: %s", mexFunctionName(), synopsis); mexErrMsgTxt(s); } data = mxGetData(PRHS_VOLUME); size = mxGetDimensions(PRHS_VOLUME); mxType = mxGetClassID(PRHS_VOLUME); mxIsComplexVolume = mxIsComplex(PRHS_VOLUME); sizex = size[0]; sizey = size[1]; sizez = mxGetNumberOfDimensions(PRHS_VOLUME)==3 ? size[2] : 1; if (mxIsComplexVolume) { if (mxType==mxSINGLE_CLASS || mxType==mxDOUBLE_CLASS) { mwSize size[3]; size_t x, y, z; size[0] = sizex*2; size[1] = sizey; size[2] = sizez; if (!(mxData = mxCreateNumericArray(sizez==1 ? 2 : 3, size, mxType, mxREAL))) { mexErrMsgTxt("%s: Error allocating temporary buffer for complex data."); } data = mxGetData(mxData); if (mxType == mxSINGLE_CLASS) { float *data_as_real = (float *)data; const float *data_real = (const float *)mxGetData(PRHS_VOLUME); const float *data_complex = (const float *)mxGetImagData(PRHS_VOLUME); for (z=0; z<sizez; z++) { for (y=0; y<sizey; y++) { for (x=0; x<sizex; x++) { *data_as_real++ = *data_real++; *data_as_real++ = *data_complex++; } } } } else { double *data_as_real = (double *)data; const double *data_real = (const double *)mxGetData(PRHS_VOLUME); const double *data_complex = (const double *)mxGetImagData(PRHS_VOLUME); for (z=0; z<sizez; z++) { for (y=0; y<sizey; y++) { for (x=0; x<sizex; x++) { *data_as_real++ = *data_real++; *data_as_real++ = *data_complex++; } } } } } else { snprintf(s, __MAX_S__LENGTH__, "%s: Complex data for this type not supported (currently only for single and double).", mexFunctionName()); mexErrMsgTxt(s); } } if (nrhs >= 3) { mwSize numel; numel = mxGetM(prhs[2]) * mxGetN(prhs[2]); if (!(mxIsNumeric(prhs[2]) || mxIsLogical(prhs[2])) || numel>1) { snprintf(s, __MAX_S__LENGTH__, "%s: allow_conversion must be one of true, false or [].", mexFunctionName(), synopsis); mexErrMsgTxt(s); } if (numel == 1) { allow_conversion = mxGetScalar(prhs[2]) != 0.; } } } { /* Allocate the memory for the ouput, so that in case of successfully writing, no error can happen afterwards in the mexfunction. */ switch (nlhs) { case 5: if (!(plhs_tmp[4] = mxCreateNumericMatrix(1, 256, mxINT8_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); } case 4: if (!(plhs_tmp[3] = mxCreateNumericMatrix(1, 40, mxINT32_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); } case 3: if (!(plhs_tmp[2] = mxCreateNumericMatrix(1, 80, mxINT8_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); } case 2: if (!(plhs_tmp[1] = mxCreateNumericMatrix(1, 4, mxINT8_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); } case 1: if (!(plhs_tmp[0] = mxCreateNumericMatrix(3, 1, mxUINT32_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); } } } res = tom_io_em_write_append_stack(filename, data, getIOTypeFromMxClassID(mxType, mxIsComplexVolume), sizex, sizey, sizez, 0, 0, 0, &header, &header_read, allow_conversion); if (res != TOM_ERR_OK) { if (res ==TOM_ERR_WRITE_FILE) { snprintf(s, __MAX_S__LENGTH__, "%s: IO-error occured. The em-file may now be damaged :(", mexFunctionName()); mexErrMsgTxt(s); } else if (res==TOM_ERR_OPEN_FILE) { snprintf(s, __MAX_S__LENGTH__, "%s: Error opening the file \"%s\" for writing.", mexFunctionName(), filename); mexErrMsgTxt(s); } else if (header_read && res==TOM_ERR_WRONG_IOTYPE_CONVERSION) { snprintf(s, __MAX_S__LENGTH__, "%s: Wrong typeconversion: can not convert volume of type %d to type %d as in the em-file.", mexFunctionName(), getIOTypeFromMxClassID(mxType, mxIsComplexVolume), tom_io_em_get_iotype_header(&header)); mexErrMsgTxt(s); } else if (res == TOM_ERR_IOTYPE_NOT_SUPPORTED) { snprintf(s, __MAX_S__LENGTH__, "%s: Saving data of type %d to em-file is (currently) not supported.", mexFunctionName(), getIOTypeFromMxClassID(mxType, mxIsComplexVolume)); mexErrMsgTxt(s); } else if (header_read && TOM_ERR_WRONG_DATA_SIZE && (sizex!=header.dims[0] || sizey!=header.dims[1])) { snprintf(s, __MAX_S__LENGTH__, "%s: Size mismatch: The volume has dimension %dx%dx%d, but the em-file has size %dx%dx%d.", mexFunctionName(), sizex, sizey, sizez, header.dims[0], header.dims[1], header.dims[2]); mexErrMsgTxt(s); } else { snprintf(s, __MAX_S__LENGTH__, "%s: Unexpected error. Is the \"%s\" a valid em-file? (%d)", mexFunctionName(), filename, res); mexErrMsgTxt(s); } } { /* Construct the output. */ void *pdata; switch (nlhs) { case 5: pdata = mxGetData(plhs[4] = plhs_tmp[4]); for (i=0; i<256; i++) { ((int8_t *)pdata)[i] = header.userdata[i]; } case 4: pdata = mxGetData(plhs[3] = plhs_tmp[3]); for (i=0; i<40; i++) { ((int32_t *)pdata)[i] = header.emdata[i]; } case 3: pdata = mxGetData(plhs[2] = plhs_tmp[2]); for (i=0; i<80; i++) { ((int8_t *)pdata)[i] = header.comment[i]; } case 2: pdata = mxGetData(plhs[1] = plhs_tmp[1]); ((int8_t *)pdata)[0] = header.machine; ((int8_t *)pdata)[1] = header.byte2; ((int8_t *)pdata)[2] = header.byte3; ((int8_t *)pdata)[3] = header.type; case 1: pdata = mxGetData(plhs[0] = plhs_tmp[0]); ((uint32_t *)pdata)[0] = header.dims[0]; ((uint32_t *)pdata)[1] = header.dims[1]; ((uint32_t *)pdata)[2] = header.dims[2]; break; case 0: default: break; } } }
unsigned int sf_IntelligentFlightSystem_autoinheritance_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[32]; char aiChksum[64]; if (nrhs<3 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the autoinheritance_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_autoinheritance_info")) return 0; mxGetString(prhs[2], aiChksum,sizeof(aiChksum)/sizeof(char)); aiChksum[(sizeof(aiChksum)/sizeof(char)-1)] = '\0'; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 2: { if (strcmp(aiChksum, "mJv7tsD6gCcUKINP8Oy5aG") == 0) { extern mxArray *sf_c2_IntelligentFlightSystem_get_autoinheritance_info (void); plhs[0] = sf_c2_IntelligentFlightSystem_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 6: { if (strcmp(aiChksum, "VSxksOs1NLkvwAzXu95Kd") == 0) { extern mxArray *sf_c6_IntelligentFlightSystem_get_autoinheritance_info (void); plhs[0] = sf_c6_IntelligentFlightSystem_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 9: { if (strcmp(aiChksum, "fckvBmBjBT8XA7CcoasVNF") == 0) { extern mxArray *sf_c9_IntelligentFlightSystem_get_autoinheritance_info (void); plhs[0] = sf_c9_IntelligentFlightSystem_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }
unsigned int sf_IntelligentFlightSystem_get_eml_resolved_functions_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[64]; if (nrhs<2 || !mxIsChar(prhs[0])) return 0; /* Possible call to get the get_eml_resolved_functions_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_eml_resolved_functions_info")) return 0; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 2: { extern const mxArray *sf_c2_IntelligentFlightSystem_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c2_IntelligentFlightSystem_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 6: { extern const mxArray *sf_c6_IntelligentFlightSystem_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c6_IntelligentFlightSystem_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 9: { extern const mxArray *sf_c9_IntelligentFlightSystem_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c9_IntelligentFlightSystem_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }
/* the gateway function */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { int i; srslte_cell_t cell; srslte_pdsch_t pdsch; srslte_chest_dl_t chest; srslte_ofdm_t fft; cf_t *input_fft, *input_signal; int nof_re; srslte_pdsch_cfg_t cfg; srslte_softbuffer_rx_t softbuffer; uint32_t rnti32; uint32_t cfi; if (nrhs < NOF_INPUTS) { help(); return; } bzero(&cfg, sizeof(srslte_pdsch_cfg_t)); if (mexutils_read_cell(ENBCFG, &cell)) { help(); return; } if (mexutils_read_uint32_struct(PDSCHCFG, "RNTI", &rnti32)) { mexErrMsgTxt("Field RNTI not found in pdsch config\n"); return; } if (mexutils_read_uint32_struct(ENBCFG, "CFI", &cfi)) { help(); return; } if (mexutils_read_uint32_struct(ENBCFG, "NSubframe", &cfg.sf_idx)) { help(); return; } if (srslte_pdsch_init(&pdsch, cell)) { mexErrMsgTxt("Error initiating PDSCH\n"); return; } srslte_pdsch_set_rnti(&pdsch, (uint16_t) (rnti32 & 0xffff)); if (srslte_softbuffer_rx_init(&softbuffer, cell)) { mexErrMsgTxt("Error initiating soft buffer\n"); return; } if (srslte_chest_dl_init(&chest, cell)) { mexErrMsgTxt("Error initializing equalizer\n"); return; } if (srslte_ofdm_rx_init(&fft, cell.cp, cell.nof_prb)) { mexErrMsgTxt("Error initializing FFT\n"); return; } nof_re = 2 * SRSLTE_CP_NORM_NSYMB * cell.nof_prb * SRSLTE_NRE; cfg.grant.mcs.tbs = mxGetScalar(TBS); if (cfg.grant.mcs.tbs == 0) { mexErrMsgTxt("Error trblklen is zero\n"); return; } if (srslte_cbsegm(&cfg.cb_segm, cfg.grant.mcs.tbs)) { mexErrMsgTxt("Error computing CB segmentation\n"); return; } if (mexutils_read_uint32_struct(PDSCHCFG, "RV", &cfg.rv)) { mexErrMsgTxt("Field RV not found in pdsch config\n"); return; } char *mod_str = mexutils_get_char_struct(PDSCHCFG, "Modulation"); if (!strcmp(mod_str, "QPSK")) { cfg.grant.mcs.mod = SRSLTE_MOD_QPSK; } else if (!strcmp(mod_str, "16QAM")) { cfg.grant.mcs.mod = SRSLTE_MOD_16QAM; } else if (!strcmp(mod_str, "64QAM")) { cfg.grant.mcs.mod = SRSLTE_MOD_64QAM; } else { mexErrMsgTxt("Unknown modulation\n"); return; } mxFree(mod_str); float *prbset; mxArray *p; p = mxGetField(PDSCHCFG, 0, "PRBSet"); if (!p) { mexErrMsgTxt("Error field PRBSet not found\n"); return; } // Only localized PRB supported cfg.grant.nof_prb = mexutils_read_f(p, &prbset); for (i=0;i<cell.nof_prb;i++) { cfg.grant.prb_idx[0][i] = false; for (int j=0;j<cfg.grant.nof_prb && !cfg.grant.prb_idx[0][i];j++) { if ((int) prbset[j] == i) { cfg.grant.prb_idx[0][i] = true; } } } memcpy(&cfg.grant.prb_idx[1], &cfg.grant.prb_idx[0], SRSLTE_MAX_PRB*sizeof(bool)); free(prbset); srslte_dl_dci_to_grant_nof_re(&cfg.grant, cell, cfg.sf_idx, cell.nof_prb<10?(cfi+1):cfi); // Fill rest of grant structure cfg.grant.lstart = cell.nof_prb<10?(cfi+1):cfi; cfg.grant.nof_symb = 2*SRSLTE_CP_NSYMB(cell.cp)-cfg.grant.lstart; cfg.grant.Qm = srslte_mod_bits_x_symbol(cfg.grant.mcs.mod); cfg.grant.nof_bits = cfg.grant.nof_re * cfg.grant.Qm; /** Allocate input buffers */ if (mexutils_read_cf(INPUT, &input_signal) < 0) { mexErrMsgTxt("Error reading input signal\n"); return; } input_fft = srslte_vec_malloc(SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp) * sizeof(cf_t)); cf_t *ce[SRSLTE_MAX_PORTS]; for (i=0;i<cell.nof_ports;i++) { ce[i] = srslte_vec_malloc(SRSLTE_SF_LEN_RE(cell.nof_prb, cell.cp) * sizeof(cf_t)); } srslte_ofdm_rx_sf(&fft, input_signal, input_fft); if (nrhs > NOF_INPUTS) { cf_t *cearray = NULL; nof_re = mexutils_read_cf(prhs[NOF_INPUTS], &cearray); cf_t *cearray_ptr = cearray; for (i=0;i<cell.nof_ports;i++) { for (int j=0;j<nof_re/cell.nof_ports;j++) { ce[i][j] = *cearray; cearray++; } } if (cearray_ptr) free(cearray_ptr); } else { srslte_chest_dl_estimate(&chest, input_fft, ce, cfg.sf_idx); } float noise_power; if (nrhs > NOF_INPUTS + 1) { noise_power = mxGetScalar(prhs[NOF_INPUTS+1]); } else { noise_power = srslte_chest_dl_get_noise_estimate(&chest); } uint8_t *data = malloc(sizeof(uint8_t) * cfg.grant.mcs.tbs); if (!data) { return; } int r = srslte_pdsch_decode(&pdsch, &cfg, &softbuffer, input_fft, ce, noise_power, data); if (nlhs >= 1) { plhs[0] = mxCreateLogicalScalar(r == 0); } if (nlhs >= 2) { mexutils_write_uint8(data, &plhs[1], cfg.grant.mcs.tbs, 1); } if (nlhs >= 3) { mexutils_write_cf(pdsch.symbols[0], &plhs[2], cfg.grant.nof_re, 1); } if (nlhs >= 4) { mexutils_write_cf(pdsch.d, &plhs[3], cfg.grant.nof_re, 1); } if (nlhs >= 5) { mexutils_write_f(pdsch.e, &plhs[4], cfg.grant.nof_bits, 1); } srslte_chest_dl_free(&chest); srslte_ofdm_rx_free(&fft); srslte_pdsch_free(&pdsch); for (i=0;i<cell.nof_ports;i++) { free(ce[i]); } free(data); free(input_signal); free(input_fft); return; }
unsigned int sf_BJStateflow_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(869586640U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1378061590U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3016396222U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1356957673U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1998470075U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3347301001U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1007541166U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2568101299U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_BJStateflow_get_check_sum(mxArray *plhs[]); sf_c1_BJStateflow_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3564696471U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(678668628U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1090454852U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3896867807U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1811237150U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3075248826U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(29541129U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2528792612U); } return 1; #else return 0; #endif }
void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) { mxArray* img; u_int8_t* p_img; /*The image from Matlab*/ u_int8_t** p_gray; /*Image converted for texture calcs*/ int mrows; /*Image height*/ int ncols; /*Image width*/ TEXTURE* features ; /*Returned struct of features*/ int i ; int imgsize[2] ; int imgindex[2] ; long offset ; int outputsize[2] ; /*Dimensions of TEXTURE struct*/ int outputindex[2] ; float* output ; /*Features to return*/ int distance, angle; /*Parameters for texture calculations*/ if (nrhs != 3) mexErrMsgTxt("\n mb_texture (im, distance, angle),\n\n" "This function returns the 14 image texture statistics described by R. Haralick.\n" "The statistics are calculated from the image's co-occurence matrix specified\n" "for a particular distance and angle. Distance is measured in pixels and\n" "the angle is measured in degrees.\n"); else if (nlhs != 1) mexErrMsgTxt("mb_texture returns a single output.\n") ; if (!mxIsNumeric(prhs[0])) mexErrMsgTxt("mb_texture requires the first input to be numeric\n") ; if (!mxIsUint8(prhs[0])) mexCallMATLAB(1, &img, 1, prhs, "im2uint8_dynamic_range"); else img = prhs[0]; mrows = mxGetM(img) ; ncols = mxGetN(img) ; if (!(mrows > 1) || !(ncols > 1)) mexErrMsgTxt("mb_texture requires an input image, not a scalar.\n") ; if ( !mxIsNumeric(prhs[1]) || (mxIsComplex(prhs[1])) ) mexErrMsgTxt("The second argument (distance) should be numeric and not complex."); if ( !mxIsNumeric(prhs[2]) || (mxIsComplex(prhs[2])) ) mexErrMsgTxt("The third argument (angle) should be numeric and not complex."); p_img = (u_int8_t*) mxGetData(img) ; distance = (double) mxGetScalar(prhs[1]) ; angle = (double) mxGetScalar(prhs[2]) ; imgsize[col] = ncols ; imgsize[row] = mrows ; p_gray = mxCalloc(mrows, sizeof(u_int8_t*)) ; if(p_gray) { for(i=0; i<mrows ; i++) { p_gray[i] = mxCalloc(ncols, sizeof(u_int8_t)) ; if(!p_gray[i]) mexErrMsgTxt("mb_texture : error allocating p_gray[i]") ; } } else mexErrMsgTxt("mb_texture : error allocating p_gray") ; for(imgindex[row] = 0 ; imgindex[row] < imgsize[row] ; imgindex[row]++) for(imgindex[col]=0; imgindex[col] < imgsize[col]; imgindex[col]++) { offset = mxCalcSingleSubscript(prhs[0], 2, imgindex) ; p_gray[imgindex[row]][imgindex[col]] = p_img[offset] ; } if (! (features=Extract_Texture_Features(distance, angle, p_gray,mrows, ncols, 255))) mexErrMsgTxt("ERROR: Could not compute Haralick Features."); outputsize[row] = 14; outputsize[col] = 1; plhs[0] = mxCreateNumericArray(2, outputsize, mxSINGLE_CLASS, mxREAL) ; if (!plhs[0]) mexErrMsgTxt("mb_texture: error allocating return variable.") ; output = (float*)mxGetData(plhs[0]) ; /* Copy the features into the return variable */ outputindex[row]=0 ; outputindex[col]=0 ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->ASM; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->contrast; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->correlation; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->variance; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->IDM; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->sum_avg; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->sum_var; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->sum_entropy; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->entropy; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->diff_var; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->diff_entropy; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->meas_corr1; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->meas_corr2; outputindex[row]++ ; offset = mxCalcSingleSubscript(plhs[0], 2, outputindex) ; output[offset] = features->max_corr_coef; /* Memory clean-up. */ for (i=0; i<mrows ; i++) mxFree(p_gray[i]) ; mxFree(p_gray) ; /* features is calloc'd inside of Extract_Texture_Features */ free(features) ; }
void mexFunction( int nOUT, mxArray *pOUT[], int nINP, const mxArray *pINP[]) { double *t1; double binsize; double *C, *B; double rbound; mwSize nbins, nT; int i, nextEl, j, count; /* check number of arguments: expects 3 inputs, 1 or 2 outputs */ if (nINP != 3) mexErrMsgTxt("Call with t1, binsize and nbins as inputs."); if (nOUT != 1 && nOUT != 2) mexErrMsgTxt("Requires one or two outputs."); /* check validity of inputs */ if (mxGetM(pINP[0]) != 1 && mxGetN(pINP[0]) != 1) mexErrMsgTxt("t1 must be a row or column vector"); if (mxGetM(pINP[1]) * mxGetN(pINP[1]) != 1) mexErrMsgTxt("binsize must be scalar"); if (mxGetM(pINP[2]) * mxGetN(pINP[2]) != 1) mexErrMsgTxt("nbins must be scalar"); if (!mxIsDouble(pINP[0])) mexErrMsgTxt("T input is not a double!"); /* unpack inputs */ nT = mxGetM(pINP[0]) * mxGetN(pINP[0]); t1 = mxGetPr(pINP[0]); if (!t1) mexErrMsgTxt("Memory allocation error t1"); // ADR 2014-11-25 binsize = mxGetScalar(pINP[1]); nbins = (int)mxGetScalar(pINP[2]); pOUT[0] = mxCreateDoubleMatrix(nbins, 1, mxREAL); // inits all C to 0 C = mxGetPr(pOUT[0]); if (!C) mexErrMsgTxt("Memory allocation error C"); // ADR 2014-11-25 if(nOUT == 2) { double m; pOUT[1] = mxCreateDoubleMatrix(nbins, 1, mxREAL); B = mxGetPr(pOUT[1]); if (!B) mexErrMsgTxt("Memory allocation error B"); // ADR 2014-11-25 m = binsize/2.0; for(j = 0; j < nbins; j++) B[j] = m + j * binsize; } /* cross correlations */ for(i = 0; i < nT; i++) { nextEl = i+1; rbound = t1[i]; for(j = 0; j < nbins; j++) { count = 0; // nothing in this bin yet rbound += binsize; // rbound of this bin while((t1[nextEl] < rbound) && (nextEl < (nT-1))) {nextEl++; count++;} C[j] += count; } } for(j = 0; j < nbins; j++) C[j] /= nT * binsize; }
void homogToInds(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* [rs,cs,is]=homogToInds(H,m,n,r0,r1,c0,c1,flag); */ int m, n, flag; double *H, r0, r1, c0, c1; int *is, m1, n1, ind=0, i, j, fr, fc; double *rs, *cs, r, c, m2, n2, z; /* extract inputs */ H = (double*) mxGetData(prhs[0]); m = (int) mxGetScalar(prhs[1]); n = (int) mxGetScalar(prhs[2]); r0 = mxGetScalar(prhs[3]); r1 = mxGetScalar(prhs[4]); c0 = mxGetScalar(prhs[5]); c1 = mxGetScalar(prhs[6]); flag = (int) mxGetScalar(prhs[7]); /* initialize memory */ m1 = (int) (r1-r0+1); m2 = (m+1.0)/2.0; n1 = (int) (c1-c0+1); n2 = (n+1.0)/2.0; rs = mxMalloc(sizeof(double)*m1*n1); cs = mxMalloc(sizeof(double)*m1*n1); is = mxMalloc(sizeof(int)*m1*n1); /* Compute rs an cs */ if( H[2]==0 && H[5]==0 ) { for( i=0; i<n1; i++ ) { r = H[0]*r0 + H[3]*(c0+i) + H[6] + m2; c = H[1]*r0 + H[4]*(c0+i) + H[7] + n2; for(j=0; j<m1; j++) { rs[ind]=r; cs[ind]=c; r+=H[0]; c+=H[1]; ind++; } } } else { for( i=0; i<n1; i++ ) { r = H[0]*r0 + H[3]*(c0+i) + H[6]; c = H[1]*r0 + H[4]*(c0+i) + H[7]; z = H[2]*r0 + H[5]*(c0+i) + 1; for(j=0; j<m1; j++) { rs[ind]=r/z+m2; cs[ind]=c/z+n2; r+=H[0]; c+=H[1]; z+=H[2]; ind++; } } } /* clamp and compute ids according to flag */ if( flag==1 ) { /* nearest neighbor */ for(i=0; i<n1*m1; i++) { r = rs[i]<1 ? 1 : (rs[i]>m ? m : rs[i]); c = cs[i]<1 ? 1 : (cs[i]>n ? n : cs[i]); is[i] = ((int) (r-.5)) + ((int) (c-.5)) * m; } } else if(flag==2) { /* bilinear */ for(i=0; i<n1*m1; i++) { r = rs[i]<2 ? 2 : (rs[i]>m-1 ? m-1 : rs[i]); c = cs[i]<2 ? 2 : (cs[i]>n-1 ? n-1 : cs[i]); fr = (int) r; fc = (int) c; rs[i]=r-fr; cs[i]=c-fc; is[i]=(fr-1)+(fc-1)*m; } } else { /* other cases - clamp only */ for(i=0; i<n1*m1; i++) { rs[i] = rs[i]<2 ? 2 : (rs[i]>m-1 ? m-1 : rs[i]); cs[i] = cs[i]<2 ? 2 : (cs[i]>n-1 ? n-1 : cs[i]); } } /* create output array */ plhs[0] = mxCreateNumericMatrix(0,0,mxDOUBLE_CLASS,mxREAL); plhs[1] = mxCreateNumericMatrix(0,0,mxDOUBLE_CLASS,mxREAL); plhs[2] = mxCreateNumericMatrix(0,0,mxINT32_CLASS,mxREAL); mxSetData(plhs[0],rs); mxSetM(plhs[0],m1); mxSetN(plhs[0],n1); mxSetData(plhs[1],cs); mxSetM(plhs[1],m1); mxSetN(plhs[1],n1); mxSetData(plhs[2],is); mxSetM(plhs[2],m1); mxSetN(plhs[2],n1); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* Check for proper number of input and output arguments */ if (nrhs < 5 || nrhs > 6) mexErrMsgTxt("5 or 6 input arguments required."); /* Check data type of input argument */ for (int i = 0; i < nrhs; i++) { if (!mxIsDouble(prhs[i])) { std::ostringstream s; s << "Input " << i + 1 << " must be of type double."; mexErrMsgTxt(s.str().c_str()); } if (mxIsComplex(prhs[i])) { std::ostringstream s; s << "Input " << i + 1 << " may not be complex."; mexErrMsgTxt(s.str().c_str()); } if (mxGetNumberOfDimensions(prhs[i]) > 2) { std::ostringstream s; s << "Input " << i + 1 << " may not have more than 2 dimensions."; mexErrMsgTxt(s.str().c_str()); } } for (int i = 2; i < 5; i++) if (mxGetM(prhs[i]) != 1 || mxGetN(prhs[i]) != 1) { std::ostringstream s; s << "Input " << i + 1 << " must be scalar."; mexErrMsgTxt(s.str().c_str()); } mwSize ai = mxGetM(prhs[0]); mwSize aj = mxGetN(prhs[0]); mwSize bi = mxGetM(prhs[1]); mwSize bj = mxGetN(prhs[1]); if (ai <= 0 || aj <= 0) mexErrMsgTxt("First argument may not be empty."); if (bi <= 0 || bj <= 0) mexErrMsgTxt("Second argument may not be empty."); if (ai != aj) mexErrMsgTxt("Coefficient matrix must be square."); if (ai != bi) mexErrMsgTxt("Argument sizes incompatible."); if (bj > 1) mexErrMsgTxt("Right-hand side vector may only have one column."); if (nrhs > 5) { mwSize xi = mxGetM(prhs[5]); mwSize xj = mxGetN(prhs[5]); if (ai != xi) mexErrMsgTxt("Argument sizes incompatible."); if (xj > 1) mexErrMsgTxt("Initialization vector may only have one column."); } if (!mxIsSparse(prhs[0])) mexErrMsgTxt("Coefficient matrix must be sparse."); if (mxIsSparse(prhs[1])) mexErrMsgTxt("Right hand size may not be sparse."); double* APr = mxGetPr(prhs[0]); mwIndex* AJc = mxGetJc(prhs[0]); mwIndex* AIr = mxGetIr(prhs[0]); double* bPr = mxGetPr(prhs[1]); double w = mxGetScalar(prhs[2]); int niters = (int) mxGetScalar(prhs[3]); double tol = mxGetScalar(prhs[4]); // ----------------------------------------------------------------- // Construct output // ----------------------------------------------------------------- plhs[0] = mxCreateDoubleMatrix(bi, 1, mxREAL); double* xPr = mxGetPr(plhs[0]); if (nrhs > 5) memcpy(xPr, mxGetPr(prhs[5]), bi * sizeof(double)); // ----------------------------------------------------------------- // Perform SOR // ----------------------------------------------------------------- for (int n = 0; n < niters; n++) { if ((n % 5) == 0) { // Terminate if residual treshold reached double res = residual(prhs[0], plhs[0], prhs[1]); if (res < tol) { if (nlhs > 1) plhs[1] = mxCreateLogicalScalar(true); if (nlhs > 2) plhs[2] = mxCreateDoubleScalar(res); if (nlhs > 3) plhs[3] = mxCreateDoubleScalar(n); return; } } double* A = APr; // Iterate over all the columns of A for (mwSize col = 0; col < ai; col++) { mwIndex row_start = AJc[col]; mwIndex nrows = AJc[col+1] - row_start; mwIndex* row = AIr + row_start; double sigma = 0.0; double diag = 0.0; // Iterate over all non-zero row indices for (mwSize row_idx = nrows; row_idx > 0; row_idx--) { double tmp = *A; mwIndex r = *row; if (r == col) diag = tmp; else sigma += tmp * xPr[r]; A++; row++; } sigma = (bPr[col] - sigma) / diag; xPr[col] += w * (sigma - xPr[col]); } } if (nlhs > 1) plhs[1] = mxCreateLogicalScalar(false); if (nlhs > 2) plhs[2] = mxCreateDoubleScalar(residual(prhs[0], plhs[0], prhs[1])); if (nlhs > 3) plhs[3] = mxCreateDoubleScalar(niters); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *Prhs[]) { register int i; register double *pdbl; mxArray **prhs=(mxArray **)&Prhs[0], *At, *Ct; struct mexdata mdata; int len, status; double *p, *p0, *ret, *x; int m, n, havejac, Arows, Crows, itmax, nopts, mintype, nextra; double opts[LM_OPTS_SZ]={LM_INIT_MU, LM_STOP_THRESH, LM_STOP_THRESH, LM_STOP_THRESH, LM_DIFF_DELTA}; double info[LM_INFO_SZ]; double *lb=NULL, *ub=NULL, *A=NULL, *b=NULL, *wghts=NULL, *C=NULL, *d=NULL, *covar=NULL; /* parse input args; start by checking their number */ if((nrhs<5)) matlabFmtdErrMsgTxt("levmar: at least 5 input arguments required (got %d).", nrhs); if(nlhs>4) matlabFmtdErrMsgTxt("levmar: too many output arguments (max. 4, got %d).", nlhs); else if(nlhs<2) matlabFmtdErrMsgTxt("levmar: too few output arguments (min. 2, got %d).", nlhs); /* note that in order to accommodate optional args, prhs & nrhs are adjusted accordingly below */ /** func **/ /* first argument must be a string , i.e. a char row vector */ if(mxIsChar(prhs[0])!=1) mexErrMsgTxt("levmar: first argument must be a string."); if(mxGetM(prhs[0])!=1) mexErrMsgTxt("levmar: first argument must be a string (i.e. char row vector)."); /* store supplied name */ len=mxGetN(prhs[0])+1; mdata.fname=mxCalloc(len, sizeof(char)); status=mxGetString(prhs[0], mdata.fname, len); if(status!=0) mexErrMsgTxt("levmar: not enough space. String is truncated."); /** jac (optional) **/ /* check whether second argument is a string */ if(mxIsChar(prhs[1])==1){ if(mxGetM(prhs[1])!=1) mexErrMsgTxt("levmar: second argument must be a string (i.e. row vector)."); /* store supplied name */ len=mxGetN(prhs[1])+1; mdata.jacname=mxCalloc(len, sizeof(char)); status=mxGetString(prhs[1], mdata.jacname, len); if(status!=0) mexErrMsgTxt("levmar: not enough space. String is truncated."); havejac=1; ++prhs; --nrhs; } else{ mdata.jacname=NULL; havejac=0; } #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: %s analytic Jacobian\n", havejac? "with" : "no"); #endif /* DEBUG */ /* CHECK if(!mxIsDouble(prhs[1]) || mxIsComplex(prhs[1]) || !(mxGetM(prhs[1])==1 && mxGetN(prhs[1])==1)) */ /** p0 **/ /* the second required argument must be a real row or column vector */ if(!mxIsDouble(prhs[1]) || mxIsComplex(prhs[1]) || !(mxGetM(prhs[1])==1 || mxGetN(prhs[1])==1)) mexErrMsgTxt("levmar: p0 must be a real vector."); p0=mxGetPr(prhs[1]); /* determine if we have a row or column vector and retrieve its * size, i.e. the number of parameters */ if(mxGetM(prhs[1])==1){ m=mxGetN(prhs[1]); mdata.isrow_p0=1; } else{ m=mxGetM(prhs[1]); mdata.isrow_p0=0; } /* copy input parameter vector to avoid destroying it */ p=mxMalloc(m*sizeof(double)); for(i=0; i<m; ++i) p[i]=p0[i]; /** x **/ /* the third required argument must be a real row or column vector */ if(!mxIsDouble(prhs[2]) || mxIsComplex(prhs[2]) || !(mxGetM(prhs[2])==1 || mxGetN(prhs[2])==1)) mexErrMsgTxt("levmar: x must be a real vector."); x=mxGetPr(prhs[2]); n=__MAX__(mxGetM(prhs[2]), mxGetN(prhs[2])); /** itmax **/ /* the fourth required argument must be a scalar */ if(!mxIsDouble(prhs[3]) || mxIsComplex(prhs[3]) || mxGetM(prhs[3])!=1 || mxGetN(prhs[3])!=1) mexErrMsgTxt("levmar: itmax must be a scalar."); itmax=(int)mxGetScalar(prhs[3]); /** opts **/ /* the fifth required argument must be a real row or column vector */ if(!mxIsDouble(prhs[4]) || mxIsComplex(prhs[4]) || (!(mxGetM(prhs[4])==1 || mxGetN(prhs[4])==1) && !(mxGetM(prhs[4])==0 && mxGetN(prhs[4])==0))) mexErrMsgTxt("levmar: opts must be a real vector."); pdbl=mxGetPr(prhs[4]); nopts=__MAX__(mxGetM(prhs[4]), mxGetN(prhs[4])); if(nopts!=0){ /* if opts==[], nothing needs to be done and the defaults are used */ if(nopts>LM_OPTS_SZ) matlabFmtdErrMsgTxt("levmar: opts must have at most %d elements, got %d.", LM_OPTS_SZ, nopts); else if(nopts<((havejac)? LM_OPTS_SZ-1 : LM_OPTS_SZ)) matlabFmtdWarnMsgTxt("levmar: only the %d first elements of opts specified, remaining set to defaults.", nopts); for(i=0; i<nopts; ++i) opts[i]=pdbl[i]; } #ifdef DEBUG else{ fflush(stderr); fprintf(stderr, "LEVMAR: empty options vector, using defaults\n"); } #endif /* DEBUG */ /** mintype (optional) **/ /* check whether sixth argument is a string */ if(nrhs>=6 && mxIsChar(prhs[5])==1 && mxGetM(prhs[5])==1){ char *minhowto; /* examine supplied name */ len=mxGetN(prhs[5])+1; minhowto=mxCalloc(len, sizeof(char)); status=mxGetString(prhs[5], minhowto, len); if(status!=0) mexErrMsgTxt("levmar: not enough space. String is truncated."); for(i=0; minhowto[i]; ++i) minhowto[i]=tolower(minhowto[i]); if(!strncmp(minhowto, "unc", 3)) mintype=MIN_UNCONSTRAINED; else if(!strncmp(minhowto, "bc", 2)) mintype=MIN_CONSTRAINED_BC; else if(!strncmp(minhowto, "lec", 3)) mintype=MIN_CONSTRAINED_LEC; else if(!strncmp(minhowto, "blec", 4)) mintype=MIN_CONSTRAINED_BLEC; else if(!strncmp(minhowto, "bleic", 5)) mintype=MIN_CONSTRAINED_BLEIC; else if(!strncmp(minhowto, "blic", 4)) mintype=MIN_CONSTRAINED_BLIC; else if(!strncmp(minhowto, "leic", 4)) mintype=MIN_CONSTRAINED_LEIC; else if(!strncmp(minhowto, "lic", 3)) mintype=MIN_CONSTRAINED_BLIC; else matlabFmtdErrMsgTxt("levmar: unknown minimization type '%s'.", minhowto); mxFree(minhowto); ++prhs; --nrhs; } else mintype=MIN_UNCONSTRAINED; if(mintype==MIN_UNCONSTRAINED) goto extraargs; /* arguments below this point are optional and their presence depends * upon the minimization type determined above */ /** lb, ub **/ if(nrhs>=7 && (mintype==MIN_CONSTRAINED_BC || mintype==MIN_CONSTRAINED_BLEC || mintype==MIN_CONSTRAINED_BLIC || mintype==MIN_CONSTRAINED_BLEIC)){ /* check if the next two arguments are real row or column vectors */ if(mxIsDouble(prhs[5]) && !mxIsComplex(prhs[5]) && (mxGetM(prhs[5])==1 || mxGetN(prhs[5])==1)){ if(mxIsDouble(prhs[6]) && !mxIsComplex(prhs[6]) && (mxGetM(prhs[6])==1 || mxGetN(prhs[6])==1)){ if((i=__MAX__(mxGetM(prhs[5]), mxGetN(prhs[5])))!=m) matlabFmtdErrMsgTxt("levmar: lb must have %d elements, got %d.", m, i); if((i=__MAX__(mxGetM(prhs[6]), mxGetN(prhs[6])))!=m) matlabFmtdErrMsgTxt("levmar: ub must have %d elements, got %d.", m, i); lb=mxGetPr(prhs[5]); ub=mxGetPr(prhs[6]); prhs+=2; nrhs-=2; } } } /** A, b **/ if(nrhs>=7 && (mintype==MIN_CONSTRAINED_LEC || mintype==MIN_CONSTRAINED_BLEC || mintype==MIN_CONSTRAINED_LEIC || mintype==MIN_CONSTRAINED_BLEIC)){ /* check if the next two arguments are a real matrix and a real row or column vector */ if(mxIsDouble(prhs[5]) && !mxIsComplex(prhs[5]) && mxGetM(prhs[5])>=1 && mxGetN(prhs[5])>=1){ if(mxIsDouble(prhs[6]) && !mxIsComplex(prhs[6]) && (mxGetM(prhs[6])==1 || mxGetN(prhs[6])==1)){ if((i=mxGetN(prhs[5]))!=m) matlabFmtdErrMsgTxt("levmar: A must have %d columns, got %d.", m, i); if((i=__MAX__(mxGetM(prhs[6]), mxGetN(prhs[6])))!=(Arows=mxGetM(prhs[5]))) matlabFmtdErrMsgTxt("levmar: b must have %d elements, got %d.", Arows, i); At=prhs[5]; b=mxGetPr(prhs[6]); A=getTranspose(At); prhs+=2; nrhs-=2; } } } /* wghts */ /* check if we have a weights vector */ if(nrhs>=6 && mintype==MIN_CONSTRAINED_BLEC){ /* only check if we have seen both box & linear constraints */ if(mxIsDouble(prhs[5]) && !mxIsComplex(prhs[5]) && (mxGetM(prhs[5])==1 || mxGetN(prhs[5])==1)){ if(__MAX__(mxGetM(prhs[5]), mxGetN(prhs[5]))==m){ wghts=mxGetPr(prhs[5]); ++prhs; --nrhs; } } } /** C, d **/ if(nrhs>=7 && (mintype==MIN_CONSTRAINED_BLEIC || mintype==MIN_CONSTRAINED_BLIC || mintype==MIN_CONSTRAINED_LEIC || mintype==MIN_CONSTRAINED_LIC)){ /* check if the next two arguments are a real matrix and a real row or column vector */ if(mxIsDouble(prhs[5]) && !mxIsComplex(prhs[5]) && mxGetM(prhs[5])>=1 && mxGetN(prhs[5])>=1){ if(mxIsDouble(prhs[6]) && !mxIsComplex(prhs[6]) && (mxGetM(prhs[6])==1 || mxGetN(prhs[6])==1)){ if((i=mxGetN(prhs[5]))!=m) matlabFmtdErrMsgTxt("levmar: C must have %d columns, got %d.", m, i); if((i=__MAX__(mxGetM(prhs[6]), mxGetN(prhs[6])))!=(Crows=mxGetM(prhs[5]))) matlabFmtdErrMsgTxt("levmar: d must have %d elements, got %d.", Crows, i); Ct=prhs[5]; d=mxGetPr(prhs[6]); C=getTranspose(Ct); prhs+=2; nrhs-=2; } } } /* arguments below this point are assumed to be extra arguments passed * to every invocation of the fitting function and its Jacobian */ extraargs: /* handle any extra args and allocate memory for * passing the current parameter estimate to matlab */ nextra=nrhs-5; mdata.nrhs=nextra+1; mdata.rhs=(mxArray **)mxMalloc(mdata.nrhs*sizeof(mxArray *)); for(i=0; i<nextra; ++i) mdata.rhs[i+1]=(mxArray *)prhs[nrhs-nextra+i]; /* discard 'const' modifier */ #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: %d extra args\n", nextra); #endif /* DEBUG */ if(mdata.isrow_p0){ /* row vector */ mdata.rhs[0]=mxCreateDoubleMatrix(1, m, mxREAL); /* mxSetM(mdata.rhs[0], 1); mxSetN(mdata.rhs[0], m); */ } else{ /* column vector */ mdata.rhs[0]=mxCreateDoubleMatrix(m, 1, mxREAL); /* mxSetM(mdata.rhs[0], m); mxSetN(mdata.rhs[0], 1); */ } /* ensure that the supplied function & Jacobian are as expected */ if(checkFuncAndJacobian(p, m, n, havejac, &mdata)){ status=LM_ERROR; goto cleanup; } if(nlhs>3) /* covariance output required */ covar=mxMalloc(m*m*sizeof(double)); /* invoke levmar */ switch(mintype){ case MIN_UNCONSTRAINED: /* no constraints */ if(havejac) status=dlevmar_der(func, jacfunc, p, x, m, n, itmax, opts, info, NULL, covar, (void *)&mdata); else status=dlevmar_dif(func, p, x, m, n, itmax, opts, info, NULL, covar, (void *)&mdata); #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: calling dlevmar_der()/dlevmar_dif()\n"); #endif /* DEBUG */ break; case MIN_CONSTRAINED_BC: /* box constraints */ if(havejac) status=dlevmar_bc_der(func, jacfunc, p, x, m, n, lb, ub, itmax, opts, info, NULL, covar, (void *)&mdata); else status=dlevmar_bc_dif(func, p, x, m, n, lb, ub, itmax, opts, info, NULL, covar, (void *)&mdata); #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: calling dlevmar_bc_der()/dlevmar_bc_dif()\n"); #endif /* DEBUG */ break; case MIN_CONSTRAINED_LEC: /* linear equation constraints */ #ifdef HAVE_LAPACK if(havejac) status=dlevmar_lec_der(func, jacfunc, p, x, m, n, A, b, Arows, itmax, opts, info, NULL, covar, (void *)&mdata); else status=dlevmar_lec_dif(func, p, x, m, n, A, b, Arows, itmax, opts, info, NULL, covar, (void *)&mdata); #else mexErrMsgTxt("levmar: no linear constraints support, HAVE_LAPACK was not defined during MEX-file compilation."); #endif /* HAVE_LAPACK */ #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: calling dlevmar_lec_der()/dlevmar_lec_dif()\n"); #endif /* DEBUG */ break; case MIN_CONSTRAINED_BLEC: /* box & linear equation constraints */ #ifdef HAVE_LAPACK if(havejac) status=dlevmar_blec_der(func, jacfunc, p, x, m, n, lb, ub, A, b, Arows, wghts, itmax, opts, info, NULL, covar, (void *)&mdata); else status=dlevmar_blec_dif(func, p, x, m, n, lb, ub, A, b, Arows, wghts, itmax, opts, info, NULL, covar, (void *)&mdata); #else mexErrMsgTxt("levmar: no box & linear constraints support, HAVE_LAPACK was not defined during MEX-file compilation."); #endif /* HAVE_LAPACK */ #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: calling dlevmar_blec_der()/dlevmar_blec_dif()\n"); #endif /* DEBUG */ break; case MIN_CONSTRAINED_BLEIC: /* box, linear equation & inequalities constraints */ #ifdef HAVE_LAPACK if(havejac) status=dlevmar_bleic_der(func, jacfunc, p, x, m, n, lb, ub, A, b, Arows, C, d, Crows, itmax, opts, info, NULL, covar, (void *)&mdata); else status=dlevmar_bleic_dif(func, p, x, m, n, lb, ub, A, b, Arows, C, d, Crows, itmax, opts, info, NULL, covar, (void *)&mdata); #else mexErrMsgTxt("levmar: no box, linear equation & inequality constraints support, HAVE_LAPACK was not defined during MEX-file compilation."); #endif /* HAVE_LAPACK */ #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: calling dlevmar_bleic_der()/dlevmar_bleic_dif()\n"); #endif /* DEBUG */ break; case MIN_CONSTRAINED_BLIC: /* box, linear inequalities constraints */ #ifdef HAVE_LAPACK if(havejac) status=dlevmar_bleic_der(func, jacfunc, p, x, m, n, lb, ub, NULL, NULL, 0, C, d, Crows, itmax, opts, info, NULL, covar, (void *)&mdata); else status=dlevmar_bleic_dif(func, p, x, m, n, lb, ub, NULL, NULL, 0, C, d, Crows, itmax, opts, info, NULL, covar, (void *)&mdata); #else mexErrMsgTxt("levmar: no box & linear inequality constraints support, HAVE_LAPACK was not defined during MEX-file compilation."); #endif /* HAVE_LAPACK */ #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: calling dlevmar_blic_der()/dlevmar_blic_dif()\n"); #endif /* DEBUG */ break; case MIN_CONSTRAINED_LEIC: /* linear equation & inequalities constraints */ #ifdef HAVE_LAPACK if(havejac) status=dlevmar_bleic_der(func, jacfunc, p, x, m, n, NULL, NULL, A, b, Arows, C, d, Crows, itmax, opts, info, NULL, covar, (void *)&mdata); else status=dlevmar_bleic_dif(func, p, x, m, n, NULL, NULL, A, b, Arows, C, d, Crows, itmax, opts, info, NULL, covar, (void *)&mdata); #else mexErrMsgTxt("levmar: no linear equation & inequality constraints support, HAVE_LAPACK was not defined during MEX-file compilation."); #endif /* HAVE_LAPACK */ #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: calling dlevmar_leic_der()/dlevmar_leic_dif()\n"); #endif /* DEBUG */ break; case MIN_CONSTRAINED_LIC: /* linear inequalities constraints */ #ifdef HAVE_LAPACK if(havejac) status=dlevmar_bleic_der(func, jacfunc, p, x, m, n, NULL, NULL, NULL, NULL, 0, C, d, Crows, itmax, opts, info, NULL, covar, (void *)&mdata); else status=dlevmar_bleic_dif(func, p, x, m, n, NULL, NULL, NULL, NULL, 0, C, d, Crows, itmax, opts, info, NULL, covar, (void *)&mdata); #else mexErrMsgTxt("levmar: no linear equation & inequality constraints support, HAVE_LAPACK was not defined during MEX-file compilation."); #endif /* HAVE_LAPACK */ #ifdef DEBUG fflush(stderr); fprintf(stderr, "LEVMAR: calling dlevmar_lic_der()/dlevmar_lic_dif()\n"); #endif /* DEBUG */ break; default: mexErrMsgTxt("levmar: unexpected internal error."); } #ifdef DEBUG fflush(stderr); printf("LEVMAR: minimization returned %d in %g iter, reason %g\n\tSolution: ", status, info[5], info[6]); for(i=0; i<m; ++i) printf("%.7g ", p[i]); printf("\n\n\tMinimization info:\n\t"); for(i=0; i<LM_INFO_SZ; ++i) printf("%g ", info[i]); printf("\n"); #endif /* DEBUG */ /* copy back return results */ /** ret **/ plhs[0]=mxCreateDoubleMatrix(1, 1, mxREAL); ret=mxGetPr(plhs[0]); ret[0]=(double)status; /** popt **/ plhs[1]=(mdata.isrow_p0==1)? mxCreateDoubleMatrix(1, m, mxREAL) : mxCreateDoubleMatrix(m, 1, mxREAL); pdbl=mxGetPr(plhs[1]); for(i=0; i<m; ++i) pdbl[i]=p[i]; /** info **/ if(nlhs>2){ plhs[2]=mxCreateDoubleMatrix(1, LM_INFO_SZ, mxREAL); pdbl=mxGetPr(plhs[2]); for(i=0; i<LM_INFO_SZ; ++i) pdbl[i]=info[i]; } /** covar **/ if(nlhs>3){ plhs[3]=mxCreateDoubleMatrix(m, m, mxREAL); pdbl=mxGetPr(plhs[3]); for(i=0; i<m*m; ++i) /* covariance matrices are symmetric, thus no need to transpose! */ pdbl[i]=covar[i]; } cleanup: /* cleanup */ mxDestroyArray(mdata.rhs[0]); if(A) mxFree(A); if(C) mxFree(C); mxFree(mdata.fname); if(havejac) mxFree(mdata.jacname); mxFree(p); mxFree(mdata.rhs); if(covar) mxFree(covar); if(status==LM_ERROR) mexWarnMsgTxt("levmar: optimization returned with an error!"); }
unsigned int sf_test_autoinheritance_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[32]; char aiChksum[64]; if (nrhs<3 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the autoinheritance_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_autoinheritance_info")) return 0; mxGetString(prhs[2], aiChksum,sizeof(aiChksum)/sizeof(char)); aiChksum[(sizeof(aiChksum)/sizeof(char)-1)] = '\0'; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 1: { if (strcmp(aiChksum, "iXoCUCWCdn5v10UYXcgv7C") == 0) { extern mxArray *sf_c1_test_get_autoinheritance_info(void); plhs[0] = sf_c1_test_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 2: { if (strcmp(aiChksum, "0KcEh7HNN3ZxPFcKkBpYp") == 0) { extern mxArray *sf_c2_test_get_autoinheritance_info(void); plhs[0] = sf_c2_test_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }
/* The gateway routine */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* ----------------- Variables ----------------- */ /* input variables */ /* mandatory input */ int startIdx; int endIdx; double * inReal; /* optional input */ int optInTimePeriod; int optInFastKPeriod; int optInFastDPeriod; double optInFastDMA; /* output variables */ int outBegIdx; int outNbElement; double* outFastK; double* outFastD; /* input dimentions */ int inSeriesRows; int inSeriesCols; /* error handling */ TA_RetCode retCode; /* ----------------- input/output count ----------------- */ /* Check for proper number of arguments. */ if (nrhs < 1 || nrhs > 5) mexErrMsgTxt("#5 inputs possible #4 optional."); if (nlhs != 2) mexErrMsgTxt("#2 output required."); /* ----------------- INPUT ----------------- */ /* Create a pointer to the input matrix inReal. */ inReal = mxGetPr(prhs[0]); /* Get the dimensions of the matrix input inReal. */ inSeriesCols = mxGetN(prhs[0]); if (inSeriesCols != 1) mexErrMsgTxt("inReal only vector alowed."); inSeriesRows = mxGetM(prhs[0]); endIdx = inSeriesRows - 1; startIdx = 0; /* Process optional arguments */ if (nrhs >= 1+1) { if (!mxIsDouble(prhs[1]) || mxIsComplex(prhs[1]) || mxGetN(prhs[1])*mxGetM(prhs[1]) != 1) mexErrMsgTxt("Input optInTimePeriod must be a scalar."); /* Get the scalar input optInTimePeriod. */ optInTimePeriod = (int) mxGetScalar(prhs[1]); } else { optInTimePeriod = 14; } if (nrhs >= 2+1) { if (!mxIsDouble(prhs[2]) || mxIsComplex(prhs[2]) || mxGetN(prhs[2])*mxGetM(prhs[2]) != 1) mexErrMsgTxt("Input optInFastKPeriod must be a scalar."); /* Get the scalar input optInTimePeriod. */ optInFastKPeriod = (int) mxGetScalar(prhs[2]); } else { optInFastKPeriod = 5; } if (nrhs >= 3+1) { if (!mxIsDouble(prhs[3]) || mxIsComplex(prhs[3]) || mxGetN(prhs[3])*mxGetM(prhs[3]) != 1) mexErrMsgTxt("Input optInFastDPeriod must be a scalar."); /* Get the scalar input optInTimePeriod. */ optInFastDPeriod = (int) mxGetScalar(prhs[3]); } else { optInFastDPeriod = 3; } if (nrhs >= 4+1) { if (!mxIsDouble(prhs[4]) || mxIsComplex(prhs[4]) || mxGetN(prhs[4])*mxGetM(prhs[4]) != 1) mexErrMsgTxt("Input optInFastDMA must be a scalar."); /* Get the scalar input optInTimePeriod. */ optInFastDMA = mxGetScalar(prhs[4]); } else { optInFastDMA = 0; } /* ----------------- OUTPUT ----------------- */ outFastK = mxCalloc(inSeriesRows, sizeof(double)); outFastD = mxCalloc(inSeriesRows, sizeof(double)); /* -------------- Invocation ---------------- */ retCode = TA_STOCHRSI( startIdx, endIdx, inReal, optInTimePeriod, optInFastKPeriod, optInFastDPeriod, optInFastDMA, &outBegIdx, &outNbElement, outFastK, outFastD); /* -------------- Errors ---------------- */ if (retCode) { mxFree(outFastK); mxFree(outFastD); mexPrintf("%s%i","Return code=",retCode); mexErrMsgTxt(" Error!"); } // Populate Output plhs[0] = mxCreateDoubleMatrix(outBegIdx+outNbElement,1, mxREAL); memcpy(((double *) mxGetData(plhs[0]))+outBegIdx, outFastK, outNbElement*mxGetElementSize(plhs[0])); mxFree(outFastK); plhs[1] = mxCreateDoubleMatrix(outBegIdx+outNbElement,1, mxREAL); memcpy(((double *) mxGetData(plhs[1]))+outBegIdx, outFastD, outNbElement*mxGetElementSize(plhs[1])); mxFree(outFastD); } /* END mexFunction */
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) /* left hand side right hand side /* function [z,kz] = mandelbrot_step(z,kz,z0,d); * Take one step of the Mandelbrot iteration. * Complex arithmetic: * z = z.^2 + z0 * kz(abs(z) < 2) == d * Real arithmetic: * x <-> real(z); * y <-> imag(z); * u <-> real(z0); * v <-> imag(z0); * [x,y] = [x.^2-y.^2+u, 2*x.*y+v]; * kz(x.^2+y.^2 < 4) = d; */ { double *x,*y,*u,*v,t; unsigned short *kz, *num, d; int j ,n, m; int dim[] = {1, 1}; x = mxGetPr(prhs[0]); y = mxGetPi(prhs[0]); kz = (unsigned short *) mxGetData(prhs[1]); u = mxGetPr(prhs[2]); v = mxGetPi(prhs[2]); d = (unsigned short) mxGetScalar(prhs[3]); plhs[0] = prhs[0]; plhs[1] = prhs[1]; plhs[2] = mxCreateNumericArray(2,dim,mxUINT32_CLASS,mxREAL); num = mxGetData(plhs[2]); *num = 0; n = mxGetN(prhs[0]); m = mxGetM(prhs[0]); if(1){ for (j=n*m; j--; ) { if (kz[j] == d-1) { t = x[j]; x[j] = x[j]*x[j] - y[j]*y[j] + u[j]; y[j] = (t+t)*y[j] + v[j]; if (x[j]*x[j] + y[j]*y[j] < 4) { kz[j] = d; } else { *num = *num+1; } } } } else { for (j=0; j<n*m; j++) { if (kz[j] == d-1) { t = x[j]; x[j] = x[j]*x[j] - y[j]*y[j] + u[j]; y[j] = 2*t*y[j] + v[j]; if (x[j]*x[j] + y[j]*y[j] < 4) { kz[j] = d; } } } } return; }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { Int *P, *Q, *Rp, *Pinv ; double *Ax, dummy, tol ; Int m, n, anz, is_complex, n1rows, n1cols, i, k ; cholmod_sparse *A, Amatrix, *Y ; cholmod_common Common, *cc ; // ------------------------------------------------------------------------- // start CHOLMOD and set parameters // ------------------------------------------------------------------------- cc = &Common ; cholmod_l_start (cc) ; spqr_mx_config (SPUMONI, cc) ; // ------------------------------------------------------------------------- // check inputs // ------------------------------------------------------------------------- if (nargout > 5) { mexErrMsgIdAndTxt ("MATLAB:maxlhs", "Too many output arguments") ; } if (nargin < 1) { mexErrMsgIdAndTxt ("MATLAB:minrhs", "Not enough input arguments") ; } if (nargin > 2) { mexErrMsgIdAndTxt ("MATLAB:maxrhs", "Too many input arguments") ; } // ------------------------------------------------------------------------- // get the input matrix A and convert to merged-complex if needed // ------------------------------------------------------------------------- if (!mxIsSparse (pargin [0])) { mexErrMsgIdAndTxt ("QR:invalidInput", "A must be sparse") ; } A = spqr_mx_get_sparse (pargin [0], &Amatrix, &dummy) ; m = A->nrow ; n = A->ncol ; is_complex = mxIsComplex (pargin [0]) ; Ax = spqr_mx_merge_if_complex (pargin [0], is_complex, &anz, cc) ; if (is_complex) { // A has been converted from real or zomplex to complex A->x = Ax ; A->z = NULL ; A->xtype = CHOLMOD_COMPLEX ; } // ------------------------------------------------------------------------- // get the tolerance // ------------------------------------------------------------------------- if (nargin < 2) { tol = is_complex ? spqr_tol <Complex> (A,cc) : spqr_tol <double> (A,cc); } else { tol = mxGetScalar (pargin [1]) ; } // ------------------------------------------------------------------------- // find the singletons // ------------------------------------------------------------------------- if (is_complex) { spqr_1colamd <Complex> (SPQR_ORDERING_NATURAL, tol, 0, A, &Q, &Rp, &Pinv, &Y, &n1cols, &n1rows, cc) ; } else { spqr_1colamd <double> (SPQR_ORDERING_NATURAL, tol, 0, A, &Q, &Rp, &Pinv, &Y, &n1cols, &n1rows, cc) ; } // ------------------------------------------------------------------------- // free unused outputs from spqr_1colamd, and the merged-complex copy of A // ------------------------------------------------------------------------- cholmod_l_free (n1rows+1, sizeof (Int), Rp, cc) ; cholmod_l_free_sparse (&Y, cc) ; if (is_complex) { // this was allocated by merge_if_complex cholmod_l_free (anz, sizeof (Complex), Ax, cc) ; } // ------------------------------------------------------------------------- // find P from Pinv // ------------------------------------------------------------------------- P = (Int *) cholmod_l_malloc (m, sizeof (Int), cc) ; for (i = 0 ; i < m ; i++) { k = Pinv ? Pinv [i] : i ; P [k] = i ; } cholmod_l_free (m, sizeof (Int), Pinv, cc) ; // ------------------------------------------------------------------------- // return results // ------------------------------------------------------------------------- pargout [0] = spqr_mx_put_permutation (P, m, TRUE, cc) ; cholmod_l_free (m, sizeof (Int), P, cc) ; if (nargout > 1) pargout [1] = spqr_mx_put_permutation (Q, n, TRUE, cc) ; cholmod_l_free (n, sizeof (Int), Q, cc) ; if (nargout > 2) pargout [2] = mxCreateDoubleScalar ((double) n1rows) ; if (nargout > 3) pargout [3] = mxCreateDoubleScalar ((double) n1cols) ; if (nargout > 4) pargout [4] = mxCreateDoubleScalar (tol) ; cholmod_l_finish (cc) ; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /****************************************************************************/ /* Input arguments */ /****************************************************************************/ #define IN_spike_matrix prhs[0] //ST1 #define IN_spike_vector prhs[1] //ST2 #define IN_Time_Length prhs[2] //T #define IN_Max_Num_Spikes prhs[3] //MaxSpike //Don't need this??!!! /****************************************************************************/ /* Output arguments */ /****************************************************************************/ #define OUT plhs[0] //int M, N, m, n; /* Since this is a custome C code, I will not checks for data type, assume user knows the valid type */ double TimeLength, MaxSpike; int i,j, M, N, Total_ROW, Num_rows_single_spike; int col, row, left_i, right_i; double *output, *spike_matrix, *spike_vector; double *Sorted_SpikeTimings, *spiketime_label; double sum, squaredCount; TimeLength = mxGetScalar(IN_Time_Length); MaxSpike = mxGetScalar(IN_Max_Num_Spikes); spike_matrix = mxGetPr(IN_spike_matrix); spike_vector = mxGetPr(IN_spike_vector); M = mxGetM(IN_spike_matrix); N = mxGetN(IN_spike_matrix); Num_rows_single_spike = mxGetM(IN_spike_vector); Total_ROW = M + Num_rows_single_spike; OUT = mxCreateDoubleMatrix(1, N, mxREAL); /* Create the output matrix */ output = mxGetPr(OUT); //=================================SORTING=================================Merge================================= //Sorted_SpikeTimings = (double**) malloc(Total_ROW * sizeof(double*)); //for (i = 0; i < Total_ROW; i++) //Sorted_SpikeTimings[i] = (double*) malloc(N * sizeof(double)); Sorted_SpikeTimings = (double*) malloc(Total_ROW * sizeof(double)); // Can be cut down to 1D array spiketime_label = (double*) malloc(Total_ROW * sizeof(double)); for(col = 0; col < N; col++) { left_i = 0; right_i = 0; row = 0; if(spike_matrix[col*M+left_i] == -1 && spike_vector[right_i] == -1) output[col] = 0.0; else{ while(left_i < M || right_i < Num_rows_single_spike){ //Check for empty spike trains if(spike_matrix[col*M+left_i] == -1) left_i = M; if(spike_vector[right_i] == -1) right_i = Num_rows_single_spike; if (left_i < M && right_i < Num_rows_single_spike){ if(spike_matrix[col*M+left_i] <= spike_vector[right_i]){ Sorted_SpikeTimings[row] = spike_matrix[col*M+left_i]; spiketime_label[row] = 1; left_i++; row++; } else{ Sorted_SpikeTimings[row] = spike_vector[right_i]; spiketime_label[row] = -1; right_i++; row++; } } else if (left_i < M){ while(left_i < M && spike_matrix[col*M+left_i] != -1){ Sorted_SpikeTimings[row] = spike_matrix[col*M+left_i]; spiketime_label[row] = 1; left_i++; row++; } break; } else if (right_i < Num_rows_single_spike){ while(right_i < Num_rows_single_spike && spike_vector[right_i] != -1){ Sorted_SpikeTimings[row] = spike_vector[right_i]; spiketime_label[row] = -1; right_i++; row++; } break; } } //what happens when ROW is < 2 (i.e., = 1)? sum = 0.0; squaredCount = spiketime_label[0]; for(i = 0; i<row-1; i++) { sum += (Sorted_SpikeTimings[i+1]-Sorted_SpikeTimings[i])*squaredCount*squaredCount; squaredCount += spiketime_label[i+1]; } sum += (TimeLength-Sorted_SpikeTimings[row-1])*squaredCount*squaredCount; //mexPrintf("Value We Need: %f\n\n",sum); output[col] = sum; } } //for (i = 0; i < Total_ROW; i++) // free(Sorted_SpikeTimings[i]); free(Sorted_SpikeTimings); free(spiketime_label); return; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { float *pOutputImage32f; unsigned short *pInputRowMap16u, *pInputColMap16u; unsigned short *pTopLeftOrg, *pBotRightMarg, *pKernelSize; unsigned char *pInputRefImage8u, *pInputTargetImage8u; unsigned short nPropRow16u, nPropCol16u; // Indices of propagation int nErrorAccum, nElementSqrDiff; mxArray *pMxArray[1]; int i, j, iRoi, jRoi; int m, n, mTarget, nTarget; int mOutput, nOutput; int nSingleChannelColNum, nSingleChannelColNumTarget;// Number of columns in single channel int nNumOfChannelElements, nNumOfChannelElementsTarget; int nNumOfROIElements; int nFirstRow, nLastRow; // Matlab indices int nFirstCol, nLastCol; // Matlab indices int nCurIterStep, nCurIterOffset, nCurIterStepTarget, nCurIterOffsetTarget; int nRoiOffset, nRoiOffsetTarget; int pChannelStep[2], pChannelStepTarget[2]; if (nrhs < 7 || nrhs > 8 || nlhs!=1) mexErrMsgTxt("Usage: outputImage=GetANNError_C3(inputRefImage8u_C3, inputTargetImage8u_C3, rowMapping16u, colMapping16u, TLboundary16u, BRboundary16u, nWidth16u, debugFlag(opt));\n"); if (mxGetClassID(prhs[0]) != mxUINT8_CLASS || mxGetClassID(prhs[1]) != mxUINT8_CLASS || mxGetClassID(prhs[2]) != mxUINT16_CLASS || mxGetClassID(prhs[3]) != mxUINT16_CLASS || mxGetClassID(prhs[4]) != mxUINT16_CLASS|| mxGetClassID(prhs[5]) != mxUINT16_CLASS || mxGetClassID(prhs[6]) != mxUINT16_CLASS) mexErrMsgTxt("input and target images must be uint8 matrices, row and column mapping images must be a uint16 matrices, top-left and bottom-right of ROI must be a uint16 scalars and kernel size must be a uint16 scalar!"); if (nrhs == 8) { debugEnable = (int)mxGetScalar(prhs[7]); } else debugEnable = 0; // Get inputs pInputRefImage8u = (unsigned char*)mxGetPr(prhs[0]); pInputTargetImage8u = (unsigned char*)mxGetPr(prhs[1]); pInputRowMap16u = (unsigned short*)mxGetPr(prhs[2]); pInputColMap16u = (unsigned short*)mxGetPr(prhs[3]); pTopLeftOrg = (unsigned short*)mxGetPr(prhs[4]); pBotRightMarg = (unsigned short*)mxGetPr(prhs[5]); pKernelSize = (unsigned short*)mxGetPr(prhs[6]); // Get sizes of variables (Opposite on purpose)// m = mxGetM(prhs[0]); // Width n = mxGetN(prhs[0]); // Height nSingleChannelColNum = n/3; mTarget = mxGetM(prhs[1]); // Width target nTarget = mxGetN(prhs[1]); // Height target nSingleChannelColNumTarget = nTarget/3; nNumOfChannelElements = nSingleChannelColNum * m; nNumOfChannelElementsTarget = nSingleChannelColNumTarget * mTarget; // Calc steps pChannelStep[0] = nNumOfChannelElements; pChannelStep[1] = 2*nNumOfChannelElements; pChannelStepTarget[0] = nNumOfChannelElementsTarget; pChannelStepTarget[1] = 2*nNumOfChannelElementsTarget; // Create output matrix mOutput = m-(*pBotRightMarg)-(*pTopLeftOrg); nOutput = nSingleChannelColNum-(*pBotRightMarg)-(*pTopLeftOrg); mOutput = m; nOutput = nSingleChannelColNum; plhs[0] = mxCreateNumericMatrix(mOutput, nOutput, mxSINGLE_CLASS, false); pOutputImage32f = (float*)mxGetPr(plhs[0]); // Initialize filter parameters nFirstRow = (int)(*pTopLeftOrg); nLastRow = (int)m-(*pBotRightMarg); nFirstCol = (int)(*pTopLeftOrg); nLastCol = (int)nSingleChannelColNum-(*pBotRightMarg); nNumOfROIElements = (*pKernelSize)*(*pKernelSize)*3; for (j=nFirstCol; j<nLastCol; j++) { nCurIterStep = j*m; nCurIterStepTarget = j*mTarget; for (i=nFirstRow; i<nLastRow; i++) { nCurIterOffset = nCurIterStep+i; nPropCol16u = pInputColMap16u[nCurIterOffset]; nPropRow16u = pInputRowMap16u[nCurIterOffset]; nCurIterOffsetTarget = (int)((nPropRow16u-1) + (nPropCol16u-1)*mTarget); // Translating matlab to C nErrorAccum = 0; for (jRoi = 0; jRoi<(*pKernelSize); jRoi++) { nRoiOffset = nCurIterOffset + jRoi*m; nRoiOffsetTarget = nCurIterOffsetTarget + jRoi*mTarget; for (iRoi = 0; iRoi<(*pKernelSize); iRoi++) { nElementSqrDiff = (int)pInputRefImage8u[nRoiOffset] - (int)pInputTargetImage8u[nRoiOffsetTarget]; nErrorAccum += nElementSqrDiff*nElementSqrDiff; nElementSqrDiff = (int)pInputRefImage8u[nRoiOffset+pChannelStep[0]] - (int)pInputTargetImage8u[nRoiOffsetTarget+pChannelStepTarget[0]]; nErrorAccum += nElementSqrDiff*nElementSqrDiff; nElementSqrDiff = (int)pInputRefImage8u[nRoiOffset+pChannelStep[1]] - (int)pInputTargetImage8u[nRoiOffsetTarget+pChannelStepTarget[1]]; nErrorAccum += nElementSqrDiff*nElementSqrDiff; nRoiOffset++; nRoiOffsetTarget++; } } pOutputImage32f[nCurIterOffset] = sqrt(nErrorAccum );// / (float)nNumOfROIElements; } } }
/* Function: mdlInitializeSampleTimes ========================================= * Abstract: * This function is used to specify the sample time(s) for your * S-function. You must register the same number of sample times as * specified in ssSetNumSampleTimes. */ static void mdlInitializeSampleTimes(SimStruct *S) { ssSetSampleTime(S, 0, mxGetScalar(ssGetSFcnParam(S, 0))); // tiempo de muestreo? ssSetOffsetTime(S, 0, 0.0); }
void mexFunction(int nlhs, mxArray *plhs[ ],int nrhs, const mxArray *prhs[ ]) { double *vol,*img; double *n,*n_z,*n_x,*n_y; double mask_r; double img_c_x,img_c_y; double vol_c_x,vol_c_y,vol_c_z; double img_r,z_lim; double z; double v_x,v_y,v_z; int i_v_x,i_v_y,i_v_z; int i1,j1,k1; double wt; double a_v_x,a_v_y,a_v_z; int v_size; int i,j; mwSignedIndex dims[3]; /**********************************************/ /*Retrieve the input data */ /* The volume */ img=mxGetPr(prhs[0]); v_size=mxGetM(prhs[0]); /* The coordinate system */ n=mxGetPr(prhs[1]); n_x=n; n_y=n+3; n_z=n+6; /* The radius */ mask_r=mxGetScalar(prhs[2]); /************************************************/ /* Create the output volume */ dims[0] = v_size; dims[1] = v_size; dims[2]= v_size; plhs[0] = mxCreateNumericArray(3, dims, mxDOUBLE_CLASS, mxREAL); vol=mxGetPr(plhs[0]); for (i=0;i<v_size*v_size*v_size;i++) *(vol+i)=0; /*************************************************/ /* Create constants */ img_c_x=v_size/2-0.0; img_c_y=v_size/2-0.0; vol_c_x=v_size/2-0.0; vol_c_y=v_size/2-0.0; vol_c_z=v_size/2-0.5; /**************************************************/ /* Back_project onto the image */ for (i=0;i<v_size;i++) for (j=0;j<v_size;j++) { /* Calculate the radius in the image */ img_r=sqrt((i-img_c_x)*(i-img_c_x)+(j-img_c_y)*(j-img_c_y)); /* If the radius is less than mask_r */ if (img_r < mask_r) { /* Radius is small, get the z limits */ z_lim=sqrt(mask_r*mask_r-img_r*img_r); for (z=-z_lim;z<=z_lim;z++) { /* Calculate an index into the volume */ /* Double indices */ /* v_x=((i-img_c_x)+vol_c_x); v_y=((j-img_c_y)+vol_c_y); v_z=(z+vol_c_z); */ v_x=(i-img_c_x)*(*n_x)+(j-img_c_y)*(*n_y)+z*(*n_z)+vol_c_x; v_y=(i-img_c_x)*(*(n_x+1))+(j-img_c_y)*(*(n_y+1))+z*(*(n_z+1))+vol_c_y; v_z=(i-img_c_x)*(*(n_x+2))+(j-img_c_y)*(*(n_y+2))+z*(*(n_z+2))+vol_c_z; /*Integer indices and fractional offsets */ i_v_x=(int)floor(v_x); i_v_y=(int)floor(v_y); i_v_z=(int)floor(v_z); a_v_x=v_x-(double)i_v_x; a_v_y=v_y-(double)i_v_y; a_v_z=v_z-(double)i_v_z; /* Multi-linear interpolation */ for (i1=0;i1<=1;i1++) for (j1=0;j1<=1;j1++) for (k1=0;k1<=1;k1++) { wt=((1-a_v_x)*(1-i1)+a_v_x*i1) *((1-a_v_y)*(1-j1)+a_v_y*j1) *((1-a_v_z)*(1-k1)+a_v_z*k1); *(vol+(i_v_x+i1)+(i_v_y+j1)*v_size+(i_v_z+k1)*v_size*v_size) += (*(img+i+j*v_size))*wt; } /* End k1 loop */ } /* End z loop */ } /* End img_r < mask_r condition */ } /* End j loop */ }
/* entry point */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { int ind, i, x, y, o, dataDim, j, bytes_to_copy, nGaborFilter; const mxArray *f; const mxArray *pAS1Map; mxArray *outPA; mwSize ndim; const mwSize* dims; mwSize dimsOutput[2]; void* start_of_pr; mxClassID datatype; /* * input variable 0: nGaborOri */ nGaborOri = (int)mxGetScalar(prhs[0]); /* * input variable 1: S1 maps */ pAS1Map = prhs[1]; dims = mxGetDimensions(pAS1Map); nGaborFilter = dims[0] * dims[1]; nGaborScale = nGaborFilter / nGaborOri; S1Map = (const float**)mxCalloc( nGaborFilter, sizeof(*S1Map) ); /* SUM1 maps */ for (i=0; i<nGaborFilter; ++i) { f = mxGetCell(pAS1Map, i); datatype = mxGetClassID(f); if (datatype != mxSINGLE_CLASS) mexErrMsgTxt("warning !! single precision required."); S1Map[i] = (const float*)mxGetPr(f); /* get the pointer to cell content */ height = mxGetM(f); /* overwriting is ok, since it is constant */ width = mxGetN(f); } /* * input variable 2: location shift radius */ locationPerturb = (int)mxGetScalar(prhs[2]); /* * input variable 3: orientation shift radius */ orientationPerturb = (int)mxGetScalar(prhs[3]); /* * input variable 4: sub sample step length */ subsample = (int)mxGetScalar(prhs[4]); StoreShift(); Compute(); /* ============================================= * Handle output variables. * ============================================= */ /* * output variable 0: M1 map */ dimsOutput[0] = 1; dimsOutput[1] = nGaborScale * nGaborOri; plhs[0] = mxCreateCellArray( 2, dimsOutput ); dimsOutput[0] = sizexSubsample; dimsOutput[1] = sizeySubsample; for( i = 0; i < nGaborOri * nGaborScale; ++i ) { outPA = mxCreateNumericArray( 2, dimsOutput, mxSINGLE_CLASS, mxREAL ); /* populate the real part of the created array */ start_of_pr = (float*)mxGetData(outPA); bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA); memcpy( start_of_pr, M1Map[i], bytes_to_copy ); mxSetCell( plhs[0], i, outPA ); } /* * output variable 1: M1 trace */ dimsOutput[0] = 1; dimsOutput[1] = nGaborScale * nGaborOri; plhs[1] = mxCreateCellArray( 2, dimsOutput ); dimsOutput[0] = sizexSubsample; dimsOutput[1] = sizeySubsample; for( i = 0; i < nGaborOri * nGaborScale; ++i ) { outPA = mxCreateNumericArray( 2, dimsOutput, mxINT32_CLASS, mxREAL ); /* populate the real part of the created array */ start_of_pr = (int*)mxGetData(outPA); bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA); memcpy( start_of_pr, M1Trace[i], bytes_to_copy ); mxSetCell( plhs[1], i, outPA ); } /* * output variable 2: stored Gabor shifts : row shifts */ dimsOutput[0] = nGaborScale * nGaborOri; dimsOutput[1] = 1; plhs[2] = mxCreateCellArray( 2, dimsOutput ); for( i = 0; i < nGaborScale*nGaborOri; ++i ) { dimsOutput[0] = numShift; dimsOutput[1] = 1; outPA = mxCreateNumericArray( 2, dimsOutput, mxINT32_CLASS, mxREAL ); start_of_pr = (int*)mxGetData(outPA); bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA); memcpy( start_of_pr, rowShift[i], bytes_to_copy ); mxSetCell( plhs[2], i, outPA ); } /* * output variable 3: stored Gabor shifts : col shifts */ dimsOutput[0] = nGaborScale * nGaborOri; dimsOutput[1] = 1; plhs[3] = mxCreateCellArray( 2, dimsOutput ); for( i = 0; i < nGaborScale*nGaborOri; ++i ) { dimsOutput[0] = numShift; dimsOutput[1] = 1; outPA = mxCreateNumericArray( 2, dimsOutput, mxINT32_CLASS, mxREAL ); start_of_pr = (int*)mxGetData(outPA); bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA); memcpy( start_of_pr, colShift[i], bytes_to_copy ); mxSetCell( plhs[3], i, outPA ); } /* * output variable 4: stored Gabor shifts : orientation shifts */ dimsOutput[0] = nGaborScale * nGaborOri; dimsOutput[1] = 1; plhs[4] = mxCreateCellArray( 2, dimsOutput ); for( i = 0; i < nGaborScale*nGaborOri; ++i ) { dimsOutput[0] = numShift; dimsOutput[1] = 1; outPA = mxCreateNumericArray( 2, dimsOutput, mxINT32_CLASS, mxREAL ); start_of_pr = (int*)mxGetData(outPA); bytes_to_copy = dimsOutput[0] * dimsOutput[1] * mxGetElementSize(outPA); memcpy( start_of_pr, orientShift[i], bytes_to_copy ); mxSetCell( plhs[4], i, outPA ); } }
void mexFunction(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[]) { char command[STRLEN]; char matlabcmd[STRLEN]; char cmd[STRLEN]; char *ptr; int poolsize, retval, block, num, i, status; #ifndef USE_PTHREADS HANDLE TName; InitializeCriticalSection(&enginemutex); #endif initFun(); mexAtExit(exitFun); /* the first argument is always the command string */ if (nrhs < 1) mexErrMsgTxt("invalid number of input arguments"); if (!mxIsChar(prhs[0])) mexErrMsgTxt("invalid input argument #1"); if (mxGetString(prhs[0], command, STRLEN - 1)) mexErrMsgTxt("invalid input argument #1"); /* convert to lower case */ ptr = command; while (*ptr) { *ptr = tolower(*ptr); ptr++; } /****************************************************************************/ if (strcmp(command, "open") == 0) { /* engine open num cmd */ if (nrhs < 2) mexErrMsgTxt("Invalid number of input arguments"); if (nrhs > 1) { if (!mxIsNumeric(prhs[1])) mexErrMsgTxt("Invalid input argument #2, should be numeric"); poolsize = mxGetScalar(prhs[1]); } if (nrhs > 2) { if (!mxIsChar(prhs[2])) mexErrMsgTxt("Invalid input argument #3, should be a string"); mxGetString(prhs[2], matlabcmd, STRLEN - 1); } else { sprintf(matlabcmd, "matlab"); } if (poolsize < 1) mexErrMsgTxt("The number of engines in the pool should be positive"); ENGINEMUTEX_LOCK; engine = engOpenSingleUse(NULL, NULL, &retval); /* returns NULL on failure */ ENGINEMUTEX_UNLOCK; if (!engine) { exitFun(); /* this cleans up all engines */ mexErrMsgTxt("failed to open MATLAB engine"); } } /****************************************************************************/ else if (strcmp(command, "close") == 0) { /* engine close */ exitFun(); retval = 0; plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL); mxGetPr(plhs[0])[0] = retval; } /****************************************************************************/ else if (strcmp(command, "put") == 0) { /* engine put num name val */ if (nrhs != 4) mexErrMsgTxt("Exactly four input arguments needed"); if (!mxIsNumeric(prhs[1])) mexErrMsgTxt("Argument #2 should be numeric"); num = mxGetScalar(prhs[1]); if (num < 1 || num > poolsize) mexErrMsgTxt("Invalid engine number"); if (!mxIsChar(prhs[2])) mexErrMsgTxt("Argument #3 should be a string"); ENGINEMUTEX_LOCK; retval = engPutVariable(engine, mxArrayToString(prhs[2]), prhs[3]); plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL); mxGetPr(plhs[0])[0] = retval; ENGINEMUTEX_UNLOCK; } /****************************************************************************/ else if (strcmp(command, "get") == 0) { /* engine get num name */ if (nrhs != 3) mexErrMsgTxt("Exactly three input arguments needed"); if (!mxIsNumeric(prhs[1])) mexErrMsgTxt("Argument #2 should be numeric"); if (!mxIsChar(prhs[2])) mexErrMsgTxt("Argument #3 should be a string"); num = mxGetScalar(prhs[1]); ENGINEMUTEX_LOCK; plhs[0] = engGetVariable(engine, mxArrayToString(prhs[2])); ENGINEMUTEX_UNLOCK; } /****************************************************************************/ else if (strcmp(command, "isbusy") == 0) { /* engine isbusy num */ if (nrhs != 2) mexErrMsgTxt("Exactly two input arguments needed"); if (!mxIsNumeric(prhs[1])) mexErrMsgTxt("Argument #2 should be numeric"); num = mxGetScalar(prhs[1]); ENGINEMUTEX_LOCK; plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL); mxGetPr(plhs[0])[0] = 1; ENGINEMUTEX_UNLOCK; } /****************************************************************************/ else if (strcmp(command, "eval") == 0) { /* engine eval num str block */ if (nrhs < 3) mexErrMsgTxt("At least three input arguments needed"); if (!mxIsNumeric(prhs[1])) mexErrMsgTxt("Argument #2 should be numeric"); num = mxGetScalar(prhs[1]); if (!mxIsChar(prhs[2])) mexErrMsgTxt("Invalid input argument #3, should be a string"); mxGetString(prhs[2], cmd, STRLEN - 1); if (nrhs > 3) { if (!mxIsNumeric(prhs[3])) mexErrMsgTxt("Invalid input argument #4, should be numeric"); block = mxGetScalar(prhs[3]); } else { block = 0; } ENGINEMUTEX_LOCK; if (!block) { #ifdef USE_PTHREADS retval = pthread_create(&(enginepool[num - 1].tid), NULL, (void *) &evalString, (void *) (enginepool + num - 1)); #else TName = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) evalString, (void *) (cmd), 0, NULL); #endif } else { retval = engEvalString(engine, cmd); } mexPrintf("Finished executing command, retval = %d\n", retval); ENGINEMUTEX_UNLOCK; WaitForSingleObject(TName, INFINITE); /* wait for the thread to become busy */ mexPrintf("Waiting for engine to become busy\n"); BUSYCOND_WAIT; mexPrintf("The engine has become busy\n"); plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL); mxGetPr(plhs[0])[0] = retval; } /****************************************************************************/ else if (strcmp(command, "poolsize") == 0) { /* engine poolsize */ ENGINEMUTEX_LOCK; plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL); mxGetPr(plhs[0])[0] = (engine!=0); ENGINEMUTEX_UNLOCK; } /****************************************************************************/ else if (strcmp(command, "info") == 0) { /* engine info */ ENGINEMUTEX_LOCK; mexPrintf("engine = %d\n", engine); ENGINEMUTEX_UNLOCK; } /****************************************************************************/ else { mexErrMsgTxt("unknown command"); return; } return; }
void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]){ int i; if(nrhs!=1){ mexPrintf("\nwriteFileNifti(niftiStruct)\n\n"); mexPrintf("Writes a NIFTI image based on fields of a structure that resembles\n"); mexPrintf("the NIFTI 1 standard (see http://nifti.nimh.nih.gov/nifti-1/ ).\n"); mexPrintf("See readFileNifti for details about the expected niftiStruct.\n\n"); return; }else if(nlhs>0) { mexPrintf("Too many output arguments"); return; } /* The first arg must be a nifti struct. */ if(!mxIsStruct(prhs[0])) mexErrMsgTxt("First arg must be a nifti struct."); const mxArray *mxnim = prhs[0]; // Sanity check that this is a complete NIFTI struct if(mxGetField(mxnim,0,"fname")==NULL || mxGetField(mxnim,0,"data")==NULL) myErrMsg("First argument must be a proper NIFTI struct (see readFileNifti).\n\n"); /* Create an empty NIFTI C struct */ nifti_image *nim = (nifti_image *)mxCalloc(1, sizeof(nifti_image)); if(!nim) myErrMsg("failed to allocate nifti image"); nim->nifti_type = 1; // We only support single-file NIFTI format /* Load the C-struct with fields from the matlab struct */ mxArray *fname = mxGetField(mxnim,0,"fname"); mxArray *data = mxGetField(mxnim,0,"data"); // fname field needs to be allocated int buflen = (mxGetN(fname)) + 1; nim->fname = (char *)mxCalloc(buflen, sizeof(char)); if(mxGetString(fname, nim->fname, buflen)) mexWarnMsgTxt("Not enough space- fname string is truncated."); nim->iname = NULL; nim->data = mxGetData(data); nim->ndim = mxGetNumberOfDimensions(data); nim->dim[0] = nim->ndim; const int *dims = mxGetDimensions(data); for(i=0; i<nim->ndim; i++) nim->dim[i+1] = dims[i]; for(i=nim->ndim+1; i<8; i++) nim->dim[i] = 1; // Why do I have to assign these explicitly? nim->nx = nim->dim[1]; nim->ny = nim->dim[2]; nim->nz = nim->dim[3]; nim->nt = nim->dim[4]; nim->nu = nim->dim[5]; nim->nv = nim->dim[6]; nim->nw = nim->dim[7]; //for(i=0; i<8; i++) mexPrintf("%d ",nim->dim[i]); mexPrintf("\n\n"); nim->nvox = mxGetNumberOfElements(data); // *** TO DO: we should support DT_RGB24 type (triplet of uint8) if(mxIsComplex(data)){ switch(mxGetClassID(data)){ case mxSINGLE_CLASS: nim->datatype=DT_COMPLEX64; nim->nbyper=8; break; case mxDOUBLE_CLASS: nim->datatype=DT_COMPLEX128; nim->nbyper=16; break; default: myErrMsg("Unknown data type!"); } }else{ switch(mxGetClassID(data)){ case mxUINT8_CLASS: nim->datatype=DT_UINT8; nim->nbyper=1; break; case mxINT8_CLASS: nim->datatype=DT_INT8; nim->nbyper=1; break; case mxUINT16_CLASS: nim->datatype=DT_UINT16; nim->nbyper=2; break; case mxINT16_CLASS: nim->datatype=DT_INT16; nim->nbyper=2; break; case mxUINT32_CLASS: nim->datatype=DT_UINT32; nim->nbyper=4; break; case mxINT32_CLASS: nim->datatype=DT_INT32; nim->nbyper=4; break; case mxUINT64_CLASS: nim->datatype=DT_UINT64; nim->nbyper=8; break; case mxINT64_CLASS: nim->datatype=DT_INT64; nim->nbyper=8; break; case mxSINGLE_CLASS: nim->datatype=DT_FLOAT32; nim->nbyper=4; break; case mxDOUBLE_CLASS: nim->datatype=DT_FLOAT64; nim->nbyper=8; break; default: mexErrMsgTxt("Unknown data type!"); } } double *pdPtr = (double *)mxGetData(mxGetField(mxnim,0,"pixdim")); int nPixDim = mxGetM(mxGetField(mxnim,0,"pixdim"))*mxGetN(mxGetField(mxnim,0,"pixdim")); if(nPixDim>8) nPixDim=8; for(i=0; i<nPixDim; i++) nim->pixdim[i+1] = (float)pdPtr[i]; // xxx dla fixed bug below (i was not being assigned). // for(nPixDim+1; i<8; i++) nim->pixdim[i] = (float)1.0; for(i = nPixDim+1; i<8; i++) nim->pixdim[i] = (float)1.0; nim->dx = nim->pixdim[1]; nim->dy = nim->pixdim[2]; nim->dz = nim->pixdim[3]; nim->dt = nim->pixdim[4]; nim->du = nim->pixdim[5]; nim->dv = nim->pixdim[6]; nim->dw = nim->pixdim[7]; nim->scl_slope = mxGetScalar(mxGetField(mxnim,0,"scl_slope")); nim->scl_inter = mxGetScalar(mxGetField(mxnim,0,"scl_inter")); nim->cal_min = mxGetScalar(mxGetField(mxnim,0,"cal_min")); nim->cal_max = mxGetScalar(mxGetField(mxnim,0,"cal_max")); nim->qform_code = (int)mxGetScalar(mxGetField(mxnim,0,"qform_code")); nim->sform_code = (int)mxGetScalar(mxGetField(mxnim,0,"sform_code")); nim->freq_dim = (int)mxGetScalar(mxGetField(mxnim,0,"freq_dim")); nim->phase_dim = (int)mxGetScalar(mxGetField(mxnim,0,"phase_dim")); nim->slice_dim = (int)mxGetScalar(mxGetField(mxnim,0,"slice_dim")); nim->slice_code = (int)mxGetScalar(mxGetField(mxnim,0,"slice_code")); nim->slice_start = (int)mxGetScalar(mxGetField(mxnim,0,"slice_start")); nim->slice_end = (int)mxGetScalar(mxGetField(mxnim,0,"slice_end")); nim->slice_duration = mxGetScalar(mxGetField(mxnim,0,"slice_duration")); /* if qform_code > 0, the quatern_*, qoffset_*, and qfac fields determine * the qform output, NOT the qto_xyz matrix; if you want to compute these * fields from the qto_xyz matrix, you can use the utility function * nifti_mat44_to_quatern() */ nim->quatern_b = mxGetScalar(mxGetField(mxnim,0,"quatern_b")); nim->quatern_c = mxGetScalar(mxGetField(mxnim,0,"quatern_c")); nim->quatern_d = mxGetScalar(mxGetField(mxnim,0,"quatern_d")); nim->qoffset_x = mxGetScalar(mxGetField(mxnim,0,"qoffset_x")); nim->qoffset_y = mxGetScalar(mxGetField(mxnim,0,"qoffset_y")); nim->qoffset_z = mxGetScalar(mxGetField(mxnim,0,"qoffset_z")); nim->qfac = mxGetScalar(mxGetField(mxnim,0,"qfac")); nim->pixdim[0] = nim->qfac; // pixdim[0] is the same as qfac (again- why duplicate the field?) double *sxPtr = (double *)mxGetData(mxGetField(mxnim,0,"sto_xyz")); for(i=0; i<16; i++) nim->sto_xyz.m[i%4][i/4] = (float)sxPtr[i]; nim->toffset = mxGetScalar(mxGetField(mxnim,0,"toffset")); // Allow units to be specified as a string char str[16]; mxGetString(mxGetField(mxnim,0,"xyz_units"),str,16); nim->xyz_units = getNiftiUnitCode(str); mxGetString(mxGetField(mxnim,0,"time_units"),str,16); nim->time_units = getNiftiUnitCode(str); nim->intent_code = (int)mxGetScalar(mxGetField(mxnim,0,"intent_code")); nim->intent_p1 = mxGetScalar(mxGetField(mxnim,0,"intent_p1")); nim->intent_p2 = mxGetScalar(mxGetField(mxnim,0,"intent_p2")); nim->intent_p3 = mxGetScalar(mxGetField(mxnim,0,"intent_p3")); mxGetString(mxGetField(mxnim,0,"intent_name"), nim->intent_name, 16); mxGetString(mxGetField(mxnim,0,"descrip"), nim->descrip, 80); mxGetString(mxGetField(mxnim,0,"aux_file"), nim->aux_file, 24); // *** TO DO: support extended header fileds! nim->num_ext = 0; /* I assume that we can rely on the nifti routine to byte-swap for us? */ nifti_image_write(nim); }
void LTFAT_NAME(ltfatMexFnc)( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { // Register exit function only once static int atExitFncRegistered = 0; if(!atExitFncRegistered) { LTFAT_NAME(ltfatMexAtExit)(LTFAT_NAME(dctMexAtExitFnc)); atExitFncRegistered = 1; } LTFAT_REAL *c_r, *c_i; const LTFAT_REAL *f_r, *f_i; dct_kind kind; mwIndex L = mxGetM(prhs[0]); mwIndex W = mxGetN(prhs[0]); mwIndex type = (mwIndex) mxGetScalar(prhs[1]); // Copy inputs and get pointers if( mxIsComplex(prhs[0])) { f_i = mxGetImagData(prhs[0]); plhs[0] = ltfatCreateMatrix(L, W, LTFAT_MX_CLASSID, mxCOMPLEX); c_i = mxGetImagData(plhs[0]); } else { plhs[0] = ltfatCreateMatrix(L, W, LTFAT_MX_CLASSID, mxREAL); } f_r = mxGetData(prhs[0]); c_r = mxGetData(plhs[0]); switch(type) { case 1: kind = DSTI; break; case 2: kind = DSTII; break; case 3: kind = DSTIII; break; case 4: kind = DSTIV; break; default: mexErrMsgTxt("Unknown type."); } LTFAT_FFTW(plan) p = LTFAT_NAME(dst_init)( L, W, c_r, kind); LTFAT_NAME(dctMexAtExitFnc)(); LTFAT_NAME(p_old) = p; LTFAT_NAME(dst_execute)(p,f_r,L,W,c_r,kind); if( mxIsComplex(prhs[0])) { LTFAT_NAME(dst_execute)(p,f_i,L,W,c_i,kind); } return; }