%% ler uma imagem de cada vez e pedir os pontos extremos
clear all
close all
clc

cd /home/morais/Documents/Tese/graficos

% READ THE AVI
mov=aviread('viplanedeparture.avi');
fid = fopen('Dados/ground_truth.txt','a');

% Ler os ficheiros de un txt
cut_lvl = dlmread('Dados/cutting_level.txt');

for frame = 1:300;
    
    % GRAB A SINGLE FRAME
    [im1,map] = frame2im(mov(frame));
    [lin , cols] = size(im1);
    
    % Identificar o nivel de corte usado na imagem  
    im1(cut_lvl(frame),1:360,:) = 255;
    
    % SHOW THE FRAME
    imshow( im1 );
    set(gcf,'position',[1000 50 900 900])
    get(gca,'TightInset')
%     set(gca, 'LooseInset')

    % obter os 6 pontos da imagem
    [x,y] = ginput(6);
    
    % correr todos os pontos obtidos
    for i=1:size(x,1)
        
        % corriguir os valores de x
        if (x(i) <= 10)
            x(i) = 0;
        elseif (x(1) >= 350)
            x(i) = 360;
        else
            x(i) = int8(x(i));
        end
        
        % corriguir os valores de Y
        if (y(i) >= 230)
            y(i)=240;
        elseif (y(i) <= cut_lvl(i)+10)
            y(i) = cut_lvl(i);
        else
            y(i) = int8(y(i));
        end
        
        % guardar os valores de X e Y para ficheiro
        fprintf(fid,'%i %i ',x(i),y(i));
        
    end
    % separar os valores obtidos por linha
    fprintf(fid,'\n');
    
    str = sprintf('frame = %d',frame);
    disp(str)

end

fclose(fid);

%% representar o ground truth
clc
clear all
close all

% Abrir o ficheiro com os dados
poli = dlmread('Dados/ground_truth.txt');
mov = aviread('viplanedeparture.avi');

