def predict(): ''' Preprocessing for dataset ''' # Read data set (Train data from CSV file) csvdata = pd.read_csv('dataprocess\\data/test.csv') maskdata = csvdata.iloc[:, 1].values imagedata = csvdata.iloc[:, 0].values dice_values = [] Vnet3d = Vnet3dModule(128, 128, 32, channels=1, costname=("dice coefficient", ), inference=True, model_path="log\segmeation\model\Vnet3d.pd-20000") for index in range(imagedata.shape[0]): image_gt = np.load(imagedata[index]) mask_pd = Vnet3d.prediction(image_gt) mask_gt = np.load(maskdata[index]) dice_value = calcu_dice(mask_pd, mask_gt) print("index,dice:", (index, dice_value)) dice_values.append(dice_value) average = sum(dice_values) / len(dice_values) print("average dice:", average)
def inference(): depth_z = 48 Vnet3d = Vnet3dModule(512, 512, depth_z, channels=1, costname=("dice coefficient",), inference=True, model_path="log\segmeation\model\Vnet3d.pd-20000") test_path = "E:\junqiangchen\data\kits19\kits19process\\" image_path = "Image" mask_path = "Mask" dice_values = [] for num in range(200, 210, 1): index = 0 batch_xs = [] batch_ys = [] test_image_path = test_path + image_path + "/" + str(num) test_mask_path = test_path + mask_path + "/" + str(num) for _ in os.listdir(test_image_path): image = cv2.imread(test_image_path + "/" + str(index) + ".bmp", cv2.IMREAD_GRAYSCALE) label = cv2.imread(test_mask_path + "/" + str(index) + ".bmp", cv2.IMREAD_GRAYSCALE) batch_xs.append(image) batch_ys.append(label) index += 1 xs_array = np.array(batch_xs) ys_array = np.array(batch_ys) xs_array = np.reshape(xs_array, (index, 512, 512)) ys_array = np.reshape(ys_array, (index, 512, 512)) ys_pd_array = np.empty((index, 512, 512), np.uint8) last_depth = 0 for depth in range(0, index // depth_z, 1): patch_xs = xs_array[depth * depth_z:(depth + 1) * depth_z, :, :] pathc_pd = Vnet3d.prediction(patch_xs) ys_pd_array[depth * depth_z:(depth + 1) * depth_z, :, :] = pathc_pd last_depth = depth if index != depth_z * last_depth: patch_xs = xs_array[(index - depth_z):index, :, :] pathc_pd = Vnet3d.prediction(patch_xs) ys_pd_array[(index - depth_z):index, :, :] = pathc_pd ys_pd_sitk = sitk.GetImageFromArray(ys_pd_array) ys_pd_array = removesmallConnectedCompont(ys_pd_sitk, 0.4) ys_pd_array = np.clip(ys_pd_array, 0, 255).astype('uint8') dice_value = calcu_dice(ys_pd_array, ys_array) print("num,dice:", (num, dice_value)) dice_values.append(dice_value) for depth in range(0, index, 1): cv2.imwrite(test_mask_path + "/" + str(depth) + "predict.bmp", ys_pd_array[depth]) average = sum(dice_values) / len(dice_values) print("average dice:", average)
def predict(): csvdata = pd.read_csv('dataprocess\\data/testtumor.csv') maskdata = csvdata.iloc[:, 1].values imagedata = csvdata.iloc[:, 0].values dice_values = [] Vnet2d = BLVnet2dModule( 512, 512, channels=1, costname=("dice coefficient", ), inference=True, model_path="log\\tumorseg\diceVnet2d\model\BLVNet2ddiceloss.pd") for index in range(imagedata.shape[0]): mask_gt = cv2.imread(maskdata[index], cv2.IMREAD_GRAYSCALE) image_gt = cv2.imread(imagedata[index], cv2.IMREAD_GRAYSCALE) mask_pd = Vnet2d.prediction(image_gt) dice_value = calcu_dice(mask_pd, mask_gt) print("index,dice:", (index, dice_value)) dice_values.append(dice_value) average = sum(dice_values) / len(dice_values) print("average dice:", average)
def inference(): """ Vnet network segmentation brats fine segmatation :return: """ channel = 4 numclass = 4 flair_name = "_flair.nii.gz" t1_name = "_t1.nii.gz" t1ce_name = "_t1ce.nii.gz" t2_name = "_t2.nii.gz" mask_name = "_seg.nii.gz" out_mask_name = "_outseg.nii.gz" # step1 init vnet model depth_z = 48 Vnet3d = Vnet3dModuleMultiLabel( 240, 240, depth_z, channels=channel, numclass=numclass, costname=("categorical_dice", ), inference=True, model_path= "log\segmeation2mm\weighted_categorical_crossentropy\model\Vnet3d.pd-10000" ) brats_path = "D:\Data\\brats18\\test" # step2 get all test image path dice_values0 = [] dice_values1 = [] dice_values2 = [] dice_values3 = [] path_list = file_name_path(brats_path) # step3 get test image(4 model) and mask for subsetindex in range(len(path_list)): # step4 load test image(4 model) and mask as ndarray brats_subset_path = brats_path + "/" + str( path_list[subsetindex]) + "/" flair_image = brats_subset_path + str( path_list[subsetindex]) + flair_name t1_image = brats_subset_path + str(path_list[subsetindex]) + t1_name t1ce_image = brats_subset_path + str( path_list[subsetindex]) + t1ce_name t2_image = brats_subset_path + str(path_list[subsetindex]) + t2_name mask_image = brats_subset_path + str( path_list[subsetindex]) + mask_name flair_src = sitk.ReadImage(flair_image, sitk.sitkInt16) t1_src = sitk.ReadImage(t1_image, sitk.sitkInt16) t1ce_src = sitk.ReadImage(t1ce_image, sitk.sitkInt16) t2_src = sitk.ReadImage(t2_image, sitk.sitkInt16) mask = sitk.ReadImage(mask_image, sitk.sitkUInt8) flair_array = sitk.GetArrayFromImage(flair_src) t1_array = sitk.GetArrayFromImage(t1_src) t1ce_array = sitk.GetArrayFromImage(t1ce_src) t2_array = sitk.GetArrayFromImage(t2_src) label = sitk.GetArrayFromImage(mask) # step5 mormazalation test image(4 model) and merage to 4 channels ndarray flair_array = normalize(flair_array) t1_array = normalize(t1_array) t1ce_array = normalize(t1ce_array) t2_array = normalize(t2_array) imagez, height, width = np.shape(flair_array)[0], np.shape( flair_array)[1], np.shape(flair_array)[2] fourmodelimagearray = np.zeros((imagez, height, width, channel), np.float) fourmodelimagearray[:, :, :, 0] = flair_array fourmodelimagearray[:, :, :, 1] = t1_array fourmodelimagearray[:, :, :, 2] = t1ce_array fourmodelimagearray[:, :, :, 3] = t2_array ys_pd_array = np.zeros((imagez, height, width), np.uint8) # step6 predict test image(4 model) last_depth = 0 for depth in range(0, imagez // depth_z, 1): patch_xs = fourmodelimagearray[depth * depth_z:(depth + 1) * depth_z, :, :, :] pathc_pd = Vnet3d.prediction(patch_xs) ys_pd_array[depth * depth_z:(depth + 1) * depth_z, :, :] = pathc_pd last_depth = depth if imagez != depth_z * last_depth: patch_xs = fourmodelimagearray[(imagez - depth_z):imagez, :, :, :] pathc_pd = Vnet3d.prediction(patch_xs) ys_pd_array[(imagez - depth_z):imagez, :, :] = pathc_pd ys_pd_array = np.clip(ys_pd_array, 0, 255).astype('uint8') all_ys_pd_array = ys_pd_array.copy() all_ys_pd_array[ys_pd_array != 0] = 1 outmask = getLargestConnectedCompont( sitk.GetImageFromArray(all_ys_pd_array)) ys_pd_array[outmask == 0] = 0 # step7 calcu test mask and predict mask dice value batch_ys = label.copy() batch_ys[label == 4] = 3 dice_value0 = 0 dice_value1 = 0 dice_value2 = 0 dice_value3 = 0 for num_class in range(4): ys_pd_array_tmp = ys_pd_array.copy() batch_ys_tmp = batch_ys.copy() ys_pd_array_tmp[ys_pd_array == num_class] = 1 batch_ys_tmp[label == num_class] = 1 if num_class == 0: dice_value0 = calcu_dice(ys_pd_array_tmp, batch_ys_tmp, 1) if num_class == 1: dice_value1 = calcu_dice(ys_pd_array_tmp, batch_ys_tmp, 1) if num_class == 2: dice_value2 = calcu_dice(ys_pd_array_tmp, batch_ys_tmp, 1) if num_class == 3: dice_value3 = calcu_dice(ys_pd_array_tmp, batch_ys_tmp, 1) print( "index,dice:", (subsetindex, dice_value0, dice_value1, dice_value2, dice_value3)) dice_values0.append(dice_value0) dice_values1.append(dice_value1) dice_values2.append(dice_value2) dice_values3.append(dice_value3) # step8 out put predict mask ys_pd_array = ys_pd_array.astype('float') outputmask = np.zeros((imagez, height, width), np.uint8) outputmask[ys_pd_array == 1] = 1 outputmask[ys_pd_array == 2] = 2 outputmask[ys_pd_array == 3] = 4 ys_pd_itk = sitk.GetImageFromArray(outputmask) ys_pd_itk.SetSpacing(mask.GetSpacing()) ys_pd_itk.SetOrigin(mask.GetOrigin()) ys_pd_itk.SetDirection(mask.GetDirection()) out_mask_image = brats_subset_path + str( path_list[subsetindex]) + out_mask_name sitk.WriteImage(ys_pd_itk, out_mask_image) average0 = sum(dice_values0) / len(dice_values0) average1 = sum(dice_values1) / len(dice_values1) average2 = sum(dice_values2) / len(dice_values2) average3 = sum(dice_values3) / len(dice_values3) print("average dice:", (average0, average1, average2, average3))