// AddLinePoints adds Line and Scatter plotters to a // plot. The variadic arguments must be either strings // or plotter.XYers. Each plotter.XYer is added to // the plot using the next color, dashes, and glyph // shape via the Color, Dashes, and Shape functions. // If a plotter.XYer is immediately preceeded by // a string then a legend entry is added to the plot // using the string as the name. func AddLinePoints(plt *plot.Plot, vs ...interface{}) { name := "" var i int for _, v := range vs { switch t := v.(type) { case string: name = t case plotter.XYer: l, s := plotter.NewLinePoints(t) l.Color = Color(i) l.Dashes = Dashes(i) s.Color = Color(i) s.Shape = Shape(i) i++ plt.Add(l, s) if name != "" { plt.Legend.Add(name, l, s) name = "" } default: panic(fmt.Sprintf("AddLinePoints handles strings and plotter.XYers, got %T", t)) } } }
func linesPlot() *plot.Plot { // Get some random points rand.Seed(int64(0)) n := 10 scatterData := randomPoints(n) lineData := randomPoints(n) linePointsData := randomPoints(n) // Create a new plot, set its title and // axis labels. p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Points Example" p.X.Label.Text = "X" p.Y.Label.Text = "Y" // Draw a grid behind the data p.Add(plotter.NewGrid()) // Make a scatter plotter and set its style. s, err := plotter.NewScatter(scatterData) if err != nil { panic(err) } s.GlyphStyle.Color = color.RGBA{R: 255, B: 128, A: 255} // Make a line plotter and set its style. l, err := plotter.NewLine(lineData) if err != nil { panic(err) } l.LineStyle.Width = vg.Points(1) l.LineStyle.Dashes = []vg.Length{vg.Points(5), vg.Points(5)} l.LineStyle.Color = color.RGBA{B: 255, A: 255} // Make a line plotter with points and set its style. lpLine, lpPoints, err := plotter.NewLinePoints(linePointsData) if err != nil { panic(err) } lpLine.Color = color.RGBA{G: 255, A: 255} lpPoints.Shape = plot.PyramidGlyph{} lpPoints.Color = color.RGBA{R: 255, A: 255} // Add the plotters to the plot, with a legend // entry for each p.Add(s, l, lpLine, lpPoints) p.Legend.Add("scatter", s) p.Legend.Add("line", l) p.Legend.Add("line points", lpLine, lpPoints) return p }
// Example_points draws some scatter points, a line, // and a line with points. func Example_points() *plot.Plot { rand.Seed(int64(0)) n := 15 scatterData := randomPoints(n) lineData := randomPoints(n) linePointsData := randomPoints(n) p, err := plot.New() if err != nil { panic(err) } p.Title.Text = "Points Example" p.X.Label.Text = "X" p.Y.Label.Text = "Y" p.Add(plotter.NewGrid()) s := must(plotter.NewScatter(scatterData)).(*plotter.Scatter) s.GlyphStyle.Color = color.RGBA{R: 255, B: 128, A: 255} s.GlyphStyle.Radius = vg.Points(3) l := must(plotter.NewLine(lineData)).(*plotter.Line) l.LineStyle.Width = vg.Points(1) l.LineStyle.Dashes = []vg.Length{vg.Points(5), vg.Points(5)} l.LineStyle.Color = color.RGBA{B: 255, A: 255} lpLine, lpPoints, err := plotter.NewLinePoints(linePointsData) if err != nil { panic(err) } lpLine.Color = color.RGBA{G: 255, A: 255} lpPoints.Shape = plot.CircleGlyph{} lpPoints.Color = color.RGBA{R: 255, A: 255} p.Add(s, l, lpLine, lpPoints) p.Legend.Add("scatter", s) p.Legend.Add("line", l) p.Legend.Add("line points", lpLine, lpPoints) return p }
// AddLinePoints adds Line and Scatter plotters to a // plot. The variadic arguments must be either strings // or plotter.XYers. Each plotter.XYer is added to // the plot using the next color, dashes, and glyph // shape via the Color, Dashes, and Shape functions. // If a plotter.XYer is immediately preceeded by // a string then a legend entry is added to the plot // using the string as the name. // // If an error occurs then none of the plotters are added // to the plot, and the error is returned. func AddLinePoints(plt *plot.Plot, vs ...interface{}) error { var ps []plot.Plotter names := make(map[[2]plot.Thumbnailer]string) name := "" var i int for _, v := range vs { switch t := v.(type) { case string: name = t case plotter.XYer: l, s, err := plotter.NewLinePoints(t) if err != nil { return err } l.Color = Color(i) l.Dashes = Dashes(i) s.Color = Color(i) s.Shape = Shape(i) i++ ps = append(ps, l, s) if name != "" { names[[2]plot.Thumbnailer{l, s}] = name name = "" } default: panic(fmt.Sprintf("AddLinePoints handles strings and plotter.XYers, got %T", t)) } } plt.Add(ps...) for ps, n := range names { plt.Legend.Add(n, ps[0], ps[1]) } return nil }
func main() { fmt.Println("Running...") start := time.Now() y1 := make([]float64, 0) y2 := make([]float64, 0) file, errF := os.Open(fileName) if errF != nil { fmt.Println("Error:", errF) return } reader := csv.NewReader(file) reader.TrimLeadingSpace = true for { record, err := reader.Read() if err == io.EOF { break } else if err != nil { fmt.Println("Error:", err) return } ft1, err1 := strconv.ParseFloat(record[1], 64) ft2, err2 := strconv.ParseFloat(record[2], 64) if err1 != nil { fmt.Println("Error:", err1) } if err2 != nil { fmt.Println("Error:", err2) } y1 = append(y1, ft1) y2 = append(y2, ft2) //fmt.Println(record[1],record[2]) //fmt.Println(err1,err2) } var pt plotter.XYs pt = make(plotter.XYs, len(y1)) for i := range pt { pt[i].X = y1[i] pt[i].Y = y2[i] } p, err := plot.New() if err != nil { panic(err) } p.Title.Text = fmt.Sprintf("Van Der Pol Oscillator") p.Y.Label.Text = "y2(t)" p.X.Label.Text = "y1(t)" /* p.X.Min = 0 p.X.Max = 4.5 p.Y.Min = 0 p.Y.Max = 4.5 */ lpLine, lpPoints := plotter.NewLinePoints(pt) lpLine.LineStyle.Width = vg.Points(0) lpLine.Color = color.RGBA{G: 255, A: 255} lpPoints.Shape = plot.CircleGlyph{} lpPoints.Color = color.RGBA{R: 255, A: 255} lpPoints.GlyphStyle.Radius = vg.Points(2.0) p.Add(lpPoints) //plotutil.AddLinePoints(p,pt) //plotutil.AddLinePoints(p,pt) // Save the plot to a PNG file. if err := p.Save(6, 6, "ploth1.png"); err != nil { panic(err) } fmt.Println(time.Since(start)) file.Close() fmt.Println("...program terminated successfully!") }
// Creates a plotinum plot from the input set of points and plot labels // and saves to a file. // The plot parameters are supplied as a map of strings. The following fields are // valid: // Title - plot title (and filename) // XLabel - x axis label (default X) // YLabel - y axis label (Y) // XMin - lower bound of x axis // XMax - upper bound of x axis // YMin - lower bound of y axis // YMax - upper bound of y axis // xsize - width of the plot (in inches) (default 6 in) // ysize - height of the plot (in inches) (default 6 in) // fixaspectratio - provides fixed aspect ratio by scaling x axis (default false) func CreatePlot(pts []plotter.XYs, label []string, params map[string]string) { colors := make([]color.RGBA, 5) colors[0] = color.RGBA{R: 255, G: 0, B: 0, A: 255} colors[1] = color.RGBA{R: 0, G: 255, B: 0, A: 255} colors[2] = color.RGBA{R: 0, G: 0, B: 255, A: 255} colors[3] = color.RGBA{R: 255, G: 0, B: 255, A: 255} colors[4] = color.RGBA{R: 255, G: 255, B: 0, A: 255} p, err := plot.New() if err != nil { panic(err) } var title string if val, ok := params["Title"]; ok { title = val } p.Title.Text = title if val, ok := params["XLabel"]; ok { p.X.Label.Text = val } else { p.X.Label.Text = "X" } if val, ok := params["YLabel"]; ok { p.Y.Label.Text = val } else { p.Y.Label.Text = "Y" } if val, ok := params["XMin"]; ok { if fval, err := strconv.ParseFloat(val, 64); err == nil { p.X.Min = fval } } if val, ok := params["XMax"]; ok { if fval, err := strconv.ParseFloat(val, 64); err == nil { p.X.Max = fval } } if val, ok := params["YMin"]; ok { if fval, err := strconv.ParseFloat(val, 64); err == nil { p.Y.Min = fval } } if val, ok := params["YMax"]; ok { if fval, err := strconv.ParseFloat(val, 64); err == nil { p.Y.Max = fval } } var xsize float64 = 6.0 if val, ok := params["XSize"]; ok { if fval, err := strconv.ParseFloat(val, 64); err == nil { xsize = fval } } var ysize float64 = 6.0 if val, ok := params["YSize"]; ok { if fval, err := strconv.ParseFloat(val, 64); err == nil { ysize = fval } } var fixaspectratio bool = false if val, ok := params["FixAspectRatio"]; ok { if bval, err := strconv.ParseBool(val); err == nil { fixaspectratio = bval } } p.Add(plotter.NewGrid()) for j := 0; j < len(pts); j++ { ll, lp := plotter.NewLinePoints(pts[j]) ll.Color = colors[j%5] lp.Color = colors[j%5] p.Add(ll, lp) p.Legend.Add(label[j], ll, lp) } if fixaspectratio { if r, err := aspectRatio(p); err == nil { xsize = ysize * r } } // Save the plot to a PNG file. filename := title + ".png" if err := p.Save(xsize, ysize, filename); err != nil { panic(err) } }
func VisualizeSignificantEvents(events SignificantEvents, filename string, options SignificantEventsOptions) { firstTime := events.FirstTime() tr := func(t time.Time) float64 { return t.Sub(firstTime).Seconds() } minX := 0.0 if options.MinX != 0 { minX = options.MinX } if !options.MinT.IsZero() { minX = tr(options.MinT) } maxX := 0.0 maxY := 0.0 minY := math.MaxFloat64 scatters := map[string][]plot.Plotter{} verticalLines := []plot.Plotter{} lineOverlays := []plot.Plotter{} colorCounter := 0 for _, name := range events.OrderedNames() { xys := plotter.XYs{} xErrs := plotter.XErrors{} for _, event := range events[name] { if event.V > 0 { xys = append(xys, struct{ X, Y float64 }{tr(event.T), event.V}) xErrs = append(xErrs, struct{ Low, High float64 }{-event.V / 2, event.V / 2}) if tr(event.T) > maxX { maxX = tr(event.T) } if event.V > maxY { maxY = event.V } if event.V < minY { minY = event.V } } } if len(xys) == 0 { say.Println(0, "No data for %s", name) continue } if options.MarkedEvents != nil { ls, ok := options.MarkedEvents[name] if ok { for _, event := range events[name] { l := viz.NewVerticalLine(tr(event.T)) l.LineStyle = ls verticalLines = append(verticalLines, l) } } } s, err := plotter.NewScatter(xys) say.ExitIfError("Couldn't create scatter plot", err) s.GlyphStyle = plot.GlyphStyle{ Color: viz.OrderedColor(colorCounter), Radius: 2, Shape: plot.CircleGlyph{}, } xErrsPlot, err := plotter.NewXErrorBars(struct { plotter.XYer plotter.XErrorer }{xys, xErrs}) say.ExitIfError("Couldn't create x errors plot", err) xErrsPlot.LineStyle = viz.LineStyle(viz.OrderedColor(colorCounter), 1) scatters[name] = []plot.Plotter{s, xErrsPlot} colorCounter++ } for _, marker := range options.VerticalMarkers { l := viz.NewVerticalLine(tr(marker.T)) l.LineStyle = marker.LineStyle verticalLines = append(verticalLines, l) } for _, lineOverlay := range options.LineOverlays { xys := plotter.XYs{} for _, event := range lineOverlay.Events { if event.V > 0 { xys = append(xys, struct{ X, Y float64 }{tr(event.T), event.V}) } } l, s, err := plotter.NewLinePoints(xys) say.ExitIfError("Couldn't create scatter plot", err) l.LineStyle = lineOverlay.LineStyle s.GlyphStyle = plot.GlyphStyle{ Color: lineOverlay.LineStyle.Color, Radius: lineOverlay.LineStyle.Width, Shape: plot.CrossGlyph{}, } lineOverlays = append(lineOverlays, l, s) } if options.MaxX != 0 { maxX = options.MaxX } if !options.MaxT.IsZero() { maxX = tr(options.MaxT) } maxY = math.Pow(10, math.Ceil(math.Log10(maxY))) if options.MaxY != 0 { maxY = options.MaxY } minY = math.Pow(10, math.Floor(math.Log10(minY))) n := len(scatters) + 1 b := viz.NewUniformBoard(1, n, 0.01) allScatterPlot, _ := plot.New() allScatterPlot.Title.Text = "All Events" allScatterPlot.X.Label.Text = "Time (s)" allScatterPlot.Y.Label.Text = "Duration (s)" allScatterPlot.Y.Scale = plot.LogScale allScatterPlot.Y.Tick.Marker = plot.LogTicks for i, name := range events.OrderedNames() { scatter, ok := scatters[name] if !ok { continue } allScatterPlot.Add(scatter[0]) allScatterPlot.Add(scatter[1]) scatterPlot, _ := plot.New() scatterPlot.Title.Text = name scatterPlot.X.Label.Text = "Time (s)" scatterPlot.Y.Label.Text = "Duration (s)" scatterPlot.Y.Scale = plot.LogScale scatterPlot.Y.Tick.Marker = plot.LogTicks scatterPlot.Add(scatter...) scatterPlot.Add(verticalLines...) scatterPlot.Add(lineOverlays...) scatterPlot.Add(options.OverlayPlots...) scatterPlot.X.Min = minX scatterPlot.X.Max = maxX scatterPlot.Y.Min = 1e-5 scatterPlot.Y.Max = maxY b.AddSubPlotAt(scatterPlot, 0, n-2-i) } allScatterPlot.Add(verticalLines...) allScatterPlot.Add(lineOverlays...) allScatterPlot.Add(options.OverlayPlots...) allScatterPlot.X.Min = minX allScatterPlot.X.Max = maxX allScatterPlot.Y.Min = 1e-5 allScatterPlot.Y.Max = maxY fmt.Println("all", minX, maxX) b.AddSubPlotAt(allScatterPlot, 0, n-1) width := 12.0 if options.WidthStretch > 0 { width = width * options.WidthStretch } b.Save(width, 5*float64(n), filename) }