rtred/rtree.go

14014 lines
432 KiB
Go

// generated; DO NOT EDIT!
package rtree
import "math"
type Iterator func(item Item) bool
type Item interface {
Rect(ctx interface{}) (min []float64, max []float64)
}
type RTree struct {
ctx interface{}
tr1 *d1RTree
tr2 *d2RTree
tr3 *d3RTree
tr4 *d4RTree
tr5 *d5RTree
tr6 *d6RTree
tr7 *d7RTree
tr8 *d8RTree
tr9 *d9RTree
tr10 *d10RTree
tr11 *d11RTree
tr12 *d12RTree
tr13 *d13RTree
tr14 *d14RTree
tr15 *d15RTree
tr16 *d16RTree
tr17 *d17RTree
tr18 *d18RTree
tr19 *d19RTree
tr20 *d20RTree
}
func New(ctx interface{}) *RTree {
return &RTree{
ctx: ctx,
tr1: d1New(),
tr2: d2New(),
tr3: d3New(),
tr4: d4New(),
tr5: d5New(),
tr6: d6New(),
tr7: d7New(),
tr8: d8New(),
tr9: d9New(),
tr10: d10New(),
tr11: d11New(),
tr12: d12New(),
tr13: d13New(),
tr14: d14New(),
tr15: d15New(),
tr16: d16New(),
tr17: d17New(),
tr18: d18New(),
tr19: d19New(),
tr20: d20New(),
}
}
func (tr *RTree) Insert(item Item) {
if item == nil {
panic("nil item being added to RTree")
}
min, max := item.Rect(tr.ctx)
if len(min) != len(max) {
return // just return
panic("invalid item rectangle")
}
switch len(min) {
default:
return // just return
panic("invalid dimension")
case 1:
var amin, amax [1]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr1.Insert(amin, amax, item)
case 2:
var amin, amax [2]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr2.Insert(amin, amax, item)
case 3:
var amin, amax [3]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr3.Insert(amin, amax, item)
case 4:
var amin, amax [4]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr4.Insert(amin, amax, item)
case 5:
var amin, amax [5]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr5.Insert(amin, amax, item)
case 6:
var amin, amax [6]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr6.Insert(amin, amax, item)
case 7:
var amin, amax [7]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr7.Insert(amin, amax, item)
case 8:
var amin, amax [8]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr8.Insert(amin, amax, item)
case 9:
var amin, amax [9]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr9.Insert(amin, amax, item)
case 10:
var amin, amax [10]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr10.Insert(amin, amax, item)
case 11:
var amin, amax [11]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr11.Insert(amin, amax, item)
case 12:
var amin, amax [12]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr12.Insert(amin, amax, item)
case 13:
var amin, amax [13]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr13.Insert(amin, amax, item)
case 14:
var amin, amax [14]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr14.Insert(amin, amax, item)
case 15:
var amin, amax [15]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr15.Insert(amin, amax, item)
case 16:
var amin, amax [16]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr16.Insert(amin, amax, item)
case 17:
var amin, amax [17]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr17.Insert(amin, amax, item)
case 18:
var amin, amax [18]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr18.Insert(amin, amax, item)
case 19:
var amin, amax [19]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr19.Insert(amin, amax, item)
case 20:
var amin, amax [20]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr20.Insert(amin, amax, item)
}
}
func (tr *RTree) Remove(item Item) {
if item == nil {
panic("nil item being added to RTree")
}
min, max := item.Rect(tr.ctx)
if len(min) != len(max) {
return // just return
panic("invalid item rectangle")
}
switch len(min) {
default:
return // just return
panic("invalid dimension")
case 1:
var amin, amax [1]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr1.Remove(amin, amax, item)
case 2:
var amin, amax [2]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr2.Remove(amin, amax, item)
case 3:
var amin, amax [3]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr3.Remove(amin, amax, item)
case 4:
var amin, amax [4]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr4.Remove(amin, amax, item)
case 5:
var amin, amax [5]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr5.Remove(amin, amax, item)
case 6:
var amin, amax [6]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr6.Remove(amin, amax, item)
case 7:
var amin, amax [7]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr7.Remove(amin, amax, item)
case 8:
var amin, amax [8]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr8.Remove(amin, amax, item)
case 9:
var amin, amax [9]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr9.Remove(amin, amax, item)
case 10:
var amin, amax [10]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr10.Remove(amin, amax, item)
case 11:
var amin, amax [11]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr11.Remove(amin, amax, item)
case 12:
var amin, amax [12]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr12.Remove(amin, amax, item)
case 13:
var amin, amax [13]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr13.Remove(amin, amax, item)
case 14:
var amin, amax [14]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr14.Remove(amin, amax, item)
case 15:
var amin, amax [15]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr15.Remove(amin, amax, item)
case 16:
var amin, amax [16]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr16.Remove(amin, amax, item)
case 17:
var amin, amax [17]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr17.Remove(amin, amax, item)
case 18:
var amin, amax [18]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr18.Remove(amin, amax, item)
case 19:
var amin, amax [19]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr19.Remove(amin, amax, item)
case 20:
var amin, amax [20]float64
for i := 0; i < len(min); i++ {
amin[i], amax[i] = min[i], max[i]
}
tr.tr20.Remove(amin, amax, item)
}
}
func (tr *RTree) Reset() {
tr.tr1 = d1New()
tr.tr2 = d2New()
tr.tr3 = d3New()
tr.tr4 = d4New()
tr.tr5 = d5New()
tr.tr6 = d6New()
tr.tr7 = d7New()
tr.tr8 = d8New()
tr.tr9 = d9New()
tr.tr10 = d10New()
tr.tr11 = d11New()
tr.tr12 = d12New()
tr.tr13 = d13New()
tr.tr14 = d14New()
tr.tr15 = d15New()
tr.tr16 = d16New()
tr.tr17 = d17New()
tr.tr18 = d18New()
tr.tr19 = d19New()
tr.tr20 = d20New()
}
func (tr *RTree) Count() int {
count := 0
count += tr.tr1.Count()
count += tr.tr2.Count()
count += tr.tr3.Count()
count += tr.tr4.Count()
count += tr.tr5.Count()
count += tr.tr6.Count()
count += tr.tr7.Count()
count += tr.tr8.Count()
count += tr.tr9.Count()
count += tr.tr10.Count()
count += tr.tr11.Count()
count += tr.tr12.Count()
count += tr.tr13.Count()
count += tr.tr14.Count()
count += tr.tr15.Count()
count += tr.tr16.Count()
count += tr.tr17.Count()
count += tr.tr18.Count()
count += tr.tr19.Count()
count += tr.tr20.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")
}
switch len(min) {
default:
return // just return
panic("invalid dimension")
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
}
if !tr.search1(min, max, iter) {
return
}
if !tr.search2(min, max, iter) {
return
}
if !tr.search3(min, max, iter) {
return
}
if !tr.search4(min, max, iter) {
return
}
if !tr.search5(min, max, iter) {
return
}
if !tr.search6(min, max, iter) {
return
}
if !tr.search7(min, max, iter) {
return
}
if !tr.search8(min, max, iter) {
return
}
if !tr.search9(min, max, iter) {
return
}
if !tr.search10(min, max, iter) {
return
}
if !tr.search11(min, max, iter) {
return
}
if !tr.search12(min, max, iter) {
return
}
if !tr.search13(min, max, iter) {
return
}
if !tr.search14(min, max, iter) {
return
}
if !tr.search15(min, max, iter) {
return
}
if !tr.search16(min, max, iter) {
return
}
if !tr.search17(min, max, iter) {
return
}
if !tr.search18(min, max, iter) {
return
}
if !tr.search19(min, max, iter) {
return
}
if !tr.search20(min, max, iter) {
return
}
}
func (tr *RTree) search1(min, max []float64, iter Iterator) bool {
var amin, amax [1]float64
for i := 0; i < 1; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr1.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search2(min, max []float64, iter Iterator) bool {
var amin, amax [2]float64
for i := 0; i < 2; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr2.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search3(min, max []float64, iter Iterator) bool {
var amin, amax [3]float64
for i := 0; i < 3; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr3.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search4(min, max []float64, iter Iterator) bool {
var amin, amax [4]float64
for i := 0; i < 4; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr4.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search5(min, max []float64, iter Iterator) bool {
var amin, amax [5]float64
for i := 0; i < 5; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr5.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search6(min, max []float64, iter Iterator) bool {
var amin, amax [6]float64
for i := 0; i < 6; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr6.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search7(min, max []float64, iter Iterator) bool {
var amin, amax [7]float64
for i := 0; i < 7; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr7.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search8(min, max []float64, iter Iterator) bool {
var amin, amax [8]float64
for i := 0; i < 8; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr8.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search9(min, max []float64, iter Iterator) bool {
var amin, amax [9]float64
for i := 0; i < 9; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr9.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search10(min, max []float64, iter Iterator) bool {
var amin, amax [10]float64
for i := 0; i < 10; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr10.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search11(min, max []float64, iter Iterator) bool {
var amin, amax [11]float64
for i := 0; i < 11; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr11.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search12(min, max []float64, iter Iterator) bool {
var amin, amax [12]float64
for i := 0; i < 12; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr12.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search13(min, max []float64, iter Iterator) bool {
var amin, amax [13]float64
for i := 0; i < 13; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr13.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search14(min, max []float64, iter Iterator) bool {
var amin, amax [14]float64
for i := 0; i < 14; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr14.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search15(min, max []float64, iter Iterator) bool {
var amin, amax [15]float64
for i := 0; i < 15; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr15.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search16(min, max []float64, iter Iterator) bool {
var amin, amax [16]float64
for i := 0; i < 16; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr16.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search17(min, max []float64, iter Iterator) bool {
var amin, amax [17]float64
for i := 0; i < 17; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr17.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search18(min, max []float64, iter Iterator) bool {
var amin, amax [18]float64
for i := 0; i < 18; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr18.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search19(min, max []float64, iter Iterator) bool {
var amin, amax [19]float64
for i := 0; i < 19; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr19.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func (tr *RTree) search20(min, max []float64, iter Iterator) bool {
var amin, amax [20]float64
for i := 0; i < 20; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
} else {
amin[i] = math.Inf(-1)
amax[i] = math.Inf(+1)
}
}
ended := false
tr.tr20.Search(amin, amax, func(dataID interface{}) bool {
if !iter(dataID.(Item)) {
ended = true
return false
}
return true
})
return !ended
}
func d1fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d1fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d1numDims = 1
d1maxNodes = 8
d1minNodes = d1maxNodes / 2
d1useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d1unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d1numDims]
type d1RTree struct {
root *d1nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d1rectT struct {
min [d1numDims]float64 ///< Min dimensions of bounding box
max [d1numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d1branchT struct {
rect d1rectT ///< Bounds
child *d1nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d1nodeT for each branch level
type d1nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d1maxNodes]d1branchT ///< Branch
}
func (node *d1nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d1nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d1listNodeT struct {
next *d1listNodeT ///< Next in list
node *d1nodeT ///< Node
}
const d1notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d1partitionVarsT struct {
partition [d1maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d1rectT
area [2]float64
branchBuf [d1maxNodes + 1]d1branchT
branchCount int
coverSplit d1rectT
coverSplitArea float64
}
func d1New() *d1RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d1RTree{
root: &d1nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d1RTree) Insert(min, max [d1numDims]float64, dataId interface{}) {
var branch d1branchT
branch.data = dataId
for axis := 0; axis < d1numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d1insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d1RTree) Remove(min, max [d1numDims]float64, dataId interface{}) {
var rect d1rectT
for axis := 0; axis < d1numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d1removeRect(&rect, dataId, &tr.root)
}
/// Find all within d1search rectangle
/// \param a_min Min of d1search bounding rect
/// \param a_max Max of d1search bounding rect
/// \param a_searchResult d1search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d1RTree) Search(min, max [d1numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d1rectT
for axis := 0; axis < d1numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d1search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d1RTree) Count() int {
var count int
d1countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d1RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d1nodeT{}
}
func d1countRec(node *d1nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d1countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d1insertRectRec(branch *d1branchT, node *d1nodeT, newNode **d1nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d1nodeT
//var newBranch d1branchT
// find the optimal branch for this record
index := d1pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d1insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d1combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d1nodeCover(node.branch[index].child)
var newBranch d1branchT
newBranch.child = otherNode
newBranch.rect = d1nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d1addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d1addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d1insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d1insertRect(branch *d1branchT, root **d1nodeT, level int) bool {
var newNode *d1nodeT
if d1insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d1nodeT{}
newRoot.level = (*root).level + 1
var newBranch d1branchT
// add old root node as a child of the new root
newBranch.rect = d1nodeCover(*root)
newBranch.child = *root
d1addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d1nodeCover(newNode)
newBranch.child = newNode
d1addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d1nodeCover(node *d1nodeT) d1rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d1combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d1addBranch(branch *d1branchT, node *d1nodeT, newNode **d1nodeT) bool {
if node.count < d1maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d1splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d1disconnectBranch(node *d1nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d1pickBranch(rect *d1rectT, node *d1nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d1rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d1calcRectVolume(curRect)
tempRect = d1combineRect(rect, curRect)
increase = d1calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d1combineRect(rectA, rectB *d1rectT) d1rectT {
var newRect d1rectT
for index := 0; index < d1numDims; index++ {
newRect.min[index] = d1fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d1fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d1splitNode(node *d1nodeT, branch *d1branchT, newNode **d1nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d1partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d1getBranches(node, branch, parVars)
// Find partition
d1choosePartition(parVars, d1minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d1nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d1loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d1rectVolume(rect *d1rectT) float64 {
var volume float64 = 1
for index := 0; index < d1numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d1rectT
func d1rectSphericalVolume(rect *d1rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d1numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d1numDims == 5 {
return (radius * radius * radius * radius * radius * d1unitSphereVolume)
} else if d1numDims == 4 {
return (radius * radius * radius * radius * d1unitSphereVolume)
} else if d1numDims == 3 {
return (radius * radius * radius * d1unitSphereVolume)
} else if d1numDims == 2 {
return (radius * radius * d1unitSphereVolume)
} else {
return (math.Pow(radius, d1numDims) * d1unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d1calcRectVolume(rect *d1rectT) float64 {
if d1useSphericalVolume {
return d1rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d1rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d1getBranches(node *d1nodeT, branch *d1branchT, parVars *d1partitionVarsT) {
// Load the branch buffer
for index := 0; index < d1maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d1maxNodes] = *branch
parVars.branchCount = d1maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d1maxNodes+1; index++ {
parVars.coverSplit = d1combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d1calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d1choosePartition(parVars *d1partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d1initParVars(parVars, parVars.branchCount, minFill)
d1pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d1notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d1combineRect(curRect, &parVars.cover[0])
rect1 := d1combineRect(curRect, &parVars.cover[1])
growth0 := d1calcRectVolume(&rect0) - parVars.area[0]
growth1 := d1calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d1classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d1notTaken == parVars.partition[index] {
d1classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d1loadNodes(nodeA, nodeB *d1nodeT, parVars *d1partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d1nodeT{nodeA, nodeB}
// It is assured that d1addBranch here will not cause a node split.
d1addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d1partitionVarsT structure.
func d1initParVars(parVars *d1partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d1notTaken
}
}
func d1pickSeeds(parVars *d1partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d1maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d1calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d1combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d1calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d1classify(seed0, 0, parVars)
d1classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d1classify(index, group int, parVars *d1partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d1combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d1calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d1rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d1removeRect provides for eliminating the root.
func d1removeRect(rect *d1rectT, id interface{}, root **d1nodeT) bool {
var reInsertList *d1listNodeT
if !d1removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d1insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d1removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d1removeRectRec(rect *d1rectT, id interface{}, node *d1nodeT, listNode **d1listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d1overlap(*rect, node.branch[index].rect) {
if !d1removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d1minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d1nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d1reInsert(node.branch[index].child, listNode)
d1disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d1disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d1overlap.
func d1overlap(rectA, rectB d1rectT) bool {
for index := 0; index < d1numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d1reInsert(node *d1nodeT, listNode **d1listNodeT) {
newListNode := &d1listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d1search in an index tree or subtree for all data retangles that d1overlap the argument rectangle.
func d1search(node *d1nodeT, rect d1rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d1overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d1search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d1overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d2fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d2fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d2numDims = 2
d2maxNodes = 8
d2minNodes = d2maxNodes / 2
d2useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d2unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d2numDims]
type d2RTree struct {
root *d2nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d2rectT struct {
min [d2numDims]float64 ///< Min dimensions of bounding box
max [d2numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d2branchT struct {
rect d2rectT ///< Bounds
child *d2nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d2nodeT for each branch level
type d2nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d2maxNodes]d2branchT ///< Branch
}
func (node *d2nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d2nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d2listNodeT struct {
next *d2listNodeT ///< Next in list
node *d2nodeT ///< Node
}
const d2notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d2partitionVarsT struct {
partition [d2maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d2rectT
area [2]float64
branchBuf [d2maxNodes + 1]d2branchT
branchCount int
coverSplit d2rectT
coverSplitArea float64
}
func d2New() *d2RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d2RTree{
root: &d2nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d2RTree) Insert(min, max [d2numDims]float64, dataId interface{}) {
var branch d2branchT
branch.data = dataId
for axis := 0; axis < d2numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d2insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d2RTree) Remove(min, max [d2numDims]float64, dataId interface{}) {
var rect d2rectT
for axis := 0; axis < d2numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d2removeRect(&rect, dataId, &tr.root)
}
/// Find all within d2search rectangle
/// \param a_min Min of d2search bounding rect
/// \param a_max Max of d2search bounding rect
/// \param a_searchResult d2search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d2RTree) Search(min, max [d2numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d2rectT
for axis := 0; axis < d2numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d2search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d2RTree) Count() int {
var count int
d2countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d2RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d2nodeT{}
}
func d2countRec(node *d2nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d2countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d2insertRectRec(branch *d2branchT, node *d2nodeT, newNode **d2nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d2nodeT
//var newBranch d2branchT
// find the optimal branch for this record
index := d2pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d2insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d2combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d2nodeCover(node.branch[index].child)
var newBranch d2branchT
newBranch.child = otherNode
newBranch.rect = d2nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d2addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d2addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d2insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d2insertRect(branch *d2branchT, root **d2nodeT, level int) bool {
var newNode *d2nodeT
if d2insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d2nodeT{}
newRoot.level = (*root).level + 1
var newBranch d2branchT
// add old root node as a child of the new root
newBranch.rect = d2nodeCover(*root)
newBranch.child = *root
d2addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d2nodeCover(newNode)
newBranch.child = newNode
d2addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d2nodeCover(node *d2nodeT) d2rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d2combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d2addBranch(branch *d2branchT, node *d2nodeT, newNode **d2nodeT) bool {
if node.count < d2maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d2splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d2disconnectBranch(node *d2nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d2pickBranch(rect *d2rectT, node *d2nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d2rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d2calcRectVolume(curRect)
tempRect = d2combineRect(rect, curRect)
increase = d2calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d2combineRect(rectA, rectB *d2rectT) d2rectT {
var newRect d2rectT
for index := 0; index < d2numDims; index++ {
newRect.min[index] = d2fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d2fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d2splitNode(node *d2nodeT, branch *d2branchT, newNode **d2nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d2partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d2getBranches(node, branch, parVars)
// Find partition
d2choosePartition(parVars, d2minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d2nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d2loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d2rectVolume(rect *d2rectT) float64 {
var volume float64 = 1
for index := 0; index < d2numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d2rectT
func d2rectSphericalVolume(rect *d2rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d2numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d2numDims == 5 {
return (radius * radius * radius * radius * radius * d2unitSphereVolume)
} else if d2numDims == 4 {
return (radius * radius * radius * radius * d2unitSphereVolume)
} else if d2numDims == 3 {
return (radius * radius * radius * d2unitSphereVolume)
} else if d2numDims == 2 {
return (radius * radius * d2unitSphereVolume)
} else {
return (math.Pow(radius, d2numDims) * d2unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d2calcRectVolume(rect *d2rectT) float64 {
if d2useSphericalVolume {
return d2rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d2rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d2getBranches(node *d2nodeT, branch *d2branchT, parVars *d2partitionVarsT) {
// Load the branch buffer
for index := 0; index < d2maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d2maxNodes] = *branch
parVars.branchCount = d2maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d2maxNodes+1; index++ {
parVars.coverSplit = d2combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d2calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d2choosePartition(parVars *d2partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d2initParVars(parVars, parVars.branchCount, minFill)
d2pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d2notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d2combineRect(curRect, &parVars.cover[0])
rect1 := d2combineRect(curRect, &parVars.cover[1])
growth0 := d2calcRectVolume(&rect0) - parVars.area[0]
growth1 := d2calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d2classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d2notTaken == parVars.partition[index] {
d2classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d2loadNodes(nodeA, nodeB *d2nodeT, parVars *d2partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d2nodeT{nodeA, nodeB}
// It is assured that d2addBranch here will not cause a node split.
d2addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d2partitionVarsT structure.
func d2initParVars(parVars *d2partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d2notTaken
}
}
func d2pickSeeds(parVars *d2partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d2maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d2calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d2combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d2calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d2classify(seed0, 0, parVars)
d2classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d2classify(index, group int, parVars *d2partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d2combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d2calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d2rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d2removeRect provides for eliminating the root.
func d2removeRect(rect *d2rectT, id interface{}, root **d2nodeT) bool {
var reInsertList *d2listNodeT
if !d2removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d2insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d2removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d2removeRectRec(rect *d2rectT, id interface{}, node *d2nodeT, listNode **d2listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d2overlap(*rect, node.branch[index].rect) {
if !d2removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d2minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d2nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d2reInsert(node.branch[index].child, listNode)
d2disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d2disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d2overlap.
func d2overlap(rectA, rectB d2rectT) bool {
for index := 0; index < d2numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d2reInsert(node *d2nodeT, listNode **d2listNodeT) {
newListNode := &d2listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d2search in an index tree or subtree for all data retangles that d2overlap the argument rectangle.
func d2search(node *d2nodeT, rect d2rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d2overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d2search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d2overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d3fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d3fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d3numDims = 3
d3maxNodes = 8
d3minNodes = d3maxNodes / 2
d3useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d3unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d3numDims]
type d3RTree struct {
root *d3nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d3rectT struct {
min [d3numDims]float64 ///< Min dimensions of bounding box
max [d3numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d3branchT struct {
rect d3rectT ///< Bounds
child *d3nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d3nodeT for each branch level
type d3nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d3maxNodes]d3branchT ///< Branch
}
func (node *d3nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d3nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d3listNodeT struct {
next *d3listNodeT ///< Next in list
node *d3nodeT ///< Node
}
const d3notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d3partitionVarsT struct {
partition [d3maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d3rectT
area [2]float64
branchBuf [d3maxNodes + 1]d3branchT
branchCount int
coverSplit d3rectT
coverSplitArea float64
}
func d3New() *d3RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d3RTree{
root: &d3nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d3RTree) Insert(min, max [d3numDims]float64, dataId interface{}) {
var branch d3branchT
branch.data = dataId
for axis := 0; axis < d3numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d3insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d3RTree) Remove(min, max [d3numDims]float64, dataId interface{}) {
var rect d3rectT
for axis := 0; axis < d3numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d3removeRect(&rect, dataId, &tr.root)
}
/// Find all within d3search rectangle
/// \param a_min Min of d3search bounding rect
/// \param a_max Max of d3search bounding rect
/// \param a_searchResult d3search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d3RTree) Search(min, max [d3numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d3rectT
for axis := 0; axis < d3numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d3search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d3RTree) Count() int {
var count int
d3countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d3RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d3nodeT{}
}
func d3countRec(node *d3nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d3countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d3insertRectRec(branch *d3branchT, node *d3nodeT, newNode **d3nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d3nodeT
//var newBranch d3branchT
// find the optimal branch for this record
index := d3pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d3insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d3combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d3nodeCover(node.branch[index].child)
var newBranch d3branchT
newBranch.child = otherNode
newBranch.rect = d3nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d3addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d3addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d3insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d3insertRect(branch *d3branchT, root **d3nodeT, level int) bool {
var newNode *d3nodeT
if d3insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d3nodeT{}
newRoot.level = (*root).level + 1
var newBranch d3branchT
// add old root node as a child of the new root
newBranch.rect = d3nodeCover(*root)
newBranch.child = *root
d3addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d3nodeCover(newNode)
newBranch.child = newNode
d3addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d3nodeCover(node *d3nodeT) d3rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d3combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d3addBranch(branch *d3branchT, node *d3nodeT, newNode **d3nodeT) bool {
if node.count < d3maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d3splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d3disconnectBranch(node *d3nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d3pickBranch(rect *d3rectT, node *d3nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d3rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d3calcRectVolume(curRect)
tempRect = d3combineRect(rect, curRect)
increase = d3calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d3combineRect(rectA, rectB *d3rectT) d3rectT {
var newRect d3rectT
for index := 0; index < d3numDims; index++ {
newRect.min[index] = d3fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d3fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d3splitNode(node *d3nodeT, branch *d3branchT, newNode **d3nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d3partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d3getBranches(node, branch, parVars)
// Find partition
d3choosePartition(parVars, d3minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d3nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d3loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d3rectVolume(rect *d3rectT) float64 {
var volume float64 = 1
for index := 0; index < d3numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d3rectT
func d3rectSphericalVolume(rect *d3rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d3numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d3numDims == 5 {
return (radius * radius * radius * radius * radius * d3unitSphereVolume)
} else if d3numDims == 4 {
return (radius * radius * radius * radius * d3unitSphereVolume)
} else if d3numDims == 3 {
return (radius * radius * radius * d3unitSphereVolume)
} else if d3numDims == 2 {
return (radius * radius * d3unitSphereVolume)
} else {
return (math.Pow(radius, d3numDims) * d3unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d3calcRectVolume(rect *d3rectT) float64 {
if d3useSphericalVolume {
return d3rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d3rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d3getBranches(node *d3nodeT, branch *d3branchT, parVars *d3partitionVarsT) {
// Load the branch buffer
for index := 0; index < d3maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d3maxNodes] = *branch
parVars.branchCount = d3maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d3maxNodes+1; index++ {
parVars.coverSplit = d3combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d3calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d3choosePartition(parVars *d3partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d3initParVars(parVars, parVars.branchCount, minFill)
d3pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d3notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d3combineRect(curRect, &parVars.cover[0])
rect1 := d3combineRect(curRect, &parVars.cover[1])
growth0 := d3calcRectVolume(&rect0) - parVars.area[0]
growth1 := d3calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d3classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d3notTaken == parVars.partition[index] {
d3classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d3loadNodes(nodeA, nodeB *d3nodeT, parVars *d3partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d3nodeT{nodeA, nodeB}
// It is assured that d3addBranch here will not cause a node split.
d3addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d3partitionVarsT structure.
func d3initParVars(parVars *d3partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d3notTaken
}
}
func d3pickSeeds(parVars *d3partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d3maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d3calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d3combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d3calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d3classify(seed0, 0, parVars)
d3classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d3classify(index, group int, parVars *d3partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d3combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d3calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d3rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d3removeRect provides for eliminating the root.
func d3removeRect(rect *d3rectT, id interface{}, root **d3nodeT) bool {
var reInsertList *d3listNodeT
if !d3removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d3insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d3removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d3removeRectRec(rect *d3rectT, id interface{}, node *d3nodeT, listNode **d3listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d3overlap(*rect, node.branch[index].rect) {
if !d3removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d3minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d3nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d3reInsert(node.branch[index].child, listNode)
d3disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d3disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d3overlap.
func d3overlap(rectA, rectB d3rectT) bool {
for index := 0; index < d3numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d3reInsert(node *d3nodeT, listNode **d3listNodeT) {
newListNode := &d3listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d3search in an index tree or subtree for all data retangles that d3overlap the argument rectangle.
func d3search(node *d3nodeT, rect d3rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d3overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d3search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d3overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d4fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d4fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d4numDims = 4
d4maxNodes = 8
d4minNodes = d4maxNodes / 2
d4useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d4unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d4numDims]
type d4RTree struct {
root *d4nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d4rectT struct {
min [d4numDims]float64 ///< Min dimensions of bounding box
max [d4numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d4branchT struct {
rect d4rectT ///< Bounds
child *d4nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d4nodeT for each branch level
type d4nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d4maxNodes]d4branchT ///< Branch
}
func (node *d4nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d4nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d4listNodeT struct {
next *d4listNodeT ///< Next in list
node *d4nodeT ///< Node
}
const d4notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d4partitionVarsT struct {
partition [d4maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d4rectT
area [2]float64
branchBuf [d4maxNodes + 1]d4branchT
branchCount int
coverSplit d4rectT
coverSplitArea float64
}
func d4New() *d4RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d4RTree{
root: &d4nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d4RTree) Insert(min, max [d4numDims]float64, dataId interface{}) {
var branch d4branchT
branch.data = dataId
for axis := 0; axis < d4numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d4insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d4RTree) Remove(min, max [d4numDims]float64, dataId interface{}) {
var rect d4rectT
for axis := 0; axis < d4numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d4removeRect(&rect, dataId, &tr.root)
}
/// Find all within d4search rectangle
/// \param a_min Min of d4search bounding rect
/// \param a_max Max of d4search bounding rect
/// \param a_searchResult d4search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d4RTree) Search(min, max [d4numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d4rectT
for axis := 0; axis < d4numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d4search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d4RTree) Count() int {
var count int
d4countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d4RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d4nodeT{}
}
func d4countRec(node *d4nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d4countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d4insertRectRec(branch *d4branchT, node *d4nodeT, newNode **d4nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d4nodeT
//var newBranch d4branchT
// find the optimal branch for this record
index := d4pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d4insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d4combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d4nodeCover(node.branch[index].child)
var newBranch d4branchT
newBranch.child = otherNode
newBranch.rect = d4nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d4addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d4addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d4insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d4insertRect(branch *d4branchT, root **d4nodeT, level int) bool {
var newNode *d4nodeT
if d4insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d4nodeT{}
newRoot.level = (*root).level + 1
var newBranch d4branchT
// add old root node as a child of the new root
newBranch.rect = d4nodeCover(*root)
newBranch.child = *root
d4addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d4nodeCover(newNode)
newBranch.child = newNode
d4addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d4nodeCover(node *d4nodeT) d4rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d4combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d4addBranch(branch *d4branchT, node *d4nodeT, newNode **d4nodeT) bool {
if node.count < d4maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d4splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d4disconnectBranch(node *d4nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d4pickBranch(rect *d4rectT, node *d4nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d4rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d4calcRectVolume(curRect)
tempRect = d4combineRect(rect, curRect)
increase = d4calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d4combineRect(rectA, rectB *d4rectT) d4rectT {
var newRect d4rectT
for index := 0; index < d4numDims; index++ {
newRect.min[index] = d4fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d4fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d4splitNode(node *d4nodeT, branch *d4branchT, newNode **d4nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d4partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d4getBranches(node, branch, parVars)
// Find partition
d4choosePartition(parVars, d4minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d4nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d4loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d4rectVolume(rect *d4rectT) float64 {
var volume float64 = 1
for index := 0; index < d4numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d4rectT
func d4rectSphericalVolume(rect *d4rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d4numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d4numDims == 5 {
return (radius * radius * radius * radius * radius * d4unitSphereVolume)
} else if d4numDims == 4 {
return (radius * radius * radius * radius * d4unitSphereVolume)
} else if d4numDims == 3 {
return (radius * radius * radius * d4unitSphereVolume)
} else if d4numDims == 2 {
return (radius * radius * d4unitSphereVolume)
} else {
return (math.Pow(radius, d4numDims) * d4unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d4calcRectVolume(rect *d4rectT) float64 {
if d4useSphericalVolume {
return d4rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d4rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d4getBranches(node *d4nodeT, branch *d4branchT, parVars *d4partitionVarsT) {
// Load the branch buffer
for index := 0; index < d4maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d4maxNodes] = *branch
parVars.branchCount = d4maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d4maxNodes+1; index++ {
parVars.coverSplit = d4combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d4calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d4choosePartition(parVars *d4partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d4initParVars(parVars, parVars.branchCount, minFill)
d4pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d4notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d4combineRect(curRect, &parVars.cover[0])
rect1 := d4combineRect(curRect, &parVars.cover[1])
growth0 := d4calcRectVolume(&rect0) - parVars.area[0]
growth1 := d4calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d4classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d4notTaken == parVars.partition[index] {
d4classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d4loadNodes(nodeA, nodeB *d4nodeT, parVars *d4partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d4nodeT{nodeA, nodeB}
// It is assured that d4addBranch here will not cause a node split.
d4addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d4partitionVarsT structure.
func d4initParVars(parVars *d4partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d4notTaken
}
}
func d4pickSeeds(parVars *d4partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d4maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d4calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d4combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d4calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d4classify(seed0, 0, parVars)
d4classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d4classify(index, group int, parVars *d4partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d4combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d4calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d4rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d4removeRect provides for eliminating the root.
func d4removeRect(rect *d4rectT, id interface{}, root **d4nodeT) bool {
var reInsertList *d4listNodeT
if !d4removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d4insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d4removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d4removeRectRec(rect *d4rectT, id interface{}, node *d4nodeT, listNode **d4listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d4overlap(*rect, node.branch[index].rect) {
if !d4removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d4minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d4nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d4reInsert(node.branch[index].child, listNode)
d4disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d4disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d4overlap.
func d4overlap(rectA, rectB d4rectT) bool {
for index := 0; index < d4numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d4reInsert(node *d4nodeT, listNode **d4listNodeT) {
newListNode := &d4listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d4search in an index tree or subtree for all data retangles that d4overlap the argument rectangle.
func d4search(node *d4nodeT, rect d4rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d4overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d4search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d4overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d5fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d5fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d5numDims = 5
d5maxNodes = 8
d5minNodes = d5maxNodes / 2
d5useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d5unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d5numDims]
type d5RTree struct {
root *d5nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d5rectT struct {
min [d5numDims]float64 ///< Min dimensions of bounding box
max [d5numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d5branchT struct {
rect d5rectT ///< Bounds
child *d5nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d5nodeT for each branch level
type d5nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d5maxNodes]d5branchT ///< Branch
}
func (node *d5nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d5nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d5listNodeT struct {
next *d5listNodeT ///< Next in list
node *d5nodeT ///< Node
}
const d5notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d5partitionVarsT struct {
partition [d5maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d5rectT
area [2]float64
branchBuf [d5maxNodes + 1]d5branchT
branchCount int
coverSplit d5rectT
coverSplitArea float64
}
func d5New() *d5RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d5RTree{
root: &d5nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d5RTree) Insert(min, max [d5numDims]float64, dataId interface{}) {
var branch d5branchT
branch.data = dataId
for axis := 0; axis < d5numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d5insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d5RTree) Remove(min, max [d5numDims]float64, dataId interface{}) {
var rect d5rectT
for axis := 0; axis < d5numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d5removeRect(&rect, dataId, &tr.root)
}
/// Find all within d5search rectangle
/// \param a_min Min of d5search bounding rect
/// \param a_max Max of d5search bounding rect
/// \param a_searchResult d5search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d5RTree) Search(min, max [d5numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d5rectT
for axis := 0; axis < d5numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d5search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d5RTree) Count() int {
var count int
d5countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d5RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d5nodeT{}
}
func d5countRec(node *d5nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d5countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d5insertRectRec(branch *d5branchT, node *d5nodeT, newNode **d5nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d5nodeT
//var newBranch d5branchT
// find the optimal branch for this record
index := d5pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d5insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d5combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d5nodeCover(node.branch[index].child)
var newBranch d5branchT
newBranch.child = otherNode
newBranch.rect = d5nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d5addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d5addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d5insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d5insertRect(branch *d5branchT, root **d5nodeT, level int) bool {
var newNode *d5nodeT
if d5insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d5nodeT{}
newRoot.level = (*root).level + 1
var newBranch d5branchT
// add old root node as a child of the new root
newBranch.rect = d5nodeCover(*root)
newBranch.child = *root
d5addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d5nodeCover(newNode)
newBranch.child = newNode
d5addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d5nodeCover(node *d5nodeT) d5rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d5combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d5addBranch(branch *d5branchT, node *d5nodeT, newNode **d5nodeT) bool {
if node.count < d5maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d5splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d5disconnectBranch(node *d5nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d5pickBranch(rect *d5rectT, node *d5nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d5rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d5calcRectVolume(curRect)
tempRect = d5combineRect(rect, curRect)
increase = d5calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d5combineRect(rectA, rectB *d5rectT) d5rectT {
var newRect d5rectT
for index := 0; index < d5numDims; index++ {
newRect.min[index] = d5fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d5fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d5splitNode(node *d5nodeT, branch *d5branchT, newNode **d5nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d5partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d5getBranches(node, branch, parVars)
// Find partition
d5choosePartition(parVars, d5minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d5nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d5loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d5rectVolume(rect *d5rectT) float64 {
var volume float64 = 1
for index := 0; index < d5numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d5rectT
func d5rectSphericalVolume(rect *d5rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d5numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d5numDims == 5 {
return (radius * radius * radius * radius * radius * d5unitSphereVolume)
} else if d5numDims == 4 {
return (radius * radius * radius * radius * d5unitSphereVolume)
} else if d5numDims == 3 {
return (radius * radius * radius * d5unitSphereVolume)
} else if d5numDims == 2 {
return (radius * radius * d5unitSphereVolume)
} else {
return (math.Pow(radius, d5numDims) * d5unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d5calcRectVolume(rect *d5rectT) float64 {
if d5useSphericalVolume {
return d5rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d5rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d5getBranches(node *d5nodeT, branch *d5branchT, parVars *d5partitionVarsT) {
// Load the branch buffer
for index := 0; index < d5maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d5maxNodes] = *branch
parVars.branchCount = d5maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d5maxNodes+1; index++ {
parVars.coverSplit = d5combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d5calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d5choosePartition(parVars *d5partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d5initParVars(parVars, parVars.branchCount, minFill)
d5pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d5notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d5combineRect(curRect, &parVars.cover[0])
rect1 := d5combineRect(curRect, &parVars.cover[1])
growth0 := d5calcRectVolume(&rect0) - parVars.area[0]
growth1 := d5calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d5classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d5notTaken == parVars.partition[index] {
d5classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d5loadNodes(nodeA, nodeB *d5nodeT, parVars *d5partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d5nodeT{nodeA, nodeB}
// It is assured that d5addBranch here will not cause a node split.
d5addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d5partitionVarsT structure.
func d5initParVars(parVars *d5partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d5notTaken
}
}
func d5pickSeeds(parVars *d5partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d5maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d5calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d5combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d5calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d5classify(seed0, 0, parVars)
d5classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d5classify(index, group int, parVars *d5partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d5combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d5calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d5rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d5removeRect provides for eliminating the root.
func d5removeRect(rect *d5rectT, id interface{}, root **d5nodeT) bool {
var reInsertList *d5listNodeT
if !d5removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d5insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d5removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d5removeRectRec(rect *d5rectT, id interface{}, node *d5nodeT, listNode **d5listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d5overlap(*rect, node.branch[index].rect) {
if !d5removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d5minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d5nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d5reInsert(node.branch[index].child, listNode)
d5disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d5disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d5overlap.
func d5overlap(rectA, rectB d5rectT) bool {
for index := 0; index < d5numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d5reInsert(node *d5nodeT, listNode **d5listNodeT) {
newListNode := &d5listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d5search in an index tree or subtree for all data retangles that d5overlap the argument rectangle.
func d5search(node *d5nodeT, rect d5rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d5overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d5search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d5overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d6fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d6fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d6numDims = 6
d6maxNodes = 8
d6minNodes = d6maxNodes / 2
d6useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d6unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d6numDims]
type d6RTree struct {
root *d6nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d6rectT struct {
min [d6numDims]float64 ///< Min dimensions of bounding box
max [d6numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d6branchT struct {
rect d6rectT ///< Bounds
child *d6nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d6nodeT for each branch level
type d6nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d6maxNodes]d6branchT ///< Branch
}
func (node *d6nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d6nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d6listNodeT struct {
next *d6listNodeT ///< Next in list
node *d6nodeT ///< Node
}
const d6notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d6partitionVarsT struct {
partition [d6maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d6rectT
area [2]float64
branchBuf [d6maxNodes + 1]d6branchT
branchCount int
coverSplit d6rectT
coverSplitArea float64
}
func d6New() *d6RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d6RTree{
root: &d6nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d6RTree) Insert(min, max [d6numDims]float64, dataId interface{}) {
var branch d6branchT
branch.data = dataId
for axis := 0; axis < d6numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d6insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d6RTree) Remove(min, max [d6numDims]float64, dataId interface{}) {
var rect d6rectT
for axis := 0; axis < d6numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d6removeRect(&rect, dataId, &tr.root)
}
/// Find all within d6search rectangle
/// \param a_min Min of d6search bounding rect
/// \param a_max Max of d6search bounding rect
/// \param a_searchResult d6search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d6RTree) Search(min, max [d6numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d6rectT
for axis := 0; axis < d6numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d6search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d6RTree) Count() int {
var count int
d6countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d6RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d6nodeT{}
}
func d6countRec(node *d6nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d6countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d6insertRectRec(branch *d6branchT, node *d6nodeT, newNode **d6nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d6nodeT
//var newBranch d6branchT
// find the optimal branch for this record
index := d6pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d6insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d6combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d6nodeCover(node.branch[index].child)
var newBranch d6branchT
newBranch.child = otherNode
newBranch.rect = d6nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d6addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d6addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d6insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d6insertRect(branch *d6branchT, root **d6nodeT, level int) bool {
var newNode *d6nodeT
if d6insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d6nodeT{}
newRoot.level = (*root).level + 1
var newBranch d6branchT
// add old root node as a child of the new root
newBranch.rect = d6nodeCover(*root)
newBranch.child = *root
d6addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d6nodeCover(newNode)
newBranch.child = newNode
d6addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d6nodeCover(node *d6nodeT) d6rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d6combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d6addBranch(branch *d6branchT, node *d6nodeT, newNode **d6nodeT) bool {
if node.count < d6maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d6splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d6disconnectBranch(node *d6nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d6pickBranch(rect *d6rectT, node *d6nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d6rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d6calcRectVolume(curRect)
tempRect = d6combineRect(rect, curRect)
increase = d6calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d6combineRect(rectA, rectB *d6rectT) d6rectT {
var newRect d6rectT
for index := 0; index < d6numDims; index++ {
newRect.min[index] = d6fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d6fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d6splitNode(node *d6nodeT, branch *d6branchT, newNode **d6nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d6partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d6getBranches(node, branch, parVars)
// Find partition
d6choosePartition(parVars, d6minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d6nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d6loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d6rectVolume(rect *d6rectT) float64 {
var volume float64 = 1
for index := 0; index < d6numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d6rectT
func d6rectSphericalVolume(rect *d6rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d6numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d6numDims == 5 {
return (radius * radius * radius * radius * radius * d6unitSphereVolume)
} else if d6numDims == 4 {
return (radius * radius * radius * radius * d6unitSphereVolume)
} else if d6numDims == 3 {
return (radius * radius * radius * d6unitSphereVolume)
} else if d6numDims == 2 {
return (radius * radius * d6unitSphereVolume)
} else {
return (math.Pow(radius, d6numDims) * d6unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d6calcRectVolume(rect *d6rectT) float64 {
if d6useSphericalVolume {
return d6rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d6rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d6getBranches(node *d6nodeT, branch *d6branchT, parVars *d6partitionVarsT) {
// Load the branch buffer
for index := 0; index < d6maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d6maxNodes] = *branch
parVars.branchCount = d6maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d6maxNodes+1; index++ {
parVars.coverSplit = d6combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d6calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d6choosePartition(parVars *d6partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d6initParVars(parVars, parVars.branchCount, minFill)
d6pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d6notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d6combineRect(curRect, &parVars.cover[0])
rect1 := d6combineRect(curRect, &parVars.cover[1])
growth0 := d6calcRectVolume(&rect0) - parVars.area[0]
growth1 := d6calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d6classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d6notTaken == parVars.partition[index] {
d6classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d6loadNodes(nodeA, nodeB *d6nodeT, parVars *d6partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d6nodeT{nodeA, nodeB}
// It is assured that d6addBranch here will not cause a node split.
d6addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d6partitionVarsT structure.
func d6initParVars(parVars *d6partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d6notTaken
}
}
func d6pickSeeds(parVars *d6partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d6maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d6calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d6combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d6calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d6classify(seed0, 0, parVars)
d6classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d6classify(index, group int, parVars *d6partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d6combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d6calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d6rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d6removeRect provides for eliminating the root.
func d6removeRect(rect *d6rectT, id interface{}, root **d6nodeT) bool {
var reInsertList *d6listNodeT
if !d6removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d6insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d6removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d6removeRectRec(rect *d6rectT, id interface{}, node *d6nodeT, listNode **d6listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d6overlap(*rect, node.branch[index].rect) {
if !d6removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d6minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d6nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d6reInsert(node.branch[index].child, listNode)
d6disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d6disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d6overlap.
func d6overlap(rectA, rectB d6rectT) bool {
for index := 0; index < d6numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d6reInsert(node *d6nodeT, listNode **d6listNodeT) {
newListNode := &d6listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d6search in an index tree or subtree for all data retangles that d6overlap the argument rectangle.
func d6search(node *d6nodeT, rect d6rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d6overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d6search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d6overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d7fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d7fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d7numDims = 7
d7maxNodes = 8
d7minNodes = d7maxNodes / 2
d7useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d7unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d7numDims]
type d7RTree struct {
root *d7nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d7rectT struct {
min [d7numDims]float64 ///< Min dimensions of bounding box
max [d7numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d7branchT struct {
rect d7rectT ///< Bounds
child *d7nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d7nodeT for each branch level
type d7nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d7maxNodes]d7branchT ///< Branch
}
func (node *d7nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d7nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d7listNodeT struct {
next *d7listNodeT ///< Next in list
node *d7nodeT ///< Node
}
const d7notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d7partitionVarsT struct {
partition [d7maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d7rectT
area [2]float64
branchBuf [d7maxNodes + 1]d7branchT
branchCount int
coverSplit d7rectT
coverSplitArea float64
}
func d7New() *d7RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d7RTree{
root: &d7nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d7RTree) Insert(min, max [d7numDims]float64, dataId interface{}) {
var branch d7branchT
branch.data = dataId
for axis := 0; axis < d7numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d7insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d7RTree) Remove(min, max [d7numDims]float64, dataId interface{}) {
var rect d7rectT
for axis := 0; axis < d7numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d7removeRect(&rect, dataId, &tr.root)
}
/// Find all within d7search rectangle
/// \param a_min Min of d7search bounding rect
/// \param a_max Max of d7search bounding rect
/// \param a_searchResult d7search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d7RTree) Search(min, max [d7numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d7rectT
for axis := 0; axis < d7numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d7search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d7RTree) Count() int {
var count int
d7countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d7RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d7nodeT{}
}
func d7countRec(node *d7nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d7countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d7insertRectRec(branch *d7branchT, node *d7nodeT, newNode **d7nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d7nodeT
//var newBranch d7branchT
// find the optimal branch for this record
index := d7pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d7insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d7combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d7nodeCover(node.branch[index].child)
var newBranch d7branchT
newBranch.child = otherNode
newBranch.rect = d7nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d7addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d7addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d7insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d7insertRect(branch *d7branchT, root **d7nodeT, level int) bool {
var newNode *d7nodeT
if d7insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d7nodeT{}
newRoot.level = (*root).level + 1
var newBranch d7branchT
// add old root node as a child of the new root
newBranch.rect = d7nodeCover(*root)
newBranch.child = *root
d7addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d7nodeCover(newNode)
newBranch.child = newNode
d7addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d7nodeCover(node *d7nodeT) d7rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d7combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d7addBranch(branch *d7branchT, node *d7nodeT, newNode **d7nodeT) bool {
if node.count < d7maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d7splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d7disconnectBranch(node *d7nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d7pickBranch(rect *d7rectT, node *d7nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d7rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d7calcRectVolume(curRect)
tempRect = d7combineRect(rect, curRect)
increase = d7calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d7combineRect(rectA, rectB *d7rectT) d7rectT {
var newRect d7rectT
for index := 0; index < d7numDims; index++ {
newRect.min[index] = d7fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d7fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d7splitNode(node *d7nodeT, branch *d7branchT, newNode **d7nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d7partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d7getBranches(node, branch, parVars)
// Find partition
d7choosePartition(parVars, d7minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d7nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d7loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d7rectVolume(rect *d7rectT) float64 {
var volume float64 = 1
for index := 0; index < d7numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d7rectT
func d7rectSphericalVolume(rect *d7rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d7numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d7numDims == 5 {
return (radius * radius * radius * radius * radius * d7unitSphereVolume)
} else if d7numDims == 4 {
return (radius * radius * radius * radius * d7unitSphereVolume)
} else if d7numDims == 3 {
return (radius * radius * radius * d7unitSphereVolume)
} else if d7numDims == 2 {
return (radius * radius * d7unitSphereVolume)
} else {
return (math.Pow(radius, d7numDims) * d7unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d7calcRectVolume(rect *d7rectT) float64 {
if d7useSphericalVolume {
return d7rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d7rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d7getBranches(node *d7nodeT, branch *d7branchT, parVars *d7partitionVarsT) {
// Load the branch buffer
for index := 0; index < d7maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d7maxNodes] = *branch
parVars.branchCount = d7maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d7maxNodes+1; index++ {
parVars.coverSplit = d7combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d7calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d7choosePartition(parVars *d7partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d7initParVars(parVars, parVars.branchCount, minFill)
d7pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d7notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d7combineRect(curRect, &parVars.cover[0])
rect1 := d7combineRect(curRect, &parVars.cover[1])
growth0 := d7calcRectVolume(&rect0) - parVars.area[0]
growth1 := d7calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d7classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d7notTaken == parVars.partition[index] {
d7classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d7loadNodes(nodeA, nodeB *d7nodeT, parVars *d7partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d7nodeT{nodeA, nodeB}
// It is assured that d7addBranch here will not cause a node split.
d7addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d7partitionVarsT structure.
func d7initParVars(parVars *d7partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d7notTaken
}
}
func d7pickSeeds(parVars *d7partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d7maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d7calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d7combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d7calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d7classify(seed0, 0, parVars)
d7classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d7classify(index, group int, parVars *d7partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d7combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d7calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d7rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d7removeRect provides for eliminating the root.
func d7removeRect(rect *d7rectT, id interface{}, root **d7nodeT) bool {
var reInsertList *d7listNodeT
if !d7removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d7insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d7removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d7removeRectRec(rect *d7rectT, id interface{}, node *d7nodeT, listNode **d7listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d7overlap(*rect, node.branch[index].rect) {
if !d7removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d7minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d7nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d7reInsert(node.branch[index].child, listNode)
d7disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d7disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d7overlap.
func d7overlap(rectA, rectB d7rectT) bool {
for index := 0; index < d7numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d7reInsert(node *d7nodeT, listNode **d7listNodeT) {
newListNode := &d7listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d7search in an index tree or subtree for all data retangles that d7overlap the argument rectangle.
func d7search(node *d7nodeT, rect d7rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d7overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d7search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d7overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d8fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d8fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d8numDims = 8
d8maxNodes = 8
d8minNodes = d8maxNodes / 2
d8useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d8unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d8numDims]
type d8RTree struct {
root *d8nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d8rectT struct {
min [d8numDims]float64 ///< Min dimensions of bounding box
max [d8numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d8branchT struct {
rect d8rectT ///< Bounds
child *d8nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d8nodeT for each branch level
type d8nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d8maxNodes]d8branchT ///< Branch
}
func (node *d8nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d8nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d8listNodeT struct {
next *d8listNodeT ///< Next in list
node *d8nodeT ///< Node
}
const d8notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d8partitionVarsT struct {
partition [d8maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d8rectT
area [2]float64
branchBuf [d8maxNodes + 1]d8branchT
branchCount int
coverSplit d8rectT
coverSplitArea float64
}
func d8New() *d8RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d8RTree{
root: &d8nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d8RTree) Insert(min, max [d8numDims]float64, dataId interface{}) {
var branch d8branchT
branch.data = dataId
for axis := 0; axis < d8numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d8insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d8RTree) Remove(min, max [d8numDims]float64, dataId interface{}) {
var rect d8rectT
for axis := 0; axis < d8numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d8removeRect(&rect, dataId, &tr.root)
}
/// Find all within d8search rectangle
/// \param a_min Min of d8search bounding rect
/// \param a_max Max of d8search bounding rect
/// \param a_searchResult d8search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d8RTree) Search(min, max [d8numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d8rectT
for axis := 0; axis < d8numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d8search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d8RTree) Count() int {
var count int
d8countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d8RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d8nodeT{}
}
func d8countRec(node *d8nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d8countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d8insertRectRec(branch *d8branchT, node *d8nodeT, newNode **d8nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d8nodeT
//var newBranch d8branchT
// find the optimal branch for this record
index := d8pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d8insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d8combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d8nodeCover(node.branch[index].child)
var newBranch d8branchT
newBranch.child = otherNode
newBranch.rect = d8nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d8addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d8addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d8insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d8insertRect(branch *d8branchT, root **d8nodeT, level int) bool {
var newNode *d8nodeT
if d8insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d8nodeT{}
newRoot.level = (*root).level + 1
var newBranch d8branchT
// add old root node as a child of the new root
newBranch.rect = d8nodeCover(*root)
newBranch.child = *root
d8addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d8nodeCover(newNode)
newBranch.child = newNode
d8addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d8nodeCover(node *d8nodeT) d8rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d8combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d8addBranch(branch *d8branchT, node *d8nodeT, newNode **d8nodeT) bool {
if node.count < d8maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d8splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d8disconnectBranch(node *d8nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d8pickBranch(rect *d8rectT, node *d8nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d8rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d8calcRectVolume(curRect)
tempRect = d8combineRect(rect, curRect)
increase = d8calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d8combineRect(rectA, rectB *d8rectT) d8rectT {
var newRect d8rectT
for index := 0; index < d8numDims; index++ {
newRect.min[index] = d8fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d8fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d8splitNode(node *d8nodeT, branch *d8branchT, newNode **d8nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d8partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d8getBranches(node, branch, parVars)
// Find partition
d8choosePartition(parVars, d8minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d8nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d8loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d8rectVolume(rect *d8rectT) float64 {
var volume float64 = 1
for index := 0; index < d8numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d8rectT
func d8rectSphericalVolume(rect *d8rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d8numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d8numDims == 5 {
return (radius * radius * radius * radius * radius * d8unitSphereVolume)
} else if d8numDims == 4 {
return (radius * radius * radius * radius * d8unitSphereVolume)
} else if d8numDims == 3 {
return (radius * radius * radius * d8unitSphereVolume)
} else if d8numDims == 2 {
return (radius * radius * d8unitSphereVolume)
} else {
return (math.Pow(radius, d8numDims) * d8unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d8calcRectVolume(rect *d8rectT) float64 {
if d8useSphericalVolume {
return d8rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d8rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d8getBranches(node *d8nodeT, branch *d8branchT, parVars *d8partitionVarsT) {
// Load the branch buffer
for index := 0; index < d8maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d8maxNodes] = *branch
parVars.branchCount = d8maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d8maxNodes+1; index++ {
parVars.coverSplit = d8combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d8calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d8choosePartition(parVars *d8partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d8initParVars(parVars, parVars.branchCount, minFill)
d8pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d8notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d8combineRect(curRect, &parVars.cover[0])
rect1 := d8combineRect(curRect, &parVars.cover[1])
growth0 := d8calcRectVolume(&rect0) - parVars.area[0]
growth1 := d8calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d8classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d8notTaken == parVars.partition[index] {
d8classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d8loadNodes(nodeA, nodeB *d8nodeT, parVars *d8partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d8nodeT{nodeA, nodeB}
// It is assured that d8addBranch here will not cause a node split.
d8addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d8partitionVarsT structure.
func d8initParVars(parVars *d8partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d8notTaken
}
}
func d8pickSeeds(parVars *d8partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d8maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d8calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d8combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d8calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d8classify(seed0, 0, parVars)
d8classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d8classify(index, group int, parVars *d8partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d8combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d8calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d8rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d8removeRect provides for eliminating the root.
func d8removeRect(rect *d8rectT, id interface{}, root **d8nodeT) bool {
var reInsertList *d8listNodeT
if !d8removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d8insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d8removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d8removeRectRec(rect *d8rectT, id interface{}, node *d8nodeT, listNode **d8listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d8overlap(*rect, node.branch[index].rect) {
if !d8removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d8minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d8nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d8reInsert(node.branch[index].child, listNode)
d8disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d8disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d8overlap.
func d8overlap(rectA, rectB d8rectT) bool {
for index := 0; index < d8numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d8reInsert(node *d8nodeT, listNode **d8listNodeT) {
newListNode := &d8listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d8search in an index tree or subtree for all data retangles that d8overlap the argument rectangle.
func d8search(node *d8nodeT, rect d8rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d8overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d8search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d8overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d9fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d9fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d9numDims = 9
d9maxNodes = 8
d9minNodes = d9maxNodes / 2
d9useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d9unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d9numDims]
type d9RTree struct {
root *d9nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d9rectT struct {
min [d9numDims]float64 ///< Min dimensions of bounding box
max [d9numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d9branchT struct {
rect d9rectT ///< Bounds
child *d9nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d9nodeT for each branch level
type d9nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d9maxNodes]d9branchT ///< Branch
}
func (node *d9nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d9nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d9listNodeT struct {
next *d9listNodeT ///< Next in list
node *d9nodeT ///< Node
}
const d9notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d9partitionVarsT struct {
partition [d9maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d9rectT
area [2]float64
branchBuf [d9maxNodes + 1]d9branchT
branchCount int
coverSplit d9rectT
coverSplitArea float64
}
func d9New() *d9RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d9RTree{
root: &d9nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d9RTree) Insert(min, max [d9numDims]float64, dataId interface{}) {
var branch d9branchT
branch.data = dataId
for axis := 0; axis < d9numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d9insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d9RTree) Remove(min, max [d9numDims]float64, dataId interface{}) {
var rect d9rectT
for axis := 0; axis < d9numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d9removeRect(&rect, dataId, &tr.root)
}
/// Find all within d9search rectangle
/// \param a_min Min of d9search bounding rect
/// \param a_max Max of d9search bounding rect
/// \param a_searchResult d9search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d9RTree) Search(min, max [d9numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d9rectT
for axis := 0; axis < d9numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d9search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d9RTree) Count() int {
var count int
d9countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d9RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d9nodeT{}
}
func d9countRec(node *d9nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d9countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d9insertRectRec(branch *d9branchT, node *d9nodeT, newNode **d9nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d9nodeT
//var newBranch d9branchT
// find the optimal branch for this record
index := d9pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d9insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d9combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d9nodeCover(node.branch[index].child)
var newBranch d9branchT
newBranch.child = otherNode
newBranch.rect = d9nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d9addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d9addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d9insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d9insertRect(branch *d9branchT, root **d9nodeT, level int) bool {
var newNode *d9nodeT
if d9insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d9nodeT{}
newRoot.level = (*root).level + 1
var newBranch d9branchT
// add old root node as a child of the new root
newBranch.rect = d9nodeCover(*root)
newBranch.child = *root
d9addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d9nodeCover(newNode)
newBranch.child = newNode
d9addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d9nodeCover(node *d9nodeT) d9rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d9combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d9addBranch(branch *d9branchT, node *d9nodeT, newNode **d9nodeT) bool {
if node.count < d9maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d9splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d9disconnectBranch(node *d9nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d9pickBranch(rect *d9rectT, node *d9nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d9rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d9calcRectVolume(curRect)
tempRect = d9combineRect(rect, curRect)
increase = d9calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d9combineRect(rectA, rectB *d9rectT) d9rectT {
var newRect d9rectT
for index := 0; index < d9numDims; index++ {
newRect.min[index] = d9fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d9fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d9splitNode(node *d9nodeT, branch *d9branchT, newNode **d9nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d9partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d9getBranches(node, branch, parVars)
// Find partition
d9choosePartition(parVars, d9minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d9nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d9loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d9rectVolume(rect *d9rectT) float64 {
var volume float64 = 1
for index := 0; index < d9numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d9rectT
func d9rectSphericalVolume(rect *d9rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d9numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d9numDims == 5 {
return (radius * radius * radius * radius * radius * d9unitSphereVolume)
} else if d9numDims == 4 {
return (radius * radius * radius * radius * d9unitSphereVolume)
} else if d9numDims == 3 {
return (radius * radius * radius * d9unitSphereVolume)
} else if d9numDims == 2 {
return (radius * radius * d9unitSphereVolume)
} else {
return (math.Pow(radius, d9numDims) * d9unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d9calcRectVolume(rect *d9rectT) float64 {
if d9useSphericalVolume {
return d9rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d9rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d9getBranches(node *d9nodeT, branch *d9branchT, parVars *d9partitionVarsT) {
// Load the branch buffer
for index := 0; index < d9maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d9maxNodes] = *branch
parVars.branchCount = d9maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d9maxNodes+1; index++ {
parVars.coverSplit = d9combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d9calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d9choosePartition(parVars *d9partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d9initParVars(parVars, parVars.branchCount, minFill)
d9pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d9notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d9combineRect(curRect, &parVars.cover[0])
rect1 := d9combineRect(curRect, &parVars.cover[1])
growth0 := d9calcRectVolume(&rect0) - parVars.area[0]
growth1 := d9calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d9classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d9notTaken == parVars.partition[index] {
d9classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d9loadNodes(nodeA, nodeB *d9nodeT, parVars *d9partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d9nodeT{nodeA, nodeB}
// It is assured that d9addBranch here will not cause a node split.
d9addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d9partitionVarsT structure.
func d9initParVars(parVars *d9partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d9notTaken
}
}
func d9pickSeeds(parVars *d9partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d9maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d9calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d9combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d9calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d9classify(seed0, 0, parVars)
d9classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d9classify(index, group int, parVars *d9partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d9combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d9calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d9rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d9removeRect provides for eliminating the root.
func d9removeRect(rect *d9rectT, id interface{}, root **d9nodeT) bool {
var reInsertList *d9listNodeT
if !d9removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d9insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d9removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d9removeRectRec(rect *d9rectT, id interface{}, node *d9nodeT, listNode **d9listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d9overlap(*rect, node.branch[index].rect) {
if !d9removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d9minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d9nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d9reInsert(node.branch[index].child, listNode)
d9disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d9disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d9overlap.
func d9overlap(rectA, rectB d9rectT) bool {
for index := 0; index < d9numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d9reInsert(node *d9nodeT, listNode **d9listNodeT) {
newListNode := &d9listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d9search in an index tree or subtree for all data retangles that d9overlap the argument rectangle.
func d9search(node *d9nodeT, rect d9rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d9overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d9search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d9overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d10fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d10fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d10numDims = 10
d10maxNodes = 8
d10minNodes = d10maxNodes / 2
d10useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d10unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d10numDims]
type d10RTree struct {
root *d10nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d10rectT struct {
min [d10numDims]float64 ///< Min dimensions of bounding box
max [d10numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d10branchT struct {
rect d10rectT ///< Bounds
child *d10nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d10nodeT for each branch level
type d10nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d10maxNodes]d10branchT ///< Branch
}
func (node *d10nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d10nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d10listNodeT struct {
next *d10listNodeT ///< Next in list
node *d10nodeT ///< Node
}
const d10notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d10partitionVarsT struct {
partition [d10maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d10rectT
area [2]float64
branchBuf [d10maxNodes + 1]d10branchT
branchCount int
coverSplit d10rectT
coverSplitArea float64
}
func d10New() *d10RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d10RTree{
root: &d10nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d10RTree) Insert(min, max [d10numDims]float64, dataId interface{}) {
var branch d10branchT
branch.data = dataId
for axis := 0; axis < d10numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d10insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d10RTree) Remove(min, max [d10numDims]float64, dataId interface{}) {
var rect d10rectT
for axis := 0; axis < d10numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d10removeRect(&rect, dataId, &tr.root)
}
/// Find all within d10search rectangle
/// \param a_min Min of d10search bounding rect
/// \param a_max Max of d10search bounding rect
/// \param a_searchResult d10search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d10RTree) Search(min, max [d10numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d10rectT
for axis := 0; axis < d10numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d10search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d10RTree) Count() int {
var count int
d10countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d10RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d10nodeT{}
}
func d10countRec(node *d10nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d10countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d10insertRectRec(branch *d10branchT, node *d10nodeT, newNode **d10nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d10nodeT
//var newBranch d10branchT
// find the optimal branch for this record
index := d10pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d10insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d10combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d10nodeCover(node.branch[index].child)
var newBranch d10branchT
newBranch.child = otherNode
newBranch.rect = d10nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d10addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d10addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d10insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d10insertRect(branch *d10branchT, root **d10nodeT, level int) bool {
var newNode *d10nodeT
if d10insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d10nodeT{}
newRoot.level = (*root).level + 1
var newBranch d10branchT
// add old root node as a child of the new root
newBranch.rect = d10nodeCover(*root)
newBranch.child = *root
d10addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d10nodeCover(newNode)
newBranch.child = newNode
d10addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d10nodeCover(node *d10nodeT) d10rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d10combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d10addBranch(branch *d10branchT, node *d10nodeT, newNode **d10nodeT) bool {
if node.count < d10maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d10splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d10disconnectBranch(node *d10nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d10pickBranch(rect *d10rectT, node *d10nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d10rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d10calcRectVolume(curRect)
tempRect = d10combineRect(rect, curRect)
increase = d10calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d10combineRect(rectA, rectB *d10rectT) d10rectT {
var newRect d10rectT
for index := 0; index < d10numDims; index++ {
newRect.min[index] = d10fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d10fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d10splitNode(node *d10nodeT, branch *d10branchT, newNode **d10nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d10partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d10getBranches(node, branch, parVars)
// Find partition
d10choosePartition(parVars, d10minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d10nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d10loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d10rectVolume(rect *d10rectT) float64 {
var volume float64 = 1
for index := 0; index < d10numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d10rectT
func d10rectSphericalVolume(rect *d10rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d10numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d10numDims == 5 {
return (radius * radius * radius * radius * radius * d10unitSphereVolume)
} else if d10numDims == 4 {
return (radius * radius * radius * radius * d10unitSphereVolume)
} else if d10numDims == 3 {
return (radius * radius * radius * d10unitSphereVolume)
} else if d10numDims == 2 {
return (radius * radius * d10unitSphereVolume)
} else {
return (math.Pow(radius, d10numDims) * d10unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d10calcRectVolume(rect *d10rectT) float64 {
if d10useSphericalVolume {
return d10rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d10rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d10getBranches(node *d10nodeT, branch *d10branchT, parVars *d10partitionVarsT) {
// Load the branch buffer
for index := 0; index < d10maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d10maxNodes] = *branch
parVars.branchCount = d10maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d10maxNodes+1; index++ {
parVars.coverSplit = d10combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d10calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d10choosePartition(parVars *d10partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d10initParVars(parVars, parVars.branchCount, minFill)
d10pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d10notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d10combineRect(curRect, &parVars.cover[0])
rect1 := d10combineRect(curRect, &parVars.cover[1])
growth0 := d10calcRectVolume(&rect0) - parVars.area[0]
growth1 := d10calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d10classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d10notTaken == parVars.partition[index] {
d10classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d10loadNodes(nodeA, nodeB *d10nodeT, parVars *d10partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d10nodeT{nodeA, nodeB}
// It is assured that d10addBranch here will not cause a node split.
d10addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d10partitionVarsT structure.
func d10initParVars(parVars *d10partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d10notTaken
}
}
func d10pickSeeds(parVars *d10partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d10maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d10calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d10combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d10calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d10classify(seed0, 0, parVars)
d10classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d10classify(index, group int, parVars *d10partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d10combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d10calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d10rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d10removeRect provides for eliminating the root.
func d10removeRect(rect *d10rectT, id interface{}, root **d10nodeT) bool {
var reInsertList *d10listNodeT
if !d10removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d10insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d10removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d10removeRectRec(rect *d10rectT, id interface{}, node *d10nodeT, listNode **d10listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d10overlap(*rect, node.branch[index].rect) {
if !d10removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d10minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d10nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d10reInsert(node.branch[index].child, listNode)
d10disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d10disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d10overlap.
func d10overlap(rectA, rectB d10rectT) bool {
for index := 0; index < d10numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d10reInsert(node *d10nodeT, listNode **d10listNodeT) {
newListNode := &d10listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d10search in an index tree or subtree for all data retangles that d10overlap the argument rectangle.
func d10search(node *d10nodeT, rect d10rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d10overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d10search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d10overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d11fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d11fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d11numDims = 11
d11maxNodes = 8
d11minNodes = d11maxNodes / 2
d11useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d11unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d11numDims]
type d11RTree struct {
root *d11nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d11rectT struct {
min [d11numDims]float64 ///< Min dimensions of bounding box
max [d11numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d11branchT struct {
rect d11rectT ///< Bounds
child *d11nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d11nodeT for each branch level
type d11nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d11maxNodes]d11branchT ///< Branch
}
func (node *d11nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d11nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d11listNodeT struct {
next *d11listNodeT ///< Next in list
node *d11nodeT ///< Node
}
const d11notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d11partitionVarsT struct {
partition [d11maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d11rectT
area [2]float64
branchBuf [d11maxNodes + 1]d11branchT
branchCount int
coverSplit d11rectT
coverSplitArea float64
}
func d11New() *d11RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d11RTree{
root: &d11nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d11RTree) Insert(min, max [d11numDims]float64, dataId interface{}) {
var branch d11branchT
branch.data = dataId
for axis := 0; axis < d11numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d11insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d11RTree) Remove(min, max [d11numDims]float64, dataId interface{}) {
var rect d11rectT
for axis := 0; axis < d11numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d11removeRect(&rect, dataId, &tr.root)
}
/// Find all within d11search rectangle
/// \param a_min Min of d11search bounding rect
/// \param a_max Max of d11search bounding rect
/// \param a_searchResult d11search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d11RTree) Search(min, max [d11numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d11rectT
for axis := 0; axis < d11numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d11search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d11RTree) Count() int {
var count int
d11countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d11RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d11nodeT{}
}
func d11countRec(node *d11nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d11countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d11insertRectRec(branch *d11branchT, node *d11nodeT, newNode **d11nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d11nodeT
//var newBranch d11branchT
// find the optimal branch for this record
index := d11pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d11insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d11combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d11nodeCover(node.branch[index].child)
var newBranch d11branchT
newBranch.child = otherNode
newBranch.rect = d11nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d11addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d11addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d11insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d11insertRect(branch *d11branchT, root **d11nodeT, level int) bool {
var newNode *d11nodeT
if d11insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d11nodeT{}
newRoot.level = (*root).level + 1
var newBranch d11branchT
// add old root node as a child of the new root
newBranch.rect = d11nodeCover(*root)
newBranch.child = *root
d11addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d11nodeCover(newNode)
newBranch.child = newNode
d11addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d11nodeCover(node *d11nodeT) d11rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d11combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d11addBranch(branch *d11branchT, node *d11nodeT, newNode **d11nodeT) bool {
if node.count < d11maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d11splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d11disconnectBranch(node *d11nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d11pickBranch(rect *d11rectT, node *d11nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d11rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d11calcRectVolume(curRect)
tempRect = d11combineRect(rect, curRect)
increase = d11calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d11combineRect(rectA, rectB *d11rectT) d11rectT {
var newRect d11rectT
for index := 0; index < d11numDims; index++ {
newRect.min[index] = d11fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d11fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d11splitNode(node *d11nodeT, branch *d11branchT, newNode **d11nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d11partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d11getBranches(node, branch, parVars)
// Find partition
d11choosePartition(parVars, d11minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d11nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d11loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d11rectVolume(rect *d11rectT) float64 {
var volume float64 = 1
for index := 0; index < d11numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d11rectT
func d11rectSphericalVolume(rect *d11rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d11numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d11numDims == 5 {
return (radius * radius * radius * radius * radius * d11unitSphereVolume)
} else if d11numDims == 4 {
return (radius * radius * radius * radius * d11unitSphereVolume)
} else if d11numDims == 3 {
return (radius * radius * radius * d11unitSphereVolume)
} else if d11numDims == 2 {
return (radius * radius * d11unitSphereVolume)
} else {
return (math.Pow(radius, d11numDims) * d11unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d11calcRectVolume(rect *d11rectT) float64 {
if d11useSphericalVolume {
return d11rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d11rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d11getBranches(node *d11nodeT, branch *d11branchT, parVars *d11partitionVarsT) {
// Load the branch buffer
for index := 0; index < d11maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d11maxNodes] = *branch
parVars.branchCount = d11maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d11maxNodes+1; index++ {
parVars.coverSplit = d11combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d11calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d11choosePartition(parVars *d11partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d11initParVars(parVars, parVars.branchCount, minFill)
d11pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d11notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d11combineRect(curRect, &parVars.cover[0])
rect1 := d11combineRect(curRect, &parVars.cover[1])
growth0 := d11calcRectVolume(&rect0) - parVars.area[0]
growth1 := d11calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d11classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d11notTaken == parVars.partition[index] {
d11classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d11loadNodes(nodeA, nodeB *d11nodeT, parVars *d11partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d11nodeT{nodeA, nodeB}
// It is assured that d11addBranch here will not cause a node split.
d11addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d11partitionVarsT structure.
func d11initParVars(parVars *d11partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d11notTaken
}
}
func d11pickSeeds(parVars *d11partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d11maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d11calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d11combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d11calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d11classify(seed0, 0, parVars)
d11classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d11classify(index, group int, parVars *d11partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d11combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d11calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d11rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d11removeRect provides for eliminating the root.
func d11removeRect(rect *d11rectT, id interface{}, root **d11nodeT) bool {
var reInsertList *d11listNodeT
if !d11removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d11insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d11removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d11removeRectRec(rect *d11rectT, id interface{}, node *d11nodeT, listNode **d11listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d11overlap(*rect, node.branch[index].rect) {
if !d11removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d11minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d11nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d11reInsert(node.branch[index].child, listNode)
d11disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d11disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d11overlap.
func d11overlap(rectA, rectB d11rectT) bool {
for index := 0; index < d11numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d11reInsert(node *d11nodeT, listNode **d11listNodeT) {
newListNode := &d11listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d11search in an index tree or subtree for all data retangles that d11overlap the argument rectangle.
func d11search(node *d11nodeT, rect d11rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d11overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d11search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d11overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d12fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d12fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d12numDims = 12
d12maxNodes = 8
d12minNodes = d12maxNodes / 2
d12useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d12unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d12numDims]
type d12RTree struct {
root *d12nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d12rectT struct {
min [d12numDims]float64 ///< Min dimensions of bounding box
max [d12numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d12branchT struct {
rect d12rectT ///< Bounds
child *d12nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d12nodeT for each branch level
type d12nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d12maxNodes]d12branchT ///< Branch
}
func (node *d12nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d12nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d12listNodeT struct {
next *d12listNodeT ///< Next in list
node *d12nodeT ///< Node
}
const d12notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d12partitionVarsT struct {
partition [d12maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d12rectT
area [2]float64
branchBuf [d12maxNodes + 1]d12branchT
branchCount int
coverSplit d12rectT
coverSplitArea float64
}
func d12New() *d12RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d12RTree{
root: &d12nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d12RTree) Insert(min, max [d12numDims]float64, dataId interface{}) {
var branch d12branchT
branch.data = dataId
for axis := 0; axis < d12numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d12insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d12RTree) Remove(min, max [d12numDims]float64, dataId interface{}) {
var rect d12rectT
for axis := 0; axis < d12numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d12removeRect(&rect, dataId, &tr.root)
}
/// Find all within d12search rectangle
/// \param a_min Min of d12search bounding rect
/// \param a_max Max of d12search bounding rect
/// \param a_searchResult d12search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d12RTree) Search(min, max [d12numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d12rectT
for axis := 0; axis < d12numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d12search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d12RTree) Count() int {
var count int
d12countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d12RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d12nodeT{}
}
func d12countRec(node *d12nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d12countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d12insertRectRec(branch *d12branchT, node *d12nodeT, newNode **d12nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d12nodeT
//var newBranch d12branchT
// find the optimal branch for this record
index := d12pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d12insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d12combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d12nodeCover(node.branch[index].child)
var newBranch d12branchT
newBranch.child = otherNode
newBranch.rect = d12nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d12addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d12addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d12insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d12insertRect(branch *d12branchT, root **d12nodeT, level int) bool {
var newNode *d12nodeT
if d12insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d12nodeT{}
newRoot.level = (*root).level + 1
var newBranch d12branchT
// add old root node as a child of the new root
newBranch.rect = d12nodeCover(*root)
newBranch.child = *root
d12addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d12nodeCover(newNode)
newBranch.child = newNode
d12addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d12nodeCover(node *d12nodeT) d12rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d12combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d12addBranch(branch *d12branchT, node *d12nodeT, newNode **d12nodeT) bool {
if node.count < d12maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d12splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d12disconnectBranch(node *d12nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d12pickBranch(rect *d12rectT, node *d12nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d12rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d12calcRectVolume(curRect)
tempRect = d12combineRect(rect, curRect)
increase = d12calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d12combineRect(rectA, rectB *d12rectT) d12rectT {
var newRect d12rectT
for index := 0; index < d12numDims; index++ {
newRect.min[index] = d12fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d12fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d12splitNode(node *d12nodeT, branch *d12branchT, newNode **d12nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d12partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d12getBranches(node, branch, parVars)
// Find partition
d12choosePartition(parVars, d12minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d12nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d12loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d12rectVolume(rect *d12rectT) float64 {
var volume float64 = 1
for index := 0; index < d12numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d12rectT
func d12rectSphericalVolume(rect *d12rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d12numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d12numDims == 5 {
return (radius * radius * radius * radius * radius * d12unitSphereVolume)
} else if d12numDims == 4 {
return (radius * radius * radius * radius * d12unitSphereVolume)
} else if d12numDims == 3 {
return (radius * radius * radius * d12unitSphereVolume)
} else if d12numDims == 2 {
return (radius * radius * d12unitSphereVolume)
} else {
return (math.Pow(radius, d12numDims) * d12unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d12calcRectVolume(rect *d12rectT) float64 {
if d12useSphericalVolume {
return d12rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d12rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d12getBranches(node *d12nodeT, branch *d12branchT, parVars *d12partitionVarsT) {
// Load the branch buffer
for index := 0; index < d12maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d12maxNodes] = *branch
parVars.branchCount = d12maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d12maxNodes+1; index++ {
parVars.coverSplit = d12combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d12calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d12choosePartition(parVars *d12partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d12initParVars(parVars, parVars.branchCount, minFill)
d12pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d12notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d12combineRect(curRect, &parVars.cover[0])
rect1 := d12combineRect(curRect, &parVars.cover[1])
growth0 := d12calcRectVolume(&rect0) - parVars.area[0]
growth1 := d12calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d12classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d12notTaken == parVars.partition[index] {
d12classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d12loadNodes(nodeA, nodeB *d12nodeT, parVars *d12partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d12nodeT{nodeA, nodeB}
// It is assured that d12addBranch here will not cause a node split.
d12addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d12partitionVarsT structure.
func d12initParVars(parVars *d12partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d12notTaken
}
}
func d12pickSeeds(parVars *d12partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d12maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d12calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d12combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d12calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d12classify(seed0, 0, parVars)
d12classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d12classify(index, group int, parVars *d12partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d12combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d12calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d12rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d12removeRect provides for eliminating the root.
func d12removeRect(rect *d12rectT, id interface{}, root **d12nodeT) bool {
var reInsertList *d12listNodeT
if !d12removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d12insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d12removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d12removeRectRec(rect *d12rectT, id interface{}, node *d12nodeT, listNode **d12listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d12overlap(*rect, node.branch[index].rect) {
if !d12removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d12minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d12nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d12reInsert(node.branch[index].child, listNode)
d12disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d12disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d12overlap.
func d12overlap(rectA, rectB d12rectT) bool {
for index := 0; index < d12numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d12reInsert(node *d12nodeT, listNode **d12listNodeT) {
newListNode := &d12listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d12search in an index tree or subtree for all data retangles that d12overlap the argument rectangle.
func d12search(node *d12nodeT, rect d12rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d12overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d12search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d12overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d13fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d13fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d13numDims = 13
d13maxNodes = 8
d13minNodes = d13maxNodes / 2
d13useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d13unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d13numDims]
type d13RTree struct {
root *d13nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d13rectT struct {
min [d13numDims]float64 ///< Min dimensions of bounding box
max [d13numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d13branchT struct {
rect d13rectT ///< Bounds
child *d13nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d13nodeT for each branch level
type d13nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d13maxNodes]d13branchT ///< Branch
}
func (node *d13nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d13nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d13listNodeT struct {
next *d13listNodeT ///< Next in list
node *d13nodeT ///< Node
}
const d13notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d13partitionVarsT struct {
partition [d13maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d13rectT
area [2]float64
branchBuf [d13maxNodes + 1]d13branchT
branchCount int
coverSplit d13rectT
coverSplitArea float64
}
func d13New() *d13RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d13RTree{
root: &d13nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d13RTree) Insert(min, max [d13numDims]float64, dataId interface{}) {
var branch d13branchT
branch.data = dataId
for axis := 0; axis < d13numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d13insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d13RTree) Remove(min, max [d13numDims]float64, dataId interface{}) {
var rect d13rectT
for axis := 0; axis < d13numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d13removeRect(&rect, dataId, &tr.root)
}
/// Find all within d13search rectangle
/// \param a_min Min of d13search bounding rect
/// \param a_max Max of d13search bounding rect
/// \param a_searchResult d13search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d13RTree) Search(min, max [d13numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d13rectT
for axis := 0; axis < d13numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d13search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d13RTree) Count() int {
var count int
d13countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d13RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d13nodeT{}
}
func d13countRec(node *d13nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d13countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d13insertRectRec(branch *d13branchT, node *d13nodeT, newNode **d13nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d13nodeT
//var newBranch d13branchT
// find the optimal branch for this record
index := d13pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d13insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d13combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d13nodeCover(node.branch[index].child)
var newBranch d13branchT
newBranch.child = otherNode
newBranch.rect = d13nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d13addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d13addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d13insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d13insertRect(branch *d13branchT, root **d13nodeT, level int) bool {
var newNode *d13nodeT
if d13insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d13nodeT{}
newRoot.level = (*root).level + 1
var newBranch d13branchT
// add old root node as a child of the new root
newBranch.rect = d13nodeCover(*root)
newBranch.child = *root
d13addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d13nodeCover(newNode)
newBranch.child = newNode
d13addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d13nodeCover(node *d13nodeT) d13rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d13combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d13addBranch(branch *d13branchT, node *d13nodeT, newNode **d13nodeT) bool {
if node.count < d13maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d13splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d13disconnectBranch(node *d13nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d13pickBranch(rect *d13rectT, node *d13nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d13rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d13calcRectVolume(curRect)
tempRect = d13combineRect(rect, curRect)
increase = d13calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d13combineRect(rectA, rectB *d13rectT) d13rectT {
var newRect d13rectT
for index := 0; index < d13numDims; index++ {
newRect.min[index] = d13fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d13fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d13splitNode(node *d13nodeT, branch *d13branchT, newNode **d13nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d13partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d13getBranches(node, branch, parVars)
// Find partition
d13choosePartition(parVars, d13minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d13nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d13loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d13rectVolume(rect *d13rectT) float64 {
var volume float64 = 1
for index := 0; index < d13numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d13rectT
func d13rectSphericalVolume(rect *d13rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d13numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d13numDims == 5 {
return (radius * radius * radius * radius * radius * d13unitSphereVolume)
} else if d13numDims == 4 {
return (radius * radius * radius * radius * d13unitSphereVolume)
} else if d13numDims == 3 {
return (radius * radius * radius * d13unitSphereVolume)
} else if d13numDims == 2 {
return (radius * radius * d13unitSphereVolume)
} else {
return (math.Pow(radius, d13numDims) * d13unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d13calcRectVolume(rect *d13rectT) float64 {
if d13useSphericalVolume {
return d13rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d13rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d13getBranches(node *d13nodeT, branch *d13branchT, parVars *d13partitionVarsT) {
// Load the branch buffer
for index := 0; index < d13maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d13maxNodes] = *branch
parVars.branchCount = d13maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d13maxNodes+1; index++ {
parVars.coverSplit = d13combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d13calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d13choosePartition(parVars *d13partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d13initParVars(parVars, parVars.branchCount, minFill)
d13pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d13notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d13combineRect(curRect, &parVars.cover[0])
rect1 := d13combineRect(curRect, &parVars.cover[1])
growth0 := d13calcRectVolume(&rect0) - parVars.area[0]
growth1 := d13calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d13classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d13notTaken == parVars.partition[index] {
d13classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d13loadNodes(nodeA, nodeB *d13nodeT, parVars *d13partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d13nodeT{nodeA, nodeB}
// It is assured that d13addBranch here will not cause a node split.
d13addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d13partitionVarsT structure.
func d13initParVars(parVars *d13partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d13notTaken
}
}
func d13pickSeeds(parVars *d13partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d13maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d13calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d13combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d13calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d13classify(seed0, 0, parVars)
d13classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d13classify(index, group int, parVars *d13partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d13combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d13calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d13rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d13removeRect provides for eliminating the root.
func d13removeRect(rect *d13rectT, id interface{}, root **d13nodeT) bool {
var reInsertList *d13listNodeT
if !d13removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d13insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d13removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d13removeRectRec(rect *d13rectT, id interface{}, node *d13nodeT, listNode **d13listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d13overlap(*rect, node.branch[index].rect) {
if !d13removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d13minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d13nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d13reInsert(node.branch[index].child, listNode)
d13disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d13disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d13overlap.
func d13overlap(rectA, rectB d13rectT) bool {
for index := 0; index < d13numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d13reInsert(node *d13nodeT, listNode **d13listNodeT) {
newListNode := &d13listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d13search in an index tree or subtree for all data retangles that d13overlap the argument rectangle.
func d13search(node *d13nodeT, rect d13rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d13overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d13search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d13overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d14fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d14fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d14numDims = 14
d14maxNodes = 8
d14minNodes = d14maxNodes / 2
d14useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d14unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d14numDims]
type d14RTree struct {
root *d14nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d14rectT struct {
min [d14numDims]float64 ///< Min dimensions of bounding box
max [d14numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d14branchT struct {
rect d14rectT ///< Bounds
child *d14nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d14nodeT for each branch level
type d14nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d14maxNodes]d14branchT ///< Branch
}
func (node *d14nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d14nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d14listNodeT struct {
next *d14listNodeT ///< Next in list
node *d14nodeT ///< Node
}
const d14notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d14partitionVarsT struct {
partition [d14maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d14rectT
area [2]float64
branchBuf [d14maxNodes + 1]d14branchT
branchCount int
coverSplit d14rectT
coverSplitArea float64
}
func d14New() *d14RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d14RTree{
root: &d14nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d14RTree) Insert(min, max [d14numDims]float64, dataId interface{}) {
var branch d14branchT
branch.data = dataId
for axis := 0; axis < d14numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d14insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d14RTree) Remove(min, max [d14numDims]float64, dataId interface{}) {
var rect d14rectT
for axis := 0; axis < d14numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d14removeRect(&rect, dataId, &tr.root)
}
/// Find all within d14search rectangle
/// \param a_min Min of d14search bounding rect
/// \param a_max Max of d14search bounding rect
/// \param a_searchResult d14search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d14RTree) Search(min, max [d14numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d14rectT
for axis := 0; axis < d14numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d14search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d14RTree) Count() int {
var count int
d14countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d14RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d14nodeT{}
}
func d14countRec(node *d14nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d14countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d14insertRectRec(branch *d14branchT, node *d14nodeT, newNode **d14nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d14nodeT
//var newBranch d14branchT
// find the optimal branch for this record
index := d14pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d14insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d14combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d14nodeCover(node.branch[index].child)
var newBranch d14branchT
newBranch.child = otherNode
newBranch.rect = d14nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d14addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d14addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d14insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d14insertRect(branch *d14branchT, root **d14nodeT, level int) bool {
var newNode *d14nodeT
if d14insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d14nodeT{}
newRoot.level = (*root).level + 1
var newBranch d14branchT
// add old root node as a child of the new root
newBranch.rect = d14nodeCover(*root)
newBranch.child = *root
d14addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d14nodeCover(newNode)
newBranch.child = newNode
d14addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d14nodeCover(node *d14nodeT) d14rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d14combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d14addBranch(branch *d14branchT, node *d14nodeT, newNode **d14nodeT) bool {
if node.count < d14maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d14splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d14disconnectBranch(node *d14nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d14pickBranch(rect *d14rectT, node *d14nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d14rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d14calcRectVolume(curRect)
tempRect = d14combineRect(rect, curRect)
increase = d14calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d14combineRect(rectA, rectB *d14rectT) d14rectT {
var newRect d14rectT
for index := 0; index < d14numDims; index++ {
newRect.min[index] = d14fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d14fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d14splitNode(node *d14nodeT, branch *d14branchT, newNode **d14nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d14partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d14getBranches(node, branch, parVars)
// Find partition
d14choosePartition(parVars, d14minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d14nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d14loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d14rectVolume(rect *d14rectT) float64 {
var volume float64 = 1
for index := 0; index < d14numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d14rectT
func d14rectSphericalVolume(rect *d14rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d14numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d14numDims == 5 {
return (radius * radius * radius * radius * radius * d14unitSphereVolume)
} else if d14numDims == 4 {
return (radius * radius * radius * radius * d14unitSphereVolume)
} else if d14numDims == 3 {
return (radius * radius * radius * d14unitSphereVolume)
} else if d14numDims == 2 {
return (radius * radius * d14unitSphereVolume)
} else {
return (math.Pow(radius, d14numDims) * d14unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d14calcRectVolume(rect *d14rectT) float64 {
if d14useSphericalVolume {
return d14rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d14rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d14getBranches(node *d14nodeT, branch *d14branchT, parVars *d14partitionVarsT) {
// Load the branch buffer
for index := 0; index < d14maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d14maxNodes] = *branch
parVars.branchCount = d14maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d14maxNodes+1; index++ {
parVars.coverSplit = d14combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d14calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d14choosePartition(parVars *d14partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d14initParVars(parVars, parVars.branchCount, minFill)
d14pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d14notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d14combineRect(curRect, &parVars.cover[0])
rect1 := d14combineRect(curRect, &parVars.cover[1])
growth0 := d14calcRectVolume(&rect0) - parVars.area[0]
growth1 := d14calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d14classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d14notTaken == parVars.partition[index] {
d14classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d14loadNodes(nodeA, nodeB *d14nodeT, parVars *d14partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d14nodeT{nodeA, nodeB}
// It is assured that d14addBranch here will not cause a node split.
d14addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d14partitionVarsT structure.
func d14initParVars(parVars *d14partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d14notTaken
}
}
func d14pickSeeds(parVars *d14partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d14maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d14calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d14combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d14calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d14classify(seed0, 0, parVars)
d14classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d14classify(index, group int, parVars *d14partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d14combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d14calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d14rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d14removeRect provides for eliminating the root.
func d14removeRect(rect *d14rectT, id interface{}, root **d14nodeT) bool {
var reInsertList *d14listNodeT
if !d14removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d14insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d14removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d14removeRectRec(rect *d14rectT, id interface{}, node *d14nodeT, listNode **d14listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d14overlap(*rect, node.branch[index].rect) {
if !d14removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d14minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d14nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d14reInsert(node.branch[index].child, listNode)
d14disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d14disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d14overlap.
func d14overlap(rectA, rectB d14rectT) bool {
for index := 0; index < d14numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d14reInsert(node *d14nodeT, listNode **d14listNodeT) {
newListNode := &d14listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d14search in an index tree or subtree for all data retangles that d14overlap the argument rectangle.
func d14search(node *d14nodeT, rect d14rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d14overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d14search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d14overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d15fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d15fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d15numDims = 15
d15maxNodes = 8
d15minNodes = d15maxNodes / 2
d15useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d15unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d15numDims]
type d15RTree struct {
root *d15nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d15rectT struct {
min [d15numDims]float64 ///< Min dimensions of bounding box
max [d15numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d15branchT struct {
rect d15rectT ///< Bounds
child *d15nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d15nodeT for each branch level
type d15nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d15maxNodes]d15branchT ///< Branch
}
func (node *d15nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d15nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d15listNodeT struct {
next *d15listNodeT ///< Next in list
node *d15nodeT ///< Node
}
const d15notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d15partitionVarsT struct {
partition [d15maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d15rectT
area [2]float64
branchBuf [d15maxNodes + 1]d15branchT
branchCount int
coverSplit d15rectT
coverSplitArea float64
}
func d15New() *d15RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d15RTree{
root: &d15nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d15RTree) Insert(min, max [d15numDims]float64, dataId interface{}) {
var branch d15branchT
branch.data = dataId
for axis := 0; axis < d15numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d15insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d15RTree) Remove(min, max [d15numDims]float64, dataId interface{}) {
var rect d15rectT
for axis := 0; axis < d15numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d15removeRect(&rect, dataId, &tr.root)
}
/// Find all within d15search rectangle
/// \param a_min Min of d15search bounding rect
/// \param a_max Max of d15search bounding rect
/// \param a_searchResult d15search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d15RTree) Search(min, max [d15numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d15rectT
for axis := 0; axis < d15numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d15search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d15RTree) Count() int {
var count int
d15countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d15RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d15nodeT{}
}
func d15countRec(node *d15nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d15countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d15insertRectRec(branch *d15branchT, node *d15nodeT, newNode **d15nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d15nodeT
//var newBranch d15branchT
// find the optimal branch for this record
index := d15pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d15insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d15combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d15nodeCover(node.branch[index].child)
var newBranch d15branchT
newBranch.child = otherNode
newBranch.rect = d15nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d15addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d15addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d15insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d15insertRect(branch *d15branchT, root **d15nodeT, level int) bool {
var newNode *d15nodeT
if d15insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d15nodeT{}
newRoot.level = (*root).level + 1
var newBranch d15branchT
// add old root node as a child of the new root
newBranch.rect = d15nodeCover(*root)
newBranch.child = *root
d15addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d15nodeCover(newNode)
newBranch.child = newNode
d15addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d15nodeCover(node *d15nodeT) d15rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d15combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d15addBranch(branch *d15branchT, node *d15nodeT, newNode **d15nodeT) bool {
if node.count < d15maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d15splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d15disconnectBranch(node *d15nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d15pickBranch(rect *d15rectT, node *d15nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d15rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d15calcRectVolume(curRect)
tempRect = d15combineRect(rect, curRect)
increase = d15calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d15combineRect(rectA, rectB *d15rectT) d15rectT {
var newRect d15rectT
for index := 0; index < d15numDims; index++ {
newRect.min[index] = d15fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d15fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d15splitNode(node *d15nodeT, branch *d15branchT, newNode **d15nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d15partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d15getBranches(node, branch, parVars)
// Find partition
d15choosePartition(parVars, d15minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d15nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d15loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d15rectVolume(rect *d15rectT) float64 {
var volume float64 = 1
for index := 0; index < d15numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d15rectT
func d15rectSphericalVolume(rect *d15rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d15numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d15numDims == 5 {
return (radius * radius * radius * radius * radius * d15unitSphereVolume)
} else if d15numDims == 4 {
return (radius * radius * radius * radius * d15unitSphereVolume)
} else if d15numDims == 3 {
return (radius * radius * radius * d15unitSphereVolume)
} else if d15numDims == 2 {
return (radius * radius * d15unitSphereVolume)
} else {
return (math.Pow(radius, d15numDims) * d15unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d15calcRectVolume(rect *d15rectT) float64 {
if d15useSphericalVolume {
return d15rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d15rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d15getBranches(node *d15nodeT, branch *d15branchT, parVars *d15partitionVarsT) {
// Load the branch buffer
for index := 0; index < d15maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d15maxNodes] = *branch
parVars.branchCount = d15maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d15maxNodes+1; index++ {
parVars.coverSplit = d15combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d15calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d15choosePartition(parVars *d15partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d15initParVars(parVars, parVars.branchCount, minFill)
d15pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d15notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d15combineRect(curRect, &parVars.cover[0])
rect1 := d15combineRect(curRect, &parVars.cover[1])
growth0 := d15calcRectVolume(&rect0) - parVars.area[0]
growth1 := d15calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d15classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d15notTaken == parVars.partition[index] {
d15classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d15loadNodes(nodeA, nodeB *d15nodeT, parVars *d15partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d15nodeT{nodeA, nodeB}
// It is assured that d15addBranch here will not cause a node split.
d15addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d15partitionVarsT structure.
func d15initParVars(parVars *d15partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d15notTaken
}
}
func d15pickSeeds(parVars *d15partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d15maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d15calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d15combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d15calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d15classify(seed0, 0, parVars)
d15classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d15classify(index, group int, parVars *d15partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d15combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d15calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d15rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d15removeRect provides for eliminating the root.
func d15removeRect(rect *d15rectT, id interface{}, root **d15nodeT) bool {
var reInsertList *d15listNodeT
if !d15removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d15insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d15removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d15removeRectRec(rect *d15rectT, id interface{}, node *d15nodeT, listNode **d15listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d15overlap(*rect, node.branch[index].rect) {
if !d15removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d15minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d15nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d15reInsert(node.branch[index].child, listNode)
d15disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d15disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d15overlap.
func d15overlap(rectA, rectB d15rectT) bool {
for index := 0; index < d15numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d15reInsert(node *d15nodeT, listNode **d15listNodeT) {
newListNode := &d15listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d15search in an index tree or subtree for all data retangles that d15overlap the argument rectangle.
func d15search(node *d15nodeT, rect d15rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d15overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d15search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d15overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d16fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d16fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d16numDims = 16
d16maxNodes = 8
d16minNodes = d16maxNodes / 2
d16useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d16unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d16numDims]
type d16RTree struct {
root *d16nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d16rectT struct {
min [d16numDims]float64 ///< Min dimensions of bounding box
max [d16numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d16branchT struct {
rect d16rectT ///< Bounds
child *d16nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d16nodeT for each branch level
type d16nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d16maxNodes]d16branchT ///< Branch
}
func (node *d16nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d16nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d16listNodeT struct {
next *d16listNodeT ///< Next in list
node *d16nodeT ///< Node
}
const d16notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d16partitionVarsT struct {
partition [d16maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d16rectT
area [2]float64
branchBuf [d16maxNodes + 1]d16branchT
branchCount int
coverSplit d16rectT
coverSplitArea float64
}
func d16New() *d16RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d16RTree{
root: &d16nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d16RTree) Insert(min, max [d16numDims]float64, dataId interface{}) {
var branch d16branchT
branch.data = dataId
for axis := 0; axis < d16numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d16insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d16RTree) Remove(min, max [d16numDims]float64, dataId interface{}) {
var rect d16rectT
for axis := 0; axis < d16numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d16removeRect(&rect, dataId, &tr.root)
}
/// Find all within d16search rectangle
/// \param a_min Min of d16search bounding rect
/// \param a_max Max of d16search bounding rect
/// \param a_searchResult d16search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d16RTree) Search(min, max [d16numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d16rectT
for axis := 0; axis < d16numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d16search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d16RTree) Count() int {
var count int
d16countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d16RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d16nodeT{}
}
func d16countRec(node *d16nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d16countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d16insertRectRec(branch *d16branchT, node *d16nodeT, newNode **d16nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d16nodeT
//var newBranch d16branchT
// find the optimal branch for this record
index := d16pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d16insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d16combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d16nodeCover(node.branch[index].child)
var newBranch d16branchT
newBranch.child = otherNode
newBranch.rect = d16nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d16addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d16addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d16insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d16insertRect(branch *d16branchT, root **d16nodeT, level int) bool {
var newNode *d16nodeT
if d16insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d16nodeT{}
newRoot.level = (*root).level + 1
var newBranch d16branchT
// add old root node as a child of the new root
newBranch.rect = d16nodeCover(*root)
newBranch.child = *root
d16addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d16nodeCover(newNode)
newBranch.child = newNode
d16addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d16nodeCover(node *d16nodeT) d16rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d16combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d16addBranch(branch *d16branchT, node *d16nodeT, newNode **d16nodeT) bool {
if node.count < d16maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d16splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d16disconnectBranch(node *d16nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d16pickBranch(rect *d16rectT, node *d16nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d16rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d16calcRectVolume(curRect)
tempRect = d16combineRect(rect, curRect)
increase = d16calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d16combineRect(rectA, rectB *d16rectT) d16rectT {
var newRect d16rectT
for index := 0; index < d16numDims; index++ {
newRect.min[index] = d16fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d16fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d16splitNode(node *d16nodeT, branch *d16branchT, newNode **d16nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d16partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d16getBranches(node, branch, parVars)
// Find partition
d16choosePartition(parVars, d16minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d16nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d16loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d16rectVolume(rect *d16rectT) float64 {
var volume float64 = 1
for index := 0; index < d16numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d16rectT
func d16rectSphericalVolume(rect *d16rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d16numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d16numDims == 5 {
return (radius * radius * radius * radius * radius * d16unitSphereVolume)
} else if d16numDims == 4 {
return (radius * radius * radius * radius * d16unitSphereVolume)
} else if d16numDims == 3 {
return (radius * radius * radius * d16unitSphereVolume)
} else if d16numDims == 2 {
return (radius * radius * d16unitSphereVolume)
} else {
return (math.Pow(radius, d16numDims) * d16unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d16calcRectVolume(rect *d16rectT) float64 {
if d16useSphericalVolume {
return d16rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d16rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d16getBranches(node *d16nodeT, branch *d16branchT, parVars *d16partitionVarsT) {
// Load the branch buffer
for index := 0; index < d16maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d16maxNodes] = *branch
parVars.branchCount = d16maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d16maxNodes+1; index++ {
parVars.coverSplit = d16combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d16calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d16choosePartition(parVars *d16partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d16initParVars(parVars, parVars.branchCount, minFill)
d16pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d16notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d16combineRect(curRect, &parVars.cover[0])
rect1 := d16combineRect(curRect, &parVars.cover[1])
growth0 := d16calcRectVolume(&rect0) - parVars.area[0]
growth1 := d16calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d16classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d16notTaken == parVars.partition[index] {
d16classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d16loadNodes(nodeA, nodeB *d16nodeT, parVars *d16partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d16nodeT{nodeA, nodeB}
// It is assured that d16addBranch here will not cause a node split.
d16addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d16partitionVarsT structure.
func d16initParVars(parVars *d16partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d16notTaken
}
}
func d16pickSeeds(parVars *d16partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d16maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d16calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d16combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d16calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d16classify(seed0, 0, parVars)
d16classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d16classify(index, group int, parVars *d16partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d16combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d16calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d16rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d16removeRect provides for eliminating the root.
func d16removeRect(rect *d16rectT, id interface{}, root **d16nodeT) bool {
var reInsertList *d16listNodeT
if !d16removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d16insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d16removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d16removeRectRec(rect *d16rectT, id interface{}, node *d16nodeT, listNode **d16listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d16overlap(*rect, node.branch[index].rect) {
if !d16removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d16minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d16nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d16reInsert(node.branch[index].child, listNode)
d16disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d16disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d16overlap.
func d16overlap(rectA, rectB d16rectT) bool {
for index := 0; index < d16numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d16reInsert(node *d16nodeT, listNode **d16listNodeT) {
newListNode := &d16listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d16search in an index tree or subtree for all data retangles that d16overlap the argument rectangle.
func d16search(node *d16nodeT, rect d16rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d16overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d16search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d16overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d17fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d17fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d17numDims = 17
d17maxNodes = 8
d17minNodes = d17maxNodes / 2
d17useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d17unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d17numDims]
type d17RTree struct {
root *d17nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d17rectT struct {
min [d17numDims]float64 ///< Min dimensions of bounding box
max [d17numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d17branchT struct {
rect d17rectT ///< Bounds
child *d17nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d17nodeT for each branch level
type d17nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d17maxNodes]d17branchT ///< Branch
}
func (node *d17nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d17nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d17listNodeT struct {
next *d17listNodeT ///< Next in list
node *d17nodeT ///< Node
}
const d17notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d17partitionVarsT struct {
partition [d17maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d17rectT
area [2]float64
branchBuf [d17maxNodes + 1]d17branchT
branchCount int
coverSplit d17rectT
coverSplitArea float64
}
func d17New() *d17RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d17RTree{
root: &d17nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d17RTree) Insert(min, max [d17numDims]float64, dataId interface{}) {
var branch d17branchT
branch.data = dataId
for axis := 0; axis < d17numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d17insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d17RTree) Remove(min, max [d17numDims]float64, dataId interface{}) {
var rect d17rectT
for axis := 0; axis < d17numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d17removeRect(&rect, dataId, &tr.root)
}
/// Find all within d17search rectangle
/// \param a_min Min of d17search bounding rect
/// \param a_max Max of d17search bounding rect
/// \param a_searchResult d17search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d17RTree) Search(min, max [d17numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d17rectT
for axis := 0; axis < d17numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d17search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d17RTree) Count() int {
var count int
d17countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d17RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d17nodeT{}
}
func d17countRec(node *d17nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d17countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d17insertRectRec(branch *d17branchT, node *d17nodeT, newNode **d17nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d17nodeT
//var newBranch d17branchT
// find the optimal branch for this record
index := d17pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d17insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d17combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d17nodeCover(node.branch[index].child)
var newBranch d17branchT
newBranch.child = otherNode
newBranch.rect = d17nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d17addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d17addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d17insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d17insertRect(branch *d17branchT, root **d17nodeT, level int) bool {
var newNode *d17nodeT
if d17insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d17nodeT{}
newRoot.level = (*root).level + 1
var newBranch d17branchT
// add old root node as a child of the new root
newBranch.rect = d17nodeCover(*root)
newBranch.child = *root
d17addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d17nodeCover(newNode)
newBranch.child = newNode
d17addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d17nodeCover(node *d17nodeT) d17rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d17combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d17addBranch(branch *d17branchT, node *d17nodeT, newNode **d17nodeT) bool {
if node.count < d17maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d17splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d17disconnectBranch(node *d17nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d17pickBranch(rect *d17rectT, node *d17nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d17rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d17calcRectVolume(curRect)
tempRect = d17combineRect(rect, curRect)
increase = d17calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d17combineRect(rectA, rectB *d17rectT) d17rectT {
var newRect d17rectT
for index := 0; index < d17numDims; index++ {
newRect.min[index] = d17fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d17fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d17splitNode(node *d17nodeT, branch *d17branchT, newNode **d17nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d17partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d17getBranches(node, branch, parVars)
// Find partition
d17choosePartition(parVars, d17minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d17nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d17loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d17rectVolume(rect *d17rectT) float64 {
var volume float64 = 1
for index := 0; index < d17numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d17rectT
func d17rectSphericalVolume(rect *d17rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d17numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d17numDims == 5 {
return (radius * radius * radius * radius * radius * d17unitSphereVolume)
} else if d17numDims == 4 {
return (radius * radius * radius * radius * d17unitSphereVolume)
} else if d17numDims == 3 {
return (radius * radius * radius * d17unitSphereVolume)
} else if d17numDims == 2 {
return (radius * radius * d17unitSphereVolume)
} else {
return (math.Pow(radius, d17numDims) * d17unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d17calcRectVolume(rect *d17rectT) float64 {
if d17useSphericalVolume {
return d17rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d17rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d17getBranches(node *d17nodeT, branch *d17branchT, parVars *d17partitionVarsT) {
// Load the branch buffer
for index := 0; index < d17maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d17maxNodes] = *branch
parVars.branchCount = d17maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d17maxNodes+1; index++ {
parVars.coverSplit = d17combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d17calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d17choosePartition(parVars *d17partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d17initParVars(parVars, parVars.branchCount, minFill)
d17pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d17notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d17combineRect(curRect, &parVars.cover[0])
rect1 := d17combineRect(curRect, &parVars.cover[1])
growth0 := d17calcRectVolume(&rect0) - parVars.area[0]
growth1 := d17calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d17classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d17notTaken == parVars.partition[index] {
d17classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d17loadNodes(nodeA, nodeB *d17nodeT, parVars *d17partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d17nodeT{nodeA, nodeB}
// It is assured that d17addBranch here will not cause a node split.
d17addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d17partitionVarsT structure.
func d17initParVars(parVars *d17partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d17notTaken
}
}
func d17pickSeeds(parVars *d17partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d17maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d17calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d17combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d17calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d17classify(seed0, 0, parVars)
d17classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d17classify(index, group int, parVars *d17partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d17combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d17calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d17rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d17removeRect provides for eliminating the root.
func d17removeRect(rect *d17rectT, id interface{}, root **d17nodeT) bool {
var reInsertList *d17listNodeT
if !d17removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d17insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d17removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d17removeRectRec(rect *d17rectT, id interface{}, node *d17nodeT, listNode **d17listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d17overlap(*rect, node.branch[index].rect) {
if !d17removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d17minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d17nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d17reInsert(node.branch[index].child, listNode)
d17disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d17disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d17overlap.
func d17overlap(rectA, rectB d17rectT) bool {
for index := 0; index < d17numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d17reInsert(node *d17nodeT, listNode **d17listNodeT) {
newListNode := &d17listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d17search in an index tree or subtree for all data retangles that d17overlap the argument rectangle.
func d17search(node *d17nodeT, rect d17rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d17overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d17search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d17overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d18fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d18fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d18numDims = 18
d18maxNodes = 8
d18minNodes = d18maxNodes / 2
d18useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d18unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d18numDims]
type d18RTree struct {
root *d18nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d18rectT struct {
min [d18numDims]float64 ///< Min dimensions of bounding box
max [d18numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d18branchT struct {
rect d18rectT ///< Bounds
child *d18nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d18nodeT for each branch level
type d18nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d18maxNodes]d18branchT ///< Branch
}
func (node *d18nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d18nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d18listNodeT struct {
next *d18listNodeT ///< Next in list
node *d18nodeT ///< Node
}
const d18notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d18partitionVarsT struct {
partition [d18maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d18rectT
area [2]float64
branchBuf [d18maxNodes + 1]d18branchT
branchCount int
coverSplit d18rectT
coverSplitArea float64
}
func d18New() *d18RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d18RTree{
root: &d18nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d18RTree) Insert(min, max [d18numDims]float64, dataId interface{}) {
var branch d18branchT
branch.data = dataId
for axis := 0; axis < d18numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d18insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d18RTree) Remove(min, max [d18numDims]float64, dataId interface{}) {
var rect d18rectT
for axis := 0; axis < d18numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d18removeRect(&rect, dataId, &tr.root)
}
/// Find all within d18search rectangle
/// \param a_min Min of d18search bounding rect
/// \param a_max Max of d18search bounding rect
/// \param a_searchResult d18search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d18RTree) Search(min, max [d18numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d18rectT
for axis := 0; axis < d18numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d18search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d18RTree) Count() int {
var count int
d18countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d18RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d18nodeT{}
}
func d18countRec(node *d18nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d18countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d18insertRectRec(branch *d18branchT, node *d18nodeT, newNode **d18nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d18nodeT
//var newBranch d18branchT
// find the optimal branch for this record
index := d18pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d18insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d18combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d18nodeCover(node.branch[index].child)
var newBranch d18branchT
newBranch.child = otherNode
newBranch.rect = d18nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d18addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d18addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d18insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d18insertRect(branch *d18branchT, root **d18nodeT, level int) bool {
var newNode *d18nodeT
if d18insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d18nodeT{}
newRoot.level = (*root).level + 1
var newBranch d18branchT
// add old root node as a child of the new root
newBranch.rect = d18nodeCover(*root)
newBranch.child = *root
d18addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d18nodeCover(newNode)
newBranch.child = newNode
d18addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d18nodeCover(node *d18nodeT) d18rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d18combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d18addBranch(branch *d18branchT, node *d18nodeT, newNode **d18nodeT) bool {
if node.count < d18maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d18splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d18disconnectBranch(node *d18nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d18pickBranch(rect *d18rectT, node *d18nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d18rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d18calcRectVolume(curRect)
tempRect = d18combineRect(rect, curRect)
increase = d18calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d18combineRect(rectA, rectB *d18rectT) d18rectT {
var newRect d18rectT
for index := 0; index < d18numDims; index++ {
newRect.min[index] = d18fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d18fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d18splitNode(node *d18nodeT, branch *d18branchT, newNode **d18nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d18partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d18getBranches(node, branch, parVars)
// Find partition
d18choosePartition(parVars, d18minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d18nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d18loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d18rectVolume(rect *d18rectT) float64 {
var volume float64 = 1
for index := 0; index < d18numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d18rectT
func d18rectSphericalVolume(rect *d18rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d18numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d18numDims == 5 {
return (radius * radius * radius * radius * radius * d18unitSphereVolume)
} else if d18numDims == 4 {
return (radius * radius * radius * radius * d18unitSphereVolume)
} else if d18numDims == 3 {
return (radius * radius * radius * d18unitSphereVolume)
} else if d18numDims == 2 {
return (radius * radius * d18unitSphereVolume)
} else {
return (math.Pow(radius, d18numDims) * d18unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d18calcRectVolume(rect *d18rectT) float64 {
if d18useSphericalVolume {
return d18rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d18rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d18getBranches(node *d18nodeT, branch *d18branchT, parVars *d18partitionVarsT) {
// Load the branch buffer
for index := 0; index < d18maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d18maxNodes] = *branch
parVars.branchCount = d18maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d18maxNodes+1; index++ {
parVars.coverSplit = d18combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d18calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d18choosePartition(parVars *d18partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d18initParVars(parVars, parVars.branchCount, minFill)
d18pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d18notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d18combineRect(curRect, &parVars.cover[0])
rect1 := d18combineRect(curRect, &parVars.cover[1])
growth0 := d18calcRectVolume(&rect0) - parVars.area[0]
growth1 := d18calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d18classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d18notTaken == parVars.partition[index] {
d18classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d18loadNodes(nodeA, nodeB *d18nodeT, parVars *d18partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d18nodeT{nodeA, nodeB}
// It is assured that d18addBranch here will not cause a node split.
d18addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d18partitionVarsT structure.
func d18initParVars(parVars *d18partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d18notTaken
}
}
func d18pickSeeds(parVars *d18partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d18maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d18calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d18combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d18calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d18classify(seed0, 0, parVars)
d18classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d18classify(index, group int, parVars *d18partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d18combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d18calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d18rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d18removeRect provides for eliminating the root.
func d18removeRect(rect *d18rectT, id interface{}, root **d18nodeT) bool {
var reInsertList *d18listNodeT
if !d18removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d18insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d18removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d18removeRectRec(rect *d18rectT, id interface{}, node *d18nodeT, listNode **d18listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d18overlap(*rect, node.branch[index].rect) {
if !d18removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d18minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d18nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d18reInsert(node.branch[index].child, listNode)
d18disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d18disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d18overlap.
func d18overlap(rectA, rectB d18rectT) bool {
for index := 0; index < d18numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d18reInsert(node *d18nodeT, listNode **d18listNodeT) {
newListNode := &d18listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d18search in an index tree or subtree for all data retangles that d18overlap the argument rectangle.
func d18search(node *d18nodeT, rect d18rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d18overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d18search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d18overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d19fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d19fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d19numDims = 19
d19maxNodes = 8
d19minNodes = d19maxNodes / 2
d19useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d19unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d19numDims]
type d19RTree struct {
root *d19nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d19rectT struct {
min [d19numDims]float64 ///< Min dimensions of bounding box
max [d19numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d19branchT struct {
rect d19rectT ///< Bounds
child *d19nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d19nodeT for each branch level
type d19nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d19maxNodes]d19branchT ///< Branch
}
func (node *d19nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d19nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d19listNodeT struct {
next *d19listNodeT ///< Next in list
node *d19nodeT ///< Node
}
const d19notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d19partitionVarsT struct {
partition [d19maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d19rectT
area [2]float64
branchBuf [d19maxNodes + 1]d19branchT
branchCount int
coverSplit d19rectT
coverSplitArea float64
}
func d19New() *d19RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d19RTree{
root: &d19nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d19RTree) Insert(min, max [d19numDims]float64, dataId interface{}) {
var branch d19branchT
branch.data = dataId
for axis := 0; axis < d19numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d19insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d19RTree) Remove(min, max [d19numDims]float64, dataId interface{}) {
var rect d19rectT
for axis := 0; axis < d19numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d19removeRect(&rect, dataId, &tr.root)
}
/// Find all within d19search rectangle
/// \param a_min Min of d19search bounding rect
/// \param a_max Max of d19search bounding rect
/// \param a_searchResult d19search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d19RTree) Search(min, max [d19numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d19rectT
for axis := 0; axis < d19numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d19search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d19RTree) Count() int {
var count int
d19countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d19RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d19nodeT{}
}
func d19countRec(node *d19nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d19countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d19insertRectRec(branch *d19branchT, node *d19nodeT, newNode **d19nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d19nodeT
//var newBranch d19branchT
// find the optimal branch for this record
index := d19pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d19insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d19combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d19nodeCover(node.branch[index].child)
var newBranch d19branchT
newBranch.child = otherNode
newBranch.rect = d19nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d19addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d19addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d19insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d19insertRect(branch *d19branchT, root **d19nodeT, level int) bool {
var newNode *d19nodeT
if d19insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d19nodeT{}
newRoot.level = (*root).level + 1
var newBranch d19branchT
// add old root node as a child of the new root
newBranch.rect = d19nodeCover(*root)
newBranch.child = *root
d19addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d19nodeCover(newNode)
newBranch.child = newNode
d19addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d19nodeCover(node *d19nodeT) d19rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d19combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d19addBranch(branch *d19branchT, node *d19nodeT, newNode **d19nodeT) bool {
if node.count < d19maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d19splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d19disconnectBranch(node *d19nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d19pickBranch(rect *d19rectT, node *d19nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d19rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d19calcRectVolume(curRect)
tempRect = d19combineRect(rect, curRect)
increase = d19calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d19combineRect(rectA, rectB *d19rectT) d19rectT {
var newRect d19rectT
for index := 0; index < d19numDims; index++ {
newRect.min[index] = d19fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d19fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d19splitNode(node *d19nodeT, branch *d19branchT, newNode **d19nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d19partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d19getBranches(node, branch, parVars)
// Find partition
d19choosePartition(parVars, d19minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d19nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d19loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d19rectVolume(rect *d19rectT) float64 {
var volume float64 = 1
for index := 0; index < d19numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d19rectT
func d19rectSphericalVolume(rect *d19rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d19numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d19numDims == 5 {
return (radius * radius * radius * radius * radius * d19unitSphereVolume)
} else if d19numDims == 4 {
return (radius * radius * radius * radius * d19unitSphereVolume)
} else if d19numDims == 3 {
return (radius * radius * radius * d19unitSphereVolume)
} else if d19numDims == 2 {
return (radius * radius * d19unitSphereVolume)
} else {
return (math.Pow(radius, d19numDims) * d19unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d19calcRectVolume(rect *d19rectT) float64 {
if d19useSphericalVolume {
return d19rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d19rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d19getBranches(node *d19nodeT, branch *d19branchT, parVars *d19partitionVarsT) {
// Load the branch buffer
for index := 0; index < d19maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d19maxNodes] = *branch
parVars.branchCount = d19maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d19maxNodes+1; index++ {
parVars.coverSplit = d19combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d19calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d19choosePartition(parVars *d19partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d19initParVars(parVars, parVars.branchCount, minFill)
d19pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d19notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d19combineRect(curRect, &parVars.cover[0])
rect1 := d19combineRect(curRect, &parVars.cover[1])
growth0 := d19calcRectVolume(&rect0) - parVars.area[0]
growth1 := d19calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d19classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d19notTaken == parVars.partition[index] {
d19classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d19loadNodes(nodeA, nodeB *d19nodeT, parVars *d19partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d19nodeT{nodeA, nodeB}
// It is assured that d19addBranch here will not cause a node split.
d19addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d19partitionVarsT structure.
func d19initParVars(parVars *d19partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d19notTaken
}
}
func d19pickSeeds(parVars *d19partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d19maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d19calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d19combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d19calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d19classify(seed0, 0, parVars)
d19classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d19classify(index, group int, parVars *d19partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d19combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d19calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d19rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d19removeRect provides for eliminating the root.
func d19removeRect(rect *d19rectT, id interface{}, root **d19nodeT) bool {
var reInsertList *d19listNodeT
if !d19removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d19insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d19removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d19removeRectRec(rect *d19rectT, id interface{}, node *d19nodeT, listNode **d19listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d19overlap(*rect, node.branch[index].rect) {
if !d19removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d19minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d19nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d19reInsert(node.branch[index].child, listNode)
d19disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d19disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d19overlap.
func d19overlap(rectA, rectB d19rectT) bool {
for index := 0; index < d19numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d19reInsert(node *d19nodeT, listNode **d19listNodeT) {
newListNode := &d19listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d19search in an index tree or subtree for all data retangles that d19overlap the argument rectangle.
func d19search(node *d19nodeT, rect d19rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d19overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d19search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d19overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}
func d20fmin(a, b float64) float64 {
if a < b {
return a
}
return b
}
func d20fmax(a, b float64) float64 {
if a > b {
return a
}
return b
}
const (
d20numDims = 20
d20maxNodes = 8
d20minNodes = d20maxNodes / 2
d20useSphericalVolume = true // Better split classification, may be slower on some systems
)
var d20unitSphereVolume = []float64{
0.000000, 2.000000, 3.141593, // Dimension 0,1,2
4.188790, 4.934802, 5.263789, // Dimension 3,4,5
5.167713, 4.724766, 4.058712, // Dimension 6,7,8
3.298509, 2.550164, 1.884104, // Dimension 9,10,11
1.335263, 0.910629, 0.599265, // Dimension 12,13,14
0.381443, 0.235331, 0.140981, // Dimension 15,16,17
0.082146, 0.046622, 0.025807, // Dimension 18,19,20
}[d20numDims]
type d20RTree struct {
root *d20nodeT ///< Root of tree
}
/// Minimal bounding rectangle (n-dimensional)
type d20rectT struct {
min [d20numDims]float64 ///< Min dimensions of bounding box
max [d20numDims]float64 ///< Max dimensions of bounding box
}
/// May be data or may be another subtree
/// The parents level determines this.
/// If the parents level is 0, then this is data
type d20branchT struct {
rect d20rectT ///< Bounds
child *d20nodeT ///< Child node
data interface{} ///< Data Id or Ptr
}
/// d20nodeT for each branch level
type d20nodeT struct {
count int ///< Count
level int ///< Leaf is zero, others positive
branch [d20maxNodes]d20branchT ///< Branch
}
func (node *d20nodeT) isInternalNode() bool {
return (node.level > 0) // Not a leaf, but a internal node
}
func (node *d20nodeT) isLeaf() bool {
return (node.level == 0) // A leaf, contains data
}
/// A link list of nodes for reinsertion after a delete operation
type d20listNodeT struct {
next *d20listNodeT ///< Next in list
node *d20nodeT ///< Node
}
const d20notTaken = -1 // indicates that position
/// Variables for finding a split partition
type d20partitionVarsT struct {
partition [d20maxNodes + 1]int
total int
minFill int
count [2]int
cover [2]d20rectT
area [2]float64
branchBuf [d20maxNodes + 1]d20branchT
branchCount int
coverSplit d20rectT
coverSplitArea float64
}
func d20New() *d20RTree {
// We only support machine word size simple data type eg. integer index or object pointer.
// Since we are storing as union with non data branch
return &d20RTree{
root: &d20nodeT{},
}
}
/// Insert entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d20RTree) Insert(min, max [d20numDims]float64, dataId interface{}) {
var branch d20branchT
branch.data = dataId
for axis := 0; axis < d20numDims; axis++ {
branch.rect.min[axis] = min[axis]
branch.rect.max[axis] = max[axis]
}
d20insertRect(&branch, &tr.root, 0)
}
/// Remove entry
/// \param a_min Min of bounding rect
/// \param a_max Max of bounding rect
/// \param a_dataId Positive Id of data. Maybe zero, but negative numbers not allowed.
func (tr *d20RTree) Remove(min, max [d20numDims]float64, dataId interface{}) {
var rect d20rectT
for axis := 0; axis < d20numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
d20removeRect(&rect, dataId, &tr.root)
}
/// Find all within d20search rectangle
/// \param a_min Min of d20search bounding rect
/// \param a_max Max of d20search bounding rect
/// \param a_searchResult d20search result array. Caller should set grow size. Function will reset, not append to array.
/// \param a_resultCallback Callback function to return result. Callback should return 'true' to continue searching
/// \param a_context User context to pass as parameter to a_resultCallback
/// \return Returns the number of entries found
func (tr *d20RTree) Search(min, max [d20numDims]float64, resultCallback func(data interface{}) bool) int {
var rect d20rectT
for axis := 0; axis < d20numDims; axis++ {
rect.min[axis] = min[axis]
rect.max[axis] = max[axis]
}
foundCount, _ := d20search(tr.root, rect, 0, resultCallback)
return foundCount
}
/// Count the data elements in this container. This is slow as no internal counter is maintained.
func (tr *d20RTree) Count() int {
var count int
d20countRec(tr.root, &count)
return count
}
/// Remove all entries from tree
func (tr *d20RTree) RemoveAll() {
// Delete all existing nodes
tr.root = &d20nodeT{}
}
func d20countRec(node *d20nodeT, count *int) {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
d20countRec(node.branch[index].child, count)
}
} else { // A leaf node
*count += node.count
}
}
// Inserts a new data rectangle into the index structure.
// Recursively descends tree, propagates splits back up.
// Returns 0 if node was not split. Old node updated.
// If node was split, returns 1 and sets the pointer pointed to by
// new_node to point to the new node. Old node updated to become one of two.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
func d20insertRectRec(branch *d20branchT, node *d20nodeT, newNode **d20nodeT, level int) bool {
// recurse until we reach the correct level for the new record. data records
// will always be called with a_level == 0 (leaf)
if node.level > level {
// Still above level for insertion, go down tree recursively
var otherNode *d20nodeT
//var newBranch d20branchT
// find the optimal branch for this record
index := d20pickBranch(&branch.rect, node)
// recursively insert this record into the picked branch
childWasSplit := d20insertRectRec(branch, node.branch[index].child, &otherNode, level)
if !childWasSplit {
// Child was not split. Merge the bounding box of the new record with the
// existing bounding box
node.branch[index].rect = d20combineRect(&branch.rect, &(node.branch[index].rect))
return false
} else {
// Child was split. The old branches are now re-partitioned to two nodes
// so we have to re-calculate the bounding boxes of each node
node.branch[index].rect = d20nodeCover(node.branch[index].child)
var newBranch d20branchT
newBranch.child = otherNode
newBranch.rect = d20nodeCover(otherNode)
// The old node is already a child of a_node. Now add the newly-created
// node to a_node as well. a_node might be split because of that.
return d20addBranch(&newBranch, node, newNode)
}
} else if node.level == level {
// We have reached level for insertion. Add rect, split if necessary
return d20addBranch(branch, node, newNode)
} else {
// Should never occur
return false
}
}
// Insert a data rectangle into an index structure.
// d20insertRect provides for splitting the root;
// returns 1 if root was split, 0 if it was not.
// The level argument specifies the number of steps up from the leaf
// level to insert; e.g. a data rectangle goes in at level = 0.
// InsertRect2 does the recursion.
//
func d20insertRect(branch *d20branchT, root **d20nodeT, level int) bool {
var newNode *d20nodeT
if d20insertRectRec(branch, *root, &newNode, level) { // Root split
// Grow tree taller and new root
newRoot := &d20nodeT{}
newRoot.level = (*root).level + 1
var newBranch d20branchT
// add old root node as a child of the new root
newBranch.rect = d20nodeCover(*root)
newBranch.child = *root
d20addBranch(&newBranch, newRoot, nil)
// add the split node as a child of the new root
newBranch.rect = d20nodeCover(newNode)
newBranch.child = newNode
d20addBranch(&newBranch, newRoot, nil)
// set the new root as the root node
*root = newRoot
return true
}
return false
}
// Find the smallest rectangle that includes all rectangles in branches of a node.
func d20nodeCover(node *d20nodeT) d20rectT {
rect := node.branch[0].rect
for index := 1; index < node.count; index++ {
rect = d20combineRect(&rect, &(node.branch[index].rect))
}
return rect
}
// Add a branch to a node. Split the node if necessary.
// Returns 0 if node not split. Old node updated.
// Returns 1 if node split, sets *new_node to address of new node.
// Old node updated, becomes one of two.
func d20addBranch(branch *d20branchT, node *d20nodeT, newNode **d20nodeT) bool {
if node.count < d20maxNodes { // Split won't be necessary
node.branch[node.count] = *branch
node.count++
return false
} else {
d20splitNode(node, branch, newNode)
return true
}
}
// Disconnect a dependent node.
// Caller must return (or stop using iteration index) after this as count has changed
func d20disconnectBranch(node *d20nodeT, index int) {
// Remove element by swapping with the last element to prevent gaps in array
node.branch[index] = node.branch[node.count-1]
node.branch[node.count-1].data = nil
node.branch[node.count-1].child = nil
node.count--
}
// Pick a branch. Pick the one that will need the smallest increase
// in area to accomodate the new rectangle. This will result in the
// least total area for the covering rectangles in the current node.
// In case of a tie, pick the one which was smaller before, to get
// the best resolution when searching.
func d20pickBranch(rect *d20rectT, node *d20nodeT) int {
var firstTime bool = true
var increase float64
var bestIncr float64 = -1
var area float64
var bestArea float64
var best int
var tempRect d20rectT
for index := 0; index < node.count; index++ {
curRect := &node.branch[index].rect
area = d20calcRectVolume(curRect)
tempRect = d20combineRect(rect, curRect)
increase = d20calcRectVolume(&tempRect) - area
if (increase < bestIncr) || firstTime {
best = index
bestArea = area
bestIncr = increase
firstTime = false
} else if (increase == bestIncr) && (area < bestArea) {
best = index
bestArea = area
bestIncr = increase
}
}
return best
}
// Combine two rectangles into larger one containing both
func d20combineRect(rectA, rectB *d20rectT) d20rectT {
var newRect d20rectT
for index := 0; index < d20numDims; index++ {
newRect.min[index] = d20fmin(rectA.min[index], rectB.min[index])
newRect.max[index] = d20fmax(rectA.max[index], rectB.max[index])
}
return newRect
}
// Split a node.
// Divides the nodes branches and the extra one between two nodes.
// Old node is one of the new ones, and one really new one is created.
// Tries more than one method for choosing a partition, uses best result.
func d20splitNode(node *d20nodeT, branch *d20branchT, newNode **d20nodeT) {
// Could just use local here, but member or external is faster since it is reused
var localVars d20partitionVarsT
parVars := &localVars
// Load all the branches into a buffer, initialize old node
d20getBranches(node, branch, parVars)
// Find partition
d20choosePartition(parVars, d20minNodes)
// Create a new node to hold (about) half of the branches
*newNode = &d20nodeT{}
(*newNode).level = node.level
// Put branches from buffer into 2 nodes according to the chosen partition
node.count = 0
d20loadNodes(node, *newNode, parVars)
}
// Calculate the n-dimensional volume of a rectangle
func d20rectVolume(rect *d20rectT) float64 {
var volume float64 = 1
for index := 0; index < d20numDims; index++ {
volume *= rect.max[index] - rect.min[index]
}
return volume
}
// The exact volume of the bounding sphere for the given d20rectT
func d20rectSphericalVolume(rect *d20rectT) float64 {
var sumOfSquares float64 = 0
var radius float64
for index := 0; index < d20numDims; index++ {
halfExtent := (rect.max[index] - rect.min[index]) * 0.5
sumOfSquares += halfExtent * halfExtent
}
radius = math.Sqrt(sumOfSquares)
// Pow maybe slow, so test for common dims just use x*x, x*x*x.
if d20numDims == 5 {
return (radius * radius * radius * radius * radius * d20unitSphereVolume)
} else if d20numDims == 4 {
return (radius * radius * radius * radius * d20unitSphereVolume)
} else if d20numDims == 3 {
return (radius * radius * radius * d20unitSphereVolume)
} else if d20numDims == 2 {
return (radius * radius * d20unitSphereVolume)
} else {
return (math.Pow(radius, d20numDims) * d20unitSphereVolume)
}
}
// Use one of the methods to calculate retangle volume
func d20calcRectVolume(rect *d20rectT) float64 {
if d20useSphericalVolume {
return d20rectSphericalVolume(rect) // Slower but helps certain merge cases
} else { // RTREE_USE_SPHERICAL_VOLUME
return d20rectVolume(rect) // Faster but can cause poor merges
} // RTREE_USE_SPHERICAL_VOLUME
}
// Load branch buffer with branches from full node plus the extra branch.
func d20getBranches(node *d20nodeT, branch *d20branchT, parVars *d20partitionVarsT) {
// Load the branch buffer
for index := 0; index < d20maxNodes; index++ {
parVars.branchBuf[index] = node.branch[index]
}
parVars.branchBuf[d20maxNodes] = *branch
parVars.branchCount = d20maxNodes + 1
// Calculate rect containing all in the set
parVars.coverSplit = parVars.branchBuf[0].rect
for index := 1; index < d20maxNodes+1; index++ {
parVars.coverSplit = d20combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
}
parVars.coverSplitArea = d20calcRectVolume(&parVars.coverSplit)
}
// Method #0 for choosing a partition:
// As the seeds for the two groups, pick the two rects that would waste the
// most area if covered by a single rectangle, i.e. evidently the worst pair
// to have in the same group.
// Of the remaining, one at a time is chosen to be put in one of the two groups.
// The one chosen is the one with the greatest difference in area expansion
// depending on which group - the rect most strongly attracted to one group
// and repelled from the other.
// If one group gets too full (more would force other group to violate min
// fill requirement) then other group gets the rest.
// These last are the ones that can go in either group most easily.
func d20choosePartition(parVars *d20partitionVarsT, minFill int) {
var biggestDiff float64
var group, chosen, betterGroup int
d20initParVars(parVars, parVars.branchCount, minFill)
d20pickSeeds(parVars)
for ((parVars.count[0] + parVars.count[1]) < parVars.total) &&
(parVars.count[0] < (parVars.total - parVars.minFill)) &&
(parVars.count[1] < (parVars.total - parVars.minFill)) {
biggestDiff = -1
for index := 0; index < parVars.total; index++ {
if d20notTaken == parVars.partition[index] {
curRect := &parVars.branchBuf[index].rect
rect0 := d20combineRect(curRect, &parVars.cover[0])
rect1 := d20combineRect(curRect, &parVars.cover[1])
growth0 := d20calcRectVolume(&rect0) - parVars.area[0]
growth1 := d20calcRectVolume(&rect1) - parVars.area[1]
diff := growth1 - growth0
if diff >= 0 {
group = 0
} else {
group = 1
diff = -diff
}
if diff > biggestDiff {
biggestDiff = diff
chosen = index
betterGroup = group
} else if (diff == biggestDiff) && (parVars.count[group] < parVars.count[betterGroup]) {
chosen = index
betterGroup = group
}
}
}
d20classify(chosen, betterGroup, parVars)
}
// If one group too full, put remaining rects in the other
if (parVars.count[0] + parVars.count[1]) < parVars.total {
if parVars.count[0] >= parVars.total-parVars.minFill {
group = 1
} else {
group = 0
}
for index := 0; index < parVars.total; index++ {
if d20notTaken == parVars.partition[index] {
d20classify(index, group, parVars)
}
}
}
}
// Copy branches from the buffer into two nodes according to the partition.
func d20loadNodes(nodeA, nodeB *d20nodeT, parVars *d20partitionVarsT) {
for index := 0; index < parVars.total; index++ {
targetNodeIndex := parVars.partition[index]
targetNodes := []*d20nodeT{nodeA, nodeB}
// It is assured that d20addBranch here will not cause a node split.
d20addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
}
}
// Initialize a d20partitionVarsT structure.
func d20initParVars(parVars *d20partitionVarsT, maxRects, minFill int) {
parVars.count[0] = 0
parVars.count[1] = 0
parVars.area[0] = 0
parVars.area[1] = 0
parVars.total = maxRects
parVars.minFill = minFill
for index := 0; index < maxRects; index++ {
parVars.partition[index] = d20notTaken
}
}
func d20pickSeeds(parVars *d20partitionVarsT) {
var seed0, seed1 int
var worst, waste float64
var area [d20maxNodes + 1]float64
for index := 0; index < parVars.total; index++ {
area[index] = d20calcRectVolume(&parVars.branchBuf[index].rect)
}
worst = -parVars.coverSplitArea - 1
for indexA := 0; indexA < parVars.total-1; indexA++ {
for indexB := indexA + 1; indexB < parVars.total; indexB++ {
oneRect := d20combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
waste = d20calcRectVolume(&oneRect) - area[indexA] - area[indexB]
if waste > worst {
worst = waste
seed0 = indexA
seed1 = indexB
}
}
}
d20classify(seed0, 0, parVars)
d20classify(seed1, 1, parVars)
}
// Put a branch in one of the groups.
func d20classify(index, group int, parVars *d20partitionVarsT) {
parVars.partition[index] = group
// Calculate combined rect
if parVars.count[group] == 0 {
parVars.cover[group] = parVars.branchBuf[index].rect
} else {
parVars.cover[group] = d20combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
}
// Calculate volume of combined rect
parVars.area[group] = d20calcRectVolume(&parVars.cover[group])
parVars.count[group]++
}
// Delete a data rectangle from an index structure.
// Pass in a pointer to a d20rectT, the tid of the record, ptr to ptr to root node.
// Returns 1 if record not found, 0 if success.
// d20removeRect provides for eliminating the root.
func d20removeRect(rect *d20rectT, id interface{}, root **d20nodeT) bool {
var reInsertList *d20listNodeT
if !d20removeRectRec(rect, id, *root, &reInsertList) {
// Found and deleted a data item
// Reinsert any branches from eliminated nodes
for reInsertList != nil {
tempNode := reInsertList.node
for index := 0; index < tempNode.count; index++ {
// TODO go over this code. should I use (tempNode->m_level - 1)?
d20insertRect(&tempNode.branch[index], root, tempNode.level)
}
reInsertList = reInsertList.next
}
// Check for redundant root (not leaf, 1 child) and eliminate TODO replace
// if with while? In case there is a whole branch of redundant roots...
if (*root).count == 1 && (*root).isInternalNode() {
tempNode := (*root).branch[0].child
*root = tempNode
}
return false
} else {
return true
}
}
// Delete a rectangle from non-root part of an index structure.
// Called by d20removeRect. Descends tree recursively,
// merges branches on the way back up.
// Returns 1 if record not found, 0 if success.
func d20removeRectRec(rect *d20rectT, id interface{}, node *d20nodeT, listNode **d20listNodeT) bool {
if node.isInternalNode() { // not a leaf node
for index := 0; index < node.count; index++ {
if d20overlap(*rect, node.branch[index].rect) {
if !d20removeRectRec(rect, id, node.branch[index].child, listNode) {
if node.branch[index].child.count >= d20minNodes {
// child removed, just resize parent rect
node.branch[index].rect = d20nodeCover(node.branch[index].child)
} else {
// child removed, not enough entries in node, eliminate node
d20reInsert(node.branch[index].child, listNode)
d20disconnectBranch(node, index) // Must return after this call as count has changed
}
return false
}
}
}
return true
} else { // A leaf node
for index := 0; index < node.count; index++ {
if node.branch[index].data == id {
d20disconnectBranch(node, index) // Must return after this call as count has changed
return false
}
}
return true
}
}
// Decide whether two rectangles d20overlap.
func d20overlap(rectA, rectB d20rectT) bool {
for index := 0; index < d20numDims; index++ {
if rectA.min[index] > rectB.max[index] ||
rectB.min[index] > rectA.max[index] {
return false
}
}
return true
}
// Add a node to the reinsertion list. All its branches will later
// be reinserted into the index structure.
func d20reInsert(node *d20nodeT, listNode **d20listNodeT) {
newListNode := &d20listNodeT{}
newListNode.node = node
newListNode.next = *listNode
*listNode = newListNode
}
// d20search in an index tree or subtree for all data retangles that d20overlap the argument rectangle.
func d20search(node *d20nodeT, rect d20rectT, foundCount int, resultCallback func(data interface{}) bool) (int, bool) {
if node.isInternalNode() {
// This is an internal node in the tree
for index := 0; index < node.count; index++ {
if d20overlap(rect, node.branch[index].rect) {
var ok bool
foundCount, ok = d20search(node.branch[index].child, rect, foundCount, resultCallback)
if !ok {
// The callback indicated to stop searching
return foundCount, false
}
}
}
} else {
// This is a leaf node
for index := 0; index < node.count; index++ {
if d20overlap(rect, node.branch[index].rect) {
id := node.branch[index].data
foundCount++
if !resultCallback(id) {
return foundCount, false // Don't continue searching
}
}
}
}
return foundCount, true // Continue searching
}