public static Bitmap TransHough(Bitmap Ent_Img, Bitmap s, Mascara Min_x, Mascara Min_y, int TetaDe, int TetaHasta, int numLineas)
{
// detectar bordes en la imagen
// Bitmap Hough_Im = DetectarBordes(Min_x, Min_y, 0);
// umbraliza la imagen
// Hough_Im = Umbralizar(Hough_Im, Otsu(HistogramaNormal(Hough_Im)));
Bitmap Hough_Im = new Image <Gray, byte>(Ent_Img).Canny(100, 50).ToBitmap();
// crear el acumulador
double pMaximo = Math.Sqrt(Math.Pow(Hough_Im.Width, 2) + Math.Pow(Hough_Im.Height, 2));
double RangoPeee = Math.Round(Math.Sqrt(Math.Pow(Hough_Im.Width, 2) + Math.Pow(Hough_Im.Height, 2)));
double RangoTeta = Math.Abs(TetaDe) + TetaHasta;
double conversor = Math.PI / 180;
Mascara Acumulador = new Mascara(new Size((int)RangoPeee, (int)RangoTeta));
// realizar transformacion lineal para cada pixel
for (int i = 0; i < Hough_Im.Height; i++)
{
for (int j = 0; j < Hough_Im.Width; j++)
{
// iterar para todo el rango de angulos
for (int iTeta = TetaDe; iTeta < RangoTeta; iTeta++)
{
if (PictureAnalizer.PixelColor2Gray(Hough_Im.GetPixel(j, i)) > 0)
{
int PeeI = (Convert.ToInt32(Math.Round(j * Math.Cos(conversor * iTeta) + i * Math.Sin(conversor * iTeta))));
Acumulador.MascaraNumerica[Math.Abs(PeeI), Math.Abs(iTeta)] += 1;
}
}
}
}
PictureAnalizer.AcumuladorGeneral = CopiarMatriz(Acumulador);
Bitmap v = new Bitmap(Hough_Im);
for (int ss = 0; ss < numLineas; ss++)
{
Point Pmax = MatrizMaxPosicion(Acumulador);
for (int i = 0; i < Hough_Im.Height; i++)
{
for (int j = 0; j < Hough_Im.Width; j++)
{
long ys = Convert.ToInt64(Math.Round((Pmax.X / Math.Sin(conversor * Pmax.Y)) - (((j * Math.Cos(conversor * Pmax.Y)) / Math.Sin(conversor * Pmax.Y)))));
if (ys == i)
{
v.SetPixel(j, i, Color.Red);
}
}
}
}
return(v);
}
static Point MatrizMaxPosicion(Mascara Ent_Mascara)
{
Point pmax = new Point();
double[] arr = new double[(int)Ent_Mascara.Dims.Width * Ent_Mascara.Dims.Height];
int k = 0;
for (int i = 0; i < Ent_Mascara.Dims.Height; i++)
{
for (int j = 0; j < Ent_Mascara.Dims.Width; j++)
{
arr[k] = Ent_Mascara.MascaraNumerica[j, i];
k++;
}
}
double max = arr.Max();
for (int i = 0; i < Ent_Mascara.Dims.Height; i++)
{
for (int j = 0; j < Ent_Mascara.Dims.Width; j++)
{
if (Ent_Mascara.MascaraNumerica[j, i] == max)
{
pmax.X = j;
pmax.Y = i;
Ent_Mascara.MascaraNumerica[j, i] = -10;
}
}
}
return(pmax);
}
private void DetectarBorde_Click(object sender, EventArgs e)
{
this.MascaraGenerica1 = conseguirMascara(MascaraTextX);
this.MascaraGenerica2 = conseguirMascara(MascataTxtY);
int c = 0;
if (ImagenEnXOpt.Checked)
{
c = 1;
}
else
if (ImagenEnY.Checked)
{
c = -1;
}
else
if (ImagenEnZOpt.Checked)
{
c = 0;
}
this.ImagenEntrada.Image = (Image)PictureAnalizer.DetectarBordes(MascaraGenerica1, MascaraGenerica2, c, (Bitmap)ImagenEntrada.Image);
}
public static Bitmap DetectarBordes(Mascara mascaraEntradaX, Mascara mascaraEntradaY, int tipo, Bitmap img)
{
Bitmap mResultadoX = PictureAnalizer.DibujarNegra(img.Width, img.Height);
Bitmap mResultadoY = PictureAnalizer.DibujarNegra(img.Width, img.Height);
Bitmap mResultadoGradZ = PictureAnalizer.DibujarNegra(img.Width, img.Height);
for (int i = 0; i < img.Height; i++)
{
for (int j = 0; j < img.Width; j++)
{
int x = 0, y = 0, z = 0;
y = PictureAnalizer.ValorMascara(j, i, new Mascara(mascaraEntradaY.MascaraNumerica, mascaraEntradaY.Dims, mascaraEntradaY.Centro), img, mResultadoY);
mResultadoY.SetPixel(j, i, Color.FromArgb(y, y, y));
x = PictureAnalizer.ValorMascara(j, i, new Mascara(mascaraEntradaX.MascaraNumerica, mascaraEntradaX.Dims, mascaraEntradaX.Centro), img, mResultadoX);
mResultadoX.SetPixel(j, i, Color.FromArgb(x, x, x));
z = PictureAnalizer.NormalizarPixel(Math.Abs(x) + Math.Abs(y));
mResultadoGradZ.SetPixel(j, i, Color.FromArgb(z, z, z));
}
}
switch (tipo)
{
case -1: return(mResultadoY);
case 1: return(mResultadoX);
case 0: return(mResultadoGradZ);
}
return(mResultadoGradZ);
}
// se supone una mascara de tipod cuadrada
public static Bitmap CortarMascaraSobreImagen(Mascara Masc_Ent, Bitmap Img_Ent, Point Pnt_Orgn)
{
// crear una subimagen del tamaño de la mascara, dimenciones cuadradas
Bitmap sbImg = PictureAnalizer.DibujarNegra(Masc_Ent.Dims.Height, Masc_Ent.Dims.Height);
// recorrer la matriz
int Pinicio = ((Masc_Ent.Dims.Height - 1) / 2) - (Masc_Ent.Dims.Height - 1) + Pnt_Orgn.X;
int Pfinal = (Masc_Ent.Dims.Height);
int k = 0;
while (Pinicio <= 0)
{
Pinicio = ((Masc_Ent.Dims.Height - 1) / 2) - (Masc_Ent.Dims.Height - 1) + Pnt_Orgn.X + k;
k++;
}
Mascara m = new Mascara(new Size(3, 3));
for (int i = Pinicio, s = 0; i < Pfinal; i++, s++)
{
for (int j = Pinicio, z = 0; j < Pfinal; j++, z++)
{
// verificar que los indices no superen los limites de la imagen
if (Pnt_Orgn.X + j < Img_Ent.Width && Pnt_Orgn.Y + i < Img_Ent.Height && Pnt_Orgn.X + j > 0 && Pnt_Orgn.Y + i > 0)
{
int PxiOrigen = PictureAnalizer.PixelColor2Gray(Img_Ent.GetPixel(Pnt_Orgn.X + j, Pnt_Orgn.Y + i));
sbImg.SetPixel(z, s, Color.FromArgb(PxiOrigen, PxiOrigen, PxiOrigen));
m.MascaraNumerica[j, i] = 1;
}
}
}
return(sbImg);
}
// objetner los caracteres de la mascara de entrada y contarlos
private void CalcularMascara_Click(object sender, EventArgs e)
{
this.MascaraGenerica1 = conseguirMascara(this.TextMascara);
PictureAnalizer.ImagenEntrada = PictureAnalizer.SuavisarImagen(this.MascaraGenerica1, (Bitmap)ImagenEntrada.Image);
ImagenEntrada.Image = PictureAnalizer.ImagenEntrada;
}
// erocionar imagen
private void button2_Click(object sender, EventArgs e)
{
Mascara m = conseguirMascara(Txt_Otros);
int color = (int)Selector_Brillo.Value;
PictureAnalizer.ImagenEntrada = PictureAnalizer.ErocionarImagen(PictureAnalizer.ImagenEntrada, m, color);
ImagenEntrada.Image = PictureAnalizer.ImagenEntrada;
}
private void button12_Click(object sender, EventArgs e)
{
Mascara Mx = conseguirMascara(hTxtX);
Mascara MY = conseguirMascara(hTxtY);
Bitmap s = PictureAnalizer.DibujarNegra(PictureAnalizer.ImagenEntrada.Width, PictureAnalizer.ImagenEntrada.Height);
// ImagenEntrada.Image = (Image)PictureAnalizer.TransHough(PictureAnalizer.ImagenEntrada,s,Mx,MY,(int)tetade.Value, (int) tetaHasta.Value);
// this.Pb_Sinus.Image = (Image)PictureAnalizer.MostrarAcms();
}
public static Bitmap [] ImagenDeTextura(Bitmap Im_Ent, Dictionary <int, double>[] hrs)
{
// conseguir los maximos de las sumas y diferencias
double MaxSuma = PictureAnalizer.MaximoHasha(hrs[0]);
double MaxResta = PictureAnalizer.MaximoHasha(hrs[1]);
double MaxGenrl = 0;
if (MaxSuma > MaxResta)
{
MaxGenrl = MaxSuma;
}
else
{
MaxGenrl = MaxResta;
}
// crear vector de imagenes de textura
Bitmap[] VectImgTxt = new Bitmap[6];
// inicar las imagenes
for (int i = 0; i < 6; i++)
{
VectImgTxt[i] = PictureAnalizer.DibujarNegra(Im_Ent.Width, Im_Ent.Height);
}
// crear una mascara para representar la subventana
Mascara Mx = new Mascara(new Size(3, 3));
// recorrer la imagen
for (int i = 0; i < Im_Ent.Height; i++)
{
for (int j = 0; j < Im_Ent.Width; j++)
{
// conseguir pixel
int Pi = PictureAnalizer.PixelColor2Gray(Im_Ent.GetPixel(j, i));
// cortar contenido de la imagen origina con la mascara
Bitmap subImg = PictureAnalizer.CortarMascaraSobreImagen(Mx, Im_Ent, new Point(j, i));
// calcular las caracteristicas de textura de la subimagen
double[] op = PictureAnalizer.CalcularCaracteristicasTextura(Im_Ent);
// asignar operaciones a la imagen
for (int k = 0; k < 6; k++)
{
int trnas = (int)Math.Round((op[i] * 255) / MaxGenrl);
VectImgTxt[i].SetPixel(j, i, Color.FromArgb(trnas, trnas, trnas));
}
}
}
return(VectImgTxt);
}
public static Bitmap ErocionarImagen(Bitmap ImagenNoDilatada, Mascara EEstructurante, int ColorPixel)
{
Bitmap ImagenErocionada = PictureAnalizer.DibujarNegra(ImagenNoDilatada.Width, ImagenNoDilatada.Height);
List <Point> listaPuntos = PictureAnalizer.PuntosInteres(ImagenNoDilatada, ColorPixel);
foreach (Point p in listaPuntos)
{
PictureAnalizer.CortarMascarEn(p.X, p.Y, EEstructurante, ImagenErocionada, ImagenNoDilatada);
}
return(ImagenErocionada);
}
public static void CopiarMascaraEn(int posX, int posY, Mascara Eestruct, Bitmap ImagenDilatada)
{
for (int iMzk = 0, iImg = posY - ((Eestruct.Dims.Height - 1) / 2); iMzk < Eestruct.Dims.Height; iMzk++, iImg++)
{
for (int jMzk = 0, jImg = posX - ((Eestruct.Dims.Width - 1) / 2); jMzk < Eestruct.Dims.Width; jMzk++, jImg++)
{
if (iImg < ImagenDilatada.Height && jImg < ImagenDilatada.Width)
{
ImagenDilatada.SetPixel(Math.Abs(jImg), Math.Abs(iImg), Color.White);
}
}
}
}
public static Bitmap SuavisarImagen(Mascara mascaraEntrada, Bitmap Img_Entrada)
{
Bitmap mResultado = PictureAnalizer.DibujarNegra(Img_Entrada.Width, Img_Entrada.Height);
for (int i = 0; i < mResultado.Height; i++)
{
for (int j = 0; j < mResultado.Width; j++)
{
PictureAnalizer.FiltrarEn(j, i, new Mascara(mascaraEntrada.MascaraNumerica, mascaraEntrada.Dims, mascaraEntrada.Centro), Img_Entrada, mResultado);
}
}
return(mResultado);
}
public Mascara conseguirMascara(TextBox TextoOrigen)
{
string[] f = TextoOrigen.Text.Split('\r', '\n');
string[] c = f[0].Replace('\r', '#').Split(' ');
int filas = TextoOrigen.Text.Split('\n').Length;
int clmns = this.restarDelimitadores("#", c);
string[] n = new string[filas * clmns];
double[,] val = new double[filas, clmns];
int i = 0;
foreach (string s in f)
{
if (s != "")
{
string[] k = s.Split(' ');
for (int j = 0; j < k.Length; j++)
{
n[i] = k[j];
i++;
}
}
}
int o = 0;
for (int z = 0; z < filas; z++)
{
for (int j = 0; j < clmns; j++)
{
val[j, z] = Convert.ToDouble(n[o]);
o++;
}
}
Mascara m = new Mascara(val, new Size(filas, clmns), new Point(1, 1));
return(m);
}
static int MaximoMascaraMatriz(Mascara Ent_Mascara)
{
double[] arr = new double[(int)Ent_Mascara.Dims.Width * Ent_Mascara.Dims.Height];
int k = 0;
for (int i = 0; i < Ent_Mascara.Dims.Height; i++)
{
for (int j = 0; j < Ent_Mascara.Dims.Width; j++)
{
arr[k] = Ent_Mascara.MascaraNumerica[j, i];
k++;
}
}
double max = arr.Max();
return((int)max);
}
public static void CortarMascarEn(int posX, int posY, Mascara Eestruct, Bitmap ImagenDilatada, Bitmap ImagenOriginal)
{
int dim = 0;
for (int iMzk = 0, iImg = posY - ((Eestruct.Dims.Height - 1) / 2); iMzk < Eestruct.Dims.Height; iMzk++, iImg++)
{
for (int jMzk = 0, jImg = posX - ((Eestruct.Dims.Width - 1) / 2); jMzk < Eestruct.Dims.Width; jMzk++, jImg++)
{
if (iImg < ImagenOriginal.Height && jImg < ImagenOriginal.Width)
{
int c = PixelColor2Gray(ImagenOriginal.GetPixel(Math.Abs(jImg), Math.Abs(iImg)));
if (c == 255)
{
dim++;
}
}
}
}
if (dim == (Eestruct.Dims.Width * Eestruct.Dims.Width))
{
ImagenDilatada.SetPixel(posX, posY, Color.White);
}
}
public static void FiltrarEn(int posX, int posY, Mascara MascaraFiltro, Bitmap ImageSinFiltro, Bitmap ImagenFiltrada)
{
double[] prom = new double[MascaraFiltro.Dims.Width * MascaraFiltro.Dims.Height];
int k = 0;
double p = 0;
for (int iMzk = 0, iImg = posY - ((MascaraFiltro.Dims.Height - 1) / 2); iMzk < MascaraFiltro.Dims.Height; iMzk++, iImg++)
{
for (int jMzk = 0, jImg = posX - ((MascaraFiltro.Dims.Width - 1) / 2); jMzk < MascaraFiltro.Dims.Width; jMzk++, jImg++)
{
if ((iImg < ImageSinFiltro.Height && jImg < ImageSinFiltro.Width) && (iImg >= 0 && jImg >= 0))
{
int c = PictureAnalizer.PixelColor2Gray(ImageSinFiltro.GetPixel(jImg, iImg));
double cm = MascaraFiltro.MascaraNumerica[jMzk, iMzk];
MascaraFiltro.MascaraNumerica[jMzk, iMzk] = c * cm;
prom[k] = MascaraFiltro.MascaraNumerica[jMzk, iMzk];
p += prom[k];
}
}
}
int t = (int)p / prom.Length;
if (t < 0)
{
t = Math.Abs(t);
}
else
if (t > 255)
{
t = 255;
}
ImagenFiltrada.SetPixel(posX, posY, Color.FromArgb(t, t, t));
}
public static int ValorMascara(int posX, int posY, Mascara MascaraFiltro, Bitmap ImageSinFiltro, Bitmap ImagenFiltrada)
{
double[] prom = new double[MascaraFiltro.Dims.Width * MascaraFiltro.Dims.Height];
int k = 0;
double p = 0;
for (int iMzk = 0, iImg = posY - ((MascaraFiltro.Dims.Height - 1) / 2); iMzk < MascaraFiltro.Dims.Height; iMzk++, iImg++)
{
for (int jMzk = 0, jImg = posX - ((MascaraFiltro.Dims.Width - 1) / 2); jMzk < MascaraFiltro.Dims.Width; jMzk++, jImg++)
{
if ((iImg < ImageSinFiltro.Height && jImg < ImageSinFiltro.Width) && (iImg >= 0 && jImg >= 0))
{
int c = PictureAnalizer.PixelColor2Gray(ImageSinFiltro.GetPixel(jImg, iImg));
double cm = MascaraFiltro.MascaraNumerica[jMzk, iMzk];
MascaraFiltro.MascaraNumerica[jMzk, iMzk] = c * cm;
prom[k] = MascaraFiltro.MascaraNumerica[jMzk, iMzk];
p += prom[k];
}
}
}
int t = (int)p;
if (t > 255)
{
t = 225;
}
else
if (t < 0)
{
t = 0;
}
return(t);
}
private void button26_Click(object sender, EventArgs e)
{
string[] nombres = { "Vacio", "Torres", "Caballos", "Alfiles", "Reinas", "Reyes", "Peones" };
//ActivationNetwork rna = EntrenarRNA();
// rna.Save("save1.rna");
// para cada imagen en la direccion de entrenamiento
DirectoryInfo sc = new DirectoryInfo(rutaEjemplos);
FileInfo[] s = sc.GetFiles();
Bitmap[,] Matzs = null;
double[][] Carz = new double[8 * 8][];
double[] Obj =
{
1, 2, 3, 4, 5, 3, 2, 1,
6, 6, 6, 6, 6, 6, 6, 6,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
6, 6, 6, 6, 6, 6, 6, 6,
1, 2, 3, 4, 5, 3, 2, 1,
};
for (int k = 0; k < 64; k++)
{
Carz[k] = new double[6];
}
int b = 0;
foreach (FileInfo imgEjemp in s)
{
ImagenEntrada.Image = PictureAnalizer.ImagenColor2Gray((Bitmap)Image.FromFile(imgEjemp.FullName));
PictureAnalizer.ImagenEntrada = (Bitmap)ImagenEntrada.Image;
Mascara mX = new Mascara(Mascara.PRDF_Opdr_LPcX, new Size(3, 3), new Point(1, 1));
Mascara mY = new Mascara(Mascara.PRDF_Opdr_LpcY, new Size(3, 3), new Point(1, 1));
ImagenEntrada.Image = PictureAnalizer.DetectarBordes(mX, mY, 0, (Bitmap)ImagenEntrada.Image);
ImagenEntrada.Image.Save(@"C:\Users\frodo\Desktop\ejemplos - copia\" + "imgBorde" + b.ToString() + ".jpeg");
b++;
Matzs = PictureAnalizer.DividirImagen((Bitmap)ImagenEntrada.Image, 8);
ImagenEntrada.Refresh();
System.Threading.Thread.Sleep(1000);
int n = 0;
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
Bitmap im = Matzs[j, i];
ImagenEntrada.Image = im;
int p = (int)Obj[n];
string dir = "Piesas/" + nombres[p] + "/";
DirectoryInfo dest = new DirectoryInfo(dir);
FileInfo[] infDir = dest.GetFiles();
switch (p)
{
case 0: im.Save(dir + nombres[p] + infDir.Length + ".jpeg"); break;
case 1: im.Save(dir + nombres[p] + infDir.Length + ".jpeg"); break;
case 2: im.Save(dir + nombres[p] + infDir.Length + ".jpeg"); break;
case 3: im.Save(dir + nombres[p] + infDir.Length + ".jpeg"); break;
case 4: im.Save(dir + nombres[p] + infDir.Length + ".jpeg"); break;
case 5: im.Save(dir + nombres[p] + infDir.Length + ".jpeg"); break;
case 6: im.Save(dir + nombres[p] + infDir.Length + ".jpeg"); break;
}
Carz[n] = PictureAnalizer.CalcularCaracteristicasTextura(im);
for (int v = 0; v < Carz[n].Length; v++)
{
Console.WriteLine(Carz[n][v]);
}
ImagenEntrada.Refresh();
System.Threading.Thread.Sleep(100);
n++;
}
}
}
List <Bitmap[]> ListaEntradas = new List <Bitmap[]>();
List <double[][]> ListaCarz = new List <double[][]>();
double carTota = 0;
for (int k = 0; k < 7; k++)
{
ListaEntradas.Add(new Bitmap[1]);
ListaCarz.Add(new double[6][]);
}
string[] rutasInternas = Directory.GetDirectories("Piesas/");
for (int i = 0; i < rutasInternas.Length; i++)
{
string ruta = rutasInternas[i];
string[] rutaSgmnt = ruta.Split('/');
int indx = Array.IndexOf(nombres.ToArray(), rutaSgmnt[1]);
DirectoryInfo infDir = new DirectoryInfo(ruta);
FileInfo[] infFile = infDir.GetFiles("*.jpeg", SearchOption.AllDirectories);
Bitmap[] imgArr = new Bitmap[infFile.Length];
double[][] carArr = new double[infFile.Length][];
carTota += infFile.Length;
for (int j = 0; j < imgArr.Length; j++)
{
imgArr[j] = (Bitmap)Image.FromFile(infFile[j].FullName);
carArr[j] = PictureAnalizer.CalcularCaracteristicasTextura(imgArr[j]);
}
ListaEntradas[indx] = imgArr;
ListaCarz[indx] = carArr;
}
double[][] lSalidas = new double[(int)carTota][];
// { "Vacio", "Torres", "Caballos","Alfiles", "Reinas", "Reyes", "Peones" };
int c = 2;
double[][] MatEntr = new double[(int)carTota][];
int t = 0;
int pi = 0;
foreach (double[][] Mat in ListaCarz)
{
foreach (double[] vector in Mat)
{
MatEntr[t] = vector;
switch (pi)
{
case 0: lSalidas[t] = new double[] { 0, 0, 0, 0 }; break;
case 1: lSalidas[t] = new double[] { 0, 0, 0, 1 }; break;
case 2: lSalidas[t] = new double[] { 0, 0, 1, 0 }; break;
case 3: lSalidas[t] = new double[] { 0, 0, 1, 1 }; break;
case 4: lSalidas[t] = new double[] { 0, 1, 0, 0 }; break;
case 5: lSalidas[t] = new double[] { 0, 1, 0, 1 }; break;
case 6: lSalidas[t] = new double[] { 0, 1, 1, 0 }; break;
}
t++;
}
pi++;
}
ActivationNetwork rna = null;
if (!Directory.Exists("rnsa.rna"))
{
rna = CrearRNA(MatEntr, lSalidas);
rna.Save("rnsa.rna");
}
else
{
rna = (ActivationNetwork)Network.Load("rnsa.rna");
}
Bitmap [] ns = ListaEntradas[0];
foreach (Bitmap x in ns)
{
double [] text = rna.Compute(PictureAnalizer.CalcularCaracteristicasTextura(x));
int l = 0;
for (int f = 0; f < text.Length; f++)
{
if (text[f] == 1)
{
l += (int)Math.Pow(2, f);
}
}
Console.Write(l + " ");
}
// generar arbol
nodo r = new nodo(8, "s");
arbol a1 = new arbol();
r.tablero = a1.TabEjemplo;
a1.raiz = r;
arbol a2 = new arbol();
r.tablero = a2.TabEjemplo;
a2.raiz = r;
imprimirTablero(r);
nodo n1 = a1.generarMovimientos(a1.raiz, arbol.ColorBlanco);
imprimirTablero(n1);
for (int i = 0; i < 10; i++)
{
n1 = a1.generarMovimientos(n1, arbol.ColorBlanco);
imprimirTablero(n1);
nodo n2 = a2.generarMovimientos(n1, arbol.ColorNegroo);
imprimirTablero(n2);
n1 = n2;
}
}
private void button24_Click(object sender, EventArgs e)
{
/**** 1 - humbralizar ******/
Bitmap img_Exm_Ent = (Bitmap)ImagenEntrada.Image;
Bitmap Org = (Bitmap)ImagenEntrada.Image;
// conseguir histogramas para umbralizar
int [] h = PictureAnalizer.Histograma(img_Exm_Ent);
double[] hn = PictureAnalizer.HistogramaNormal(img_Exm_Ent);
int umbral = PictureAnalizer.Otsu(hn);
Bitmap img_Exm = PictureAnalizer.Umbralizar(img_Exm_Ent, umbral);
PictureAnalizer.ImagenEntrada = img_Exm;
ImagenEntrada.Image = img_Exm;
ImagenEntrada.Image.Save("ImgHumbralizada.jpeg");
ImagenEntrada.Refresh();
/**** 2 - erocionar la imagen ******/
Mascara ee = new Mascara(Mascara.PRDF_Estr_Bcdd, new Size(3, 3), new Point(1, 1));
Bitmap cv = PictureAnalizer.ErocionarImagen(img_Exm, ee, 255);
img_Exm = PictureAnalizer.ErocionarImagen(img_Exm, ee, 255);
Bitmap cn = img_Exm;
PictureAnalizer.ImagenEntrada = img_Exm;
ImagenEntrada.Image = img_Exm;
ImagenEntrada.Image.Save("ImgErocionada.jpeg");
ImagenEntrada.Refresh();
Mascara es = new Mascara(Mascara.PRDF_Estr_Cruz, new Size(3, 3), new Point(1, 1));
img_Exm = PictureAnalizer.DilatarImagen(img_Exm, es, 255);
PictureAnalizer.ImagenEntrada = img_Exm;
ImagenEntrada.Image = img_Exm;
ImagenEntrada.Image.Save("ImgDilatada.jpeg");
ImagenEntrada.Refresh();
Bitmap sa = PictureAnalizer.DibujarNegra(cn.Width, cn.Height);
for (int i = 0; i < cn.Height; i++)
{
for (int j = 0; j < cn.Width; j++)
{
int cOr = PictureAnalizer.PixelColor2Gray(img_Exm.GetPixel(j, i));
if (cOr == 255)
{
int cON = PictureAnalizer.PixelColor2Gray(cv.GetPixel(j, i));
sa.SetPixel(j, i, Color.FromArgb(cON, cON, cON));
}
}
}
ImagenEntrada.Image = sa;
Bitmap sae = PictureAnalizer.DibujarNegra(cn.Width, cn.Height);
for (int i = 0; i < cn.Height; i++)
{
for (int j = 0; j < cn.Width; j++)
{
int cOr = PictureAnalizer.PixelColor2Gray(sa.GetPixel(j, i));
if (cOr > 0)
{
int cON = PictureAnalizer.PixelColor2Gray(Org.GetPixel(j, i));
sae.SetPixel(j, i, Color.FromArgb(cON, cON, cON));
}
}
}
ImagenEntrada.Image = sae;
ImagenEntrada.Image.Save("ImgCombinada.jpeg");
ImagenEntrada.Refresh();
}
// jsm22
private void button23_Click(object sender, EventArgs e)
{
Mascara m = new Mascara(Mascara.PRDF_Estr_Bcdd, new Size(3, 3), new Point(1, 1));
ImagenEntrada.Image = PictureAnalizer.ExtBorde((Bitmap)ImagenEntrada.Image, m);
}
public static Bitmap Apertura(Bitmap ImagenOriginal, Mascara MascaraEnviada, int colorPixel)
{
Bitmap im = PictureAnalizer.DilatarImagen(PictureAnalizer.ErocionarImagen(ImagenOriginal, MascaraEnviada, colorPixel), MascaraEnviada, colorPixel);
return(im);
}
public static Bitmap ExtBorde(Bitmap ImagenOriginal, Mascara MascaraEnviada)
{
Bitmap n = PictureAnalizer.DilatarImagen(ImagenOriginal, MascaraEnviada, 255);
return(PictureAnalizer.Resta(n, ImagenOriginal));
}
public static Mascara CopiarMatriz(Mascara Origen)
{
Mascara mn = new Mascara(Origen.MascaraNumerica, Origen.Dims, Origen.Centro);
return(mn);
}
