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
311 lines
9.0 KiB
Go
311 lines
9.0 KiB
Go
// Gradient implementation fo rasterx package
|
|
// Copyright 2018 All rights reserved.
|
|
// Created: 5/12/2018 by S.R.Wiley
|
|
|
|
package rasterx
|
|
|
|
import (
|
|
"image/color"
|
|
"math"
|
|
"sort"
|
|
)
|
|
|
|
// SVG bounds paremater constants
|
|
const (
|
|
ObjectBoundingBox GradientUnits = iota
|
|
UserSpaceOnUse
|
|
)
|
|
|
|
// SVG spread parameter constants
|
|
const (
|
|
PadSpread SpreadMethod = iota
|
|
ReflectSpread
|
|
RepeatSpread
|
|
)
|
|
|
|
const epsilonF = 1e-5
|
|
|
|
type (
|
|
// SpreadMethod is the type for spread parameters
|
|
SpreadMethod byte
|
|
// GradientUnits is the type for gradient units
|
|
GradientUnits byte
|
|
// GradStop represents a stop in the SVG 2.0 gradient specification
|
|
GradStop struct {
|
|
StopColor color.Color
|
|
Offset float64
|
|
Opacity float64
|
|
}
|
|
// Gradient holds a description of an SVG 2.0 gradient
|
|
Gradient struct {
|
|
Points [5]float64
|
|
Stops []GradStop
|
|
Bounds struct{ X, Y, W, H float64 }
|
|
Matrix Matrix2D
|
|
Spread SpreadMethod
|
|
Units GradientUnits
|
|
IsRadial bool
|
|
}
|
|
)
|
|
|
|
// ApplyOpacity sets the color's alpha channel to the given value
|
|
func ApplyOpacity(c color.Color, opacity float64) color.NRGBA {
|
|
r, g, b, _ := c.RGBA()
|
|
return color.NRGBA{uint8(r), uint8(g), uint8(b), uint8(opacity * 0xFF)}
|
|
}
|
|
|
|
// tColor takes the paramaterized value along the gradient's stops and
|
|
// returns a color depending on the spreadMethod value of the gradient and
|
|
// the gradient's slice of stop values.
|
|
func (g *Gradient) tColor(t, opacity float64) color.Color {
|
|
d := len(g.Stops)
|
|
// These cases can be taken care of early on
|
|
if t >= 1.0 && g.Spread == PadSpread {
|
|
s := g.Stops[d-1]
|
|
return ApplyOpacity(s.StopColor, s.Opacity*opacity)
|
|
}
|
|
if t <= 0.0 && g.Spread == PadSpread {
|
|
return ApplyOpacity(g.Stops[0].StopColor, g.Stops[0].Opacity*opacity)
|
|
}
|
|
|
|
var modRange = 1.0
|
|
if g.Spread == ReflectSpread {
|
|
modRange = 2.0
|
|
}
|
|
mod := math.Mod(t, modRange)
|
|
if mod < 0 {
|
|
mod += modRange
|
|
}
|
|
|
|
place := 0 // Advance to place where mod is greater than the indicated stop
|
|
for place != len(g.Stops) && mod > g.Stops[place].Offset {
|
|
place++
|
|
}
|
|
switch g.Spread {
|
|
case RepeatSpread:
|
|
var s1, s2 GradStop
|
|
switch place {
|
|
case 0, d:
|
|
s1, s2 = g.Stops[d-1], g.Stops[0]
|
|
default:
|
|
s1, s2 = g.Stops[place-1], g.Stops[place]
|
|
}
|
|
return g.blendStops(mod, opacity, s1, s2, false)
|
|
case ReflectSpread:
|
|
switch place {
|
|
case 0:
|
|
return ApplyOpacity(g.Stops[0].StopColor, g.Stops[0].Opacity*opacity)
|
|
case d:
|
|
// Advance to place where mod-1 is greater than the stop indicated by place in reverse of the stop slice.
|
|
// Since this is the reflect spead mode, the mod interval is two, allowing the stop list to be
|
|
// iterated in reverse before repeating the sequence.
|
|
for place != d*2 && mod-1 > (1-g.Stops[d*2-place-1].Offset) {
|
|
place++
|
|
}
|
|
switch place {
|
|
case d:
|
|
s := g.Stops[d-1]
|
|
return ApplyOpacity(s.StopColor, s.Opacity*opacity)
|
|
case d * 2:
|
|
return ApplyOpacity(g.Stops[0].StopColor, g.Stops[0].Opacity*opacity)
|
|
default:
|
|
return g.blendStops(mod-1, opacity,
|
|
g.Stops[d*2-place], g.Stops[d*2-place-1], true)
|
|
}
|
|
default:
|
|
return g.blendStops(mod, opacity,
|
|
g.Stops[place-1], g.Stops[place], false)
|
|
}
|
|
default: // PadSpread
|
|
switch place {
|
|
case 0:
|
|
return ApplyOpacity(g.Stops[0].StopColor, g.Stops[0].Opacity*opacity)
|
|
case len(g.Stops):
|
|
s := g.Stops[len(g.Stops)-1]
|
|
return ApplyOpacity(s.StopColor, s.Opacity*opacity)
|
|
default:
|
|
return g.blendStops(mod, opacity, g.Stops[place-1], g.Stops[place], false)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (g *Gradient) blendStops(t, opacity float64, s1, s2 GradStop, flip bool) color.Color {
|
|
s1off := s1.Offset
|
|
if s1.Offset > s2.Offset && !flip { // happens in repeat spread mode
|
|
s1off--
|
|
if t > 1 {
|
|
t--
|
|
}
|
|
}
|
|
if s2.Offset == s1off {
|
|
return ApplyOpacity(s2.StopColor, s2.Opacity)
|
|
}
|
|
if flip {
|
|
t = 1 - t
|
|
}
|
|
tp := (t - s1off) / (s2.Offset - s1off)
|
|
r1, g1, b1, _ := s1.StopColor.RGBA()
|
|
r2, g2, b2, _ := s2.StopColor.RGBA()
|
|
|
|
return ApplyOpacity(color.RGBA{
|
|
uint8((float64(r1)*(1-tp) + float64(r2)*tp) / 256),
|
|
uint8((float64(g1)*(1-tp) + float64(g2)*tp) / 256),
|
|
uint8((float64(b1)*(1-tp) + float64(b2)*tp) / 256),
|
|
0xFF}, (s1.Opacity*(1-tp)+s2.Opacity*tp)*opacity)
|
|
}
|
|
|
|
//GetColorFunction returns the color function
|
|
func (g *Gradient) GetColorFunction(opacity float64) interface{} {
|
|
return g.GetColorFunctionUS(opacity, Identity)
|
|
}
|
|
|
|
//GetColorFunctionUS returns the color function using the User Space objMatrix
|
|
func (g *Gradient) GetColorFunctionUS(opacity float64, objMatrix Matrix2D) interface{} {
|
|
switch len(g.Stops) {
|
|
case 0:
|
|
return ApplyOpacity(color.RGBA{0, 0, 0, 255}, opacity) // default error color for gradient w/o stops.
|
|
case 1:
|
|
return ApplyOpacity(g.Stops[0].StopColor, opacity) // Illegal, I think, should really should not happen.
|
|
}
|
|
|
|
// sort by offset in ascending order
|
|
sort.Slice(g.Stops, func(i, j int) bool {
|
|
return g.Stops[i].Offset < g.Stops[j].Offset
|
|
})
|
|
|
|
w, h := float64(g.Bounds.W), float64(g.Bounds.H)
|
|
oriX, oriY := float64(g.Bounds.X), float64(g.Bounds.Y)
|
|
gradT := Identity.Translate(oriX, oriY).Scale(w, h).
|
|
Mult(g.Matrix).Scale(1/w, 1/h).Translate(-oriX, -oriY).Invert()
|
|
|
|
if g.IsRadial {
|
|
cx, cy, fx, fy, rx, ry := g.Points[0], g.Points[1], g.Points[2], g.Points[3], g.Points[4], g.Points[4]
|
|
if g.Units == ObjectBoundingBox {
|
|
cx = g.Bounds.X + g.Bounds.W*cx
|
|
cy = g.Bounds.Y + g.Bounds.H*cy
|
|
fx = g.Bounds.X + g.Bounds.W*fx
|
|
fy = g.Bounds.Y + g.Bounds.H*fy
|
|
rx *= g.Bounds.W
|
|
ry *= g.Bounds.H
|
|
} else {
|
|
cx, cy = g.Matrix.Transform(cx, cy)
|
|
fx, fy = g.Matrix.Transform(fx, fy)
|
|
rx, ry = g.Matrix.TransformVector(rx, ry)
|
|
cx, cy = objMatrix.Transform(cx, cy)
|
|
fx, fy = objMatrix.Transform(fx, fy)
|
|
rx, ry = objMatrix.TransformVector(rx, ry)
|
|
}
|
|
|
|
if cx == fx && cy == fy {
|
|
// When the focus and center are the same things are much simpler;
|
|
// t is just distance from center
|
|
// scaled by the bounds aspect ratio times r
|
|
if g.Units == ObjectBoundingBox {
|
|
return ColorFunc(func(xi, yi int) color.Color {
|
|
x, y := gradT.Transform(float64(xi)+0.5, float64(yi)+0.5)
|
|
dx := float64(x) - cx
|
|
dy := float64(y) - cy
|
|
return g.tColor(math.Sqrt(dx*dx/(rx*rx)+(dy*dy)/(ry*ry)), opacity)
|
|
})
|
|
}
|
|
return ColorFunc(func(xi, yi int) color.Color {
|
|
x := float64(xi) + 0.5
|
|
y := float64(yi) + 0.5
|
|
dx := x - cx
|
|
dy := y - cy
|
|
return g.tColor(math.Sqrt(dx*dx/(rx*rx)+(dy*dy)/(ry*ry)), opacity)
|
|
})
|
|
}
|
|
fx /= rx
|
|
fy /= ry
|
|
cx /= rx
|
|
cy /= ry
|
|
|
|
dfx := fx - cx
|
|
dfy := fy - cy
|
|
|
|
if dfx*dfx+dfy*dfy > 1 { // Focus outside of circle; use intersection
|
|
// point of line from center to focus and circle as per SVG specs.
|
|
nfx, nfy, intersects := RayCircleIntersectionF(fx, fy, cx, cy, cx, cy, 1.0-epsilonF)
|
|
fx, fy = nfx, nfy
|
|
if intersects == false {
|
|
return color.RGBA{255, 255, 0, 255} // should not happen
|
|
}
|
|
}
|
|
if g.Units == ObjectBoundingBox {
|
|
return ColorFunc(func(xi, yi int) color.Color {
|
|
x, y := gradT.Transform(float64(xi)+0.5, float64(yi)+0.5)
|
|
ex := x / rx
|
|
ey := y / ry
|
|
|
|
t1x, t1y, intersects := RayCircleIntersectionF(ex, ey, fx, fy, cx, cy, 1.0)
|
|
if intersects == false { //In this case, use the last stop color
|
|
s := g.Stops[len(g.Stops)-1]
|
|
return ApplyOpacity(s.StopColor, s.Opacity*opacity)
|
|
}
|
|
tdx, tdy := t1x-fx, t1y-fy
|
|
dx, dy := ex-fx, ey-fy
|
|
if tdx*tdx+tdy*tdy < epsilonF {
|
|
s := g.Stops[len(g.Stops)-1]
|
|
return ApplyOpacity(s.StopColor, s.Opacity*opacity)
|
|
}
|
|
return g.tColor(math.Sqrt(dx*dx+dy*dy)/math.Sqrt(tdx*tdx+tdy*tdy), opacity)
|
|
})
|
|
}
|
|
return ColorFunc(func(xi, yi int) color.Color {
|
|
x := float64(xi) + 0.5
|
|
y := float64(yi) + 0.5
|
|
ex := x / rx
|
|
ey := y / ry
|
|
|
|
t1x, t1y, intersects := RayCircleIntersectionF(ex, ey, fx, fy, cx, cy, 1.0)
|
|
if intersects == false { //In this case, use the last stop color
|
|
s := g.Stops[len(g.Stops)-1]
|
|
return ApplyOpacity(s.StopColor, s.Opacity*opacity)
|
|
}
|
|
tdx, tdy := t1x-fx, t1y-fy
|
|
dx, dy := ex-fx, ey-fy
|
|
if tdx*tdx+tdy*tdy < epsilonF {
|
|
s := g.Stops[len(g.Stops)-1]
|
|
return ApplyOpacity(s.StopColor, s.Opacity*opacity)
|
|
}
|
|
return g.tColor(math.Sqrt(dx*dx+dy*dy)/math.Sqrt(tdx*tdx+tdy*tdy), opacity)
|
|
})
|
|
}
|
|
p1x, p1y, p2x, p2y := g.Points[0], g.Points[1], g.Points[2], g.Points[3]
|
|
if g.Units == ObjectBoundingBox {
|
|
p1x = g.Bounds.X + g.Bounds.W*p1x
|
|
p1y = g.Bounds.Y + g.Bounds.H*p1y
|
|
p2x = g.Bounds.X + g.Bounds.W*p2x
|
|
p2y = g.Bounds.Y + g.Bounds.H*p2y
|
|
|
|
dx := p2x - p1x
|
|
dy := p2y - p1y
|
|
d := (dx*dx + dy*dy) // self inner prod
|
|
return ColorFunc(func(xi, yi int) color.Color {
|
|
x, y := gradT.Transform(float64(xi)+0.5, float64(yi)+0.5)
|
|
dfx := x - p1x
|
|
dfy := y - p1y
|
|
return g.tColor((dx*dfx+dy*dfy)/d, opacity)
|
|
})
|
|
}
|
|
|
|
p1x, p1y = g.Matrix.Transform(p1x, p1y)
|
|
p2x, p2y = g.Matrix.Transform(p2x, p2y)
|
|
p1x, p1y = objMatrix.Transform(p1x, p1y)
|
|
p2x, p2y = objMatrix.Transform(p2x, p2y)
|
|
dx := p2x - p1x
|
|
dy := p2y - p1y
|
|
d := (dx*dx + dy*dy)
|
|
// if d == 0.0 {
|
|
// fmt.Println("zero delta")
|
|
// }
|
|
return ColorFunc(func(xi, yi int) color.Color {
|
|
x := float64(xi) + 0.5
|
|
y := float64(yi) + 0.5
|
|
dfx := x - p1x
|
|
dfy := y - p1y
|
|
return g.tColor((dx*dfx+dy*dfy)/d, opacity)
|
|
})
|
|
}
|