Mercurial > hg > minc-tools

changeset 28:370a5c093eba

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Extended image dimension conversion to arbitrary dimension. Fixed some bugs in dimension conversion.
author neelin <neelin>
date Tue, 01 Dec 1992 14:01:18 +0000
parents de46a5b67d64
children 47c908ca190a
files libsrc/dim_conversion.c libsrc/image_conversion.c
diffstat 2 files changed, 151 insertions(+), 84 deletions(-) [+]
line wrap: on
line diff
--- a/libsrc/dim_conversion.c
+++ b/libsrc/dim_conversion.c
@@ -19,6 +19,10 @@
 @MODIFIED   : 
 ---------------------------------------------------------------------------- */
 
+#ifndef lint
+static char rcsid[] = "$Header: /private-cvsroot/minc/libsrc/dim_conversion.c,v 1.5 1992-12-01 14:01:18 neelin Exp $ MINC (MNI)";
+#endif
+
 #include <type_limits.h>
 #include <minc_private.h>
 
@@ -42,7 +46,7 @@
 public int miicv_attach(int icvid, int cdfid, int varid)
 {
    mi_icv_type *icvp;         /* Pointer to icv structure */
-   long size_diff;
+   long size_diff, user_dim_size;
    int idim;
 
    MI_SAVE_ROUTINE_NAME("miicv_attach");
@@ -72,7 +76,7 @@
       or offset, or if we have to convert from vector to scalar. */
 
    icvp->do_dimconvert = (icvp->user_do_scalar && icvp->var_is_vector);
-   for (idim=0; idim<MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim<icvp->user_num_imgdims; idim++) {
       if (icvp->derv_dim_flip[idim] || (icvp->derv_dim_scale[idim] != 1) ||
           (icvp->derv_dim_off[idim] != 0))
          icvp->do_dimconvert = TRUE;
@@ -81,12 +85,15 @@
 
    /* Check if we have to zero user's buffer on GETs */
    icvp->derv_do_zero = FALSE;
-   for (idim=0; idim<MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim<icvp->user_num_imgdims; idim++) {
+      user_dim_size = ((icvp->user_dim_size[idim]<=0) ? 
+                       icvp->var_dim_size[idim] :
+                       icvp->user_dim_size[idim]);
       if (icvp->derv_dim_grow[idim])
-         size_diff = icvp->user_dim_size[idim] -
+         size_diff = user_dim_size -
                      icvp->var_dim_size[idim] * icvp->derv_dim_scale[idim];
       else
-         size_diff = icvp->user_dim_size[idim] - 1 -
+         size_diff = user_dim_size - 1 -
                      (icvp->var_dim_size[idim] - 1)
                         / icvp->derv_dim_scale[idim];
       if ((icvp->derv_dim_off[idim]!=0) || (size_diff!=0))
@@ -120,13 +127,13 @@
    int oldncopts;             /* For saving value of ncopts */
    char dimname[MAX_NC_NAME]; /* Dimensions name */
    int idim;                  /* Looping counter for fastest image dims */
-   int subsc[MI_PRIV_IMGDIMS]; /* Subscripts for fastest image dims */
-   int dimvid[MI_PRIV_IMGDIMS]; /* Variable ids for dimensions */
+   int subsc[MI_MAX_IMGDIMS]; /* Subscripts for fastest image dims */
+   int dimvid[MI_MAX_IMGDIMS]; /* Variable ids for dimensions */
 
    MI_SAVE_ROUTINE_NAME("MI_icv_get_dim");
 
-   /* Check that the variable has at least MI_PRIV_IMGDIMS dimensions */
-   if (icvp->var_ndims < MI_PRIV_IMGDIMS) {
+   /* Check that the variable has at least icvp->user_num_imgdims dimensions */
+   if (icvp->var_ndims < icvp->user_num_imgdims) {
       MI_LOG_PKG_ERROR2(MI_ERR_TOOFEWDIMS, 
                        "Variable has too few dimensions to be an image");
       MI_RETURN_ERROR(MI_ERROR);
@@ -137,9 +144,9 @@
                        &(icvp->var_vector_size)))
    icvp->var_is_vector = STRINGS_EQUAL(dimname, MIvector_dimension);
 
-   /* Check that the variable has at least MI_PRIV_IMGDIMS+1 dimensions if 
-      it is a vector field */
-   if (icvp->var_is_vector && (icvp->var_ndims < MI_PRIV_IMGDIMS+1)) {
+   /* Check that the variable has at least icvp->user_num_imgdims+1 
+      dimensions if it is a vector field */
+   if (icvp->var_is_vector && (icvp->var_ndims < icvp->user_num_imgdims+1)) {
       MI_LOG_PKG_ERROR2(MI_ERR_TOOFEWDIMS, 
                         "Variable has too few dimensions to be an image");
       MI_RETURN_ERROR(MI_ERROR);
@@ -147,13 +154,13 @@
 
    /* Check for dimension flipping and get dimension sizes */
 
-   /* Get subscripts for first MI_PRIV_IMGDIMS dimensions */
+   /* Get subscripts for first icvp->user_num_imgdims dimensions */
    subsc[0] = (icvp->var_is_vector) ? icvp->var_ndims-2 : icvp->var_ndims-1;
-   for (idim=1; idim < MI_PRIV_IMGDIMS; idim++)
+   for (idim=1; idim < icvp->user_num_imgdims; idim++)
       subsc[idim]=subsc[idim-1]-1;
 
    /* Get dimension variable ids */
-   for (idim=0; idim < MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim < icvp->user_num_imgdims; idim++) {
       {MI_CHK_ERR(ncdiminq(cdfid, icvp->var_dim[subsc[idim]], dimname, 
                        &(icvp->var_dim_size[idim])))};
       oldncopts = ncopts; ncopts = 0;
@@ -207,7 +214,7 @@
 
    /* Loop through fast dimensions */
 
-   for (idim=0; idim < MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim < icvp->user_num_imgdims; idim++) {
 
       /* Get name of the dimension */
       {MI_CHK_ERR(ncdiminq(cdfid, icvp->var_dim[subsc[idim]], dimname, 
@@ -281,7 +288,7 @@
       image. (This is get-oriented: grow is TRUE if the variable dimension 
       has to be expanded to fit the user's dimensions). */
 
-   for (idim=0; idim < MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim < icvp->user_num_imgdims; idim++) {
 
       /* Check to see if we user wants resize */
       if (icvp->user_dim_size[idim] <= 0) {
@@ -337,7 +344,7 @@
    /* Loop through dimensions, resetting scale if needed, setting offset 
       and pixel step and start */
 
-   for (idim=0; idim < MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim < icvp->user_num_imgdims; idim++) {
 
       /* Check for aspect ratio */
       if (icvp->user_keep_aspect) {
@@ -436,7 +443,7 @@
    /* Check each dimension to see if we need to worry about the variable
       buffer size. This only occurs if we are shrinking the dimension from 
       the variable buffer to the user buffer. */
-   for (idim=0; idim < MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim < icvp->user_num_imgdims; idim++) {
       if (!icvp->derv_dim_grow[idim])
          icvp->derv_bufsize_step[subsc[idim]]=icvp->derv_dim_scale[idim];
       if (icvp->derv_bufsize_step[subsc[idim]] != 1)
@@ -469,7 +476,7 @@
    /* Find out whether we need to compress variable or user buffer */
    icvp->derv_var_compress = (icvp->var_is_vector && icvp->user_do_scalar);
    icvp->derv_usr_compress = FALSE;
-   for (idim=0; idim<MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim<icvp->user_num_imgdims; idim++) {
       if (icvp->derv_dim_scale[idim]!=1) {
          if (icvp->derv_dim_grow[idim])
             icvp->derv_usr_compress = TRUE;
@@ -490,7 +497,7 @@
    else
       icvp->derv_var_pix_num=1;
    icvp->derv_usr_pix_num=1;
-   for (idim=0; idim<MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim<icvp->user_num_imgdims; idim++) {
       if (icvp->derv_dim_grow[idim])
          icvp->derv_usr_pix_num *= icvp->derv_dim_scale[idim];
       else
@@ -703,8 +710,8 @@
    int idim, jdim;
    int fastdim;
    /* Variables for calculating pixel offsets for compress/expand */
-   long var_dcount[MI_PRIV_IMGDIMS+1], var_dend[MI_PRIV_IMGDIMS+1];
-   long usr_dcount[MI_PRIV_IMGDIMS+1], usr_dend[MI_PRIV_IMGDIMS+1];
+   long var_dcount[MI_MAX_IMGDIMS+1], var_dend[MI_MAX_IMGDIMS+1];
+   long usr_dcount[MI_MAX_IMGDIMS+1], usr_dend[MI_MAX_IMGDIMS+1];
    long pixcount;
    int var_fd, usr_fd, dshift;
    long ipix;
@@ -727,7 +734,7 @@
    /* Get the indices of high and low image dimensions */
    imgdim_high=icvp->var_ndims-1;
    if (icvp->var_is_vector) imgdim_high--;
-   imgdim_low = imgdim_high - MI_PRIV_IMGDIMS + 1;
+   imgdim_low = imgdim_high - icvp->user_num_imgdims + 1;
 
    /* Get the buffer sizes */
    buffer_len = icvp->var_typelen;
@@ -750,10 +757,10 @@
          * icvp->derv_icv_count[idim+1];
    }
 
-   /* Set sign of buffer steps for flipping, if needed */
+   /* Set sign of user steps for flipping, if needed */
    for (idim=imgdim_low; idim <= imgdim_high; idim++) {
       if (icvp->derv_dim_flip[imgdim_high-idim])
-         dcp->buf_step[idim] *= (-1);
+         dcp->usr_step[idim] *= (-1);
    }
 
    /* Get the pointers to the start of buffers and the number of pixels
@@ -774,37 +781,43 @@
          if (icvp->derv_dim_grow[jdim]) {
             dcp->end[idim] = bufcount[idim];
             buffer_index = 0;
-            values_index = bufstart[idim]*scale - icvp->derv_icv_start[idim] 
-               + offset;
+            if (!icvp->derv_dim_flip[jdim])
+               values_index = bufstart[idim]*scale
+                  - icvp->derv_icv_start[idim] + offset;
+            else
+               values_index = 
+                  (icvp->var_dim_size[jdim] - bufstart[idim])*scale
+                  - 1 - icvp->derv_icv_start[idim] + offset;
          }
          else {
             dcp->end[idim] = (bufcount[idim] - 1 + bufstart[idim]%scale) 
                                      / scale + 1; 
             buffer_index = -(bufstart[idim] % scale);
-            values_index = bufstart[idim]/scale - icvp->derv_icv_start[idim]
-               + offset;
+            if (!icvp->derv_dim_flip[jdim])
+               values_index = bufstart[idim]/scale
+                  - icvp->derv_icv_start[idim] + offset;
+            else
+               values_index = 
+                  (icvp->var_dim_size[jdim] - bufstart[idim] - 1)/scale
+                  - icvp->derv_icv_start[idim] + offset;
          }
-         /* Change index for flipping, if needed. Note that buf_step will
-            be negative if flipping is needed. */
-         if (icvp->derv_dim_flip[jdim])
-            buffer_index -= (bufcount[idim]-1);
       }
-      buffer_off += buffer_index * dcp->buf_step[idim];
-      values_off += values_index * dcp->usr_step[idim];
+      buffer_off += buffer_index * ABS(dcp->buf_step[idim]);
+      values_off += values_index * ABS(dcp->usr_step[idim]);
    }
 
    /* Calculate arrays of offsets for compress/expand. */
    if (dcp->do_compress || dcp->do_expand) {
       /* Initialize counters */
-      var_fd = MI_PRIV_IMGDIMS-1;
-      usr_fd = MI_PRIV_IMGDIMS-1;
+      var_fd = icvp->user_num_imgdims-1;
+      usr_fd = icvp->user_num_imgdims-1;
       if (icvp->var_is_vector && icvp->user_do_scalar) {
          var_fd++;
          var_dcount[var_fd]=0;
          var_dend[var_fd]=icvp->var_vector_size;
       }
-      for (jdim=0; jdim<MI_PRIV_IMGDIMS; jdim++) {
-         idim=MI_PRIV_IMGDIMS - jdim - 1;
+      for (jdim=0; jdim<icvp->user_num_imgdims; jdim++) {
+         idim=icvp->user_num_imgdims - jdim - 1;
          var_dcount[idim] = 0;
          usr_dcount[idim] = 0;
          var_dend[idim] = (icvp->derv_dim_grow[jdim] ?
@@ -827,7 +840,9 @@
                idim--;
                var_dcount[idim]++;
             }
-            pixcount = var_dcount[idim] * dcp->buf_step[idim+dshift];
+            for (idim=0, pixcount=0; idim<=var_fd; idim++) {
+               pixcount += var_dcount[idim] * dcp->buf_step[idim+dshift];
+            }
          }
       }
 
@@ -844,7 +859,9 @@
                idim--;
                usr_dcount[idim]++;
             }
-            pixcount = usr_dcount[idim] * dcp->usr_step[idim+dshift];
+            for (idim=0, pixcount=0; idim<=var_fd; idim++) {
+               pixcount += usr_dcount[idim] * dcp->usr_step[idim+dshift];
+            }
          }
       }
 
--- a/libsrc/image_conversion.c
+++ b/libsrc/image_conversion.c
@@ -31,6 +31,10 @@
 @MODIFIED   : 
 ---------------------------------------------------------------------------- */
 
+#ifndef lint
+static char rcsid[] = "$Header: /private-cvsroot/minc/libsrc/image_conversion.c,v 1.6 1992-12-01 14:01:57 neelin Exp $ MINC (MNI)";
+#endif
+
 #include <type_limits.h>
 #include <minc_private.h>
 
@@ -100,8 +104,9 @@
    icvp->user_xdim_dir = MI_ICV_POSITIVE;
    icvp->user_ydim_dir = MI_ICV_POSITIVE;
    icvp->user_zdim_dir = MI_ICV_POSITIVE;
+   icvp->user_num_imgdims = 2;
    icvp->user_keep_aspect = TRUE;
-   for (idim=0; idim<MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim<MI_MAX_IMGDIMS; idim++) {
       icvp->user_dim_size[idim]=MI_ICV_ANYSIZE;
    }
 
@@ -112,7 +117,7 @@
    /* Values that can be read by user */
    icvp->derv_imgmax = MI_DEFAULT_MAX;
    icvp->derv_imgmin = MI_DEFAULT_MIN;
-   for (idim=0; idim<MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim<MI_MAX_IMGDIMS; idim++) {
       icvp->derv_dim_step[idim] = 0.0;
       icvp->derv_dim_start[idim] = 0.0;
    }
@@ -225,7 +230,7 @@
 ---------------------------------------------------------------------------- */
 public int miicv_set(int icvid, int icv_property, void *value)
 {
-   int ival;
+   int ival, idim;
    mi_icv_type *icvp;
 
    MI_SAVE_ROUTINE_NAME("miicv_set");
@@ -290,6 +295,15 @@
       icvp->user_zdim_dir = ((ival==MI_ICV_POSITIVE) || 
                              (ival==MI_ICV_NEGATIVE)) ? ival : MI_ICV_ANYDIR;
       break;
+   case MI_ICV_NUM_IMGDIMS:
+      ival = *((int *) value);
+      if ((ival<0) || (ival>MI_MAX_IMGDIMS)) {
+         MI_LOG_PKG_ERROR2(MI_ERR_BADPROP,
+                           "MI_ICV_NUM_IMGDIMS out of range");
+         MI_RETURN_ERROR(MI_ERROR);
+      }
+      icvp->user_num_imgdims = ival;
+      break;
    case MI_ICV_ADIM_SIZE:
       icvp->user_dim_size[0] = *((long *) value); break;
    case MI_ICV_BDIM_SIZE:
@@ -297,9 +311,18 @@
    case MI_ICV_KEEP_ASPECT:
       icvp->user_keep_aspect = *((int *) value); break;
    default:
-      MI_LOG_PKG_ERROR2(MI_ERR_BADPROP,
-                        "Tried to set unknown or illegal icv property");
-      MI_RETURN_ERROR(MI_ERROR);
+      /* Check for image dimension properties */
+      if ((icv_property>=MI_ICV_DIM_SIZE) && 
+          (icv_property<MI_ICV_DIM_SIZE+MI_MAX_IMGDIMS)) {
+         idim = icv_property - MI_ICV_DIM_SIZE;
+         icvp->user_dim_size[idim] = *((long *) value);
+      }
+      else {
+         MI_LOG_PKG_ERROR2(MI_ERR_BADPROP,
+                           "Tried to set unknown or illegal icv property");
+         MI_RETURN_ERROR(MI_ERROR);
+      }
+      break;
    }
 
    MI_RETURN(MI_NOERROR);
@@ -320,6 +343,7 @@
 ---------------------------------------------------------------------------- */
 public int miicv_inq(int icvid, int icv_property, void *value)
 {
+   int idim;
    mi_icv_type *icvp;
 
    MI_SAVE_ROUTINE_NAME("miicv_inq");
@@ -364,6 +388,8 @@
       *((int *) value) = icvp->user_ydim_dir; break;
    case MI_ICV_ZDIM_DIR:
       *((int *) value) = icvp->user_zdim_dir; break;
+   case MI_ICV_NUM_IMGDIMS:
+      *((int *) value) = icvp->user_num_imgdims; break;
    case MI_ICV_ADIM_SIZE:
       *((long *) value) = icvp->user_dim_size[0]; break;
    case MI_ICV_BDIM_SIZE:
@@ -379,9 +405,28 @@
    case MI_ICV_KEEP_ASPECT:
       *((int *) value) = icvp->user_keep_aspect; break;
    default:
-      MI_LOG_PKG_ERROR2(MI_ERR_BADPROP,
-                        "Tried to inquire about unknown icv property");
-      MI_RETURN_ERROR(MI_ERROR);
+      /* Check for image dimension properties */
+      if ((icv_property>=MI_ICV_DIM_SIZE) && 
+          (icv_property<MI_ICV_DIM_SIZE+MI_MAX_IMGDIMS)) {
+         idim = icv_property - MI_ICV_DIM_SIZE;
+         *((long *) value) = icvp->user_dim_size[idim];
+      }
+      else if ((icv_property>=MI_ICV_DIM_STEP) && 
+               (icv_property<MI_ICV_DIM_STEP+MI_MAX_IMGDIMS)) {
+         idim = icv_property - MI_ICV_DIM_STEP;
+         *((double *) value) = icvp->derv_dim_step[idim];
+      }
+      else if ((icv_property>=MI_ICV_DIM_START) && 
+               (icv_property<MI_ICV_DIM_START+MI_MAX_IMGDIMS)) {
+         idim = icv_property - MI_ICV_DIM_START;
+         *((double *) value) = icvp->derv_dim_start[idim];
+      }
+      else {
+         MI_LOG_PKG_ERROR2(MI_ERR_BADPROP,
+                           "Tried to inquire about unknown icv property");
+         MI_RETURN_ERROR(MI_ERROR);
+      }
+      break;
    }
 
    MI_RETURN(MI_NOERROR);
@@ -444,7 +489,7 @@
    icvp->derv_do_bufsize_step = FALSE;
    icvp->derv_var_pix_off = NULL;
    icvp->derv_usr_pix_off = NULL;
-   for (idim=0; idim<MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim<icvp->user_num_imgdims; idim++) {
       icvp->derv_dim_flip[idim] = FALSE;
       icvp->derv_dim_grow[idim] = TRUE;
       icvp->derv_dim_scale[idim] = 1;
@@ -676,10 +721,6 @@
       icvp->derv_imgmax = MI_DEFAULT_MAX;
       icvp->derv_imgmin = MI_DEFAULT_MIN;
    }
-   else if (icvp->user_user_norm) {
-      icvp->derv_imgmax = icvp->user_imgmax;
-      icvp->derv_imgmin = icvp->user_imgmin;
-   }
    else {
       /* Get image max, min variable ids */
       vid[0]=icvp->imgmaxid;
@@ -692,7 +733,8 @@
          icvp->derv_imgmin = icvp->var_vmin;
       }
 
-      /* If the variables are there then get the max and min */
+      /* If the variables are there then get the max and min and fastest 
+         varying dimension */
       else {
          immptr[0] = &(icvp->derv_imgmax);
          immptr[1] = &(icvp->derv_imgmin);
@@ -703,7 +745,6 @@
             /* Loop through dimensions, checking dimensions against image,
                getting dimension sizes and total max/min variable size */
             size=1;     /* Size of MIimagemax/min variable */
-            icvp->derv_firstdim = -1;  /* Doesn't vary with image */
             for (idim=0; idim<ndims; idim++) {
                /* Look to see where this dimension falls as an image 
                   dimension */
@@ -713,30 +754,39 @@
                }
                /* Get the dimension size */
                MI_CHK_ERR(ncdiminq(cdfid, dim[idim], NULL, &(count[idim])))
-               size *= count[i];
+               size *= count[idim];
             }
-            /* Get space */
-            if ((buffer=MALLOC(size, double))==NULL) {
-               MI_LOG_SYS_ERROR1("MI_icv_get_norm");
-               MI_RETURN_ERROR(MI_ERROR);
-            }
-            /* Get values */
-            if (mivarget(cdfid, vid[imm], 
-                         miset_coords(ndims, 0L, start),
-                         count, NC_DOUBLE, NULL, buffer)==MI_ERROR) {
+
+            /* Don't bother reading variable if user set image range */
+
+            if (!icvp->user_user_norm) {
+               /* Get space */
+               if ((buffer=MALLOC(size, double))==NULL) {
+                  MI_LOG_SYS_ERROR1("MI_icv_get_norm");
+                  MI_RETURN_ERROR(MI_ERROR);
+               }
+               /* Get values */
+               if (mivarget(cdfid, vid[imm], 
+                            miset_coords(ndims, 0L, start),
+                            count, NC_DOUBLE, NULL, buffer)==MI_ERROR) {
+                  FREE(buffer);
+                  MI_RETURN_ERROR(MI_ERROR);
+               }
+               /* Loop through values, getting max/min */
+               *immptr[imm] = buffer[0];
+               for (ientry=1; ientry<size; ientry++) {
+                  if (imm==0)
+                     *immptr[imm] = MAX(*immptr[imm], buffer[ientry]);
+                  else
+                     *immptr[imm] = MIN(*immptr[imm], buffer[ientry]);
+               }
                FREE(buffer);
-               MI_RETURN_ERROR(MI_ERROR);
-            }
-            /* Loop through values, getting max/min */
-            *immptr[imm] = buffer[0];
-            for (ientry=1; ientry<size; ientry++) {
-               if (imm==0)
-                  *immptr[imm] = MAX(*immptr[imm], buffer[ientry]);
-               else
-                  *immptr[imm] = MIN(*immptr[imm], buffer[ientry]);
-            }
-            FREE(buffer);
-         }
+            }         /* End if (!icvp->user_user_norm) */
+         }         /* End for (imm=0; imm<2; imm++) */
+      }         /* End if {} else {} no max/min vars */
+      if (icvp->user_user_norm) {
+         icvp->derv_imgmax = icvp->user_imgmax;
+         icvp->derv_imgmin = icvp->user_imgmin;
       }
    }
 
@@ -773,7 +823,7 @@
    /* Reset values that are read-only (and set when attached) */
    icvp->derv_imgmax = MI_DEFAULT_MAX;
    icvp->derv_imgmin = MI_DEFAULT_MIN;
-   for (idim=0; idim<MI_PRIV_IMGDIMS; idim++) {
+   for (idim=0; idim<MI_MAX_IMGDIMS; idim++) {
       icvp->derv_dim_step[idim] = 0.0;
       icvp->derv_dim_start[idim] = 0.0;
    }
@@ -1038,7 +1088,7 @@
    }
 
    /* Get the number of non image dimensions */
-   num_non_img_dims=icvp->var_ndims-MI_PRIV_IMGDIMS;
+   num_non_img_dims=icvp->var_ndims-icvp->user_num_imgdims;
    if (icvp->var_is_vector)
       num_non_img_dims--;
 
@@ -1049,8 +1099,8 @@
    }
 
    /* Go through image dimensions */
-   for (i=num_non_img_dims, j=MI_PRIV_IMGDIMS-1; 
-        i < num_non_img_dims+MI_PRIV_IMGDIMS; i++, j--) {
+   for (i=num_non_img_dims, j=icvp->user_num_imgdims-1; 
+        i < num_non_img_dims+icvp->user_num_imgdims; i++, j--) {
       /* Check coordinates. */
       icv_dim_size = (icvp->user_dim_size[j] > 0) ?
             icvp->user_dim_size[j] : icvp->var_dim_size[j];