Manipulación de dos imágenes para realizar un montaje, usando código en Java

El código implementado nos indica que se procede a mezclar dos imágenes una como (background), imagen de fondo y la otra imagen (foreground)para ser montada sobre la primera.

La imagen background es multiplicada por un número alpha, la imagen foreground en primera instancia es duplicada y luego multiplicada por el número alpha con lo cual la imagen original (background no se modificará), dando como resultado una mezcla de las dos imágenes citadas.

A continuación se inserta el código.

import ij.IJ;
import ij.ImagePlus;
import ij.WindowManager;
import ij.process.*;
import ij.gui.GenericDialog;
import java.awt.*;
import ij.plugin.filter.*;

public class Alpha_Blending implements PlugInFilter {
ImagePlus fgIm = null;
static double alpha = 0.5;

public int setup(String arg, ImagePlus img) {
return DOES_8G;
}

public void run(ImageProcessor bgIp) {

if(runDialog()){
ImageProcessor fgIp=fgIm.getProcessor().convertToByte(false);
fgIp = fgIp.duplicate();
fgIp.multiply(1-alpha);
bgIp.multiply(alpha);
bgIp.copyBits(fgIp, 0, 0, Blitter.ADD);
}
}

boolean runDialog(){
int[] windowList = WindowManager.getIDList();
if (windowList == null){
IJ.noImage();
return false;
}
String[] windowTitles = new String[windowList.length];
for(int i = 0; i < windowList.length; i++)
{
ImagePlus im = WindowManager.getImage (windowList[i]);
if (im == null)
windowTitles[i] = "untitled";
else
windowTitles[i] = im.getShortTitle();
}
GenericDialog gd = new GenericDialog("Alpha Blending");
gd.addChoice("Foreground image: ", windowTitles, windowTitles[0]);
gd. addNumericField("Alpha value [0. . 1]: " , alpha, 2);
gd.showDialog();
if (gd.wasCanceled())
return false;
else {
int fgIdx = gd.getNextChoiceIndex();
fgIm = WindowManager.getImage(windowList[fgIdx]);
alpha = gd.getNextNumber ();
return true;
}
}
}

Control Movimiento

import ij.IJ;
import ij.ImagePlus;
import ij.WindowManager;
import ij.process.*;
import ij.gui.GenericDialog;
import java.awt.*;
import ij.plugin.filter.*;

public class Control_Moviento implements PlugInFilter
{
ImagePlus fgIm = null;
static double alpha = 0.5;

public int setup(String arg, ImagePlus img)
{
return DOES_8G;
}

public void run(ImageProcessor bgIp)
{

if(runDialog())
{
ImageProcessor fgIp=fgIm.getProcessor().convertToByte(false);
fgIp = fgIp.duplicate();
bgIp.copyBits(fgIp, 0, 0, Blitter.DIFFERENCE);
int w=bgIp.getWidth();
int n=bgIp.getHeight();
for(int i =0; i < w;i++)
{
for(int j= 0; j < n;j++)
{
int p =bgIp.getPixel(i,j);
if (p <150)
{
p=0;
}else if(p>=150)
{
p=255;
}
bgIp.putPixel(i,j,p);
}
}

}
}

boolean runDialog(){
int[] windowList = WindowManager.getIDList();
if (windowList == null){
IJ.noImage();
return false;
}
String[] windowTitles = new String[windowList.length];
for(int i = 0; i < windowList.length; i++)
{
ImagePlus im = WindowManager.getImage (windowList[i]);
if (im == null)
windowTitles[i] = "untitled";
else
windowTitles[i] = im.getShortTitle();
}
GenericDialog gd = new GenericDialog("Alpha Blending");
gd.addChoice("Foreground image: ", windowTitles, windowTitles[0]);
gd. addNumericField("Alpha value [0. . 1]: " , alpha, 2);
gd.showDialog();
if (gd.wasCanceled())
return false;
else {
int fgIdx = gd.getNextChoiceIndex();
fgIm = WindowManager.getImage(windowList[fgIdx]);
alpha = gd.getNextNumber ();
return true;
}

}

}

Detector de movimiento

import ij.IJ;
import ij.ImagePlus;
import ij.WindowManager;
import ij.process.*;
import ij.gui.GenericDialog;
import java.awt.*;
import ij.plugin.filter.*;

