Python numpy 模块，histogram2d() 实例源码

def plot_density_map(x, y, xbins, ybins, Nlevels=4, cbar=True, weights=None):

    Z = np.histogram2d(x, y, bins=(xbins, ybins), weights=weights)[0].astype(float).T

    # central values
    lt = get_centers_from_bins(xbins)
    lm = get_centers_from_bins(ybins)
    cX, cY = np.meshgrid(lt, lm)
    X, Y = np.meshgrid(xbins, ybins)

    im = plt.pcolor(X, Y, Z, cmap=plt.cm.Blues)
    plt.contour(cX, cY, Z, levels=nice_levels(Z, Nlevels), cmap=plt.cm.Greys_r)

    if cbar:
        cb = plt.colorbar(im)
    else:
        cb = None
    plt.xlim(xbins[0], xbins[-1])
    plt.ylim(ybins[0], ybins[-1])

    try:
        plt.tight_layout()
    except Exception as e:
        print(e)
    return plt.gca(), cb

def shot_heatmap(df,sigma = 1,log=False,player_pic=True,ax=None,cmap='jet'):
    '''
    This function plots a heatmap based on the shot chart.
    input - dataframe with x and y coordinates.
    optional - log (default false) plots heatmap in log scale. 
               player (default true) adds player's picture and name if true 
               sigma - the sigma of the Gaussian kernel. In feet (default=1)
    '''
    n,_,_ = np.histogram2d( 0.1*df['LOC_X'].values, 0.1*df['LOC_Y'].values,bins = [500, 500],range = [[-25,25],[-5.25,44.75]])
    KDE = ndimage.filters.gaussian_filter(n,10.0*sigma)
    N = 1.0*KDE/np.sum(KDE)
    if ax is None:
        ax = plt.gca(xlim = [30,-30],ylim = [-7,43],xticks=[],yticks=[],aspect=1.0)
    court(ax,outer_lines=True,color='black',lw=2.0,direction='down')
    ax.axis('off')
    if log:
        ax.imshow(np.rot90(np.log10(N+1)),cmap=cmap,extent=[25.0, -25.0, -5.25, 44.75])
    else:
        ax.imshow(np.rot90(N),cmap=cmap,extent=[25.0, -25.0, -5.25, 44.75])
    if player_pic:
        player_id = df.PLAYER_ID.values[0]
        pic = players_picture(player_id)
        ax.imshow(pic,extent=[15,25,30,37.8261])
    ax.text(0,-7,'By: Doingthedishes',color='white',horizontalalignment='center',fontsize=20,fontweight='bold')

def photonsToFrame(photonposframe,imagesize,background):
        pixels = imagesize
        edges = range(0, pixels+1)
            # HANDLE CASE FOR NO PHOTONS DETECTED AT ALL IN FRAME
        if photonposframe.size == 0:
            simframe = _np.zeros((pixels, pixels))
        else:
            xx = photonposframe[:, 0]
            yy = photonposframe[:, 1]

            simframe, xedges, yedges = _np.histogram2d(yy, xx, bins=(edges, edges))
            simframe = _np.flipud(simframe)  # to be consistent with render

        #simframenoise = noisy(simframe,background,noise)
        simframenoise = noisy_p(simframe, background)
        simframenoise[simframenoise > 2**16-1] = 2**16-1
        simframeout = _np.round(simframenoise).astype('<u2')

        return simframeout

def mask_locs(self):

        locs = self.locs[0]
        steps_x = len(self.xedges)
        steps_y = len(self.yedges)

        x_ind = np.floor((locs['x']-self.x_min)/(self.x_max-self.x_min)*steps_x)-1
        y_ind = np.floor((locs['y']-self.y_min)/(self.y_max-self.y_min)*steps_y)-1
        x_ind = x_ind.astype(int)
        y_ind = y_ind.astype(int)

        index = self.mask[y_ind,x_ind].astype(bool)
        self.index_locs = locs[index]
        self.index_locs_out = locs[~index]

        H_new, xedges, yedges = np.histogram2d(self.index_locs['x'], self.index_locs['y'], bins=(self.xedges, self.yedges))
        self.H_new = H_new.T  # Let each row list bins with common y range.

        ax4 = self.figure.add_subplot(144, title='Masked image')
        ax4.imshow(self.H_new, interpolation='nearest', origin='low',extent=[self.xedges[0], self.xedges[-1], self.yedges[0], self.yedges[-1]])
        ax4.grid(False)
        self.mask_exists = 1
        self.saveButton.setEnabled(True)
        self.canvas.draw()

def calc_mutual_information(x, y, bins):
    try:
        if bins == -1:
            bins = doane_bin(x)
        if bins == np.inf:
            bins = sturges_bin(x)
    except ValueError:
        bins = 10.0
    # print "bins", bins
    try:
        c_xy = np.histogram2d(x, y, bins)[0]
        mi = metrics.mutual_info_score(None, None, contingency=c_xy)
        # print "success"
    except Exception,e: 
        print "error with mi calc", str(e)
        mi = 0
    return mi

