add legend and series coloring

config.go

@@ -0,0 +1,203 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+	"sort"
+
+	"slices"
+
+	"github.com/go-echarts/go-echarts/v2/opts"
+)
+
+type Config struct {
+	Data   Data
+	Output url.URL
+	Graph  struct {
+		Type string
+	}
+}
+
+type Data struct {
+	Points [][][]float64
+	Labels []string
+	Weight struct {
+		Floor int
+		Range int
+	}
+	Title    string
+	Subtitle string
+}
+
+func newConfig() (Config, error) {
+	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.html`)
+	graphType := envOr("GRAPH_TYPE", `scatter`)
+
+	fs := flag.NewFlagSet("cmd", flag.ContinueOnError)
+	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
+	}
+
+	var result Config
+
+	if err := json.Unmarshal([]byte(dataPoints), &result.Data.Points); err != nil {
+		return result, err
+	}
+
+	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 {
+			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, expect)
+		for i := range result.Data.Labels {
+			result.Data.Labels[i] = fmt.Sprintf("%c", byte(int('A')+i))
+		}
+
+		if dataLabels == "" {
+		} else if err := json.Unmarshal([]byte(dataLabels), &result.Data.Labels); err != nil {
+			return result, err
+		} else if len(result.Data.Labels) < expect {
+			return result, fmt.Errorf("expected at least %d labels but got %d", expect, len(result.Data.Labels))
+		}
+	}
+
+	if err := json.Unmarshal([]byte(dataWeightRange), &result.Data.Weight.Range); err != nil {
+		return result, err
+	} else if result.Data.Weight.Range < 0 {
+		return result, fmt.Errorf("found negative weight range %d", result.Data.Weight.Range)
+	}
+
+	if err := json.Unmarshal([]byte(dataWeightFloor), &result.Data.Weight.Floor); err != nil {
+		return result, err
+	} else if result.Data.Weight.Floor < 0 {
+		return result, fmt.Errorf("found negative weight floor %d", result.Data.Weight.Floor)
+	}
+
+	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)
+	} else {
+		result.Output = *u
+	}
+
+	return result, nil
+}
+
+func envOr(k, v string) string {
+	if s := os.Getenv(k); s != "" {
+		log.Printf("found $%s = %s", k, s)
+		return s
+	}
+	return v
+}
+
+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))
+	}
+	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 {
+		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]
+	zrange := zmax - zmin
+	if zrange == 0 {
+		zrange = 1
+	}
+	log.Printf("d=%+v zmin=%v zmax=%v zrange=%v", d.Points, zmin, zmax, 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 weighXYasZ(input [][]float64) [][]float64 {
+	xyz := map[float64]map[float64]float64{}
+	for i := range input {
+		x := input[i][0]
+		if _, ok := xyz[x]; !ok {
+			xyz[x] = map[float64]float64{}
+		}
+		y := input[i][1]
+		z := 1.0
+		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 := [][]float64{}
+	for x := range xyz {
+		for y, z := range xyz[x] {
+			result = append(result, []float64{x, y, z})
+		}
+	}
+	sort.Slice(result, func(i, j int) bool {
+		return result[i][0] < result[j][0]
+	})
+	return result
+}

go.mod

@@ -1,3 +1,5 @@
 module charts
 
 go 1.21.1
+
+require github.com/go-echarts/go-echarts/v2 v2.3.3 // indirect

go.sum

@@ -0,0 +1,2 @@
+github.com/go-echarts/go-echarts/v2 v2.3.3 h1:uImZAk6qLkC6F9ju6mZ5SPBqTyK8xjZKwSmwnCg4bxg=
+github.com/go-echarts/go-echarts/v2 v2.3.3/go.mod h1:56YlvzhW/a+du15f3S2qUGNDfKnFOeJSThBIrVFHDtI=

main.go

@@ -1,9 +1,15 @@
 package main
 
 import (
+	"bytes"
 	"context"
-	"io"
+	"fmt"
+	"log"
+	"os"
 	"os/signal"
+
+	"github.com/go-echarts/go-echarts/v2/charts"
+	"github.com/go-echarts/go-echarts/v2/opts"
 )
 
 func main() {
@@ -15,5 +21,103 @@ func main() {
 }
 
 func run(ctx context.Context) error {
-	return io.EOF
+	config, err := newConfig()
+	if err != nil {
+		return err
+	}
+	log.Printf("%+v", config)
+
+	x, y, data, err := config.Data.AsScatterData()
+	if err != nil {
+		return err
+	}
+	log.Printf("%s: (%s, %s) = %v", config.Data.Title, x, y, data)
+
+	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
+			}
+		}
+	}
+
+	if 0 <= minX && minX <= 1 {
+		minX = 0
+	} else if 1 <= minX {
+		minX -= 1
+		maxX += 1
+	}
+	if 0 <= minY && minY <= 1 {
+		minY = 0
+	} else if 1 <= minY {
+		minY -= 1
+		maxY += 1
+	}
+	log.Printf("x=[%v, %v] y=[%v, %v]", minX, maxX, minY, maxY)
+
+	globalOpts := []charts.GlobalOpts{
+		charts.WithTitleOpts(opts.Title{
+			Title:    config.Data.Title,
+			Subtitle: config.Data.Subtitle,
+		}),
+		charts.WithTooltipOpts(opts.Tooltip{
+			Show:      true,
+			Formatter: `{c}`,
+		}),
+		charts.WithLegendOpts(opts.Legend{Show: true}),
+		charts.WithXAxisOpts(opts.XAxis{
+			Name:         x,
+			NameLocation: "middle",
+			NameGap:      config.Data.Weight.Floor + config.Data.Weight.Range,
+			Min:          minX,
+			Max:          maxX,
+		}),
+		charts.WithYAxisOpts(opts.YAxis{
+			Name:         y,
+			NameLocation: "middle",
+			NameGap:      config.Data.Weight.Floor + config.Data.Weight.Range,
+			Min:          minY,
+			Max:          maxY,
+		}),
+	}
+
+	buff := bytes.NewBuffer(nil)
+
+	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 {
+	case "file":
+		return os.WriteFile(config.Output.Path, buff.Bytes(), os.ModePerm)
+	}
+	return fmt.Errorf("not impl output scheme: %s", config.Output.Scheme)
 }