def save(self, savePath, patientID):
if self.onlyCancer:
print("Saving only images with cancer.")
savePath = Path(savePath)
saveImagePath = savePath / "image" / patientID / "dummy.mha"
saveTextPath = savePath / "path" / (patientID + ".txt")
if not saveImagePath.parent.exists():
createParentPath(str(saveImagePath))
if not saveTextPath.parent.exists():
createParentPath(str(saveTextPath))
for i in range(2):
length = len(self.cuttedLabelList[i])
for x in tqdm(range(length), desc="Saving images...", ncols=60):
if self.onlyCancer and not (
self.cuttedStackedLabelArrayList[i][x] == 2).any():
continue
saveImagePath = savePath / "image" / patientID / "image_{}_{:02d}.mha".format(
i, x)
saveLabelPath = savePath / "image" / patientID / "label_{}_{:02d}.mha".format(
i, x)
sitk.WriteImage(self.cuttedLabelList[i][x], str(saveLabelPath),
True)
sitk.WriteImage(self.cuttedImageList[i][x], str(saveImagePath),
True)
write_file(str(saveTextPath),
str(saveImagePath) + "\t" + str(saveLabelPath))
def main(args):
""" Get the patch size from string."""
plane_size = getSizeFromString(args.plane_size, digit=2)
""" Slice module. """
image = sitk.ReadImage(args.image_path)
dummy = sitk.Image(image.GetSize(), sitk.sitkUInt8)
dummy.SetOrigin(image.GetOrigin())
dummy.SetSpacing(image.GetSpacing())
dummy.SetDirection(image.GetDirection())
""" Get patches. """
tpc = ThinPatchCreater(image=image,
label=dummy,
image_patch_width=args.image_patch_width,
label_patch_width=args.label_patch_width,
plane_size=plane_size,
overlap=args.overlap)
tpc.execute()
image_array_list, _ = tpc.output("Array")
""" Confirm if GPU is available. """
use_cuda = torch.cuda.is_available() and True
device = torch.device("cuda" if use_cuda else "cpu")
""" Load model. """
with open(args.modelweightfile, 'rb') as f:
model = cloudpickle.load(f)
model = torch.nn.DataParallel(model, device_ids=args.gpuid)
model.eval()
""" Caluculate lower and upper crop size. """
image_patch_size = np.array(plane_size.tolist() + [args.image_patch_width])
label_patch_size = np.array(plane_size.tolist() + [args.label_patch_width])
diff = image_patch_size - label_patch_size
lower_crop_size = diff // 2
upper_crop_size = (diff + 1) // 2
""" Segmentation module. """
segmented_array_list = []
for image_array in tqdm(image_array_list,
desc="Segmenting images...",
ncols=60):
image_array = torch.from_numpy(image_array)[None, None,
...].to(device,
dtype=torch.float)
segmented_array = model(image_array)
segmented_array = segmented_array.to("cpu").detach().numpy().astype(
np.float)
segmented_array = np.squeeze(segmented_array)
segmented_array = np.argmax(segmented_array, axis=0).astype(np.uint8)
segmented_array = croppingForNumpy(segmented_array,
lower_crop_size[::-1],
upper_crop_size[::-1])
segmented_array_list.append(segmented_array)
""" Restore module. """
segmented = tpc.restore(segmented_array_list)
createParentPath(args.save_path)
print("Saving image to {}".format(args.save_path))
sitk.WriteImage(segmented, args.save_path, True)
def main(args):
testing = [
'019', '023', '054', '093', '096', '123', '127', '136', '141', '153',
'188', '191', '201'
]
for x in testing:
truePath = Path(args.labelPath) / ("case_00" + x) / "label.nii.gz"
segPath = Path(args.labelPath) / ("case_00" + x) / "label_seg.mha"
true = sitk.ReadImage(str(truePath))
seg = sitk.ReadImage(str(segPath))
trueArray = sitk.GetArrayFromImage(true)
segArray = sitk.GetArrayFromImage(seg)
check = np.logical_and(trueArray == segArray, segArray == 2)
overlapArray = np.where(check, 3, segArray)
overlap = sitk.GetImageFromArray(overlapArray)
overlap.SetDirection(true.GetDirection())
overlap.SetOrigin(true.GetOrigin())
overlap.SetSpacing(true.GetSpacing())
savePath = Path(args.savePath) / ("case_00" + x) / "label_over.mha"
createParentPath(savePath)
sitk.WriteImage(overlap, str(savePath), True)
def main(args):
if args.class_label is not None:
if len(args.class_label) != args.classes:
print(
"[ERROR] You have to equate the length of class_label with the classes"
)
sys.exit()
else:
args.class_label = ["Class {}".format(c) for c in range(args.classes)]
df = pd.DataFrame()
ID = []
whole_DICE = []
DICE_per_class = [[] for _ in range(args.classes)]
total = len(args.patientID_list) * args.classes
with tqdm(desc="Caluculating DICE...", ncols=60, total=total) as pbar:
for x in args.patientID_list:
true_directory = Path(
args.true_directory) / ("case_" + x) / args.true_name
predict_directory = Path(
args.predict_directory) / ("case_" + x) / args.predict_name
true = sitk.ReadImage(str(true_directory))
predict = sitk.ReadImage(str(predict_directory))
true_array = sitk.GetArrayFromImage(true)
predict_array = sitk.GetArrayFromImage(predict)
dice = DICE(true_array, predict_array)
whole_DICE.append(dice)
ID.append("case_" + x)
for c in range(args.classes):
true_c_array = (true_array == c).astype(int)
predict_c_array = (predict_array == c).astype(int)
dice = DICE(true_c_array, predict_c_array)
DICE_per_class[c].append(dice)
pbar.update(1)
df["patient ID"] = ID
df["Whole DICE"] = whole_DICE
for c in range(args.classes):
df[args.class_label[c]] = DICE_per_class[c]
avg_dice = np.mean(whole_DICE)
means = {"patient ID": ["means"]}
means["Whole DICE"] = [avg_dice]
for c, dice_c in zip(range(args.classes), DICE_per_class):
avg_dice = np.mean(dice_c)
means[args.class_label[c]] = [avg_dice]
df_means = pd.DataFrame(means)
df = pd.concat([df, df_means], sort=False)
createParentPath(args.save_path)
print("Saving dataframe to {}...".format(args.save_path))
df.to_csv(args.save_path, index=False)
print("Done.")
def main(args):
""" Get the patch size from string."""
matchobj = re.match("([0-9]+)-([0-9]+)-([0-9]+)", args.patch_size)
if matchobj is None:
print("[ERROR] Invalid patch size : {}.".fotmat(args.patch_size))
sys.exit()
patch_size = [int(s) for s in matchobj.groups()]
""" Get the patch size from string."""
matchobj = re.match("([0-9]+)-([0-9]+)", args.plane_size)
if matchobj is None:
print("[ERROR] Invalid patch size : {}.".fotmat(args.plane_size))
sys.exit()
plane_size = [int(s) for s in matchobj.groups()]
""" Slice module. """
image = sitk.ReadImage(args.image_path)
lpc = LabelPatchCreater(
label = image,
patch_size = patch_size,
plane_size = plane_size,
overlap = args.overlap,
num_rep = args.num_rep,
)
lpc.execute()
image_array_list = lpc.output("Array")
use_cuda = torch.cuda.is_available() and True
device = torch.device("cuda" if use_cuda else "cpu")
""" Load model. """
with open(args.modelweightfile, 'rb') as f:
model = cloudpickle.load(f)
model = torch.nn.DataParallel(model, device_ids=args.gpuid)
model.eval()
""" Segmentation module. """
segmented_array_list = []
for image_array in tqdm(image_array_list, desc="Segmenting images...", ncols=60):
image_array = torch.from_numpy(image_array)[None, None, ...].to(device, dtype=torch.float)
segmented_array = model(image_array)
segmented_array = segmented_array.to("cpu").detach().numpy().astype(np.float)
segmented_array = np.squeeze(segmented_array)
segmented_array = np.argmax(segmented_array, axis=0).astype(np.uint8)
segmented_array_list.append(segmented_array)
""" Restore module. """
segmented = lpc.restore(segmented_array_list)
createParentPath(args.save_path)
print("Saving image to {}".format(args.save_path))
sitk.WriteImage(segmented, args.save_path, True)
def main(args):
image = sitk.ReadImage(args.image_path)
resampled_image = resampleSpacing(image, list(args.spacing), args.is_label)
print("Change shape from {} to {}.".format(image.GetSize(), resampled_image.GetSize()))
print("Chage spacing from {} to {}.".format(image.GetSpacing(), resampled_image.GetSpacing()))
createParentPath(args.save_path)
sitk.WriteImage(resampled_image, args.save_path, True)
def main(args):
use_cuda = torch.cuda.is_available() and True
device = torch.device("cuda" if use_cuda else "cpu")
""" Slice module. """
labelFile = Path(args.imageDirectory) / "segmentation.nii.gz"
imageFile = Path(args.imageDirectory) / "imaging.nii.gz"
label = sitk.ReadImage(str(labelFile))
image = sitk.ReadImage(str(imageFile))
slicer = sler(image=image,
label=label,
outputImageSize=args.patchSize,
widthSize=args.widthSize,
paddingSize=args.paddingSize,
noFlip=args.noFlip)
slicer.execute()
_, cuttedImageArrayList = slicer.output("Array")
""" Load model. """
with open(args.modelweightfile, 'rb') as f:
model = cloudpickle.load(f)
model = torch.nn.DataParallel(model, device_ids=args.gpuid)
model.eval()
""" Segmentation module. """
segmentedArrayList = [[] for _ in range(2)]
for i in range(2):
length = len(cuttedImageArrayList[i])
for x in tqdm(range(length), desc="Segmenting images...", ncols=60):
imageArray = cuttedImageArrayList[i][x]
imageArray = imageArray.transpose((2, 0, 1))
imageArray = torch.from_numpy(imageArray[np.newaxis, ...]).to(
device, dtype=torch.float)
segmentedArray = model(imageArray)
segmentedArray = segmentedArray.to("cpu").detach().numpy().astype(
np.float)
segmentedArray = np.squeeze(segmentedArray)
segmentedArray = np.argmax(segmentedArray, axis=0).astype(np.uint8)
segmentedArrayList[i].append(segmentedArray)
""" Restore module. """
segmentedArray = slicer.restore(segmentedArrayList)
segmented = getImageWithMeta(segmentedArray, label)
createParentPath(args.savePath)
print("Saving image to {}".format(args.savePath))
sitk.WriteImage(segmented, args.savePath, True)
def main(args):
label = sitk.ReadImage(args.label_path)
label_array = sitk.GetArrayFromImage(label)
if args.mask_number < 0:
mask_array = (label_array > 0).astype(np.int)
else:
mask_array = (label_array == args.mask_number).astype(np.int)
mask = getImageWithMeta(mask_array, label)
createParentPath(args.save_path)
print("Saving mask image to {} ...".format(args.save_path))
sitk.WriteImage(mask, args.save_path, True)
print("Done")
def save(self, save_path):
save_path = Path(save_path)
save_image_path = save_path / "dummy.mha"
if not save_image_path.parent.exists():
createParentPath(str(save_image_path))
with tqdm(total=len(self.image_list), desc="Saving image and label...", ncols=60) as pbar:
for i, (image, label) in enumerate(zip(self.image_list, self.label_list)):
save_image_path = save_path / "image_{:04d}.mha".format(i)
save_label_path = save_path / "label_{:04d}.mha".format(i)
sitk.WriteImage(image, str(save_image_path), True)
sitk.WriteImage(label, str(save_label_path), True)
pbar.update(1)
def save(self, save_path, patientID):
save_path = Path(save_path)
save_image_path = save_path / patientID / "dummy.mha"
if not save_image_path.parent.exists():
createParentPath(str(save_image_path))
for i, (image,
label) in tqdm(enumerate(zip(self.image_list,
self.label_list)),
desc="Saving images and labels...",
ncols=60):
save_image_path = save_path / patientID / "image_{:04d}.mha".format(
i)
save_label_path = save_path / patientID / "label_{:04d}.mha".format(
i)
sitk.WriteImage(image, str(save_image_path), True)
sitk.WriteImage(label, str(save_label_path), True)
def main(args):
if not Path(args.log_path).exists():
with open(args.json, "r") as f:
json_file = json.load(f)
df = pd.DataFrame([json_file])
else:
df_org = pd.read_csv(args.log_path)
with open(args.json, "r") as f:
json_file = json.load(f)
df_new = pd.DataFrame([json_file])
df = pd.concat([df_org, df_new], sort=False)
createParentPath(args.log_path)
print("Logging to {}...".format(args.log_path))
df.to_csv(args.log_path, index=False)
print("Done")
def main(args):
path = Path(args.filePath)
savePath = Path(args.savePath)
saveSize = (256, 256)
imagePathList = []
labelPathList = []
for d in ["left", "right"]:
imagePath = path / ("image_" + d + ".nii.gz")
labelPath = path / ("label_" + d + ".nii.gz")
image = sitk.ReadImage(str(imagePath))
label = sitk.ReadImage(str(labelPath))
dummyPath = savePath / d / "dummy.mha"
createParentPath(dummyPath)
length = image.GetSize()[0]
for x in range(length):
imageSavePath = savePath / d / ("image_" + str(x).zfill(3) +
".mha")
labelSavePath = savePath / d / ("label_" + str(x).zfill(3) +
".mha")
imageSlice = ResamplingInAxis(image, x, saveSize)
labelSlice = ResamplingInAxis(label, x, saveSize, is_label=True)
sitk.WriteImage(imageSlice, str(imageSavePath), True)
sitk.WriteImage(labelSlice, str(labelSavePath), True)
imagePathList.append(str(imageSavePath))
labelPathList.append(str(labelSavePath))
textSavePath = savePath.parent / "path" / (path.name + ".txt")
createParentPath(textSavePath)
imagePathList = sorted(imagePathList)
labelPathList = sorted(labelPathList)
for x, y in zip(imagePathList, labelPathList):
write_file(textSavePath, str(y) + "\t" + str(x))
def save(self, save_path):
save_path = Path(save_path)
save_image_path = save_path / "dummy.npy"
if not save_image_path.parent.exists():
createParentPath(str(save_image_path))
if not self.integrate:
with tqdm(total=len(self.masked_indices),
desc="Saving image, label and coordinate...",
ncols=60) as pbar:
for i, (image_array_patch, label_array_patch,
coordinate_array_patch) in enumerate(self.loadData()):
save_image_path = save_path / "image_{:04d}.npy".format(i)
save_label_path = save_path / "label_{:04d}.npy".format(i)
save_coordinate_path = save_path / "coordinate_{:04d}.npy".format(
i)
np.save(str(save_image_path), image_array_patch)
np.save(str(save_label_path), label_array_patch)
np.save(str(save_coordinate_path), coordinate_array_patch)
pbar.update(1)
else:
with tqdm(
total=len(self.masked_indices),
desc="Saving image integrated with coordinate and label...",
ncols=60) as pbar:
for i, (image_array_patch,
label_array_patch) in enumerate(self.loadData()):
save_image_path = save_path / "image_{:04d}.npy".format(i)
save_label_path = save_path / "label_{:04d}.npy".format(i)
np.save(str(save_image_path), image_array_patch)
np.save(str(save_label_path), label_array_patch)
pbar.update(1)
def save(self, save_path, kind):
if kind == "Image":
save_path = Path(save_path)
save_image_path = save_path / "dummy.mha"
if not save_image_path.parent.exists():
createParentPath(str(save_image_path))
with tqdm(total=len(self.image_list), desc="Saving image and label as image...", ncols=60) as pbar:
for i, (image, label) in enumerate(zip(self.image_list, self.label_list)):
save_image_path = save_path / "image_{:04d}.mha".format(i)
save_label_path = save_path / "label_{:04d}.mha".format(i)
sitk.WriteImage(image, str(save_image_path), True)
sitk.WriteImage(label, str(save_label_path), True)
pbar.update(1)
if kind == "Array":
save_path = Path(save_path)
save_image_path = save_path / "dummy.npy"
if not save_image_path.parent.exists():
createParentPath(str(save_image_path))
with tqdm(total=len(self.image_array_list), desc="Saving image and label as array...", ncols=60) as pbar:
for i, (image_array, label_array) in enumerate(zip(self.image_array_list, self.label_array_list)):
save_image_path = save_path / "image_{:04d}.npy".format(i)
save_label_path = save_path / "label_{:04d}.npy".format(i)
np.save(str(save_image_path), image_array)
np.save(str(save_label_path), label_array)
pbar.update(1)
else:
print("[ERROR] Kind must be Image / Array.")
sys.exit()
def main(args):
sys.path.append("..")
use_cuda = torch.cuda.is_available() and True
device = torch.device("cuda" if use_cuda else "cpu")
""" Slice module. """
image = sitk.ReadImage(args.image_path)
liver = sitk.ReadImage(args.liver_path)
if args.mask_path is not None:
mask = sitk.ReadImage(args.mask_path)
else:
mask = None
""" Dummy image """
label = sitk.Image(image.GetSize(), sitk.sitkInt8)
label.SetOrigin(image.GetOrigin())
label.SetDirection(image.GetDirection())
label.SetSpacing(image.GetSpacing())
""" Get the patch size from string."""
image_patch_size = getSizeFromString(args.image_patch_size)
""" Get the patch size from string."""
label_patch_size = getSizeFromString(args.label_patch_size)
cogc = CenterOfGravityCaluculater(liver)
liver_center = cogc.execute()
print("Liver center: ", liver_center)
iace = ImageAndCoordinateExtractor(
image = image,
label = label,
mask = mask,
image_array_patch_size = image_patch_size,
label_array_patch_size = label_patch_size,
overlap = args.overlap,
center = liver_center,
integrate = True
)
iace.execute()
""" Load model. """
with open(args.modelweightfile, 'rb') as f:
model = cloudpickle.load(f)
model = torch.nn.DataParallel(model, device_ids=args.gpuid)
model.eval()
""" Segmentation module. """
segmented_array_list = []
for image_array, _ in tqdm(iace.loadData(), desc="Segmenting images...", ncols=60):
#image_array = image_array.transpose(2, 0, 1)
while image_array.ndim < 5:
image_array = image_array[np.newaxis, ...]
image_array = torch.from_numpy(image_array).to(device, dtype=torch.float)
segmented_array = model(image_array)
segmented_array = segmented_array.to("cpu").detach().numpy().astype(np.float)
segmented_array = np.squeeze(segmented_array)
segmented_array = np.argmax(segmented_array, axis=0).astype(np.uint8)
#segmented_array = segmented_array.transpose(1, 2, 0)
segmented_array_list.append(segmented_array)
""" Restore module. """
segmented = iace.restore(segmented_array_list)
createParentPath(args.save_path)
print("Saving image to {}".format(args.save_path))
sitk.WriteImage(segmented, args.save_path, True)
def main(_):
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
#config.log_device_placement = True
sess = tf.compat.v1.Session(config=config)
tf.compat.v1.keras.backend.set_session(sess)
modelweightfile = os.path.expanduser(args.modelweightfile)
with tf.device('/device:GPU:{}'.format(args.gpuid)):
print('loading U-net model {}...'.format(modelweightfile), end='', flush=True)
# with open(args.modelfile) as f:
# model = tf.compat.v1.keras.models.model_from_yaml(f.read())
# model.load_weights(args.modelweightfile)
model = tf.compat.v1.keras.models.load_model(modelweightfile,
custom_objects={'penalty_categorical' : penalty_categorical, 'kidney_dice':kidney_dice, 'cancer_dice':cancer_dice})
print('done')
savepath = os.path.expanduser(args.savepath)
createParentPath(savepath)
labelfile = os.path.expanduser(args.labelfile)
imagefile = os.path.expanduser(args.imagefile)
## Read image
label = sitk.ReadImage(labelfile)
image = sitk.ReadImage(imagefile)
labelArray = sitk.GetArrayFromImage(label)
imageArray = sitk.GetArrayFromImage(image)
print("Whole size: ",labelArray.shape)
totalNumber = len(labelArray[:,0,:0])
#######スライス開始##########
#################腎臓の数を特定, １ブロックにつき１つになるように3Dのまま、最大範囲切り取る##########################
kidIndex = []#特定された腎臓のインデックス群[[1つ目],[2つ目],...]
kidFragment = []#分けた3腎臓のインデックス群の保存先
k = []#一時的保持
for x in range(totalNumber-1):
if np.where(labelArray[x,:,:]!=0,True,False).any() and np.where(labelArray[x+1,:,:]!=0,True,False).any():
k.append(x)
elif np.where(labelArray[x,:,:]!=0,True,False).any() and not(np.where(labelArray[x+1,:,:]!=0,True,False).any()):
k.append(x)
kidIndex.append(copy.copy(k))
k.clear()
if len(kidIndex) != 2:
print("The patient has horse shoe kidney.")
sys.exit()
cutKidFragLabel = []#[[1つ目の腎臓の行列],[2つ目の腎臓の行列],..]
cutKidFragImage = []
skip_cnt = 0
check1=0
check2=0
inversedImage = np.zeros_like(labelArray)
invDic = [[] for x in range(2)]##invereに必要な情報を保存
cutIndex = []##高さ方向の挿入位置
for i,kidFrag in enumerate(kidIndex):
IndexFirst = kidFrag[0]
IndexFinal = kidFrag[-1]
if IndexFirst < len(labelArray[:,0,0])/2:
kidFragment.append(np.arange(IndexFinal+1,len(labelArray[:,0,0])))
check1 += 1
else:
kidFragment.append(np.arange(IndexFirst))
check2 += 1
#分けた腎臓の行列を保存
if kidFragment[i][0]==kidFragment[i][-1]:
skip_cnt -= 1
continue
else:
cutKidFragLabel.append(labelArray[kidFragment[i][0]:kidFragment[i][-1]+1,:,:])
cutKidFragImage.append(imageArray[kidFragment[i][0]:kidFragment[i][-1]+1,:,:])
i = i + skip_cnt
#一つの腎臓を反転
if i == 1:
cutKidFragLabel[1] = cutKidFragLabel[1][::-1,:,:]
cutKidFragImage[1] = cutKidFragImage[1][::-1,:,:]
#############################################################################################
#axial方向について、３D画像として切り取る
cutKidFragLabel[i], cutKidFragImage[i], cIndex, snum = cut3D(cutKidFragLabel[i],cutKidFragImage[i],"axial")
#print("cutted size_"+str(i)+": ",cutKidFragLabel[i].shape)
##最大サイズの腎臓を持つスライスの特定
mArea = []
for ckfl in range(len(cutKidFragLabel[i][0,0,:])):
mArea.append(caluculate_area(cutKidFragLabel[i][:,:,ckfl]))
maxArea = np.argmax(mArea)
#最大サイズのスライスの幅、高さの計算
roi, maxCenter, maxwh, maxAngle = cut_image(cutKidFragLabel[i][:,:,maxArea])
roi, center, wh, angle = cut_image(cutKidFragImage[i][:,:,maxArea], center=maxCenter, wh=maxwh, angle=maxAngle)
rmaxwh = list(maxwh)
rmaxwh = rmaxwh[::-1]
rmaxwh = tuple(rmaxwh)#調整
imgArrayList = []
ctMax = -10**9
ctMin = 10**9
for ckfl in range(len(cutKidFragLabel[i][0,0,:])):
a = caluculate_area(cutKidFragLabel[i][:,:,ckfl])
##腎臓のない領域の画像保存
if a==0:
x0 = maxCenter[1] - int((maxwh[1]+15)/2)
x1 = maxCenter[1] + int((maxwh[1]+15)/2)
y0 = maxCenter[0] - int((maxwh[0]+15)/2)
y1 = maxCenter[0] + int((maxwh[0]+15)/2)
if x0<0:
x0 = 0
if y0<0:
y0 = 0
roi_lab = cutKidFragLabel[i][x0 :x1, y0 :y1, ckfl]
roi_img = cutKidFragImage[i][x0 :x1, y0 :y1, ckfl]
center = maxCenter
wh = maxwh
angle = 0
##腎臓領域ありの時
else:
roi, center, wh, angle = cut_image(cutKidFragLabel[i][:,:,ckfl])
if (maxwh[0]>maxwh[1])==(wh[0]>wh[1]):
roi, center, wh, angle = cut_image(cutKidFragLabel[i][:,:,ckfl],wh=maxwh)##中心,角度取得
roi_lab = roi
else:
roi, center, wh, angle = cut_image(cutKidFragLabel[i][:,:,ckfl],wh=rmaxwh)##中心,角度取得
roi_lab = roi
roi, center, wh, angle = cut_image(cutKidFragImage[i][:,:,ckfl], center=center, wh=wh, angle=angle)
roi_img = roi
###############Change!!!!!!!!!!!!!!!!!!!!!!!!! Do not change img from float to int
#roi_img = np.array(roi_img, dtype=np.int64)
if roi_img.max()>ctMax:
ctMax = roi_img.max()
if roi_img.min()<ctMin:
ctMin = roi_img.min()
imgArrayList.append(roi_img)
##inverse用
invDic[i].append({
"roi_lab" : np.zeros_like(roi_lab),
"roi_img" : roi_img,
"cutKidFragLabel" : cutKidFragLabel[i][:,:,ckfl],
"wh" : wh, "center" : center, "angle" : angle,
"labelArray" : labelArray,
"image" : label
})
print("{}(st nd) kidney {}/{} cutted".format(i,len(invDic[i]),len(cutKidFragLabel[i][0,0,:])))
#ヒストグラム均一化
print(type(imgArrayList[0][0][0]))
equalizedImageArrayList = equalizingHistogramSummedFloat(imgArrayList, args.npyfile, args.alpha)
llll = 0
for equalizedImage, inv in zip(equalizedImageArrayList, invDic[i]):
inv["roi_img"] = equalizedImage
# save_image_256(equalizedImage, label, r"test/test"+str(i)+"_"+str(llll)+".mha")
# llll += 1
cutIndex.append(cIndex)
####スライス終了####
#####segmentation#########
for i in range(len(invDic)):
for l in range(1,len(invDic[i])-1):
#save_image_256(invDic[i][l]["roi_lab"], label,os.path.join(args.savepath, "label{}_{:02d}.mha".format(i,l)), is_lab=False)
for m in range(-1,2):
imgArray = invDic[i][l+m]["roi_img"]
if imgArray.shape!=(256,256):
img = sitk.GetImageFromArray(imgArray)
img = Resampling(img, (256, 256), img.GetSize())
imgArray = sitk.GetArrayFromImage(img)
if m==-1:
stackedArray = imgArray
else:
stackedArray = np.dstack([stackedArray, imgArray])
stackedArray = stackedArray[np.newaxis,...]
print('Shape of input image: {}'.format(stackedArray.shape))
print('segmenting...')
paarry = model.predict(stackedArray, batch_size = args.batchsize, verbose = 0)
print('paarry.shape: {}'.format(paarry.shape))
labelarry = np.argmax(paarry, axis=-1).astype(np.uint8)
labelarry = labelarry.reshape(256,256)
#save_image_256(labelarry, label,os.path.join(args.savepath, "result{}_{:02d}.mha".format(i,l)), is_lab=True)
lab = sitk.GetImageFromArray(labelarry)
lab = Resampling(lab, invDic[i][l]["roi_img"].shape[::-1], lab.GetSize())
labelarry = sitk.GetArrayFromImage(lab)
print('labelarry.shape: {}'.format(labelarry.shape))
invDic[i][l]["roi_lab"] = labelarry
##invDic[i][l]["roi_lab"]<-segmented image
###########################Inverse#############################################
icheck = False
for i in range(len(invDic)):
scheck = False
for l in range(len(invDic[i])):
#save_image_256(invDic[i][l]["roi_lab"], label,os.path.join(args.savepath, "result{}_{:02d}.mha".format(i,l)), is_lab=True)
iImg = inverse_image(invDic[i][l]["roi_lab"],
invDic[i][l]["cutKidFragLabel"],
invDic[i][l]["wh"], invDic[i][l]["center"], invDic[i][l]["angle"],
invDic[i][l]["labelArray"], i)
##高さ方向にstack
if not scheck:
scheck = True
inversedImg = iImg
else:
inversedImg = np.dstack([inversedImg, iImg])
print("inversed",inversedImg.shape)
if i==0:
icheck = True
iImage = copy.copy(inversedImage)
inversedImage[:,:,cutIndex[i][0]:cutIndex[i][-1]+1] = inversedImg
else:
iImage[:,:,cutIndex[i][0]:cutIndex[i][-1]+1] = inversedImg
inversedImage = inversedImage+iImage
LF = sitk.GetImageFromArray(inversedImage)
LF.SetOrigin(label.GetOrigin())
LF.SetSpacing(label.GetSpacing())
LF.SetDirection(label.GetDirection())
print('saving segmented label to {}...'.format(savepath), end='', flush=True)
sitk.WriteImage(LF, savepath, True)
def main(args):
# Read image
labelPath = Path(args.imagePath) / (args.prefix + "segmentation.nii.gz")
imagePath = Path(args.imagePath) / (args.prefix + "imaging.nii.gz")
print("Reading {}...".format(str(labelPath)))
print("Reading {}...".format(str(imagePath)))
img = sitk.ReadImage(str(imagePath))
imageArray = sitk.GetArrayFromImage(img)
label = sitk.ReadImage(str(labelPath))
labelArray = sitk.GetArrayFromImage(label)
# Find a border dividing the kidney into a separate space
startIdx, endIdx = searchBound(labelArray, 'sagittal')
print("startIndex : ", startIdx)
print("endIndex : ", endIdx)
# Divide the kidney into leftArray and rightArray
leftArray = np.copy(labelArray[ : startIdx[1] - 1, :, :])
rightArray = np.copy(labelArray[endIdx[0] + 1 : , :, :])
print('leftArray shapes : ', leftArray.shape)
print('rightArray shapes : ', rightArray.shape)
leftImgArray = np.copy(imageArray[ : startIdx[1] - 1,:,:])
rightImgArray = np.copy(imageArray[endIdx[0] + 1 : , :, :])
arrayDict = {"left" : np.array([np.copy(leftArray), np.copy(leftImgArray)]), "right" : np.array([np.copy(rightArray), np.copy(rightImgArray)])}
del imageArray, labelArray, leftArray, leftImgArray, rightArray, rightImgArray
gc.collect()
for xxx in ["left", "right"]:
# Input array
inputLabelArray = arrayDict[xxx][0]
inputImageArray = arrayDict[xxx][1]
# Find kidney region
idx = np.where(inputLabelArray > 0)
# Preprocessing for OBB
vertics = np.stack([*idx], axis=-1)
# Implement OBB
obb = OBB.build_from_points(vertics)
# Minimum vertics for defining bounding box per vertex
index = (((0, 1), (0, 3), (0, 5)),
((1, 0), (1, 2), (1, 4)),
((2, 1), (2, 3), (2, 7)),
((3, 0), (3, 2), (3, 6)),
((4, 1), (4, 5), (4, 7)),
((5, 0), (5, 4), (5, 6)),
((6, 3), (6, 5), (6, 7)),
((7, 2,), (7, 4), (7, 6)))
# Find the closest vertex to origin
minVertex = sorted([(x[0]**2 + x[1]**2 + x[2]**2, i) for i, x in enumerate(obb.points)])[0][1]
print("minVertex : ", minVertex)
# Calucualte the length of each side of bouding box and output in decending order
points = getSortedDistance(obb.points, index[minVertex])
#Slide to locate point[0][0] into (0,0,0)
#points = points - points[0][0]
rotationMatrix, rotatedBoundingVertics = makeCompleteMatrix(points)
print("rotatedBoundingVertics")
print(rotatedBoundingVertics.astype(int))
#Measure for rotated coordinates are out of range of inputArray size
slide, affineMatrix = determineSlide(rotatedBoundingVertics, rotationMatrix, inputLabelArray)
# Slide boundingVertics
print("slide : ", slide)
rotatedAndSlidedBoundingVertics = rotatedBoundingVertics + slide
print("rotatedAndSlidedBoundingVertics")
print(rotatedAndSlidedBoundingVertics.astype(int))
origin, clipSize = determineClipSize(rotatedAndSlidedBoundingVertics, inputLabelArray.shape)
print("origin : ", origin)
print("clipSize : ", clipSize)
# For affine transformation, make inverse matrix
invAffine = np.linalg.inv(affineMatrix)
refCoords = makeRefCoords(inputLabelArray, invAffine)
print("redCoords shape : ", refCoords.shape)
print("Rotating image...")
rotatedLabelArray = transformImageArray(inputLabelArray, refCoords, "nearest")
rotatedImageArray = transformImageArray(inputImageArray, refCoords, "linear")
rotatedLabelArray = rotatedLabelArray[origin[0] - 1 : clipSize[0] + 1,
origin[1] - 1 : clipSize[1] + 1,
origin[2] - 1 : clipSize[2] + 1]
rotatedImageArray = rotatedImageArray[origin[0] - 1 : clipSize[0] + 1,
origin[1] - 1 : clipSize[1] + 1,
origin[2] - 1 : clipSize[2] + 1]
pre = np.where(inputLabelArray > 0, True, False).sum()
post = np.where(rotatedLabelArray > 0, True, False).sum()
log = Path(args.log) / "failList.txt"
saveLabelPath = Path(args.savePath) / ("label_" + xxx + "." + args.extension)
saveImagePath = Path(args.savePath) / ("image_" + xxx + "." + args.extension)
createParentPath(saveLabelPath)
# reverse right image
if xxx == "right":
print("It is the right kidney which should be reversed.")
rotatedLabelArray = reverseImage(rotatedLabelArray)
rotatedImageArray = reverseImage(rotatedImageArray)
if 0.99 < post / pre < 1.1:
print("Succeeded in clipping.")
rotatedLabel = sitk.GetImageFromArray(rotatedLabelArray)
rotatedImage = sitk.GetImageFromArray(rotatedImageArray)
saveImage(rotatedLabel, label, str(saveLabelPath))
saveImage(rotatedImage, img, str(saveImagePath))
else:
print("Failed to clip.")
print("Writing failed patient to {}".format(str(log)))
print("Done")
# Match one kidney shape with the other one.
if (Path(args.savePath) / ("label_right." + args.extension)).exists() and (Path(args.savePath) / ("label_left." + args.extension)).exists():
rightLabelPath = Path(args.savePath) / ("label_right." + args.extension)
rightImagePath = Path(args.savePath) / ("image_right." + args.extension)
leftLabelPath = Path(args.savePath) / ("label_left." + args.extension)
leftImagePath = Path(args.savePath) / ("image_left." + args.extension)
rightLabel = sitk.ReadImage(str(rightLabelPath))
rightImage = sitk.ReadImage(str(rightImagePath))
leftLabel = sitk.ReadImage(str(leftLabelPath))
leftImage = sitk.ReadImage(str(leftImagePath))
rightLabelArray = sitk.GetArrayFromImage(rightLabel)
rightImageArray = sitk.GetArrayFromImage(rightImage)
leftLabelArray = sitk.GetArrayFromImage(leftLabel)
leftImageArray = sitk.GetArrayFromImage(leftImage)
rightLabelTransformedArray = Resizing(rightLabelArray, leftLabelArray,"nearest")
rightImageTransformedArray = Resizing(rightImageArray, leftImageArray, "linear")
leftLabelTransformedArray = Resizing(leftLabelArray, rightLabelArray,"nearest")
leftImageTransformedArray = Resizing(leftImageArray, rightImageArray, "linear")
saveRightLabelTransformedPath = Path(args.savePath) / ("label_right_transformed." + args.extension)
saveRightImageTransformedPath = Path(args.savePath) / ("image_right_transformed." + args.extension)
saveLeftLabelTransformedPath = Path(args.savePath) / ("label_left_transformed." + args.extension)
saveLeftImageTransformedPath = Path(args.savePath) / ("image_left_transformed." + args.extension)
rightLabelTransformed = sitk.GetImageFromArray(rightLabelTransformedArray)
rightImageTransformed = sitk.GetImageFromArray(rightImageTransformedArray)
leftLabelTransformed = sitk.GetImageFromArray(leftLabelTransformedArray)
leftImageTransformed = sitk.GetImageFromArray(leftImageTransformedArray)
saveImage(rightLabelTransformed, rightLabel, str(saveRightLabelTransformedPath))
saveImage(rightImageTransformed, rightImage, str(saveRightImageTransformedPath))
saveImage(leftLabelTransformed, leftLabel, str(saveLeftLabelTransformedPath))
saveImage(leftImageTransformed, leftImage, str(saveLeftImageTransformedPath))
def main(args):
use_cuda = torch.cuda.is_available() and True
device = torch.device("cuda" if use_cuda else "cpu")
""" Load model. """
with open(args.modelweightfile, 'rb') as f:
model = cloudpickle.load(f)
model = torch.nn.DataParallel(model, device_ids=args.gpuid)
model.eval()
dataset = UNetDataset([
args.image_path_layer_1, args.image_path_layer_2, args.image_path_thin
],
args.label_path,
criteria={"train": [args.patientID]},
transform=UNetTransform())
segmented_array_list = []
image_array_list, _ = dataset.__getitem__(0)
image_array_list = [
torch.from_numpy(image_array)[None, ...].to(device, dtype=torch.float)
for image_array in image_array_list
]
seg_array = model(*image_array_list).to("cpu").detach().numpy().astype(
np.float)
seg_array = np.squeeze(seg_array)
output_shape = seg_array.shape
with tqdm(total=dataset.__len__(), desc="Segmenting images...",
ncols=60) as pbar:
segmented_array = np.zeros(output_shape, dtype=np.float64)
for i in range(1, dataset.__len__() + 1):
image_array_list, _ = dataset.__getitem__(i - 1)
image_array_list = [
torch.from_numpy(image_array)[None, ...].to(device,
dtype=torch.float)
for image_array in image_array_list
]
seg_array = model(
*image_array_list).to("cpu").detach().numpy().astype(np.float)
seg_array = np.squeeze(seg_array)
if i % args.num_rep == 0:
segmented_array += seg_array
segmented_array = np.argmax(segmented_array,
axis=0).astype(np.uint8)
segmented_array_list.append(segmented_array)
segmented_array = np.zeros(output_shape, dtype=np.float64)
else:
segmented_array += seg_array
pbar.update(1)
img = sitk.ReadImage(args.org_image)
matchobj = re.match("([0-9]+)-([0-9]+)-([0-9]+)", args.patch_size)
if matchobj is None:
print("[ERROR] Invalid patch size : {}".format(args.patch_size))
patch_size = np.array([int(s) for s in matchobj.groups()])
matchobj = re.match("([0-9]+)-([0-9]+)", args.plane_size)
if matchobj is None:
print("[ERROR] Invalid patch size : {}".format(args.plane_size))
plane_size = np.array([int(s) for s in matchobj.groups()])
lpc = LabelPatchCreater(label=img,
patch_size=patch_size,
plane_size=plane_size,
overlap=args.overlap,
num_rep=args.num_rep)
lpc.execute()
segmented = lpc.restore(segmented_array_list)
createParentPath(args.save_path)
sitk.WriteImage(segmented, args.save_path, True)
def main(args):
print(args.alpha)
labelFile = Path(args.originalFilePath) / 'segmentation.nii.gz'
imageFile = Path(args.originalFilePath) / 'imaging.nii.gz'
## Read image
label = sitk.ReadImage(str(labelFile))
image = sitk.ReadImage(str(imageFile))
labelArray = sitk.GetArrayFromImage(label)
imageArray = sitk.GetArrayFromImage(image)
meta = {}
meta["Spacing"] = label.GetSpacing()[1:3]
meta["Origin"] = label.GetOrigin()[1:3]
meta["Direction"] = label.GetDirection()[3:5] + label.GetDirection()[6:8]
print("Whole size: ", labelArray.shape)
totalNumber = len(labelArray[:, 0, :0])
#################腎臓の数を特定, １ブロックにつき１つになるように3Dのまま、最大範囲切り取る##########################
kidIndex = [] #特定された腎臓のインデックス群[[1つ目],[2つ目],...]
kidFragment = [] #分けた3腎臓のインデックス群の保存先
k = [] #一時的保持
for x in range(totalNumber - 1):
if np.where(labelArray[x, :, :] != 0, True, False).any() and np.where(
labelArray[x + 1, :, :] != 0, True, False).any():
k.append(x)
elif np.where(labelArray[x, :, :] != 0, True,
False).any() and not (np.where(
labelArray[x + 1, :, :] != 0, True, False).any()):
k.append(x)
kidIndex.append(copy.copy(k))
k.clear()
if len(kidIndex) != 2:
print("The patient has horse shoe kidney.")
print(args.savelabelpath.rsplit(os.sep)[-1] + " failed.")
#write_file("exceptPatient.txt", args.savelabelpath.rsplit(os.sep)[-1])
sys.exit()
cutKidFragLabel = [] #[[1つ目の腎臓の行列],[2つ目の腎臓の行列],..]
cutKidFragImage = []
skip_cnt = 0
check1 = 0
check2 = 0
for i, kidFrag in enumerate(kidIndex):
roi_label = []
roi_image = []
IndexFirst = kidFrag[0]
IndexFinal = kidFrag[-1]
if IndexFirst < len(labelArray[:, 0, 0]) / 2:
kidFragment.append(
np.arange(IndexFinal + 1, len(labelArray[:, 0, 0])))
check1 += 1
else:
kidFragment.append(np.arange(IndexFirst))
check2 += 1
#分けた腎臓の行列を保存
if kidFragment[i][0] == kidFragment[i][-1]:
skip_cnt -= 1
continue
else:
cutKidFragLabel.append(
labelArray[kidFragment[i][0]:kidFragment[i][-1] + 1, :, :])
cutKidFragImage.append(
imageArray[kidFragment[i][0]:kidFragment[i][-1] + 1, :, :])
i = i + skip_cnt
#一つの腎臓を反転
if i == 1:
cutKidFragLabel[1] = cutKidFragLabel[1][::-1, :, :]
cutKidFragImage[1] = cutKidFragImage[1][::-1, :, :]
#############################################################################################
#axial方向について、３D画像として切り取る
cutKidFragLabel[i], cutKidFragImage[i], _, _ = cut3D(
cutKidFragLabel[i], cutKidFragImage[i], "axial")
print("cutted size_" + str(i) + ": ", cutKidFragLabel[i].shape)
##最大サイズの腎臓を持つスライスの特定
mArea = []
for ckfl in range(len(cutKidFragLabel[i][0, 0, :])):
mArea.append(caluculate_area(cutKidFragLabel[i][:, :, ckfl]))
maxArea = np.argmax(mArea)
#最大サイズのスライスの幅、高さの計算
roi, maxCenter, maxwh, maxAngle = cut_image(
cutKidFragLabel[i][:, :, maxArea])
roi, center, wh, angle = cut_image(cutKidFragImage[i][:, :, maxArea],
center=maxCenter,
wh=maxwh,
angle=maxAngle)
rmaxwh = list(maxwh)
rmaxwh = rmaxwh[::-1]
rmaxwh = tuple(rmaxwh) #調整
imgArrayList = []
ctMax = -10**9
ctMin = 10**9
for ckfl in range(len(cutKidFragLabel[i][0, 0, :])):
a = caluculate_area(cutKidFragLabel[i][:, :, ckfl])
##腎臓のない領域の画像保存
if a == 0:
x0 = maxCenter[1] - int((maxwh[1] + 15) / 2)
x1 = maxCenter[1] + int((maxwh[1] + 15) / 2)
y0 = maxCenter[0] - int((maxwh[0] + 15) / 2)
y1 = maxCenter[0] + int((maxwh[0] + 15) / 2)
if x0 < 0:
x0 = 0
if y0 < 0:
y0 = 0
roi_label = cutKidFragLabel[i][x0:x1, y0:y1, ckfl]
roi_image = cutKidFragImage[i][x0:x1, y0:y1, ckfl]
##腎臓領域ありの時
else:
roi, center, wh, angle = cut_image(cutKidFragLabel[i][:, :,
ckfl])
if (maxwh[0] > maxwh[1]) == (wh[0] > wh[1]):
roi, center, wh, angle = cut_image(
cutKidFragLabel[i][:, :, ckfl], wh=maxwh) ##中心,角度取得
roi_label = roi
else:
roi, center, wh, angle = cut_image(
cutKidFragLabel[i][:, :, ckfl], wh=rmaxwh) ##中心,角度取得
roi_label = roi
roi, center, wh, angle = cut_image(cutKidFragImage[i][:, :,
ckfl],
center=center,
wh=wh,
angle=angle)
roi_image = roi
#ヒストグラム平坦化
roi_image = np.array(roi_image, dtype=np.int64)
if roi_image.max() > ctMax:
ctMax = roi_image.max()
if roi_image.min() < ctMin:
ctMin = roi_image.min()
imgArrayList.append(roi_image)
##1枚1枚ヒストグラム平坦化
#roi_image = np.array(roi_image, dtype=np.uint8)
#roi_image = cv2.equalizeHist(roi_image)
patientID = args.originalFilePath.split('/')[-1]
OPL = Path(args.savePath
) / 'label' / patientID / "label{}_{:02d}.mha".format(
i, ckfl)
OPI = Path(args.savePath
) / 'image' / patientID / "image{}_{:02d}.mha".format(
i, ckfl)
OPT = Path(args.savePath) / 'path' / (patientID + '.txt')
#Make parent path
if not OPI.parent.exists():
createParentPath(str(OPI))
if not OPL.parent.exists():
createParentPath(str(OPL))
if not OPT.parent.exists():
createParentPath(str(OPT))
save_image_256(roi_label, label, str(OPL), is_lab=True)
#save_image_256(roi_image, image, OPI)
write_file(str(OPT), str(OPL) + "\t" + str(OPI))
print(ctMax, ctMin)
equalizedImageArrayList = equalizingHistogram(imgArrayList, args.alpha)
for x, equalizedImageArray in enumerate(equalizedImageArrayList):
OPI = Path(args.savePath
) / 'image' / patientID / "image{}_{:02d}.mha".format(
i, x)
save_image_256(equalizedImageArray, image, str(OPI))
##分けられているかどうかの確認
if check1 == check2:
print("Succeeded in cutting.")
print(args.originalFilePath.split('/')[-1] + " done.\n")
else:
print("Failed to cutting.")
def main(args):
#Change!!!!##############################################
labelFile = Path(args.originalFilePath) / 'segmentation.nii.gz'
imageFile = Path(args.originalFilePath) / 'imaging.nii.gz'
#args.labelfile -> labelFile##########################
#args.imageFile -> imageFile#########################
## Read image
label = sitk.ReadImage(str(labelFile))
image = sitk.ReadImage(str(imageFile))
##########################################################
##################################################
# For resampling, get direction, spacing, origin in 2D
extractSliceFilter = sitk.ExtractImageFilter()
size = list(image.GetSize())
size[0] = 0
index = (0, 0, 0)
extractSliceFilter.SetSize(size)
extractSliceFilter.SetIndex(index)
sliceImage = extractSliceFilter.Execute(image)
if image.GetNumberOfComponentsPerPixel() == 1:
minmax = sitk.MinimumMaximumImageFilter()
minmax.Execute(image)
imageMinval = minmax.GetMinimum()
else:
imageMinval = None
if label.GetNumberOfComponentsPerPixel() == 1:
minmax = sitk.MinimumMaximumImageFilter()
minmax.Execute(label)
labelMinval = minmax.GetMinimum()
else:
labelMinval = None
##################################################
labelArray = sitk.GetArrayFromImage(label)
imageArray = sitk.GetArrayFromImage(image)
print("Whole size: ", labelArray.shape)
totalNumber = len(labelArray[:, 0, :0])
#################腎臓の数を特定, １ブロックにつき１つになるように3Dのまま、最大範囲切り取る##########################
kidIndex = [] #特定された腎臓のインデックス群[[1つ目],[2つ目],...]
kidFragment = [] #分けた3腎臓のインデックス群の保存先
k = [] #一時的保持
for x in range(totalNumber - 1):
if np.where(labelArray[x, :, :] != 0, True, False).any() and np.where(
labelArray[x + 1, :, :] != 0, True, False).any():
k.append(x)
elif np.where(labelArray[x, :, :] != 0, True,
False).any() and not (np.where(
labelArray[x + 1, :, :] != 0, True, False).any()):
k.append(x)
kidIndex.append(copy.copy(k))
k.clear()
if len(kidIndex) != 2:
print("The patient has horse shoe kidney.")
#Change!###################################################################
#print(args.savelabelpath.rsplit(os.sep)[-1]+" failed.")
#write_file("exceptPatient.txt", args.savelabelpath.rsplit(os.sep)[-1])
############################################################################
sys.exit()
cutKidFragLabel = [] #[[1つ目の腎臓の行列],[2つ目の腎臓の行列],..]
cutKidFragImage = []
skip_cnt = 0
check1 = 0
check2 = 0
for i, kidFrag in enumerate(kidIndex):
roi_label = []
roi_image = []
IndexFirst = kidFrag[0]
IndexFinal = kidFrag[-1]
if IndexFirst < len(labelArray[:, 0, 0]) / 2:
kidFragment.append(
np.arange(IndexFinal + 1, len(labelArray[:, 0, 0])))
check1 += 1
else:
kidFragment.append(np.arange(IndexFirst))
check2 += 1
#分けた腎臓の行列を保存
if kidFragment[i][0] == kidFragment[i][-1]:
skip_cnt -= 1
continue
else:
cutKidFragLabel.append(
labelArray[kidFragment[i][0]:kidFragment[i][-1] + 1, :, :])
cutKidFragImage.append(
imageArray[kidFragment[i][0]:kidFragment[i][-1] + 1, :, :])
i = i + skip_cnt
#一つの腎臓を反転
if i == 1:
cutKidFragLabel[1] = cutKidFragLabel[1][::-1, :, :]
cutKidFragImage[1] = cutKidFragImage[1][::-1, :, :]
#############################################################################################
#axial方向について、３D画像として切り取る
cutKidFragLabel[i], cutKidFragImage[i], cutIndex, snum = cut3D(
cutKidFragLabel[i], cutKidFragImage[i], "axial")
print("cutted size_" + str(i) + ": ", cutKidFragLabel[i].shape)
##最大サイズの腎臓を持つスライスの特定
mArea = []
for ckfl in range(len(cutKidFragLabel[i][0, 0, :])):
mArea.append(caluculate_area(cutKidFragLabel[i][:, :, ckfl]))
maxArea = np.argmax(mArea)
#最大サイズのスライスの幅、高さの計算
roi, maxCenter, maxwh, maxAngle = cut_image(
cutKidFragLabel[i][:, :, maxArea])
roi, center, wh, angle = cut_image(cutKidFragImage[i][:, :, maxArea],
center=maxCenter,
wh=maxwh,
angle=maxAngle)
rmaxwh = list(maxwh)
rmaxwh = rmaxwh[::-1]
rmaxwh = tuple(rmaxwh) #調整
noKidImg = 0
for ckfl in range(len(cutKidFragLabel[i][0, 0, :])):
a = caluculate_area(cutKidFragLabel[i][:, :, ckfl])
##腎臓のない領域の画像保存
if a == 0:
x0 = maxCenter[1] - int((maxwh[1] + 15) / 2)
x1 = maxCenter[1] + int((maxwh[1] + 15) / 2)
y0 = maxCenter[0] - int((maxwh[0] + 15) / 2)
y1 = maxCenter[0] + int((maxwh[0] + 15) / 2)
if x0 < 0:
x0 = 0
if y0 < 0:
y0 = 0
roi_label = cutKidFragLabel[i][x0:x1, y0:y1, ckfl]
roi_image = cutKidFragImage[i][x0:x1, y0:y1, ckfl]
##腎臓領域ありの時
else:
roi, center, wh, angle = cut_image(cutKidFragLabel[i][:, :,
ckfl])
if (maxwh[0] > maxwh[1]) == (wh[0] > wh[1]):
roi, center, wh, angle = cut_image(
cutKidFragLabel[i][:, :, ckfl], wh=maxwh) ##中心,角度取得
roi_label = roi
else:
roi, center, wh, angle = cut_image(
cutKidFragLabel[i][:, :, ckfl], wh=rmaxwh) ##中心,角度取得
roi_label = roi
roi, center, wh, angle = cut_image(cutKidFragImage[i][:, :,
ckfl],
center=center,
wh=wh,
angle=angle)
roi_image = roi
#Change!!!!###########################################################
patientID = args.originalFilePath.split('/')[-1]
OPL = Path(args.savePath
) / 'label' / patientID / "label{}_{:02d}.mha".format(
i, ckfl)
OPI = Path(args.savePath
) / 'image' / patientID / "image{}_{:02d}.mha".format(
i, ckfl)
OPT = Path(args.savePath) / 'path' / (patientID + '.txt')
#Make parent path
if not OPI.parent.exists():
createParentPath(str(OPI))
if not OPL.parent.exists():
createParentPath(str(OPL))
if not OPT.parent.exists():
createParentPath(str(OPT))
roiLabel = sitk.GetImageFromArray(roi_label)
roiImage = sitk.GetImageFromArray(roi_image)
originalSpacing = sliceImage.GetSpacing()
originalSize = roiLabel.GetSize()
roiLabel.SetSpacing(originalSpacing)
roiImage.SetSpacing(originalSpacing)
roiLabel.SetOrigin(sliceImage.GetOrigin())
roiImage.SetOrigin(sliceImage.GetOrigin())
roiLabel.SetDirection(sliceImage.GetDirection())
roiImage.SetDirection(sliceImage.GetDirection())
newSize = (256, 256)
newSpacing = [
originalSize[0] * originalSpacing[0] / newSize[0],
originalSize[1] * originalSpacing[1] / newSize[1]
]
imageResampler = sitk.ResampleImageFilter()
if imageMinval is not None:
imageResampler.SetDefaultPixelValue(imageMinval)
imageResampler.SetOutputSpacing(newSpacing)
imageResampler.SetOutputOrigin(sliceImage.GetOrigin())
imageResampler.SetOutputDirection(sliceImage.GetDirection())
imageResampler.SetSize(newSize)
roiImage = imageResampler.Execute(roiImage)
labelResampler = sitk.ResampleImageFilter()
if labelMinval is not None:
labelResampler.SetDefaultPixelValue(labelMinval)
labelResampler.SetOutputSpacing(newSpacing)
labelResampler.SetOutputOrigin(sliceImage.GetOrigin())
labelResampler.SetOutputDirection(sliceImage.GetDirection())
labelResampler.SetSize(newSize)
labelResampler.SetInterpolator(sitk.sitkNearestNeighbor)
roiLabel = labelResampler.Execute(roiLabel)
sitk.WriteImage(roiImage, str(OPI), True)
sitk.WriteImage(roiLabel, str(OPL), True)
write_file(str(OPT), str(OPL) + "\t" + str(OPI))
#########################################################################
##分けられているかどうかの確認
if check1 == check2:
print("Succeeded in cutting.")
print(args.originalFilePath.split('/')[-1] + " done.\n")
else:
print("Failed to cutting.")
def main(args):
sys.path.append("..")
use_cuda = torch.cuda.is_available() and True
device = torch.device("cuda" if use_cuda else "cpu")
""" Slice module. """
image = sitk.ReadImage(args.image_path)
if args.mask_path is not None:
mask = sitk.ReadImage(args.mask_path)
else:
mask = None
""" Dummy image """
label = sitk.Image(image.GetSize(), sitk.sitkInt8)
label.SetOrigin(image.GetOrigin())
label.SetDirection(image.GetDirection())
label.SetSpacing(image.GetSpacing())
""" Get the patch size from string."""
matchobj = re.match("([0-9]+)-([0-9]+)-([0-9]+)", args.image_patch_size)
if matchobj is None:
print("[ERROR] Invalid patch size : {}.".fotmat(args.image_patch_size))
sys.exit()
image_patch_size = [int(s) for s in matchobj.groups()]
""" Get the patch size from string."""
matchobj = re.match("([0-9]+)-([0-9]+)-([0-9]+)", args.label_patch_size)
if matchobj is None:
print("[ERROR] Invalid patch size : {}.".fotmat(args.label_patch_size))
sys.exit()
label_patch_size = [int(s) for s in matchobj.groups()]
iace = ImageAndCoordinateExtractor(image=image,
label=label,
mask=mask,
image_array_patch_size=image_patch_size,
label_array_patch_size=label_patch_size,
overlap=args.overlap,
integrate=True)
iace.execute()
image_array_list, _ = iace.output()
""" Load model. """
with open(args.modelweightfile, 'rb') as f:
model = cloudpickle.load(f)
model = torch.nn.DataParallel(model, device_ids=args.gpuid)
model.eval()
""" Segmentation module. """
segmented_array_list = []
for image_array in tqdm(image_array_list,
desc="Segmenting images...",
ncols=60):
#image_array = image_array.transpose(2, 0, 1)
while image_array.ndim < 5:
image_array = image_array[np.newaxis, ...]
image_array = torch.from_numpy(image_array).to(device,
dtype=torch.float)
segmented_array = model(image_array)
segmented_array = segmented_array.to("cpu").detach().numpy().astype(
np.float)
segmented_array = np.squeeze(segmented_array)
segmented_array = np.argmax(segmented_array, axis=0).astype(np.uint8)
#segmented_array = segmented_array.transpose(1, 2, 0)
segmented_array_list.append(segmented_array)
""" Restore module. """
segmented = iace.restore(segmented_array_list)
createParentPath(args.save_path)
print("Saving image to {}".format(args.save_path))
sitk.WriteImage(segmented, args.save_path, True)
def main(args):
path = Path(args.filePath)
leftImagePath = path / "image_left.nii.gz"
rightImagePath = path / "image_right.nii.gz"
leftImage = sitk.ReadImage(str(leftImagePath))
rightImage = sitk.ReadImage(str(rightImagePath))
leftImageArray = sitk.GetArrayFromImage(leftImage)
rightImageArray = sitk.GetArrayFromImage(rightImage)
leftLabelPath = path / "label_left.nii.gz"
rightLabelPath = path / "label_right.nii.gz"
leftLabel = sitk.ReadImage(str(leftLabelPath))
rightLabel = sitk.ReadImage(str(rightLabelPath))
leftLabelArray = sitk.GetArrayFromImage(leftLabel)
rightLabelArray = sitk.GetArrayFromImage(rightLabel)
length = leftImageArray.shape[2]
imagePath = []
labelPath = []
for x in range(length):
leftImageSlice = leftImageArray[:,:,x]
rightImageSlice = rightImageArray[:,:,x]
savePath = Path(args.savePath)
leftImageSavePath = savePath / ("left/image_" + str(x).zfill(3) + ".mha")
rightImageSavePath = savePath / ("right/image_" + str(x).zfill(3) + ".mha")
createParentPath(leftImageSavePath)
createParentPath(rightImageSavePath)
leftLabelSlice = leftLabelArray[:,:,x]
rightLabelSlice = rightLabelArray[:,:,x]
leftLabelSavePath = savePath / ("left/label_" + str(x).zfill(3) + ".mha")
rightLabelSavePath = savePath / ("right/label_" + str(x).zfill(3) + ".mha")
sitk.WriteImage(sitk.GetImageFromArray(leftImageSlice), "test/test_{}.mha".format(x), True)
save_image_256(leftImageSlice, leftImage, str(leftImageSavePath))
save_image_256(rightImageSlice, rightImage, str(rightImageSavePath))
save_image_256(leftLabelSlice, leftLabel, str(leftLabelSavePath), is_lab=True)
save_image_256(rightLabelSlice, rightLabel, str(rightLabelSavePath), is_lab=True)
imagePath.append(leftImageSavePath)
imagePath.append(rightImageSavePath)
labelPath.append(leftLabelSavePath)
labelPath.append(rightLabelSavePath)
textSavePath = savePath.parent / "path" / (path.name + ".txt")
createParentPath(textSavePath)
imagePath = sorted(imagePath)
labelPath = sorted(labelPath)
print(len(imagePath), len(labelPath))
for x, y in zip(imagePath, labelPath):
write_file(textSavePath, str(x) + "\t" + str(y))
def main(_):
""" Slice module. """
labelFile = Path(args.imageDirectory) / "segmentation.nii.gz"
imageFile = Path(args.imageDirectory) / "imaging.nii.gz"
label = sitk.ReadImage(str(labelFile))
image = sitk.ReadImage(str(imageFile))
slicer = sler(image,
label,
outputImageSize=args.outputImageSize,
widthSize=args.widthSize,
paddingSize=args.paddingSize,
noFlip=args.noFlip)
slicer.execute()
_, cuttedImageArrayList = slicer.output("Array")
""" Segmentation module. """
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
config.log_device_placement = True
sess = tf.compat.v1.Session(config=config)
tf.compat.v1.keras.backend.set_session(sess)
modelweightfile = os.path.expanduser(args.modelweightfile)
with tf.device('/device:GPU:{}'.format(args.gpuid)):
print('loading U-net model {}...'.format(modelweightfile),
end='',
flush=True)
#with open(args.modelfile) as f:
# model = tf.compat.v1.keras.models.model_from_yaml(f.read())
# model.load_weights(args.modelweightfile)
model = tf.compat.v1.keras.models.load_model(modelweightfile,
custom_objects={
'penalty_categorical':
penalty_categorical,
'kidney_dice':
kidney_dice,
'cancer_dice':
cancer_dice
})
print('done')
segmentedArrayList = [[] for _ in range(2)]
for i in range(2):
length = len(cuttedImageArrayList[i])
for x in tqdm(range(length), desc="Segmenting images...", ncols=60):
imageArray = cuttedImageArrayList[i][x]
imageArray = imageArray[np.newaxis, ...]
segmentedArray = model.predict(imageArray,
batch_size=args.batchsize,
verbose=0)
segmentedArray = np.squeeze(segmentedArray)
segmentedArray = np.argmax(segmentedArray,
axis=-1).astype(np.uint8)
print((segmentedArray > 0).any())
segmentedArrayList[i].append(segmentedArray)
""" Restore module. """
segmentedArray = slicer.restore(segmentedArrayList)
segmented = getImageWithMeta(segmentedArray, label)
createParentPath(args.savePath)
print("Saving image to {}".format(args.savePath))
sitk.WriteImage(segmented, args.savePath, True)
def main(args):
use_cuda = torch.cuda.is_available() and True
device = torch.device("cuda" if use_cuda else "cpu")
""" Slice module. """
labelFile = Path(args.imageDirectory) / "segmentation.nii.gz"
imageFile = Path(args.imageDirectory) / "imaging.nii.gz"
label = sitk.ReadImage(str(labelFile))
image = sitk.ReadImage(str(imageFile))
""" Get the patch size from string."""
matchobj = re.match("([0-9]+)-([0-9]+)-([0-9]+)", args.patch_size)
if matchobj is None:
print("[ERROR] Invalid patch size : {}.".fotmat(args.patch_size))
sys.exit()
patch_size = [int(s) for s in matchobj.groups()]
""" Get the slide size from string."""
if args.slide is not None:
matchobj = re.match("([0-9]+)-([0-9]+)-([0-9]+)", args.slide)
if matchobj is None:
print("[ERROR] Invalid patch size : {}.".fotmat(args.slide))
sys.exit()
slide = [int(s) for s in matchobj.groups()]
else:
slide = None
""" Get the padding size from string."""
if args.padding is not None:
matchobj = re.match("([0-9]+)-([0-9]+)-([0-9]+)", args.padding)
if matchobj is None:
print("[ERROR] Invalid patch size : {}.".fotmat(args.padding))
sys.exit()
padding = [int(s) for s in matchobj.groups()]
else:
padding = None
extractor = extor(image=image,
label=label,
patch_size=patch_size,
slide=slide,
padding=padding)
extractor.execute()
image_array_list, l = extractor.output("Array")
""" Load model. """
with open(args.modelweightfile, 'rb') as f:
model = cloudpickle.load(f)
model = torch.nn.DataParallel(model, device_ids=args.gpuid)
model.eval()
""" Segmentation module. """
segmented_array_list = []
cnt = 0
for image_array in tqdm(image_array_list,
desc="Segmenting images...",
ncols=60):
image_array = image_array.transpose(2, 0, 1)
image_array = torch.from_numpy(image_array[np.newaxis,
...]).to(device,
dtype=torch.float)
segmented_array = model(image_array)
segmented_array = segmented_array.to("cpu").detach().numpy().astype(
np.float)
segmented_array = np.squeeze(segmented_array)
segmented_array = np.argmax(segmented_array, axis=0).astype(np.uint8)
segmented_array_list.append(segmented_array)
""" Restore module. """
segmented = extractor.restore(segmented_array_list)
createParentPath(args.savePath)
print("Saving image to {}".format(args.savePath))
sitk.WriteImage(segmented, args.savePath, True)
def main(args):
path = Path(args.imagePath)
imagePath = path / (args.prefix + 'imaging.nii.gz')
labelPath = path / (args.prefix + 'segmentation.nii.gz')
image = sitk.ReadImage(str(imagePath))
label = sitk.ReadImage(str(labelPath))
print(label.GetSize())
imageArray = sitk.GetArrayFromImage(image)
labelArray = sitk.GetArrayFromImage(label)
startIdx, endIdx = searchBound(labelArray, 'sagittal')
startIdx, endIdx = adjustDiff(startIdx, endIdx, labelArray.shape[0])
startIdx -= args.expansion
endIdx += args.expansion
clipLabelArray = {
"left": labelArray[startIdx[0]:endIdx[0] + 1, ...],
"right": labelArray[startIdx[1]:endIdx[1] + 1, ...]
}
clipImageArray = {
"left": imageArray[startIdx[0]:endIdx[0] + 1, ...],
"right": imageArray[startIdx[1]:endIdx[1] + 1, ...]
}
print("Clipping images in sagittal direction...")
print("Left Kidney clipped size : {}".format(clipLabelArray["left"].shape))
print("Right Kidney clipped size : {}".format(
clipLabelArray["right"].shape))
startIdx, endIdx = searchBoundAndMakeIndex(clipLabelArray, "axial")
startIdx, endIdx = adjustDiff(startIdx, endIdx, labelArray.shape[2])
startIdx -= args.expansion
endIdx += args.expansion
clipLabelArray = {
"left": clipLabelArray["left"][..., startIdx[0]:endIdx[0] + 1],
"right": clipLabelArray["right"][..., startIdx[1]:endIdx[1] + 1]
}
clipImageArray = {
"left": clipImageArray["left"][..., startIdx[0]:endIdx[0] + 1],
"right": clipImageArray["right"][..., startIdx[1]:endIdx[1] + 1]
}
print("Clipping images in axial direction...")
print("Left Kidney clipped size : {}".format(clipLabelArray["left"].shape))
print("Right Kidney clipped size : {}".format(
clipLabelArray["right"].shape))
startIdx, endIdx = searchBoundAndMakeIndex(clipLabelArray, "coronal")
startIdx, endIdx = adjustDiff(startIdx, endIdx, labelArray.shape[1])
startIdx -= args.expansion
endIdx += args.expansion
clipLabelArray = {
"left": clipLabelArray["left"][:, startIdx[0]:endIdx[0] + 1, :],
"right": clipLabelArray["right"][:, startIdx[1]:endIdx[1] + 1, :]
}
clipImageArray = {
"left": clipImageArray["left"][:, startIdx[0]:endIdx[0] + 1, :],
"right": clipImageArray["right"][:, startIdx[1]:endIdx[1] + 1, :]
}
print("Clipping images in coronal direction...")
print("Left Kidney clipped size : {}".format(clipLabelArray["left"].shape))
print("Right Kidney clipped size : {}".format(
clipLabelArray["right"].shape))
if not args.noReverse:
clipLabelArray["right"] = clipLabelArray["right"][::-1, ...]
clipImageArray["right"] = clipImageArray["right"][::-1, ...]
if not args.nonBlack:
leftIdx = np.where(clipLabelArray["left"] > 0, True, False)
clipImageArray["left"] = np.where(leftIdx, clipImageArray["left"],
-1024)
rightIdx = np.where(clipLabelArray["right"] > 0, True, False)
clipImageArray["right"] = np.where(rightIdx, clipImageArray["right"],
-1024)
clipLabelArray["left"] = sitk.GetImageFromArray(clipLabelArray["left"])
clipLabelArray["right"] = sitk.GetImageFromArray(clipLabelArray["right"])
clipImageArray["left"] = sitk.GetImageFromArray(clipImageArray["left"])
clipImageArray["right"] = sitk.GetImageFromArray(clipImageArray["right"])
savePath = Path(args.savePath)
leftLabelPath = savePath / "label_left.nii.gz"
leftImagePath = savePath / "image_left.nii.gz"
rightLabelPath = savePath / "label_right.nii.gz"
rightImagePath = savePath / "image_right.nii.gz"
createParentPath(leftLabelPath)
saveImage(clipLabelArray["left"], label, str(leftLabelPath))
saveImage(clipLabelArray["right"], label, str(rightLabelPath))
saveImage(clipImageArray["left"], label, str(leftImagePath))
saveImage(clipImageArray["right"], label, str(rightImagePath))
def main(_):
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
#config.log_device_placement = True
sess = tf.compat.v1.Session(config=config)
tf.compat.v1.keras.backend.set_session(sess)
modelweightfile = os.path.expanduser(args.modelweightfile)
with tf.device('/device:GPU:{}'.format(args.gpuid)):
print('loading U-net model {}...'.format(modelweightfile), end='', flush=True)
# with open(args.modelfile) as f:
# model = tf.compat.v1.keras.models.model_from_yaml(f.read())
# model.load_weights(args.modelweightfile)
model = tf.compat.v1.keras.models.load_model(modelweightfile,
custom_objects={'penalty_categorical' : penalty_categorical, 'kidney_dice':kidney_dice, 'cancer_dice':cancer_dice})
print('done')
savePath = os.path.expanduser(args.savepath)
createParentPath(savePath)
imagefile = os.path.expanduser(args.imagefile)
## Read image
image = sitk.ReadImage(imagefile)
imageArray = sitk.GetArrayFromImage(image)
print("Whole size: ",imageArray.shape)
originalShape = imageArray.shape
resizedImageArray, axis = sliceImage(imageArray, interpolation="linear")
segmentedArray = []
if axis == 0:
length = originalShape[0]
zero = np.zeros((256, 256)) - 1024.
for x in range(length):
if x == 0:
imageArray3ch = np.dstack([zero, resizedImageArray[x, :, :], resizedImageArray[x + 1, :, :]])
elif x == (length - 1):
imageArray3ch = np.dstack([resizedImageArray[x - 1, :, :], resizedImageArray[x, :, :], zero])
else:
imageArray3ch = np.dstack([resizedImageArray[x - 1, :, :], resizedImageArray[x, :, :], resizedImageArray[x + 1, :, :]])
imageArray3ch = imageArray3ch[np.newaxis,...]
print('Shape of input shape: {}'.format(imageArray3ch.shape))
print('segmenting...')
segArray = model.predict(imageArray3ch, batch_size=args.batchsize, verbose=0)
segArray = np.argmax(segArray, axis=-1).astype(np.uint8)
segArray = segArray.reshape(256, 256)
segmentedArray.append(segArray)
segmentedArray = np.stack(segmentedArray, axis=axis)
dummyArray = np.zeros(originalShape)
segmentedArray = Resizing(segmentedArray, dummyArray, interpolation="nearest")
print('SegmentedArray shape : {}'.format(segmentedArray.shape))
segmented = sitk.GetImageFromArray(segmentedArray)
saveImage(segmented, image, savePath)
if axis == 1:
length = originalShape[1]
zero = np.zeros((256, 256)) - 1024.
for x in range(length):
if x == 0:
imageArray3ch = np.dstack([zero, resizedImageArray[:, x, :], resizedImageArray[:, x + 1, :]])
elif x == (length - 1):
imageArray3ch = np.dstack([resizedImageArray[:, x - 1, :], resizedImageArray[:, x, :], zero])
else:
imageArray3ch = np.dstack([resizedImageArray[:, x - 1, :], resizedImageArray[:, x, :], resizedImageArray[:, x + 1, :]])
def main(args):
print('Loading npy file...')
npyFile = os.path.expanduser(args.npyFile)
HIST = np.load(npyFile)
print('Loading it has done. ')
aHIST = HIST * args.alpha + (1 - args.alpha) / 2048
#Make CDF
cdf = aHIST.cumsum()
cdf_m = np.ma.masked_equal(cdf,0)
temp = (cdf_m - cdf_m.min())/(cdf_m.max()-cdf_m.min())
cdf_m = 2048*temp
cdf = np.ma.filled(cdf_m,0).astype('int64')
print('Making CDF has done.' )
#Read iamge and equalizing histogram
for x in range(args.number):
sx = str(x).zfill(3)
if sx in ignore:
continue
#Make CT and segmentation path
slicePath = os.path.expanduser(args.slicePath)
pI = Path(slicePath) / ('image/case_00' + sx)
pL = Path(slicePath) / ('label/case_00' + sx)
if not pI.exists():
print(str(pI), "dose not exit.")
sys.exit()
if not pL.exists():
print(str(pL), "does not exit.")
sys.exit()
#pI = list(pI.iterdir()).sort()
for i,l in zip(sorted(pI.iterdir()), sorted(pL.iterdir())):
#savePath
savePath = os.path.expanduser(args.savePath)
OPI = Path(savePath) / "image" / ('case_00' + sx) / i.name
OPL = Path(savePath) / "label" / ('case_00' + sx) / l.name
OPT = Path(savePath) / "path" / ("case_00" + sx + ".txt")
#Make parent path
if not OPI.parent.exists():
createParentPath(str(OPI))
if not OPL.parent.exists():
createParentPath(str(OPL))
if not OPT.parent.exists():
createParentPath(str(OPT))
#print(str(OPL) + "\t" + str(OPI))
ctImg = sitk.ReadImage(str(i))
ctImgArray = sitk.GetArrayFromImage(ctImg)
ctImgArray = ctImgArray + 1024
ctImgArray = np.clip(ctImgArray, 0, 2048)
#Equalizing histogram
ctImgArray = cdf[ctImgArray] - 1024
#Save ct image
ctImgNew = sitk.GetImageFromArray(ctImgArray)
ctImgNew.SetOrigin(ctImg.GetOrigin())
ctImgNew.SetSpacing(ctImg.GetSpacing())
ctImgNew.SetDirection(ctImg.GetDirection())
sitk.WriteImage(ctImgNew, str(OPI))
#Save label image
labImg = sitk.ReadImage(str(l))
sitk.WriteImage(labImg, str(OPL), True)
#Save textfile
write_file(str(OPT), str(OPL) + "\t" + str(OPI))
print("case_00" + sx + "done. ")
def main(_):
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
#config.log_device_placement = True
sess = tf.compat.v1.Session(config=config)
tf.compat.v1.keras.backend.set_session(sess)
modelweightfile = os.path.expanduser(args.modelweightfile)
with tf.device('/device:GPU:{}'.format(args.gpuid)):
print('loading U-net model {}...'.format(modelweightfile),
end='',
flush=True)
# with open(args.modelfile) as f:
# model = tf.compat.v1.keras.models.model_from_yaml(f.read())
# model.load_weights(args.modelweightfile)
model = tf.compat.v1.keras.models.load_model(modelweightfile,
custom_objects={
'penalty_categorical':
penalty_categorical,
'kidney_dice':
kidney_dice,
'cancer_dice':
cancer_dice
})
print('done')
savePath = os.path.expanduser(args.savepath)
createParentPath(savePath)
imagefile = os.path.expanduser(args.imagefile)
## Read image
image = sitk.ReadImage(imagefile)
print("Image shape : {}".format(image.GetSize()))
length = image.GetSize()[0]
segmentedSize = [256, 256]
sliceImageArrayList = []
for x in range(length):
sliceImage = ResamplingInAxis(image, x, segmentedSize)
sliceImageArray = sitk.GetArrayFromImage(sliceImage)
sliceImageArrayList.append(sliceImageArray)
zero = np.zeros(segmentedSize) - 1024.
segmentedArrayList = []
for x in range(length):
middle = sliceImageArrayList[x]
if x == 0:
top = zero
bottom = sliceImageArrayList[x + 1]
elif x == (length - 1):
top = sliceImageArrayList[x - 1]
bottom = zero
else:
top = sliceImageArrayList[x - 1]
bottom = sliceImageArrayList[x + 1]
imageArray3ch = np.dstack([top, middle, bottom])
imageArray3ch = imageArray3ch[np.newaxis, ...]
print("Shape og input shape : {}".format(imageArray3ch.shape))
print("Segmenting...")
segmentedArray = model.predict(imageArray3ch,
batch_size=args.batchsize,
verbose=0)
segmentedArray = np.argmax(segmentedArray, axis=-1).astype(np.int8)
segmentedArray = segmentedArray.reshape(*segmentedSize)
segmentedArrayList.append(segmentedArray)
segmentedArray = np.dstack(segmentedArrayList)
segmented = sitk.GetImageFromArray(segmentedArray)
dummy = ResampleSize(image, [length] + segmentedSize)
segmented.SetOrigin(dummy.GetOrigin())
segmented.SetSpacing(dummy.GetSpacing())
segmented.SetDirection(dummy.GetDirection())
segmented = ResampleSize(segmented, image.GetSize(), is_label=True)
print("SegmentedArray shape : {}".format(segmented.GetSize()))
print("Saving image to {}...".format(savePath))
sitk.WriteImage(segmented, savePath, True)
def main(_):
config = tf.compat.v1.ConfigProto(
#allow_soft_placement=True, log_device_placement=True
)
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
sess = tf.compat.v1.Session(config=config)
tf.compat.v1.keras.backend.set_session(sess)
trainingdatafile = os.path.expanduser(args.trainingdatafile)
trainingdatalist = ReadSliceDataList3ch_1ch(trainingdatafile)
print(trainingdatalist[0])
testdatalist = None
if args.testfile is not None:
testfile = os.path.expanduser(args.testfile)
testdatalist = ReadSliceDataList3ch_1ch(testfile)
testdatalist = random.sample(testdatalist, int(len(testdatalist)*0.1))
(imageshape, labelshape) = GetInputShapes(trainingdatalist[0])
nclasses = 3 # Number of classes
print("image shapes: ",imageshape)
print("label shapes: ",labelshape)
with tf.device('/device:GPU:{}'.format(args.gpuid)):
x = tf.keras.layers.Input(shape=imageshape, name="x")
segmentation = ConstructModel(x, nclasses, not args.nobn, not args.nodropout)
model = tf.compat.v1.keras.Model(x, segmentation)
#model = tf.keras.models.Model(x, segmentation)
model.summary()
optimizer = tf.keras.optimizers.Adam(lr=args.learningrate)
model.compile(loss=penalty_categorical, optimizer=optimizer, metrics=[kidney_dice, cancer_dice])
#createParentPath(args.modelfile)
# with open(args.modelfile, 'w') as f:
# f.write(model.to_yaml())
#tf.compat.v1.keras.models.save_model(model, args.modelfile)
if args.weightfile is None:
initial_epoch = 0
createParentPath(args.initialWeightFilePath)
model.save_weights(args.initialWeightFilePath)
else:
model.load_weights(args.weightfile)
initial_epoch = args.initialepoch
logdir = os.path.expanduser(args.logdir)
if args.latestfile is None:
latestfile = logdir + '/latestweights.hdf5'
else:
latestfile = os.path.expanduser(args.latestfile)
#latestfile = args.latestfile
createParentPath(latestfile)
tb_cbk = tf.keras.callbacks.TensorBoard(log_dir=logdir)
latest_cbk = LatestWeightSaver(latestfile)
def step_decay(epoch):
x = 1e-3
if epoch >= 80: x = 1e-4
return x
#lr_decay = tf.keras.callbacks.LearningRateScheduler(step_decay)
callbacks = [tb_cbk, latest_cbk]
#callbacks = [tb_cbk, latest_cbk, lr_decay]
if testdatalist is not None:
if args.bestfile is None:
logdir = os.path.expanduser(args.logdir)
bestfile = logdir + '/bestweights.hdf5'
else:
bestfile = os.path.expanduser(args.bestfile)
#bestfile = args.bestfile
createParentPath(bestfile)
chkp_cbk = tf.keras.callbacks.ModelCheckpoint(filepath=bestfile, save_best_only = True, save_weights_only = False)
callbacks.append(chkp_cbk)
if args.weightinterval is not None:
periodic_cbk = PeriodicWeightSaver(logdir=args.logdir, interval=args.weightinterval)
callbacks.append(periodic_cbk)
steps_per_epoch = len(trainingdatalist) / args.batchsize
print ("Batch size: {}".format(args.batchsize))
print ("Number of Epochs: {}".format(args.epochs))
print ("Number of Steps/epoch: {}".format(steps_per_epoch))
with tf.device('/device:GPU:{}'.format(args.gpuid)):
if not args.noaugmentation:
if testdatalist is not None:
historys = model.fit_generator(ImportBatchArray(trainingdatalist, batch_size = args.batchsize, apply_augmentation = True),
steps_per_epoch = int(steps_per_epoch), epochs = args.epochs,
callbacks=callbacks,
validation_data = ImportBatchArray(testdatalist, batch_size = args.batchsize),
validation_steps = len(testdatalist),
initial_epoch = int(initial_epoch))
else:
historys = model.fit_generator(ImportBatchArray(trainingdatalist, batch_size = args.batchsize, apply_augmentation = True),
steps_per_epoch = int(steps_per_epoch), epochs = args.epochs,
callbacks=callbacks,
initial_epoch = int(initial_epoch))
else:
if testdatalist is not None:
historys = model.fit_generator(ImportBatchArray(trainingdatalist, batch_size = args.batchsize, apply_augmentation = False),
steps_per_epoch = int(steps_per_epoch), epochs = args.epochs,
callbacks=callbacks,
validation_data = ImportBatchArray(testdatalist, batch_size = args.batchsize),
validation_steps = len(testdatalist),
initial_epoch = int(initial_epoch))
else:
historys = model.fit_generator(ImportBatchArray(trainingdatalist, batch_size = args.batchsize, apply_augmentation = False),
steps_per_epoch = int(steps_per_epoch), epochs = args.epochs,
callbacks=callbacks,
initial_epoch = int(initial_epoch))
cancer = historys.history['cancer_dice']
val_cancer = historys.history['val_cancer_dice']
kid = historys.history['kidney_dice']
val_kid = historys.history['val_kidney_dice']
epochs = len(cancer)
if args.history is not None:
historyy = os.path.expanduser(args.history)
createParentPath(historyy)
history_file = open(historyy,"a")
for x in range(epochs):
print("{:.3f}\t{:.3f}\t{:.3f}\t{:.3f}".format(cancer[x],val_cancer[x],kid[x],val_kid[x]),file = history_file)
print("\n",file=history_file)
history_file.close()
def main(_):
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
#config.log_device_placement = True
sess = tf.compat.v1.Session(config=config)
tf.compat.v1.keras.backend.set_session(sess)
modelweightfile = os.path.expanduser(args.modelweightfile)
with tf.device('/device:GPU:{}'.format(args.gpuid)):
print('loading U-net model {}...'.format(modelweightfile),
end='',
flush=True)
# with open(args.modelfile) as f:
# model = tf.compat.v1.keras.models.model_from_yaml(f.read())
# model.load_weights(args.modelweightfile)
model = tf.compat.v1.keras.models.load_model(modelweightfile,
custom_objects={
'penalty_categorical':
penalty_categorical,
'kidney_dice':
kidney_dice,
'cancer_dice':
cancer_dice
})
print('done')
savePath = os.path.expanduser(args.savePath)
createParentPath(savePath)
meta = {}
## Read image
labelFile = Path(args.imageDirectory) / "segmentation.nii.gz"
imageFile = Path(args.imageDirectory) / "imaging.nii.gz"
label = sitk.ReadImage(str(labelFile))
image = sitk.ReadImage(str(imageFile))
labelArray = sitk.GetArrayFromImage(label)
imageArray = sitk.GetArrayFromImage(image)
startIdx, endIdx = searchBound(labelArray, 'sagittal')
startIdx, endIdx = adjustDiff(startIdx, endIdx, labelArray.shape[0])
startIdx -= args.expansion
endIdx += args.expansion
clipLabelArray = {
"left": labelArray[startIdx[0]:endIdx[0] + 1, ...],
"right": labelArray[startIdx[1]:endIdx[1] + 1, ...]
}
clipImageArray = {
"left": imageArray[startIdx[0]:endIdx[0] + 1, ...],
"right": imageArray[startIdx[1]:endIdx[1] + 1, ...]
}
meta["left"] = {"sagittal": [startIdx[0], endIdx[0] + 1]}
meta["right"] = {"sagittal": [startIdx[1], endIdx[1] + 1]}
print("Clipping images in sagittal direction...")
startIdx, endIdx = searchBoundAndMakeIndex(clipLabelArray, "axial")
startIdx, endIdx = adjustDiff(startIdx, endIdx, labelArray.shape[2])
startIdx -= args.expansion
endIdx += args.expansion
clipLabelArray = {
"left": clipLabelArray["left"][..., startIdx[0]:endIdx[0] + 1],
"right": clipLabelArray["right"][..., startIdx[1]:endIdx[1] + 1]
}
clipImageArray = {
"left": clipImageArray["left"][..., startIdx[0]:endIdx[0] + 1],
"right": clipImageArray["right"][..., startIdx[1]:endIdx[1] + 1]
}
meta["left"]["axial"] = [startIdx[0], endIdx[0] + 1]
meta["right"]["axial"] = [startIdx[1], endIdx[1] + 1]
print("Clipping images in axial direction...")
startIdx, endIdx = searchBoundAndMakeIndex(clipLabelArray, "coronal")
startIdx, endIdx = adjustDiff(startIdx, endIdx, labelArray.shape[1])
startIdx -= args.expansion
endIdx += args.expansion
clipLabelArray = {
"left": clipLabelArray["left"][:, startIdx[0]:endIdx[0] + 1, :],
"right": clipLabelArray["right"][:, startIdx[1]:endIdx[1] + 1, :]
}
clipImageArray = {
"left": clipImageArray["left"][:, startIdx[0]:endIdx[0] + 1, :],
"right": clipImageArray["right"][:, startIdx[1]:endIdx[1] + 1, :]
}
meta["left"]["coronal"] = [startIdx[0], endIdx[0] + 1]
meta["left"]["size"] = clipImageArray["left"].shape
meta["right"]["coronal"] = [startIdx[1], endIdx[1] + 1]
meta["right"]["size"] = clipImageArray["right"].shape
print("Clipping images in coronal direction...")
print("Left Kidney clipped size : {}".format(clipLabelArray["left"].shape))
print("Right Kidney clipped size : {}".format(
clipLabelArray["right"].shape))
clipLabelArray["right"] = clipLabelArray["right"][::-1, ...]
clipImageArray["right"] = clipImageArray["right"][::-1, ...]
clipLabelArray["left"] = sitk.GetImageFromArray(clipLabelArray["left"])
clipLabelArray["right"] = sitk.GetImageFromArray(clipLabelArray["right"])
clipImageArray["left"] = sitk.GetImageFromArray(clipImageArray["left"])
clipImageArray["right"] = sitk.GetImageFromArray(clipImageArray["right"])
blackArray = np.zeros_like(labelArray)
for d in ["left", "right"]:
clipImageArray[d].SetDirection(label.GetDirection())
clipImageArray[d].SetOrigin(label.GetOrigin())
clipImageArray[d].SetSpacing(label.GetSpacing())
# clipLabelArray[d].SetDirection(label.GetDirection())
# clipLabelArray[d].SetOrigin(label.GetOrigin())
# clipLabelArray[d].SetSpacing(label.GetSpacing())
length = clipImageArray[d].GetSize()[0]
# clipLabelArray[d] = ResampleSize(clipLabelArray[d], (length, 256, 256), is_label=True)
clipImageArray[d] = ResampleSize(clipImageArray[d], (length, 256, 256))
clipImgArray = sitk.GetArrayFromImage(clipImageArray[d])
# clipLabArray = sitk.GetArrayFromImage(clipLabelArray[d])
zero = np.zeros((256, 256)) - 1024.
stackedArrayList = []
for x in range(length):
if x == 0:
top = zero
middle = clipImgArray[..., x]
bottom = clipImgArray[..., x + 1]
elif x == (length - 1):
top = clipImgArray[..., x - 1]
middle = clipImgArray[..., x]
bottom = zero
else:
top = clipImgArray[..., x - 1]
middle = clipImgArray[..., x]
bottom = clipImgArray[..., x + 1]
stackedArray = np.dstack([top, middle, bottom])
stackedArray = stackedArray[np.newaxis, ...]
print('Shape of input image: {}'.format(stackedArray.shape))
print('segmenting...')
paarry = model.predict(stackedArray,
batch_size=args.batchsize,
verbose=0)
print('stackedArray.shape: {}'.format(stackedArray.shape))
labelarry = np.argmax(paarry, axis=-1).astype(np.uint8)
labelarry = labelarry.reshape(256, 256)
# labelarry = clipLabArray[..., x]
stackedArrayList.append(labelarry)
stackedArray = np.dstack(stackedArrayList)
if d == "right":
stackedArray = stackedArray[::-1, ...]
stacked = sitk.GetImageFromArray(stackedArray)
stacked.SetDirection(clipImageArray[d].GetDirection())
stacked.SetOrigin(clipImageArray[d].GetOrigin())
stacked.SetSpacing(clipImageArray[d].GetSpacing())
stacked = ResampleSize(stacked, meta[d]["size"][::-1], is_label=True)
stackedArray = sitk.GetArrayFromImage(stacked)
print(meta)
blackArray[meta[d]["sagittal"][0]:meta[d]["sagittal"][1],
meta[d]["coronal"][0]:meta[d]["coronal"][1],
meta[d]["axial"][0]:meta[d]["axial"][1]] = stackedArray
black = sitk.GetImageFromArray(blackArray)
black.SetDirection(label.GetDirection())
black.SetOrigin(label.GetOrigin())
black.SetSpacing(label.GetSpacing())
sitk.WriteImage(black, savePath, True)
print("Saving image to {}...".format(savePath))
