ARCHIVO QUE PROCESA LA INFORMACION

IMAGEN.JAVA
//Definimos en que paquete buscaremos la clase requerida mas adelante
package tutorialredim;

//Importamos las bibliotecas requeridas para el procesamiento de imagenes y

archivos
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class TutorialRedim {

//se define el metodo principal
public static void main(String[] args) throws IOException {
//Introducimos la imagen dentro de la clase Imagen del archivo Imagen.java
que sera el input
Imagen obj = new Imagen("entrada.jpg");
obj.binarizarImagen(100);
//Cuando se crea la imagen temporal dentro de las subclases del archivo
Imagen.java
//llamamos al objeto imprimirImagen para poder generar el output
BufferedImage img = obj.imprimirImagen();
//Una vez que se realiza el proceso escribimos la imagen en un nuevo
archivo "img"
ImageIO.write(img, "jpg", new File("Escala de verde.jpg"));

ARCHIVO QUE REALIZA LA CONVERSION

TUTORIALREDIM.JAVA
//Se verifica de que paquete pertenece la clase, en este caso de tutorialredim.
package tutorialredim;
//importamos las bibliotecas correspondientes
//Contiene clases para crear una aplicaci?n GUI independiente de la plataforma
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
//Entrada y Salida. Clases que definen distintos flujos de datos
import java.io.File;
import java.io.IOException;
//Contiene otras clases utiles que ayudan al programador
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.imageio.ImageIO;
//Para crear una clase se utiliza la palabra reservada class y a continuaci?n el
nombre de la clase.
//La definici?n de la clase se pone entre las llaves de apertura y cierre.
//El nombre de la clase empieza por letra may?scula
public class Imagen {
//definimos en numeros enteros las dimensiones de la imagen
public static final int anchoPermitido=1024;
public static final int altoPermitido=720;
//declaramos un arreglo que maneje el color
private Color arreglo[][];
//declaramos variables que nos permitan hacer comparativos de alto y ancho
private int ancho;
private int alto;
//Asignamos valores al arreglo
public Imagen(String archivo) {
arreglo = new Color[anchoPermitido][anchoPermitido];
cargarImagen(archivo);
}
//
public void cargarImagen(String archivo){
BufferedImage bf=null;
//verificamos el origen de la imagen
try {
bf = ImageIO.read(new File(archivo));
} catch (IOException ex) {
Logger.getLogger(Imagen.class.getName()).log(Level.SEVERE, null, ex);
}
//comprobamos tama?os y si estos exeden se asignan predeterminados ya
mencionados
if (bf.getWidth()<anchoPermitido) {
ancho=bf.getWidth();
}else
ancho=anchoPermitido;
if (bf.getHeight()<altoPermitido) {
alto=bf.getHeight();
}else
alto=altoPermitido;
//Obtenemos pixeles y color RGB
int cont=0;
for (int i = 0; i < alto; i++) {
for (int j = 0; j < ancho; j++) {
cont++;
arreglo[i][j]= new Color(bf.getRGB(j, i));
}
}
}
public BufferedImage redimensionar(String archivo, double porcentaje ){
BufferedImage bf = null;
try {
bf = ImageIO.read(new File(archivo));
} catch (IOException ex) {
Logger.getLogger(Imagen.class.getName()).log(Level.SEVERE, null, ex);
 }
//Obtenemos los tama?o de la imagen y se asignan valores a las variables
antes mencionadas
int ancho = bf.getWidth();
int alto = bf.getHeight();
int escalaAncho = (int)(porcentaje* ancho);
int escalaAlto = (int)(porcentaje*alto);
//Se crea la imagen temporal para trabajar
BufferedImage bufim = new BufferedImage(escalaAncho, escalaAlto,
bf.getType());
Graphics2D g = bufim.createGraphics();

g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,RenderingHints.VALUE_INTERPOLAT
ION_BILINEAR);
g.drawImage(bf, 0,0, escalaAncho,escalaAlto, 0,0,ancho,alto, null);
g.dispose();
return bufim;
}
//Se realizan las formulas correspondientes para determinar los colores RGB
public void binarizarImagen(double umbral){
for (int i = 0; i < alto; i++) {
for (int j = 0; j < ancho; j++) {
Color pix= arreglo[i][j];
//se declara la variable promedio y obtiene RGB para asignar
colores solidos segun el caso
int promedio =(pix.getBlue()+pix.getRed()+pix.getGreen())/3;
if (promedio<umbral)
arreglo[i][j]=Color.green;
else
arreglo[i][j] = Color.WHITE;
}
}
}
public BufferedImage imprimirImagen(){
// Creamos la imagen para dibujar en ella y las variables para determinar
el tama?o
BufferedImage salida = new BufferedImage(ancho, alto,
BufferedImage.TYPE_INT_RGB);
//de binarizarImagen se asigna los colores para procesar el output segun
tama?o de imagen y
//pixeles definidos en arreglo
for (int i = 0; i < alto; i++) {
for (int j = 0; j < ancho; j++) {
salida.setRGB(j, i, arreglo[i][j].getRGB());
}
}
//Retornamos el resultado de "Salida" y este sera usado en
"TutorialRedim.java"
return salida;
}
}