MATLAB Language
Disegno

Circles

L'opzione più semplice per disegnare un cerchio è, ovviamente, la funzione del rectangle .

%// radius
r = 2;

%// center
c = [3 3];

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

ma la curvatura del rettangolo deve essere impostata su 1 !

Il vettore position definisce il rettangolo, i primi due valori x e y sono nell'angolo in basso a sinistra del rettangolo. Gli ultimi due valori definiscono la larghezza e l'altezza del rettangolo.

pos = [ [x y] width height ]

L' angolo in basso a sinistra del cerchio - sì, questo cerchio ha angoli, quelli immaginari però - è il centro c = [3 3] meno il raggio r = 2 che è [xy] = [1 1] . Larghezza e altezza sono uguali al diametro del cerchio, quindi width = 2*r; height = width;

Nel caso in cui la scorrevolezza della soluzione di cui sopra non sia sufficiente, non c'è modo di aggirare usando il modo ovvio di disegnare un cerchio reale mediante l'uso di funzioni trigonometriche .

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

frecce

In primo luogo, si può usare la quiver , in cui non si ha a che fare con unità di figure normalizzate non coerenti mediante l'uso di 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)

Importante è il quinto argomento di quiver : 0 che disabilita un ridimensionamento altrimenti predefinito, in quanto questa funzione viene solitamente utilizzata per tracciare campi vettoriali. (o utilizzare la coppia di valori di proprietà 'AutoScale','off' )

Si può anche aggiungere funzionalità aggiuntive:

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

Se si desiderano punte di freccia diverse, è necessario utilizzare le annotazioni (questa risposta può essere utile Come si modifica lo stile della freccia nella trama del quiver? ).

La dimensione della freccia può essere regolata con la proprietà 'MaxHeadSize' . Purtroppo non è coerente. I limiti degli assi devono essere impostati in seguito.

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

C'è un altro tweak per le teste di freccia regolabili:

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

che puoi chiamare dal tuo script come segue:

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

Ellisse

Per tracciare un'ellisse puoi usare la sua equazione . Un'ellisse ha un asse maggiore e uno minore. Inoltre, vogliamo essere in grado di tracciare l'ellisse su diversi punti centrali. Pertanto scriviamo una funzione i cui input e output sono:

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

È possibile utilizzare la seguente funzione per ottenere i punti su un'ellisse e quindi tracciare quei punti.

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

Poligono (s)

Crea i vettori per mantenere le posizioni x e y dei vertici, inseriscili in patch .

Singolo poligono

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

Poligoni multipli

I vertici di ciascun poligono occupano una colonna di ciascuno di 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');

Trama Pseudo 4D

Una matrice (mxn) può essere rappresentata da una superficie usando surf ;

Il colore della superficie viene impostato automaticamente come funzione dei valori nella matrice (mxn) . Se la mappa di colori non è specificata, viene applicata quella predefinita.

È possibile aggiungere una barra di colore per visualizzare la mappa colori corrente e indicare la mappatura dei valori dei dati nella mappa colori.

Nell'esempio seguente, la matrice z (mxn) viene generata dalla funzione:

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

nell'intervallo [-pi,pi] . Le x ed y valori possono essere generati utilizzando la meshgrid funzione e la superficie è resa come segue:

% 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

Figura 1

Ora potrebbe essere il caso che ulteriori informazioni siano collegate ai valori della matrice z e che siano archiviate in un'altra matrice (mxn)

È possibile aggiungere queste informazioni aggiuntive sulla trama modificando il modo in cui la superficie è colorata.

Ciò consentirà di avere un tipo di trama 4D: per la rappresentazione 3D della superficie generata dalla prima matrice (mxn) , la quarta dimensione sarà rappresentata dai dati contenuti nella seconda matrice (mxn) .

È possibile creare tale trama chiamando surf con 4 input:

surf(x,y,z,C)

dove il parametro C è la seconda matrice (che deve essere della stessa dimensione di z ) e viene utilizzato per definire il colore della superficie.

Nell'esempio seguente, la matrice C viene generata dalla funzione:

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

nell'intervallo [-pi,pi]

La superficie generata da C è

figura 2

Ora possiamo chiamare surf con quattro input:

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

Figura 3

Confrontando la Figura 1 e la Figura 3, possiamo notare che:

• la forma della superficie corrisponde ai valori z (la prima matrice (mxn) )
• il colore della superficie (e il suo intervallo, dato dalla barra di colore) corrisponde ai valori C (la prima (mxn) matrice)

Figura 4

Naturalmente, è possibile scambiare z e C nel grafico per avere la forma della superficie data dalla matrice C e il colore dato dalla matrice z :

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

e confrontare la Figura 2 con la Figura 4

Disegno veloce

Ci sono tre modi principali per fare sequenze o animazioni sequenziali: plot(x,y) , set(h , 'XData' , y, 'YData' , y) e la linea animatedline . Se vuoi che la tua animazione sia liscia, hai bisogno di un disegno efficiente e i tre metodi non sono equivalenti.

% 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

Prendo 5.278172 seconds . La funzione di tracciatura in pratica elimina e ricrea ogni volta l'oggetto linea. Un modo più efficiente per aggiornare un XData YData proprietà XData e YData dell'oggetto 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

Ora ottengo 2.741996 seconds , molto meglio!

animatedline è una funzione relativamente nuova, introdotta nel 2014b. Vediamo come va:

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 , non buono come l'aggiornamento di un 3.360569 seconds esistente, ma ancora migliore della plot(x,y) .

Naturalmente, se devi tracciare una singola riga, come in questo esempio, i tre metodi sono quasi equivalenti e danno animazioni fluide. Ma se si dispone di grafici più complessi, l'aggiornamento degli oggetti Line esistenti farà la differenza.