def test_scalebar_loc(scalebar):
assert scalebar.get_loc() is None
assert scalebar.loc is None
scalebar.set_location("upper right")
assert scalebar.get_loc() == 1
assert scalebar.loc == 1
scalebar.location = "lower left"
assert scalebar.get_loc() == 3
assert scalebar.loc == 3
scalebar.set_loc("lower right")
assert scalebar.get_loc() == 4
assert scalebar.loc == 4
scalebar.location = "upper left"
assert scalebar.get_loc() == 2
assert scalebar.loc == 2
with pytest.raises(ValueError):
ScaleBar(1.0, loc="upper right", location="upper left")
with pytest.raises(ValueError):
ScaleBar(1.0, loc="upper right", location=2)
def get_scalebar(px, unit, sb_settings):
if '1/' in unit:
# px = px*10**(-9)
scalebar = ScaleBar(px, unit, SI_LENGTH_RECIPROCAL,
**sb_settings)
else:
scalebar = ScaleBar(px, unit, **sb_settings)
return scalebar
def addscale(img,
imgdata,
outfile,
scale_value='auto'): # Add Scalebar on TEM Image
# extract scale bar and scale unit
scale_x = imgdata['scale'][0]
scale_y = imgdata['scale'][1]
scale_ratio = scale_y / scale_x
scale_unit = imgdata['scale_unit']
dimension = imgdata['dimension (px,px)']
# image prepration for new image
imga = np.array(img)
color = sb_color(imga) # color of scale bar
dpi = 1000
fig = plt.figure(figsize=(dimension[0] / dpi, dimension[1] / dpi),
frameon=False)
ax = fig.add_axes([0, 0, 1, 1])
ax.axis('off')
location = 'lower left'
frameon = False
# find optimum scale bar value
scvs = np.array([1, 2, 5, 10, 20, 50, 100, 200,
500]) # scale bar candidates
scvs_px = scvs / imgdata['scale'][0]
rel_len = imgdata['image size (px,px)'][
1] * 0.2 # scale bar should close to 20% of image width
scale_value = scvs[np.argmin(abs(scvs_px - rel_len))]
print('scale_value= {}'.format(scale_value))
if scale_unit[0] == '1': # reciporcal space, such as 1/nm
scalebar = ScaleBar(scale_x,
scale_unit,
SI_LENGTH_RECIPROCAL,
location=location,
frameon=frameon,
color=color,
fixed_value=scale_value)
else: # real space
scalebar = ScaleBar(scale_x,
scale_unit,
location=location,
frameon=frameon,
color=color,
fixed_value=scale_value)
plt.imshow(imga)
plt.gca().add_artist(scalebar)
plt.savefig(outfile, dpi=dpi)
return outfile
def plotRxDConcentration(speciesLabel,
regionLabel,
plane='xy',
figSize=(5, 10),
fontSize=10,
scalebar=False,
title=True,
showFig=True,
saveFig=True):
from .. import sim
# set font size
plt.rcParams.update({'font.size': fontSize})
species = sim.net.rxd['species'][speciesLabel]['hObj']
region = sim.net.rxd['regions'][regionLabel]['hObj']
plane2mean = {'xz': 1, 'xy': 2}
fig = plt.figure(figsize=figSize)
plt.imshow(species[region].states3d[:].mean(plane2mean[plane]).T,
interpolation='nearest',
origin='upper') # extent=k[extracellular].extent('xy')
ax = plt.gca()
if scalebar:
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
sb = ScaleBar(1e-6)
sb.location = 'lower left'
ax.add_artist(sb)
plt.colorbar(label='[' + species.name + '] (mM)')
plt.xlabel(plane[0] + ' location (um)')
plt.ylabel(plane[1] + ' location (um)')
if title:
plt.title('RxD: ' + species.name + ' concentration')
plt.tight_layout()
# show fig
if showFig: _showFigure()
# save figure
if saveFig:
if isinstance(saveFig, basestring):
filename = saveFig
else:
filename = sim.cfg.filename + '_rxd_concentration.png'
plt.savefig(filename)
return fig, {'data': species[region].states3d[:].mean(plane2mean[plane])}
def add_scale(self, verbose=False):
"""Add a scale to the top-right corner of the cropped image."""
if verbose:
print('Adding a scale bar..')
for img in self.edited_image_list:
scalebar = ScaleBar(img.mm_to_px)
# Prepare a figure without axes and calculate figure sizes
fig = plt.figure()
ax = plt.subplot(1, 1, 1)
plt.axis('off', frameon=False)
# Add image and scale
ax.imshow(img.image)
ax.add_artist(scalebar)
# Save the figure without borders to a temporary file
temp_file = os.path.join(tempfile.gettempdir(), 'temp.png')
extent = ax.get_window_extent().transformed(
fig.dpi_scale_trans.inverted())
fig.savefig(temp_file, bbox_inches=extent, dpi=600)
plt.close()
# Reload the temporary file as image object and delete it
img.image = io.imread(temp_file)
os.remove(temp_file)
if verbose:
print('Scale bar added.')
def add_scalebar(self):
"""
Display a scale bar in a matplotlib figure
"""
controller = self.controller
if controller.barON.get():
try:
if self.imgfile.dxyz is not None:
scalebar = ScaleBar(self.imgfile.dxyz[0], units = self.imgfile.unit,
frameon='False', color='w', location='lower right',
box_color='k', box_alpha='0')
# 1 pixel = metadata info
self.ax.add_artist(scalebar)
controller.canvas.draw()
if controller.roiON.get():
self.processed.roi_selector()
except AttributeError:
pass
else:
try:
if self.imgfile.dxyz is not None:
self.ax.artists.clear()
self.fig.canvas.draw()
except AttributeError:
pass
def __init__(self,
image,
axis,
colourbar_axis=None,
cmap=plt.get_cmap('gray'),
filepath=os.getcwd(),
polygoncallback=None):
'''For plotting Image as an image
Input a 2D array to plot as an image, and an axis to plot the image on
Optional arguments: define an axis to put a colourbar in, define the filepath to save images to'''
self.axis = axis
self.colourbar_axis = colourbar_axis
self.cmap = cmap
self.Image = image
self.axis.set_axis_off()
self.filepath = filepath
self.PlottedImage = self.axis.imshow(self.Image.data,
cmap=self.cmap,
interpolation='none')
if self.colourbar_axis:
self.cbar = self.AddColourbar()
if image.calibration != 0:
self.scalebar = ScaleBar(self.Image.calibration)
self.scalebar.box_alpha = 0.5
self.axis.add_artist(self.scalebar)
if polygoncallback:
self.polygoncallback = polygoncallback
else:
self.polygoncallback = self.keyboard_press
self.PolygonGroups = PolygonGrouper.PolygonGroupManager(self.axis)
self.Lines = LineDraw.LineDraw(self.axis)
self.canvas = self.axis.figure.canvas
self.connect()
self.creator = None
self.mover = None
def SaveMovieFrame(self,frame,roi_path_dict={},vmin=0,suffix='raw'):
if suffix=='raw':
self.raw_frame_string = os.path.join(self.save_direct,
"frame%04d"%(self.ts)+"_raw.png")
save_string = self.raw_frame_string
elif suffix=='shifted':
self.shifted_frame_string = os.path.join(self.save_direct,
"frame%04d"%(self.ts)+"_shifted.png")
save_string = self.shifted_frame_string
plt.figure(figsize=(6.,6.))
ax = plt.subplot(111)
ax.imshow(frame,vmin=vmin)
ax.plot(self.first_nuc_points[:,1],self.first_nuc_points[:,0],color='red',linewidth=1.25)
i=0
for key in roi_path_dict:
this_roi_path = roi_path_dict[key]
this_patch = patches.PathPatch(this_roi_path,facecolor='none',linewidth=1.0,edgecolor='white')
i+=1
ax.add_patch(this_patch)
scalebar = ScaleBar(self.pix_res,'um',location=4)
plt.gca().add_artist(scalebar)
plt.tight_layout()
plt.savefig(save_string,format='png',dpi=300)
plt.close('all')
def plot(self, save=False):
fig, ax = plt.subplots(1, 2, figsize=(14, 6))
ax[0].imshow(self.image)
ax[0].set_title('Imagen original', fontsize=14)
ax[0].add_artist(ScaleBar(self.pixel_height, 'm')) # Barra de escala
ax[1].imshow(self.transformed.mean(3))
ax[1].set_title('Imagen final', fontsize=14)
ax[1].add_artist(ScaleBar(self.pixel_height / self.magnification,
'm')) # Barra de escala
if save:
fig.savefig(os.path.join('outputs', self.output_name))
plt.show(block=True)
def export_data(self, event):
if event.inaxes == self.fig_image_parameter[7].ax:
print('export')
#'''Save image respecting the number of pixels of the origin image'''
#imsave('image_array.png', self.image_data)
#'''Save image without respecting the number of pixels of the origin image'''
plt.ioff()
fig_export = plt.figure(figsize=(10, 7), dpi=100)
ax_fig_export = fig_export.add_subplot(1, 1, 1)
image_fig_export = ax_fig_export.imshow(self.image_data,
cmap=self.cmap,
vmin=self.cmin,
vmax=self.cmax)
ax_fig_export.set_axis_off()
if self.state_scalebar == 1:
ax_fig_export.add_artist(ScaleBar(self.cal * 10**-9))
fig_export.canvas.draw()
if self.line_prof is not None:
np.savetxt('line_profile', self.profile)
fig_export.colorbar(image_fig_export)
fig_export.savefig('image.png')
print('Image saved')
status_export_raw = 1
if status_export_raw == 1:
np.savetxt('image_raw', self.image_data, delimiter=',')
print('Raw data extracted')
plt.close(fig_export)
def plotHeatGraph(self, sol, post=None, name="", vmax=None, cmap="Reds", objective=None):
mx=int(np.max(self.data['x']))
my=int(np.max(self.data['y']))
color = ['black',(0,0,0,0)]
cmapm = colors.ListedColormap(color)
bounds=[-1,0]
norm = colors.BoundaryNorm(bounds, cmapm.N)
gridmap = [[0 for x in range(mx+1)] for y in range(my+1)]
grid = [[0 for x in range(mx+1)] for y in range(my+1)]
i=0
for index, row in self.data.iterrows():
if i == self.source:
sy=int(row['y'])
sx=int(row['x'])
gridmap[int(row['y'])][int(row['x'])]=1
grid[int(row['y'])][int(row['x'])]=sol[i]
i+=1
#np.invert(gridmap)
gridmap = np.ma.masked_where(gridmap ==1, gridmap)
if vmax == None:
a = plt.imshow(np.flipud(grid), interpolation='none', cmap=cmap, extent=[0,mx+1,0,my+1])
else:
a = plt.imshow(np.flipud(grid), interpolation='none', cmap=cmap, extent=[0,mx+1,0,my+1], vmin=0, vmax=vmax)
if np.min(gridmap) == 0:
h = plt.imshow(np.flipud(gridmap), interpolation='none', cmap=cmapm, extent=[0,mx+1,0,my+1])
#plt.set(h, 'AlphaData', gridmap)
plt.colorbar(a)
plt.xticks(np.arange(0,mx+1))
plt.yticks(np.arange(0,my+1))
plt.grid(ls='solid')
if not post == None:
if plot_title:
if objective:
plt.title("%s: Patrol Effort, Objective: %f" %(name, objective))
else:
plt.title("Patrol Effort with Post %d %s" %(post, name))
# plt.xticks(np.arange(0,mx+1),[self.min_xval+self.resolution*i for i in range(mx+1)], rotation=60)
# plt.xlabel("x", fontsize=12)
# plt.yticks(np.arange(0,my+1),[self.min_yval+self.resolution*i for i in range(my+1)])
# plt.ylabel("y", fontsize=12)
scalebar = ScaleBar(dx=self.resolution, units='m', fixed_value=1, fixed_units='km', location='lower left') # 1 km or 200 m or 500m
plt.gca().add_artist(scalebar)
# plt.xticks(fontsize=6)
# plt.yticks(fontsize=6)
plt.plot([sx+0.5], [sy+0.5], marker='o', markersize=5, color="blue")
plt.savefig(self.datafolder + "patrol_effort_map_post_%d_%s.png" % (post, name))
plt.close()
#plt.show()
else:
plt.show()
def roadRight():
x2 = []
y2 = []
s1 = v1.get()
s2 = v2.get()
s3 = v3.get()
s4 = v4.get()
remarks = [s1, s2, s3, s4]
with open('csvfile1.txt', 'r') as csvfile:
plots = csv.reader(csvfile, delimiter=',')
for row in plots:
for i in range(0, 4):
if row[3] == remarks[i]:
x2.append(float(row[0]))
y2.append(float(row[1]))
print(x2, y2)
plt.plot(x2, y2)
scalebar = ScaleBar(0.02) # 1 pixel = 100 meter
plt.gca().add_artist(scalebar)
plt.legend(plt.plot(x2, y2), ["Road Right"], loc='lower right')
plt.axis('off')
plt.show()
def verifySegmentationBF(BFimage: np.ndarray, rRegion: np.ndarray,
sobelMasked: np.ndarray, imThresh: np.ndarray,
PATH: str, m: int, t: int, label: int):
if not os.path.exists(os.path.join(PATH, str(m))):
os.makedirs(os.path.join(PATH, str(m)))
savePath = os.path.join(PATH, str(m))
fname = f"{int(m):02d}t{int(t):03d}.jpeg"
fig, ax = plt.subplots(1, 3, figsize=(10, 10))
plt.imshow(BFimage, cmap="gray", origin="lower")
ax[0].imshow(BFimage, cmap="gray", origin="lower")
ax[0].axis("off")
ax[1].imshow(imThresh, cmap="viridis", origin="lower")
ax[1].axis("off")
ax[2].imshow(BFimage, cmap="gray", origin="lower")
ax[2].imshow(rRegion, alpha=0.3, origin="lower")
ax[2].axis("off")
scalebar = ScaleBar(0.33, units="um")
plt.gca().add_artist(scalebar)
plt.savefig(os.path.join(savePath, fname))
plt.close(fig)
return
def plot_image_to_file(d, title, legend=None):
PLOT_LOCK.acquire()
fig = plt.figure(constrained_layout=False, figsize=(15, 11.28), dpi=100)
ax = fig.add_subplot()
#ax.set_title(title, {'fontsize' :28})
ax.set_axis_off()
img = ax.imshow(d)
scalebar = ScaleBar(35, location=3, box_color='white')
plt.gca().add_artist(scalebar)
ax_img = fig.add_axes([0.15, 0.75, 0.21, 0.2], anchor='NW')
ax_img.imshow(te_logo)
ax_img.axis('off')
if legend:
ax_legend = fig.add_axes([0.63, 0.02, 0.22, 0.2], anchor='SE')
ax_legend.imshow(legend)
ax_legend.axis('off')
plt.tight_layout()
f = tempfile.NamedTemporaryFile(suffix='.png').name
plt.savefig(f, bbox_inches='tight')
PLOT_LOCK.release()
return f
def go_plot(p_bbox, p_raster_data, p_raster_data_extent, family, species,
points, p_xticks, p_jticks, p_xlabels, p_ylabels):
f, ax = plt.subplots(figsize=(7, 7))
ep.plot_rgb(
p_raster_data.values,
rgb=[0, 1, 2],
ax=ax,
#title="test Burundi",
extent=p_raster_data_extent)
p_points = geopandas.GeoDataFrame(geometry=points)
p_points.set_crs(epsg=3857, inplace=True)
p_points.plot(ax=ax, zorder=20, color="black")
ax.set_xticks(p_xticks)
ax.set_yticks(p_jticks)
ax.set_xticklabels(p_xlabels)
ax.set_yticklabels(p_ylabels)
ax.set_xlim(p_bbox[0], p_bbox[1])
ax.set_ylim(p_bbox[2], p_bbox[3])
ax.add_artist(ScaleBar(dx=1, box_alpha=0.1, location='lower left'))
print(family)
print(species)
#ax.set_title(family+ " - "+ species)
plt.savefig(output_map + family + "_" + species + ".png", dpi=300)
plt.close('all')
def show_threeview(nt, fig=None, **kwargs):
"""
Plots all three two-dimensional projections of the neuron in nt.
:param nt: NeuronTree, neuron to be plotted
:param fig: (optional) pass the figure handle from outside if you want more control.
:param kwargs: arguments that can be passed to the NeuronTree.draw_2D() function.
"""
if not fig:
fig = plt.figure(figsize=(16, 16))
ax1 = plt.subplot2grid((4, 4), (0, 1), rowspan=3, colspan=3)
ax2 = plt.subplot2grid((4, 4), (0, 0), rowspan=3, colspan=1)
ax3 = plt.subplot2grid((4, 4), (3, 1), rowspan=1, colspan=3)
ax4 = plt.subplot2grid((4, 4), (3, 0), rowspan=1, colspan=1)
nt.draw_2D(fig, ax=ax2, projection='zy', **kwargs)
nt.draw_2D(fig, ax=ax3, projection='xz', **kwargs)
nt.draw_2D(fig, ax=ax1, projection='xy', **kwargs)
scalebar = ScaleBar(1, units='um', location='lower left', box_alpha=0)
ax1.add_artist(scalebar)
ax4.axis('off')
ax1.axis('off')
ax2.spines['right'].set_visible(False)
ax2.spines['top'].set_visible(False)
ax3.spines['right'].set_visible(False)
ax3.spines['top'].set_visible(False)
def plot_fancy_overlay(
fiber,
cell,
field,
path_png,
label="field",
dpi=300,
cmap_cell="Greys_r",
cmap_fiber="Greys_r",
cmap_angle="viridis",
alpha_ori=0.8,
alpha_cell=0.4,
alpha_fiber=0.4, # example cmaps: viridis/inferno/coolwarm
omin=-1,
omax=1,
scale=None):
fig = plt.figure()
plt.imshow(field, cmap=cmap_angle, vmin=omin, vmax=omax, alpha=alpha_ori)
cbar = plt.colorbar()
plt.imshow(fiber, cmap=cmap_fiber, alpha=alpha_fiber)
plt.imshow(cell, cmap=cmap_cell, alpha=alpha_cell)
plt.axis('off')
cbar.set_label(label, fontsize=12)
if scale is not None:
scalebar = ScaleBar(scale,
"um",
length_fraction=0.1,
location="lower right",
box_alpha=0,
color="k")
plt.gca().add_artist(scalebar)
plt.tight_layout()
plt.savefig(path_png, dpi=dpi, bbox_inches='tight', pad_inches=0)
return fig
def plot_fiber_seg(fiber_image,
c0,
c1,
segmention,
path_png,
dpi=200,
scale=None):
fig7 = plt.figure()
my_norm = matplotlib.colors.Normalize(vmin=0.9999, vmax=1, clip=False)
# create a copy of matplotlib cmap
cmap = copycmap("Greys")
# everything under vmin gets transparent (all zeros in mask)
cmap.set_under('k', alpha=0)
#everything else visible
cmap.set_over('k', alpha=1)
# plot mask and center
plt.imshow(fiber_image, origin="upper")
plt.imshow(segmention, cmap=cmap, norm=my_norm, origin="upper")
plt.scatter(c0, c1, c="w")
plt.axis('off')
if scale is not None:
scalebar = ScaleBar(scale,
"um",
length_fraction=0.1,
location="lower right",
box_alpha=0,
color="k")
plt.gca().add_artist(scalebar)
plt.tight_layout()
plt.savefig(path_png, dpi=dpi, bbox_inches='tight', pad_inches=0)
return fig7
def _save_with_scalebar(self, signal, output_size=None):
# upstream this part to hyperspy
from matplotlib_scalebar.scalebar import ScaleBar
from matplotlib.figure import Figure
data = signal.data
dpi = 100
axes = signal.axes_manager.signal_axes
if output_size is None:
output_size = [axis.size for axis in axes]
fig = Figure(figsize=[size / dpi for size in output_size], dpi=dpi)
ax = fig.add_axes([0, 0, 1, 1])
ax.axis('off')
ax.imshow(data, cmap='gray')
if not isinstance(axes[0].units, str):
raise ValueError(
"Units of the signal axis needs to be of string type.")
scalebar = ScaleBar(axes[0].scale,
axes[0].units,
box_alpha=0.75,
length_fraction=0.4,
location='lower left',
font_properties={'size': 40})
ax.add_artist(scalebar)
fig.savefig(self.fullfname, dpi=dpi)
def create_preview(self):
if self.preview_figure != None:
plt.close(self.preview_figure)
# ---------fig0-------------------------------------------------------------
# first picture after the blurring and turning to binary
default_file = 'den.png'
src = cv.imread(self.p_file_path, cv.COLOR_BGR2HLS)
if src is None:
print('Error opening image!')
return -1
blur = cv.GaussianBlur(src, (5, 5), 0)
p_threshold2 = self.p_threshold1 * 3 if self.p_threshold1 <= 85 else 255
dst = cv.Canny(src, self.p_threshold1, p_threshold2, None, 3)
(DendriteList, img_merged_lines, _lines,
merged_lines_all) = self.get_detected_picture(dst)
self.preview_figure = plt.figure("Preview segmentation line detection")
ax = plt.gca()
scalebar = ScaleBar(0.167, 'um')
ax.add_artist(scalebar)
textstr = "Identified lines: {} \nIdentified lines after merging : {} ".format(
len(_lines), len(merged_lines_all))
props = dict(facecolor='blue', alpha=0.2)
ax.set_xlabel(textstr, bbox=props, fontsize=20)
imshow(img_merged_lines)
plt.xticks([]), plt.yticks([])
plt.show()
def plot_image_to_file(d, title, cmap=None, legend=None):
# find the position to place the dot
dot_pos = len(d[0]) / 2
fig = plt.figure(constrained_layout=False, figsize=(15, 11.28), dpi=100)
ax = fig.add_subplot()
ax.set_title(title, {'fontsize': 28})
ax.set_axis_off()
plt.plot(dot_pos, dot_pos, 'ko')
img = ax.imshow(d)
scalebar = ScaleBar(30, fixed_units='km', location=3,
box_color='none') # 1 pixel = 0.2 meter
plt.gca().add_artist(scalebar)
ax_img = fig.add_axes([0.16, 0.73, 0.21, 0.2], anchor='NW')
if cmap:
ax_img.imshow(te_logo, cmap=cmap)
else:
ax_img.imshow(te_logo)
ax_img.axis('off')
if legend:
ax_legend = fig.add_axes([0.63, 0.07, 0.21, 0.2], anchor='SE')
ax_legend.imshow(legend)
ax_legend.axis('off')
plt.tight_layout()
f = tempfile.NamedTemporaryFile(suffix='.png').name
plt.savefig(f, bbox_inches='tight')
return f
def shape_subplot(data, shape_names, dx, units, ax, ax_radius=None):
# Gather all shapes and plot
all_shapes = geopandas.GeoSeries(data[shape_names].values.flatten())
all_shapes.plot(color=(0, 0, 0, 0),
edgecolor=(1, 1, 1, 0.8),
lw=1,
aspect=None,
ax=ax)
# Set axes boundaries to be square; make sure size of cells are relative to one another
if ax_radius:
s_bound = data.bounds
centerx = np.mean([s_bound["minx"].min(), s_bound["maxx"].max()])
centery = np.mean([s_bound["miny"].min(), s_bound["maxy"].max()])
ax.set_xlim(centerx - ax_radius, centerx + ax_radius)
ax.set_ylim(centery - ax_radius, centery + ax_radius)
for spine in ax.spines.values():
spine.set(edgecolor="white", linewidth=1)
# Create scale bar
scalebar = ScaleBar(dx,
units,
location="lower right",
color="white",
box_alpha=0,
scale_loc="top")
ax.add_artist(scalebar)
def try_add_scalebar(axes, pixel_size, units="um", fontsize=8,
location="lower left"):
"""
If the *matplotlib_scalebar* package is available, add a
scalebar. Otherwise do nothing.
args
----
axes : matplotlib.axes.Axes
pixel_size : float
units : str
fontsize : int
location : str, "upper left", "lower left",
"upper right", or "lower right"
returns
-------
None
"""
try:
from matplotlib_scalebar.scalebar import ScaleBar
scalebar = ScaleBar(pixel_size, units, location=location,
frameon=False, color="w", font_properties={'size': fontsize})
axes.add_artist(scalebar)
except ModuleNotFoundError:
pass
def plot_images(img_xy_data,
img_add_metadata,
img_metadata,
channels,
saving_on=False,
scalebar=True):
format.formatLH()
for img_index, img in enumerate(img_xy_data):
ic(img_index, img.shape)
# print ('image:', img)
# print ('index:', index)
# zstacks = (img_metadata[img_index][0]['Shape_czifile'][4])
image = img[0]
scaling_x = handler.disp_scaling(img_add_metadata) #[img_index])
ic(scaling_x)
#print(img_metadata[img_index][0]['Filename'])
print(img_metadata[img_index]['Filename'])
for channel_index, channel_img in enumerate(img): #enumerates channels
ic(channel_index)
ic(channels[channel_index])
ic(channel_img.shape)
for z_index, z_img in enumerate(channel_img):
ic(z_index) #plt.imshow(imx) #ic(inx, imx)
ic(z_img.shape)
temp_filename = img_metadata[img_index]['Filename'].replace(
'.czi', '')
#temp_filename = img_metadata[img_index][0]['Filename'].replace('.czi', '')
title_filename = ''.join([
temp_filename, '_', channels[channel_index], '_',
str(z_index)
])
output_filename = ''.join(
['analysis/', title_filename, '.png'])
fig = plt.figure(figsize=(5, 5), frameon=False)
fig.tight_layout(pad=0)
plt.imshow(z_img, cmap='gray')
scalebar = ScaleBar(dx=scaling_x[0],
location='lower right',
fixed_value=30,
fixed_units='µm',
frameon=False,
color='w') # 1 pixel = scale [m]
plt.gca().add_artist(scalebar)
plt.axis('off')
plt.title(title_filename)
if saving_on:
plt.savefig(output_filename,
dpi=300) # ,image[channel],cmap='gray')
def _plot_scalebar(ax, fig, **kwargs):
x1, x2, y1, y2 = ax.axis()
_y = (y1 + y2) / 2
scale_bar = ScaleBar(1,
location=kwargs.get("location", "lower left"),
fixed_value=kwargs.get("fixed_value", None),
fixed_units=kwargs.get("fixed_units", None))
fig.gca().add_artist(scale_bar)
def _plot_scale(ax, fig, **kwargs):
x1, x2, y1, y2 = ax.axis()
_y = (y1 + y2) / 2
p1, p2 = (int(x1), _y), (int(x1) + 1, _y)
meter_per_deg = gcc.distance_between_points(p1, p2)
scale_bar = ScaleBar(meter_per_deg, units="m", location=kwargs.get("location", "lower left"),
fixed_value=kwargs.get("fixed_value", None), fixed_units=kwargs.get("fixed_units", None))
fig.gca().add_artist(scale_bar)
def visualize(obj,
data,
titlestr,
scale=1,
save=False,
file=None,
microns=1,
factor=5):
sz = np.array([
np.linalg.eig(obj.sigma[:3, :3, i])[0].sum()
for i in range(obj.sigma.shape[2])
])
cl = obj.mu[:, 3:6]
cl[cl < 0] = 0
cl = cl / cl.max()
P = obj.mu[:, :3] * scale
plt.cla()
plt.imshow(factor * data[:, :, :, [0, 1, 2]].max(2) / data.max())
plt.scatter(P[:, 1],
P[:, 0],
s=20 * sz,
edgecolors='w',
marker='o',
facecolors=cl)
if obj.prior is not None:
cl = obj.prior['mu'][:, 3:]
cl[cl < 0] = 0
cl = cl / cl.max()
PR = obj.prior['mu'][:, :3] * scale
plt.scatter(PR[:, 1],
PR[:, 0],
s=10 * sz,
edgecolors='w',
marker='x',
facecolors=cl)
for i in range(len(obj.prior['names'])):
plt.annotate(obj.prior['names'][i], (P[i, 1], P[i, 0]), c='r')
plt.title(titlestr)
plt.axis('off')
scalebar = ScaleBar(microns, 'um')
plt.gca().add_artist(scalebar)
if save:
plt.gcf().set_size_inches(data.shape[1] / 20, data.shape[0] / 20)
plt.savefig(file + '-labeling.eps', format='eps')
plt.savefig(file + '-labeling.png', format='png')
plt.savefig(file + '-labeling.pdf', format='pdf')
plt.close('all')
else:
plt.pause(.1)
plt.show()
def draw(self):
self.ax.clear()
self.sample_figure.draw(self.ax)
scalebar = ScaleBar(1.0, location="lower left")
self.ax.add_artist(scalebar)
self.canvas.draw()
def plot(self, axis=None, title="", gamma=0.5, cmap='gray'):
if axis is None:
_, axis = plt.subplots(1, 1, figsize=(8, 8))
axis.imshow((self.volume.sum(axis=0)) ** gamma, cmap=cmap)
axis.axis(False)
scale_bar = ScaleBar(self.pitch * 1e-6)
axis.add_artist(scale_bar)
title = f"{title}\n{self.total_count / 1e6:0.2f} mil photons"
axis.set_title(title)
def plot_cntr(self, roi_max_distance=300, padding=50):
soma_pos = self.soma
dendrites = self.data_paths[self.data_paths.type == 3]
rois_pos = np.vstack(self.data_rois.roi_pos)
rois_dis = self.data_rois.dendritic_distance_to_soma.values
colors = np.vstack(
plt.cm.viridis(
(rois_dis / roi_max_distance * 255).astype(int)))[:, :3]
fig, ax = plt.subplots(figsize=(8, 8))
quality = self.data_cntr['cntr_quality'].values
for row in dendrites.iterrows():
path = row[1]['path']
ax.plot(path[:, 0], path[:, 1], color='gray')
for row in self.data_cntr.iterrows():
idx = row[0]
idx -= 1
if idx < 0: continue
distance = self.data_rois.loc[idx]['dendritic_distance_to_soma']
if row[1]['cntr_quality']:
cntr = row[1]['RF_cntr_upsampled'][0]
ax.plot(cntr[:, 0], cntr[:, 1], color=colors[idx])
ax.scatter(rois_pos[idx, 0],
rois_pos[idx, 1],
color=colors[idx],
zorder=10)
stack_pixel_size = self.data_stack['pixel_size']
stack_shape = self.data_stack['shape']
max_lim = (stack_shape * stack_pixel_size)[0]
max_lim = np.maximum(max_lim, 350)
ax.set_xlim(-padding, max_lim)
ax.set_ylim(-padding, max_lim)
scalebar = ScaleBar(1,
units='um',
location='lower left',
box_alpha=0,
pad=0)
ax.add_artist(scalebar)
ax.invert_yaxis()
ax.axis('off')
ax.axis('equal')
