/*! \fn VImage VDTDilate(VImage src,VImage dest,VDouble radius) \brief 3D morphological dilation \param src input image (bit repn) \param dest output image (bit repn) \param radius radius of the spherical structural element */ VImage VDTDilate(VImage src,VImage dest,VDouble radius) { VImage float_image; VBit *bin_pp; VFloat *float_pp; int i,nbands,nrows,ncols,npixels; if (VPixelRepn(src) != VBitRepn) VError("Input image must be of type VBit"); nbands = VImageNBands(src); nrows = VImageNRows(src); ncols = VImageNColumns(src); npixels = nbands * nrows * ncols; float_image = VChamferDist3d(src,NULL,VFloatRepn); if (! float_image) VError("VDTDilate failed.\n"); dest = VSelectDestImage("VDTDilate",dest,nbands,nrows,ncols,VBitRepn); if (! dest) return NULL; float_pp = (VFloat *) VPixelPtr(float_image,0,0,0); bin_pp = (VBit *) VPixelPtr(dest,0,0,0); for (i=0; i<npixels; i++) *bin_pp++ = ((*float_pp++ > radius) ? 0 : 1); VDestroyImage(float_image); VCopyImageAttrs (src,dest); return dest; }
VImage VImageManager::vtimestep( VAttrList list, VImage dest, int step ) { VFillImage( dest, VAllBands, 0 ); VPointer src_pp = NULL; VPointer dest_pp = NULL; VAttrListPosn posn; VShort *ptr1 = NULL; VShort *ptr2 = NULL; VString str; VImage src; int n = 0; int npixels = 0; bool revert = false; for ( VFirstAttr ( list, & posn ); VAttrExists ( & posn ); VNextAttr ( & posn ) ) { if ( VGetAttrRepn ( & posn ) != VImageRepn ) continue; VGetAttrValue ( &posn, NULL, VImageRepn, &src ); if ( VPixelRepn( src ) != VShortRepn ) continue; if ( ( VGetAttr ( VImageAttrList ( src ), "MPIL_vista_0", NULL, VStringRepn, ( VPointer ) & str ) != VAttrFound ) && ( VGetAttr ( VImageAttrList ( src ), "repetition_time", NULL, VStringRepn, ( VPointer ) & str ) != VAttrFound ) ) continue; /* doch nicht rumdrehen! if (VGetAttr (VImageAttrList (src), "extent", NULL, VStringRepn, (VPointer) & str) != VAttrFound) revert = true; */ if ( n == 0 ) VCopyImageAttrs ( src, dest ); if ( VImageNRows( src ) > 1 ) { if ( VSelectBand ( "vtimestep", src, step, &npixels, &src_pp ) == FALSE ) VError( "err reading data" ); int destBand = ( revert ) ? VImageNBands( dest ) - n - 1 : n; dest_pp = VPixelPtr( dest, destBand, 0, 0 ); ptr1 = ( VShort * ) src_pp; ptr2 = ( VShort * ) dest_pp; memcpy ( ptr2, ptr1, npixels * sizeof( VShort ) ); } n++; } return dest; }
/* ** concordance mapping */ VImage VCCM2(float *A1,float *A2,VImage map,int type) { VImage dest=NULL; size_t b,r,c,i,j,k,kk,nvoxels; int nslices=0,nrows=0,ncols=0; double *arr1=NULL,*arr2=NULL,u; nslices = VPixel(map,0,3,0,VShort); nrows = VPixel(map,0,3,1,VShort); ncols = VPixel(map,0,3,2,VShort); nvoxels = VImageNColumns(map); dest = VCreateImage(nslices,nrows,ncols,VFloatRepn); VFillImage(dest,VAllBands,0); VCopyImageAttrs (map, dest); VSetAttr(VImageAttrList(dest),"modality",NULL,VStringRepn,"conimg"); arr1 = (double *) VCalloc(nvoxels,sizeof(double)); arr2 = (double *) VCalloc(nvoxels,sizeof(double)); fprintf(stderr," concordance mapping...\n"); for (i=0; i<nvoxels; i++) { if (i%50 == 0) fprintf(stderr," %6d of %d\r",i,nvoxels); b = (int)VPixel(map,0,0,i,VShort); r = (int)VPixel(map,0,1,i,VShort); c = (int)VPixel(map,0,2,i,VShort); for (j=0; j<nvoxels; j++) arr1[j] = arr2[j] = 0; kk = 0; for (j=0; j<i; j++) { k=j+i*(i+1)/2; arr1[kk] = (double)A1[k]; arr2[kk] = (double)A2[k]; kk++; } for (j=i+1; j<nvoxels; j++) { k=i+j*(j+1)/2; arr1[kk] = (double)A1[k]; arr2[kk] = (double)A2[k]; kk++; } u = 0; switch (type) { case 0: u = kendall(arr1,arr2,nvoxels); break; case 1: u = CCC(arr1,arr2,nvoxels); break; default: VError("illegal type"); } VPixel(dest,b,r,c,VFloat) = (VFloat)u; } fprintf(stderr,"\n"); return dest; }
VImage VSelSlices (VImage src,VImage dest,VShort first,VShort last) { int nbands,nrows,ncols,nbands_neu,npixels; int i,b,bn; VRepnKind repn; nbands = VImageNBands(src); nrows = VImageNRows(src); ncols = VImageNColumns(src); repn = VPixelRepn(src); if (first < 0) VError("VSelSlices: parameter <first> must be positive"); if (last < 0) last = nbands-1; if (last >= nbands) last = nbands-1; if (first > last) VError("VSelSlices: <first> must be less than <last>."); nbands_neu = last - first + 1; if (dest == NULL) dest = VCreateImage(nbands_neu,nrows,ncols,repn); npixels = nrows * ncols; #define SelSlices(type) \ { \ type *src_pp, *dest_pp; \ bn = 0; \ for (b=first; b<=last; b++) { \ src_pp = VPixelPtr(src,b,0,0); \ dest_pp = VPixelPtr(dest,bn,0,0); \ for (i=0; i<npixels; i++) *dest_pp++ = *src_pp++; \ bn++; \ } \ } /* Instantiate the macro once for each source pixel type: */ switch (repn) { case VBitRepn: SelSlices (VBit); break; case VUByteRepn: SelSlices (VUByte); break; case VSByteRepn: SelSlices (VSByte); break; case VShortRepn: SelSlices (VShort); break; case VLongRepn: SelSlices (VLong); break; case VFloatRepn: SelSlices (VFloat); break; case VDoubleRepn: SelSlices (VDouble); break; default: ; } /* Let the destination inherit any attributes of the source image: */ VCopyImageAttrs (src, dest); return dest; }
VImage VCopyImage (VImage src, VImage dest, VBand band) { VImage result; if (src == dest && (band == VAllBands || (band == 0 && VImageNBands (src) == 1))) return src; if ((result = VCopyImagePixels (src, dest, band)) != 0) VCopyImageAttrs (src, result); return result; }
/*! \fn VImage VMapImageRange(VImage src,VImage dest,VRepnKind repn) \brief The minimum and maximum grey values of the input images are computed, and a linear mapping is performed mapping the input minimum(maximum) of the input image to the min(max) value of the output pixel repn. E.g. if the input image min is -17 and its max is +2376, and the output repn is VUByteRepn, then the linear mapping function maps -17 to 0 and +2376 to 255. \param src input image (any repn) \param dest output image \param repn the output pixel repn (e.g. VUByteRepn) */ VImage VMapImageRange(VImage src,VImage dest,VRepnKind repn) { int i,nbands,nrows,ncols,npixels; float u,ymin,ymax,dmin,dmax,slope; if (repn == VDoubleRepn || repn == VLongRepn || repn == VSByteRepn) VError(" VMapImageRange: double, long and sbyte are not supported"); nbands = VImageNBands(src); nrows = VImageNRows(src); ncols = VImageNColumns(src); npixels = VImageNPixels(src); dest = VSelectDestImage("VMapImageRange",dest,nbands,nrows,ncols,repn); if (! dest) VError(" err creating dest image"); VFillImage(dest,VAllBands,0); ymin = VPixelMaxValue(src); ymax = VPixelMinValue(src); for (i=0; i<npixels; i++) { u = VGetPixelValue (src,i); if (u < ymin) ymin = u; if (u > ymax) ymax = u; } dmax = VPixelMaxValue(dest); dmin = VPixelMinValue(dest); slope = (dmax - dmin) / (ymax - ymin); for (i=0; i<npixels; i++) { u = VGetPixelValue (src,i); u = slope * (u - ymin); if (u < dmin) u = dmin; if (u > dmax) u = dmax; VSetPixelValue(dest,i,(VFloat) u); } VCopyImageAttrs (src, dest); return dest; }
VImage ConcatDesigns(VImage *design, int nimages) { VImage dest = NULL; VString buf = NULL; VDouble x; int i, r, c, row, col; int nrows, ncols; nrows = ncols = 0; for(i = 0; i < nimages; i++) { ncols += VImageNColumns(design[i]); nrows += VImageNRows(design[i]); } dest = VCreateImage(1, nrows, ncols, VFloatRepn); VFillImage(dest, VAllBands, 0); VCopyImageAttrs(design[0], dest); VSetAttr(VImageAttrList(dest), "nsessions", NULL, VShortRepn, (VShort)nimages); buf = (VString) VMalloc(80); buf[0] = '\0'; for(i = 0; i < nimages; i++) sprintf(buf, "%s %d", buf, (int)VImageNRows(design[i])); VSetAttr(VImageAttrList(dest), "session_lengths", NULL, VStringRepn, buf); buf[0] = '\0'; for(i = 0; i < nimages; i++) sprintf(buf, "%s %d", buf, (int)VImageNColumns(design[i])); VSetAttr(VImageAttrList(dest), "session_covariates", NULL, VStringRepn, buf); row = col = 0; for(i = 0; i < nimages; i++) { for(r = 0; r < VImageNRows(design[i]); r++) { for(c = 0; c < VImageNColumns(design[i]); c++) { x = VGetPixel(design[i], 0, r, c); if(row + r >= VImageNRows(dest)) VError(" row: %d\n", row + r); if(col + c >= VImageNColumns(dest)) VError(" column: %d\n", col + c); VSetPixel(dest, 0, row + r, col + c, x); } } row += VImageNRows(design[i]); col += VImageNColumns(design[i]); } return dest; }
VImage WriteOutput(VImage src,VImage map,int nslices,int nrows, int ncols, float *ev, int n) { VImage dest=NULL; int i,b,r,c; dest = VCreateImage(nslices,nrows,ncols,VFloatRepn); VFillImage(dest,VAllBands,0); VCopyImageAttrs (src, dest); VSetAttr(VImageAttrList(dest),"modality",NULL,VStringRepn,"conimg"); for (i=0; i<n; i++) { b = VPixel(map,0,0,i,VFloat); r = VPixel(map,0,1,i,VFloat); c = VPixel(map,0,2,i,VFloat); if (b < 0 || r < 0 || c < 0) VError(" WriteOutput: illegal address %d %d %d",b,r,c); VPixel(dest,b,r,c,VFloat) = ev[i]; } return dest; }
/* * Flip3dImage * */ VImage Flip3dImage(VImage src, VImage dest, VBand band, VBoolean x_axis, VBoolean y_axis, VBoolean z_axis) { int nx, ny, nz; int i, j, k; nx = VImageNColumns(src); ny = VImageNRows(src); nz = VImageNBands(src); /* Check the destination image. If it is NULL, then create one of the appropriate size and type. */ dest = VSelectDestImage("Flip3dImage", dest, nz, ny, nx, VPixelRepn(src)); if(! dest) return NULL; for(i = 0; i < nx; i++) for(j = 0; j < ny; j++) for(k = 0; k < nz; k++) { if(! x_axis && ! y_axis && ! z_axis) VSetPixel(dest, k, j, i, VGetPixel(src, k, j, i)); if(x_axis && ! y_axis && ! z_axis) VSetPixel(dest, k, j, i, VGetPixel(src, k, j, nx - i - 1)); if(! x_axis && y_axis && ! z_axis) VSetPixel(dest, k, j, i, VGetPixel(src, k, ny - j - 1, i)); if(! x_axis && ! y_axis && z_axis) VSetPixel(dest, k, j, i, VGetPixel(src, nz - k - 1, j, i)); if(x_axis && y_axis && ! z_axis) VSetPixel(dest, k, j, i, VGetPixel(src, k, ny - j - 1, nx - i - 1)); if(x_axis && ! y_axis && z_axis) VSetPixel(dest, k, j, i, VGetPixel(src, nz - k - 1, j, nx - i - 1)); if(! x_axis && y_axis && z_axis) VSetPixel(dest, k, j, i, VGetPixel(src, nz - k - 1, ny - j - 1, i)); if(x_axis && y_axis && z_axis) VSetPixel(dest, k, j, i, VGetPixel(src, nz - k - 1, ny - j - 1, nx - i - 1)); }; /* Let the destination inherit any attributes of the source image: */ VCopyImageAttrs(src, dest); return dest; };
VImage VCreateImageLike (VImage src) { return VCopyImageAttrs (src, NULL); }
/*! \fn VImage VDTClose(VImage src,VImage dest,VDouble radius) \brief 3D morphological closing (dilation+erosion) \param src input image (bit repn) \param dest output image (bit repn) \param radius radius of the spherical structural element */ VImage VDTClose(VImage src,VImage dest,VDouble radius) { VImage float_image=NULL,tmp=NULL; VBit *bin_pp; VFloat *float_pp; int i,nbands,nrows,ncols,npixels,b,r,c; int border = 7; border = (int) (radius - 1); if (VPixelRepn(src) != VBitRepn) VError("Input image must be of type VBit"); nbands = VImageNBands(src) + 2*border; nrows = VImageNRows(src) + 2*border; ncols = VImageNColumns(src) + 2*border; npixels = nbands * nrows * ncols; tmp = VCreateImage(nbands,nrows,ncols,VBitRepn); for (b=border; b<nbands-border; b++) { for (r=border; r<nrows-border; r++) { for (c=border; c<ncols-border; c++) { VPixel(tmp,b,r,c,VBit) = VPixel(src,b-border,r-border,c-border,VBit); } } } float_image = VChamferDist3d(tmp,NULL,VFloatRepn); if (! float_image) VError("VDTClose failed.\n"); float_pp = (VFloat *) VPixelPtr(float_image,0,0,0); bin_pp = (VBit *) VPixelPtr(tmp,0,0,0); for (i=0; i<npixels; i++) *bin_pp++ = ((*float_pp++ > radius) ? 1 : 0); float_image = VChamferDist3d(tmp,float_image,VFloatRepn); if (! float_image) VError("VDTClose failed.\n"); float_pp = (VFloat *) VPixelPtr(float_image,0,0,0); bin_pp = (VBit *) VPixelPtr(tmp,0,0,0); for (i=0; i<npixels; i++) *bin_pp++ = ((*float_pp++ > radius) ? 1 : 0); VDestroyImage(float_image); dest = VSelectDestImage("VDTClose",dest,VImageNBands(src),VImageNRows(src),VImageNColumns(src), VBitRepn); if (! dest) return NULL; for (b=border; b<nbands-border; b++) { for (r=border; r<nrows-border; r++) { for (c=border; c<ncols-border; c++) { VPixel(dest,b-border,r-border,c-border,VBit) = VPixel(tmp,b,r,c,VBit); } } } VDestroyImage(tmp); VCopyImageAttrs (src, dest); return dest; }
VImage VShearImageX (VImage src, VImage dest, VBand band, double shear) { int src_nrows, src_ncols, src_nbands; int dest_nrows, dest_ncols, dest_nbands; VRepnKind src_repn, dest_repn; double skew, skewi, skewf, left, oleft; int x, y, b, src_curband, dest_curband; int extra_ncols, sdx, sdy, ddx, ddy; /* Read properties of "src": */ src_nrows = VImageNRows (src); src_ncols = VImageNColumns (src); src_nbands = VImageNBands (src); src_repn = VPixelRepn (src); /* Check to ensure that "band" exists: */ if (band != VAllBands && (band < 0 || band >= src_nbands)) { VWarning ("VShearImageY: Band %d referenced in image of %d bands", band, VImageNBands (src)); return NULL; } /* Determine properties of "dest": */ dest_nrows = src_nrows; extra_ncols = (int) floor (shear * (src_nrows - 0.5)); dest_ncols = src_ncols + VMax (extra_ncols, -extra_ncols) + 1; dest_nbands = (band == VAllBands) ? src_nbands : 1; dest_repn = src_repn; /* Calculate displacements in converting from xy-coord. to row/column-coord. : */ sdx = 0; sdy = src_nrows - 1; ddx = (extra_ncols < 0) ? -extra_ncols : 0; ddy = dest_nrows - 1; /* Create dest image */ dest = VSelectDestImage ("VShearImageX", dest, dest_nbands, dest_nrows, dest_ncols, dest_repn); if (dest == NULL) return NULL; /* Set all dest pixels to zero: */ VFillImage (dest, VAllBands, 0.0); /* Treat lower left-hand corner of image as origin, with y up and x to the right. */ /* * Shear a row of an image of a particular type: */ #define ShearRow(type) \ { \ type pixel; \ for (x = 0; x < src_ncols; x++) { \ pixel = VPixel (src, \ src_curband, \ XYToRow (x, y, sdx, sdy), \ XYToCol (x, y, sdx, sdy), \ type); \ left = pixel * skewf; \ pixel = pixel - left + oleft; \ VPixel (dest, \ dest_curband, \ XYToRow ((int) (x + skewi), y, ddx, ddy), \ XYToCol ((int) (x + skewi), y, ddx, ddy), \ type) \ = pixel; \ oleft = left; \ } \ VPixel (dest, \ dest_curband, \ XYToRow ((int) (src_ncols + skewi), y, ddx, ddy), \ XYToCol ((int) (src_ncols + skewi), y, ddx, ddy), \ type) \ = (type) oleft; \ } /* For each band in the dest image do: */ for (b = 0; b < dest_nbands; b++) { src_curband = (band == VAllBands) ? b : band; dest_curband = (band == VAllBands) ? b : 0; /* For each row in the source image do: */ for (y = 0; y < src_nrows; y++) { skew = shear * (y + 0.5); skewi = floor (skew); skewf = skew - skewi; oleft = 0.0; /* Shear a row according to pixel representation: */ switch (src_repn) { case VBitRepn: ShearRow (VBit); break; case VUByteRepn: ShearRow (VUByte); break; case VSByteRepn: ShearRow (VSByte); break; case VShortRepn: ShearRow (VShort); break; case VLongRepn: ShearRow (VLong); break; case VFloatRepn: ShearRow (VFloat); break; case VDoubleRepn: ShearRow (VDouble); break; default: break; } } } VCopyImageAttrs (src, dest); return dest; #undef ShearRow }
VImage VTopoclass(VImage src, VImage dest) { int b=0,r=0,c=0,i,u=0; int bb,rr,cc,n; int b0,b1,r0,r1,c0; int nbands,nrows,ncols; int c1,c2,c3; VBit adj[27]; VUByte v; nbands = VImageNBands(src); nrows = VImageNRows(src); ncols = VImageNColumns(src); dest = VCreateImage(nbands,nrows,ncols,VUByteRepn); for (b=0; b<nbands; b++) { for (r=0; r<nrows; r++) { for (c=0; c<ncols; c++) { VPixel(dest,b,r,c,VUByte) = 0; if (VPixel(src,b,r,c,VBit) == 0) continue; /* ** get number of connected components in N26 */ i = 0; for (bb=b-1; bb<=b+1; bb++) { for (rr=r-1; rr<=r+1; rr++) { for (cc=c-1; cc<=c+1; cc++) { if (bb >= 0 && bb < nbands && rr >= 0 && rr < nrows && cc >= 0 && cc < ncols) u = VPixel(src,bb,rr,cc,VBit); else u = 0; adj[i++] = u; } } } adj[13] = 0; c1 = VNumComp26(adj); /* ** get number of connected components in -N18 ** 6-adjacent to the center voxel */ for (i=0; i<27; i++) { u = adj[i]; adj[i] = (u > 0) ? 0 : 1; } adj[13] = 0; adj[0] = 0; adj[2] = 0; adj[6] = 0; adj[8] = 0; adj[18] = 0; adj[20] = 0; adj[24] = 0; adj[26] = 0; c2 = VANumComp6(adj); c3 = VBNumComp6(adj); if (c2 == 0) /* interior point */ VPixel(dest,b,r,c,VUByte) = 1; else if (c1 == 0) /* isolated point */ VPixel(dest,b,r,c,VUByte) = 2; else if (c2 == 1 && c1 == 1) /* border point */ VPixel(dest,b,r,c,VUByte) = 3; else if (c2 == 1 && c1 == 2) /* curve point */ VPixel(dest,b,r,c,VUByte) = 4; else if (c2 == 1 && c1 > 2) /* curves junction */ VPixel(dest,b,r,c,VUByte) = 5; /* else if (c2 == 2 && c1 == 1 && c3 > 2) VPixel(dest,b,r,c,VUByte) = 8; */ else if (c2 == 2 && c1 == 1) /* surface point */ VPixel(dest,b,r,c,VUByte) = 6; else if (c2 == 2 && c1 >= 2) /* surface/curve junction */ VPixel(dest,b,r,c,VUByte) = 7; else if (c2 > 2 && c1 == 1) /* surfaces junction */ VPixel(dest,b,r,c,VUByte) = 8; else if (c2 > 2 && c1 >= 2) /* surfaces/curve junction */ VPixel(dest,b,r,c,VUByte) = 9; else /* undefined */ VPixel(dest,b,r,c,VUByte) = 10; /* n = VPixel(dest,b,r,c,VUByte); fprintf(stderr," %2d %2d %2d : %d %d %d, %d\n",b,r,c,c1,c2,c3,n); */ } } } /* ** get missed curves junctions */ for (b=0; b<nbands; b++) { for (r=0; r<nrows; r++) { for (c=0; c<ncols; c++) { if (VPixel(dest,b,r,c,VUByte) == 4) { n = 0; b0 = (b < 1) ? 0 : b - 1; b1 = (b >= nbands - 1) ? nbands - 1 : b + 1; for (bb=b0; bb<=b1; bb++) { r0 = (r < 1) ? 0 : r - 1; r1 = (r >= nrows - 1) ? nrows - 1 : r + 1; for (rr=r0; rr<=r1; rr++) { c0 = (c < 1) ? 0 : c - 1; c1 = (c >= ncols - 1) ? ncols - 1 : c + 1; for (cc=c0; cc<=c1; cc++) { v = VPixel(dest,bb,rr,cc,VUByte); if (v == 3 || v == 4 || v == 5) n++; } } } if (n > 3) { VPixel(dest,b,r,c,VUByte) = 5; } } } } } VJunction(src,dest); VCopyImageAttrs (src, dest); return dest; }
VAttrList VGetContrast(VAttrList list, gsl_vector_float *con, VShort type) { VAttrList out_list; int nbands = 0, nrows = 0, ncols = 0, band, row, col; VImage src = NULL, dest = NULL, std_image = NULL; VImage beta_images[MBETA], res_image = NULL, bcov_image = NULL; VString buf = NULL; VAttrListPosn posn; VString str; int i, nbeta; float t = 0, s = 0, tsigma = 0, z = 0, zmax = 0, zmin = 0; float sigma, var, sum, df; float *ptr1, *ptr2; char *constring = NULL; gsl_vector_float *beta = NULL, *tmp = NULL; gsl_matrix_float *bcov = NULL; i = 0; for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) { if(VGetAttrRepn(& posn) != VImageRepn) continue; VGetAttrValue(& posn, NULL, VImageRepn, & src); if(VPixelRepn(src) != VFloatRepn) continue; VGetAttr(VImageAttrList(src), "modality", NULL, VStringRepn, &str); if(strcmp(str, "BETA") == 0) { beta_images[i++] = VCopyImage(src, NULL, VAllBands); } else if(strcmp(str, "RES/trRV") == 0) { res_image = VCopyImage(src, NULL, VAllBands); } else if(strcmp(str, "BCOV") == 0) { bcov_image = VCopyImage(src, NULL, VAllBands); } } nbeta = VImageNRows(bcov_image); nbands = VImageNBands(beta_images[0]); nrows = VImageNRows(beta_images[0]); ncols = VImageNColumns(beta_images[0]); if(VGetAttr(VImageAttrList(beta_images[0]), "df", NULL, VFloatRepn, &df) != VAttrFound) VError(" attribute 'df' not found"); if(nbeta > MBETA) { fprintf(stderr, " number of betas: %d, maximum number of betas: %d\n", nbeta, MBETA); VError(" maximum number of betas is exceeded"); } /* ** read contrast vector */ if(nbeta != con->size) VError("contrast vector has bad length (%d), correct length is %d", con->size, nbeta); fprintf(stderr, " contrast vector:\n"); char str1[10]; constring = (char *)VMalloc(sizeof(char) * 10 * nbeta); constring[0] = '\0'; for(i = 0; i < nbeta; i++) { fprintf(stderr, " %.2f", fvget(con, i)); sprintf(str1, "%1.2f ", fvget(con, i)); strcat((char *)constring, (const char *)str1); } fprintf(stderr, "\n"); /* get variance estimation */ bcov = gsl_matrix_float_alloc(nbeta, nbeta); ptr1 = VImageData(bcov_image); ptr2 = bcov->data; for(i = 0; i < nbeta * nbeta; i++) *ptr2++ = *ptr1++; gsl_matrix_float_transpose(bcov); tmp = fmat_x_vector(bcov, con, tmp); var = fskalarproduct(tmp, con); sigma = sqrt(var); /* ** create output data structs */ out_list = VCreateAttrList(); dest = VCreateImage(nbands, nrows, ncols, VFloatRepn); VFillImage(dest, VAllBands, 0); VCopyImageAttrs(beta_images[0], dest); switch(type) { case 0: /* conimg */ buf = VNewString("conimg"); break; case 1: /* t-image */ buf = VNewString("tmap"); break; case 2: /* zmap */ buf = VNewString("zmap"); break; default: VError(" illegal type"); } fprintf(stderr, " output type: %s\n", buf); VSetAttr(VImageAttrList(dest), "modality", NULL, VStringRepn, buf); VSetAttr(VImageAttrList(dest), "name", NULL, VStringRepn, buf); VSetAttr(VImageAttrList(dest), "contrast", NULL, VStringRepn, constring); VAppendAttr(out_list, "image", NULL, VImageRepn, dest); if(type == 0) { std_image = VCreateImage(nbands, nrows, ncols, VFloatRepn); VFillImage(std_image, VAllBands, 0); VCopyImageAttrs(beta_images[0], std_image); VSetAttr(VImageAttrList(std_image), "modality", NULL, VStringRepn, "std_dev"); VSetAttr(VImageAttrList(std_image), "name", NULL, VStringRepn, "std_dev"); VAppendAttr(out_list, "image", NULL, VImageRepn, std_image); } /* ** loop thru image */ zmax = zmin = 0; beta = gsl_vector_float_alloc(nbeta); for(band = 0; band < nbands; band++) { for(row = 0; row < nrows; row++) { for(col = 0; col < ncols; col++) { t = z = sum = 0; ptr1 = beta->data; for(i = 0; i < nbeta; i++) { *ptr1++ = VPixel(beta_images[i], band, row, col, VFloat); } sum = fskalarproduct(beta, con); if(ABS(sum) < 1.0e-10) continue; s = VPixel(res_image, band, row, col, VFloat); tsigma = sqrt(s) * sigma; if(tsigma > 0.00001) t = sum / tsigma; else t = 0; if(isnan(t) || isinf(t)) t = 0; switch(type) { case 0: /* conimg */ z = sum; break; case 1: /* t-image */ z = t; break; case 2: /* zmap */ z = t2z_approx(t, df); if(z > 30) z = 30; if(sum < 0) z = -z; break; default: ; } if(isnan(z) || isinf(z)) z = 0; if(z > zmax) zmax = z; if(z < zmin) zmin = z; VPixel(dest, band, row, col, VFloat) = z; if(type == 0) VPixel(std_image, band, row, col, VFloat) = tsigma; } } } fprintf(stderr, " min= %.3f, max= %.3f\n", zmin, zmax); return out_list; }
VImage SimilarityMatrix(VAttrList list, VImage mask, VShort minval, VShort fisher) { VAttrListPosn posn; VImage src[NSLICES], dest = NULL, map = NULL; int b, r, c, i, j, n, ntimesteps, nrows, ncols, nslices; double u, x, y, smin, smax, tiny = 1.0e-6; gsl_matrix_float *mat = NULL; /* ** get image dimensions */ i = ntimesteps = nrows = ncols = 0; for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) { if(VGetAttrRepn(& posn) != VImageRepn) continue; VGetAttrValue(& posn, NULL, VImageRepn, & src[i]); if(VPixelRepn(src[i]) != VShortRepn) continue; if(VImageNBands(src[i]) > ntimesteps) ntimesteps = VImageNBands(src[i]); if(VImageNRows(src[i]) > nrows) nrows = VImageNRows(src[i]); if(VImageNColumns(src[i]) > ncols) ncols = VImageNColumns(src[i]); i++; if(i >= NSLICES) VError(" too many slices"); } nslices = i; n = 0; for(b = 0; b < nslices; b++) { if(VImageNRows(src[b]) < 2) continue; for(r = 0; r < nrows; r++) { for(c = 0; c < ncols; c++) { if(VPixel(src[b], 0, r, c, VShort) < minval) continue; if(VGetPixel(mask, b, r, c) < 0.1) continue; n++; } } } fprintf(stderr, " n: %d\n", n); /* ** voxel addresses */ map = VCreateImage(1, 5, n, VFloatRepn); VFillImage(map, VAllBands, 0); VPixel(map, 0, 3, 0, VFloat) = nslices; VPixel(map, 0, 3, 1, VFloat) = nrows; VPixel(map, 0, 3, 2, VFloat) = ncols; i = 0; for(b = 0; b < nslices; b++) { if(VImageNRows(src[b]) < 2) continue; for(r = 0; r < nrows; r++) { for(c = 0; c < ncols; c++) { if(VPixel(src[b], 0, r, c, VShort) < minval) continue; if(VGetPixel(mask, b, r, c) < 0.1) continue; VPixel(map, 0, 0, i, VFloat) = b; VPixel(map, 0, 1, i, VFloat) = r; VPixel(map, 0, 2, i, VFloat) = c; i++; } } } /* ini output image */ if(n < 8000) dest = VCreateImage(1, n, n, VFloatRepn); else if(n >= 8000 && n < 10000) dest = VCreateImage(1, n, n, VShortRepn); else dest = VCreateImage(1, n, n, VSByteRepn); VFillImage(dest, VAllBands, 0); smin = VPixelMinValue(dest); smax = VPixelMaxValue(dest); /* ** avoid casting to float, copy data to matrix */ mat = gsl_matrix_float_calloc(n, ntimesteps); for(i = 0; i < n; i++) { b = VPixel(map, 0, 0, i, VFloat); r = VPixel(map, 0, 1, i, VFloat); c = VPixel(map, 0, 2, i, VFloat); float *ptr = gsl_matrix_float_ptr(mat, i, 0); int k; j = 0; for(k = 0; k < ntimesteps; k++) { if(j >= mat->size2) VError(" j= %d %d", j, mat->size2); if(k >= VImageNBands(src[b])) VError(" k= %d %d", k, VImageNBands(src[b])); *ptr++ = (float) VPixel(src[b], k, r, c, VShort); j++; } } /* ** main process loop */ for(i = 0; i < n; i++) { if(i % 50 == 0) fprintf(stderr, " i: %4d\r", i); const float *arr1 = gsl_matrix_float_const_ptr(mat, i, 0); for(j = 0; j <= i; j++) { const float *arr2 = gsl_matrix_float_const_ptr(mat, j, 0); u = Correlation(arr1, arr2, ntimesteps); /* Fisher r-to-z transform */ if(fisher) { x = 1 + u; y = 1 - u; if(x < tiny) x = tiny; if(y < tiny) y = tiny; u = 0.5 * log(x / y); } if(VPixelRepn(dest) != VFloatRepn) { u *= smax; if(u < smin) u = smin; if(u > smax) u = smax; } VSetPixel(dest, 0, i, j, u); VSetPixel(dest, 0, j, i, u); } } VCopyImageAttrs(src[0], dest); VSetAttr(VImageAttrList(dest), "similarity_metric", NULL, VStringRepn, "corr_pearson"); VSetAttr(VImageAttrList(dest), "name", NULL, VStringRepn, "similarity_matrix"); VSetAttr(VImageAttrList(dest), "map", NULL, VImageRepn, map); return dest; }
VImage GetMap(VAttrList list1,VAttrList list2,VImage mask,VShort minval) { VAttrListPosn posn; VImage src1[NSLICES],src2[NSLICES],map=NULL; size_t b,r,c,i,n; int nrows,ncols,nslices,nrows2,ncols2,nslices2; /* ** get image dimensions */ i = nrows = ncols = 0; for (VFirstAttr (list1, & posn); VAttrExists (& posn); VNextAttr (& posn)) { if (VGetAttrRepn (& posn) != VImageRepn) continue; VGetAttrValue (& posn, NULL,VImageRepn, & src1[i]); if (VPixelRepn(src1[i]) != VShortRepn) continue; if (VImageNRows(src1[i]) > nrows) nrows = VImageNRows(src1[i]); if (VImageNColumns(src1[i]) > ncols) ncols = VImageNColumns(src1[i]); i++; if (i >= NSLICES) VError(" too many slices"); } nslices = i; i = nrows2 = ncols2 = 0; for (VFirstAttr (list2, & posn); VAttrExists (& posn); VNextAttr (& posn)) { if (VGetAttrRepn (& posn) != VImageRepn) continue; VGetAttrValue (& posn, NULL,VImageRepn, & src2[i]); if (VPixelRepn(src2[i]) != VShortRepn) continue; if (VImageNRows(src2[i]) > nrows2) nrows2 = VImageNRows(src2[i]); if (VImageNColumns(src2[i]) > ncols2) ncols2 = VImageNColumns(src2[i]); i++; if (i >= NSLICES) VError(" too many slices"); } nslices2 = i; if (nslices2 != nslices) VError(" inconsistent number of slices: %d %d",nslices,nslices2); if (nrows2 != nrows) VError(" inconsistent number of rows: %d %d",nrows,nrows2); if (ncols2 != ncols) VError(" inconsistent number of cols: %d %d",ncols,ncols2); /* count number of voxels */ n = 0; for (b=0; b<nslices; b++) { if (VImageNRows(src1[b]) < 2) continue; if (VImageNRows(src2[b]) < 2) continue; for (r=0; r<nrows; r++) { for (c=0; c<ncols; c++) { if (VPixel(src1[b],0,r,c,VShort) < minval) continue; if (VPixel(src2[b],0,r,c,VShort) < minval) continue; if (VGetPixel(mask,b,r,c) < 0.5) continue; n++; } } } fprintf(stderr," nvoxels: %ld\n",(long)n); /* ** voxel addresses */ map = VCreateImage(1,5,n,VShortRepn); if (map == NULL) VError(" error allocating addr map"); VFillImage(map,VAllBands,0); VCopyImageAttrs (src1[0],map); VPixel(map,0,3,0,VShort) = nslices; VPixel(map,0,3,1,VShort) = nrows; VPixel(map,0,3,2,VShort) = ncols; i = 0; for (b=0; b<nslices; b++) { if (VImageNRows(src1[b]) < 2) continue; if (VImageNRows(src2[b]) < 2) continue; for (r=0; r<nrows; r++) { for (c=0; c<ncols; c++) { if (VPixel(src1[b],0,r,c,VShort) < minval) continue; if (VPixel(src2[b],0,r,c,VShort) < minval) continue; if (VGetPixel(mask,b,r,c) < 0.5) continue; VPixel(map,0,0,i,VShort) = b; VPixel(map,0,1,i,VShort) = r; VPixel(map,0,2,i,VShort) = c; i++; } } } return map; }
VImage VScaleIntensity(VImage src, double white, double black) /* scale any input image to VUByte, mapping white (black) percent of the voxel to white (black) */ { int x, y, z, nx, ny, nz, i, range, maxshort; unsigned int lb, ub, limit, sum, *histo; double m, b, max, min, mean, var, v; VImage dst; maxshort = (int)(VRepnMaxValue(VShortRepn)); histo = (unsigned int *)VCalloc(maxshort, sizeof(unsigned int)); nx = VImageNColumns(src); ny = VImageNRows(src); nz = VImageNBands(src); if (white < 0 || white > 100 || black < 0 || black > 100 || white+black >= 100) { fprintf(stderr, "VScaleIntensity: illegal percentage given.\n"); return 0; }; /* first pass: find maximum and minimum values */ VImageStats(src, VAllBands, &min, &max, &mean, &var); if (max == min) { fprintf(stderr, "VScaleIntensity: illegal data in image.\n"); return 0; }; b = min; m = (max-min) / (double)maxshort; /* second pass: build a histogram*/ for (z = 0; z < nz; z++) { for (y = 0; y < ny; y++) { for (x = 0; x < nx; x++) { v = VGetPixel(src, z, y, x); i = (int)((v-b)/m+0.5); histo[i]++; }; }; }; /* throw away pc percent of the voxel below lb and pc percent above ub */ limit = (black * nx * ny * nz) / 100; lb = 0; sum = 0; for (i = 0; i < maxshort; i++) { sum += histo[i]; if (sum >= limit) { lb = i; break; }; }; limit = (white * nx * ny * nz) / 100; ub = maxshort-1; sum = 0; for (i = maxshort-1; i >= 0; i--) { sum += histo[i]; if (sum >= limit) { ub = i; break; }; }; min = lb*m+b; max = ub*m+b; /* third pass: create and convert image */ dst = VCreateImage(nz, ny, nx, VUByteRepn); if (dst == 0) return 0; range = 256; m = range / (max - min); b = range - (m * max); for (z = 0; z < nz; z++) { for (y = 0; y < ny; y++) { for (x = 0; x < nx; x++) { v = VGetPixel(src, z, y, x); i = (int)(v * m + b + 0.5); if (i < 0) i = 0; else if (i >= range) i = range-1; VPixel(dst, z, y, x, VUByte) = i; }; }; }; VFree(histo); VCopyImageAttrs(src, dst); return dst; }
VImage VHistoEqualize(VImage src,VImage dest,VFloat exponent) { int nbands,nrows,ncols,npixels; float u,v,sum; float *histo,*p; int i,j,dim; VShort *src_pp; VUByte *dest_pp; double smin,smax,x,y; if (VPixelRepn(src) != VShortRepn) VError(" input pixel repn must be short"); if (exponent < 0.5) VError("parameter '-exponent' should be >= 0.5"); if (exponent > 10) VWarning("parameter '-exponent' should be < 10"); nbands = VImageNBands(src); nrows = VImageNRows(src); ncols = VImageNColumns(src); npixels = nbands * nrows * ncols; dest = VSelectDestImage("VContrastShort",dest,nbands,nrows,ncols,VUByteRepn); if (! dest) VError(" err creating dest image"); VFillImage(dest,VAllBands,0); y = (double) exponent; smin = VRepnMinValue(VShortRepn); smax = VRepnMaxValue(VShortRepn); dim = 2.0 * smax + 1.0; histo = (float *) VCalloc(dim,sizeof(float)); for (j=0; j<dim; j++) histo[j] = 0; p = (float *) VCalloc(dim,sizeof(float)); src_pp = (VShort *) VImageData(src); for (i=0; i<npixels; i++) { j = *src_pp++; j -= smin; if (j == 0) continue; histo[j]++; } sum = 0; for (j=0; j<dim; j++) sum += histo[j]; for (j=0; j<dim; j++) histo[j] /= sum; /* cumulative hist */ for (i=0; i<dim; i++) { sum = 0; for (j=0; j<=i; j++) sum += histo[j]; p[i] = sum; } /* make lut */ for (i=0; i<dim; i++) { x = (double)p[i]; if (x > 0) p[i] = (float)(pow(x,y) * 255.0); } /* apply lut */ src_pp = (VShort *) VImageData(src); dest_pp = (VUByte *) VImageData(dest); for (i=0; i<npixels; i++) { u = *src_pp++; j = (int) (u-smin); v = (double)p[j]; if (v < 0) v = 0; if (v > 255) v = 255; *dest_pp++ = (VUByte) v; } VFree(p); VFree(histo); VCopyImageAttrs (src, dest); return dest; }
/*! \fn VImage VContrastShort(VImage src,VImage dest,VFloat percent,VFloat background) \param src input image (short repn) \param dest output image (ubyte repn) */ VImage VContrastShort(VImage src,VImage dest,VFloat low,VFloat high) { int nbands,nrows,ncols,npixels; float u,v,xmin,xmax,slope,sum; float *histo; int i,j,dim; VShort *src_pp; VUByte *dest_pp; double smin,smax; double percent1,percent2; if (VPixelRepn(src) != VShortRepn) VError(" input pixel repn must be short"); nbands = VImageNBands(src); nrows = VImageNRows(src); ncols = VImageNColumns(src); npixels = nbands * nrows * ncols; dest = VSelectDestImage("VContrastShort",dest,nbands,nrows,ncols,VUByteRepn); if (! dest) VError(" err creating dest image"); VFillImage(dest,VAllBands,0); smin = VRepnMinValue(VShortRepn); smax = VRepnMaxValue(VShortRepn); percent1 = low; /* unten */ percent2 = high; /* oben */ dim = 2.0 * smax + 1.0; histo = (float *) VCalloc(dim,sizeof(float)); for (j=0; j<dim; j++) histo[j] = 0; src_pp = (VShort *) VImageData(src); for (i=0; i<npixels; i++) { j = *src_pp++; j -= smin; histo[j]++; } sum = 0; for (j=0; j<dim; j++) sum += histo[j]; for (j=0; j<dim; j++) histo[j] /= sum; xmin = 0; sum = 0; for (j=0; j<dim; j++) { sum += histo[j]; if (sum > percent1) break; } xmin = j+smin; xmax = dim; sum = 0; for (j=dim; j>0; j--) { sum += histo[j]; if (sum > percent2) break; } xmax = j+smin; slope = 255.0f / (xmax - xmin); src_pp = (VShort *) VImageData(src); dest_pp = (VUByte *) VImageData(dest); for (i=0; i<npixels; i++) { u = *src_pp++; v = (int) (slope * (u - xmin) + 0.5); if (v < 0) v = 0; if (v > 255) v = 255; *dest_pp++ = (VUByte) v; } VFree(histo); VCopyImageAttrs (src, dest); return dest; }
/*! \fn VImage VContrastUByte(VImage src,VImage dest,VFloat percent,VFloat background) \param src input image (ubyte repn) \param dest output image (ubyte repn) \param percent percentage of pixels to ignore at either end of the histogram. \param background input grey values with absolute values less than <background> are assumed to be image background. */ VImage VContrastUByte(VImage src,VImage dest,VFloat low,VFloat high) { int nbands,nrows,ncols,npixels; float u,v,xmin,xmax,slope,sum,background; float histo[256]; int i,j; VUByte *src_pp,*dest_pp; if (VPixelRepn(src) != VUByteRepn) VError(" input pixel repn must be ubyte"); nbands = VImageNBands(src); nrows = VImageNRows(src); ncols = VImageNColumns(src); npixels = nbands * nrows * ncols; dest = VSelectDestImage("VContrastUByte",dest,nbands,nrows,ncols,VUByteRepn); if (! dest) VError(" err creating dest image"); VFillImage(dest,VAllBands,0); for (j=0; j<256; j++) histo[j] = 0; xmin = VPixelMaxValue(src); xmax = VPixelMinValue(src); background = xmin; src_pp = (VUByte *) VImageData(src); for (i=0; i<npixels; i++) { j = *src_pp++; if (j <= background) continue; histo[j]++; } sum = 0; for (j=0; j<256; j++) sum += histo[j]; for (j=0; j<256; j++) histo[j] /= sum; xmin = 0; sum = 0; for (j=0; j<256; j++) { if (j > background) sum += histo[j]; if (sum > low) break; } xmin = j; xmax = 255.0; sum = 0; for (j=255; j>0; j--) { if (j > background) sum += histo[j]; if (sum > high) break; } xmax = j; slope = (float) (255.0) / ((float) (xmax - xmin)); src_pp = (VUByte *) VImageData(src); dest_pp = (VUByte *) VImageData(dest); for (i=0; i<npixels; i++) { u = *src_pp; if (u <= background) { v = 0; } else { v = (int) (slope * (u - xmin) + 0.5); if (v < 0) v = 0; if (v > 255) v = 255; } *dest_pp = (VUByte) v; src_pp++; dest_pp++; } VFree(histo); VCopyImageAttrs (src, dest); return dest; }
VImage VDoTrans(VImage src, VImage dest, VImage transform, VFloat resolution, VLong type) { VImage src1 = NULL, dest_cor = NULL, dest_sag = NULL, trans = NULL; int i, nbands1 = 0, nrows1 = 0, ncols1 = 0; int xdim, ydim, zdim; int orient = AXIAL; float b0, r0, c0; float scaleb, scaler, scalec; float scale[3], shift[3]; VString str, str1, str2, str3, str4, str5, str6; VShort buf; VDouble u; float transResX = 1.0, transResY = 1.0, transResZ = 1.0; VString _transResString; if(VGetAttr(VImageAttrList(transform), "voxel", NULL, VStringRepn, (VPointer) &_transResString) == VAttrFound) { sscanf(_transResString, "%f %f %f", &transResX, &transResY, &transResZ); } /* ** get matrix size */ xdim = 160; ydim = 200; zdim = 160; if(VGetAttr(VImageAttrList(transform), "zdim", NULL, VShortRepn, (VPointer) & buf) == VAttrFound) { zdim = buf; } if(VGetAttr(VImageAttrList(transform), "ydim", NULL, VShortRepn, (VPointer) & buf) == VAttrFound) { ydim = buf; } if(VGetAttr(VImageAttrList(transform), "xdim", NULL, VShortRepn, (VPointer) & buf) == VAttrFound) { xdim = buf; } /* ** get slice orientation */ if(VGetAttr(VImageAttrList(src), "orientation", NULL, VStringRepn, (VPointer) & str) != VAttrFound) VError(" attribute 'orientation' missing in input file."); if(strcmp(str, "coronal") == 0) { orient = CORONAL; nbands1 = ydim; nrows1 = zdim; ncols1 = xdim; } else if(strcmp(str, "axial") == 0) { orient = AXIAL; nbands1 = zdim; nrows1 = ydim; ncols1 = xdim; } else if(strcmp(str, "sagittal") == 0) { orient = SAGITTAL; nbands1 = zdim; nrows1 = xdim; ncols1 = ydim; } else VError("orientation must be axial or coronal"); nbands1 /= (resolution / transResX); nrows1 /= (resolution / transResY); ncols1 /= (resolution / transResZ); /* ** scale to size */ if(VGetAttr(VImageAttrList(src), "voxel", NULL, VStringRepn, (VPointer) & str) != VAttrFound) VError(" attribute 'voxel' missing in input file."); sscanf(str, "%f %f %f", &scalec, &scaler, &scaleb); scaleb /= (resolution / transResX); scaler /= (resolution / transResY); scalec /= (resolution / transResZ); scale[0] = scaleb; scale[1] = scaler; scale[2] = scalec; shift[0] = 0; shift[1] = (float)nrows1 * 0.5 - scaler * (float)VImageNRows(src) * 0.5; shift[2] = (float)ncols1 * 0.5 - scalec * (float)VImageNColumns(src) * 0.5; src1 = VShuffleSlices(src, NULL); switch(type) { case 0: src = VTriLinearScale3d(src1, NULL, nbands1, nrows1, ncols1, shift, scale); break; case 1: src = VNNScale3d(src1, NULL, nbands1, nrows1, ncols1, shift, scale); break; default: VError(" illegal resampling type"); } /* ** resample image */ trans = VCopyImage(transform, NULL, VAllBands); for(i = 0; i < 3; i++) { u = VPixel(trans, 0, i, 0, VDouble); u /= resolution; VPixel(trans, 0, i, 0, VDouble) = u; } b0 = (float)nbands1 * 0.5; r0 = (float)nrows1 * 0.5; c0 = (float)ncols1 * 0.5; switch(type) { case 0: dest = VTriLinearSample3d(src, dest, trans, b0, r0, c0, nbands1, nrows1, ncols1); break; case 1: dest = VNNSample3d(src, dest, trans, b0, r0, c0, nbands1, nrows1, ncols1); break; } /* ** update header */ float _cax, _cay, _caz, _cpx, _cpy, _cpz; float _fixpointx, _fixpointy, _fixpointz; str1 = str2 = str3 = str4 = NULL; str1 = (VString) VMalloc(80); sprintf(str1, "%.2f %.2f %.2f", resolution, resolution, resolution); if(VGetAttr(VImageAttrList(trans), "ca", NULL, VStringRepn, (VPointer) & str2) != VAttrFound) { str2 = NULL; } else { sscanf(str2, "%f %f %f", &_cax, &_cay, &_caz); _cax /= (resolution / transResX); _cay /= (resolution / transResY); _caz /= (resolution / transResZ); sprintf(str2, "%.2f %.2f %.2f", _cax, _cay, _caz); } if(VGetAttr(VImageAttrList(trans), "cp", NULL, VStringRepn, (VPointer) & str3) != VAttrFound) { str3 = NULL; } else { sscanf(str3, "%f %f %f", &_cpx, &_cpy, &_cpz); _cpx /= (resolution / transResX); _cpy /= (resolution / transResY); _cpz /= (resolution / transResZ); sprintf(str3, "%.2f %.2f %.2f", _cpx, _cpy, _cpz); } if(VGetAttr(VImageAttrList(trans), "extent", NULL, VStringRepn, (VPointer) & str4) != VAttrFound) str4 = NULL; if(VGetAttr(VImageAttrList(trans), "fixpoint", NULL, VStringRepn, (VPointer) & str5) != VAttrFound) { str5 = NULL; } else { sscanf(str5, "%f %f %f", &_fixpointx, &_fixpointy, &_fixpointz); _fixpointx /= (resolution / transResX); _fixpointy /= (resolution / transResY); _fixpointz /= (resolution / transResZ); sprintf(str5, "%.2f %.2f %.2f", _fixpointx, _fixpointy, _fixpointz); } if(VGetAttr(VImageAttrList(trans), "talairach", NULL, VStringRepn, (VPointer) & str6) != VAttrFound) { str6 = NULL; } if(orient == CORONAL) { dest_cor = VAxial2Coronal(dest, NULL); VDestroyImage(dest); VCopyImageAttrs(src, dest_cor); VSetAttr(VImageAttrList(dest_cor), "voxel", NULL, VStringRepn, str1); if(str2) VSetAttr(VImageAttrList(dest_cor), "ca", NULL, VStringRepn, str2); if(str3) VSetAttr(VImageAttrList(dest_cor), "cp", NULL, VStringRepn, str3); if(str4) VSetAttr(VImageAttrList(dest_cor), "extent", NULL, VStringRepn, str4); if(str5) VSetAttr(VImageAttrList(dest_cor), "fixpoint", NULL, VStringRepn, str5); if(str6) VSetAttr(VImageAttrList(dest_cor), "talairach", NULL, VStringRepn, str6); return dest_cor; } else if(orient == SAGITTAL) { dest_sag = VAxial2Sagittal(dest, NULL); VDestroyImage(dest); VCopyImageAttrs(src, dest_sag); VSetAttr(VImageAttrList(dest_sag), "voxel", NULL, VStringRepn, str1); if(str2) VSetAttr(VImageAttrList(dest_sag), "ca", NULL, VStringRepn, str2); if(str3) VSetAttr(VImageAttrList(dest_sag), "cp", NULL, VStringRepn, str3); if(str4) VSetAttr(VImageAttrList(dest_sag), "extent", NULL, VStringRepn, str4); if(str5) VSetAttr(VImageAttrList(dest_sag), "fixpoint", NULL, VStringRepn, str5); if(str6) VSetAttr(VImageAttrList(dest_sag), "talairach", NULL, VStringRepn, str6); return dest_sag; } else { VCopyImageAttrs(src, dest); VSetAttr(VImageAttrList(dest), "voxel", NULL, VStringRepn, str1); if(str2) VSetAttr(VImageAttrList(dest), "ca", NULL, VStringRepn, str2); if(str3) VSetAttr(VImageAttrList(dest), "cp", NULL, VStringRepn, str3); if(str4) VSetAttr(VImageAttrList(dest), "extent", NULL, VStringRepn, str4); if(str5) VSetAttr(VImageAttrList(dest), "fixpoint", NULL, VStringRepn, str5); if(str6) VSetAttr(VImageAttrList(dest), "talairach", NULL, VStringRepn, str6); return dest; } }
int main(int argc, char *argv[]) { static VFloat reso = -1.0; static VLong itype = 0; static VBoolean flip = TRUE; static VBoolean reorder = TRUE; static VOptionDescRec options[] = { { "reso", VFloatRepn, 1, (VPointer) &reso, VOptionalOpt, NULL, "New voxel resolution in mm, def: -1 means min(1.0,\"best source resolution\")" }, { "flip", VBooleanRepn, 1, (VPointer) &flip, VOptionalOpt, NULL, "Whether to flip to natural convention" }, { "reorder", VBooleanRepn, 1, (VPointer) &reorder, VOptionalOpt, NULL, "Whether to reorder axial slices from axial source image" }, { "interpolation", VLongRepn, 1, & itype, VOptionalOpt, ITYPDict, "Type of interpolation (0: linear, 1: nearest neighbour, 2: cubic spline)" } }; FILE *in_file, *out_file; VAttrList list; VAttrListPosn posn; int nobjects = 0; VImage src = NULL, dest = NULL, result = NULL; int i, b, r, c, nbands, nrows, ncols; VString str, newstr, fixpointString, caString, cpString; float fix_c, fix_r, fix_b; float ca_c, ca_r, ca_b; float cp_c, cp_r, cp_b; float x, y, z, min; VDouble v, scale_band, scale_row, scale_col; float scale[3], shift[3]; /* print information */ char prg_name[100]; char ver[100]; getLipsiaVersion(ver, sizeof(ver)); sprintf(prg_name, "visotrop V%s", ver); fprintf(stderr, "%s\n", prg_name); fflush(stderr); /* Parse command line arguments: */ VParseFilterCmd(VNumber(options), options, argc, argv, & in_file, & out_file); /* Read source image(s): */ if(!(list = VReadFile(in_file, NULL))) exit(EXIT_FAILURE); /* Scale each object: */ for(VFirstAttr(list, & posn); VAttrExists(& posn); VNextAttr(& posn)) { switch(VGetAttrRepn(& posn)) { case VImageRepn: VGetAttrValue(& posn, NULL, VImageRepn, & src); if(VGetAttr(VImageAttrList(src), "voxel", NULL, VStringRepn, (VPointer) & str) == VAttrFound) { sscanf(str, "%f %f %f", &x, &y, &z); fprintf(stderr, " voxel: %f %f %f\n", x, y, z); min = x < y ? x : y; min = z < min ? z : min; /* if resolution is not set, use default value 1 or smaler value if the image resolution is better */ if(reso < 0.0) reso = min < 1.0 ? min : 1.0; if(reso <= 0.0) exit(EXIT_FAILURE); fprintf(stderr, " new resolution: %f \n", reso); scale_col = x / reso; scale_row = y / reso; scale_band = z / reso; nbands = VImageNBands(src) * scale_band; nrows = VImageNRows(src) * scale_row; ncols = VImageNColumns(src) * scale_col; if(VImageNBands(src) == nbands && VImageNRows(src) == nrows && VImageNColumns(src) == ncols) { itype = 0; } fprintf(stderr, " interpolation type: %s\n", ITYPDict[itype].keyword); fprintf(stderr, " old dim: %3d %3d %3d\n", VImageNBands(src), VImageNRows(src), VImageNColumns(src)); for(i = 0; i < 3; i++) shift[i] = scale[i] = 0; scale[0] = scale_band; scale[1] = scale_row; scale[2] = scale_col; switch(itype) { /* trilinear interpolation resampling */ case 0: dest = VTriLinearScale3d(src, NULL, (int)nbands, (int)nrows, (int)ncols, shift, scale); break; /* nearest neightbour resampling */ case 1: dest = VNNScale3d(src, NULL, (int)nbands, (int)nrows, (int)ncols, shift, scale); break; /* cubic spline */ case 2: dest = VCubicSplineScale3d(src, NULL, (int)nbands, (int)nrows, (int)ncols, shift, scale); break; case 3: /* no interpolation, just reshuffle */ dest = VCopyImage(src, NULL, VAllBands); break; default: VError(" unknown resampling type %d", itype); } if(! dest) exit(EXIT_FAILURE); /*aa 2003/09/11 added function not to rotate siemens data*/ if(! VGetAttr(VImageAttrList(src), "orientation", NULL, VStringRepn, (VPointer) & str) == VAttrFound) VError(" attribute 'orientation' missing"); if(strcmp(str, "axial") == 0) { fprintf(stderr, " new dim: %3d %3d %3d\n", nbands, nrows, ncols); result = VCreateImage(nbands, nrows, ncols, VPixelRepn(src)); VFillImage(result, VAllBands, 0); for(b = 0; b < nbands; b++) for(r = 0; r < nrows; r++) for(c = 0; c < ncols; c++) { v = VGetPixel(dest, b, r, c); if((flip == FALSE) && (reorder == FALSE)) VSetPixel(result, b, r, ncols - c - 1, v); else if((flip == TRUE) && (reorder == FALSE)) VSetPixel(result, b, r, c, v); else if((flip == FALSE) && (reorder == TRUE)) VSetPixel(result, nbands - b - 1, r, ncols - c - 1, v); else if((flip == TRUE) && (reorder == TRUE)) VSetPixel(result, nbands - b - 1, r, c, v); } } else if(strcmp(str, "sagittal") == 0) { /* re-arrange from sagittal to axial orientation */ fprintf(stderr, " new dim: %3d %3d %3d\n", nrows, ncols, nbands); result = VCreateImage(nrows, ncols, nbands, VPixelRepn(src)); VFillImage(result, VAllBands, 0); for(b = 0; b < nbands; b++) for(r = 0; r < nrows; r++) for(c = 0; c < ncols; c++) { v = VGetPixel(dest, b, r, c); if(flip == FALSE) VSetPixel(result, r, c, nbands - b - 1, v); else VSetPixel(result, r, c, b, v); } } else if(strcmp(str, "coronal") == 0) { /* re-arrange from coronal to axial orientation */ fprintf(stderr, " new dim: %3d %3d %3d\n", nrows, nbands, ncols); result = VCreateImage(nrows, nbands, ncols, VPixelRepn(src)); VFillImage(result, VAllBands, 0); for(b = 0; b < nbands; b++) for(r = 0; r < nrows; r++) for(c = 0; c < ncols; c++) { v = VGetPixel(dest, b, r, c); if(flip == FALSE) VSetPixel(result, r, b, ncols - c - 1, v); else VSetPixel(result, r, b, c, v); } } else { VError(" unknown resampling type %d", itype); exit(EXIT_FAILURE); } /* copy attributes from source image */ VCopyImageAttrs(src, result); // [TS] 08/03/27 // correct 'fixpoint', 'ca' and 'cp' if they exist in the source image // // NOTE: // this is only done when no flipping or reordering is requested :-( // (WARNING!!!!) '-flip true' actually means that no flipping is done (WHAAAAT ????) // and therefore we test for reorder = false and flip = true fixpointString = VMalloc(80); caString = VMalloc(80); cpString = VMalloc(80); VBoolean _issueWarning = FALSE; if(VGetAttr(VImageAttrList(src), "fixpoint", NULL, VStringRepn, (VPointer)&fixpointString) == VAttrFound) { if(reorder == FALSE && flip == TRUE) { sscanf(fixpointString, "%f %f %f", &fix_c, &fix_r, &fix_b); fix_c *= scale_col; fix_r *= scale_row; fix_b *= scale_band; sprintf((char *)fixpointString, "%f %f %f", fix_c, fix_r, fix_b); VSetAttr(VImageAttrList(result), "fixpoint", NULL, VStringRepn, fixpointString); } else { _issueWarning = TRUE; } } if(VGetAttr(VImageAttrList(src), "ca", NULL, VStringRepn, (VPointer)&caString) == VAttrFound) { if(reorder == FALSE && flip == TRUE) { sscanf(caString, "%f %f %f", &ca_c, &ca_r, &ca_b); ca_c *= scale_col; ca_r *= scale_row; ca_b *= scale_band; sprintf((char *)caString, "%f %f %f", ca_c, ca_r, ca_b); VSetAttr(VImageAttrList(result), "ca", NULL, VStringRepn, caString); } else { _issueWarning = TRUE; } } if(VGetAttr(VImageAttrList(src), "cp", NULL, VStringRepn, (VPointer)&cpString) == VAttrFound) { if(reorder == FALSE && flip == TRUE) { sscanf(cpString, "%f %f %f", &cp_c, &cp_r, &cp_b); cp_c *= scale_col; cp_r *= scale_row; cp_b *= scale_band; sprintf((char *)cpString, "%f %f %f", cp_c, cp_r, cp_b); VSetAttr(VImageAttrList(result), "cp", NULL, VStringRepn, cpString); } else { _issueWarning = TRUE; } } if(_issueWarning) { VWarning("Attributes 'fixpoint', 'ca' and 'cp' exist but were not corrected and are therefore likely to be wrong"); VWarning("This was caused by setting -flip to false or -reorder to true"); VWarning("Please correct the values manually using vattredit"); } /* set the attributes to the changed values */ newstr = VMalloc(80); sprintf((char *)newstr, "%f %f %f", reso, reso, reso); VSetAttr(VImageAttrList(result), "voxel", NULL, VStringRepn, newstr); VSetAttr(VImageAttrList(result), "orientation", NULL, VStringRepn, "axial"); if(flip) VSetAttr(VImageAttrList(result), "convention", NULL, VStringRepn, "natural"); else VSetAttr(VImageAttrList(result), "convention", NULL, VStringRepn, "radiologic"); } VSetAttrValue(& posn, NULL, VImageRepn, result); VDestroyImage(src); break; default: continue; } nobjects++; } /* Make History */ VHistory(VNumber(options), options, prg_name, &list, &list); /* Write the results to the output file: */ if(! VWriteFile(out_file, list)) exit(EXIT_FAILURE); fprintf(stderr, "%s: done.\n", argv[0]); return EXIT_SUCCESS; }
VImage VTopSmoothImage3d(VImage bit_image, VImage grey_image, VImage result, VLong neighb, VLong numiter) { long nbands, nrows, ncols, npixels; VRepnKind repn; long i, i0, i1, n, iter, npts, u; long b0, b1, r0, r1, c0, c1, b, r, c; long n1, n6, n18, n26; int isum; double sum, norm = 0; VBit *dest_pp, *bit_pp; VUByte *ubyte_pp; int background = 0; VPoint *array = NULL; repn = VPixelRepn(bit_image); if(repn != VBitRepn) VError("Smooth3d: repn must be bit"); nbands = VImageNBands(bit_image); nrows = VImageNRows(bit_image); ncols = VImageNColumns(bit_image); npixels = nbands * nrows * ncols; if(result == NULL) result = VCreateImage(nbands, nrows, ncols, repn); if(! result) return NULL; bit_pp = VPixelPtr(bit_image, 0, 0, 0); dest_pp = VPixelPtr(result, 0, 0, 0); for(i = 0; i < npixels; i++) *dest_pp++ = *bit_pp++; n1 = 8; n6 = 4; n18 = 2; n26 = 1; switch(neighb) { case 0: norm = n1 + 6 * n6; break; case 1: norm = n1 + 6 * n6 + 12 * n18; break; case 2: norm = n1 + 6 * n6 + 12 * n18 + 8 * n26; break; default: ; } n = 1; ubyte_pp = VPixelPtr(grey_image, 0, 0, 0); for(i = 0; i < npixels; i++) if(*ubyte_pp++ > background) n++; array = (VPoint *) VMalloc(sizeof(VPoint) * (n + 2)); for(i = 0; i < n + 2; i++) array[i].val = array[i].b = array[i].r = array[i].c = 0; n = 1; for(b = 0; b < nbands; b++) { for(r = 0; r < nrows; r++) { for(c = 0; c < ncols; c++) { u = VPixel(grey_image, b, r, c, VUByte); if(u > background) { array[n].b = b; array[n].r = r; array[n].c = c; array[n].val = (float)u; n++; } } } } npts = n; VPoint_hpsort(n - 1, array); iter = 0; n = 100; while(n > 1 && iter < numiter) { iter++; n = 0; for(i = 1; i < npts; i++) { b = array[i].b; r = array[i].r; c = array[i].c; b0 = (b < 1) ? 0 : b - 1; b1 = (b > nbands - 2) ? nbands - 1 : b + 1; r0 = (r < 1) ? 0 : r - 1; r1 = (r > nrows - 2) ? nrows - 1 : r + 1; c0 = (c < 1) ? 0 : c - 1; c1 = (c > ncols - 2) ? ncols - 1 : c + 1; isum = 0; i1 = VPixel(bit_image, b, r, c, VBit); isum += (int) i1 * n1; isum += (int) VPixel(bit_image, b0, r, c, VBit) * n6; isum += (int) VPixel(bit_image, b, r0, c, VBit) * n6; isum += (int) VPixel(bit_image, b, r, c0, VBit) * n6; isum += (int) VPixel(bit_image, b1, r, c, VBit) * n6; isum += (int) VPixel(bit_image, b, r1, c, VBit) * n6; isum += (int) VPixel(bit_image, b, r, c1, VBit) * n6; if(neighb == 1) { isum += VPixel(bit_image, b0, r0, c, VBit) * n18; isum += (int) VPixel(bit_image, b, r0, c0, VBit) * n18; isum += (int) VPixel(bit_image, b0, r, c0, VBit) * n18; isum += (int) VPixel(bit_image, b1, r1, c, VBit) * n18; isum += (int) VPixel(bit_image, b, r1, c1, VBit) * n18; isum += (int) VPixel(bit_image, b1, r, c1, VBit) * n18; isum += (int) VPixel(bit_image, b1, r0, c, VBit) * n18; isum += (int) VPixel(bit_image, b, r1, c0, VBit) * n18; isum += (int) VPixel(bit_image, b1, r, c0, VBit) * n18; isum += (int) VPixel(bit_image, b0, r1, c, VBit) * n18; isum += (int) VPixel(bit_image, b, r0, c1, VBit) * n18; isum += (int) VPixel(bit_image, b0, r, c1, VBit) * n18; } if(neighb == 2) { isum += (int) VPixel(bit_image, b0, r0, c0, VBit) * n26; isum += (int) VPixel(bit_image, b1, r0, c0, VBit) * n26; isum += (int) VPixel(bit_image, b0, r1, c0, VBit) * n26; isum += (int) VPixel(bit_image, b0, r0, c1, VBit) * n26; isum += (int) VPixel(bit_image, b1, r1, c0, VBit) * n26; isum += (int) VPixel(bit_image, b1, r0, c1, VBit) * n26; isum += (int) VPixel(bit_image, b0, r1, c1, VBit) * n26; isum += (int) VPixel(bit_image, b1, r1, c1, VBit) * n26; } sum = (double) isum / (double) norm; i0 = 0; if(sum >= 0.5) i0 = 1; if(i1 == 1 && i0 == 0) { if(VSimplePoint(result, b, r, c, 26) == 0) i0 = 1; } else if(i1 == 0 && i0 == 1) { VPixel(result, b, r, c, VBit) = 1; if(VSimplePoint(result, b, r, c, 26) == 0) i0 = 0; } VPixel(result, b, r, c, VBit) = i0; if(i0 != i1) n++; } if(numiter > 1) { bit_pp = (VBit *) VImageData(bit_image); dest_pp = (VBit *) VImageData(result); for(i = 0; i < npixels; i++) *bit_pp++ = *dest_pp++; } } /* Successful completion: */ VCopyImageAttrs(bit_image, result); return result; }
VImage VAddCovariates(VImage design, VString cfile) { VImage dest = NULL, tmp = NULL; FILE *fp = NULL; char buf[LEN], token[80]; int i, j, r, c, ncols, nrows, add_cols; double u; float x; add_cols = 0; nrows = VImageNRows(design); ncols = VImageNColumns(design); /* read first file */ fp = fopen(cfile, "r"); if(fp == NULL) VError(" err opening file %s", cfile); tmp = VCreateImage(1, nrows, NCOV, VFloatRepn); VFillImage(tmp, VAllBands, 0); i = 0; while(!feof(fp)) { for(j = 0; j < LEN; j++) buf[j] = '\0'; fgets(buf, LEN, fp); if(buf[0] == '#' || buf[0] == '%') continue; if(strlen(buf) < 2) continue; if(i > nrows) VError(" too many rows in file (%d), max is %d", i, nrows); j = 0; while(VStringToken(buf, token, j, 30)) { sscanf(token, "%f", &x); if(j >= NCOV) VError(" too many additional covariates (%d), max is %d", j, NCOV - 1); VPixel(tmp, 0, i, j, VFloat) = x; j++; } if(j < 1) continue; if(add_cols > 0 && j > add_cols) VError(" inconsistent number of columns (%d, %d), line %d", j, add_cols, i + 1); if(add_cols == 0 && j > add_cols) add_cols = j; if(i >= nrows) continue; i++; } fclose(fp); if(i != nrows) VError(" file: inconsistent number of rows: %d %d", i, nrows); /* ** create new design file */ dest = VCreateImage(1, nrows, ncols + add_cols, VPixelRepn(design)); VFillImage(dest, VAllBands, 1); VCopyImageAttrs(design, dest); for(r = 0; r < nrows; r++) { for(c = 0; c < ncols; c++) { u = VGetPixel(design, 0, r, c); VSetPixel(dest, 0, r, c, u); } } /* add covariates */ for(r = 0; r < nrows; r++) { for(c = 0; c < add_cols; c++) { u = VPixel(tmp, 0, r, c, VFloat); VSetPixel(dest, 0, r, c + ncols - 1, u); } } fprintf(stderr, " %d columns added to design file\n", add_cols); return dest; }
/*! \fn VImage VTriLinearSample3d (VImage src,VImage dest,VImage transform, float b0,float r0,float c0,int dst_nbands,int dst_nrows,int dst_ncolumns) \brief Resample a 3D image using trilinear interpolation. \param src input image (any repn) \param dest output image (any repn) \param transform 4x3 transformation image (float or double repn). The first column of <transform> contains the translation vector. The remaining three columns contains the 3x3 linear transformation matrix. \param b0 slice address that remains fixed \param r0 row address that remains fixed \param c0 column address that remains fixed \param dst_nbands number of output slices \param dst_nrows number of output rows \param dst_ncolumns number of output columns */ VImage VTriLinearSample3d(VImage src,VImage dest,VImage transform, float b0,float r0,float c0, int dst_nbands,int dst_nrows,int dst_ncolumns) { int src_nrows, src_ncols, src_nbands; VRepnKind repn; int b,r,c; int i,j,n; float bp,rp,cp,bx,rx,cx; float a[3][3],ainv[3][3],detA,signx; float shift[3]; float val; int sx, sy, sz; /* origin of subcube */ float px, py, pz; /* fractions of subcube */ float qx, qy, qz; /* fractions of subcube */ float value; /* value of voxel */ int lx, ly, lz; /* lengths */ int ox, oy, oz; /* offsets */ int x, y, z; /* indices */ if (VPixelRepn(transform) != VFloatRepn && VPixelRepn(transform) != VDoubleRepn) VError("transform image must be float or double repn"); /* Extract data from source image */ src_nrows = VImageNRows(src); src_ncols = VImageNColumns(src); src_nbands = VImageNBands(src); repn = VPixelRepn(src); /* get transformation matrix : */ for (i=0; i<3; i++) { for (j=0; j<3; j++) { a[i][j] = VGetPixel(transform,0,i,j+1); } } /* get its inverse : */ ainv[0][0] = a[1][1]*a[2][2] - a[1][2]*a[2][1]; ainv[1][0] = -a[1][0]*a[2][2] + a[1][2]*a[2][0]; ainv[2][0] = a[1][0]*a[2][1] - a[1][1]*a[2][0]; ainv[0][1] = -a[0][1]*a[2][2] + a[0][2]*a[2][1]; ainv[1][1] = a[0][0]*a[2][2] - a[0][2]*a[2][0]; ainv[2][1] = -a[0][0]*a[2][1] + a[0][1]*a[2][0]; ainv[0][2] = a[0][1]*a[1][2] - a[0][2]*a[1][1]; ainv[1][2] = -a[0][0]*a[1][2] + a[0][2]*a[1][0]; ainv[2][2] = a[0][0]*a[1][1] - a[0][1]*a[1][0]; /* determinant */ detA = a[0][0]*ainv[0][0] + a[0][1]*ainv[1][0] + a[0][2]*ainv[2][0]; if (detA == 0) VError(" VTriLinearSample3d: transformation matrix is singular"); for (i=0; i<3; i++) { for (j=0; j<3; j++) { ainv[i][j] /= detA; } } /* get translation vector */ shift[0] = VGetPixel(transform,0,0,0); shift[1] = VGetPixel(transform,0,1,0); shift[2] = VGetPixel(transform,0,2,0); #define GetValues(type) \ { \ type *src_pp; \ src_pp = (type *) VPixelPtr (src, sz, sy, sx); \ val += (float) pz * py * px * *src_pp; src_pp += ox; \ val += (float) pz * py * qx * *src_pp; src_pp += oy; \ val += (float) pz * qy * px * *src_pp; src_pp += ox; \ val += (float) pz * qy * qx * *src_pp; src_pp += oz; \ val += (float) qz * py * px * *src_pp; src_pp += ox; \ val += (float) qz * py * qx * *src_pp; src_pp += oy; \ val += (float) qz * qy * px * *src_pp; src_pp += ox; \ val += (float) qz * qy * qx * *src_pp; \ VPixel(dest,b,r,c,type) = val; \ } /* ** create output image */ dest = VSelectDestImage("VTriLinearSample3d",dest,dst_nbands,dst_nrows,dst_ncolumns,repn); if (! dest) return NULL; VFillImage(dest,VAllBands,0); /* Determines the value of each pixel in the destination image: */ for (b=0; b<dst_nbands; b++) { for (r=0; r<dst_nrows; r++) { for (c=0; c<dst_ncolumns; c++) { bx = (float) b - shift[0]; rx = (float) r - shift[1]; cx = (float) c - shift[2]; bp = ainv[0][0] * bx + ainv[0][1] * rx + ainv[0][2] * cx; rp = ainv[1][0] * bx + ainv[1][1] * rx + ainv[1][2] * cx; cp = ainv[2][0] * bx + ainv[2][1] * rx + ainv[2][2] * cx; bp += b0; rp += r0; cp += c0; if (bp < 0 || bp > src_nbands) continue; if (rp < 0 || rp > src_nrows) continue; if (cp < 0 || cp > src_ncols) continue; /* compute origin of subcube */ sx = (int) (cp); sy = (int) (rp); sz = (int) (bp); /* check subcube */ if ((sx < -1) || (sx > src_ncols - 1)) continue; if ((sy < -1) || (sy > src_nrows - 1)) continue; if ((sz < -1) || (sz > src_nbands - 1)) continue; /* compute fractions of subcube */ qx = cp - sx; px = 1 - qx; qy = rp - sy; py = 1 - qy; qz = bp - sz; pz = 1 - qz; /* compute lengths and offsets */ lx = 1; ly = src_ncols; lz = src_nrows * src_ncols; if (sx == -1) {sx = 0; lx = 0;}; if (sy == -1) {sy = 0; ly = 0;}; if (sz == -1) {sz = 0; lz = 0;}; if (sx == src_ncols - 1) lx = 0; if (sy == src_nrows - 1) ly = 0; if (sz == src_nbands - 1) lz = 0; ox = lx; oy = ox + ly - 2 * lx; oz = oy + lz - 2 * ly; val = 0; switch(repn) { case VShortRepn: GetValues(VShort); break; case VUByteRepn: GetValues(VUByte); break; case VFloatRepn: GetValues(VFloat); break; case VSByteRepn: GetValues(VSByte); break; default: VError(" illegal pixel repn"); } } } } VCopyImageAttrs (src, dest); return dest; }
/* ** general linear regression */ VAttrList VRegression(ListInfo *linfo, int nlists, VShort minval, VImage design, VFloat sigma, VLong itr) { VAttrList out_list; VImageInfo *xinfo; int nbands = 0, nslices = 0, nrows = 0, ncols = 0, slice, row, col, nr, nc; VImage src[NSLICES], res_image = NULL; VImage beta_image[MBETA], BCOV = NULL, KX_image = NULL; VImage res_map[ETMP]; float smooth_fwhm = 0, vx = 0, vy = 0, vz = 0; VFloat *float_pp, df; VRepnKind repn; float d, err; int i, k, l, n, m = 0, nt, fd = 0, npix = 0; int i0 = 0, i1 = 0; double u, sig, trace = 0, trace2 = 0, var = 0, sum = 0, nx = 0, mean = 0, sum2; float *ptr1, *ptr2; double x; gsl_matrix_float *X = NULL, *XInv = NULL, *SX = NULL; gsl_vector_float *y, *z, *beta, *ys; gsl_vector *kernel; gsl_matrix_float *S = NULL, *Vc = NULL, *F = NULL, *P = NULL, *Q = NULL; gsl_matrix_float *R = NULL, *RV = NULL; VBoolean smooth = TRUE; /* no smoothness estimation */ gsl_set_error_handler_off(); /* ** read input data */ nslices = nbands = nrows = ncols = 0; for(k = 0; k < nlists; k++) { n = linfo[k].nslices; nr = linfo[k].nrows; nc = linfo[k].ncols; nt = linfo[k].ntimesteps; nbands += nt; if(nslices == 0) nslices = n; else if(nslices != n) VError(" inconsistent image dimensions, slices: %d %d", n, nslices); if(nrows == 0) nrows = nr; else if(nrows != nr) VError(" inconsistent image dimensions, rows: %d %d", nr, nrows); if(ncols == 0) ncols = nc; else if(ncols != nc) VError(" inconsistent image dimensions, cols: %d %d", nc, ncols); } fprintf(stderr, " num images: %d, image dimensions: %d x %d x %d\n", nlists, nslices, nrows, ncols); /* ** get design dimensions */ m = VImageNRows(design); /* number of timesteps */ n = VImageNColumns(design); /* number of covariates */ fprintf(stderr, " ntimesteps=%d, num covariates=%d\n", m, n); if(n >= MBETA) VError(" too many covariates (%d), max is %d", n, MBETA); if(m != nbands) VError(" design dimension inconsistency: %d %d", m, nbands); fprintf(stderr, " working...\n"); /* ** read design matrix */ X = gsl_matrix_float_alloc(m, n); for(k = 0; k < m; k++) { for(l = 0; l < n; l++) { x = VGetPixel(design, 0, k, l); fmset(X, k, l, (float)x); } } /* ** pre-coloring, set up K-matrix, S=K, V = K*K^T with K=S */ S = gsl_matrix_float_alloc(m, m); GaussMatrix((double)sigma, S); Vc = fmat_x_matT(S, S, NULL); /* ** compute pseudoinverse */ SX = fmat_x_mat(S, X, NULL); XInv = fmat_PseudoInv(SX, NULL); /* ** get variance estimate */ Q = fmat_x_mat(XInv, Vc, Q); F = fmat_x_matT(Q, XInv, F); BCOV = VCreateImage(1, n, n, VFloatRepn); float_pp = VImageData(BCOV); ptr1 = F->data; for(i = 0; i < n * n; i++) *float_pp++ = *ptr1++; gsl_matrix_float_free(Q); gsl_matrix_float_free(F); /* ** get effective degrees of freedom */ R = gsl_matrix_float_alloc(m, m); P = fmat_x_mat(SX, XInv, P); gsl_matrix_float_set_identity(R); gsl_matrix_float_sub(R, P); RV = fmat_x_mat(R, Vc, NULL); trace = 0; for(i = 0; i < m; i++) trace += fmget(RV, i, i); P = fmat_x_mat(RV, RV, P); trace2 = 0; for(i = 0; i < m; i++) trace2 += fmget(P, i, i); df = (trace * trace) / trace2; fprintf(stderr, " df= %.3f\n", df); /* ** create output images */ /* * Get attribute list from first image in first file (filename is linfo[0].filename) * */ /************ * TILOSTUFF * *************/ VImage attribute_image = read_attribute_template(linfo[0].filename); xinfo = linfo[0].info; out_list = VCreateAttrList(); res_image = VCreateImage(nslices, nrows, ncols, VFloatRepn); VFillImage(res_image, VAllBands, 0); VCopyImageAttrs(attribute_image, res_image); VSetAttr(VImageAttrList(res_image), "name", NULL, VStringRepn, "RES/trRV"); VSetAttr(VImageAttrList(res_image), "modality", NULL, VStringRepn, "RES/trRV"); VSetAttr(VImageAttrList(res_image), "df", NULL, VFloatRepn, df); VSetAttr(VImageAttrList(res_image), "patient", NULL, VStringRepn, xinfo->patient); VSetAttr(VImageAttrList(res_image), "voxel", NULL, VStringRepn, xinfo->voxel); VSetAttr(VImageAttrList(res_image), "repetition_time", NULL, VLongRepn, itr); VSetAttr(VImageAttrList(res_image), "talairach", NULL, VStringRepn, xinfo->talairach); /* neu */ VSetAttr(VImageAttrList(res_image),"indexOrigin",NULL,VStringRepn,xinfo->indexOrigin); VSetAttr(VImageAttrList(res_image),"columnVec",NULL,VStringRepn,xinfo->columnVec); VSetAttr(VImageAttrList(res_image),"rowVec",NULL,VStringRepn,xinfo->rowVec); VSetAttr(VImageAttrList(res_image),"sliceVec",NULL,VStringRepn,xinfo->sliceVec); VSetAttr(VImageAttrList(res_image),"FOV",NULL,VStringRepn,xinfo->FOV); /*--------*/ if(xinfo->fixpoint[0] != 'N') VSetAttr(VImageAttrList(res_image), "fixpoint", NULL, VStringRepn, xinfo->fixpoint); if(xinfo->ca[0] != 'N') { VSetAttr(VImageAttrList(res_image), "ca", NULL, VStringRepn, xinfo->ca); VSetAttr(VImageAttrList(res_image), "cp", NULL, VStringRepn, xinfo->cp); VSetAttr(VImageAttrList(res_image), "extent", NULL, VStringRepn, xinfo->extent); } VAppendAttr(out_list, "image", NULL, VImageRepn, res_image); for(i = 0; i < n; i++) { beta_image[i] = VCreateImage(nslices, nrows, ncols, VFloatRepn); VFillImage(beta_image[i], VAllBands, 0); VCopyImageAttrs(attribute_image, beta_image[i]); VSetAttr(VImageAttrList(beta_image[i]), "patient", NULL, VStringRepn, xinfo->patient); VSetAttr(VImageAttrList(beta_image[i]), "voxel", NULL, VStringRepn, xinfo->voxel); VSetAttr(VImageAttrList(beta_image[i]), "repetition_time", NULL, VLongRepn, itr); VSetAttr(VImageAttrList(beta_image[i]), "talairach", NULL, VStringRepn, xinfo->talairach); /* neu */ VSetAttr(VImageAttrList(beta_image[i]),"indexOrigin",NULL,VStringRepn,xinfo->indexOrigin); VSetAttr(VImageAttrList(beta_image[i]),"columnVec",NULL,VStringRepn,xinfo->columnVec); VSetAttr(VImageAttrList(beta_image[i]),"rowVec",NULL,VStringRepn,xinfo->rowVec); VSetAttr(VImageAttrList(beta_image[i]),"sliceVec",NULL,VStringRepn,xinfo->sliceVec); VSetAttr(VImageAttrList(beta_image[i]),"FOV",NULL,VStringRepn,xinfo->FOV); /*--------*/ if(xinfo->fixpoint[0] != 'N') VSetAttr(VImageAttrList(beta_image[i]), "fixpoint", NULL, VStringRepn, xinfo->fixpoint); if(xinfo->ca[0] != 'N') { VSetAttr(VImageAttrList(beta_image[i]), "ca", NULL, VStringRepn, xinfo->ca); VSetAttr(VImageAttrList(beta_image[i]), "cp", NULL, VStringRepn, xinfo->cp); VSetAttr(VImageAttrList(beta_image[i]), "extent", NULL, VStringRepn, xinfo->extent); } VSetAttr(VImageAttrList(beta_image[i]), "name", NULL, VStringRepn, "BETA"); VSetAttr(VImageAttrList(beta_image[i]), "modality", NULL, VStringRepn, "BETA"); VSetAttr(VImageAttrList(beta_image[i]), "beta", NULL, VShortRepn, i + 1); VSetAttr(VImageAttrList(beta_image[i]), "df", NULL, VFloatRepn, df); VAppendAttr(out_list, "image", NULL, VImageRepn, beta_image[i]); } VSetAttr(VImageAttrList(design), "name", NULL, VStringRepn, "X"); VSetAttr(VImageAttrList(design), "modality", NULL, VStringRepn, "X"); VAppendAttr(out_list, "image", NULL, VImageRepn, design); KX_image = Mat2Vista(SX); VSetAttr(VImageAttrList(KX_image), "name", NULL, VStringRepn, "KX"); VSetAttr(VImageAttrList(KX_image), "modality", NULL, VStringRepn, "KX"); VAppendAttr(out_list, "image", NULL, VImageRepn, KX_image); VSetAttr(VImageAttrList(BCOV), "name", NULL, VStringRepn, "BCOV"); VSetAttr(VImageAttrList(BCOV), "modality", NULL, VStringRepn, "BCOV"); VAppendAttr(out_list, "image", NULL, VImageRepn, BCOV); /* ** create temporary images for smoothness estimation */ /* smoothness estim only for 3D images, i.e. CA/CP known */ /* if(xinfo->ca[0] == 'N') smooth = FALSE;*/ if(smooth) { i0 = 20; i1 = i0 + 30; if(i1 > m) i1 = m; for(i = i0; i < i1; i++) { if(i - i0 >= ETMP) VError(" too many tmp images"); res_map[i - i0] = VCreateImage(nslices, nrows, ncols, VFloatRepn); VFillImage(res_map[i - i0], VAllBands, 0); } } /* ** process */ ys = gsl_vector_float_alloc(m); y = gsl_vector_float_alloc(m); z = gsl_vector_float_alloc(m); beta = gsl_vector_float_alloc(n); kernel = GaussKernel((double)sigma); for(k = 0; k < nlists; k++) { src[k] = VCreateImage(linfo[k].ntimesteps, nrows, ncols, linfo[k].repn); VFillImage(src[k], VAllBands, 0); } npix = 0; for(slice = 0; slice < nslices; slice++) { if(slice % 5 == 0) fprintf(stderr, " slice: %3d\r", slice); for(k = 0; k < nlists; k++) { if(linfo[k].zero[slice] == 0) goto next1; fd = open(linfo[k].filename, O_RDONLY); if(fd == -1) VError("could not open file %s", linfo[k].filename); nt = linfo[k].ntimesteps; if(! VReadBandDataFD(fd, &linfo[k].info[slice], 0, nt, &src[k])) VError(" error reading data"); close(fd); } repn = linfo[0].repn; for(row = 0; row < nrows; row++) { for(col = 0; col < ncols; col++) { for(k = 0; k < nlists; k++) if(VPixel(src[k], 0, row, col, VShort) < minval + 1) goto next; npix++; /* read time series data */ sum = sum2 = nx = 0; ptr1 = y->data; for(k = 0; k < nlists; k++) { nt = VImageNBands(src[k]); for(i = 0; i < nt; i++) { u = VPixel(src[k], i, row, col, VShort); (*ptr1++) = u; sum += u; sum2 += u * u; nx++; } } mean = sum / nx; sig = sqrt((double)((sum2 - nx * mean * mean) / (nx - 1.0))); if(sig < 0.001) continue; /* centering and scaling, Seber, p.330 */ ptr1 = y->data; for(i = 0; i < m; i++) { u = ((*ptr1) - mean) / sig; (*ptr1++) = u + 100.0; } /* S x y */ ys = VectorConvolve(y, ys, kernel); /* compute beta's */ fmat_x_vector(XInv, ys, beta); /* residuals */ fmat_x_vector(SX, beta, z); err = 0; ptr1 = ys->data; ptr2 = z->data; for(i = 0; i < m; i++) { d = ((*ptr1++) - (*ptr2++)); err += d * d; } /* sigma^2 */ var = err / trace; /* write residuals output */ VPixel(res_image, slice, row, col, VFloat) = (VFloat)var; /* save residuals of several timesteps for smoothness estimation */ if(smooth) { ptr1 = ys->data; ptr2 = z->data; err = 0; for(i = i0; i < i1; i++) { d = ((*ptr1++) - (*ptr2++)); err += d * d; VPixel(res_map[i - i0], slice, row, col, VFloat) = d; } if (err > 0) err = sqrt(err); for(i = i0; i < i1; i++) { d = VPixel(res_map[i - i0], slice, row, col, VFloat); if (err > 1.0e-6) d /= err; else d = 0; VPixel(res_map[i - i0], slice, row, col, VFloat) = d / err; } } /* write beta output */ ptr1 = beta->data; for(i = 0; i < n; i++) VPixel(beta_image[i], slice, row, col, VFloat) = (VFloat)(*ptr1++); next: ; } } next1: ; } /* ** Smoothness estimation based on residual images */ if(smooth) { smooth_fwhm = VSmoothnessEstim(res_map, i1 - i0); sscanf(xinfo->voxel, "%f %f %f", &vx, &vy, &vz); vx = (vx + vy + vz) / 3.0; /* voxels should be isotropic */ smooth_fwhm *= vx; fprintf(stderr, " smoothness: %f\n", smooth_fwhm); VSetAttr(VImageAttrList(res_image), "smoothness", NULL, VFloatRepn, smooth_fwhm); for(i = 0; i < n; i++) { VSetAttr(VImageAttrList(beta_image[i]), "smoothness", NULL, VFloatRepn, smooth_fwhm); } for(i = 0; i < i1 - i0; i++) VDestroyImage(res_map[i]); } ende: if(npix == 0) VError(" no voxels above threshold %d found", minval); return out_list; }
/*! \fn VImage VContrast(VImage src,VImage dest,VRepnKind repn,VFloat alpha,VFloat background) \param src input image (any repn) \param dest output image (any repn) \param repn the output pixel repn (e.g. VUByteRepn) \param alpha contrast stretching factor. The function stretches grey values between mean-alpha*sigma and mean+alpha*sigma. \param background input grey values with absolute values less than <background> are assumed to be image background and are not used for computing the image mean and sigma. If set to zero, it has no effect. */ VImage VContrast(VImage src,VImage dest,VRepnKind repn,VFloat alpha,VFloat background) { int i,nbands,nrows,ncols,npixels; float u,xmin,xmax,ymin,ymax,slope,smin,smax; float sum1,sum2,nx; float mean,sigma; if (repn == VDoubleRepn || repn == VLongRepn || repn == VSByteRepn) VError(" double, long and sbyte are not supported by VContrast"); if (alpha <= 0) VError("alpha must be positive"); nbands = VImageNBands(src); nrows = VImageNRows(src); ncols = VImageNColumns(src); npixels = VImageNPixels(src); dest = VSelectDestImage("VContrast",dest,nbands,nrows,ncols,repn); if (! dest) VError(" err creating dest image"); VFillImage(dest,VAllBands,0); smin = VPixelMaxValue(src); smax = VPixelMinValue(src); sum1 = sum2 = nx = 0; for (i=0; i<npixels; i++) { u = VGetPixelValue (src,i); if (ABS(u) < background) continue; if (u < smin) smin = u; if (u > smax) smax = u; sum1 += u; sum2 += u*u; nx++; } if (nx < 2) VError(" no foreground pixels found"); mean = sum1/nx; sigma = sqrt((double)((sum2 - nx * mean * mean) / (nx - 1.0))); ymax = VPixelMaxValue(dest); ymin = VPixelMinValue(dest); xmax = mean + alpha * sigma; if (xmax > smax) xmax = smax; xmin = mean - alpha * sigma; if (xmin < smin) xmin = smin; slope = (ymax - ymin) / (xmax - xmin); for (i=0; i<npixels; i++) { u = VGetPixelValue (src,i); if (u != 0) u = slope * (u - xmin); if (u > ymax) u = ymax; if (u < ymin) u = ymin; VSetPixelValue(dest,i,(VFloat) u); } VCopyImageAttrs (src, dest); return dest; }
/*! \fn VImage VBiLinearScale2d (VImage src,VImage dest,int dest_nrows,int dest_ncols, VFloat yscale,VFloat xscale) \brief Scale all slices of a 3D image using a 2D slicewise bilinear interpolation. \param src input image (any repn) \param dest output image (any repn) \param dest_nrows number of rows in output image \param dest_ncols number of columns in output image \param shift[2] translation vector (row,column) \param scale[2] scaling vector (row,column) */ VImage VBiLinearScale2d (VImage src,VImage dest,int dest_nrows,int dest_ncols, VFloat shift[2], VFloat scale[2]) { int b,r,c; float rp=0,cp=0,x,y,yscale,xscale; int right,left,top,bottom; float p1,p2,p3,p4; float val; int nrows,ncols,nbands; VRepnKind repn; /* Extract data from source image */ nrows = VImageNRows(src); ncols = VImageNColumns(src); nbands = VImageNBands(src); repn = VPixelRepn(src); dest = VSelectDestImage("VBiLinearScale2d",dest,nbands,dest_nrows,dest_ncols,repn); if (! dest) return NULL; VFillImage(dest,VAllBands,0); #define Top(r) ( (int) (r) ) #define Bottom(r) ( (int) (r) + 1 ) #define Left(c) ( (int) (c) ) #define Right(c) ( (int) (c) + 1 ) yscale = 1.0 / scale[0]; xscale = 1.0 / scale[1]; for (b = 0; b < nbands; b++) { for (r = 0; r < dest_nrows; r++) { rp = yscale * ((float) r - shift[0]); if (rp < 0 || rp >= nrows) continue; for (c = 0; c < dest_ncols; c++) { cp = xscale * ((float) c - shift[1]); if (cp < 0 || cp >= ncols) continue; right = Right(cp); left = Left(cp); if (left < 0 || right >= ncols) continue; top = Top(rp); bottom = Bottom(rp); if (top < 0 || bottom >= nrows) continue; x = right - cp; y = bottom - rp; p1 = VGetPixel(src,b,top,left); p2 = VGetPixel(src,b,top,right); p3 = VGetPixel(src,b,bottom,left); p4 = VGetPixel(src,b,bottom,right); val = x * y * p1 + (1-x) * y * p2 + x * (1-y) * p3 + (1-x) * (1-y) * p4; if (repn == VUByteRepn) { val = (int)(val + 0.5); if (val < 0) val = 0; if (val > 255) val = 255; } VSetPixel(dest,b,r,c,(VDouble) val); } } } VCopyImageAttrs (src, dest); return dest; }
VImage VContrastAny(VImage src,VImage dest,VFloat low,VFloat high) { int nbands,nrows,ncols; double xmin,xmax,slope,sum,a; float *histo; int b,r,c,j,dim; VUByte *dest_pp; double smin,smax,u,v,tiny; nbands = VImageNBands(src); nrows = VImageNRows(src); ncols = VImageNColumns(src); dest = VSelectDestImage("VContrastAny",dest,nbands,nrows,ncols,VUByteRepn); if (! dest) VError(" err creating dest image"); VFillImage(dest,VAllBands,0); smin = VPixelMaxValue(src); smax = VPixelMinValue(src); for (b=0; b<nbands; b++) { for (r=0; r<nrows; r++) { for (c=0; c<ncols; c++) { u = VGetPixel(src,b,r,c); if (u < smin) smin = u; if (u > smax) smax = u; } } } dim = 10000; if (VPixelRepn(src) == VUByteRepn) dim = 256; histo = (float *) VCalloc(dim,sizeof(float)); for (j=0; j<dim; j++) histo[j] = 0; tiny = 2.0/(double)dim; a = ((double) dim) / (smax - smin); for (b=0; b<nbands; b++) { for (r=0; r<nrows; r++) { for (c=0; c<ncols; c++) { u = VGetPixel(src,b,r,c); if (ABS(u) < tiny) continue; j = (int) (a * (u - smin) + 0.5); if (j < 0) j = 0; if (j >= dim) j = dim-1; histo[j]++; } } } sum = 0; for (j=0; j<dim; j++) sum += histo[j]; for (j=0; j<dim; j++) histo[j] /= sum; xmin = 0; sum = 0; for (j=0; j<dim; j++) { sum += histo[j]; if (sum > low) break; } xmin = ((double)j)/a + smin; xmax = dim; sum = 0; for (j=dim; j>0; j--) { sum += histo[j]; if (sum > high) break; } xmax = ((double)j)/a + smin; slope = 255.0 / (xmax - xmin); dest_pp = (VUByte *) VImageData(dest); for (b=0; b<nbands; b++) { for (r=0; r<nrows; r++) { for (c=0; c<ncols; c++) { u = VGetPixel(src,b,r,c); v = (int) (slope * (u - xmin) + 0.5); if (ABS(u) < tiny) v = 0; if (v < 0) v = 0; if (v > 255) v = 255; *dest_pp++ = (VUByte) v; } } } VCopyImageAttrs (src, dest); return dest; }
static VImage RotateImage (VImage src, VImage dest, VBand band, double angle) { double shearx, sheary; int margin_nrows, margin_ncols; int src_nbands; /* src_repn, src_nrows, src_ncols; */ VImage sx_image, sysx_image, sxsysx_image, cropped_image; /* Ensure that range of "angle" is valid: */ if (angle <= -0.5 * M_PI || angle >= 0.5 * M_PI) { VWarning ("VRotateImage: Internal error in RotateImage"); return NULL; } /* Determine "shearx" and "sheary": */ shearx = - tan (angle / 2.0); sheary = sin (angle); /* Read properties of "src": */ /* src_nrows = VImageNRows (src); */ /* src_ncols = VImageNColumns (src); */ /* src_repn = VPixelRepn (src); */ src_nbands = VImageNBands (src); /* Check to ensure that "band" exists: */ if (band != VAllBands && (band < 0 || band >= src_nbands)) { VWarning ("VRotateImage: Band %d referenced in image of %d bands", band, VImageNBands (src)); return NULL; } /* First shear in x direction: */ sx_image = VShearImageX (src, NULL, band, shearx); if (sx_image == NULL) return NULL; /* Then shear in y direction: */ sysx_image = VShearImageY (sx_image, NULL, VAllBands, sheary); if (sysx_image == NULL) return NULL; /* Finally, shear in x direction again: */ sxsysx_image = VShearImageX (sysx_image, NULL, VAllBands, shearx); if (sxsysx_image == NULL) return NULL; /* Calculate margin (unwanted blank space) sizes: */ margin_nrows = VImageNRows (src) * fabs (shearx) * fabs (sheary); margin_ncols = (VImageNRows (sysx_image) - VImageNRows (src)) * fabs (shearx); /* Remove margins: */ cropped_image = VCropImage (sxsysx_image, dest, VAllBands, margin_nrows, margin_ncols, VImageNRows (sxsysx_image) - 2 * margin_nrows, VImageNColumns (sxsysx_image) - 2 * margin_ncols); /* Clean up: */ VDestroyImage (sx_image); VDestroyImage (sysx_image); VDestroyImage (sxsysx_image); VCopyImageAttrs (src, cropped_image); return cropped_image; }