Problem with Octave and imnoise (nonconformant arguments (op1 is 11x1, op2 is 9x1))

Question

I have a problem that is complicating my life with octave, I am working with a bee algorithm, to work with it, first I use "imnoise" to add noise to the image, but the problem is that when I add noise, for some reason when trying to perform operations with the original image and the image with noise, it tells me that these images have different sizes.

Noise add

clc;
pkg load image;

I=imread('emigray.jpg');

%I=rgb2gray(I);
sigmaNoise = 0.250;
Inoisy = imnoise(I, "gaussian",0.05);
imwrite(Inoisy,'sucia.jpg');
size(I);
size(Inoisy);
ABCPAR(50,50,0,'emigray.jpg','sucia.jpg');

Before executing the bee algorithm, it calculates the rmse but there is where it throws the error that the images have different sizes.

function [mse, rmse] = RMSE(signal1, signal2)
    originalRowSize = size(signal1,1);
    originalColSize = size(signal1,2);

    originalRowSize
    originalColSize

    size(signal2,1)
    size(signal2,2)

    signal1 = signal1(:);
    signal2 = signal2(:);
    size(signal1)
    size(signal2)
    mse = sum((signal1 - signal2).^2)./(originalRowSize*originalColSize);
    rmse = sqrt(mse);

The error.

error: operator -: nonconformant arguments (op1 is 11x1, op2 is 9x1)
error: called from
    RMSE at line 15 column 9
    ABCPAR at line 52 column 23
    filtro at line 12 column 1

I don't know how to solve it, every thing I try doesn't work, help, thank you very much for your help.

ABCPAR is the bee algorithm and the error is because it uses the value of mse and does not find it, because that is where the error in RMSE was generated.

ABCPAR

