chart: github.com/vdobler/chart Index | Files | Directories

package chart

import "github.com/vdobler/chart"

Package chart implements common chart/plot types.

The following chart types are available:

StripChart       Visualize set of numeric values
ScatterChart     Plot (x,y) data (with optional error bars)
                 and/or functions
HistChart        Produce histograms from data
BarChart         Show (x,y) data as bars
BoxChart         Box charts to visualize distributions
PieChart         Pie and Ring charts

Chart tries to provides useful defaults and produce nice charts without sacrificing accuracy. The generated charts look good and are higly customizable but will not match the visual quality of handmade photoshop charts or the statistical features of charts produced by S or R.

Creating charts consists of the following steps:

1. Create chart object
2. Configure chart, axis, autoscaling etc.
3. Add one ore more data sets
4. Render chart to one or more graphic outputs

You may change the configuration at any step or render to different outputs.

The different chart types and their fields are all simple struct types where the zero value provides suitable defaults. All fields are exported, even if you are not supposed to manipulate them directy or are 'output fields'. E.g. the common Data field of all chart types will store the sample data added with one or more Add... methods. Some fields are mere output which expose internal stuff for your use like the Data2Screen and Screen2Data functions of the Ranges. Some fields are even input/output fields: E.g. you may set the Range.TicSetting.Delta to some positive value which will be used as the spacing between tics on that axis; on the other hand if you leave Range.TicSetting.Delta at its default 0 you indicate to the plotting routine to automatically determine the tic delta which is then reported back in this fields.

All charts (except pie/ring charts) contain at least one axis represented by a field of type Range. Axis can be differented into following categories:

o  Date/Time axis (Time=true): The values on this axis are interpreted as
   seconds since the Unix epoc, tics are labeld in date and time units.
   (The Log and Category fields are simply ignored for Date/Time axis.)

