Overlay vs Show to combine plots?

Question

I am trying to understand the differences of Overlay and Show to combine two plots. A typical use case is to superpose a ListPlot of some data with a Plot of a curve to fit the data.

The following example comes from the Documentation:

data = {{0, 1}, {1, 0}, {3, 2}, {5, 4}};
line = Fit[data, {1, x}, x];
parabola = Fit[data, {1, x, x^2}, x];

datplot = ListPlot[data, PlotStyle -> Red];
fitplot = Plot[{line, parabola}, {x, 0, 5}];

Then I tried to Show them together or to Overlay them:

{Show[datplot, fitplot], Overlay[{datplot, fitplot}]}

In this case Overlay doesn't work very well. But this is resolved by setting a common PlotRange for both plots.

datplot = ListPlot[data, PlotStyle->Red, PlotRange->{{0,5},{0,5}}];
fitplot = Plot[{line,parabola}, {x,0,5}, PlotRange->{{0,5},{0,5}}];
{Show[datplot,fitplot], Overlay[{datplot,fitplot}]}

And this time we obtain identical results.

So my question is:

What are the differences of Show and Overlay for plots? Can I do something with Show that I cannot do with Overlay? When is one more convenient than the other (again, in the context of plot superposition)?

Answer 1

One important use of Overlay is when two plots are differently scaled but you want to show them together anyway. Here is one example:

C1 = RGBColor[0.368, 0.507, 0.710];
C2 = RGBColor[0.881, 0.611, 0.142];

p1 =
  ListLinePlot[
   {1, 7, 2000, 5, 4, 7, 164},
   ImagePadding -> 45,
   Frame -> {True, True, True, False},
   FrameLabel -> "Blue Series",
   FrameStyle -> {Automatic, C1, Automatic, Automatic},
   FrameTicks -> {All, All, None, None},
   GridLines -> Automatic,
   PlotRange -> {{1, Automatic}, All},
   PlotStyle -> C1];

p2 =
  ListLinePlot[
   {1, 4, 3, 5, 2, 6, 8},
   Axes -> False,
   ImagePadding -> 45,
   Frame -> {False, False, False, True},
   FrameLabel -> {None, None, None, "Orange Series"},
   FrameStyle -> {Automatic, Automatic, Automatic, C2},
   FrameTicks -> {None, None, None, All},
   PlotRange -> {{1, Automatic}, All},
   PlotStyle -> C2];

Overlay[{p1, p2}]

Now the same with Show

Show[{p1, p2}]

Show preserves the different scalings whereas Overlay "simply" superimposes one "image" upon the other.

Answer 2

The other answers point out important differences which I won't repeat. But here's another one. Overlay is implemented by drawing everything. It visually stacks all of its contents. Show is implemented by merging the primitive lists and options. This introduces some important differences.

For example, if the options contradict one another in plots, then Show will pick the first fully resolved option. E.g.,

Show[Plot[Sin[x], {x, 0, 2 \[Pi]}, AxesOrigin -> {0, 0}], 
 Plot[Cos[x], {x, 0, 2 \[Pi]}, AxesOrigin -> {\[Pi], 0}]]

Or, you can even add the option to Show to override all local options.

Show[Plot[Sin[x], {x, 0, 2 \[Pi]}, AxesOrigin -> {0, 0}], 
 Plot[Cos[x], {x, 0, 2 \[Pi]}, AxesOrigin -> {\[Pi], 0}], 
 AxesOrigin -> {2 \[Pi], 0}]

Overlay can do nothing more than a visual superposition. Incidentally, since Overlay is doing a visual superposition, that means that it might end up double-drawing things that you don't intend to be double-drawn. For example, imagine you have plots which have GridLines (for simplicity, I'll just use the same plot twice here):

p = Plot[x, {x, 0, 1}, GridLines -> Automatic]

Overlay[{p, p}]

Oops..what happened to those grid lines? They got a lot darker in the Overlay version. They got darker because, by default, GridLines are rendered as partially transparent. This was done so that they look reasonable regardless of the choice of background color you might have chosen for the graphic. But here, what you've done is to overdraw a transparent color on itself, thereby making a darker color. If that description wasn't very clear, then this should help to illustrate what I'm talking about:

Graphics[{GrayLevel[0, 0.3],
  Rectangle[{0, 0}, {1.2, 1.2}], Rectangle[{.8, .8}, {2, 2}]}]

That is exactly what's going on in the Overlay case. And, furthermore, it even has subtle drawing effects on things you might not have noticed at first. For example, antialiasing is implemented as a pixel compositing operation, effectively equivalent to using transparency. Which means that anything in a graphic which is antialiased and multiply drawn is going to look darker around the edges. That's why the tick labels in the Overlay example above look darker. If you look carefully at the screenshot you provide in your question, you'll notice that your tick labels look darker, too.

Okay...so those are some subtle issues with overdrawing. Let's try a non-subtle issue...plots with background colors:

Overlay[{Plot[Sin[x], {x, 0, 2 Pi}, Background -> LightBlue], 
  Plot[Cos[x], {x, 0, 2 Pi}, Background -> LightOrange]}]

Oops...where did the sine wave go? Because the plots are visually stacked, the background color for the second plot completely obscures everything that was drawn as part of the first graphic.

Answer 3

Following your example,

  pp=={Show[datplot,fitplot], Overlay[{datplot,fitplot}]};

I can continue to operate on Show, e.g. as

  pp[[1]] // Show[#, PlotRange -> {0, 1}] &

Whereas

  pp[[2]] // Show[#, PlotRange -> {0, 1}] &

returns

Overlay is not a type of graphics. >>