CODIGO BACKPROPAGATION

package redesneuronales;
//import java.awt.*;
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

//import java.lang.String;
//import javax.vecmath.Matrix3d;

public class Backpropagation {

public int k=0;

//Numero de neuronas a la entrada y la saldida de la red
int numEntradas, numSalidas;

// Numero de capas en la red
int numCapas;

// Numero de neuronas por capa
int numNeuronas_Capas [];
Matriz coefCompen [];

Matriz mPesos [];

Matriz outCapa[] = new Matriz [numCapas+1];
Matriz delta_propa[] = new Matriz[numCapas+1];
JRadioButton jRadioButton1 = new JRadioButton();
JButton jButton1 = new JButton();

public Backpropagation(){
String aux = JOptionPane.showInputDialog(null,
"Ingrese el numero de elementos de entrada",
"",JOptionPane.DEFAULT_OPTION);


numEntradas = Integer.parseInt(aux);
aux = JOptionPane.showInputDialog(null,
"Ingrese el numero de capas de la red",
"",JOptionPane.DEFAULT_OPTION);

numCapas = Integer.parseInt(aux);

aux = JOptionPane.showInputDialog(null,
"Ingrese el numero de elementos a la salida",
"",JOptionPane.DEFAULT_OPTION);

numSalidas = Integer.parseInt(aux);


// Llena el vector con el nuemro de neuronas por capa
numNeuronas_Capas = new int[numCapas];
for (int i = 0 ; i < numCapas; i++){
aux = JOptionPane.showInputDialog(null,
"ingrese el nuemro de neuronas para la capa " + (i+1)
,"",
JOptionPane.DEFAULT_OPTION);
numNeuronas_Capas[i] = Integer.parseInt(aux);
}


// Matriz de coeficientes de activacion
coefCompen = new Matriz [numCapas+1];
for (int i= 0; i < numCapas; i++)
coefCompen[i] = new Matriz(numNeuronas_Capas[i],1,-1,1);
coefCompen[numCapas] = new Matriz(numSalidas,1,-1,1);

// Matriz de pesos aleatorios
mPesos = new Matriz [numCapas+1];
for (int i = 0; i < numCapas; i++){
if (i == 0)
mPesos[i] = new Matriz (numNeuronas_Capas[i],numEntradas,-3,3);
else
mPesos[i] = new Matriz(numNeuronas_Capas[i],numNeuronas_Capas[i-1],-3,3);
}
mPesos[numCapas] = new Matriz ( numSalidas, numNeuronas_Capas[numCapas-1],-3,3);

}

// Propagacion directa
public Matriz [] propagacionDirecta(Matriz entrada){
Matriz salidaCapa[] = new Matriz [numCapas+1];

int i;
salidaCapa[0] = ((mPesos[0].multiplica(entrada)).suma(coefCompen[0])).logsigActivacion();
for (i = 1 ; i <= numCapas; i++){
salidaCapa[i] = ((mPesos[i].multiplica(salidaCapa[i-1])).suma(coefCompen[i])).logsigActivacion();
}
outCapa = salidaCapa;

return salidaCapa;
}

public Matriz calculoError(Matriz entrada, Matriz salida_real){
Matriz error2 = new Matriz();
Matriz error = new Matriz();
error = salida_real.resta(propagacionDirecta(entrada)[numCapas]);
error2 = (error.trans()).multiplica(error);

return error;
}

public Matriz [] propagacionInversa(Matriz errorSalida){
Matriz m[] = new Matriz[numCapas+1];
Matriz delta [] = new Matriz [numCapas+1];
Matriz ones = new Matriz(errorSalida.numFilas,errorSalida.numCols,"ones");
Matriz net_inv = new Matriz();

for (int i = 0; i <= numCapas; i++){
m[i] = mPesos[i].trans();
}

delta[numCapas] = errorSalida.multComponente(
(outCapa[numCapas]).multComponente((ones.resta(outCapa[numCapas]))));
net_inv = m[numCapas].multiplica(delta[numCapas]);
for (int i = numCapas-1; i >= 0 ; i--){
ones = new Matriz(net_inv.numFilas,net_inv.numCols,"ones");
delta[i] = net_inv.multComponente(
(outCapa[i]).multComponente((ones.resta(outCapa[i]))));
net_inv = m[i].multiplica(delta[i]);
}
delta_propa = delta;

return delta;
}

/**
* Actualiza los pesos luego que el se ha propagado el error
*
* @param entrada Matriz la entrada
* @param rata double la rata de aprendizaje
* @return Matriz[] regresa las matrices de vada capa ya actualizados
*/
public Matriz [] actuliazacionPesos(Matriz entrada,double rata){
Matriz temp[] = new Matriz [numCapas+1];
Matriz t[] = new Matriz [numCapas+1];

rata = 2*rata;
temp[0] = mPesos[0].suma(
(delta_propa[0].productoEscalarMatriz(rata)).multiplica(entrada.trans()));
t[0] = coefCompen[0].suma(delta_propa[0].productoEscalarMatriz(rata));

for (int i = 1 ; i <= numCapas; i++){
temp[i] = mPesos[i].suma(
(delta_propa[i].productoEscalarMatriz(rata)).multiplica((outCapa[i-1].trans())));
t[i] = coefCompen[i].suma(delta_propa[i].productoEscalarMatriz(rata));
}
mPesos = temp;
coefCompen = t;
return temp;
}

/**
* Simula la red neuronal dependiendo de la entrada presentada a la red
*
* @param patronesEntrada Matriz el patron de entrada
* @param aux String
* @return Matriz[]
*/
public Matriz [] simulacion(Matriz patronesEntrada,String aux){
Matriz p [] = new Matriz [patronesEntrada.numCols];
Matriz t[] = new Matriz [patronesEntrada.numCols];
Matriz salidaCapa[] = new Matriz [numCapas+1];

for (int j = 0; j < patronesEntrada.numCols;j++){
p[j] = new Matriz(patronesEntrada.numFilas,1);
for (int i = 0; i < patronesEntrada.numFilas;i++)
p[j].matrizDbl[i][0] = patronesEntrada.matrizDbl[i][0];
salidaCapa = propagacionDirecta(p[j]);
t[j] = salidaCapa[numCapas];
}
for (int j = 0; j < patronesEntrada.numCols; j++){
System.out.print("entradas\n"+p[j].toString());
System.out.print("salidas\n"+t[j].toString());
}
return t;
}

/**
* devuelva la salida real de la red neuronal cuando de le presenta el
* patron p
* @param p Matriz patron de entrada
* @return Matriz patron de salida a
*/
public Matriz simulacion(Matriz p){
Matriz salida = new Matriz (numSalidas,1);
salida = propagacionDirecta(p)[numCapas];

return salida;
}



public void entrenamientoOnLine(Matriz [] patronEntrada,Matriz [] salida){

Matriz e = new Matriz();
Matriz error2 = new Matriz(1,1);

double errorDouble = 0;

for (int i = 0; i < patronEntrada.length; i++){
e = salida[i].resta(simulacion(patronEntrada[i]));
error2 = (e.trans()).multiplica(e);
errorDouble = error2.matrizDbl[0][0];

while (Math.sqrt(errorDouble) > 0.001){
//System.out.println(i);
this.propagacionInversa(e);
this.actuliazacionPesos(patronEntrada[i],0.1);
k += 1;
//System.out.println(error2.toString());
e = salida[i].resta(simulacion(patronEntrada[i]));
error2 = (e.trans()).multiplica(e);
errorDouble = error2.matrizDbl[0][0];
i = 0;
//System.out.println(this.mPesos[0].toString());
}
}
//System.out.print("prueba\n"+simulacion(patronEntrada).toString());
}

public void entrenamientoOffLine(Matriz [] P, Matriz [] T){
Matriz e = new Matriz(P[0].numFilas,1), E;
Matriz error2 = new Matriz(1,1);
double errorDouble = 100;

while (Math.sqrt(errorDouble) > 0.1)
//for (int k = 0; k < 100 ; k++)
{
for (int i = 0; i < P.length; i++){
e = (T[i].resta(simulacion(P[i]))).suma(e);
}
System.out.println(e.toString());
E = e.productoEscalarMatriz(1.0 / (double) P.length);
error2 = (E.trans()).multiplica(E);
errorDouble = error2.matrizDbl[0][0];
System.out.print(errorDouble + "\n");
this.propagacionInversa(E);
for (int i = 0; i < P.length; i++)
this.actuliazacionPesos(P[i],0.1);
k += 1;
}



}
public static void main(String[] args) {
JOptionPane.showMessageDialog(null,"cuerpo","titulo",JOptionPane.DEFAULT_OPTION);
}
}

