def main(args):
image = sitk.ReadImage(args.image_path)
if args.mask_path is not None:
mask = sitk.ReadImage(args.mask_path)
else:
mask = None
with open(args.model_path, "rb") as f:
model = cloudpickle.load(f)
image_patch_size = getSizeFromString(args.image_patch_size)
label_patch_size = getSizeFromString(args.label_patch_size)
padding_size_in_model = getSizeFromString(args.padding_size_in_model)
fmc = FeatureMapCreater(image=image,
model=model,
image_patch_size=image_patch_size,
label_patch_size=label_patch_size,
mask=mask,
padding_size_in_model=padding_size_in_model,
is_label=args.is_label)
fmc.execute()
fmc.save(args.save_path)
def main(args):
""" Read image and label. """
label = sitk.ReadImage(args.label_path)
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
""" Get the patch size from string."""
image_patch_size = getSizeFromString(args.image_patch_size)
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,
center=liver_center,
mask=mask,
image_array_patch_size=image_patch_size,
label_array_patch_size=label_patch_size,
overlap=args.overlap,
integrate=True)
iace.execute()
iace.save(args.save_path)
"""
def main(args):
image = sitk.ReadImage(args.image_path)
with open(args.model_path, "rb") as f:
model = cloudpickle.load(f)
model.eval()
if args.mask_path is not None:
mask = sitk.ReadImage(args.mask_path)
else:
mask = None
image_patch_size = getSizeFromString(args.image_patch_size)
label_patch_size = getSizeFromString(args.label_patch_size)
plane_size = getSizeFromString(args.plane_size, digit=2)
fmc = FeatureMapCreater(image=image,
model=model,
mask=mask,
image_patch_size=image_patch_size,
label_patch_size=label_patch_size,
image_patch_width=args.image_patch_width,
label_patch_width=args.label_patch_width,
plane_size=plane_size)
fmc.execute()
fmc.save(args.save_path)
message = args.save_path + " DONE."
sendToLineNotify(message)
def main(args):
plane_size = getSizeFromString(args.plane_size, digit=2)
image = sitk.ReadImage(args.image_path)
label = sitk.ReadImage(args.label_path)
if args.mask_path is not None:
mask = sitk.ReadImage(args.mask_path)
else:
mask = None
tpc = ThinPatchCreater(image=image,
label=label,
image_patch_width=args.image_patch_width,
label_patch_width=args.label_patch_width,
plane_size=plane_size,
overlap=args.overlap,
mask=mask)
tpc.execute()
"""
array_list = tpc.output("Array")
res = tpc.restore(array_list)
print(res.GetDirection(), res.GetOrigin(), res.GetSpacing())
from functions import DICE
dice = DICE(sitk.GetArrayFromImage(image), sitk.GetArrayFromImage(res))
print(dice)
"""
tpc.save(args.save_path)
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):
""" Read image and label. """
label = sitk.ReadImage(args.label_path)
image = sitk.ReadImage(args.image_path)
if args.mask_path is not None:
mask = sitk.ReadImage(args.mask_path)
else:
mask = None
""" Get the patch size from string."""
image_patch_size = getSizeFromString(args.image_patch_size)
label_patch_size = getSizeFromString(args.label_patch_size)
iace = ImageAndCoordinateExtractor(image=image,
label=label,
center=(0, 0, 0),
mask=mask,
image_array_patch_size=image_patch_size,
label_array_patch_size=label_patch_size,
overlap=args.overlap,
integrate=True)
iace.execute()
iace.save(args.save_path)
"""
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(args):
""" Get the patch size etc from string."""
image_patch_size = getSizeFromString(args.image_patch_size)
label_patch_size = getSizeFromString(args.label_patch_size)
image_patch_size_fmc = getSizeFromString(args.image_patch_size_fmc)
label_patch_size_fmc = getSizeFromString(args.label_patch_size_fmc)
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 model for FeatureMapCreater. """
with open(args.modelweightfile_fmc, 'rb') as f:
model_fmc = cloudpickle.load(f)
model_fmc.eval()
""" Get feature maps. """
fmc = FeatureMapCreater(image=image,
model=model_fmc,
image_patch_size=image_patch_size_fmc,
label_patch_size=label_patch_size_fmc,
image_patch_width=args.image_patch_width_fmc,
label_patch_width=args.label_patch_width_fmc,
plane_size=plane_size)
fmc.execute()
feature_map_list = fmc.output()
del fmc
""" Get patches. """
extractor = extor(image=image,
label=dummy,
image_patch_size=image_patch_size,
label_patch_size=label_patch_size)
extractor.execute()
image_array_list = extractor.output()[0]
assert len(image_array_list) == len(feature_map_list)
""" Load model for segmentation. """
with open(args.modelweightfile, 'rb') as f:
model = cloudpickle.load(f)
model.eval()
""" Confirm if GPU is available. """
use_cuda = torch.cuda.is_available() and True
device = torch.device("cuda" if use_cuda else "cpu")
""" Segmentation module. """
segmented_array_list = []
with tqdm(total=len(image_array_list),
desc="Segmenting images...",
ncols=60) as pbar:
for image_array, feature_map in zip(image_array_list,
feature_map_list):
segmented_array = segment(image_array,
feature_map,
model,
device=device)
segmented_array = np.argmax(segmented_array,
axis=0).astype(np.uint8)
segmented_array_list.append(segmented_array)
pbar.update(1)
""" Restore module. """
segmented = extractor.restore(segmented_array_list)
createParentPath(args.save_path)
print("Saving image to {}".format(args.save_path))
sitk.WriteImage(segmented, args.save_path, True)
