rtree.go

// Copyright 2012 Daniel Connelly.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package rtreego is a library for efficiently storing and querying spatial data.
package rtreego

import (
	"fmt"
	"math"
	"reflect"
	"sort"

	"github.com/mohae/deepcopy"
)

// Comparator compares two spatials and returns whether they are equal.
type Comparator func(obj1, obj2 Spatial) (equal bool)

func defaultComparator(obj1, obj2 Spatial) bool {
	return obj1 == obj2
}

// Rtree represents an R-tree, a balanced search tree for storing and querying
// spatial objects.  Dim specifies the number of spatial dimensions and
// MinChildren/MaxChildren specify the minimum/maximum branching factors.
type Rtree struct {
	Dim         int
	MinChildren int
	MaxChildren int
	root        *node
	size        int    // 每次调用 Insert 都会加 1，调用 DeleteWithComparator 时会减 1
	height      uint32 // 不应超过 4294967295 层。层数太深，失去了使用树的意义

	// deleted is a temporary buffer to avoid memory allocations in Delete.
	// It is just an optimization and not part of the data structure.
	//
	// 一个临时缓冲区，用于在执行 “删除”（Delete）操作时避免内存分配。它仅仅是一种优化手段，并非数据结构的组成部分
	deleted []*node

	// FloatingPointTolerance is the tolerance to guard against floating point rounding errors during minMaxDist calculations.
	//
	// 在计算最小的最大距离(minMaxDist)过程中用于防范浮点舍入误差的容差。
	FloatingPointTolerance float64
}

// NewTree returns an Rtree. If the number of objects given on initialization
// is larger than max, the Rtree will be initialized using the Overlap
// Minimizing Top-down bulk-loading algorithm.
func NewTree(dim, min, max int, objs ...Spatial) *Rtree {
	rt := &Rtree{
		Dim:                    dim,
		MinChildren:            min,
		MaxChildren:            max,
		height:                 1,
		FloatingPointTolerance: 1e-6,
		root: &node{
			entries: []entry{},
			leaf:    true,
			level:   1,
		},
	}

	if len(objs) <= rt.MaxChildren {
		for _, obj := range objs {
			rt.Insert(obj)
		}
	} else {
		rt.bulkLoad(objs)
	}

	return rt
}

// GetRoot 返回当前存储在树中的当前根节点。
// 添加/删除节点，可能会导致根节点变化。
func (tree *Rtree) GetRoot() *node {
	return tree.root
}

// Size returns the number of objects currently stored in tree.
//
// 返回当前存储在树中的对象的数量。
func (tree *Rtree) Size() int {
	return tree.size
}

func (tree *Rtree) String() string {
	return "foo"
}

// Depth returns the maximum depth of tree.
//
// 返回树的最大深度。
func (tree *Rtree) Depth() uint32 {
	return tree.height
}

type dimSorter struct {
	dim  int
	objs []entry
}

func (s *dimSorter) Len() int {
	return len(s.objs)
}

func (s *dimSorter) Swap(i, j int) {
	s.objs[i], s.objs[j] = s.objs[j], s.objs[i]
}

func (s *dimSorter) Less(i, j int) bool {
	return s.objs[i].bb.p[s.dim] < s.objs[j].bb.p[s.dim]
}

// walkPartitions splits objs into slices of maximum k elements and
// iterates over these partitions.
//
// 将对象拆分成最大包含 k 个元素的切片，并对这些分区进行迭代
func walkPartitions(k int, objs []entry, iter func(parts []entry)) {
	n := (len(objs) + k - 1) / k // ceil(len(objs) / k)

	for i := 1; i < n; i++ {
		iter(objs[(i-1)*k : i*k])
	}
	iter(objs[(n-1)*k:])
}

func sortByDim(dim int, objs []entry) {
	sort.Sort(&dimSorter{dim, objs})
}

