Error Invalid Floating Operation
 

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,

:( 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;

:D 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 ;)

Gracias seoane...
 

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:D

Gracias, por tu ayuda...
Saludos,

;) 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. :p

Sorprendente... ¡Eres bueno!
 

Mi torpeza, no lo vi...

¡Con razon, cuando iba haciendo pruebas paso a paso (es... una muerte... y eso que era imagenes de 10 x 10!:D:mad:) 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,

Pues... solo una aclaracion
 

Lamento abrir el hilo de hace una semana. Estuve fuera estos dias. Veras, Seoane... en tu código hay una parte interesante:
[delphi]) div t;[delphi]

Solo quería aclarar que puede haber una falla en esta parte:
¡un cero! No es gran cosa... pero bueno solo aclaro eso.
Según estuve viendo... no siempre el valor la suma del filtro es
positiva. En algunos la suma es cero. Y por ende... aqui falla.

Mediante tu código logré llevarlo según mis apuntes... y con
filtro en formato real y no como tu expones.
Unos pequeños cambios y listo. Muchas gracias!

:eek: Caramba! Me faltaba el seguro contra usuario torpes ... Tal como implemento yo el filtro, con números enteros y positivos, la única forma de que fallara es que algún usuario, con ganas de fastidiar, utilizara un filtro en que todos los valores fuesen 0. No tendría sentido, pero nunca esta mal revisarlo todo en busca de cosas sin sentido por parte del usuario ;)

Por lo demás, me alegro de que consiguieras terminar tu código. Si no es algo confidencial, puedes colocarlo por aquí para echarle un vistazo.

ummm... no veo problema.... alli va...
 

ummm.... no veo que viole algun código del reglamento de trabajos finales de mi universidad (El código que escribí corresponde al sistema para el proyecto de grado). Después de todo es conocimiento adquirido de mis prácticas.. y entre mis fuentes bibliográfica menciono a este maravilloso foro. Además... sólo expongo una breve parte de lo que es... asi que lo pongo:

Código Delphi [-]
function SpaceFiltrate(Image: TPicture; Filter: TTemplate; var MSE: real): integer;
{******************************************************************************
 Descripción:
 Realiza un filtrado espacial mediante una operación de ponderación de los va-
 lores de los pixeles vecinos.
 Mediante la función f(I1(x,y)) se obtiene la imagen I2 en la que cada pixel de
 I1 se ha sustituido por un promedio ponderado de pixels vecinos. La expresión
 matemática es:

 f(Ii(x,y) = Sum Sum a(i,j)* I1(x - i,y - i)
             i,j E w

 Una iterpretación equivalente es convolucionar la imagen con la respuesta im-
 pulsional del filtro, que puede representarse como una plantilla.

 Parámetros:
 - Image: Imagen a filtrar.
 - Filter: Plantilla de filtrado.

 Resultrados:
 - FILTER_SPACE: ante una operación exitosa.
 - NOT_FILTER_SPACE: ante una operación fallida.
 ******************************************************************************}
var i, j : integer;
    Bmp: TBitmap;
    P1, P2, P3, P4: PByte;
    aux, Dif: real;
begin
  // Damos por supuesto que no se pudo realizar la operación
  RESULT := NOT_FILTER_SPACE;
  Bmp:= TBitmap.Create;
  try
    // guardamos la imagen en formato de mapa de bit auxiliar
    // es necesaria para operar
    Bmp.Width:= Image.Width;
    Bmp.Height:= Image.Height;
    Bmp.Canvas.Draw(0,0,Image.Graphic);
    // Si no es formato de mapa de bits hay que convertirla
    if not (Image.Graphic is TBitmap) then
      Image.Assign(Bmp);
    // Asignamos un formato de 24 bits (pero a nivel de gris)
    Image.Bitmap.PixelFormat:= pf24bit;
    Bmp.PixelFormat:= pf24bit;
    // se filtra todo menos el contorno...
    // si se flitrara el contorno todo seria negro: la operacion de filtrado
    // no es capaz de armar un valor alto cercano al que debería tomar, ya que
    // sòlo ponderaría a lo sumo 6 de los 9 lugares vecinos.
    MSE := 0;
    for j:= 0 to Bmp.Height - 3 do
    begin
      P1:= Bmp.ScanLine[j];
      P2:= Bmp.ScanLine[j+1];
      P3:= Bmp.ScanLine[j+2];
      // P4 es la linea linea central a filtrar
      P4:= Image.Bitmap.ScanLine[j+1];
      for i:= 0 to Bmp.Width - 3 do
      begin
        Aux := PTFila(P4)[2][BLUE];
        PTFila(P4)[2][BLUE] :=
            trunc(
             (PTFila(P1)[1][BLUE]*Filter[1,1]) +
             (PTFila(P1)[2][BLUE]*Filter[1,2]) +
             (PTFila(P1)[3][BLUE]*Filter[1,3]) +

             (PTFila(P2)[1][BLUE]*Filter[2,1]) +
             (PTFila(P2)[2][BLUE]*Filter[2,2]) +
             (PTFila(P2)[3][BLUE]*Filter[2,3]) +

             (PTFila(P3)[1][BLUE]*Filter[3,1]) +
             (PTFila(P3)[2][BLUE]*Filter[3,2]) +
             (PTFila(P3)[3][BLUE]*Filter[3,3])
            );
        // calculamos el MSE
        Dif := (Aux - PTFila(P4)[2][BLUE]);
        Dif := Power(Dif,2);
        MSE := MSE  + Dif;

        PTFila(P4)[2][GREEN] := PTFila(P4)[2][BLUE];
        PTFila(P4)[2][RED] := PTFila(P4)[2][BLUE];
        // avanzamos de a 3 lugares...
        // P1..P4 tienen la estructura de punteros para 3 pixeles
        inc(P1,Sizeof(TRGBCanal));
        inc(P2,Sizeof(TRGBCanal));
        inc(P3,Sizeof(TRGBCanal));
        inc(P4,Sizeof(TRGBCanal));
      end;
    end;
  finally
    Bmp.Free;
  end;
  // "corregimos el MSE a razon de la muestra de pixeles"
  MSE := MSE /((Image.Bitmap.Height - 2)*(Image.Bitmap.Width - 2));
  // establecemos un formato de 8 bits
  Image.Bitmap.PixelFormat := pf8bit;
  result := FILTER_SPACE;
end; {* Fin F. SpaceFiltrate *}

Los cambios, están en que yo he definido:

Código Delphi [-]
const
  STANDAR_FILTER: TTemplate = ((1/9,1/9,1/9),(1/9,1/9,1/9),(1/9,1/9,1/9));

type
  {* Estructuras asociadas al canal *}
  TRGBCanal = array[BLUE..RED] of Byte;
  PTRGBCanal = ^TRGBCanal;
  TRGBArray = array[1..3] of Byte;


  {* Estructuras para formar plantillas auxiliares *}
  // Cada plantilla es de 3x3x3
  TFila = array[1..3] of TRGBCanal;
  //TFila es una fila de 3 pixeles
  PTFila = ^TFila;

  {* Estructuras de plantillas *}
  TTemplate = array[1..3,1..3] of real;

Espero que pueda ayudar a alguien más... en caso de que llegase a violar algún código... bueno... ya me las arreglo yo. Y si... fuera necesario cerrar el hilo o borrarlo... bueno... veré si me comunico con Emilio para ver que me dice.

Saludos,