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 ""