public class Alpha_Blending implements PlugInFilter {
ImagePlus fgIm = null;
static double alpha = 0.5;

public int setup(String arg, ImagePlus img) {
return DOES_8G;
}

public void run(ImageProcessor bgIp) {

if(runDialog()){
ImageProcessor fgIp=fgIm.getProcessor().convertToByte(false);
fgIp = fgIp.duplicate();
bgIp.copyBits(fgIp, 0, 0, Blitter.DIFFERENCE);
int w=bgIp.getWidth();
int n=bgIp.getHeight();
for(int i =0; i < w;i++)
{
for(int j= 0; j < n;j++)
{
int p =bgIp.getPixel(i,j);
if (p <150){
p=0;
}else if(p>=150){
p=255;
}
bgIp.putPixel(i,j,p);
}
}

}
}

boolean runDialog(){
int[] windowList = WindowManager.getIDList();
if (windowList == null){
IJ.noImage();
return false;
}
String[] windowTitles = new String[windowList.length];
for(int i = 0; i < windowList.length; i++)
{
ImagePlus im = WindowManager.getImage (windowList[i]);
if (im == null)
windowTitles[i] = "untitled";
else
windowTitles[i] = im.getShortTitle();
}
GenericDialog gd = new GenericDialog("Alpha Blending");
gd.addChoice("Foreground image: ", windowTitles, windowTitles[0]);
gd. addNumericField("Alpha value [0. . 1]: " , alpha, 2);
gd.showDialog();
if (gd.wasCanceled())
return false;
else {
int fgIdx = gd.getNextChoiceIndex();
fgIm = WindowManager.getImage(windowList[fgIdx]);
alpha = gd.getNextNumber ();
return true;
}

}

}

Manipulación de 2 o más Imágenes (imageJ)

import ij.ImagePlus;
import ij.WindowManager;import ij.process.*;
import ij.gui.GenericDialog;import ij.gui.*;
import ij.plugin.filter.PlugInFilterRunner;
import java.awt.*;import ij.plugin.filter.*;