********************************************************************
**********RECONOCIMIENTO DE MONEDAS*********************************
********************************************************************


Module calculos
Dim resp(256) As Integer
Sub bitmap_to_matriz(ByRef matr(,) As Integer, ByRef mibitmap As Bitmap)
Dim i, j, nf, nc As Integer
Dim micolor As Color
nc = UBound(matr, 2) 'UBound: debuelve el maximo valor permitido de un arreglo
nf = UBound(matr, 1)

For i = 0 To nf
For j = 0 To nc
micolor = mibitmap.GetPixel(j, i) 'getpixel: metodo de mapa de bits y obtiene el color
matr(i, j) = micolor.R
Next
Next
End Sub

Sub matriz_to_bitmap(ByRef matr(,) As Integer, ByRef mibitmap As Bitmap)
Dim i, j, nf, nc, valor As Integer
Dim micolor As Color
nc = UBound(matr, 2) 'UBound: debuelve el maximo valor permitido de un arreglo
nf = UBound(matr, 1)

For i = 0 To nf
For j = 0 To nc
valor = matr(i, j)
micolor = Color.FromArgb(255, valor, valor, valor)
mibitmap.SetPixel(j, i, micolor)
Next
Next
End Sub

Sub normalizar255(ByRef reales(,) As Double, ByRef matriz(,) As Integer)
Dim vmin As Double
Dim vmax As Double
Dim i, j, nc, nf As Integer
vmin = minval(reales)
vmax = maxval(reales)
nc = UBound(reales, 2)
nf = UBound(reales, 1)
'vmin = reales(0, 0)
For i = 0 To nf
For j = 0 To nc
matriz(i, j) = (reales(i, j) - vmin) * 255 / (vmax - vmin)
If (matriz(i, j) < 0) Then matriz(i, j) = 0
If (matriz(i, j) > 255) Then matriz(i, j) = 255
Next
Next
End Sub

