Error Invalid Floating Operation

[[Delphius]]

hola foristas,

Buenas, les escribo en esta ocasión porque no logro explicarme... porque en algunas ocasiones, cuando pruebo mi algoritmo anda, y en otras no. Veran, me levanta un error que dice Invalid floating Operation... un error muy simple de corregir... pero ya mi cerebro se me hizo añicos.

Tengo que implementar funciones de tratamiento de imagen. Y me estan saliendo bárbaras... pero he llegado a una, que se denomina flitrado. El algoritmo es sencillo, en pocas palabras, pero rompe cocos...

El filtrado modifica el valor de un pixel mediante un promediado entre los pixeles vecinos. Para llevar el promediado se arma una plantilla (matriz) de 3x3 con valores porcentuales (es decir que la suma final de todos es 1 o 100%) no necesariamente iguales. Dependiendo de estos valores se consiguen varios efectos.
A medida que se exploran los pixeles se "superpone la plantilla" sobre la imagen y se aplica la siguiente operacion:

PtoImg2(x,y) = Sumatoria( PtoImg1(i,j) * Plantilla(i,j) )

Es decir que por cada "vecino" en la posición (i,j) se lo multplica con el valor porcentual en la plantilla en dicha posición y se suma. Por tanto, se tiene que x-1 <= i <= x+1 y en forma análoga para y. El pixel a analizar corresponde a la situacion en que (x = i,y = j) es decir al del centro de la plantilla.


Es muy extraño, he realido cambios una y otra vez, y siempre hago las pruebas con las mismas imagenes... el error sigue...
Adjunto el código (pas y dcu). La funcion está declarada en USpaceOperations.

Como se que en esta comunidad hay mentes brillantes... de seguro hay alguien que pueda darme un cascarron y me dice.. "mira @%$ el error está aca..." Se que debe ser una taradez... pero para mi es algo de que lleva horas...

Desde ya muchas gracias,

[[seoane]]

Lo siento Delphius, pero no encuentro donde puede estar el error en tu código. Pero mirando tu código, me entraron ganas de hacer teclear algo de código yo. Espero que no te moleste que lo ponga por aquí:

Código Delphi [-]
type
  TRGB = array[1..3] of Byte;
  PRGB = ^TRGB;
  TFila = array[1..3] of TRGB;
  PFila = ^TFila;

const
  Filtro : array[1..3,1..3] of Integer =
    (
     (10,10,10),
     (10,10,10),
     (10,10,10)
    );

procedure Filtrar(Img: TPicture);
var
  Bitmap: TBitmap;
  P1,P2,P3,P4: PByte;
  i,j,k,t: 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;
    t:= 0;
    for i:= 1 to 3 do
      for j:= 1 to 3 do
        inc(t,filtro[i,j]);
    for j:= 0 to Bitmap.Height - 3 do
    begin
      P1:= Bitmap.ScanLine[j];
      P2:= Bitmap.ScanLine[j+1];
      P3:= Bitmap.ScanLine[j+2];
      P4:= Img.Bitmap.ScanLine[j+1];
      for i:= 0 to Bitmap.Width - 3 do
      begin
        for k:= 1 to 3 do
        begin
          PFila(P4)[2][k]:=
            (
             (PFila(P1)[1][k]*Filtro[1,1]) +
             (PFila(P1)[2][k]*Filtro[1,2]) +
             (PFila(P1)[3][k]*Filtro[1,3]) +

             (PFila(P2)[1][k]*Filtro[2,1]) +
             (PFila(P2)[2][k]*Filtro[2,2]) +
             (PFila(P2)[3][k]*Filtro[2,3]) +

             (PFila(P3)[1][k]*Filtro[3,1]) +
             (PFila(P3)[2][k]*Filtro[3,2]) +
             (PFila(P3)[3][k]*Filtro[3,3])
            ) div t;
        end;
        inc(P1,Sizeof(TRGB));
        inc(P2,Sizeof(TRGB));
        inc(P3,Sizeof(TRGB));
        inc(P4,Sizeof(TRGB));
      end;
    end;
  finally
    Bitmap.Free;
  end;
end;

Por ejemplo, si tenemos una imagen cargada en un TImage:

Código Delphi [-]
  Filtrar(Image1.Picture);
  Image1.Refresh;

[[seoane]]

Jeje, yo sigo poniendo código. Pero es que el tema me gusto.

Este es un pequeño "truco" que me explicaron hace tiempo para eliminar el moiré, aunque también lo podríamos utilizar para eliminar el ruido de una imagen. Se basa en aplicar el filtro varias veces hasta obtener una imagen muy suavizada, entonces fusionamos la imagen resultante con la imagen original.

Código Delphi [-]
type
  TRGB = array[1..3] of Byte;
  PRGB = ^TRGB;
  TFila = array[1..3] of TRGB;
  PFila = ^TFila;

const
  Filtro : array[1..3,1..3] of Integer =
    (
     (10,10,10),
     (10,10,10),
     (10,10,10)
    );