def signal_gaussian(
            signal_location=np.array([61, 21])*u.deg,
            fov_center=np.array([60, 20])*u.deg,
            width=0.05*u.deg,
            signal_events=80,
            bins=[80, 80],
            fov=4*u.deg,
        ):

    # reshape so if signal_events = 1 the array can be indexed in the same way.
    signal = multivariate_normal.rvs(
                mean=signal_location.value,
                cov=width.value,
                size=signal_events
                ).reshape(signal_events, 2)
    r = np.array([fov_center - fov/2, fov_center + fov/2]).T

    signal_hist, _, _ = np.histogram2d(signal[:, 0], signal[:, 1], bins=bins, range=r)
    return signal_hist

def plot_heatmap(ax, xpoints, ypoints, nbins, title=None, maxcount=None):
    ''' Plot a heatmap of the given data on on the given axes. '''
    # imshow expects y,x for the image, but x,y for the extents,
    # so we have to manage that here...
    bins = np.concatenate( (np.arange(0,1.0,1.0/nbins), [1.0]) )
    heatmap, yedges, xedges = np.histogram2d(ypoints, xpoints, bins=bins)
    extent = [xedges[0],xedges[-1], yedges[0], yedges[-1]]
    # make sure we always show the full extent of the tank and the full extent of the data,
    # whichever is wider.
    ax.set_xlim(min(0, xedges[0]), max(1, xedges[-1]))
    ax.set_ylim(min(0, yedges[0]), max(1, yedges[-1]))
    if title:
        ax.set_title(title)
    if maxcount is not None:
        norm = Normalize(0, maxcount)
    else:
        norm = None
    return ax.imshow(heatmap, extent=extent, cmap=plt.get_cmap('hot'), origin='lower', interpolation='nearest', norm=norm)

def drawSmoothCatalog(self, catalog, label=None, **kwargs):
        ax = plt.gca()
        ra,dec = catalog.ra_dec
        x, y = sphere2image(self.ra,self.dec,ra,dec)

        delta_x = self.radius/100.
        smoothing = 2*delta_x
        bins = numpy.arange(-self.radius, self.radius + 1.e-10, delta_x)
        h, xbins, ybins = numpy.histogram2d(x, y, bins=[bins, bins])
        blur = nd.filters.gaussian_filter(h.T, smoothing / delta_x)

        defaults = dict(cmap='gray_r',rasterized=True)
        kwargs = dict(defaults.items()+kwargs.items())

        xx,yy = np.meshgrid(xbins,ybins)
        im = drawProjImage(xx,yy,blur,coord='C',**kwargs)

        if label:
            plt.text(0.05, 0.95, label, fontsize=10, ha='left', va='top', 
                     color='k', transform=pylab.gca().transAxes,
                     bbox=dict(facecolor='white', alpha=1., edgecolor='none'))

def visualize2D(fig, ax, xs, ys, bins=200,
                xlabel='x', ylabel='y',
                xlim=None, ylim=None):
    H, xedges, yedges = numpy.histogram2d(xs, ys, bins)
    H = numpy.rot90(H)
    H = numpy.flipud(H)
    Hmasked = numpy.ma.masked_where(H == 0, H)

    ax.pcolormesh(xedges, yedges, Hmasked)

    ax.set_xlabel(xlabel)
    ax.set_ylabel(ylabel)

    if xlim is None:
        xlim = (min(xs), max(xs))
    if ylim is None:
        ylim = (min(ys), max(ys))
    ax.set_xlim(*xlim)
    ax.set_ylim(*ylim)
    fig.colorbar(pyplot.contourf(Hmasked))

def test_zoom():
    edges = pixel_edges(jet_size=1, pixel_size=(0.1, 0.1), border_size=0.25)
    assert_equal(edges[0].shape, (26,))
    assert_equal(edges[1].shape, (26,))
    image, _, _ = np.histogram2d(
        np.random.normal(0, 1, 1000), np.random.normal(0, 1, 1000),
        bins=(edges[0], edges[1]))
    assert_true(image.sum() > 0)
    assert_equal(image.shape, (25, 25))

    # zooming with factor 1 should not change anything
    image_zoomed = zoom_image(image, 1, out_width=25)
    assert_array_almost_equal(image, image_zoomed)

    assert_raises(ValueError, zoom_image, image, 0.5)

    # test out_width
    assert_equal(zoom_image(image, 1, out_width=11).shape, (11, 11))

    image_zoomed = zoom_image(image, 2, out_width=25)
    assert_true(image.sum() < image_zoomed.sum())