public class Filtro_Control_Movimiento implements PlugInFilter
{
static double alpha = 0.5;
ImagePlus Iplus = null;
public int setup(String arg, ImagePlus imp)
{
return DOES_8G;
}
public void run(ImageProcessor ip)
{
if(runDialog())
{
ImageProcessor Ipro = Iplus.getProcessor().convertToByte(false);
Ipro = Ipro.duplicate();
Ipro.multiply(1-alpha);
Ipro.multiply(alpha);
Ipro.copyBits(Ipro, 0, 0, Blitter.ADD);

}
}
boolean runDialog()
{
int [] windowList = WindowManager.getIDList();
if (windowList == null)
{
IJ.noImage();
return false;
}
String[] windowTitles = new String[windowList.length];
for(int i=0; i {
ImagePlus im = WindowManager.getImage(windowList[i]);
if(im == null)
windowTitles[i] = "untitled";
else
windowTitles[i] = im.getShortTitle();
}
GenericDialog gd =new GenericDialog("Alpha Blending");
gd.addChoice("Foreground image:",windowTitles, windowTitles[0]); gd.addNumericField("Alpha value [0..1]:", alpha, 2);
gd.showDialog();
if(gd.wasCanceled())
return false;
else{
int fgIdx = gd.getNextChoiceIndex();
Iplus=WindowManager.getImage(windowList[fgIdx]); alpha=gd.getNextNumber();
return true;
}
}
}

Filtro de Manejo de Imagenes

Manejo de Imagenes
import ij.IJ;
import ij.ImagePlus;
import ij.WindowManager;
import ij.process.*;
import ij.gui.GenericDialog;
import ij.gui.*;
import ij.plugin.filter.PlugInFilterRunner;
import java.awt.*;
import ij.plugin.filter.*;

public class Filtro_Control_Movimiento implements PlugInFilter
{
static double alpha = 0.5;
ImagePlus Iplus = null;

public int setup(String arg, ImagePlus imp)
{
return DOES_8G;
}

public void run(ImageProcessor ip)
{
if(runDialog())
{
ImageProcessor Ipro = Iplus.getProcessor().convertToByte(false);
Ipro = Ipro.duplicate();
Ipro.multiply(1-alpha);
Ipro.multiply(alpha);
Ipro.copyBits(Ipro, 0, 0, Blitter.ADD);
}

}

boolean runDialog()
{
int [] windowList = WindowManager.getIDList();
if (windowList == null)
{
IJ.noImage();
return false;
}

String[] windowTitles = new String[windowList.length];

for(int i=0; i {
ImagePlus im = WindowManager.getImage(windowList[i]);
if(im == null)
windowTitles[i] = "untitled";
else
windowTitles[i] = im.getShortTitle();
}

GenericDialog gd =new GenericDialog("Alpha Blending");
gd.addChoice("Foreground image:",windowTitles, windowTitles[0]);
gd.addNumericField("Alpha value [0..1]:", alpha, 2);
gd.showDialog();
if(gd.wasCanceled())
return false;
else{
int fgIdx = gd.getNextChoiceIndex();
Iplus=WindowManager.getImage(windowList[fgIdx]);
alpha=gd.getNextNumber();
return true;
}
}
}

Manipulación de varias imágenes con image j

import ij.IJ;
import ij.ImagePlus;
import ij.WindowManager;
import ij.process.*;
import ij.gui.GenericDialog;
import java.awt.*;
import ij.plugin.filter.*;

public class Alpha_Blending implements PlugInFilter {
ImagePlus fgIm = null;
static double alpha = 0.5;

public int setup(String arg, ImagePlus img) {
return DOES_8G;
}

public void run(ImageProcessor bgIp) {

if(runDialog()){
ImageProcessor fgIp=fgIm.getProcessor().convertToByte(false);
fgIp = fgIp.duplicate();
fgIp.multiply(1-alpha);
bgIp.multiply(alpha);
bgIp.copyBits(fgIp, 0, 0, Blitter.ADD);
}
}

boolean runDialog(){
int[] windowList = WindowManager.getIDList();
if (windowList == null){
IJ.noImage();
return false;
}
String[] windowTitles = new String[windowList.length];
for(int i = 0; i < windowList.length; i++)
{
ImagePlus im = WindowManager.getImage (windowList[i]);
if (im == null)
windowTitles[i] = "untitled";
else
windowTitles[i] = im.getShortTitle();
}
GenericDialog gd = new GenericDialog("Alpha Blending");
gd.addChoice("Foreground image: ", windowTitles, windowTitles[0]);
gd. addNumericField("Alpha value [0. . 1]: " , alpha, 2);
gd.showDialog();
if (gd.wasCanceled())
return false;
else {
int fgIdx = gd.getNextChoiceIndex();
fgIm = WindowManager.getImage(windowList[fgIdx]);
alpha = gd.getNextNumber ();
return true;
}

}

}

Manejo de mùltiples imágenes con ImageJ

import ij.IJ;
import ij.ImagePlus;
import ij.WindowManager;
import ij.process.*;
import ij.gui.GenericDialog;
import java.awt.*;
import ij.plugin.filter.*;

public class Alpha_Blending implements PlugInFilter {
ImagePlus fgIm = null;
static double alpha = 0.5;

public int setup(String arg, ImagePlus img) {
return DOES_8G;
}

public void run(ImageProcessor bgIp) {

if(runDialog()){
ImageProcessor fgIp=fgIm.getProcessor().convertToByte(false);
fgIp = fgIp.duplicate();
fgIp.multiply(1-alpha);
bgIp.multiply(alpha);
bgIp.copyBits(fgIp, 0, 0, Blitter.ADD);
}
}

boolean runDialog(){
int[] windowList = WindowManager.getIDList();
if (windowList == null){
IJ.noImage();
return false;
}
String[] windowTitles = new String[windowList.length];
for(int i = 0; i < windowList.length; i++)
{
ImagePlus im = WindowManager.getImage (windowList[i]);
if (im == null)
windowTitles[i] = "untitled";
else
windowTitles[i] = im.getShortTitle();
}
GenericDialog gd = new GenericDialog("Alpha Blending");
gd.addChoice("Foreground image: ", windowTitles, windowTitles[0]);
gd. addNumericField("Alpha value [0. . 1]: " , alpha, 2);
gd.showDialog();
if (gd.wasCanceled())
return false;
else {
int fgIdx = gd.getNextChoiceIndex();
fgIm = WindowManager.getImage(windowList[fgIdx]);
alpha = gd.getNextNumber ();
return true;
}

}

}

Filtro Ecualización

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filtro_Equalizacion implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_ALL;
}

public void run(ImageProcessor ip)
{
int [] H= ip.getHistogram();
int K1=255;
for (int k=1; k< H.length; k++)
{
H[k]=H[k-1]+H[k];
}

int w=ip.getWidth();
int n=ip.getHeight();
for(int i =0; i < w;i++)
{
for(int j= 0; j < n;j++)
{
//int p = (int)(ip.getPixel(i,j)*0.5+1.5);
int p =(int)(ip.getPixel(i, j));
p=H[p]*((K1-1)/(i*j));
ip.putPixel(i,j,p);
}
}
}

}

Filtro Umbralización

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filter_Umbralizacion implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_8G;
}

public void run(ImageProcessor ip)
{
int w=ip.getWidth();
int n=ip.getHeight();
for(int i =0; i < w;i++)
{
for(int j= 0; j < n;j++)
{
int p =ip.getPixel(i,j);
//p = (int)(p*2+50);
if (p < 50){
p=0;
}else if(p > =50){
p=255;
}
ip.putPixel(i,j,p);
}
}
}

}

Filtro Contraste

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filter_Contraste implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_8G;
}

