Ivan Mendoza: Algoritmo Genetico Rompe Cabeza (MATLAB)

Bien aquí les dejo un algoritmo genético que desarrolle para armar un rompe cabeza de 6 x 6.

Para realizarlo utilice MATLAB el código es muy sencillo de entender y esta comentado, además para realizarlo me base en esta publicación de Fubito Toyama, Yukihiro Fujiki, Kenji Shoji, y Juichi Miyamichi de la Facultad de ingeniería en la Universidad de Utsunomiya en Japón.

Por lo que ustedes pueden tomar como referencia esa publicacion tambien.

Ver Publicación

Esta fue la imagen que utilze yo para partirla en imagenes de 100x100px por lo que la imagen es de 600x600px

DESCARGAR CODIGO

Solo recuerden cambiar las rutas de acceso a archivos.

Cualquier duda comenten.

f = imread('C:\Users\ivan\Documents\scrambledImage orgi.bmp'); % leemos la imagen la imagen se grabo como 8bit bmp 
 f = logical(f); % convierte la imagen a binario
 
 %padres_fit=zeros(200,1);
 
 padres=zeros(200,37);
% imagenbn=rgb2gray(f); % convierte imagen a escala de grises
%f(y,x)
%m = a(ri : rf , ci : cf)

A1= f(1 : 100, 1 : 100); % Extrae y Genera un matriz nueva a partir de f de 100 x 100

A2= f(1 : 100, 101 : 200);
A3= f(1 : 100, 201 : 300);
A4= f(1 : 100, 301 : 400);
A5= f(1 : 100, 401 : 500);
A6= f(1 : 100, 501 : 600);

B1= f(101 : 200, 1 : 100); % Extrae y Genera un matriz nueva a partir de f de 50 x 50
B2= f(101 : 200, 101 : 200);
B3= f(101 : 200, 201 : 300);
B4= f(101 : 200, 301 : 400);
B5= f(101 : 200, 401 : 500);
B6= f(101 : 200, 501 : 600);

C1= f(201 : 300, 1 : 100); % Extrae y Genera un matriz nueva a partir de f de 50 x 50
C2= f(201 : 300, 101 : 200);
C3= f(201 : 300, 201 : 300);
C4= f(201 : 300, 301 : 400);
C5= f(201 : 300, 401 : 500);
C6= f(201 : 300, 501 : 600);

D1= f(301 : 400, 1 : 100); % Extrae y Genera un matriz nueva a partir de f de 50 x 50
D2= f(301 : 400, 101 : 200);
D3= f(301 : 400, 201 : 300);
D4= f(301 : 400, 301 : 400);
D5= f(301 : 400, 401 : 500);
D6= f(301 : 400, 501 : 600);

E1= f(401 : 500, 1 : 100); % Extrae y Genera un matriz nueva a partir Ee f Ee 50 x 50
E2= f(401 : 500, 101 : 200);
E3= f(401 : 500, 201 : 300);
E4= f(401 : 500, 301 : 400);
E5= f(401 : 500, 401 : 500);
E6= f(401 : 500, 501 : 600);

F1= f(501 : 600, 1 : 100); % FxtraF y GFnFra un matriz nuFva a partir FF f FF 50 x 50
F2= f(501 : 600, 101 : 200);
F3= f(501 : 600, 201 : 300);
F4= f(501 : 600, 301 : 400);
F5= f(501 : 600, 401 : 500);
F6= f(501 : 600, 501 : 600);

%%%%%%%%%%%%%%%%%%%%%    FUNCION DE FITNESS       %%%%%%%%%%%%%%%%%%%%%%%%%
r1=100;
r2=101;
a=0;
for v=1:5
AB= f(r1 : r1, 1 :600);
BB= f(r2 : r2, 1 :600);

n=length(AB); % Cual es la longitud del vector?
[cantidad,posicion]=   find(AB==BB); % la funcion find te dice que elementos son iguales entre 2 vectores % esta puede funcionar solo con CANTIDAD, posicion es para bidimenciones
ig=length(cantidad); % iguales cantidad de elementos iguales entre la comparacion
x=ig*100/n;
a=a+x;
%porcentaje=[[num2str(x)]];

