def stackplot(data, x, y, hue, cmap=palettes.neon):
    xs = np.array(data[x])
    yss = []
    labels = []
    for k,grp in data.groupby(hue):
        labels.append(k)
        grp_xs = grp[x].tolist()
        grp_ys = grp[y].tolist()
        ys = []
        for v in xs:
            if len(grp_xs) > 0 and grp_xs[0] == v:
                ys.append(grp_ys.pop(0))
                grp_xs.pop(0)
            else:
                if len(ys) == 0:
                    ys.append(0.)
                else:
                    ys.append(ys[-1])
        assert len(grp_xs) == 0
        assert len(grp_ys) == 0
        assert len(ys) == len(xs)
        yss.append(np.array(ys, dtype=float))

    if cmap is not None:
        colors = colors_from_hue(data, hue, cmap)
    else:
        colors = None

    plt.stackplot(xs, *yss, labels=labels, colors=colors)

    plt.ylabel(y)
    plt.xlabel(x)
    plt.gca().autoscale(tight=True)
    plt.gca().margins(y=0.1)

def plot3():
### number of settlements, cropping: abandoned/sown, soil degradation, total real income
    fig = plt.figure(figsize=(12,7))
    crop_yield_evo[np.isnan(crop_yield_evo)]=0
    
    ### number of settlements
    plt.subplot(221)
    plt.plot(crop_yield_evo)
    plt.title("crop yield")
    
    ### ecoserv benefit 
    plt.subplot(222)
    plt.plot(eco_benefit_evo)
    plt.title("eco benefit")
    
    ### soil degradation
    plt.subplot(223)
    plt.plot(trade_income_evo)
    plt.title("trade strength")
    
    ### total real income
    plt.subplot(224)
    plt.stackplot(np.arange(N),np.nanmean(crop_yield_evo,1)*1.1,np.nanmean(eco_benefit_evo,1)*10,np.nanmean(trade_income_evo,1)*6000)
    plt.title("total real income")
    
    plt.tight_layout()
    fig.savefig(picture_directory+'3_panel.png',dpi=200)
    plt.close(fig)

def stack_plot(fr, outfile, normalize=False, dont_stack=False, max_n=20):

    
    if len(fr.columns) > max_n: # reformat columns and group together nonsignificant ones
        
        js = sorted([ (c,fr[c].sum()) for c in fr.columns ], key=lambda j: j[1], reverse=True)
        top_js  = [ i[0] for i in js[:max_n]]
        rest_js = [ i[0] for i in js[max_n:]]
        # replace
        fr['Others']=fr[rest_js].sum(axis=1)
        # remove
        fr=fr.drop(rest_js, axis=1)
        labels = top_js+['Others']
    else:
        js = sorted([ (c,fr[c].sum()) for c in fr.columns ], key=lambda j: j[1], reverse=True)
        labels  = [ i[0] for i in js]
        
    pyplot.figure(figsize=(13, 8))
    
    colors = generate_n_colors(len(labels))
    if dont_stack:
        for color, label in zip(colors, labels):
            pyplot.plot(fr.index, fr[label], color=color, label=label, linewidth=2)
    else:
        pyplot.stackplot(fr.index, fr[labels].T, labels=labels)#, colors=colors
        #fr.plot(kind='area')
        
    pyplot.legend(loc=2)
    pyplot.ylabel('Lines of code')
    pyplot.tight_layout()
    pyplot.savefig(outfile)

