package main

import (
	"image"
	"image/png"
	"os"

	"github.com/srwiley/oksvg"
	"github.com/srwiley/rasterx"
)

func main() {
	scale := 2.0

	in, err := os.Open("in.svg")
	check(err)
	defer in.Close()

	icon, err := oksvg.ReadIconStream(in)
	check(err)

	w, h := int(icon.ViewBox.W*scale), int(icon.ViewBox.H*scale)

	icon.SetTarget(0, 0, float64(w), float64(h))
	rgba := image.NewRGBA(image.Rect(0, 0, w, h))
	dasher := rasterx.NewDasher(w, h, rasterx.NewScannerGV(w, h, rgba, rgba.Bounds()))
	icon.Draw(dasher, 1)

	out, err := os.Create("out.png")
	check(err)
	defer out.Close()

	err = png.Encode(out, rgba)
	check(err)
}

func check(err error) {
	if err != nil {
		panic(err)
	}
}

diff --git a/gradient.go b/gradient.go
index 6be8fe7..8f00985 100644
--- a/gradient.go
+++ b/gradient.go
@@ -189,8 +189,10 @@ func (g *Gradient) GetColorFunctionUS(opacity float64, objMatrix Matrix2D) inter
 			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)
 		}
 
@@ -203,7 +205,7 @@ func (g *Gradient) GetColorFunctionUS(opacity float64, objMatrix Matrix2D) inter
 					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 g.tColor(math.Sqrt((dx*dx)/(rx*rx)+(dy*dy)/(ry*ry)), opacity)
 				})
 			}
 			return ColorFunc(func(xi, yi int) color.Color {
@@ -211,7 +213,7 @@ func (g *Gradient) GetColorFunctionUS(opacity float64, objMatrix Matrix2D) inter
 				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)
+				return g.tColor(math.Sqrt((dx*dx)/(rx*rx)+(dy*dy)/(ry*ry)), opacity)
 			})
 		}
 		fx /= rx

	cx, cy := float64(w/2.0), float64(h/2.0)
	r := float64(w / 3.0)
	angle := 45.0
	rot := angle * math.Pi / 180.0

	// find the point on circle of radius r at angle rot
	px := cx + r*math.Cos(rot)
	py := cy + r*math.Sin(rot)

	points := []float64{r, r, angle, 1, 0, px, py}

	stroker.Start(rasterx.ToFixedP(cx, cy))
	//stroker.Line(rasterx.ToFixedP(cx, cy+r))
	stroker.Start(rasterx.ToFixedP(px, py))
	rasterx.AddArc(points, cx, cy, px, py, stroker)
	//stroker.Stop(false)
	//stroker.Line(rasterx.ToFixedP(cx, cy))
	stroker.Stop(false)
	stroker.Draw()

	stroker.Start(rasterx.ToFixedP(cx, cy))
	stroker.Line(rasterx.ToFixedP(cx, cy+r))
	stroker.Start(rasterx.ToFixedP(px, py))
	rasterx.AddArc(points, cx, cy, px, py, stroker)
	stroker.Line(rasterx.ToFixedP(cx, cy))
	stroker.Stop(false)
	stroker.Draw()

package main

import (
	"image"
	"image/color"
	"image/draw"
	"log"

	"golang.org/x/exp/shiny/driver"
	"golang.org/x/exp/shiny/screen"
	"golang.org/x/exp/shiny/widget"

	"golang.org/x/image/math/fixed"

	"github.com/srwiley/rasterx"
)

const (
	S = 512
)

func main() {
	log.SetFlags(0)
	driver.Main(func(s screen.Screen) {
		src := TestMultiFunctionGV() // image.NewRGBA(image.Rect(0, 0, sw, sh))

		w := widget.NewSheet(widget.NewImage(src, src.Bounds()))
		if err := widget.RunWindow(s, w, &widget.RunWindowOptions{
			NewWindowOptions: screen.NewWindowOptions{
				Title:  "Rasterx Example",
				Width:  S,
				Height: S,
			},
		}); err != nil {
			log.Fatal(err)
		}
	})
}

//////////////////////////////////////////////////////

func toFixedP(x, y float64) (p fixed.Point26_6) {
	p.X = fixed.Int26_6(x * 64)
	p.Y = fixed.Int26_6(y * 64)
	return
}

