bel/charts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: bel:3aa9f635bed5cd88dbf380875e3493ba4d313ebd
Branches Tags
bel:main
...
compare: bel:94fb1a97fe593d38d4d9ddc6a3ee22311677f1e5
Branches Tags
bel:main

5 Commits
3aa9f635be ... 94fb1a97fe

Author SHA1 Message Date
Bel LaPointe
94fb1a97fe add legend and series coloring 2024-02-21 13:36:57 -07:00
Bel LaPointe
ac5f3bdc1c log env 2024-02-21 13:34:14 -07:00
Bel LaPointe
3ff2bf0c91 sort by x 2024-02-21 13:28:45 -07:00
Bel LaPointe
0dc484047c upgrade DATA_POINTS to require 3d array but now multi series is ok 2024-02-21 13:19:01 -07:00
Bel LaPointe
83579698c0 accept -graph-type 2024-02-21 12:56:54 -07:00
2 changed files with 108 additions and 52 deletions
Expand all files Collapse all files

100
config.go
View File

@@ -7,6 +7,7 @@ import (
"log"
"net/url"
"os"
"sort"
"slices"
@@ -16,10 +17,13 @@ import (
type Config struct {
Data Data
Output url.URL
Graph struct {
Type string
}
}
type Data struct {
Points [][]float64
Points [][][]float64
Labels []string
Weight struct {
Floor int
@@ -30,22 +34,24 @@ type Data struct {
}
func newConfig() (Config, error) {
dataPoints := envOr("DATA_POINTS", `[[11, 21], [11, 22], [12, 21], [12, 21], [14, 23]]`)
dataPoints := envOr("DATA_POINTS", `[[[11, 21], [12, 22], [12, 21], [14, 23]]]`)
dataLabels := envOr("DATA_LABELS", ``)
dataWeightRange := envOr("DATA_WEIGHT_RANGE", `20`)
dataWeightFloor := envOr("DATA_WEIGHT_FLOOR", `12`)
dataTitle := envOr("DATA_TITLE", ``)
dataSubtitle := envOr("DATA_SUBTITLE", ``)
output := envOr("OUTPUT", `file:///tmp/f`)
output := envOr("OUTPUT", `file:///tmp/f.html`)
graphType := envOr("GRAPH_TYPE", `scatter`)
fs := flag.NewFlagSet("cmd", flag.ContinueOnError)
fs.StringVar(&dataPoints, "data-points", dataPoints, `JSON [[x, y, z, ...]]`)
fs.StringVar(&dataPoints, "data-points", dataPoints, `JSON [[[x, y, z, ...]]]`)
fs.StringVar(&dataLabels, "data-labels", dataLabels, `(optional) JSON ["foo", "bar", "baz"]`)
fs.StringVar(&dataWeightFloor, "data-weight-floor", dataWeightFloor, `int min point size`)
fs.StringVar(&dataWeightRange, "data-weight-range", dataWeightRange, `int max point scale up`)
fs.StringVar(&dataTitle, "data-title", dataTitle, `chart title`)
fs.StringVar(&dataSubtitle, "data-subtitle", dataSubtitle, `chart subtitle`)
fs.StringVar(&output, "output", output, `scheme://location`)
fs.StringVar(&graphType, "graph-type", graphType, `[scatter, line]`)
if err := fs.Parse(os.Args[1:]); err != nil {
return Config{}, err
}
@@ -56,13 +62,16 @@ func newConfig() (Config, error) {
return result, err
}
if len(result.Data.Points) > 0 {
if len(result.Data.Points) > 0 && len(result.Data.Points[0]) > 0 {
expect := len(result.Data.Points[0][0])
for i := range result.Data.Points {
if want := len(result.Data.Points[0]); want != len(result.Data.Points[i]) {
return result, fmt.Errorf("point [%d] expected %d dimensions but found %d", i, want, len(result.Data.Points[i]))
for j := range result.Data.Points[i] {
if got := len(result.Data.Points[i][j]); expect != got {
return result, fmt.Errorf("point [%d] expected %d dimensions but found %d", i, expect, got)
}
}
}
result.Data.Labels = make([]string, len(result.Data.Points[0]))
result.Data.Labels = make([]string, expect)
for i := range result.Data.Labels {
result.Data.Labels[i] = fmt.Sprintf("%c", byte(int('A')+i))
}
@@ -70,8 +79,8 @@ func newConfig() (Config, error) {
if dataLabels == "" {
} else if err := json.Unmarshal([]byte(dataLabels), &result.Data.Labels); err != nil {
return result, err
} else if len(result.Data.Labels) < len(result.Data.Points[0]) {
return result, fmt.Errorf("expected at least %d labels but got %d", len(result.Data.Points[0]), len(result.Data.Labels))
} else if len(result.Data.Labels) < expect {
return result, fmt.Errorf("expected at least %d labels but got %d", expect, len(result.Data.Labels))
}
}
@@ -89,6 +98,7 @@ func newConfig() (Config, error) {
result.Data.Title = dataTitle
result.Data.Subtitle = dataSubtitle
result.Graph.Type = graphType
if u, err := url.Parse(output); err != nil {
return result, fmt.Errorf("failed to parse $OUTPUT (%s): %w", output, err)
@@ -101,20 +111,42 @@ func newConfig() (Config, error) {
func envOr(k, v string) string {
if s := os.Getenv(k); s != "" {
log.Printf("found $%s = %s", k, s)
return s
}
return v
}
func (d Data) AsScatterData() (string, string, []opts.ScatterData, error) {
func scatterAsLineData(data [][]opts.ScatterData) [][]opts.LineData {
result := make([][]opts.LineData, len(data))
for i := range data {
result[i] = make([]opts.LineData, len(data[i]))
for j := range data[i] {
result[i][j] = opts.LineData{
Value: data[i][j].Value,
SymbolSize: data[i][j].SymbolSize,
}
}
}
return result
}
func (d Data) AsScatterData() (string, string, [][]opts.ScatterData, error) {
if !(2 <= len(d.Labels) && len(d.Labels) <= 3) {
return "", "", nil, fmt.Errorf("cannot map %d dimensions to [2,3]", len(d.Labels))
}
d = d.weighXYasZ()
d2 := d
d2.Points = make([][][]float64, len(d.Points))
for i := range d.Points {
d2.Points[i] = weighXYasZ(d.Points[i])
}
d = d2
zs := make([]float64, 0)
for i := range d.Points {
zs = append(zs, d.Points[i][2])
for j := range d.Points[i] {
zs = append(zs, d.Points[i][j][2])
}
}
slices.Sort(zs)
zmin, zmax := zs[0], zs[len(zs)-1]
@@ -124,42 +156,48 @@ func (d Data) AsScatterData() (string, string, []opts.ScatterData, error) {
}
log.Printf("d=%+v zmin=%v zmax=%v zrange=%v", d.Points, zmin, zmax, zrange)
result := make([]opts.ScatterData, 0)
for i := range d.Points {
x := d.Points[i][0]
y := d.Points[i][1]
z := d.Points[i][2]
result = append(result, opts.ScatterData{
Value: []float64{x, y},
SymbolSize: d.Weight.Floor + int((float64(d.Weight.Range)*(z-zmin))/zrange),
})
result := make([][]opts.ScatterData, 0)
for _, series := range d.Points {
subresult := make([]opts.ScatterData, 0)
for i := range series {
x := series[i][0]
y := series[i][1]
z := series[i][2]
subresult = append(subresult, opts.ScatterData{
Value: []float64{x, y},
SymbolSize: d.Weight.Floor + int((float64(d.Weight.Range)*(z-zmin))/zrange),
})
}
result = append(result, subresult)
}
return d.Labels[0], d.Labels[1], result, nil
}
func (d Data) weighXYasZ() Data {
func weighXYasZ(input [][]float64) [][]float64 {
xyz := map[float64]map[float64]float64{}
for i := range d.Points {
x := d.Points[i][0]
for i := range input {
x := input[i][0]
if _, ok := xyz[x]; !ok {
xyz[x] = map[float64]float64{}
}
y := d.Points[i][1]
y := input[i][1]
z := 1.0
if len(d.Labels) > 2 {
z = d.Points[i][2]
if len(input[i]) > 2 {
z = input[i][2]
}
if _, ok := xyz[x][y]; !ok {
xyz[x][y] = 0.0
}
xyz[x][y] += z
}
result := d
result.Points = [][]float64{}
result := [][]float64{}
for x := range xyz {
for y, z := range xyz[x] {
result.Points = append(result.Points, []float64{x, y, z})
result = append(result, []float64{x, y, z})
}
}
sort.Slice(result, func(i, j int) bool {
return result[i][0] < result[j][0]
})
return result
}

60
main.go
View File

@@ -33,20 +33,22 @@ func run(ctx context.Context) error {
}
log.Printf("%s: (%s, %s) = %v", config.Data.Title, x, y, data)
minX, maxX := data[0].Value.([]float64)[0], data[0].Value.([]float64)[0]
minY, maxY := data[0].Value.([]float64)[1], data[0].Value.([]float64)[1]
for _, datum := range data {
x := datum.Value.([]float64)[0]
if x < minX {
minX = x
} else if x > maxX {
maxX = x
}
y := datum.Value.([]float64)[1]
if y < minY {
minY = y
} else if y > maxY {
maxY = y
minX, maxX := data[0][0].Value.([]float64)[0], data[0][0].Value.([]float64)[0]
minY, maxY := data[0][0].Value.([]float64)[1], data[0][0].Value.([]float64)[1]
for _, series := range data {
for _, datum := range series {
x := datum.Value.([]float64)[0]
if x < minX {
minX = x
} else if x > maxX {
maxX = x
}
y := datum.Value.([]float64)[1]
if y < minY {
minY = y
} else if y > maxY {
maxY = y
}
}
}
@@ -64,8 +66,7 @@ func run(ctx context.Context) error {
}
log.Printf("x=[%v, %v] y=[%v, %v]", minX, maxX, minY, maxY)
scatter := charts.NewScatter()
scatter.SetGlobalOptions(
globalOpts := []charts.GlobalOpts{
charts.WithTitleOpts(opts.Title{
Title: config.Data.Title,
Subtitle: config.Data.Subtitle,
@@ -74,7 +75,7 @@ func run(ctx context.Context) error {
Show: true,
Formatter: `{c}`,
}),
charts.WithLegendOpts(opts.Legend{Show: false}),
charts.WithLegendOpts(opts.Legend{Show: true}),
charts.WithXAxisOpts(opts.XAxis{
Name: x,
NameLocation: "middle",
@@ -89,12 +90,29 @@ func run(ctx context.Context) error {
Min: minY,
Max: maxY,
}),
)
scatter.AddSeries(y, data)
}
buff := bytes.NewBuffer(nil)
if err := scatter.Render(buff); err != nil {
return err
switch config.Graph.Type {
case "line":
line := charts.NewLine()
line.SetGlobalOptions(globalOpts...)
for i, series := range scatterAsLineData(data) {
line.AddSeries(fmt.Sprintf("%s[%d]", y, i), series)
}
if err := line.Render(buff); err != nil {
return err
}
case "scatter":
scatter := charts.NewScatter()
scatter.SetGlobalOptions(globalOpts...)
for i, series := range data {
scatter.AddSeries(fmt.Sprintf("%s[%d]", y, i), series)
}
if err := scatter.Render(buff); err != nil {
return err
}
}
switch config.Output.Scheme {