examples, some fixes

examples/annotations/main.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+
+	/*
+	   In this example we add an `Annotation` series, which is a special type of series that
+	   draws annotation labels at given X and Y values (as translated by their respective ranges).
+
+	   It is important to not that the chart automatically sizes the canvas box to fit the annotations,
+	   As well as automatically assign a series color for the `Stroke` or border component of the series.
+
+	   The annotation series is most often used by the original author to show the last value of another series, but
+	   they can be used in other capacities as well.
+	*/
+
+	graph := chart.Chart{
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+			chart.AnnotationSeries{
+				Annotations: []chart.Annotation{
+					{X: 1.0, Y: 1.0, Label: "One"},
+					{X: 2.0, Y: 2.0, Label: "Two"},
+					{X: 3.0, Y: 3.0, Label: "Three"},
+					{X: 4.0, Y: 4.0, Label: "Four"},
+					{X: 5.0, Y: 5.0, Label: "Five"},
+				},
+			},
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.ListenAndServe(":8080", nil)
+}

examples/axes/main.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+
+	/*
+	   The below will draw the same chart as the `basic` example, except with both the x and y axes turned on.
+	   In this case, both the x and y axis ticks are generated automatically, the x and y ranges are established automatically, the canvas "box" is adjusted to fit the space the axes occupy so as not to clip.
+	*/
+
+	graph := chart.Chart{
+		XAxis: chart.XAxis{
+			Style: chart.Style{
+				Show: true, //enables / displays the x-axis
+			},
+		},
+		YAxis: chart.YAxis{
+			Style: chart.Style{
+				Show: true, //enables / displays the y-axis
+			},
+		},
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.ListenAndServe(":8080", nil)
+}

