def Normalize():
root_folder = r'D:\ProblemData\Prcoessed'
for case in os.listdir(root_folder):
case_folder = os.path.join(root_folder, case)
if not os.path.isdir(case_folder):
continue
print('Normalizing PZ of {}'.format(case))
wg_path = os.path.join(case_folder, 'prostate_roi.nii.gz')
cg_path = os.path.join(case_folder, 'cg.nii')
if not os.path.exists(wg_path) and not os.path.exists(cg_path):
continue
wg_image, _, wg_data = LoadNiiData(wg_path, dtype=np.uint8)
cg_image, _, cg_data = LoadNiiData(cg_path, dtype=np.uint8)
print(np.unique(wg_data), np.unique(cg_data))
if list(np.unique(wg_data)) == [0, 255]:
wg = np.array(wg_data / 255, dtype=np.uint8)
else:
wg = wg_data
if list(np.unique(cg_data)) == [0, 255]:
cg = np.array(cg_data / 255, dtype=np.uint8)
else:
cg = cg_data
wg_array = GetImageFromArrayByImage(wg, wg_image)
cg_array = GetImageFromArrayByImage(cg, wg_image)
SaveNiiImage(os.path.join(case_folder, 'normalize_prostate_roi.nii'),
wg_array)
SaveNiiImage(os.path.join(case_folder, 'normalize_cg.nii'), cg_array)
print(np.unique(wg), np.unique(cg))
def MergePzAndTz():
from MeDIT.Visualization import Imshow3DArray
from MeDIT.Normalize import Normalize01
root_folder = r'D:\ProblemData\Prcoessed'
for case in os.listdir(root_folder):
case_folder = os.path.join(root_folder, case)
if not os.path.isdir(case_folder):
continue
print('Estimating PZ of {}'.format(case))
cg_path = os.path.join(case_folder, 'cg.nii')
pz_path = os.path.join(case_folder, 'pz.nii')
cg_image, _, cg_data = LoadNiiData(cg_path, dtype=np.uint8)
pz_image, _, pz_data = LoadNiiData(pz_path, dtype=np.uint8)
# Merge
merge_roi = pz_data + 2 * cg_data
# Imshow3DArray(np.concatenate((Normalize01(cg_data), Normalize01(pz_data), Normalize01(merge_roi)), axis=1))
# print(np.unique(merge_roi))
# Save PZ image
merge_image = GetImageFromArrayByImage(merge_roi, pz_image)
SaveNiiImage(os.path.join(case_folder, 'merge_pz1_cg2.nii'),
merge_image)
def Run(self, image, store_folder=''):
if isinstance(image, str):
image = sitk.ReadImage(image)
resolution = image.GetSpacing()
flip_log = [0, 0, 0]
_, data = GetDataFromSimpleITK(image,
dtype=np.float32,
is_flip=False,
flip_log=flip_log)
# Preprocess Data
data = self._config.CropDataShape(data, resolution)
input_list = self.TransOneDataFor2_5DModel(data)
with self.graph.as_default():
# 多监督模型输出三个，第一个为于是大小尺寸
preds_list = self._model.predict(input_list)
pred = preds_list[0]
pred = np.argmax(pred, axis=-1)
pred = self.invTransDataFor2_5DModel(pred)
pred = self._config.RecoverDataShape(pred, resolution)
pred = self.__FilterResult(pred)
new_pred = self.__KeepLargest(np.round(pred))
mask_image = GetImageFromArrayByImage(new_pred,
image,
flip_log=flip_log)
if store_folder:
if os.path.isdir(store_folder):
store_folder = os.path.join(
store_folder, '{}.nii.gz'.format(self._config.GetName()))
SaveNiiImage(store_folder, mask_image)
return new_pred, mask_image
def Normalize(process_folder, resampe_folder):
for case in os.listdir(process_folder):
case_folder = os.path.join(process_folder, case)
store_case_folder = os.path.join(resampe_folder, case)
if not os.path.exists(store_case_folder):
os.mkdir(store_case_folder)
print('Normalizing {}'.format(case))
roi_path = os.path.join(case_folder, 'roi.nii')
if not os.path.exists(roi_path):
continue
roi_image, _, roi_data = LoadImage(roi_path, dtype=np.uint8)
if list(np.unique(roi_data)) == [0, 255]:
roi = np.array(roi_data / 255, dtype=np.uint8)
else:
roi = roi_data
roi_array = GetImageFromArrayByImage(roi, roi_image)
SaveNiiImage(os.path.join(store_case_folder, 'normalize_roi.nii'),
roi_array)
if os.path.exists(os.path.join(case_folder, 'normalize_roi.nii')):
os.remove(os.path.join(case_folder, 'normalize_roi.nii'))
def GetPzRegion():
root_folder = r'D:\ProblemData\Prcoessed'
for case in os.listdir(root_folder):
case_folder = os.path.join(root_folder, case)
if not os.path.isdir(case_folder):
continue
print('Estimating PZ of {}'.format(case))
wg_path = os.path.join(case_folder, 'prostate_roi.nii.gz')
cg_path = os.path.join(case_folder, 'cg.nii')
t2_path = os.path.join(case_folder, 't2.nii')
if not os.path.exists(wg_path) and not os.path.exists(cg_path):
continue
wg_image, _, wg_data = LoadNiiData(wg_path, dtype=np.uint8)
cg_image, _, cg_data = LoadNiiData(cg_path, dtype=np.uint8)
# # Calculating PZ
pz_data = wg_data - cg_data
# print(np.unique(pz_data))
pz_data[pz_data == 255] = 0
# from MeDIT.Visualization import Imshow3DArray
# from MeDIT.Normalize import Normalize01
#
# _, _, t2 = LoadNiiData(t2_path)
#
# Imshow3DArray(np.concatenate([Normalize01(t2), Normalize01(t2)], axis=1), roi=np.concatenate([pz_data0, pz_data], axis=1))
#
# print(np.unique(pz_data), np.unique(wg_data), np.unique(cg_data))
# Save PZ image
pz_image = GetImageFromArrayByImage(pz_data, wg_image)
SaveNiiImage(os.path.join(case_folder, 'pz.nii'), pz_image)
def SaveNumpyToImageByRef(store_path, data, ref_image):
image = GetImageFromArrayByImage(data, ref_image)
image.CopyInformation(ref_image)
sitk.WriteImage(image, store_path)
def LoadFreeSurferLabel(ref_image_path, label_file, store_folder=''):
if store_folder:
if not os.path.exists(store_folder):
os.mkdir(store_folder)
def _GetLabel(label_path):
with open(label_path, 'r') as file:
lines = file.readlines()
position_list = []
for line in lines[2:]:
one_line = line.split(' ')
one_line = [index for index in one_line if index != '']
position_list.append([
float(one_line[1]),
float(one_line[2]),
float(one_line[3])
])
return position_list
if not (isinstance(ref_image_path, str) and isinstance(label_file, str)):
print('The input must be file path (string)')
flip_log = [0, 0, 0]
if ref_image_path.endswith('.mgz'):
temp_image = nb.load(ref_image_path)
if store_folder:
nb.save(temp_image,
os.path.join(store_folder, 'transfer_image.nii.gz'))
image, data, show_data = LoadNiiData(os.path.join(
store_folder, 'transfer_image.nii.gz'),
is_flip=flip_log)
else:
temp_image_path = 'temp_image.nii.gz'
nb.save(temp_image, temp_image_path)
image, data, show_data = LoadNiiData(temp_image_path,
is_flip=flip_log)
os.remove(temp_image_path)
if ref_image_path.endswith('.nii') or ref_image_path.endswith('.nii.gz'):
image, data, show_data = LoadNiiData(ref_image_path, is_flip=flip_log)
origion = image.GetOrigin()
image.SetOrigin((128, 128, 128))
position_list = _GetLabel(label_file)
index_list = list(
set([
image.TransformPhysicalPointToIndex(position)
for position in position_list
]))
mask = np.zeros((image.GetSize()), dtype=np.uint8)
for index in index_list:
mask[index[1], index[0], index[2]] = 1
if store_folder:
from MeDIT.ImageProcess import GetImageFromArrayByImage
image.SetOrigin(origion)
store_image = GetImageFromArrayByImage(mask,
image,
is_transfer_axis=True)
SaveNiiImage(os.path.join(store_folder, 'label.nii.gz'), store_image)
return show_data, mask
def Run(self,
image,
model_folder_path,
store_folder='',
is_return_all_data=False):
resolution = image.GetSpacing()
_, data = GetDataFromSimpleITK(image, dtype=np.float32)
self._image_preparer.LoadModelConfig(
os.path.join(model_folder_path, 'config.ini'))
''' 2) Select Data'''
data = self._image_preparer.CropDataShape(data, resolution)
data = self.TransDataFor2DModel(data)
data = NormalizeForTensorflow(data)
preds = self._loaded_model.predict(data)
if is_return_all_data:
data = np.squeeze(data)
preds = np.squeeze(preds)
pred1 = preds[:, :np.prod(data.shape[1:3]) // 16]
pred2 = preds[:,
np.prod(data.shape[1:3]) //
16:-np.prod(data.shape[1:3])]
pred3 = preds[:, -np.prod(data.shape[1:3]):]
pred1 = np.reshape(
pred1, (data.shape[0], data.shape[1] // 4, data.shape[2] // 4))
pred2 = np.reshape(
pred2, (data.shape[0], data.shape[1] // 2, data.shape[2] // 2))
pred3 = np.reshape(pred3,
(data.shape[0], data.shape[1], data.shape[2]))
import cv2
data1 = np.zeros(
(data.shape[0], data.shape[1] // 4, data.shape[2] // 4))
data2 = np.zeros(
(data.shape[0], data.shape[1] // 2, data.shape[2] // 2))
for slice_index in range(data.shape[0]):
data1[slice_index, ...] = cv2.resize(
data[slice_index,
...], (data.shape[1] // 4, data.shape[2] // 4))
data2[slice_index, ...] = cv2.resize(
data[slice_index,
...], (data.shape[1] // 2, data.shape[2] // 2))
data1 = np.transpose(data1, (1, 2, 0))
data2 = np.transpose(data2, (1, 2, 0))
data3 = np.transpose(data, (1, 2, 0))
pred1 = np.transpose(pred1, (1, 2, 0))
pred2 = np.transpose(pred2, (1, 2, 0))
pred3 = np.transpose(pred3, (1, 2, 0))
return [data1, data2, data3], [pred1, pred2, pred3]
preds = preds[:, -np.prod(self._image_preparer.GetShape()):, :]
preds = np.reshape(preds,
(data.shape[0], self._image_preparer.GetShape()[0],
self._image_preparer.GetShape()[1]))
# ct the ROI
preds = self.invTransDataFor2DModel(preds)
preds = self._image_preparer.RecoverDataShape(preds, resolution)
mask = np.asarray(preds > 0.5, dtype=np.uint8)
mask = self.__KeepLargest(mask)
# To process the extremely cases
final_shape = image.GetSize()
final_shape = [final_shape[1], final_shape[0], final_shape[2]]
mask = Crop3DImage(mask, final_shape)
mask_image = GetImageFromArrayByImage(mask, image)
if store_folder:
if os.path.isdir(store_folder):
store_folder = os.path.join(store_folder,
'prostate_roi.nii.gz')
SaveNiiImage(store_folder, mask_image)
return preds, mask, mask_image