Processamient de iMagens, Contador através de imagenes
 

Hola amigos, si alguien puede ayudarme estoy agradecido!!! estoy con un proyecto que consiste en contar objetos de una imagen BMP, las mismas estan cargadas en Timage, el funcionamiento es mas o menos como sigue abajo

Llenando la Región

La forma de explotación de la imagen en la búsqueda de colonias (regiones Blancas) es, el algoritmo de relleno al encontra el pixel blanco, recorre los cinco vecinos píxeles, como se muestra en la ilustración a continuación, al recorrer los vecinos se sigue la siguiente orden: Pixel Lateral Izquierdo (LI) , Pixel Diagonal Inferior Izquierdo(DII), Pixel Inferior (I), Pixel Diagonal Inferior Derecho(DID) Pixel Lateral Dereho (LD).

LI......Pixel I...... LD
DII.......I.......... DID

La llamada recursiva busca un pixel blanco en la orden indicada de los cinco vecinos, LI, DII, I, DID, LD. Al identificar el primer vecino como pixel blanco sel le altera el color del pixel para otra tonalidad y la direccion de este pixel e passada como parametro para la llamada recursiva, en el regreso de rutina, la busqueda por pixel blancos continuaen los demas vecinos cmo en la orden indicada, no haviendo mas pixels blancos, la rutina vuelve. Quando la primero rutina recursiva vuelve para el algoritmo e contage y un contador recibe +, cuando el rellenos de los objetos fueren concluido ya no habra colonias blancas y el contador dirá quanas colonias havian!!, lo es un poco conplicado, mi esañol no es mui BUeno, pero haver si lo entendiern un poco

Hola,
no creo que haga falta recursividad, a no ser que quieras tu implementar el floodfill. Puedes ir rastreando todos los pixels, y al encontrar uno blanco, llenar toda el area de otro color y aumentar el contador. Te dejo un ejemplo, usando el floodfill de delphi y otro casero, recursivo. (este ejemplo falla si se solapan dos zonas)

Código Delphi [-]
type
  TForm1 = class(TForm)
    Button1: TButton;
    Image1: TImage;
    Label1: TLabel;
    procedure Button1Click(Sender: TObject);
    procedure Rellena_colonia(i,j : integer; col,rel : TColor; im : TImage);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject);
var
        i,j : integer;
        colonias : integer;
        x,y,r: integer;
begin
        Image1.Canvas.Brush.Color := clBlack;
        Image1.Canvas.FillRect(Rect(0,0,Image1.Width,Image1.Height));

        Image1.Canvas.Brush.Color := clWhite;
        colonias := random(10);

        for i := 0 to colonias do
        begin
        x := random(Image1.Width);
        y := random(Image1.Height);
        Image1.Canvas.Ellipse(Rect(x,y,x+random(50),y+random(50)));
        end;

        ShowMessage(inttostr(colonias));

        colonias := 0;
        for i := 0 to Image1.Width do
        for j := 0 to Image1.Height do
        if Image1.Canvas.Pixels[i,j] = clWhite then
        begin
             rellena_colonia(i,j,clWhite,clRed,Image1);
             inc(colonias);
        end;

        Label1.Caption := inttostr(colonias);
end;

{procedure TForm1.Rellena_colonia(i,j : integer; col,rel : TColor; im : TImage);
begin
        if (i = 0) or (j = 0) or (i > Im.Width) or (i > Im.Height) then exit;
        if Im.Canvas.Pixels[i,j] <> col then exit;
        Im.Canvas.Pixels[i,j] := rel;

        rellena_colonia(i-1,j-1,col,rel,im);
        rellena_colonia(i  ,j-1,col,rel,im);
        rellena_colonia(i+1,j-1,col,rel,im);
        rellena_colonia(i-1,j  ,col,rel,im);
        rellena_colonia(i  ,j  ,col,rel,im);
        rellena_colonia(i+1,j  ,col,rel,im);
        rellena_colonia(i-1,j+1,col,rel,im);
        rellena_colonia(i  ,j+1,col,rel,im);
        rellena_colonia(i+1,j+1,col,rel,im);
end;}

procedure TForm1.Rellena_colonia(i,j : integer; col,rel : TColor; im : TImage);
begin
        Im.Canvas.Brush.Color := rel;
        Im.Canvas.FloodFill(i,j,col,fsSurface);
