Colormap on the outside of a circle

Hi, I am new to MATLAB but have ovecome a huge learning curve thanks to the user answers provided on this site. There is something I am stumpped by and I was wondering if there were any suggestions...

I have a colormap of around 16000 color shades in a specific order that I would like to distribute evenly around the outside of a circle. The closest I have gotten is using the pie chart function to render an image like the one attached. This is almost exactly what I would like to have, except for 2 things:

-I only need the outer maybe 10%, the ineer content is not important to me -when I try to make a pie chart with divisions greater than 1000, the processing time is extremely long

is there a more efficient way of mapping the 16000 color colormap to the outside of a circle?

Thanks so much

Answer 1

[Star Strider]

Note: There is an error in my original Answer. The correct code for my Answer is in this Comment.

———————————————————————————————————————————————

I believe Image Analyst has one of these ready to go, but lacking it, I came up with this:

N = 256;                        % Nr Colours
c = colormap(jet(N));           % Define ‘colormap’

th = linspace(0, 2*pi, N);      % Create Polar Grid
r = 0.5:0.5:1;
[TH,R] = meshgrid(th,r);
[X,Y] = pol2cart(TH,R);

C = bsxfun(@times,(X + Y),th);  % Multiply X,Y, by ‘th’ —> Spiral

figure(1)                       % Plot Flat Spiral
surf(X,Y,C)
view([0  90])
axis square
grid off

You will likely have to experiment with it to get the result you want. It’s fairly simple, and I copied some of the basic ideas from Contour Plot in Polar Coordinates (since I believe in giving credit where credit is due). The idea of using the spiral to force the colour mapping to the spiral was mine! :) All you need do is to define the colormap, and the plot does the rest magickally.

producing:

This plot has edges between the faces. If you want a smooth plot without the edges, and therefore seamless colour transitions (as you likely would with 16000 colours), replace the previous ‘figure(1)’ plot with this code:

figure(1)                       % Plot Flat Spiral Without Edges
hs = surf(X,Y,C);
view([0  90])
axis square
grid off
set(hs, 'EdgeColor','none')

Otherwise, the code is the same. You can also experiment with the lighting and other options, turning the axes off, and other such tweaks if you like, since this is a surface object. See Chart Surface Properties for details.

[Hans Bernhard]

This is incredible. Not only did you exactly solve the problem, but you have such an amazing explanation! I can't thank you enough. Amazing!

[Star Strider]

My pleasure!

[Hans Bernhard]

Almost perfect! Now I am running into a new problem. Your process does exactly what I want when the colormap is a gradient of colors between a few nodes. However, when I put in a colormap that fades evenly between 2 colors, the resulting spiral is not as I expect.

In other words, I have a color gradient that moves periodically between black and purple expressed by a Nx3 matrix. when I assign the matrix to the colormap I get the proper gradient with N values that continues predictably from beginning to end. However, MATLAB automatically places nodes in seemingly random spots, which occasionally clump in one color more than others.

my resulting polar chart of N divisions, instead of being an even back and forth variation of purple and black looks uneven. Is this because of the nodes?

I am new to all of this, and before coming back I spent a while searching for possible node related documentation but I couldn't find anything that made sense for my situation. If anyone has a quick hint of what I should be looking at that would be amazing

[Hans Bernhard]

or maybe it would be easier to see with the N scaled down. Here is a colormap with 54 colors going from purple to dark and back. I would think the color wheel with N=54 would have the same contour (purple do dark and back), but it does not:

[Star Strider]

I apologise for the delay — life intrudes.

Here is a much more robust version:

N = 256;                                % Number Of Colours In Colour Wheel
th = linspace(0, 2*pi, N);              % Angles
xy = @(a,r) [r.*cos(a); r.*sin(a)];     % Function: Calculate (x,y) Vectors
r_ext = 1.0;                            % Outer Radius
r_int = 0.7;                            % Inner Radius
C(1,:,:) = xy(th,r_ext);                % Outer Circle
C(2,:,:) = xy(th,r_int);                % Inner Circle
c = colormap(jet(N));                   % Set ‘colormap’

figure(1)
C1 = squeeze(C(1,:,:));                 % Reduce ‘C1’ Dimensions
plot(C1(1,:), C1(2,:))
hold on
C2 = squeeze(C(2,:,:));                 % Reduce ‘C2’ Dimensions
plot(C2(1,:), C2(2,:))
for k1 = 1:size(C2,2)
    plot([C1(1,k1), C2(1,k1)], [C1(2,k1), C2(2,k1)], 'Color',c(k1,:), 'LineWidth',0.25)
    k2 = max([mod(k1+1,size(C2,2)), 1]);
    patch([C1(1,k1), C1(1,k2), C2(1,k2), C2(1,k1)], [C1(2,k1), C1(2,k2), C2(2,k2), C2(2,k1)], c(k1,:), 'EdgeColor','none')    
end
hold off
axis square

The overall design is to create two segmented circles, and then define each segment as a patch object. Since patch objects require four vertices (in this application), the ‘k2’ calculation (the next segment index) also allows the code to ‘wrap around’ to the first index and complete the circle and the patch vertices.

