go-chart/chart.go

503 lines
13 KiB
Go
Raw Normal View History

2016-07-07 03:54:00 +02:00
package chart
import (
2016-07-08 05:26:07 +02:00
"errors"
2016-07-07 03:54:00 +02:00
"io"
2016-07-11 02:19:44 +02:00
"math"
2016-07-07 03:54:00 +02:00
"github.com/golang/freetype/truetype"
)
// Chart is what we're drawing.
type Chart struct {
2016-07-07 23:44:03 +02:00
Title string
TitleStyle Style
2016-07-07 03:54:00 +02:00
Width int
Height int
2016-07-09 02:57:14 +02:00
DPI float64
2016-07-07 03:54:00 +02:00
2016-07-10 05:14:11 +02:00
Background Style
Canvas Style
2016-07-07 03:54:00 +02:00
2016-07-10 10:11:47 +02:00
XAxis XAxis
YAxis YAxis
YAxisSecondary YAxis
2016-07-07 03:54:00 +02:00
2016-07-13 05:34:59 +02:00
Font *truetype.Font
defaultFont *truetype.Font
2016-07-13 04:14:14 +02:00
Series []Series
Elements []Renderable
2016-07-07 03:54:00 +02:00
}
2016-07-09 02:57:14 +02:00
// GetDPI returns the dpi for the chart.
func (c Chart) GetDPI(defaults ...float64) float64 {
if c.DPI == 0 {
if len(defaults) > 0 {
return defaults[0]
}
return DefaultDPI
}
return c.DPI
}
2016-07-07 23:44:03 +02:00
// GetFont returns the text font.
2016-07-13 05:34:59 +02:00
func (c Chart) GetFont() *truetype.Font {
2016-07-08 06:15:35 +02:00
if c.Font == nil {
2016-07-13 05:34:59 +02:00
return c.defaultFont
}
return c.Font
}
// GetWidth returns the chart width or the default value.
func (c Chart) GetWidth() int {
if c.Width == 0 {
return DefaultChartWidth
2016-07-07 03:54:00 +02:00
}
2016-07-13 05:34:59 +02:00
return c.Width
}
// GetHeight returns the chart height or the default value.
func (c Chart) GetHeight() int {
if c.Height == 0 {
return DefaultChartHeight
}
return c.Height
2016-07-07 03:54:00 +02:00
}
// Render renders the chart with the given renderer to the given io.Writer.
2016-07-10 19:43:04 +02:00
func (c Chart) Render(rp RendererProvider, w io.Writer) error {
2016-07-08 05:26:07 +02:00
if len(c.Series) == 0 {
return errors.New("Please provide at least one series")
}
2016-07-12 03:48:51 +02:00
c.YAxisSecondary.AxisType = YAxisSecondary
2016-07-13 05:34:59 +02:00
r, err := rp(c.GetWidth(), c.GetHeight())
2016-07-09 02:57:14 +02:00
if err != nil {
return err
}
2016-07-10 05:14:11 +02:00
2016-07-13 05:34:59 +02:00
if c.Font == nil {
defaultFont, err := GetDefaultFont()
if err != nil {
return err
}
c.defaultFont = defaultFont
}
2016-07-09 02:57:14 +02:00
r.SetDPI(c.GetDPI(DefaultDPI))
2016-07-07 23:44:03 +02:00
c.drawBackground(r)
var xt, yt, yta []Tick
xr, yr, yra := c.getRanges()
2016-07-10 19:43:04 +02:00
canvasBox := c.getDefaultCanvasBox()
xf, yf, yfa := c.getValueFormatters()
xr, yr, yra = c.setRangeDomains(canvasBox, xr, yr, yra)
2016-07-10 19:43:04 +02:00
2016-07-13 07:55:46 +02:00
err = c.checkRanges(xr, yr, yra)
if err != nil {
return err
}
if c.hasAxes() {
xt, yt, yta = c.getAxesTicks(r, xr, yr, yra, xf, yf, yfa)
2016-07-12 03:48:51 +02:00
canvasBox = c.getAxisAdjustedCanvasBox(r, canvasBox, xr, yr, yra, xt, yt, yta)
xr, yr, yra = c.setRangeDomains(canvasBox, xr, yr, yra)
2016-07-17 08:45:28 +02:00
// do a second pass in case things haven't settled yet.
xt, yt, yta = c.getAxesTicks(r, xr, yr, yra, xf, yf, yfa)
2016-07-17 08:45:28 +02:00
canvasBox = c.getAxisAdjustedCanvasBox(r, canvasBox, xr, yr, yra, xt, yt, yta)
xr, yr, yra = c.setRangeDomains(canvasBox, xr, yr, yra)
}
2016-07-10 19:43:04 +02:00
if c.hasAnnotationSeries() {
canvasBox = c.getAnnotationAdjustedCanvasBox(r, canvasBox, xr, yr, yra, xf, yf, yfa)
xr, yr, yra = c.setRangeDomains(canvasBox, xr, yr, yra)
xt, yt, yta = c.getAxesTicks(r, xr, yr, yra, xf, yf, yfa)
}
c.drawCanvas(r, canvasBox)
c.drawAxes(r, canvasBox, xr, yr, yra, xt, yt, yta)
2016-07-08 02:50:16 +02:00
for index, series := range c.Series {
c.drawSeries(r, canvasBox, xr, yr, yra, series, index)
2016-07-07 03:54:00 +02:00
}
c.drawTitle(r)
2016-07-13 04:14:14 +02:00
for _, a := range c.Elements {
2016-07-15 03:29:06 +02:00
a(r, canvasBox, c.styleDefaultsElements())
2016-07-13 04:14:14 +02:00
}
2016-07-07 03:54:00 +02:00
return r.Save(w)
}
2016-07-10 10:11:47 +02:00
func (c Chart) getRanges() (xrange, yrange, yrangeAlt Range) {
2016-08-06 01:55:55 +02:00
var minx, maxx float64 = math.MaxFloat64, -math.MaxFloat64
var miny, maxy float64 = math.MaxFloat64, -math.MaxFloat64
var minya, maxya float64 = math.MaxFloat64, -math.MaxFloat64
2016-07-10 10:11:47 +02:00
seriesMappedToSecondaryAxis := false
2016-07-17 05:53:46 +02:00
// note: a possible future optimization is to not scan the series values if
// all axis are represented by either custom ticks or custom ranges.
2016-07-07 23:44:03 +02:00
for _, s := range c.Series {
2016-07-13 05:34:59 +02:00
if s.GetStyle().IsZero() || s.GetStyle().Show {
seriesAxis := s.GetYAxis()
2016-07-15 18:02:50 +02:00
if bvp, isBoundedValueProvider := s.(BoundedValueProvider); isBoundedValueProvider {
seriesLength := bvp.Len()
for index := 0; index < seriesLength; index++ {
vx, vy1, vy2 := bvp.GetBoundedValue(index)
minx = math.Min(minx, vx)
maxx = math.Max(maxx, vx)
if seriesAxis == YAxisPrimary {
miny = math.Min(miny, vy1)
miny = math.Min(miny, vy2)
maxy = math.Max(maxy, vy1)
maxy = math.Max(maxy, vy2)
} else if seriesAxis == YAxisSecondary {
minya = math.Min(minya, vy1)
minya = math.Min(minya, vy2)
maxya = math.Max(maxya, vy1)
maxya = math.Max(maxya, vy2)
seriesMappedToSecondaryAxis = true
2016-07-15 18:02:50 +02:00
}
}
} else if vp, isValueProvider := s.(ValueProvider); isValueProvider {
2016-07-13 05:34:59 +02:00
seriesLength := vp.Len()
for index := 0; index < seriesLength; index++ {
vx, vy := vp.GetValue(index)
minx = math.Min(minx, vx)
maxx = math.Max(maxx, vx)
if seriesAxis == YAxisPrimary {
miny = math.Min(miny, vy)
maxy = math.Max(maxy, vy)
} else if seriesAxis == YAxisSecondary {
minya = math.Min(minya, vy)
maxya = math.Max(maxya, vy)
seriesMappedToSecondaryAxis = true
2016-07-13 05:34:59 +02:00
}
2016-07-07 23:44:03 +02:00
}
}
}
}
2016-07-23 07:43:27 +02:00
if c.XAxis.Range == nil {
xrange = &ContinuousRange{}
2016-07-23 07:43:27 +02:00
} else {
xrange = c.XAxis.Range
}
2016-07-23 07:43:27 +02:00
if c.YAxis.Range == nil {
yrange = &ContinuousRange{}
2016-07-23 07:43:27 +02:00
} else {
yrange = c.YAxis.Range
}
2016-07-23 07:43:27 +02:00
if c.YAxisSecondary.Range == nil {
yrangeAlt = &ContinuousRange{}
2016-07-23 07:43:27 +02:00
} else {
yrangeAlt = c.YAxisSecondary.Range
}
2016-07-17 05:53:46 +02:00
if len(c.XAxis.Ticks) > 0 {
2016-08-06 01:55:55 +02:00
tickMin, tickMax := math.MaxFloat64, -math.MaxFloat64
2016-07-17 05:53:46 +02:00
for _, t := range c.XAxis.Ticks {
tickMin = math.Min(tickMin, t.Value)
tickMax = math.Max(tickMax, t.Value)
}
xrange.SetMin(tickMin)
xrange.SetMax(tickMax)
2016-07-23 07:43:27 +02:00
} else if xrange.IsZero() {
xrange.SetMin(minx)
xrange.SetMax(maxx)
2016-07-10 10:11:47 +02:00
}
2016-07-17 05:53:46 +02:00
if len(c.YAxis.Ticks) > 0 {
2016-08-06 01:55:55 +02:00
tickMin, tickMax := math.MaxFloat64, -math.MaxFloat64
2016-07-17 05:53:46 +02:00
for _, t := range c.YAxis.Ticks {
tickMin = math.Min(tickMin, t.Value)
tickMax = math.Max(tickMax, t.Value)
}
yrange.SetMin(tickMin)
yrange.SetMax(tickMax)
2016-07-23 07:43:27 +02:00
} else if yrange.IsZero() {
yrange.SetMin(miny)
yrange.SetMax(maxy)
delta := yrange.GetDelta()
2016-07-30 03:24:25 +02:00
roundTo := Math.GetRoundToForDelta(delta)
rmin, rmax := Math.RoundDown(yrange.GetMin(), roundTo), Math.RoundUp(yrange.GetMax(), roundTo)
yrange.SetMin(rmin)
yrange.SetMax(rmax)
2016-07-07 23:44:03 +02:00
}
2016-07-10 20:19:56 +02:00
2016-07-17 05:53:46 +02:00
if len(c.YAxisSecondary.Ticks) > 0 {
2016-08-06 01:55:55 +02:00
tickMin, tickMax := math.MaxFloat64, -math.MaxFloat64
2016-07-17 05:53:46 +02:00
for _, t := range c.YAxis.Ticks {
tickMin = math.Min(tickMin, t.Value)
tickMax = math.Max(tickMax, t.Value)
}
yrangeAlt.SetMin(tickMin)
yrangeAlt.SetMax(tickMax)
2016-07-23 07:43:27 +02:00
} else if seriesMappedToSecondaryAxis && yrangeAlt.IsZero() {
yrangeAlt.SetMin(minya)
yrangeAlt.SetMax(maxya)
delta := yrangeAlt.GetDelta()
2016-07-30 03:24:25 +02:00
roundTo := Math.GetRoundToForDelta(delta)
rmin, rmax := Math.RoundDown(yrangeAlt.GetMin(), roundTo), Math.RoundUp(yrangeAlt.GetMax(), roundTo)
yrangeAlt.SetMin(rmin)
yrangeAlt.SetMax(rmax)
2016-07-10 20:19:56 +02:00
}
2016-07-11 02:19:44 +02:00
2016-07-10 10:11:47 +02:00
return
}
2016-07-13 07:55:46 +02:00
func (c Chart) checkRanges(xr, yr, yra Range) error {
if math.IsInf(xr.GetDelta(), 0) || math.IsNaN(xr.GetDelta()) || xr.GetDelta() == 0 {
2016-07-13 07:55:46 +02:00
return errors.New("Invalid (infinite or NaN) x-range delta")
}
if math.IsInf(yr.GetDelta(), 0) || math.IsNaN(yr.GetDelta()) || yr.GetDelta() == 0 {
2016-07-13 07:55:46 +02:00
return errors.New("Invalid (infinite or NaN) y-range delta")
}
if c.hasSecondarySeries() {
if math.IsInf(yra.GetDelta(), 0) || math.IsNaN(yra.GetDelta()) || yra.GetDelta() == 0 {
2016-07-13 07:55:46 +02:00
return errors.New("Invalid (infinite or NaN) y-secondary-range delta")
}
}
return nil
}
2016-07-10 19:43:04 +02:00
func (c Chart) getDefaultCanvasBox() Box {
return c.Box()
2016-07-10 10:11:47 +02:00
}
2016-07-10 19:43:04 +02:00
func (c Chart) getValueFormatters() (x, y, ya ValueFormatter) {
for _, s := range c.Series {
if vfp, isVfp := s.(ValueFormatterProvider); isVfp {
sx, sy := vfp.GetValueFormatters()
if s.GetYAxis() == YAxisPrimary {
x = sx
y = sy
} else if s.GetYAxis() == YAxisSecondary {
x = sx
ya = sy
}
}
}
if c.XAxis.ValueFormatter != nil {
x = c.XAxis.ValueFormatter
}
if c.YAxis.ValueFormatter != nil {
y = c.YAxis.ValueFormatter
}
if c.YAxisSecondary.ValueFormatter != nil {
ya = c.YAxisSecondary.ValueFormatter
}
return
}
func (c Chart) hasAxes() bool {
return c.XAxis.Style.Show || c.YAxis.Style.Show || c.YAxisSecondary.Style.Show
}
2016-07-10 19:43:04 +02:00
func (c Chart) getAxesTicks(r Renderer, xr, yr, yar Range, xf, yf, yfa ValueFormatter) (xticks, yticks, yticksAlt []Tick) {
if c.XAxis.Style.Show {
2016-08-06 01:55:55 +02:00
xticks = c.XAxis.GetTicks(r, xr, c.styleDefaultsAxes(), xf)
2016-07-10 19:43:04 +02:00
}
if c.YAxis.Style.Show {
2016-08-06 01:55:55 +02:00
yticks = c.YAxis.GetTicks(r, yr, c.styleDefaultsAxes(), yf)
2016-07-10 19:43:04 +02:00
}
if c.YAxisSecondary.Style.Show {
2016-08-06 01:55:55 +02:00
yticksAlt = c.YAxisSecondary.GetTicks(r, yar, c.styleDefaultsAxes(), yfa)
2016-07-10 19:43:04 +02:00
}
return
}
2016-07-12 03:48:51 +02:00
func (c Chart) getAxisAdjustedCanvasBox(r Renderer, canvasBox Box, xr, yr, yra Range, xticks, yticks, yticksAlt []Tick) Box {
axesOuterBox := canvasBox.Clone()
2016-07-10 19:43:04 +02:00
if c.XAxis.Style.Show {
2016-08-06 01:55:55 +02:00
axesBounds := c.XAxis.Measure(r, canvasBox, xr, c.styleDefaultsAxes(), xticks)
axesOuterBox = axesOuterBox.Grow(axesBounds)
2016-07-10 19:43:04 +02:00
}
if c.YAxis.Style.Show {
2016-08-06 01:55:55 +02:00
axesBounds := c.YAxis.Measure(r, canvasBox, yr, c.styleDefaultsAxes(), yticks)
axesOuterBox = axesOuterBox.Grow(axesBounds)
2016-07-10 19:43:04 +02:00
}
if c.YAxisSecondary.Style.Show {
2016-08-06 01:55:55 +02:00
axesBounds := c.YAxisSecondary.Measure(r, canvasBox, yra, c.styleDefaultsAxes(), yticksAlt)
axesOuterBox = axesOuterBox.Grow(axesBounds)
2016-07-12 03:48:51 +02:00
}
2016-07-11 09:12:14 +02:00
return canvasBox.OuterConstrain(c.Box(), axesOuterBox)
2016-07-10 10:11:47 +02:00
}
func (c Chart) setRangeDomains(canvasBox Box, xr, yr, yra Range) (Range, Range, Range) {
xr.SetDomain(canvasBox.Width())
yr.SetDomain(canvasBox.Height())
yra.SetDomain(canvasBox.Height())
return xr, yr, yra
2016-07-07 23:44:03 +02:00
}
func (c Chart) hasAnnotationSeries() bool {
for _, s := range c.Series {
2016-07-11 02:19:44 +02:00
if as, isAnnotationSeries := s.(AnnotationSeries); isAnnotationSeries {
2016-07-13 05:34:59 +02:00
if as.Style.IsZero() || as.Style.Show {
return true
}
}
}
2016-07-11 02:19:44 +02:00
return false
}
2016-07-13 07:55:46 +02:00
func (c Chart) hasSecondarySeries() bool {
for _, s := range c.Series {
if s.GetYAxis() == YAxisSecondary {
return true
}
}
return false
}
func (c Chart) getAnnotationAdjustedCanvasBox(r Renderer, canvasBox Box, xr, yr, yra Range, xf, yf, yfa ValueFormatter) Box {
annotationSeriesBox := canvasBox.Clone()
for seriesIndex, s := range c.Series {
2016-07-11 02:19:44 +02:00
if as, isAnnotationSeries := s.(AnnotationSeries); isAnnotationSeries {
2016-07-13 05:34:59 +02:00
if as.Style.IsZero() || as.Style.Show {
style := c.styleDefaultsSeries(seriesIndex)
var annotationBounds Box
if as.YAxis == YAxisPrimary {
annotationBounds = as.Measure(r, canvasBox, xr, yr, style)
} else if as.YAxis == YAxisSecondary {
2016-07-11 02:19:44 +02:00
annotationBounds = as.Measure(r, canvasBox, xr, yra, style)
}
2016-07-11 02:19:44 +02:00
annotationSeriesBox = annotationSeriesBox.Grow(annotationBounds)
}
}
}
2016-07-15 03:29:06 +02:00
return canvasBox.OuterConstrain(c.Box(), annotationSeriesBox)
}
func (c Chart) getBackgroundStyle() Style {
return c.Background.InheritFrom(c.styleDefaultsBackground())
}
2016-07-07 03:54:00 +02:00
func (c Chart) drawBackground(r Renderer) {
2016-07-30 01:36:29 +02:00
Draw.Box(r, Box{
Right: c.GetWidth(),
Bottom: c.GetHeight(),
}, c.getBackgroundStyle())
}
func (c Chart) getCanvasStyle() Style {
return c.Canvas.InheritFrom(c.styleDefaultsCanvas())
2016-07-07 03:54:00 +02:00
}
func (c Chart) drawCanvas(r Renderer, canvasBox Box) {
2016-07-30 01:36:29 +02:00
Draw.Box(r, canvasBox, c.getCanvasStyle())
2016-07-07 03:54:00 +02:00
}
2016-07-10 19:43:04 +02:00
func (c Chart) drawAxes(r Renderer, canvasBox Box, xrange, yrange, yrangeAlt Range, xticks, yticks, yticksAlt []Tick) {
2016-07-10 10:11:47 +02:00
if c.XAxis.Style.Show {
2016-08-06 01:55:55 +02:00
c.XAxis.Render(r, canvasBox, xrange, c.styleDefaultsAxes(), xticks)
}
2016-07-10 10:11:47 +02:00
if c.YAxis.Style.Show {
2016-08-06 01:55:55 +02:00
c.YAxis.Render(r, canvasBox, yrange, c.styleDefaultsAxes(), yticks)
2016-07-08 05:26:07 +02:00
}
2016-07-10 10:11:47 +02:00
if c.YAxisSecondary.Style.Show {
2016-08-06 01:55:55 +02:00
c.YAxisSecondary.Render(r, canvasBox, yrangeAlt, c.styleDefaultsAxes(), yticksAlt)
2016-07-08 05:26:07 +02:00
}
}
2016-07-10 10:11:47 +02:00
func (c Chart) drawSeries(r Renderer, canvasBox Box, xrange, yrange, yrangeAlt Range, s Series, seriesIndex int) {
2016-07-13 05:34:59 +02:00
if s.GetStyle().IsZero() || s.GetStyle().Show {
if s.GetYAxis() == YAxisPrimary {
s.Render(r, canvasBox, xrange, yrange, c.styleDefaultsSeries(seriesIndex))
} else if s.GetYAxis() == YAxisSecondary {
s.Render(r, canvasBox, xrange, yrangeAlt, c.styleDefaultsSeries(seriesIndex))
}
2016-07-10 10:11:47 +02:00
}
2016-07-07 03:54:00 +02:00
}
2016-07-10 19:43:04 +02:00
func (c Chart) drawTitle(r Renderer) {
2016-07-07 23:44:03 +02:00
if len(c.Title) > 0 && c.TitleStyle.Show {
2016-07-13 05:34:59 +02:00
r.SetFont(c.TitleStyle.GetFont(c.GetFont()))
2016-07-10 19:43:04 +02:00
r.SetFontColor(c.TitleStyle.GetFontColor(DefaultTextColor))
titleFontSize := c.TitleStyle.GetFontSize(DefaultTitleFontSize)
2016-07-07 23:44:03 +02:00
r.SetFontSize(titleFontSize)
2016-07-10 19:43:04 +02:00
2016-07-12 03:48:51 +02:00
textBox := r.MeasureText(c.Title)
2016-07-10 19:43:04 +02:00
textWidth := textBox.Width()
textHeight := textBox.Height()
2016-07-10 19:43:04 +02:00
2016-07-13 05:34:59 +02:00
titleX := (c.GetWidth() >> 1) - (textWidth >> 1)
2016-07-10 19:43:04 +02:00
titleY := c.TitleStyle.Padding.GetTop(DefaultTitleTop) + textHeight
2016-07-07 03:54:00 +02:00
r.Text(c.Title, titleX, titleY)
}
}
2016-07-15 03:29:06 +02:00
func (c Chart) styleDefaultsBackground() Style {
return Style{
FillColor: DefaultBackgroundColor,
StrokeColor: DefaultBackgroundStrokeColor,
StrokeWidth: DefaultStrokeWidth,
}
}
func (c Chart) styleDefaultsCanvas() Style {
return Style{
FillColor: DefaultCanvasColor,
StrokeColor: DefaultCanvasStrokeColor,
StrokeWidth: DefaultStrokeWidth,
}
}
2016-07-13 05:34:59 +02:00
func (c Chart) styleDefaultsSeries(seriesIndex int) Style {
2016-07-29 03:51:55 +02:00
strokeColor := GetDefaultColor(seriesIndex)
return Style{
StrokeColor: strokeColor,
StrokeWidth: DefaultStrokeWidth,
2016-07-13 05:34:59 +02:00
Font: c.GetFont(),
FontSize: DefaultFontSize,
}
}
2016-08-06 01:55:55 +02:00
func (c Chart) styleDefaultsAxes() Style {
2016-07-13 05:34:59 +02:00
return Style{
Font: c.GetFont(),
2016-07-21 23:14:28 +02:00
FontColor: DefaultAxisColor,
2016-07-13 05:34:59 +02:00
FontSize: DefaultAxisFontSize,
StrokeColor: DefaultAxisColor,
StrokeWidth: DefaultAxisLineWidth,
}
}
2016-07-15 03:29:06 +02:00
func (c Chart) styleDefaultsElements() Style {
return Style{
Font: c.GetFont(),
}
}
// Box returns the chart bounds as a box.
func (c Chart) Box() Box {
dpr := c.Background.Padding.GetRight(DefaultBackgroundPadding.Right)
dpb := c.Background.Padding.GetBottom(DefaultBackgroundPadding.Bottom)
return Box{
Top: c.Background.Padding.GetTop(DefaultBackgroundPadding.Top),
Left: c.Background.Padding.GetLeft(DefaultBackgroundPadding.Left),
Right: c.GetWidth() - dpr,
Bottom: c.GetHeight() - dpb,
}
}