examples/basic/main.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+	graph := chart.Chart{
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func drawChartWide(res http.ResponseWriter, req *http.Request) {
+	graph := chart.Chart{
+		Width: 1920, //this overrides the default.
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.HandleFunc("/wide", drawChartWide)
+	http.ListenAndServe(":8080", nil)
+}

examples/custom_formatters/main.go

@@ -0,0 +1,44 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+	/*
+	   In this example we use a custom `ValueFormatter` for the y axis, letting us specify how to format text of the y-axis ticks.
+	   You can also do this for the x-axis, or the secondary y-axis.
+	   This example also shows what the chart looks like with the x-axis left off or not shown.
+	*/
+
+	graph := chart.Chart{
+		YAxis: chart.YAxis{
+			Style: chart.Style{
+				Show: true,
+			},
+			ValueFormatter: func(v interface{}) string {
+				if vf, isFloat := v.(float64); isFloat {
+					return fmt.Sprintf("%0.6f", vf)
+				}
+				return ""
+			},
+		},
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.ListenAndServe(":8080", nil)
+}

examples/custom_ranges/main.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+	/*
+	   In this example we set a custom range for the y-axis, overriding the automatic range generation.
+	   Note: the chart will still generate the ticks automatically based on the custom range, so the intervals may be a bit weird.
+	*/
+
+	graph := chart.Chart{
+		YAxis: chart.YAxis{
+			Style: chart.Style{
+				Show: true,
+			},
+			Range: chart.Range{
+				Min: 0.0,
+				Max: 10.0,
+			},
+		},
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.ListenAndServe(":8080", nil)
+}

examples/custom_styles/main.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+	"github.com/wcharczuk/go-chart/drawing"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+	/*
+	   In this example we set some custom colors for the series and the chart background and canvas.
+	*/
+	graph := chart.Chart{
+		Background: chart.Style{
+			FillColor: drawing.ColorBlue,
+		},
+		Canvas: chart.Style{
+			FillColor: drawing.ColorFromHex("efefef"),
+		},
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				Style: chart.Style{
+					Show:        true,                           //note; if we set ANY other properties, we must set this to true.
+					StrokeColor: drawing.ColorRed,               // will supercede defaults
+					FillColor:   drawing.ColorRed.WithAlpha(64), // will supercede defaults
+				},
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.ListenAndServe(":8080", nil)
+}

examples/custom_ticks/main.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+	/*
+	   In this example we set a custom set of ticks to use for the y-axis. It can be (almost) whatever you want, including some custom labels for ticks.
+	   Custom ticks will supercede a custom range, which will supercede automatic generation based on series values.
+	*/
+
+	graph := chart.Chart{
+		YAxis: chart.YAxis{
+			Style: chart.Style{
+				Show: true,
+			},
+			Range: chart.Range{
+				Min: 0.0,
+				Max: 4.0,
+			},
+			Ticks: []chart.Tick{
+				{0.0, "0.00"},
+				{2.0, "2.00"},
+				{4.0, "4.00"},
+				{6.0, "6.00"},
+				{8.0, "Eight"},
+				{10.0, "Ten"},
+			},
+		},
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.ListenAndServe(":8080", nil)
+}

examples/legend/main.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+
+	/*
+	   In this example we add a `Renderable` or a custom component to the `Elements` array.
+	   In this specific case it is a pre-built renderable (`CreateLegend`) that draws a legend for the chart's series.
+	   If you like, you can use `CreateLegend` as a template for writing your own renderable, or even your own legend.
+	*/
+
+	graph := chart.Chart{
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				Name:    "A test series",
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+		},
+	}
+
+	//note we have to do this as a separate step because we need a reference to graph
+	graph.Elements = []chart.Renderable{
+		chart.CreateLegend(&graph),
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.ListenAndServe(":8080", nil)
+}

examples/simple_moving_average/main.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+
+	/*
+		In this example we add a new type of series, a `SimpleMovingAverageSeries` that takes another series as a required argument.
+		InnerSeries only needs to implement `ValueProvider`, so really you could chain `SimpleMovingAverageSeries` together if you wanted.
+	*/
+
+	mainSeries := chart.ContinuousSeries{
+		Name:    "A test series",
+		XValues: chart.Seq(1.0, 100.0),   //generates a []float64 from 1.0 to 100.0 in 1.0 step increments, or 100 elements.
+		YValues: chart.SeqRand(100, 100), //generates a []float64 randomly from 0 to 100 with 100 elements.
+	}
+
+	// note we create a SimpleMovingAverage series by assignin the inner series.
+	// we need to use a reference because `.Render()` needs to modify state within the series.
+	smaSeries := &chart.SimpleMovingAverageSeries{
+		InnerSeries: mainSeries,
+	} // we can optionally set the `WindowSize` property which alters how the moving average is calculated.
+
+	graph := chart.Chart{
+		Series: []chart.Series{
+			mainSeries,
+			smaSeries,
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.ListenAndServe(":8080", nil)
+}

examples/twoaxis/main.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"net/http"
+
+	"github.com/wcharczuk/go-chart"
+)
+
+func drawChart(res http.ResponseWriter, req *http.Request) {
+
+	/*
+	   In this example we add a second series, and assign it to the secondary y axis, giving that series it's own range.
+
+	   We also enable all of the axes by setting the `Show` propery of their respective styles to `true`.
+	*/
+
+	graph := chart.Chart{
+		XAxis: chart.XAxis{
+			Style: chart.Style{
+				Show: true, //enables / displays the x-axis
+			},
+		},
+		YAxis: chart.YAxis{
+			Style: chart.Style{
+				Show: true, //enables / displays the y-axis
+			},
+		},
+		YAxisSecondary: chart.YAxis{
+			Style: chart.Style{
+				Show: true, //enables / displays the secondary y-axis
+			},
+		},
+		Series: []chart.Series{
+			chart.ContinuousSeries{
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+			},
+			chart.ContinuousSeries{
+				YAxis:   chart.YAxisSecondary,
+				XValues: []float64{1.0, 2.0, 3.0, 4.0, 5.0},
+				YValues: []float64{50.0, 40.0, 30.0, 20.0, 10.0},
+			},
+		},
+	}
+
+	res.Header().Set("Content-Type", "image/png")
+	graph.Render(chart.PNG, res)
+}
+
+func main() {
+	http.HandleFunc("/", drawChart)
+	http.ListenAndServe(":8080", nil)
+}