diff --git a/doc/devel/python_interface_devel.rst b/doc/devel/python_interface_devel.rst
index a63bc2e90a..1c5f1667a2 100644
--- a/doc/devel/python_interface_devel.rst
+++ b/doc/devel/python_interface_devel.rst
@@ -41,7 +41,7 @@ do is to define inputs, outputs, _run_interface() (not run()), and _list_outputs
             thresholded_map = np.zeros(data.shape)
             thresholded_map[active_map] = data[active_map]
 
-            new_img = nb.Nifti1Image(thresholded_map, img.get_affine(), img.get_header())
+            new_img = nb.Nifti1Image(thresholded_map, img.affine, img.header)
             _, base, _ = split_filename(fname)
             nb.save(new_img, base + '_thresholded.nii')
 
diff --git a/examples/dmri_camino_dti.py b/examples/dmri_camino_dti.py
index bf94ebdae9..20392d9bf5 100755
--- a/examples/dmri_camino_dti.py
+++ b/examples/dmri_camino_dti.py
@@ -39,7 +39,7 @@ def get_vox_dims(volume):
     if isinstance(volume, list):
         volume = volume[0]
     nii = nb.load(volume)
-    hdr = nii.get_header()
+    hdr = nii.header
     voxdims = hdr.get_zooms()
     return [float(voxdims[0]), float(voxdims[1]), float(voxdims[2])]
 
@@ -49,7 +49,7 @@ def get_data_dims(volume):
     if isinstance(volume, list):
         volume = volume[0]
     nii = nb.load(volume)
-    hdr = nii.get_header()
+    hdr = nii.header
     datadims = hdr.get_data_shape()
     return [int(datadims[0]), int(datadims[1]), int(datadims[2])]
 
@@ -57,7 +57,7 @@ def get_data_dims(volume):
 def get_affine(volume):
     import nibabel as nb
     nii = nb.load(volume)
-    return nii.get_affine()
+    return nii.affine
 
 subject_list = ['subj1']
 fsl.FSLCommand.set_default_output_type('NIFTI')
diff --git a/examples/dmri_connectivity.py b/examples/dmri_connectivity.py
index 35c7ee3c39..4b7debff8f 100755
--- a/examples/dmri_connectivity.py
+++ b/examples/dmri_connectivity.py
@@ -77,7 +77,7 @@ def get_vox_dims(volume):
     if isinstance(volume, list):
         volume = volume[0]
     nii = nb.load(volume)
-    hdr = nii.get_header()
+    hdr = nii.header
     voxdims = hdr.get_zooms()
     return [float(voxdims[0]), float(voxdims[1]), float(voxdims[2])]
 
@@ -87,7 +87,7 @@ def get_data_dims(volume):
     if isinstance(volume, list):
         volume = volume[0]
     nii = nb.load(volume)
-    hdr = nii.get_header()
+    hdr = nii.header
     datadims = hdr.get_data_shape()
     return [int(datadims[0]), int(datadims[1]), int(datadims[2])]
 
@@ -95,7 +95,7 @@ def get_data_dims(volume):
 def get_affine(volume):
     import nibabel as nb
     nii = nb.load(volume)
-    return nii.get_affine()
+    return nii.affine
 
 
 def select_aparc(list_of_files):
diff --git a/examples/fmri_ants_openfmri.py b/examples/fmri_ants_openfmri.py
index 8c9cbdcdd0..8c8e050097 100755
--- a/examples/fmri_ants_openfmri.py
+++ b/examples/fmri_ants_openfmri.py
@@ -80,8 +80,8 @@ def median(in_files):
             average = data
         else:
             average = average + data
-    median_img = nb.Nifti1Image(average / float(idx + 1),
-                                img.get_affine(), img.get_header())
+    median_img = nb.Nifti1Image(average / float(idx + 1), img.affine,
+                                img.header)
     filename = os.path.join(os.getcwd(), 'median.nii.gz')
     median_img.to_filename(filename)
     return filename
diff --git a/examples/fmri_fsl.py b/examples/fmri_fsl.py
index d33deaab24..89dd96c627 100755
--- a/examples/fmri_fsl.py
+++ b/examples/fmri_fsl.py
@@ -108,7 +108,7 @@ def getmiddlevolume(func):
     funcfile = func
     if isinstance(func, list):
         funcfile = func[0]
-    _, _, _, timepoints = load(funcfile).get_shape()
+    _, _, _, timepoints = load(funcfile).shape
     return int(timepoints / 2) - 1
 
 preproc.connect(inputnode, ('func', getmiddlevolume), extract_ref, 't_min')
diff --git a/examples/fmri_spm_auditory.py b/examples/fmri_spm_auditory.py
index 9933277f0f..94b6f1a565 100755
--- a/examples/fmri_spm_auditory.py
+++ b/examples/fmri_spm_auditory.py
@@ -123,7 +123,7 @@ def get_vox_dims(volume):
     if isinstance(volume, list):
         volume = volume[0]
     nii = nb.load(volume)
-    hdr = nii.get_header()
+    hdr = nii.header
     voxdims = hdr.get_zooms()
     return [float(voxdims[0]), float(voxdims[1]), float(voxdims[2])]
 
diff --git a/examples/fmri_spm_face.py b/examples/fmri_spm_face.py
index 7f918aafa7..942bace0ff 100755
--- a/examples/fmri_spm_face.py
+++ b/examples/fmri_spm_face.py
@@ -117,7 +117,7 @@ def get_vox_dims(volume):
     if isinstance(volume, list):
         volume = volume[0]
     nii = nb.load(volume)
-    hdr = nii.get_header()
+    hdr = nii.header
     voxdims = hdr.get_zooms()
     return [float(voxdims[0]), float(voxdims[1]), float(voxdims[2])]
 
diff --git a/examples/rsfmri_vol_surface_preprocessing.py b/examples/rsfmri_vol_surface_preprocessing.py
index 953d07595f..c375278629 100644
--- a/examples/rsfmri_vol_surface_preprocessing.py
+++ b/examples/rsfmri_vol_surface_preprocessing.py
@@ -125,8 +125,8 @@ def median(in_files):
             average = data
         else:
             average = average + data
-    median_img = nb.Nifti1Image(average / float(idx + 1),
-                                img.get_affine(), img.get_header())
+    median_img = nb.Nifti1Image(average / float(idx + 1), img.affine,
+                                img.header)
     filename = os.path.join(os.getcwd(), 'median.nii.gz')
     median_img.to_filename(filename)
     return filename
@@ -165,8 +165,7 @@ def bandpass_filter(files, lowpass_freq, highpass_freq, fs):
             filtered_data = data
         else:
             filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))
-        img_out = nb.Nifti1Image(filtered_data, img.get_affine(),
-                                 img.get_header())
+        img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)
         img_out.to_filename(out_file)
         out_files.append(out_file)
     return list_to_filename(out_files)
diff --git a/examples/rsfmri_vol_surface_preprocessing_nipy.py b/examples/rsfmri_vol_surface_preprocessing_nipy.py
index d3ace02535..477e1e377c 100644
--- a/examples/rsfmri_vol_surface_preprocessing_nipy.py
+++ b/examples/rsfmri_vol_surface_preprocessing_nipy.py
@@ -119,8 +119,8 @@ def median(in_files):
             average = data
         else:
             average = average + data
-    median_img = nb.Nifti1Image(average / float(idx + 1),
-                                img.get_affine(), img.get_header())
+    median_img = nb.Nifti1Image(average / float(idx + 1), img.affine,
+                                img.header)
     filename = os.path.join(os.getcwd(), 'median.nii.gz')
     median_img.to_filename(filename)
     return filename
@@ -156,8 +156,7 @@ def bandpass_filter(files, lowpass_freq, highpass_freq, fs):
             filtered_data = data
         else:
             filtered_data = np.real(np.fft.ifftn(np.fft.fftn(data) * F))
-        img_out = nb.Nifti1Image(filtered_data, img.get_affine(),
-                                 img.get_header())
+        img_out = nb.Nifti1Image(filtered_data, img.affine, img.header)
         img_out.to_filename(out_file)
         out_files.append(out_file)
     return list_to_filename(out_files)
