Matplotlib: color mixing or how to preprocess color to counteract transparency

Question

In short: I am using matplotlib to draw a scater plot and a surface. I have run into a problem so that the surface is always drawn on top of the points and not behind as it should be.

I want to solve this by preprocessing color of the points so that when overlayed by the surface I obtain the "original color", this way the surface will appear behind the points. I specify color of the points using HEX values.

The problem with the surface and points I encounter is similar to the problem described here.

---

Here are the details:

I have a 3D scatter plot of Blue and Red points in Matplotlib:

self.subplot_3d = self.subplot.scatter(x_red, y_red, z_red, s = 150, c = RED,  depthshade = False, lw = 0, alpha = 1)
self.subplot_3d = self.subplot.scatter(x_blue, y_blue, z_blue, s = 150, c = BLUE,  depthshade = False, lw = 0, alpha = 1)

Points are linearly separable - there exists a separating plane, which separates red points and blue points. I draw the plain using

self.plane = self.subplot.plot_surface(X, Y, Z, antialiased = True, color = RED_BACKGROUND, alpha = 0.5)

I want to draw two plots: in the first, there is no separating plain drawn - only the red and blue points(left). And in the second there is a separating plane (right).

Once the separating plane is drawn, I was not able to force the plane to be drawn between red and blue points (as expected from the plane equation and the position of the points) The plane always appears on top of all the points.

The solution I was thinking about is the following: "preprocess" the color of the blue points so that when overlayed with the color of the transparent plane I obtain the original blue color. In this way the points will appear to be on top of the plane, and it should "solve" my current problem.

I have used HEX color specification, I am not sure how the color mix when I use transparency in matplotlib. I am looking for reference or suggestion how I should "counteract" red transparent color of the plane with, say, alpha = 0.2.

In another words I would like to achive something like sepicifiying: Blue = #0000FF Red = #FF0000 PreProcBlue = "#-FF00FF"' so that PreProcBlue + Red = Blue.

Thanks!

Answer 1

One problem is that scatter does not respect zorder. Therefore one could use plot instead.

I have compiled an example which compares plot and scatter, plotting blue dots below z=0, a plane at z=0 and red dots above z=0.
In each case I'm using a zorder of -100, 1, 100 for blue dots, plane, red dots respectively. (Note that if differences in zorder are smaller or if all are positive, this will fail)

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(12,6))
ax = fig.add_subplot(121, projection='3d', aspect="equal")
ax2 = fig.add_subplot(122, projection='3d', aspect="equal")
plt.subplots_adjust(0,0,1,1,0,0)

x = np.array([-1,1])
X,Y = np.meshgrid(x,x)
Z = np.zeros_like(X)

xr = np.random.rand(10,3)
xb = np.random.rand(10,3)
xb[:,2] = xb[:,2]-1.


ax2.set_title("scatter")
ax2.scatter(xb[:,0], xb[:,1], xb[:,2], s = 144, c = "b",  depthshade = False, lw = 0, alpha = 1, zorder=-100)
ax2.plot_surface(X, Y, Z, antialiased = True, color = "#800000", alpha = 0.5, zorder=0)
ax2.scatter(xr[:,0], xr[:,1], xr[:,2], s = 144, c = "r",  depthshade = False, lw = 0, alpha = 1, zorder=100)

ax.set_title("plot")
ax.plot(xb[:,0], xb[:,1], xb[:,2], c = "b",  marker="o", markersize=12, lw = 0, alpha = 1, zorder=-100)
ax.plot_surface(X, Y, Z, antialiased = True, color = "#800000", alpha = 0.5, zorder=0)
ax.plot(xr[:,0], xr[:,1], xr[:,2], c = "r",  marker="o", markersize=12, lw = 0, alpha = 1, zorder=100)

ax2.view_init(elev=32, azim=115)
ax.view_init(elev=32, azim=115)

def on_move(event):
    if event.inaxes == ax:
        ax2.view_init(elev=ax.elev, azim=ax.azim)
    elif event.inaxes == ax2:
        ax.view_init(elev=ax2.elev, azim=ax2.azim)
    else:
        return
    fig.canvas.draw_idle()

c1 = fig.canvas.mpl_connect('motion_notify_event', on_move)

plt.savefig(__file__+".png")
plt.show()

As can be seen from the picture, plot behaves as expected, showing the red dots above the plane and the blue dots below it.

Note that I have used matplotlib 2.0.0 to produce those plots; I am not sure, if it would be the same for 1.5.3 or below.

---

Some insights on why it is impossible to 'precompensate' the color of the background dots for the mixing with an overlay for the case that the resulting color should be fully blue:

We stay in the RGBA colorsceme, where each color is represented by the tuple (red, green, blue, alpha), where each channel can take values between 0 and 1.
The resulting color shall be fully blue: cres = (0,0,1,1). The color of the overlay can be some half-transparent red: cover = (1,0,0,0.5).

The color of the dot can then be calculated using the usual colormixing formulae to be cdot = (1,0,2,1).

As you can see, the blue channel would need to be 2 for that to work, which is outside the colorsystem's range. Of course you might want to verify that for any other color cover this is still true, but it already is clear intuitively: For any mixing with a transparent color cover, cdot's blue channel will be larger than 1, producing a non-existing color.