end;
end.

Coso el tema es que no es tan simple como eso.
Se trata de algoritmos de predicción que buscan zonas y formas en una imagen.
El objetivo de estos algoritmos es predecir donde están los objetos deseados examinando la dirección del cambio del color.

Cesar Junior, ¿los puntos blancos tienen el mismo tamaño? ¿Son siempre blancos o tienen alguna tonalidad semejante al blanco?

Me gustaría saber si haz hecho algún avance. ¿Tienes algo de código ya hecho?

Saludos,

Hola! consiste que los puntos blancos son varialbles nunk del mismo tamaño, pero si que son siempre blancos, en relacion a esto todavia no é logrado algo
exito, pero al final la idea es tener el tumero de colonias blancas,

Cualquier avance que tengas es bueno que nos digas, no necesariamente tiene que estar funcionando. Esto te lo digo para saber de que modo estás llevando a cabo el algoritmo y poder asesorarte sin tener que obligarte a cambiar demasiado tu código.

Saludos,

Hola,

Disculpen la intromisión pues no conozco de estos temas, pero me gustaría saber cuál es el problema con el algoritmo de coso. Quizá no sea óptimo, pero hasta donde veo, cuenta las colonias blancas correctamente.

// Saludos

Estuve pensando en el algoritmo que describes y me he quedado pensando ¿Cúando se da por válido un punto blanco y se explora hacia otro lado?

Tengo entendido que los algoritmos de estos tipos lo que hacen es calcular la dirección del cambio entre los colores vecinos (los 8) y reposicionarse en en la dirección donde detectan la mayor "sensibilidad". Por lo general la condición de parada y válidación del objeto se establece cuando entre los pixeles vecinos no hay cierta "sensibilidad" y/o superan un valor umbral de decisión.

El asunto aqui es que no necesariamente los puntos blancos son vecinos ni ocupan un pixel. Es posible que haya muchos pixel de distancia entre un punto blanco y otro.

Tal como describes el algoritmo, da la idea de que siempre se posiciona en el primer pixel vecino (entre los 5) blanco que encuentre ¿Y si no encuentra? ¿Que se hace? ¿Allí es cuando se da por entendido que se encontró un punto?

Me gustaría que nos dieras más referencia del tema que estás tratando.

Saludos,

para detectar la forma si que se necesitaria recursividad : se podria medir la distancia entre los puntos mas lejanos entre si, creando vectores entre ellos, eliminando los puntos que son combinaciones lineales de estos vectores y los que pertenecen a areas delimitadas 3 a 3, y mirando el numero y angulo de los vectores resultantes...claro esta q seria bastante mas complicado, pero si, se puede hacer ;)

Ejem,

¿Y bien?

???

estooo....yo claro esta que estoy de acuerdo conmigo mismo :D (a veces...) igualmente supongo q se puede mejorar, a ver si me pongo un rato y saco lo que he comentado en el otro post, que parece interesante... saludos

El algoritmo de coso funciona, y funcionará mientras que las figuras sean simples.

La cuestión es que cuando se está llevando el conteo de colonias (me gustaría saber de que: virus, hormigas, células) no es tan simple puesto que las figuras tienden ser un tanto complejas, encimarse, agruparse, etc. Emplear el FloodFill "a secas" como lo emplea coso puede conducir a un conteo erróneo, y se necesita de un algoritmo que permita determinar las semejanzas a la forma del objeto de estudio.

¿Y si consideramos la posibilidad de que la imagen tenga ruido? Una lectura basada en el algoritmo de coso es posible que arroje falsos positivos. Otro motivo más para saber si es necesario un algoritmo de predicción, tal como lo da a entender lo que busca Cesar Junior.

Debido a estas cuestiones es que le he pedido a Cesar Junior que nos aporte más información del tema.

Saludos,

en el caso que hubiese ruido, se tendria q muestrear la imagen aplicando un filtro de contrastes. En el caso q estuviesen solapadas, con ruido, y del mismo color, seria muy muy dificil que una maquina lo adivinase. Lo mejor seria en ese caso que fuesen imagenes de distinto color, o bien tener una idea aproximada de su forma, o bien de su tamaño, para asi acotar el area de cada entidad. Tambien se podria preparar una red neuronal para, tras sucesivas iteraciones, encontrar una media de forma, tamaño, color de cada objeto y asi intentar predecir el numero de colonias (predecir, pues no seria un algoritmo determinante) existente en la imagen.