o  Real valued axis (Time=false).  Those come in different flavours:
     -  Simple linear real valued axis (Log=false, Category=nil).
     -  Logrithmic axis (Log=True).  Such an axis may cover only a
        range of ]0,inf[
     -  Categorical axis (Log=false, Category!=nil):
        The values 0, 1, 2, ... are labeled with the strings in Category.
        (You might want to set up the range manually, e.g. with the
        Fixed() method of Range)

How the axis is autoscaled can be controlled for both ends of the axis individually by MinMode and MaxMode which allow a fine control of the (auto-) scaling.

After setting up the chart, adding data, samples, functions you can render the chart to a Graphics output. This process will set several internal fields of the chart. If you reuse the chart, add additional data and output it again these fields might no longer indicate 'automatical/default' but contain the value calculated in the first output round.

Index

Package Files

bar.go box.go chart.go data.go doc.go graphics.go hist.go key.go pie.go scatter.go stat.go strip.go style.go time.go util.go

Variables

var (
    KeyHorSep      float32 = 1.5  // Horizontal spacing between key box and content
    KeyVertSep     float32 = 0.5  // Vertical spacing between key box and content
    KeyColSep      float32 = 2.0  // Horizontal spacing between two columns in key
    KeySymbolWidth float32 = 5    // Horizontal length/space reserved for symbol
    KeySymbolSep   float32 = 2    // Horizontal spacing bewteen symbol and text
    KeyRowSep      float32 = 0.75 // Vertical spacing between individual rows.
)

The following variables control the layout of the key/legend box. All values are in font-units (fontheight for vertical, fontwidth for horizontal values)

var CharacterWidth = map[int]float32{'a': 16.8, 'b': 17.0, 'c': 15.2, 'd': 16.8, 'e': 16.8, 'f': 8.5, 'g': 17.0,
    'h': 16.8, 'i': 5.9, 'j': 5.9, 'k': 16.8, 'l': 6.9, 'm': 25.5, 'n': 16.8, 'o': 16.8, 'p': 17.0, 'q': 17.0,
    'r': 10.2, 's': 15.2, 't': 8.4, 'u': 16.8, 'v': 15.4, 'w': 22.2, 'x': 15.2, 'y': 15.2, 'z': 15.2,
    'A': 20.2, 'B': 20.2, 'C': 22.2, 'D': 22.2, 'E': 20.2, 'F': 18.6, 'G': 23.5, 'H': 22.0, 'I': 8.2, 'J': 15.2,
    'K': 20.2, 'L': 16.8, 'M': 25.5, 'N': 22.0, 'O': 23.5, 'P': 20.2, 'Q': 23.5, 'R': 21.1, 'S': 20.2, 'T': 18.5,
    'U': 22.0, 'V': 20.2, 'W': 29.0, 'X': 20.2, 'Y': 20.2, 'Z': 18.8, ' ': 8.5,
    '1': 16.8, '2': 16.8, '3': 16.8, '4': 16.8, '5': 16.8, '6': 16.8, '7': 16.8, '8': 16.8, '9': 16.8, '0': 16.8,
    '.': 8.2, ',': 8.2, ':': 8.2, ';': 8.2, '+': 17.9, '"': 11.0, '*': 11.8, '%': 27.0, '&': 20.2, '/': 8.4,
    '(': 10.2, ')': 10.2, '=': 18.0, '?': 16.8, '!': 8.5, '[': 8.2, ']': 8.2, '{': 10.2, '}': 10.2, '$': 16.8,
    '<': 18.0, '>': 18.0, '§': 16.8, '°': 12.2, '^': 14.2, '~': 18.0,
}

CharacterWidth is a table of the (relative) width of common runes.

var DebugLogger *log.Logger = log.New(ioutil.Discard, "", 0)

DebugLogger is used to log some information about the chart generation.

var DefaultOptions = map[PlotElement]Style{
    MajorAxisElement: Style{LineColor: color.NRGBA{0, 0, 0, 0xff}, LineWidth: 2, LineStyle: SolidLine},
    MinorAxisElement: Style{LineColor: color.NRGBA{0, 0, 0, 0xff}, LineWidth: 2, LineStyle: SolidLine},
    MajorTicElement:  Style{LineColor: color.NRGBA{0, 0, 0, 0xff}, LineWidth: 1, LineStyle: SolidLine},
    MinorTicElement:  Style{LineColor: color.NRGBA{0, 0, 0, 0xff}, LineWidth: 1, LineStyle: SolidLine},
    ZeroAxisElement:  Style{LineColor: color.NRGBA{0x40, 0x40, 0x40, 0xff}, LineWidth: 1, LineStyle: SolidLine},
    GridLineElement:  Style{LineColor: color.NRGBA{0x80, 0x80, 0x80, 0xff}, LineWidth: 1, LineStyle: SolidLine},
    GridBlockElement: Style{LineColor: color.NRGBA{0xe6, 0xfc, 0xfc, 0xff}, LineWidth: 0, FillColor: color.NRGBA{0xe6, 0xfc, 0xfc, 0xff}},
    KeyElement: Style{LineColor: color.NRGBA{0x20, 0x20, 0x20, 0xff}, LineWidth: 1, LineStyle: SolidLine,
        FillColor: color.NRGBA{0xf0, 0xf0, 0xf0, 0xc0}, Font: Font{Size: SmallFontSize}},
    TitleElement: Style{LineColor: color.NRGBA{0, 0, 0, 0xff}, LineWidth: 1, LineStyle: SolidLine,
        FillColor: color.NRGBA{0xec, 0xc7, 0x50, 0xff}, Font: Font{Size: LargeFontSize}},
    RangeLimitElement: Style{Font: Font{Size: SmallFontSize}},
}

DefaultStyle maps chart elements to styles.

var Delta []TimeDelta = []TimeDelta{
    Second{1}, Second{5}, Second{15},
    Minute{1}, Minute{5}, Minute{15},
    Hour{1}, Hour{6},
    Day{1}, Week{1},
    Month{1}, Month{3}, Month{6},
    Year{1}, Year{10}, Year{100},
}

Delta is a list of increasing time deltas used to construct tic spacings for date/time axis. Must be sorted min to max according to Seconds() of each member.

var ExpandABitFraction = 0.5

ExpandABitFraction is the fraction of a major tic spacing added during axis range expansion with the ExpandABit mode.

var PieChartHighlight = 0.15 // How much are flaged segments offset.
var PieChartShrinkage = 0.66 // Scaling factor of radius of next data set.
var StandardColors = []color.Color{
    color.NRGBA{0xcc, 0x00, 0x00, 0xff},
    color.NRGBA{0x00, 0xbb, 0x00, 0xff},
    color.NRGBA{0x00, 0x00, 0xdd, 0xff},
    color.NRGBA{0x99, 0x66, 0x00, 0xff},
    color.NRGBA{0xbb, 0x00, 0xbb, 0xff},
    color.NRGBA{0x00, 0xaa, 0xaa, 0xff},
    color.NRGBA{0xbb, 0xbb, 0x00, 0xff},
}

Standard colors used by AutoStyle

var StandardFillFactor = 0.5

How much brighter/darker filled elements become.

var StandardLineStyles = []LineStyle{SolidLine, DashedLine, DottedLine, LongDashLine, LongDotLine}

Standard line styles used by AutoStyle (fill=false)

var StandardSymbols = []int{'o', '=', '%', '&', '+', 'X', '*', '@', '#', 'A', 'Z'}

Standard symbols used by AutoStyle

var Symbol = []int{
    'o',
    '=',
    '%',
    '&',
    '+',
    'X',
    '*',
    '0',
    '@',
    '#',
    'A',
    'W',
    'V',
    'Z',
    '.',
}

Symbol is the list of different symbols.

var Units = []string{" y", " z", " a", " f", " p", " n", " µ", "m", " k", " M", " G", " T", " P", " E", " Z", " Y"}

Units are the SI prefixes for 10^3n

func AbsoluteValue Uses

func AbsoluteValue(value, sum float64) (s string)

AbsoluteValue will format value (ignoring sum). It is a convenience function which can be assigned to the PieChart.FmtVal or PieChart.FmtKey field.

func FmtFloat Uses

func FmtFloat(f float64) string

FmtFloat yields a string representation of f. E.g. 12345.67 --> "12.3 k"; 0.09876 --> "99 m"

func FmtTime Uses

func FmtTime(sec int64, step TimeDelta) string

func GenericBars Uses

func GenericBars(bg BasicGraphics, bars []Barinfo, style Style)

GenericBars draws the bars in the given style using bg. TODO: Is Bars and Generic Bars useful at all? Replaceable by rect?

func GenericBoxes Uses

func GenericBoxes(bg BasicGraphics, boxes []Box, width int, style Style)

GenericBoxes draws box plots. (Default implementation for box plots). The values for each box in boxes are in screen coordinates!

func GenericCircle Uses

func GenericCircle(bg BasicGraphics, x, y, r int, style Style)

GenericCircle approximates a circle of radius r around (x,y) with lines.

func GenericKey Uses

func GenericKey(bg BasicGraphics, x, y int, key Key, options PlotOptions)

GenericKey draws the key onto bg at (x,y).

func GenericPath Uses

func GenericPath(mg MinimalGraphics, x, y []int, style Style)

GenericPath is the incomplete implementation of a list of points connected by straight lines. Incomplete: Dashed lines won't work properly.

func GenericRect Uses

func GenericRect(mg MinimalGraphics, x, y, w, h int, style Style)

GenericRect draws a rectangle of size w x h at (x,y). Drawing is done by simple lines only.

func GenericRings Uses

func GenericRings(bg BasicGraphics, wedges []Wedgeinfo, x, y, ro, ri int, eccentricity float64)

GeenricRings draws wedges for pie/ring charts charts. The pie's/ring's center is at (x,y) with ri and ro the inner and outer diameter. Eccentricity allows to correct for non-square pixels (e.g. in text mode).

func GenericScatter Uses

func GenericScatter(bg BasicGraphics, points []EPoint, plotstyle PlotStyle, style Style)

GenericScatter draws the given points according to style. style.FillColor is used as color of error bars and style.FontSize is used as the length of the endmarks of the error bars. Both have suitable defaults if the FontXyz are not set. Point coordinates and errors must be provided in screen coordinates.

func GenericSymbol Uses

func GenericSymbol(bg BasicGraphics, x, y int, style Style)

GenericSymbol draws the symbol defined by style at (x,y).

func GenericTextLen Uses

func GenericTextLen(mg MinimalGraphics, t string, font Font) (width int)

GenericTextLen tries to determine the width in pixel of t if rendered into mg in using font.

func GenericWedge Uses

func GenericWedge(mg MinimalGraphics, x, y, ro, ri int, phi, psi, ecc float64, style Style)

GenericWedge draws a pie/wedge just by lines

func GenericXAxis Uses

func GenericXAxis(bg BasicGraphics, rng Range, y, ym int, options PlotOptions)

GenericXAxis draws the x-axis with range rng solely by graphic primitives of bg. The x-axis is drawn at y on the screen and the mirrored x-axis is drawn at ym.

func GenericYAxis Uses

func GenericYAxis(bg BasicGraphics, rng Range, x, xm int, options PlotOptions)

GenericYAxis draws the y-axis with the range rng solely by graphic primitives of bg. The y.axis and the mirrord y-axis are drawn at x and ym respectively.

func IntegerValue Uses

func IntegerValue(value, sum float64) (s string)

IntegerValue will format value (ignoring sum) as an integer. It is a convenience function which can be assigned to the PieChart.FmtVal or PieChart.FmtKey field.

func NextSymbol Uses

func NextSymbol(s int) int

NextSymbol returns the next symbol of s: Either in the global list Symbol or (if not found there) the next character.

func PercentValue Uses

func PercentValue(value, sum float64) (s string)

PercentValue formats value as percentage of sum. It is a convenience function which can be assigned to the PieChart.FmtVal or PieChart.FmtKey field.

func PercentilInt Uses

func PercentilInt(data []int, p int) int

Return p percentil of pre-sorted integer data. 0 <= p <= 100.

func RoundDown Uses

func RoundDown(t time.Time, d TimeDelta) time.Time

RoundDown will round tp down to next "full" d.

func RoundNext Uses

func RoundNext(t time.Time, d TimeDelta) time.Time

RoundNext will round t to nearest full d.

func RoundUp Uses

func RoundUp(t time.Time, d TimeDelta) time.Time

RoundUp will round tp up to next "full" d.

func SanitizeRect Uses

func SanitizeRect(x, y, w, h, r int) (int, int, int, int)

SanitizeRect returns the top left corner and the positive width and height of the given (possibly unsanitized) rectangle taking into account the line width r.

func SixvalFloat64 Uses

func SixvalFloat64(data []float64, p int) (min, lq, med, avg, uq, max float64)

Compute minimum, p percentil, median, average, 100-p percentil and maximum of values in data.

func SixvalInt Uses

func SixvalInt(data []int, p int) (min, lq, med, avg, uq, max int)

Compute minimum, p percentil, median, average, 100-p percentil and maximum of values in data.

func SymbolIndex Uses

func SymbolIndex(s int) (idx int)

SymbolIndex returns the index of the symbol s in Symbol or -1 if not found.

type BarChart Uses

type BarChart struct {
    XRange, YRange Range
    Title          string      // Title of the chart
    Key            Key         // Key/Legend
    Horizontal     bool        // Display as horizontal bars (unimplemented)
    Stacked        bool        // Display different data sets ontop of each other (default is side by side)
    ShowVal        int         // Display values: 0: don't show; 1: above bar, 2: centerd in bar; 3: at top of bar
    SameBarWidth   bool        // all data sets use the same (smalest of all data sets) bar width
    BarWidthFac    float64     // if nonzero: scale determined bar width with this factor
    Options        PlotOptions // visual apperance, nil to use DefaultOptions
    Data           []BarChartData
}

BarChart draws simple bar charts. (Use CategoricalBarChart if your x axis is categorical, that is not numeric.)

Stacking is on a "both bars have _identical_ x values" basis.

func (*BarChart) AddData Uses

func (c *BarChart) AddData(name string, data []Point, style Style)

AddData adds the data to the chart.

func (*BarChart) AddDataPair Uses

func (c *BarChart) AddDataPair(name string, x, y []float64, style Style)

AddDataPair is a convenience method to add all the (x[i],y[i]) pairs to the chart.

func (*BarChart) Plot Uses

func (c *BarChart) Plot(g Graphics)

Plot renders the chart to the graphics output g.

func (*BarChart) Reset Uses

func (c *BarChart) Reset()

Reset chart to state before plotting.

type BarChartData Uses

type BarChartData struct {
    Name    string
    Style   Style
    Samples []Point
}

BarChartData encapsulates data sets in a bar chart.

type Barinfo Uses

type Barinfo struct {
    // contains filtered or unexported fields
}

Barinfo describes a rectangular bar (e.g. in a histogram or a bar plot).

type BasicGraphics Uses

type BasicGraphics interface {
    MinimalGraphics
    Symbol(x, y int, style Style)                          // Put symbol s at (x,y)
    Rect(x, y, w, h int, style Style)                      // Draw (w x h) rectangle at (x,y)
    Wedge(x, y, ro, ri int, phi, psi float64, style Style) // Wedge
    Path(x, y []int, style Style)                          // Path of straight lines
    Options() PlotOptions                                  // access to current PlotOptions
}

BasicGraphics is an interface of the most basic graphic primitives. Any type which implements BasicGraphics can use generic implementations of the Graphics methods.

type Box Uses

type Box struct {
    X           float64   // x-position of the box
    Avg         float64   // "average" value (uncommon in std. box plots, but sometimes useful)
    Q1, Med, Q3 float64   // lower quartil, median and upper quartil
    Low, High   float64   // low and hig end of whiskers (normaly last point in the 1.5*IQR range of Q1/3)
    Outliers    []float64 // list of y-values of outliers
}

Box represents a box in an boxplot.

func (Box) XErr Uses

func (p Box) XErr() float64

func (Box) XVal Uses

func (p Box) XVal() float64

func (Box) YErr Uses

func (p Box) YErr() float64

func (Box) YVal Uses

func (p Box) YVal() float64

type BoxChart Uses

type BoxChart struct {
    XRange, YRange Range  // x and y axis
    Title          string // Title of the chart
    Key            Key    // Key/legend
    Options        PlotOptions
    Data           []BoxChartData // the data sets to draw
}

BoxChart represents box charts.

To faciliate standard use of box plots, the method AddSet() exists which will calculate the various elents of a box (e.g. med, q3, outliers, ...) from raw data.

func (*BoxChart) AddData Uses

func (c *BoxChart) AddData(name string, data []Box, style Style)

AddData adds all boxes in data to the chart.

func (*BoxChart) AddSet Uses

func (c *BoxChart) AddSet(x float64, data []float64, outlier bool)

AddSet will add to last data set in the chart one new box calculated from data. If outlier is true, than outliers (1.5*IQR from 25/75 percentil) are drawn. If outlier is false, than the wiskers extend from min to max.

func (*BoxChart) NextDataSet Uses

func (c *BoxChart) NextDataSet(name string, style Style)

NextDataSet adds a new (empty) data set to chart. After adding the data set you can fill this last data set with AddSet()

func (*BoxChart) Plot Uses

func (c *BoxChart) Plot(g Graphics)

Plot renders the chart to the graphic output g.

func (*BoxChart) Reset Uses

func (c *BoxChart) Reset()

Reset chart to state before plotting.

type BoxChartData Uses

type BoxChartData struct {
    Name    string
    Style   Style
    Samples []Box
}

BoxChartData encapsulates a data set in a box chart

type CatValue Uses

type CatValue struct {
    Cat  string
    Val  float64
    Flag bool
}

CatValue is the standard implementation for CategoryValue.

func (CatValue) Category Uses

func (c CatValue) Category() string

func (CatValue) Flaged Uses

func (c CatValue) Flaged() bool

func (CatValue) Value Uses

func (c CatValue) Value() float64

type CategoryChartData Uses

type CategoryChartData struct {
    Name    string
    Style   []Style
    Samples []CatValue
}

type CategoryValue Uses

type CategoryValue interface {
    Category() string
    Value() float64
    Flaged() bool
}

CategoryValue is the interface for any type of data which is a category-real-pair.

type Chart Uses

type Chart interface {
    Plot(g Graphics) // Plot the chart to g.
    Reset()          // Reset any setting made during last plot.
}

Chart ist the very simple interface for all charts: They can be plotted to a graphics output.

type Day Uses

type Day struct{ Num int }

Day

func (Day) Format Uses

func (d Day) Format(t time.Time) string

func (Day) Period Uses

func (d Day) Period() bool

func (Day) RoundDown Uses

func (d Day) RoundDown(t time.Time) time.Time

func (Day) Seconds Uses

func (d Day) Seconds() int64

func (Day) String Uses

func (d Day) String() string

type EPoint Uses

type EPoint struct {
    X, Y           float64
    DeltaX, DeltaY float64 // Full range of x and y error, NaN for no errorbar.
    OffX, OffY     float64 // Offset of error range (must be < Delta)
}

EPoint represents a point in two dimensions (X,Y) with possible error ranges in both dimensions. To faciliate common symetric errors, OffX/Y defaults to 0 and only DeltaX/Y needs to be set up.

func (EPoint) BoundingBox Uses

func (p EPoint) BoundingBox() (xl, yl, xh, yh float64)

func (EPoint) XErr Uses

func (p EPoint) XErr() (float64, float64)

func (EPoint) XVal Uses

func (p EPoint) XVal() float64

func (EPoint) YErr Uses

func (p EPoint) YErr() (float64, float64)

func (EPoint) YVal Uses

func (p EPoint) YVal() float64

type Expansion Uses

type Expansion int

Expansion determines the way an axis range is expanded to align nicely with the tics on the axis.

const (
    ExpandNextTic Expansion = iota // Set min/max to next tic really below/above min/max of data.
    ExpandToTic                    // Set to next tic below/above or equal to min/max of data.
    ExpandTight                    // Use data min/max as limit.
    ExpandABit                     // Like ExpandToTic and add/subtract ExpandABitFraction of tic distance.
)

Suitable values for Expand in RangeMode.

type Font Uses

type Font struct {
    Name  string      // "": default
    Size  FontSize    // relative size of font to default in output graphics
    Color color.Color // "": default, other: use this
}

Font describes a font.

type FontSize Uses

type FontSize int

FontSize is the relative font size used in chart. Five sizes seem enough.

const (
    TinyFontSize FontSize = iota - 2
    SmallFontSize
    NormalFontSize
    LargeFontSize
    HugeFontSize
)

type Graphics Uses

type Graphics interface {
    BasicGraphics

    Dimensions() (int, int) // character-width / height

    Begin() // start of chart drawing
    End()   // Done, cleanup

    // All stuff is preprocessed: sanitized, clipped, strings formated, integer coords,
    // screen coordinates,
    XAxis(xr Range, ys, yms int, options PlotOptions) // Draw x axis xr at screen position ys (and yms if mirrored)
    YAxis(yr Range, xs, xms int, options PlotOptions) // Same for y axis.

    Scatter(points []EPoint, plotstyle PlotStyle, style Style) // Points, Lines and Line+Points
    Boxes(boxes []Box, width int, style Style)                 // Boxplots
    Bars(bars []Barinfo, style Style)                          // any type of histogram/bars
    Rings(wedeges []Wedgeinfo, x, y, ro, ri int)               // Pie/ring diagram elements

    Key(x, y int, key Key, options PlotOptions) // place key at x,y
}

Graphics is the interface all chart drivers have to implement

type GridMode Uses

type GridMode int

GridMode describes the way a grid on the major tics is drawn

const (
    GridOff    GridMode = iota // No grid lines
    GridLines                  // Grid lines
    GridBlocks                 // Zebra style background
)

type HistChart Uses

type HistChart struct {
    XRange, YRange Range       // Lower limit of YRange is fixed to 0 and not available for input
    Title          string      // Title of chart
    Key            Key         // Key/Legend
    Counts         bool        // Display counts instead of frequencies
    Stacked        bool        // Display different data sets ontop of each other
    Shifted        bool        // Shift non-stacked bars sideways (and make them smaler)
    FirstBin       float64     // center of the first (lowest bin)
    BinWidth       float64     // Width of bins (0: auto)
    TBinWidth      TimeDelta   // BinWidth for time XRange
    Gap            float64     // gap between bins in (bin-width units): 0<=Gap<1,
    Sep            float64     // separation of bars in one bin (in bar width units) -1<Sep<1
    Kernel         Kernel      // Smoothing kernel (usable only for non-stacked histograms)
    Options        PlotOptions // general stylistic optins
    Data           []HistChartData
}

HistChart represents histogram charts.

Histograms should not be mixed up with bar charts produced by BarChart: Histograms are computed (binified) automatically from the raw data.

func (*HistChart) AddData Uses

func (c *HistChart) AddData(name string, data []float64, style Style)

AddData will add data to the plot. Legend will be updated by name.

func (*HistChart) AddDataGeneric Uses

func (c *HistChart) AddDataGeneric(name string, data []Value, style Style)

AddDataGeneric is the generic version which allows the addition of any type implementing the Value interface.

func (*HistChart) AddDataInt Uses

func (c *HistChart) AddDataInt(name string, data []int, style Style)

AddDataInt is a convenience method to add integer data (a simple wrapper around AddData).

func (*HistChart) Plot Uses

func (c *HistChart) Plot(g Graphics)

Plot will output the chart to the graphic device g.

func (*HistChart) Reset Uses

func (c *HistChart) Reset()

Reset chart to state before plotting.

type HistChartData Uses

type HistChartData struct {
    Name    string
    Style   Style
    Samples []float64
}

HistChartData encapsulates one data set in a histogram chart.

type Hour Uses

type Hour struct{ Num int }

Hour

func (Hour) Format Uses

func (h Hour) Format(t time.Time) string

func (Hour) Period Uses

func (h Hour) Period() bool

func (Hour) RoundDown Uses

func (h Hour) RoundDown(t time.Time) time.Time

func (Hour) Seconds Uses

func (h Hour) Seconds() int64

func (Hour) String Uses

func (h Hour) String() string

type Kernel Uses

type Kernel func(x float64) float64

Kernel is a smoothing kernel for histograms.

var (
    // 1/2
    RectangularKernel = func(x float64) float64 {
        if x >= -1 && x < 1 {
            return 0.5
        }
        return 0
    }

    // 1 - |x|
    TriangularKernel = func(x float64) float64 {
        if x >= -1 && x < 1 {
            return 1 - math.Abs(x)
        }
        return 0
    }

    // 15/16 * (1-x^2)^2
    BisquareKernel Kernel = func(x float64) float64 {
        if x >= -1 && x < 1 {
            a := (1 - x*x)
            return 15.0 / 16.0 * a * a
        }
        return 0
    }

    // 35/32 * (1-x^2)^3
    TriweightKernel Kernel = func(x float64) float64 {
        if x >= -1 && x < 1 {
            a := (1 - x*x)
            return 35.0 / 32.0 * a * a * a
        }
        return 0
    }

    // 3/4 * (1-x^2)
    EpanechnikovKernel Kernel = func(x float64) float64 {
        if x >= -1 && x < 1 {
            return 3.0 / 4.0 * (1.0 - x*x)
        }
        return 0
    }

    // 1/sqrt(2pi) * exp(-1/2x^2)
    GaussKernel Kernel = func(x float64) float64 {
        return sqrt2piinv * math.Exp(-0.5*x*x)
    }
)

Some common smoothing kernels. All are identical 0 outside [-1,1[.

type Key Uses

type Key struct {
    Hide    bool       // Don't show key/legend if true
    Cols    int        // Number of colums to use. If <0 fill rows before colums
    Border  int        // -1: off, 0: std, 1...:other styles
    Pos     string     // default "" is "itr"
    Entries []KeyEntry // List of entries in the legend
    X, Y    int
}

Key encapsulates settings for keys/legends in a chart.

Key placement is governed by Pos which may take the following values:

     otl  otc  otr
    +-------------+          o: outside
olt |itl  itc  itr| ort      i: inside
    |             |          t: top
olc |icl  icc  icr| orc      c: centered
    |             |          b: bottom
olb |ibl  ibc  ibr| orb      l: left
    +-------------+          c: centered
     obl  obc  obr           r: right

func (Key) Layout Uses

func (key Key) Layout(bg BasicGraphics, m [][]*KeyEntry, font Font) (w, h int, colwidth, rowheight []int)

Layout determines how wide and broad the places keys in m will be rendered.

func (Key) Place Uses

func (key Key) Place() (matrix [][]*KeyEntry)

Place layouts the Entries in key in the requested (by key.Cols) matrix format

type KeyEntry Uses

type KeyEntry struct {
    Text      string    // Text to display
    PlotStyle PlotStyle // What to show: symbol, line, bar or combination thereof
    Style     Style     // How to show

}

KeyEntry encapsulates an antry in the key/legend.

type LayoutData Uses

type LayoutData struct {
    Width, Height      int // width and height of graph area
    Left, Top          int // left and top margin
    KeyX, KeyY         int // x and y coordiante of key
    NumXtics, NumYtics int // suggested numer of tics for both axis
}

LayoutData encapsulates the layout of the graph area in the whole drawing area.

type LineStyle Uses

type LineStyle int

LineStyle describes the different types of lines.

const (
    SolidLine      LineStyle = iota //  ----------------------
    DashedLine                      //  ----  ----  ----  ----
    DottedLine                      //  - - - - - - - - - - -
    DashDotDotLine                  //  ----  -  -  ----  -  -
    LongDashLine                    //
    LongDotLine
)

The supported line styles.

type MinimalGraphics Uses

type MinimalGraphics interface {
    Background() (r, g, b, a uint8)                         // Color of background
    FontMetrics(font Font) (fw float32, fh int, mono bool)  // Return fontwidth and -height in pixel
    TextLen(t string, font Font) int                        // Length=width of t in screen units if set on font
    Line(x0, y0, x1, y1 int, style Style)                   // Draw line from (x0,y0) to (x1,y1)
    Text(x, y int, t string, align string, rot int, f Font) // Put t at (x,y) rotated by rot aligned [[tcb]][lcr]
}

MinimalGraphics is the interface any graphics driver must implement, so that he can fall back to the generic routines for the higher level outputs.

type Minute Uses

type Minute struct {
    Num int
}

Minute

func (Minute) Format Uses

func (m Minute) Format(t time.Time) string

func (Minute) Period Uses

func (m Minute) Period() bool

func (Minute) RoundDown Uses

func (m Minute) RoundDown(t time.Time) time.Time

func (Minute) Seconds Uses

func (m Minute) Seconds() int64

func (Minute) String Uses

func (m Minute) String() string

type MirrorAxis Uses

type MirrorAxis int

MirrorAxis describes if and how an axis is drawn on the oposite side of a chart,

const (
    MirrorAxisAndTics MirrorAxis = 0  // draw a full mirrored axis including tics
    MirrorNothing     MirrorAxis = -1 // do not draw a mirrored axis
    MirrorAxisOnly    MirrorAxis = 1  // just draw a mirrord axis, but omit tics
)

type Month Uses

type Month struct {
    Num int
}

Month

func (Month) Format Uses

func (m Month) Format(t time.Time) string

func (Month) Period Uses

func (m Month) Period() bool

func (Month) RoundDown Uses

func (m Month) RoundDown(t time.Time) time.Time

func (Month) Seconds Uses

func (m Month) Seconds() int64

func (Month) String Uses

func (m Month) String() string

type PieChart Uses

type PieChart struct {
    Title   string  // The title
    Key     Key     // The Key/Legend
    Inner   float64 // relative radius of inner white are (set to 0.7 to produce ring chart)
    Options PlotOptions
    Data    []CategoryChartData // The data

    FmtVal func(value, sume float64) string // add value labels to pie segments
    FmtKey func(value, sume float64) string // add value labels to key entries
}

PieChart represents pie and ring charts. Data is exported but it you should use the AddData, AddDataPair and AddIntDataPair methods to populate this field. The FmtVal and FmtKey function are used to format optional labels on the pie segments (FmtVal) and on the legend/key entries if non nil. The FmtKey must be set before adding data via the AddXY methods.

func (*PieChart) AddData Uses

func (c *PieChart) AddData(name string, data []CatValue, style []Style)

func (*PieChart) AddDataPair Uses

func (c *PieChart) AddDataPair(name string, cat []string, val []float64)

func (*PieChart) AddIntDataPair Uses

func (c *PieChart) AddIntDataPair(name string, cat []string, val []int)

func (*PieChart) Plot Uses

func (c *PieChart) Plot(g Graphics)

Plot outputs the scatter chart sc to g.

func (*PieChart) Reset Uses

func (c *PieChart) Reset()

Reset chart to state before plotting.

type PlotElement Uses

type PlotElement int

PlotElement identifies one element in a plot/chart

const (
    MajorAxisElement PlotElement = iota
    MinorAxisElement
    MajorTicElement
    MinorTicElement
    ZeroAxisElement
    GridLineElement
    GridBlockElement
    KeyElement
    TitleElement
    RangeLimitElement
)

type PlotOptions Uses

type PlotOptions map[PlotElement]Style

PlotOptions contains a Style for each PlotElement. If a PlotOption does not contain a certainPlotElement the value in DefaultStyle is used.

type PlotStyle Uses

type PlotStyle int

PlotStyle describes how data and functions are drawn in scatter plots. Can be used to describe how a key entry is drawn

const (
    PlotStylePoints      PlotStyle = iota + 1 // draw symbol at data point
    PlotStyleLines                            // connect data points by straight lines
    PlotStyleLinesPoints                      // symbols and lines
    PlotStyleBox                              // produce boxplot
)

type Point Uses

type Point struct{ X, Y float64 }

Point is a point in two dimensions (x,y) implementing XYValue.

func (Point) XErr Uses

func (p Point) XErr() (float64, float64)

func (Point) XVal Uses

func (p Point) XVal() float64

func (Point) YErr Uses

func (p Point) YErr() (float64, float64)

func (Point) YVal Uses

func (p Point) YVal() float64

type Range Uses

type Range struct {
    Label            string     // Label of axis
    Log              bool       // Logarithmic axis?
    Time             bool       // Date/Time axis?
    MinMode, MaxMode RangeMode  // How to handel min and max of this axis/range
    TicSetting       TicSetting // How to handle tics.
    DataMin, DataMax float64    // Actual min/max values from data. If both zero: not calculated
    ShowLimits       bool       // Display axis Min and Max values on plot
    ShowZero         bool       // Add line to show 0 of this axis
    Category         []string   // If not empty (and neither Log nor Time): Use Category[n] as tic label at pos n+1.

    // The following values are set up during plotting
    Min, Max   float64   // Actual minium and maximum of this axis/range.
    TMin, TMax time.Time // Same as Min/Max, but used for Date/Time axis
    Tics       []Tic     // List of tics to display

    // The following functions are set up during plotting
    Norm        func(float64) float64 // Function to map [Min:Max] to [0:1]
    InvNorm     func(float64) float64 // Inverse of Norm()
    Data2Screen func(float64) int     // Function to map data value to screen position
    Screen2Data func(int) float64     // Inverse of Data2Screen
}

Range encapsulates all information about an axis.

func (*Range) Fixed Uses

func (r *Range) Fixed(min, max, delta float64)

Fixed is a helper (just reduces typing) functions which turns of autoscaling and sets the axis range to [min,max] and the tic distance to delta.

func (*Range) Init Uses

func (r *Range) Init()

func (*Range) Reset Uses

func (r *Range) Reset()

Reset the fields in r which have been set up during a plot.

func (*Range) Setup Uses

func (r *Range) Setup(desiredNumberOfTics, maxNumberOfTics, sWidth, sOffset int, revert bool)

Setup several fields of the Range r according to RangeModes and TicSettings. DataMin and DataMax of r must be present and should indicate lowest and highest value present in the data set. The following fields of r are filled:

(T)Min and (T)Max    lower and upper limit of axis, (T)-version for date/time axis
Tics                 slice of tics to draw
TicSetting.(T)Delta  actual tic delta
Norm and InvNorm     mapping of [lower,upper]_data --> [0:1] and inverse
Data2Screen          mapping of data to screen coordinates
Screen2Data          inverse of Data2Screen

The parameters desiredNumberOfTics and maxNumberOfTics are what the say. sWidth and sOffset are screen-width and -offset and are used to set up the Data-Screen conversion functions. If revert is true, than screen coordinates are assumed to be the other way around than mathematical coordinates.

TODO(vodo) seperate screen stuff into own method.

func (*Range) TFixed Uses

func (r *Range) TFixed(min, max time.Time, delta TimeDelta)

TFixed is the date/time version of Fixed.

type RangeMode Uses

type RangeMode struct {
    Fixed          bool      // If false: autoscaling. If true: use (T)Value/TValue as fixed setting
    Constrained    bool      // If false: full autoscaling. If true: use (T)Lower (T)Upper as limits
    Expand         Expansion // One of ExpandNextTic, ExpandTight, ExpandABit
    Value          float64   // Value of end point of axis in Fixed=true mode, ignorder otherwise
    TValue         time.Time // Same as Value, but used for Date/Time axis
    Lower, Upper   float64   // Lower and upper limit for constrained autoscaling
    TLower, TUpper time.Time // Same s Lower/Upper, but used for Date/Time axis
}

RangeMode describes how one end of an axis is set up. There are basically three different main modes:

* Fixed: Fixed==true.
  Use Value/TValue as fixed value this ignoring the actual data range.
* Unconstrained autoscaling: Fixed==false && Constrained==false.
  Set range to whatever data requires.
* Constrained autoscaling: Fixed==false && Constrained==true.
  Scale axis according to data present, but limit scaling to intervall [Lower,Upper]

For both autoscaling modes Expand defines how much expansion is done below/above the lowest/highest data point.

type Real Uses

type Real float64

Real is a float64 implementing the Value interface.

func (Real) XVal Uses

func (r Real) XVal() float64

type ScatterChart Uses

type ScatterChart struct {
    XRange, YRange Range  // X and Y axis
    Title          string // Title of the chart
    Key            Key    // Key/Legend
    Options        PlotOptions
    Data           []ScatterChartData // The actual data (filled with Add...-methods)
    NSamples       int                // number of samples for function plots
}

ScatterChart represents scatter charts, line charts and function plots.

func (*ScatterChart) AddData Uses

func (c *ScatterChart) AddData(name string, data []EPoint, plotstyle PlotStyle, style Style)

AddData adds points in data to chart. A key/legend entry is produced if name is not empty.

func (*ScatterChart) AddDataGeneric Uses

func (c *ScatterChart) AddDataGeneric(name string, data []XYErrValue, plotstyle PlotStyle, style Style)

AddDataGeneric is the generiv version of AddData which allows any type to be plotted that implements the XYErrValue interface.

func (*ScatterChart) AddDataPair Uses

func (c *ScatterChart) AddDataPair(name string, x, y []float64, plotstyle PlotStyle, style Style)

AddDataPair is a convenience method which wrapps around AddData: It adds the points (x[n],y[n]) to the chart.

func (*ScatterChart) AddFunc Uses

func (c *ScatterChart) AddFunc(name string, f func(float64) float64, plotstyle PlotStyle, style Style)

AddFunc adds a function f to this chart. A key/legend entry is produced if name is not empty.

func (*ScatterChart) Plot Uses

func (c *ScatterChart) Plot(g Graphics)

Plot outputs the scatter chart to the graphic output g.

func (*ScatterChart) Reset Uses

func (c *ScatterChart) Reset()

Reset chart to state before plotting.

type ScatterChartData Uses

type ScatterChartData struct {
    Name      string                // The name of this data set. TODO: unused?
    PlotStyle PlotStyle             // Points, Lines+Points or Lines only
    Style     Style                 // Color, sizes, pointtype, linestyle, ...
    Samples   []EPoint              // The actual points for scatter/lines charts
    Func      func(float64) float64 // The function to draw.
}

ScatterChartData encapsulates a data set or function in a scatter chart. Not both Samples and Func may be non nil at the same time.

type Second Uses

type Second struct {
    Num int
}

Second

func (Second) Format Uses

func (s Second) Format(t time.Time) string

func (Second) Period Uses

func (s Second) Period() bool

func (Second) RoundDown Uses

func (s Second) RoundDown(t time.Time) time.Time

func (Second) Seconds Uses

func (s Second) Seconds() int64

func (Second) String Uses

func (s Second) String() string

type StripChart Uses

type StripChart struct {
    Jitter       bool // Add jitter to help distinguish overlapping values
    ScatterChart      // The embeded ScatterChart is responsible for all drawing
}

StripChart represents very simple strip charts.

func (*StripChart) AddData Uses

func (sc *StripChart) AddData(name string, data []float64, style Style)

AddData adds data to the strip chart.

func (*StripChart) AddDataGeneric Uses

func (sc *StripChart) AddDataGeneric(name string, data []Value)

func (*StripChart) Plot Uses

func (sc *StripChart) Plot(g Graphics)

Plot outputs the strip chart sc to g.

func (*StripChart) Reset Uses

func (sc *StripChart) Reset()

Reset chart to state before plotting.

type Style Uses

type Style struct {
    Symbol      int         // 0: no symbol; any codepoint: this symbol
    SymbolColor color.Color // color of symbol
    SymbolSize  float64     // scaling factor of symbol
    LineStyle   LineStyle   // SolidLine, DashedLine, DottedLine, .... see below
    LineColor   color.Color // color of line
    LineWidth   int         // 0: no line,  >=1 width of line in pixel
    Font        Font        // the font to use
    FillColor   color.Color
}

Style contains all information about all graphic elements in a chart. All colors are in the form "#rrggbb" with rr/gg/bb hexvalues. Not all elements of a plot use all fields in this struct.

func AutoStyle Uses

func AutoStyle(i int, fill bool) (style Style)

AutoStyle produces a styles based on StandardColors, StandardLineStyles, and StandardSymbols. Call with fill = true for charts with filled elements (hist, bar, cbar, pie).

func ElementStyle Uses

func ElementStyle(options PlotOptions, element PlotElement) Style

type Tic Uses

type Tic struct {
    Pos      float64 // position of the tic on the axis (in data coordinates).
    LabelPos float64 // position of the label on the axis (in data coordinates).
    Label    string  // the Label of the tic
    Align    int     // alignment of the label:  -1: left/top,  0 center,  1 right/bottom (unused)
}

Tic describs a single tic on an axis.

type TicSetting Uses

type TicSetting struct {
    Hide       bool       // dont show tics if true
    HideLabels bool       // don't show tic labels if true
    Tics       int        // 0: across axis,  1: inside,  2: outside,  other: off
    Minor      int        // 0: off,  1: auto,  >1: number of intervalls (not number of tics!)
    Delta      float64    // wanted step between major tics.  0 means auto
    TDelta     TimeDelta  // same as Delta, but used for Date/Time axis
    Grid       GridMode   // GridOff, GridLines, GridBlocks
    Mirror     MirrorAxis // 0: mirror axis and tics, -1: don't mirror anything, 1: mirror axis only (no tics)

    // Format is used to print the tic labels. If unset FmtFloat is used.
    Format func(float64) string

    // TFormat is used to print tic labels for date/time axis.
    TFormat func(time.Time, TimeDelta) string

    // TLocation allows to fix the timezone in which date/time axis tic labels
    // are printed.
    TLocation *time.Location

    UserDelta bool // true if Delta or TDelta was input
}

TicSetting describes how (if at all) tics are shown on an axis.

type TimeDelta Uses

type TimeDelta interface {
    Seconds() int64                  // amount of delta in seconds
    RoundDown(t time.Time) time.Time // Round dow t to "whole" delta
    String() string                  // retrieve string representation
    Format(t time.Time) string       // format t properly
    Period() bool                    // true if this delta is a time period (like a month)
}

Represents a tic-distance in a timed axis

func MatchingTimeDelta Uses

func MatchingTimeDelta(delta float64, fac float64) TimeDelta

func NextTimeDelta Uses

func NextTimeDelta(d TimeDelta) TimeDelta

type Value Uses

type Value interface {
    XVal() float64
}

Value is the interface for any type of data representable by a real. Its standard implementation here is Real (float64).

type Wedgeinfo Uses

type Wedgeinfo struct {
    Phi, Psi float64 // Start and ende of wedge. Fuill circle if |phi-psi| > 4pi
    Text, Tp string  // label text and text position: [ico]
    Style    Style   // style of this wedge
    Font     Font    // font of text
    Shift    int     // Highlighting of wedge
}

Wedgeinfo describes a wedge in a pie chart.

type Week Uses

type Week struct {
    Num int
}

Week

func (Week) Format Uses

func (w Week) Format(t time.Time) string

func (Week) Period Uses

func (w Week) Period() bool

func (Week) RoundDown Uses

func (w Week) RoundDown(t time.Time) time.Time

func (Week) Seconds Uses

func (w Week) Seconds() int64

func (Week) String Uses

func (w Week) String() string

type XYErrValue Uses

type XYErrValue interface {
    XVal() float64
    YVal() float64
    XErr() (float64, float64) // X-range [min,max], error intervall. Use NaN to indicate "no error".
    YErr() (float64, float64) // Y-range error interval (like XErr).
}

XYErrValue is the interface for any type of data which is point-like (x,y) and has some measurement error.

type XYValue Uses

type XYValue interface {
    XVal() float64
    YVal() float64
}

XYValue is the interface for any type of data which is point-like and has a x- and y-coordinate. Its standard implementation here is Point.

type Year Uses

type Year struct {
    Num int
}

Year

func (Year) Format Uses

func (y Year) Format(t time.Time) string

func (Year) Period Uses

func (y Year) Period() bool

func (Year) RoundDown Uses

func (y Year) RoundDown(t time.Time) time.Time

func (Year) Seconds Uses

func (y Year) Seconds() int64

func (Year) String Uses

func (y Year) String() string

Directories

PathSynopsis
example
imgg
svgg
txtg

Package chart imports 9 packages (graph) and is imported by 88 packages. Updated 2019-07-25. Refresh now. Tools for package owners.