Beliebte Posts:

Sonntag, 13. November 2016

Matlab: GUI Interface

Erstellen eines GUI interfaces

(English) In diesem Beitrag zeige ich wie man mit Matlab ganz einfach ein GUI Interface mit Buttons etc. erstellt und ein Programm daraus schreibt.
Hierfür muss zuerst in Matlab in die Konsule "guide" eingegeben werden, dass sich ein Fester öffnet. Hier kann man jetzt entweder schon erstellt Interfaces öffnen oder ein neues erstellen.


In einem neu erstellten Interface kann ganz einfach mit den entsprechenden Buttons und anderen Objekten eine Oberfläche erstellt werden. Dies kann man speichern und ausführen woraufhin ein Matlab Code erstellt wird.
Für die Programmierung ist wichtig, dass hierbei jedem Objekt ein "Tag" zugeordnet wird und benannt wird. Dies kann man mit dem "Inspector" bearbeiten, indem einfach auf ein Objekt doppelt geklickt wird. Hier können auch noch weitere Einstellungen wie Design oder "Value" oder "Name" angegeben werden:
Hier kann nun mit dem grünen Pfeil des Editors der Code erstellt werden und die einzelnen Funktionen definiert werden.

Programmieren des GUI interfaces

Der Button kann nun programmiert werden, indem  in dem Quellcode unter "function pushbutton1_Callback(hObject, eventdata, handles)" der Code eingegeben wird. In meinem Fall zeichne ich eine Spirale in "axes1" in Abhängigkeit des Wertes des Textfeldes daneben (zwischen 0 und 3 Pi). Hierfür wird der Wert von "Slider" verwendet um die Reichweite von "x" zu anzugeben. Mit "global" kann man die Variable zu einer globalen Variable machen, wobei darauf zu achten ist, wenn sie in einem anderen Abschnitt benutzt wird muss immer erst "global x" hinu´zugefügt werden.

function pushbutton1_Callback(hObject, eventdata, handles)
global x;
xneu = 1080*get(handles.slider1,'Value')
x = [0:0.1:xneu/180*pi];


Für das Zeichnen wird erst die "axis" des Graph "axes1" ausgewählt:

axis(handles.axes1);

und dann geplottet:

plot(sin(x).*x,cos(x).*x,'parent',handles.axes1);
guidata(hObject,handles);

als nächstes wird der Wert der "Checkbox" eingelesen mit "get(handles...)"

check = get(handles.checkbox1,'Value');if check == 1
    axis(handles.axes2);
    plot(x,cos(x).*x,'parent',handles.axes2);
    guidata(hObject,handles);
end


Falls die Checkbox aktiviert ist, wird in "axes2" ebenfalls eine Funktion geplottet.
Für den "Slider" und die "Editbox" wird jeweils das "hObject", der Wert, mit "set" auf das andere übertragen, damit die beiden immer den gleichen Wert anzeigen.

function slider1_Callback(hObject, eventdata, handles)

slider = num2str( round(get(hObject,'Value')*1080,2) );
set(handles.edit1,'String', slider);


...

function edit1_Callback(hObject, eventdata, handles)

edit = round(str2num( get(hObject,'String') ),2);
set(handles.slider1,'Value',edit/(1080));


Hilfreich ist bei dem "Slider", der "Checkbox" und der "Editbox" jeweils wieder den Button aufzurufen, damit automatisch neu geplottet wird:

pushbutton1_Callback(hObject, eventdata, handles);

All die anderen Objekte der GUI Interface funktionieren änhlich und können immer mit der "Callback" Funktion editiert werden.

Quellcode:

function varargout = GUI(varargin)
gui_Singleton = 1;
gui_State = struct('gui_Name',       mfilename, ...
                   'gui_Singleton',  gui_Singleton, ...
                   'gui_OpeningFcn', @GUI_OpeningFcn, ...
                   'gui_OutputFcn',  @GUI_OutputFcn, ...
                   'gui_LayoutFcn',  [] , ...
                   'gui_Callback',   []);
if nargin && ischar(varargin{1})
    gui_State.gui_Callback = str2func(varargin{1});
end

if nargout
    [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
    gui_mainfcn(gui_State, varargin{:});
end


function GUI_OpeningFcn(hObject, eventdata, handles, varargin)

handles.output = hObject;

guidata(hObject, handles);


function varargout = GUI_OutputFcn(hObject, eventdata, handles)

varargout{1} = handles.output;


% this is the buttom that shows the figures
function pushbutton1_Callback(hObject, eventdata, handles)
global x;
xneu = 1080*get(handles.slider1,'Value')
x = [0:0.1:xneu/180*pi];

axis(handles.axes1);
plot(sin(x).*x,cos(x).*x,'parent',handles.axes1);
guidata(hObject,handles);

check = get(handles.checkbox1,'Value');
if check == 1
    axis(handles.axes2);
    plot(x,cos(x).*x,'parent',handles.axes2);
    guidata(hObject,handles);
end

% this checkbox is plotting both figures if it is on
function checkbox1_Callback(hObject, eventdata, handles)
pushbutton1_Callback(hObject, eventdata, handles);

% --- Executes on slider movement.
function slider1_Callback(hObject, eventdata, handles)

slider = num2str( round(get(hObject,'Value')*1080,2) );
set(handles.edit1,'String', slider);
pushbutton1_Callback(hObject, eventdata, handles);

function slider1_CreateFcn(hObject, eventdata, handles)

if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor',[.9 .9 .9]);
end



function edit1_Callback(hObject, eventdata, handles)

edit = round(str2num( get(hObject,'String') ),2);
set(handles.slider1,'Value',edit/(1080));
pushbutton1_Callback(hObject, eventdata, handles);

function edit1_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))
    set(hObject,'BackgroundColor','white');
end



Sonntag, 19. Juni 2016

Matlab: alle Dateien aus Ordner darstellen

Öffnen und Darstellen aller Dateien aus einem Ordner

(English) In diesem Post wird beschrieben, wie aus einem Ordner mit Matlab alle Dateien geöffnet und geplottet werden können.
Zuerst werden alle Datein des Formats  *.txt geladen und in files gespeichert.

files = dir('*.csv');

Dann werden alle Dateien in eine Variable gespeichert. Für value = 2 wird beispielsweise nur jede 2. Datei genommen.

for i = 1:1:length(files)/value
    fid3{i}=files(i).name;
end

Diese Dateien sind noch nicht sortiert und können nun sortiert werden. Hierfür muss "natsortfiles" aus Matlab-Exchange heruntergeladen werden:

fid3 = natsortfiles(fid3)
for i = 1:value:length(files) 
    fid = fopen(fid3{i});
    daten = textscan(fid,'%f %f','delimiter',',','headerlines',0');
    q1(:,i/value) = daten(1);
    q2(:,i/value) = daten(2);
end
fclose(fid);

Im "textscan"-Befehl wird mit 'headlines',0 die Anzahl der Zeilen der .txt Datei gelöscht. Die Daten aus Spalte 1 werden in q1 und aus Spalte 2 in q2 gespeichert.

Nun werden die Dateien geöffnet und als Matrix abgespeichert. aus q1 und q2 kann nun noch ein Bereich ausgesucht werden und als x und y gespeichert werden:

%convert cell to matrix
q1=cell2mat(q1);
q2=cell2mat(q2);
%take a defined area
x = q1(650:1150,:);
y = q2(650:1150,:);

Nun können die Daten wie folgt geplottet werden. Dabei wird die Funktion ColSpec genutzt.

fig = figure(1)
hold on;
for i=1:1:length(files)
     h(i)=plot(x(:,i),y(:,i),'Color',ColSpec(length(x),i);
 end

Nun können noh die Daten durchnummeriert werden und dann in der Legende dargestellt werden:

leg = num2str([1:1:length(files)]');
leg = strcat('Datei', leg);
legend(h2,leg,'location','EastOutside');





Matlab: Farbspektrum für Plots

Farbspektren mit Matlab

(English) In diesem Post wird beschrieben, wie mit meiner Funktion für Matlab, ein Farbspektrum erzeugt werden kann, sodass verschiedene Plots alle verschiedene Farben haben.
Hierfür habe ich die Funktion geschrieben (Download):

function [CoolSpec] = ColSpec(a,q,value,start,m,k,inv)

Es kann also mit "a" die Anzahl der verschiedenen Farben im Bereich von rot über gelb zu grün zu blau und zu pink abgegeben werden. Mit dem Wert q wird der q'te Wert des Spektrums zurückgegeben. Mit "value" wird die Weite des Spektrums beschreiben also für Wert größer 1 wird sich die Farbe weniger ändern. "start" gibt den Startwert der Farbe an. Dabei ist rot (start = 0), gelb (start = 0.5), grün(start = 1), hellblau (start = 1.5-2), dunkelblau (start = 2.5) und pink (start = 3) und dann beginnts wieder von vorne. Mit "m" und "k" kann für kleinere Werte als 1 die Helligkeit der Kuven kontinuierlich verringert werden. Mit Werten "inv" kann für ungleich 0 das Spektrum von blau über grün nach rot verwendet werden.

Hier sind vier verschiedene Parameter beispielhaft gezeigt:
ColSpec(21,i,1.2,0,0.8,1,2);



 Mit den Parametern ColSpec(5,:,1,0) bzw. ColSpec(5)


  Mit den Parametern ColSpec(5,:,2,0)
  Mit den Parametern ColSpec(5,:,2,2)

Quellcode:

function [CoolSpec] = ColSpec(a,q,value,start,m,k,inv)
% This Function creates a colorsweep for mulitple plots.
%Therefor "a" defines the amount of different colors
% "q" ist the qth value which is created
% "value" defines how far the sweep should be. So for value = 1
% the sweep goes form red to yellow to green to blue to violett.
%start is the value at which color you want to start.
%start = 0 --> red
%start = 0.5 --> yellow
%start = 1 --> green
%start = 1.5 - 2 --> brigthblue
%start = 2.5 --> darkblue
%start = 3 --> pink
%m and q handels the brigthness of th curve
%inv handels the inverted spectra from blue to red over over

if nargin <7
    inv = 0;
end
if nargin <6
    k=1;
end
if nargin <5
    m=0.9;
end
if nargin <4
    start = 0;
end
if nargin <3
    value=1;
end
alt = a;
a = a*value*1.2;
s = round(start*alt/3);
speed = 6;
for j=s:1:alt+s-1
    i=j;
    if i>a;
        i = round(i-a);
    end
    if i<a/(3)
        r = 2*m-i/a*speed;
        g = i/a*speed;
        b = 0;      
    end
    if i>=a/(3) && i<2*a/(3)
        r = 0;
        g = 2*m-(i-a/(3))/a*speed;
        b = (i-a/(3))/a*speed;      
    end
    if i>=2*a/(3)
        r = (i-2*a/(3))/a*speed;
        g = 0;
        b = 2*m-(i-2*a/(3))/a*speed;      
    end
    %ROT
    if r<0
        r1 = 0;
    elseif r<1
        r1 = r;
    else
        r1=m;
    end
    %GRÜN
    if g<0
        g1 = 0;
    elseif g<1
        g1 = g;
    else
        g1=m;
    end
  
    if b<0
        b1 = 0;
    elseif b<1
        b1 = b;
    else
        b1=m;
    end
  
    if inv == 0
        col = [k*r1 k*g1 k*b1];
    else
        col = [k*b1 k*g1 k*r1];
    end
    CoolSpec{j-s+1,:} = col;
    if i>alt;
        i = 0;
    end
end
if nargin > 1
    CoolSpec = CoolSpec{q,:};
end

Sonntag, 15. Mai 2016

Matlab: optische Aufbauten

Optikenaufbauten mit Matlab

(English) Dieser Post ist dazu da, optische Aufbauten aus Linsen, Spiegeln und anderen Optiken schön mit Matlab darzustellen. Dafür habe ich einige einzelne Funktionen geschrieben mit denen man diese infolgender Form benutzen kann (MATLAB Dateien):
opticlense(x,y,deg,thick,dx,dy,color)
opticbeamsplitter(x,y,deg,thick,dx,dy,color)
opticbikonvex(x,y,deg,thick,dx,dy,color) 
opticdistance(x1,y1,x2,y2,string,len,thick,color)
opticline(x,y,deg,len,thick,color)
opticmirror(x,y,deg,style,thick,color,len)
opticslit(x,y,deg,thick,color,len)

Hierbei gibt x und y die Position des optischen Elements an. So kann nun Maßstabgetreu in Matlab die Linsen positioniert werden. deg gibt den Winkel der Neigung der Optik an und dx, dy bzw. len die Länge in x, y Richtung. color bestimmt die Farbe der Optik und thick die Dicke der Linie. In opticdistance x1,y1 sind die Startwerte und x2,y2 die Endwerte des Abstandes, wobei mit string der Name (z.B. die Entfernung) eingegeben werden kann. In opticmirror stellt style für den Wert 0 einen normalen Spiegel und für 1 einen gestrichelten Spiegel dar. In folgender Abbildung ist der Versuchsaufbau meine Bachelorarbeit zu sehen wie diese mit Matlab in Latex eingebunden wurde:

Quellcode:

clear all;
clc;




fig(1) = figure(1);
clf(1);
hold on;
box off;
axis off;
xLaser = [-11.4 -2.4 -2.4 -11.4 -11.4];
yLaser = [2 2 7.7 7.7 2];
text(-11,6,'Ti:Saphir Laser','interpreter','Latex')
text(-11,4.6,'76 MHz; 800 nm','interpreter','Latex')
text(-11,3.2,'Pulsrate: 150 fs')
plot(xLaser,yLaser,'Color',colors('darkred'),'linewidth',1.15);
xbLaser = [-7 -10.5 -10.5 -7 -7];
ybLaser = [-5.5 -5.5 -2.5 -2.5 -5.5];
text(-10.2,-4,'SHG')
plot(xbLaser,ybLaser,'Color',colors('blue'),'linewidth',1.15);
%xLight = [12.2 9.1 9.1 12.2 12.2];
%yLight = [-12 -12 -10 -10 -12];
opticlense(10,-10,45,1,1.2,1.2,colors('yellow'));
opticlense(10,-10,225,1,1.2,1.2,colors('yellow'));
opticlense(10,-10,135,1,1.2,1.2,colors('yellow'));
opticlense(10,-10,315,1,1.2,1.2,colors('yellow'));
text(8.9,-8.5,'WLC','interpreter','latex')
%plot(xLight,yLight,'Color',colors('yellow'),'linewidth',1.15);

xSpec = [-18 -18 -23 -23 -18 -18];
ySpec = [-19.8 -15 -15 -21 -21 -20.2];
text(-22.7,-15.8,'Monochr.');
plot(xSpec,ySpec,'Color',[0 0 0],'linewidth',1.15);
opticline(-19,-20,45);
xmono = [-20:0.1:-18.5];
xmono2 = [-22.5:0.1:-21];
opticline(-20.5,-20,15,2,1.6);
plot(xmono,-21.5+5*cos((xmono+19.25)*0.35),'Color',[0 0 0]);
plot(xmono2,-21.5+5*cos((xmono2+21.75)*0.35),'Color',[0 0 0]);



xSpecc = [-21.75 -22.25 -22.25 -21.75 -21.75];
ySpecc = [-21 -21 -21.5 -21.5 -21];
plot(xSpecc,ySpecc,'Color',[0 0 0],'linewidth',1.15);

xSpecb = [-23.5 -23 -23 -23.5 -23.5];
ySpecb = [-19.75 -19.75 -20.25 -20.25 -19.75];
plot(xSpecb,ySpecb,'Color',[0 0 0],'linewidth',1.15);

xStreak = [-20 -27 -27 -20 -20];
yStreak = [-24.5 -24.5 -21.5 -21.5 -24.5];
text(-26,-23,'LN$_2$-CCD','interpreter','latex');
plot(xStreak,yStreak,'Color',[0 0 0],'linewidth',1.15);

xspec2 = [-23.5 -28 -28 -23.5 -23.5];
yspec2 = [-19 -19 -21 -21 -19];
text(-27.8,-20,'Streak');
plot(xspec2,yspec2,'Color',[0 0 0],'linewidth',1.15);

xUSB1 = [-12.3 -9.3 -9.3 -12.3 -12.3];
yUSB1 = [-16.5 -16.5 -14.7 -14.7 -16.5];
plot(xUSB1,yUSB1,'Color',[0 0 0],'linewidth',1.15);
plot([-10.6 -11 -11.4 -10.2 -10.6],[-16.5 -16.5 -17 -17 -16.5],'Color',[0 0 0],'linewidth',1.15);
text(-12.4,-15.7,'CCD')

xUSB2 = [7.3 4.3 4.3 7.3 7.3];
yUSB2 = [-17.5 -17.5 -15.7 -15.7 -17.5];
plot([5.6 6 6.4 5.2 5.6],[-17.5 -17.5 -18 -18 -17.5],'Color',[0 0 0],'linewidth',1.15);
plot(xUSB2,yUSB2,'Color',[0 0 0],'linewidth',1.15);
text(4.2,-16.7,'CCD')

%opticdistance(-2.4,3,18.6,3,'105 cm');
%opticdistance(23,-4,23,-6,'10 cm');
%opticdistance(23,-6,23,-19,'115 cm');
%opticdistance(23,-19,23,-20.5,'7.5 cm');
%opticdistance(18.6,-8.5,-5.4,-8.5,'120 cm');
%opticdistance(-12,-22,12,-22,'120 cm');


plot([-2.4 10.6],[3 3],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
%plot([0 0],[0 -4],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
%plot([0 10.6],[-4 -4],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([10.6 10.6],[3 -4],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([10.6 -5.4],[-4 -4],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-5.4 -7],[-4 -4],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-10.5 -24],[-4 -4],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-24 -24],[-4 -1.2],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-24 -5.4],[-1.2 -1.2],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-5.4 -5.4],[-1.2 -20],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);

plot([-5.4 9.4],[-10 -10],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
%plot([-2.4 -2.4],[-9.5 -11],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
%plot([-2.4 12.2],[-11 -11],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);


plot([-5.4 5],[-20 -20],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([5 12],[-20 -20],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([12 12],[-20 -24],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([12 -12],[-24 -24],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-12 -12],[-24 -20],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-10.8 -10.8],[-20 -17],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-12 -5.4],[-20 -20],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-12 -19],[-20 -20],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([5.8 5.8],[-20 -18],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-19 -19.25],[-20 -16.5],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-19.25 -20.5],[-16.5 -20],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-20.5 -21.75],[-20 -16.5],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);
plot([-21.75 -22],[-16.5 -21],'-','Color',[0.6 0.6 0.6],'linewidth',1.3);

%Bereiche
xba = [-12 -12 -2.1 -2.1 12.7 12.7 -12];
yba = [8.5 1 1 -6.2 -6.2 8.5 8.5];
plot(xba,yba,'--','Color',colors('darkred'),'linewidth',1.15);
text(-14.5,7.5,'\textbf{(a)}','Color',colors('darkred'),'interpreter','latex');

xbb = [-2.8 -2.8 -27.5 -27.5 -2.8];
ybb = [0.2 -6.2 -6.2 0.2 0.2];
plot(xbb,ybb,'--','Color',colors('blue'),'linewidth',1.15);
text(-26.6,1.5,'\textbf{(b)}','Color',colors('blue'),'interpreter','latex');

xbc = [-8 -8 12.7 12.7 -8];
ybc = [-12.1 -7.2 -7.2 -12.1 -12.1];
plot(xbc,ybc,'--','Color',colors('yellow'),'linewidth',1.15);
text(-10.3,-8.5,'\textbf{(c)}','Color',colors('yellow'),'interpreter','latex');

xbd = [-13.3 -13.3 12.7 12.7 -13.3];
ybd = [-12.6 -26 -26 -12.6 -12.6];
plot(xbd,ybd,'--','Color',colors('green'),'linewidth',1.15);
text(-13,-11.5,'\textbf{(d)}','Color',colors('green'),'interpreter','latex');

xbd = [-13.8 -13.8 -28.5 -28.5 -13.8];
ybd = [-14.5 -26 -26 -14.5 -14.5];
plot(xbd,ybd,'--','Color',colors('orange'),'linewidth',1.15);
text(-29,-13.5,'\textbf{(e)}','Color',colors('orange'),'interpreter','latex');

%
%xp = [-0.6 -0.6 -1.8 -1.8 -0.6];
%yp = [0.3 -0.3 -0.3 0.3 0.3];
%plot(xp,yp,'Color',[0 0 0],'linewidth',1.15);
%text(-2.0,1,'Cw')
%opticmirror(0,0,45,0,1.15,colors('darkred'));
%opticmirror(0,-4,45,0,1.15,colors('darkred'));

opticlense(2.5,3,90);
text(1,4.5,'$\text{CL}_1$','interpreter','latex');
opticlense(7.5,3,-90);
text(5.5,4.5,'$\text{CL}_2$','interpreter','latex');
%opticline(9.4,-4,90);
%text(8,-3,'$\nicefrac{\lambda}{2}$','interpreter','latex');
%opticbeamsplitter(10.6,-4,90);
%text(10.3,-3,'Pbs','interpreter','latex');
%opticline(10.6,-5,-45);
%text(10.7,-5,'Gp','interpreter','latex');
opticmirror(10.6,3,45,0,1.15,colors('darkred'));
text(9.9,4,'$\text{DM}_1$','interpreter','latex');
opticmirror(10.6,-4,-45,0,1.15,colors('darkred'));
text(9.9,-5.2,'$\text{DM}_1$','interpreter','latex');
opticlense(9,-4,-90);
text(8.2,-5.5,'$\text{L}_1$','interpreter','latex');
arrow2D(8,-2.5,180,[0 0 0],6,6,1.15);
arrow2D(9.5,-2.5,0,[0 0 0],6,6',1.15);
plot([8 9.5],[-2.5 -2.5],'k','linewidth',1.15);
%opticslit(16.2,-6,90);

%blue light
opticmirror(-5.4,-4,-45,1,1.15,colors('darkred'));
text(-5.6,-5.1,'RM','interpreter','latex');

opticlense(-12.4,-4,90);
text(-12.8,-5.5,'$\text{L}_2$','interpreter','latex');
text(-15,-5.5,'$\text{PH}_1$','interpreter','latex');
opticslit(-13.4,-4,90);

opticlense(-17.4,-4,90);
text(-17.8,-5.5,'$\text{L}_2$','interpreter','latex');
arrow2D(-18,-2.5,180,[0 0 0],6,6,1.15);
arrow2D(-16.5,-2.5,0,[0 0 0],6,6,1.15);
plot([-18 -16.5],[-2.5 -2.5],'k','linewidth',1.15);
text(-19,-5.5,'$\text{I}_1$','interpreter','latex');
opticslit(-18.4,-4,90);

opticmirror(-24,-4,45,0,1.15,colors('blue'));
text(-27,-0.7,'$\text{DM}_2$','interpreter','latex');

opticmirror(-24,-1.2,-45,0,1.15,colors('blue'));
text(-27,-4.5,'$\text{DM}_2$','interpreter','latex');

opticline(-22.4,-1.2,90);
text(-22.2,-2.2,'$\text{F}_1$','interpreter','latex');
opticmirror(-5.4,-1.2,45,0,1.15,colors('blue'));
text(-5.6,-0.8,'$\text{DM}_2$','interpreter','latex');

%white light
text(-5.3,-8.5,'RM','interpreter','latex');
opticmirror(-5.4,-10,-45,1);

opticbeamsplitter(-1.4,-10,90);
text(-2.2,-8.5,'P','interpreter','latex');
opticlense(0.35,-10,-90);
text(-0.5,-8.5,'$\text{L}_5$','interpreter','latex');
opticlense(2.35,-10,90);
text(1.6,-8.5,'$\text{L}_4$','interpreter','latex');
opticlense(5.8,-10,-90);
text(4.5,-8.5,'$\text{L}_3$','interpreter','latex');
arrow2D(2,-11.5,180,[0 0 0],6,6,1.15);
arrow2D(3.5,-11.5,0,[0 0 0],6,6,1.15);
plot([2 3.5],[-11.5 -11.5],'k','linewidth',1.15);

opticslit(6.9,-10,90);
text(6,-8.5,'$\text{PH}_2''$','interpreter','latex');


%all three
%opticline(-5.4,-9.5,0);
%text(-5,-9.5,'Cw','interpreter','latex')
opticline(-5.4,-13.5,0);
text(-5,-13.75,'FW','interpreter','latex');
opticline(-5.4,-14,0);

opticlense(-5.4,-15.4,180);
text(-5,-15.7,'$\text{L}_6$','interpreter','latex');


opticmirror(-5.4,-20,45);
text(-6.8,-20.9,'BS','interpreter','latex');

opticlense(-4.4,-20,90);
text(-5,-18.5,'$\text{L}_3''$','interpreter','latex');
opticlense(-1.4,-20,-90);
text(-2.6,-18.5,'$\text{L}_4''$','interpreter','latex');

%CRYOSTAT

xcry3 = [0.1 0.1 1.1 1.1 0.1];
ycry3 = [-20 -19 -20 -21 -20];
plot(xcry3,ycry3,'Color',[0.6 0.6 0.6],'linewidth',1.15);

xcry = [-0.2 -0.2 0.4 0.4 -0.2];
ycry = [-20 -19.3 -20 -20.7 -20];
plot(xcry,ycry,'k','linewidth',1.15);

plot([1.1 0.1],[-21 -21],'Color',[0.6 0.6 0.6],'linewidth',1.15);
plot([1.1 0.1],[-20 -20],'Color',[0.6 0.6 0.6],'linewidth',1.15);
plot([0.1 -0.9],[-19 -19],'Color',[0.6 0.6 0.6],'linewidth',1.15);

xcry2 = [-0.9 -0.9 0.1 0.1 -0.9];
ycry2 = [-20 -19 -20 -21 -20];
plot(xcry2,ycry2,'Color',[0.6 0.6 0.6],'linewidth',1.15);

xend = [-0.9 -0.9 0.1 0.1 -0.9];
yend = [-20 -19 -20 -21 -20];
plot(xend,yend,'Color',[0.6 0.6 0.6],'linewidth',1.15);
%doublearrwow
arrow2D(-1,-21.5,0,[0 0 0],6,6,1.15);
arrow2D(-2.5,-21.5,180,[0 0 0],6,6,1.15);
plot([-2.5 -1],[-21.5 -21.5],'k','linewidth',1.15);


arrow2D(1,-21.5,180,[0 0 0],6,6,1.15);
arrow2D(2.5,-21.5,0,[0 0 0],6,6,1.15);
plot([2.5 1],[-21.5 -21.5],'k','linewidth',1.15);


arrow2D(0,-21.3,90,[0 0 0],4,6,1.15);
arrow2D(0,-23.2,-90,[0 0 0],4,6,1.15);
plot([0 0],[-21.3 -23.2],'k','linewidth',1.15);

arrow2D(-0.65,-21.55,135,[0 0 0],5,5,1.15);
arrow2D(0.65,-22.95,-45,[0 0 0],5,5',1.15);
plot([-0.65 +0.65],[-21.55 -22.95],'k','linewidth',1.15);

%opticline(0.1,-19,90);
arrow2D(0.3,-18.5,233,[0 0 0],6,6,1.15);
plot([0.3 0.3+0.5*2.5],[-18.5 -18.5+0.707*2.5],'k','linewidth',1.15);
text(-1,-14.8,'sample in');
text(-1,-16,'cryostate');

opticlense(1.6,-20,90);
text(1.0,-18.5,'$\text{L}_4''$','interpreter','latex');


text(2.8,-18.5,'$\text{L}_6''$','interpreter','latex');
opticlense(4,-20,-90);
text(7.7,-18.5,'$\text{L}_7$','interpreter','latex');
opticlense(8.3,-20,90);
opticmirror(5.8,-20,-45,1);
text(5.2,-21.2,'$\text{RM}''$','interpreter','latex');


opticmirror(-12,-20,45,1);
text(-11.0,-21.2,'$\text{RM}''$','interpreter','latex');

text(-13.2,-19,'$\text{RM}$','interpreter','latex');

text(-8.5,-18.5,'$\text{L}_5''$','interpreter','latex');
opticlense(-7.4,-20,-90);

text(-10.3,-18,'$\text{L}_4''''$','interpreter','latex');
opticlense(-10.8,-18.3,0);
text(-13.5,-25,'MM');
opticmirror(-12,-24,+45);
text(9.9,-25,'MM');
opticmirror(12,-24,-45);
text(9.9,-18.8,'MM');
opticmirror(12,-20,+45);
%text(-10.2,-18,'RM','interpreter','latex');
opticmirror(-10.8,-20,45,1);

opticline(-14.8,-20,90);
text(-16.0,-18.5,'$\text{F}_{\text{1,2}}$','interpreter','latex');

text(-17.4,-18.5,'$\text{L}_7''$','interpreter','latex');
opticlense(-16.5,-20,90);
arrow2D(-15.7,-21.5,0,[0 0 0],6,6,1.15);
arrow2D(-17.2,-21.5,180,[0 0 0],6,6,1.15);
plot([-17.2 -15.7],[-21.5 -21.5],'k','linewidth',1.15);

text(-17.4,-18.5,'$\text{L}_7''$','interpreter','latex');

xl = [-28.5 12.7 12.7 -28.5 -28.5];
yl = [-26.8 -26.8 -38.2 -38.2 -26.8];
plot(xl,yl,'k','linewidth',1.15);

text(-27,-28.5,'CL');
text(-24,-28.5,'zylindrische Linse');
text(-27,-30.5,'L');
text(-24,-30.5,'Linse');
text(-27,-32.5,'PH');
text(-24,-32.5,'Lochblende');
text(-27,-34.5,'BS');
text(-24,-34.5,'Strahlteiler');
text(-27,-36.5,'SHG');
text(-24,-36.5,'Frequenzverdoppelung');

text(-13,-28.5,'RM');
text(-10,-28.5,'beweglicher Spiegel');
text(-13,-30.5,'DM');
text(-10,-30.5,'dielektrischer Spiegel');
text(-13,-32.5,'MM');
text(-10,-32.5,'metalischer Spiegel');
text(3,-34.5,'I');
text(6,-34.5,'Irisblende');

text(3,-28.5,'F');
text(6,-28.5,'Filter');
text(3,-30.5,'FW');
text(6,-30.5,'Filterrad');
text(3,-32.5,'P');
text(6,-32.5,'Polarisator');
text(-13,-34.5,'WLC');
text(-10,-34.5,'Weisslichtlampe');

%set(gca, 'linewidth',1.5);
xlim([-29 13]);
%ylim([-23.5 8]);
%set(findall(gcf,'-property','FontSize'),'FontSize',10)
%set(findobj(gcf,'-property','FontSize'),'FontSize',10)

matlab2tikz('compositionneu.tikz', 'height', '\figureheight', 'width', '\figurewidth', 'figurehandle', fig(1));

Montag, 18. April 2016

Theremin: Das elektrische Musikinstrument

Allgemein:

(English) Ein Theremin ist ein elektrisches Musikinstrument, welches durch zwei Schwingkreise geregelt wird, indem an einem Schwingkreis eine Antenne angeschlossen ist. Durch Annäherung der Hand wird die Kapazität geändert und somit auch die Frequenz des Schwingkreises. Schlussendlich hört man die Differenz zwischen den beiden Schwingkreisen.

Aufbau:

Hierfür habe ich folgende Schaltung genommen.

Die Stückliste ist wie folgt:
  • OPV TL071 x2
  • LM386 x1

    Kondensator:
  • 100 nF x2
  • 220 nF x2
  • 47 pF x2
  • 47 nF x1
  • 100 pF x1
  • 10 nF x1
  • Elko 220 u x3

    Widerstand:
  • 100 k  x4
  • 22 k x4
  • 47 k x2
  • 10 x1

    Potentiometer:
  • 100k x1
  • 10k x2

    Sonstiges:
  • Diode 1N4007 1
  • BAT42 2
  • Antenne
  • Lautsprecher
Um das Theremin mit Strom zu versorgen werden entweder 2 9V-Akkus benötigt die in Reihe geschaltet sind oder sonstige 18V Spannungsdifferenz. Mit Netzteilen ist es kritisch, da diese eine richtige Erdung brauchen. Eignen könnten sich dafür diese Stecker, falls man so wie ich zwei 9V-Netzteile hat. Alles aufgebaut sieht dies dann auf dem Steckbrett in etwas so aus (Mit zusätzlichem Lautsprecheranschluss und On-Off Schalter): Wichtig ist, dass kurze Kabel verwendet werden und knapp über dem Steckbrett, da das Theremin sehr stark dadurch beeinflusst wird und sich deswegen die Tonhöhe ändert.
Steckerkonstruktion als +-9V Quelle
Wie zu sehen, habe ich mir eine Antennenhalterung aus dem 3D Drucker gedruckt (STL-Datei). 
Als Antenne eignet sich so ziemlich jeder elektrisch leitender Stoff der fest ist. 
Wird nun noch alles in ein Gehäuse aus dem 3D-Drucker von meinem Bruder eingebracht sieht dies wie folgt aus: 





Hier kann jedes Einzelteil für das Gehäuse gedruckt werden bzw. noch nachgearbeitet werden.

 Anwendung:

Die Anwendung ist einfach: Je näher man mit der Hand zur Antenne geht, desto tiefer wird der Ton (Ausnahmen siehe in "Analyse"). Bewegt man die zweite Hand über das Theremin merkt man, dass sich ebenfalls der Ton ändert, da dieser sehr empfindlich ist. Dies kann zum Beispiel ausgenutzt werden, um die Reichweite der Töne ("Range") zu verändern. Normalerweise kann das Theremin eine Oktave aber wird mit der anderen Hand ebenfalls der Schwingkreis verändert gehen sogar 2-3 Oktaven.
Praktisch ist auch, um die Range zu erhöhen muss man sehr nah an die Antenne ran. Wird diese allerdings berührt wird das Signal unterbrochen. Da der Ton reziprok tiefer wird, sind kleinste Änderungen der Entferung im Nahfeld schon ausschlaggebend. Deswegen kann ein Handschuh genutzt werden, damit die Antenne nie "wirklich" berührt wird. Hier ein kleines Video von "Over the rainbow":
video

 Analyse:

Da ich Physiker bin, hat mich eben interessiert wie die Frequenz mit dem einstellbaren Widerstand zusammenhängt. Dabei ist interessant, dass im Bereich R = 0-10 kOhm der Ton höher wird (Frequenz höher) je höher der Widerstand ist. Ebenfalls gilt hier je weiter man sich von der Antenne wegbewegt, wird der Ton höher (bis zu einem Grenzwert). Dies ist auch in Abbildung 1 zu sehen.
Wird jedoch der einstallbare Widerstand in den Bereich 100 kOhm gestellt, so dreht sich alles um:
Bei steigendem Widerstand sinkt die Tonhöhe und bei Vergrößerung des Abstands zur Antenne wird der Ton tiefer.
Abb:1 Abhängigkeit der Tonhöhe vom einstellbaren WIderstand für verschiedene Töne

In diesem Abbild sind für verschiedene Töne (mit dem Stimmgerät gemessen) die jeweiligen Werte des Widerstands aufgetragen für den Bereich 0-10 kOhm und 90-100 kOhm. Die Fitparameter sind wie folgt:
  • R(f) = 0.002605[Ohm*s]*f+0.02711[Ohm]
  • R(f) = -0.001624[Ohm*s]*f+100.3[Ohm]
 Theoretisch einmal eine Ursprungsgerade mit Steigung 0.002605[Ohm*s] ca. 1/400. Dies zeigt auch, dass bei Verdoppelung des Widerstands sich auch die Frequenz in etwa Verdoppelt.
Dies ist allerdings nicht mehr der Fall für die Messung bei ca. 100 kOhm.



Sonntag, 10. April 2016

Matlab: Matlabskript

Matlabskript

Da ich sehr viel mit Matlab mache, habe ich auch immer nebenher mir alles dokumentiert und die wichtigsten Befehle in eine Latexdatei zusammengefasst. Dieses Skript ist für Anfänger als auch für Fortgeschrittene. Es beginnt mit einfachen Plot- und Fit-Funktionen über 3D-Plots und Fehlergeraden.

Matlabskript

Vorschau:


Matheabitur Skript

Matheabitur-Skript

Da ich dieses Jahr ziemlich viel Mathenachhilfe gegeben habe, habe ich nebenher ein Matheskript geschrieben für das Abitur mit allen relevanten Themen.

Bei irgendwelchen Fehlern oder Unklarheiten im Skript würde ich mich gerne über Komentare und Bemerkungen freuen, da ich doch nicht die Zeit hatte öfters über das Skript zu schauen und es zu perfektionieren.

Ich hoffes es hilft euch beim Lernen und Verstehen!
 
Matheabitur-Skript

Vorschau:


Mittwoch, 30. März 2016

Arduino: Geräuschsensor LM393

Motivation

Da ich mir ein Theremin gebaut habe, wollte ich mir mit dem Arduino-Geräuschsensor LM393 eine Art Mikrofon bauen, bzw. einen Lautstärke regeler.

Anwendung:

Die Anwendung des Sensors ist ziemlich einfach. Man nimmt ein beliebiges Arduino-Board und verbindet vom Sensor VCC mit +5V, GND mit GND und OUT mit A0.


Nun wird einfach der analog Pin A0 mit analogRead(A0) ausgelesen. Der Arduino gibt abhängig von der Lautstärke entweder 26 oder 1023 als Wert an. Es kommt selten vor, dass sich ein Wert dazwischen befindet. Deswegen habe ich immer über einige Werte (500) gemittelt und dann den Durchschnitt bestimmt. Wird nun 10 Sekunden lang immer der Wert ermittelt, kann der Lautstärkeverlauf ziemlich grob bestimmt werden. Dieser ist umso genauer, über je mehr Werte gemittelt wird. Allerdings ist die Zahl der gemittelten Werte und die Werte die man pro Sekunde aufnehmen will, abhängig von der Geschwindigkeit des Computers. 
In folgenden Bildern ist der Lautstärkeverlauf für den Ton c eines Klaviers in Abhängigkeit der Zeit für verschiedene Anzahlen gemittelter Werte geplottet. Dabei ist zu erkennen, dass bei 10 Werten ein willkürlicher Verlauf ensteht, bei 5000 Werten jedoch eine stetige Kurve:


Wie zu sehen ist gibt es erst ab ca 500 Werten pro Mittelung einen Verlauf, der nicht zu große Abweichungen hat. 

Hier der Quellcode:

int audioPin = A0;
int j=1;
int seconds = 0;
int mills = millis();


void setup() {
  Serial.begin(115200);
}

void loop() {
  int soundWave;
  long Sound = 0;
  int range = 1000;
  soundWave = analogRead(audioPin);
  for (int i = 1;i<range;i++){
    soundWave = analogRead(audioPin);
    Sound = Sound + soundWave;
  }
  Serial.print(double(mills-seconds)/1000);
  Serial.print(" ");
  Serial.println(Sound/(range));
  j=j+1;
  mills = millis();
  if ((mills-seconds)>10000){
    while(1==1);
  }
}

Sonntag, 10. Januar 2016

Matlab: Kegel/Pfeil in 3D

Kegel/Pfeil in 3D

(English) Um einen Kegel bzw. ein Pfeil im 3D darzustellen kann die Funktion:

function arrow3D(x,y,z,x2,y2,z2,length,thick,color)

 verwendet werden. Dabei ist "x2,y2,z2" der Endwert der Pfeiles, also die Spitze und "x,y,z" der Anfang des Vektors bzw. des Pfeiles. "length" gibt die Länge des Pfeils an und "thick" die Dicke. Mit "color" kann der Pfeil gefärbt werden. Wie die Funktion angewendet wird, kann im vorherigen Post nachgelesen werden.


Hier der Quellcode:


function arrow3D(x,y,z,x2,y2,z2,length,thick,color)

if nargin<5
    scale = 1;
end
x=-x;
y=-y;
x2=-x2;
y2=-y2;

vector2=[x2;y2;z2];
vector1=[x;y;z];
vector21=[x2-x;y2-y;z2-z];

u1=[x2-x;y2-y;z2-z];
u1=1/norm(u1)*u1;
u2=[1;0;0];
val=u1(1,1);
abstand=u1-val*u2;
if abstand==zeros(3,1)
    u2=[0;1;0];
end;
%Kreuzprodukt
u3(1,1)=u1(2,1)*u2(3,1)-u1(3,1)*u2(2,1);
u3(2,1)=u1(3,1)*u2(1,1)-u1(1,1)*u2(3,1);
u3(3,1)=u1(1,1)*u2(2,1)-u1(2,1)*u2(1,1);
u3=1/norm(u3)*u3;
%
u2(1,1)=u1(2,1)*u3(3,1)-u1(3,1)*u3(2,1);
u2(2,1)=u1(3,1)*u3(1,1)-u1(1,1)*u3(3,1);
u2(3,1)=u1(1,1)*u3(2,1)-u1(2,1)*u3(1,1);
u2=1/norm(u2)*u2;
%orthnormale vektoren
v1=u2;
v2=u3;
step=pi/50;
a = [step:step:2*pi];
er=vector2;
Er=repmat(er,1,numel(a));
zerx=(Er(1,:))';
zery=(Er(2,:))';
zerz=(Er(3,:))';

vectorscale=(1-length)*vector21;
grund=(v1*sin(a)+v2*cos(a))*norm(vector2'-vector1')/3*thick;
VS=repmat(vectorscale+vector1,1,numel(a));
grund=grund+VS;

xspitz=[zerx';grund(1,:)];
yspitz=[zery';grund(2,:)];
zspitz=[zerz';grund(3,:)];

xrep=reshape(xspitz,1,2*numel(a))';
yrep=reshape(yspitz,1,2*numel(a))';
zrep=reshape(zspitz,1,2*numel(a))';

%hold on;
%view(3);
plot3(xrep,yrep,zrep,'Color',color);




Matlab: Punkte und Vektoren in 3D-Plots

Punkte und Vektoren in 3D-Plots

(English) Diese Matlabfunktion ist für das im vorherigen Post dargestellte 3D-Gitter. Dabei kann mit folgender Funktion ein Vektor bzw. ein Punkt im 3D-Plot erstellt werden.

function punkt3D(x1,y1,z1,x2,y2,z2,sign,name,color,dx,dy,dz,true)

Dabei gibt "x1,y1,z1" dem Startpunkt des Vektors und "x2,y2,z2" dem Endpunkt. Dabei kann mit "sign" das Zeichen am Endpunkt bestimmt werden. Mit "name" wird des Punkt benannt und "color färbt die Vektor.
Ist der Name nicht an der richtigen Stelle, kann dieser mit "dx,dy,dz" entsprechend verschoben werden. Für die Variable "true = 1" wird die Projektion des Vektors auf die 3 Ebenen angeschaltet.
Als Beispiel erhält man folgendes Bild mit diesem Quellcode:

grid3D(0,2,0,2,-2,2,4,4,4);
punkt3D(0,0,0,2,2,2,'.','P(2|2|2)',colors('orange'));
punkt3D(0,0,0,1,0.5,1,'arrow','Q(1|0.5|1)',colors('brightblue'),0,0,0.4);
arrow3D(1.5,1.5,0,1.5,1,0,0.4,0.2,'k');
punkt3D(0,0,0,0,1,1,'arrow','R(0|1|1)',colors('darkgreen'),0,0,0.4);

 Hierfür wird jedoch die Funktion arrow3D(...) gebraucht, da für "sign = 'arrow' " wie in dem Schaubild ein Pfeil ans Ende des Vektors gezeichnet wird. Dies kann optional auch einfach im folgenden Quellcode gelöscht werden.

Hier der Quellcode:
function punkt3D(x1,y1,z1,x2,y2,z2,sign,name,color,dx,dy,dz,true)

if nargin<10
    dx=0;
    dy=0;
    dz=0;
end
if nargin<9
    color='black';
end
if nargin>12
    plot3([0 -x2],[-y2 -y2],[z2 z2],'--','Color','[0.8 0.8 0.8');
    plot3([-x2 -x2],[0 -y2],[z2 z2],'--','Color','[0.8 0.8 0.8');
    plot3([-x2 -x2],[-y2 -y2],[0 z2],'--','Color','[0.8 0.8 0.8');
end

if strcmp(sign,'arrow') == 1
    xrange = x2-x1;
    yrange = y2-y1;
    zrange = z2-z1;
    arrow3D(x2-xrange/7,y2-yrange/7,z2-zrange/7,x2,y2,z2,1,1,color);
end
if strcmp(sign,'arrow') == 0
    p2 = plot3(-x2, -y2, z2,sign,'Color',color,'Markersize',7);
end
p1 = plot3([-x1 -x2],[-y1 -y2],[z1 z2]);
p3 = text(-x2-x2/10-dx, -y2-y2/7-dy, z2+z2/10+dz,name);
set([p1 p3],'Color',color);

Matlab: 3D Plot in kartesischem Koordinatensystem

3D Grid/Gitter

(English) In diesem Post stell ich mein 3D-Gitter für Matlab vor. Dieses erzeugt in Abhängigkeit verschiedener Parameter ein Gitter in Matlab. Dieses kann einfach genutzt werden, um Vektoren, Ebenen und Geraden im dreidimensionalen Darzustellen.

function grid3D(x2,x,y2,y,z2,z,amountx,amounty,amountz,arrowtrue);

dabei gibt x2,y2,z2 die Startwerte der Achse und x,y,z die Endwerte der Achse an. Die anderen Variablen sind optional. Dabei gibt amountx, amounty, amountz die Anzahl der Achsenunterteilungen an. Wenn "arrowtrue = 1" ist, dann werden Pfeile an die Achsen gezeichnet. Diese sind jedoch nur für symmetrische Gitter gut zu gebrauchen.

Hier der Quellcode:
 function grid3D(x2,x,y2,y,z2,z,amountx,amounty,amountz,arrowtrue);

if nargin<7
    amountx = 4;
    amounty = 4;
    amountz = 4;
end
if nargin<10
    arrowtrue = 0;
end

xrange = x2-x;
yrange = y2-y;
zrange = z-z2;

zq = 0:1:amountz;
yq = 0:1:amounty;
xq = 0:1:amountx;

hold on;
set(gca,'visible','off')

xv1=x*ones(amountx+1,1)+(xq*xrange/amountx)';
yv1=y*ones(amounty+1,1)+(yq*yrange/amounty)';
zv1=z*ones(amountz+1,1)-(zq*zrange/amountz)';
if (nargin>6)
    view(3);
    %x1x2 Ebene.  
    plot3([-x2 -x],[0 0],[zv1 zv1],'Color',[0.8 0.8 0.8]);
    plot3([0 0],[-y2 -y],[zv1 zv1],'Color',[0.8 0.8 0.8]);
    %x1x3 Ebene.  
    plot3([-xv1 -xv1],[0 0],[z2 z],'Color',[0.8 0.8 0.8]);
    plot3([-xv1 -xv1],[-y2 -y],[0 0],'Color',[0.8 0.8 0.8]);
    %x2x3 Ebene.  
    plot3([0 0],[-yv1 -yv1],[z2 z],'Color',[0.8 0.8 0.8]);
    plot3([-x2 -x],[-yv1 -yv1],[0 0],'Color',[0.8 0.8 0.8]);
end;

%texte
text(-x,-y/10,-z/20,'x_1')
text(-x/20,-y,-z/10,'x_2')
text(-x/10,y/20,z,'x_3')

xv1(sum((xv1==0),2)>0,:)=[];
yv1(sum((yv1==0),2)>0,:)=[];
zv1(sum((zv1==0),2)>0,:)=[];
%Values
text(-xv1,  zeros(numel(xv1),1),  z/12*ones(numel(xv1),1),num2cell(round(xv1*100)/100));
text(zeros(numel(yv1),1),  -yv1, z/15*ones(numel(yv1),1),  num2cell(round(yv1*100)/100));
text(x/15*ones(numel(zv1),1),  y/15*ones(numel(zv1),1),  zv1,num2cell(round(zv1*100)/100));

xrange=-xrange
yrange=-yrange
dx = xrange/15;
dy = yrange/15;
dz = zrange/15;

%arrows
if arrowtrue == 1
    thickx=(yrange+zrange)/(2*xrange);
    thicky=(xrange+zrange)/(2*yrange);
    thickz=(yrange+xrange)/(2*zrange);
    arrow3D(x,0,0,x+dx,0,0,1,1*thickx,'k')
    arrow3D(0,y,0,0,y+dy,0,1,1*thicky,'k')
    arrow3D(0,0,z,0,0,z+dz,1,1*thickz,'k')
end
%axis
view(3);
plot3([-x2 -x],[0 0],[0 0],'k');
plot3([0 0],[-y2 -y],[0 0],'k');
plot3([0 0],[0 0],[z2 z],'k');


xlim([-(x+dx) -x2]);
ylim([-(y+dy) -y2]);
zlim([z2 z+dz]);

Montag, 24. August 2015

Matlab: Polarplot Achsenbeschriftungs- und Skalierfunktion

Polar-Plots

(English) Bei Polar-Plots mit Matlab stößt man auf ein Problem, da mit MATLABTIKZ die Achsenbeschriftung nicht übernommen wird. Dies kann man mit der von mir programmierten Funktion jedoch lösen:

polartikzlabel(angleticks,abs,ticks,absdeg,anglestr,absstr,round1)

Hierbei gibt "angleticks" die Anzahl der Unterteilungen der Winkel an, "abs" den Radius des Polarplots an, "ticks" die Anzahl der Aufteilungsschritte der Radienskala, "absdeg" den Winkel der Radienbeschriftungsskala an.
"anglestr" gibt die Beschriftung der Winkelachse an und "absstr" die Beschriftung der Radialachse an. "round1" gibt an, wie viele Nachkommestellen die Beschriftungen haben sollen.

Dies kann wie folgt aussehen: polartikzlabel(5,1,6,40,'angle','radial',3)

Hier der Quellcode:

function polargrid(angleticks,abs,ticks,absdeg,anglestr,absstr,round1)
%angleticks set the number of ticks in equidistant angles.
%abs set the radius of the polarplot.
%ticks set the number of ticks in equidistant radialskale.
%absdeg set the degree of the radialaxis.
%anglestr set the labeling of the angleaxis.
%absstr set the labeling of the radialaxis.
%the number of positions behind the point.

  
%Delete the text
delete(findall(gcf,'type','text'));

%Delete the grid
set(0,'ShowHiddenHandles','on')
set(findobj(findobj(get(gca,'Children'),'Type','Line'),'LineStyle','-'),{'Visible'},{'off'});
hold on;
%Declare the variables
value1=360/angleticks;
value2=abs/ticks;
if nargin < 5
    anglestr = 'angle';
    absstr = 'radial';
end
%round the labels
if nargin < 7
    round1 = 2;
end
round1 = (10)^(round1);
angles =round([0:value1*round1:(360-value1)*round1])/(round1);
rho = round([0:value2*round1:abs*round1])/(round1)

n=numel(rho);
rad=rho(n)+rho(n)/10;

%Draw the angle-scale
amount = numel(angles);
X = [zeros(amount,1), rho(n)*cos(angles(1:amount)'./180*pi)];
Y = [zeros(amount,1), rho(n)*sin(angles(1:amount)'./180*pi)];

plot(X',Y','Color',[0.8 0.8 0.8]);

%Draw the radial-scale
anglegrid = [0:pi/100:2*pi];
Xgrid = rho'* cos(anglegrid);
Ygrid = rho'* sin(anglegrid);
plot(Xgrid',Ygrid','Color',[0.8 0.8 0.8]);


%Draw the skalevalues
Xangle = rad.*cos(angles./180*pi)-abs/20;
Yangle = rad.*sin(angles./180*pi);
text(Xangle,Yangle,num2cell(angles));

Xrho = rho*cos(absdeg/180*pi);
Yrho = rho*sin(absdeg/180*pi)+sin(absdeg/180*pi)*abs/10;
text(Xrho,Yrho,num2cell(rho));

%Write the labels
text(1.1*abs*cos(absdeg/180*pi),1.3*abs*sin(absdeg/180*pi),absstr);
text(abs+abs/5,0,anglestr);


Sonntag, 23. August 2015

Matlab: Matlabplots in Latex einbinden (MATLABTIKZ)

Matlabplots in Latex (MATLABTIKZ)

(English) Das besondere hierbei ist, dass die Bilder die mit MATLABTIKZ erstellt werden in Latex noch angepasst werden können, heißt sie können verzerrt werden und die Schrift im Graphen hat die Latexschriftart und -größe. Dies wird wie folgt in Matlab implementiert:


h(1) = figure(1);

...

matlab2tikz('runge.tikz', 'height', '\figureheight', 'width','\figurewidth', 'figurehandle', h(1));

In Latex werden nun folgende Pakete benötigt.

\usepackage{pgfplots}

\usepackage{grffile}

\pgfplotsset{compat=newest}

\usetikzlibrary{plotmarks}

\usepgfplotslibrary{polar}

\usepgfplotslibrary{patchplots}

Und dann das Bild einfügen: 
\begin{figure}[H]
\newlength\figureheight\setlength\figureheight{5.5cm}
\newlength\figurewidth\setlength\figurewidth{0.65\textwidth}
\input{runge.tikz}
\captionof{figure}{Runge-Kutta-Verfahren 2. Ordnung}
\end{figure}

Donnerstag, 14. Mai 2015

Power Wheel (selbstgebaut)

Power Wheel

In diesem Post werde ich erklären, wie man ein Power Wheel baut und wie man damit trainieren kann. Zuerst einmal sieht mein Power-Wheel so aus:

 Diese Sportgerät ist perfekt zum Trainieren von Bauch-, Rückenmuskeln (unterer), Nackenmuskeln und den Latissimus. Dabei ist dieses Gerät nicht so gut für Anfänger geeignet und auch nicht aus dem kalten, also uneingewärmten Zutand.

Material

Als Material werden 1-2 kleine Räde (Durchmesser ca. 15 cm) benötigt. Mit einem Rad ist es schwieriger das Gleichgewicht zu halten, also schlechter für Anfänger, besser für Fortgeschrittene. Nun wird eine passende Stange aus Metall bzw. stabilem Material benötigt jedoch am Besten mit Gewinde. Diese sollte gut in die Räder passen. Die Stange sollte eine Länge von ca. 30 - 35 cm haben und eine Durchmesser von ca. 8 mm. Es werden noch 4 Muttern benötigt, welche alle auf das Gewinde passen müssen. Nun wird noch ein bisschen Schaumstoff, bzw. ein Stück von einer Isomatte und Tape für den Griff benötigt.

Herstellung

Zum Herstellen werden die Räder mittig an der Stange platziert. Nun werden die Mütter je 2 Rechts und Links an die Räder geschraubt jedoch mit einem kleinen Abstand, damit die Räder noch gut frei  rollen können. Die Muttern werden nun beide gegenseitig stark festgedreht, damit sich diese nichtmehr bewegen. Als letztes muss noch das Stück Isomatte einmal um den Griff gewickelt und dann mit dem Tape einfach festgemacht werden. 

Schon ist das Power Wheel fertig und kann zum Trainieren genutzt werden.

Training

Wie vorher schon erwähnt ist es wichtig nicht sofort aus dem kalten Zustand mit dem Power Wheel zu trainieren, da dies leicht zu kleinen Muskelzerrungen im Bauch führen kann.
Für Anfänger ist es wichtig zuerst auf den Knie mit geradem Rücken und ausgestreckten Armen langsam nach vorne zu rollen. Darauf dann auch auf die selbe Art wieder zurück rollen, so dass man aufrecht da sitzt. Dies wird wiederholt, bis man es schafft nur mit der Nase den Boden zu berühren und dann wieder zurückzurollen. Dabei darf der Rücken nicht in ein Hohlkreuz geformt werden. Es ist auch nicht gut Schwung aus der Hüfte zu nutzen. Lieber nicht so weiter runter als sich etwas kaputt zu machen.
Für Fortgeschrittene kann diese Übung auf den Knien zum Aufwärmen genutzt werden. Dabei ist wichtig, dass wenn man parallel zum Boden ist und nur die Nase den Boden berührt, versucht langsam wieder in die Ausgangsposition zu kommen. Wenn man die Arme leicht anbeugt, kann das die Übung erleichtern. Wenn diese Übung kein Problem mehr ist, kann aus dem Stand mit ziemlich weitem Grätschstand die Übung nun verucht werden, ohne mit den Knien den Boden zu berühren. Von hier kann man die Beine immer mehr schleißen bis man nach langem Training endlich die "Roll-Ups" aus dem Stand mit geschlossenen Beinen kann. Die Übung kann durch leichte Krümmung des Rückens erleichtert werden.

Viel Spaß und Erfolg beim Trainieren!

Push-Up Bars (selbstgebaut)

Push-Up Bars

In diesem Post werd ich zeigen wie ich mir meine eigenen Push-Up Bars gebaut habe. Diese haben Materialmäßig weniger als 5€ gekostet und sind ziemlich stabil, heißt Handstand ist auf ihnen möglich. So sehen diese aus:
 

Materialien

Um die nötigen Materialien zu besorgen, eignet es sich am Besten, in den nächsten Baumarkt zu gehen. Dort sucht man sich ein Rundholz, welches perfekt in die Hand passt. Hierbei ist wichtig, dass es sich gut anfühlt von der Dicke her. Meine haben 25 mm Durchmesser und halten mindestens 100 kg. Die Länge beträgt 35 cm aber kann nach belieben variiert werden. Jedoch lieber nicht zu kurz. Und es sollten zwei gekauft werden, da man ja auch zwei Push-Up Bars benötigt...
Als nächstes braucht man vier stabile Platten. Ich habe dickere Sperrholzplatten mit einer Dicke von 18 mm benutzt. Diese halten sehr gut und es besteht auch wenig Gefahr, dass diese beim Trainieren umkippen. Die Platten sollten jedoch nicht dünner sein. Die Breite und Länge ist theoretisch frei wählbar, doch ich empfehle, dass das Rundholz mindestens 5 cm über dem Boden ist, heißt das Sperrholz sollte mindestens 10x10 cm groß sein. Ist alles besorgt wird noch normaler Holzleim benötigt.

Herstellung

Um nun die Push-Up Bars zu bauen, wird als erstes in die vier Stützen ein Loch mit dem Durchmesser des Rundholzes gebohrt. Am einfachsten geht dies im Baumarkt, sonst quält man sich ein bisschen, indem man den größten Bohraufsatz nimmt und den Rest mit der Pfeile auf die richtige Größe bringt. Hier darf das Loch auch nicht zu groß sein, da dann der Leim nicht so gut hält. Falls das Loch jedoch zu groß ist, können Holzspäne in das Loch geleimt werden und wenn diese festgeleimt sind noch gekürzt werden:
 Wenn die Rundhölzer mit den Stützen verleimt werden, kann man drauf auchten, dass diese symmetrisch aussehen und vorne und hinten gleich viel von dem Rundholz herausschaut. Es funktioniert auch, wenn diese Bündig zum Holz sind aber sicherer ist, wenn diese ein bisschen überstehen. Nun einfach noch einen Tag den Leim trocken lassen und dann kann sofort trainiert werden.
Viel Spaß und Erfolg mit den Push-Up Bars.




Montag, 11. Mai 2015

Matlab: Fehlerfunktionen (exponentiell)

Ergänzung zu Fehlergeraden mit Matlab

Exponentielles Fitting

(English) In diesem Post wird noch die Matlabfunktion für Plots mit halblogarithmischer Skalabzw. mit einem exponentiellen Verhalten der Form "b*(exp(a*x)". Die Funktion ist wie die Funtion "Errorline" aufgebaut. Der einzige Unterschied ist, dass diese Funktion ein Eingabewert mehr benötigt.
function [smax,smin,rmax,rmin] = errexpfunc(x,y,xerr,yerr, count,scale)
Hierbei gibt scale die Stelle des Schnittpunktes der beiden Fehlerfunktionen in Abhängigkeit von den x-Werten an. Für "scale = 1" schneiden sich die beiden Fehlerexponentialfunktionen in der Mitte und für "scale = 0" am ersten x-Wert und für "scale = 2" am letzten Messwert.




Quellcode:

function [smax,smin,rmax,rmin] = errexpfunc(x,y,xerr,yerr, count,scale)
%This is a function to plot a maximal and minimal errorline with given
%errors 'xerr' and 'yerr'. It also can create the box around the mesured
%values to see in which area the errorlines are plotted.
%For count 1 it plots just the errorline. For count 2 it plots the box and
%count 3 it plots both. Scale ist the value, where the intersection of the
%two functions are. It just exsists in the area [0;2).


l=numel(x);
xmid=x(1)+(x(l)-x(1))/2*scale
xerr=0;
if(xerr==0)
   xerr = zeros([l,1])
end
ymax=y+yerr
ymin=y-yerr

fitmax=fit(x,ymax,@(a,b,x) b*exp(a*x));
fitmin=fit(x,ymin,@(a,b,x) b*exp(a*x));
fitVal=fit(x,y, @(a,b,x) b*exp(a*x));
%Fit the maximal and the minimal errorlines through the mesured values with
%their deviations.
a=coeffvalues(fitmax);
b=coeffvalues(fitmin);
c=coeffvalues(fitVal);
amax=a(1);
amin=b(1);
bmax=a(2);
bmin=b(2);
afit=c(1);
bfit=c(2);

%Declare the 4 corners of the box
xlu=x(1)-xerr(1);
xld=x(1)-xerr(1);
xru=x(l)+xerr(1);
xrd=x(l)+xerr(1);

ylu=exp(amax*xlu)*bmax;
yrd=exp(amin*xrd)*bmin;
ymid=exp(afit*xmid)*bfit;

yru=exp(amax*xru)*bmax;
yld=exp(amin*xld)*bmin;
ymid=exp(afit*xmid)*bfit;
xcrnl=[xld xlu];
xcrnr=[xrd xru];
ycrnl=[yld ylu];
ycrnr=[yrd yru];

expmaxx=[xlu xmid xrd];
expmaxy=[ylu ymid yrd];
expminx=[xld xmid xru];
expminy=[yld ymid yru];

fitmax1=fit(expmaxx',expmaxy',@(a,b,x) b*exp(a*x));
fitmin1=fit(expminx',expminy',@(a,b,x) b*exp(a*x));
a=coeffvalues(fitmax1);
b=coeffvalues(fitmin1);
smax=a(1);
smin=b(1);
rmax=a(2);
rmin=b(2);



hold on;
if(count==1)
    h1=plot(fitmax1);
    set(h1,'Color',[0.0 0.7 0.3])
    h2=plot(fitmin1)
    set(h2,'Color',[0.0 0.7 0.3])
    legend([h1],'Errorfunctions');
end
if(count==2)
    h3=plot(fitmax,'--');
    set(h3,'Color',[0.8 0 0.4]);
    h4=plot(fitmin,'--');
    set(h4,'Color',[0.8 0 0.4]);
    plot(xcrnl',ycrnl','--','Color',[0.8 0 0.4]);
    plot(xcrnr',ycrnr','--','Color',[0.8 0 0.4]);
    legend([h4],'Errorbox');
end
if (count==3)
    h1=plot(fitmax1);
    set(h1,'Color',[0.0 0.7 0.3])
    h2=plot(fitmin1)
    set(h2,'Color',[0.0 0.7 0.3])
    h3=plot(fitmax,'--');
    set(h3,'Color',[0.8 0 0.4]);
    h4=plot(fitmin,'--');
    set(h4,'Color',[0.8 0 0.4]);
    plot(xcrnl',ycrnl','--','Color',[0.8 0 0.4]);
    plot(xcrnr',ycrnr','--','Color',[0.8 0 0.4]);
    plot(xcrnl',ycrnl','--','Color',[0.8 0 0.4]);
    plot(xcrnr',ycrnr','--','Color',[0.8 0 0.4]);
    legend([h1 h4],'Errorfunctions','Errorbox');
end

end

Sonntag, 10. Mai 2015

Matlab: Messwertfilter

Messwertfilter:

Verfahren:

(English) Die Matlab-Funktion ist dazu da, Messwerte mit großen Abweichungen bei linearen Zusammenhängen zu filtern und durch die restlichen Messwerte die Funktion zu fitten. Ansich funktioniert diese Funktion ähnlich wie die Fehlergeradenfunktion, bei der eine Gerade durch die y-Werte mit deren maximalen Fehler und eine Gerade durch die y-Werte mit deren minimale Fehler gefittet wird. Dabei kann in der Funktion entschieden werden, wie große Abweichungen zugelassen werden, sprich welche prozentuale Abweichung zu den Fehlerwerten.
Wenn ein Wert gefiltert wird, wiederholt sich die Filterfunktion und überprüft mit dem neuen fit, ob wieder Messwerte außerhalb dem Fehlerbereich sind. Folgende Abbildung veranschaulicht die Funktionsweise:
 
Hierbei ist in rot die Fehlerbox und der gefilterte Messwert.

 Implementieren:

Die Funktion kann die Fehlerbox und die gefilterten wie auch nicht gefilterten Werte zurückgeben und wird wie folgt in Matlab aufgerufen:"[x,y,xerr,yerr,xaus,yaus,xerraus,yerraus] = filterfunc(x, y, xerr, yerr, scale, count)". Dabei sind "xaus,yaus" die gefilterten x- und y-Werte und "xerraus,yerraus" die gefilterten x- und y-Fehlerwerte.
Die Filterfunktion hat sechs Argumente, wobei "x,y,xerr,yerr" die Werte mit ihren Fehlern sind. Falls kein x-Fehlerwert existiert kann einfach "0" eingegeben werden. "Scale" gibt an wie stark gefiltert werden soll. Für (scale = 1) wird genau die Abweichung der eingegeben y-Fehler verwendet. Für kleinere Faktoren wird folglich die Box kleiner und somit mehr Messwerte gefiltert.
Wie folgt sind vier plots mit verschiedenen scale-Faktoren zu sehen:

Mit dem letzten Argument (count), wird für (count = 1) die Fehlerbox geplottet, für alle anderen Werte wird nichts geplottet sondern nur die Rückgabewerte geben.

Quellcode:

function [x,y,xerr,yerr,xaus,yaus,xerraus,yerraus] = filterfunc(x, y, xerr, yerr, scale, count)
%This function filters the values, which are imprecise. 'Scale' is a
%parameter for this imprecise. With 'scale=1' the imprecise is exacly your
%y-error. With count '1' this function plots the errorbox'.
%If the measured point is outside the area, this function will
%take the values out and give it back at 'xaus, yaus, xerraus, yerraus'.


l=numel(x);
if(xerr==0)
    xerr=zeros([l,1]);
endymax=y+scale*yerr
ymin=y-scale*yerr
fitmax=fit(x,ymax,@(a,b,x) a*x+b);
fitmin=fit(x,ymin,@(a,b,x) a*x+b);
fitVal=fit(x,y,@(a,b,x) a*x+b);

%Fit the maximal and the minimal errorlines through the mesured values with
%their deviations.
a=coeffvalues(fitmax);
b=coeffvalues(fitmin);

amax=a(1);
amin=b(1);
bmax=a(2);
bmin=b(2);

xaus=[];
yaus=[];
xerraus=[];
yerraus=[];

yp=x*amax+bmax;
ym=x*amin+bmin;
n=1;
%filter the values with a large imprecision
while(1==1)
    altamax=amax;
    altbmax=bmax;
    altamin=amin;
    altbmin=bmin;
    for i=1:1:l
        if (i>l)
            break;
        end
        if( (y(i)>(yp(i)+yerr(i)*(scale-1))) | (y(i)<(ym(i)-yerr(i)*(scale-1))) )
            xaus(n)=x(i);
            yaus(n)=y(i);
            xerraus(n)=xerr(i);
            yerraus(n)=yerr(i);
            x(i)=[];
            y(i)=[];
            yp(i)=[];
            ym(i)=[];
            xerr(i)=[];
            yerr(i)=[];
            i=i-1;
            l=l-1;
            n=n+1;
        end
    end
    if (numel(x)>1)
        fitmax=fit(x,y+yerr*scale,@(a,b,x) a*x+b);
        fitmin=fit(x,y-yerr*scale,@(a,b,x) a*x+b);
    end
    a=coeffvalues(fitmax);
    b=coeffvalues(fitmin);
    amax=a(1);
    amin=b(1);
    bmax=a(2);
    bmin=b(2);
    %if in this cycle the fits are equal, then close the function 
    if (abs(altamax-amax)<1e-6 & abs(altbmax-bmax)<1e-6 & abs(altamin-amin)<1e-6 & abs(altbmin-bmin)<1e-6)
        break;
    end
            
end
if (n==1)
    xaus=[];
    yaus=[];
    xerraus=[];
    yerraus=[];
end
l=numel(x)
if (l>=2)
    l=numel(x);

    %Declare the 4 corners of the box
    xlu=x(1)-xerr(1);
    xld=x(1)-xerr(1);
    xru=x(l)+xerr(1);
    xrd=x(l)+xerr(1);

ylu=amax*xlu+bmax;
yru=amax*xru+bmax;
yld=amin*xld+bmin;
yrd=amin*xrd+bmin;

%Declare the vectors of the corners.
xcorner=[xlu xru xrd xld xlu];
ycorner=[ylu yru yrd yld ylu];

if (count == 1)
    hold on;
    plot(xcorner,ycorner,'--','Color',[0.8 0 0.2]);
end
end

if (l==0)
    display('All measurpoint are acapetable');
end
if (numel(x)==0)
    display('No points are in that scale');
end
end


Matlab: Fehlergeraden

Das Verfahren:

(English) Dieser Post geht über das plotten von Fehlergeraden für zum Beispiel Protokolle in der Uni oder andere Anwendungen. Die Methode dabei ist, dass durch die y-Werte mit deren Fehlern eine minimale und eine maximale Gerade geplottet wird. Diese ergeben eine Box bei welcher die x-Abgrenzung an der Stelle des ersten Messwerte mit Fehler in negative x-Richtung und den letzten Messwert mit Fehler in positive x-Richtung. Nun werden die Ecken der Box diagonal mit zwei Geraden verbunden, welche die Fehlergeraden sind.
Die Funktion zeichnet mit dem Befehl "[smax,smin,rmax,rmin] = errlinefunc(x, y,xerr,yerr, count)" die Fehlergeraden (count = 1), die Box (count = 2) oder Fehlergerade und Box (count = 3). (count = 0) gibt nur die Werte zurück und erstellt keine plots.
In diesem Bild sind Messwerte mit deren Fehlerbalken (blau), der Fehlergeraden (grün) und der Fehlerbox (rot) eingezeichnet:
Die Funktion gibt mit "smax,smin" die Steigungen der maximalen und minimalen Fehlergerade an und mit "rmax,rmin" deren Schnittpunkt mit der y-Achse.

Quellcode:

Der Quellcode der Funktion sieht wie folgt aus:

function [smax,smin,rmax,rmin] = errlinefunc(x, y,xerr,yerr, count)
%This is a function to plot a maximal and minimal errorline with given
%errors 'xerr' and 'yerr'. It also can create the box around the mesured
%values to see in which area the errorlines are plotted.
%For count 1 it plots just the errorline. For count 2 it plots the box and
%count 3 it plots both.

l=numel(x);
if(xerr==0)
   xerr = zeros([l,1])
end
ymax=y+yerr
ymin=y-yerr
ymax = y + yerr;

fitmax=fit(x,ymax,@(a,b,x) a*x+b);
fitmin=fit(x,ymin,@(a,b,x) a*x+b);
fitVal=fit(x,y, @(a,b,x) a*x+b);
%Fit the maximal and the minimal errorlines through the mesured values with
%their deviations.
a=coeffvalues(fitmax);
b=coeffvalues(fitmin);
c=coeffvalues(fitVal);
amax=a(1);
amin=b(1);
bmax=a(2);
bmin=b(2);
afit=c(1);
bfit=c(2);

%Declare the 4 corners of the box
xlu=x(1)-xerr(1);
xld=x(1)-xerr(1);
xru=x(l)+xerr(1);
xrd=x(l)+xerr(1);

ylu=amax*xlu+bmax;
yru=amax*xru+bmax;
yld=amin*xld+bmin;
yrd=amin*xrd+bmin;

%Declare the vectors of the corners.
xcorner=[xlu xru xrd xld xlu];
ycorner=[ylu yru yrd yld ylu];
xcrnmax=[xlu xrd];
xcrnmin=[xld xru];
ycrnmax=[ylu yrd];
ycrnmin=[yld yru];

smax=(yru-yld)/(xru-xld);
smin=(yrd-ylu)/(xrd-xlu);
rmax=yld-xld*smax;
rmin=ylu-xlu*smin;

f1(x)=rmax+x*smax;
f2(x)=rmin+x*smin;
%Declare the rises and the y-values
s1=(yrd-ylu)/(xrd-xlu);
s2=(yru-yld)/(xru-xld);

y1=ylu-s1*xlu;
y2=yld-s2*xld;

hold on;
if(count==1)
    line(xcrnmax,ycrnmax,'Color',[0.0 0.7 0.3]);
    line(xcrnmin,ycrnmin,'Color',[0.0 0.7 0.3]);
end

if(count==2)
    plot(xcorner,ycorner,'--','Color',[0.8 0 0.2]);
end

if(count==3)
    line(xcrnmax,ycrnmax,'Color',[0.0 0.7 0.3]);
    line(xcrnmin,ycrnmin,'Color',[0.0 0.7 0.3]);
    plot(xcorner,ycorner,'--','Color',[0.8 0 0.2]);
end

end