// bulkLoad bulk loads the Rtree using OMT algorithm. bulkLoad contains special
// handling for the root node.
//
// 使用 OMT 算法批量加载 R 树。批量加载（bulkLoad）操作包含针对根节点的特殊处理。
func (tree *Rtree) bulkLoad(objs []Spatial) {
	n := len(objs)

	// create entries for all the objects
	entries := make([]entry, n)
	for i := range objs {
		entries[i] = entry{
			bb:  objs[i].Bounds(),
			obj: objs[i],
		}
	}

	// following equations are defined in the paper describing OMT
	var (
		N = float64(n)
		M = float64(tree.MaxChildren)
	)
	// Eq1: height of the tree
	// use log2 instead of log due to rounding errors with log,
	// eg, math.Log(9) / math.Log(3) > 2
	h := math.Ceil(math.Log2(N) / math.Log2(M))

	// Eq2: size of subtrees at the root
	nsub := math.Pow(M, h-1)

	// Inner Eq3: number of subtrees at the root
	s := math.Ceil(N / nsub)

	// Eq3: number of slices
	S := math.Floor(math.Sqrt(s))

	// sort all entries by first dimension
	sortByDim(0, entries)

	tree.height = uint32(h)
	tree.size = n
	tree.root = tree.omt(uint32(h), int(S), entries, int(s))
}

// omt is the recursive part of the Overlap Minimizing Top-loading bulk-
// load approach. Returns the root node of a subtree.
//
// 重叠最小化顶部加载批量加载方法的递归部分。返回一棵子树的根节点。
func (tree *Rtree) omt(level uint32, nSlices int, objs []entry, m int) *node {
	// if number of objects is less than or equal than max children per leaf,
	// we need to create a leaf node
	if len(objs) <= m {
		// as long as the recursion is not at the leaf, call it again
		if level > 1 {
			child := tree.omt(level-1, nSlices, objs, m)
			n := &node{
				level: level,
				entries: []entry{{
					bb:    child.ComputeBoundingBox(),
					child: child,
				}},
			}
			child.parent = n
			return n
		}
		entries := make([]entry, len(objs))
		copy(entries, objs)
		return &node{
			leaf:    true,
			entries: entries,
			level:   level,
		}
	}

	n := &node{
		level:   level,
		entries: make([]entry, 0, m),
	}

	// maximum node size given at most M nodes at this level
	k := (len(objs) + m - 1) / m // = ceil(N / M)

	// In the root level, split objs in nSlices. In all other levels,
	// we use a single slice.
	vertSize := len(objs)
	if nSlices > 1 {
		vertSize = nSlices * k
	}

	// create sub trees
	walkPartitions(vertSize, objs, func(vert []entry) {
		// sort vertical slice by a different dimension on every level
		sortByDim(int((tree.height-level+1))%tree.Dim, vert)

		// split slice into groups of size k
		walkPartitions(k, vert, func(part []entry) {
			child := tree.omt(level-1, 1, part, tree.MaxChildren)
			child.parent = n

			n.entries = append(n.entries, entry{
				bb:    child.ComputeBoundingBox(),
				child: child,
			})
		})
	})
	return n
}

// node represents a tree node of an Rtree.
type node struct {
	parent  *node
	entries []entry
	level   uint32 // node depth in the Rtree 节点所处深度，不应超过 4294967295 层。层数太深，失去了使用树的意义
	leaf    bool
}

func (n *node) Children() []*node {
	if len(n.entries) < 1 {
		return nil
	}
	children := make([]*node, len(n.entries))
	for i, e := range n.entries {
		children[i] = e.child
	}
	return children
}

func (n *node) Parent() *node {
	return n.parent
}

func (n *node) String() string {
	return fmt.Sprintf("node{leaf: %v, entries: %v}", n.leaf, n.entries)
}

// entry represents a spatial index record stored in a tree node.
//
// 表示存储在树节点中的空间索引记录。
type entry struct {
	bb    Rect // 此 entry 的所有子节点的最小外接矩形边界框。
	child *node
	obj   Spatial
}