% muestra que porcentaje de elementos es igual entre 2 cadenas o vectores
r1=r1+100;
r2=r2+100;
end
fitness=a/5;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%    %%%%%%%%%%%%%%%%%%%%%%%
r1=100;
r2=101;
a=0;
for v=1:5
AB= f(1 : 600, r1 :r1);
BB= f(1 : 600, r2 :r2);
b=x;
n=length(AB); % Cual es la longitud del vector?
[cantidad,posicion]=find(AB==BB); % la funcion find te dice que elementos son iguales entre 2 vectores % esta puede funcionar solo con CANTIDAD, posicion es para bidimenciones
ig=length(cantidad); % iguales cantidad de elementos iguales entre la comparacion
x=ig*100/n;
a=a+x;
%porcentaje=[[num2str(x)]];

% muestra que porcentaje de elementos es igual entre 2 cadenas o vectores
r1=r1+100;
r2=r2+100;
end
fitness=(fitness+(a/5))/2;
display(fitness); 
fitnessideal=fitness;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

fitness=0;

%%%%%%%%%%%%%%%%%%%%%% CREACION DE PADRES %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%valores=[ A2 A3 A4 A5 A6];
c_r=[1 2 3 4 5 6]; % BASURA
cross2=[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20]; %BASURA

imagen1=[A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6]; % IMAGEN EN "BLANCO" para sobre escribir
v_or=[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36]; % vector ordenado

for ciclo=1:200 % ciclo crea padres
    
v_rn=randperm(length(v_or)); % lo revolemos
v_rn=randperm(length(v_rn)); % lo volvemos a revolver

v_fn=[v_rn(1,1) v_rn(1,2) v_rn(1,3) v_rn(1,4) v_rn(1,5) v_rn(1,6);v_rn(1,7) v_rn(1,8) v_rn(1,9) v_rn(1,10) v_rn(1,11) v_rn(1,12);
      v_rn(1,13) v_rn(1,14) v_rn(1,15) v_rn(1,16) v_rn(1,17) v_rn(1,18);v_rn(1,19) v_rn(1,20) v_rn(1,21) v_rn(1,22) v_rn(1,23) v_rn(1,24);
      v_rn(1,25) v_rn(1,26) v_rn(1,27) v_rn(1,28) v_rn(1,29) v_rn(1,30);v_rn(1,31) v_rn(1,32) v_rn(1,33) v_rn(1,34) v_rn(1,35) v_rn(1,36)];
 
 for tablapadres=1:36 
padres(ciclo,tablapadres)=v_rn(1,tablapadres); % ESTE FOR COMPLETO SOLO COPIA EL V_RN A LA TABLA DE PADRES
 end
% se muestrean valores de vector rn despues del random en cada casilla

% TODO ESTO ES LO QUE INTERPRETA LA MATRIZ RANDOM PARA REGENERAR LA IMAGEN
% SEGUN LOS VALORES DE LA MATRIZ V_FN
y=1; z=100; 
w=1; x=100; u=0;
for valorrn=1:36 
    if y==601
            y=501; z=600;
    end
c=1; d=100;
 a=1; b=100; t=0;       
for pieza=1:36
  
if     v_rn(valorrn)==pieza; % se muestra el primero
        if c==601
            c=501; d=600;
        end
      
        imagen1(w : x, y : z)= f(a : b, c : d); % C & D cambian cada 1 iteracion a razon de 100 y reinician cada 6
   
end                                           % A & B cambian cada 6 iteraciones a razon de 100 y jamaz reinician.
    t=t+1;  c=c+100; d=d+100;
        
       if c>501
            c=1; d=100;
       end
       if t>5
            a=a+100; b=b+100;   t=0;
       end       
end 
u=u+1;  y=y+100; z=z+100;
        
       if y>501
            y=1; z=100;
       end
       if u>5
            w=w+100; x=x+100;   u=0;
       end
       
end

y=0; z=0; w=0; x=0; u=0; c=0; d=0; b=0; t=0;

%%%%%%%%%%%%%%%%%%%%%    FUNCION DE FITNESS       %%%%%%%%%%%%%%%%%%%%%%%%%
r1=100;
r2=101;
a=0;
for v=1:5
AB= imagen1(r1 : r1, 1 :600);
BB= imagen1(r2 : r2, 1 :600);

n=length(AB); % Cual es la longitud del vector?
[cantidad,posicion]=find(AB==BB); % la funcion find te dice que elementos son iguales entre 2 vectores % esta puede funcionar solo con CANTIDAD, posicion es para bidimenciones
ig=length(cantidad); % iguales cantidad de elementos iguales entre la comparacion
x=ig*100/n;
a=a+x;
%porcentaje=[[num2str(x)]];

