Está en la página 1de 7

Carga im�genes desde el directorio

public void cargarImagenes(String directorio) {


File directorioImagenes = new File(directorio);
File[] listaImagenes = directorioImagenes.listFiles();
int numImagenes = 0;
for (int i = 0; i < listaImagenes.length; i++) {
if (!listaImagenes[i].getName().equals("Thumbs.db")) {
numImagenes++;
}
}
archivoRN = new String[numImagenes];
arregloImagenes = new JPanelImagenMadurezBinarizar[numImagenes];
for (int i = 0; i < numImagenes; i++) {
arregloImagenes[i] = new JPanelImagenMadurezBinarizar();
arregloImagenes[i].setRutaImagen(listaImagenes[i].getAbsolutePath());
}
}
Encarga de la binarizaci�n de las im�genes, reducir la imagen y comparar esa im�gen
binarizadas con la reducida, Si ambos pixeles tienen el mismo color ,se pinta de
blanco, sino se pinta de negro
public class JPanelImagenMadurezBinarizar extends javax.swing.JPanel {

private static final int PORCENTAJE = 40;


private static final int ZOOM_DISMINUIR = 10;
private static final int DIMENSION_ANCHO = 300;
private static final int DIMENSION_ALTO = 400;
private static final Color COLOR_LINEAS = Color.ORANGE;
private String rutaImagen = ""; //"C:\\Users\\laptop-
w8\\Desktop\\pera_ercolini_0.jpg"
private String linea = "";
private BufferedImage imagenBufferedImageOriginal = null;
private Image imagen1T, imagen2T, imagen3T, imagen4T, imagen_actual;
private File archivoImagen;
private int ancho = 400;
private int alto = 400;
private int[][] matriz; // matriz para generar archivo de texto
private int numeroFilas = 50;
private int numeroColumnas = 50;
private boolean pintarLineas = false;
//////////////
private Integer[] entradaRN;
//////////////

private int[] promediosVerticales;

/**
* Creates new form JPanelImagenBinarizada
*/
public JPanelImagenMadurezBinarizar() {
initComponents();
matriz = new int[numeroFilas][numeroColumnas];
Dimension d = new Dimension(DIMENSION_ANCHO + 1, DIMENSION_ALTO + 1);
this.setPreferredSize(d);
this.setSize(d);
}

@Override
public void paint(Graphics g) {
super.paint(g); //To change body of generated methods, choose Tools |
Templates.

if (rutaImagen != null) {
g.drawImage(imagen_actual, 0, 0, ancho, alto, this);
if (pintarLineas) {
pintarLineasMatriz(g);
}
setOpaque(false);
}
}

public void iniciar() {


archivoImagen = new File(rutaImagen);
pintarLineas = true;
cargarImagenOriginal();
blancoNegro();
escalado();
corona();
analisis();
salidaBinaria();
generarLinea();
}

public void imagenOriginal() {


archivoImagen = new File(rutaImagen);
cargarImagenOriginal();
porcentajeColor();
}

public void imagenBinarizada() {


archivoImagen = new File(rutaImagen);
cargarImagenOriginal();
blancoNegro();
}

public void imagenCorona() {


archivoImagen = new File(rutaImagen);
cargarImagenOriginal();
blancoNegro();
escalado();
corona();
}

/**
* Cargamos la imagen
*/
public void cargarImagenOriginal() {

try {
imagenBufferedImageOriginal = ImageIO.read(archivoImagen);
} catch (IOException ex) {
System.out.println("Excepcion al leer el archivo: " + ex);
}
// obtener ancho y alto de la archivoImagen
ajusteImagen();
try {
imagen1T = imagenBufferedImageOriginal.getScaledInstance(ancho, alto,
Image.SCALE_AREA_AVERAGING);
} catch (Exception ex) {
System.out.println("Excepcion al escalar la imagen: " + ex);
}
imagen_actual = imagen1T;
}

public void ajusteImagen() {


ancho = imagenBufferedImageOriginal.getWidth();
alto = imagenBufferedImageOriginal.getHeight();
// ajustar archivoImagen a tama�o del jpanel
if (ancho >= DIMENSION_ANCHO || alto >= DIMENSION_ALTO) {
int per1 = ancho - DIMENSION_ANCHO;
int per2 = alto - DIMENSION_ALTO;
double red = 0;
if (per1 > per2) {
red = (per1 * 1.0) / ancho;
} else {
red = (per2 * 1.0) / alto;
}
ancho = (int) ((1 - red) * ancho);
alto = (int) ((1 - red) * alto);
}
// ajustar archivoImagen a multiplo de numero de filas y numero de columnas
int ancho_original = ancho;
int alto_original = alto;
ancho = (ancho_original / numeroColumnas) * numeroColumnas;
alto = (alto_original / numeroFilas) * numeroFilas;

if (ancho_original > ancho) {


ancho = ancho + numeroColumnas;
}
if (alto_original > alto) {
alto = alto + numeroFilas;
}
}

public void blancoNegro() {

// convertirmo la imagen a flujo de enteros


int[] pix = Util.convertirImagenToArray(imagen1T, ancho, alto);
// pasar la imagen a negro y blanco
Util.convertirImagenBlancoNegro(imagen1T, pix, ancho, alto);
// crear imagen original
imagen1T = crearImagen(pix, ancho, alto);
// la imagen pasa a ser pintada por el jpanel
imagen_actual = imagen1T;
}

public void escalado() {


// imagen disminuida por escalamiento
disminuir(ZOOM_DISMINUIR);
imagen_actual = imagen2T;
}

public void corona() {


// aplicacion del and del las dos imagenes
int[] px3 = Util.coronaCircular(imagen1T, imagen2T, ancho, alto);
imagen3T = crearImagen(px3, ancho, alto);
imagen_actual = imagen3T;
}

public void analisis() {


matriz = new int[numeroFilas][numeroColumnas];
int[] temp = Util.convertirImagenToArray(imagen3T, ancho, alto);
int[][] matriz2 = Util.convertirArrayToMatriz(temp, ancho, alto);
int total = 0;
int aproxBlanco = 0;
int aproxNegro = 0;
// System.out.println("ancho: " + ancho + ",alto: " + alto);
for (int i = 0; i < numeroFilas; i++) {
for (int j = 0; j < numeroColumnas; j++) {
int long_x = ancho / numeroColumnas;
int long_y = alto / numeroFilas;
int inicio_alto = i * long_y;
int fin_alto = (inicio_alto + long_y);
int inicio_ancho = j * long_x;
int fin_ancho = (inicio_ancho + long_x);
for (int m = inicio_alto; m < fin_alto; m++) {
for (int n = inicio_ancho; n < fin_ancho; n++) {
int p = matriz2[m][n];
Color r = new Color(p);
int azul = r.getBlue();
if (azul > 220) {
aproxBlanco++;
} else {
aproxNegro++;
}
total = aproxBlanco + aproxNegro;
}
}
if ((aproxNegro * 1.0 / total * 1.0) * 100 > PORCENTAJE) {
matriz[i][j] = 1;
Util.pintarMatriz(matriz2, inicio_ancho, inicio_alto,
fin_ancho, fin_alto, 0xff000000);
} else {
matriz[i][j] = 0;
Util.pintarMatriz(matriz2, inicio_ancho, inicio_alto,
fin_ancho, fin_alto, 0xffffffff);
}
aproxBlanco = 0;
aproxNegro = 0;
total = 0;
}
}
int[] temp2 = Util.convertirMatrizToArray(matriz2, ancho, alto);
imagen4T = crearImagen(temp2, ancho, alto);
imagen_actual = imagen4T;
}

public void porcentajeColor() {


int[] pix = Util.convertirImagenToArray(imagen1T, ancho, alto);
int[][] matriz = Util.convertirArrayToMatriz(pix, ancho, alto);
promediosVerticales = Util.hallarMadurez(imagen1T, matriz, ancho, alto);
}

public void disminuir(int zoom) {


// System.out.println("antes: " + ancho + "," + alto);
int ancho_temp = (int) ((1 - (zoom / 100f)) * ancho);
int alto_temp = (int) ((1 - (zoom / 100f)) * alto);
// System.out.println("despues: " + ancho_temp + "," + alto_temp);

// imagen con menor dimension que 1T


imagen2T = imagen1T.getScaledInstance(ancho_temp, alto_temp,
Image.SCALE_AREA_AVERAGING);
// convertimos la imagen a flujo de enteros
int[] px2 = Util.convertirImagenToArray(imagen2T, ancho_temp, alto_temp);
// creamos una imagen con dimension igual a la primera con fondo blanco
int[][] matriz_temp = Util.crearImagenBlanca(ancho, alto);
// unimos la imagen2T a la imagen con fondo blanco
Util.pasarArrayToMatriz(px2, matriz_temp, ancho_temp, alto_temp, ancho,
alto);
// de la nueva matriz la pasamos a un arreglo de enteros
px2 = Util.convertirMatrizToArray(matriz_temp, ancho, alto);
// a partir del arreglo de enteros creamos una imagen
imagen2T = crearImagen(px2, ancho, alto);
}

public void pintarLineasMatriz(Graphics g) {


g.setColor(COLOR_LINEAS);
// pintar horizontales
for (int i = 1; i <= numeroFilas; i++) {
if (i != numeroFilas / 2) {
g.drawLine(0, (alto / numeroFilas) * i, ancho, (alto / numeroFilas)
* i);
}
}
// pinta verticales
for (int i = 1; i < numeroColumnas; i++) {
if (i != numeroColumnas / 2) {
g.drawLine((ancho / numeroColumnas) * i, 0, (ancho /
numeroColumnas) * i, alto);
}
}
// pintar ejes
g.setColor(Color.BLUE);
g.drawLine(ancho / 2, 0, ancho / 2, alto); //y
g.drawLine(0, alto / 2, ancho, alto / 2); // x
// pinta el contorno
g.drawRect(0, 0, ancho, alto);
}

public void generarImagenMatrizAzul(Graphics g) {


for (int i = 0; i < numeroFilas; i++) {
for (int j = 0; j < numeroColumnas; j++) {
if (matriz[i][j] == 1) {
g.setColor(Color.BLUE);
} else {
g.setColor(Color.WHITE);
}
g.fillRect((ancho / numeroColumnas) * j, (alto / numeroFilas) * i,
(ancho / numeroColumnas) * (j + 1), (alto / numeroFilas) *
(i + 1));
}
}
}
public Image crearImagen(int[] m, int ancho, int alto) {
return createImage(new MemoryImageSource(ancho, alto, m, 0, ancho));
}

public void generarArchivo() {


Util.generarArchivo(matriz, numeroFilas, numeroColumnas);
}

public void salidaBinaria() {


Util.salidaBinaria(matriz, numeroFilas, numeroColumnas);
}

public void generarLinea() {


linea = Util.generarLinea(matriz, numeroFilas, numeroColumnas);
entradaRN = Util.generarVectorLinea(matriz, numeroFilas, numeroColumnas);
}

public String getLinea() {


return linea;
}

public Integer[] getEntradaRN() {


return entradaRN;
}

public void setRutaImagen(String rutaImagen) {


this.rutaImagen = rutaImagen;
}

public String getRutaImagen() {


return rutaImagen;
}

public int[] getPromediosVerticales() {


return promediosVerticales;
}

public void setPromediosVerticales(int[] promediosVerticales) {


this.promediosVerticales = promediosVerticales;
}

/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">

private void initComponents() {

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);


this.setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 400, Short.MAX_VALUE)
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 300, Short.MAX_VALUE)
);
}
}

También podría gustarte