def renderScene(drug_grp, imagefn, options): imagefn, ext = splitext(imagefn) ext = '.' + options.format options.imageFileName = imagefn+'_iff_drug'+ext 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'] gvessels = drug_grp.parent['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_by_filename(drug_grp.parent['field_ld']) iff_ld = krebsutils.read_lattice_data_from_hdf_by_filename(str(drug_grp.file.filename),str(drug_grp.parent.name)+'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_ld = krebsutils.read_lattice_data_from_hdf_by_filename(str(gvessels.file.filename),str(gvessels.name)+'/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 surface2Volume(vesselgroup): vessels = krebsutils.read_vesselgraph(vesselgroup, ['flags', 'radius', 'length']) flags = RemoveArteriovenousFlagsFromCapillaries(vessels['flags']) flags = flags[:,0] 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) radius = np.asarray(vessels['radius'][mask], dtype = np.float64) radius = radius[:,0] vol = math.pi * np.power(radius, 2.) * length surface = 2* math.pi* radius* length #surface = np.sum(surface) #vol = np.sum(vol) s2v = surface/vol mystd = np.std(s2v) myavg = np.average(s2v) myrel = mystd/myavg print("spread: %f" % myrel) return np.average(surface/vol) return compute(0), compute(krebsutils.ARTERY), compute(krebsutils.VEIN), compute(krebsutils.CAPILLARY)
def write(gmeasure, groupname): weight = dataman.obtain_data('basic_vessel_samples', 'weight', vesselgroup, self.sample_length) flags = dataman.obtain_data('basic_vessel_samples', 'flags', vesselgroup, self.sample_length) position = dataman.obtain_data('basic_vessel_samples', 'position', vesselgroup, self.sample_length) mask = myutils.bbitwise_and(flags, krebsutils.CIRCULATED) flags = flags[mask] position = position[mask, ...] weight = weight[mask] ####### put into bins eps = 1.0 - 1.e-15 x0, x1, y0, y1, z0, z1 = fieldLd.worldBox ranges = [ np.arange(x0, x1, fieldLd.scale * eps), np.arange(y0, y1, fieldLd.scale * eps), np.arange(z0, z1, fieldLd.scale * eps), ] mvd, _ = np.histogramdd(position, bins=ranges, weights=weight) mvd *= 1.e6 / (fieldLd.scale**3) ####### save gmeasure.create_dataset(groupname, data=mvd, compression=9, dtype=np.float32)
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 / totalvol
def render_different_data_types(vesselgroup, options): filenamepostfix = '' labels = { 'flow': '$log_{10}$ Flow Rate', 'shearforce': '$log_{10}$ Shear Force', 'hematocrit': 'Hematocrit', 'pressure': 'Blood Pressure $kPa$', 'S_tot': 'Adaption Signal', 'conductivitySignal': 'Conductivity Signal', 'metabolicSignal': 'Metabolic Signal', 'radius': 'Vesselradius $\mu$m', } graph = krebsutils.read_vessels_from_hdf( vesselgroup, ['position', 'flags', 'radius', 'nodeflags'] + options.datalist, return_graph=True) #nodeflags not good for apj.h5 #numpy int64 bug! #graph = krebsutils.read_vessels_from_hdf(vesselgroup, ['position', 'flags', 'radius' ] + options.datalist, return_graph=True) #if vesselgroup.attrs.get('CLASS') == 'GRAPH': # vessel_ld = krebsutils.read_lattice_data_from_hdf(vesselgroup['lattice']) # options.wbbox = vessel_ld.GetWorldBox() #if vesselgroup.attrs.get('CLASS') == 'REALWORLD': # options.wbbox = np.max(np.asarray(vesselgroup['nodes/world_pos']),0) options.wbbox = ComputeBoundingBox(vesselgroup, graph) if options.filteruncirculated: graph = graph.get_filtered(edge_indices=myutils.bbitwise_and( graph['flags'], krebsutils.CIRCULATED)) if options.filterradiushighpass > 0: graph = graph.get_filtered( edge_indices=graph['radius'] > filterradiushighpass) filenamepostfix = '_rhp' if options.filterradiuslowpass > 0: print("lowpass filter activated:") graph = graph.get_filtered( edge_indices=graph['radius'] < filterradiuslowpass) filenamepostfix = '_rlp' for data_name in options.datalist: if 'colorfactory' in options: colors_factory = options.colorfactory colors_factory(graph) cm, (datamin, datamax) = make_any_color_arrays(graph, data_name, options) fn = vesselgroup.file.filename options.imageFileName = splitext( basename(fn) )[0] + '_' + myutils.sanitize_posixpath(vesselgroup.name).replace( '/', '-') + '_' + data_name + filenamepostfix + '.' + options.format print(options.imageFileName) with EasyPovRayRender(options) as epv: CreateScene2(vesselgroup, epv, graph, options) if options.noOverlay: epv.render(imagefn) else: RenderImageWithOverlay(epv, cm, labels[data_name], options)
def process(vesselgroups): bins = np.logspace(-1., 1.1, 50, base=10.) result = [] for g in vesselgroups: r = dataman.obtain_data('basic_vessel_samples', 'radius', g, 30.) w = dataman.obtain_data('basic_vessel_samples', 'weight', g, 30.) f = dataman.obtain_data('basic_vessel_samples', 'flags', g, 30.) i = myutils.bbitwise_and(f, krebsutils.CIRCULATED) if filterflags is not None: i &= myutils.bbitwise_and(f, filterflags) h = myutils.MeanValueArray.fromHistogram1d(bins, r[i], w[i]) result.append(h) result = myutils.MeanValueArray.fromSummation(result) #ax.bar(bins[:-1], result.sum, width=(bins[1]-bins[0])) y = result.sum y /= np.sum(y) y /= (bins[1:] - bins[:-1]) return bins[:-1], y
def compute(flagMask): if flagMask: mask = mask1 & myutils.bbitwise_and(flags, flagMask) else: mask = mask1 length = np.asarray(vessels['length'][mask], dtype=np.float64) radius = np.asarray(vessels['radius'][mask], dtype=np.float64) vol = math.pi * np.power(radius, 2.) * length vol = np.sum(vol) return vol / totalvol
def PlotRadiusHistogram(ax, dataman, vesselgroups, filterflags=None): #bins = np.linspace(0., 200., 20) #bins = np.asarray([ 0., 4, 8, 16, 32, 64, 128, 256]) bins = np.logspace(-1., 2., 50, base=10.) result = [] for g in vesselgroups: r = dataman.obtain_data('basic_vessel_samples', 'radius', g, 30.) w = dataman.obtain_data('basic_vessel_samples', 'weight', g, 30.) f = dataman.obtain_data('basic_vessel_samples', 'flags', g, 30.) i = myutils.bbitwise_and(f, krebsutils.CIRCULATED) if filterflags is not None: i &= myutils.bbitwise_and(f, filterflags) h = myutils.MeanValueArray.fromHistogram1d(bins, r[i], w[i]) result.append(h) result = myutils.MeanValueArray.fromSummation(result) #ax.bar(bins[:-1], result.sum, width=(bins[1]-bins[0])) y = result.sum y /= np.sum(y) y /= (bins[1:] - bins[:-1]) ax.step(bins[:-1], y, where='post')
def cylinderCollectionLineDensity(vesselgroup): vessels = krebsutils.read_vesselgraph(vesselgroup, ['flags', 'length']) flags = RemoveArteriovenousFlagsFromCapillaries(vessels['flags']) flags = flags[:,0] 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/totalvol return compute(0), compute(krebsutils.ARTERY), compute(krebsutils.VEIN), compute(krebsutils.CAPILLARY)
def compute(flagMask): if flagMask: mask = mask1 & myutils.bbitwise_and(flags, flagMask) else: mask = mask1 length = np.asarray(vessels['length'][mask], dtype = np.float64) radius = np.asarray(vessels['radius'][mask], dtype = np.float64) radius = radius[:,0] vol = math.pi * np.power(radius, 2.) * length surface = 2* math.pi* radius* length #surface = np.sum(surface) #vol = np.sum(vol) s2v = surface/vol mystd = np.std(s2v) myavg = np.average(s2v) myrel = mystd/myavg print("spread: %f" % myrel) return np.average(surface/vol)
def renderScene(po2group, imagefn, options): dataman = myutils.DataManager(2, [DataDetailedPO2(), DataBasicVessel()]) gvessels, gtumor = OpenVesselAndTumorGroups(po2group) po2vessels, po2field_ld, po2field, parameters = dataman( 'detailedPO2', po2group) po2vessels = np.average(po2vessels, axis=0) print 'po2vessels:', po2vessels.min(), po2vessels.max() print 'po2field:', np.amin(po2field), np.amax(po2field) #vessel_ld = krebsutils.read_lattice_data_from_hdf(gvessels['lattice']) vessel_graph = dataman('vessel_graph', gvessels, ['position', 'flags', 'radius', 'hematocrit']) vessel_graph.edges['po2_vessels'] = po2vessels print(parameters) 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: print("lowpass filter activated:") vessel_graph = vessel_graph.get_filtered( edge_indices=vessel_graph['radius'] < options.filterradiuslowpass) imagefn, ext = splitext(imagefn) ext = '.' + options.format #renderSliceWithDistribution((vessel_ld, vessel_graph, 'po2vessels'), (po2field_ld, po2field), imagefn+'_po2vessels'+ext, '', options) #renderSlice((vessel_ld, vessel_graph, 'saturation'), (None, None), imagefn+'_saturation'+ext, '', options) #renderSlice((vessel_ld, vessel_graph, 'hboconc'), (None, None), imagefn+'_hboconc'+ext, 'HbO [mmol/l blood]', options) #try world options.imageFileName = imagefn + '_po2vessels' + ext renderSliceWithDistribution((po2field_ld, vessel_graph, 'po2_vessels'), (po2field_ld, po2field), '', options) options.imageFileName = imagefn + '_saturation' + ext renderSlice((po2field_ld, vessel_graph, 'saturation'), (None, None), '', options) options.imageFileName = imagefn + '_hboconc' + ext renderSlice((po2field_ld, vessel_graph, 'hboconc'), (None, None), 'HbO [mmol/l blood]', options)
def GenerateRadialDistributions(dataman, vesselgroup, tumorgroup, sample_length, bins_spec, distance_distribution_name, ld, sample_iterator): weight_smpl = dataman.obtain_data('basic_vessel_samples', 'weight', vesselgroup, sample_length) flags = dataman.obtain_data('basic_vessel_samples', 'flags', vesselgroup, sample_length) # get the radial distance function (either distance from tumor border or distance from center) if distance_distribution_name =='levelset': dist_smpl, distmap, mask, tumor_ld = dataman.obtain_data('distancemap_samples', vesselgroup, tumorgroup, sample_length, distance_distribution_name, ld) #filter uncirculated mask = mask & myutils.bbitwise_and(flags, krebsutils.CIRCULATED) dist_smpl = dist_smpl[mask] weight_smpl = weight_smpl[mask] #""" not yet ready!!!! # if distance_distribution_name =='radial': # #ld = krebsutils.read_lattice_data_from_hdf(iff_file['field_ld']) # distmap = dataman.obtain_data('distance_from_center_distribution', ld) # distmap = distmap.ravel() # dist_smpl = distmap # mask = distmap < tumor_center_distance # ifp_field = ifp_field[mask] # ifp_histo = myutils.MeanValueArray.fromHistogram1d(ifp_bins, ifp_field, np.ones_like(ifp_field)) # dist_smpl = dataman.obtain_data('distance_from_center_distribution', ld) # dist_smpl = dist_smpl.ravel() # mask = dist_smpl>0 #everything # dist_smpl = dist_smpl[mask] # weight_smpl = weight_smpl[mask] #dist_smpl, distmap, mask, tumor_ld = dataman.obtain_data('distance_from_center_distribution', vesselgroup, tumorgroup, sample_length, distance_distribution_name, ld) # note: tumor_ld might be another unrelated lattice #""" res=[] for (smpl, avg_mode) in sample_iterator: bins = bins_spec.arange() if avg_mode is radialAvgPerVolume: a = myutils.MeanValueArray.fromHistogram1d(bins, dist_smpl, smpl[mask], weight_smpl) # integral over length within bins b = myutils.MeanValueArray.fromHistogram1d(bins, distmap.ravel(), np.ones_like(distmap.ravel())) # how much tissue volume in the bins a.cnt = b.cnt.copy() a.sum *= 1./(tumor_ld.scale**3) a.sqr *= a.sum**2 # length integral per tissue volume #a *= 1.e6 elif avg_mode is radialAvgPerVessels: a = myutils.MeanValueArray.fromHistogram1d(bins, dist_smpl, smpl[mask], weight_smpl) else: assert (avg_mode is radialAvgPerVolume or avg_mode is radialAvgPerVessels) res.append(a) return res
def CalcPhiVessels(dataman, vesselgroup, ld, scaling, samples_per_cell = 5): '''samples per cell mean the lattice grid cell, the total number of samples for a vessel is determined by the ratio of its volume to the volume of a grid cell times the samples_per_cell''' graph = krebsutils.read_vessels_from_hdf(vesselgroup, ['position', 'radius', 'flags'] , return_graph=True) mask=myutils.bbitwise_and(graph['flags'], krebsutils.CIRCULATED) print(mask.shape) graph = graph.get_filtered(edge_indices = mask) print('vessels filtered before fraction calculation!') theRadii = np.asarray(graph['radius'])*scaling if(theRadii.ndim>1): theRadii = theRadii[:,0] if theRadii.dtype == np.float32: thePositions = np.asarray(graph['position'],dtype=np.float32)*scaling else: thePositions = np.asarray(graph['position'])*scaling theEdgeList = np.asarray(graph.edgelist) if sys.flags.debug: print(thePositions) print(thePositions.shape) print(type(thePositions)) print("thepos: %s" % thePositions.dtype) print(theEdgeList) print(theEdgeList.shape) print(type(theEdgeList)) print("theEd: %s" % theEdgeList.dtype) print(theRadii) print(theRadii.shape) print(type(theRadii)) print('theRadii: %s' % theRadii.dtype) print(ld) print(type(ld)) print(ld.GetScale()) print(type(samples_per_cell)) vessel_fraction = krebsutils.make_vessel_volume_fraction_field(thePositions,theEdgeList,theRadii,ld,samples_per_cell) return vessel_fraction
def write(gmeasure, groupname): graph = dataman.obtain_data( 'vessel_graph', vesselgroup, ['position', 'radius', 'flags', 'pressure']) graph = graph.get_filtered( myutils.bbitwise_and(graph['flags'], krebsutils.CIRCULATED)) edgevalues = graph['pressure'] edgevalues = edgevalues[graph.edgelist] # main calculation thefield = krebsutils.CalcIntervascularInterpolationField( graph.edgelist, graph['radius'], graph['position'], edgevalues, fieldLdFine, 1.) del edgevalues # gradient of the interpolated blood pressure thegrad = scipy.ndimage.gaussian_filter(thefield, 1.0, 0, mode='nearest') gradfield_ = krebsutils.field_gradient(thegrad) thegrad = np.sum([np.square(g) for g in gradfield_], axis=0) thegrad = np.sqrt(thegrad) del gradfield_, thefield # now we scale down the highres version, TODO: make it work with other than 3 dimensions # first local average m = self.fine_bin_subdivision kernel = np.ones((m, m, m), dtype=np.float32) thegrad = scipy.signal.fftconvolve(thegrad, kernel, mode='valid') # then pick every m'th which contains the average of m finer boxes combined thegrad = np.ascontiguousarray(thegrad[::m, ::m, ::m]) assert all(thegrad.shape == fieldLd.shape) gmeasure.create_dataset(groupname, data=thegrad, compression=9, dtype=np.float32)
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, fieldld, 1.) volfraction = krebsutils.make_vessel_volume_fraction_field( graph['position'], graph.edgelist, graph['radius'], fieldld, 5) thegrad = ndimage.gaussian_filter(thefield, 1.0, 0, mode='nearest') gradfield_ = krebsutils.field_gradient(thegrad) thegrad = np.sum([np.square(g) for g in gradfield_], axis=0)
def make_any_color_arrays(vesselgraph, data_name): edges = vesselgraph.edgelist num_nodes = len(vesselgraph.nodes['position']) flags = vesselgraph.edges['flags'] nflags = krebsutils.edge_to_node_property(num_nodes, edges, flags, 'or') mask = myutils.bbitwise_and(flags, krebsutils.CIRCULATED) nmask = myutils.bbitwise_and(nflags, krebsutils.CIRCULATED) if data_name in vesselgraph.edges: edgedata = vesselgraph.edges[data_name] nodedata = krebsutils.edge_to_node_property(num_nodes, edges, edgedata, 'avg') else: nodedata = vesselgraph.nodes[data_name] edgedata = np.average((nodedata[edges[:, 0]], nodedata[edges[:, 1]]), axis=0) gray = np.asarray((0.1, 0.1, 0.1)) edgecolors = np.repeat(gray.reshape(1, -1), len(edgedata), axis=0) nodecolors = np.repeat(gray.reshape(1, -1), len(nodedata), axis=0) #colors = lambda arr: cm.to_rgba(arr)[:,:3] colors = lambda arr: np.power(cm.to_rgba(arr)[:, :3], 2.4) if data_name == 'hematocrit': cm = matplotlib.cm.ScalarMappable(cmap=cm_hematocrit) cm.set_clim(0, 1) unmapped_range = (0., 1.) edgecolors[mask] = colors(edgedata[mask]) nodecolors[nmask] = colors(nodedata[nmask]) elif data_name == 'pressure': p0 = np.amin(nodedata) p1 = np.amax(nodedata) unmapped_range = (p0, p1) cm = matplotlib.cm.ScalarMappable(cmap=cm_redblue) cm.set_clim(p0, p1) edgecolors[mask] = colors(edgedata[mask]) nodecolors[nmask] = colors(nodedata[nmask]) elif data_name == 'shearforce': mask = mask & (edgedata > 0) nmask = nmask & (nodedata > 0) edgedata = edgedata[mask] nodedata = nodedata[nmask] unmapped_range = edgedata.min(), edgedata.max() edgedata = np.log10(edgedata) nodedata = np.log10(nodedata) p0 = -4 #np.amin(edgedata) p1 = -1 #np.amax(edgedata) cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.spectral) cm.set_clim(p0, p1) edgecolors[mask] = colors(edgedata) nodecolors[nmask] = colors(nodedata) elif data_name == 'flow': mask = mask & (edgedata > 0) nmask = nmask & (nodedata > 0) edgedata = edgedata[mask] nodedata = nodedata[nmask] unmapped_range = edgedata.min(), edgedata.max() edgedata = np.log10(edgedata) nodedata = np.log10(nodedata) p0 = np.floor(np.amin(edgedata)) p1 = np.ceil(np.amax(edgedata)) cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.jet) cm.set_clim(p0, p1) edgecolors[mask] = colors(edgedata) nodecolors[nmask] = colors(nodedata) elif data_name == 'flags': unmapped_range = (0., 1.) mask = mask & (edgedata > 0) nmask = nmask & (nodedata > 0) edgedata = edgedata[mask] nodedata = nodedata[nmask] edgedata = np.bitwise_and(edgedata, krebsutils.ARTERY) cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.jet) edgecolors[mask] = colors(edgedata) nodecolors[nmask] = colors(nodedata) vesselgraph.edges['colors'] = edgecolors vesselgraph.nodes['colors'] = nodecolors return cm, unmapped_range
def InsertGraphColors(vesselgraph, po2field, data_name): edges = vesselgraph.edgelist if type(vesselgraph.nodes['position']) is tuple: num_nodes = len(vesselgraph.nodes['position'][0]) else: num_nodes = len(vesselgraph.nodes['position']) if data_name in vesselgraph.edges: edgedata = data = vesselgraph.edges[data_name] nodedata = krebsutils.edge_to_node_property(num_nodes, edges, data, 'avg') else: nodedata = data = vesselgraph.nodes[data_name] edgedata = np.average((data[edges[:, 0]], data[edges[:, 1]]), axis=0) if data_name == 'po2_vessels': try: p1 = np.amax(data) except ValueError: print("p1 not found") pass if po2field is not None: p1 = max(p1, np.amax(po2field)) try: p0 = np.amin(data) except ValueError: print("p0 not found") pass if po2field is not None: p0 = min(p0, np.amin(po2field)) #p1 = math.ceil(p1/10.0)*10.0 # round to powers of something #p1 = 100.0 value_range = (p0, p1) cm = matplotlib.cm.ScalarMappable(cmap=cm_po2) elif data_name == 'saturation': cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.Spectral) vesselgraph.edges['saturation'] value_range = (np.min(vesselgraph.edges['saturation']), np.max(vesselgraph.edges['saturation'])) #value_range = (0,1.) elif data_name == 'hboconc': cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.gnuplot) p1 = math.ceil(np.amax(data)) value_range = (0., p1) cm.set_clim(*value_range) colors = lambda arr: np.power(cm.to_rgba(arr)[:, :3], 2.4) if data_name in vesselgraph.edges: edgecolors = colors(data) nodecolors = colors(nodedata) else: edgecolors = colors(edgedata) nodecolors = colors(data) flags = vesselgraph.edges['flags'] nflags = krebsutils.edge_to_node_property(num_nodes, edges, flags, 'or') #is_not_set = lambda flags_,flag: np.bitwise_not(np.asarray(np.bitwise_and(flags_, flag), np.bool)) gray = np.asarray((0.3, 0.3, 0.3)) circulated = myutils.bbitwise_and(flags, krebsutils.CIRCULATED) uncirculated = np.logical_not(circulated) node_circulated = myutils.bbitwise_and(nflags, krebsutils.CIRCULATED) node_uncirculated = np.logical_not(node_circulated) #nuncirculated = is_not_set(nflags,krebsutils.CIRCULATED) edgecolors[uncirculated] = gray nodecolors[node_uncirculated] = gray print 'colormap range ', cm.get_clim() vesselgraph.edges['colors'] = edgecolors vesselgraph.nodes['colors'] = nodecolors return cm
def RemoveArteriovenousFlagsFromCapillaries(flags): capil_mask = myutils.bbitwise_and(flags, krebsutils.CAPILLARY) flags[capil_mask] = np.bitwise_and(flags[capil_mask], np.asarray(~(krebsutils.ARTERY | krebsutils.VEIN), dtype=flags.dtype)) return flags
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, 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
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 render_different_data_types(vesselgroup, tumorgroup, imagefn, options, cell_group=None): filenamepostfix = '' labels = { 'flow': '$log_{10}$ Flow Rate', 'shearforce': '$log_{10}$ Shear Force', 'hematocrit': 'Hematocrit', 'pressure': 'Blood Pressure $kPa$', 'S_tot': 'Adaption Signal', 'conductivitySignal': 'Conductivity Signal', 'metabolicSignal': 'Metabolic Signal', 'radius': 'Vesselradius $\mu$m', } graph = krebsutils.read_vessels_from_hdf( vesselgroup, ['position', 'flags', 'radius', 'nodeflags'] + options.datalist, return_graph=True) options.wbbox = povrayRenderVessels.ComputeBoundingBox(vesselgroup, graph) if options.filteruncirculated: graph = graph.get_filtered(edge_indices=myutils.bbitwise_and( graph['flags'], krebsutils.CIRCULATED)) if options.filterradiushighpass > 0: graph = graph.get_filtered( edge_indices=graph['radius'] > filterradiushighpass) filenamepostfix = '_rhp' if options.filterradiuslowpass > 0: print("lowpass filter activated:") graph = graph.get_filtered( edge_indices=graph['radius'] < filterradiuslowpass) filenamepostfix = '_rlp' for data_name in options.datalist: if 'colorfactory' in options: print('colorfactory in options') colors_factory = options.colorfactory colors_factory(graph) cm, (datamin, datamax) = povrayRenderVessels.make_any_color_arrays( graph, data_name, options) fn = vesselgroup.file.filename if cell_group is not None and options.cells: options.imageFileName = splitext( basename(fn) )[0] + '_' + myutils.sanitize_posixpath(vesselgroup.name).replace( '/', '-' ) + '_' + data_name + '_cell_' + options.cellsProperty + '_' + filenamepostfix #+'.'+ options.format else: options.imageFileName = splitext( basename(fn) )[0] + '_' + myutils.sanitize_posixpath(vesselgroup.name).replace( '/', '-') + '_' + data_name + filenamepostfix #+'.'+ options.format with povrayEasy.EasyPovRayRender(options) as epv: povrayEasy.CreateScene2(vesselgroup, epv, graph, options) if options.noOverlay: epv.render(options.imageFileName) else: if cell_group and options.cells: cells_cm = povrayRenderCells.addVBLCells( epv, options.cellsProperty, cell_group, options) povrayEasy.RenderImageWithOverlay(epv, cm, labels[data_name], options, colormap_cells=cells_cm) else: povrayEasy.RenderImageWithOverlay(epv, cm, labels[data_name], options)
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)
'position', 'radius', 'hematocrit', 'pressure', 'flow', 'flags', 'shearforce', 'nodeflags', 'edge_boundary' ] + datalist, return_graph=True) else: graph = krebsutils.read_vessels_from_hdf( vesselgroup, [ 'position', 'radius', 'hematocrit', 'pressure', 'flow', 'flags', 'shearforce' ] + datalist, return_graph=True) if goodArguments.filteruncirculated: graph = graph.get_filtered( edge_indices=myutils.bbitwise_and( graph['flags'], krebsutils.CIRCULATED)) writeVessels_(graph, goodArguments) elif 'out' in d: vesselgroup = f[join('/', d + '/vessels')]['.'] if '/parameters' in f: useConstO2 = f['/parameters'].attrs['useConstO2'] # comes as string useConstO2 = bool(useConstO2) else: useConstO2 = False if useConstO2: ''' the po2_node will not be present in this case ''' graph = krebsutils.read_vessels_from_hdf( vesselgroup,
dirs = myutils.walkh5(f['/'], pattern) if goodArguments.outfn: print("you chose: %s as outfilename" % goodArguments.outfn) goodArguments.outfn = goodArguments.outfn + '_%s.vtk' else: goodArguments.outfn = outfn = "%s-%%s.vtk" % (os.path.splitext(os.path.basename(fn))[0]) for d in dirs: if 'vessels' in d and 'po2' not in d: vesselgroup = f[join('/',d)]['.'] new = False if new: graph = krebsutils.read_vessels_from_hdf(vesselgroup, ['position', 'radius', 'hematocrit', 'pressure', 'flow', 'flags','shearforce','nodeflags','edge_boundary'] + datalist, return_graph=True) else: graph = krebsutils.read_vessels_from_hdf(vesselgroup, ['position', 'radius', 'hematocrit', 'pressure', 'flow', 'flags','shearforce'] + datalist, return_graph=True) if goodArguments.filteruncirculated: graph = graph.get_filtered(edge_indices = myutils.bbitwise_and(graph['flags'], krebsutils.CIRCULATED)) writeVessels_(graph, goodArguments) elif 'out' in d: vesselgroup = f[join('/',d+'/vessels')]['.'] new = False if new: graph = krebsutils.read_vessels_from_hdf(vesselgroup, ['position', 'radius', 'hematocrit', 'pressure', 'flow', 'flags','shearforce','nodeflags','edge_boundary'] + datalist, return_graph=True) else: graph = krebsutils.read_vessels_from_hdf(vesselgroup, ['position', 'radius', 'hematocrit', 'pressure', 'flow', 'flags','shearforce'] + datalist, return_graph=True) if goodArguments.filteruncirculated: graph = graph.get_filtered(edge_indices = myutils.bbitwise_and(graph['flags'], krebsutils.CIRCULATED)) hdftumor2vtk(graph, goodArguments) elif 'po2' in d: #vesselgroup = f[join('/',d+'/vessels')]['.'] if 'adaption' in d:
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)
def make_any_color_arrays(vesselgraph, data_name): edges = vesselgraph.edgelist num_nodes = len(vesselgraph.nodes['position']) flags = vesselgraph.edges['flags'] flags = np.asarray(flags, dtype='uint32') nflags = krebsutils.edge_to_node_property(num_nodes, edges, flags, 'or') mask = myutils.bbitwise_and(flags, krebsutils.CIRCULATED) nmask = myutils.bbitwise_and(nflags, krebsutils.CIRCULATED) if data_name in vesselgraph.edges: edgedata = vesselgraph.edges[data_name] nodedata = krebsutils.edge_to_node_property(num_nodes, edges, edgedata, 'avg') else: nodedata = vesselgraph.nodes[data_name] edgedata = np.average((nodedata[edges[:, 0]], nodedata[edges[:, 1]]), axis=0) gray = np.asarray((0.1, 0.1, 0.1)) edgecolors = np.repeat(gray.reshape(1, -1), len(edgedata), axis=0) nodecolors = np.repeat(gray.reshape(1, -1), len(nodedata), axis=0) #colors = lambda arr: cm.to_rgba(arr)[:,:3] colors = lambda arr: np.power(cm.to_rgba(arr)[:, :3], 2.4) if data_name == 'hematocrit': cm = matplotlib.cm.ScalarMappable(cmap=cm_hematocrit) cm.set_clim(0, 1) unmapped_range = (0., 1.) edgecolors[mask] = colors(edgedata[mask]) nodecolors[nmask] = colors(nodedata[nmask]) elif data_name == 'pressure': #this looks really ugly if there is a zero pressure node #p0 = np.amin(nodedata) p0 = np.min(nodedata[np.nonzero(nodedata)]) p1 = np.amax(nodedata) unmapped_range = (p0, p1) cm = matplotlib.cm.ScalarMappable(cmap=cm_redblue) cm.set_clim(p0, p1) edgecolors[mask] = colors(edgedata[mask]) nodecolors[nmask] = colors(nodedata[nmask]) elif data_name == 'shearforce': mask = mask & (edgedata > 0) nmask = nmask & (nodedata > 0) edgedata = edgedata[mask] nodedata = nodedata[nmask] unmapped_range = edgedata.min(), edgedata.max() edgedata = np.log10(edgedata) nodedata = np.log10(nodedata) p0 = -4 #np.amin(edgedata) p1 = -1 #np.amax(edgedata) cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.spectral) cm.set_clim(p0, p1) edgecolors[mask] = colors(edgedata) nodecolors[nmask] = colors(nodedata) elif data_name == 'S_tot': #mask = mask & (edgedata>0) #nmask = nmask & (nodedata>0) edgedata = edgedata[mask] nodedata = nodedata[nmask] unmapped_range = edgedata.min(), edgedata.max() p0 = np.amin(edgedata) p1 = np.amax(edgedata) #print("p0: %f, p1: %f" % (p0,p1)) #unmapped_range = (p0, p1) cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.jet) cm.set_clim(p0, p1) #edgedata = np.log10(edgedata) #nodedata = np.log10(nodedata) #p0 = -4#np.amin(edgedata) #p1 = -1#np.amax(edgedata) #cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.spectral) #cm.set_clim(p0, p1) edgecolors[mask] = colors(edgedata) nodecolors[nmask] = colors(nodedata) elif data_name == 'flow': mask = mask & (edgedata > 0) nmask = nmask & (nodedata > 0) edgedata = edgedata[mask] nodedata = nodedata[nmask] unmapped_range = edgedata.min(), edgedata.max() edgedata = np.log10(edgedata) nodedata = np.log10(nodedata) p0 = np.floor(np.amin(edgedata)) p1 = np.ceil(np.amax(edgedata)) cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.jet) cm.set_clim(p0, p1) edgecolors[mask] = colors(edgedata) nodecolors[nmask] = colors(nodedata) elif data_name == 'conductivitySignal': edgedata = edgedata[mask] nodedata = nodedata[nmask] unmapped_range = edgedata.min(), edgedata.max() p0 = np.amin(edgedata) p1 = np.amax(edgedata) cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.jet) cm.set_clim(p0, p1) edgecolors[mask] = colors(edgedata) nodecolors[nmask] = colors(nodedata) elif data_name == 'metabolicSignal': edgedata = edgedata[mask] nodedata = nodedata[nmask] unmapped_range = edgedata.min(), edgedata.max() p0 = np.amin(edgedata) p1 = np.amax(edgedata) cm = matplotlib.cm.ScalarMappable(cmap=matplotlib.cm.jet) cm.set_clim(p0, p1) edgecolors[mask] = colors(edgedata) nodecolors[nmask] = colors(nodedata) elif data_name == 'flags': edgecolors[mask & (flags & krebsutils.ARTERY).astype(np.bool)] = np.asarray( (1., 0., 0.)) nodecolors[nmask & (nflags & krebsutils.ARTERY).astype(np.bool)] = np.asarray( (1., 0., 0.)) edgecolors[mask & (flags & krebsutils.VEIN).astype(np.bool)] = np.asarray( (0., 0., 1.)) nodecolors[nmask & (nflags & krebsutils.VEIN).astype(np.bool)] = np.asarray( (0., 0., 1.)) edgecolors[mask & (flags & krebsutils.CAPILLARY).astype(np.bool)] = np.asarray( (0., 1., 0.)) nodecolors[nmask & (nflags & krebsutils.CAPILLARY).astype(np.bool)] = np.asarray( (0., 1., 0.)) for idx in vesselgraph.roots: nodecolors[idx] = np.asarray((1., 1., 0.)) cm, unmapped_range = None, (None, None) vesselgraph.edges['colors'] = edgecolors vesselgraph.nodes['colors'] = nodecolors return cm, unmapped_range
if 0: fig = pyplot.figure() ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) plt = ax.scatter(position[:, 0], position[:, 1], c=weight_smpl, s=5, edgecolor=None, cmap=matplotlib.cm.jet, marker='o') ax.set_axis_bgcolor('k') fig.colorbar(plt) pyplot.show() mask = mask & myutils.bbitwise_and(flags, krebsutils.CIRCULATED) dist_smpl = dist_smpl[mask] weight_smpl = weight_smpl[mask] bins = BinsSpecRange(-10000., 10000., 100.).arange() a = myutils.MeanValueArray.fromHistogram1d( bins, dist_smpl, weight_smpl, weight_smpl) #np.ones_like(dist_smpl) b = myutils.MeanValueArray.fromHistogram1d(bins, distmap.ravel(), np.ones_like(distmap.ravel())) a.cnt = b.cnt.copy() a.sum *= 1. / (tumor_ld.scale**3) a.sqr *= a.sum**2 c = a.sum / (bins[1:]**2 - bins[:-1]**2) fig, axes = pyplot.subplots(2, 1)