clear all;
global FACETAS IMAGENES INTERSECCIONES TRAYECTORIAS DIFRACTORES;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%                     RECORDATORIO DE TABLAS                            
%                materiales
%*------*-----------------------*----------*
%|      | permitividad compleja | espesor  |
%*------*-----------------------*----------*
%|indice|                       |          |
%*------*-----------------------*----------*
%
%                 facetas
%*------*----*----*----*----*------*---------*----------*
%|      | x1 | y1 | x2 | y2 | tipo | externa | material |
%*------*----*----*----*----*------*---------*----------*
%|indice|    |    |    |    |      |         |          |
%*------*----*----*----*----*------*---------*----------*
%
%
%                 difractores
%*------*---*---*----------*----------*----------*----------*
%|      | x | y | faceta 1 | faceta 2 | factor n | material |
%*------*---*---*----------*----------*----------*----------*
%|indice|   |   |          |          |          |          |
%*------*---*---*----------*----------*----------*----------*
%
%
%                 imagenes
%*------*----*----*-------*--------*                 
%|      | x1 | y1 | padre | faceta |
%*------*----*----*-------*--------*
%|indice|    |    |       |        |
%*------*----*----*-------*--------*
%
%
%                intersecciones (tipo: 0/1/2 reflexión/transmisión/difracción)
%*------*---*---*------*--------*-------------------*-----*-----*---------*---*----*                 
%|      | x | y | tipo | faceta | angulo incidencia |dif1 |dif2 | material| R0| R1 |
%*------*---*---*------*--------*-------------------*-----*-----*---------*---*----*
%|indice|   |   |      |        |                   |     |     |         |   |    |
%*------*---*---*------*--------*-------------------*-----*-----*---------*---*----*
%
%                trayectorias
%*------*--------*--------*--------*-----------------*-----------------------*---------------*------------*                 
%|      | num int| 1ª int | 2ª int | dist tx - 1ªint | distancia 1ªint 2ªint | dist 2ªint rx | dist total |
%*------*--------*--------*--------*-----------------*-----------------------*---------------*------------*
%|indice|        |        |        |                 |                       |               |            |
%*------*--------*--------*--------*-----------------*-----------------------*---------------*------------*
%
%
%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

solicitar_parametros

%Intersecciones entre facetas para la difracción
interseccion_facetas=[];
for n_fac=1:num_facetas-1
    segmento1=[FACETAS(n_fac,1:2);FACETAS(n_fac,3:4)];
    for aux=n_fac+1:num_facetas
        segmento2=[FACETAS(aux,1:2);FACETAS(aux,3:4)];
        punto_interseccion=calcula_intersecciones(segmento1,segmento2);
        if(isempty(punto_interseccion)==0) %Existe intersección
            interseccion_facetas=[interseccion_facetas;punto_interseccion];
        end
    end
end
[num_int_fac ~]=size(interseccion_facetas);        
POTENCIA(round(xmax/res+1),round(ymax/res+1))=0;

%Árbol de las imágenes del tx
IMAGENES(1,1:4)=[x_tx y_tx 0 0]; %considero el TX como una imagen con faceta=0 y padre=0
if (num_refl~=0)
    for num=1:num_facetas
        calcula_imagen([x_tx y_tx],1,num); %El padre es el TX, imagen 1
    end
    if(num_refl>1) %Si hay mas de dos reflexiones creamos el árbol de imágenes
        arbol_imagenes(num_facetas,num_refl);
    end
end
[ultima_imagen ~]=size(IMAGENES); %indice de la ultima imagen
progreso=0;

%Análisis de cada punto del entorno según la resolución
for x_rx=0:res:xmax
    for y_rx=0:res:ymax
        p_rx=[x_rx,y_rx];        
        E_refl=0;
        E_los=0;
        E_dif=0;
        E_dif2=0;
        E_rd=0;
        E_dr=0;
        %caminos=[];
        INTERSECCIONES=[];
        TRAYECTORIAS=[];
        IMAGENES(ultima_imagen+1:end,:)=[]; %Reinicializo el árbol de las imágenes del rx
        ultima_imagen_rx=0;
        