% muestra que porcentaje de elementos es igual entre 2 cadenas o vectores
r1=r1+100;
r2=r2+100;
end
fitness=a/5;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
r1=100;
r2=101;
a=0;
for v=1:5
AB= imagen1(1 : 600, r1 :r1);
BB= imagen1(1 : 600, r2 :r2);
b=x;
n=length(AB); % Cual es la longitud del vector?
[cantidad,posicion]=find(AB==BB); % la funcion find te dice que elementos son iguales entre 2 vectores % esta puede funcionar solo con CANTIDAD, posicion es para bidimenciones
ig=length(cantidad); % iguales cantidad de elementos iguales entre la comparacion
x=ig*100/n;
a=a+x;
%porcentaje=[[num2str(x)]];

% muestra que porcentaje de elementos es igual entre 2 cadenas o vectores
r1=r1+100;
r2=r2+100;
end
fitness=(fitness+(a/5))/2;

padres(ciclo, 37)=fitness;
end

%imwrite(imagen1,'C:\Users\ivan\Documents\imagen1.bmp');

%display(fitness);
%display(v_fn);
%display(padres);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

while fitness<83.66
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% BORRAR

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%valores=[ A2 A3 A4 A5 A6];
c_r=[1 2 3 4 5 6];
cross2=[1 2 3 4 5 6 7 8 9 10];

imagen1=[A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6;A6 A6 A6 A6 A6 A6];
v_or=[1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36];

for ciclo=1:195  % Solo deja los 5 mas altos
    
v_rn= v_or;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%PRIMER RANDOM EN FILAS

% TODO ESTO ES LO QUE INTERPRETA LA MATRIZ RANDOM PARA REGENERAR LA IMAGEN
% SEGUN LOS VALORES DE LA MATRIZ
y=1; z=100;
w=1; x=100; u=0;
for valorrn=1:36 
    if y==601
            y=501; z=600;
    end
c=1; d=100;
 a=1; b=100; t=0;       
for pieza=1:36
  
if     v_rn(valorrn)==pieza; % se muestra el primero
        if c==601
            c=501; d=600;
        end
      
        imagen1(w : x, y : z)= f(a : b, c : d); % C & D cambian cada 1 iteracion a razon de 100 y reinician cada 6
   
end                                           % A & B cambian cada 6 iteraciones a razon de 100 y jamaz reinician.
    t=t+1;  c=c+100; d=d+100;
        
       if c>501
            c=1; d=100;
       end
       if t>5
            a=a+100; b=b+100;   t=0;
       end       
end 
u=u+1;  y=y+100; z=z+100;
        
       if y>501
            y=1; z=100;
       end
       if u>5
            w=w+100; x=x+100;   u=0;
       end
       
end

y=0; z=0; w=0; x=0; u=0; c=0; d=0; b=0; t=0;

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%f=imagen1;

%%%%%%%%%%%%%%%%%%%%%    FUNCION DE FITNESS       %%%%%%%%%%%%%%%%%%%%%%%%%
r1=100;
r2=101;
a=0;
for v=1:5
AB= imagen1(r1 : r1, 1 :600);
BB= imagen1(r2 : r2, 1 :600);

n=length(AB); % Cual es la longitud del vector?
[cantidad,posicion]=find(AB==BB); % la funcion find te dice que elementos son iguales entre 2 vectores % esta puede funcionar solo con CANTIDAD, posicion es para bidimenciones
ig=length(cantidad); % iguales cantidad de elementos iguales entre la comparacion
x=ig*100/n;
a=a+x;
%porcentaje=[[num2str(x)]];

% muestra que porcentaje de elementos es igual entre 2 cadenas o vectores
r1=r1+100;
r2=r2+100;
end
fitness=a/5;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
r1=100;
r2=101;
a=0;
for v=1:5
AB= imagen1(1 : 600, r1 :r1);
BB= imagen1(1 : 600, r2 :r2);
b=x;
n=length(AB); % Cual es la longitud del vector?
[cantidad,posicion]=find(AB==BB); % la funcion find te dice que elementos son iguales entre 2 vectores % esta puede funcionar solo con CANTIDAD, posicion es para bidimenciones
ig=length(cantidad); % iguales cantidad de elementos iguales entre la comparacion
x=ig*100/n;
a=a+x;
%porcentaje=[[num2str(x)]];