This creates plot lines to match the patch colours, so the plotted borders between the segments completely disappear, and it can appear seamless if you want it to be. If you want borders between the colours, set ‘c(k1,:)’ in the plot call to 'k' or whatever colour you want it to be. I set the patch edge colours to 'none' for the same reason.

Using the ‘jet’ colormap, this code produces this plot:

[Hans Bernhard]

Haha. I can't believe you would apologize for an insanely fast and totally informative response. More than providing the solution, thank you for taking the time to explain the thought process. I am going to look this over when I get back home.

[Image Analyst]

Using a colormap you can get up to 256 colors, not the full 16,000 he said he needs. If getting all 16,000 colors is really necessary, then he'll have to create an RGB image like my color wheel demo does.

Of course getting 16,000 with even an RGB image could be tough. Let's say that the screen is 1000 pixels high. That means there will be pi*1000 = 3,141 pixels going around the circle. If each pixel was a wedge going towards the center (which of course it can't be), then you could only have 3,141 colors. That's better than 256 but nowhere close to 16,000.

Hans, can you explain why you think you need 16 thousand colors? A circle can't represent that full amount. To get every one of the 16,000 colors on a circle on the screen you'd need a circle 16,000 / pi = 5093 pixel high image. I doubt your screen is that big. You either need to use fewer colors, or use a rectangle. Using an 8/24 bit RGB display you can have 16.7 million colors of course you can only simlultaneously display not more colors than you have pixels, so it you're displaying a 1 megapixel image you can have a million colors. If you're displaying an 800x600 image you can have 480,000 colors.

[Star Strider]

@Hans — Thank you! I like to code faster than that, but some code takes time. I also wanted to be sure the explanation was as clear and concise as I could write it.

I’m not certain that you’ll be able to see all your 16K colours, but with that in mind, I plotted the patch borders in the same colours as the patches, so that will at least allow you to see the colours rather than only the borders (usually black).

[Mike Garrity]

Actually the 256 entry limit on colormaps was fixed in R2014b. You can now go up to the limits of your graphics card's texture size. A call to "opengl info" will tell you what that limit is. It's typically at least 2,048. On my machine, it is 16,384, so I can do this:

[x,y,z]=peaks(250);
surf(x,y,z,'FaceColor','interp','EdgeColor','none')
colormap(flag(16384))
xlim(2+[0 0.1])
ylim(2+[0 0.1])

and get the following:

[Image Analyst]

Very cool Mike. Though I guess I can't figure out how to get it to work. What's wrong with the following code? Why does it not do the full jet colormap with all colors? It only does the blue end of the scale.

openglInfo = opengl('data')
numColors = openglInfo.MaxTextureSize % 16384 for me
% Make linear ramp.
ramp = uint16(linspace(0, numColors, 1600));
% Extend vertically to make an image.
my2DRamp = repmat(ramp, 800, 1);
% Display image and apply colormap.
imshow(my2DRamp);
colormap(jet(numColors));
colorbar;

[Star Strider]

@Mike — I actually pushed the limit up to 16000 at one point to test it. (I have R2015a.) The only problem was that my colorwheel code took forever to run. I didn’t visually notice any difference (on my 2-year-old HP gaming laptop with a high-end AMD graphics card).

[Mike Garrity]

But if you use FaceColor=interp, you shouldn't have to make your mesh size as large as the colormap size. The card will do linear interpolation of the CData between the vertices before doing the colormap lookup. You just need enough mesh resolution that the linear approximation is good.

[Mike Garrity]

@Image Analyst That's interesting.

Here's what I see with your code:

>> caxis 
ans = 0  65535
>> h = get(gca,'Children')
h = Image with properties:
            CData: [800x1600 uint16]
     CDataMapping: 'scaled'
>> max(h.CData(:))
ans = 16384

So it thinks that the colormap should cover the values from 0 to 65,535. However the largest value in your image is 16,384. Therefore the image only uses a 1/4 of the colormap.

The next thing to check is the CLimMode:

>> get(gca,'CLimMode')
ans = manual

Ah, someone has set the CLim manually! I'm not sure where that happened. My guess is that it's hiding inside imshow somewhere. I'll try to get a chance to look for it later.

For the time being, you can just do this:

caxis auto

to get the entire colormap.

Now, we do need to be clear that the size of the colormap is only one part of the pipeline. To really get more colors displayed on the screen, we need to worry about the narrowest representation of colors in the entire pipeline. The reality is that you are going to see banding caused by operations which truncate to 8 bit. Getting rid of the limit on the colormap size was a really important step, but it's not the only limitation that matters here.

I should also mention that many graphics cards will struggle with aliasing issues with colormaps like flag(16384).

[Star Strider]

I tried that, but with 'FaceColor','interp' it threw an error. I’m not sure what the problem was, but the code provided an decent plot without it at a lower number of colours, so I just let it go at that.

Answer 2

[Image Analyst]

Looks like you've gotten an acceptable answer, but for what it's worth, here's my color wheel demo, attached. You need to adapt it to make the hue some constant, like 0.9 for purple or something. Then quantize the value image instead of the hue image to take on values from 0 to 0.5 or something.

Answer 3

[Chad Greene]

Another option is to use phasebar.