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