clear all; clc; close all;

%Filtern der Randwerte der Sollmessdaten                                 
%Auslesen inklusive der Laufparameter I und J!
Sollmes = importdata('C:\Users\_admin\Desktop\sollmes.txt', ' ', 8);

%Randwerte filtern
j=1;
for  i =1:length(Sollmes.data);
   if ((Sollmes.data(i,2) == 1) && (Sollmes.data(i,1) ~= 1) && (Sollmes.data(i,1) ~= 25) )   || ((Sollmes.data(i,2) == 30)&&(Sollmes.data(i,1) ~= 1) &&(Sollmes.data(i,1) ~= 25) )|| (Sollmes.data(i,1) == 1) || (Sollmes.data(i,1) == 25)
       sollmesrand(j,1) = Sollmes.data(i,1);  %J
       sollmesrand(j,2) = Sollmes.data(i,2);  %I
       sollmesrand(j,3) = Sollmes.data(i,3);  %xp
       sollmesrand(j,4) = Sollmes.data(i,4);  %yp
       sollmesrand(j,5) = Sollmes.data(i,5);  %zp
       sollmesrand(j,6) = Sollmes.data(i,6);  %xn
       sollmesrand(j,7) = Sollmes.data(i,7);  %yn
       sollmesrand(j,8) = Sollmes.data(i,8);  %zn
       j = j+1;
   end
end

%Auslesen der Istmessdaten inklusive Laufparameter J und I

Istmess = importdata('C:\Users\_admin\Desktop\istmess.txt', ' ', 7);

%Zusammenfuehren der Istmessdaten und der dazugehörigen Randwerte aus den Sollmessdaten zu einer Struktur
%Hier werden nur noch die Parameter  (J I xp yp zp xn yn zn) ausgelesen!
zusammen = Istmess.data(:,1:8);
zusammen = [zusammen(:,1:8); sollmesrand(:,:)];

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Berechnung des Fits der Fläche

% Initialize arrays to store fits and goodness-of-fit.
flaeche.fitresult = cell( 1, 1 );
flaeche.gof = struct( 'sse', cell( 1, 1 ), ...
    'rsquare', [], 'dfe', [], 'adjrsquare', [], 'rmse', [] );

%% Fit: 'cubicinterp'.
flaeche.ft = 'cubicinterp';
flaeche.opts = fitoptions( flaeche.ft );
flaeche.opts.Weights = zeros(1,0);
[flaeche.fitresult, flaeche.gof, flaeche.output] = fit( [zusammen(:,3), zusammen(:,4)], zusammen(:,5), flaeche.ft, flaeche.opts );

%%Ausgabe in Matlab der größten/kleinsten Residuen
flaeche.resid_max = max(flaeche.output.residuals)*1000;
flaeche.resid_min = min(flaeche.output.residuals)*1000;
disp('flaeche resid_max [µm]'), flaeche.resid_max
disp('flaeche resid_min [µm]'), flaeche.resid_min

%Ausgabe Gütemaße des Flaechenfits
disp('Guetemaße Flaechenfit'), flaeche.gof(1,1)

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Die noch zu berechnenden Werte von X & Y-Paaren werden mit Fits je Linie
%% J berechnet, bezogen auf Istmesswerte
%%
%%
%% An dieser Stelle wird nur entlang schon vorhandener Linien interpoliert
%% Verfeinerung in J-Richtung findet später statt!
%% Dazu: nehme x und y von zwei J-Reihen und finde mittelwert -> an der
%% Stelle Berechnung der 'neuen' Reihe

