Exemplo n.º 1
0
def plot_Kiel_diagram(starl):
    """
    Plot Kiel diagram.
    """
    x = starl['temperature']
    y = starl['g']
    age = starl['age']/1e6
    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)
    
    cmap = pl.cm.spectral
    norm = pl.Normalize(age.min(), age.max())
    lc = LineCollection(segments, cmap=cmap,norm=norm)
    lc.set_array(age)
    lc.set_linewidth(3)
    pl.gca().add_collection(lc)
    pl.xlim(x.max(), x.min())
    pl.ylim(y.max(), y.min())
    pl.xlabel('Effective temperature [K]')
    pl.ylabel('log(surface gravity [cm s$^{-2}$]) [dex]')
    
    ax0 = pl.gca()
    ax1 = pl.mpl.colorbar.make_axes(ax0)[0]
    norm = pl.mpl.colors.Normalize(age.min(), age.max())
    cb1 = pl.mpl.colorbar.ColorbarBase(ax1, cmap=cmap,
                                   norm=norm,orientation='vertical')
    cb1.set_label('Age [Myr]')
    pl.axes(ax0)
Exemplo n.º 2
0
def hello():

    rtimes, rt, rp = np.loadtxt("data/data.txt").T
    rtimes = map(datetime.datetime.fromtimestamp, rtimes)
    rtimes = matplotlib.dates.date2num(rtimes)
    fig = Figure()
    axis = fig.add_subplot(1, 1, 1)
    axis.xaxis_date()
    fig.autofmt_xdate()

    forecast_list = []
    for fname in glob.glob("data/forecast.*.txt"):
        stamp = fname.split(".")[1]
        times, tempa = np.loadtxt(fname).T
        times = map(datetime.datetime.fromtimestamp, times)
        times = matplotlib.dates.date2num(times)

        points = np.array([times, tempa]).T.reshape(-1, 1, 2)
        segments = np.concatenate([points[:-1], points[1:]], axis=1)
        lc = LineCollection(segments, cmap=plt.get_cmap("jet"),
                            norm=plt.Normalize(0, 1))
        lc.set_array(np.linspace(0,1,len(times)))
        lc.set_linewidth(1)
        axis.add_collection(lc)

        axis.plot_date(times, tempa, "-", linewidth=0)

    axis.plot_date(rtimes, rt, "-",linewidth=1, color="black")

    canvas = FigureCanvas(fig)
    output = StringIO.StringIO()
    canvas.print_png(output)
    response = make_response(output.getvalue())
    response.mimetype = 'image/png'
    return response
Exemplo n.º 3
0
def show_mf_wave(**kwargs):
    ion()
    mjfile='data/mf_W1%s_W2%s_U%s_N%s_dmu%s.npy'%(kwargs.get('K1'),kwargs.get('K2'),kwargs.get('U'),kwargs.get('nsite'),kwargs.get('dmu'))
    pls=load(mjfile)
    ampl=(pls[:2]*pls[:2].conj()).real
    print 'Magnituede %s'%sum(ampl,axis=1)
    if ONSV:
        return
    #mjfile2='data/mf_W1%s_W2%s_U%s_N%s_dmu%s.npy'%(kwargs.get('K1'),kwargs.get('K2'),kwargs.get('U'),kwargs.get('nsite'),-kwargs.get('dmu'))
    #pls2=load(mjfile2)
    #overlap=(pls2[:2].dot(pls[:2].T.conj()))
    #print overlap
    #subplot(211)

    #plot(abs(ket_even.state))
    #ylim(0,0.5)
    #subplot(212)
    #plot(abs(ket_odd.state))
    #ylim(0,0.5)
    #pdb.set_trace()
    lw=2
    lc='r'
    nsite=pls.shape[1]
    for n in xrange(2):
        pln=ampl[n]
        ax=subplot(121+n)
        lc=LineCollection([[(i,0),(i,pln[i].item())] for i in xrange(nsite)])
        lc.set_linewidth(lw)
        ax.add_collection(lc)

        ax.autoscale()
        ax.margins(0.1)
    pdb.set_trace()
Exemplo n.º 4
0
def d3():
    rtimes, rt, rp = np.loadtxt("data/data.txt").T
    mask = np.logical_and(rtimes>1391000000, rtimes<1393000000)
    rtimes = rtimes[mask]
    rt = rt[mask]
    rtimes = map(datetime.datetime.fromtimestamp, rtimes)
    rtimes = matplotlib.dates.date2num(rtimes)
    fig, axis = plt.subplots()

    axis.xaxis_date()
    fig.autofmt_xdate()
    axis.plot_date(rtimes, rt, "-",linewidth=3, color="black")

    forecast_list = []
    for fname in glob.glob("data/forecast.1391*.txt"):
        stamp = fname.split(".")[1]
        times, tempa = np.loadtxt(fname).T
        times = map(datetime.datetime.fromtimestamp, times)
        times = matplotlib.dates.date2num(times)

        points = np.array([times, tempa]).T.reshape(-1, 1, 2)
        segments = np.concatenate([points[:-1], points[1:]], axis=1)
        lc = LineCollection(segments, cmap=plt.get_cmap("jet"),
                            norm=plt.Normalize(0, 1))
        lc.set_array(np.linspace(0,1,len(times)))
        lc.set_linewidth(1)
        axis.add_collection(lc)

        axis.plot_date(times, tempa, "-", linewidth=2)



    return fig_to_html(fig)
Exemplo n.º 5
0
    def test_characteristic(self):
        m, n = 100, 100

        # Compute characteristic.
        c = vel.characteristic(m, n, c0, v0, tau0, tau1, 0.6)

        # Compute velocity field.
        v = vel.velocity(m, n, c0, v0, tau0, tau1)

        # Convert to matrix.
        v = dh.funvec2img(v.vector().get_local(), m, n)

        # Plot velocity.
        fig = plt.figure()
        plt.imshow(v, cmap=cm.coolwarm)

        # Plot characteristic.
        y = np.linspace(0, m, m + 1).reshape(m + 1, 1)

        points = np.array([n * c, y]).T.reshape(-1, 1, 2)
        segments = np.concatenate([points[:-1], points[1:]], axis=1)

        lc = LineCollection(segments[:-1])
        lc.set_linewidth(2)
        plt.gca().add_collection(lc)
        plt.show()

        plt.close(fig)
Exemplo n.º 6
0
    def loadlines(self,
                  name,
                  curdir='beijingJson',
                  zorder=None,
                  linewidth=0.5,
                  color='k',
                  antialiased=1,
                  ax=None,
                  default_encoding='utf-8',
                  linestyle='-',
                  linesalpha=1):
        # get current axes instance (if none specified).
        filename = curdir + '/' + name + '.json'
        coords = json.load(codecs.open(filename, 'r', 'utf-8'))
        coords = self.projectcoords(coords)

        ax = ax or self._check_ax()
        # make LineCollections for each polygon.
        lines = LineCollection(coords, antialiaseds=(1, ))
        lines.set_color(color)
        lines.set_linewidth(linewidth)
        lines.set_linestyle(linestyle)
        lines.set_alpha(linesalpha)
        lines.set_label('_nolabel_')
        if zorder is not None:
            lines.set_zorder(zorder)
        ax.add_collection(lines)
        # set axes limits to fit map region.
        self.set_axes_limits(ax=ax)
        # clip boundaries to map limbs
        lines, c = self._cliplimb(ax, lines)
        self.__dict__[name] = coords
        return lines
Exemplo n.º 7
0
def show_bonds(bonds,start=None,lw=1,**kwargs):
    '''
    Display a collection of bonds.

    bonds:
        A <BondCollection> instance.
    start:
        the location of starting atoms.
    lw,**kwargs:
        line width of bonds and key word arguments for 

    *return*:
        None
    '''
    vdim=bonds.vdim #this bonds is a class bondcollection
    bvs=[]
    if start is None:
        start=zeros([bonds.N,vdim])
    elif ndim(start)==1:
        bvs=zip(start,bonds.bondvs+start)
    else:
        bvs=zip(start,bonds.bondvs+start)
    if vdim==1:
        bvs=[(append(start,[0]),append(end,[0])) for start,end in bvs]
    lc=LineCollection(bvs,**kwargs) #draw lines
    lc.set_linewidth(lw)
    ax=gca()
    ax.add_collection(lc)
    ax.autoscale()
    ax.margins(0.1)