function [GlobalOpt, GlobalParams, conv]=ABCPAR(Np, gmax,opti, I, Inoisy)
    O = size(I)
    N = size(Inoisy)
    I
    Inoisy
    if(opti==0)
        GlobalOpt=inf;
    else
        GlobalOpt=0;
    end

    %Inicializo los vectores de par�metros
    vector_numIt=1:100;
    vector_dt=0.1:0.01:0.2;
    vector_k=1:0.5:30;


    
    range=[1 100 1 11 1 59];
    
    
    %Parametros iniciales
    d=3; %dimensiones
    
    %Np=250; %tama�o poblacion
    fuente_comida=round(Np/2); %Fuentes de comida
    limit=5; %criterio de abandono 
    
    Aux=1;
    Rango=zeros(1,3);
    for i=1:d
        Rango(i)=range(1,Aux+1)-range(1,Aux);
        Aux=Aux+2;
    end 
    
    %Poblacion inicial aleatoria
    %Poblacion=(rand(fuente_comida,d)*Rango)+range(1)
    Poblacion=zeros(fuente_comida,d)
    for i=1:d
        Poblacion(:,i)=round((rand(fuente_comida,1)*Rango(i))+1);
    end
    
    %Calcula fitness de la funci�n objetivo para la poblaci�n inicial
    for ii=1:fuente_comida
       
        IFiltrada=difusionAnisotropicaPM(Inoisy, vector_numIt(Poblacion(ii,1)), vector_dt(Poblacion(ii,2)), vector_k(Poblacion(ii,3)));
        variable = 'size 1'
        size(IFiltrada)
        
        if(opti==0)
            ValFit(ii)=RMSE(I,IFiltrada);
            Fitness(ii)=ValFit(ii);
        else
            ValFit(ii)=snr(I,IFiltrada); 
            Fitness(ii)=ValFit(ii);
        end
    end
    
    %inicializar contadores de prueba
    prueba=zeros(1,fuente_comida);
    
    %Se actualiza la fuente donde se encontr� la mejor fuente de comida
    if(opti==0)
        MejorInd=find(ValFit==min(ValFit));
    else
        MejorInd=find(ValFit==max(ValFit));   
    end
    
    MejorInd=MejorInd(end);
    GlobalOpt=ValFit(MejorInd);
    GlobalParams=Poblacion(MejorInd,:); %Se refiere a la Ubicaci�n del mejor individuo
    g=1;   %contador de generaciones
    
    while((g<=gmax))
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        %%%%%%%%%%Fase de abeja obrera%%%%%%%%%%%%
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        for i=1:fuente_comida
            %Parametro a modificar determinado aleatoriamente
            Param2Change=fix(rand*d)+1;
            %Se utiliza una solucion aleatoria para producir una nueva solucion mutante, ambas deben ser diferentes
            vecino=fix(rand*(fuente_comida))+1;
            %Por si justo el vecino es el mismo
            while(vecino==i)
                vecino=fix(rand*(fuente_comida))+1;
            end
            soluciones=Poblacion(i,:);
            %es aplicado: v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij})
            soluciones(Param2Change)=round(Poblacion(i,Param2Change)+(Poblacion(i,Param2Change)-Poblacion(vecino,Param2Change))*(rand-0.5)*2);
            
            if(soluciones(Param2Change)<1)
                soluciones(Param2Change)=1;
            end
            if(soluciones(Param2Change)>range(2*Param2Change))
                soluciones(Param2Change)=range(2*Param2Change);
            end
            
            IFiltrada=difusionAnisotropicaPM(Inoisy, vector_numIt(soluciones(1)), vector_dt(soluciones(2)), vector_k(soluciones(3)));
            variable = 'size 2'
            size(IFiltrada)
            if(opti==0)
                ValFitSol=RMSE(I,IFiltrada);
                FitnessSol=ValFit(ii);
            else
                ValFitSol=snr(I,IFiltrada); 
                FitnessSol=ValFit(ii);
            end
                     
            %Se aplica un criterio de selecci�n Greedy entre la solucion
            %actual y la producida(mutante), se conserva la mejor entre ellas
            if(opti==0)
                if(FitnessSol<Fitness(i))
                    Poblacion(i,:)=soluciones;
                    Fitness(i)=FitnessSol;
                    ValFit(i)=ValFitSol;
                    prueba(i)=0;
                else
                    prueba(i)=prueba(i)+1;   %se incrementa el contador de prueba
                end
            else
                if(FitnessSol>Fitness(i))
                    Poblacion(i,:)=soluciones;
                    Fitness(i)=FitnessSol;
                    ValFit(i)=ValFitSol;
                    prueba(i)=0;
                else
                    prueba(i)=prueba(i)+1;   %se incrementa el contador de prueba
                end
            end     
        end
        
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        %%%%%%%Fin fase Abeja obrera%%%%%%%%
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        
        %se calculan probabilidades utilizando los valores de fitness normalizados
        probab=(0.9.*Fitness./max(Fitness))+0.1;
        
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        %%%%%%Fase de abeja observadora%%%%%%%
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        i=1;
        t=0;
        while t<fuente_comida
            %Las abejas observadoras ver�n la danza de las obreras y eligiran una buena fuente
            if rand<probab(i)
                t=t+1;
                
                %el parametro a modificar se selecciona aleatoriamente
                Param2Change=fix(rand*d)+1;
                %es utilizada una solucion aleatoria para producr una nueva solucion caldidato, deber�n ser diferentes entre si
                while(vecino==i)
                    vecino=fix(rand*(fuente_comida))+1;
                end
                soluciones=Poblacion(i,:);
                
                %Se aplica: v_{ij}=x_{ij}+\phi_{ij}*{kj}-x_{ij})
                soluciones(Param2Change)=round(Poblacion(i,Param2Change)+(Poblacion(i,Param2Change)-Poblacion(vecino,Param2Change))*(rand-0.5)*2);
                
                %Si el parametro generado est� fuera de los limites, es llevado al limite m�s proximo
                if(soluciones(Param2Change)<1)
                    soluciones(Param2Change)=1;
                end
                if(soluciones(Param2Change)>range(2*Param2Change))
                    soluciones(Param2Change)=range(2*Param2Change);
                end
           
                IFiltrada=difusionAnisotropicaPM(Inoisy, vector_numIt(soluciones(1)), vector_dt(soluciones(2)), vector_k(soluciones(3)));
                variable = 'size 3'
                size(IFiltrada)
                
                if(opti==0)
                    ValFitSol=RMSE(I,IFiltrada);
                    FitnessSol=ValFit(ii);
                else
                    ValFitSol=snr(I,IFiltrada);
                    FitnessSol=ValFit(ii);
                end
                
                %Se aplica un criterio de selecci�n Greedy entre la solucion
                %actual y la producida(mutante), se conserva la mejor entre ellas
                if(opti==0)
                    if(FitnessSol<Fitness(i))
                        Poblacion(i,:)=soluciones;
                        Fitness(i)=FitnessSol;
                        ValFit(i)=ValFitSol;
                        prueba(i)=0;
                    else
                        prueba(i)=prueba(i)+1;   %se incrementa el contador de prueba
                    end
                else
                    if(FitnessSol>Fitness(i))
                        Poblacion(i,:)=soluciones;
                        Fitness(i)=FitnessSol;
                        ValFit(i)=ValFitSol;
                        prueba(i)=0;
                    else
                        prueba(i)=prueba(i)+1;   %se incrementa el contador de prueba
                    end
                end
            end
            i=i+1;
            %Si supera la cantidad de fuentes de comida vuelve a empezar
            if (i==(fuente_comida)+1)
                i=1;
            end
        end
        
        if(opti==0)
            %Se incrementa la mejor fuente de comida
            ind=find(ValFit==min(ValFit));
            ind=ind(end);
            if (ValFit(ind)<GlobalOpt)
                GlobalOpt=ValFit(ind);
                GlobalParams=Poblacion(ind,:);
            end
        else
            %Se incrementa la mejor fuente de comida
            ind=find(ValFit==max(ValFit));
            ind=ind(end);
            if (ValFit(ind)>GlobalOpt)
                GlobalOpt=ValFit(ind);
                GlobalParams=Poblacion(ind,:);
            end 
        end 
        
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        %Fin de la fase de la abeja observadora%
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%       
        
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        %Fase de la abeja exploradora%
        %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
        
        %if(opti==0)
        
        %else
            
        %end   
        
        %se determinan las fuentes de comida cuyo valor de l�mite es alcanzado
        ind=find(prueba==max(prueba));
        ind=ind(end);
        if(prueba(ind)>limit)
            prueba(ind)=0;
            
            soluciones=zeros(1,d);
            for i=1:d
                soluciones(i)=round((Rango(i)).*rand(1,1)+1);
            end

            if(opti==0)
                IFiltrada=difusionAnisotropicaPM(Inoisy, vector_numIt(soluciones(1)), vector_dt(soluciones(2)), vector_k(soluciones(3)));
                variable = 'size 4'
                size(IFiltrada)
                ValFitSol=RMSE(I,IFiltrada);
                FitnessSol=ValFit(ii);                
            else
                IFiltrada=difusionAnisotropicaPM(Inoisy, vector_numIt(soluciones(1)), vector_dt(soluciones(2)), vector_k(soluciones(3)));
                variable = 'size 5'
                size(IFiltrada)
                ValFitSol=snr(I,IFiltrada);
                FitnessSol=ValFit(ii);
            end    
            
            Poblacion(ind,:)=soluciones;
            Fitness(ind)=FitnessSol;
            ValFit(ind)=ValFitSol;
        end
        conv(g)=GlobalOpt
        Poblacion
        
        g=g+1;  %se incrementa la iteracion
        %clc
        
        %se despliegan la posicion y fitness del mejor individuo
        %disp(g)
        %disp(GlobalOpt)
        %disp(GlobalParams)
        
    end
    return;
