# # Drawing

## # Circles

The easiest option to draw a circle, is - obviously - the ** rectangle** function.

```
%// radius
r = 2;
%// center
c = [3 3];
pos = [c-r 2*r 2*r];
rectangle('Position',pos,'Curvature',[1 1])
axis equal
```

but the curvature of the rectangle has to be set to **1**!

The `position`

vector defines the rectangle, the first two values `x`

and `y`

are the lower left corner of the rectangle. The last two values define width and height of the rectangle.

```
pos = [ [x y] width height ]
```

The lower left **corner** of the circle - yes, this circle has corners, imaginary ones though - is the **center** `c = [3 3]`

**minus the radius** `r = 2`

which is `[x y] = [1 1]`

. **Width** and **height** are equal to the **diameter** of the circle, so `width = 2*r; height = width;`

In case the smoothness of the above solution is not sufficient, there is no way around using the obvious way of drawing an actual circle by use of **trigonometric functions**.

```
%// number of points
n = 1000;
%// running variable
t = linspace(0,2*pi,n);
x = c(1) + r*sin(t);
y = c(2) + r*cos(t);
%// draw line
line(x,y)
%// or draw polygon if you want to fill it with color
%// fill(x,y,[1,1,1])
axis equal
```

## # Arrows

Firstly, one can use `quiver`

, where one doesn't have to deal with unhandy normalized figure units by use of `annotation`

```
drawArrow = @(x,y) quiver( x(1),y(1),x(2)-x(1),y(2)-y(1),0 )
x1 = [10 30];
y1 = [10 30];
drawArrow(x1,y1); hold on
x2 = [25 15];
y2 = [15 25];
drawArrow(x2,y2)
```

Important is the 5th argument of `quiver`

: 0 which disables an otherwise default scaling, as this function is usually used to plot vector fields. (or use the property value pair `'AutoScale','off'`

)

One can also add additional features:

```
drawArrow = @(x,y,varargin) quiver( x(1),y(1),x(2)-x(1),y(2)-y(1),0, varargin{:} )
drawArrow(x1,y1); hold on
drawArrow(x2,y2,'linewidth',3,'color','r')
```

If different arrowheads are desired, one needs to use annotations (this answer is may helpful How do I change the arrow head style in quiver plot?).

The arrow head size can be adjust with the `'MaxHeadSize'`

property. It's not consistent unfortunately. The axes limits need to be set afterwards.

```
x1 = [10 30];
y1 = [10 30];
drawArrow(x1,y1,{'MaxHeadSize',0.8,'Color','b','LineWidth',3}); hold on
x2 = [25 15];
y2 = [15 25];
drawArrow(x2,y2,{'MaxHeadSize',10,'Color','r','LineWidth',3}); hold on
xlim([1, 100])
ylim([1, 100])
```

There is another tweak for adjustable arrow heads:

```
function [ h ] = drawArrow( x,y,xlimits,ylimits,props )
xlim(xlimits)
ylim(ylimits)
h = annotation('arrow');
set(h,'parent', gca, ...
'position', [x(1),y(1),x(2)-x(1),y(2)-y(1)], ...
'HeadLength', 10, 'HeadWidth', 10, 'HeadStyle', 'cback1', ...
props{:} );
end
```

which you can call from your script as follows:

```
drawArrow(x1,y1,[1, 100],[1, 100],{'Color','b','LineWidth',3}); hold on
drawArrow(x2,y2,[1, 100],[1, 100],{'Color','r','LineWidth',3}); hold on
```

## # Ellipse

To plot an ellipse you can use its equation. An ellipse has a major and a minor axis. Also we want to be able to plot the ellipse on different center points. Therefore we write a function whose inputs and outputs are:

```
Inputs:
r1,r2: major and minor axis respectively
C: center of the ellipse (cx,cy)
Output:
[x,y]: points on the circumference of the ellipse
```

You can use the following function to get the points on an ellipse and then plot those points.

```
function [x,y] = getEllipse(r1,r2,C)
beta = linspace(0,2*pi,100);
x = r1*cos(beta) - r2*sin(beta);
y = r1*cos(beta) + r2*sin(beta);
x = x + C(1,1);
y = y + C(1,2);
end
```

**Exmaple:**

```
[x,y] = getEllipse(1,0.3,[2 3]);
plot(x,y);
```

## # Polygon(s)

Create vectors to hold the x- and y-locations of vertices, feed these into `patch`

.

### # Single Polygon

```
X=rand(1,4); Y=rand(1,4);
h=patch(X,Y,'red');
```

### # Multiple Polygons

Each polygon's vertices occupy one column of each of `X`

