clear all;
% by Michael Sams
% Lehrstuhl für Carbon Composites
% TU Munich
% sams.m@gmx.net

% Kloeppelpositionen:

% RECHTS-laufend: "kl_pos_re" (Zeilenvektor)
% LINKS-laufend: "kl_pos_li" (Zeilenvektor)

%%%%%%%%%%%% VEKTOREN KOENNEN VERAENDERT WERDEN %%%%%%%%%%%%%%%

% Vollbesetzung
%kl_pos_re = [1,3,5,7,9,11,13];     % Position der einzelnen Kloeppel nach RECHTS
%kl_pos_li = [2,4,6,8,10,12,14];    % Position der einzelnen Kloeppel nach LINKS

% Halbbesetzung
%kl_pos_re = [1,5,9,13,17,21,25];   % Position der einzelnen Kloeppel nach RECHTS
%kl_pos_li = [4,8,12,16,20,24,28];  % Position der einzelnen Kloeppel nach LINKS

% RECHTS = 2 x LINKS - Besetzung
kl_pos_re = [1,3,5,7,9,11,13,15,17,19];  % Position der einzelnen Kloeppel nach RECHTS
kl_pos_li = [2,6,10,14,18,22,26,30,34];  % Position der einzelnen Kloeppel nach LINKS

% RECHTS oben / LINKS voll
%kl_pos_re = [1,5,9,13,17,21,25,29,33,37,41,45,49];   % Position der einzelnen Kloeppel nach RECHTS
%kl_pos_li = [2,4,6,8,10,12,14,16,18,20,22,24,26];    % Position der einzelnen Kloeppel nach LINKS

% Plot scale (Hoehe des Faserversatzes - Ondulation)
pl_scale = 0.3;

% interpol. div
i_div = 0.1;

% interpolation
% 'nearest', 'linear', 'spline', 'pchip', 'cubic'
interpol = 'cubic';

% fiber-Radius (for plot)
radius=0.3;

%%%%%%%%%%%%%%% KEINE AENDERUNGEN MEHR VORNEHMEN %%%%%%%%%%%%%%
%% BEGINN QUELLCODE

% Bestimmung der Fluegelraederanzahl aus max. Position von RECHTS- und
% LINKS-drehenden Kloeppel (aus "kl_pos_re" und "kl_pos_li")
if (max(kl_pos_re) >= max(kl_pos_li))
    if (mod(max(kl_pos_re),2)==0)
        n_flraed = max(kl_pos_re/2)+1;
    else
        n_flraed = (max(kl_pos_re)+1)/2+1;
    end
else
    if (mod(max(kl_pos_li),2)==0)
        n_flraed = max(kl_pos_li/2)+1;
    else
        n_flraed = (max(kl_pos_li)+1)/2+1;
    end
end
 
% Positionen and den Fluegelraeder
t = 0:n_flraed*2;   

%% RECHTS-laufende Kloeppel

n_kl_re = size(kl_pos_re);  % Anzahl der Elemente im Vektor
n_kl_re = n_kl_re(1,2);     % --> Anzahl der Kloeppel nach RECHTS

for i = 1:n_kl_re % Generiert alle definierten Kloeppel
    % Schleife fuer die einzelnen Kloeppelpositionen
    % Alternierende Reihe mit NULL fuer Kloeppelpositionen
    for j=kl_pos_re(1,i):n_flraed*2
        if mod(j,2)==0  % bei ungeraden t: Pos. 0
            y_re(i,j+1)=0;
        elseif mod(j,2)==1 % bei geraden t: Pos. 1 oder -1
            y_re(i,j+1)=(-1)^((j-1)/2);
        end
    end
    % Loescht alle Positionen vor der definierten Pos.
    % Vektorelemente mit "NaN" besetzen, die VOR der Startpos. liegen
    for k=1:kl_pos_re(1,i)
        y_re(i,k)=NaN;
    end
end

%% LINKS-laufende Kloeppel

