http://www.mathworks.com/help/matlab/ref/colormap.html You can manually specify the colormap, either from the preset ones or by making one completely customized. When providing a built-in colormap you can also specify the number of levels it should have. IE- colormap(jet(10)) will give you the same colormap as in your figure, but with only 10 possible levels. Technically what you have is a discrete map, it just has too many levels, but that's getting a bit pedantic. Play around with the above snippet and see how many levels gives the look you are wanting.

"Are they particularly well suited to coloring 3D shapes/contours (as the name "colorcube" seems to imply)?" No, not particularly. Discrete colormaps are used to color data which are not continuous, e.g. discrete categories or groups or the like. You can search the internet for thousands of tutorials on "discrete vs continuous data". Discrete colormaps are usually defined in terms a fixed set of colors, for example: FLAG (3 colors) PRISM (6 colors) LINES (whatever the current default axes ColorOrder has) The LINES colormap gives a big hint as to what discrete colormaps are good for: they are commonly used for coloring plot lines, scatter plots, and other discrete data which need to be distinguished. The LINES colormaps is defined in terms of the axes ColorOrder, so the colormaps simply gives the user access to the same colors that are used by all commands that use the ColorOrder. Read more here: https://www.mathworks.com/help/matlab/ref/matlab.graphics.axis.axes-properties.html#budumk7_sep_shared-ColorOrder "What are some good examples of non-continuous colormap applications" The following page gives exactly what you asked for, good examples of discrete colormaps in use: https://www.mathworks.com/help/matlab/ref/colororder.html IMHO the (default) colormap LINES is an okay set of colors, whereas FLAG and PRISM are basically useless. Here are some other discrete colormaps: https://www.mathworks.com/matlabcentral/fileexchange/62729-matplotlib-perceptually-uniform-colormaps https://www.mathworks.com/matlabcentral/fileexchange/45208-colorbrewer-attractive-and-distinctive-colormaps Or generate your own set of discrete colors: https://www.mathworks.com/matlabcentral/fileexchange/70215-maximally-distinct-color-generator

I think you want to use instead of |surf|. Take a look at the first example in the documentation page. It closely matches what you are trying to do.

Try this: cmap = jet(20) cmap = flipud(cmap(1:10,:)); cmap(1,:) = [1,1,1]; colormap(cmap); colorbar

Unlike imshow, the image function sets the CDataMapping property of the image object to 'direct'. Read MATLAB docs for more details. This is how this affects the outcome:

% create 256x256-matrix with discrete, ascending column values
X = repmat(linspace(0, 100, 256), 256, 1);
% first subplot
subplot 121
image(X)
colorbar
% second subplot
subplot 122
image(X, 'CDataMapping', 'scaled')
colorbar

% set colormalt to "jet"
cmap = jet(10);
colormap(cmap)

You want to use the to tell the axes what colors you want to use. That's pretty easy: colormap([0 0 .5; 0 1 0; 1 1 0; 1 0 0]) But the problem is that MATLAB's colormap lookup is always linear. If your bins aren't all the same width, then it isn't that simple. You'll probably need something like this: npts = 1e5; x = randn(npts,1); y = randn(npts,1); z = randn(npts,1); scatter3(x,y,z,32,z,'.') crange = caxis; t = linspace(crange(1),crange(2),64); cmap = zeros(64,3); mask = t<=.5; cmap(mask,:) = repmat([.5 0 0],[sum(mask), 1]); mask = t>.5 & t<=1; cmap(mask,:) = repmat([0 1 0],[sum(mask), 1]); mask = t>1 & t<=2 cmap(mask,:) = repmat([1 1 0],[sum(mask), 1]); mask = t>2; cmap(mask,:) = repmat([1 0 0],[sum(mask), 1]); colormap(cmap); You actually could simplify that a bit because the colormap will clamp to the last color for values that are off the end. That means that you could just have the linspace go between any two fixed values that are convenient. If you do that, you need to pass the values you use into the so the axes knows the range you're defining the colormap for.

In re-reading the orginal question, it is worth clarifying that this solution only visually creates the colorbar. On its own that is not enough to make the data in the plot match the colorbar. Note that the tick locations are evenly spaced from 0 to 500. The code programmatically replaces the original labels with the new labels. Separate code is necessary to rescale the values so that the colors in the colorbar correspond to values in the plot. Said another way, anything colored white has a value up to 31.25, not 0.01. tickVals = linspace(0,500,17) Apologies for that confusion. Here's sample code for how I would do this for my example. To work, you also have to specify the levels contourf should use. contourf(___,levels) % Create a data set with values from 0 to 600 (was 500 previously) data = rescale(peaks,0,600); % copy a copy of the data for rescaling newdata = data; % New tick values newTickVals = [0 0.01 0.5 1 1.5 2 5 10 15 20 25 50 75 100 250 500 inf]; for tv = 2:length(newTickVals) % find all data between the new tick ranges, one block at a time ind = data>newTickVals(tv-1) & data<=newTickVals(tv); % Change the corresponding values in the copied data to scale to the % block edges newdata(ind) = rescale(data(ind),tickVals(tv-1),tickVals(tv)); end % The rest of the code remains the same (with addition of specifying % levels) contourf(newdata,tickVals) C=parula(15); C(end+1,:)=1; colormap(flipud(C)) colorbar('Ticks',tickVals,... 'TickLabels',["" "0.01" "0.5" "1" "1.5" "2" "5" "10" "15" "20" "25" "50" "75" "100" "250" "500" ">500"]); Now the colorbar colors correspond to the values in the original data variable Note: Because this approach rescales the data to make a non-linear colorbar range possible, I think this approach only works for 2D plots (i.e. plots where only color is used to show the Z value. This approach will distort the appearance of the plot if it is plotted in 3D, e.g. a surface plot.)

The default number of colors in a colormap is 64; if you decrease the number of colors, you get more discrete blocks: colormap(parula(64)); colorbar; vs colormap(parula(10)); colorbar; For more explicit control over color intervals, you might want to check out

The only way I managed to find to stop this is to re-colour each section of the colour bar in Inkscape with the discrete colour that was meant to be in that section. In reality, I think this just inserted another rectangle of that colour within that box, but it worked ok. This wouldn't work if my tickmarks didn't completely separate each section of the colourbar though.

Not a pretty solution, but it worked for me!

Will had a great idea to use histc(), but I had to edit his code to make it work for me. Here's what I ended up with.

my_colormap = [204  204  204
               153  153  153
               255  255  178
               254  204   92
               253  141   60
               240   59   32
               189    0   38
                 0    0    0]/255 ;
binEdges = [0 0.001 0.005 0.01 0.05 0.1 0.25 0.5 1] ;
labels = textscan(num2str(binEdges*100),'%s') ;
labels = labels{1} ;
labels{length(labels)} = [labels{length(labels)} '%'] ;

[~,indices] = histc(map_data,binEdges);
indices(isnan(map_data)) = NaN ;
indices(isinf(map_data)) = NaN ;

figure ;
pcolor(indices-1)   % Instead of image(), to display NaN values as white
shading flat
axis equal tight

colormap(gca,my_colormap);   % gca as first argument prevents 
                             % colormap from changing for all 
                             % subsequent plots
h = colorbar;
caxis([0 length(binEdges)-1])
h.YTickLabel = labels ;