Exemple #1
0
    def write_body(self):
        try:
            from matplotlib.path import Path
        except ImportError:
            Path = None
            from matplotlib.patches import Circle, Polygon
        else:
            from matplotlib.patches import Circle, PathPatch

        indices = self.X[:, 2].argsort()
        for a in indices:
            xy = self.X[a, :2]
            if a < self.natoms:
                r = self.d[a] / 2
                if ((xy[1] + r > 0) and (xy[1] - r < self.h) and
                    (xy[0] + r > 0) and (xy[0] - r < self.w)):
                    circle = Circle(xy, r, facecolor=self.colors[a])
                    circle.draw(self.renderer)
            else:
                a -= self.natoms
                c = self.T[a]
                if c != -1:
                    hxy = self.D[c]
                    if Path is None:
                        line = Polygon((xy + hxy, xy - hxy))
                    else:
                        line = PathPatch(Path((xy + hxy, xy - hxy)))
                    line.draw(self.renderer)
Exemple #2
0
 def animate(currentNode = currentNode):
     while 1:
         newNode = q.get()
         if currentNode: currentNode.remove()
         circle = Circle(newNode,0.1)
         currentNode = ax.add_patch(circle)
         circle.set_fc('r')
         fig.canvas.draw()
Exemple #3
0
def circle(xy=None, x=None, y=None, **kwargs):
	if xy is None:
		if x is None or y is None:
			raise 'circle: need x and y'
		xy = array([x,y])
	c = Circle(xy=xy, **kwargs)
	a=gca()
	c.set_clip_box(a.bbox)
	a.add_artist(c)
	return c
Exemple #4
0
    def draw_vswr_circles(self, vswr_radii, labels=False):
        for r in vswr_radii:
            c = Circle((0, 0), r, ls='dashed', **self.patch_options_light)

            c.set_clip_path(self.smith_circle)
            c.set_clip_box(self.ax.bbox)
            self.ax.add_patch(c)

        if labels:
            for r in vswr_radii:
                if r > 0:
                    vswr = (1 + r)/(1 - r)
                    self.ax.text(0, r, '%.1f' % vswr, **self.label_options)
def make_animation_frames(name, semimajor, planet_radius, star_radius, star_color, orbital_period):
    #not affiliated with Animal Planet.

    center = np.array([0.5,0.5])
    angle = np.random.uniform(0, 2*np.pi)
    planet_center = center+semimajor*np.array([1,0])

    fig = Figure(figsize=(6,6))
    axis = fig.add_subplot(1, 1, 1)

    star = Circle(center, radius=star_radius, color=star_color)
    orbit = Circle(center, radius=semimajor, fill=False, linestyle='dashed', color='gray')
    planet = Circle(planet_center, radius=planet_radius, color='green')

    axis.add_patch(star)
    axis.add_patch(orbit)
    axis.add_patch(planet)
    axis.axis('off')

    filenames = []
    #set 50 days to be 5 seconds
    orbital_period = orbital_period/100.*5.
    #let's put the period in seconds
    fps = 100.
    print 'orbital period = ', orbital_period
    nframe = int(orbital_period*fps)


    #round off 
    orbital_period = nframe/fps
    omega = 2*np.pi/orbital_period
    angles = np.linspace(0, 2*np.pi, nframe)
    if not os.path.exists("frames"):
        os.makekdir("frames")
    if not os.path.exists("gifs"):
        os.makekdir("gifss")
    print angles
    print "nframe = ", nframe
    for i,theta in enumerate(angles):
        canvas = FigureCanvas(fig)
        planet.center = center+semimajor*np.array([np.cos(theta),np.sin(theta)])
        filename = ("frames/%.4d_"%i)+remove_space(name)+'.png'
        fig.savefig(filename)
        filenames.append(filename)

    #animate
    gifname = "gifs/%s.gif" % remove_space(name)
    frame_names = " ".join(filenames)
    cmd = "convert -delay 1 %s %s" % (frame_names, gifname)
    print cmd   
    os.system(cmd)
Exemple #6
0
 def add_breadcrumb(self):
     """ Adds a breadcrumb """
     c = Circle(self._loc, radius = 16.25)
     c.set_facecolor('0.65')  # grey
     c.set_edgecolor('black')
     c.set_zorder(zorders['breadcrumbs'])
     c.set_fill(True)
     self.view.add_artist(c)
     self.breadcrumbs.append(c)
     self.draw()
Exemple #7
0
def circle( xy, radius, color="lightsteelblue", facecolor="none", alpha=1, ax=None ):
    """ add a circle to ax= or current axes
    """
        # from .../pylab_examples/ellipse_demo.py
    e = Circle( xy=xy, radius=radius )
    if ax is None:
        ax = plt.gca()  # ax = subplot( 1,1,1 )
    ax.add_artist(e)
    e.set_clip_box(ax.bbox)
    e.set_edgecolor( color )
    e.set_facecolor( facecolor )  # "none" not None
    e.set_alpha( alpha )
Exemple #8
0
 def scatter_plot(self, equators=True, tagging=True, depth_cap=None):
     if depth_cap is None:
         depth_cap = self.height
     fig = plt.figure(figsize=(12, 10))
     ax = fig.add_subplot(111, projection="3d")
     plt.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
     xs = [self.nodes[self.root].coord.x]
     ys = [self.nodes[self.root].coord.y]
     zs = [self.nodes[self.root].coord.z]
     plot_color_board = ["blue", "red", "yellow", "green", "black"]
     font0 = FontProperties()
     font0.set_size(8)
     current_generation = deque([self.root])
     next_generation = True
     while next_generation:
         next_generation = deque()
         while current_generation:
             n = current_generation.popleft()
             if self.nodes[n].depth <= depth_cap:
                 xs.append(self.nodes[n].coord.x)
                 ys.append(self.nodes[n].coord.y)
                 zs.append(self.nodes[n].coord.z)
                 if tagging:
                     ax.text(self.nodes[n].coord.x + 0.01,
                             self.nodes[n].coord.y + 0.01,
                             self.nodes[n].coord.z + 0.01,
                             ("n{0}".format(n)), fontproperties=font0)
             for child in self.nodes[n].children:
                 next_generation.append(child)
                 if self.nodes[n].depth <= depth_cap:
                     xe = [self.nodes[n].coord.x, self.nodes[child].coord.x]
                     ye = [self.nodes[n].coord.y, self.nodes[child].coord.y]
                     ze = [self.nodes[n].coord.z, self.nodes[child].coord.z]
                     ax.plot(xe, ye, ze, plot_color_board[self.nodes[n].depth % 5])
         current_generation = next_generation
     ax.scatter(xs, ys, zs, c="r", marker="o")
     global_radius = self.nodes[self.root].radius * 1.12
     if equators:
         for axis in ["x", "y", "z"]:
             circle = Circle((0, 0), global_radius * 1.1)
             circle.set_clip_box(ax.bbox)
             circle.set_edgecolor("gray")
             circle.set_alpha(0.3)
             circle.set_facecolor("none")  # "none" not None
             ax.add_patch(circle)
             art3d.pathpatch_2d_to_3d(circle, z=0, zdir=axis)
     ax.set_xlim([-1.2 * global_radius, 1.2 * global_radius])
     ax.set_ylim([-1.2 * global_radius, 1.2 * global_radius])
     ax.set_zlim([-1.2 * global_radius, 1.2 * global_radius])
     ax.set_xlabel("X Label")
     ax.set_ylabel("Y Label")
     ax.set_zlabel("Z Label")
     plt.show()
Exemple #9
0
class Annotate(object):
    def __init__(self):
        self.ax = plt.gca()
        # self.rect = Rectangle((0,0), 1, 1)
        self.circ = Circle((0,0), 1, alpha=0.1)
        self.x0 = None
        self.y0 = None
        self.x1 = None
        self.y1 = None
        # self.ax.add_patch(self.rect)
        self.ax.add_patch(self.circ)
        self.press = None
        self.ax.figure.canvas.mpl_connect('button_press_event', self.on_press)
        self.ax.figure.canvas.mpl_connect('motion_notify_event', self.on_motion)
        self.ax.figure.canvas.mpl_connect('button_release_event', self.on_release)

    def on_press(self, event):
        print 'press'
        self.press = 1
        self.x0 = event.xdata
        self.y0 = event.ydata

    def on_motion(self, event):
        if self.press is None:
            return
        self.x1 = event.xdata
        self.y1 = event.ydata
        radius = ((self.x1 - self.x0)**2 + (self.y1 - self.y0)**2)**0.5
        self.circ.set_radius(radius)
        self.circ.center = self.x0, self.y0
        # ###self.rect.set_width(self.x1 - self.x0)
        # ###self.rect.set_height(self.y1 - self.y0)
        # ###self.rect.set_xy((self.x0, self.y0))
        self.ax.figure.canvas.draw()

    def on_release(self, event):
        print 'release'
        self.press = None
        self.x1 = event.xdata
        self.y1 = event.ydata
        radius = ((self.x1 - self.x0) ** 2 + (self.y1 - self.y0) ** 2) ** 0.5
        self.circ.set_radius(radius)
        self.circ.center = self.x0, self.y0
        # ###self.rect.set_width(self.x1 - self.x0)
        # ###self.rect.set_height(self.y1 - self.y0)
        # ###self.rect.set_xy((self.x0, self.y0))
        self.ax.figure.canvas.draw()
    def __init__(self, axes, sim, type_to_radius, type_to_color):
        assert len(type_to_radius) == len(type_to_color)

        particle_types_arr = sim.types
        self._typeToRadius = type_to_radius
        self._typeToColor = type_to_color
        self._particleCircles = []
        self._sim = sim
        for particleType in particle_types_arr:
            c = Circle((0, 0, 0), type_to_radius[particleType], )
            c.set_color(self._typeToColor[particleType])
            self._particleCircles.append(c)
            axes.add_patch(c)

        axes.set_xlim([0, sim.domain_size[0]])
        axes.set_ylim([0, sim.domain_size[1]])
        axes.set_aspect('equal')
Exemple #11
0
    def draw_chart_axes(self):
        # make outer circle
        self.smith_circle = Circle((0, 0), 1, transform=self.ax.transData, fc='none',
                              **self.patch_options_axis)
        self.ax.add_patch(self.smith_circle)

        # make constant r=1 circle
        z0_circle = Circle((0.5, 0), 0.5, transform=self.ax.transData, fc='none',
                              **self.patch_options_axis)
        z0_circle.set_clip_path(self.smith_circle)
        z0_circle.set_clip_box(self.ax.bbox)
        self.ax.add_patch(z0_circle)

        # make x-axis
        line = Line2D([-1,1],[0,0], **self.patch_options_axis)
        line.set_clip_path(self.smith_circle)
        line.set_clip_box(self.ax.bbox)
        self.ax.add_line(line)
class SelectablePoint:
    def __init__(self, xy, label, fig):
        self.point = Circle( (xy[0], xy[1]), .25, figure=fig)
        self.label = label
        self.cidpress = self.point.figure.canvas.mpl_connect('button_press_event', self.onClick)

    def onClick(self, e):
        if self.point.contains(e)[0]:
            print self.label
Exemple #13
0
def myCorrPlot(df):
	"""
	Correlation plot ( ~ corrplot with R)

	Takes a Pandas DataFrame as input and returns
	the plot which can then be shown with
    plot.show(), saved to a file with plot.savefig(), or
    manipulated in any other standard matplotlib way.

	Forked from https://github.com/louridas/corrplot
	"""
	plt.figure(1)
	ax = plt.subplot(1, 1, 1, aspect='equal')
	poscm = cm.get_cmap('Blues')
	negcm = cm.get_cmap('Reds')
	labels = df.columns

	for pair in combinations(labels, 2):
		corr = pearsonr(df[pair[0]].values, df[pair[1]].values)[0]
		clrmap = poscm if corr >= 0 else negcm
		circle = Circle((labels.get_loc(pair[0]),labels.get_loc(pair[1])), radius = 0.4)
		circle.set_edgecolor('black')
		circle.set_facecolor(clrmap(np.abs(corr)))
		mirrorCircle = Circle((labels.get_loc(pair[1]),labels.get_loc(pair[0])), radius = 0.4)
		mirrorCircle.set_edgecolor('black')
		mirrorCircle.set_facecolor(clrmap(np.abs(corr)))
		ax.add_artist(circle)
		ax.add_artist(mirrorCircle)

	ax.set_xlim(-1, len(labels))
	ax.set_ylim(-1, len(labels))
		
	ax.xaxis.tick_top()
	xtickslocs = np.arange(len(labels))
	ax.set_xticks(xtickslocs)
	ax.set_xticklabels(labels, rotation=30, fontsize='small', ha='left')

	ax.invert_yaxis()
	ytickslocs = np.arange(len(labels))
	ax.set_yticks(ytickslocs)
	ax.set_yticklabels(labels, fontsize='small')
	
	return plt
Exemple #14
0
    def draw_impedance_circles(self, intercept_x_coords, intercept_angles, labels=False):
        r_circle_coords, x_circle_coords, rs, xs = self._impedance_circle_coords(intercept_x_coords, intercept_angles)

        for center, radius in chain(r_circle_coords, x_circle_coords):
            c = Circle(center, radius, **self.patch_options_dark)

            c.set_clip_path(self.smith_circle)
            c.set_clip_box(self.ax.bbox)
            self.ax.add_patch(c)

        if labels:
            for x, r in zip(intercept_x_coords, rs):
                self.ax.text(x + 0.04, 0.03, '%.0f' % round(self.z0*r), **self.label_options)

            for a, x in zip(intercept_angles, xs):
                r = (a - 90) if x > 0 else (a + 90)
                a = np.radians(a)
                d = 1.04

                self.ax.text(d*cos(a), d*sin(a), '%.0fj' % round(self.z0*x), rotation=r, **self.label_options)
Exemple #15
0
    def draw_admittance_circles(self, intercept_x_coords, intercept_angles, labels=False):
        r_circle_coords, x_circle_coords, rs, xs = self._impedance_circle_coords(intercept_x_coords, intercept_angles)

        # admittance circles have same coords as impedance ones, except flipped
        # on the y-axis
        for (x, y), radius in chain(r_circle_coords, x_circle_coords):
            c = Circle((-x, -y), radius, **self.patch_options_light)

            c.set_clip_path(self.smith_circle)
            c.set_clip_box(self.ax.bbox)
            self.ax.add_patch(c)

        if labels:
            for x, r in zip(intercept_x_coords, rs):
                self.ax.text(-x, 0, '%.1f' % (1/(50*r)), **self.label_options)

            for a, x in zip(intercept_angles, xs):
                r = (a - 90) if x < 0 else (a + 90)
                a = np.radians(a)

                self.ax.text(cos(pi - a), sin(pi - a), '%.1f' % (1/(50*x)), rotation=r, **self.label_options)
Exemple #16
0
 def __init__(self):
     self.ax = plt.gca()
     # self.rect = Rectangle((0,0), 1, 1)
     self.circ = Circle((0,0), 1, alpha=0.1)
     self.x0 = None
     self.y0 = None
     self.x1 = None
     self.y1 = None
     # self.ax.add_patch(self.rect)
     self.ax.add_patch(self.circ)
     self.press = None
     self.ax.figure.canvas.mpl_connect('button_press_event', self.on_press)
     self.ax.figure.canvas.mpl_connect('motion_notify_event', self.on_motion)
     self.ax.figure.canvas.mpl_connect('button_release_event', self.on_release)
