Calcolo di un campo di distanza con segno 2D

Question

Sto provando a calcolare un campo di distanza firmato di pixel di immagini in bianco e nero, ma penso di essere riuscito a ottenere il codice errato da qualche parte. Poiché questo è il mio ingresso e uscita:

ingresso

uscita

Il problema che sto avendo è la linea nera al centro della S, il mio la comprensione mi lascia credere che dovrebbe essere completamente grigio chiaro?

Questo è il codice che sto utilizzando:

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

vostra colpevole è questa dichiarazione condizione:

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

Ciò significa che si è interessati solo sulla distanza più breve da un pixel nero per un pixel bianco, o se 'a' è bianco, allora stai cercando il pixel nero più vicino.

Se si modifica che prova per vedere:

if (p == white) 
{ 

allora si avrà probabilmente ottenere quello che ci si aspetta.

(Non l'ho verificato, quindi si spera sia corretto).

(Inoltre, se non fosse corretto, sarebbe bello a pubblicare il tuo metodo di Math.Clamp dal momento che non è una costruito nel metodo di libreria nella classe Math.)

Un'ultima cosa, non certo se l'algoritmo ti chiede di confrontare un pixel con se stesso o meno, quindi potresti dover tenerne conto all'interno dei tuoi loop nidificati.

(in pratica, cosa ti aspetteresti che l'output dovesse apparire come un'immagine completamente nera con un pixel bianco nel mezzo? L'output del pixel centrale dovrebbe essere nero poiché non ci sono pixel bianchi nelle vicinanze, o dovrebbe essere bianco.)