Merge branch 'benchmark'

Author: engelsjk

.gitignore

@@ -1 +1,4 @@
 notes.txt
+test/debug/
+debug.go
+debug_test.go

benchmark_test.go

@@ -0,0 +1,60 @@
+package polygol
+
+import (
+	"testing"
+)
+
+func BenchmarkAsiaUnion(b *testing.B) {
+	geoms, err := loadGeoms("test/end-to-end/countries-asia/args.geojson")
+	if err != nil {
+		b.Fatal(err)
+	}
+	_, err = Union(Geom{}, geoms...)
+	if err != nil {
+		b.Fatal(err)
+	}
+}
+
+func BenchmarkAfricaUnion(b *testing.B) {
+	geoms, err := loadGeoms("test/end-to-end/countries-africa/args.geojson")
+	if err != nil {
+		b.Fatal(err)
+	}
+	_, err = Union(Geom{}, geoms...)
+	if err != nil {
+		b.Fatal(err)
+	}
+}
+
+func BenchmarkEuropeUnion(b *testing.B) {
+	geoms, err := loadGeoms("test/end-to-end/countries-europe/args.geojson")
+	if err != nil {
+		b.Fatal(err)
+	}
+	_, err = Union(Geom{}, geoms...)
+	if err != nil {
+		b.Fatal(err)
+	}
+}
+
+func BenchmarkNorthAmericaUnion(b *testing.B) {
+	geoms, err := loadGeoms("test/end-to-end/countries-north-america/args.geojson")
+	if err != nil {
+		b.Fatal(err)
+	}
+	_, err = Union(Geom{}, geoms...)
+	if err != nil {
+		b.Fatal(err)
+	}
+}
+
+func BenchmarkSouthAmericaUnion(b *testing.B) {
+	geoms, err := loadGeoms("test/end-to-end/countries-south-america/args.geojson")
+	if err != nil {
+		b.Fatal(err)
+	}
+	_, err = Union(Geom{}, geoms...)
+	if err != nil {
+		b.Fatal(err)
+	}
+}

end-to-end_test.go