def heatmap (d, bins=(100, 100), smoothing=1.3, cmap='jet'):
  def getx (pt):
    return pt.coords[0][0]

  def gety (pt):
    return pt.coords[0][1]

  x = list(d.geometry.apply(getx))
  y = list(d.geometry.apply(gety))
  heatmap, xedges, yedges = np.histogram2d(y, x, bins=bins)
  extent = [yedges[0], yedges[-1], xedges[-1], xedges[0]]  # bin edges along the x and y dimensions, ordered

  # why are we taking log?
  logheatmap = np.log(heatmap)
  logheatmap[np.isneginf(logheatmap)] = 0
  logheatmap = ndimage.filters.gaussian_filter(logheatmap, smoothing, mode='nearest')


  return (logheatmap, extent)

def DensityHistogram(xypoints, numbins):

     xpoints = map(lambda (x, y): x, xypoints)
     ypoints = map(lambda (x, y): y, xypoints)
     minx, maxx, miny, maxy = min(xpoints), max(xpoints), \
                              min(ypoints), max(ypoints)
     xedges = np.arange(minx, maxx, (maxx - minx) / float(numbins))
     yedges = np.arange(miny, maxy, (maxy - miny) / float(numbins))
     H, xedges, yedges = np.histogram2d(ypoints, xpoints, bins = (xedges, yedges))

     fig = plt.figure(figsize=(7, 3))
     ax = fig.add_subplot(132)
     ax.set_title('pcolormesh: exact bin edges')
     X, Y = np.meshgrid(xedges, yedges)
     ax.pcolormesh(X, Y, H)
     ax.set_aspect('equal')
     #plt.savefig('./output/foo.png', bbox_inches='tight')
     #plt.show()

     g = histogram([xpoints, ypoints])
     g.save('./output/foo2.png')

## def

def addDistributions(self,Tuple):
        import numpy
        selidxs=[]

        ytuple=Tuple[self.nameY]
        xtuple=Tuple[self.nameX]

        useonlyoneclass=len(self.classes)==1 and len(self.classes[0])==0

        if not useonlyoneclass:
            labeltuple=Tuple[self.classes]
            for c in self.classes:
                selidxs.append(labeltuple[c]>0)
        else:
            selidxs=[numpy.zeros(len(xtuple),dtype='int')<1]


        for i in range(len(self.classes)):
            tmphist,xe,ye=numpy.histogram2d(xtuple[selidxs[i]],ytuple[selidxs[i]],[self.axisX,self.axisY],normed=True)
            self.xedges=xe
            self.yedges=ye
            if len(self.distributions)==len(self.classes):
                self.distributions[i]=self.distributions[i]+tmphist
            else:
                self.distributions.append(tmphist)

def heatmap(self, get_ball_var):

        heat_values = get_ball_var('ball_position_history')

        # Generate some test data
        x = np.random.randn(8873)
        y = np.random.randn(8873)

        heatmap, xedges, yedges = np.histogram2d(x, y, bins=50)
        extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]

        # x = np.random.randn(100000)
        y = np.random.randn(100000)

        #  print(y)

        # plt.hist2d(HeatValues[0],HeatValues[1],bins=100);

        # plt.clf()
        # plt.imshow(heatmap, extent=extent)
        # plt.show()

def _init_read_free(self):
        # subverted... interpret self.filename as a numpy array
        try:
            FEC = self.filename  # FreeEnergyContainer?
            F = FEC.F
        except AttributeError:
            super(DerivedFreeEnergy,self)._init_read_free()
            return
        self._midpoints = (FEC.X, FEC.Y)
        self._X = FEC.X
        self._Y = FEC.Y
        self._free_energy = numpy.ma.array(F, mask=numpy.logical_not(numpy.isfinite(F)),
                                           fill_value=1000);
        # reconstruct what input histogram2d would need
        self._edges = (self._mid2edges(self._X),    # NMP bin edges
                       self._mid2edges(self._Y))    # LID bin edges

def plotAgainstGFP_hist2d(self):
        fig1 = pylab.figure(figsize = (20, 15))
        print len(self.GFP)
        for i in xrange(min(len(data.cat), 4)):
            print len(self.GFP[self.categories == i])
            vect = []
            pylab.subplot(2,2,i+1)
            pop = self.GFP[self.categories == i]
            print "cat", i, "n pop", len(self.GFP[(self.categories == i) & (self.GFP > -np.log(12.5))])
            H, xedges, yedges = np.histogram2d(self.angles[self.categories == i], self.GFP[self.categories == i], bins = 10)
            hist = pylab.hist2d(self.GFP[self.categories == i], self.angles[self.categories == i], bins = 10, cmap = pylab.cm.Reds, normed = True)
            pylab.clim(0.,0.035)
            pylab.colorbar()
            pylab.title(data.cat[i])
            pylab.xlabel('GFP score')
            pylab.ylabel('Angle (degree)')
            pylab.xlim([-4.2, -1])
        pylab.show()

def calculate_mutualinformation(x, y, bins):
    pxy, _, _ = np.histogram2d(x, y, bins)
    px, _, = np.histogram(x, bins)
    py, _, = np.histogram(y, bins)

    pxy = pxy/np.sum(pxy)
    px = px/np.sum(px)
    py = py/np.sum(py)

    pxy = pxy[np.nonzero(pxy)]
    px = px[np.nonzero(px)]
    py = py[np.nonzero(py)]

    hxy = -np.sum(pxy*np.log2(pxy))
    hx = -np.sum(px*np.log2(px))
    hy = -np.sum(py*np.log2(py))

    MI = hx+hy-hxy

    return MI