J=1;        
k=1;
for J=1:25;
    for i=1:length(Istmess.data(:,1))
        if (Istmess.data(i,1) == J)
            tmp.linie.wert(k,1) = Istmess.data(i,1);  %J
            tmp.linie.wert(k,2) = Istmess.data(i,2);  %I
            tmp.linie.wert(k,3) = Istmess.data(i,3);  %xp
            tmp.linie.wert(k,4) = Istmess.data(i,4);  %yp
            tmp.linie.wert(k,5) = Istmess.data(i,5);  %zp
            tmp.linie.wert(k,6) = Istmess.data(i,6);  %xn
            tmp.linie.wert(k,7) = Istmess.data(i,7);  %yn
            tmp.linie.wert(k,8) = Istmess.data(i,8);  %zn
            tmp.linie.wert(k,9) = Istmess.data(i,9);  %fn
            k = k+1;
        end
    end

    %Fit x
    tmp.linie.x.ft = 'poly3';           %x und y einzeln hingegen bleiben über ganz J in guter Genauigkeit
    tmp.linie.x.opts = fitoptions(tmp.linie.x.ft);
    [tmp.linie.x.fitresult, tmp.linie.x.gof, tmp.linie.x.output] = fit( tmp.linie.wert(:,2),tmp.linie.wert(:,3), tmp.linie.x.ft, tmp.linie.x.opts );    %i als Zähler, x-Koord.

    %Fit y
    tmp.linie.y.ft = 'poly3';
    tmp.linie.y.opts = fitoptions(tmp.linie.y.ft);
    [tmp.linie.y.fitresult, tmp.linie.y.gof, tmp.linie.y.output] = fit( tmp.linie.wert(:,2),tmp.linie.wert(:,4), tmp.linie.y.ft, tmp.linie.y.opts );    %i als Zähler, y-Koord.

    
     %Auswerten an Punkten kleiner 1 und größer 25 liefert neue Werte!
    %Berechnung von 7 weiteren Punkten je Richtung
    for i=1:7
        tmp.linie.Koord(i,1) = J;
        tmp.linie.Koord(i,2) = -7+i;
        tmp.linie.Koord(i,3) = feval(tmp.linie.x.fitresult, -7+i);
        tmp.linie.Koord(i,4) = feval(tmp.linie.y.fitresult, -7+i);
    end
    for i=1:7
        tmp.linie.Koord(i+7,1) = J;
        tmp.linie.Koord(i+7,2) = 25+i;
        tmp.linie.Koord(i+7,3) = feval(tmp.linie.x.fitresult, 25+i);
        tmp.linie.Koord(i+7,4) = feval(tmp.linie.y.fitresult, 25+i);
    end

    %Abspeichern je J in eigener Struktur, so dass keine Werte verloren gehen!
    Linie(1,J) = tmp.linie;
    k=1;
    
    %Berechnung der z-Werte über gefittete Flaeche an berechneten
    %X-Y-Koordinaten
    i=1;
    for i=1:length(Linie(1,J).Koord(:,1));
        Linie(1,J).Koord(i,5) = feval(flaeche.fitresult, [Linie(1,J).Koord(i,3), Linie(1,J).Koord(i,4)]);                               %z-Wert soll ja berechnet werden!
    end
    
    
    
end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Ergebnis wird in neuer Struktur gespeichert, dazu ist ein Anpassen der
%% Indizes nötig
%% Hier: Abspeichern der 'alten' J-Struktur mit Platz für die
%% Interpolierten Werte, aber schon mit verlängertem Index I
%% Entscheidend: wie viele Werte der I-Punkte sollen angehängt werden?
%% Je Zeile einen J-Wert zwischenschieben, damit J gerade = urspr. Messwert
J=1;
I=1;

%vorläufig: 4 vor 1 und eben der letzte der berechnet wird als '26'
pktvorI = 4;
pktnachI = 1;



