postprocess: collision_ranker

Author: paulmach

config/spreadsheets/collision_rank.yaml

@@ -0,0 +1,77 @@
+package integrationtests
+
+import (
+	"testing"
+
+	"github.com/paulmach/osm"
+)
+
+func TestCollisionRank(t *testing.T) {
+	cases := []struct {
+		name string
+		tags osm.Tags
+		rank int
+	}{
+		{
+			name: "beach",
+			tags: osm.Tags{
+				{Key: "natural", Value: "beach"},
+				{Key: "name", Value: "Stinson Beach"},
+			},
+			rank: 534,
+		},
+		{
+			name: "population",
+			tags: osm.Tags{
+				{Key: "name", Value: "Berkeley"},
+				{Key: "population", Value: "120000"},
+				{Key: "place", Value: "city"},
+			},
+			rank: 350,
+		},
+		{
+			name: "population",
+			tags: osm.Tags{
+				{Key: "name", Value: "Berkeley"},
+				{Key: "population", Value: "210000"},
+				{Key: "place", Value: "city"},
+			},
+			rank: 347,
+		},
+		{
+			name: "building exit",
+			tags: osm.Tags{
+				{Key: "name", Value: "exit"},
+				{Key: "entrance", Value: "fire_exit"},
+			},
+			rank: 4303,
+		},
+		{
+			name: "no rank if no name",
+			tags: osm.Tags{
+				{Key: "building", Value: "true"},
+			},
+			rank: 0,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			data := &osm.OSM{
+				Nodes: osm.Nodes{{ID: 1, Visible: true, Version: 1, Tags: tc.tags}},
+			}
+
+			// run the request
+			tile := processOSM(t, data)
+
+			for name, layer := range tile {
+				for _, feature := range layer.Features {
+					r := feature.Properties.MustInt("collision_rank", 0)
+					if r != tc.rank {
+						t.Errorf("layer %v: incorrect rank: %v != %v", name, r, tc.rank)
+					}
+				}
+			}
+		})
+	}
+}

embeddedconfig/config.go

@@ -14,7 +14,7 @@ import (
 )
 
 // to copy the yaml data into the binary for easier loading.
-//go:generate go-bindata -pkg embeddedconfig -o embeddedconfig/config.go -prefix=config config/queries.yaml config/yaml/ config/spreadsheets/scale_rank/ config/spreadsheets/sort_rank/
+//go:generate go-bindata -pkg embeddedconfig -o embeddedconfig/config.go -prefix=config config/queries.yaml config/yaml/ config/spreadsheets/ config/spreadsheets/scale_rank/ config/spreadsheets/sort_rank/
 //go:generate gofmt -w embeddedconfig/config.go
 
 // Config is the full queries.yaml config file for this library.

integration_tests/collision_rank_test.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/paulmach/osmzen/filter"
 	"github.com/paulmach/osmzen/matcher"
+	"github.com/paulmach/osmzen/ranker"
 
 	"github.com/paulmach/orb"
 	"github.com/paulmach/orb/clip/smartclip"
@@ -63,7 +64,7 @@ var functions = map[string]func(*CompileContext, *Config) (Function, error){
 	"whitelist":                          compileWhitelist,
 	"quantize_height":                    compileQuantizeHeight,
 	"clamp_min_zoom":                     compileClampMinZoom,
-	"add_collision_rank":                 nil, // TODO, yes
+	"add_collision_rank":                 compileAddCollisionRank,
 }
 
 var (
@@ -206,6 +207,67 @@ func compileCSVMatchProperties(ctx *CompileContext, c *Config) (Function, error)
 	}, nil
 }
 
