Today, someone I know googled for some help drawing a filled circle in MATLAB and asked me what I thought of the code that was found. The code found, which seems to be the conventional way to draw circles in MATLAB according to Internet posters, generates a polygonal approximation of a circle and then fills it. It goes something like this (where you can use
linspace(0,2*pi,N+1) and
daspect([1,1,1]) (or
axis square) instead of two of the commands used here):
xc = 0;
yc = 0;
r = 2;
N = 256;
theta = (0:N)*2*pi/N;
x = r*cos(theta) + xc;
y = r*sin(theta) + yc;
fill(x, y, 'k');
axis equal;
where
(xc,yc) is the coordinate of the center of the circle,
r is the radius of the circle, and
(N-1) is the number of sides of the polygon that is inscribed inside the desired circle (i.e., the polygon's corners intersect the circle). The circle is filled with the color black, which corresponds to the
'k' parameter of the
fill command. To quickly get rid of the circle without clearing the figure, change the
fill command so its figure handle gets assigned to a variable (e.g.,
h = fill(x,y,'k');) and you can delete that figure handle later (e.g.,
delete(h);). I notice that some people precede the
fill command with a
plot(x,y); command, but that is not necessary; the
fill command will construct the closed finite polygon and put a (black) border around it by default, and so there is no need to draw the border ahead of time with
plot.
[ Of course, there are methods very similar to the above that use a rotating complex phasor (i.e., a complex exponential from r*exp(i*theta)) and then let plot generate the projected Cartesian plane coordinates from the complex plane. These methods are equivalent but depend on MATLAB to do the trigonometry behind the scenes, which may or may not be faster... ]
What surprises me is that there is a perfectly nice built-in MATLAB command that will draw rectangles, rounded rectangles, circles, and ellipses very quickly essentially without having to approximate them with finite polygons. It is the
rectangle command. Some of the people who posted code like the above example apparently know about the
rectangle command (because they use it to verify that their circular approximation is sufficiently circular); however, I guess it's not ideal for them because it references the figure to a corner as opposed to its center. Nevertheless, a lot of people who might not be as picky may not know about the
rectangle command, and so here's an example similar to the above.
w = 4;
xc = 0;
yc = 0;
rectangle('Curvature',[1 1], ...
'Position',[xc-w/2 yc-w/2 w w], ...
'FaceColor','k');
axis equal;
The
'Curvature' property tells MATLAB that the lines connecting the corners of the rectangle should have no straight portions. By decreasing each of the 1's to 0 in the curvature property, the circle looks more like a rounded rectangle with flat sides and rounded corners. The
'Position' property places the bottom-left corner of the rectangle in its first two elements and then sets the width and height of the "rectangle". So here, a circle centered at
(xc, yc) is drawn with a radius of
w/2. The circle is filled with
'FaceColor'. Again,
axis equal; could be replaced with
daspect([1,1,1]); or
axis square;. Additionally, rectangle can be assigned to a variable (e.g.,
h = rectangle(...);) so that the rectangle can be easily removed later (e.g.,
delete(h);) without having to clear the figure. So this example draws a circle, but by playing with the
rectangle parameters, it is easy to draw rectangles, rounded rectangles, and ellipses as well.
It is possible that the former method might be faster, but I can't imagine it would be much faster. The latter method seems more elegant and intuitive to me, and I have to imagine that's what the people at Mathworks would advise you to use if you called them up. Having said that, I have not called them up, and so you decide for yourself.