def plot_stack_candidates(tweets, cands, interval, start = 0, \
  end = MAX_TIME // 60, tic_inc = 120, save_to = None): 
  '''
  Plots stackplot for the candidates in list cands over the time interval
  ''' 

  period = range(start, end, interval)
  percent_dict = tweets.mention_minute_percent(cands, interval, period)

  y = [] 
  fig = plt.figure(figsize = (FIGWIDTH, FIGHEIGHT))
  legends = [] 
  for candidate in percent_dict:
    y.append(percent_dict[candidate]) 
    legends.append(CANDIDATE_NAMES[candidate])
  plt.stackplot(period, y)

  plt.title("Percentage of Mentions per {} minutes before, during, \
    and after debate".format(interval))
  plt.xlabel("Time")
  plt.ylabel("Number of Tweets")
  plt.legend(y, legends)

  ticks_range = range(start, end, tic_inc)
  labels = list(map(lambda x: str(x - start) + " min", ticks_range))
  plt.xticks(ticks_range, labels, rotation = 'vertical')
  plt.xlim( (start, end) )
  plt.ylim( (0.0, 1.0))
  
  if save_to: 
    fig.savefig(save_to)
  plt.show()

def plot2():
    ### number of settlements,cropping: abandoned/sown, soil degradation, forest state
    fig = plt.figure(figsize=(12, 7))
    
    ### number of settlements
    plt.subplot(221)
    plt.plot(number_settlements_evo)
    plt.title("number of settlements")
    
    ### cropping: abandoned/sown
    plt.subplot(222)
    plt.plot(abnd_sown_evo[:, 0], "r")
    plt.plot(abnd_sown_evo[:, 1], "g")
    plt.title("abandoned/sown")
    
    ### soil degradation
    plt.subplot(223)
    plt.plot(soil_deg_evo[0])
    plt.title("soil degradation")
    
    ### forest state
    plt.subplot(224)
    plt.stackplot(np.arange(N),forest_evo[0],forest_evo[1],forest_evo[2],colors=['#FF9900', '#66FF33','#336600'])
    plt.title("forest state")
    
    plt.tight_layout()
    fig.savefig(picture_directory+'2_panel.png',dpi=200)
    plt.close(fig)

def stacked_trajectory_plot(xlabel="generation"):
    colors_lighter = [
        "#A567AF",
        "#8F69C1",
        "#8474D1",
        "#7F85DB",
        "#7F97DF",
        "#82A8DD",
        "#88B5D5",
        "#8FC0C9",
        "#97C8BC",
        "#A1CDAD",
        "#ACD1A0",
        "#B9D395",
        "#C6D38C",
        "#D3D285",
        "#DECE81",
        "#E8C77D",
        "#EDBB7A",
        "#EEAB77",
        "#ED9773",
        "#EA816F",
        "#E76B6B",
    ]
    mpl.rcParams["font.size"] = 18
    haplotypes = get_all_haplotypes()
    trajectories = [get_trajectory(haplotype) for haplotype in haplotypes]
    plt.stackplot(range(generations), trajectories, colors=colors_lighter)
    plt.ylim(0, 1)
    plt.ylabel("frequency")
    plt.xlabel(xlabel)

  def plot(self):
    # Read events.
    #self.read_simple_events()
    #self.read_external_events()
    self.read_events()
    self.scale(self.scale_factor)
    
    # Set the plot size.
    grid_row = 2
    grid_fig_col = self.num_simple_events / 2
    grid_legend_col = 8
    grid_col = grid_fig_col + grid_legend_col
    fig = plt.figure(figsize = (grid_col, grid_row * 6))

    # Plot simple events.
    plt.subplot2grid((grid_row, grid_col), (0, 0), colspan = grid_fig_col)
    x = np.arange(self.num_simple_events)
    # Prepare colors.
    colors = self.get_colors(len(V8_STATES_PLOT))
    plt.stackplot(x, [self.data[key] for key in V8_STATES_PLOT], colors = colors)
    # Set the axis limits.
    plt.xlim(xmin = 0, xmax = self.num_simple_events - 1)
    plt.ylim(ymin = 0, ymax = self.sampling_period)
    # Draw legend.
    plt.subplot2grid((grid_row, grid_col), (0, grid_col - 1))
    total_ticks = self.num_simple_events * self.sampling_period
    plt.table(cellText = [[str(100 * sum(self.data[key]) / total_ticks) + ' %'] for key in reversed(V8_STATES_PLOT)],
              rowLabels = V8_STATES_PLOT[::-1],
              rowColours = colors[::-1],
              colLabels = ['Ticks'],
              loc = 'center')
    plt.xticks([])
    plt.yticks([])
    
    # Plot external events.
    plt.subplot2grid((grid_row, grid_col), (1, 0), colspan = grid_fig_col)
    x = np.arange(self.num_external_events)
    # Prepare colors.
    colors = self.get_colors(len(EXTERNAL_DETAILS))
    plt.stackplot(x, [self.data_external[key] for key in EXTERNAL_DETAILS], colors = colors)
    # Set the axis limits.
    plt.xlim(xmin = 0, xmax = self.num_external_events - 1)
    plt.ylim(ymin = 0, ymax = self.sampling_period)
    # Draw legend.
    plt.subplot2grid((grid_row, grid_col), (1, grid_col - 3), colspan = 3)
    total_ticks = 0
    for key in EXTERNAL_DETAILS:
      total_ticks += sum(self.data_external[key]) + 1
    plt.table(cellText = [[str(100 * sum(self.data_external[key]) / total_ticks) + ' %', str(sum(self.num_external[key]))] for key in reversed(EXTERNAL_DETAILS)],
              rowLabels = EXTERNAL_DETAILS[::-1],
              rowColours = colors[::-1],
              colLabels = ['Ticks', '# of Times'],
              loc = 'center')
    plt.xticks([])
    plt.yticks([])
    
    # Finally draw the plot.
    plt.tight_layout()
    plt.show()

def stacked_trajectory_plot(xlabel="generation"):
    mpl.rcParams['font.size']=18
    haplotypes = get_all_haplotypes()
    trajectories = [get_trajectory(haplotype) for haplotype in haplotypes]
    plt.stackplot(range(generations), trajectories, colors=colors_lighter)
    plt.ylim(0, 1)
    plt.ylabel("frequency")
    plt.xlabel(xlabel)

    def stackPlot(self, mergeMeth, xAxis, lst1, lst, lst3):
        xLims = plt.xlim(-.05, (xAxis +.05))
        yLims = plt.ylim(0, max(mergeMeth) + 1)


        #fig, ax = plt.subplots()
        plt.stackplot(xAxis, lst1, lst2, lst3, colors=['m','c','y'])
        plt.show()

def makePlot(fn=getCosDistribution):
    # collect data
    h = 60
    linePlots = []
    stackedPlots = {
        'labels': [],
        'data': [],
        'colors': [],
    }
    for line in lines:
        distribution = fn(line['schedule'], line['capacity'])
        distribution = rotate(distribution, -line.get('offset', 0))
        distribution = distribution[3*h:] + distribution[:3*h]
        distribution = distribution[1*h:23*h]
        if line.get('stacked'):
            stackedPlots['data'  ].append(distribution)
            stackedPlots['colors'].append(line['color'])
            stackedPlots['labels'].append(line['line'])            
            
        else:
            linePlots.append({
                'y': distribution,
                'color': line['color'],
                'linestyle': line.get('linestyle', '-'),
                'linewidth': line.get('linewidth', 2),
                'alpha': line.get('alpha', 1),
            })
    X = [t/60.0 for t in  range(4*h, 26*h)]

    # make plot
    matplotlib.rcParams.update({'font.size': 16})
    fig, ax = plot.subplots(facecolor="white", figsize=(13,7), dpi=100)
    ax.xaxis.set_major_formatter(ticker.FuncFormatter(lambda d, _: str(d%24)+"h"))
    ax.yaxis.set_major_formatter(ticker.FuncFormatter(lambda d, _: "{:,}".format(int(d))))
    plot.xlim(4, 26)
    plot.ylim(0, 35000)
    plot.xticks(range(4,27, 2))
    plot.ticklabel_format(axis='x',)
    plot.minorticks_on()
    plot.grid(color='#000000', alpha=0.2, linestyle='-', linewidth=0.8, which='both')
    ax.yaxis.grid(color='#000000', alpha=0.1, linestyle='-', linewidth=0.4, which='minor')
#    plot.grid(color='#000000', b=True, which='minor', axis='x', alpha=0.15, linestyle='-', linewidth=0.5, xdata=range(5,27, 2))
    ax.xaxis.set_minor_locator(ticker.AutoMinorLocator(2))

    if len(stackedPlots['data']) > 0:
        plot.stackplot(X,
                       *(stackedPlots['data']),
                       colors=stackedPlots['colors'],
                       alpha = 0.5,
                       linewidth = 0)
    for p in linePlots:
        plot.plot(X,
                  p['y'],
                  alpha=p['alpha'],
                  color=p['color'], linewidth=p['linewidth'], linestyle=p['linestyle'],)
#    plot.axes(axisbg='w')

    plot.show()

def plot_population_drift(drift_data, title):
    generations = range(drift_data.shape[1])
    xs = range(drift_data.shape[0])
    colors = [str(hex(SKIN_COLORS[x])).replace("0x", "#") for x in xs]
    plt.stackplot(generations, drift_data, baseline="zero", colors=colors)
    plt.xlabel("Generations")
    plt.ylabel("Frequency")
    plt.title("Phenotype Drift:%s" % (title))
    plt.show()

def stacked(asim, msim):
    if len(asim) != len(msim):
        raise Exception("The Replacement and Maintenance sets arent the same lenght")
    else:
        plt.stackplot(range(0, len(asim)), [asim, msim], colors=["#377EB8", "#55BA87"])
        plt.legend([mpatches.Patch(color="#377EB8"), mpatches.Patch(color="#55BA87")], ["Replacement", "Maintenance"])
        plt.title("Expected Financial Consequence - Replacement & Maintenance")
        plt.xlabel("Years")
        plt.ylabel("Fin. Consequence (k)")

def stacked_trajectory_plot(history, generations, name = 'stacked_trajectory', xlabel="generation"):
    colors_lighter = ["#A567AF", "#8F69C1", "#8474D1", "#7F85DB", "#7F97DF", "#82A8DD", "#88B5D5", "#8FC0C9", "#97C8BC", "#A1CDAD", "#ACD1A0", "#B9D395", "#C6D38C", "#D3D285", "#DECE81", "#E8C77D", "#EDBB7A", "#EEAB77", "#ED9773", "#EA816F", "#E76B6B"]
    mpl.rcParams['font.size']=18
    haplotypes = get_all_haplotypes(history, generations)
    trajectories = [get_trajectory(haplotype, generations, history) for haplotype in haplotypes]
    plt.stackplot(range(generations), trajectories, colors=colors_lighter)
    plt.ylim(0, 1)
    plt.ylabel("frequency")
    plt.xlabel(xlabel)
    plt.savefig(name + '.png', bbox_inches='tight',  dpi = 600)

def plotLats(classifNr,dx):

	x = [classifNr[i] for i in classifNr]
	n = 180/dx + 1
	y = np.arange(-90,90+dx,dx)
	fig = plt.figure()
	plt.stackplot(y,x,alpha = 0.4,colors = colors)
	plt.margins(0,0)
	plt.title('Classifications and latitudes, percentage')
	plt.xlabel('Latitudes')
	plt.xticks(y)
	plt.show()

def test05():
    k = [1,2,3,4,5]

    a = [2,3,2,3,2]
    b = [4,1,5,3,5]
    c = [1,4,2,2,3]
    d = [3,2,1,2,0]

    plt.stackplot(k, a, b, c, d, colors=['r', 'g', 'b', 'y'])
    plt.plot([],[],label='a',color='r',linewidth=5)
    plt.plot([],[],label='b',color='g',linewidth=5)
    plt.plot([],[],label='c',color='b',linewidth=5)
    plt.plot([],[],label='d',color='y',linewidth=5)

def test_stackplot_baseline():
    np.random.seed(0)
    def layers(n, m):
        def bump(a):
            x = 1 / (.1 + np.random.random())
            y = 2 * np.random.random() - .5
            z = 10 / (.1 + np.random.random())
            for i in range(m):
                w = (i / float(m) - y) * z
                a[i] += x * np.exp(-w * w)
        a = np.zeros((m, n))
        for i in range(n):
            for j in range(5):
                bump(a[:, i])
        return a

    d=layers(3, 100)

    fig = plt.figure()

    plt.subplot(2, 2, 1)
    plt.stackplot(range(100), d.T, baseline='zero')

    plt.subplot(2, 2, 2)
    plt.stackplot(range(100), d.T, baseline='sym')

    plt.subplot(2, 2, 3)
    plt.stackplot(range(100), d.T, baseline='wiggle')

    plt.subplot(2, 2, 4)
    plt.stackplot(range(100), d.T, baseline='weighted_wiggle')

def stack_plots():
    days = [1,2,3,4,5]
    sleeping = [7,8,6,11,7]
    eating = [2,3,4,3,2]
    working = [7,8,7,2,2]
    playing = [8,5,7,8,13]
    
    
    pyplot.plot([], [], color='magenta', label='Sleeping', linewidth=3)
    pyplot.plot([], [], color='cyan', label='Eating', linewidth=3)
    pyplot.plot([], [], color='red', label='Working', linewidth=3)
    pyplot.plot([], [], color='black', label='Playing', linewidth=3)
    pyplot.stackplot(days, sleeping, eating, working, playing, colors=['magenta', 'cyan', 'red', 'black'])
    pyplot_apply_2d()

def make_scaling_plot(params, title, path, axis=None):
    m = run_model(**params)
    purple = '#BBA4D1'
    blue = '#3399CC'
    plt_title(title)
    plt.stackplot([(tick * params['sec_per_tick']) / 60.0 for tick in range(m.ticks)], m.builders_in_use, m.builders_available,
                  colors=(purple, blue), linewidth=0)
    plt.legend([mpatches.Patch(color=purple),
                mpatches.Patch(color=blue)],
               ['Busy Builder Machines','Available Builder Machines'])
    plt.xlabel('Time (m)')
    plt.ylabel('Machines')
    if axis:
        plt.axis(axis)
    plt_save(path)

def plot(dates, f_frac, m_frac, title, f_overall, m_overall):
    x_spacing = [i+1 for i in range(len(dates))]
    plt.stackplot(x_spacing, f_frac, m_frac, labels=('Female', 'Male'),
                  colors=('r','b'))
    plt.axhline(f_overall, linewidth=2, color='m')
    plt.axhline(m_overall, linewidth=2, color='c')
    plt.xlabel('Date')
    plt.ylabel('Fraction of New Yorker bylines')
    plt.title(title)
    plt.xticks(takespread(x_spacing, MAX_X_TICKS),
               takespread(dates, MAX_X_TICKS), rotation=45)
    plt.yticks([i/10.0 for i in range(10)])
    plt.legend(('Overall female', 'Overall male', 'Female', 'Male'), loc='center right', fontsize='x-small')
    plt.autoscale()
    plt.show()

def plot_computable():
    # get data
    sizes = []
    durations_compute = []
    durations_overhead = []
    for p in client.eval.computables.find({"query.$comment.exp":"computable"}).sort("query.$comment.db-size",1):
        compute = p["computables"][1]["compute"]
        sizes.append(p["query"]["$comment"]["db-size"])
        durations_compute.append(compute * 1000.0)
        durations_overhead.append((p["total"]-compute) * 1000.0)
        
    durations_stack = np.row_stack((durations_overhead, durations_compute))
    
    with PdfPages('computable-durations.pdf') as pdf:
        # format plot
        #fig, ax = plt.subplots()

        plt.figure(figsize=(8,5))
        plt.xlabel('db size (#docs)')
        plt.ylabel('duration (ms)')
        plt.axis([0, 100000, 0.0, 80])
    
        # fill plot
        polys = plt.stackplot(sizes, durations_stack)
        
        #construct legend:
        legendProxies = []
        for poly in polys:
            legendProxies.append(plt.Rectangle((0, 0), 1, 1, fc=poly.get_facecolor()[0]))
        plt.legend(legendProxies, ["overhead", "compute time"], loc=2)
        
        # save plot
        # plt.show()
        pdf.savefig()
        plt.close()