path.go

package gg

import (
	"errors"
	"math"

	"github.com/golang/freetype/raster"
	"golang.org/x/image/math/fixed"
)

func flattenPath(p raster.Path) ([][]Point, error) {
	var result = make([][]Point, len(p)*2)
	var path = make([]Point, 0, len(p)*2)
	var cx, cy float64
	for i := 0; i < len(p); {
		switch p[i] {
		case 0:
			if len(path) > 0 {
				result = append(result, path)
				path = nil
			}
			x := unfix(p[i+1])
			y := unfix(p[i+2])
			path = append(path, Point{x, y})
			cx, cy = x, y
			i += 4
		case 1:
			x := unfix(p[i+1])
			y := unfix(p[i+2])
			path = append(path, Point{x, y})
			cx, cy = x, y
			i += 4
		case 2:
			x1 := unfix(p[i+1])
			y1 := unfix(p[i+2])
			x2 := unfix(p[i+3])
			y2 := unfix(p[i+4])
			n := quadraticBezierLen(cx, cy, x1, y1, x2, y2)
			a := len(path)
			path = append(path, make([]Point, n)...)
			if err := quadraticBezier(cx, cy, x1, y1, x2, y2, float64(n)-1, path[a:]); err != nil {
				return nil, err
			}
			cx, cy = x2, y2
			i += 6
		case 3:
			x1 := unfix(p[i+1])
			y1 := unfix(p[i+2])
			x2 := unfix(p[i+3])
			y2 := unfix(p[i+4])
			x3 := unfix(p[i+5])
			y3 := unfix(p[i+6])
			n := cubicBezierLen(cx, cy, x1, y1, x2, y2, x3, y3)
			a := len(path)
			path = append(path, make([]Point, n)...)
			if err := cubicBezier(cx, cy, x1, y1, x2, y2, x3, y3, float64(n)-1, path[a:]); err != nil {
				return nil, err
			}
			cx, cy = x3, y3
			i += 8
		default:
			return nil, errors.New("bad path")
		}
	}
	if len(path) > 0 {
		result = append(result, path)
	}
	return result, nil
}

func dashPath(paths [][]Point, dashes []float64, offset float64) [][]Point {
	if len(dashes) == 0 {
		return paths
	}
	if len(dashes) == 1 {
		dashes = append(dashes, dashes[0])
	}
	var result = make([][]Point, 0, len(paths)*2)
	for _, path := range paths {
		if len(path) < 2 {
			continue
		}
		previous := path[0]
		pathIndex := 1
		dashIndex := 0
		segmentLength := 0.0

		// offset
		if offset != 0 {
			var totalLength float64
			for _, dashLength := range dashes {
				totalLength += dashLength
			}
			offset = math.Mod(offset, totalLength)
			if offset < 0 {
				offset += totalLength
			}
			for i, dashLength := range dashes {
				offset -= dashLength
				if offset < 0 {
					dashIndex = i
					segmentLength = dashLength + offset
					break
				}
			}
		}

		var segment = make([]Point, 0, (len(path)-pathIndex)*2)
		segment = append(segment, previous)
		for pathIndex < len(path) {
			dashLength := dashes[dashIndex]
			point := path[pathIndex]
			d := previous.Distance(point)
			maxd := dashLength - segmentLength
			if d > maxd {
				t := maxd / d
				p := previous.Interpolate(point, t)
				segment = append(segment, p)
				if dashIndex%2 == 0 && len(segment) > 1 {
					result = append(result, segment)
				}
				segment = make([]Point, 0, (len(path)-pathIndex)*2)
				segment = append(segment, p)
				segmentLength = 0
				previous = p
				dashIndex = (dashIndex + 1) % len(dashes)
			} else {
				segment = append(segment, point)
				previous = point
				segmentLength += d
				pathIndex++
			}
		}
		if dashIndex%2 == 0 && len(segment) > 1 {
			result = append(result, segment)
		}
	}
	return result
}

func rasterPath(paths [][]Point) raster.Path {
	var result = make(raster.Path, 0, len(paths))
	for _, path := range paths {
		var previous fixed.Point26_6
		for i, point := range path {
			f := point.Fixed()
			if i == 0 {
				result.Start(f)
			} else {
				dx := f.X - previous.X
				dy := f.Y - previous.Y
				if dx < 0 {
					dx = -dx
				}
				if dy < 0 {
					dy = -dy
				}
				if dx+dy > 8 {
					// TODO: this is a hack for cases where two points are
					// too close - causes rendering issues with joins / caps
					result.Add1(f)
				}
			}
			previous = f
		}
	}
	return result
}

func dashed(path raster.Path, dashes []float64, offset float64) (raster.Path, error) {
	fp, err := flattenPath(path)
	if err != nil {
		return nil, err
	}
	return rasterPath(dashPath(fp, dashes, offset)), nil
}