%No consideramos los puntos en las paredes externas 
        for num=1:num_facetas
            faceta=[FACETAS(num,1:2);FACETAS(num,3:4)];
            punto_en_faceta=punto_en_segmento(p_rx,faceta);
            if(punto_en_faceta==1 || (x_tx==x_rx && y_tx==y_rx))                
                if(x_rx==0 || y_rx==0 || x_rx==xmax || y_rx==ymax)
                    POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=NaN;
                else
                    POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=(POTENCIA(round((x_rx-res)/res+1),round(y_rx/res+1))+POTENCIA(round(x_rx/res+1),round((y_rx-res)/res+1)))/2;
                end
                break;
            elseif(num==num_facetas)
                r=distancias(p_rx,p_tx);
                if(r<0.1) %A frecuencia 2.4Ghz-> lambda=0.125, campo lejano si r<<lambda
                    r=0.1;
                    E_total=calcula_campo(P0,Dg,k0,r,0,0,0,0,0,pol);
                    S=(abs(E_total)^2)/(120*pi);
                    POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=10*log10(S*Aef);
                else
                    %Comprobamos los distintos tipos de rayos            
                    if(rayos_los) 
                        num_int_trans=calcula_int_transmision(0,p_tx,p_rx);
                        r=distancias(p_tx,p_rx);
                        E_los=calcula_campo(P0,Dg,k0,r,0,0,1,num_int_trans,0,pol);
                    end
                    
                    if(rayos_ref)
                        for n_im=2:ultima_imagen
                            im=n_im; %Inicializamos la imagen padre
                            xrx=x_rx;
                            yrx=y_rx;
                            [ult_int ~]=size(INTERSECCIONES); %Indice de la ultima interseccion antes de la nueva trayectoria
                            while(im~=1)
                                seg_rx_im=[[xrx yrx];IMAGENES(im,1:2)];
                                pared_de_imagen=[FACETAS(IMAGENES(im,4),1:2);FACETAS(IMAGENES(im,4),3:4)];
                                punt_int=calcula_intersecciones(seg_rx_im,pared_de_imagen);
                                if(isempty(punt_int)==0) %Existe intersección
                                    incorrecto=0;
                                    for k=1:num_int_fac
                                        p_aux=interseccion_facetas(k,1:2);
                                        if(abs(p_aux(1)-punt_int(1))<0.001 && abs(p_aux(2)-punt_int(2))<0.001)
                                            incorrecto=1; %No quiero puntos que esten en esquinas
                                            break
                                        end
                                    end
                                end
                                    
                                % No queremos reflexiones en las
                                % esquinas
                                if((isempty(punt_int)==0 && incorrecto==0 && ((abs(punt_int(1)-pared_de_imagen(1,1))>0.001) || (abs(punt_int(2)-pared_de_imagen(1,2))>0.001)) && ((abs(punt_int(1)-pared_de_imagen(2,1))>0.001) || (abs(punt_int(2)-pared_de_imagen(2,2))>0.001))))
                                    interseccion=[punt_int,0,IMAGENES(im,4),angulo_incidencia(seg_rx_im,pared_de_imagen),0,0,FACETAS(IMAGENES(im,4),7)];
                                    [ult_int2 ~]=size(INTERSECCIONES);
                                    INTERSECCIONES(ult_int2+1,1:8)=interseccion; %Sentido inverso, del rx al tx
                                    xrx=punt_int(1); %Ahora mi nuevo rx sera el punto de interseccion
                                    yrx=punt_int(2);
                                    im=(IMAGENES(im,3)); %Compruebo de que imagen proviene
                                    if(im==1) %Hemos llegado al tx
                                        [ult_int2 ~]=size(INTERSECCIONES); %Intersecciones totales
                                        n_int=ult_int2-ult_int; %Numero de intersecciones de la ultima trayectoria
                                        camino(n_int,1,p_tx,p_rx); %Almaceno trayectoria invertida
                                    end
                                else
                                    [ult_int2 ~]=size(INTERSECCIONES); %Ahora comprobamos si existen intersecciones de trayectorias erroneas
                                    if(ult_int2~=ult_int) %En este caso hay trayectorias nuevas desde la ultima vez
                                        INTERSECCIONES(ult_int+1:ult_int2,:)=[]; %Borramos solo la ultima trayectoria calculada
                                    end
                                    break %Salimos del while, pasamos a otra imagen
                                end
                            end
                        end %Final analisis imagenes para reflexion

                        %calculo del campo electrico total para las trayectorias de reflexion
                        if(isempty(TRAYECTORIAS)==0)
                            [num_trayectos ~]=size(TRAYECTORIAS);
                            for nc=1:num_trayectos
                                num_int_trans=calcula_int_transmision(nc,p_tx,p_rx);
                                num_int=TRAYECTORIAS(nc,1);
                                r=TRAYECTORIAS(nc,2*num_int+3);
                                E=calcula_campo(P0,Dg,k0,r,0,0,2,num_int_trans,nc,pol);
                                E_refl=E_refl+E;
                            end
                        end
                    end
                    
                    if(rayos_dif)
                        %Difracción simple
                        for n_dif=1:dif
                            p_dif=DIFRACTORES(n_dif,1:2);
                            n=DIFRACTORES(n_dif,5);
                            [phitx phirx R0 Rn]=angulo_difraccion(p_tx,p_rx,DIFRACTORES(n_dif,1:6),pol);
                            if(isempty(phitx)==0 && isempty(phirx)==0) %Trayectoria del tx-pdif y pdif-rx correcta
                                [int_dif ~]=size(INTERSECCIONES);
                                INTERSECCIONES(int_dif+1,1:8)=[p_dif,2,n_dif,pi/2,phitx,phirx,DIFRACTORES(n_dif,6)]; %Yo uso n_dif para saber de que difractor viene esta intersección
                                camino(1,0,p_tx,p_rx);
                                [ult_trayectodif ~]=size(TRAYECTORIAS);
                                s1=TRAYECTORIAS(ult_trayectodif,3); %Recorrido tx-p_dif
                                s2=TRAYECTORIAS(ult_trayectodif,4); %Recorrido p_dif-rx
                                num_int_trans=calcula_int_transmision(ult_trayectodif,p_tx,p_rx);
                                D=coef_difraccion(k0,beta,R0,Rn,phitx,phirx,s2,n,pol);
                                E=calcula_campo(P0,Dg,k0,s1,s2,D,3,num_int_trans,ult_trayectodif,pol); %Tengo que poner los nuevos parametros de difraccion
                                E_dif=E_dif+E;
                            end

                            %Difracción doble
                            if(rayos_dif2 && dif>1 && isempty(phirx)==0) %Busco camino doble difractado para llegar al rx
                                [ult_trayecto ~]=size(TRAYECTORIAS); %Antes de la difracción doble
                                for dif_aux=1:dif %Calculamos todas las trayectorias doblemente difractadas
                                    if(dif_aux~=n_dif && (DIFRACTORES(n_dif,3)~=DIFRACTORES(dif_aux,3)) && (DIFRACTORES(n_dif,3)~=DIFRACTORES(dif_aux,4)) && (DIFRACTORES(n_dif,4)~=DIFRACTORES(dif_aux,3)) && (DIFRACTORES(n_dif,4)~=DIFRACTORES(dif_aux,4))) %Busco difractor distinto y que no sea de la misma faceta (bordes)
                                        p_dif2=DIFRACTORES(dif_aux,1:2);
                                        [phitx1 phirx1 R01 Rn1]=angulo_difraccion(p_tx,p_dif,DIFRACTORES(dif_aux,1:6),pol);
                                        if(isempty(phitx1)==0 && isempty(phirx1)==0) %Trayectoria del tx-pdif y pdif-pdif2 correcta
                                            [phitx2 phirx2 R02 Rn2]=angulo_difraccion(p_dif2,p_rx,DIFRACTORES(n_dif,1:6),pol);
                                            if(isempty(phitx2)==0 && isempty(phirx2)==0) %Trayectoria del pdif-pdif2 y pdif2-rx correcta
                                                [int_dif ~]=size(INTERSECCIONES);
                                                INTERSECCIONES(int_dif+1,1:10)=[p_dif2,2,dif_aux,pi/2,phitx1,phirx1,DIFRACTORES(dif_aux,6),R01,Rn1];
                                                INTERSECCIONES(int_dif+2,1:10)=[p_dif,2,n_dif,pi/2,phitx2,phirx2,DIFRACTORES(n_dif,6),R02,Rn2];
                                                camino(2,0,p_tx,p_rx);
                                            end
                                        end
                                    end
                                end %Ya tenemos las trayectorias doblemente difractadas
                                [ult_trayectodif2 ~]=size(TRAYECTORIAS);
                                if(ult_trayectodif2~=ult_trayecto) %Existen trayectorias de difracción doble 
                                    for nc=ult_trayecto+1:ult_trayectodif2 %Recorremos esas trayectorias
                                        s1_aux1=TRAYECTORIAS(nc,4); %Recorrido tx-p_dif1
                                        s2_aux1=TRAYECTORIAS(nc,5); %Recorrido p_dif1-p_dif2
                                        phitx1=INTERSECCIONES(TRAYECTORIAS(nc,2),6);
                                        phirx1=INTERSECCIONES(TRAYECTORIAS(nc,2),7);
                                        R01=INTERSECCIONES(TRAYECTORIAS(nc,2),9);
                                        Rn1=INTERSECCIONES(TRAYECTORIAS(nc,2),10);
                                        D_aux1=coef_difraccion(k0,beta,R01,Rn1,phitx1,phirx1,s2_aux1,n,pol);
                                        n_aux=DIFRACTORES(INTERSECCIONES(TRAYECTORIAS(nc,3),4),5);
                                        %s1_aux2=s2_aux1; %Recorrido p_dif1-p_dif2
                                        s2_aux2=TRAYECTORIAS(nc,6); %Recorrido p_dif2-rx
                                        phitx2=INTERSECCIONES(TRAYECTORIAS(nc,3),6);
                                        phirx2=INTERSECCIONES(TRAYECTORIAS(nc,3),7);
                                        R02=INTERSECCIONES(TRAYECTORIAS(nc,3),9);
                                        Rn2=INTERSECCIONES(TRAYECTORIAS(nc,3),10);
                                        D_aux2=coef_difraccion(k0,beta,R02,Rn2,phitx2,phirx2,s2_aux2,n_aux,pol);
                                        num_int_trans=calcula_int_transmision(nc,p_tx,p_rx);
                                        D=[D_aux1 D_aux2]; 
                                        s1=s1_aux1;
                                        s2=[s2_aux1 s2_aux2];
                                        E=calcula_campo(P0,Dg,k0,s1,s2,D,3,num_int_trans,nc,pol); %Tengo que poner los nuevos parametros de difraccion
                                        E_dif2=E_dif2+E;
                                    end
                                end
                            end
                            %Reflexiones con difracción
                            if(rayos_mix && isempty(phirx)==0)
                                [ult_trayecto ~]=size(TRAYECTORIAS); %Antes de las de reflexión-difracción
                                for n_im=2:ultima_imagen
                                    im=n_im; %Inicializamos la imagen padre
                                    xrx=p_dif(1);
                                    yrx=p_dif(2);
                                    [ult_int ~]=size(INTERSECCIONES); %Indice de la ultima interseccion antes de la nueva trayectoria
                                    while(im~=1)
                                        seg_rx_im=[[xrx yrx];IMAGENES(im,1:2)];
                                        pared_de_imagen=[FACETAS(IMAGENES(im,4),1:2);FACETAS(IMAGENES(im,4),3:4)];
                                        punt_int=calcula_intersecciones(seg_rx_im,pared_de_imagen);
                                        % No queremos reflexiones en las
                                        % esquinas
                                        if((isempty(punt_int)==0 && ((abs(punt_int(1)-pared_de_imagen(1,1))>0.001) || (abs(punt_int(2)-pared_de_imagen(1,2))>0.001)) && ((abs(punt_int(1)-pared_de_imagen(2,1))>0.001) || (abs(punt_int(2)-pared_de_imagen(2,2))>0.001))))
                                            if(n_im==im) %La difracción se calcula al principio
                                                [phitx phirx R0 Rn]=angulo_difraccion(punt_int,p_rx,DIFRACTORES(n_dif,1:6),pol);
                                                if(isempty(phitx)==0 && isempty(phirx)==0) %Basta solo con phitx, phirx viene de la difracción original
                                                    [ult_int2 ~]=size(INTERSECCIONES);
                                                    INTERSECCIONES(ult_int2+1,1:10)=[p_dif,2,n_dif,pi/2,phitx,phirx,DIFRACTORES(n_dif,6),R0,Rn];
                                                else break; %Pasamos a otra imagen, no hay trayectoria correcta entre la imagen y el punto de difracción                                                   
                                                end
                                            end
                                            interseccion=[punt_int,0,IMAGENES(im,4),angulo_incidencia(seg_rx_im,pared_de_imagen),0,0,FACETAS(IMAGENES(im,4),7)];
                                            [ult_int2 ~]=size(INTERSECCIONES);
                                            INTERSECCIONES(ult_int2+1,1:8)=interseccion; %Sentido inverso, del rx al tx
                                            xrx=punt_int(1); %Ahora mi nuevo rx sera el punto de interseccion
                                            yrx=punt_int(2);
                                            im=(IMAGENES(im,3)); %Compruebo de que imagen proviene
                                            if(im==1) %Hemos llegado al tx
                                                [ult_int2 ~]=size(INTERSECCIONES); %Intersecciones totales
                                                n_int=ult_int2-ult_int; %Numero de intersecciones de la ultima trayectoria
                                                camino(n_int,1,p_tx,p_rx); %Almaceno trayectoria invertida
                                            end
                                        else
                                            [ult_int2 ~]=size(INTERSECCIONES); %Ahora comprobamos si existen intersecciones de trayectorias erroneas
                                            if(ult_int2~=ult_int) %En este caso hay trayectorias nuevas desde la ultima vez
                                                INTERSECCIONES(ult_int+1:ult_int2,:)=[]; %Borramos solo la ultima trayectoria calculada
                                            end
                                            break %Salimos del while, pasamos a otra imagen
                                        end
                                    end
                                end %Final analisis imagenes para reflexion con difracción
                                [ult_trayectord ~]=size(TRAYECTORIAS);
                                if(ult_trayectord~=ult_trayecto) %Existen trayectorias difracción-reflexión, se almacenan después de las difracciones dobles
                                    for nc=ult_trayecto+1:ult_trayectord
                                        num_int_trans=calcula_int_transmision(nc,p_tx,p_rx);
                                        num_int=TRAYECTORIAS(nc,1);
                                        phitx=INTERSECCIONES(TRAYECTORIAS(nc,num_int+1),6);
                                        phirx=INTERSECCIONES(TRAYECTORIAS(nc,num_int+1),7);
                                        R0=INTERSECCIONES(TRAYECTORIAS(nc,num_int+1),9);
                                        Rn=INTERSECCIONES(TRAYECTORIAS(nc,num_int+1),10);
                                        s2=TRAYECTORIAS(nc,2*num_int+2); %Recorrido del difractor hasta el rx
                                        r=TRAYECTORIAS(nc,2*num_int+3)-s2; %Recorrido total hasta el difractor (reflexiones)
                                        D=coef_difraccion(k0,beta,R0,Rn,phitx,phirx,s2,n,pol);
                                        E=calcula_campo(P0,Dg,k0,r,s2,D,2,num_int_trans,nc,pol);
                                        E_rd=E_rd+E;
                                    end
                                end
                            end
                            %Difracción con reflexiones
                            if(rayos_mix && isempty(phitx)==0)
                                [ult_trayecto ~]=size(TRAYECTORIAS); %Antes de las de difracción-reflexión
                                if(ultima_imagen_rx==0) %Si no existe árbol de imagenes para ese punto, se crea a partir de la ultima posición
                                    IMAGENES(ultima_imagen+1,1:4)=[x_rx y_rx 0 0]; %evaluamos a partir del rx
                                    if (num_refl~=0)
                                        for nf=1:num_facetas
                                            calcula_imagen([x_rx y_rx],ultima_imagen+1,nf); %El padre es el rx
                                        end
                                        if(num_refl>1) %Si hay mas de dos reflexiones creamos el árbol de imágenes
                                            arbol_imagenes(num_facetas,num_refl);
                                        end
                                    end
                                    [ultima_imagen_rx ~]=size(IMAGENES); %indice de la ultima imagen
                                end
                                for n_im=ultima_imagen+2:ultima_imagen_rx
                                    im=n_im; %Inicializamos la imagen padre
                                    xrx=p_dif(1);
                                    yrx=p_dif(2);
                                    [ult_int ~]=size(INTERSECCIONES); %Indice de la ultima interseccion antes de la nueva trayectoria
                                    while(im~=ultima_imagen+1) %La imagen padre del segundo árbol
                                        seg_rx_im=[[xrx yrx];IMAGENES(im,1:2)];
                                        pared_de_imagen=[FACETAS(IMAGENES(im,4),1:2);FACETAS(IMAGENES(im,4),3:4)];
                                        punt_int=calcula_intersecciones(seg_rx_im,pared_de_imagen);
                                        % No queremos reflexiones en las
                                        % esquinas
                                        if((isempty(punt_int)==0 && ((abs(punt_int(1)-pared_de_imagen(1,1))>0.001) || (abs(punt_int(2)-pared_de_imagen(1,2))>0.001)) && ((abs(punt_int(1)-pared_de_imagen(2,1))>0.001) || (abs(punt_int(2)-pared_de_imagen(2,2))>0.001))))
                                            if(xrx==p_dif(1) && yrx==p_dif(2))
                                                [phitx phirx R0 Rn]=angulo_difraccion(p_tx,punt_int,DIFRACTORES(n_dif,1:6),pol);
                                                if(isempty(phitx)==0 && isempty(phirx)==0) %Basta con phirx, phitx es el de la difracción original
                                                    [ult_int2 ~]=size(INTERSECCIONES);
                                                    INTERSECCIONES(ult_int2+1,1:10)=[p_dif,2,n_dif,pi/2,phitx,phirx,DIFRACTORES(n_dif,6),R0,Rn];
                                                else
                                                    break %Salimos del while, pasamos a otra imagen.
                                                end
                                            end
                                            interseccion=[punt_int,0,IMAGENES(im,4),angulo_incidencia(seg_rx_im,pared_de_imagen),0,0,FACETAS(IMAGENES(im,4),7)];
                                            [ult_int2 ~]=size(INTERSECCIONES);
                                            INTERSECCIONES(ult_int2+1,1:8)=interseccion; %Sentido inverso, del rx al tx
                                            xrx=punt_int(1); %Ahora mi nuevo rx sera el punto de interseccion
                                            yrx=punt_int(2);
                                            im=(IMAGENES(im,3)); %Compruebo de que imagen proviene
                                            if(im==ultima_imagen+1) %Hemos llegado al tx (p_dif), la difracción se calcula al final
                                                [ult_int2 ~]=size(INTERSECCIONES); %Intersecciones totales
                                                n_int=ult_int2-ult_int; %Numero de intersecciones de la ultima trayectoria
                                                camino(n_int,0,p_tx,p_rx); %Almaceno trayectoria no invertida, ya que el recorrido fue p_dif-p_rx
                                            end
                                        else
                                            [ult_int2 ~]=size(INTERSECCIONES); %Ahora comprobamos si existen intersecciones de trayectorias erroneas
                                            if(ult_int2~=ult_int) %En este caso hay trayectorias nuevas desde la ultima vez
                                                INTERSECCIONES(ult_int+1:ult_int2,:)=[]; %Borramos solo la ultima trayectoria calculada
                                            end
                                            break %Salimos del while, pasamos a otra imagen
                                        end
                                    end
                                end %Final analisis imagenes para reflexion con difracción
                                [ult_trayectodr ~]=size(TRAYECTORIAS);
                                if(ult_trayectodr~=ult_trayecto) %Existen trayectorias difracción-reflexión, se almacenan después de las de reflexión-difracción
                                    for nc=ult_trayecto+1:ult_trayectodr
                                        num_int_trans=calcula_int_transmision(nc,p_tx,p_rx);
                                        num_int=TRAYECTORIAS(nc,1);
                                        phitx=INTERSECCIONES(TRAYECTORIAS(nc,2),6); %La primera intersección es la de difracción
                                        phirx=INTERSECCIONES(TRAYECTORIAS(nc,2),7);
                                        R0=INTERSECCIONES(TRAYECTORIAS(nc,2),9);
                                        Rn=INTERSECCIONES(TRAYECTORIAS(nc,2),10);
                                        s1=TRAYECTORIAS(nc,num_int+2); %Recorrido total hasta el difractor
                                        r=TRAYECTORIAS(nc,2*num_int+3)-s1; %Recorrido del difractor hasta el rx (reflexiones)
                                        D=coef_difraccion(k0,beta,R0,Rn,phitx,phirx,r,n,pol);
                                        E=calcula_campo(P0,Dg,k0,s1,r,D,2,num_int_trans,nc,pol);
                                        E_dr=E_dr+E;
                                    end
                                end
                            end
                        end                       
                    end
                    
                    %Calculamos ahora la potencia total a partir de la suma
                    %de los campos debidos a los distinto rayos
                    E_total=E_los+E_refl+E_dif+E_dif2+E_rd+E_dr;
                    if(E_total~=0)
                        S=(abs(E_total)^2)/(120*pi);
                        POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=10*log10(S*Aef);
                    end

                end %Fin de campo lejano                
            end
        end

        clc;
        fprintf('Procesando: %.2f%% completado\n',100*(1+progreso)/((1+xmax/res)*(1+ymax/res)));
        if (x_rx==rx(1) && y_rx==rx(2))%PRUEBAS
            intersecciones=INTERSECCIONES;
            trayectorias=TRAYECTORIAS;
            pinta_trayectorias(res,p_tx,rx,xmax,ymax,trayectorias,intersecciones);
        end
        progreso=progreso+1;
    end %Final coordenada y del rx
