aboutsummaryrefslogtreecommitdiff
path: root/hershey.go
blob: 585f3cedfe4f192610572022269b66b272dad838 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
	"strconv"
	"strings"
)

type Unit float64

type Point struct {
	X, Y Unit
}

type Path []Point
type Set []Path

type Glyph struct {
	S Set
	W Unit
}

type Font map[rune]Glyph

func parseInt(s string) (n int) {
	s = strings.TrimSpace(s)
	n, _ = strconv.Atoi(s)
	return
}

func parsePoint(in uint8) Unit {
	return Unit(in) - Unit('R')
}

func parseData(s string, w, h, scale Unit) Set {
	var st Set
	for i, el := range strings.Fields(s) {
		var ph Path
		if i > 0 {
			el = el[1:]
		}
		for n := 0; n < len(el); n += 2 {
			var p Point
			p.Y = scale * (w/2 + parsePoint(el[n]))
			p.X = scale * (h/2 + parsePoint(el[n+1]))
			ph = append(ph, p)
		}
		st = append(st, ph)
	}
	return st
}

func loadFont(fname string, scale Unit) Font {
	fnt := make(Font)

	f, err := os.Open(fname)
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
		line := scanner.Text()
		n := parseInt(line[0:5])
		//k := parseInt(line[5:8])
		l := parsePoint(line[8])
		r := parsePoint(line[9])
		w := r - l
		fnt[rune(n)] = Glyph{
			S: parseData(line[10:], w, 32, scale),
			W: w * scale,
		}
	}
	if err := scanner.Err(); err != nil {
		log.Fatal(err)
	}
	return fnt
}

func (p Point) String() string {
	return fmt.Sprintf("%v,%v,", p.X, p.Y)
}

func (p Path) String() (s string) {
	//s = fmt.Sprint("Y0,", p[0])
	s = fmt.Sprint("M", p[0], "D")
	for _, pt := range p[1:] {
		s += fmt.Sprint(pt)
	}
	return
}

func (st Set) String() (s string) {
	for _, p := range st {
		s += fmt.Sprint(p)
	}
	return
}

func (g Glyph) String() string {
	return fmt.Sprint(g.S)
}

func (f Font) Select(n []int) Font {
	ret := make(Font)
	for i, p := range n {
		ret[rune(i+32)] = f[rune(p)]
	}
	return ret
}