Error Invalid Floating Operation

[[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,

[[Delphius]]

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!

[[seoane]]

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.

[[Delphius]]

Empezado por seoane

Si no es algo confidencial, puedes colocarlo por aquí para echarle un vistazo.

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,