Sub normalizar255_E(ByRef reales(,) As Integer, ByRef matriz(,) As Integer)
Dim vmin As Double
Dim vmax As Double
Dim i, j, nc, nf, cont As Integer
vmin = minval(reales)
vmax = maxval(reales)
nc = UBound(reales, 2)
nf = UBound(reales, 1)
cont = 1
For i = 0 To nf
For j = 0 To nc
matriz(i, j) = (reales(i, j) - vmin) * 255 / (vmax - vmin)
If (matriz(i, j) < 0) Then matriz(i, j) = 0
If (matriz(i, j) > 255) Then matriz(i, j) = cont
Next
cont += 1
Next
End Sub

Function minval(ByRef reales(,) As Integer) As Integer
Dim i, j, nc, nf As Integer
Dim vmin As Double
nc = UBound(reales, 2)
nf = UBound(reales, 1)
vmin = reales(0, 0)
For i = 0 To nf
For j = 0 To nc 'indice de columnas
If (vmin > reales(i, j)) Then vmin = reales(i, j)
Next
Next
Return vmin
End Function

Function maxval(ByRef reales(,) As Integer) As Integer
Dim i, j, nc, nf As Integer
Dim vmax As Double
nc = UBound(reales, 2)
nf = UBound(reales, 1)
vmax = reales(0, 0)
For i = 0 To nf
For j = 0 To nc 'indice de columnas
If (vmax < reales(i, j)) Then vmax = reales(i, j)
Next
Next
Return vmax
End Function

Function minval(ByRef reales(,) As Double) As Double
Dim i, j, nc, nf As Integer
Dim vmin As Double
nc = UBound(reales, 2)
nf = UBound(reales, 1)
vmin = reales(0, 0)
For i = 0 To nf
For j = 0 To nc 'indice de columnas
If (vmin > reales(i, j)) Then vmin = reales(i, j)
Next
Next
Return vmin
End Function
Function maxval(ByRef reales(,) As Double) As Double
Dim i, j, nc, nf As Integer
Dim vmax As Double
nc = UBound(reales, 2)
nf = UBound(reales, 1)
vmax = reales(0, 0)
For i = 0 To nf
For j = 0 To nc 'indice de columnas
If (vmax < reales(i, j)) Then vmax = reales(i, j)
Next
Next
Return vmax
End Function

Sub color_gris(ByRef imagen1 As Bitmap, ByRef imagen2 As Bitmap)
Dim i, j As Integer
Dim color1, color2 As Color
Dim grisd As Double
Dim gris As Integer
Dim r, g, b As Integer
Dim mr(imagen1.Height - 1, imagen1.Width - 1) As Integer
' bitmap_to_matriz(mr, imagen1)
For i = 0 To imagen1.Height - 1
For j = 0 To imagen1.Width - 1
color1 = imagen1.GetPixel(j, i)
r = color1.R
g = color1.G
b = color1.B
grisd = 0.299 * r + 0.587 * g + 0.114 * b
gris = Math.Round(grisd)
If (gris > 255) Then gris = 255
color2 = Color.FromArgb(255, gris, gris, gris)
imagen2.SetPixel(j, i, color2)
Next
Next
End Sub

