Processamient de iMagens, Contador através de imagenes

[[Delphius]]

Empezado por roman

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...

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

Saludos,

[Cesar Junior]

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

[Cesar Junior]

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

[[seoane]]

Pues yo también me voy a meter 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

[[Delphius]]

Empezado por seoane

Pues yo también me voy a meter 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?
Y bueno, habría que considerar hasta que punto le es aplicable y/o útil a Cesar.

Saludos,

[Cesar Junior]

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

[[coso]]

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.

[[Delphius]]

Coso quería preguntarte, esto como off-topic, ¿porqué el uso de Pixels[]?
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,

[[coso]]

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

[Cesar Junior]

Empezado por coso

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.

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

[Cesar Junior]

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

[[Delphius]]

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,

[[coso]]

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

[Cesar Junior]

Empezado por seoane

Pues yo también me voy a meter 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

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

[[coso]]

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

[Cesar Junior]

Empezado por coso

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!!!

[[coso]]

de nada