public void run(ImageProcessor ip)
{
int w=ip.getWidth();
int n=ip.getHeight();
for(int i =0; i < w;i++)
{
for(int j= 0; j {
int p =ip.getPixel(i,j);
p = (int)(p*2+50);
if (p > 255){
p=255;
}
ip.putPixel(i,j,p);
}
}
}

}

Ecualización

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filtro_Ecualizacion implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_ALL;
}

public void run(ImageProcessor ip)
{
int [] vec= ip.getHistogram();
int I=255;
for (int k=1; k< vec.length; k++)
{
vec[k]=vec[k-1]+vec[k];
}

int w=ip.getWidth();
int h=ip.getHeight();
for(int i =0; i < w; i++)
{
for(int j= 0; j < h; j++)
{
int img =(int)(ip.getPixel(i, j));
img=vec[img]*((I-1)/(i*j));
ip.putPixel(i,j,i,img);
}
}
}

}

ECUALIZACIÓN

la ecualización de un histograma permite que se eliminen sombras de la imagen y se aumente la visibilidad. La ecualización del histograma permite mejorar imágenes de forma muy puntual y especifica.

Para lograr una buena ecualización en las imágenes se realiza el histograma a todas las imágenes en escala de grises, encontrando los valores del rango donde se debe aumentar el contraste para ampliar la visibilidad de la imagen

ECUALIZACION PARA ESCALA DE GRISES

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filtro_Equalizacion implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_ALL;
}

public void run(ImageProcessor ip)
{
int [] H= ip.getHistogram();//declaro un arreglo para almacenar el histograma
int K1=255;
for (int k=1; k< H.length; k++)
{
H[k]=H[k-1]+H[k];
}

int w=ip.getWidth();//asigno a una variable el ancho de la imagen
int n=ip.getHeight(); //asigno a una variable el largo de la imagen
for(int i =0; i < w;i++)
{
for(int j= 0; j < n;j++)
{
//int p = (int)(ip.getPixel(i,j)*0.5+1.5);
int p =(int)(ip.getPixel(i, j));
p=H[p]*((K1-1)/(i*j));
ip.putPixel(i,j,p);
}
}
}

}


ECUALIZACION PARA IMAGEN A COLOR

import java.applet.*;
import java.awt.*;
import java.awt.image.*;

