Fix distance field edge detection.

src/core/SkDistanceFieldGen.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDistanceFieldGen.h"
 #include "SkPoint.h"
 
 struct DFData {
     float   fAlpha;      // alpha value of source texel
     float   fDistSq;     // distance squared to nearest (so far) edge texel
     SkPoint fDistVector; // distance vector to nearest (so far) edge texel
 };
 
+enum NeighborFlags {
+    kLeft_NeighborFlag        = 0x01,
+    kRight_NeighborFlag       = 0x02,
+    kTopLeft_NeighborFlag     = 0x04,
+    kTop_NeighborFlag         = 0x08,
+    kTopRight_NeighborFlag    = 0x10,
+    kBottomLeft_NeighborFlag  = 0x20,
+    kBottom_NeighborFlag      = 0x40,
+    kBottomRight_NeighborFlag = 0x80,
+    kAll_NeighborFlags        = 0xff,
+ 
+    kNeighborFlagCount        = 8
+};
+
 // We treat an "edge" as a place where we cross from a texel >= 128 to a texel < 128,
 // or vice versa. This means we just need to check if the MSBs are different.
-static bool found_edge(const unsigned char* imagePtr, int width) {
+// 'neighborFlags' is used to limit the directions in which we test to avoid indexing
+// outside of the image
+static bool found_edge(const unsigned char* imagePtr, int width, int neighborFlags) {
+    // the order of these should match the neighbor flags above
+    const int kNum8ConnectedNeighbors = 8;
     const int offsets[8] = {-1, 1, -width-1, -width, -width+1, width-1, width, width+1 };
+    SkASSERT(kNum8ConnectedNeighbors == kNeighborFlagCount);
 
     // search for an edge
-    int checkVal = *imagePtr >> 7;
-    for (int i = 0; i < 8; ++i) {
-        const unsigned char* checkPtr = imagePtr + offsets[i];
-        if (checkVal ^ (*checkPtr >> 7)) {
+    unsigned char currVal = *imagePtr >> 7;
+    for (int i = 0; i < kNum8ConnectedNeighbors; ++i) {
+        unsigned char checkVal;
+        if ((1 << i) & neighborFlags) {
+            const unsigned char* checkPtr = imagePtr + offsets[i];
+            checkVal = *checkPtr >> 7;
+        } else {
+            checkVal = 0;
+        }
+        SkASSERT(checkVal == 0 || checkVal == 1);
+        SkASSERT(currVal == 0 || currVal == 1);
+        if (checkVal != currVal) {
             return true;
         }
     }
 
     return false;
 }
 
 static void init_glyph_data(DFData* data, unsigned char* edges, const unsigned char* image,
                             int dataWidth, int dataHeight,
                             int imageWidth, int imageHeight,
                             int pad) {
     data += pad*dataWidth;
     data += pad;
     edges += (pad*dataWidth + pad);
 
     for (int j = 0; j < imageHeight; ++j) {
         for (int i = 0; i < imageWidth; ++i) {
             if (255 == *image) {
                 data->fAlpha = 1.0f;
             } else {
                 data->fAlpha = (*image)*0.00392156862f;  // 1/255
             }
-            if (i > 0 && i < imageWidth-1 && j > 0 && j < imageHeight-1 &&
-                found_edge(image, imageWidth)) {
+            int checkMask = kAll_NeighborFlags;
+            if (i == 0) {
+                checkMask &= ~(kLeft_NeighborFlag|kTopLeft_NeighborFlag|kBottomLeft_NeighborFlag);
+            }
+            if (i == imageWidth-1) {
+                checkMask &= ~(kRight_NeighborFlag|kTopRight_NeighborFlag|kBottomRight_NeighborFlag);
+            }
+            if (j == 0) {
+                checkMask &= ~(kTopLeft_NeighborFlag|kTop_NeighborFlag|kTopRight_NeighborFlag);
+            }
+            if (j == imageHeight-1) {
+                checkMask &= ~(kBottomLeft_NeighborFlag|kBottom_NeighborFlag|kBottomRight_NeighborFlag);
+            }
+            if (found_edge(image, imageWidth, checkMask)) {
                 *edges = 255;  // using 255 makes for convenient debug rendering
             }
             ++data;
             ++image;
             ++edges;
         }
         data += 2*pad;
         edges += 2*pad;
     }
 }
@@ skipping 200 matching lines @@
     distVec = check->fDistVector;
     distSq = check->fDistSq + 2.0f*(distVec.fX + distVec.fY + 1.0f);
     if (distSq < curr->fDistSq) {
         distVec.fX += 1.0f;
         distVec.fY += 1.0f;
         curr->fDistSq = distSq;
         curr->fDistVector = distVec;
     }
 }
 
+// enable this to output edge data rather than the distance field
+#define DUMP_EDGE 0
+
+#if !DUMP_EDGE
 static unsigned char pack_distance_field_val(float dist, float distanceMagnitude) {
     if (dist <= -distanceMagnitude) {
         return 255;
     } else if (dist > distanceMagnitude) {
         return 0;
     } else {
         return (unsigned char)((distanceMagnitude-dist)*128.0f/distanceMagnitude);
     }
 }
+#endif
 
 // assumes an 8-bit image and distance field
 bool SkGenerateDistanceFieldFromImage(unsigned char* distanceField,
                                       const unsigned char* image,
                                       int width, int height,
                                       int distanceMagnitude) {
     SkASSERT(NULL != distanceField);
     SkASSERT(NULL != image);
 
     // the final distance field will have additional texels on each side to handle
@@ skipping 85 matching lines @@
         currData -= dataWidth-1;
         currEdge -= dataWidth-1;
     }
 
     // copy results to final distance field data
     currData = dataPtr + dataWidth+1;
     currEdge = edgePtr + dataWidth+1;
     unsigned char *dfPtr = distanceField;
     for (int j = 1; j < dataHeight-1; ++j) {
         for (int i = 1; i < dataWidth-1; ++i) {
+#if DUMP_EDGE
+            unsigned char val = (currData->fAlpha >= 0.5f) ? 255 : 0;
+            if (*currEdge) {
+                val = 128;
+            }
+            *dfPtr++ = val;
+#else
             float dist;
             if (currData->fAlpha > 0.5f) {
                 dist = -SkScalarSqrt(currData->fDistSq);
             } else {
                 dist = SkScalarSqrt(currData->fDistSq);
             }
-
             *dfPtr++ = pack_distance_field_val(dist, (float)distanceMagnitude);
+#endif
             ++currData;
             ++currEdge;
         }
         currData += 2;
         currEdge += 2;
     }
 
     return true;
 }