def __init__(self, size = (20, 200), inside = "random"):
self.filter = fp = np.array([[1, 1, 1],
[1, 0, 1],
[1, 1, 1]], np.uint8)
self.in_process = False
self.fig = plt.figure()
# self.fig, self.ax = plt.subplots(figsize=(6,7),)
# self.animation_ax = plt.subplot2grid((6,7), (0, 0), colspan=6, rowspan=6)
# button_ax = plt.subplot2grid((6,7), (0, 6), rowspan=1)
# button_1ax = plt.subplot2grid((6,7), (1, 6), rowspan=1)
self.animation_ax = self.fig.add_axes([.05, .05, .8, .9])
self.animation_ax.axis('off')
# sld_size_ax = self.fig.add_axes([.85, .3, .15, .03])
# sld_size = Slider(sld_size_ax, 'Size', size[0], size[1], valinit=np.mean(size), valfmt=u'%0.0f', dragging=True)
# sld_size.on_changed(self.sld_size_callback)
btn_draw_ax = self.fig.add_axes([.85, .2, .1, .1])
btn_draw = Button(btn_draw_ax, 'ginput')
btn_draw.on_clicked(self.btn_draw_callback)
button_1ax = self.fig.add_axes([.85, .1, .1, .1])
goutput = Button(button_1ax, 'goutput')
goutput.on_clicked(self.goutput_callback)
self.size = np.mean(size)
if inside == "random":
self.field = np.random.randint(2, size=(self.size,self.size))
elif inside == "empty":
self.field = np.zeros((self.size, self.size))
self.im = self.animation_ax.imshow(self.field, cmap=plt.cm.gray, interpolation='nearest')
def pick_cest(args):
if len(args.experiments) > 1:
sys.exit(
"\nError: Multiple experiment files were given. 'chemex pick_cest' "
"should only be run with a single experiment files.\n"
)
# Read experimental setup and data
data = datasets.read_data(args)
if not data.data[0].experiment_name.startswith("cest"):
sys.exit(
"\nError: The command 'chemex pick_cest' only works with CEST "
"experiments.\n"
)
callback = Buttons(data, args.out_dir)
axprevious = plt.axes([0.825, 0.1, 0.075, 0.075])
axnext = plt.axes([0.9, 0.1, 0.075, 0.075])
bprevious = Button(axprevious, "Previous")
bprevious.on_clicked(callback.previous)
bnext = Button(axnext, "Next")
bnext.on_clicked(callback.next)
plt.show()
def setup_controls(self):
""" Set up button axes"""
buttons = [[('Auto levels', self.do_autolevels),
('Levels1', self.do_levels_test),
('Oldie', self.do_levels_old),
('Clip', self.do_levels_clip)],
[('Blur uniform', self.do_blur),
('Blur gaussian', self.do_blur_gaussian),
('Sharpen', self.do_sharpen),
('Unsharp', self.do_unsharp),
('Edge detection', self.do_edges)],
[('Apply', self.apply),
('Reset', self.reset),
('Save', self.save),
('Quit', self.quit)]]
max_cols = max(len(row) for row in buttons)
padding = 0.01
start, end = 0.03, 0.97
hspace = (end - start) / max_cols
row_height = 0.03
vspace = row_height + 0.003
for j, row in enumerate(buttons):
for i, b in enumerate(row):
box = [start + i*hspace, 0.01 + j*vspace,
hspace - padding, row_height]
print box
axis = self.fig.add_axes(box)
button = Button(axis, b[0])
self.axes.append(axis)
button.on_clicked(b[1])
self.buttons.append(button)
def setup_plot():
global rate_slider, delta_slider, fig, ax, l, radio
fig, ax = plt.subplots()
ax.grid('on')
plt.subplots_adjust(left=0.25, bottom=0.25)
moneyFmt = FuncFormatter(money)
ax.yaxis.set_major_formatter(moneyFmt)
s = calc_compounding( rate, periods, principal, contribution, delta,inflation)
t = np.arange(2014, (2014+periods))
l, = plt.plot(t,s, lw=2, color='red')
plt.ylabel("Investment Loss (FV)")
plt.axis([2014, (2014+periods), 0, principal])
plt.axis('tight')
axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], axisbg=axcolor)
axamp = plt.axes([0.25, 0.15, 0.65, 0.03], axisbg=axcolor)
rate_slider = Slider(axfreq, 'Avg.Returns', 4, 8, valinit=rate)
delta_slider = Slider(axamp, 'Delta', 0.1, 1, valinit=delta)
resetax = plt.axes([0.8, 0.025, 0.1, 0.04])
button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
rate_slider.on_changed(update)
delta_slider.on_changed(update)
button.on_clicked(reset)
rax = plt.axes([0.015, 0.15, 0.15, 0.15], axisbg=axcolor)
radio = RadioButtons(rax, ('0','3000', '6000', '9000'), active=0)
radio.on_clicked(contribution_update)
plt.show()
return rate_slider,delta_slider,fig,ax,l,radio
class slider():
def __init__(self,res):
self.res=res
def slider_bar(self,res):
#setupthe slider
axcolor = 'lightgoldenrodyellow'
self.axtime = plt.axes([0.1, 0.05, 0.8, 0.03], axisbg=axcolor)
self.stime = Slider(self.axtime, 'Timestep', 0, len(res.resobj.fils.fid.dimensions['Time']), valinit=0)
def update(val,res):
t = self.stime.val
res.refresh_plot(t)
self.stime.on_changed(update(self,res))
def foward_button(self,res):
self.fwdax = plt.axes([0.1, 0.1, 0.1, 0.04])
self.fwdb = Button(self.fwdax, 'forward', color='lightgoldenrodyellow', hovercolor='0.975')
self.fwdb.on_clicked(slider.update(res.resobj.timestep-1,res))
def plot(self):
self.update_current()
# maximize window
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
self.fig.canvas.mpl_connect('button_press_event', self.onclick)
self.fig.canvas.mpl_connect('key_press_event', self.onpress)
finishax = plt.axes([0.83, 0.85, 0.15, 0.1])
finishbutton = Button(finishax, 'Finish', hovercolor='0.975')
finishbutton.on_clicked(self.finish)
closeax = plt.axes([0.83, 0.65, 0.15, 0.1])
button = Button(closeax, 'Replace (m)', hovercolor='0.975')
button.on_clicked(self.replace_b)
nextax = plt.axes([0.83, 0.45, 0.15, 0.1])
nextbutton = Button(nextax, 'Next (n)', hovercolor='0.975')
nextbutton.on_clicked(self.next_go)
deleteax = plt.axes([0.83, 0.25, 0.15, 0.1])
delete_button = Button(deleteax, 'Delete (j)', hovercolor='0.975')
delete_button.on_clicked(self.delete_b)
undoax = plt.axes([0.83, 0.1, 0.15, 0.1])
undo_button = Button(undoax, 'Undo (u)', hovercolor='0.975')
undo_button.on_clicked(self.undo_b)
plt.show()
return
def debug_plot(a, b, nodes, fs, coeffs):
global _debug_fig, _debug_cancelled
if _debug_cancelled:
return
if 'show' not in locals():
from pylab import axes, subplot, subplots_adjust, figure, draw, plot, axvline, xlim, title, waitforbuttonpress, gcf
from matplotlib.widgets import Button
if _debug_fig is None:
#curfig = gcf()
#print dir(curfig)
_debug_fig = figure()
ax = _debug_fig.add_subplot(111)
#subplots_adjust(bottom=0.15)
butax = axes([0.8, 0.015, 0.1, 0.04])
button = Button(butax, 'Debug', hovercolor='0.975')
def debug(event):
import pdb; pdb.set_trace()
button.on_clicked(debug)
_debug_fig.sca(ax)
draw()
#figure(curfig)
_debug_fig.gca().clear()
plot(nodes, fs, linewidth=5, figure = _debug_fig)
axvline(a, color="r", figure = _debug_fig)
axvline(b, color="r", figure = _debug_fig)
d = 0.05 * (b-a)
_debug_fig.gca().set_xlim(a-d, b+d)
title("press key in figure for next debugplot or close window to continue")
try:
while not _debug_cancelled and not _debug_fig.waitforbuttonpress(-1):
pass
except:
_debug_cancelled = True
def param_gui(letter_name, shapeModeler):
global sliders, mainPlot, fig, pca_params
fig, ax = plt.subplots()
whiteSpace = 0.15 + num_params*0.05
plt.subplots_adjust( bottom=whiteSpace)
plt.axis('equal')
#plot of initial shape
params = np.zeros((num_params,1))
shape = shapeModeler.makeShape(params)
shape = ShapeModeler.normaliseShape(shape)
numPointsInShape = len(shape)/2
x_shape = shape[0:numPointsInShape]
y_shape = shape[numPointsInShape:]
mainPlot, = plt.plot(x_shape, -y_shape)
plt.axis([-1, 1, -1, 1],autoscale_on=False, aspect='equal')
plt.title(letter_name)
#add sliders to modify parameter values
parameterVariances = shapeModeler.getParameterVariances()
sliders = [0]*num_params
for i in range(num_params):
slider = Slider(plt.axes([0.25, 0.1+0.05*(num_params-i-1), 0.65, 0.03], axisbg=axcolor),
'Parameter '+str(i+1), -5*parameterVariances[i], 5*parameterVariances[i], valinit=0)
slider.on_changed(partial(update, shapeModeler))
sliders[i] = slider
resetax = plt.axes([0.8, 0.025, 0.1, 0.04])
button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
button.on_clicked(reset)
plt.show()
return pca_params
def main():
global ax
fig = plt.figure()
bhandler = ButtonHandler()
mhandler = MouseHandler()
axclear = plt.axes([0.37, 0.02, 0.1, 0.075])
axload = plt.axes([0.48, 0.02, 0.1, 0.075])
axsave = plt.axes([0.59, 0.02, 0.1, 0.075])
axcreate = plt.axes([0.7, 0.02, 0.1, 0.075])
axrun = plt.axes([0.81, 0.02, 0.1, 0.075])
bclear = Button(axclear, 'CLEAR')
bclear.on_clicked(bhandler.clear)
bload = Button(axload, 'LOAD')
bload.on_clicked(bhandler.load_data)
bsave = Button(axsave, 'SAVE')
bsave.on_clicked(bhandler.save_data)
bcreate = Button(axcreate, 'CREATE')
bcreate.on_clicked(bhandler.create_polygon)
brun = Button(axrun, 'RUN')
brun.on_clicked(bhandler.run_triangulation)
ax = fig.add_subplot(111, autoscale_on=False)
cid = fig.canvas.mpl_connect('button_press_event', mhandler.onclick)
plt.show()
class NavField:
def __init__(self, pltinfo):
self.fld = -1
self.nflds = len(pltinfo.selindices['field'])
self.pltinfo = pltinfo
prevwidth = 0.13
nextwidth = 0.12
butheight = 0.05
butleft = 0.7
butbot = 0.025
butgap = 0.5 * butbot
self.nextloc = [butleft + prevwidth + butgap,
butbot, nextwidth, butheight]
self.prevloc = [butleft, butbot, prevwidth, butheight]
self.inactivecolor = '#99aaff'
self.activecolor = '#aaffcc'
def _draw_buts(self):
if self.fld < self.nflds - 1:
axnext = pl.axes(self.nextloc)
self.bnext = Button(axnext, 'Next fld >',
color=self.inactivecolor,
hovercolor=self.activecolor)
self.bnext.on_clicked(self.next)
if self.fld > 0:
axprev = pl.axes(self.prevloc)
self.bprev = Button(axprev, '< Prev fld',
color=self.inactivecolor,
hovercolor=self.activecolor)
self.bprev.on_clicked(self.prev)
#pl.show()
def _do_plot(self):
didplot = plotfield(self.pltinfo.selindices['field'][self.fld],
self.pltinfo)
if didplot:
self._draw_buts()
return didplot
def next(self, event):
didplot = False
startfld = self.fld
while self.fld < self.nflds - 1 and not didplot:
self.fld += 1
didplot = self._do_plot()
if not didplot:
print "You are on the last field with any selected baselines."
self.fld = startfld
#plotfield(self.pltinfo.selindices['field'][self.fld],
# self.pltinfo, self.mytb)
def prev(self, event):
didplot = False
startfld = self.fld
while self.fld > 0 and not didplot:
self.fld -= 1
didplot = self._do_plot()
if not didplot:
print "You are on the first field with any selected baselines."
self.fld = startfld
def preparePlot(shapeModeler):
global sliders, mainPlot, fig
fig, ax = plt.subplots();
whiteSpace = 0.15 + numParams*0.05;
plt.subplots_adjust( bottom=whiteSpace);
plt.axis('equal');
#plot of initial shape
params = np.zeros((numParams,1));
shape = shapeModeler.makeShape(params);
shape = ShapeModeler.normaliseShape(shape);
numPointsInShape = len(shape)/2;
x_shape = shape[0:numPointsInShape];
y_shape = shape[numPointsInShape:];
mainPlot, = plt.plot(x_shape, -y_shape);
plt.axis([-1, 1, -1, 1],autoscale_on=False, aspect='equal');
#add sliders to modify parameter values
parameterVariances = shapeModeler.getParameterVariances();
sliders = [0]*numParams;
for i in range(numParams):
slider = Slider(plt.axes([0.25, 0.1+0.05*(numParams-i-1), 0.65, 0.03], axisbg=axcolor),
'Parameter '+str(i+1), -5*parameterVariances[i], 5*parameterVariances[i], valinit=0);
slider.on_changed(update);
sliders[i] = slider;
resetax = plt.axes([0.8, 0.025, 0.1, 0.04])
button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
button.on_clicked(reset)
plt.show()
def main():
from matplotlib import pyplot as plt
import utils
fig = utils.createfig()
a = WSin(fig, [0.1, 0.5, 0.8, 0.3] , nps=5)
b = WSin(fig, [0.1, 0.1, 0.8, 0.3], nps=3, om=3)
args11 = (dict(k=0, am=1, ph=0, t='v', n='1'),
dict(k=-1.5, am=0.1, ph=0.5, t='v', n='3'),)
args12 = (dict(k=1,am=2,ph=1,t='i',n='2'),)
args13 = (dict(k=100,am=3,ph=2,t='i',n='no',v=False),)
args2 = (dict(k=0,am=1,ph=0,t='v',n='1'),dict(k=1,am=2,ph=1,t='i',n='2'),
dict(k=-1.5,am=0.1,ph=0,t='v',n='3'),\
dict(k=100,am=3,ph=2,t='i',n='no',v=False),)
a.new(100, args11, args12, ())
b.new(101, *args2)
#b.set_anim(True)
# bottone
from matplotlib.widgets import Button
box = fig.add_axes([0.05, 0.90, 0.05, 0.05])
but = Button(box, 'next')
def func(wtf):
#args2 = _r_args(4)
#print args2
#b.new(100, *args2)
b.set_anim(not b.get_anim())
but.on_clicked(func)
plt.show()
def __init__(self, image_sequence):
# Fix the size of subplot
self.fig, self.axes = plt.subplots(2, sharey=True, figsize=(10, 5))
# Set background to be gray
self.fig.patch.set_facecolor('#333333')
# Store image sequence in self.seq and display the sequence
self.seq = image_sequence
self.image = self.seq.init_image()
self.image2 = self.seq.init_image_original()
self.image_figure = plt.subplot2grid((3, 3), (0, 0), colspan=3, rowspan=2)
self.image_figure.axis('off')
self.image_plot = self.image_figure.imshow(self.image)
self.image_figure.set_title('Dinic', color='white')
self.init_figure = plt.subplot2grid((3, 3), (2, 1))
self.init_figure.axis('off')
self.init_plot = plt.imshow(self.image2)
self.init_figure.set_title('Flow Graph', color = 'white' )
self.text_figure = plt.subplot2grid((3, 3), (2, 2))
self.text_figure.axis('off')
self.text_figure.set_title('',color = 'white')
plt.subplots_adjust(bottom=0.2)
axnext = plt.axes([0.81, 0.05, 0.1, 0.075])
bnext = Button(axnext, 'Next')
bnext.on_clicked(self.next)
plt.show()
def __init__(self):
'''variable definitions'''
SEGMENTS = int(3) #number of segments
#could probably make these lists instead of arrays
self.l = np.array([0, 100, 100, 80])# actual measurements of segment length in mm
self.w = np.array([0]*SEGMENTS,dtype=float) #horizontal coordinate
self.z = np.array([0]*SEGMENTS,dtype=float) #vertical coordinate
self.x = np.array([0]*SEGMENTS,dtype=float) #x axis components
self.y = np.array([0]*SEGMENTS,dtype=float) #y axis components
self.a = np.array([np.pi]*SEGMENTS,dtype=float) #angle for the link, reference is previous link
self.gripper_angle = np.array([0, -45, -90, 45, 90])#preselected gripper angles
self.current_gripper = 2 #gripper angle selection
self.tw = 30.0 # w axis position depth
self.tz = 20.0 # z axis starting position height
self.l12 = 0.0 # hypotenuse belween a1 & a2
self.a12 = 0.0 #inscribed angle between hypotenuse, w
self.fig = plt.figure("CS 4TE3 Robot Simulator") #create the frame
self.ax = plt.axes([0.05, 0.2, 0.90, .75], projection='3d') #3d ax panel
self.axe = plt.axes([0.25, 0.85, 0.001, .001])#panel for error message
self.count = 0
self.coords = ((20,30),(50,60),(30,40),(70,100),(70,150))
self.display_error()
self.draw_robot()
butval = plt.axes([0.35, 0.1, 0.1, 0.075])
but = Button(butval, 'move')
but.on_clicked(self.move_click)
#error = dist(1,2);
#print (error)
plt.show()#end of constructor
class ButtonClickProcessor(object):
def __init__(self, axes, label, color, viewer):
self.groups = viewer.groups
self.fig_text = viewer.fig_text
self.button = Button(axes, label=label, color=color)
self.button.on_clicked(self.print_group)
def print_group(self, event):
print(self.button.label.get_text())
group = self.groups[int(self.button.label.get_text())]
self.fig_text.clf()
self.ax_text = self.fig_text.add_subplot(111)
# plt.rcParams['text.usetex'] = True
y_write = np.linspace(0, 0.9, len(group.keys()))
for ii, key in enumerate(group.keys()):
self.ax_text.text(0, y_write[ii], str(key) + ' : ' + str(group[key]), fontsize=15, fontstyle='oblique')
#Show it
self.fig_text.canvas.draw()
class MButton(object):
"""Custom button."""
def __init__(self, fig, rect, label, func, fargs=None,
c='#0DE51B', hc='#5CFF67'):
"""init function
Parameters:
fig: matplotlib.figure.Figure instance
rect: [left, bottom, width, height]
each of which in 0-to-1-fraction i.e. 0<=x<=1
label: string
button label
func: function
function called when button is clicked
fargs: array, optional, default: None
(optional) arguments for func
c: a matplotlib color i.e. string
color i.e. background color
hc: a matplotlib color i.e. string
hovercolor i.e. background color when cursor is on button
"""
self.fig = fig
self._rect = rect
self._label = label
self._func = func
self._fargs = fargs
self.axes = self.fig.add_axes(rect)
self.button = Button(self.axes, label, color=c, hovercolor=hc)
self.button.label.set_fontsize('x-small')
self.button.label.set_family('monospace')
self.button.on_clicked(self._onclick)
def _onclick(self, wtf):
"""Actual function called when button is clicked."""
if self.get_visible():
if self._func is not None: # not necessary
if self._fargs is not None:
self._func(*self._fargs)
else:
self._func()
self.fig.canvas.draw()
def set_visible(self, b):
"""Set its visibility.
Parameters:
b: boolean
"""
self.axes.set_visible(b)
def get_visible(self):
"""Get its visibility.
Returns: b
b: boolean
"""
return self.axes.get_visible()
def image_interactive_plot(names, *callbacks):
plt.figure()
plt.subplots_adjust(bottom=0.2, top=0.95, right=0.8)
#cax = plt.axes([0.8, 0.2, 0.2, 0.8])
#im = cax.imshow(np.arange(21).reshape(3,7),cmap=clsscm, alpha=0.0,interpolation='bilinear',norm=mpl.colors.NoNorm(), vmin=0, vmax=255)
#cb = mpl.colorbar.Colorbar(cax, im)
#cb.set_ticks(range(21))
#cb.set_ticklabels(ds.classnames)
n = len(callbacks)
y = int(np.ceil(np.sqrt(n)))
x = int(np.ceil(float(n) / y))
ax = []
for i, c in enumerate(callbacks):
ax.append(plt.gcf().add_subplot(x, y, i+1))
c(names[0], ax[i])
class Index:
img_ind = 0
axname = None
def next(self, event):
if (self.img_ind+1) in range(len(names)):
self.img_ind += 1
try:
for i, c in enumerate(callbacks):
ax[i].clear()
c(names[self.img_ind], ax[i])
self.axname.set_text(names[self.img_ind])
except:
self.img_ind -=1
plt.draw()
def prev(self, event):
if (self.img_ind-1) in range(len(names)):
self.img_ind -= 1
try:
for i, c in enumerate(callbacks):
ax[i].clear()
c(names[self.img_ind], ax[i])
self.axname.set_text(names[self.img_ind])
except:
self.img_ind +=1
cb = Index()
cb.axname = plt.figtext(0.1, 0.05, names[0], fontsize=24)
axprev = plt.axes([0.7, 0.05, 0.1, 0.075])
axnext = plt.axes([0.81, 0.05, 0.1, 0.075])
bnext = Button(axnext, 'Next')
bnext.on_clicked(cb.next)
bprev = Button(axprev, 'Previous')
bprev.on_clicked(cb.prev)
plt.show()
def makeDisplay():
global line1
global line2
a = moose.element( '/model/graphs/concA' )
b = moose.element( '/model/graphs/concB' )
img = mpimg.imread( 'simple_bistab.png' )
#plt.ion()
fig = plt.figure( figsize=(8,10) )
png = fig.add_subplot(311)
imgplot = plt.imshow( img )
plt.axis('off')
ax2 = fig.add_subplot(312)
#ax.set_ylim( 0, 0.1 )
plt.ylabel( 'Conc (mM)' )
plt.xlabel( 'Time (s)' )
ax2.autoscale( enable = True, axis = 'y' )
plt.title( "States of system. Molecules a and b are swapped at t=100 and 200 to cause state flips." )
t = numpy.arange( 0, a.vector.size, 1 ) #sec
line1, = ax2.plot( t, a.vector, 'r-', label = 'a' )
line2, = ax2.plot( t, b.vector, 'b-', label = 'b' )
plt.legend()
ax = fig.add_subplot(313)
plt.axis('off')
axcolor = 'palegreen'
axReset = plt.axes( [0.25,0.05, 0.30,0.03], facecolor='blue' )
axQuit = plt.axes( [0.60,0.05, 0.30,0.03], facecolor='blue' )
axAinit = plt.axes( [0.25,0.1, 0.65,0.03], facecolor=axcolor )
axBinit = plt.axes( [0.25,0.15, 0.65,0.03], facecolor=axcolor )
axCinit = plt.axes( [0.25,0.20, 0.65,0.03], facecolor=axcolor )
axKcat2 = plt.axes( [0.25,0.25, 0.65,0.03], facecolor=axcolor )
axKcat1 = plt.axes( [0.25,0.30, 0.65,0.03], facecolor=axcolor )
#aInit = Slider( axAinit, 'A init conc', 0, 10, valinit=1.0, valstep=0.2)
reset = Button( axReset, 'Reset', color = 'cyan' )
q = Button( axQuit, 'Quit', color = 'pink' )
aInit = Slider( axAinit, 'A init conc', 0, 10, valinit=1.0 )
bInit = Slider( axBinit, 'B init conc', 0, 10, valinit=0.0 )
cInit = Slider( axCinit, 'C init conc', 0, 0.1, valinit=0.01 )
kcat2 = Slider( axKcat2, 'Kcat for enz2', 0, 2, valinit=0.6 )
kcat1 = Slider( axKcat1, 'Kcat for enz1', 0, 2, valinit=0.4 )
def resetParms( event ):
aInit.reset()
bInit.reset()
cInit.reset()
kcat2.reset()
kcat1.reset()
reset.on_clicked( resetParms )
q.on_clicked( doQuit )
aInit.on_changed( updateAinit )
bInit.on_changed( updateBinit )
cInit.on_changed( updateCinit )
kcat1.on_changed( updateKcat1 )
kcat2.on_changed( updateKcat2 )
plt.show()
def interactive_predictions_plot(img_infos):
plt.figure()
plt.subplots_adjust(bottom=0.2, top=0.95, right=0.8)
ax = []
def show(info, axes):
for a in axes:
a.clear()
axes[0].imshow(info.image)
show_segmentation(info.ground_truth, axes[1], numclasses=info.ds.classnum)
show_segmentation(info.prediction, axes[2], numclasses=info.ds.classnum)
cb = mpl.colorbar.ColorbarBase(axes[3], cmap=label_colormap(info.ds.classnum), norm=mpl.colors.NoNorm())
cb.set_ticks(np.arange(info.ds.classnum))
cb.set_ticklabels(info.ds.classnames)
for i in range(4):
ax.append(plt.gcf().add_subplot(2, 2, i+1))
show(img_infos[0], ax)
class Index:
img_ind = 0
axname = None
def next(self, event):
if (self.img_ind+1) in range(len(img_infos)):
self.img_ind += 1
try:
show(img_infos[self.img_ind], ax)
self.axname.set_text(img_infos[self.img_ind].name)
except:
self.img_ind -=1
plt.draw()
def prev(self, event):
if (self.img_ind-1) in range(len(img_infos)):
self.img_ind -= 1
try:
show(img_infos[self.img_ind], ax)
self.axname.set_text(img_infos[self.img_ind].name)
except:
self.img_ind +=1
cb = Index()
cb.axname = plt.figtext(0.1, 0.05, img_infos[0].name, fontsize=24)
axprev = plt.axes([0.7, 0.05, 0.1, 0.075])
axnext = plt.axes([0.81, 0.05, 0.1, 0.075])
bnext = Button(axnext, 'Next')
bnext.on_clicked(cb.next)
bprev = Button(axprev, 'Previous')
bprev.on_clicked(cb.prev)
plt.show()
def main(argv):
"""Test maximum density."""
print(len(argv))
if len(argv) < 1:
shot_number=int(open('shot_number.txt','r').read())
else:
if (len(argv) == 1) & ("py" in argv[0]):
shot_number=int(open('shot_number.txt','r').read())
else:
shot_number = int(argv[1])
fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.25)
shot = ppb.ProcProfile(shot_number)
shot.reference_gd(all_shot=1)
cluster = 20
shot.plasma_gd(1, cluster, 1)
ax.pcolormesh(shot.X['K'], shot.Y['K'], shot.matrix_k_mean)
ax.pcolormesh(shot.X['Ka'], shot.Y['Ka'], shot.matrix_ka_mean)
plt.plot(shot.X['K'], shot.Y['K'][shot.matrix_k_mean.argmax(axis=0)] - 3.36, color='b', linewidth=2.0)
plt.plot(shot.X['Ka'], shot.Y['Ka'][shot.matrix_ka_mean.argmax(axis=0)] - 3.36, color='b', linewidth=2.0)
plt.plot(shot.X['K'], shot.Y['K'][shot.matrix_k_mean.argmax(axis=0)], color='b', linewidth=2.0)
plt.plot(shot.X['Ka'], shot.Y['Ka'][shot.matrix_ka_mean.argmax(axis=0)], color='b', linewidth=2.0)
l, = plt.plot(shot.X['K'], shot.Y['K'][shot.matrix_k_mean.argmax(axis=0)], color='r', linewidth=2.0)
m, = plt.plot(shot.X['Ka'], shot.Y['Ka'][shot.matrix_ka_mean.argmax(axis=0)], color='r', linewidth=2.0)
plt.xlabel("freq (GHz)")
plt.ylabel("group delay (ns)")
plt.title("# %s - time: %s ms" % (shot.shot, shot.sweep2time(shot.sweep_cur)))
plt.ylim(0, 12)
plt.xlim(shot.X['K'].min(), shot.X['Ka'].max())
axcolor = 'lightgoldenrodyellow'
axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], axisbg=axcolor)
sweep = Slider(axfreq, 'Sweep', 1, len(shot.points) - 1 - cluster, valinit=1, valfmt='%1.f')
def update(val):
shot.plasma_gd(int(sweep.val), cluster, 1)
ax.pcolormesh(shot.X['K'], shot.Y['K'], shot.matrix_k_mean)
ax.pcolormesh(shot.X['Ka'], shot.Y['Ka'], shot.matrix_ka_mean)
l.set_ydata(shot.Y['K'][shot.matrix_k_mean.argmax(axis=0)])
m.set_ydata(shot.Y['Ka'][shot.matrix_ka_mean.argmax(axis=0)])
ax.set_title("# %s - time: %.3f ms" % (shot.shot, shot.sweep2time(shot.sweep_cur)))
fig.canvas.draw_idle()
sweep.on_changed(update)
resetax = plt.axes([0.8, 0.025, 0.1, 0.04])
button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
def reset(event):
sweep.reset()
button.on_clicked(reset)
plt.show()
def figPause(fig):
global gInPause
buttonAxes = plt.axes([0.9, 0.9, 0.1, 0.05])
button = Button(buttonAxes, '>>')
button.on_clicked(onclick)
gInPause = True
print('Program paused in figure window...')
while gInPause:
plt.pause(0.2)
plt.draw()
button.disconnect_events()
def interactive_dataset_plot(dataset):
plt.figure()
plt.subplots_adjust(bottom=0.2, top=0.95, right=0.8)
ax = []
def show(info, axes):
for a in axes:
a.clear()
axes[0].imshow(info.image)
show_segmentation(info.ground_truth, axes[1])
for i in range(2):
ax.append(plt.gcf().add_subplot(1, 2, i+1))
show(dataset[0], ax)
class Index:
img_ind = 0
axname = None
def next(self, event):
if (self.img_ind+1) in range(len(dataset)):
self.img_ind += 1
try:
show(dataset[self.img_ind], ax)
self.axname.set_text(dataset[self.img_ind].name)
except:
self.img_ind -=1
plt.draw()
def prev(self, event):
if (self.img_ind-1) in range(len(dataset)):
self.img_ind -= 1
try:
show(dataset[self.img_ind], ax)
self.axname.set_text(dataset[self.img_ind].name)
except:
self.img_ind +=1
cb = Index()
cb.axname = plt.figtext(0.1, 0.05, dataset[0].name, fontsize=24)
axprev = plt.axes([0.7, 0.05, 0.1, 0.075])
axnext = plt.axes([0.81, 0.05, 0.1, 0.075])
bnext = Button(axnext, 'Next')
bnext.on_clicked(cb.next)
bprev = Button(axprev, 'Previous')
bprev.on_clicked(cb.prev)
plt.show()
def build_interface(self, spec):
gs0 = gridspec.GridSpecFromSubplotSpec(
self.r, self.c,
subplot_spec=spec)
k=0
for i in range(1, self.c):
for j in range(0, self.r):
ax=self.fig.add_subplot(gs0[j, i])
bt=Button(ax, self.collist[k])
bt.on_clicked(self.hndl_event)
k=k+1
def run_main(A,B,C,dA,dB,dC):
plt.close()
plt.figure()
int_writer()
var_writer_uncert(A,B,C)
run_SPCAT()
data = cat_reader()
t = []
s = []
for x in data:
s.append(0.0)
s.append(str(10**float(x[1])))
s.append(0.0)
t.append(float(x[0])-0.0001)
t.append(x[0])
t.append(float(x[0])+0.0001)
ax = plt.subplot(111)
plt.subplots_adjust(left=0.25, bottom=0.25)
a0 = 5
f0 = 3
global l
l, = plt.plot(t,s, lw=2, color='red')
#plt.axis([0, 1, -10, 10])
axcolor = 'lightgoldenrodyellow'
axA = plt.axes([0.25, 0.15, 0.65, 0.03], axisbg=axcolor)
axB = plt.axes([0.25, 0.1, 0.65, 0.03], axisbg=axcolor)
axC = plt.axes([0.25, 0.05, 0.65, 0.03], axisbg=axcolor)
global A_slider
global B_slider
global C_slider
A_slider = Slider(axA, 'A', A-dA, A+dA, valinit=A)
B_slider = Slider(axB, 'B', B-dB, B+dB, valinit=B)
C_slider = Slider(axC, 'C', C-dC, C+dC, valinit=C)
A_slider.on_changed(update)
B_slider.on_changed(update)
C_slider.on_changed(update)
global button
global radio
resetax = plt.axes([0.1, 0.025, 0.1, 0.04])
button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
button.on_clicked(reset)
rax = plt.axes([0.025, 0.5, 0.15, 0.15], axisbg=axcolor)
radio = RadioButtons(rax, ('red', 'blue', 'green'), active=0)
radio.on_clicked(colorfunc)
plt.show()
def display3DBoardSingleFrame(self, grid):
def drawGamePrism(ax):
cube_corner = [[0, 0, 0], [self.rownum, 0, 0], [self.rownum, self.colnum, 0], [0, self.colnum, 0],
[0, 0, self.height], [self.rownum, 0, self.height], [self.rownum, self.colnum, self.height], [0, self.colnum, self.height]]
ax.plot3D(*zip(cube_corner[0], cube_corner[1]), color = "m")
ax.plot3D(*zip(cube_corner[1], cube_corner[5]), color = "m")
ax.plot3D(*zip(cube_corner[5], cube_corner[4]), color = "m")
ax.plot3D(*zip(cube_corner[4], cube_corner[0]), color = "m")
ax.plot3D(*zip(cube_corner[3], cube_corner[2]), color = "m")
ax.plot3D(*zip(cube_corner[2], cube_corner[6]), color = "m")
ax.plot3D(*zip(cube_corner[6], cube_corner[7]), color = "m")
ax.plot3D(*zip(cube_corner[7], cube_corner[3]), color = "m")
ax.plot3D(*zip(cube_corner[0], cube_corner[3]), color = "m")
ax.plot3D(*zip(cube_corner[1], cube_corner[2]), color = "m")
ax.plot3D(*zip(cube_corner[5], cube_corner[6]), color = "m")
ax.plot3D(*zip(cube_corner[4], cube_corner[7]), color = "m")
def drawThreadPoles(ax):
for x in range(self.rownum):
for y in range(self.colnum):
minz, maxz = 0, self.height
ax.plot3D(*zip([x,y,minz], [x,y,maxz]), color = "g")
fig = plt.figure()
ax = fig.add_subplot(111, projection = '3d')
ax.set_xticks(np.arange(grid.shape[0]), minor = False)
ax.set_yticks(np.arange(grid.shape[1]), minor = False)
ax.set_zticks(np.arange(grid.shape[2]), minor = False)
drawGamePrism(ax)
drawThreadPoles(ax)
for x in range(len(grid)):
for y in range(len(grid[0])):
for z in range(len(grid[0][0])):
if(grid[x][y][z] == 0):
continue
elif(grid[x][y][z] == 1):
color = 'b'
elif(grid[x][y][z] == 2):
color = 'r'
ax.scatter([x], [y], [z], c = color, s = 80)
ax.set_xlabel('X Label')
ax.set_ylabel('Y Label')
ax.set_zlabel('Z Label')
axstop = plt.axes([0.9, 0.0, 0.1, 0.075])
axnext = plt.axes([0.1, 0.0, 0.1, 0.075])
button_stop = Button(axstop, 'Stop')
button_next = Button(axnext, 'Next')
button_stop.on_clicked(self.exiting)
button_next.on_clicked(self.closeplt)
plt.show()
def _GUI_display(self,redshift_est,ztest,corr_val,wave,flux_sc):
'''Display the spectrum and reference lines.'''
self.fig = plt.figure(figsize=(10, 8))
gs = gridspec.GridSpec(2, 1, height_ratios=[2, 1])
ax2 = plt.subplot(gs[0])
ax = plt.subplot(gs[1])
plt.subplots_adjust(right=0.8)
ax.plot(ztest,corr_val,'b')
ax.axvline(redshift_est,color='k',ls='--')
ax.fill_between(self.ztest,np.zeros(self.ztest.size),self.corr_prior,facecolor='grey',alpha=0.6)
ax.set_xlabel('Redshift')
ax.set_ylabel('Correlation')
self.pspec, = ax2.plot(wave,flux_sc)
ax2.axvline(3725.0*(1+redshift_est),ls='--',alpha=0.7,c='blue')
ax2.axvline(3968.5*(1+redshift_est),ls='--',alpha=0.7,c='red')
ax2.axvline(3933.7*(1+redshift_est),ls='--',alpha=0.7,c='red')
ax2.axvline(4102.9*(1+redshift_est),ls='--',alpha=0.7,c='orange')
ax2.axvline(4304.0*(1+redshift_est),ls='--',alpha=0.7,c='orange')
ax2.axvline(4862.0*(1+redshift_est),ls='--',alpha=0.7,c='orange')
ax2.axvline(4959.0*(1+redshift_est),ls='--',alpha=0.7,c='blue')
ax2.axvline(5007.0*(1+redshift_est),ls='--',alpha=0.7,c='blue')
ax2.axvline(5175.0*(1+redshift_est),ls='--',alpha=0.7,c='orange')
if self.first_pass:
self.line_est = Estimateline(self.pspec,ax2,self.uline_n)
rax = plt.axes([0.85, 0.5, 0.1, 0.2])
if self.qualityval == 0:
radio = RadioButtons(rax, ('Unclear', 'Clear'))
else:
radio = RadioButtons(rax, ('Unclear', 'Clear'),active=1)
def qualfunc(label):
if label == 'Clear':
self.qualityval = 1
else:
self.qualityval = 0
radio.on_clicked(qualfunc)
closeax = plt.axes([0.83, 0.3, 0.15, 0.1])
button = Button(closeax, 'Accept & Close', hovercolor='0.975')
def closeplot(event):
plt.close()
button.on_clicked(closeplot)
ax2.set_xlim(self.lower_w,self.upper_w)
ax2.set_xlabel('Wavelength (A)')
ax2.set_ylabel('Counts')
if not self.first_pass:
self.spectra2 = DragSpectra(self.pspec,flux_sc,ax2,self.fig)
self.fig.canvas.mpl_connect('motion_notify_event',self.spectra2.on_motion)
self.fig.canvas.mpl_connect('button_press_event',self.spectra2.on_press)
self.fig.canvas.mpl_connect('button_release_event',self.spectra2.on_release)
plt.show()
def main():
for i in range(-10,10):
print(i,i%4)
fig = plt.figure('ECG chart')
callback = Index()
data = spio.loadmat('s0026lrem_short.mat')
data = data['val']
print(data, len(data))
print(len(data[1]))
global axes
for i in range(1,13):
ax1 = plt.subplot(13, 1 , i)
axes.append(ax1)
for i in range(1,13):
fft = []
global axes_xlim
#ecg_plot(data, prepare_array(read_file('samples1_long.csv')), axes[i-1],i)
ecg_plot(data, axes[i-1],i)
callback.update_genY(Y[i-1],0)
print(len(Y[i-1]))
callback.update_genX(X[i-1],0)
axes_xlim[0] = ylen
callback.update_genY(FFTaxes[i-1],1)
callback.update_genX(frq,1)
callback.update_genY(WTaxesA[i-1],2)
callback.update_genX(range(0,len(WTaxesA[i-1])),2)
axes_xlim[2] = len(WTaxesA[i-1])
callback.update_genY(WTaxesD[i-1],3)
callback.update_genX(range(0,len(WTaxesD[i-1])),3)
axes_xlim[3]= len(WTaxesD[i-1])
ecg_plot_info(axes)
fig.subplots_adjust(hspace = 0.1, left = 0.05, right = 0.95, top = 0.95, bottom = 0.05)
print("Uderzenia na sekunde: ")
print(60000/calculate_bpm())
axprev = plt.axes([0.7, 0.01, 0.1, 0.075])
axnext = plt.axes([0.81, 0.01, 0.1, 0.075])
bnext = Button(axnext, 'Next')
bprev = Button(axprev, 'Previous')
bprev.on_clicked(callback.prev)
bnext.on_clicked(callback.next)
plt.show()
def setup(self):
self.fig, self.ax = plt.subplots()
self.t = np.linspace(0, 10, 1000)
self.line, = plt.plot(self.t, np.sin(self.t), lw=2)
self.v = 0
slider_ax = plt.axes([0.1, 0.1, 0.8, 0.02])
slider = Slider(slider_ax, "Offset", -5, 5, valinit=0, color='#AAAAAA')
slider.on_changed(self.on_change)
ax1 = plt.axes([0.2, 0.5, 0.1, 0.075])
#ax2 = plt.axes([0.7, 0.5, 0.1, 0.075])
b1 = Button(ax1, 'Draw')
b1.on_clicked(self.callback)
plt.show()
class ButtonSet:
def __init__(self, px, mx, kx):
self.buttonP = Button(px, '+')
self.buttonM = Button(mx, '-')
self.stVal = kx
self.buttonP.on_clicked(self.button_handler_p)
self.buttonM.on_clicked(self.button_handler_m)
def button_handler_p(self, event):
self.stVal += 0.1
def button_handler_m(self, event):
self.stVal -= 0.1
def main(argv=None): ani = animation.FuncAnimation(fig, run, data_gen, blit=True, interval=10, repeat=False) axprev = plt.axes([0.7, 0.05, 0.1, 0.075]) axnext = plt.axes([0.81, 0.05, 0.1, 0.075]) bnext = Button(axnext, 'Pause') bnext.on_clicked(pause_animation) bprev = Button(axprev, 'Play') bprev.on_clicked(play_animation) plt.show()
def submit(self):
if (self.type == game.SheetType.MATCH):
#If the match is empty, reset the data and display fields
if self.matchData['Team'] == 0:
print("Found an empty match, skipping")
self.matchData = dict(game.SCOUT_FIELDS)
self.display = cv2.cvtColor(self.sheet, cv2.COLOR_GRAY2BGR)
return
#Open the database and check if the match has already been processed
datapath = 'data_' + CURRENT_EVENT + '.db'
conn = sql.connect(datapath)
conn.row_factory = sql.Row
cursor = conn.cursor()
history = cursor.execute(
'SELECT * FROM scout WHERE Team=? AND Match=?',
(str(self.matchData['Team']), str(
self.matchData['Match']))).fetchall()
if history and not self.matchData['Replay']:
print("Already processed this match, skipping")
self.data = dict(game.SCOUT_FIELDS)
self.display = cv2.cvtColor(self.sheet, cv2.COLOR_GRAY2BGR)
return
elif (self.type == game.SheetType.PIT):
if self.pitData['Team'] == 0:
print("Found an empty pit sheet, skipping")
self.pitData = dict(game.PIT_SCOUT_FIELDS)
self.display = cv2.cvtColor(self.sheet, cv2.COLOR_GRAY2BGR)
return
datapath = 'data_' + CURRENT_EVENT + '.db'
conn = sql.connect(datapath)
conn.row_factory = sql.Row
cursor = conn.cursor()
history = cursor.execute('SELECT * FROM pitScout WHERE Team=?',
(str(self.pitData['Team']), )).fetchall()
if history:
print("Already processed this team, skipping")
self.pitData = dict(game.PIT_SCOUT_FIELDS)
self.display = cv2.cvtColor(self.sheet, cv2.COLOR_GRAY2BGR)
return
#Create and open the GUI to verify data
print("Found new data, opening")
output = ''
if self.type == game.SheetType.MATCH:
for key, value in self.matchData.items():
output += key + "=" + str(value) + '\n'
elif self.type == game.SheetType.PIT:
for key, value in self.pitData.items():
output += key + "=" + str(value) + '\n'
fig = plt.figure('PiScout')
fig.subplots_adjust(left=0, right=0.6)
plt.subplot(111)
plt.imshow(self.display)
plt.title('Scanned Sheet')
plt.text(600, 784, output, fontsize=12)
upload = Button(plt.axes([0.68, 0.31, 0.15, 0.07]), 'Upload Data')
upload.on_clicked(self.upload)
save = Button(plt.axes([0.68, 0.24, 0.15, 0.07]), 'Save Data Offline')
save.on_clicked(self.save)
edit = Button(plt.axes([0.68, 0.17, 0.15, 0.07]), 'Edit Data')
edit.on_clicked(self.edit)
cancel = Button(plt.axes([0.68, 0.1, 0.15, 0.07]), 'Cancel')
cancel.on_clicked(self.cancel)
mng = plt.get_current_fig_manager()
try:
mng.window.state('zoomed')
except AttributeError:
print("Window resizing exploded, oh well.")
plt.show()
self.matchData = dict(game.SCOUT_FIELDS)
self.pitData = dict(game.PIT_SCOUT_FIELDS)
self.display = cv2.cvtColor(self.sheet, cv2.COLOR_GRAY2BGR)
def run(data_directory, output_file, data_set="SBC-17", start=0, n_events=5):
## Want to go through events and show the raw piezo trace, then click to select a t0.
## Display the t0, ask for confirmation, and then save to an output file.
full_stop = False
with open(output_file, "w") as f:
try:
fcntl.flock(
f, fcntl.LOCK_EX
| fcntl.LOCK_NB) # <-- Locks the file until f.__exit__()
except BlockingIOError:
print(
"Critical: File is currently locked by another user/process. Aborting."
)
return
except:
print("Unsupported on non-Linux/Mac OS's. Aborting.")
return
evs_processed = 0
all_ids = [
i for i in os.listdir(data_directory) if
os.path.isdir(os.path.join(data_directory, i)) and i != "scratch"
]
n_skip = 0
_counter = 0
for ev_id in all_ids:
if data_set == "SBC-17":
f_template = re.compile(
"^[0-9]{8}_[0-9]+"
) ## Until the year 10,000 this should work. . .
f_match = re.match(f_template, ev_id)
if f_match:
d = int(ev_id.split("_")[0])
if d < 20170630:
continue # Skips all data that happened before June 30 2017.
all_evs = [
i for i in os.listdir(os.path.join(data_directory, ev_id))
if os.path.isdir(os.path.join(data_directory, ev_id, i))
]
all_evs = sorted(all_evs, key=int)
for ev in all_evs:
if start > _counter:
_counter += 1
continue
if full_stop:
# f.write(_last_out_str)
print("Processed {} events ({}-{})".format(
evs_processed - 1, start,
start + evs_processed - 1))
return
if evs_processed >= n_events:
# f.write(_last_out_str)
print("Processed {} events ({}-{})".format(
evs_processed, start, start + evs_processed))
return
else:
## We grab the event and extract the Piezo traces
print(os.path.join(RAW_DIRECTORY, ev_id, ev),
end=" >>>>> ")
ev_data = GE(os.path.join(RAW_DIRECTORY, ev_id), ev,
"fastDAQ")
try:
piezo2 = ev_data["fastDAQ"]["Piezo2"]
except Exception as e:
print(
"********************Exception! Fix this.********************"
)
continue
## We grab the timebase from the event data and find the mean time interval
timebase = ev_data["fastDAQ"]["time"]
xextent = (min(timebase), max(timebase))
dt = np.mean(np.diff(timebase))
plt.plot(timebase, piezo2)
drawing_ax = plt.gca()
plt.ioff()
actions = mplActions(timebase, piezo2, ev_id, ev, f,
drawing_ax)
cid = plt.gcf().canvas.mpl_connect(
'button_press_event', actions.on_click)
g_fit = plt.axes([0.543, 0.05, 0.357, 0.15])
g_but = Button(g_fit, "Confirm", hovercolor="green")
g_but.label.set_fontsize(45)
g_but.on_clicked(actions.confirm)
b_fit = plt.axes([0.125, 0.05, 0.359, 0.15])
b_but = Button(b_fit, "Skip", hovercolor="red")
b_but.label.set_fontsize(45)
b_but.on_clicked(actions.skip)
close_fit = plt.axes([0.91, 0.05, .08, 0.15])
close_button = Button(close_fit,
"Stop\nall",
hovercolor="red")
close_button.label.set_fontsize(14)
close_button.on_clicked(actions.stop)
plt.show()
full_stop = actions.full_stop
evs_processed += 1
return
def do_plot(RES):
'''
Make sure
%matplolib qt
TODO: in future just setup once, and then update lines only
'''
# live plot https://stackoverflow.com/questions/11874767/how-do-i-plot-in-real-time-in-a-while-loop-using-matplotlib
# see also pylive
import matplotlib
matplotlib.use('Qt5Agg')
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from pyEPR.toolbox_plotting import legend_translucent
from pyEPR.toolbox import combinekw, xarray_unravel_levels, floor_10
plt.ion()
fig = plt.figure(1, figsize=(25, 10))
fig.clf()
fig, axs = plt.subplots(2, 3, subplot_kw=dict(), num=1, sharex=True)
kw = dict(marker='o')
leg_kw = dict(fontsize=9, ncol=1)
# Frequency
ax = axs[0, 0]
df = pd.DataFrame({x: 1000. * RES[x]['freq_hfss']
for x in RES}).transpose()
df.plot(ax=ax, **kw)
ax.set_title(
'Linear mode, HFSS frequency $\omega_m/2\pi$ and dressed (MHz)')
legend_translucent(ax, leg_kw=combinekw(
leg_kw, dict(title='Mode #'))) #ax.legend(title= 'Mode #')
# Dressed frequency
ax.set_prop_cycle(None)
df = pd.DataFrame({x: RES[x]['Hres']['f01'] for x in RES}).transpose()
df.plot(ax=ax,
legend=False,
**combinekw(kw, dict(marker=None, alpha=0.5, ls='--')))
# Pmj Norm
ax = axs[1, 0]
df = pd.DataFrame({x: RES[x]['_Pmj_norm'] for x in RES}).transpose()
df.plot(ax=ax, **kw)
ax.set_title('HFSS $p_{mj}$ norm')
legend_translucent(ax, leg_kw=combinekw(leg_kw, dict(title='Mode #')))
# Frequency
ax = axs[0, 1]
df = pd.DataFrame({x: RES[x]['alpha'] for x in RES}).transpose()
df.plot(ax=ax, **kw)
ax.set_title(r'Anharmonicity $\alpha_{mj}/2\pi$ (MHz)')
legend_translucent(ax, leg_kw=combinekw(leg_kw, dict(title='Mode #')))
if RES[pass_]['ND'] is not None: # plot numerical solution
ax.set_prop_cycle(None)
df = pd.DataFrame({x: diag(RES[x]['ND']['CHI'])
for x in RES}).transpose()
df.plot(ax=ax,
legend=False,
**combinekw(kw, dict(marker=None, alpha=0.5, ls='--')))
ax = axs[0, 2]
df = pd.DataFrame({x: RES[x]['chi'] for x in RES}).transpose()
df.plot(ax=ax, **kw)
ax.set_title(r'Cross-Kerr $\chi_{mm\prime}/2\pi$ (MHz)')
legend_translucent(ax, leg_kw=combinekw(leg_kw, dict(title='Mode #')))
# if RES[pass_]['ND'] is not None: # plot numerical solution
# ax.set_prop_cycle(None)
# df = pd.DataFrame({x:-get_above_diagonal(RES[x]['ND']['CHI']) for x in RES}).transpose()
## df = pd.DataFrame({x:RES[x]['Hres']['chi2'] for x in RES}).transpose()
# df.plot(ax=ax,legend=False,**combinekw(kw,dict(marker=None,alpha=0.5,ls='--')))
ax = axs[1, 2]
df = pd.DataFrame({x: RES[x]['Hres']['omega_zx'] for x in RES}).transpose()
df.plot(ax=ax, **kw)
ax.set_title(r'Cross-Resonance $\omega_{ZX}/2\pi$ (MHz)')
legend_translucent(ax, leg_kw=combinekw(leg_kw, dict(title='C,T')))
# Pmj normed plot
ax = axs[1, 1]
da = xarray_unravel_levels({x: RES[x]['Pmj_normed']
for x in RES},
names=['pass', 'mode', 'junction'])
for mode in da.coords['mode']:
for junc in da.coords['junction']:
junc_name = str(junc.values)[2:]
ys = da.sel(mode=mode, junction=junc)
ys.plot.line(ax=ax,
label='%2s,%4s' % (str(mode.values), junc_name),
**kw)
min_ = floor_10(min(abs(np.min(da.values)),
abs(np.max(da.values)))) # just in case
ax.set_ylim(min_, 1.05)
ax.set_yscale("log", nonposy='clip')
legend_translucent(ax, leg_kw=combinekw(leg_kw, dict(title='$p_{mj}$')))
ax.set_title('HFSS $p_{mj}$ normed')
from matplotlib.widgets import Button
class Index(object):
ind = 0
def __init__(self, button, ax):
self.ax = ax
self.button = button # so it doesnt get erased
def next(self, event):
i = self.ind = (self.ind + 1) % 5
ax = self.ax
if i == 0:
ax.set_ylim(min_, 1.05)
ax.set_yscale("log", nonposy='clip')
elif i == 1:
ax.set_ylim(min_, 1.02)
ax.set_yscale("linear", nonposy='clip')
elif i == 2:
ax.set_ylim(0.8, 1.02)
ax.set_yscale("linear", nonposy='clip')
elif i == 3:
ax.set_ylim(10**-3, 10**-1)
ax.set_yscale("log", nonposy='clip')
elif i == 4:
ax.set_ylim(5 * 10**-5, 2 * 10**-3)
ax.set_yscale("log", nonposy='clip')
self.button.label.set_text('Next %d' % (self.ind))
fig.canvas.draw()
fig.canvas.flush_events()
pos1 = ax.get_position()
pos2 = [pos1.x0 + 0., pos1.y0 + pos1.height + 0.002, 0.07, 0.04]
axnext = plt.axes(pos2)
bnext = Button(axnext, 'Next')
callback = Index(bnext, ax)
bnext.on_clicked(callback.next)
for ax in np.ndarray.flatten(axs):
ax.set_xlabel('Pass number')
#ax.autoscale(tight=True)
fig.tight_layout() #pad=0.4, w_pad=0.5, h_pad=1.0)
fig.show()
plt.pause(0.01)
return df
class PointFixer:
def __init__(self, clone, display):
print "Reading image: " + clone.filebase
print >> sys.stderr, "Current image: " + clone.filebase
# read first image
im = cv2.imread(clone.filepath, cv2.IMREAD_GRAYSCALE)
if im is None:
print "Image " + clone.filepath + " not found. Check your image filepath."
raise IOError
self.original_image = im
self.image = im
self.display = display
self.clone = clone
# set default editing properties
self.edges = False
self.edge_blur = 1.0
hc = self.clone.high_contrast(self.original_image)
self.original_edge_image = cv2.Canny(
np.array(255 * gaussian(hc, self.edge_blur), dtype=np.uint8), 0,
50) / 255
self.edge_image = self.original_edge_image.copy()
self.params = {}
self.de = clone.dorsal_edge
self.do_fit_dorsal = False
self.show_dorsal_edge = True
self.add_checkpoint = False
self.mask_clicked = False
self.unmask_clicked = False
self.masked_regions = {}
self.selected = None
self.checkpoints = self.clone.checkpoints
self.cid = self.display.figure.canvas.mpl_connect(
'button_press_event', self)
self.kid = self.display.figure.canvas.mpl_connect(
'key_press_event', self.keypress)
self.draw()
def __call__(self, event):
# handles mouse clicks given context
if event.inaxes != self.display.axes: return
# if add checkpoint is selected, handle click to add checkpoint
if self.add_checkpoint:
self.get_closest_checkpoint(event.ydata, event.xdata, n=2)
self.insert_new_checkpoint(event.ydata, event.xdata)
self.clone.checkpoints = self.checkpoints
self.fit_dorsal()
self.add_checkpoint = False
self.selected = None
self.draw()
elif not (self.mask_clicked or self.unmask_clicked):
if (self.selected is None):
# select closest checkpoint to mouse click if none selected
self.get_closest_checkpoint(event.ydata, event.xdata)
self.display.scatter(self.selected[1],
self.selected[0],
c="green")
self.display.figure.canvas.draw()
else:
# move checkpoint and update the dorsal fit
self.display.clear()
self.set_closest_checkpoint(event.ydata, event.xdata)
self.clone.checkpoints = self.checkpoints
if self.do_fit_dorsal:
self.fit_dorsal()
self.do_fit_dorsal = False
self.selected = None
self.draw()
def keypress(self, event):
if (event.key == "backspace") or (event.key == "delete"):
self.delete_selected_checkpoint(event)
def fit_dorsal(self):
# re-fits dorsal edge and calcualtes all statistics
self.clone.fit_dorsal_edge(self.original_image,
dorsal_edge_blur=self.edge_blur,
edges=self.edge_image)
self.clone.tail_dorsal = tuple(self.checkpoints[-1, :])
self.clone.remove_tail_spine()
self.de = self.clone.interpolate(self.clone.dorsal_edge)
self.checkpoints = self.clone.checkpoints
self.clone.head = tuple(self.checkpoints[0, :])
self.clone.get_animal_length()
self.clone.get_animal_dorsal_area()
self.clone.qscore()
self.clone.analyze_pedestal()
def flip_button_press(self, event):
# flips the dorsal and ventral positions and updates all downstream statistics
# and visualization
self.display.imshow(self.image, cmap="gray")
self.clone.flip = not self.clone.flip
self.clone.find_eye(self.original_image)
self.clone.find_features(self.original_image)
self.clone.get_orientation_vectors()
self.clone.eye_vertices()
self.clone.find_head(self.original_image)
self.clone.initialize_dorsal_edge(self.original_image)
self.clone.fit_dorsal_edge(self.original_image)
self.edge_image = self.clone.edges
self.clone.find_tail(self.original_image)
self.clone.remove_tail_spine()
self.de = self.clone.interpolate(self.clone.dorsal_edge)
self.checkpoints = self.clone.checkpoints
self.draw()
def edge_button_press(self, event):
# switches view of the GUI from raw to edge or vice-versa,
# depending on what is currently being shown
self.edges = not self.edges
if self.edges:
self.image = self.edge_image
self.draw()
if not self.edges:
self.image = self.original_image
self.draw()
def draw(self):
# updates all visualizations depending on current state of the GUI,
# and redraws the GUI image and buttons
self.display.clear()
buttoncolor = [0.792156862745098, 0.8823529411764706, 1.0]
axaddcheck = plt.axes([0.025, 0.085, 0.1, 0.075])
self.addcheckbutton = Button(axaddcheck,
'Add Checkpoint',
color=buttoncolor,
hovercolor=buttoncolor)
self.addcheckbutton.on_clicked(self.add_checkpoint_button_press)
if self.add_checkpoint:
self.addcheckbutton.color = "green"
self.addcheckbutton.hovercolor = "green"
self.display.imshow(self.image, cmap="gray")
axaccept = plt.axes([0.875, 0.7, 0.1, 0.075])
self.acceptbutton = Button(axaccept,
'Accept Changes',
color=buttoncolor,
hovercolor=buttoncolor)
self.acceptbutton.on_clicked(self.accept)
if self.clone.accepted:
self.acceptbutton.color = "blue"
self.acceptbutton.hovercolor = "blue"
axmodified = plt.axes([0.875, 0.6, 0.1, 0.075])
self.modifiedbutton = Button(axmodified,
'Mark as Modified',
color=buttoncolor,
hovercolor=buttoncolor)
self.modifiedbutton.on_clicked(self.modified_clicked)
if self.clone.modified:
self.modifiedbutton.color = "blue"
self.modifiedbutton.hovercolor = "blue"
axmask = plt.axes([0.025, 0.185, 0.05, 0.075])
self.maskbutton = Button(axmask,
'Mask',
color=buttoncolor,
hovercolor=buttoncolor)
self.maskbutton.on_clicked(self.mask)
axunmask = plt.axes([0.075, 0.185, 0.05, 0.075])
self.unmaskbutton = Button(axunmask,
'Unmask',
color=buttoncolor,
hovercolor=buttoncolor)
self.unmaskbutton.on_clicked(self.unmask)
if self.mask_clicked:
self.maskbutton.color = "green"
self.maskbutton.hovercolor = "green"
if self.unmask_clicked:
self.unmaskbutton.color = "green"
self.unmaskbutton.hovercolor = "green"
if self.show_dorsal_edge:
try:
self.display.scatter(self.de[:, 1], self.de[:, 0], c="blue")
except TypeError:
pass
if self.edges:
checkpoint_color = "yellow"
else:
checkpoint_color = "black"
try:
self.display.scatter(self.checkpoints[:, 1],
self.checkpoints[:, 0],
c=checkpoint_color)
except TypeError:
pass
self.display.scatter(self.clone.tail_tip[1],
self.clone.tail_tip[0],
c='red')
self.display.text(self.clone.tail_tip[1],
self.clone.tail_tip[0],
'tail_tip',
color='red')
self.display.scatter(self.clone.tail[1], self.clone.tail[0], c='red')
self.display.text(self.clone.tail[1],
self.clone.tail[0],
'tail',
color='red')
self.display.axis('off')
self.display.set_title(self.clone.filepath, color="black")
self.display.figure.canvas.draw()
def get_closest_checkpoint(self, x, y, n=1):
# finds the closest dorsal checkpoint to a given point
#
# input: x, y - x and y coordinates of a point
self.selected = self.checkpoints[
np.argsort(np.linalg.norm(self.checkpoints -
(x, y), axis=1))[0:n], :]
if n == 1:
self.selected = self.selected[0]
if self.clone.dist((x, y), self.selected) > self.clone.dist(
(x, y), self.clone.tail_tip):
if self.clone.dist(
(x, y), self.clone.tail_tip) > self.clone.dist(
(x, y), self.clone.tail):
self.selected = self.clone.tail
else:
self.selected = self.clone.tail_tip
elif self.clone.dist((x, y), self.selected) > self.clone.dist(
(x, y), self.clone.tail):
if self.clone.dist(
(x, y), self.clone.tail_tip) < self.clone.dist(
(x, y), self.clone.tail):
self.selected = self.clone.tail_tip
else:
self.selected = self.clone.tail
def set_closest_checkpoint(self, x, y):
# finds closest checkpoint to x,y
#
# input: x,y - given point
# if x,y is close enough to tail_tip, assume user
# wants to set the tail tip and update
if self.clone.dist(self.selected, self.clone.tail_tip) < 0.0001:
self.clone.tail_tip = (x, y)
self.clone.get_tail_spine_length(
) # calculate new tail_spine_length
# if x,y is close enough to tail point, assume user
# wants to set the tail point and update
elif self.clone.dist(self.selected, self.clone.tail) < 0.0001:
self.clone.tail = (x, y)
self.clone.get_tail_spine_length()
self.clone.get_animal_length()
else:
val = self.checkpoints[np.argmin(
np.linalg.norm(self.checkpoints - self.selected, axis=1)), :]
self.checkpoints[np.argmin(
np.linalg.norm(self.checkpoints -
self.selected, axis=1)), :] = (x, y)
self.do_fit_dorsal = True
def insert_new_checkpoint(self, x, y):
# inserts a new checkpoint at x,y
idx1 = np.argwhere(self.checkpoints == self.selected[0])[0][0]
idx2 = np.argwhere(self.checkpoints == self.selected[1])[0][0]
x = int(x)
y = int(y)
if (np.min([idx1, idx2])
== 0) and (np.dot(self.checkpoints[0, :] - np.array(
(x, y)), self.checkpoints[1, :] - np.array((x, y))) > 0):
self.checkpoints = np.vstack([(x, y), self.checkpoints])
self.clone.head = (x, y)
elif (np.max([idx1, idx2]) == len(self.checkpoints) -
1) and (np.dot(self.checkpoints[-1, :] - np.array(
(x, y)), self.checkpoints[-2, :] - np.array((x, y))) > 0):
self.checkpoints = np.vstack([self.checkpoints, (x, y)])
self.clone.tail_dorsal = np.array((x, y))
else:
self.checkpoints = np.vstack([
self.checkpoints[0:np.min([idx1, idx2]) + 1, :], (x, y),
self.checkpoints[np.max([idx1, idx2]):]
])
def delete_selected_checkpoint(self, event):
# removes the selected checkpoint from the list
if self.selected is not None:
self.checkpoints = np.delete(self.checkpoints,
np.argmin(
np.linalg.norm(self.checkpoints -
self.selected,
axis=1)),
axis=0)
self.clone.checkpoints = self.checkpoints
self.fit_dorsal()
self.selected = None
self.draw()
def toggle_dorsal_button_press(self, event):
self.show_dorsal_edge = not self.show_dorsal_edge
self.draw()
def add_checkpoint_button_press(self, event):
self.add_checkpoint = not self.add_checkpoint
self.draw()
def accept(self, event):
if self.clone.accepted == 0:
self.clone.accepted = 1
else:
self.clone.accepted = 0
self.draw()
def modified_clicked(self, event):
if self.clone.modified == 0:
self.clone.modified = 1
else:
self.clone.modified = 0
self.draw()
def lasso_then_mask(self, verts, add_to_metadata=True):
# takes arbitrary ROI given by user and masks out edge pixels
if add_to_metadata:
try:
nkeys = len(self.masked_regions.keys())
self.masked_regions[nkeys] = ('m', np.vstack(verts))
except AttributeError:
self.masked_regions[0] = ('m', np.vstack(verts))
path = Path(verts)
x, y = np.where(self.edge_image)
for i in xrange(len(x)):
if path.contains_point([y[i], x[i]]):
self.edge_image[x[i]][y[i]] = 0
self.image = self.edge_image
self.clone.initialize_dorsal_edge(self.original_image,
dorsal_edge_blur=self.edge_blur,
edges=self.edge_image)
self.fit_dorsal()
self.draw()
def mask(self, event):
self.mask_clicked = not self.mask_clicked
if self.mask_clicked:
self.unmask_clicked = False
self.lasso = LassoSelector(self.display,
onselect=self.lasso_then_mask)
self.edges = False
self.edge_button_press(1)
else:
self.lasso = 0
self.draw()
def lasso_then_unmask(self, verts, add_to_metadata=True):
if add_to_metadata:
try:
nkeys = len(self.masked_regions.keys())
self.masked_regions[nkeys] = ('u', np.vstack(verts))
except AttributeError:
self.masked_regions[0] = ('u', np.vstack(verts))
path = Path(verts)
x, y = np.where(self.original_edge_image)
for i in xrange(len(x)):
if path.contains_point([y[i], x[i]]):
self.edge_image[x[i]][y[i]] = 1
self.image = self.edge_image
self.clone.initialize_dorsal_edge(self.original_image,
dorsal_edge_blur=self.edge_blur,
edges=self.edge_image)
self.fit_dorsal()
self.draw()
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()
class SplitPrintWindow():
def __init__(self,
print_manager,
combo_prints,
hulls_df,
print_numb,
vid_panel,
invert_axes=True):
self.root = tk.Tk()
self.root.wm_title("Split the Selected Print")
self.fig = Figure(figsize=(10, 8), dpi=100)
self.canvas = FigureCanvasTkAgg(self.fig,
master=self.root) # A tk.DrawingArea.
self.canvas.draw()
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.root)
self.toolbar.update()
self.canvas._tkcanvas.pack(side=tk.TOP, fill=tk.BOTH, expand=1)
self.print_manager = print_manager
self.combo_prints = combo_prints
self.print_numb = print_numb
self.first_frame = self.combo_prints.first_frame[print_numb]
n_frames = (self.combo_prints.last_frame[print_numb] -
self.first_frame) + 1
grid_size = int(np.ceil(np.sqrt(n_frames)))
self.axes = []
self.fig.set_size_inches(16, 9)
button_axes = self.fig.add_axes([.01, .01, .05, .05])
self.button = Button(button_axes, 'Split')
self.button.on_clicked(self.create_new_hulls)
these_hulls = hulls_df[hulls_df.print_numb == print_numb]
self.collections = {}
self.xyes = {}
for i in range(0, n_frames):
ax = self.fig.add_subplot(grid_size, grid_size, i + 1)
self.axes.append(ax)
ax.set_axis_off()
frame = vid_panel.get_frame(self.first_frame + i)
X = self.combo_prints.X[print_numb]
Y = self.combo_prints.Y[print_numb]
ax.imshow(frame)
xes = []
yes = []
for c in (these_hulls.contours[these_hulls.frame ==
self.first_frame + i].values[0]):
#add all to a single list to make one collection
xes = xes + list(c[:, 0, 0])
yes = yes + list(c[:, 0, 1])
self.collections[ax] = ax.scatter(xes, yes)
self.xyes[ax] = self.collections[ax].get_offsets()
#set it to have list of facecolors so that selection works
facecolors = self.collections[ax].get_facecolors()
npts = len(self.xyes[ax])
facecolors = np.tile(facecolors, npts).reshape(npts, -1)
self.collections[ax].set_facecolor(facecolors)
if invert_axes:
ax.set_xlim(X + 50, X - 50)
else:
ax.set_xlim(X - 50, X + 50)
ax.set_ylim(Y - 50, Y + 50)
ax.set_title('Frame ' + str(self.first_frame + i))
self.axes = np.asarray(self.axes)
self.cid = self.canvas.mpl_connect('button_press_event', self.onpress)
self.canvas.draw()
tk.mainloop()
def create_new_hulls(self, event):
new_hull_points = []
old_hull_points = []
frame = []
if (sys.version_info > (3, 0)):
iterab = self.collections.items()
else:
iterab = self.collections.iteritems()
for ax, collection in iterab:
#make np array of bools with whether color matches the selection color for each point
inds = np.asarray([
True if np.array_equal(i, [.4, .4, .9, 1.0]) else False
for i in collection.get_facecolors()
])
#use np bool indexing to get x,y values for selected and unselected
new_hull_points.append(self.xyes[ax][inds])
old_hull_points.append(self.xyes[ax][~inds])
frame.append(self.first_frame + np.where(self.axes == ax)[0])
self.print_manager.split_print(new_hull_points, old_hull_points, frame,
self.print_numb)
self.root.destroy()
def callback(self, verts):
facecolors = self.collections[self.current_axes].get_facecolors()
p = path.Path(verts)
ind = p.contains_points(self.xyes[self.current_axes])
for i in range(len(self.xyes[self.current_axes])):
if ind[i]:
facecolors[i] = [.4, .4, .9, 1.0]
else:
facecolors[i] = [.4, .4, .2, .5]
self.collections[self.current_axes].set_facecolor(facecolors)
self.fig.canvas.draw_idle()
self.fig.canvas.widgetlock.release(self.lasso)
del self.lasso
#TODO: troubleshoot widget locks
def onpress(self, event):
if self.fig.canvas.widgetlock.locked(): return
if event.inaxes is None: return
self.current_axes = event.inaxes
self.lasso = Lasso(event.inaxes, (event.xdata, event.ydata),
self.callback)
# acquire a lock on the widget drawing
self.fig.canvas.widgetlock(self.lasso)
def Start(self, even):
if self.flag == False:
self.flag = True
t = Thread(target=self.TheadStart)
t.start()
def Stop(self, even):
self.flag = False
#设置按钮
callback = ButtonHandler()
button_point = plt.axes([0.7, 0.05, 0.1, 0.075])
button_start = Button(button_point, '开始')
button_start.on_clicked(callback.Start)
button_point = plt.axes([0.81, 0.05, 0.1, 0.075])
button_stop = Button(button_point, '暂停')
button_stop.on_clicked(callback.Stop)
# def th():
# while True:
# sleep(1)
# button_time.label = str(datetime.datetime.now())
# button_time.ax.figure.c
# # fig.draw()
#
# t_pre= Thread(target=th)
# t_pre.start()
class gyro_ui(object):
'''Classe pour interface graphique de visualisation des données de remuage
'''
format_date = "%d %b %Y %H:%M:%S"
date_formatter = mdates.DateFormatter("%d %b") # For axis
#date_formatter = ticker.FormatStrFormatter('%d %b') # for axis
ratio_gyro = 131.0 #Gyro : 1/131 degrés/secondes
ratio_acceleration = 16384.0 #Acceleration : 1/16384 g (g=9.81 N.s-2)
seuil_gyro_mvt = 200.0 / 131.0 #Seuil au delà duquel une vitesse angulaire est considéré comme un mvt
accel_detect = 1000.0 / 131.0
trig_detect = datetime.timedelta(minutes=10)
def __init__(self, bdd, images_folder=None):
'''Initialisation
- bdd : base de données gyro_db
'''
self.bdd = bdd
self.dates = []
self.acc_Xs = []
self.acc_Ys = []
self.acc_Zs = []
self.gyro_Xs = []
self.gyro_Ys = []
self.gyro_Zs = []
self.angle_Xs = []
self.angle_Ys = []
#self.angle_Zs = []
self.angle_X = 0
self.angle_Y = 0
self.angle_Z = 0
self.lecture_donnees()
self.scan_images(images_folder)
self.fig = plt.figure()
self.fig.canvas.set_window_title('Fileurope - CMP - FGYRO')
self.init_graphes()
self.lecture = False
self.th_lecture_image = None
self.vitesse_lecture = 1
def run(self):
'''Run the ui
'''
plt.show()
def lecture_donnees(self):
'''lecture de la base de données et correction des données
'''
logging.info('Lecture des donnees')
for data in self.bdd.mesures():
try:
self.dates.append(gyro_db.utc_to_local(data['date']))
self.acc_Xs.append(data['acc_X'] / gyro_ui.ratio_acceleration)
self.acc_Ys.append(data['acc_Y'] / gyro_ui.ratio_acceleration)
self.acc_Zs.append(data['acc_Z'] / gyro_ui.ratio_acceleration)
self.gyro_Xs.append(data['gyro_X'] / gyro_ui.ratio_gyro)
self.gyro_Ys.append(data['gyro_Y'] / gyro_ui.ratio_gyro)
self.gyro_Zs.append(data['gyro_Z'] / gyro_ui.ratio_gyro)
###Calculs angulaires
# Accélération totale : c'est la pesanteur
acc = sqrt(data['acc_X']**2 + data['acc_Y']**2 +
data['acc_Z']**2)
#Rotation autour de l'axe de la bouteille (c'est le roulis)
self.angle_Xs.append(asin(data['acc_Z'] / acc) * 180 / pi)
#Inclinaison de la bouteille vers le bas (c'est le tanguage)
self.angle_Ys.append(acos(data['acc_X'] / acc) * 180 / pi)
#self.angle_Zs.append(0)
except Exception as e:
print(e)
logging.info("%s mesures trouvees." % (len(self.dates)))
#Moyenne des vitesses angulaires pour auto-calibration
try:
corr_gyro_Xs = sum(self.gyro_Xs) / len(self.gyro_Xs)
except:
corr_gyro_Xs = 0
try:
corr_gyro_Ys = sum(self.gyro_Ys) / len(self.gyro_Ys)
except:
corr_gyro_Ys = 0
try:
corr_gyro_Zs = sum(self.gyro_Zs) / len(self.gyro_Zs)
except:
corr_gyro_Zs = 0
logging.info(
"Correction des moyennes des vitesses angulaires : x:%s, y:%s, z:%s"
% (corr_gyro_Xs, corr_gyro_Ys, corr_gyro_Zs))
nb_supp_mesures_angle = 0
for i in range(len(self.dates)):
#Correction des vitesses angulaires
self.gyro_Xs[i] -= corr_gyro_Xs
self.gyro_Ys[i] -= corr_gyro_Ys
self.gyro_Zs[i] -= corr_gyro_Zs
# "Suppression" des mesures d'angle quand il y a une vitesses angulaire
if i > 0 and (abs(self.gyro_Xs[i]) > gyro_ui.seuil_gyro_mvt
or abs(self.gyro_Ys[i]) > gyro_ui.seuil_gyro_mvt
or abs(self.gyro_Zs[i]) > gyro_ui.seuil_gyro_mvt):
self.angle_Xs[i] = self.angle_Xs[i - 1]
self.angle_Ys[i] = self.angle_Ys[i - 1]
#self.angle_Zs[i] = self.angle_Zs[i-1]
nb_supp_mesures_angle += 1
logging.info("%s mesures d'angle supprimees" % nb_supp_mesures_angle)
# Recherche des phases
self.phases = [] # Un enregistrement par phase
self.etapes = [] # A chaque point, la phase correspondante
i = 0
while i < len(self.dates):
acceleration = sqrt(self.gyro_Xs[i]**2 + self.gyro_Ys[i]**2 +
self.gyro_Zs[i]**2)
if acceleration > gyro_ui.accel_detect:
acceleration_max = acceleration
date_debut_mouvement = self.dates[i]
date_fin_mouvement = date_debut_mouvement
date_fin_trig = date_debut_mouvement + gyro_ui.trig_detect
while self.dates[i] < date_fin_trig:
acceleration = sqrt(self.gyro_Xs[i]**2 +
self.gyro_Ys[i]**2 +
self.gyro_Zs[i]**2)
acceleration_max = max(acceleration_max, acceleration)
if acceleration > gyro_ui.accel_detect:
date_fin_phase = self.dates[i]
i += 1
self.phases.append({
'debut_mvt': date_debut_mouvement,
'fin_mvt': date_fin_mouvement,
'acceleration_max': acceleration_max
})
logging.info("Phase detectee : no %s : debut = %s, fin = %s" %
(len(self.phases), date_debut_mouvement,
date_fin_mouvement))
else:
i += 1
self.etapes.append(len(self.phases))
self.export_xls()
def export_xls(self, filename=None):
'''Exporte les données vers un fichier excel
'''
#TODO mettre menu dans interface
if filename is None:
filename = "gyro.xlsx"
import xlsxwriter
workbook = xlsxwriter.Workbook(filename)
worksheet = workbook.add_worksheet("phases")
format_date = workbook.add_format({'num_format': 'dd/mm/yy hh:mm:ss'})
col = 0
for key in self.phases[0]:
row = 0
worksheet.write(row, col, key)
row += 1
for item in self.phases:
if "date" in key:
worksheet.write_datetime(row, col,
self.phases[row - 1][key],
format_date)
else:
worksheet.write(row, col, self.phases[row - 1][key])
row += 1
col += 1
workbook.close()
def init_graphes(self):
''' Inititialise les graphiques
'''
### IMAGE REMUTRACE
image_capteur = plt.imread('capteur.png')
self.image_capteur_plot = self.fig.add_subplot(233)
self.image_capteur_plot.set_axis_off()
self.image_capteur_plot.imshow(image_capteur)
### 3D (non implementé)
#self.3D = figure3D().add_subplot(233)
#self.3D = self.fig.add_subplot(233)
### GRAPHE XYZ
#self.xyz=self.fig.add_subplot(231)
#self.xyz.set_xlabel('Temps')
#self.xyz.set_ylabel('x,y,z')
#self.xyz.plot(self.dates, self.acc_Xs, label='acc_X')
#self.xyz.plot(self.dates, self.acc_Ys, label='acc_Y')
#self.xyz.plot(self.dates, self.acc_Zs, label='acc_Z')
#self.xyz.legend()
#self.xyz_line = False
### GRAPHE GxGyGz
self.GxGyGz = self.fig.add_subplot(231) #, sharex = self.xyz)
self.GxGyGz.set_title(u'Vitesse angulaire')
self.GxGyGz.set_xlabel(u'Temps')
self.GxGyGz.set_ylabel(u'Deg/s')
self.GxGyGz.plot(self.dates, self.gyro_Xs, label='gyro_X')
self.GxGyGz.plot(self.dates, self.gyro_Ys, label='gyro_Y')
self.GxGyGz.plot(self.dates, self.gyro_Zs, label='gyro_Z')
#self.GxGyGz.set_xticks(self.dates)
self.GxGyGz.xaxis.set_major_locator(mdates.DayLocator())
#self.GxGyGz.xaxis.set_minor_locator(mdates.HourLocator())
self.GxGyGz.xaxis.set_major_formatter(
ticker.FormatStrFormatter("%d %b"))
self.GxGyGz.legend()
self.GxGyGz_line = False
#self.fig.autofmt_xdate()
#plt.xticks(rotation=90)
logging.debug("GRAPHE GxGyGz ok")
### GRAPHE INCLINAISON
self.Inclinaison = self.fig.add_subplot(234, sharex=self.GxGyGz)
self.Inclinaison.plot(self.dates, self.angle_Ys, label='Inclinaison')
#self.Inclinaison.legend()
self.Inclinaison.set_title(u'Inclinaison')
self.Inclinaison.set_xlabel(u'Temps')
self.Inclinaison.set_ylabel(u'Deg')
self.Inclinaison_line = False
### GRAPHE ROTATION
self.Rotation = self.fig.add_subplot(235, sharex=self.GxGyGz)
self.Rotation.plot(self.dates, self.angle_Xs, label='Rotation')
#self.Rotation.legend()
self.Rotation.set_title(u'Rotation')
self.Rotation.set_xlabel(u'Temps')
self.Rotation.set_ylabel(u'Deg')
self.Rotation_line = False
### PHOTO
self.image_plot = self.fig.add_subplot(232)
self.image_plot.set_axis_off()
self.image_plot.set_title(u'Caméra')
### BOUTONS
self.fig.canvas.mpl_connect('button_press_event', self.on_click)
self.bt_lecture = Button(plt.axes([0.65, 0.3, 0.05, 0.03]), 'lecture')
self.bt_lecture.on_clicked(self.on_bt_lecture_click)
self.bt_lecture10 = Button(plt.axes([0.65, 0.2, 0.05, 0.03]),
'lecturex10')
self.bt_lecture10.on_clicked(self.on_bt_lecture_click10)
#self.tb_vitesse = TextBox(plt.axes([0.9, 0.8, 0.05, 0.03]),'Vitesse', initial = '1')
#self.tb_vitesse.on_submit(self.on_tb_vitesse_submit)
### Détail étape
axe_etape = self.fig.add_axes([0.65, 0.4, 0.03, 0.03])
axe_etape.set_axis_off()
self.etape = plt.text(0, 3, u'Etape n° ?')
self.etape_debut_mvt = plt.text(0, 2, u'Début : --')
self.etape_fin_mvt = plt.text(0, 1, u'Fin : --')
self.etape_acceleration_max = plt.text(0, 0, u'Accélération max : --')
### LEGENDE : FILEUROPE-CMP
legende = self.fig.add_axes([0.75, 0.07, 0.2, 0.3])
legende.set_axis_off()
#rect = Rectangle((0,0),1,1,fill=True, color= 'blue')
#legende.add_patch(rect)
logo_img = plt.imread('logo.png')
legende.imshow(logo_img)
text_legende = plt.text(0.05, 0.05, u"Remutrace - Brevet déposé.")
self.fig.canvas.mpl_connect('key_press_event', self.press)
def scan_images(self, rep):
'''Scan le repertoire des images
et peuble le dict self.images : {date:nom_fichier _image}
'''
#logging.info("Scan du repertoir images : %s ..."%(rep))
self.images = {}
self.images_dates = {}
if rep:
for fichier in os.listdir(rep):
if os.path.isfile(os.path.join(rep, fichier)):
try:
self.images[datetime.datetime.strptime(
fichier[3:-4],
"%Y-%m-%d %H-%M-%S.%f")] = os.path.join(
rep, fichier)
except:
pass
self.images_dates = self.images.keys()
self.images_dates.sort()
logging.info("%s images trouvees." % (len(self.images)))
self.xdate_index = 0
def show_image(self):
'''Update the image and the cursors and the etape
'''
if len(self.images) > 0:
date = self.images_dates[self.xdate_index]
image_path = self.images[date]
#logging.debug("Image %s"%(image_path))
image_file = cbook.get_sample_data(image_path)
image = plt.imread(image_file)
self.image_plot.clear()
self.image_plot.set_axis_off()
self.image_plot.imshow(image)
self.image_plot.set_title(u'Caméra')
self.image_plot.text(
0, 800, "Date : " +
self.dates[self.xdate_index].strftime(gyro_ui.format_date))
if self.GxGyGz_line:
self.GxGyGz_line.remove()
self.GxGyGz_line = self.GxGyGz.vlines(
date,
self.GxGyGz.get_ylim()[0] * 0.75,
self.GxGyGz.get_ylim()[1] * 0.75)
if self.Inclinaison_line:
self.Inclinaison_line.remove()
self.Inclinaison_line = self.Inclinaison.vlines(
date,
self.Inclinaison.get_ylim()[0] * 0.75,
self.Inclinaison.get_ylim()[1] * 0.75)
if self.Rotation_line:
self.Rotation_line.remove()
self.Rotation_line = self.Rotation.vlines(
date,
self.Rotation.get_ylim()[0] * 0.75,
self.Rotation.get_ylim()[1] * 0.75)
etape = self.etapes[self.xdate_index]
self.etape.set_text(u"Etape n° %s" % etape)
self.etape_debut_mvt.set_text(
u"Début : " +
self.phases[etape]["debut_mvt"].strftime(gyro_ui.format_date))
self.etape_fin_mvt.set_text(
u"Fin : " +
self.phases[etape]["fin_mvt"].strftime(gyro_ui.format_date))
self.etape_acceleration_max.set_text(
u"Accél. max : %s" % self.phases[etape]["acceleration_max"])
# TODO et plus d'info
self.fig.canvas.draw() # C'est ici que c'est long (0.3 s)
def on_click(self, event):
'''callback function when click on graphe
'''
#logging.debug('button=%d, inaxes = %s, x=%d, y=%d, xdata=%f, ydata=%f' %(event.button, event.inaxes, event.x, event.y, event.xdata, event.ydata))
if len(self.images) > 0:
if event.inaxes in [self.GxGyGz, self.Inclinaison, self.Rotation]:
date = mdates.num2date(event.xdata).replace(tzinfo=None)
#try:
self.xdate_index = self.images_dates.index(
min(self.images_dates, key=lambda d: abs(d - date)))
logging.debug(self.xdate_index)
self.show_image()
# except:
# pass
# Attention : bricolage+++
def on_bt_lecture_click10(self, event):
self.vitesse_lecture = 10
self.on_bt_lecture_click_all(event)
def on_bt_lecture_click(self, event):
'''
'''
self.vitesse_lecture = 1
self.on_bt_lecture_click_all(event)
def on_bt_lecture_click_all(self, event):
if self.lecture:
self.lecture = False
self.bt_lecture.Label = matplotlib_text.Text(text='lecture')
logging.info("Pause")
self.th_lecture_image.stop()
self.fig.canvas.draw()
else:
self.lecture = True
self.bt_lecture.Label = matplotlib_text.Text(text='pause')
logging.info("Lecture")
self.fig.canvas.draw()
self.th_lecture_image = f_thread(self.lecture_images)
self.th_lecture_image.start()
# Fin du bricolage
def lecture_images(self, sens=1):
''' affichage de l'image suivante
Utilisation : en threading : f_thread(self.lecture_images)
'''
self.xdate_index += sens * self.vitesse_lecture
if self.xdate_index > len(self.images_dates):
self.xdate_index = 0
self.lecture = False
self.show_image()
time.sleep(0.05) #Pour donner la main à l'affichage
def press(self, event):
''' Quand une fleche droite ou gauche est appuyée : image suivante ou précédente
'''
print("Key pressed : " + event.key)
sys.stdout.flush()
if event.key == "down":
self.lecture_images(1)
elif event.key == "up":
self.lecture_images(-1)
elif event.key == "pagedown":
self.lecture_images(10)
elif event.key == "pageup":
self.lecture_images(-10)
def on_tb_vitesse_submit(self, text):
''' quand changement vitesse de lecture
'''
try:
self.vitesse_lecture = int(text)
except:
pass
def show():
depthmap.process(plt, input, depth[index], 0) #rgb[index])
if edges == 1:
depthmap.showEdges()
else:
depthmap.showResult()
ax = plt.gca()
ax.text(0.5,
1.075,
depth[index],
horizontalalignment='center',
verticalalignment='center',
transform=ax.transAxes)
bprev = Button(plt.axes([0.0, 0.0, 0.1, 0.075]), '<<', color='gray')
bprev.on_clicked(prev)
bnext = Button(plt.axes([0.9, 0.0, 0.1, 0.075]), '>>', color='gray')
bnext.on_clicked(next)
bexportOBJ = Button(plt.axes([0.2, 0.0, 0.2, 0.05]),
'Export OBJ',
color='gray')
bexportOBJ.on_clicked(exportOBJ)
bexportPCD = Button(plt.axes([0.4, 0.0, 0.2, 0.05]),
'Export PCD',
color='gray')
bexportPCD.on_clicked(exportPCD)
bconvertPCDs = Button(plt.axes([0.6, 0.0, 0.2, 0.05]),
'Convert all PCDs',
color='gray')
bconvertPCDs.on_clicked(convertAllPCDs)
if edges == 0:
bshowedges = Button(plt.axes([0.0, 0.94, 0.2, 0.05]),
'Show edges',
color='gray')
bshowedges.on_clicked(swapEdges)
else:
bshowedges = Button(plt.axes([0.0, 0.94, 0.2, 0.05]),
'Hide edges',
color='gray')
bshowedges.on_clicked(swapEdges)
plt.show()
def drawPeople(P=[]):
plt.clf() #清除数据
drawFile() #绘制高斯函数
drawSecondFile()
R_x = [] #向右移动的行人的x坐标
R_y = [] #y坐标
L_x = [] #向左移动的行人的x坐标
L_y = [] #y坐标
G_x_r = []
G_y_r = []
G_x_l = []
G_y_l = []
G_x = []
G_y = []
de_x = []
de_y = []
for p in P: #遍历行人列表
if p.logo == Data.LOGO_PEOPLE: #此行可以省略？
if p.debug == 1:
de_x.append(p.x)
de_y.append(p.y)
else:
if p.isInGrend:
if p.isNewDefine == 1:
G_x_r.append(p.x)
G_y_r.append(p.y)
elif p.isNewDefine == 2:
G_x_l.append(p.x)
G_y_l.append(p.y)
else:
G_x.append(p.x)
G_y.append(p.y)
else:
if p.type: #如果行人方向为 【右】
R_x.append(p.x) #添加x坐标
R_y.append(p.y) #添加y坐标
else: #如果行人方向为【左】
L_x.append(p.x)
L_y.append(p.y)
# R_x.append(p[0])
# R_y.append(p[1])
# plt.figure(figsize=(10,6))
plt.subplot(1, 1, 1) #绘图板布局 不知道怎么取消这一行
plt.scatter(G_x_r, G_y_r, c='k', marker='<')
plt.scatter(G_x_l, G_y_l, c='k', marker='>')
plt.scatter(G_x, G_y, c='k', marker='s')
plt.scatter(de_x, de_y, c='b', marker='D')
plt.scatter(R_x, R_y, c='r', marker='<') #绘制行人--散点图
plt.scatter(L_x, L_y, c='b', marker='>')
drawWallAndExit() #绘制墙壁和出口
# plt.show()
'''由于无法右上角关闭 加了个关闭按钮'''
closeFig = plt.axes([0.8, 0.025, 0.1, 0.04]) #关闭按钮
closeFigbutton = Button(closeFig, 'close', hovercolor='0.5') #按钮样式
closeFigbutton.on_clicked(closeFigure) #按钮按下去的动作
#-------------------------------------------------
pauseFig = plt.axes([0.2, 0.025, 0.1, 0.04])
pauseFigbutton = Button(pauseFig, 'pause', hovercolor='0.5')
pauseFigbutton.on_clicked(pauseFigure)
# ---------------------------------------------------
pauseResFig = plt.axes([0.6, 0.025, 0.1, 0.04])
pauseFigResbutton = Button(pauseResFig, 'res', hovercolor='0.5')
pauseFigResbutton.on_clicked(pauseResFigure)
# ---------------------------------------------------
while Data.figure_pause:
plt.pause(1) # 暂停1s
plt.pause(1) #暂停1s
sd = Slider(axd, r'$d/\lambda$', 0., 10., valinit=d0)
st0 = Slider(axt, r'$(d/\lambda)\,\theta_0$', 0., 2., valinit=t00)
# Update plot using slider data
def update(val):
d = sd.val
t0 = st0.val
l.set_ydata(2. * np.cos(np.pi * d * np.sin(t * np.pi)) *
np.cos(np.pi * d * np.sin(t * np.pi)) * np.sinc(0.5 * t0) *
np.sinc(0.5 * t0))
fig.canvas.draw_idle()
sd.on_changed(update)
st0.on_changed(update)
# Generate reset button
resetax = plt.axes([0.8, 0.02, 0.1, 0.04])
button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
def reset(event):
sd.reset()
st0.reset()
button.on_clicked(reset)
plt.show()
class Animation:
"""The foundation of all animations.
Parameters
----------
blocks : list of animatplot.animations.Block
A list of blocks to be animated
timeline : Timeline or 1D array, optional
If an array is passed in, it will be converted to a Timeline.
If not given, a timeline will be created using the length of the
first block.
fig : matplotlib figure, optional
The figure that the animation is to occur on
Attributes
----------
animation
a matplotlib animation returned from FuncAnimation
"""
def __init__(self, blocks, timeline=None, fig=None):
if timeline is None:
self.timeline = Timeline(range(len(blocks[0])))
elif not isinstance(timeline, Timeline):
self.timeline = Timeline(timeline)
else:
self.timeline = timeline
_len_time = len(self.timeline)
for block in blocks:
if len(block) != _len_time:
raise ValueError(
"All blocks must animate for the same amount of time")
self.blocks = blocks
self.fig = plt.gcf() if fig is None else fig
self._has_slider = False
self._pause = False
def animate(i):
updates = []
for block in self.blocks:
updates.append(block._update(self.timeline.index))
if self._has_slider:
self.slider.set_val(self.timeline.index)
self.timeline._update()
return updates
self.animation = FuncAnimation(self.fig,
animate,
frames=self.timeline._len,
interval=1000 / self.timeline.fps)
def toggle(self, axis=None):
"""Creates a play/pause button to start/stop the animation
Parameters
----------
axis : optional
A matplotlib axis to attach the button to.
"""
if axis is None:
adjust_plot = {'bottom': .2}
rect = [.78, .03, .1, .07]
plt.subplots_adjust(**adjust_plot)
self.button_ax = plt.axes(rect)
else:
self.button_ax = axis
self.button = Button(self.button_ax, "Pause")
self.button.label2 = self.button_ax.text(
0.5,
0.5,
'Play',
verticalalignment='center',
horizontalalignment='center',
transform=self.button_ax.transAxes)
self.button.label2.set_visible(False)
def pause(event):
if self._pause:
self.animation.event_source.start()
self.button.label.set_visible(True)
self.button.label2.set_visible(False)
else:
self.animation.event_source.stop()
self.button.label.set_visible(False)
self.button.label2.set_visible(True)
self.fig.canvas.draw()
self._pause ^= True
self.button.on_clicked(pause)
def timeline_slider(self,
text='Time',
axis=None,
valfmt='%1.2f',
color=None):
"""Creates a timeline slider.
Parameters
----------
text : str, optional
The text to display for the slider. Defaults to 'Time'
axis : optional
A matplotlib axis to attach the slider to
valfmt : str, optional
a format specifier used to print the time
Defaults to '%1.2f'
color :
The color of the slider.
"""
if axis is None:
adjust_plot = {'bottom': .2}
rect = [.18, .05, .5, .03]
plt.subplots_adjust(**adjust_plot)
self.slider_ax = plt.axes(rect)
else:
self.slider_ax = axis
if self.timeline.log:
valfmt = '$10^{%s}$' % valfmt
self.slider = Slider(self.slider_ax,
text,
0,
self.timeline._len - 1,
valinit=0,
valfmt=(valfmt + self.timeline.units),
valstep=1,
color=color)
self._has_slider = True
def set_time(t):
self.timeline.index = int(self.slider.val)
self.slider.valtext.set_text(self.slider.valfmt %
(self.timeline[self.timeline.index]))
if self._pause:
for block in self.blocks:
block._update(self.timeline.index)
self.fig.canvas.draw()
self.slider.on_changed(set_time)
def controls(self, timeline_slider_args={}, toggle_args={}):
"""Creates interactive controls for the animation
Creates both a play/pause button, and a time slider at once
Parameters
----------
timeline_slider_args : Dict, optional
A dictionary of arguments to be passed to timeline_slider()
toggle_args : Dict, optional
A dictionary of argyments to be passed to toggle()
"""
self.timeline_slider(**timeline_slider_args)
self.toggle(**toggle_args)
def save_gif(self, filename):
"""Saves the animation to a gif
A convience function. Provided to let the user avoid dealing
with writers.
Parameters
----------
filename : str
the name of the file to be created without the file extension
"""
self.timeline.index -= 1 # required for proper starting point for save
self.animation.save(filename + '.gif',
writer=PillowWriter(fps=self.timeline.fps))
def save(self, *args, **kwargs):
"""Saves an animation
A wrapper around :meth:`matplotlib.animation.Animation.save`
"""
self.timeline.index -= 1 # required for proper starting point for save
self.animation.save(*args, **kwargs)
ax[0].set_ylabel('Local Time')
ax[0].yaxis_date()
ax[0].yaxis.set_major_formatter(date_format)
cbar_ax = f.add_axes([0.85, 0.15, 0.05, 0.7])
c = f.colorbar(p[0], cax=cbar_ax)
c.set_label('Power (dB, arbitrary)')
from matplotlib.widgets import Slider, Button
rax = plt.axes([0.82, 0.03, 0.15, 0.04])
check = Button(rax, 'Med Subtract')
def func(event):
global medsub, check, colorscale
medsub = not medsub
if medsub:
check.label.set_text("Med Subtracted")
colorscale = [-0.5, 0.5]
else:
check.label.set_text("Raw Power")
colorscale = [-10, 10]
check.on_clicked(func)
ani = animation.FuncAnimation(f, updatefig, frames=100, interval=100)
f.show()
def held_karp(dists):
"""
Implementation of Held-Karp, an algorithm that solves the Traveling
Salesman Problem using dynamic programming with memoization.
Parameters:
dists: distance matrix
Returns:
A tuple, (cost, path).
"""
n = len(dists)
C = {}
for k in range(1, n):
C[(1 << k, k)] = (dists[0][k], 0)
for subset_size in range(2, n):
for subset in itertools.combinations(range(1, n), subset_size):
# Set bits for all nodes in this subset
bits = 0
for bit in subset:
bits |= 1 << bit
# Find the lowest cost to get to this subset
for k in subset:
prev = bits & ~(1 << k)
res = []
for m in subset:
if m == 0 or m == k:
continue
res.append((C[(prev, m)][0] + dists[m][k], m))
C[(bits, k)] = min(res)
bits = (2**n - 1) - 1
res = []
for k in range(1, n):
res.append((C[(bits, k)][0] + dists[k][0], k))
opt, parent = min(res)
path = []
for i in range(n - 1):
path.append(parent)
new_bits = bits & ~(1 << parent)
_, parent = C[(bits, parent)]
bits = new_bits
path.append(0)
return opt, list(reversed(path))
def solve(event):
global n, trucks, solver, li, ax, warehouses, loc_x, loc_y, lines_x, lines_y, obj_value, exec_value
global distances, distances2
print("solving...")
ax.clear()
ax.set_xlim(0,1000)
ax.set_ylim(0,1000)
plot_data(ax, loc_x, loc_y, warehouses)
ax.text(400, 1075, "solving...", family="serif", horizontalalignment='left', verticalalignment='top')
plt.draw()
fig.canvas.draw()
start_time = time.time()
# Calculate constraint for Li
total_l = 0
total_c = 0.0
paths = 0
slack = False
while total_c < n or paths < trucks:
c1 = min(c,n)
total_c += c1
total_l += c1*(c1+1)/2
paths += 1
if total_c > n:
slack = True
if solver=="cbc" or solver=="glpk" or solver=="gurobi":
# Objective function
z = pulp.LpProblem('Test', pulp.LpMinimize)
# Generate decision variables
x = {}
y = {}
variables = []
l = {}
s = {}
for i in range(n+warehouses):
for j in range(n+warehouses):
if i==j:
continue
x[i,j] = pulp.LpVariable('x_' + str(i) + '_' + str(j), 0, 1, pulp.LpInteger)
if i >= warehouses:
l[i] = pulp.LpVariable('l_' + str(i), 1, min(n,c), pulp.LpInteger)
# Objective function
z += pulp.lpSum([distances[i][j] * x[i,j] for i in range(n+warehouses) for j in
list(range(i)) + list(range(i+1,n+warehouses))])
# Constraints
constraintSeq = []
constraintTrucks = []
for i in range(n+warehouses):
if i>=warehouses:
constraintSeq.append(l[i])
constraintFrom = []
constraintTo = []
for j in range(n+warehouses):
if i==j:
continue
if i>=warehouses and j>=warehouses:
z += pulp.lpSum([l[i], -1*l[j], n*x[i,j], -n+1]) <= 0
if i>=warehouses:
constraintFrom.append(x[i,j])
constraintTo.append(x[j,i])
if i<warehouses:
constraintTrucks.append(x[j,i])
if i>=warehouses:
z += pulp.lpSum(constraintFrom) == 1 # paths from location
z += pulp.lpSum(constraintTo) == 1 # paths to location
if i==warehouses and (paths > 1 or warehouses>1):
z += pulp.lpSum(constraintTrucks) == paths # paths to warehouse
if not slack:
z += pulp.lpSum(constraintSeq) == total_l
else:
z += pulp.lpSum(constraintSeq) <= total_l
# Solve
if solver=="cbc":
status = z.solve()
if solver=="glpk":
status = z.solve(pulp.GLPK())
if solver=="gurobi":
status = z.solve(pulp.GUROBI_CMD())
# should be 'Optimal'
if pulp.LpStatus[status]!="Optimal":
print("RESULT: ".pulp.LpStatus[status])
print("Objective function value: "+str(z.objective.value()))
# Print variables & save path
lines_x = []
lines_y = []
li = [0] * n
for i in range(n+warehouses):
if i>=warehouses:
li[i-warehouses] = pulp.value(l[i])
for j in range(n+warehouses):
if i==j:
continue
if pulp.value(x[i,j]) == 1:
lines_x.append(loc_x[i])
lines_x.append(loc_x[j])
lines_y.append(loc_y[i])
lines_y.append(loc_y[j])
lines_x.append(np.nan)
lines_y.append(np.nan)
obj_value = "c=" + str(round(z.objective.value(),2))
elif solver=="cut plane":
model = Model("tsp")
model.hideOutput()
x = {}
l = {}
for i in range(n+warehouses):
for j in range(n+warehouses):
if i != j:
x[i,j] = model.addVar(ub=1, name="x(%s,%s)"%(i,j))
if (paths > 1 or warehouses > 1) and i >= warehouses:
l[i] = model.addVar(ub=min(c,n),lb=1, name="l(%s)"%(i))
if paths == 1 and warehouses == 1:
# SYMMETRIC DISTANCE MATRIX ONLY
#for i in range(n+warehouses):
#model.addCons(quicksum(x[j,i] for j in range(n+warehouses) if j != i) + \
# quicksum(x[i,j] for j in range(n+warehouses) if j != i) == 2,"Degree(%s)"%i)
# ASYMMETRIC DISTANCE MATRIX
for i in range(n+warehouses):
model.addCons(quicksum(x[j,i] for j in range(n+warehouses) if j != i) == 1,"In(%s)"%i)
model.addCons(quicksum(x[i,j] for j in range(n+warehouses) if j != i) == 1,"Out(%s)"%i)
else:
for i in range(warehouses, n+warehouses):
model.addCons(quicksum(x[j,i] for j in range(n+warehouses) if j != i) == 1,"In(%s)"%i)
model.addCons(quicksum(x[i,j] for j in range(n+warehouses) if j != i) == 1,"Out(%s)"%i)
for i in range(warehouses, n+warehouses):
for j in range(warehouses, n+warehouses):
if i!=j:
model.addCons(l[i] -l[j] +n*x[i,j] <= n-1, "Li(%s,%s)"%(i,j))
model.addCons(quicksum(x[j,i] for i in range(warehouses) for j in range(n+warehouses) if i!=j) == paths, "Paths(%s)"%paths)
if not slack:
model.addCons(quicksum(l[i] for i in range(warehouses,n+warehouses)) == total_l,"TotalL")
else:
model.addCons(quicksum(l[i] for i in range(warehouses,n+warehouses)) <= total_l, "TotalL")
model.setObjective(quicksum(distances2[i,j]*x[i,j] for (i,j) in x), "minimize")
EPS = 1.e-6
isMIP = False
model.setPresolve(SCIP_PARAMSETTING.OFF)
while True:
model.optimize()
#edges = []
lines_x = []
lines_y = []
edges = []
li = [0] * n
for (i,j) in x:
# i=j already skipped
if model.getVal(x[i,j]) > EPS:
#edges.append( (i,j) )
lines_x.append(loc_x[i])
lines_x.append(loc_x[j])
lines_y.append(loc_y[i])
lines_y.append(loc_y[j])
lines_x.append(np.nan)
lines_y.append(np.nan)
edges.append( (i,j) )
if paths>1 or warehouses>1:
for i in range(warehouses, n+warehouses):
li[i-warehouses] = int(model.getVal(l[i]))
obj_value = "c=" + str(round(model.getObjVal(),2))
ax.clear()
ax.set_xlim(0,1000)
ax.set_ylim(0,1000)
plot_data_lines(lines_x,lines_y)
plot_data(ax, loc_x, loc_y, warehouses)
ax.text(400, 1075, "solving...", family="serif", horizontalalignment='left', verticalalignment='top')
fig.canvas.draw()
if addcut(edges,model,x,warehouses) == False:
if isMIP: # integer variables, components connected: solution found
break
model.freeTransform()
for (i,j) in x: # all components connected, switch to integer model
model.chgVarType(x[i,j], "B")
if paths > 1 or warehouses > 1:
for i in range(warehouses,n+warehouses):
model.chgVarType(l[i], "I")
isMIP = True
sol_li = [0] * (n+warehouses)
sol_xij = {}
print('solved.')
elif solver == 'held-karp':
li = [0] * n
opt, path = held_karp(distances)
print(path)
obj_value = "c=" + str(round(opt,2))
x = [[0 for x in range(n+warehouses)] for y in range(n+warehouses)]
for idx, val in enumerate(path):
if idx < (len(path)-1):
x[val][path[idx+1]] = 1;
elif idx == (len(path)-1):
x[val][path[0]] = 1;
for i in range(n+warehouses):
for j in range(n+warehouses):
if x[i][j] == 1:
#edges.append( (i,j) )
lines_x.append(loc_x[i])
lines_x.append(loc_x[j])
lines_y.append(loc_y[i])
lines_y.append(loc_y[j])
lines_x.append(np.nan)
lines_y.append(np.nan)
#edges.append( (i,j) )
# Print computation time
time2 = time.time() - start_time
exec_value = time2
units = 'secs'
if time2 > 60:
time2 /= 60
units = 'mins'
if time2 > 60:
time2 /= 60
units = 'hours'
time2 = round(time2,2)
exec_value = "exec=" + str(time2) + " " + units
print("--- " + str(time2) + " " + units + " ---")
# Redraw points
ax.clear()
ax.set_xlim(0,1000)
ax.set_ylim(0,1000)
plot_data_lines(lines_x,lines_y)
plot_data(ax, loc_x, loc_y, warehouses)
ax.text(350, 1075, obj_value, family="serif", horizontalalignment='right', verticalalignment='top')
ax.text(450, 1075, exec_value, family="serif", horizontalalignment='left', verticalalignment='top')
fig.canvas.draw()
axsolve = plt.axes([0.87, 0.905, 0.1, 0.075])
bsolve = Button(axsolve, 'Solve')
bsolve.on_clicked(solve)
plt.show()
T = Tvals[Tind]
point.set_data(Tvals[Tind], states[Tind])
val_slider.set_val(states[Tind])
ax.set_ylim([
np.min(W.States[0:N_slider.val]) - 1,
np.max(W.States[0:N_slider.val]) + 1
])
fig.canvas.draw_idle()
N_slider.on_changed(sliders_on_changed)
t_slider.on_changed(sliders_on_changed)
# Add a button for resetting the parameters
reset_button_ax = fig.add_axes([0.8, 0.02, 0.1, 0.01])
reset_button = Button(reset_button_ax,
'Reset',
color=axis_color,
hovercolor='0.975')
def reset_button_on_clicked(mouse_event):
N_slider.reset()
reset_button.on_clicked(reset_button_on_clicked)
plt.show()
d = float(text)
except ValueError:
print("Вы пытаетесь ввести не число")
#Create graph
fig, graph_axes = plt.subplots()
graph_axes.grid()
graph_axes.set_title('Model Trays - Volterra')
fig.subplots_adjust(left=0.06, right=0.80, top=0.95, bottom=0.23)
#Create add button
axes_button_add = plt.axes([0.55, 0.01, 0.4, 0.075])
button_add = Button(axes_button_add,
'Добавить новый график',
hovercolor='#f0f0f0')
button_add.on_clicked(onButtonAddClicked)
#Create clear buttin
axes_button_clear = plt.axes([0.05, 0.01, 0.4, 0.075])
button_clear = Button(axes_button_clear,
'Очистить график',
hovercolor='#f0f0f0')
button_clear.on_clicked(onButtonClearClicked)
#Create textbox
axbox = plt.axes([0.88, 0.90, 0.10, 0.075])
x0_box = TextBox(axbox,
'Задача \n Коши \n x0 =',
initial="0.1",
hovercolor='#d9d9d9')
x0 = 0.1
# Add a time slider
if len(all_times) > 1:
axfreq = plt.axes([0.1, 0.0, 0.5, 0.03])
time_slider = Slider(axfreq, 'ix', 0., len(all_times) - 1, 0.)
time_slider.on_changed(update)
# Add buttons to go to next/previous variable and snapshot, and one to switch
# between primitive
axprev_iw = plt.axes([0.8, 0.0, 0.075, 0.05])
axnext_iw = plt.axes([0.875, 0.0, 0.075, 0.05])
axprim = plt.axes([0.95, 0.0, 0.05, 0.05])
axprev_file = plt.axes([0.0, 0.0, 0.05, 0.05])
axnext_file = plt.axes([0.7, 0.0, 0.05, 0.05])
bnext_iw = Button(axnext_iw, '+iw')
bnext_iw.on_clicked(next_var)
bprev_iw = Button(axprev_iw, '-iw')
bprev_iw.on_clicked(prev_var)
bnext_file = Button(axnext_file, '+')
bnext_file.on_clicked(next_file)
bprev_file = Button(axprev_file, '-')
bprev_file.on_clicked(prev_file)
bprim = Button(axprim, 'P/C')
bprim.on_clicked(switch_cons_prim)
# Initial state
i_var = 1
i_file = 0
is_conservative = True
line, = ax.plot(all_cons[0][:, 0], all_cons[0][:, i_var])
class Viewer:
# GUI object
def __init__(self, gui_params, params):
# loads metadata from available xls files
if gui_params['load_metadata']:
self.curation_data = utils.load_manual_curation(
params['curation_csvpath'])
self.males_list = utils.load_male_list(params['male_listpath'])
self.induction_dates = utils.load_induction_data(
params['induction_csvpath'])
self.season_data = utils.load_pond_season_data(
params['pond_season_csvpath'])
self.early_release = utils.load_release_data(
params['early_release_csvpath'])
self.late_release = utils.load_release_data(
params['late_release_csvpath'])
self.duplicate_data = utils.load_duplicate_data(
params['duplicate_csvpath'])
self.experimenter_data, self.inducer_data = utils.load_experimenter_data(
params['experimenter_csvpath'])
# loads in default params from txt files
self.gui_params = gui_params
self.params = params
self.params.update(self.gui_params)
self.auto_save_count = 0
file_list = []
metadata_list = []
print "Reading in image file list"
with open(self.params["image_list_filepath"], "rb") as f:
line = f.readline().strip()
while line:
file_list.append(line)
line = f.readline().strip()
print "Reading in analysis file"
self.data = utils.csv_to_df(self.params["input_analysis_file"])
try:
saved_data = utils.csv_to_df(self.params["output_analysis_file"])
for row in saved_data.iterrows():
i = np.where(self.data['filebase'] == row[1]['filebase'])
for k, v in row[1].iteritems():
self.data.loc[i[0], k] = v
except IOError:
pass
if not hasattr(self.data, 'accepted'):
self.data['accepted'] = np.zeros(len(self.data))
self.shape_data = utils.read_shape_long(
self.params["input_shape_file"])
try:
saved_shape_data = utils.read_shape_long(
self.params["output_shape_file"])
fbs = np.unique(saved_shape_data['filebase'])
self.shape_data = self.shape_data.drop(
self.shape_data[self.shape_data['filebase'].isin(fbs)].index)
self.shape_data = self.shape_data.append(saved_shape_data)
except IOError:
print("No output shape data")
pass
try:
self.masked_regions = utils.read_masked_regions_long(
self.params["masked_regions_output"])
except IOError:
self.masked_regions = {}
all_clone_list = []
for f in file_list:
try:
if os.name == "nt":
fileparts = f.split("\\")
else:
fileparts = f.split("/")
clone = utils.dfrow_to_clone(
self.data,
np.where(self.data.filebase == fileparts[-1])[0][0],
self.params)
clone.filepath = f
all_clone_list.append(clone)
except IndexError:
print "No entry found in datafile for " + str(f)
for i in xrange(len(all_clone_list)):
index = (self.shape_data.filebase == all_clone_list[i].filebase)
all_clone_list[i].dorsal_edge = np.transpose(
np.vstack((np.transpose(self.shape_data.loc[index].x),
np.transpose(self.shape_data.loc[index].y))))
all_clone_list[i].q = np.array(self.shape_data.loc[index].q)
all_clone_list[i].qi = np.array(self.shape_data.loc[index].qi)
idx = self.shape_data.loc[index].checkpoint == 1
all_clone_list[i].checkpoints = all_clone_list[i].dorsal_edge[
idx, :]
clone_list = []
for clone in all_clone_list:
print clone.dorsal_edge
if len(clone.dorsal_edge) > 0:
if not (int(self.params['skip_accepted']) and clone.accepted):
clone_list.append(clone)
else:
print "No shape data found for " + clone.filebase
if len(clone_list) == 0:
print "Either image list is empty or they have all been 'accepted'"
return
self.all_clone_list = all_clone_list
self.clone_list = clone_list
self.curr_idx = 0
self.clone = self.clone_list[self.curr_idx]
self.saving = 0
self.fig = plt.figure(figsize=(15, 10))
self.fig.patch.set_facecolor("lightgrey")
self.display = self.fig.add_subplot(111)
self.display.axis('off')
try:
self.obj = PointFixer(self.clone, self.display)
try:
self.obj.masked_regions = self.masked_regions[
self.clone.filebase]
self.mask_all_regions()
except (AttributeError, KeyError):
pass
except IOError:
try:
self.clone.modification_notes += " Image file not found."
except TypeError:
self.clone.modification_notes = "Image file not found."
if self.curr_idx < len(self.clone_list) - 1:
self.next_button_press(1)
self.obj.clone.modifier = self.gui_params["default_modifier"]
self.populate_figure()
self.add_checkpoint = False
return
def populate_figure(self):
# updates GUI button placement, colors, etc
self.display.clear()
button_color = [0.792156862745098, 0.8823529411764706, 1.0]
if self.saving == 1:
self.saving_text = self.fig.text(0.875,
0.879,
'Saving',
fontsize=10,
fontweight='bold',
color=[0.933, 0.463, 0])
else:
try:
self.saving_text.remove()
except (ValueError, AttributeError):
pass
self.notes_text = self.fig.text(0.852,
0.575,
'Notes',
fontsize=10,
color="black")
axmodnotes = plt.axes([0.852, 0.45, 0.125, 0.12])
initial_modnotes = str(self.obj.clone.modification_notes)
if initial_modnotes == "nan":
initial_modnotes = ""
self.notestextbox = TextBox(axmodnotes, '', initial=initial_modnotes)
self.notestextbox.on_submit(self.set_notes)
axmodifier = plt.axes([0.875, 0.37, 0.1, 0.035])
self.modifiertextbox = TextBox(axmodifier,
'Initials',
initial=str(
self.params['default_modifier']))
self.modifiertextbox.on_submit(self.change_default_modifier)
axflip = plt.axes([0.50, 0.01, 0.1, 0.075])
self.flipbutton = Button(axflip,
'Flip',
color=button_color,
hovercolor=button_color)
self.flipbutton.on_clicked(self.obj.flip_button_press)
axedges = plt.axes([0.60, 0.01, 0.1, 0.075])
self.edgebutton = Button(axedges,
'Toggle Edges',
color=button_color,
hovercolor=button_color)
self.edgebutton.on_clicked(self.obj.edge_button_press)
axtogdorsal = plt.axes([0.70, 0.01, 0.1, 0.075])
self.togdorsalbutton = Button(axtogdorsal,
'Toggle Dorsal Fit',
color=button_color,
hovercolor=button_color)
self.togdorsalbutton.on_clicked(self.obj.toggle_dorsal_button_press)
axdel = plt.axes([0.025, 0.01, 0.1, 0.075])
self.delcheckbutton = Button(axdel,
'Delete Checkpoint',
color=button_color,
hovercolor=button_color)
self.delcheckbutton.on_clicked(self.obj.delete_selected_checkpoint)
axsave = plt.axes([0.875, 0.8, 0.1, 0.075])
self.savebutton = Button(axsave,
'Save',
color=button_color,
hovercolor=button_color)
self.savebutton.on_clicked(self.save)
axblur = plt.axes([0.25, 0.01, 0.1, 0.035])
self.blurtextbox = TextBox(axblur,
'Gaussian Blur StDev',
initial=str(self.obj.edge_blur))
self.blurtextbox.on_submit(self.set_edge_blur)
axreset = plt.axes([0.40, 0.01, 0.1, 0.075])
self.resetbutton = Button(axreset,
'Reset',
color=button_color,
hovercolor=button_color)
self.resetbutton.on_clicked(self.reset_button_press)
if self.curr_idx + 1 < len(self.clone_list):
axnext = plt.axes([0.875, 0.01, 0.1, 0.075])
self.nextbutton = Button(axnext,
'Next',
color=button_color,
hovercolor=button_color)
self.nextbutton.on_clicked(self.next_button_press)
if self.curr_idx > 0:
axprev = plt.axes([0.875, 0.085, 0.1, 0.075])
self.prevbutton = Button(axprev,
'Previous',
color=button_color,
hovercolor=button_color)
self.prevbutton.on_clicked(self.prev_button_press)
self.obj.draw()
def set_notes(self, text):
# saves any viable, user-added notes in text field
try:
self.obj.clone.modification_notes = str(text)
self.obj.draw()
except ValueError:
print "Invalid value for notes"
def set_edge_blur(self, text):
# sets the edge blur value, updates the binary edge image
try:
self.obj.edge_blur = float(text)
except ValueError:
print "Invalid value for gaussian blur sigma"
self.obj.clone.initialize_dorsal_edge(
self.obj.original_image, dorsal_edge_blur=self.obj.edge_blur)
self.obj.clone.fit_dorsal_edge(self.obj.original_image,
dorsal_edge_blur=self.obj.edge_blur)
self.obj.de = self.obj.clone.interpolate(self.obj.clone.dorsal_edge)
self.obj.edge_image = self.obj.clone.edges
self.mask_all_regions()
self.obj.checkpoints = self.obj.clone.checkpoints
self.obj.edges = False
self.obj.edge_button_press(1)
self.obj.clone.dorsal_edge_blur = self.obj.edge_blur
self.obj.draw()
def mask_all_regions(self):
try:
for region_id in xrange(len(self.obj.masked_regions.keys())):
region = self.obj.masked_regions[region_id]
if region[0] == "u":
self.obj.lasso_then_unmask(region[1],
add_to_metadata=False)
elif region[0] == "m":
self.obj.lasso_then_mask(region[1], add_to_metadata=False)
except AttributeError:
pass
def change_default_modifier(self, text):
self.gui_params['default_modifier'] = str(text)
with open("gui_params.txt", "w+") as f:
for k, v in gui_params.items():
f.write(str(k) + ", " + str(v) + "\n")
self.obj.clone.modifier = self.gui_params["default_modifier"]
def prev_button_press(self, event):
# moves to the previous image in the list relative to the current clone
self.clone_list[self.curr_idx] = self.obj.clone
self.masked_regions[self.obj.clone.filebase] = self.obj.masked_regions
self.curr_idx -= 1
self.clone = self.clone_list[self.curr_idx]
self.fig.clear()
self.display = self.fig.add_subplot(111)
self.display.axis('off')
self.obj = PointFixer(self.clone, self.display)
self.obj.clone.modifier = self.gui_params["default_modifier"]
try:
self.obj.masked_regions = self.masked_regions[
self.obj.clone.filebase]
self.mask_all_regions()
except KeyError:
pass
self.populate_figure()
return
def next_button_press(self, event):
# moves to the next image in the list
try:
self.clone_list[self.curr_idx] = self.obj.clone
self.masked_regions[
self.obj.clone.filebase] = self.obj.masked_regions
except AttributeError:
self.clone_list[self.curr_idx] = self.clone
self.auto_save_count += 1
if self.gui_params["auto_save"]:
if self.auto_save_count == self.gui_params["auto_save_number"]:
self.save(1)
self.auto_save_count = 0
self.curr_idx += 1
try:
self.clone = self.clone_list[self.curr_idx]
if os.path.isfile(self.clone.filepath):
self.fig.clear()
self.display = self.fig.add_subplot(111)
self.display.axis('off')
self.obj.clone.modifier = self.gui_params["default_modifier"]
self.obj = PointFixer(self.clone, self.display)
try:
self.obj.masked_regions = self.masked_regions[
self.obj.clone.filebase]
self.mask_all_regions()
except KeyError:
pass
else:
print "Image " + self.clone.filepath + " not found. Check your image filepath."
raise IOError
except IOError:
try:
self.clone.modification_notes += " Image file not found."
except TypeError:
self.clone.modification_notes = "Image file not found."
if self.curr_idx < len(self.clone_list) - 1:
self.next_button_press(event)
else:
self.curr_idx -= 1
self.clone = self.clone_list[self.curr_idx]
self.populate_figure()
def reset_button_press(self, event):
# resets current clone to default and redraws
if self.obj.clone.flip:
self.obj.clone.flip = not self.obj.clone.flip
self.obj.clone.find_features(self.obj.original_image,
**self.obj.params)
self.obj.clone.get_orientation_vectors()
self.obj.clone.find_head(self.obj.original_image, **self.obj.params)
self.obj.edge_blur = 1.0
self.blurtextbox.set_val('1.0')
self.obj.clone.dorsal_blur = 1.0
self.obj.edge_image = self.obj.original_edge_image.copy()
if self.obj.edges:
self.obj.image = self.obj.edge_image
self.obj.clone.initialize_dorsal_edge(self.obj.original_image,
edges=self.obj.edge_image,
**self.obj.params)
self.obj.clone.fit_dorsal_edge(self.obj.original_image,
**self.obj.params)
self.obj.clone.find_tail(self.obj.original_image)
self.obj.masked_regions = {}
self.obj.clone.remove_tail_spine()
self.obj.de = self.obj.clone.interpolate(self.obj.clone.dorsal_edge)
self.obj.selected = None
self.obj.checkpoints = self.obj.clone.checkpoints
self.obj.draw()
def save(self, event):
# saves all data (modified and unmodofied) to new csv
print "Saving..."
self.clone_list[self.curr_idx] = self.obj.clone
self.masked_regions[self.obj.clone.filebase] = self.obj.masked_regions
for all_c in xrange(len(self.all_clone_list)):
for c in xrange(len(self.clone_list)):
if self.all_clone_list[all_c].filebase == self.clone_list[
c].filebase:
self.all_clone_list[all_c] = self.clone_list[c]
self.saving = 1
self.populate_figure()
with open(self.params["input_analysis_file"],
"rb") as analysis_file_in, open(
self.params["output_analysis_file"],
"wb") as analysis_file_out:
# read/write header and save column names
line = analysis_file_in.readline()
analysis_file_out.write(line)
line = line.strip()
DATA_COLS = line.split("\t")
line = analysis_file_in.readline()
while line:
written = False
for clone in self.all_clone_list:
if (line.split("\t")[0]
== clone.filebase) and clone.accepted:
analysis_file_out.write(
utils.clone_to_line(clone, DATA_COLS) + "\n")
written = True
if (not written) and (not self.params['truncate_output']):
analysis_file_out.write(line)
line = analysis_file_in.readline()
with open(self.params["output_shape_file"], "wb") as shape_file_out:
# read/write header
line = "\t".join(
["filebase", "i", "x", "y", "qi", "q", "checkpoint"]) + "\n"
shape_file_out.write(line)
clone = None
for c in self.all_clone_list:
if c.accepted:
clone = c
if clone is not None:
for i in np.arange(len(clone.dorsal_edge)):
if len(
np.where((clone.checkpoints
== clone.dorsal_edge[i, :]).all(
axis=1))[0]) > 0:
checkpoint = 1
else:
checkpoint = 0
shape_file_out.write('\t'.join([
clone.filebase,
str(i),
str(clone.dorsal_edge[i, 0]),
str(clone.dorsal_edge[i, 1]),
str(clone.qi[i]),
str(clone.q[i]),
str(checkpoint)
]) + "\n")
clone = None
self.saving = 0
self.populate_figure()
with open(self.params["input_analysis_metadata_file"],
"rb") as analysis_file_in, open(
self.params["output_analysis_metadata_file"],
"wb") as analysis_file_out:
line = analysis_file_in.readline()
analysis_file_out.write(line)
line = analysis_file_in.readline()
while line:
written = False
for clone in self.all_clone_list:
if (line.split("\t")[0]
== clone.filebase) and clone.accepted:
metadata = [clone.filebase] + [
str(getattr(clone, mf))
for mf in ANALYSIS_METADATA_FIELDS
]
analysis_file_out.write("\t".join(metadata + ["\n"]))
written = True
if (not written) and (not self.params['truncate_output']):
analysis_file_out.write(line)
line = analysis_file_in.readline()
with open(self.params["masked_regions_output"], "wb") as file_out:
file_out.write("\t".join(
["filebase", "i", "x", "y", "masking_or_unmasking"]) + "\n")
for clone in self.all_clone_list:
if clone.accepted:
try:
masked_regions = self.masked_regions[clone.filebase]
for i in xrange(len(masked_regions.keys())):
m_or_u, region = masked_regions[i]
for j in xrange(region.shape[0]):
file_out.write("\t".join([
clone.filebase,
str(i),
str(region[j][0]),
str(region[j][1]), m_or_u
]) + "\n")
except KeyError:
continue
print "Saving done."
class SelectPanel():
"""Displays radio buttons for paw classification and the current paw number.
Alse displays information on the combination process
"""
def __init__(self, fig, outer):
#you may want this to not be a title, for now seems good enough
self.title_axes = fig.add_subplot(outer[1, 1])
self.title_axes.set_axis_off()
g = gspec.GridSpecFromSubplotSpec(1,
2,
subplot_spec=outer[1, 1],
wspace=0.1,
hspace=0.1)
self.lr_axis = fig.add_subplot(g[0, 1])
self.lr_axis.set_axis_off()
self.fh_axis = fig.add_subplot(g[0, 0])
self.fh_axis.set_axis_off()
#button_holder = fig.add_subplot(outer[1,1])
#button_holder.set_axis_off()
g = gspec.GridSpecFromSubplotSpec(4,
1,
subplot_spec=outer[2, 1],
wspace=0.1,
hspace=0.1)
#g.update(left=0.15, right=0.85, wspace=0.02, hspace=.04,
# bottom = .02, top = .98)
self.del_but_ax = fig.add_subplot(g[1, 0])
self.merge_but_ax = fig.add_subplot(g[2, 0])
self.split_but_ax = fig.add_subplot(g[3, 0])
self.del_but_ax.set_axis_off()
self.split_but_ax.set_axis_off()
def set_print_manager(self, pm):
self.print_manager = pm
def set_selected(self, print_numb, is_right, is_hind):
"""when a paw is selected, set the radio buttons and their callbacks
"""
self.clear_axes()
self.title_axes.set_title('Print ' + str(print_numb))
self.lr_but = RadioButtons(self.lr_axis, ('Left', 'Right'),
active=int(is_right))
self.fh_but = RadioButtons(self.fh_axis, ('Front', 'Hind'),
active=int(is_hind))
self.lr_but.on_clicked(self.print_manager.change_print_classification)
self.fh_but.on_clicked(self.print_manager.change_print_classification)
self.del_but_ax.set_axis_on()
self.del_but = Button(self.del_but_ax, 'Delete')
self.del_but.on_clicked(
lambda x: self.print_manager.delete_print(print_numb))
self.merge_but = Button(self.merge_but_ax, 'Merge')
self.merge_but.on_clicked(
lambda x: self.print_manager.toggle_combo_state())
self.split_but_ax.set_axis_on()
self.split_but = Button(self.split_but_ax, 'Split Print')
self.split_but.on_clicked(
lambda x: self.print_manager.initiate_split_window())
plt.draw()
def clear_axes(self):
self.title_axes.clear()
self.title_axes.set_axis_off()
self.title_axes.set_title('')
self.lr_axis.clear()
self.lr_axis.set_axis_off()
self.fh_axis.clear()
self.fh_axis.set_axis_off()
self.del_but_ax.clear()
self.del_but_ax.set_axis_off()
self.merge_but_ax.clear()
self.merge_but_ax.set_axis_off()
self.split_but_ax.clear()
self.split_but_ax.set_axis_off()
self.lr_but = None
self.fh_but = None
plt.draw()
def display_combo_text(self, print_numb):
"""Displays directions when combo state is active
"""
self.clear_axes()
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
# place a text box in upper left in axes coords
self.title_axes.text(0.05,
0.95,
"Left click on another print to \n" +
"combine with print " + str(print_numb) + "\n" +
"Or press c again to cancel",
transform=self.title_axes.transAxes,
fontsize=14,
verticalalignment='top',
bbox=props)
def display_combo_text2(self, print_numb, print_numb2):
"""Displays directions when combo state is active
"""
self.clear_axes()
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
# place a text box in upper left in axes coords
self.title_axes.text(0.05,
0.95,
"To combine print " + str(print_numb) + "\n" +
"and print " + str(print_numb2) + "\n" +
"Press enter. \n Or press c again to cancel",
transform=self.title_axes.transAxes,
fontsize=14,
verticalalignment='top',
bbox=props)
class FigureContainer():
"""instantiates figure and axes, creates all other objects. Holds the
animation"""
def __init__(self, file):
#because I'm using keys that matplotlib also uses, remove some bindings
plt.rcParams['keymap.fullscreen'] = '{'
plt.rcParams['keymap.yscale'] = '}'
self.fig = plt.figure(facecolor='w')
self.fig.set_size_inches(16, 9)
g = gspec.GridSpec(5,
2,
height_ratios=[2, 6, 4, 1, 6],
width_ratios=[10, 3])
g.update(left=0.05,
right=0.95,
wspace=0.02,
hspace=.04,
bottom=.02,
top=.98)
#add the axes in the subplot areas desired
self.spatial_axis = self.fig.add_subplot(g[1, 0])
self.vid_axis = self.fig.add_subplot(g[4, 0])
self.temporal_axis = self.fig.add_subplot(g[2, 0])
#self.select_axis = self.fig.add_subplot(g[:,1])
self.sel_panel = SelectPanel(self.fig, g)
#create an axes to hold space for the buttons
#self.fig.add_subplot(g[0,0]).set_axis_off()
g2 = gspec.GridSpecFromSubplotSpec(1,
4,
subplot_spec=g[0, 0],
wspace=0.1,
hspace=0.1)
ax = self.fig.add_subplot(g2[0, 0])
self.sav_but = Button(ax, 'Save Changes')
ax = self.fig.add_subplot(g2[0, 2])
self.pp_but = Button(ax, 'Pause Video')
self.pp_but.on_clicked(self.toggle_play)
#ax=self.fig.add_subplot(g2[0,3])
#self.pick_file_but = Button(ax, 'Load File')
#self.pick_file_but.on_clicked(self.load_new_file)
self.is_playing = True
#add a slider
slid_ax = self.fig.add_subplot(g[3, 0])
self.slide = Slider(slid_ax,
'Frame',
0,
100,
valinit=0,
valfmt='%0.0f')
self.init_for_file(file)
#and start the animation
self.anim = animation.FuncAnimation(self.fig,
self.update_func,
fargs=(),
interval=15,
repeat=True)
plt.show()
def load_new_file(self, _):
self.init_for_file(pick_file())
def toggle_play(self, _):
self.is_playing = not self.is_playing
if self.is_playing:
self.pp_but.label.set_text('Pause') # works
else:
self.pp_but.label.set_text('Play')
def update_func(self, j):
"""based on the value of the slider, update the video
"""
if self.is_playing:
#the min and max range don't seem to be working, so manually check
i = int(self.slide.val) + 1
if i < self.slide.valmin:
i = self.slide.valmin
if i > self.slide.valmax:
i = self.slide.valmin
self.print_manager.change_frame(self.prev_frame, i)
#self.slide.set_val(i%len(self.left_panel.frames))
self.slide.set_val(i)
self.prev_frame = i
return j
def init_for_file(self, file):
self.print_manager = PrintManager(self.temporal_axis,
self.spatial_axis, self.sel_panel,
self.vid_axis, self.slide, file)
self.sel_panel.set_print_manager(self.print_manager)
self.set_slider_range()
self.prev_frame = self.slide.val
#activate pick events
self.fig.canvas.mpl_connect('pick_event', self.print_manager.on_pick)
self.fig.canvas.mpl_connect('key_press_event',
self.print_manager.on_key_press)
#g2.update(left=0.05, right=0.95, wspace=0.02, hspace=.04,
# bottom = .2, top = .8)
#ax=self.fig.add_subplot(g2[0,0])
#Button(ax, 'Load File').on_clicked(
# self.print_manager.initiate_split_window)
self.sav_but.on_clicked(self.print_manager.save)
def set_slider_range(self):
"""set the slider to range between combo_prints first frame and
last frame"""
self.slide.set_val(self.print_manager.combo_prints.first_frame.min())
self.slide.valmin = self.print_manager.combo_prints.first_frame.min()
self.slide.valmax = self.print_manager.combo_prints.last_frame.max()
self.slide.ax.set_xlim(self.slide.valmin, self.slide.valmax)
def calibrate(self):
plt.clf()
self.img = cv2.cvtColor(self.img, cv2.COLOR_BGR2RGB)
plt.imshow(self.img)
self.anounce(
'You will define a rectangle in the image \n by selecting its corners, click to begin'
)
plt.waitforbuttonpress()
while True:
pts = []
while len(pts) < 3:
self.anounce(
'Select 4 corners of the rectangle in the following order:\n top left, top right, bottom left, bottom right'
)
pts = np.asarray(plt.ginput(4, timeout=-1))
if len(pts) < 4:
self.anounce('Too few points, starting over')
self.anounce('Happy? Key click for yes, mouse click for no')
fill_pts = np.copy(pts)
fill_pts[[2, 3]] = fill_pts[[3, 2]]
print(pts)
print(fill_pts)
ph = plt.fill(fill_pts[:, 0], fill_pts[:, 1], 'r', lw=2)
if plt.waitforbuttonpress():
break
for p in ph:
p.remove()
pts = pts.tolist()
for pt in pts:
pt[0] = round(pt[0])
pt[1] = round(pt[1])
self.corners = pts
def submitWidth(text):
self.width = eval(text)
def submitHeight(text):
self.height = eval(text)
def submit(event):
print("Corners: {}".format(self.corners))
print("Width is {}m".format(self.width))
print("Height is {}m".format(self.height))
print("Calibration is complete")
plt.close('all')
self.anounce(
"Enter the width and height (in metres) in the fields below \n Width: top left corner to top right corner \n Height: top left corner to bottom left corner"
)
width_box = TextBox(plt.axes([0.2, 0.02, 0.2, 0.05]),
'Width:',
initial='')
width_box.on_text_change(submitWidth)
height_box = TextBox(plt.axes([0.6, 0.02, 0.2, 0.05]),
'Height:',
initial='')
height_box.on_text_change(submitHeight)
submit_button = Button(plt.axes([0.85, 0.02, 0.1, 0.05]), 'Submit')
submit_button.on_clicked(submit)
plt.show()
class Chart(object):
def __init__(self, plt):
global current_temp
global current_fan_speed
self.plot = plt # create instance of plt
self.fig = fig # create a figure (one figure per window)
self.axes = axes # add a subplot to the figure. axes is of type Axes which contains most of the figure elements
# working on the Axes object
self.axes.set_title("GPU Fan Controller") # title for the chart
self.axes.grid()
# chart min/max display values
self.x_min = -5
self.x_max = 105
self.y_min = 25
self.y_max = 105
self.axes.set_xlim(self.x_min, self.x_max)
self.axes.set_ylim(self.y_min, self.y_max)
# Save button
saveFig = self.fig.add_axes([0.8, 0.015, 0.1, 0.04])
self.saveFig = Button(saveFig, "Save")
self.saveFig.on_clicked(self.saveToFile)
# printAxes = self.fig.add_axes([0.2, 0.025, 0.1, 0.04]) #position rect [left, bottom, width, height] where all quantities are in fractions of figure width and height
# self.printButton = Button(printAxes, "Print")
# self.printButton.on_clicked(self.printData)
# Reset button
resetChart = self.fig.add_axes([0.125, 0.015, 0.1, 0.04])
self.resetChart = Button(resetChart, "Reset")
self.resetChart.on_clicked(self.resetData)
# Apply button
applyAxes = self.fig.add_axes([0.685, 0.015, 0.1, 0.04])
self.applyAxes = Button(applyAxes, "Apply")
self.applyAxes.on_clicked(self.applyData)
#b=blue, o=circle, picker=max distance for considering point as clicked
self.line, = axes.plot(x_values, y_values, linestyle='-', marker='o', color='b', picker=5) #tuple unpacking: this function returns a tuple, with the comma we take the first element
self.dragHandler = DragHandler(self)
self.dataController = DataController(x_values, y_values)
#validate points from file!
self.updatedCurve = nvfanspeed.updatedCurve
self.nvidiaController = nvfanspeed.NvidiaFanController(x_values, y_values)
self.nvidiaController.start()
# signal traps
signal.signal(signal.SIGINT, self.exit_signal_handler) #CTRL-C
signal.signal(signal.SIGQUIT, self.exit_signal_handler) #CTRL-\
signal.signal(signal.SIGHUP, self.exit_signal_handler) #terminal closed
signal.signal(signal.SIGTERM, self.exit_signal_handler)
# close app
self.fig.canvas.mpl_connect("close_event", self.on_close)
def on_close(self, event):
self.nvidiaController.stop()
def exit_signal_handler(self, signal, frame):
self.close()
def close(self):
self.plot.close('all')
self.nvidiaController.stop()
def show(self):
self.plot.show() #display ALL non closed figures
#pyplot is stateful: usually self.plot.function() works on the current plot in the current figure
# def printData(self, event):
# xdata, ydata = self.dataController.getData()
# print "---------------"
# for index in range(0, len(xdata)):
# print xdata[index], ydata[index]
# print "---------------"
def resetData(self, event):
initChartValues() # reset to initial values
xydata = [x_values, y_values]
self.line.set_data(xydata) # update curve with values
self.updateChart(x_values, y_values) # update chart to reflect values
def updateChart(self, xdata, ydata):
"""
Due to how the NvidiaFanController run loop was structured to constantly update, there was an issue where updating the curve points could take anywhere from 3 to 10+ loop iterations
By pausing the loop, updates to the curve points occur consistently between 1-3 loop iterations
As a precaution, updating the chart with GPU temp/fan speed stats have also been paused, although may not be necessary.
"""
self.setUpdateStats(False) # temporarily stops live GPU updates
self.updatedCurve(True) # pauses the nvfanspeed run loop
self.nvidiaController.setCurve(xdata, ydata) # updates curve with new x and y data
self.updatedCurve(False) # resumes nvfanspeed loop
self.setUpdateStats(True) # enables live GPU updates
def setUpdateStats(self, bool):
global update_stats
update_stats = bool
def applyData(self, event):
xdata = self.line.get_xdata() # grabs current curve y data
ydata = self.line.get_ydata() # grabs current curve y data
is_valid_curve = self.dataController.setData(xdata, ydata) # checks if curve is exponentially growing (returns bool)
if is_valid_curve:
self.updateChart(xdata, ydata) # updates nvfanspeed.NvidiaFanController() with new curve data
displayDialogBox('Successfully applied the current curve to the fan settings!')
else:
xdata, ydata = self.dataController.getData() # gets previous data
xydata = [xdata, ydata]
self.line.set_data(xydata) # resets line to previous curve
def saveToFile(self, event):
config = []
xdata, ydata = self.dataController.getData() # get current curve points
for index in range(0, len(xdata)):
res = [xdata[index], ydata[index]] # combine x and y data
config.append(res) # append it to config
savedConfig = np.array(config) # convert config to numpy array (req'd to convert base10 to int)
np.savetxt("config.csv", savedConfig.astype(int) , delimiter=",", fmt='%i') # saves array[temp, fspd] to config.csv
displayDialogBox('Successfully saved the current curve configuration!')
global_path = os.getcwd()
out_name = global_path + '/../../data/ParteII/sujetos'
path = out_name + '/' + meta_sub
n_time = time.asctime(time.localtime(time.time()))
_today = str(datetime.date.today())
today = _today.replace('-', '')
_time = n_time.split()
save_time = today + '_' + _time[3].replace(':', '')[:-2]
try:
os.mkdir(path)
except OSError:
print("Creation of the directory %s failed" % path)
else:
print("Successfully created the directory %s " % path)
np.savetxt(path + '/' + meta_sub + '_' + save_time + '.csv',
np.c_[res_values, elapsed_time],
delimiter=';',
fmt='%s',
header="Resultado VAS")
plt.close()
sVAS.on_changed(update)
reset_button.on_clicked(reset)
save_button.on_clicked(save)
DAx = plt.axes([0.25, 0.20, 0.65, 0.03]) DSlider = Slider(DAx, 'Days to transition (E->A orA->M) (1/Gamma) (1/Gamma)', 1, 15, valinit = 10, valstep = 1, color = sliderColor) deltaAx = plt.axes([0.25, 0.05, 0.65, 0.03]) deltaSlider = Slider(deltaAx, 'Days of incubation (delta)', 1, 15, valinit = 3, valstep = 1, color = sliderColor) def reset(event): '''Reset all of the sliders''' betaSlider.reset() DSlider.reset() deltaSlider.reset() muSlider.reset() resetAx = fig.add_axes([0.45, 0.025, 0.1, 0.04]) resetButton = Button(resetAx, 'Reset', color = 'gray') resetButton.on_clicked(reset) def model(event): '''Update the parameters and plots''' beta1 = betaSlider.val gamma1 = gamma2 = eta = 1/DSlider.val delta = deltaSlider.val mu = muSlider.val #Differentiate the equations again sol = generateData(time, initVec, N, beta1, beta2, tLock, gamma1, gamma2, eta, mu, delta, alpha, rho) S, E, A, M, R, D = sol #Change the y-data on each of the plots Splt.set_ydata(S) Eplt.set_ydata(E)
def __init__(self, images, shape):
fig = plt.figure(figsize=(10, 6))
# subplot positions
h_nav = [Size.Fixed(0.5), Size.Fixed(2.5)]
v_nav = [Size.Fixed(0.5), Size.Scaled(1.0), Size.Fixed(0.5)]
h_im = [Size.Fixed(0.5), Size.Scaled(1.0), Size.Fixed(0.5)]
v_im = [Size.Fixed(0.5), Size.Scaled(1.0), Size.Fixed(0.5)]
nav = Divider(fig, (0.0, 0.0, 0.2, 1.), h_nav, v_nav, aspect=False)
image = Divider(fig, (0.2, 0.0, 0.8, 1.), h_im, v_im, aspect=True)
image.set_anchor('C')
# Toolbar menu box
ax1 = LocatableAxes(fig, nav.get_position())
ax1.set_axes_locator(nav.new_locator(nx=1, ny=1))
ax1.get_xaxis().set_visible(False)
ax1.get_yaxis().set_visible(False)
fig.add_axes(ax1, label='toolbar')
ax1.text(0.05, 0.45, "Filter", weight='heavy',
transform=ax1.transAxes)
# Image space
ax2 = LocatableAxes(fig, image.get_position())
ax2.set_axes_locator(image.new_locator(nx=1, ny=1))
fig.add_axes(ax2, label='image_space')
self.callback = ImageIndex(images, shape, fig)
# Navigation
## Go to
ax_text_index = plt.axes([0.59, 0.05, 0.1, 0.075])
ip = InsetPosition(ax1, [0.2, 0.84, 0.3, 0.05])
ax_text_index.set_axes_locator(ip)
entry_index = TextBox(ax_text_index, 'Go to', initial="0")
entry_index.on_submit(self.callback.submit_index)
## Previous
ax_prev = plt.axes([0.7, 0.05, 0.075, 0.075])
ip = InsetPosition(ax1, [0.55, 0.84, 0.15, 0.05])
ax_prev.set_axes_locator(ip)
bprev = Button(ax_prev, '<<')
bprev.on_clicked(self.callback.prev)
## Next
ax_next = plt.axes([0.81, 0.05, 0.075, 0.075])
ip = InsetPosition(ax1, [0.75, 0.84, 0.15, 0.05])
ax_next.set_axes_locator(ip)
bnext = Button(ax_next, '>>')
bnext.on_clicked(self.callback.next)
# Bounding Boxes
ax_chec = plt.axes([0.1, 0.05, 0.35, 0.075])
ip = InsetPosition(ax1, [0.05, 0.5, 0.9, 0.3])
ax_chec.set_axes_locator(ip)
ax_chec.text(0.05, 0.85, "Bounding Boxes", transform=ax_chec.transAxes)
check = CheckButtons(ax_chec,
('characters', 'lines'),
(False, False))
check.on_clicked(self.callback.update_bboxes)
# Filtering
## Image
ax_text_image = plt.axes([0.1, 0.1, 0.1, 0.075])
ip = InsetPosition(ax1, [0.26, 0.38, 0.64, 0.05])
ax_text_image.set_axes_locator(ip)
entry_image = TextBox(ax_text_image, 'images',
initial="image_id,image_id")
entry_image.on_submit(self.callback.submit_images)
## Characters
ax_text_char = plt.axes([0.1, 0.2, 0.1, 0.075])
ip = InsetPosition(ax1, [0.21, 0.3, 0.69, 0.05])
ax_text_char.set_axes_locator(ip)
entry_char = TextBox(ax_text_char, 'chars',
initial="U+3055,U+3056")
entry_char.on_submit(self.callback.submit_chars)
## Reset
ax_reset = plt.axes([0., 0., 1., 1.])
ip = InsetPosition(ax1, [0.05, 0.2, 0.2, 0.05])
ax_reset.set_axes_locator(ip)
breset = Button(ax_reset, 'Reset')
breset.on_clicked(self.callback.reset)
plt.show()
class DiagramInfo:
'''Manages the plot that displays diagram info.'''
precision = 2
def __init__(self, ax, on_auto_clicked):
self.ax = ax
self.on_auto_clicked_callback = on_auto_clicked
kwargs = {
'horizontalalignment': 'center',
'verticalalignment': 'center',
'transform': self.ax.transAxes
}
self.A_text = self.ax.text(.05, .5, "A =", fontsize=25, **kwargs)
self.matrix_text = self.ax.text(.7,
.5,
"(No Matrix)",
fontsize=25,
**kwargs)
self.trace_text = self.ax.text(.5,
.15,
"(No Data)",
fontsize=14,
**kwargs)
self.det_text = self.ax.text(.5,
.05,
"(No Data)",
fontsize=14,
**kwargs)
# AUTO Button setup
warnings.filterwarnings(
"ignore",
message=
"This figure includes Axes that are not compatible with tight_layout, so results might be incorrect."
)
button_axes = plt.axes([0, 0, 1, 1])
ip = InsetPosition(self.ax, [0.2, 0.88, 0.6, 0.1])
button_axes.set_axes_locator(ip)
self.auto_button = Button(button_axes,
'RUN AUTO ELLIPSE',
color='gray')
self.auto_button.on_clicked(lambda event: self.on_auto_clicked(event))
# Don't draw the axes
self.ax.axis('off')
def update(self, trace, det, A):
A_ = np.around(A, self.precision)
txt = "{} {} \n{} {} ".format(A_[0, 0], A_[0, 1], A_[1, 0], A_[1, 1])
#A_txt=r"$ \begin{matrix} a & b \\ d & e \end{matrix} $"
self.matrix_text.set_text(txt)
txt = r"$\tau = {0:.2f}$".format(trace)
self.trace_text.set_text(txt)
txt = r"$\Delta = {0:.2f}$".format(det)
self.det_text.set_text(txt)
def on_auto_clicked(self, event):
self.on_auto_clicked_callback()
def draw(self):
while True:
try:
_ = self.xMl
break
except:
time.sleep(5)
self.fig = plt.figure()
self.ax = self.fig.add_subplot(1, 1, 1)
plt.subplots_adjust(bottom=0.25)
axnext = plt.axes([0.6, 0.05, 0.1, 0.075])
bnext = Button(axnext, 'Refresh')
bnext.on_clicked(self.refresh_func)
while True:
if self.refresh:
self.ax.lines = list()
self.ax.texts = list()
self.ax.plot(self.xM, self.yM, color="black", linewidth=1)
for n, xpos, ypos, value in zip(self.Nl, self.xMl, self.yMl,
self.slope_list):
self.ax.text(xpos - 1,
ypos + 0.0005,
str(abs(value)),
fontsize=6,
color="gray",
fontweight="bold")
for x_slice, y_slice, x_point, y_point, sig_type in self.signal_list:
self.ax.plot(x_slice,
y_slice,
color="steelblue",
linewidth=1)
self.ax.text(x_point,
self.y_min - 0.002,
sig_type,
fontsize=5,
color="steelblue",
fontweight="bold")
for xpos, ypos, close_type, x, start_price in self.close_list:
self.ax.plot([
xpos,
], [
ypos,
], "*k", markersize=5)
if ypos != start_price:
if close_type == "long":
color = "red" if ypos > start_price else "green"
y_2_points = [start_price, ypos]
else:
color = "red" if ypos < start_price else "green"
y_2_points = [start_price, 2 * start_price - ypos]
self.ax.plot([x, x + 0.001],
y_2_points,
color=color,
linewidth=2)
if self.long_trigger_price is not None:
self.ax.plot(self.xM, [
self.long_trigger_price,
] * len(self.xM),
"--r",
linewidth=0.5)
if self.short_trigger_price is not None:
self.ax.plot(self.xM, [
self.short_trigger_price,
] * len(self.xM),
"--g",
linewidth=0.5)
self.ax.set_title(str(round(self.pnl, 3)))
plt.pause(30)
else:
plt.pause(120)
class IncrInsert_2d:
def __init__(self, fn, initial_points, n_steps=1):
self.plot3d = None
self.title = None
self.n_steps = n_steps
self.N = 2
self.initial_points = initial_points
self.fn = fn
self.triang = _delaunay2.DelaunayInterp2(fn)
# insert the initial points
for x in initial_points:
f_val = fn(x)
self.triang.insert(x, f_val)
print("inserted %d initial points" % len(initial_points))
self.init_draw()
def init_draw(self):
self.fig = plt.figure()
self.ax = Axes3D(self.fig)
self.update_plot()
self.axbutton = plt.axes([0.81, 0.05, 0.1, 0.075])
self.button = Button(self.axbutton, 'Insert')
self.button.on_clicked(self.on_insert_click)
plt.draw()
def update_plot(self):
t0 = time.time()
if (self.plot3d != None):
for item in self.plot3d:
[x.remove() for x in item]
self.plot3d = None
[item.remove() for item in self.ax.collections]
del self.ax.collections[:]
t1 = time.time()
(all_segments, min_coords,
max_coords) = self.triang.get_line_segments()
t2 = time.time()
self.plot3d = []
for segment in all_segments:
(p0, p1, is_concave) = segment
color = ('b' if (is_concave) else 'r')
(xpair, ypair, zpair) = zip(p0, p1)
self.plot3d.append(self.ax.plot3D(xpair, ypair, zpair,
color=color))
t3 = time.time()
error_queue = self.triang.get_error_queue()
if (len(error_queue) > 0):
(err, f_val, x) = error_queue[0]
self.next_point = self.ax.scatter([x[0]], [x[1]], [f_val],
color='r')
self.ax.set_xlim(min_coords[0], max_coords[0])
self.ax.set_ylim(min_coords[1], max_coords[1])
self.ax.set_zlim(min_coords[2], max_coords[2])
def on_insert_click(self, event):
t1 = time.time()
for i in range(self.n_steps):
self.triang.insert_largest_error_point()
t2 = time.time()
#print("time of insertion: %f, %d points, avg %f" % (t2-t1, self.n_steps, (t2-t1)/self.n_steps))
self.update_plot()
plt.draw()
class RotatableAxes:
def __init__(self, fig: mpl.figure.Figure, axes: mpl.axes.Axes,
rect_angle: list, rect_reset: list):
self.fig = fig
# Suppose that there exists an image in the axes
self.axes = axes
self.renderer = self.axes.figure.canvas.get_renderer()
self.axes_img_instance = self.axes.get_images()[0]
self.original_axes_img = self.axes_img_instance.make_image(
self.renderer, unsampled=True)[0]
self.axes_for_angle_slider = self.fig.add_axes(rect_angle)
self.axes_for_reset_button = self.fig.add_axes(rect_reset)
self.angle_slider = Slider(self.axes_for_angle_slider,
'Angle(Degree)',
0.0,
359.0,
valinit=0.0,
valstep=0.1)
self.angle_slider.on_changed(self.update_img)
self.reset_button = Button(self.axes_for_reset_button, 'Reset')
self.reset_button.on_clicked(self.reset)
def connect(self) -> None:
# connect to all the events we need
self.fig.canvas.mpl_connect('button_press_event', self.onclick)
def disconnect(self) -> None:
# disconnect all the stored connection ids
self.fig.canvas.mpl_disconnect(self.onclick)
def update_la_img(self):
self.axes_img_instance = self.axes.get_images()[0]
self.original_axes_img = self.axes_img_instance.make_image(
self.renderer, unsampled=True)[0]
self.angle_slider.reset()
def onclick(self, event: mpl.backend_bases.Event) -> None:
if self.axes == event.inaxes:
cur_img = self.axes_img_instance.make_image(self.renderer,
unsampled=True)[0]
if event.button == mpl.backend_bases.MouseButton.LEFT and event.inaxes is not None:
rotated_image = ndimage.rotate(cur_img, 90.0, reshape=False)
self.axes_img_instance.set_data(rotated_image)
elif event.button == mpl.backend_bases.MouseButton.RIGHT and event.inaxes is not None:
flipped_img = cur_img[:, ::-1]
self.axes_img_instance.set_data(flipped_img)
self.axes.figure.canvas.draw()
self.axes.figure.canvas.flush_events()
def update_img(self, new_angle: float) -> None:
axes_images_list = self.axes.get_images()
rotated_img = ndimage.rotate(self.original_axes_img,
new_angle,
reshape=False)
axes_images_list[0].set_data(rotated_img)
self.axes.figure.canvas.update()
self.axes.figure.canvas.flush_events()
def reset(self, event: mpl.backend_bases.Event):
self.angle_slider.reset()
movie_cbar = movie_fig.colorbar(movie_plot)
movie_cbar.ax.set_ylabel(r'log $\Sigma$ [ g/cm$^2$ ]')
movie_cbar.set_ticks(cbar_ticks)
plt.grid(b=True)
img_name = 'movie_plot_%05i%s' % (i, img_format)
plt.savefig(dir_name + '/' + img_name)
print 'Saving image: ' + dir_name + '/' + img_name
plt.close(movie_fig)
# Create movie
movie_name = 'movie.mp4'
dummy_name = movie_name
dummy_i = 0
while os.path.isfile(dummy_name):
dummy_i += 1
dummy_name = movie_name.replace('.', '_%03i.' % dummy_i)
movie_name = dummy_name
subprocess.call([
'ffmpeg', '-start_number',
repr(i_start), '-i',
dir_name + os.sep + 'movie_plot_%05d' + img_format, '-c:v', 'libx264',
'-crf', '0', '-pix_fmt', 'yuv420p', movie_name
])
print 'Saving movie ' + movie_name
# Delete folder
shutil.rmtree(dir_name)
slider_time.on_changed(update) # This is executed when changing the slider
button_movie.on_clicked(
create_movie) # This is done by click on the movie button
def __init__(self):
# Ask the user for data file, image, train..
self.args = parseArgs()
(self.numRows, self.numCols) = (32, 128)
# Set X and Y ticks to match data size
(xStart, xStop, xStep) = (16, 128, 16)
(yStart, yStop, yStep) = (8, 32, 8)
(self.xlist, self.ylist) = ([], [])
# Generate list of xticks to label the x axis
for i in range(xStart, xStop, xStep):
self.xlist.append(i)
# Generate yticks for the y-axis
for i in range(yStart, yStop, yStep):
self.ylist.append(i)
(imgOffset, timeStamp, run_number, trainNumber, image_number,
imageData) = self.obtainImageWithInfo()
# Create the figure and title
self.fig = plt.figure(1)
self.ax = self.fig.add_subplot(111)
self.mainTitle = plt.title("")
# Previous, next buttons inspired by example: matplotlib.org/1.3.1/examples/widgets/buttons.html
# Previous, Next ASIC module buttons..
decModule = plt.axes([0.85, 0.115, 0.07, 0.045])
incModule = plt.axes([0.92, 0.115, 0.07,
0.045]) # [left, bottom, width, height]
incrementModule = Button(incModule, '+M')
incrementModule.on_clicked(self.nextModule)
decrementModule = Button(decModule, '-M')
decrementModule.on_clicked(self.prevModule)
# Previous, Next image buttons..
decImage = plt.axes([0.85, 0.06, 0.07, 0.045])
incImage = plt.axes([0.92, 0.06, 0.07,
0.045]) # [left, bottom, width, height]
incrementImg = Button(incImage, '+I')
incrementImg.on_clicked(self.nextImage)
decrementImg = Button(decImage, '-I')
decrementImg.on_clicked(self.prevImage)
# Previous, Next train buttons..
decTrain = plt.axes([0.85, 0.005, 0.07, 0.045])
incTrain = plt.axes([0.92, 0.005, 0.07,
0.045]) # [left, bottom, width, height]
incrementTrain = Button(incTrain, '+T')
incrementTrain.on_clicked(self.nextTrain)
decrementTrain = Button(decTrain, '-T')
decrementTrain.on_clicked(self.prevTrain)
# Determine row/col coordinates according to selected ASIC module
(rowStart, colStart) = self.asicStartingRowColumn(self.args.module)
self.img = self.ax.imshow(imageData[rowStart:rowStart + self.numRows,
colStart:colStart + self.numCols],
interpolation='nearest',
vmin='0',
vmax='4095')
self.ax.set_xticks(self.xlist)
self.ax.set_yticks(self.ylist)
dateStr = time.strftime('%d/%m/%y %H:%M:%S', time.localtime(timeStamp))
titleText = 'Run %d Train %d Image %d Module %d : %s' % (
run_number, trainNumber, image_number, self.args.module, dateStr)
self.mainTitle.set_text(titleText)
# Add a colour bar
axc, kw = matplotlib.colorbar.make_axes(self.ax)
cb = matplotlib.colorbar.Colorbar(axc, self.img)
self.img.colorbar = cb
self.artist = self.fig.get_children()
DataCursor(
self.artist[1], imageData[rowStart:rowStart + self.numRows,
colStart:colStart + self.numCols])
plt.show()
