cfc65a13f6
This commit includes updates that affects the build, testing, and
deployment of Tile38.
- The root level build.sh has been broken up into multiple scripts
and placed in the "scripts" directory.
- The vendor directory has been updated to follow the Go modules
rules, thus `make` should work on isolated environments. Also
some vendored packages may have been updated to a later
version, if needed.
- The Makefile has been updated to allow for making single
binaries such as `make tile38-server`. There is some scaffolding
during the build process, so from now on all binaries should be
made using make. For example, to run a development version of
the tile38-cli binary, do this:
make tile38-cli && ./tile38-cli
not this:
go run cmd/tile38-cli/main.go
- Travis.CI docker push script has been updated to address a
change to Docker's JSON repo meta output, which in turn fixes
a bug where new Tile38 versions were not being properly pushed
to Docker
99 lines
2.0 KiB
Go
99 lines
2.0 KiB
Go
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
|
|
}
|