public class ProcesamientoImagen { JFileChooser selector = new JFileChooser();

private int r, g, b; //Le damos un título

private Color color;
int umbral = 127;//
int gNiveles[];
double gProb[], gProbAc[];
double fijmax, fijmin, max = 255, min = 0;
int totalElementosNiveles;
//Imagen actual que se ha cargado
private BufferedImage imageActual;
private BufferedImage imageReal;
public BufferedImage getImageActual() {
return imageActual;
} File imagenSeleccionada =
public void setImageActual(BufferedImage
imageActual) {
this.imageActual = imageActual;
selector.setDialogTitle("Seleccione una imagen");
//Filtramos los tipos de archivos
FileNameExtensionFilter filtroImagen = new
FileNameExtensionFilter("JPG & GIF & BMP", "jpg",
"gif", "bmp");
selector.setFileFilter(filtroImagen);
//Abrimos el cuadro de diálog
int flag = selector.showOpenDialog(null);
//Comprobamos que pulse en aceptar
if (flag == JFileChooser.APPROVE_OPTION) {
try {
//Devuelve el fichero seleccionado
selector.getSelectedFile();
//Asignamos a la variable bmp la imagen
leida

} bmp = ImageIO.read(imagenSeleccionada);

public BufferedImage getImageReal() { } catch (Exception e) {

return imageReal; }

} }

public void setImageReal(BufferedImage imageReal) //Asignamos la imagen cargada a la propiedad

{ imageActual

this.imageReal = imageReal; imageActual = bmp;

} imageReal = ProcesamientoImagen.clone(bmp);

public void recargar() { //Retornamos el valor

imageActual = return bmp;

ProcesamientoImagen.clone(imageReal); }
} public BufferedImage escalaGrisesC() {
//Método que devuelve una imagen abierta desde //Variables que almacenarán los píxeles
archivo
int mediaPixel, colorSRGB;
//Retorna un objeto BufferedImagen
Color colorAux;
public BufferedImage abrirImagen() {
//Recorremos la imagen píxel a píxel
//Creamos la variable que será devuelta (la
creamos como null) for (int i = 0; i < imageActual.getWidth(); i++) {
BufferedImage bmp = null; for (int j = 0; j < imageActual.getHeight(); j++) {
//Creamos un nuevo cuadro de diálogo para //Almacenamos el color del píxel
seleccionar imagen
 colorAux = new for (int j = 0; j < imageActual.getHeight(); j++) {
Color(this.imageActual.getRGB(i, j));
color = new Color(imageActual.getRGB(i, j));
//System.out.print("color auxiliar es: " +
colorAux); //se extraen los valores RGB

//Calculamos la media de los tres canales r = color.getRed();

(rojo, verde, azul) g = color.getGreen();
mediaPixel = (int) ((colorAux.getRed() + b = color.getBlue();
colorAux.getGreen() + colorAux.getBlue()) / 3);
System.out.println(r + "," + g + "," + b);
//System.out.print("color media pixel es:
"+mediaPixel); r = (r > umbral) ? 255 : 0;

//Cambiamos a formato sRGB g = (g > umbral) ? 255 : 0;

colorSRGB = (mediaPixel << 16) | (mediaPixel b = (b > umbral) ? 255 : 0;

<< 8) | mediaPixel; imageActual.setRGB(i, j, validaRGB(r, g,
//Asignamos el nuevo valor al BufferedImage b).getRGB());

//System.out.print("color SRGB es : }
"+mediaPixel); }
imageActual.setRGB(i, j, colorSRGB); return imageActual;
} }
} public BufferedImage operadorUmbralNegativo() {
//Retornamos la imagen for (int i = 0; i < imageActual.getWidth(); i++) {
return imageActual; for (int j = 0; j < imageActual.getHeight(); j++) {
} color = new Color(imageActual.getRGB(i, j));
////////Operadores //se extraen los valores RGB
public BufferedImage operadorNegativo() { r = color.getRed();
for (int i = 0; i < imageActual.getWidth(); i++) { g = color.getGreen();
for (int j = 0; j < imageActual.getHeight(); j++) { b = color.getBlue();
color = new Color(imageActual.getRGB(i, j));
//se extraen los valores RGB r = (r > umbral) ? 0 : 255;
r = 255 - color.getRed(); g = (g > umbral) ? 0 : 255;
g = 255 - color.getGreen(); b = (b > umbral) ? 0 : 255;
b = 255 - color.getBlue(); imageActual.setRGB(i, j, validaRGB(r, g,
imageActual.setRGB(i, j, validaRGB(r, g, b).getRGB());
b).getRGB()); }
} }
} return imageActual;
return imageActual; }
} public BufferedImage
public BufferedImage operadorUmbral() { operadorIntervaloUmbralBinario(int l1, int l2) {

for (int i = 0; i < imageActual.getWidth(); i++) { for (int i = 0; i < imageActual.getWidth(); i++) {
 for (int j = 0; j < imageActual.getHeight(); j++) { color = new Color(imageActual.getRGB(i, j));
color = new Color(imageActual.getRGB(i, j)); //se extraen los valores RGB
//se extraen los valores RGB r = color.getRed();
r = color.getRed(); g = color.getGreen();
g = color.getGreen(); b = color.getBlue();
b = color.getBlue(); r = (r > l1 && r < l2) ? 255 - r : 255;
r = (r > l1 && r < l2) ? 0 : 255; g = (g > l1 && g < l2) ? 255 - g : 255;
g = (g > l1 && g < l2) ? 0 : 255; b = (b > l1 && b < l2) ? 255 - b : 255;
b = (b > l1 && b < l2) ? 0 : 255; imageActual.setRGB(i, j, validaRGB(r, g,
b).getRGB());
imageActual.setRGB(i, j, validaRGB(r, g,
b).getRGB()); }
} }
} return imageActual;
return imageActual; }
} public BufferedImage
operadorUmbralEscalaGrises(int l1, int l2) {
public BufferedImage
operadorIntervaloUmbralBinarioNegativo(int l1, int l2) for (int i = 0; i < imageActual.getWidth(); i++) {
{
for (int j = 0; j < imageActual.getHeight(); j++) {
for (int i = 0; i < imageActual.getWidth(); i++) {
color = new Color(imageActual.getRGB(i, j));
for (int j = 0; j < imageActual.getHeight(); j++) {
//se extraen los valores RGB
color = new Color(imageActual.getRGB(i, j));
r = color.getRed();
//se extraen los valores RGB
g = color.getGreen();
r = color.getRed();
b = color.getBlue();
g = color.getGreen();
r = (r > l1 && r < l2) ? r : 255;
b = color.getBlue();
g = (g > l1 && g < l2) ? g : 255;
r = (r > l1 && r < l2) ? 255 : 0;
b = (b > l1 && b < l2) ? b : 255;
g = (g > l1 && g < l2) ? 255 : 0;
imageActual.setRGB(i, j, validaRGB(r, g,
b = (b > l1 && b < l2) ? 255 : 0; b).getRGB());
imageActual.setRGB(i, j, validaRGB(r, g, }
b).getRGB());
}
}
return imageActual;
}
}
return imageActual;
public BufferedImage operadorExtension(int l1, int
} l2) {
public BufferedImage for (int i = 0; i < imageActual.getWidth(); i++) {
operadorUmbralEscalaGrisesInvertido(int l1, int l2) {
for (int j = 0; j < imageActual.getHeight(); j++) {
for (int i = 0; i < imageActual.getWidth(); i++) {
color = new Color(imageActual.getRGB(i, j));
for (int j = 0; j < imageActual.getHeight(); j++) {
 //se extraen los valores RGB mediaPixel = 100;
r = color.getRed(); } else if (mediaPixel > 100 && mediaPixel <=
180) {
g = color.getGreen();
mediaPixel = 200;
b = color.getBlue();
} else {
r = (r > l1 && r < l2) ? (r - l1) * 255 / (l2 - l1) :
0; mediaPixel = 255;
g = (g > l1 && g < l2) ? (g - l1) * 255 / (l2 - l1) : }
0;
colorSRGB = (mediaPixel << 16) | (mediaPixel
b = (b > l1 && b < l2) ? (b - l1) * 255 / (l2 - l1) : << 8) | mediaPixel;
0;
imageActual.setRGB(i, j, colorSRGB);
imageActual.setRGB(i, j, validaRGB(r, g,
b).getRGB()); }

} }
return imageActual;
}
return imageActual; }

} /////Filtros