public class eqHist extends Applet //CLASE ECUALIZACIÓN
{
// Declaración de variables globales

Choice imagenes = new Choice(); // lista desplegable con las imagenes originales
Button cargar; // botón para cargar la imagen
Button aplicar; // botón para aplicar ecualización y representar histogramas

Image art; // imagen original
int w = 284; // anchura de la imagen original (fija)
int h = 129; // altura de la imagen original (fija)
int[] pixels; // vector para contener los pixels de la imagen original
PixelGrabber m_pixelgrabber; // objeto para guardar los pixels
int pixel; // valor (instantaneo) del pixel (al recorrer la imagen)

int[] histogram = new int[256]; // histograma de la imagen original
int maxFrequency = 0; // máxima frecuencia del histograma de la imagen original
int maxFrequencyIndx = 1; // índice de dicha máxima frecuencia

int[] histogram2=new int[256]; // histograma de la imagen ecualizada
int maxFrequency2 = 0; // máx. freq. del hist. de la imagen ecualizada
int maxFrequencyIndx2 = 1; // índice de dicha máxima frecuencia

double area; // tamaño de la imagen (w*h)

double cumNormHist [] = new double [256] ; // histograma normalizado acumulado
double min; // valor minimo del histograma normalizado acumulado
int[] dest = new int[256]; // niveles de gris transformados
int destino; // nuevo valor del pixel (imagen ecualizada)
int[] pixelsdestino; // vector para contener los pixels de la img ecualizada
Image m_ImageNew; // imagen ecualizada
boolean ecualizar = false; // vble. booleana para controlar la representacion
// si (ecualizar) entonces
// pintar histogramas e imagen ecualizada


public void init()
{
cargar = new Button ("Cargar imagen");

imagenes.addItem("img0");
imagenes.addItem("img1");
imagenes.addItem("img2");
imagenes.addItem("img3");
imagenes.addItem("img4");

add(imagenes);
add(cargar);

aplicar = new Button ("Ecualizar imagen");
add(aplicar);

// Inicializacion del histograma
for (int i = 0 ; i < 256 ; i ++) {
histogram[i] = 0;
}

maxFrequencyIndx = 1 ;
maxFrequency = 1 ;

// Inicializacion del histograma de la imagen ecualizada
for (int i = 0 ; i < 256 ; i ++) {
histogram2[i] = 0;
}

maxFrequencyIndx2 = 1;
maxFrequency2 = 1;

}

public boolean action ( Event e, Object o )
{
String parametro; // parametro que hay que obtener de la pagina web
int indice; // indice de imagen seleccionado

if ( e.target == cargar ) // si pulsamos el boton cargar
{
indice=imagenes.getSelectedIndex();
parametro="img" + Integer.toString(indice);
art=getImage(getDocumentBase(), getParameter(parametro));
ecualizar=false; // solo pintar la imagen a cargar

repaint();
return true;
}

if ( e.target == aplicar ) // si pulsamos el boton aplicar
{

// Obtenemos una matriz con los pixels de la imagen original

pixels = new int[w * h];
m_pixelgrabber = new PixelGrabber (art, 0, 0, w, h, pixels, 0, w) ;
try {
m_pixelgrabber.grabPixels();
}
catch (InterruptedException e2) {
System.err.println("interrupted waiting for pixels!");
//return;
}


// Inicializacion del histograma

for (int i = 0 ; i < 256 ; i ++) {
histogram[i] = 0;
}


// Creamos el histograma

for (int r = 0 ; r < h ; r++) { // recorremos todo el vector
for (int c = 0 ; c < w ; c++) { // de enteros (4 bytes/entero)
pixel = pixels[r * w + c] & 0xff; //nos quedamos con el
// ultimo byte (Blue,pq R=G=B)
histogram [pixel]++; // aumentamos el nº apariciones del
// nivel de gris en cuestión
}
}


// Buscamos la maxima frecuencia de aparicion

maxFrequencyIndx=0;
maxFrequency=0;

for (int i = 0 ; i < 256 ; i++) {
if (histogram[i] > maxFrequency) {
maxFrequencyIndx = i ;
maxFrequency = histogram[i] ;
}
}


//Histograma normalizado acumulado

area = w * h ;

for (int i = 0 ; i < 256 ; i++) {
cumNormHist [i] = 0 ; // inicializacion
}

cumNormHist[0] = (double)histogram[0] / area ;

if (cumNormHist[0]!=0) {
min=cumNormHist[0];
}
else {
min=1; // el valor minimo del Cumulative Norm. Histogram siempre sera < 1
}

for (int i = 1 ; i < 256 ; i++) {
cumNormHist[i] = cumNormHist[i - 1] + ((double)histogram[i] / area) ;

if ((cumNormHist[i]!=0) & (cumNormHist[i] min=cumNormHist[i];
}

}


// Creacion imagen ecualizada

pixelsdestino=new int[w*h];
for (int i = 0 ; i < 256 ; i++) {
dest [i] =(int) (((cumNormHist[i]-min)/(1-min))*255 + 0.5) ; // nuevos niveles de gris
}

for (int r = 0 ; r < h ; r++) {
for (int c = 0 ; c < w ; c++) {
pixel = pixels[r * w + c] & 0xff; // nivel del gris del pixel
// en la imagen original
destino = dest[pixel]; // nuevo nivel de gris (transformado)

int origen = destino;
int suma = 0;
int[] b = new int[33] ;

// Calculo del valor a almacenar en el vector de pixels

// Hemos de crear un valor entero (4 bytes) que contenga: FF XY XY XY, a partir de XY en decimal
// pasamos el número en decimal (origen) a binario, lo negamos y lo replicamos

for (int i = 1 ; i < 9 ; i ++) {
b[i] = origen % 2;

if (b[i]==1) {
b[i]=0;
}
else {
b[i]=1;
}

b[i]=b[i] & 1;

b[i+8] = b[i];
b[i+16] = b[i];
b[i+24]= 0;
origen = origen / 2;
}

// pasamos el valor binario obtenido a decimal

for (int j = 1 ; j <= 24 ; j ++) {
suma=suma+(b[j]*(int)(Math.pow(2,(double)(j-1))));
}

// si a este número le sumamos 1 y lo cambiamos de signo obtendremos el valor deseado
// (es decir, habremos deshecho el complemento a 2)

suma=suma+1;
suma=0-suma;

pixelsdestino[r * w + c]= suma;
}
}

MemoryImageSource mis = new MemoryImageSource(w, h, pixelsdestino, 0, w) ;
m_ImageNew = createImage (mis) ;

// Inicializacion del histograma de la imagen ecualizada

for (int i = 0 ; i < 256 ; i ++) {
histogram2[i] = 0;
}


// Creamos el histograma de la imagen ecualizada

for (int r = 0 ; r < h ; r++) {
for (int c = 0 ; c < w ; c++) {
pixel = pixelsdestino[r * w + c] & 0xff;
histogram2 [pixel]++;
}
}


// Buscamos la maxima frecuencia de aparicion

maxFrequencyIndx2=0;
maxFrequency2=0;

for (int i = 0 ; i < 256 ; i++) {
if (histogram2[i] > maxFrequency2) {
maxFrequencyIndx2 = i ;
maxFrequency2 = histogram2[i] ;
}
}

ecualizar=true; // pintar img original y ecualizada, pintar histogramas
repaint();
return true;
}
return false;
}

public void paint(Graphics g) {
g.drawString("ECUALIZACION DE HISTOGRAMA",10,25);

g.drawLine(0,40,700,40); // 1ª linea horizontal (completa, debajo de botones)
g.drawLine(205,0,205,40); // 1ª linea vertical (separa titulo de botones)

g.drawString("IMAGEN ORIGINAL",20,60);
g.drawString("IMAGEN ECUALIZADA",550,60);

g.drawLine(0,67,700,67); // 2ª linea horizontal (debajo del texto anterior)
g.drawLine(350,40,350,425); // 2ª linea vertical (separando los textos)

g.drawLine(0,230,700,230); // 3ª linea horizontal (completa, antes texto histogramas)

g.drawString("HISTOGRAMA IMAGEN ORIGINAL",20,250);
g.drawString("HISTOGRAMA IMAGEN ECUALIZADA",475,250);

g.drawLine(0,257,700,257); // 4ª linea horizontal (completa, despues texto hist.)


g.drawImage(art,33,84,this); // imagen original

if (ecualizar) { // pintar tb. imagen ecualizada e histogramas

g.drawImage(m_ImageNew,383,84,this); // imagen ecualizada

// Representacion grafica del histograma de la imagen original

int offset=15;

int desplaza=33; // desplazamiento horizontal
int baja=275; // desplazamiento vertical

g.setColor (new Color (255, 255, 255)) ;
g.fillRect(desplaza+0, baja+0, 255 + offset * 2 - 1, 100 + offset * 2 - 1) ;

g.setColor (new Color (0, 0, 0)) ;
g.drawRect(desplaza+0, baja+0, 255 + offset * 2, 100 + offset * 2) ;

g.setColor (new Color (0, 0, 0)) ;
g.drawString ("0", desplaza+offset / 2, baja+100 + offset * 2 - 2) ;
g.drawString ("255", desplaza+255, baja+100 + offset * 2 - 2) ;
g.drawString (String.valueOf(maxFrequency), desplaza+2, baja+offset) ;

for (int i = 0 ; i < 256 ; i++){
g.drawLine (desplaza+i + offset, baja+100 + offset - ((int)(((float)histogram[i] / (float)maxFrequency2) * 100.0)), desplaza+i + offset, baja+100 + offset);
}

// Representacion grafica del histograma de la imagen ecualizada

int desplaza2=383; // desplazamiento horizontal
int baja2=275; // desplazamiento vertical

g.setColor (new Color (255, 255, 255)) ;
g.fillRect(desplaza2+0, baja2+0, 255 + offset * 2 - 1, 100 + offset * 2 - 1) ;

g.setColor (new Color (0, 0, 0)) ;
g.drawRect(desplaza2+0, baja2+0, 255 + offset * 2, 100 + offset * 2) ;

g.setColor (new Color (0, 0, 0)) ;
g.drawString ("0", desplaza2+offset / 2, baja2+100 + offset * 2 - 2) ;
g.drawString ("255", desplaza2+255, baja2+100 + offset * 2 - 2) ;
g.drawString (String.valueOf(maxFrequency2), desplaza2+2, baja2+offset) ;

for (int i = 0 ; i < 256 ; i++){
g.drawLine (desplaza2+i + offset, baja2+100 + offset - ((int)(((float)histogram2[i] / (float)maxFrequency2) * 100.0)), desplaza2+i + offset, baja2+100 + offset);
}
}

}

}

UMBRALIZACIÖN

INTRODUCCION

UMBRALIZACION (SEGMENTACIÓN POR UMBRAL)
La operación de segmentación trata de distinguir si un píxel pertenece, o no, a un objeto de interés y, por lo tanto, produce una imagen binaria. Todavía no hay una teoría unificada de la segmentación de imágenes. Dentro de las técnicas más comunes en segmentación existe el método de umbralización.
“La umbralización se emplea cuando hay una clara diferencia entre los objetos a extraer respecto del fondo de la escena. Los principios que rigen son la similitud entre los píxeles pertenecientes a un objeto y sus diferencias respecto al resto.

Consiste en la división o separación de una imagen en regiones de atributos similares. Es decir, la segmentación subdivide una imagen en sus partes constituyentes u objetos. El grado de subdivisiones depende del problema a resolver.
Los algoritmos para segmentar imágenes monocromáticas generalmente se basan en una de las dos propiedades básicas de los valores del nivel de gris: discontinuidad y similitud.
En la primera categoría, la aproximación es particionar la imagen basándose en cambios abruptos en el nivel de gris. Las principales áreas de interés en esta categoría son de detección de puntos aislados, de líneas y de bordes en una imagen.
La segunda categoría se basa en segmentar por niveles de umbral, en regiones de crecimiento y en corte y pegado de regiones.

Tipos de Umbralización utilizando el histograma

–P-tile
–Modales
–Iterativos
–Adaptativos
–Variables

UMBRALIZACION PARA ESCALA DE GRISES


import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filter_Umbralizacion implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_8G;
}

