Home > PR > regu_operador.m

regu_operador

PURPOSE ^

function [rest]=regu_operador(Imobservada,b,lambdas,N,M,F,criterio_lambda,pinta);

SYNOPSIS ^

function [restaurada,objetoparaoverlapping]=regu_operador(Imobservada,b,lambdas,N,M,F,criterio_lambda,pinta,varargin);

DESCRIPTION ^

 function [rest]=regu_operador(Imobservada,b,lambdas,N,M,F,criterio_lambda,pinta);

   Dada una imagen observada que ha pasado por un proceso de degradación  representado
   por K y a la que se ha añadido ruido, se intenta regularizar usando el operador
   de penalización F y parámetros de regularización lambdas. N es el tamaño del bloque
   y M es el tamaño del bloque más un borde, esto se hace para que los efectos de borde
   no se vean en la solución. 
   Se devuelve tambien la imagen con los bloques sin procesar para hacer el overlapping

      
      EJEMPLO                                                                        
                                                                                     
      N=16;                                                                          
      M=44;                                                                          
                                                                                     
      Nlambdas=70;                                                                   
                                                                                     
      lambdas=logspace(-2,2,Nlambdas);                                               
                                                                                     
                                                                                     
      operador=fft2(filt2dsegder,M,M);                                               
                                                                                     
      figure,[Irest]=regu_operador(BlurredNoisy,PSF,lambdas,N,M,operador,criterio_lambda,pinta);

CROSS-REFERENCE INFORMATION ^

This function calls: This function is called by:

SOURCE CODE ^

0001 % function [rest]=regu_operador(Imobservada,b,lambdas,N,M,F,criterio_lambda,pinta);
0002 %
0003 %   Dada una imagen observada que ha pasado por un proceso de degradación  representado
0004 %   por K y a la que se ha añadido ruido, se intenta regularizar usando el operador
0005 %   de penalización F y parámetros de regularización lambdas. N es el tamaño del bloque
0006 %   y M es el tamaño del bloque más un borde, esto se hace para que los efectos de borde
0007 %   no se vean en la solución.
0008 %   Se devuelve tambien la imagen con los bloques sin procesar para hacer el overlapping
0009 %
0010 %
0011 %      EJEMPLO
0012 %
0013 %      N=16;
0014 %      M=44;
0015 %
0016 %      Nlambdas=70;
0017 %
0018 %      lambdas=logspace(-2,2,Nlambdas);
0019 %
0020 %
0021 %      operador=fft2(filt2dsegder,M,M);
0022 %
0023 %      figure,[Irest]=regu_operador(BlurredNoisy,PSF,lambdas,N,M,operador,criterio_lambda,pinta);
0024 %
0025 
0026 
0027 function [restaurada,objetoparaoverlapping]=regu_operador(Imobservada,b,lambdas,N,M,F,criterio_lambda,pinta,varargin);
0028 
0029 
0030 sinruido=wiener2(Imobservada,[3 3]);
0031 
0032 noiseest = mean(var(sinruido-Imobservada));
0033 
0034 normaruido = sqrt(noiseest)*M;
0035 
0036 
0037 
0038 [fil,col]=size(Imobservada);
0039 
0040 restaurada=rand([fil,col]); 
0041 
0042 nver = fil/N;
0043 nhor = col/N;
0044 
0045 objetoparaoverlapping = rand(nver*M,nhor*M);
0046 
0047 
0048 a=(M-N)/2;
0049 
0050 Im2=ampliaconborde(Imobservada,a);
0051  
0052 nlamb=length(lambdas);
0053 
0054 
0055 %lambdasoptimas=restaurada;
0056 
0057 % El operador de blurring en Fourier
0058 
0059 B=freqz2(b,M,M);
0060 
0061 B=ifftshift(B);
0062 
0063 
0064 
0065 %Im3 = ampliaconborde(Imoriginal,a);
0066 
0067 
0068 contadorfilas=0; 
0069 
0070 %% Estimación del parametro de regularizacion
0071 
0072 %Nbloques = 20;
0073 %
0074 %filas = round(N/2 + rand(Nbloques,1)*(fil-N));
0075 %columnas = round(N/2 + rand(Nbloques,1)*(col-N));
0076 %
0077 %lamb = 0;
0078 %
0079 %for i=1:Nbloques
0080 %
0081 %      observado=Im2(filas(i)+a-M/2+1:filas(i)+a+M/2,columnas(i)+a-M/2+1:columnas(i)+a+M/2);
0082 %
0083 %      [sol,lambda]=restaura_bloque(observado,B,F,M,N,lambdas,2);
0084 %
0085 %      lamb = lamb + lambda;
0086 %end
0087 %
0088 %lamb = lamb / Nbloques;
0089 
0090 %% Fin estimación del parametro de regularizacion
0091  
0092 
0093 if (nargin==8)
0094    
0095    for i=N/2:N:fil
0096       %fprintf('\nFila %d : ',i)
0097       contadorfilas = contadorfilas+1;
0098       contadorcolumnas = 0;
0099    
0100       for j=N/2:N:col
0101          %fprintf('%d, ',j)
0102       
0103          contadorcolumnas = contadorcolumnas + 1;
0104     
0105       
0106          observado=Im2(i+a-M/2+1:i+a+M/2,j+a-M/2+1:j+a+M/2);
0107          
0108         % bloqueor=Im3(i+a-M/2+1:i+a+M/2,j+a-M/2+1:j+a+M/2);
0109               
0110    
0111          
0112          [sol]=restaura_bloque(observado,B,F,M,N,lambdas,criterio_lambda);
0113          
0114     
0115          restaurada(i-N/2+1:i+N/2,j-N/2+1:j+N/2)=sol(a+1:a+N,a+1:a+N);
0116          
0117          if (pinta==1)
0118             imshow(restaurada,[0 256],'notruesize'),pause(0.2);
0119          end
0120               
0121          %lambdasoptimas(i-N/2+1:i+N/2,j-N/2+1:j+N/2)=lcurva.corner;
0122          
0123          objetoparaoverlapping((contadorfilas-1)*M+1:contadorfilas*M,(contadorcolumnas-1)*M+1:contadorcolumnas*M) = sol;
0124           
0125       end
0126    end
0127    
0128    restaurada = do_overlap(objetoparaoverlapping,M,N,8);
0129     
0130 
0131 else
0132    centro = varargin{1};
0133    
0134    i = centro(1);
0135    j=centro(2);
0136    
0137    observado=Im2(i+a-M/2+1:i+a+M/2,j+a-M/2+1:j+a+M/2);
0138          
0139    % bloqueor=Im3(i+a-M/2+1:i+a+M/2,j+a-M/2+1:j+a+M/2);
0140                           
0141    [sol]=restaura_bloque(observado,B,F,M,N,lambdas,criterio_lambda);
0142    
0143    restaurada = sol;
0144 end
0145    
0146    
0147  
0148  
0149

Generated on Wed 29-Nov-2006 16:19:19 by m2html © 2003