def test_f32_rounding(self):
        # gh-4799, check that the rounding of the edges works with float32
        x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
        y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
        counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
        assert_equal(counts_hist.sum(), 3.)

def edgeplot(self, TT, ps):
        for ei,X in enumerate(self.edges):
            (i, j) = X[:2]
            Ta = TT[i]
            Tb = TT[j]
            plt.clf()
            if len(Ta) > 1000:
                nbins = 101
                ra = np.hstack((Ta.ra, Tb.ra))
                dec = np.hstack((Ta.dec, Tb.dec))
                H,xe,ye = np.histogram2d(ra, dec, bins=nbins)
                (matchRA, matchDec, dr,dd) = self.edge_matches(ei, goodonly=True)
                G,xe,ye = np.histogram2d(matchRA, matchDec, bins=(xe,ye))
                assert(G.shape == H.shape)
                img = antigray(H / H.max())
                img[G>0,:] = matplotlib.cm.hot(G[G>0] / H[G>0])
                ax = setRadecAxes(xe[0], xe[-1], ye[0], ye[-1])
                plt.imshow(img, extent=(min(xe), max(xe), min(ye), max(ye)),
                           aspect='auto', origin='lower', interpolation='nearest')
                plt.axis(ax)

            else:
                self.plotallstars([Ta,Tb])
                self.plotmatchedstars(ei)
                plt.xlabel('RA (deg)')
                plt.ylabel('Dec (deg)')
            ps.savefig()

    # one plot per edge

def gen_hist(self, event=None):
        try:
            xnum = int(self.x_axis_num.text())
            ynum = int(self.y_axis_num.text())
        except ValueError:
            sys.stderr.write('Need axes numbers to be integers\n')
            return
        self.hist2d, self.binx, self.biny = np.histogram2d(self.embed[:,xnum], self.embed[:,ynum], bins=100)

        delx = self.binx[1] - self.binx[0]
        dely = self.biny[1] - self.biny[0]
        self.binx = np.insert(self.binx, 0, [self.binx[0]-6*delx, self.binx[0]-delx])
        self.binx = np.insert(self.binx, len(self.binx), [self.binx[-1]+delx, self.binx[-1]+6*delx])
        self.biny = np.insert(self.biny, 0, [self.biny[0]-6*dely, self.biny[0]-dely])
        self.biny = np.insert(self.biny, len(self.biny), [self.biny[-1]+dely, self.biny[-1]+6*dely])

def _compute_occupancy(self):

        x, y = self.trans_func(self._extern, at=self._bst.bin_centers)

        xmin = self.xbins[0]
        xmax = self.xbins[-1]
        ymin = self.ybins[0]
        ymax = self.ybins[-1]

        occupancy, _, _ = np.histogram2d(x, y, bins=[self.xbins, self.ybins], range=([[xmin, xmax], [ymin, ymax]]))

        return occupancy

def test_f32_rounding(self):
        # gh-4799, check that the rounding of the edges works with float32
        x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
        y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
        counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
        assert_equal(counts_hist.sum(), 3.)

def from_values(cls, x, y, weights=None, nbins=200, x_name=None, y_name=None):

        """
        This function ...
        :param x:
        :param y:
        :param weights:
        :param nbins:
        :param x_name:
        :param y_name:
        :return:
        """

        #rBins_F, FBins_r = getRadBins(x, y, 1, weights)
        #rBins_F[rBins_F > 25] = np.nan

        rBins_F = None
        FBins_r = None

        #print("rBins_F", rBins_F)
        #print("FBins_r", FBins_r)

        # Estimate the 2D histogram
        H, xedges, yedges = np.histogram2d(x, y, bins=nbins, normed=True, weights=weights)

        # H needs to be rotated and flipped
        H = np.rot90(H)
        H = np.flipud(H)

        # Mask zeros
        Hmasked = np.ma.masked_where(H == 0, H)  # Mask pixels with a value of zero

        return cls(Hmasked, xedges, yedges, rBins_F, FBins_r, x_name, y_name)

    # -----------------------------------------------------------------

def from_values(cls, x, y, weights=None, nbins=200, x_name=None, y_name=None):

        """
        This function ...
        :param x:
        :param y:
        :param weights:
        :param nbins:
        :param x_name:
        :param y_name:
        :return:
        """

        #rBins_F, FBins_r = getRadBins(x, y, 1, weights)
        #rBins_F[rBins_F > 25] = np.nan

        rBins_F = None
        FBins_r = None

        #print("rBins_F", rBins_F)
        #print("FBins_r", FBins_r)

        # Estimate the 2D histogram
        H, xedges, yedges = np.histogram2d(x, y, bins=nbins, normed=True, weights=weights)

        # H needs to be rotated and flipped
        H = np.rot90(H)
        H = np.flipud(H)

        # Mask zeros
        Hmasked = np.ma.masked_where(H == 0, H)  # Mask pixels with a value of zero

        return cls(Hmasked, xedges, yedges, rBins_F, FBins_r, x_name, y_name)

    # -----------------------------------------------------------------

