MATLAB Language
Zeichnung

Kreise

Die einfachste Möglichkeit, einen Kreis zu zeichnen, ist - offensichtlich - die rectangle .

%// radius
r = 2;

%// center
c = [3 3];

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

aber die Krümmung des Rechtecks ​​muss auf 1 gesetzt werden !

Der position definiert das Rechteck, die ersten beiden Werte x und y sind die linke untere Ecke des Rechtecks. Die letzten beiden Werte definieren die Breite und Höhe des Rechtecks.

pos = [ [x y] width height ]

Die untere linke Ecke des Kreises - ja, dieser Kreis hat Ecken, aber imaginäre - ist der Mittelpunkt c = [3 3] minus dem Radius r = 2 der [xy] = [1 1] . Breite und Höhe sind gleich dem Durchmesser des Kreises, also width = 2*r; height = width;

Für den Fall, dass die Glätte der obigen Lösung nicht ausreichend ist, gibt es keinen Weg, die offensichtliche Art und Weise zu verwenden, einen tatsächlichen Kreis unter Verwendung trigonometrischer Funktionen zu zeichnen.

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

Pfeile

Erstens kann man einen quiver , bei dem man nicht mit unhandlichen normalisierten Figureneinheiten durch annotation umgehen muss

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)

Wichtig ist das 5. Argument von quiver : 0, das eine ansonsten voreingestellte Skalierung deaktiviert, da diese Funktion normalerweise zum Zeichnen von Vektorfeldern verwendet wird. (oder verwenden Sie das Eigenschaftswertpaar 'AutoScale','off' )

Man kann auch zusätzliche Funktionen hinzufügen:

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

Wenn verschiedene Pfeilspitzen gewünscht werden, müssen Anmerkungen verwendet werden (diese Antwort kann hilfreich sein. Wie kann ich den Pfeilkopfstil in der Köcherzeichnung ändern? ).

Die Größe der Pfeilspitze kann mit der Eigenschaft 'MaxHeadSize' . Es ist leider nicht konsistent. Die Achsengrenzen müssen danach eingestellt werden.

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

Es gibt eine weitere Anpassung für einstellbare Pfeilspitzen:

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

die Sie aus Ihrem Skript wie folgt aufrufen können:

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

Um eine Ellipse zu zeichnen, können Sie deren Gleichung verwenden . Eine Ellipse hat eine Haupt- und eine Nebenachse. Außerdem möchten wir die Ellipse auf verschiedenen Mittelpunkten zeichnen können. Deshalb schreiben wir eine Funktion, deren Ein- und Ausgänge sind:

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

Sie können die folgende Funktion verwenden, um die Punkte auf einer Ellipse abzurufen und diese Punkte dann zu zeichnen.

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

Beispiel:

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

Polygon (e)

Erstellen Sie Vektoren, um die x- und y-Positionen von Scheitelpunkten zu patch .

Einzelnes Polygon

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

Mehrere Polygone

Die Scheitelpunkte jedes Polygons belegen jeweils eine Spalte von 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-Auftrag

Eine (mxn) -Matrix kann durch Surfen durch eine Oberfläche dargestellt werden;

Die Farbe der Oberfläche wird automatisch als Funktion der Werte in der (mxn) -Matrix festgelegt. Wenn keine Farbzuordnung angegeben wird, wird die Standardeinstellung angewendet.

Eine Farbleiste kann hinzugefügt werden, um die aktuelle Farbkarte anzuzeigen und die Zuordnung von Datenwerten in die Farbkarte anzuzeigen.

Im folgenden Beispiel wird die z (mxn) -Matrix von der Funktion generiert:

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

über dem Intervall [-pi,pi] . Die x und y Werte können mit der Netzgitterfunktion generiert werden und die Oberfläche wird wie folgt dargestellt:

% 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

Abbildung 1

Nun könnte es sein, dass zusätzliche Informationen mit den Werten der z Matrix verknüpft sind und in einer anderen (mxn) -Matrix gespeichert werden

Es ist möglich, diese zusätzlichen Informationen zur Darstellung hinzuzufügen, indem Sie die Art und Weise ändern, wie die Oberfläche gefärbt wird.

Dies ermöglicht eine Art 4D-Darstellung: Für die 3D-Darstellung der Oberfläche, die von der ersten (mxn) -Matrix erzeugt wird, wird die vierte Dimension durch die in der zweiten (mxn) -Matrix enthaltenen Daten dargestellt.

Sie können ein solches Diagramm erstellen, indem Sie surf mit 4 Eingaben aufrufen:

surf(x,y,z,C)

wobei der C Parameter die zweite Matrix ist (die dieselbe Größe wie z ) und zur Definition der Farbe der Oberfläche verwendet wird.

Im folgenden Beispiel wird die C Matrix von der Funktion generiert:

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

über dem Intervall [-pi,pi]

Die durch C erzeugte Fläche ist

Figur 2

Jetzt können wir mit vier Eingaben surf :

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

Figur 3

Beim Vergleich von Abbildung 1 und Abbildung 3 können wir Folgendes feststellen:

• die Form der Oberfläche entspricht den z Werten (der ersten (mxn) -Matrix)
• Die Farbe der Oberfläche (und ihr Bereich, angegeben durch die Farbleiste) entspricht den C Werten (der ersten (mxn) -Matrix).

Figur 4

Natürlich ist es möglich, z und C in der Auftragung auszutauschen, um die durch die C Matrix gegebene Form der Oberfläche und die durch die z Matrix gegebene Farbe zu erhalten:

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

und zum Vergleich von 2 mit 4

Schnelles Zeichnen

Es gibt drei Hauptmöglichkeiten für sequentielle Plots oder Animationen: plot(x,y) , set(h , 'XData' , y, 'YData' , y) und animatedline set(h , 'XData' , y, 'YData' , y) . Wenn Sie eine reibungslose Animation wünschen, benötigen Sie ein effizientes Zeichnen. Die drei Methoden sind nicht gleichwertig.

% 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

Ich bekomme 5.278172 seconds . Mit der Plot-Funktion wird das Linienobjekt grundsätzlich jedes Mal gelöscht und neu erstellt. Eine effizientere Methode zum Aktualisieren eines Diagramms ist die Verwendung der XData und YData Eigenschaften des Line Objekts.

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

Jetzt bekomme ich 2.741996 seconds , viel besser!

animatedline ist eine relativ neue Funktion, die 2014b eingeführt wurde. Mal sehen, wie es läuft:

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 , nicht so gut wie das Aktualisieren einer vorhandenen 3.360569 seconds , aber immer noch besser als die plot(x,y) .

Wenn Sie, wie in diesem Beispiel, eine einzige Linie plotten müssen, sind die drei Methoden fast gleichwertig und ergeben glatte Animationen. Wenn Sie komplexere Plots haben, wird das Aktualisieren vorhandener Line Objekte einen Unterschied machen.