After examining current Go chart options, I find this one to be best-in-class for aesthetics and detail. For my purposes, I'm only missing one key feature: colormaps.

Specifically, for plotting X/Y scatterplots, I have a Z axis of values associated with each X/Y point. I need that Z axis to have its values from Z-min to Z-max mapped to a color range for each point, as shown here.

A good set of colormaps is discussed here and here. As you can see there, the viridis colormap is consistently high performing for the human eye.

Because of the way checkRanges is implemented here: https://github.com/wcharczuk/go-chart/blob/master/chart.go#L274, one can't plot something like f(x)=3.14.

So I was indeed able to use our features from #33 to plot my z values. But it was pretty ugly. I had to index the z value from the x and y float64 values. The only way I could see to do this was to hash x and y using sprintf("%.3f_%.3f", x, y) and map it to the z value:

zFirst := zSequence[0]
zMin, zMax := zFirst, zFirst
for _, z := range zSequence[1:] {
	if z < zMin {
		zMin = z
	}
	if z > zMax {
		zMax = z
	}
}

getHash := func(x, y float64) string {
	hash := sprintf("%.3f_%.3f", x, y)
	return hash
}

zHash := map[string]float64{}
for i, x := range xSequence {
	y := ySequence[i]
	z := zSequence[i]
	hash := getHash(x, y)
	zHash[hash] = z
}

viridisOfZ := func(xr, yr chart.Range, x, y float64) drawing.Color {
	hash := getHash(x, y)
	z := zHash[hash]
	return chart.Viridis(z, zMin, zMax)
}

I think it would be much better to just add and process an optional ZValues in chart.ContinuousSeries the same way XValues and YValues are processed. Then we would need to change DotColorProvider to have tho following signature:

type DotColorProvider func(xrange, yrange, zrange Range, x, y, z float64) drawing.Color

If the ZValues are not defined, the runtime can just send this function 0 for z and have zrange be from 0 to 0.

With this functionality added, my entire program above could be reduced to

viridisOfZ := func(xr, yr, zr chart.Range, x, y, z float64) drawing.Color {
	return chart.Viridis(z, zr.GetMin(), zr.GetMax())
}

I think you would have a much easier time implementing this one than I since you know the flow of the plotting section of the package.

package main

import (
	"fmt"
	"os"

	"github.com/wcharczuk/go-chart"
)

func drawChart() {
	sbc := chart.BarChart{
		Height:   512,
		BarWidth: 60,
		XAxis: chart.Style{
			Show: true,
		},
		YAxis: chart.YAxis{
			Style: chart.Style{
				Show: true,
			},
		},
		Bars: []chart.Value{
			{Value: 0, Label: "Blue"},
			{Value: 0, Label: "Green"},
			{Value: 0, Label: "Gray"},
			{Value: 0, Label: "Orange"},
			{Value: 0, Label: "Test"},
			{Value: 0, Label: "??"},
			{Value: 0, Label: "!!"},
		},
	}

	println("rendering")
	err := sbc.Render(chart.PNG, os.Stdout)
	if err != nil {
		fmt.Printf("Error rendering chart: %v\n", err)
	}
}

func main() {
	drawChart()
}

This PR introduces two new fields on Style: DotWidth and DotColor. It also tweaks some aspects of the raster renderer, namely the .Circle function and some of the inner workings of the drawing package.

Important consideration; so far only Draw.LineSeries uses these new fields, support in other types of plots is ongoing.

Also adds an example for scatter plots in _examples/scatter/main.go.

I'm experimenting with go-chart to replace some python charting (matplotlib), and I need to produce an XY scatter plot with values against time (see attached as a sample).

When I plot these series using go-chart it draws lines between the points, and I couldn't figure out how to plot points/ticks only.

Is it possible? Is this something you're considering? How would you recommend going about this if I were to help implement it? :)

Sample XY scatter plot

As a user I would like to be able to invert a chart axis so that I can show values as having a low absolute value but a high relative value at the top of the graph.

Context I'm charting rank values with 1 being the highest rank and 100 being a lower relative rank. I would like to be able to invert the Y axis so that the higher rank shows as being higher on the chart.

My custom formatter is overlapping the text so I need to either adjust the tick intervals or angle the test. I can see some references in the code to setting text angle but I can't see how it's exposed.

What are my options here.

Also, thanks for being responsive to my other issues :)

I've tried a few different pie charts and and it looks like when one of the segments makes up >50% of the pie that segment is drawn using 360-angle, which in the example below is the orange segment.

This is the png version that I was expecting the svg version to look like:

And here is a screenshot of the svg that I got:

