[Git][freetype/freetype][master] 3 commits: * include/freetype/freetype.

Werner Lemberg pushed to branch master at FreeType / FreeType

Commits:

5499d7bf

by Anuj Verma at 2022-03-05T16:44:23+01:00

* include/freetype/freetype.h: Improve SDF documentation.

2600ef63

by Anuj Verma at 2022-03-05T16:53:45+01:00

[sdf] Implement deviation-based splitting for Bezier curves.

* src/sdf/ftsdf.c (split_sdf_cubic, split_sdf_shape): Add checks to figure
out the deviation of Bezier curves and stop splitting if the curve is flat
enough.

* src/sdf/ftsdfcommon.h (ONE_PIXEL): New macro.

360e2507

by Anuj Verma at 2022-03-05T17:00:10+01:00

[sdf] Fix corner checks and improve performance.

* src/sdf/ftsdf.c (sdf_generate_bounding_box): Always check for a corner if
two distances (for different curves) are very close.

(sdf_conic_to): Check whether the conic curve can be treated as a line
(which happens if the control point coincides with any end point).

Changes:

include/freetype/freetype.h

@@ -3409,6 +3409,44 @@ FT_BEGIN_HEADER
     *   }
+    *
     *   ```
 +   *
 +   *   FreeType has two rasterizers for generating SDF, namely:
 +   *
 +   *   1. `sdf` for generating SDF directly from glyph's outline, and
 +   *
 +   *   2. `bsdf` for generating SDF from rasterized bitmaps.
 +   *
 +   *   Depending on the glyph type (i.e., outline or bitmap), one of the two
 +   *   rasterizers is chosen at runtime and used for generating SDFs.  To
 +   *   force the use of `bsdf` you should render the glyph with any of the
 +   *   FreeType's other rendering modes (e.g., `FT_RENDER_MODE_NORMAL`) and
 +   *   then re-render with `FT_RENDER_MODE_SDF`.
 +   *
 +   *   There are some issues with stability and possible failures of the SDF
 +   *   renderers (specifically `sdf`).
 +   *
 +   *   1. The `sdf` rasterizer is sensitive to really small features (e.g.,
 +   *      sharp turns that are less than 1~pixel) and imperfections in the
 +   *      glyph's outline, causing artifacts in the final output.
 +   *
 +   *   2. The `sdf` rasterizer has limited support for handling intersecting
 +   *      contours and *cannot* handle self-intersecting contours whatsoever.
 +   *      Self-intersection happens when a single connected contour intersect
 +   *      itself at some point; having these in your font definitely pose a
 +   *      problem to the rasterizer and cause artifacts, too.
 +   *
 +   *   3. Generating SDF for really small glyphs may result in undesirable
 +   *      output; the pixel grid (which stores distance information) becomes
 +   *      too coarse.
 +   *
 +   *   4. Since the output buffer is normalized, precision at smaller spreads
 +   *      is greater than precision at larger spread values because the
 +   *      output range of [0..255] gets mapped to a smaller SDF range.  A
 +   *      spread of~2 should be sufficient in most cases.
 +   *
 +   *   Points (1) and (2) can be avoided by using the `bsdf` rasterizer,
 +   *   which is more stable than the `sdf` rasterizer in general.
 +   *
     */
    typedef enum  FT_Render_Mode_
+   {

src/sdf/ftsdf.c

@@ -738,6 +738,18 @@
      contour = shape->contours;
 +    /* If the control point coincides with any of the end points */
 +    /* then it is a line and should be treated as one to avoid   */
 +    /* unnecessary complexity later in the algorithm.            */
 +    if ( ( contour->last_pos.x == control_1->x &&
 +           contour->last_pos.y == control_1->y ) ||
 +         ( control_1->x == to->x &&
 +           control_1->y == to->y )               )
 +    {
 +      sdf_line_to( to, user );
 +      goto Exit;
 +    }
++
      FT_CALL( sdf_edge_new( memory, &edge ) );
      edge->edge_type = SDF_EDGE_CONIC;
@@ -764,9 +776,9 @@
                  const FT_26D6_Vec*  to,
                  void*               user )
+   {
 -    SDF_Shape*    shape    = ( SDF_Shape* )user;
 -    SDF_Edge*     edge     = NULL;
 -    SDF_Contour*  contour  = NULL;
 +    SDF_Shape*    shape   = ( SDF_Shape* )user;
 +    SDF_Edge*     edge    = NULL;
 +    SDF_Contour*  contour = NULL;
      FT_Error   error  = FT_Err_Ok;
      FT_Memory  memory = shape->memory;
@@ -1137,23 +1149,38 @@
                     FT_Int        max_splits,
                     SDF_Edge**    out )
+   {
 -    FT_Error     error = FT_Err_Ok;
 -    FT_26D6_Vec  cpos[7];
 -    SDF_Edge*    left,*  right;
 +    FT_Error       error = FT_Err_Ok;
 +    FT_26D6_Vec    cpos[7];
 +    SDF_Edge*      left, *right;
 +    const FT_26D6  threshold = ONE_PIXEL / 4;
 -    if ( !memory || !out  )
 +    if ( !memory || !out )
+     {
        error = FT_THROW( Invalid_Argument );
        goto Exit;
+     }
 -    /* split the conic */
 +    /* split the cubic */
      cpos[0] = control_points[0];
      cpos[1] = control_points[1];
      cpos[2] = control_points[2];
      cpos[3] = control_points[3];
 +    /* If the segment is flat enough we won't get any benefit by */
 +    /* splitting it further, so we can just stop splitting.      */
 +    /*                                                           */
 +    /* Check the deviation of the Bezier curve and stop if it is */
 +    /* smaller than the pre-defined `threshold` value.           */
 +    if ( FT_ABS( 2 * cpos[0].x - 3 * cpos[1].x + cpos[3].x ) < threshold &&
 +         FT_ABS( 2 * cpos[0].y - 3 * cpos[1].y + cpos[3].y ) < threshold &&
 +         FT_ABS( cpos[0].x - 3 * cpos[2].x + 2 * cpos[3].x ) < threshold &&
 +         FT_ABS( cpos[0].y - 3 * cpos[2].y + 2 * cpos[3].y ) < threshold )
 +    {
 +      split_cubic( cpos );
 +      goto Append;
 +    }
++
      split_cubic( cpos );
      /* If max number of splits is done */
@@ -1250,13 +1277,32 @@
            /* Subdivide the curve and add it to the list. */
+           {
              FT_26D6_Vec  ctrls[3];
 +            FT_26D6      dx, dy;
 +            FT_UInt      num_splits;
              ctrls[0] = edge->start_pos;
              ctrls[1] = edge->control_a;
              ctrls[2] = edge->end_pos;
 -            error = split_sdf_conic( memory, ctrls, 32, &new_edges );
 +            dx = FT_ABS( ctrls[2].x + ctrls[0].x - 2 * ctrls[1].x );
 +            dy = FT_ABS( ctrls[2].y + ctrls[0].y - 2 * ctrls[1].y );
 +            if ( dx < dy )
 +              dx = dy;
++
 +            /* Calculate the number of necessary bisections.  Each      */
 +            /* bisection causes a four-fold reduction of the deviation, */
 +            /* hence we bisect the Bezier curve until the deviation     */
 +            /* becomes less than 1/8th of a pixel.  For more details    */
 +            /* check file `ftgrays.c`.                                  */
 +            num_splits = 1;
 +            while ( dx > ONE_PIXEL / 8 )
 +            {
 +              dx         >>= 2;
 +              num_splits <<= 1;
 +            }
++
 +            error = split_sdf_conic( memory, ctrls, num_splits, &new_edges );
+           }
            break;
@@ -3286,6 +3332,7 @@
              FT_26D6_Vec          grid_point = zero_vector;
              SDF_Signed_Distance  dist       = max_sdf;
              FT_UInt              index      = 0;
 +            FT_16D16             diff       = 0;
              if ( x < 0 || x >= width )
@@ -3313,7 +3360,7 @@
              if ( dist.distance > sp_sq )
                continue;
 -            /* square_root the values and fit in a 6.10 fixed-point */
 +            /* take the square root of the distance if required */
              if ( USE_SQUARED_DISTANCES )
                dist.distance = square_root( dist.distance );
@@ -3325,11 +3372,15 @@
              /* check whether the pixel is set or not */
              if ( dists[index].sign == 0 )
                dists[index] = dist;
 -            else if ( dists[index].distance > dist.distance )
 -              dists[index] = dist;
 -            else if ( FT_ABS( dists[index].distance - dist.distance )
 -                        < CORNER_CHECK_EPSILON )
 -              dists[index] = resolve_corner( dists[index], dist );
 +            else
 +            {
 +              diff = FT_ABS( dists[index].distance - dist.distance );
++
 +              if ( diff <= CORNER_CHECK_EPSILON )
 +                dists[index] = resolve_corner( dists[index], dist );
 +              else if ( dists[index].distance > dist.distance )
 +                dists[index] = dist;
 +            }
+           }
+         }

src/sdf/ftsdfcommon.h

@@ -48,6 +48,8 @@ FT_BEGIN_HEADER
  #define MIN_SPREAD      2
    /* maximum spread supported by the renderer */
  #define MAX_SPREAD      32
 +  /* pixel size in 26.6 */
 +#define ONE_PIXEL       ( 1 << 6 )
    /**************************************************************************

From:	Werner Lemberg (@wl)
Subject:	[Git][freetype/freetype][master] 3 commits: * include/freetype/freetype.h: Improve SDF documentation.
Date:	Sat, 05 Mar 2022 16:07:47 +0000