func (e entry) String() string {
	if e.child != nil {
		return fmt.Sprintf("entry{bb: %v, child: %v}", e.bb, e.child)
	}
	return fmt.Sprintf("entry{bb: %v, obj: %v}", e.bb, e.obj)
}

// Spatial is an interface for objects that can be stored in an Rtree and queried.
//
// R树上存储对象的接口。以提供存储和查询功能。
type Spatial interface {
	Bounds() Rect
	AppendTraceBox(bb Rect) Spatial
}

// Insertion

// Insert inserts a spatial object into the tree.  If insertion
// causes a leaf node to overflow, the tree is rebalanced automatically.
//
// Implemented per Section 3.2 of "R-trees: A Dynamic Index Structure for
// Spatial Searching" by A. Guttman, Proceedings of ACM SIGMOD, p. 47-57, 1984.
//
// “插入”（Insert）操作会将一个空间对象插入到树中。如果插入操作导致叶子节点溢出，该树会自动重新平衡。
//
// 此操作是按照 A. 古特曼（A. Guttman）所著《R 树：一种用于空间搜索的动态索引结构》的第 3.2 节实现的，
//
// 该文 1984 年发表于《美国计算机协会数据管理专业组会议论文集》，第 47 - 57 页。
func (tree *Rtree) Insert(obj Spatial) {
	e := entry{obj.Bounds(), nil, obj}
	tree.insert(e, 1)
	tree.size++
}

// insert adds the specified entry to the tree at the specified level.
//
// “插入”（insert）操作会将指定的条目添加到树中指定的层级上。
func (tree *Rtree) insert(e entry, level uint32) {
	leaf := tree.chooseNode(tree.root, e, level)
	leaf.entries = append(leaf.entries, e)

	// update parent pointer if necessary
	if e.child != nil {
		e.child.parent = leaf
	}

	// split leaf if overflows
	var split *node
	if len(leaf.entries) > tree.MaxChildren {
		leaf, split = leaf.split(tree.MinChildren)
	}
	root, splitRoot := tree.adjustTree(leaf, split)
	if splitRoot != nil {
		oldRoot := root
		tree.height++
		tree.root = &node{
			parent: nil,
			level:  tree.height,
			entries: []entry{
				{bb: oldRoot.ComputeBoundingBox(), child: oldRoot},
				{bb: splitRoot.ComputeBoundingBox(), child: splitRoot},
			},
		}
		oldRoot.parent = tree.root
		splitRoot.parent = tree.root
	}
}

// chooseNode finds the node at the specified level to which e should be added.
//
// “选择节点”（chooseNode）操作会在指定层级上查找元素 e 应添加到哪个节点。
func (tree *Rtree) chooseNode(n *node, e entry, level uint32) *node {
	if n.leaf || n.level == level { // 如果n是叶子节点或者n的层级等于指定的层级，则应添加到该节点 n 上
		return n
	}

	// find the entry whose bb needs least enlargement to include obj
	diff := float32(math.MaxFloat32)
	var chosen entry
	for _, en := range n.entries {
		bb := boundingBox(en.bb, e.bb)
		d := bb.Size() - en.bb.Size()
		if d < diff || (d == diff && en.bb.Size() < chosen.bb.Size()) {
			diff = d
			chosen = en
		}
	}

	return tree.chooseNode(chosen.child, e, level)
}

// adjustTree splits overflowing nodes and propagates the changes upwards.
//
// 拆分溢出的节点，并将更改向上传递。
func (tree *Rtree) adjustTree(n, nn *node) (*node, *node) {
	// Let the caller handle root adjustments.
	if n == tree.root {
		return n, nn
	}

	// Re-size the bounding box of n to account for lower-level changes.
	en := n.getEntry()
	prevBox := en.bb
	en.bb = n.ComputeBoundingBox()

	// If nn is nil, then we're just propagating changes upwards.
	if nn == nil {
		// Optimize for the case where nothing is changed
		// to avoid ComputeBoundingBox which is expensive.
		if en.bb.Equal(prevBox) {
			return tree.root, nil
		}
		return tree.adjustTree(n.parent, nil)
	}

	// Otherwise, these are two nodes resulting from a split.
	// n was reused as the "left" node, but we need to add nn to n.parent.
	enn := entry{nn.ComputeBoundingBox(), nn, nil}
	n.parent.entries = append(n.parent.entries, enn)

	// If the new entry overflows the parent, split the parent and propagate.
	if len(n.parent.entries) > tree.MaxChildren {
		return tree.adjustTree(n.parent.split(tree.MinChildren))
	}

	// Otherwise keep propagating changes upwards.
	return tree.adjustTree(n.parent, nil)
}

