def __init__(self, ax): self.time_lbl = ax.text(0.02, 0.95, '', transform=ax.transAxes) self.power_lbl = ax.text(0.02, 0.90, '', transform=ax.transAxes) self.rotation_lbl = ax.text(0.02, 0.85, '', transform=ax.transAxes) self.hs_lbl = ax.text(0.02, 0.80, '', transform=ax.transAxes) self.vs_lbl = ax.text(0.02, 0.75, '', transform=ax.transAxes) self.fuel_lbl = ax.text(0.02, 0.70, '', transform=ax.transAxes) # BUTTONS # TODO: Reset # TODO: run,pause, next/prev frame # SLIDERS ax_power = plt.axes([0.2, 0.02, 0.5, 0.02]) ax_rotation = plt.axes([0.2, 0.08, 0.5, 0.02]) self.slider_power = plt.Slider(ax_power, 'Power', valmin=0, valmax=4, valinit=0, valstep=1) self.slider_rotation = plt.Slider(ax_rotation, 'Rotation', valmin=-90, valmax=90, valinit=0, valstep=1)
def draw(robots, create_video_path=None): fig, ax = plt.subplots() size = 0 for name, arr in robots.items(): x = [xyz[0] for t, xyz in arr] y = [xyz[1] for t, xyz in arr] plt.plot(x, y, '-', label=name) size = max(size, len(x)) ax.set_aspect(1.0) plt.legend() # The function to be called anytime a slider's value changes def update(val): ax.clear() for name, arr in robots.items(): x = [xyz[0] for t, xyz in arr] y = [xyz[1] for t, xyz in arr] index = min(int(val), len(x) - 1) ax.plot(x[:index + 1], y[:index + 1], '-', label=name) ax.scatter([x[index]], [y[index]], s=50) ax.annotate(name[0], (x[index], y[index])) fig.canvas.draw_idle() if create_video_path is not None: assert create_video_path.endswith(".mp4"), create_video_path writer = None fps = 10 for i in range(size): update(i) image_stream = io.BytesIO() plt.savefig(image_stream, format='png') image_stream.seek(0) file_bytes = np.asarray(bytearray(image_stream.read()), dtype=np.uint8) img = cv2.imdecode(file_bytes, cv2.IMREAD_COLOR) if writer is None: height, width = img.shape[:2] writer = cv2.VideoWriter(create_video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height)) writer.write(img) if writer is not None: writer.release() return # i.e. no interactive session axcolor = 'lightgoldenrodyellow' # Make a horizontal slider to control the frequency. axfreq = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor) slider = plt.Slider( ax=axfreq, label='time [s]', valmin=0.0, valmax=size, valinit=0.0, ) slider.on_changed(update) plt.show()
def _set_up_sliders(self): """ Creates an slider for every parameter. """ i = 0.05 self._sliders = {} for param in self.model.params: if not param.fixed: axbg = 'lightgoldenrodyellow' else: axbg = 'red' # start-x, start-y, width, height ax = self.fig.add_axes((0.162, i, 0.68, 0.03), facecolor=axbg, label=param) val = param.value if not hasattr(param, 'min') or param.min is None: minimum = 0 else: minimum = param.min if not hasattr(param, 'max') or param.max is None: maximum = 2 * val else: maximum = param.max slid = plt.Slider(ax, param, minimum, maximum, valinit=val, valfmt='% 5.4g') self._sliders[param] = slid slid.on_changed(self._update_plot) i += 0.05
def sliderplot(YY, X=None, slidervals=None, *args, **kwargs): """ Shortcut to creating a simple 2D plot with a slider to go through a third dimension YY = [nxm]: y axis data (initially plots Y[0,:]) X = [n] or [nxm]: x axis data (can be 1D or 2D, either same length or shape as Y) slidervals = None or [m]: Values to give in the slider E.G. sliderplot([1,2,3],[[2,4,6],[8,10,12],[14,16,18],[20,22,24]],slidervals=[3,6,9,12]) """ if 'linewidth' and 'lw' not in kwargs.keys(): kwargs['linewidth'] = 2 fig = plt.figure(figsize=FIGURE_SIZE, dpi=FIGURE_DPI) X = np.asarray(X, dtype=np.float) Y = np.asarray(YY, dtype=np.float) if slidervals is None: slidervals = range(Y.shape[0]) slidervals = np.asarray(slidervals, dtype=np.float) if X.ndim < 2: X = np.tile(X, Y.shape[0]).reshape(Y.shape) plotline, = plt.plot(X[0, :], Y[0, :], *args, **kwargs) plt.axis([X.min(), X.max(), Y.min(), Y.max()]) plt.subplots_adjust(bottom=0.2) ax = plt.gca() " Create slider on plot" axsldr = plt.axes([0.15, 0.05, 0.65, 0.03], axisbg='lightgoldenrodyellow') sldr = plt.Slider(axsldr, '', 0, len(slidervals) - 1) txt = axsldr.set_xlabel('{} [{}]'.format(slidervals[0], 0), fontsize=18) plt.sca(ax) " Slider update function" def update(val): "Update function for pilatus image" pno = int(np.floor(sldr.val)) plotline.set_xdata(X[pno, :]) plotline.set_ydata(Y[pno, :]) txt.set_text('{} [{}]'.format(slidervals[pno], pno)) plt.draw() plt.gcf().canvas.draw() # fig1.canvas.draw() sldr.on_changed(update)
# # plot the estimated damage for the least damaging orientation ax1 = fig.add_subplot(221) ax1.imshow(damage.min(0), interpolation='bicubic') ax1.set_title('Vascular damage at best orientation') # plot the interactive GUI ax2 = plt.subplot(222) ax2im = ax2.imshow(meanvasdam, 'gray', interpolation='none') # plot probe img = plt.imshow(probe[0], extent=[0, 0, 0, 0], alpha=0.5) # plot dynamic timecourse # ax3 = fig.add_subplot(223) # ax3.plot([1,2,3,4,5]) # plot histogram with slider ax3 = fig.add_subplot(223) ax3.hist(damage.flatten()) slide = plt.Slider(ax3, "", 0, 10) # plot luminance ax4 = fig.add_subplot(224) ax4.imshow(lumdam.min(0)) plt.draw() plt.show() plt.ioff()
def select_epochs(folder, overWrite=False): # Find test set with most uniform covering of speed and environment variable. # provides then a little manual tool to change the size of the window # and its position. if not os.path.exists(folder + 'nnBehavior.mat'): raise ValueError('this file does not exist :' + folder + 'nnBehavior.mat') with tables.open_file(folder + 'nnBehavior.mat', "a") as f: children = [c.name for c in f.list_nodes("/behavior")] if overWrite == False and "trainEpochs" in children and "testEpochs" in children: return # Get info from the file speedMask = f.root.behavior.speedMask[:] positions = f.root.behavior.positions positions = np.swapaxes(positions[:, :], 1, 0) speeds = f.root.behavior.speed positionTime = f.root.behavior.position_time positionTime = np.swapaxes(positionTime[:, :], 1, 0) speeds = np.swapaxes(speeds[:, :], 1, 0) if speeds.shape[0] == positionTime.shape[0] - 1: speeds = np.append(speeds, speeds[-1]).reshape(positionTime.shape[0], speeds.shape[1]) #We extract session names: sessionNames = [ "".join([chr(c) for c in l[0][:, 0]]) for l in f.root.behavior.SessionNames[:, 0] ] if sessionNames[0] != 'Recording': IsMultiSessions = True sessionNames = [ "".join([chr(c) for c in l[0][:, 0]]) for l in f.root.behavior.SessionNames[:, 0] ] sessionStart = f.root.behavior.SessionStart[:, :][:, 0] sessionStop = f.root.behavior.SessionStop[:, :][:, 0] else: IsMultiSessions = False sessionValue = np.zeros(speedMask.shape[0]) if IsMultiSessions: for k in range(len(sessionNames)): sessionValue[ep.inEpochs( positionTime[:, 0], [sessionStart[k], sessionStop[k]])] = k # Select the representative behavior without sleeps to show epochToShow = [] if IsMultiSessions: sleep_list = [ re.search('sleep', sessionNames[x], re.IGNORECASE) for x in range(len(sessionNames)) ] id_sleep = [ x for x in range(len(sleep_list)) if sleep_list[x] != None ] if id_sleep: all_id = set(range(len(sessionNames))) id_toshow = list( all_id.difference(id_sleep)) # all except sleeps for id in id_toshow: epochToShow.extend([sessionStart[id], sessionStop[id]]) else: epochToShow.extend([ positionTime[0, 0], positionTime[-1, 0] ]) # if no sleeps, or session names, or hab take everything maskToShow = ep.inEpochsMask(positionTime[:, 0], epochToShow) behToShow = positions[maskToShow, :] timeToShow = positionTime[maskToShow, 0] sessionValue_toshow = sessionValue[maskToShow] if IsMultiSessions: SessionNames_toshow = [sessionNames[i] for i in id_toshow] ### Get times of show if IsMultiSessions: if id_sleep[0] == 0: # if sleep goes first get the end of it ids = np.where(sessionValue == id_sleep[0])[0] st = positionTime[ids[-1] + 1] for i in id_sleep[1:]: ids = np.where(sessionValue == i)[0] st = np.append( st, (positionTime[ids[0]], positionTime[ids[-1]])) if st[-1] != positionTime[-1]: st = np.append(st, positionTime[-1]) else: st = st[:-1] else: # if it starts with maze st = positionTime[0] for i in id_sleep: ids = np.where(sessionValue == i)[0] st = np.append( st, (positionTime[ids[0]], positionTime[ids[-1]])) if st[-1] != positionTime[-1]: st = np.append(st, positionTime[-1]) else: st = st[:-1] assert (st.shape[0] % 2 == 0) showtimes = tuple(zip(st[::2], st[1::2])) # Default train and test sets sizeTest = timeToShow.shape[0] // 10 testSetId = timeToShow.shape[0] - timeToShow.shape[0] // 10 bestTestSet = 0 useLossPredTrainSet = True lossPredSetId = 0 sizelossPredSet = timeToShow.shape[0] // 10 SetData = { 'sizeTest': sizeTest, 'testsetId': testSetId, 'bestTestSet': bestTestSet, 'useLossPredTrainSet': useLossPredTrainSet, 'lossPredSetId': lossPredSetId, 'sizelossPredSet': sizelossPredSet } #### Next we provide a tool to manually change the bestTest set position # as well as its size: # Cut the cmap to avoid black colors min_val, max_val = 0.3, 1.0 n = 20 cmap = plt.get_cmap("nipy_spectral") colors = cmap(np.linspace(min_val, max_val, n)) cmSessValue = mplt.colors.LinearSegmentedColormap.from_list( "mycmap", colors) colorSess = cmSessValue( np.arange(len(sessionNames)) / (len(sessionNames))) keptSession = np.zeros(len(colorSess)) + 1 # a mask for the session if IsMultiSessions: keptSession[id_sleep] = 0 fig = plt.figure() gs = plt.GridSpec(positions.shape[1] + 5, max(len(colorSess), 2), figure=fig) if IsMultiSessions: ax = [ fig.add_subplot(gs[id, :]) for id in range(positions.shape[1]) ] #ax for feature display ax[0].get_shared_x_axes().join(ax[0], ax[1]) # ax = [brokenaxes(xlims=showtimes, subplot_spec=gs[id,:]) for id in range(positions.shape[1])] #ax for feature display else: ax = [ fig.add_subplot(gs[id, :]) for id in range(positions.shape[1]) ] #ax for feature display ax[0].get_shared_x_axes().join(ax[0], ax[1]) ax += [fig.add_subplot(gs[-5, id]) for id in range(len(sessionNames))] ax += [ fig.add_subplot(gs[-4, max(len(colorSess) - 3, 1):max(len(colorSess), 2)]) ] ax += [ fig.add_subplot(gs[-4, 0:max(len(colorSess) - 4, 1)]), fig.add_subplot(gs[-3, :]) ] #loss pred training set slider ax += [fig.add_subplot(gs[-2, :]), fig.add_subplot(gs[-1, :])] #test set. if IsMultiSessions: trainEpoch, testEpochs, lossPredSetEpochs = ep.get_epochs( timeToShow, SetData, keptSession, starts=sessionStart, stops=sessionStop) else: trainEpoch, testEpochs, lossPredSetEpochs = ep.get_epochs( timeToShow, SetData, keptSession) ls = [] for dim in range(positions.shape[1]): l1 = ax[dim].scatter( timeToShow[ep.inEpochs(timeToShow, trainEpoch)[0]], behToShow[ep.inEpochs(timeToShow, trainEpoch)[0], dim], c="red", s=0.5) l2 = ax[dim].scatter( timeToShow[ep.inEpochs(timeToShow, testEpochs)[0]], behToShow[ep.inEpochs(timeToShow, testEpochs)[0], dim], c="black", s=0.5) if SetData['useLossPredTrainSet']: l3 = ax[dim].scatter( timeToShow[ep.inEpochs(timeToShow, lossPredSetEpochs)[0]], behToShow[ep.inEpochs(timeToShow, lossPredSetEpochs)[0], dim], c="orange", s=0.5) else: l3 = ax[dim].scatter(timeToShow[0], behToShow[0, dim], c='orange', s=0.5) ls.append([l1, l2, l3]) # display the sessions positions at the bottom: if IsMultiSessions: for idk, k in enumerate(id_toshow): if len(np.where(np.equal(sessionValue_toshow, k))[0]) > 0: ax[id].hlines(np.min(behToShow[ np.logical_not(np.isnan(behToShow[:, dim])), dim]) - np.std(behToShow[ np.logical_not(np.isnan(behToShow[:, dim])), dim]), xmin=timeToShow[np.min( np.where( np.equal(sessionValue_toshow, k)))], xmax=timeToShow[np.max( np.where( np.equal(sessionValue_toshow, k)))], color=colorSess[idk], linewidth=3.0) #TODO add histograms here... slider = plt.Slider(ax[-2], 'test starting index', 0, behToShow.shape[0] - SetData['sizeTest'], valinit=SetData['testsetId'], valstep=1) sliderSize = plt.Slider(ax[-1], 'test size', 0, behToShow.shape[0], valinit=SetData['sizeTest'], valstep=1) if SetData['useLossPredTrainSet']: buttLossPred = plt.Button(ax[-5], "lossPred", color="orange") else: buttLossPred = plt.Button(ax[-5], "lossPred", color="white") sliderLossPredTrain = plt.Slider( ax[-4], "loss network training \n set starting index", 0, behToShow.shape[0], valinit=0, valstep=1) sliderLossPredTrainSize = plt.Slider(ax[-3], "loss network training set size", 0, behToShow.shape[0], valinit=SetData['sizeTest'], valstep=1) # Next we add buttons to select the sessions we would like to keep: butts = [ plt.Button(ax[len(ax) - k - 6], sessionNames[k], color=colorSess[k]) for k in range(len(colorSess)) ] if IsMultiSessions: for id in id_sleep: ax[len(ax) - id - 6].set_axis_off() def update(val): SetData['testsetId'] = slider.val SetData['sizeTest'] = sliderSize.val SetData['lossPredSetId'] = sliderLossPredTrain.val SetData['sizelossPredSet'] = sliderLossPredTrainSize.val if IsMultiSessions: trainEpoch, testEpochs, lossPredSetEpochs = ep.get_epochs( timeToShow, SetData, keptSession, starts=sessionStart, stops=sessionStop) else: trainEpoch, testEpochs, lossPredSetEpochs = ep.get_epochs( timeToShow, SetData, keptSession) for dim in range(len(ls)): l1, l2, l3 = ls[dim] if isinstance(l1, list): for iaxis in range(len(l1)): l1[iaxis].set_offsets( np.transpose( np.stack([ timeToShow[ep.inEpochs( timeToShow, trainEpoch)[0]], behToShow[ ep.inEpochs(timeToShow, trainEpoch)[0], dim] ]))) l2[iaxis].set_offsets( np.transpose( np.stack([ timeToShow[ep.inEpochs( timeToShow, testEpochs)[0]], behToShow[ ep.inEpochs(timeToShow, testEpochs)[0], dim] ]))) if SetData['useLossPredTrainSet']: try: ls[dim][2][iaxis].remove() # l3[iaxis].remove() except: pass else: try: ls[dim][2][iaxis].remove() # l3[iaxis].remove() except: pass if SetData['useLossPredTrainSet']: ls[dim][2] = ax[dim].scatter( timeToShow[ep.inEpochs(timeToShow, lossPredSetEpochs)[0]], behToShow[ ep.inEpochs(timeToShow, lossPredSetEpochs)[0], dim], c="orange", s=0.5) else: l1.set_offsets( np.transpose( np.stack([ timeToShow[ep.inEpochs(timeToShow, trainEpoch)[0]], behToShow[ ep.inEpochs(timeToShow, trainEpoch)[0], dim] ]))) l2.set_offsets( np.transpose( np.stack([ timeToShow[ep.inEpochs(timeToShow, testEpochs)[0]], behToShow[ ep.inEpochs(timeToShow, testEpochs)[0], dim] ]))) if SetData['useLossPredTrainSet']: try: ls[dim][2].remove() except: pass ls[dim][2] = ax[dim].scatter( timeToShow[ep.inEpochs(timeToShow, lossPredSetEpochs)[0]], behToShow[ ep.inEpochs(timeToShow, lossPredSetEpochs)[0], dim], c="orange", s=0.5) else: try: l3.remove() except: pass fig.canvas.draw_idle() slider.on_changed(update) sliderSize.on_changed(update) sliderLossPredTrain.on_changed(update) sliderLossPredTrainSize.on_changed(update) def buttUpdate(id): def buttUpdate(val): if keptSession[id]: butts[id].color = [0, 0, 0, 0] keptSession[id] = 0 else: keptSession[id] = 1 butts[id].color = colorSess[id] update(0) return buttUpdate [b.on_clicked(buttUpdate(id)) for id, b in enumerate(butts)] def buttUpdateLossPred(val): if SetData['useLossPredTrainSet']: buttLossPred.color = [0, 0, 0, 0] SetData['useLossPredTrainSet'] = False else: SetData['useLossPredTrainSet'] = True buttLossPred.color = "orange" update(0) return SetData['useLossPredTrainSet'] buttLossPred.on_clicked(buttUpdateLossPred) suptitle_str = 'Please choose train and test sets. You can include validation set' plt.suptitle(suptitle_str, fontsize=22) plt.get_current_fig_manager().window.showMaximized() plt.show() testSetId = slider.val sizeTest = sliderSize.val lossPredSetId = sliderLossPredTrain.val sizelossPredSet = sliderLossPredTrainSize.val if IsMultiSessions: trainEpoch, testEpochs, lossPredSetEpochs = ep.get_epochs( timeToShow, SetData, keptSession, starts=sessionStart, stops=sessionStop) else: trainEpoch, testEpochs, lossPredSetEpochs = ep.get_epochs( timeToShow, SetData, keptSession) if "testEpochs" in children: f.remove_node("/behavior", "testEpochs") f.create_array("/behavior", "testEpochs", testEpochs) if "trainEpochs" in children: f.remove_node("/behavior", "trainEpochs") f.create_array("/behavior", "trainEpochs", trainEpoch) if "keptSession" in children: f.remove_node("/behavior", "keptSession") f.create_array("/behavior", "keptSession", keptSession) if "lossPredSetEpochs" in children: f.remove_node("/behavior", "lossPredSetEpochs") if SetData['useLossPredTrainSet']: f.create_array("/behavior", "lossPredSetEpochs", lossPredSetEpochs) else: f.create_array("/behavior", "lossPredSetEpochs", []) f.flush() #effectively write down the modification we just made fig, ax = plt.subplots() trainMask = ep.inEpochsMask(positionTime, trainEpoch)[:, 0] testMask = ep.inEpochsMask(positionTime, testEpochs)[:, 0] ax.scatter(positionTime[trainMask], positions[trainMask, 0], c="red") ax.scatter(positionTime[testMask], positions[testMask, 0], c="black") if SetData['useLossPredTrainSet']: lossPredMask = ep.inEpochsMask(positionTime, lossPredSetEpochs)[:, 0] ax.scatter(positionTime[lossPredMask], positions[lossPredMask, 0], c="orange") fig.show()
def speed_filter(folder, overWrite=False): ## A simple tool to set up a threshold on the speed value # The speed threshold is then implemented through a speed_mask: # a boolean array indicating for each index (i.e measured feature time step) # if it is above threshold or not. # Parameters window_len = 14 #changed following Dima's advice with tables.open_file(folder + 'nnBehavior.mat', "a") as f: children = [c.name for c in f.list_nodes("/behavior")] if "speedMask" in children: print("speedMask already created") if overWrite: f.remove_node("/behavior", "speedMask") else: return # Prepare data positions = f.root.behavior.positions speed = f.root.behavior.speed positionTime = f.root.behavior.position_time sessionNames = [ "".join([chr(c) for c in l[0][:, 0]]) for l in f.root.behavior.SessionNames[:, 0] ] if sessionNames[0] != 'Recording': IsMultiSessions = True sessionStart = f.root.behavior.SessionStart[:, :][:, 0] sessionStop = f.root.behavior.SessionStop[:, :][:, 0] else: IsMultiSessions = False positions = np.swapaxes(positions[:, :], 1, 0) speed = np.swapaxes(speed[:, :], 1, 0) posTime = np.swapaxes(positionTime[:, :], 1, 0) if speed.shape[0] == posTime.shape[0] - 1: speed = np.append(speed, speed[-1]) speed = np.reshape(speed, [speed.shape[0], 1]) # Make sure all variables stay in the time limits tmin = 0 tmax = posTime[-1] myposTime = posTime[((posTime >= tmin) * (posTime <= tmax))[:, 0]] myspeed = speed[((posTime >= tmin) * (posTime <= tmax))[:, 0]] # Select the representative behavior to show epochToShow = [] if IsMultiSessions: hab_list = [ re.search('hab', sessionNames[x], re.IGNORECASE) for x in range(len(sessionNames)) ] id_hab = [x for x in range(len(hab_list)) if hab_list[x] != None] sleep_list = [ re.search('sleep', sessionNames[x], re.IGNORECASE) for x in range(len(sessionNames)) ] id_sleep = [ x for x in range(len(sleep_list)) if sleep_list[x] != None ] if id_hab: for id in id_hab: epochToShow.extend([sessionStart[id], sessionStop[id]]) elif id_sleep: id_toshow = list(range(id_sleep[0] + 1, id_sleep[1])) # in between two sleeps for id in id_toshow: epochToShow.extend([sessionStart[id], sessionStop[id]]) else: epochToShow.extend([ myposTime[0, 0], myposTime[-1, 0] ]) # if no sleeps, or session names, or hab take everything maskToShow = ep.inEpochsMask(myposTime[:, 0], epochToShow) behToShow = positions[maskToShow, :] timeToShow = myposTime[maskToShow, 0] # Smooth speed s = np.r_[myspeed[window_len - 1:0:-1], myspeed, myspeed[-2:-window_len - 1:-1]] w = eval('np.' + "hamming" + '(window_len)') myspeed2 = np.convolve(w / w.sum(), s[:, 0], mode='valid')[(window_len // 2 - 1):-(window_len // 2)] speedToshowSm = myspeed2[maskToShow] speedThreshold = np.mean( np.log(speedToshowSm[speedToshowSm >= 0] + 10**(-8))) speedFilter = speedToshowSm > np.exp(speedThreshold) # Figure fig = plt.figure(figsize=(7, 15)) fig.suptitle("Speed threshold selection", fontsize=18, fontweight='bold') # Coordinates over time ax0 = fig.add_subplot(6, 2, (1, 2)) l1, = ax0.plot(timeToShow[speedFilter], behToShow[speedFilter, 0], c="red") l2, = ax0.plot(timeToShow[speedFilter], behToShow[speedFilter, 1], c="orange") l3 = ax0.scatter(timeToShow[speedFilter], np.zeros(timeToShow[speedFilter].shape[0]) - 4, c="black", s=0.2) ax0.set_ylabel("environmental \n variable") # Speed over time ax1 = fig.add_subplot(6, 2, (3, 4), sharex=ax0) l4, = ax1.plot(timeToShow[speedFilter], speedToshowSm[speedFilter], c="purple") # smoothed ax1.set_ylabel("speed") ax1.set_xlabel("Time (s)") # Speed histogram ax2 = fig.add_subplot(6, 2, 7) speed_log = np.log(speedToshowSm[np.not_equal(speedToshowSm, 0)] + 10**(-8)) ax2.hist(speed_log, histtype="step", bins=200, color="blue") ax2.set_yticks([]) l5 = ax2.axvline(speedThreshold, color="black") ax2.set_xlabel("log speed") ax2.set_xlim(np.percentile(speed_log[~np.isnan(speed_log)], 0.3), np.max(speed_log[~np.isnan(speed_log)])) ax3 = fig.add_subplot(6, 2, 8) speed_plot = speedToshowSm[np.not_equal(speedToshowSm, 0)] ax3.hist(speed_plot, histtype="step", bins=200, color="blue") ax3.set_yticks([]) l6 = ax3.axvline(np.exp(speedThreshold), color="black") ax3.set_xlabel("raw speed") ax3.set_xlim(0, np.percentile(speed_plot[~np.isnan(speed_plot)], 98)) ax4 = fig.add_subplot(6, 2, (11, 12)) slider = plt.Slider( ax4, ' ', np.min(np.log(speedToshowSm[speedToshowSm >= 0] + 10**(-8))), np.max(np.log(speedToshowSm[speedToshowSm >= 0] + 10**(-8))), valinit=speedThreshold, valstep=0.01) ax4.set_ylabel("speed Threshold") ax = [ax0, ax1, ax2, ax3, ax4] def update(val): speedThreshold = val speedFilter = speedToshowSm > np.exp(speedThreshold) l1.set_ydata(behToShow[speedFilter, 0]) l2.set_ydata(behToShow[speedFilter, 1]) l1.set_xdata(timeToShow[speedFilter]) l2.set_xdata(timeToShow[speedFilter]) l3.set_offsets( np.transpose( np.stack([ timeToShow[speedFilter], np.zeros(timeToShow[speedFilter].shape[0]) - 4 ]))) l4.set_ydata(speedToshowSm[speedFilter]) l4.set_xdata(timeToShow[speedFilter]) l5.set_xdata(val) l6.set_xdata(np.exp(val)) fig.canvas.draw_idle() slider.on_changed(update) plt.show() # Final value speedFilter = myspeed2 > np.exp( slider.val) # Apply the value to the whole dataset f.create_array("/behavior", "speedMask", speedFilter) f.flush() f.close() # Change the way you save df = pd.DataFrame([np.exp(slider.val)]) df.to_csv(folder + "speedFilterValue.csv") #save the speed filter value
def __init__(self, doneCallback, skipCallback, dumpCallback, exitCallback, prevCallback, background, MAX_PROMINENCE=6.0, FALSE_MAXIMUM_ROW_DISTANCE = 30): self.MAX_PROMINENCE = MAX_PROMINENCE self.FALSE_MAXIMUM_ROW_DISTANCE = FALSE_MAXIMUM_ROW_DISTANCE self.doneCallback = doneCallback self.skipCallback = skipCallback self.dumpCallback = dumpCallback self.exitCallback = exitCallback self.prevCallback = prevCallback self.fig = plt.figure() self.ax = self.fig.add_subplot(111) self.background = background self.ax.set_xlabel("Time") self.ax.set_ylabel("Voltage") self.titleColor = 'black' self.ax.name = 'main' self.fig.subplots_adjust(bottom=0.27, top=0.92, left=0.08, right=0.94) # Define an axes area and draw a slider in it min_prom_slider_ax = self.fig.add_axes([0.25, 0.17, 0.65, 0.03]) self.min_prom_slider = plt.Slider(min_prom_slider_ax, 'Min. Prom.', 0.0, MAX_PROMINENCE, valinit=MAX_PROMINENCE) # Draw another slider max_prom_slider_ax = self.fig.add_axes([0.25, 0.12, 0.65, 0.03]) self.max_prom_slider = plt.Slider(max_prom_slider_ax, 'Max. Prom.', 0.0, MAX_PROMINENCE, valinit=MAX_PROMINENCE) self.min_prom_slider.on_changed(self.updateProminence) self.max_prom_slider.on_changed(self.updateProminence) self.doneButtonTitle = 'Done' doneButtonAxes = plt.axes([0.80, 0.05, 0.1, 0.045]) self.doneButton = plt.Button(doneButtonAxes, self.doneButtonTitle) self.doneButton.on_clicked(self.done) resetBtn = plt.axes([0.69, 0.05, 0.1, 0.045]) self.resetButton = plt.Button(resetBtn, 'Auto') self.resetButton.on_clicked(self.reset) skipButtonAxes = plt.axes([0.58, 0.05, 0.1, 0.045]) self.skipButton = plt.Button(skipButtonAxes, 'Skip') self.skipButton.on_clicked(self.skip) dumpButtonAxes = plt.axes([0.47, 0.05, 0.1, 0.045]) self.dumpButton = plt.Button(dumpButtonAxes, 'Dump') self.dumpButton.on_clicked(self.dump) clearButtonAxes = plt.axes([0.36, 0.05, 0.1, 0.045]) self.clearButton = plt.Button(clearButtonAxes, 'Clear') self.clearButton.on_clicked(self.clear) prevButtonAxes = plt.axes([0.25, 0.05, 0.1, 0.045]) self.prevButton = plt.Button(prevButtonAxes, 'Prev') self.prevButton.on_clicked(self.prev) exitButtonAxes = plt.axes([0.14, 0.05, 0.1, 0.045]) self.exitButton = plt.Button(exitButtonAxes, 'Exit') self.exitButton.on_clicked(self.exit) self.fig.canvas.mpl_connect('button_press_event', self.onclick)
ax.set_zlim3d(0, 1.5 * max_q) ax.set_xlabel('x', fontsize=22) ax.set_ylabel('z', fontsize=22) ax.set_zlabel('y', fontsize=22) # Detector axdet = plt.axes([0.6, 0.1, 0.4, 0.8]) plt.sca(axdet) pl_im = plt.imshow(detector_image) pl_im.set_clim(0, 1) axsldr1 = plt.axes([0.1, 0.4, 0.35, 0.06], facecolor='lightgoldenrodyellow') axsldr2 = plt.axes([0.1, 0.3, 0.35, 0.06], facecolor='lightgoldenrodyellow') axsldr3 = plt.axes([0.1, 0.2, 0.35, 0.06], facecolor='lightgoldenrodyellow') axsldr4 = plt.axes([0.1, 0.1, 0.35, 0.06], facecolor='lightgoldenrodyellow') sldr1 = plt.Slider(axsldr1, 'phi', -180, 180, valinit=0, valfmt='%5.2f') sldr2 = plt.Slider(axsldr2, 'chi', -98, 98, valinit=90, valfmt='%5.2f') sldr3 = plt.Slider(axsldr3, 'eta', -40, 220, valinit=0, valfmt='%5.2f') sldr4 = plt.Slider(axsldr4, 'delta', 0, 160, valinit=detector_del, valfmt='%5.2f') def update_all(val): "Update function for pilatus image" phi, chi, eta, delta = sldr1.val, sldr2.val, sldr3.val, sldr4.val
def sliderplot2D(ZZZ, XX=None, YY=None, slidervals=None, *args, **kwargs): """ Shortcut to creating an image plot with a slider to go through a third dimension ZZZ = [nxmxo]: z axis data XX = [nxm] or [n]: x axis data YY = [nxm] or [m]: y axis data slidervals = None or [o]: Values to give in the slider if XX and/or YY have a single dimension, the 2D values are generated via meshgrid E.G. sliderplot([1,2,3],[[2,4,6],[8,10,12],[14,16,18],[20,22,24]],slidervals=[3,6,9,12]) """ if 'linewidth' and 'lw' not in kwargs.keys(): kwargs['linewidth'] = 2 fig = plt.figure(figsize=FIGURE_SIZE, dpi=FIGURE_DPI) ZZZ = np.asarray(ZZZ, dtype=np.float) if slidervals is None: slidervals = range(ZZZ.shape[2]) slidervals = np.asarray(slidervals, dtype=np.float) if XX is None: XX = range(ZZZ.shape[1]) if YY is None: YY = range(ZZZ.shape[0]) XX = np.asarray(XX, dtype=np.float) YY = np.asarray(YY, dtype=np.float) if XX.ndim < 2: XX, YY = np.meshgrid(XX, YY) p = plt.pcolormesh(XX, YY, ZZZ[:, :, 0]) # p.set_clim(cax) plt.subplots_adjust(bottom=0.2) ax = plt.gca() ax.set_aspect('equal') ax.autoscale(tight=True) " Create slider on plot" axsldr = plt.axes([0.15, 0.05, 0.65, 0.03], axisbg='lightgoldenrodyellow') sldr = plt.Slider(axsldr, '', 0, len(slidervals) - 1) txt = axsldr.set_xlabel('{} [{}]'.format(slidervals[0], 0), fontsize=18) plt.sca(ax) " Slider update function" def update(val): "Update function for pilatus image" pno = int(np.round(sldr.val)) p.set_array(ZZZ[:-1, :-1, pno].ravel()) txt.set_text('{} [{}]'.format(slidervals[pno], pno)) plt.draw() plt.gcf().canvas.draw() # fig1.canvas.draw() sldr.on_changed(update)
fig.canvas.mpl_connect('button_press_event', onClick) anim = animation.FuncAnimation(fig, animate, init_func=init, frames=360, interval=20, blit=True, repeat=True) ############################################################################### ############################## Put sliders axslider_inc = plt.axes([0.1, 0.92, 0.25, 0.03]) s_inc = plt.Slider(axslider_inc, 'Inc ', 0, 90, valfmt='%0d', valinit=90) s_inc.on_changed(update) axslider_node = plt.axes([0.65, 0.92, 0.25, 0.03]) s_node = plt.Slider(axslider_node, 'Node Angle', -90, 90, valfmt='%0d', valinit=0) s_node.on_changed(update) axslider_a = plt.axes([0.1, 0.06, 0.5, 0.03]) s_a = plt.Slider(axslider_a, 'a ', 0.1, 10.0, valfmt='%0.1f', valinit=1.0) s_a.on_changed(update)
# --- Sliders Start --- ''' Some Interface stuff. Also here it would be great to have some automatic function which does this... instead of writing each line, something which detects what parameters are to be used and then auto finds space and creates a slider for it. ''' fig3 = plt.figure(3) fig3.clear() axcolor = 'lightgoldenrodyellow' axATT = plt.axes([0.25, 0.90, 0.50, 0.02], axisbg=axcolor) sATT = plt.Slider(axATT, 'Attenuation dBm', -90, -20.0, valinit=-51.44, valfmt='%1.5f') axPHI = plt.axes([0.25, 0.87, 0.50, 0.02], axisbg=axcolor) sPHI = plt.Slider(axPHI, 'Phase offset', -np.pi, np.pi, valinit=0) axXSC = plt.axes([0.25, 0.84, 0.50, 0.02], axisbg=axcolor) sXSC = plt.Slider(axXSC, 'x-scale', 0.9, 1.1, valinit=1.04187, valfmt='%1.5f') axXPOS = plt.axes([0.25, 0.81, 0.50, 0.02], axisbg=axcolor) sXPOS = plt.Slider(axXPOS, 'x-pos', -0.5, 0.5, valinit=-0.49125, valfmt='%1.5f') axWb = plt.axes([0.25, 0.49, 0.50, 0.02], axisbg=axcolor) sWb = plt.Slider(axWb, 'WireBond Ind. pH', 0, 2000, valinit=1200.0)
plt.ylabel('$м^3$') fig2 = plt.figure(2) ax2 = fig2.add_subplot(1, 1, 1) p2, = ax2.plot(weeks, y) plt.title('Витрати води') plt.xlabel('номер неділі від 2019 року') plt.ylabel('$м^3/c$') plt.subplots_adjust(bottom=0.25) axfreq = plt.axes([0.25, 0.1, 0.65, 0.03]) height_slider = plt.Slider( ax=axfreq, label='Висота греблі (м)', valmin=1, valmax=100, valstep=1, valinit=H, ) fig3 = plt.figure(3) ax3 = fig3.add_subplot(1, 1, 1) p3, = ax3.plot(weeks, e(H)) plt.title('Кількість виробленої энергії від 2019 року') plt.xlabel('номер неділі від 2019 року') plt.ylabel('(кВт/час)') fig4 = plt.figure(4) ax4 = fig4.add_subplot(1, 1, 1) p4, = ax4.plot(weeks, de(H)) plt.title('Кількість виробленої энергії у неділю')
def image_slider(self, index=None, axis=0, clim=None, cmap=None, colorbar=False, **kwargs): """ Plot image in matplotlib figure with a slider (if available) :param index: int, image index, 0-length of scan, if None, use centre index :param axis: int, axis to index (0-2) :param clim: [min, max] colormap cut-offs (None for auto) :param cmap: str colormap name (None for auto) :param colorbar: False/ True add colorbar to plot :param kwargs: additinoal arguments for plot_detector_image :return: axes object """ if index is None: index = self.vol.shape[axis] // 2 # Create figure show = False if 'axes' not in kwargs: show = True axes = create_axes(subplot=111) kwargs['axes'] = axes axes = self.image(index, axis, clim, cmap, colorbar, **kwargs) # pcolormesh object pcolor = axes.collections[0] # Move axes for slider bbox = axes.get_position() left, bottom, width, height = bbox.x0, bbox.y0, bbox.width, bbox.height change_in_height = height * 0.1 new_position = [ left, bottom + 2 * change_in_height, width, height - 2 * change_in_height ] new_axes_position = [left, bottom, width, change_in_height] axes.set_position(new_position, 'original') new_axes = axes.figure.add_axes(new_axes_position) sldr = plt.Slider(new_axes, 'Volume', 0, self.vol.shape[axis], valinit=index, valfmt='%0.0f') def update(val): """Update function for pilatus image""" imgno = int(round(sldr.val)) if axis == 1: im = self.vol[:, imgno, :] elif axis == 2: im = self.vol[:, :, imgno] else: im = self.vol[imgno] pcolor.set_array(im.flatten()) plt.draw() # fig.canvas.draw() sldr.on_changed(update) if show: plt.show() return axes
def imshow(data, title=None, isrgb=True, vmin=0, vmax=None, cmap=None, miniswhite=False, interpolation='bilinear', dpi=96, figure=None, subplot=111, show_hist = False, auto_scale = False, **kwargs): """Plot n-dimensional images using matplotlib.pyplot. Return figure, subplot and plot axis. Requires pyplot already imported ``from matplotlib import pyplot``. Arguments --------- isrgb : bool If True, data will be displayed as RGB(A) images if possible. miniswhite : bool If True, gray scale palette will be inverted. title : str Window and subplot title figure : a matplotlib.figure.Figure instance (optional) subplot : int A matplotlib.pyplot.subplot axis Other arguments are same as for matplotlib.pyplot.imshow. """ data = data.squeeze() dims = len(data.shape) if dims < 2 or dims>3: raise ValueError("not an image") if dims == 2: data = numpy.array([data], data.dtype) dims = len(data.shape) if (isrgb and data.shape[-3] in (3, 4)): data = numpy.swapaxes(data, -3, -2) data = numpy.swapaxes(data, -2, -1) elif (not isrgb and data.shape[-1] in (3, 4)): data = numpy.swapaxes(data, -3, -1) data = numpy.swapaxes(data, -2, -1) isrgb = isrgb and data.shape[-1] in (3, 4) dims -= 3 if isrgb else 2 datamax = data.max() datamin = data.min() if datamin < 0: vmin = datamin if data.dtype in (numpy.int8, numpy.int16, numpy.int32, numpy.uint8, numpy.uint16, numpy.uint32): for bits in (8, 10, 12, 14, 16, 20, 24, 32): if datamax < 2**bits: datamax = 2**bits break if isrgb and data.dtype != numpy.uint8: data *= (255.0 / datamax) # better use digitize() data = data.astype('B') elif isrgb: data /= datamax if not isrgb and vmax is None: vmax = data.max() datamax = data.max() import matplotlib.pyplot as pyplot if figure is None: pyplot.rc('font', family='sans-serif', weight='normal', size=8) figure = pyplot.figure(dpi=dpi, figsize=(10.3, 6.3), frameon=True, facecolor='1.0', edgecolor='w') try: figure.canvas.manager.window.title(title) except Exception: pass pyplot.subplots_adjust(bottom=0.03*(dims+2), top=0.925, left=0.1, right=0.95, hspace=0.05, wspace=0.0) subplot = pyplot.subplot(subplot) if title: pyplot.title(title, size=11) if cmap is None: cmap = pyplot.cm.binary if miniswhite else pyplot.cm.gray current = list((0, ) * dims) current[0] = data.shape[0]//2 image = pyplot.imshow(data[tuple(current)].squeeze(), vmin=vmin, vmax=vmax, cmap=cmap, interpolation=interpolation, **kwargs) p = image.axes.get_position () cbar = None if not isrgb: cbar = pyplot.colorbar() tick_values = [] from ..utils import tostr if dims: current_axis = [0] sliders = [pyplot.Slider( pyplot.axes([0.125, 0.03*(axis+1), 0.725, 0.025]), 'Dimension %i' % axis, 0, data.shape[axis]-1, 0, #facecolor='0.5', valfmt='%%.0f of %i' % data.shape[axis]) for axis in range(dims)] for slider in sliders: slider.drawon = False if show_hist: hist = pyplot.axes([0.03,p.y0, 2*(p.x0-0.03), p.height]) hist_args = dict(bins = show_hist, orientation='horizontal') h = hist.hist(data[tuple(current)].ravel(), **hist_args) hist.set_xlim(0,h[0][1:].max()) def set_image(current, sliders=sliders, data=data, cbar=cbar, tick_values=tick_values): """Change image and redraw canvas.""" d = data[tuple(current)].squeeze() mx = d.max() if auto_scale and mx: scale = datamax/mx if cbar is not None: if not tick_values: ticks = cbar.ax.get_yticklabels() tick_values[:] = [float(t.get_text()) for t in ticks] cbar.ax.set_yticklabels(map(tostr, [t/scale for t in tick_values])) d *= scale image.set_data(d) if show_hist: p = image.axes.get_position() hist.cla() h = hist.hist(data[tuple(current)].ravel(), **hist_args) hist.set_xlim(0,h[0][1:].max()) for ctrl, index in zip(sliders, current): ctrl.eventson = False ctrl.set_val(index) ctrl.eventson = True figure.canvas.draw() def on_changed(index, axis, data=data, image=image, figure=figure, current=current): """Callback for slider change event.""" print current, axis index = int(round(index)) current_axis[0] = axis if index == current[axis]: return if index >= data.shape[axis]: index = 0 elif index < 0: index = data.shape[axis] - 1 current[axis] = index set_image(current) def on_keypressed(event, data=data, current=current): """Callback for key press event.""" key = event.key axis = current_axis[0] print current, axis if str(key) in '0123456789': on_changed(int(key), axis) elif key == 'right': on_changed(current[axis] + 1, axis) elif key == 'left': try: on_changed(current[axis] - 1, axis) except IndexError, msg: print axis, len (current), `str(msg)` elif key == 'up': current_axis[0] = 0 if axis == len(data.shape)-1 else axis + 1 elif key == 'down': current_axis[0] = len(data.shape)-1 if axis == 0 else axis - 1 elif key == 'end': on_changed(data.shape[axis] - 1, axis) elif key == 'home': on_changed(0, axis) elif key == 'm': on_changed(data.shape[axis]//2, axis) elif key == 'q': sys.exit(0)
def __init__(self, index, dm): self.current_index = index self.dm = dm self.raw_data = dm.raw_data self.p_max_locs = dm.p_max_locs self.saecg_p = dm.saecg_wrapper['saecg_p'] self.fs = dm.fs self.mode = 1 # view mode for beat viewer self.fig, self.ax = plt.subplots( nrows=5, ncols=1, gridspec_kw={'height_ratios': [1, 1, 0.1, 0.1, 1]}) self.fig.tight_layout() # Configure the layout of UI elements self.axprev = plt.axes([0.7, 0.01, 0.08, 0.03]) self.axnext = plt.axes([0.81, 0.01, 0.08, 0.03]) self.axanalyze = plt.axes([0.05, 0.01, 0.08, 0.03]) self.axmode = plt.axes([0.15, 0.01, 0.08, 0.03]) self.axpremature = plt.axes([0.25, 0.01, 0.1, 0.03]) self.bnext = Button(self.axnext, 'Next') self.bnext.on_clicked(lambda x: self.next_button_pushed(x)) self.bprev = Button(self.axprev, 'Previous') self.bprev.on_clicked(lambda x: self.prev_button_pushed(x)) self.banalyze = Button(self.axanalyze, 'Analyze') self.banalyze.on_clicked(lambda x: self.analyze_button_pushed(x)) self.bmode = Button(self.axmode, 'Mode') self.bmode.on_clicked(lambda x: self.mode_button_pushed(x)) self.bpremature = Button(self.axpremature, 'Premature Beat Analysis') self.bpremature.on_clicked(lambda x: self.premature_button_pushed(x)) plt.axes(self.ax[0]) self.ax[0].set_title('Raw Data') plt.plot(np.true_divide(range(len(self.raw_data)), self.fs), self.raw_data) plt.scatter(np.true_divide(self.dm.heartpy_params['wd']['peaklist'], self.fs), self.raw_data[self.dm.heartpy_params['wd']['peaklist']], c='g') plt.axes(self.ax[1]) title_string = 'Signal Averaged P Wave' self.ax[1].set_title(title_string) plt.plot(np.true_divide(range(len(self.saecg_p)), self.fs), self.saecg_p) # Make the slider for left edge plt.axes(self.ax[2]) self.slider_start = plt.Slider(self.ax[2], 'Start', 0, len(self.saecg_p) / self.fs, valinit=0.1 * len(self.saecg_p) / self.fs, color='blue') self.slider_start.on_changed(lambda x: self.slider_updated(x)) # Make the slider for right edge plt.axes(self.ax[3]) self.slider_end = plt.Slider(self.ax[3], 'End', 0, len(self.saecg_p) / self.fs, valinit=0.9 * len(self.saecg_p) / self.fs, color='blue') self.slider_end.on_changed(lambda x: self.slider_updated(x)) plt.axes(self.ax[1]) self.ax[1].vlines( self.slider_start.val, self.saecg_p[int(self.slider_start.val * self.fs)] - 0.02, self.saecg_p[int(self.slider_start.val * self.fs)] + 0.02, color='red') self.ax[1].vlines( self.slider_end.val, self.saecg_p[int(self.slider_end.val * self.fs)] - 0.02, self.saecg_p[int(self.slider_end.val * self.fs)] + 0.02, color='red') plt.axes(self.ax[4]) self.ax[4].clear() title_string = 'Beat %d out of %d beats' % ( self.get_current_index() + 1, len(dm.beat_wrapper['beats'])) self.ax[4].set_title(title_string) plt.plot( np.true_divide( range(len(self.dm.beat_wrapper['beats'][self.current_index])), self.fs), self.dm.beat_wrapper['beats'][self.current_index]) plt.plot(self.p_max_locs[self.get_current_index()] / self.fs, self.dm.beat_wrapper['beats'][self.get_current_index()][round( self.p_max_locs[self.get_current_index()])], marker='x') plt.plot( self.dm.xcorr_params['max_loc'][self.get_current_index()] / self.fs, self.dm.beat_wrapper['beats'][self.current_index] [self.dm.xcorr_params['max_loc'][self.get_current_index()]], 'o') mng = plt.get_current_fig_manager() mng.window.state("zoomed") plt.show()
def dynamic_plot(investor_history, ibov_var, print_ops, max_num_ops=7): """ Dynamically plots, over time, the performance of IBOVESPA and on investor. :param investor_history: performance history of the investor. :param ibov_var: price history of IBOVESPA. :param print_ops: if True, the investor's decisions (buy and sell operations) will be plot. :param max_num_ops: max number of operations to display on the screen at a time. """ # init plt.ion() figure, ax = plt.subplots() lines_ibov, = ax.plot([], [], "g", linewidth=3, alpha=0.6) lines_inv, = ax.plot([], [], "r", linewidth=3, alpha=0.6) BASE_PAUSE_TIME = 1 pause_time = BASE_PAUSE_TIME ax.set_autoscaley_on(True) ax.set_xlim(0, len(ibov_var)) ax.grid() plt.legend(['IBOV', "Investor"], loc='upper left') plt.xlabel("Time (days)") plt.gca().yaxis.set_major_formatter(mticker.FormatStrFormatter('%.1f%%')) figure.subplots_adjust(left=0.25, bottom=0.25) # speed slider spd_slider_ax = figure.add_axes([0.42, 0.07, 0.3, 0.05], facecolor='lightgoldenrodyellow') spd_slider = plt.Slider(spd_slider_ax, 'Speed', 0.2, 20, valinit=BASE_PAUSE_TIME) def spd_slider_on_changed(val): nonlocal pause_time pause_time = BASE_PAUSE_TIME / val spd_slider.on_changed(spd_slider_on_changed) # plot xdata = [] ydata_inv = [] ydata_ibov = [] pc_ann_inv = pc_ann_ibov = None op_points = [] op_annotations = [] for x in range(len(ibov_var)): # set data xdata.append(x) ydata_inv.append(investor_history[0][x]) ydata_ibov.append(ibov_var[x]) lines_inv.set_xdata(xdata) lines_inv.set_ydata(ydata_inv) lines_ibov.set_xdata(xdata) lines_ibov.set_ydata(ydata_ibov) # rescale ax.relim() ax.autoscale_view() # percentage annotation if pc_ann_ibov is not None: pc_ann_ibov.remove() pc_ann_ibov = ax.annotate('%0.2f%%' % ydata_ibov[-1], xy=(1, ydata_ibov[-1]), xytext=(8, 0), color=lines_ibov.get_color(), xycoords=('axes fraction', 'data'), textcoords='offset points', weight="bold") if pc_ann_inv is not None: pc_ann_inv.remove() pc_ann_inv = ax.annotate('%0.2f%%' % ydata_inv[-1], xy=(1, ydata_inv[-1]), xytext=(8, 0), color=lines_inv.get_color(), xycoords=('axes fraction', 'data'), textcoords='offset points', weight="bold") # op annotation if print_ops and investor_history[1][x][1] != 0: color = "g" if investor_history[1][x][0] == "BUY" else "r" p, = ax.plot([xdata[-1]], [ydata_inv[-1]], marker='o', markersize=5, color=color) op_points.append(p) op_annotations.append( ax.annotate("%d" % investor_history[1][x][1], xy=(xdata[-1], ydata_inv[-1]), xytext=(xdata[-1] - 0.25, ydata_inv[-1] - 0.25), color=color, weight="bold", fontsize=8, arrowprops={"arrowstyle": "->"})) if len(op_annotations) > max_num_ops: op_points.pop(0).remove() op_annotations.pop(0).remove() # remove the oldest annotation # draw and delay plt.pause(pause_time) plt.ioff() plt.show()
v_speed=0, fuel=500, rotation=0, power=0) dt = 1. / 40 fig, ax = plt.subplots() ax.set_position([0.1, 0.2, 0.8, 0.7]) ship_position, = ax.plot(ship.x, ship.y, 'bo', ms=6) # SLIDERS ax_power = plt.axes([0.2, 0.02, 0.5, 0.02]) ax_rotation = plt.axes([0.2, 0.08, 0.5, 0.02]) slider_power = plt.Slider(ax_power, 'Power', valmin=0, valmax=4, valinit=0, valstep=1) slider_rotation = plt.Slider(ax_rotation, 'Rotation', valmin=-90, valmax=90, valinit=0, valstep=1) slider_power.on_changed(update_power) slider_rotation.on_changed(update_rotation) # TEXTS time_text = ax.text(0.02, 0.95, '', transform=ax.transAxes) power_text = ax.text(0.02, 0.90, '', transform=ax.transAxes) rotation_text = ax.text(0.02, 0.85, '', transform=ax.transAxes)
mpl.xlim(Idler_Motion_Pts.x_lim) mpl.ylim(Idler_Motion_Pts.y_lim) mpl.xlabel('x') mpl.ylabel('y') mpl.grid() mpl.gca().set_aspect('equal', adjustable='box') ## Plot constant tValues along f(t, thetaSpace) # Color axcolor = 'lightgoldenrodyellow' ax_θ_O = mpl.axes([0.25, 0.1, 0.5, 0.05], facecolor=axcolor) sliθ_O = mpl.Slider(ax_θ_O, 'θ_O (Rotation Around P_0)', Omega_O.linspace[0], Omega_O.linspace[-1]) sliθ_O.set_val(C_motion_all_t.Vars['omega_O'].val) def update(val): C_motion_all_t.Vars['omega_O'].val = val C_motion_all_t.coord_gen() handle_plot.set_xdata(C_motion_all_t.x[-1]) handle_plot.set_ydata(C_motion_all_t.y[-1]) fig.canvas.draw_idle() sliθ_O.on_changed(update) mpl.show()
room.plot(ax) # Detector axdet = plt.axes([0.6, 0.1, 0.4, 0.8]) room.plot_detector(axdet) axdet.axis('image') axsldr1 = plt.axes([0.1, 0.45, 0.35, 0.06], facecolor='lightgoldenrodyellow') axsldr2 = plt.axes([0.1, 0.37, 0.35, 0.06], facecolor='lightgoldenrodyellow') axsldr3 = plt.axes([0.1, 0.29, 0.35, 0.06], facecolor='lightgoldenrodyellow') axsldr4 = plt.axes([0.1, 0.21, 0.35, 0.06], facecolor='lightgoldenrodyellow') axsldr5 = plt.axes([0.1, 0.13, 0.35, 0.06], facecolor='lightgoldenrodyellow') axsldr6 = plt.axes([0.1, 0.05, 0.35, 0.06], facecolor='lightgoldenrodyellow') sldr1 = plt.Slider(axsldr1, 'phi', -180, 180, valinit=diffractometer.phi, valfmt='%5.2f') sldr2 = plt.Slider(axsldr2, 'chi', -98, 98, valinit=diffractometer.chi, valfmt='%5.2f') sldr3 = plt.Slider(axsldr3, 'eta', -20, 200, valinit=diffractometer.eta, valfmt='%5.2f') sldr4 = plt.Slider(axsldr4,
inp = autoencoder.get_layer(index=-1-middle).input_shape[1:] inp = Input(shape=(inp[0], inp[1], 1)) x = autoencoder.get_layer(index=-1-middle)(inp) for i in range(1, middle+1): x = autoencoder.get_layer(index=-1-(middle-i))(x) decode = Model(inp, x) def update(val): vals = [] """"for s in slider: vals.append(s.val)""" for i in range(decode.get_input_shape_at(0)[1]): vals.append([]) for i2 in range(decode.get_input_shape_at(0)[2]): vals[-1].append([slider[i*decode.get_input_shape_at(0)[2]+i2].val]) plt.subplot(211) image = decode.predict(np.array([vals])) plt.imshow(image.reshape(img_height, img_width)) axcolor = 'lightgoldenrodyellow' slider = [] """for i in range(int(img_height/2**LAYER_COUNT)):""" for i in range(decode.get_input_shape_at(0)[2]*decode.get_input_shape_at(0)[1]): ax = plt.axes([0.25, (decode.get_input_shape_at(0)[2]*decode.get_input_shape_at(0)[1]-i)*0.1, 0.65, 0.03], facecolor=axcolor) slider.append(plt.Slider(ax, 'input'+str(i), 0, 30)) slider[-1].on_changed(update) update(0) plt.show()
maxval = xdata.max() else: maxval = ydata.max() ax.set_xlim(minval, maxval) ax.set_ylim(minval, maxval) spacing = np.linspace(0.1, 0.05, 2) thickness = 0.02 ax_a = plt.axes([0.3, spacing[0], 0.5, thickness], facecolor='white') ax_b = plt.axes([0.3, spacing[1], 0.5, thickness], facecolor='white') sldr_a = plt.Slider(ax_a, 'Rotation Rate', s1 - 0.01, s1 + 0.01, valinit=s1, valfmt='%0.5f', color='gray') sldr_b = plt.Slider(ax_b, 'Speed Factor', s2 - 2, s2 + 2, valinit=s2, valfmt='%0.5f', color='gray') def update(val): s1 = sldr_a.val s2 = sldr_b.val
import numpy as np from matplotlib import pyplot, animation from mpl_toolkits.mplot3d import Axes3D #Enables 3D functionality from time import sleep from mechlib import geometry as g #Objects p1 = g.Vector3() p2 = g.Vector3(1, 1, 1) graphables = [g.Origin(origin=p1), g.Origin(origin=p2), g.Line(p1, p2)] #SETUP fig = pyplot.figure(figsize=plt.figaspect(2.)) #The graphical figure fig.suptitle('3D Lin-Alg Rotations') ax = fig.add_subplot(2, 1, 1, projection='3d') #The graphing subplot setAxesRange(ax3D, 4) #Drawing for o in graphables: o.draw(ax) ax = fig.add_subplot(2, 1, 2) #The slider subplot s = pyplot.Slider(axSlider, "Theta", 0, 360, 0) #The slider fig.show() #SHOW #while True: # graphables[0].rotate('z', np.radians(s.val)) # fig.canvas.draw()
def interactive_3d_plot(vid_path, triangulated_csv_path, skeleton_path=None, figure_size=(9, 5), marker_size=5, skeleton_thickness=1): """Makes an interactive 3D plot with video and a slider to control the frame number. Arguments: vid_path {str} -- location of the video to observe. triangulated_csv_path {str} -- location of csv with triangulated points corresponding to the video given in vid_path. """ global FIG, FIGNUM, AXS, SLIDER # Import the triangulated CSV with open(triangulated_csv_path, 'r') as f: triagreader = csv.reader(f) l = next(triagreader) bodyparts = [] for i, bp in enumerate(l): if (i - 1) % 3 == 0: bodyparts.append(bp) num_bodyparts = len(bodyparts) next(triagreader) triangulated_points = [] for row in triagreader: triangulated_points.append([[] for _ in range(3)]) for ibp in range(num_bodyparts): triangulated_points[-1][0].append(float(row[1 + ibp * 3])) triangulated_points[-1][1].append(float(row[2 + ibp * 3])) triangulated_points[-1][2].append(float(row[3 + ibp * 3])) triangulated_points = np.array(triangulated_points) # Get the video video = cv2.VideoCapture(vid_path) num_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT)) if skeleton_path is not None: with open(skeleton_path, 'r') as yaml_file: dic = yaml.safe_load(yaml_file) bp_list = dic['bodyparts'] bp_connections = dic['skeleton'] skeleton = True else: skeleton = False # Check the number of frames vs number of rows in csv if num_frames != np.shape(triangulated_points)[0]: raise Warning( 'Number of frames in video and rows in CSV are not equal. Check that the paths' + ' given are correct.') # Initalize the plots cmap = matplotlib.cm.get_cmap('jet') color_idx = np.linspace(0, 1, num_bodyparts) bp_cmap = cmap(color_idx) # Limits in space of the markers + 10% margin = 1.3 pcntl = 2 x_range = (np.nanpercentile(triangulated_points[:, 0, :], pcntl) * margin, np.nanpercentile(triangulated_points[:, 0, :], 100 - pcntl) * margin) y_range = (np.nanpercentile(triangulated_points[:, 1, :], pcntl) * margin, np.nanpercentile(triangulated_points[:, 1, :], 100 - pcntl) * margin) z_range = (np.nanpercentile(triangulated_points[:, 2, :], pcntl) * margin, np.nanpercentile(triangulated_points[:, 2, :], 100 - pcntl) * margin) FIG = mpl_pp.figure(figsize=figure_size) FIGNUM = mpl_pp.gcf().number AXS = [] AXS.append(FIG.add_subplot(1, 2, 1)) AXS.append(FIG.add_subplot(1, 2, 2, projection='3d')) AXS[1].view_init(elev=90, azim=90) def update(iframe): iframe = int(iframe) mpl_pp.figure(FIGNUM) video.set(cv2.CAP_PROP_POS_FRAMES, iframe) # Set the frame to get fe, frame = video.read() # Read the frame if fe: frame_rgb = frame[..., ::-1].copy() AXS[0].cla() AXS[0].imshow(frame_rgb) AXS[1].cla() AXS[1].set_xlim(x_range) AXS[1].set_ylim(y_range) AXS[1].set_zlim(z_range) # Underlying skeleton if skeleton: for bpc in bp_connections: ibp1 = bp_list.index(bpc[0]) ibp2 = bp_list.index(bpc[1]) t_point1 = triangulated_points[iframe, :, ibp1] t_point2 = triangulated_points[iframe, :, ibp2] if any(np.isnan(t_point1)) or any(np.isnan(t_point1)): continue AXS[1].plot([t_point1[0], t_point2[0]], [t_point1[1], t_point2[1]], [t_point1[2], t_point2[2]], color='k', linewidth=skeleton_thickness) # Bodypart markers for ibp in range(np.size(triangulated_points, 2)): # Markers AXS[1].scatter(triangulated_points[iframe, 0, ibp], triangulated_points[iframe, 1, ibp], triangulated_points[iframe, 2, ibp], color=bp_cmap[ibp, :], s=marker_size) def arrow_key_image_control(event): if event.key == 'left' and SLIDER.val > 0: SLIDER.set_val(SLIDER.val - 1) elif event.key == 'right' and SLIDER.val < num_frames - 1: SLIDER.set_val(SLIDER.val + 1) else: pass update(0) axcolor = 'lightgoldenrodyellow' ax_ind = mpl_pp.axes([0.15, 0.1, 0.65, 0.03], facecolor=axcolor) SLIDER = mpl_pp.Slider(ax_ind, 'Frame', 0, num_frames - 1, valinit=0, valstep=1, valfmt='%u') SLIDER.on_changed(update) cid = FIG.canvas.mpl_connect('key_press_event', arrow_key_image_control) mpl_pp.show()