Sub histograma1(ByRef mibitmap As Bitmap, ByRef arreglo() As Long)
Dim i, j, valor As Integer
Dim micolor As Color
'nc = UBound(matr, 2) --> y en el bitmap(alto de pixeles)
'nf = UBound(matr, 1) --> x en el bitmap(ancho de pixeles)

'j --> columnas : i --> filas
For i = 0 To mibitmap.Height - 1
For j = 0 To mibitmap.Width - 1
micolor = mibitmap.GetPixel(j, i) 'getpixel: metodo de mapa de bits y obtiene el color
'si es pa los 3 colores hay q poner los 3 componentes
valor = micolor.R
arreglo(valor) += 1

Next
Next
For i = 0 To 255
If arreglo(i) <> 0 Then
'MessageBox.Show(arreglo(i), i, MessageBoxButtons.OK)
End If

Next
End Sub

Sub ordenar(ByRef vec() As Integer, ByRef mediana As Integer)
Dim i, j, n, aux As Integer
n = UBound(vec, 1)

For i = 0 To n - 1
For j = 0 To n - 1
If (vec(j) > vec(j + 1)) Then
aux = vec(j)
vec(j) = vec(j + 1)
vec(j + 1) = aux
End If
Next
Next
mediana = vec(Math.Abs(n / 2))
End Sub

Sub filtro_mediana(ByRef imagen As Bitmap, ByRef tamano As Integer)
Dim nx, ny, i, j, i1, j1, i3, j3, nFiltro, vPixel, mediana As Integer
nx = imagen.Width - 1 : ny = imagen.Height - 1
Dim matrizInic(ny, nx) As Integer, matrizfinal(ny, nx) As Double
bitmap_to_matriz(matrizInic, imagen)
nFiltro = tamano - 1
Dim vec(tamano * tamano - 1), cont As Integer
cont = 0
For i = 0 To ny
For j = 0 To nx
cont = 0
For i1 = i - (nFiltro / 2) To i + (nFiltro / 2)
For j1 = j - (nFiltro / 2) To j + (nFiltro / 2)
i3 = i1 : j3 = j1
If i3 < 0 Then i3 = i1 * (-1)
If j3 < 0 Then j3 = j1 * (-1)
If i3 > ny Then i3 = ny - (i1 - ny)
If j3 > nx Then j3 = nx - (j1 - nx)
vPixel = matrizInic(i3, j3)
vec(cont) = vPixel
cont = cont + 1
Next
Next
ordenar(vec, mediana)
matrizfinal(i, j) = mediana
Next
Next
'MessageBox.Show(mediana)
normalizar255(matrizfinal, matrizInic)
matriz_to_bitmap(matrizInic, imagen)
End Sub

Function Umbral(ByRef mibitmap As Bitmap)
Dim i, j, valor, valumbral As Integer
Dim micolor As Color
Dim arreglo(256) As Long
For i = 0 To mibitmap.Height - 1
For j = 0 To mibitmap.Width - 1
micolor = mibitmap.GetPixel(j, i)
valor = micolor.R
arreglo(valor) += 1
Next
Next
valumbral = 0
For i = 0 To 255
If arreglo(i) >= valumbral Then
valumbral = arreglo(i)
Else
valumbral = valumbral
End If
Next
Return valumbral
End Function

Sub binarizar(ByRef imagen1 As Bitmap)
Dim i, j, nc, nf, arreglo(256) As Integer
Dim IO(imagen1.Height - 1, imagen1.Width - 1) As Integer
Dim IB(imagen1.Height - 1, imagen1.Width - 1) As Integer

nc = imagen1.Width - 1 : nf = imagen1.Height - 1
' MessageBox.Show(cont)
bitmap_to_matriz(IO, imagen1)
For i = 1 To nf
For j = 1 To nc
If IO(i, j) >= 50 Then
IB(i, j) = 255
Else
IB(i, j) = 0
End If
Next j
Next i
matriz_to_bitmap(IB, imagen1)
End Sub
Sub etiquetado(ByRef imagen1 As Bitmap)
Dim i, j, etiq, nc, nf As Integer
Dim IO(imagen1.Height - 1, imagen1.Width - 1) As Integer