n_kl_li = size(kl_pos_li);  % Anzahl der Elemente im Vektor
n_kl_li = n_kl_li(1,2);     % Anzahl der Kloeppel nach LINKS

for i = 1:n_kl_li % Generiert alle definierten Kloeppel
    % Schleife fuer die einzelnen Kloeppelpositionen
    % Alternierende Reihe mit NULL fuer Kloeppelpositionen
    for j=kl_pos_li(1,i):-1:0
        if mod(j,2)==0  % bei ungeraden t: Pos. 0
            y_li(i,j+1)=0;
        elseif mod(j,2)==1 % bei geraden t: Pos. 1 oder -1
            y_li(i,j+1)=(-1)^((j+1)/2);
        end
    end
    % Loescht alle Positionen vor der definierten Pos.
    % Vektorelemente mit "NaN" besetzen, die NACH der Startpos. liegen
    for k=kl_pos_li(1,i)+2:n_flraed*2+1
        y_li(i,k)=NaN;
    end
end

%% Vergleich der RECHTS-laufenden mit den LINKS-laufenden Kloeppel
%  Ueberpruefen welcher Kloeppel ueber den anderen laeuft

% Vergleichsmatrizen
% Vergleich von jedem einzelnen RECHTS-laufenden Kloeppel mit allen
% LINKS-laufenden Kloeppel

for i=1:n_kl_re
    comp(1,:,i)=t(1,:);     % 1.Zeile: Kloeppelpos. t
    comp(2,:,i)=y_re(i,:);  % 2.Zeile: i-RECHTS-laufende Kloeppel

    for j=1:n_kl_li
        comp(j+2,:,i)=y_li(j,:); % j.Zeile: LINKS-laufende Kloeppel
    end
end

% Flechtmatrix
% Darstellung der "ueberlaufenden" Flechtfaeden
FM = cell(n_flraed,2*n_flraed);