public BufferedImage operadorReduccionNivelGris() ///Aclarado

{ public BufferedImage correccionGamma(int q,
int mediaPixel, colorSRGB; double gamma) {

Color colorAux; for (int i = 0; i < imageActual.getWidth(); i++) {

for (int i = 0; i < imageActual.getWidth(); i++) { for (int j = 0; j < imageActual.getHeight(); j++) {
color = new Color(imageActual.getRGB(i, j));
for (int j = 0; j < imageActual.getHeight(); j++) {
//Trabajando con el promedio para //se extraen los valores RGB
simplificar r = color.getRed();
colorAux = new g = color.getGreen();
Color(this.imageActual.getRGB(i, j));
b = color.getBlue();
mediaPixel = (int) ((colorAux.getRed() +
colorAux.getGreen() + colorAux.getBlue()) / 3); r = (int) (q * Math.pow((r / q), gamma));

/* g = (int) (q * Math.pow((g / q), gamma));

Se definen 4 intervalos estaticos, para b = (int) (q * Math.pow((b / q), gamma));

muestra
0 para p<=50 imageActual.setRGB(i, j, validaRGB(r, g,
100 para 50<p<=100 b).getRGB());

200 para 100<p<=180 }

255 para 180<p<=255 }

*/ return imageActual;

if (mediaPixel <= 50) { }

mediaPixel = 0; public BufferedImage filtroLogaritmica(int q, double

alfa) {
} else if (mediaPixel > 50 && mediaPixel <=
100) { for (int i = 0; i < imageActual.getWidth(); i++) {
 for (int j = 0; j < imageActual.getHeight(); j++) {
color = new Color(imageActual.getRGB(i, j));
//se extraen los valores RGB
r = color.getRed();
g = color.getGreen();
b = color.getBlue();
double a = q / Math.log(alfa * q + 1);
r = (int) (a * Math.log(alfa * r + 1));
g = (int) (a * Math.log(alfa * g + 1));
b = (int) (a * Math.log(alfa * b + 1));
imageActual.setRGB(i, j, validaRGB(r, g,
b).getRGB());
}
} imageActual.setRGB(i, j, validaRGB(r, g,
return imageActual;
for (int i = 0; i < imageActual.getWidth(); i++) {
for (int j = 0; j < imageActual.getHeight(); j++) {
color = new Color(imageActual.getRGB(i, j));
//se extraen los valores RGB
r = color.getRed();
g = color.getGreen();
b = color.getBlue();
double a = q / (1 - Math.pow(Math.E, -alfa));
r = (int) (a * (1 - Math.pow(Math.E, -alfa * r /
q)));
g = (int) (a * (1 - Math.pow(Math.E, -alfa * g /
q)));
b = (int) (a * (1 - Math.pow(Math.E, -alfa * b /
q)));
b).getRGB());

} }

public BufferedImage filtroSeno(int q) { }

for (int i = 0; i < imageActual.getWidth(); i++) { return imageActual;

for (int j = 0; j < imageActual.getHeight(); j++) { }

color = new Color(imageActual.getRGB(i, j)); //Obscurecimiento

//se extraen los valores RGB public BufferedImage filtroObsCoseno(int q) {

r = color.getRed(); for (int i = 0; i < imageActual.getWidth(); i++) {

g = color.getGreen(); for (int j = 0; j < imageActual.getHeight(); j++) {

b = color.getBlue(); color = new Color(imageActual.getRGB(i, j));

r = (int) (q * Math.sin(Math.PI / (2 * q) * r)); //se extraen los valores RGB

g = (int) (q * Math.sin(Math.PI / (2 * q) * g)); r = color.getRed();

b = (int) (q * Math.sin(Math.PI / (2 * q) * b)); g = color.getGreen();

b = color.getBlue();

imageActual.setRGB(i, j, validaRGB(r, g, r = (int) (q * (1 - Math.cos(Math.PI * r / (2 *

b).getRGB()); q))));

} g = (int) (q * (1 - Math.cos(Math.PI * g / (2 *
q))));
}
b = (int) (q * (1 - Math.cos(Math.PI * b / (2 *
return imageActual; q))));
} imageActual.setRGB(i, j, validaRGB(r, g,
public BufferedImage filtroExponencial(int q, double b).getRGB());
alfa) { }
 } r = (r >= l1 && r <= l2) ? (int) (q * (r - l1) / (l2 -
l1)) : r;
return imageActual;
g = (g >= l1 && g <= l2) ? (int) (q * (g - l1) / (l2
} - l1)) : g;
public BufferedImage filtroObsExponencial(int q, b = (b >= l1 && b <= l2) ? (int) (q * (b - l1) / (l2
double alfa) { - l1)) : b;
for (int i = 0; i < imageActual.getWidth(); i++) { imageActual.setRGB(i, j, validaRGB(r, g,
for (int j = 0; j < imageActual.getHeight(); j++) { b).getRGB());

color = new Color(imageActual.getRGB(i, j)); }

//se extraen los valores RGB }

r = color.getRed(); return imageActual;

g = color.getGreen(); }

b = color.getBlue(); /////Histograma

double a = q / (Math.pow(Math.E, alfa) - 1); public BufferedImage expansionHistograma() {

r = (int) (a * (Math.pow(Math.E, alfa * r / q) - int mediaPixel, colorSRGB;

1)); calculaArreglosHistograma();
g = (int) (a * (Math.pow(Math.E, alfa * g / q) - System.out.println("");
1));
System.out.println("Total " +
b = (int) (a * (Math.pow(Math.E, alfa * b / q) - totalElementosNiveles);
1));
System.out.println("Fijmax " + fijmax);
System.out.println("Fijmin " + fijmin);
imageActual.setRGB(i, j, validaRGB(r, g,
b).getRGB()); System.out.println("Tam " +
(imageActual.getWidth() * imageActual.getHeight()));
}
for (int i = 0; i < imageActual.getWidth(); i++) {
}
for (int j = 0; j < imageActual.getHeight(); j++) {
return imageActual;
color = new Color(this.imageActual.getRGB(i,
} j));
///////////////////////////////////////////////////// mediaPixel = (int) ((color.getRed() +
////Filtro por segmento lineal color.getGreen() + color.getBlue()) / 3);

public BufferedImage filtroSementosLineales(int l1,

int l2, int q) { mediaPixel = (int) (((mediaPixel - fijmin) /
for (int i = 0; i < imageActual.getWidth(); i++) { (fijmax - fijmin)) * (max - min) + min);

for (int j = 0; j < imageActual.getHeight(); j++) {

color = new Color(imageActual.getRGB(i, j)); colorSRGB = (mediaPixel << 16) | (mediaPixel
<< 8) | mediaPixel;
//se extraen los valores RGB
imageActual.setRGB(i, j, colorSRGB);
r = color.getRed();
}
g = color.getGreen();
}
b = color.getBlue();
return imageActual;
}
 private void calculaArreglosHistograma() { }
int mediaPixel = 0; }
double probA = 0; }
totalElementosNiveles = 0; public static final BufferedImage
clone(BufferedImage image) {
gNiveles = new int[256];
BufferedImage clone = new
gProb = new double[256]; BufferedImage(image.getWidth(),
gProbAc = new double[256]; image.getHeight(), image.getType());
fijmax = 0; Graphics2D g2d = clone.createGraphics();
fijmin = 255; g2d.drawImage(image, 0, 0, null);
for (int i = 0; i < imageActual.getWidth(); i++) { g2d.dispose();
for (int j = 0; j < imageActual.getHeight(); j++) { return clone;
color = new Color(this.imageActual.getRGB(i, }
j));
public Color validaRGB(int r, int g, int b) {
mediaPixel = (int) ((color.getRed() +
color.getGreen() + color.getBlue()) / 3); if (r > 255) {
gNiveles[mediaPixel] += 1; r = 255;
if (mediaPixel > fijmax) { }
fijmax = mediaPixel; if (r < 0) {
} r = 0;
if (mediaPixel < fijmin) { }
fijmin = mediaPixel; if (g > 255) {
} g = 255;
} }
} if (g < 0) {
for (int i = 0; i < gNiveles.length; i++) { g = 0;
if (gNiveles[i] > 0) { }
totalElementosNiveles += gNiveles[i]; if (b > 255) {
} b = 255;
} }
for (int i = 0; i < gNiveles.length; i++) { if (b < 0) {
if (gNiveles[i] > 0) { b = 0;
gProb[i] = (double) gNiveles[i] / }
totalElementosNiveles;
return new Color(r, g, b);
probA += gProb[i];
}
gProbAc[i] = probA;
System.out.println("Indice : " + i + ", Nivel: " +
gNiveles[i] + ", Prob: " + gProb[i] + ", Prob Ac: " +
gProbAc[i]);