// getEntry returns a pointer to the entry for the node n from n's parent.
//
// 为节点 n 返回一个指向其父节点中的对应 entry 的指针。即找到自己的承载主体。
func (n *node) getEntry() *entry {
	var e *entry
	for i := range n.parent.entries {
		if n.parent.entries[i].child == n {
			e = &n.parent.entries[i]
			break
		}
	}
	return e
}

// ComputeBoundingBox finds the MBR of the children of n.
//
// 查找节点 n 的所有子节点的最小外接矩形边界框
func (n *node) ComputeBoundingBox() (bb Rect) {
	if len(n.entries) == 1 {
		bb = n.entries[0].bb
		return
	}

	bb = boundingBox(n.entries[0].bb, n.entries[1].bb)
	for _, e := range n.entries[2:] {
		bb = boundingBox(bb, e.bb)
	}
	return
}

// split splits a node into two groups while attempting to minimize the
// bounding-box area of the resulting groups.
//
// 将一个节点拆分成两组，同时尽量使生成的这两组的边界框面积最小化
func (n *node) split(minGroupSize int) (left, right *node) {
	// find the initial split
	l, r := n.pickSeeds()
	leftSeed, rightSeed := n.entries[l], n.entries[r]

	// get the entries to be divided between left and right
	remaining := append(n.entries[:l], n.entries[l+1:r]...)
	remaining = append(remaining, n.entries[r+1:]...)

	// setup the new split nodes, but re-use n as the left node
	left = n
	left.entries = []entry{leftSeed}
	right = &node{
		parent:  n.parent,
		leaf:    n.leaf,
		level:   n.level,
		entries: []entry{rightSeed},
	}

	// TODO
	if rightSeed.child != nil {
		rightSeed.child.parent = right
	}
	if leftSeed.child != nil {
		leftSeed.child.parent = left
	}

	// distribute all of n's old entries into left and right.
	for len(remaining) > 0 {
		next := pickNext(left, right, remaining)
		e := remaining[next]

		if len(remaining)+len(left.entries) <= minGroupSize {
			assign(e, left)
		} else if len(remaining)+len(right.entries) <= minGroupSize {
			assign(e, right)
		} else {
			assignGroup(e, left, right)
		}

		remaining = append(remaining[:next], remaining[next+1:]...)
	}

	return
}

// getAllBoundingBoxes traverses tree populating slice of bounding boxes of non-leaf nodes.
//
// 深度遍历n节点非叶子节点的最小外接矩形边界框切片。
func (n *node) getAllBoundingBoxes() []Rect {
	var rects []Rect
	if n.leaf {
		return rects
	}
	for _, e := range n.entries {
		if e.child == nil {
			return rects
		}
		rectsInter := append(e.child.getAllBoundingBoxes(), e.bb)
		rects = append(rects, rectsInter...)
	}
	return rects
}

func assign(e entry, group *node) {
	if e.child != nil {
		e.child.parent = group
	}
	group.entries = append(group.entries, e)
}