% muestra que porcentaje de elementos es igual entre 2 cadenas o vectores
r1=r1+100;
r2=r2+100;
end
fitness=(fitness+(a/5))/2;

padres(ciclo, 37)=fitness;
end

%imwrite(imagen1,'C:\Users\ivan\Documents\imagen1.bmp');

%display(fitness);
%display(v_fn);
%display(padres);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
display(padres);
generacion=0;

for fitnesssss=1:10;
    display(generacion);
if padres(200,37)>75
    display('%%%%%%%%%%%%%%%%%%%%   75% SETENTA Y CINCO %%%%%%%%%%%%%%%%%%%%%%%%');
end
if padres(200,37)>70
    display('%%%%%%%%%%%%%%%%%%%%      70% SETENTA      %%%%%%%%%%%%%%%%%%%%%%%%');
end
if padres(200,37)>68
    display('%%%%%%%%%%%%%%%%%%%%   68% SESENTA Y OCHO %%%%%%%%%%%%%%%%%%%%%%%%');
end
    display(padres(200,37));

%--------- CREACION DE HIJOS A PARTIR DE PADRES -----------%    
v_prov=zeros(1,36); %vector provicional para aplicar algoritmo de crossover problemente no requiere declararse
hijos=zeros(20000,37); % creamos matriz de 37 C por 20000 R
ZH=0;
for XH=1:200
   for YT=1:100 
       YH=YT+ZH;
       v_prov=padres(XH,1:36);
       
       % ALGORITMO DE CROSSOVER (AQUI)SE TRABAJARA SOBRE v_prob antes de
       % regenerarse como imagen, obtener tu fitness y grabarse en la tabla
       %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       randomcross=randperm(length(cross2));
randomcross=randomcross(1);  
switch randomcross
case 1
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for primero=1:1
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ESTA FUNCION HACE UN
AJ=[1 7 13 19 25 31];
    neworder = randperm(length(AJ));                 % VERDADERO RANDOM DE AJ

for i=1:length(AJ) AJnew(i) = AJ(neworder(i)); 
 end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

swapA=v_prov(AJnew(1));
swapB=v_prov(AJnew(1)+5);
v_prov(AJnew(1))=swapB;
v_prov(AJnew(1)+5)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 2
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for segundo=1:1
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ESTA FUNCION HACE UN
AJ=[1 7 13 19 25 31];
    neworder = randperm(length(AJ));                 % VERDADERO RANDOM DE AJ

for i=1:length(AJ) AJnew(i) = AJ(neworder(i)); 
 end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

swapA=v_prov(AJnew(1));
swapB=v_prov(AJnew(1)+4);
v_prov(AJnew(1))=swapB;
v_prov(AJnew(1)+4)=swapA;
swapA=v_prov(AJnew(1)+1);
swapB=v_prov(AJnew(1)+5);
v_prov(AJnew(1)+1)=swapB;
v_prov(AJnew(1)+5)=swapA;

end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 3
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for tercero=1:1
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ESTA FUNCION HACE UN
AJ=[1 7 13 19 25 31];
    neworder = randperm(length(AJ));                 % VERDADERO RANDOM DE AJ
 for i=1:length(AJ) AJnew(i) = AJ(neworder(i)); 
 end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