etiq = 50 'And IO(j + 1, i - 1) = 0 & _And IO(j + 1, i) = 0
nc = imagen1.Width - 1 : nf = imagen1.Height - 1
bitmap_to_matriz(IO, imagen1)
For i = 0 To nf - 1
For j = 0 To nc - 1
If IO(i, j) <> 0 Then
If IO(i, j - 1) = 0 And IO(i - 1, j) = 0 Then
etiq = etiq + 1
IO(i, j) = etiq
'MessageBox.Show(etiq)
Else
If IO(i + 1, j) <> 0 Then
IO(i + 1, j) = IO(i, j)
End If
End If
End If
Next
Next
End Sub

Sub etiquetado_4p(ByRef imagen As Bitmap)

Dim i, j, i1, j1, nf, nc, iequiv, etiq, pizq, psup As Integer
Dim matriz(imagen.Height - 1, imagen.Width - 1) As Integer
Dim matriz1(imagen.Height - 1, imagen.Width - 1) As Integer
Dim existe As Boolean
bitmap_to_matriz(matriz, imagen)
nf = UBound(matriz, 1)
nc = UBound(matriz, 2)
Dim tequiv(nf, 2)
etiq = 1
iequiv = 0
For i = 0 To nf
For j = 0 To nc
If matriz(i, j) <> 0 Then
If i - 1 < 0 Then
psup = 0
Else
psup = matriz(i - 1, j)
End If
If j - 1 < 0 Then
pizq = 0
Else
pizq = matriz(i, j - 1)
End If
If pizq = 0 And psup = 0 Then
etiq = etiq + 1
matriz(i, j) = etiq
End If
If pizq <> 0 And psup <> 0 Then
matriz(i, j) = pizq
If pizq <> psup Then
'agrega a tabla de equivalencia
existe = False
If iequiv > 0 Then
'verifica que psup y pizq no esten en tabla
For i1 = 0 To iequiv - 1
If tequiv(i1, 0) = psup And tequiv(i1, 1) = pizq Then
existe = True
End If
Next
End If
If existe = False Then
tequiv(iequiv, 0) = psup
tequiv(iequiv, 1) = pizq
tequiv(iequiv, 2) = 0
iequiv = iequiv + 1
End If
End If
End If
If pizq <> 0 And psup = 0 Or _
pizq = 0 And psup <> 0 Then
matriz(i, j) = pizq + psup
End If
End If
Next
Next
Debug.Write("numero de etiquetas=" & etiq & vbCrLf)
Debug.Write("antes de proceso de equiv" & vbCrLf)
'For i = 0 To iequiv - 1
' Debug.Write(i & " " & tequiv(i, 0) & " " & tequiv(i, 1) & " " & tequiv(i, 2) & vbCrLf)
'Next

'proceso de tabla de equivalencias
Dim vr, vb As Integer
' transformacion de tequiv
' se asegura que tequiv(i,0) For i = 0 To iequiv - 1
If tequiv(i, 0) > tequiv(i, 1) Then
vr = tequiv(i, 0) : tequiv(i, 0) = tequiv(i, 1) : tequiv(i, 1) = vr
End If
Next

For i = 0 To iequiv - 1
If tequiv(i, 2) = 0 Then
tequiv(i, 2) = tequiv(i, 0)
End If
vr = tequiv(i, 0)
vb = tequiv(i, 1)
For j = 0 To iequiv - 1
If tequiv(j, 2) = 0 Then
If tequiv(j, 0) = vr Or tequiv(j, 1) = vr _
Or tequiv(j, 0) = vb Or tequiv(j, 1) = vb Then
tequiv(j, 2) = tequiv(i, 2)
vr = tequiv(j, 0)
vb = tequiv(j, 1)
j = 0
End If
End If
Next j

Debug.Write("- " & i)
Next

Debug.Write("luego proceso de equivalencias" & vbCrLf)
For i = 0 To iequiv - 1
Debug.Write(i & " " & tequiv(i, 0) & " " & tequiv(i, 1) & " " & tequiv(i, 2) & vbCrLf)
Next
'genera tabla de reemplazos
Dim tr(etiq)
For j = 0 To etiq
tr(j) = j
Next
For j = 0 To iequiv - 1
For j1 = 0 To 1
tr(tequiv(j, j1)) = tequiv(j, 2)
Next
Next
'REEMPLAZO
For i = 0 To nf
For j = 0 To nc
matriz(i, j) = tr(matriz(i, j))
Next j
Next i
Debug.Write("matriz final" & vbCrLf)
For i = 0 To nf
For j = 0 To nc
If matriz(i, j) <> 0 Then
Debug.Write(i & " ; " & j & " valor " & matriz(i, j) & vbCrLf)
End If
Next
Next

