fix #782 (bring vendor into the main tree)

vendor/github.com/tidwall/rtree/.travis.yml

@@ -0,0 +1 @@
+language: go

vendor/github.com/tidwall/rtree/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016 Josh Baker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/tidwall/rtree/README.md

@@ -0,0 +1,22 @@
+RTree implementation for Go
+===========================
+
+[![Build Status](https://travis-ci.org/tidwall/rtree.svg?branch=master)](https://travis-ci.org/tidwall/rtree)
+[![GoDoc](https://godoc.org/github.com/tidwall/rtree?status.svg)](https://godoc.org/github.com/tidwall/rtree)
+
+This package provides an in-memory R-Tree implementation for Go, useful as a spatial data structure.
+It has support for 1-20 dimensions, and can store and search multidimensions interchangably in the same tree.
+
+Authors
+-------
+* 1983 Original algorithm and test code by Antonin Guttman and Michael Stonebraker, UC Berkely
+* 1994 ANCI C ported from original test code by Melinda Green 
+* 1995 Sphere volume fix for degeneracy problem submitted by Paul Brook
+* 2004 Templated C++ port by Greg Douglas
+* 2016 Go port by Josh Baker
+* 2018 Added kNN and merged in some of the RBush logic by Vladimir Agafonkin
+
+License
+-------
+RTree source code is available under the MIT License.
+

vendor/github.com/tidwall/rtree/base/knn.go

@@ -0,0 +1,98 @@
+package base
+
+import (
+	"github.com/tidwall/tinyqueue"
+)
+
+type queueItem struct {
+	node   *treeNode
+	isItem bool
+	dist   float64
+}
+
+func (item *queueItem) Less(b tinyqueue.Item) bool {
+	return item.dist < b.(*queueItem).dist
+}
+
+// KNN returns items nearest to farthest. The dist param is the "box distance".
+func (tr *RTree) KNN(min, max []float64, center bool, iter func(item interface{}, dist float64) bool) bool {
+	var isBox bool
+	knnPoint := make([]float64, tr.dims)
+
+	bbox := &treeNode{min: min, max: max}
+
+	for i := 0; i < tr.dims; i++ {
+		knnPoint[i] = (bbox.min[i] + bbox.max[i]) / 2
+		if !isBox && bbox.min[i] != bbox.max[i] {
+			isBox = true
+		}
+	}
+	node := tr.data
+	queue := tinyqueue.New(nil)
+	for node != nil {
+		for i := 0; i < node.count; i++ {
+			child := node.children[i]
+			var dist float64
+			if isBox {
+				dist = boxDistRect(bbox, child)
+			} else {
+				dist = boxDistPoint(knnPoint, child)
+			}
+			queue.Push(&queueItem{node: child, isItem: node.leaf, dist: dist})
+		}
+		for queue.Len() > 0 && queue.Peek().(*queueItem).isItem {
+			item := queue.Pop().(*queueItem)
+			if !iter(item.node.unsafeItem().item, item.dist) {
+				return false
+			}
+		}
+		last := queue.Pop()
+		if last != nil {
+			node = (*treeNode)(last.(*queueItem).node)
+		} else {
+			node = nil
+		}
+	}
+	return true
+}
+
+func boxDistRect(a, b *treeNode) float64 {
+	var dist float64
+	for i := 0; i < len(a.min); i++ {
+		var min, max float64
+		if a.min[i] > b.min[i] {
+			min = a.min[i]
+		} else {
+			min = b.min[i]
+		}
+		if a.max[i] < b.max[i] {
+			max = a.max[i]
+		} else {
+			max = b.max[i]
+		}
+		squared := min - max
+		if squared > 0 {
+			dist += squared * squared
+		}
+	}
+	return dist
+}
+
+func boxDistPoint(point []float64, childBox *treeNode) float64 {
+	var dist float64
+	for i := 0; i < len(point); i++ {
+		d := axisDist(point[i], childBox.min[i], childBox.max[i])
+		dist += d * d
+	}
+	return dist
+}
+
+func axisDist(k, min, max float64) float64 {
+	if k < min {
+		return min - k
+	}
+	if k <= max {
+		return 0
+	}
+	return k - max
+}

vendor/github.com/tidwall/rtree/base/load.go

@@ -0,0 +1,97 @@
+package base
+
+import "math"
+
+// Load bulk load items into the R-tree.
+func (tr *RTree) Load(mins, maxs [][]float64, items []interface{}) {
+	if len(items) < tr.minEntries {
+		for i := 0; i < len(items); i++ {
+			tr.Insert(mins[i], maxs[i], items[i])
+		}
+		return
+	}
+
+	// prefill the items
+	fitems := make([]*treeNode, len(items))
+	for i := 0; i < len(items); i++ {
+		item := &treeItem{min: mins[i], max: maxs[i], item: items[i]}
+		fitems[i] = item.unsafeNode()
+	}
+
+	// following equations are defined in the paper describing OMT
+	N := len(fitems)
+	M := tr.maxEntries
+	h := int(math.Ceil(math.Log(float64(N)) / math.Log(float64(M))))
+	Nsubtree := int(math.Pow(float64(M), float64(h-1)))
+	S := int(math.Ceil(math.Sqrt(float64(N) / float64(Nsubtree))))
+
+	// sort by the initial axis
+	axis := 0
+	sortByAxis(fitems, axis)
+
+	// build the root node. it's split differently from the subtrees.
+	children := make([]*treeNode, 0, S)
+	for i := 0; i < S; i++ {
+		var part []*treeNode
+		if i == S-1 {
+			// last split
+			part = fitems[len(fitems)/S*i:]
+		} else {
+			part = fitems[len(fitems)/S*i : len(fitems)/S*(i+1)]
+		}
+		children = append(children, tr.omt(part, h-1, axis+1))
+	}
+
+	node := tr.createNode(children)
+	node.leaf = false
+	node.height = h
+	tr.calcBBox(node)
+
+	if tr.data.count == 0 {
+		// save as is if tree is empty
+		tr.data = node
+	} else if tr.data.height == node.height {
+		// split root if trees have the same height
+		tr.splitRoot(tr.data, node)
+	} else {
+		if tr.data.height < node.height {
+			// swap trees if inserted one is bigger
+			tr.data, node = node, tr.data
+		}
+
+		// insert the small tree into the large tree at appropriate level
+		tr.insert(node, nil, tr.data.height-node.height-1, true)
+	}
+}
+
+func (tr *RTree) omt(fitems []*treeNode, h, axis int) *treeNode {
+	if len(fitems) <= tr.maxEntries {
+		// reached leaf level; return leaf
+		children := make([]*treeNode, len(fitems))
+		copy(children, fitems)
+		node := tr.createNode(children)
+		node.height = h
+		tr.calcBBox(node)
+		return node
+	}
+
+	// sort the items on a different axis than the previous level.
+	sortByAxis(fitems, axis%tr.dims)
+	children := make([]*treeNode, 0, tr.maxEntries)
+	partsz := len(fitems) / tr.maxEntries
+	for i := 0; i < tr.maxEntries; i++ {
+		var part []*treeNode
+		if i == tr.maxEntries-1 {
+			// last part
+			part = fitems[partsz*i:]
+		} else {
+			part = fitems[partsz*i : partsz*(i+1)]
+		}
+		children = append(children, tr.omt(part, h-1, axis+1))
+	}
+	node := tr.createNode(children)
+	node.height = h
+	node.leaf = false
+	tr.calcBBox(node)
+	return node
+}

vendor/github.com/tidwall/rtree/base/rtree.go

@@ -0,0 +1,673 @@
+package base
+
+import (
+	"math"
+	"unsafe"
+)
+
+// precalculate infinity
+var mathInfNeg = math.Inf(-1)
+var mathInfPos = math.Inf(+1)
+
+type treeNode struct {
+	min, max []float64
+	children []*treeNode
+	count    int
+	height   int
+	leaf     bool
+}
+
+func (node *treeNode) unsafeItem() *treeItem {
+	return (*treeItem)(unsafe.Pointer(node))
+}
+
+func (tr *RTree) createNode(children []*treeNode) *treeNode {
+	n := &treeNode{
+		height:   1,
+		leaf:     true,
+		children: make([]*treeNode, tr.maxEntries+1),
+	}
+	if len(children) > 0 {
+		n.count = len(children)
+		copy(n.children[:n.count], children)
+	}
+	n.min = make([]float64, tr.dims)
+	n.max = make([]float64, tr.dims)
+	for i := 0; i < tr.dims; i++ {
+		n.min[i] = mathInfPos
+		n.max[i] = mathInfNeg
+	}
+	return n
+}
+
+func (node *treeNode) extend(b *treeNode) {
+	for i := 0; i < len(node.min); i++ {
+		if b.min[i] < node.min[i] {
+			node.min[i] = b.min[i]
+		}
+		if b.max[i] > node.max[i] {
+			node.max[i] = b.max[i]
+		}
+	}
+}
+
+func (node *treeNode) area() float64 {
+	area := node.max[0] - node.min[0]
+	for i := 1; i < len(node.min); i++ {
+		area *= node.max[i] - node.min[i]
+	}
+	return area
+}
+
+func (node *treeNode) enlargedAreaAxis(b *treeNode, axis int) float64 {
+	var max, min float64
+	if b.max[axis] > node.max[axis] {
+		max = b.max[axis]
+	} else {
+		max = node.max[axis]
+	}
+	if b.min[axis] < node.min[axis] {
+		min = b.min[axis]
+	} else {
+		min = node.min[axis]
+	}
+	return max - min
+}
+
+func (node *treeNode) enlargedArea(b *treeNode) float64 {
+	area := node.enlargedAreaAxis(b, 0)
+	for i := 1; i < len(node.min); i++ {
+		area *= node.enlargedAreaAxis(b, i)
+	}
+	return area
+}
+
+func (node *treeNode) intersectionAreaAxis(b *treeNode, axis int) float64 {
+	var max, min float64
+	if node.max[axis] < b.max[axis] {
+		max = node.max[axis]
+	} else {
+		max = b.max[axis]
+	}
+	if node.min[axis] > b.min[axis] {
+		min = node.min[axis]
+	} else {
+		min = b.min[axis]
+	}
+	if max > min {
+		return max - min
+	}
+	return 0
+}
+func (node *treeNode) intersectionArea(b *treeNode) float64 {
+	area := node.intersectionAreaAxis(b, 0)
+	for i := 1; i < len(node.min); i++ {
+		area *= node.intersectionAreaAxis(b, i)
+	}
+	return area
+}
+func (node *treeNode) margin() float64 {
+	margin := node.max[0] - node.min[0]
+	for i := 1; i < len(node.min); i++ {
+		margin += node.max[i] - node.min[i]
+	}
+	return margin
+}
+
+type result int
+
+const (
+	not        result = 0
+	intersects result = 1
+	contains   result = 2
+)
+
+func (node *treeNode) overlaps(b *treeNode) result {
+	for i := 0; i < len(node.min); i++ {
+		if b.min[i] > node.max[i] || b.max[i] < node.min[i] {
+			return not
+		}
+		if node.min[i] > b.min[i] || b.max[i] > node.max[i] {
+			i++
+			for ; i < len(node.min); i++ {
+				if b.min[i] > node.max[i] || b.max[i] < node.min[i] {
+					return not
+				}
+			}
+			return intersects
+		}
+	}
+	return contains
+}
+
+func (node *treeNode) intersects(b *treeNode) bool {
+	for i := 0; i < len(node.min); i++ {
+		if b.min[i] > node.max[i] || b.max[i] < node.min[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func (node *treeNode) findItem(item interface{}) int {
+	for i := 0; i < node.count; i++ {
+		if node.children[i].unsafeItem().item == item {
+			return i
+		}
+	}
+	return -1
+}
+
+func (node *treeNode) contains(b *treeNode) bool {
+	for i := 0; i < len(node.min); i++ {
+		if node.min[i] > b.min[i] || b.max[i] > node.max[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func (node *treeNode) childCount() int {
+	if node.leaf {
+		return node.count
+	}
+	var n int
+	for i := 0; i < node.count; i++ {
+		n += node.children[i].childCount()
+	}
+	return n
+}
+
+type treeItem struct {
+	min, max []float64
+	item     interface{}
+}
+
+func (item *treeItem) unsafeNode() *treeNode {
+	return (*treeNode)(unsafe.Pointer(item))
+}
+
+// RTree is an R-tree
+type RTree struct {
+	dims       int
+	maxEntries int
+	minEntries int
+	data       *treeNode // root node
+	// resusable fields, these help performance of common mutable operations.
+	reuse struct {
+		path    []*treeNode // for reinsertion path
+		indexes []int       // for remove function
+		stack   []int       // for bulk loading
+	}
+}
+
+// New creates a new R-tree
+func New(dims, maxEntries int) *RTree {
+	if dims <= 0 {
+		panic("invalid dimensions")
+	}
+
+	tr := &RTree{}
+	tr.dims = dims
+	tr.maxEntries = int(math.Max(4, float64(maxEntries)))
+	tr.minEntries = int(math.Max(2, math.Ceil(float64(tr.maxEntries)*0.4)))
+	tr.data = tr.createNode(nil)
+	return tr
+}
+
+// Insert inserts an item
+func (tr *RTree) Insert(min, max []float64, item interface{}) {
+	if len(min) != tr.dims || len(max) != tr.dims {
+		panic("invalid dimensions")
+	}
+	if item == nil {
+		panic("nil item")
+	}
+	bbox := treeNode{min: min, max: max}
+	tr.insert(&bbox, item, tr.data.height-1, false)
+}
+
+func (tr *RTree) insert(bbox *treeNode, item interface{}, level int, isNode bool) {
+	tr.reuse.path = tr.reuse.path[:0]
+	node, insertPath := tr.chooseSubtree(bbox, tr.data, level, tr.reuse.path)
+	if item == nil {
+		// item is only nil when bulk loading a node
+		if node.leaf {
+			panic("loading node into leaf")
+		}
+		node.children[node.count] = bbox
+		node.count++
+	} else {
+		ti := &treeItem{min: bbox.min, max: bbox.max, item: item}
+		node.children[node.count] = ti.unsafeNode()
+		node.count++
+	}
+	node.extend(bbox)
+	for level >= 0 {
+		if insertPath[level].count > tr.maxEntries {
+			insertPath = tr.split(insertPath, level)
+			level--
+		} else {
+			break
+		}
+	}
+	tr.adjustParentBBoxes(bbox, insertPath, level)
+	tr.reuse.path = insertPath
+}
+
+func (tr *RTree) adjustParentBBoxes(bbox *treeNode, path []*treeNode, level int) {
+	// adjust bboxes along the given tree path
+	for i := level; i >= 0; i-- {
+		path[i].extend(bbox)
+	}
+}
+
+func (tr *RTree) chooseSubtree(bbox, node *treeNode, level int, path []*treeNode) (*treeNode, []*treeNode) {
+	var targetNode *treeNode
+	var area, enlargement, minArea, minEnlargement float64
+	for {
+		path = append(path, node)
+		if node.leaf || len(path)-1 == level {
+			break
+		}
+		minEnlargement = mathInfPos
+		minArea = minEnlargement
+		for i := 0; i < node.count; i++ {
+			child := node.children[i]
+			area = child.area()
+			enlargement = bbox.enlargedArea(child) - area
+			if enlargement < minEnlargement {
+				minEnlargement = enlargement
+				if area < minArea {
+					minArea = area
+				}
+				targetNode = child
+			} else if enlargement == minEnlargement {
+				if area < minArea {
+					minArea = area
+					targetNode = child
+				}
+			}
+		}
+		if targetNode != nil {
+			node = targetNode
+		} else if node.count > 0 {
+			node = (*treeNode)(node.children[0])
+		} else {
+			node = nil
+		}
+	}
+	return node, path
+}
+func (tr *RTree) split(insertPath []*treeNode, level int) []*treeNode {
+	var node = insertPath[level]
+	var M = node.count
+	var m = tr.minEntries
+
+	tr.chooseSplitAxis(node, m, M)
+	splitIndex := tr.chooseSplitIndex(node, m, M)
+
+	spliced := make([]*treeNode, node.count-splitIndex)
+	copy(spliced, node.children[splitIndex:])
+	node.count = splitIndex
+
+	newNode := tr.createNode(spliced)
+	newNode.height = node.height
+	newNode.leaf = node.leaf
+
+	tr.calcBBox(node)
+	tr.calcBBox(newNode)
+
+	if level != 0 {
+		insertPath[level-1].children[insertPath[level-1].count] = newNode
+		insertPath[level-1].count++
+	} else {
+		tr.splitRoot(node, newNode)
+	}
+	return insertPath
+}
+func (tr *RTree) chooseSplitIndex(node *treeNode, m, M int) int {
+	var i int
+	var bbox1, bbox2 *treeNode
+	var overlap, area, minOverlap, minArea float64
+	var index int
+
+	minArea = mathInfPos
+	minOverlap = minArea
+
+	for i = m; i <= M-m; i++ {
+		bbox1 = tr.distBBox(node, 0, i, nil)
+		bbox2 = tr.distBBox(node, i, M, nil)
+
+		overlap = bbox1.intersectionArea(bbox2)
+		area = bbox1.area() + bbox2.area()
+
+		// choose distribution with minimum overlap
+		if overlap < minOverlap {
+			minOverlap = overlap
+			index = i
+
+			if area < minArea {
+				minArea = area
+			}
+		} else if overlap == minOverlap {
+			// otherwise choose distribution with minimum area
+			if area < minArea {
+				minArea = area
+				index = i
+			}
+		}
+	}
+	return index
+}
+func (tr *RTree) calcBBox(node *treeNode) {
+	tr.distBBox(node, 0, node.count, node)
+}
+func (tr *RTree) chooseSplitAxis(node *treeNode, m, M int) {
+	minMargin := tr.allDistMargin(node, m, M, 0)
+	var minAxis int
+	for axis := 1; axis < tr.dims; axis++ {
+		margin := tr.allDistMargin(node, m, M, axis)
+		if margin < minMargin {
+			minMargin = margin
+			minAxis = axis
+		}
+	}
+	if minAxis < tr.dims {
+		tr.sortNodes(node, minAxis)
+	}
+}
+func (tr *RTree) splitRoot(node, newNode *treeNode) {
+	tr.data = tr.createNode([]*treeNode{node, newNode})
+	tr.data.height = node.height + 1
+	tr.data.leaf = false
+	tr.calcBBox(tr.data)
+}
+func (tr *RTree) distBBox(node *treeNode, k, p int, destNode *treeNode) *treeNode {
+	if destNode == nil {
+		destNode = tr.createNode(nil)
+	} else {
+		for i := 0; i < tr.dims; i++ {
+			destNode.min[i] = mathInfPos
+			destNode.max[i] = mathInfNeg
+		}
+	}
+	for i := k; i < p; i++ {
+		if node.leaf {
+			destNode.extend(node.children[i])
+		} else {
+			destNode.extend((*treeNode)(node.children[i]))
+		}
+	}
+	return destNode
+}
+func (tr *RTree) allDistMargin(node *treeNode, m, M int, axis int) float64 {
+	tr.sortNodes(node, axis)
+
+	var leftBBox = tr.distBBox(node, 0, m, nil)
+	var rightBBox = tr.distBBox(node, M-m, M, nil)
+	var margin = leftBBox.margin() + rightBBox.margin()
+
+	var i int
+
+	if node.leaf {
+		for i = m; i < M-m; i++ {
+			leftBBox.extend(node.children[i])
+			margin += leftBBox.margin()
+		}
+		for i = M - m - 1; i >= m; i-- {
+			leftBBox.extend(node.children[i])
+			margin += rightBBox.margin()
+		}
+	} else {
+		for i = m; i < M-m; i++ {
+			child := (*treeNode)(node.children[i])
+			leftBBox.extend(child)
+			margin += leftBBox.margin()
+		}
+		for i = M - m - 1; i >= m; i-- {
+			child := (*treeNode)(node.children[i])
+			leftBBox.extend(child)
+			margin += rightBBox.margin()
+		}
+	}
+	return margin
+}
+func (tr *RTree) sortNodes(node *treeNode, axis int) {
+	sortByAxis(node.children[:node.count], axis)
+}
+
+func sortByAxis(items []*treeNode, axis int) {
+	if len(items) < 2 {
+		return
+	}
+	left, right := 0, len(items)-1
+	pivotIndex := len(items) / 2
+	items[pivotIndex], items[right] = items[right], items[pivotIndex]
+	for i := range items {
+		if items[i].min[axis] < items[right].min[axis] {
+			items[i], items[left] = items[left], items[i]
+			left++
+		}
+	}
+	items[left], items[right] = items[right], items[left]
+	sortByAxis(items[:left], axis)
+	sortByAxis(items[left+1:], axis)
+}
+
+// Search searches the tree for items in the input rectangle
+func (tr *RTree) Search(min, max []float64, iter func(item interface{}) bool) bool {
+	bbox := &treeNode{min: min, max: max}
+	if !tr.data.intersects(bbox) {
+		return true
+	}
+	return tr.search(tr.data, bbox, iter)
+}
+
+func (tr *RTree) search(node, bbox *treeNode, iter func(item interface{}) bool) bool {
+	if node.leaf {
+		for i := 0; i < node.count; i++ {
+			if bbox.intersects(node.children[i]) {
+				if !iter(node.children[i].unsafeItem().item) {
+					return false
+				}
+			}
+		}
+	} else {
+		for i := 0; i < node.count; i++ {
+			r := bbox.overlaps(node.children[i])
+			if r == intersects {
+				if !tr.search(node.children[i], bbox, iter) {
+					return false
+				}
+			} else if r == contains {
+				if !scan(node.children[i], iter) {
+					return false
+				}
+			}
+		}
+	}
+	return true
+}
+
+func (tr *RTree) IsEmpty() bool {
+	empty := true
+	tr.Scan(func(item interface{}) bool {
+		empty = false
+		return false
+	})
+	return empty
+}
+
+// Remove removes an item from the R-tree.
+func (tr *RTree) Remove(min, max []float64, item interface{}) {
+	bbox := &treeNode{min: min, max: max}
+	tr.remove(bbox, item)
+}
+
+func (tr *RTree) remove(bbox *treeNode, item interface{}) {
+	path := tr.reuse.path[:0]
+	indexes := tr.reuse.indexes[:0]
+
+	var node = tr.data
+	var i int
+	var parent *treeNode
+	var index int
+	var goingUp bool
+
+	for node != nil || len(path) != 0 {
+		if node == nil {
+			node = path[len(path)-1]
+			path = path[:len(path)-1]
+			if len(path) == 0 {
+				parent = nil
+			} else {
+				parent = path[len(path)-1]
+			}
+			i = indexes[len(indexes)-1]
+			indexes = indexes[:len(indexes)-1]
+			goingUp = true
+		}
+
+		if node.leaf {
+			index = node.findItem(item)
+			if index != -1 {
+				// item found, remove the item and condense tree upwards
+				copy(node.children[index:], node.children[index+1:])
+				node.children[node.count-1] = nil
+				node.count--
+				path = append(path, node)
+				tr.condense(path)
+				goto done
+			}
+		}
+		if !goingUp && !node.leaf && node.contains(bbox) { // go down
+			path = append(path, node)
+			indexes = append(indexes, i)
+			i = 0
+			parent = node
+			node = (*treeNode)(node.children[0])
+		} else if parent != nil { // go right
+			i++
+			if i == parent.count {
+				node = nil
+			} else {
+				node = (*treeNode)(parent.children[i])
+			}
+			goingUp = false
+		} else {
+			node = nil
+		}
+	}
+done:
+	tr.reuse.path = path
+	tr.reuse.indexes = indexes
+	return
+}
+func (tr *RTree) condense(path []*treeNode) {
+	// go through the path, removing empty nodes and updating bboxes
+	var siblings []*treeNode
+	for i := len(path) - 1; i >= 0; i-- {
+		if path[i].count == 0 {
+			if i > 0 {
+				siblings = path[i-1].children[:path[i-1].count]
+				index := -1
+				for j := 0; j < len(siblings); j++ {
+					if siblings[j] == path[i] {
+						index = j
+						break
+					}
+				}
+				copy(siblings[index:], siblings[index+1:])
+				siblings[len(siblings)-1] = nil
+				path[i-1].count--
+				//siblings = siblings[:len(siblings)-1]
+				//path[i-1].children = siblings
+			} else {
+				tr.data = tr.createNode(nil) // clear tree
+			}
+		} else {
+			tr.calcBBox(path[i])
+		}
+	}
+}
+
+// Count returns the number of items in the R-tree.
+func (tr *RTree) Count() int {
+	return tr.data.childCount()
+}
+
+// Traverse iterates over the entire R-tree and includes all nodes and items.
+func (tr *RTree) Traverse(iter func(min, max []float64, level int, item interface{}) bool) bool {
+	return tr.traverse(tr.data, iter)
+}
+
+func (tr *RTree) traverse(node *treeNode, iter func(min, max []float64, level int, item interface{}) bool) bool {
+	if !iter(node.min, node.max, int(node.height), nil) {
+		return false
+	}
+	if node.leaf {
+		for i := 0; i < node.count; i++ {
+			child := node.children[i]
+			if !iter(child.min, child.max, 0, child.unsafeItem().item) {
+				return false
+			}
+		}
+	} else {
+		for i := 0; i < node.count; i++ {
+			child := node.children[i]
+			if !tr.traverse(child, iter) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// Scan iterates over the entire R-tree
+func (tr *RTree) Scan(iter func(item interface{}) bool) bool {
+	return scan(tr.data, iter)
+}
+
+func scan(node *treeNode, iter func(item interface{}) bool) bool {
+	if node.leaf {
+		for i := 0; i < node.count; i++ {
+			child := node.children[i]
+			if !iter(child.unsafeItem().item) {
+				return false
+			}
+		}
+	} else {
+		for i := 0; i < node.count; i++ {
+			child := node.children[i]
+			if !scan(child, iter) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// Bounds returns the bounding box of the entire R-tree
+func (tr *RTree) Bounds() (min, max []float64) {
+	if tr.data.count > 0 {
+		return tr.data.min, tr.data.max
+	}
+	return make([]float64, tr.dims), make([]float64, tr.dims)
+}
+
+// Complexity returns the complexity of the R-tree. The higher the value, the
+// more complex the tree. The value of 1 is the lowest.
+func (tr *RTree) Complexity() float64 {
+	var nodeCount int
+	var itemCount int
+	tr.Traverse(func(_, _ []float64, level int, _ interface{}) bool {
+		if level == 0 {
+			itemCount++
+		} else {
+			nodeCount++
+		}
+		return true
+	})
+	return float64(tr.maxEntries*nodeCount) / float64(itemCount)
+}

vendor/github.com/tidwall/rtree/rtree.go

@@ -0,0 +1,278 @@
+package rtree
+
+import (
+	"math"
+	"sync"
+
+	"github.com/tidwall/rtree/base"
+)
+
+type Iterator func(item Item) bool
+type Item interface {
+	Rect(ctx interface{}) (min []float64, max []float64)
+}
+
+type RTree struct {
+	dims       int
+	maxEntries int
+	ctx        interface{}
+	trs        []*base.RTree
+	used       int
+}
+
+func New(ctx interface{}) *RTree {
+	tr := &RTree{
+		ctx:        ctx,
+		dims:       20,
+		maxEntries: 13,
+	}
+	tr.trs = make([]*base.RTree, 20)
+	return tr
+}
+
+func (tr *RTree) Insert(item Item) {
+	if item == nil {
+		panic("nil item")
+	}
+	min, max := item.Rect(tr.ctx)
+	if len(min) != len(max) {
+		return // just return
+		panic("invalid item rectangle")
+	}
+	if len(min) < 1 || len(min) > len(tr.trs) {
+		return // just return
+		panic("invalid dimension")
+	}
+	btr := tr.trs[len(min)-1]
+	if btr == nil {
+		btr = base.New(len(min), tr.maxEntries)
+		tr.trs[len(min)-1] = btr
+		tr.used++
+	}
+	amin := make([]float64, len(min))
+	amax := make([]float64, len(max))
+	for i := 0; i < len(min); i++ {
+		amin[i], amax[i] = min[i], max[i]
+	}
+	btr.Insert(amin, amax, item)
+}
+
+func (tr *RTree) Remove(item Item) {
+	if item == nil {
+		panic("nil item")
+	}
+	min, max := item.Rect(tr.ctx)
+	if len(min) != len(max) {
+		return // just return
+		panic("invalid item rectangle")
+	}
+	if len(min) < 1 || len(min) > len(tr.trs) {
+		return // just return
+		panic("invalid dimension")
+	}
+	btr := tr.trs[len(min)-1]
+	if btr == nil {
+		return
+	}
+	amin := make([]float64, len(min))
+	amax := make([]float64, len(max))
+	for i := 0; i < len(min); i++ {
+		amin[i], amax[i] = min[i], max[i]
+	}
+	btr.Remove(amin, amax, item)
+	if btr.IsEmpty() {
+		tr.trs[len(min)-1] = nil
+		tr.used--
+	}
+}
+func (tr *RTree) Reset() {
+	for i := 0; i < len(tr.trs); i++ {
+		tr.trs[i] = nil
+	}
+	tr.used = 0
+}
+func (tr *RTree) Count() int {
+	var count int
+	for _, btr := range tr.trs {
+		if btr != nil {
+			count += btr.Count()
+		}
+	}
+	return count
+}
+
+func (tr *RTree) Search(bounds Item, iter Iterator) {
+	if bounds == nil {
+		panic("nil bounds being used for search")
+	}
+	min, max := bounds.Rect(tr.ctx)
+	if len(min) != len(max) {
+		return // just return
+		panic("invalid item rectangle")
+	}
+	if len(min) < 1 || len(min) > len(tr.trs) {
+		return // just return
+		panic("invalid dimension")
+	}
+	used := tr.used
+	for i, btr := range tr.trs {
+		if used == 0 {
+			break
+		}
+		if btr != nil {
+			if !search(btr, min, max, i+1, iter) {
+				return
+			}
+			used--
+		}
+	}
+}
+func search(btr *base.RTree, min, max []float64, dims int, iter Iterator) bool {
+	amin := make([]float64, dims)
+	amax := make([]float64, dims)
+	for i := 0; i < dims; i++ {
+		if i < len(min) {
+			amin[i] = min[i]
+			amax[i] = max[i]
+		} else {
+			amin[i] = math.Inf(-1)
+			amax[i] = math.Inf(+1)
+		}
+	}
+	var ended bool
+	btr.Search(amin, amax, func(item interface{}) bool {
+		if !iter(item.(Item)) {
+			ended = true
+			return false
+		}
+		return true
+	})
+	return !ended
+}
+
+func (tr *RTree) KNN(bounds Item, center bool, iter func(item Item, dist float64) bool) {
+	if bounds == nil {
+		panic("nil bounds being used for search")
+	}
+	min, max := bounds.Rect(tr.ctx)
+	if len(min) != len(max) {
+		return // just return
+		panic("invalid item rectangle")
+	}
+	if len(min) < 1 || len(min) > len(tr.trs) {
+		return // just return
+		panic("invalid dimension")
+	}
+
+	if tr.used == 0 {
+		return
+	}
+	if tr.used == 1 {
+		for i, btr := range tr.trs {
+			if btr != nil {
+				knn(btr, min, max, center, i+1, func(item interface{}, dist float64) bool {
+					return iter(item.(Item), dist)
+				})
+				break
+			}
+		}
+		return
+	}
+
+	type queueT struct {
+		done bool
+		step int
+		item Item
+		dist float64
+	}
+
+	var mu sync.Mutex
+	var ended bool
+	queues := make(map[int][]queueT)
+	cond := sync.NewCond(&mu)
+	for i, btr := range tr.trs {
+		if btr != nil {
+			dims := i + 1
+			mu.Lock()
+			queues[dims] = []queueT{}
+			cond.Signal()
+			mu.Unlock()
+			go func(dims int, btr *base.RTree) {
+				knn(btr, min, max, center, dims, func(item interface{}, dist float64) bool {
+					mu.Lock()
+					if ended {
+						mu.Unlock()
+						return false
+					}
+					queues[dims] = append(queues[dims], queueT{item: item.(Item), dist: dist})
+					cond.Signal()
+					mu.Unlock()
+					return true
+				})
+				mu.Lock()
+				queues[dims] = append(queues[dims], queueT{done: true})
+				cond.Signal()
+				mu.Unlock()
+			}(dims, btr)
+		}
+	}
+	mu.Lock()
+	for {
+		ready := true
+		for i := range queues {
+			if len(queues[i]) == 0 {
+				ready = false
+				break
+			}
+			if queues[i][0].done {
+				delete(queues, i)
+			}
+		}
+		if len(queues) == 0 {
+			break
+		}
+		if ready {
+			var j int
+			var minDist float64
+			var minItem Item
+			var minQueue int
+			for i := range queues {
+				if j == 0 || queues[i][0].dist < minDist {
+					minDist = queues[i][0].dist
+					minItem = queues[i][0].item
+					minQueue = i
+				}
+			}
+			queues[minQueue] = queues[minQueue][1:]
+			if !iter(minItem, minDist) {
+				ended = true
+				break
+			}
+			continue
+		}
+		cond.Wait()
+	}
+	mu.Unlock()
+}
+func knn(btr *base.RTree, min, max []float64, center bool, dims int, iter func(item interface{}, dist float64) bool) bool {
+	amin := make([]float64, dims)
+	amax := make([]float64, dims)
+	for i := 0; i < dims; i++ {
+		if i < len(min) {
+			amin[i] = min[i]
+			amax[i] = max[i]
+		} else {
+			amin[i] = math.Inf(-1)
+			amax[i] = math.Inf(+1)
+		}
+	}
+	var ended bool
+	btr.KNN(amin, amax, center, func(item interface{}, dist float64) bool {
+		if !iter(item.(Item), dist) {
+			ended = true
+			return false
+		}
+		return true
+	})
+	return !ended
+}