swapA=v_prov(AJnew(1));
swapB=v_prov(AJnew(1)+3);
v_prov(AJnew(1))=swapB;
v_prov(AJnew(1)+3)=swapA;
swapA=v_prov(AJnew(1)+1);
swapB=v_prov(AJnew(1)+4);
v_prov(AJnew(1)+1)=swapB;
v_prov(AJnew(1)+4)=swapA;
swapA=v_prov(AJnew(1)+2);
swapB=v_prov(AJnew(1)+5);
v_prov(AJnew(1)+2)=swapB;
v_prov(AJnew(1)+5)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 4
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for cuarto=1:1
c_rr=randperm(length(c_r));
swapA=v_prov(c_rr(1));
swapB=v_prov(c_rr(6));
v_prov(c_rr(1))=swapB;
v_prov(c_rr(6))=swapA;
swapA=v_prov(c_rr(1)+6);
swapB=v_prov(c_rr(6)+6);
v_prov(c_rr(1)+6)=swapB;
v_prov(c_rr(6)+6)=swapA;
swapA=v_prov(c_rr(1)+12);
swapB=v_prov(c_rr(6)+12);
v_prov(c_rr(1)+12)=swapB;
v_prov(c_rr(6)+12)=swapA;
swapA=v_prov(c_rr(1)+18);
swapB=v_prov(c_rr(6)+18);
v_prov(c_rr(1)+18)=swapB;
v_prov(c_rr(6)+18)=swapA;
swapA=v_prov(c_rr(1)+24);
swapB=v_prov(c_rr(6)+24);
v_prov(c_rr(1)+24)=swapB;
v_prov(c_rr(6)+24)=swapA;
swapA=v_prov(c_rr(1)+30);
swapB=v_prov(c_rr(6)+30);
v_prov(c_rr(1)+30)=swapB;
v_prov(c_rr(6)+30)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 5
for quinto=1:1
swapA=v_prov(1);
swapB=v_prov(15);
v_prov(1)=swapB;
v_prov(15)=swapA;
swapA=v_prov(6);
swapB=v_prov(16);
v_prov(6)=swapB;
v_prov(16)=swapA;
swapA=v_prov(21);
swapB=v_prov(31);
v_prov(21)=swapB;
v_prov(31)=swapA;
swapA=v_prov(22);
swapB=v_prov(36);
v_prov(22)=swapB;
v_prov(36)=swapA;
end    
case 6
for sexto=1:1
swapA=v_prov(1);
swapB=v_prov(8);
v_prov(1)=swapB;
v_prov(8)=swapA;
swapA=v_prov(6);
swapB=v_prov(11);
v_prov(6)=swapB;
v_prov(11)=swapA;
swapA=v_prov(26);
swapB=v_prov(31);
v_prov(26)=swapB;
v_prov(31)=swapA;
swapA=v_prov(29);
swapB=v_prov(36);
v_prov(29)=swapB;
v_prov(36)=swapA;
end
case 7
 for septimo=1:1
swapA=v_prov(1);
swapB=v_prov(7);
v_prov(1)=swapB;
v_prov(7)=swapA;
swapA=v_prov(6);
swapB=v_prov(12);
v_prov(6)=swapB;
v_prov(12)=swapA;
swapA=v_prov(25);
swapB=v_prov(31);
v_prov(25)=swapB;
v_prov(31)=swapA;
swapA=v_prov(30);
swapB=v_prov(36);
v_prov(30)=swapB;
v_prov(36)=swapA;
end 
case 8
for octavo=1:1
swapA=v_prov(8);
swapB=v_prov(13);
v_prov(8)=swapB;
v_prov(13)=swapA;
swapA=v_prov(9);
swapB=v_prov(19);
v_prov(9)=swapB;
v_prov(19)=swapA;
swapA=v_prov(18);
swapB=v_prov(28);
v_prov(18)=swapB;
v_prov(28)=swapA;
swapA=v_prov(24);
swapB=v_prov(29);
v_prov(24)=swapB;
v_prov(29)=swapA;
end 
case 9
for noveno=1:1
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ESTA FUNCION HACE UN
AJ=[1 7 13 19 25 31];
    neworder = randperm(length(AJ));                 % VERDADERO RANDOM DE AJ
 for i=1:length(AJ) AJnew(i) = AJ(neworder(i)); 
 end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