si bien las circumstancias que comenta delphius harian el algoritmo mucho mas general, no creo que sean (excepto el solapamiento, que se tendria q resolver con distintos colores por figura) necesarias para nuestro amigo cesar junior. en el caso q si, le recomiendo una busqueda de 'redes neuronales reconocimiento de objetos' por google. Hay algunos ejemplos realmente interesantes, que parecen sacados de ciencia ficcion, si esto hoy en dia existe. saludos, voy a cenar ;) hasta luego

Pero, ¿no estás presuponiendo demasiado Delphius? En el algoritmo original planteado por César, no veo que se intente determinar distintas formas, sólo el número de colonias blancas. Digamos que en esta imagen



hay dos estrellas y dos cruces, pero, si nos limitamos a contar manchas blancas, pues yo veo tres.

// Saludos

Tal vez amigo, tal vez. Yo de entrada me preguntaba si por casualidad la cosas pueden resolverse del modo simple, o del modo complicado.

Yo por las dudas, yo prefiero agarrar el cañón. No vaya a ser cosa...:p:D

Y bueno, si se trata de contar manchas si, tal vez baste y sobre con algo similar a lo que pasó coso.

Saludos,

La idéa basica es essa, en lo q dice a respecto de la imagen, ella reciben un pré tratamiento, de filtro como la Binarización, o sea que se separa el fondo del objeto, asi como el ejemplo arriba, el algoritmo se llama Region Filling, e intentado el algoritmo de coso peo no me há dado resultado, lo estoi estudiando para ver si lo hago algunas modificaciones

Un ejemplo de imagen, iaginen estos nodulos como la paret blanca y ele fondo como la como negro, al final deve retornar um total de 9 nodulos

http://www.nitragin.com.ar/brasil/im...oc/g_inoc7.jpg

Pues yo también me voy a meter :D Si lo que queremos es contar manchas, porque no difuminamos bien la imagen, y luego le aplicamos un "umbral". Seguramente las formas que queden sean lo bastante simples y definidas para que no tengamos problemas en encontrarlas.

De todas formas seria interesante un algoritmo que además de localizar la mancha nos dijera su tamaño, no es lo mismo una mancha de 1 pixels que de 100x100, podría interesarnos descartar las que fueran demasiado pequeñas

¿Eso quiere decir que tu también le apuntas con el cañón?:D:rolleyes:;)
Y bueno, habría que considerar hasta que punto le es aplicable y/o útil a Cesar.

Saludos,

Esso estaria interessante, pues ya que todavia no e encontrado una imagen donde haya ese problema, pero eso no quiere decir q no vaya a ocurrir:D

hola,

Código Delphi [-]
 
function TForm1.Lluminositat(c : TColor): integer;
var
        r,g,b : integer;
        act : integer;
begin
       r := Red(c);
       g := Green(c);
       b := Blue(c);
       act := r+g+b;
       Lluminositat := act div 3;
end;
function TForm1.Red(c : TColor) : integer;
begin
        Red := c and $FF;
end;
function TForm1.Green(c : TColor) : integer;
begin
        Green := (c and $FF00) div $100;
end;
function TForm1.Blue(c : TColor) : integer;
begin
        Blue := (c and $FF0000) div $10000;
end;

si haces algo como

Código Delphi [-]
 
procedure filtro_de_contraste(cn : TCanvas);
var
i,j : integer;
begin
for i := 0 to cn.Width do
for j := 0 to cn.Height do
begin
 if Lluminositat(cn.Pixels[i,j]) > 128 then cn.Pixels[i,j] := clWhite
 else cn.Pixels[i,j] := clBlack;
end;
end;

tendras un filtro de contraste bastante aproximado. Solo hara falta aplicarlo antes. Si lo que quieres son deducir la direccion de degradado del color, puedes hacerlo tambien buscando el punto de maximo brillo (mediante lluminositat), restar con la luminosidad de los adyacentes, y aquel donde la diferencia (el gradiente) sea maximo, es el mas proximo al borde, aunque no creo que lo necesites.

