Sizing cells in a GraphicsGrid/GraphicsRow

Question

I would like to add a colour bar to a plot. I tried to use GraphicsRow for this. In a GraphicsRow, each item is given the same space, resulting in this:

Clear[colorbar]
colorbar[colorFunction_: Automatic, divs_: 25] := 
 DensityPlot[y, {x, 0, .1}, {y, 0, 1}, AspectRatio -> Automatic, 
  PlotRangePadding -> 0, PlotPoints -> {2, divs}, MaxRecursion -> 0, 
  FrameTicks -> {None, Automatic, None, None}, 
  ColorFunction -> colorFunction]

GraphicsRow[{DensityPlot[Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}],
             colorbar[]}]

The colour bar has too much space around it. How can I specify the amount of space GraphicsRow should give a particular item?

Alternatively, what is a better way to include the colour bar?

---

Answer summary

After experimenting with this for a while, it seems that the situation is the following (simplified):

• Grid and friends (Row, Column) will size the grid cells to fit each item individually (cells resized to fit items).

• GraphicsGrid will first set up a grid with fixed cell sizes, then fit each item into the cells (items resized to fit cells).

GraphicsGrid-like solutions are more convenient when the whole graphic need to be sized to a specification.

István's answer hacks GraphcisRow by setting a negative spacing and thus pushing the elements closer together. It's the most convenient for this situation, but it doesn't generalize for many cells.

R.M.'s solution suggests using Grid instead. This generalizes well, but requires pre-sizing all items individually, and no resizing is possible after (e.g. just before import).

Since GraphicsGrid is implemented in terms of Inset, the most general easily resizable solution would be implementing a GraphicsGrid-like construct where cell size ratios can be specified. kguler's last answer illustrates this best.

Several other solutions used Inset directly as well. A problem with resizing these solutions can be that the aspect ratio of elements is size-dependent (due to the absolute sizes used in ImagePadding), so how they fit into a fixed aspect ratio Inset will depend on the scale. Note for example the difference in scaling behaviour between István's solution and kguler's solution at small sizes: in kguler's solution (using a cell aspect ratio matching that of the colour bar) the colourbar suddenly get shrunk compared to the main plot at small sizes, but the tick marks will never overlap with the other plot. in István's solution (which uses overlapping square cells) the colour bar never gets overshrunk, but the tick marks will overlap the main plot.

Update: Version 9 has built-in support for plot legends, including colour bars. Legended is used to append a legend to a graphics object.

Answer 1

One way of doing it is to use Row instead of GraphicsRow and setting an explicit ImageSize. The solution also scales for different sizes. Setting the same ImagePadding on both plots will ensure that they are nicely aligned. For example:

With[{size = 300}, 
 Row[Show[#, ImageSize -> {Automatic, size}, 
     ImagePadding -> 20] & /@ {DensityPlot[
     Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}], colorbar[]}]]

---

The above plot still has excess spacing between the graphic and the color bar. The reason for this is because of the uniform padding of 20. So this translates to 20 for the right side of the first + 20 for the left side of the second which means a 40 total between the two. Using the {{left, right}, {bottom, top}} spacing specification for ImagePadding works very well in aligning color bars to a plot. For this case, modify the above code to: ImagePadding -> {{20, 0}, {20, 5}}, which results in

You can now set a separate right padding if you need to leave some more space between the two.

Answer 2

You can overlap GraphicsRow items by specifying negative spacings. This omits whitespace to the right (as in kguler's answer):

size = 360;

colorbar[colorFunction_: Automatic, divs_: 25] := 
 DensityPlot[y, {x, 0, .1}, {y, 0, 1}, AspectRatio -> Automatic, 
  PlotRangePadding -> 0, PlotPoints -> {2, divs}, MaxRecursion -> 0, 
  FrameTicks -> {None, Automatic, None, None}, 
  ColorFunction -> colorFunction, ImageSize -> {size/5, size}]

GraphicsRow[
 Show[#, ImagePadding -> 20] & /@ {DensityPlot[
    Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}, ImageSize -> size],
    colorbar[]}, Alignment -> Right, ImageSize -> size, Frame -> None,
  Spacings -> {-3 size/4, Automatic}]

Updated with appropriate size specifications.

Answer 3

Using GraphicsRow options:

- Alignment option

  GraphicsRow[{DensityPlot[
  Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}], colorbar[]}, 
  Alignment -> Left]

gives

- Spacings with negative values:

 GraphicsRow[{DensityPlot[
 Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}], colorbar[]}, 
 Spacings -> Scaled[-.4]]

or

 GraphicsRow[{DensityPlot[
 Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}], colorbar[]}, 
 Spacings -> -100]

Both give less white space on the right.

Replacing position and size options of Inset

Inspecting the InputForm of the output from GraphicsRow, we see that it is a collection of Inset objects, one for each graphics object in the argument list. So the positions and sizes of the graphics objects can be controlled by options to Inset. These are

Inset[obj,pos,opos]

aligns the inset so that position opos in the object lies at position pos in the enclosing graphic.

Inset[obj,pos,opos,size]

specifies the size of the inset in the coordinate system of the enclosing graphic.

This suggests a hack (specific to the example and wrapped with Panel to show the relative sizes)

 a = 420; b = 120; 
 Panel@GraphicsRow[{DensityPlot[
 Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}], 
 Graphics[colorbar[]]}, ImageSize -> 500] /. Inset[gr_, 
   {576., pos2_}, ImageScaled[{0.5, 0.5}], {sz1_, sz2_}] :> 
Inset[gr, 
   {a, pos2}, ImageScaled[{0.5, 0.5}], {b , sz2}]