swapA=v_prov(AJnew(1));
swapB=v_prov(AJnew(6));
v_prov(AJnew(1))=swapB;
v_prov(AJnew(6))=swapA;
swapA=v_prov(AJnew(1)+1);
swapB=v_prov(AJnew(6)+1);
v_prov(AJnew(1)+1)=swapB;
v_prov(AJnew(6)+1)=swapA;
swapA=v_prov(AJnew(1)+2);
swapB=v_prov(AJnew(6)+2);
v_prov(AJnew(1)+2)=swapB;
v_prov(AJnew(6)+2)=swapA;
swapA=v_prov(AJnew(1)+3);
swapB=v_prov(AJnew(6)+3);
v_prov(AJnew(1)+3)=swapB;
v_prov(AJnew(6)+3)=swapA;
swapA=v_prov(AJnew(1)+4);
swapB=v_prov(AJnew(6)+4);
v_prov(AJnew(1)+4)=swapB;
v_prov(AJnew(6)+4)=swapA;
swapA=v_prov(AJnew(1)+5);
swapB=v_prov(AJnew(6)+5);
v_prov(AJnew(1)+5)=swapB;
v_prov(AJnew(6)+5)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%   
case 10    
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for decimo=1:1
swapA=v_prov(1);
swapB=v_prov(36);
v_prov(1)=swapB;
v_prov(36)=swapA;
swapA=v_prov(8);
swapB=v_prov(29);
v_prov(8)=swapB;
v_prov(29)=swapA;
swapA=v_prov(15);
swapB=v_prov(22);
v_prov(15)=swapB;
v_prov(22)=swapA;
swapA=v_prov(21);
swapB=v_prov(16);
v_prov(21)=swapB;
v_prov(16)=swapA;
swapA=v_prov(26);
swapB=v_prov(11);
v_prov(26)=swapB;
v_prov(11)=swapA;
swapA=v_prov(31);
swapB=v_prov(6);
v_prov(31)=swapB;
v_prov(6)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 11
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for primero=1:1
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ESTA FUNCION HACE UN
AJ=[1 7 13 19 25 31];
    neworder = randperm(length(AJ));                 % VERDADERO RANDOM DE AJ

for i=1:length(AJ) AJnew(i) = AJ(neworder(i)); 
 end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

swapA=v_prov(AJnew(1));
swapB=v_prov(AJnew(1)+5);
v_prov(AJnew(1))=swapB;
v_prov(AJnew(1)+5)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 12
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for segundo=1:1
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ESTA FUNCION HACE UN
AJ=[1 7 13 19 25 31];
    neworder = randperm(length(AJ));                 % VERDADERO RANDOM DE AJ

for i=1:length(AJ) AJnew(i) = AJ(neworder(i)); 
 end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 13
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for tercero=1:1
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ESTA FUNCION HACE UN
AJ=[1 7 13 19 25 31];
    neworder = randperm(length(AJ));                 % VERDADERO RANDOM DE AJ
 for i=1:length(AJ) AJnew(i) = AJ(neworder(i)); 
 end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
swapA=v_prov(AJnew(1));
swapB=v_prov(AJnew(1)+3);
v_prov(AJnew(1))=swapB;
v_prov(AJnew(1)+3)=swapA;
swapA=v_prov(AJnew(1)+1);
swapB=v_prov(AJnew(1)+4);
v_prov(AJnew(1)+1)=swapB;
v_prov(AJnew(1)+4)=swapA;
swapA=v_prov(AJnew(1)+2);
swapB=v_prov(AJnew(1)+5);
v_prov(AJnew(1)+2)=swapB;
v_prov(AJnew(1)+5)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 14
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for cuarto=1:1
c_rr=randperm(length(c_r));
swapA=v_prov(c_rr(1));
swapB=v_prov(c_rr(6));
v_prov(c_rr(1))=swapB;
v_prov(c_rr(6))=swapA;
swapA=v_prov(c_rr(1)+6);
swapB=v_prov(c_rr(6)+6);
v_prov(c_rr(1)+6)=swapB;
v_prov(c_rr(6)+6)=swapA;
swapA=v_prov(c_rr(1)+12);
swapB=v_prov(c_rr(6)+12);
v_prov(c_rr(1)+12)=swapB;
v_prov(c_rr(6)+12)=swapA;
swapA=v_prov(c_rr(1)+18);
swapB=v_prov(c_rr(6)+18);
v_prov(c_rr(1)+18)=swapB;
v_prov(c_rr(6)+18)=swapA;
swapA=v_prov(c_rr(1)+24);
swapB=v_prov(c_rr(6)+24);
v_prov(c_rr(1)+24)=swapB;
v_prov(c_rr(6)+24)=swapA;
swapA=v_prov(c_rr(1)+30);
swapB=v_prov(c_rr(6)+30);
v_prov(c_rr(1)+30)=swapB;
v_prov(c_rr(6)+30)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
case 15
for quinto=1:1
swapA=v_prov(1);
swapB=v_prov(15);
v_prov(1)=swapB;
v_prov(15)=swapA;
swapA=v_prov(6);
swapB=v_prov(16);
v_prov(6)=swapB;
v_prov(16)=swapA;
swapA=v_prov(21);
swapB=v_prov(31);
v_prov(21)=swapB;
v_prov(31)=swapA;
swapA=v_prov(22);
swapB=v_prov(36);
v_prov(22)=swapB;
v_prov(36)=swapA;
end    
case 16
for sexto=1:1
swapA=v_prov(1);
swapB=v_prov(8);
v_prov(1)=swapB;
v_prov(8)=swapA;
swapA=v_prov(6);
swapB=v_prov(11);
v_prov(6)=swapB;
v_prov(11)=swapA;
swapA=v_prov(26);
swapB=v_prov(31);
v_prov(26)=swapB;
v_prov(31)=swapA;
swapA=v_prov(29);
swapB=v_prov(36);
v_prov(29)=swapB;
v_prov(36)=swapA;
end
case 17
     for septimo=1:1