public void run(ImageProcessor ip)
{
int w=ip.getWidth();
int n=ip.getHeight();
for(int i =0; i < w;i++)
{
for(int j= 0; j < n;j++)
{
int p =ip.getPixel(i,j);
//p = (int)(p*2+50);
if (p < 50){
p=0;
}else if(p > =80){//cabe recalcar que si me acerco a 255 la imagen se haría mas oscura o si me acerco a 0 la imagen se haría mas clara.
p=255;
}
ip.putPixel(i,j,p);
}
}
}

}
UMBRALIZACION PARA PARA IMAGENES A COLOR


Codigo Fuente Para la umbralización

import java.applet.*;
import java.awt.*;
import java.awt.Image.*;
import java.awt.event.*;
import java.awt.image.renderable.ParameterBlock;
import java.io.*;
import java.util.Hashtable;
import java.util.Vector;
import javax.media.jai.*;
import javax.media.jai.JAI;
import javax.media.jai.PlanarImage;
import javax.media.jai.Histogram;
import javax.media.jai.operator.HistogramDescriptor;
import javax.media.jai.RenderedOp;
import javax.media.jai.ROI;
import javax.media.jai.widget.ScrollingImagePanel;


public class umbralizacion extends Applet implements ItemListener, ActionListener
{
//declaramos como variables globales todas las que deban ser accedidas por más de un método
public Choice menu;
private Button boton;
Image foto;
String fotoelegida;
int marcador,max1,max2,media1,media2 ;
int opciones[]=new int[7];
int cadena[]=new int[256];
//en el método init inicializamos la varible opciones y el entorno gráfico inicial
public void init()
{
String eleccion;
for (int i=0; i<7; marcador="0;" eleccion="llaves" menu="new" fotoelegida="eleccion+" foto="getImage(getDocumentBase(),fotoelegida);" boton="new" fotoelegida="menu.getSelectedItem()+" foto="getImage(getDocumentBase(),fotoelegida);" marcador="menu.getSelectedIndex();//marcador" image1 =" JAI.create(" bins =" {256};" low =" {0.0D};" high =" {256.0D};" hist =" new" pb =" new" region =" null;" dst =" JAI.create(" hist =" (Histogram)" cadena =" hist.getBins(0);" max1="cadena[0];" media1="0;" media2="256;" max2="cadena[128];" i="0;">=max1) {
max1=cadena[i];
media1=i;
}

}

for (int j=128; j<>=max2) {
max2=cadena[j];
media2=j;
}

}

