El modelo RGB en el que se añaden luces rojas, verdes y azules en diferentes intensidades y permutaciones y combinaciones de ellas que producen una amplia gama de colores, mientras que la escala de grises se refiere a los colores blanco y negro solo donde la intensidad más débil da origen al color negro y la más fuerte como blanco puro. Las imágenes en escala de grises, una especie de monocromo en blanco y negro o gris, se componen exclusivamente de tonos de gris. El contraste va desde el negro en la intensidad más débil hasta el blanco en la más fuerte.
Acercarse:
Para alcanzar el objetivo, es probable que el enfoque trate la imagen como una array multidimensional donde cada elemento es equivalente a un píxel. Ahora simplemente iteramos sobre cada píxel. Además, iterar sobre cada píxel y calcular los colores de la escala de grises RGB y ajustarlos a la escala de grises.
Procedimiento:
Usaremos algunos métodos integrados de la clase BufferedImage. Clases requeridas para realizar la operación:
- Para leer y escribir un archivo de imagen tenemos que importar la clase File. Esta clase representa nombres de rutas de archivos y directorios en general.
import java.io.File ;
- Para manejar errores usamos la clase IOException
import java.io.IOException ;
- Para contener la imagen, creamos el objeto BufferedImage para eso usamos la clase BufferedImage. Este objeto se utiliza para almacenar una imagen en la RAM.
import java.awt.image.BufferedImage ;
- Para realizar la operación de lectura y escritura de la imagen , importaremos la clase ImageIO. Esta clase tiene métodos estáticos para leer y escribir una imagen.
import javax.imageio.ImageIO;
Implementación:
Ejemplo
Java
// Java Program to Create Grayscale Image
// implementation to Blurr RGB image
// Importing required libraries
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
// Main class
public class GFG {
// Main driver method
public static void main(String[] args)
throws IOException, InterruptedException
{
// Declaring an array to hold color spectrum
Color color[];
// Reading the image in the form of file
// from the directory
File fin = new File("D:/test/Image.jpeg");
// Convert file into image form by
// creating object of BufferedImage class
BufferedImage input = ImageIO.read(fin);
// Now creating output Image
BufferedImage output = new BufferedImage(
input.getWidth(), input.getHeight(),
BufferedImage.TYPE_INT_RGB);
// Setting attributes to image
int i = 0;
int max = 400, rad = 10;
int a1 = 0, r1 = 0, g1 = 0, b1 = 0;
color = new Color[max];
// core section responsible for blurring of image
int x = 1, y = 1, x1, y1, ex = 5, d = 0;
// Running loop for each pixel and blurring it
// Nested for loops
for (x = rad; x < input.getHeight() - rad; x++) {
for (y = rad; y < input.getWidth() - rad; y++) {
for (x1 = x - rad; x1 < x + rad; x1++) {
for (y1 = y - rad; y1 < y + rad; y1++) {
color[i++] = new Color(
input.getRGB(y1, x1));
}
}
// Smoothing colors of image to
// get grayscaled corresponding image
i = 0;
for (d = 0; d < max; d++) {
a1 = a1 + color[d].getAlpha();
}
a1 = a1 / (max);
for (d = 0; d < max; d++) {
r1 = r1 + color[d].getRed();
}
r1 = r1 / (max);
for (d = 0; d < max; d++) {
g1 = g1 + color[d].getGreen();
}
g1 = g1 / (max);
for (d = 0; d < max; d++) {
b1 = b1 + color[d].getBlue();
}
b1 = b1 / (max);
int sum1 = (a1 << 24) + (r1 << 16)
+ (g1 << 8) + b1;
output.setRGB(y, x, (int)(sum1));
}
}
// Finally writing the blurred image on the disc
// specifying type and location
// to be written on machine
ImageIO.write(
output, "jpeg",
new File("D:/test/BlurredImage.jpeg"));
// Display message for successful execution of
// program
System.out.println("Image blurred successfully !");
}
}
Producción:
Image blurred successfully !
También se demuestra una representación visual en la que, después de ejecutar el programa, la consola aparecerá con una compilación y ejecución exitosas del programa, lo que conducirá a una escala de grises de la imagen, como se muestra a continuación.
