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]) #######スライス開始########## #################腎臓の数を特定, 1ブロックにつき1つになるように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方向について、3D画像として切り取る 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]) #################腎臓の数を特定, 1ブロックにつき1つになるように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方向について、3D画像として切り取る 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]) #################腎臓の数を特定, 1ブロックにつき1つになるように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方向について、3D画像として切り取る 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))