repaint(); //dibujamos en pantalla,la imagen elegida junto con su histograma

}

}

public void actionPerformed(ActionEvent e) {
//si se pulsa el botón Procesar imagen,realizamos la umbralización
RenderedOp image1 = JAI.create("fileload",fotoelegida);
int valor=opciones[marcador];//sólo realizamos el proceso si no lo hemos hecho antes
if (valor==0){
//declaramos las variables necesarias,teniendo en cuenta que el cambio de tipos
//numéricos en Java pasa por la creación de objetos numericos.
Integer mx1 = new Integer(max1);
Integer mx2 = new Integer(max2);
Integer m1 = new Integer(media1);
Integer m2 = new Integer(media2);
double vari1=0;
double vari2=0;
double vartemp1=0;
double vartemp2=0;
double f1;
double num;
double den1;
double f2;
double den2;
for ( int k=5; k<10;k++) ent =" new" f1="ent.doubleValue();" cad1 =" new" num=" Math.pow(f1,2.0F)/(-2.0F);" den1=" Math.log(cad1.doubleValue()/mx1.doubleValue());" vartemp1=" num/den1;" vari1="vari1+" cad2 =" new" den2=" Math.log(cad2.doubleValue()/mx2.doubleValue());" vartemp2=" num/den2;" vari2="vari2+" vari1="vari1/5;" vari2="vari2/5;" a="(0.5D/vari1-0.5D/vari2);" b="(m2.doubleValue()/vari2)-(m1.doubleValue()/vari1);" c="0.5D*(Math.pow(m1.doubleValue(),2.0F)/vari1)-0.5D*(Math.pow(m2.doubleValue(),2.0F)/vari2)+Math.log(mx2.doubleValue()/mx1.doubleValue());" u="(-1.0D*b" umbral=" new" bp =" new" procesada =" JAI.create(" ancho =" procesada.getWidth();" alto =" procesada.getHeight();" panel =" new" window =" new" max="1;//Para">max2) {
max=max1;
}
else {
max=max2;
}
g.drawRect( 349,49,2*257,402);
g.setColor(Color.white);
g.fillRect( 350,50,2*256,400 );
g.setColor(Color.black);
g.drawString("Histograma de "+ fotoelegida,370,440);
for ( int n=0; n<255;n++) {//representamos el histograma normalizado a su máximo
if (max!=0){
g.setColor( Color.black );
g.drawRect(350+n*2,400-(cadena[n]*350)/max,2,(cadena[n]*350)/max);
g.setColor(Color.blue);
g.fillRect(350+n*2,400-(cadena[n]*350)/max,1,(cadena[n]*350)/max-1);
}
}
}
}