Exemple #17
0
def shooting_plot(shot_df, plot_size=(12,11), gridNum=30, mymap=plt.get_cmap('Spectral')):

    from matplotlib.patches import Circle
    x = shot_df.LOC_X[shot_df['LOC_Y']<425.1]
    y = shot_df.LOC_Y[shot_df['LOC_Y']<425.1]

    (shotVals, shotNumber) = find_shot_vals(shot_df, gridNum)

    fig = plt.figure(figsize=plot_size)
    cmap = mymap
    ax = plt.axes([0.1, 0.1, 0.8, 0.8])
    draw_court(outer_lines=False)
    plt.xlim(-250,250)
    plt.ylim(422.5, -47.5)

    norm = mpl.colors.Normalize(vmin=-0.5, vmax = -0.1)

    import math
    def logistic(x):
        return 20 / (1 + math.exp(-0.18*(x-np.median(shotNumber.get_array()))))

    for i, shots in enumerate(shotVals):
        restricted = Circle(shotNumber.get_offsets()[i], radius=shotNumber.get_array()[i],
                            color=cmap(norm(shots)),alpha=0.8, fill=True)
        restricted.radius = logistic( np.sqrt(restricted.radius) )
        if restricted.radius > 240/gridNum: restricted.radius=240/gridNum
        ax.add_patch(restricted)

    ax2 = fig.add_axes([0.92, 0.1, 0.02, 0.8])
    cb = mpl.colorbar.ColorbarBase(ax2,cmap=cmap, orientation='vertical')
    cb.set_label('next-possession value')
    cb.set_ticks([0.0, 0.25, 0.5, 0.75, 1.0])
    cb.set_ticklabels(['-0.5','-0.4', '-0.3','-0.2', '-0.1'])

    plt.show()

    return ax
 def __init__(self, vl, room_shape, start_iter):
     super(EnvironmentReader,self).__init__(win_size=[700,700],
                                            win_loc=pos,
                                            title='Environment')
     self.vl = vl
     self.cur_iter = start_iter
     
     self.cur_i = 0
     self.max_iter = np.max(vl['Iter num'])
     self.maxx = room_shape[0][1]
     self.maxy = room_shape[1][1]
     self.cntr_x = np.mean(room_shape[0])
     self.cntr_y = np.mean(room_shape[1])
     
     self.x_hist = []; self.y_hist = []
     
     self.canvas.mpl_connect('resize_event',lambda x: self.update_background())
     
     self.pos, = self.ax.plot([],[],color='g',animated=True)
     self.vel = Arrow([0,0],[1,0],arrowstyle='-|>, head_length=3, head_width=3',
                      animated=True, linewidth=4)
     self.ax.add_patch(self.vel)
     #self.radius, = self.ax.plot([],[],color='r',animated=True)
     self.clockcounter = self.ax.text(self.maxx,room_shape[1][0],
                                      '',ha='right',size='large',
                                      animated=True)
     self.iters = self.ax.text(self.maxx-1, room_shape[1][0]+3,
                               '',ha='right',animated=True)
     self.target = Circle([0,0],0,animated=True,color='r')
     self.target.set_radius(11)
     self.ax.add_artist(self.target)
     
     self.ax.set_xlim(room_shape[0])
     self.ax.set_ylim(room_shape[1])
     
     self.draw_plc_flds()
     
     self.draw_HMM_sectors()
     self.predicted_counter = self.ax.text(self.maxx,room_shape[1][0]+10,'',
                                           ha='right',size='large',animated=True)
     self.prediction_hist = None
     #self.cur_sec = Rectangle([0,0],self.HMM.dx,self.HMM.dy,fill=True,
     #                         color='k',animated=True)
     #self.ax_env.add_patch(self.cur_sec)
     
     self.canvas.draw()
Exemple #19
0
    def __init__(self, cloud, selection_shape, z_color=False, unlabeled_color = (1,0,0), labeled_color = (0,0,1)):
        self.selection_shape = selection_shape
        self.unlabeled_color = np.array(unlabeled_color)
        self.labeled_color = np.array(labeled_color)
        assert not np.all(unlabeled_color == labeled_color)
        
        self.fig = plt.figure('label rope ends', figsize=(24,12))
        self.fig.clear()
        self.ax = self.fig.add_subplot(111, aspect='equal')
        
        if cloud.shape[1] == 6:
            self.cloud = cloud
        else:
            self.cloud = np.c_[cloud[:,:3], np.tile(self.unlabeled_color, (cloud.shape[0],1))]
        
        if z_color:
            z_min = self.cloud[:,2].min()
            z_max = self.cloud[:,2].max()
            self.z_color = np.empty((len(self.cloud),3))
            for i in range(len(self.cloud)):
                f = (self.cloud[i,2] - z_min) / (z_max - z_min)
                self.z_color[i,:] = np.array(colorsys.hsv_to_rgb(f,1,1))
        else:
            self.z_color = None
        self.scatters = []
        self.rescatter_cloud()
        self.ax.autoscale(False)
        
        if self.selection_shape == 'rectangle' or self.selection_shape == 'square':
            self.rect = Rectangle((0,0), 0, 0, facecolor='None', edgecolor='green', linestyle='dashed')
            self.ax.add_patch(self.rect)
        elif self.selection_shape == 'circle':
            self.circle = Circle((0,0), 0, facecolor='None', edgecolor='green', linestyle='dashed')
            self.ax.add_patch(self.circle)
        self.x0 = None
        self.y0 = None
        self.x1 = None
        self.y1 = None

        self.fig.canvas.mpl_connect('button_press_event', self.on_press)
        self.fig.canvas.mpl_connect('button_release_event', self.on_release)
        self.motion_notify_cid = None
        self.fig.canvas.mpl_connect('key_press_event', self.on_key)

        plt.show()
Exemple #20
0
    def enable_cursor(self):
        self.cid_on_mouse_move = self.fig.canvas.mpl_connect('motion_notify_event', self._on_mouse_move)
        self.fig.canvas.mpl_connect('button_press_event', self._on_mouse_press)
        #self.cid_on_mouse_leave = self.fig.canvas.mpl_connect('axes_leave_event', self._on_mouse_leave)
        #self.cid_resize = self.fig.canvas.mpl_connect('resize_event', self._resize)
        self.cid_draw = self.fig.canvas.mpl_connect('draw_event', self._draw)

        self.cursor_text = Text(0.7, 0.1, 'n/a',
            horizontalalignment='left',
            verticalalignment='center',
            #bbox=dict(facecolor='white', alpha=1, ec='gray', pad=10),
            color='white',
            fontsize='small',
            alpha=0.8,
            backgroundcolor='gray',
            family='monospace',
            clip_box=self.ax.bbox,
            animated=True,
            transform = self.ax.transAxes)
        self.ax.add_artist(self.cursor_text)

        self.circle_matched_term = Circle((100,100), 0.02, alpha=0.5, color='green', animated=True)
        self.ax.add_patch(self.circle_matched_term)
Exemple #21
0
 def __init__(self, message, net, direction, *args, **kwargs):
     Circle.__init__(self, self._get_pos(message, net, direction), *args,
                     **kwargs)
Exemple #22
0
def im_phot(directory,gain,im_file,aperture):
	""" Perform photometry on the image """

	# Read in fits image file and create array with wcs coordinates
	os.chdir(directory)
	hdulist = fits.open(im_file)
	w = WCS(im_file)
	data = hdulist[0].data
	data[np.isnan(data)] = 0
	hdulist.close()

	# Calculate center point of image (RA, Dec) if not input by user
	targetra, targetdec = w.all_pix2world(len(data[:,0])/2,len(data[0,:])/2,0)

	# Use SEP for background subtraction and source detection
	datasw = data.byteswap().newbyteorder().astype('float64')
	bkg = sep.Background(datasw)
	data_bgs = data - bkg
	data_bgs[data_bgs < 0] = 0
	mean = np.mean(data_bgs)
	median = np.median(data_bgs)
	std = bkg.globalrms
	objects = sep.extract(data_bgs,3,err=bkg.globalrms)
	objra, objdec = w.all_pix2world(objects['x'],objects['y'],0)

	# Find dummy magnitudes using aperture photometry and plot images
	fig, ax = plt.subplots()
	image = plt.imshow(data_bgs,cmap='gray',vmin=(mean-3*std),
		vmax=(mean+3*std),origin='lower')
	sepmag = []
	sepmagerr = []
	ra = []
	dec = []
	xpixel = []
	ypixel = []

	for i in range(len(objects)):
				
		# Perform circular aperture photometry
		flux,fluxerr,flag = sep.sum_circle(data_bgs,objects['x'][i],
			objects['y'][i],aperture,err=std,gain=gain)
		mag = -2.5*np.log10(flux)
		maglimit1 = -2.5*np.log10((flux+fluxerr))
		maglimit2 = -2.5*np.log10((flux-fluxerr))
		magerr1 = np.abs(mag-maglimit1)
		magerr2 = np.abs(mag-maglimit2)
		magerr = (magerr1+magerr2)/2
		
		# Save object properties to arrays
		sepmag.append(mag)
		sepmagerr.append(magerr)
		ra.append(objra[i])
		dec.append(objdec[i])
		xpixel.append(objects['x'][i])
		ypixel.append(objects['y'][i])
		
		# Plot the detections on the image
		out = Circle(xy=(objects['x'][i],objects['y'][i]),radius=aperture)
		out.set_facecolor('none')
		out.set_edgecolor('red')
		ax.add_artist(out)

	plt.savefig(directory+'detections.png')	
	return targetra,targetdec,sepmag,sepmagerr,ra,dec,xpixel,ypixel
    def gauge(labels=['LOW','MEDIUM','HIGH','EXTREME'], \
              colors=['#007A00','#0063BF','#FFCC00','#ED1C24'], Probability=1, fname=False):

        N = len(labels)
        colors = colors[::-1]
        """
        begins the plotting
        """

        gauge_img = io.BytesIO()
        fig, ax = plt.subplots()

        ang_range, mid_points = degree_range(4)

        labels = labels[::-1]
        """
        plots the sectors and the arcs
        """
        patches = []
        for ang, c in zip(ang_range, colors):
            # sectors
            patches.append(Wedge((0., 0.), .4, *ang, facecolor='w', lw=2))
            # arcs
            patches.append(
                Wedge((0., 0.),
                      .4,
                      *ang,
                      width=0.10,
                      facecolor=c,
                      lw=2,
                      alpha=0.5))

        [ax.add_patch(p) for p in patches]
        """
        set the labels (e.g. 'LOW','MEDIUM',...)
        """

        for mid, lab in zip(mid_points, labels):

            ax.text(0.35 * np.cos(np.radians(mid)), 0.35 * np.sin(np.radians(mid)), lab, \
                horizontalalignment='center', verticalalignment='center', fontsize=14, \
                fontweight='bold', rotation = rot_text(mid))
        """
        set the bottom banner and the title
        """
        r = Rectangle((-0.4, -0.1), 0.8, 0.1, facecolor='w', lw=2)
        ax.add_patch(r)

        ax.text(0, -0.05, 'Churn Probability ' + np.round(Probability,2).astype(str), horizontalalignment='center', \
             verticalalignment='center', fontsize=22, fontweight='bold')
        """
        plots the arrow now
        """

        pos = (1 - Probability) * 180
        ax.arrow(0, 0, 0.225 * np.cos(np.radians(pos)), 0.225 * np.sin(np.radians(pos)), \
                     width=0.04, head_width=0.09, head_length=0.1, fc='k', ec='k')

        ax.add_patch(Circle((0, 0), radius=0.02, facecolor='k'))
        ax.add_patch(Circle((0, 0), radius=0.01, facecolor='w', zorder=11))
        """
        removes frame and ticks, and makes axis equal and tight
        """

        ax.set_frame_on(False)
        ax.axes.set_xticks([])
        ax.axes.set_yticks([])
        ax.axis('equal')
        plt.tight_layout()

        plt.savefig(gauge_img, format='png')
        gauge_img.seek(0)
        url = base64.b64encode(gauge_img.getvalue()).decode()
        return url
def create_base(box_bg='#CCCCCC',
                arrow1='#88CCFF',
                arrow2='#88FF88',
                supervised=True):
    plt.figure(figsize=(9, 6), facecolor='w')
    ax = plt.axes((0, 0, 1, 1), xticks=[], yticks=[], frameon=False)
    ax.set_xlim(0, 9)
    ax.set_ylim(0, 6)

    patches = [Rectangle((0.3, 3.6), 1.5, 1.8, zorder=1, fc=box_bg),
               Rectangle((0.5, 3.8), 1.5, 1.8, zorder=2, fc=box_bg),
               Rectangle((0.7, 4.0), 1.5, 1.8, zorder=3, fc=box_bg),

               Rectangle((2.9, 3.6), 0.2, 1.8, fc=box_bg),
               Rectangle((3.1, 3.8), 0.2, 1.8, fc=box_bg),
               Rectangle((3.3, 4.0), 0.2, 1.8, fc=box_bg),

               Rectangle((0.3, 0.2), 1.5, 1.8, fc=box_bg),

               Rectangle((2.9, 0.2), 0.2, 1.8, fc=box_bg),

               Circle((5.5, 3.5), 1.0, fc=box_bg),

               Polygon([[5.5, 1.7],
                        [6.1, 1.1],
                        [5.5, 0.5],
                        [4.9, 1.1]], fc=box_bg),

               FancyArrow(2.3, 4.6, 0.35, 0, fc=arrow1,
                          width=0.25, head_width=0.5, head_length=0.2),

               FancyArrow(3.75, 4.2, 0.5, -0.2, fc=arrow1,
                          width=0.25, head_width=0.5, head_length=0.2),

               FancyArrow(5.5, 2.4, 0, -0.4, fc=arrow1,
                          width=0.25, head_width=0.5, head_length=0.2),

               FancyArrow(2.0, 1.1, 0.5, 0, fc=arrow2,
                          width=0.25, head_width=0.5, head_length=0.2),

               FancyArrow(3.3, 1.1, 1.3, 0, fc=arrow2,
                          width=0.25, head_width=0.5, head_length=0.2),

               FancyArrow(6.2, 1.1, 0.8, 0, fc=arrow2,
                          width=0.25, head_width=0.5, head_length=0.2)]

    if supervised:
        patches += [Rectangle((0.3, 2.4), 1.5, 0.5, zorder=1, fc=box_bg),
                    Rectangle((0.5, 2.6), 1.5, 0.5, zorder=2, fc=box_bg),
                    Rectangle((0.7, 2.8), 1.5, 0.5, zorder=3, fc=box_bg),
                    FancyArrow(2.3, 2.9, 2.0, 0, fc=arrow1,
                               width=0.25, head_width=0.5, head_length=0.2),
                    Rectangle((7.3, 0.85), 1.5, 0.5, fc=box_bg)]
    else:
        patches += [Rectangle((7.3, 0.2), 1.5, 1.8, fc=box_bg)]

    for p in patches:
        ax.add_patch(p)

    plt.text(1.45, 4.9, "Training\nText,\nDocuments,\nImages,\netc.",
             ha='center', va='center', fontsize=14)

    plt.text(3.6, 4.9, "Feature\nVectors",
             ha='left', va='center', fontsize=14)

    plt.text(5.5, 3.5, "Machine\nLearning\nAlgorithm",
             ha='center', va='center', fontsize=14)

    plt.text(1.05, 1.1, "New Text,\nDocument,\nImage,\netc.",
             ha='center', va='center', fontsize=14)

    plt.text(3.3, 1.7, "Feature\nVector",
             ha='left', va='center', fontsize=14)

    plt.text(5.5, 1.1, "Predictive\nModel",
             ha='center', va='center', fontsize=12)

    if supervised:
        plt.text(1.45, 3.05, "Labels",
                 ha='center', va='center', fontsize=14)

        plt.text(8.05, 1.1, "Expected\nLabel",
                 ha='center', va='center', fontsize=14)
        plt.text(8.8, 5.8, "Supervised Learning Model",
                 ha='right', va='top', fontsize=18)

    else:
        plt.text(8.05, 1.1,
                 "Likelihood\nor Cluster ID\nor Better\nRepresentation",
                 ha='center', va='center', fontsize=12)
        plt.text(8.8, 5.8, "Unsupervised Learning Model",
                 ha='right', va='top', fontsize=18)