% Alle RECHTS-laufenden Kloeppel durchlaufen
for k=1:n_kl_re;
    
    s=0;        % Schrittzaehler (erster Schritt - RECHTS)
    
    % Position im Vektor, der RECHTS-laufenden Kloeppel
    pos_re=1;
    
    % Position des ersten RECHTEN Elements ermitteln
    % Vektor "comp(2,:,k)" (2.Zeile - nach erstem "NaN" von links)
    while (isnan(comp(2,pos_re,k)))
        pos_re=pos_re+1;    
    end

    % alle LINKS-laufenden mit "einem" RECHTS-laufenden vergleichen
    for i=1:n_kl_li
        
        % Position des letzten LINKEN Elements ermitteln
        % Vektor "comp(i,:,k)" ((i+2).Zeile - erstes "NaN" von links)
        pos_li=1;
        while (~isnan(comp(i+2,pos_li,k)))
            pos_li=pos_li+1;
        end

        % CRASH - Es sind zwei Kloeppel auf der selben Anfangsposition - CRASH
        if (pos_li-pos_re == 1)
            fprintf('\n\n### CRASH ###\n\n');
            fprintf('Kloeppel RECHTS: %d\n', k);
            fprintf('Kloeppel LINKS : %d\n', i);
            fprintf('sind an der gleichen Anfangsposition!!\n');
            return;
        % Wenn "pos_re" < "pos_li" KANN es im naechsten Schritt eine
        % Ueberschneidung der beiden Flechtfaeden geben
        elseif (pos_re < pos_li && pos_li-pos_re >=2)
            
            % "pos_li" ist auf der ersten Position mit "NaN" und deswegen
            % muess man 1 abziehen um auf der ersten Kloeppelposition zu
            % sein; zusaetzlich ziehen wir "s" (Schrittzaehler) von der
            % Position ab (wenn der RECHTE und der LINKE Kloeppel noch zu
            % weit voneinander entfernt sind und eine Ueberschneidung erst
            % in einem spaeteren Schritt vonstatten geht!)
            pos_li=pos_li-1 - s;
            
            % CRASH - Es kommen zwei Kloeppel zur gleichen Position - CRASH
            if (pos_li == pos_re)
                fprintf('\n\n### CRASH ###\n\n');
                fprintf('Kloeppel RECHTS: %d\n', k);
                fprintf('Kloeppel LINKS : %d\n', i);
                fprintf('fahren an die gleiche Position!!\n');
                return;
            end
            
            % Wenn der RECHTE und der LINKE Kloeppel noch zu weit
            % voneinander entfernt sind, werden die Schritte hochgezaehlt
            % bis die Positionen der Beiden stimmt.
            while ( ~(pos_re == (pos_li)-1))
                pos_re=pos_re+1;
                pos_li=pos_li-1;
                s=s+1;
            end
                
            % Schrittvektoren von RECHTS und von LINKS
            % Moeglichkeiten der Schritte von 'a' auf 'b':
            % Ueberlaufend - POSITIV:
            % - [0,1]: von Pos. 0 auf Pos. 1
            % - [1,0]: von Pos. 1 auf Pos. 0
            % Unterlaufend - NEGATIV:
            % - [0,-1]: von Pos. 0 auf Pos. -1
            % - [-1,0]: von Pos. -1 auf Pos. 0
            % Schritt von 'a' auf 'b' - RECHTS
            step_re(1,1) = comp(2,pos_re,k);
            step_re(1,2) = comp(2,pos_re+1,k);
            % Schritt von 'b' auf 'a' - LINKS
            step_li(1,1) = comp(i+2,pos_li,k);
            step_li(1,2) = comp(i+2,pos_li-1,k);

            % Check: ob der RECHTS-laufende Kloeppel UEBERLAEUFT
            if ((step_re(1,1)==0 && step_re(1,2)==1)||(step_re(1,1)==1 && step_re(1,2)==0))&&...
               ((step_li(1,1)==0 && step_li(1,2)==-1)||(step_li(1,1)==-1 && step_li(1,2)==0))
                FM{s+1,pos_re} = 'RE';
                s=s+1;  % naechster Schritt
                pos_re=pos_re+1;

            % Check: ob der LINKS-laufende Kloeppel UEBERLAEUFT
            elseif ((step_li(1,1)==0 && step_li(1,2)==1)||(step_li(1,1)==1 && step_li(1,2)==0))&&...
                   ((step_re(1,1)==0 && step_re(1,2)==-1)||(step_re(1,1)==-1 && step_re(1,2)==0))
                FM{s+1,pos_re} = 'LI';
                s=s+1;
                pos_re=pos_re+1;

            else
                % Wenn das erscheint, gibt es entweder einen Crash oder
                % ich habe stuemperhaft programmiert!
                FM{s+1,pos_re+1} = '##';

            end
            
        end % if-Bedingung: (pos_re < pos_li)
    end % for-Schleife: LINKS
end % for-Schleife: RECHTS

%% Ausgabe des Flechtmusters

