Brightness plot (or image) with rows corresponding to arrays of varying length

Question

I am using Python with numpy, scipy, matplotlib.

I have two lists containing arrays of varying length, which for concreteness I will call x and y and say they look like (the actual arrays are on the order of ~1000 elements in length, and the actual lists have on the order of ~10s to ~100s of arrays):

x = [
    np.array([0, 1, 2, 3, 4]),
    np.array([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]),
    np.array([0, 2 ,4])
]
y = [
    np.array([0, 0, 1, 0, 0]),
    np.array([1, 0.75, 0.5, 0.25, 0.0, 0.25, 0.5, 0.75, 1]),
    np.array([0, 1, 0,])
]

Each x-array is sorted, and each y-array is sorted by the corresponding x-array, so len(x[i])==len(y[i]) is always True and x[i][j] always corresponds to y[i][j]. Each x-array ranges between the same two values (e.g., 0 and 4 in the above example).

I want to make a plot or save an image (if possible I want to know how to do both) where the i'th row is y[i] vs. x[i], with brightness corresponding to the y-value.

So e.g., in the above example:

• For the entire plot the x-axis would go from 0 to 4 (if I save an image instead of making a plot, then I'm not worried about explicitly having the x-values on an axis anyway, but I just know that the y-values of each row correspond to x-values going from 0 to 4).
• The 1st row would have the middle fifth of the row white, and the rest of the row black.
• The 2nd row would be divided into eights, with the middle of the row black and the two edges white, the rest varying shades of grey.
• The 3rd row would be divided into thirds, with the middle third of the row white and the two edge thirds of the row black.

I'm sure I could do this easily if Python or numpy has any stretch-array functions so that I could normalize the lengths of all of the arrays in x and y, or if matplotlib simply has a built-in function for exactly this type of plot. But I don't know whether either of these exist.

Does anyone know how to do this sort of thing (or for that matter, what this sort of plot would be called)?

Thanks very much for any help. Please let me know if my question is unclear.

---Further elaboration on above example--- If I go the route of stretching the arrays to all be of the same length, then the final arrays above might look something like (after stretching)

x = [
    np.array([0, 0, 1, 1, 2, 3, 3, 4, 4]),
    np.array([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]),
    np.array([0,0,0,2,2,2,4,4,4])
]
y = [
    np.array([0, 0, 0, 0, 1, 0, 0, 0, 0]),
    np.array([1, 0.75, 0.5, 0.25,0, 0 .25,0 .5, 0.75, 1]),
    np.array([0, 0, 0, 1, 1, 1, 0, 0, 0])
]

And the plot or image would look something like would look like an image version of y (I can't post the image without 10 reputation points).

Answer 1

You could use interp1d with kind="nearest". (Using "nearest" will give steps at the boundaries and look like an expansion, but without your needing to do it explicitly, and also do a reasonable approximation to what you want if your lengths don't exactly divide as needed.) This would give something like this:

import numpy as np
from scipy import interpolate
import matplotlib.pyplot as plt
import matplotlib.cm as cm


x = [
    np.array([0, 1., 2, 3, 4]),
    np.array([0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4]),
    np.array([0, 2., 4])
]
y = [
    np.array([0, 0, 1., 0, 0]),
    np.array([1, 0.75, 0.5, 0.25, .25, 0, .5, 0.75, 1]),
    np.array([0, 1., 0,])
]

N = 30
xd = np.linspace(0, 4, 30)

data = np.zeros((len(x), N), dtype=np.float)
print data.shape

for i in range(len(x)):
    xi, yi = x[i], y[i]
    f = interpolate.interp1d(x[i], y[i], kind="nearest")
    data[i] = f(xd)

fig, ax = plt.subplots()
i = ax.imshow(data, cmap=cm.gray, interpolation='nearest')
#fig.colorbar(i)

plt.show()

Because the x-dimension of the output needs to be an integer, you would need to have a number that was divisible by all or your lengths. This could be large odd numbers (45 in this case, though I used 30 as an approximation in the above example). A completely generalizable approach would be to build the plot from patches, although that would be much more of a hassle.

Answer 2

One approach would be to use numpy.repeat, which repeats each element of a 1-d array a certain number of times. For instance:

>>> np.repeat([1,2,3,4], 3)
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])

The idea would be to find the least common multiple of the lengths of all of your lists, then use np.repeat on each to "stretch" the arrays to a common length.

More generally, you might interpolate the values of the arrays, for example, linearly, using scipy.interpolate.interp1d:

from scipy.interpolate import interp1d
import numpy as np

x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 0, 1, 0, 0])

f = interp1d(x,y)
print f(np.linspace(0,4,10))

Which prints:

[ 0.          0.          0.          0.33333333  0.77777778  0.77777778
  0.33333333  0.          0.          0.        ]