diff --git a/nipype/algorithms/icc.py b/nipype/algorithms/icc.py
index 98758dfcbf..af61c260b9 100644
--- a/nipype/algorithms/icc.py
+++ b/nipype/algorithms/icc.py
@@ -49,19 +49,19 @@ def _run_interface(self, runtime):
             icc[x], subject_var[x], session_var[x], session_F[x], _, _ = ICC_rep_anova(Y)
 
         nim = nb.load(self.inputs.subjects_sessions[0][0])
-        new_data = np.zeros(nim.get_shape())
+        new_data = np.zeros(nim.shape)
         new_data[maskdata] = icc.reshape(-1,)
-        new_img = nb.Nifti1Image(new_data, nim.get_affine(), nim.get_header())
+        new_img = nb.Nifti1Image(new_data, nim.affine, nim.header)
         nb.save(new_img, 'icc_map.nii')
 
-        new_data = np.zeros(nim.get_shape())
+        new_data = np.zeros(nim.shape)
         new_data[maskdata] = session_var.reshape(-1,)
-        new_img = nb.Nifti1Image(new_data, nim.get_affine(), nim.get_header())
+        new_img = nb.Nifti1Image(new_data, nim.affine, nim.header)
         nb.save(new_img, 'session_var_map.nii')
 
-        new_data = np.zeros(nim.get_shape())
+        new_data = np.zeros(nim.shape)
         new_data[maskdata] = subject_var.reshape(-1,)
-        new_img = nb.Nifti1Image(new_data, nim.get_affine(), nim.get_header())
+        new_img = nb.Nifti1Image(new_data, nim.affine, nim.header)
         nb.save(new_img, 'subject_var_map.nii')
 
         return runtime
diff --git a/nipype/algorithms/mesh.py b/nipype/algorithms/mesh.py
index ed51d7bf13..ecf5dd59a2 100644
--- a/nipype/algorithms/mesh.py
+++ b/nipype/algorithms/mesh.py
@@ -111,13 +111,12 @@ def _run_interface(self, runtime):
         points = np.array(mesh.points)
         warp_dims = nb.funcs.four_to_three(nb.load(self.inputs.warp))
 
-        affine = warp_dims[0].get_affine()
-        voxsize = warp_dims[0].get_header().get_zooms()
+        affine = warp_dims[0].affine
+        voxsize = warp_dims[0].header.get_zooms()
         vox2ras = affine[0:3, 0:3]
         ras2vox = np.linalg.inv(vox2ras)
         origin = affine[0:3, 3]
-        voxpoints = np.array([np.dot(ras2vox,
-                                     (p - origin)) for p in points])
+        voxpoints = np.array([np.dot(ras2vox, (p - origin)) for p in points])
 
         warps = []
         for axis in warp_dims:
diff --git a/nipype/algorithms/metrics.py b/nipype/algorithms/metrics.py
index 746919e06e..bbc8ea8d59 100644
--- a/nipype/algorithms/metrics.py
+++ b/nipype/algorithms/metrics.py
@@ -92,9 +92,9 @@ def _eucl_min(self, nii1, nii2):
         origdata2 = nii2.get_data().astype(np.bool)
         border2 = self._find_border(origdata2)
 
-        set1_coordinates = self._get_coordinates(border1, nii1.get_affine())
+        set1_coordinates = self._get_coordinates(border1, nii1.affine)
 
-        set2_coordinates = self._get_coordinates(border2, nii2.get_affine())
+        set2_coordinates = self._get_coordinates(border2, nii2.affine)
 
         dist_matrix = cdist(set1_coordinates.T, set2_coordinates.T)
         (point1, point2) = np.unravel_index(
@@ -108,7 +108,7 @@ def _eucl_cog(self, nii1, nii2):
         origdata1 = nii1.get_data().astype(np.bool)
         cog_t = np.array(center_of_mass(origdata1)).reshape(-1, 1)
         cog_t = np.vstack((cog_t, np.array([1])))
-        cog_t_coor = np.dot(nii1.get_affine(), cog_t)[:3, :]
+        cog_t_coor = np.dot(nii1.affine, cog_t)[:3, :]
 
         origdata2 = nii2.get_data().astype(np.bool)
         (labeled_data, n_labels) = label(origdata2)
@@ -119,7 +119,7 @@ def _eucl_cog(self, nii1, nii2):
             cogs[:3, i] = np.array(center_of_mass(origdata2,
                                                   labeled_data, i + 1))
 
-        cogs_coor = np.dot(nii2.get_affine(), cogs)[:3, :]
+        cogs_coor = np.dot(nii2.affine, cogs)[:3, :]
 
         dist_matrix = cdist(cog_t_coor.T, cogs_coor.T)
 
@@ -131,8 +131,8 @@ def _eucl_mean(self, nii1, nii2, weighted=False):
 
         origdata2 = nii2.get_data().astype(np.bool)
 
-        set1_coordinates = self._get_coordinates(border1, nii1.get_affine())
-        set2_coordinates = self._get_coordinates(origdata2, nii2.get_affine())
+        set1_coordinates = self._get_coordinates(border1, nii1.affine)
+        set2_coordinates = self._get_coordinates(origdata2, nii2.affine)
 
         dist_matrix = cdist(set1_coordinates.T, set2_coordinates.T)
         min_dist_matrix = np.amin(dist_matrix, axis=0)
@@ -172,8 +172,8 @@ def _eucl_max(self, nii1, nii2):
         border1 = self._find_border(origdata1)
         border2 = self._find_border(origdata2)
 
-        set1_coordinates = self._get_coordinates(border1, nii1.get_affine())
-        set2_coordinates = self._get_coordinates(border2, nii2.get_affine())
+        set1_coordinates = self._get_coordinates(border1, nii1.affine)
+        set2_coordinates = self._get_coordinates(border2, nii2.affine)
         distances = cdist(set1_coordinates.T, set2_coordinates.T)
         mins = np.concatenate(
             (np.amin(distances, axis=0), np.amin(distances, axis=1)))
@@ -283,7 +283,7 @@ def _run_interface(self, runtime):
         scale = 1.0
 
         if self.inputs.vol_units == 'mm':
-            voxvol = nii1.get_header().get_zooms()
+            voxvol = nii1.header.get_zooms()
             for i in range(nii1.get_data().ndim - 1):
                 scale = scale * voxvol[i]
 
@@ -330,8 +330,8 @@ def _run_interface(self, runtime):
         both_data = np.zeros(data1.shape)
         both_data[(data1 - data2) != 0] = 1
 
-        nb.save(nb.Nifti1Image(both_data, nii1.get_affine(),
-                               nii1.get_header()), self.inputs.out_file)
+        nb.save(nb.Nifti1Image(both_data, nii1.affine, nii1.header),
+                self.inputs.out_file)
 
         self._labels = labels
         self._ove_rois = results
@@ -452,8 +452,9 @@ def _run_interface(self, runtime):
             ch[msk == 0] = 0
             diff += w * ch
 
-        nb.save(nb.Nifti1Image(diff, nb.load(self.inputs.in_ref[0]).get_affine(),
-                               nb.load(self.inputs.in_ref[0]).get_header()), self.inputs.out_file)
+        nb.save(nb.Nifti1Image(diff, nb.load(self.inputs.in_ref[0]).affine,
+                               nb.load(self.inputs.in_ref[0]).header),
+                self.inputs.out_file)
 
         return runtime
 
@@ -549,7 +550,7 @@ def _run_interface(self, runtime):
 
         errmap = errvectorexp.reshape(mapshape)
 
-        hdr = nii_ref.get_header().copy()
+        hdr = nii_ref.header.copy()
         hdr.set_data_dtype(np.float32)
         hdr['data_type'] = 16
         hdr.set_data_shape(mapshape)
@@ -563,7 +564,7 @@ def _run_interface(self, runtime):
         else:
             self._out_file = self.inputs.out_map
 
-        nb.Nifti1Image(errmap.astype(np.float32), nii_ref.get_affine(),
+        nb.Nifti1Image(errmap.astype(np.float32), nii_ref.affine,
                        hdr).to_filename(self._out_file)
 
         return runtime
diff --git a/nipype/algorithms/misc.py b/nipype/algorithms/misc.py
index e4e41326ce..84a905b065 100644
--- a/nipype/algorithms/misc.py
+++ b/nipype/algorithms/misc.py
@@ -111,7 +111,7 @@ def _get_brodmann_area(self):
                           1,
                           2 * self.inputs.dilation_size + 1))
 