Exemple #25
0
class SmithChart(object):
    z0 = 50
    current_plane = None
    two_port = None
    show_matched_termination_cursor = True
    gain_cursor = False

    def __init__(self, ax=None, show_cursor=True, admittance=True, labels=False):
        self.ax = ax if ax else gca()
        self.fig = self.ax.figure

        self.draw_smith_chart(admittance, labels)

        if show_cursor:
            self.enable_cursor()

    def _impedance_circle_coords(self, intercept_x_coords, intercept_angles):
        # find coords for constant R circles
        rs = 2/(1 - asarray(intercept_x_coords)) - 1 # convert to desired resistances
        r_circle_coords = [((r/(r+1), 0), 1/(r + 1)) for r in rs]

        # find coords for constant X circles
        intercept_angles = np.radians(intercept_angles)
        xs = np.sin(intercept_angles)/(1 - np.cos(intercept_angles)) # convert to desired reactances
        x_circle_coords = [((1, 1/x), abs(1/x)) for x in xs]

        return r_circle_coords, x_circle_coords, rs, xs

    def draw_impedance_circles(self, intercept_x_coords, intercept_angles, labels=False):
        r_circle_coords, x_circle_coords, rs, xs = self._impedance_circle_coords(intercept_x_coords, intercept_angles)

        for center, radius in chain(r_circle_coords, x_circle_coords):
            c = Circle(center, radius, **self.patch_options_dark)

            c.set_clip_path(self.smith_circle)
            c.set_clip_box(self.ax.bbox)
            self.ax.add_patch(c)

        if labels:
            for x, r in zip(intercept_x_coords, rs):
                self.ax.text(x + 0.04, 0.03, '%.0f' % round(self.z0*r), **self.label_options)

            for a, x in zip(intercept_angles, xs):
                r = (a - 90) if x > 0 else (a + 90)
                a = np.radians(a)
                d = 1.04

                self.ax.text(d*cos(a), d*sin(a), '%.0fj' % round(self.z0*x), rotation=r, **self.label_options)

    def draw_admittance_circles(self, intercept_x_coords, intercept_angles, labels=False):
        r_circle_coords, x_circle_coords, rs, xs = self._impedance_circle_coords(intercept_x_coords, intercept_angles)

        # admittance circles have same coords as impedance ones, except flipped
        # on the y-axis
        for (x, y), radius in chain(r_circle_coords, x_circle_coords):
            c = Circle((-x, -y), radius, **self.patch_options_light)

            c.set_clip_path(self.smith_circle)
            c.set_clip_box(self.ax.bbox)
            self.ax.add_patch(c)

        if labels:
            for x, r in zip(intercept_x_coords, rs):
                self.ax.text(-x, 0, '%.1f' % (1/(50*r)), **self.label_options)

            for a, x in zip(intercept_angles, xs):
                r = (a - 90) if x < 0 else (a + 90)
                a = np.radians(a)

                self.ax.text(cos(pi - a), sin(pi - a), '%.1f' % (1/(50*x)), rotation=r, **self.label_options)

    def draw_vswr_circles(self, vswr_radii, labels=False):
        for r in vswr_radii:
            c = Circle((0, 0), r, ls='dashed', **self.patch_options_light)

            c.set_clip_path(self.smith_circle)
            c.set_clip_box(self.ax.bbox)
            self.ax.add_patch(c)

        if labels:
            for r in vswr_radii:
                if r > 0:
                    vswr = (1 + r)/(1 - r)
                    self.ax.text(0, r, '%.1f' % vswr, **self.label_options)

    def draw_chart_axes(self):
        # make outer circle
        self.smith_circle = Circle((0, 0), 1, transform=self.ax.transData, fc='none',
                              **self.patch_options_axis)
        self.ax.add_patch(self.smith_circle)

        # make constant r=1 circle
        z0_circle = Circle((0.5, 0), 0.5, transform=self.ax.transData, fc='none',
                              **self.patch_options_axis)
        z0_circle.set_clip_path(self.smith_circle)
        z0_circle.set_clip_box(self.ax.bbox)
        self.ax.add_patch(z0_circle)

        # make x-axis
        line = Line2D([-1,1],[0,0], **self.patch_options_axis)
        line.set_clip_path(self.smith_circle)
        line.set_clip_box(self.ax.bbox)
        self.ax.add_line(line)

    def draw_smith_chart(self, admittance, labels):
        # plot options for constant z/y circles and axes
        self.patch_options_light = {'fc':'none', 'color':'#474959', 'alpha':0.2, 'lw':1}
        self.patch_options_dark = {'fc':'none', 'color':'#474959', 'alpha':0.5, 'lw':1}
        self.patch_options_axis = {'color':'black', 'alpha':0.8, 'lw':1.5}

        # options for z/y circle labels
        self.label_options = {'ha':'center', 'va':'center', 'size':'9', 'alpha':0.5}#,
                         #'bbox':dict(fc='white', ec='none', alpha=0.5)}
        #self.label_options = {'ha':'center', 'va':'center', 'size':'10', 'alpha':0.5}

        # x-axis coordinates where constant R circles will intersect
        intercept_x_coords = arange(-0.75, 1, 0.25)

        # angles where constant X circles will intersect (in degrees relative
        # to positive x-axis)
        intercept_angles = arange(40, 360, 40)

        # radii for vswr circles
        vswr_radii = arange(0, 1, 0.2)

        self.draw_chart_axes()
        self.draw_impedance_circles(intercept_x_coords, intercept_angles, labels)
        self.draw_admittance_circles(intercept_x_coords, intercept_angles, labels=0)
        self.draw_vswr_circles(vswr_radii, labels)

        self.ax.grid(0)
        self.ax.axis('equal')
        self.ax.axis(np.array([-1.1, 1.1, -1.1, 1.1]))

        self.save_background()

    def enable_cursor(self):
        self.cid_on_mouse_move = self.fig.canvas.mpl_connect('motion_notify_event', self._on_mouse_move)
        self.fig.canvas.mpl_connect('button_press_event', self._on_mouse_press)
        #self.cid_on_mouse_leave = self.fig.canvas.mpl_connect('axes_leave_event', self._on_mouse_leave)
        #self.cid_resize = self.fig.canvas.mpl_connect('resize_event', self._resize)
        self.cid_draw = self.fig.canvas.mpl_connect('draw_event', self._draw)

        self.cursor_text = Text(0.7, 0.1, 'n/a',
            horizontalalignment='left',
            verticalalignment='center',
            #bbox=dict(facecolor='white', alpha=1, ec='gray', pad=10),
            color='white',
            fontsize='small',
            alpha=0.8,
            backgroundcolor='gray',
            family='monospace',
            clip_box=self.ax.bbox,
            animated=True,
            transform = self.ax.transAxes)
        self.ax.add_artist(self.cursor_text)

        self.circle_matched_term = Circle((100,100), 0.02, alpha=0.5, color='green', animated=True)
        self.ax.add_patch(self.circle_matched_term)

    def plot_circle(self, center, radius, text='', text_color='black', circle_color='red',\
                filled=False, circle_alpha=0.2, linestyle='solid', hatch=None):
        text_alpha = 0.7

        text_x_offset = 0.15
        text_y_offset = 0.1

        # calculate position for text
        a, b = center

        # find closet point to edge of circle
        x = a*(1 - radius/sqrt(a**2 + b**2))
        y = b*(1 - radius/sqrt(a**2 + b**2))
        dist_to_circle = sqrt(x**2 + y**2)

        #print 'dist to sphere: ', sqrt(x**2 + y**2)

        if (x**2 + y**2) == 1:
            text_x_offset *= -1
            text_y_offset *= -1

            #textpos = ((a - x)/radius + text_x_offset, (b - y)/radius + text_y_offset)
            textpos = (x/dist_to_circle + text_x_offset, y/dist_to_circle + text_y_offset)
        else:
            textpos = (x + text_x_offset, y + text_y_offset)

        #print 'textpos: ', textpos

        # make actual circle
        c = Circle(center, radius, fc=circle_color, ec='white', alpha=circle_alpha, fill=filled, linestyle=linestyle, hatch=hatch)
        self.ax.add_patch(c)

        self.ax.annotate(text, (x, y), color=text_color,\
            fontsize='small', alpha=text_alpha, xycoords='data', xytext=textpos,\
            arrowprops=dict(arrowstyle="->", alpha=text_alpha,\
            connectionstyle="arc3,rad=0.17"))

    def draw_stability_circles(self, two_port, plane='both', label=None):
        filled = True

        if plane == 'source' or plane == 'both':
            for i, (center, radius, circle_stable) in enumerate(zip(*two_port.source_stability_circle())):
                if circle_stable:
                    hatch = None
                    color = 'green'
                else:
                    hatch = '/'
                    color = 'red'

                if label is None:
                    label_actual = '\n(%0.2f MHz)' % (two_port.f[i]/1e6) if two_port.f is not None else ''
                    label_actual = 'Source' + label_actual
                else:
                    label_actual = label

                self.plot_circle((center.real, center.imag), radius, text=label_actual, filled=filled,\
                                text_color='black', circle_color=color, hatch=hatch)

        if plane == 'load' or plane == 'both':
            for i, (center, radius, circle_stable) in enumerate(zip(*two_port.load_stability_circle())):
                if circle_stable:
                    hatch = None
                    color = 'green'
                else:
                    hatch = '/'
                    color = 'red'

                if label is None:
                    label_actual = '\n(%0.2f MHz)' % (two_port.f[i]/1e6) if two_port.f is not None else ''
                    label_actual = 'Load' + label_actual
                else:
                    label_actual = label

                self.plot_circle((center.real, center.imag), radius, text=label_actual, filled=filled,\
                                text_color='black', circle_color=color, hatch=hatch)

        self.save_background()

    def plot_gain_circles(self, two_port, gains_db=None, plane='source', \
                          gain_cursor=True, surface=False):
        self.two_port = two_port
        self.gain_cursor = gain_cursor
        self.current_plane = plane

        max_gain = self.two_port.g_max()

        if (self.two_port.kt() < 1).any():
            max_gain = self.two_port.max_double_sided_mismatched_gain()

        if gains_db == None:
            gains_db = np.trunc(10*db(max_gain)[0]*linspace(0.5, 1, 4))/10
        if surface:
            filled = False
            circle_alpha = 0.7
            linestyle = 'dashed'
        else:
            filled = True
            circle_alpha = 0.2
            linestyle = 'solid'

        for g in gains_db:
            if plane == 'source':
                center, radius = self.two_port.available_gain_circle(un_db(g))
                self.ax.set_title('Source plane')
            elif plane == 'load':
                center, radius = self.two_port.operating_gain_circle(un_db(g))
                self.ax.set_title('Load plane')

            text = str(g) + ' dB'

            self.plot_circle((center[0].real, center[0].imag), radius[0], text=text, filled=filled,\
                text_color='black', circle_color='orange', circle_alpha=circle_alpha,\
                linestyle=linestyle)

        if not surface:
            self.save_background()

            return

        num_segments = 1000

        i, r = meshgrid(linspace(-1.1, 1.1, num_segments), linspace(-1.1, 1.1, num_segments))
        gamma = i + 1j*r
        term = OnePort(s=gamma.reshape(-1))

        if plane == 'source':
            g = self.two_port.g_a(term)
        elif plane == 'load':
            g = self.two_port.g_p(term)

        g = db(g).reshape(num_segments, num_segments)
        g[abs(gamma) > 1] = nan

        im = self.ax.imshow(g, origin='lower', extent=(-1.1, 1.1, -1.1, 1.1), interpolation='bicubic', alpha=0.9)
        im.set_clim(gains_db[0], db(max_gain))

        self.save_background()

    def _on_mouse_press(self, event):
        if event.button == 3:
            print 'clearing'
            self.fig.canvas.restore_region(self.background, bbox=self.ax.bbox)

    def _on_mouse_move(self, event):
        if event.xdata is None or event.ydata is None:
            return

        gamma = event.xdata + 1j*event.ydata
        cursor_port = OnePort(s=gamma)

        self.fig.canvas.restore_region(self.background, bbox=self.ax.bbox)

        self.update_gain_cursor(cursor_port)
        self.update_info_box(cursor_port)

        #self.fig.canvas.draw()
        self.fig.canvas.blit(self.ax.bbox)

    def update_gain_cursor(self, cursor_port):
        if not self.gain_cursor or self.two_port is None:
            return

        if self.current_plane == 'source':
            term_matched = (cursor_port*self.two_port).out().conj()
            term_resulting = (self.two_port*term_matched).inp()
        else:
            term_matched = (self.two_port*cursor_port).inp().conj()
            term_resulting = (term_matched*self.two_port).out()

        self.circle_matched_term.center = real(term_matched.s), imag(term_matched.s)

        if abs(term_matched.s) > 1 or abs(term_resulting.s) > 1:
            self.circle_matched_term.set_color('r')
        else:
            self.circle_matched_term.set_color('g')

        self.ax.draw_artist(self.circle_matched_term)

    def update_info_box(self, cursor_port):
        z = cursor_port.z
        y = cursor_port.y

        data = '$\\Gamma$ = {:>7.2f} $\\angle$ {:>+8.3f}$^{{\\circ}}$'.format(float(abs(cursor_port.s)), float(degrees(angle(cursor_port.s))))
        data += '\nVSWR = {:>7.2f}'.format(float(cursor_port.vswr()))
        data += '\nMM = {:>7.2f} dB'.format(float(db(cursor_port.mismatch())))
        data += '\nZ = {:>7.2f}{:>+8.2f}j '.format(float(real(z)), float(imag(z)))

        if self.two_port is not None:
            if self.current_plane == 'source':
                term_matched = (cursor_port*self.two_port).out().conj()
                gain = self.two_port.g_t(cursor_port, term_matched)
            else:
                term_matched = (self.two_port*cursor_port).inp().conj()
                gain = self.two_port.g_t(term_matched, cursor_port)

            x = float(imag(z))
            w = 2*pi*self.two_port.f[0]

            if x > 0:
                hf = 'H'
                lc = x/w
            else:
                hf = 'F'
                lc = 1/(w*x)

            val, prefix = to_eng_form(abs(lc))
            data += '({:>3.2f} {}{}) '.format(val, prefix, hf)
        data += '$\\Omega$'

        data += '\n  = {:>7.2f} // {:>+8.2f}j '.format(float(1/real(y)), float(-1/imag(y)))
        if self.two_port is not None:
            x = float(-1/imag(y))
            w = 2*pi*self.two_port.f[0]
            if x > 0:
                hf = 'H'
                lc = x/w
            else:
                hf = 'F'
                lc = 1/(w*x)

            val, prefix = to_eng_form(abs(lc))
            data += '({:>3.2f} {}{}) '.format(val, prefix, hf)
        data += '$\\Omega$'

        if self.gain_cursor and self.two_port is not None:
            gain_str = '{:>7.2f} dB'.format(float(db(gain))) if gain > 0 else 'n/a'
            data += '\nG = ' + gain_str

        self.cursor_text.set_text(data)
        self.ax.draw_artist(self.cursor_text)

    def plot_s_param(self, s, color='blue'):
        self.plot_line(s, color)

        self.save_background()

    def plot_line(self, points, color='blue'):
        r, t = abs(points), angle(points)

        l = Line2D(r*cos(t), r*sin(t), color=color)
        self.ax.add_line(l)

    def save_background(self):
        self.fig.canvas.draw()
        self.background = self.fig.canvas.copy_from_bbox(self.ax.bbox)

    def _on_mouse_leave(self, event):
        pass

    def _resize(self, event):
        self.save_background()
        print 'resize\n'
        #self.ax.draw(None)
        #self.fig.canvas.draw()
        #self.fig.canvas.restore_region(self.background, bbox=self.ax.bbox)

    def _draw(self, event):
        self.fig.canvas.mpl_disconnect(self.cid_draw)
        #self.fig.canvas.restore_region(self.background, bbox=self.ax.bbox)
        self.save_background()
        self.cid_draw = self.fig.canvas.mpl_connect('draw_event', self._draw)
