Procesamiento de imágenes en Java: comparación de dos imágenes

requisitos previos:

Nota: la imagen debe ser de la misma dimensión 

Algoritmo:

  1. Compruebe si las dimensiones de ambas imágenes coinciden.
  2. Obtenga los valores RGB de ambas imágenes.
  3. Calcule la diferencia en dos píxeles correspondientes de tres componentes de color.
  4. Repita los pasos 2 y 3 para cada píxel de las imágenes.
  5. Por último, calcula el porcentaje dividiendo la suma de las diferencias por el número de píxeles.

Para obtener la diferencia promedio por píxel 3, para obtener la diferencia promedio por componente de color 255, para obtener un valor entre 0,0 y 1,0 que se puede convertir en un valor porcentual.

Implementación: hemos mostrado las imágenes de entrada a continuación junto con la salida para percibir la comparación e ilustrar las diferencias entre ellas.

Java

// Java Program to Compare Two Images Using OpenCV
// Via printing Difference Percentage
  
// Importing required classes
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
  
// Main class
// ImageComparison
class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Initially assigning null
        BufferedImage imgA = null;
        BufferedImage imgB = null;
  
        // Try block to check for exception
        try {
  
            // Reading file from local directory by
            // creating object of File class
            File fileA
                = new File("/home / pratik /"
                           + " Desktop / image1.jpg");
            File fileB
                = new File("/home / pratik /"
                           + " Desktop / image2.jpg");
  
            // Reading files
            imgA = ImageIO.read(fileA);
            imgB = ImageIO.read(fileB);
        }
  
        // Catch block to check for exceptions
        catch (IOException e) {
            // Display the exceptions on console
            System.out.println(e);
        }
  
        // Assigning dimensions to image
        int width1 = imgA.getWidth();
        int width2 = imgB.getWidth();
        int height1 = imgA.getHeight();
        int height2 = imgB.getHeight();
  
        // Checking whether the images are of same size or
        // not
        if ((width1 != width2) || (height1 != height2))
  
            // Display message straightaway
            System.out.println("Error: Images dimensions"
                               + " mismatch");
        else {
  
            // By now, images are of same size
  
            long difference = 0;
  
            // treating images likely 2D matrix
  
            // Outer loop for rows(height)
            for (int y = 0; y < height1; y++) {
  
                // Inner loop for columns(width)
                for (int x = 0; x < width1; x++) {
  
                    int rgbA = imgA.getRGB(x, y);
                    int rgbB = imgB.getRGB(x, y);
                    int redA = (rgbA >> 16) & 0xff;
                    int greenA = (rgbA >> 8) & 0xff;
                    int blueA = (rgbA)&0xff;
                    int redB = (rgbB >> 16) & 0xff;
                    int greenB = (rgbB >> 8) & 0xff;
                    int blueB = (rgbB)&0xff;
  
                    difference += Math.abs(redA - redB);
                    difference += Math.abs(greenA - greenB);
                    difference += Math.abs(blueA - blueB);
                }
            }
  
            // Total number of red pixels = width * height
            // Total number of blue pixels = width * height
            // Total number of green pixels = width * height
            // So total number of pixels = width * height *
            // 3
            double total_pixels = width1 * height1 * 3;
  
            // Normalizing the value of different pixels
            // for accuracy
  
            // Note: Average pixels per color component
            double avg_different_pixels
                = difference / total_pixels;
  
            // There are 255 values of pixels in total
            double percentage
                = (avg_different_pixels / 255) * 100;
  
            // Lastly print the difference percentage
            System.out.println("Difference Percentage-->"
                               + percentage);
        }
    }
}

Salida:
Caso de uso 1: Imágenes de entrada

Salida: Porcentaje de diferencia–>2.843600130405922

Caso de uso 2: imágenes de entrada

Salida: Porcentaje de diferencia–>6.471412648669786

Caso de uso 3: imágenes de entrada

Salida: Porcentaje de diferencia–>0.0

Este artículo es una contribución de Pratik Agarwal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 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 *