def load_trainingdata_fromOneImage_withDownsampling_noInterpl(
srcFile,
B0File,
maskFile,
degreeSet,
refFile,
_params,
sDim,
tDim,
srcNumSlice,
offset=[],
scan_dir='axial',
triplanar=False,
img_aug=False,
skipZero=False,
gaussiansmooth=False,
dtype=np.uint16):
# print ("Extract samples: Start ---")
srcImageFile = str(srcFile)
srcImg = sitk.ReadImage(str(srcFile))
B0ImageFile = str(B0File)
B0Img = sitk.ReadImage(str(B0ImageFile))
maskImageFile = str(maskFile)
maskImg = sitk.ReadImage(str(maskImageFile))
center = FuncImage.GetCenter(str(refFile))
srcImg_Ori = srcImg
allSrcPatchSet = np.zeros([
_params["training_parameters"]["MaximumNumPatches"]["value"],
_params["training_parameters"]["input_width"]["value"],
_params["training_parameters"]["input_height"]["value"],
_params["training_parameters"]["input_channels"]["value"]
],
dtype=dtype)
allB0PatchSet = np.zeros([
_params["training_parameters"]["MaximumNumPatches"]["value"],
_params["training_parameters"]["input_width"]["value"],
_params["training_parameters"]["input_height"]["value"],
_params["training_parameters"]["input_channels"]["value"]
],
dtype=dtype)
allMaskPatchSet = np.zeros([
_params["training_parameters"]["MaximumNumPatches"]["value"],
_params["training_parameters"]["input_width"]["value"],
_params["training_parameters"]["input_height"]["value"],
_params["training_parameters"]["input_channels"]["value"]
],
dtype=dtype)
if len(offset) == 0:
offset = [
int(_params["training_parameters"]["input_width"]["value"] / 2),
int(_params["training_parameters"]["input_height"]["value"] / 2),
int(_params["training_parameters"]["input_channels"]["value"] / 2)
]
stdIdx = 0
for d in range(len(degreeSet)):
# rotate Image
# srcImg = FuncImage.RotateItkImg(srcImg_Ori, degreeSet[d], center, inverse=True)
if (img_aug == True):
# intensity augmentation by Histogram equalization
srcImgList = FuncImage.augment_images_intensity(srcImg_Ori)
for l in range(len(srcImgList)):
srcImg = srcImgList[l]
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
# Extract Patches
srcPatchSet = cropOneSlice_Patch(_params,
srcArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
stdIdx = endIdx
del srcPatchSet
del srcArray
del srcImg
else:
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
if (gaussiansmooth == True):
srcArray = gaussian_filter(srcArray, sigma=1)
B0Array = sitk.GetArrayFromImage(B0Img)
B0Array = B0Array.transpose((2, 1, 0))
maskArray = sitk.GetArrayFromImage(maskImg)
maskArray = maskArray.transpose((2, 1, 0))
print('srcArray mean: ' + ` np.mean(srcArray) `)
# Extract Patches
srcPatchSet, B0PatchSet, maskPatchSet = cropOneSlice_Patch_withDownsampling(
_params,
srcArray,
B0Array,
maskArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
print('srcPatchSet mean: ' + ` np.mean(srcPatchSet) `)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
allB0PatchSet[stdIdx:endIdx, :, :, :] = B0PatchSet
allMaskPatchSet[stdIdx:endIdx, :, :, :] = maskPatchSet
stdIdx = endIdx
del srcPatchSet
del B0PatchSet
del maskPatchSet
del srcArray
del B0Array
del maskArray
del srcImg
del B0Img
del maskImg
allSrcPatchSet = allSrcPatchSet[0:stdIdx, :, :, :]
allB0PatchSet = allB0PatchSet[0:stdIdx, :, :, :]
allMaskPatchSet = allMaskPatchSet[0:stdIdx, :, :, :]
del srcImg_Ori
# print ("Extract samples: Done ---")
return allSrcPatchSet, allB0PatchSet, allMaskPatchSet
def load_trainingdata_fromOneImage_withRotation(srcFile,
degreeSet,
refFile,
_params,
sDim,
tDim,
srcNumSlice,
offset=[],
img_aug=False,
skipZero=False,
SRCNN=False,
dtype=np.uint16):
# print ("Extract samples: Start ---")
srcImageFile = str(srcFile)
srcImg = sitk.ReadImage(str(srcFile))
center = FuncImage.GetCenter(str(refFile))
srcImg_Ori = srcImg
if SRCNN == True:
allSrcPatchSet = np.zeros([
_params["training_parameters"]["MaximumNumPatches"]["value"],
_params["training_parameters"]["input_width"]["value"],
_params["training_parameters"]["input_height"]["value"],
_params["training_parameters"]["input_channels"]["value"]
],
dtype=dtype)
else:
allSrcPatchSet = np.zeros([
_params["training_parameters"]["MaximumNumPatches"]["value"],
_params["training_parameters"]["output_width"]["value"],
_params["training_parameters"]["output_height"]["value"],
_params["training_parameters"]["output_channels"]["value"]
],
dtype=dtype)
if len(offset) == 0:
offset = [
int(_params["training_parameters"]["output_width"]["value"] / 2),
int(_params["training_parameters"]["output_height"]["value"] / 2),
int(_params["training_parameters"]["output_channels"]["value"] / 2)
]
stdIdx = 0
for d in range(len(degreeSet)):
# rotate Image
# srcImg = FuncImage.RotateItkImg(srcImg_Ori, degreeSet[d], center, inverse=True)
if (img_aug == True):
# intensity augmentation by Histogram equalization
srcImgList = FuncImage.augment_images_intensity(srcImg_Ori)
for l in range(len(srcImgList)):
srcImg = srcImgList[l]
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
# Extract Patches
srcPatchSet, srcPatchMod = cropOneSlice_Patch(
_params,
srcArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
stdIdx = endIdx
del srcPatchSet
del srcArray
del srcImg
else:
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
# Extract Patches
srcPatchSet = cropOneSlice_Patch(_params,
srcArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
stdIdx = endIdx
del srcPatchSet
del srcArray
del srcImg
allSrcPatchSet = allSrcPatchSet[0:stdIdx, :, :, :]
del srcImg_Ori
# print ("Extract samples: Done ---")
return allSrcPatchSet
def load_trainingdata_fromOneImage_withDownsampling_Interpl(
srcFile,
B0File,
maskFile,
degreeSet,
refFile,
_params,
sDim,
tDim,
srcNumSlice,
offset=[],
scan_dir='axial',
triplanar=False,
img_aug=False,
skipZero=False,
gaussiansmooth=False,
dtype=np.uint16):
# print ("Extract samples: Start ---")
srcImageFile = str(srcFile)
srcImg = sitk.ReadImage(str(srcFile))
B0ImageFile = str(B0File)
B0Img = sitk.ReadImage(str(B0ImageFile))
maskImageFile = str(maskFile)
maskImg = sitk.ReadImage(str(maskImageFile))
center = FuncImage.GetCenter(str(refFile))
srcImg_Ori = srcImg
allSrcPatchSet = np.zeros([
_params["training_parameters"]["MaximumNumPatches"]["value"],
_params["training_parameters"]["input_width"]["value"],
_params["training_parameters"]["input_height"]["value"],
_params["training_parameters"]["input_channels"]["value"]
],
dtype=dtype)
allB0PatchSet = np.zeros([
_params["training_parameters"]["MaximumNumPatches"]["value"],
_params["training_parameters"]["input_width"]["value"],
_params["training_parameters"]["input_height"]["value"],
_params["training_parameters"]["input_channels"]["value"]
],
dtype=dtype)
allMaskPatchSet = np.zeros([
_params["training_parameters"]["MaximumNumPatches"]["value"],
_params["training_parameters"]["input_width"]["value"],
_params["training_parameters"]["input_height"]["value"],
_params["training_parameters"]["input_channels"]["value"]
],
dtype=dtype)
if len(offset) == 0:
offset = [
int(_params["training_parameters"]["input_width"]["value"] / 2),
int(_params["training_parameters"]["input_height"]["value"] / 2),
int(_params["training_parameters"]["input_channels"]["value"] / 2)
]
stdIdx = 0
for d in range(len(degreeSet)):
# rotate Image
# srcImg = FuncImage.RotateItkImg(srcImg_Ori, degreeSet[d], center, inverse=True)
if (img_aug == True):
# intensity augmentation by Histogram equalization
srcImgList = FuncImage.augment_images_intensity(srcImg_Ori)
for l in range(len(srcImgList)):
srcImg = srcImgList[l]
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
# Extract Patches
srcPatchSet = cropOneSlice_Patch(_params,
srcArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
stdIdx = endIdx
del srcPatchSet
del srcArray
del srcImg
else:
if (triplanar):
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
# axial
orgArray = srcArray
# Downsampling in slices
# zero-padding first
if (srcArray.shape[2] % ds_factor != 0):
addslices = ds_factor - (srcArray.shape[2] % ds_factor)
zeroArray = np.zeros(
[srcArray.shape[0], srcArray.shape[1], addslices],
dtype=dtype)
srcArray = np.concatenate([srcArray, zeroArray], axis=2)
#print srcArray.shape
# srcArray_down = srcArray[:,:,offset_slice::ds_factor]
# print srcArray_down.shape
# Interpolation in slices
#srcArray_up = resample_poly(srcArray_down, ds_factor, 1, axis = 2)
# bi-linear interpolation
noStep = int(srcArray.shape[2] / ds_factor) - 1
srcArray_up = srcArray
for k in range(0, noStep):
for z in range(1, ds_factor):
ind1 = k * ds_factor + offset_slice
ind2 = (k + 1) * ds_factor + offset_slice
srcArray_up[:, :, ind1 + z] = (srcArray[:, :, ind1] *
(ds_factor - z) +
srcArray[:, :, ind2] *
(z)) / ds_factor
#if (srcArray.shape[2] % ds_factor != 0):
srcArray_axial = srcArray_up[:, :, 0:orgArray.shape[2]]
# sagittal
srcArray = sitk.GetArrayFromImage(srcImg) # z, y, x
orgArray = srcArray
# Downsampling in slices
# zero-padding first
if (srcArray.shape[2] % ds_factor != 0):
addslices = ds_factor - (srcArray.shape[2] % ds_factor)
zeroArray = np.zeros(
[srcArray.shape[0], srcArray.shape[1], addslices],
dtype=dtype)
srcArray = np.concatenate([srcArray, zeroArray], axis=2)
#print srcArray.shape
# srcArray_down = srcArray[:,:,offset_slice::ds_factor]
# print srcArray_down.shape
# Interpolation in slices
#srcArray_up = resample_poly(srcArray_down, ds_factor, 1, axis = 2)
# bi-linear interpolation
noStep = int(srcArray.shape[2] / ds_factor) - 1
srcArray_up = srcArray
for k in range(0, noStep):
for z in range(1, ds_factor):
ind1 = k * ds_factor + offset_slice
ind2 = (k + 1) * ds_factor + offset_slice
srcArray_up[:, :, ind1 + z] = (srcArray[:, :, ind1] *
(ds_factor - z) +
srcArray[:, :, ind2] *
(z)) / ds_factor
#if (srcArray.shape[2] % ds_factor != 0):
srcArray_sag = srcArray_up[:, :, 0:orgArray.shape[2]]
srcArray_sag = srcArray_sag.transpose((2, 1, 0))
# coronal
srcArray = sitk.GetArrayFromImage(srcImg) # z, y, x
srcArray = srcArray.transpose((2, 0, 1)) # x, z, y
orgArray = srcArray
# Downsampling in slices
# zero-padding first
if (srcArray.shape[2] % ds_factor != 0):
addslices = ds_factor - (srcArray.shape[2] % ds_factor)
zeroArray = np.zeros(
[srcArray.shape[0], srcArray.shape[1], addslices],
dtype=dtype)
srcArray = np.concatenate([srcArray, zeroArray], axis=2)
#print srcArray.shape
# srcArray_down = srcArray[:,:,offset_slice::ds_factor]
# print srcArray_down.shape
# Interpolation in slices
#srcArray_up = resample_poly(srcArray_down, ds_factor, 1, axis = 2)
# bi-linear interpolation
noStep = int(srcArray.shape[2] / ds_factor) - 1
srcArray_up = srcArray
for k in range(0, noStep):
for z in range(1, ds_factor):
ind1 = k * ds_factor + offset_slice
ind2 = (k + 1) * ds_factor + offset_slice
srcArray_up[:, :, ind1 + z] = (srcArray[:, :, ind1] *
(ds_factor - z) +
srcArray[:, :, ind2] *
(z)) / ds_factor
#if (srcArray.shape[2] % ds_factor != 0):
srcArray_cor = srcArray_up[:, :, 0:orgArray.shape[2]]
srcArray_cor = srcArray_cor.transpose((0, 2, 1))
srcArray = np.mean(srcArray_axial, srcArray_sag, srcArray_cor)
del srcArray_axial
del srcArray_sag
del srcArray_cor
# Extract Patches
srcPatchSet = cropOneSlice_Patch(_params,
srcArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
stdIdx = endIdx
del srcPatchSet
del srcArray
del srcImg
del orgArray
#del srcArray_down
del srcArray_up
else:
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
orgArray = srcArray
# find nonzero slices
idx_scan = []
ds_factor = _params["training_parameters"]["ds_factor"][
"value"]
for slc in range(orgArray.shape[2]):
if np.count_nonzero(orgArray[:, :, slc]) > 0:
idx_scan.append(slc)
retArray_down = orgArray[:, :, idx_scan]
## using ndimage.zoom
retArray_up = zoom(retArray_down, (1, 1, ds_factor), order=1)
retArray = retArray_up
retArray[:, :, idx_scan] = orgArray[:, :, idx_scan]
B0Array = sitk.GetArrayFromImage(B0Img)
B0Array = B0Array.transpose((2, 1, 0))
maskArray = sitk.GetArrayFromImage(maskImg)
maskArray = maskArray.transpose((2, 1, 0))
print('srcArray mean: ' + ` np.mean(retArray) `)
# # # Downsampling in slices
# # # zero-padding first
# # if (srcArray.shape[2] % ds_factor != 0):
# # addslices = ds_factor - (srcArray.shape[2] % ds_factor)
# # zeroArray = np.zeros([srcArray.shape[0], srcArray.shape[1], addslices], dtype=dtype)
# # srcArray = np.concatenate([srcArray, zeroArray], axis = 2)
# # #print srcArray.shape
# # # bi-linear interpolation
# noStep = int(srcArray.shape[2]/ds_factor) - 1
# srcArray_up = srcArray
# for k in range(0, noStep):
# for z in range(1, ds_factor):
# ind1 = k*ds_factor + offset_slice
# ind2 = (k+1)*ds_factor + offset_slice
# srcArray_up[:,:,ind1 + z] = (srcArray[:,:,ind1]*(ds_factor-z) + srcArray[:,:,ind2]*(z))/ds_factor
# srcArray = srcArray_up[:,:,0:orgArray.shape[2]]
# Extract Patches
srcPatchSet = cropOneSlice_Patch(_params,
retArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
B0PatchSet = cropOneSlice_Patch(_params,
B0Array,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
maskPatchSet = cropOneSlice_Patch(_params,
maskArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
allB0PatchSet[stdIdx:endIdx, :, :, :] = B0PatchSet
allMaskPatchSet[stdIdx:endIdx, :, :, :] = maskPatchSet
stdIdx = endIdx
del srcPatchSet
del B0PatchSet
del maskPatchSet
del srcArray
del retArray
del B0Array
del maskArray
del srcImg
del B0Img
del maskImg
del orgArray
#del srcArray_down
# del srcArray_up
allSrcPatchSet = allSrcPatchSet[0:stdIdx, :, :, :]
allB0PatchSet = allB0PatchSet[0:stdIdx, :, :, :]
allMaskPatchSet = allMaskPatchSet[0:stdIdx, :, :, :]
del srcImg_Ori
# print ("Extract samples: Done ---")
return allSrcPatchSet, allB0PatchSet, allMaskPatchSet
def load_trainingdata_fromOneImage_withDownsampling_Interpl(
srcFile,
degreeSet,
refFile,
_params,
sDim,
tDim,
srcNumSlice,
offset_slice,
ds_factor,
offset=[],
scan_dir='axial',
triplanar=False,
img_aug=False,
skipZero=False,
dtype=np.uint16):
# print ("Extract samples: Start ---")
srcImageFile = str(srcFile)
srcImg = sitk.ReadImage(str(srcFile))
center = FuncImage.GetCenter(str(refFile))
srcImg_Ori = srcImg
allSrcPatchSet = np.zeros([
_params["training_parameters"]["MaximumNumPatches"]["value"],
_params["training_parameters"]["input_width"]["value"],
_params["training_parameters"]["input_height"]["value"],
_params["training_parameters"]["input_channels"]["value"]
],
dtype=dtype)
if len(offset) == 0:
offset = [
int(_params["training_parameters"]["input_width"]["value"] / 2),
int(_params["training_parameters"]["input_height"]["value"] / 2),
int(_params["training_parameters"]["input_channels"]["value"] / 2)
]
stdIdx = 0
for d in range(len(degreeSet)):
# rotate Image
# srcImg = FuncImage.RotateItkImg(srcImg_Ori, degreeSet[d], center, inverse=True)
if (img_aug == True):
# intensity augmentation by Histogram equalization
srcImgList = FuncImage.augment_images_intensity(srcImg_Ori)
for l in range(len(srcImgList)):
srcImg = srcImgList[l]
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
# Extract Patches
srcPatchSet = cropOneSlice_Patch(_params,
srcArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
stdIdx = endIdx
del srcPatchSet
del srcArray
del srcImg
else:
if (triplanar):
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
# axial
orgArray = srcArray
# Downsampling in slices
# zero-padding first
if (srcArray.shape[2] % ds_factor != 0):
addslices = ds_factor - (srcArray.shape[2] % ds_factor)
zeroArray = np.zeros(
[srcArray.shape[0], srcArray.shape[1], addslices],
dtype=dtype)
srcArray = np.concatenate([srcArray, zeroArray], axis=2)
#print srcArray.shape
# srcArray_down = srcArray[:,:,offset_slice::ds_factor]
# print srcArray_down.shape
# Interpolation in slices
#srcArray_up = resample_poly(srcArray_down, ds_factor, 1, axis = 2)
# bi-linear interpolation
noStep = int(srcArray.shape[2] / ds_factor) - 1
srcArray_up = srcArray
for k in range(0, noStep):
for z in range(1, ds_factor):
ind1 = k * ds_factor + offset_slice
ind2 = (k + 1) * ds_factor + offset_slice
srcArray_up[:, :, ind1 + z] = (srcArray[:, :, ind1] *
(ds_factor - z) +
srcArray[:, :, ind2] *
(z)) / ds_factor
#if (srcArray.shape[2] % ds_factor != 0):
srcArray_axial = srcArray_up[:, :, 0:orgArray.shape[2]]
# sagittal
srcArray = sitk.GetArrayFromImage(srcImg) # z, y, x
orgArray = srcArray
# Downsampling in slices
# zero-padding first
if (srcArray.shape[2] % ds_factor != 0):
addslices = ds_factor - (srcArray.shape[2] % ds_factor)
zeroArray = np.zeros(
[srcArray.shape[0], srcArray.shape[1], addslices],
dtype=dtype)
srcArray = np.concatenate([srcArray, zeroArray], axis=2)
#print srcArray.shape
# srcArray_down = srcArray[:,:,offset_slice::ds_factor]
# print srcArray_down.shape
# Interpolation in slices
#srcArray_up = resample_poly(srcArray_down, ds_factor, 1, axis = 2)
# bi-linear interpolation
noStep = int(srcArray.shape[2] / ds_factor) - 1
srcArray_up = srcArray
for k in range(0, noStep):
for z in range(1, ds_factor):
ind1 = k * ds_factor + offset_slice
ind2 = (k + 1) * ds_factor + offset_slice
srcArray_up[:, :, ind1 + z] = (srcArray[:, :, ind1] *
(ds_factor - z) +
srcArray[:, :, ind2] *
(z)) / ds_factor
#if (srcArray.shape[2] % ds_factor != 0):
srcArray_sag = srcArray_up[:, :, 0:orgArray.shape[2]]
srcArray_sag = srcArray_sag.transpose((2, 1, 0))
# coronal
srcArray = sitk.GetArrayFromImage(srcImg) # z, y, x
srcArray = srcArray.transpose((2, 0, 1)) # x, z, y
orgArray = srcArray
# Downsampling in slices
# zero-padding first
if (srcArray.shape[2] % ds_factor != 0):
addslices = ds_factor - (srcArray.shape[2] % ds_factor)
zeroArray = np.zeros(
[srcArray.shape[0], srcArray.shape[1], addslices],
dtype=dtype)
srcArray = np.concatenate([srcArray, zeroArray], axis=2)
#print srcArray.shape
# srcArray_down = srcArray[:,:,offset_slice::ds_factor]
# print srcArray_down.shape
# Interpolation in slices
#srcArray_up = resample_poly(srcArray_down, ds_factor, 1, axis = 2)
# bi-linear interpolation
noStep = int(srcArray.shape[2] / ds_factor) - 1
srcArray_up = srcArray
for k in range(0, noStep):
for z in range(1, ds_factor):
ind1 = k * ds_factor + offset_slice
ind2 = (k + 1) * ds_factor + offset_slice
srcArray_up[:, :, ind1 + z] = (srcArray[:, :, ind1] *
(ds_factor - z) +
srcArray[:, :, ind2] *
(z)) / ds_factor
#if (srcArray.shape[2] % ds_factor != 0):
srcArray_cor = srcArray_up[:, :, 0:orgArray.shape[2]]
srcArray_cor = srcArray_cor.transpose((0, 2, 1))
srcArray = np.mean(srcArray_axial, srcArray_sag, srcArray_cor)
del srcArray_axial
del srcArray_sag
del srcArray_cor
# Extract Patches
srcPatchSet = cropOneSlice_Patch(_params,
srcArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
stdIdx = endIdx
del srcPatchSet
del srcArray
del srcImg
del orgArray
#del srcArray_down
del srcArray_up
else:
# Get array
srcArray = sitk.GetArrayFromImage(srcImg)
srcArray = srcArray.transpose((2, 1, 0))
orgArray = srcArray
if (scan_dir == 'axial'):
# Downsampling in slices
# zero-padding first
if (srcArray.shape[2] % ds_factor != 0):
addslices = ds_factor - (srcArray.shape[2] % ds_factor)
zeroArray = np.zeros(
[srcArray.shape[0], srcArray.shape[1], addslices],
dtype=dtype)
srcArray = np.concatenate([srcArray, zeroArray],
axis=2)
#print srcArray.shape
# bi-linear interpolation
noStep = int(srcArray.shape[2] / ds_factor) - 1
srcArray_up = srcArray
for k in range(0, noStep):
for z in range(1, ds_factor):
ind1 = k * ds_factor + offset_slice
ind2 = (k + 1) * ds_factor + offset_slice
srcArray_up[:, :,
ind1 + z] = (srcArray[:, :, ind1] *
(ds_factor - z) +
srcArray[:, :, ind2] *
(z)) / ds_factor
srcArray = srcArray_up[:, :, 0:orgArray.shape[2]]
elif (scan_dir == 'coronal'):
# Downsampling in slices
# zero-padding first
if (srcArray.shape[1] % ds_factor != 0):
addslices = ds_factor - (srcArray.shape[1] % ds_factor)
zeroArray = np.zeros(
[srcArray.shape[0], addslices, srcArray.shape[2]],
dtype=dtype)
srcArray = np.concatenate([srcArray, zeroArray],
axis=1)
#print srcArray.shape
# bi-linear interpolation
noStep = int(srcArray.shape[1] / ds_factor) - 1
srcArray_up = srcArray
for k in range(0, noStep):
for y in range(1, ds_factor):
ind1 = k * ds_factor + offset_slice
ind2 = (k + 1) * ds_factor + offset_slice
srcArray_up[:,
ind1 + y, :] = (srcArray[:, ind1, :] *
(ds_factor - y) +
srcArray[:, ind2, :] *
(y)) / ds_factor
srcArray = srcArray_up[:, 0:orgArray.shape[1], :]
else: # scan_dir == 'sagittal'
# Downsampling in slices
# zero-padding first
if (srcArray.shape[0] % ds_factor != 0):
addslices = ds_factor - (srcArray.shape[0] % ds_factor)
zeroArray = np.zeros(
[addslices, srcArray.shape[1], srcArray.shape[2]],
dtype=dtype)
srcArray = np.concatenate([srcArray, zeroArray],
axis=0)
#print srcArray.shape
# bi-linear interpolation
noStep = int(srcArray.shape[0] / ds_factor) - 1
srcArray_up = srcArray
for k in range(0, noStep):
for x in range(1, ds_factor):
ind1 = k * ds_factor + offset_slice
ind2 = (k + 1) * ds_factor + offset_slice
srcArray_up[ind1 +
x, :, :] = (srcArray[ind1, :, :] *
(ds_factor - x) +
srcArray[ind2, :, :] *
(x)) / ds_factor
srcArray = srcArray_up[0:orgArray.shape[0], :, :]
# Extract Patches
srcPatchSet = cropOneSlice_Patch(_params,
srcArray,
sDim,
tDim,
srcNumSlice,
offset,
skipZero=skipZero,
dtype=dtype)
endIdx = stdIdx + srcPatchSet.shape[0]
allSrcPatchSet[stdIdx:endIdx, :, :, :] = srcPatchSet
stdIdx = endIdx
del srcPatchSet
del srcArray
del srcImg
del orgArray
#del srcArray_down
del srcArray_up
allSrcPatchSet = allSrcPatchSet[0:stdIdx, :, :, :]
del srcImg_Ori
# print ("Extract samples: Done ---")
return allSrcPatchSet