% RECHTS - Diagonal-Matrix-Vectoren (alle Faeden)
spalte=0; % Schleifenzaehler - Spaltenzaehler fuer Diagonale
red_half=0; % Schleifenzaehler - Matrix-Zeilen-Reduktion
for re_faden=1:2*n_flraed % alle Spalten der Flechtmatix durchlaufen (alle moegl. Faeden)
    spalte=re_faden; % Spaltenzaehler fuer Schleife
    first=0; % Indikator ob erste(s) Element je Faden belegt ist oder nicht
     
    % in der rechten Haelfte der Flechtmatrix (re_faden > n_flraed; da
    % Spaltenanzahl 2*n_flraed), muss die Anzahl der durchlaufenden Zeilen
    % reduziert werden, do sonst ueber die Matrixdimension in der Schleife
    % hinausgelaufen wird!
    if re_faden > n_flraed 
        red_half=red_half+1;
    end
    
        % alle Zeilen der Flechtmatrix werden je Faden (Spalte) durchlaufen
        % (diagonal nach rechts - bei RECHTS)
        for zeile = 1:n_flraed-red_half
            % wenn vor Anfang (first==0) und die Stelle in der Flechtmatrix
            % ist leer --> dann Vektor "rech_vec" mit Position und Wert
            % NULL belegen
            if( isempty(FM{zeile,spalte}) && first==0)
                rech_vec(1,zeile,re_faden) = zeile;
                rech_vec(2,zeile,re_faden) = spalte;
                rech_vec(3,zeile,re_faden) = 0;
                spalte=spalte+1; % Spaltenposition nach rechts ruecken
                
            % wenn vor Anfang (first==0) und die Stelle in der Flechtmatrix
            % ist NICHT leer --> dann checken ob 'RE' oder 'LI'
            elseif (~isempty(FM{zeile,spalte}) && first==0)
                if (FM{zeile,spalte} == 'RE')
                    rech_vec(1,zeile,re_faden) = zeile;
                    rech_vec(2,zeile,re_faden) = spalte;
                    rech_vec(3,zeile,re_faden) = 1;
                    first = 1; % Anfang
                    spalte=spalte+1; % Spaltenposition nach rechts ruecken
                elseif (FM{zeile,spalte} == 'LI')
                    rech_vec(1,zeile,re_faden) = zeile;
                    rech_vec(2,zeile,re_faden) = spalte;
                    rech_vec(3,zeile,re_faden) = -1;
                    first = 1; % Anfang
                    spalte=spalte+1; % Spaltenposition nach rechts ruecken
                end

            % wenn nach Anfang (first==1) und die Stelle in der Flechtmatrix
            % ist leer --> dann Vektor mit letzter Position besetzen -->
            % kein Wechsel der Faeden
            elseif (isempty(FM{zeile,spalte}) && first==1)
                    rech_vec(1,zeile,re_faden) = zeile;
                    rech_vec(2,zeile,re_faden) = spalte;
                    rech_vec(3,zeile,re_faden) = rech_vec(3,zeile-1,re_faden);
                    spalte=spalte+1;
                    
            % Allg. Fall: sonst checken ob 'RE' oder 'LI' und entsprechend
            % belegen
            else
                if (FM{zeile,spalte} == 'RE')
                    rech_vec(1,zeile,re_faden) = zeile;
                    rech_vec(2,zeile,re_faden) = spalte;
                    rech_vec(3,zeile,re_faden) = 1;
                    first = 1;
                    spalte=spalte+1;
                elseif (FM{zeile,spalte} == 'LI')
                    rech_vec(1,zeile,re_faden) = zeile;
                    rech_vec(2,zeile,re_faden) = spalte;
                    rech_vec(3,zeile,re_faden) = -1;
                    first = 1;
                    spalte=spalte+1;
                end
            end
        end
end
size_rech=size(rech_vec); % Groesse des Vektors: "rech_vec"