Off-topic
 

Coso quería preguntarte, esto como off-topic, ¿porqué el uso de Pixels[]?:confused:
He visto que en otros hilos que tratas sobre el tema de pixeles, en tus códigos usas Pixels.
Yo me acostumbré a emplear Scanline. Tal vez se necesita un poco más de código pero me parece que se consigue mejor perfomance.

Yo he probado con imagenes relativamente grandes y el uso de scanLine por sobre Pixels se nota.

Saludos,

para q se entienda el algoritmo tansolo, luego si se tiene que optimizar, si se puede usar scanline o directamente operar en memoria

procedure Comic(Img: TPicture; Umbral: Integer);
var
Bitmap: TBitmap;
P1,P2,P3,P4: PByte;
i,j: Integer;
begin
Bitmap:= TBitmap.Create;
try
Bitmap.Width:= Img.Width;
Bitmap.Height:= Img.Height;
Bitmap.Canvas.Draw(0,0,Img.Graphic);
if not (Img.Graphic is TBitmap) then
Img.Assign(Bitmap);
Img.Bitmap.PixelFormat:= pf24bit;
Bitmap.PixelFormat:= pf24bit;
for j:= -1 to Bitmap.Height - 2 do
begin
// Ajustamos el borde superior
if j < 0 then
P1:= Bitmap.ScanLine[0]
else
P1:= Bitmap.ScanLine[j];
P2:= Bitmap.ScanLine[j+1];
// Ajustamos el borde inferior
if j > Bitmap.Height - 3 then
P3:= Bitmap.ScanLine[Bitmap.Height - 1]
else
P3:= Bitmap.ScanLine[j+2];
P4:= Img.Bitmap.ScanLine[j+1];
// Primera columna
PFila(P4)[1]:=
Calcular(PFila(P1),PFila(P2),PFila(P3),1,2,Umbral);
for i:= 0 to Bitmap.Width - 3 do
begin
PFila(P4)[2]:=
Calcular(PFila(P1),PFila(P2),PFila(P3),2,3,Umbral);
inc(P1,Sizeof(TRGB));
inc(P2,Sizeof(TRGB));
inc(P3,Sizeof(TRGB));
inc(P4,Sizeof(TRGB));
end;
// Ultima columna
PFila(P4)[2]:=
Calcular(PFila(P1),PFila(P2),PFila(P3),2,2,Umbral);
end;
finally
Bitmap.Free;
end;
end;


Esto que fue postado aqui da un resultado mui bueno, e intentado trabajar con el primer algoritmo que me passaste pero no logre exito con el, tbm é intentado el recursivo pero tampoco me dio resultados, cae que parece simples, pero ya veo q no lo es tanto

procedure limiar(ABmp: TBitmap);
var
c: TCursor;
x, y: Integer;
R, G, B: Byte;
ColorRGB: LongInt;
HCLR: Byte;
begin
Li := Limiarizar; // variable global q recibe el valor de Limiar
c := Screen.Cursor;
Screen.Cursor := crHourGlass;
for y := 0 to (ABmp.Height - 1) do
for x := 0 to (ABmp.Width - 1) do begin
ColorRGB := ColorToRGB(ABmp.Canvas.Pixels[x, y]);
// obtém as cores da paleta
R := GetRValue(ColorRGB);
G := GetGValue(ColorRGB);
B := GetBValue(ColorRGB);
// compara valor
HCLR := 0;
if R > Li then HCLR := 255;
if G > Li then HCLR := 255;
if B > Li then HCLR := 255;
// converte para tons de cinza
R := HCLR;
G := HCLR;
B := HCLR;


// aplica a nova cor ao pixel
ABmp.Canvas.Pixels[x, y] := PaletteRGB(R, G, B);
end;
Screen.Cursor := c;
end;


Consiste que con esto conseguimos binarizar la imagen de acuerdo con la necessidad de cada, o sea que como una imagen en escala de grizes varia de 0 a 255 ejemplo de lmiar 127 todo aquells pixels q estean abajo de 127 van a 0 (negro) y todos los que estean arriba de 127 van a 255(blanco), esto da resultados mas preciso dependiendo de la imagen, al resultado de esto estoy intentando implementar algo