k=1+25+pktvorI+pktnachI;
for J=1:25
    for i=1:length(Istmess.data(:,1))
        if ((Istmess.data(i,1) == J) && (Istmess.data(i,2) == 1))
            
            for m=1:length(Linie(1,J).Koord(:,1));  
                if (Linie(1,J).Koord(m,2) == 0);
                    for n=1:pktvorI;
                         Ergebnis(k+n-1,1) = Linie(1,J).Koord(m-pktvorI+n,1) + J;
                         Ergebnis(k+n-1,2) = Linie(1,J).Koord(m-pktvorI+n,2) + pktvorI;
                         Ergebnis(k+n-1,3) = Linie(1,J).Koord(m-pktvorI+n,3);
                         Ergebnis(k+n-1,4) = Linie(1,J).Koord(m-pktvorI+n,4);
                         Ergebnis(k+n-1,5) = Linie(1,J).Koord(m-pktvorI+n,5);
                         Ergebnis(k+n-1,10) = 1;    %1 als Kennzeichnung für interpolierte Werte
                    end
                end
            end
            
            k = k+pktvorI;                                      %%ab hier wieder keine interpolierten Punkte
            Ergebnis(k,1) = Istmess.data(i,1) +J;  %J
            Ergebnis(k,2) = Istmess.data(i,2) + pktvorI;  %I
            Ergebnis(k,3) = Istmess.data(i,3);  %xp
            Ergebnis(k,4) = Istmess.data(i,4);  %yp
            Ergebnis(k,5) = Istmess.data(i,5);  %zp
            Ergebnis(k,6) = Istmess.data(i,6);  %xn
            Ergebnis(k,7) = Istmess.data(i,7);  %yn
            Ergebnis(k,8) = Istmess.data(i,8);  %zn
            Ergebnis(k,9) = Istmess.data(i,9);  %fn
            k = k+1;
        end
         if ((Istmess.data(i,1) == J) && (Istmess.data(i,2) > 1) && (Istmess.data(i,2) < 25))   %%keine interpolierten Punkte
            Ergebnis(k,1) = Istmess.data(i,1) +J;   %J
            Ergebnis(k,2) = Istmess.data(i,2) +pktvorI; %I
            Ergebnis(k,3) = Istmess.data(i,3);  %xp
            Ergebnis(k,4) = Istmess.data(i,4);  %yp
            Ergebnis(k,5) = Istmess.data(i,5);  %zp
            Ergebnis(k,6) = Istmess.data(i,6);  %xn
            Ergebnis(k,7) = Istmess.data(i,7);  %yn
            Ergebnis(k,8) = Istmess.data(i,8);  %zn
            Ergebnis(k,9) = Istmess.data(i,9);  %fn
            k=k+1;
         end
         if ((Istmess.data(i,1) == J) && (Istmess.data(i,2) == 25))
            Ergebnis(k,1) = Istmess.data(i,1) +J;  %J
            Ergebnis(k,2) = Istmess.data(i,2) + pktvorI;  %I
            Ergebnis(k,3) = Istmess.data(i,3);  %xp
            Ergebnis(k,4) = Istmess.data(i,4);  %yp
            Ergebnis(k,5) = Istmess.data(i,5);  %zp
            Ergebnis(k,6) = Istmess.data(i,6);  %xn
            Ergebnis(k,7) = Istmess.data(i,7);  %yn
            Ergebnis(k,8) = Istmess.data(i,8);  %zn
            Ergebnis(k,9) = Istmess.data(i,9);  %fn
           % k = k+1+pktnachI;
           
                                %%bis hierhin keine interpolierten Punkte
            k = k+1;
               for m=1:length(Linie(1,J).Koord(:,1));  
                    if (Linie(1,J).Koord(m,2) == 0);
                        for n=1:pktnachI;
                             Ergebnis(k+n-1,1) = Linie(1,J).Koord(m+n,1) + J;
                             Ergebnis(k+n-1,2) = Linie(1,J).Koord(m+n,2) + pktvorI;
                             Ergebnis(k+n-1,3) = Linie(1,J).Koord(m+n,3);
                             Ergebnis(k+n-1,4) = Linie(1,J).Koord(m+n,4);
                             Ergebnis(k+n-1,5) = Linie(1,J).Koord(m+n,5);
                             Ergebnis(k+n-1,10) = 1;
                        end
                    end
               end
              k = k+ pktnachI;
        end
    end
    k = k+25+pktvorI+pktnachI;
    
end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Berechnung der Verfeinerung in Richtung der I-Koordinate
%% Wirds für die Randlinien anders zwecks Abstand Sollmes/Istmess eins?
%% Für Alles dazwischen sollts ja wirklich einfach werden!

%%Erstmal für J größer 2 und kleiner 50

%Startwert bei 1
k=25+pktvorI+pktnachI; %Länge eines Intervalls : 25+4+1 = 30

for j=2:2:48;
    for l=1:k;
        Ergebnis(l+(j*k),1) = (Ergebnis(l+((j-1)*k),1) + Ergebnis(l+((j+1)*k),1))/2;
        Ergebnis(l+(j*k),2) = (Ergebnis(l+((j-1)*k),2) + Ergebnis(l+((j+1)*k),2))/2;
        Ergebnis(l+(j*k),3) = (Ergebnis(l+((j-1)*k),3) + Ergebnis(l+((j+1)*k),3))/2;
        Ergebnis(l+(j*k),4) = (Ergebnis(l+((j-1)*k),4) + Ergebnis(l+((j+1)*k),4))/2;
        Ergebnis(l+(j*k),5) = feval(flaeche.fitresult, [ Ergebnis(l+(j*k),3) ,Ergebnis(l+(j*k),4) ]);
        Ergebnis(l+(j*k),10) =1;
    end