% LINKS - Diagonal-Matrix-Vectoren (alle Faeden)
spalte=0; % Schleifenzaehler - Spaltenzaehler fuer Diagonale
red_half=0; % Schleifenzaehler - Matrix-Zeilen-Reduktion
for li_faden=2*n_flraed:-1:1 % alle Spalten der Flechtmatix durchlaufen (alle moegl. Faeden)
    spalte=li_faden; % Spaltenzaehler fuer Schleife
    first=0; % Indikator ob erste(s) Element je Faden belegt ist oder nicht
    
    % in der linken Haelfte der Flechtmatrix (li_faden < n_flraed; da
    % Spaltenanzahl 2*n_flraed), muss die Anzahl der durchlaufenden Zeilen
    % reduziert werden, do sonst ueber die Matrixdimension in der Schleife
    % hinausgelaufen wird!
    if li_faden < n_flraed
        red_half=red_half+1;
    end

        % alle Zeilen der Flechtmatrix werden je Faden (Spalte) durchlaufen
        % (diagonal nach links - bei LINKS)
        for zeile = 1:n_flraed-red_half
            
            % wenn vor Anfang (first==0) und die Stelle in der Flechtmatrix
            % ist leer --> dann Vektor "link_vec" mit Position und Wert
            % NULL belegen
            if( isempty(FM{zeile,spalte}) && first==0)
                link_vec(1,zeile,li_faden) = zeile;
                link_vec(2,zeile,li_faden) = spalte;
                link_vec(3,zeile,li_faden) = 0;
                spalte=spalte-1; % Spaltenposition nach links ruecken
            
            % wenn vor Anfang (first==0) und die Stelle in der Flechtmatrix
            % ist NICHT leer --> dann checken ob 'RE' oder 'LI'
            elseif (~isempty(FM{zeile,spalte}) && first==0)
                if (FM{zeile,spalte} == 'RE')
                    link_vec(1,zeile,li_faden) = zeile;
                    link_vec(2,zeile,li_faden) = spalte;
                    link_vec(3,zeile,li_faden) = -1;
                    first = 1; % Anfang
                    spalte=spalte-1; % Spaltenposition nach links ruecken
                elseif (FM{zeile,spalte} == 'LI')
                    link_vec(1,zeile,li_faden) = zeile;
                    link_vec(2,zeile,li_faden) = spalte;
                    link_vec(3,zeile,li_faden) = 1;
                    first = 1; % Anfang
                    spalte=spalte-1; % Spaltenposition nach links ruecken
                end

            % wenn nach Anfang (first==1) und die Stelle in der Flechtmatrix
            % ist leer --> dann Vektor mit letzter Position besetzen -->
            % kein Wechsel der Faeden
            elseif (isempty(FM{zeile,spalte}) && first==1)
                    link_vec(1,zeile,li_faden) = zeile;
                    link_vec(2,zeile,li_faden) = spalte;
                    link_vec(3,zeile,li_faden) = link_vec(3,zeile-1,li_faden);
                    spalte=spalte-1;
                           
            % Allg. Fall: sonst checken ob 'RE' oder 'LI' und entsprechend
            % belegen     
            else
                if (FM{zeile,spalte} == 'RE')
                    link_vec(1,zeile,li_faden) = zeile;
                    link_vec(2,zeile,li_faden) = spalte;
                    link_vec(3,zeile,li_faden) = -1;
                    first = 1;
                    spalte=spalte-1;
                elseif (FM{zeile,spalte} == 'LI')
                    link_vec(1,zeile,li_faden) = zeile;
                    link_vec(2,zeile,li_faden) = spalte;
                    link_vec(3,zeile,li_faden) = 1;
                    first = 1;
                    spalte=spalte-1;
                end
            end
        end
end
size_link=size(link_vec); % Groesse des Vektors: "rech_vec"

% Bestimmung der untersten Überschneidung
pot_faden_re=1;
pos_pot_re=1;
while (rech_vec(3,pos_pot_re,pot_faden_re)==0)
    if (pos_pot_re < size_rech(2))
        pos_pot_re=pos_pot_re+1;
    elseif (pos_pot_re == size_rech(2))
        pos_pot_re=1;
        pot_faden_re=pot_faden_re+1;
        continue;
    end
end
pot_faden_li=size_link(3);
pos_pot_li=size_link(2);
while (link_vec(3,pos_pot_li,pot_faden_li)==0)
    if (pos_pot_li > 1)
        pos_pot_li=pos_pot_li-1;
    elseif (pos_pot_li == 1)
        pos_pot_li=size_link(2);
        pot_faden_li=pot_faden_li-1;
        continue;
    end