// assignGroup chooses one of two groups to which a node should be added.
//
// 将节点分配给 left 和 right 其中一个组。优先分配到合并后外接边框面积最小的组中。若面积相等，则分配到子节点少的那组。
func assignGroup(e entry, left, right *node) {
	leftBB := left.ComputeBoundingBox()
	rightBB := right.ComputeBoundingBox()
	leftEnlarged := boundingBox(leftBB, e.bb)
	rightEnlarged := boundingBox(rightBB, e.bb)

	// first, choose the group that needs the least enlargement
	leftDiff := leftEnlarged.Size() - leftBB.Size()
	rightDiff := rightEnlarged.Size() - rightBB.Size()
	if diff := leftDiff - rightDiff; diff < 0 {
		assign(e, left)
		return
	} else if diff > 0 {
		assign(e, right)
		return
	}

	// next, choose the group that has smaller area
	if diff := leftBB.Size() - rightBB.Size(); diff < 0 {
		assign(e, left)
		return
	} else if diff > 0 {
		assign(e, right)
		return
	}

	// next, choose the group with fewer entries
	if diff := len(left.entries) - len(right.entries); diff <= 0 {
		assign(e, left)
		return
	}
	assign(e, right)
}

// pickSeeds chooses two child entries of n to start a split.
//
// 从 n 的子节点中选择两个节点，作为分裂的种子节点,已确保分裂后面积最小。
func (n *node) pickSeeds() (int, int) {
	left, right := 0, 1
	maxWastedSpace := float32(-1.0)
	for i, e1 := range n.entries {
		for j, e2 := range n.entries[i+1:] {
			d := boundingBox(e1.bb, e2.bb).Size() - e1.bb.Size() - e2.bb.Size()
			if d > maxWastedSpace {
				maxWastedSpace = d
				left, right = i, j+i+1
			}
		}
	}
	return left, right
}

// pickNext chooses an entry to be added to an entry group.
//
// 遍历entries中的条目，与left和right的边界框计算增量面积变化，选择一个面积变化最大条目，并返回其在entries中的索引。
func pickNext(left, right *node, entries []entry) (next int) {
	maxDiff := -1.0
	leftBB := left.ComputeBoundingBox()
	rightBB := right.ComputeBoundingBox()
	for i, e := range entries {
		d1 := boundingBox(leftBB, e.bb).Size() - leftBB.Size()
		d2 := boundingBox(rightBB, e.bb).Size() - rightBB.Size()
		d := math.Abs(float64(d1 - d2))
		if d > maxDiff {
			maxDiff = d
			next = i
		}
	}
	return
}

// Deletion

// Delete removes an object from the tree.  If the object is not found, returns
// false, otherwise returns true. Uses the default comparator when checking
// equality.
//
// Implemented per Section 3.3 of "R-trees: A Dynamic Index Structure for
// Spatial Searching" by A. Guttman, Proceedings of ACM SIGMOD, p. 47-57, 1984.
//
// “Delete（删除）” 操作会从树中移除一个对象。如果未找到该对象，则返回 “false”（假），
// 否则返回 “true”（真）。在检查相等性时，会使用默认的比较器。
func (tree *Rtree) Delete(obj Spatial) bool {
	return tree.DeleteWithComparator(obj, defaultComparator)
}

// DeleteWithComparator removes an object from the tree using a custom
// comparator for evaluating equalness. This is useful when you want to remove
// an object from a tree but don't have a pointer to the original object
// anymore.
//
// 使用自定义比较器来评估相等性，进而从树中移除一个对象。当你想要从树中移除一个对象，
// 但已不再持有指向原始对象的指针时，这一操作就很有用了。
func (tree *Rtree) DeleteWithComparator(obj Spatial, cmp Comparator) bool {
	n := tree.findLeaf(tree.root, obj, cmp)
	if n == nil {
		return false
	}

	ind := -1
	for i, e := range n.entries {
		if cmp(e.obj, obj) {
			ind = i
		}
	}
	if ind < 0 {
		return false
	}

	n.entries = append(n.entries[:ind], n.entries[ind+1:]...)

	tree.condenseTree(n)
	tree.size--

	if !tree.root.leaf && len(tree.root.entries) == 1 {
		tree.root = tree.root.entries[0].child
	}

	tree.height = tree.root.level

	return true
}