for i=1:300
    [RGB,map] = frame2im(mov(i));
    
    Pts_poly = poli(i,:)';
    patch();
    RGB = insertShape(RGB,'FilledPolygon',Pts_poly.','Color',[0 1 1],'Opacity',0.2);

    imshow(RGB)
end

%% Play saved data in .txt
clear all
close all
clc

% ler os dados de ficheiro
poli = dlmread('Dados/ground_truth.txt');
mov = aviread('viplanedeparture.avi');

figure
% ciclo para ler os polignos dos frames individualmente 
for n=1:size(poli,1)
    % inicializar as variáveis a zero
    x=[];
    y=[];
    % converter para imagem 
    [RGB,map] = frame2im(mov(n));
    % obter os polignos de cada frame individualmente
    Pts_poly = poli(n,:);
    imshow(RGB)
    
    for i=1:2:size(Pts_poly,2)-1
        % criar vectores de x e y para desenhar os poligonos
        x = [x Pts_poly(i)];
        y = [y Pts_poly(i+1)];
    end
    x
    y
%     set(gca,'YDir','reverse');
    hold on
    fill(x,y,'r')
    axis ij
%     axis([0 240 0 360])
    pause(0.1)
    hold off
end

%% Creat ground_truth
clear all
close all
clc

cd /home/morais/Bags/Piscinas_Ilhavo/

srcFiles = dir('/home/morais/Bags/Piscinas_Ilhavo/images/*.jpg');  % the folder in which ur images exists

for i = 1 : 300
    filename = strcat('/home/morais/Bags/Piscinas_Ilhavo/images/',srcFiles(i).name);
    I = imread(filename);
    imshow(I);
    str = sprintf('frame_id - %d',i);
    title(str);
    axis on
    set(gcf,'position',[1000 50 900 900]);
    get(gca,'TightInset');
    % Pedir um numero de pontos que descrevem o poligono
    x_pts = [];
    y_pts = [];
    hold on
    while 1
        [x,y,b] = ginput(1);
        imshow(I);
        str = sprintf('frame_id - %d',i);
        title(str);
        axis on
        set(gcf,'position',[1000 50 900 900]);
        get(gca,'TightInset');
        hold on
       
        switch b
            case 49 % adicionar os pontos da zona do carro
                disp('add botton points')
                x = [0 0 size(I,2) size(I,2)];
                y = [size(I,1)-80 size(I,1) size(I,1) size(I,1)-80];
                x_pts = [x_pts x];
                y_pts = [y_pts y];
                
            case 8 % eliminar o ultimo ponto
                disp('delet last point')
                x_pts = x_pts(1,1:end-1);
                y_pts = y_pts(1,1:end-1);
                
            case 48 % salvar os pontos e passar ao proximo frame
                 data{i}.frame_id = i;
                 data{i}.x = x_pts;
                 data{i}.y = y_pts;
                break
                
            otherwise % acomular os pontos que saiem do ginput
                disp('added point')
                x_pts = [x_pts x];
                y_pts = [y_pts y];
        end
        color = 'r';
        alpha = .3;
        h = fill(x_pts,y_pts,color);
        set(h,'FaceColor',color,'EdgeColor',color,'FaceAlpha',alpha,'EdgeAlpha',alpha)
        
        hold off
    end
       
    pause(0.01);hold off
end

save ground_truth data
close all
%% Load ground truth and display 
clear all
close all
clc

cd /home/morais/Bags/Piscinas_Ilhavo/

srcFiles = dir('/home/morais/Bags/Piscinas_Ilhavo/images/*.jpg');  % the folder in which ur images exists
load ground_truth

for i=1:size(data,2)
    filename = strcat('/home/morais/Bags/Piscinas_Ilhavo/images/',srcFiles(i).name);
    I = imread(filename);
    % fazer o display da imagem
    imshow(I);
    set(gcf,'position',[720 0 720 790]);
    get(gca,'TightInset');
    % fazer os display do poligno
    color = 'r';
    alpha = .3;
    hold on
    h = fill(data{i}.x , data{i}.y , color);
    set(h,'FaceColor',color,'EdgeColor',color,'FaceAlpha',alpha,'EdgeAlpha',alpha)
    
    pause(0.15);
    hold off
end

close all

%% Converter os ficheiros para matrizes e guarda-las
clear all
close all
clc
cd /home/morais/Bags/Piscinas_Ilhavo/Algoritmo_2/

[FileName,PathName,FilterIndex] = uigetfile('*.txt','Select files to convert','MultiSelect','on');
name = cellstr(FileName);
% name{1} = '/home/morais/Bags/Piscinas_Ilhavo/Algoritmo_2/dados.txt';

% for n=1:size(FileName,2)
for n=1:1
    matrix = readData(name{n});
    if size(matrix,2)<300;
        disp('size Error')
        size(matrix,2)
    end

    k = name{n}(1:end-4); 
    
    filename = mat2str([k '.mat']);
    filename = filename(2:end-1);
    save(filename)
    disp(sprintf('saved -- %s', filename));
end
disp('The End')

%% Load all ".mat" files from current directory and compare them to the ground truth
clear all
close all
clc

% [FileName,PathName,FilterIndex] = uigetfile('*.txt','Select files to convert','MultiSelect','on');
% name = cellstr(FileName);

% Turn warning off
warning('off','all')
tam_original_image = 0;

% cd /home/morais/Bags/Piscinas_Ilhavo/               % mudar o diretorio
cd /home/morais/Bags/Piscinas_Ilhavo/Algoritmo_2/               % mudar o diretorio
load ground_truth                                   % carregar o groud truth (data)

s = what; %look in current directory
%s=what('dir') %change dir for your directory name 

matfiles = s.mat;
matfiles = matfiles(end-1);
% the folder in which ur images exists
srcFiles = dir('/home/morais/Bags/Piscinas_Ilhavo/images/*.jpg');  

display = 0; % mostrar imagens = 1 / não mostrar = 0;

% carregar todos os ficheiros ".mat" do directório
for a=1:size(matfiles,1)
    src = sprintf('resultado - %d',a);
    disp(src);
% Ler os ficheiros das configurações individuais
    load(char(matfiles(a)));
    
    if (size(matrix,2)<300)
        disp('ERROR size')
        Resultados{a}.name = txt(1:end-4);
        Resultados{a}.std_p = 0;
        Resultados{a}.std_n = 0;
        Resultados{a}.mean_p = 0;
        Resultados{a}.mean_n = 0;
        Resultados{a}.six = 0;
        Resultados{a}.seven = 0;
        Resultados{a}.height = 0;
        
        save Resultados Resultados
        continue
    end
    
    A = [];
    F = [];
    True_positive_6 = [];
    True_positive_7 = [];
    True_positive_8 = [];
    disp(['matfile ' char(matfiles(a)) '-->LOAD']);
    
    for i=1:1:300        
       
            % Ler as imagens
            filename = strcat('/home/morais/Bags/Piscinas_Ilhavo/images/',srcFiles(i).name);
            I = imread(filename);
            
            if display==1   % fazer o display da imagem
                imshow(I);
                set(gcf,'position',[720 0 720 790]);
                get(gca,'TightInset');
                title('Resultados automaticos');
                
                % fazer os display do groundtruth
                color = 'r';
                alpha = .3;
                hold on
                g = fill(data{i}.x , data{i}.y , color);
                
                set(g,'FaceColor',color,'EdgeColor',color,'FaceAlpha',alpha,'EdgeAlpha',alpha)
                
                % Fazer o display do poligono
                color = 'g';
                alpha = .3;
                hold on
                h = fill(matrix{i}.x , matrix{i}.y , color);
                
                set(h,'FaceColor',color,'EdgeColor',color,'FaceAlpha',alpha,'EdgeAlpha',alpha)
            end
            
            %%%% Separar os dados lidos do ficheiro .txt em variaveis
            % poligono do groudtruth
            Ax = {data{i}.x};
            Ay = {data{i}.y};
            % Poligono dado pelo algoritmo
            Bx = {matrix{i}.x'};
            By = {matrix{i}.y'};
            
            % calcular a intersecção dos poligonos criados 
            [Cx, Cy] = polybool('intersection', Ax, Ay, Bx, By);
            TPR = 0;
            FPR = 0;
            TP = 0;
            
            % Caso exista mais do que um poligono de intersecção
            for k=1:size(Cx,2)
                if display==1 % fazer o display das imagens
                    % Interseção entre os poligonos
                    intersection = fill(Cx{k} , Cy{k} , color);
                end
                
                % calcular a area das imagem original
                tam_original_image = size(I,1)*size(I,2);
                
                % somar a area dos varios poligonos encontrados
                TP =TP + polyarea(Cx{k},Cy{k});     % True positive                
            end
            
            FP = polyarea(Bx{1},By{1}) - TP;        % False positive
            FN = polyarea(Ax{1},Ay{1}) - TP;        % False negative
            TN = tam_original_image - TP - FP - FN;               % True negative
            
            % TPR (True Positive Rate)
            TPR = TP / (TP + FN);
            
            % FPR (False Positive Rate)
            FPR = FP / (FP + TN);
            
            % criar um vetor com os valores de acerto acomulado 
            A = [A TPR];
            F = [F FPR];
            
            txt =char(matfiles(a));
            text(10,10,['TPR: ' num2str(TPR) ])
            text(10,30,['FPR: ' num2str(FPR) ])
            text(10,50,txt(1:end-4));
            
            
            % definir o limite de ser positivo ou nao 
            if TPR > 0.6
                True_positive_6 = [True_positive_6 1];
            else
                True_positive_6 = [True_positive_6 0];
            end
            
            if TPR > 0.7
                True_positive_7 = [True_positive_7 1];
            else
                True_positive_7 = [True_positive_7 0];
            end
            
            if TPR > 0.8
                True_positive_8 = [True_positive_8 1];
            else
                True_positive_8 = [True_positive_8 0];
            end
            
            
            if display==1 % fazer o display das imagens
                % criar as legendas para os poligonos
                legend('Groundtruth','Generated Poligon');
                
                pause(0.15);
                hold off
            end
    end
    
%     % Criar um histograma com o TRP
%     axis([0 1 0 300]);
%     hist(A,40);title([txt(1:end-4)]); 
%     H = hist(A,40);
%     
%     % Guardar o histogramas com os resultados obtidos
%     name = sprintf('%s.jpeg',txt(1:end-4));
%     saveas(gcf, name, 'jpeg')

    % Calcular a media dos resultados e o desvio padrão e guardar os
    % respectivos
    disp(['matfile ' char(matfiles(a)) '-->SAVED']);    
    Resultados{a}.name = txt(1:end-4);
    Resultados{a}.std_p = std(A);
    Resultados{a}.std_n = std(F);
    Resultados{a}.mean_p = mean(A);
    Resultados{a}.mean_n = mean(F);
    Resultados{a}.six = sum(True_positive_6);
    Resultados{a}.seven = sum(True_positive_7);
    Resultados{a}.height = sum(True_positive_8);
    Resultados{a}.g = TP/(TP+FP+FN);
    Resultados{a}.DR = TP/(TP+FP);
    Resultados{a}.DA = TP/(TP+FN);
    Resultados{a}.VRI = FN/(polyarea(Ax{1},Ay{1})
    
    
    save Resultados Resultados
%     disp('end')
end

disp('The End')
%% fazer gráficos automaticos com os resultados obtidos
clear all
close all
clc

cd /home/morais/Bags/Piscinas_Ilhavo/Algoritmo_2/   % mudar o diretorio de trabalho
load 'data_fix.mat'                   % carregar os resultados obtidos

% Iniciar os vetores vazios
y = [];      % media
x = [];

detectionThreshold = [];
groupThreshold = [];
ipmInterpolation = [];
kernelHeight = [];
kernelWidth = [];
lineHeight = [];
lineWidth = [];

for n=2:size(Resultados,2)
    [token, remain] = strtok(Resultados{n}.name);
    
    if strcmp(token,'detectionThreshold') 
       detectionThreshold = [detectionThreshold n];
    elseif strcmp(token,'groupThreshold')
        groupThreshold = [groupThreshold n];
    elseif strcmp(token,'ipmInterpolation')
        ipmInterpolation = [ipmInterpolation n];
    elseif strcmp(token,'kernelHeight')
        kernelHeight = [kernelHeight n];
    elseif strcmp(token,'kernelWidth')
        kernelWidth = [kernelWidth n];
    elseif strcmp(token,'lineHeight')
        lineHeight = [lineHeight n];
    elseif strcmp(token,'lineWidth')
        lineWidth = [lineWidth n];
    end
    
end


label = {'detectionThreshold','groupThreshold','kernelHeight','kernelWidth','lineHeight','lineWidth'};

% variação da quantidade de positivos em relação a variação do parâmetro

for j = 1:size(label,2)
    dt_y = [];
    dt_x = [];
    figure
    xlabel([char(label(j))]) ; ylabel('Positivos (%)')
    ylim([0 1.1])
    grid on
    hold on
    A = [];
    B = [];
    C = [];
    D = [];
    for i = 1:size(eval(char(label(j))),2)
        
        eval(sprintf('name = Resultados{%s(%d)}.name',char(label(j)),i));
        id = strfind(name,'=');
        
        eval(sprintf('a = Resultados{%s(%d)}.name(%d + 1:end)',char(label(j)),i,id));
        eval(sprintf('b = Resultados{%s(%d)}.six',char(label(j)),i));
        eval(sprintf('c = Resultados{%s(%d)}.seven',char(label(j)),i));
        eval(sprintf('d = Resultados{%s(%d)}.height',char(label(j)),i));
        
        A = [A str2num(a)];
        B = [B b/300];
        C = [C c/300];
        D = [D d/300];
        
        
    end
    
    [Asorted, SortIndex] = sort(A);
    Bsorted = B(SortIndex);
    Csorted = C(SortIndex);
    Dsorted = D(SortIndex);
    
    LineWidth = 2;
    plot( Asorted , Bsorted , '-rs','LineWidth',LineWidth)
    plot( Asorted , Csorted , '-gs','LineWidth',LineWidth)
    plot( Asorted , Dsorted , '-bs','LineWidth',LineWidth)
    legend('60%','70%','80%');
    hold on
    
end


%% fazer gráficos automaticos com os resultados obtidos no Algoritmo 2
clear all
close all
clc

cd /home/morais/Bags/Piscinas_Ilhavo/Algoritmo_2/   % mudar o diretorio de trabalho
load 'Resultados.mat'                   % carregar os resultados obtidos

% Iniciar os vetores vazios
y = [];      % media
x = [];

MinVote = [];
TrackThreshold = [];
LineLeng = [];
LineGap = [];
Threshold = [];


for n=1:size(Resultados,2)
    [token, remain] = strtok(Resultados{n}.name);
    
    if strcmp(token,'MinVote') 
       MinVote = [MinVote n];
    elseif strcmp(token,'TrackThreshold')
        TrackThreshold = [TrackThreshold n];
    elseif strcmp(token,'LineLeng')
        LineLeng = [LineLeng n];
    elseif strcmp(token,'LineGap')
        LineGap = [LineGap n];
    elseif strcmp(token,'Threshold')
        Threshold = [Threshold n];
    end
    
end

label = {'MinVote','TrackThreshold','LineLeng','LineGap','Threshold'};
% variação da quantidade de positivos em relação a variação do parâmetro

for j = 1:size(label,2)
    dt_y = [];
    dt_x = [];
    figure
    xlabel([char(label(j))]) ; ylabel('Positivos (%)')
    ylim([0 1.1])
    grid on
    hold on
    A = [];
    B = [];
    C = [];
    D = [];
    
    for i = 1:size(eval(char(label(j))),2)
        
        eval(sprintf('name = Resultados{%s(%d)}.name',char(label(j)),i));
        id = strfind(name,'=');
        
        eval(sprintf('a = Resultados{%s(%d)}.name(%d + 1:end)',char(label(j)),i,id));
        eval(sprintf('b = Resultados{%s(%d)}.six',char(label(j)),i));
        eval(sprintf('c = Resultados{%s(%d)}.seven',char(label(j)),i));
        eval(sprintf('d = Resultados{%s(%d)}.height',char(label(j)),i));
        
        max = 300;
        
        A = [A str2num(a)];
        B = [B b/max];
        C = [C c/max];
        D = [D d/max];
        
    end
    
    [Asorted, SortIndex] = sort(A);
    Bsorted = B(SortIndex);
    Csorted = C(SortIndex);
    Dsorted = D(SortIndex);
    
    LineWidth = 2;
    plot( Asorted , Bsorted , '-rs','LineWidth',LineWidth)
    plot( Asorted , Csorted , '-gs','LineWidth',LineWidth)
    plot( Asorted , Dsorted , '-bs','LineWidth',LineWidth)
    legend('60%','70%','80%');
    hold on
    
end

%% Calcular os parametros de desempenho do algoritmo
clc
clear all
close all

cd /home/morais/Bags/Piscinas_Ilhavo/
load 'Resultados.mat'                   % carregar os resultados obtidos

g = [];
DR = [];
DA = [];

for n=1:size(Resultados,2)
   g = [g Resultados{n}.g];
   DR = [DR Resultados{n}.DR];
   DA = [DA Resultados{n}.DA];
end

gm = mean(g);
gd = std(g);
DRm = mean(DR);
DRd = std(DR);
DAm = mean(DA);
DAd = std(DA);
format long g

hold on
grid on
axis([ 0 300 0 1])
LineWidth = 2;
x = 1:1:size(Resultados,2);
plot( x , g , '-rs' ,'LineWidth',LineWidth)
plot( x , DR , '-gs' ,'LineWidth',LineWidth)
plot( x , DA , '-bs' ,'LineWidth',LineWidth)   
legend('g','DR','DA');
xlabel('Frame')
ylabel('')

fprintf('g = %d+/- %d \n',gm,gd)
fprintf('DR = %d+/- %d \n' ,DRm,DRd)
fprintf('DA = %d+/- %d \n',DAm,DAd)

%% Load mat file compare them to the groud truth 
clear all
close all
clc

% [FileName,PathName,FilterIndex] = uigetfile('*.txt','Select files to convert','MultiSelect','on');
% name = cellstr(FileName);

% Turn warning off
warning('off','all')
tam_original_image = 0;

% cd /home/morais/Bags/Piscinas_Ilhavo/               % mudar o diretorio
cd /home/morais/Bags/Piscinas_Ilhavo/Algoritmo_2/               % mudar o diretorio
load ground_truth                                   % carregar o groud truth (data)

s = what; %look in current directory
%s=what('dir') %change dir for your directory name 

% matfiles = s.mat;
% matfiles = matfiles(end-1);
% the folder in which ur images exists
srcFiles = dir('/home/morais/Bags/Piscinas_Ilhavo/images/*.jpg');  

display = 0; % mostrar imagens = 1 / não mostrar = 0;

% carregar um ficheiro ".mat" do directório
% for a=1:size(matfiles,1)
%     src = sprintf('resultado - %d',a);
%     disp(src);
    
% Ler os ficheiros das configurações individuais
%     load(char('dados.mat'));
        load(char('data_fix.mat'))


    
    A = [];
    F = [];
    True_positive_6 = [];
    True_positive_7 = [];
    True_positive_8 = [];
    
    for i=1:1:300        
       
            % Ler as imagens
            filename = strcat('/home/morais/Bags/Piscinas_Ilhavo/images/',srcFiles(i).name);
            I = imread(filename);
            
            if display==1   % fazer o display da imagem
                imshow(I);
                set(gcf,'position',[720 0 720 790]);
                get(gca,'TightInset');
                title('Resultados automaticos');
                
                % fazer os display do groundtruth
                color = 'r';
                alpha = .3;
                hold on
                g = fill(data{i}.x , data{i}.y , color);
                
                set(g,'FaceColor',color,'EdgeColor',color,'FaceAlpha',alpha,'EdgeAlpha',alpha)
                
                % Fazer o display do poligono
                color = 'g';
                alpha = .3;
                hold on
                h = fill(matrix{i}.x , matrix{i}.y , color);
                
                set(h,'FaceColor',color,'EdgeColor',color,'FaceAlpha',alpha,'EdgeAlpha',alpha)
            end
            
            %%%% Separar os dados lidos do ficheiro .txt em variaveis
            % poligono do groudtruth
            Ax = {data{i}.x};
            Ay = {data{i}.y};
            % Poligono dado pelo algoritmo
            Bx = {matrix{i}.x'};
            By = {matrix{i}.y'};
            
            % calcular a intersecção dos poligonos criados 
            [Cx, Cy] = polybool('intersection', Ax, Ay, Bx, By);
            TPR = 0;
            FPR = 0;
            TP = 0;
            
            % Caso exista mais do que um poligono de intersecção
            for k=1:size(Cx,2)
                if display==1 % fazer o display das imagens
                    % Interseção entre os poligonos
                    intersection = fill(Cx{k} , Cy{k} , color);
                end
                
                % calcular a area das imagem original
                tam_original_image = size(I,1)*size(I,2);
                
                % somar a area dos varios poligonos encontrados
                TP =TP + polyarea(Cx{k},Cy{k});     % True positive                
            end
            
            FP = polyarea(Bx{1},By{1}) - TP;        % False positive
            FN = polyarea(Ax{1},Ay{1}) - TP;        % False negative
            TN = tam_original_image - TP - FP - FN;               % True negative
            
            % TPR (True Positive Rate)
            TPR = TP / (TP + FN);
            
            % FPR (False Positive Rate)
            FPR = FP / (FP + TN);
            
            % criar um vetor com os valores de acerto acomulado 
            A = [A TPR];
            F = [F FPR];
            
            txt =char('detectionThreshold = 30.mat');
            text(10,10,['TPR: ' num2str(TPR) ])
            text(10,30,['FPR: ' num2str(FPR) ])
            text(10,50,txt(1:end-4));
            
                
            
            if display==1 % fazer o display das imagens
                % criar as legendas para os poligonos
                legend('Groundtruth','Generated Poligon');
                
                pause(0.15);
                hold off
            end
            
    Resultados{i}.name = txt(1:end-4);
    Resultados{i}.frame = i;
    Resultados{i}.g = TP/(TP+FP+FN);
        if (Resultados{i}.g>1)
            Resultados{i}.g = 1;
        end
        
    Resultados{i}.DR = TP/(TP+FP);
    
    if (Resultados{i}.DR>1)
        Resultados{i}.DR=1;
    end
    
    Resultados{i}.DA = TP/(TP+FN);
    
    if (Resultados{i}.DA>1)
        Resultados{i}.DA=1;
    end
            
    end
    
    
    g = [];
DR = [];
DA = [];

for n=1:size(Resultados,2)
   g = [g Resultados{n}.g];
   DR = [DR Resultados{n}.DR];
   DA = [DA Resultados{n}.DA];
end

gm = mean(g);
gd = std(g);
DRm = mean(DR);
DRd = std(DR);
DAm = mean(DA);
DAd = std(DA);
format long g

hold on
grid on
% axis([ 0 300 0 1])
LineWidth = 2;
x = 1:1:size(Resultados,2);
plot( x , g , '-rs' ,'LineWidth',LineWidth)
plot( x , DR , '-gs' ,'LineWidth',LineWidth)
plot( x , DA , '-bs' ,'LineWidth',LineWidth)   
% legend('g','DR','DA','Location','SouthWest');
legend('g','DR','DA','Location','SouthEast');
xlabel('Frame')
ylabel('%')
% title('Real time Detection of Lane Markers in Urban Streets')
title('Road Recognition')

fprintf('g = %d+/- %d \n',gm,gd)
fprintf('DR = %d+/- %d \n' ,DRm,DRd)
fprintf('DA = %d+/- %d \n',DAm,DAd)
    
save Resultados_lane_departure_fix Resultados
disp('end')
    
    %% disp. Resultados
    
    clear all
    close all
    clc
    
    cd /home/morais/Bags/Piscinas_Ilhavo  % mudar o diretorio
%     load Resultados_caltech.mat             %Carregar os Resultados guardados 
%     load caltech_dist
        Resultados = load(char('data_fix.mat'))

% load dist_road_recognition
% load Resultados_lane_departure.mat
    g = [];
    DR = [];
    DA = [];
    
    figure('Position',[80 80 1200 500],'Color',[1 1 1])
    
    % Converter os resultados para vetores
    for n=1:size(Resultados,2)
        g = [g Resultados{n}.g];
        DR = [DR Resultados{n}.DR];
        DA = [DA Resultados{n}.DA];
    end
    
    % calcular as médias
    format long g
    gm = mean(g);
    DAm = mean(DA);
    DRm = mean(DR);
    
    % Calcular os desvio padrão
    DRd = std(DR);
    DAd = std(DA);
    gd = std(g);

%     dist = ones(1,300)*4.5;
    
    hold on
    grid on
    axis([ 0 300 0 1.1])
    LineWidth = 2;
    x = 1:1:size(Resultados,2);
    % Fazer os gráficos
    [AX,H1,H2] = plotyy(x,g,x,dist,'plot');
    plot( x , DR , '-rs' ,'LineWidth',LineWidth)
    plot( x , DA , '-gs' ,'LineWidth',LineWidth)
%     set(AX(2),'YLim',[0 7])
%     set(AX(2),'YTick',[0:1:5])
    
    % Muadas as cores dos marcadores
    set(H1,'marker','s','LineWidth',LineWidth)
    set(H2,'marker','d','LineWidth',LineWidth)
    set(H2,'color',[1 0.7 0]);
    
    % Criar as legendas
    legend('g','DR','DA','Dist','Location','SouthWest');
    xlabel('Frame')
    ylabel('%')
    set(get(AX(1),'Ylabel'),'String','%','fontsize',12)
    set(get(AX(2),'Ylabel'),'String','Distancia (m)','fontsize',12)
    title('Road Recognition')

    
    % Mudar a cor dos eixos
    set(AX(1), 'YColor', [0 0 0])
    set(AX(2), 'YColor', [0 0 0])
    
    %Mostrar as variáveis
    format long g
    fprintf('g = %d+/- %d \n',gm,gd)
    fprintf('DR = %d+/- %d \n' ,DRm,DRd)
    fprintf('DA = %d+/- %d \n',DAm,DAd)
    
%     export_fig teste.pdf -pdf
    
    
    %% Mostrar os poligonos gerados 
    
    clear all
    close all
    clc
    
    % [FileName,PathName,FilterIndex] = uigetfile('*.txt','Select files to convert','MultiSelect','on');
    % name = cellstr(FileName);
    
    % Turn warning off
    warning('off','all')
    tam_original_image = 0;
    
%     cd /home/morais/Bags/Piscinas_Ilhavo/               % mudar o diretorio
    cd /home/morais/Bags/Piscinas_Ilhavo/Algoritmo_2/               % mudar o diretorio
    load ground_truth                                   % carregar o groud truth (data)

    srcFiles = dir('/home/morais/Bags/Piscinas_Ilhavo/images/*.jpg')

    % Ler os ficheiros das configurações individuais
    load(char('data_fix.mat'))
    dist = [];
    
    for i=1:1:300
        
        % Ler as imagens
        filename = strcat('/home/morais/Bags/Piscinas_Ilhavo/images/',srcFiles(i).name);
        I = imread(filename);

        imshow(I);
        set(gcf,'Color',[1 1 1]);
        get(gca,'TightInset');
%         title('Resultados automaticos');
        hold on
        
        % fazer os display do groundtruth
        color = 'r';
        alpha = .3;
        g = fill(data{i}.x , data{i}.y , color);
        set(g,'FaceColor',color,'EdgeColor',color,'FaceAlpha',alpha,'EdgeAlpha',alpha)
        
        % Fazer o display do poligono
        color = 'g';
        alpha = .3;
        h = fill(matrix{i}.x , matrix{i}.y , color);
        set(h,'FaceColor',color,'EdgeColor',color,'FaceAlpha',alpha,'EdgeAlpha',alpha)

        
        % Criar as legendas das imagens
%         leg = legend('Groundtruth','Generated Poligon');
%         set(leg,'FontSize',10);
%                 distance = ((640-min(matrix{i}.y))*4.5)/(640-206);
%     dist = [dist distance];

%         str = sprintf('Frame %d',i);
%         txt = text(10,470,str);
%         set(txt,'BackgroundColor',[1 1 1],'FontSize',30);
      
        switch i
            case 1
%                 export_fig frame1.png -png
                disp('Saved frame 1')
                pause(0.15);
                break
            
            case 35
%                 k = waitforbuttonpress; 
                export_fig frame35.png -png
                disp('Saved frame 35')
                pause(0.15);
                
            case 200
%                 k = waitforbuttonpress; 
                export_fig frame200.png -png
                disp('Saved frame 200')
                pause(0.15);
                
            case 89
%                 k = waitforbuttonpress;
                export_fig frame89.png -png
                disp('Saved frame 89')
                pause(0.15);
                
            case 146
%                 k = waitforbuttonpress;
                export_fig frame146.png -png
                disp('Saved frame 146')
                pause(0.15);
                
            case 260
%                 k = waitforbuttonpress;
                export_fig frame260.png -png
                disp('Saved frame 260')
                pause(0.15);
                
            otherwise
                pause(0.15);
        end

        hold off
    end
    
    disp('---THE END---')
     
    