def define(self): self.con = ConnectionPatch(lw=1.5, color=(.25, .25, 1), picker=10, xyA=(self.x0, self.y0), coordsA='data', axesA=self.ax0, xyB=(self.xx, self.yy), coordsB='data', axesB=self.axx) self.con.parent = self super(BlitFigure, self.master).add_artist(self.con) self.master.add_artist(self.con) self.scat += [ self.axx.scatter(self.xx, self.yy, c=[], s=200, linewidth=1.5, edgecolors=(.25, .25, 1)) ] self.master.add_artist(self.scat[-1]) self.master.del_artist(self.line) del self.line
def __init__(self, outputPlot): self.decayValue = 0 self.outputPlot = outputPlot self.measurementPatch = Rectangle((0, 0), 1, 1, linewidth=1, color='gray', facecolor='none') self.statePatch = Circle((0, 0), 1, facecolor='blue') self.speedPatch = Arrow(0, 0, 3, 3) self.circlePatch = Circle((0, 0), 1, linewidth=1, color='red', facecolor='None') self.linePatch = ConnectionPatch((0, 0), (1, 1), 'data') self.model = 0 self.startLine = (0, 0) self.needToResetStartLine = True self.outputPlot.add_patch(self.measurementPatch) self.outputPlot.add_patch(self.statePatch) self.outputPlot.add_patch(self.speedPatch) self.outputPlot.add_patch(self.circlePatch) self.outputPlot.add_patch(self.linePatch) self.circlePatch.set_visible(False) self.linePatch.set_visible(False)
def connect_plots(ax0, ax1, x, y, delta): xy0 = (x + delta, y + delta) xy1 = (x - delta, y + delta) xy2 = (x + delta, y - delta) xy3 = (x - delta, y - delta) con0 = ConnectionPatch(xyA=xy0, xyB=xy1, coordsA="data", coordsB="data", axesA=ax0, axesB=ax1, color="m") ax0.add_artist(con0) con1 = ConnectionPatch(xyA=xy2, xyB=xy3, coordsA="data", coordsB="data", axesA=ax0, axesB=ax1, color="m") ax0.add_artist(con1) return con0, con1
def step_4(t,resonance,FID,fig,ax_one,ax_FID,ax_mult,ax_FT,freqs,nb_freq,trial,mult,integ,posinteg,neginteg,n): con_3 = ConnectionPatch(xyB=(1.2,0.5), xyA=(-0.2,0.5), coordsA="axes fraction", coordsB="axes fraction",axesA=ax_mult, axesB=ax_FT,color="red") con_3.set_arrowstyle("simple",head_length=0.5, head_width=1, tail_width=0.3) ax_mult.add_patch(con_3) ax_mult.fill_between(t,mult[n],where=mult[n]>0,interpolate=True,color="blue",label="Positive Areas") ax_mult.fill_between(t,mult[n],where=mult[n]<0,interpolate=True,color="red",label="Negative Areas") if ax_mult.get_legend() is None: ax_mult.legend(loc=1) ax_FT.plot(freqs[:n+1],integ[:n+1],linewidth=1,color="blue") ax_FT.plot([freqs[n]],[integ[n]],"ro") ann=ax_FT.annotate("Trial frequency {} Hz\nTotal area {}".format(round(freqs[n],1),round(round(posinteg[n],3)+round(neginteg[n],3),3)), xy=(freqs[n],integ[n]), xycoords='data', xytext=(-25, 10), textcoords='offset points', arrowprops=dict(facecolor='black',shrink=0.1,width=2,headwidth=10), horizontalalignment='right', verticalalignment='bottom') session["message"]="""The area under the multiplication curve (over the acquisition time) for a given trial frequency represents the relative intensity of the signal at this frequency.<br><br> For instance, the calculation for the trial frequency {} Hz from your FID gives (see graph 3):<br><br> <div style="background-color:white;font-weight:bold">Total area ( = Relative intensity) = <br><span style="color:blue">Positive areas</span> + <span style="color:red">Negative areas </span>= <span style="color:blue">({})</span> + <span style="color:red">({})</span> = {} area units</div><br> This point is reported on the final spectrum presented in graph 4.<br><br> The computer will repeat this operation with trial frequencies from {} to {} Hz in order to cover all our range of frequencies.<br><br> Press OK to access the spectrum generation (loading of the animation can take up to 1 min).<br><input type=submit name="msgOK" value="OK" class="control">""".format(round(freqs[n],1),round(posinteg[n],3),round(neginteg[n],3),round(round(posinteg[n],3)+round(neginteg[n],3),3),session["freq_min"]-1,session["freq_max"]+1) session["FT_step"]=4 return t,resonance,FID,fig,ax_one,ax_FID,ax_mult,ax_FT,freqs,nb_freq,trial,mult,integ,posinteg,neginteg,n,ann
def plot_warp(from_s, to_s, new_s, path, filename=None, fig=None, axs=None): """Plot the warped sequence and its relation to the original sequence and the target sequence. :param from_s: From sequence. :param to_s: To sequence. :param new_s: Warped version of from sequence. :param path: Optimal warping path. :param filename: Filename path (optional). :param fig: Matplotlib Figure object :param axs: Array of Matplotlib axes.Axes objects (length == 3) :return: Figure, list[Axes] """ try: import matplotlib.pyplot as plt import matplotlib as mpl from matplotlib.patches import ConnectionPatch except ImportError: logger.error( "The plot_warp function requires the matplotlib package to be installed." ) return if fig is None and axs is None: fig, axs = plt.subplots(nrows=3, ncols=1, sharex='all', sharey='all') elif fig is None or axs is None: raise TypeError( f'The fig and axs arguments need to be both None or both instantiated.' ) axs[0].plot(from_s, label="From") axs[0].legend() axs[1].plot(to_s, label="To") axs[1].legend() lines = [] line_options = {'linewidth': 0.5, 'color': 'orange', 'alpha': 0.8} for r_c, c_c in path: if r_c < 0 or c_c < 0: continue con = ConnectionPatch(xyA=[r_c, from_s[r_c]], coordsA=axs[0].transData, xyB=[c_c, to_s[c_c]], coordsB=axs[1].transData, **line_options) lines.append(con) axs[2].plot(new_s, label="From-warped") axs[2].legend() for i in range(len(to_s)): con = ConnectionPatch(xyA=[i, to_s[i]], coordsA=axs[1].transData, xyB=[i, new_s[i]], coordsB=axs[2].transData, **line_options) lines.append(con) for line in lines: fig.add_artist(line) if filename: plt.savefig(filename) plt.close() fig, axs = None, None return fig, axs
def _connect_axes(self, ax1, ax2): """Draws an arrow from ax1 to ax2. """ axis_center = self.get_cell_center() con = ConnectionPatch(xyA=axis_center, xyB=axis_center, coordsA="data", coordsB="data", axesA=ax1, axesB=ax2, color="red", mutation_scale=40, arrowstyle="->", shrinkB=5, shrinkA=5) ax1.add_artist(con) con = ConnectionPatch(xyA=axis_center, xyB=axis_center, coordsA="data", coordsB="data", axesA=ax2, axesB=ax1, color="red", mutation_scale=40, arrowstyle="<-", shrinkB=5, shrinkA=5) ax2.add_artist(con) ax1.plot(*axis_center, 'ro', markersize=10) ax2.plot(*axis_center, 'ro', markersize=10)
def plot_image_matching(x1, y1, x2, y2, bx1, by1, bx2, by2, img1, img2): f = plt.figure(figsize=(30, 30)) ax1 = f.add_subplot(121) ax2 = f.add_subplot(122) ax1.imshow(img1) ax1.axis('off') ax2.imshow(img2) ax2.axis('off') ax1.plot(x1, y1, 'ro', markersize=3) ax2.plot(x2, y2, 'ro', markersize=3) ax1.plot(bx1, by1, 'bo', markersize=3) ax2.plot(bx2, by2, 'bo', markersize=3) for i in range(len(x1)): con = ConnectionPatch(xyA=(x2[i], y2[i]), xyB=(x1[i], y1[i]), coordsA="data", coordsB="data", axesA=ax2, axesB=ax1, color="red") ax2.add_artist(con) for i in range(len(bx1)): con = ConnectionPatch(xyA=(bx2[i], by2[i]), xyB=(bx1[i], by1[i]), coordsA="data", coordsB="data", axesA=ax2, axesB=ax1, color="blue") ax2.add_artist(con)
def plot_synth_data_with_gates(models, concatenated_data, hparams, plot_config={}): plt.rcParams.update({'font.size': 20, 'font.family': 'serif'}) DEFAULT_PLOT_CONFIG.update(plot_config) plot_config = DEFAULT_PLOT_CONFIG features = ['M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'M8'] if plot_config['ncols'] < 7: raise ValueError('Need at least seven columns to display tree') input = SynthInput(hparams) fig = plt.figure(figsize=plot_config['figsize']) plt.tight_layout() grid = gridspec.GridSpec(nrows=3, ncols=plot_config['ncols'], figure=fig) grid.update(hspace=plot_config['hspace'], wspace=plot_config['wspace']) axes = [] axes.append(fig.add_subplot(grid[0,plot_config['ncols']//2])) axes.append(fig.add_subplot(grid[1,plot_config['ncols']//2 - 1])) axes.append(fig.add_subplot(grid[1,plot_config['ncols']//2 + 1])) axes.append(fig.add_subplot(grid[2,plot_config['ncols']//2 + 2])) fig.suptitle(plot_config['title'] ,x=.53, y=0, fontsize=25) for i in range(len(axes)): axes[i].set_xlim(right=plot_config['right']) axes[i].set_ylim(top=plot_config['top']) axes[i].set_xticks([], []) axes[i].set_yticks([], []) axes[0].set_ylabel('M2') axes[0].set_xlabel('M1') con = ConnectionPatch(xyA=(0., 0.), xyB=(.5, 1.), coordsA="axes fraction", \ coordsB="axes fraction", axesA=axes[0], axesB=axes[1], color='k', arrowstyle='-|>') axes[0].add_artist(con) axes[1].set_ylabel('M4') axes[1].set_xlabel('M3') con = ConnectionPatch(xyA=(1., 0.), xyB=(.5, 1.), coordsA="axes fraction", \ coordsB="axes fraction", axesA=axes[0], axesB=axes[2], color='k', arrowstyle='-|>') axes[0].add_artist(con) axes[2].set_ylabel('M6') axes[2].set_xlabel('M5') con = ConnectionPatch(xyA=(1., 0.), xyB=(.5, 1.), coordsA="axes fraction", \ coordsB="axes fraction", axesA=axes[2], axesB=axes[3], color='k', arrowstyle='-|>') axes[2].add_artist(con) axes[3].set_ylabel('M8') axes[3].set_xlabel('M7') flat_axes = np.array([axes[0], axes[2], axes[3], axes[1]]) for axis in flat_axes: axis.set_ylim(0, 1) axis.set_xlim(0, 1) init_gate_plotter = DataAndGatesPlotter(models['init'], concatenated_data) init_gate_plotter.plot_on_axes(flat_axes, hparams) final_gates_and_data_plotter = DataAndGatesPlotter(models['final'], concatenated_data, color='r') final_gates_and_data_plotter.plot_on_axes(flat_axes, hparams)
def plot_2dmap(self, data=None): """ Plots the distribution of the map in two dimensions, including the connections for neighbouring neurons. Only available if the dimensionality of the map is 2. Args: - data: (optional) an m by N array. If included, the map is plotted together with the provided data. """ if self.m != 2: raise ValueError("SOM dimensionality is not two") # Plot points first plt.figure() if data is not None: plt.scatter(data[0, :], data[1, :], alpha=0.5, edgecolors="none") plt.scatter(self.neurons[0, :], self.neurons[1, :], s=10, c="k") # Add the lines axis = plt.gca() i = 0 j = 0 for i in range(self.h - 1): for j in range(self.w - 1): # Connect to neurons in front of and below the neuron neuron_idx = self.neurons[:, np.ravel_multi_index( (i, j), (self.h, self.w))] neuron_front = self.neurons[:, np.ravel_multi_index( (i, j + 1), (self.h, self.w))] neuron_below = self.neurons[:, np.ravel_multi_index( (i + 1, j), (self.h, self.w))] axis.add_patch( ConnectionPatch(neuron_idx, neuron_front, "data")) axis.add_patch( ConnectionPatch(neuron_idx, neuron_below, "data")) # For the last column, connect to neuron below neuron_idx = self.neurons[:, np.ravel_multi_index((i, j + 1), (self.h, self.w))] neuron_below = self.neurons[:, np.ravel_multi_index((i + 1, j + 1), (self.h, self.w))] axis.add_patch(ConnectionPatch(neuron_idx, neuron_below, "data")) for j in range(self.w - 1): # For the last row, connect to neurons in front of the neuron neuron_idx = self.neurons[:, np.ravel_multi_index((self.h - 1, j), (self.h, self.w))] neuron_front = self.neurons[:, np.ravel_multi_index( (self.h - 1, j + 1), (self.h, self.w))] axis.add_patch(ConnectionPatch(neuron_idx, neuron_front, "data")) plt.show(block=False)
def add_connection(source_ax, source_data_coord, target_ax, target_data_coord): con = ConnectionPatch(xyA=source_data_coord, xyB=target_data_coord, coordsA='data', coordsB='data', axesA=source_ax, axesB=target_ax, arrowstyle='->', clip_on=False, linewidth=3) con.set_zorder(10) source_ax.add_artist(con)
def __init__(self, px_i, px_f, width): self.px_i = px_i self.px_f = px_f self.px_width = width # Find distance in pixels of line profile self.px_dist = int( np.round( np.hypot(self.px_f[0] - self.px_i[0], self.px_f[1] - self.px_i[1]))) self.s_dist = None # Calculate the angle the line makes with the x-axis self.line_vec = np.array( [self.px_f[0] - self.px_i[0], self.px_f[1] - self.px_i[1]]) self.angle = np.angle(self.line_vec[0] + self.line_vec[1] * 1j, deg=False) # Calculate the offset in X and Y for the linewidth start # and end points at the start point for the line profile self.xyA_i = ( (self.px_i[0] - width / 2 * np.sin(self.angle)), (self.px_i[1] + width / 2 * np.cos(self.angle)), ) self.xyB_i = ( (self.px_i[0] + width / 2 * np.sin(self.angle)), (self.px_i[1] - width / 2 * np.cos(self.angle)), ) self.cpatch_i = ConnectionPatch( xyA=self.xyA_i, xyB=self.xyB_i, coordsA="data", coordsB="data", ) self.cpatch_line = ConnectionPatch( xyA=self.px_i, xyB=self.px_f, coordsA="data", coordsB="data", ) self.xyA_f = ( (self.px_f[0] - width / 2 * np.sin(self.angle)), (self.px_f[1] + width / 2 * np.cos(self.angle)), ) self.xyB_f = ( (self.px_f[0] + width / 2 * np.sin(self.angle)), (self.px_f[1] - width / 2 * np.cos(self.angle)), ) self.cpatch_f = ConnectionPatch( xyA=self.xyA_f, xyB=self.xyB_f, coordsA="data", coordsB="data", )
def _plot_feature_to_kernel_lines(kernel_matrix_2d, feature_matrix_2d, feature_row_at_center, feature_column_at_center, kernel_axes_object, feature_axes_object): """Plots lines between feature map and kernel. :param kernel_matrix_2d: See doc for `_plot_kernel`. :param feature_matrix_2d: Same. :param feature_row_at_center: Same. :param feature_column_at_center: Same. :param kernel_axes_object: Axes on which kernel is plotted (instance of `matplotlib.axes._subplots.AxesSubplot`). :param feature_axes_object: Axes on which feature map is plotted (instance of `matplotlib.axes._subplots.AxesSubplot`). """ num_feature_rows = feature_matrix_2d.shape[0] num_feature_columns = feature_matrix_2d.shape[1] num_kernel_rows = kernel_matrix_2d.shape[0] first_feature_row = max([feature_row_at_center - 1.5, -0.5]) last_feature_row = min( [feature_row_at_center + 1.5, num_feature_rows - 0.5]) last_feature_column = min( [feature_column_at_center + 1.5, num_feature_columns - 0.5]) center_row_from_bottom = num_feature_rows - feature_row_at_center - 1 first_kernel_row = -0.5 + max([1 - feature_row_at_center, 0]) last_kernel_row = 0.5 + min( [1 + center_row_from_bottom, num_kernel_rows - 1]) first_kernel_column = -0.5 + max([1 - feature_column_at_center, 0]) this_connection_object = ConnectionPatch( xyA=(first_kernel_column, first_kernel_row), xyB=(last_feature_column, first_feature_row), coordsA='data', coordsB='data', axesA=kernel_axes_object, axesB=feature_axes_object, color=FEATURE_TO_KERNEL_LINE_COLOUR, linewidth=FEATURE_TO_KERNEL_LINE_WIDTH, linestyle='dashed') kernel_axes_object.add_artist(this_connection_object) this_connection_object = ConnectionPatch( xyA=(first_kernel_column, last_kernel_row), xyB=(last_feature_column, last_feature_row), coordsA='data', coordsB='data', axesA=kernel_axes_object, axesB=feature_axes_object, color=FEATURE_TO_KERNEL_LINE_COLOUR, linewidth=FEATURE_TO_KERNEL_LINE_WIDTH, linestyle='dashed') kernel_axes_object.add_artist(this_connection_object)
def step_1(): t,resonance,FID,fig,ax_one,ax_FID,ax_mult,ax_FT=draw_freq() con_2 = ConnectionPatch(xyA=(0.5,-0.2), xyB=(0.5,1.15), coordsA="axes fraction", coordsB="axes fraction",axesA=ax_FID, axesB=ax_mult,color="red") con_2.set_arrowstyle("simple",head_length=0.5, head_width=1, tail_width=0.3) ax_FID.add_patch(con_2) freqs=np.arange(session["freq_min"]-1,session["freq_max"]+1,session["freq_res"]) freqs=np.append(freqs,session["freq_max"]+1) nb_freq=freqs.size trial=np.zeros((nb_freq,session["nb_points"])) mult=np.zeros((nb_freq,session["nb_points"])) integ=np.zeros(nb_freq) posinteg=np.zeros(nb_freq) neginteg=np.zeros(nb_freq) for i,freq in enumerate(freqs): trial[i]=np.cos(2*np.pi*freq*t) mult[i]=trial[i]*FID posmult=np.zeros(session["nb_points"]) negmult=np.zeros(session["nb_points"]) for nn,ii in enumerate(mult[i]): if ii >0: posmult[nn]=ii if ii <0: negmult[nn]=ii posinteg[i]=np.trapz(posmult,t) neginteg[i]=np.trapz(negmult,t) integ[i]=np.trapz(mult[i],t) if freq<=session["freq_min"]: n=i ax_FT.set_ylim(integ.min()-(integ.max()-integ.min())*0.05,integ.max()+(integ.max()-integ.min())*0.4) ax_FID.plot(t,trial[n],linewidth=1,color="magenta",alpha=0.5) ax_mult.plot(t,mult[n],linewidth=1,color="black",alpha=0.5) ax_FID.legend(("FID","Trial Frequency {} Hz".format(round(freqs[n],1))),loc=1) session["message"]="""The acquired signal will be processed and the computer will try to find all the frequencies from which your FID is composed.<br><br> To do this, it will multiply your FID by cosine functions with increasing frequencies, covering all our frequencies range from {} to {} Hz.<br> We will call these cosine functions "Trial Frequencies".<br><br> The multiplication is done "point by point", as shown in the example below: <br><br> <img src="/static/img1.png" style="width:95%"/><br><br> The result of the multiplication of your FID by the trial frequency {} Hz is shown in graph 3.<br> <input type=submit name="msgOK" value="Next" class="control">""".format(session["freq_min"],session["freq_max"],round(freqs[n],1)) session["FT_step"]=1 return t,resonance,FID,fig,ax_one,ax_FID,ax_mult,ax_FT,freqs,nb_freq,trial,mult,integ,posinteg,neginteg,n
def add_connection(source_ax, source_data_coord, target_ax, target_data_coord): con = ConnectionPatch(xyA=source_data_coord, xyB=target_data_coord, coordsA='data', coordsB='data', axesA=source_ax, axesB=target_ax, arrowstyle='->', clip_on=False, linewidth=3) con.set_zorder(10) source_ax.add_artist(con)
def linking_lines( fig_: Figure, axes_A: Axes, axes_B: Axes, axes_C: Axes, axes_D: Axes, color_: str = brown_, ) -> None: r""" Draw lines linking features in the main plot to zoom insets. Args: fig_: Figure to act on axes_A: Axes of zoom box A axes_B: Axes of zoom box B axes_C: Axes of zoom box C axes_D: Axes of zoom box D """ joins: List[ConnectionPatch] = [None] * 3 kwargs = dict(color=color_, linestyle=":") joins[0] = ConnectionPatch( xyA=(0.2, 0), coordsA=axes_D.transData, xyB=(0.4, 1), coordsB=axes_A.transData, **kwargs, ) joins[1] = ConnectionPatch( xyA=(1, 0.00), coordsA=axes_D.transData, xyB=(0, 0.9), coordsB=axes_B.transData, **kwargs, ) joins[2] = ConnectionPatch( xyA=(1, 0.60), coordsA=axes_D.transData, xyB=(0, 0.8), coordsB=axes_C.transData, **kwargs, ) for join_ in joins: fig_.add_artist(join_)
def plotting_pairs(self, BLPoints, FUPoints): ''' Plotting the point pairs next to each other in one plot. :param BLPoints: Baseline points -- shape (N,2) :param FUPoints: Follow-up points -- shape (N,2) Function for plotting pairs of points in two transformed images. ''' fig = plt.figure(1) a1 = fig.add_subplot(1, 2, 1) self.plotting_points(self.bl, BLPoints, number=True) a2 = fig.add_subplot(1, 2, 2) self.plotting_points(self.fu, FUPoints, number=True) for idx in range(BLPoints.shape[0]): xbl = BLPoints[idx][0] ybl = BLPoints[idx][1] xfu = FUPoints[idx][0] yfu = FUPoints[idx][1] con = ConnectionPatch(xyA=(xfu, yfu), xyB=(xbl, ybl), coordsA="data", coordsB="data", axesA=a2, axesB=a1, color="red") a2.add_artist(con)
def vmarker(x0, x1, ax0, ax1, **kwargs): xy0 = (x0, ax0.get_ylim()[0]) xy1 = (x1, ax1.get_ylim()[1]) ax0.axvline(x0, **kwargs) ax1.axvline(x1, **kwargs) con = ConnectionPatch(xy0, xy1, 'data', 'data', ax0, ax1, **kwargs) ax0.add_artist(con)
def visualize_pair(self, image1, image2): img1 = mpimg.imread(image1) img2 = mpimg.imread(image2) x1 = self.point1.x y1 = self.point1.y x2 = self.point2.x y2 = self.point2.y fig = plt.figure() ax1 = fig.add_subplot(1, 2, 1) ax1.imshow(img1) ax1.plot(x1, y1, 'r*') ax2 = fig.add_subplot(1, 2, 2) ax2.imshow(img2) ax2.plot(x2, y2, 'r*') con = ConnectionPatch(xyA=(x2, y2), xyB=(x1, y1), coordsA="data", coordsB="data", axesA=ax2, axesB=ax1, color="red") ax2.add_artist(con) fig.savefig('result.png')
def show(self, filename=None, **kwargs): tsx, tsy = kwargs.get('tsx', 0), kwargs.get('tsy', 0) fig, ax = plt.subplots(figsize=self.figsize) ax.axis('equal') ax.set_xticks([]), ax.set_yticks([]) sns.despine(left=True, bottom=True, right=True, top=True) ax.set_xlim((min(self.ymin, self.xmin), max(self.ymax, self.xmax))) ax.set_ylim((min(self.ymin, self.xmin), max(self.ymax, self.xmax))) for name, v in self._vertices.items(): vx, vy = v.position c = Circle((vx, vy), v.radius, zorder=20) c.set_edgecolor(v.rcolor) c.set_facecolor(v.color) ax.annotate(name, xy=(vx, vy), fontsize=v.tsize, ha='center', xytext=(vx + tsx, vy + tsy), color=v.tcolor, zorder=21) ax.add_artist(c) for e in self._alist[name]: l = ConnectionPatch(e.a.position, e.b.position, 'data') ax.add_artist(l) plt.close() return fig
def animate(frame): ax.patches = [] c_B = cum_orbits[0, int(frame)] for j, i in enumerate(draw_idx): c_A, c_B = cum_orbits[i, int(frame)], cum_orbits[i + 1, int(frame)] r = radius[i] ax.add_patch( plt.Circle((c_A.real, c_A.imag), r, fill=False, linestyle="dotted", linewidth=args.circle_width, color=args.circle_color)) ax.add_patch( ConnectionPatch((c_A.real, c_A.imag), (c_B.real, c_B.imag), ax.transData, arrowstyle="-", linewidth=args.vector_width, color=args.vector_color)) x, y = cum_orbits[-1, :int(frame) + 1].real, cum_orbits[-1, :int(frame) + 1].imag pl.set_data(x, y) return ax.patches + [ pl, ]
def example(): from matplotlib import pyplot as plt import numpy as np # todo: read the example image from the papers source directory image1 = imread(wrapper.source_directory + '/adam1.png') image2 = imread(wrapper.source_directory + '/adam2.png') # todo: call the wrapped function(s) with a valid set of arguments matches, keys1, keys2 = wrapper.asift(image1, image2) # todo: display the results fig = plt.figure(figsize=(10, 5)) ax1 = fig.add_subplot(121) plt.imshow(image1, cmap='Greys_r') ax2 = fig.add_subplot(122) plt.imshow(image2, cmap='Greys_r') for x1, y1, x2, y2 in matches[::1, :]: con = ConnectionPatch(xyA=(x2, y2), xyB=(x1, y1), coordsA="data", coordsB="data", axesA=ax2, axesB=ax1, shrinkB=5, color='r') ax2.add_artist(con) plt.draw() plt.show() print('done')
def draw_pitch(ax): # focus on only half of the pitch #Pitch Outline & Centre Line Pitch = Rectangle([0,0], width = 120, height = 80, fill = False) #Left, Right Penalty Area and midline LeftPenalty = Rectangle([0,22.3], width = 14.6, height = 35.3, fill = False) RightPenalty = Rectangle([105.4,22.3], width = 14.6, height = 35.3, fill = False) midline = ConnectionPatch([60,0], [60,80], "data", "data") #Left, Right 6-yard Box LeftSixYard = Rectangle([0,32], width = 4.9, height = 16, fill = False) RightSixYard = Rectangle([115.1,32], width = 4.9, height = 16, fill = False) #Prepare Circles centreCircle = plt.Circle((60,40),8.1,color="black", fill = False) centreSpot = plt.Circle((60,40),0.71,color="black") #Penalty spots and Arcs around penalty boxes leftPenSpot = plt.Circle((9.7,40),0.71,color="black") rightPenSpot = plt.Circle((110.3,40),0.71,color="black") leftArc = Arc((9.7,40),height=16.2,width=16.2,angle=0,theta1=310,theta2=50,color="black") rightArc = Arc((110.3,40),height=16.2,width=16.2,angle=0,theta1=130,theta2=230,color="black") element = [Pitch, LeftPenalty, RightPenalty, midline, LeftSixYard, RightSixYard, centreCircle, centreSpot, rightPenSpot, leftPenSpot, leftArc, rightArc] for i in element: ax.add_patch(i)
def draw(self, img_q, img_t, pt_qt): import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt from matplotlib.patches import ConnectionPatch fig, (ax_q, ax_t) = plt.subplots(1, 2, figsize=(8, 4)) for pt_q, pt_t in pt_qt: con = ConnectionPatch(pt_t, pt_q, coordsA='data', coordsB='data', axesA=ax_t, axesB=ax_q, color='g', linewidth=0.5) ax_t.add_artist(con) ax_q.plot(pt_q[0], pt_q[1], 'rx') ax_t.plot(pt_t[0], pt_t[1], 'rx') ax_q.imshow(img_q) ax_t.imshow(img_t) ax_q.axis('off') ax_t.axis('off') plt.subplots_adjust(wspace=0, hspace=0) plt.show()
def drawSPC(self, currentClass, fig, ogX, ogY): # Draws the CPC by resizing the figure and creating the graph for currentIndex in range(len(ogX)): n = len(fig.axes) for b in range(n): fig.axes[b].change_geometry(currentClass, len(ogX), b + 1) # Resizing (row, column, position) ax = fig.add_subplot(currentClass, len(ogX), n + 1) ax.set_xlabel("X " + str(currentIndex * 2 + 1)) # Styling the graph ax.set_ylabel("X " + str(currentIndex * 2 + 2)) if (currentIndex == 0): ax.set_title("SPC for Class: " + str(currentClass)) xMin = min(ogX) - 1 xMax = max(ogX) + 1 yMin = min(ogY) - 1 yMax = max(ogY) + 1 plt.xlim(float(xMin), float(xMax)) plt.ylim(float(yMin), float(yMax)) ax.plot(ogX[currentIndex], ogY[currentIndex], 'r') # Plotting the graph pax = fig.axes[n] if (currentIndex > 0): xy = ( ogX[currentIndex - 1], ogY[currentIndex - 1]) # These are for original values to be graphed in SPC ab = (ogX[currentIndex], ogY[currentIndex]) con = ConnectionPatch(xyA=ab, xyB=xy, coordsA="data", coordsB="data", axesA=fig.axes[n], axesB=fig.axes[n - 1], color="purple") pax.add_artist(con) pax.plot(ogX[currentIndex], ogY[currentIndex], 'ro', markersize=10) # Plot the SPC points on each graph else: pax.plot(ogX[currentIndex], ogY[currentIndex], 'ro', markersize=10) # Plot the SPC points on each graph
def plot_corr(img1, img2, img1_pts, img2_pts, vsplit=False, figsize=(20, 15)): plot1 = 211 plot2 = 212 if vsplit: plot1 = 121 plot2 = 122 fig = plt.figure(figsize=figsize) ax1 = plt.subplot(plot1) ax1.imshow(img1, cmap='gray', aspect = "auto") ax1.scatter(img1_pts[:, 0], img1_pts[:, 1], marker='+') ax1.set_xticklabels([]) ax1.set_yticklabels([]) ax2 = plt.subplot(plot2) ax2.imshow(img2, cmap='gray', aspect = "auto") ax2.scatter(img2_pts[:, 0], img2_pts[:, 1], marker='+') ax2.set_xticklabels([]) ax2.set_yticklabels([]) for i in range(len(img1_pts)): xy1 = (img1_pts[i,0],img1_pts[i,1]) xy2 = (img2_pts[i,0],img2_pts[i,1]) con = ConnectionPatch(xyA=xy2, xyB=xy1, coordsA="data", coordsB="data", axesA=ax2, axesB=ax1, color='#53F242') ax2.add_artist(con) plt.subplots_adjust(wspace=0, hspace=0) # plt.tight_layout() plt.show()
def addArrow(ax, cx, xdiff, cy, ydiff, text, color="k", ha="left", va="center", arrowstyle="-|>", shrinkA=2, shrinkB=4, xlog=False, ylog=True): x = cx * xdiff if xlog else cx + xdiff y = cy * ydiff if ylog else cy + ydiff con = ConnectionPatch(xyA=(x, y), xyB=(cx, cy), coordsA="data", coordsB="data", arrowstyle=arrowstyle, shrinkA=shrinkA, shrinkB=shrinkB, mutation_scale=20, fc="w", color=color) # connectionstyle="arc3,rad=0.3" ax.add_artist(con) ax.annotate(text, xy=(x, y), ha=ha, va=va, color=color) #,box=dict(boxstyle="round", fc="w")
def plot_expected_lengths(lengths, batch_sizes, choose_length, markers=[], n_batches=10000): fig, axarr = plt.subplots(len(batch_sizes), 1, figsize=(14, 20), sharex=True) expected_lengths = {} for i, batch_size in enumerate(batch_sizes): maxs = [] for _ in tqdm(range(n_batches), disable=False): val = choose_length(np.random.choice(lengths, batch_size)) maxs.append(math.ceil(val)) pd.Series(maxs).plot.hist(bins=50, ax=axarr[i], density=True, color='black', edgecolor='white', alpha=0.1) expected = np.mean(maxs) expected_lengths[batch_size] = expected max_y = axarr[i].get_ylim()[1] axarr[i].vlines([expected], 0, 1e3, 'limegreen', lw=4) axarr[i].set_ylim([0, max_y]) axarr[i].set_xlim([0, max(lengths)]) axarr[i].set_ylabel(f'batch_size={batch_size}', rotation=0) axarr[i].yaxis.set_label_coords(-0.1, 0.45) axarr[i].set_yticks([]) for marker in markers: con = ConnectionPatch(xyA=(marker, axarr[0].get_ylim()[1]), xyB=(marker, 0), coordsA='data', coordsB='data', axesA=axarr[0], axesB=axarr[-1], color='red', lw=4) axarr[0].add_artist(con) axarr[0].set_zorder(1) axarr[0].set_title(f'Expected sequence lengths with various batch sizes (n per batch = {n_batches})') plt.subplots_adjust(hspace=0) return expected_lengths
def plot_graph(graph, ax, n, weighted, shrinkA, shrinkB, layout, polygon_radius, attr, arrowstyle, weight_color, arrow_color): """ creates a plot of nodes and edges connected by a ConnectionPatch object. """ for node in plot_graph.nodes: x_i, y_i = plot_graph.points[node] for adj_node in node.adjacent_nodes: _from = graph.get_node_id(node) _to = graph.get_node_id(adj_node) edge = graph.connections[_from][_to] A_color = "k" if not arrow_color else edge.color A_width = edge.linewidth if not edge.linewidth else edge.linewidth * 4 x_prime, y_prime = plot_graph.points[adj_node] con = ConnectionPatch((x_i, y_i), (x_prime, y_prime), COORDSA, COORDSB, arrowstyle=arrowstyle, shrinkA=shrinkA, shrinkB=shrinkB, mutation_scale=plot_graph.scale, fc=A_color, linewidth=A_width, edgecolor=A_color) if weighted: T_color = "k" if not weight_color else A_color x_mid, y_mid = (x_prime + x_i) * 0.5, (y_prime + y_i) * 0.5 weight = edge.weight fontsize = 12 / n + 12 ax.text(x_mid, y_mid, str(weight), fontsize=edge.fontsize * fontsize + fontsize, color=T_color) ax.add_artist(con)
def draw_matches(img1, keypoints1, img2, keypoints2, plot_title=""): """ Draws matches of keypoints between img1 and img2. :param img1: the first image :param keypoints1: the first image's keypoints :param img2: the second image :param keypoints2: the second image's keypoints :param plot_title: the title of the plot """ figure = plt.figure(figsize=(10, 5)) ax1 = plt.subplot(1, 2, 1) ax2 = plt.subplot(1, 2, 2) img1 = cv2.drawKeypoints(img1, keypoints1, None) img2 = cv2.drawKeypoints(img2, keypoints2, None) ax1.imshow(img1) ax2.imshow(img2) for kp1, kp2 in zip(keypoints1, keypoints2): con = ConnectionPatch(xyA=kp2.pt, xyB=kp1.pt, coordsA="data", coordsB="data", axesA=ax2, axesB=ax1, color=np.random.rand(3, )) ax2.add_patch(con) plt.title(plot_title) plt.show() figure.savefig("data/results/" + plot_title.replace(" ", "-").replace(".", "-") + '.png', dpi=100, bbox_inches='tight')
def example(): # todo: read the example image from the papers source directory image1=imread(wrapper.source_directory+'/examples/gobelet.png') image2=imread(wrapper.source_directory+'/examples/gobelet2.png') # todo: call the wrapped function(s) with a valid set of arguments #keys1=wrapper. keys1=wrapper.extract_surf(image1) keys2=wrapper.extract_surf(image2) matches=wrapper.match_surf(keys1,keys2) # todo: display the results fig = plt.figure(figsize=(10,5)) ax1 = fig.add_subplot(121) plt.imshow(image1) ax2 = fig.add_subplot(122) plt.imshow(image2) for x1,y1,x2,y2 in matches: con = ConnectionPatch(xyA=(x2, y2), xyB=(x1,y1), coordsA="data", coordsB="data" , axesA=ax2, axesB=ax1, shrinkB=5,color='r') ax2.add_artist(con) plt.draw() plt.show() print 'done'
def plot_transfer(self, transfer, source_plates, target_plates, axes=None): """Plot the plates and add and arrow for the transfer""" fig, axes, axes_dict = self.plot_plates(source_plates, target_plates, axes=axes) source_well = transfer.source_well source_plate = source_well.plate source_ax = axes_dict[source_plate.name] x, y = source_well.coordinates[::-1] source_coord = x, source_plate.num_rows - y + 1 target_well = transfer.destination_well target_plate = target_well.plate target_ax = axes_dict[target_plate.name] x, y = target_well.coordinates[::-1] target_coord = x, target_plate.num_rows - y + 1 target_ax.set_zorder(source_ax.get_zorder() - 1) arrow = ConnectionPatch( xyA=source_coord, xyB=target_coord, coordsA="data", coordsB="data", axesA=source_ax, axesB=target_ax, shrinkB=5.0, lw=2, facecolor='black', arrowstyle="wedge", zorder=1000) source_ax.add_artist(arrow) return fig, axes
ax2.set_title('Age of approvers') ax2.legend(('50-65', 'Over 65', '35-49', 'Under 35')) ax2.axis('off') ax2.set_xlim(- 2.5 * width, 2.5 * width) # use ConnectionPatch to draw lines between the two plots # get the wedge data theta1, theta2 = ax1.patches[0].theta1, ax1.patches[0].theta2 center, r = ax1.patches[0].center, ax1.patches[0].r bar_height = sum([item.get_height() for item in ax2.patches]) # draw top connecting line x = r * np.cos(np.pi / 180 * theta2) + center[0] y = np.sin(np.pi / 180 * theta2) + center[1] con = ConnectionPatch(xyA=(- width / 2, bar_height), xyB=(x, y), coordsA="data", coordsB="data", axesA=ax2, axesB=ax1) con.set_color([0, 0, 0]) con.set_linewidth(4) ax2.add_artist(con) # draw bottom connecting line x = r * np.cos(np.pi / 180 * theta1) + center[0] y = np.sin(np.pi / 180 * theta1) + center[1] con = ConnectionPatch(xyA=(- width / 2, 0), xyB=(x, y), coordsA="data", coordsB="data", axesA=ax2, axesB=ax1) con.set_color([0, 0, 0]) ax2.add_artist(con) con.set_linewidth(4) plt.show()