Hola Cesar Junior,
¿Avanzaste en algo?

Cuando coloques código, por favor usa la etiquetas [ DELPHI ] [ /DELPHI ] (sin los espacios) para que el código se resalte mejor.

Saludos,

es extraño, si consigues pasarlo todo a manchas blancas, el primer algoritmo te las cuenta...¿porque te falla?

En realidad no me las cuenta, me la passa todo lo que es blanco a negro, y depues dibuja una elipse Randon, q la passa a rojo, es extraño tenter cambiar algunas cosas pero no me dio resultado

ah....vamos, que no entendiste nada

El algoritmo esta integrado en un ejemplo que pinta todo de negro y luego dibuja unas elipses blancas para contarlas. Luego recorre cada pixel y si encuentra alguno de color blanco, lo pinta de otro color y aumenta el contador de zonas. La parte util para ti supongo que tendria que ser aquella que recorre cada pixel y rellena, y no la que dibuja las elipses.

Si, en verdad que tenes razon, es que soy aprendiz, y me di cuenta de q no estava entendiendo nada, rs.. hize unos experimentos com grano de maíz, y tu algoritmo funciona muy bien, solo ay q estudiar una forma de mejorar la imagen cuando loa sgranos estan muy juntos me da un valor aproximado, pero te agradesco mucho q en reaqlidad funciona muy bien!!!

Y quedo asi

Código Delphi [-]
 
procedure TForm1.Rellena_colonia(i,j : integer; col,rel : TColor; im : TImage);
begin
        Im.Canvas.Brush.Color := rel;
        Im.Canvas.FloodFill(i,j,col,fsSurface);
end;
 
 
procedure TForm1.BitBtn6Click(Sender: TObject);
var
        i,j : integer;
        colonias : integer;
begin
        colonias := 0;
        for i := 0 to Image1.Width do
        for j := 0 to Image1.Height do
        if Image1.Canvas.Pixels[i,j] = clWhite then
        begin
             rellena_colonia(i,j,clWhite,clRed,Image1);
             inc(colonias);
        end;
        Label2.Caption := inttostr(colonias);
        Label2.Visible:=true;
        ShowMessage(inttostr(Colonias));
end;

Esto funciona mui bien, cuando la imagen esta bien definida

Esto de definir un tamanho con un algoritmo se ve interessante que camino devo seguir?

Hola de nuevo Cesar Junior,

Código Delphi [-]
        colonias := 0;
        for i := 0 to Image1.Width do
        for j := 0 to Image1.Height do
        if Image1.Canvas.Pixels[i,j] = clWhite then
        begin 
             tam := 0;
             rellena_colonia(i,j,clWhite,clRed,Image1,tam);
             ShowMessage(inttostr(tam)); // tamaño de colonia
             inc(colonias);
        end;
        Label1.Caption := inttostr(colonias);
end;

procedure TForm1.Rellena_colonia(i,j : integer; col,rel : TColor; im : TImage; var tam : integer);
begin
        if (i = 0) or (j = 0) or (i > Im.Width) or (i > Im.Height) then exit;
        if Im.Canvas.Pixels[i,j] <> col then exit;
        Im.Canvas.Pixels[i,j] := rel;
        inc(tam);

        rellena_colonia(i-1,j-1,col,rel,im,tam);
        rellena_colonia(i  ,j-1,col,rel,im,tam);
        rellena_colonia(i+1,j-1,col,rel,im,tam);
        rellena_colonia(i-1,j  ,col,rel,im,tam);
        rellena_colonia(i  ,j  ,col,rel,im,tam);
        rellena_colonia(i+1,j  ,col,rel,im,tam);
        rellena_colonia(i-1,j+1,col,rel,im,tam);
        rellena_colonia(i  ,j+1,col,rel,im,tam);
        rellena_colonia(i+1,j+1,col,rel,im,tam);
end;

te ira contando los tamaños

Sensacional! esto funciona de maravilha!!! ahora voia definir cuales son los intereses para la contage, felicitaciones!!! se nota que para ti es de una simplicidad, cuando ya para mi parecia un monstro de 7 cabezas, asi q tenga los resultados posto aqui para mostrarles, des de ya gracias a todos con las ideas el tiepo tomado, a Coso, [DELPHIUS], seoane!!!

de nada ;)