Exemple #26
0
class Annotate(object):
    def __init__(self, cloud, selection_shape, z_color=False, unlabeled_color = (1,0,0), labeled_color = (0,0,1)):
        self.selection_shape = selection_shape
        self.unlabeled_color = np.array(unlabeled_color)
        self.labeled_color = np.array(labeled_color)
        assert not np.all(unlabeled_color == labeled_color)
        
        self.fig = plt.figure('label rope ends', figsize=(24,12))
        self.fig.clear()
        self.ax = self.fig.add_subplot(111, aspect='equal')
        
        if cloud.shape[1] == 6:
            self.cloud = cloud
        else:
            self.cloud = np.c_[cloud[:,:3], np.tile(self.unlabeled_color, (cloud.shape[0],1))]
        
        if z_color:
            z_min = self.cloud[:,2].min()
            z_max = self.cloud[:,2].max()
            self.z_color = np.empty((len(self.cloud),3))
            for i in range(len(self.cloud)):
                f = (self.cloud[i,2] - z_min) / (z_max - z_min)
                self.z_color[i,:] = np.array(colorsys.hsv_to_rgb(f,1,1))
        else:
            self.z_color = None
        self.scatters = []
        self.rescatter_cloud()
        self.ax.autoscale(False)
        
        if self.selection_shape == 'rectangle' or self.selection_shape == 'square':
            self.rect = Rectangle((0,0), 0, 0, facecolor='None', edgecolor='green', linestyle='dashed')
            self.ax.add_patch(self.rect)
        elif self.selection_shape == 'circle':
            self.circle = Circle((0,0), 0, facecolor='None', edgecolor='green', linestyle='dashed')
            self.ax.add_patch(self.circle)
        self.x0 = None
        self.y0 = None
        self.x1 = None
        self.y1 = None

        self.fig.canvas.mpl_connect('button_press_event', self.on_press)
        self.fig.canvas.mpl_connect('button_release_event', self.on_release)
        self.motion_notify_cid = None
        self.fig.canvas.mpl_connect('key_press_event', self.on_key)

        plt.show()
    
    def rescatter_cloud(self):
        for scatter in self.scatters:
            scatter.remove()
        self.scatters = []
        if self.z_color is not None:
            ul_inds = np.absolute((self.cloud[:,3:] - self.unlabeled_color)).sum(axis=1) == 0 # unlabeled inds
            self.scatters.append(plt.scatter(self.cloud[ul_inds,0], self.cloud[ul_inds,1], c=self.z_color[ul_inds,:], edgecolors=self.z_color[ul_inds,:], marker=',', s=5))
            self.scatters.append(plt.scatter(self.cloud[~ul_inds,0], self.cloud[~ul_inds,1], c=self.cloud[~ul_inds,3:], edgecolors=self.cloud[~ul_inds,3:], marker='o', s=20))
        else:
            self.scatters.append(plt.scatter(self.cloud[:,0], self.cloud[:,1], c=self.cloud[:,3:], edgecolors=self.cloud[:,3:], marker=',', s=5))
    
    def on_press(self, event):
        if event.xdata < self.ax.get_xlim()[0] or event.xdata > self.ax.get_xlim()[1] or \
            event.ydata < self.ax.get_ylim()[0] or event.ydata > self.ax.get_ylim()[1]:
            return
        self.x0 = event.xdata
        self.y0 = event.ydata
        self.motion_notify_cid = self.fig.canvas.mpl_connect('motion_notify_event', self.on_motion)

    def on_release(self, event):
        if self.motion_notify_cid:
            self.fig.canvas.mpl_disconnect(self.motion_notify_cid)
            self.motion_notify_cid = None
            if self.selection_shape == 'rectangle' or self.selection_shape == 'square':
                x0 = min(self.x0, self.x1)
                x1 = max(self.x0, self.x1)
                y0 = min(self.y0, self.y1)
                y1 = max(self.y0, self.y1)
                inside_rect_inds = (x0 <= self.cloud[:,0]) * (self.cloud[:,0] <= x1) * (y0 <= self.cloud[:,1]) * (self.cloud[:,1] <= y1)
                num_pts_inside_rect = inside_rect_inds.sum()
                self.cloud[inside_rect_inds,3:] = np.tile(self.labeled_color, (num_pts_inside_rect,1))
            elif self.selection_shape == 'circle':
                inside_circle_inds = np.apply_along_axis(np.linalg.norm, 1, self.cloud[:,:2] - np.array(self.circle.center)) <= self.circle.get_radius()
                num_pts_inside_circle = inside_circle_inds.sum()
                self.cloud[inside_circle_inds,3:] = np.tile(self.labeled_color, (num_pts_inside_circle,1))
            self.rescatter_cloud()
            plt.draw()
    
    def on_motion(self, event):
        if event.xdata < self.ax.get_xlim()[0] or event.xdata > self.ax.get_xlim()[1] or \
            event.ydata < self.ax.get_ylim()[0] or event.ydata > self.ax.get_ylim()[1]:
            return
        if self.selection_shape == 'rectangle':
            self.x1 = event.xdata
            self.y1 = event.ydata
        elif self.selection_shape == 'circle' or self.selection_shape == 'square':
            side = max(abs(event.xdata - self.x0), abs(event.ydata - self.y0))
            self.x1 = self.x0 + np.sign(event.xdata - self.x0) * side
            self.y1 = self.y0 + np.sign(event.ydata - self.y0) * side
        if self.selection_shape == 'rectangle' or self.selection_shape == 'square':
            self.rect.set_width(self.x1 - self.x0)
            self.rect.set_height(self.y1 - self.y0)
            self.rect.set_xy((self.x0, self.y0))
        elif self.selection_shape == 'circle':
            self.circle.center = ((self.x1 + self.x0)/2.0, (self.y0 + self.y1)/2.0)
            self.circle.set_radius(side/2.0)
        plt.draw()
    
    def on_key(self, event):
        if event.key == 'q':
            sys.exit(0)
        if event.key == 'd':
            plt.close(self.fig)
Exemple #27
0
def plot_state_qsphere(state, figsize=None, ax=None, show_state_labels=True,
                       show_state_phases=False, use_degrees=False, *, rho=None):
    """Plot the qsphere representation of a quantum state.
    Here, the size of the points is proportional to the probability
    of the corresponding term in the state and the color represents
    the phase.

    Args:
        state (Statevector or DensityMatrix or ndarray): an N-qubit quantum state.
        figsize (tuple): Figure size in inches.
        ax (matplotlib.axes.Axes): An optional Axes object to be used for
            the visualization output. If none is specified a new matplotlib
            Figure will be created and used. Additionally, if specified there
            will be no returned Figure since it is redundant.
        show_state_labels (bool): An optional boolean indicating whether to
            show labels for each basis state.
        show_state_phases (bool): An optional boolean indicating whether to
            show the phase for each basis state.
        use_degrees (bool): An optional boolean indicating whether to use
            radians or degrees for the phase values in the plot.

    Returns:
        Figure: A matplotlib figure instance if the ``ax`` kwag is not set

    Raises:
        ImportError: Requires matplotlib.
        VisualizationError: if input is not a valid N-qubit state.

        QiskitError: Input statevector does not have valid dimensions.

    Example:
        .. jupyter-execute::

           from qiskit import QuantumCircuit
           from qiskit.quantum_info import Statevector
           from qiskit.visualization import plot_state_qsphere
           %matplotlib inline

           qc = QuantumCircuit(2)
           qc.h(0)
           qc.cx(0, 1)

           state = Statevector.from_instruction(qc)
           plot_state_qsphere(state)
    """
    if not HAS_MATPLOTLIB:
        raise ImportError('Must have Matplotlib installed. To install, run "pip install '
                          'matplotlib".')
    try:
        import seaborn as sns
    except ImportError:
        raise ImportError('Must have seaborn installed to use '
                          'plot_state_qsphere. To install, run "pip install seaborn".')
    rho = DensityMatrix(state)
    num = rho.num_qubits
    if num is None:
        raise VisualizationError("Input is not a multi-qubit quantum state.")
    # get the eigenvectors and eigenvalues
    eigvals, eigvecs = linalg.eigh(rho.data)

    if figsize is None:
        figsize = (7, 7)

    if ax is None:
        return_fig = True
        fig = plt.figure(figsize=figsize)
    else:
        return_fig = False
        fig = ax.get_figure()

    gs = gridspec.GridSpec(nrows=3, ncols=3)

    ax = fig.add_subplot(gs[0:3, 0:3], projection='3d')
    ax.axes.set_xlim3d(-1.0, 1.0)
    ax.axes.set_ylim3d(-1.0, 1.0)
    ax.axes.set_zlim3d(-1.0, 1.0)
    ax.axes.grid(False)
    ax.view_init(elev=5, azim=275)

    # start the plotting
    # Plot semi-transparent sphere
    u = np.linspace(0, 2 * np.pi, 25)
    v = np.linspace(0, np.pi, 25)
    x = np.outer(np.cos(u), np.sin(v))
    y = np.outer(np.sin(u), np.sin(v))
    z = np.outer(np.ones(np.size(u)), np.cos(v))
    ax.plot_surface(x, y, z, rstride=1, cstride=1, color='k',
                    alpha=0.05, linewidth=0)

    # Get rid of the panes
    ax.w_xaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
    ax.w_yaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))
    ax.w_zaxis.set_pane_color((1.0, 1.0, 1.0, 0.0))

    # Get rid of the spines
    ax.w_xaxis.line.set_color((1.0, 1.0, 1.0, 0.0))
    ax.w_yaxis.line.set_color((1.0, 1.0, 1.0, 0.0))
    ax.w_zaxis.line.set_color((1.0, 1.0, 1.0, 0.0))

    # Get rid of the ticks
    ax.set_xticks([])
    ax.set_yticks([])
    ax.set_zticks([])

    # traversing the eigvals/vecs backward as sorted low->high
    for idx in range(eigvals.shape[0]-1, -1, -1):
        if eigvals[idx] > 0.001:
            # get the max eigenvalue
            state = eigvecs[:, idx]
            loc = np.absolute(state).argmax()
            # remove the global phase from max element
            angles = (np.angle(state[loc]) + 2 * np.pi) % (2 * np.pi)
            angleset = np.exp(-1j * angles)
            state = angleset * state

            d = num
            for i in range(2 ** num):
                # get x,y,z points
                element = bin(i)[2:].zfill(num)
                weight = element.count("1")
                zvalue = -2 * weight / d + 1
                number_of_divisions = n_choose_k(d, weight)
                weight_order = bit_string_index(element)
                angle = (float(weight) / d) * (np.pi * 2) + \
                        (weight_order * 2 * (np.pi / number_of_divisions))

                if (weight > d / 2) or ((weight == d / 2) and
                                        (weight_order >= number_of_divisions / 2)):
                    angle = np.pi - angle - (2 * np.pi / number_of_divisions)

                xvalue = np.sqrt(1 - zvalue ** 2) * np.cos(angle)
                yvalue = np.sqrt(1 - zvalue ** 2) * np.sin(angle)

                # get prob and angle - prob will be shade and angle color
                prob = np.real(np.dot(state[i], state[i].conj()))
                if prob > 1:  # See https://github.com/Qiskit/qiskit-terra/issues/4666
                    prob = 1
                colorstate = phase_to_rgb(state[i])

                alfa = 1
                if yvalue >= 0.1:
                    alfa = 1.0 - yvalue

                if not np.isclose(prob, 0) and show_state_labels:
                    rprime = 1.3
                    angle_theta = np.arctan2(np.sqrt(1 - zvalue ** 2), zvalue)
                    xvalue_text = rprime * np.sin(angle_theta) * np.cos(angle)
                    yvalue_text = rprime * np.sin(angle_theta) * np.sin(angle)
                    zvalue_text = rprime * np.cos(angle_theta)
                    element_text = '$\\vert' + element + '\\rangle$'
                    if show_state_phases:
                        element_angle = (np.angle(state[i]) + (np.pi * 4)) % (np.pi * 2)
                        if use_degrees:
                            element_text += '\n$%.1f^\\circ$' % (element_angle * 180/np.pi)
                        else:
                            element_angle = pi_check(element_angle, ndigits=3).replace('pi', '\\pi')
                            element_text += '\n$%s$' % (element_angle)
                    ax.text(xvalue_text, yvalue_text, zvalue_text, element_text,
                            ha='center', va='center', size=12)

                ax.plot([xvalue], [yvalue], [zvalue],
                        markerfacecolor=colorstate,
                        markeredgecolor=colorstate,
                        marker='o', markersize=np.sqrt(prob) * 30, alpha=alfa)

                a = Arrow3D([0, xvalue], [0, yvalue], [0, zvalue],
                            mutation_scale=20, alpha=prob, arrowstyle="-",
                            color=colorstate, lw=2)
                ax.add_artist(a)

            # add weight lines
            for weight in range(d + 1):
                theta = np.linspace(-2 * np.pi, 2 * np.pi, 100)
                z = -2 * weight / d + 1
                r = np.sqrt(1 - z ** 2)
                x = r * np.cos(theta)
                y = r * np.sin(theta)
                ax.plot(x, y, z, color=(.5, .5, .5), lw=1, ls=':', alpha=.5)

            # add center point
            ax.plot([0], [0], [0], markerfacecolor=(.5, .5, .5),
                    markeredgecolor=(.5, .5, .5), marker='o', markersize=3,
                    alpha=1)
        else:
            break

    n = 64
    theta = np.ones(n)

    ax2 = fig.add_subplot(gs[2:, 2:])
    ax2.pie(theta, colors=sns.color_palette("hls", n), radius=0.75)
    ax2.add_artist(Circle((0, 0), 0.5, color='white', zorder=1))
    offset = 0.95  # since radius of sphere is one.

    if use_degrees:
        labels = ['Phase\n(Deg)', '0', '90', '180   ', '270']
    else:
        labels = ['Phase', '$0$', '$\\pi/2$', '$\\pi$', '$3\\pi/2$']

    ax2.text(0, 0, labels[0], horizontalalignment='center',
             verticalalignment='center', fontsize=14)
    ax2.text(offset, 0, labels[1], horizontalalignment='center',
             verticalalignment='center', fontsize=14)
    ax2.text(0, offset, labels[2], horizontalalignment='center',
             verticalalignment='center', fontsize=14)
    ax2.text(-offset, 0, labels[3], horizontalalignment='center',
             verticalalignment='center', fontsize=14)
    ax2.text(0, -offset, labels[4], horizontalalignment='center',
             verticalalignment='center', fontsize=14)

    if return_fig:
        if get_backend() in ['module://ipykernel.pylab.backend_inline',
                             'nbAgg']:
            plt.close(fig)
        return fig
Exemple #28
0
def circles(x, y, s, c='b', vmin=None, vmax=None, **kwargs):
    """
    Make a scatter of circles plot of x vs y, where x and y are sequence 
    like objects of the same lengths. The size of circles are in data scale.

    Parameters
    ----------
    x,y : scalar or array_like, shape (n, )
        Input data
    s : scalar or array_like, shape (n, ) 
        Radius of circle in data unit.
    c : color or sequence of color, optional, default : 'b'
        `c` can be a single color format string, or a sequence of color
        specifications of length `N`, or a sequence of `N` numbers to be
        mapped to colors using the `cmap` and `norm` specified via kwargs.
        Note that `c` should not be a single numeric RGB or RGBA sequence 
        because that is indistinguishable from an array of values
        to be colormapped. (If you insist, use `color` instead.)  
        `c` can be a 2-D array in which the rows are RGB or RGBA, however. 
    vmin, vmax : scalar, optional, default: None
        `vmin` and `vmax` are used in conjunction with `norm` to normalize
        luminance data.  If either are `None`, the min and max of the
        color array is used.
    kwargs : `~matplotlib.collections.Collection` properties
        Eg. alpha, edgecolor(ec), facecolor(fc), linewidth(lw), linestyle(ls), 
        norm, cmap, transform, etc.

    Returns
    -------
    paths : `~matplotlib.collections.PathCollection`

    Examples
    --------
    a = np.arange(11)
    circles(a, a, a*0.2, c=a, alpha=0.5, edgecolor='none')
    plt.colorbar()

    License
    --------
    This code is under [The BSD 3-Clause License]
    (http://opensource.org/licenses/BSD-3-Clause)
    """
    

    if np.isscalar(c):
        kwargs.setdefault('color', c)
        c = None
    if 'fc' in kwargs: kwargs.setdefault('facecolor', kwargs.pop('fc'))
    if 'ec' in kwargs: kwargs.setdefault('edgecolor', kwargs.pop('ec'))
    if 'ls' in kwargs: kwargs.setdefault('linestyle', kwargs.pop('ls'))
    if 'lw' in kwargs: kwargs.setdefault('linewidth', kwargs.pop('lw'))

    patches = [Circle((x_, y_), s_) for x_, y_, s_ in np.broadcast(x, y, s)]
    collection = PatchCollection(patches, **kwargs)
    if c is not None:
        collection.set_array(np.asarray(c))
        collection.set_clim(vmin, vmax)

    ax = plt.gca()
    ax.add_collection(collection)
    ax.autoscale_view()
    if c is not None:
        plt.sci(collection)
    return collection
Exemple #29
0
 def myscatter(ax, colormap, x, y, radii, colors): 
     for x1,y1,r,c in zip(x, y, radii, colormap(colors)): 
         ax.add_patch(Circle((x1,y1), r, fc=c)) 
