int csimMexSet(int nlhs, mxArray *[], int nrhs, const mxArray *prhs[])
{
if ( !TheNetwork )
mexErrMsgTxt("CSIM: No network initialized yet!\n");
if ( nrhs < 3 || nlhs > 0 )
mexErrMsgTxt("CSIM-Usage: csim('set',idx,field,value[,field,value]*);\n");
char *globalVar;
if ( getString(prhs[1],&globalVar) == 0) {
if ( nrhs != 3 )
mexErrMsgTxt("CSIM-Usage: csim('set',field,value);\n");
double tmp;
if ( getDouble(prhs[2],&tmp) ) {
mexErrMsgTxt("CSIM-Usage: csim('set',field,value); value not a single double\n");
}
if ( TheNetwork->setField(globalVar,tmp) < 0 ) {
TheCsimError.add("csimMexSet: can not set field %s to %g!",globalVar,tmp); return -1;
}
} else {
uint32 *idx; int nIdx;
if ( getUint32Vector(prhs[1],&idx,&nIdx) )
mexErrMsgTxt("CSIM-Usage: csim('set',idx[,field,value]*); idx is not a uint32 vector.\n");
// loop over all <field,value> pairs
int k=2;
while ( k < nrhs ) {
char *paramName;
if ( getString(prhs[k],¶mName) )
mexErrMsgTxt("CSIM-Usage: csim('set',idx,field,value[,field,value]*); field is not a string.\n");
double *value; int m,n;
if ( getDoubleArray(prhs[k+1],&value,&m,&n) )
mexErrMsgTxt("CSIM-Usage: csim('set',idx,field,value[,field,value]*); value is not a double array.\n");
if ( n < 1 )
mexErrMsgTxt("CSIM-Usage: csim('set',idx,field,value[,field,value]*); value is empty!");
if ( (n>1) && (n!=nIdx) )
mexErrMsgTxt("CSIM-Usage: csim('set',idx,field,value[,field,value]*); size(value,2) != length(idx)\n");
if ( TheNetwork->setParameter(idx,nIdx,paramName,value,m,n) < 0 ) {
TheCsimError.add("csim('set',idx,field,value); failed\n");
return -1;
}
k += 2;
}
}
return 0;
}
/***********************************************************************//**
* \brief mexFunction to append a stack to an existing em-file.
**************************************************************************/
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) {
size_t filename_length = 0;
#define __MAX_FILENAME_LENGTH__ ((int)2048)
char filename[__MAX_FILENAME_LENGTH__+1];
#define __MAX_S__LENGTH__ (4096)
char s[__MAX_S__LENGTH__+1];
#define __BUFFERLENGTH_SYNOPSIS__ 1024
char synopsis[__BUFFERLENGTH_SYNOPSIS__];
size_t i, j, k;
const void *w_data;
int w_iotype;
size_t dims[3];
uint32_t *subregion = NULL;
uint32_t subregion_field[6];
tom_io_em_header header;
float *complexCopy = 0;
char autoval_magic = 1;
size_t stridey=0, stridez=0;
memset(&header, 0, sizeof(header));
snprintf(synopsis, __BUFFERLENGTH_SYNOPSIS__, "%s(filename, data, [subregion_in, magic, comment, emdata, userdata])", mexFunctionName());
if (nrhs==0 && nlhs==0) {
/* Print help */
mexPrintf("SYNOPSIS: %s\n", synopsis);
mexPrintf("mex-file compiled from file \"" __FILE__ "\" at " __DATE__ ", " __TIME__ ".\n");
return;
}
if (nlhs>0 || nrhs<2 || nrhs>7) {
snprintf(s, __MAX_S__LENGTH__, "%s: Wrong number of in/output arguments: %s.", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
{
#define __MAX_UINT32_T__ 0xFFFFFFFF
const mxArray *arg;
mxArray *tmpArray = NULL;
const mwSize *size;
double *pdouble;
int8_t *pint8;
int32_t *pint32;
mxClassID type;
/* filename */
arg = prhs[0];
if (!mxIsChar(arg) || mxGetNumberOfDimensions(arg)!=2 || mxGetM(arg)!=1 || (filename_length=mxGetN(arg))<1 || filename_length>=__MAX_FILENAME_LENGTH__) {
snprintf(s, __MAX_S__LENGTH__, "%s: needs file name as first parameter: %s.", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
mxGetString(arg, filename, __MAX_FILENAME_LENGTH__);
/* subregion */
if (nrhs >= 3) {
arg = prhs[2];
i = mxGetM(arg);
j = mxGetN(arg);
if (!mxIsNumeric(arg) || mxIsComplex(arg) || mxGetNumberOfDimensions(arg)!=2 || !((i==0&&j==0) || (i==1&&j==6) || (i==6&&j==1))) {
snprintf(s, __MAX_S__LENGTH__, "%s: The subregion must be either [] or a 1x6 vector: %s", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
if (i!=0) {
if (!(tmpArray=getDoubleArray(arg))) {
snprintf(s, __MAX_S__LENGTH__, "%s: Error creating a copy of the subregion. Maybe out of memory.", mexFunctionName());
mexErrMsgTxt(s);
}
pdouble = mxGetPr(tmpArray);
for (k=0; k<6; k++) {
if (pdouble[k] != floor(pdouble[k]) || pdouble[k]<0 || (k>=3&&pdouble[k]<=0) || pdouble[k]>__MAX_UINT32_T__) {
snprintf(s, __MAX_S__LENGTH__, "%s: The subregion must contain positive integer values: %s", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
subregion_field[k] = (uint32_t)pdouble[k];
}
subregion = subregion_field;
mxDestroyArray(tmpArray);
}
}
/* magic */
if (nrhs >= 4) {
arg = prhs[3];
if (!mxIsNumeric(arg) || mxIsComplex(arg) || mxGetNumberOfDimensions(arg)!=2) {
snprintf(s, __MAX_S__LENGTH__, "%s: magic must be a 4-vector of int8 or [].", mexFunctionName());
mexErrMsgTxt(s);
}
if (mxGetNumberOfElements(arg) > 0) {
if (mxGetClassID(arg)!=mxINT8_CLASS || mxGetNumberOfElements(arg)!=4 || (mxGetN(arg)!=1&&mxGetM(arg)!=1)) {
snprintf(s, __MAX_S__LENGTH__, "%s: magic must be a 4-vector of int8 or [].", mexFunctionName());
mexErrMsgTxt(s);
}
pint8 = (int8_t *)mxGetData(arg);
header.machine = pint8[0];
header.byte2 = pint8[1];
header.byte3 = pint8[2];
header.type = pint8[3];
autoval_magic = 0;
}
}
/* comment */
if (nrhs >= 5) {
arg = prhs[4];
if (!mxIsNumeric(arg) || mxIsComplex(arg) || mxGetNumberOfDimensions(arg)!=2) {
snprintf(s, __MAX_S__LENGTH__, "%s: comment must be a 80-vector of int8 or [].", mexFunctionName());
mexErrMsgTxt(s);
}
if (mxGetNumberOfElements(arg) > 0) {
if (mxGetClassID(arg)!=mxINT8_CLASS || mxGetNumberOfElements(arg)!=80 || (mxGetN(arg)!=1&&mxGetM(arg)!=1)) {
snprintf(s, __MAX_S__LENGTH__, "%s: comment must be a 80-vector of int8 or [].", mexFunctionName());
mexErrMsgTxt(s);
}
pint8 = (int8_t *)mxGetData(arg);
for (i=0; i<80; i++) {
header.comment[i] = pint8[i];
}
}
}
/* emdata */
if (nrhs >= 6) {
arg = prhs[5];
if (!mxIsNumeric(arg) || mxIsComplex(arg) || mxGetNumberOfDimensions(arg)!=2) {
snprintf(s, __MAX_S__LENGTH__, "%s: emdata must be a 40-vector of int32 or [].", mexFunctionName());
mexErrMsgTxt(s);
}
if (mxGetNumberOfElements(arg) > 0) {
if (mxGetClassID(arg)!=mxINT32_CLASS || mxGetNumberOfElements(arg)!=40 || (mxGetN(arg)!=1&&mxGetM(arg)!=1)) {
snprintf(s, __MAX_S__LENGTH__, "%s: comment must be a 40-vector of int32 or [].", mexFunctionName());
mexErrMsgTxt(s);
}
pint32 = (int32_t *)mxGetData(arg);
for (i=0; i<40; i++) {
header.emdata[i] = pint32[i];
}
}
}
/* userdata */
if (nrhs >= 7) {
arg = prhs[6];
if (!mxIsNumeric(arg) || mxIsComplex(arg) || mxGetNumberOfDimensions(arg)!=2) {
snprintf(s, __MAX_S__LENGTH__, "%s: userdata must be a 256-vector of int8 or [].", mexFunctionName());
mexErrMsgTxt(s);
}
if (mxGetNumberOfElements(arg) > 0) {
if (mxGetClassID(arg)!=mxINT8_CLASS || mxGetNumberOfElements(arg)!=256 || (mxGetN(arg)!=1&&mxGetM(arg)!=1)) {
snprintf(s, __MAX_S__LENGTH__, "%s: userdata must be a 256-vector of int8 or [].", mexFunctionName());
mexErrMsgTxt(s);
}
pint8 = (int8_t *)mxGetData(arg);
for (i=0; i<256; i++) {
header.userdata[i] = pint8[i];
}
}
}
arg = prhs[1];
if (!mxIsNumeric(arg) || mxGetNumberOfDimensions(arg)>3 || mxGetNumberOfElements(arg)<1) {
snprintf(s, __MAX_S__LENGTH__, "%s: The volume must be a non-empty numeric array.", mexFunctionName());
mexErrMsgTxt(s);
}
size = mxGetDimensions(arg);
dims[0] = size[0];
dims[1] = size[1];
dims[2] = mxGetNumberOfDimensions(arg)==3 ? size[2] : 1;
type = mxGetClassID(arg);
if (mxIsComplex(arg)) {
const size_t numel = dims[0]*dims[1]*dims[2];
float *pdst;
if (!autoval_magic && tom_io_em_get_iotype(&header)!=TOM_IO_TYPE_COMPLEX4) {
snprintf(s, __MAX_S__LENGTH__, "%s: Saving complex data is only possible as complex (single) floating point.", mexFunctionName());
mexErrMsgTxt(s);
}
if (!(complexCopy = malloc(numel*2*sizeof(float)))) {
snprintf(s, __MAX_S__LENGTH__, "%s: Error allocating memory for temporary copy of complex data.", mexFunctionName());
mexErrMsgTxt(s);
}
pdst = complexCopy;
if (type == mxSINGLE_CLASS) {
const float *psrc_re, *psrc_im;
psrc_re = (float *)mxGetData(arg);
psrc_im = (float *)mxGetImagData(arg);
for (i=0; i<numel; i++) {
*pdst++ = psrc_re[i];
*pdst++ = psrc_im[i];
}
} else if (type == mxDOUBLE_CLASS) {
const double *psrc_re, *psrc_im;
psrc_re = mxGetPr(arg);
psrc_im = mxGetPr(arg);
for (i=0; i<numel; i++) {
*pdst++ = psrc_re[i];
*pdst++ = psrc_im[i];
}
} else {
free(complexCopy);
snprintf(s, __MAX_S__LENGTH__, "%s: EM supports only floating point complex data (single).", mexFunctionName(), type);
mexErrMsgTxt(s);
}
w_iotype = TOM_IO_TYPE_COMPLEX4;
w_data = complexCopy;
} else {
switch (type) {
case mxINT8_CLASS:
w_iotype = TOM_IO_TYPE_INT8;
break;
case mxINT16_CLASS:
w_iotype = TOM_IO_TYPE_INT16;
break;
case mxINT32_CLASS:
w_iotype = TOM_IO_TYPE_INT32;
break;
case mxSINGLE_CLASS:
w_iotype = TOM_IO_TYPE_FLOAT;
break;
case mxDOUBLE_CLASS:
w_iotype = TOM_IO_TYPE_DOUBLE;
break;
default:
snprintf(s, __MAX_S__LENGTH__, "%s: The volume has type %s: This can not be saved to EM without conversion.", mexFunctionName(), type);
mexErrMsgTxt(s);
}
w_data = mxGetData(arg);
}
if (subregion) {
if (subregion[0]+subregion[3]>dims[0] || subregion[1]+subregion[4]>dims[1] || subregion[2]+subregion[5]>dims[2]) {
snprintf(s, __MAX_S__LENGTH__, "%s: The subregion is out of the volume.", mexFunctionName());
mexErrMsgTxt(s);
}
header.dims[0] = subregion[3];
header.dims[1] = subregion[4];
header.dims[2] = subregion[5];
w_data = (const char *)w_data + ((((subregion[2]*dims[1] + subregion[1]))*dims[0] + subregion[0])*tom_io_iotype_datasize(w_iotype));
stridey = dims[0] * tom_io_iotype_datasize(w_iotype);
stridez = dims[1] * stridey;
} else {
if (dims[0]>=__MAX_UINT32_T__ || dims[1]>=__MAX_UINT32_T__ || dims[2]>=__MAX_UINT32_T__) {
snprintf(s, __MAX_S__LENGTH__, "%s: The volume is too large to save it to EM.", mexFunctionName());
mexErrMsgTxt(s);
}
header.dims[0] = dims[0];
header.dims[1] = dims[1];
header.dims[2] = dims[2];
}
if (autoval_magic) {
header.machine = 6;
tom_io_em_set_iotype(&header, w_iotype);
}
if (!tom_io_em_is_valid_header(&header, sizeof(header))) {
if (complexCopy) {
free(complexCopy);
}
snprintf(s, __MAX_S__LENGTH__, "%s: The given EM-Header is not valid. Check the content of magic.", mexFunctionName());
mexErrMsgTxt(s);
}
#undef __MAX_UINT32_T__
}
{
/*printf("WRITE: swapped: %d, %d->%d %20.15f\n", tom_io_em_is_swaped(&header), w_iotype, tom_io_em_get_iotype(&header), *((double *)w_data));*/
int i;
if ((i=tom_io_em_write(filename, &header, w_data, w_iotype, 0, stridey, stridez)) != TOM_ERR_OK) {
if (complexCopy) {
free(complexCopy);
}
if (i == TOM_ERR_WRONG_IOTYPE_CONVERSION) {
snprintf(s, __MAX_S__LENGTH__, "%s: The type conversion from %d to %d is not implemented/supported.", mexFunctionName(), w_iotype, tom_io_em_get_iotype(&header));
} else {
snprintf(s, __MAX_S__LENGTH__, "%s: Error saving the file (%d).", mexFunctionName(), i);
}
mexErrMsgTxt(s);
}
}
if (complexCopy) {
free(complexCopy);
}
}
/***********************************************************************//**
* \brief mexFunction to append a stack to an existing em-file.
**************************************************************************/
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[]) {
size_t filename_length = 0;
#define __MAX_FILENAME_LENGTH__ ((int)2048)
char filename[__MAX_FILENAME_LENGTH__+1];
#define __MAX_S__LENGTH__ (4096)
char s[__MAX_S__LENGTH__+1];
#define __BUFFERLENGTH_SYNOPSIS__ 1024
char synopsis[__BUFFERLENGTH_SYNOPSIS__];
size_t i, j, k;
const void *w_data;
int w_iotype;
uint32_t subregion_start[3] = { 0,0,0 };
uint32_t reverse_sampling[3] = { 0,0,0 };
tom_io_em_header header;
int allow_conversion = 1;
mxArray *plhs_tmp[5] = { NULL, NULL, NULL, NULL, NULL };
void *complexCopy = NULL;
uint32_t w_sizex, w_sizey, w_sizez;
size_t w_stridex=0, w_stridey=0, w_stridez=0;
snprintf(synopsis, __BUFFERLENGTH_SYNOPSIS__, "[size, magic, comment, emdata, userdata] = %s(filename, volume, [subregion_start, reverse_sampling, allow_conversion])", mexFunctionName());
if (nrhs==0 && nlhs==0) {
/* Print help */
mexPrintf("SYNOPSIS: %s\n", synopsis);
mexPrintf("mex-file compiled from file \"" __FILE__ "\" at " __DATE__ ", " __TIME__ ".\n");
return;
}
if (nlhs>5 || nrhs<2 || nrhs>5) {
snprintf(s, __MAX_S__LENGTH__, "%s: Wrong number of in/output arguments: %s.", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
{
#define __MAX_UINT32_T__ 0xFFFFFFFF
const mxArray *arg;
mxArray *tmpArray = NULL;
const mwSize *size;
double *pdouble;
mxClassID type;
/* filename */
arg = prhs[0];
if (!mxIsChar(arg) || mxGetNumberOfDimensions(arg)!=2 || mxGetM(arg)!=1 || (filename_length=mxGetN(arg))<1 || filename_length>=__MAX_FILENAME_LENGTH__) {
snprintf(s, __MAX_S__LENGTH__, "%s: needs file name as first parameter: %s.", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
mxGetString(arg, filename, __MAX_FILENAME_LENGTH__);
/* subregion_start */
if (nrhs >= 3) {
arg = prhs[2];
i = mxGetM(arg); j = mxGetN(arg);
if (!mxIsNumeric(arg) || mxIsComplex(arg) || mxGetNumberOfDimensions(arg)!=2 || !((i==0&&j==0) || (i==1&&j==3) || (i==3&&j==1))) {
snprintf(s, __MAX_S__LENGTH__, "%s: The subregion_start must be either [] or a 1x3 vector: %s", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
if (i!=0) {
if (!(tmpArray=getDoubleArray(arg))) {
snprintf(s, __MAX_S__LENGTH__, "%s: Error creating a copy of the subregion_start. Maybe out of memory.", mexFunctionName());
mexErrMsgTxt(s);
}
pdouble = mxGetPr(tmpArray);
for (k=0; k<3; k++) {
subregion_start[k] = (uint32_t)pdouble[k];
if (pdouble[k] != subregion_start[k]) {
snprintf(s, __MAX_S__LENGTH__, "%s: subregion_start must contain integer values: %s", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
}
mxDestroyArray(tmpArray);
}
}
/* reverse_sampling */
if (nrhs >= 4) {
arg = prhs[3];
i = mxGetM(arg); j = mxGetN(arg);
if (!mxIsNumeric(arg) || mxIsComplex(arg) || mxGetNumberOfDimensions(arg)!=2 || !((i==0&&j==0) || (i==1&&j==3) || (i==3&&j==1))) {
snprintf(s, __MAX_S__LENGTH__, "%s: The reverse_sampling must be either [] or a 1x3 vector: %s", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
if (i!=0) {
if (!(tmpArray=getDoubleArray(arg))) {
snprintf(s, __MAX_S__LENGTH__, "%s: Error creating a copy of the reverse_sampling. Maybe out of memory.", mexFunctionName());
mexErrMsgTxt(s);
}
pdouble = mxGetPr(tmpArray);
for (k=0; k<3; k++) {
reverse_sampling[k] = (uint32_t)pdouble[k];
if (pdouble[k] != reverse_sampling[k]) {
snprintf(s, __MAX_S__LENGTH__, "%s: reverse_sampling must contain integer values: %s", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
}
mxDestroyArray(tmpArray);
}
}
if (reverse_sampling[0] < 1) { reverse_sampling[0] = 1; }
if (reverse_sampling[1] < 1) { reverse_sampling[1] = 1; }
if (reverse_sampling[2] < 1) { reverse_sampling[2] = 1; }
/* allow_conversion */
if (nrhs >= 5) {
const mwSize numel = mxGetNumberOfElements(arg = prhs[4]);
if (!(mxIsNumeric(arg) || mxIsLogical(arg)) || numel>1) {
snprintf(s, __MAX_S__LENGTH__, "%s: allow_conversion must be one of true, false or [].", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
if (numel == 1) {
allow_conversion = mxGetScalar(arg) != 0;
}
}
{
/* Allocate the memory for the ouput, so that in case of successfully writing, no
error can happen afterwards in the mexfunction. */
switch (nlhs) {
case 5:
if (!(plhs_tmp[4] = mxCreateNumericMatrix(1, 256, mxINT8_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); }
case 4:
if (!(plhs_tmp[3] = mxCreateNumericMatrix(1, 40, mxINT32_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); }
case 3:
if (!(plhs_tmp[2] = mxCreateNumericMatrix(1, 80, mxINT8_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); }
case 2:
if (!(plhs_tmp[1] = mxCreateNumericMatrix(1, 4, mxINT8_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); }
case 1:
if (!(plhs_tmp[0] = mxCreateNumericMatrix(3, 1, mxUINT32_CLASS, mxREAL))) { mexErrMsgTxt("Error allocating memory"); }
}
}
/* data */
arg = prhs[1];
if (!mxIsNumeric(arg) || mxGetNumberOfDimensions(arg)>3) {
snprintf(s, __MAX_S__LENGTH__, "%s: needs a numerical volume as second parameter: %s", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
type = mxGetClassID(arg);
size = mxGetDimensions(arg);
w_sizex = size[0];
w_sizey = size[1];
w_sizez = mxGetNumberOfDimensions(arg)==3 ? size[2] : 1;
if (w_sizex!=size[0] || w_sizey!=size[1] || w_sizez!=(mxGetNumberOfDimensions(arg)==3?size[2]:1)) {
snprintf(s, __MAX_S__LENGTH__, "%s: The volume is too large to save it as EM.", mexFunctionName(), synopsis);
mexErrMsgTxt(s);
}
if (mxIsComplex(arg)) {
const size_t numel = w_sizex * w_sizey * w_sizez;
float *pdst;
if (!allow_conversion && type!=mxSINGLE_CLASS) {
snprintf(s, __MAX_S__LENGTH__, "%s: Can not convert complex volume to single (not allow_conversion).", mexFunctionName());
mexErrMsgTxt(s);
}
if (!(complexCopy = malloc(numel*2*sizeof(float)))) {
snprintf(s, __MAX_S__LENGTH__, "%s: Error allocating memory for temporary copy of complex data.", mexFunctionName());
mexErrMsgTxt(s);
}
pdst = complexCopy;
if (type == mxSINGLE_CLASS) {
const float *psrc_re;
const float *psrc_im;
psrc_re = (float *)mxGetData(arg);
psrc_im = (float *)mxGetData(arg);
for (i=0; i<numel; i++) {
*pdst++ = psrc_re[i];
*pdst++ = psrc_im[i];
}
} else if (type == mxDOUBLE_CLASS) {
const double *psrc_re, *psrc_im;
psrc_re = mxGetPr(arg);
psrc_im = mxGetPi(arg);
for (i=0; i<numel; i++) {
*pdst++ = psrc_re[i];
*pdst++ = psrc_im[i];
}
} else {
free(complexCopy); complexCopy = NULL;
snprintf(s, __MAX_S__LENGTH__, "%s: EM supports only floating point complex data (single).", mexFunctionName(), type);
mexErrMsgTxt(s);
}
w_data = complexCopy;
w_iotype = TOM_IO_TYPE_COMPLEX4;
} else {
w_data = mxGetData(arg);
w_iotype = getIOTypeFromMxClassID(type, false);
}
}
{
int header_read;
int fcn_res = tom_io_em_write_paste(filename, w_data, w_iotype, w_sizex, w_sizey, w_sizez, w_stridex, w_stridey, w_stridez, &header, &header_read, allow_conversion, subregion_start, reverse_sampling);
if (fcn_res != TOM_ERR_OK) {
if (complexCopy) { free(complexCopy); complexCopy = NULL; }
switch (fcn_res) {
case TOM_ERR_VOLUME_TOO_LARGE:
snprintf(s, __MAX_S__LENGTH__, "%s: The %lux%lux%lu-volume is to large to paste it into the %lux%lux%lu-EM-file (start at %lux%lux%lu, sample %lux%lux%lu).", mexFunctionName(), (unsigned long)w_sizex, (unsigned long)w_sizey, (unsigned long)w_sizez, (unsigned long)header.dims[0], (unsigned long)header.dims[1], (unsigned long)header.dims[2], (unsigned long)subregion_start[0], (unsigned long)subregion_start[1], (unsigned long)subregion_start[2], (unsigned long)reverse_sampling[0], (unsigned long)reverse_sampling[1], (unsigned long)reverse_sampling[2]);
break;
case TOM_ERR_WRONG_IOTYPE_CONVERSION:
snprintf(s, __MAX_S__LENGTH__, "%s: Error converting the volume from type %d to type %d (allow conversion = %s).", mexFunctionName(), (int)w_iotype, (int)tom_io_em_get_iotype(&header), allow_conversion ? "yes" : "no");
break;
default:
snprintf(s, __MAX_S__LENGTH__, "%s: Unspecified error pasting the volume to file (%d).", mexFunctionName(), fcn_res);
break;
}
mexErrMsgTxt(s);
}
if (complexCopy) { free(complexCopy); complexCopy = NULL;}
}
{
/* Construct the output. */
void *pdata;
switch (nlhs) {
case 5:
pdata = mxGetData(plhs[4] = plhs_tmp[4]);
for (i=0; i<256; i++) { ((int8_t *)pdata)[i] = header.userdata[i]; }
case 4:
pdata = mxGetData(plhs[3] = plhs_tmp[3]);
for (i=0; i<40; i++) { ((int32_t *)pdata)[i] = header.emdata[i]; }
case 3:
pdata = mxGetData(plhs[2] = plhs_tmp[2]);
for (i=0; i<80; i++) { ((int8_t *)pdata)[i] = header.comment[i]; }
case 2:
pdata = mxGetData(plhs[1] = plhs_tmp[1]);
((int8_t *)pdata)[0] = header.machine;
((int8_t *)pdata)[1] = header.byte2;
((int8_t *)pdata)[2] = header.byte3;
((int8_t *)pdata)[3] = header.type;
case 1:
pdata = mxGetData(plhs[0] = plhs_tmp[0]);
((uint32_t *)pdata)[0] = header.dims[0];
((uint32_t *)pdata)[1] = header.dims[1];
((uint32_t *)pdata)[2] = header.dims[2];
break;
case 0:
default:
break;
}
}
}
/*!
* \brief Grabs ft rosparams from a given node hande namespace
*
* The force/torque parameters consist of
* 6x ADC offset values
* 6x6 gain matrix as 6-elment array of 6-element arrays of doubles
*
* \return True, if there are no problems.
*/
bool FTParamsInternal::getRosParams(ros::NodeHandle nh)
{
if (!nh.hasParam("ft_params"))
{
ROS_WARN("'ft_params' not available for force/torque sensor in namespace '%s'",
nh.getNamespace().c_str());
return false;
}
XmlRpc::XmlRpcValue params;
nh.getParam("ft_params", params);
if (params.getType() != XmlRpc::XmlRpcValue::TypeStruct)
{
ROS_ERROR("expected ft_params to be struct type");
return false;
}
if (!getDoubleArray(params, "offsets", offsets_, 6))
{
return false;
}
if (!getDoubleArray(params, "gains", gains_, 6))
{
return false;
}
XmlRpc::XmlRpcValue coeff_matrix = params["calibration_coeff"];
if (coeff_matrix.getType() != XmlRpc::XmlRpcValue::TypeArray)
{
ROS_ERROR("Expected FT param 'calibration_coeff' to be list type");
return false;
}
if (coeff_matrix.size() != 6)
{
ROS_ERROR("Expected FT param 'calibration_coeff' to have 6 elements");
return false;
}
for (int i=0; i<6; ++i)
{
XmlRpc::XmlRpcValue coeff_row = coeff_matrix[i];
if (coeff_row.getType() != XmlRpc::XmlRpcValue::TypeArray)
{
ROS_ERROR("Expected FT param calibration_coeff[%d] to be list type", i);
return false;
}
if (coeff_row.size() != 6)
{
ROS_ERROR("Expected FT param calibration_coeff[%d] to have 6 elements", i);
return false;
}
for (int j=0; j<6; ++j)
{
if (coeff_row[j].getType() != XmlRpc::XmlRpcValue::TypeDouble)
{
ROS_ERROR("Expected FT param calibration_coeff[%d,%d] to be floating point type", i,j);
return false;
} else {
calibration_coeff(i,j) = static_cast<double>(coeff_row[j]);
}
}
}
return true;
}