end

%%Randwerte : jetzt benutze äußersten Rand der Istmessdaten zusammen mit
%%den Sollmessdaten

for l=1:k;
    Ergebnis(l,1) = ((Ergebnis(k+l,1)/2) + sollmesrand(l,1))/2;
    Ergebnis(l,2) = (Ergebnis(k+l,2) + sollmesrand(l,2))/2;
    Ergebnis(l,3) = (Ergebnis(k+l,3) + sollmesrand(l,3))/2;
    Ergebnis(l,4) = (Ergebnis(k+l,4) + sollmesrand(l,4))/2;
    Ergebnis(l,5) = feval(flaeche.fitresult, [ Ergebnis(l,3), Ergebnis(l,4) ]);
    Ergebnis(l,10) = 1;
end

for l=1:k;
   Ergebnis(l+50*k,1) = ((Ergebnis(l+49*k,1) + sollmesrand(76+l,1)*2)/2)+1;
   Ergebnis(l+50*k,2) = (Ergebnis(l+49*k,2) + sollmesrand(76+l,2))/2;
   Ergebnis(l+50*k,3) = (Ergebnis(l+49*k,3) + sollmesrand(76+l,3))/2;
   Ergebnis(l+50*k,4) = (Ergebnis(l+49*k,4) + sollmesrand(76+l,4))/2;
   Ergebnis(l+50*k,5) = feval(flaeche.fitresult, [ Ergebnis(l+50*k,3), Ergebnis(l+50*k,4) ]);
   Ergebnis(l+50*k,10) = 1;
end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Nach Abspeichern des Ergebnisses: Berechnung der Normalenvektoren und
%% Länge, dazu braucht man den Fit durch die Sollmessdaten als Fläche um
%% dann an jedem der Istmesspunkte den Wert zu berechnen um so die
%% Differenz zu erhalten.

%Fit durch Sollmessdaten
% Initialize arrays to store fits and goodness-of-fit.
sollmesflaeche.fitresult = cell( 1, 1 );
sollmesflaeche.gof = struct( 'sse', cell( 1, 1 ), ...
    'rsquare', [], 'dfe', [], 'adjrsquare', [], 'rmse', [] );

sollmesflaeche.ft = 'cubicinterp';
sollmesflaeche.opts = fitoptions( sollmesflaeche.ft );
sollmesflaeche.opts.Weights = zeros(1,0);
[sollmesflaeche.fitresult, sollmesflaeche.gof, sollmesflaeche.output] = fit( [Sollmes.data(:,3), Sollmes.data(:,4)], Sollmes.data(:,5), sollmesflaeche.ft, sollmesflaeche.opts );

%%Ausgabe in Matlab der größten/kleinsten Residuen
sollmesflaeche.resid_max = max(sollmesflaeche.output.residuals)*1000;
sollmesflaeche.resid_min = min(sollmesflaeche.output.residuals)*1000;
disp('Sollmesflaeche resid_max [µm]'), sollmesflaeche.resid_max
disp('Sollmesflaeche resid_min [µm]'), sollmesflaeche.resid_min

%Ausgabe Gütemaße des Flaechenfits
disp('Guetemaße Flaechenfit Sollmessdaten'), sollmesflaeche.gof(1,1)

%%Berechnung der z-Werte sämtlicher Interpolierter Punkte (Zugriff auf
%%X,Y-Koordinate in Ergebnis und Abgleich über Spalte 10 möglich)
k=1;
for i=1:length(Ergebnis(:,1));
    if (Ergebnis(i,10) == 1);
        sollmesflaeche.interp(k,1) = Ergebnis(i,1); %J
        sollmesflaeche.interp(k,2) = Ergebnis(i,2); %I
        sollmesflaeche.interp(k,3) = Ergebnis(i,3); %xp
        sollmesflaeche.interp(k,4) = Ergebnis(i,4); %yp
        %berechne zp über fit durch Sollmessdaten
        sollmesflaeche.interp(k,5) = feval(sollmesflaeche.fitresult, [ sollmesflaeche.interp(k,3), sollmesflaeche.interp(k,4) ]);
        k = k+1;
    end