-        return nb.Nifti1Image(newdata, nii.get_affine(), nii.get_header())
+        return nb.Nifti1Image(newdata, nii.affine, nii.header)
 
     def _list_outputs(self):
         outputs = self._outputs().get()
@@ -150,8 +150,7 @@ def _run_interface(self, runtime):
             thresholded_map = np.zeros(data.shape)
             thresholded_map[active_map] = data[active_map]
 
-            new_img = nb.Nifti1Image(
-                thresholded_map, img.get_affine(), img.get_header())
+            new_img = nb.Nifti1Image(thresholded_map, img.affine, img.header)
             _, base, _ = split_filename(fname)
             nb.save(new_img, base + '_thresholded.nii')
 
@@ -201,11 +200,11 @@ def _run_interface(self, runtime):
         for fname in self.inputs.volumes:
             img = nb.load(fname)
 
-            affine = img.get_affine()
+            affine = img.affine
             affine = np.dot(self.inputs.transformation_matrix, affine)
 
-            nb.save(nb.Nifti1Image(img.get_data(), affine,
-                                   img.get_header()), self._gen_output_filename(fname))
+            nb.save(nb.Nifti1Image(img.get_data(), affine, img.header),
+                    self._gen_output_filename(fname))
 
         return runtime
 
@@ -300,15 +299,15 @@ def _gen_output_file_name(self, suffix=None):
 
     def _run_interface(self, runtime):
         img = nb.load(self.inputs.in_file[0])
-        header = img.get_header().copy()
+        header = img.header.copy()
         vollist = [nb.load(filename) for filename in self.inputs.in_file]
         data = np.concatenate([vol.get_data().reshape(
-            vol.get_shape()[:3] + (-1,)) for vol in vollist], axis=3)
+            vol.shape[:3] + (-1,)) for vol in vollist], axis=3)
         if data.dtype.kind == 'i':
             header.set_data_dtype(np.float32)
             data = data.astype(np.float32)
         if isdefined(self.inputs.regress_poly):
-            timepoints = img.get_shape()[-1]
+            timepoints = img.shape[-1]
             X = np.ones((timepoints, 1))
             for i in range(self.inputs.regress_poly):
                 X = np.hstack((X, legendre(
@@ -319,16 +318,16 @@ def _run_interface(self, runtime):
                                              betas[1:, :, :, :], 0, 3)),
                                   0, 4)
             data = data - datahat
-            img = nb.Nifti1Image(data, img.get_affine(), header)
+            img = nb.Nifti1Image(data, img.affine, header)
             nb.save(img, self._gen_output_file_name('detrended'))
         meanimg = np.mean(data, axis=3)
         stddevimg = np.std(data, axis=3)
         tsnr = meanimg / stddevimg
-        img = nb.Nifti1Image(tsnr, img.get_affine(), header)
+        img = nb.Nifti1Image(tsnr, img.affine, header)
         nb.save(img, self._gen_output_file_name())
-        img = nb.Nifti1Image(meanimg, img.get_affine(), header)
+        img = nb.Nifti1Image(meanimg, img.affine, header)
         nb.save(img, self._gen_output_file_name('mean'))
-        img = nb.Nifti1Image(stddevimg, img.get_affine(), header)
+        img = nb.Nifti1Image(stddevimg, img.affine, header)
         nb.save(img, self._gen_output_file_name('stddev'))
         return runtime
 
@@ -1023,7 +1022,7 @@ def _run_interface(self, runtime):
 
         result = self.gen_noise(in_data, mask=in_mask, snr_db=snr,
                                 dist=self.inputs.dist, bg_dist=self.inputs.bg_dist)
-        res_im = nb.Nifti1Image(result, in_image.get_affine(), in_image.get_header())
+        res_im = nb.Nifti1Image(result, in_image.affine, in_image.header)
         res_im.to_filename(self._gen_output_filename())
         return runtime
 
@@ -1257,10 +1256,11 @@ def normalize_tpms(in_files, in_mask=None, out_files=[]):
     if len(in_files) == 1:
         img_data = imgs[0].get_data()
         img_data[img_data > 0.0] = 1.0
-        hdr = imgs[0].get_header().copy()
+        hdr = imgs[0].header.copy()
         hdr['data_type'] = 16
         hdr.set_data_dtype(np.float32)
-        nib.save(nib.Nifti1Image(img_data.astype(np.float32), imgs[0].get_affine(), hdr), out_files[0])
+        nib.save(nib.Nifti1Image(img_data.astype(np.float32), imgs[0].affine,
+                                 hdr), out_files[0])
         return out_files[0]
 
     img_data = np.array([im.get_data() for im in imgs]).astype(np.float32)
@@ -1281,10 +1281,11 @@ def normalize_tpms(in_files, in_mask=None, out_files=[]):
     for i, out_file in enumerate(out_files):
         data = np.ma.masked_equal(img_data[i], 0)
         probmap = data / weights
-        hdr = imgs[i].get_header().copy()
+        hdr = imgs[i].header.copy()
         hdr['data_type'] = 16
         hdr.set_data_dtype('float32')
-        nib.save(nib.Nifti1Image(probmap.astype(np.float32), imgs[i].get_affine(), hdr), out_file)
+        nib.save(nib.Nifti1Image(probmap.astype(np.float32), imgs[i].affine,
+                                 hdr), out_file)
 
     return out_files
 
@@ -1302,7 +1303,7 @@ def split_rois(in_file, mask=None, roishape=None):
         roishape = (10, 10, 1)
 
     im = nb.load(in_file)
-    imshape = im.get_shape()
+    imshape = im.shape
     dshape = imshape[:3]
     nvols = imshape[-1]
     roisize = roishape[0] * roishape[1] * roishape[2]