// findLeaf finds the leaf node containing obj.
//
// 查找包含 obj 的叶子节点。可能涉及到递归调用
func (tree *Rtree) findLeaf(n *node, obj Spatial, cmp Comparator) *node {
	if n.leaf {
		return n
	}
	// if not leaf, search all candidate subtrees
	for _, e := range n.entries {
		if e.bb.containsRect(obj.Bounds()) {
			leaf := tree.findLeaf(e.child, obj, cmp)
			if leaf == nil {
				continue
			}
			// check if the leaf actually contains the object
			for _, leafEntry := range leaf.entries {
				if cmp(leafEntry.obj, obj) {
					return leaf
				}
			}
		}
	}
	return nil
}

// condenseTree deletes underflowing nodes and propagates the changes upwards.
//
// “condenseTree（压缩树）” 操作会删除下溢节点，并将这些变更向上传播。
func (tree *Rtree) condenseTree(n *node) {
	// reset the deleted buffer
	tree.deleted = tree.deleted[:0]

	for n != tree.root {
		if len(n.entries) < tree.MinChildren {
			// find n and delete it by swapping the last entry into its place
			idx := -1
			for i, e := range n.parent.entries {
				if e.child == n {
					idx = i
					break
				}
			}
			if idx == -1 {
				panic(fmt.Errorf("Failed to remove entry from parent"))
			}
			l := len(n.parent.entries)
			n.parent.entries[idx] = n.parent.entries[l-1]
			n.parent.entries = n.parent.entries[:l-1]

			// only add n to deleted if it still has children
			if len(n.entries) > 0 {
				tree.deleted = append(tree.deleted, n)
			}
		} else {
			// just a child entry deletion, no underflow
			en := n.getEntry()
			prevBox := en.bb
			en.bb = n.ComputeBoundingBox()

			if en.bb.Equal(prevBox) {
				// Optimize for the case where nothing is changed
				// to avoid ComputeBoundingBox which is expensive.
				break
			}
		}
		n = n.parent
	}

	for i := len(tree.deleted) - 1; i >= 0; i-- {
		n := tree.deleted[i]
		// reinsert entry so that it will remain at the same level as before
		e := entry{n.ComputeBoundingBox(), n, nil}
		tree.insert(e, n.level+1)
	}
}

// Searching

// SearchIntersect returns all objects that intersect the specified rectangle.
// Implemented per Section 3.1 of "R-trees: A Dynamic Index Structure for
// Spatial Searching" by A. Guttman, Proceedings of ACM SIGMOD, p. 47-57, 1984.
//
// （交集搜索） 会返回所有与指定矩形相交的对象。
// 内部实现涉及遍历和递归调用。
// 其实现依据是 A. 古特曼（A. Guttman）所著《R - 树：一种用于空间搜索的动态索引结构》的第 3.1 节，
// 该内容出自 1984 年美国计算机协会数据管理专业组（ACM SIGMOD）的会议论文集，第 47 至 57 页。
func (tree *Rtree) SearchIntersect(bb Rect, needTrace bool, filters ...Filter) []Spatial {
	return tree.searchIntersect([]Spatial{}, tree.root, bb, needTrace, filters)
}

// SearchIntersectWithLimit is similar to SearchIntersect, but returns
// immediately when the first k results are found. A negative k behaves exactly
// like SearchIntersect and returns all the results.
//
// Kept for backwards compatibility, please use SearchIntersect with a
// LimitFilter.
//
// （带限制的交集搜索） 与 “SearchIntersect（交集搜索）” 类似，
// 但在找到前 k 个结果时会立即返回。当 k 为负数时，其行为与 “SearchIntersect” 完全一样，会返回所有结果。
// 保留该功能是为了向后兼容，不过请使用带有 “LimitFilter（限制过滤器）” 的 “SearchIntersect” 来实现相应操作。
func (tree *Rtree) SearchIntersectWithLimit(k int, bb Rect, needTrace bool) []Spatial {
	// backwards compatibility, previous implementation didn't limit results if
	// k was negative.
	if k < 0 {
		return tree.SearchIntersect(bb, needTrace)
	}
	return tree.SearchIntersect(bb, needTrace, LimitFilter(k))
}

