PathSlide.cpp File Reference

#include "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkFont.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkPathBuilder.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPathUtils.h"
#include "include/core/SkRegion.h"
#include "include/core/SkShader.h"
#include "include/core/SkTypeface.h"
#include "include/effects/SkGradientShader.h"
#include "include/utils/SkParsePath.h"
#include "src/base/SkTime.h"
#include "src/base/SkUTF.h"
#include "src/core/SkGeometry.h"
#include "tools/fonts/FontToolUtils.h"
#include "tools/timer/TimeUtils.h"
#include "tools/viewer/ClickHandlerSlide.h"
#include <stdlib.h>
#include "include/effects/SkCornerPathEffect.h"
#include "src/base/SkRandom.h"

Go to the source code of this file.

Classes
class	PathSlide
class	ArcToSlide
class	FatStrokeSlide
class	CubicCurveSlide
class	CubicCurve2Slide

Functions
static void	test_cubic ()
static void	test_cubic2 ()
static int	compute_parallel_to_base (const SkPoint pts[4], SkScalar t[2])
static SkPoint	lerp (SkPoint a, SkPoint b, float t)
static int	find_max_deviation_cubic (const SkPoint src[4], SkScalar ts[2])

Function Documentation

compute_parallel_to_base()

static int compute_parallel_to_base ( const SkPoint  pts[4], SkScalar  t[2]  )

static

Definition at line 421 of file PathSlide.cpp.

                                                                         {
    // F = At^3 + Bt^2 + Ct + D
    SkVector A = pts[3] - pts[0] + (pts[1] - pts[2]) * 3.0f;
    SkVector B = (pts[0] - pts[1] - pts[1] + pts[2]) * 3.0f;
    SkVector C = (pts[1] - pts[0]) * 3.0f;
    SkVector DA = pts[3] - pts[0];
 
    // F' = 3At^2 + 2Bt + C
    SkScalar a = 3 * A.cross(DA);
    SkScalar b = 2 * B.cross(DA);
    SkScalar c = C.cross(DA);
 
    int n = SkFindUnitQuadRoots(a, b, c, t);
    SkString str;
    for (int i = 0; i < n; ++i) {
        str.appendf(" %g", t[i]);
    }
    SkDebugf("roots %s\n", str.c_str());
    return n;
}

find_max_deviation_cubic()

static int find_max_deviation_cubic ( const SkPoint  src[4], SkScalar  ts[2]  )

static

Definition at line 531 of file PathSlide.cpp.

                                                                          {
    // deviation = F' x (d - a) == 0, solve for t(s)
    // F = At^3 + Bt^2 + Ct + D
    // F' = 3At^2 + 2Bt + C
    // Z = d - a
    // F' x Z = 3(A x Z)t^2 + 2(B x Z)t + (C x Z)
    //
    SkVector A = src[3] + (src[1] - src[2]) * 3 - src[0];
    SkVector B = (src[2] - src[1] - src[1] + src[0]) * 3;
    SkVector C = (src[1] - src[0]) * 3;
    SkVector Z = src[3] - src[0];
    // now forumlate the quadratic coefficients we need to solve for t : F' x Z
    return SkFindUnitQuadRoots(3 * A.cross(Z), 2 * B.cross(Z), C.cross(Z), ts);
}

lerp()

static SkPoint lerp ( SkPoint  a, SkPoint  b, float  t  )

static

Definition at line 527 of file PathSlide.cpp.

                                                   {
    return a * (1 - t) + b * t;
}

test_cubic()

static void test_cubic ( )

static

Definition at line 32 of file PathSlide.cpp.

                         {
    SkPoint src[4] = {
        { 556.25000f, 523.03003f },
        { 556.23999f, 522.96002f },
        { 556.21997f, 522.89001f },
        { 556.21997f, 522.82001f }
    };
    SkPoint dst[11];
    dst[10].set(42, -42);   // one past the end, that we don't clobber these
    SkScalar tval[] = { 0.33333334f, 0.99999994f };
 
    SkChopCubicAt(src, dst, tval, 2);
 
#if 0
    for (int i = 0; i < 11; i++) {
        SkDebugf("--- %d [%g %g]\n", i, dst[i].fX, dst[i].fY);
    }
#endif
}

test_cubic2()

static void test_cubic2 ( )

static

Definition at line 52 of file PathSlide.cpp.

                          {
    const char* str = "M2242 -590088L-377758 9.94099e+07L-377758 9.94099e+07L2242 -590088Z";
    SkPath path;
    SkParsePath::FromSVGString(str, &path);
 
    {
        SkRect r = path.getBounds();
        SkIRect ir;
        r.round(&ir);
        SkDebugf("[%g %g %g %g] [%x %x %x %x]\n",
                SkScalarToDouble(r.fLeft), SkScalarToDouble(r.fTop),
                SkScalarToDouble(r.fRight), SkScalarToDouble(r.fBottom),
                (uint32_t)ir.fLeft, (uint32_t)ir.fTop, (uint32_t)ir.fRight, (uint32_t)ir.fBottom);
    }
 
    SkBitmap bitmap;
    bitmap.allocN32Pixels(300, 200);
 
    SkCanvas canvas(bitmap);
    SkPaint paint;
    paint.setAntiAlias(true);
    canvas.drawPath(path, paint);
}