public static Bitmap MostrarAcms( )
{
double porcentaje = 0;
double u = (porcentaje / 100) * MaximoMascaraMatriz(PictureAnalizer.AcumuladorGeneral);
Bitmap m = PictureAnalizer.DibujarNegra(PictureAnalizer.AcumuladorGeneral.Dims.Width, PictureAnalizer.AcumuladorGeneral.Dims.Height);
for (int i = 0; i < PictureAnalizer.AcumuladorGeneral.Dims.Height; i++)
{
for (int j = 0; j < PictureAnalizer.AcumuladorGeneral.Dims.Width; j++)
{
int c = (int)PictureAnalizer.AcumuladorGeneral.MascaraNumerica[j, i];
if (c >= u)
{
c = PictureAnalizer.NormalizarPixel(c);
m.SetPixel(j, i, Color.FromArgb(c, c, c));
}
else
{
m.SetPixel(j, i, Color.Black);
}
}
}
return(m);
}
// subdividir la imagen
public static Bitmap[,] DividirImagen(Bitmap Img_ImgOriginal, int divNum)
{
// generar una matriz para guardar cada casilla
Bitmap[,] MatrizImg = new Bitmap[divNum, divNum];
// dividir las dimenciones de la imagen
int h, w;
h = (int)Math.Round((double)Img_ImgOriginal.Height / divNum, 0);
w = (int)Math.Round((double)Img_ImgOriginal.Width / divNum, 0);
for (int i = 0; i < divNum; i++)
{
for (int j = 0; j < divNum; j++)
{
MatrizImg[j, i] = new Bitmap(w, h);
for (int y = i * h, s = 0; y < (h - 1) * (i + 1); y++, s++)
{
for (int x = j * w, n = 0; x < (w - 1) * (j + 1); x++, n++)
{
int c = PictureAnalizer.PixelColor2Gray(Img_ImgOriginal.GetPixel(x, y));
MatrizImg[j, i].SetPixel(n, s, Color.FromArgb(c, c, c));
}
}
}
}
return(MatrizImg);
}
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);
}
// cerradura de una imagen
private void button6_Click(object sender, EventArgs e)
{
int color = (int)Selector_Brillo.Value;
PictureAnalizer.ImagenEntrada = PictureAnalizer.Cerradura(PictureAnalizer.ImagenEntrada, conseguirMascara(Txt_Otros), color);
ImagenEntrada.Image = PictureAnalizer.ImagenEntrada;
}
// 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);
}
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 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);
}
// 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;
}
public static double [] CalcularCaracteristicasTextura(Bitmap Im_ent)
{
Dictionary <int, double>[] hsr = PictureAnalizer.HistogramasSumaDiferencia(Im_ent);
double[] op = PictureAnalizer.CaracteristicasTextura(hsr[0], hsr[1]);
return(op);
}
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();
}
// otsu automatico
private void button1_Click(object sender, EventArgs e)
{
int[] h = PictureAnalizer.Histograma((Bitmap)ImagenEntrada.Image);
double[] hn = PictureAnalizer.HistogramaNormal((Bitmap)ImagenEntrada.Image);
int t = PictureAnalizer.Otsu(hn);
MessageBox.Show("", t.ToString());
ImagenEntrada.Image = PictureAnalizer.Umbralizar((Bitmap)ImagenEntrada.Image, t);
}
public static double [] HistogramaNormal(Bitmap ImagenColor)
{
int[] h = PictureAnalizer.Histograma(ImagenColor);
double [] HistNorm = new double[256];
for (int i = 0; i < 256; i++)
{
HistNorm[i] = h[i] / ((double)ImagenColor.Width * ImagenColor.Height);
}
return(HistNorm);
}
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 int [] HistogramaAcumulado(Bitmap input)
{
int [] h = PictureAnalizer.Histograma(input);
int[] Hacum = new int[256];
for (int i = 1; i < 256; i++)
{
Hacum[i] = Hacum[i - 1] + h[i];
}
return(Hacum);
}
private void otsuToolStripMenuItem_Click(object sender, EventArgs e)
{
Analizador.SetImagenSalida((Bitmap)ImagenEntrada.Image);
// crear un histograma
int[] h = PictureAnalizer.Histograma(PictureAnalizer.ImagenEntrada);
double[] hn = PictureAnalizer.HistogramaNormal(PictureAnalizer.ImagenEntrada);
// realizar una umbralizacion
int t = PictureAnalizer.Otsu(hn);
this.ImagenSalida.Image = PictureAnalizer.Umbralizar(PictureAnalizer.ImagenEntrada, t);
MessageBox.Show("Umbral Optimo " + t.ToString(), "Umbral optimo");
}
// probar todas las imagenes de una carpeta
private void desdeCarpetaToolStripMenuItem_Click(object sender, EventArgs e)
{
FolderBrowserDialog c = new FolderBrowserDialog();
c.ShowDialog();
string rutaCarpetaTest = c.SelectedPath;
// buscar todos lo archivos de imagen en el directorio
DirectoryInfo dirs = new DirectoryInfo(rutaCarpetaTest);
// recorrer cada archivo en el directorio
int b = 0;
foreach (var im in dirs.GetFiles("*.jpg", SearchOption.AllDirectories))
{
Bitmap imEnt = new Bitmap(im.FullName);
Analizador.SetImagenEntrada(imEnt);
Analizador.SetImagenSalida(PictureAnalizer.ImagenColor2Gray(imEnt));
ImagenEntrada.Image = PictureAnalizer.ImagenEntrada;
ImagenSalida.Image = PictureAnalizer.ImagenEntrada;
ImagenEntrada.Refresh();
ImagenSalida.Refresh();
System.Threading.Thread.Sleep(100);
// crear un histograma
int[] h = PictureAnalizer.Histograma(PictureAnalizer.ImagenEntrada);
double[] hn = PictureAnalizer.HistogramaNormal(PictureAnalizer.ImagenEntrada);
// realizar una umbralizacion
int t = PictureAnalizer.Otsu(hn);
this.ImagenSalida.Image = PictureAnalizer.Umbralizar(PictureAnalizer.ImagenEntrada, t);
imEnt = (Bitmap)this.ImagenSalida.Image;
//PictureAnalizer.GuardarImagenSalida((Bitmap) PictureAnalizer.ImagenEntrada, this.RutaGuardado + "\\OtsuEntrada" + b.ToString() + im.Name );
PictureAnalizer.GuardarImagenSalida((Bitmap)this.ImagenSalida.Image, this.RutaGuardado + "\\OtsuSalida" + b.ToString() + im.Name);
PictureAnalizer.GuardarImagenSalida(PictureAnalizer.DilatarImagen(imEnt, this.MascaraActual, 255), this.RutaGuardado + "\\SalidaDilatada" + b.ToString() + im.Name);
PictureAnalizer.GuardarImagenSalida(PictureAnalizer.ErocionarImagen(imEnt, this.MascaraActual, 255), this.RutaGuardado + "\\SalidaErocionada" + b.ToString() + im.Name);
// PictureAnalizer.GuardarImagenSalida( PictureAnalizer.Cerradura(imEnt, this.MascaraActual), this.RutaGuardado + "\\SalidaCerradura" + b.ToString() + im.Name);
// PictureAnalizer.GuardarImagenSalida( PictureAnalizer.Apertura(imEnt, this.MascaraActual), this.RutaGuardado + "\\SalidaApertura" + b.ToString() + im.Name);
PictureAnalizer.GuardarImagenSalida(PictureAnalizer.ExtBorde(imEnt, this.MascaraActual), this.RutaGuardado + "\\SalidaBorde" + b.ToString() + im.Name);
b++;
ImagenSalida.Refresh();
System.Threading.Thread.Sleep(100);
}
}
public static Bitmap ImagenColor2Gray(Bitmap ImagenColor)
{
Bitmap ImagenGray = new Bitmap(ImagenColor.Width, ImagenColor.Height);
for (int i = 0; i < ImagenColor.Height; i++)
{
for (int j = 0; j < ImagenColor.Width; j++)
{
int c = PictureAnalizer.PixelColor2Gray(ImagenColor.GetPixel(j, i));
ImagenGray.SetPixel(j, i, Color.FromArgb(c, c, c));
}
}
return(ImagenGray);
}
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 static int [] Histograma(Bitmap ImagenEntradaGray)
{
int[] hist = new int[256];
for (int i = 0; i < ImagenEntradaGray.Height; i++)
{
for (int j = 0; j < ImagenEntradaGray.Width; j++)
{
int color = PictureAnalizer.PixelColor2Gray(ImagenEntradaGray.GetPixel(j, i));
hist[color] += 1;
}
}
return(hist);
}
private void button19_Click(object sender, EventArgs e)
{
Dictionary <int, double>[] Hsr = PictureAnalizer.HistogramasSumaDiferencia(PictureAnalizer.ImagenEntrada);
PictureAnalizer.HNormSumasDifecs = Hsr;
Bitmap[] img_Text = PictureAnalizer.ImagenDeTextura(PictureAnalizer.ImagenEntrada, PictureAnalizer.HNormSumasDifecs);
pc_S1.Image = img_Text[0];
pc_s2.Image = img_Text[1];
pc_s3.Image = img_Text[2];
pc_s4.Image = img_Text[3];
pc_s5.Image = img_Text[4];
pc_s6.Image = img_Text[5];
}
private void button18_Click(object sender, EventArgs e)
{
Dictionary <int, double>[] Hsr = PictureAnalizer.HistogramasSumaDiferencia(PictureAnalizer.ImagenEntrada);
// media, varianza, homogen, energia, entropia, contraste
double[] Carc = PictureAnalizer.CaracteristicasTextura(Hsr[0], Hsr[1]);
lbl_Textr.Text = "";
lbl_Textr.Text = " Media: " + Math.Round(Carc[0]) + "\n" + " Varianza: " + Math.Round(Carc[1]) + "\n" + " Homogeneidad: " + Math.Round(Carc[2]) + "\n"
+ " Energia: " + Math.Round(Carc[3]) + "\n" + " Entropia: " + Math.Round(Carc[4]) + "\n" + " Contraste: " + Math.Round(Carc[5]) + "\n";
PictureAnalizer.HNormSumasDifecs = Hsr;
int c = 0;
}
private void ToolButCargar_Click(object sender, EventArgs e)
{
// cargar una imagen
OpenFileDialog f = new OpenFileDialog();
f.ShowDialog();
f.OpenFile();
string rutaImagenEntrada = f.FileName;
// fijar imagen de entrada y de salida(en escala de grices)
Analizador.SetImagenEntrada(PictureAnalizer.ImagenColor2Gray((Bitmap)(Image.FromFile(rutaImagenEntrada))));
// fijar imaenes en la gui
ImagenEntrada.Image = PictureAnalizer.ImagenEntrada;
}
public static Bitmap CambiarBrillo(Bitmap ImagenSinBrillo, double brillo)
{
Bitmap n = PictureAnalizer.DibujarNegra(ImagenSinBrillo.Width, ImagenSinBrillo.Height);
for (int i = 0; i < n.Height; i++)
{
for (int j = 0; j < n.Width; j++)
{
Color c = ImagenSinBrillo.GetPixel(j, i);
int ViejoC = PictureAnalizer.PixelColor2Gray(c);
int NuevoC = PictureAnalizer.NormalizarPixel(ViejoC + Convert.ToInt32(brillo));
n.SetPixel(j, i, Color.FromArgb(NuevoC, NuevoC, NuevoC));
}
}
return(n);
}
public static Bitmap DibujarCuadradoEn(int DimX, int DimY, int dimX, int dimY, Point inicio, Color c)
{
Bitmap img = PictureAnalizer.DibujarNegra(DimX, DimY);
for (int i = inicio.Y; i < dimY; i++)
{
for (int j = inicio.X; j < dimX; j++)
{
if (i < img.Height && j < img.Width)
{
img.SetPixel(j, i, c);
}
}
}
return(img);
}
private void combinarQrsToolStripMenuItem_Click(object sender, EventArgs e)
{
// poner los pixeles de la imagen obtenida en rojo
for (int i = 0; i < PictureAnalizer.ImagenEntrada.Height; i++)
{
for (int j = 0; j < PictureAnalizer.ImagenEntrada.Width; j++)
{
int c = PictureAnalizer.PixelColor2Gray(PictureAnalizer.ImagenEntrada.GetPixel(j, i));
if (c == 0)
{
ImgOriginal.SetPixel(j, i, Color.Red);
}
}
}
ImagenEntrada.Image = ImgOriginal;
}
public static Bitmap MoverInvertido(Bitmap imgEntrada, int ColorOrigen)
{
Bitmap imgExt = new Bitmap(imgEntrada.Width, imgEntrada.Height);
for (int i = 0; i < imgEntrada.Height; i++)
{
for (int j = 0; j < imgEntrada.Width; j++)
{
int c = PictureAnalizer.PixelColor2Gray(ImagenEntrada.GetPixel(j, i));
if (c == ColorOrigen)
{
imgExt.SetPixel(j, i, Color.FromArgb(c, c, c));
}
}
}
return(imgExt);
}
public static List <Point> PuntosInteres(Bitmap ImagenEntrada, int c)
{
List <Point> lisp = new List <Point>();
for (int i = 0; i < ImagenEntrada.Height; i++)
{
for (int j = 0; j < ImagenEntrada.Width; j++)
{
int C = PictureAnalizer.PixelColor2Gray(ImagenEntrada.GetPixel(j, i));
if (c == C)
{
Point p = new Point(j, i);
lisp.Add(p);
}
}
}
return(lisp);
}
public static Bitmap ResaltarLineas(Bitmap Img_Entrada)
{
Bitmap imgLines = PictureAnalizer.DibujarNegra(Img_Entrada.Width, Img_Entrada.Height);
for (int i = 0; i < Img_Entrada.Height; i++)
{
for (int j = 0; j < Img_Entrada.Width; j++)
{
bool x = false, y = false;
int c = PictureAnalizer.PixelColor2Gray(Img_Entrada.GetPixel(j, i));
if (c > 0)
{
int cYan, cYPs, cXan, cXPs;
if (i - 1 > 0 && i + 1 < Img_Entrada.Height)
{
cYan = PictureAnalizer.PixelColor2Gray(Img_Entrada.GetPixel(j, i - 1));
cYPs = PictureAnalizer.PixelColor2Gray(Img_Entrada.GetPixel(j, i + 1));
if (cYan > 0 && cYPs > 0)
{
y = true;
}
}
if (j - 1 > 0 && j + 1 < Img_Entrada.Width)
{
cXan = PictureAnalizer.PixelColor2Gray(Img_Entrada.GetPixel(j - 1, i));
cXPs = PictureAnalizer.PixelColor2Gray(Img_Entrada.GetPixel(j + 1, i));
if (cXan > 0 && cXPs > 0)
{
x = true;
}
}
if (x && y)
{
imgLines.SetPixel(j, i, Color.White);
}
}
}
}
return(imgLines);
}
