def label_chart(self, csv_path):
"""Show and Label the Chart. Call this method. """
# Create axis for the price and technical indicator graph
ax1 = self.fig.add_suplot(211)
# Turn on axes and background lines
self.path = csv_path
plt.axis('on')
self.df.plot(x=self.col_label, y=self.row_label, ax=ax1, label='price', color='black')
# Plot Technical Indicators
if self.tech_inds:
for col_name in self.tech_inds:
ti_df = self.df[['time', col_name]].copy()
ti_df.plot(x='time', y=col_name, ax=ax1, label=col_name)
# 1 = left mouse, 2 = scroll wheel, 3 = right mouse
lsso_sell = LassoSelector(ax=self.ax, onselect=self.onSelectSell,
lineprops=self.lineprops_sell, button=1)
lsso_buy = LassoSelector(ax=self.ax, onselect=self.onSelectBuy,
lineprops=self.lineprops_buy, button=3)
lsso_clear = LassoSelector(ax=self.ax, onselect=self.onSelectClear,
lineprops=self.lineprops_clear, button=2)
# On Keyboard Enter press, export the labelled data to .csv
self.fig.canvas.mpl_connect('key_press_event',
self.enter_press_export_event)
plt.show()
def init_df(self, df):
self.exclude = set()
self.mean_line = None
self.initial_df = df.set_index(['lon', 'lat'])
self.df = df.reset_index().drop_duplicates(
['lon', 'lat', 'time']).set_index(['lon', 'lat'])
collection = self.scatter_ax.scatter(self.df.time, self.df.temperature,
1)
self.lola = lola = df.drop_duplicates(
['lon', 'lat']).reset_index().set_index(['lon', 'lat'])
lola['index'] = np.arange(len(lola))
map_collection = self.map_ax.scatter(lola.index.get_level_values(0),
lola.index.get_level_values(1),
s=1,
transform=ccrs.PlateCarree())
self.collection = collection
self.map_collection = map_collection
self.xys = collection.get_offsets()
self.Npts = len(self.xys)
self.map_xys = map_collection.get_offsets()
self.map_Npts = len(self.map_xys)
# Ensure that we have separate colors for each object
self.fc = collection.get_facecolors()
if len(self.fc) == 0:
raise ValueError('Collection must have a facecolor')
elif len(self.fc) == 1:
self.fc = np.tile(self.fc, (self.Npts, 1))
# Ensure that we have separate colors for each object
self.map_fc = map_collection.get_facecolors()
if len(self.map_fc) == 0:
raise ValueError('Collection must have a facecolor')
elif len(self.map_fc) == 1:
self.map_fc = np.tile(self.map_fc, (self.map_Npts, 1))
self.lasso = LassoSelector(self.scatter_ax, onselect=self.onselect)
self.map_lasso = LassoSelector(self.map_ax, onselect=self.map_onselect)
self.plot_band_mean()
self.ind = []
self.map_ind = []
self.refresh_table()
def reset_selection(self):
"""Reset lasso selection
"""
self.xy_compute()
self.ind = []
self.selected = controller.get_view_mask(controller.slice).flatten()
self.lasso = LassoSelector(self.main_ax, onselect=self.onselect)
def create_baseplot(self):
self.fig = plt.figure()
self.fig.suptitle("Interactive Dimension Reduction RoI Selection")
self.ax1 = plt.axes([0.12, 0.2, 0.4, 0.75])
self.ax1.set_title("Embedding")
self.ax1.set_xlabel("Dimension A")
self.ax1.set_ylabel("Dimension B")
self.ax1.set_xlim([self.ax1_xmin, self.ax1_xmax])
self.ax1.set_ylim([self.ax1_ymin, self.ax1_ymax])
self.pts = self.ax1.scatter(self.embedding[:, 0],
self.embedding[:, 1],
s=10,
c="blue")
self.ax1.set_aspect('equal')
self.ax2 = plt.axes([0.55, 0.2, 0.4, 0.75])
self.ax2.axis("off")
self.ax2.set_title('RoI Area:')
self.ax2.imshow(self.img, vmax=1)
self.lsso = LassoSelector(ax=self.ax1,
onselect=self.onselect,
lineprops=self.toggle_props[self.toggle])
plt.subplots_adjust(bottom=0.1)
self.ax3 = plt.axes([0.25, 0.05, 0.12, 0.065])
self.resetbutton = Button(self.ax3, "Reset")
self.resetbutton.on_clicked(self.reset)
self.ax4 = plt.axes([0.45, 0.05, 0.12, 0.065])
self.roibutton = Button(self.ax4, "Set RoI")
self.roibutton.on_clicked(self.exportroi)
self.ax5 = plt.axes([0.65, 0.05, 0.22, 0.065])
self.returnbutton = Button(self.ax5, "Return and Close")
self.returnbutton.on_clicked(self.return_rois)
def reset(self, event):
self.lsso = LassoSelector(ax=self.ax1,
onselect=self.onselect,
lineprops=self.toggle_props["roi"])
self.pts.remove()
self.adjust_variables()
self.adjust_plots()
def setTarget(self, event):
#lassoの対象をclickから決定する
if not len(event.ind):
return True
if not self.lassoTarget == None: #初回のclickでない場合は先に選択されていたものを元に戻す
self.lassoTarget.set_alpha(self.pre_alpha)
try: #あったら掃除 多分いつもある
self.selectedLine.remove()
except:
pass
self.selectedIndices = set()
self.unselectedIndices = set()
#plotの設定を保存
self.lassoTarget = event.artist
self.pre_alpha = self.lassoTarget.get_alpha()
self.pre_settings = self.getSettings(self.lassoTarget)
#alphaの調整とselectedLineの描画 まだinvisible データの取得
self.lassoTarget.set_alpha(self.ALPHA_OTHER)
self.selectedLine, = self.lassoTarget.axes.plot([], [],
visible=False,
linestyle='None',
**self.pre_settings)
self.lasso = LassoSelector(self.lassoTarget.axes,
onselect=self.onselect)
self.xys = np.array([[x, y] for x, y in zip(
self.lassoTarget.get_xdata(), self.lassoTarget.get_ydata())])
self.canvas.draw()
def draw_mask(
tif_file,
out_tif=None,
n_masks=1,
):
image = tifffile.imread(tif_file)
if len(image.shape) > 2:
image = find_xy_image(image)
if type(out_tif) == type(None):
out_tif = tif_file.replace('.tif', '_single_mask.tif')
y, x = np.mgrid[:image.shape[0], :image.shape[1]]
points = np.transpose((x.ravel(), y.ravel()))
mask = np.zeros(image.shape, dtype='uint16')
for mask_idx in range(n_masks):
fig, ax = plt.subplots(figsize=(9, 9))
plot_image = image.copy()
plot_image[np.where(mask)] = image.max()
ax.imshow(plot_image, cmap='gray', vmax=image.mean() + 3 * image.std())
lasso = LassoSelector(ax, onselect)
plt.show()
plt.close()
verts = np.asarray(pd.read_csv('_verts.txt', sep='\t', header=None))
path = Path(verts, closed=True)
new_mask = path.contains_points(points).reshape(image.shape[0], \
image.shape[1]).astype('uint16')
mask += new_mask
tifffile.imsave(out_tif, mask)
return mask, path
def __init__(self, ax, button=3):
self.canvas = ax.figure.canvas
self.Npts = len(self.xys)
self.lasso = LassoSelector(ax, onselect=self.onselect, button=[button])
self.ind = []
def show(self):
self.fig = plt.figure()
ax = self.fig.add_subplot(111)
ax.axis("off")
lo = np.nanmin(self.xy, axis=0)
hi = np.nanmax(self.xy, axis=0)
center = (hi + lo) / 2
w, h = hi - lo
ampl = 1.3
w *= ampl
h *= ampl
ax.set_xlim(center[0] - w / 2, center[0] + w / 2)
ax.set_ylim(center[1] - h / 2, center[1] + h / 2)
ax.imshow(self.image)
ax.scatter(*self.xy.T, s=self.cfg["dotsize"]**2)
ax.add_collection(self.lines)
ax.invert_yaxis()
self.lasso = LassoSelector(ax, onselect=self.on_select)
ax_clear = self.fig.add_axes([0.85, 0.55, 0.1, 0.1])
ax_export = self.fig.add_axes([0.85, 0.45, 0.1, 0.1])
self.clear_button = Button(ax_clear, "Clear")
self.clear_button.on_clicked(self.clear)
self.export_button = Button(ax_export, "Export")
self.export_button.on_clicked(self.export)
self.fig.canvas.mpl_connect("pick_event", self.on_pick)
plt.show()
def __init__(self, directory):
self.directory = directory
self.sampleArray = self.directory.sampleFits.arrays
self.openArray = self.directory.openFits.arrays
self.im = self.sampleArray[sliderInd]
self.frame = tk.Toplevel()
self.fig = Figure(figsize=(7, 7))
self.ax = self.fig.add_subplot(111)
self.strainButton = tk.Button(self.frame,
text="do",
command=self.strainMap)
self.canvas = FigureCanvasTkAgg(self.fig, master=self.frame)
self.canvas.show()
self.canvas.get_tk_widget().grid(row=0)
self.canvas.mpl_connect('key_press_event', self.onKey)
self.strainButton.grid(row=1)
self.mask = np.zeros((512, 512))
self.pix = np.arange(512)
self.XX, self.YY = np.meshgrid(self.pix, self.pix)
self.pix = np.vstack((self.XX.flatten(), self.YY.flatten())).T
self.lasso = LassoSelector(self.ax, self.onselect)
def close():
lasso = LassoSelector(ax1, onselect) # associated with subplot 1
plt.show()
return array
def LassoSelection(img):
from matplotlib.widgets import LassoSelector
from matplotlib import path
import matplotlib.pyplot as plt
global nROI, ROI, ROI_color, points
dims = img.shape
nROI = 0
ROI = np.zeros((dims[0], dims[1]))
ROI_color = np.zeros((dims[0], dims[1], 3))
points = np.fliplr(np.array(np.nonzero(np.ones((dims[0], dims[1])))).T)
fig = plt.figure(1, figsize=(14, 7))
ax1 = plt.subplot(121)
f1 = ax1.imshow(imNormalize(img, 99), cmap=plt.get_cmap('gray'))
ax2 = plt.subplot(122)
f2 = ax2.imshow(ROI_color, cmap=plt.get_cmap('gray'))
points_poly = []
def onselectf(verts):
global nROI, ROI, ROI_color, points
nROI += 1
p = path.Path(verts)
points_poly = np.where(p.contains_points(points, radius=1))[0]
tmp = np.zeros((dims[0], dims[1]))
tmp[points[points_poly, 1], points[points_poly, 0]] = 1
tmp[np.where(ROI > 0)] = 0
ROI = ROI + tmp * nROI
ROI_color = ROI_color + np.tile(tmp[:, :, None], (1, 1, 3))
f2.set_data(ROI_color)
fig.canvas.draw()
print('ROI', nROI, 'drawn')
lasso = LassoSelector(ax1, onselect=onselectf)
plt.show()
cnum = 0
while True:
select = fig.ginput(1)
if not select:
break
else:
xy = (np.asarray(select)[0]).astype(int)
if xy.min() >= 1 and xy[1] < dims[0] and xy[0] < dims[1]:
cnum = 1
print('ROI selection done')
return nROI, ROI
def __init__(self, oengus, pos):
self.canvas = oengus.figure.canvas
self.canvas.mpl_connect('draw_event', self._draw_event)
self.axes = oengus.SubPlotList[pos[0]][pos[1]].axes
self.lasso = LassoSelector(
self.axes,
#lineprops={'color': 'red', 'linewidth': 4, 'alpha': 0.8},
onselect=self.onselect #partial(
)
def exportroi(self, event):
self.lsso = LassoSelector(ax=self.ax1,
onselect=self.onselect,
lineprops=self.toggle_props["roi"])
self.idx["reset"] = []
if not (self.img == 0).all():
self.rois.append(self.img.copy())
self.adjust_variables()
self.adjust_plots()
def __init__(self, ax, grid, csv, image):
self.canvas = ax.figure.canvas
self.grid = grid
self.csv = csv
self.ax = ax
self.image = image
self.tool = LassoSelector(ax, onselect=self.onselect)
self.ind = []
self.selection = []
def create_lassos():
lassos = matts_admin_functions.create_empty_list(number_of_planes)
lasso_functions = create_lasso_functions()
for plane in range(number_of_planes):
axis = main.region_figures[plane].get_axes()
lassos[plane] = LassoSelector(axis[0], lasso_functions[plane])
return lassos
def __init__(self, ax, implot, color=[1,1,1]):
self.canvas = ax.figure.canvas
self.implot = implot
self.array = implot.get_array()
xv, yv = np.meshgrid(np.arange(self.array.shape[1]),np.arange(self.array.shape[0]))
self.pix = np.vstack( (xv.flatten(), yv.flatten()) ).T
self.ind = []
self.im_bool = np.zeros((self.array.shape[0], self.array.shape[1]))
self.color = color
self.lasso = LassoSelector(ax, onselect=self.onselect)
def __init__(self, tracker, ax, collection, alpha, alpha_other=0.2):
self.tracker = tracker
self.ax = ax
self.collection = collection
self.fc = collection.get_facecolors()
self.alpha = alpha
self.alpha_other = alpha_other
self.lasso = LassoSelector(ax, onselect=self.on_select)
self.is_connected = True
self.toggle()
def select_lasso_area(self):
self.lasso_plane_list = list()
lasso_props = {'color': 'red', 'linewidth': 0.5, 'alpha': 1}
self.lasso = LassoSelector(self.canvas.axes,
self.onselect,
lineprops=lasso_props)
self.cursor = Cursor(self.canvas.axes,
useblit=False,
color='red',
linewidth=0.5)
def __init__(self, ax, collection, parent):
self.ax = ax
self.canvas = ax.figure.canvas
self.collection = collection
self.xys = collection
self.Npts = len(self.xys)
self.parent = parent
self.lasso = LassoSelector(ax, onselect=self.onselect)
self.ind = []
def __init__(self, img, shape, mask):
self.img = img
self.phi_shape = shape
self.fig = plt.figure()
self.ax1 = self.fig.add_subplot(121)
self.pix = self.region_select_setup()
self.selected_region = None
m = LassoSelector(self.ax1, self.onselect)
plt.show()
self.mask = (self.selected_region > 0) * 1
def tempvis(csv_file, tmax, tmin, cmap, showortell='show'):
"""This function converts the csv file into a black-and-white picture. It does not at present
have a colorbar to indicate the temperature scale."""
csv = np.genfromtxt(csv_file, delimiter=',')
title = '\n Heat map of ' + csv_file.split("/")[-1][:-4] + '\n'
fig = plt.figure()
ax1 = fig.add_subplot(121)
ax1.imshow(csv)
ax1.set(title=title)
ax2 = fig.add_subplot(122)
ax2.imshow(np.zeros_like(csv))
plt.subplots_adjust()
x, y = np.meshgrid(np.arange(csv.shape[1]), np.arange(csv.shape[0]))
pix = np.vstack((x.flatten(), y.flatten())).T
saved_localmax = []
saved_localmaxavg = []
saved_localmin = []
saved_localavg = []
saved_labels = []
saved_volts = []
saved_currs = []
def onselect(verts):
#Driver for lasso selection on images
p = Path(verts)
ind = p.contains_points(pix, radius=1)
selected = np.zeros_like(csv)
selected.flat[ind] = csv.flat[ind]
data = csv.flat[ind]
ax2.imshow(selected)
fig.canvas.draw_idle()
save = input("Save data in selection?[y/n]: ")
if (save == "y"):
max = np.amax(data)
maxavg = np.average(heapq.nlargest(10, data))
min = np.amin(data)
avg = np.average(data)
saved_localmax.append(max)
saved_localmaxavg.append(maxavg)
saved_localmin.append(min)
saved_localavg.append(avg)
lab = input("Label for this region: ")
volt = input("Voltage: ")
curr = input("Current: ")
saved_labels.append(lab)
saved_volts.append(float(volt))
saved_currs.append(float(curr))
lasso = LassoSelector(ax1, onselect)
plt.show()
print("Done with processing")
print("--------------------------------------")
return (saved_localmax, saved_localmaxavg, saved_localmin, saved_localavg,
saved_labels, saved_volts, saved_currs)
def accept(event):
if event.key == "enter":
print("Selected points:")
print(selector.xys[selector.ind])
selector.disconnect()
ax.set_title("")
fig.canvas.draw()
selector.lasso = LassoSelector(ax, onselect=selector.onselect)
selector.ind = np.array([]).astype(int)
selector.fc[:, -1] = 1
selector.collection.set_facecolors(selector.fc)
def draw(self):
if 0:
t = arange(0.0, 3.0, 0.01)
s = sin(2 * pi * t)
self.axes.plot(t, s)
lineprops = {'color': 'red', 'linewidth': 4, 'alpha': 0.8}
self.lsso = LassoSelector(ax=self.axes,
onselect=onSelect,
lineprops=lineprops)
self.canvas.mpl_connect('button_press_event', onPress)
self.canvas.mpl_connect('button_release_event', onRelease)
plt.show()
def refreshLassoWidget(self, keep_paths=False):
self.roi_ax.clear()
init_lasso = False
if self.roi_image is not None:
if len(self.roi_mask) > 0:
newImage = plot_tools.overlayImage(
self.roi_image[:, :, self.current_z_slice],
self.roi_mask,
0.5,
self.colors,
z=self.current_z_slice)
else:
newImage = self.roi_image[:, :, self.current_z_slice]
self.roi_ax.imshow(newImage, cmap=cm.gray)
init_lasso = True
else:
self.roi_ax.imshow(self.blank_image)
self.roi_ax.set_axis_off()
self.roi_canvas.draw()
if not keep_paths:
self.roi_path_list = []
if init_lasso:
if self.roi_type == 'circle':
self.lasso_1 = EllipseSelector(self.roi_ax,
onselect=self.newEllipse,
button=1)
elif self.roi_type == 'freehand':
self.lasso_1 = LassoSelector(self.roi_ax,
onselect=self.newFreehand,
button=1)
self.lasso_2 = LassoSelector(self.roi_ax,
onselect=self.appendFreehand,
button=3)
else:
print(
'Warning ROI type not recognized. Choose circle or freehand'
)
def lassoSwitch(event):
"""Enable disable lasso tool."""
global lasso
lasso = []
flexFig.lassoSwitchCount = (flexFig.lassoSwitchCount + 1) % 2
if flexFig.lassoSwitchCount == 1: # enable lasso
flexFig.disconnect() # disable drag function of sector mask
lasso = LassoSelector(ax, onselect)
bLasso.label.set_text("Lasso\nOn")
else: # disable lasso
# lasso = [] # I am not sure we want to reset lasso with this button
flexFig.connect() # enable drag function of sector mask
bLasso.label.set_text("Lasso\nOff")
def __init__(self, ax, collection, alpha_other=0.3):
"""The lasso."""
self.canvas = ax.figure.canvas
self.collection = collection
self.alpha_other = alpha_other
self.xys = collection.get_offsets()
self.fcl = collection.get_facecolors()
if not self.fcl.any():
raise ValueError('Collection must have a facecolor')
elif len(self.fcl) == 1:
self.fcl = np.tile(self.fcl, (len(self.xys), 1))
self.lasso = LassoSelector(ax, onselect=self.onselect)
self.ind = []
def __init__(self, x, y, canvas, figure, data, xlabel, ylabel):
self.canvas = canvas
self.ax = figure
self.ax.clear()
self.collection = data
self.xlabel = xlabel
self.ylabel = ylabel
self.xys = self.collection.get_offsets()
self.x = x
self.y = y
self.ax.scatter(x, y, color='blue')
self.ind = []
self.lasso = LassoSelector(self.ax, onselect=self.onselect)
def choosePolygon(self, event=None):
'''
Activates matplotlib widget LassoSelector.
'''
from matplotlib.widgets import LassoSelector
if hasattr(self, '_cidRect'):
self.disconnectRect()
self.printOutput(
'Select polygon is active. Add points with leftclick. Finish with rightclick.'
)
self._cidPoly = None
self._cidPoly = self.ax.figure.canvas.mpl_connect(
'button_press_event', self._onpress)
self._lasso = LassoSelector(self.ax, self._onselect_verts)
return self._lasso
def unmask(self, event):
self.unmask_clicked = not self.unmask_clicked
if self.unmask_clicked:
self.mask_clicked = False
self.lasso = LassoSelector(self.display,
onselect=self.lasso_then_unmask)
self.edges = False
self.edge_button_press(1)
else:
self.lasso = 0
self.draw()