procedure Filtrar(Img: TPicture);
var
  Bitmap: TBitmap;
  P1,P2,P3,P4: PByte;
  i,j,k,t: 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;
    t:= 0;
    for i:= 1 to 3 do
      for j:= 1 to 3 do
        inc(t,filtro[i,j]);
    for j:= 0 to Bitmap.Height - 3 do
    begin
      P1:= Bitmap.ScanLine[j];
      P2:= Bitmap.ScanLine[j+1];
      P3:= Bitmap.ScanLine[j+2];
      P4:= Img.Bitmap.ScanLine[j+1];
      for i:= 0 to Bitmap.Width - 3 do
      begin
        for k:= 1 to 3 do
        begin
          PFila(P4)[2][k]:=
            (
             (PFila(P1)[1][k]*Filtro[1,1]) +
             (PFila(P1)[2][k]*Filtro[1,2]) +
             (PFila(P1)[3][k]*Filtro[1,3]) +

             (PFila(P2)[1][k]*Filtro[2,1]) +
             (PFila(P2)[2][k]*Filtro[2,2]) +
             (PFila(P2)[3][k]*Filtro[2,3]) +

             (PFila(P3)[1][k]*Filtro[3,1]) +
             (PFila(P3)[2][k]*Filtro[3,2]) +
             (PFila(P3)[3][k]*Filtro[3,3])
            ) div t;
        end;
        inc(P1,Sizeof(TRGB));
        inc(P2,Sizeof(TRGB));
        inc(P3,Sizeof(TRGB));
        inc(P4,Sizeof(TRGB));
      end;
    end;
  finally
    Bitmap.Free;
  end;
end;

// Aplicamos el filtro varias veces y luego lo fusionamos con el original
procedure FiltrarYCombinar(Img: TPicture; n: integer);
var
  Bitmap: TBitmap;
  P1, P2: ^TRGB;
  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 i:=1 to n do
      Filtrar(Img);
    for j:= 0 to Bitmap.Height - 1 do
    begin
      P1:= Img.Bitmap.ScanLine[j];
      P2:= Bitmap.ScanLine[j];
      for i:= 0 to Bitmap.Width - 1 do
      begin
        P1^[1]:= (P1^[1] + P2^[1]) shr 1;
        P1^[2]:= (P1^[2] + P2^[2]) shr 1;
        P1^[3]:= (P1^[3] + P2^[3]) shr 1;
        inc(P1);
        inc(P2);
      end;
    end;
  finally
    Bitmap.Free;
  end;
end;


// Por ejemplo, si tenemos una imagen cargada en un TImage
FiltrarYCombinar(Image1.Picture,4);
Image1.Refresh;

PD: Delphius, si te molesta que me entrometa en tu hilo, me lo dices y lo pongo en un hilo nuevo

[[Delphius]]

seoane, muchas gracias por brindar tu ayuda.

¡Pues,... ¡que ganas de teclear! Yo me estuve rascando el coco intentando buscarle la vuelta implementandolo con el scanline() así como lo haces vos...

No probé tu código... ya le hecho una ojeada profunda... pero a mi primera percepción, ya se está modificando el valor del pixel, en el mismo procedimiento. Si es como estoy pensando (de con sòlo darle una hojeada)... los càlculos no seran los correctos. Pues, se debe mantener en forma "temporal" los datos de la imagen (como mi Matrix) y con ella modificar en forma directa a la imagen. ¿Me explico?

1) Hacer copia temporal de la imagen (en mi caso Matrix)
2) con la matrix y la plantilla de filtrado calcular valor nuevo para P(x,y)
3) Hacer que el "pixel" de la (con scanline()) sea igual al valor calculado. Y NO SOBREESCRIBIR EN LA MATRIX (en mi caso). Si sobreescribo la posición, se pierde el nuevo valor.

Según consta en mis apuntes que tengo eso realiza, en ningún momento pierde el viejo valor.

Pero... claro... es muy posible que me haya equivocado. Se ve que sabes sobre tratamiento de imagen.
Yo mucho de esto no entiendo. Estoy aprendiendo a medida que lo programo.

No me molesta que pongas el código. Todo lo contrario, si tiene que ver con el tema... además... tal vez me sirva

Gracias, por tu ayuda...
Saludos,

[[seoane]]

Empezado por Delphius

No probé tu código... ya le hecho una ojeada profunda... pero a mi primera percepción, ya se está modificando el valor del pixel, en el mismo procedimiento.

Pues vuelve a echarle otra ojeada. Al comienzo del procedimiento hago esto:

Código Delphi [-]
  Bitmap.Canvas.Draw(0,0,Img.Graphic);

Es decir, copio el contenido de la imagen en un bitmap, que nos va a servir como almacenamiento temporal. Luego al operar, tomo los valores del bitmap temporal y los resultados los guardo directamente en la imagen final.

La única diferencia con tu código, es que en el mio no aplico el filtro sobre los pixels de la primera y ultima fila, ni tampoco sobre los de la primera y última columna. Te preguntaras por que, pues porque para esos puntos solo están disponibles, como mucho, 6 puntos de la matriz, por lo que al aplicar el filtro inevitablemente termina oscureciendo el borde da la imagen. Este efecto todavía es mas visible si pasas varias veces el filtro sobre una imagen.

Por cierto, me alegro de que no te moleste que me entrometiera en tu hilo.

[[Delphius]]

Empezado por seoane

Pues vuelve a echarle otra ojeada. Al comienzo del procedimiento hago esto:

Código Delphi [-]
Bitmap.Canvas.Draw(0,0,Img.Graphic);

Mi torpeza, no lo vi...

Empezado por seoane

La única diferencia con tu código, es que en el mio no aplico el filtro sobre los pixels de la primera y ultima fila, ni tampoco sobre los de la primera y última columna. Te preguntaras por que, pues porque para esos puntos solo están disponibles, como mucho, 6 puntos de la matriz, por lo que al aplicar el filtro inevitablemente termina oscureciendo el borde da la imagen. Este efecto todavía es mas visible si pasas varias veces el filtro sobre una imagen.

¡Con razon, cuando iba haciendo pruebas paso a paso (es... una muerte... y eso que era imagenes de 10 x 10!) notaba que se ponía negro!
Eso no aclara el libro que tengo... que vivo... su no fuera por vos, yo ya lo habría dejado asi.

Eso me indica que tengo que ponerles mas pilas y ganas de empezara estudiarle bien la mano. Pues si... se nota que sabes de esto..

Saludos,