add optimized line plot

Author: egonelbre

cmd/canvas-example/canvas-example

@@ -6,7 +6,6 @@ import (
 	"io/ioutil"
 	"math"
 
-	"github.com/kr/pretty"
 	"github.com/loov/plot"
 )
 
@@ -54,7 +53,7 @@ func main() {
 		Dash:   []plot.Length{1, 2, 3},
 	})
 
-	pretty.Print(canvas)
+	fmt.Println(canvas)
 
 	ioutil.WriteFile("example.svg", canvas.Bytes(), 0755)
 }

cmd/canvas-example/main.go

@@ -0,0 +1,3 @@
+module github.com/loov/plot
+
+go 1.12

go.mod

@@ -1,5 +1,7 @@
 package plot
 
+import "math"
+
 // Line implements a simple line plot.
 type Line struct {
 	Style
@@ -32,3 +34,76 @@ func (line *Line) Draw(plot *Plot, canvas Canvas) {
 		canvas.Poly(points, &plot.Theme.Line)
 	}
 }
+
+// OptimizedLine implements a simple line plot.
+type OptimizedLine struct {
+	Style
+	Label string
+
+	Data []Point
+
+	ThresholdPx float64
+}
+
+// NewOptimizedLine creates a new line element that tries to optimize drawing.
+func NewOptimizedLine(label string, points []Point, thresholdPx float64) *OptimizedLine {
+	return &OptimizedLine{
+		Label:       label,
+		ThresholdPx: thresholdPx,
+		Data:        points,
+	}
+}
+
+// Stats calculates element statistics.
+func (line *OptimizedLine) Stats() Stats {
+	return PointsStats(line.Data)
+}
+
+// Draw draws the element to canvas.
+func (line *OptimizedLine) Draw(plot *Plot, canvas Canvas) {
+	canvas = canvas.Clip(canvas.Bounds())
+	points := project(line.Data, plot.X, plot.Y, canvas.Bounds())
+
+	const optimizeCount = 100
+	if len(points) < optimizeCount {
+		if !line.Style.IsZero() {
+			canvas.Poly(points, &line.Style)
+		} else {
+			canvas.Poly(points, &plot.Theme.Line)
+		}
+		return
+	}
+
+	// always include the first point
+	optimized := points[:1]
+
+	prev := points[0]
+	mid := points[1]
+	for _, next := range points[2:] {
+		// does the mid change significantly from the previous?
+		if math.Abs(prev.Y-mid.Y) < line.ThresholdPx && math.Abs(prev.X-mid.X) < line.ThresholdPx {
+			mid = next
+			continue
+		}
+
+		// is the mid on the line from prev to next?
+		p := invlerp(mid.X, prev.X, next.X)
+		knownY := lerp(p, prev.Y, next.Y)
+		if math.Abs(knownY-mid.X) < line.ThresholdPx {
+			mid = next
+			continue
+		}
+
+		// otherwise let's output
+		optimized = append(optimized, mid)
+		prev, mid = mid, next
+	}
+	// add the final point
+	optimized = append(optimized, points[len(points)-1])
+
+	if !line.Style.IsZero() {
+		canvas.Poly(optimized, &line.Style)
+	} else {
+		canvas.Poly(optimized, &plot.Theme.Line)
+	}
+}

go.sum

@@ -35,7 +35,17 @@ func niceNumber(span float64, round bool) float64 {
 	return nice * math.Pow(10, exp)
 }
 
-// lerpUnit implements interpolates between min and max.
+// lerp interpolates between min and max using p=[0,1].
+func lerp(p, min, max float64) float64 {
+	return p*(max-min) + min
+}
+
+// invlerp return inverse lerp from min, max and the value.
+func invlerp(v, min, max float64) float64 {
+	return (v - min) / (max - min)
+}
+
+// lerpUnit interpolates between min and max using p=[-1,1].
 func lerpUnit(p, min, max float64) float64 {
 	pu := (p + 1) * 0.5
 	return pu*(max-min) + min