@@ -1391,9 +1392,9 @@ def merge_rois(in_files, in_idxs, in_ref,
             pass
 
     ref = nb.load(in_ref)
-    aff = ref.get_affine()
-    hdr = ref.get_header().copy()
-    rsh = ref.get_shape()
+    aff = ref.affine
+    hdr = ref.header.copy()
+    rsh = ref.shape
     del ref
     npix = rsh[0] * rsh[1] * rsh[2]
     fcdata = nb.load(in_files[0]).get_data()
diff --git a/nipype/algorithms/modelgen.py b/nipype/algorithms/modelgen.py
index 2fa95a3605..93aaeb042c 100644
--- a/nipype/algorithms/modelgen.py
+++ b/nipype/algorithms/modelgen.py
@@ -355,7 +355,7 @@ def _generate_standard_design(self, infolist,
             for i, out in enumerate(outliers):
                 numscans = 0
                 for f in filename_to_list(sessinfo[i]['scans']):
-                    shape = load(f).get_shape()
+                    shape = load(f).shape
                     if len(shape) == 3 or shape[3] == 1:
                         iflogger.warning(("You are using 3D instead of 4D "
                                           "files. Are you sure this was "
@@ -459,7 +459,7 @@ def _concatenate_info(self, infolist):
                 numscans = len(f)
             elif isinstance(f, string_types):
                 img = load(f)
-                numscans = img.get_shape()[3]
+                numscans = img.shape[3]
             else:
                 raise Exception('Functional input not specified correctly')
             nscans.insert(i, numscans)
@@ -779,7 +779,7 @@ def _generate_clustered_design(self, infolist):
             infoout[i].durations = None
             if info.conditions:
                 img = load(self.inputs.functional_runs[i])
-                nscans = img.get_shape()[3]
+                nscans = img.shape[3]
                 reg, regnames = self._cond_to_regress(info, nscans)
                 if hasattr(infoout[i], 'regressors') and infoout[i].regressors:
                     if not infoout[i].regressor_names:
diff --git a/nipype/algorithms/rapidart.py b/nipype/algorithms/rapidart.py
index 435b3c99e5..06ad009d50 100644
--- a/nipype/algorithms/rapidart.py
+++ b/nipype/algorithms/rapidart.py
@@ -362,10 +362,10 @@ def _detect_outliers_core(self, imgfile, motionfile, runidx, cwd=None):
                 nim = funcs.concat_images(images)
 
         # compute global intensity signal
-        (x, y, z, timepoints) = nim.get_shape()
+        (x, y, z, timepoints) = nim.shape
 
         data = nim.get_data()
-        affine = nim.get_affine()
+        affine = nim.affine
         g = np.zeros((timepoints, 1))
         masktype = self.inputs.mask_type
         if masktype == 'spm_global':  # spm_global like calculation
@@ -397,7 +397,7 @@ def _detect_outliers_core(self, imgfile, motionfile, runidx, cwd=None):
         elif masktype == 'file':  # uses a mask image to determine intensity
             maskimg = load(self.inputs.mask_file)
             mask = maskimg.get_data()
-            affine = maskimg.get_affine()
+            affine = maskimg.affine
             mask = mask > 0.5
             for t0 in range(timepoints):
                 vol = data[:, :, :, t0]
diff --git a/nipype/algorithms/tests/test_normalize_tpms.py b/nipype/algorithms/tests/test_normalize_tpms.py
index 56bd4e7ebf..d044eff77c 100644
--- a/nipype/algorithms/tests/test_normalize_tpms.py
+++ b/nipype/algorithms/tests/test_normalize_tpms.py
@@ -37,8 +37,8 @@ def test_normalize_tpms():
         data = im.get_data()
         mapdata.append(data.copy())
 
-        nb.Nifti1Image(2.0 * (data * mskdata), im.get_affine(),
-                       im.get_header()).to_filename(filename)
+        nb.Nifti1Image(2.0 * (data * mskdata), im.affine,
+                       im.header).to_filename(filename)
         in_files.append(filename)
 
     normalize_tpms(in_files, in_mask, out_files=out_files)
diff --git a/nipype/algorithms/tests/test_splitmerge.py b/nipype/algorithms/tests/test_splitmerge.py
index 0f874cbdce..89af22afe7 100644
--- a/nipype/algorithms/tests/test_splitmerge.py
+++ b/nipype/algorithms/tests/test_splitmerge.py
@@ -19,7 +19,7 @@ def test_split_and_merge():
     in_mask = example_data('tpms_msk.nii.gz')
     dwfile = op.join(tmpdir, 'dwi.nii.gz')
     mskdata = nb.load(in_mask).get_data()
-    aff = nb.load(in_mask).get_affine()
+    aff = nb.load(in_mask).affine
 
     dwshape = (mskdata.shape[0], mskdata.shape[1], mskdata.shape[2], 6)
     dwdata = np.random.normal(size=dwshape)
diff --git a/nipype/interfaces/cmtk/cmtk.py b/nipype/interfaces/cmtk/cmtk.py
index 3da9c3bf2f..f527cccc0a 100644
--- a/nipype/interfaces/cmtk/cmtk.py
+++ b/nipype/interfaces/cmtk/cmtk.py
@@ -187,7 +187,7 @@ def cmat(track_file, roi_file, resolution_network_file, matrix_name, matrix_mat_
 
     roi = nb.load(roi_file)
     roiData = roi.get_data()
-    roiVoxelSize = roi.get_header().get_zooms()
+    roiVoxelSize = roi.header.get_zooms()
     (endpoints, endpointsmm) = create_endpoints_array(fib, roiVoxelSize)
 
     # Output endpoint arrays
@@ -706,7 +706,8 @@ def _run_interface(self, runtime):
                 GMlabelDict['a'] = LUTlabelDict[label][4]
                 labelDict[label] = GMlabelDict
 
-        roi_image = nb.Nifti1Image(niiGM, niiAPARCimg.get_affine(), niiAPARCimg.get_header())
+        roi_image = nb.Nifti1Image(niiGM, niiAPARCimg.affine,
+                                   niiAPARCimg.header)
         iflogger.info('Saving ROI File to {path}'.format(path=roi_file))
         nb.save(roi_image, roi_file)
 
diff --git a/nipype/interfaces/cmtk/parcellation.py b/nipype/interfaces/cmtk/parcellation.py
index 2297177e01..80b0e72ab0 100644
--- a/nipype/interfaces/cmtk/parcellation.py
+++ b/nipype/interfaces/cmtk/parcellation.py
@@ -263,12 +263,12 @@ def create_roi(subject_id, subjects_dir, fs_dir, parcellation_name, dilation):
         out_roi = op.abspath('ROI_%s.nii.gz' % parcellation_name)
 
         # update the header
-        hdr = aseg.get_header()
+        hdr = aseg.header
         hdr2 = hdr.copy()
         hdr2.set_data_dtype(np.uint16)
 
         log.info("Save output image to %s" % out_roi)
-        img = nb.Nifti1Image(rois, aseg.get_affine(), hdr2)
+        img = nb.Nifti1Image(rois, aseg.affine, hdr2)
         nb.save(img, out_roi)
 
     iflogger.info("[ DONE ]")
@@ -294,7 +294,7 @@ def create_roi(subject_id, subjects_dir, fs_dir, parcellation_name, dilation):
         # store volume eg in ROIv_scale33.nii.gz
         out_roi = op.abspath('ROIv_%s.nii.gz' % parcellation_name)
         iflogger.info("Save output image to %s" % out_roi)
-        img = nb.Nifti1Image(rois, aseg.get_affine(), hdr2)
+        img = nb.Nifti1Image(rois, aseg.affine, hdr2)
         nb.save(img, out_roi)
 
         iflogger.info("[ DONE ]")
@@ -437,7 +437,7 @@ def create_wm_mask(subject_id, subjects_dir, fs_dir, parcellation_name):
 
     # output white matter mask. crop and move it afterwards
     wm_out = op.join(fs_dir, 'mri', 'fsmask_1mm.nii.gz')
-    img = nb.Nifti1Image(wmmask, fsmask.get_affine(), fsmask.get_header())
+    img = nb.Nifti1Image(wmmask, fsmask.affine, fsmask.header)
     iflogger.info("Save white matter mask: %s" % wm_out)
     nb.save(img, wm_out)
 
diff --git a/nipype/interfaces/dipy/preprocess.py b/nipype/interfaces/dipy/preprocess.py
index ef7c7451f4..885a97a93a 100644
--- a/nipype/interfaces/dipy/preprocess.py
+++ b/nipype/interfaces/dipy/preprocess.py
@@ -181,9 +181,9 @@ def resample_proxy(in_file, order=3, new_zooms=None, out_file=None):
         out_file = op.abspath('./%s_reslice%s' % (fname, fext))
 
     img = nb.load(in_file)
-    hdr = img.get_header().copy()
+    hdr = img.header.copy()
     data = img.get_data().astype(np.float32)
-    affine = img.get_affine()
+    affine = img.affine
     im_zooms = hdr.get_zooms()[:3]
 
     if new_zooms is None:
@@ -220,9 +220,9 @@ def nlmeans_proxy(in_file, settings,
         out_file = op.abspath('./%s_denoise%s' % (fname, fext))
 
     img = nb.load(in_file)
-    hdr = img.get_header()
+    hdr = img.header
     data = img.get_data()
-    aff = img.get_affine()
+    aff = img.affine
 
     nmask = data[..., 0] > 80
     if noise_mask is not None:
diff --git a/nipype/interfaces/dipy/simulate.py b/nipype/interfaces/dipy/simulate.py
index 569adb1a8c..939d7d15a4 100644
--- a/nipype/interfaces/dipy/simulate.py
+++ b/nipype/interfaces/dipy/simulate.py
@@ -116,9 +116,9 @@ def _run_interface(self, runtime):
 
         # Load the baseline b0 signal
         b0_im = nb.load(self.inputs.baseline)
-        hdr = b0_im.get_header()
-        shape = b0_im.get_shape()
-        aff = b0_im.get_affine()
+        hdr = b0_im.header
+        shape = b0_im.shape
+        aff = b0_im.affine
 
         # Check and load sticks and their volume fractions
         nsticks = len(self.inputs.in_dirs)
diff --git a/nipype/interfaces/dipy/tensors.py b/nipype/interfaces/dipy/tensors.py
index 067c300d62..edafea1306 100644
--- a/nipype/interfaces/dipy/tensors.py
+++ b/nipype/interfaces/dipy/tensors.py
@@ -49,7 +49,7 @@ def tensor_fitting(data, bvals, bvecs, mask_file=None):
     """
     img = nb.load(in_file)
     data = img.get_data()
-    affine = img.get_affine()
+    affine = img.affine
     if mask_file is not None:
         mask = nb.load(self.inputs.mask_file).get_data()
     else:
diff --git a/nipype/interfaces/dipy/tracks.py b/nipype/interfaces/dipy/tracks.py
index 6851da7de2..7daff72589 100644
--- a/nipype/interfaces/dipy/tracks.py
+++ b/nipype/interfaces/dipy/tracks.py
@@ -75,8 +75,8 @@ def _run_interface(self, runtime):
 
         if isdefined(self.inputs.reference):
             refnii = nb.load(self.inputs.reference)
-            affine = refnii.get_affine()
-            data_dims = refnii.get_shape()[:3]
+            affine = refnii.affine
+            data_dims = refnii.shape[:3]
             kwargs = dict(affine=affine)
         else:
             iflogger.warn(('voxel_dims and data_dims are deprecated'
@@ -103,10 +103,8 @@ def _run_interface(self, runtime):
 
         iflogger.info(
             ('Track density map saved as {i}, size={d}, '
-             'dimensions={v}').format(
-                i=out_file,
-                d=img.get_shape(),
-                v=img.get_header().get_zooms()))
+             'dimensions={v}').format(i=out_file, d=img.shape,
+                                      v=img.header.get_zooms()))
         return runtime
 
     def _list_outputs(self):
diff --git a/nipype/interfaces/elastix/utils.py b/nipype/interfaces/elastix/utils.py
index 541cfa1ec4..ab034dac07 100644
--- a/nipype/interfaces/elastix/utils.py
+++ b/nipype/interfaces/elastix/utils.py
@@ -91,20 +91,20 @@ def _run_interface(self, runtime):
         if isdefined(self.inputs.reference_image):
             im = nb.load(self.inputs.reference_image)
 
-            if len(im.get_header().get_zooms()) == 4:
+            if len(im.header.get_zooms()) == 4:
                 im = nb.func.four_to_three(im)[0]
 
-            size = ' '.join(["%01d" % s for s in im.get_shape()])
+            size = ' '.join(["%01d" % s for s in im.shape])
             p = re.compile((self._pattern % 'Size').decode('string-escape'))
             rep = '(\g<entry>%s\g<3>' % size
             contents = p.sub(rep, contents)
 
-            index = ' '.join(["0" for s in im.get_shape()])
+            index = ' '.join(["0" for s in im.shape])
             p = re.compile((self._pattern % 'Index').decode('string-escape'))
             rep = '(\g<entry>%s\g<3>' % index
             contents = p.sub(rep, contents)
 
-            spacing = ' '.join(["%0.4f" % f for f in im.get_header().get_zooms()])
+            spacing = ' '.join(["%0.4f" % f for f in im.header.get_zooms()])
             p = re.compile((self._pattern % 'Spacing').decode('string-escape'))
             rep = '(\g<entry>%s\g<3>' % spacing
             contents = p.sub(rep, contents)
@@ -113,7 +113,7 @@ def _run_interface(self, runtime):
             itkmat[0, 0] = -1
             itkmat[1, 1] = -1
 
-            affine = np.dot(itkmat, im.get_affine())
+            affine = np.dot(itkmat, im.affine)
             dirs = ' '.join(['%0.4f' % f for f in affine[0:3, 0:3].reshape(-1)])
             orig = ' '.join(['%0.4f' % f for f in affine[0:3, 3].reshape(-1)])
 
diff --git a/nipype/interfaces/freesurfer/preprocess.py b/nipype/interfaces/freesurfer/preprocess.py
index 619edde594..21dc798b5a 100644
--- a/nipype/interfaces/freesurfer/preprocess.py
+++ b/nipype/interfaces/freesurfer/preprocess.py
@@ -378,7 +378,7 @@ def _list_outputs(self):
         outputs = self.output_spec().get()
         outfile = self._get_outfilename()
         if isdefined(self.inputs.split) and self.inputs.split:
-            size = load(self.inputs.in_file).get_shape()
+            size = load(self.inputs.in_file).shape
             if len(size) == 3:
                 tp = 1
             else:
@@ -398,7 +398,7 @@ def _list_outputs(self):
         if isdefined(self.inputs.out_type):
             if self.inputs.out_type in ['spm', 'analyze']:
                 # generate all outputs
-                size = load(self.inputs.in_file).get_shape()
+                size = load(self.inputs.in_file).shape
                 if len(size) == 3:
                     tp = 1
                 else:
diff --git a/nipype/interfaces/fsl/epi.py b/nipype/interfaces/fsl/epi.py
index 2823cce3ff..1b119d3391 100644
--- a/nipype/interfaces/fsl/epi.py
+++ b/nipype/interfaces/fsl/epi.py
@@ -105,8 +105,8 @@ def _run_interface(self, runtime):
         if runtime.returncode == 0:
             out_file = self.inputs.out_fieldmap
             im = nib.load(out_file)
-            dumb_img = nib.Nifti1Image(np.zeros(im.get_shape()),
-                                       im.get_affine(), im.get_header())
+            dumb_img = nib.Nifti1Image(np.zeros(im.shape), im.affine,
+                                       im.header)
             out_nii = nib.funcs.concat_images((im, dumb_img))
             nib.save(out_nii, out_file)
 
diff --git a/nipype/interfaces/fsl/model.py b/nipype/interfaces/fsl/model.py
index 62e16e9319..96d0746d17 100644
--- a/nipype/interfaces/fsl/model.py
+++ b/nipype/interfaces/fsl/model.py
@@ -318,7 +318,7 @@ def _run_interface(self, runtime):
                                                       self.inputs.contrasts,
                                                       no_bases, do_tempfilter)
             nim = load(func_files[i])
-            (_, _, _, timepoints) = nim.get_shape()
+            (_, _, _, timepoints) = nim.shape
             fsf_txt = fsf_header.substitute(run_num=i,
                                             interscan_interval=self.inputs.interscan_interval,
                                             num_vols=timepoints,
diff --git a/nipype/interfaces/fsl/preprocess.py b/nipype/interfaces/fsl/preprocess.py
index 65540646e1..1f3137085e 100644
--- a/nipype/interfaces/fsl/preprocess.py
+++ b/nipype/interfaces/fsl/preprocess.py
@@ -696,7 +696,7 @@ def _list_outputs(self):
         if isdefined(self.inputs.save_mats) and self.inputs.save_mats:
             _, filename = os.path.split(outputs['out_file'])
             matpathname = os.path.join(cwd, filename + '.mat')
-            _, _, _, timepoints = load(self.inputs.in_file).get_shape()
+            _, _, _, timepoints = load(self.inputs.in_file).shape
             outputs['mat_file'] = []
             for t in range(timepoints):
                 outputs['mat_file'].append(os.path.join(matpathname,
diff --git a/nipype/interfaces/mrtrix/convert.py b/nipype/interfaces/mrtrix/convert.py
index 711ea2107b..89cf1c2299 100644
--- a/nipype/interfaces/mrtrix/convert.py
+++ b/nipype/interfaces/mrtrix/convert.py
@@ -184,7 +184,7 @@ def _run_interface(self, runtime):
         dx, dy, dz = get_data_dims(self.inputs.image_file)
         vx, vy, vz = get_vox_dims(self.inputs.image_file)
         image_file = nb.load(self.inputs.image_file)
-        affine = image_file.get_affine()
+        affine = image_file.affine
         out_filename = op.abspath(self.inputs.out_filename)
 
         # Reads MRTrix tracks
@@ -202,7 +202,7 @@ def _run_interface(self, runtime):
             xfm = np.genfromtxt(self.inputs.matrix_file)
             iflogger.info(xfm)
             registration_image_file = nb.load(self.inputs.registration_image_file)
-            reg_affine = registration_image_file.get_affine()
+            reg_affine = registration_image_file.affine
             r_dx, r_dy, r_dz = get_data_dims(self.inputs.registration_image_file)
             r_vx, r_vy, r_vz = get_vox_dims(self.inputs.registration_image_file)
             iflogger.info('Using affine from registration image file {r}'.format(r=self.inputs.registration_image_file))
diff --git a/nipype/interfaces/nipy/model.py b/nipype/interfaces/nipy/model.py
index 7fba0b26c7..f6ff113530 100644
--- a/nipype/interfaces/nipy/model.py
+++ b/nipype/interfaces/nipy/model.py
@@ -164,19 +164,19 @@ def _run_interface(self, runtime):
         self._beta_file = os.path.abspath("beta.nii")
         beta = np.zeros(mask.shape + (glm.beta.shape[0],))
         beta[mask, :] = glm.beta.T
-        nb.save(nb.Nifti1Image(beta, nii.get_affine()), self._beta_file)
+        nb.save(nb.Nifti1Image(beta, nii.affine), self._beta_file)
 
         self._s2_file = os.path.abspath("s2.nii")
         s2 = np.zeros(mask.shape)
         s2[mask] = glm.s2
-        nb.save(nb.Nifti1Image(s2, nii.get_affine()), self._s2_file)
+        nb.save(nb.Nifti1Image(s2, nii.affine), self._s2_file)
 
         if self.inputs.save_residuals:
             explained = np.dot(design_matrix, glm.beta)
             residuals = np.zeros(mask.shape + (nscans,))
             residuals[mask, :] = timeseries - explained.T
             self._residuals_file = os.path.abspath("residuals.nii")
-            nb.save(nb.Nifti1Image(residuals, nii.get_affine()), self._residuals_file)
+            nb.save(nb.Nifti1Image(residuals, nii.affine), self._residuals_file)
 
         self._nvbeta = glm.nvbeta
         self._dof = glm.dof
@@ -186,7 +186,7 @@ def _run_interface(self, runtime):
             self._a_file = os.path.abspath("a.nii")
             a = np.zeros(mask.shape)
             a[mask] = glm.a.squeeze()
-            nb.save(nb.Nifti1Image(a, nii.get_affine()), self._a_file)
+            nb.save(nb.Nifti1Image(a, nii.affine), self._a_file)
         self._model = glm.model
         self._method = glm.method
 
@@ -295,19 +295,19 @@ def _run_interface(self, runtime):
             stat_map = np.zeros(mask.shape)
             stat_map[mask] = est_contrast.stat().T
             stat_map_file = os.path.abspath(name + "_stat_map.nii")
-            nb.save(nb.Nifti1Image(stat_map, nii.get_affine()), stat_map_file)
+            nb.save(nb.Nifti1Image(stat_map, nii.affine), stat_map_file)
             self._stat_maps.append(stat_map_file)
 
             p_map = np.zeros(mask.shape)
             p_map[mask] = est_contrast.pvalue().T
             p_map_file = os.path.abspath(name + "_p_map.nii")
-            nb.save(nb.Nifti1Image(p_map, nii.get_affine()), p_map_file)
+            nb.save(nb.Nifti1Image(p_map, nii.affine), p_map_file)
             self._p_maps.append(p_map_file)
 
             z_map = np.zeros(mask.shape)
             z_map[mask] = est_contrast.zscore().T
             z_map_file = os.path.abspath(name + "_z_map.nii")
-            nb.save(nb.Nifti1Image(z_map, nii.get_affine()), z_map_file)
+            nb.save(nb.Nifti1Image(z_map, nii.affine), z_map_file)
             self._z_maps.append(z_map_file)
 
         return runtime
diff --git a/nipype/interfaces/nipy/preprocess.py b/nipype/interfaces/nipy/preprocess.py
index 6016181ee0..49a493f02c 100644
--- a/nipype/interfaces/nipy/preprocess.py
+++ b/nipype/interfaces/nipy/preprocess.py
@@ -65,8 +65,8 @@ def _run_interface(self, runtime):
         brain_mask = compute_mask(**args)
         _, name, ext = split_filename(self.inputs.mean_volume)
         self._brain_mask_path = os.path.abspath("%s_mask.%s" % (name, ext))
-        nb.save(nb.Nifti1Image(brain_mask.astype(np.uint8),
-                               nii.get_affine()), self._brain_mask_path)
+        nb.save(nb.Nifti1Image(brain_mask.astype(np.uint8), nii.affine),
+                self._brain_mask_path)
 
         return runtime
 
@@ -371,10 +371,7 @@ def _run_interface(self, runtime):
             s = slice(self.inputs.begin_index, nii.shape[3])
         else:
             s = slice(self.inputs.begin_index, self.inputs.end_index)
-        nii2 = nb.Nifti1Image(
-            nii.get_data()[..., s],
-            nii.get_affine(),
-            nii.get_header())
+        nii2 = nb.Nifti1Image(nii.get_data()[..., s], nii.affine, nii.header)
         nb.save(nii2, out_file)
         return runtime
 
diff --git a/nipype/interfaces/spm/base.py b/nipype/interfaces/spm/base.py
index 44fc7ca7ac..0ca470d0ed 100644
--- a/nipype/interfaces/spm/base.py
+++ b/nipype/interfaces/spm/base.py
@@ -46,7 +46,7 @@ def func_is_3d(in_file):
         return func_is_3d(in_file[0])
     else:
         img = load(in_file)
-        shape = img.get_shape()
+        shape = img.shape
         if len(shape) == 3 or (len(shape) == 4 and shape[3] == 1):
             return True
         else:
@@ -74,10 +74,10 @@ def scans_for_fname(fname):
             scans[sno] = '%s,1' % f
         return scans
     img = load(fname)
-    if len(img.get_shape()) == 3:
+    if len(img.shape) == 3:
         return np.array(('%s,1' % fname,), dtype=object)
     else:
-        n_scans = img.get_shape()[3]
+        n_scans = img.shape[3]
         scans = np.zeros((n_scans,), dtype=object)
         for sno in range(n_scans):
             scans[sno] = '%s,%d' % (fname, sno + 1)
diff --git a/nipype/workflows/dmri/dipy/denoise.py b/nipype/workflows/dmri/dipy/denoise.py
index 7b7afc47ee..68c27d0d89 100644
--- a/nipype/workflows/dmri/dipy/denoise.py
+++ b/nipype/workflows/dmri/dipy/denoise.py
@@ -64,7 +64,7 @@ def csf_mask(in_file, in_mask, out_file=None):
         out_file = op.abspath("%s_csfmask%s" % (fname, ext))
 
     im = nb.load(in_file)
-    hdr = im.get_header().copy()
+    hdr = im.header.copy()
     hdr.set_data_dtype(np.uint8)
     hdr.set_xyzt_units('mm')
     imdata = im.get_data()
@@ -84,8 +84,8 @@ def csf_mask(in_file, in_mask, out_file=None):
     remove_pixel = mask_size[label_im]
     label_im[remove_pixel] = 0
     label_im[label_im > 0] = 1
-    nb.Nifti1Image(label_im.astype(np.uint8),
-                   im.get_affine(), hdr).to_filename(out_file)
+    nb.Nifti1Image(label_im.astype(np.uint8), im.affine,
+                   hdr).to_filename(out_file)
     return out_file
 
 
@@ -107,13 +107,11 @@ def bg_mask(in_file, in_mask, out_file=None):
         out_file = op.abspath("%s_bgmask%s" % (fname, ext))
 
     im = nb.load(in_file)
-    hdr = im.get_header().copy()
+    hdr = im.header.copy()
     hdr.set_data_dtype(np.uint8)
     hdr.set_xyzt_units('mm')
     imdata = im.get_data()
     msk = nb.load(in_mask).get_data()
-    msk = 1 - binary_dilation(msk,
-                              structure=np.ones((20, 20, 20)))
-    nb.Nifti1Image(msk.astype(np.uint8),
-                   im.get_affine(), hdr).to_filename(out_file)
+    msk = 1 - binary_dilation(msk, structure=np.ones((20, 20, 20)))
+    nb.Nifti1Image(msk.astype(np.uint8), im.affine, hdr).to_filename(out_file)
     return out_file
diff --git a/nipype/workflows/dmri/fsl/artifacts.py b/nipype/workflows/dmri/fsl/artifacts.py
index dc7387f0c0..03a1b0c31c 100644
--- a/nipype/workflows/dmri/fsl/artifacts.py
+++ b/nipype/workflows/dmri/fsl/artifacts.py
@@ -899,7 +899,7 @@ def _xfm_jacobian(in_xfm):
 def _get_zoom(in_file, enc_dir):
     import nibabel as nb
 
-    zooms = nb.load(in_file).get_header().get_zooms()
+    zooms = nb.load(in_file).header.get_zooms()
 
     if 'y' in enc_dir:
         return zooms[1]
diff --git a/nipype/workflows/dmri/fsl/epi.py b/nipype/workflows/dmri/fsl/epi.py
index bfeb2afeb9..f62fabb792 100644
--- a/nipype/workflows/dmri/fsl/epi.py
+++ b/nipype/workflows/dmri/fsl/epi.py
@@ -731,8 +731,7 @@ def _prepare_phasediff(in_file):
     if fext == '.gz':
         name, _ = os.path.splitext(name)
     out_file = os.path.abspath('./%s_2pi.nii.gz' % name)
-    nib.save(nib.Nifti1Image(
-        diff_norm, img.get_affine(), img.get_header()), out_file)
+    nib.save(nib.Nifti1Image(diff_norm, img.affine, img.header), out_file)
     return out_file
 
 
@@ -756,8 +755,7 @@ def _fill_phase(in_file):
     import os
     import numpy as np
     img = nib.load(in_file)
-    dumb_img = nib.Nifti1Image(np.zeros(
-        img.get_shape()), img.get_affine(), img.get_header())
+    dumb_img = nib.Nifti1Image(np.zeros(img.shape), img.affine, img.header)
     out_nii = nib.funcs.concat_images((img, dumb_img))
     name, fext = os.path.splitext(os.path.basename(in_file))
     if fext == '.gz':
@@ -778,7 +776,7 @@ def _vsm_remove_mean(in_file, mask_file, in_unwarped):
     img_data[msk == 0] = 0
     vsmmag_masked = ma.masked_values(img_data.reshape(-1), 0.0)
     vsmmag_masked = vsmmag_masked - vsmmag_masked.mean()
-    img._data = vsmmag_masked.reshape(img.get_shape())
+    img._data = vsmmag_masked.reshape(img.shape)
     name, fext = os.path.splitext(os.path.basename(in_file))
     if fext == '.gz':
         name, _ = os.path.splitext(name)
diff --git a/nipype/workflows/dmri/fsl/tbss.py b/nipype/workflows/dmri/fsl/tbss.py
index 504334c2d3..c0e2faa096 100644
--- a/nipype/workflows/dmri/fsl/tbss.py
+++ b/nipype/workflows/dmri/fsl/tbss.py
@@ -14,7 +14,7 @@ def tbss1_op_string(in_files):
     op_strings = []
     for infile in in_files:
         img = nib.load(infile)
-        dimtup = tuple([d - 2 for d in img.get_shape()])
+        dimtup = tuple(d - 2 for d in img.shape)
         dimtup = dimtup[0:3]
         op_str = '-min 1 -ero -roi 1 %d 1 %d 1 %d 0 1' % dimtup
         op_strings.append(op_str)
diff --git a/nipype/workflows/dmri/fsl/utils.py b/nipype/workflows/dmri/fsl/utils.py
index c7cff21521..72c92b565a 100644
--- a/nipype/workflows/dmri/fsl/utils.py
+++ b/nipype/workflows/dmri/fsl/utils.py
@@ -228,10 +228,9 @@ def extract_bval(in_dwi, in_bval, b=0, out_file=None):
         selection = np.where(bvals == b)
 
     extdata = np.squeeze(dwidata.take(selection, axis=3))
-    hdr = im.get_header().copy()
+    hdr = im.header.copy()
     hdr.set_data_shape(extdata.shape)
-    nb.Nifti1Image(extdata, im.get_affine(),
-                   hdr).to_filename(out_file)
+    nb.Nifti1Image(extdata, im.affine, hdr).to_filename(out_file)
     return out_file
 
 
@@ -247,7 +246,7 @@ def hmc_split(in_file, in_bval, ref_num=0, lowbval=5.0):
 
     im = nb.load(in_file)
     data = im.get_data()
-    hdr = im.get_header().copy()
+    hdr = im.header.copy()
     bval = np.loadtxt(in_bval)
 
     lowbs = np.where(bval <= lowbval)[0]
@@ -273,10 +272,10 @@ def hmc_split(in_file, in_bval, ref_num=0, lowbval=5.0):
 
     refdata = data[..., volid]
     hdr.set_data_shape(refdata.shape)
-    nb.Nifti1Image(refdata, im.get_affine(), hdr).to_filename(out_ref)
+    nb.Nifti1Image(refdata, im.affine, hdr).to_filename(out_ref)
 
     hdr.set_data_shape(data.shape)
-    nb.Nifti1Image(data, im.get_affine(), hdr).to_filename(out_mov)
+    nb.Nifti1Image(data, im.affine, hdr).to_filename(out_mov)
     np.savetxt(out_bval, bval)
     return [out_ref, out_mov, out_bval, volid]
 
@@ -298,7 +297,7 @@ def remove_comp(in_file, in_bval, volid=0, out_file=None):
 
     im = nb.load(in_file)
     data = im.get_data()
-    hdr = im.get_header().copy()
+    hdr = im.header.copy()
     bval = np.loadtxt(in_bval)
 
     if volid == 0:
@@ -312,7 +311,7 @@ def remove_comp(in_file, in_bval, volid=0, out_file=None):
                               axis=3)
         bval = np.hstack((bval[:volid], bval[(volid + 1):]))
     hdr.set_data_shape(data.shape)
-    nb.Nifti1Image(data, im.get_affine(), hdr).to_filename(out_file)
+    nb.Nifti1Image(data, im.affine, hdr).to_filename(out_file)
 
     out_bval = op.abspath('bval_extract.txt')
     np.savetxt(out_bval, bval)
@@ -357,8 +356,7 @@ def recompose_dwi(in_dwi, in_bval, in_corrected, out_file=None):
     for bindex, dwi in zip(dwis, in_corrected):
         dwidata[..., bindex] = nb.load(dwi).get_data()
 
-    nb.Nifti1Image(dwidata, im.get_affine(),
-                   im.get_header()).to_filename(out_file)
+    nb.Nifti1Image(dwidata, im.affine, im.header).to_filename(out_file)
     return out_file
 
 
@@ -415,11 +413,11 @@ def time_avg(in_file, index=[0], out_file=None):
         data = np.average(np.array([im.get_data().astype(np.float32)
                                     for im in imgs]), axis=0)
 
-    hdr = imgs[0].get_header().copy()
+    hdr = imgs[0].header.copy()
     hdr.set_data_shape(data.shape)
     hdr.set_xyzt_units('mm')
     hdr.set_data_dtype(np.float32)
-    nb.Nifti1Image(data, imgs[0].get_affine(), hdr).to_filename(out_file)
+    nb.Nifti1Image(data, imgs[0].affine, hdr).to_filename(out_file)
     return out_file
 
 
@@ -461,11 +459,11 @@ def b0_average(in_dwi, in_bval, max_b=10.0, out_file=None):
            for im in imgs[index]]
     b0 = np.average(np.array(b0s), axis=0)
 
-    hdr = imgs[0].get_header().copy()
+    hdr = imgs[0].header.copy()
     hdr.set_data_shape(b0.shape)
     hdr.set_xyzt_units('mm')
     hdr.set_data_dtype(np.float32)
-    nb.Nifti1Image(b0, imgs[0].get_affine(), hdr).to_filename(out_file)
+    nb.Nifti1Image(b0, imgs[0].affine, hdr).to_filename(out_file)
     return out_file
 
 
@@ -598,7 +596,7 @@ def siemens2rads(in_file, out_file=None):
     in_file = np.atleast_1d(in_file).tolist()
     im = nb.load(in_file[0])
     data = im.get_data().astype(np.float32)
-    hdr = im.get_header().copy()
+    hdr = im.header.copy()
 
     if len(in_file) == 2:
         data = nb.load(in_file[1]).get_data().astype(np.float32) - data
@@ -612,7 +610,7 @@ def siemens2rads(in_file, out_file=None):
     hdr.set_data_dtype(np.float32)
     hdr.set_xyzt_units('mm')
     hdr['datatype'] = 16
-    nb.Nifti1Image(data, im.get_affine(), hdr).to_filename(out_file)
+    nb.Nifti1Image(data, im.affine, hdr).to_filename(out_file)
     return out_file
 
 
@@ -633,8 +631,7 @@ def rads2radsec(in_file, delta_te, out_file=None):
 
     im = nb.load(in_file)
     data = im.get_data().astype(np.float32) * (1.0 / delta_te)
-    nb.Nifti1Image(data, im.get_affine(),
-                   im.get_header()).to_filename(out_file)
+    nb.Nifti1Image(data, im.affine, im.header).to_filename(out_file)
     return out_file
 
 
@@ -664,8 +661,7 @@ def demean_image(in_file, in_mask=None, out_file=None):
 
     mean = np.median(data[msk == 1].reshape(-1))
     data[msk == 1] = data[msk == 1] - mean
-    nb.Nifti1Image(data, im.get_affine(),
-                   im.get_header()).to_filename(out_file)
+    nb.Nifti1Image(data, im.affine, im.header).to_filename(out_file)
     return out_file
 
 
@@ -685,8 +681,8 @@ def add_empty_vol(in_file, out_file=None):
         out_file = op.abspath('./%s_4D.nii.gz' % fname)
 
     im = nb.load(in_file)
-    zim = nb.Nifti1Image(np.zeros_like(im.get_data()), im.get_affine(),
-                         im.get_header())
+    zim = nb.Nifti1Image(np.zeros_like(im.get_data()), im.affine,
+                         im.header)
     nb.funcs.concat_images([im, zim]).to_filename(out_file)
     return out_file
 
@@ -707,8 +703,8 @@ def reorient_bvecs(in_dwi, old_dwi, in_bvec):
     bvecs = np.loadtxt(in_bvec).T
     new_bvecs = []
 
-    N = nb.load(in_dwi).get_affine()
-    O = nb.load(old_dwi).get_affine()
+    N = nb.load(in_dwi).affine
+    O = nb.load(old_dwi).affine
     RS = N.dot(np.linalg.inv(O))[:3, :3]
     sc_idx = np.where((np.abs(RS) != 1) & (RS != 0))
     S = np.ones_like(RS)
@@ -732,12 +728,12 @@ def copy_hdr(in_file, in_file_hdr, out_file=None):
         out_file = op.abspath('./%s_fixhdr.nii.gz' % fname)
 
     imref = nb.load(in_file_hdr)
-    hdr = imref.get_header().copy()
+    hdr = imref.header.copy()
     hdr.set_data_dtype(np.float32)
     vsm = nb.load(in_file).get_data().astype(np.float32)
     hdr.set_data_shape(vsm.shape)
     hdr.set_xyzt_units('mm')
-    nii = nb.Nifti1Image(vsm, imref.get_affine(), hdr)
+    nii = nb.Nifti1Image(vsm, imref.affine, hdr)
     nii.to_filename(out_file)
     return out_file
 
@@ -756,7 +752,7 @@ def enhance(in_file, clip_limit=0.010, in_mask=None, out_file=None):
 
     im = nb.load(in_file)
     imdata = im.get_data()
-    imshape = im.get_shape()
+    imshape = im.shape
 
     if in_mask is not None:
         msk = nb.load(in_mask).get_data()
@@ -770,8 +766,8 @@ def enhance(in_file, clip_limit=0.010, in_mask=None, out_file=None):
     adapted = exposure.equalize_adapthist(imdata.reshape(imshape[0], -1),
                                           clip_limit=clip_limit)
 
-    nb.Nifti1Image(adapted.reshape(imshape), im.get_affine(),
-                   im.get_header()).to_filename(out_file)
+    nb.Nifti1Image(adapted.reshape(imshape), im.affine,
+                   im.header).to_filename(out_file)
 
     return out_file
 
diff --git a/nipype/workflows/fmri/fsl/estimate.py b/nipype/workflows/fmri/fsl/estimate.py
index ef2a3c44d0..a600f63350 100644
--- a/nipype/workflows/fmri/fsl/estimate.py
+++ b/nipype/workflows/fmri/fsl/estimate.py
@@ -251,15 +251,15 @@ def get_dofvolumes(dof_files, cope_files):
         import nibabel as nb
         import numpy as np
         img = nb.load(cope_files[0])
-        if len(img.get_shape()) > 3:
-            out_data = np.zeros(img.get_shape())
+        if len(img.shape) > 3:
+            out_data = np.zeros(img.shape)
         else:
-            out_data = np.zeros(list(img.get_shape()) + [1])
+            out_data = np.zeros(list(img.shape) + [1])
         for i in range(out_data.shape[-1]):
             dof = np.loadtxt(dof_files[i])
             out_data[:, :, :, i] = dof
         filename = os.path.join(os.getcwd(), 'dof_file.nii.gz')
-        newimg = nb.Nifti1Image(out_data, None, img.get_header())
+        newimg = nb.Nifti1Image(out_data, None, img.header)
         newimg.to_filename(filename)
         return filename
 
diff --git a/nipype/workflows/fmri/fsl/preprocess.py b/nipype/workflows/fmri/fsl/preprocess.py
index 6ac1d7b86d..4915d93444 100644
--- a/nipype/workflows/fmri/fsl/preprocess.py
+++ b/nipype/workflows/fmri/fsl/preprocess.py
@@ -29,7 +29,7 @@ def pickmiddle(files):
     import numpy as np
     middlevol = []
     for f in files:
-        middlevol.append(int(np.ceil(load(f).get_shape()[3] / 2)))
+        middlevol.append(int(np.ceil(load(f).shape[3] / 2)))
     return middlevol
 
 
@@ -39,9 +39,9 @@ def pickvol(filenames, fileidx, which):
     if which.lower() == 'first':
         idx = 0
     elif which.lower() == 'middle':
-        idx = int(np.ceil(load(filenames[fileidx]).get_shape()[3] / 2))
+        idx = int(np.ceil(load(filenames[fileidx]).shape[3] / 2))
     elif which.lower() == 'last':
-        idx = load(filenames[fileidx]).get_shape()[3] - 1
+        idx = load(filenames[fileidx]).shape[3] - 1
     else:
         raise Exception('unknown value for volume selection : %s' % which)
     return idx
diff --git a/nipype/workflows/fmri/spm/preprocess.py b/nipype/workflows/fmri/spm/preprocess.py
index 34060fc6d3..c1f533323d 100644
--- a/nipype/workflows/fmri/spm/preprocess.py
+++ b/nipype/workflows/fmri/spm/preprocess.py
@@ -191,7 +191,7 @@ def compute_icv(class_images):
         from numpy import prod
         icv = []
         for session in class_images:
-            voxel_volume = prod(load(session[0][0]).get_header().get_zooms())
+            voxel_volume = prod(load(session[0][0]).header.get_zooms())
             img = load(session[0][0]).get_data() + \
                 load(session[1][0]).get_data() + \
                 load(session[2][0]).get_data()
diff --git a/nipype/workflows/misc/utils.py b/nipype/workflows/misc/utils.py
index cc3e196f15..640e6b0221 100644
--- a/nipype/workflows/misc/utils.py
+++ b/nipype/workflows/misc/utils.py
@@ -10,7 +10,7 @@ def get_vox_dims(volume):
     if isinstance(volume, list):
         volume = volume[0]
     nii = nb.load(volume)
-    hdr = nii.get_header()
+    hdr = nii.header
     voxdims = hdr.get_zooms()
     return [float(voxdims[0]), float(voxdims[1]), float(voxdims[2])]
 
@@ -20,7 +20,7 @@ def get_data_dims(volume):
     if isinstance(volume, list):
         volume = volume[0]
     nii = nb.load(volume)
-    hdr = nii.get_header()
+    hdr = nii.header
     datadims = hdr.get_data_shape()
     return [int(datadims[0]), int(datadims[1]), int(datadims[2])]
 
@@ -28,7 +28,7 @@ def get_data_dims(volume):
 def get_affine(volume):
     import nibabel as nb
     nii = nb.load(volume)
-    return nii.get_affine()
+    return nii.affine
 
 
 def select_aparc(list_of_files):
diff --git a/nipype/workflows/rsfmri/fsl/resting.py b/nipype/workflows/rsfmri/fsl/resting.py
index 8826a7ed9d..2bf8f28bd8 100644
--- a/nipype/workflows/rsfmri/fsl/resting.py
+++ b/nipype/workflows/rsfmri/fsl/resting.py
@@ -46,7 +46,7 @@ def select_volume(filename, which):
     if which.lower() == 'first':
         idx = 0
     elif which.lower() == 'middle':
-        idx = int(np.ceil(load(filename).get_shape()[3] / 2))
+        idx = int(np.ceil(load(filename).shape[3] / 2))
     else:
         raise Exception('unknown value for volume selection : %s' % which)
     return idx