def get_hist_node2vec(emb,d,my_min,my_max,definition):
    # d should be an even integer
    img_dim = int(np.arange(my_min, my_max+0.05,(my_max+0.05-my_min)/float(definition*(my_max+0.05-my_min))).shape[0]-1)
    my_bins = np.linspace(my_min,my_max,img_dim) #  to have middle bin centered on zero
    Hs = []
    for i in range(0,d,2):
        H, xedges, yedges = np.histogram2d(x=emb[:,i],y=emb[:,i+1],bins=my_bins, normed=False)
        Hs.append(H)
    Hs = np.array(Hs)    
    return  Hs

def get_hist_node2vec(emb,d,my_min,my_max,definition):
    # d should be an even integer
    img_dim = int(np.arange(my_min, my_max+0.05,(my_max+0.05-my_min)/float(definition*(my_max+0.05-my_min))).shape[0]-1)
    my_bins = np.linspace(my_min,my_max,img_dim) #  to have middle bin centered on zero
    Hs = []
    for i in range(0,d,2):
        H, xedges, yedges = np.histogram2d(x=emb[:,i],y=emb[:,i+1],bins=my_bins, normed=False)
        Hs.append(H)
    Hs = np.array(Hs)    
    return Hs

def histogram2dstd(data, std = 6, bins = 50):
  """Create histogram resolving distribution according to std"""

  ## calculate standard deviations in each direction
  stds = np.std(data[:,0:-2], axis = 0);
  means = np.mean(data[:,0:-2], axis = 0);

  rngs = [[m- std * s, m + std * s] for m,s in itertools.izip(means,stds)];  

  hist = np.histogram2d(data[:,0], data[:,1], bins = bins, range = rngs);

  return hist;

def mutual_info(x, y, bins=10):
    counts_xy, bins_x, bins_y = np.histogram2d(x, y, bins=(bins, bins))
    counts_x, bins = np.histogram(x, bins=bins)
    counts_y, bins = np.histogram(y, bins=bins)

    counts_xy += 1
    counts_x += 1
    counts_y += 1
    P_xy = counts_xy / np.sum(counts_xy, dtype=float)
    P_x = counts_x / np.sum(counts_x, dtype=float)
    P_y = counts_y / np.sum(counts_y, dtype=float)

    I_xy = np.sum(P_xy * np.log2(P_xy / (P_x.reshape(-1, 1) * P_y)))

    return I_xy / (entropy(counts_x) + entropy(counts_y))

def generate_image(self):
        locs = self.locs[0]
        self.stepsize = 1/self.oversampling
        self.xedges = np.arange(self.x_min,self.x_max,self.stepsize)
        self.yedges = np.arange(self.y_min,self.y_max,self.stepsize)
        H, xedges, yedges = np.histogram2d(locs['x'], locs['y'], bins=(self.xedges, self.yedges))
        H = H.T  # Let each row list bins with common y range.
        self.H = H

def getHSHistograms_2D(HSVimage):
    (Width, Height) = HSVimage.shape[1], HSVimage.shape[0]    
    H, xedges, yedges = numpy.histogram2d(numpy.reshape(HSVimage[:,:,0], Width*Height), numpy.reshape(HSVimage[:,:,1], Width*Height), bins=(range(-1,180, 30), range(-1, 256, 64)))
    H = H / numpy.sum(H);
    return (H, xedges, yedges)

def test_f32_rounding(self):
        # gh-4799, check that the rounding of the edges works with float32
        x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
        y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
        counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
        assert_equal(counts_hist.sum(), 3.)

def compute_histogram(data, bins=36):
    h, x, y = np.histogram2d(data[data.columns[0]], data[data.columns[1]], bins=bins, normed=True)
    xc = (x[:-1] + x[1:]) / 2
    yc = (y[:-1] + y[1:]) / 2
    coords = np.array([(xi, yi) for xi in xc for yi in yc])
    theta = coords[:, 0]
    r = coords[:, 1]
    return h.flatten(), theta, r

def create_cube(df, bins, bin_range):
    _, x_edges, y_edges = np.histogram2d(
        df.alt, df.az, bins=bins, range=bin_range)
    slices = []
    N = 100
    for df in np.array_split(df, N):
        H, _, _ = np.histogram2d(df.alt, df.az, bins=[
                                 x_edges, y_edges], range=bin_range)
        slices.append(H)

    slices = np.array(slices)
    return slices