class BallBeam():
    """ BallBeam

    Simple ball and beam simulation built to interface easily with OpenAI's
    gym environments.

    System dynamics
    ---------------
    dx/dt = v(t)
    dv/dt = -m*g*sin(theta(t))/((I + 1)*m)

    Parameters
    ----------
    time_step : time of one simulation step, float (s)

    beam_length : length of beam, float (units)

    max_angle : max of abs(angle), float (rads) 

    init_velocity : initial speed of ball, float (units/s)
    """

    def __init__(self, timestep=0.01, beam_length=1.08, max_angle=20*3.14/180, init_velocity=0.0):
        self.dt = timestep                  # time step
        self.g = 9.82                       # gravity
        self.r = 0.0159                       # ball radius
        self.L = beam_length                # beam length
        self.I = (2/5*self.r**2 )             # solid ball inertia (omits mass)
        self.init_velocity = init_velocity  # initial velocity
        self.max_angle = max_angle          # max beam angle (rad)
        self.reset()
        self.human_rendered = False
        self.machine_rendered = False

    def reset(self):
        radius = self.L/2                       # beam radius
        self.t = 0.0                            # time
        self.x = 0.4                           # ball position x
        self.y = self.r                         # ball position y
        self.v = self.init_velocity             # ball velocity
        self.theta = 0.0                        # beam angle (rad)
        self.dtheta = 0.0                       # beam angle change (rad)
        self.v_x = 0.0                          # velocity x component
        self.v_y = 0.0                          # velocity y component
        self.lim_x = [-cos(self.theta)*radius,  # geam limits x
                       cos(self.theta)*radius] 
        self.lim_y = [-sin(self.theta)*radius,  # beam limits y
                       sin(self.theta)*radius] 

    def update(self, angle):
        """ 
        Update simulation with one time step

        Parameters
        ----------
        angle : angle the beam should be set to, float (rad)
        """
        radius = self.L/2

        # simulation could be improved further by using voltage as input and a
        # motor simulation deciding theta     
        theta = max(-self.max_angle, min(self.max_angle, angle))
        
        # store angle change for angular velocity
        self.dtheta = (theta - self.theta)
        self.theta = theta 

        if self.on_beam:
            x = self.x
            y = self.y

            # dynamics on beam
            self.v +=  (x*self.dtheta*self.dtheta-self.g*sin(self.theta))*(5/7)*self.dt   
            self.x += self.v*self.dt
            self.y = self.r/cos(self.theta) + self.x*sin(self.theta)

            # keep track of velocities for x and y
            self.v_x = (self.x - x)/self.dt
            self.v_y = (self.y - y)/self.dt
        else:
            # free fall dynamics off beam
            self.v_y -= self.g*self.dt
            self.v = (self.v_x**2 + self.v_y**2)**0.5
            self.x += self.v_x*self.dt
            self.y += self.v_y*self.dt
        
        # edge of beam
        self.lim_x = [-cos(self.theta)*radius, cos(self.theta)*radius]
        self.lim_y = [-sin(self.theta)*radius, sin(self.theta)*radius]
        
        # update time
        self.t += self.dt

    def _init_render(self, setpoint, mode):
        """ Initialize rendering """
        radius = self.L/2

        if mode == 'human':
            self.human_rendered = True
            plt.ion()
            fig, ax = plt.subplots(1, 1, figsize=(8, 4))
            fig.canvas.set_window_title('Beam & Ball')
            ax.set(xlim = (-2*radius, 2*radius), ylim = (-self.L/2, self.L/2))
            
            # draw ball
            self.ball_plot = Circle((self.x, self.y), self.r)
            ax.add_patch(self.ball_plot)
            ax.patches[0].set_color('red')
            # draw beam
            ax.plot([-cos(self.theta)*radius, cos(self.theta)*radius], 
                    [-sin(self.theta)*radius, sin(self.theta)*radius], lw=4, color='black')
            ax.plot(0.0, 0.0, '.', ms=20)

            if setpoint is not None:
                ax.add_patch(Polygon( \
                    [[setpoint*cos(self.theta), -0.01*self.L + setpoint*sin(self.theta)],
                    [setpoint*cos(self.theta) - 0.015*self.L, -0.03*self.L + setpoint*sin(self.theta)],
                    [setpoint*cos(self.theta) + 0.015*self.L, -0.03*self.L + setpoint*sin(self.theta)]]))
                ax.patches[1].set_color('red')

            self.fig = fig
            self.ax = ax
        else:
            self.machine_rendered = True
            fig, ax = plt.subplots(1, 1, figsize=(8, 4))

            # avoid drawing plot but still initialize
            _ = fig.canvas.set_window_title('Beam & Ball')
            _ = ax.set(xlim = (-2*radius, 2*radius), ylim = (-self.L/2, self.L/2))
            
            # draw ball
            self.ball_plot = Circle((self.x, self.y), self.r)
            _ = ax.add_patch(self.ball_plot)
            _ = ax.patches[0].set_color('red')
            # draw beam
            _ = ax.plot([-cos(self.theta)*radius, cos(self.theta)*radius], 
                    [-sin(self.theta)*radius, sin(self.theta)*radius], lw=4, color='black')
            _ = ax.plot(0.0, 0.0, '.', ms=20)

            if setpoint is not None:
                _ = ax.add_patch(Polygon( \
                    [[setpoint*cos(self.theta), -0.01*self.L + setpoint*sin(self.theta)],
                    [setpoint*cos(self.theta) - 0.015*self.L, -0.03*self.L + setpoint*sin(self.theta)],
                    [setpoint*cos(self.theta) + 0.015*self.L, -0.03*self.L + setpoint*sin(self.theta)]]))
                _ = ax.patches[1].set_color('red')

            self.machine_fig = fig
            self.machine_ax = ax

    def render(self, setpoint=None, mode='human'):
        """ 
        Render simulation at it's current state

        Parameters
        ----------
        setpoint : optional marking of the ball setpoint, float (units)

        mode : rendering mode, str [human, machine]
        """
        if (not self.human_rendered and mode == 'human') or \
           (not self.machine_rendered and mode == 'machine'):
            self._init_render(setpoint, mode)

        if mode == 'human':
            # update ball
            self.ball_plot.set_center((self.x, self.y))
            # update beam
            self.ax.lines[0].set(xdata=self.lim_x, ydata=self.lim_y)

            # mark setpoint
            if setpoint is not None:
                self.ax.patches[1].set_xy( \
                    [[setpoint*cos(self.theta), -0.01*self.L + setpoint*sin(self.theta)],
                    [setpoint*cos(self.theta) - 0.015*self.L, -0.03*self.L + setpoint*sin(self.theta)],
                    [setpoint*cos(self.theta) + 0.015*self.L, -0.03*self.L + setpoint*sin(self.theta)]])

            # update figure
            self.fig.canvas.draw()
            self.fig.canvas.flush_events()

        else:
            # update ball
            _ = self.ball_plot.set_center((self.x, self.y))
            # update beam
            _ = self.machine_ax.lines[0].set(xdata=self.lim_x, ydata=self.lim_y)

            # mark setpoint
            if setpoint is not None:
                _ = self.machine_ax.patches[1].set_xy( \
                    [[setpoint*cos(self.theta), -0.01*self.L + setpoint*sin(self.theta)],
                    [setpoint*cos(self.theta) - 0.015*self.L, -0.03*self.L + setpoint*sin(self.theta)],
                    [setpoint*cos(self.theta) + 0.015*self.L, -0.03*self.L + setpoint*sin(self.theta)]])

            # update figure
            _ = self.machine_fig.canvas.draw()
            _ = self.machine_fig.canvas.flush_events()


    @property
    def on_beam(self):
        """ 
        Check if ball is still on the beam 
        
        Returns
        -------
        on_beam : if ball is still located on the beam, bool
        
        """
        return self.lim_x[0] < self.x and self.lim_x[1] > self.x
Exemple #31
0
    def __init__(self, map, schedule):
        self.map = map
        self.schedule = schedule

        aspect = map["map"]["dimensions"][0] / map["map"]["dimensions"][1]

        self.fig = plt.figure(frameon=False, figsize=(4 * aspect, 4))
        self.ax = self.fig.add_subplot(111, aspect='equal')
        self.fig.subplots_adjust(left=0,
                                 right=1,
                                 bottom=0,
                                 top=1,
                                 wspace=None,
                                 hspace=None)
        # self.ax.set_frame_on(False)

        self.patches = []
        self.artists = []
        self.agents = dict()
        self.agent_names = dict()
        # create boundary patch
        xmin = -0.5
        ymin = -0.5
        xmax = map["map"]["dimensions"][0] - 0.5
        ymax = map["map"]["dimensions"][1] - 0.5

        # self.ax.relim()
        plt.xlim(xmin, xmax)
        plt.ylim(ymin, ymax)
        # self.ax.set_xticks([])
        # self.ax.set_yticks([])
        # plt.axis('off')
        # self.ax.axis('tight')
        # self.ax.axis('off')

        self.patches.append(
            Rectangle((xmin, ymin),
                      xmax - xmin,
                      ymax - ymin,
                      facecolor='none',
                      edgecolor='red'))
        for o in map["map"]["obstacles"]:
            x, y = o[0], o[1]
            self.patches.append(
                Rectangle((x - 0.5, y - 0.5),
                          1,
                          1,
                          facecolor='red',
                          edgecolor='red'))

        # create agents:
        self.T = 0
        # draw goals first
        for d, i in zip(map["agents"], range(0, len(map["agents"]))):
            if "goal" in d:
                goals = [d["goal"]]
            if "potentialGoals" in d:
                goals = [goal for goal in d["potentialGoals"]]
            for goal in goals:
                self.patches.append(
                    Rectangle((goal[0] - 0.25, goal[1] - 0.25),
                              0.5,
                              0.5,
                              facecolor=Colors[i % len(Colors)],
                              edgecolor='black',
                              alpha=0.5))

        for d, i in zip(map["agents"], range(0, len(map["agents"]))):
            name = d["name"]
            self.agents[name] = Circle((d["start"][0], d["start"][1]),
                                       0.3,
                                       facecolor=Colors[i % len(Colors)],
                                       edgecolor='black')
            self.agents[name].original_face_color = Colors[i % len(Colors)]
            self.patches.append(self.agents[name])
            self.T = max(self.T, schedule["schedule"][name][-1]["t"])
            self.agent_names[name] = self.ax.text(d["start"][0], d["start"][1],
                                                  name.replace('agent', ''))
            self.agent_names[name].set_horizontalalignment('center')
            self.agent_names[name].set_verticalalignment('center')
            self.artists.append(self.agent_names[name])

        # self.ax.set_axis_off()
        # self.fig.axes[0].set_visible(False)
        # self.fig.axes.get_yaxis().set_visible(False)

        # self.fig.tight_layout()

        self.anim = animation.FuncAnimation(self.fig,
                                            self.animate_func,
                                            init_func=self.init_func,
                                            frames=int(self.T + 1) * 10,
                                            interval=100,
                                            blit=True)
    def circles(self, x, y, s, c='b', vmin=None, vmax=None, **kwargs):
        """
        See https://gist.github.com/syrte/592a062c562cd2a98a83 

        Make a scatter plot of circles. 
        Similar to plt.scatter, but the size of circles are in data scale.
        Parameters
        ----------
        x, y : scalar or array_like, shape (n, )
            Input data
        s : scalar or array_like, shape (n, ) 
            Radius of circles.
        c : color or sequence of color, optional, default : 'b'
            `c` can be a single color format string, or a sequence of color
            specifications of length `N`, or a sequence of `N` numbers to be
            mapped to colors using the `cmap` and `norm` specified via kwargs.
            Note that `c` should not be a single numeric RGB or RGBA sequence 
            because that is indistinguishable from an array of values
            to be colormapped. (If you insist, use `color` instead.)  
            `c` can be a 2-D array in which the rows are RGB or RGBA, however. 
        vmin, vmax : scalar, optional, default: None
            `vmin` and `vmax` are used in conjunction with `norm` to normalize
            luminance data.  If either are `None`, the min and max of the
            color array is used.
        kwargs : `~matplotlib.collections.Collection` properties
            Eg. alpha, edgecolor(ec), facecolor(fc), linewidth(lw), linestyle(ls), 
            norm, cmap, transform, etc.
        Returns
        -------
        paths : `~matplotlib.collections.PathCollection`
        Examples
        --------
        a = np.arange(11)
        circles(a, a, s=a*0.2, c=a, alpha=0.5, ec='none')
        plt.colorbar()
        License
        --------
        This code is under [The BSD 3-Clause License]
        (http://opensource.org/licenses/BSD-3-Clause)
        """

        if np.isscalar(c):
            kwargs.setdefault('color', c)
            c = None

        if 'fc' in kwargs:
            kwargs.setdefault('facecolor', kwargs.pop('fc'))
        if 'ec' in kwargs:
            kwargs.setdefault('edgecolor', kwargs.pop('ec'))
        if 'ls' in kwargs:
            kwargs.setdefault('linestyle', kwargs.pop('ls'))
        if 'lw' in kwargs:
            kwargs.setdefault('linewidth', kwargs.pop('lw'))
        # You can set `facecolor` with an array for each patch,
        # while you can only set `facecolors` with a value for all.

        zipped = np.broadcast(x, y, s)
        patches = [Circle((x_, y_), s_) for x_, y_, s_ in zipped]
        collection = PatchCollection(patches, **kwargs)
        if c is not None:
            c = np.broadcast_to(c, zipped.shape).ravel()
            collection.set_array(c)
            collection.set_clim(vmin, vmax)

        ax = plt.gca()
        ax.add_collection(collection)
        ax.autoscale_view()
        # plt.draw_if_interactive()
        if c is not None:
            plt.sci(collection)
Exemple #33
0
def extract_minutiae_cylinder(img_input,
                              minutiae_input,
                              ROI=None,
                              num_ori=12,
                              angle=None,
                              processing=None):
    # for the latent or the low quality rolled print
    minutiae = minutiae_input.copy()
    img = img_input.copy()
    if processing == 'STFT':
        img = LP.STFT(img)
    elif processing == 'contrast':
        img = LP.local_constrast_enhancement(img)
    elif processing == 'texture':
        img = LP.FastCartoonTexture(img)
    sigma = 5**2
    if ROI is not None:
        h, w = ROI.shape
        for i in range(h):
            for j in range(w):
                if ROI[i, j] == 0:
                    img[i, j] = 255

        h, w = ROI.shape
        col_sum = np.sum(ROI, axis=0)

        ind = [x for x in range(len(col_sum)) if col_sum[x] > 0]
        min_x = np.max([np.min(ind) - 32, 0])
        max_x = np.min([np.max(ind) + 32, w])

        row_sum = np.sum(ROI, axis=1)

        ind = [x for x in range(len(row_sum)) if row_sum[x] > 0]
        min_y = np.max([np.min(ind) - 32, 0])
        max_y = np.min([np.max(ind) + 32, h])

        ROI = ROI[min_y:max_y, min_x:max_x]
        img = img[min_y:max_y, min_x:max_x]
        minutiae[:, 0] = minutiae[:, 0] - min_x
        minutiae[:, 1] = minutiae[:, 1] - min_y
    else:
        h, w = img.shape[0:2]
        ROI = np.ones((h, w))

    # rotate the image and ROI, and also update minutiae points
    h0, w0 = ROI.shape
    if angle is not None:
        h02 = (h0 + 1) / 2
        w02 = (w0 + 1) / 2

        img = rotate(img, angle)
        ROI = rotate(ROI, angle)

        h, w = ROI.shape
        h2 = (h + 1) / 2
        w2 = (w + 1) / 2

        angle = -angle / 180.0 * math.pi
        cosTheta = math.cos(angle)
        sinTheta = math.sin(angle)
        xx = (minutiae[:, 0] - w02) * cosTheta - (minutiae[:, 1] -
                                                  h02) * sinTheta + w2

        yy = (minutiae[:, 0] - w02) * sinTheta + (minutiae[:, 1] -
                                                  h02) * cosTheta + h2
        ori = minutiae[:, 2] - angle
        #
        minutiae[:, 0] = xx
        minutiae[:, 1] = yy
        minutiae[:, 2] = ori
        show = 0
        if show:
            minu_num = minutiae.shape[0]
            fig, ax = plt.subplots(1)
            ax.set_aspect('equal')

            R = 10
            arrow_len = 15
            ax.imshow(img, cmap='gray')
            for i in range(0, minu_num):
                xx = minutiae[i, 0]
                yy = minutiae[i, 1]
                circ = Circle((xx, yy), R, color='r', fill=False)
                ax.add_patch(circ)

                ori = -minutiae[i, 2]
                dx = math.cos(ori) * arrow_len
                dy = math.sin(ori) * arrow_len
                ax.arrow(xx,
                         yy,
                         dx,
                         dy,
                         head_width=0.05,
                         head_length=0.1,
                         fc='r',
                         ec='r')
            plt.show()
    h, w = ROI.shape
    minutiae_cylinder = np.zeros((h, w, num_ori), dtype=float)
    cylinder_ori = np.asarray(range(num_ori)) * math.pi * 2 / num_ori

    Y, X = np.mgrid[0:h, 0:w]
    minu_num = minutiae.shape[0]
    for i in range(0, minu_num):
        xx = minutiae[i, 0]
        yy = minutiae[i, 1]
        if yy < 0 or xx < 0:
            continue
            print xx, yy
            minu_num = minutiae.shape[0]
            fig, ax = plt.subplots(1)
            ax.set_aspect('equal')

            R = 10
            arrow_len = 15
            ax.imshow(img, cmap='gray')
            for i in range(0, minu_num):
                xx = minutiae[i, 0]
                yy = minutiae[i, 1]
                circ = Circle((xx, yy), R, color='r', fill=False)
                ax.add_patch(circ)

                ori = -minutiae[i, 2]
                dx = math.cos(ori) * arrow_len
                dy = math.sin(ori) * arrow_len
                ax.arrow(xx,
                         yy,
                         dx,
                         dy,
                         head_width=0.05,
                         head_length=0.1,
                         fc='r',
                         ec='r')
            plt.show()
        weight = np.exp(-((X - xx) * (X - xx) + (Y - yy) * (Y - yy)) / sigma)

        ori = minutiae[i, 2]
        if ori < 0:
            ori += np.pi * 2
        if ori > np.pi * 2:
            ori -= np.pi * 2

        for j in range(num_ori):

            ori_diff = np.fabs(ori - cylinder_ori[j])

            if ori_diff > np.pi * 2:
                ori_diff = ori_diff - np.pi * 2

            ori_diff = np.min([ori_diff, np.pi * 2 - ori_diff])
            minutiae_cylinder[:, :,
                              j] += weight * np.exp(-ori_diff / np.pi * 6)
    show = 0
    if show:
        fig, ax = plt.subplots(1)
        ax.set_aspect('equal')

        R = 10
        arrow_len = 15
        ax.imshow(img, cmap='gray')
        for i in range(0, minu_num):
            xx = minutiae[i, 0]
            yy = minutiae[i, 1]
            circ = Circle((xx, yy), R, color='r', fill=False)
            ax.add_patch(circ)

            ori = -minutiae[i, 2]
            dx = math.cos(ori) * arrow_len
            dy = math.sin(ori) * arrow_len
            ax.arrow(xx,
                     yy,
                     dx,
                     dy,
                     head_width=0.05,
                     head_length=0.1,
                     fc='r',
                     ec='r')
        plt.show()

    return img, ROI, minutiae_cylinder