end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Berechnung des Normalenvektors für alle interpolierten Punkte
%%
%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%surfnorm benötigt die punkte in dieser speziellen form, sonst keine
%ausgabe!

for j=1:51;
    laengei =0;
    for z=1:length(Ergebnis(:,1));
        if (Ergebnis(z,1) == j);
            laengei = laengei+1;
        
        end
    end
    for i=1:laengei;
        tmp.x2(j,i) = Ergebnis(i+(j-1)*laengei,3);
        tmp.y2(j,i) = Ergebnis(i+(j-1)*laengei,4);
        tmp.z2(j,i) = Ergebnis(i+(j-1)*laengei,5);
        
    end
end



[Nx,Ny,Nz] = surfnorm(tmp.x2,tmp.y2,tmp.z2);

%abfrage ob interpolierter wert -> wenn ja, dann schreibe in ergebnis
for z =1:length(Ergebnis(:,1))
    if (Ergebnis(z,10) == 1);
        Ergebnis(z,6) = Nx( Ergebnis(z,1), Ergebnis(z,2) );
        Ergebnis(z,7) = Ny( Ergebnis(z,1), Ergebnis(z,2) );
        Ergebnis(z,8) = Nz( Ergebnis(z,1), Ergebnis(z,2) );
    end
end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Bestimmung der Länge des Normalenvektors: in Richtung wandern, bis
%% Kontakt mit dem oberen Fit durch die Sollmessdaten auftaucht
%% Nur numerisch möglich, also Vorgehen durch Intervalle?


%Version 1: gehe in Richtung des Normalenvektors in sehr feinen
%Intervallen, Abgleich der entstehenden Z-Werte des Vektors und der
%entsprechenden X,Y-Paare eingesetzt in den Fit der Sollmessdaten,
%wenn kleiner Abbruchkriterium : Ziel erreicht

tic



%testweise nur über ein paar reihen laufen lassen
% for z=1:length(Ergebnis(:,1));

    %Berechnung dauert ewig, sinnvoll zum Abgleich ist z=31:60, da es sich
    %dabei um vorhandene Punkte für einen Abgleich handelt.
for z=1:200;        %gewuenschte Punkte festlegen
      %spaeter nur fuer interpolierte Punkte, Berechnung von bestehenden
      %Istmessdaten erlaubt Feststellung der Abweichung!
%     if (Ergebnis(z,10) == 1);
        disp('interpolierter Punkt erreicht')
        
        clear vektorlaenge;
        clear richtung;
        vektorlaenge = 0.0001;
        k=0;
        %Ueberpruefen, welche der Flaechen weiter außen liegt!
        if (    ((Ergebnis(z,3)^2+Ergebnis(z,4)^2+Ergebnis(z,5)^2)^0.5) >  ((Ergebnis(z,3)^2+Ergebnis(z,4)^2+(feval(sollmesflaeche.fitresult, [ Ergebnis(z,3) , Ergebnis(z,4) ]))^2)^0.5)    );
                %Istmessflaeche hat groeßeren Abstand zum Ursprung , weiter
                %außen --> Richtung der Normalenvektoren muss umgedreht
                %werden
                richtung = 1;
        else
                richtung = 0;
        end
        while (k == 0);
            clear testwert;
            clear testwert2;
            clear narf;

            %wie berechnet man den z-wert des aktuellen punktes?
            %startwert + vektorlänge mal einheitsrichtung
            if (richtung == 1);
                testwert = (Ergebnis(z,5) - (vektorlaenge*Ergebnis(z,8)));
                testwert2 = feval(sollmesflaeche.fitresult, [ (Ergebnis(z,3)-(vektorlaenge*Ergebnis(z,6))) ,  (Ergebnis(z,4)-(vektorlaenge*Ergebnis(z,7))) ]); %bestimme wert z des flaechenfits der sollmessdaten bei vektorlaenge 
            else
                testwert = (Ergebnis(z,5) + (vektorlaenge*Ergebnis(z,8)));
                testwert2 = feval(sollmesflaeche.fitresult, [ (Ergebnis(z,3)+(vektorlaenge*Ergebnis(z,6))) ,  (Ergebnis(z,4)+(vektorlaenge*Ergebnis(z,7))) ]); %bestimme wert z des flaechenfits der sollmessdaten bei vektorlaenge 
            end  
            narf = (testwert2-testwert);
