package chart import ( "errors" "io" "math" "github.com/golang/freetype/truetype" ) // Chart is what we're drawing. type Chart struct { Title string TitleStyle Style Width int Height int DPI float64 Background Style Canvas Style Axes Style FinalValueLabel Style XRange Range YRange Range Font *truetype.Font Series []Series } // 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 } // GetFont returns the text font. func (c Chart) GetFont() (*truetype.Font, error) { if c.Font == nil { f, err := GetDefaultFont() if err != nil { return nil, err } return f, nil } return c.Font, nil } // Render renders the chart with the given renderer to the given io.Writer. func (c *Chart) Render(provider RendererProvider, w io.Writer) error { if len(c.Series) == 0 { return errors.New("Please provide at least one series") } r, err := provider(c.Width, c.Height) if err != nil { return err } if c.hasText() { font, err := c.GetFont() if err != nil { return err } r.SetFont(font) } r.SetDPI(c.GetDPI(DefaultDPI)) canvasBox := c.calculateCanvasBox(r) xrange, yrange := c.initRanges(canvasBox) c.drawBackground(r) c.drawCanvas(r, canvasBox) c.drawAxes(r, canvasBox, xrange, yrange) for index, series := range c.Series { c.drawSeries(r, canvasBox, index, series, xrange, yrange) } c.drawTitle(r) return r.Save(w) } func (c Chart) hasText() bool { return c.TitleStyle.Show || c.Axes.Show || c.FinalValueLabel.Show } func (c Chart) getAxisWidth() int { asw := 0 if c.Axes.Show { asw = int(c.Axes.GetStrokeWidth(DefaultAxisLineWidth)) } return asw } func (c Chart) calculateCanvasBox(r Renderer) Box { dpr := DefaultBackgroundPadding.Right finalLabelWidth := c.calculateFinalLabelWidth(r) if finalLabelWidth > dpr { dpr = finalLabelWidth } axisBottomHeight := c.calculateBottomLabelHeight() dpb := DefaultBackgroundPadding.Bottom if dpb < axisBottomHeight { dpb = axisBottomHeight } cb := Box{ Top: c.Background.Padding.GetTop(DefaultBackgroundPadding.Top), Left: c.Background.Padding.GetLeft(DefaultBackgroundPadding.Left), Right: c.Width - c.Background.Padding.GetRight(dpr), Bottom: c.Height - c.Background.Padding.GetBottom(dpb), } cb.Height = cb.Bottom - cb.Top cb.Width = cb.Right - cb.Left return cb } func (c Chart) calculateFinalLabelWidth(r Renderer) int { if !c.FinalValueLabel.Show { return 0 } var finalLabelText string for _, s := range c.Series { _, lv := s.GetValue(s.Len() - 1) var ll string if c.YRange.Formatter != nil { ll = c.YRange.Formatter(lv) } else { ll = s.GetYFormatter()(lv) } if len(finalLabelText) < len(ll) { finalLabelText = ll } } r.SetFontSize(c.FinalValueLabel.GetFontSize(DefaultFinalLabelFontSize)) textWidth, _ := r.MeasureText(finalLabelText) asw := c.getAxisWidth() pl := c.FinalValueLabel.Padding.GetLeft(DefaultFinalLabelPadding.Left) pr := c.FinalValueLabel.Padding.GetRight(DefaultFinalLabelPadding.Right) lsw := int(c.FinalValueLabel.GetStrokeWidth(DefaultAxisLineWidth)) return DefaultFinalLabelDeltaWidth + pl + pr + textWidth + asw + 2*lsw } func (c Chart) calculateBottomLabelHeight() int { if c.Axes.Show { return c.getAxisWidth() + int(math.Ceil(c.Axes.GetFontSize(DefaultAxisFontSize))) + DefaultXAxisMargin } return 0 } func (c Chart) initRanges(canvasBox Box) (xrange Range, yrange Range) { //iterate over each series, pull out the min/max for x,y var didSetFirstValues bool var globalMinY, globalMinX float64 var globalMaxY, globalMaxX float64 for _, s := range c.Series { seriesLength := s.Len() for index := 0; index < seriesLength; index++ { vx, vy := s.GetValue(index) if didSetFirstValues { if globalMinX > vx { globalMinX = vx } if globalMinY > vy { globalMinY = vy } if globalMaxX < vx { globalMaxX = vx } if globalMaxY < vy { globalMaxY = vy } } else { globalMinX, globalMaxX = vx, vx globalMinY, globalMaxY = vy, vy didSetFirstValues = true } } if xrange.Formatter == nil { xrange.Formatter = s.GetXFormatter() } if yrange.Formatter == nil { yrange.Formatter = s.GetYFormatter() } } if c.XRange.IsZero() { xrange.Min = globalMinX xrange.Max = globalMaxX } else { xrange.Min = c.XRange.Min xrange.Max = c.XRange.Max } if c.XRange.Formatter != nil { xrange.Formatter = c.XRange.Formatter } if c.XRange.Ticks != nil { xrange.Ticks = c.XRange.Ticks } xrange.Domain = canvasBox.Width if c.YRange.IsZero() { yrange.Min = globalMinY yrange.Max = globalMaxY } else { yrange.Min = c.YRange.Min yrange.Max = c.YRange.Max } if c.YRange.Formatter != nil { yrange.Formatter = c.YRange.Formatter } if c.YRange.Ticks != nil { yrange.Ticks = c.YRange.Ticks } yrange.Domain = canvasBox.Height return } func (c Chart) drawBackground(r Renderer) { r.SetFillColor(c.Background.GetFillColor(DefaultBackgroundColor)) r.SetStrokeColor(c.Background.GetStrokeColor(DefaultBackgroundStrokeColor)) r.SetStrokeWidth(c.Background.GetStrokeWidth(DefaultStrokeWidth)) r.MoveTo(0, 0) r.LineTo(c.Width, 0) r.LineTo(c.Width, c.Height) r.LineTo(0, c.Height) r.LineTo(0, 0) r.Close() r.FillStroke() } func (c Chart) drawCanvas(r Renderer, canvasBox Box) { r.SetFillColor(c.Canvas.GetFillColor(DefaultCanvasColor)) r.SetStrokeColor(c.Canvas.GetStrokeColor(DefaultCanvasStrokColor)) r.SetStrokeWidth(c.Canvas.GetStrokeWidth(DefaultStrokeWidth)) r.MoveTo(canvasBox.Left, canvasBox.Top) r.LineTo(canvasBox.Right, canvasBox.Top) r.LineTo(canvasBox.Right, canvasBox.Bottom) r.LineTo(canvasBox.Left, canvasBox.Bottom) r.LineTo(canvasBox.Left, canvasBox.Top) r.Close() r.FillStroke() } func (c Chart) drawAxes(r Renderer, canvasBox Box, xrange, yrange Range) { if c.Axes.Show { r.SetStrokeColor(c.Axes.GetStrokeColor(DefaultAxisColor)) r.SetStrokeWidth(c.Axes.GetStrokeWidth(DefaultStrokeWidth)) r.MoveTo(canvasBox.Left, canvasBox.Bottom) r.LineTo(canvasBox.Right, canvasBox.Bottom) r.LineTo(canvasBox.Right, canvasBox.Top) r.Stroke() c.drawXAxisLabels(r, canvasBox, xrange) c.drawYAxisLabels(r, canvasBox, yrange) } } func (c Chart) generateRangeTicks(r Range, tickCount int, offset float64) []Tick { var ticks []Tick rangeTicks := Slices(tickCount, r.Max-r.Min) for _, rv := range rangeTicks { ticks = append(ticks, Tick{ RangeValue: rv + offset, Label: r.Format(rv + offset), }) } return ticks } func (c Chart) drawYAxisLabels(r Renderer, canvasBox Box, yrange Range) { tickFontSize := c.Axes.GetFontSize(DefaultAxisFontSize) asw := c.getAxisWidth() tx := canvasBox.Right + DefaultFinalLabelDeltaWidth + asw r.SetFontColor(c.Axes.GetFontColor(DefaultAxisColor)) r.SetFontSize(tickFontSize) ticks := yrange.Ticks if ticks == nil { minimumTickHeight := tickFontSize + DefaultMinimumTickVerticalSpacing tickCount := int(math.Floor(float64(yrange.Domain) / float64(minimumTickHeight))) if tickCount > DefaultMaxTickCount { tickCount = DefaultMaxTickCount } ticks = c.generateRangeTicks(yrange, tickCount, yrange.Min) } for _, t := range ticks { v := t.RangeValue y := yrange.Translate(v) ty := int(y) r.Text(t.Label, tx, ty) } } func (c Chart) drawXAxisLabels(r Renderer, canvasBox Box, xrange Range) { tickFontSize := c.Axes.GetFontSize(DefaultAxisFontSize) ty := canvasBox.Bottom + DefaultXAxisMargin + int(tickFontSize) r.SetFontColor(c.Axes.GetFontColor(DefaultAxisColor)) r.SetFontSize(tickFontSize) ticks := xrange.Ticks if ticks == nil { maxLabelWidth := 60 minimumTickWidth := maxLabelWidth + DefaultMinimumTickHorizontalSpacing tickCount := int(math.Floor(float64(xrange.Domain) / float64(minimumTickWidth))) if tickCount > DefaultMaxTickCount { tickCount = DefaultMaxTickCount } ticks = c.generateRangeTicks(xrange, tickCount, xrange.Min) } for _, t := range ticks { v := t.RangeValue x := xrange.Translate(v) tx := canvasBox.Left + int(x) r.Text(t.Label, tx, ty) } } func (c Chart) drawSeries(r Renderer, canvasBox Box, index int, s Series, xrange, yrange Range) { if s.Len() == 0 { return } cx := canvasBox.Left cy := canvasBox.Top cb := canvasBox.Bottom cw := canvasBox.Width v0x, v0y := s.GetValue(0) x0 := cw - xrange.Translate(v0x) y0 := yrange.Translate(v0y) var vx, vy float64 var x, y int fill := s.GetStyle().GetFillColor() if !fill.IsZero() { r.SetFillColor(fill) r.MoveTo(x0+cx, y0+cy) for i := 1; i < s.Len(); i++ { vx, vy = s.GetValue(i) x = cw - xrange.Translate(vx) y = yrange.Translate(vy) r.LineTo(x+cx, y+cy) } r.LineTo(x+cx, cb) r.LineTo(x0+cx, cb) r.Close() r.Fill() } stroke := s.GetStyle().GetStrokeColor(GetDefaultSeriesStrokeColor(index)) r.SetStrokeColor(stroke) r.SetStrokeWidth(s.GetStyle().GetStrokeWidth(DefaultStrokeWidth)) r.MoveTo(x0+cx, y0+cy) for i := 1; i < s.Len(); i++ { vx, vy = s.GetValue(i) x = cw - xrange.Translate(vx) y = yrange.Translate(vy) r.LineTo(x+cx, y+cy) } r.Stroke() c.drawFinalValueLabel(r, canvasBox, index, s, yrange) } func (c Chart) drawFinalValueLabel(r Renderer, canvasBox Box, index int, s Series, yrange Range) { if c.FinalValueLabel.Show { _, lv := s.GetValue(s.Len() - 1) ll := yrange.Format(lv) py := canvasBox.Top ly := yrange.Translate(lv) + py r.SetFontSize(c.FinalValueLabel.GetFontSize(DefaultFinalLabelFontSize)) textWidth, _ := r.MeasureText(ll) textHeight := int(math.Floor(DefaultFinalLabelFontSize)) halfTextHeight := textHeight >> 1 asw := 0 if c.Axes.Show { asw = int(c.Axes.GetStrokeWidth(DefaultAxisLineWidth)) } cx := canvasBox.Right + asw pt := c.FinalValueLabel.Padding.GetTop(DefaultFinalLabelPadding.Top) pl := c.FinalValueLabel.Padding.GetLeft(DefaultFinalLabelPadding.Left) pr := c.FinalValueLabel.Padding.GetRight(DefaultFinalLabelPadding.Right) pb := c.FinalValueLabel.Padding.GetBottom(DefaultFinalLabelPadding.Bottom) textX := cx + pl + DefaultFinalLabelDeltaWidth textY := ly + halfTextHeight ltlx := cx + pl + DefaultFinalLabelDeltaWidth ltly := ly - (pt + halfTextHeight) ltrx := cx + pl + pr + textWidth ltry := ly - (pt + halfTextHeight) lbrx := cx + pl + pr + textWidth lbry := ly + (pb + halfTextHeight) lblx := cx + DefaultFinalLabelDeltaWidth lbly := ly + (pb + halfTextHeight) //draw the shape... r.SetFillColor(c.FinalValueLabel.GetFillColor(DefaultFinalLabelBackgroundColor)) r.SetStrokeColor(c.FinalValueLabel.GetStrokeColor(s.GetStyle().GetStrokeColor(GetDefaultSeriesStrokeColor(index)))) r.SetStrokeWidth(c.FinalValueLabel.GetStrokeWidth(DefaultAxisLineWidth)) r.MoveTo(cx, ly) r.LineTo(ltlx, ltly) r.LineTo(ltrx, ltry) r.LineTo(lbrx, lbry) r.LineTo(lblx, lbly) r.LineTo(cx, ly) r.Close() r.FillStroke() r.SetFontColor(c.FinalValueLabel.GetFontColor(DefaultTextColor)) r.Text(ll, textX, textY) } } func (c Chart) drawTitle(r Renderer) error { if len(c.Title) > 0 && c.TitleStyle.Show { r.SetFontColor(c.Canvas.GetFontColor(DefaultTextColor)) titleFontSize := c.Canvas.GetFontSize(DefaultTitleFontSize) r.SetFontSize(titleFontSize) textWidth, _ := r.MeasureText(c.Title) titleX := (c.Width >> 1) - (textWidth >> 1) titleY := c.TitleStyle.Padding.GetTop(DefaultTitleTop) + int(titleFontSize) r.Text(c.Title, titleX, titleY) } return nil }