Creating topographical scalp maps: part 2 - colour maps and contour lines

Colormap choices

So how do you go about choosing what colourmap to use? Luckily, there are a whole bunch of options out there that are already designed to solve the problems identified above.

With ggplot2, use of these various colourmaps is trivially easy. Many are already available thanks to RColorBrewer, an implementation of Cynthia Brewer’s colourmaps. Other nice colour schemes are available through the viridis package, which implements the perceptually uniform colour maps from Python’s matplotlib.

Sequential colour maps

Sequential colour maps take a single colour (approximately…) that varies smoothly between two tones. These have the advantage they show a clear linear progression from the bottom to the top of the scale. Matplotlib’s default colour maps print nicely in black and white, are robust to colour blindness, and span a good range of the palette to make differences in scale easy to see. After loading the viridis package, they can be used as below:

library(viridis)
viridisPlot <- v4plot + scale_fill_gradientn(colours = viridis(10),
                              limits = c(-2,2),
                              guide = "colourbar",
                              oob = squish) +
  ggtitle('Viridis')
magmaPlot <- v4plot + scale_fill_gradientn(colours = viridis(10, option = "A"),
                              limits = c(-2,2),
                              guide = "colourbar",
                              oob = squish)+
  ggtitle('Magma')

infernoPlot <- v4plot + scale_fill_gradientn(colours = viridis(10, option = "B"),
                              limits = c(-2,2),
                              guide = "colourbar",
                              oob = squish)+
  ggtitle('Inferno')
plasmaPlot <- v4plot + scale_fill_gradientn(colours = viridis(10, option = "C"),
                              limits = c(-2,2),
                              guide = "colourbar",
                              oob = squish)+
  ggtitle('Plasma')

grid.arrange(viridisPlot, magmaPlot, infernoPlot, plasmaPlot, ncol = 2, nrow = 2)

From a first glance, I probably like Plasma and Viridis best from these options. One thing I like about the sequential maps is that they don’t place too much emphasis on any particular point, doing a good job of conveying the smoothness of the topography and not imposing any sharp transitions. These particular colour schemes would also be good for displaying raw spectral power in time-frequency plots or topographies. Raw spectral power (i.e. power which is not baseline corrected) is all-positive, so has no natural reference point such as zero to form the center of its scale.

Diverging colour maps

Diverging colour maps use two different colours either side of a reference point, so they’re nice for showing when something is above or below some sort of important value. For example, on an ERP topography you’re probably keen to know where the amplitude is above zero and where it is below zero.

 RdBuPlot <- v4plot + scale_fill_distiller(type = "div",palette = "RdBu",limits = c(-2,2),
                              guide = "colourbar",
                              oob = squish) +
  ggtitle('RdBu')

PuOrPlot <- v4plot + scale_fill_distiller(type = "div",palette = "PuOr",limits = c(-2,2),
                              guide = "colourbar",
                              oob = squish) +
  ggtitle('PuOr')

RdYlGnPlot <- v4plot + scale_fill_distiller(type = "div",palette = "RdYlGn",limits = c(-2,2),
                              guide = "colourbar",
                              oob = squish) +
  ggtitle('RdYlGn')

PiYGPlot <- v4plot + scale_fill_distiller(type = "div",palette = "BrBG",limits = c(-2,2),
                              guide = "colourbar",
                              oob = squish) +
  ggtitle('BrBG')

grid.arrange(RdBuPlot, PuOrPlot, RdYlGnPlot, PiYGPlot, ncol = 2, nrow = 2)

Again, these are quite an improvement over Jet-style colour maps, and are particularly useful for showing data with a clear reference point (e.g. ERPs or baseline-corrected time-frequency plots/topographies).

MNE style maps and contours

MNE is a really comprehensive package for Python that offers many advanced tools for M/EEG analysis. Their default colourmap is the RdBu diverging map shown above. A neat trick I like on their topographies is that the contour lines change with the amplitude within each contour level; specifically, contours around amplitudes greater than or equal to zero use solid lines, while contours around amplitudes less than zero use dashed lines. That’s also simple to do in ggplot2. Note that here I also define a custom version of the “RdBu” colormap to make it a bit more punchy, like the MNE plots.

matplotlibRdBu_r <- colorRampPalette(c("#053061","#4694C4","#F6F6F6","#E7886C","#67001F"),interpolate = "spline")


v4plot <- ggplot(interpV4[interpV4$incircle,],aes(x = x, y = y, fill = amplitude))+
  geom_raster()+
  stat_contour(aes(z = amplitude,linetype = ..level..<0),
               bins = 6,
               colour = "black",
               size = 1.2,
               show.legend = FALSE
               )+
  theme_topo()+
   geom_path(data = maskRing,
            aes(x, y, z = NULL, fill =NULL),
            colour = "white",
            size = 6)+ scale_fill_gradientn(colours = matplotlibRdBu_r(10),
                        limits = c(-2,2),
                        guide = "colourbar",
                        oob = squish)+
  geom_point(data = singleTimepoint,
             aes(x,y),
             size = 1)+
  geom_path(data = headShape,
            aes(x,y,z = NULL,fill = NULL),
            size = 1)+
  geom_path(data = nose,
            aes(x, y, z = NULL, fill = NULL),
            size = 1)+
  coord_equal()

v4plot

The trick is in this code:

 stat_contour(aes(z = amplitude,linetype = ..level..<0),
               bins = 6,
               colour = "black",
               size = 1.2,
               show.legend = FALSE
               )

stat_contour creates a new data frame internally which splits the data into bins. This new dataframe has a column “level”, which is the value of each bin edge. Columns from internally generated dataframes can be accessed using ..[column name].., so I simply check if the level is less than 0, which sets the linetype to different numbers for bins >=0 than for bins <0.