Exemplo n.º 8
0
def hilbert_spectrum(time, frec, amp, config):
    x = time
    y = frec
    z = amp

    n = len(x)
    cmap = plt.get_cmap(config['color_map'])

    # norm = BoundaryNorm(np.linspace(z.min(), z.max(), 1000), cmap.N)
    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)
    norm = Normalize(vmin=0, vmax=1300)
    # norm = None

    lc = LineCollection(segments, cmap=cmap, norm=norm)
    lc.set_array(z)
    lc.set_linewidth(config['linewidth'])

    fig1, ax1 = plt.subplots()
    plt.gca().add_collection(lc)
    plt.xlim(x.min(), x.max())
    plt.ylim(y.min(), y.max())

    line = ax1.add_collection(lc)
    cbar = fig1.colorbar(line, ax=ax1, format='%1.0f')

    cbar.set_label(config['zlabel'], size=13)
    cbar.ax.tick_params(labelsize=12)
    cbar.set_ticks(list(np.arange(np.min(z), np.max(z), config['step_cbar'])))
    ax1.set_xlabel(config['xlabel'], fontsize=13)
    ax1.set_ylabel(config['ylabel'], fontsize=13)
    # ax1.set_ylim(config['ylim'][0], config['ylim'][1])
    ax1.tick_params(axis='both', labelsize=12)

    return fig1, ax1
Exemplo n.º 9
0
def plot_center(data_values, left_idx, right_idx, k):
    x_l = []
    y_l = []
    for i in range(left_idx, right_idx):
        x_c, y_c = center_slice(data_values[:, :, i], k)
        x_l.append(x_c)
        y_l.append(y_c)

    x = np.array(x_l)
    y = np.array(y_l)
    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)
    fig, ax = plt.subplots()
    # Create a continuous norm to map from data points to colors
    norm = plt.Normalize(0, len(x))
    lc = LineCollection(segments, cmap='cool', norm=plt.Normalize(0, 16))
    # Set the values used for colormapping
    lc.set_array(np.linspace(0, 20, len(x)))
    lc.set_linewidth(3)
    line = ax.add_collection(lc)
    fig.colorbar(line, ax=ax)
    ax.plot(x, y, c='white', alpha=0.001)
    ax.set_xlim(0, 15)
    ax.set_ylim(0, 15)
    ax.set_title(f'Brightness movement, coeff = {k}')
    plt.grid(True)
    # ax.autoscale()
    plt.show()
Exemplo n.º 10
0
def plot_spectrum(el,x=arange(2),offset=[0.,0.],ax=None,lw=3,**kwargs):
    '''
    Plot spectrum.

    el:
        the data.
    x:
        the lower and upper limit of x.
    offset:
        the displace of data.
    ax:
        the ax.
    '''
    N=len(el)
    if ax==None:
        ax=gca()
    #x=repeat([array(x)+offset[0]],N,axis=0).T
    x=array(x)+offset[0]
    el=el+offset[1]
    lc=LineCollection([[(x[0],el[i]),(x[1],el[i])] for i in xrange(N)],**kwargs)
    lc.set_linewidth(lw)
    #pl=ax.plot(x,concatenate([el[newaxis,...],el[newaxis,...]],axis=0))
    ax.add_collection(lc)
    ax.autoscale()
    ax.margins(0.1)
    #for i in xrange(N):
        #axhline(y=el[i],xmin=x[0],xmax=x[1])
    return ax
Exemplo n.º 11
0
def plot_transitions_w_strengths(Ex,Ey,Strain_start,Strain_end,pts,B_field=[0.,0.,0.],m0=True,m1=True,p1=True,ax=None,log_scale =False):
    
    Strain = Ex-Ey
    ExZero = (Ex+Ey)/2 
    EyZero = (Ex+Ey)/2 
    
    Strainarray = np.linspace(Strain_start,Strain_end,pts)

    trans_keys = []
    if m0:
        trans_keys.append('ms0')
    if m1:
        trans_keys.append('msm1')
    if p1:
        trans_keys.append('msp1')
        
    transitions = {}
    for key in trans_keys:
        transitions[key] = {}
        transitions[key]['strength'] = np.empty([6,pts])
        transitions[key]['freq'] = np.empty([6,pts])
        
    for ii in range(pts):
        slice_list = nvlevels.get_optical_transition_strengths_ExEy(ExZero+Strainarray[ii]/2,EyZero-Strainarray[ii]/2,B_field=B_field,
                    show_ms0_transitions=m0,show_m1_transitions=m1,show_p1_transitions=p1)
        
        for key in trans_keys:
            transitions[key]['strength'][:,ii] = slice_list[key]['strength']
            transitions[key]['freq'][:,ii] = slice_list[key]['freq']
            
    color_map_key = {'msp1' : 'Blues', 'msm1': 'Greens', 'ms0' : 'Reds'}

    if ax == None:
        fig = plt.figure(figsize = (8,6))

        ax = plt.subplot()

    for key in transitions:
        
        for ii in range(np.shape(transitions[key]['freq'])[0]):

            points = np.array([Strainarray, transitions[key]['freq'][ii,:]]).T.reshape(-1, 1, 2)
            segments = np.concatenate([points[:-1], points[1:]], axis=1)
            if not log_scale:
                lc = LineCollection(segments, cmap=plt.get_cmap(color_map_key[key]),norm=plt.Normalize(vmin=0,vmax=1))
                lc.set_array(transitions[key]['strength'][ii,:])
            else:
                lc = LineCollection(segments, cmap=plt.get_cmap(color_map_key[key]),norm=plt.Normalize(vmin=-3,vmax=0))
                transitions[key]['strength'][ii,(transitions[key]['strength'][ii,:] == 0)] = 1e-5
                lc.set_array(np.log10(transitions[key]['strength'][ii,:]))
            lc.set_linewidth(1)
            ax.add_collection(lc)

    plt.ylabel('Frequency (GHz)')
    plt.xlabel('Strain splitting (GHz)')

    ax.autoscale_view(True,True,True)
    
    plt.show()
    plt.close("all")
def display_conv_activations(model,sig):
    if len(sig.shape)==2:
        sig = sig.reshape(1,sig.shape[0],sig.shape[1])
    #get activations
    activations = keract.get_activations(model, sig)
    #get convolutional layers keys
    conv_keys = [key for key in activations.keys() if 'conv' in key]
    #prepare for plotting
    t = np.linspace(0, len(sig[0]),len(sig[0]))
    signal = sig[0].reshape(-1,)
    points = np.array([t, signal]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)
    #create fig and axs
    fig = plt.figure(figsize=(18,5))

    if len(conv_keys)>10:
        print('Warning: only the 10 last layers will be displayed')

    for i in range(1,min([11,len(conv_keys)])):
        ax = fig.add_subplot(2,5,i)
        key = conv_keys[-i]
        act = np.mean(activations[key][0],axis=1)
        # Create a continuous norm to map from data points to colors
        norm = plt.Normalize(act.min(), act.max())
        lc = LineCollection(segments, cmap='bwr', norm=norm)
        # Set the values used for colormapping
        lc.set_array(act)
        lc.set_linewidth(2)
        line = ax.add_collection(lc)
        fig.colorbar(line, ax=ax)
        ax.set_xlim(t.min(), t.max())
        ax.set_title(key)
    plt.tight_layout()
Exemplo n.º 13
0
def plot_multi_line(x, y, z, bins, colors, ax):
    """
    Plot a multi-color line.
    See: http://matplotlib.sourceforge.net/examples/
               pylab_examples/multicolored_line.html
    """

    from matplotlib.collections import LineCollection
    from matplotlib.colors import ListedColormap, BoundaryNorm

    # Allow specifying bin centers, not edges
    if len(bins) == len(colors):
        bins = np.array(bins, dtype=np.float)
        bins = np.concatenate([[z.min() - 1],
                               (bins[1:] + bins[:-1]) / 2.0,
                               [z.max() + 1]])

    cmap = ListedColormap(colors)
    norm = BoundaryNorm(bins, cmap.N)

    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    lc = LineCollection(segments, cmap=cmap, norm=norm)
    lc.set_array(z)
    lc.set_linewidth(3)
    ax.add_collection(lc)