@@ -10,7 +10,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/engelsjk/polygol/geojson"
+	geojson "github.com/engelsjk/polygol/geojson"
 )
 
 const (
@@ -27,7 +27,7 @@ var (
 	opsSkip     = []string{}
 )
 
-type TestCase struct {
+type testCase struct {
 	Name          string
 	OperationType string
 	ResultPath    string
@@ -52,10 +52,9 @@ func TestEndToEnd(t *testing.T) {
 		}
 
 		targetDir := path.Join(endToEndDir, target.Name())
-
 		argsPath := path.Join(targetDir, "args.geojson")
 
-		args, err := loadGeoms(argsPath, false)
+		args, err := loadGeoms(argsPath)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -65,7 +64,7 @@ func TestEndToEnd(t *testing.T) {
 			log.Fatal(err)
 		}
 
-		testCases := []TestCase{}
+		testCases := []testCase{}
 
 		for _, f := range files {
 			if f.Name() == "args.geojson" {
@@ -79,13 +78,13 @@ func TestEndToEnd(t *testing.T) {
 			opType := strings.TrimSuffix(fn, ext)
 			fp := filepath.Join(targetDir, fn)
 			if opType != "all" {
-				testCases = append(testCases, TestCase{
-					Name:          fmt.Sprintf("%s-all", target.Name()),
+				testCases = append(testCases, testCase{
+					Name:          fmt.Sprintf("%s-%s", target.Name(), opType),
 					OperationType: opType,
 					ResultPath:    fp,
 				})
 			} else {
-				testCases = []TestCase{
+				testCases = []testCase{
 					{
 						Name:          fmt.Sprintf("%s-union", target.Name()),
 						OperationType: "union",
@@ -97,7 +96,7 @@ func TestEndToEnd(t *testing.T) {
 						ResultPath:    fp,
 					},
 					{
-						Name:          fmt.Sprintf("%s-all", target.Name()),
+						Name:          fmt.Sprintf("%s-xor", target.Name()),
 						OperationType: "xor",
 						ResultPath:    fp,
 					},
@@ -119,7 +118,8 @@ func TestEndToEnd(t *testing.T) {
 				if contains(opsSkip, testCase.OperationType) {
 					fmt.Printf("skipping op type %s...\n", testCase.OperationType)
 				}
-				geoms, err := loadGeoms(testCase.ResultPath, true)
+
+				geoms, err := loadGeoms(testCase.ResultPath)
 				if err != nil {
 					t.Fatal(err)
 				}
@@ -130,6 +130,7 @@ func TestEndToEnd(t *testing.T) {
 				if err != nil {
 					t.Error(err)
 				}
+
 				expect(t, equalMultiPoly(expected, result))
 			})
 		}
@@ -145,8 +146,9 @@ func contains(s []string, str string) bool {
 	return false
 }
 
-func loadGeoms(filepath string, singleFeature bool) ([]Geom, error) {
+func loadGeoms(filepath string) ([]Geom, error) {
 
+	fmt.Println(filepath)
 	f, err := os.Open(filepath)
 	if err != nil {
 		return nil, err
@@ -158,25 +160,11 @@ func loadGeoms(filepath string, singleFeature bool) ([]Geom, error) {
 		return nil, err
 	}
 
-	var features []*geojson.Feature
-
-	if singleFeature {
-		f, err := geojson.UnmarshalFeature(b)
-		if err != nil {
-			return nil, err
-		}
-		features = append(features, f)
-	} else {
-		fc, err := geojson.UnmarshalFeatureCollection(b)
-		if err != nil {
-			return nil, err
-		}
-		features = append(features, fc.Features...)
-	}
+	newFeatures := unmarshalFeatureOrFeatureCollection(b)
 
-	geoms := make([]Geom, len(features))
-	for i := range features {
-		fg := features[i].Geometry
+	geoms := make([]Geom, len(newFeatures))
+	for i := range newFeatures {
+		fg := newFeatures[i].Geometry
 		switch fg.Type {
 		case "Polygon":
 			geoms[i] = Geom{fg.Polygon}
@@ -189,3 +177,18 @@ func loadGeoms(filepath string, singleFeature bool) ([]Geom, error) {
 
 	return geoms, nil
 }
+
+func unmarshalFeatureOrFeatureCollection(b []byte) []*geojson.Feature {
+	feature, err := geojson.UnmarshalFeature(b)
+	if err != nil {
+		return nil
+	}
+	if feature.Type != "FeatureCollection" {
+		return []*geojson.Feature{feature}
+	}
+	fc, err := geojson.UnmarshalFeatureCollection(b)
+	if err != nil {
+		return nil
+	}
+	return fc.Features
+}

flp.go

@@ -3,7 +3,8 @@ package polygol
 import "math"
 
 const (
-	epsilon = float64(7.)/3 - float64(4.)/3 - float64(1.)
+	// epsilon = float64(7.)/3 - float64(4.)/3 - float64(1.)
+	epsilon = 2e-12
 )
 
 var (

flp_test.go

@@ -2,7 +2,7 @@ package polygol
 
 import "testing"
 
-func TestCompare(t *testing.T) {
+func TestFlpCompare(t *testing.T) {
 	var a, b float64
 
 	// exactly equal

geojson/geojson.go

@@ -116,10 +116,12 @@ func decodePolygonSet(data interface{}) ([][][][]float64, error) {
 }
 
 type Feature struct {
+	Type     string    `json:"type"`
 	Geometry *Geometry `json:"geometry"`
 }
 
 type FeatureCollection struct {
+	Type     string     `json:"type"`
 	Features []*Feature `json:"features"`
 }
 

geom-in_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 )
 
-func TestRingIn(t *testing.T) {
+func TestGeomInRingIn(t *testing.T) {
 	var ringIn *ringIn
 	var err error
 	var ring [][]float64
@@ -44,7 +44,7 @@ func TestRingIn(t *testing.T) {
 	expect(t, !ringIn.isExterior)
 }
 
-func TestPolyIn(t *testing.T) {
+func TestGeomInPolyIn(t *testing.T) {
 
 	op := newOperation("")
 
@@ -66,7 +66,7 @@ func TestPolyIn(t *testing.T) {
 	expect(t, len(polyIn.getSweepEvents()) == 22)
 }
 
-func TestmultiPolyIn(t *testing.T) {
+func TestGeomInMultiPolyIn(t *testing.T) {
 
 	var multiPolyIn *multiPolyIn
 	var err error
@@ -119,3 +119,54 @@ func TestmultiPolyIn(t *testing.T) {
 	}, false)
 	expect(t, err != nil)
 }
+
+func TestGeomInRingInIndexOf(t *testing.T) {
+	r1 := &ringIn{}
+	r2 := &ringIn{}
+	r3 := &ringIn{}
+	r4 := &ringIn{}
+	r5 := &ringIn{}
+	r6 := &ringIn{}
+
+	ringIns := []*ringIn{r1, r2, r3, r4, r5}
+	expect(t, r1.indexOf(ringIns) == 0)
+	expect(t, r2.indexOf(ringIns) == 1)
+	expect(t, r3.indexOf(ringIns) == 2)
+	expect(t, r4.indexOf(ringIns) == 3)
+	expect(t, r5.indexOf(ringIns) == 4)
+	expect(t, r6.indexOf(ringIns) == -1)
+}
+
+func TestGeomInPolyInIndexOf(t *testing.T) {
+	p1 := &polyIn{}
+	p2 := &polyIn{}
+	p3 := &polyIn{}
+	p4 := &polyIn{}
+	p5 := &polyIn{}
+	p6 := &polyIn{}
+
+	polyIns := []*polyIn{p1, p2, p3, p4, p5}
+	expect(t, p1.indexOf(polyIns) == 0)
+	expect(t, p2.indexOf(polyIns) == 1)
+	expect(t, p3.indexOf(polyIns) == 2)
+	expect(t, p4.indexOf(polyIns) == 3)
+	expect(t, p5.indexOf(polyIns) == 4)
+	expect(t, p6.indexOf(polyIns) == -1)
+}
+
+func TestGeomInMultiPolyInIndexOf(t *testing.T) {
+	mp1 := &multiPolyIn{}
+	mp2 := &multiPolyIn{}
+	mp3 := &multiPolyIn{}
+	mp4 := &multiPolyIn{}
+	mp5 := &multiPolyIn{}
+	mp6 := &multiPolyIn{}
+
+	multiPolyIns := []*multiPolyIn{mp1, mp2, mp3, mp4, mp5}
+	expect(t, mp1.indexOf(multiPolyIns) == 0)
+	expect(t, mp2.indexOf(multiPolyIns) == 1)
+	expect(t, mp3.indexOf(multiPolyIns) == 2)
+	expect(t, mp4.indexOf(multiPolyIns) == 3)
+	expect(t, mp5.indexOf(multiPolyIns) == 4)
+	expect(t, mp6.indexOf(multiPolyIns) == -1)
+}

geom-out.go

@@ -38,7 +38,9 @@ func newRingOutFromSegments(allSegments []*segment) ([]*ringOut, error) {
 	ringsOut := []*ringOut{}
 
 	for i := 0; i < len(allSegments); i++ {
+
 		segment := allSegments[i]
+
 		if !segment.isInResult() || segment.ringOut != nil {
 			continue
 		}
@@ -347,5 +349,3 @@ func (mpo *multiPolyOut) composePolys(rings []*ringOut) []*polyOut {
 	}
 	return polys
 }
-
-//////////////