def main(args):
# ---------- SETTINGS ----------
nameInputImagesRelPath = 'RawReferResults'
nameInputReferImagesRelPath = 'Images_Full'
nameOutputImagesRelPath = 'RawReferResults_Orig_Full'
nameInputImagesFiles = '*.nii.gz'
nameInputReferImagesFiles = '*.nii.gz'
# prefixPatternInputFiles = 'vol[0-9][0-9]_*'
nameBoundingBoxes = 'found_boundingBoxes_original.npy'
nameOutputImagesFiles = lambda in_name: filenamenoextension(in_name) + '.nii.gz'
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(args.basedir)
BaseDataPath = workDirsManager.getNameBaseDataPath()
InputImagesPath = workDirsManager.getNameExistPath(BaseDataPath, nameInputImagesRelPath)
InputReferImagesPath = workDirsManager.getNameExistPath(BaseDataPath, nameInputReferImagesRelPath)
OutputImagesPath = workDirsManager.getNameNewPath(BaseDataPath, nameOutputImagesRelPath)
listInputImagesFiles = findFilesDirAndCheck(InputImagesPath, nameInputImagesFiles)
listInputReferImagesFiles = findFilesDirAndCheck(InputReferImagesPath, nameInputReferImagesFiles)
dict_bounding_boxes = readDictionary(joinpathnames(BaseDataPath, nameBoundingBoxes))
for i, in_image_file in enumerate(listInputImagesFiles):
print("\nInput: \'%s\'..." % (basename(in_image_file)))
in_referimage_file = findFileWithSamePrefix(basename(in_image_file), listInputReferImagesFiles,
prefix_pattern='vol[0-9][0-9]_')
print("Refer image file: \'%s\'..." % (basename(in_referimage_file)))
bounding_box = dict_bounding_boxes[filenamenoextension(in_referimage_file)]
cropped_image_array = FileReader.getImageArray(in_image_file)
print("Input cropped image size: \'%s\'..." %(str(cropped_image_array.shape)))
# 1 step: invert image
cropped_image_array = FlippingImages.compute(cropped_image_array, axis=0)
# 2 step: extend image
full_image_shape = FileReader.getImageSize(in_referimage_file)
full_image_array = ExtendImages.compute3D(cropped_image_array, bounding_box, full_image_shape)
print("Output full image size: \'%s\'..." % (str(full_image_array.shape)))
out_image_file = joinpathnames(OutputImagesPath, nameOutputImagesFiles(in_image_file))
print("Output: \'%s\', of dims \'%s\'..." %(basename(out_image_file), str(full_image_array.shape)))
FileReader.writeImageArray(out_image_file, full_image_array)
def main(args):
# ---------- SETTINGS ----------
nameInputRelPath = '<input_dir>'
nameOutputRelPath = '<output_dir>'
nameInputFiles = '*.nii.gz'
def nameOutputFiles(in_name):
return in_name.replace('<suffix_ini>', '<suffix_end>')
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(BASEDIR)
BaseDataPath = workDirsManager.getNameBaseDataPath()
InputPath = workDirsManager.getNameExistPath(BaseDataPath,
nameInputRelPath)
OutputPath = workDirsManager.getNameNewPath(BaseDataPath,
nameOutputRelPath)
listInputFiles = findFilesDirAndCheck(InputPath, nameInputFiles)
for i, in_file in enumerate(listInputFiles):
print("\nInput: \'%s\'..." % (basename(in_file)))
in_array = FileReader.getImageArray(in_file)
# ...
# write here the code
# ...
out_array = None
out_file = joinpathnames(OutputPath,
nameOutputFiles(basename(in_file)))
print("Output: \'%s\', of dims \'%s\'..." %
(basename(out_file), str(out_array.shape)))
FileReader.writeImageArray(out_file, out_array)
def main(args):
# ---------- SETTINGS ----------
nameRawImagesRelPath = 'RawImages'
nameComputeMasksRelPath = 'ProbNnetoutMasks'
# Get the file list:
nameImagesFiles = '*.dcm'
nameOutMasksFiles = lambda in_name: filenamenoextension(
in_name) + '_probnnetout.nii.gz'
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(args.basedir)
BaseDataPath = workDirsManager.getNameBaseDataPath()
InputImagesPath = workDirsManager.getNameExistPath(BaseDataPath,
nameRawImagesRelPath)
ComputeMasksPath = workDirsManager.getNameNewPath(BaseDataPath,
nameComputeMasksRelPath)
listImagesFiles = findFilesDir(InputImagesPath, nameImagesFiles)
nbImagesFiles = len(listImagesFiles)
# Retrieve training model
modelConstructor = DICTAVAILNETWORKS3D(IMAGES_DIMS_Z_X_Y, args.model)
modelConstructor.type_padding = 'valid'
if args.size_out_nnet == None:
args.size_out_nnet = modelConstructor.get_size_output_full_Unet()
print(
"For input images of size: %s; Output of Neural Networks_Keras are images of size: %s..."
% (IMAGES_DIMS_Z_X_Y, args.size_out_nnet))
for images_file in listImagesFiles:
print('\'%s\'...' % (images_file))
images_array = FileReader.getImageArray(images_file)
if (args.invertImageAxial):
images_array = FlippingImages.compute(images_array, axis=0)
print("Compute masks proportion output...")
if (args.slidingWindowImages):
images_reconstructor = SlidingWindowReconstructorImages3D(
IMAGES_DIMS_Z_X_Y,
images_array.shape,
args.prop_overlap_Z_X_Y,
size_outUnet_sample=args.size_out_nnet)
else:
images_reconstructor = SlidingWindowReconstructorImages3D(
IMAGES_DIMS_Z_X_Y,
images_array.shape, (0.0, 0.0, 0.0),
size_outUnet_sample=args.size_out_nnet)
masks_probValidConvNnet_output_array = images_reconstructor.get_filtering_map_array(
)
out_masksFilename = joinpathnames(ComputeMasksPath,
nameOutMasksFiles(images_file))
FileReader.writeImageArray(out_masksFilename,
masks_probValidConvNnet_output_array)
def main(args):
# ---------- SETTINGS ----------
nameInputImagesRelPath = 'Images_Full'
nameInputGroundTruthRelPath = 'Airways_DistTrans_Full'
nameInputRoiMasksRelPath = 'Airways_DilatedMasks_Full'
nameOutputImagesRelPath = 'Images_WorkData_2'
nameOutputGroundTruthRelPath = 'LumenDistTransClipped_WorkData'
nameInputImagesFiles = '*.nii.gz'
nameInputGroundTruthFiles = '*dist_clipdila_normal_power2.nii.gz'
nameInputRoiMasksFiles = '*_dilated10.nii.gz'
nameRescaleFactors = 'rescaleFactors_images.npy'
nameCropBoundingBoxes = 'cropBoundingBoxes_images.npy'
nameOutputImageFiles = 'images-%0.2i_dim%s' + getFileExtension(
FORMATTRAINDATA)
nameOutputGroundTruthFiles = 'grndtru-%0.2i_dim%s' + getFileExtension(
FORMATTRAINDATA)
if (args.saveVisualizeProcData):
nameVisualOutputRelPath = 'VisualizeWorkData'
nameOutputVisualFiles = lambda filename: basename(filename).replace(
'.npz', '.nii.gz')
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(args.basedir)
BaseDataPath = workDirsManager.getNameBaseDataPath()
InputImagesPath = workDirsManager.getNameExistPath(BaseDataPath,
nameInputImagesRelPath)
InputGroundTruthPath = workDirsManager.getNameExistPath(
BaseDataPath, nameInputGroundTruthRelPath)
OutputImagesPath = workDirsManager.getNameNewPath(BaseDataPath,
nameOutputImagesRelPath)
OutputGroundTruthPath = workDirsManager.getNameNewPath(
BaseDataPath, nameOutputGroundTruthRelPath)
if (args.saveVisualizeProcData):
VisualOutputPath = workDirsManager.getNameNewPath(
BaseDataPath, nameVisualOutputRelPath)
listInputImagesFiles = findFilesDirAndCheck(InputImagesPath,
nameInputImagesFiles)
listInputGroundTruthFiles = findFilesDirAndCheck(
InputGroundTruthPath, nameInputGroundTruthFiles)
if (len(listInputImagesFiles) != len(listInputGroundTruthFiles)):
message = 'num files in dir 1 \'%s\', not equal to num files in dir 2 \'%i\'...' % (
len(listInputImagesFiles), len(listInputGroundTruthFiles))
CatchErrorException(message)
if (args.masksToRegionInterest):
InputRoiMasksPath = workDirsManager.getNameExistPath(
BaseDataPath, nameInputRoiMasksRelPath)
listInputRoiMaskFiles = findFilesDirAndCheck(InputRoiMasksPath,
nameInputRoiMasksFiles)
if (args.rescaleImages):
dict_rescaleFactors = readDictionary(
joinpathnames(BaseDataPath, nameRescaleFactors))
if (args.cropImages):
dict_cropBoundingBoxes = readDictionary(
joinpathnames(BaseDataPath, nameCropBoundingBoxes))
# START ANALYSIS
# ------------------------------
print("-" * 30)
print("Preprocessing...")
print("-" * 30)
for i, (in_image_file, in_grndtru_file) in enumerate(
zip(listInputImagesFiles, listInputGroundTruthFiles)):
print("\nInput: \'%s\'..." % (basename(in_image_file)))
print("And: \'%s\'..." % (basename(in_grndtru_file)))
(image_array, grndtru_array) = FileReader.get2ImageArraysAndCheck(
in_image_file, in_grndtru_file)
print("Original dims : \'%s\'..." % (str(image_array.shape)))
if (args.isClassificationData):
print("Convert to binary masks (0, 1)...")
grndtru_array = OperationBinaryMasks.process_masks(grndtru_array)
if (args.masksToRegionInterest):
print("Mask input to RoI: lungs...")
in_roimask_file = listInputRoiMaskFiles[i]
print("RoI mask (lungs) file: \'%s\'..." %
(basename(in_roimask_file)))
roimask_array = FileReader.getImageArray(in_roimask_file)
grndtru_array = OperationBinaryMasks.apply_mask_exclude_voxels(
grndtru_array, roimask_array)
if (args.rescaleImages):
rescale_factor = dict_rescaleFactors[filenamenoextension(
in_image_file)]
print("Rescale image with a factor: \'%s\'..." %
(str(rescale_factor)))
image_array = RescaleImages.compute3D(image_array, rescale_factor)
grndtru_array = RescaleImages.compute3D(grndtru_array,
rescale_factor)
print("Final dims: %s..." % (str(image_array.shape)))
if (args.cropImages):
crop_bounding_box = dict_cropBoundingBoxes[filenamenoextension(
in_image_file)]
print("Crop image to bounding-box: \'%s\'..." %
(str(crop_bounding_box)))
image_array = CropImages.compute3D(image_array, crop_bounding_box)
grndtru_array = CropImages.compute3D(grndtru_array,
crop_bounding_box)
print("Final dims: %s..." % (str(image_array.shape)))
# if (args.extendSizeImages):
# print("Extend images to fixed size \'%s\':..." %(str(CROPSIZEBOUNDINGBOX)))
# size_new_image = (image_array.shape[0], CROPSIZEBOUNDINGBOX[0], CROPSIZEBOUNDINGBOX[1])
# backgr_val_images = -1000
# backgr_val_masks = -1 if args.masksToRegionInterest else 0
# bounding_box = dict_bounding_boxes[filenamenoextension(in_image_file)]
#
# image_array = ExtendImages.compute3D(image_array, bounding_box, size_new_image, background_value=backgr_val_images)
# grndtru_array = ExtendImages.compute3D(grndtru_array, bounding_box, size_new_image, background_value=backgr_val_masks)
# print("Final dims: %s..." % (str(image_array.shape)))
out_image_file = joinpathnames(
OutputImagesPath,
nameOutputImageFiles % (i + 1, tuple2str(image_array.shape)))
out_grndtru_file = joinpathnames(
OutputGroundTruthPath, nameOutputGroundTruthFiles %
(i + 1, tuple2str(grndtru_array.shape)))
print("Output: \'%s\', of dims \'%s\'..." % (basename(out_image_file),
(image_array.shape)))
print("And: \'%s\', of dims \'%s\'..." %
(basename(out_grndtru_file), str(grndtru_array.shape)))
FileReader.writeImageArray(out_image_file, image_array)
FileReader.writeImageArray(out_grndtru_file, grndtru_array)
if (args.saveVisualizeProcData):
print("Saving working data to visualize...")
out_image_file = joinpathnames(
VisualOutputPath, nameOutputVisualFiles(out_image_file))
out_grndtru_file = joinpathnames(
VisualOutputPath, nameOutputVisualFiles(out_grndtru_file))
FileReader.writeImageArray(out_image_file, image_array)
FileReader.writeImageArray(out_grndtru_file, grndtru_array)
def main(args):
# ---------- SETTINGS ----------
nameInputImagesRelPath = 'ProcImagesExperData'
nameInputMasksRelPath = 'ProcMasksExperData'
nameVisualImagesRelPath = 'VisualInputData'
# Get the file list:
nameInImagesFiles = '*.npy'
nameInMasksFiles = '*.npy'
nameOutImagesFiles_type1 = 'visualImages-%0.2i_dim%s.nii.gz'
nameOutMasksFiles_type1 = 'visualMasks-%0.2i_dim%s.nii.gz'
nameOutImagesFiles_type2 = 'visualImages-%0.2i_dim%s-batch%0.2i.nii.gz'
nameOutMasksFiles_type2 = 'visualMasks-%0.2i_dim%s-batch%0.2i.nii.gz'
nameOutImagesFiles_type3 = 'visualImages-%0.2i_dim%s-batch%s.nii.gz'
nameOutMasksFiles_type3 = 'visualMasks-%0.2i_dim%s-batch%s.nii.gz'
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(args.basedir)
BaseDataPath = workDirsManager.getNameBaseDataPath()
InputImagesPath = workDirsManager.getNameExistPath(BaseDataPath,
nameInputImagesRelPath)
InputMasksPath = workDirsManager.getNameExistPath(BaseDataPath,
nameInputMasksRelPath)
VisualImagesPath = workDirsManager.getNameNewPath(args.basedir,
nameVisualImagesRelPath)
listImagesFiles = findFilesDir(InputImagesPath, nameInImagesFiles)
listMasksFiles = findFilesDir(InputMasksPath, nameInMasksFiles)
nbImagesFiles = len(listImagesFiles)
nbMasksFiles = len(listMasksFiles)
# Run checkers
if (nbImagesFiles == 0):
message = "0 Images found in dir \'%s\'" % (InputImagesPath)
CatchErrorException(message)
if (nbImagesFiles != nbMasksFiles):
message = "num CTs Images %i not equal to num Masks %i" % (
nbImagesFiles, nbMasksFiles)
CatchErrorException(message)
for i, (images_file,
masks_file) in enumerate(zip(listImagesFiles, listMasksFiles)):
print('\'%s\'...' % (images_file))
print('\'%s\'...' % (masks_file))
images_array = FileReader.getImageArray(images_file)
masks_array = FileReader.getImageArray(masks_file)
if (images_array.shape != masks_array.shape):
message = "size of Images and Masks not equal: %s != %s" % (
images_array.shape, masks_array.shape)
CatchErrorException(message)
print("Original image of size: %s..." % (str(images_array.shape)))
if (args.createImagesBatches):
shape_batches = images_array.shape[1:]
print(
"Input images data stored as batches of size %s. Visualize batches..."
% (str(shape_batches)))
images_generator = getImagesVolumeTransformator3D(
images_array, args.transformationImages,
args.elasticDeformationImages)
(visual_images_array,
visual_masks_array) = images_generator.get_images_array(
images_array, masks_array=masks_array)
for j, (batch_images_array, batch_masks_array) in enumerate(
zip(visual_images_array, visual_masks_array)):
out_images_filename = joinpathnames(
VisualImagesPath, nameOutImagesFiles_type2 %
(i + 1, tuple2str(visual_images_array.shape[1:]), j + 1))
out_masks_filename = joinpathnames(
VisualImagesPath, nameOutMasksFiles_type2 %
(i + 1, tuple2str(visual_masks_array.shape[1:]), j + 1))
FileReader.writeImageArray(out_images_filename,
batch_images_array)
FileReader.writeImageArray(out_masks_filename,
batch_masks_array)
# endfor
else:
if (args.visualProcDataInBatches):
print(
"Input images data stored as volume. Generate batches of size %s. Visualize batches..."
% (str(IMAGES_DIMS_Z_X_Y)))
images_generator = getImagesDataGenerator3D(
args.slidingWindowImages, args.prop_overlap_Z_X_Y,
args.transformationImages, args.elasticDeformationImages)
batch_data_generator = BatchDataGenerator_2Arrays(
IMAGES_DIMS_Z_X_Y,
images_array,
masks_array,
images_generator,
size_batch=1,
shuffle=False)
num_batches_total = len(batch_data_generator)
print(
"Generate total %s batches by sliding-window, with coordinates:..."
% (num_batches_total))
for j in range(num_batches_total):
coords_sliding_window_box = images_generator.slidingWindow_generator.get_limits_image(
j)
(visual_images_array,
visual_masks_array) = next(batch_data_generator)
visual_images_array = np.squeeze(visual_images_array,
axis=0)
visual_masks_array = np.squeeze(visual_masks_array, axis=0)
out_images_filename = joinpathnames(
VisualImagesPath, nameOutImagesFiles_type3 %
(i + 1, tuple2str(visual_images_array.shape),
tuple2str(coords_sliding_window_box)))
out_masks_filename = joinpathnames(
VisualImagesPath, nameOutMasksFiles_type3 %
(i + 1, tuple2str(visual_masks_array.shape),
tuple2str(coords_sliding_window_box)))
FileReader.writeImageArray(out_images_filename,
visual_images_array)
FileReader.writeImageArray(out_masks_filename,
visual_masks_array)
# endfor
else:
print(
"Input images data stored as volume of size %s. Visualize volume..."
% (str(images_array.shape)))
images_generator = getImagesVolumeTransformator3D(
images_array.shape, args.transformationImages,
args.elasticDeformationImages)
(visual_images_array,
visual_masks_array) = images_generator.get_images_array(
images_array, masks_array=masks_array)
out_images_filename = joinpathnames(
VisualImagesPath, nameOutImagesFiles_type1 %
(i + 1, tuple2str(visual_images_array.shape)))
out_masks_filename = joinpathnames(
VisualImagesPath, nameOutMasksFiles_type1 %
(i + 1, tuple2str(visual_masks_array.shape)))
FileReader.writeImageArray(out_images_filename,
visual_images_array)
FileReader.writeImageArray(out_masks_filename,
visual_masks_array)
def main(args):
# ---------- SETTINGS ----------
nameInputPredictionsRelPath = args.predictionsdir
nameInputReferMasksRelPath = 'Airways_Full'
nameInputRoiMasksRelPath = 'Lungs_Full'
nameInputCentrelinesRelPath = 'Centrelines_Full'
nameOutputPredictionsRelPath = nameInputPredictionsRelPath
nameInputPredictionsFiles = 'predict-probmaps_*.nii.gz'
nameInputReferMasksFiles = '*_lumen.nii.gz'
nameInputRoiMasksFiles = '*_lungs.nii.gz'
nameInputCentrelinesFiles = '*_centrelines.nii.gz'
# prefixPatternInputFiles = 'av[0-9][0-9]*'
if (args.calcMasksThresholding):
suffixPostProcessThreshold = '_thres%s' % (str(
args.thresholdValue).replace('.', '-'))
if (args.attachTracheaToCalcMasks):
suffixPostProcessThreshold += '_withtrachea'
else:
suffixPostProcessThreshold += '_notrachea'
else:
suffixPostProcessThreshold = ''
nameAccuracyPredictFiles = 'predict_accuracy_tests%s.txt' % (
suffixPostProcessThreshold)
def nameOutputFiles(in_name, in_acc):
out_name = filenamenoextension(in_name).replace(
'predict-probmaps',
'predict-binmasks') + '_acc%2.0f' % (np.round(100 * in_acc))
return out_name + '%s.nii.gz' % (suffixPostProcessThreshold)
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(args.basedir)
BaseDataPath = workDirsManager.getNameBaseDataPath()
InputPredictionsPath = workDirsManager.getNameExistPath(
args.basedir, nameInputPredictionsRelPath)
InputReferenceMasksPath = workDirsManager.getNameExistPath(
BaseDataPath, nameInputReferMasksRelPath)
OutputPredictionsPath = workDirsManager.getNameNewPath(
args.basedir, nameOutputPredictionsRelPath)
listInputPredictionsFiles = findFilesDirAndCheck(
InputPredictionsPath, nameInputPredictionsFiles)
listInputReferenceMasksFiles = findFilesDirAndCheck(
InputReferenceMasksPath, nameInputReferMasksFiles)
if (args.masksToRegionInterest):
InputRoiMasksPath = workDirsManager.getNameExistPath(
BaseDataPath, nameInputRoiMasksRelPath)
listInputRoiMasksFiles = findFilesDirAndCheck(InputRoiMasksPath,
nameInputRoiMasksFiles)
if (args.attachTracheaToCalcMasks):
def compute_trachea_masks(refermask_array, roimask_array):
return np.where(roimask_array == 1, 0, refermask_array)
listPostProcessMetrics = OrderedDict()
list_isUseCenlineFiles = []
for imetrics in args.listPostprocessMetrics:
listPostProcessMetrics[imetrics] = DICTAVAILMETRICFUNS(
imetrics).compute_np_safememory
list_isUseCenlineFiles.append(
DICTAVAILMETRICFUNS(imetrics)._is_cenline_grndtru)
#endfor
isuse_centreline_files = any(list_isUseCenlineFiles)
if isuse_centreline_files:
InputCentrelinesPath = workDirsManager.getNameExistPath(
BaseDataPath, nameInputCentrelinesRelPath)
listInputCentrelinesFiles = findFilesDirAndCheck(
InputCentrelinesPath, nameInputCentrelinesFiles)
out_predictAccuracyFilename = joinpathnames(InputPredictionsPath,
nameAccuracyPredictFiles)
fout = open(out_predictAccuracyFilename, 'w')
strheader = '/case/ ' + ' '.join(
['/%s/' % (key)
for (key, _) in listPostProcessMetrics.iteritems()]) + '\n'
fout.write(strheader)
for i, in_prediction_file in enumerate(listInputPredictionsFiles):
print("\nInput: \'%s\'..." % (basename(in_prediction_file)))
in_refermask_file = findFileWithSamePrefix(
basename(in_prediction_file).replace('predict-probmaps', ''),
listInputReferenceMasksFiles,
prefix_pattern='vol[0-9][0-9]_')
print("Refer mask file: \'%s\'..." % (basename(in_refermask_file)))
prediction_array = FileReader.getImageArray(in_prediction_file)
refermask_array = FileReader.getImageArray(in_refermask_file)
print("Predictions of size: %s..." % (str(prediction_array.shape)))
if (args.calcMasksThresholding):
print(
"Compute prediction masks by thresholding probability maps to value %s..."
% (args.thresholdValue))
prediction_array = ThresholdImages.compute(prediction_array,
args.thresholdValue)
if isuse_centreline_files:
in_centreline_file = findFileWithSamePrefix(
basename(in_prediction_file).replace('predict-probmaps', ''),
listInputCentrelinesFiles,
prefix_pattern='vol[0-9][0-9]_')
print("Centrelines file: \'%s\'..." %
(basename(in_centreline_file)))
centrelines_array = FileReader.getImageArray(in_centreline_file)
if (args.masksToRegionInterest):
in_roimask_file = findFileWithSamePrefix(
basename(in_prediction_file).replace('predict-probmaps', ''),
listInputRoiMasksFiles,
prefix_pattern='vol[0-9][0-9]_')
print("RoI mask (lungs) file: \'%s\'..." %
(basename(in_roimask_file)))
roimask_array = FileReader.getImageArray(in_roimask_file)
if (args.attachTracheaToCalcMasks):
print("Attach trachea mask to computed prediction masks...")
trachea_masks_array = compute_trachea_masks(
refermask_array, roimask_array)
prediction_array = OperationBinaryMasks.join_two_binmasks_one_image(
prediction_array, trachea_masks_array)
else:
prediction_array = OperationBinaryMasks.apply_mask_exclude_voxels_fillzero(
prediction_array, roimask_array)
refermask_array = OperationBinaryMasks.apply_mask_exclude_voxels_fillzero(
refermask_array, roimask_array)
if isuse_centreline_files:
centrelines_array = OperationBinaryMasks.apply_mask_exclude_voxels_fillzero(
centrelines_array, roimask_array)
# ---------- COMPUTE POST PROCESSING MEASURES ----------
list_postprocess_measures = OrderedDict()
for i, (key, value) in enumerate(listPostProcessMetrics.iteritems()):
if list_isUseCenlineFiles[i]:
acc_value = value(centrelines_array, prediction_array)
else:
acc_value = value(refermask_array, prediction_array)
list_postprocess_measures[key] = acc_value
# endfor
main_postprocess_accuracy = list_postprocess_measures.values()[0]
# print list accuracies on screen and in file
prefix_casename = getSubstringPatternFilename(
basename(in_prediction_file), substr_pattern='vol[0-9][0-9]_')[:-1]
strdata = '\'%s\'' % (prefix_casename)
for (key, value) in list_postprocess_measures.iteritems():
print("Metric \'%s\': %s..." % (key, value))
strdata += ' %s' % (str(value))
#endfor
strdata += '\n'
fout.write(strdata)
# ---------- COMPUTE POST PROCESSING MEASURES ----------
out_file = joinpathnames(
OutputPredictionsPath,
nameOutputFiles(basename(in_prediction_file),
main_postprocess_accuracy))
print("Output: \'%s\', of dims \'%s\'..." %
(basename(out_file), str(prediction_array.shape)))
FileReader.writeImageArray(out_file, prediction_array)
#endfor
#close list accuracies file
fout.close()
def main(args):
# ---------- SETTINGS ----------
nameOrigImagesDataRelPath = 'Images_WorkData'
nameOrigMasksDataRelPath = 'LumenDistTrans_WorkData'
nameOriginImagesFiles = 'images*' + getFileExtension(FORMATTRAINDATA)
nameOriginMasksFiles = 'grndtru*' + getFileExtension(FORMATTRAINDATA)
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(args.basedir)
OrigImagesDataPath = workDirsManager.getNameExistPath(
workDirsManager.getNameBaseDataPath(), nameOrigImagesDataRelPath)
OrigGroundTruthDataPath = workDirsManager.getNameExistPath(
workDirsManager.getNameBaseDataPath(), nameOrigMasksDataRelPath)
TrainingDataPath = workDirsManager.getNameNewPath(
workDirsManager.getNameTrainingDataPath())
ValidationDataPath = workDirsManager.getNameNewPath(
workDirsManager.getNameValidationDataPath())
TestingDataPath = workDirsManager.getNameNewPath(
workDirsManager.getNameTestingDataPath())
listImagesFiles = findFilesDir(OrigImagesDataPath, nameOriginImagesFiles)
listGroundTruthFiles = findFilesDir(OrigGroundTruthDataPath,
nameOriginMasksFiles)
numImagesFiles = len(listImagesFiles)
numGroundTruthFiles = len(listGroundTruthFiles)
if (numImagesFiles != numGroundTruthFiles):
message = "num image files \'%s\' not equal to num ground-truth files \'%s\'..." % (
numImagesFiles, numGroundTruthFiles)
CatchErrorException(message)
if (args.distribute_fixed_names):
print("Split dataset with Fixed Names...")
names_repeated = find_element_repeated_two_indexes_names(
NAME_IMAGES_TRAINING, NAME_IMAGES_VALIDATION)
names_repeated += find_element_repeated_two_indexes_names(
NAME_IMAGES_TRAINING, NAME_IMAGES_TESTING)
names_repeated += find_element_repeated_two_indexes_names(
NAME_IMAGES_VALIDATION, NAME_IMAGES_TESTING)
if names_repeated:
message = "found names repeated in list Training / Validation / Testing names: %s" % (
names_repeated)
CatchErrorException(message)
indexesTraining = find_indexes_names_images_files(
NAME_IMAGES_TRAINING, listImagesFiles)
indexesValidation = find_indexes_names_images_files(
NAME_IMAGES_VALIDATION, listImagesFiles)
indexesTesting = find_indexes_names_images_files(
NAME_IMAGES_TESTING, listImagesFiles)
print(
"Training (%s files)/ Validation (%s files)/ Testing (%s files)..."
% (len(indexesTraining), len(indexesValidation),
len(indexesTesting)))
else:
numTrainingFiles = int(args.prop_data_training * numImagesFiles)
numValidationFiles = int(args.prop_data_validation * numImagesFiles)
numTestingFiles = int(args.prop_data_testing * numImagesFiles)
print(
"Training (%s files)/ Validation (%s files)/ Testing (%s files)..."
% (numTrainingFiles, numValidationFiles, numTestingFiles))
if (args.distribute_random):
print("Split dataset Randomly...")
indexesAllFiles = np.random.choice(range(numImagesFiles),
size=numImagesFiles,
replace=False)
else:
print("Split dataset In Order...")
indexesAllFiles = range(numImagesFiles)
indexesTraining = indexesAllFiles[0:numTrainingFiles]
indexesValidation = indexesAllFiles[numTrainingFiles:numTrainingFiles +
numValidationFiles]
indexesTesting = indexesAllFiles[numTrainingFiles +
numValidationFiles::]
print("Files assigned to Training Data: \'%s\'" %
([basename(listImagesFiles[index]) for index in indexesTraining]))
print("Files assigned to Validation Data: \'%s\'" %
([basename(listImagesFiles[index]) for index in indexesValidation]))
print("Files assigned to Testing Data: \'%s\'" %
([basename(listImagesFiles[index]) for index in indexesTesting]))
# ******************** TRAINING DATA ********************
for index in indexesTraining:
makelink(
listImagesFiles[index],
joinpathnames(TrainingDataPath, basename(listImagesFiles[index])))
makelink(
listGroundTruthFiles[index],
joinpathnames(TrainingDataPath,
basename(listGroundTruthFiles[index])))
#endfor
# ******************** TRAINING DATA ********************
# ******************** VALIDATION DATA ********************
for index in indexesValidation:
makelink(
listImagesFiles[index],
joinpathnames(ValidationDataPath,
basename(listImagesFiles[index])))
makelink(
listGroundTruthFiles[index],
joinpathnames(ValidationDataPath,
basename(listGroundTruthFiles[index])))
#endfor
# ******************** VALIDATION DATA ********************
# ******************** TESTING DATA ********************
for index in indexesTesting:
makelink(
listImagesFiles[index],
joinpathnames(TestingDataPath, basename(listImagesFiles[index])))
makelink(
listGroundTruthFiles[index],
joinpathnames(TestingDataPath,
basename(listGroundTruthFiles[index])))
def main(args):
# ---------- SETTINGS ----------
nameInputImagesRelPath = 'RawAirways'
nameInputRoiMasksRelPath = 'RawLungs'
nameReferenceImgRelPath = 'RawImages'
nameOutputImagesRelPath = 'Airways_Rescaled_0.6x0.6x0.6_Full'
nameOutputRoiMasksRelPath = 'Lungs_Rescaled_0.6x0.6x0.6_Full'
nameInputImagesFiles = '*surface0.dcm'
nameInputRoiMasksFiles = '*.dcm'
nameReferenceImgFiles = '*.dcm'
# prefixPatternInputFiles = 'av[0-9][0-9]*'
nameRescaleFactors = 'rescaleFactors_images_0.6x0.6x0.6.npy'
def nameOutputImagesFiles(in_name):
in_name = in_name.replace('surface0', 'lumen')
in_name = in_name.replace('surface1', 'outwall')
#in_name = in_name.replace('-result','_noopfront')
#in_name = in_name.replace('-centrelines','_centrelines')
return filenamenoextension(in_name) + '.nii.gz'
nameOutputRoiMasksFiles = lambda in_name: filenamenoextension(
in_name).replace('-lungs', '_lungs') + '.nii.gz'
nameOutputImagesMaskedToRoiFiles = lambda in_name: filenamenoextension(
nameOutputImagesFiles(in_name)) + '_maskedToLungs.nii.gz'
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(args.basedir)
BaseDataPath = workDirsManager.getNameBaseDataPath()
InputImagesPath = workDirsManager.getNameExistPath(BaseDataPath,
nameInputImagesRelPath)
ReferenceImgPath = workDirsManager.getNameExistPath(
BaseDataPath, nameReferenceImgRelPath)
OutputImagesPath = workDirsManager.getNameNewPath(BaseDataPath,
nameOutputImagesRelPath)
listInputImagesFiles = findFilesDirAndCheck(InputImagesPath,
nameInputImagesFiles)
listReferenceImgFiles = findFilesDirAndCheck(ReferenceImgPath,
nameReferenceImgFiles)
if (args.masksToRegionInterest):
InputRoiMasksPath = workDirsManager.getNameExistPath(
BaseDataPath, nameInputRoiMasksRelPath)
OutputRoiMasksPath = workDirsManager.getNameNewPath(
BaseDataPath, nameOutputRoiMasksRelPath)
listInputRoiMasksFiles = findFilesDirAndCheck(InputRoiMasksPath,
nameInputRoiMasksFiles)
if (args.rescaleImages):
dict_rescaleFactors = readDictionary(
joinpathnames(BaseDataPath, nameRescaleFactors))
for i, in_image_file in enumerate(listInputImagesFiles):
print("\nInput: \'%s\'..." % (basename(in_image_file)))
image_array = FileReader.getImageArray(in_image_file)
if (args.isClassificationData):
print("Convert to binary masks (0, 1)...")
image_array = OperationBinaryMasks.process_masks(image_array)
if (args.masksToRegionInterest):
print("Mask input to RoI: lungs...")
in_roimask_file = findFileWithSamePrefix(basename(in_image_file),
listInputRoiMasksFiles)
print("RoI mask (lungs) file: \'%s\'..." %
(basename(in_roimask_file)))
roimask_array = FileReader.getImageArray(in_roimask_file)
if (args.isClassificationData):
print("Convert to binary masks (0, 1)...")
roimask_array = OperationBinaryMasks.process_masks(
roimask_array)
# Image masked to RoI: exclude voxels not contained in lungs
image_maskedToRoi_array = OperationBinaryMasks.apply_mask_exclude_voxels_fillzero(
image_array, roimask_array)
if (args.rescaleImages):
in_referimg_file = findFileWithSamePrefix(basename(in_image_file),
listReferenceImgFiles)
rescale_factor = dict_rescaleFactors[filenamenoextension(
in_referimg_file)]
print("Rescale image with a factor: \'%s\'..." %
(str(rescale_factor)))
image_array = RescaleImages.compute3D(image_array,
rescale_factor,
is_binary_mask=True)
print("Final dims: %s..." % (str(image_array.shape)))
if (args.masksToRegionInterest):
roimask_array = RescaleImages.compute3D(roimask_array,
rescale_factor,
is_binary_mask=True)
image_maskedToRoi_array = RescaleImages.compute3D(
image_maskedToRoi_array,
rescale_factor,
is_binary_mask=True)
out_file = joinpathnames(
OutputImagesPath, nameOutputImagesFiles(basename(in_image_file)))
print("Output: \'%s\', of dims \'%s\'..." %
(basename(out_file), str(image_array.shape)))
FileReader.writeImageArray(out_file, image_array)
if (args.masksToRegionInterest):
out_roimask_file = joinpathnames(
OutputRoiMasksPath,
nameOutputRoiMasksFiles(basename(in_roimask_file)))
out_maskedToRoi_file = joinpathnames(
OutputImagesPath,
nameOutputImagesMaskedToRoiFiles(basename(in_image_file)))
FileReader.writeImageArray(out_roimask_file, roimask_array)
FileReader.writeImageArray(out_maskedToRoi_file,
image_maskedToRoi_array)
def main(args):
# First thing, set session in the selected(s) devices: CPU or GPU
set_session_in_selected_device(use_GPU_device=True,
type_GPU_installed=args.typeGPUinstalled)
# ---------- SETTINGS ----------
nameInputRoiMasksRelPath = 'Lungs_Full'
nameReferenceImgRelPath = 'Images_Full'
# Get the file list:
nameImagesFiles = 'images*' + getFileExtension(FORMATTRAINDATA)
nameGroundTruthFiles = 'grndtru*' + getFileExtension(FORMATTRAINDATA)
nameInputRoiMasksFiles = '*_lungs.nii.gz'
nameReferenceImgFiles = '*.nii.gz'
nameRescaleFactors = 'rescaleFactors_images.npy'
nameCropBoundingBoxes = 'cropBoundingBoxes_images.npy'
nameOutputPredictionFiles = 'predict-probmaps_%s.nii.gz'
if (args.saveFeatMapsLayers):
nameOutputFeatureMapsDirs = 'featureMaps-%s_lay_%s'
nameOutputFeatureMapsFiles = 'featmaps-%s_lay_%s_map%0.2i.nii.gz'
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(args.basedir)
BaseDataPath = workDirsManager.getNameBaseDataPath()
TestingDataPath = workDirsManager.getNameExistPath(
workDirsManager.getNameDataPath(args.typedata))
ReferenceImgPath = workDirsManager.getNameExistPath(
BaseDataPath, nameReferenceImgRelPath)
ModelsPath = workDirsManager.getNameExistPath(args.basedir, args.modelsdir)
OutputPredictionPath = workDirsManager.getNameNewPath(
args.basedir, args.predictionsdir)
listTestImagesFiles = findFilesDir(TestingDataPath, nameImagesFiles)
listTestGroundTruthFiles = findFilesDir(TestingDataPath,
nameGroundTruthFiles)
listReferenceImgsFiles = findFilesDirAndCheck(ReferenceImgPath,
nameReferenceImgFiles)
if (args.masksToRegionInterest):
InputRoiMasksPath = workDirsManager.getNameExistPath(
BaseDataPath, nameInputRoiMasksRelPath)
listInputRoiMasksFiles = findFilesDirAndCheck(InputRoiMasksPath,
nameInputRoiMasksFiles)
if (args.rescaleImages):
dict_rescaleFactors = readDictionary(
joinpathnames(BaseDataPath, nameRescaleFactors))
if (args.cropImages):
dict_cropBoundingBoxes = readDictionary(
joinpathnames(BaseDataPath, nameCropBoundingBoxes))
test_images_generator = getImagesDataGenerator3D(
args.slidingWindowImages, args.prop_overlap_Z_X_Y,
args.transformationImages, args.elasticDeformationImages)
images_reconstructor = getImagesReconstructor3D(
args.slidingWindowImages,
args.prop_overlap_Z_X_Y,
use_TransformationImages=False,
isfilterImages=args.filterPredictProbMaps,
prop_valid_outUnet=args.prop_valid_outUnet)
# LOADING MODEL
# ----------------------------------------------
print("-" * 30)
print("Loading saved model...")
print("-" * 30)
if TYPE_DNNLIBRARY_USED == 'Keras':
print(
"Loading full model: weights, optimizer, loss, metrics ... and restarting..."
)
modelSavedPath = joinpathnames(
ModelsPath, 'model_' + args.prediction_modelFile + '.hdf5')
print("Restarting from file: \'%s\'..." % (modelSavedPath))
loss_fun = DICTAVAILLOSSFUNS(
args.lossfun, is_masks_exclude=args.masksToRegionInterest).loss
metrics = [
DICTAVAILMETRICFUNS(imetrics,
is_masks_exclude=args.masksToRegionInterest).
get_renamed_compute() for imetrics in args.listmetrics
]
custom_objects = dict(
map(lambda fun: (fun.__name__, fun), [loss_fun] + metrics))
# load and compile model
model = NeuralNetwork.get_load_saved_model(
modelSavedPath, custom_objects=custom_objects)
# output model summary
model.summary()
elif TYPE_DNNLIBRARY_USED == 'Pytorch':
print(
"Loading full model: weights, optimizer, loss, metrics ... and restarting..."
)
modelSavedPath = joinpathnames(
ModelsPath, 'model_' + args.prediction_modelFile + '.pt')
print("Restarting from file: \'%s\'..." % (modelSavedPath))
# load and compile model
trainer = Trainer.load_model_full(modelSavedPath)
# output model summary
trainer.get_summary_model()
if (args.saveFeatMapsLayers):
if TYPE_DNNLIBRARY_USED == 'Keras':
visual_model_params = VisualModelParams(model, IMAGES_DIMS_Z_X_Y)
if args.firstSaveFeatMapsLayers:
get_index_featmap = lambda i: args.firstSaveFeatMapsLayers + i
else:
get_index_featmap = lambda i: i
elif TYPE_DNNLIBRARY_USED == 'Pytorch':
message = 'Visualize a model feature maps still not implemented...'
CatchErrorException(message)
# ----------------------------------------------
# START ANALYSIS
# ----------------------------------------------
print("-" * 30)
print("Predicting model...")
print("-" * 30)
for ifile, test_xData_file in enumerate(listTestImagesFiles):
print("\nInput: \'%s\'..." % (basename(test_xData_file)))
# COMPUTE PREDICTION
# ------------------------------------------
print("Loading data...")
if (args.slidingWindowImages or args.transformationImages):
if TYPE_DNNLIBRARY_USED == 'Keras':
test_xData = LoadDataManagerInBatches_DataGenerator(
IMAGES_DIMS_Z_X_Y,
test_images_generator).loadData_1File(test_xData_file,
shuffle_images=False)
elif TYPE_DNNLIBRARY_USED == 'Pytorch':
test_xData = LoadDataManager.loadData_1File(test_xData_file)
test_batch_data_generator = TrainingBatchDataGenerator(
IMAGES_DIMS_Z_X_Y, [test_xData], [test_xData],
test_images_generator,
batch_size=1,
shuffle=False)
(test_yData, test_xData) = DataSampleGenerator(
IMAGES_DIMS_Z_X_Y, [test_xData], [test_xData],
test_images_generator).get_full_data()
else:
test_xData = LoadDataManagerInBatches(
IMAGES_DIMS_Z_X_Y).loadData_1File(test_xData_file)
test_xData = np.expand_dims(test_xData, axis=0)
print("Total Data batches generated: %s..." % (len(test_xData)))
print("Evaluate model...")
if TYPE_DNNLIBRARY_USED == 'Keras':
predict_yData = model.predict(test_xData, batch_size=1)
elif TYPE_DNNLIBRARY_USED == 'Pytorch':
predict_yData = trainer.predict(test_batch_data_generator)
if (args.saveFeatMapsLayers):
print("Compute feature maps of evaluated model...")
featuremaps_data = visual_model_params.get_feature_maps(
test_xData,
args.nameSaveModelLayer,
max_num_feat_maps=args.maxNumSaveFeatMapsLayers,
first_feat_maps=args.firstSaveFeatMapsLayers)
# ------------------------------------------
# RECONSTRUCT FULL-SIZE PREDICTION
# ------------------------------------------
print("Reconstruct prediction to full size...")
# Assign original images and masks files
index_refer_img = getIndexOriginImagesFile(basename(test_xData_file),
beginString='images',
firstIndex='01')
reference_img_file = listReferenceImgsFiles[index_refer_img]
print("Reference image file: \'%s\'..." %
(basename(reference_img_file)))
# init reconstructor with size of "ifile"
predict_fullsize_shape = FileReader.getImageSize(test_xData_file)
images_reconstructor.complete_init_data(predict_fullsize_shape)
prediction_array = images_reconstructor.compute(predict_yData)
if (args.saveFeatMapsLayers):
featuremaps_array = images_reconstructor.compute(featuremaps_data)
# reconstruct from cropped / rescaled images
reference_img_shape = FileReader.getImageSize(reference_img_file)
if (args.cropImages):
crop_bounding_box = dict_cropBoundingBoxes[filenamenoextension(
reference_img_file)]
print(
"Predicted data are cropped. Extend array size to original. Bounding-box: \'%s\'..."
% (str(crop_bounding_box)))
prediction_array = ExtendImages.compute3D(prediction_array,
crop_bounding_box,
reference_img_shape)
print("Final dims: %s..." % (str(prediction_array.shape)))
if (args.masksToRegionInterest):
print("Mask predictions to RoI: lungs...")
in_roimask_file = listInputRoiMasksFiles[index_refer_img]
print("RoI mask (lungs) file: \'%s\'..." %
(basename(in_roimask_file)))
roimask_array = FileReader.getImageArray(in_roimask_file)
prediction_array = OperationBinaryMasks.reverse_mask_exclude_voxels_fillzero(
prediction_array, roimask_array)
if (args.saveFeatMapsLayers):
print("Reconstruct predicted feature maps to full size...")
if (args.cropImages):
num_featmaps = featuremaps_array.shape[-1]
featuremaps_shape = list(reference_img_shape) + [num_featmaps]
featuremaps_array = ExtendImages.compute3D(
featuremaps_array, crop_bounding_box, featuremaps_shape)
if (args.masksToRegionInterest):
featuremaps_array = OperationBinaryMasks.reverse_mask_exclude_voxels_fillzero(
featuremaps_array, roimask_array)
# ------------------------------------------
out_prediction_file = joinpathnames(
OutputPredictionPath, nameOutputPredictionFiles %
(filenamenoextension(reference_img_file)))
print("Output: \'%s\', of dims \'%s\'..." %
(basename(out_prediction_file), prediction_array.shape))
FileReader.writeImageArray(out_prediction_file, prediction_array)
if (args.saveFeatMapsLayers):
nameOutputFeatureMapsRelPath = nameOutputFeatureMapsDirs % (
filenamenoextension(reference_img_file),
args.nameSaveModelLayer)
OutputFeatureMapsPath = workDirsManager.getNameNewPath(
OutputPredictionPath, nameOutputFeatureMapsRelPath)
num_featmaps = featuremaps_array.shape[-1]
for ifeatmap in range(num_featmaps):
out_featuremaps_file = joinpathnames(
OutputFeatureMapsPath, nameOutputFeatureMapsFiles %
(filenamenoextension(reference_img_file),
args.nameSaveModelLayer, get_index_featmap(ifeatmap) + 1))
print("Output: \'%s\', of dims \'%s\'..." %
(basename(out_featuremaps_file),
featuremaps_array[..., ifeatmap].shape))
FileReader.writeImageArray(out_featuremaps_file,
featuremaps_array[..., ifeatmap])
def main(args):
# ---------- SETTINGS ----------
nameInputImagesRelPath = 'ProcImages'
nameInputMasksRelPath = 'ProcMasks'
namePredictMasksFiles = 'predict_binmasks*thres0-5_withtraquea.nii.gz'
nameInputImagesFiles = '*.nii.gz'
nameInputMasksFiles = '*outerwall*traquea.nii.gz'
# template search files
tempSearchInputFiles = 'av[0-9]*'
# create file to save FROC values
temp_outfilename = '%s_video.gif'
# ---------- SETTINGS ----------
workDirsManager = WorkDirsManager(args.basedir)
BaseDataPath = workDirsManager.getNameBaseDataPath()
InputPredictMasksPath = workDirsManager.getNameExistPath(
args.basedir, args.predictionsdir)
InputImagesPath = workDirsManager.getNameExistPath(args.basedir,
nameInputImagesRelPath)
InputMasksPath = workDirsManager.getNameExistPath(args.basedir,
nameInputMasksRelPath)
OutputPath = workDirsManager.getNameNewPath(args.basedir, 'movies_results')
listPredictMasksFiles = findFilesDir(InputPredictMasksPath,
namePredictMasksFiles)
listImagesCTFiles = findFilesDir(InputImagesPath, nameInputImagesFiles)
listGrndTruthMasksFiles = findFilesDir(InputMasksPath, nameInputMasksFiles)
nbPredictionsFiles = len(listPredictMasksFiles)
nbImagesCTFiles = len(listImagesCTFiles)
nbGrndTruthMasksFiles = len(listGrndTruthMasksFiles)
# Run checkers
if (nbPredictionsFiles == 0):
message = "0 Predictions found in dir \'%s\'" % (InputPredictMasksPath)
CatchErrorException(message)
if (nbImagesCTFiles == 0):
message = "0 Images CT found in dir \'%s\'" % (InputImagesPath)
CatchErrorException(message)
if (nbGrndTruthMasksFiles == 0):
message = "0 Ground-truth Masks found in dir \'%s\'" % (InputMasksPath)
CatchErrorException(message)
for i, predict_masks_file in enumerate(listPredictMasksFiles):
print('\'%s\'...' % (predict_masks_file))
name_prefix_case = getExtractSubstringPattern(
basename(predict_masks_file), tempSearchInputFiles)
for iterfile_1, iterfile_2 in zip(listImagesCTFiles,
listGrndTruthMasksFiles):
if name_prefix_case in iterfile_1:
images_CT_file = iterfile_1
grndtruth_masks_file = iterfile_2
#endfor
print("assigned to '%s' and '%s'..." %
(basename(images_CT_file), basename(grndtruth_masks_file)))
predict_masks_array = FileReader.getImageArray(predict_masks_file)
images_CT_array = FileReader.getImageArray(images_CT_file)
grndtruth_masks_array = FileReader.getImageArray(grndtruth_masks_file)
if (args.invertImageAxial):
predict_masks_array = FlippingImages.compute(predict_masks_array,
axis=0)
images_CT_array = FlippingImages.compute(images_CT_array, axis=0)
grndtruth_masks_array = FlippingImages.compute(
grndtruth_masks_array, axis=0)
print("Rendering animations...")
list_frames = []
for i in range(images_CT_array.shape[0]):
images_CT_slice = images_CT_array[i, :, :]
grndtruth_masks_slice = grndtruth_masks_array[i, :, :]
predict_masks_slice = predict_masks_array[i, :, :]
frame_image_CT = (
images_CT_slice - np.min(images_CT_slice)
) / float(np.max(images_CT_slice) - np.min(images_CT_slice))
frame_new = np.zeros(
(images_CT_slice.shape[0], images_CT_slice.shape[1], 3),
dtype=np.uint8)
frame_new[:, :, :] = 255 * frame_image_CT[:, :, None]
if (TYPE_ANIMATION == '1'):
index_frame_TP_mask = np.argwhere(grndtruth_masks_slice *
predict_masks_slice)
index_frame_FN_mask = np.argwhere(grndtruth_masks_slice *
(1.0 - predict_masks_slice))
index_frame_FP_mask = np.argwhere(
(1.0 - grndtruth_masks_slice) * predict_masks_slice)
# paint True Positives, False Negatives and False Positives in yellow, blue and red colour, respectively
for index in index_frame_TP_mask:
frame_new[tuple(index)] = YELLOW_COLOR
for index in index_frame_FN_mask:
frame_new[tuple(index)] = BLUE_COLOR
for index in index_frame_FP_mask:
frame_new[tuple(index)] = RED_COLOR
is_valid_frame = len(index_frame_TP_mask) > 0 or len(
index_frame_FN_mask) > 0 or len(index_frame_FP_mask) > 0
elif (TYPE_ANIMATION == '2'):
index_frame_predict_bound_mask = skimage.segmentation.find_boundaries(
predict_masks_slice)
index_frame_grndtruth_bound_mask = skimage.segmentation.find_boundaries(
grndtruth_masks_slice)
# draw boundaries of prediction / ground-truth masks with green / red colour, respectively
for index in index_frame_predict_bound_mask:
frame_new[tuple(index)] = GREEN_COLOR
for index in index_frame_grndtruth_bound_mask:
frame_new[tuple(index)] = RED_COLOR
is_valid_frame = len(
index_frame_predict_bound_mask) > 0 or len(
index_frame_grndtruth_bound_mask) > 0
# skip frames that do not contain any predictions and/or ground-truth masks
if is_valid_frame:
list_frames.append(frame_new)
if len(list_frames) > 0:
print("Good movie...")
outfilename = joinpathnames(OutputPath,
temp_outfilename % (name_prefix_case))
imageio.mimsave(outfilename, list_frames, fps=20)