// searchIntersect 搜索指定矩形 bb 在 n 节点中相交的所有对象。
// 会涉及到遍历和递归调用
func (tree *Rtree) searchIntersect(results []Spatial, n *node, bb Rect, needTrace bool, filters []Filter) []Spatial {
	for _, e := range n.entries {
		if !intersect(e.bb, bb) {
			continue
		}

		if !n.leaf {
			results = tree.searchIntersect(results, e.child, bb, needTrace, filters)
			continue
		}

		refuse, abort := applyFilters(results, e.obj, filters)
		if !refuse {
			searchOut := e.obj
			if needTrace {
				valueType := reflect.TypeOf(searchOut)
				valueKind := valueType.Kind()
				if valueKind == reflect.Pointer {
					copyValue := deepcopy.Copy(searchOut)
					searchOut = copyValue.(Spatial)
				}
				searchOut = searchOut.AppendTraceBox(n.ComputeBoundingBox())
				np := n.parent
				for np != nil {
					searchOut = searchOut.AppendTraceBox(np.ComputeBoundingBox())
					np = np.parent
				}
			}
			results = append(results, searchOut)
		}

		if abort {
			break
		}
	}
	return results
}

// NearestNeighbor returns the closest object to the specified point.
// Implemented per "Nearest Neighbor Queries" by Roussopoulos et al
func (tree *Rtree) NearestNeighbor(p Point, needTrace bool) Spatial {
	obj, _ := tree.nearestNeighbor(p, tree.root, math.MaxFloat64, nil, needTrace)
	return obj
}

// GetAllBoundingBoxes returning slice of bounding boxes by traversing tree. Slice
// includes bounding boxes from all non-leaf nodes.
func (tree *Rtree) GetAllBoundingBoxes() []Rect {
	var rects []Rect
	if tree.root != nil {
		rects = tree.root.getAllBoundingBoxes()
	}
	return rects
}

// utilities for sorting slices of entries

type entrySlice struct {
	entries []entry
	dists   []float64
}

func (s entrySlice) Len() int { return len(s.entries) }

func (s entrySlice) Swap(i, j int) {
	s.entries[i], s.entries[j] = s.entries[j], s.entries[i]
	s.dists[i], s.dists[j] = s.dists[j], s.dists[i]
}

func (s entrySlice) Less(i, j int) bool {
	return s.dists[i] < s.dists[j]
}

func sortEntries(p Point, entries []entry) ([]entry, []float64) {
	sorted := make([]entry, len(entries))
	dists := make([]float64, len(entries))
	return sortPreallocEntries(p, entries, sorted, dists)
}

func sortPreallocEntries(p Point, entries, sorted []entry, dists []float64) ([]entry, []float64) {
	// use preallocated slices
	sorted = sorted[:len(entries)]
	dists = dists[:len(entries)]

	for i := 0; i < len(entries); i++ {
		sorted[i] = entries[i]
		dists[i] = p.minDist(entries[i].bb)
	}
	sort.Sort(entrySlice{sorted, dists})
	return sorted, dists
}

func pruneEntriesMinDist(d float64, entries []entry, minDists []float64) []entry {
	var i int
	for ; i < len(entries); i++ {
		if minDists[i] > d {
			break
		}
	}
	return entries[:i]
}