def circleFromRMS(xy, rad):
	cir = Circle(xy, rad)
	cir.set_clip_box(ax.bbox)
	cir.set_alpha(0.2)
	cir.set_facecolor(tableau20[0])
	return cir
Exemple #35
0
class CircleSpanSelector:
    """
    Select a center/radius range of the circle for a matplotlib Axes

    Example usage:

      ax = subplot(111)
      ax.plot(x,y)

      def onselect(center, radius, x, y):
          print center, radius
      span = CircleSpanSelector(ax, onselect)
    """
   
    def __init__(self, ax, onselect, minspan=None, useblit=False, circprops=None):
	""" 

        Create a span selector in ax.  When a selection is made, clear
        the span and call onselect with

          onselect(center, radius, x, y) 
	
	where x and y are the coordinate used to calculate the radius
        and clear the span.

        If minspan is not None, ignore events smaller than minspan

        The span rect is drawn with rectprops; default
          circprops = dict(fc='blue', alpha=0.5)

        set the visible attribute to False if you want to turn off
        the functionality of the span selector


        """
        if circprops is None:
            circprops = dict(fc='w', alpha=0.5)        
            
        self.ax = ax
        self.visible = True
        self.canvas = ax.figure.canvas
        self.canvas.mpl_connect('motion_notify_event', self.onmove)
        self.canvas.mpl_connect('button_press_event', self.press)
        self.canvas.mpl_connect('button_release_event', self.release)
        self.canvas.mpl_connect('draw_event', self.update_background)

        self.circ = None
        self.background = None

        self.circprops = circprops
        self.onselect = onselect
        self.useblit = useblit
        self.minspan = minspan

        self.circ = Circle( (0,0), 1, **self.circprops)
        
	self.unit_verts = [v for v in self.circ.verts]
	self.circ.set_visible(False)

        if not self.useblit: self.ax.add_patch(self.circ)
        self.pressx = None
        
    def update_background(self, event):
        'force an update of the background'
        if self.useblit:
            self.background = self.canvas.copy_from_bbox(self.ax.bbox)

        
    def ignore(self, event):
        'return True if event should be ignored'
        return  event.inaxes!=self.ax or not self.visible or event.button !=1 


    def press(self, event):
        'on button press event'
        if self.ignore(event): return
        
	print "press"
        self.circ.set_visible(self.visible)
        self.pressx = event.xdata
        self.pressy = event.ydata
	self.circ.set_visible(False)

        return False


    def release(self, event):
        'on button release event'
        if self.pressx is None or self.ignore(event): return
        if self.pressy is None or self.ignore(event): return

        self.canvas.draw()
	self.center = [self.pressx, self.pressy]
	self.radius = sqrt((event.xdata-self.center[0])**2 + (event.ydata-self.center[1])**2)
	y = event.ydata
	x = event.xdata
        if self.minspan is not None and radius<self.minspan: return
        self.onselect(self.center, self.radius, x, y)
        self.pressx = None
	self.pressy = None
        return False

    def update(self):
        'draw using newfangled blit or oldfangled draw depending on useblit'
        if self.useblit:
            if self.background is not None:
                self.canvas.restore_region(self.background)
            self.ax.draw_artist(self.circ)
            self.canvas.blit(self.ax.bbox)
        else:
            self.canvas.draw_idle()

        return False

    def onmove(self, event):
        'on motion notify event'
        if self.pressx is None or self.ignore(event): return
        if self.pressy is None or self.ignore(event): return

        self.center = [self.pressx,self.pressy]
	self.radius = sqrt((event.xdata-self.center[0])**2 + (event.ydata-self.center[1])**2)
	if self.radius > 0.5:
	    self.circ.set_visible(True)
	else:
	    self.circ.set_visible(False)
        self.circ.verts = [(v[0]*self.radius+self.center[0],v[1]*self.radius+self.center[1]) for v in self.unit_verts]
	pylab.draw()

        self.update()
        return False
Exemple #36
0
    min = tf.math.reduce_min(prediction)
    fps = 1 / (end_time - start_time)
    # prediction = prediction > 0.5
    print(f"{image_file_name} MIN = {min}, MAX = {max}, FPS = {fps:.2f}")

    fig, axes = plt.subplots(
        4, 5, figsize=(16, 16))  # the number of images in the grid is 5*5 (25)
    threshold = 0.5

    for i, ax in enumerate(axes.flat):
        if i == prediction.shape[0]:
            break
        show_img = np.zeros((64, 64))
        ax.imshow(prediction[i], cmap='gray', vmin=0, vmax=1)
        # ax.imshow(img[0])
        cx, cy = np.unravel_index(prediction[i].argmax(), prediction[i].shape)
        if prediction[i, cx, cy] > threshold:
            patches = [Circle((cy, cx), radius=1, color='red')]
            for p in patches:
                ax.add_patch(p)
        ax.set_title(labels[i])
    ax.imshow(img[0])
    plt.subplots_adjust(left=0,
                        bottom=0,
                        right=1,
                        top=0.97,
                        wspace=0,
                        hspace=0.25)
    plt.show()

    pass
Exemple #37
0
    def _add_patches(self, df, method, fill, ax, diagonal=True):
        width, height = df.shape

        patches = []
        colors = []
        for x in range(width):
            for y in range(height):
                if fill == 'lower' and x > y:
                    continue
                elif fill == 'upper' and x < y:
                    continue
                if diagonal is False and x == y:
                    continue
                datum = (df.ix[x, y] + 1.) / 2.
                d = df.ix[x, y]
                d_abs = np.abs(d)
                #c = self.pvalues[x, y]
                rotate = -45 if d > 0 else +45
                #cmap = self.poscm if d >= 0 else self.negcm
                if method in ['ellipse', 'square', 'rectangle', 'color']:
                    if method == 'ellipse':
                        func = Ellipse
                        patch = func((x, y), width=1 * self.shrink,
                                     height=(self.shrink - d_abs * self.shrink), angle=rotate)
                    else:
                        func = Rectangle
                        w = h = d_abs * self.shrink
                        # FIXME shring must be <=1
                        offset = (1 - w) / 2.
                        if method == 'color':
                            w = 1
                            h = 1
                            offset = 0
                        patch = func((x + offset - .5, y + offset - .5), width=w,
                                     height=h, angle=0)
                    if self.edgecolor:
                        patch.set_edgecolor(self.edgecolor)
                    # patch.set_facecolor(cmap(d_abs))
                    colors.append(datum)
                    if d_abs > 0.05:
                        patch.set_linestyle('dotted')
                    # ax.add_artist(patch)
                    patches.append(patch)
                    # FIXME edgecolor is always printed
                elif method == 'circle':
                    patch = Circle((x, y), radius=d_abs * self.shrink / 2.)
                    if self.edgecolor:
                        patch.set_edgecolor(self.edgecolor)
                    # patch.set_facecolor(cmap(d_abs))
                    colors.append(datum)
                    if d_abs > 0.05:
                        patch.set_linestyle('dotted')
                    # ax.add_artist(patch)
                    patches.append(patch)
                elif method in ['number', 'text']:
                    if d < 0:
                        edgecolor = self.cm(-1.0)
                    elif d >= 0:
                        edgecolor = self.cm(1.0)
                    d_str = "{:.2f}".format(d).replace(
                        "0.", ".").replace(".00", "")
                    ax.text(x, y, d_str, color=edgecolor,
                            fontsize=self.fontsize, horizontalalignment='center',
                            weight='bold', alpha=max(0.5, d_abs),
                            withdash=False)
                elif method == 'pie':
                    S = 360 * d_abs
                    patch = [
                        Wedge((x, y), 1 * self.shrink / 2., -90, S - 90),
                        Wedge((x, y), 1 * self.shrink / 2., S - 90, 360 - 90),
                    ]
                    # patch[0].set_facecolor(cmap(d_abs))
                    # patch[1].set_facecolor('white')
                    colors.append(datum)
                    colors.append(0.5)
                    if self.edgecolor:
                        patch[0].set_edgecolor(self.edgecolor)
                        patch[1].set_edgecolor(self.edgecolor)

                    # ax.add_artist(patch[0])
                    # ax.add_artist(patch[1])
                    patches.append(patch[0])
                    patches.append(patch[1])
                else:
                    raise ValueError(
                        'Method for the symbols is not known. Use e.g, square, circle')

        if self.binarise_color:
            colors = [1 if color > 0.5 else -1 for color in colors]

        if len(patches):
            col1 = PatchCollection(
                patches, array=np.array(colors), cmap=self.cm)
            ax.add_collection(col1)

            self.collection = col1
