simplify: Visvalingam, by default, keeps 3 points for "areas"

simplify/douglas_peucker.go

@@ -19,7 +19,7 @@ func DouglasPeucker(threshold float64) *DouglasPeuckerSimplifier {
  }
 }
 
-func (s *DouglasPeuckerSimplifier) simplify(ls orb.LineString, wim bool) (orb.LineString, []int) {
+func (s *DouglasPeuckerSimplifier) simplify(ls orb.LineString, area, wim bool) (orb.LineString, []int) {
  mask := make([]byte, len(ls))
  mask[0] = 1
  mask[len(mask)-1] = 1

simplify/douglas_peucker_test.go

@@ -40,7 +40,7 @@ func TestDouglasPeucker(t *testing.T) {
 
  for _, tc := range cases {
  t.Run(tc.name, func(t *testing.T) {
- v, im := DouglasPeucker(tc.threshold).simplify(tc.ls, true)
+ v, im := DouglasPeucker(tc.threshold).simplify(tc.ls, false, true)
  if !v.Equal(tc.expected) {
  t.Log(v)
  t.Log(tc.expected)

simplify/helpers.go

@@ -4,7 +4,7 @@ package simplify
 import "github.com/paulmach/orb"
 
 type simplifier interface {
- simplify(orb.LineString, bool) (orb.LineString, []int)
+ simplify(l orb.LineString, area bool, withIndexMap bool) (orb.LineString, []int)
 }
 
 func simplify(s simplifier, geom orb.Geometry) orb.Geometry {
@@ -64,24 +64,24 @@ func simplify(s simplifier, geom orb.Geometry) orb.Geometry {
 }
 
 func lineString(s simplifier, ls orb.LineString) orb.LineString {
- return runSimplify(s, ls)
+ return runSimplify(s, ls, false)
 }
 
 func multiLineString(s simplifier, mls orb.MultiLineString) orb.MultiLineString {
  for i := range mls {
- mls[i] = runSimplify(s, mls[i])
+ mls[i] = runSimplify(s, mls[i], false)
  }
  return mls
 }
 
 func ring(s simplifier, r orb.Ring) orb.Ring {
- return orb.Ring(runSimplify(s, orb.LineString(r)))
+ return orb.Ring(runSimplify(s, orb.LineString(r), true))
 }
 
 func polygon(s simplifier, p orb.Polygon) orb.Polygon {
  count := 0
  for i := range p {
- r := orb.Ring(runSimplify(s, orb.LineString(p[i])))
+ r := orb.Ring(runSimplify(s, orb.LineString(p[i]), true))
  if i != 0 && len(r) <= 2 {
  continue
  }
@@ -113,10 +113,10 @@ func collection(s simplifier, c orb.Collection) orb.Collection {
  return c
 }
 
-func runSimplify(s simplifier, ls orb.LineString) orb.LineString {
+func runSimplify(s simplifier, ls orb.LineString, area bool) orb.LineString {
  if len(ls) <= 2 {
  return ls
  }
- ls, _ = s.simplify(ls, false)
+ ls, _ = s.simplify(ls, area, false)
  return ls
 }

simplify/radial.go

@@ -20,7 +20,7 @@ func Radial(df orb.DistanceFunc, threshold float64) *RadialSimplifier {
  }
 }
 
-func (s *RadialSimplifier) simplify(ls orb.LineString, wim bool) (orb.LineString, []int) {
+func (s *RadialSimplifier) simplify(ls orb.LineString, area, wim bool) (orb.LineString, []int) {
  var indexMap []int
  if wim {
  indexMap = append(indexMap, 0)

simplify/radial_test.go

@@ -41,7 +41,7 @@ func TestRadial(t *testing.T) {
 
  for _, tc := range cases {
  t.Run(tc.name, func(t *testing.T) {
- v, im := Radial(planar.Distance, tc.threshold).simplify(tc.ls, true)
+ v, im := Radial(planar.Distance, tc.threshold).simplify(tc.ls, false, true)
  if !v.Equal(tc.expected) {
  t.Log(v)
  t.Log(tc.expected)

simplify/visvalingam.go

@@ -12,10 +12,17 @@ var _ orb.Simplifier = &VisvalingamSimplifier{}
 // performs the vivalingham algorithm.
 type VisvalingamSimplifier struct {
  Threshold float64
- ToKeep int
+
+ // If 0 defaults to 2 for line, 3 for non-closed rings and 4 for closed rings.
+ // The intent is to maintain valid geometry after simplification, however it
+ // is still possible for the simplification to create self-intersections.
+ ToKeep int
 }
 
 // Visvalingam creates a new VisvalingamSimplifier.
+// If minPointsToKeep is 0 the algorithm will keep at least 2 points for lines,
+// 3 for non-closed rings and 4 for closed rings. However it is still possible
+// for the simplification to create self-intersections.
 func Visvalingam(threshold float64, minPointsToKeep int) *VisvalingamSimplifier {
  return &VisvalingamSimplifier{
  Threshold: threshold,
@@ -25,19 +32,42 @@ func Visvalingam(threshold float64, minPointsToKeep int) *VisvalingamSimplifier
 
 // VisvalingamThreshold runs the Visvalingam-Whyatt algorithm removing
 // triangles whose area is below the threshold.
+// Will keep at least 2 points for lines, 3 for non-closed rings and 4 for closed rings.
+// The intent is to maintain valid geometry after simplification, however it
+// is still possible for the simplification to create self-intersections.
 func VisvalingamThreshold(threshold float64) *VisvalingamSimplifier {
  return Visvalingam(threshold, 0)
 }
 
 // VisvalingamKeep runs the Visvalingam-Whyatt algorithm removing
-// triangles of minimum area until we're down to `toKeep` number of points.
-func VisvalingamKeep(toKeep int) *VisvalingamSimplifier {
- return Visvalingam(math.MaxFloat64, toKeep)
+// triangles of minimum area until we're down to `minPointsToKeep` number of points.
+// If minPointsToKeep is 0 the algorithm will keep at least 2 points for lines,
+// 3 for non-closed rings and 4 for closed rings. However it is still possible
+// for the simplification to create self-intersections.
+func VisvalingamKeep(minPointsToKeep int) *VisvalingamSimplifier {
+ return Visvalingam(math.MaxFloat64, minPointsToKeep)
 }
 
-func (s *VisvalingamSimplifier) simplify(ls orb.LineString, wim bool) (orb.LineString, []int) {
+func (s *VisvalingamSimplifier) simplify(ls orb.LineString, area, wim bool) (orb.LineString, []int) {
+ if len(ls) <= 1 {
+ return ls, nil
+ }
+
+ toKeep := s.ToKeep
+ if toKeep == 0 {
+ if area {
+ if ls[0] == ls[len(ls)-1] {
+ toKeep = 4
+ } else {
+ toKeep = 3
+ }
+ } else {
+ toKeep = 2
+ }
+ }
+
  var indexMap []int
- if len(ls) <= s.ToKeep {
+ if len(ls) <= toKeep {
  if wim {
  // create identify map
  indexMap = make([]int, len(ls))
@@ -89,7 +119,7 @@ func (s *VisvalingamSimplifier) simplify(ls orb.LineString, wim bool) (orb.LineS
  // run through the reduction process
  for len(heap) > 0 {
  current := heap.Pop()
- if current.area > threshold || len(ls)-removed <= s.ToKeep {
+ if current.area > threshold || len(ls)-removed <= toKeep {
  break
  }
 
@@ -153,7 +183,7 @@ type visItem struct {
  next *visItem
  previous *visItem
 
- index int // interal index in heap, for removal and update
+ index int // internal index in heap, for removal and update
 }
 
 func (h *minHeap) Push(item *visItem) {

simplify/visvalingam_test.go

@@ -33,7 +33,7 @@ func TestVisvalingamThreshold(t *testing.T) {
 
  for _, tc := range cases {
  t.Run(tc.name, func(t *testing.T) {
- v, im := VisvalingamThreshold(tc.threshold).simplify(tc.ls, true)
+ v, im := VisvalingamThreshold(tc.threshold).simplify(tc.ls, false, true)
  if !v.Equal(tc.expected) {
  t.Log(v)
  t.Log(tc.expected)
@@ -49,6 +49,45 @@ func TestVisvalingamThreshold(t *testing.T) {
  }
 }
 
+func TestVisvalingamThreshold_area(t *testing.T) {
+ cases := []struct {
+ name string
+ r orb.Ring
+ expected orb.Ring
+ indexMap []int
+ }{
+ {
+ name: "reduction",
+ r: orb.Ring{{0, 0}, {1, 0}, {1, 0.5}, {1, 1}, {0.5, 1}, {0, 1}},
+ expected: orb.Ring{{0, 0}, {1, 0}, {0, 1}},
+ indexMap: []int{0, 1, 5},
+ },
+ {
+ name: "reduction closed",
+ r: orb.Ring{{0, 0}, {1, 0}, {1, 0.5}, {1, 1}, {0.5, 1}, {0, 1}, {0, 0}},
+ expected: orb.Ring{{0, 0}, {1, 0}, {1, 1}, {0, 0}},
+ indexMap: []int{0, 1, 3, 6},
+ },
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ v, im := VisvalingamThreshold(10).simplify(orb.LineString(tc.r), true, true)
+ if !v.Equal(orb.LineString(tc.expected)) {
+ t.Log(v)
+ t.Log(tc.expected)
+ t.Errorf("incorrect ring")
+ }
+
+ if !reflect.DeepEqual(im, tc.indexMap) {
+ t.Log(im)
+ t.Log(tc.indexMap)
+ t.Errorf("incorrect index map")
+ }
+ })
+ }
+}
+
 func TestVisvalingamKeep(t *testing.T) {
  cases := []struct {
  name string
@@ -96,7 +135,7 @@ func TestVisvalingamKeep(t *testing.T) {
 
  for _, tc := range cases {
  t.Run(tc.name, func(t *testing.T) {
- v, im := VisvalingamKeep(tc.keep).simplify(tc.ls, true)
+ v, im := VisvalingamKeep(tc.keep).simplify(tc.ls, false, true)
  if !v.Equal(tc.expected) {
  t.Log(v)
  t.Log(tc.expected)
@@ -181,7 +220,7 @@ func TestVisvalingam(t *testing.T) {
 
  for _, tc := range cases {
  t.Run(tc.name, func(t *testing.T) {
- v, im := Visvalingam(tc.threshold, tc.keep).simplify(tc.ls, true)
+ v, im := Visvalingam(tc.threshold, tc.keep).simplify(tc.ls, false, true)
  if !v.Equal(tc.expected) {
  t.Log(v)
  t.Log(tc.expected)