+type addCollisionRank struct {
+	Ranker *ranker.Ranker
+}
+
+func (f *addCollisionRank) Eval(ctx *Context, layers map[string]*geojson.FeatureCollection) {
+	for name, layer := range layers {
+		for _, feature := range layer.Features {
+
+			// hard coded version of the where clause in queries.yaml
+			add := false
+			if name == "pois" || hasName(feature) {
+				add = true
+			} else if _, ok := feature.Properties["ref"]; ok {
+				add = true
+			} else if _, ok := feature.Properties["shield_text"]; ok {
+				add = true
+			} else if _, ok := feature.Properties["bicycle_shield_text"]; ok {
+				add = true
+			} else if _, ok := feature.Properties["bus_shield_text"]; ok {
+				add = true
+			} else if _, ok := feature.Properties["walking_shield_text"]; ok {
+				add = true
+			} else if _, ok := feature.Properties["bicycle_shield_text"]; ok {
+				add = true
+			}
+
+			if add {
+				rank := f.Ranker.Rank(name, feature.Properties)
+				feature.Properties["collision_rank"] = rank
+			}
+		}
+	}
+}
+
+func compileAddCollisionRank(ctx *CompileContext, c *Config) (Function, error) {
+	data, err := ctx.Asset(c.Resources.Ranker.Path)
+	if err != nil {
+		return nil, err
+	}
+
+	r, err := ranker.Load(data)
+	if err != nil {
+		return nil, err
+	}
+
+	where := "layer_name == 'pois' or " +
+		"_has_name or " +
+		"ref is not None or " +
+		"shield_text is not None or " +
+		"bicycle_shield_text is not None or " +
+		"bus_shield_text is not None or " +
+		"walking_shield_text is not None"
+	if where != c.Params["where"] {
+		return nil, errors.Errorf("add_collision_rank: where has changed, it's hard coded")
+	}
+
+	return &addCollisionRank{
+		Ranker: r,
+	}, nil
+}
+
 type handleLabelPlacement struct {
 	Layers      []string
 	ClipFactors map[string]float64
@@ -579,7 +641,7 @@ func keyIsName(key string) bool {
 	}
 
 	// then any of the alternative forms of name
-	tagTameAlternates := []string{
+	tagNameAlternates := []string{
 		"int_name",
 		"loc_name",
 		"nat_name",
@@ -592,7 +654,7 @@ func keyIsName(key string) bool {
 		"name:short",
 	}
 
-	for _, alt := range tagTameAlternates {
+	for _, alt := range tagNameAlternates {
 		if strings.HasPrefix(key, alt) {
 			return true
 		}
@@ -601,6 +663,16 @@ func keyIsName(key string) bool {
 	return false
 }
 
+func hasName(feature *geojson.Feature) bool {
+	for k := range feature.Properties {
+		if keyIsName(k) {
+			return true
+		}
+	}
+
+	return false
+}
+
 type dropNames struct {
 	Layer     string
 	StartZoom float64

load.go

@@ -41,6 +41,11 @@ type Config struct {
 			InitFunc string `yaml:"init_fn"`
 			Path     string `yaml:"path"`
 		} `yaml:"matcher"`
+		Ranker struct {
+			Type     string `yaml:"type"`
+			InitFunc string `yaml:"init_fn"`
+			Path     string `yaml:"path"`
+		} `yaml:"ranker"`
 	} `yaml:"resources"`
 	Params map[interface{}]interface{} `yaml:"params"`
 }

postprocess/functions.go

@@ -0,0 +1,76 @@
+package ranker
+
+import "github.com/pkg/errors"
+
+// Condition is a matcher in the YAML file that can be evaluated.
+// It is not as full featured as filter.Condition but differs in that
+// it takes a string->interface{} map vs. a string->string.
+type Condition interface {
+	Eval(map[string]interface{}) bool
+}
+
+// CompileCondition compiles the matcher in the collision_rank YAML file so
+// it can be evaluated. YAML will decompile hashes into this map with
+// interface{} keys. We assume they are always strings.
+func CompileCondition(cond map[interface{}]interface{}) (Condition, error) {
+	conds := []Condition{}
+	for key, val := range cond {
+		switch key {
+		case "not":
+			c, err := CompileCondition(val.(map[interface{}]interface{}))
+			if err != nil {
+				return nil, err
+			}
+
+			conds = append(conds, &notCond{cond: c})
+		default:
+			// we want to only support comparable types. If the file adds
+			// nested hashes we need to do more work.
+			if _, ok := val.(map[interface{}]interface{}); ok {
+				return nil, errors.Errorf("compile: key %v is a hash", key)
+			}
+
+			conds = append(conds, &eqCond{
+				Key: key.(string),
+				Val: val,
+			})
+		}
+	}
+
+	if len(conds) == 1 {
+		return conds[0], nil
+	}
+
+	return &allCond{conds: conds}, nil
+}
+
+type eqCond struct {
+	Key string
+	Val interface{}
+}
+
+func (c *eqCond) Eval(vals map[string]interface{}) bool {
+	return vals[c.Key] == c.Val
+}
+
+type notCond struct {
+	cond Condition
+}
+
+func (c *notCond) Eval(vals map[string]interface{}) bool {
+	return !c.cond.Eval(vals)
+}
+
+type allCond struct {
+	conds []Condition
+}
+
+func (c *allCond) Eval(vals map[string]interface{}) bool {
+	for _, c := range c.conds {
+		if !c.Eval(vals) {
+			return false
+		}
+	}
+
+	return true
+}