end
% unterster Überschneidungspunkt
for i=1:min(size_link(2),size_rech(2))
    if (rech_vec(1,i,pot_faden_re)==link_vec(1,i,pot_faden_li)) &&...
            (rech_vec(2,i,pot_faden_re)==link_vec(2,i,pot_faden_li))
        re_li_pos(1,1)=rech_vec(1,i,pot_faden_re);
        re_li_pos(1,2)=rech_vec(2,i,pot_faden_re);
    end
end

% RECHTS - interpolierte Faeden (alle)
for faden=1:size_rech(3) % alle Faeden durchlaufen
    
    pos_i=1; % Position im Faden - Groessenbestimmung
    
    % WENN die Position NICHT NULL dann...
    while (~(rech_vec(1,pos_i,faden)==0))
        if (pos_i == n_flraed) % CHECK: ob am Ende des Vektors
            break;
        elseif (~rech_vec(1,pos_i+1,faden)==0) % CHECK: ob rechts von der Position eine NULL, wenn nicht...
            pos_i=pos_i+1;
        else % wenn rechts von der Position eine NULL ist, dann...
            break;
        end
    end
    
    % Bereich fuer Plot...von - bis:
    % erster Wert: rech_vec(1,1,faden)
    % letzer Wert: rech_vec(1,pos_i,faden)
    x=rech_vec(1,1,faden):i_div:rech_vec(1,pos_i,faden);
    size_x=size(x); % Groesse von "x"
    
    % Matrizen fuer Plot - x, y Koordinaten incl. INTERPOLIERTER z-Koordinate
    % fuer schoeneren Fadenverlauf
    if (~(size_x(2)==1))
        rech_interpol(1,1:size_x(2),faden)= rech_vec(1,1,faden):i_div:rech_vec(1,pos_i,faden);
        rech_interpol(2,1:size_x(2),faden) = rech_vec(2,1,faden):i_div:rech_vec(2,pos_i,faden);
        rech_interpol(3,1:size_x(2),faden) = pl_scale * interp1(rech_vec(1,1:pos_i,faden),rech_vec(3,1:pos_i,faden),x,interpol);
    end
end
size_re_int=size(rech_interpol); % Groesse des Arrays

%RECHTS interpoliert - loeschen der Nullfaeden
% und belegen mit NaN
for i=1:size_re_int(3) % alle Faeden (in Plot-Matrizen) durchlaufen
    nullpos=0; % Schleifenzaehler fuer Nullen
    for k=0:size_re_int(2)-1 % alle Werte je Faden durchlaufen
        
        if( rech_interpol(3,1+k,i)==0) % Wenn z-Wert == NULL
            nullpos=nullpos+1; %...dann hochzaehlen
        end

        % wenn ein x-Wert NULL ist, alle Werte an dieser Position mit NaN
        % belegen
        if( rech_interpol(1,1+k,i)==0) 
            rech_interpol(1,1+k,i) = NaN;
            rech_interpol(2,1+k,i) = NaN;
            rech_interpol(3,1+k,i) = NaN;
        end
    end

    % Wenn alle z-Werte je Faden NULL sind...Faden eliminieren
    if (nullpos==size_re_int(2))
        for j=0:size_re_int(2)-1
                rech_interpol(1,1+j,i) = NaN;
                rech_interpol(2,1+j,i) = NaN;
                rech_interpol(3,1+j,i) = NaN;
        end
    end
end

% LINKS - interpolierte Faeden (alle)
for faden=1:size_link(3)
    
    pos_i=1;
    while (~(link_vec(1,pos_i,faden)==0))
        if (pos_i == n_flraed)
            break;
        elseif (~link_vec(1,pos_i+1,faden)==0)
            pos_i=pos_i+1;
        else
            break;
        end
    end
    
    x=link_vec(1,1,faden):i_div:link_vec(1,pos_i,faden);
    size_x=size(x);
    
    if (~(size_x(2)==1))
        link_interpol(1,1:size_x(2),faden)= link_vec(1,1,faden):i_div:link_vec(1,pos_i,faden);
        link_interpol(2,1:size_x(2),faden) = link_vec(2,1,faden):-i_div:link_vec(2,pos_i,faden);
        link_interpol(3,1:size_x(2),faden) = pl_scale * interp1(link_vec(1,1:pos_i,faden),link_vec(3,1:pos_i,faden),x,interpol);
    end