MessageBox.Show("****Fin Reconocimiento****")
normalizar255_E(matriz, matriz1)
matriz_to_bitmap(matriz1, imagen)

End Sub

Function etiqueta(ByRef matriz(,) As Integer, ByRef nf As Integer, ByRef nc As Integer) As Integer

Dim i, j, cont, k As Integer
Dim arr(256), temp(256) As Integer
cont = 0
For i = 0 To 255
arr(i) = i
Next
For i = 0 To nf
For j = 0 To nc
For k = 0 To 255
If matriz(i, j) <> 0 Then
If matriz(i, j) = arr(k) Then

End If
End If
Next
Next
Next


End Function

Sub calculo_valores(ByRef val() As Long, ByRef uno As Integer, ByRef cinco As Integer, ByRef diez As Integer, ByRef vcinc As Integer, ByRef cinq As Integer, ByRef und As Integer)

Dim i As Integer
uno = 0 : diez = 0 : cinco = 0 : vcinc = 0 : cinq = 0 : und = 0

For i = 0 To 255
If val(i) >= 7054 And val(i) <= 8454 Then
diez += 1
End If
If val(i) >= 8455 And val(i) <= 9900 Then
uno += 1
End If
If val(i) >= 9968 And val(i) <= 12182 Then
cinco += 1
End If
If val(i) >= 12183 And val(i) <= 15000 Then
vcinc += 1
End If
If val(i) >= 15200 And val(i) <= 19000 Then
und += 1
End If
If val(i) >= 19759 And val(i) <= 25000 Then
cinq += 1
End If
Next

End Sub

End Module

*****************************************************************
*****************************************************************

Imports System.Drawing
Imports System.drawing.Drawing2D
Imports System.Drawing.Graphics
Imports System.Drawing.Image
Imports System.Windows
Imports System.Math

Public Class Form1

Private Sub btncargar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btncargar.Click
Dim imagen As Bitmap
imagen = New Bitmap(Me.PictureBox1.Width, Me.PictureBox1.Height) 'a esa imagen le asigna el ancho y el alto del picturebox
With Me.ofd1
'.InitialDirectory = "C:\"
.Filter = "Formatos (*.bmp;*.jpg;*.jpeg;*.gif;*.tif)|" & _
"*.bmp;*.jpg;*.jpeg;*.gif;*.tif|Bitmaps (*.bmp)|*.bmp|" & _
"GIFs (*.gif)|*.gif|JPEGs (*.jpg)|*.jpg;*.jpeg|TIFs (*.tif)|*.tif"
.FilterIndex = 1
End With
If ofd1.ShowDialog() = Windows.Forms.DialogResult.OK Then
imagen = FromFile(ofd1.FileName) 'este le transfiere la imagen desde el archivo fisico a memoria a un objeto tipo bitmap
End If
Me.PictureBox1.Width = imagen.Width
Me.PictureBox1.Height = imagen.Height
Me.PictureBox1.Image = imagen
lb_ah1.Text = "W " & imagen.Width & " - " & "H " & imagen.Height
End Sub


Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim miimagen1 As Bitmap

Dim miimagen2 As Bitmap
'Dim uncen, cinc, diezc, vintc, cincc As Integer
Dim uno, diez, cinco, vcinc, cinq, und As Integer


Dim valhisto(255) As Long
miimagen1 = New Bitmap(Me.PictureBox1.Image)
miimagen2 = New Bitmap(miimagen1.Width, miimagen1.Height)
color_gris(miimagen1, miimagen2)
Dim tamano As Integer

tamano = 9
filtro_mediana(miimagen2, tamano)
binarizar(miimagen2)
'Dim matriz(miimagen2.Height - 1, miimagen2.Width - 1) As Integer
etiquetado_4p(miimagen2)
histograma1(miimagen2, valhisto)

calculo_valores(valhisto, uno, cinco, diez, vcinc, cinq, und)
txt_uc.Text = uno
txt_dc.Text = diez
txt_cc.Text = cinco
txt_vc.Text = vcinc
txt_qc.Text = cinq
txt_ud.Text = und


End Sub

Protected Overrides Sub Finalize()
MyBase.Finalize()
End Sub
End Class