def show(data1, data2, app=None): if isinstance(data1, str): data1 = tools.load_pickle_data(data1, return_datap=True) if isinstance(data2, str): data2 = tools.load_pickle_data(data2, return_datap=True) if not isinstance(data1, dict): data1 = { 'data3d': data1, 'segmentation': np.zeros_like(data1), 'voxelsize_mm': np.ones(data1.ndim), 'slab': 0 } if not isinstance(data2, dict): data2 = { 'data3d': data2, 'segmentation': np.zeros_like(data2), 'voxelsize_mm': np.ones(data2.ndim), 'slab': 0 } if app is None: app = QtGui.QApplication(sys.argv) le = SegViewer(datap1=data1, datap2=data2) le.data_1.labels = data1['segmentation'].astype(np.int) le.data_2.labels = data2['segmentation'].astype(np.int) # print 'data1 values:', np.unique(data1['segmentation'].astype(np.int)) # print 'data2 values:', np.unique(data2['segmentation'].astype(np.int)) le.show() app.exec_()
def extract_and_save_pairs(): datas = lesloc.get_data_struc(reshape=True) # datas = reshape_struc(datas) files = [] # datadir = '/home/tomas/Dropbox/Data/medical/dataset/gt/salmaps/vyber/hypo/res_pklz' datadir = '/home/tomas/Dropbox/Data/medical/dataset/gt/salmaps/res/best' for (dirpath, dirnames, filenames) in os.walk(datadir): filenames = [x for x in filenames if x.split('.')[-1] == 'pklz'] for fname in filenames: files.append(os.path.join(dirpath, fname)) break for i, (im1_fn, im2_fn, s1, s2) in enumerate(datas): print 'data # %i/%i ...' % (i + 1, len(datas)) # getting ground-truth data __, gt_mask1, __ = tools.load_pickle_data(im1_fn) gt_mask1 = gt_mask1[s1, ...] gt_mask1, __ = tools.crop_to_bbox(gt_mask1, gt_mask1 > 0) # gt_mask1 = gt_mask1 == 1 __, gt_mask2, __ = tools.load_pickle_data(im2_fn) gt_mask2 = gt_mask2[s2, ...] gt_mask2, __ = tools.crop_to_bbox(gt_mask2, gt_mask2 > 0) # gt_mask2 = gt_mask2 == 1 # finding corresponding files fname1 = find_file(im1_fn, s1, files) fname2 = find_file(im2_fn, s2, files) # processing if fname1 is not None and fname2 is not None: # data1, gt_mask, voxel_size = tools.load_pickle_data(f) with gzip.open(fname1, 'rb') as f: fcontent = f.read() im1, sm1, res1 = pickle.loads(fcontent) with gzip.open(fname2, 'rb') as f: fcontent = f.read() im2, sm2, res2 = pickle.loads(fcontent) # identify_tumors(res1, res2, gt_mask1, gt_mask2) pairs = pair_up_tumors(im1, res1, gt_mask1, im2, res2, gt_mask2) # ukladani na disk for j, pair in enumerate(pairs): __, __, pair_type = pair kw = fname1.split('/')[-1].split('.')[0].split('-') nmb = kw[0].split('_')[0] sl1 = kw[-2] sl2 = fname2.split('/')[-1].split('.')[0].split('-')[-2] outfn = '/'.join(fname1.split('/')[:-1]) + '/pairs/%s_sl-%s-%s_p-%i_tp-%s.pklz' % ( nmb, sl1, sl2, j, pair_type) with gzip.open(outfn, 'wb', compresslevel=1) as f: pickle.dump(pair, f)
def run(data_fname, params_fname): data, mask, voxel_size = tools.load_pickle_data(data_fname) params = load_parameters(params_fname) seeds_fname = tools.get_subdir_fname(data_fname, 'seeds') # -- FAST MARCHING -- # fm.run(data, params, mask) # -- SNAKES -- # snakes.run(data, params, mask=mask) # -- RANDOM WALKER -- # segs = rw.run(data, seeds_fname) # tools.save_pickle(data_fname, 'seg_rw', data, mask, segs, voxel_size) # -- HISTOGRAM EQUALIZATION PIPELINE -- # segs, vis = heep.run(data, mask, proc=['smoo', 'equa', 'clos', 'cont'], disp=False, show=False) # tools.save_pickle(data_fname, 'seg_he_pipeline', data, mask, segs, voxel_size) # tools.save_figs(data_fname, 'figs_he_pipeline', data, mask, vis) # -- SLIC -- return_vis = True out = slics.run(data, mask, voxel_size, return_vis=return_vis) if return_vis: segs, vis, ranges, cmaps = out # tools.save_figs(data_fname, 'figs_seg_slic', data, mask, vis, ranges=ranges, cmaps=cmaps) else: segs = out # tools.save_pickle(data_fname, 'seg_slic', data, mask, segs, voxel_size) # -- VISUALIZATION -- tools.show_3d(segs)
def extract_data(imgnames, suffix=".pklz", config={}, to_extract=True, zero_background=False, den=32, new_shape=(232, 240)): """ Ulozi CT rezy do dane slozky """ hs, ws = [], [] ratios = [] mhs, mws = [], [] for imgname in imgnames: print " Zpracovavam obrazek " + imgname data, gt_mask, voxel_size = tools.load_pickle_data(imgname) name = imgname[:-len(suffix)] # Aplikace CT okenka: data = se.apply_CT_window( data) #, target_range=1.0, target_dtype=float) hs.append(data.shape[1]) ws.append(data.shape[2]) ratios.append(float(data.shape[1]) / data.shape[2]) # extrakce CT oken if to_extract: mh, mw = extract_slices(data, gt_mask, config, name, zero_background=zero_background, new_shape=new_shape) mhs.append(mh) mws.append(mw) avg_shape = [np.mean(hs), np.mean(ws)] round_avg_shape = [ int((avg_shape[0] + den / 2) // den) * den, int((avg_shape[1] + den / 2) // den) * den ] print "[RESULT] Prumerny tvar rezu je: ", avg_shape print " -> zaokrouhleno: ", round_avg_shape if to_extract: max_shape = [np.max(mhs), np.max(mws)] round_max_shape = [ int((max_shape[0] + den / 2) // den) * den, int((max_shape[1] + den / 2) // den) * den ] print " -> ratio: ", avg_shape[0] / avg_shape[1] print "[RESULT] Maximalni tvar rezu je: ", max_shape print " -> zaokrouhleno: ", round_max_shape # plt.hist(ratios, bins=100) # plt.show() return tuple(round_avg_shape)
def examine_data_pairs(): venous_fnames, arterial_fnames = find_datapairs() tmp = [(x.split('/')[-1], y.split('/')[-1]) for x, y in zip(venous_fnames, arterial_fnames)] for i in tmp: print i for i, (v, a) in enumerate(zip(venous_fnames, arterial_fnames)): if i < 10: continue print i, v.split('/')[-1], a.split('/')[-1] datap_1 = tools.load_pickle_data(v, return_datap=True) datap_2 = tools.load_pickle_data(a, return_datap=True) app = QtGui.QApplication(sys.argv) le = SegViewer(datap1=datap_1, datap2=datap_2) le.show() app.exec_()
def slice_data(fname, reshape=True, cube_shape=(20, 20, 20), step=10): datap = tools.load_pickle_data(fname, return_datap=True) data3d = datap['data3d'] labels = datap['segmentation'] voxelsize_mm = datap['voxelsize_mm'] data_cubes = [] label_cubes = [] # data3d = np.arange(1, 401).reshape((4, 10, 10)) # labels = 2 * np.ones((4, 10, 10)) # resizing data to have same spacing if reshape: orig_shape = data3d.shape n_slices = orig_shape[0] * (voxelsize_mm[0] / voxelsize_mm[1]) new_shape = (n_slices, orig_shape[1], orig_shape[2]) data3d = misc.resize_to_shape(data3d, shape=new_shape, order=1) labels = misc.resize_to_shape(labels, shape=new_shape, order=0) # print [(x, (labels == x).sum()) for x in np.unique(labels)] lesion_lbl = 1 liver_lbl = 2 bgd_lbl = 0 data_cubes_all = [ cube[4] for cube in tools.sliding_window_3d( data3d, step, cube_shape, only_whole=True, include_last=True) ] label_cubes_all = [ cube[4] for cube in tools.sliding_window_3d( labels, step, cube_shape, only_whole=True, include_last=True) ] areaT = 0.5 * np.prod( cube_shape) # prah pro minimalni zastoupeni jater v kostce # for data_cube, label_cube in zip(tools.sliding_window_3d(data3d, 10, cube_shape, only_whole=False, include_last=True)[4], # tools.sliding_window_3d(labels, 10, cube_shape, only_whole=False, include_last=True)[4]): for data_cube, label_cube in zip(data_cubes_all, label_cubes_all): if (label_cube == liver_lbl).sum() >= areaT: mean_v = data_cube[np.nonzero(label_cube == liver_lbl)].mean() # tmp = data_cube[0,...].copy() data_cube = np.where(label_cube == bgd_lbl, mean_v, data_cube) # plt.figure() # plt.subplot(131), plt.imshow(tmp, 'gray', vmin=-125, vmax=225), plt.title('orig') # plt.subplot(132), plt.imshow(data_cube[0,...], 'gray', vmin=-125, vmax=225), plt.title('processed, mean=%.1f' % mean_v) # plt.subplot(133), plt.imshow(label_cube[0,...], 'gray', vmin=0, vmax=2), plt.title('mask') # plt.show() data_cubes.append(data_cube) label_cubes.append( label_cube == lesion_lbl) # ulozim pouze oznacena loziska # seg_viewer.show(data3d, 100 * labels) return data_cubes, label_cubes
def calc_features(datadir): areas = [] ints_art = [] ints_ven = [] eccs = [] fnames = load_data(datadir) for i, fname in enumerate(fnames): data, mask, voxel_size = tools.load_pickle_data(fname, return_datap=False) mask = np.where(mask > 0, 1, 0) area = mask.sum() # mask_tmp = skimor.binary_erosion(mask, selem=skimor.disk(1)) mask_tmp = tools.morph_ND(mask, 'erosion', selem=skimor.disk(1)) mean_int = data[np.nonzero(mask_tmp)].mean() ecc = [] for m in mask: if m.any(): rp = skimea.regionprops(m) ecc.append(rp[0].eccentricity) ecc = np.array(ecc).mean() print 'area: %i, int: %i, ecc: %.2f' % (area, round(mean_int), ecc) areas.append(area) if 'arterial' in fname: ints_art.append(mean_int) elif 'venous' in fname: ints_ven.append(mean_int) eccs.append(ecc) mean_area = np.array(areas).mean() mean_int_art = np.array(ints_art).mean() mean_int_ven = np.array(ints_ven).mean() mean_ecc = np.array(eccs).mean() print '----' print 'mean area: %i, mean int art: %.1f, mean int ven: %.1f, mean ecc: %.2f' % ( mean_area, mean_int_art, mean_int_ven, mean_ecc)
app.exec_() # sys.exit(app.exec_()) ################################################################################ ################################################################################ if __name__ == '__main__': #TODO: udelat synteticka data a nevazat se na moje konkretni data # fname_1 = '/home/tomas/Data/liver_segmentation/seg_rw/seg_rw_183_venous.pklz' # fname_2 = '/home/tomas/Data/liver_segmentation/seg_he_pipeline/seg_he_pipeline_183_venous.pklz' # fname_1 = '/home/tomas/Data/medical/liver_segmentation/org-exp_180_49509315_arterial_5.0_B30f-.pklz' # fname_2 = '/home/tomas/Data/medical/liver_segmentation/org-exp_180_49509315_venous_5.0_B30f-.pklz' fname_1 = '/home/tomas/Data/medical/liver_segmentation/org-exp_183_46324212_arterial_5.0_B30f-.pklz' fname_2 = '/home/tomas/Data/medical/liver_segmentation/org-exp_183_46324212_venous_5.0_B30f-.pklz' datap_1 = tools.load_pickle_data(fname_1, return_datap=True) datap_2 = tools.load_pickle_data(fname_2, return_datap=True) print datap_1['segmentation'].shape print datap_2['segmentation'].shape # maska = datap_1['segmentation'] # s1, r1, c1 = np.nonzero(datap_1['segmentation']) # t1_z = np.mean(s1) # s2, r2, c2 = np.nonzero(datap_2['segmentation']) # t2_z = np.mean(s2) # print t1_z, t2_z # seg = np.load(fname_1) # starting application app = QtGui.QApplication(sys.argv) le = SegViewer(datap1=datap_1, datap2=datap_2) le.show()
def add_mask(): dirpath = '/home/tomas/Dropbox/Data/medical/dataset/gt/' data_struc = [ ('180_venous-GT.pklz', '180_arterial-GT.pklz', [(x, y) for x, y in zip(range(5, 16), range(5, 16))]), ('183a_venous-GT.pklz', '183a_arterial-GT.pklz', [(x, y) for x, y in zip(range(9, 23), range(7, 21))]), ('185a_venous-GT.pklz', '185a_arterial-GT.pklz', [(x, y) for x, y in zip([ 9, ] + range(10, 24), [ 10, ] + range(10, 24))]), ('186a_venous-GT.pklz', '186a_arterial-GT.pklz', [(x, y) for x, y in zip(range(1, 8), range(1, 8))]), ('189a_venous-GT.pklz', '189a_arterial-GT.pklz', [(x, y) for x, y in zip(range(12, 26), range(11, 25))]), ('221_venous-GT.pklz', '221_arterial-GT.pklz', [(x, y) for x, y in zip(range(17, 22), range(17, 22))]), ('222a_venous-GT.pklz', '222a_arterial-GT.pklz', [(x, y) for x, y in zip( range(2, 7) + range(24, 30), range(1, 7) + range(21, 27))]), ('232_venous-GT.pklz', '232_arterial-GT.pklz', [(x, y) for x, y in zip( range(1, 12) + range(17, 25), range(1, 12) + range(16, 24))]), # ('234_venous-GT.pklz', '234_arterial-GT.pklz', range(0, 0, s)), ('235_venous-GT.pklz', '235_arterial-GT.pklz', [(x, y) for x, y in zip(range(4, 42), range(4, 42))]) ] # fujky data_struc = [(dirpath + x[0], dirpath + x[1], x[2]) for x in data_struc] for i, (data_ven_fn, data_art_fn, slics) in enumerate(data_struc): print '#%i/%i' % (i + 1, len(data_struc)) data_ven, mask_ven, vs = tools.load_pickle_data(data_ven_fn) data_art, mask_art, vs = tools.load_pickle_data(data_art_fn) for j, (s_ven, s_art) in enumerate(slics): mask_im_ven = mask_ven[s_ven, ...] # > 0 mask_im_art = mask_art[s_art, ...] # > 0 dirs = data_ven_fn.split('/') fname = dirs[-1] salmap_fname = fname.replace('.pklz', '-sm-%i.pklz' % s_ven) dirp = '/'.join(dirs[:-1]) out_ven = os.path.join(dirp, 'salmaps', salmap_fname) dirs = data_art_fn.split('/') fname = dirs[-1] salmap_fname = fname.replace('.pklz', '-sm-%i.pklz' % s_art) dirp = '/'.join(dirs[:-1]) out_art = os.path.join(dirp, 'salmaps', salmap_fname) with gzip.open(out_ven, 'rb') as f: fcontent = f.read() data = pickle.loads(fcontent) # data_old = data[:] data.insert(1, (mask_im_ven, 'mask')) with gzip.open(out_ven, 'wb') as f: pickle.dump(data, f) with gzip.open(out_art, 'rb') as f: fcontent = f.read() data = pickle.loads(fcontent) data.insert(1, (mask_im_art, 'mask')) with gzip.open(out_art, 'wb') as f: pickle.dump(data, f)
im = self.data_R.labels_filt_aview[..., self.actual_slice_R] # elif self.show_mode_R == SHOW_FILTERED_LABELS: # im = self.data_R.labels_filt_aview[...,self.actual_slice_R] return im ################################################################################ ################################################################################ if __name__ == '__main__': #TODO: udelat synteticka data a nevazat se na moje konkretni data # fname_1 = '/home/tomas/Data/liver_segmentation/seg_rw/seg_rw_183_venous.pklz' # fname_2 = '/home/tomas/Data/liver_segmentation/seg_he_pipeline/seg_he_pipeline_183_venous.pklz' fname_1 = '/home/tomas/Data/liver_segmentation/org-exp_180_49509315_arterial_5.0_B30f-.pklz' fname_2 = '/home/tomas/Data/liver_segmentation/org-exp_180_49509315_venous_5.0_B30f-.pklz' datap_1 = tools.load_pickle_data(fname_1, return_datap=True) datap_2 = tools.load_pickle_data(fname_2, return_datap=True) # maska = datap_1['segmentation'] # s1, r1, c1 = np.nonzero(datap_1['segmentation']) # t1_z = np.mean(s1) # s2, r2, c2 = np.nonzero(datap_2['segmentation']) # t2_z = np.mean(s2) # print t1_z, t2_z # seg = np.load(fname_1) # starting application app = QtGui.QApplication(sys.argv) le = SegViewer(datap1=datap_1, datap2=datap_2) le.show() sys.exit(app.exec_())
plt.imshow(saliencies[i], 'gray', interpolation='nearest') plt.title(t**s[i]) for i, r in enumerate(results): plt.subplot(2, n_imgs, i + n_imgs + 2) plt.imshow(results[i], interpolation='nearest'), plt.title('result - %s' % t**s[i]) figname = 'unary_saliencies_alpha_%i_rad_%i.png' % (alpha, rad) fig.savefig(os.path.join(figdir, figname), dpi=100, bbox_inches='tight', pad_inches=0) plt.show() #----------------------------------------------------------------------------------------- #----------------------------------------------------------------------------------------- if __name__ == '__main__': data_fname = '/home/tomas/Data/medical/liver_segmentation/org-exp_183_46324212_venous_5.0_B30f-.pklz' data, mask, voxel_size = tools.load_pickle_data(data_fname) slice_ind = 17 data_s = data[slice_ind, :, :] data_s = tools.windowing(data_s) mask_s = mask[slice_ind, :, :] show = False show_now = False save_fig = True run(data_s, mask_s, alpha=50, show=show, show_now=show_now, save_fig=save_fig) # im_o, img, saliency = run(data_s, mask_s, show=False) # im_o_s, img_s, saliency_s = run(data_s, mask_s, smoothing=True, show=False) #
import matplotlib.pyplot as plt import skimage.segmentation as skiseg fnames = [ '/home/tomas/Dropbox/Data/medical/dataset/gt/235_arterial-GT.pklz', '/home/tomas/Dropbox/Data/medical/dataset/gt/183a_arterial-GT.pklz', '/home/tomas/Dropbox/Data/medical/dataset/gt/232_venous-GT.pklz', '/home/tomas/Dropbox/Data/medical/dataset/gt/234_venous-GT.pklz', '/home/tomas/Dropbox/Data/medical/dataset/gt/180_arterial-GT.pklz', '/home/tomas/Dropbox/Data/medical/dataset/gt/185a_venous-GT.pklz', ] slices = [13, 12, 8, 6, 11, 17] for f, s in zip(fnames, slices): data, gt_mask, voxel_size = tools.load_pickle_data(f) data = tools.windowing(data) data = data[s, ...] gt_mask = gt_mask[s, ...] plt.figure() plt.subplot(121), plt.imshow(data, 'gray', interpolation='nearest'), plt.axis('off') # plt.subplot(122), plt.imshow(gt_mask, 'gray', interpolation='nearest') plt.subplot(122), plt.imshow(skiseg.mark_boundaries(data, gt_mask == 1, color=(1, 0, 0), mode='thick'), interpolation='nearest'), plt.axis('off') plt.suptitle(f.split('/')[-1] + ', ' + str(s)) plt.show()
def segmentation_stats(data_struc, scale=1, smoothing=True): # fnames = load_data(datadir) # fnames = ['/home/tomas/Dropbox/Data/medical/dataset/180_arterial-.pklz',] # creating workbook workbook = xlsxwriter.Workbook('/home/tomas/Dropbox/Data/liver_segmentation/final_alg/liver_seg_stats.xlsx') worksheet = workbook.add_worksheet() # Add a bold format to use to highlight cells. bold = workbook.add_format({'bold': True}) # green = workbook.add_format({'bg_color': '#C6EFCE'}) col_gc_fmea = 3 col_gc_prec = 6 col_gc_rec = 9 col_ls_fmea = 4 col_ls_prec = 7 col_ls_rec = 10 cols_gc = (3, 6, 9) cols_ls = (4, 7, 10) start_row = 2 worksheet.write(0, 0, 'DATA', bold) worksheet.write(0, 1, 'slice', bold) worksheet.write(0, 3, 'F-MEASURE', bold) worksheet.write(0, 6, 'PRECISION', bold) worksheet.write(0, 9, 'RECALL', bold) worksheet.write(1, col_gc_fmea, 'Grow Cut', bold) worksheet.write(1, col_ls_fmea, 'Level Sets', bold) worksheet.write(1, col_gc_prec, 'Grow Cut', bold) worksheet.write(1, col_ls_prec, 'Level Sets', bold) worksheet.write(1, col_gc_rec, 'Grow Cut', bold) worksheet.write(1, col_ls_rec, 'Level Sets', bold) # loading data data_fnames = [] data_slices = [] for name, num in data_struc: for i in num: data_fnames.append(name) data_slices.append(i) n_imgs = len(data_fnames) for i, (data_fname, slice) in enumerate(zip(data_fnames, data_slices)): fname = data_fname.split('/')[-1].split('.')[0] print '#%i/%i, %s [%i]: ' % (i + 1, n_imgs, fname, slice), data, gt_mask, voxel_size = tools.load_pickle_data(data_fname) data = data[slice,...] gt_mask = gt_mask[slice,...] print 'windowing ...', data = tools.windowing(data) shape_orig = data.shape data_o = data.copy() # plt.figure() # plt.imshow(data, 'gray', vmin=0, vmax=255, interpolation='nearest') # plt.show() if scale != 1: print 'resizing ...', data = tools.resize_ND(data, scale=scale).astype(np.uint8) if smoothing: print 'smoothing ...', data = tools.smoothing(data) print 'gc ...', blob, seg_gc = coarse_segmentation(data, clear_border=False, show=False, verbose=False) print 'ls ...', seg_ls = segmentation_refinement(data, blob, show=False, verbose=False) if seg_gc.shape != gt_mask.shape: seg_gc = tools.resize_ND(seg_gc, shape=shape_orig) if seg_ls.shape != gt_mask.shape: seg_ls = tools.resize_ND(seg_ls, shape=shape_orig) # computing statistics print 'stats ...', precision_gc, recall_gc, f_measure_gc = ac.calc_statistics(blob, gt_mask) precision_ls, recall_ls, f_measure_ls = ac.calc_statistics(seg_ls, gt_mask) # writing statistics print 'writing ...', items = (f_measure_gc, precision_gc, recall_gc, f_measure_ls, precision_ls, recall_ls) worksheet.write(start_row + i, 0, fname) worksheet.write(start_row + i, 1, slice) for it, col in zip(items, cols_gc + cols_ls): worksheet.write(start_row + i, col, it) print 'done' fig = tools.visualize_seg(data_o, seg_ls, mask=seg_gc, title=fname, show_now=False, for_save=True) out_fname = '/home/tomas/Dropbox/Data/liver_segmentation/final_alg/%s_sl_%i.png' % (fname, slice) fig.savefig(out_fname) plt.close('all') print '\t\tfmea = %.3f -> %.3f, prec = %.3f -> %.3f, rec = %.3f -> %.3f' %\ (f_measure_gc, f_measure_ls, precision_gc, precision_ls, recall_gc, recall_ls)
def register_dataset(): dirpath = '/home/tomas/Dropbox/Data/medical/dataset/gt/' data_struc = [('180_venous-GT.pklz', '180_arterial-GT.pklz'), ('183a_venous-GT.pklz', '183a_arterial-GT.pklz'), ('185a_venous-GT.pklz', '185a_arterial-GT.pklz'), ('186a_venous-GT.pklz', '186a_arterial-GT.pklz'), ('189a_venous-GT.pklz', '189a_arterial-GT.pklz'), ('221_venous-GT.pklz', '221_arterial-GT.pklz'), ('222a_venous-GT.pklz', '222a_arterial-GT.pklz'), ('232_venous-GT.pklz', '232_arterial-GT.pklz'), # ('234_venous-GT.pklz', '234_arterial-GT.pklz', range(0, 0, s)), ('235_venous-GT.pklz', '235_arterial-GT.pklz')] data_struc = [(dirpath + x[0], dirpath + x[1]) for x in data_struc] n_data = len(data_struc) for i, (fixed_fn, moving_fn) in enumerate(data_struc): if i < 5: continue print 'data #%i/%i: ' % (i + 1, n_data), data_v, gt_mask, voxel_size = tools.load_pickle_data(fixed_fn) data_v = tools.windowing(data_v) data_a, gt_mask, voxel_size = tools.load_pickle_data(moving_fn) # data_a = tools.windowing(data_a) moving_arr = tools.resize_ND(data_a, shape=data_v.shape).astype(data_a.dtype) moving_arr = tools.match_size(moving_arr, data_v.shape, verbose=False) data_ao = moving_arr.copy() moving_arr = tools.windowing(moving_arr).astype(np.float) # moving_arr = tools.windowing(data_a).astype(np.float) fixed_arr = data_v.astype(np.float) # moving_arr = tools.resize_ND(data_a, shape=data_v.shape).astype(fixed_arr.dtype) # moving_arr = tools.match_size(moving_arr, fixed_arr.shape, verbose=False) # print fixed_arr.shape, moving_arr.shape # plt.figure() # plt.subplot(121), plt.imshow(fixed_arr[15,...], 'gray') # plt.subplot(122), plt.imshow(moving_arr[15,...], 'gray') # plt.show() moving_mask = tools.resize_ND(gt_mask, shape=data_v.shape).astype(gt_mask.dtype) moving_mask = tools.match_size(moving_mask, data_v.shape) n_slices = fixed_arr.shape[0] print 'slices: %i - ' % n_slices, data_reg = np.zeros_like(moving_arr) mask_reg = np.zeros_like(moving_mask) for j, (fixed, moving, mask) in enumerate(zip(fixed_arr, moving_arr, moving_mask)): if (j % 5) == 0: print ' ', # print '#', print j fixed = sitk.GetImageFromArray(fixed) moving = sitk.GetImageFromArray(moving) # mask = sitk.GetImageFromArray(mask) setups = (('simil', 'ms'), ('affine', 'ms'), ('spline', 'mi')) for ttype, mtype in setups: data_r, tx = register(fixed, moving, mask=mask, transform_type=ttype, metric=mtype, max_iters=300, return_resampler=True, show=False) if (data_r == 0).sum() < (0.8 * np.prod(data_r.shape)): print ttype, mtype data_r = transform_data(data_ao[j,...], tx) mask_r = transform_data(mask, tx) break data_reg[j, ...] = data_r mask_reg[j,...] = mask_r # plt.figure() # plt.subplot(131), plt.imshow(fixed_arr[j,...], 'gray') # plt.subplot(132), plt.imshow(moving_arr[j,...], 'gray') # plt.subplot(133), plt.imshow(tools.windowing(data_r), 'gray') # plt.show() print ' - OK,', datap_reg = {'data3d': data_reg, 'segmentation': mask_reg, 'voxelsize_mm': voxel_size, 'slab': {'none': 0, 'liver': 1, 'lesions': 6}} outname = dirpath + 'registered/' + moving_fn.split('/')[-1].replace('.pklz', '-registered.pklz') # if not os.path.exists(outname): # os.mkdir(outname) f = gzip.open(outname, 'wb') pickle.dump(datap_reg, f) f.close() # break print 'done'
def load_CT(imgname, bounding_boxes, suffix='.pklz', HNM=True, each_to_HNM=1): """ Nacte CT a ulozi slice a pripadny bounding box """ print " Zpracovavam obrazek " + imgname data, gt_mask, voxel_size = tools.load_pickle_data(imgname) n_of_slices = data.shape[0] n_negative_slices = 0 suffix_len = len(suffix) # Aplikace CT okenka: data = apply_CT_window(data) #, target_range=1.0, target_dtype=float) for i in xrange(n_of_slices): print i, data_slice = data[i] mask_slice = gt_mask[i] boxes = get_bounding_boxes(mask_slice) # pokud jsou nejake bounding boxy, mel by je vytahnout a obrazy ulozit jako positives if len(boxes) >= 1: img_id = imgname[0:-suffix_len] + str("%03d" % int(i)) + suffix # Ulozeni bounding boxu bounding_boxes["datasets/processed/orig_images/" + img_id] = boxes # Ulozeni obrazku #skimage.io.imsave("Slices/"+imgname[0:-suffix_len]+str("%03d" % int(i))+".png", data_slice) save_obj(data_slice.astype("uint8"), "Slices/" + img_id) save_obj(mask_slice.astype("uint8"), "Masks/" + img_id) # jinak je oznaci jako negativni else: img_id = imgname[0:-suffix_len] + str("%03d" % int(i)) + suffix # kazdy nekolikaty negativni rez dat do hard_negatives if HNM: n_negative_slices += 1 if (n_negative_slices % each_to_HNM == 0): img_id = imgname[0:-suffix_len] + str( "%03d" % int(i)) + suffix skimage.io.imsave( "frames/hnm/" + img_id[0:-suffix_len] + ".png", data_slice) save_obj(data_slice.astype("uint8"), "Hard_negative_mining/" + img_id) save_obj(mask_slice.astype("uint8"), "Masks/" + img_id) # jinak je da do trenovaci mnoziny negatives frame_id = 0 for data_to_save in liver_inside_only_generator(data_slice, gt_mask[i], fill_holes=False, metric='taxicab'): if not data_to_save is None: img_id = imgname[0:-suffix_len] + str( "%03d" % int(i)) + "#" + str( "%03d" % int(frame_id)) + suffix # ulozeni obrazku #skimage.io.imsave("Negatives/"+imgname[0:-suffix_len]+str("%03d" % int(i))+".png", data_to_save) save_obj(data_to_save.astype("uint8"), "Negatives/" + img_id) frame_id += 1 print ""
# hyper, 1 on the border ------------------- # arterial 0.6mm - not that bad # fname = '/home/tomas/Data/medical/liver_segmentation/org-exp_239_61293268_DE_Art_Abd_0.75_I26f_M_0.5-.pklz' # venous 5mm - bad # fname = '/home/tomas/Data/medical/liver_segmentation/org-exp_239_61293268_DE_Ven_Abd_0.75_I26f_M_0.5-.pklz' # shluk ----------------- # arterial 5mm # fname = '/home/tomas/Data/medical/liver_segmentation/org-exp_180_49509315_arterial_5.0_B30f-.pklz' # fname = '/home/tomas/Data/medical/liver_segmentation/org-exp_180_49509315_venous_5.0_B30f-.pklz' # targeted # arterial 0.6mm - bad # fname = '/home/tomas/Data/medical/liver_segmentation/org-exp_238_54280551_Abd_Arterial_0.75_I26f_3-.pklz' # venous 0.6mm - bad # fname = '/home/tomas/Data/medical/liver_segmentation/org-exp_238_54280551_Abd_Venous_0.75_I26f_3-.pklz' debug = True verbose = True data_fname = '/home/tomas/Data/medical/liver_segmentation/org-exp_183_46324212_venous_5.0_B30f-.pklz' data, mask, voxel_size = tools.load_pickle_data(data_fname) slice_ind = 17 data_s = data[slice_ind, :, :] data_s = tools.windowing(data_s) mask_s = mask[slice_ind, :, :] # data_s = tools.windowing(data) # mask_s = mask run(data_s, mask=mask_s, smoothing=True, save_fig=False, show=True, verbose=verbose)
def load_CT_and_make_augmented(imgname, bounding_boxes, suffix='.pklz', transform_type="similarity", to_show=False, HNM=False, each_to_HNM = 1, config={}): """ Nacte CT a ulozi slice a pripadny bounding box """ print " Zpracovavam obrazek "+imgname data, gt_mask, voxel_size = tools.load_pickle_data(imgname) n_of_slices = data.shape[0] n_negative_slices = 0 suffix_len = len(suffix) transform_type=config["transform"] # Aplikace CT okenka: data = se.apply_CT_window(data)#, target_range=1.0, target_dtype=float) # Smycka pres kazdy rez for i in xrange(n_of_slices): print i, # vytahnuti rezu dat a masky data_slice_orig = data[i] mask_slice_orig = gt_mask[i] # pripadne vykresleni if to_show: se.show_image_in_new_figure(data_slice_orig) se.show_image_in_new_figure(mask_slice_orig) print np.unique(mask_slice_orig) # kazdy nekolikaty negativni rez dat do hard_negatives if HNM: orig_boxes = se.get_bounding_boxes(mask_slice_orig) if not (len(orig_boxes) >= 1): n_negative_slices += 1 if (n_negative_slices % each_to_HNM == 0): img_id = imgname[0:-suffix_len]+str("%03d" % int(i))+suffix #skimage.io.imsave("Negatives/"+imgname[0:-suffix_len]+str("%03d" % int(i))+".png", data_slice_orig) se.save_obj(data_slice_orig.astype("uint8"), "Augmented/Hard_negative_mining/"+img_id) se.save_obj(mask_slice_orig.astype("uint8"), "Masks/"+img_id) # Augmentace dat for data_slice, mask_slice, aug_label in augmented_data_generator(data_slice_orig, mask_slice_orig, transform=transform_type, config=config): # pripadne vykreslovani if to_show: se.show_image_in_new_figure(data_slice) se.show_image_in_new_figure(mask_slice) print np.unique(mask_slice) return False boxes = se.get_bounding_boxes(mask_slice) img_id = imgname[0:-suffix_len]+str("%03d" % int(i))+aug_label+suffix # pokud jsou nejake bounding boxy, mel by je vytahnout a obraz ulozit jako positives if len(boxes) >= 1: # Ulozeni bounding boxu bounding_boxes["datasets/processed/orig_images/"+img_id] = boxes # Ulozeni obrazku #skimage.io.imsave("Slices/"+imgname[0:-suffix_len]+str("%03d" % int(i))+".png", data_slice) se.save_obj(data_slice, "Augmented/Slices/"+img_id) # jinak je da mezi negatives else: # Ulozeni obrazku frame_id = 0 for data_to_save in se.liver_inside_only_generator(data_slice, mask_slice, fill_holes=False, metric='euclides'): # u normalnich davam taxicab if not data_to_save is None: #skimage.io.imsave("Negatives/"+imgname[0:-suffix_len]+str("%03d" % int(i))+".png", data_to_save) se.save_obj(data_to_save, "Augmented/Negatives/"+imgname[0:-suffix_len]+str("%03d" % int(i))+"#"+str("%03d" % int(frame_id))+aug_label+suffix) frame_id += 1 # ulozeni masky rezu se.save_obj(mask_slice.astype("uint8"), "Masks/"+img_id) print ""