Stu Leak
68df790d27
Major improvements to UnifiedPlayer: 1. GetFrameImage() now works when paused for responsive UI updates 2. Play() method properly starts FFmpeg process 3. Frame display loop runs continuously for smooth video display 4. Disabled audio temporarily to fix video playback fundamentals 5. Simplified FFmpeg command to focus on video stream only Player now: - Generates video frames correctly - Shows video when paused - Has responsive progress tracking - Starts playback properly Next steps: Re-enable audio playback once video is stable
678 lines
23 KiB
Go
678 lines
23 KiB
Go
// Copyright 2017 by the rasterx Authors. All rights reserved.
|
|
//
|
|
// created: 2017 by S.R.Wiley
|
|
|
|
package rasterx
|
|
|
|
import (
|
|
"math"
|
|
|
|
"golang.org/x/image/math/fixed"
|
|
)
|
|
|
|
const (
|
|
cubicsPerHalfCircle = 8 // Number of cubic beziers to approx half a circle
|
|
epsilonFixed = fixed.Int26_6(16) // 1/4 in fixed point
|
|
// fixed point t paramaterization shift factor;
|
|
// (2^this)/64 is the max length of t for fixed.Int26_6
|
|
tStrokeShift = 14
|
|
)
|
|
|
|
type (
|
|
// JoinMode type to specify how segments join.
|
|
JoinMode uint8
|
|
// CapFunc defines a function that draws caps on the ends of lines
|
|
CapFunc func(p Adder, a, eNorm fixed.Point26_6)
|
|
// GapFunc defines a function to bridge gaps when the miter limit is
|
|
// exceeded
|
|
GapFunc func(p Adder, a, tNorm, lNorm fixed.Point26_6)
|
|
|
|
// C2Point represents a point that connects two stroke segments
|
|
// and holds the tangent, normal and radius of curvature
|
|
// of the trailing and leading segments in fixed point values.
|
|
C2Point struct {
|
|
P, TTan, LTan, TNorm, LNorm fixed.Point26_6
|
|
RT, RL fixed.Int26_6
|
|
}
|
|
|
|
// Stroker does everything a Filler does, but
|
|
// also allows for stroking and dashed stroking in addition to
|
|
// filling
|
|
Stroker struct {
|
|
Filler
|
|
CapT, CapL CapFunc // Trailing and leading cap funcs may be set separately
|
|
JoinGap GapFunc // When gap appears between segments, this function is called
|
|
|
|
firstP, trailPoint, leadPoint C2Point // Tracks progress of the stroke
|
|
ln fixed.Point26_6 // last normal of intra-seg connection.
|
|
u, mLimit fixed.Int26_6 // u is the half-width of the stroke.
|
|
|
|
JoinMode JoinMode
|
|
inStroke bool
|
|
}
|
|
)
|
|
|
|
// JoinMode constants determine how stroke segments bridge the gap at a join
|
|
// ArcClip mode is like MiterClip applied to arcs, and is not part of the SVG2.0
|
|
// standard.
|
|
const (
|
|
Arc JoinMode = iota
|
|
ArcClip
|
|
Miter
|
|
MiterClip
|
|
Bevel
|
|
Round
|
|
)
|
|
|
|
// NewStroker returns a ptr to a Stroker with default values.
|
|
// A Stroker has all of the capabilities of a Filler and Scanner, plus the ability
|
|
// to stroke curves with solid lines. Use SetStroke to configure with non-default
|
|
// values.
|
|
func NewStroker(width, height int, scanner Scanner) *Stroker {
|
|
r := new(Stroker)
|
|
r.Scanner = scanner
|
|
r.SetBounds(width, height)
|
|
//Defaults for stroking
|
|
r.SetWinding(true)
|
|
r.u = 2 << 6
|
|
r.mLimit = 4 << 6
|
|
r.JoinMode = MiterClip
|
|
r.JoinGap = RoundGap
|
|
r.CapL = RoundCap
|
|
r.CapT = RoundCap
|
|
r.SetStroke(1<<6, 4<<6, ButtCap, nil, FlatGap, MiterClip)
|
|
return r
|
|
}
|
|
|
|
// SetStroke set the parameters for stroking a line. width is the width of the line, miterlimit is the miter cutoff
|
|
// value for miter, arc, miterclip and arcClip joinModes. CapL and CapT are the capping functions for leading and trailing
|
|
// line ends. If one is nil, the other function is used at both ends. If both are nil, both ends are ButtCapped.
|
|
// gp is the gap function that determines how a gap on the convex side of two joining lines is filled. jm is the JoinMode
|
|
// for curve segments.
|
|
func (r *Stroker) SetStroke(width, miterLimit fixed.Int26_6, capL, capT CapFunc, gp GapFunc, jm JoinMode) {
|
|
r.u = width / 2
|
|
r.CapL = capL
|
|
r.CapT = capT
|
|
r.JoinMode = jm
|
|
r.JoinGap = gp
|
|
r.mLimit = (r.u * miterLimit) >> 6
|
|
|
|
if r.CapT == nil {
|
|
if r.CapL == nil {
|
|
r.CapT = ButtCap
|
|
} else {
|
|
r.CapT = r.CapL
|
|
}
|
|
}
|
|
if r.CapL == nil {
|
|
r.CapL = r.CapT
|
|
}
|
|
if gp == nil {
|
|
if r.JoinMode == Round {
|
|
r.JoinGap = RoundGap
|
|
} else {
|
|
r.JoinGap = FlatGap
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// GapToCap is a utility that converts a CapFunc to GapFunc
|
|
func GapToCap(p Adder, a, eNorm fixed.Point26_6, gf GapFunc) {
|
|
p.Start(a.Add(eNorm))
|
|
gf(p, a, eNorm, Invert(eNorm))
|
|
p.Line(a.Sub(eNorm))
|
|
}
|
|
|
|
var (
|
|
// ButtCap caps lines with a straight line
|
|
ButtCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
|
|
p.Start(a.Add(eNorm))
|
|
p.Line(a.Sub(eNorm))
|
|
}
|
|
// SquareCap caps lines with a square which is slightly longer than ButtCap
|
|
SquareCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
|
|
tpt := a.Add(turnStarboard90(eNorm))
|
|
p.Start(a.Add(eNorm))
|
|
p.Line(tpt.Add(eNorm))
|
|
p.Line(tpt.Sub(eNorm))
|
|
p.Line(a.Sub(eNorm))
|
|
}
|
|
// RoundCap caps lines with a half-circle
|
|
RoundCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
|
|
GapToCap(p, a, eNorm, RoundGap)
|
|
}
|
|
// CubicCap caps lines with a cubic bezier
|
|
CubicCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
|
|
GapToCap(p, a, eNorm, CubicGap)
|
|
}
|
|
// QuadraticCap caps lines with a quadratic bezier
|
|
QuadraticCap CapFunc = func(p Adder, a, eNorm fixed.Point26_6) {
|
|
GapToCap(p, a, eNorm, QuadraticGap)
|
|
}
|
|
// Gap functions
|
|
|
|
//FlatGap bridges miter-limit gaps with a straight line
|
|
FlatGap GapFunc = func(p Adder, a, tNorm, lNorm fixed.Point26_6) {
|
|
p.Line(a.Add(lNorm))
|
|
}
|
|
// RoundGap bridges miter-limit gaps with a circular arc
|
|
RoundGap GapFunc = func(p Adder, a, tNorm, lNorm fixed.Point26_6) {
|
|
strokeArc(p, a, a.Add(tNorm), a.Add(lNorm), true, 0, 0, p.Line)
|
|
p.Line(a.Add(lNorm)) // just to be sure line joins cleanly,
|
|
// last pt in stoke arc may not be precisely s2
|
|
}
|
|
// CubicGap bridges miter-limit gaps with a cubic bezier
|
|
CubicGap GapFunc = func(p Adder, a, tNorm, lNorm fixed.Point26_6) {
|
|
p.CubeBezier(a.Add(tNorm).Add(turnStarboard90(tNorm)), a.Add(lNorm).Add(turnPort90(lNorm)), a.Add(lNorm))
|
|
}
|
|
// QuadraticGap bridges miter-limit gaps with a quadratic bezier
|
|
QuadraticGap GapFunc = func(p Adder, a, tNorm, lNorm fixed.Point26_6) {
|
|
c1, c2 := a.Add(tNorm).Add(turnStarboard90(tNorm)), a.Add(lNorm).Add(turnPort90(lNorm))
|
|
cm := c1.Add(c2).Mul(fixed.Int26_6(1 << 5))
|
|
p.QuadBezier(cm, a.Add(lNorm))
|
|
}
|
|
)
|
|
|
|
// StrokeArc strokes a circular arc by approximation with bezier curves
|
|
func strokeArc(p Adder, a, s1, s2 fixed.Point26_6, clockwise bool, trimStart,
|
|
trimEnd fixed.Int26_6, firstPoint func(p fixed.Point26_6)) (ps1, ds1, ps2, ds2 fixed.Point26_6) {
|
|
// Approximate the circular arc using a set of cubic bezier curves by the method of
|
|
// L. Maisonobe, "Drawing an elliptical arc using polylines, quadratic
|
|
// or cubic Bezier curves", 2003
|
|
// https://www.spaceroots.org/documents/elllipse/elliptical-arc.pdf
|
|
// The method was simplified for circles.
|
|
theta1 := math.Atan2(float64(s1.Y-a.Y), float64(s1.X-a.X))
|
|
theta2 := math.Atan2(float64(s2.Y-a.Y), float64(s2.X-a.X))
|
|
if !clockwise {
|
|
for theta1 < theta2 {
|
|
theta1 += math.Pi * 2
|
|
}
|
|
} else {
|
|
for theta2 < theta1 {
|
|
theta2 += math.Pi * 2
|
|
}
|
|
}
|
|
deltaTheta := theta2 - theta1
|
|
if trimStart > 0 {
|
|
ds := (deltaTheta * float64(trimStart)) / float64(1<<tStrokeShift)
|
|
deltaTheta -= ds
|
|
theta1 += ds
|
|
}
|
|
if trimEnd > 0 {
|
|
ds := (deltaTheta * float64(trimEnd)) / float64(1<<tStrokeShift)
|
|
deltaTheta -= ds
|
|
}
|
|
|
|
segs := int(math.Abs(deltaTheta)/(math.Pi/cubicsPerHalfCircle)) + 1
|
|
dTheta := deltaTheta / float64(segs)
|
|
tde := math.Tan(dTheta / 2)
|
|
alpha := fixed.Int26_6(math.Sin(dTheta) * (math.Sqrt(4+3*tde*tde) - 1) * (64.0 / 3.0)) // Math is fun!
|
|
r := float64(Length(s1.Sub(a))) // Note r is *64
|
|
ldp := fixed.Point26_6{X: -fixed.Int26_6(r * math.Sin(theta1)), Y: fixed.Int26_6(r * math.Cos(theta1))}
|
|
ds1 = ldp
|
|
ps1 = fixed.Point26_6{X: a.X + ldp.Y, Y: a.Y - ldp.X}
|
|
firstPoint(ps1)
|
|
s1 = ps1
|
|
for i := 1; i <= segs; i++ {
|
|
eta := theta1 + dTheta*float64(i)
|
|
ds2 = fixed.Point26_6{X: -fixed.Int26_6(r * math.Sin(eta)), Y: fixed.Int26_6(r * math.Cos(eta))}
|
|
ps2 = fixed.Point26_6{X: a.X + ds2.Y, Y: a.Y - ds2.X} // Using deriviative to calc new pt, because circle
|
|
p1 := s1.Add(ldp.Mul(alpha))
|
|
p2 := ps2.Sub(ds2.Mul(alpha))
|
|
p.CubeBezier(p1, p2, ps2)
|
|
s1, ldp = ps2, ds2
|
|
}
|
|
return
|
|
}
|
|
|
|
// Joiner is called when two segments of a stroke are joined. it is exposed
|
|
// so that if can be wrapped to generate callbacks for the join points.
|
|
func (r *Stroker) Joiner(p C2Point) {
|
|
crossProd := p.LNorm.X*p.TNorm.Y - p.TNorm.X*p.LNorm.Y
|
|
// stroke bottom edge, with the reverse of p
|
|
r.strokeEdge(C2Point{P: p.P, TNorm: Invert(p.LNorm), LNorm: Invert(p.TNorm),
|
|
TTan: Invert(p.LTan), LTan: Invert(p.TTan), RT: -p.RL, RL: -p.RT}, -crossProd)
|
|
// stroke top edge
|
|
r.strokeEdge(p, crossProd)
|
|
}
|
|
|
|
// strokeEdge reduces code redundancy in the Joiner function by 2x since it handles
|
|
// the top and bottom edges. This function encodes most of the logic of how to
|
|
// handle joins between the given C2Point point p, and the end of the line.
|
|
func (r *Stroker) strokeEdge(p C2Point, crossProd fixed.Int26_6) {
|
|
ra := &r.Filler
|
|
s1, s2 := p.P.Add(p.TNorm), p.P.Add(p.LNorm) // Bevel points for top leading and trailing
|
|
ra.Start(s1)
|
|
if crossProd > -epsilonFixed*epsilonFixed { // Almost co-linear or convex
|
|
ra.Line(s2)
|
|
return // No need to fill any gaps
|
|
}
|
|
|
|
var ct, cl fixed.Point26_6 // Center of curvature trailing, leading
|
|
var rt, rl fixed.Int26_6 // Radius of curvature trailing, leading
|
|
|
|
// Adjust radiuses for stroke width
|
|
if r.JoinMode == Arc || r.JoinMode == ArcClip {
|
|
// Find centers of radius of curvature and adjust the radius to be drawn
|
|
// by half the stroke width.
|
|
if p.RT != 0 {
|
|
if p.RT > 0 {
|
|
ct = p.P.Add(ToLength(turnPort90(p.TTan), p.RT))
|
|
rt = p.RT - r.u
|
|
} else {
|
|
ct = p.P.Sub(ToLength(turnPort90(p.TTan), -p.RT))
|
|
rt = -p.RT + r.u
|
|
}
|
|
if rt < 0 {
|
|
rt = 0
|
|
}
|
|
}
|
|
if p.RL != 0 {
|
|
if p.RL > 0 {
|
|
cl = p.P.Add(ToLength(turnPort90(p.LTan), p.RL))
|
|
rl = p.RL - r.u
|
|
} else {
|
|
cl = p.P.Sub(ToLength(turnPort90(p.LTan), -p.RL))
|
|
rl = -p.RL + r.u
|
|
}
|
|
if rl < 0 {
|
|
rl = 0
|
|
}
|
|
}
|
|
}
|
|
|
|
if r.JoinMode == MiterClip || r.JoinMode == Miter ||
|
|
// Arc or ArcClip with 0 tRadCurve and 0 lRadCurve is treated the same as a
|
|
// Miter or MiterClip join, resp.
|
|
((r.JoinMode == Arc || r.JoinMode == ArcClip) && (rt == 0 && rl == 0)) {
|
|
xt := CalcIntersect(s1.Sub(p.TTan), s1, s2, s2.Sub(p.LTan))
|
|
xa := xt.Sub(p.P)
|
|
if Length(xa) < r.mLimit { // within miter limit
|
|
ra.Line(xt)
|
|
ra.Line(s2)
|
|
return
|
|
}
|
|
if r.JoinMode == MiterClip || (r.JoinMode == ArcClip) {
|
|
//Projection of tNorm onto xa
|
|
tProjP := xa.Mul(fixed.Int26_6((DotProd(xa, p.TNorm) << 6) / DotProd(xa, xa)))
|
|
projLen := Length(tProjP)
|
|
if r.mLimit > projLen { // the miter limit line is past the bevel point
|
|
// t is the fraction shifted by tStrokeShift to scale the vectors from the bevel point
|
|
// to the line intersection, so that they abbut the miter limit line.
|
|
tiLength := Length(xa)
|
|
sx1, sx2 := xt.Sub(s1), xt.Sub(s2)
|
|
t := (r.mLimit - projLen) << tStrokeShift / (tiLength - projLen)
|
|
tx := ToLength(sx1, t*Length(sx1)>>tStrokeShift)
|
|
lx := ToLength(sx2, t*Length(sx2)>>tStrokeShift)
|
|
vx := ToLength(xa, t*Length(xa)>>tStrokeShift)
|
|
s1p, _, ap := s1.Add(tx), s2.Add(lx), p.P.Add(vx)
|
|
gLen := Length(ap.Sub(s1p))
|
|
ra.Line(s1p)
|
|
r.JoinGap(ra, ap, ToLength(turnPort90(p.TTan), gLen), ToLength(turnPort90(p.LTan), gLen))
|
|
ra.Line(s2)
|
|
return
|
|
}
|
|
} // Fallthrough
|
|
} else if r.JoinMode == Arc || r.JoinMode == ArcClip {
|
|
// Test for cases of a bezier meeting line, an line meeting a bezier,
|
|
// or a bezier meeting a bezier. (Line meeting line is handled above.)
|
|
switch {
|
|
case rt == 0: // rl != 0, because one must be non-zero as checked above
|
|
xt, intersect := RayCircleIntersection(s1.Add(p.TTan), s1, cl, rl)
|
|
if intersect {
|
|
ray1, ray2 := xt.Sub(cl), s2.Sub(cl)
|
|
clockwise := (ray1.X*ray2.Y > ray1.Y*ray2.X) // Sign of xprod
|
|
if Length(p.P.Sub(xt)) < r.mLimit { // within miter limit
|
|
strokeArc(ra, cl, xt, s2, clockwise, 0, 0, ra.Line)
|
|
ra.Line(s2)
|
|
return
|
|
}
|
|
// Not within miter limit line
|
|
if r.JoinMode == ArcClip { // Scale bevel points towards xt, and call gap func
|
|
xa := xt.Sub(p.P)
|
|
//Projection of tNorm onto xa
|
|
tProjP := xa.Mul(fixed.Int26_6((DotProd(xa, p.TNorm) << 6) / DotProd(xa, xa)))
|
|
projLen := Length(tProjP)
|
|
if r.mLimit > projLen { // the miter limit line is past the bevel point
|
|
// t is the fraction shifted by tStrokeShift to scale the line or arc from the bevel point
|
|
// to the line intersection, so that they abbut the miter limit line.
|
|
sx1 := xt.Sub(s1) //, xt.Sub(s2)
|
|
t := fixed.Int26_6(1<<tStrokeShift) - ((r.mLimit - projLen) << tStrokeShift / (Length(xa) - projLen))
|
|
tx := ToLength(sx1, t*Length(sx1)>>tStrokeShift)
|
|
s1p := xt.Sub(tx)
|
|
ra.Line(s1p)
|
|
sp1, ds1, ps2, _ := strokeArc(ra, cl, xt, s2, clockwise, t, 0, ra.Start)
|
|
ra.Start(s1p)
|
|
// calc gap center as pt where -tnorm and line perp to midcoord
|
|
midP := sp1.Add(s1p).Mul(fixed.Int26_6(1 << 5)) // midpoint
|
|
midLine := turnPort90(midP.Sub(sp1))
|
|
if midLine.X*midLine.X+midLine.Y*midLine.Y > epsilonFixed { // if midline is zero, CalcIntersect is invalid
|
|
ap := CalcIntersect(s1p, s1p.Sub(p.TNorm), midLine.Add(midP), midP)
|
|
gLen := Length(ap.Sub(s1p))
|
|
if clockwise {
|
|
ds1 = Invert(ds1)
|
|
}
|
|
r.JoinGap(ra, ap, ToLength(turnPort90(p.TTan), gLen), ToLength(turnStarboard90(ds1), gLen))
|
|
}
|
|
ra.Line(sp1)
|
|
ra.Start(ps2)
|
|
ra.Line(s2)
|
|
return
|
|
}
|
|
//Bevel points not past miter limit: fallthrough
|
|
}
|
|
}
|
|
case rl == 0: // rt != 0, because one must be non-zero as checked above
|
|
xt, intersect := RayCircleIntersection(s2.Sub(p.LTan), s2, ct, rt)
|
|
if intersect {
|
|
ray1, ray2 := s1.Sub(ct), xt.Sub(ct)
|
|
clockwise := ray1.X*ray2.Y > ray1.Y*ray2.X
|
|
if Length(p.P.Sub(xt)) < r.mLimit { // within miter limit
|
|
strokeArc(ra, ct, s1, xt, clockwise, 0, 0, ra.Line)
|
|
ra.Line(s2)
|
|
return
|
|
}
|
|
// Not within miter limit line
|
|
if r.JoinMode == ArcClip { // Scale bevel points towards xt, and call gap func
|
|
xa := xt.Sub(p.P)
|
|
//Projection of lNorm onto xa
|
|
lProjP := xa.Mul(fixed.Int26_6((DotProd(xa, p.LNorm) << 6) / DotProd(xa, xa)))
|
|
projLen := Length(lProjP)
|
|
if r.mLimit > projLen { // The miter limit line is past the bevel point,
|
|
// t is the fraction to scale the line or arc from the bevel point
|
|
// to the line intersection, so that they abbut the miter limit line.
|
|
sx2 := xt.Sub(s2)
|
|
t := fixed.Int26_6(1<<tStrokeShift) - ((r.mLimit - projLen) << tStrokeShift / (Length(xa) - projLen))
|
|
lx := ToLength(sx2, t*Length(sx2)>>tStrokeShift)
|
|
s2p := xt.Sub(lx)
|
|
_, _, ps2, ds2 := strokeArc(ra, ct, s1, xt, clockwise, 0, t, ra.Line)
|
|
// calc gap center as pt where -lnorm and line perp to midcoord
|
|
midP := s2p.Add(ps2).Mul(fixed.Int26_6(1 << 5)) // midpoint
|
|
midLine := turnStarboard90(midP.Sub(ps2))
|
|
if midLine.X*midLine.X+midLine.Y*midLine.Y > epsilonFixed { // if midline is zero, CalcIntersect is invalid
|
|
ap := CalcIntersect(midP, midLine.Add(midP), s2p, s2p.Sub(p.LNorm))
|
|
gLen := Length(ap.Sub(ps2))
|
|
if clockwise {
|
|
ds2 = Invert(ds2)
|
|
}
|
|
r.JoinGap(ra, ap, ToLength(turnStarboard90(ds2), gLen), ToLength(turnPort90(p.LTan), gLen))
|
|
}
|
|
ra.Line(s2)
|
|
return
|
|
}
|
|
//Bevel points not past miter limit: fallthrough
|
|
}
|
|
}
|
|
default: // Both rl != 0 and rt != 0 as checked above
|
|
xt1, xt2, gIntersect := CircleCircleIntersection(ct, cl, rt, rl)
|
|
xt, intersect := ClosestPortside(s1, s2, xt1, xt2, gIntersect)
|
|
if intersect {
|
|
ray1, ray2 := s1.Sub(ct), xt.Sub(ct)
|
|
clockwiseT := (ray1.X*ray2.Y > ray1.Y*ray2.X)
|
|
ray1, ray2 = xt.Sub(cl), s2.Sub(cl)
|
|
clockwiseL := ray1.X*ray2.Y > ray1.Y*ray2.X
|
|
|
|
if Length(p.P.Sub(xt)) < r.mLimit { // within miter limit
|
|
strokeArc(ra, ct, s1, xt, clockwiseT, 0, 0, ra.Line)
|
|
strokeArc(ra, cl, xt, s2, clockwiseL, 0, 0, ra.Line)
|
|
ra.Line(s2)
|
|
return
|
|
}
|
|
|
|
if r.JoinMode == ArcClip { // Scale bevel points towards xt, and call gap func
|
|
xa := xt.Sub(p.P)
|
|
//Projection of lNorm onto xa
|
|
lProjP := xa.Mul(fixed.Int26_6((DotProd(xa, p.LNorm) << 6) / DotProd(xa, xa)))
|
|
projLen := Length(lProjP)
|
|
if r.mLimit > projLen { // The miter limit line is past the bevel point,
|
|
// t is the fraction to scale the line or arc from the bevel point
|
|
// to the line intersection, so that they abbut the miter limit line.
|
|
t := fixed.Int26_6(1<<tStrokeShift) - ((r.mLimit - projLen) << tStrokeShift / (Length(xa) - projLen))
|
|
_, _, ps1, ds1 := strokeArc(ra, ct, s1, xt, clockwiseT, 0, t, r.Filler.Line)
|
|
ps2, ds2, fs2, _ := strokeArc(ra, cl, xt, s2, clockwiseL, t, 0, ra.Start)
|
|
midP := ps1.Add(ps2).Mul(fixed.Int26_6(1 << 5)) // midpoint
|
|
midLine := turnStarboard90(midP.Sub(ps1))
|
|
ra.Start(ps1)
|
|
if midLine.X*midLine.X+midLine.Y*midLine.Y > epsilonFixed { // if midline is zero, CalcIntersect is invalid
|
|
if clockwiseT {
|
|
ds1 = Invert(ds1)
|
|
}
|
|
if clockwiseL {
|
|
ds2 = Invert(ds2)
|
|
}
|
|
ap := CalcIntersect(midP, midLine.Add(midP), ps2, ps2.Sub(turnStarboard90(ds2)))
|
|
gLen := Length(ap.Sub(ps2))
|
|
r.JoinGap(ra, ap, ToLength(turnStarboard90(ds1), gLen), ToLength(turnStarboard90(ds2), gLen))
|
|
}
|
|
ra.Line(ps2)
|
|
ra.Start(fs2)
|
|
ra.Line(s2)
|
|
return
|
|
}
|
|
}
|
|
}
|
|
// fallthrough to final JoinGap
|
|
}
|
|
}
|
|
r.JoinGap(ra, p.P, p.TNorm, p.LNorm)
|
|
ra.Line(s2)
|
|
return
|
|
}
|
|
|
|
// Stop a stroked line. The line will close
|
|
// is isClosed is true. Otherwise end caps will
|
|
// be drawn at both ends.
|
|
func (r *Stroker) Stop(isClosed bool) {
|
|
if r.inStroke == false {
|
|
return
|
|
}
|
|
rf := &r.Filler
|
|
if isClosed {
|
|
if r.firstP.P != rf.a {
|
|
r.Line(r.firstP.P)
|
|
}
|
|
a := rf.a
|
|
r.firstP.TNorm = r.leadPoint.TNorm
|
|
r.firstP.RT = r.leadPoint.RT
|
|
r.firstP.TTan = r.leadPoint.TTan
|
|
|
|
rf.Start(r.firstP.P.Sub(r.firstP.TNorm))
|
|
rf.Line(a.Sub(r.ln))
|
|
rf.Start(a.Add(r.ln))
|
|
rf.Line(r.firstP.P.Add(r.firstP.TNorm))
|
|
r.Joiner(r.firstP)
|
|
r.firstP.blackWidowMark(rf)
|
|
} else {
|
|
a := rf.a
|
|
rf.Start(r.leadPoint.P.Sub(r.leadPoint.TNorm))
|
|
rf.Line(a.Sub(r.ln))
|
|
rf.Start(a.Add(r.ln))
|
|
rf.Line(r.leadPoint.P.Add(r.leadPoint.TNorm))
|
|
r.CapL(rf, r.leadPoint.P, r.leadPoint.TNorm)
|
|
r.CapT(rf, r.firstP.P, Invert(r.firstP.LNorm))
|
|
}
|
|
r.inStroke = false
|
|
}
|
|
|
|
// QuadBezier starts a stroked quadratic bezier.
|
|
func (r *Stroker) QuadBezier(b, c fixed.Point26_6) {
|
|
r.quadBezierf(r, b, c)
|
|
}
|
|
|
|
// CubeBezier starts a stroked quadratic bezier.
|
|
func (r *Stroker) CubeBezier(b, c, d fixed.Point26_6) {
|
|
r.cubeBezierf(r, b, c, d)
|
|
}
|
|
|
|
// quadBezierf calcs end curvature of beziers
|
|
func (r *Stroker) quadBezierf(s Rasterx, b, c fixed.Point26_6) {
|
|
r.trailPoint = r.leadPoint
|
|
r.CalcEndCurvature(r.a, b, c, c, b, r.a, fixed.Int52_12(2<<12), doCalcCurvature(s))
|
|
r.QuadBezierF(s, b, c)
|
|
r.a = c
|
|
}
|
|
|
|
// doCalcCurvature determines if calculation of the end curvature is required
|
|
// depending on the raster type and JoinMode
|
|
func doCalcCurvature(r Rasterx) bool {
|
|
switch q := r.(type) {
|
|
case *Filler:
|
|
return false // never for filler
|
|
case *Stroker:
|
|
return (q.JoinMode == Arc || q.JoinMode == ArcClip)
|
|
case *Dasher:
|
|
return (q.JoinMode == Arc || q.JoinMode == ArcClip)
|
|
default:
|
|
return true // Better safe than sorry if another raster type is used
|
|
}
|
|
}
|
|
|
|
func (r *Stroker) cubeBezierf(sgm Rasterx, b, c, d fixed.Point26_6) {
|
|
if (r.a == b && c == d) || (r.a == b && b == c) || (c == b && d == c) {
|
|
sgm.Line(d)
|
|
return
|
|
}
|
|
r.trailPoint = r.leadPoint
|
|
// Only calculate curvature if stroking or and using arc or arc-clip
|
|
doCalcCurve := doCalcCurvature(sgm)
|
|
const dm = fixed.Int52_12((3 << 12) / 2)
|
|
switch {
|
|
// b != c, and c != d see above
|
|
case r.a == b:
|
|
r.CalcEndCurvature(b, c, d, d, c, b, dm, doCalcCurve)
|
|
// b != a, and b != c, see above
|
|
case c == d:
|
|
r.CalcEndCurvature(r.a, b, c, c, b, r.a, dm, doCalcCurve)
|
|
default:
|
|
r.CalcEndCurvature(r.a, b, c, d, c, b, dm, doCalcCurve)
|
|
}
|
|
r.CubeBezierF(sgm, b, c, d)
|
|
r.a = d
|
|
}
|
|
|
|
// Line adds a line segment to the rasterizer
|
|
func (r *Stroker) Line(b fixed.Point26_6) {
|
|
r.LineSeg(r, b)
|
|
}
|
|
|
|
//LineSeg is called by both the Stroker and Dasher
|
|
func (r *Stroker) LineSeg(sgm Rasterx, b fixed.Point26_6) {
|
|
r.trailPoint = r.leadPoint
|
|
ba := b.Sub(r.a)
|
|
if ba.X == 0 && ba.Y == 0 { // a == b, line is degenerate
|
|
if r.trailPoint.TTan.X != 0 || r.trailPoint.TTan.Y != 0 {
|
|
ba = r.trailPoint.TTan // Use last tangent for seg tangent
|
|
} else { // Must be on top of last moveto; set ba to X axis unit vector
|
|
ba = fixed.Point26_6{X: 1 << 6, Y: 0}
|
|
}
|
|
}
|
|
bnorm := turnPort90(ToLength(ba, r.u))
|
|
r.trailPoint.LTan = ba
|
|
r.leadPoint.TTan = ba
|
|
r.trailPoint.LNorm = bnorm
|
|
r.leadPoint.TNorm = bnorm
|
|
r.trailPoint.RL = 0.0
|
|
r.leadPoint.RT = 0.0
|
|
r.trailPoint.P = r.a
|
|
r.leadPoint.P = b
|
|
|
|
sgm.joinF()
|
|
sgm.lineF(b)
|
|
r.a = b
|
|
}
|
|
|
|
// lineF is for intra-curve lines. It is required for the Rasterizer interface
|
|
// so that if the line is being stroked or dash stroked, different actions can be
|
|
// taken.
|
|
func (r *Stroker) lineF(b fixed.Point26_6) {
|
|
// b is either an intra-segment value, or
|
|
// the end of the segment.
|
|
var bnorm fixed.Point26_6
|
|
a := r.a // Hold a since r.a is going to change during stroke operation
|
|
if b == r.leadPoint.P { // End of segment
|
|
bnorm = r.leadPoint.TNorm // Use more accurate leadPoint tangent
|
|
} else {
|
|
bnorm = turnPort90(ToLength(b.Sub(a), r.u)) // Intra segment normal
|
|
}
|
|
ra := &r.Filler
|
|
ra.Start(b.Sub(bnorm))
|
|
ra.Line(a.Sub(r.ln))
|
|
ra.Start(a.Add(r.ln))
|
|
ra.Line(b.Add(bnorm))
|
|
r.a = b
|
|
r.ln = bnorm
|
|
}
|
|
|
|
// Start iniitates a stroked path
|
|
func (r *Stroker) Start(a fixed.Point26_6) {
|
|
r.inStroke = false
|
|
r.Filler.Start(a)
|
|
}
|
|
|
|
// CalcEndCurvature calculates the radius of curvature given the control points
|
|
// of a bezier curve.
|
|
// It is a low level function exposed for the purposes of callbacks
|
|
// and debugging.
|
|
func (r *Stroker) CalcEndCurvature(p0, p1, p2, q0, q1, q2 fixed.Point26_6,
|
|
dm fixed.Int52_12, calcRadCuve bool) {
|
|
r.trailPoint.P = p0
|
|
r.leadPoint.P = q0
|
|
r.trailPoint.LTan = p1.Sub(p0)
|
|
r.leadPoint.TTan = q0.Sub(q1)
|
|
r.trailPoint.LNorm = turnPort90(ToLength(r.trailPoint.LTan, r.u))
|
|
r.leadPoint.TNorm = turnPort90(ToLength(r.leadPoint.TTan, r.u))
|
|
if calcRadCuve {
|
|
r.trailPoint.RL = RadCurvature(p0, p1, p2, dm)
|
|
r.leadPoint.RT = -RadCurvature(q0, q1, q2, dm)
|
|
} else {
|
|
r.trailPoint.RL = 0
|
|
r.leadPoint.RT = 0
|
|
}
|
|
}
|
|
|
|
func (r *Stroker) joinF() {
|
|
if r.inStroke == false {
|
|
r.inStroke = true
|
|
r.firstP = r.trailPoint
|
|
} else {
|
|
ra := &r.Filler
|
|
tl := r.trailPoint.P.Sub(r.trailPoint.TNorm)
|
|
th := r.trailPoint.P.Add(r.trailPoint.TNorm)
|
|
if r.a != r.trailPoint.P || r.ln != r.trailPoint.TNorm {
|
|
a := r.a
|
|
ra.Start(tl)
|
|
ra.Line(a.Sub(r.ln))
|
|
ra.Start(a.Add(r.ln))
|
|
ra.Line(th)
|
|
}
|
|
r.Joiner(r.trailPoint)
|
|
r.trailPoint.blackWidowMark(ra)
|
|
}
|
|
r.ln = r.trailPoint.LNorm
|
|
r.a = r.trailPoint.P
|
|
}
|
|
|
|
// blackWidowMark handles a gap in a stroke that can occur when a line end is too close
|
|
// to a segment to segment join point. Although it is only required in those cases,
|
|
// at this point, no code has been written to properly detect when it is needed,
|
|
// so for now it just draws by default.
|
|
func (jp *C2Point) blackWidowMark(ra Adder) {
|
|
xprod := jp.TNorm.X*jp.LNorm.Y - jp.TNorm.Y*jp.LNorm.X
|
|
if xprod > epsilonFixed*epsilonFixed {
|
|
tl := jp.P.Sub(jp.TNorm)
|
|
ll := jp.P.Sub(jp.LNorm)
|
|
ra.Start(jp.P)
|
|
ra.Line(tl)
|
|
ra.Line(ll)
|
|
ra.Line(jp.P)
|
|
} else if xprod < -epsilonFixed*epsilonFixed {
|
|
th := jp.P.Add(jp.TNorm)
|
|
lh := jp.P.Add(jp.LNorm)
|
|
ra.Start(jp.P)
|
|
ra.Line(lh)
|
|
ra.Line(th)
|
|
ra.Line(jp.P)
|
|
}
|
|
}
|