reconocimiento de imagenes

[jachguate]

Empezado por roman

¿Podrías explicar a qué te refieres con esto?

// Saludos

vamos... supongamos que yo estoy viendo 1 a 1 los pixels que forman la imagen (que es una matriz de n x m pixels). En una imagen un punto negro será una secuencia de pixels negros... en otras palabras será 1 o mas pixels de color negro dispuestos continuamente sobre la imagen.

Si yo barro la imágen de izquierda a derecha... y hay un punto de los pixels de la columna 7 a la columna 14 de la fila 1, se da por sentado que las columnas 8, 9, 10, 11, 12 y 13 también serán pixels negros.

Mencionaba que para "puntos" con mas de un pixel de alto, habrá que idear un mecanismo para reconocer, en la fila 2 (continuando con el ejemplo) que los pixels de la columna 6 a 14 (nota el cambio de la columna inicial) pertenecen siempre al mismo punto ya contado. No es algo complicado.

Hasta luego.

[jachguate]

Otro asunto es que los pixels que componen el punto sean realmente "negros"... si no,

• habrá que idear un mecanismo de "tolerancia" para incluir grises u otros colores obscuros
• o bien un algoritmo para hacer primero una copia de la imagen en blanco y negro y trabajar sobre ella

hasta luego.

[the darkness]

o.k. muchas gracias por sus respuestas, y jachguate, me queda claro lo que me pides que haga, pero la verdad, estoy en cero referente al tratamiento de imagenesa, por tanto me estoy poniendo a investigar bastante, pero me suena logico lo que mencionas, solo te pido un favro, como puedo hacer dicho barrido y sobre que lo comparo. por que se prodria decir que verificar pixel por pixel y se comparara con colores especificos.
espero y me ayudes.
gracias

[jachguate]

si la imagen la cargas en un Bitmap, podes acceder a los pixels asi valiendote de su propiedad canvas.pixels, que es un array de 0 a width - 1, y de 0 a height - 1 de TColor.

Hasta luego.

[Amilius]

La verdad que es un sistema complejo (toda una tesis) y es muy difícil que puedas encontrar un módulo listo para contar manchas de una imagen.

Por la descripción del tipo de imagen diría que lo ideal es tratarla como escala de grises (8bits de profundidad de color, lo que da 256 niveles de gris que van de 0 a 255).

Tengo una idea simple para solucionar el problema:
cada punto vale de 0 a 255:
0=negro ,255=blanco

Eliges un punto al azar de la imagen que no esté revisado, si es más bajo que cierto umbral vas marcando esa zona en espiral (como revisado) hasta que los pixeles tengan valor más alto que otro umbral. Cuentas como 1 mancha y mides su tamaño de acuerdo al área que pintaste antes de decidir que los pixeles restantes no formaban parte de la mancha. Continuas este proceso hasta que no existan áreas de la imagen no marcadas como "revisadas".

Esto servirá si y sólo si: las manchas son circulares, la mancha más pequeña tiene un buen tamaño en pixeles, tienen buen contraste y el contraste entre manchas y fondo es constante y el fondo es también de matiz constante.

Para dar mayor potencia a un sistema de tratamiento de imágenes te recomiendo investigar algunas herramientas matemáticas como el análisis wavelet, ideal para imágenes, que permiten analizar la imagen a varias escalas y permiten realizar detección de bordes también a varias escalas, lo que también es util para eliminar frecuencias muy bajas de la imagen (gradientes en el fondo) para mejorar los resultados.

=P

Creo que escribi demasiado...

P.D.

Esto es para los que alguna vez intentaron hacer algo con "Pixels" y vieron que era muuuuuuuy lento:

/*
Esto es muchísimo más rápido que usar Pixels[x,y] (Realmente mucho más rápido), pero también más complicado y PELIGROSO, no vayan a escribir fuera del area de memoria de su bitmap!!.

OJO que el bitmap va de 0 a Height-1 y de 0 a width-1, no se salgan de límites !!
*/
//Tipos necesarios
  PuntoRGB=array[0..2] of byte;
  TlineaRGB=array[0..MAX_LINEA] of PuntoRGB;
  PlineaRGB=^TlineaRGB;

//OJO que:
CImagen = class(TBitmap)

//(Aplica un "blur" en dos pasadas a un bitmap de 24bits de profundidad de color)

//Esto está implementado a manera de incluir un método adicional:

procedure CImagen.Suavizar();
var i,j,k:integer;
    rgb1,rgb2,rgb3:PlineaRGB;
begin
  for j:=2 to Height-1 do
  begin
    rgb1:=ScanLine[j-2];
    rgb2:=ScanLine[j-1];
    rgb3:=ScanLine[j];
    for i:=0 to width-1 do
      for k:=0 to 2 do //colores
        rgb2[i,k]:=(rgb1[i,k]+rgb2[i,k] shl 1+rgb3[i,k]+3) shr 2;
  end;
  for j:=0 to Height-1 do
  begin
    rgb1:=ScanLine[j];
    for i:=2 to width-1 do
      for k:=0 to 2 do //colores
        rgb1[i-1,k]:=(rgb1[i-2,k]+rgb1[i-1,k] shl 1+rgb1[i,k]+3) shr 2;//interpolar
  end;
end;