swapA=v_prov(1);
swapB=v_prov(7);
v_prov(1)=swapB;
v_prov(7)=swapA;
swapA=v_prov(6);
swapB=v_prov(12);
v_prov(6)=swapB;
v_prov(12)=swapA;
swapA=v_prov(25);
swapB=v_prov(31);
v_prov(25)=swapB;
v_prov(31)=swapA;
swapA=v_prov(30);
swapB=v_prov(36);
v_prov(30)=swapB;
v_prov(36)=swapA;
end 
case 18
for octavo=1:1
swapA=v_prov(8);
swapB=v_prov(13);
v_prov(8)=swapB;
v_prov(13)=swapA;
swapA=v_prov(9);
swapB=v_prov(19);
v_prov(9)=swapB;
v_prov(19)=swapA;
swapA=v_prov(18);
swapB=v_prov(28);
v_prov(18)=swapB;
v_prov(28)=swapA;
swapA=v_prov(24);
swapB=v_prov(29);
v_prov(24)=swapB;
v_prov(29)=swapA;
end 
case 19
for noveno=1:1
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ESTA FUNCION HACE UN
AJ=[1 7 13 19 25 31];
    neworder = randperm(length(AJ));                 % VERDADERO RANDOM DE AJ
 for i=1:length(AJ) AJnew(i) = AJ(neworder(i)); 
 end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
swapA=v_prov(AJnew(1));
swapB=v_prov(AJnew(6));
v_prov(AJnew(1))=swapB;
v_prov(AJnew(6))=swapA;
swapA=v_prov(AJnew(1)+1);
swapB=v_prov(AJnew(6)+1);
v_prov(AJnew(1)+1)=swapB;
v_prov(AJnew(6)+1)=swapA;
swapA=v_prov(AJnew(1)+2);
swapB=v_prov(AJnew(6)+2);
v_prov(AJnew(1)+2)=swapB;
v_prov(AJnew(6)+2)=swapA;
swapA=v_prov(AJnew(1)+3);
swapB=v_prov(AJnew(6)+3);
v_prov(AJnew(1)+3)=swapB;
v_prov(AJnew(6)+3)=swapA;
swapA=v_prov(AJnew(1)+4);
swapB=v_prov(AJnew(6)+4);
v_prov(AJnew(1)+4)=swapB;
v_prov(AJnew(6)+4)=swapA;
swapA=v_prov(AJnew(1)+5);
swapB=v_prov(AJnew(6)+5);
v_prov(AJnew(1)+5)=swapB;
v_prov(AJnew(6)+5)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%   
case 20    
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
for decimo=1:1
swapA=v_prov(1);
swapB=v_prov(36);
v_prov(1)=swapB;
v_prov(36)=swapA;
swapA=v_prov(8);
swapB=v_prov(29);
v_prov(8)=swapB;
v_prov(29)=swapA;
swapA=v_prov(15);
swapB=v_prov(22);
v_prov(15)=swapB;
v_prov(22)=swapA;
swapA=v_prov(21);
swapB=v_prov(16);
v_prov(21)=swapB;
v_prov(16)=swapA;
swapA=v_prov(26);
swapB=v_prov(11);
v_prov(26)=swapB;
v_prov(11)=swapA;
swapA=v_prov(31);
swapB=v_prov(6);
v_prov(31)=swapB;
v_prov(6)=swapA;
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
end
       
       
       %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
       
       v_fn=[v_prov(1,1) v_prov(1,2) v_prov(1,3) v_prov(1,4) v_prov(1,5) v_prov(1,6);v_prov(1,7) v_prov(1,8) v_prov(1,9) v_prov(1,10) v_prov(1,11) v_prov(1,12);
            v_prov(1,13) v_prov(1,14) v_prov(1,15) v_prov(1,16) v_prov(1,17) v_prov(1,18);v_prov(1,19) v_prov(1,20) v_prov(1,21) v_prov(1,22) v_prov(1,23) v_prov(1,24);
            v_prov(1,25) v_prov(1,26) v_prov(1,27) v_prov(1,28) v_prov(1,29) v_prov(1,30);v_prov(1,31) v_prov(1,32) v_prov(1,33) v_prov(1,34) v_prov(1,35) v_prov(1,36)];
        
 
       
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%       
% TODO ESTO ES LO QUE INTERPRETA LA MATRIZ RANDOM PARA REGENERAR LA IMAGEN
% SEGUN LOS VALORES DE LA MATRIZ
y=1; z=100;
w=1; x=100; u=0;
for valorrn=1:36 
    if y==601
            y=501; z=600;
    end
