// 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);
}
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);
}
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);
}
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 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 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);
}
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);
}
public static Bitmap Resta(Bitmap ImagenA, Bitmap ImagenB)
{
Bitmap c = PictureAnalizer.DibujarNegra(ImagenA.Width, ImagenA.Height);
for (int i = 0; i < ImagenB.Height; i++)
{
for (int j = 0; j < ImagenB.Width; j++)
{
Color n = ImagenA.GetPixel(j, i);
Color m = ImagenB.GetPixel(j, i);
if (m != n)
{
c.SetPixel(j, i, n);
}
}
}
return(c);
}
public static Bitmap MoverPuntos(Bitmap Img_Entrada, Bitmap imgCompare)
{
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));
imgLines.SetPixel(j, i, Color.FromArgb(c, c, c));
if (c > 0)
{
int cYan, cYPs, cXan, cXPs;
if (i - 1 > 0 && i + 1 < Img_Entrada.Height)
{
cYan = PictureAnalizer.PixelColor2Gray(imgCompare.GetPixel(j, i - 1));
cYPs = PictureAnalizer.PixelColor2Gray(imgCompare.GetPixel(j, i + 1));
if (cYan > 0 || cYPs > 0)
{
imgLines.SetPixel(j, i - 1, Color.FromArgb(c, c, c));
imgLines.SetPixel(j, i + 1, Color.FromArgb(c, c, c));
}
}
if (j - 1 > 0 || j + 1 < Img_Entrada.Width)
{
cXan = PictureAnalizer.PixelColor2Gray(imgCompare.GetPixel(j - 1, i));
cXPs = PictureAnalizer.PixelColor2Gray(imgCompare.GetPixel(j + 1, i));
if (cXan > 0 || cXPs > 0)
{
imgLines.SetPixel(j - 1, i, Color.FromArgb(c, c, c));
imgLines.SetPixel(j + 1, i, Color.FromArgb(c, c, c));
}
}
}
}
}
return(imgLines);
}
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();
}