def renderSliceWithDistribution(vesselgroup, imagefn, options): vessel_ld = krebsutils.read_lattice_data_from_hdf( vesselgroup['vessels/lattice']) vessel_graph = krebsutils.read_vessels_from_hdf( vesselgroup['vessels'], ['position', 'flags', 'radius', 'pressure', 'shearforce', 'nodeflags'], return_graph=True) vessel_graph.edges['radius'] *= 4. #kwargs = deepcopy(kwargs) wbbox = vessel_ld.worldBox trafo = calc_centering_normalization_trafo(wbbox) height = (wbbox[5] - wbbox[4]) * trafo.w print('Vessel BBox:' + str(vessel_ld.worldBox)) print(vessel_ld) print('Post Trafo Ld BBox:' + str(transform_ld(trafo, vessel_ld).worldBox)) hasGfField = 'field_ld' in vesselgroup and vessel_ld.shape[2] == 1 #hasGfField = False if hasGfField: volume_ld = krebsutils.read_lattice_data_from_hdf( vesselgroup['field_ld']) print('Volume BBox:' + str(volume_ld.worldBox)) print(volume_ld) volumedata = np.asarray(vesselgroup['gf']) #print volumedata.shape, volumedata.min(), volumedata.max() volume_ld = transform_ld(trafo, volume_ld) print('Post Trafo Volume BBox:' + str(volume_ld.worldBox)) print('volume data bounds:' + str(volumedata.min()), str(volumedata.max())) colorfactory(vessel_graph) with EasyPovRayRender(**options) as epv: epv.setBackground(options.pop('background', 0.0)) cam_fov = 60. cam_distance_factor = ComputeCameraDistanceFactor( cam_fov, options['res'], wbbox) epv.setCamera((0, 0, cam_distance_factor * 1.05), lookat=(0, 0, 0), fov=cam_fov, up='y') epv.addLight(10. * Vec3(1, 0.5, 2), 1.2) cm = matplotlib.cm.ScalarMappable(cmap=cm_gf) cm.set_clim(-0.01, 1.01) pvcm = matplotlibColormapToPovray('DATACOLORMAP', cm) epv.declareColorMap(pvcm) if hasGfField: volumedata = epv.declareVolumeData(volumedata, volume_ld.worldBox, volume_ld) epv.addVolumeDataSlice(volumedata, (0, 0, 0), (0, 0, 1.), pvcm) addVesselTree(epv, vessel_graph, trafo=trafo, **options) imagefn = epv.render(imagefn)
def plot(filename): rc = matplotlib.rc rc('font', size=8.) rc('axes', titlesize=10., labelsize=10.) rc('figure', **{'subplot.wspace': 0.15, 'subplot.hspace': 0.15}) rc('savefig', facecolor='white') dpi = 100. results = Results(filename) ld = krebsutils.read_lattice_data_from_hdf(results.f['field_ld']) size = ld.shape extent = ld.worldBox[:4] ldface = (krebsutils.read_lattice_data_from_hdf( results.f['face_ld_0']), krebsutils.read_lattice_data_from_hdf( results.f['face_ld_1'])) extface = tuple(q.worldBox[:4] for q in ldface) data = collections.defaultdict(list) for idx, group in enumerate(results): def show(a, ext): pyplot.imshow(np.asarray(a[..., size[2] / 2]).transpose(), extent=ext, origin='bottom', interpolation='nearest') def contour(): return pyplot.contour(np.asarray(group['ls'][..., size[2] / 2]).transpose(), levels=[0.], extent=extent, origin='lower') print "plotting %i" % idx if 1: pyplot.figure(figsize=(1200. / dpi, 1000. / dpi)) pyplot.subplot(221) show(group['ls'], extent) pyplot.colorbar() contour() pyplot.subplot(222) show(group['rho'], extent) pyplot.colorbar() contour() pyplot.subplot(223) show(group['force_0'], extface[0]) pyplot.colorbar() contour() pyplot.subplot(224) show(group['force_1'], extface[1]) pyplot.colorbar() contour() pyplot.savefig("%s_%i.png" % (filename, idx), dpi=dpi) data['time'].append(group.attrs['time']) data['mass'].append(group.attrs['mass']) data['area'].append(group.attrs['area'])
def get_tumld(tumorgroup): p = tumorgroup['ptc'].attrs['LATTICE_PATH'] tum_ld = krebsutils.read_lattice_data_from_hdf(tumorgroup.file[p]) #field_ld is in root #tum_ld = krebsutils.read_lattice_data_from_hdf(tumorgroup.parent.parent['field_ld']) #tum_ld = krebsutils.read_lattice_data_from_hdf(tumorgroup.file[tumorgroup['conc'].attrs['LATTICE_PATH']]) return tum_ld
def computeO2Uptake(po2group, tumorgroup): po2field = np.asarray(po2group['po2field']) po2ld = krebsutils.read_lattice_data_from_hdf(po2group['field_ld']) parameters = readParameters(po2group) uptake = pickDetailedO2Library(parameters).computeO2Uptake(po2field, po2ld, tumorgroup, parameters) uptake *= 60. # 1/s -> 1/min return uptake;
def asVtkDataSets(self, return_ld_path=False): import krebsutils result = {} for k, gg in self.data.iteritems(): if k == VtkFiles: for g in gg: # ds = vtkcommon.vtkStringToDataset( # np.asarray(g).tostring(), # vtk.vtkDataSetReader if g.attrs['TYPE'] == 'VTK_FILE' else self.gridtype2vtureader[g.attrs.get('VTK_DATASET_TYPE', 'vtkUnstructuredGrid')] # ) ds = vtkcommon.vtkDatasetFromHdf5(g) result[g.name] = ds else: #ds = vtkcommon.vtkImageDataFromLd(self.file[k].attrs) ld = krebsutils.read_lattice_data_from_hdf(self.file[k]) ds = vtkcommon.vtkImageDataFromLd(ld) name = posixpath.commonprefix([q.name for q in gg]) for q in gg: # iterate over hdf datasets and add them to the image data vtkcommon.vtkImageDataAddData(ds, q, 'CellData', posixpath.basename(q.name)) if not return_ld_path: result[name] = ds else: result[name] = (ds, k) return result.values()
def getDomainSizeFromVesselFile(fn): with h5files.open(fn, 'r') as f: ld = krebsutils.read_lattice_data_from_hdf( krebsutils.find_lattice_group_(f['vessels'])) size = np.amax(ld.GetWorldSize()) # longest axis times the lattice spacing return size
def __init__(self, dataman, group, label): self.label = label self.dataman = dataman self.group = group self.cachelocation = (group.file, group.name) self.po2group, self.vesselgroup = group['po2'], group['vessels'] #self.po2vessels, self.po2fieldld, self.po2field, _ = dataman.obtain_data('detailedPO2', self.po2group) self.po2fieldld = krebsutils.read_lattice_data_from_hdf(self.po2group['field_ld']) self.po2vessels = self.po2group['po2vessels'] self.po2field = self.po2group['po2field'] self.worldbb = self.po2fieldld.worldBox self.fluxes = dataman.obtain_data('detailedPO2_total_fluxes', '', self.po2group, sample_length, 1, self.cachelocation) self.samples = GenerateSingleCapillarySamples(dataman, self.po2group, self.cachelocation) self.samplesx = 1.e-3*self.samples['x'] self.numSamples = len(self.samples['x']) ld = self.po2fieldld x0, x1, y0, y1, z0, z1 = ld.box self.x_field = np.linspace(ld.LatticeToWorld((x0, 0, 0))[0], ld.LatticeToWorld((x1,0,0))[0], x1-x0+1) self.y_field = np.linspace(ld.LatticeToWorld((0, y0, 0))[1], ld.LatticeToWorld((0, y1,0))[1], y1-y0+1) if not 'LIMITS' in self.po2field.attrs: self.po2field.attrs['LIMITS'] = (np.amin(self.po2field), np.amax(self.po2field)) if not 'LIMITS' in self.po2vessels.attrs: self.po2vessels.attrs['LIMITS'] = (np.amin(self.po2vessels), np.amax(self.po2vessels)) pf0, pf1 = self.po2field.attrs['LIMITS'] pv0, pv1 = self.po2vessels.attrs['LIMITS'] self.po2range = (min(pf0, pv0), max(pf1, pv1)) self.params_ = None
def ObtainDataOfVesselFile(f): dataman = myutils.DataManager(20, [ krebs.analyzeGeneral.DataTumorTissueSingle(), krebs.analyzeGeneral.DataVesselRadial(), krebs.analyzeGeneral.DataDistanceFromCenter(), krebs.analyzeBloodFlow.DataTumorBloodFlow(), krebs.analyzeGeneral.DataBasicVessel(), krebs.analyzeGeneral.DataVesselSamples(), ]) vesselgroup = f['vessels'] ld = krebsutils.read_lattice_data_from_hdf(f['field_ld']) #print 'field_box = ', ld.worldBox #bins_spec = krebs.analyzeGeneral.BinsSpecRange(100., 1000., 100.) bins_spec = krebs.analyzeGeneral.BinsSpecRange(100., 1000., 100.) mvd, mvd_bins = dataman.obtain_data('sphere_vessel_density', vesselgroup, None, bins_spec, 'radial', ld, (f, 'data')) rbf, rbf_bins = dataman.obtain_data('cum_rbf_radial', vesselgroup, None, bins_spec, 'radial', ld, (f, 'data')) rbv = dataman.obtain_data('basic_vessel_radial', 'phi_vessels', vesselgroup, None, 50., bins_spec, 'radial', ld, (f, 'data')) # rbv returns myutils.MeanValueArray scale = f['vessels/lattice'].attrs['SCALE'] message = f['parameters'].attrs['MESSAGE'] return dict(mvd=np.asarray(mvd), rbf=np.asarray(rbf), rbv=rbv.avg, bins=bins_spec.arange(), scale=scale, message=message)
def makeLD(self, vesselgroup): ldvessels = krebsutils.read_lattice_data_from_hdf( vesselgroup['lattice']) fieldld = krebsutils.SetupFieldLattice(ldvessels.worldBox, 3, self.bin_size, 0.) fieldldFine = krebsutils.SetupFieldLattice( fieldld.worldBox, 3, self.bin_size / self.fine_bin_subdivision, 0.) return fieldld, fieldldFine
def from_vessel_file(filenames, grp_pattern): dirs = set() dataman = myutils.DataManager(20, [ krebs.plotIff.DataTissue(), krebs.plotIff.DataGlobalIff(), krebs.plotIff.DataRadialIff(), krebs.analyzeGeneral.DataDistanceFromCenter(), krebs.analyzeGeneral.DataVesselSamples(), krebs.analyzeGeneral.DataBasicVessel(), o2analysis.DataDetailedPO2() ]) f_measure = h5files.open('chache.h5', 'a', search=False) def cachelocation(g): path = posixpath.join( 'FileCS_' + myutils.checksum(basename(g.file.filename)), g.name.strip(posixpath.sep)) return (f_measure, path) #run with grp_pattern: iff/vessels for fn in filenames: with h5py.File(fn, 'r+') as f: d = myutils.walkh5(f, grp_pattern) assert len(d), 'you f****d up, pattern "%s" not found in "%s"!' % ( grp_pattern, fn) dirs = set.union(dirs, d) for group_path in dirs: if 'vessel' in grp_pattern and not 'o2' in grp_pattern: vesselgroup = f[group_path] ldvessels = ku.read_lattice_data_from_hdf( vesselgroup['lattice']) fieldld = ku.SetupFieldLattice(ldvessels.worldBox, 3, 10, 0.) phi_vessels = krebs.analyzeGeneral.CalcPhiVessels( dataman, vesselgroup, fieldld, scaling=1., samples_per_cell=5) print('bla') import nibabel as nib new_image = nib.Nifti1Image(phi_vessels, affine=np.eye(4)) common_filename = os.path.splitext(os.path.basename(fn))[0] new_image.to_filename(common_filename + '_vessels' + '.nii') if 'o2' in grp_pattern: po2group = f[group_path] #sample_length = 500. #data = dataman.obtain_data('detailedPO2_global', 'po2_tissue', po2group, sample_length, cachelocation(po2group)) data = np.asarray(po2group['po2field']) print('bla') import nibabel as nib new_image = nib.Nifti1Image(data, affine=np.eye(4)) common_filename = os.path.splitext(os.path.basename(fn))[0] new_image.to_filename(common_filename + '_po2' + '.nii')
def CenterTheLattice(f, h5_path): """ The histological MVD is determined for intersections of the vascular network with a number of concentric spheres. Therefore it is convenient to first move the system so that it is centered at the coordinate origin. """ ld = krebsutils.read_lattice_data_from_hdf(f[h5_path]) del f[h5_path] ld = ld.GetCentered() krebsutils.write_lattice_data_to_hdf(f, h5_path, ld)
def write(gmeasure, groupname): vessels = dataman.obtain_data('vessel_graph', vesselgroup, ['flags', 'flow']) arterialFlow, _ = GetRootVesselData(vessels, vessels['flow']) arterialFlow = np.sum(arterialFlow) ldvessels = krebsutils.read_lattice_data_from_hdf( vesselgroup['lattice']) totalVolume = np.cumprod(ldvessels.GetWorldSize())[2] perfusion = arterialFlow / totalVolume ds = gmeasure.create_dataset(groupname, data=perfusion) ds.attrs['unit'] = '1 / s'
class EnsembleFiles(object): def __init__(self, dataman, filenames, pattern): files = [h5files.open(fn, 'r+') for fn in filenames] items = [] has_tumor = True for f in files: paths = myutils.walkh5(f['.'], pattern) for path in paths: g = f[path] if g.attrs.get('CLASS', None) == 'GRAPH': gvessels = g gtumor = None try: source = h5files.openLink(g, 'SOURCE') gtumor = source.parent['tumor'] g = source.parent except Exception, e: raise RuntimeError( 'tried to get tumor data but failed:' + str(e)) else: gvessels, gtumor = g['vessels'], (g['tumor'] if 'tumor' in g else None) e = EnsembleItem(path=path, gvessels=gvessels, gtumor=gtumor, group=g) e.time = g.attrs['time'] has_tumor = has_tumor and gtumor is not None e.vessel_system_length = dataman.obtain_data( 'vessel_system_length', gvessels) items.append(e) if has_tumor: d = collections.defaultdict(list) # path -> list of EnsembleItem for e in items: d[e.path].append(e) tumor_snapshot_times = dict( (k, np.average(map(lambda e: e.time, v))) for k, v in d.items()) tumor_snapshot_order = sorted( tumor_snapshot_times.keys(), key=(lambda path: tumor_snapshot_times[path])) tumor_snapshots = [(d[path], path, tumor_snapshot_times[path]) for path in tumor_snapshot_order] self.files = files self.items = items self.tumor_snapshots = tumor_snapshots # list of tuple(items, path, time) self.has_tumor = has_tumor ld = krebsutils.read_lattice_data_from_hdf( items[0].gvessels['lattice']) self.world_size = ld.GetWorldSize()
def from_vessel_file(filenames, grp_pattern): dirs = set() dataman = myutils.DataManager(20, [ krebs.plotIff.DataTissue(), krebs.plotIff.DataGlobalIff(), krebs.plotIff.DataRadialIff(), krebs.analyzeGeneral.DataDistanceFromCenter(), krebs.analyzeGeneral.DataBasicVessel() ]) #run with grp_pattern: iff/vessels for fn in filenames: with h5py.File(fn, 'r') as f: d = myutils.walkh5(f, grp_pattern) assert len(d), 'you f****d up, pattern "%s" not found in "%s"!' % ( grp_pattern, fn) dirs = set.union(dirs, d) for group_path in dirs: vesselgroup = f[group_path] ldvessels = ku.read_lattice_data_from_hdf( vesselgroup['lattice']) fieldld = ku.SetupFieldLattice(ldvessels.worldBox, 3, 10, 0.) #fieldldFine = ku.SetupFieldLattice(fieldld.worldBox, 3, 50 / 10, 0.) phi_vessels = krebs.analyzeGeneral.CalcPhiVessels( dataman, f['iff/vessels'], fieldld, scaling=1., samples_per_cell=5) #a_abs = np.fabs(phi_vessels) #a_max = np.amax(a_abs) #n_phi = phi_vessels/a_max #visual = (phi_vessels-phi_vessels.min()) #inner1 = matplotlib.cm.gist_earth(n_phi) #inner2 = np.uint8(inner1*255) #result = Image.fromarray(inner2[:,:,:,0:2],mode='RGB') #result.save('out.tiff') print('bla') import nibabel as nib new_image = nib.Nifti1Image(phi_vessels, affine=np.eye(4)) new_image.to_filename('myni') #for i in np.arange(0,phi_vessels.shape[2]): # plt.imsave('img/%03i.png' % i,phi_vessels[:,:,i]) #scipy.io.savemat('test.mat', phi_vessels) #np.save('mydata.tiff',phi_vessels) #pydicom. #pydicom.write_file('mydata.dcm', phi_vessels) plt.imshow(phi_vessels[:, :, 20]) plt.show()
def sampleVessels(po2group, vesselgroup, tumorgroup, sample_length): po2vessels = np.asarray(po2group['po2vessels']) if po2vessels.shape[0] <> 2: po2vessels = np.transpose(po2vessels) po2field = np.asarray(po2group['po2field']) ld = krebsutils.read_lattice_data_from_hdf(po2group['field_ld']) parameters = readParameters(po2group) # call thee c++ stuff samples, fluxes = pickDetailedO2Library(parameters).sampleVessels(vesselgroup, tumorgroup, parameters, po2vessels, po2field, ld, sample_length) # convert units to mlO2/s, and also return dicts fluxes = dict((k, f*60.e-12) for k,f in zip(('Jin_root', 'Jout_root', 'Jout_tv', 'tv_cons'), fluxes)) samples = dict( po2 = samples[0], extpo2 = samples[1], jtv = samples[2]*60.e-4, # 1.e-4 to convert from mu m^3 O2 / um^2 / s to ml O2 / cm^2 / min dS_dx = samples[3]*1.e3, # in 1/mmm ) return samples, fluxes
def CenterLattice(g): '''needs h5 goup g, which is deleted and rewritten where the new lattice is centered ''' print '------', g.name + '--------' ld = krebsutils.read_lattice_data_from_hdf(g) #meanwhile worldBox is 3D thisBox = ld.worldBox bmin, bmax = thisBox[0:2] offset = -0.5 * (bmin + bmax) # which is the negative center #offset[0] = 0 # don't move in x orig = ld.GetOriginPosition() orig += offset ld.SetOriginPosition(orig) parent = g.parent name = str(g.name) del g del parent[name] krebsutils.write_lattice_data_to_hdf(parent, name, ld) return offset
def PrintGlobalData(pdfpages, vesselgroups, f_measure, dataman): from analyzeBloodVolumeSimple import cylinderCollectionVolumeDensity import detailedo2Analysis.plotsForPaper import detailedo2 sample_length = detailedo2Analysis.plotsForPaper.sample_length def cachelocation(g): path = posixpath.join( 'FileCS_' + myutils.checksum(basename(g.file.filename)), g.name.strip(posixpath.sep)) return (f_measure, path) f2l = myutils.f2l bbox_vessels = list() data_by_name = collections.defaultdict(list) #prop_list = ['mvd', 'mvd_a', 'mvd_v', 'mvd_c', 'rBV', 'rBV_a', 'rBV_v', 'rBV_c', 'venous_rBV_fraction', 'rBF', 'meanCapillaryDistance', 'mean_r'] #prop_list = ['rBV', 'rBF', ] #prop_list = 'phi_a phi_v phi_c mvd_a mvd_v mvd_c mean_r'.split() prop_list2 = [ 'radius', 'shearforce', 'velocity', 'flow', 'avg_cap_dist', 'mvd_linedensity', 'mvd_sphere_sampling', 'mvd', 'mvd_a', 'mvd_v', 'mvd_c', 'phi_vessels', 'phi_a', 'phi_v', 'phi_c', 'total_perfusion' ] #prop_list2 = ['radius','shearforce','velocity','flow','avg_cap_dist','mvd_linedensity','phi_vessels'] prop_data_vessel_global = ['mvd'] try: os.remove('initialvesseldata.h5') except OSError: pass with h5py.File('initialvesseldata.h5', 'w-') as f: for k, v in data_by_name.iteritems(): f.create_dataset(k, data=v) result_string = [] for name in prop_list2: data = [] for gvessels in vesselgroups: data.append( dataman.obtain_data('basic_vessel_global', name, gvessels, cachelocation(gvessels))) ld_vessels = krebsutils.read_lattice_data_from_hdf( gvessels['lattice']) bbox_vessels.append(ld_vessels.worldBox) result_string.append(r'$<%s>$ = $%s$%s' % (Prettyfier.get_sym(name), Format( name, data), Prettyfier.get_munit(name))) ld = krebsutils.read_lattice_data_from_hdf(vesselgroups[0]['lattice']) bbox_vessels.append(ld.worldBox) bbox_vessels = np.average(bbox_vessels, axis=0).reshape(3, 2).transpose() result_string += ['Vessel System Bounding Box'] + list(fmt_(bbox_vessels)) fig, _ = mpl_utils.MakeTextPage(result_string, figsize=(mpl_utils.a4size[0], mpl_utils.a4size[0])) pdfpages.savefig(fig, postfix='_vesselsglobal')
def PrintGlobalDataWithOxygen(pdfpages, po2groups, vesselgroups, f_measure, dataman): from analyzeBloodVolumeSimple import cylinderCollectionVolumeDensity import detailedo2Analysis.plotsForPaper import detailedo2 sample_length = detailedo2Analysis.plotsForPaper.sample_length def cachelocation(g): path = posixpath.join( 'FileCS_' + myutils.checksum(basename(g.file.filename)), g.name.strip(posixpath.sep)) return (f_measure, path) f2l = myutils.f2l bbox_vessels = list() bbox_field = list() data_by_name = collections.defaultdict(list) O2_prop_list = [ 'po2', 'sat', 'sat_via_hb_ratio', 'gtv', 'jtv', 'mro2', 'po2_tissue', 'chb', 'chb_oxy', 'chb_deoxy', 'oef', 'e1', 'e3', 'Jin_root', 'Jout_root', 'Jout_tv', 'Jout_cons', 'sat_vein', 'sat_art', 'sat_capi' ] prop_list = [ 'mvd', 'mvd_a', 'mvd_v', 'mvd_c', 'rBV', 'rBV_a', 'rBV_v', 'rBV_c', 'venous_rBV_fraction', 'rBF', 'meanCapillaryDistance', 'mean_r' ] #prop_list2 = ['shearforce', 'velocity'] #prop_list2 = ['velocity'] for po2group in po2groups: for prop in O2_prop_list: data = dataman.obtain_data('detailedPO2_global', prop, po2group, sample_length, cachelocation(po2group)) data_by_name[prop].append(data) ld = krebsutils.read_lattice_data_from_hdf(po2group['field_ld']) bbox_field.append(ld.worldBox) gvessels, _ = detailedo2.OpenVesselAndTumorGroups(po2group) # for prop in prop_list2: # data = dataman.obtain_data('basic_vessel_global', prop, gvessels, cachelocation(gvessels)) # data_by_name[prop].append(data) ld = krebsutils.read_lattice_data_from_hdf(gvessels['lattice']) bbox_vessels.append(ld.worldBox) rbv, a, v, c = cylinderCollectionVolumeDensity(gvessels) sa, sv, sc = data_by_name['sat_art'][-1], data_by_name['sat_vein'][ -1], data_by_name['sat_capi'][-1] data_by_name['sat_estimated_by_acv'].append( (sa * a + sv * v + sc * c) / rbv) O2_prop_list.append('sat_estimated_by_acv') try: os.remove('initialvesseldata.h5') except OSError: pass with h5py.File('initialvesseldata.h5', 'w-') as f: for k, v in data_by_name.iteritems(): f.create_dataset(k, data=v) # def fmt_(v, exponent=None, multi=1.): # avg, std = np.average(v, axis=0), np.std(v, axis=0) # if exponent is not None: # exponent_str = ('\,10^{%i}' % exponent) if exponent<>0 else '' # f = math.pow(10., exponent) # s = r'%s \pm %s%s' % (f2l(avg/f*multi, exponential=False), f2l(std/f*multi, exponential=False), exponent_str) # else: # s = r'%s \pm %s\,' % (f2l(avg*multi), f2l(std*multi)) # return s result_string = [] for name, v in myutils.iterate_items(data_by_name, O2_prop_list): result_string.append(r'$<%s>$ = $%s$%s' % (Prettyfier.get_sym(name), Format( name, v), Prettyfier.get_munit(name))) # text = FormatGeometricAndPerfusionData() prop_list2 = ['avg_cap_dist', 'mvd_linedensity'] #bbox_vessels = list() #bbox_field = list() for name in prop_list2: data = [] for gvessels in vesselgroups: data.append( dataman.obtain_data('basic_vessel_global', name, gvessels, cachelocation(gvessels))) #ld = krebsutils.read_lattice_data_from_hdf(vesselgroups[0]['lattice']) #bbox_vessels.append(ld.worldBox) result_string.append(r'$<%s>$ = $%s$%s' % (Prettyfier.get_sym(name), Format( name, data), Prettyfier.get_munit(name))) #""" some problems still exists here #need field_ld which in not consistently stored""" # mvd_exp=[] # for (gvessels,po2group) in zip(vesselgroups,po2groups): # ld = krebsutils.read_lattice_data_from_hdf(po2group['field_ld']) # mvd_sampling_results, mvd_bins = dataman.obtain_data('sphere_vessel_density', gvessels, None, suggest_bins_from_world(ld), 'radial', ld, cachelocation(gvessels)) # mvd_exp.append(np.mean(np.asarray(mvd_sampling_results)*1e6)) # # result_string.append(r'$<%s>$ = $%s$%s' % # (Prettyfier.get_sym('mvd_exp'), Format('mvd_exp', mvd_exp), Prettyfier.get_munit('mvd_exp'))) bbox_vessels = np.average(bbox_vessels, axis=0).reshape(3, 2).transpose() bbox_field = np.average(bbox_field, axis=0).reshape(3, 2).transpose() result_string += ['Vessel System Bounding Box'] + list( fmt_(bbox_vessels)) + ['FD-Grid Bounding Box'] + list(fmt_(bbox_field)) fig, _ = mpl_utils.MakeTextPage(result_string, figsize=(mpl_utils.a4size[0], mpl_utils.a4size[0])) pdfpages.savefig(fig, postfix='_vesselsglobal') fig = matplotlib.figure.Figure(figsize=(mpl_utils.a4size[0] * 0.5, mpl_utils.a4size[0] * 0.5)) ax = fig.add_axes([0.1, 0.2, 0.8, 0.75]) for po2group in po2groups: iterations = detailedo2Analysis.plotsForPaper.GetConvergenceData( po2group) x = iterations['iteration'] y = iterations['delta_vessM'] + iterations['delta_fieldM'] ax.plot(x, y) ax.set(yscale='log', xlabel='iterations', ylabel=r'$|p(new) - p(old)|_\infty$') pdfpages.savefig(fig, postfix='_convergence')
def obtain_data(self, dataman, dataname, *args): if dataname == 'ld': f, = args ld = krebsutils.read_lattice_data_from_hdf(f['field_ld']) return ld #### if dataname == 'time': if len (args) == 1: group, = args else: group = args[0][args[1]] # f, group = args return group.attrs['time'] # in hours ##### if dataname == 'fieldvariable': f, fieldname, group = args[:3] g = f[group] # group name to actual group tumor_path = tumor_path_(f, group) ld = dataman.obtain_data('ld', f) def get(name): return self.obtain_data(dataman, 'fieldvariable', f, name, group) if fieldname == 'phi_cells': data = f[tumor_path]['conc'] elif fieldname == 'dist_tumor_': data = f[tumor_path]['ls'] elif fieldname == 'theta_tumor': gtumor = f[tumor_path] if gtumor.attrs['TYPE'] == 'faketumor': data = gtumor['tc_density'] else: data = gtumor['ptc'] elif fieldname == 'phi_necro': data = f[tumor_path]['necro'] elif fieldname in ('oxy'): try: data = g['oxy'] except KeyError: data = g['fieldOxy'] elif fieldname in ('gf'): data = g['fieldGf'] elif fieldname in ('press', 'sources', 'vel'): data = f[tumor_path][fieldname] elif fieldname == 'phi_viabletumor': theta_tumor = get('theta_tumor') phi_cells = get('phi_cells') phi_necro = get('phi_necro') data = theta_tumor * (phi_cells - phi_necro) elif fieldname == 'phi_tumor': theta_tumor = get('theta_tumor') phi_cells = get('phi_cells') data = theta_tumor * phi_cells elif fieldname == 'dist_necro': phi_necro = get('phi_necro') phi_cells = get('phi_cells') tumor_contour_level = 0.5*np.average(phi_cells) data = calc_distmap(phi_necro, ld, tumor_contour_level) elif fieldname == 'dist_viabletumor': def read(gmeasure, dsname): return np.asarray(gmeasure[dsname]) def write(gmeasure, dsname): dist_tumor = get('dist_tumor') dist_necro = get('dist_necro') data = np.maximum(dist_tumor, -dist_necro) gmeasure.create_dataset(dsname, data = data, compression = 9) fm = myutils.MeasurementFile(f, h5files) data = myutils.hdf_data_caching(read, write, fm, (tumor_path, 'dist_viabletumor'), (0,1)) elif fieldname == 'phi_vessels': def read(gmeasure, name): return np.asarray(gmeasure[name]) def write(gmeasure, name): phi_vessels = CalcPhiVessels(dataman, f[group]['vessels'], ld, scaling = 1.) gmeasure.create_dataset(name, data = phi_vessels, compression = 9) fm = myutils.MeasurementFile(f, h5files) data = myutils.hdf_data_caching(read, write, fm, (group, 'phi_vessels'), (0,1)) elif fieldname == 'dist_tumor': def read(gmeasure, name): return np.asarray(gmeasure[name]) def write(gmeasure, name): ls = get('dist_tumor_') ls = -ls dist = calc_distmap(np.asarray(ls < 0., dtype=np.float32), ld, 0.5) gmeasure.create_dataset(name, data = dist, compression = 9) fm = myutils.MeasurementFile(f, h5files) data = myutils.hdf_data_caching(read, write, fm, (tumor_path, 'dist_tumor_full'), (0,1)) else: raise RuntimeError('unkown field %s' % fieldname) if len(args)>3 and args[3] == 'imslice': import plotBulkTissue return plotBulkTissue.imslice(data) else: return np.asarray(data) if dataname == 'fieldvariable_radial': property_name, tumorgroup, bins_spec, distance_distribution_name, cachelocation = args def write(gmeasure, groupname): distmap, ld = obtain_distmap_(dataman, tumorgroup, distance_distribution_name) data = dataman.obtain_data('fieldvariable', tumorgroup.file, property_name, tumorgroup.name) bins = bins_spec.arange() a = myutils.MeanValueArray.fromHistogram1d(bins, np.ravel(distmap), np.ravel(data)) ds = a.write(gmeasure, groupname) ds.attrs['BINS_SPEC'] = str(bins_spec) def read(gmeasure, groupname): assert groupname == property_name return myutils.MeanValueArray.read(gmeasure, groupname) return HdfCacheRadialDistribution((read, write), property_name, bins_spec, distance_distribution_name, cachelocation, 1) if dataname == 'approximate_tumor_radius': tumorgroup, = args def write(gmeasure, groupname): rad = ApproximateTumorRadius(dataman, tumorgroup) ds = gmeasure.create_dataset(groupname, data = rad) def read(gmeasure, groupname): return np.asscalar(gmeasure[groupname][()]) return myutils.hdf_data_caching(read, write, tumorgroup, ('approximate_tumor_radius',), (1,))
def __init__(self, name): f = h5py.File(name + '.h5', 'r') self.ld = ld = krebsutils.read_lattice_data_from_hdf(f['field_ld']) self.groups = myutils.getTimeSortedGroups(f['.'], 'out') self.f = f
import mpl_utils # blurring is used to actually compute the local average with the help of a box filter. SHOW_BLURRED_IMAGES = False if SHOW_BLURRED_IMAGES: import scipy.signal as sig import scipy.ndimage as ndimage if __name__ == '__main__': filename = sys.argv[1] grouppath = sys.argv[2] with h5py.File(filename, 'r') as file: vesselgroup = file[grouppath] ldvessels = krebsutils.read_lattice_data_from_hdf( vesselgroup['lattice']) wbbox = ldvessels.worldBox graph = krebsutils.read_vesselgraph( vesselgroup, ['position', 'radius', 'flags', 'pressure']) graph = graph.get_filtered( myutils.bbitwise_and(graph['flags'], krebsutils.CIRCULATED)) fieldld = krebsutils.SetupFieldLattice(wbbox, 3, 50., 0.) print fieldld edgevalues = graph['pressure'] edgevalues = edgevalues[graph.edgelist] thefield = krebsutils.CalcIntervascularInterpolationField( graph.edgelist, graph['radius'], graph['position'], edgevalues,
def obtain_data(self, dataman, dataname, *args): if dataname == 'blood_flow': vesselgroup, tumorgroup, cachelocation = args has_tumor = tumorgroup is not None def read(gmeasure, groupname): return dict((k, float(v[...])) for (k, v) in gmeasure[groupname].iteritems()) def write(gmeasure, groupname): #vessels = krebsutils.read_vesselgraph(vesselgroup, ['flow', 'pressure', 'position', 'flags']) vessels = dataman.obtain_data('vessel_graph', vesselgroup, ['position', 'flags', 'flow']) pos = vessels['position'] if has_tumor: ldtumor = dataman.obtain_data('ld', tumorgroup.file) dist = dataman.obtain_data('fieldvariable', tumorgroup.file, 'theta_tumor', tumorgroup.name) dist = krebsutils.sample_field(pos, dist, ldtumor, linear_interpolation=True) res = ComputeIsosurfaceBloodFlow(dataman, vesselgroup, dist, 0.5) res.update( DataTumorBloodFlow.ComputeTotalBloodFlow_(vessels)) else: res = DataTumorBloodFlow.ComputeTotalBloodFlow_(vessels) g = gmeasure.create_group(groupname) for k, v in res.iteritems(): g.create_dataset(k, data=v) #fm = myutils.MeasurementFile(f, h5files) ret = myutils.hdf_data_caching( read, write, cachelocation[0], ('global', cachelocation[1], 'tissue', 'blood_flow'), (1, 1, 1, 3)) return ret if dataname == 'blood_flow_rbf': vesselgroup, tumorgroup, cachelocation = args has_tumor = tumorgroup is not None data = dataman.obtain_data('blood_flow', vesselgroup, tumorgroup, cachelocation).copy() ldvessels = krebsutils.read_lattice_data_from_hdf( vesselgroup['lattice']) total_flow = data['total_flow_in'] total_volume = np.cumprod(ldvessels.GetWorldSize())[2] total_flow_p_volume = total_flow / total_volume data['rBF_total'] = total_flow_p_volume data['total_volume'] = total_volume if has_tumor: ldtumor = dataman.obtain_data('ld', tumorgroup.file) theta_tumor = dataman.obtain_data('fieldvariable', tumorgroup.file, 'theta_tumor', tumorgroup.name) tumor_volume = np.sum(theta_tumor) * (ldtumor.scale**3) tumor_flow = data['flow_in'] tumor_flow_p_volume = tumor_flow / tumor_volume data['rBF_tumor'] = tumor_flow_p_volume data['tumor_volume'] = tumor_volume #print 'estimated tumor volume:', tumor_volume #print 'tumor flow:', tumor_flow #print 'rBF:', tumor_flow_p_volume*60. data = dict(map(DataTumorBloodFlow.FixUnit_, data.items())) return data if dataname in ('cum_rbf_radial', 'avg_surf_vessel_rad_radial', 'sphere_vessel_density'): vesselgroup, tumorgroup, bins_spec, distance_distribution_name, ld, cachelocation = args WorkerFunction = { 'cum_rbf_radial': ComputeIsosurfaceRegionalBloodFlow, 'avg_surf_vessel_rad_radial': ComputeIsosurfaceAvgRadius, 'sphere_vessel_density': ComputeSphereVesselDensity, }[dataname] version = { 'cum_rbf_radial': 4, 'avg_surf_vessel_rad_radial': 3, 'sphere_vessel_density': 1, }[dataname] def read(gmeasure, groupname): gmeasure = gmeasure[groupname] return gmeasure['values'], gmeasure['bins'] def write(gmeasure, groupname): values, bins = ComputeIsosurfaceRadialCurve( dataman, vesselgroup, tumorgroup, bins_spec, distance_distribution_name, ld, cachelocation, WorkerFunction) gmeasure = gmeasure.create_group(groupname) gmeasure.create_dataset('values', data=values) gmeasure.create_dataset('bins', data=bins) return krebs.analyzeGeneral.HdfCacheRadialDistribution( (read, write), dataname, bins_spec, distance_distribution_name, cachelocation, version)
def write(gmeasure, measurename): assert prop == measurename gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups( po2group) if prop in ['po2', 'sat', 'gtv', 'jtv']: w = dataman.obtain_data('basic_vessel_samples', 'weight', gvessels, sample_length) d = dataman.obtain_data('detailedPO2_samples', prop, po2group, sample_length, 1, samplelocation) gmeasure.create_dataset(prop, data=myutils.WeightedAverageStd( d, weights=w)) elif prop in ['sat_vein', 'sat_capi', 'sat_art']: w = dataman.obtain_data('basic_vessel_samples', 'weight', gvessels, sample_length) d = dataman.obtain_data('detailedPO2_samples', 'sat', po2group, sample_length, 1, samplelocation) f = dataman.obtain_data('basic_vessel_samples', 'flags', gvessels, sample_length) mask = ~myutils.bbitwise_and( f, krebsutils.WITHIN_TUMOR) & myutils.bbitwise_and( f, krebsutils.CIRCULATED) m = { 'sat_vein': krebsutils.VEIN, 'sat_capi': krebsutils.CAPILLARY, 'sat_art': krebsutils.ARTERY } mask &= myutils.bbitwise_and(f, m[prop]) d, w = d[mask], w[mask] gmeasure.create_dataset(prop, data=myutils.WeightedAverageStd( d, weights=w)) elif prop in [ 'e1', 'e2', 'e3', 'Jin_root', 'Jout_root', 'Jout_tv', 'tv_cons', 'Jout_cons' ]: d = dataman.obtain_data('detailedPO2_total_fluxes', prop, po2group, sample_length, 1, samplelocation) gmeasure.create_dataset(prop, data=[d[prop], 0]) elif prop == 'po2_tissue': _, po2ld, po2field, parameters = dataman.obtain_data( 'detailedPO2', po2group) d = myutils.largeDatasetAverageAndStd(po2field) gmeasure.create_dataset(prop, data=d) elif prop == 'mro2': uptakefield = detailedo2.computeO2Uptake(po2group, gtumor) d = myutils.largeDatasetAverageAndStd(uptakefield) gmeasure.create_dataset(prop, data=d) elif prop in ('sat_via_hb_ratio', 'vfhb_oxy', 'vfhb_deoxy', 'vfhb'): weight = dataman.obtain_data('basic_vessel_samples', 'weight', gvessels, sample_length) flags = dataman.obtain_data('basic_vessel_samples', 'flags', gvessels, sample_length) mask = myutils.bbitwise_and(flags, krebsutils.CIRCULATED) hema = dataman.obtain_data('basic_vessel_samples', 'hematocrit', gvessels, sample_length)[mask] sat = dataman.obtain_data('detailedPO2_samples', 'sat', po2group, sample_length, None, samplelocation)[mask] rad = dataman.obtain_data('basic_vessel_samples', 'radius', gvessels, sample_length)[mask] weight = weight[mask] hbvolume = weight * rad * rad * math.pi * hema ld = krebsutils.read_lattice_data_from_hdf( po2group['field_ld']) volume = np.product(ld.GetWorldSize()) if prop == 'sat_via_hb_ratio': result = np.sum(hbvolume * sat) / np.sum(hbvolume) elif prop == 'vfhb_oxy': result = np.sum(hbvolume * sat) / volume elif prop == 'vfhb_deoxy': result = np.sum(hbvolume * (1. - sat)) / volume elif prop == 'vfhb': result = np.sum(hbvolume) / volume gmeasure.create_dataset(prop, data=[result, 0.]) elif prop in ('chb_oxy', 'chb_deoxy', 'chb'): m = { 'chb_oxy': 'vfhb_oxy', 'chb_deoxy': 'vfhb_deoxy', 'chb': 'vfhb' } result = dataman.obtain_data('detailedPO2_global', m[prop], po2group, sample_length, cachelocation) result = result * detailedo2.chb_of_rbcs gmeasure.create_dataset(prop, data=[result, 0.]) elif prop == 'mro2_by_j': fluxes = dataman.obtain_data('detailedPO2_total_fluxes', prop, po2group, sample_length, 1) ld = krebsutils.read_lattice_data_from_hdf( po2group['field_ld']) worldbb = ld.worldBox result = fluxes['Jout_tv'] / np.prod(worldbb[1] - worldbb[0]) * 1.e12 gmeasure.create_dataset(prop, data=[result, 0.]) elif prop == 'oef': fluxes = dataman.obtain_data('detailedPO2_total_fluxes', prop, po2group, sample_length, 1, samplelocation) result = (fluxes['Jin_root'] - fluxes['Jout_root']) / fluxes['Jin_root'] gmeasure.create_dataset(prop, data=[result, 0.]) else: assert False
def write(gmeasure, groupname): ld = krebsutils.read_lattice_data_from_hdf(vesselgroup['lattice']) volume = np.prod(ld.GetWorldSize()) if property_name == 'mvd_linedensity': graph = dataman.obtain_data('vessel_graph', vesselgroup, ['length']) l = np.asarray(graph['length'], dtype=np.float64) data = (np.sum(l) / volume, 0.) data = [d*1e6 for d in data] #from 1/mum^2 to 1/mm^2 elif property_name in 'phi_vessels phi_a phi_v phi_c'.split(): from analyzeBloodVolumeSimple import cylinderCollectionVolumeDensity phi_vessels, phi_a, phi_v, phi_c = cylinderCollectionVolumeDensity(vesselgroup) if property_name == 'phi_vessels': data = [phi_vessels, 0.] if property_name == 'phi_a': data = [phi_a, 0.] if property_name == 'phi_v': data = [phi_v, 0.] if property_name == 'phi_c': data = [phi_c, 0.] elif property_name in 'mvd mvd_a mvd_v mvd_c'.split(): from analyzeBloodVolumeSimple import cylinderCollectionLineDensity mvd, mvd_a, mvd_v, mvd_c = cylinderCollectionLineDensity(vesselgroup) if property_name == 'mvd': data = [mvd, 0.] if property_name == 'mvd_a': data = [mvd_a, 0.] if property_name == 'mvd_v': data = [mvd_v, 0.] if property_name == 'mvd_c': data = [mvd_c, 0.] elif property_name == 'mvd_sphere_sampling': ld = krebsutils.read_lattice_data_from_hdf(vesselgroup.parent['field_ld']) mvd_sampling_results, mvd_bins = dataman.obtain_data('sphere_vessel_density', vesselgroup, None, suggest_bins_from_world(ld), 'radial', ld, cachelocation ) #print(mvd_sampling_results) data = [ np.mean(np.asarray(mvd_sampling_results)*1e6), np.std(np.asarray(mvd_sampling_results)*1e6)] elif property_name == 'avg_cap_dist': vessels = krebsutils.read_vesselgraph(vesselgroup, ['flags', 'length','radius']) flags = RemoveArteriovenousFlagsFromCapillaries(vessels['flags']) mask1 = myutils.bbitwise_and(flags, krebsutils.CIRCULATED) #totalvol = totalLdVolume(vesselgroup) def compute(flagMask): if flagMask: mask = mask1 & myutils.bbitwise_and(flags, flagMask) else: mask = mask1 length = np.asarray(vessels['length'][mask], dtype = np.float64) total = np.sum(length) return total/volume '''luedemann et. al. assume capillaries are vessels smaller than this: see manuscript draft ''' mvd_cap = compute((vessels['radius']<=4.0).all()) data = (np.sqrt(1/mvd_cap), 0.) elif property_name == 'phi_vessels': graph = dataman.obtain_data('vessel_graph', vesselgroup, ['length','radius']) l = np.asarray(graph['length'], dtype=np.float64) r = np.asarray(graph['radius'], dtype=np.float64) data = l*np.square(r)*math.pi data = (np.sum(data) / volume, 0.) elif property_name == 'total_perfusion': data = getTotalPerfusion([vesselgroup])*60 #to minutes else: data = dataman.obtain_data('basic_vessel_samples', property_name, vesselgroup, 30.) weight = dataman.obtain_data('basic_vessel_samples', 'weight', vesselgroup, 30.) data = myutils.WeightedAverageStd(data, weights=weight) gmeasure.create_dataset(groupname, data = data)
def runSTFTest(): params = dict( tend=0.01, out_intervall=0.0001, stepper='impeuler', fn_out='sfttest', num_threads=2, kdiff=10., kstf=0.5, ) ld = krebsutils.LatticeDataQuad3d((0, 49, 0, 49, 0, 0), 1. / 50.) ld.SetCellCentering((True, True, False)) extent = ld.worldBox[:4] #f_conc = lambda x,y,z: zalesakDisk((x,y,z), 0.3, (0.5,0.5,0.)) f_conc = lambda x, y, z: circle_distfunc(x, y, z, 0.3, (0.5, 0.5, 0.)) if not os.path.isfile('sfttest.h5'): surfaceTensionForceTest(dicttoinfo(params), ld, dict(conc_profile=f_conc)) rc = matplotlib.rc rc('font', size=8.) rc('axes', titlesize=10., labelsize=10.) rc('figure', **{'subplot.wspace': 0.15, 'subplot.hspace': 0.15}) rc('savefig', facecolor='white') dpi = 100. results = Results('sfttest') ldface = (krebsutils.read_lattice_data_from_hdf(results.f['face_ld_0']), krebsutils.read_lattice_data_from_hdf(results.f['face_ld_1'])) extface = tuple(q.worldBox[:4] for q in ldface) data = collections.defaultdict(list) for idx, group in enumerate(results): def show(a, ext): pyplot.imshow(np.asarray(a[..., 0]).transpose(), extent=ext, origin='bottom', interpolation='nearest') def contour(): return pyplot.contour(np.asarray(group['ls'][..., 0]).transpose(), levels=[0.], extent=extent, origin='lower') print "plotting %i" % idx if 1: pyplot.figure(figsize=(1200. / dpi, 1000. / dpi)) # pyplot.subplot(221) # show(group['ls'], extent) # pyplot.colorbar() # contour() # pyplot.subplot(222) # show(group['rho'], extent) # pyplot.colorbar() # contour() pyplot.subplot(221) pyplot.plot(np.linspace(extent[0], extent[1], 50), group['ls'][:, 25, 0]) pyplot.gca().set(xlabel='x', ylabel=r'$\phi$') pyplot.gca().grid(color=(0.5, ) * 3) pyplot.subplot(222) pyplot.plot(np.linspace(extent[0], extent[1], 50), group['rho'][:, 25, 0]) pyplot.gca().set(xlabel='x', ylabel=r'$\rho$') pyplot.gca().grid(color=(0.5, ) * 3) pyplot.subplot(223) show(group['force_0'], extface[0]) pyplot.colorbar() contour() pyplot.subplot(224) show(group['force_1'], extface[1]) pyplot.colorbar() contour() pyplot.savefig("sfttest%04i.png" % idx, dpi=dpi) data['time'].append(group.attrs['time']) data['mass'].append(group.attrs['mass']) data['area'].append(group.attrs['area']) pyplot.figure(figsize=(1200. / dpi, 600. / dpi)) pyplot.subplot(121) pyplot.plot(data['time'], data['mass'], marker='x') pyplot.gca().set(xlabel='t', ylabel='mass') pyplot.subplot(122) pyplot.plot(data['time'], data['area'], marker='+') pyplot.gca().set(xlabel='t', ylabel='area') pyplot.savefig('vstime.png')
def renderScene(vesselgroup, tumorgroup, imagefn, options): if vesselgroup is not None: vgrp = vesselgroup['lattice'] wbbox = krebsutils.read_lattice_data_from_hdf_by_filename( str(vgrp.file.filename), str(vgrp.name)).worldBox else: wbbox = krebsutils.read_lattice_data_from_hdf( tumorgroup.file['field_ld']).worldBox trafo = calc_centering_normalization_trafo(wbbox) zsize = (wbbox[5] - wbbox[4]) vessel_ld = krebsutils.read_lattice_data_from_hdf_by_filename( str(vesselgroup.file.filename), str(vesselgroup.name) + '/lattice') options.wbbox = vessel_ld.GetWorldBox() with EasyPovRayRender(options) as epv: epv.setBackground(options.background) cam = options.cam if cam in ('topdown', 'topdown_slice'): cam_fov = 60. cam_distance_factor = options.cam_distance_multiplier * ComputeCameraDistanceFactor( cam_fov, options.res, wbbox) epv.addLight(10 * Vec3(1.7, 1.2, 2), 1., area=(4, 4, 3, 3), jitter=True) if cam == 'topdown_slice': imagefn += '_slice' options.vessel_clip = ('zslice', -201 * trafo.w, 201 * trafo.w) options.tumor_clip = ('zslice', -100 * trafo.w, 100 * trafo.w) epv.setCamera( (0, 0, cam_distance_factor * 0.5 * (200. * trafo.w + 2.)), (0, 0, 0), cam_fov, up='y') else: imagefn += '_top' epv.setCamera( (0, 0, cam_distance_factor * 0.5 * (zsize * trafo.w + 2.)), (0, 0, 0), cam_fov, up='y') else: imagefn += '_pie' cam_fov = 60. basepos = options.cam_distance_multiplier * np.asarray( (0.6, 0.7, 0.55)) * (1. / 1.4) * math.tan( math.pi * 0.25) / math.tan(math.pi / 180. / 2. * cam_fov) epv.setCamera(basepos, (0, 0, 0), cam_fov, up=(0, 0, 1)) num_samples_large_light = 4 num_samples_small_light = 2 epv.addLight(10 * Vec3(0.7, 1., 0.9), 0.8, area=(1., 1., num_samples_small_light, num_samples_small_light), jitter=True) epv.addLight(10 * Vec3(0.5, 0.5, 0.5), 0.6, area=(5., 5., num_samples_large_light, num_samples_large_light), jitter=True) options.vessel_clip = ('pie', 0.) options.tumor_clip = ('pie', -50 * trafo.w) if vesselgroup is not None: graph = krebsutils.read_vessels_from_hdf( vesselgroup, ['position', 'flags', 'radius', 'pressure'], return_graph=True) if options.filteruncirculated: graph = graph.get_filtered(edge_indices=myutils.bbitwise_and( graph['flags'], krebsutils.CIRCULATED)) if 'colorfactory' in options: print('colorfactory is in options') colorfactory = options.colorfactory else: print('colorfactory not in options') colorfactory = make_pressure_color_arrays colorfactory(graph) #addVesselTree(epv, graph, trafo, vesselgroup = vesselgroup, options) epv.addVesselTree2(epv, graph, trafo, options) if tumorgroup is not None and 'conc' in tumorgroup: addBulkTissueTumor(epv, tumorgroup, trafo, options) if (tumorgroup is not None and tumorgroup.attrs['TYPE'] == 'faketumor'): print('nix') if options.noOverlay: epv.render(imagefn + '.png') else: povrayEasy.RenderImageWithOverlay(epv, imagefn + '.png', None, 'tumor', options)
def obtain_data(self, dataman, dataname, *args): if dataname == 'detailedPO2Parameters': po2group, = args return detailedo2.readParameters(po2group) if dataname == 'detailedPO2': po2group, = args a = np.asarray(po2group['po2vessels']) if a.shape[0] <> 2: a = np.transpose(a) po2field = po2group['po2field'] ld = krebsutils.read_lattice_data_from_hdf(po2group['field_ld']) parameters = dataman.obtain_data('detailedPO2Parameters', po2group) return a, ld, po2field, parameters if dataname == 'detailedPO2_consumption': po2group, tumorgroup = args return detailedo2.computeO2Uptake(po2group, tumorgroup) if dataname == 'detailedPO2_samples' or dataname == 'detailedPO2_total_fluxes': prop, po2group, sample_length, every, cachelocation = args def read(gmeasure, name): gmeasure = gmeasure[name] if dataname == 'detailedPO2_samples': if prop == 'gtv': parameters = dataman.obtain_data( 'detailedPO2Parameters', po2group) #po2 = dataman.obtain_data('detailedPO2_samples','po2', *args[1:]) #extpo2 = dataman.obtain_data('detailedPO2_samples','extpo2', *args[1:]) #return (po2-extpo2)/(parameters['grid_lattice_const']*parameters.get('transvascular_ring_size',0.5)) gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups( po2group) jtv = dataman.obtain_data('detailedPO2_samples', 'jtv', *args[1:]) #radius = dataman.obtain_data('basic_vessel_samples', 'radius', gvessels, sample_length) #radius = radius * (60.e-4*math.pi*2.* parameters['kD_tissue']*parameters['alpha_t']) radius = ( 60.e-4 * parameters.get('D_tissue', parameters.get('kD_tissue', None)) * parameters.get('solubility_tissue', parameters.get('alpha_t', None))) gtv = jtv / radius return gtv elif prop == 'sat': po2 = dataman.obtain_data('detailedPO2_samples', 'po2', *args[1:]) parameters = dataman.obtain_data( 'detailedPO2Parameters', po2group) return detailedo2.PO2ToSaturation(po2, parameters) else: ds = gmeasure['smpl_' + prop] ds = ds[...] if every is None else ds[::every] return ds else: keys = filter(lambda k: k.startswith('flux_'), gmeasure.keys()) fluxes = dict(map(lambda k: (k[5:], gmeasure[k][()]), keys)) fluxes['e1'] = abs( 100. * (fluxes['Jin_root'] - fluxes['Jout_root'] - fluxes['Jout_tv']) / fluxes['Jin_root']) fluxes['e2'] = abs( 100. * (fluxes['Jin_root'] - fluxes['Jout_root'] - fluxes['Jout_cons'] - fluxes.get('tv_cons', 0.)) / fluxes['Jin_root']) fluxes['e3'] = abs( 100. * (fluxes['Jout_tv'] - fluxes['Jout_cons'] - fluxes.get('tv_cons', 0.)) / fluxes['Jout_tv']) return fluxes def write(gmeasure, name): # do the sampling gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups( po2group) smpl, fluxes = detailedo2.sampleVessels( po2group, gvessels, gtumor, sample_length) #cons = dataman.detailedPO2_consumption(po2group, gtumor) cons = dataman.obtain_data('detailedPO2_consumption', po2group, gtumor) # get the raw data, just for the consumption flux po2vessels, ld, po2field, parameters = dataman.obtain_data( 'detailedPO2', po2group) avgCons = np.asarray(myutils.largeDatasetAverage(cons), dtype=np.float64) fluxes['Jout_cons'] = avgCons * np.product( cons.shape) * (ld.scale * 1.e-4)**3 del po2vessels, po2field, ld gmeasure = gmeasure.create_group(name) for k, v in smpl.iteritems(): gmeasure.create_dataset('smpl_' + k, data=v, compression=9, dtype=np.float32) for k, v in fluxes.iteritems(): gmeasure.create_dataset('flux_' + k, data=v) # scalar dataset version_id = myutils.checksum(sample_length, 3, getuuid_(po2group)) ret = myutils.hdf_data_caching( read, write, cachelocation[0], (cachelocation[1], 'samples_and_fluxes'), (None, version_id)) return ret if dataname == 'detailedPO2_global': prop, po2group, sample_length, cachelocation = args samplelocation = MakeSampleLocation(po2group) def write(gmeasure, measurename): assert prop == measurename gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups( po2group) if prop in ['po2', 'sat', 'gtv', 'jtv']: w = dataman.obtain_data('basic_vessel_samples', 'weight', gvessels, sample_length) d = dataman.obtain_data('detailedPO2_samples', prop, po2group, sample_length, 1, samplelocation) gmeasure.create_dataset(prop, data=myutils.WeightedAverageStd( d, weights=w)) elif prop in ['sat_vein', 'sat_capi', 'sat_art']: w = dataman.obtain_data('basic_vessel_samples', 'weight', gvessels, sample_length) d = dataman.obtain_data('detailedPO2_samples', 'sat', po2group, sample_length, 1, samplelocation) f = dataman.obtain_data('basic_vessel_samples', 'flags', gvessels, sample_length) mask = ~myutils.bbitwise_and( f, krebsutils.WITHIN_TUMOR) & myutils.bbitwise_and( f, krebsutils.CIRCULATED) m = { 'sat_vein': krebsutils.VEIN, 'sat_capi': krebsutils.CAPILLARY, 'sat_art': krebsutils.ARTERY } mask &= myutils.bbitwise_and(f, m[prop]) d, w = d[mask], w[mask] gmeasure.create_dataset(prop, data=myutils.WeightedAverageStd( d, weights=w)) elif prop in [ 'e1', 'e2', 'e3', 'Jin_root', 'Jout_root', 'Jout_tv', 'tv_cons', 'Jout_cons' ]: d = dataman.obtain_data('detailedPO2_total_fluxes', prop, po2group, sample_length, 1, samplelocation) gmeasure.create_dataset(prop, data=[d[prop], 0]) elif prop == 'po2_tissue': _, po2ld, po2field, parameters = dataman.obtain_data( 'detailedPO2', po2group) d = myutils.largeDatasetAverageAndStd(po2field) gmeasure.create_dataset(prop, data=d) elif prop == 'mro2': uptakefield = detailedo2.computeO2Uptake(po2group, gtumor) d = myutils.largeDatasetAverageAndStd(uptakefield) gmeasure.create_dataset(prop, data=d) elif prop in ('sat_via_hb_ratio', 'vfhb_oxy', 'vfhb_deoxy', 'vfhb'): weight = dataman.obtain_data('basic_vessel_samples', 'weight', gvessels, sample_length) flags = dataman.obtain_data('basic_vessel_samples', 'flags', gvessels, sample_length) mask = myutils.bbitwise_and(flags, krebsutils.CIRCULATED) hema = dataman.obtain_data('basic_vessel_samples', 'hematocrit', gvessels, sample_length)[mask] sat = dataman.obtain_data('detailedPO2_samples', 'sat', po2group, sample_length, None, samplelocation)[mask] rad = dataman.obtain_data('basic_vessel_samples', 'radius', gvessels, sample_length)[mask] weight = weight[mask] hbvolume = weight * rad * rad * math.pi * hema ld = krebsutils.read_lattice_data_from_hdf( po2group['field_ld']) volume = np.product(ld.GetWorldSize()) if prop == 'sat_via_hb_ratio': result = np.sum(hbvolume * sat) / np.sum(hbvolume) elif prop == 'vfhb_oxy': result = np.sum(hbvolume * sat) / volume elif prop == 'vfhb_deoxy': result = np.sum(hbvolume * (1. - sat)) / volume elif prop == 'vfhb': result = np.sum(hbvolume) / volume gmeasure.create_dataset(prop, data=[result, 0.]) elif prop in ('chb_oxy', 'chb_deoxy', 'chb'): m = { 'chb_oxy': 'vfhb_oxy', 'chb_deoxy': 'vfhb_deoxy', 'chb': 'vfhb' } result = dataman.obtain_data('detailedPO2_global', m[prop], po2group, sample_length, cachelocation) result = result * detailedo2.chb_of_rbcs gmeasure.create_dataset(prop, data=[result, 0.]) elif prop == 'mro2_by_j': fluxes = dataman.obtain_data('detailedPO2_total_fluxes', prop, po2group, sample_length, 1) ld = krebsutils.read_lattice_data_from_hdf( po2group['field_ld']) worldbb = ld.worldBox result = fluxes['Jout_tv'] / np.prod(worldbb[1] - worldbb[0]) * 1.e12 gmeasure.create_dataset(prop, data=[result, 0.]) elif prop == 'oef': fluxes = dataman.obtain_data('detailedPO2_total_fluxes', prop, po2group, sample_length, 1, samplelocation) result = (fluxes['Jin_root'] - fluxes['Jout_root']) / fluxes['Jin_root'] gmeasure.create_dataset(prop, data=[result, 0.]) else: assert False def read(gmeasure, measurename): d = np.asarray(gmeasure[measurename]) if measurename in ('chb_oxy', 'chb', 'chb_deoxy'): d *= 1.e6 return d[0] # its a tuple (avg, std), we want avg now. version_num = collections.defaultdict(lambda: 3) version_id = myutils.checksum(sample_length, version_num[prop], getuuid_(po2group)) #version_id = myutils.checksum(sample_length, (2 if prop in else 1)) return myutils.hdf_data_caching(read, write, cachelocation[0], ('global', cachelocation[1], prop), (1, 1, version_id)) if dataname == 'detailedPO2_radial': po2group, sample_length, bins_spec, distance_distribution_name, cachelocation = args samplelocation = MakeSampleLocation(po2group) # we assume that there is a tumor. without this measurement makes little sense def read(gmeasure, name): d = dict(gmeasure[name].items()) d = dict( (k, myutils.MeanValueArray.read(v)) for k, v in d.items()) hbo = d['vfhb_oxy'] hbd = d['vfhb_deoxy'] hb = myutils.MeanValueArray(hbo.cnt, hbo.sum + hbd.sum, hbo.sqr + hbd.sqr) d['vfhb'] = hb sat = hbo.avg / hb.avg d['sat_via_hb_ratio'] = myutils.MeanValueArray( np.ones_like(hb.cnt), sat, sat * sat) d['chb_oxy'] = d['vfhb_oxy'] * detailedo2.chb_of_rbcs * 1.e6 d['chb_deoxy'] = d['vfhb_deoxy'] * detailedo2.chb_of_rbcs * 1.e6 d['chb'] = d['vfhb'] * detailedo2.chb_of_rbcs * 1.e6 return d def write(gmeasure, name): gvessels, gtumor = detailedo2.OpenVesselAndTumorGroups( po2group) weight_smpl = dataman.obtain_data('basic_vessel_samples', 'weight', gvessels, sample_length) flags = dataman.obtain_data('basic_vessel_samples', 'flags', gvessels, sample_length) # get teh radial distance function (either distance from tumor border or distance from center) dist_smpl, distmap, mask, tumor_ld = dataman.obtain_data( 'distancemap_samples', gvessels, gtumor, sample_length, distance_distribution_name, None) # tumor_ld might actually be a unrelated lattice #filter uncirculated mask = mask & myutils.bbitwise_and(flags, krebsutils.CIRCULATED) dist_smpl = dist_smpl[mask] weight_smpl = weight_smpl[mask] bins = bins_spec.arange() gmeasure = gmeasure.create_group(name) for name in ['po2', 'extpo2', 'jtv', 'sat', 'gtv', 'dS_dx']: smpl = dataman.obtain_data('detailedPO2_samples', name, po2group, sample_length, None, samplelocation) myutils.MeanValueArray.fromHistogram1d( bins, dist_smpl, smpl[mask], w=weight_smpl).write(gmeasure, name) del smpl _, po2ld, po2field, parameters = dataman.obtain_data( 'detailedPO2', po2group) po2field = krebsutils.resample_field(np.asarray(po2field), po2ld.worldBox, tumor_ld.shape, tumor_ld.worldBox, order=1, mode='nearest') myutils.MeanValueArray.fromHistogram1d(bins, distmap.ravel(), po2field.ravel()).write( gmeasure, 'po2_tissue') del po2field uptakefield = detailedo2.computeO2Uptake(po2group, gtumor) uptakefield = krebsutils.resample_field(uptakefield, po2ld.worldBox, tumor_ld.shape, tumor_ld.worldBox, order=1, mode='nearest') myutils.MeanValueArray.fromHistogram1d( bins, distmap.ravel(), uptakefield.ravel()).write(gmeasure, 'mro2') del uptakefield hema = dataman.obtain_data('basic_vessel_samples', 'hematocrit', gvessels, sample_length)[mask] sat = dataman.obtain_data('detailedPO2_samples', 'sat', po2group, sample_length, None, samplelocation)[mask] rad = dataman.obtain_data('basic_vessel_samples', 'radius', gvessels, sample_length)[mask] hbvolume = weight_smpl * rad * rad * math.pi * hema vol_per_bin = myutils.MeanValueArray.fromHistogram1d( bins, distmap.ravel(), np.ones_like( distmap.ravel())).cnt * (tumor_ld.scale**3) tmp = myutils.MeanValueArray.fromHistogram1d( bins, dist_smpl, hbvolume * sat) tmp.cnt = vol_per_bin.copy() tmp.write(gmeasure, 'vfhb_oxy') tmp = myutils.MeanValueArray.fromHistogram1d( bins, dist_smpl, hbvolume * (1. - sat)) tmp.cnt = vol_per_bin.copy() tmp.write(gmeasure, 'vfhb_deoxy') del tmp, hbvolume, vol_per_bin version = getuuid_(po2group) ret = analyzeGeneral.HdfCacheRadialDistribution( (read, write), 'po2', bins_spec, distance_distribution_name, cachelocation, version) return ret assert False
def vess_size_to_tum_size(fn, tum_lattice_const): vesselgroup = h5files.open(fn, 'r')['/vessels'] if __debug__: print("vesselgroup.id.id: %i" % vesselgroup.id.id) ld = krebsutils.read_lattice_data_from_hdf( krebsutils.find_lattice_group_(vesselgroup)) ld_vessels = krebsutils.read_lattice_data_from_hdf(vesselgroup['lattice']) bbox = ld_vessels.worldBox boxLengths = ((bbox[1] - bbox[0]), (bbox[3] - bbox[2]), (bbox[5] - bbox[4])) number_of_numerical_grid_points = np.ceil( (np.asarray(boxLengths) + .5) / tum_lattice_const) for (i, x) in enumerate(number_of_numerical_grid_points): if x == 1: number_of_numerical_grid_points[i] = 2 del vesselgroup l = ld.shape s = int(ld.scale) """ mapping from: latticesize initial vesselsnetwork to numical lattice of tissue lattice first number: size x second number: size z third number: lattice constant """ vs = { (9, 1, 130): (10, 10), #div runtime test (100, 6, 80): (228, 10), # 100x5.80 (100, 62, 80): (196, 128), #100x50.80 (200, 6, 80): (384, 10), #200x5.80 (60, 75, 80): (128, 128), #60x60.80 # now hierarchical builds (167, 17, 80): (300, 34), (103, 121, 80): (150, 150), # with large lattice spacing (59, 69, 150): (160, 160), (63, 65, 150): (160, 160), #(103,121,80) : (200, 200), # a special extra large configuration # 7x7 * 2^3 hierarchical biulds (127, 129, 80): (150, 150), # actual size could be 270**3 # twodimensional system (160, 1, 80): (350, 1), # quasi twodimensional (163, 9, 80): (350, 24), (59, 9, 150): (250, 32), # small system (31, 5, 150): (80, 16), # 16 cm flat (111, 9, 150): (267, 32), # 8mm P10 3d #(55,61, 130) : (80,90), #(55,61, 130) : (155,155), (55, 61, 130): (100, 100), # 8mm P10 q2d (59, 5, 130): (100, 15), (47, 9, 130): (50, 20), # for testing 3d_mini_mini (14, 18, 130): (40, 40), # trastuzumab calibration growth (53, 65, 80): (100, 100), # 5mm P11 q2d, 5mm x 5mm x 0.3mm (59, 5, 90): (int(4000. / tum_lattice_const), int(300. / tum_lattice_const + 0.5)), # swine h1 (17, 19, 75): (int(1200. / tum_lattice_const), int(1200. / tum_lattice_const)), # swine h2 (35, 37, 75): (int(1400. / tum_lattice_const), int(1400. / tum_lattice_const)), # swine h2 -big (67, 77, 75 (67, 77, 75): (int(5000. / tum_lattice_const), int(5000. / tum_lattice_const)), # 4mm x 0.3 P? ?? (51, 57, 88): (int(4000. / tum_lattice_const), int(4000. / tum_lattice_const)), #the vessBigTras (119, 141, 88): (int(10000. / tum_lattice_const), int(10000. / tum_lattice_const)), } #[(l[0],l[2],s)] theKey = (l[0], l[2], s) if theKey in vs: return (vs[theKey][0], vs[theKey][0], vs[theKey][1]) else: print('Warning: Guessed tum grid size') return number_of_numerical_grid_points.astype(int)
def renderScene(drug_grp, imagefn, options): max_conc = getMaxConcentration(drug_grp.file) dataman = myutils.DataManager(2, [DataBasicVessel()]) timepoint = drug_grp.attrs['time'] #comes in seconds timepoint = timepoint / 3600. gvessels = drug_grp.parent['iff/vessels'] iff_pressure_field = drug_grp.parent['iff/iff_pressure'] drug_conc_field = drug_grp['conc'] cell_drug_conc_field = drug_grp['conc_cell'] ex_drug_conc_field = drug_grp['conc_ex'] #ex_drug_auc_field = drug_grp.parent['measurements/drug_local_integral']['auc_ex'] #in_drug_auc_field = drug_grp.parent['measurements/drug_local_integral']['auc_in'] iff_ld = krebsutils.read_lattice_data_from_hdf(drug_grp.parent['field_ld']) #ld = iffgroup['lattice'] #po2vessels, po2field_ld, po2field, parameters = dataman('detailedPO2', po2group) #po2vessels = np.average(po2vessels, axis=0) #print 'po2vessels:', po2vessels.min(), po2vessels.max() print 'ifpfield:', np.amin(iff_pressure_field), np.amax(iff_pressure_field) print 'drug_conc_field:', np.amin(drug_conc_field), np.amax( drug_conc_field) vessel_ld = krebsutils.read_lattice_data_from_hdf(gvessels['lattice']) vessel_graph = dataman('vessel_graph', gvessels, ['position', 'flags', 'radius']) #vessel_graph.edges['po2vessels'] = po2vessels #vessel_graph.edges['saturation'] = PO2ToSaturation(po2vessels, parameters) #vessel_graph.edges['hboconc'] = vessel_graph.edges['saturation']*vessel_graph.edges['hematocrit']*chb_of_rbcs*1.0e3 vessel_graph = vessel_graph.get_filtered(edge_indices=myutils.bbitwise_and( vessel_graph['flags'], krebsutils.CIRCULATED)) if options.filterradiuslowpass > 0.0: print("lowpass filter activated:") vessel_graph = vessel_graph.get_filtered( edge_indices=vessel_graph['radius'] < kwargs['filterradiuslowpass'] ) imagefn, ext = splitext(imagefn) ext = '.' + options.format if 1: if timepoint == 0: renderSliceWithDistribution( (vessel_ld, vessel_graph, 'iff_pressure'), (iff_ld, iff_pressure_field), (imagefn + '_iff_pressure_t%0.1fh' % timepoint) + ext, 'IF pressure t=%.1f h' % timepoint, options, max_conc=max_conc) renderSliceWithDistribution( (vessel_ld, vessel_graph, 'drug_conc'), (iff_ld, drug_conc_field), (imagefn + '_iff_drug_t%0.1fh' % timepoint) + ext, '%s t=%.1f h' % (drug_grp.file.attrs.get('MESSAGE'), timepoint), options, max_conc=max_conc) #renderSliceWithDistribution((vessel_ld, vessel_graph, 'drug_conc'), (iff_ld, cell_drug_conc_field), (imagefn+'_iff_drug_incell_t%0.1fh'%timepoint)+ext, 'Tr. intr. t=%.1f h'%timepoint, kwargs) #renderSliceWithDistribution((vessel_ld, vessel_graph, 'drug_conc'), (iff_ld, ex_drug_conc_field), (imagefn+'_iff_drug_excell_t%0.1fh'%timepoint)+ext, 'Tr. extr. t=%.1f h'%timepoint, kwargs) if options.plot_auc: renderSliceWithDistribution((vessel_ld, vessel_graph, 'auc'), (iff_ld, ex_drug_auc_field), imagefn + '_iff_ex_drug_auc' + ext, 'Tr. extr. t=%.1f h' % timepoint, options, max_conc=max_conc) #renderSliceWithDistribution((vessel_ld, vessel_graph, 'auc'), (iff_ld, in_drug_auc_field), imagefn+'_iff_in_drug_auc'+ext, 'Tr. intr. t=%.1f h'%timepoint, kwargs) if 0: renderSlice((vessel_ld, vessel_graph, 'radius'), (iff_ld, iff_pressure_field), imagefn + '_iff_pressure' + ext, '', options) renderSlice((vessel_ld, vessel_graph, 'radius'), (iff_ld, drug_conc_field), imagefn + '_iff_drug' + ext, '', options) renderSlice((vessel_ld, vessel_graph, 'radius'), (iff_ld, cell_drug_conc_field), imagefn + '_iff_drug_incell' + ext, '', options) renderSlice((vessel_ld, vessel_graph, 'radius'), (iff_ld, ex_drug_conc_field), imagefn + '_iff_drug_excell' + ext, '', options)
def sample_vessel_system(goodArguments): filename = goodArguments.vesselFileNames grouppath = goodArguments.grp_pattern with h5py.File(filename, 'r') as file: if ('vessels' in grouppath): print('found vessels!') vesselgroup = file[grouppath] else: if ('out' in grouppath): outgroup = file[grouppath] print('found tumor of type: %s' % str(outgroup['tumor'].attrs.get('TYPE'))) vesselgroup = file[grouppath + '/vessels'] else: print("unknown data structure!") ldvessels = krebsutils.read_lattice_data_from_hdf( vesselgroup['lattice']) wbbox = ldvessels.worldBox graph = krebsutils.read_vesselgraph(vesselgroup, ['position', 'flags']) graph = graph.get_filtered( myutils.bbitwise_and(graph['flags'], krebsutils.CIRCULATED)) print 'vessel ld:' print ldvessels ''' this splits splits space in lattices of 300. the second 300 adds a 'safety layer of 100. mum so we do not consider the outermost data for calculating the actual mvd ''' sampling_lattice_spacing = goodArguments.sampling_lattice_spacing fieldld = krebsutils.SetupFieldLattice(wbbox, 3, sampling_lattice_spacing, 100.) wbbox = fieldld.worldBox print 'field ld:' print fieldld z = fieldld.shape[2] / 2 longitudinal_sampling_distance = goodArguments.longitudinal weights = krebsutils.sample_edges_weights(graph.nodes['position'], graph.edgelist, longitudinal_sampling_distance) positions = krebsutils.sample_edges( graph.nodes['position'], graph.edgelist, graph.nodes['position'], longitudinal_sampling_distance, krebsutils.VesselSamplingFlags.DATA_PER_NODE | krebsutils.VesselSamplingFlags.DATA_LINEAR) eps = 1.0 - 1.e-15 x0, x1, y0, y1, z0, z1 = wbbox ranges = [ np.arange(x0, x1, fieldld.scale * eps), np.arange(y0, y1, fieldld.scale * eps), np.arange(z0, z1, fieldld.scale * eps), ] print 'histogram bin ends:', map(lambda r: (r.min(), r.max()), ranges) mvd, _ = np.histogramdd(positions, bins=ranges, weights=weights) mvd *= 1.e6 / (fieldld.scale**3) print 'result shape:', mvd.shape print('average mvd') print(np.mean(mvd[1:-1, 1:-1, 1:-1])) ''' new stuff ''' from scipy import ndimage bool_field = mvd > 0 bool_field = np.logical_not(bool_field) distance_map = ndimage.morphology.distance_transform_edt(bool_field) distance_map = distance_map * sampling_lattice_spacing # fig, ax = pyplot.subplots(1) # plt = ax.imshow(mvd[:,:,z], interpolation = 'none') # ax.set(title = 'MVD') # divider = mpl_utils.make_axes_locatable(ax) # cax = divider.append_axes("right", size = "5%", pad = 0.05) # fig.colorbar(plt, cax = cax) fig, ax = pyplot.subplots(1) plt = ax.imshow(distance_map[:, :, z], interpolation='none') #ax.set(title = 'Distance Map \n group: %s, file: %s' %(grouppath, filename)) ax.set(title='Distance Map \n smp_logitudinal: %s, lattice_const: %s' % (longitudinal_sampling_distance, sampling_lattice_spacing)) divider = mpl_utils.make_axes_locatable(ax) cax = divider.append_axes("right", size="5%", pad=0.05) fig.colorbar(plt, cax=cax) basename(filename) with PdfPages('distmap_' + basename(filename) + '_' + grouppath + '.pdf') as pdf: pdf.savefig(fig)