func PlotGraph(title string, timestamps []int64, w io.Writer) error {
p, err := plot.New()
if err != nil {
return err
}
p.Title.Text = title
p.X.Label.Text = "Time"
p.Y.Label.Text = "Number of stars"
p.Y.Min = 0
points := make(plotter.XYs, len(timestamps))
for i, timestamp := range timestamps {
points[i].X = float64(timestamp)
points[i].Y = float64(i + 1)
}
plotutil.AddLinePoints(p, "Stars", points)
c := vgimg.New(4*vg.Inch, 4*vg.Inch)
cpng := vgimg.PngCanvas{c}
p.Draw(draw.New(cpng))
if _, err := cpng.WriteTo(w); err != nil {
return err
}
return nil
}
// WriterTo returns an io.WriterTo that will write the plot as
// the specified image format.
//
// Supported formats are:
//
// eps, jpg|jpeg, pdf, png, svg, and tif|tiff.
func (p *Plot) WriterTo(w, h vg.Length, format string) (io.WriterTo, error) {
var c interface {
vg.CanvasSizer
io.WriterTo
}
switch format {
case "eps":
c = vgeps.New(w, h)
case "jpg", "jpeg":
c = vgimg.JpegCanvas{Canvas: vgimg.New(w, h)}
case "pdf":
c = vgpdf.New(w, h)
case "png":
c = vgimg.PngCanvas{Canvas: vgimg.New(w, h)}
case "svg":
c = vgsvg.New(w, h)
case "tif", "tiff":
c = vgimg.TiffCanvas{Canvas: vgimg.New(w, h)}
default:
return nil, fmt.Errorf("unsupported format: %q", format)
}
p.Draw(draw.New(c))
return c, nil
}
func TestIssue179(t *testing.T) {
scatter, err := plotter.NewScatter(plotter.XYs{{1, 1}, {0, 1}, {0, 0}})
if err != nil {
log.Fatal(err)
}
p, err := plot.New()
if err != nil {
log.Fatal(err)
}
p.Add(scatter)
p.HideAxes()
c := vgimg.JpegCanvas{Canvas: vgimg.New(5.08*vg.Centimeter, 5.08*vg.Centimeter)}
p.Draw(draw.New(c))
b := bytes.NewBuffer([]byte{})
if _, err = c.WriteTo(b); err != nil {
t.Error(err)
}
f, err := os.Open(filepath.Join("testdata", "issue179.jpg"))
if err != nil {
t.Error(err)
}
defer f.Close()
want, err := ioutil.ReadAll(f)
if err != nil {
t.Error(err)
}
if !bytes.Equal(b.Bytes(), want) {
t.Error("Image mismatch")
}
}
func plotSingle(df *DataFrame, name string) {
p, err := plot.New()
if err != nil {
log.Fatal(err)
}
p.X.Label.Text = "X"
p.Y.Label.Text = "Y"
err = plotutil.AddLinePoints(p, name, df.PlotPoints())
if err != nil {
log.Fatal(err)
}
c := vgsvg.New(16*vg.Inch, 9*vg.Inch)
can := draw.New(c)
p.Draw(can)
p.Save(16*vg.Inch/2, 9*vg.Inch/2, fmt.Sprintf("graphs/%s.png", name))
f, err := os.Create(fmt.Sprintf("graphs/%s.svg", name))
if err != nil {
log.Fatal(err)
}
c.WriteTo(f)
}
func main() {
rand.Seed(int64(0))
p, err := plot.New()
if err != nil {
panic(err)
}
p.Title.Text = "Plotutil example"
p.X.Label.Text = "X"
p.Y.Label.Text = "Y"
err = plotutil.AddLinePoints(
p,
"First", randomPoints(15),
)
if err != nil {
panic(err)
}
cnvs, err := vgx11.New(4*96, 4*96, "Example")
if err != nil {
panic(err)
}
p.Draw(draw.New(cnvs))
cnvs.Paint()
time.Sleep(5 * time.Second)
err = plotutil.AddLinePoints(
p,
"Second", randomPoints(15),
"Third", randomPoints(15),
)
if err != nil {
panic(err)
}
p.Draw(draw.New(cnvs))
cnvs.Paint()
time.Sleep(10 * time.Second)
// Save the plot to a PNG file.
// if err := p.Save(4, 4, "points.png"); err != nil {
// panic(err)
// }
}
// WriterTo returns an io.WriterTo that will write the plot as
// the specified image format.
//
// Supported formats are:
//
// eps, jpg|jpeg, pdf, png, svg, and tif|tiff.
func (p *Plot) WriterTo(w, h vg.Length, format string) (io.WriterTo, error) {
c, err := draw.NewFormattedCanvas(w, h, format)
if err != nil {
return nil, err
}
p.Draw(draw.New(c))
return c, nil
}
func TestIssue179(t *testing.T) {
t.Skip("github.com/BurntSushi/xgbutil#30 issue not fixed")
if !hasX11() {
t.Skip("no X11 environment")
}
scatter, err := plotter.NewScatter(plotter.XYs{{1, 1}, {0, 1}, {0, 0}})
if err != nil {
t.Fatalf("error: %v\n", err)
}
p, err := plot.New()
if err != nil {
t.Fatalf("error: %v\n", err)
}
p.Add(scatter)
p.HideAxes()
c, err := New(5.08*vg.Centimeter, 5.08*vg.Centimeter, "test issue179")
if err != nil {
t.Fatalf("error: %v\n", err)
}
p.Draw(draw.New(c))
b := bytes.NewBuffer([]byte{})
err = jpeg.Encode(b, c.ximg, nil)
if err != nil {
t.Error(err)
}
f, err := os.Open(filepath.Join("..", "vgimg", "testdata", "issue179.jpg"))
if err != nil {
t.Error(err)
}
defer f.Close()
want, err := ioutil.ReadAll(f)
if err != nil {
t.Error(err)
}
if !bytes.Equal(b.Bytes(), want) {
t.Error("Image mismatch")
}
}
func main() {
const (
p = 1 * vg.Centimeter
nrows = 4
ncols = 5
)
for _, f := range formats {
c, err := draw.NewFormattedCanvas(10*ncols*vg.Centimeter,
10*nrows*vg.Centimeter, f)
if err != nil {
log.Fatal(err)
}
dc := draw.New(c)
tiles := draw.Tiles{
Rows: nrows, Cols: ncols,
PadTop: p, PadBottom: p,
PadRight: p, PadLeft: p,
PadX: p, PadY: p,
}
ii := 0
for j := 0; j < nrows; j++ {
for i := 0; i < ncols; i++ {
if ii < len(examples) {
ex := examples[ii]
ex.p.Draw(tiles.At(dc, i, j))
if err != nil {
log.Fatalf("failed to draw tile for %s.%s: %v", ex.name, f, err)
}
ii++
}
}
}
w, err := os.Create("examples." + f)
if err != nil {
log.Fatal(err)
}
_, err = c.WriteTo(w)
if err != nil {
log.Fatal(err)
}
}
}
func (c *Calibrate) Update(entity *ecs.Entity, dt float32) {
if c.frameIndex != 0 {
return
}
var (
cal *CalibrateComponent
ok bool
)
if cal, ok = entity.ComponentFast(cal).(*CalibrateComponent); !ok {
return
}
// Render the image again
plt, err := plot.New()
if err != nil {
log.Fatal(err)
}
plotutil.AddLinePoints(plt,
"CH"+strconv.Itoa(int(cal.ChannelIndex)), plotter.XYer(c.channels[cal.ChannelIndex]))
img := image.NewRGBA(image.Rect(0, 0, 3*dpi, 3*dpi))
canv := vgimg.NewWith(vgimg.UseImage(img))
plt.Draw(draw.New(canv))
bgTexture := engi.NewImageRGBA(img)
// Give it to engi
erender := &engi.RenderComponent{
Display: engi.NewRegion(engi.NewTexture(bgTexture), 0, 0, 3*dpi, 3*dpi),
Scale: engi.Point{1, 1},
Transparency: 1,
Color: color.RGBA{255, 255, 255, 255},
}
erender.SetPriority(engi.HUDGround)
entity.AddComponent(erender)
}
func plotMulti(name string, names []string, frames []*DataFrame) {
if len(names) != len(frames) {
log.Fatal("wrong length for plots")
}
p, err := plot.New()
if err != nil {
log.Fatal(err)
}
p.X.Label.Text = "X"
p.Y.Label.Text = "Y"
lines := make([]interface{}, len(names)*2)
x := 0
for i := 0; i < len(lines); i += 2 {
lines[i] = names[x]
lines[i+1] = frames[x].PlotPoints()
x += 1
}
err = plotutil.AddLinePoints(p, lines...)
if err != nil {
log.Fatal(err)
}
c := vgsvg.New(16*vg.Inch, 9*vg.Inch)
can := draw.New(c)
p.Draw(can)
p.Save(16*vg.Inch/2, 9*vg.Inch/2, fmt.Sprintf("graphs/%s.png", name))
f, err := os.Create(fmt.Sprintf("graphs/%s.svg", name))
if err != nil {
log.Fatal(err)
}
c.WriteTo(f)
}
func (c *client) run() {
var err error
dir, err := ioutil.TempDir("", "snfusion-web-")
if err != nil {
log.Printf("error creating temporary directory: %v\n", err)
return
}
defer func() {
c.srv.unregister <- c
c.ws.Close()
c.srv = nil
os.RemoveAll(dir)
}()
type params struct {
ID int `json:"id"`
NumIters int `json:"num_iters"`
NumCarbons float64 `json:"num_carbons"`
Seed int64 `json:"seed"`
}
type genReply struct {
ID int `json:"id"`
Stage string `json:"stage"`
Err error `json:"err"`
Msg string `json:"msg"`
Engine sim.Engine `json:"engine"`
}
type plotReply struct {
ID int `json:"id"`
Stage string `json:"stage"`
Err error `json:"err"`
SVG string `json:"svg"`
}
type zipReply struct {
ID int `json:"id"`
Stage string `json:"stage"`
Err error `json:"err"`
Href string `json:"href"`
}
for {
param := params{
NumIters: 100000,
NumCarbons: 60,
Seed: 1234,
}
log.Printf("waiting for simulation parameters...\n")
err = websocket.JSON.Receive(c.ws, ¶m)
if err != nil {
log.Printf("error rcv: %v\n", err)
return
}
id := param.ID
msgbuf := new(bytes.Buffer)
msg := log.New(msgbuf, "snfusion-sim: ", 0)
engine := sim.Engine{
NumIters: param.NumIters,
NumCarbons: param.NumCarbons,
Seed: param.Seed,
}
engine.SetLogger(msg)
log.Printf("processing... %#v\n", engine)
csvbuf := new(bytes.Buffer)
errc := make(chan error)
ticker := time.NewTicker(1 * time.Second)
go func() {
errc <- engine.Run(csvbuf)
ticker.Stop()
}()
err = <-errc
if err != nil {
log.Printf("error: %v\n", err)
_ = websocket.JSON.Send(c.ws, genReply{
ID: id, Err: err, Engine: engine, Stage: "gen-done", Msg: msgbuf.String(),
})
return
}
err = websocket.JSON.Send(c.ws, genReply{
ID: id, Err: err, Engine: engine, Stage: "gen-done", Msg: msgbuf.String(),
})
if err != nil {
log.Printf("error sending data: %v\n", err)
return
}
csvdata := make([]byte, len(csvbuf.Bytes()))
copy(csvdata, csvbuf.Bytes())
log.Printf("running post-processing...\n")
r := csv.NewReader(csvbuf)
r.Comma = ';'
r.Comment = '#'
table := make([]plotter.XYs, len(engine.Population))
for i := range table {
table[i] = make(plotter.XYs, engine.NumIters+1)
}
for ix := 0; ix < engine.NumIters+1; ix++ {
var text []string
text, err = r.Read()
if err != nil {
break
}
for i := range engine.Population {
table[i][ix].X = float64(ix)
table[i][ix].Y = float64(atoi(text[i]))
}
}
if err == io.EOF {
err = nil
}
if err != nil {
log.Printf("error reading data: %v\n", err)
return
}
p, err := plot.New()
if err != nil {
panic(err)
}
p.Title.Text = fmt.Sprintf(
"Time evolution of nuclei C%v-O%v (seed=%d)",
engine.NumCarbons,
100-engine.NumCarbons,
engine.Seed,
)
p.X.Label.Text = "Iteration number"
p.Y.Label.Text = "Atomic mass of nuclei"
for i, n := range engine.Population {
line, err := plotter.NewLine(table[i])
if err != nil {
log.Fatalf(
"error adding data points for nucleus %v: %v\n",
n, err,
)
}
line.LineStyle.Color = col(n)
line.LineStyle.Width = vg.Points(1)
p.Add(line)
p.Legend.Add(label(n), line)
}
p.Add(plotter.NewGrid())
p.Legend.Top = true
p.Legend.XOffs = -1 * vg.Centimeter
figX := 25 * vg.Centimeter
figY := figX / vg.Length(math.Phi)
// Create a Canvas for writing SVG images.
canvas := vgsvg.New(figX, figY)
// Draw to the Canvas.
p.Draw(draw.New(canvas))
outsvg := new(bytes.Buffer)
_, err = canvas.WriteTo(outsvg)
if err != nil {
log.Printf("error svg: %v\n", err)
return
}
err = websocket.JSON.Send(c.ws, plotReply{
ID: id, Err: err, SVG: outsvg.String(), Stage: "plot-done",
})
if err != nil {
log.Printf("error sending data: %v\n", err)
return
}
pngcanvas := vgimg.PngCanvas{Canvas: vgimg.New(figX, figY)}
p.Draw(draw.New(pngcanvas))
outpng := new(bytes.Buffer)
_, err = pngcanvas.WriteTo(outpng)
if err != nil {
log.Printf("error png: %v\n", err)
return
}
href := filepath.Join(dir, fmt.Sprintf("output-%d.zip", id))
zipf, err := os.Create(href)
if err != nil {
log.Printf("error creating zip file: %v\n", err)
}
defer zipf.Close()
zipw := zip.NewWriter(zipf)
defer zipw.Close()
for _, file := range []struct {
Name string
Body []byte
}{
{"output.csv", csvdata},
{"output.png", outpng.Bytes()},
} {
ff, err := zipw.Create(file.Name)
if err != nil {
log.Printf("error creating zip content %v: %v\n", file.Name, err)
return
}
_, err = ff.Write(file.Body)
if err != nil {
log.Printf("error writing zip content %v: %v\n", file.Name, err)
return
}
}
err = zipw.Close()
if err != nil {
log.Printf("error closing zip-writer: %v\n", err)
return
}
err = zipf.Close()
if err != nil {
log.Printf("error closing zip-file: %v\n", err)
return
}
err = websocket.JSON.Send(c.ws, zipReply{
ID: id, Err: err, Href: href, Stage: "zip-done",
})
if err != nil {
log.Printf("error sending zip: %v\n", err)
return
}
log.Printf("saved report under %v\n", href)
}
}