zeni/go-chart
1
0
Fork 0
Code Issues Pull requests Projects Releases 2 Packages Wiki Activity Actions

Use ArcTo to draw the single value case.

Browse source 
Use the ArcTo method to draw the single value case.
Rename pc (piechart) to dc (donutchart)
This commit is contained in:
Anders Bach Madsen 2020-05-26 15:47:22 +02:00
parent 962b9abdec
commit 69b6cb7fc5
1 changed files with 102 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

190
donut_chart.go
View file

@ -31,97 +31,97 @@ type DonutChart struct {
} }
// GetDPI returns the dpi for the chart. // GetDPI returns the dpi for the chart.
func (pc DonutChart) GetDPI(defaults ...float64) float64 { func (dc DonutChart) GetDPI(defaults ...float64) float64 {
if pc.DPI == 0 { if dc.DPI == 0 {
if len(defaults) > 0 { if len(defaults) > 0 {
return defaults[0] return defaults[0]
} }
return DefaultDPI return DefaultDPI
} }
return pc.DPI return dc.DPI
} }
// GetFont returns the text font. // GetFont returns the text font.
func (pc DonutChart) GetFont() *truetype.Font { func (dc DonutChart) GetFont() *truetype.Font {
if pc.Font == nil { if dc.Font == nil {
return pc.defaultFont return dc.defaultFont
} }
return pc.Font return dc.Font
} }
// GetWidth returns the chart width or the default value. // GetWidth returns the chart width or the default value.
func (pc DonutChart) GetWidth() int { func (dc DonutChart) GetWidth() int {
if pc.Width == 0 { if dc.Width == 0 {
return DefaultChartWidth return DefaultChartWidth
} }
return pc.Width return dc.Width
} }
// GetHeight returns the chart height or the default value. // GetHeight returns the chart height or the default value.
func (pc DonutChart) GetHeight() int { func (dc DonutChart) GetHeight() int {
if pc.Height == 0 { if dc.Height == 0 {
return DefaultChartWidth return DefaultChartWidth
} }
return pc.Height return dc.Height
} }
// 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 (pc DonutChart) Render(rp RendererProvider, w io.Writer) error { func (dc DonutChart) Render(rp RendererProvider, w io.Writer) error {
if len(pc.Values) == 0 { if len(dc.Values) == 0 {
return errors.New("please provide at least one value") return errors.New("please provide at least one value")
} }
r, err := rp(pc.GetWidth(), pc.GetHeight()) r, err := rp(dc.GetWidth(), dc.GetHeight())
if err != nil { if err != nil {
return err return err
} }
if pc.Font == nil { if dc.Font == nil {
defaultFont, err := GetDefaultFont() defaultFont, err := GetDefaultFont()
if err != nil { if err != nil {
return err return err
} }
pc.defaultFont = defaultFont dc.defaultFont = defaultFont
} }
r.SetDPI(pc.GetDPI(DefaultDPI)) r.SetDPI(dc.GetDPI(DefaultDPI))
canvasBox := pc.getDefaultCanvasBox() canvasBox := dc.getDefaultCanvasBox()
canvasBox = pc.getCircleAdjustedCanvasBox(canvasBox) canvasBox = dc.getCircleAdjustedCanvasBox(canvasBox)
pc.drawBackground(r) dc.drawBackground(r)
pc.drawCanvas(r, canvasBox) dc.drawCanvas(r, canvasBox)
finalValues, err := pc.finalizeValues(pc.Values) finalValues, err := dc.finalizeValues(dc.Values)
if err != nil { if err != nil {
return err return err
} }
pc.drawSlices(r, canvasBox, finalValues) dc.drawSlices(r, canvasBox, finalValues)
pc.drawTitle(r) dc.drawTitle(r)
for _, a := range pc.Elements { for _, a := range dc.Elements {
a(r, canvasBox, pc.styleDefaultsElements()) a(r, canvasBox, dc.styleDefaultsElements())
} }
return r.Save(w) return r.Save(w)
} }
func (pc DonutChart) drawBackground(r Renderer) { func (dc DonutChart) drawBackground(r Renderer) {
Draw.Box(r, Box{ Draw.Box(r, Box{
Right: pc.GetWidth(), Right: dc.GetWidth(),
Bottom: pc.GetHeight(), Bottom: dc.GetHeight(),
}, pc.getBackgroundStyle()) }, dc.getBackgroundStyle())
} }
func (pc DonutChart) drawCanvas(r Renderer, canvasBox Box) { func (dc DonutChart) drawCanvas(r Renderer, canvasBox Box) {
Draw.Box(r, canvasBox, pc.getCanvasStyle()) Draw.Box(r, canvasBox, dc.getCanvasStyle())
} }
func (pc DonutChart) drawTitle(r Renderer) { func (dc DonutChart) drawTitle(r Renderer) {
if len(pc.Title) > 0 && !pc.TitleStyle.Hidden { if len(dc.Title) > 0 && !dc.TitleStyle.Hidden {
Draw.TextWithin(r, pc.Title, pc.Box(), pc.styleDefaultsTitle()) Draw.TextWithin(r, dc.Title, dc.Box(), dc.styleDefaultsTitle())
} }
} }
func (pc DonutChart) drawSlices(r Renderer, canvasBox Box, values []Value) { func (dc DonutChart) drawSlices(r Renderer, canvasBox Box, values []Value) {
cx, cy := canvasBox.Center() cx, cy := canvasBox.Center()
diameter := MinInt(canvasBox.Width(), canvasBox.Height()) diameter := MinInt(canvasBox.Width(), canvasBox.Height())
radius := float64(diameter>>1) / 1.1 radius := float64(diameter>>1) / 1.1
@ -132,12 +132,15 @@ func (pc DonutChart) drawSlices(r Renderer, canvasBox Box, values []Value) {
var lx, ly int var lx, ly int
if len(values) == 1 { if len(values) == 1 {
pc.styleDonutChartValue(0).WriteToRenderer(r) dc.styleDonutChartValueSingle(0).WriteToRenderer(r)
r.MoveTo(cx, cy) r.MoveTo(cx, cy)
r.Circle(radius, cx, cy) r.ArcTo(cx, cy, (radius / 1.25), (radius / 1.25), DegreesToRadians(0), DegreesToRadians(359))
r.LineTo(cx, cy)
r.Close()
r.FillStroke()
} else { } else {
for index, v := range values { for index, v := range values {
v.Style.InheritFrom(pc.styleDonutChartValue(index)).WriteToRenderer(r) v.Style.InheritFrom(dc.styleDonutChartValue(index)).WriteToRenderer(r)
r.MoveTo(cx, cy) r.MoveTo(cx, cy)
rads = PercentToRadians(total) rads = PercentToRadians(total)
delta = PercentToRadians(v.Value) delta = PercentToRadians(v.Value)
@ -153,8 +156,8 @@ func (pc DonutChart) drawSlices(r Renderer, canvasBox Box, values []Value) {
//making the donut hole //making the donut hole
v := Value{Value: 100, Label: "center"} v := Value{Value: 100, Label: "center"}
styletemp := pc.SliceStyle.InheritFrom(Style{ styletemp := dc.SliceStyle.InheritFrom(Style{
StrokeColor: ColorWhite, StrokeWidth: 4.0, FillColor: ColorWhite, FontColor: ColorWhite, //Font: pc.GetFont(),//FontSize: pc.getScaledFontSize(), StrokeColor: ColorWhite, StrokeWidth: 4.0, FillColor: ColorWhite, FontColor: ColorWhite,
}) })
v.Style.InheritFrom(styletemp).WriteToRenderer(r) v.Style.InheritFrom(styletemp).WriteToRenderer(r)
r.MoveTo(cx, cy) r.MoveTo(cx, cy)
@ -166,7 +169,7 @@ func (pc DonutChart) drawSlices(r Renderer, canvasBox Box, values []Value) {
// draw the labels // draw the labels
total = 0 total = 0
for index, v := range values { for index, v := range values {
v.Style.InheritFrom(pc.styleDonutChartValue(index)).WriteToRenderer(r) v.Style.InheritFrom(dc.styleDonutChartValue(index)).WriteToRenderer(r)
if len(v.Label) > 0 { if len(v.Label) > 0 {
delta2 = PercentToRadians(total + (v.Value / 2.0)) delta2 = PercentToRadians(total + (v.Value / 2.0))
delta2 = RadianAdd(delta2, _pi2) delta2 = RadianAdd(delta2, _pi2)
@ -182,7 +185,7 @@ func (pc DonutChart) drawSlices(r Renderer, canvasBox Box, values []Value) {
} }
} }
func (pc DonutChart) finalizeValues(values []Value) ([]Value, error) { func (dc DonutChart) finalizeValues(values []Value) ([]Value, error) {
finalValues := Values(values).Normalize() finalValues := Values(values).Normalize()
if len(finalValues) == 0 { if len(finalValues) == 0 {
return nil, fmt.Errorf("donut chart must contain at least (1) non-zero value") return nil, fmt.Errorf("donut chart must contain at least (1) non-zero value")
@ -190,11 +193,11 @@ func (pc DonutChart) finalizeValues(values []Value) ([]Value, error) {
return finalValues, nil return finalValues, nil
} }
func (pc DonutChart) getDefaultCanvasBox() Box { func (dc DonutChart) getDefaultCanvasBox() Box {
return pc.Box() return dc.Box()
} }
func (pc DonutChart) getCircleAdjustedCanvasBox(canvasBox Box) Box { func (dc DonutChart) getCircleAdjustedCanvasBox(canvasBox Box) Box {
circleDiameter := MinInt(canvasBox.Width(), canvasBox.Height()) circleDiameter := MinInt(canvasBox.Width(), canvasBox.Height())
square := Box{ square := Box{
@ -205,43 +208,54 @@ func (pc DonutChart) getCircleAdjustedCanvasBox(canvasBox Box) Box {
return canvasBox.Fit(square) return canvasBox.Fit(square)
} }
func (pc DonutChart) getBackgroundStyle() Style { func (dc DonutChart) getBackgroundStyle() Style {
return pc.Background.InheritFrom(pc.styleDefaultsBackground()) return dc.Background.InheritFrom(dc.styleDefaultsBackground())
} }
func (pc DonutChart) getCanvasStyle() Style { func (dc DonutChart) getCanvasStyle() Style {
return pc.Canvas.InheritFrom(pc.styleDefaultsCanvas()) return dc.Canvas.InheritFrom(dc.styleDefaultsCanvas())
} }
func (pc DonutChart) styleDefaultsCanvas() Style { func (dc DonutChart) styleDefaultsCanvas() Style {
return Style{ return Style{
FillColor: pc.GetColorPalette().CanvasColor(), FillColor: dc.GetColorPalette().CanvasColor(),
StrokeColor: pc.GetColorPalette().CanvasStrokeColor(), StrokeColor: dc.GetColorPalette().CanvasStrokeColor(),
StrokeWidth: DefaultStrokeWidth, StrokeWidth: DefaultStrokeWidth,
} }
} }
func (pc DonutChart) styleDefaultsDonutChartValue() Style { func (dc DonutChart) styleDefaultsDonutChartValue() Style {
return Style{ return Style{
StrokeColor: pc.GetColorPalette().TextColor(), StrokeColor: dc.GetColorPalette().TextColor(),
StrokeWidth: 4.0, StrokeWidth: 4.0,
FillColor: pc.GetColorPalette().TextColor(), FillColor: dc.GetColorPalette().TextColor(),
} }
} }
func (pc DonutChart) styleDonutChartValue(index int) Style { func (dc DonutChart) styleDonutChartValue(index int) Style {
return pc.SliceStyle.InheritFrom(Style{ return dc.SliceStyle.InheritFrom(Style{
StrokeColor: ColorWhite, StrokeColor: ColorWhite,
StrokeWidth: 4.0, StrokeWidth: 4.0,
FillColor: pc.GetColorPalette().GetSeriesColor(index), FillColor: dc.GetColorPalette().GetSeriesColor(index),
FontSize: pc.getScaledFontSize(), FontSize: dc.getScaledFontSize(),
FontColor: pc.GetColorPalette().TextColor(), FontColor: dc.GetColorPalette().TextColor(),
Font: pc.GetFont(), Font: dc.GetFont(),
}) })
} }
func (pc DonutChart) getScaledFontSize() float64 { func (dc DonutChart) styleDonutChartValueSingle(index int) Style {
effectiveDimension := MinInt(pc.GetWidth(), pc.GetHeight()) return dc.SliceStyle.InheritFrom(Style{
StrokeColor: dc.GetColorPalette().GetSeriesColor(index),
StrokeWidth: 4.0,
FillColor: dc.GetColorPalette().GetSeriesColor(index),
FontSize: dc.getScaledFontSize(),
FontColor: dc.GetColorPalette().TextColor(),
Font: dc.GetFont(),
})
}
func (dc DonutChart) getScaledFontSize() float64 {
effectiveDimension := MinInt(dc.GetWidth(), dc.GetHeight())
if effectiveDimension >= 2048 { if effectiveDimension >= 2048 {
return 48.0 return 48.0
} else if effectiveDimension >= 1024 { } else if effectiveDimension >= 1024 {
@ -254,33 +268,33 @@ func (pc DonutChart) getScaledFontSize() float64 {
return 10.0 return 10.0
} }
func (pc DonutChart) styleDefaultsBackground() Style { func (dc DonutChart) styleDefaultsBackground() Style {
return Style{ return Style{
FillColor: pc.GetColorPalette().BackgroundColor(), FillColor: dc.GetColorPalette().BackgroundColor(),
StrokeColor: pc.GetColorPalette().BackgroundStrokeColor(), StrokeColor: dc.GetColorPalette().BackgroundStrokeColor(),
StrokeWidth: DefaultStrokeWidth, StrokeWidth: DefaultStrokeWidth,
} }
} }
func (pc DonutChart) styleDefaultsElements() Style { func (dc DonutChart) styleDefaultsElements() Style {
return Style{ return Style{
Font: pc.GetFont(), Font: dc.GetFont(),
} }
} }
func (pc DonutChart) styleDefaultsTitle() Style { func (dc DonutChart) styleDefaultsTitle() Style {
return pc.TitleStyle.InheritFrom(Style{ return dc.TitleStyle.InheritFrom(Style{
FontColor: pc.GetColorPalette().TextColor(), FontColor: dc.GetColorPalette().TextColor(),
Font: pc.GetFont(), Font: dc.GetFont(),
FontSize: pc.getTitleFontSize(), FontSize: dc.getTitleFontSize(),
TextHorizontalAlign: TextHorizontalAlignCenter, TextHorizontalAlign: TextHorizontalAlignCenter,
TextVerticalAlign: TextVerticalAlignTop, TextVerticalAlign: TextVerticalAlignTop,
TextWrap: TextWrapWord, TextWrap: TextWrapWord,
}) })
} }
func (pc DonutChart) getTitleFontSize() float64 { func (dc DonutChart) getTitleFontSize() float64 {
effectiveDimension := MinInt(pc.GetWidth(), pc.GetHeight()) effectiveDimension := MinInt(dc.GetWidth(), dc.GetHeight())
if effectiveDimension >= 2048 { if effectiveDimension >= 2048 {
return 48 return 48
} else if effectiveDimension >= 1024 { } else if effectiveDimension >= 1024 {
@ -294,22 +308,22 @@ func (pc DonutChart) getTitleFontSize() float64 {
} }
// GetColorPalette returns the color palette for the chart. // GetColorPalette returns the color palette for the chart.
func (pc DonutChart) GetColorPalette() ColorPalette { func (dc DonutChart) GetColorPalette() ColorPalette {
if pc.ColorPalette != nil { if dc.ColorPalette != nil {
return pc.ColorPalette return dc.ColorPalette
} }
return AlternateColorPalette return AlternateColorPalette
} }
// Box returns the chart bounds as a box. // Box returns the chart bounds as a box.
func (pc DonutChart) Box() Box { func (dc DonutChart) Box() Box {
dpr := pc.Background.Padding.GetRight(DefaultBackgroundPadding.Right) dpr := dc.Background.Padding.GetRight(DefaultBackgroundPadding.Right)
dpb := pc.Background.Padding.GetBottom(DefaultBackgroundPadding.Bottom) dpb := dc.Background.Padding.GetBottom(DefaultBackgroundPadding.Bottom)
return Box{ return Box{
Top: pc.Background.Padding.GetTop(DefaultBackgroundPadding.Top), Top: dc.Background.Padding.GetTop(DefaultBackgroundPadding.Top),
Left: pc.Background.Padding.GetLeft(DefaultBackgroundPadding.Left), Left: dc.Background.Padding.GetLeft(DefaultBackgroundPadding.Left),
Right: pc.GetWidth() - dpr, Right: dc.GetWidth() - dpr,
Bottom: pc.GetHeight() - dpb, Bottom: dc.GetHeight() - dpb,
} }
} }