def create_cube(self, points):
        t, alt, az = points.T

        alt = alt.astype(np.float)
        az = az.astype(np.float)

        _, x_edges, y_edges = np.histogram2d(
                    alt,
                    az,
                    bins=self.bins,
                    range=self.bin_range
        )

        slices = []
        timestamps = []
        for indeces in np.array_split(np.arange(0, len(points)), self.slices_per_cube):
            timestamps.append(t[indeces][0])
            H, _, _ = np.histogram2d(
                            alt[indeces],
                            az[indeces],
                            bins=[x_edges, y_edges],
                            range=self.bin_range)
            slices.append(H)

        slices = np.array(slices)
        timestamps = np.array(timestamps)

        return timestamps, slices

def myplot(x, y, nb=32, xsize=500, ysize=500):
    heatmap, xedges, yedges = np.histogram2d(x, y, bins=nb)
    extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]
    return heatmap.T, extent

def summarizeMap(mapDataFrame):
    latlon  = mapDataFrame[['meta_latitude','meta_longitude']]
    latlon = latlon[pd.notnull(latlon['meta_latitude'])]
    latlon = latlon[pd.notnull(latlon['meta_longitude'])]
    minLat = np.amin(latlon['meta_latitude'])
    maxLat = np.amax(latlon['meta_latitude'])
    minLon = np.amin(latlon['meta_longitude'])
    maxLon = np.amax(latlon['meta_longitude'])
    if len(latlon) > 1:
        latlon_map = np.histogram2d(x=latlon['meta_longitude'],y=latlon['meta_latitude'],bins=[36,18], range=[[minLon, maxLon], [minLat, maxLat]])
    else:
        latlon_map = np.histogram2d(x=[],y=[],bins=[36,18], range=[[-180, 180], [-90, 90]])
    #define latlon map color bin info
    percentiles, countRanges, fillColors = getMapBins(latlon_map[0], num_bins=10)
    # range should be flexible to rules in DatasetSearchSummary
    # latlon_map[0] is the lonxlat (XxY) array of counts; latlon_map[1] is the nx/lon bin starts; map[2] ny/lat bin starts
    lonstepsize = (latlon_map[1][1]-latlon_map[1][0])/2
    latstepsize = (latlon_map[2][1]-latlon_map[2][0])/2
    maxMapCount = np.amax(latlon_map[0])
    map_data = []
    for lon_ix,lonbin in enumerate(latlon_map[0]):
        for lat_ix,latbin in enumerate(lonbin):
            #[latlon_map[2][ix]+latstepsize for ix,latbin in enumerate(latlon_map[0][0])]
            lat = latlon_map[2][lat_ix]+latstepsize
            lon = latlon_map[1][lon_ix]+lonstepsize
            value = latbin
            buffer=0.0001
            #left-bottom, left-top, right-top, right-bottom, left-bottom
            polygon = [[lon-lonstepsize+buffer,lat-latstepsize+buffer], [lon-lonstepsize+buffer,lat+latstepsize-buffer], [lon+lonstepsize-buffer,lat+latstepsize-buffer], [lon+lonstepsize-buffer,lat-latstepsize+buffer], [lon-lonstepsize,lat-latstepsize]]
            bin_ix = np.amax(np.argwhere(np.array(percentiles)<=sp.percentileofscore(latlon_map[0].flatten(), value)))
            fillColor = fillColors[bin_ix]
            map_data.append({"lat":lat,"lon":lon,"count":value,"polygon":polygon, "fillColor":fillColor})
    map_legend_info = {"ranges":countRanges, "fills":fillColors}
    return (map_data,map_legend_info)

# Query Construction Helpers / Data Retrieval
# Based on a rule (field name, comparator and value), add a filter to a query object
# TODO add some better documentation here on what each type is

def hinton(W, bg='grey', facecolors=('w', 'k')):
    """Draw a hinton diagram of the matrix W on the current pylab axis

    Hinton diagrams are a way of visualizing numerical values in a matrix/vector,
    popular in the neural networks and machine learning literature. The area
    occupied by a square is proportional to a value's magnitude, and the colour
    indicates its sign (positive/negative).

    Example usage:

        R = np.random.normal(0, 1, (2,1000))
        h, ex, ey = np.histogram2d(R[0], R[1], bins=15)
        hh = h - h.T
        hinton.hinton(hh)
    """
    M, N = W.shape
    square_x = np.array([-.5, .5, .5, -.5])
    square_y = np.array([-.5, -.5, .5, .5])

    ioff = False
    if plt.isinteractive():
        plt.ioff()
        ioff = True

    plt.fill([-.5, N - .5, N - .5, - .5], [-.5, -.5, M - .5, M - .5], bg)
    Wmax = np.abs(W).max()
    for m, Wrow in enumerate(W):
        for n, w in enumerate(Wrow):
            c = plt.signbit(w) and facecolors[1] or facecolors[0]
            plt.fill(square_x * w / Wmax + n, square_y * w / Wmax + m, c, edgecolor=c)

    plt.ylim(-0.5, M - 0.5)
    plt.xlim(-0.5, M - 0.5)

    if ioff is True:
        plt.ion()

    plt.draw_if_interactive()