, `Y`

.

```
X=rand(4,3); Y=rand(4,3);
for i=2:3
X(:,i)=X(:,i)+(i-1); % create horizontal offsets for visibility
end
h=patch(X,Y,'red');
```

## # Pseudo 4D plot

A `(m x n)`

matrix can be representes by a surface by using surf;

The color of the surface is automatically set as function of the values in the `(m x n)`

matrix.
If the colormap is not specified, the default one is applied.

A colorbar can be added to display the current colormap and indicate the mapping of data values into the colormap.

In the following example, the `z (m x n)`

matrix is generated by the function:

```
z=x.*y.*sin(x).*cos(y);
```

over the interval `[-pi,pi]`

. The `x`

and `y`

values can be generated using the meshgrid
function and the surface is rendered as follows:

```
% Create a Figure
figure
% Generate the `x` and `y` values in the interval `[-pi,pi]`
[x,y] = meshgrid([-pi:.2:pi],[-pi:.2:pi]);
% Evaluate the function over the selected interval
z=x.*y.*sin(x).*cos(y);
% Use surf to plot the surface
S=surf(x,y,z);
xlabel('X Axis');
ylabel('Y Axis');
zlabel('Z Axis');
grid minor
colormap('hot')
colorbar
```

**Figure 1**

Now it could be the case that additional information are linked to the values
of the `z`

matrix and they are store in another `(m x n)`

matrix

It is possible to add these additional information on the plot by modifying the way the surface is colored.

This will allows having kinda of 4D plot: to the 3D representation of the surface
generated by the first `(m x n)`

matrix, the fourth dimension will be represented by the
data contained in the second `(m x n)`

matrix.

It is possible to create such a plot by calling `surf`

with 4 input:

```
surf(x,y,z,C)
```

where the `C`

parameter is the second matrix (which has to be of the same size of `z`

) and
is used to define the color of the surface.

In the following example, the `C`

matrix is generated by the function:

```
C=10*sin(0.5*(x.^2.+y.^2))*33;
```

over the interval `[-pi,pi]`

The surface generated by `C`

is

**Figure 2**

Now we can call `surf`

with four input:

```
figure
surf(x,y,z,C)
% shading interp
xlabel('X Axis');
ylabel('Y Axis');
zlabel('Z Axis');
grid minor
colormap('hot')
colorbar
```

**Figure 3**

Comparing Figure 1 and Figure 3, we can notice that:

- the shape of the surface corresponds to the
`z`

values (the first`(m x n)`

matrix) - the colour of the surface (and its range, given by the colorbar) corresponds to the
`C`

values (the first`(m x n)`

matrix)

**Figure 4**

Of course, it is possible to swap `z`

and `C`

in the plot to have the shape of the surface given by the `C`

matrix and the color given by the `z`

matrix:

```
figure
surf(x,y,C,z)
% shading interp
xlabel('X Axis');
ylabel('Y Axis');
zlabel('Z Axis');
grid minor
colormap('hot')
colorbar
```

and to compare Figure 2 with Figure 4

## # Fast drawing

There are three main ways to do sequential plot or animations: `plot(x,y)`

, `set(h , 'XData' , y, 'YData' , y)`

and `animatedline`

. If you want your animation to be smooth, you need efficient drawing, and the three methods are not equivalent.

```
% Plot a sin with increasing phase shift in 500 steps
x = linspace(0 , 2*pi , 100);
figure
tic
for thetha = linspace(0 , 10*pi , 500)
y = sin(x + thetha);
plot(x,y)
drawnow
end
toc
```

I get `5.278172 seconds`

.
The plot function basically deletes and recreates the line object each time. A more efficient way to update a plot is to use the `XData`

and `YData`

properties of the `Line`

object.

```
tic
h = []; % Handle of line object
for thetha = linspace(0 , 10*pi , 500)
y = sin(x + thetha);
if isempty(h)
% If Line still does not exist, create it
h = plot(x,y);
else
% If Line exists, update it
set(h , 'YData' , y)
end
drawnow
end
toc
```

Now I get `2.741996 seconds`

, much better!

`animatedline`

is a relatively new function, introduced in 2014b. Let's see how it fares:

```
tic
h = animatedline;
for thetha = linspace(0 , 10*pi , 500)
y = sin(x + thetha);
clearpoints(h)
addpoints(h , x , y)
drawnow
end
toc
```

`3.360569 seconds`

, not as good as updating an existing plot, but still better than `plot(x,y)`

.

Of course, if you have to plot a single line, like in this example, the three methods are almost equivalent and give smooth animations. But if you have more complex plots, updating existing `Line`

objects will make a difference.