Code Snippet:

	palette := summaryPalette{chart.AlternateColorPalette, myOverrideColors}

	pie := chart.PieChart{
		Width:  width,
		Height: height,
		Values: []chart.Value{
			{Value: notAtDepotRemaining.Value, Label: fmt.Sprintf("Remaining %.0f %s", notAtDepotRemaining.Value, notAtDepotRemaining.Unit)},
			{Value: notAtDepotUsed.Value, Label: fmt.Sprintf("Empty %.0f %s", notAtDepotUsed.Value, notAtDepotUsed.Unit)},
			{Value: depotUsed.Value, Label: fmt.Sprintf("Returned %.0f %s", depotUsed.Value, depotUsed.Unit)},
			{Value: depotRemaining.Value, Label: fmt.Sprintf("Stock %.0f %s", depotRemaining.Value, depotRemaining.Unit)},
		},
		ColorPalette: palette,
	}

        ext := path.Ext(r.URL.Path)
	switch ext {
	case ".png":
		w.Header().Set("Content-Type", "image/png")
		if err := pie.Render(chart.PNG, w); err != nil {
			return fmt.Errorf("PNG: %s", err)
		}

	case ".svg":
		w.Header().Set("Content-Type", "image/svg+xml")
		if err := pie.Render(chart.SVG, w); err != nil {
			return fmt.Errorf("SVG: %s", err)
		}

	default:
		http.NotFound(w, r)
	}

It's possible to show less values / labels on X Axis? It would be great if it could only show minimum, maximum, the middle and maybe 1 or 2 between those.

$ go get github.com/wcharczuk/go-chart

github.com/wcharczuk/go-chart

E:\Code\Go\src\github.com\wcharczuk\go-chart\vector_renderer.go:173: vr.fc.MeasureString(body).Ceil undefined (type fixed.Int26_6 has no field or method Ceil)

intel i7 amd64 win10

When there was only one value for the pie chart the circle was not drawn. The style of the value was not used, and the radius of the circle was not matching the value when there are more than one elements.

It seems that "Circle" does not print a correct circle, the shape is weird. To print the donut hole it does not use "Circle", so I used the same code to draw a single element.

I had a requirement to generate charts that somtimes contain only 1 element(100%)/ But having only one element as input values ends up with just the canvas. Single item donut charts seem to have some custom handling here . https://github.com/wcharczuk/go-chart/blob/c1468e8ae4ed7c6f564f3bb54ae90b563dcf65ce/donut_chart.go#L134

func main() {
	donut := chart.DonutChart{
		Width:  512,
		Height: 512,
		Values: []chart.Value{
			{
				Value: 1,
			},
		},
	}
	f, _ := os.Create("donut.png")
	donut.Render(chart.PNG, f)
	
}

Output(just a white canvas):

Workaround As a workaround I ended up with adding an extra value with a very small value(1e-7) and very small stroke width which triggered the usual rendering. Its not ideal as you can still see a tiny white line but its something.

Values: []chart.Value{
			{
				Value: 1,
				Style: chart.Style{
					StrokeWidth: 1e-7,
				},
			},
			{
				Value: 1e-7,
				Style: chart.Style{
					StrokeWidth: 1e-7,
				},
			},
		},

Output

Trying to put Politics & Government on right side of chart. Despire reordering passed graph.Bars Politics & Government is second anyway

	for i, value := range values {
		j := 0 // 0-9
		switch value.Label {
		case "Family & Relationships":
			j = 0
		case "Entertainment & Music":
			j = 9
		case "Society & Culture":
			j = 2
		case "Health":
			j = 3
		case "Business & Finance":
			j = 4
		case "Education & Reference":
			j = 5
		case "Sports":
			j = 6
		case "Science & Mathematics":
			j = 7
		case "Computers & Internet":
			j = 8
		case "Politics & Government":
			values[i].Label = "ХУЙ" // TODO: изменить порядок баров
			j = 2
		default:
			pp.Println("category not found", value.Label)
		}
		values[i], values[j] = values[j], values[i]
	}

	graph := chart.BarChart{
		Title: text,
		TitleStyle: chart.Style{
			Padding: chart.Box{Bottom: 50},
			Font:    font,
		},
		ColorPalette: nil,
		Width:        1100,
		Height:       600,
		DPI:          0,
		BarWidth:     60,
		Background:   chart.Style{},
		Canvas:       chart.Style{},
		XAxis:        chart.Style{},
		YAxis: chart.YAxis{
			AxisType: chart.YAxisPrimary, // TODO: need chart.YAxisSecondary but Yaxis just crops. Waiting for fixing
		},
		BarSpacing: 0,
		Font:       nil,
		Bars:       values,
		Elements:   nil,
	}

https://i.yapx.cc/UNGAJ.png

This PR builds on top of #199 and it improves some visual issues such as some poorly chosen paddings and it fixes the issue that for several legends users weren't able to provide custom paddings.

To get a feeling how I adjusted the default paddings between vertical legend elements:

Old:

New:

PS: This is a clone of https://github.com/wcharczuk/go-chart/pull/190 since my PR was stale and I wanted to create a clone of this project. Hence I merged other changes into my branch. To have a clean feature branch, I created a new one.

Hey there,

I had some issues with #185 - the line in the legend was just way too long in my charts. So I implemented a legend type that puts the line on the left hand side. That way the legend looks a lot cleaner than before for legends with (at least) one long and one short label.

Let me know what you think about it.

Cheers, Rico

PS: This is a clone of https://github.com/wcharczuk/go-chart/pull/189 since my PR was stale and I wanted to create a clone of this project. Hence I merged other changes into my branch. To have a clean feature branch, I created a new one.