static void mdlOutputs(SimStruct *S, int_T tid)
{
PCONFIG_DATA config;
const real_T *in_xdot;
const real_T *in_x0;
InputRealPtrsType pin_params;
const boolean_T *in_reset;
real_T *out_x;
real_T *out_t;
real_T *xd;
real_T *xd_temp;
real_T *xd_temp2;
time_T initial_time;
time_T final_time;
quaternion phi;
quaternion q;
vector omegadot_temp;
const real_T *pomegadot;
int_T i;
/* Retrieve C object from the pointers vector */
config = ssGetPWork(S)[0];
xd = (real_T*) ssGetDWork(S,0);
xd_temp = (real_T*) ssGetDWork(S,1);
if( config->nq ) xd_temp2 = (real_T*) ssGetDWork(S,2);
in_xdot = ssGetInputPortRealSignal(S, config->idxin_xdot);
if( config->idxin_x0 ) in_x0 = ssGetInputPortRealSignal(S, config->idxin_x0);
if( config->idxin_params ) pin_params = ssGetInputPortRealSignalPtrs(S, config->idxin_params);
if( config->idxin_reset ) in_reset = ((InputBooleanPtrsType) ssGetInputPortSignalPtrs(S, config->idxin_reset))[0];
out_x = ssGetOutputPortRealSignal(S, 1);
if( config->idxout_time ) out_t = ssGetOutputPortRealSignal(S, config->idxout_time);
switch( intval(mxGetScalar(paramSpecificationsSource)) )
{
case 1:
initial_time = config->initial_time;
final_time = ssGetTaskTime(S,0);
break;
case 2:
initial_time = mxGetScalar(paramInitialTime);
final_time = mxGetScalar(paramFinalTime);
break;
case 3:
initial_time = *(pin_params[0]);
final_time = *(pin_params[1]);
break;
default:
ssSetErrorStatus(S,"Wrong integration algorithm selected");
return;
}
/* ssPrintf("ti=%f, tf=%f\r\n", initial_time, final_time); */
/* Reset the states */
if( ssGetIWorkValue(S, 0) || (config->idxin_reset && *in_reset) || (intval(mxGetScalar(paramSpecificationsSource)) > 1) )
{
ssSetIWorkValue(S, 0, 0);
if( intval(mxGetScalar(paramInitialConditionSource)) == 1 )
{
/* Internal initial conditions */
for( i=0; i<config->nstates; i++ )
{
xd[i] = mxGetPr(paramInitialCondition)[(mxGetNumberOfElements(paramInitialCondition) == 1 ? 0 : i)];
}
}
else
{
/* External initial conditions */
memcpy(xd, in_x0, config->nstates*sizeof(real_T));
}
memcpy(out_x, xd, config->nstates*sizeof(real_T));
if( config->idxout_time ) out_t[0] = initial_time;
}
if( final_time > initial_time )
{
if( intval(mxGetScalar(paramIntegrationAlgorithm)) == 1 )
{
/* Euler algorithm */
if( !ssCallSystemWithTid(S,0,tid) ) return;
i = 0;
while( i<config->nstates )
{
if( config->nq && (i >= config->start_idx_q) && (i < config->end_idx_q) )
{
pomegadot = ( config->use_omegadot ? &in_xdot[i] : config->omegadot_zero );
QuaternionIntegralEulerChange( final_time-initial_time, &in_xdot[i], pomegadot, &xd[i], phi );
QuaternionProd(&xd[i], phi, &xd[i]);
QuaternionNormalize(&xd[i]);
i += 4;
}
else
{
xd[i] += in_xdot[i] * (final_time-initial_time);
i++;
}
}
}
if( intval(mxGetScalar(paramIntegrationAlgorithm)) == 2 )
{
/* Runge-Kutta algorithm */
/* f1 */
if( !ssCallSystemWithTid(S,0,tid) ) return;
i = 0;
while( i<config->nstates )
{
if( config->nq && (i >= config->start_idx_q) && (i < config->end_idx_q) )
{
pomegadot = ( config->use_omegadot ? &in_xdot[i] : config->omegadot_zero );
omegadot_temp[0] = pomegadot[0]*6; omegadot_temp[1] = pomegadot[1]*6; omegadot_temp[2] = pomegadot[2]*6;
QuaternionIntegralEulerChange( (final_time-initial_time)/6, &in_xdot[i], omegadot_temp, &xd[i], &xd_temp[i] );
QuaternionProd(&xd_temp[i], &xd_temp[i], q);
QuaternionProd(&xd_temp[i], q, phi);
QuaternionProd(&xd[i], phi, &out_x[i]);
i += 4;
}
else
{
xd_temp[i] = in_xdot[i];
out_x[i] = xd[i] + 0.5*(final_time-initial_time)*in_xdot[i];
i++;
}
}
if( config->idxout_time ) out_t[0] = initial_time + 0.5*(final_time-initial_time);
/* f2 */
if( !ssCallSystemWithTid(S,0,tid) ) return;
i = 0;
while( i<config->nstates )
{
if( config->nq && (i >= config->start_idx_q) && (i < config->end_idx_q) )
{
pomegadot = ( config->use_omegadot ? &in_xdot[i] : config->omegadot_zero );
omegadot_temp[0] = pomegadot[0]*6; omegadot_temp[1] = pomegadot[1]*6; omegadot_temp[2] = pomegadot[2]*6;
QuaternionIntegralEulerChange( (final_time-initial_time)/6, &in_xdot[i], omegadot_temp, &xd[i], q );
QuaternionProd(q, q, phi);
QuaternionProd(&xd_temp[i], phi, &xd_temp[i]);
QuaternionProd(phi, q, phi);
QuaternionProd(&xd[i], phi, &out_x[i]);
i += 4;
}
else
{
xd_temp[i] += 2*in_xdot[i];
out_x[i] = xd[i] + 0.5*(final_time-initial_time)*in_xdot[i];
i++;
}
}
if( config->idxout_time ) out_t[0] = initial_time + 0.5*(final_time-initial_time);
/* f3 */
if( !ssCallSystemWithTid(S,0,tid) ) return;
i = 0;
while( i<config->nstates )
{
if( config->nq && (i >= config->start_idx_q) && (i < config->end_idx_q) )
{
pomegadot = ( config->use_omegadot ? &in_xdot[i] : config->omegadot_zero );
omegadot_temp[0] = pomegadot[0]*6; omegadot_temp[1] = pomegadot[1]*6; omegadot_temp[2] = pomegadot[2]*6;
QuaternionIntegralEulerChange( (final_time-initial_time)/6, &in_xdot[i], omegadot_temp, &xd[i], q );
QuaternionProd(q, q, phi);
QuaternionProd(&xd_temp[i], phi, &xd_temp[i]);
QuaternionProd(phi, q, phi);
QuaternionProd(phi, phi, phi);
QuaternionProd(&xd[i], phi, &out_x[i]);
i += 4;
}
else
{
xd_temp[i] += 2*in_xdot[i];
out_x[i] = xd[i] + (final_time-initial_time)*in_xdot[i];
i++;
}
}
if( config->idxout_time ) out_t[0] = final_time;
/* f4 */
if( !ssCallSystemWithTid(S,0,tid) ) return;
i = 0;
while( i<config->nstates )
{
if( config->nq && (i >= config->start_idx_q) && (i < config->end_idx_q) )
{
pomegadot = ( config->use_omegadot ? &in_xdot[i] : config->omegadot_zero );
omegadot_temp[0] = pomegadot[0]*6; omegadot_temp[1] = pomegadot[1]*6; omegadot_temp[2] = pomegadot[2]*6;
QuaternionIntegralEulerChange( (final_time-initial_time)/6, &in_xdot[i], omegadot_temp, &xd[i], q );
QuaternionProd(&xd_temp[i], q, &xd_temp[i]);
QuaternionProd(&xd[i], &xd_temp[i], &xd[i]);
QuaternionNormalize(&xd[i]);
i += 4;
}
else
{
xd_temp[i] += in_xdot[i];
xd[i] += 1.0/6*(final_time-initial_time)*xd_temp[i];
i++;
}
}
}
}
else
{
if( !ssCallSystemWithTid(S,0,tid) ) return;
}
config->initial_time = final_time;
/* Update the outputs */
memcpy(out_x, xd, config->nstates*sizeof(real_T));
if( config->idxout_time ) out_t[0] = final_time;
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
if(strcmp(glp_version(),"4.36")<0){
mexErrMsgTxt("This MEX interface is compatible only with GLPK version 4.36 or higher.");
}
if (nrhs != 9){
mexPrintf("MEX interface to GLPK Version %s\n",glp_version());
mexPrintf("Internal interface for the GNU GLPK library.\n");
mexPrintf("You should use the 'glpk' function instead.\n\n");
mexPrintf("SYNTAX: [xopt, fmin, status, extra] = glpk(c, a, b, lb, ub, ctype, vartype, sense, param)\n");
return;
}
//-- 1nd Input. A column array containing the objective function
//-- coefficients.
int mrowsc = mxGetM(C_IN);
double *c=mxGetPr(C_IN);
if (c == NULL) mexErrMsgTxt("glpk: invalid value of C");
//-- 2nd Input. A matrix containing the constraints coefficients.
// If matrix A is NOT a sparse matrix
double *A = mxGetPr(A_IN); // get the matrix
if(A==NULL) mexErrMsgTxt("glpk: invalid value of A");
int mrowsA = mxGetM(A_IN);
int *rn;
int *cn;
double *a;
int nz = 0;
if(!mxIsSparse(A_IN)){
rn=(int *)mxCalloc(mrowsA*mrowsc+1,sizeof(int));
cn=(int *)mxCalloc(mrowsA*mrowsc+1,sizeof(int));
a=(double *)mxCalloc(mrowsA*mrowsc+1,sizeof(double));
for (int i = 0; i < mrowsA; i++){
for (int j = 0; j < mrowsc; j++){
if (A[i+j*mrowsA] != 0){
nz++;
rn[nz] = i + 1;
cn[nz] = j + 1;
a[nz] = A[i+j*mrowsA];
}
}
}
}else{
/* NOTE: nnz is the actual number of nonzeros and is stored as the
last element of the jc array where the size of the jc array is the
number of columns + 1 */
nz = *(mxGetJc(A_IN) + mrowsc);
mwIndex *jc = mxGetJc(A_IN);
mwIndex *ir = mxGetIr(A_IN);
double *pr = mxGetPr(A_IN);
rn=(int *)mxCalloc(nz+1,sizeof(int));
cn=(int *)mxCalloc(nz+1,sizeof(int));
a=(double *)mxCalloc(nz+1,sizeof(double));
int nelc,count,row;
count=0; row=0;
for(int i=1;i<=mrowsc;i++){
nelc=jc[i]-jc[i-1];
for(int j=0;j<nelc;j++){
count++;
rn[count]=ir[row]+1;
cn[count]=i;
a[count]=pr[row];
row++;
}
}
}
//-- 3rd Input. A column array containing the right-hand side value
// for each constraint in the constraint matrix.
double *b = mxGetPr(B_IN);
if (b==NULL) mexErrMsgTxt("glpk: invalid value of b");
//-- 4th Input. An array of length mrowsc containing the lower
//-- bound on each of the variables.
double *lb = mxGetPr(LB_IN);
if (lb==NULL) mexErrMsgTxt("glpk: invalid value of lb");
//-- LB argument, default: Free
int *freeLB=(int *)mxCalloc(mrowsc,sizeof(int));
for (int i = 0; i < mrowsc; i++) {
if (lb[i]==-mxGetInf()){
freeLB[i] = 1;
}else freeLB[i] = 0;
}
//-- 5th Input. An array of at least length numcols containing the upper
//-- bound on each of the variables.
double *ub = mxGetPr(UB_IN);
if (ub==NULL) mexErrMsgTxt("glpk: invalid value of ub");
int *freeUB=(int *)mxCalloc(mrowsc,sizeof(int));
for (int i = 0; i < mrowsc; i++)
{
if (ub[i]==mxGetInf())
{
freeUB[i] = 1;
}else freeUB[i] = 0;
}
//-- 6th Input. A column array containing the sense of each constraint
//-- in the constraint matrix.
int size = mxGetNumberOfElements(CTYPE_IN) + 1;
if (size==0) mexErrMsgTxt("glpk: invalid value of ctype");
/* Allocate enough memory to hold the converted string. */
char *ctype =(char *)mxCalloc(size, sizeof (char));
/* Copy the string data from string_array_ptr and place it into buf. */
if (mxGetString(CTYPE_IN, ctype, size) != 0) mexErrMsgTxt("Could not convert string data.");
//-- 7th Input. A column array containing the types of the variables.
size = mxGetNumberOfElements(VARTYPE_IN)+1;
char *vtype = (char *)mxCalloc(size, sizeof (char));
int *vartype = (int *)mxCalloc(size, sizeof (int));
if (size==0) mexErrMsgTxt("glpk: invalid value of vartype");
// Copy the string data from string_array_ptr and place it into buf.
if (mxGetString(VARTYPE_IN, vtype, size) != 0)
mexErrMsgTxt("Could not convert string data.");
int isMIP = 0;
for (int i = 0; i < mrowsc ; i++)
{
switch (vtype[i]){
case 'I': vartype[i] = GLP_IV; isMIP = 1; break;
case 'B': vartype[i] = GLP_BV; isMIP = 1; break;
default: vartype[i] = GLP_CV;
}
}
//-- 8th Input. Sense of optimization.
int sense;
double *tmp = mxGetPr(SENSE_IN);
if (*tmp >= 0) sense = 1;
else sense = -1;
//-- 9th Input. A structure containing the control parameters.
//-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//-- Integer parameters
//-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//-- Level of messages output by the solver
GLPK_GET_INT_PARAM (PARAM, "msglev", glpIntParam[0]);
if (glpIntParam[0] < 0 || glpIntParam[0] > 3)
{
mexErrMsgTxt("glpk: param.msglev must be 0 (no output [default]) or 1 (error messages only) or 2 (normal output) or 3 (full output)");
}
//-- scaling option
GLPK_GET_INT_PARAM (PARAM, "scale", glpIntParam[1]);
if (glpIntParam[1] < 0 || glpIntParam[1] > 4)
{
mexErrMsgTxt("glpk: param.scale must be 0 (no scaling) or 1 (equilibration scaling [default]) or 2 (geometric mean scaling) or 3 (geometric then equilibration scaling) or 4 (rounds scale factors to nearest power of 2)");
}
//-- Dual dimplex option
GLPK_GET_INT_PARAM (PARAM, "dual", glpIntParam[2]);
if (glpIntParam[2] < 0 || glpIntParam[2] > 2)
{
mexErrMsgTxt("glpk: param.dual must be 0 (do NOT use dual simplex [default]) or 1 (use dual simplex) or 2 (two phase dual simplex, switch to primal simplexi if it fails");
}
//-- Pricing option
GLPK_GET_INT_PARAM (PARAM, "price", glpIntParam[3]);
if (glpIntParam[3] < 0 || glpIntParam[3] > 1)
{
mexErrMsgTxt("glpk: param.price must be 0 (textbook pricing) or 1 (steepest edge pricing [default])");
}
//-- Ratio test option
GLPK_GET_INT_PARAM (PARAM, "r_test", glpIntParam[20]);
if (glpIntParam[20] < 0 || glpIntParam[20] > 1)
{
mexErrMsgTxt("glpk: param.r_test must be 0 (textbook) or 1 (Harris's Two pass ratio test)");
}
//-- Solution rounding option
GLPK_GET_INT_PARAM (PARAM, "round", glpIntParam[4]);
if (glpIntParam[4] < 0 || glpIntParam[4] > 1)
{
mexErrMsgTxt("glpk: param.round must be 0 (report all primal and dual values [default]) or 1 (replace tiny primal and dual values by exact zero)");
}
//-- Simplex iterations limit
GLPK_GET_INT_PARAM (PARAM, "itlim", glpIntParam[5]);
//-- Simplex iterations count
GLPK_GET_INT_PARAM (PARAM, "itcnt", glpIntParam[6]);
//-- Output frequency, in iterations
GLPK_GET_INT_PARAM (PARAM, "outfrq", glpIntParam[7]);
//-- Branching heuristic option
GLPK_GET_INT_PARAM (PARAM, "branch", glpIntParam[14]);
if (glpIntParam[14] < 0 || glpIntParam[14] > 3)
{
mexErrMsgTxt("glpk: param.branch must be (MIP only) 0 (branch on first variable) or 1 (branch on last variable) or 2 (most fractional variable) or 3 (branch using a heuristic by Driebeck and Tomlin [default]");
}
//-- Backtracking heuristic option
GLPK_GET_INT_PARAM (PARAM, "btrack", glpIntParam[15]);
if (glpIntParam[15] < 0 || glpIntParam[15] > 3)
{
mexErrMsgTxt("glpk: param.btrack must be (MIP only) 0 (depth first search) or 1 (breadth first search) or 2 ( best local bound ) or 3 (backtrack using the best projection heuristic [default]");
}
//-- Presolver option
GLPK_GET_INT_PARAM (PARAM, "presol", glpIntParam[16]);
if (glpIntParam[16] < 0 || glpIntParam[16] > 1)
{
mexErrMsgTxt("glpk: param.presol must be 0 (do NOT use LP presolver) or 1 (use LP presolver [default])");
}
//-- Generating cuts
GLPK_GET_INT_PARAM (PARAM, "usecuts", glpIntParam[17]);
if (glpIntParam[17] < 0 || glpIntParam[17] > 5)
{
mexErrMsgTxt("glpk: param.usecuts must be 0 (do NOT generate cuts), 1 (generate Gomory's cuts [default]), 2 (mir), 3 (cov) or 4 (clq cuts), 5( all cuts)");
}
//-- PrePocessing
GLPK_GET_INT_PARAM (PARAM, "pprocess", glpIntParam[18]);
if (glpIntParam[18] < 0 || glpIntParam[18] > 2)
{
mexErrMsgTxt("glpk: param.pprocess must be 0 (disable preprocessing), 1 (preprocess root only) or 2 (preprocess all levels)");
}
//-- Binarize
GLPK_GET_INT_PARAM (PARAM, "binarize", glpIntParam[19]);
if (glpIntParam[19] < 0 || glpIntParam[19] > 1)
{
mexErrMsgTxt("glpk: param.binarize must be 0 (do use binarization) or 1 (replace general integer variable by binary ones)");
}
//-- LPsolver option
int lpsolver = 1;
GLPK_GET_INT_PARAM (PARAM, "lpsolver", lpsolver);
if (lpsolver < 1 || lpsolver > 3)
{
mexErrMsgTxt("glpk: param.lpsolver must be 1 (simplex method) or 2 (interior point method) or 3 (LP in exact arithmetic)");
}
//-- Save option
int save_pb = 0;
char *save_filename = NULL;
char *filetype = NULL;
GLPK_GET_INT_PARAM (PARAM, "save", save_pb);
save_pb = (save_pb != 0);
if (save_pb){
// -- Look for the name --
mxArray *mxtmp=mxGetField(PARAM,0,"savefilename");
if ( mxtmp != NULL ){
int nl=mxGetNumberOfElements(mxtmp)+1;
nl=nl+4; // increase size to consider then extension .xxx
save_filename=(char *)mxCalloc(nl,sizeof(char));
if (mxGetString(mxtmp, save_filename, nl) != 0)
mexErrMsgTxt("glpk: Could not load file name to save.");
}else{
// Default file name
save_filename= (char *)mxCalloc(9, sizeof(char));
strcpy(save_filename,"outpb");
}
// -- Look for the type --
char save_filetype[5];
mxArray *txtmp=mxGetField(PARAM,0,"savefiletype");
if ( txtmp != NULL ){
int nl=mxGetNumberOfElements(txtmp)+1;
filetype=(char *)mxCalloc(nl,sizeof(char));
if (mxGetString(txtmp, filetype, nl) != 0)
mexErrMsgTxt("glpk: Could not load file type.");
if (!strcmp(filetype,"fixedmps") || !strcmp(filetype,"freemps")){
strcpy(save_filetype,".mps");
} else {
if (!strcmp(filetype,"cplex")) strcpy(save_filetype,".lp");
else {
if (!strcmp(filetype,"plain")) strcpy(save_filetype,".txt");
}
}
}else{
filetype= (char *)mxCalloc(5, sizeof(char));
strcpy(filetype,"cplex");
strcpy(save_filetype,".lp"); // Default file type
}
strcat(save_filename,save_filetype); // name.extension
}
// MPS parameters
//-- mpsinfo
GLPK_GET_INT_PARAM (PARAM, "mpsinfo", glpIntParam[8]);
//-- mpsobj
GLPK_GET_INT_PARAM (PARAM, "mpsobj", glpIntParam[9]);
if (glpIntParam[9] < 0 || glpIntParam[9] > 2)
{
mexErrMsgTxt("glpk: param.mpsobj must be 0 (never output objective function row) or 1 (always output objective function row ) or 2 [default](output objective function row if the problem has no free rows)");
}
//-- mpsorig
GLPK_GET_INT_PARAM (PARAM, "mpsorig", glpIntParam[10]);
//-- mpswide
GLPK_GET_INT_PARAM (PARAM, "mpswide", glpIntParam[11]);
//-- mpsfree
GLPK_GET_INT_PARAM (PARAM, "mpsfree", glpIntParam[12]);
//-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//-- Real parameters
//-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//-- Ratio test option
GLPK_GET_REAL_PARAM (PARAM, "relax", 0);
//-- Relative tolerance used to check if the current basic solution
//-- is primal feasible
GLPK_GET_REAL_PARAM (PARAM, "tolbnd", 1);
//-- Absolute tolerance used to check if the current basic solution
//-- is dual feasible
GLPK_GET_REAL_PARAM (PARAM, "toldj", 2);
//-- Relative tolerance used to choose eligible pivotal elements of
//-- the simplex table in the ratio test
GLPK_GET_REAL_PARAM (PARAM, "tolpiv", 3);
GLPK_GET_REAL_PARAM (PARAM, "objll", 4);
GLPK_GET_REAL_PARAM (PARAM, "objul", 5);
GLPK_GET_REAL_PARAM (PARAM, "tmlim", 6);
GLPK_GET_REAL_PARAM (PARAM, "outdly", 7);
GLPK_GET_REAL_PARAM (PARAM, "tolint", 8);
GLPK_GET_REAL_PARAM (PARAM, "tolobj", 9);
GLPK_GET_REAL_PARAM (PARAM, "mipgap", 10);
//-- Assign pointers to the output parameters
const char **extranames=(const char **)mxCalloc(4,sizeof(*extranames));
extranames[0]="lambda";
extranames[1]="redcosts";
extranames[2]="time";
extranames[3]="memory";
XMIN_OUT = mxCreateDoubleMatrix(mrowsc, 1, mxREAL);
FMIN_OUT = mxCreateDoubleMatrix(1, 1, mxREAL);
STATUS_OUT = mxCreateDoubleMatrix(1, 1, mxREAL);
double *xmin = mxGetPr(XMIN_OUT);
double *fmin = mxGetPr(FMIN_OUT);
double *status = mxGetPr(STATUS_OUT);
EXTRA_OUT = mxCreateStructMatrix(1, 1, 4, extranames);
mxArray *mxlambda = mxCreateDoubleMatrix(mrowsA, 1, mxREAL);
mxArray *mxredcosts = mxCreateDoubleMatrix(mrowsc, 1, mxREAL);
mxArray *mxtime = mxCreateDoubleMatrix(1, 1, mxREAL);
mxArray *mxmem = mxCreateDoubleMatrix(1, 1, mxREAL);
double *lambda = mxGetPr(mxlambda);
double *redcosts= mxGetPr(mxredcosts);
double *time = mxGetPr(mxtime);
double *mem = mxGetPr(mxmem);
int jmpret = setjmp (mark);
if (jmpret == 0)
glpk (sense, mrowsc, mrowsA, c, nz, rn,
cn, a, b, ctype, freeLB, lb, freeUB,
ub, vartype, isMIP, lpsolver, save_pb, save_filename, filetype,
xmin, fmin, status, lambda,
redcosts, time, mem);
if (! isMIP)
{
mxSetField(EXTRA_OUT,0,extranames[0],mxlambda);
mxSetField(EXTRA_OUT,0,extranames[1],mxredcosts);
}
mxSetField(EXTRA_OUT,0,extranames[2],mxtime);
mxSetField(EXTRA_OUT,0,extranames[3],mxmem);
mxFree(rn);
mxFree(cn);
mxFree(a);
mxFree(freeLB);
mxFree(freeUB);
mxFree(ctype);
mxFree(vartype);
mxFree(vtype);
mxFree(extranames);
mxFree(save_filename);
mxFree(filetype);
return;
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray*prhs[] )
{
// [is_string,is_esc_char,is_quote] = parse_json_helper(string)
//see mxmalloc for example ...
char* string;
size_t string_byte_length;
mwSize string_length;
mwSize index;
mxLogical* is_string;
mxLogical* is_esc_char;
mxLogical* is_quote;
bool in_string = false;
//This seems wasteful, I thought I was working with the string
//directly ... Might be able to improve this ...
string_byte_length = mxGetNumberOfElements(prhs[0])*sizeof(mxChar)+1;
string_length = (mwSize)mxGetNumberOfElements(prhs[0]);
string = mxMalloc(string_length);
mxGetString(prhs[0],string,(mwSize)string_length);
//NOTE: This initializes everything to false, we could eventually remove the initialization
plhs[0] = mxCreateLogicalMatrix(1,string_length);
is_string = mxGetLogicals(plhs[0]);
plhs[1] = mxCreateLogicalMatrix(1,string_length);
is_esc_char = mxGetLogicals(plhs[1]);
plhs[2] = mxCreateLogicalMatrix(1,string_length);
is_quote = mxGetLogicals(plhs[2]);
//TODO: Add check on empty string and return ...
//NOTE: We assume the first character is not a quote
//as this would be invalid JSON
//is_string[0] = false;
//is_esc_char[0] = false;
//is_quote[0] = false;
/* Copy data into the mxArray */
for ( index = 1; index < string_length; index++ ) {
if (!is_esc_char[index-1])
{
if (string[index] == '"')
{ //'"'
is_quote[index] = true;
in_string = !in_string;
}
else if (string[index] == '\\') //'\'
{
is_esc_char[index] = true;
is_string[index] = in_string;
}
else
{
is_string[index] = in_string;
}
}
else
{
is_string[index] = in_string;
}
}
mxFree(string);
}
int main(int ac, char *av[])
{
/* Input parameters:
*
* iterations: Number of points to draw in the triangle
* draw: If true, draw the triangle in a figure window before returning.
*/
mxArray *iterations = NULL, *draw = NULL;
/* The Sierpinski function returns the X and Y coordinates of the points
* forming the pattern in the triangle.
*/
mxArray *x = NULL, *y = NULL;
/* Default number of iterations */
int num_points = 7500;
/* Validate the number of inputs */
if (ac < 1 || ac > 2)
{
fprintf(stderr, "Expecting 0 or 1 input(s). Found %d\n", ac);
usage(av[0]);
}
/* If we have the right number of inputs (1), try to convert the input
* string to an integer.
*/
if (ac == 2)
num_points = atoi(av[1]);
/* Type check on input argument -- atoi() will fail if the input is
* not an integer.
*/
if (num_points == 0)
{
fprintf(stderr, "First argument must be an integer.\n");
usage(av[0]);
}
/* Create the input data */
iterations = mxCreateDoubleScalar(num_points);
draw = mxCreateLogicalScalar(1);
/* Call the library intialization routine and make sure that the
* library was initialized properly
*/
mclInitializeApplication(NULL,0);
if (!libtriangleInitialize())
{
fprintf(stderr,"could not initialize the triangle library properly\n");
return -1;
}
/* Call the library function */
mlfSierpinski(2, &x, &y, iterations, draw);
/* Display the return value of the library function */
printf("Calculated %d points\n", mxGetNumberOfElements(x));
/* Free the memory used by the return values. */
mxDestroyArray(x); x=NULL;
mxDestroyArray(y); y=NULL;
/* Call the library termination routine */
libtriangleTerminate();
/* Free the memory used by the input variables */
mxDestroyArray(iterations); iterations=0;
mxDestroyArray(draw); draw = 0;
/* Shut down all MCR instances */
mclTerminateApplication();
/* Success */
return 0;
}
// Function definitions.
// -----------------------------------------------------------------
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//Input Args
double *x0;
//Outputs Args
double *x, *fval, *exitflag, *iter, *feval;
//Internal Vars
size_t ndec;
int printLevel = 0;
//M1QN3 Vars
int m = 5, n, indic, ndz;
int uiparm[2] = {1,0}; //user integer array [citer, printLevel]
double *g, dxmin = 1e-8, df1, epsg = 1e-6, *dz;
char *normtype = "dfn";
int impres = 0, io = 0, omode = 0, reverse = 0;
int imode[3] = {0,0,0}; //DIS, cold start, no SIMUL with indic = 1
int iz[5];
float *rzs = NULL; double *dzs = NULL; //dummy args
//Defaults
int maxfev = 1500;
int maxiter = 1000;
maxtime = 1000;
iterF.enabled = false;
if (nrhs < 1) {
if(nlhs < 1)
printSolverInfo();
else
plhs[0] = mxCreateString(M1QN3_VERSION);
return;
}
//Check user inputs
checkInputs(prhs,nrhs);
//Get Sizes
ndec = mxGetNumberOfElements(pX0);
//Get Objective Function Handle
if (mxIsChar(pFUN)) {
CHECK(mxGetString(pFUN, fun.f, FLEN) == 0,"error reading objective name string");
fun.nrhs = 1;
fun.xrhs = 0;
} else {
fun.prhs[0] = (mxArray*)pFUN;
strcpy(fun.f, "feval");
fun.nrhs = 2;
fun.xrhs = 1;
}
fun.prhs[fun.xrhs] = mxCreateDoubleMatrix(ndec, 1, mxREAL); //x0
//Get Gradient Function Handle
if (mxIsChar(pGRAD)) {
CHECK(mxGetString(pGRAD, fun.g, FLEN) == 0,"error reading gradient name string");
fun.nrhs_g = 1;
fun.xrhs_g = 0;
} else {
fun.prhs_g[0] = (mxArray*)pGRAD;
strcpy(fun.g, "feval");
fun.nrhs_g = 2;
fun.xrhs_g = 1;
}
fun.prhs_g[fun.xrhs_g] = mxCreateDoubleMatrix(ndec, 1, mxREAL); //x0
//Get x0
x0 = mxGetPr(pX0);
//Get Options if specified
if(nrhs > eOPTS) {
if(mxGetField(pOPTS,0,"display"))
printLevel = (int)*mxGetPr(mxGetField(pOPTS,0,"display"));
if(mxGetField(pOPTS,0,"maxfeval"))
maxfev = (int)*mxGetPr(mxGetField(pOPTS,0,"maxfeval"));
if(mxGetField(pOPTS,0,"maxiter"))
maxiter = (int)*mxGetPr(mxGetField(pOPTS,0,"maxiter"));
if(mxGetField(pOPTS,0,"maxtime"))
maxtime = *mxGetPr(mxGetField(pOPTS,0,"maxtime"));
if(mxGetField(pOPTS,0,"tolafun"))
epsg = *mxGetPr(mxGetField(pOPTS,0,"tolafun")); //not function tolerance (gradient)
if(mxGetField(pOPTS,0,"nupdates"))
m = (int)*mxGetPr(mxGetField(pOPTS,0,"nupdates")); //number of l-bfgs updates
if(mxGetField(pOPTS,0,"iterfun") && !mxIsEmpty(mxGetField(pOPTS,0,"iterfun")))
{
iterF.prhs[0] = (mxArray*)mxGetField(pOPTS,0,"iterfun");
strcpy(iterF.f, "feval");
iterF.enabled = true;
iterF.prhs[1] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL);
iterF.prhs[2] = mxCreateDoubleMatrix(1,1,mxREAL);
iterF.prhs[3] = mxCreateDoubleMatrix(ndec,1,mxREAL);
}
}
//Create Outputs
plhs[0] = mxCreateDoubleMatrix(ndec,1, mxREAL);
plhs[1] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[3] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[4] = mxCreateDoubleMatrix(1,1, mxREAL);
x = mxGetPr(plhs[0]);
fval = mxGetPr(plhs[1]);
exitflag = mxGetPr(plhs[2]);
iter = mxGetPr(plhs[3]);
feval = mxGetPr(plhs[4]);
//Copy initial guess to x
memcpy(x,x0,ndec*sizeof(double));
//Print Header
if(printLevel) {
mexPrintf("\n------------------------------------------------------------------\n");
mexPrintf(" This is M1QN3 v%s\n",M1QN3_VERSION);
mexPrintf(" Authors: Jean Charles Gilbert, Claude Lemarechal, INRIA\n MEX Interface J. Currie 2012\n\n");
mexPrintf(" Problem Properties:\n");
mexPrintf(" # Decision Variables: %4d\n",ndec);
mexPrintf("------------------------------------------------------------------\n");
}
//Assign Arguments
n = (int)ndec;
indic = 4;
g = (double*)mxCalloc(n,sizeof(double)); //allocate memory for gradient
ndz = 4*n + m*(2*n + 1);
dz = (double*)mxCalloc(ndz,sizeof(double));
//Start timer
start = clock();
//Initialization Call
SIMUL(&indic, &n, x, fval, g, uiparm, NULL, NULL);
//Set df1 (initial estiamte of f reduction)
df1 = *fval;
//MEX Options
uiparm[0] = 1;
uiparm[1] = printLevel;
//Call Algorithm
M1QN3(SIMUL,EUCLID,CTONBE,CTCABE,&n,x,fval,g,&dxmin,&df1,&epsg,normtype,
&impres,&io,imode,&omode,&maxiter,&maxfev,iz,dz,&ndz,&reverse,&indic,
uiparm,rzs,dzs);
//Save Status & Iterations
*exitflag = (double)omode;
*iter = maxiter;
*feval = maxfev;
//Check if maxtime exceeded
if(((double)(end-start))/CLOCKS_PER_SEC > maxtime)
*exitflag = 8;
//Print Header
if(printLevel){
//Termination Detected
switch((int)*exitflag)
{
//Success
case 1:
mexPrintf("\n *** SUCCESSFUL TERMINATION ***\n *** gradient convergence |gk|/|g1| < epsg ***\n"); break;
//Error
case 5:
mexPrintf("\n *** MAXIMUM FUNCTION EVALUATIONS REACHED ***\n"); break;
case 4:
mexPrintf("\n *** MAXIMUM ITERATIONS REACHED ***\n"); break;
case 8:
mexPrintf("\n *** MAXIMUM TIME REACHED ***\n"); break;
case 2:
mexPrintf("\n *** ERROR: one of the input arguments is not well initialized ***\n"); break;
case 3:
mexPrintf("\n *** ERROR: the line-search is blocked on tmax = 10^20 ***\n"); break;
case 6:
mexPrintf("\n *** ERROR: stop dxmin during the line-search ***\n"); break;
case 7:
mexPrintf("\n *** ERROR: either (g,d) is nonnegative or (y,s) is nonpositive ***\n"); break;
//Early Exit
case 0:
mexPrintf("\n *** TERMINATION: USER EXITED ***\n"); break;
//Other Error
default:
mexPrintf("\n *** ERROR: internal error code %d ***\n",omode); break;
}
if(*exitflag==1)
mexPrintf("\n Final fval: %12.5g\n In %3.0f iterations\n",*fval,*iter);
mexPrintf("------------------------------------------------------------------\n\n");
}
//Free Memory
mxFree(g);
mxFree(dz);
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
/* Check number of input arguments */
if (nrhs > 13) {
ERROR("Thirteen or fewer input arguments are required.");
} else if (nrhs < 5) {
ERROR("At least five input arguments are required.");
}
/* Check number of output arguments */
if (nlhs > 1) {
ERROR("Too many output arguments.");
}
INT numPoints = (INT) * (DOUBLE *) mxGetData(prhs[0]);
CHAR distLabelName;
if (mxGetNumberOfElements(prhs[1]) != 0) {
if (!mxIsChar(prhs[1])) {
ERROR("Second argument must be of type CHAR.");
}
distLabelName = (CHAR)*(CHAR*) mxGetData(prhs[1]);
} else {
distLabelName = 'R';
}
DOUBLE *matlabConstraintMat = (DOUBLE*) mxGetData(prhs[2]);
DOUBLE *weights = (DOUBLE*) mxGetData(prhs[3]);
DOUBLE *tau = (DOUBLE*) mxGetData(prhs[4]);
INT numConstraints = (INT) mxGetM(prhs[2]);
INT numRepeats = (INT) mxGetNumberOfElements(prhs[4]);
DOUBLE tolerance;
if ((nrhs >= 6) && (mxGetNumberOfElements(prhs[5]) != 0)) {
tolerance = *(DOUBLE*) mxGetData(prhs[5]);
} else {
tolerance = 0.00001;
}
DOUBLE delta;
if ((nrhs >= 7) && (mxGetNumberOfElements(prhs[6]) != 0)) {
delta = *(DOUBLE*) mxGetData(prhs[6]);
} else {
delta = 0.1;
}
INT numIters;
if ((nrhs >= 8) && (mxGetNumberOfElements(prhs[7]) != 0)) {
numIters = (INT)*(DOUBLE*) mxGetData(prhs[7]);
} else {
numIters = 50000;
}
INT rankIncrement;
if ((nrhs >= 9) && (mxGetNumberOfElements(prhs[8]) != 0)) {
rankIncrement = (INT)*(DOUBLE*) mxGetData(prhs[8]);
} else {
rankIncrement = - 1;
}
INT lineSearchFlag;
if ((nrhs >= 10) && (mxGetNumberOfElements(prhs[9]) != 0)) {
lineSearchFlag = (INT)*(DOUBLE*) mxGetData(prhs[9]);
} else {
lineSearchFlag = 0;
}
DOUBLE eta;
if ((nrhs >= 11) && (mxGetNumberOfElements(prhs[10]) != 0)) {
eta = *(DOUBLE*) mxGetData(prhs[10]);
} else {
eta = 1.1;
}
DOUBLE tauMultiplier;
if ((nrhs >= 12) && (mxGetNumberOfElements(prhs[11]) != 0)) {
tauMultiplier = *(DOUBLE*) mxGetData(prhs[11]);
} else {
tauMultiplier = 10000;
}
DOUBLE tauRate;
if ((nrhs >= 13) && (mxGetNumberOfElements(prhs[12]) != 0)) {
tauRate = *(DOUBLE*) mxGetData(prhs[12]);
} else {
tauRate = 0.9;
}
if ((mxGetNumberOfElements(prhs[3]) != 0) && \
(mxGetNumberOfElements(prhs[3]) != numConstraints)) {
ERROR("First dimension of vector weights does not match number of constraints (first dimension of constraint matrix).");
}
INT *constraintMat;
DOUBLE *betaVec;
DIST_LABEL_TYPE distLabelType = convertDistLabelName(distLabelName);
if (distLabelType == DIST_LABEL_TARGETS) {
if (mxGetN(prhs[2]) != 3) {
ERROR("Constraint matrix does not meet specified format: second dimension not equal to three.");
}
constraintMat = (INT *) MALLOC(numConstraints * 2 * sizeof(INT));
betaVec = (DOUBLE *) MALLOC(numConstraints * 1 * sizeof(DOUBLE));
} else if (distLabelType == DIST_LABEL_BOUNDS) {
if (mxGetN(prhs[2]) != 4) {
ERROR("Constraint matrix does not meet specified format: second dimension not equal to four.");
}
constraintMat = (INT *) MALLOC(numConstraints * 3 * sizeof(INT));
betaVec = (DOUBLE *) MALLOC(numConstraints * 1 * sizeof(DOUBLE));
} else if ((distLabelType == DIST_LABEL_RELATIONAL) \
|| (distLabelType == DIST_LABEL_SQRHINGE) \
|| (distLabelType == DIST_LABEL_HUBERHINGE)) {
if (mxGetN(prhs[2]) != 5) {
ERROR("Constraint matrix does not meet specified format: second dimension not equal to five.");
}
constraintMat = (INT *) MALLOC(numConstraints * 4 * sizeof(INT));
betaVec = (DOUBLE *) MALLOC(numConstraints * 1 * sizeof(DOUBLE));
}
convertDistanceLabelMat(constraintMat, betaVec, distLabelType, \
matlabConstraintMat, numConstraints, numPoints);
plhs[0] = mxCreateNumericMatrix(numPoints, numPoints, MXPRECISION_CLASS, mxREAL);
DOUBLE *K = (DOUBLE *) mxGetData(plhs[0]);
if (numRepeats > 1) {
nrkl_apg(K, distLabelType, constraintMat, betaVec, weights, tau, delta, \
numIters, tolerance, lineSearchFlag, eta, numPoints, \
numConstraints, numRepeats);
} else {
nrkl_apg_continuation(K, distLabelType, constraintMat, betaVec, weights, \
*tau, delta, numIters, tolerance, lineSearchFlag, eta, \
tauMultiplier, tauRate, numPoints, numConstraints);
}
FREE(constraintMat);
FREE(betaVec);
}
// Function definitions.
// -----------------------------------------------------------------
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//Input Args
double *x0 = NULL, *lb = NULL, *ub = NULL, *A = NULL, *b = NULL;
//Outputs Args
double *x, *fval, *exitflag, *iter, *feval;
//Internal Vars
double *llb, *lub;
size_t ndec;
int i, exit_code;
//PSwarm Vars
double *sol = NULL;
int lincon = 0;
if (nrhs < 1) {
if(nlhs < 1)
printSolverInfo();
else
plhs[0] = mxCreateString(PSWARM_VERSION);
return;
}
//Check user inputs
checkInputs(prhs,nrhs,&lincon);
//Set Defaults
printLevel = 0;
maxtime = 1000;
noFeval = 0;
ctrlCExit = false;
iterF.enabled = false;
//Reset Stats
stats.solveriters = 0;
stats.objfunctions = 0;
stats.pollsteps = 0;
stats.sucpollsteps = 0;
//Set PSwarm Defaults
opt.s = 42;
opt.mu = 0.5; opt.nu = 0.5;
opt.maxvfactor = 0.5; opt.maxiter = 1500;
opt.maxf = 10000;
opt.iweight = 0.9; opt.fweight = 0.4;
opt.n2grd = 0.5;
opt.blim = 10;
opt.tol = 1e-5;
opt.delta = Inf; opt.fdelta = 5.0; opt.idelta = 2.0; opt.ddelta = 0.5;
opt.pollbasis = 0; opt.EpsilonActive = 0.1;
opt.IPrint = 10;
opt.vectorized = 0; //important, otherwise will pass whole swarm
opt.outfcn = &iterfcn; //iteration + ctrl c
//Get Sizes
ndec = mxGetNumberOfElements(prhs[1]);
//Get Objective Function Handle
if (mxIsChar(prhs[0])) {
CHECK(mxGetString(prhs[0], fun.f, FLEN) == 0,"error reading objective name string");
fun.nrhs = 1;
fun.xrhs = 0;
} else {
fun.prhs[0] = (mxArray*)prhs[0];
strcpy(fun.f, "feval");
fun.nrhs = 2;
fun.xrhs = 1;
}
//Get x0
x0 = mxGetPr(prhs[1]);
//Get Bounds
//LB
if(!mxIsEmpty(prhs[2])){
llb = mxGetPr(prhs[2]);
lb = mxCalloc(ndec,sizeof(double));
memcpy(lb,llb,ndec*sizeof(double));
for(i=0;i<ndec;i++) {
if(mxIsInf(lb[i]))
lb[i] = -1e19;
}
}
else {
lb = mxCalloc(ndec,sizeof(double));
for(i=0;i<ndec;i++)
lb[i] = -1e19;
}
//UB
if(nrhs > 3 && !mxIsEmpty(prhs[3])){
lub = mxGetPr(prhs[3]);
ub = mxCalloc(ndec,sizeof(double));
memcpy(ub,lub,ndec*sizeof(double));
for(i=0;i<ndec;i++) {
if(mxIsInf(ub[i]))
ub[i] = 1e19;
}
}
else {
ub = mxCalloc(ndec,sizeof(double));
for(i=0;i<ndec;i++)
ub[i] = 1e19;
}
//Get Linear Inequality Constraints
if(nrhs > 4) {
if(!mxIsEmpty(prhs[4]) && !mxIsEmpty(prhs[5])) {
A = mxGetPr(prhs[4]);
b = mxGetPr(prhs[5]);
}
}
//Get Options if specified
if(nrhs > 6) {
if(mxGetField(prhs[6],0,"display"))
printLevel = (int)*mxGetPr(mxGetField(prhs[6],0,"display"));
if(mxGetField(prhs[6],0,"maxiter"))
opt.maxiter = (int)*mxGetPr(mxGetField(prhs[6],0,"maxiter"));
if(mxGetField(prhs[6],0,"maxtime"))
maxtime = *mxGetPr(mxGetField(prhs[6],0,"maxtime"));
if(mxGetField(prhs[6],0,"tolfun"))
opt.tol = *mxGetPr(mxGetField(prhs[6],0,"tolfun"));
if(mxGetField(prhs[6],0,"maxfeval"))
opt.maxf = (int)*mxGetPr(mxGetField(prhs[6],0,"maxfeval"));
if(mxGetField(prhs[6],0,"swarm_size"))
opt.s = (int)*mxGetPr(mxGetField(prhs[6],0,"swarm_size"));
if(mxGetField(prhs[6],0,"vectorized"))
opt.vectorized = (int)*mxGetPr(mxGetField(prhs[6],0,"vectorized"));
if(mxGetField(prhs[6],0,"mu"))
opt.mu = *mxGetPr(mxGetField(prhs[6],0,"mu"));
if(mxGetField(prhs[6],0,"nu"))
opt.nu = *mxGetPr(mxGetField(prhs[6],0,"nu"));
if(mxGetField(prhs[6],0,"iweight"))
opt.iweight = *mxGetPr(mxGetField(prhs[6],0,"iweight"));
if(mxGetField(prhs[6],0,"fweight"))
opt.fweight = *mxGetPr(mxGetField(prhs[6],0,"fweight"));
if(mxGetField(prhs[6],0,"delta"))
opt.delta = *mxGetPr(mxGetField(prhs[6],0,"delta"));
if(mxGetField(prhs[6],0,"idelta"))
opt.idelta = *mxGetPr(mxGetField(prhs[6],0,"idelta"));
if(mxGetField(prhs[6],0,"ddelta"))
opt.ddelta = *mxGetPr(mxGetField(prhs[6],0,"ddelta"));
if(mxGetField(prhs[6],0,"iterfun") && !mxIsEmpty(mxGetField(prhs[6],0,"iterfun")))
{
iterF.prhs[0] = (mxArray*)mxGetField(prhs[6],0,"iterfun");
strcpy(iterF.f, "feval");
iterF.enabled = true;
iterF.prhs[1] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL);
iterF.prhs[2] = mxCreateDoubleMatrix(1,1,mxREAL);
iterF.prhs[3] = mxCreateDoubleMatrix(ndec,1,mxREAL);
}
}
//If not vectorized, we can create x now, otherwise must be done in callback
if(!opt.vectorized)
fun.prhs[fun.xrhs] = mxCreateDoubleMatrix(ndec, 1, mxREAL);
//Create Outputs
plhs[0] = mxCreateDoubleMatrix(ndec,1, mxREAL);
plhs[1] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[3] = mxCreateDoubleMatrix(1,1, mxREAL);
plhs[4] = mxCreateDoubleMatrix(1,1, mxREAL);
x = mxGetPr(plhs[0]);
fval = mxGetPr(plhs[1]);
exitflag = mxGetPr(plhs[2]);
iter = mxGetPr(plhs[3]);
feval = mxGetPr(plhs[4]);
//Print Header
if(printLevel) {
mexPrintf("\n------------------------------------------------------------------\n");
mexPrintf(" This is PSwarm v1.5\n");
mexPrintf(" Authors: A.I.F Vaz and L.N. Vicente\n MEX Interface J. Currie 2012\n\n");
mexPrintf(" Problem Properties:\n");
mexPrintf(" # Decision Variables: %4d\n",ndec);
mexPrintf(" # Linear Constraints: %4d\n",lincon);
mexPrintf("------------------------------------------------------------------\n");
}
//Run PSwarm
start = clock();
exit_code = PSwarm((int)ndec, &func, lb, ub, lincon, A, b, &sol, fval, x0);
if(exit_code == 0) {
//Copy Solution
memcpy(x,sol,ndec*sizeof(double));
free(sol);
*iter = (double)stats.solveriters;
*feval = (double)stats.objfunctions;
}
//Save Status & Iterations
*exitflag = getStatus(exit_code,stats.solveriters,stats.objfunctions);
//Print Header
if(printLevel){
//Termination Detected
switch((int)*exitflag)
{
//Success
case 1:
mexPrintf("\n *** SUCCESSFUL TERMINATION ***\n *** Normal Exit ***\n"); break;
//Error
case -1:
mexPrintf("\n *** ERROR: Abnormal Exit ***\n"); break;
case 0:
if(stats.solveriters >= (opt.maxiter-5))
mexPrintf("\n *** MAXIMUM ITERATIONS REACHED ***\n");
else if(((double)(end-start))/CLOCKS_PER_SEC > maxtime)
mexPrintf("\n *** MAXIMUM TIME EXCEEDED ***\n");
else
mexPrintf("\n *** MAXIMUM FUNCTION EVALUATIONS REACHED ***\n");
break;
//Early Exit
case -2:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Failed to allocate memory ***\n"); break;
case -3:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: Unable to initialize population - check constraints are feasible ***\n"); break;
case -5:
mexPrintf("\n *** TERMINATION: EARLY EXIT ***\n *** CAUSE: User Exit (Ctrl C) ***\n"); break;
}
if(*exitflag==1)
mexPrintf("\n Final Objective: %12.5g\n In %3d iterations and\n %4d function evaluations\n",*fval,stats.solveriters,stats.objfunctions);
mexPrintf("------------------------------------------------------------------\n\n");
}
//Free Memory
if(lb) mxFree(lb);
if(ub) mxFree(ub);
}
//=========================================================================
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
//Documentation of the calling forms is given within each if clause
if (!locked)
{
//NOTE: If we run clear all this will clear the definition of
//this file and depending on whether or not we had open references
//could cause Matlab to crash. By locking this file we prevent
//clearing the file (which means we can't recompile it unless we
//close Matlab) but we also prevent Matlab from crashing.
//
//TODO: Implement allowing unlock by reference counting
//TODO: Alternatively we could pass in a command to unlock
mexLock();
locked = 1;
}
ADI_FileHandle fileH(0);
//Setup output result code
//-----------------------------------------------
//Each function returns a result code, indicating if the function call
//worked or not.
ADIResultCode result;
int *out_result; //Each function will return a result code as well as
//possibly other values ..
plhs[0] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL);
out_result = (int *) mxGetData(plhs[0]);
//Which function to call
double function_option = mxGetScalar(prhs[0]);
//Function list
//--------------------------------------
// 0 ADI_OpenFile
// 1 ADI_GetNumberOfRecords
// 2 ADI_GetNumberOfChannels
// 3 ADI_GetNumTicksInRecord
// 4 ADI_GetRecordTickPeriod
// 5 ADI_GetNumSamplesInRecord
// 6 ADI_CreateCommentsAccessor
// 7 ADI_CloseCommentsAccessor
// 8 ADI_GetCommentInfo
// 9 ADI_NextComment
// 10 ADI_GetSamples
// 11 ADI_GetUnitsName
// 12 ADI_GetChannelName
// 13 ADI_CloseFile
// 14 ADI_GetErrorMessage
// 15 ADI_GetRecordSamplePeriod
// 16 ADI_GetRecordTime
// 17 ADI_CreateFile
if (function_option == 0)
{
// ADI_OpenFile <> openFile
// ===================================================
// [result_code,file_h] = sdk_mex(0,file_path)
wchar_t *w_file_path = (wchar_t *)mxGetData(prhs[1]);
//long openMode = getLongInput(prhs,2);
result = ADI_OpenFile(w_file_path, &fileH, kOpenFileForReadOnly);
out_result[0] = result;
setFileHandle(plhs,result,fileH);
}
else if (function_option == 0.5)
{
//This is a call to open the file for reading and writing
//
//TODO: Replace this with an input to function 0
wchar_t *w_file_path = (wchar_t *)mxGetData(prhs[1]);
result = ADI_OpenFile(w_file_path, &fileH, kOpenFileForReadAndWrite);
out_result[0] = result;
setFileHandle(plhs,result,fileH);
}
else if (function_option == 1)
{
// ADI_GetNumberOfRecords <> getNumberOfRecords
// ======================================================
// [result_code,n_records] = sdk_mex(1,file_handle)
long nRecords = 0;
fileH = getFileHandle(prhs);
//ADIResultCode ADI_GetNumberOfRecords(ADI_FileHandle fileH, long* nRecords);
result = ADI_GetNumberOfRecords(fileH,&nRecords);
out_result[0] = result;
setLongOutput(plhs,1,nRecords);
}
else if (function_option == 2)
{
// ADI_GetNumberOfChannels <> getNumberOfChannels
// ========================================================
// [result_code,n_channels] = sdk_mex(2,file_handle)
long nChannels = 0;
fileH = getFileHandle(prhs);
//ADIResultCode ADI_GetNumberOfChannels(ADI_FileHandle fileH, long* nChannels);
result = ADI_GetNumberOfChannels(fileH,&nChannels);
out_result[0] = result;
setLongOutput(plhs,1,nChannels);
}
else if (function_option == 3)
{
// ADI_GetNumTicksInRecord <> getNTicksInRecord
// ======================================================
// [result,n_ticks] = sdk_mex(3,file_handle,record_idx_0b)
fileH = getFileHandle(prhs);
//0 or 1 based ...
long record = getLongInput(prhs,2);
long nTicks = 0;
//ADIResultCode ADI_GetNumTicksInRecord(ADI_FileHandle fileH, long record, long* nTicks);
result = ADI_GetNumTicksInRecord(fileH,record,&nTicks);
out_result[0] = result;
setLongOutput(plhs,1,nTicks);
}
else if (function_option == 4)
{
// ADI_GetRecordTickPeriod <> getTickPeriod
// =========================================================
// [result,s_per_tick] = sdk_mex(4,file_handle,record_idx_0b,channel_idx_0b)
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
long channel = getLongInput(prhs,3);
double secsPerTick = 0;
//ADIResultCode ADI_GetRecordTickPeriod(ADI_FileHandle fileH, long channel, long record, double* secsPerTick);
out_result[0] = ADI_GetRecordTickPeriod(fileH,channel,record,&secsPerTick);
setDoubleOutput(plhs,1,secsPerTick);
}
else if (function_option == 5)
{
// ADI_GetNumSamplesInRecord <> getNSamplesInRecord
// ========================================================
// [result_code,n_samples] = sdk_mex(5,file_handle,record_idx_0b,channel_idx_0b);
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
long channel = getLongInput(prhs,3);
long nSamples = 0;
//ADIResultCode ADI_GetNumSamplesInRecord(ADI_FileHandle fileH, long channel, long record, long* nSamples);
out_result[0] = ADI_GetNumSamplesInRecord(fileH,channel,record,&nSamples);
setLongOutput(plhs,1,nSamples);
}
else if (function_option == 6)
{
// ADI_CreateCommentsAccessor <> getCommentAccessor
// ========================================================
// [result_code,comments_h] = sdk_mex(6,file_handle,record_idx_0b);
ADI_CommentsHandle commentsH(0);
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
//ADIResultCode ADI_CreateCommentsAccessor(ADI_FileHandle fileH, long record, ADI_CommentsHandle* commentsH);
result = ADI_CreateCommentsAccessor(fileH,record,&commentsH);
out_result[0] = result;
int64_t *p_c;
plhs[1] = mxCreateNumericMatrix(1,1,mxINT64_CLASS,mxREAL);
p_c = (int64_t *) mxGetData(plhs[1]);
if (result == 0)
p_c[0] = (int64_t)commentsH;
else
p_c[0] = 0;
}
else if (function_option == 7)
{
// ADI_CloseCommentsAccessor <> closeCommentAccessor
// ========================================================
// result_code = sdk_mex(7,comments_h);
ADI_CommentsHandle commentsH = getCommentsHandle(prhs);
//ADIResultCode ADI_CloseCommentsAccessor(ADI_CommentsHandle *commentsH);
out_result[0] = ADI_CloseCommentsAccessor(&commentsH);
}
else if (function_option == 8)
{
// ADI_GetCommentInfo <> getCommentInfo
// ====================================================
// [result_code,comment_string,comment_length,tick_pos,channel,comment_num] = sdk_mex(8,comment_h)
//
// Status: Done
ADI_CommentsHandle commentsH = getCommentsHandle(prhs);
wchar_t *messageOut = getStringOutputPointer(plhs,1);
long tickPos = 0;
long channel = 0;
long commentNum = 0;
long textLen = 0;
//ADIResultCode ADI_GetCommentInfo(ADI_CommentsHandle commentsH, long *tickPos, long *channel, long *commentNum, wchar_t* text,long maxChars, long *textLen);
// tickPos - receives the tick position of the comment in the record [outparam]
// commentNum - receives the number of the comment [outparam]
// channel - receives the channel of the comment (-1 for all channel comments) [outparam]
// text - buffer to receive null terminated text for the comment (optional, may be NULL) [outparam]
// maxChars - the size of the text buffer in wchar_t s. The text will be truncated to fit in this size
// textLen - receives the number of characters needed to hold the full comment text,
// even if parameter text is NULL (optional, may be NULL) [outparam]
out_result[0] = ADI_GetCommentInfo(commentsH,&tickPos,&channel,&commentNum,messageOut,MAX_STRING_LENGTH,&textLen);
setLongOutput(plhs,2,textLen);
setLongOutput(plhs,3,tickPos);
setLongOutput(plhs,4,channel);
setLongOutput(plhs,5,commentNum);
}
else if (function_option == 9)
{
// ADI_NextComment <> advanceComments
// ==================================================
// result_code = adi.sdk_mex(9,comments_h);
//
// Returns kResultNoData if there are no more comments ...
//
// Status: Done
ADI_CommentsHandle commentsH = getCommentsHandle(prhs);
//ADIResultCode ADI_NextComment(ADI_CommentsHandle commentsH);
out_result[0] = ADI_NextComment(commentsH);
}
else if (function_option == 10)
{
// ADI_GetSamples <> getChannelData
// ===========================================================
// [result,data,n_returned] = sdk_mex(10,file_h,channel_0b,record_0b,startPos,nLength,dataType)
fileH = getFileHandle(prhs);
long channel = getLongInput(prhs,2);
long record = getLongInput(prhs,3);
long startPos = getLongInput(prhs,4);
long nLength = getLongInput(prhs,5);
ADICDataFlags dataType = static_cast<ADICDataFlags>(getLongInput(prhs,6));
plhs[1] = mxCreateNumericMatrix(1,(mwSize)nLength,mxSINGLE_CLASS,mxREAL);
float *data = (float *)mxGetData(plhs[1]);
long returned = 0;
// Retrieves a block of sample data from the file into a buffer. Samples are in physical
// prefixed units.
//DLLEXPORT ADIResultCode ADI_GetSamples(ADI_FileHandle fileH, long channel, long record, long startPos,
// ADICDataFlags dataType, long nLength, float* data, long* returned);
out_result[0] = ADI_GetSamples(fileH,channel,record,startPos,dataType,nLength,data,&returned);
//out_result[0] = ADI_GetSamples(fileH,channel,record,startPos,kADICDataAtSampleRate,nLength,data,&returned);
setLongOutput(plhs,2,returned);
//out_result[0] = 4;
}
else if (function_option == 11)
{
// ADI_GetUnitsName <> getUnits
// =======================================
// [result_code,str_data,str_length] = sdk_mex(11,file_h,record,channel);
//Inputs
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
long channel = getLongInput(prhs,3);
//Outputs
long textLen = 0;
wchar_t *unitsOut = getStringOutputPointer(plhs,1);
// Retrieves the prefixed units of a channel, as a string.
//
//ADIResultCode ADI_GetUnitsName(ADI_FileHandle fileH, long channel, long record, wchar_t* units, long maxChars, long *textLen);
out_result[0] = ADI_GetUnitsName(fileH, channel, record, unitsOut, MAX_STRING_LENGTH, &textLen);
setLongOutput(plhs,2,textLen);
}
else if (function_option == 12)
{
// ADI_GetChannelName <> getChannelName
// =============================================
// [result_code,str_data,str_length] = sdk_mex(12,file_h,channel);
//Inputs
fileH = getFileHandle(prhs);
long channel = getLongInput(prhs,2);
//Outputs
long textLen = 0;
wchar_t *nameOut = getStringOutputPointer(plhs,1);
// Retrieves the name of a channel, as a string.
//ADIResultCode ADI_GetChannelName(ADI_FileHandle fileH, long channel, wchar_t* name, long maxChars, long *textLen);
out_result[0] = ADI_GetChannelName(fileH, channel, nameOut, MAX_STRING_LENGTH, &textLen);
setLongOutput(plhs,2,textLen);
}
else if (function_option == 13)
{
// ADI_CloseFile <> closeFile
// ==============================================================
//
fileH = getFileHandle(prhs);
result = ADI_CloseFile(&fileH);
out_result[0] = result;
}
else if (function_option == 14)
{
// ADI_GetErrorMessage <> getErrorMessage
// ==============================================================
// err_msg = sdk_mex(14,error_code)
long textLen = 0;
wchar_t *messageOut = getStringOutputPointer(plhs,1);
ADIResultCode code = (ADIResultCode)getLongInput(prhs,1);
//ADIResultCode ADI_GetErrorMessage(ADIResultCode code, wchar_t* messageOut, long maxChars, long *textLen);
out_result[0] = ADI_GetErrorMessage(code, messageOut, MAX_STRING_LENGTH, &textLen);
setLongOutput(plhs,2,textLen);
}
else if (function_option == 15)
{
// ADI_GetRecordSamplePeriod <> getSamplePeriod
// ==============================================================
// [result_code,dt_channel] = sdk_mex(15,file_h,record,channel)
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
long channel = getLongInput(prhs,3);
double secsPerSample = 0;
out_result[0] = ADI_GetRecordSamplePeriod(fileH, channel, record, &secsPerSample);
setDoubleOutput(plhs,1,secsPerSample);
}
else if (function_option == 16)
{
// ADI_GetRecordTime <> getRecordStartTime
// ==============================================================
// [result_code,trigger_time,frac_secs,trigger_minus_rec_start] = sdk_mex(16,file_h,record)
fileH = getFileHandle(prhs);
long record = getLongInput(prhs,2);
time_t triggerTime = 0;
double fracSecs = 0;
long triggerMinusStartTicks = 0;
//Retrieves time information about the specified record.
//The trigger time is the time origin of the record and may differ from the start time if
//there is a pre or post trigger delay, as specified by the trigMinusRecStart parameter.
// Params: fileH - ADI_FileHandle for the open file
// record - the record index (starting from 0)
// triggerTime - time_t receives the date and time of the trigger
// position for the new record. Measured as number of
// seconds from 1 Jan 1970
// fracSecs - receives the fractional seconds part of
// the record trigger time ('triggerTime' parameter)
// trigMinusRecStart - trigger-time-minus-record-start-ticks. Receives the
// difference between the time of trigger tick and the first
// tick in the record. This +ve for pre-trigger delay and
// -ve for post-trigger delay.
// Return: a ADIResultCode for result of the operation
//DLLEXPORT ADIResultCode ADI_GetRecordTime(ADI_FileHandle fileH, long record, time_t *triggerTime,
//double *fracSecs, long *triggerMinusStartTicks);
out_result[0] = ADI_GetRecordTime(fileH, record, &triggerTime, &fracSecs, &triggerMinusStartTicks);
setDoubleOutput(plhs,1,(double)triggerTime);
setDoubleOutput(plhs,2,fracSecs);
setLongOutput(plhs,3,triggerMinusStartTicks);
}
else if (function_option == 17){
//
// ADI_CreateFile <> createFile
// ==============================================================
// [result_code,file_h] = sdk_mex(17,file_path)
//
// Implemented via sdk.createFile
wchar_t *w_file_path = (wchar_t *)mxGetData(prhs[1]);
result = ADI_CreateFile(w_file_path, &fileH);
out_result[0] = result;
setFileHandle(plhs,result,fileH);
}
else if (function_option == 18){
//
// ADI_SetChannelName <> setChannelName
// ==============================================================
// [result_code,file_h] = sdk_mex(18,file_h,channel,name)
//
// Implemented via sdk.setChannelName
fileH = getFileHandle(prhs);
long channel = getLongInput(prhs,2);
wchar_t *channel_name = (wchar_t *)mxGetData(prhs[3]);
out_result[0] = ADI_SetChannelName(fileH, channel, channel_name);
}
else if (function_option == 19){
//
// ADI_CreateWriter <> createDataWriter
// ===========================================
// [result_code,writer_h] = sdk_mex(19,file_h)
//
// Implemented via sdk.createDataWriter
ADI_WriterHandle writerH(0);
fileH = getFileHandle(prhs);
result = ADI_CreateWriter(fileH,&writerH);
out_result[0] = result;
setWriterHandle(plhs,result,writerH);
}
else if (function_option == 20){
//
// ADI_SetChannelInfo <> setChannelInfo
// ===========================================
// [result_code] = sdk_mex(20,writer_h,channel,enabled,seconds_per_sample,units,limits)
//
// implemented via adi.sdk.setChannelInfo
ADI_WriterHandle writerH = getWriterHandle(prhs);
long channel = getLongInput(prhs,2);
int enabled = getIntInput(prhs,3);
double seconds_per_sample = getDoubleInput(prhs,4);
wchar_t *units = (wchar_t *)mxGetData(prhs[5]);
float *temp_limits = (float *)mxGetData(prhs[5]);
ADIDataLimits limits;
limits.mMaxLimit = temp_limits[1];
limits.mMinLimit = temp_limits[0];
out_result[0] = ADI_SetChannelInfo(writerH, channel, enabled, seconds_per_sample, units, &limits);
// DLLEXPORT ADIResultCode ADI_SetChannelInfo(ADI_WriterHandle writerH, long channel, int enabled,
// double secondsPerSample, const wchar_t* units, const ADIDataLimits *limits);
}
else if (function_option == 21){
//
// ADI_StartRecord <> startRecord
// ===========================================
// result_code = sdk_mex(21, writerH, trigger_time, fractional_seconds, trigger_minus_rec_start)
//
// implemented via adi.sdk.startRecord
ADI_WriterHandle writerH = getWriterHandle(prhs);
time_t trigger_time = (time_t)getDoubleInput(prhs,2);
double fractional_seconds = getDoubleInput(prhs,3);
long trigger_minus_rec_start = getLongInput(prhs,4);
out_result[0] = ADI_StartRecord(writerH, trigger_time, fractional_seconds, trigger_minus_rec_start);
// DLLEXPORT ADIResultCode ADI_StartRecord(ADI_WriterHandle writerH, time_t triggerTime,
// double fracSecs, long triggerMinusStartTicks);
}
else if (function_option == 22){
//
// ADI_AddChannelSamples <> addChannelSamples
// ===========================================
// [result_code,new_ticks_added] = sdk_mex(22, writerH, channel, data, n_samples)
//
// adi.sdk.addChannelSamples
ADI_WriterHandle writerH = getWriterHandle(prhs);
long channel = getLongInput(prhs,2);
float *data = (float *)mxGetData(prhs[3]);
long n_samples = (long)mxGetNumberOfElements(prhs[3]);
long new_ticks_added = 0;
out_result[0] = ADI_AddChannelSamples(writerH, channel, data, n_samples, &new_ticks_added);
setLongOutput(plhs,1,new_ticks_added);
// DLLEXPORT ADIResultCode ADI_AddChannelSamples(ADI_WriterHandle writerH, long channel,
// float* data, long nSamples, long *newTicksAdded);
}
else if (function_option == 23){
//
// ADI_FinishRecord <> finishRecord
// ===========================================
// [result_code] = sdk_mex(23, writerH)
//
// Implemented via adi.sdk.finishRecord
ADI_WriterHandle writerH = getWriterHandle(prhs);
out_result[0] = ADI_FinishRecord(writerH);
// DLLEXPORT ADIResultCode ADI_FinishRecord(ADI_WriterHandle writerH);
}
else if (function_option == 24){
//
// ADI_CommitFile <> commitFile
// ===========================================
// [result_code] = sdk_mex(24, writerH, flags)
//
// Implemented via adi.sdk.commitFile
ADI_WriterHandle writerH = getWriterHandle(prhs);
//TODO: What are the flags??????
out_result[0] = ADI_CommitFile(writerH, 0);
// DLLEXPORT ADIResultCode ADI_CommitFile(ADI_WriterHandle writerH, long flags);
}
else if (function_option == 25){
//
// ADI_CloseWriter <> closeWriter
// ===========================================
// [result_code] = sdk_mex(25, writerH)
//
// Implemented via adi.sdk.closeWriter
ADI_WriterHandle writerH = getWriterHandle(prhs);
out_result[0] = ADI_CloseWriter(&writerH);
// DLLEXPORT ADIResultCode ADI_CloseWriter(ADI_WriterHandle *writerH);
}
else if (function_option == 26){
//
// ADI_AddComment <> addComment
// ===========================================
// [result_code, comment_number] =
// sdk_mex(26, file_h, channel, record, tick_position, text)
//
// Implemented via adi.sdk.addComment
fileH = getFileHandle(prhs);
long channel = getLongInput(prhs,2);
long record = getLongInput(prhs,3);
long tick_position = getLongInput(prhs,4);
wchar_t *text = (wchar_t *)mxGetData(prhs[5]);
long comment_number = 0;
//long comment_number = getLongInput(prhs,6);
out_result[0] = ADI_AddComment(fileH, channel, record, tick_position, text, &comment_number);
setLongOutput(plhs,1,comment_number);
// DLLEXPORT ADIResultCode ADI_AddComment(ADI_FileHandle fileH, long channel, long record, long tickPos,
// const wchar_t* text, long* commentNum);
}
else if (function_option == 27){
//
// ADI_DeleteComment <> deleteComment
// ===========================================
// result_code = sdk_mex(27,file_h,comment_number)
//
// Implemented via adi.sdk.deleteComment
fileH = getFileHandle(prhs);
long comment_number = getLongInput(prhs,2);
out_result[0] = ADI_DeleteComment(fileH,comment_number);
// DLLEXPORT ADIResultCode ADI_DeleteComment(ADI_FileHandle fileH, long commentNum);
}
else if (function_option == 100){
mexUnlock();
locked = 0;
}
else
{
mexErrMsgIdAndTxt("adinstruments:sdk_mex",
"Invalid function option");
}
//ADI_GetRecordSamplePeriod
//ADI_GetRecordTime
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/* field data */
LSMLIB_REAL *phi;
LSMLIB_REAL *mask;
LSMLIB_REAL **source_fields;
LSMLIB_REAL *distance_function;
LSMLIB_REAL **extension_fields;
int num_ext_fields;
/* grid data */
const int *grid_dims = mxGetDimensions(PHI);
double *dX = mxGetPr(DX);
LSMLIB_REAL dX_matlab_order[2];
/* numerical parameters */
int spatial_discretization_order;
/* auxilliary variables */
int i;
int error_code;
mxArray* tmp_mxArray;
/* Check for proper number of arguments */
if (nrhs < 3) {
mexErrMsgTxt(
"Insufficient number of input arguments (3 required; 2 optional)");
} else if (nrhs > 5) {
mexErrMsgTxt("Too many input arguments (3 required; 2 optional)");
} else if (nlhs > 2) {
mexErrMsgTxt("Too many output arguments.");
}
/* Check that the inputs have the correct floating-point precision */
#ifdef LSMLIB_DOUBLE_PRECISION
if (!mxIsDouble(PHI)) {
mexErrMsgTxt("Incompatible precision: LSMLIB built for double-precision but phi is single-precision");
}
#else
if (!mxIsSingle(PHI)) {
mexErrMsgTxt("Incompatible precision: LSMLIB built for single-precision but phi is double-precision");
}
#endif
/* Get mask */
if ( (nrhs < 4) || (mxIsEmpty(MASK)) ) {
mask = 0; /* NULL mask ==> all points are in interior of domain */
} else {
#ifdef LSMLIB_DOUBLE_PRECISION
if (!mxIsDouble(MASK)) {
mexErrMsgTxt("Incompatible precision: LSMLIB built for double-precision but mask is single-precision");
}
#else
if (!mxIsSingle(MASK)) {
mexErrMsgTxt("Incompatible precision: LSMLIB built for single-precision but mask is double-precision");
}
#endif
mask = (LSMLIB_REAL*) mxGetPr(MASK);
}
/* Get spatial derivative order */
if (nrhs < 5) {
spatial_discretization_order = 2;
} else {
spatial_discretization_order = mxGetPr(SPATIAL_DERIVATIVE_ORDER)[0];
}
/* Assign pointers for phi and extension field data */
phi = (LSMLIB_REAL*) mxGetPr(PHI);
num_ext_fields = mxGetNumberOfElements(SOURCE_FIELDS);
source_fields = (LSMLIB_REAL**) mxMalloc(num_ext_fields*sizeof(LSMLIB_REAL*));
for (i = 0; i < num_ext_fields; i++) {
tmp_mxArray = mxGetCell(SOURCE_FIELDS,i);
#ifdef LSMLIB_DOUBLE_PRECISION
if (!mxIsDouble(tmp_mxArray)) {
mexErrMsgTxt("Incompatible precision: LSMLIB built for double-precision but one of the source fields is single-precision");
}
#else
if (!mxIsSingle(tmp_mxArray)) {
mexErrMsgTxt("Incompatible precision: LSMLIB built for single-precision but one of the source fields is double-precision");
}
#endif
source_fields[i] = (LSMLIB_REAL*) mxGetPr(tmp_mxArray);
}
/* Create distance function and extension field data */
#ifdef LSMLIB_DOUBLE_PRECISION
DISTANCE_FUNCTION = mxCreateDoubleMatrix(grid_dims[0], grid_dims[1], mxREAL);
#else
DISTANCE_FUNCTION = mxCreateNumericMatrix(grid_dims[0], grid_dims[1],
mxSINGLE_CLASS, mxREAL);
#endif
distance_function = (LSMLIB_REAL*) mxGetPr(DISTANCE_FUNCTION);
num_ext_fields = mxGetNumberOfElements(SOURCE_FIELDS);
EXTENSION_FIELDS = mxCreateCellArray(1, &num_ext_fields);
extension_fields =
(LSMLIB_REAL**) mxMalloc(num_ext_fields*sizeof(LSMLIB_REAL*));
for (i = 0; i < num_ext_fields; i++) {
#ifdef LSMLIB_DOUBLE_PRECISION
tmp_mxArray = mxCreateDoubleMatrix(grid_dims[0], grid_dims[1], mxREAL);
#else
tmp_mxArray= mxCreateNumericMatrix(grid_dims[0], grid_dims[1],
mxSINGLE_CLASS, mxREAL);
#endif
mxSetCell(EXTENSION_FIELDS, i, tmp_mxArray);
extension_fields[i] = (LSMLIB_REAL*) mxGetPr(tmp_mxArray);
}
/* Change order of dX to be match MATLAB meshgrid() order for grids. */
dX_matlab_order[0] = dX[1];
dX_matlab_order[1] = dX[0];
LSMLIB_REAL *extension_mask_dummy; /* ipa.n */
/* Carry out FMM calculation */
error_code = computeExtensionFields2d(
distance_function,
extension_fields,
phi,
mask,
source_fields,
extension_mask_dummy, /* ipa.n */
num_ext_fields,
spatial_discretization_order,
(int*) grid_dims,
dX_matlab_order);
if (error_code) {
mexErrMsgTxt("computeExtensionFields2d failed...");
}
/* Clean up memory */
mxFree(source_fields);
mxFree(extension_fields);
return;
}
// matlab entry point
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
// input must have tree size, binary_feature_filename, binary_feature_flipped_filename, action name
if (nrhs != 4)
mexErrMsgTxt("Wrong number of inputs, treesize, binaryfeaturefilename, binaryfeatureflippedfilename, action_name needed");
// Currently, we do not have any output
if (nlhs != 0)
mexErrMsgTxt("Wrong number of outputs");
/* make sure the first input argument is scalar */
if( !mxIsDouble(prhs[0]) ||
mxIsComplex(prhs[0]) ||
mxGetNumberOfElements(prhs[0])!=1 ) {
mexErrMsgIdAndTxt("MyToolbox:arrayProduct:notScalar",
"Input tree size must be a scalar.");
}
/* input must be a string */
if ( mxIsChar(prhs[1]) != 1 || mxIsChar(prhs[2]) != 1 || mxIsChar(prhs[3]) != 1 )
mexErrMsgIdAndTxt( "MATLAB:revord:inputNotString",
"Input must be a string.");
// read in input string
char *DataFilename, *DataFilenameFlipped, *action;
DataFilename = mxArrayToString(prhs[1]);
DataFilenameFlipped = mxArrayToString(prhs[2]);
action = mxArrayToString(prhs[3]);
// set the seed for random numbers
srand(time(NULL));
mexPrintf("Entered dttrain.cpp!\n"); // debug!!!!
// set parameters for learning
PARAMETER param;
SetParameters(param);
param.treeNum = mxGetScalar(prhs[0]); // treat tree num specially
mexPrintf("tree num is %d\n", param.treeNum); // debug!!!!
mexPrintf("parameters set!\n"); // debug!!!!
// get image feature descriptors from the file
vector<SINGLEIM> imVec;
int classNum;
// use filename passed in here!!!
GetData(imVec, DataFilename, param);
mexPrintf("read %s to image vector! total size of %d\n", DataFilename, imVec.size()); // debug!!!!
//GetData(imVec, DataFilenameFlipped, param);
//mexPrintf("read %s to image vector, total size of %d\n", DataFilenameFlipped, imVec.size()); // debug!!!!
AdjustLabels(imVec, classNum);
mexPrintf("Finish getting data from the disk.\n");
// pre-pooling for the background information, if it is necessary
// if (param.bgPrePooling == 1)
// BgPrePooling(imVec, param);
// mexPrintf("Finish getting background feature.\n");
// the pre-allocated memory for all the trees
int treeMemSize = int(pow(2, param.maxTreeDepth + 1)) * param.treeNum;
TREENODE *treeMemory = new TREENODE[treeMemSize];
InitTreeMem(treeMemory, treeMemSize);
int treeMemID = 0;
vector<TREENODE*> trees; // the set of decision trees
for (int i = 0; i < param.treeNum; i++)
{
trees.push_back(treeMemory + treeMemID);
treeMemID++;
}
mexPrintf("Finish initializing all the trees.\n");
// train decision trees
clock_t t1, t2;
vector<int> trainID, valID; // indicate which samples are included in the current tree node
char filename[1024];
float *valDist = (float*)malloc(sizeof(float) * classNum); // sample distribution in the val set
for (int i = 0; i < param.treeNum; i++)
{
t1 = clock();
GetFilename(filename, action);
mexPrintf("\nThe current tree will be in this file: %s\n", filename);
trainID.clear();
valID.clear();
InitializeTree(trees[i]);
int nodeID = 0;
memset(valDist, 0, sizeof(float) * classNum);
TrainDecisionTree(trees[i], imVec, param, trainID, valID,
classNum, nodeID, treeMemory, treeMemID, valDist);
// sprintf(filename, "trees/tree_%d%d%d.txt", i / 100, (i % 100) / 10, i % 10);
OutputTree(trees[i], filename);
t2 = clock();
mexPrintf("\n Time for trainning this tree: %f\n", (float)(t2 - t1) / CLOCKS_PER_SEC);
}
free(valDist);
ReleaseData(imVec);
for (int i = 0; i < param.treeNum; i++)
ReleaseTreeMem(trees[i]);
delete[] treeMemory;
}
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/* check: only one input and one output argument */
if (nrhs !=3)
mexErrMsgTxt("Must have 3 input arguments");
if (nlhs !=1)
mexErrMsgTxt("Must have 1 output argument");
/* Get inputs*/
// Check data types
if (!mxIsDouble(Distances_IN) || mxIsComplex(Distances_IN)){
mexErrMsgTxt("Inputs must be double.");
}
if (!mxIsDouble(Constrains_IN) || mxIsComplex(Constrains_IN)){
mexErrMsgTxt("Inputs must be double.");
}
// Check first input
int nDims = mxGetNumberOfDimensions(Distances_IN);
if (nDims!=2) {
mexErrMsgTxt("First Input must be 2-D.");
}
double *D = (double*) mxGetPr(Distances_IN);
if ( mxGetN(Distances_IN) != mxGetM(Distances_IN))
{
mexErrMsgTxt("First Input must be a squared matrix.");
}
unsigned int nDataPoints = (unsigned int) mxGetM(Distances_IN);
// Check second input
int nDims2 = mxGetNumberOfDimensions(Constrains_IN);
if ( (nDims2>2) ||
(mxGetM(Constrains_IN)!=mxGetN(Constrains_IN)) || (mxGetN(Constrains_IN)!=nDataPoints) )
{
mexErrMsgTxt("Second Input must be squared 2-D matrix, with same size than first Input");
}
double * C = (double*) mxGetPr(Constrains_IN);
//mexPrintf("nDataPoints = %d\n",nDataPoints);
// Check third input
int numElems= mxGetNumberOfElements(Threshold_IN);
if (numElems>1)
{
mexErrMsgTxt("Third Input must be scalar.");
}
double Threshold = (double) mxGetScalar(Threshold_IN);
clusterID_OUT = mxCreateNumericMatrix(nDataPoints, 1, mxDOUBLE_CLASS,mxREAL);
double *clusterIds = (double *) mxGetPr(clusterID_OUT);
// -------------------------- Main Algorithm --------------------- //
//
timer mytimer;
mytimer.start("imposing Must Links");
imposeMustLinks(D,C, nDataPoints);
mytimer.check();
mytimer.restart();
mytimer.start("propagating Must Links");
propagateMustLinks(D,C,nDataPoints);
mytimer.check();
mytimer.restart();
mytimer.start("imposing Cannot Links");
imposeCannotLinks(D,C,nDataPoints);
mytimer.check();
mytimer.restart();
//propagateCannotLinks(D,C,nDataPoints);
mytimer.start("complete-linkage clustering");
completeLink(D,clusterIds,nDataPoints,Threshold);
mytimer.check();
/*
std::vector<int > centerPoints(nDataPoints,0);
std::vector<int > memberships(nDataPoints,0);
// intial centers and clusters
for (unsigned int i=0;i<nDataPoints;i++)
{
memberships[i] = i;
centerPoints[i] = i;
}
*/
/*
// compute distance matrix
double * distance = new double[nDataPoints*nDataPoints];
double maxDist = 0;
for (unsigned int i=0;i<nDataPoints;i++)
{
distance[i + i*nDataPoints] = 0;
for(unsigned int j=i+1;j<nDataPoints;j++)
{
double sum = 0;
for(unsigned int d=0; d<1;d++){
//diff += ;
sum += ((data[i + d*nDataPoints]- data[j + d*nDataPoints])
*(data[i + d*nDataPoints]- data[j + d*nDataPoints]))
/(3e-16+data[i + d*nDataPoints] + data[j + d*nDataPoints]);
}
distance[i + j*nDataPoints] = sum;
distance[j + i*nDataPoints] = sum;
if (sum>maxDist)
maxDist = sum;
}
}
*/
//mexPrintf("centers size = %d\n",centers.size());
//mexPrintf("clusters size = %d\n",clusters.size());
/*
int k=0;
while (1) {
double mindist = maxDist;
unsigned int minidx[2];
minidx[0] = 0;
minidx[1] = 0;
// get pair of closest centers
for (unsigned int i=0; i<nDataPoints; i++)
{
if (centerPoints[i]==-1)
continue;
for (unsigned int j=i+1; j<nDataPoints; j++)
{
if (centerPoints[j]==-1)
continue;
if (mindist>distance[centerPoints[i] + centerPoints[j]*nDataPoints])
{
minidx[0] = i;
minidx[1] = j;
mindist = distance[centerPoints[i] + centerPoints[j]*nDataPoints];
}
}
}
//mexPrintf("trh = %g\tmindist = %g\n\n",threshold,mindist);
// if min dist is larger than threshold, then stop
if (mindist>threshold)
break;
// merge clusters by updating membership
unsigned int new_clust = minidx[0];
unsigned int old_clust = minidx[1];
//mexPrintf("join clust %d and %d\n",new_clust,old_clust);
for (unsigned int i=0;i<nDataPoints;i++)
{
//if ((memberships[i] == minidx[0]) || (memberships[i] == minidx[1]) )
if (memberships[i] == old_clust)
{
memberships[i] = new_clust;
}
}
// eliminate old center
centerPoints[old_clust] = -1;
// update cluster center
unsigned int bestCenter = 0;
double bestDist = maxDist*nDataPoints+1;
for (unsigned int i=0;i<nDataPoints;i++)
{
if (memberships[i] != minidx[0])
continue;
//mexPrintf("comparing: %d\t",i);
double thisDist = 0;
for (unsigned int j=0; j<nDataPoints; j++)
{
if (memberships[j] != minidx[0])
continue;
thisDist += distance[i + j*nDataPoints];
//mexPrintf("%d\t",j);
}
if (thisDist<bestDist)
{
bestCenter = i;
bestDist = thisDist;
}
//mexPrintf("\n");
}
centerPoints[new_clust] = bestCenter;
//mexPrintf("new center is %d\n",bestCenter);
k++;
if (k>nDataPoints)
{
//mexPrintf("wtf?\n");
return;
}
}
delete [] distance;
*/
//initialize output
/*
centers_OUT = mxCreateNumericMatrix(nDataPoints, 1, mxDOUBLE_CLASS,mxREAL);
double *centersOut = (double *) mxGetPr(centers_OUT);
for (unsigned int idx = 0; idx< nDataPoints;idx++)
{
centersOut[idx] = centerPoints[idx]+1;
}
clusterID_OUT = mxCreateNumericMatrix(nDataPoints, 1, mxDOUBLE_CLASS,mxREAL);
double *clusterIdOut = (double *) mxGetPr(clusterID_OUT);
for (unsigned int idx = 0; idx< nDataPoints;idx++)
{
clusterIdOut[idx] = memberships[idx]+1;
}
*/
}
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if (!(nlhs==1))
{
mexErrMsgIdAndTxt("MyToolbox:arrayProduct:nlhs","One output required.");
}
if(nrhs<1)
{
mexErrMsgIdAndTxt("MyToolbox:arrayProduct:nrhs","At least one input required.");
}
if(nrhs>2)
{
mexErrMsgIdAndTxt("MyToolbox:arrayProduct:nrhs","A maximum of two inputs is required.");
}
if(nrhs==1 || nrhs==2)
{
if (!(mxIsDouble(prhs[0])))
{
mexErrMsgTxt("The input must be a double matrix.");
}
if (nrhs==2 && (!mxIsStruct(prhs[1])))
{
mexErrMsgTxt("The second and optional input must be a structure. Type \"help lsd\" to discover more.");
}
double scale=0.8;
double sigma_coef=0.6;
double quant=2.0;
double ang_th=22.5;
double log_eps=0.0;
double density_th=0.7;
int n_bins=1024;
double width=1.5;
double* ptr;
if (nrhs==2)
{
int tmp=0;
for( tmp=0; tmp<mxGetNumberOfFields(prhs[1]);tmp++)
{
if ( strcmp(mxGetFieldNameByNumber(prhs[1],tmp),"scale")==0)
{
if (!(mxIsDouble(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0)))))
{
mexErrMsgTxt("A double argument was expected.");
}
if (mxGetNumberOfElements((mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0))))!=1)
{
mexErrMsgTxt("Only one value was expected.");
}
ptr=mxGetPr(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],tmp)));
if(ptr[0]>=0)
{
scale=ptr[0];
mexPrintf("ptr[0]=%e et scale=%e",ptr[0],scale);
}
else
{
mexErrMsgTxt("The scale value is not acceptable. For more information, type \"help lsd\"");
}
}
if ( strcmp(mxGetFieldNameByNumber(prhs[1],tmp),"sigma_coef")==0)
{
if (!mxIsDouble(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0))))
{
mexErrMsgTxt("A double argument was expected.");
}
if (!mxGetNumberOfElements((mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0)))))
{
mexErrMsgTxt("Only one value was expected.");
}
ptr=mxGetPr(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],tmp)));
if(ptr[0]>=0)
{
sigma_coef=ptr[0];
}
else
{
mexErrMsgTxt("The sigma_coef value is not acceptable. For more information, type \"help lsd\"");
}
}
if ( strcmp(mxGetFieldNameByNumber(prhs[1],tmp),"quant")==0)
{
if (!mxIsDouble(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0))))
{
mexErrMsgTxt("A double argument was expected.");
}
if (!mxGetNumberOfElements((mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0)))))
{
mexErrMsgTxt("Only one value was expected.");
}
ptr=mxGetPr(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],tmp)));
if(ptr[0]>=0)
{
quant=ptr[0];
}
else
{
mexErrMsgTxt("The quant value is not acceptable. For more information, type \"help lsd\"");
}
}
if ( strcmp(mxGetFieldNameByNumber(prhs[1],tmp),"ang_th")==0)
{
if (!mxIsDouble(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0))))
{
mexErrMsgTxt("A double argument was expected.");
}
if (!mxGetNumberOfElements((mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0)))))
{
mexErrMsgTxt("Only one value was expected.");
}
ptr=mxGetPr(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],tmp)));
if(ptr[0]>=0 && ptr[0]<=180)
{
ang_th=ptr[0];
}
else
{
mexErrMsgTxt("The ang_th value is not acceptable. For more information, type \"help lsd\"");
}
}
if ( strcmp(mxGetFieldNameByNumber(prhs[1],tmp),"log_eps")==0)
{
if (!mxIsDouble(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0))))
{
mexErrMsgTxt("A double argument was expected.");
}
if (!mxGetNumberOfElements((mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0)))))
{
mexErrMsgTxt("Only one value was expected.");
}
ptr=mxGetPr(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],tmp)));
log_eps=ptr[0];
}
if ( strcmp(mxGetFieldNameByNumber(prhs[1],tmp),"n_bins")==0)
{
if (!mxIsDouble(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0))))
{
mexErrMsgTxt("A double argument was expected.");
}
if (!mxGetNumberOfElements((mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],0)))))
{
mexErrMsgTxt("Only one value was expected.");
}
ptr=mxGetPr(mxGetField(prhs[1],0,mxGetFieldNameByNumber(prhs[1],tmp)));
if(ptr[0]>=1)
{
n_bins=ptr[0];
}
else
{
mexErrMsgTxt("The n_bins value is not acceptable. For more information, type \"help lsd\"");
}
}
}
}
double * image=mxGetPr(prhs[0]);
int X=mxGetN(prhs[0]);
int Y=mxGetM(prhs[0]);
double * segs;
int n;
int dim = 7;
int * region;
int regX,regY;
int i,j;
/* execute LSD */
segs = LineSegmentDetection( &n, image, X, Y,
scale,
sigma_coef,
quant,
ang_th,
log_eps,
density_th,
n_bins,
NULL,
®X, ®Y );
/* The output which is created here will be an array */
mwSize *dims;
plhs[0]=mxCreateDoubleMatrix(n,dim,mxREAL);
double* pointeur=(double*)mxGetPr(plhs[0]);
int z=0;
for(z=0;z<n;z++)
{
for(j=0;j<dim;j++)
{
pointeur[z+j*n]=segs[z*dim+j];
}
}
z=0;
j=0;
for(z=0;z<n;z++)
{
for(j=0;j<dim;j++)
{
double c=pointeur[z+3*n];
pointeur[z+3*n]=pointeur[z];
pointeur[z]=c;
c=pointeur[z+2*n];
pointeur[z+2*n]=pointeur[z+n];
pointeur[z+n]=c;
}
}
}
}
void SetupParams(int nrhs, const mxArray *prhs[]) {
// PARAMETER DEFINITIONS GO HERE
// First two paramers are feature matrix and initial cluster assignment (or emptry)
int NumParams = nrhs-2;
if (NumParams % 2 != 0)
mexErrMsgTxt("Number of parameters should be even (i.e., param name, param value)");
char buf[STRLEN];
int ActualNumParam = NumParams/2;
for (int paramiter=0;paramiter<ActualNumParam;paramiter++) {
int strlen = (int) mxGetNumberOfElements(prhs[2+paramiter])+1;
mxGetString(prhs[2+paramiter*2], buf, STRLEN);
if (_strcmpi(buf, "MinClusters") == 0){
MinClusters = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting MinClusters to %d\n",MinClusters);
} else if (_strcmpi(buf, "MaxClusters") == 0) {
MaxClusters = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting MaxClusters to %d\n",MaxClusters);
} else if (_strcmpi(buf, "MaxPossibleClusters") == 0) {
MaxPossibleClusters = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting MaxPossibleClusters to %d\n",MaxPossibleClusters);
} else if (_strcmpi(buf, "nStarts") == 0) {
nStarts = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting nStarts to %d\n",nStarts);
} else if (_strcmpi(buf, "RandomSeed") == 0) {
RandomSeed = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting RandomSeed to %d\n",RandomSeed);
} else if (_strcmpi(buf, "Verbose") == 0) {
Verbose = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting Verbose to %d\n",Verbose);
} else if (_strcmpi(buf, "DistThresh") == 0) {
DistThresh = (float) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting DistThresh to %f\n",DistThresh);
} else if (_strcmpi(buf, "FullStepEvery") == 0) {
FullStepEvery = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting FullStepEvery to %d\n",FullStepEvery);
} else if (_strcmpi(buf, "ChangedThresh") == 0) {
ChangedThresh = (float) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting ChangedThresh to %f\n",ChangedThresh);
} else if (_strcmpi(buf, "Screen") == 0) {
Screen = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting Screen to %d\n",Screen);
} else if (_strcmpi(buf, "MaxIter") == 0) {
MaxIter = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting MaxIter to %d\n",MaxIter);
} else if (_strcmpi(buf, "SplitEvery") == 0) {
SplitEvery = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting SplitEvery to %d\n",SplitEvery);
} else if (_strcmpi(buf, "PenaltyMix") == 0) {
PenaltyMix = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting PenaltyMix to %d\n",PenaltyMix);
} else if (_strcmpi(buf, "Subset") == 0) {
Subset = (int) *(double*)mxGetPr(prhs[2+paramiter*2+1]);
printf("Setting Subset to %d\n",Subset);
} else
mexErrMsgTxt("Unknown paramter");
}
/*
INT_PARAM(MinClusters);
INT_PARAM(MaxClusters);
INT_PARAM(MaxPossibleClusters);
INT_PARAM(nStarts);
INT_PARAM(RandomSeed);
INT_PARAM(Verbose);
FLOAT_PARAM(DistThresh);
INT_PARAM(FullStepEvery);
FLOAT_PARAM(ChangedThresh);
BOOLEAN_PARAM(Screen);
INT_PARAM(MaxIter);
INT_PARAM(SplitEvery);
FLOAT_PARAM(PenaltyMix);
INT_PARAM(Subset);
*/
}
/* Function: mdlCheckParameters =============================================
* Abstract:
* Validate our parameters to verify they are okay.
*/
static void mdlCheckParameters(SimStruct *S)
{
int_T param;
for( param=0; param<NPARAMS; param++ )
{
if ( (param != 11) && (param != 12) )
if ( !IS_PARAM_DOUBLE(ssGetSFcnParam(S, param)) && (mxGetNumberOfElements(ssGetSFcnParam(S, param)) < 1) )
{
ssSetErrorStatus(S, "Parameter is not a double.");
return;
}
}
if( (mxGetNumberOfElements(paramQuaternionIndex) != 0) && (mxGetNumberOfElements(paramQuaternionIndex) != 2) )
{
ssSetErrorStatus(S, "The quaternion index must be defined by two numbers.");
return;
}
if( mxGetNumberOfElements(paramQuaternionIndex) == 2 )
{
if( !IS_PARAM_DOUBLE(paramQuaternionIndex) )
{
ssSetErrorStatus(S, "The quaternion index must be defined by of type double.");
return;
}
if( (intval(mxGetPr(paramQuaternionIndex)[0]) < 1) || (intval(mxGetPr(paramQuaternionIndex)[0]) > intval(mxGetPr(paramQuaternionIndex)[1])) )
{
ssSetErrorStatus(S, "The quaternion index interval is not defined properly.");
return;
}
param = intval(mxGetPr(paramQuaternionIndex)[1]) - intval(mxGetPr(paramQuaternionIndex)[0]) + 1;
if( param != (param/4)*4 )
{
ssSetErrorStatus(S, "The quaternion index interval must have a length multiple of 4.");
return;
}
}
if( (mxGetNumberOfElements(paramOmegaDotIndex) != 0) && (mxGetNumberOfElements(paramOmegaDotIndex) != 2) )
{
ssSetErrorStatus(S, "The omega_dot index must be defined by two numbers.");
return;
}
if( mxGetNumberOfElements(paramOmegaDotIndex) == 2 )
{
if( !IS_PARAM_DOUBLE(paramOmegaDotIndex) )
{
ssSetErrorStatus(S, "The omega_dot index must be defined by of type double.");
return;
}
if( (intval(mxGetPr(paramOmegaDotIndex)[0]) < 1) || (intval(mxGetPr(paramOmegaDotIndex)[0]) > intval(mxGetPr(paramOmegaDotIndex)[1])) )
{
ssSetErrorStatus(S, "The omega_dot index interval is not defined properly.");
return;
}
param = intval(mxGetPr(paramOmegaDotIndex)[1]) - intval(mxGetPr(paramOmegaDotIndex)[0]) + 1;
if( param != (param/3)*3 )
{
ssSetErrorStatus(S, "The omega_dot index interval must have a length multiple of 3.");
return;
}
}
if ( !((mxGetPr(paramSampleTime)[0] == -1) || (mxGetPr(paramSampleTime)[0] > 0)) )
{
ssSetErrorStatus(S, "The sample time must be inherited (-1) or discrete (a positive number).");
return;
}
}
void mexFunction(int nlhs, mxArray* plhs[],
const int nrhs, const mxArray* prhs[]) {
if (nrhs != 3) {
mexPrintf("Exactly 3 arguments required.");
}
// Grab the region mask (HxW).
int H = mxGetM(prhs[ARG_IMG_REGIONS]);
int W = mxGetN(prhs[ARG_IMG_REGIONS]);
int N = H * W;
if (mxGetClassID(prhs[ARG_IMG_REGIONS]) != mxINT32_CLASS) {
mexErrMsgTxt("imgRegions must be of class 'int32'");
}
int* img_regions = (int*) mxGetData(prhs[ARG_IMG_REGIONS]);
// Get the number of regions.
int R = (int) mxGetScalar(prhs[ARG_NUM_REGIONS]);
// Grab the eroded region mask.
if (mxGetNumberOfDimensions(prhs[ARG_IMG_ERODED]) != 2
|| mxGetNumberOfElements(prhs[ARG_IMG_ERODED]) != N) {
mexErrMsgTxt("imgEroded must be of size HxW");
} else if (mxGetClassID(prhs[ARG_IMG_ERODED]) != mxLOGICAL_CLASS) {
mexErrMsgTxt("imgEroded must be of class 'logical'");
}
bool* img_eroded = (bool*) mxGetData(prhs[ARG_IMG_ERODED]);
// Create the outputs.
mwSize ndims_out = 3;
mwSize dims_out[] = {H, W, R};
plhs[RET_INTERIORS] = mxCreateLogicalArray(ndims_out, &dims_out[0]);
plhs[RET_EDGES] = mxCreateLogicalArray(ndims_out, &dims_out[0]);
mwSize ndims_out_size = 2;
mwSize dims_out_size[] = {R, 1};
bool* img_interiors = (bool*) mxGetData(plhs[RET_INTERIORS]);
bool* img_edges = (bool*) mxGetData(plhs[RET_EDGES]);
// unsigned int num_pix_interiors[R];
// unsigned int num_pix_edges[R];
unsigned int * num_pix_interiors = new unsigned int [R];
unsigned int * num_pix_edges = new unsigned int [R];
for (int rr = 0; rr < R; ++rr) {
num_pix_interiors[rr] = 0;
num_pix_edges[rr] = 0;
}
for (int ii = 0; ii < N; ++ii, ++img_eroded) {
// Grab the Region ID.
int region_id = img_regions[ii] - 1;
// Is it in the interior?
if (*img_eroded) {
img_interiors[region_id * N + ii] = true;
++num_pix_interiors[region_id];
} else {
img_edges[region_id * N + ii] = true;
++num_pix_edges[region_id];
}
}
// Now that we know how many pixels make up the interiors and borders,
// if we have any interiors or border regions that are empty, just use
// the entire mask instead.
for (int ii = 0; ii < N; ++ii) {
// Grab the Region ID.
int region_id = img_regions[ii] - 1;
if (num_pix_interiors[region_id] == 0) {
img_interiors[region_id * N + ii] = true;
}
if (num_pix_edges[region_id] == 0) {
img_edges[region_id * N + ii] = true;
}
}
}
/* Entry point */
void mexFunction(
int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
int* channels;
int channelsNumber;
float* gains;
int gainsNumber;
/* Load MCHA library */
Mcha mcha;
if ( !mcha.noError() )
{
mexErrMsgTxt( mcha.getErrorStr() );
return;
}
errorMsg = mxCreateString("");
/* Check the number of input/output arguments */
if ((nrhs != 2) || (nlhs>1))
{
errorMsg = mxCreateString("Wrong call to function.");
return;
}
/* Check if the data is valid */
if (!mxIsNumeric(channelsArray) || !mxIsNumeric(gainsArray) )
{
errorMsg = mxCreateString("Wrong call to function: channels and gains arrays should be numeric vectors");
return;
}
/* Get the size of the channels matrix */
double* channelsData = mxGetPr(channelsArray);
channelsNumber = (int) mxGetNumberOfElements(channelsArray);
double* gainsData = mxGetPr(gainsArray);
gainsNumber = (int) mxGetNumberOfElements(gainsArray);
/* Check is the lengths are the same */
if (channelsNumber != gainsNumber)
{
errorMsg = mxCreateString("Wrong call to function: the lenghts of the channels and gains arrays should be the same");
return;
}
/* Create and fill channels and gains arrays */
if (channelsNumber > 0)
{
channels = new int[channelsNumber];
gains = new float[channelsNumber];
for (int i= 0; i<channelsNumber; i++)
{
channels[i] = (int) channelsData[i];
gains[i] = (float) gainsData[i];
}
/* Call the function */
if ( !mcha.setGain (channels, channelsNumber, gains) )
{
errorMsg = mxCreateString( mcha.getLastError() );
}
}
/* Clean up */
delete [] channels;
delete [] gains;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
/* inputs:
* image array
* prmVect
* mode
* {options}
*/
dataStruct_t data;
/* check inputs */
if (nrhs < 3) mexErrMsgTxt("Inputs should be: data, prmVect, mode.");
if (!mxIsDouble(prhs[0])) mexErrMsgTxt("Data input must be double array.");
size_t nx = mxGetN(prhs[0]);
size_t ny = mxGetM(prhs[0]);
if (nx != ny) mexErrMsgTxt("Input image must be a square.");
if (!(nx % 2)) mexErrMsgTxt("The side of the input image must be odd.");
int N = nx*ny;
if (mxGetNumberOfElements(prhs[1])!=NPARAMS || !mxIsDouble(prhs[1])) mexErrMsgTxt("Incorrect parameter vector format.");
if (!mxIsChar(prhs[2])) mexErrMsgTxt("Mode needs to be a string.");
if (nrhs < 4) {
data.maxIter = 500;
data.eAbs = 1e-8;
data.eRel = 1e-8;
} else {
if (!mxIsDouble(prhs[3]) || mxGetNumberOfElements(prhs[3])!=3) mexErrMsgTxt("Options must must be double array with 3 elements.");
double *options = mxGetPr(prhs[3]);
data.maxIter = options[0];
data.eAbs = options[1];
data.eRel = options[2];
}
/* read mode input */
int np = (int)mxGetNumberOfElements(prhs[2]);
char *mode;
mode = (char*)malloc(sizeof(char)*(np+1));
mxGetString(prhs[2], mode, np+1);
int i;
for (i=0; i<strlen(mode); ++i) {
mode[i] = tolower(mode[i]);
}
np = 0; /* number of parameters to fit */
for (i=0; i<NPARAMS; ++i) {
if (strchr(mode, refMode[i])!=NULL) { np++; }
}
if (np==0) mexErrMsgTxt("Unknown mode.");
/* allocate */
data.nx = nx;
data.np = np;
data.pixels = mxGetPr(prhs[0]);
data.gx = (double*)malloc(sizeof(double)*nx);
data.gy = (double*)malloc(sizeof(double)*nx);
data.estIdx = (int*)malloc(sizeof(int)*np);
memcpy(data.prmVect, mxGetPr(prhs[1]), NPARAMS*sizeof(double));
data.dfunc = (pfunc_t*) malloc(sizeof(pfunc_t) * np);
/* read mask/pixels */
data.nValid = N;
for (i=0; i<N; ++i) {
data.nValid -= (int)mxIsNaN(data.pixels[i]);
}
if (data.nValid < 5) mexErrMsgTxt("Input image must contain at least 5 data points.");
data.idx = (int*)malloc(sizeof(int)*data.nValid);
int *nanIdx = (int*)malloc(sizeof(int)*(N-data.nValid));
int k = 0, l = 0;
for (i=0; i<N; ++i) {
if (!mxIsNaN(data.pixels[i])) {
data.idx[k++] = i;
} else {
nanIdx[l++] = i;
}
}
np = 0;
if (strchr(mode, 'x')!=NULL) {data.estIdx[np] = 0; data.dfunc[np++] = df_dx;}
if (strchr(mode, 'y')!=NULL) {data.estIdx[np] = 1; data.dfunc[np++] = df_dy;}
if (strchr(mode, 'a')!=NULL) {data.estIdx[np] = 2; data.dfunc[np++] = df_dA;}
if (strchr(mode, 's')!=NULL) {data.estIdx[np] = 3; data.dfunc[np++] = df_ds;}
if (strchr(mode, 'c')!=NULL) {data.estIdx[np] = 4; data.dfunc[np++] = df_dc;}
data.x_init = (double*)malloc(sizeof(double)*np);
for (i=0; i<np; ++i) {
data.x_init[i] = data.prmVect[data.estIdx[i]];
}
MLalgo(&data);
/* parameters */
if (nlhs > 0) {
plhs[0] = mxCreateDoubleMatrix(1, NPARAMS, mxREAL);
memcpy(mxGetPr(plhs[0]), data.prmVect, NPARAMS*sizeof(double));
}
/* standard dev. of parameters & covariance matrix */
double RSS = 0.0;
double* resValid = NULL;
if (nlhs > 1) {
resValid = (double*)malloc(data.nValid*sizeof(double));
for (i=0; i<data.nValid; ++i) {
resValid[i] = gsl_vector_get(data.residuals, i);
RSS += resValid[i]*resValid[i];
}
gsl_matrix *covar = gsl_matrix_alloc(np, np);
gsl_multifit_covar(data.J, 0.0, covar);
double iRSS = RSS/(data.nValid - data.np - 1);
plhs[1] = mxCreateDoubleMatrix(1, data.np, mxREAL);
double *prmStd = mxGetPr(plhs[1]);
for (i=0; i<data.np; ++i) {
prmStd[i] = sqrt(iRSS*gsl_matrix_get(covar, i, i));
}
if (nlhs > 2) {
plhs[2] = mxCreateDoubleMatrix(np, np, mxREAL);
/* cov. matrix is symmetric, no need to transpose */
memcpy(mxGetPr(plhs[2]), covar->data, np*np*sizeof(double));
}
gsl_matrix_free(covar);
}
/* residuals */
if (nlhs > 3) {
const char *fieldnames[] = {"data", "hAD", "mean", "std", "RSS"};
mwSize dims[2] = {1, 1};
plhs[3] = mxCreateStructArray(2, dims, 5, fieldnames);
mxArray *val = mxCreateDoubleMatrix(nx, nx, mxREAL);
double* res = mxGetPr(val);
double mean = 0.0, std = 0.0;
for (i=0; i<data.nValid; ++i) {
res[data.idx[i]] = resValid[i];
mean += resValid[i];
}
std = sqrt((RSS-mean*mean/data.nValid)/(data.nValid-1));
mean /= data.nValid;
for (i=0; i<N-data.nValid; ++i) {
res[nanIdx[i]] = mxGetNaN();
}
// A-D test, case 2: mean known
unsigned char hAD = adtest(resValid, data.nValid, 2, 0.0, std, 0.05);
mxSetFieldByNumber(plhs[3], 0, 0, val);
mxSetFieldByNumber(plhs[3], 0, 1, mxCreateLogicalScalar(hAD));
mxSetFieldByNumber(plhs[3], 0, 2, mxCreateDoubleScalar(mean));
mxSetFieldByNumber(plhs[3], 0, 3, mxCreateDoubleScalar(std));
mxSetFieldByNumber(plhs[3], 0, 4, mxCreateDoubleScalar(RSS));
}
/* Jacobian */
if (nlhs > 4) {
/* convert row-major double* data.J->data to column-major double* */
plhs[4] = mxCreateDoubleMatrix(N, np, mxREAL);
double *J = mxGetPr(plhs[4]);
int k;
for (k=0; k<np; ++k) {
for (i=0; i<data.nValid; ++i) {
J[data.idx[i]+k*N] = gsl_matrix_get(data.J, i, k);
}
for (i=0; i<N-data.nValid; ++i) {
J[nanIdx[i]+k*N] = mxGetNaN();
}
}
}
free(resValid);
gsl_matrix_free(data.J);
gsl_vector_free(data.residuals);
free(data.x_init);
free(nanIdx);
free(data.idx);
free(data.dfunc);
free(data.estIdx);
free(data.gy);
free(data.gx);
free(mode);
}
int MatlabBufferGadget::process(GadgetContainerMessage<IsmrmrdReconData>* m1)
{
// Initialize a string for matlab commands
std::string cmd;
auto recon_data = m1->getObjectPtr();
mwSize nencoding_spaces = recon_data->rbit_.size();
const char* fieldnames[2] = {"data","reference"};
auto reconArray = mxCreateStructArray(1,&nencoding_spaces,2,fieldnames);
//auto reconArray = mxCreateCellArray(1,&nencoding_spaces);
for (int i = 0; i < recon_data->rbit_.size(); i++){
auto mxrecon = BufferToMatlabStruct(&recon_data->rbit_[i].data_);
mxSetField(reconArray,i,"data",mxrecon);
if (recon_data->rbit_[i].ref_){
auto mxref = BufferToMatlabStruct(recon_data->rbit_[i].ref_.get_ptr());
mxSetField(reconArray,i,"reference",mxref);
}
}
engPutVariable(engine_, "recon_data", reconArray);
cmd = "[imageQ,bufferQ] = matgadget.run_process(recon_data); matgadget.emptyQ(); whos()";
send_matlab_command(cmd);
// Get the size of the gadget's queue
mxArray *imageQ = engGetVariable(engine_, "imageQ");
if (imageQ == NULL) {
GERROR("Failed to get the imageQ from matgadget\n");
return GADGET_FAIL;
}
size_t qlen = mxGetNumberOfElements(imageQ);
GDEBUG("Image Queue size: %d \n", qlen);
const mwSize* dims = mxGetDimensions(imageQ);
mwSize ndims = mxGetNumberOfDimensions(imageQ);
//Read all Image bytes
for (mwIndex idx = 0; idx < qlen; idx++) {
mxArray *res_hdr = mxGetField(imageQ, idx, "bytes");
mxArray *res_data = mxGetField(imageQ, idx, "image");
GadgetContainerMessage<ISMRMRD::ImageHeader>* m3 =
new GadgetContainerMessage<ISMRMRD::ImageHeader>();
ISMRMRD::ImageHeader *hdr_new = m3->getObjectPtr();
memcpy(hdr_new, mxGetData(res_hdr), sizeof(ISMRMRD::ImageHeader));
auto image= MatlabToHoNDArray<std::complex<float>>(res_data);
auto m4 = new GadgetContainerMessage< hoNDArray< std::complex<float> > >(image);
auto dims = *image->get_dimensions();
delete image;
m3->cont(m4);
if (this->next()->putq(m3) < 0) {
GDEBUG("Failed to put Image message on queue\n");
return GADGET_FAIL;
}
}
//Match engGetVariable with mxDestroy___s
mxArray* bufferQ = engGetVariable(engine_,"bufferQ");
qlen = mxGetNumberOfElements(bufferQ);
GDEBUG("Buffer Queue size: %d \n", qlen);
for (mwIndex idx = 0; idx <qlen; idx++){
IsmrmrdReconData output_data;
IsmrmrdReconBit bit;
bit.data_ = MatlabStructToBuffer(mxGetField(bufferQ,idx,"data"));
auto ref = mxGetField(bufferQ,idx,"reference");
if (ref){
GDEBUG("Adding reference");
bit.ref_ = MatlabStructToBuffer(ref);
}
output_data.rbit_.push_back(bit);
auto m3 = new GadgetContainerMessage<IsmrmrdReconData>(output_data.rbit_);
if (this->next()->putq(m3) < 0){
GDEBUG("Failed to put Buffer message on queue\n");
return GADGET_FAIL;
}
}
mxDestroyArray(bufferQ);
mxDestroyArray(imageQ);
//mxDestroyArray(reconArray); //We're not supposed to delete this?
// We are finished with the incoming messages m1 and m2
m1->release();
return GADGET_OK;
}
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) {
// INPUT:
float *pfY, *pfBias, *pfWeight;
// OUTPUT:
float *pfYout;
mwSize ndims_out, *dims_out;
// Local:
const mxArray * pArg;
// mwSize nrowsX,ncolsX, nrowsY1, ncolsY1, nrowsY2, ncolsY2;
//long Nx, nshift, Nvecs, Ny;
long h, w, kH, kW, dH, dW, nInputPlanes, nInputPlanes_y, h_out, w_out, nOutputPlanes;
long nBias;
/* --------------- Check inputs ---------------------*/
if (nrhs != 5)
mexErrMsgTxt("5 inputs required");
if (nlhs > 1)
mexErrMsgTxt("only one output allowed");
/// ------------------- Y ----------
pArg = prhs[0];
if (!mxIsNumeric(pArg) || !mxIsSingle(pArg) || mxIsEmpty(pArg) || mxIsComplex(pArg) )
mexErrMsgTxt("Input 1 (Y) must be a noncomplex matrix of singles.");
pfY = (float*) mxGetData(prhs[0]);
h = mxGetM(pArg);
w = mxGetSize(pArg, 2);
nInputPlanes_y = (long) mxGetSize(pArg, 3);
//mexPrintf("Size Y = %d x %d x %d\n", mxGetSize(pArg, 1), mxGetSize(pArg, 2), mxGetSize(pArg, 3));
/// ------------------- Bias ----------
pArg = prhs[1];
if(!mxIsNumeric(pArg) || !mxIsSingle(pArg) || mxIsEmpty(pArg) || mxIsComplex(pArg) ) {
mexErrMsgTxt("Input 2 (Bias) must be a noncomplex single matrix.");
}
pfBias = (float*) mxGetData(pArg);
nBias = (long) mxGetNumberOfElements(pArg);
/// ------------------- Weight ----------
pArg = prhs[2];
if(!mxIsNumeric(pArg) || !mxIsSingle(pArg) || mxIsEmpty(pArg) || mxIsComplex(pArg) ) {
mexErrMsgTxt("Input 3 (Weight) must be a noncomplex single matrix.");
}
pfWeight = (float*) mxGetData(pArg);
kH = mxGetM(pArg);
kW = mxGetSize(pArg, 2);
nInputPlanes = mxGetSize(pArg, 3);
nOutputPlanes = mxGetSize(pArg, 4);
if (nInputPlanes_y != nInputPlanes) {
mexPrintf("number of input planes in weight mtx: %d. number of input planes in y : %d\n", nInputPlanes, nInputPlanes_y);
mexErrMsgTxt("number of input planes in weight mtx must be the same as the number of input planes in y");
}
if (nBias != nOutputPlanes) {
mexPrintf("number of elements in Bias : %d. size3 = %d\n", nBias, nOutputPlanes);
mexErrMsgTxt("number of elements in Bias must be the same size of dimension 3 of weights");
}
//mexPrintf("Size Weight = %d x %d x %d\n", kH, kW, nOutputPlanes);
//mexPrintf("Size Weight = %d x %d x %d\n", mxGetSize(pArg, 1), mxGetSize(pArg, 2), mxGetSize(pArg, 3));
/// ------------------- dH ----------
pArg = prhs[3];
if(!mxIsNumeric(pArg) || !mxIsSingle(pArg) || mxIsEmpty(pArg) || mxIsComplex(pArg) || (mxGetNumberOfElements(pArg) > 1) ) {
mexErrMsgTxt("Input 4 (dH) must be a noncomplex single scalar.");
}
dH = (long) mxGetScalar(pArg);
/// ------------------- dW ----------
pArg = prhs[4];
if(!mxIsNumeric(pArg) || !mxIsSingle(pArg) || mxIsEmpty(pArg) || mxIsComplex(pArg) || (mxGetNumberOfElements(pArg) > 1) ) {
mexErrMsgTxt("Input 5 (dW) must be a noncomplex single scalar.");
}
dW = (long) mxGetScalar(pArg);
h_out = floor( (h - kH)/ dH) + 1;
w_out = floor( (w - kW)/ dW) + 1;
//mexPrintf("h, w, kH, kW, dH, dW = %d, %d, %d, %d, %d, %d\n", h, w, kH, kW, dH, dW);
// y_out1 = zeros(h_out, w_out, nOutputPlanes);
// pfYout = (float***) mxCalloc(h_out * w_out * nOutputPlanes);
/// ------------------- Yout (OUTPUT)----------
ndims_out = 3;
dims_out = (mwSize*) mxCalloc(ndims_out, sizeof(mwSize));
dims_out[0] = (mwSize) h_out;
dims_out[1] = (mwSize) w_out;
dims_out[2] = (mwSize) nOutputPlanes;
//mexPrintf("Creating output ... \n");
//mexPrintf("Size Yout (before) (a) = %d x %d x %d\n", h_out, w_out, nOutputPlanes);
//mexPrintf("Size Yout (before) (b) = %d x %d x %d\n", dims_out[0], dims_out[1], dims_out[2]);
plhs[0] = mxCreateNumericArray(ndims_out, dims_out,
mxSINGLE_CLASS, mxREAL);
pfYout = (float*) mxGetData(plhs[0]);
//mexPrintf("Size Yout = %d x %d x %d\n", mxGetSize(plhs[0], 1), mxGetSize(plhs[0], 2), mxGetSize(plhs[0], 3));
nn_spatialConvolution(pfY, pfBias, pfWeight, dH, dW,
h, w, kH, kW, nInputPlanes, nOutputPlanes, pfYout);
}
void mexFunction(
int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
int SSEnable = 0;
if (nrhs < 1) {
mexErrMsgTxt("One input required.");
} else if (nlhs != 1) {
mexErrMsgTxt("One output argument required.");
}
// I am expecting an nxm array, where n is the # of clusters
// and m is the number of features.
mwSize nrows = mxGetM(prhs[0]);
mwSize ncols = mxGetN(prhs[0]);
mwSize elements = mxGetNumberOfElements(prhs[0]);
mwSize number_of_dims=mxGetNumberOfDimensions(prhs[0]);
if (!mxIsDouble(prhs[0])) {
mexErrMsgTxt("Input must be a double array.");
}
if (nrhs > 1) {
SSEnable = 1;
}
plhs[0] = mxCreateDoubleMatrix(1,3,mxREAL);
double *pOut = mxGetPr(plhs[0]);
pOut[0] = 12.2;
pOut[1] = 1.12;
pOut[2] = 12;
double *pFa = mxGetPr(prhs[0]);
double *pCol[10];
for (int z=0;z<ncols;z++) {
pCol[z] = pFa+z*nrows;
}
double dMin = 1e12;
// Data is in column major order... so,
// x and y can point to each column, then
// iterate on features by adding x/y + mcols
double fsum;
for (int x=0;x<nrows;x++) {
for (int y=0;y<nrows;y++) {
if (y != x) {
fsum = 0;
for (int z=0;z<ncols;z++) {
// Simple squared function.
double t = (pCol[z][x]-pCol[z][y]);
fsum += t*t;
//fsum += (pFa[x+z*nrows]-pFa[y+z*nrows])*(pFa[x+z*nrows]-pFa[y+z*nrows]);
}
//fsum = sqrt(fsum); // Don't bother with the sqrt.. we just want t relative value..
if (fsum < dMin) {
dMin = fsum;
pOut[0] = double(x+1);
pOut[1] = double(y+1);
pOut[2] = dMin;
// This is an optimization. If a lot of pixels are close to zero in distance,
// then it is not that important to find the "closest" of those.
if (dMin < 0.02) {
return;
}
}
}
}
}
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
/* Check number of input arguments */
if (nrhs > 9) {
ERROR("Nine or fewer input arguments are required.");
} else if (nrhs < 4) {
ERROR("At least four input arguments are required.");
}
/* Check number of output arguments */
if (nlhs > 1) {
ERROR("Too many output arguments.");
}
DOUBLE *X = (DOUBLE*) mxGetData(prhs[0]);
CHAR distLabelName;
if (mxGetNumberOfElements(prhs[1]) != 0) {
if (!mxIsChar(prhs[1])) {
ERROR("Second argument must be of type CHAR.");
}
distLabelName = (CHAR)*(CHAR*) mxGetData(prhs[1]);
} else {
distLabelName = 'R';
}
DOUBLE *matlabConstraintMat = (DOUBLE*) mxGetData(prhs[2]);
DOUBLE *tau = (DOUBLE*) mxGetData(prhs[3]);
INT N = (INT) mxGetM(prhs[0]);
INT numSamples = (INT) mxGetN(prhs[0]);
INT numConstraints = (INT) mxGetM(prhs[2]);
INT numRepeats = (INT) mxGetNumberOfElements(prhs[3]);
DOUBLE tolerance;
if ((nrhs >= 5) && (mxGetNumberOfElements(prhs[4]) != 0)) {
tolerance = *(DOUBLE*) mxGetData(prhs[4]);
} else {
tolerance = 0.00001;
}
DOUBLE delta;
if ((nrhs >= 6) && (mxGetNumberOfElements(prhs[5]) != 0)) {
delta = *(DOUBLE*) mxGetData(prhs[5]);
} else {
delta = 0.00001;
}
INT numIters;
if ((nrhs >= 7) && (mxGetNumberOfElements(prhs[6]) != 0)) {
numIters = (INT)*(DOUBLE*) mxGetData(prhs[6]);
} else {
numIters = 100000;
}
DOUBLE tauMultiplier;
if ((nrhs >= 8) && (mxGetNumberOfElements(prhs[7]) != 0)) {
tauMultiplier = *(DOUBLE*) mxGetData(prhs[7]);
} else {
tauMultiplier = 10000;
}
DOUBLE tauRate;
if ((nrhs >= 9) && (mxGetNumberOfElements(prhs[8]) != 0)) {
tauRate = *(DOUBLE*) mxGetData(prhs[8]);
} else {
tauRate = 0.9;
}
INT *constraintMat;
DOUBLE *betaVec;
DIST_LABEL_TYPE distLabelType = convertDistLabelName(distLabelName);
if (distLabelType == DIST_LABEL_TARGETS) {
if (mxGetN(prhs[2]) != 3) {
ERROR("Constraint matrix does not meet specified format: second dimension not equal to three.");
}
constraintMat = (INT *) MALLOC(numConstraints * 2 * sizeof(INT));
betaVec = (DOUBLE *) MALLOC(numConstraints * 1 * sizeof(DOUBLE));
} else if (distLabelType == DIST_LABEL_BOUNDS) {
if (mxGetN(prhs[2]) != 4) {
ERROR("Constraint matrix does not meet specified format: second dimension not equal to four.");
}
constraintMat = (INT *) MALLOC(numConstraints * 3 * sizeof(INT));
betaVec = (DOUBLE *) MALLOC(numConstraints * 1 * sizeof(DOUBLE));
} else if ((distLabelType == DIST_LABEL_RELATIONAL) \
|| (distLabelType == DIST_LABEL_SQRHINGE) \
|| (distLabelType == DIST_LABEL_HUBERHINGE)) {
if (mxGetN(prhs[2]) != 5) {
ERROR("Constraint matrix does not meet specified format: second dimension not equal to five.");
}
constraintMat = (INT *) MALLOC(numConstraints * 4 * sizeof(INT));
betaVec = (DOUBLE *) MALLOC(numConstraints * 1 * sizeof(DOUBLE));
}
convertDistanceLabelMat(constraintMat, betaVec, distLabelType, \
matlabConstraintMat, numConstraints, numSamples);
plhs[0] = mxCreateNumericMatrix(N, N, MXPRECISION_CLASS, mxREAL);
DOUBLE *A = (DOUBLE *) mxGetData(plhs[0]);
if (numRepeats > 1) {
nrml_fpc(A, X, distLabelType, constraintMat, betaVec, tau, delta, \
numIters, tolerance, N, numConstraints, numRepeats);
} else {
nrml_fpc_continuation(A, X, distLabelType, constraintMat, betaVec, *tau, \
delta, numIters, tolerance, tauMultiplier, tauRate, N, \
numConstraints);
}
FREE(constraintMat);
FREE(betaVec);
}
/*
* The mex function runs a MST problem.
*/
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
mwIndex i;
mwIndex mrows, ncols;
mwIndex n,nz;
/* sparse matrix */
mwIndex *ia, *ja;
/* matching */
mwIndex *m;
double *m_double;
/* output */
int verify = 0;
/*
* The current calling pattern is
* test_matching_mex(A,matching)
*/
const mxArray* arg_matrix;
const mxArray* arg_matching;
int required_arguments = 2;
if (nrhs != required_arguments) {
mexErrMsgIdAndTxt("matlab_bgl:invalidMexArgument",
"the function requires %i arguments, not %i\n",
required_arguments, nrhs);
}
arg_matrix = prhs[0];
arg_matching = prhs[1];
/* The first input must be a sparse matrix. */
mrows = mxGetM(arg_matrix);
ncols = mxGetN(arg_matrix);
if (mrows != ncols || !mxIsSparse(arg_matrix)) {
mexErrMsgIdAndTxt("matlab_bgl:invalidMexArgument",
"the matrix must be sparse and square");
}
n = mrows;
/* The second input must be of size n */
if (mxGetNumberOfElements(arg_matching) != n) {
mexErrMsgIdAndTxt("matlab_bgl:invalidMexArgument",
"the matching must be size %i not %i", n,
mxGetNumberOfElements(arg_matching));
}
m_double = mxGetPr(arg_matching);
m = mxCalloc(n, sizeof(mwIndex));
for (i=0; i < n; i++) {
m[i] = (mwIndex)m_double[i] ;
if (m[i] == 0) { m[i] = n; }
else { --m[i]; }
}
/* Get the sparse matrix */
/* recall that we've transposed the matrix */
ja = mxGetIr(arg_matrix);
ia = mxGetJc(arg_matrix);
nz = ia[n];
plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL);
#ifdef _DEBUG
mexPrintf("test_maximum_cardinality_matching...");
#endif
test_maximum_cardinality_matching(n, ja, ia, m, &verify);
*mxGetPr(plhs[0]) = (double)verify;
#ifdef _DEBUG
mexPrintf("return\n");
#endif
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/*declare variables*/
const mwSize *dims;
mwIndex indx;
int i, numdims, indx1, indx2, indx3;
int numelin;
mxClassID classid;
double *input1r, *input1i, *input2r, *input2i, *output1r, *output1i;
double a[3][3], b[3][3];
double ai[3][3], bi[3][3];
/*figure out the classid*/
classid = mxGetClassID(prhs[0]);
/*check inputs*/
if (nrhs!=2)
mexErrMsgTxt("Wrong number of input arguments");
/*associate inputs*/
input1r = mxGetData(prhs[0]);
input1i = mxGetImagData(prhs[0]);
input2r = mxGetData(prhs[1]);
input2i = mxGetImagData(prhs[1]);
/*figure out dimension info and number of elements*/
dims = mxGetDimensions(prhs[0]);
numdims = mxGetNumberOfDimensions(prhs[0]);
numelin = mxGetNumberOfElements(prhs[0]);
/*associate output*/
if (input1i == NULL && input2i == NULL)
{
plhs[0] = mxCreateNumericArray(numdims, dims, classid, mxREAL);
output1r = mxGetData(plhs[0]);
}
else
{
plhs[0] = mxCreateNumericArray(numdims, dims, classid, mxCOMPLEX);
output1r = mxGetData(plhs[0]);
output1i = mxGetImagData(plhs[0]);
}
/* do the computation*/
if (input1i == NULL && input2i == NULL)
{
for (i=0; i<numelin/9; i++)
{
/* real-valued case*/
for (indx2=0; indx2<3; ++indx2)
for (indx1=0; indx1<3; ++indx1)
{
a[indx1][indx2] = input1r[i*9+indx1+indx2*3];
b[indx1][indx2] = input2r[i*9+indx1+indx2*3];
output1r[i*9+indx1+indx2*3] = 0;
}
for (indx3=0; indx3<3; ++indx3)
for (indx2=0; indx2<3; ++indx2)
for (indx1=0; indx1<3; ++indx1)
{
output1r[i*9+indx2+indx3*3] += a[indx2][indx1] * b[indx1][indx3];
}
}
return;
}
else if (input1i == NULL && input2i != NULL)
{
for (i=0; i<numelin/9; i++)
{
/* first input real-valued case, second input complex*/
for (indx2=0; indx2<3; ++indx2)
for (indx1=0; indx1<3; ++indx1)
{
a[indx1][indx2] = input1r[i*9+indx1+indx2*3];
b[indx1][indx2] = input2r[i*9+indx1+indx2*3];
bi[indx1][indx2] = input2i[i*9+indx1+indx2*3];
output1r[i*9+indx1+indx2*3] = 0;
output1i[i*9+indx1+indx2*3] = 0;
}
for (indx3=0; indx3<3; ++indx3)
for (indx2=0; indx2<3; ++indx2)
for (indx1=0; indx1<3; ++indx1)
{
output1r[i*9+indx2+indx3*3] += a[indx2][indx1] * b[indx1][indx3];
output1i[i*9+indx2+indx3*3] += a[indx2][indx1] * bi[indx1][indx3];
}
}
return;
}
else if (input1i != NULL && input2i == NULL)
{
for (i=0; i<numelin/9; i++)
{
/* first input complex-valued, second input real-valued*/
for (indx2=0; indx2<3; ++indx2)
for (indx1=0; indx1<3; ++indx1)
{
a[indx1][indx2] = input1r[i*9+indx1+indx2*3];
b[indx1][indx2] = input2r[i*9+indx1+indx2*3];
ai[indx1][indx2] = input1i[i*9+indx1+indx2*3];
output1r[i*9+indx1+indx2*3] = 0;
output1i[i*9+indx1+indx2*3] = 0;
}
for (indx3=0; indx3<3; ++indx3)
for (indx2=0; indx2<3; ++indx2)
for (indx1=0; indx1<3; ++indx1)
{
output1r[i*9+indx2+indx3*3] += a[indx2][indx1] * b[indx1][indx3];
output1i[i*9+indx2+indx3*3] += ai[indx2][indx1] * b[indx1][indx3];
}
}
return;
}
else
{
for (i=0; i<numelin/9; i++)
{
/* both inputs complex-valued*/
for (indx2=0; indx2<3; ++indx2)
for (indx1=0; indx1<3; ++indx1)
{
a[indx1][indx2] = input1r[i*9+indx1+indx2*3];
b[indx1][indx2] = input2r[i*9+indx1+indx2*3];
ai[indx1][indx2] = input1i[i*9+indx1+indx2*3];
bi[indx1][indx2] = input2i[i*9+indx1+indx2*3];
output1r[i*9+indx1+indx2*3] = 0;
output1i[i*9+indx1+indx2*3] = 0;
}
for (indx3=0; indx3<3; ++indx3)
for (indx2=0; indx2<3; ++indx2)
for (indx1=0; indx1<3; ++indx1)
{
output1r[i*9+indx2+indx3*3] += a[indx2][indx1] * b[indx1][indx3] - ai[indx2][indx1] * bi[indx1][indx3];
output1i[i*9+indx2+indx3*3] += ai[indx2][indx1] * b[indx1][indx3] + a[indx2][indx1] * bi[indx1][indx3];
}
}
return;
}
}
// btkAppendEvent(h, label, time, context)
// btkAppendEvent(h, label, time, context, subject)
// btkAppendEvent(h, label, time, context, subject, description)
// btkAppendEvent(h, label, time, context, subject, description, id)
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if(nrhs < 4)
mexErrMsgTxt("Minimum of four inputs required.");
if (nlhs > 2)
mexErrMsgTxt("Too many output arguments.");
btk::Event::Pointer evt = btk::Event::New();
btk::Acquisition::Pointer acq = btk_MOH_get_object<btk::Acquisition>(prhs[0]);
btk::Acquisition::EventConstIterator it;
// Label
if (!mxIsChar(prhs[1]) || mxIsEmpty(prhs[1]))
mexErrMsgTxt("The label must be a non-empty string.");
else
{
size_t strlen_ = (mxGetM(prhs[1]) * mxGetN(prhs[1]) * sizeof(mxChar)) + 1;
char* buffer = (char*)mxMalloc(strlen_);
mxGetString(prhs[1], buffer, strlen_);
evt->SetLabel(buffer);
mxFree(buffer);
it = acq->FindEvent(evt->GetLabel());
}
// Time
if ((mxGetClassID(prhs[2]) != mxDOUBLE_CLASS) || mxIsEmpty(prhs[2]) || mxIsComplex(prhs[2]) || (mxGetNumberOfElements(prhs[2]) != 1))
mexErrMsgTxt("The time must be set by a numerical (double) value.");
else
{
double t = mxGetScalar(prhs[2]);
evt->SetTime(t);
}
// Context
if (!mxIsChar(prhs[3]))
mexErrMsgTxt("The context must be a string.");
else
{
size_t strlen_ = (mxGetM(prhs[3]) * mxGetN(prhs[3]) * sizeof(mxChar)) + 1;
char* buffer = (char*)mxMalloc(strlen_);
mxGetString(prhs[3], buffer, strlen_);
evt->SetContext(buffer);
mxFree(buffer);
}
// Subject (optional)
if (nrhs >= 5)
{
if (!mxIsChar(prhs[4]))
mexErrMsgTxt("The subject must be a string.");
else
{
size_t strlen_ = (mxGetM(prhs[4]) * mxGetN(prhs[4]) * sizeof(mxChar)) + 1;
char* buffer = (char*)mxMalloc(strlen_);
mxGetString(prhs[4], buffer, strlen_);
evt->SetSubject(buffer);
mxFree(buffer);
}
}
else // Use the first name in the SUBJECTS:NAMES parameter.
{
btk::MetaData::ConstIterator subjects = acq->GetMetaData()->FindChild("SUBJECTS");
if (subjects != acq->GetMetaData()->End())
{
btk::MetaData::ConstIterator names = (*subjects)->FindChild("NAMES");
if (names != (*subjects)->End())
{
if ((*names)->GetInfo() != btk::MetaDataInfo::Null)
{
if ((*names)->GetInfo()->GetDimensionsProduct(1) != 0)
{
evt->SetSubject(btkTrimString((*names)->GetInfo()->ToString(0)));
}
}
}
}
}
// Description (optional)
if (nrhs >= 6)
{
if (!mxIsChar(prhs[5]))
mexErrMsgTxt("The description must be a string.");
else
{
size_t strlen_ = (mxGetM(prhs[5]) * mxGetN(prhs[5]) * sizeof(mxChar)) + 1;
char* buffer = (char*)mxMalloc(strlen_);
mxGetString(prhs[5], buffer, strlen_);
evt->SetDescription(buffer);
mxFree(buffer);
}
}
else // Use the description of the first event with the same label.
{
if (it != acq->EndEvent())
evt->SetDescription((*it)->GetDescription());
}
// ID (optional)
// If the function was called from btkEmulateC3Dserver, the ID was set to a fake
// value (-65536) used later to store correctly some events in the C3D header section
if (nrhs >= 7)
{
if ((mxGetClassID(prhs[6]) != mxDOUBLE_CLASS) || mxIsEmpty(prhs[6]) || mxIsComplex(prhs[6]) || (mxGetNumberOfElements(prhs[6]) != 1))
mexErrMsgTxt("The ID must be set by a single double representing an integer value.");
else
{
int id = static_cast<int>(mxGetScalar(prhs[6]));
if (id == -65536)
{
evt->SetDetectionFlags(0x10000);
id = 0;
}
evt->SetId(id);
}
}
else // Use the ID of the first event with the same label.
{
if (it != acq->EndEvent())
evt->SetId((*it)->GetId());
}
acq->AppendEvent(evt);
btkMXCreateEventsStructure(acq, nlhs, plhs);
};
/*
%COMP_IFILTERBANK_TD Synthesis filterbank
% Usage: f=comp_ifilterbank_fft(c,g,a,Ls,offset,ext);
%
% Input parameters:
% c : Cell array of length M, each element is N(m)*W matrix.
% g : Filterbank filters - length M cell-array, each element is vector of length filtLen(m)
% a : Upsampling factors - array of length M.
% offset : Delay of the filters - scalar or array of length M.
% Ls : Output length.
% ext : Border exension technique.
%
% Output parameters:
% f : Output Ls*W array.
%
*/
void LTFAT_NAME(ltfatMexFnc)( int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[] )
{
// printf("Filename: %s, Function name %s, %d \n.",__FILE__,__func__,mxIsDouble(prhs[0]));
const mxArray* mxc = prhs[0];
const mxArray* mxg = prhs[1];
double* a = mxGetPr(prhs[2]);
double* Lsdouble = mxGetPr(prhs[3]);
unsigned int Ls = (unsigned int) *Lsdouble;
double* offset = mxGetPr(prhs[4]);
char* ext = mxArrayToString(prhs[5]);
// number of channels
unsigned int W = mxGetN(mxGetCell(mxc,0));
// filter number
unsigned int M = mxGetNumberOfElements(mxg);
// input data length
unsigned int* Lc = mxMalloc(M*sizeof(unsigned int));
for(unsigned int m=0;m<M;m++)
{
Lc[m] = (unsigned int) mxGetM(mxGetCell(mxc,m));
}
// filter lengths
unsigned int* filtLen = mxMalloc(M*sizeof(unsigned int));
for(unsigned int m=0;m<M;m++)
{
filtLen[m] = (unsigned int) mxGetNumberOfElements(mxGetCell(mxg,m));
}
// POINTER TO THE INPUT
LTFAT_TYPE** cPtrs = (LTFAT_TYPE**) mxMalloc(M*sizeof(LTFAT_TYPE*));
for(unsigned int m=0;m<M;++m)
{
cPtrs[m] = (LTFAT_TYPE*) mxGetData(mxGetCell(mxc,m));
}
// allocate output
plhs[0] = ltfatCreateMatrix(Ls, W,LTFAT_MX_CLASSID,LTFAT_MX_COMPLEXITY);
// POINTER TO OUTPUT
LTFAT_TYPE* fPtr = (LTFAT_TYPE*) mxGetData(plhs[0]);
// Set to zeros
memset(fPtr,0,Ls*W*sizeof(LTFAT_TYPE));
// POINTER TO THE FILTERS
LTFAT_TYPE** gPtrs = (LTFAT_TYPE**) mxMalloc(M*sizeof(LTFAT_TYPE*));
for(unsigned int m=0;m<M;m++)
{
gPtrs[m] = (LTFAT_TYPE*) mxGetData(mxGetCell(mxg, m));
}
// over all channels
// #pragma omp parallel for private(m)
for(unsigned int m =0; m<M; m++)
{
for(unsigned int w =0; w<W; w++)
{
// Obtain pointer to w-th column in input
LTFAT_TYPE *fPtrCol = fPtr + w*Ls;
// Obtaing pointer to w-th column in m-th element of output cell-array
LTFAT_TYPE *cPtrCol = cPtrs[m] + w*Lc[m];
//(upconv_td)(const LTFAT_TYPE *in, int inLen, LTFAT_TYPE *out, const int outLen, const LTFAT_TYPE *filts, int fLen, int up, int skip, enum ltfatWavExtType ext)
LTFAT_NAME(upconv_td)(cPtrCol,Lc[m],fPtrCol,Ls,gPtrs[m],filtLen[m],a[m],-offset[m],ltfatExtStringToEnum(ext));
}
}
}
/* driver */
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum {IN_I=0, IN_ER} ;
enum {OUT_MEMBERS} ;
idx_t i ;
int k, nel, ndims ;
mwSize const * dims ;
val_t const * I_pt ;
int last = 0 ;
int last_expanded = 0 ;
val_t value = 0 ;
double const * er_pt ;
int* subs_pt ; /* N-dimensional subscript */
int* nsubs_pt ; /* diff-subscript to point to neigh. */
idx_t* strides_pt ; /* strides to move in image array */
val_t* visited_pt ; /* flag */
idx_t* members_pt ; /* region members */
bool invert = VL_FALSE ;
/** -----------------------------------------------------------------
** Check the arguments
** -------------------------------------------------------------- */
if (nin != 2) {
mexErrMsgTxt("Two arguments required.") ;
} else if (nout > 4) {
mexErrMsgTxt("Too many output arguments.");
}
if(mxGetClassID(in[IN_I]) != mxUINT8_CLASS) {
mexErrMsgTxt("I must be of class UINT8.") ;
}
if(!vlmxIsPlainScalar(in[IN_ER])) {
mexErrMsgTxt("ER must be a DOUBLE scalar.") ;
}
/* get dimensions */
nel = mxGetNumberOfElements(in[IN_I]) ;
ndims = mxGetNumberOfDimensions(in[IN_I]) ;
dims = mxGetDimensions(in[IN_I]) ;
I_pt = mxGetData(in[IN_I]) ;
/* allocate stuff */
subs_pt = mxMalloc( sizeof(int) * ndims ) ;
nsubs_pt = mxMalloc( sizeof(int) * ndims ) ;
strides_pt = mxMalloc( sizeof(idx_t) * ndims ) ;
visited_pt = mxMalloc( sizeof(val_t) * nel ) ;
members_pt = mxMalloc( sizeof(idx_t) * nel ) ;
er_pt = mxGetPr(in[IN_ER]) ;
/* compute strides to move into the N-dimensional image array */
strides_pt [0] = 1 ;
for(k = 1 ; k < ndims ; ++k) {
strides_pt [k] = strides_pt [k-1] * dims [k-1] ;
}
/* load first pixel */
memset(visited_pt, 0, sizeof(val_t) * nel) ;
{
idx_t idx = (idx_t) *er_pt ;
if (idx < 0) {
idx = -idx;
invert = VL_TRUE ;
}
if( idx < 1 || idx > nel ) {
char buff[80] ;
snprintf(buff,80,"ER=%d out of range [1,%d]",idx,nel) ;
mexErrMsgTxt(buff) ;
}
members_pt [last++] = idx - 1 ;
}
value = I_pt[ members_pt[0] ] ;
/* -----------------------------------------------------------------
* Fill region
* -------------------------------------------------------------- */
while(last_expanded < last) {
/* pop next node xi */
idx_t index = members_pt[last_expanded++] ;
/* convert index into a subscript sub; also initialize nsubs
to (-1,-1,...,-1) */
{
idx_t temp = index ;
for(k = ndims-1 ; k >=0 ; --k) {
nsubs_pt [k] = 0 ;
subs_pt [k] = temp / strides_pt [k] ;
temp = temp % strides_pt [k] ;
}
}
nsubs_pt[0] = -1;
/* process neighbors of xi */
int nk = 0;
while(VL_TRUE) {
int good = VL_TRUE ;
idx_t nindex = 0 ;
/* compute NSUBS+SUB, the correspoinding neighbor index NINDEX
and check that the pixel is within image boundaries. */
for(k = 0 ; k < ndims && good ; ++k) {
int temp = nsubs_pt [k] + subs_pt [k] ;
good &= 0 <= temp && temp < (signed) dims[k] ;
nindex += temp * strides_pt [k] ;
}
/* process neighbor
1 - the pixel is within image boundaries;
2 - the pixel is indeed different from the current node
(this happens when nsub=(0,0,...,0));
3 - the pixel has value not greather than val
is a pixel older than xi
4 - the pixel has not been visited yet
*/
if(good
&& nindex != index
&& ((!invert && I_pt [nindex] <= value) ||
( invert && I_pt [nindex] >= value))
&& ! visited_pt [nindex] ) {
/* mark as visited */
visited_pt [nindex] = 1 ;
/* add to list */
members_pt [last++] = nindex ;
}
/* move to next neighbor */
// k = 0 ;
// while(++ nsubs_pt [k] > 1) {
// nsubs_pt [k++] = -1 ;
// if(k == ndims) goto done_all_neighbors ;
// }
if (nsubs_pt[nk] == -1)
nsubs_pt[nk] += 2;
else{
nsubs_pt[nk] = 0;
nk++;
if(nk == ndims) goto done_all_neighbors ;
nsubs_pt[nk] = -1;
}
}
/* next neighbor */
done_all_neighbors : ;
} /* goto pop next member */
/*
* Save results
*/
{
mwSize dims[2] ;
int unsigned * pt ;
dims[0] = last ;
out[OUT_MEMBERS] = mxCreateNumericArray(1,dims,mxUINT32_CLASS,mxREAL);
pt = mxGetData(out[OUT_MEMBERS]) ;
for (i = 0 ; i < last ; ++i) {
*pt++ = members_pt[i] + 1 ;
}
}
/* free stuff */
mxFree( members_pt ) ;
mxFree( visited_pt ) ;
mxFree( strides_pt ) ;
mxFree( nsubs_pt ) ;
mxFree( subs_pt ) ;
}
void recurse_object(const mxArray* in, json& obj)
{
// Go over all types
if (mxIsCell(in)) {
int N = mxGetNumberOfElements(in);
for (int a = 0; a < N; ++a) {
obj.emplace_back();
recurse_object(mxGetCell(in, a), obj.back());
}
} else if (mxIsStruct(in)) {
int M = mxGetNumberOfFields(in);
std::vector<const char*> fnames(M);
for (int b = 0; b < M; ++b)
fnames[b] = mxGetFieldNameByNumber(in, b);
int N = mxGetNumberOfElements(in);
for (int a = 0; a < N; ++a) {
json obj_;
for (int b = 0; b < M; ++b)
recurse_object(mxGetFieldByNumber(in, a, b), obj_[fnames[b]]);
if (N == 1)
obj = std::move(obj_);
else
obj.push_back(std::move(obj_));
}
} else if (mxIsChar(in)) {
obj = json::parse(mxArrayToString(in));
} else if (mxIsLogical(in)) {
int N = mxGetNumberOfElements(in);
const mxLogical* data = (const mxLogical*)mxGetData(in);
if (N == 1) {
obj = data[0] != 0;
} else {
for (int a = 0; a < N; ++a)
obj.push_back(data[a] != 0);
}
} else if (mxIsNumeric(in)) {
int N = mxGetNumberOfElements(in);
const void* data = (const void*)mxGetData(in);
switch (mxGetClassID(in)) {
case mxDOUBLE_CLASS:
if (N == 1) { obj = ((const double*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const double*)data)[a]); }
break;
case mxSINGLE_CLASS:
if (N == 1) { obj = ((const float*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const float*)data)[a]); }
break;
case mxUINT8_CLASS:
if (N == 1) { obj = ((const uint8_t*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const uint8_t*)data)[a]); }
break;
case mxINT8_CLASS:
if (N == 1) { obj = ((const int8_t*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const int8_t*)data)[a]); }
break;
case mxUINT16_CLASS:
if (N == 1) { obj = ((const uint16_t*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const uint16_t*)data)[a]); }
break;
case mxINT16_CLASS:
if (N == 1) { obj = ((const int16_t*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const int16_t*)data)[a]); }
break;
case mxUINT32_CLASS:
if (N == 1) { obj = ((const uint32_t*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const uint32_t*)data)[a]); }
break;
case mxINT32_CLASS:
if (N == 1) { obj = ((const int32_t*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const int32_t*)data)[a]); }
break;
case mxUINT64_CLASS:
if (N == 1) { obj = ((const uint64_t*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const uint64_t*)data)[a]); }
break;
case mxINT64_CLASS:
if (N == 1) { obj = ((const int64_t*)data)[0]; } else {
for (int a = 0; a < N; ++a) obj.push_back(((const int64_t*)data)[a]); }
break;
default:
mexErrMsgTxt("Unsupported type.");
break;
}
} else {
mexErrMsgTxt("Unrecognized type.");
}
}
void buffer_getdat(char *hostname, int port, mxArray *plhs[], const mxArray *prhs[])
{
int server;
int verbose = 0;
size_t n;
double *val;
char msg[512];
message_t *request = NULL;
message_t *response = NULL;
header_t *header = NULL;
data_t *data = NULL;
datasel_t datasel;
/* this is for the Matlab specific output */
const char *field_names[NUMBER_OF_FIELDS] = {"nchans", "nsamples", "data_type", "bufsize", "buf"};
mxArray *datp;
/* allocate the elements that will be used in the communication */
request = malloc(sizeof(message_t));
request->def = malloc(sizeof(messagedef_t));
request->buf = NULL;
request->def->version = VERSION;
request->def->command = GET_DAT;
request->def->bufsize = 0;
if ((prhs[0]!=NULL) && (mxGetNumberOfElements(prhs[0])==2) && (mxIsDouble(prhs[0])) && (!mxIsComplex(prhs[0]))) {
/* fprintf(stderr, "args OK\n"); */
val = (double *)mxGetData(prhs[0]);
datasel.begsample = (UINT32_T)(val[0]);
datasel.endsample = (UINT32_T)(val[1]);
if (verbose) print_datasel(&datasel);
request->def->bufsize = append(&request->buf, request->def->bufsize, &datasel, sizeof(datasel_t));
}
/* open the TCP socket */
if ((server = open_connection(hostname, port)) < 0) {
sprintf(msg, "ERROR: failed to create socket (%d)\n", server);
mexErrMsgTxt(msg);
}
if (verbose) print_request(request->def);
clientrequest(server, request, &response);
if (verbose) print_response(response->def);
close_connection(server);
if (response->def->command==GET_OK) {
data = malloc(sizeof(data_t));
data->def = response->buf;
data->buf = (char *)response->buf + sizeof(datadef_t);
if (verbose) print_datadef(data->def);
switch (data->def->data_type) {
case DATATYPE_INT8:
datp = mxCreateNumericMatrix(data->def->nchans, data->def->nsamples, mxINT8_CLASS, mxREAL);
memcpy(mxGetPr(datp), data->buf, data->def->nchans*data->def->nsamples*WORDSIZE_INT8);
break;
case DATATYPE_INT16:
datp = mxCreateNumericMatrix(data->def->nchans, data->def->nsamples, mxINT16_CLASS, mxREAL);
memcpy(mxGetPr(datp), data->buf, data->def->nchans*data->def->nsamples*WORDSIZE_INT16);
break;
case DATATYPE_INT32:
datp = mxCreateNumericMatrix(data->def->nchans, data->def->nsamples, mxINT32_CLASS, mxREAL);
memcpy(mxGetPr(datp), data->buf, data->def->nchans*data->def->nsamples*WORDSIZE_INT32);
break;
case DATATYPE_INT64:
datp = mxCreateNumericMatrix(data->def->nchans, data->def->nsamples, mxINT64_CLASS, mxREAL);
memcpy(mxGetPr(datp), data->buf, data->def->nchans*data->def->nsamples*WORDSIZE_INT64);
break;
case DATATYPE_FLOAT32:
datp = mxCreateNumericMatrix(data->def->nchans, data->def->nsamples, mxSINGLE_CLASS, mxREAL);
memcpy(mxGetPr(datp), data->buf, data->def->nchans*data->def->nsamples*WORDSIZE_FLOAT32);
break;
case DATATYPE_FLOAT64:
datp = mxCreateNumericMatrix(data->def->nchans, data->def->nsamples, mxDOUBLE_CLASS, mxREAL);
memcpy(mxGetPr(datp), data->buf, data->def->nchans*data->def->nsamples*WORDSIZE_FLOAT64);
break;
default:
mexErrMsgTxt("ERROR; unsupported data type\n");
}
plhs[0] = mxCreateStructMatrix(1, 1, NUMBER_OF_FIELDS, field_names);
mxSetFieldByNumber(plhs[0], 0, 0, mxCreateDoubleScalar((double)data->def->nchans));
mxSetFieldByNumber(plhs[0], 0, 1, mxCreateDoubleScalar((double)(data->def->nsamples)));
mxSetFieldByNumber(plhs[0], 0, 2, mxCreateDoubleScalar((double)(data->def->data_type)));
mxSetFieldByNumber(plhs[0], 0, 3, mxCreateDoubleScalar((double)(data->def->bufsize)));
mxSetFieldByNumber(plhs[0], 0, 4, datp);
FREE(data);
}
else {
sprintf(msg, "ERROR: the buffer returned an error (%d)\n", response->def->command);
mexErrMsgTxt(msg);
}
if (request) {
FREE(request->def);
FREE(request->buf);
FREE(request);
}
if (response) {
FREE(response->def);
FREE(response->buf);
FREE(response);
}
return;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/*declare variables*/
const mwSize *dims;
mwIndex indx;
int i, numdims;
int numelin;
mxClassID classid;
double *input1r, *input1i, *input2r, *input2i, *output1r, *output1i;
double a, b, c, d, e, f, g, h, absa, absb, absc, absd, offr, offi;
double ai, bi, ci, di, ei, fi, gi, hi;
/*figure out the classid*/
classid = mxGetClassID(prhs[0]);
/*check inputs*/
if (nrhs!=2)
mexErrMsgTxt("Wrong number of input arguments");
/*associate inputs*/
input1r = mxGetData(prhs[0]);
input1i = mxGetImagData(prhs[0]);
input2r = mxGetData(prhs[1]);
input2i = mxGetImagData(prhs[1]);
/*figure out dimension info and number of elements*/
dims = mxGetDimensions(prhs[0]);
numdims = mxGetNumberOfDimensions(prhs[0]);
numelin = mxGetNumberOfElements(prhs[0]);
/*associate output*/
if (input1i == NULL && input2i == NULL)
{
plhs[0] = mxCreateNumericArray(numdims, dims, classid, mxREAL);
output1r = mxGetData(plhs[0]);
}
else
{
plhs[0] = mxCreateNumericArray(numdims, dims, classid, mxCOMPLEX);
output1r = mxGetData(plhs[0]);
output1i = mxGetImagData(plhs[0]);
}
/* do the computation*/
if (input1i == NULL && input2i == NULL)
{
for (i=0; i<numelin/4; i++)
{
a = input1r[i*4 ];
b = input1r[i*4+1];
c = input1r[i*4+2];
d = input1r[i*4+3];
e = input2r[i*4 ];
f = input2r[i*4+1];
g = input2r[i*4+2];
h = input2r[i*4+3];
output1r[i*4 ] = e*a*a + 2*f*a*c + h*c*c;
output1r[i*4+1] = e*a*b + f*a*d + f*b*c + h*c*d;
output1r[i*4+2] = e*a*b + f*b*c + f*a*d + h*c*d;
output1r[i*4+3] = e*b*b + 2*f*b*d + h*d*d;
}
return;
}
else if (input1i == NULL)
{
for (i=0; i<numelin/4; i++)
{
/*matrix 1*/
a = input1r[i*4 ]; b = input1r[i*4+1]; c = input1r[i*4+2]; d = input1r[i*4+3];
/*matrix 2*/
e = input2r[i*4 ]; f = input2r[i*4+1]; g = input2r[i*4+2]; h = input2r[i*4+3];
ei = input2i[i*4 ]; fi = input2i[i*4+1]; gi = input2i[i*4+2]; hi = input2i[i*4+3];
/*compute some quantities only once*/
absa = a*a;
absb = b*b;
absc = c*c;
absd = (d*d+di*di);
offr = e*a*b + f*a*d + f*b*c + h*c*d;
offi = -ei*a*b - fi*a*d + fi*b*c - hi*c*d;
/*fill in the real part of the output matrix*/
output1r[i*4 ] = e*absa + 2*f*a*c + h*absc;
output1r[i*4+1] = offr;
output1r[i*4+2] = offr;
output1r[i*4+3] = e*absb + 2*f*b*d + h*absd;
/*fill in the imaginary part of the output matrix*/
output1i[i*4 ] = ei*absa + hi*absc;
output1i[i*4+1] = -offi;
output1i[i*4+2] = offi;
output1i[i*4+3] = ei*absb + hi*absd;
}
}
/*else if (input2i == NULL)*/
else
{
for (i=0; i<numelin/4; i++)
{
/*matrix 1*/
a = input1r[i*4 ]; b = input1r[i*4+1]; c = input1r[i*4+2]; d = input1r[i*4+3];
ai = input1i[i*4 ]; bi = input1i[i*4+1]; ci = input1i[i*4+2]; di = input1i[i*4+3];
/*matrix 2*/
e = input2r[i*4 ]; f = input2r[i*4+1]; g = input2r[i*4+2]; h = input2r[i*4+3];
ei = input2i[i*4 ]; fi = input2i[i*4+1]; gi = input2i[i*4+2]; hi = input2i[i*4+3];
/*compute some quantities only once*/
absa = (a*a+ai*ai);
absb = (b*b+bi*bi);
absc = (c*c+ci*ci);
absd = (d*d+di*di);
offr = (e*a*b+e*ai*bi-ei*a*bi+ei*ai*b) + (f*a*d+f*ai*di-fi*a*di+fi*ai*d) + (f*b*c+f*bi*ci-fi*b*ci+fi*bi*c) + (h*c*d+h*ci*di-hi*c*di+hi*ci*d);
offi = (-ei*ai*bi-e*a*bi+e*ai*b-ei*a*b) + (-fi*ai*di-f*a*di+f*ai*d-fi*a*d) + (fi*bi*ci+f*b*ci-f*bi*c+fi*b*c) + (-hi*ci*di-h*c*di+h*ci*d-hi*c*d);
/*fill in the real part of the output matrix*/
output1r[i*4 ] = e*absa + 2*(f*a*c+f*ai*ci-fi*a*ci+fi*ai*c) + h*absc;
output1r[i*4+1] = offr;
output1r[i*4+2] = offr;
output1r[i*4+3] = e*absb + 2*(f*b*d+f*bi*di-fi*b*di+fi*bi*d) + h*absd;
/*fill in the imaginary part of the output matrix*/
output1i[i*4 ] = ei*absa + hi*absc;
output1i[i*4+1] = -offi;
output1i[i*4+2] = offi;
output1i[i*4+3] = ei*absb + hi*absd;
}
return;
}
}
static void mdlStart(SimStruct *S)
{
PCONFIG_DATA config;
int_T nports_in = 1;
int_T nports_out = 2;
int_T nq;
/* Store new C object in the pointers vector */
config = (PCONFIG_DATA) calloc(1, sizeof(CONFIG_DATA));
ssGetPWork(S)[0] = config;
/* Store the number of ports and their indices */
config->idxin_xdot = 0;
if( intval(mxGetScalar(paramInitialConditionSource)) > 1 )
{
config->idxin_x0 = nports_in++;
}
else
{
config->idxin_x0 = 0;
}
if( intval(mxGetScalar(paramSpecificationsSource)) == 3 )
{
config->idxin_params = nports_in++;
}
else
{
config->idxin_params = 0;
}
if( intval(mxGetScalar(paramExternalReset)) > 1 )
{
config->idxin_reset = nports_in++;
}
else
{
config->idxin_reset = 0;
}
config->idxout_x = 1;
if( intval(mxGetScalar(paramOutputTime)) > 0 )
{
config->idxout_time = nports_out++;
}
else
{
config->idxout_time = 0;
}
/* Store the number of quaternions */
if( mxGetNumberOfElements(paramQuaternionIndex) == 2 )
{
config->start_idx_q = intval(mxGetPr(paramQuaternionIndex)[0]) - 1;
config->end_idx_q = intval(mxGetPr(paramQuaternionIndex)[1]) - 1;
nq = 1 + config->end_idx_q - config->start_idx_q;
nq = nq / 4;
config->nq = nq;
if( mxGetNumberOfElements(paramOmegaDotIndex) == 2 )
{
config->start_idx_omegadot = intval(mxGetPr(paramOmegaDotIndex)[0]) - 1;
config->end_idx_omegadot = intval(mxGetPr(paramOmegaDotIndex)[1]) - 1;
config->use_omegadot = 1;
}
}
config->initial_time = ssGetTStart(S);
config->nstates = ssGetInputPortWidth(S, 0);
}