Calcular un campo de distancia con signo 2D

Question

Estoy tratando de calcular un campo de distancia con signo de píxeles de imágenes en blanco y negro, pero creo que he logrado obtener mi código incorrecto en alguna parte. Como esta es mi entrada y salida:

entrada

salida

El problema que estoy teniendo es la línea de negro en el centro de la S, mi entender me hace creer que debería ser completamente gris claro?

Este es el código que estoy usando:

for (int x = 0; x < source.width; ++x) 
    { 
     for(int y = 0; y < source.height; ++y) 
     { 
      // Get pixel 
      float a = source.GetPixel(x, y).r; 

      // Distance to closest pixel which is the inverse of a 
      // start on float.MaxValue so we can be sure we found something 
      float distance = float.MaxValue; 

      // Search coordinates, x min/max and y min/max 
      int fxMin = Math.Max(x - searchDistance, 0); 
      int fxMax = Math.Min(x + searchDistance, source.width); 
      int fyMin = Math.Max(y - searchDistance, 0); 
      int fyMax = Math.Min(y + searchDistance, source.height); 

      for (int fx = fxMin; fx < fxMax; ++fx) 
      { 
       for (int fy = fyMin; fy < fyMax; ++fy) 
       { 
        // Get pixel to compare to 
        float p = source.GetPixel(fx, fy).r; 

        // If not equal a 
        if (a != p) 
        { 
         // Calculate distance 
         float xd = x - fx; 
         float yd = y - fy; 
         float d = Math.Sqrt((xd * xd) + (yd * yd)); 

         // Compare absolute distance values, and if smaller replace distnace with the new oe 
         if (Math.Abs(d) < Math.Abs(distance)) 
         { 
          distance = d; 
         } 
        } 
       } 
      } 

      // If we found a new distance, otherwise we'll just use A 

      if (distance != float.MaxValue) 
      { 

       // Clamp distance to -/+ 
       distance = Math.Clamp(distance, -searchDistance, +searchDistance); 

       // Convert from -search,+search to 0,+search*2 and then convert to 0.0, 1.0 and invert 
       a = 1f - Math.Clamp((distance + searchDistance)/(searchDistance + searchDistance), 0, 1); 
      } 

      // Write pixel out 
      target.SetPixel(x, y, new Color(a, a, a, 1)); 
     } 
    } 

Answer 1

el culpable es esta declaración condición:

// If not equal a 
if (a != p) 
{ 

Esto significa que sólo está interesado en la distancia más corta desde un píxel a Negro un píxel blanco, o si 'a' es blanco, entonces está buscando el píxel negro más cercano.

Si pasa la prueba para ver sólo:

if (p == white) 
{ 

Entonces es probable que obtener lo que espera.

(No probé esto, así que espero que sea correcto).

(También, si no fuera correcta, sería bueno para publicar su método de Math.Clamp ya que no es construido en un método de biblioteca en la clase de matemáticas.)

Una última cosa, no Asegúrese de que el algoritmo quiere que compare un píxel consigo mismo o no, por lo que podría necesitar tenerlo en cuenta dentro de sus bucles anidados.

(básicamente, ¿cuál sería la salida de una imagen totalmente negra con un píxel blanco en el medio? ¿Debería ser negra la salida del píxel medio ya que no hay píxeles blancos cercanos, o debería ser blanco.)