Filtro de Ecualización

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;
public class Equalizacion implements PlugInFilter
{
ImagePlus imp;
public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_ALL;
}

public void run(ImageProcessor ip)
{
int []H = ip.getHistogram();
int K1=255;
for (int k=1; k< H.length; k++)
{
H[k]=H[k-1]+H[k];
}
int f=ip.getWidth();
int c=ip.getHeight();
for(int i =0; i {
for(int j= 0; j {
int pixel =(int)(ip.getPixel(i, j));
pixel=H[pixel]*((K1-1)/(i*j));
ip.putPixel(i,j,pixel);
}
}
}
}

Filtro de Umbralización

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filtro_Umbra implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_8G;
}

public void run(ImageProcessor ip)
{
int f=ip.getWidth();
int c=ip.getHeight();
for(int i =0; i {
for(int j= 0; j {
int pixel =ip.getPixel(i,j);

if (pixel <50){
pixel=0;
}else if(pixel>=50){
pixel=255;
}
ip.putPixel(i,j,pixel);
}
}
}

}

Filtro de Contraste

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filtro_Cont implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_8G;
}

public void run(ImageProcessor ip)
{
int f=ip.getWidth();
int c=ip.getHeight();
int a=2;
int b=50;
int c=255;
for(int i =0; i {
for(int j= 0; j {
int pixel =ip.getPixel(i,j);
pixel = (int)(pixel*a+b);
if (pixel >c)
{
pixel=c;
}
ip.putPixel(i,j,pixel);
}
}
}
}

Filtros

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;


public class Filtro_Umbralizacion implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_ALL;
}

public void run(ImageProcessor ip)
{
int w=ip.getWidth();
int h=ip.getHeight();
for(int i =0; i< j=" 0;" imp =" imp;" w="ip.getWidth();" h="ip.getHeight();" i ="0;" int="" j="0;">< p ="(int)((ip.getPixel(i,j))*0.5+1.5);"> 255)
{
p=255;
}
ip.putPixel(i,j,p);
}
}
}

}


import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filtro_ControlDeContraste implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_ALL;
}

public void run(ImageProcessor ip)
{
int w=ip.getWidth();
int h=ip.getHeight();
int Ahigh=0;
int Alow=255;

for(int i =0; i Ahigh)
{
Ahigh =ip.getPixel(i,j);
}
if(ip.getPixel(i,j) < Alow)
{
Alow=ip.getPixel(i,j);
}
}
}

for(int i =0; i
{
for(int j= 0; j
{
ip.putPixel(i,j,((ip.getPixel(i,j)-Alow)*255/(Ahigh-Alow)));
}
}
}
}

Umbralización en Imágenes a escala de grises

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filter_Umbralizacion1 implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_8G;
}

public void run(ImageProcessor ip)
{
int w=ip.getWidth();
int n=ip.getHeight();
for(int i =0; i < w; i ++)
{
for(int j= 0; j < n; j++)
{
int img =ip.getPixel(i,j);
if (img <50){
img=0;
}else if(img>=50){
img=255;
}
ip.putPixel(i,j,img);
}
}
}

}

Manejo de Contraste en Imágenes en escala de grises

import ij.*;
import ij.process.*;
import ij.gui.*;
import java.awt.*;
import ij.plugin.filter.*;

public class Filter_Contraste implements PlugInFilter
{
ImagePlus imp;

public int setup(String arg, ImagePlus imp)
{
this.imp = imp;
return DOES_8G;
}

public void run(ImageProcessor ip)
{
int w=ip.getWidth();
int n=ip.getHeight();
for(int i =0; i < w; i++)
{
for(int j= 0; j < n; j ++)
{
int img =ip.getPixel(i,j);
img = (int)(img*2+20);
if (img >255)
{
img=255;
}
ip.putPixel(i,j,img);
}
}
}

}