func (tree *Rtree) nearestNeighbor(p Point, n *node, d float64, nearest Spatial, needTrace bool) (Spatial, float64) {
	if n.leaf {
		for _, e := range n.entries {
			dist := math.Sqrt(p.minDist(e.bb))
			if dist < d {
				d = dist
				nearest = e.obj
				if needTrace {
					valueType := reflect.TypeOf(nearest)
					valueKind := valueType.Kind()
					if valueKind == reflect.Pointer {
						copyValue := deepcopy.Copy(nearest)
						nearest = copyValue.(Spatial)
					}
					nearest = nearest.AppendTraceBox(n.ComputeBoundingBox())
					np := n.parent
					for np != nil {
						nearest = nearest.AppendTraceBox(np.ComputeBoundingBox())
						np = np.parent
					}
				}
			}
		}
	} else {
		// Search only through entries with minDist <= minMinMaxDist,
		// where minDist is the distance between a point and a rectangle,
		// and minMaxDist is the smallest value among the maximum distance across all axes.
		//
		// Entries with minDist > minMinMaxDist are guaranteed to be farther away than some other entry.
		//
		// For more details, please consult
		// N. Roussopoulos, S. Kelley and F. Vincent, ACM SIGMOD, pages 71-79, 1995.
		minMinMaxDist := math.MaxFloat64
		for _, e := range n.entries {
			minMaxDist := p.minMaxDist(e.bb)
			if minMaxDist < minMinMaxDist {
				minMinMaxDist = minMaxDist
			}
		}

		for _, e := range n.entries {
			minDist := p.minDist(e.bb)
			// Add a bit of tolerance to guard against floating point rounding errors.
			if minDist > minMinMaxDist+tree.FloatingPointTolerance {
				continue
			}

			subNearest, dist := tree.nearestNeighbor(p, e.child, d, nearest, needTrace)
			if dist < d {
				d = dist
				nearest = subNearest
			}
		}
	}
	return nearest, d
}

// NearestNeighbors gets the closest Spatials to the Point.
func (tree *Rtree) NearestNeighbors(k int, p Point, needTrace bool, filters ...Filter) []Spatial {
	// preallocate the buffers for sortings the branches. At each level of the
	// tree, we slide the buffer by the number of entries in the node.
	maxBufSize := tree.MaxChildren * int(tree.Depth())
	branches := make([]entry, maxBufSize)
	branchDists := make([]float64, maxBufSize)

	// allocate the buffers for the results
	dists := make([]float64, 0, k)
	objs := make([]Spatial, 0, k)

	objs, _, _ = tree.nearestNeighbors(k, p, tree.root, dists, objs, filters, branches, branchDists, needTrace)
	return objs
}

// insert obj into nearest and return the first k elements in increasing order.
func insertNearest(k int, dists []float64, nearest []Spatial, dist float64, obj Spatial, filters []Filter) ([]float64, []Spatial, bool) {
	i := sort.SearchFloat64s(dists, dist)
	for i < len(nearest) && dist >= dists[i] {
		i++
	}
	if i >= k {
		return dists, nearest, false
	}

	if refuse, abort := applyFilters(nearest, obj, filters); refuse || abort {
		return dists, nearest, abort
	}

	// no resize since cap = k
	if len(nearest) < k {
		dists = append(dists, 0)
		nearest = append(nearest, nil)
	}

	left, right := dists[:i], dists[i:len(dists)-1]
	copy(dists, left)
	copy(dists[i+1:], right)
	dists[i] = dist

	leftObjs, rightObjs := nearest[:i], nearest[i:len(nearest)-1]
	copy(nearest, leftObjs)
	copy(nearest[i+1:], rightObjs)
	nearest[i] = obj

	return dists, nearest, false
}

func (tree *Rtree) nearestNeighbors(k int, p Point, n *node, dists []float64, nearest []Spatial, filters []Filter, b []entry, bd []float64, needTrace bool) ([]Spatial, []float64, bool) {
	var abort bool
	if n.leaf {
		for _, e := range n.entries {
			dist := p.minDist(e.bb)
			dists, nearest, abort = insertNearest(k, dists, nearest, dist, e.obj, filters)
			if abort {
				break
			}
		}
	} else {
		branches, branchDists := sortPreallocEntries(p, n.entries, b, bd)
		// only prune if buffer has k elements
		if l := len(dists); l >= k {
			branches = pruneEntriesMinDist(dists[l-1], branches, branchDists)
		}
		for _, e := range branches {
			nearest, dists, abort = tree.nearestNeighbors(k, p, e.child, dists, nearest, filters, b[len(n.entries):], bd[len(n.entries):], needTrace)
			if abort {
				break
			}
		}
	}
	return nearest, dists, abort
}