end
size_li_int=size(link_interpol);

% LINKS interpoliert - loeschen der Nullfaeden
for i=1:size_li_int(3)
    nullpos=0;
    for k=0:size_li_int(2)-1
        if( link_interpol(3,1+k,i)==0)
            nullpos=nullpos+1;
        end
        
        if( link_interpol(1,1+k,i)==0)
            link_interpol(1,1+k,i) = NaN;
            link_interpol(2,1+k,i) = NaN;
            link_interpol(3,1+k,i) = NaN;
        end
    end
    if (nullpos==size_li_int(2))
        for j=0:size_li_int(2)-1
                link_interpol(1,1+j,i) = NaN;
                link_interpol(2,1+j,i) = NaN;
                link_interpol(3,1+j,i) = NaN;
        end
    end
end

% BESCHNEIDUNG AUF QUADRAT
% rechts-unten beschneiden -- RECHTS/ROT
diag=0;
diag_ja=0;
for i=1:size_re_int(3)
    for k=0:size_re_int(2)-1 
        if ((rech_interpol(1,1+k,i)>(re_li_pos(1)-diag/2)) &&...
                (rech_interpol(2,1+k,i)>(re_li_pos(2)+diag/2)))
            rech_interpol(1,1+k,i) = NaN;
            rech_interpol(2,1+k,i) = NaN;
            rech_interpol(3,1+k,i) = NaN;
            diag_ja=1;
        end
    end
    
    if diag_ja==1
       diag=diag+1;
    end
end

% links-unten beschneiden -- BLAU/LINKS
diag=0;
diag_ja=0;
for i=size_li_int(3):-1:1
    for k=size_li_int(2)-1:-1:0
        if ((link_interpol(1,1+k,i)>(re_li_pos(1)-diag/2)) &&...
                (link_interpol(2,1+k,i)<(re_li_pos(2)-diag/2)))
            link_interpol(1,1+k,i) = NaN;
            link_interpol(2,1+k,i) = NaN;
            link_interpol(3,1+k,i) = NaN;
            diag_ja=1;
        end
    end
    
    if diag_ja==1
       diag=diag+1;
    end
end

% links-oben beschneiden -- RECHTS/ROT
% linker-Eckpunkt
li_unten_vers=floor((re_li_pos(1)-1)/2);
li_unten=[1+li_unten_vers, re_li_pos(2)-li_unten_vers];

diag=0;
diag_ja=0;
for i=1:size_re_int(3)
    for k=0:size_re_int(2)-1 
        if ((rech_interpol(1,1+k,i)<(li_unten(1)-diag/2)) &&...
                (rech_interpol(2,1+k,i)<(li_unten(2)+diag/2)))
            rech_interpol(1,1+k,i) = NaN;
            rech_interpol(2,1+k,i) = NaN;
            rech_interpol(3,1+k,i) = NaN;
            diag_ja=1;
        end
    end
    
    if diag_ja==1
       diag=diag+1;
    end
end

% links-oben beschneiden -- LINKS/BLAU
for i=1:size_li_int(3)
    a_pos=1;
    while ((a_pos < size_li_int(2)) && isnan(link_interpol(1,a_pos,i)))
        a_pos=a_pos+1;
    end
    
    if (link_interpol(2,a_pos,i) < re_li_pos(2))
        link_interpol(:,:,i)=NaN;
    end
end

% rechts-oben beschneiden -- BLAU/LINKS
% rechter-Eckpunkt
re_unten_vers=floor((re_li_pos(1)-1)/2);
re_unten=[1+re_unten_vers, re_li_pos(2)+re_unten_vers];