%             pause(5)
            if (abs(narf) < 0.001);    %abbruchkriterium : bis auf ein µm an der fläche
                Ergebnis(z,9) = vektorlaenge;
                k=1;
                disp('Laenge gefunden!')
                %pause(5)
           elseif (vektorlaenge > 0.200);   
                Ergebnis(z,9) = 99;
                disp('Fehler!')
                k=1;
            else
               vektorlaenge = (vektorlaenge+0.000001);  
            end
        end
%     end

end
disp('fast fertig....')
toc


%%Version 2

% % %%%%%%%%%%%%%%%%%%%%%%%%
% % %koennte man alles auch durchrechnen lassen?
% % %problem wird vermutlich das ansprechen des fits als funktion?
% % %laeuft zwar durch, hat aber acuh keine plausiblen werte!
% % tic
% % for z=1:length(Ergebnis(:,1));
% % %     if(Ergebnis(z,10) == 1 );
% %         disp('interpolierter Pkt erreicht...');
% %         
% %         clear richtung;
% %         clear vektorlaenge;
% %         clear intervall;
% %         clear funktion;
% %         clear exitflag;
% %         exitflag = 500;
% %         %berechne, welche flaeche aussen liegt
% %         if ( ((Ergebnis(z,3)^2+Ergebnis(z,4)^2+Ergebnis(z,5)^2)^0.5) >  ((Ergebnis(z,3)^2+Ergebnis(z,4)^2+(feval(sollmesflaeche.fitresult, [ Ergebnis(z,3) , Ergebnis(z,4) ]))^2)^0.5)   );
% %             richtung = 1;   %falls istmess ausserhalb der sollmesflaeche liegt
% %         else 
% %             richtung = 0;
% %         end
% %         
% % %         vektorlaenge = 1;  %startwert so groß waehlen, dass keine gefahr besteht
% % %         intervall = 1;
% %         abbruch = 0;
% % 
% %         while (exitflag == 500);
% % %             clear pkt_a;
% %             clear pkt_b;
% %             clear zwertsollmes;
% %             
% %             %wie berechnet man den z-wert des aktuellen punktes?
% %             %startwert + vektorlänge mal einheitsrichtung
% %             if (richtung == 1);

% %                 funktion =  @(vektorlaenge)((Ergebnis(z,5) - (vektorlaenge*Ergebnis(z,8))) - feval(sollmesflaeche.fitresult, [ (Ergebnis(z,3)-(vektorlaenge*Ergebnis(z,6))) ,  (Ergebnis(z,4)-(vektorlaenge*Ergebnis(z,7))) ]));
% %             else
% %             
% %                 funktion =  @(vektorlaenge)((Ergebnis(z,5) + (vektorlaenge*Ergebnis(z,8))) - feval(sollmesflaeche.fitresult, [ (Ergebnis(z,3)+(vektorlaenge*Ergebnis(z,6))) ,  (Ergebnis(z,4)+(vektorlaenge*Ergebnis(z,7))) ]));
% % 
% %             end
% %             
% %             %bei schneiden wuerde diese funktion zu 0 werden, entspricht
% %             %definition von fsolve
% %             x0 = 0.01;
% % %             options = optimset('Algorithm','trust-region-reflective');
% % %             mit dem algorithmus rechnets gar nicht erst durch
% %             [vektorlaenge, wertvonfunktionbeivektorlaenge, exitflag, outputsymbrechnung] = fsolve(funktion, x0)    
% %             
% %             if ((exitflag >= 0) && (exitflag < 10))
% %                Ergebnis(z,9) = vektorlaenge; 
% %             elseif (exitflag < 0 )
% %                 Ergebnis(z,9) = 99;
% %                 disp('Fehler!');
% %             end
% %         
% %            
% %         end
% % %     end
% % end
% % toc
% % 
% % disp('fast fertig...');