Log Scale Matplotlib PatchCollection Colors

Question

I have a function that generates a heterogeneous mesh and then plots the patches. It specifies the lower and upper x and y edge for every bin. For example, a single bin is defined by the vector [x0, x1, y0, y1]. These coordinates translate to a bin:

    y1|---------|   
      |         |  
      |   bin   | 
      |         |
    y0|---------|
     x0         x1   

I have an (Nx4) mesh that contains N bins with [x0, x1, y0, y1] columns. To plot the data, I do the following:

z_plot  = z_stat / (dx * dy)     # ``z_stat`` is a calculated z-value 
z_plot  = z_plot / z_plot.max()  # for any given bin.

colors = mpl.cm.jet(z_plot)                   # Let fill data be white.
colors[z_stat == fill] = (1.0, 1.0, 1.0, 1.0) # fill=-9999.0, typically.

dx = mesh[:, 1] - mesh[:, 0]  # x1-x0
dy = mesh[:, 3] - mesh[:, 2]  # y1-y0.

xy = zip(mesh[:, 0], mesh[:, 2])  # (x,y) coordinates of each
                                  # bin's lower left corner.

patches = [mpl.patches.Rectangle(xy[i], dx[i], dy[i],         # I dont want
                                 ec=None, lw=0, fc=colors[i]) # visible edges.
            for i in range(mesh.shape[0])
          ]

patches = mpl.collections.PatchCollection(patches, match_original=True)
ax.add_collection(patches)

if z_stat is not None:

    kwargs = {'orientation': 'vertical'}
    cax, kw = _mpl.colorbar.make_axes_gridspec(plot_ax, **kwargs)

    cbar = mpl.colorbar.ColorbarBase(cax, cmap=_mpl.cm.jet)

This is the result:

This question does something similar, but without the logscale colors. I don't know how to get the colors to log scale. Simply passing something like mpl.colors.LogNorm() to mpl.colorbar.ColorbarBase() did not work for me.

EDIT 1: Generating the mesh.

I have a function that generates a heterogeneous mesh and then plots the patches. It starts with a 2D array:

mesh = [[x00, x10, y00, y01], 
        [x10, x11, y10, y11], 
        ..., 
        [xN0, xN1, yN0, yN1]] 

I read through the mesh and divide each bin in four:

#    y1|----|----|          x0, x1, y0, y1 = mesh[i, :]
#      | p4 | p3 |          xh = [x0 + .5*(x1-x0)]
#      |----|----| <- yh    yh = [y0 + .5 *(y1-y0)]
#      | p1 | p2 |
#    y0|----|----|
#     x0    ^-xh x1       

If each of [p1, p2, p3, p4] have more than the minimum number of data points (e.g. 50), I replace row [x0, x1, y0, y1] with this array:

        new_mesh = _np.array([[x0, xh, xh, x0],  # Define the 16 edges of  
                              [xh, x1, x1, xh],  # the 4 new bins that are  
                              [y0, y0, yh, yh],  # going to replace the bin 
                              [yh, yh, y1, y1]]  # originally defined by 
                            ).T                  # [x0, x1, y0, y1].

        if i == 0:  # 0th edge is a special case for indexing.

            mesh_h = _np.concatenate([new_mesh, mesh[1:]])

        else:

            mesh_h = _np.concatenate([mesh[:i], new_mesh, mesh[i+1:]])         


        mesh = mesh_h  # Set the new edges.

Answer 1

Although I can't test your exact case as you've not provided an independently runnable example you should (if my understanding of your desired behaviour is correct) be able to accomplish what you want as follows.

Firstly edit this line to remove the manual setting of the colour and edge information:

patches = [mpl.patches.Rectangle(xy[i], dx[i], dy[i],         # I dont want
                                 ec=None, lw=0, fc=colors[i]) # visible edges.
            for i in range(mesh.shape[0])
          ]

It should look something like this:

patches = [mpl.patches.Rectangle(xy[i], dx[i], dy[i]) for i in range(mesh.shape[0])]

Then pass LogNorm, jet and your edge parameter to PatchCollection. This is because we want matplotlib to handle as much as possible by itself so it can sort out the colours for you.

patch_collection = mpl.collections.PatchCollection(patches,cmap=matplotlib.cm.jet, norm=matplotlib.colors.LogNorm(), lw=0)

Then use set_array to give the PatchCollection the z information:

patch_collection.set_array(z_plot)

Finally add the collection to the plot, create the colorbar and show the figure:

ax.add_collection(patch_collection)
plt.colorbar(patch_collection)

plt.show()

This answer is heavily based on the example given here which may be useful.