c=1; d=100;
 a=1; b=100; t=0;       
for pieza=1:36
  
if     v_prov(valorrn)==pieza; % se muestra el primero
        if c==601
            c=501; d=600;
        end
      
        imagen1(w : x, y : z)= f(a : b, c : d); % C & D cambian cada 1 iteracion a razon de 100 y reinician cada 6
   
end                                           % A & B cambian cada 6 iteraciones a razon de 100 y jamaz reinician.
    t=t+1;  c=c+100; d=d+100;
        
       if c>501
            c=1; d=100;
       end
       if t>5
            a=a+100; b=b+100;   t=0;
       end       
end 
u=u+1;  y=y+100; z=z+100;
        
       if y>501
            y=1; z=100;
       end
       if u>5
            w=w+100; x=x+100;   u=0;
       end
       
end

y=0; z=0; w=0; x=0; u=0; c=0; d=0; b=0; t=0;   
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%%%%%%%%%%%%%%%%%%%    FUNCION DE FITNESS       %%%%%%%%%%%%%%%%%%%%%%%%%
r1=100;
r2=101;
a=0;
for v=1:5
AB= imagen1(r1 : r1, 1 :600);
BB= imagen1(r2 : r2, 1 :600);

n=length(AB); % Cual es la longitud del vector?
[cantidad,posicion]=find(AB==BB); % la funcion find te dice que elementos son iguales entre 2 vectores % esta puede funcionar solo con CANTIDAD, posicion es para bidimenciones
ig=length(cantidad); % iguales cantidad de elementos iguales entre la comparacion
x=ig*100/n;
a=a+x;
%porcentaje=[[num2str(x)]];

% muestra que porcentaje de elementos es igual entre 2 cadenas o vectores
r1=r1+100;
r2=r2+100;
end
fitness=a/5;
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
r1=100;
r2=101;
a=0;
for v=1:5
AB= imagen1(1 : 600, r1 :r1);
BB= imagen1(1 : 600, r2 :r2);
b=x;
n=length(AB); % Cual es la longitud del vector?
[cantidad,posicion]=find(AB==BB); % la funcion find te dice que elementos son iguales entre 2 vectores % esta puede funcionar solo con CANTIDAD, posicion es para bidimenciones
ig=length(cantidad); % iguales cantidad de elementos iguales entre la comparacion
x=ig*100/n;
a=a+x;
%porcentaje=[[num2str(x)]];

% muestra que porcentaje de elementos es igual entre 2 cadenas o vectores
r1=r1+100;
r2=r2+100;
end
fitness=(fitness+(a/5))/2;

% if fitness>60
   %    display(fitness); 
   % end

hijos(YH,37)=fitness;
  
hijos(YH,1:36)=v_prov(1:36);
       
     YH=YH-ZH;
       
    
   end
   ZH=ZH+100;
end

hijosordenada=sortrows(hijos,37); % ordena la matriz de hijos(20000*37) en orden de menos a mayor segun el fitness de la columna 37

%% AHORA LOS HIJOS PASARAN A SER LOS NUEVOS PADRES
npadres2=19800;
for npadres=1:200
npadres2=npadres2+1;    
padres(npadres,1:37)=hijosordenada(npadres2,1:37);

end
display(v_fn);
imwrite(imagen1,'C:\Users\ivan\Documents\imagen1.bmp');

generacion=generacion+1;
end
end

Ivan Mendoza

viernes, 21 de noviembre de 2014

Algoritmo Genetico Rompe Cabeza (MATLAB)

No hay comentarios: