[[Delphius]]

Buenas, sigo con esto del algoritmo de Sobel.. estoy empezando a calibrar ideas...

Y como dije antes... no estoy muy seguro de los resultados.
Verán, este es mi algoritmo. Bueno en realidad se muestra una parte, yo diría la más importante porque el resto puede seguirse de lo que seoane había comentado.

Código Delphi [-]
const
HORIZONTAL_GRADIENT_SOBEL: TTemplate = ((-1,0,1),(-2,0,2),(-1,0,1));
VERTICAL_GRADIENT_SOBEL: TTemplate = ((-1,-2,-1),(0,0,0),(1,2,1));

GRADIENT_DIVIDING_ONLY = 4;

type
TGradientOption = (goHorizontal,goVertical,goBoth);

function GetGradient(F1, F2, F3: PTFila; Gradient: TGradientOption; PosX, PosY,
         Threshold: integer): TRGBCanal;
{******************************************************************************
 Descripción:
 Devuelve el valor de gradiente de sobel asociado a una posición determinada de
 la imagen dependiendo si debe evaluar uno o ambos gradientes.

 Parámetros:
 - F1, F2, F3: Filas correspondientes al filtrado.
 - Gradient: Gradiente a evaluar.
   * Horizontal
   * Vertical
   * Ambos
 - PosX, PosY: Posición actual de los pixel vecinos x e y al evaluado.
 - Threshold: Umbral de decisión.
 ******************************************************************************}
var k: integer;
    GHor, GVer: byte;
begin
  // Para cada canal:
  for k := RED downto BLUE do
    begin
      // Calculamos:
      // ...El Gradiente Horizontal
      GHor := round(
                    (F1[1][k] * HORIZONTAL_GRADIENT_SOBEL[1,1] +
                     F1[PosY][k] * HORIZONTAL_GRADIENT_SOBEL[1,3] +
                     F2[1][k] * HORIZONTAL_GRADIENT_SOBEL[2,1] +
                     F2[PosY][k] * HORIZONTAL_GRADIENT_SOBEL[2,3] +
                     F3[1][k] * HORIZONTAL_GRADIENT_SOBEL[3,1] +
                     F3[PosY][k] * HORIZONTAL_GRADIENT_SOBEL[3,3])
                     /GRADIENT_DIVIDING_ONLY);
      // ...El Gradiante Vertical
      GVer := round(
                    (F1[1][k] * VERTICAL_GRADIENT_SOBEL[1,1] +
                     F1[PosX][k] * VERTICAL_GRADIENT_SOBEL[1,2] +
                     F1[PosY][k] * VERTICAL_GRADIENT_SOBEL[1,3] +
                     F3[1][k] * VERTICAL_GRADIENT_SOBEL[3,1] +
                     F3[PosX][k] * VERTICAL_GRADIENT_SOBEL[3,2] +
                     F3[PosY][k] * VERTICAL_GRADIENT_SOBEL[3,3])
                     /GRADIENT_DIVIDING_ONLY);
      // Determinamos que gradiante usamos
      case Gradient of
        goHorizontal: result[k] := GHor;
        goVertical: result[k] := GVer;
        goBoth: result[k] := GHor + GVer;
      end; // Fin case

      if Threshold > 0
         then begin
                if result[k] >= Threshold
                   then result[k] := 0
                   else result[k] := MAX_RGB;
              end;
    end;
end; {* Fin F. GetGradient *}

Hay una pequeña diferencia con lo descripto en las referencias que tengo. Mis fuentes indican que para obtener la imagen real debe obtenerse el módulo de entre ambos gradientes. Es decir la raiz cuadrada de la suma de los cuadrados de los gradientes.
De lo que pude averiguar en internet, se recomienda implementar la suma directa, tal como pueden observar, ya que simplica las operaciones y se obtiene una buena aproximación.
No me convence todavía algunos resultados... consigo unos bordes gruesos no se si realmente estoy codificando algo mal.
Le agradecería si alguien puede ver este código y/o conoce del tema y me de unas pautas para corregir mi inconveniente.

Como prueba... vean esto:




Este resultado se obtiene siguiendo dos pasos:
1. Se convierte a nivel de gris
2. Se le aplica un suavizado
3. Se calcula el contorno mediante Sobel con un valor de 80.

¿Se entiende lo que trato de explicar? Eso espero.
Gracias, pero mucha gracias a toda persona que se haya tomado el tiempo y las molestias.

Saludos,