func GetTestPath() (testPath rasterx.Path) {
	//Path for Q
	//M210.08,222.97
	testPath.Start(toFixedP(210.08, 222.97))
	//L192.55,244.95
	testPath.Line(toFixedP(192.55, 244.95))
	//Q146.53,229.95,115.55,209.55
	testPath.QuadBezier(toFixedP(146.53, 229.95), toFixedP(115.55, 209.55))
	//Q102.50,211.00,95.38,211.00
	testPath.QuadBezier(toFixedP(102.50, 211.00), toFixedP(95.38, 211.00))
	//Q56.09,211.00,31.17,182.33
	testPath.QuadBezier(toFixedP(56.09, 211.00), toFixedP(31.17, 182.33))
	//Q6.27,153.66,6.27,108.44
	testPath.QuadBezier(toFixedP(6.27, 153.66), toFixedP(6.27, 108.44))
	//Q6.27,61.89,31.44,33.94
	testPath.QuadBezier(toFixedP(6.27, 61.89), toFixedP(31.44, 33.94))
	//Q56.62,6.00,98.55,6.00
	testPath.QuadBezier(toFixedP(56.62, 6.00), toFixedP(98.55, 6.00))
	//Q141.27,6.00,166.64,33.88
	testPath.QuadBezier(toFixedP(141.27, 6.00), toFixedP(166.64, 33.88))
	//Q192.02,61.77,192.02,108.70
	testPath.QuadBezier(toFixedP(192.02, 61.77), toFixedP(192.02, 108.70))
	//Q192.02,175.67,140.86,202.05
	testPath.QuadBezier(toFixedP(192.02, 175.67), toFixedP(140.86, 202.05))
	//Q173.42,216.66,210.08,222.97
	testPath.QuadBezier(toFixedP(173.42, 216.66), toFixedP(210.08, 222.97))
	//z
	testPath.Stop(false)
	//M162.22,109.69 M162.22,109.69
	testPath.Start(toFixedP(162.22, 109.69))
	//Q162.22,70.11,145.61,48.55
	testPath.QuadBezier(toFixedP(162.22, 70.11), toFixedP(145.61, 48.55))
	//Q129.00,27.00,98.42,27.00
	testPath.QuadBezier(toFixedP(129.00, 27.00), toFixedP(98.42, 27.00))
	//Q69.14,27.00,52.53,48.62
	testPath.QuadBezier(toFixedP(69.14, 27.00), toFixedP(52.53, 48.62))
	//Q35.92,70.25,35.92,108.50
	testPath.QuadBezier(toFixedP(35.92, 70.25), toFixedP(35.92, 108.50))
	//Q35.92,146.75,52.53,168.38
	testPath.QuadBezier(toFixedP(35.92, 146.75), toFixedP(52.53, 168.38))
	//Q69.14,190.00,98.42,190.00
	testPath.QuadBezier(toFixedP(69.14, 190.00), toFixedP(98.42, 190.00))
	//Q128.34,190.00,145.28,168.70
	testPath.QuadBezier(toFixedP(128.34, 190.00), toFixedP(145.28, 168.70))
	//Q162.22,147.41,162.22,109.69
	testPath.QuadBezier(toFixedP(162.22, 147.41), toFixedP(162.22, 109.69))
	//z
	testPath.Stop(false)

	return testPath
}

// TestMultiFunction tests a Dasher's ability to function
// as a filler, stroker, and dasher by invoking the corresponding anonymous structs
func TestMultiFunctionGV() image.Image {
	img := image.NewRGBA(image.Rect(0, 0, S, S))
	src := image.NewUniform(color.NRGBA{255, 0, 0, 255})
	scannerGV := rasterx.NewScannerGV(S, S, img, img.Bounds(), src, image.ZP)

	draw.Draw(img, img.Bounds(), image.White, image.ZP, draw.Src)

	d := rasterx.NewDasher(S, S, scannerGV)
	d.SetStroke(10*64, 4*64, rasterx.RoundCap, nil, rasterx.RoundGap, rasterx.ArcClip, []float64{33, 12}, 0)
	p := GetTestPath()

	p.AddTo(d)
	d.Draw()
	d.Clear()
	return img
}

// Human readable path constants
const (
	PathMoveTo PathCommand = iota
	PathLineTo
	PathQuadTo
	PathCubicTo
	PathClose
	PathCloseF
)

// Close joins the ends of the path
func (p *Path) Stop(closeLoop bool) {
	if closeLoop {
		*p = append(*p, fixed.Int26_6(PathClose))
	} else {
		*p = append(*p, fixed.Int26_6(PathCloseF))
	}
}

// AddPath adds the Path p to q. This bridges the path and adder interface.
func (p Path) AddTo(q Adder) {
	for i := 0; i < len(p); {
		switch PathCommand(p[i]) {
		case PathMoveTo:
			q.Start(fixed.Point26_6{p[i+1], p[i+2]})
			i += 3
		case PathLineTo:
			q.Line(fixed.Point26_6{p[i+1], p[i+2]})
			i += 3
		case PathQuadTo:
			q.QuadBezier(fixed.Point26_6{p[i+1], p[i+2]}, fixed.Point26_6{p[i+3], p[i+4]})
			i += 5
		case PathCubicTo:
			q.CubeBezier(fixed.Point26_6{p[i+1], p[i+2]},
				fixed.Point26_6{p[i+3], p[i+4]}, fixed.Point26_6{p[i+5], p[i+6]})
			i += 7
		case PathClose:
			q.Stop(true)
			i += 1
		case PathCloseF:
		 	q.Stop(false)
		  	i += 1
		default:
			panic("adder geom: bad path")
		}
	}
	q.Stop(false)
}