def main():
logger = logging.getLogger()
logger.setLevel(logging.WARNING)
ch = logging.StreamHandler()
logger.addHandler(ch)
#logger.debug('input params')
data3d_a_path = None # os.path.join(path_to_script, '../../../data/medical/data_orig/sliver07/training-part1/liver-orig001.mhd')
data3d_b_path = None #os.path.join(path_to_script, '../../../data/medical/data_orig/sliver07/training-part1/liver-seg001.mhd')
parser = argparse.ArgumentParser(
description='Information about pkl/pklz file')
parser.add_argument('pklzFile', help='path to data')
args = parser.parse_args()
data = misc.obj_from_file(args.pklzFile, 'pickle')
print(data)
try:
pyed = sed3.sed3(data['data3d'], contour=data['segmentation'])
pyed.show()
except:
try:
pyed = sed3.sed3(data['data3d'])
pyed.show()
except:
print("Problem with visualization")
def _automatic_localization(self):
"""
Automatic localization made by Tomas Ryba.
"""
# seeds = self.get_seeds_using_class_1(class1)
liver = self.data3d * (self.segmentation != 0)
print('analyzing histogram...')
class1 = tools.analyse_histogram(self.data3d,
roi=self.segmentation != 0)
# sed3.sed3(self.data3d, seeds=class1).show()
print('getting seeds...')
seeds = self.get_seeds_using_prob_class1(
liver,
class1,
thresholdType='percOfMaxDist',
percT=0.3)
# sed3.sed3(self.data3d, seeds=seeds).show()
print('Starting random walker...')
rw = random_walker(liver, seeds, mode='cg_mg')
print('...finished.')
label_l = self.data['slab']['lesions']
lessions = rw == 2
sed3.sed3(self.data3d, contour=lessions).show()
lessions = self.filter_objects(lessions)
self.segmentation = np.where(lessions, label_l, self.segmentation)
def main():
logger = logging.getLogger()
logger.setLevel(logging.WARNING)
ch = logging.StreamHandler()
logger.addHandler(ch)
#logger.debug('input params')
data3d_a_path = None # os.path.join(path_to_script, '../../../data/medical/data_orig/sliver07/training-part1/liver-orig001.mhd')
data3d_b_path = None #os.path.join(path_to_script, '../../../data/medical/data_orig/sliver07/training-part1/liver-seg001.mhd')
parser = argparse.ArgumentParser(
description='Information about pkl/pklz file')
parser.add_argument('pklzFile',
help='path to data' )
args = parser.parse_args()
data = misc.obj_from_file(args.pklzFile, 'pickle')
print data
try:
pyed = sed3.sed3(data['data3d'], contour=data['segmentation'])
pyed.show()
except:
try:
pyed = sed3.sed3(data['data3d'])
pyed.show()
except:
print "Problem with visualization"
def _automatic_localization(self):
"""
Automatic localization made by Tomas Ryba.
"""
# seeds = self.get_seeds_using_class_1(class1)
liver = self.data3d * (self.segmentation != 0)
print('analyzing histogram...')
class1 = tools.analyse_histogram(self.data3d,
roi=self.segmentation != 0)
# sed3.sed3(self.data3d, seeds=class1).show()
print('getting seeds...')
seeds = self.get_seeds_using_prob_class1(liver,
class1,
thresholdType='percOfMaxDist',
percT=0.3)
# sed3.sed3(self.data3d, seeds=seeds).show()
print('Starting random walker...')
rw = random_walker(liver, seeds, mode='cg_mg')
print('...finished.')
label_l = self.data['slab']['lesions']
lessions = rw == 2
sed3.sed3(self.data3d, contour=lessions).show()
lessions = self.filter_objects(lessions)
self.segmentation = np.where(lessions, label_l, self.segmentation)
def main():
# logger = logging.getLogger()
logger.setLevel(logging.WARNING)
ch = logging.StreamHandler()
logger.addHandler(ch)
# logger.debug('input params')
# input parser
parser = argparse.ArgumentParser(
description='Module for segmentation of simple anatomical structures')
parser.add_argument('-i',
'--inputfile',
default='vessels.pkl',
help='path to data dir')
# args = parser.parse_args()
# horsi kvalita segmentace
# datapath = os.path.join(path_to_script, "../vessels1.pkl")
# hypodenzni meta
# datapath = os.path.join(path_to_script, args.inputfile)
# horsi kvalita segmentace
# datapath = os.path.join(path_to_script, "../organ.pkl")
# data = misc.obj_from_file(args.inputfile, filetype = 'pickle')
dcmdir = '/home/tomas/Dropbox/Work/Data/medical/org-38289898-export1.pklz'
data = misc.obj_from_file(dcmdir, filetype='pickle')
# windowing
data['data3d'] = tools.windowing(data['data3d'], level=50, width=350)
# data['data3d'] = smoothing(data['data3d'], sliceId=0)
# smoothing ----------------
# bilateral
# data['data3d'] = tools.smoothing_bilateral(data['data3d'],
# sigma_space=15, sigma_color=0.05, sliceId=0)
# more bilateral
# data['data3d'] = tools.smoothing_bilateral(data['data3d'],
# sigma_space=15, sigma_color=0.1, sliceId=0)
# total-variation
data['data3d'] = tools.smoothing_tv(data['data3d'], weight=0.05, sliceId=0)
# more total-variation
# data['data3d'] = tools.smoothing_tv(data['data3d'], weight=0.2,
# multichannel=False, sliceId=0)
# sed3.sed3(data['data3d']).show()
tumory = Lesions()
# tumory.overlay_test()
tumory.import_data(data)
tumory.automatic_localization()
tumors = tumory.segmentation == tumory.data['slab']['lesions']
sed3.sed3(tumory.data3d, contour=tumors).show()
def GetMaskForLiversSegmentation(image):
# arrayImage = np.array(sitk.GetArrayFromImage(image))
caster = sitk.CastImageFilter()
caster.SetOutputPixelType(sitk.sitkUInt8)
image = caster.Execute(image)
ed = sed3.sed3(image)
ed.show()
allSeeds = np.where(ed.seeds > 0)
seeds = []
for i in range(len(allSeeds[0])):
p = (int(allSeeds[0][i]), int(allSeeds[1][i]), int(allSeeds[2][i]))
seeds.append(p)
# print image.GetSize()
# max1 = 0
# min1 = image.GetSize()[0]
# max2 = 0
# min2 = image.GetSize()[1]
# max3 = 0
# min3 = image.GetSize()[2]
# for seed in allSeeds:
# if seed[0] > max1:
# max1 = seed[0]
# if seed[0] < min1:
# min1 = seed[0]
# if seed[1] > max2:
# max2 = seed[1]
# if seed[1] < min2:
# min2 = seed[1]
# if seed[2] > max3:
# max3 = seed[2]
# if seed[2] < min3:
# min3 = seed[2]
# imgRes = sitk.GetImageFromArray(sitk.Cast(image, sitk.sitkUInt32))[min1:max1][min2:max2][min3:max3]
print 'Region grow segmentation'
regionGrow = sitk.ConnectedThreshold(image,
seedList=seeds,
lower=50,
upper=220)
# regionGrow = sitk.ConnectedThreshold(sitk.Cast(image,sitk.sitkUInt8),
# seedList=seeds,
# lower=50, upper=220)
writer = sitk.ImageFileWriter()
outputDirPath = 'C:/Users/duso/PycharmProjects/Semestralni_Prace/Registration/Frangis/RegistrationTests/test/Filters_'
writer.SetFileName(outputDirPath + 'liversMaskTest.nrrd')
writer.Execute(regionGrow)
print 'Region grow segmentation done'
ed = sed3.sed3(sitk.RescaleIntensity(regionGrow))
ed.show()
def main():
logger = logging.getLogger()
logger.setLevel(logging.WARNING)
ch = logging.StreamHandler()
logger.addHandler(ch)
# logger.debug('input params')
# input parser
parser = argparse.ArgumentParser(
description='Module for segmentation of simple anatomical structures')
parser.add_argument('-i', '--inputfile', default='vessels.pkl',
help='path to data dir')
# args = parser.parse_args()
# horsi kvalita segmentace
# datapath = os.path.join(path_to_script, "../vessels1.pkl")
# hypodenzni meta
# datapath = os.path.join(path_to_script, args.inputfile)
# horsi kvalita segmentace
# datapath = os.path.join(path_to_script, "../organ.pkl")
# data = misc.obj_from_file(args.inputfile, filetype = 'pickle')
dcmdir = '/home/tomas/Dropbox/Work/Data/medical/org-38289898-export1.pklz'
data = misc.obj_from_file(dcmdir, filetype='pickle')
# windowing
data['data3d'] = tools.windowing(data['data3d'], level=50, width=350)
# data['data3d'] = smoothing(data['data3d'], sliceId=0)
# smoothing ----------------
# bilateral
# data['data3d'] = tools.smoothing_bilateral(data['data3d'],
# sigma_space=15, sigma_color=0.05, sliceId=0)
# more bilateral
# data['data3d'] = tools.smoothing_bilateral(data['data3d'],
# sigma_space=15, sigma_color=0.1, sliceId=0)
# total-variation
data['data3d'] = tools.smoothing_tv(data['data3d'], weight=0.05, sliceId=0)
# more total-variation
# data['data3d'] = tools.smoothing_tv(data['data3d'], weight=0.2,
# multichannel=False, sliceId=0)
# sed3.sed3(data['data3d']).show()
tumory = Lesions()
# tumory.overlay_test()
tumory.import_data(data)
tumory.automatic_localization()
tumors = tumory.segmentation == tumory.data['slab']['lesions']
sed3.sed3(tumory.data3d, contour=tumors).show()
def show(data3d_a_path, sliver_seg_path, ourSegmentation):
reader = datareader.DataReader()
#data3d_a_path = os.path.join(path_to_script, data3d_a_path)
datap_a = reader.Get3DData(data3d_a_path,
dataplus_format=True)
if 'orig_shape' in datap_a.keys():
# pklz
data3d_a = qmisc.uncrop(datap_a['data3d'], datap_a['crinfo'],
datap_a['orig_shape'])
else:
#dicom
data3d_a = datap_a['data3d']
if sliver_seg_path is not None:
sliver_seg_path = os.path.join(path_to_script, sliver_seg_path)
sliver_datap = reader.Get3DData(sliver_seg_path,
dataplus_format=True)
if 'segmentation' in sliver_datap.keys():
sliver_seg = sliver_datap['segmentation']
sliver_seg = qmisc.uncrop(sliver_datap['segmentation'],
sliver_datap['crinfo'],
data3d_a.shape)
else:
sliver_seg = sliver_datap['data3d']
pyed = sed3.sed3(data3d_a, contour=sliver_seg)
print "Sliver07 segmentation"
pyed.show()
if ourSegmentation != None:
ourSegmentation = os.path.join(path_to_script, ourSegmentation)
datap_our = reader.Get3DData(ourSegmentation, dataplus_format=True)
#data_our = misc.obj_from_file(ourSegmentation, 'pickle')
#data3d_our = data_our['segmentation']
our_seg = qmisc.uncrop(datap_our['segmentation'], datap_our['crinfo'],
data3d_a.shape)
if ourSegmentation != None:
pyed = sed3.sed3(data3d_a, contour=our_seg)
print "Our segmentation"
pyed.show()
if (ourSegmentation is not None) and (sliver_seg_path is not None):
diff = (our_seg.astype(np.int8) - sliver_seg)
diff[diff==-1] = 2
#import ipdb; ipdb.set_trace() # BREAKPOINT
pyed = sed3.sed3(data3d_a, contour=our_seg,
seeds=diff)
print "Sliver07 and our segmentation differences"
pyed.show()
def annotate2(number_of_scans): #annotation starting from scan 1
'''
Annotate the data form our medical dataset, starting from scan 1, up to scan passed in param.
Save the labels to an excel file 'tabulka2.xlsx'.
'''
df = pd.DataFrame(columns=[
'ID', 'Mark 1 slice id', 'Mark 2 slice id', 'Mark 3 slice id',
'Mark 4 slice id'
])
for i in range(number_of_scans):
print(f'Showing scan n. {str(i+1).zfill(2)}')
dr = io3d.DataReader()
datap = dr.Get3DData(
f'data/medical/orig/sliver07/training/liver-orig0{str(i+1).zfill(2)}.mhd',
dataplus_format=True)
ed = sed3.sed3(datap['data3d'][::-1, :, :], windowW=400, windowC=40)
ed.show()
nz = np.nonzero(ed.seeds)
ids = np.unique(nz[0])
df = df.append(
{
'ID': i + 1,
'Mark 1 slice id': ids[0],
'Mark 2 slice id': ids[1],
'Mark 3 slice id': ids[2],
'Mark 4 slice id': ids[3]
},
ignore_index=True)
df.to_excel('tabulka2.xlsx', sheet_name='List1', index=False)
def main():
parser = argparse.ArgumentParser(
description='data3dviewer - Viewer for 3d data (mostly from CT)')
parser.add_argument('path', help='Path to directory with 3d data')
parser.add_argument('-d',
'--debug',
action='store_true',
help='Debug mode')
args = parser.parse_args()
logging.basicConfig(stream=sys.stdout)
logger = logging.getLogger()
logger.setLevel(logging.WARNING)
if args.debug:
logger.setLevel(logging.DEBUG)
# load dicom data
logger.info("Loading 3d data from: %s" % os.path.abspath(args.path))
datap = io3d.read(os.path.abspath(args.path), dataplus_format=True)
data3d = datap["data3d"]
logger.info("voxelsize: %s" % str(datap["voxelsize_mm"]))
# temporary fix for io3d <-512;511> value range bug
# this is caused by hardcoded slope 0.5 in dcmreader
if np.min(data3d) >= -512: data3d = data3d * 2
# display data
ed = sed3.sed3(data3d)
ed.show()
def main():
# logger = logging.getLogger()
logger.setLevel(logging.WARNING)
ch = logging.StreamHandler()
logger.addHandler(ch)
#logger.debug('input params')
# input parser
parser = argparse.ArgumentParser(
description='Module for segmentation of simple anatomical structures')
parser.add_argument('-i',
'--inputfile',
default='organ.pkl',
help='path to data dir')
args = parser.parse_args()
data = misc.obj_from_file(args.inputfile, filetype='pickle')
data3d = data['data3d']
voxelsize_mm = data['voxelsize_mm']
ss = SimpleSegmentation()
simple_seg = ss.simple_segmentation(data3d, voxelsize_mm)
#visualization
pyed = sed3.sed3(data['data3d'], seeds=simple_seg)
pyed.show()
# save
savestring = raw_input('Save output data? (y/n): ')
if savestring in ['Y', 'y']:
misc.obj_to_file(data, "resection.pkl", filetype='pickle')
def main():
logger = logging.getLogger()
logger.setLevel(logging.WARNING)
ch = logging.StreamHandler()
logger.addHandler(ch)
#logger.debug('input params')
# input parser
parser = argparse.ArgumentParser(
description='Module for segmentation of simple anatomical structures')
parser.add_argument('-i', '--inputfile',
default='organ.pkl',
help='path to data dir')
args = parser.parse_args()
data = misc.obj_from_file(args.inputfile, filetype = 'pickle')
data3d = data['data3d']
voxelsize_mm = data['voxelsize_mm']
ss = SimpleSegmentation()
simple_seg = ss.simple_segmentation(data3d, voxelsize_mm)
#visualization
pyed = sed3.sed3(data['data3d'], seeds=simple_seg)
pyed.show()
# save
savestring = raw_input('Save output data? (y/n): ')
if savestring in ['Y', 'y']:
misc.obj_to_file(data, "resection.pkl", filetype='pickle')
def compareSegmentationWithFile(self):
"""
Function make GUI for reading segmentaion file to compare it with
actual segmentation using Sliver methodics. It calls
organ_segmentation function to do the work.
"""
self.statusBar().showMessage("Reading segmentation from file ...")
QApplication.processEvents()
logger.debug("import segmentation from file to compare by sliver")
logger.debug(str(self.oseg.crinfo))
logger.debug(str(self.oseg.data3d.shape))
logger.debug(str(self.oseg.segmentation.shape))
seg_path = self.__get_datafile(app=True, directory=self.oseg.input_datapath_start)
if seg_path is None:
self.statusBar().showMessage("No data path specified!")
return
evaluation, score, segdiff = self.oseg.sliver_compare_with_other_volume_from_file(seg_path)
print "Evaluation: ", evaluation
print "Score: ", score
text = self.__evaluation_to_text(score)
segdiff[segdiff == -1] = 2
logger.debug("segdif unique " + str(np.unique(segdiff)))
QApplication.processEvents()
ed = sed3.sed3(self.oseg.data3d, seeds=segdiff, contour=(self.oseg.segmentation == self.oseg.slab["liver"]))
ed.show()
self.setLabelText(self.text_seg_data, text)
self.statusBar().showMessage("Ready")
def one_experiment_setting_for_whole_dataset(inputdata,
tile_shape,
feature_fcn,
classif_fcn,
train,
visualization=False):
fvall = []
fv_tiles = []
indata_len = len(inputdata['data'])
indata_len = 3
for i in range(0, indata_len):
data3d_orig, data3d_seg = read_data_orig_and_seg(inputdata, i)
feat_hist_by_segmentation(data3d_orig, data3d_seg, visualization)
if visualization:
pyed = sed3.sed3(data3d_orig, contour=data3d_seg)
pyed.show()
#import pdb; pdb.set_trace()
#fvall.insert(i, get_features(
# data3d_orig,
#ltl = (labels_train_lin_float * 10).astype(np.int8)
#labels_train = arrange_to_tiled_data(cidxs, tile_shape,
# d_shp, ltl)
#pyed = sed3.sed3(labels_train, contour=labels)
# @TODO vracet něco inteligentního, fvall je prázdný
return fvall
def main():
main_logger = logging.getLogger()
main_logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
main_logger.addHandler(ch)
# input parser
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('-i', '--inputfile',
default=None,
required=True,
help='input file')
parser.add_argument('-sn', '--seriesnumber',
default=None,
help='seriesnumber')
parser.add_argument('-d', '--debug',
action='store_true',
help='Debug mode')
args = parser.parse_args()
if args.debug:
ch.setLevel(logging.DEBUG)
data3d, metadata = read(args.inputfile,
series_number=args.seriesnumber,
dataplus_format=False)
import sed3
ed = sed3.sed3(data3d)
ed.show()
def main():
main_logger = logging.getLogger()
main_logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
main_logger.addHandler(ch)
# input parser
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('-i',
'--inputfile',
default=None,
required=True,
help='input file')
parser.add_argument('-sn',
'--seriesnumber',
default=None,
help='seriesnumber')
parser.add_argument('-d',
'--debug',
action='store_true',
help='Debug mode')
args = parser.parse_args()
if args.debug:
ch.setLevel(logging.DEBUG)
data3d, metadata = read(args.inputfile,
series_number=args.seriesnumber,
dataplus_format=False)
import sed3
ed = sed3.sed3(data3d)
ed.show()
def test_split_organ_segmentation_recursive(self):
import lisa.organ_segmentation
import io3d
# datap = io3d.datasets.generate_abdominal()
datap = io3d.datasets.generate_synthetic_liver(return_dataplus=True)
slab = datap["slab"]
oseg = lisa.organ_segmentation.OrganSegmentation()
oseg.import_dataplus(datap)
oseg.label_volumetric_vessel_tree("porta")
labeled_branches = oseg.segmentation
seeds = np.zeros_like(oseg.data3d, dtype=np.int)
seeds[40, 122:126, 165:168] = 1
seeds[40, 144:148, 131:133] = 2
seeds[40, 122:126, 114:117] = 2
seeds[40, 90:95, 103:106] = 3
seeds[40, 122:126, 84:88] = 3
# import sed3
# ed = sed3.sed3(datap["data3d"], contour=datap["segmentation"], seeds=seeds)
# ed.show()
split_labels_out, connected = oseg.split_tissue_recusively_with_labeled_volumetric_vessel_tree(
"liver", seeds)
# labeled_branches = lisa.virtual_resection.branch_labels(oseg, "porta")
data3d = datap["data3d"]
segmentation = datap["segmentation"]
organ_label = "liver"
import sed3
# ed = sed3.sed3(labeled_branches, contour=organ_split)
ed = sed3.sed3(split_labels_out)
ed.show()
self.assertGreater(np.sum(oseg.select_label("split1")), 1000)
self.assertGreater(np.sum(oseg.select_label("split2")), 1000)
def one_experiment_setting_for_whole_dataset(
inputdata, tile_shape, feature_fcn, classif_fcn, train, visualization=False
):
fvall = []
fv_tiles = []
indata_len = len(inputdata["data"])
indata_len = 3
for i in range(0, indata_len):
data3d_orig, data3d_seg = read_data_orig_and_seg(inputdata, i)
feat_hist_by_segmentation(data3d_orig, data3d_seg, visualization)
if visualization:
pyed = sed3.sed3(data3d_orig, contour=data3d_seg)
pyed.show()
# import pdb; pdb.set_trace()
# fvall.insert(i, get_features(
# data3d_orig,
# ltl = (labels_train_lin_float * 10).astype(np.int8)
# labels_train = arrange_to_tiled_data(cidxs, tile_shape,
# d_shp, ltl)
# pyed = sed3.sed3(labels_train, contour=labels)
# @TODO vracet něco inteligentního, fvall je prázdný
return fvall
def show(data3d_a_path, sliver_seg_path, ourSegmentation):
reader = datareader.DataReader()
#data3d_a_path = os.path.join(path_to_script, data3d_a_path)
datap_a = reader.Get3DData(data3d_a_path, dataplus_format=True)
if 'orig_shape' in datap_a.keys():
# pklz
data3d_a = qmisc.uncrop(datap_a['data3d'], datap_a['crinfo'],
datap_a['orig_shape'])
else:
#dicom
data3d_a = datap_a['data3d']
if sliver_seg_path is not None:
sliver_seg_path = os.path.join(path_to_script, sliver_seg_path)
sliver_datap = reader.Get3DData(sliver_seg_path, dataplus_format=True)
if 'segmentation' in sliver_datap.keys():
sliver_seg = sliver_datap['segmentation']
sliver_seg = qmisc.uncrop(sliver_datap['segmentation'],
sliver_datap['crinfo'], data3d_a.shape)
else:
sliver_seg = sliver_datap['data3d']
pyed = sed3.sed3(data3d_a, contour=sliver_seg)
print("Sliver07 segmentation")
pyed.show()
if ourSegmentation != None:
ourSegmentation = os.path.join(path_to_script, ourSegmentation)
datap_our = reader.Get3DData(ourSegmentation, dataplus_format=True)
#data_our = misc.obj_from_file(ourSegmentation, 'pickle')
#data3d_our = data_our['segmentation']
our_seg = qmisc.uncrop(datap_our['segmentation'], datap_our['crinfo'],
data3d_a.shape)
if ourSegmentation != None:
pyed = sed3.sed3(data3d_a, contour=our_seg)
print("Our segmentation")
pyed.show()
if (ourSegmentation is not None) and (sliver_seg_path is not None):
diff = (our_seg.astype(np.int8) - sliver_seg)
diff[diff == -1] = 2
#import ipdb; ipdb.set_trace() # BREAKPOINT
pyed = sed3.sed3(data3d_a, contour=our_seg, seeds=diff)
print("Sliver07 and our segmentation differences")
pyed.show()
def resection(data):
#pyed = sed3.sed3(data['segmentation'])
#pyed.show()
# vessels = get_biggest_object(data['segmentation'] == data['slab']['porta'])
vessels = data['segmentation'] == data['slab']['porta']
# ostranění porty z více kusů, nastaví se jim hodnota liver
#data['segmentation'][data['segmentation'] == data['slab']['porta']] = data['slab']['liver']
#show3.show3(data['segmentation'])
import pdb
pdb.set_trace()
#data['segmentation'][vessels == 1] = data['slab']['porta']
#segm = data['segmentation']
#pyed = sed3.sed3(vessels)
#pyed.show()
print("Select cut")
lab = virtual_resection.cut_editor_old(data)
pyed = sed3.sed3(lab) #, contour=segm)
pyed.show()
l1 = 1
l2 = 2
#import pdb; pdb.set_trace()
# dist se tady počítá od nul jenom v jedničkách
dist1 = scipy.ndimage.distance_transform_edt(lab != l1)
dist2 = scipy.ndimage.distance_transform_edt(lab != l2)
#segm = (dist1 < dist2) * (data['segmentation'] != data['slab']['none'])
segm = (((data['segmentation'] != 0) * (dist1 < dist2)).astype('int8') +
(data['segmentation'] != 0).astype('int8'))
# vizualizace 1
# pyed = sed3.sed3(segm)
# pyed.show()
# import pdb; pdb.set_trace()
# pyed = sed3.sed3(data['data3d'], contour=segm)
# pyed.show()
# import pdb; pdb.set_trace()
# vizualizace 2
linie = np.abs(dist1 - dist2) < 1
pyed = sed3.sed3(data['data3d'],
contour=data['segmentation'] == data['slab']['liver'],
seeds=linie)
pyed.show()
def resection(data):
#pyed = sed3.sed3(data['segmentation'])
#pyed.show()
# vessels = get_biggest_object(data['segmentation'] == data['slab']['porta'])
vessels = data['segmentation'] == data['slab']['porta']
# ostranění porty z více kusů, nastaví se jim hodnota liver
#data['segmentation'][data['segmentation'] == data['slab']['porta']] = data['slab']['liver']
#show3.show3(data['segmentation'])
import pdb; pdb.set_trace()
#data['segmentation'][vessels == 1] = data['slab']['porta']
#segm = data['segmentation']
#pyed = sed3.sed3(vessels)
#pyed.show()
print ("Select cut")
lab = virtual_resection.cut_editor_old(data)
pyed = sed3.sed3(lab )#, contour=segm)
pyed.show()
l1 = 1
l2 = 2
#import pdb; pdb.set_trace()
# dist se tady počítá od nul jenom v jedničkách
dist1 = scipy.ndimage.distance_transform_edt(lab != l1)
dist2 = scipy.ndimage.distance_transform_edt(lab != l2)
#segm = (dist1 < dist2) * (data['segmentation'] != data['slab']['none'])
segm = (((data['segmentation'] != 0) * (dist1 < dist2)).astype('int8') + (data['segmentation'] != 0).astype('int8'))
# vizualizace 1
# pyed = sed3.sed3(segm)
# pyed.show()
# import pdb; pdb.set_trace()
# pyed = sed3.sed3(data['data3d'], contour=segm)
# pyed.show()
# import pdb; pdb.set_trace()
# vizualizace 2
linie = np.abs(dist1 - dist2) < 1
pyed = sed3.sed3(data['data3d'], contour = data['segmentation']==data['slab']['liver'] ,seeds = linie)
pyed.show()
def compareSegmentationWithFile(self):
"""
Function make GUI for reading segmentaion file to compare it with
actual segmentation using Sliver methodics. It calls
organ_segmentation function to do the work.
"""
self.statusBar().showMessage('Reading segmentation from file ...')
QApplication.processEvents()
logger.debug("import segmentation from file to compare by sliver")
logger.debug(str(self.oseg.crinfo))
logger.debug(str(self.oseg.data3d.shape))
logger.debug(str(self.oseg.segmentation.shape))
if 'loadcomparedir' in self.oseg.cache.data.keys():
directory = self.oseg.cache.get('loadcomparedir')
else:
directory = self.oseg.input_datapath_start
#
seg_path = self.__get_datafile(
app=True,
directory=directory
)
if seg_path is None:
self.statusBar().showMessage('No data path specified!')
return
evaluation, segdiff = \
self.oseg.sliver_compare_with_other_volume_from_file(seg_path)
print 'Evaluation: ', evaluation
# print 'Score: ', score
text = self.__evaluation_to_text(evaluation)
segdiff[segdiff == -1] = 2
logger.debug('segdif unique ' + str(np.unique(segdiff)))
QApplication.processEvents()
try:
ed = sed3.sed3qt(
self.oseg.data3d,
seeds=segdiff,
# contour=(self.oseg.segmentation == self.oseg.slab['liver'])
contour=self.oseg.segmentation
)
ed.exec_()
except:
ed = sed3.sed3(
self.oseg.data3d,
seeds=segdiff,
contour=(self.oseg.segmentation == self.oseg.slab['liver'])
)
ed.show()
head, teil = os.path.split(seg_path)
self.oseg.cache.update('loadcompatext_seg_dataredir', head)
self.setLabelText(self.segBody.lblSegData, text)
self.statusBar().showMessage('Ready')
def compareSegmentationWithFile(self):
"""
Function make GUI for reading segmentaion file to compare it with
actual segmentation using Sliver methodics. It calls
organ_segmentation function to do the work.
"""
self.statusBar().showMessage('Reading segmentation from file ...')
QApplication.processEvents()
logger.debug("import segmentation from file to compare by sliver")
logger.debug(str(self.oseg.crinfo))
logger.debug(str(self.oseg.data3d.shape))
logger.debug(str(self.oseg.segmentation.shape))
if 'loadcomparedir' in self.oseg.cache.data.keys():
directory = self.oseg.cache.get('loadcomparedir')
else:
directory = self.oseg.input_datapath_start
#
seg_path = self.__get_datafile(
app=True,
directory=directory
)
if seg_path is None:
self.statusBar().showMessage('No data path specified!')
return
evaluation, segdiff = \
self.oseg.sliver_compare_with_other_volume_from_file(seg_path)
print 'Evaluation: ', evaluation
# print 'Score: ', score
text = self.__evaluation_to_text(evaluation)
segdiff[segdiff == -1] = 2
logger.debug('segdif unique ' + str(np.unique(segdiff)))
QApplication.processEvents()
try:
ed = sed3.sed3qt(
self.oseg.data3d,
seeds=segdiff,
# contour=(self.oseg.segmentation == self.oseg.slab['liver'])
contour=self.oseg.segmentation
)
ed.exec_()
except:
ed = sed3.sed3(
self.oseg.data3d,
seeds=segdiff,
contour=(self.oseg.segmentation == self.oseg.slab['liver'])
)
ed.show()
head, teil = os.path.split(seg_path)
self.oseg.cache.update('loadcomparedir', head)
# self.setLabelText(self.text_seg_data, text)
self.statusBar().showMessage('Ready')
def virtual_resection_visualization(data, segm, dist1, dist2, cut,
interactivity=True):
v1, v2 = liver_spit_volume_mm3(segm, data['voxelsize_mm'])
if interactivity:
print "Liver volume: %.4g l" % ((v1 + v2) * 1e-6)
print "volume1: %.4g l (%.3g %%)" % (
(v1) * 1e-6, 100 * v1 / (v1 + v2))
print "volume2: %.4g l (%.3g %%)" % (
(v2) * 1e-6, 100 * v2 / (v1 + v2))
# pyed = sed3.sed3(segm)
# pyed.show()
# import pdb; pdb.set_trace()
linie = (((data['segmentation'] != 0) *
(np.abs(dist1 - dist2) < 1))).astype(np.int8)
linie_vis = 2 * linie
linie_vis[cut == 1] = 1
linie_vis = linie_vis.astype(np.int8)
if interactivity:
pyed = sed3.sed3(
data['data3d'],
seeds=linie_vis,
contour=(data['segmentation'] != 0))
pyed.show()
# import pdb; pdb.set_trace()
# show3.show3(data['segmentation'])
slab = {
'liver': 1,
'porta': 2,
'resected_liver': 3,
'resected_porta': 4}
slab.update(data['slab'])
data['slab'] = slab
data['slab']['resected_liver'] = 3
data['slab']['resected_porta'] = 4
mask_resected_liver = (
(segm == 1) & (data['segmentation'] == data['slab']['liver']))
mask_resected_porta = (
(segm == 1) & (data['segmentation'] == data['slab']['porta']))
data['segmentation'][mask_resected_liver] = \
data['slab']['resected_liver']
data['segmentation'][mask_resected_porta] = \
data['slab']['resected_porta']
logger.debug('resection_old() end')
return data
def test_interactive_test(self):
import sed3
import numpy as np
img = np.zeros([10, 10, 15])
img[6:9, 2:7, 1:5] = 1
img[7:9, 3:9, 8:14] = 2
ed = sed3.sed3(img)
ed.show()
print(ed.seeds)
def test_run_without_show(self):
import sed3
import numpy as np
img = np.zeros([10, 10, 15])
img[6:9, 2:7, 1:5] = 1
img[7:9, 3:9, 8:14] = 2
ed = sed3.sed3(img)
# ed.show()
print(ed.seeds)
def test_interactive_test(self):
import sed3
import numpy as np
img = np.zeros([10, 10, 15])
img[6:9, 2:7, 1:5] = 1
img[7:9, 3:9, 8:14] = 2
ed = sed3.sed3(img)
ed.show()
print(ed.seeds)
def test_run_without_show(self):
import sed3
import numpy as np
img = np.zeros([10, 10, 15])
img[6:9, 2:7, 1:5] = 1
img[7:9, 3:9, 8:14] = 2
ed = sed3.sed3(img)
# ed.show()
print(ed.seeds)
def buttonClicked(self):
print("button")
import sed3
import numpy as np
img = np.zeros([10, 10, 15])
img[6:9, 2:7, 1:5] = 1
img[7:9, 3:9, 8:14] = 2
ed = sed3.sed3(img)
ed.show()
print("konec sed3")
def annotate(number_of_scans): #annotation starting from scan 1
'''
Annotate the data form 3DIrcad1 dataset, starting from scan 1, up to scan passed in param.
Save the labels to an excel file 'tabulka.xlsx'.
'''
df = pd.DataFrame(columns=[
'Ircad ID', 'Mark 1 slice id', 'Mark 2 slice id', 'Mark 3 slice id',
'Mark 4 slice id'
])
for i in range(number_of_scans):
dr = io3d.DataReader()
pth = io3d.datasets.join_path('medical/orig/3Dircadb1.{}/'.format(i +
1),
get_root=True)
datap = dr.Get3DData(pth + "PATIENT_DICOM/", dataplus_format=True)
datap_labelled = dr.Get3DData(pth + 'MASKS_DICOM/liver',
dataplus_format=True)
ed = sed3.sed3(datap['data3d'],
contour=datap_labelled['data3d'],
windowW=400,
windowC=40)
ed.show()
nz = np.nonzero(ed.seeds)
ids = np.unique(nz[0])
order = input("Did liver end before kidney started? (y/n)")
if order == "y":
df = df.append(
{
'Ircad ID': i + 1,
'Mark 1 slice id': ids[0],
'Mark 2 slice id': ids[1],
'Mark 3 slice id': ids[2],
'Mark 4 slice id': ids[3]
},
ignore_index=True)
elif order == "n":
df = df.append(
{
'Ircad ID': i + 1,
'Mark 1 slice id': ids[0],
'Mark 2 slice id': ids[2],
'Mark 3 slice id': ids[1],
'Mark 4 slice id': ids[3]
},
ignore_index=True)
else:
print("ERROR")
break
df.to_excel('tabulka.xlsx', sheet_name='List1', index=False)
def one_exp_set_training(inputdata,
tile_shape,
feature_fcn_plus_params,
classif_fcn_plus_params,
use_voxelsize_norm=False,
working_voxelsize_mm=[1, 1, 1],
visualization=False):
"""
Training of experiment.
"""
features_t_all = []
labels_train_lin_all = []
indata_len = len(inputdata['data'])
features_t_all = []
# indata_len = 3
classif_fcn, classif_fcn_params = classif_fcn_plus_params
logger.debug('number of data files ' + str(indata_len))
for i in range(0, indata_len):
data3d_orig, data3d_seg, voxelsize_mm = read_data_orig_and_seg(
inputdata, i)
if use_voxelsize_norm:
data3d_orig, data3d_seg = norm_voxelsize(data3d_orig, data3d_seg,
voxelsize_mm,
working_voxelsize_mm)
if visualization:
pyed = sed3.sed3(data3d_orig, contour=data3d_seg)
pyed.show()
logger.debug('data shape ' + str(data3d_orig.shape))
fv_t = get_features_in_tiles(data3d_orig, data3d_seg, tile_shape,
feature_fcn_plus_params[0],
feature_fcn_plus_params[1])
cidxs, features_t, seg_cover_t = fv_t
labels_train_lin_float = np.array(seg_cover_t)
labels_train_lin = (labels_train_lin_float > 0.5).astype(
np.int8).tolist()
features_t_all = features_t_all + features_t
labels_train_lin_all = labels_train_lin_all + labels_train_lin
# if there are named variables use dict unpacking
if isinstance(classif_fcn_params, dict):
clf = classif_fcn(**classif_fcn_params)
else:
clf = classif_fcn(*classif_fcn_params)
clf.fit(features_t_all, labels_train_lin_all)
# import ipdb; ipdb.set_trace() # noqa BREAKPOINT
return clf
def one_exp_set_training(inputdata, tile_shape,
feature_fcn_plus_params,
classif_fcn_plus_params,
use_voxelsize_norm=False,
working_voxelsize_mm=[1, 1, 1],
visualization=False):
"""
Training of experiment.
"""
features_t_all = []
labels_train_lin_all = []
indata_len = len(inputdata['data'])
features_t_all = []
# indata_len = 3
classif_fcn, classif_fcn_params = classif_fcn_plus_params
logger.debug('number of data files ' + str(indata_len))
for i in range(0, indata_len):
data3d_orig, data3d_seg, voxelsize_mm = read_data_orig_and_seg(
inputdata, i)
if use_voxelsize_norm:
data3d_orig, data3d_seg = norm_voxelsize(
data3d_orig, data3d_seg,
voxelsize_mm, working_voxelsize_mm)
if visualization:
pyed = sed3.sed3(data3d_orig,
contour=data3d_seg)
pyed.show()
logger.debug('data shape ' + str(data3d_orig.shape))
fv_t = get_features_in_tiles(data3d_orig, data3d_seg, tile_shape,
feature_fcn_plus_params[0],
feature_fcn_plus_params[1])
cidxs, features_t, seg_cover_t = fv_t
labels_train_lin_float = np.array(seg_cover_t)
labels_train_lin = (
labels_train_lin_float > 0.5).astype(np.int8).tolist()
features_t_all = features_t_all + features_t
labels_train_lin_all = labels_train_lin_all + labels_train_lin
# if there are named variables use dict unpacking
if isinstance(classif_fcn_params, dict):
clf = classif_fcn(**classif_fcn_params)
else:
clf = classif_fcn(*classif_fcn_params)
clf.fit(features_t_all, labels_train_lin_all)
# import ipdb; ipdb.set_trace() # noqa BREAKPOINT
return clf
def test_ms_seg(self):
"""
Test multiscale segmentation
"""
img, seg, seeds = self.make_data(64, 20)
segparams = {
# 'method':'graphcut',
'method':'multiscale_graphcut',
'use_boundary_penalties': False,
'boundary_dilatation_distance': 2,
'boundary_penalties_weight': 1,
'block_size': 8,
'tile_zoom_constant': 1
}
gc = pycut.ImageGraphCut(img, segparams=segparams)
gc.set_seeds(seeds)
gc.run()
# import sed3
# ed = sed3.sed3(gc.segmentation==0, contour=seg)
# ed.show()
self.assertLess(
np.sum(
np.abs(
(gc.segmentation == 0).astype(np.int8) -
seg.astype(np.int8))
)
, 600)
# different resolution
# sz = [128,128,128]
sz = [70,70,70]
sz = [90,90,90]
sz = [100,100,100]
sz = [200,200,200]
sz1 = 208
sz = [sz1, sz1, sz1]
img2 = pycut.zoom_to_shape(img, sz, np.uint8)
seg2 = pycut.zoom_to_shape(seg, sz, np.uint8)
seeds2 = pycut.zoom_to_shape(seeds, sz, np.int8)
segparams['tile_zoom_constant'] = 0.8
gc = pycut.ImageGraphCut(img2, segparams=segparams)
gc.set_seeds(seeds2)
gc.run()
import sed3
ed = sed3.sed3(gc.segmentation==0, contour=seg2)
ed.show()
def test_branch_labels_just_in_module(self):
import lisa.organ_segmentation
import io3d
# datap = io3d.datasets.generate_abdominal()
datap = io3d.datasets.generate_synthetic_liver(return_dataplus=True)
oseg = lisa.organ_segmentation.OrganSegmentation()
oseg.import_dataplus(datap)
bl = lisa.virtual_resection.label_volumetric_vessel_tree(oseg, "porta")
import sed3
ed = sed3.sed3(bl, contour=datap["segmentation"])
ed.show()
self.assertEqual(True, True)
def test_branch_labels_from_oseg(self):
import lisa.organ_segmentation
import io3d
# datap = io3d.datasets.generate_abdominal()
datap = io3d.datasets.generate_synthetic_liver(return_dataplus=True)
oseg = lisa.organ_segmentation.OrganSegmentation()
oseg.import_dataplus(datap)
oseg.label_volumetric_vessel_tree("porta")
import sed3
ed = sed3.sed3(oseg.segmentation)
ed.show()
self.assertEqual(True, True)
def read_bin_file(self, filename, bitsperblock=8):
bytesperblock = bitsperblock / 8
if bytesperblock == 2:
dtype = np.uint16
else:
logger.error("Unknown data type")
data = np.fromfile(filename, dtype=np.uint8)
shape = [1024, 1024, 10]
d3 = np.reshape(data[:np.prod(shape)],shape)
ed = sed3.sed3(d3[:200, :200, :])
ed.show()
print("all ok")
def test_ms_seg_compared_with_different_resolution(self):
"""
Test multiscale segmentation
"""
img, seg, seeds = self.make_data(64, 20)
segparams = {
# 'method':'graphcut',
'method': 'multiscale_graphcut',
'use_boundary_penalties': False,
'boundary_dilatation_distance': 2,
'boundary_penalties_weight': 1,
'block_size': 8,
'tile_zoom_constant': 1
}
gc = pycut.ImageGraphCut(img, segparams=segparams)
gc.set_seeds(seeds)
gc.run()
# import sed3
# ed = sed3.sed3(gc.segmentation==0, contour=seg)
# ed.show()
self.assertLess(
np.sum(
np.abs(
(gc.segmentation == 0).astype(np.int8) - seg.astype(np.int8))
),
600)
# different resolution
# sz = [128,128,128]
sz = [70,70,70]
sz = [90,90,90]
sz = [100,100,100]
sz = [200,200,200]
sz1 = 70
sz = [sz1, sz1, sz1]
img2 = pycut.zoom_to_shape(img, sz, np.uint8)
seg2 = pycut.zoom_to_shape(seg, sz, np.uint8)
seeds2 = pycut.zoom_to_shape(seeds, sz, np.int8)
segparams['tile_zoom_constant'] = 0.8
gc = pycut.ImageGraphCut(img2, segparams=segparams)
gc.set_seeds(seeds2)
gc.run()
import sed3
ed = sed3.sed3(gc.segmentation==0, contour=seg2)
ed.show()
def read_bin_file(self, filename, bitsperblock=8):
bytesperblock = bitsperblock / 8
if bytesperblock == 2:
dtype = np.uint16
else:
logger.error("Unknown data type")
data = np.fromfile(filename, dtype=np.uint8)
shape = [1024, 1024, 10]
d3 = np.reshape(data[:np.prod(shape)],shape)
import sed3
ed = sed3.sed3(d3[:200, :200, :])
ed.show()
print("all ok")
def test_branch_labels_with_gui_just_in_module(self):
import lisa.organ_segmentation
import io3d
# datap = io3d.datasets.generate_abdominal()
datap = io3d.datasets.generate_synthetic_liver(return_dataplus=True)
oseg = lisa.organ_segmentation.OrganSegmentation()
oseg.import_dataplus(datap)
labeled_branches = lisa.virtual_resection.label_volumetric_vessel_tree(
oseg, "porta")
data3d = datap["data3d"]
segmentation = datap["segmentation"]
slab = datap["slab"]
organ_label = "liver"
seeds = np.zeros_like(data3d, dtype=np.int)
seeds[40, 125, 166] = 1
seeds[40, 143, 130] = 2
seeds[40, 125, 115] = 3
seglabel1 = labeled_branches[seeds == 1][0]
seglabel2 = labeled_branches[seeds == 2][0]
seglabel3 = labeled_branches[seeds == 3][0]
import imma.measure
import imma.image_manipulation
import imma.image_manipulation as ima
# import sed3
# ed = sed3.sed3(labeled_branches) # , contour=datap["segmentation"])
# ed.show()
organseg = ima.select_labels(segmentation, organ_label, slab)
organ_split, connected = lisa.virtual_resection.split_tissue_on_bifurcation(
labeled_branches, seglabel1, [seglabel2, seglabel3], organseg)
import sed3
# ed = sed3.sed3(labeled_branches, contour=organ_split)
ed = sed3.sed3(organ_split)
ed.show()
self.assertTrue(np.array_equal(np.unique(organ_split), [0, 1, 2]))
self.assertGreater(np.sum(organ_split == 0), 1000,
"At least some background expected")
self.assertGreater(np.sum(organ_split == 1), 1000,
"At least some object expected")
self.assertGreater(np.sum(organ_split == 2), 1000,
"At least some object expected")
def synthetic_liver_template(self, params):
"""
Function uses organ_segmentation for synthetic box object
segmentation.
"""
# dcmdir = os.path.join(path_to_script,'./../sample_data/matlab/examples/sample_data/DICOM/digest_article/') # noqa
# data
data3d, segm, voxelsize_mm, slab, seeds_liver, seeds_porta = io3d.datasets.generate_synthetic_liver(
)
# seeds
# seeds = np.zeros(data3d.shape, np.int8)
# seeds[40:55, 90:120, 70:110] = 1
# seeds[30:45, 190:200, 40:90] = 2
# [mm] 10 x 10 x 10 # voxelsize_mm = [1, 4, 3]
metadata = {'voxelsize_mm': voxelsize_mm}
oseg = organ_segmentation.OrganSegmentation(None,
data3d=data3d,
metadata=metadata,
seeds=seeds_liver,
working_voxelsize_mm=5,
manualroi=False,
autocrop=False,
**params)
oseg.ninteractivity()
volume = oseg.get_segmented_volume_size_mm3("liver")
self.assertGreater(volume, 570000,
"Liver volume should have proper size")
self.assertLess(volume, 640000, "Liver volume should have proper size")
oseg.portalVeinSegmentation(interactivity=False, threshold=180)
volume_porta = oseg.get_segmented_volume_size_mm3("porta")
self.assertGreater(volume_porta, 9000,
"Liver volume should have proper size")
self.assertLess(volume_porta, 11000,
"Liver volume should have proper size")
import sed3
ed = sed3.sed3(data3d, contour=(oseg.segmentation))
ed.show()
oseg.saveVesselTree('porta')
def differencing(path, res, axis):
sez = list()
teacher = list()
dr = io3d.DataReader()
datap = dr.Get3DData(path, dataplus_format=True)
ed = sed3.sed3(datap['data3d'])
datap['data3d'] = misc.resize_to_shape(datap['data3d'], [datap['data3d'].shape[0],100,100])
ed.show()
try:
under = np.where(ed.seeds == 1)[0][0]
except:
under = None
try:
over = np.where(ed.seeds == 3)[0][0]
except:
over = None
number_of_slice = np.shape(ed.seeds)[0]
c = list()
if under is None and over is None:
return [],[]
elif under is None or over is None:
print u'byla zadana jenom jedna mez zadejte obe nebo zadnou'
w, y = differencing(path, res)
return w, y
if over > under:
c = [1 for i in range(under)]
b = [2 for i in range(over-under)]
c.extend(b)
b = [3 for i in range(number_of_slice-over)]
c.extend(b)
else:
c = [3 for i in range(over)]
b = [2 for i in range(under - over)]
c.extend(b)
b = [1 for i in range(number_of_slice - under)]
c.extend(b)
over, under = under, over
for i in range(number_of_slice):
a = datap['data3d'][i,:,:]
x = c[i]
teacher.append(x)
sez.append(a)
return sez, teacher, under, over
def test_skeleton_problem_with_some_types_of_rectangular_structures(self):
# TODO fix bug in skeletonization algorithm.
# It ignores vertical structures and horizontal structures. Sometimes is just change the shape inough.
#
import io3d.datasets
data3d, segm, voxelsize_mm, slab, seeds_liver, seeds_porta = (
io3d.datasets.generate_synthetic_liver())
data_segm = segm == 2
# data_segm[39:44, 120:170, 100:111] = True
# data_segm[39:44, 50:120, 60:70] = True
# data_segm[39:44, 60:120, 100:105] = True
# data_segm[39:44, 60:120, 110:110 + 5] = True
data_segm[39:44, 120:130, 120:240] = True
data_segm[39:44, 60:120, 120:120 + 6] = True
data_segm[39:44, 60:120, 130:130 + 7] = True
data_segm[39:44, 60:120, 140:140 + 8] = True
data_segm[39:44, 60:120, 160:160 + 9] = True
data_segm[39:44, 60:120, 180:180 + 10] = True
data_segm[39:44, 60:120, 200:200 + 11] = True
data_segm[39:44, 60:120, 220:220 + 12] = True
# data_segm[39:44, 60:120, 120:126] = True
# data_segm[39:44, 60:120, 130:140] = True
# data_segm[39:44, 60:120, 150:151] = True
# data_segm[39:44, 60:120, 160:162] = True
data_skelet = skelet3d.skelet3d(data_segm)
import sed3
ed = sed3.sed3(data_skelet,
contour=data_segm) # , contour=branche_label)
ed.show()
self.assertEqual(
np.max(data_skelet[39:44, 60:100, 140:140 + 8]),
1,
"In this branche is expected skeleton",
)
self.assertEqual(np.min(data_skelet), 0)
self.assertEqual(np.max(data_skelet), 1)
def preparedata(inputfile,
outputfile='prepared.pklz',
crop=None,
threshold=None,
visualization=False,
zero_border=0,
label=2):
"""
:param inputfile: path to input file or directory, See io3d library for available file formats.
:param outputfile: path to output file
:param crop: crop parameters with fallowing format [[minX, maxX], [minY, maxY], [minZ. maxZ]]
:param threshold: set threshold for data
:param visualization: set true to show visualization
:param zero_border: data border can be set to zero. zero_border. Default is 0
:param label: set segmentation output label. Default is 2
:return:
"""
datap = io3d.datareader.read(inputfile, dataplus_format=True)
if crop is not None:
datap['data3d'] = datap['data3d'][crop[0][0]:crop[0][1],
crop[1][0]:crop[1][1],
crop[2][0]:crop[2][1]]
if 'segmentation' in datap.keys():
datap['segmentation'] = datap['segmentation'][
crop[0][0]:crop[0][1], crop[1][0]:crop[1][1],
crop[2][0]:crop[2][1]]
if threshold is not None:
datap['segmentation'] = (datap['data3d'] > threshold).astype(
np.uint8) * label
if visualization:
ed = sed3.sed3(datap['data3d'], contour=datap['segmentation'])
ed.show()
if zero_border > 0:
datap['segmentation'][:zero_border, :, :] = 0
datap['segmentation'][:, :zero_border, :] = 0
datap['segmentation'][:, :, :zero_border] = 0
datap['segmentation'][-zero_border:, :, :] = 0
datap['segmentation'][:, -zero_border:, :] = 0
datap['segmentation'][:, :, -zero_border:] = 0
# datap['segmentation'][datap['segmentation'] > 0] = label
io3d.datawriter.write(datap, outputfile)
def showSegmentedData(self):
skan = SkeletonAnalyser(
self.data3d_skel,
volume_data=self.data3d_thr,
voxelsize_mm=self.metadata['voxelsize_mm'])
data3d_nodes_vis = skan.sklabel.copy()
del(skan)
# edges
data3d_nodes_vis[data3d_nodes_vis > 0] = 1
# nodes and terminals
data3d_nodes_vis[data3d_nodes_vis < 0] = 2
if not self.nogui:
pyed = se.sed3(
self.data3d,
seeds=(data3d_nodes_vis).astype(np.int8),
contour=self.data3d_thr.astype(np.int8)
)
pyed.show()
def test_real_data_segmentation(self):
import lisa.dataset
app = QApplication(sys.argv)
dcmdir = os.path.join(lisa.dataset.sample_data_path(), 'jatra_5mm')
oseg = organ_segmentation.OrganSegmentation(dcmdir,
working_voxelsize_mm=4)
oseg.add_seeds_mm([81], [120], [120],
label=1, radius=30)
oseg.add_seeds_mm([81], [170, 220, 250], [250, 250, 200],
label=2, radius=30)
oseg.add_seeds_mm([100], [170], [140],
label=10, radius=5)
# oseg.interactivity(min_val=-200, max_val=200)
oseg.ninteractivity()
ed = sed3.sed3(oseg.data3d, contour=oseg.segmentation, seeds=oseg.seeds)
ed.show()
oseg.portalVeinSegmentation(seeds=(oseg.seeds==10))
def test_real_data_segmentation(self):
import lisa.dataset
app = QApplication(sys.argv)
dcmdir = os.path.join(lisa.dataset.sample_data_path(), 'jatra_5mm')
oseg = organ_segmentation.OrganSegmentation(dcmdir,
working_voxelsize_mm=4)
oseg.add_seeds_mm([81], [120], [120],
label=1, radius=30)
oseg.add_seeds_mm([81], [170, 220, 250], [250, 250, 200],
label=2, radius=30)
oseg.add_seeds_mm([100], [170], [140],
label=10, radius=5)
# oseg.interactivity(min_val=-200, max_val=200)
oseg.ninteractivity()
ed = sed3.sed3(oseg.data3d, contour=oseg.segmentation, seeds=oseg.seeds)
ed.show()
oseg.portalVeinSegmentation(seeds=(oseg.seeds==10))
def main():
#logger = logging.getLogger(__name__)
logger = logging.getLogger()
logger.setLevel(logging.WARNING)
ch = logging.StreamHandler()
logger.addHandler(ch)
#logger.debug('input params')
## read confguraton from file, use default values from OrganSegmentation
# input parser
parser = argparse.ArgumentParser(
description=' Show dicom data with overlay')
parser.add_argument('-i',
'--inputdatapath',
default='',
help='path to data dir')
args_obj = parser.parse_args()
args = vars(args_obj)
#print args["arg"]
reader = datareader.DataReader()
data3d, metadata = reader.Get3DData(args['inputdatapath'], qt_app=None)
overlays = reader.GetOverlay()
overlay = np.zeros(data3d.shape, dtype=np.int8)
print "overlays ", overlays.keys()
for key in overlays:
overlay += overlays[key]
#import ipdb; ipdb.set_trace() # BREAKPOINT
pyed = sed3.sed3(data3d, contour=overlay)
pyed.show()
#print savestring
# import pdb; pdb.set_trace()
return
def simple_segmentation(self, data3d, voxelsize_mm):
simple_seg = np.zeros(data3d.shape)
#definice konvoluční masky
KONV_MASK = np.ones([10, 10, 10], float)
KONV_MASK = KONV_MASK / 9.0
#definice konvoluční funkce - param a - matice m*n kterou budeme přenásobovat konvoluční maticí, b - Konvoluční maska m*n
# nalezení kostí
simple_seg = data3d > BONES
#simple_seg[(simple_seg.shape[0]/5)*4:simple_seg.shape[0]] = 0
#nalzení páteře
spine_finder = scipy.ndimage.filters.convolve(
(simple_seg).astype(np.int), KONV_MASK)
#pyed = sed3.sed3(simple_seg)
#
simple_seg += ((spine_finder > 25) * SPINE_ID)
pyed = sed3.sed3(simple_seg)
pyed.show()
return simple_seg
def main():
#logger = logging.getLogger(__name__)
logger = logging.getLogger()
logger.setLevel(logging.WARNING)
ch = logging.StreamHandler()
logger.addHandler(ch)
#logger.debug('input params')
## read confguraton from file, use default values from OrganSegmentation
# input parser
parser = argparse.ArgumentParser(
description=' Show dicom data with overlay')
parser.add_argument('-i', '--inputdatapath',
default='',
help='path to data dir')
args_obj = parser.parse_args()
args = vars(args_obj)
#print args["arg"]
reader = datareader.DataReader()
data3d, metadata = reader.Get3DData(args['inputdatapath'], qt_app=None)
overlays = reader.GetOverlay()
overlay = np.zeros(data3d.shape, dtype=np.int8)
print "overlays ", overlays.keys()
for key in overlays:
overlay += overlays[key]
#import ipdb; ipdb.set_trace() # BREAKPOINT
pyed = sed3.sed3(data3d, contour=overlay)
pyed.show()
#print savestring
# import pdb; pdb.set_trace()
return
def simple_segmentation(self, data3d, voxelsize_mm):
simple_seg = np.zeros(data3d.shape )
#definice konvoluční masky
KONV_MASK = np.ones([10,10,10], float)
KONV_MASK = KONV_MASK/9.0;
#definice konvoluční funkce - param a - matice m*n kterou budeme přenásobovat konvoluční maticí, b - Konvoluční maska m*n
# nalezení kostí
simple_seg = data3d > BONES
#simple_seg[(simple_seg.shape[0]/5)*4:simple_seg.shape[0]] = 0
#nalzení páteře
spine_finder = scipy.ndimage.filters.convolve((simple_seg).astype(np.int), KONV_MASK)
#pyed = sed3.sed3(simple_seg)
#
simple_seg += ((spine_finder>25)*SPINE_ID)
pyed = sed3.sed3(simple_seg)
pyed.show()
return simple_seg
def test_skeleton_problem_with_some_types_of_rectangular_structures(self):
# TODO fix bug in skeletonization algorithm.
# It ignores vertical structures and horizontal structures. Sometimes is just change the shape inough.
#
import io3d.datasets
data3d, segm, voxelsize_mm, slab, seeds_liver, seeds_porta = io3d.datasets.generate_synthetic_liver()
data_segm = segm == 2
# data_segm[39:44, 120:170, 100:111] = True
# data_segm[39:44, 50:120, 60:70] = True
# data_segm[39:44, 60:120, 100:105] = True
# data_segm[39:44, 60:120, 110:110 + 5] = True
data_segm[39:44, 120:130, 120:240] = True
data_segm[39:44, 60:120, 120:120 + 6] = True
data_segm[39:44, 60:120, 130:130 + 7] = True
data_segm[39:44, 60:120, 140:140 + 8] = True
data_segm[39:44, 60:120, 160:160 + 9] = True
data_segm[39:44, 60:120, 180:180 + 10] = True
data_segm[39:44, 60:120, 200:200 + 11] = True
data_segm[39:44, 60:120, 220:220 + 12] = True
# data_segm[39:44, 60:120, 120:126] = True
# data_segm[39:44, 60:120, 130:140] = True
# data_segm[39:44, 60:120, 150:151] = True
# data_segm[39:44, 60:120, 160:162] = True
data_skelet = skelet3d.skelet3d(data_segm)
import sed3
ed = sed3.sed3(data_skelet, contour=data_segm)# , contour=branche_label)
ed.show()
self.assertEqual(np.max(
data_skelet[39:44, 60:100, 140:140 + 8]
), 1, "In this branche is expected skeleton")
self.assertEqual(np.min(data_skelet), 0)
self.assertEqual(np.max(data_skelet), 1)
default='mesh_geom.vtk',
help='temp file used in processing')
parser.add_argument(
'-d', '--degrad', type=int,
default=4,
help='data degradation, default 4')
parser.add_argument(
'-l', '--labels', type=int, metavar='N', nargs='+',
default=[1],
help='segmentation labels, default 1')
parser.add_argument(
'-s', '--show', action='store_true',
help='Show mode')
args = parser.parse_args()
dr = io3d.DataReader()
data = dr.Get3DData(args.inputfile, dataplus_format=True)
# args.label = np.array(eval(args.label))
# print args.label
# import pdb; pdb.set_trace()
ds = data['segmentation']
if args.show:
dsel = select_labels(ds, args.labels)
import sed3
ed = sed3.sed3(dsel.astype(np.double))
ed.show()
seg2stl(ds, labels=args.labels, degrad=args.degrad, outputfile=args.outputfile, tempfile=args.tempfile)
def visualization(self):
pyed = sed3.sed3(
self.segmentation == self.data['slab']['lesions'])
pyed.show()
def test_run_with_seeds_and_contour(self):
import sed3
img, seeds, segmentation = self.create_data()
sed3.sed3(img, seeds=seeds, contour=segmentation)
sys.exit(0)
if args.draw is not None:
parts = [ s.strip().lower() for s in args.draw.split(",") ]
masks = [ obj.getPart(p) for p in parts ]
if args.drawdepth:
rd = ResultsDrawer(mask_depth = True, default_volume_alpha = 255)
else:
rd = ResultsDrawer()
img = rd.drawImageAutocolor(data3d, voxelsize, volumes = masks)
img.show()
if args.show is not None:
import sed3
seg = obj.getPart(args.show)
ed = sed3.sed3(data3d, contour=seg); ed.show()
####################################################################
print("-----------------------------------------------------------")
# data3d = obj.getData3D(raw=True)
# lungs = obj.getLungs(raw=True)
# bones = obj.getBones(raw=True)
# vessels = obj.getVessels()
# aorta = obj.getAorta()
# venacava = obj.getVenaCava()
# print(data3d.shape)
# ed = sed3.sed3(data3d, contour=lungs); ed.show()
# ed = sed3.sed3(data3d, contour=bones); ed.show()
# bones_stats = obj.analyzeBones()
def get_seeds_using_prob_class1(self, data, class1, roi=None, dens_min=20,
dens_max=255,
thresholdType='percOfMaxDist', percT=0.5):
# calculates probability based on similarity of intensities
probs, mu = tools.intensity_probability(data, std=10)
# sed3.sed3(data).show()
# sed3.sed3(probs).show()
# normalizing and calculating reciprocal values
# weights_ints = skexp.rescale_intensity(probs,
# in_range=(0,probs.max()), out_range=(1,0))
weights_ints = np.exp(-probs)
weights_h = np.where(data > mu, 1 - probs, 0)
weights_l = np.where(data < mu, 1 - probs, 0)
# sed3.sed3(1 - probs).show()
sed3.sed3(weights_h).show()
sed3.sed3(weights_l).show()
if roi is None:
roi = np.logical_and(data >= dens_min, data <= dens_max)
dist_data = np.where(class1 == 1, False, True)
dist_data *= roi > 0
# dists = distance_transform_edt(dist_data)
# sed3.sed3(dists).show()
# print 'dists max = %i' % dists.max()
# print 'dists min = %i' % dists.min()
# print 'weights_ints max = %.4f' % weights_ints.max()
# print 'weights_ints min = %.4f' % weights_ints.min()
# print 'probs max = %.4f' % probs.max()
# print 'probs min = %.4f' % probs.min()
# energy = dists * weights_ints
energy = weights_ints
# sed3.sed3(energy).show()
seeds = np.zeros(data.shape, dtype=np.bool)
if thresholdType == 'percOfMaxDist':
seeds = energy > (percT * energy.max())
elif thresholdType == 'mean':
seeds = energy > 2 * (energy[np.nonzero(energy)]).mean()
# TODO: tady je problem, ze energy je v intervalu <0.961, 1> - hrozne
# maly rozsah
print('energy max = %.4f' % energy.max())
print('energy min = %.4f' % energy.min())
print('thresh = %.4f' % (percT * energy.max()))
print(seeds.min())
print(seeds.max())
print('seed perc = %.2f' % (
(energy > percT * energy.max()).sum()/np.float(energy.nbytes)))
sed3.sed3(seeds).show()
# removing to small objects
min_size_of_seed_area = 60
print('before removing: %i' % seeds.sum())
seeds = skimor.remove_small_objects(
seeds, min_size=min_size_of_seed_area, connectivity=1,
in_place=False)
print('after removing: %i' % seeds.sum())
all_seeds = np.zeros(data.shape, dtype=np.int)
# allSeeds[np.nonzero(self.segmentation)] = 80
all_seeds[np.nonzero(class1)] = 1 # zdrava tkan
all_seeds[np.nonzero(seeds)] = 2 # outliers
# kvuli segmentaci pomoci random walkera se omezi obraz pouze na
# segmentovana jatra a cevy
all_seeds = np.where(roi == 0, -1, all_seeds)
sed3.sed3(all_seeds).show()
return all_seeds
def segmentation(data3d, segmentation, params):
""" Texture analysis by LBP algorithm.
data: CT (or MRI) 3D data
segmentation: labeled image with same size as data where label:
1 mean liver pixels,
-1 interesting tissuse (bones)
0 otherwise
"""
MAXPATTERNS = 10
slices = data3d.shape[2]
data3d = data3d.astype(np.int16)
params[2] = 0
data3d = data3d * segmentation;
data3d = sp.ndimage.filters.gaussian_filter(data3d,params*2.5)
pyed = sed3.sed3(data3d)
pyed.show()
lbp = lbpLib.loadLbpLibrary()
lbpReftmp = (ctypes.c_long * 256)()
lbpRef = np.zeros([MAXPATTERNS,256])
actualpatterns = 0
# vytvoreni referencnich LBP obrazu
for j in range(15,data3d.shape[0]-16):
if (actualpatterns == MAXPATTERNS) :
break
for k in range(15,data3d.shape[1]-16):
if (actualpatterns == MAXPATTERNS) :
break
if ((pyed.seeds[j,k,pyed.actual_slice] == 1)):
lbpReftmp = lbpLib.realTimeLbpImNp(lbp, data3d[j-15:j+16,k-15:k+16,pyed.actual_slice])
for z in range(256):
lbpRef[actualpatterns, z] = lbpReftmp[z]
print(lbpRef[actualpatterns,])
actualpatterns += 1
# uprava velikosti dat
for i in range(20):
h2 = data3d.shape[0] - i*16
if (h2 <= 0):
h2 = i*16
break
for i in range(20):
w2 = data3d.shape[1] - i*16
if (w2 <= 0):
w2 = i*16
break
# obdelnikova data prevedeme na ctverec
if (w2 >= h2 ):
h2 = w2
else :
w2 = h2
numOfPartsX = (w2) / 16
numOfPartsY = (h2) / 16
minMaxData = np.zeros([h2,w2,data3d.shape[2]],dtype = np.float)
lbpSlice = np.zeros([h2,w2])
# hlavni cyklus vypocitavajici odezvy
for i in range(slices):
tempData = np.zeros([h2,w2],dtype = np.float)
tempData[0:data3d.shape[0],0:data3d.shape[1]] = data3d[:,:,i].astype(np.float)
lbpSlice = lbpLib.realTimeLbpIm2ImNp(lbp, tempData.astype(np.int16))
lbpRes = lbpLib.lbp2HistsNp(lbp, lbpSlice)
for j in range(lbpRes.shape[0]):
minmaxBestVal = 0
for k in range(MAXPATTERNS):
minmaxVal = minmax(lbpRes[j,:],lbpRef[k,:])
if minmaxVal > minmaxBestVal :
minmaxBestVal = minmaxVal
minMaxData[16*(j/numOfPartsX):16*(j/numOfPartsX)+16,16*(j % numOfPartsX):16*(j % numOfPartsX)+16,i] = minmaxBestVal
# zobrazeni vysledku
pyed2 = sed3.sed3(minMaxData)
pyed2.show()
return segmentation
def eval_all_from_dataset_metadata(inputdata, visualization=False,
special_evaluation_function=None):
"""
set metadata
"""
evaluation_all = {
'file1': [],
'file2': [],
'volume1_mm3': [],
'volume2_mm3': [],
'err1_mm3': [],
'err2_mm3': [],
'err1_percent': [],
'err2_percent': [],
'voe': [],
'vd': [],
'avgd': [],
'rmsd': [],
'processing_time': [],
'organ_interactivity_counter': [],
'maxd': []
}
for i in range(0, len(inputdata['data'])):
reader = datareader.DataReader()
data3d_a_path = os.path.join(inputdata['basedir'],
inputdata['data'][i]['sliverseg'])
data3d_a, metadata_a = reader.Get3DData(data3d_a_path)
print "inputdata ", inputdata['data'][i].values()
try:
# if there is defined overlay
data3d_a = reader.GetOverlay()[inputdata['data'][i][
'overlay_number']]
logger.info('overlay loaded')
print 'overlay loaded'
except:
logger.debug("overlay not loaded")
pass
logger.debug('data A shape ' + str(data3d_a.shape))
data3d_b_path = os.path.join(inputdata['basedir'],
inputdata['data'][i]['ourseg'])
obj_b = misc.obj_from_file(data3d_b_path, filetype='pickle')
# data_b, metadata_b = reader.Get3DData(data3d_b_path)
if 'crinfo' in obj_b.keys():
data3d_b = qmisc.uncrop(obj_b['segmentation'],
obj_b['crinfo'], data3d_a.shape)
else:
data3d_b = obj_b['segmentation']
# import pdb; pdb.set_trace()
# data3d_a = (data3d_a > 1024).astype(np.int8)
data3d_a = (data3d_a > 0).astype(np.int8)
data3d_b = (data3d_b > 0).astype(np.int8)
if visualization:
pyed = sed3.sed3(data3d_a, # + (4 * data3d_b)
contour=data3d_b)
pyed.show()
evaluation_one = compare_volumes(data3d_a, data3d_b,
metadata_a['voxelsize_mm'])
if special_evaluation_function is not None:
evaluation_one.update(
special_evaluation_function(
data3d_a, data3d_b, metadata_a['voxelsize_mm']
))
evaluation_all['file1'].append(data3d_a_path)
evaluation_all['file2'].append(data3d_b_path)
for key in evaluation_one.keys():
if key not in evaluation_all.keys():
evaluation_all[key] = []
evaluation_all[key].append(evaluation_one[key])
# evaluation_all['volume1_mm3'].append(evaluation_one['volume1_mm3'])
# evaluation_all['volume2_mm3'].append(evaluation_one['volume2_mm3'])
# evaluation_all['err1_mm3'].append(evaluation_one['err1_mm3'])
# evaluation_all['err2_mm3'].append(evaluation_one['err2_mm3'])
# evaluation_all['err1_percent'].append(evaluation_one['err1_percent'])
# evaluation_all['err2_percent'].append(evaluation_one['err2_percent'])
# evaluation_all['voe'].append(evaluation_one['voe'])
# evaluation_all['vd'].append(evaluation_one['vd'])
# evaluation_all['avgd'].append(evaluation_one['avgd'])
# evaluation_all['rmsd'].append(evaluation_one['rmsd'])
# evaluation_all['maxd'].append(evaluation_one['maxd'])
if 'processing_time' in obj_b.keys():
# this is only for compatibility with march2014 data
processing_time = obj_b['processing_time']
organ_interactivity_counter = obj_b['organ_interactivity_counter']
else:
try:
processing_time = obj_b['processing_information']['organ_segmentation']['processing_time'] # noqa
organ_interactivity_counter = obj_b['processing_information']['organ_segmentation']['organ_interactivity_counter'] # noqa
except:
processing_time = 0
organ_interactivity_counter = 0
evaluation_all['processing_time'].append(processing_time)
evaluation_all['organ_interactivity_counter'].append(
organ_interactivity_counter)
return evaluation_all
def show(data3dw):
data3d = data3dw.datap["data3d"]
import sed3
ed = sed3.sed3qt(data3d)
# ed = sed3.se
# ed.show()
ed.exec_()
if __name__ == "__main__":
# main()
app = QtGui.QApplication(sys.argv)
# w = QtGui.QWidget()
# w = DictEdit(dictionary={'jatra':2, 'ledviny':7})
w = DataReaderWidget(loaddir="~", loadfiledir="~",
cachefile="~/cache.yaml",
after_function=None, before_function=None)
w.resize(250, 150)
w.move(300, 300)
w.setWindowTitle('io3dQtWidget')
w.show()
app.exec_()
data3d = w.datap["data3d"]
import sed3
ed = sed3.sed3(data3d)
ed.show()