def animate(i):
    global anim_running
    if not anim_running:
        return ax,
    ax.clear()
    s_t.set_val(t[i])
    anim_running = True
    # plot only tmin to t[i] when t < tbuf
    wpts = w[0:i]
    Ypts = Y[0:i]
    tpts = t[0:i]
    if i >= tbuff:
        # plot  from  t[i-tbuff] to t = t[i]
        wpts = w[i - tbuff:i]
        Ypts = Y[i - tbuff:i]
        tpts = t[i - tbuff:i]

    points = np.array([wpts, Ypts]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)
    lc = LineCollection(segments, cmap=hot2cold)
    lc.set_array(tpts)
    lc.set_linewidth(3)
    ax.add_collection(lc)
    ax.scatter(wpts, Ypts, s=3, c='r')
    ax.set_title("Goodwin model: wage and output trajectory")
    ax.set_xlabel('wage share, $w$')
    ax.set_ylabel('Output, $Y$')
    ax.set_xlim(0, wmax)
    ax.set_ylim(0, Ymax)
    return ax,
def display_conv_activations_transplant(model,sig,cols):
    """
    for transplant with 10 channels
    """

    #get activations
    sig = sig.reshape(1,sig.shape[0],sig.shape[1])
    activations = keract.get_activations(model, sig)
    conv_keys = [key for key in activations.keys() if 'conv' in key]
    #prepare for plotting
    t = np.linspace(0, len(sig[0]),len(sig[0]))
    #signal = sig[0].reshape(-1,)
    #create fig and axs
    fig = plt.figure(figsize=(14,5))
    key = conv_keys[-1] #last convolutional layer
    act = np.mean(activations[key][0],axis=1)
    # Create a continuous norm to map from data points to colors
    norm = plt.Normalize(act.min(), act.max())
    for i in range(1,11):

        signal = sig[0][:,i-1]
        points = np.array([t, signal]).T.reshape(-1, 1, 2)
        segments = np.concatenate([points[:-1], points[1:]], axis=1)
        ax = fig.add_subplot(2,5,i)
        lc = LineCollection(segments, cmap='bwr', norm=norm)
        # Set the values used for colormapping
        lc.set_array(act)
        lc.set_linewidth(2)
        line = ax.add_collection(lc)
        fig.colorbar(line, ax=ax)
        ax.set_xlim(t.min(), t.max())
        ax.set_ylim(signal.min(),signal.max())
        ax.set_title(cols[i-1],fontsize=13)

    plt.tight_layout()
Exemplo n.º 16
0
def multicolored_line(graph,
                      x,
                      y,
                      norm_color_value,
                      ax=None,
                      alpha=1.,
                      cmap='cool',
                      lw=2):

    if ax is None:
        fig, ax = graph.figure()
    else:
        fig = None

    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    # Create a continuous norm to map from data points to colors
    norm = plt.Normalize(norm_color_value.min(), norm_color_value.max())
    lc = LineCollection(segments, cmap=cmap, norm=norm)
    # Set the values used for colormapping
    lc.set_array(norm_color_value)
    lc.set_linewidth(lw)

    line = ax.add_collection(lc)
    return fig, ax, line
Exemplo n.º 17
0
def plot_prediction(session, model, title, data, x, y):
    global p
    preds = []
    for i in range(len(data)):
        p = session.run(model.f, {
            model.batch_size: 1,
            model.x: [data[:i + 1]]
        })[0]
        preds.append(np.argmax(p))

    x = x[1:]
    y = y[1:]
    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)
    fig, ax = plt.subplots()

    cmap = ListedColormap(['r', 'y', 'g'])
    norm = BoundaryNorm([(len(p) - 1) * i / len(p) for i in range(len(p) + 1)],
                        cmap.N)
    lc = LineCollection(segments, cmap=cmap, norm=norm)
    lc.set_array(np.array(preds))
    lc.set_linewidth(2)
    line = ax.add_collection(lc)
    fig.colorbar(line, ax=ax)
    ax.set_xlim(x.min(), x.max())
    ax.set_ylim(y.min(), y.max())

    plt.title(title)
    plt.xlabel("Day")
    plt.ylabel("Price")

    plt.show()
Exemplo n.º 18
0
def plot_indiv(points, ax, title, grid_size, tt, prey = False):
    
    
    ticks = np.arange(grid_size)
    norm = plt.Normalize(tt.min(), tt.max())
    
    if not (points == points[0]).all():
        points = points.reshape(-1, 1 , 2)
        
        # x is vertical
        points = np.flip(points, axis = 2)

        segments = np.concatenate([points[:-1], points[1:]], axis=1)
        if not prey:
            lc = LineCollection(segments, cmap = 'winter' ,norm=norm)
        else:
            lc = LineCollection(segments, cmap = 'autumn' ,norm=norm)
        lc.set_array(tt)
        lc.set_linewidth(10)
        line = ax.add_collection(lc)
        plt.colorbar(line, ax=ax)
    else:
        if not prey:
            ax.plot(points[0,1], points[0,0], 's', color = 'b', markersize = 10)
        else:
            ax.plot(points[0,1], points[0,0], 's', color = 'r', markersize = 10)
            
    ax.set_xlim(-1, grid_size)
    ax.set_ylim(grid_size, -1)
    ax.set_xticks(ticks)
    ax.set_yticks(ticks)
    ax.grid()
    ax.set_title(title)
Exemplo n.º 19
0
def plot_saliency_median(beispiel, grads):
    from matplotlib.collections import LineCollection
    from matplotlib.colors import ListedColormap, BoundaryNorm

    x = np.arange(0, 600)
    y = np.squeeze(beispiel[1:, :], 1)
    dydx = grads
    # Create a set of line segments so that we can color them individually
    # This creates the points as a N x 1 x 2 array so that we can stack points
    # together easily to get the segments. The segments array for line collection
    # needs to be (numlines) x (points per line) x 2 (for x and y)
    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    fig, axs = plt.subplots(figsize=(14, 7))
    # Create a continuous norm to map from data points to colors
    norm = plt.Normalize(dydx.min(), dydx.max())
    lc = LineCollection(segments, cmap='viridis', norm=norm)
    # Set the values used for colormapping
    lc.set_array(dydx)
    lc.set_linewidth(3)
    line = axs.add_collection(lc)
    fig.colorbar(line, ax=axs)

    axs.set_xlim(x.min(), x.max())
    axs.set_ylim(beispiel[1:, :].min() - 100, beispiel[1:, :].max() + 100)
    plt.show()