with output

DIY GraphicsRow: Using Graphics and Inset:

Use Graphics and Inset to replicate what GraphicsRow does, and control the options for Inset directly:

 Graphics[{ {Inset[
 DensityPlot[Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}], 
    {192, -189.}, ImageScaled[{0.5, 0.5}], {360, 360.}], 
  Inset[Graphics[colorbar[]], 
    {420., -189.}, ImageScaled[{0.5, 0.5}], {120., 360.}]}}, 
ContentSelectable -> True, ImageSize -> 500,
PlotRangePadding -> {6, 5}]

which produces the same output.

Answer 4

Further to R.M.'s answer, you can use some combination of ImageSize on the graphic elements and ItemSize for the Grid elements themselves to finesse spacing. I've added the possibility to include other options to the colorbar function, such as ImageSize, though if you use them you need to set the other two arguments explicitly. This is an alternative to Show with additional options.

colorbar[colorFunction_: Automatic, divs_: 25, 
  opts : OptionsPattern[]] := 
 DensityPlot[y, {x, 0, .1}, {y, 0, 1}, 
  Evaluate[Sequence @@ FilterRules[{opts}, Options[DensityPlot]]], 
  AspectRatio -> Automatic, PlotRangePadding -> 0, 
  PlotPoints -> {2, divs}, MaxRecursion -> 0, 
  FrameTicks -> {None, Automatic, None, None}, 
  ColorFunction -> colorFunction]

Framed to show the difference between ItemSize and ImageSize. Note that the former is in character widths and the latter is in pixels.

Grid[{{DensityPlot[Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}], 
   Framed@colorbar[Automatic, 30, ImageSize -> 32]}}, 
 ItemSize -> {{15, 4}}, Frame -> All, FrameStyle -> Red]

This alternative might be useful if, like here, the default sizes don't quite work together, and for whatever reason you don't want to use Show.

Answer 5

This is a little late, but I had actually fought the same problem a couple of days ago, and only now saw that this was a question. I'm putting it here as another solution:

Clear[colorbar,defaultSize]
defaultSize=360;

colorbar[colorFunction_: Automatic, divs_: 25] := 
 DensityPlot[y, {x, 0, .1}, {y, 0, 1}, PlotRangePadding -> 0, 
  PlotPoints -> {2, divs}, AspectRatio -> Full, 
  ImageSize -> {defaultSize/10, defaultSize}, MaxRecursion -> 0, 
  FrameTicks -> {None, Automatic, None, None}, 
  ColorFunction -> colorFunction]

GraphicsRow[{DensityPlot[
   Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}, ImageSize -> defaultSize], 
  colorbar[]}, Alignment -> {Left, Center}, Spacings -> 20, 
 ImageSize -> {Automatic, defaultSize}]

The difference between the original question and this is the following:

1. AspectRatio->Full which according to the docs: "specifies that a graphic should be stretched so as to fill out its enclosing region in a Grid or related construct."

2. Explicit ImageSize, especially in the GraphicsRow to specify Automatic in the horizontal direction, but our default size in the vertical.

3. Alignment->{Left,Center}

4. Spacings played around with until a 'nice' value was found.

Hope this helps someone. FWIW, I have no idea why the above works, maybe someone better versed in inner MMA speak can answer that.

Answer 6

This seems to give good flexibility:

Show[DensityPlot[Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}], 
 Graphics@Inset[colorbar[], {15, 0}], 
 ImagePadding -> {{20, 100}, {20, 20}}, PlotRangeClipping -> False]

EDIT: You can also use relative coordinates:

Graphics@Inset[colorbar[], ImageScaled[{0.9, 0.5}]]

The advantage of this method is that you can easily configure/tweak it to be almost anything you want, and also add multiple Graphics:

Show[DensityPlot[Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}], 
 Graphics@Inset[colorbar[], ImageScaled[{1, 0.3}], {0.5, 0.5}, 
   ImageScaled[{0.1, 0.4}]], ImagePadding -> {{20, 20}, {20, 20}}]

Answer 7

Mathematica versions 11 and 12 behave differently with regard to GraphicsRow/GraphicsGrid.

For GraphicsRow, there is no change required when using the negative spacing hack identified as István's answer in the Question's Answer Summary.

For GraphicsGrid, the negative spacing hack which worked in version 11 does not immediately in version 12. Calling AspectRatio as outlined in a related post allows keeping previously chosen spacing(s) as is. Besides, both versions 11 and 12 result in whitespace at the top. If neither using Frame nor Dividers, that can be removed with ImageCrop, see e.g. there.

Answer 8

This is the best scaling behavior for this specific problem that I could come up with:

Clear[colorbar]
colorbar[colorFunction_: Automatic, divs_: 25] := 
 DensityPlot[y, {x, 0, .1}, {y, 0, 1},
   PlotPoints -> {2, divs}, MaxRecursion -> 0,
   AspectRatio -> 7, PlotRangePadding -> 0,  
   Frame -> False, Axes -> {False, True}, 
   TicksStyle -> Directive[Bold, Red], AxesOrigin -> {0.1}, 
   ColorFunction -> colorFunction
 ]

Graphics[{
  First @ DensityPlot[Sin[Norm[{x, y}]], {x, -10, 10}, {y, -10, 10}],
  Inset[
    colorbar[],
    Scaled[{1, 1/2}],
    ImageScaled[{-0.1, 1/2}],
    Scaled[{1/7, 1}]
  ]
 },
 Frame -> True,
 ImagePadding -> {{Automatic, Automatic}, {Automatic, 5}}
]