def test_f32_rounding(self):
        # gh-4799, check that the rounding of the edges works with float32
        x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
        y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
        counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
        assert_equal(counts_hist.sum(), 3.)

def twoDimensionalHistogram(title, title_x, title_y,
                            z, bins_x, bins_y,
                            lim_x=None, lim_y=None,
                            vmin=None, vmax=None):
    """
    Create a two-dimension histogram plot or binned map.

    If using the outputs of numpy.histogram2d, remember to transpose the histogram.

    INPUTS
    """
    pylab.figure()

    mesh_x, mesh_y = numpy.meshgrid(bins_x, bins_y)

    if vmin != None and vmin == vmax:
        pylab.pcolor(mesh_x, mesh_y, z)
    else:
        pylab.pcolor(mesh_x, mesh_y, z, vmin=vmin, vmax=vmax)
    pylab.xlabel(title_x)
    pylab.ylabel(title_y)
    pylab.title(title)
    pylab.colorbar()

    if lim_x:
        pylab.xlim(lim_x[0], lim_x[1])
    if lim_y:
        pylab.ylim(lim_y[0], lim_y[1])

############################################################

def drawHessDiagram(self,catalog=None):
        ax = plt.gca()
        if not catalog: catalog = self.get_stars()

        r_peak = self.kernel.extension
        angsep = ugali.utils.projector.angsep(self.ra, self.dec, catalog.ra, catalog.dec)
        cut_inner = (angsep < r_peak)
        cut_annulus = (angsep > 0.5) & (angsep < 1.) # deg

        mmin, mmax = 16., 24.
        cmin, cmax = -0.5, 1.0
        mbins = np.linspace(mmin, mmax, 150)
        cbins = np.linspace(cmin, cmax, 150)

        color = catalog.color[cut_annulus]
        mag = catalog.mag[cut_annulus]

        h, xbins, ybins = numpy.histogram2d(color, mag, bins=[cbins,mbins])
        blur = nd.filters.gaussian_filter(h.T, 2)
        kwargs = dict(extent=[xbins.min(),xbins.max(),ybins.min(),ybins.max()],
                      cmap='gray_r', aspect='auto', origin='lower', 
                      rasterized=True, interpolation='none')
        ax.imshow(blur, **kwargs)

        pylab.scatter(catalog.color[cut_inner], catalog.mag[cut_inner], 
                      c='red', s=7, edgecolor='none')# label=r'$r < %.2f$ deg'%(r_peak))
        ugali.utils.plotting.drawIsochrone(self.isochrone, c='b', zorder=10)
        ax.set_xlim(-0.5, 1.)
        ax.set_ylim(24., 16.)
        plt.xlabel(r'$g - r$')
        plt.ylabel(r'$g$')
        plt.xticks([-0.5, 0., 0.5, 1.])
        plt.yticks(numpy.arange(mmax - 1., mmin - 1., -1.))

        radius_string = (r'${\rm r}<%.1f$ arcmin'%( 60 * r_peak))
        pylab.text(0.05, 0.95, radius_string, 
                   fontsize=10, ha='left', va='top', color='red', 
                   transform=pylab.gca().transAxes,
                   bbox=dict(facecolor='white', alpha=1., edgecolor='none'))

def histogram2d(self,distance_modulus=None,delta_mag=0.03,steps=10000):
        """
        Return a 2D histogram the isochrone in mag-mag space.

        Parameters:
        -----------
        distance_modulus : distance modulus to calculate histogram at
        delta_mag : magnitude bin size
        mass_steps : number of steps to sample isochrone at

        Returns:
        --------
        bins_mag_1 : bin edges for first magnitude
        bins_mag_2 : bin edges for second magnitude
        isochrone_pdf : weighted pdf of isochrone in each bin
        """
        if distance_modulus is not None:
            self.distance_modulus = distance_modulus

        # Isochrone will be binned, so might as well sample lots of points
        mass_init,mass_pdf,mass_act,mag_1,mag_2 = self.sample(mass_steps=steps)

        #logger.warning("Fudging intrinisic dispersion in isochrone.")
        #mag_1 += np.random.normal(scale=0.02,size=len(mag_1))
        #mag_2 += np.random.normal(scale=0.02,size=len(mag_2))

        # We cast to np.float32 to save memory
        bins_mag_1 = np.arange(self.mod+mag_1.min() - (0.5*delta_mag),
                               self.mod+mag_1.max() + (0.5*delta_mag),
                               delta_mag).astype(np.float32)
        bins_mag_2 = np.arange(self.mod+mag_2.min() - (0.5*delta_mag),
                               self.mod+mag_2.max() + (0.5*delta_mag),
                               delta_mag).astype(np.float32)

        # ADW: Completeness needs to go in mass_pdf here...
        isochrone_pdf = np.histogram2d(self.mod + mag_1,
                                       self.mod + mag_2,
                                       bins=[bins_mag_1, bins_mag_2],
                                       weights=mass_pdf)[0].astype(np.float32)

        return isochrone_pdf, bins_mag_1, bins_mag_2