end %Final coordenada x del rx



% Aproximamos los puntos donde la señal no esta definida
for x_rx=0:res:xmax    
    for y_rx=0:res:ymax
        if(isnan(POTENCIA(round(x_rx/res+1),round(y_rx/res+1))))
            if(x_rx~=0 && x_rx~=xmax && y_rx==0)
                if(isnan(POTENCIA(round(x_rx/res+1),round((y_rx+res)/res+1))))
                    POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=ajuste_potencia(POTENCIA(round((x_rx-res)/res+1):round((x_rx+res)/res+1),round(y_rx/res+1):round((y_rx+res)/res+1)));
                else
                    POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=POTENCIA(round(x_rx/res+1),round((y_rx+res)/res+1));
                end
            elseif(x_rx==xmax && y_rx~=0 && y_rx~=ymax)
                POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=POTENCIA(round((x_rx-res)/res+1),round(y_rx/res+1));
            elseif(x_rx~=0 && x_rx~=xmax && y_rx==ymax)
                POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=POTENCIA(round(x_rx/res+1),round((y_rx-res)/res+1));
            elseif(x_rx==0 && y_rx~=0 && y_rx~=ymax)
                if(isnan(POTENCIA(round((x_rx+res)/res+1),round(y_rx/res+1))))
                    POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=ajuste_potencia(POTENCIA(round(x_rx/res+1):round((x_rx+res)/res+1),round((y_rx-res)/res+1):round((y_rx+res)/res+1)));
                else
                    POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=POTENCIA(round((x_rx+res)/res+1),round(y_rx/res+1));
                end
            elseif(x_rx==0 && y_rx==0)
                POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=POTENCIA(round((x_rx+res)/res+1),round((y_rx+res)/res+1));
            elseif(x_rx==xmax && y_rx==0)
                POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=POTENCIA(round((x_rx-res)/res+1),round((y_rx+res)/res+1));
            elseif(x_rx==xmax && y_rx==ymax)
                POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=POTENCIA(round((x_rx-res)/res+1),round((y_rx-res)/res+1));
            elseif(x_rx==0 && y_rx==ymax)
                POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=POTENCIA(round((x_rx+res)/res+1),round((y_rx-res)/res+1));
            elseif(x_rx~=0 && x_rx~=xmax && y_rx~=0 && y_rx~=xmax)
                POTENCIA(round(x_rx/res+1),round(y_rx/res+1))=ajuste_potencia(POTENCIA(round((x_rx-res)/res+1):round((x_rx+res)/res+1),round((y_rx-res)/res+1):round((y_rx+res)/res+1)));
            end
        end
    end
end
ModS=(1/Aef)*10.^(POTENCIA/10);
%Representamos los resultados obtenidos 
representacion_resultados(xmax,ymax,p_tx,POTENCIA,res);
fprintf('El nivel de potencia en el punto (%.2f,%.2f) es de %.2f dBm \n',rx(1),rx(2),POTENCIA(round(rx(1)/res+1),round(rx(2)/res+1)));