int create_2D_image(void)
{
int r,i;
midimhandle_t hdim[NDIMS-1];
mihandle_t hvol;
short *buf = (short *)malloc(CX * CY * sizeof(short));
double *offsets = (double *)malloc(CX * sizeof(double));
double start_values[NDIMS-1]={-1.01, -2.02};
miboolean_t flag=0;
long count[NDIMS-1];
long start[NDIMS-1];
r = micreate_dimension("xspace", MI_DIMCLASS_SPATIAL, MI_DIMATTR_NOT_REGULARLY_SAMPLED, CX, &hdim[0]);
r = micreate_dimension("yspace", MI_DIMCLASS_USER, MI_DIMATTR_REGULARLY_SAMPLED, CY, &hdim[1]);
for(i=0; i < CX; i++)
{
offsets[i] = (i * i) + 0.1;
}
r = miset_dimension_offsets(hdim[0], CX, 0, offsets);
r = miset_dimension_separation(hdim[1], 0.06);
r = miset_dimension_starts(hdim, NDIMS-1, start_values);
r = micreate_volume("2D_image.mnc", NDIMS-1 , hdim, MI_TYPE_SHORT,
MI_CLASS_REAL, NULL, &hvol);
/* set slice scaling flag to true */
r = miset_slice_scaling_flag(hvol, flag);
r = micreate_volume_image(hvol);
for (i = 0; i < CX*CY; i++) {
buf[i] = (short) i * 0.1;
}
start[0] = start[1] = 0;
count[0] = CX; count[1] = CY;
r = miset_voxel_value_hyperslab(hvol, MI_TYPE_SHORT, start, count, buf);
r = miclose_volume(hvol);
return r<0?1:0;
}
int
main(int argc, char *argv[])
{
int r;
const char **file_list = NULL; /* List of file names */
struct vff_attrs vffattrs;
struct mnc_vars mnc2;
char out_str[1024]; /* Big string for filename */
midimhandle_t hdim[MAX_VFF_DIMS];
mihandle_t hvol;
double mnc_vrange[2]; /* MINC valid min/max */
int num_file_args; /* Number of files on command line */
string_t out_dir; /* Output directory */
int length;
struct stat st;
int ifile;
int num_files; /* Total number of files */
int is_file=0;
int is_list=0;
int ival;
char *extension;
mnc2.mnc_srange[0]= -1;
mnc2.mnc_srange[1]= -1;
G.pname = argv[0]; /* get program name */
G.dirname = NULL;
G.little_endian = 1; /*default is little endian unless otherwise*/
G.minc_history = time_stamp(argc, argv); /* Create minc history string */
if (ParseArgv(&argc, argv, argTable, 0) || argc < 2) {
usage();
exit(EXIT_FAILURE);
}
if (G.dirname != NULL) {
#if HAVE_DIRENT_H
if (stat(G.dirname, &st) != 0 || !S_ISDIR(st.st_mode)) {
fprintf(stderr,"Option -addattrs requires directory as argument!!!\n");
exit(EXIT_FAILURE);
}
#endif
}
if (G.List)
{
num_file_args = argc - 1;
}
else
{
strcpy(out_str, argv[1]);
extension = strrchr(out_str, '.');
if (extension != NULL )
{
extension++;
if (strcmp(extension, "mnc") !=0)
{
usage();
exit(EXIT_FAILURE);
}
}
if (argc == 3)
{
/* check if last argument is dir */
num_file_args = argc - 2;
strcpy(out_dir, argv[argc - 1]);
/* make sure path ends with slash
*/
length = strlen(out_dir);
if (out_dir[length - 1] != '/')
{
out_dir[length++] = '/';
out_dir[length++] = '\0';
}
if (stat(out_dir, &st) != 0 || !S_ISDIR(st.st_mode))
{/* assume filename */
is_file =1;
}
}
else
{ //list of 2d files must check!
num_file_args = argc - 2;
is_list = 1;
}
}
if (!is_file || G.List)
{
/* Get space for file lists */
/* Allocate the array of pointers used to implement the
* list of filenames.
*/
file_list = malloc(1 * sizeof(char *));
CHKMEM(file_list);
/* Go through the list of files, expanding directories where they
* are encountered...
*/
num_files = 0;
for (ifile = 1 ; ifile <= num_file_args; ifile++)
{
#if HAVE_DIRENT_H
if (stat(argv[ifile + 1], &st) == 0 && S_ISDIR(st.st_mode))
{
DIR *dp;
struct dirent *np;
char *tmp_str;
length = strlen(argv[ifile + 1]);
dp = opendir(argv[ifile + 1]);
if (dp != NULL)
{
while ((np = readdir(dp)) != NULL)
{
/* Generate the full path to the file.
*/
tmp_str = malloc(length + strlen(np->d_name) + 2);
strcpy(tmp_str, argv[ifile + 1]);
if (tmp_str[length-1] != '/')
{
tmp_str[length] = '/';
tmp_str[length+1] = '\0';
}
strcat(&tmp_str[length], np->d_name);
if (stat(tmp_str, &st) == 0 && S_ISREG(st.st_mode))
{
file_list = realloc(file_list,
(num_files + 1) * sizeof(char *));
file_list[num_files++] = tmp_str;
}
else
{
free(tmp_str);
}
}
closedir(dp);
}
else
{
fprintf(stderr, "Error opening directory '%s'\n",
argv[ifile + 1]);
}
}
else
{
file_list = realloc(file_list, (num_files + 1) * sizeof(char *));
file_list[num_files++] = strdup(argv[ifile + 1]);
}
#else
file_list = realloc(file_list, (num_files + 1) * sizeof(char *));
file_list[num_files++] = strdup(argv[ifile + 1]);
#endif
}
}
if (G.List)
{
exit(EXIT_SUCCESS);
}
if (is_file)
{
read_3Dvff_file_header(argv[2],&mnc2,&vffattrs);
}
else
{
read_2Dvff_files_header(file_list,num_files,&mnc2,&vffattrs);
}
/* ok starting to create minc2.0 file assuming 3D must take care of 2D*/
r = micreate_dimension("zspace", MI_DIMCLASS_SPATIAL,
MI_DIMATTR_REGULARLY_SAMPLED, mnc2.mnc_count[2], &hdim[0]);
if (r != 0) {
TESTRPT("failed create_dimension zspace", r);
return (1);
}
r = micreate_dimension("yspace", MI_DIMCLASS_SPATIAL,
MI_DIMATTR_REGULARLY_SAMPLED, mnc2.mnc_count[1], &hdim[1]);
if (r != 0) {
TESTRPT("failed create_dimension yspace", r);
return (1);
}
r = micreate_dimension("xspace", MI_DIMCLASS_SPATIAL,
MI_DIMATTR_REGULARLY_SAMPLED, mnc2.mnc_count[0], &hdim[2]);
if (r != 0) {
TESTRPT("failed create_dimension xspace", r);
return (1);
}
r = miset_dimension_start(hdim[0], mnc2.mnc_starts[2]);
if (r < 0) {
TESTRPT("failed dimension start xspace", r);
return (1);
}
r = miset_dimension_start(hdim[1], mnc2.mnc_starts[1]);
if (r < 0) {
TESTRPT("failed dimension start yspace", r);
return (1);
}
/* create negative start for xspace to correct orientation */
r = miset_dimension_start(hdim[2], mnc2.mnc_starts[0] * -1);
if (r < 0) {
TESTRPT("failed dimension start zspace", r);
return (1);
}
/* create negative spacing for zspace to correct orientation */
r = miset_dimension_separation(hdim[0], mnc2.mnc_steps[2] * -1);
if (r < 0) {
TESTRPT("failed dimension separation xspace", r);
return (1);
}
/* create negative spacing for yspace to correct orientation */
r = miset_dimension_separation(hdim[1], mnc2.mnc_steps[1] * -1);
if (r < 0) {
TESTRPT("failed dimension separation yspace", r);
return (1);
}
r = miset_dimension_separation(hdim[2], mnc2.mnc_steps[0]);
if (r < 0) {
TESTRPT("failed dimension separation zspace", r);
return (1);
}
r = micreate_volume(out_str,MAX_VFF_DIMS, hdim, mnc2.mnc_type,
MI_CLASS_REAL, NULL, &hvol);
if (r != 0) {
TESTRPT("error creating volume", r);
return (1);
}
r = micreate_volume_image(hvol);
if (r != 0) {
TESTRPT("error creating volume", r);
return (1);
}
// read image slice by slice
if (is_file)
{
read_3Dvff_file_image(hvol, argv[2], mnc2, vffattrs, mnc_vrange);
}
else
{
read_2Dvff_files_image(hvol,file_list,num_files, mnc2, vffattrs, mnc_vrange);
}
miset_volume_valid_range(hvol,mnc_vrange[1], mnc_vrange[0]);
if (mnc2.mnc_srange[0] == -1 || mnc2.mnc_srange[1] == -1) {
/* min and max are not specified in the file
voxel range is set same as real range */
mnc2.mnc_srange[0] = mnc_vrange[0];
mnc2.mnc_srange[1] = mnc_vrange[1];
}
miset_volume_range(hvol,mnc2.mnc_srange[1], mnc2.mnc_srange[0]);
if (is_file) {
/* create minc history 3D */
strcat(vffattrs.cmd_line,G.minc_history);
G.minc_history = vffattrs.cmd_line;
/* attributes from vff file itself 3D case*/
add_vff_attribute_to_file(hvol,&vffattrs);
}
if (G.dirname != NULL) {
/* attributes from external files 3D case*/
add_attributes_from_files(hvol);
}
else if (!is_file) {
/* just afew attributes from 2D case */
ival = vffattrs.year;
r = miset_attr_values(hvol, MI_TYPE_INT, "study",
MIstart_year,1 , &ival);
if (r < 0) {
TESTRPT("failed to add date:year attribute", r);
}
ival = vffattrs.month;
r = miset_attr_values(hvol, MI_TYPE_INT, "study",
MIstart_month,1 , &ival);
if (r < 0) {
TESTRPT("failed to add date:month attribute", r);
}
ival = vffattrs.day;
r = miset_attr_values(hvol, MI_TYPE_INT, "study",
MIstart_day,1 , &ival);
if (r < 0) {
TESTRPT("failed to add date:day attribute", r);
}
}
/* add history attribute */
r = miadd_history_attr(hvol,strlen(G.minc_history), G.minc_history);
if (r < 0) {
TESTRPT("error creating history", r);
return (1);
}
if (file_list != NULL) {
free_list(num_files, file_list);
free(file_list);
}
miclose_volume(hvol);
exit(EXIT_SUCCESS);
}
int main(void)
{
mihandle_t vol;
int r;
midimhandle_t dim[NDIMS];
int n;
misize_t coords[NDIMS];
misize_t count[NDIMS];
int i,j,k;
double offset;
unsigned int voxel;
/* Write data one voxel at a time. */
for (i = 0; i < NDIMS; i++) {
count[i] = 1;
}
r = micreate_dimension("time", MI_DIMCLASS_TIME,
MI_DIMATTR_NOT_REGULARLY_SAMPLED, CT, &dim[0]);
if (r < 0) {
TESTRPT("failed", r);
}
for (i = 0; i < CT; i++) {
offset = (i * i) + 100.0;
r = miset_dimension_offsets(dim[0], 1, i, &offset);
if (r < 0) {
TESTRPT("failed", r);
}
}
r = micreate_dimension("xspace",MI_DIMCLASS_SPATIAL,
MI_DIMATTR_REGULARLY_SAMPLED, CX, &dim[1]);
if (r < 0) {
TESTRPT("failed", r);
}
r = miset_dimension_start(dim[1], XSTART);
if (r < 0) {
TESTRPT("failed", r);
}
r = miset_dimension_separation(dim[1], XSTEP);
if (r < 0) {
TESTRPT("failed", r);
}
r = micreate_dimension("yspace",MI_DIMCLASS_SPATIAL,
MI_DIMATTR_REGULARLY_SAMPLED, CY, &dim[2]);
if (r < 0) {
TESTRPT("failed", r);
}
r = miset_dimension_start(dim[2], YSTART);
if (r < 0) {
TESTRPT("failed", r);
}
r = miset_dimension_separation(dim[2], YSTEP);
if (r < 0) {
TESTRPT("failed", r);
}
r = micreate_dimension("zspace",MI_DIMCLASS_SPATIAL,
MI_DIMATTR_REGULARLY_SAMPLED, CZ, &dim[3]);
if (r < 0) {
TESTRPT("failed", r);
}
r = miset_dimension_start(dim[3], ZSTART);
if (r < 0) {
TESTRPT("failed", r);
}
r = miset_dimension_separation(dim[3], ZSTEP);
if (r < 0) {
TESTRPT("failed", r);
}
r = micreate_volume("tst-dim.mnc", NDIMS, dim, MI_TYPE_UINT,
MI_CLASS_REAL, NULL, &vol);
if (r < 0) {
TESTRPT("failed", r);
}
r = micreate_volume_image(vol);
if (r < 0) {
TESTRPT("failed", r);
}
check_dims(vol, dim);
for (i = 0; i < CX; i++) {
for (j = 0; j < CY; j++) {
for (k = 0; k < CZ; k++) {
coords[0] = 0;
coords[1] = i;
coords[2] = j;
coords[3] = k;
voxel = (i*10000)+(j*100)+k;
r = miset_voxel_value_hyperslab(vol,
MI_TYPE_UINT,
coords,
count,
&voxel);
if (r < 0) {
TESTRPT("Error writing voxel", r);
}
}
}
}
r = miclose_volume(vol);
if (r < 0) {
TESTRPT("failed", r);
}
/***** 03-Aug-2004: Added two tests for bugs reported by Leila */
r = miopen_volume("tst-dim.mnc", MI2_OPEN_RDWR, &vol);
if (r < 0) {
TESTRPT("failed", r);
}
r = miget_volume_dimension_count(vol, MI_DIMCLASS_ANY,
MI_DIMATTR_REGULARLY_SAMPLED, &n);
if (r < 0) {
TESTRPT("failed", r);
}
if (n != NDIMS - 1) {
TESTRPT("wrong result", n);
}
r = miget_volume_dimension_count(vol, MI_DIMCLASS_ANY,
MI_DIMATTR_NOT_REGULARLY_SAMPLED, &n);
if (r < 0) {
TESTRPT("failed", r);
}
if (n != 1) {
TESTRPT("wrong result", n);
}
r = miclose_volume(vol);
if (r < 0) {
TESTRPT("failed", r);
}
/* Test #2 - verify that we don't print anything scary if a user
* closes a volume prematurely.
*/
r = micreate_dimension("xspace",MI_DIMCLASS_SPATIAL,
MI_DIMATTR_REGULARLY_SAMPLED, CX, &dim[0]);
if (r < 0) {
TESTRPT("failed", r);
}
r = micreate_dimension("yspace",MI_DIMCLASS_SPATIAL,
MI_DIMATTR_REGULARLY_SAMPLED, CY, &dim[1]);
if (r < 0) {
TESTRPT("failed", r);
}
r = micreate_dimension("zspace",MI_DIMCLASS_SPATIAL,
MI_DIMATTR_REGULARLY_SAMPLED, CZ, &dim[2]);
if (r < 0) {
TESTRPT("failed", r);
}
r = micreate_volume("tst-vol.mnc", 3, dim, MI_TYPE_SHORT,
MI_CLASS_LABEL, NULL, &vol);
if (r < 0) {
TESTRPT("failed", r);
}
r = miclose_volume(vol);
if (r < 0) {
TESTRPT("failed", r);
}
/** End of tests added 03-Aug-2004 **/
if (error_cnt != 0) {
fprintf(stderr, "%d error%s reported\n",
error_cnt, (error_cnt == 1) ? "" : "s");
}
else {
fprintf(stderr, "No errors\n");
}
return (error_cnt);
}
