void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
// Check for proper number of arguments
if (nrhs != 2)
mexErrMsgTxt("Two input arguments required.");
if (nlhs != 4)
mexErrMsgTxt("Four output arguments required.");
// The input must be noncomplex
if (mxIsComplex(prhs[0]) || mxIsComplex(prhs[1]) ||
!mxIsNumeric(prhs[0]) || !mxIsNumeric(prhs[1]))
mexErrMsgTxt("The input must be noncomplex (and numeric).");
// The second input must be an unsigned integer
if (mxIsSingle(prhs[1]) || mxIsDouble(prhs[1]))
mexErrMsgTxt("The second input must be an integer.");
if (mxIsSingle(prhs[0])) {
if (mxIsInt8(prhs[1]))
compute<float, char>(plhs, prhs);
else if (mxIsUint8(prhs[1]))
compute<float, unsigned char>(plhs, prhs);
else if (mxIsInt16(prhs[1]))
compute<float, short>(plhs, prhs);
else if (mxIsUint16(prhs[1]))
compute<float, unsigned short>(plhs, prhs);
else if (mxIsInt32(prhs[1]))
compute<float, int>(plhs, prhs);
else if (mxIsUint32(prhs[1]))
compute<float, unsigned int>(plhs, prhs);
else if (mxIsInt64(prhs[1]))
compute<float, long long int>(plhs, prhs);
else if (mxIsUint64(prhs[1]))
compute<float, unsigned long long int>(plhs, prhs);
}
else if (mxIsDouble(prhs[0])) {
if (mxIsInt8(prhs[1]))
compute<double, char>(plhs, prhs);
else if (mxIsUint8(prhs[1]))
compute<double, unsigned char>(plhs, prhs);
else if (mxIsInt16(prhs[1]))
compute<double, short>(plhs, prhs);
else if (mxIsUint16(prhs[1]))
compute<double, unsigned short>(plhs, prhs);
else if (mxIsInt32(prhs[1]))
compute<double, int>(plhs, prhs);
else if (mxIsUint32(prhs[1]))
compute<double, unsigned int>(plhs, prhs);
else if (mxIsInt64(prhs[1]))
compute<double, long long int>(plhs, prhs);
else if (mxIsUint64(prhs[1]))
compute<double, unsigned long long int>(plhs, prhs);
}
else
mexErrMsgTxt("Input types not supported.");
}
void check_argin(int nrhs, const mxArray *prhs[])
{
if (nrhs > 2 || nrhs < 1)
mxErrMsgTxt("TZ_SEGDETECTOR takes 1~3 arguments.");
if (!mxIsInt8(prhs[0]))
mxErrMsgTxt("The first argument must be an int8 array.");
if (!tz_mxIsVector(prhs[0]))
mxErrMsgTxt("The first argument must be a vector.");
if (nrhs >= 2)
if (!mxIsInt8(prhs[1]))
mxErrMsgTxt("The first argument must be an int8 scalar.");
}
const char *mxGetClassName(const mxArray *ptr)
{
if (mxIsDouble(ptr))
{
return "double";
}
if (mxIsChar(ptr))
{
return "char";
}
if (mxIsLogical(ptr))
{
return "bool";
}
if (mxIsSparse(ptr))
{
return "sparse";
}
if (mxIsInt8(ptr))
{
return "int8";
}
if (mxIsInt16(ptr))
{
return "int16";
}
if (mxIsInt32(ptr))
{
return "int32";
}
if (mxIsInt64(ptr))
{
return "int64";
}
if (mxIsUint8(ptr))
{
return "uint8";
}
if (mxIsUint16(ptr))
{
return "uint16";
}
if (mxIsUint32(ptr))
{
return "uint32";
}
if (mxIsUint64(ptr))
{
return "uint64";
}
if (mxIsCell(ptr))
{
return "cell";
}
if (mxIsStruct(ptr))
{
return "struct";
}
return "unknown";
}
int mxGetElementSize(const mxArray *ptr)
{
if (mxIsChar(ptr))
{
return sizeof(wchar_t*);
}
else if (mxIsLogical(ptr))
{
return sizeof(int);
}
else if (mxIsDouble(ptr))
{
return sizeof(double);
}
else if (mxIsSparse(ptr))
{
return sizeof(double);
}
else if (mxIsInt8(ptr))
{
return sizeof(char);
}
else if (mxIsInt16(ptr))
{
return sizeof(short);
}
else if (mxIsInt32(ptr))
{
return sizeof(int);
}
else if (mxIsInt64(ptr))
{
return sizeof(long long);
}
else if (mxIsUint8(ptr))
{
return sizeof(unsigned char);
}
else if (mxIsUint16(ptr))
{
return sizeof(unsigned short);
}
else if (mxIsUint32(ptr))
{
return sizeof(unsigned int);
}
else if (mxIsUint64(ptr))
{
return sizeof(unsigned long long);
}
else if (mxIsCell(ptr))
{
return sizeof(types::InternalType*);
}
else if (mxIsStruct(ptr))
{
return sizeof(types::SingleStruct*);
}
return 0;
}
static MAPTYPE *get_maps_3dvol(const mxArray *ptr, int *n)
{
int num_dims, jj, t, dtype = 0;
const mwSize *dims;
MAPTYPE *maps;
unsigned char *dptr;
if (mxIsDouble(ptr)) dtype = SPM_DOUBLE;
else if (mxIsSingle(ptr)) dtype = SPM_FLOAT;
else if (mxIsInt32 (ptr)) dtype = SPM_SIGNED_INT;
else if (mxIsUint32(ptr)) dtype = SPM_UNSIGNED_INT;
else if (mxIsInt16 (ptr)) dtype = SPM_SIGNED_SHORT;
else if (mxIsUint16(ptr)) dtype = SPM_UNSIGNED_SHORT;
else if (mxIsInt8 (ptr)) dtype = SPM_SIGNED_CHAR;
else if (mxIsUint8 (ptr)) dtype = SPM_UNSIGNED_CHAR;
else mexErrMsgTxt("Unknown volume datatype.");
maps = (MAPTYPE *)mxCalloc(1, sizeof(MAPTYPE));
num_dims = mxGetNumberOfDimensions(ptr);
if (num_dims > 3)
{
mexErrMsgTxt("Too many dimensions.");
}
dims = mxGetDimensions(ptr);
for(jj=0; jj<num_dims; jj++)
maps->dim[jj]=dims[jj];
for(jj=num_dims; jj<3; jj++)
maps->dim[jj]=1;
for(jj=0; jj<16; jj++)
maps->mat[jj] = 0.0;
for(jj=0; jj<4; jj++)
maps->mat[jj + jj*4] = 1.0;
maps->dtype = dtype;
maps->data = (void **)mxCalloc(maps->dim[2],sizeof(void *));
maps->scale = (double *)mxCalloc(maps->dim[2],sizeof(double));
maps->offset = (double *)mxCalloc(maps->dim[2],sizeof(double));
t = maps->dim[0]*maps->dim[1]*get_datasize(maps->dtype)/8;
dptr = (unsigned char *)mxGetPr(ptr);
for(jj=0; jj<maps->dim[2]; jj++)
{
maps->scale[jj] = 1.0;
maps->offset[jj] = 0.0;
maps->data[jj] = &(dptr[jj*t]);
}
maps->addr = 0;
maps->len = 0;
*n = 1;
return(maps);
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/* Check arguments */
if (nrhs < 4)
mexErrMsgTxt("Need four input arguments.");
if (!mxIsInt8(prhs[0])) {
mexErrMsgTxt("Map needs to be int8 array");
}
char *im = (char *)mxGetData(prhs[0]);
int nx = mxGetM(prhs[0]);
int ny = mxGetN(prhs[0]);
double *x_im = mxGetPr(prhs[1]);
double xmin = x_im[0];
double xmax = x_im[mxGetNumberOfElements(prhs[1])-1];
double xresolution = (xmax-xmin)/(nx-1);
//printf("x: %.3f %.3f %.3f\n", xmin, xmax, xresolution);
double *y_im = mxGetPr(prhs[2]);
double ymin = y_im[0];
double ymax = y_im[mxGetNumberOfElements(prhs[2])-1];
double yresolution = (ymax-ymin)/(ny-1);
//printf("y: %.3f %.3f %.3f\n", ymin, ymax, yresolution);
double *vp = mxGetPr(prhs[3]);
if (mxGetM(prhs[3]) != 3) {
mexErrMsgTxt("Point array needs to contain 3 rows");
}
int np = mxGetN(prhs[3]);
double af = 0.5;
if (nrhs >= 5) {
af = mxGetScalar(prhs[4]);
}
for (int k = 0; k < np; k++) {
int ix = (int) round((vp[3*k]-xmin)/xresolution);
int iy = (int) round((vp[3*k+1]-ymin)/yresolution);
// printf("ix,iy = %d,%d\n",ix,iy);
if ((ix >= 0) && (ix < nx) && (iy >= 0) && (iy < ny)) {
int index = ix + nx*iy;
int s = im[index] + af*(vp[3*k+2] - im[index]);
if (s >= 127) s = 127;
if (s <= -128) s = -128;
im[index] = s;
}
}
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
}
void mxSetImagData(mxArray *array_ptr, void *data_ptr)
{
if (mxIsChar(array_ptr))
{
((String *)array_ptr)->setImg((wchar_t **)data_ptr);
}
else if (mxIsDouble(array_ptr))
{
((Double *)array_ptr)->setImg((double *)data_ptr);
}
else if (mxIsInt8(array_ptr))
{
((Int8 *)array_ptr)->setImg((char *)data_ptr);
}
else if (mxIsInt16(array_ptr))
{
((Int16 *)array_ptr)->setImg((short *)data_ptr);
}
else if (mxIsInt32(array_ptr))
{
((Int32 *)array_ptr)->setImg((int *)data_ptr);
}
else if (mxIsInt64(array_ptr))
{
((Int64 *)array_ptr)->setImg((long long *)data_ptr);
}
else if (mxIsLogical(array_ptr))
{
((Bool *)array_ptr)->setImg((int *)data_ptr);
}
// else if (mxIsSingle(array_ptr)) {
// ((Float *) array_ptr)->setImg((float *) data_ptr);
// }
else if (mxIsUint8(array_ptr))
{
((UInt8 *)array_ptr)->setImg((unsigned char *)data_ptr);
}
else if (mxIsUint16(array_ptr))
{
((UInt16 *)array_ptr)->setImg((unsigned short *)data_ptr);
}
else if (mxIsUint32(array_ptr))
{
((UInt32 *)array_ptr)->setImg((unsigned int *)data_ptr);
}
else if (mxIsUint64(array_ptr))
{
((UInt64 *)array_ptr)->setImg((unsigned long long *) data_ptr);
}
}
void mxSetImagData(mxArray *array_ptr, void *data_ptr)
{
if (mxIsChar(array_ptr))
{
((types::String *)array_ptr)->setImg((wchar_t **)data_ptr);
}
else if (mxIsDouble(array_ptr))
{
((types::Double *)array_ptr)->setImg((double *)data_ptr);
}
else if (mxIsInt8(array_ptr))
{
((types::Int8 *)array_ptr)->setImg((char *)data_ptr);
}
else if (mxIsInt16(array_ptr))
{
((types::Int16 *)array_ptr)->setImg((short *)data_ptr);
}
else if (mxIsInt32(array_ptr))
{
((types::Int32 *)array_ptr)->setImg((int *)data_ptr);
}
else if (mxIsInt64(array_ptr))
{
((types::Int64 *)array_ptr)->setImg((long long *)data_ptr);
}
else if (mxIsLogical(array_ptr))
{
((types::Bool *)array_ptr)->setImg((int *)data_ptr);
}
else if (mxIsUint8(array_ptr))
{
((types::UInt8 *)array_ptr)->setImg((unsigned char *)data_ptr);
}
else if (mxIsUint16(array_ptr))
{
((types::UInt16 *)array_ptr)->setImg((unsigned short *)data_ptr);
}
else if (mxIsUint32(array_ptr))
{
((types::UInt32 *)array_ptr)->setImg((unsigned int *)data_ptr);
}
else if (mxIsUint64(array_ptr))
{
((types::UInt64 *)array_ptr)->setImg((unsigned long long *) data_ptr);
}
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/* arguments:
*
* img - image (m-by-n-by-k float, i.e. float image[k][n][m])
* w - window (m-by-n char, i.e. char w[n][m])
*/
if (nrhs != 2)
mexErrMsgTxt("Wrong number of arguments (expected: image, window).");
if (!mxIsSingle(prhs[0]) || mxGetNumberOfDimensions(prhs[0]) != 3 ||
mxIsComplex(prhs[0]))
mexErrMsgTxt("Image should be a 3D array of real singles.");
if (!mxIsInt8(prhs[1]) || mxGetNumberOfDimensions(prhs[1]) != 2 ||
mxIsComplex(prhs[1]))
mexErrMsgTxt("Window should be a 2D array of real int8s.");
const mwSize *imgdims = mxGetDimensions(prhs[0]);
const mwSize imgx = imgdims[0];
const mwSize imgy = imgdims[1];
const mwSize imgz = imgdims[2];
float *img = (float*)mxGetPr(prhs[0]);
size_t wx = mxGetM(prhs[1]);
size_t wy = mxGetN(prhs[1]);
char *w = (char*)mxGetPr(prhs[1]);
if (!(wx % 2) || !(wy % 2))
mexErrMsgTxt("Window size should be odd-by-odd.");
plhs[0] = mxCreateNumericArray(3, imgdims, mxSINGLE_CLASS, mxREAL);
float *newimg = (float*)mxGetPr(plhs[0]);
#pragma omp parallel for schedule(static) num_threads(4)
for (size_t k = 0; k < imgz; k++)
{
size_t offs = imgx * imgy * k;
dilate(img + offs, newimg + offs, imgx, imgy, w, wx, wy);
}
}
//-------------------------------------------------------------------
void mexFunction(int POutputCount, mxArray* POutput[], int PInputCount, const mxArray *PInputs[])
{
const int *SZ;
double* LInput;
double* LInputI;
double* LOutputSum;
double* LOutputSumI;
double* LOutputCount;
double* LOutputSum2;
double* LOutputSum4;
double x, x2;
unsigned long LCount, LCountI;
double LSum, LSum2, LSum4;
unsigned DIM = 0;
unsigned long D1, D2, D3; // NN; //
unsigned ND, ND2; // number of dimensions: input, output
unsigned long ix1, ix2; // index to input and output
unsigned j, k, l; // running indices
int *SZ2; // size of output
// check for proper number of input and output arguments
if ((PInputCount <= 0) || (PInputCount > 2))
mexErrMsgTxt("SumSkipNan.MEX requires 1 or 2 arguments.");
if (POutputCount > 4)
mexErrMsgTxt("SumSkipNan.MEX has 1 to 4 output arguments.");
// get 1st argument
if(mxIsDouble(PInputs[0]))
LInput = mxGetPr(PInputs[0]);
else
mexErrMsgTxt("First argument must be DOUBLE.");
if(mxIsLogical(PInputs[0]))
LInput = (double*)mxGetLogicals(PInputs[0]);
else if(mxIsNumeric(PInputs[0]))
LInput = mxGetPr(PInputs[0]);
else if(mxIsSparse(PInputs[0]))
LInput = mxGetPr(PInputs[0]);
else if(mxIsInt8(PInputs[0]))
LInput = (double *)mxGetData(PInputs[0]);
else if(mxIsUint8(PInputs[0]))
LInput = (double *)mxGetData(PInputs[0]);
else if(mxIsInt16(PInputs[0]))
LInput = (double *)mxGetData(PInputs[0]);
else if(mxIsUint16(PInputs[0]))
LInput = (double *)mxGetData(PInputs[0]);
else if(mxIsInt32(PInputs[0]))
LInput = (double *)mxGetData(PInputs[0]);
else if(mxIsUint32(PInputs[0]))
LInput = (double *)mxGetData(PInputs[0]);
else
mexErrMsgTxt("First argument must be NUMERIC.");
if(mxIsComplex(PInputs[0]))
LInputI = mxGetPi(PInputs[0]);
if(mxIsComplex(PInputs[0]) & (POutputCount > 3))
mexErrMsgTxt("More than 3 output arguments only supported for REAL data ");
// get 2nd argument
if (PInputCount == 2){
switch (mxGetNumberOfElements(PInputs[1])) {
case 0: x = 0.0; // accept empty element
break;
case 1: x = (mxIsNumeric(PInputs[1]) ? mxGetScalar(PInputs[1]) : -1.0);
break;
default:x = -1.0; // invalid
}
if ((x < 0) || (x > 65535) || (x != floor(x)))
mexErrMsgTxt("Error SUMSKIPNAN.MEX: DIM-argument must be a positive integer scalar");
DIM = (unsigned)floor(x);
}
// get size
ND = mxGetNumberOfDimensions(PInputs[0]);
// NN = mxGetNumberOfElements(PInputs[0]);
SZ = mxGetDimensions(PInputs[0]);
// if DIM==0 (undefined), look for first dimension with more than 1 element.
for (k = 0; (DIM < 1) && (k < ND); k++)
if (SZ[k]>1) DIM = k+1;
if (DIM < 1) DIM=1; // in case DIM is still undefined
ND2 = (ND>DIM ? ND : DIM); // number of dimensions of output
SZ2 = (int*)mxCalloc(ND2, sizeof(int)); // allocate memory for output size
for (j=0; j<ND; j++) // copy size of input;
SZ2[j] = SZ[j];
for (j=ND; j<ND2; j++) // in case DIM > ND, add extra elements 1
SZ2[j] = 1;
for (j=0, D1=1; j<DIM-1; D1=D1*SZ2[j++]); // D1 is the number of elements between two elements along dimension DIM
D2 = SZ2[DIM-1]; // D2 contains the size along dimension DIM
for (j=DIM, D3=1; j<ND; D3=D3*SZ2[j++]); // D3 is the number of blocks containing D1*D2 elements
SZ2[DIM-1] = 1; // size of output is same as size of input but SZ(DIM)=1;
// create outputs
#define TYP mxDOUBLE_CLASS
if(mxIsComplex(PInputs[0]))
{ POutput[0] = mxCreateNumericArray(ND2, SZ2, TYP, mxCOMPLEX);
LOutputSum = mxGetPr(POutput[0]);
LOutputSumI= mxGetPi(POutput[0]);
}
else
{ POutput[0] = mxCreateNumericArray(ND2, SZ2, TYP, mxREAL);
LOutputSum = mxGetPr(POutput[0]);
}
if (POutputCount >= 2){
POutput[1] = mxCreateNumericArray(ND2, SZ2, TYP, mxREAL);
LOutputCount = mxGetPr(POutput[1]);
}
if (POutputCount >= 3){
POutput[2] = mxCreateNumericArray(ND2, SZ2, TYP, mxREAL);
LOutputSum2 = mxGetPr(POutput[2]);
}
if (POutputCount >= 4){
POutput[3] = mxCreateNumericArray(ND2, SZ2, TYP, mxREAL);
LOutputSum4 = mxGetPr(POutput[3]);
}
mxFree(SZ2);
// OUTER LOOP: along dimensions > DIM
for (l = 0; l<D3; l++)
{
ix2 = l*D1; // index for output
ix1 = ix2*D2; // index for input
// Inner LOOP: along dimensions < DIM
for (k = 0; k<D1; k++, ix1++, ix2++)
{
LCount = 0;
LSum = 0.0;
LSum2 = 0.0;
LSum4 = 0.0;
// LOOP along dimension DIM
for (j=0; j<D2; j++)
{
x = LInput[ix1 + j*D1];
if (!mxIsNaN(x))
{
LCount++;
LSum += x;
x2 = x*x;
LSum2 += x2;
LSum4 += x2*x2;
}
}
LOutputSum[ix2] = LSum;
if (POutputCount >= 2)
LOutputCount[ix2] = (double)LCount;
if (POutputCount >= 3)
LOutputSum2[ix2] = LSum2;
if (POutputCount >= 4)
LOutputSum4[ix2] = LSum4;
if(mxIsComplex(PInputs[0]))
{
LSum = 0.0;
LCountI = 0;
LSum2 = 0.0;
for (j=0; j<D2; j++)
{
x = LInputI[ix1 + j*D1];
if (!mxIsNaN(x))
{
LCountI++;
LSum += x;
LSum2 += x*x;
}
}
LOutputSumI[ix2] = LSum;
if (LCount != LCountI)
mexErrMsgTxt("Number of NaNs is different for REAL and IMAG part");
if (POutputCount >= 3)
LOutputSum2[ix2] += LSum2;
}
}
}
}
int isFunctionHandle( const mxArray* const M )
{
if ( M == NULL )
return 0;
if ( mxIsCell(M) )
return 0;
if ( mxIsChar(M) )
return 0;
if ( mxIsComplex(M) )
return 0;
if ( mxIsDouble(M) )
return 0;
if ( mxIsEmpty(M) )
return 0;
if ( mxIsInt8(M) )
return 0;
if ( mxIsInt16(M) )
return 0;
if ( mxIsInt32(M) )
return 0;
if ( mxIsLogical(M) )
return 0;
if ( mxIsLogicalScalar(M) )
return 0;
if ( mxIsLogicalScalarTrue(M) )
return 0;
if ( mxIsNumeric(M) )
return 0;
if ( mxIsSingle(M) )
return 0;
if ( mxIsSparse(M) )
return 0;
if ( mxIsStruct(M) )
return 0;
if ( mxIsUint8(M) )
return 0;
if ( mxIsUint16(M) )
return 0;
if ( mxIsUint32(M) )
return 0;
// assume to be a function handle iff it is nothing else
return 1;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
// check the arguments
if(nrhs != 3 && nrhs !=2 && nrhs!=4)
mexErrMsgTxt("Usage [jointprob_table, marginprob_1, marginprob2] = progname(vector1, vector2, maxstatenum, b_returnprob). \n(Both vectors can be images). Max range handled: INT type of the OS");
if(nlhs > 3)
mexErrMsgTxt("Too many output argument <jointprob_table>.");
if (!mxIsInt8(prhs[0]) && !mxIsUint8(prhs[0]) && !mxIsDouble(prhs[0]) )
mexErrMsgTxt("The first input argument must be types of INT8 or UINT8 or DOUBLE.");
if (!mxIsInt8(prhs[1]) && !mxIsUint8(prhs[1]) && !mxIsDouble(prhs[1]) )
mexErrMsgTxt("The second input argument must be types of INT8 or UINT8 or DOUBLE.");
//get and check size information
long i,j;
void *img1 = (void *)mxGetData(prhs[0]);
long len1 = mxGetNumberOfElements(prhs[0]);
mxClassID type1 = mxGetClassID(prhs[0]);
void *img2 = (void *)mxGetData(prhs[1]);
long len2 = mxGetNumberOfElements(prhs[1]);
mxClassID type2 = mxGetClassID(prhs[1]);
if (!img1 || !img2 || !len1 || !len2)
mexErrMsgTxt("At least one of the input vectors is invalid.");
if (len1!=len2)
mexErrMsgTxt("The two vectors/images should have the same length.");
int b_findstatenum = 1;
int nstate1 = 0, nstate2 = 0;
if (nrhs>=3)
{
b_findstatenum = 0;
long MaxGrayLevel = (long) mxGetScalar(prhs[2]);
nstate1 = nstate2 = MaxGrayLevel;
if (MaxGrayLevel<=1)
{
printf("The argument #state is invalid. This program will decide #state itself.\n");
b_findstatenum = 1;
}
}
int b_returnprob = 1;
if (nrhs>=4)
{
b_returnprob = (mxGetScalar(prhs[3])!=0);
}
//copy data into new INT type array (hence quantization) and then reange them begin from 0 (i.e. state1)
int * vec1 = new int[len1];
int * vec2 = new int[len2];
int nrealstate1=0, nrealstate2=0;
switch(type1)
{
case mxINT8_CLASS: copyvecdata((char *)img1,len1,vec1,nrealstate1); break;
case mxUINT8_CLASS: copyvecdata((unsigned char *)img1,len1,vec1,nrealstate1); break;
case mxDOUBLE_CLASS: copyvecdata((double *)img1,len1,vec1,nrealstate1); break;
}
switch(type2)
{
case mxINT8_CLASS: copyvecdata((char *)img2,len2,vec2,nrealstate2); break;
case mxUINT8_CLASS: copyvecdata((unsigned char *)img2,len2,vec2,nrealstate2); break;
case mxDOUBLE_CLASS: copyvecdata((double *)img2,len2,vec2,nrealstate2); break;
}
//update the #state when necessary
if (nstate1<nrealstate1)
{
nstate1 = nrealstate1;
// printf("First vector #state = %i\n",nrealstate1);
}
if (nstate2<nrealstate2)
{
nstate2 = nrealstate2;
// printf("Second vector #state = %i\n",nrealstate2);
}
//generate the joint-distribution table
plhs[0] = mxCreateDoubleMatrix(nstate1,nstate2,mxREAL);
double *hab = (double *) mxGetPr(plhs[0]);
double **hab2d = new double * [nstate2];
for(j=0;j<nstate2;j++)
hab2d[j] = hab + (long)j*nstate1;
for (i=0; i<nstate1;i++)
for (j=0; j<nstate2;j++)
{
hab2d[j][i] = 0;
}
for (i=0;i<len1;i++)
{
//old method -- slow
// indx = (long)(vec2[i]) * nstate1 + vec1[i];
// hab[indx] += 1;
//new method -- fast
hab2d[vec2[i]][vec1[i]] += 1;
}
//return the probabilities, otherwise return count numbers
if(b_returnprob)
{
for (i=0; i<nstate1;i++)
for (j=0; j<nstate2;j++)
{
hab2d[j][i] /= len1;
}
}
//for nlhs>=2
if (nlhs>=2)
{
plhs[1] = mxCreateDoubleMatrix(nstate1,1,mxREAL);
double *ha = (double *)mxGetPr(plhs[1]);
for (i=0;i<nstate1;i++) {ha[i] = 0;}
for (i=0;i<nstate1;i++)
for (j=0;j<nstate2;j++)
{
ha[i] += hab2d[j][i];
}
}
if (nlhs>=3)
{
plhs[2] = mxCreateDoubleMatrix(nstate2,1,mxREAL);
double *hb = (double *)mxGetPr(plhs[2]);
for (j=0;j<nstate2;j++) {hb[j] = 0;}
for (i=0;i<nstate1;i++)
for (j=0;j<nstate2;j++)
{
hb[j] += hab2d[j][i];
}
}
//finish
if (hab2d) {delete []hab2d;}
if (vec1) delete []vec1;
if (vec2) delete []vec2;
return;
}
int mxIsClass(const mxArray *ptr, const char *name)
{
if (strcmp(name, "cell") == 0)
{
return mxIsCell(ptr);
}
if (strcmp(name, "char") == 0)
{
return mxIsChar(ptr);
}
if (strcmp(name, "double") == 0)
{
return mxIsDouble(ptr);
}
if (strcmp(name, "int8") == 0)
{
return mxIsInt8(ptr);
}
if (strcmp(name, "int16") == 0)
{
return mxIsInt16(ptr);
}
if (strcmp(name, "int32") == 0)
{
return mxIsInt32(ptr);
}
if (strcmp(name, "int64") == 0)
{
return mxIsInt64(ptr);
}
if (strcmp(name, "logical") == 0)
{
return mxIsLogical(ptr);
}
if (strcmp(name, "single") == 0)
{
return mxIsSingle(ptr);
}
if (strcmp(name, "struct") == 0)
{
return mxIsStruct(ptr);
}
if (strcmp(name, "uint8") == 0)
{
return mxIsUint8(ptr);
}
if (strcmp(name, "uint16") == 0)
{
return mxIsUint16(ptr);
}
if (strcmp(name, "uint32") == 0)
{
return mxIsUint32(ptr);
}
if (strcmp(name, "uint64") == 0)
{
return mxIsUint64(ptr);
}
// TODO: how to handle <class_name> and <class_id>?
return 0;
}
int mxIsNumeric(const mxArray *ptr)
{
return mxIsDouble(ptr) || mxIsSingle(ptr) ||
mxIsInt8(ptr) || mxIsUint8(ptr) ||
mxIsInt16(ptr) || mxIsUint16(ptr) || mxIsInt32(ptr) || mxIsUint32(ptr) || mxIsInt64(ptr) || mxIsUint64(ptr);
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
int i, j, nx, ny, n_read = 0, n_points = 0, one_or_zero;
int n_output = 0, n_fields, n_pts, ii, jj, GMT_pad[4];
int error = FALSE, suppress = FALSE, node = FALSE, z_only = FALSE;
int is_double = FALSE, is_single = FALSE, is_int32 = FALSE, is_int16 = FALSE;
int is_uint16 = FALSE, is_uint8 = FALSE, is_int8 = FALSE;
int free_copy = TRUE, need_padding = FALSE, row_maj = FALSE;
double value, west, east, south, north, threshold = 1.0, i_dx, i_dy, half, *in, *out;
float *f;
int i2, argc = 0, nc_h, nr_h, mx, n_arg_no_char = 0, *i_4, interpolant = BCR_BICUBIC;
short int *i_2;
unsigned short int *ui_2;
char **argv, *i_1;
unsigned char *ui_1;
float *z_4;
double *pdata_d, *z_8, *head;
struct GRD_HEADER grd;
struct GMT_EDGEINFO edgeinfo;
struct GMT_BCR bcr;
argc = nrhs;
for (i = 0; i < nrhs; i++) { /* Check input to find how many arguments are of type char */
if(!mxIsChar(prhs[i])) {
argc--;
n_arg_no_char++; /* Number of arguments that have a type other than char */
}
}
argc++; /* to account for the program's name to be inserted in argv[0] */
/* get the length of the input string */
argv = (char **)mxCalloc(argc, sizeof(char *));
argv[0] = "grdtrack_m";
for (i = 1; i < argc; i++)
argv[i] = (char *)mxArrayToString(prhs[i+n_arg_no_char-1]);
west = east = south = north = 0.0;
GMT_boundcond_init (&edgeinfo);
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
switch (argv[i][1]) {
case 'R':
error += decode_R (argv[i], &west, &east, &south, &north);
break;
case 'L':
if (argv[i][2]) {
error += GMT_boundcond_parse (&edgeinfo, &argv[i][2]);
/*if (edgeinfo.gn) {
GMT_io.in_col_type[0] = GMT_io.out_col_type[0] = GMT_IS_LON;
GMT_io.in_col_type[1] = GMT_io.out_col_type[1] = GMT_IS_LAT;
}*/
}
/*else {
GMT_io.in_col_type[0] = GMT_io.out_col_type[0] = GMT_IS_LON;
GMT_io.in_col_type[1] = GMT_io.out_col_type[1] = GMT_IS_LAT;
}*/
break;
case 'N':
node = TRUE;
break;
case 'Q':
interpolant = BCR_BILINEAR;
threshold = (argv[i][2]) ? atof (&argv[i][2]) : 1.0;
break;
case 'S':
suppress = TRUE;
break;
case 'Z':
z_only = TRUE;
break;
default:
error = TRUE;
break;
}
}
}
if (argc == 1 || error) {
mexPrintf ("grdtrack - Sampling of a 2-D gridded netCDF grdfile along 1-D trackline\n\n");
mexPrintf ("usage: out = grdtrack_m(grd,head,xydata, ['-L<flag>'], ['-N']\n");
mexPrintf ("\t['-Q[<value>]'], ['-R<west/east/south/north>[r]'] ['-S'] ['-Z'] ['-f[i|o]<colinfo>']\n");
mexPrintf ("\t<xydata> is an multicolumn array with (lon,lat) in the first two columns\n");
mexPrintf ("\n\tOPTIONS:\n");
mexPrintf ("\t-L sets boundary conditions. <flag> can be either\n");
mexPrintf ("\t g for geographic boundary conditions\n");
mexPrintf ("\t or one or both of\n");
mexPrintf ("\t x for periodic boundary conditions on x\n");
mexPrintf ("\t y for periodic boundary conditions on y\n");
mexPrintf ("\t-N Report value at nearest node instead of interpolating\n");
mexPrintf ("\t-Q Quick mode, use bilinear rather than bicubic interpolation.\n");
mexPrintf ("\t Optionally, append <value> in the 0 < value <= 1 range.\n");
mexPrintf ("\t [Default = 1 requires all 4 nodes to be non-NaN.], <value> = 0.5\n");
mexPrintf ("\t will interpolate about 1/2 way from a non-NaN to a NaN node, while\n");
mexPrintf ("\t 0.1 will go about 90%% of the way, etc.\n");
mexPrintf ("\t-R specifies a subregion [Default is old region]\n");
mexPrintf ("\t-S Suppress output when result equals NaN\n");
mexPrintf ("\t-Z only output z-values [Default gives all columns]\n");
mexPrintf ("\n\tSECRET INFO:\n");
mexPrintf ("\t When input points are inside the outer skirt of 2 rows and columns of\n");
mexPrintf ("\t the 2-D grid we don't need to set boundary conditions and as\n");
mexPrintf ("\t such we can use the input array without further to C order\n");
mexPrintf ("\t conversion (to row major). This save a lot of memory and execution\n");
mexPrintf ("\t time. However, this possibility works only when input 2-D array is\n");
mexPrintf ("\t of tipe SINGLE (though the computations are all done in doubles).\n");
mexPrintf ("\t The other cases request using a temporary array of size (M+2)x(N+2)\n");
return;
}
if (threshold <= 0.0 || threshold > 1.0) {
mexPrintf ("GRDTRACK_M SYNTAX ERROR -Q: threshold must be in <0,1] range\n");
error++;
}
if (error) return;
if (nlhs == 0) {
mexPrintf("ERROR: Must provide an output.\n");
return;
}
/* Find out in which data type was given the input array */
if (mxIsDouble(prhs[0])) {
z_8 = mxGetPr(prhs[0]);
is_double = TRUE;
}
else if (mxIsSingle(prhs[0])) {
z_4 = mxGetData(prhs[0]);
is_single = TRUE;
}
else if (mxIsInt32(prhs[0])) {
i_4 = mxGetData(prhs[0]);
is_int32 = TRUE;
}
else if (mxIsInt16(prhs[0])) {
i_2 = mxGetData(prhs[0]);
is_int16 = TRUE;
}
else if (mxIsUint16(prhs[0])) {
ui_2 = mxGetData(prhs[0]);
is_uint16 = TRUE;
}
else if (mxIsUint8(prhs[0])) {
ui_1 = mxGetData(prhs[0]);
is_uint8 = TRUE;
}
else if (mxIsInt8(prhs[0])) {
i_1 = mxGetData(prhs[0]);
is_int8 = TRUE;
}
else {
mexPrintf("GRDTRACK ERROR: Unknown input data type.\n");
mexErrMsgTxt("Valid types are:double, single, Int32, Int16, UInt16, UInt8 and Int8.\n");
}
nx = mxGetN (prhs[0]);
ny = mxGetM (prhs[0]);
if (!mxIsNumeric(prhs[0]) || ny < 2 || nx < 2)
mexErrMsgTxt("First argument must contain a decent array\n");
nc_h = mxGetN (prhs[1]);
nr_h = mxGetM (prhs[1]);
if (!mxIsNumeric(prhs[1]) || nr_h > 1 || nc_h < 9)
mexErrMsgTxt("Second argument must contain a valid header of the input array.\n");
head = mxGetPr(prhs[1]); /* Get header info */
/* Check that thirth argument contains at least a mx2 table */
n_pts = mxGetM (prhs[2]);
n_fields = mxGetN(prhs[2]);
if (!mxIsNumeric(prhs[2]) || (n_fields < 2))
mexErrMsgTxt("GRDTRACK ERROR: thirth argument must contain the x,y positions where to interpolate.\n");
if (z_only)
n_fields = 0;
/* Read the interpolation points and convert them to double */
if (mxIsDouble(prhs[2]))
in = mxGetPr(prhs[2]);
else if (mxIsSingle(prhs[2]))
in = mxGetData(prhs[2]);
grd.x_min = head[0]; grd.x_max = head[1];
grd.y_min = head[2]; grd.y_max = head[3];
grd.z_min = head[4]; grd.z_max = head[5];
grd.x_inc = head[7]; grd.y_inc = head[8];
grd.nx = nx; grd.ny = ny;
grd.node_offset = irint(head[6]);
mx = nx + 4;
if (west == east) { /* No subset asked for */
west = grd.x_min;
east = grd.x_max;
south = grd.y_min;
north = grd.y_max;
}
one_or_zero = (grd.node_offset) ? 0 : 1;
half = (grd.node_offset) ? 0.5 : 0.0;
nx = irint ( (east - west) / grd.x_inc) + one_or_zero;
ny = irint ( (north - south) / grd.y_inc) + one_or_zero;
i_dx = 1.0 / grd.x_inc;
i_dy = 1.0 / grd.y_inc;
if (!node) {
/* If we don't have any point inside the two outer row/columns
there is no need to set boundary conditions plus all the extra
ovehead that it implies. So check it out here. */
int n;
double this_xmin, this_xmax, this_ymin, this_ymax;
n = (interpolant == BCR_BILINEAR) ? 1 : 2;
this_xmin = grd.x_min + n * grd.x_inc;
this_xmax = grd.x_max - n * grd.x_inc;
this_ymin = grd.y_min + n * grd.y_inc;
this_ymax = grd.y_max - n * grd.y_inc;
for (i = 0; i < n_pts; i++) {
if (in[i] < this_xmin || in[i] > this_xmax) {
need_padding = TRUE;
break;
}
if (in[i+n_pts] < this_ymin || in[i+n_pts] > this_ymax) {
need_padding = TRUE;
break;
}
}
}
#if original_GMT_code
need_padding = TRUE;
#endif
if (need_padding) row_maj = TRUE; /* Here we have to use the old row major code */
if (!need_padding) { /* We can use the column major order of the Matlab array */
if (!is_single)
f = mxCalloc (nx * ny, sizeof (float));
if (is_double)
for (j = 0; j < nx*ny; j++) f[j] = (float)z_8[j];
else if (is_single) {
f = z_4;
free_copy = FALSE; /* Signal that we shouldn't free f */
}
else if (is_int32)
for (j = 0; j < nx*ny; j++) f[j] = (float)i_4[j];
else if (is_int16)
for (j = 0; j < nx*ny; j++) f[j] = (float)i_2[j];
else if (is_uint16)
for (j = 0; j < nx*ny; j++) f[j] = (float)ui_2[j];
else if (is_uint8)
for (j = 0; j < nx*ny; j++) f[j] = (float)ui_1[j];
else if (is_int8)
for (j = 0; j < nx*ny; j++) f[j] = (float)i_1[j];
GMT_pad[0] = GMT_pad[1] = GMT_pad[2] = GMT_pad[3] = 0;
}
else {
f = mxCalloc ((nx+4)*(ny+4), sizeof (float));
/* Transpose from Matlab orientation to gmt grd orientation */
if (is_double) {
for (i = 0, i2 = ny - 1; i < ny; i++, i2--) {
ii = (i2 + 2)*mx + 2;
for (j = 0; j < nx; j++) f[ii + j] = (float)z_8[j*ny+i];
}
}
else if (is_single) {
for (i = 0, i2 = ny - 1; i < ny; i++, i2--) {
ii = (i2 + 2)*mx + 2;
for (j = 0; j < nx; j++) f[ii + j] = z_4[j*ny+i];
}
}
else if (is_int32) {
for (i = 0, i2 = ny - 1; i < ny; i++, i2--) {
ii = (i2 + 2)*mx + 2;
for (j = 0; j < nx; j++) f[ii + j] = (float)i_4[j*ny+i];
}
}
else if (is_int16) {
for (i = 0, i2 = ny - 1; i < ny; i++, i2--) {
ii = (i2 + 2)*mx + 2;
for (j = 0; j < nx; j++) f[ii + j] = (float)i_2[j*ny+i];
}
}
else if (is_uint16) {
for (i = 0, i2 = ny - 1; i < ny; i++, i2--) {
ii = (i2 + 2)*mx + 2;
for (j = 0; j < nx; j++) f[ii + j] = (float)ui_2[j*ny+i];
}
}
else if (is_uint8) {
for (i = 0, i2 = ny - 1; i < ny; i++, i2--) {
ii = (i2 + 2)*mx + 2;
for (j = 0; j < nx; j++) f[ii + j] = (float)ui_1[j*ny+i];
}
}
else if (is_int8) {
for (i = 0, i2 = ny - 1; i < ny; i++, i2--) {
ii = (i2 + 2)*mx + 2;
for (j = 0; j < nx; j++) f[ii + j] = (float)i_1[j*ny+i];
}
}
GMT_pad[0] = GMT_pad[1] = GMT_pad[2] = GMT_pad[3] = 2;
GMT_boundcond_param_prep (&grd, &edgeinfo);
}
/*project_info.w = west; project_info.e = east;
project_info.s = south; project_info.n = north;*/
/* Initialize bcr structure: */
GMT_bcr_init (&grd, GMT_pad, interpolant, threshold, &bcr);
if (need_padding)
/* Set boundary conditions */
GMT_boundcond_set (&grd, &edgeinfo, GMT_pad, f);
if ((out = mxCalloc(n_pts * (n_fields+1), sizeof (double))) == 0)
mexErrMsgTxt("GRDTRACK ERROR: Could not allocate memory\n");
for (i = 0; i < n_pts; i++) {
while ( (mxIsNaN(in[i]) || mxIsNaN(in[i+n_pts])) && !z_only) {
for (j = 0; j < n_fields; j++) out[j*n_pts+i] = in[j*n_pts+i];
out[j*n_pts+i] = mxGetNaN();
i++;
}
/* If point is outside grd area, shift it using periodicity or skip if not periodic. */
while ( (in[i+n_pts] < grd.y_min) && (edgeinfo.nyp > 0) ) in[i+n_pts] += (grd.y_inc * edgeinfo.nyp);
if (in[i+n_pts] < grd.y_min) continue;
while ( (in[i+n_pts] > grd.y_max) && (edgeinfo.nyp > 0) ) in[i+n_pts] -= (grd.y_inc * edgeinfo.nyp);
if (in[i+n_pts] > grd.y_max) continue;
while ( (in[i] < grd.x_min) && (edgeinfo.nxp > 0) ) in[i] += (grd.x_inc * edgeinfo.nxp);
if (in[i] < grd.x_min) continue;
while ( (in[i] > grd.x_max) && (edgeinfo.nxp > 0) ) in[i] -= (grd.x_inc * edgeinfo.nxp);
if (in[i] > grd.x_max) continue;
if (node) {
ii = irint ((in[i] - grd.x_min) * i_dx - half) + one_or_zero;
jj = irint ((grd.y_max - in[i+n_pts]) * i_dy - half) + one_or_zero;
value = f[(jj+GMT_pad[3])*mx+ii+GMT_pad[0]];
}
else
value = GMT_get_bcr_z(&grd, in[i], in[i+n_pts], f, &edgeinfo, &bcr, row_maj);
if (suppress && mxIsNaN (value)) continue;
if (z_only) { /* Simply print out value */
out[i] = value;
}
else { /* Simply copy other columns, append value, and output */
for (j = 0; j < n_fields; j++) out[j*n_pts+i] = in[j*n_pts+i];
out[j*n_pts+i] = value;
}
}
/*if (!(!need_padding && !is_single)) {
mexPrintf("Merda vou Friar %d\t%d\n", need_padding, is_single);
mxFree((void *)f);
}*/
if (free_copy)
mxFree((void *)f);
plhs[0] = mxCreateDoubleMatrix (n_pts,n_fields+1, mxREAL);
pdata_d = mxGetPr(plhs[0]);
memcpy(pdata_d, out, n_pts*(n_fields+1)*8);
mxFree(out);
}
int mxSetDimensions(mxArray *array_ptr, const int *dims, int ndim)
{
if (mxIsCell(array_ptr))
{
((types::Cell *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsChar(array_ptr))
{
((types::String *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsDouble(array_ptr))
{
((types::Double *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsSparse(array_ptr))
{
//TODO
}
else if (mxIsInt8(array_ptr))
{
((types::Int8 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsInt16(array_ptr))
{
((types::Int16 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsInt32(array_ptr))
{
((types::Int32 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsInt64(array_ptr))
{
((types::Int64 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsLogical(array_ptr))
{
((types::Bool *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsStruct(array_ptr))
{
((types::Struct *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsUint8(array_ptr))
{
((types::UInt8 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsUint16(array_ptr))
{
((types::UInt16 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsUint32(array_ptr))
{
((types::UInt32 *)array_ptr)->resize((int *)dims, ndim);
}
else if (mxIsUint64(array_ptr))
{
((types::UInt64 *)array_ptr)->resize((int *)dims, ndim);
}
return 0;
}
static void get_map_dat(int i, const mxArray *ptr, MAPTYPE *maps)
{
mxArray *tmp;
double *pr;
int num_dims, j, t, dtype = 0;
const mwSize *dims;
unsigned char *dptr;
tmp=mxGetField(ptr,i,"dat");
if (tmp == (mxArray *)0)
{
free_maps(maps,i);
mexErrMsgTxt("Cant find dat.");
}
if (mxIsDouble(tmp)) dtype = SPM_DOUBLE;
else if (mxIsSingle(tmp)) dtype = SPM_FLOAT;
else if (mxIsInt32 (tmp)) dtype = SPM_SIGNED_INT;
else if (mxIsUint32(tmp)) dtype = SPM_UNSIGNED_INT;
else if (mxIsInt16 (tmp)) dtype = SPM_SIGNED_SHORT;
else if (mxIsUint16(tmp)) dtype = SPM_UNSIGNED_SHORT;
else if (mxIsInt8 (tmp)) dtype = SPM_SIGNED_CHAR;
else if (mxIsUint8 (tmp)) dtype = SPM_UNSIGNED_CHAR;
else
{
free_maps(maps,i);
mexErrMsgTxt("Unknown volume datatype.");
}
dptr = (unsigned char *)mxGetPr(tmp);
num_dims = mxGetNumberOfDimensions(tmp);
if (num_dims > 3)
{
free_maps(maps,i);
mexErrMsgTxt("Too many dimensions.");
}
dims = mxGetDimensions(tmp);
for(j=0; j<num_dims; j++)
maps[i].dim[j]=dims[j];
for(j=num_dims; j<3; j++)
maps[i].dim[j]=1;
tmp=mxGetField(ptr,i,"dim");
if (tmp != (mxArray *)0)
{
if (mxGetM(tmp)*mxGetN(tmp) != 3)
{
free_maps(maps,i);
mexErrMsgTxt("Wrong sized dim.");
}
pr = mxGetPr(tmp);
if (maps[i].dim[0] != (mwSize)fabs(pr[0]) ||
maps[i].dim[1] != (mwSize)fabs(pr[1]) ||
maps[i].dim[2] != (mwSize)fabs(pr[2]))
{
free_maps(maps,i);
mexErrMsgTxt("Incompatible volume dimensions in dim.");
}
}
tmp=mxGetField(ptr,i,"dt");
if (tmp != (mxArray *)0)
{
if (mxGetM(tmp)*mxGetN(tmp) != 1 && mxGetM(tmp)*mxGetN(tmp) != 2)
{
free_maps(maps,i);
mexErrMsgTxt("Wrong sized dt.");
}
pr = mxGetPr(tmp);
if (dtype != (int)fabs(pr[0]))
{
free_maps(maps,i);
mexErrMsgTxt("Incompatible datatype in dt.");
}
}
maps[i].addr = 0;
maps[i].len = 0;
maps[i].dtype = dtype;
maps[i].data = (void **)mxCalloc(maps[i].dim[2],sizeof(void *));
maps[i].scale = (double *)mxCalloc(maps[i].dim[2],sizeof(double));
maps[i].offset = (double *)mxCalloc(maps[i].dim[2],sizeof(double));
t = maps[i].dim[0]*maps[i].dim[1]*get_datasize(maps[i].dtype)/8;
tmp = mxGetField(ptr,i,"pinfo");
if (tmp != (mxArray *)0)
{
if ((mxGetM(tmp) != 2 && mxGetM(tmp) != 3) || (mxGetN(tmp) != 1 && mxGetN(tmp) != maps[i].dim[2]))
{
free_maps(maps,i+1);
mexErrMsgTxt("Wrong sized pinfo.");
}
if (mxGetM(tmp) == 3 && mxGetPr(tmp)[2] != 0)
{
free_maps(maps,i+1);
mexErrMsgTxt("pinfo(3) must equal 0 to read dat field.");
}
pr = mxGetPr(tmp);
if (mxGetN(tmp) == 1)
for(j=0; j<maps[i].dim[2]; j++)
{
maps[i].scale[j] = pr[0];
maps[i].offset[j] = pr[1];
maps[i].data[j] = &(dptr[j*t]);
}
else
for(j=0; j<maps[i].dim[2]; j++)
{
maps[i].scale[j] = pr[0+j*2];
maps[i].offset[j] = pr[1+j*2];
maps[i].data[j] = &(dptr[j*t]);
}
}
else
for(j=0; j<maps[i].dim[2]; j++)
{
maps[i].scale[j] = 1.0;
maps[i].offset[j] = 0.0;
maps[i].data[j] = &(dptr[j*t]);
}
tmp=mxGetField(ptr,i,"mat");
if (tmp != (mxArray *)0)
{
if (mxGetM(tmp) != 4 || mxGetN(tmp) != 4)
{
free_maps(maps,i+1);
mexErrMsgTxt("Wrong sized mat.");
}
pr = mxGetPr(tmp);
for(j=0; j<16; j++)
maps[i].mat[j] = pr[j];
}
else
{
for(j=0; j<16; j++)
maps[i].mat[j] = 0.0;
for(j=0; j<4; j++)
maps[i].mat[j + j*4] = 1.0;
}
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs,
const mxArray *prhs[])
{
char *CIN;
int *DS, *WS, *SI, *ZIN;
double *srww,*srwp,*srdp, *probs, *WC, *WWC, *ZZ;
double ALPHA,BETA, GAMMA0, GAMMA1, DELTA;
mwIndex *irww, *jcww, *irwp, *jcwp, *irdp, *jcdp;
int *z,*d,*w, *s, *c, *sc, *order, *wp, *dp, *ztot, *wtot, *wc;
int W,T,D,NN,SEED,OUTPUT, nzmax, nzmaxwp, nzmaxdp, ntokens;
int i,j,cc,n,nt,wi,di;
int startcond;
mexPrintf( "GibbsSamplerLDACOL: entering...\n" );
mexEvalString("drawnow;");
/* Check for proper number of arguments. */
if (nrhs < 13) {
mexErrMsgTxt("At least 13 input arguments required");
} else if (nlhs != 5) {
mexErrMsgTxt("5 output arguments required");
}
//[ WP,DP,WC,C,Z ] = GibbsSamplerLDACOL( WS , DS , SI , WW , T , N , ALPHA , BETA , GAMMA0, GAMMA1 , DELTA , SEED , OUTPUT , CIN , ZIN );
/* process the input arguments */
if (mxIsInt32( prhs[ 0 ] ) != 1)
mexErrMsgTxt("WS must be int32");
WS = (int *)mxGetData(prhs[0]);
if (mxIsInt32( prhs[ 1 ] ) != 1)
mexErrMsgTxt("DS must be int32");
DS = (int *)mxGetData(prhs[1]);
if (mxIsInt32( prhs[ 2 ] ) != 1)
mexErrMsgTxt("SI must be int32");
SI = (int *)mxGetData(prhs[2]);
//for (int yy=0;yy<20;yy++)
// printf("%2d: WS=%4u, DS=%4u, SI=%4u\n",yy,WS[yy],DS[yy],SI[yy]);
if ((mxIsSparse( prhs[ 3 ] ) != 1) || (mxIsDouble( prhs[ 3 ] ) != 1))
mexErrMsgTxt("WW collocation matrix must be a sparse double precision matrix");
/* dealing with sparse array WW */
srww = mxGetPr(prhs[3]);
irww = mxGetIr(prhs[3]);
jcww = mxGetJc(prhs[3]);
nzmax= mxGetNzmax(prhs[3]);
W = mxGetM( prhs[3] );
ntokens = mxGetM( prhs[ 0 ] ) * mxGetN( prhs[ 0 ] );
D = 0;
for (i=0; i<ntokens; i++) {
if (DS[ i ] > D) D = (int) DS[ i ];
}
T = (int) mxGetScalar(prhs[4]);
if (T<=0) mexErrMsgTxt("Number of topics must be greater than zero");
NN = (int) mxGetScalar(prhs[5]);
if (NN<0) mexErrMsgTxt("Number of iterations must be greater than zero");
ALPHA = (double) mxGetScalar(prhs[6]);
if (ALPHA<=0) mexErrMsgTxt("ALPHA must be greater than zero");
BETA = (double) mxGetScalar(prhs[7]);
if (BETA<=0) mexErrMsgTxt("BETA must be greater than zero");
GAMMA0 = (double) mxGetScalar(prhs[8]);
if (GAMMA0<=0) mexErrMsgTxt("GAMMA0 must be greater than zero");
GAMMA1 = (double) mxGetScalar(prhs[9]);
if (GAMMA1<=0) mexErrMsgTxt("GAMMA1 must be greater than zero");
DELTA = (double) mxGetScalar(prhs[10]);
if (DELTA<=0) mexErrMsgTxt("DELTA must be greater than zero");
SEED = (int) mxGetScalar(prhs[11]);
// set the seed of the random number generator
OUTPUT = (int) mxGetScalar(prhs[12]);
// assume that we start a new chain
startcond = 0;
if (nrhs > 13) {
startcond = 1;
if (mxIsInt8( prhs[ 13 ] ) != 1)
mexErrMsgTxt("C must be int8");
CIN = (char*)mxGetData(prhs[13]);
if (mxIsInt32( prhs[ 14 ] ) != 1)
mexErrMsgTxt("Z must be int32");
ZIN = (int*)mxGetData(prhs[14]);
//for (int yy=0;yy<20;yy++)
// printf("%2d: Z=%4u, C=%4u\n",yy,ZIN[yy],CIN[yy]);
}
// seeding
seedMT( 1 + SEED * 2 ); // seeding only works on uneven numbers
/* allocate memory */
if (OUTPUT==2) {
mexPrintf( "GibbsSamplerLDACOL: Allocating z,d,w,s,c,sc\n" );
mexEvalString("drawnow;");
}
z = (int *) mxCalloc( ntokens , sizeof( int ));
d = (int *) mxCalloc( ntokens , sizeof( int ));
w = (int *) mxCalloc( ntokens , sizeof( int ));
s = (int *) mxCalloc( ntokens , sizeof( int ));
c = (int *) mxCalloc( ntokens , sizeof( int ));
sc = (int *) mxCalloc( ntokens , sizeof( int ));
if (startcond==1) {
if (OUTPUT==2) {
mexPrintf( "GibbsSamplerLDACOL: Preparing c,z\n" );
}
for (i=0; i<ntokens; i++) c[ i ] = (int) CIN[ i ];
for (i=0; i<ntokens; i++) z[ i ] = (int) ZIN[ i ] - (int) 1;
}
if (OUTPUT==2) {
mexPrintf( "GibbsSamplerLDACOL: Preparing w,d,s\n" );
mexEvalString("drawnow;");
}
for (i=0; i<ntokens; i++) w[ i ] = (int) (WS[ i ] - 1); // Matlab indexing not zero based
for (i=0; i<ntokens; i++) d[ i ] = (int) (DS[ i ] - 1); // Matlab indexing not zero based
for (i=0; i<ntokens; i++) s[ i ] = (int) SI[ i ];
if (OUTPUT==2) {
mexPrintf( "GibbsSamplerLDACOL: Allocating order,wp,dp,wc,ztot,wtot,probs\n" );
mexEvalString("drawnow;");
}
order = (int *) mxCalloc( ntokens , sizeof( int ));
wp = (int *) mxCalloc( T*W , sizeof( int ));
dp = (int *) mxCalloc( T*D , sizeof( int ));
wc = (int *) mxCalloc( W , sizeof( int ));
ztot = (int *) mxCalloc( T , sizeof( int ));
wtot = (int *) mxCalloc( W , sizeof( int ));
probs = (double *) mxCalloc( T , sizeof( double ));
n = ntokens;
/*for (i=0; i<10; i++) {
mexPrintf( "i=%4d w[i]=%3d d[i]=%d z[i]=%d s[i]=%d\n" , i , w[i] , d[i] , z[i] , s[i] );
}*/
if (OUTPUT==2) {
mexPrintf( "Running LDA COL Gibbs Sampler Version 1.0\n" );
if (startcond==1) mexPrintf( "Starting with C and Z vector given as input\n" );
mexPrintf( "Arguments:\n" );
mexPrintf( "\tNumber of words W = %d\n" , W );
mexPrintf( "\tNumber of docs D = %d\n" , D );
mexPrintf( "\tNumber of topics T = %d\n" , T );
mexPrintf( "\tNumber of iterations N = %d\n" , NN );
mexPrintf( "\tHyperparameter ALPHA = %4.4f\n" , ALPHA );
mexPrintf( "\tHyperparameter BETA = %4.4f\n" , BETA );
mexPrintf( "\tHyperparameter GAMMA0 = %4.4f\n" , GAMMA0 );
mexPrintf( "\tHyperparameter GAMMA1 = %4.4f\n" , GAMMA1 );
mexPrintf( "\tHyperparameter DELTA = %4.4f\n" , DELTA );
mexPrintf( "\tSeed number = %d\n" , SEED );
mexPrintf( "\tNumber of tokens = %d\n" , ntokens );
mexPrintf( "Internal Memory Allocation\n" );
mexPrintf( "\tw,d,z,s,c,sc,order indices combined = %d bytes\n" , 7 * sizeof( int) * ntokens );
mexPrintf( "\twp (full) matrix (%dx%d) = %d bytes\n" , W,T,sizeof( int ) * W * T );
mexPrintf( "\tdp (full) matrix (%dx%d) = %d bytes\n" , D,T,sizeof( int ) * D * T );
mexPrintf( "Checking: sizeof(char)=%d sizeof(int)=%d sizeof(long)=%d sizeof(double)=%d\n" , sizeof(char),sizeof(int) , sizeof(long) , sizeof(double));
mexEvalString("drawnow;");
}
/* run the model */
GibbsSamplerLDACOL( ALPHA, BETA, GAMMA0,GAMMA1,DELTA, W, T, D, NN, OUTPUT, n, z, d, w, s, c, sc, wp, dp, ztot, wtot, order, probs , srww, irww, jcww, wc, startcond );
/* ---------------------------------------------
Erasing variables to free memory
-----------------------------------------------*/
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from d,w,s,sc,ztot,wtot,probs\n");
mexEvalString("drawnow;");
mxFree(d);
mxFree(w);
mxFree(s);
mxFree(sc);
mxFree(ztot);
mxFree(wtot);
mxFree(probs);
}
/* ---------------------------------------------
convert the full wp matrix into a sparse matrix
-----------------------------------------------*/
nzmaxwp = 0;
for (i=0; i<W; i++) {
for (j=0; j<T; j++)
nzmaxwp += (int) ( *( wp + j + i*T )) > 0;
}
if (OUTPUT==2) {
mexPrintf( "Constructing sparse output matrix wp\n" );
mexPrintf( "Number of nonzero entries for WP = %d\n" , nzmaxwp );
mexEvalString("drawnow;");
}
plhs[0] = mxCreateSparse( W,T,nzmaxwp,mxREAL);
srwp = mxGetPr(plhs[0]);
irwp = mxGetIr(plhs[0]);
jcwp = mxGetJc(plhs[0]);
n = 0;
for (j=0; j<T; j++) {
*( jcwp + j ) = n;
for (i=0; i<W; i++) {
cc = (int) *( wp + i*T + j );
if (cc >0) {
*( srwp + n ) = cc;
*( irwp + n ) = i;
n++;
}
}
}
*( jcwp + T ) = n;
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'wp'\n");
mexEvalString("drawnow;");
mxFree(wp);
}
/* ---------------------------------------------
convert the full DP matrix into a sparse matrix
-----------------------------------------------*/
nzmaxdp = 0;
for (i=0; i<D; i++) {
for (j=0; j<T; j++)
nzmaxdp += (int) ( *( dp + j + i*T )) > 0;
}
if (OUTPUT==2) {
mexPrintf( "Constructing sparse output matrix dp\n" );
mexPrintf( "Number of nonzero entries for DP = %d\n" , nzmaxdp );
mexEvalString("drawnow;");
}
plhs[1] = mxCreateSparse( D,T,nzmaxdp,mxREAL);
srdp = mxGetPr(plhs[1]);
irdp = mxGetIr(plhs[1]);
jcdp = mxGetJc(plhs[1]);
n = 0;
for (j=0; j<T; j++) {
*( jcdp + j ) = n;
for (i=0; i<D; i++) {
cc = (int) *( dp + i*T + j );
if (cc >0) {
*( srdp + n ) = cc;
*( irdp + n ) = i;
n++;
}
}
}
*( jcdp + T ) = n;
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'dp'\n");
mexEvalString("drawnow;");
mxFree(dp);
}
/* ---------------------------------------------
create the WC count matrix
-----------------------------------------------*/
plhs[ 2 ] = mxCreateDoubleMatrix( W , 1 , mxREAL );
WC = mxGetPr( plhs[ 2 ] );
for (i=0; i<W; i++) WC[ i ] = (double) wc[ i ];
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'wc'\n");
mexEvalString("drawnow;");
mxFree(wc);
}
/* ---------------------------------------------
create the C route vector
-----------------------------------------------*/
plhs[ 3 ] = mxCreateDoubleMatrix( ntokens , 1 , mxREAL );
WWC = mxGetPr( plhs[ 3 ] );
for (i=0; i<ntokens; i++) WWC[ i ] = (double) c[ i ];
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'c'\n");
mexEvalString("drawnow;");
mxFree(c);
}
/* ---------------------------------------------
create the topic assignment vector
-----------------------------------------------*/
plhs[ 4 ] = mxCreateDoubleMatrix( ntokens , 1 , mxREAL );
ZZ = mxGetPr( plhs[ 4 ] );
for (i=0; i<ntokens; i++) ZZ[ i ] = (double) z[ i ] + 1;
if (OUTPUT==2) {
mexPrintf( "Freeing internal memory from matrix 'z'\n");
mexEvalString("drawnow;");
mxFree(z);
}
}