Exemple #38
0
if __name__ == "__main__":

    import matplotlib.pyplot as plt

    ax = plt.gca()
    ax.set_aspect(1.)

    at = AnchoredText("Figure 1a",
                      loc=2, frameon=True)
    at.patch.set_boxstyle("round,pad=0.,rounding_size=0.2")
    ax.add_artist(at)

    from matplotlib.patches import Circle
    ada = AnchoredDrawingArea(20, 20, 0, 0,
                              loc=1, pad=0., frameon=False)
    p = Circle((10, 10), 10)
    ada.da.add_artist(p)
    ax.add_artist(ada)

    # draw an ellipse of width=0.1, height=0.15 in the data coordinate
    ae = AnchoredEllipse(ax.transData, width=0.1, height=0.15, angle=0.,
                         loc=3, pad=0.5, borderpad=0.4, frameon=True)

    ax.add_artist(ae)

    # draw a horizontal bar with length of 0.1 in Data coordinate
    # (ax.transData) with a label underneath.
    asb = AnchoredSizeBar(ax.transData,
                          0.1,
                          r"1$^{\prime}$",
                          loc=8,
Exemple #39
0
    def __init__(self,
                 subarray,
                 axes=None,
                 autoupdate=True,
                 tel_scale=2.0,
                 alpha=0.7,
                 title=None,
                 radius=None,
                 frame=GroundFrame()):

        self.frame = frame
        self.subarray = subarray

        # get the telescope positions. If a new frame is set, this will
        # transform to the new frame.
        self.tel_coords = subarray.tel_coords.transform_to(frame)

        # set up colors per telescope type
        tel_types = [str(tel) for tel in subarray.tels.values()]
        if radius is None:
            # set radius to the mirror radius (so big tels appear big)
            radius = [
                np.sqrt(tel.optics.mirror_area.to("m2").value) * tel_scale
                for tel in subarray.tel.values()
            ]

        if title is None:
            title = subarray.name

        # get default matplotlib color cycle (depends on the current style)
        color_cycle = cycle(plt.rcParams['axes.prop_cycle'].by_key()['color'])

        # map a color to each telescope type:
        tel_type_to_color = {}
        for tel_type in list(set(tel_types)):
            tel_type_to_color[tel_type] = next(color_cycle)

        tel_color = [tel_type_to_color[ttype] for ttype in tel_types]

        patches = []
        for x, y, r, c in zip(list(self.tel_coords.x.value),
                              list(self.tel_coords.y.value), list(radius),
                              tel_color):
            patches.append(
                Circle(
                    xy=(x, y),
                    radius=r,
                    fill=True,
                    color=c,
                    alpha=alpha,
                ))

        # build the legend:
        legend_elements = []
        for ttype in list(set(tel_types)):
            color = tel_type_to_color[ttype]
            legend_elements.append(
                Line2D([0], [0],
                       marker='o',
                       color=color,
                       label=ttype,
                       markersize=10,
                       alpha=alpha,
                       linewidth=0))
        plt.legend(handles=legend_elements)

        self.tel_colors = tel_color
        self.autoupdate = autoupdate
        self.telescopes = PatchCollection(patches, match_original=True)
        self.telescopes.set_linewidth(2.0)

        self.axes = axes or plt.gca()
        self.axes.add_collection(self.telescopes)
        self.axes.set_aspect(1.0)
        self.axes.set_title(title)
        self._labels = []
        self._quiver = None
        self.axes.autoscale_view()
Exemple #40
0
def example():
  
  
  #--------------------------------#
  # Parameters
  #--------------------------------#
  
  # Simulation
  wl = 400.
  k = 2*pi/wl
  
  w = 200
  h = 800
  
  m = 1
  n = 2
  
  # Plotting
  res = 500
  xmax = 800
  
  Ro = 1. #distance to measure field (m)
  angle_res = 100

  
  #--------------------------------#
  
  
  
  # Algorithm
  
  dipoles = getDipoles(m,n,w,h)
  
  xs = ys = np.linspace(-xmax,xmax,res)
  
  X,Y = np.meshgrid(xs,ys)
  
  for di,d in enumerate(dipoles):
        
    R = getR(d[0],d[1],X,Y)
    
    phi = pi*(getPhase(m,n,di))
    
    if di==0: Fz  = 1/R*exp(1j*(k*R + phi))
    else:     Fz += 1/R*exp(1j*(k*R + phi))
  
  
  # Plot Real Field
  fig = plt.figure()
  ax  = fig.add_subplot(111)

  Fz *= -1  #flip values so plot color matches dipole color
  Fz /= np.amax(abs(Fz))

  scale = 0.01
  
  im = ax.imshow(Fz.real,extent=putil.getExtent(xs,ys),vmax=scale,vmin=-1*scale,cmap='RdBu')
  fig.colorbar(im)
  
  drawDipoleBox(m,n,w,h,ax)
  
  for di,d in enumerate(dipoles):
    
    p = getPhase(m,n,di)
    ax.add_patch(Circle(d,15,facecolor=colors[p]))

  # Power plot
  fig = plt.figure()
  ax  = fig.add_subplot(111)

  P = abs(Fz)**2
  P /= np.amax(P)
  
  im = ax.imshow(P,extent=putil.getExtent(xs,ys),vmax=sqrt(scale),cmap='hot')
  fig.colorbar(im)
  
    
    
  # Plot Farfield
  ff_fig = plt.figure()
  ff_ax  = ff_fig.add_subplot(111,polar=True)
  ff_ax.grid(True)

  FFplot(ff_ax,wl,w,h,m,n,Ro=Ro,angle_res=angle_res)
  
  print getFF(wl,w,h,m,n,0)
    
  plt.show()
  
  return 0
Exemple #41
0
    for i in range(3):
        for j in range(n_col):
            ax = add_subplot(i, j, projection="3d")
            ax.axis("off")

    col1_axs = axs[:, :3]
    plot_neuron_morphology(
        label1_ids, label1_inputs, label1_outputs, col1_axs, row_label=True
    )
    col1_axs[0, 1].set_title(label1)

    legend_elements = []
    for ct in connection_types:
        p = Circle(
            (-1, -1), facecolor=connection_colors[ct], label=ct, linewidth=0, radius=1
        )
        legend_elements.append(p)
    col1_axs[2, 0].legend(
        handles=legend_elements, bbox_to_anchor=(0, 0), loc="upper left"
    )

    col2_axs = axs[:, 3:]
    plot_neuron_morphology(
        label2_ids, label2_inputs, label2_outputs, col2_axs, row_label=True
    )
    col2_axs[0, 1].set_title(label2)

    plt.tight_layout()

    stashfig(f"morpho-compare-{label1}_{label2}")
def add3Dcircle(x, y, z, r, color, axe, direction):
    #edgecolor="black"
    p = Circle((x, y), r, facecolor=color)
    axe.add_patch(p)
    art3d.pathpatch_2d_to_3d(p, z=z, zdir=direction)
Exemple #43
0
import matplotlib.cm as cm
import matplotlib.pyplot as plt
from matplotlib.patches import Circle, PathPatch
from matplotlib.path import Path
from matplotlib.transforms import Affine2D
import numpy as np

r = np.random.rand(50)
t = np.random.rand(50) * np.pi * 2.0
x = r * np.cos(t)
y = r * np.sin(t)

fig, ax = plt.subplots(figsize=(6, 6))
circle = Circle((0, 0),
                1,
                facecolor='none',
                edgecolor=(0, 0.8, 0.8),
                linewidth=3,
                alpha=0.5)
ax.add_patch(circle)

im = plt.imshow(np.random.random((100, 100)),
                origin='lower',
                cmap=cm.winter,
                interpolation='spline36',
                extent=([-1, 1, -1, 1]))
im.set_clip_path(circle)

plt.plot(x, y, 'o', color=(0.9, 0.9, 1.0), alpha=0.8)

# Dolphin from OpenClipart library by Andy Fitzsimon
#       <cc:License rdf:about="http://web.resource.org/cc/PublicDomain">
Exemple #44
0
def runSlices(opsimName,
              metadata,
              simdata,
              fields,
              bins,
              args,
              opsDb,
              verbose=False):
    # Set up the movie slicer.
    movieslicer = setupMovieSlicer(simdata, bins)
    # Set up formatting for output suffix.
    sliceformat = '%s0%dd' % ('%', int(np.log10(len(movieslicer))) + 1)
    # Get the telescope latitude info.
    lat_tele = Site(name='LSST').latitude_rad
    # Run through the movie slicer slicePoints and generate plots at each point.
    for i, ms in enumerate(movieslicer):
        t = time.time()
        slicenumber = sliceformat % (i)
        if verbose:
            print(slicenumber)
        # Set up metrics.
        if args.movieStepsize != 0:
            tstep = args.movieStepsize
        else:
            tstep = ms['slicePoint']['binRight'] - bins[i]
            if tstep > 1:
                tstep = 40. / 24. / 60. / 60.
        # Add simple view of time to plot label.
        times_from_start = ms['slicePoint']['binRight'] - (int(bins[0]) +
                                                           0.16 - 0.5)
        # Opsim years are 365 days (not 365.25)
        years = int(times_from_start / 365)
        days = times_from_start - years * 365
        plotlabel = 'Year %d Day %.4f' % (years, days)
        # Set up metrics.
        metricList, plotDictList = setupMetrics(
            opsimName,
            metadata,
            plotlabel=plotlabel,
            t0=ms['slicePoint']['binRight'],
            tStep=tstep,
            years=years,
            verbose=verbose)
        # Identify the subset of simdata in the movieslicer 'data slice'
        simdatasubset = simdata[ms['idxs']]
        # Set up opsim slicer on subset of simdata provided by movieslicer
        opslicer = slicers.OpsimFieldSlicer()
        # Set up metricBundles to combine metrics, plotdicts and slicer.
        bundles = []
        sqlconstraint = ''
        for metric, plotDict in zip(metricList, plotDictList):
            bundles.append(
                metricBundles.MetricBundle(metric,
                                           opslicer,
                                           constraint=sqlconstraint,
                                           metadata=metadata,
                                           runName=opsimName,
                                           plotDict=plotDict))
        # Remove (default) stackers from bundles, because we've already run them above on the original data.
        for mb in bundles:
            mb.stackerList = []
        bundledict = metricBundles.makeBundlesDictFromList(bundles)
        # Set up metricBundleGroup to handle metrics calculation + plotting
        bg = metricBundles.MetricBundleGroup(bundledict,
                                             opsDb,
                                             outDir=args.outDir,
                                             resultsDb=None,
                                             saveEarly=False)
        # 'Hack' bundleGroup to just go ahead and run the metrics, without querying the database.
        simData = simdatasubset
        bg.fieldData = fields
        bg.setCurrent(sqlconstraint)
        bg.runCurrent(constraint=sqlconstraint, simData=simData)
        # Plot data each metric, for this slice of the movie, adding slicenumber as a suffix for output plots.
        # Plotting here, rather than automatically via sliceMetric method because we're going to rotate the sky,
        #  and add extra legend info and figure text (for FilterColors metric).
        ph = plots.PlotHandler(outDir=args.outDir,
                               figformat='png',
                               dpi=72,
                               thumbnail=False,
                               savefig=False)
        obsnow = np.where(simdatasubset['observationStartMJD'] ==
                          simdatasubset['observationStartMJD'].max())[0]
        raCen = np.radians(
            np.mean(simdatasubset[obsnow]['observationStartLST']))
        # Calculate horizon location.
        horizonlon, horizonlat = addHorizon(lat_telescope=lat_tele)
        # Create the plot for each metric and save it (after some additional manipulation).
        for mb in bundles:
            ph.setMetricBundles([mb])
            fignum = ph.plot(plotFunc=plots.BaseSkyMap(),
                             plotDicts={'raCen': raCen})
            fig = plt.figure(fignum)
            ax = plt.gca()
            # Add horizon and zenith.
            plt.plot(horizonlon, horizonlat, 'k.', alpha=0.3, markersize=1.8)
            plt.plot(0, lat_tele, 'k+')
            # For the FilterColors metric, add some extra items.
            if mb.metric.name == 'FilterColors':
                # Add the time stamp info (plotlabel) with a fancybox.
                plt.figtext(0.75,
                            0.9,
                            '%s' % (plotlabel),
                            bbox=dict(boxstyle='Round, pad=0.7',
                                      fc='w',
                                      ec='k',
                                      alpha=0.5))
                # Add a legend for the filters.
                filterstacker = stackers.FilterColorStacker()
                for i, f in enumerate(['u', 'g', 'r', 'i', 'z', 'y']):
                    plt.figtext(0.92,
                                0.55 - i * 0.035,
                                f,
                                color=filterstacker.filter_rgb_map[f])
                # Add a moon.
                moonRA = np.radians(np.mean(simdatasubset[obsnow]['moonRA']))
                lon = -(moonRA - raCen - np.pi) % (np.pi * 2) - np.pi
                moonDec = np.radians(np.mean(simdatasubset[obsnow]['moonDec']))
                # Note that moonphase is 0-100 (translate to 0-1). 0=new.
                moonPhase = np.mean(simdatasubset[obsnow]['moonPhase']) / 100.
                alpha = np.max([moonPhase, 0.15])
                circle = Circle((lon, moonDec),
                                radius=0.05,
                                color='k',
                                alpha=alpha)
                ax.add_patch(circle)
                # Add some explanatory text.
                ecliptic = Line2D([], [], color='r', label="Ecliptic plane")
                galaxy = Line2D([], [], color='b', label="Galactic plane")
                horizon = Line2D([], [],
                                 color='k',
                                 alpha=0.3,
                                 label="20 deg elevation limit")
                moon = Line2D([], [],
                              color='k',
                              linestyle='',
                              marker='o',
                              markersize=8,
                              alpha=alpha,
                              label="\nMoon (Dark=Full)\n         (Light=New)")
                zenith = Line2D([], [],
                                color='k',
                                linestyle='',
                                marker='+',
                                markersize=5,
                                label="Zenith")
                plt.legend(
                    handles=[horizon, zenith, galaxy, ecliptic, moon],
                    loc=[0.1, -0.35],
                    ncol=3,
                    frameon=False,
                    title=
                    'Aitoff plot showing HA/Dec of simulated survey pointings',
                    numpoints=1,
                    fontsize='small')
            # Save figure.
            plt.savefig(os.path.join(
                args.outDir,
                mb.metric.name + '_' + slicenumber + '_SkyMap.png'),
                        format='png',
                        dpi=72)
            plt.close('all')
            dt, t = dtime(t)
            if verbose:
                print('Ran and plotted slice %s of movieslicer in %f s' %
                      (slicenumber, dt))
Exemple #45
0
    def add_danger(self, danger_id):
        """ Appends a new danger to the appropriate list of `env`, and updates
        the `env` view. The position at which the danger is placed is computed
        based on the rover's location and direction, but also where on the
        robot that particular danger-detection sensor is located. """
        
        """if danger_id == left_bumper:
            
        elif danger_id == right_bumper:
            
        elif danger_id == left_and_right_bumper:

        elif danger_id == front_left_cliff:

        elif danger_id == front_right_cliff:

        elif danger_id == left_cliff:

        elif danger_id == right_cliff:

        elif danger_id == white_tape_front_left:

        elif danger_id == white_tape_front_right:

        elif danger_id == white_tape_left:

        elif danger_id == white_tape_right:

        elif danger_id == left_wheel:

        elif danger_id == right_wheel:

        elif danger_id == middle_wheel:

        else:
            raise NotImplementedError()
        """


        # Find the danger location using `danger_angle` and `danger_distance`
        # TODO: maybe later
        # danger_loc = conv_radial(self, danger_theta, danger_r)

        # Plot
        if (1 <= danger_id <= 3): # Bumper range in OIStopID
            """ Adds a bump """
            c = Circle(self._loc, radius = 6.25)
            c.set_facecolor('0.65')  # grey
            c.set_edgecolor('black')
            c.set_zorder(zorders['bumps'])
            c.set_fill(True)
            self.view.add_artist(c)
            self.bumps.append(c)
            self.draw()
        elif (4 <= danger_id <= 7): # Cliff range in OIStopID
            """ Adds a cliff """
            c = Circle(self._loc, radius = 6.25)
            c.set_facecolor('0.65')  # grey
            c.set_edgecolor('black')
            c.set_zorder(zorders['cliffs'])
            c.set_fill(True)
            self.view.add_artist(c)
            self.cliffs.append(c)
            self.draw()
        elif (12 <= danger_id <= 14): # Drop range in OIStopID
            """ Adds a drop """
            c = Circle(self._loc, radius = 6.25)
            c.set_facecolor('0.65')  # grey
            c.set_edgecolor('black')
            c.set_zorder(zorders['drops'])
            c.set_fill(True)
            self.view.add_artist(c)
            self.drops.append(c)
            self.draw()
        elif (8 <= danger_id <= 11): # White tape range in OIStopID
            """ Adds tape """
            c = Circle(self._loc, radius = 6.25)
            c.set_facecolor('0.65')  # grey
            c.set_edgecolor('black')
            c.set_zorder(zorders['tape'])
            c.set_fill(True)
            self.view.add_artist(c)
            self.tape.append(c)
            self.draw()
        else:
            raise NotImplementedError()
            
        # The following is the temporary workaround:
        sys.stderr.write("danger found: " + str(danger_id)) # TODO: check to see if enum strig is a thing
Ex, Ey = np.zeros((ny, nx)), np.zeros((ny, nx))
potential = np.zeros((ny, nx))
fig = plotter.figure()
plot1 = fig.add_subplot(121)
plot2 = fig.add_subplot(122)
charge_colors = {True: '#aa0000', False: '#0000aa'}
for x, y in zip(xLocationsOnRing, yLocationsOnRing):
    littleChargedParticle = chargedParticle(np.array([x, y]), dq)
    ex, ey = littleChargedParticle.electricFieldforPlotting(X, Y)
    Ex += ex
    Ey += ey
    potential += littleChargedParticle.electricPotentialforPlotting(X, Y)
    plot1.add_artist(
        Circle(littleChargedParticle.location,
               0.01,
               color=charge_colors[littleChargedParticle.charge > 0]))
    plot2.add_artist(
        Circle(littleChargedParticle.location,
               0.01,
               color=charge_colors[littleChargedParticle.charge > 0]))
color = np.log(np.sqrt(Ex**2 + Ey**2))
plot1.streamplot(X,
                 Y,
                 Ex,
                 Ey,
                 color=color,
                 linewidth=1,
                 cmap=plotter.cm.inferno,
                 density=3,
                 arrowstyle='->',
Exemple #47
0
 def __init__(self, xy, *args, **kwargs):
     Circle.__init__(self, xy, *args, **kwargs)
        xy1, z1 = (y, z), x
    else:
        xy1, z1 = (x, y), z

    text_path = TextPath((0, 0), s, size=size, usetex=usetex)
    trans = Affine2D().rotate(angle).translate(xy1[0], xy1[1])

    p1 = PathPatch(trans.transform_path(text_path), **kwargs)
    ax.add_patch(p1)
    art3d.pathpatch_2d_to_3d(p1, z=z1, zdir=zdir)


fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

p = Circle((5, 5), 3)
ax.add_patch(p)
art3d.pathpatch_2d_to_3d(p, z=0, zdir="x")


text3d(ax, (4, -2, 0), "X-axis", zdir="z", size=.5, usetex=False,
       ec="none", fc="k")
text3d(ax, (12, 4, 0), "Y-axis", zdir="z", size=.5, usetex=False, angle=.5*3.14159,
       ec="none", fc="k")
text3d(ax, (12, 10, 4), "Z-axis", zdir="y", size=.5, usetex=False, angle=.5*3.14159,
       ec="none", fc="k")

text3d(ax, (1, 5, 0),
       r"$\displaystyle G_{\mu\nu} + \Lambda g_{\mu\nu} = \frac{8\pi G}{c^4} T_{\mu\nu}  $",
       zdir="z", size=1, usetex=True,
       ec="none", fc="k")

matplotlib.rcParams['lines.linewidth'] = 2


pyplot.axis([0, gridWidth, 0, gridHeight])
pyplot.grid(True)
# Setting the axis labels.
pyplot.xlabel('X Space')
pyplot.ylabel('Y Space')

#Give the plot a title
pyplot.title('Radius Search Plot Using Shapely (%d Points)' % (numberOfPoints)) 

# Draw the collision circle/boundary
cir = Circle((circleX, circleY), radius=circleRadius, fc='b')
cir.set_alpha(0.4)
pyplot.gca().add_patch(cir)


for idx, point in enumerate(pointList):
	style = 'go'
	iAlpha = 0.4
	if(idx in matchingPoints):
		style = 'ro'
		iAlpha = 1
	pyplot.plot(point[0], point[1], style, linewidth=1, markersize=3, alpha=iAlpha)


pyplot.savefig(os.getcwd()+'/'+str(filename))
Exemple #50
0
    if (label == -1):
        xcord0.append(xPt)
        ycord0.append(yPt)
    else:
        xcord1.append(xPt)
        ycord1.append(yPt)

fr.close()
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(xcord0, ycord0, marker='s', s=90)
ax.scatter(xcord1, ycord1, marker='o', s=50, c='red')
plt.title('Support Vectors Circled')
circle = Circle((4.6581910000000004, 3.507396),
                0.5,
                facecolor='none',
                edgecolor=(0, 0.8, 0.8),
                linewidth=3,
                alpha=0.5)
ax.add_patch(circle)
circle = Circle((3.4570959999999999, -0.082215999999999997),
                0.5,
                facecolor='none',
                edgecolor=(0, 0.8, 0.8),
                linewidth=3,
                alpha=0.5)
ax.add_patch(circle)
circle = Circle((6.0805730000000002, 0.41888599999999998),
                0.5,
                facecolor='none',
                edgecolor=(0, 0.8, 0.8),
                linewidth=3,
 def __init__(self, xy, label, fig):
     self.point = Circle( (xy[0], xy[1]), .25, figure=fig)
     self.label = label
     self.cidpress = self.point.figure.canvas.mpl_connect('button_press_event', self.onClick)
def create_predict_update_chart(box_bg='#CCCCCC',
                                arrow1='#88CCFF',
                                arrow2='#88FF88'):
    plt.figure(figsize=(3, 3), facecolor='w')
    ax = plt.axes((0, 0, 1, 1), xticks=[], yticks=[], frameon=False)
    #ax.set_xlim(0, 10)
    #ax.set_ylim(0, 10)

    pc = Circle((4, 5), 0.5, fc=box_bg)
    uc = Circle((6, 5), 0.5, fc=box_bg)
    ax.add_patch(pc)
    ax.add_patch(uc)

    plt.text(4, 5, "Predict\nStep", ha='center', va='center', fontsize=14)
    plt.text(6, 5, "Update\nStep", ha='center', va='center', fontsize=14)

    #btm
    ax.annotate('',
                xy=(4.1, 4.5),
                xycoords='data',
                xytext=(6, 4.5),
                textcoords='data',
                size=20,
                arrowprops=dict(arrowstyle="simple",
                                fc="0.6",
                                ec="none",
                                patchB=pc,
                                patchA=uc,
                                connectionstyle="arc3,rad=-0.5"))
    #top
    ax.annotate('',
                xy=(6, 5.5),
                xycoords='data',
                xytext=(4.1, 5.5),
                textcoords='data',
                size=20,
                arrowprops=dict(arrowstyle="simple",
                                fc="0.6",
                                ec="none",
                                patchB=uc,
                                patchA=pc,
                                connectionstyle="arc3,rad=-0.5"))

    ax.annotate('Measurement ($\mathbf{z_k}$)',
                xy=(6.3, 5.4),
                xycoords='data',
                xytext=(6, 6),
                textcoords='data',
                size=18,
                arrowprops=dict(arrowstyle="simple", fc="0.6", ec="none"))

    ax.annotate('',
                xy=(4.0, 3.5),
                xycoords='data',
                xytext=(4.0, 4.5),
                textcoords='data',
                size=18,
                arrowprops=dict(arrowstyle="simple", fc="0.6", ec="none"))

    ax.annotate('Initial\nConditions ($\mathbf{x_0}$)',
                xy=(4.0, 5.5),
                xycoords='data',
                xytext=(2.5, 6.5),
                textcoords='data',
                size=18,
                arrowprops=dict(arrowstyle="simple", fc="0.6", ec="none"))

    plt.text(4,
             3.4,
             'State Estimate ($\mathbf{\hat{x}_k}$)',
             ha='center',
             va='center',
             fontsize=18)
    plt.axis('equal')
def plot_job_history(jobs, interval='year'):
    """Plots the job history of the user from the given list of jobs.

    Args:
        jobs (list): A list of jobs with type IBMQjob.
        interval (str): Interval over which to examine.

    Returns:
        fig: A Matplotlib figure instance.
    """
    def get_date(job):
        """Returns a datetime object from a IBMQJob instance.

        Args:
            job (IBMQJob): A job.

        Returns:
            dt: A datetime object.
        """
        return datetime.datetime.strptime(job.creation_date(),
                                          '%Y-%m-%dT%H:%M:%S.%fZ')

    current_time = datetime.datetime.now()

    if interval == 'year':
        bins = [(current_time - datetime.timedelta(days=k * 365 / 12))
                for k in range(12)]
    elif interval == 'month':
        bins = [(current_time - datetime.timedelta(days=k)) for k in range(30)]
    elif interval == 'week':
        bins = [(current_time - datetime.timedelta(days=k)) for k in range(7)]

    binned_jobs = [0] * len(bins)

    if interval == 'year':
        for job in jobs:
            for ind, dat in enumerate(bins):
                date = get_date(job)
                if date.month == dat.month:
                    binned_jobs[ind] += 1
                    break
            else:
                continue
    else:
        for job in jobs:
            for ind, dat in enumerate(bins):
                date = get_date(job)
                if date.day == dat.day and date.month == dat.month:
                    binned_jobs[ind] += 1
                    break
            else:
                continue

    nz_bins = []
    nz_idx = []
    for ind, val in enumerate(binned_jobs):
        if val != 0:
            nz_idx.append(ind)
            nz_bins.append(val)

    total_jobs = sum(binned_jobs)

    colors = [
        '#003f5c', '#ffa600', '#374c80', '#ff764a', '#7a5195', '#ef5675',
        '#bc5090'
    ]

    if interval == 'year':
        labels = [
            '{}-{}'.format(str(bins[b].year)[2:], bins[b].month)
            for b in nz_idx
        ]
    else:
        labels = ['{}-{}'.format(bins[b].month, bins[b].day) for b in nz_idx]
    fig, ax = plt.subplots(1, 1, figsize=(5, 5))  # pylint: disable=invalid-name
    ax.pie(nz_bins[::-1],
           labels=labels,
           colors=colors,
           textprops={'fontsize': 14},
           rotatelabels=True,
           counterclock=False)
    ax.add_artist(Circle((0, 0), 0.7, color='white', zorder=1))
    ax.text(0,
            0,
            total_jobs,
            horizontalalignment='center',
            verticalalignment='center',
            fontsize=26)
    fig.tight_layout()
    return fig
Exemple #54
0
Z = loss(B0, B1, a=1, b=1.2, c=1, cx=cx, cy=cy)
# Z = np.where(Z<600,Z,np.NAN)

# Create a figure and a 3D Axes
fig = plt.figure(figsize=(4.2, 3.1))
ax = fig.add_subplot(111, projection='3d')
vmax = 800
ax.plot_surface(B0, B1, Z, alpha=0.7, cmap='coolwarm', vmax=vmax)
ax.set_xlabel("$\\beta_1$", labelpad=0)
ax.set_ylabel("$\\beta_2$", labelpad=0)
ax.set_zlim(0, 500)
ax.tick_params(axis='x', pad=0)
ax.tick_params(axis='y', pad=0)
ax.set_xlim(-w, w)
ax.set_ylim(-h, h)
safe = Circle(xy=(0, 0), radius=lmbda, color='grey')
ax.add_patch(safe)
art3d.pathpatch_2d_to_3d(safe, z=0)

ax.plot([cx], [cy], marker='x', markersize=10, color='black')

contr = ax.contour(B0,
                   B1,
                   Z,
                   levels=50,
                   linewidths=.5,
                   cmap='coolwarm',
                   zdir='z',
                   offset=0,
                   vmax=vmax)
Exemple #55
0
    def _add_patches(self, df, method, fill, ax, diagonal=True):

        from matplotlib.patches import Ellipse, Circle, Rectangle, Wedge
        from matplotlib.collections import PatchCollection

        width, height = df.shape

        patches = []
        colors = []
        for x in range(width):
            for y in range(height):
                if fill == 'lower' and x > y:
                    continue
                elif fill == 'upper' and x < y:
                    continue
                if diagonal is False and x == y:
                    continue
                datum = (df.ix[x, y] + 1.) / 2.
                d = df.ix[x, y]
                d_abs = np.abs(d)
                #c = self.pvalues[x, y]
                rotate = -45 if d > 0 else +45
                #cmap = self.poscm if d >= 0 else self.negcm
                if method in ['ellipse', 'square', 'rectangle', 'color']:
                    if method == 'ellipse':
                        func = Ellipse
                        patch = func(
                            (x, y),
                            width=1 * self.shrink,
                            height=(self.shrink - d_abs * self.shrink),
                            angle=rotate)
                    else:
                        func = Rectangle
                        w = h = d_abs * self.shrink
                        # FIXME shring must be <=1
                        offset = (1 - w) / 2.
                        if method == 'color':
                            w = 1
                            h = 1
                            offset = 0
                        patch = func((x + offset - .5, y + offset - .5),
                                     width=w,
                                     height=h,
                                     angle=0)
                    if self.edgecolor:
                        patch.set_edgecolor(self.edgecolor)
                    # patch.set_facecolor(cmap(d_abs))
                    colors.append(datum)
                    if d_abs > 0.05:
                        patch.set_linestyle('dotted')
                    # ax.add_artist(patch)
                    patches.append(patch)
                    # FIXME edgecolor is always printed
                elif method == 'circle':
                    patch = Circle((x, y), radius=d_abs * self.shrink / 2.)
                    if self.edgecolor:
                        patch.set_edgecolor(self.edgecolor)
                    # patch.set_facecolor(cmap(d_abs))
                    colors.append(datum)
                    if d_abs > 0.05:
                        patch.set_linestyle('dotted')
                    # ax.add_artist(patch)
                    patches.append(patch)
                elif method in ['number', 'text']:
                    if d < 0:
                        edgecolor = self.cm(-1.0)
                    elif d >= 0:
                        edgecolor = self.cm(1.0)
                    d_str = "{:.2f}".format(d).replace("0.",
                                                       ".").replace(".00", "")
                    ax.text(x,
                            y,
                            d_str,
                            color=edgecolor,
                            fontsize=self.fontsize,
                            horizontalalignment='center',
                            weight='bold',
                            alpha=max(0.5, d_abs),
                            withdash=False)
                elif method == 'pie':
                    S = 360 * d_abs
                    patch = [
                        Wedge((x, y), 1 * self.shrink / 2., -90, S - 90),
                        Wedge((x, y), 1 * self.shrink / 2., S - 90, 360 - 90),
                    ]
                    # patch[0].set_facecolor(cmap(d_abs))
                    # patch[1].set_facecolor('white')
                    colors.append(datum)
                    colors.append(0.5)
                    if self.edgecolor:
                        patch[0].set_edgecolor(self.edgecolor)
                        patch[1].set_edgecolor(self.edgecolor)

                    # ax.add_artist(patch[0])
                    # ax.add_artist(patch[1])
                    patches.append(patch[0])
                    patches.append(patch[1])
                else:
                    raise ValueError(
                        'Method for the symbols is not known. Use e.g, square, circle'
                    )

        if self.binarise_color:
            colors = [1 if color > 0.5 else -1 for color in colors]

        if len(patches):
            col1 = PatchCollection(patches,
                                   array=np.array(colors),
                                   cmap=self.cm)
            ax.add_collection(col1)

            self.collection = col1
Exemple #56
0
def plot_span_circle(fig: plt.Figure, ax: plt.Axes, R: PlanarTriangle,
                     P: Triangle, i: int) -> None:
    c, r = get_span_circle(R, P, i)
    circle = Circle(c, r, linestyle="--", fill=None)
    ax.add_patch(circle)
Exemple #57
0
    def __init__(self, instance, schedule, duration):

        with open(instance) as map_file:
            map_data = yaml.load(map_file, Loader=yaml.SafeLoader)

        aspect = (map_data["map"]["dimensions"][0] +
                  2) / (map_data["map"]["dimensions"][1] + 2)
        self.fig, self.ax = plt.subplots(frameon=False,
                                         figsize=(4 * aspect, 4))
        self.ax.set_aspect('equal')
        plt.axis('off')
        self.fig.subplots_adjust(left=0,
                                 right=1,
                                 bottom=0,
                                 top=1,
                                 wspace=None,
                                 hspace=None)

        xmin = -1
        ymin = -1
        xmax = map_data["map"]["dimensions"][0] + 1
        ymax = map_data["map"]["dimensions"][1] + 1

        plt.xlim(xmin, xmax)
        plt.ylim(ymin, ymax)

        for o in map_data["map"]["obstacles"]:
            self.ax.add_patch(
                Rectangle(o, 1.0, 1.0, facecolor='gray', alpha=0.5))
        for x in range(-1, map_data["map"]["dimensions"][0] + 1):
            self.ax.add_patch(
                Rectangle([x, -1], 1.0, 1.0, facecolor='gray', alpha=0.5))
            self.ax.add_patch(
                Rectangle([x, map_data["map"]["dimensions"][1]],
                          1.0,
                          1.0,
                          facecolor='gray',
                          alpha=0.5))
        for y in range(map_data["map"]["dimensions"][1]):
            self.ax.add_patch(
                Rectangle([-1, y], 1.0, 1.0, facecolor='gray', alpha=0.5))
            self.ax.add_patch(
                Rectangle([map_data["map"]["dimensions"][0], y],
                          1.0,
                          1.0,
                          facecolor='gray',
                          alpha=0.5))

        self.data = np.load(schedule)
        self.num_agents = len(map_data["agents"])
        self.dt = self.data[1, 0] - self.data[0, 0]
        self.colors = []
        self.robots = []
        for i in range(self.num_agents):
            # plot trajectory
            # line = self.ax.plot(self.data[:,1+i*4], self.data[:,1+i*4+1],alpha=0.5,linewidth=2,linestyle='dashed')
            line = self.ax.plot(self.data[0:0, 1 + i * 4],
                                self.data[0:0, 1 + i * 4 + 1],
                                alpha=0.5,
                                linewidth=2,
                                linestyle='dashed')
            color = line[0].get_color()
            self.colors.append(color)

            # plot start and goal
            start = np.array(map_data["agents"][i]["start"])
            goal = np.array(map_data["agents"][i]["goal"])
            self.robots.append(
                Circle(start + np.array([0.5, 0.5]),
                       0.15,
                       alpha=0.5,
                       color=color))
            self.ax.add_patch(self.robots[-1])
            self.ax.add_patch(
                Rectangle(goal + np.array([0.3, 0.3]),
                          0.4,
                          0.4,
                          alpha=0.5,
                          color=color))

        if duration < 0:
            duration = int(self.data[-1, 0])
        else:
            duration = int(duration)

        self.anim = animation.FuncAnimation(self.fig,
                                            self.animate_func,
                                            init_func=self.init_func,
                                            frames=duration * 10,
                                            interval=100,
                                            blit=True)
 def animate(self):
     if self.is_sim_mode == True:
         if MathsCalculations.CalcRange(
                 self, MathsCalculations.GetVelocity(self),
                 MathsCalculations.GetAngleOfProjection(self),
                 MathsCalculations.GetElevation(
                     self)) > MathsCalculations.CalcMaxHeight(
                         self, MathsCalculations.GetVelocity(self),
                         MathsCalculations.GetAngleOfProjection(self),
                         MathsCalculations.GetElevation(self)):
             limit = MathsCalculations.CalcRange(
                 self, MathsCalculations.GetVelocity(self),
                 MathsCalculations.GetAngleOfProjection(self),
                 MathsCalculations.GetElevation(self))
         else:
             limit = MathsCalculations.CalcMaxHeight(
                 self, MathsCalculations.GetVelocity(self),
                 MathsCalculations.GetAngleOfProjection(self),
                 MathsCalculations.GetElevation(self))
         try:
             self.cl = self.figure_sm.clf()
             self.ax = self.figure_sm.add_subplot()
             self.circle = Circle((0, 0), 0.3)
             self.ax.add_artist(self.circle)
             self.ax.set_xlim([0, limit + (limit * 0.1)])
             self.ax.set_ylim([0, limit + (limit * 0.1)])
             self.animation1 = animation.FuncAnimation(
                 self.figure_sm,
                 self.animate_loop_sm,
                 frames=np.arange(
                     0,
                     MathsCalculations.CalcTimeTaken(
                         self, float(self.veloinp_sm.text()),
                         float(self.anglespin_sm.text()),
                         float(self.elevinp_sm.text())), 0.01),
                 interval=10,
                 repeat=False)
             self.animation2 = animation.FuncAnimation(
                 self.figure_sm,
                 self.animate_trailloop_sm,
                 frames=np.arange(
                     0,
                     MathsCalculations.CalcTimeTaken(
                         self, float(self.veloinp_sm.text()),
                         float(self.anglespin_sm.text()),
                         float(self.elevinp_sm.text())), 0.01),
                 interval=10,
                 repeat=False)
             self.canvas_sm.draw()
         except:
             print("Error")
     else:
         try:
             self.cl = self.figure_qm.clf()
             self.ax = self.figure_qm.add_subplot()
             self.circle = Circle((0, 0), 0.5)
             self.ax.add_artist(self.circle)
             self.ax.set_xlim([0, limit] + (limit * 0.1))
             self.ax.set_ylim([0, limit] + (limit * 0.1))
             self.animation = animation.FuncAnimation(
                 self.figure_qm,
                 self.animate_loop_qm,
                 frames=np.arange(
                     0,
                     MathsCalculations.CalcTimeTaken(
                         self, float(self.veloinp_qm.text()),
                         float(self.angleinp_qm.text()),
                         float(self.elevinp_qm.text())), 0.01),
                 interval=10,
                 repeat=False)
             self.canvas_qm.draw()
         except:
             print("Error")
Exemple #59
0
               start_points=seed.T)
ax2.streamplot(x,
               z,
               Vx,
               Vz - u,
               color=color,
               linewidth=1,
               cmap='afmhot',
               density=5,
               arrowstyle='-|>',
               arrowsize=1.0,
               minlength=0.4,
               start_points=seed.T)
for ax in (ax1, ax2):
    # Add filled circle for sphere
    ax.add_patch(Circle((0, 0), a, color='C0', zorder=2))
    ax.set_xlabel('$x$')
    ax.set_ylabel('$z$')
    ax.set_aspect('equal')
    ax.set_xlim(-0.7 * xlim, 0.7 * xlim)
    ax.set_ylim(-0.7 * zlim, 0.7 * zlim)
fig.tight_layout()
fig.savefig('./figures/stokesFlowStream.pdf')
fig.show()
"""
Introduction to Python for Science & Engineering
by David J. Pine
Code last edited: 2018-09-15

Streamplot example using matplotlib
"""
Exemple #60
0
        data = np.array(data)
        xys = data[:, :2]
        sphere1s = data[:, 2:5]
        sphere2s = data[:, 5:8]
        point1s = data[:, 8:10]
        point2s = data[:, 10:12]

        color2 = '#d6191b'
        patches_circle = []
        for xy, sphere1, sphere2, point1, point2 in zip(
                xys, sphere1s, sphere2s, point1s, point2s):
            xc = xy[0] + sphere2[0] - sphere1[0]
            yc = xy[1] + sphere2[1] - sphere1[1]
            r = sqrt(sphere1[2] * sphere1[2] + sphere2[2] * sphere2[2])
            if invert_yaxis:
                circle = Circle((xc, -yc), r, color=color2)
                patches_circle.append(circle)
            else:
                circle = Circle((xc, yc), r, color=color2)
                patches_circle.append(circle)

            xc = xy[0] + point2[0] - sphere1[0]
            yc = xy[1] + point2[1] - sphere1[1]
            r = sphere1[2]
            if invert_yaxis:
                circle = Circle((xc, -yc), r, color=color2)
                patches_circle.append(circle)
            else:
                circle = Circle((xc, yc), r, color=color2)
                patches_circle.append(circle)