void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/* DECLARATIONS: */
double *concc,*conrr,*medianx,*mediany,*medianf; /*, numelboolmatrix*/
mwSize j,num;
/*Read input*/
concc = mxGetPr(prhs[0]);
conrr = mxGetPr(prhs[1]);
medianx = mxGetPr(prhs[2]);
mediany = mxGetPr(prhs[3]);
medianf = mxGetPr(prhs[4]);
num = mxGetNumberOfElements(prhs[1]);
/* Initialize output */
plhs[0] = mxCreateDoubleMatrix(num,1, mxREAL);
double* v = mxGetPr(plhs[0]);
for( j=0 ; j<num ; j++ )
{
v[j] = sqrt(pow(medianx[mwSize(concc[j]-1)]-medianx[mwSize(conrr[j]-1)],2)+ pow(mediany[mwSize(concc[j]-1)]-mediany[mwSize(conrr[j]-1)],2)+pow(medianf[mwSize(concc[j]-1)]-medianf[mwSize(conrr[j]-1)],2));
}
}
void Pool_VisualMark(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[], mxClassID classID)
{
mwSize DATA_DIMS[4];
mwSize M_DIMS[4];
if (mxGetClassID(mxGetField(prhs[0],0,"size")) != classID)
mexErrMsgTxt("size must be the same real, single/double type");
if (mxGetClassID(mxGetField(prhs[0],0,"stride")) != classID)
mexErrMsgTxt("stride must be the same real, single/double type");
if (mxGetClassID(mxGetField(prhs[0],0,"MapSize")) != classID)
mexErrMsgTxt("MapSize must be the same real, single/double type");
T *size = (T *)mxGetData(mxGetField(prhs[0],0,"size"));
T *stride = (T *)mxGetData(mxGetField(prhs[0],0,"stride"));
T *MapSize = (T *)mxGetData(mxGetField(prhs[0],0,"MapSize"));
const mxArray *ptr_data = prhs[1];
T *data_point = (T *)mxGetData(prhs[1]);
const mwSize *tmp = mxGetDimensions(ptr_data);
DATA_DIMS[0] = tmp[0];
DATA_DIMS[1] = tmp[1];
if (mxGetNumberOfDimensions(ptr_data) == 2) {
DATA_DIMS[2] = 1;
DATA_DIMS[3] = 1;
} else if (mxGetNumberOfDimensions(ptr_data) == 3) {
DATA_DIMS[2] = tmp[2];
DATA_DIMS[3] = 1;
} else {
DATA_DIMS[2] = tmp[2];
DATA_DIMS[3] = tmp[3];
}
mwSize MARK_DIMS[6];
const mxArray *ptr_Mark = prhs[2];
T *mark_point = (T *)mxGetData(prhs[2]);
const mwSize *tmp_1 = mxGetDimensions(ptr_Mark);
MARK_DIMS[0] = tmp_1[0];
MARK_DIMS[1] = tmp_1[1];
if (mxGetNumberOfDimensions(ptr_Mark) == 2) {
MARK_DIMS[2] = 1;
MARK_DIMS[3] = 1;
MARK_DIMS[4] = 1;
MARK_DIMS[5] = 1;
} else if (mxGetNumberOfDimensions(ptr_Mark) == 3) {
MARK_DIMS[2] = tmp_1[2];
MARK_DIMS[3] = 1;
MARK_DIMS[4] = 1;
MARK_DIMS[5] = 1;
} else if (mxGetNumberOfDimensions(ptr_Mark) == 4) {
MARK_DIMS[2] = tmp_1[2];
MARK_DIMS[3] = tmp_1[3];
MARK_DIMS[4] = 1;
MARK_DIMS[5] = 1;
} else if (mxGetNumberOfDimensions(ptr_Mark) == 5) {
MARK_DIMS[2] = tmp_1[2];
MARK_DIMS[3] = tmp_1[3];
MARK_DIMS[4] = tmp_1[4];
MARK_DIMS[5] = 1;
} else {
MARK_DIMS[2] = tmp_1[2];
MARK_DIMS[3] = tmp_1[3];
MARK_DIMS[4] = tmp_1[4];
MARK_DIMS[5] = tmp_1[5];
}
M_DIMS[0] = mwSize(int(MapSize[0]));
M_DIMS[1] = mwSize(int(MapSize[1]));
M_DIMS[2] = mwSize(int(MapSize[2]));
M_DIMS[3] = DATA_DIMS[3];
mwSize data_sample_size = DATA_DIMS[0] * DATA_DIMS[1] * DATA_DIMS[2];
mwSize data_channel_size = DATA_DIMS[0] * DATA_DIMS[1];
mwSize mark_sample_size = MARK_DIMS[4] * MARK_DIMS[3] * MARK_DIMS[2] * MARK_DIMS[1] * MARK_DIMS[0];
mwSize mark_channel_size = MARK_DIMS[3] * MARK_DIMS[2] * MARK_DIMS[1] * MARK_DIMS[0];
mwSize mark_col_size = MARK_DIMS[2] * MARK_DIMS[1] * MARK_DIMS[0];
mwSize mark_row_size = MARK_DIMS[1] * MARK_DIMS[0];
mwSize output_sample_size = M_DIMS[0] * M_DIMS[1] * M_DIMS[2];
mwSize output_channel_size = M_DIMS[0] * M_DIMS[1];
plhs[0] = mxCreateNumericArray(4,M_DIMS,classID,mxREAL);
mxArray *OutputData = plhs[0];
T *Output_point = (T *)mxGetData(OutputData);
for(mwSize i = 0;i < M_DIMS[3];i ++){
#ifdef OPENMP
#pragma omp parallel for
#endif
for(mwSize j = 0;j < M_DIMS[2];j ++){
for(mwSize k = 0;k < M_DIMS[1];k ++){
for(mwSize l = 0;l < M_DIMS[0];l ++){
Output_point[i * output_sample_size + j * output_channel_size + k * M_DIMS[0] + l] = data_point[int(
i * data_sample_size + j * data_channel_size + (k * stride[1] + mark_point[i * mark_sample_size + \
j * mark_channel_size + k * mark_col_size + l * mark_row_size + 1]) * DATA_DIMS[0] + (l * stride[0] + \
mark_point[i * mark_sample_size + j * mark_channel_size + k * mark_col_size + l * mark_row_size]))];
}
}
}
}
}
extern bool aperture_bft_set(mxArray *plhs[], const mxArray* mx_handle,
const mxArray* mx_data, const size_t type) {
const int n_odim = 1;
const float_type* data_vec;
const bool* p_b = NULL;
mwSize o_dims[n_odim];
// mwSize n_elements, length;
size_t n_elements, length;
Aperture* p_aperture = NULL;
bool* p_blhs = NULL;
char stype[256];
Call(mxIsPointer, (mx_handle));
if (type < 7)
Call(mxIsRealFloat, (mx_data));
p_aperture = &(get_object<Aperture>(mx_handle));
o_dims[0] = mwSize(1);
Call(plhs[0] = mxCreateLogicalArray,
(n_odim, (const mwSize*)o_dims));
n_elements = (mwSize) mxGetM(mx_data);
data_vec = ((const float_type *) mxGetData(mx_data));
switch (type) {
case 0:
// Positions
Call1(mxCheckDimensions, (mx_data, 2, n_elements, 3),
"Positions must be 3D array");
length = (size_t)3*n_elements;
Call1(p_aperture->setPositions, (data_vec, length), "Incompatible size");
p_aperture->data->m_type = Aperture::custom;
break;
case 1:
// Focus
if ((mxGetM(mx_data)==0) && (mxGetN(mx_data)==0)) {
data_vec = NULL;
}
else {
Call1(mxCheckDimensions, (mx_data, 2, 1, 3), "Positions must be 3D");
}
p_aperture->setFocus(data_vec);
break;
case 2:
// Center focus
Call1(mxCheckDimensions, (mx_data, 2, n_elements, 3),
"Positions must be 3D");
p_aperture->setCenterFocus(data_vec, n_elements);
break;
case 3:
// fs
Call1(mxIsScalarFloat, (mx_data), "fs must be scalar float");
Aperture::_fs = *((const float_type*) mxGetData(mx_data));
break;
case 6:
// c
Call1(mxIsScalarFloat, (mx_data), "c must be scalar float");
Aperture::_c = *((const float_type*) mxGetData(mx_data));
break;
case 4:
// f0
Call1(mxIsScalarFloat, (mx_data), "f0 must be scalar float");
Aperture::_f0 = *((const float_type*) mxGetData(mx_data));
case 5:
// Delays
if ((mxGetM(mx_data)==0) && (mxGetN(mx_data)==0)) {
data_vec = NULL;
}
else {
Call1(mxCheckDimensions, (mx_data, 2, p_aperture->n_elements(), 1),
"Receive delays must match number of elements");
}
p_aperture->setDelays(data_vec);
break;
case 7:
// Aperture type
Call(mxIsChar, (mx_data));
Call(mxu_fixed_string, (stype, 256, mx_data, "1st argument"));
if (!strcmp(stype,"custom"))
p_aperture->data->m_type = Aperture::custom;
else if (!strcmp(stype,"linear_array"))
p_aperture->data->m_type = Aperture::linear_array;
else if (!strcmp(stype,"convex_array"))
p_aperture->data->m_type = Aperture::convex_array;
else {
Fail("Unknown type");
}
break;
case 8:
// PP-wave on/off
Call(mxIsLogical, (mx_data));
p_b = ((const bool*) mxGetData(mx_data));
p_aperture->data->m_ppwave = *p_b;
break;
case 9:
// Orientation
Call1(mxCheckDimensions, (mx_data, 2, n_elements, 3),
"Orientations must be 3D Euler angles");
p_aperture->setOrientation(data_vec, n_elements);
break;
default:
break;
}
p_blhs = ((bool*) mxGetData(plhs[0]));
*p_blhs = true;
return true;
}
extern bool aperture_bft_get(mxArray *plhs[], const mxArray* mx_handle,
const size_t type) {
const size_t n_odim = 2;
mwSize o_dims[n_odim];
bool retval = true;
size_t i;
Aperture* p_aperture;
Aperture* p_aperture_clone;
float_type* p_flhs = NULL;
bool* p_blhs = NULL;
size_t* p_ilhs = NULL;
int aperturetype = 0;
Call(mxIsPointer, (mx_handle));
p_aperture = &(get_object<Aperture>(mx_handle));
switch (type) {
case 0:
// Positions
o_dims[0] = mwSize(p_aperture->n_elements());
o_dims[1] = mwSize(3);
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxFLOAT_CLASS, mxREAL));
p_flhs = ((float_type*) mxGetData(plhs[0]));
for (i=0 ; i < 3*p_aperture->n_elements() ; i++ ) {
p_flhs[i] = p_aperture->data->m_pos->m_data[0][i];
}
break;
case 1:
// Focus point (VS)
o_dims[0] = mwSize(0);
o_dims[1] = mwSize(0);
if (p_aperture->data->m_focus) {
o_dims[0] = mwSize(1);
o_dims[1] = mwSize(3);
}
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxFLOAT_CLASS, mxREAL));
p_flhs = ((float_type*) mxGetData(plhs[0]));
for (i=0 ; i < 3 ; i++ ) {
if (p_aperture->data->m_focus)
p_flhs[i] = p_aperture->data->m_focus[i];
}
break;
case 2:
// Center focus
o_dims[0] = mwSize(p_aperture->data->m_nemissions);
o_dims[1] = mwSize(3);
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxFLOAT_CLASS, mxREAL));
p_flhs = ((float_type*) mxGetData(plhs[0]));
for (i=0 ; i < 3*p_aperture->data->m_nemissions ; i++ ) {
p_flhs[i] = p_aperture->data->m_center_focus[i];
}
break;
case 3:
// fs
o_dims[0] = mwSize(1);
o_dims[1] = mwSize(1);
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxFLOAT_CLASS, mxREAL));
p_flhs = ((float_type*) mxGetData(plhs[0]));
p_flhs[0] = Aperture::_fs;
break;
case 4:
// f0
o_dims[0] = mwSize(1);
o_dims[1] = mwSize(1);
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxFLOAT_CLASS, mxREAL));
p_flhs = ((float_type*) mxGetData(plhs[0]));
p_flhs[0] = Aperture::_f0;
break;
case 7:
// c
o_dims[0] = mwSize(1);
o_dims[1] = mwSize(1);
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxFLOAT_CLASS, mxREAL));
p_flhs = ((float_type*) mxGetData(plhs[0]));
p_flhs[0] = Aperture::_c;
break;
case 5:
// Receive delays
if (p_aperture->data->m_delays) {
o_dims[0] = mwSize(p_aperture->n_elements());
o_dims[1] = mwSize(1);
}
else {
o_dims[0] = mwSize(0);
o_dims[1] = mwSize(0);
}
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxFLOAT_CLASS, mxREAL));
p_flhs = ((float_type*) mxGetData(plhs[0]));
if (p_aperture->data->m_delays)
for (i=0 ; i < p_aperture->n_elements() ; i++ )
p_flhs[i] = p_aperture->data->m_delays[i];
break;
case 6:
// Id
o_dims[0] = mwSize(1);
o_dims[1] = mwSize(1);
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxPOINTER_CLASS, mxREAL));
// Use ptr_t
p_ilhs = ((size_t*) mxGetData(plhs[0]));
p_ilhs[0] = p_aperture->data->m_id;
break;
case 8:
// Clone
p_aperture_clone = p_aperture->Clone();
plhs[0] = create_handle<Aperture>(p_aperture_clone);
enable_aperture_destructor = true;
mexLock();
break;
case 9:
// Version
Call(plhs[0] = mxCreateString, (PACKAGE_VERSION));
break;
case 10:
// Aperture type
aperturetype = p_aperture->data->m_type;
switch (aperturetype) {
case Aperture::custom:
Call(plhs[0] = mxCreateString, ("custom"));
break;
case Aperture::linear_array:
Call(plhs[0] = mxCreateString, ("linear_array"));
break;
case Aperture::convex_array:
Call(plhs[0] = mxCreateString, ("convex_array"));
break;
default:
Call(plhs[0] = mxCreateString, ("unknown"));
};
break;
case 11:
/// Focus delays
o_dims[0] = mwSize(p_aperture->n_elements());
o_dims[1] = mwSize(1);
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxFLOAT_CLASS, mxREAL));
p_flhs = ((float_type*) mxGetData(plhs[0]));
retval = p_aperture->getFocusDelays(p_flhs);
if (!retval) {
retval = true;
// Return zero values
/*
Fail("No focus delays available for un-focused array");
*/
}
break;
case 12:
// PP-wave on/off
o_dims[0] = mwSize(1);
o_dims[1] = mwSize(1);
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxLOGICAL_CLASS, mxREAL));
p_blhs = ((bool*) mxGetData(plhs[0]));
p_blhs[0] = p_aperture->data->m_ppwave;
break;
case 13:
// Orientation
// Center focus
o_dims[0] = mwSize(p_aperture->data->m_nemissions);
o_dims[1] = mwSize(3);
Call(plhs[0] = mxCreateNumericArray,
(n_odim, (const mwSize*)o_dims, mxFLOAT_CLASS, mxREAL));
p_flhs = ((float_type*) mxGetData(plhs[0]));
for (i=0 ; i < 3*p_aperture->data->m_nemissions ; i++ ) {
p_flhs[i] = p_aperture->data->m_euler[i];
}
break;
}
return retval;
}
void DePool(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[], mxClassID classID)
{
if (mxGetClassID(mxGetField(prhs[0],0,"size")) != classID)
mexErrMsgTxt("size must be the same real, single/double type");
if (mxGetClassID(mxGetField(prhs[0],0,"stride")) != classID)
mexErrMsgTxt("stride must be the same real, single/double type");
if (mxGetClassID(mxGetField(prhs[0],0,"MapSize")) != classID)
mexErrMsgTxt("MapSize must be the same real, single/double type");
T *size = (T *)mxGetData(mxGetField(prhs[0],0,"size"));
T *stride = (T *)mxGetData(mxGetField(prhs[0],0,"stride"));
T *MapSize = (T *)mxGetData(mxGetField(prhs[0],0,"MapSize"));
std::string type = mxArrayToString(mxGetField(prhs[0],0,"type"));
mwSize SENSI_DIMS[4];
const mxArray *ptr_sensitivity = prhs[1];
T *sensitivity_point = (T *)mxGetData(ptr_sensitivity);
const mwSize *tmp = mxGetDimensions(ptr_sensitivity);
SENSI_DIMS[0] = tmp[0];
SENSI_DIMS[1] = tmp[1];
if (mxGetNumberOfDimensions(ptr_sensitivity) == 2) {
SENSI_DIMS[2] = 1;
SENSI_DIMS[3] = 1;
} else if (mxGetNumberOfDimensions(ptr_sensitivity) == 3) {
SENSI_DIMS[2] = tmp[2];
SENSI_DIMS[3] = 1;
} else {
SENSI_DIMS[2] = tmp[2];
SENSI_DIMS[3] = tmp[3];
}
mwSize sensi_sample_size = SENSI_DIMS[0] * SENSI_DIMS[1] * SENSI_DIMS[2];
mwSize sensi_channel_size = SENSI_DIMS[0] * SENSI_DIMS[1];
mwSize OUPUT_DIMS[4];
OUPUT_DIMS[0] = stride[0] * (MapSize[0] - 1) + size[0];
OUPUT_DIMS[1] = stride[1] * (MapSize[1] - 1) + size[1];
OUPUT_DIMS[2] = SENSI_DIMS[2];
OUPUT_DIMS[3] = SENSI_DIMS[3];
plhs[0] = mxCreateNumericArray(4,OUPUT_DIMS,classID,mxREAL);
mxArray *OutputData = plhs[0];
T *Output_point = (T *)mxGetData(OutputData);
mwSize output_sample_size = OUPUT_DIMS[0] * OUPUT_DIMS[1] * OUPUT_DIMS[2];
mwSize output_channel_size = OUPUT_DIMS[0] * OUPUT_DIMS[1];
if(type.compare("max") == 0){
mwSize MARK_DIMS[6];
const mxArray *ptr_mark = prhs[2];
T *mark_point = (T *)mxGetData(ptr_mark);
const mwSize *tmp_1 = mxGetDimensions(ptr_mark);
MARK_DIMS[0] = tmp_1[0];
MARK_DIMS[1] = tmp_1[1];
MARK_DIMS[2] = tmp_1[2];
MARK_DIMS[3] = tmp_1[3];
if (mxGetNumberOfDimensions(ptr_mark) == 4) {
MARK_DIMS[4] = 1;
MARK_DIMS[5] = 1;
} else if (mxGetNumberOfDimensions(ptr_mark) == 5) {
MARK_DIMS[4] = tmp_1[4];
MARK_DIMS[5] = 1;
} else {
MARK_DIMS[4] = tmp_1[4];
MARK_DIMS[5] = tmp_1[5];
}
mwSize mark_sample_size = MARK_DIMS[4] * MARK_DIMS[3] * MARK_DIMS[2] * MARK_DIMS[1] * MARK_DIMS[0];
mwSize mark_channel_size = MARK_DIMS[3] * MARK_DIMS[2] * MARK_DIMS[1] * MARK_DIMS[0];
mwSize mark_col_size = MARK_DIMS[2] * MARK_DIMS[1] * MARK_DIMS[0];
mwSize mark_row_size = MARK_DIMS[1] * MARK_DIMS[0];
for(mwSize i = 0;i < SENSI_DIMS[3];i ++){
#ifdef OPENMP
#pragma omp parallel for
#endif
for(mwSize j = 0;j < SENSI_DIMS[2];j ++){
for(mwSize k = 0;k < SENSI_DIMS[1];k ++){
for(mwSize l = 0;l < SENSI_DIMS[0];l ++){
Output_point[i * output_sample_size + j * output_channel_size + mwSize(mark_point[i * mark_sample_size + j * mark_channel_size + \
k * mark_col_size + l * mark_row_size + 1] + k * stride[1]) * OUPUT_DIMS[0] + mwSize(mark_point[i * mark_sample_size + j * mark_channel_size + \
k * mark_col_size + l * mark_row_size] + l * stride[0])] = \
Output_point[i * output_sample_size + j * output_channel_size + mwSize(mark_point[i * mark_sample_size + j * mark_channel_size + \
k * mark_col_size + l * mark_row_size + 1] + k * stride[1]) * OUPUT_DIMS[0] + mwSize(mark_point[i * mark_sample_size + j * mark_channel_size + \
k * mark_col_size + l * mark_row_size] + l * stride[0])] + sensitivity_point[i * sensi_sample_size + j * sensi_channel_size + \
k * SENSI_DIMS[0] + l];
}
}
}
}
}
else if(type.compare("average") == 0){
for(mwSize i = 0;i < SENSI_DIMS[3];i ++){
#ifdef OPENMP
#pragma omp parallel for
#endif
for(mwSize j = 0;j < SENSI_DIMS[2];j ++){
for(mwSize k = 0;k < SENSI_DIMS[1];k ++){
for(mwSize l = 0;l < SENSI_DIMS[0];l ++){
for(mwSize m = k * stride[1];m < std::min(int(k * stride[1] + size[1]),int(OUPUT_DIMS[1]));m ++){
for(mwSize n = l * stride[0];n < std::min(int(l * stride[0] + size[0]),int(OUPUT_DIMS[0]));n ++){
Output_point[i * output_sample_size + j * output_channel_size + m * OUPUT_DIMS[0] + n] = \
Output_point[i * output_sample_size + j * output_channel_size + m * OUPUT_DIMS[0] + n] + \
sensitivity_point[i * sensi_sample_size + j * sensi_channel_size + k * SENSI_DIMS[0] + l] / (size[0] * size[1]);
}
}
}
}
}
}
}
else if(type.compare("abs_max") == 0)
{
mexErrMsgTxt("the pooling operation ""abs_max"" is not implemented yet!");
}
}
static mxArray* matlab_create_value(gld_property *prop)
{
mxArray *value=NULL;
switch ( prop->get_type() ) {
case PT_double:
case PT_random:
case PT_enduse:
case PT_loadshape:
value = mxCreateDoubleScalar(*(double*)prop->get_addr());
break;
case PT_complex:
{
value = mxCreateDoubleMatrix(1,1,mxCOMPLEX);
complex *v = (complex*)prop->get_addr();
*mxGetPr(value) = v->Re();
*mxGetPi(value) = v->Im();
}
break;
case PT_int16:
value = mxCreateDoubleScalar((double)*(int16*)prop->get_addr());
break;
case PT_enumeration:
case PT_int32:
value = mxCreateDoubleScalar((double)*(int32*)prop->get_addr());
break;
case PT_set:
case PT_int64:
value = mxCreateDoubleScalar((double)*(int64*)prop->get_addr());
break;
case PT_timestamp:
value = mxCreateDoubleScalar((double)*(TIMESTAMP*)prop->get_addr());
break;
case PT_bool:
value = mxCreateDoubleScalar((double)*(bool*)prop->get_addr());
break;
case PT_char8:
case PT_char32:
case PT_char256:
case PT_char1024:
{
const char *str[] = {(char*)prop->get_addr()};
value = mxCreateCharMatrixFromStrings(mwSize(1),str);
}
break;
case PT_double_array:
{
double_array *data = (double_array*)prop->get_addr();
size_t n=data->get_rows(), m=data->get_cols();
value = mxCreateDoubleMatrix(0,0,mxREAL);
double *copy = (double*)mxMalloc(m*n);
for ( int c=0 ; c<m ; c++ )
{
for ( int r=0 ; r<n ; r++ )
{
copy[c*m+r] = data->get_at(r,c);
}
}
mxSetPr(value,copy);
mxSetM(value,m);
mxSetN(value,n);
}
break;
case PT_complex_array:
// TODO
break;
default:
value = NULL;
break;
}
return value;
}
EXPORT bool glx_init(glxlink *mod)
{
gl_verbose("initializing matlab link");
gl_verbose("PATH=%s", getenv("PATH"));
// initialize matlab engine
MATLABLINK *matlab = (MATLABLINK*)mod->get_data();
matlab->status = 0;
#ifdef WIN32
if ( matlab->command )
matlab->engine = engOpen(matlab->command);
else
matlab->engine = engOpenSingleUse(NULL,NULL,&matlab->status);
if ( matlab->engine==NULL )
{
gl_error("matlab engine start failed, status code is '%d'", matlab->status);
return false;
}
#else
matlab->engine = engOpen(matlab->command);
if ( matlab->engine==NULL )
{
gl_error("matlab engine start failed");
return false;
}
#endif
// set the output buffer
if ( matlab->output_buffer!=NULL )
engOutputBuffer(matlab->engine,matlab->output_buffer,(int)matlab->output_size);
// setup matlab engine
engSetVisible(matlab->engine,window_show(matlab));
gl_debug("matlab link is open");
// special values needed by matlab
mxArray *ts_never = mxCreateDoubleScalar((double)(TIMESTAMP)TS_NEVER);
engPutVariable(matlab->engine,"TS_NEVER",ts_never);
mxArray *ts_error = mxCreateDoubleScalar((double)(TIMESTAMP)TS_INVALID);
engPutVariable(matlab->engine,"TS_ERROR",ts_error);
mxArray *gld_ok = mxCreateDoubleScalar((double)(bool)true);
engPutVariable(matlab->engine,"GLD_OK",gld_ok);
mxArray *gld_err = mxCreateDoubleScalar((double)(bool)false);
engPutVariable(matlab->engine,"GLD_ERROR",gld_err);
// set the workdir
if ( strcmp(matlab->workdir,"")!=0 )
{
#ifdef WIN32
_mkdir(matlab->workdir);
#else
mkdir(matlab->workdir,0750);
#endif
if ( matlab->workdir[0]=='/' )
matlab_exec(matlab,"cd '%s'", matlab->workdir);
else
matlab_exec(matlab,"cd '%s/%s'", getcwd(NULL,0),matlab->workdir);
}
// run the initialization command(s)
if ( matlab->init )
{
mxArray *ans = matlab_exec(matlab,"%s",matlab->init);
if ( ans && mxIsDouble(ans) && (bool)*mxGetPr(ans)==false )
{
gl_error("matlab init failed");
return false;
}
else if ( ans && mxIsChar(ans) )
{
int buflen = (mxGetM(ans) * mxGetN(ans)) + 1;
char *string =(char*)malloc(buflen);
int status_error = mxGetString(ans, string, buflen);
if (status_error == 0)
{
gl_error("'%s'",string);
return false;
}
else
{
gl_error("Did not catch Matlab error");
return false;
}
}
}
if ( matlab->rootname!=NULL )
{
// build gridlabd data
mwSize dims[] = {1,1};
mxArray *gridlabd_struct = mxCreateStructArray(2,dims,0,NULL);
///////////////////////////////////////////////////////////////////////////
// build global data
LINKLIST *item;
mxArray *global_struct = mxCreateStructArray(2,dims,0,NULL);
for ( item=mod->get_globals() ; item!=NULL ; item=mod->get_next(item) )
{
char *name = mod->get_name(item);
GLOBALVAR *var = mod->get_globalvar(item);
mxArray *var_struct = NULL;
mwIndex var_index;
if ( var==NULL ) continue;
// do not map module or structured globals
if ( strchr(var->prop->name,':')!=NULL )
{
// ignore module globals here
}
else if ( strchr(var->prop->name,'.')!=NULL )
{
char struct_name[256];
if ( sscanf(var->prop->name,"%[^.]",struct_name)==0 )
{
gld_property prop(var);
var_index = mxAddField(global_struct,prop.get_name());
var_struct = matlab_create_value(&prop);
if ( var_struct!=NULL )
{
//mod->add_copyto(var->prop->addr,mxGetData(var_struct));
mxSetFieldByNumber(global_struct,0,var_index,var_struct);
}
}
}
else // simple data
{
gld_property prop(var);
var_index = mxAddField(global_struct,prop.get_name());
var_struct = matlab_create_value(&prop);
if ( var_struct!=NULL )
{
//mod->add_copyto(var->prop->addr,mxGetData(var_struct));
mxSetFieldByNumber(global_struct,0,var_index,var_struct);
}
}
// update export list
if ( var_struct!=NULL )
{
mod->set_addr(item,(void*)var_struct);
mod->set_index(item,(size_t)var_index);
}
}
// add globals structure to gridlabd structure
mwIndex gridlabd_index = mxAddField(gridlabd_struct,"global");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,global_struct);
///////////////////////////////////////////////////////////////////////////
// build module data
dims[0] = dims[1] = 1;
mxArray *module_struct = mxCreateStructArray(2,dims,0,NULL);
// add modules
for ( MODULE *module = callback->module.getfirst() ; module!=NULL ; module=module->next )
{
// create module info struct
mwIndex dims[] = {1,1};
mxArray *module_data = mxCreateStructArray(2,dims,0,NULL);
mwIndex module_index = mxAddField(module_struct,module->name);
mxSetFieldByNumber(module_struct,0,module_index,module_data);
// create version info struct
const char *version_fields[] = {"major","minor"};
mxArray *version_data = mxCreateStructArray(2,dims,sizeof(version_fields)/sizeof(version_fields[0]),version_fields);
mxArray *major_data = mxCreateDoubleScalar((double)module->major);
mxArray *minor_data = mxCreateDoubleScalar((double)module->minor);
mxSetFieldByNumber(version_data,0,0,major_data);
mxSetFieldByNumber(version_data,0,1,minor_data);
// attach version info to module info
mwIndex version_index = mxAddField(module_data,"version");
mxSetFieldByNumber(module_data,0,version_index,version_data);
}
gridlabd_index = mxAddField(gridlabd_struct,"module");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,module_struct);
///////////////////////////////////////////////////////////////////////////
// build class data
dims[0] = dims[1] = 1;
mxArray *class_struct = mxCreateStructArray(2,dims,0,NULL);
gridlabd_index = mxAddField(gridlabd_struct,"class");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,class_struct);
mwIndex class_id[1024]; // index into class struct
memset(class_id,0,sizeof(class_id));
// add classes
for ( CLASS *oclass = callback->class_getfirst() ; oclass!=NULL ; oclass=oclass->next )
{
// count objects in this class
mwIndex dims[] = {0,1};
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECT *obj = mod->get_object(item);
if ( obj==NULL || obj->oclass!=oclass ) continue;
dims[0]++;
}
if ( dims[0]==0 ) continue;
mxArray *runtime_struct = mxCreateStructArray(2,dims,0,NULL);
// add class
mwIndex class_index = mxAddField(class_struct,oclass->name);
mxSetFieldByNumber(class_struct,0,class_index,runtime_struct);
// add properties to class
for ( PROPERTY *prop=oclass->pmap ; prop!=NULL && prop->oclass==oclass ; prop=prop->next )
{
mwIndex dims[] = {1,1};
mxArray *property_struct = mxCreateStructArray(2,dims,0,NULL);
mwIndex runtime_index = mxAddField(runtime_struct,prop->name);
mxSetFieldByNumber(runtime_struct,0,runtime_index,property_struct);
}
// add objects to class
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECT *obj = mod->get_object(item);
if ( obj==NULL || obj->oclass!=oclass ) continue;
mwIndex index = class_id[obj->oclass->id]++;
// add properties to class
for ( PROPERTY *prop=oclass->pmap ; prop!=NULL && prop->oclass==oclass ; prop=prop->next )
{
gld_property p(obj,prop);
mxArray *data = matlab_create_value(&p);
mxSetField(runtime_struct,index,prop->name,data);
}
// update export list
mod->set_addr(item,(void*)runtime_struct);
mod->set_index(item,(size_t)index);
}
}
///////////////////////////////////////////////////////////////////////////
// build the object data
dims[0] = 0;
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
if ( mod->get_object(item)!=NULL ) dims[0]++;
}
dims[1] = 1;
memset(class_id,0,sizeof(class_id));
const char *objfields[] = {"name","class","id","parent","rank","clock","valid_to","schedule_skew",
"latitude","longitude","in","out","rng_state","heartbeat","lock","flags"};
mxArray *object_struct = mxCreateStructArray(2,dims,sizeof(objfields)/sizeof(objfields[0]),objfields);
mwIndex n=0;
for ( item=mod->get_objects() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECT *obj = mod->get_object(item);
if ( obj==NULL ) continue;
class_id[obj->oclass->id]++; // index into class struct
const char *objname[] = {obj->name&&isdigit(obj->name[0])?NULL:obj->name};
const char *oclassname[] = {obj->oclass->name};
if (obj->name) mxSetFieldByNumber(object_struct,n,0,mxCreateCharMatrixFromStrings(mwSize(1),objname));
mxSetFieldByNumber(object_struct,n,1,mxCreateCharMatrixFromStrings(mwSize(1),oclassname));
mxSetFieldByNumber(object_struct,n,2,mxCreateDoubleScalar((double)class_id[obj->oclass->id]));
if (obj->parent) mxSetFieldByNumber(object_struct,n,3,mxCreateDoubleScalar((double)obj->parent->id+1));
mxSetFieldByNumber(object_struct,n,4,mxCreateDoubleScalar((double)obj->rank));
mxSetFieldByNumber(object_struct,n,5,mxCreateDoubleScalar((double)obj->clock));
mxSetFieldByNumber(object_struct,n,6,mxCreateDoubleScalar((double)obj->valid_to));
mxSetFieldByNumber(object_struct,n,7,mxCreateDoubleScalar((double)obj->schedule_skew));
if ( isfinite(obj->latitude) ) mxSetFieldByNumber(object_struct,n,8,mxCreateDoubleScalar((double)obj->latitude));
if ( isfinite(obj->longitude) ) mxSetFieldByNumber(object_struct,n,9,mxCreateDoubleScalar((double)obj->longitude));
mxSetFieldByNumber(object_struct,n,10,mxCreateDoubleScalar((double)obj->in_svc));
mxSetFieldByNumber(object_struct,n,11,mxCreateDoubleScalar((double)obj->out_svc));
mxSetFieldByNumber(object_struct,n,12,mxCreateDoubleScalar((double)obj->rng_state));
mxSetFieldByNumber(object_struct,n,13,mxCreateDoubleScalar((double)obj->heartbeat));
mxSetFieldByNumber(object_struct,n,14,mxCreateDoubleScalar((double)obj->lock));
mxSetFieldByNumber(object_struct,n,15,mxCreateDoubleScalar((double)obj->flags));
n++;
}
gridlabd_index = mxAddField(gridlabd_struct,"object");
mxSetFieldByNumber(gridlabd_struct,0,gridlabd_index,object_struct);
///////////////////////////////////////////////////////////////////////////
// post the gridlabd structure
matlab->root = gridlabd_struct;
engPutVariable(matlab->engine,matlab->rootname,matlab->root);
}
///////////////////////////////////////////////////////////////////////////
// build the import/export data
for ( LINKLIST *item=mod->get_exports() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECTPROPERTY *objprop = mod->get_export(item);
if ( objprop==NULL ) continue;
// add to published items
gld_property prop(objprop->obj,objprop->prop);
item->addr = (mxArray*)matlab_create_value(&prop);
engPutVariable(matlab->engine,item->name,(mxArray*)item->addr);
}
for ( LINKLIST *item=mod->get_imports() ; item!=NULL ; item=mod->get_next(item) )
{
OBJECTPROPERTY *objprop = mod->get_import(item);
if ( objprop==NULL ) continue;
// check that not already in export list
LINKLIST *export_item;
bool found=false;
for ( export_item=mod->get_exports() ; export_item!=NULL ; export_item=mod->get_next(export_item) )
{
OBJECTPROPERTY *other = mod->get_export(item);
if ( memcmp(objprop,other,sizeof(OBJECTPROPERTY)) )
found=true;
}
if ( !found )
{
gld_property prop(objprop->obj,objprop->prop);
item->addr = (mxArray*)matlab_create_value(&prop);
engPutVariable(matlab->engine,item->name,(mxArray*)item->addr);
}
}
static int32 matlab_flag = 1;
gl_global_create("MATLAB",PT_int32,&matlab_flag,PT_ACCESS,PA_REFERENCE,PT_DESCRIPTION,"indicates that MATLAB is available",NULL);
mod->last_t = gl_globalclock;
return true;
}
// X = get_x_slice32c15(img, ind);
// img: [a,b,c]. int16. the CT volume
// ind: [M]. linear index to the image for the locations of sampling points
// X: [32, 32, 15, M]. single. the slices data batch
void mexFunction(int no, mxArray *vo[],
int ni, mxArray const *vi[])
{
//// Input
mxArray const *img = vi[0];
mxArray const *ind = vi[1];
///// Create Output and set it
mwSize M = mxGetM(ind) * mxGetN(ind);
mwSize dims[4] = {S,S,C,0};
dims[3] = M;
mxArray *X = mxCreateNumericArray(4, dims, mxSINGLE_CLASS, mxREAL);
vo[0] = X;
//// do the job
int16_T *p_img = (int16_T*) mxGetData(img);
const mwSize *sz_img;
sz_img = mxGetDimensions(img);
double *p_ind = (double*) mxGetData(ind);
float *p_X = (float*) mxGetData(X);
// iterate over center points
#pragma omp parallel for
for (int64_T m = 0; m < M; ++m) {
// center index --> center point
mwSize ixcen = mwSize( *(p_ind + m) );
ixcen -= 1; // Matlab 1 base -> C 0 base
mwSize pntcen[3];
ix_to_pnt3d(sz_img, ixcen, pntcen);
{ // dim_1, dim_2, dim_3 (CC planes): inner to outer
mwSize stride_X = 0 + S*S*C*m;
float *pp = p_X + stride_X;
for (int k = 0; k < CC; ++k) {
for (int j = (-SS); j < SS; ++j) {
for (int i = (-SS); i < SS; ++i) {
// the working offset
int d[3];
d[0] = i; d[1] = j; d[2] = CHANNNEL_OFFSET_TMPL[k];
// value on the image
float val;
get_val_from_offset(p_img, sz_img, pntcen, d, val);
// write back
*pp = val; ++pp;
} // for i
} // for j
} // for k
}
{ // dim_2, dim_3, dim_1(CC planes): inner to outer
mwSize stride_X = 1*S*S*CC + S*S*C*m;
float *pp = p_X + stride_X;
for (int i = 0; i < CC; ++i) {
for (int k = (-SS); k < SS; ++k) {
for (int j = (-SS); j < SS; ++j) {
// the working offset
int d[3];
d[0] = CHANNNEL_OFFSET_TMPL[i]; d[1] = j; d[2] = k;
// value on the image
float val;
get_val_from_offset(p_img, sz_img, pntcen, d, val);
// write back
*pp = val; ++pp;
} // for j
} // for k
} // for i
}
{ // dim_1, dim_3, dim_2(CC planes): inner to outer
int stride = 2*S*S*CC + S*S*C*m;
float *pp = p_X + stride;
for (int j = 0; j < CC; ++j) {
for (int k = (-SS); k < SS; ++k) {
for (int i = (-SS); i < SS; ++i) {
// the working offset
int d[3];
d[0] = i; d[1] = CHANNNEL_OFFSET_TMPL[j]; d[2] = k;
// value on the image
float val;
get_val_from_offset(p_img, sz_img, pntcen, d, val);
// write back
*pp = val; ++pp;
} // for i
} // for k
} // for j
}
} // for m
return;
}