end

difusionAnisotropicaPM

function Ifiltrada = difusionAnisotropicaPM(Inoisy, numIt, dt, k)
    Ifiltrada = double(Inoisy);
    [xDim, yDim] = size(Ifiltrada);
    in = [1 1:xDim-1];
    is = [2:xDim xDim];
    ie = [1 1:yDim-1];
    io = [2:yDim yDim];
    for it = 1: numIt
        gn = Ifiltrada(in,:) - Ifiltrada;
        gs = Ifiltrada(is,:) - Ifiltrada;
        ge = Ifiltrada(:,ie) - Ifiltrada;
        go = Ifiltrada(:,io) - Ifiltrada;

        cn = lorenciana(gn,k);
        cs = lorenciana(gs,k);
        ce = lorenciana(ge,k);
        co = lorenciana(go,k);
        Ifiltrada = Ifiltrada + dt.*(gn.*cn + gs.*cs + ge.*ce + go.*co);
    end
    Ifiltrada = uint8(Ifiltrada);
end

function g = lorenciana(grad,k)
    g = 1./(1+ (grad./k).^2);
end

snr

function v = snr(x,y)
    x = double(x);
    y = double(y);
    % snr - signal to noise ratio
    %
    %   v = snr(x,y);
    %
    % v = 20*log10( norm(x(:)) / norm(x(:)-y(:)) )
    %
    %   x is the original clean signal (reference).
    %   y is the denoised signal.
    % 
    %   Copyright (c) 2008 Gabriel Peyre
    v = 20.*log10(norm(x(:))./norm(x(:)-y(:)));

Sizes output

O =

    1   11

N =

   1   9

I = emigray.jpg
Inoisy = sucia.jpg
Poblacion =

   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0
   0   0   0

variable = size 1
ans =

   1   9

originalRowSize = 1
originalColSize = 11
ans = 1
ans = 9
ans =

   11    1

ans =

   9   1

error: operator -: nonconformant arguments (op1 is 11x1, op2 is 9x1)
error: called from
    RMSE at line 15 column 9
    ABCPAR at line 52 column 23
    filtro at line 12 column 1

Answer 1

You need to call ABCPAR as follows:

ABCPAR(50,50,0,I,Inoisy);

You pass in file names, but this function does not expect file names, it expects arrays. So it uses the names as if they were data, hence the sizes of 1x9 and 1x11, which correspond to the sizes of the file names.