305 lines
7.2 KiB
Go
305 lines
7.2 KiB
Go
package intervals
|
|
|
|
import (
|
|
"fmt"
|
|
"image/color"
|
|
"os"
|
|
|
|
"gonum.org/v1/plot"
|
|
"gonum.org/v1/plot/palette"
|
|
"gonum.org/v1/plot/plotter"
|
|
"gonum.org/v1/plot/vg"
|
|
"gonum.org/v1/plot/vg/draw"
|
|
"gonum.org/v1/plot/vg/vgimg"
|
|
)
|
|
|
|
type PlotType int
|
|
|
|
const (
|
|
PlotTypeIntervals PlotType = iota
|
|
PlotTypeGaps
|
|
PlotTypeOverlapped
|
|
PlotTypeMerged
|
|
)
|
|
|
|
const (
|
|
openBracket = "["
|
|
closeBracket = "]"
|
|
openParenthesis = "("
|
|
closeParenthesis = ")"
|
|
)
|
|
|
|
type IntervalPlot interface {
|
|
PlotData(path string, intervals Intervals, addIntervals, addGaps, addOverlapped, addMerges bool) error
|
|
CreatePlot(title string, xys plotter.XYs, plotType PlotType) (*Superplot, error)
|
|
AlignPlots(plotItems []*Superplot, minLow, maxHigh int) *vgimg.Canvas
|
|
CreateFileFromCanvas(path string, img *vgimg.Canvas) error
|
|
}
|
|
|
|
type intervalPlot struct {
|
|
lowInclusive bool
|
|
highInclusive bool
|
|
intervalOpening string
|
|
intervalClosing string
|
|
}
|
|
|
|
func NewPlot(lowInclusive bool, highInclusive bool) IntervalPlot {
|
|
opening := ""
|
|
if lowInclusive {
|
|
opening = openBracket
|
|
} else {
|
|
opening = openParenthesis
|
|
}
|
|
|
|
closing := ""
|
|
if highInclusive {
|
|
closing = closeBracket
|
|
} else {
|
|
closing = closeParenthesis
|
|
}
|
|
|
|
ip := &intervalPlot{
|
|
lowInclusive: lowInclusive,
|
|
highInclusive: highInclusive,
|
|
intervalOpening: opening,
|
|
intervalClosing: closing,
|
|
}
|
|
return ip
|
|
}
|
|
|
|
type Superplot struct {
|
|
Plot *plot.Plot
|
|
NumElements int
|
|
}
|
|
|
|
func (ip *intervalPlot) PlotData(path string, intervals Intervals, addIntervals, addGaps, addOverlapped, addMerges bool) error {
|
|
plots := []*Superplot{}
|
|
var err error
|
|
|
|
if addIntervals {
|
|
// create Intervals plot
|
|
xysIntervals := ip.convertToPlotterXYs(intervals.GetIntervals())
|
|
p1, err := ip.CreatePlot("Intervals", xysIntervals, PlotTypeIntervals)
|
|
if err != nil {
|
|
return fmt.Errorf("could not create plot: %v", err)
|
|
}
|
|
plots = append(plots, p1)
|
|
}
|
|
|
|
if addGaps {
|
|
// create Gaps plot
|
|
xysGaps := ip.convertToPlotterXYs(intervals.Gaps())
|
|
p2, err := ip.CreatePlot("Gaps", xysGaps, PlotTypeGaps)
|
|
if err != nil {
|
|
return fmt.Errorf("could not create plot: %v", err)
|
|
}
|
|
plots = append(plots, p2)
|
|
}
|
|
|
|
if addOverlapped {
|
|
// create Overlapped `plot
|
|
xysOverlapped := ip.convertToPlotterXYs(intervals.Overlapped())
|
|
p3, err := ip.CreatePlot("Overlapped", xysOverlapped, PlotTypeOverlapped)
|
|
if err != nil {
|
|
return fmt.Errorf("could not create plot: %v", err)
|
|
}
|
|
plots = append(plots, p3)
|
|
}
|
|
|
|
if addMerges {
|
|
// create Merged plot
|
|
xysMerged := ip.convertToPlotterXYs(intervals.Merge())
|
|
p4, err := ip.CreatePlot("Merged", xysMerged, PlotTypeMerged)
|
|
if err != nil {
|
|
return fmt.Errorf("could not create plot: %v", err)
|
|
}
|
|
plots = append(plots, p4)
|
|
}
|
|
|
|
// join all plots, align them
|
|
canvas := ip.AlignPlots(plots, intervals.GetMinLow(), intervals.GetMaxHigh())
|
|
err = ip.CreateFileFromCanvas("out.png", canvas)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ip *intervalPlot) CreateFileFromCanvas(path string, img *vgimg.Canvas) error {
|
|
f, err := os.Create(path)
|
|
if err != nil {
|
|
return fmt.Errorf("could not create %s: %v", path, err)
|
|
}
|
|
|
|
png := vgimg.PngCanvas{Canvas: img}
|
|
if _, err := png.WriteTo(f); err != nil {
|
|
return fmt.Errorf("could not write to %s: %v", path, err)
|
|
}
|
|
|
|
if err := f.Close(); err != nil {
|
|
return fmt.Errorf("could not close %s: %v", path, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ip *intervalPlot) AlignPlots(plotItems []*Superplot, minLow, maxHigh int) *vgimg.Canvas {
|
|
rows, cols := len(plotItems), 1
|
|
plots := make([][]*plot.Plot, rows)
|
|
for j := 0; j < rows; j++ {
|
|
plots[j] = make([]*plot.Plot, cols)
|
|
for i := 0; i < cols; i++ {
|
|
p := plotItems[j]
|
|
|
|
// make sure the horizontal scales match
|
|
p.Plot.X.Min = float64(minLow) // MinX
|
|
p.Plot.X.Max = float64(maxHigh) //MaxX
|
|
|
|
plots[j][i] = p.Plot
|
|
}
|
|
}
|
|
|
|
img := vgimg.New(vg.Points(512), vg.Points(float64(200*rows)))
|
|
dc := draw.New(img)
|
|
|
|
t := draw.Tiles{
|
|
Rows: rows,
|
|
Cols: cols,
|
|
}
|
|
|
|
canvases := plot.Align(plots, t, dc)
|
|
for j := 0; j < rows; j++ {
|
|
for i := 0; i < cols; i++ {
|
|
if plots[j][i] != nil {
|
|
plots[j][i].Draw(canvases[j][i])
|
|
}
|
|
}
|
|
}
|
|
return img
|
|
}
|
|
|
|
func (ip *intervalPlot) CreatePlot(title string, xys plotter.XYs, plotType PlotType) (*Superplot, error) {
|
|
p, err := plot.New()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("could not create plot: %v", err)
|
|
}
|
|
|
|
// Draw a grid behind the data
|
|
p.Add(plotter.NewGrid())
|
|
p.Title.Text = title
|
|
p.HideY()
|
|
p.X.Padding = vg.Length(5)
|
|
p.Y.Padding = vg.Length(20)
|
|
|
|
ip.plotIntervals(p, plotType, xys)
|
|
return &Superplot{p, xys.Len()}, nil
|
|
}
|
|
|
|
func (ip *intervalPlot) plotIntervals(p *plot.Plot, plotType PlotType, xys plotter.XYs) error {
|
|
var ps []plot.Plotter
|
|
colors := ip.getColors()
|
|
numColors := len(colors)
|
|
|
|
crossShape := draw.CrossGlyph{}
|
|
ringShape := draw.RingGlyph{}
|
|
legendWithCrossShape := false
|
|
legendWithRingShape := false
|
|
for i, xy := range xys {
|
|
pXYLow := struct{ X, Y float64 }{xy.X, float64(i)}
|
|
pXYHigh := struct{ X, Y float64 }{xy.Y, float64(i)}
|
|
pXYs := plotter.XYs{pXYLow, pXYHigh}
|
|
color := colors[i%numColors]
|
|
|
|
var s1, s2 *plotter.Scatter
|
|
var err error
|
|
label := ""
|
|
if plotType == PlotTypeIntervals {
|
|
label = fmt.Sprintf("%s%v,%v%s", ip.intervalOpening, xy.X, xy.Y, ip.intervalClosing)
|
|
s1, err = plotter.NewScatter(plotter.XYs{pXYLow})
|
|
if err != nil {
|
|
return fmt.Errorf("unable to create new scatter: %v", err)
|
|
}
|
|
if !ip.lowInclusive {
|
|
s1.GlyphStyle.Shape = crossShape
|
|
if !legendWithCrossShape {
|
|
p.Legend.Add("Exclusive", s1)
|
|
legendWithCrossShape = true
|
|
}
|
|
} else {
|
|
s1.GlyphStyle.Shape = ringShape
|
|
if !legendWithRingShape {
|
|
p.Legend.Add("Inclusive", s1)
|
|
legendWithRingShape = true
|
|
}
|
|
}
|
|
|
|
s2, err = plotter.NewScatter(plotter.XYs{pXYHigh})
|
|
if err != nil {
|
|
return fmt.Errorf("unable to create new scatter: %v", err)
|
|
}
|
|
if !ip.highInclusive {
|
|
s2.GlyphStyle.Shape = crossShape
|
|
if !legendWithCrossShape {
|
|
p.Legend.Add("Exclusive", s2)
|
|
legendWithCrossShape = true
|
|
}
|
|
} else {
|
|
s2.GlyphStyle.Shape = ringShape
|
|
if !legendWithRingShape {
|
|
p.Legend.Add("Inclusive", s2)
|
|
legendWithRingShape = true
|
|
}
|
|
}
|
|
} else {
|
|
label = fmt.Sprintf("%s%v,%v%s", openBracket, xy.X, xy.Y, closeBracket)
|
|
s1, err = plotter.NewScatter(pXYs)
|
|
if err != nil {
|
|
return fmt.Errorf("unable to create new scatter: %v", err)
|
|
}
|
|
if !ip.lowInclusive && !ip.highInclusive {
|
|
s1.GlyphStyle.Shape = crossShape
|
|
}
|
|
}
|
|
|
|
if xy.X != xy.Y {
|
|
l, err := plotter.NewLine(pXYs)
|
|
l.Color = color
|
|
l.Width = vg.Points(10)
|
|
if err != nil {
|
|
return fmt.Errorf("could not create a new line: %v", err)
|
|
}
|
|
ps = append(ps, l)
|
|
p.Legend.Add(label, l)
|
|
} else {
|
|
s1.Color = color
|
|
if s2 != nil {
|
|
s2.Color = color
|
|
}
|
|
p.Legend.Add(label, s1)
|
|
}
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("could not create a new scatter: %v", err)
|
|
}
|
|
ps = append(ps, s1)
|
|
if s2 != nil {
|
|
ps = append(ps, s2)
|
|
}
|
|
}
|
|
p.Legend.Left = false
|
|
p.Add(ps...)
|
|
return nil
|
|
}
|
|
|
|
func (ip *intervalPlot) getColors() []color.Color {
|
|
palette := palette.Rainbow(10, 0, 1, 1, 1, 1)
|
|
return palette.Colors()
|
|
}
|
|
|
|
func (ip *intervalPlot) convertToPlotterXYs(intervals []*Interval) plotter.XYs {
|
|
pxys := plotter.XYs{}
|
|
for _, intvl := range intervals {
|
|
pxys = append(pxys, struct{ X, Y float64 }{X: float64(intvl.Low), Y: float64(intvl.High)})
|
|
}
|
|
return pxys
|
|
}
|