mostly works.

This commit is contained in:
Will Charczuk 2016-07-10 10:43:04 -07:00
parent e9a36274ac
commit abfdc3e0d9
14 changed files with 465 additions and 159 deletions

View file

@ -14,13 +14,35 @@ type AnnotationSeries struct {
Annotations []Annotation Annotations []Annotation
} }
// GetName returns the name of the time series.
func (as AnnotationSeries) GetName() string {
return as.Name
}
// GetStyle returns the line style.
func (as AnnotationSeries) GetStyle() Style {
return as.Style
}
// GetYAxis returns which YAxis the series draws on.
func (as AnnotationSeries) GetYAxis() YAxisType {
return as.YAxis
}
// Render draws the series. // Render draws the series.
func (as AnnotationSeries) Render(r Renderer, canvasBox Box, xrange, yrange Range) { func (as AnnotationSeries) Render(r Renderer, canvasBox Box, xrange, yrange Range, defaults Style) {
if as.Style.Show { if as.Style.Show {
style := as.Style.WithDefaultsFrom(Style{
FillColor: DefaultAnnotationFillColor,
FontSize: DefaultAnnotationFontSize,
StrokeColor: defaults.StrokeColor,
StrokeWidth: defaults.StrokeWidth,
Padding: DefaultAnnotationPadding,
})
for _, a := range as.Annotations { for _, a := range as.Annotations {
lx := xrange.Translate(a.X) + canvasBox.Left lx := canvasBox.Right - xrange.Translate(a.X)
ly := yrange.Translate(a.Y) + canvasBox.Top ly := yrange.Translate(a.Y) + canvasBox.Top
DrawAnnotation(r, canvasBox, xrange, yrange, as.Style, lx, ly, a.Label) DrawAnnotation(r, canvasBox, xrange, yrange, style, lx, ly, a.Label)
} }
} }
} }

44
axis.go
View file

