svgpath.go

// Package svgpath provides functionality for working with SVG paths.
package svgpath

import (
	"encoding/binary"
	"fmt"
	"strconv"

	"github.com/hfoxy/svgpath"
)

// Compress compresses a SVG path into an optimised
// binary format. It may return the input value.
func Compress(path string) ([]byte, error) {
	segs, err := svgpath.Parse(path)
	if err != nil {
		return nil, err
	}

	// The SVG 1.1 specification allows "moveto" commands
	// to be followed by implicit "lineto" commands. It
	// also allows for a continuation of arguments of the
	// same command.
	//
	// Assume that the parser returns indivually commands
	// with only a single set of arguments.

	var buf []byte
	for _, seg := range segs {
		cmd := makeCommand(seg.Command)
		if cmd == 0 {
			return nil, fmt.Errorf("invalid command %q", seg.Command)
		}
		buf = binary.AppendVarint(buf, int64(cmd))
		for _, f := range seg.Args {
			buf = binary.AppendVarint(buf, int64(f*1000))
		}
	}

	// don't make output bigger
	if len(buf) > len(path) {
		return []byte(path), nil
	}

	return buf, nil
}

const (
	invalidCmd command = iota
	cmdM
	cmdZ
	cmdL
	cmdH
	cmdV
	cmdC
	cmdS
	cmdQ
	cmdT
	cmdA
)

type command int8

func makeCommand(r rune) (cmd command) {
	switch r | ('a' - 'A') { // make lower case
	case 'm':
		cmd = cmdM
	case 'z':
		cmd = cmdZ
	case 'l':
		cmd = cmdL
	case 'h':
		cmd = cmdH
	case 'v':
		cmd = cmdV
	case 'c':
		cmd = cmdC
	case 's':
		cmd = cmdS
	case 'q':
		cmd = cmdQ
	case 't':
		cmd = cmdT
	case 'a':
		cmd = cmdA
	}
	if 'a' <= r && r <= 'z' {
		cmd = -cmd
	}
	return cmd
}

// Decompress decompresses an encoded SVG path.
func Decompress(data string) (string, error) {
	if data == "" {
		return data, nil
	}

	// paths always start with a moveto command
	// if found the data is uncompressed
	if data[0] == 'M' || data[0] == 'm' {
		return data, nil
	}

	buf := make([]byte, 0, len(data)*2)
	off := 0
	var lastCmd command
	for {
		if len(data[off:]) == 0 {
			break
		}
		v, n := binary.Varint([]byte(data[off:]))
		if n <= 0 {
			return "", fmt.Errorf("error reading command at offset %d", off)
		}
		off += n

		var letter byte
		var nargs int
		cmd := command(v)
		if v < 0 {
			cmd = -cmd
		}
		switch cmd {
		case cmdM:
			letter, nargs = 'M', 2
		case cmdZ:
			letter, nargs = 'Z', 0
		case cmdL:
			letter, nargs = 'L', 2
		case cmdH:
			letter, nargs = 'H', 1
		case cmdV:
			letter, nargs = 'V', 1
		case cmdC:
			letter, nargs = 'C', 6
		case cmdS:
			letter, nargs = 'S', 4
		case cmdQ:
			letter, nargs = 'Q', 4
		case cmdT:
			letter, nargs = 'T', 2
		case cmdA:
			letter, nargs = 'A', 7
		}
		if v < 0 {
			// commmand is relative
			// make letter lower case
			letter |= ('a' - 'A')
		}
		if letter == 0 {
			return "", fmt.Errorf("bad command at offset %d", off)
		}

		if lastCmd == 0 || lastCmd != cmd && lastCmd == cmdM && cmd != cmdL {
			lastCmd = cmd
			buf = append(buf, letter)
		}

		for i := 0; i < nargs; i++ {
			v, n := binary.Varint([]byte(data[off:]))
			if n <= 0 {
				return "", fmt.Errorf("error reading argument at offset %d", off)
			}
			f := float64(v) / 1000
			buf = append(buf, ' ')
			buf = strconv.AppendFloat(buf, f, 'f', -1, 64)
			off += n
		}
	}

	return string(buf), nil
}