Significant changes to the RNiftyReg package are laid out below for each release. ================================================================================= VERSION 1.0.2 - A further compiler-sensitive problem, which was causing the package to fail to install using Solaris Studio, has been addressed. ================================================================================= VERSION 1.0.1 - A Windows-specific compile-time problem has been addressed. ================================================================================= VERSION 1.0.0 - RNiftyReg now provides an interface to the symmetric version of the NiftyReg nonlinear registration algorithm. This allows consistent transformations to be obtained in both directions, in one operation. - The upstream code has been updated to match NiftyReg v1.3.9. Default cost function weightings have also been tweaked to match those used in that release. - The type of an affine matrix is now written to file with it. The type therefore does not necessarily need to be specified when reading the matrix back in. - The "interpolationPrecision" option has been removed where it appeared. The code now simply makes an appropriate choice in each case. - Internal calculation of the final control point spacing from an initial control point image was sometimes wrong. This has been corrected. ================================================================================= VERSION 0.6.2 - Nonlinear registration now works properly for 2D target images. - Control point spacing is now set from the initial control point image (as it should be), if one is supplied. - Two small bugs in the upstream NiftyReg code have been fixed. - Attempting to perform 4D-to-2D registration now produces a more specific error message. ================================================================================= VERSION 0.6.1 - The package now redefines standard C print functions to avoid problems with output not being captured by R. ================================================================================= VERSION 0.6.0 - RNiftyReg can now perform nonlinear registration via the niftyreg.nonlinear() function. This method optimises over a set of moveable control points arranged in a grid over the image. The applyControlPoints() function has also been added as the nonlinear equivalent of applyAffine(). See ?niftyreg.nonlinear for details on these new functions. The niftyreg() function now serves as a common interface to both the linear and nonlinear optimisations. - The "initAffine" argument to niftyreg() now accepts a list of matrices as well as a single affine matrix. - The upstream NiftyReg code has been updated, thereby taking in a number of tweaks added since the last release version. - A bug in the quaternion-to-matrix conversion in xformToAffine() has been fixed. ================================================================================= VERSION 0.5.0 - The niftyreg() and applyAffine() functions gain an "interpolationPrecision" argument, which affects the data type of the final image. See ?niftyreg for details. - The actual number of algorithm iterations run at each level is now stored in the output produced by niftyreg(). - A bug has been addressed whereby niftyreg() returned the affine matrix used for initialisation, if specified, rather than the final one. (Reported by Brandon Whitcher.) - The first level of the algorithm is supposed to include both a rigid-body and affine optimisation, but the latter was previously omitted due to a bug. This has been corrected. In addition, the first level is allowed twice as many iterations as subsequent levels, as in the original NiftyReg implementation. - The "data_type" slot of the "nifti" class is now properly set in the image returned by niftyreg(). - The underlying NIfTI reference library files have been updated. - Spurious parameters have been removed to avoid warnings at compile time. - Calls to problematic C/C++ functions such as exit() have been avoided (although NIfTI and NiftyReg library functions still use printf() and the like). ================================================================================= VERSION 0.4.1 - The reportr package is now properly imported in the namespace file. ================================================================================= VERSION 0.4.0 - The applyAffine() function has been added as a convenience wrapper to niftyreg(...,nLevels=0), for applying a precomputed affine transformation to a new image without further optimisation. - RNiftyReg now uses the reportr package for message and error reporting. - The package now has a formal namespace. ================================================================================= VERSION 0.3.1 - A bug in previous releases affecting the downsampling of images during early "levels" of alignment has been fixed. Coregistration of larger images, in particular, should be improved as a result. ================================================================================= VERSION 0.3.0 - 2D-to-2D, 3D-to-2D and 4D-to-3D registration are now supported by niftyreg(). As a result of this added flexibility, a list of affine matrices, rather than a single matrix, is now returned by this function. - An image of fewer than 4 pixels/voxels in any dimension cannot be registered since it cannot accommodate a single matching block. Providing such an image as the source or target now produces an error rather than a crash. (Thanks to Takeo Katsuki for pointing this out.) - Further documentation improvements. ================================================================================= VERSION 0.2.0 - Added an option to niftyreg() to control the type of interpolation that is applied to the final coregistered image. - Performing better type checking of image data before passing it to the C++ code, to avoid intermittent errors from R. - Documentation improvements. ================================================================================= VERSION 0.1.0 - First public release. 3D affine and rigid-body registration are available. =================================================================================