def pixelize(jet_csts, edges, cutoff=0.1):
    """Return eta-phi histogram of transverse energy deposits.

    Optionally set all instensities below cutoff to zero.
    """
    image, _, _ = np.histogram2d(
        jet_csts['eta'], jet_csts['phi'],
        bins=(edges[0], edges[1]),
        weights=jet_csts['ET'] * (jet_csts['ET'] > cutoff))
    return image

def update_data(self):
        var = getattr(self._sim, self._variable)[:,0:2]

        mask = None
        if self._sub_domain:
            pos = self._sim.positions
            mask_x = np.logical_or(pos[:, 0] <= self._sub_domain[0][0],
                                   pos[:, 0] >= self._sub_domain[0][1])
            mask_y = np.logical_or(pos[:, 1] <= self._sub_domain[1][0],
                                   pos[:, 1] >= self._sub_domain[1][1])
            mask = np.logical_or(mask_x, mask_y)
        if self._particle_type is not None:
            if mask is None:
                mask = (self._sim.types != self._particle_type)
            else:
                mask = np.logical_or(mask, (self._sim.types != self._particle_type))

        if mask is not None:
            tiledmask = np.transpose(np.tile(mask, (2, 1)))
            var = ma.masked_array(var, tiledmask)
            var = var.compressed()
            var = var.reshape([len(var)//2, 2])

        hist, self._x_edges, self._y_edges = np.histogram2d(var[:, 0], var[:, 1],
                                                            bins=self._nr_of_bins, range=self._hist_range)
        if self._window is not None:
            self._dataHistory.append(hist)
            if len(self._dataHistory) > self._window:
                del self._dataHistory[0]
            self._histogram_array = sum(self._dataHistory)
        else:
            self._histogram_array += hist

def test_f32_rounding(self):
        # gh-4799, check that the rounding of the edges works with float32
        x = np.array([276.318359, -69.593948, 21.329449], dtype=np.float32)
        y = np.array([5005.689453, 4481.327637, 6010.369629], dtype=np.float32)
        counts_hist, xedges, yedges = np.histogram2d(x, y, bins=100)
        assert_equal(counts_hist.sum(), 3.)

def get_heatmaps(neuron_list, spikes, pos, num_bins=100):
    """ Gets the 2D heatmaps for firing of a given set of neurons.

    Parameters
    ----------
    neuron_list : list of ints
        These will be the indices into the full list of neuron spike times
    spikes : list
        Containing nept.SpikeTrain for each neuron.
    pos : nept.Position
        Must be 2D.
    num_bins : int
        This will specify how the 2D space is broken up, the greater the number
        the more specific the heatmap will be. The default is set at 100.

    Returns
    -------
    heatmaps : dict of lists
        Where the key is the neuron number and the value is the heatmap for
        that individual neuron.
    """
    if not pos.dimensions == 2:
        raise ValueError("pos must be two-dimensional")

    xedges = np.linspace(np.min(pos.x)-2, np.max(pos.x)+2, num_bins+1)
    yedges = np.linspace(np.min(pos.y)-2, np.max(pos.y)+2, num_bins+1)

    heatmaps = dict()
    count = 1
    for neuron in neuron_list:
        field_x = []
        field_y = []
        for spike in spikes[neuron].time:
            spike_idx = find_nearest_idx(pos.time, spike)
            field_x.append(pos.x[spike_idx])
            field_y.append(pos.y[spike_idx])
            heatmap, out_xedges, out_yedges = np.histogram2d(field_x, field_y, bins=[xedges, yedges])
        heatmaps[neuron] = heatmap.T
        print(str(neuron) + ' of ' + str(len(neuron_list)))
        count += 1
    return heatmaps

def test_image():
    import matplotlib.pyplot as plt

    con = config.Config()
    data = DataGenerator(con)
    xedges = [_ / 7 for _ in range(-14, 15)]
    yedges = [_ / 7 for _ in range(-14, 15)]
    image_data = {}
    for x, y in data.get_train_data(1):
        e, v = scipy.linalg.eigh(
            x.values.reshape((10, 10)))  # np.linalg.eig will return the complex data sometimes...

        for i in range(1, len(v)):
            new_v = preprocessing.scale(v[i])

            for k in range(0, len(new_v), 2):
                if k not in image_data:
                    image_data[k] = {}
                    image_data[k][0] = [new_v[k]]
                    image_data[k][1] = [new_v[k + 1]]
                else:
                    image_data[k][0].append(new_v[k])
                    image_data[k][1].append(new_v[k + 1])

        for k in image_data.keys():
            H, new_xedges, new_yedges = np.histogram2d(image_data[k][0], image_data[k][1], bins=(xedges, yedges))
            print(H)
            plt.imshow(H, cmap=plt.cm.gray, interpolation='nearest', origin='low',
                       extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
            plt.show()