MATLAB Language
Dessin

Des cercles

L'option la plus simple pour dessiner un cercle est évidemment la fonction rectangle .

%// radius
r = 2;

%// center
c = [3 3];

pos = [c-r 2*r 2*r];
rectangle('Position',pos,'Curvature',[1 1])
axis equal

mais la courbure du rectangle doit être réglée sur 1 !

Le vecteur de position définit le rectangle, les deux premières valeurs x et y sont le coin inférieur gauche du rectangle. Les deux dernières valeurs définissent la largeur et la hauteur du rectangle.

pos = [ [x y] width height ]

Le coin inférieur gauche du cercle - oui, ce cercle a des coins, mais imaginaires - est le centre c = [3 3] moins le rayon r = 2 qui est [xy] = [1 1] . La largeur et la hauteur sont égales au diamètre du cercle, donc width = 2*r; height = width;

Dans le cas où la finesse de la solution ci-dessus n'est pas suffisante, il n'y a pas moyen de contourner le moyen évident de dessiner un cercle réel en utilisant des fonctions trigonométriques .

%// 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

Flèches

Tout d'abord, on peut utiliser le quiver , où l'on n'a pas à traiter avec des unités de chiffres normalisées peu maniables en utilisant des 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 est le cinquième argument de quiver : 0 qui désactive une mise à l'échelle par défaut, car cette fonction est généralement utilisée pour tracer des champs de vecteurs. (ou utilisez la paire de valeurs de propriétés 'AutoScale','off' )

On peut également ajouter des fonctionnalités supplémentaires:

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')

Si des pointes de flèches différentes sont souhaitées, il faut utiliser des annotations (cette réponse peut être utile). Comment puis-je modifier le style de la flèche dans le diagramme de carquois?

La taille de la tête de flèche peut être 'MaxHeadSize' avec la propriété 'MaxHeadSize' . Ce n'est pas cohérent malheureusement. Les limites des axes doivent être définies ultérieurement.

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])

Il y a un autre ajustement pour les têtes de flèche réglables:

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

que vous pouvez appeler depuis votre script comme suit:

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

Pour tracer une ellipse, vous pouvez utiliser son équation . Une ellipse a un axe majeur et un axe mineur. Nous voulons également pouvoir tracer l'ellipse sur différents points centraux. Nous écrivons donc une fonction dont les entrées et les sorties sont:

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

Vous pouvez utiliser la fonction suivante pour obtenir les points sur une ellipse, puis tracer ces 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);

Polygone (s)

Créez des vecteurs pour contenir les emplacements x et y des sommets, insérez-les dans le patch .

Polygone unique

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

Plusieurs polygones

Les sommets de chaque polygone occupent une colonne de chacun des 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');

Tracé de pseudo 4D

Une matrice (mxn) peut être représentée par une surface en utilisant le surf ;

La couleur de la surface est automatiquement définie en fonction des valeurs de la matrice (mxn) . Si la palette de couleurs n'est pas spécifiée, celle par défaut est appliquée.

Une barre de couleur peut être ajoutée pour afficher la palette de couleurs actuelle et indiquer le mappage des valeurs de données dans la palette de couleurs.

Dans l'exemple suivant, la matrice z (mxn) est générée par la fonction:

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

sur l'intervalle [-pi,pi] . Les valeurs x et y peuvent être générées à l'aide de la fonction meshgrid et la surface est rendue comme suit:

% 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

Maintenant, il se peut que des informations supplémentaires soient liées aux valeurs de la matrice z et qu'elles soient stockées dans une autre matrice (mxn)

Il est possible d'ajouter ces informations supplémentaires sur le tracé en modifiant la couleur de la surface.

Cela permet d'avoir un peu de 4D plot: à la représentation 3D de la surface générée par la première matrice (mxn) , la quatrième dimension sera représentée par les données contenues dans la deuxième matrice (mxn) .

Il est possible de créer un tel complot en appelant surf avec 4 entrées:

surf(x,y,z,C)

où le paramètre C est la seconde matrice (qui doit avoir la même taille de z ) et sert à définir la couleur de la surface.

Dans l'exemple suivant, la matrice C est générée par la fonction:

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

sur l'intervalle [-pi,pi]

La surface générée par C est

Figure 2

Maintenant, nous pouvons appeler surf avec quatre entrées:

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

figure 3

En comparant les figures 1 et 3, on peut noter que:

• la forme de la surface correspond aux valeurs z (la première matrice (mxn) )
• la couleur de la surface (et son étendue, donnée par la barre de couleur) correspond aux valeurs C (la première matrice (mxn) )

Figure 4

Bien entendu, il est possible de permuter z et C dans le tracé pour avoir la forme de la surface donnée par la matrice C et la couleur donnée par la matrice z :

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

et comparer la figure 2 avec la figure 4

Dessin rapide

Il y a trois manières principales de faire un tracé séquentiel ou des animations: plot(x,y) , set(h , 'XData' , y, 'YData' , y) et ligne animatedline . Si vous voulez que votre animation soit fluide, vous avez besoin d'un dessin efficace et les trois méthodes ne sont pas équivalentes.

% 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

Je reçois 5.278172 seconds . La fonction de tracé supprime et recrée essentiellement l'objet ligne à chaque fois. Un moyen plus efficace de mettre à jour un tracé consiste à utiliser les propriétés XData et YData de l'objet Line .

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

Maintenant, j'obtiens 2.741996 seconds , beaucoup mieux!

animatedline est une fonction relativement nouvelle, introduite en 2014b. Voyons comment ça se passe:

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 , pas aussi bon que la mise à jour d'un tracé existant, mais toujours meilleur que le plot(x,y) .

Bien sûr, si vous devez tracer une seule ligne, comme dans cet exemple, les trois méthodes sont presque équivalentes et donnent des animations fluides. Mais si vous avez des tracés plus complexes, la mise à jour des objets Line existants fera une différence.