Exemplo n.º 20
0
def plotflow(nm,j,ylabel='Congestion Window Size',state=False):
  i=0

  if state and not isinstance(nm,list):
    r = (1,0,0)
    g = (0,1,0)
    b = (0,0,1)
    clrs = np.zeros((flows[nm][3].shape[0],3))
    clrs[flows[nm][-1]=='SS']=g
    clrs[flows[nm][-1]=='CA']=b
    clrs[flows[nm][-1]=='FR']=r
    points = np.array([flows[nm][i], flows[nm][j]]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    lc = LineCollection(segments, colors=clrs)
    lc.set_linewidth(1.7)
    fig, ax = plt.subplots()
    ax.add_collection(lc)
    ax.autoscale_view()

    line_ss = mlines.Line2D([], [], color='green', label='Slow Start')
    line_ca = mlines.Line2D([], [], color='blue', label='Congestion Avoidance')
    line_fr = mlines.Line2D([], [], color='red', label='Fast Recovery')
    plt.legend(handles=[line_ss,line_ca,line_fr])
  else:
    if isinstance(nm,list):
      for n in nm:
        if n in flows:
          plt.plot(flows[n][i],flows[n][j],label=n)
    else:
      plt.plot(flows[nm][i],flows[nm][j])
    plt.legend()
  plt.xlabel('time (s)')
  plt.ylabel(ylabel)
  plt.show()
def update(val):
    global scat
    Yeari = int(S_Year.val) - 1880
    ax.cla()
    r = NP[M * Yeari:M * (Yeari + 1)]

    points = PL.BuildPolyLine(r)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    # for same reason, we have faster update time if we create new lc
    # instead of set new segments
    # lc.set_segments(segments) #if you remove the comment add comments at the two next commands
    lc = LineCollection(segments,
                        cmap=plt.get_cmap('coolwarm'),
                        norm=plt.Normalize(np.min(NP), np.max(NP)))

    lc.set_linewidth(3)
    lc.set_array(PL.R)  # this is necessary

    ax.scatter(PL.Qthetta,
               r,
               s=50,
               c=r,
               cmap=plt.cm.coolwarm,
               vmin=ticks[0],
               vmax=ticks[-1])
    ax.add_collection(lc)
    ax.set_rticks(ticks)
    ax.set_yticklabels(tick_label)
    ax.set_rmax(np.max(NP) + 0.06)
    ax.set_rlabel_position(-22.5)
    ax.set_xticks(np.pi / 180. * np.linspace(0, 360, 12, endpoint=False))
    ax.set_xticklabels(Months)

    fig.canvas.draw_idle()
def plot_view(result):
    # Determine bounding box if no clipping boundary was supplied
    if not result['bbox']:
        result['bbox'] = bbox_of_view(result)

    ax = plt.subplot(111)
    # plt.box(on=None)
    m = Basemap(resolution='i',
                projection='merc',
                llcrnrlat=result['bbox']['ymin'],
                urcrnrlat=result['bbox']['ymax'],
                llcrnrlon=result['bbox']['xmin'],
                urcrnrlon=result['bbox']['xmax'],
                lat_ts=(result['bbox']['xmin'] +
                        result['bbox']['xmax']) / 2)
    m.drawcoastlines()

    try:
        for el in result['results']:
            vectors = get_vectors_from_postgis_map(m, loads(el['geom']))
            lines = LineCollection(vectors, antialiaseds=(1, ))
            lines.set_facecolors('black')
            lines.set_edgecolors('white')
            lines.set_linewidth(1)
            ax.add_collection(lines)
        m.fillcontinents(color='coral', lake_color='aqua')
    # If AttributeError assume geom_type 'Point', simply collect all
    # points and perform scatterplot
    except AttributeError:
        xy = m([loads(point['geom']).x for point in result['results']],
               [loads(point['geom']).y for point in result['results']])
        plt.scatter(xy[0], xy[1])

    plt.show()
Exemplo n.º 23
0
def add_china_map_2basemap(ax,name ="province", facecolor='none',
                           edgecolor='c', lw=2, encoding='utf-8', **kwargs):
    """
    Add china province boundary to basemap instance.
    :param mp: basemap instance.
    :param ax: matplotlib axes instance.
    :param name: map name.
    :param facecolor: fill color, default is none.
    :param edgecolor: edge color.
    :param lw: line width.
    :param kwargs: keywords passing to Polygon.
    :return: None.
    """

    # map name
    names = {'nation': "bou1_4p", 'province': "bou2_4p",
             'county': "BOUNT_poly", 'river': "hyd1_4p",
             'river_high': "hyd2_4p"}
        # get shape file and information
    shpfile = pkg_resources.resource_filename(
        'meteva', "resources/maps/" + names[name])
    shp1 = readshapefile(shpfile, default_encoding=encoding)
    lines = LineCollection(shp1,antialiaseds=(1,))
    lines.set_color(edgecolor)
    lines.set_linewidth(lw)
    lines.set_label('_nolabel_')
    ax.add_collection(lines)
Exemplo n.º 24
0
def plot_pheno_in_dir(path, save_path=None):
    os.chdir(path)
    files = os.listdir()

    # Find generation numbers
    pheno_generations = []
    for fname in files:
        if fname.startswith("archive") and ".dat" in fname:
            pheno_generations.append(fname.rstrip(r".dat")[len("archive_"):])

    for GEN_NUMBER in pheno_generations:
        if save_path:
            os.chdir(path)

        FILE = f'archive_{GEN_NUMBER}.dat'

        phenotypes = []

        with open(FILE, "r") as f:
            for line in f.readlines():
                data = line.strip().split(" ")
                # descriptors.append(data[1,2])
                phenotypes.append([float(x) for x in data[-2:]])

        fig = plt.figure()
        spec = fig.add_gridspec(1, 1)
        ax1 = fig.add_subplot(spec[0, 0], aspect='equal', adjustable='box')
        max_dpf = max(phen[1] for phen in phenotypes)
        plt.xlim([-max_dpf, max_dpf])
        plt.ylim([-max_dpf, max_dpf])

        # create lines, origin to point
        lines = []
        colours = []
        for (angle, dpf) in phenotypes:
            x = np.cos(angle) * dpf
            y = np.sin(angle) * dpf
            lines.append([(0, 0), (x, y)])
            colours.append(dpf)

        # Create a continuous norm to map from data points to colors
        norm = plt.Normalize(0, max_dpf)

        # https://matplotlib.org/3.1.0/tutorials/colors/colormaps.html

        # add all lines with the colours
        lc = LineCollection(lines, cmap='PuBuGn', norm=norm)
        colour_data = ax1.add_collection(lc)
        fig.colorbar(colour_data, ax=ax1)

        # Set the values used for colormapping
        lc.set_array(np.array(colours))
        lc.set_linewidth(1)
        plt.title(f"Solution space in Polar Coordinates - Gen {GEN_NUMBER}")

        if save_path:
            os.chdir(save_path)

        plt.savefig(f"pheno_{GEN_NUMBER}.png")
        plt.close()
def update(tval):
    global anim_running
    anim_running ^= True
    ax.clear()
    # update t array index
    i = closest_index(t, tval, tol=(tmin - tmax) / 1000.)
    # plot only tmin to t_[i] when  i<tbuf
    wpts = w[0:i]
    Ypts = Y[0:i]
    tpts = t[0:1]
    if i >= tbuff:
        # plot  from  t[i-tbuff] to t_cur = t[i]
        wpts = w[i - tbuff:i]
        Ypts = Y[i - tbuff:i]
        tpts = t[i - tbuff:i]
    points = np.array([wpts, Ypts]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    lc = LineCollection(segments,
                        cmap=hot2cold)  # , norm=plt.Normalize(0, 1) )
    lc.set_array(tpts)
    lc.set_linewidth(3)
    ax.add_collection(lc)
    ax.scatter(wpts, Ypts, s=3, c='r')
    ax.set_title("Goodwin model: wage and output trajectory")
    ax.set_xlabel('wage share, $w$')
    ax.set_ylabel('Output, $Y$')
    ax.set_xlim(0, wmax)
    ax.set_ylim(0, Ymax)
    #plt.draw()
    fig.canvas.draw_idle()
Exemplo n.º 26
0
def load_colorado_shapes(m):

    # read all US counties
    rdr = shapefile.Reader("../USA_adm/USA_adm2")
    shapes = rdr.shapes()
    records = rdr.records()

    # only keep Colorado counties
    ndx = filter(lambda i: records[i][4] == 'Colorado', np.arange(len(shapes)))
    shapes = [shapes[i] for i in ndx]
    records = [records[i] for i in ndx]

    # modified from web tutorial
    # http://www.geophysique.be/2013/02/12/matplotlib-basemap-tutorial-10-shapefiles-unleached-continued/
    line_col = []
    for record, shape in zip(records, shapes):
        lons,lats = zip(*shape.points)
        data = np.array(m(lons, lats)).T
 
        if len(shape.parts) == 1:
            segs = [data,]
        else:
            segs = []
            for i in range(1,len(shape.parts)):
                index = shape.parts[i-1]
                index2 = shape.parts[i]
                segs.append(data[index:index2])
                segs.append(data[index2:])
 
        lines = LineCollection(segs, antialiaseds=(1,))
        lines.set_edgecolors('k')
        lines.set_linewidth(0.8)
        line_col.append(lines)

    return line_col
Exemplo n.º 27
0
class BatchLineCollection(object):
    def __init__(self, ax):
        self._ax = ax
        self._lc = None

    @property
    def artists(self):
        return [self._lc]

    def draw(self, x, y, **kwargs):
        segments = []
        for x_i, y_i in zip(x, y):
            xy_i = np.stack([x_i, y_i], axis=1)
            xy_i = xy_i.reshape(-1, 1, 2)
            segments_i = np.hstack([xy_i[:-1], xy_i[1:]])
            segments.append(segments_i)
        segments = np.concatenate(segments, axis=0)

        if self._lc is None:
            self._lc = PltLineCollection(segments)
            self._ax.add_collection(self._lc)
        else:
            self._lc.set_segments(segments)
        if 'color' in kwargs:
            self._lc.set_color(np.reshape(kwargs['color'],
                                          [len(segments), -1]))
        if 'linewidth' in kwargs:
            self._lc.set_linewidth(kwargs['linewidth'])
        self._lc.set_joinstyle('round')
        self._lc.set_capstyle('round')
Exemplo n.º 28
0
def pl():
    x = np.linspace(0, 10, 500)
    y = np.sin(x)
    dydx = np.cos(0.5 * (x[:-1] + x[1:]))  # first derivative

    # Create a set of line segments so that we can color them individually
    # This creates the points as a N x 1 x 2 array so that we can stack points
    # together easily to get the segments. The segments array for line collection
    # needs to be (numlines) x (points per line) x 2 (for x and y)

    # points[0] = (x[0], y[0]
    points = np.array([x, y]).T.reshape(-1, 1, 2)
    # segments[0] = 2x2 matrix. segments[0][0] = points[0]; segments[0][1] = points[1]
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    fig, axs = plt.subplots(1, 1)

    # Create a continuous norm to map from data points to colors
    # min(norm) = 0, max(norm) = 1
    norm = plt.Normalize(dydx.min(), dydx.max())
    # cmap = color map
    lc = LineCollection(segments, cmap='viridis', norm=norm)
    # Set the values used for colormapping
    lc.set_array(dydx)
    lc.set_linewidth(2)
    line = axs.add_collection(lc)
    fig.colorbar(line, ax=axs)

    axs.set_xlim(x.min(), x.max())
    axs.set_ylim(-1.1, 1.1)

    embed()

    plt.show()
Exemplo n.º 29
0
    def draw_shp_polygons(self, shp_filepath, linewidths=0.2, colors='k', antialiaseds=None, linestyles='solid'):
        """
        Draw a shapefile containing polygons
        """   
        # Read the shapefile as shapes and records. For each polygon in shapes, draw its boundaries
        r = shapefile.Reader(shp_filepath)
        shapes = r.shapes()
        records = r.records()

        for record, shape in zip(records, shapes):
            lons, lats = zip(*shape.points)
            data = [(x, y) for x, y in zip(*self(lons, lats))]
            
            # shape.parts is a list containing the starting index of each part of shape (e.g. a lake inside the shape) on xy_pts. If shape contains only 1 part, a list containing 0 is returned.
            if len(shape.parts) == 1: 
                segs = [data, ]
            else:
                segs = []
                for npart in range(1, len(shape.parts)):
                    ix1 = shape.parts[npart-1]
                    ix2 = shape.parts[npart]
                    segs.append(data[ix1:ix2])
                    
                segs.append(data[ix2: ])
            
            lines = LineCollection(segs, antialiaseds = [1, ])
            lines.set_edgecolors(colors)
            lines.set_linestyle(linestyles)
            lines.set_linewidth(linewidths)
            self.ax.add_collection(lines)
Exemplo n.º 30
0
Arquivo: style.py Projeto: kubo4/lime
def color_code(x, y, z, fig, ax, cbar=False):
    # Create a set of line segments so that we can color them individually
    # This creates the points as a N x 1 x 2 array so that we can stack points
    # together easily to get the segments. The segments array for line collection
    # needs to be (numlines) x (points per line) x 2 (for x and y)
    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    # Create a continuous norm to map from data points to colors
    norm = plt.Normalize(0, 1)
    lc = LineCollection(segments, cmap='viridis', norm=norm)
    # Set the values used for colormapping
    lc.set_array(z)
    lc.set_linewidth(2)
    line = ax.add_collection(lc)

    # if cbar:
    #     cbar = fig.colorbar(line, orientation='horizontal')
    #     cbar.set_ticks([0., 1.])
    #     cbar.set_ticklabels(['matter', 'photon'])

    # ax.set_xlim(-6,4)
    # ax.set_ylim(3.,8.0)

    return line
Exemplo n.º 31
0
def colorline(x, y, cmap=None, cm_range=(0, 0.7), **kwargs):
    """Colorline plots a trajectory of (x,y) points with a colormap"""

    # plt.plot(x, y, '-k', zorder=1)
    # plt.scatter(x, y, s=40, c=plt.cm.RdBu(np.linspace(0,1,40)), zorder=2, edgecolor='k')

    assert len(cm_range) == 2, "cm_range must have (min, max)"
    assert len(x) == len(y), "x and y must have the same number of elements!"

    ax = kwargs.get('ax', plt.gca())
    lw = kwargs.get('lw', 2)
    if cmap is None:
        cmap = plt.cm.Blues_r

    t = np.linspace(cm_range[0], cm_range[1], len(x))

    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    lc = LineCollection(segments,
                        cmap=cmap,
                        norm=plt.Normalize(0, 1),
                        zorder=50)
    lc.set_array(t)
    lc.set_linewidth(lw)

    ax.add_collection(lc)

    return lc
Exemplo n.º 32
0
def plot_line_colored(x, y, t, w=None, color=None, cmap=None):
    import numpy as np
    from matplotlib.collections import LineCollection

    # Create a set of line segments so that we can color them individually
    # This creates the points as a N x 1 x 2 array so that we can stack points
    # together easily to get the segments. The segments array for line collection
    # needs to be numlines x points per line x 2 (x and y)
    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    extra = {}
    if w is None: extra['linewidths'] = w

    # Create the line collection object, setting the colormapping parameters.
    # Have to set the actual values used for colormapping separately.
    lc = LineCollection(segments,
                        cmap=p.get_cmap(cmap),
                        **extra
                        #norm=p.Normalize(0, 10)
                        )
    lc.set_array(t)
    lc.set_linewidth(w)

    if color is not None:
        lc.set_color(color)

    p.gca().add_collection(lc)
Exemplo n.º 33
0
    def figure(self, ax, x, y, speed, state):
        # Rescale x and y to figure
        x, y = x/4, y/4

        # Read image and RGB-> BGR
        background_path = os.path.join(self.maps_dir, state+".png")
        background = cv2.imread(background_path)
        background = background[:, :, ::-1]

        # Create a line of segments
        points = np.array([x, y]).T.reshape(-1, 1, 2)
        segments = np.concatenate([points[:-1], points[1:]], axis=1)

        # Create a continuous norm to map from data points to colors
        norm = plt.Normalize(speed.min(), speed.max())
        lc = LineCollection(segments, cmap='winter', norm=norm)

        # Set the values used for colormapping
        lc.set_array(speed)
        lc.set_linewidth(2)
        ax.add_collection(lc)
        fig.colorbar(line, ax=ax)

        ax.imshow(background, alpha=0.3)

        ax.get_xaxis().set_visible(False)
        ax.get_yaxis().set_visible(False)
        ax.set_title(f"State: {state}, episodes: {self.step}")
Exemplo n.º 34
0
def plot(ax, x, y, time, sim_type):
    assert (len(x) == len(y) == len(time))

    l = len(time)
    if use_hf_coloration:
        time_to_grayscale = 0.8 / 23.6  # for HF coloring
    else:
        time_to_grayscale = 0.8 / time[l - 1]
    colors = []
    for i in range(l - 1):
        if use_hf_coloration:
            color = get_hf_color(time[i])  # time[] is really HF
        else:
            g = 0.8 - (time[i] * time_to_grayscale)**2.0
            if sim_type == 'driven':
                color = (g, 1.0, g, 0.8)
            else:
                color = (g, g, 1.0, 1.0)
        colors.append(color)

    points = zip(x, y)
    segments = zip(points[:-1], points[1:])
    lc = LineCollection(segments, colors=colors)
    lc.set_alpha(1.0)
    lc.set_linewidth(1.0)
    lc.set_antialiased(True)
    ax.add_collection(lc)
    if use_hf_coloration:
        end_points.append((x[l - 1], y[l - 1], get_hf_color(time[l - 1])))
    else:
        end_points.append((x[l - 1], y[l - 1], COLOR[sim_type]))
Exemplo n.º 35
0
def plot(ax, x, y, time, sim_type):
	assert(len(x) == len(y) == len(time))

	l = len(time)
	if use_hf_coloration:
		time_to_grayscale = 0.8 / 23.6 # for HF coloring
	else:
		time_to_grayscale = 0.8 / time[l-1]
	colors = []
	for i in range(l-1):
		if use_hf_coloration:
			color = get_hf_color(time[i])  # time[] is really HF
		else:
			g = 0.8 - (time[i] * time_to_grayscale)**2.0
			if sim_type == 'driven':
				color = (g, 1.0, g, 0.8)
			else:
				color = (g, g, 1.0, 1.0)
		colors.append(color)
	
	points = zip(x,y)
	segments = zip(points[:-1], points[1:])
	lc = LineCollection(segments, colors=colors)
	lc.set_alpha(1.0)
	lc.set_linewidth(1.0)
	lc.set_antialiased(True)
	ax.add_collection(lc)
	if use_hf_coloration:
		end_points.append((x[l-1], y[l-1], get_hf_color(time[l-1])))
	else:
		end_points.append((x[l-1], y[l-1], COLOR[sim_type]))
Exemplo n.º 36
0
    def __plot_all(self, spectrum):
        total = len(spectrum)
        count = 0.0
        for timeStamp in spectrum:
            if self.settings.fadeScans:
                alpha = (total - count) / total
            else:
                alpha = 1

            data = spectrum[timeStamp].items()
            peakF, peakL = self.extent.get_peak_fl()

            segments, levels = self.__create_segments(data)
            if segments is not None:
                lc = LineCollection(segments)
                lc.set_array(numpy.array(levels))
                lc.set_norm(self.__get_norm(self.settings.autoL, self.extent))
                lc.set_cmap(self.colourMap)
                lc.set_linewidth(self.lineWidth)
                lc.set_gid('plot')
                lc.set_alpha(alpha)
                self.axes.add_collection(lc)
                count += 1

        return peakF, peakL
Exemplo n.º 37
0
def add_data(globe, axes, color_dict):
    """Add shapefile polygons to the matplotlib axes"""
    file_object = shapefile.Reader(filename)
    shapes = file_object.shapes()
    records = file_object.records()
    #iterate over all but the first 20 polygons (they're junk)
    for record, shape in zip(records[20:],shapes[20:]):
        #this entry is the colour code
        description = record[6]
        lons,lats = zip(*shape.points)
        #transform the lat/long coords to the right projection
        data = np.array(globe(lons, lats)).T
        #shapefile shapes can have disconnected parts, we have
        #to check
        if len(shape.parts) == 1:
            segs = [data,]
        else:
            segs = []
            for i in range(1,len(shape.parts)):
                #add all the parts
                index = shape.parts[i-1]
                index2 = shape.parts[i]
                segs.append(data[index:index2])
            segs.append(data[index2:])
        #Add all the parts we've found as a set of lines
        lines = LineCollection(segs,antialiaseds=(1,))
        lines.set_facecolors(color_dict[description])
        lines.set_edgecolors('k')
        lines.set_linewidth(0.1)
        #add the collection to the active axes
        axes.add_collection(lines)
Exemplo n.º 38
0
	def plotTrajDist(self, trajFallRisk, trajectory, counter, background_filename, traj_png_filenames, traj_pdf_filenames):
		x = []
		y = []
		dydx = []
		for i in range(len(trajectory)):
			x.append(trajectory[i][0][1])
			y.append(trajectory[i][0][0])
			dydx.append(trajFallRisk[i])

		# Create a set of line segments so that we can color them individually
		# This creates the points as a N x 1 x 2 array so that we can stack points
		# together easily to get the segments. The segments array for line collection
		# needs to be (numlines) x (points per line) x 2 (for x and y)
		points = np.array([x, y]).T.reshape(-1, 1, 2)
		segments = np.concatenate([points[:-1], points[1:]], axis=1)

		fig, ax = plt.subplots()
		datafile = cbook.get_sample_data(background_filename, asfileobj=False)
		im = image.imread(datafile)
		ax.imshow(im, aspect='auto', extent=(0, 10, 0, 10), alpha=0.5, zorder=-1)

		c = ["navy", [0.27,0.69,0.70], [0.45,0.68,0.82], [0.67,0.85,0.91], [0.99,0.68,0.38], [0.95,0.43,0.26], [0.84,0.19,0.15], "firebrick"]
		v = [0, 0.15, 0.3, 0.45, 0.6, 0.72, 0.85, 1.]
		l = list(zip(v,c))
		palette=LinearSegmentedColormap.from_list('rg',l, N=256)
		lc = LineCollection(segments, cmap=palette, norm=plt.Normalize(0, 1.5))
		lc.set_array(np.array(dydx))
		lc.set_linewidth(4)
		line = ax.add_collection(lc)
		fig.colorbar(line, ax=ax)
		plt.xlim(0, 10)
		plt.ylim(0, 10)
		plt.savefig(traj_png_filenames[counter], dpi =300)
		plt.savefig(traj_pdf_filenames[counter], dpi =300)
		plt.show()
Exemplo n.º 39
0
def plot_bumps_1d(Y,
                  subsampling=20,
                  labels=None,
                  labels_palette='hls',
                  ax=None):
    if ax is None:
        ax = plt.gca()

    Y_subsampled = Y[:, ::subsampling]

    ax.plot(Y_subsampled)
    ax.set_xticks([])

    if labels is not None:
        labels = np.sort(labels)
        unique_labels = np.unique(labels)

        segments = []
        for lab in unique_labels:
            subset = np.where(labels == lab)[0]
            segments.append((subset[0] - 0.5, subset[-1] + 0.5))

        offset = -0.1 * Y_subsampled.max()
        h_segments = [((s[0], offset), (s[1], offset)) for s in segments]

        colors = sns.color_palette(labels_palette, n_colors=len(unique_labels))

        hlc = LineCollection(h_segments, colors=colors)
        hlc.set_linewidth(5)
        hlc.set_clip_on(False)
        ax.add_collection(hlc)
Exemplo n.º 40
0
def waterfall_plot(fig,ax,X,Y,Z):
    '''
    Make a waterfall plot
    Input:
        fig,ax : matplotlib figure and axes to populate
        Z : n,m numpy array. Must be a 2d array even if only one line should be plotted
        X,Y : n,m array
    '''
    # Set normalization to the same values for all plots
    norm = plt.Normalize(Z.min().min(), Z.max().max())
    # Check sizes to loop always over the smallest dimension
    n,m = Z.shape
    if n>m:
        X=X.T; Y=Y.T; Z=Z.T
        m,n = n,m

    for j in range(n):
        # reshape the X,Z into pairs 
        points = np.array([X[j,:], Z[j,:]]).T.reshape(-1, 1, 2)
        segments = np.concatenate([points[:-1], points[1:]], axis=1)        
        lc = LineCollection(segments, cmap='plasma', norm=norm)
        # Set the values used for colormapping
        lc.set_array((Z[j,1:]+Z[j,:-1])/2)
        lc.set_linewidth(2) # set linewidth a little larger to see properly the colormap variation
        line = ax.add_collection3d(lc,zs=(Y[j,1:]+Y[j,:-1])/2, zdir='y') # add line to axes

    fig.colorbar(lc) # add colorbar, as the normalization is the same for all, it doesent matter which of the lc objects we use
Exemplo n.º 41
0
    def __plot_all(self):
        total = len(self.data)
        count = 0.0
        for timeStamp in self.data:
            if len(self.data[timeStamp]) < 2:
                self.parent.threadPlot = None
                return None, None

            if self.fade:
                alpha = (total - count) / total
            else:
                alpha = 1

            data = self.data[timeStamp].items()
            peakF, peakL = self.extent.get_peak_fl()

            segments, levels = self.__create_segments(data)
            lc = LineCollection(segments)
            lc.set_array(numpy.array(levels))
            lc.set_norm(self.__get_norm(self.autoL, self.extent))
            lc.set_cmap(self.colourMap)
            lc.set_linewidth(self.lineWidth)
            lc.set_gid('plot')
            lc.set_alpha(alpha)
            self.axes.add_collection(lc)
            count += 1

        return peakF, peakL
Exemplo n.º 42
0
def addLine(shapefilename):

    r = shapefile.Reader(shapefilename)
    shapes = r.shapes()
    records = r.records()

    cnt = 0
    for record, shape in zip(records, shapes):
        print(cnt)

        lons,lats = zip(*shape.points)
        data = np.array(m(lons, lats)).T

        if len(shape.parts) == 1:
            segs = [data,]
        else:
            segs = []
            for i in range(1,len(shape.parts)):
                index = shape.parts[i-1]
                index2 = shape.parts[i]
                segs.append(data[index:index2])
            segs.append(data[index2:])

        lines = LineCollection(segs,antialiaseds=(1,), zorder=3)
        # lines.set_facecolors(np.random.rand(3, 1) * 0.5 + 0.5)
        lines.set_edgecolors('k')
        lines.set_linewidth(0.3)
        ax.add_collection(lines)
        cnt += 1
Exemplo n.º 43
0
def colorline(ax, x,y,z,linewidth=1, colormap='jet', norm=None, zorder=1, alpha=1, linestyle='solid'):
        cmap = plt.get_cmap(colormap)
        
        if type(linewidth) is list or type(linewidth) is np.array or type(linewidth) is np.ndarray:
            linewidths = linewidth
        else:
            linewidths = np.ones_like(z)*linewidth
        
        if norm is None:
            norm = plt.Normalize(np.min(z), np.max(z))
        else:
            norm = plt.Normalize(norm[0], norm[1])
        
        '''
        if self.hide_colorbar is False:
            if self.cb is None:
                self.cb = matplotlib.colorbar.ColorbarBase(self.ax1, cmap=cmap, norm=norm, orientation='vertical', boundaries=None)
        '''
            
        # Create a set of line segments so that we can color them individually
        # This creates the points as a N x 1 x 2 array so that we can stack points
        # together easily to get the segments. The segments array for line collection
        # needs to be numlines x points per line x 2 (x and y)
        points = np.array([x, y]).T.reshape(-1, 1, 2)
        segments = np.concatenate([points[:-1], points[1:]], axis=1)
        
        # Create the line collection object, setting the colormapping parameters.
        # Have to set the actual values used for colormapping separately.
        lc = LineCollection(segments, linewidths=linewidths, cmap=cmap, norm=norm, zorder=zorder, alpha=alpha, linestyles=linestyle )
        lc.set_array(z)
        lc.set_linewidth(linewidth)
        
        ax.add_collection(lc)
Exemplo n.º 44
0
def traceShape(file_shapefile):
    r = shapefile.Reader(file_shapefile)
    shapes = r.shapes()
    records = r.records()
    #sc_fac = 100000
    for record, shape in zip(records,shapes):
        #print shape.points
        lonsh,latsh = zip(*shape.points)
        # lonsh = [x/sc_fac for x in lonsh]
        # latsh = [x/sc_fac for x in latsh]
        data = np.array(m(lonsh, latsh)).T
     
        if len(shape.parts) == 1:
            segs = [data,]
        else:
            segs = []
            for i in range(1,len(shape.parts)):
                index = shape.parts[i-1]
                index2 = shape.parts[i]
                segs.append(data[index:index2])
            segs.append(data[index2:])
     
        lines = LineCollection(segs,antialiaseds=(1,))
        # lines.set_facecolors(cm.jet(np.random.rand(1)))
        lines.set_edgecolors('k')
        lines.set_linewidth(0.1)
        ax.add_collection(lines)

    return None
Exemplo n.º 45
0
def coordsToLC(x, y, vals, cmap='jet'):
    """Converts coordinates to LineCollection and labels them with colormap.
	
	Args:
		x (numpy.ndarray): List of x-values.
		y (numpy.ndarray): List of y-values.
		vals (numpy.ndarray): Segment values.
	
	Keyword Args:	
		cmap (str): Name of colormap.
	
	Returns:
		matplotlib.collections.LineCollection: LineCollection of the data.
	
	"""

    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)

    lc = LineCollection(segments,
                        cmap=plt.get_cmap(cmap),
                        norm=plt.Normalize(0, max(vals)))

    lc.set_array(vals)
    lc.set_linewidth(3)

    return lc
Exemplo n.º 46
0
def doTracelines(xstart,ystart,zstart,step,tmax,Nmax):
    global ActiveAxis, ActiveCanvas, ActiveTimmlModel, ActiveSettings
    setActiveWindow()
    win = getActiveWindow()
    ActiveAxis.set_autoscale_on(False)
    width = 0.5
    color = []
    for j in range(getActiveNumberLayers()):
        color.append( ActiveSettings.get_color('Trace',j) )
        color[j] = colorConverter.to_rgba( color[j] )
    for i in range( len(xstart) ):
        xyz, time, reason, pylayers = ActiveTimmlModel.\
            traceline(xstart[i],ystart[i],zstart[i],step,tmax,Nmax,tstart=0.0,window=win,labfrac = 2.0, Hfrac = 2.0)
        trace_color = []
        for j in range(len(xyz)-1):  # Number of segments one less than number of points
            trace_color.append( color[ pylayers[j] ] )
        points = zip( xyz[:,0], xyz[:,1] )
        segments = zip( points[:-1], points[1:] )
        LC = LineCollection(segments, colors = trace_color)
        LC.set_linewidth(width)
        ActiveAxis.add_collection(LC)
        #ActiveAxis.plot( xyz[:,0], xyz[:,1], 'b' )
    ActiveAxis.set_xlim(win[0],win[2])
    ActiveAxis.set_ylim(win[1],win[3])
    ActiveCanvas.draw()
Exemplo n.º 47
0
def trajectory_vel_with_occupancy_grid(map, file_ptahs):
    occupancy_grid, start, goal = get_occupancy_grid(map)
    #plt.style.use('ggplot')
    labels = []
    for fp in file_ptahs:
        # data_path = np.genfromtxt(fp, delimiter=',')
        # plt.plot(data_path[:, 0], data_path[:, 1], color = "r" if "rrt" in fp else "b")
        # labels.append("RRT" if "rrt" in fp else "Wavefront")
        
        data_trajectory = np.genfromtxt(fp, delimiter=',')

        fig, axs = plt.subplots()
        velocities = data_trajectory[:, 2]
        # Create a continuous norm to map from data points to colors
        norm = plt.Normalize(velocities.min(), velocities.max())
        points = np.array([data_trajectory[:, 0], data_trajectory[:, 1]]).T.reshape(-1, 1, 2)
        segments = np.concatenate([points[:-1], points[1:]], axis=1)
        lc = LineCollection(segments, cmap="Reds" if "rrt" in fp else "Blues", norm=norm)
        # Set the values used for colormapping
        lc.set_array(velocities)
        lc.set_linewidth(2)
        line = axs.add_collection(lc)
        plt.colorbar(line, ax=axs)
        occupancy_grid.draw()
        plt.show()
    #plt.title('Planned trajectories')
    plt.legend(labels)
    occupancy_grid.draw()
    plt.show()
Exemplo n.º 48
0
    def __plot_all(self, spectrum):
        total = len(spectrum)
        count = 0.0
        for timeStamp in spectrum:
            if self.settings.fadeScans:
                alpha = (total - count) / total
            else:
                alpha = 1

            data = spectrum[timeStamp].items()
            peakF, peakL = self.extent.get_peak_fl()

            segments, levels = self.__create_segments(data)
            if segments is not None:
                lc = LineCollection(segments)
                lc.set_array(numpy.array(levels))
                lc.set_norm(self.__get_norm(self.settings.autoL, self.extent))
                lc.set_cmap(self.colourMap)
                lc.set_linewidth(self.lineWidth)
                lc.set_gid('plot')
                lc.set_alpha(alpha)
                self.axes.add_collection(lc)
                count += 1

        return peakF, peakL
Exemplo n.º 49
0
    def __plot_all(self):
        total = len(self.data)
        count = 0.0
        for timeStamp in self.data:
            if len(self.data[timeStamp]) < 2:
                self.parent.threadPlot = None
                return None, None

            if self.fade:
                alpha = (total - count) / total
            else:
                alpha = 1

            data = self.data[timeStamp].items()
            peakF, peakL = self.extent.get_peak_fl()

            segments, levels = self.__create_segments(data)
            lc = LineCollection(segments)
            lc.set_array(numpy.array(levels))
            lc.set_norm(self.__get_norm(self.autoL, self.extent))
            lc.set_cmap(self.colourMap)
            lc.set_linewidth(self.lineWidth)
            lc.set_gid('plot')
            lc.set_alpha(alpha)
            self.axes.add_collection(lc)
            count += 1

        return peakF, peakL
Exemplo n.º 50
0
def plotcf(grid, phase, modulus, darken=None, axes=None, linestylep="solid", linewidthp=1, color="k", **kwargs):
    r"""Plot the modulus of a complex valued function
    :math:`f:\mathbb{R} \rightarrow \mathbb{C}`
    together with its phase in a color coded fashion.

    :param grid: The grid nodes of the real domain R
    :param phase: The phase of the complex domain result f(grid)
    :param modulus: The modulus of the complex domain result f(grid)
    :param darken: Whether to take into account the modulus of the data to darken colors.
    :param axes: The axes instance used for plotting.
    :param linestylep: The line style of the phase curve.
    :param linewidthp: The line width of the phase curve.
    :param color: The color of the phase curve.
    """
    # Color mapping
    rgb_colors = color_map(modulus, phase=phase, modulus=modulus, darken=darken)

    # Put all the vertical line into a collection
    segments = [array([[node, 0], [node, value]]) for node, value in zip(grid, modulus)]
    line_segments = LineCollection(segments)

    # Set some properties of the lines
    rgb_colors = line_segments.to_rgba(rgb_colors)
    line_segments.set_color(rgb_colors[0])
    line_segments.set_linestyle(linestylep)
    line_segments.set_linewidth(linewidthp)

    # Plot to the given axis instance or retrieve the current one
    if axes is None:
        axes = gca()

    # Plot the phase
    axes.add_collection(line_segments)
    # Plot the modulus
    axes.plot(grid, modulus, color=color, **kwargs)
Exemplo n.º 51
0
def _plotpartial(ax, partial, downsample=1, cmap='inferno', exp=1, linewidth=1, avg=True):
    # columns: time, freq, amp, phase, bw
    segments, Z = _segmentsZ(partial, downsample=downsample, exp=exp, avg=avg)
    lc = LineCollection(segments, cmap=cmap)
    # Set the values used for colormapping
    lc.set_array(Z)
    lc.set_linewidth(linewidth)
    lc.set_alpha(None)
    ax.add_collection(lc, autolim=True)
Exemplo n.º 52
0
 def shape(self, height, yrange, rotated):
     g = rlg2mpl.Group()
     trans = TransformScalePart(g.combined_transform)
     y = height/2.0
     segments = [[(x1,y),(x2,y)] for (x1,x2) in self.segments]
     a = LineCollection(segments, edgecolor='k', facecolor='k')
     a.set_linewidth(2)
     g.add(a)
     a.set_transform(g.combined_transform)
     return g
Exemplo n.º 53
0
def plotgraph(xy,edges,edgecolor='b'):
    lcol = xy[edges]
    lc = LineCollection(xy[edges])
    lc.set_linewidth(0.1)
    lc.set_color(edgecolor)
    pl.gca().add_collection(lc)
    #pl.plot(xy[:,0], xy[:,1], 'ro')
    pl.xlim(xy[:,0].min(), xy[:,0].max())
    pl.ylim(xy[:,1].min(), xy[:,1].max())
    pl.show()
Exemplo n.º 54
0
 def shape(self, height, yrange, rotated):
     g = rlg2mpl.Group()
     trans = TransformScalePart(g.combined_transform)
     segment = [(0.1, 0), (0.9, 0)]
     if rotated:
         segment = [(y, x) for (x, y) in segment]
     a = LineCollection([segment], colors=self.cvalues, offsets=self.offsets, transOffset=g.combined_transform)
     a.set_linewidth(3)
     g.add(a)
     a.set_transform(trans)
     return g
Exemplo n.º 55
0
def plot_colored_line(ax, x, y, c=None, s=2, **kwargs):
    """ Draws a linegraph with the line color coded.
    """
    points = np.array([x, y]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)
    lc = LineCollection(segments, **kwargs)
    if c is not None:
        lc.set_array(c)
    lc.set_linewidth(s)
    ax.add_collection(lc)
    ax.set_xlim([x.min(), x.max()])
    ax.set_ylim([y.min(), y.max()])
Exemplo n.º 56
0
def plot_trajectory(trajectories, name='trajectory', pos='left'):
    print "Plotting trajectory: %s" % name
    plt.figure(1, figsize=(4, 4))

    ax = plt.subplot(111)
    trajx = np.concatenate([t[0] for t in trajectories])
    trajy = np.concatenate([t[1] for t in trajectories])
    annote = set()
    for t in trajectories:
        for a in t[2]:
            annote.add(a)

    cmap = plt.get_cmap('Greys')

    t = np.arange(trajx.shape[0]) * 0.001
    points = np.array([trajy, trajx]).T.reshape(-1, 1, 2)
    segments = np.concatenate([points[:-1], points[1:]], axis=1)
    lc = LineCollection(segments, cmap=cmap,
                        norm=plt.Normalize(-t[-1] * 0.5, t[-1] * 0.75))
    lc.set_array(t)
    lc.set_linewidth(3)
    lc.set_rasterized(True)
    ax.add_collection(lc)

    for (a_t, l) in annote:
        ix = int(a_t / 0.001) - 1
        xy = (trajy[ix], trajx[ix])
        xytext = (-30 if xy[0] > 0 else 30, -30 if xy[1] > 0 else 30)
        if l == 'Start of next trial' and xy[1] > 0:
            l = 'Start of\nnext trial'
            xytext = (-50, 5)
        if l == 'Release\n(premature)':
            xytext = (-10, -35)
        plt.annotate(l, xy, xycoords='data', xytext=xytext, ha='center',
                     va='center', textcoords='offset points',
                     arrowprops={'arrowstyle': '->',
                                 'connectionstyle': 'arc3, rad=0.2'})

    plt.axhline(0.0, color='k', ls=":")
    plt.axvline(0.0, color='k', ls=":")
    if 'left' in pos:
        plt.ylabel("Task state (arbitrary units)")
        ax.get_yaxis().tick_left()
    else:
        plt.yticks(())
    ax.get_xaxis().tick_bottom()
    plt.xlabel("Relative time in task state (arbitrary units)")


    plt.axis((-1.5, 1.5, -2.0, 1.5))
    plt.subplots_adjust(bottom=0.12, top=0.97, left=0.17, right=0.97)

    save_or_show('plots/' + name + '_traj')
Exemplo n.º 57
0
    def drawstates(self,ax,linewidth=0.5,color='k',antialiased=1):
        """
 Draw state boundaries in Americas.

 ax - current axis instance.
 linewidth - state boundary line width (default 0.5)
 color - state boundary line color (default black)
 antialiased - antialiasing switch for state boundaries (default True).
        """
        coastlines = LineCollection(self.statesegs,antialiaseds=(antialiased,))
        coastlines.color(color)
        coastlines.set_linewidth(linewidth)
        ax.add_collection(coastlines)
Exemplo n.º 58
0
    def drawcoastlines(self,ax,linewidth=1.,color='k',antialiased=1):
        """
 Draw coastlines.

 ax - current axis instance.
 linewidth - coastline width (default 1.)
 color - coastline color (default black)
 antialiased - antialiasing switch for coastlines (default True).
        """
        coastlines = LineCollection(self.coastsegs,antialiaseds=(antialiased,))
        coastlines.color(color)
        coastlines.set_linewidth(linewidth)
        ax.add_collection(coastlines)
Exemplo n.º 59
0
    def plot(self, show_minima=False, linewidth=0.5, axes=None):
        """draw the disconnectivity graph using matplotlib
        
        don't forget to call calculate() first
        
        also, you must call pyplot.show() to actually see the plot
        """
        import matplotlib as mpl
        from matplotlib.collections import LineCollection
        import matplotlib.pyplot as plt
        
        self.line_segments = self._get_line_segments(self.tree_graph, eoffset=self.eoffset)
        
        #set up how the figure should look
        if axes is not None:
            ax = axes
        else:
            fig = plt.figure(figsize=(6,7))
            fig.set_facecolor('white')
            ax = fig.add_subplot(111, adjustable='box')

        ax.tick_params(axis='y', direction='out')
        ax.yaxis.tick_left()
        ax.spines['left'].set_color('black')
        ax.spines['left'].set_linewidth(0.5)
        ax.spines['top'].set_color('none')
        ax.spines['bottom'].set_color('none')
        ax.spines['right'].set_color('none')
#        plt.box(on=True)
        
        #draw the minima as points
        if show_minima:      
            leaves = self.tree_graph.get_leaves()
            energies = [self._getEnergy(leaf.data["minimum"]) for leaf in leaves]
            xpos = [leaf.data["x"] for leaf in leaves]
        
            ax.plot(xpos, energies, 'o')
        
        # draw the line segments 
        # use LineCollection because it's much faster than drawing the lines individually 
        linecollection = LineCollection([ [(x[0],y[0]), (x[1],y[1])] for x,y in self.line_segments])
        linecollection.set_linewidth(linewidth)
        linecollection.set_color("k")
        ax.add_collection(linecollection)
        
        # scale the axes appropriately
        ax.relim()
        ax.autoscale_view(scalex=True, scaley=True, tight=None)

        #remove xtics            
        ax.set_xticks([])        
Exemplo n.º 60
0
	def AddLine(self, X, Y, Z):	#Add line to the 2D plot to show where the slice is taken
		# global linecolor
		# try:
		# 	self.line_segment.pop(0).remove()
		# except:
		# 	pass
		points = np.array([X,Y]).T.reshape(-1,1,2)
		segments = np.concatenate([points[:-1], points[1:]], axis=1)
		lc = LineCollection(segments, cmap=plt.get_cmap('Spectral'))
		lc.set_array(Z)
		lc.set_linewidth(2)
		self.axes.add_collection(lc)

		self.canvas.draw()								#Update 2D plot