@ -14,46 +14,6 @@ const (
type Axis interface { type Axis interface {
GetName() string GetName() string
GetStyle() Style GetStyle() Style
Render(c *Chart, r Renderer, canvasBox Box, ra Range) GetTicks(r Renderer, ra Range, vf ValueFormatter) []Tick
} Render(c *Chart, r Renderer, canvasBox Box, ra Range, ticks []Tick)
// axis represents the basics of an axis implementation.
type axis struct {
Name string
Style Style
ValueFormatter ValueFormatter
Range Range
Ticks []Tick
}
func (a axis) GetName() string {
return a.Name
}
func (a axis) GetStyle() Style {
return a.Style
}
func (a axis) getTicks(ra Range) []Tick {
if len(a.Ticks) > 0 {
return a.Ticks
}
return a.generateTicks(ra)
}
func (a axis) generateTicks(ra Range) []Tick {
step := a.getTickStep(ra)
return a.generateTicksWithStep(ra, step)
}
func (a axis) getTickCount(ra Range) int {
return 0
}
func (a axis) getTickStep(ra Range) float64 {
return 0.0
}
func (a axis) generateTicksWithStep(ra Range, step float64) []Tick {
return []Tick{}
} }

181
chart.go
View file

@ -5,6 +5,7 @@ import (
"io" "io"
"github.com/golang/freetype/truetype" "github.com/golang/freetype/truetype"
"github.com/wcharczuk/go-chart/drawing"
) )
// Chart is what we're drawing. // Chart is what we're drawing.
@ -51,7 +52,7 @@ func (c Chart) GetFont() (*truetype.Font, error) {
} }
// Render renders the chart with the given renderer to the given io.Writer. // Render renders the chart with the given renderer to the given io.Writer.
func (c *Chart) Render(rp RendererProvider, w io.Writer) error { func (c Chart) Render(rp RendererProvider, w io.Writer) error {
if len(c.Series) == 0 { if len(c.Series) == 0 {
return errors.New("Please provide at least one series") return errors.New("Please provide at least one series")
} }
@ -64,16 +65,26 @@ func (c *Chart) Render(rp RendererProvider, w io.Writer) error {
if err != nil { if err != nil {
return err return err
} }
c.Font = font
r.SetFont(font) r.SetFont(font)
r.SetDPI(c.GetDPI(DefaultDPI)) r.SetDPI(c.GetDPI(DefaultDPI))
xrange, yrange, yrangeAlt := c.getRanges() xrange, yrange, yrangeAlt := c.getRanges()
canvasBox := c.getCanvasBox(r, xrange, yrange, yrangeAlt) canvasBox := c.getDefaultCanvasBox()
xrange, yrange, yrangeAlt = c.getRangeDomains(canvasBox, xrange, yrange, yrangeAlt) xf, yf, yfa := c.getValueFormatters()
xrange, yrange, yrangeAlt = c.setRangeDomains(canvasBox, xrange, yrange, yrangeAlt)
xticks, yticks, yticksAlt := c.getAxesTicks(r, xrange, yrange, yrangeAlt, xf, yf, yfa)
canvasBox = c.getAdjustedCanvasBox(r, canvasBox, xticks, yticks, yticksAlt)
// we do a second pass to take the updated domains into account
xrange, yrange, yrangeAlt = c.setRangeDomains(canvasBox, xrange, yrange, yrangeAlt)
xticks, yticks, yticksAlt = c.getAxesTicks(r, xrange, yrange, yrangeAlt, xf, yf, yfa)
canvasBox = c.getAdjustedCanvasBox(r, canvasBox, xticks, yticks, yticksAlt)
c.drawBackground(r) c.drawBackground(r)
c.drawCanvas(r, canvasBox) c.drawCanvas(r, canvasBox)
c.drawAxes(r, canvasBox, xrange, yrange, yrangeAlt) c.drawAxes(r, canvasBox, xrange, yrange, yrangeAlt, xticks, yticks, yticksAlt)
for index, series := range c.Series { for index, series := range c.Series {
c.drawSeries(r, canvasBox, xrange, yrange, yrangeAlt, series, index) c.drawSeries(r, canvasBox, xrange, yrange, yrangeAlt, series, index)
} }
@ -147,21 +158,11 @@ func (c Chart) getRanges() (xrange, yrange, yrangeAlt Range) {
return return
} }
func (c Chart) getCanvasBox(r Renderer, xrange, yrange, yrangeAlt Range) Box { func (c Chart) getDefaultCanvasBox() Box {
dpl := c.Background.Padding.GetLeft(DefaultBackgroundPadding.Left) dpl := c.Background.Padding.GetLeft(DefaultBackgroundPadding.Left)
dpr := c.Background.Padding.GetRight(DefaultBackgroundPadding.Right) dpr := c.Background.Padding.GetRight(DefaultBackgroundPadding.Right)
dpb := c.Background.Padding.GetBottom(DefaultBackgroundPadding.Bottom) dpb := c.Background.Padding.GetBottom(DefaultBackgroundPadding.Bottom)
if c.YAxisSecondary.Style.Show {
dpl = c.getYAxisSecondaryWidth(r, yrangeAlt)
}
if c.YAxis.Style.Show {
dpr = c.getYAxisWidth(r, yrange)
}
if c.XAxis.Style.Show {
dpb = c.getXAxisHeight(r, xrange)
}
cb := Box{ cb := Box{
Top: c.Background.Padding.GetTop(DefaultBackgroundPadding.Top), Top: c.Background.Padding.GetTop(DefaultBackgroundPadding.Top),
Left: dpl, Left: dpl,
@ -173,23 +174,95 @@ func (c Chart) getCanvasBox(r Renderer, xrange, yrange, yrangeAlt Range) Box {
return cb return cb
} }
func (c Chart) getYAxisSecondaryWidth(r Renderer, ra Range) int { func (c Chart) getValueFormatters() (x, y, ya ValueFormatter) {
var ll string for _, s := range c.Series {
ticks := c.YAxisSecondary.getTicks(ra) if vfp, isVfp := s.(ValueFormatterProvider); isVfp {
for _, t := range ticks { sx, sy := vfp.GetValueFormatters()
if len(t.Label) > len(ll) { if s.GetYAxis() == YAxisPrimary {
ll = t.Label x = sx
y = sy
} else if s.GetYAxis() == YAxisSecondary {
x = sx
ya = sy
} }
} }
r.SetFontSize(c.YAxisSecondary.Style.GetFontSize(DefaultFontSize)) }
r.SetFont(c.YAxisSecondary.Style.GetFont(c.Font)) if c.XAxis.ValueFormatter != nil {
tw, _ := r.MeasureText(ll) x = c.XAxis.ValueFormatter
return tw + DefaultYAxisMargin }
if c.YAxis.ValueFormatter != nil {
y = c.YAxis.ValueFormatter
}
if c.YAxisSecondary.ValueFormatter != nil {
ya = c.YAxisSecondary.ValueFormatter
}
return
} }
func (c Chart) getYAxisWidth(r Renderer, ra Range) int { func (c Chart) getAxesTicks(r Renderer, xr, yr, yar Range, xf, yf, yfa ValueFormatter) (xticks, yticks, yticksAlt []Tick) {
if c.XAxis.Style.Show {
xticks = c.XAxis.GetTicks(r, xr, xf)
}
if c.YAxis.Style.Show {
yticks = c.YAxis.GetTicks(r, yr, yf)
}
if c.YAxisSecondary.Style.Show {
yticksAlt = c.YAxisSecondary.GetTicks(r, yr, yf)
}
return
}
func (c Chart) getAdjustedCanvasBox(r Renderer, defaults Box, xticks, yticks, yticksAlt []Tick) Box {
canvasBox := Box{}
var dpl, dpr, dpb int
if c.XAxis.Style.Show {
dpb = c.getXAxisHeight(r, xticks)
}
if c.YAxis.Style.Show {
dpr = c.getYAxisWidth(r, yticks)
}
if c.YAxisSecondary.Style.Show {
dpl = c.getYAxisSecondaryWidth(r, yticksAlt)
}
canvasBox.Top = defaults.Top
if dpl != 0 {
canvasBox.Left = c.Canvas.Padding.GetLeft(dpl)
} else {
canvasBox.Left = defaults.Left
}
if dpr != 0 {
canvasBox.Right = c.Width - c.Canvas.Padding.GetRight(dpr)
} else {
canvasBox.Right = defaults.Right
}
if dpb != 0 {
canvasBox.Bottom = c.Height - c.Canvas.Padding.GetBottom(dpb)
} else {
canvasBox.Bottom = defaults.Bottom
}
canvasBox.Width = canvasBox.Right - canvasBox.Left
canvasBox.Height = canvasBox.Bottom - canvasBox.Top
return canvasBox
}
func (c Chart) getXAxisHeight(r Renderer, ticks []Tick) int {
r.SetFontSize(c.XAxis.Style.GetFontSize(DefaultFontSize))
r.SetFont(c.XAxis.Style.GetFont(c.Font))
var tl int
for _, t := range ticks {
_, lh := r.MeasureText(t.Label)
if lh > tl {
tl = lh
}
}
return tl + DefaultXAxisMargin
}
func (c Chart) getYAxisWidth(r Renderer, ticks []Tick) int {
var ll string var ll string
ticks := c.YAxis.getTicks(ra)
for _, t := range ticks { for _, t := range ticks {
if len(t.Label) > len(ll) { if len(t.Label) > len(ll) {
ll = t.Label ll = t.Label
@ -201,21 +274,21 @@ func (c Chart) getYAxisWidth(r Renderer, ra Range) int {
return tw + DefaultYAxisMargin return tw + DefaultYAxisMargin
} }
func (c Chart) getXAxisHeight(r Renderer, ra Range) int { func (c Chart) getYAxisSecondaryWidth(r Renderer, ticks []Tick) int {
r.SetFontSize(c.XAxis.Style.GetFontSize(DefaultFontSize)) var ll string
r.SetFont(c.XAxis.Style.GetFont(c.Font))
var tl int
ticks := c.YAxis.getTicks(ra)
for _, t := range ticks { for _, t := range ticks {
_, lh := r.MeasureText(t.Label) if len(t.Label) > len(ll) {
if lh > tl { ll = t.Label
tl = lh
} }
} }
return tl + DefaultXAxisMargin
}
func (c Chart) getRangeDomains(canvasBox Box, xrange, yrange, yrangeAlt Range) (Range, Range, Range) { r.SetFontSize(c.YAxisSecondary.Style.GetFontSize(DefaultFontSize))
r.SetFont(c.YAxisSecondary.Style.GetFont(c.Font))
tw, _ := r.MeasureText(ll)
return tw + DefaultYAxisMargin
}
func (c Chart) setRangeDomains(canvasBox Box, xrange, yrange, yrangeAlt Range) (Range, Range, Range) {
xrange.Domain = canvasBox.Width xrange.Domain = canvasBox.Width
yrange.Domain = canvasBox.Height yrange.Domain = canvasBox.Height
yrangeAlt.Domain = canvasBox.Height yrangeAlt.Domain = canvasBox.Height
@ -248,19 +321,19 @@ func (c Chart) drawCanvas(r Renderer, canvasBox Box) {
r.FillStroke() r.FillStroke()
} }
func (c Chart) drawAxes(r Renderer, canvasBox Box, xrange, yrange, yrangeAlt Range) { func (c Chart) drawAxes(r Renderer, canvasBox Box, xrange, yrange, yrangeAlt Range, xticks, yticks, yticksAlt []Tick) {
if c.XAxis.Style.Show { if c.XAxis.Style.Show {
c.XAxis.Render(r, canvasBox, xrange) c.XAxis.Render(r, canvasBox, xrange, xticks)
} }
if c.YAxis.Style.Show { if c.YAxis.Style.Show {
c.YAxis.Render(r, canvasBox, yrange, YAxisPrimary) c.YAxis.Render(r, canvasBox, yrange, YAxisPrimary, yticks)
} }
if c.YAxisSecondary.Style.Show { if c.YAxisSecondary.Style.Show {
c.YAxisSecondary.Render(r, canvasBox, yrangeAlt, YAxisSecondary) c.YAxisSecondary.Render(r, canvasBox, yrangeAlt, YAxisSecondary, yticksAlt)
} }
} }
func (c Chart) getSeriesDefaults(seriesIndex int) Style { func (c Chart) getSeriesStyleDefaults(seriesIndex int) Style {
strokeColor := GetDefaultSeriesStrokeColor(seriesIndex) strokeColor := GetDefaultSeriesStrokeColor(seriesIndex)
return Style{ return Style{
StrokeColor: strokeColor, StrokeColor: strokeColor,
@ -273,21 +346,27 @@ func (c Chart) getSeriesDefaults(seriesIndex int) Style {
func (c Chart) drawSeries(r Renderer, canvasBox Box, xrange, yrange, yrangeAlt Range, s Series, seriesIndex int) { func (c Chart) drawSeries(r Renderer, canvasBox Box, xrange, yrange, yrangeAlt Range, s Series, seriesIndex int) {
if s.GetYAxis() == YAxisPrimary { if s.GetYAxis() == YAxisPrimary {
s.Render(r, canvasBox, xrange, yrange, c.getSeriesDefaults(seriesIndex)) s.Render(r, canvasBox, xrange, yrange, c.getSeriesStyleDefaults(seriesIndex))
} else if s.GetYAxis() == YAxisSecondary { } else if s.GetYAxis() == YAxisSecondary {
s.Render(r, canvasBox, xrange, yrange, c.getSeriesDefaults(seriesIndex)) s.Render(r, canvasBox, xrange, yrange, c.getSeriesStyleDefaults(seriesIndex))
} }
} }
func (c Chart) drawTitle(r Renderer) error { func (c Chart) drawTitle(r Renderer) {
if len(c.Title) > 0 && c.TitleStyle.Show { if len(c.Title) > 0 && c.TitleStyle.Show {
r.SetFontColor(c.Canvas.GetFontColor(DefaultTextColor)) r.SetFont(c.TitleStyle.GetFont(c.Font))
titleFontSize := c.Canvas.GetFontSize(DefaultTitleFontSize) r.SetFontColor(c.TitleStyle.GetFontColor(DefaultTextColor))
titleFontSize := c.TitleStyle.GetFontSize(DefaultTitleFontSize)
r.SetFontSize(titleFontSize) r.SetFontSize(titleFontSize)
textWidth, _ := r.MeasureText(c.Title)
textWidthPoints, textHeightPoints := r.MeasureText(c.Title)
textWidth := int(drawing.PointsToPixels(r.GetDPI(), float64(textWidthPoints)))
textHeight := int(drawing.PointsToPixels(r.GetDPI(), float64(textHeightPoints)))
titleX := (c.Width >> 1) - (textWidth >> 1) titleX := (c.Width >> 1) - (textWidth >> 1)
titleY := c.TitleStyle.Padding.GetTop(DefaultTitleTop) + int(titleFontSize) titleY := c.TitleStyle.Padding.GetTop(DefaultTitleTop) + textHeight
r.Text(c.Title, titleX, titleY) r.Text(c.Title, titleX, titleY)
} }
return nil
} }

View file

@ -31,6 +31,18 @@ func (cs ContinuousSeries) GetValue(index int) (float64, float64) {
return cs.XValues[index], cs.YValues[index] return cs.XValues[index], cs.YValues[index]
} }
// GetValueFormatters returns value formatter defaults for the series.
func (cs ContinuousSeries) GetValueFormatters() (x, y ValueFormatter) {
x = FloatValueFormatter
y = FloatValueFormatter
return
}
// GetYAxis returns which YAxis the series draws on.
func (cs ContinuousSeries) GetYAxis() YAxisType {
return cs.YAxis
}
// Render renders the series. // Render renders the series.
func (cs ContinuousSeries) Render(r Renderer, canvasBox Box, xrange, yrange Range, defaults Style) { func (cs ContinuousSeries) Render(r Renderer, canvasBox Box, xrange, yrange Range, defaults Style) {
style := cs.Style.WithDefaultsFrom(defaults) style := cs.Style.WithDefaultsFrom(defaults)

View file

@ -32,18 +32,25 @@ const (
DefaultAxisFontSize = 10.0 DefaultAxisFontSize = 10.0
// DefaultTitleTop is the default distance from the top of the chart to put the title. // DefaultTitleTop is the default distance from the top of the chart to put the title.
DefaultTitleTop = 10 DefaultTitleTop = 10
// DefaultYAxisMargin is the default distance from the right of the canvas to the y axis labels. // DefaultYAxisMargin is the default distance from the right of the canvas to the y axis labels.
DefaultYAxisMargin = 5 DefaultYAxisMargin = 10
// DefaultXAxisMargin is the default distance from bottom of the canvas to the x axis labels. // DefaultXAxisMargin is the default distance from bottom of the canvas to the x axis labels.
DefaultXAxisMargin = 10 DefaultXAxisMargin = 10
//DefaultVerticalTickWidth is half the margin.
DefaultVerticalTickWidth = DefaultYAxisMargin >> 1
//DefaultHorizontalTickWidth is half the margin.
DefaultHorizontalTickWidth = DefaultXAxisMargin >> 1
// DefaultMinimumTickHorizontalSpacing is the minimum distance between horizontal ticks. // DefaultMinimumTickHorizontalSpacing is the minimum distance between horizontal ticks.
DefaultMinimumTickHorizontalSpacing = 20 DefaultMinimumTickHorizontalSpacing = 20
// DefaultMinimumTickVerticalSpacing is the minimum distance between vertical ticks. // DefaultMinimumTickVerticalSpacing is the minimum distance between vertical ticks.
DefaultMinimumTickVerticalSpacing = 20 DefaultMinimumTickVerticalSpacing = 20
// DefaultDateFormat is the default date format. // DefaultDateFormat is the default date format.
DefaultDateFormat = "2006-01-02" DefaultDateFormat = "2006-01-02"
// DefaultMaxTickCount is the maximum number of ticks to draw
DefaultMaxTickCount = 7
) )
var ( var (

View file

@ -8,14 +8,13 @@ func DrawLineSeries(r Renderer, canvasBox Box, xrange, yrange Range, s Style, vs
return return
} }
cx := canvasBox.Left ct := canvasBox.Top
cy := canvasBox.Top
cb := canvasBox.Bottom cb := canvasBox.Bottom
cw := canvasBox.Width cr := canvasBox.Right
v0x, v0y := vs.GetValue(0) v0x, v0y := vs.GetValue(0)
x0 := cw - xrange.Translate(v0x) x0 := cr - xrange.Translate(v0x)
y0 := yrange.Translate(v0y) y0 := yrange.Translate(v0y) + ct
var vx, vy float64 var vx, vy float64
var x, y int var x, y int
@ -23,15 +22,15 @@ func DrawLineSeries(r Renderer, canvasBox Box, xrange, yrange Range, s Style, vs
fill := s.GetFillColor() fill := s.GetFillColor()
if !fill.IsZero() { if !fill.IsZero() {
r.SetFillColor(fill) r.SetFillColor(fill)
r.MoveTo(x0+cx, y0+cy) r.MoveTo(x0, y0)
for i := 1; i < vs.Len(); i++ { for i := 1; i < vs.Len(); i++ {
vx, vy = vs.GetValue(i) vx, vy = vs.GetValue(i)
x = cw - xrange.Translate(vx) x = cr - xrange.Translate(vx)
y = yrange.Translate(vy) y = yrange.Translate(vy) + ct
r.LineTo(x+cx, y+cy) r.LineTo(x, y)
} }
r.LineTo(x+cx, cb) r.LineTo(x, cb)
r.LineTo(x0+cx, cb) r.LineTo(x0, cb)
r.Close() r.Close()
r.Fill() r.Fill()
} }
@ -40,12 +39,12 @@ func DrawLineSeries(r Renderer, canvasBox Box, xrange, yrange Range, s Style, vs
r.SetStrokeColor(stroke) r.SetStrokeColor(stroke)
r.SetStrokeWidth(s.GetStrokeWidth(DefaultStrokeWidth)) r.SetStrokeWidth(s.GetStrokeWidth(DefaultStrokeWidth))
r.MoveTo(x0+cx, y0+cy) r.MoveTo(x0, y0)
for i := 1; i < vs.Len(); i++ { for i := 1; i < vs.Len(); i++ {
vx, vy = vs.GetValue(i) vx, vy = vs.GetValue(i)
x = cw - xrange.Translate(vx) x = cr - xrange.Translate(vx)
y = yrange.Translate(vy) y = yrange.Translate(vy) + ct
r.LineTo(x+cx, y+cy) r.LineTo(x, y)
} }
r.Stroke() r.Stroke()
} }
@ -81,6 +80,7 @@ func DrawAnnotation(r Renderer, canvasBox Box, xrange, yrange Range, s Style, lx
r.SetFillColor(s.GetFillColor(DefaultAnnotationFillColor)) r.SetFillColor(s.GetFillColor(DefaultAnnotationFillColor))
r.SetStrokeColor(s.GetStrokeColor()) r.SetStrokeColor(s.GetStrokeColor())
r.SetStrokeWidth(s.GetStrokeWidth()) r.SetStrokeWidth(s.GetStrokeWidth())
r.MoveTo(lx, ly) r.MoveTo(lx, ly)
r.LineTo(ltlx, ltly) r.LineTo(ltlx, ltly)
r.LineTo(ltrx, ltry) r.LineTo(ltrx, ltry)

View file

@ -9,7 +9,7 @@ import (
// Renderer represents the basic methods required to draw a chart. // Renderer represents the basic methods required to draw a chart.
type Renderer interface { type Renderer interface {
// GetDPI returns the dpi for the renderer. // GetDPI gets the DPI for the renderer.
GetDPI() float64 GetDPI() float64
// SetDPI sets the DPI for the renderer. // SetDPI sets the DPI for the renderer.

30
series_test.go Normal file
View file

@ -0,0 +1,30 @@
package chart
import (
"testing"
"time"
"github.com/blendlabs/go-assert"
)
func TestTimeSeriesGetValue(t *testing.T) {
assert := assert.New(t)
ts := TimeSeries{
Name: "Test",
XValues: []time.Time{
time.Now().AddDate(0, 0, -5),
time.Now().AddDate(0, 0, -4),
time.Now().AddDate(0, 0, -3),
time.Now().AddDate(0, 0, -2),
time.Now().AddDate(0, 0, -1),
},
YValues: []float64{
1.0, 2.0, 3.0, 4.0, 5.0,
},
}
x0, y0 := ts.GetValue(0)
assert.NotZero(x0)
assert.Equal(1.0, y0)
}

View file

@ -5,7 +5,6 @@ import (
"net/http" "net/http"
"github.com/wcharczuk/go-chart" "github.com/wcharczuk/go-chart"
"github.com/wcharczuk/go-chart/drawing"
"github.com/wcharczuk/go-web" "github.com/wcharczuk/go-web"
) )
@ -21,38 +20,73 @@ func chartHandler(rc *web.RequestContext) web.ControllerResult {
rc.Response.Header().Set("Content-Type", "image/svg+xml") rc.Response.Header().Set("Content-Type", "image/svg+xml")
} }
s1x := []float64{1.0, 2.0, 3.0, 4.0}
s1y := []float64{2.5, 5.0, 2.0, 3.3}
s2x := []float64{3.0, 4.0, 5.0, 6.0}
s2y := []float64{6.0, 5.0, 4.0, 1.0}
c := chart.Chart{ c := chart.Chart{
Title: "A Test Chart", Title: "A Test Chart",
TitleStyle: chart.Style{ TitleStyle: chart.Style{
Show: true, Show: true,
FontSize: 26.0,
}, },
Width: 640, Width: 1024,
Height: 480, Height: 400,
Axes: chart.Style{ XAxis: chart.XAxis{
Style: chart.Style{
Show: true, Show: true,
StrokeWidth: 1.0, StrokeWidth: 1.0,
}, },
YRange: chart.Range{ },
YAxis: chart.YAxis{
Style: chart.Style{
Show: true,
StrokeWidth: 1.0,
},
Range: chart.Range{
Min: 0.0, Min: 0.0,
Max: 7.0, Max: 7.0,
}, },
FinalValueLabel: chart.Style{
Show: true,
}, },
Series: []chart.Series{ Series: []chart.Series{
chart.ContinuousSeries{ chart.ContinuousSeries{
Name: "a", Name: "a",
XValues: []float64{1.0, 2.0, 3.0, 4.0}, XValues: s1x,
YValues: []float64{2.5, 5.0, 2.0, 3.3}, YValues: s1y,
Style: chart.Style{
FillColor: drawing.Color{R: 0, G: 116, B: 217, A: 128},
},
}, },
chart.ContinuousSeries{ chart.ContinuousSeries{
Name: "b", Name: "b",
XValues: []float64{3.0, 4.0, 5.0, 6.0}, XValues: s2x,
YValues: []float64{6.0, 5.0, 4.0, 1.0}, YValues: s2y,
},
chart.AnnotationSeries{
Name: "a - last value",
Style: chart.Style{
Show: true,
StrokeColor: chart.GetDefaultSeriesStrokeColor(0),
},
Annotations: []chart.Annotation{
chart.Annotation{
X: s1x[len(s1x)-1],
Y: s1y[len(s1y)-1],
Label: chart.FloatValueFormatter(s1y[len(s1y)-1]),
},
},
},
chart.AnnotationSeries{
Name: "b - last value",
Style: chart.Style{
Show: true,
StrokeColor: chart.GetDefaultSeriesStrokeColor(1),
},
Annotations: []chart.Annotation{
chart.Annotation{
X: s2x[len(s2x)-1],
Y: s2y[len(s2y)-1],
Label: chart.FloatValueFormatter(s2y[len(s2y)-1]),
},
},
}, },
}, },
} }
@ -74,6 +108,9 @@ func main() {
app.SetName("Chart Test Server") app.SetName("Chart Test Server")
app.SetLogger(web.NewStandardOutputLogger()) app.SetLogger(web.NewStandardOutputLogger())
app.GET("/", chartHandler) app.GET("/", chartHandler)
app.GET("/:format", chartHandler) app.GET("/format/:format", chartHandler)
app.GET("/favico.ico", func(rc *web.RequestContext) web.ControllerResult {
return rc.Raw([]byte{})
})
log.Fatal(app.Start()) log.Fatal(app.Start())
} }

View file

@ -28,11 +28,6 @@ func (ts TimeSeries) Len() int {
return len(ts.XValues) return len(ts.XValues)
} }
// GetYAxis returns which YAxis the series draws on.
func (ts TimeSeries) GetYAxis() YAxisType {
return ts.YAxis
}
// GetValue gets a value at a given index. // GetValue gets a value at a given index.
func (ts TimeSeries) GetValue(index int) (x float64, y float64) { func (ts TimeSeries) GetValue(index int) (x float64, y float64) {
x = float64(ts.XValues[index].Unix()) x = float64(ts.XValues[index].Unix())
@ -40,6 +35,18 @@ func (ts TimeSeries) GetValue(index int) (x float64, y float64) {
return return
} }
// GetValueFormatters returns value formatter defaults for the series.
func (ts TimeSeries) GetValueFormatters() (x, y ValueFormatter) {
x = TimeValueFormatter
y = FloatValueFormatter
return
}
// GetYAxis returns which YAxis the series draws on.
func (ts TimeSeries) GetYAxis() YAxisType {
return ts.YAxis
}
// Render renders the series. // Render renders the series.
func (ts TimeSeries) Render(r Renderer, canvasBox Box, xrange, yrange Range, defaults Style) { func (ts TimeSeries) Render(r Renderer, canvasBox Box, xrange, yrange Range, defaults Style) {
style := ts.Style.WithDefaultsFrom(defaults) style := ts.Style.WithDefaultsFrom(defaults)

View file

@ -3,8 +3,6 @@ package chart
import ( import (
"fmt" "fmt"
"time" "time"
"github.com/blendlabs/go-util"
) )
// ValueFormatter is a function that takes a value and produces a string. // ValueFormatter is a function that takes a value and produces a string.
@ -26,7 +24,7 @@ func TimeValueFormatterWithFormat(v interface{}, dateFormat string) string {
if typed, isTyped := v.(float64); isTyped { if typed, isTyped := v.(float64); isTyped {
return time.Unix(int64(typed), 0).Format(dateFormat) return time.Unix(int64(typed), 0).Format(dateFormat)
} }
return util.StringEmpty return ""
} }
// FloatValueFormatter is a ValueFormatter for float64. // FloatValueFormatter is a ValueFormatter for float64.
@ -39,5 +37,5 @@ func FloatValueFormatterWithFormat(v interface{}, floatFormat string) string {
if typed, isTyped := v.(float64); isTyped { if typed, isTyped := v.(float64); isTyped {
return fmt.Sprintf(floatFormat, typed) return fmt.Sprintf(floatFormat, typed)
} }
return util.StringEmpty return ""
} }

View file

@ -0,0 +1,6 @@
package chart
// ValueFormatterProvider is a series that has custom formatters.
type ValueFormatterProvider interface {
GetValueFormatters() (x, y ValueFormatter)
}

View file

@ -1,27 +1,101 @@
package chart package chart
import "github.com/wcharczuk/go-chart/drawing" import (
"math"
"sort"
"github.com/wcharczuk/go-chart/drawing"
)
// XAxis represents the horizontal axis. // XAxis represents the horizontal axis.
type XAxis struct { type XAxis struct {
axis Name string
Style Style
ValueFormatter ValueFormatter
Range Range
Ticks []Tick
}
// GetName returns the name.
func (xa XAxis) GetName() string {
return xa.Name
}
// GetStyle returns the style.
func (xa XAxis) GetStyle() Style {
return xa.Style
}
// GetTicks returns the ticks for a series. It coalesces between user provided ticks and
// generated ticks.
func (xa XAxis) GetTicks(r Renderer, ra Range, vf ValueFormatter) []Tick {
if len(xa.Ticks) > 0 {
return xa.Ticks
}
return xa.generateTicks(r, ra, vf)
}
func (xa XAxis) generateTicks(r Renderer, ra Range, vf ValueFormatter) []Tick {
step := xa.getTickStep(r, ra, vf)
return xa.generateTicksWithStep(ra, step, vf)
}
func (xa XAxis) getTickCount(r Renderer, ra Range, vf ValueFormatter) int {
fontSize := xa.Style.GetFontSize(DefaultFontSize)
r.SetFontSize(fontSize)
// take a cut at determining the 'widest' value.
l0 := vf(ra.Min)
ln := vf(ra.Max)
ll := l0
if len(ln) > len(l0) {
ll = ln
}
llw, _ := r.MeasureText(ll)
textWidth := drawing.PointsToPixels(r.GetDPI(), float64(llw))
width := textWidth + DefaultMinimumTickHorizontalSpacing
count := int(math.Ceil(float64(ra.Domain) / float64(width)))
return count
}
func (xa XAxis) getTickStep(r Renderer, ra Range, vf ValueFormatter) float64 {
tickCount := xa.getTickCount(r, ra, vf)
step := ra.Delta() / float64(tickCount)
return step
}
func (xa XAxis) generateTicksWithStep(ra Range, step float64, vf ValueFormatter) []Tick {
var ticks []Tick
for cursor := ra.Min; cursor < ra.Max; cursor += step {
ticks = append(ticks, Tick{
Value: cursor,
Label: vf(cursor),
})
}
return ticks
} }
// Render renders the axis // Render renders the axis
func (xa XAxis) Render(r Renderer, canvasBox Box, ra Range) { func (xa XAxis) Render(r Renderer, canvasBox Box, ra Range, ticks []Tick) {
tickFontSize := xa.Style.GetFontSize(DefaultFontSize) tickFontSize := xa.Style.GetFontSize(DefaultFontSize)
tickHeight := drawing.PointsToPixels(r.GetDPI(), tickFontSize) tickHeight := drawing.PointsToPixels(r.GetDPI(), tickFontSize)
ty := canvasBox.Bottom + DefaultXAxisMargin + int(tickHeight) ty := canvasBox.Bottom + DefaultXAxisMargin + int(tickHeight)
r.SetStrokeColor(xa.Style.GetStrokeColor(DefaultAxisColor))
r.SetStrokeWidth(xa.Style.GetStrokeWidth(DefaultAxisLineWidth))
r.MoveTo(canvasBox.Left, canvasBox.Bottom)
r.LineTo(canvasBox.Right, canvasBox.Bottom)
r.Stroke()
r.SetFontColor(xa.Style.GetFontColor(DefaultAxisColor)) r.SetFontColor(xa.Style.GetFontColor(DefaultAxisColor))
r.SetFontSize(tickFontSize) r.SetFontSize(tickFontSize)
ticks := xa.getTicks(ra) sort.Sort(Ticks(ticks))
for _, t := range ticks { for _, t := range ticks {
v := t.Value v := t.Value
x := ra.Translate(v) x := ra.Translate(v)
tx := canvasBox.Left + int(x) tx := canvasBox.Right - x
r.Text(t.Label, tx, ty) r.Text(t.Label, tx, ty)
} }
} }

View file

@ -1,28 +1,102 @@
package chart package chart
import (
"math"
"sort"
)
// YAxis is a veritcal rule of the range. // YAxis is a veritcal rule of the range.
// There can be (2) y-axes; a primary and secondary. // There can be (2) y-axes; a primary and secondary.
type YAxis struct { type YAxis struct {
axis Name string
Style Style
ValueFormatter ValueFormatter
Range Range
Ticks []Tick
}
// GetName returns the name.
func (ya YAxis) GetName() string {
return ya.Name
}
// GetStyle returns the style.
func (ya YAxis) GetStyle() Style {
return ya.Style
}
// GetTicks returns the ticks for a series. It coalesces between user provided ticks and
// generated ticks.
func (ya YAxis) GetTicks(r Renderer, ra Range, vf ValueFormatter) []Tick {
if len(ya.Ticks) > 0 {
return ya.Ticks
}
return ya.generateTicks(r, ra, vf)
}
func (ya YAxis) generateTicks(r Renderer, ra Range, vf ValueFormatter) []Tick {
step := ya.getTickStep(r, ra, vf)
return ya.generateTicksWithStep(ra, step, vf)
}
func (ya YAxis) getTickCount(r Renderer, ra Range, vf ValueFormatter) int {
textHeight := int(ya.Style.GetFontSize(DefaultFontSize))
height := textHeight + DefaultMinimumTickVerticalSpacing
count := int(math.Ceil(float64(ra.Domain) / float64(height)))
return count
}
func (ya YAxis) getTickStep(r Renderer, ra Range, vf ValueFormatter) float64 {
tickCount := ya.getTickCount(r, ra, vf)
return ra.Delta() / float64(tickCount)
}
func (ya YAxis) generateTicksWithStep(ra Range, step float64, vf ValueFormatter) []Tick {
var ticks []Tick
for cursor := ra.Min; cursor < ra.Max; cursor += step {
ticks = append(ticks, Tick{
Value: cursor,
Label: vf(cursor),
})
}
return ticks
} }
// Render renders the axis. // Render renders the axis.
func (ya YAxis) Render(r Renderer, canvasBox Box, ra Range, axisType YAxisType) { func (ya YAxis) Render(r Renderer, canvasBox Box, ra Range, axisType YAxisType, ticks []Tick) {
var lx int
var tx int var tx int
if axisType == YAxisPrimary { if axisType == YAxisPrimary {
lx = canvasBox.Right
tx = canvasBox.Right + DefaultYAxisMargin tx = canvasBox.Right + DefaultYAxisMargin
} else if axisType == YAxisSecondary { } else if axisType == YAxisSecondary {
lx = canvasBox.Left
tx = canvasBox.Left - DefaultYAxisMargin tx = canvasBox.Left - DefaultYAxisMargin
} }
r.SetFontColor(ya.Style.GetFontColor(DefaultAxisColor)) r.SetStrokeColor(ya.Style.GetStrokeColor(DefaultAxisColor))
r.SetFontSize(ya.Style.GetFontSize(DefaultFontSize)) r.SetStrokeWidth(ya.Style.GetStrokeWidth(DefaultAxisLineWidth))
ticks := ya.getTicks(ra) r.MoveTo(lx, canvasBox.Bottom)
r.LineTo(lx, canvasBox.Top)
r.Stroke()
r.SetFontColor(ya.Style.GetFontColor(DefaultAxisColor))
fontSize := ya.Style.GetFontSize(DefaultFontSize)
r.SetFontSize(fontSize)
sort.Sort(Ticks(ticks))
for _, t := range ticks { for _, t := range ticks {
v := t.Value v := t.Value
y := ra.Translate(v) ly := ra.Translate(v) + canvasBox.Top
ty := int(y)
th := int(fontSize) >> 1
ty := ly + th
r.Text(t.Label, tx, ty) r.Text(t.Label, tx, ty)
r.MoveTo(lx, ly)
r.LineTo(lx+DefaultVerticalTickWidth, ly)
r.Stroke()
} }
} }