void dim_loop(int fd, int dimensions_nb, t_vol *volume,
t_tissue_stack *t, char *id_percent,
int slice_resume, int dimension_resume)
{
int dim = 0;
int slice = 0;
int this_slice = 0;
int size;
char *hyperslab;
int i;
unsigned long *start;
long unsigned int *count;
short cancel = 0;
if (dimension_resume > -1)
dim = dimension_resume;
start = malloc(volume->dim_nb * sizeof(*start));
count = malloc(volume->dim_nb * sizeof(*count));
start[0] = start[1] = start[2] = 0;
i = 0;
while (i < volume->dim_nb)
{
count[i] = volume->size[i];
i++;
}
printf("Dimensions size: size[0] ==> %i | size[1] ==> %i | size[2] ==> %i\n\n", (int)volume->size[0], (int)volume->size[1], (int)volume->size[2]);
while (dim < dimensions_nb && cancel == 0)
{
size = (dim == 0 ? (volume->size[2] * volume->size[1]) :
(dim == 1 ? (volume->size[0] * volume->size[2]) : (volume->size[0] * volume->size[1])));
hyperslab = malloc(size * sizeof(*hyperslab));
slice = volume->size[dim];
if (slice_resume != -1)
{
this_slice = slice_resume;
slice_resume = -1;
}
else
this_slice = 0;
count[dim] = 1;
while (this_slice < slice && cancel == 0)
{
start[dim] = this_slice;
memset(hyperslab, '\0', size);
miget_real_value_hyperslab(volume->minc_volume, MI_TYPE_UBYTE, (misize_t*)start, (misize_t*)count, hyperslab);
write(fd, hyperslab, size);
printf("Slice = %i / %i - dim = %i\r", this_slice, (int)volume->size[dim], dim);
fflush(stdout);
this_slice++;
}
start[dim] = 0;
count[dim] = volume->size[dim];
dim++;
free(hyperslab);
printf(" \r");
}
}
void dim_loop(int fd, int dimensions_nb, t_vol *volume,
t_tissue_stack *t, char *id_percent,
int slice_resume, int dimension_resume)
{
int dim = 0;
int slice = 0;
int this_slice = 0;
int size;
char *hyperslab;
int i;
unsigned long *start;
long unsigned int *count;
short cancel = 0;
if (dimension_resume > -1)
dim = dimension_resume;
start = malloc(volume->dim_nb * sizeof(*start));
count = malloc(volume->dim_nb * sizeof(*count));
start[0] = start[1] = start[2] = 0;
i = 0;
while (i < volume->dim_nb)
{
count[i] = volume->size[i];
i++;
}
while (dim < dimensions_nb && cancel == 0)
{
size = (dim == 0 ? (volume->size[2] * volume->size[1]) :
(dim == 1 ? (volume->size[0] * volume->size[2]) : (volume->size[0] * volume->size[1])));
hyperslab = malloc(size * sizeof(*hyperslab));
slice = volume->size[dim];
if (slice_resume != -1)
{
this_slice = slice_resume;
slice_resume = -1;
}
else
this_slice = 0;
count[dim] = 1;
while (this_slice < slice && cancel == 0)
{
start[dim] = this_slice;
memset(hyperslab, '\0', size);
miget_real_value_hyperslab(volume->minc_volume, MI_TYPE_UBYTE, start, count, hyperslab);
write(fd, hyperslab, size);
DEBUG("Slice = %i - dim = %i", this_slice, dim);
this_slice++;
t->percent_add(1, id_percent, t);
cancel = t->is_percent_paused_cancel(id_percent, t);
}
start[dim] = 0;
count[dim] = volume->size[dim];
dim++;
free(hyperslab);
}
}
void cautious_get_hyperslab(mihandle_t volume,
mitype_t buffer_data_type,
misize_t *voxel_offsets,
misize_t *sizes,
void *buffer,
string error_message){
int res = miget_real_value_hyperslab(volume, buffer_data_type, voxel_offsets, sizes, buffer);
if(res != MI_NOERROR){
stop(error_message);
}
}
void get_mask_slice(mihandle_t hmask,
misize_t *sizes,
double *mask_buffer,
int slice_number) {
int result;
misize_t start[3];
misize_t count[3];
start[0] = slice_number; start[1] = 0; start[2] = 0;
count[0] = 1; count[1] = sizes[1]; count[2] = sizes[2];
result = miget_real_value_hyperslab(hmask, MI_TYPE_DOUBLE,
start, count, mask_buffer);
if (result != MI_NOERROR) {
error("Error getting mask slice %d.\n", slice_number);
}
}
/* get a real value hyperslab from file */
SEXP get_hyperslab2( SEXP filename, SEXP start, SEXP count, SEXP slab) {
int result;
mihandle_t hvol;
int i;
misize_t tmp_start[3];
misize_t tmp_count[3];
/*
char **c_filename;
int *c_start;
int *c_count;
double *c_slab;
*/
/* open the volume */
Rprintf("Crap %s\n", CHAR(STRING_ELT(filename, 0)));
result = miopen_volume(CHAR(STRING_ELT(filename,0)),
MI2_OPEN_READ, &hvol);
if (result != MI_NOERROR) {
error("Error opening input file: %s.\n", CHAR(STRING_ELT(filename,0)));
}
for (i=0; i < 3; i++) {
tmp_start[i] = (unsigned long) INTEGER(start)[i];
tmp_count[i] = (unsigned long) INTEGER(count)[i];
}
/* get the hyperslab */
Rprintf("Start: %i %i %i\n", INTEGER(start)[0], INTEGER(start)[1], INTEGER(start)[2]);
Rprintf("Count: %i %i %i\n", INTEGER(count)[0], INTEGER(count)[1], INTEGER(count)[2]);
if (miget_real_value_hyperslab(hvol,
MI_TYPE_DOUBLE,
tmp_start,
tmp_count,
REAL(slab))
< 0) {
error("Could not get hyperslab.\n");
}
return(slab);
}
/* get a real value hyperslab from file */
void get_hyperslab(char **filename, int *start, int *count, double *slab) {
int result;
mihandle_t hvol;
int i;
unsigned long tmp_start[3];
unsigned long tmp_count[3];
/* open the volume */
result = miopen_volume(filename[0],
MI2_OPEN_READ, &hvol);
if (result != MI_NOERROR) {
error("Error opening input file: %s.\n", filename[0]);
}
for (i=0; i < 3; i++) {
tmp_start[i] = (unsigned long) start[i];
tmp_count[i] = (unsigned long) count[i];
}
/* get the hyperslab */
//Rprintf("Start: %i %i %i\n", start[0], start[1], start[2]);
//Rprintf("Count: %i %i %i\n", count[0], count[1], count[2]);
if (miget_real_value_hyperslab(hvol,
MI_TYPE_DOUBLE,
(misize_t *) tmp_start,
(misize_t *) tmp_count,
slab)
< 0) {
error("Could not get hyperslab.\n");
}
// Close the volume, to free handle
result = miclose_volume(hvol);
if (result != MI_NOERROR) {
error("Error closing file: %s.\n", filename[0]);
}
return;
}
void fill_slice_buffer(SEXP filenames,
misize_t *sizes,
mihandle_t *hvol,
double **buffer,
int slice_number) {
int num_files, result, i;
misize_t start[3];
misize_t count[3];
//Rprintf("Sizes in fill_slice: %d %d %d\n",
//sizes[0], sizes[1], sizes[2]);
Rprintf("%d ", slice_number);
start[0] = slice_number; start[1] = 0; start[2] = 0;
count[0] = (misize_t) 1;
count[1] = sizes[1];
count[2] = sizes[2];
//count[1] = 1;
//count[2] = 1;
num_files = LENGTH(filenames);
for (i=0; i < num_files; i++) {
//Rprintf("buffer: %p\n", buffer[0]);
//Rprintf("fill_slice_buffer: f %d, start %lu %lu %lu, count %lu %lu %lu\n",
//i, start[0], start[1], start[2],
//count[0], count[1], count[2]);
result = miget_real_value_hyperslab(hvol[i],
MI_TYPE_DOUBLE,
start,
count,
buffer[i]);
//Rprintf("hs results: %d\n", result);
if (result != MI_NOERROR) {
error("Error getting data from slice %d.\n", slice_number);
}
}
}
int main(int argc, char **argv)
{
mihandle_t vol;
midimhandle_t dim[NDIMS];
unsigned int sizes[NDIMS];
unsigned long start[NDIMS];
unsigned long count[NDIMS];
unsigned long howfar[NDIMS];
unsigned long location[NDIMS];
double *buffer,value;
int r = 0;
static char *dimorder[] = {"xspace", "yspace", "zspace"};
printf("Creating image with slice scaling!! \n");
create_test_file();
printf("Opening hyperslab-test2.mnc! \n");
r = miopen_volume("hyperslab-test2.mnc", MI2_OPEN_READ, &vol);
if (r < 0) {
TESTRPT("failed to open image", r);
}
#ifdef APPARENTORDER
/* set the apparent dimension order to be xyz */
r = miset_apparent_dimension_order_by_name(vol, 3, dimorder);
/* get the apparent dimensions and their sizes */
r = miget_volume_dimensions( vol, MI_DIMCLASS_SPATIAL,
MI_DIMATTR_ALL, MI_DIMORDER_APPARENT,
3, dim);
r = miget_dimension_sizes( dim, 3, sizes );
#else
/* get the apparent dimensions and their sizes */
r = miget_volume_dimensions( vol, MI_DIMCLASS_SPATIAL,
MI_DIMATTR_ALL, MI_DIMORDER_FILE,
3, dim);
r = miget_dimension_sizes( dim, 3, sizes );
#endif
if (r == MI_NOERROR) {
printf("Sizes: %d, %d, %d\n", sizes[0], sizes[1], sizes[2]);
}
else {
fprintf(stderr, "Error getting dimension sizes\n");
}
/* try to play with hyperslab functions!! */
start[0] = 4;
start[1] = 3;
start[2] = 5;
howfar[0] = 120;
howfar[1] = 180;
howfar[2] = 110;
count[0] = howfar[0] - start[0];
count[1] = howfar[1] - start[1];
count[2] = howfar[2] - start[2];
/* Alocate memory for the hyperslab*/
buffer = (double *)malloc(count[0] * count[1] * count[2] * sizeof(double));
if (buffer == NULL) {
fprintf(stderr, "Error allocation memory.\n");
exit(-1);
}
/* Get real value hyperslab*/
printf("\n");
printf("Getting a real value hyperslab \n");
printf("Starting at %d, %d, %d \n", start[0], start[1], start[2]);
printf("Extending to %d, %d, %d \n", howfar[0], howfar[1], howfar[2]);
printf("\n");
if (miget_real_value_hyperslab(vol,MI_TYPE_DOUBLE, start, count, buffer)
< 0) {
fprintf(stderr, "Could not get hyperslab.\n");
exit(-1);
}
/* set an arbitrary location to print values from */
location[0] = 70;
location[1] = 100;
location[2] = 104;
printf("Test arbitrary location %d, %d, %d \n",
location[0], location[1], location[2]);
miget_real_value(vol, location, 3, &value);
printf("Test from hyperslab: %f \n",
*( buffer + (location[0] - start[0])*count[1]*count[2] +
(location[1]- start[1]) * count[2] + (location[2]- start[2])));
printf("Test from voxel scaled: %f\n", value);
miget_voxel_value(vol, location, 3, &value);
printf("Test voxel value itself: %f\n", value);
printf("\n");
printf("HMMMMMMMMMM! let's try something else \n");
printf("\n");
/* set another arbitrary location to print values from */
location[0] = 104;
location[1] = 100;
location[2] = 70;
printf("Test arbitrary location %d, %d, %d \n",
location[0], location[1], location[2]);
miget_real_value(vol, location, 3, &value);
printf("Test from hyperslab: %f \n",
*( buffer + (location[0] - start[0])*count[1]*count[2] +
(location[1]- start[1]) * count[2] + (location[2]- start[2])));
printf("Test from voxel scaled: %f\n", value);
miget_voxel_value(vol, location, 3, &value);
printf("Test voxel value itself: %f\n", value);
/* close volume*/
miclose_volume(vol);
if (error_cnt != 0) {
fprintf(stderr, "%d error%s reported\n",
error_cnt, (error_cnt == 1) ? "" : "s");
}
else {
fprintf(stderr, "\n No errors\n");
}
return (error_cnt);
}
SEXP minc2_apply(SEXP filenames, SEXP fn, SEXP have_mask,
SEXP mask, SEXP mask_value, SEXP rho) {
int result;
mihandle_t *hvol, hmask;
int i, v0, v1, v2, output_index, buffer_index;
unsigned long start[3], count[3];
//unsigned long location[3];
int num_files;
double *xbuffer, *xoutput, **full_buffer;
double *xhave_mask, *xmask_value;
double *mask_buffer;
midimhandle_t dimensions[3];
misize_t sizes[3];
SEXP output, buffer;
//SEXP R_fcall;
/* allocate memory for volume handles */
num_files = LENGTH(filenames);
hvol = malloc(num_files * sizeof(mihandle_t));
Rprintf("Number of volumes: %i\n", num_files);
/* open the mask - if so desired */
xhave_mask = REAL(have_mask);
if (xhave_mask[0] == 1) {
result = miopen_volume(CHAR(STRING_ELT(mask, 0)),
MI2_OPEN_READ, &hmask);
if (result != MI_NOERROR) {
error("Error opening mask: %s.\n", CHAR(STRING_ELT(mask, 0)));
}
}
/* get the value inside that mask */
xmask_value = REAL(mask_value);
/* open each volume */
for(i=0; i < num_files; i++) {
result = miopen_volume(CHAR(STRING_ELT(filenames, i)),
MI2_OPEN_READ, &hvol[i]);
if (result != MI_NOERROR) {
error("Error opening input file: %s.\n", CHAR(STRING_ELT(filenames,i)));
}
}
/* get the file dimensions and their sizes - assume they are the same*/
miget_volume_dimensions( hvol[0], MI_DIMCLASS_SPATIAL,
MI_DIMATTR_ALL, MI_DIMORDER_FILE,
3, dimensions);
result = miget_dimension_sizes( dimensions, 3, sizes );
Rprintf("Volume sizes: %i %i %i\n", sizes[0], sizes[1], sizes[2]);
/* allocate the output buffer */
PROTECT(output=allocVector(REALSXP, (sizes[0] * sizes[1] * sizes[2])));
xoutput = REAL(output);
/* allocate the local buffer that will be passed to the function */
PROTECT(buffer=allocVector(REALSXP, num_files));
xbuffer = REAL(buffer);
//PROTECT(R_fcall = lang2(fn, R_NilValue));
/* allocate first dimension of the buffer */
full_buffer = malloc(num_files * sizeof(double));
/* allocate second dimension of the buffer
- big enough to hold one slice per subject at a time */
for (i=0; i < num_files; i++) {
full_buffer[i] = malloc(sizes[1] * sizes[2] * sizeof(double));
}
/* allocate buffer for mask - if necessary */
if (xhave_mask[0] == 1) {
mask_buffer = malloc(sizes[1] * sizes[2] * sizeof(double));
}
/* set start and count. start[0] will change during the loop */
start[0] = 0; start[1] = 0; start[2] = 0;
count[0] = 1; count[1] = sizes[1]; count[2] = sizes[2];
/* loop across all files and voxels */
Rprintf("In slice \n");
for (v0=0; v0 < sizes[0]; v0++) {
start[0] = v0;
for (i=0; i < num_files; i++) {
if (miget_real_value_hyperslab(hvol[i],
MI_TYPE_DOUBLE,
(misize_t *) start,
(misize_t *) count,
full_buffer[i]) )
error("Error opening buffer.\n");
}
/* get mask - if desired */
if (xhave_mask[0] == 1) {
if (miget_real_value_hyperslab(hmask,
MI_TYPE_DOUBLE,
(misize_t *) start,
(misize_t *) count,
mask_buffer) )
error("Error opening mask buffer.\n");
}
Rprintf(" %d ", v0);
for (v1=0; v1 < sizes[1]; v1++) {
for (v2=0; v2 < sizes[2]; v2++) {
output_index = v0*sizes[1]*sizes[2]+v1*sizes[2]+v2;
buffer_index = sizes[2] * v1 + v2;
/* only perform operation if not masked */
if(xhave_mask[0] == 0
|| (xhave_mask[0] == 1 &&
mask_buffer[buffer_index] > xmask_value[0] -0.5 &&
mask_buffer[buffer_index] < xmask_value[0] + 0.5)) {
for (i=0; i < num_files; i++) {
// location[0] = v0;
// location[1] = v1;
// location[2] = v2;
//SET_VECTOR_ELT(buffer, i, full_buffer[i][index]);
//result = miget_real_value(hvol[i], location, 3, &xbuffer[i]);
xbuffer[i] = full_buffer[i][buffer_index];
//Rprintf("V%i: %f\n", i, full_buffer[i][index]);
}
/* install the variable "x" into environment */
defineVar(install("x"), buffer, rho);
//SETCADDR(R_fcall, buffer);
//SET_VECTOR_ELT(output, index, eval(R_fcall, rho));
//SET_VECTOR_ELT(output, index, test);
/* evaluate the function */
xoutput[output_index] = REAL(eval(fn, rho))[0];
}
else {
xoutput[output_index] = 0;
}
}
}
}
Rprintf("\nDone\n");
/* free memory */
for (i=0; i<num_files; i++) {
miclose_volume(hvol[i]);
free(full_buffer[i]);
}
free(full_buffer);
UNPROTECT(2);
/* return the results */
return(output);
}
