Eliminación de ruido usando el filtro Median en C++

El filtrado de mediana es un proceso no lineal útil para reducir el ruido impulsivo o de sal y pimienta. El filtro mediano también se usa para preservar las propiedades de los bordes mientras se reduce el ruido. Además, las técnicas de suavizado, como el desenfoque gaussiano, también se utilizan para reducir el ruido, pero no pueden preservar las propiedades de los bordes. El filtro mediano se usa ampliamente en el procesamiento de imágenes digitales porque conserva las propiedades de los bordes.

Acercarse : 

  • Almacene los valores de píxeles de la imagen de entrada en una array.
  • Para cada valor de píxel, almacene todo el valor de píxel vecino, incluida esa celda, en una nueva array (llamada ventana).
  • Ordenar la array de ventanas.
  • La mediana de la array de ventanas se utiliza para almacenar la intensidad de píxeles de la imagen de salida.

Problemas de límites Ejemplo: Ejemplo 
de filtrado de la mediana 2D utilizando una ventana de muestreo de 3 x 3: 
Ampliación de los valores del borde hacia el exterior con valores en el límite.  

Conservación de bordes: 
todas las técnicas de suavizado se utilizan para eliminar el ruido. El filtro mediano también es un tipo de técnica de suavizado como el filtro gaussiano, pero la única diferencia entre el filtro mediano y el filtro gaussiano es que el filtro mediano conserva la propiedad del borde mientras que el filtro gaussiano no. La preservación de los bordes es una propiedad importante porque los bordes son importantes para la apariencia visual. Para la propiedad de preservación de bordes, el filtro mediano se usa ampliamente en el procesamiento de imágenes digitales. 

Implementación en C++ del algoritmo de filtro mediano. 

C++

#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;
 
/* Function to sort an array using insertion sort*/
void insertionSort(int arr[], int n)
{
    int i, key, j;
    for (i = 1; i < n; i++)
    {
        key = arr[i];
        j = i - 1;
 
        /* Move elements of arr[0..i-1], that are
        greater than key, to one position ahead
        of their current position */
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}
 
int array[2000][2000];
int arr[2000][2000];
int main()
{
    int window[9],row = 0, col = 0, numrows = 0, numcols = 0,MAX=0;
    ifstream infile("Saltpepper.pgm");
    stringstream ss;
    string inputLine = "";
 
    // First line : version
    getline(infile,inputLine);
    if(inputLine.compare("P2") != 0) cerr << "Version error" << endl;
    else cout << "Version : " << inputLine << endl;
 
    // Continue with a stringstream
    ss << infile.rdbuf();
 
    // Secondline : size of image
    ss >> numcols >> numrows >> MAX;
 
    //print total number of rows, columns and maximum intensity of image
    cout << numcols << " columns and " << numrows << " rows" <<endl<<"
    Maximum Intensity "<< MAX <<endl;
 
 
    //Initialize a new array of same size of image with 0
    for(row = 0; row <= numrows; ++row)
        array[row][0]=0;
    for( col = 0; col<=numcols; ++col )
        array[0][col]=0;
 
    // Following lines : data
    for(row = 1; row <= numrows; ++row)
    {
        for (col = 1; col <= numcols; ++col)
        {
            //original data store in new array
            ss >> array[row][col];
        }
    }
 
 
    // Now print the array to see the result
    for(row = 1; row <= numrows; ++row)
    {
        for(col = 1; col <= numcols; ++col)
        {
            //neighbor pixel values are stored in window including this pixel
            window[0] = array[row-1][col-1];
            window[1] = array[row-1][col];
            window[2] = array[row-1][col+1];
            window[3] = array[row][col-1];
            window[4] = array[row][col];
            window[5] = array[row][col+1];
            window[6] = array[row+1][col-1];
            window[7] = array[row+1][col];
            window[8] = array[row+1][col+1];
 
            //sort window array
            insertionSort(window,9);
            //put the median to the new array
            arr[row][col]=window[4];   
        }
    }
 
    ofstream outfile;
     
    //new file open to store the output image
    outfile.open("Medianfilter.pnm");
    outfile<<"P2"<<endl;
    outfile<<numcols<<" "<<numrows<<endl;
    outfile<<"255"<<endl;
     
    for(row = 1; row <= numrows; ++row)
    {
        for (col = 1; col <= numcols; ++col)
        {
            //store resultant pixel values to the output file
            outfile << arr[row][col]<<" ";
        }
    }
     
    outfile.close();
    infile.close();
    return 0 ;
}

Imagen de entrada 

Imagen de salida 

Publicación traducida automáticamente

Artículo escrito por Avik_Dutta y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *