fig = plt.figure(figsize=(8,4.5),facecolor=(0.129,0.129,0.129))
ax3=fig.add_subplot(212)
line3, =ax3.plot([1,2,3],[1,2,3])
ax2=fig.add_subplot(211)
line2, =ax2.plot([1,2,3],[1,2,3])
ax1=fig.add_subplot(111)
line1, =ax1.plot([1,2,3],[1,2,3])
ax1.tick_params(axis='x', colors='white')
ax1.tick_params(axis='y', colors='white')
ax2.tick_params(axis='x', colors='white')
ax2.tick_params(axis='y', colors='white')
ax3.tick_params(axis='x', colors='white')
ax3.tick_params(axis='y', colors='white')
fig.subplots_adjust(left=0.20,right=0.80,bottom=0.04)
typeSelectorax = plt.axes([0.01,0.71,0.14,0.25])
typeSelector = RadioButtons(typeSelectorax,("none","butter","ellip","cheby"))
slider1ax = plt.axes([0.01,0.26,0.04,0.4])
slider1 = Slider(slider1ax,"low",0.05,10,orientation="vertical")
slider1.label.set_color("white")
slider2ax = plt.axes([0.06,0.26,0.04,0.4])
slider2 = Slider(slider2ax,"high",1,60,orientation="vertical")
slider2.label.set_color("white")
slider3ax = plt.axes([0.11,0.26,0.04,0.4])
slider3 = Slider(slider3ax,"order",0,5,orientation="vertical")
slider3.label.set_color("white")
plusbuttonax = plt.axes([0.9,0.01,0.1,0.09])
plusim = Image.open("plus.png")
plusbutton = Button(plusbuttonax,"",plusim,color=(0.129,0.129,0.129),hovercolor=(0.15,0.15,0.15))
savebuttonax=plt.axes([0.9,0.13,0.1,0.1])
loadbuttonax=plt.axes([0.9,0.26,0.1,0.1])
saveim = Image.open("save.png")
fig, ax = plt.subplots()
plt.subplots_adjust(left=0.25, bottom=0.25)
t = np.arange(0.0, 1.0, 0.001)
a0 = 5
f0 = 3
s = a0 * np.sin(2 * np.pi * f0 * t)
l, = plt.plot(t, s, lw=5, color='red')
plt.axis([0, 1, -10, 10])
axcolor = 'lightgoldenrodyellow'
axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)
sino_freq = Slider(axfreq, 'Freq', 0.1, 30.0, valinit=f0)
sino_freq.on_changed(update)
axamp = plt.axes([0.25, 0.15, 0.65, 0.03], facecolor=axcolor)
sino_amp = Slider(axamp, 'Amp', 0.1, 10.0, valinit=a0)
sino_amp.on_changed(update)
resetax = plt.axes([0.8, 0.025, 0.1, 0.04])
reset_button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
reset_button.on_clicked(reset)
radioax = plt.axes([0.025, 0.5, 0.15, 0.15], facecolor=axcolor)
radio = RadioButtons(radioax, ('red', 'blue', 'green'), active=0)
radio.on_clicked(colorfunc)
plt.show()
#%% Radio buttom for velocity selection
## Add vel to mapdict
if cumfile2:
mapdict_vel = {'vel(1)': vel, 'vel(2)': vel2}
mapdict_unit.update([('vel(1)', 'mm/yr'), ('vel(2)', 'mm/yr')])
else:
mapdict_vel = {'vel': vel}
mapdict_unit.update([('vel', 'mm/yr')])
mapdict_vel.update(mapdict_data)
mapdict_data = mapdict_vel ## To move vel to top
axrad_vel = pv.add_axes(
[0.01, 0.3, 0.13, len(mapdict_data) * 0.025 + 0.04])
### Radio buttons
radio_vel = RadioButtons(axrad_vel, tuple(mapdict_data.keys()))
for label in radio_vel.labels:
label.set_fontsize(8)
def show_vel(val_ind):
global vmin, vmax, cum_disp_flag
cum_disp_flag = False
if 'vel' in val_ind: ## Velocity
data = mapdict_data[val_ind] * mask
data = data - np.nanmean(data[refy1:refy2, refx1:refx2])
if vlimauto: ## auto
vmin = np.nanpercentile(data * mask, 100 - auto_crange)
vmax = np.nanpercentile(data * mask, auto_crange)
cax.set_cmap(cmap)
cax.set_clim(vmin, vmax)
ax = fig.add_subplot(111, projection='3d')
ax.set_facecolor('#A9A9A9') # set background to medium gray
fig.patch.set_facecolor('#A9A9A9') # match with axes background for aesthetics
ax.w_xaxis.set_pane_color((.5, .5, .5))
ax.w_yaxis.set_pane_color((.5, .5, .5))
ax.w_zaxis.set_pane_color((.5, .5, .5))
# Shrink current axis by 10%
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.9,
box.height]) # set for 1 time
psc_colors = cm.get_cmap('autumn')(np.linspace(0, 1, n_psc))
csc_colors = cm.get_cmap('winter')(np.linspace(0, 1, n_csc))
colors = ColorTracker()
# Plotting gets called here
# 3D scatter plot
plot(ax, 0)
process_ax(ax)
# Location slider
axloc = plt.axes([0.20, 0.1, 0.3, 0.03], facecolor='silver')
sloc = Slider(axloc, 'Location ID', 0, cloc, valinit=0, valstep=1)
sloc.on_changed(update)
# Buttons
rax = plt.axes([0.025, 0.5, 0.08, 0.10], facecolor='silver')
radio = RadioButtons(rax, ('1st', '2nd'), active=0)
radio.on_clicked(click)
# Show
plt.show()
def show(self, edit_mode=False, window_location=(10, 30)):
"""
Calls matplotlib.pyplot.show() to display log viewer. If
edit_mode == True, it includes options to graphically edit
curve data, and stores these changes within the LogViewer
object. After editing is finished, access the updated
:class:`petropy.Log` data with the .log property.
Parameters
-----------
edit_mode : bool (default False)
Setting to allow editing of curve data
window_location : float, float tuple (default 10, 30)
Tuple of floats to specify top left location of LogViewer
First value is pixels from the left of the screen.
Second value is pixels from the top of the screen.
Examples
--------
>>> import petropy as ptr
>>> log = ptr.log_data('WFMP') # sample Wolfcamp log
>>> viewer = ptr.LogViewer(log) # default triple-combo template
>>> viewer.show() # display graphs
>>> import petropy as ptr
>>> log = ptr.log_data('WFMP') # sample Wolfcamp log
>>> viewer = ptr.LogViewer(log)
# display graphs with editing option
>>> viewer.show(edit_mode = True)
>>> file_path = 'path/to/new_file.las'
# writes changed data to new las file
>>> viewer.log.write(file_path)
"""
if len(str(self.log.well['UWI'].value)) > 0:
log_window_title = 'UWI: ' + str(self.log.well['UWI'].value)
elif len(self.log.well['API'].value) > 0:
log_window_title = 'API: ' + str(self.log.well['API'].value)
else:
log_window_title = 'Log Viewer'
self.fig.canvas.set_window_title(log_window_title)
if edit_mode:
mpl.rcParams['toolbar'] = 'None'
self.edit_fig, self.edit_axes = plt.subplots(1)
mpl.rcParams['toolbar'] = 'toolmanager'
rax = plt.axes([0, 0, 1, 1])
self._radio_button = RadioButtons(
rax, ('No Edit', 'Manual Edit', 'Bulk Shift'))
self._radio_button.on_clicked(self._radio_click)
self.fig.canvas.mpl_connect('pick_event', self._curve_pick)
self.fig.canvas.mpl_connect('button_press_event',
self._edit_lock_toggle)
self.fig.canvas.mpl_connect('button_release_event',
self._edit_lock_toggle)
self.fig.canvas.mpl_connect('motion_notify_event',
self._draw_curve)
self.edit_fig.set_size_inches(2, 1)
self.edit_fig.canvas.set_window_title('Curve Edit Options')
plt.show()
pl.ioff()
ax = pl.subplot(111)
pl.subplots_adjust(left=0.25)
pl.subplots_adjust(right=0.95) # see also the colorbar params in core.py
#call_spec()
#Buttons Start Here
bxl = 0.02
bw = 0.12 # width (for most)
axcolor = 'lightgoldenrodyellow'
#define the box where the buttons live
rax = pl.axes([bxl, 0.87, bxl + bw, 0.11], axisbg=axcolor)
radio = RadioButtons(rax, ('no marker', '40', '80', '120'), active=0)
def msfunc(label):
global y, NFFT, Fsamp, Fcentre, foverlap, detrend, _window, _type, fmod, marker_size
msdict = {'no marker': 0, '40': 40, '80': 80, '120': 120}
marker_size = msdict[label]
print("marker_size", marker_size)
callback.redraw(
) # really should add markers here! (this is a call without getting new data)
radio.on_clicked(msfunc)
rax = pl.axes([bxl, 0.68, bxl + bw, 0.18], axisbg=axcolor)
radio = RadioButtons(rax, ('win 128', '256', '512', '1024', '2048', '4096'),
def __init__(self, img: np.ndarray, mask: np.ndarray, win_title=None):
super().__init__(win_title, (0.05, 0.18, 0.9, 0.7))
axcolor = 'lightgoldenrodyellow'
self.disable_callbacks()
self.src = img.copy()
self.src_hsv = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)
self.mask_src = preprocess_mask(mask)
self.gc_mask = np.copy(self.mask_src)
self.viewmode = ViewMode.MASKED_IMAGE
self.brush_iptr = BrushInterpreter()
self.history_mgr = MaskEditHistoryManager()
self.save_result = False
self.pixel_panel = self.fig.add_axes((0.7, 0.9, 0.08, 0.05))
self.pixel_panel.imshow(255 * np.ones((5, 8, 3), np.uint8))
hide_axes_labels(self.pixel_panel)
for pos in ['left', 'top', 'right', 'bottom']:
self.pixel_panel.spines[pos].set_color('none')
unit = 0.06
# Create brush panel
self.brush_panel = self.fig.add_axes((unit, 0.9, len(BrushType) * unit, unit))
hide_axes_labels(self.brush_panel)
self.brush_panel.imshow(np.array([[BrushType.val2color(i) for i in range(len(BrushType))]]))
self.brush_indicator = []
self.update_brush_panel()
# Create largest component panel
self.lc_panel = self.fig.add_axes(((len(BrushType) + 1) * unit, 0.9, unit, unit))
hide_axes_labels(self.lc_panel)
self.lc_panel.text(
-0.45, -0.7,
'Largest Component Only',
bbox=dict(
linewidth=1,
edgecolor='goldenrod',
facecolor='none',
alpha=1.0
)
)
self.lc_panel.imshow(np.array([[[255, 255, 224]]], dtype=np.uint8))
self.lc_switch = RadioButtons(self.lc_panel, ('off', 'on'))
self.lc_switch.on_clicked(lambda x: self.update_mask() or self.history_mgr.add_switch_history('lc') or self.display())
# Create fill holes panel
self.fh_panel = self.fig.add_axes(((len(BrushType) + 3) * unit, 0.9, unit, unit))
hide_axes_labels(self.fh_panel)
self.fh_panel.text(
-0.45, -0.7,
'Fill Holes',
bbox=dict(
linewidth=1,
edgecolor='goldenrod',
facecolor='none',
alpha=1.0
)
)
self.fh_panel.imshow(np.array([[[255, 255, 224]]], dtype=np.uint8))
self.fh_switch = RadioButtons(self.fh_panel, ('off', 'on'))
self.fh_switch.on_clicked(lambda x: self.update_mask() or self.history_mgr.add_switch_history('fh') or self.display())
# Create component area threshold panel
self.area_panel = self.fig.add_axes(((len(BrushType) + 5) * unit, 0.9 + 0.3 * unit, 3 * unit, 0.3 * unit), facecolor=axcolor)
hide_axes_labels(self.area_panel)
self.area_panel.text(
-0.45, 1.7,
'Filter Small Components by Area',
bbox=dict(
linewidth=1,
edgecolor='goldenrod',
facecolor='none',
alpha=1.0
)
)
self.area_slider = Slider(self.area_panel, '', 0, 100, valinit=0, color=(0, 1, 0, 0.3), valfmt='%0.2f%% of the largest component')
self.on_area_adjust = False
# Create threshold sliders
self.upper_names = ['Upper H', 'Upper S', 'Upper V']
self.lower_names = ['Lower H', 'Lower S', 'Lower V']
self.min_values = np.array([0, 0, 0])
self.max_values = np.array([359, 255, 255])
self.thresh_sliders = {}
self.thresh_slider_panels = []
self.on_thresh_adjust = False
for i in range(3):
lower_slider_ax = self.fig.add_axes((0.25, 0.12 - (2 * i) * 0.018 - i * 0.008, 0.7, 0.01), facecolor=axcolor)
self.thresh_sliders[self.lower_names[i]] = Slider(
lower_slider_ax, self.lower_names[i],
self.min_values[i], self.max_values[i],
valinit=self.min_values[i], color=(0, 1, 0, 0.3),
valfmt='%d'
)
self.thresh_sliders[self.lower_names[i]].valtext.set_text(str(int(self.min_values[i])))
self.thresh_slider_panels.append(lower_slider_ax)
upper_slider_ax = self.fig.add_axes((0.25, 0.12 - (2 * i + 1) * 0.018 - i * 0.008, 0.7, 0.01), facecolor=axcolor)
self.thresh_sliders[self.upper_names[i]] = Slider(
upper_slider_ax, self.upper_names[i],
self.min_values[i], self.max_values[i],
valinit=self.max_values[i], color=(0, 1, 0, 0.3),
valfmt='%d'
)
self.thresh_sliders[self.upper_names[i]].valtext.set_text(str(int(self.max_values[i])))
self.thresh_slider_panels.append(upper_slider_ax)
self.enable_callbacks()
# Create hue-saturation panel
self.hs_panel = self.fig.add_axes((0.008, 0.01, 0.15, 0.15), projection='polar', facecolor=axcolor)
self.hs_plot_mode = HSPlotMode.ALL
self.hs_region_iptr = PolarDragInterpreter()
self.arc_regions = []
self.temp_arc_regions = []
hide_axes_labels(self.hs_panel)
# Create value panel
self.v_panel = self.fig.add_axes((0.16, 0.01, 0.02, 0.15), facecolor=axcolor)
hide_axes_labels(self.v_panel, 'x')
self.plot_hs_range()
self.plot_thresh_regions()
self.display()
self.root.focus_force()
sI1 = Slider(axI1, 'Intensity 1 \n(1e14 W/cm2)', 0, 10, valinit=5)
sI2 = Slider(axI2, 'Intensity 2 \n(1e14 W/cm2)', 0, 10, valinit=5)
stbnum = Slider(axtbnum, 'num tb', 0, 100, valinit=10)
stbmin = Slider(axtbmin, 'tb min\n(fs)', 0, 2.66, valinit=.01)
stbmax = Slider(axtbmax, 'tb max\n(fs)', 0, 2.66, valinit=2.66)
sv0long = Slider(axv0long, 'v0 tunnel dir\n(1e6 m/s)', -10, 10, valinit=0)
sv0tran = Slider(axv0tran, 'v0 transverse dir\n(1e6 m/s)', -10, 10, valinit=0)
stnum = Slider(axtnum, 'Num time steps', 0, 1000, valinit=200)
ststa = Slider(axtsta, 'Start time\n(fs)', 0, 10, valinit=.0001)
stend = Slider(axtend, 'Time duration\n(fs)', 0, 10, valinit=6)
colorbutton = RadioButtons(axcolor, ('Time color', 'Energy color'))
global color_status
color_status = 'Time color'
rotbutton = RadioButtons(axrot, ('Counter rotating', 'Co rotating'))
global rotation
rotation = -1
plt.subplots_adjust(left=0.08, bottom=0.05, right=0.95, top=0.96, hspace=0.14)
###################### Done setting up the figure #####################
global cbar
cbar = ''
###################### This activates everytime something is clicked ###############
def plot_signals(self):
# Create figure
self.fig, self.ax = plt.subplots()
# Load composite signals
self.time, self.signal, self.seis, self.phono = self.composite_peaks.composites[
self.index]
self.first, self.second = hb.get_derivatives(self.signal)
# Plot ECG, Phono and Seismo
self.signal_line, = self.ax.plot(self.signal,
linewidth=1,
c="b",
label="ECG")
self.first_line, = self.ax.plot(range(len(self.signal)),
1 + 5 * self.first,
'--',
linewidth=0.5,
c='magenta',
label="ECG 1st Derv.")
self.second_line, = self.ax.plot(range(len(self.signal)),
1 + 5 * self.second,
'--',
linewidth=0.5,
c='k',
label="ECG 2nd Derv.")
self.seis_line, = self.ax.plot(self.seis,
'--',
linewidth=0.5,
c='r',
label="Seis")
self.phono_line, = self.ax.plot(self.phono,
'--',
linewidth=0.5,
c='g',
label="Phono")
self.ax.set_xlim(0, len(self.signal))
sig_min = min(self.signal)
sig_max = max(self.signal)
self.ax.set_ylim(sig_min - 0.2 * (sig_max - sig_min),
sig_max + 0.2 * (sig_max - sig_min))
plt.legend(loc='upper right')
# T''max Peak
self.ddT_point = self.ax.scatter(
self.composite_peaks.ddT.data[self.index],
self.signal[self.composite_peaks.ddT.data[self.index]],
c='#2ca02c')
self.ddT_text = self.ax.text(
self.composite_peaks.ddT.data[self.index],
self.signal[self.composite_peaks.ddT.data[self.index]] + 0.2,
"T''max",
fontsize=9,
horizontalalignment='center')
# TM Seismo
self.tm_seis_point = self.ax.scatter(
self.composite_peaks.TM_seis.data[self.index],
self.seis[self.composite_peaks.TM_seis.data[self.index]],
c='#9467bd')
self.tm_seis_text = self.ax.text(
self.composite_peaks.TM_seis.data[self.index],
self.seis[self.composite_peaks.TM_seis.data[self.index]] + 0.2,
"TM Seis",
fontsize=9,
horizontalalignment='center')
# TM Phono
self.tm_phono_point = self.ax.scatter(
self.composite_peaks.TM_phono.data[self.index],
self.phono[self.composite_peaks.TM_phono.data[self.index]],
c='#e377c2')
self.tm_phono_text = self.ax.text(
self.composite_peaks.TM_phono.data[self.index],
self.phono[self.composite_peaks.TM_phono.data[self.index]] + 0.2,
"TM Phono",
fontsize=9,
horizontalalignment='center')
# Initalize axes and data points
self.x = range(len(self.signal))
self.y = self.signal
# Cross hairs
self.lx = self.ax.axhline(color='k', linewidth=0.2) # the horiz line
self.ly = self.ax.axvline(color='k', linewidth=0.2) # the vert line
# Add data
left_shift = 0.45
start = 0.96
space = 0.04
self.ax.text(0.01,
start,
transform=self.ax.transAxes,
s="Folder: " + self.folder_name,
fontsize=12,
horizontalalignment='left')
self.ax.text(0.01,
start - space,
transform=self.ax.transAxes,
s="Dosage: " + str(self.dosage),
fontsize=12,
horizontalalignment='left')
self.ax.text(0.01,
start - 2 * space,
transform=self.ax.transAxes,
s="File: " + self.file_name,
fontsize=12,
horizontalalignment='left')
self.ax.text(0.01,
start - 3 * space,
transform=self.ax.transAxes,
s="File #: " + str(self.interval_number),
fontsize=12,
horizontalalignment='left')
self.i_text = self.ax.text(0.60 - left_shift,
1.1 - space,
transform=self.ax.transAxes,
s="Composite: " + str(self.index + 1) +
"/" +
str(len(self.composite_peaks.composites)),
fontsize=12,
horizontalalignment='left')
# Add Intervals
start_left = 0.575
shift_left = 0.10
tm_seis = str(
round(
1 / (self.time[self.composite_peaks.TM_seis.data[self.index]] -
self.time[self.composite_peaks.ddT.data[self.index]]), 2))
tm_phono = str(
round(
1 /
(self.time[self.composite_peaks.TM_phono.data[self.index]] -
self.time[self.composite_peaks.ddT.data[self.index]]), 2))
self.tm_text = self.ax.text(start_left + shift_left,
0.91,
horizontalalignment='center',
transform=self.fig.transFigure,
s="1/(E-M)lusi\nSeis: " + tm_seis + " Hz" +
"\nPhono: " + tm_phono + " Hz")
# Add index buttons
ax_prev = plt.axes([0.575 - left_shift, 0.9, 0.1, 0.075])
self.bprev = Button(ax_prev, 'Previous')
self.bprev.on_clicked(self.prev)
ax_next = plt.axes([0.8 - left_shift, 0.9, 0.1, 0.075])
self.b_next = Button(ax_next, 'Next')
self.b_next.on_clicked(self.next)
self.fig.canvas.mpl_connect('motion_notify_event', self.mouse_move)
# Add Save Button
ax_save = plt.axes([0.8, 0.9, 0.1, 0.075])
self.b_save = Button(ax_save, 'Save')
self.b_save.on_clicked(self.save)
# Add Line buttons
self.ax.text(-0.13,
0.97,
transform=self.ax.transAxes,
s="Snap on to:",
fontsize=12,
horizontalalignment='left')
# left, bottom, width, height
ax_switch_signals = plt.axes([0.02, 0.7, 0.07, 0.15])
self.b_switch_signals = RadioButtons(ax_switch_signals,
('ECG', 'Seismo', 'Phono'))
for c in self.b_switch_signals.circles:
c.set_radius(0.05)
self.b_switch_signals.on_clicked(self.switch_signal)
self.fig.canvas.mpl_connect('button_press_event', self.on_click)
self.fig.canvas.mpl_connect('button_release_event', self.off_click)
# Add Line hide buttons
self.ax.text(1.015,
0.97,
transform=self.ax.transAxes,
s="Hide Signal:",
fontsize=12,
horizontalalignment='left')
ax_hide_signals = plt.axes([0.91, 0.7, 0.08, 0.20])
self.b_hide_signals = CheckButtons(
ax_hide_signals,
('ECG', '1st Derv.', '2nd Derv.', 'Seismo', 'Phono'))
self.b_hide_signals.on_clicked(self.switch_signal)
# Add Sliders
start = 0.91
slider_width = 0.0075
slider_height = 0.47
self.signal_amp_slider = Slider(plt.axes(
[start, 0.15, slider_width, slider_height]),
label="ECG\n\nA",
valmin=0.01,
valmax=10,
valinit=1,
orientation='vertical')
self.signal_amp_slider.label.set_size(8)
self.signal_amp_slider.on_changed(self.switch_signal)
self.signal_amp_slider.valtext.set_visible(False)
self.second_height_slider = Slider(plt.axes(
[start + 2 * slider_width, 0.15, slider_width, slider_height]),
label=" 2nd\n Derv.\nH",
valmin=1.5 * min(self.signal),
valmax=1.5 * max(self.signal),
valinit=0,
orientation='vertical')
self.second_height_slider.label.set_size(8)
self.second_height_slider.on_changed(self.switch_signal)
self.second_height_slider.valtext.set_visible(False)
self.second_amp_slider = Slider(plt.axes(
[start + 3 * slider_width, 0.15, slider_width, slider_height]),
label="\nA",
valmin=0.01,
valmax=10,
valinit=1,
orientation='vertical')
self.second_amp_slider.label.set_size(8)
self.second_amp_slider.on_changed(self.switch_signal)
self.second_amp_slider.valtext.set_visible(False)
self.seis_height_slider = Slider(plt.axes(
[start + 5 * slider_width, 0.15, slider_width, slider_height]),
label=" Seis\n\nH",
valmin=1.5 * min(self.signal),
valmax=1.5 * max(self.signal),
valinit=0,
orientation='vertical')
self.seis_height_slider.label.set_size(8)
self.seis_height_slider.on_changed(self.switch_signal)
self.seis_height_slider.valtext.set_visible(False)
self.seis_amp_slider = Slider(plt.axes(
[start + 6 * slider_width, 0.15, slider_width, slider_height]),
label="\n\nA",
valmin=0.01,
valmax=10,
valinit=1,
orientation='vertical')
self.seis_amp_slider.label.set_size(8)
self.seis_amp_slider.on_changed(self.switch_signal)
self.seis_amp_slider.valtext.set_visible(False)
self.phono_height_slider = Slider(plt.axes(
[start + 8 * slider_width, 0.15, slider_width, slider_height]),
label="\n Phono\nH",
valmin=1.5 * min(self.signal),
valmax=1.5 * max(self.signal),
valinit=0,
orientation='vertical')
self.phono_height_slider.label.set_size(8)
self.phono_height_slider.on_changed(self.switch_signal)
self.phono_height_slider.valtext.set_visible(False)
self.phono_amp_slider = Slider(plt.axes(
[start + 9 * slider_width, 0.15, slider_width, slider_height]),
label="A",
valmin=.01,
valmax=10,
valinit=1,
orientation='vertical')
self.phono_amp_slider.label.set_size(8)
self.phono_amp_slider.on_changed(self.switch_signal)
self.phono_amp_slider.valtext.set_visible(False)
# Maximize frame
mng = plt.get_current_fig_manager()
mng.full_screen_toggle()
plt.show()
ax2.set_xlim(np.min(wave), np.max(wave))
ax2.set_ylim(0, 1.25*np.max(spec))
ax2.set_ylabel('Intensity (' + cal_status + ')')
ax1.clear()
ax1.imshow(scaled, origin='lower', aspect=1/x_scale, cmap='gray')
ax1.scatter([ix], [iy], marker='+')
fig.canvas.draw_idle()
fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10, 8))
fig.canvas.mpl_connect('button_press_event', onclick)
ax1.imshow(scaled, origin='lower', aspect=1/x_scale, cmap='gray')
ax1.set_xlabel('Solar X (pixels)')
ax1.set_ylabel('Solar Y (pixels)')
spectrum, = ax2.step([], [])
ax2.set_xlabel('Wavelength ($\AA$)')
ax2.set_ylabel('Intensity (counts)')
ax = plt.axes([0.05, 0.925, 0.1, 0.05], facecolor=widget_color)
button = Button(ax, 'Quit', color=widget_color)
button.on_clicked(exit_widget)
ax = plt.axes([0.2, 0.925, 0.1, 0.05], facecolor=widget_color)
radio = RadioButtons(ax, ('counts', 'ergs'))
radio.on_clicked(set_cal_status)
plt.show()
#print(inv.transform((335.175, 247.)))
payoutSlider = Slider(plt.axes([subplotLeftness, 0.53, defaultSliderWidth, defaultSliderHeight]), 'Payout', 0.1, 30.0, valinit=5, valstep=5)
prevSliderLeftness = payoutSlider.ax.get_position().get_points().tolist()[0][0]
prevSliderBottomness = payoutSlider.ax.get_position().get_points().tolist()[0][1]
prevSliderWidth = payoutSlider.ax.get_position().get_points().tolist()[1][0]
prevSliderHeight = payoutSlider.ax.get_position().get_points().tolist()[1][1]
betaSlider = Slider(plt.axes([subplotLeftness, prevSliderBottomness-(defaultSliderHeight+0.01), defaultSliderWidth, defaultSliderHeight]), r'$\beta_d$', -2.0, 2.0, valinit=1, valstep=0.001)
prevSliderBottomness = betaSlider.ax.get_position().get_points().tolist()[0][1]
riskFreeSlider = Slider(plt.axes([subplotLeftness, prevSliderBottomness-(defaultSliderHeight+0.01), defaultSliderWidth, defaultSliderHeight]), 'Risk-Free Rate', 0.0, 5.0, valinit=3.00, valstep=0.001)
prevSliderBottomness = riskFreeSlider.ax.get_position().get_points().tolist()[0][1]
marketReturnSlider = Slider(plt.axes([subplotLeftness, prevSliderBottomness-(defaultSliderHeight+0.01), defaultSliderWidth, defaultSliderHeight]), 'Market Return', -18.0, 18.0, valinit=7.00, valstep=0.001)
radio1 = RadioButtons(plt.axes([0.01, 0.653, 0.09, 0.1]), (r'$\beta_d$', r'$\alpha_i$', r'$\Delta_{\theta}$'), active = 0)
def update(val):
payout_currSliderVal = payoutSlider.val
beta_currSliderVal = betaSlider.val
rf_currSliderVal = riskFreeSlider.val
mr_currSliderVal = marketReturnSlider.val
costsOfEquity = (calcCostOfEquity(rf_currSliderVal, beta_currSliderVal, 'MarketReturn', mr_currSliderVal),
calcCostOfEquity(rf_currSliderVal, beta_currSliderVal, 'MarketReturn', mr_currSliderVal))
for x in range(0,len(coordinatesForBarChart.patches)):
coordinatesForBarChart[x].set_height( calcTwoStage_PE(growthRates,(extraordinaryPayoutRatio, payout_currSliderVal), costsOfEquity,durations[x]) )
fig.canvas.draw_idle()
payoutSlider.on_changed(update)
betaSlider.on_changed(update)
def span_plot(fig, axs, lines, tts, dataP):
xs = []
ys = []
for i in range(len(axs)):
xs.append(lines[i].get_xdata())
ys.append(lines[i].get_ydata())
axcolor = 'lightgoldenrodyellow'
rax = plt.axes([0.20, 0.87, 0.10, 0.05], facecolor=axcolor)
radio = RadioButtons(rax, ('HR_CH4_d', 'HP_CH4_d'))
rax2 = plt.axes([0.35, 0.87, 0.10, 0.05], facecolor=axcolor)
radio2 = RadioButtons(rax2, ('HR_dCH4', 'HP_dCH4'))
def CH4func(label):
xb = lines[0].get_xdata()
dataPs = dataP.set_index('Julday')
hzdict = {
'HP_CH4_d': dataPs.HPCH4_d.loc[xb].values,
'HR_CH4_d': dataPs.HRCH4_d.loc[xb].values
}
ydata = hzdict[label]
lines[0].set_ydata(ydata)
plt.draw()
def dCH4func(label):
xb = lines[1].get_xdata()
dataPs = dataP.set_index('Julday')
hzdict = {
'HP_dCH4': dataPs.HPdCH4.loc[xb].values,
'HR_dCH4': dataPs.HRdCH4.loc[xb].values
}
ydata = hzdict[label]
lines[1].set_ydata(ydata)
plt.draw()
radio.on_clicked(CH4func)
radio2.on_clicked(dCH4func)
def fun_select(x2, y2, indmax, indmin):
indmax = min(len(x2) - 1, indmax)
thisx = x2[indmin:indmax]
thisy = y2[indmin:indmax]
if len(thisy) == 0:
s = 'Avg = %.3f\nStd = %.3f' % (-9999.999, -9999.999)
else:
s = 'Avg = %.3f\nStd = %.3f' % (thisy.mean(), thisy.std())
return thisx, thisy, s
history = {'ax0': [], 'ax1': [], 'ax2': [], 'ax3': []}
key_ax = list(history.keys())
def onselect(xmin, xmax):
i = 0
x2 = lines[i].get_xdata()
y2 = lines[i].get_ydata()
indmin, indmax = np.searchsorted(x2, (xmin, xmax))
indmax = min(len(x2) - 1, indmax)
for j in range(len(axs)):
xx = lines[j].get_xdata()
yy = lines[j].get_ydata()
thisx, thisy, s = fun_select(xx, yy, indmax, indmin)
if len(thisx) > 0:
history[key_ax[j]].append([thisx, thisy, s])
lines[j].set_data(thisx, thisy)
miny = np.nanmin(thisy)
maxy = np.nanmax(thisy)
miny = np.nanmax([miny, lim_plot_var[j][0]])
maxy = np.nanmin([maxy, lim_plot_var[j][1]])
if miny > 0:
axs[j].set_ylim(.9 * miny, 1.1 * maxy)
else:
axs[j].set_ylim(1.1 * miny, .9 * maxy)
tts[j].set_text(s)
if len(thisx) > 0:
axs[i].set_xlim(xmin, xmax)
fig.canvas.draw()
def regselect(xmin, xmax):
i = 0
x2 = lines[i].get_xdata()
y2 = lines[i].get_ydata()
indmin, indmax = np.searchsorted(x2, (xmin, xmax))
for j in range(len(axs)):
xx = lines[j].get_xdata()
yy = lines[j].get_ydata()
if len(xx) > 0:
thisx, thisy, s = fun_select(xx, yy, indmax, indmin)
tts[j].set_text(s)
fig.canvas.draw()
span1 = []
span2 = []
for i in range(len(axs)):
span1.append(
SpanSelector(axs[i],
onselect,
'horizontal',
useblit=True,
rectprops=dict(alpha=0.5, facecolor='red'),
minspan=15 / 86400.,
button=1))
span2.append(
SpanSelector(axs[i],
regselect,
'horizontal',
useblit=True,
rectprops=dict(alpha=0.5, facecolor='green'),
minspan=15 / 86400.,
button=2,
span_stays=True))
class Index(object):
def back(self, event):
if len(history[key_ax[0]]) > 1:
for i in range(len(axs)):
del history[key_ax[i]][-1]
xss = history[key_ax[i]][-1][0]
yss = history[key_ax[i]][-1][1]
ss = history[key_ax[i]][-1][2]
lines[i].set_data(xss, yss)
tts[i].set_text(ss)
miny = np.nanmin(yss)
maxy = np.nanmax(yss)
miny = np.nanmax([miny, lim_plot_var[i][0]])
maxy = np.nanmin([maxy, lim_plot_var[i][1]])
if miny > 0:
axs[i].set_ylim(.9 * miny, 1.1 * maxy)
else:
axs[i].set_ylim(1.1 * miny, .9 * maxy)
axs[-1].set_xlim(xss.min(), xss.max())
plt.draw()
else:
for i in range(len(axs)):
axs[i].set_ylim(lim_plot_var[i])
lines[i].set_data(xs[i], ys[i])
s = 'Avg = %.3f\nStd = %.3f' % (np.nanmean(
ys[i]), np.nanstd(ys[i]))
tts[i].set_text(s)
axs[-1].set_xlim(xs[-1].min(), xs[-1].max())
plt.draw()
def reset(self, event):
for i in range(len(axs)):
axs[i].set_ylim(lim_plot_var[i])
lines[i].set_data(xs[i], ys[i])
s = 'Avg = %.3f\nStd = %.3f' % (np.nanmean(
ys[i]), np.nanstd(ys[i]))
history[key_ax[i]].append([xs[i], ys[i], s])
tts[i].set_text(s)
axs[-1].set_xlim(xs[-1].min(), xs[-1].max())
plt.draw()
callback = Index()
axres = plt.axes([0.50, 0.87, 0.1, 0.05])
axbac = plt.axes([0.60, 0.87, 0.1, 0.05])
bnres = Button(axres, 'Reset Plot')
bnbac = Button(axbac, 'Back')
bnres.on_clicked(callback.reset)
bnbac.on_clicked(callback.back)
plt.show()
def __init__(self, df, metrics=None):
# storing and parsing the dataset
self.process_dataset(df)
# setting the dendrogram subplot
self.ax_dendrogram = plt.subplot(111)
plt.subplots_adjust(left=0.1, right=0.95, bottom=0.25, top=0.95)
# setting the 'threshold' slider control
ax_thres = plt.axes([0.02, 0.25, 0.03, 0.7], axisbg=self.ax_back_color)
self.ax_thres = VertSlider(ax_thres, 'Thres', 0.0, 1.0, valinit=0.5)
self.ax_thres.valtext.set_visible(False)
self.ax_thres.on_changed(self.on_ax_thres_changed)
# setting the 'methods' radio control
ax_methods = plt.axes([0.1, 0.01, 0.15, 0.15],
axisbg=self.ax_back_color,
zorder=5)
methods_options = tuple(sorted(self.methods_dict.keys()))
self.ax_methods = RadioButtons(ax_methods, methods_options, active=0)
self.selected_method = list(self.methods_dict)[0]
self.ax_methods.on_clicked(self.on_ax_methods_clicked)
# setting the 'metrics' radio control
if metrics is not None:
self.metrics_dict = {}
# for each metric supplied
for m in metrics:
if m not in measures.measures_list:
raise ValueError('Unknown metric')
# dynamically adding metrics
self.metrics_dict[measures.measures_names[
m]] = measures.measure_to_function[m]
ax_metrics = plt.axes([0.3, 0.01, 0.16, 0.15],
axisbg=self.ax_back_color,
zorder=4)
metrics_options = tuple(sorted(self.metrics_dict.keys()))
self.ax_metrics = RadioButtons(ax_metrics,
metrics_options,
active=0,
activecolor='blue')
self.selected_metric = list(self.metrics_dict)[0]
self.ax_metrics.on_clicked(self.on_ax_metrics_clicked)
# adding visualization options
ax_options = plt.axes([0.51, 0.01, 0.26, 0.15],
axisbg=self.ax_back_color)
opt_labels = ('Show labels', 'Show annotations')
opt_vals = (False, ) * len(opt_labels)
self.ax_options = CheckButtons(ax_options, opt_labels, opt_vals)
self.ax_options.on_clicked(self.on_ax_options_clicked)
# adding the button that actually performs clustering
btn_width = 0.14
ax_go_button = plt.axes(
[0.95 - btn_width, 0.09, btn_width, 0.5 * btn_width])
self.ax_go_button = Button(ax_go_button,
'Go!!!',
color=self.ax_back_color,
hovercolor='0.911')
self.ax_go_button.on_clicked(self.on_ax_go_button_clicked)
# adding the button that saves the results
ax_save_button = plt.axes(
[0.95 - btn_width, 0.01, btn_width, 0.5 * btn_width])
self.ax_save_button = Button(ax_save_button,
'Save!!!',
color=self.ax_back_color,
hovercolor='0.911')
self.ax_save_button.on_clicked(self.on_ax_save_button_clicked)
global lims_flag
if lims_flag:
mainax.axis(lims)
else:
mainax.set_aspect('equal')
lims_flag = True
plt.draw()
# set the callback
#sfreq.on_changed(update)
sliderCount.on_changed(update)
rax = plt.axes([0.025, 0.5, 0.15, 0.15], axisbg=axcolor)
radio = RadioButtons(rax, ('allpoints', 'incremental'), active=1)
def setswitch(label):
global switch
#print label == 'allpoints', label == 'incremental'
if label == 'allpoints':
switch = SHOWALL
elif label == 'incremental':
switch = INCREMENTAL
#print switch
update(None)
radio.on_clicked(setswitch)
def __init__(self, Egg):
# =============================================================================
# Initialize Egg
# =============================================================================
self.Egg = Egg
# =============================================================================
# Initialize Figure and Main Axis
# =============================================================================
self.figure = plt.figure(num=self.Egg.EGG_figure_Name +
" Control Panel",
figsize=[5.5, 8],
clear=True)
self.main_ax = self.figure.add_axes([0, 0, 1, 1],
label="main_ax",
facecolor='white')
self.main_ax.tick_params(
axis='x', # changes apply to the x-axis
which='both', # both major and minor ticks are affected
bottom=False, # ticks along the bottom edge are off
top=False, # ticks along the top edge are off
left=False,
right=False,
labelbottom=False) # labels along the bottom edge are off
self.main_ax.tick_params(
axis='y', # changes apply to the x-axis
which='both', # both major and minor ticks are affected
left=False,
right=False,
labelleft=False) # labels along the bottom edge are off
self.main_ax.margins(x=0)
self.main_ax.set_xlim([0, 1])
self.main_ax.set_ylim([0, 1])
# =============================================================================
# Create Buttons
# =============================================================================
Button_width = .2
Button_height = .06
Edge_width = 0.05
Button_spacing = 0.03
Top_gap = 0
Bottom_Gap = .5
Left_gap = 0
Right_gap = 0
Button_count = 0
Button_Box = patches.Rectangle(
(Edge_width / 2, Edge_width + Bottom_Gap), 1 - Edge_width,
1 - Bottom_Gap - 1.5 * Edge_width)
# Button_Box = patches.Rectangle((0.15, 0.5), .25, .25)
self.main_ax.add_patch(Button_Box)
max_buttons_per_column = (int)(math.floor(
(1 + Button_spacing - 2 * Edge_width - Top_gap - Bottom_Gap) /
(Button_height + Button_spacing)))
max_buttons_per_row = (int)(math.floor(
(1 + Button_spacing - 2 * Edge_width - Left_gap - Right_gap) /
(Button_width + Button_spacing)))
def Button_params():
column_number = math.floor(Button_count / max_buttons_per_column)
row_number = Button_count - max_buttons_per_column * column_number
left = Edge_width + Left_gap + (
(Button_width + Button_spacing) * column_number)
bottom = 1 - Edge_width - Top_gap - Button_height - (
Button_height + Button_spacing) * row_number
if Button_count > max_buttons_per_column * max_buttons_per_row:
raise Exception("TOO MANY BUTTONS!!!")
return [left, bottom, Button_width, Button_height]
self.Reset_Button_ax = self.figure.add_axes(Button_params(),
label="Reset_Button_ax",
facecolor='white')
Button_count += 1
self.Reset_Button = Button(
self.Reset_Button_ax,
label="Reset",
)
self.Reset_Button.on_clicked(self.Egg.Reset_GUI(Reset_Tone=True))
self.Play_Button_ax = self.figure.add_axes(Button_params(),
label="Play_Button_ax",
facecolor='white')
Button_count += 1
self.Play_Button = Button(
self.Play_Button_ax,
label="Play",
)
self.Play_Button.on_clicked(self.Egg.Play)
self.Loop_Button_ax = self.figure.add_axes(Button_params(),
label="Loop_Button_ax",
facecolor='white')
Button_count += 1
self.Loop_Button = Button(
self.Loop_Button_ax,
label="Loop",
)
self.Loop_Button.on_clicked(self.Egg.Loop)
self.Stop_Button_ax = self.figure.add_axes(Button_params(),
label="Stop_Button_ax",
facecolor='white')
Button_count += 1
self.Stop_Button = Button(
self.Stop_Button_ax,
label="Stop",
)
self.Stop_Button.on_clicked(self.Egg.Stop)
# =============================================================================
# Create Misc. Box
# =============================================================================
Misc_Box = patches.Rectangle((Edge_width / 2, Edge_width / 2),
1 - Edge_width,
Bottom_Gap,
color='g')
self.main_ax.add_patch(Misc_Box)
self.Plot_Toggle_ax = self.figure.add_axes(
[Edge_width, Edge_width, .25, .18],
label="Plot_Toggle_ax",
facecolor='white')
self.Plot_Toggle = CheckButtons(ax=self.Plot_Toggle_ax,
labels=[
"Plot Wave", "Plot Savgol",
"Plot Linear", "Plot Selectors"
],
actives=[True, True, True, True])
def Update_Plot_Toggle(val):
Toggle_Bools = self.Plot_Toggle.get_status()
self.Egg.Plot_Wave = Toggle_Bools[0]
self.Egg.Plot_Savgol = Toggle_Bools[1]
self.Egg.Plot_Linear = Toggle_Bools[2]
self.Egg.Plot_Selectors = Toggle_Bools[3]
self.Egg.Update_Canvas()(0)
self.Plot_Toggle.on_clicked(Update_Plot_Toggle)
self.Savgol_Mode_Select_ax = self.figure.add_axes(
[Edge_width, Edge_width + .25, .25, .18],
label="Savgol_Mode_Select_ax",
facecolor='white')
self.Savgol_Mode_Select = RadioButtons(self.Savgol_Mode_Select_ax,
labels=[
"wrap",
"mirror",
"nearest",
"constant",
])
def Update_Savgol_Mode_Select(val):
active_mode = self.Savgol_Mode_Select.value_selected
self.Egg.Update_Savgol_Mode(active_mode)
self.Savgol_Mode_Select.on_clicked(Update_Savgol_Mode_Select)
def print_who_speak_next(time_speak, names):
"""
Affiche un graphique permettant de changer les parametre de who speak next et d'observer le parametre
:param time_speak: la liste des persoones qui parles
:param names: le nom des personnes dans la conversation
"""
fig, ax = plt.subplots()
plt.subplots_adjust(right=0.8, bottom=0.5)
val = 0
wsms = list()
xvalues = list()
while val < time_speak[-1][1][1]:
wsms.append(
who_speak_next_matrix(time_speak, len(names), (val, val + 200)))
xvalues.append(val)
val += 200
yvalues = list()
for wsm in wsms:
yvalues.append(wsm[0, 1])
ax.bar(xvalues, yvalues, 180)
axcolor = 'lightgoldenrodyellow'
axframe = plt.axes([0.2, 0.3, 0.5, 0.05], facecolor=axcolor)
axminrng = plt.axes([0.2, 0.2, 0.5, 0.05], facecolor=axcolor)
axmaxrng = plt.axes([0.2, 0.1, 0.5, 0.05], facecolor=axcolor)
axlabel1 = plt.axes([0.85, 0.7, 0.1, 0.15])
axLabel2 = plt.axes([0.85, 0.5, 0.1, 0.15])
axcheck = plt.axes([0.85, 0.3, 0.15, 0.15])
sframe = Slider(axframe, 'size window', 0.1, 500, valinit=200, valstep=0.1)
sminrng = Slider(axminrng,
'Minimum',
0,
time_speak[-1][1][1],
valinit=0,
valstep=1)
smaxrng = Slider(axmaxrng,
'Maximum',
0,
time_speak[-1][1][1],
valinit=time_speak[-1][1][1],
valstep=1)
rad1 = RadioButtons(axlabel1, names)
rad2 = RadioButtons(axLabel2, names, active=1)
pourcent = CheckButtons(axcheck, ['Pourcentage'])
def updateWsms(label):
val = sminrng.val
wsms.clear()
xvalues.clear()
while val < smaxrng.val:
wsms.append(
who_speak_next_matrix(
time_speak,
len(names), (val, val + sframe.val),
pourcentage=pourcent.lines[0][0].get_visible()))
xvalues.append(val)
val += sframe.val
update(rad1.value_selected, rad2.value_selected)
def updateLabel1(label):
update(label, rad2.value_selected)
def updateLabel2(label):
update(rad1.value_selected, label)
def update(label1, label2):
yvalues = list()
for wsm in wsms:
yvalues.append(wsm[names.index(label1), names.index(label2)])
ax.clear()
ax.bar(xvalues, yvalues, sframe.val - 2 / 10 * sframe.val)
fig.canvas.draw_idle()
sframe.on_changed(updateWsms)
sminrng.on_changed(updateWsms)
smaxrng.on_changed(updateWsms)
rad1.on_clicked(updateLabel1)
rad2.on_clicked(updateLabel2)
pourcent.on_clicked(updateWsms)
plt.show()
def __init__(self, fig, ax, img_dir, classes, model_path, json_file):
self.RS = RectangleSelector(ax, self.line_select_callback,
drawtype='box', useblit=True,
button=[1, 3], # don't use middle button
minspanx=5, minspany=5,
spancoords='pixels',
interactive=True)
ax.set_yticklabels([])
ax.set_xticklabels([])
#self.classes, self.img_paths, _ = read_JSON_file(json_file)
with open(classes, 'r') as f:
self.classes, img_paths = sorted([x.strip().split(',')[0] for x in f.readlines()]), glob.glob(os.path.abspath(os.path.join(img_dir, '*.jpg')))
plt.tight_layout()
self.ax = ax
self.fig = fig
self.axradio = plt.axes([0.0, 0.0, 0.1, 1])
self.radio = RadioButtons(self.axradio, self.classes)
self.zoom_scale = 1.2
self.zoom_id = self.fig.canvas.mpl_connect('scroll_event', self.zoom)
self.keyboard_id = self.fig.canvas.mpl_connect('key_press_event', self.onkeyboard)
self.selected_poly = False
self.axsave = plt.axes([0.81, 0.05, 0.1, 0.05])
self.b_save = Button(self.axsave, 'Save')
self.b_save.on_clicked(self.save)
self.objects, self.existing_patches, self.existing_rects = [], [], []
self.num_pred = 0
if json_file is None:
self.images, self.annotations = [], []
self.index = 0
self.ann_id = 0
else:
with open(json_file, 'r') as g:
d = json.loads(g.read())
self.images, self.annotations = d['images'], d['annotations']
self.index = len(self.images)
self.ann_id = len(self.annotations)
print (self.index)
prev_files = [x['file_name'] for x in self.images]
for i, f in enumerate(img_paths):
im = Image.open(f)
width, height = im.size
dic = {'file_name': f, 'id': self.index+i, 'height': height, 'width': width}
if f not in prev_files:
self.images.append(dic)
else:
self.index+=1
image = plt.imread(self.images[self.index]['file_name'])
self.ax.imshow(image, aspect='auto')
if not args['no_feedback']:
sys.path.append(args['maskrcnn_dir'])
from config import Config
import model as modellib
from skimage.measure import find_contours
from visualize_cv2 import random_colors
class InstanceConfig(Config):
NAME = os.path.basename(model_path)
GPU_COUNT = 1
IMAGES_PER_GPU = 1
NUM_CLASSES = 22 + 1
IMAGE_SHAPE = np.array([Config.IMAGE_MIN_DIM, Config.IMAGE_MIN_DIM, 3])
self.config = InstanceConfig()
plt.connect('draw_event', self.persist)
# Create model object in inference mode.
self.model = modellib.MaskRCNN(mode="inference", model_dir='/'.join(args['weights_path'].split('/')[:-2]), config=self.config)
# Load weights trained on MS-COCO
self.model.load_weights(args['weights_path'], by_name=True)
r = self.model.detect([image], verbose=0)[0]
# Number of instances
N = r['rois'].shape[0]
masks = r['masks']
# Show area outside image boundaries.
height, width = image.shape[:2]
class_ids, scores, rois = r['class_ids'], r['scores'], r['rois'],
for i in range(N):
# Label
class_id = class_ids[i]
score = scores[i] if scores is not None else None
label = self.classes[class_id-1]
pat = patches.Rectangle((rois[i][1], rois[i][0]), rois[i][3]-rois[i][1], rois[i][2]-rois[i][0], linewidth=1, edgecolor='r',facecolor='r', alpha=0.4)
rect = self.ax.add_patch(pat)
self.objects.append(label)
self.existing_patches.append(pat.get_bbox().get_points())
self.existing_rects.append(pat)
self.num_pred = len(self.objects)
fig.canvas.draw_idle()
sSg.on_changed(update)
swg.on_changed(update)
sS1.on_changed(update)
sw1.on_changed(update)
sQ1.on_changed(update)
sS2.on_changed(update)
sw2.on_changed(update)
sQ2.on_changed(update)
rax = plt.axes([0.025, 0.5, 0.15, 0.15], facecolor=axcolor)
radio = RadioButtons(rax, ('Single', 'Binary'), active=0)
def binary(label):
if (label == 'Binary'):
bin = 1
Sg0 = -15.9
wg0 = 6.
S10 = -13.9
w10 = 6.5
Q10 = 1.2
S20 = -9.9
w20 = 6.3
Q20 = 1.4
meta_df = pd.DataFrame(meta_frame)
meta_df.sort_index()
meta_df.to_csv(csv_name)
print('FILE WRITTEN')
def close(event):
plt.close('all')
quit
cid = fig.canvas.mpl_connect('button_press_event', onclick_ax)
'''RADIO BUTTONS'''
axcolor = 'lightgoldenrodyellow'
rax = plt.axes([0.05, 0.7, 0.15, 0.15], facecolor=axcolor)
radio = RadioButtons(rax, ('10%', '40%', '80%', '100%'))
radio.on_clicked(set_hz_flag)
choose1 = plt.axes([0.06, 0.50, 0.15, 0.03])
choose_button1 = Button(choose1, 'File \n Select')
choose_button1.on_clicked(choose_transmitter)
move_to_frame = plt.axes([0.06, 0.46, 0.15, 0.03])
move_to_frame_button = Button(move_to_frame, 'mv_to_frm')
move_to_frame_button.on_clicked(move_to_frame_func)
write_csv = plt.axes([0.06, 0.42, 0.15, 0.03])
write_csv_button = Button(write_csv, 'Write \n CSV')
write_csv_button.on_clicked(write_csv_func)
runB = plt.axes([0.06, 0.38, 0.15, 0.03])
sxamp = Slider(xamp, 'A', 0, 3, valinit=A)
syamp = Slider(yamp, 'B', 0, 3, valinit=B)
sxfreq = Slider(xfreq, 'a', 0, 4, valinit=a)
syfreq = Slider(yfreq, 'c', 0, 4, valinit=c)
sxphase = Slider(xphase, 'b', 0, 7, valinit=b)
syphase = Slider(yphase, 'd', 0, 7, valinit=d)
sphase_diff = Slider(phase_diff, 'Rotate', 0, 3, valinit=r)
#Text in window
plt.text(0.40, -0.90, 'controlers', fontsize=14)
#Radio button for graphs
radio = RadioButtons(
rax, ('(0,0)', 'y=0', 'x=0', 'y=x(/)', 'y=-x(\)', 'y=x^2(∪)', 'y=-x^2(∩)',
'x=y^2(⊂)', 'x=-y^2(⊃)', 'x^2+y^2=1(o)', 'Eight(8)', 'Infinity(∞)',
'N', 'И', 'Z', 'S', 'Alpha(∝)', 'Mirror of ∝', 'Gujarati four',
'Mirror of Gujarati four', 'Rotation(∪,∩)3D', 'Rotation(⊂,⊃)3D',
'Rotation(N,И)3D', 'Rotation(Z,S)3D', 'Bangles_X', 'Bangles_Y',
'Crown_X', 'Crown_Y', 'Atom'),
active=3)
#animation function
def animate(i):
#not creating exctra variable using global variables
global A
global B
global a
global b
global c
global d
global r
def __init__(self):
# initialise the 5 plots
plt.figure('Distribution Explorer', figsize=(12, 7))
self.name = 'Weibull' # starting value
dist = Weibull_Distribution(alpha=100, beta=2, gamma=0)
plt.suptitle(dist.param_title_long, fontsize=15)
self.ax_pdf = plt.subplot(231)
dist.PDF()
plt.title('PDF')
plt.xlabel('')
plt.ylabel('')
self.ax_cdf = plt.subplot(232)
dist.CDF()
plt.title('CDF')
plt.xlabel('')
plt.ylabel('')
self.ax_sf = plt.subplot(233)
dist.SF()
plt.title('SF')
plt.xlabel('')
plt.ylabel('')
self.ax_hf = plt.subplot(234)
dist.HF()
plt.title('HF')
plt.xlabel('')
plt.ylabel('')
self.ax_chf = plt.subplot(235)
dist.CHF()
plt.title('CHF')
plt.xlabel('')
plt.ylabel('')
plt.subplots_adjust(left=0.07,
right=0.98,
top=0.9,
bottom=0.25,
wspace=0.18,
hspace=0.30)
# initialise the sliders
x0 = 0.1
width = 0.8
height = 0.03
self.active_color = 'steelblue'
self.background_color = 'whitesmoke'
self.ax0 = plt.axes([x0, 0.15, width, height],
facecolor=self.background_color)
self.ax1 = plt.axes([x0, 0.1, width, height],
facecolor=self.background_color)
self.ax2 = plt.axes([x0, 0.05, width, height],
facecolor=self.background_color)
self.s0 = Slider(self.ax0,
'Alpha',
valmin=0.1,
valmax=500,
valinit=dist.alpha,
facecolor=self.active_color)
self.s1 = Slider(self.ax1,
'Beta',
valmin=0.2,
valmax=25,
valinit=dist.beta,
facecolor=self.active_color)
self.s2 = Slider(self.ax2,
'Gamma',
valmin=0,
valmax=500,
valinit=dist.gamma,
facecolor=self.active_color)
plt.subplots_adjust(left=0.07,
right=0.98,
top=0.9,
bottom=0.25,
wspace=0.18,
hspace=0.30)
# initialise the radio button
radio_ax = plt.axes([0.708, 0.25, 0.27, 0.28],
facecolor=self.background_color)
radio_ax.set_title('Distribution')
self.radio = RadioButtons(
radio_ax, ('Weibull', 'Gamma', 'Normal', 'Lognormal', 'Beta',
'Exponential', 'Loglogistic', 'Gumbel'),
active=0,
activecolor=self.active_color)
# begin the interactive section
distribution_explorer.__interactive(self, initial_run=True)
ibutton_add = Button(axes_ibutton_add, 'Изометрическая')
ibutton_add.on_clicked(iButton)
def oButton(event):
ax.view_init(-2, -36)
plt.draw()
axes_obutton_add = plt.axes([0.06, 0.05, 0.4, 0.075])
obutton_add = Button(axes_obutton_add, 'Ортографическая')
obutton_add.on_clicked(oButton)
lines_visibility = plt.axes([0.02, 0.85, 0.37, 0.11],
facecolor='lavenderblush')
radio = RadioButtons(lines_visibility,
('Каркасная отрисовка', 'Убрать видимые линии'))
def lines(a):
condition = {'Каркасная отрисовка': 0.20, 'Убрать видимые линии': 1}
alpha = condition[a]
ax.add_collection3d(
Poly3DCollection(verts,
facecolors='pink',
linewidths=1,
edgecolors='purple',
alpha=alpha))
plt.draw()
radio.on_clicked(lines)
Tb_slider = Slider(ax_tb, 'T (K)', 10000, 30000, valinit = 15000)
Ta_slider = Slider(ax_ta, 'T (K)', 7500, 10000, valinit = 8000)
Tg_slider = Slider(ax_tg, 'T (K)', 5200, 6000, valinit = 5500)
Tm_slider = Slider(ax_tm, 'T (K)', 2400, 3700, valinit = 3000)
ax_dust = plot.axes([slider_x, slider_y - 6.0 * slider_separation, slider_length, slider_height])
dust_slider = Slider(ax_dust, 'Dust', -1, 2.0, valinit = 0)
# Radio Buttons
radio_length = 0.10
radio_height = 0.10
radio_separation = 0.12
ax_y = plot.axes([0.05, slider_y + slider_height - radio_height, radio_length, radio_height])
radio_y = RadioButtons(ax_y, ('linear', 'log'), active = 0)
ax_norm = plot.axes([0.05, slider_y + slider_height - radio_height - radio_separation, radio_length + 0.10, radio_height])
radio_norm = RadioButtons(ax_norm, ('normalize blue', 'normalize red'), active = 0)
def update(val):
num_b = b_slider.val; num_a = a_slider.val; num_g = g_slider.val; num_m = m_slider.val
temp_b = Tb_slider.val; temp_a = Ta_slider.val; temp_g = Tg_slider.val; temp_m = Tm_slider.val
dust_Av = dust_slider.val
include_b = 1; include_a = 1; include_g = 1; include_m = 1
if num_b < 0:
include_b = 0
if num_a < 0:
def __init__(self, fig, ax, args):
self.ax = ax
self.ax.set_yticklabels([])
self.ax.set_xticklabels([])
self.img_dir = args['image_dir']
self.index = 0
self.fig = fig
self.polys = []
self.zoom_scale, self.points, self.prev, self.submit_p, self.lines, self.circles = 1.2, [], None, None, [], []
self.zoom_id = fig.canvas.mpl_connect('scroll_event', self.zoom)
self.click_id = fig.canvas.mpl_connect('button_press_event',
self.onclick)
self.clickrel_id = fig.canvas.mpl_connect('button_release_event',
self.onclick_release)
self.keyboard_id = fig.canvas.mpl_connect('key_press_event',
self.onkeyboard)
self.axradio = plt.axes([0.0, 0.0, 0.2, 1])
self.axbringprev = plt.axes([0.3, 0.05, 0.17, 0.05])
self.axreset = plt.axes([0.48, 0.05, 0.1, 0.05])
self.axsubmit = plt.axes([0.59, 0.05, 0.1, 0.05])
self.axprev = plt.axes([0.7, 0.05, 0.1, 0.05])
self.axnext = plt.axes([0.81, 0.05, 0.1, 0.05])
self.b_bringprev = Button(self.axbringprev,
'Bring Previous Annotations')
self.b_bringprev.on_clicked(self.bring_prev)
self.b_reset = Button(self.axreset, 'Reset')
self.b_reset.on_clicked(self.reset)
self.b_submit = Button(self.axsubmit, 'Submit')
self.b_submit.on_clicked(self.submit)
self.b_next = Button(self.axnext, 'Next')
self.b_next.on_clicked(self.next)
self.b_prev = Button(self.axprev, 'Prev')
self.b_prev.on_clicked(self.previous)
self.button_axes = [
self.axbringprev, self.axreset, self.axsubmit, self.axprev,
self.axnext, self.axradio
]
self.existing_polys = []
self.existing_patches = []
self.selected_poly = False
self.objects = []
self.feedback = args['feedback']
self.right_click = False
self.text = ''
with open(args['class_file'], 'r') as f:
self.class_names = [
x.strip() for x in f.readlines() if x.strip() != ""
]
self.radio = RadioButtons(self.axradio, self.class_names)
self.class_names = ('BG', ) + tuple(self.class_names)
self.img_paths = sorted(glob.glob(os.path.join(self.img_dir, '*.jpg')))
if len(self.img_paths) == 0:
self.img_paths = sorted(
glob.glob(os.path.join(self.img_dir, '*.png')))
if os.path.exists(self.img_paths[self.index][:-3] + 'txt'):
self.index = len(glob.glob(os.path.join(self.img_dir, '*.txt')))
self.checkpoint = self.index
try:
im = Image.open(self.img_paths[self.index])
except IndexError:
print(
"Reached end of dataset! Delete some TXT files if you want to relabel some images in the folder"
)
exit()
width, height = im.size
im.close()
image = plt.imread(self.img_paths[self.index])
if args['feedback']:
from mask_rcnn import model as modellib
from mask_rcnn.get_json_config import get_demo_config
#from skimage.measure import find_contours
from .contours import find_contours
from mask_rcnn.visualize_cv2 import random_colors
config = get_demo_config(len(self.class_names) - 2, True)
if args['config_path'] is not None:
config.from_json(args['config_path'])
# Create model object in inference mode.
model = modellib.MaskRCNN(
mode="inference",
model_dir='/'.join(args['weights_path'].split('/')[:-2]),
config=config)
# Load weights trained on MS-COCO
model.load_weights(args['weights_path'], by_name=True)
r = model.detect([image], verbose=0)[0]
# Number of instances
N = r['rois'].shape[0]
masks = r['masks']
# Generate random colors
colors = random_colors(N)
# Show area outside image boundaries.
height, width = image.shape[:2]
class_ids, scores = r['class_ids'], r['scores']
for i in range(N):
color = colors[i]
# Label
class_id = class_ids[i]
score = scores[i] if scores is not None else None
label = self.class_names[class_id]
# Mask
mask = masks[:, :, i]
# Mask Polygon
# Pad to ensure proper polygons for masks that touch image edges.
padded_mask = np.zeros((mask.shape[0] + 2, mask.shape[1] + 2),
dtype=np.uint8)
padded_mask[1:-1, 1:-1] = mask
contours = find_contours(padded_mask, 0.5)
for verts in contours:
# Subtract the padding and flip (y, x) to (x, y)
verts = np.fliplr(verts) - 1
pat = PatchCollection([Polygon(verts, closed=True)],
facecolor='green',
linewidths=0,
alpha=0.6)
self.ax.add_collection(pat)
self.objects.append(label)
self.existing_patches.append(pat)
self.existing_polys.append(
Polygon(verts,
closed=True,
alpha=0.25,
facecolor='red'))
self.ax.imshow(image, aspect='auto')
self.text += str(self.index) + '\n' + os.path.abspath(self.img_paths[
self.index]) + '\n' + str(width) + ' ' + str(height) + '\n\n'
ax1.axis(lim)
ax2 = pyplot.subplot(2, 1, 2)
l2 = ax2.scatter(onoff[1], onoff[0])
ax2.grid()
ax2.axis(lim2)
cbUpdate = doUpdate()
axUpdate = pyplot.axes([0.90, 0.20, 0.1, 0.05])
bUpdate = Button(axUpdate, 'Update')
bUpdate.on_clicked(cbUpdate.update)
cbDump = doDump()
axDump = pyplot.axes([0.90, 0.70, 0.1, 0.05])
bDump = Button(axDump, 'Dump')
bDump.on_clicked(cbDump.dump)
rAx = pyplot.axes([0.90, 0.77, 0.1, 0.10])
#radio = RadioButtons(rAx, ('None', 'Fast', 'Slow', 'Strt'))
radio = RadioButtons(rAx, tuple(SIGNALS.keys()))
def radiofunc(strSignal):
global SignalType
SignalType = strSignal
radio.on_clicked(radiofunc)
pyplot.show()
x, y = get_xydata(data, 0, c0, 10**d0, 10**s0)
scat = plt.scatter(x, y, s=1)
axcolor = 'lightgoldenrodyellow'
#axstart = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)
#axdens = plt.axes([0.25, 0.15, 0.65, 0.03], facecolor=axcolor)
axstart = plt.axes([0.25, 0.1, 0.65, 0.03])
axdens = plt.axes([0.25, 0.15, 0.65, 0.03])
height = (len(parnames) - 1) * 0.05
#rax = plt.axes([0.025, 0.5-height/2, 0.1, height], facecolor=axcolor)
rax = plt.axes([0.025, 0.5 - height / 2, 0.1, height])
resetax = plt.axes([0.8, 0.025, 0.1, 0.04])
ilogS = (math.log10(N * dSdN))
ilogSamps = int(math.log10(N))
print("ilogS=", ilogS)
sstart = Slider(axstart, 'log-Start', 2, ilogS, valinit=s0)
sdens = Slider(axdens, 'log-Density', 1, ilogSamps, valinit=d0)
radio = RadioButtons(rax, parnames[1:], active=0)
for circle in radio.circles: # adjust radius here. The default is 0.05
circle.set_radius(0.03)
button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
sstart.on_changed(update)
sdens.on_changed(update)
radio.on_clicked(update)
button.on_clicked(reset)
plt.show()
a_s = alpha_0*np.ones(2)
a_em = phi_0*np.ones(2)
r = np.arange(2)
plt.polar(np.pi*np.ones(2),r,'k')
l_s, = plt.polar(a_s,r,'r:')
l_em, = plt.polar(a_em,r,'b')
plt.ylim(0,1)
plt.yticks(np.linspace(0,1,5),[])
axcolor = 'lightgoldenrodyellow'
axlf = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)
slf = Slider(axlf, '$\lambda/\Lambda$', 0, 2, valinit=lamfr_0)
rax = plt.axes([0.025, 0.5, 0.15, 0.15], facecolor=axcolor)
radio = RadioButtons(rax, ('+', '-'), active=0)
# The red line shows acoustic wave directed towards origin
# The blue line shows scattered EM wave directed from origin
def update(val):
pm_s = radio.value_selected
pm = 1
if(pm_s is '-'):
pm = -1
lamfr = slf.val
alpha = np.arccos(-pm*lamfr/2)
phi = 2*np.arctan(pm*np.sqrt(lamfr**2/4/(1-lamfr**2/4+eps))) + np.pi*(1-pm)
l_s.set_xdata((np.pi+alpha)*np.ones(2))
l_em.set_xdata(phi*np.ones(2))
fig.canvas.draw_idle()
def radio2(val):
"""Select between showing both, +ve, -ve or none for second h(r)"""
args.choice[1] = val
replot()
radio = [radio1, radio2]
ax_choice = [None, None]
ax_choice[0] = plt.axes([0.05, 0.42, 0.1, 0.15])
ax_choice[1] = plt.axes([0.05, 0.25, 0.1, 0.15])
choice = [None, None]
for i in [0, 1]:
choice[i] = RadioButtons(ax_choice[i], ('none', '+ve', '-ve', 'both'),
active=3)
choice[i].on_clicked(radio[i])
for i, (w00, w01, w11, color, text) in enumerate(selector(args.swap)):
[label.set_color(color) for label in choice[i].labels]
def swap(event):
"""swap between (hnn, hzz) and (h00, h01) representations"""
args.swap = not args.swap
for i, (w00, w01, w11, color, text) in enumerate(selector(args.swap)):
[line[2 * i + j].set_color(color) for j in [0, 1]]
label[i].set_color(color)
label[i].set_text(text)
[label.set_color(color) for label in choice[i].labels]
replot()
def draw_point_rod_2D(vals, vals_min, fig_title=''):
fig_2D, ax_2D = plt.subplots(num=fig_title, figsize=(11, 7))
fig_2D.subplots_adjust(left=0.13, bottom=0.15, right=0.99,
top=0.99) #0.86 x 0.86
img = ax_2D.imshow(vals['md'][0],
extent=[zmin, zmax, rmin, rmax],
vmin=vals_min,
vmax=-vals_min,
origin="lower",
interpolation='bilinear',
cmap=img_cmap)
model_patches = draw_models(ax_2D)
ax_2D.set_xlabel(r'$z$', **axis_font)
ax_2D.set_ylabel(r'$r$', **axis_font)
ax_2D.axis([zmin, zmax, rmin, rmax])
phi_slider_axes = fig_2D.add_axes([0.41, 0.02, 0.35, 0.03],
facecolor=widget_color)
phi_slider = Slider(phi_slider_axes,
r'$\phi$',
0,
theta_points - 1,
valinit=zero_theta,
valstep=1,
valfmt='%1.1f deg')
data_chooser_axes = fig_2D.add_axes([0.03, 0.55, 0.05, 0.1],
facecolor=widget_color)
data_chooser = RadioButtons(data_chooser_axes, vals.keys())
mc_scale_slider_axes = fig_2D.add_axes([0.04, 0.10, 0.03, 0.35],
facecolor=widget_color)
mc_scale_slider = VertSlider(mc_scale_slider_axes,
r'MC scaling',
0.0,
-vals_min,
valinit=-vals_min / 2)
def update_img(_):
curr_phi_index = int(phi_slider.val)
curr_phi_val = thetas[curr_phi_index]
phi_slider.valtext.set_text(phi_slider.valfmt %
(np.rad2deg(curr_phi_val)))
curr_data = data_chooser.value_selected
if curr_data == 'md':
to_plot = vals['md']
else:
to_plot = vals['mc'] * (2.0 / -vals_min) * mc_scale_slider.val
if curr_data == 'diff':
to_plot = vals['md'] - to_plot
draw_models(ax_2D, phi=curr_phi_val, old=model_patches)
img.set_data(to_plot[curr_phi_index])
fig_2D.canvas.draw_idle()
phi_slider.on_changed(update_img)
data_chooser.on_clicked(update_img)
mc_scale_slider.on_changed(update_img)
return phi_slider, data_chooser, mc_scale_slider
wns, modes = ['bior4.4', 'db8', 'sym8', 'coif8'], ['hard', 'soft', 'garrote']
wn, mode = wns[0], modes[0]
# Shrinkage... Live!
def display():
global S, wn, L, h, Th
dft = wc_op(S, wn, L, h, Th)
plt.subplot(1, 1, 1)
plt.cla()
plt.xticks([]); plt.yticks([])
plt.title(f'{wn} @ λ = {h}')
_ = plt.plot(S, color ='gray', marker = '.', markersize = 1, linewidth = 0), plt.plot(dft, 'k', s, 'r'), plt.show()
def thresh_live(λ):
global h; h = λ
display()
def family_live(_wn):
global wn; wn = _wn
display()
def mode_live(_mode):
global Th, mode;
mode = _mode; Th = lambda x, h: thrsd(x, h, mode = mode)
display()
fig, _ = plt.subplots(); plt.subplots_adjust(left = .1, bottom = .16)
axTh, axWn, axM = plt.axes([.57, .01, .33, .03]), plt.axes([.1, .01, .3, .12]), plt.axes([.31, .01, .15, .12])
slTh = Slider(axTh, 'λ = ', 0.0, np.ceil(2*sh), valinit = sh, valstep = 0.03125 * sh)
rbWn = RadioButtons(axWn, wns, active = 0); rbM = RadioButtons(axM, modes, active = 0)
slTh.on_changed(thresh_live); rbWn.on_clicked(family_live); rbM.on_clicked(mode_live)
thresh_live(h)