diag=0;
diag_ja=0;
for i=size_li_int(3):-1:1
    for k=size_li_int(2)-1:-1:0
        if ((link_interpol(1,1+k,i)<(re_unten(1)-diag/2)) &&...
                (link_interpol(2,1+k,i)>(re_unten(2)-diag/2)))
            link_interpol(1,1+k,i) = NaN;
            link_interpol(2,1+k,i) = NaN;
            link_interpol(3,1+k,i) = NaN;
            diag_ja=1;
        end
    end
    
    if diag_ja==1
       diag=diag+1;
    end
end

% rechts-oben beschneiden -- ROT/RECHTS
for i=1:size_re_int(3)
    a_pos=1;
    while ((a_pos < size_re_int(2)) && isnan(rech_interpol(1,a_pos,i)))
        a_pos=a_pos+1;
    end
    
    if (rech_interpol(2,a_pos,i) > re_li_pos(2))
        rech_interpol(:,:,i)=NaN;
    end
end


%% PLOT
figure(2);
hold on;
% for i=1:size_re_int(3)
%     plot3(rech_interpol(1,:,i),rech_interpol(2,:,i),rech_interpol(3,:,i),'LineWidth',10,'Color','red');
%     plot3(link_interpol(1,:,i),link_interpol(2,:,i),link_interpol(3,:,i),'LineWidth',10,'Color','blue');
% end


theta=0:0.1:2*pi+0.1; % Winkel fuer Faser-Querschnitt (Kreis)
% Schlauchplot - RECHTS
for i=1:size_re_int(3)
    
    a_pos=1;
    while ((a_pos < size_re_int(2)) && isnan(rech_interpol(1,a_pos,i)))
        a_pos=a_pos+1;
    end
    
    if(~isnan(rech_interpol(1,a_pos,i)) && ~isnan(rech_interpol(1,a_pos+1,i)))

        v = null(rech_interpol(:,a_pos+1,i)'-rech_interpol(:,a_pos,i)');
        center = rech_interpol(:,a_pos,i)';
        points = repmat(center',1,size(theta,2)) + radius*(v(:,1)*cos(theta)+v(:,2)*sin(theta));

       % plot3(points(1,:),points(2,:),points(3,:),'r-');
       % plot3(rech_interpol(1,:,i),rech_interpol(2,:,i),rech_interpol(3,:,i),'LineWidth',2,'Color','red');

        [pipexdata,pipeydata,pipezdata]=sweep(points',rech_interpol(:,a_pos:size_re_int(2),i)');
        surf(real(pipexdata),real(pipeydata),real(pipezdata),'FaceColor','red','EdgeColor','none');
    end
end
% Schlauchplot - LINKS
for i=1:size_li_int(3)
    
    a_pos=1;
    while ((a_pos < size_li_int(2)) && isnan(link_interpol(1,a_pos,i)))
        a_pos=a_pos+1;
    end
    
    if(~isnan(link_interpol(1,a_pos,i)) && ~isnan(link_interpol(1,a_pos+1,i)))
        
        v = null(link_interpol(:,a_pos+1,i)'-link_interpol(:,a_pos,i)');
        center = link_interpol(:,a_pos,i)';
        points = repmat(center',1,size(theta,2)) + radius*(v(:,1)*cos(theta)+v(:,2)*sin(theta));
        
       % plot3(points(1,:),points(2,:),points(3,:),'r-');
       % plot3(rech_interpol(1,:,i),rech_interpol(2,:,i),rech_interpol(3,:,i),'LineWidth',2,'Color','red');
        
        [pipexdata,pipeydata,pipezdata]=sweep(points',link_interpol(:,a_pos:size_li_int(2),i)');
        surf(real(pipexdata),real(pipeydata),real(pipezdata),'FaceColor','blue','EdgeColor','none');
    end
end

camlight headlight; lighting gouraud;
hold off;
grid on;
axis image;
axis off;
view(-8,30);
%set(gcf, 'renderer', 'zbuffer');