diff --git a/Gopkg.lock b/Gopkg.lock
index 9a29ba9c..e33ae7f7 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -223,12 +223,12 @@
revision = "9876f1454cf0993a53d74c27196993e345f50dd1"
[[projects]]
- branch = "master"
- digest = "1:2fef6390e8d9118debd4937a699afad9e1629f2d5d3c965a58fc33afe04f9b46"
+ digest = "1:4d2ec831fbaaf74fd75d2d9fe107e605c92489ec6cef6d36e1f23b678e9f2bd4"
name = "github.com/tidwall/buntdb"
packages = ["."]
pruneopts = ""
- revision = "b67b1b8c1658cb01502801c14e33c61e6c4cbb95"
+ revision = "6249481c29c2cd96f53b691b74ac1893f72774c2"
+ version = "v1.1.0"
[[projects]]
digest = "1:91acf4d86b348c1f1832336836035373b047ffcb16a0fde066bd531bbe3452b2"
@@ -319,11 +319,14 @@
[[projects]]
branch = "master"
- digest = "1:9384bff0cadcd196d5981923a738898c36d4ce049781152b9a9816791c8221b4"
+ digest = "1:5d9d865e55b95f001e52a7f5d1f812e8a80f0f05d5b04ede006f24206ebba33c"
name = "github.com/tidwall/rtree"
- packages = ["."]
+ packages = [
+ ".",
+ "base",
+ ]
pruneopts = ""
- revision = "d4a8a3d30d5729f85edfba1745241f3a621d0359"
+ revision = "6cd427091e0e662cb4f8e2c9eb1a41e1c46ff0d3"
[[projects]]
digest = "1:ca969d3e75ed5b3003f4f5864bb5c13d99471ef57f9049bf78562d7ee1ac019c"
@@ -341,6 +344,14 @@
pruneopts = ""
revision = "de5932d649b50053050d43056146b960f3d90ca5"
+[[projects]]
+ branch = "master"
+ digest = "1:9d6562efe571b54b2ec08ed598e4ba08d77b966dc2103a4300ae0cd0286dd6c3"
+ name = "github.com/tidwall/tinyqueue"
+ packages = ["."]
+ pruneopts = ""
+ revision = "1e39f55115634cad2c504631c8bfcc292f2c9c55"
+
[[projects]]
branch = "master"
digest = "1:9d71091ff8756d88318a4334be685d311b10e1a01c0290ce743187b3bfb1b3f6"
diff --git a/Gopkg.toml b/Gopkg.toml
index a7f4c2e7..d118b3e6 100644
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -67,8 +67,8 @@ required = [
name = "github.com/tidwall/btree"
[[constraint]]
- branch = "master"
name = "github.com/tidwall/buntdb"
+ version = "1.1.0"
[[constraint]]
name = "github.com/tidwall/gjson"
diff --git a/vendor/github.com/tidwall/buntdb/README.md b/vendor/github.com/tidwall/buntdb/README.md
index 66562322..31798093 100644
--- a/vendor/github.com/tidwall/buntdb/README.md
+++ b/vendor/github.com/tidwall/buntdb/README.md
@@ -1,6 +1,6 @@
-
@@ -9,15 +9,12 @@
-BuntDB is a low-level, in-memory, key/value store in pure Go.
+BuntDB is a low-level, in-memory, key/value store in pure Go.
It persists to disk, is ACID compliant, and uses locking for multiple
-readers and a single writer. It supports custom indexes and geospatial
-data. It's ideal for projects that need a dependable database and favor
+readers and a single writer. It supports custom indexes and geospatial
+data. It's ideal for projects that need a dependable database and favor
speed over data size.
-The desire to create BuntDB stems from the need for a new embeddable
-database for [Tile38](https://github.com/tidwall/tile38) and [SummitDB](https://github.com/tidwall/summitdb).
-
Features
========
@@ -52,7 +49,7 @@ This will retrieve the library.
## Opening a database
-The primary object in BuntDB is a `DB`. To open or create your
+The primary object in BuntDB is a `DB`. To open or create your
database, use the `buntdb.Open()` function:
```go
@@ -71,8 +68,8 @@ func main() {
log.Fatal(err)
}
defer db.Close()
-
- ...
+
+ ...
}
```
@@ -94,18 +91,18 @@ A read-only transaction should be used when you don't need to make changes to th
```go
err := db.View(func(tx *buntdb.Tx) error {
- ...
- return nil
+ ...
+ return nil
})
```
### Read/write Transactions
-A read/write transaction is used when you need to make changes to your data. There can only be one read/write transaction running at a time. So make sure you close it as soon as you are done with it.
+A read/write transaction is used when you need to make changes to your data. There can only be one read/write transaction running at a time. So make sure you close it as soon as you are done with it.
```go
err := db.Update(func(tx *buntdb.Tx) error {
- ...
- return nil
+ ...
+ return nil
})
```
@@ -115,8 +112,8 @@ To set a value you must open a read/write transaction:
```go
err := db.Update(func(tx *buntdb.Tx) error {
- _, _, err := tx.Set("mykey", "myvalue", nil)
- return err
+ _, _, err := tx.Set("mykey", "myvalue", nil)
+ return err
})
```
@@ -125,34 +122,32 @@ To get the value:
```go
err := db.View(func(tx *buntdb.Tx) error {
- val, err := tx.Get("mykey")
- if err != nil{
- return err
- }
- fmt.Printf("value is %s\n", val)
- return nil
+ val, err := tx.Get("mykey")
+ if err != nil{
+ return err
+ }
+ fmt.Printf("value is %s\n", val)
+ return nil
})
```
-Getting non-existent values will case an `ErrNotFound` error.
+Getting non-existent values will cause an `ErrNotFound` error.
### Iterating
All keys/value pairs are ordered in the database by the key. To iterate over the keys:
```go
err := db.View(func(tx *buntdb.Tx) error {
-err := tx.Ascend("", func(key, value string) bool{
- fmt.Printf("key: %s, value: %s\n", key, value)
- })
- return err
+ err := tx.Ascend("", func(key, value string) bool {
+ fmt.Printf("key: %s, value: %s\n", key, value)
+ })
+ return err
})
```
There is also `AscendGreaterOrEqual`, `AscendLessThan`, `AscendRange`, `AscendEqual`, `Descend`, `DescendLessOrEqual`, `DescendGreaterThan`, `DescendRange`, and `DescendEqual`. Please see the [documentation](https://godoc.org/github.com/tidwall/buntdb) for more information on these functions.
-
-
## Custom Indexes
Initially all data is stored in a single [B-tree](https://en.wikipedia.org/wiki/B-tree) with each item having one key and one value. All of these items are ordered by the key. This is great for quickly getting a value from a key or [iterating](#iterating) over the keys. Feel free to peruse the [B-tree implementation](https://github.com/tidwall/btree).
@@ -170,7 +165,7 @@ Now you can add various names:
```go
db.Update(func(tx *buntdb.Tx) error {
- tx.Set("user:0:name", "tom", nil)
+ tx.Set("user:0:name", "tom", nil)
tx.Set("user:1:name", "Randi", nil)
tx.Set("user:2:name", "jane", nil)
tx.Set("user:4:name", "Janet", nil)
@@ -186,10 +181,10 @@ Finally you can iterate over the index:
```go
db.View(func(tx *buntdb.Tx) error {
tx.Ascend("names", func(key, val string) bool {
- fmt.Printf(buf, "%s %s\n", key, val)
+ fmt.Printf(buf, "%s %s\n", key, val)
return true
})
- return nil
+ return nil
})
```
The output should be:
@@ -213,7 +208,7 @@ Now only items with keys that have the prefix `user:` will be added to the `name
### Built-in types
-Along with `IndexString`, there is also `IndexInt`, `IndexUint`, and `IndexFloat`.
+Along with `IndexString`, there is also `IndexInt`, `IndexUint`, and `IndexFloat`.
These are built-in types for indexing. You can choose to use these or create your own.
So to create an index that is numerically ordered on an age key, we could use:
@@ -226,7 +221,7 @@ And then add values:
```go
db.Update(func(tx *buntdb.Tx) error {
- tx.Set("user:0:age", "35", nil)
+ tx.Set("user:0:age", "35", nil)
tx.Set("user:1:age", "49", nil)
tx.Set("user:2:age", "13", nil)
tx.Set("user:4:age", "63", nil)
@@ -240,22 +235,22 @@ db.Update(func(tx *buntdb.Tx) error {
```go
db.View(func(tx *buntdb.Tx) error {
tx.Ascend("ages", func(key, val string) bool {
- fmt.Printf(buf, "%s %s\n", key, val)
+ fmt.Printf(buf, "%s %s\n", key, val)
return true
})
- return nil
+ return nil
})
```
The output should be:
```
-user:6:name 3
-user:5:name 8
-user:2:name 13
-user:7:name 16
-user:0:name 35
-user:1:name 49
-user:4:name 63
+user:6:age 3
+user:5:age 8
+user:2:age 13
+user:7:age 16
+user:0:age 35
+user:1:age 49
+user:4:age 63
```
## Spatial Indexes
@@ -273,7 +268,7 @@ To add some lon,lat points to the `fleet` index:
```go
db.Update(func(tx *buntdb.Tx) error {
- tx.Set("fleet:0:pos", "[-115.567 33.532]", nil)
+ tx.Set("fleet:0:pos", "[-115.567 33.532]", nil)
tx.Set("fleet:1:pos", "[-116.671 35.735]", nil)
tx.Set("fleet:2:pos", "[-113.902 31.234]", nil)
return nil
@@ -284,38 +279,52 @@ And then you can run the `Intersects` function on the index:
```go
db.View(func(tx *buntdb.Tx) error {
- tx.Intersects("fleet", "[-117 30],[-112 36]", func(key, val string) bool {
- ...
- return true
- })
- return nil
+ tx.Intersects("fleet", "[-117 30],[-112 36]", func(key, val string) bool {
+ ...
+ return true
+ })
+ return nil
})
```
This will get all three positions.
+### k-Nearest Neighbors
+
+Use the `Nearby` function to get all the positions in order of nearest to farthest :
+
+```go
+db.View(func(tx *buntdb.Tx) error {
+ tx.Nearby("fleet", "[-113 33]", func(key, val string, dist float64) bool {
+ ...
+ return true
+ })
+ return nil
+})
+```
+
### Spatial bracket syntax
The bracket syntax `[-117 30],[-112 36]` is unique to BuntDB, and it's how the built-in rectangles are processed. But, you are not limited to this syntax. Whatever Rect function you choose to use during `CreateSpatialIndex` will be used to process the parameter, in this case it's `IndexRect`.
-- **2D rectangle:** `[10 15],[20 25]`
+- **2D rectangle:** `[10 15],[20 25]`
*Min XY: "10x15", Max XY: "20x25"*
-- **3D rectangle:** `[10 15 12],[20 25 18]`
+- **3D rectangle:** `[10 15 12],[20 25 18]`
*Min XYZ: "10x15x12", Max XYZ: "20x25x18"*
-- **2D point:** `[10 15]`
+- **2D point:** `[10 15]`
*XY: "10x15"*
-- **LatLon point:** `[-112.2693 33.5123]`
+- **LonLat point:** `[-112.2693 33.5123]`
*LatLon: "33.5123 -112.2693"*
-- **LatLon bounding box:** `[-112.26 33.51],[-112.18 33.67]`
+- **LonLat bounding box:** `[-112.26 33.51],[-112.18 33.67]`
*Min LatLon: "33.51 -112.26", Max LatLon: "33.67 -112.18"*
**Notice:** The longitude is the Y axis and is on the left, and latitude is the X axis and is on the right.
-You can also represent `Infinity` by using `-inf` and `+inf`.
+You can also represent `Infinity` by using `-inf` and `+inf`.
For example, you might have the following points (`[X Y M]` where XY is a point and M is a timestamp):
```
[3 9 1]
@@ -330,8 +339,8 @@ You can then do a search for all points with `M` between 2-4 by calling `Interse
```go
tx.Intersects("points", "[-inf -inf 2],[+inf +inf 4]", func(key, val string) bool {
- println(val)
- return true
+ println(val)
+ return true
})
```
@@ -410,7 +419,7 @@ Order by age range 30-50
```
## Multi Value Index
-With BuntDB it's possible to join multiple values on a single index.
+With BuntDB it's possible to join multiple values on a single index.
This is similar to a [multi column index](http://dev.mysql.com/doc/refman/5.7/en/multiple-column-indexes.html) in a traditional SQL database.
In this example we are creating a multi value index on "name.last" and "age":
@@ -448,9 +457,9 @@ db.View(func(tx *buntdb.Tx) error {
Any index can be put in descending order by wrapping it's less function with `buntdb.Desc`.
```go
-db.CreateIndex("last_name_age", "*",
- buntdb.IndexJSON("name.last"),
- buntdb.Desc(buntdb.IndexJSON("age")))
+db.CreateIndex("last_name_age", "*",
+buntdb.IndexJSON("name.last"),
+buntdb.Desc(buntdb.IndexJSON("age")))
```
This will create a multi value index where the last name is ascending and the age is descending.
@@ -474,9 +483,9 @@ import "github.com/tidwall/collate"
// To sort case-insensitive in French.
db.CreateIndex("name", "*", collate.IndexString("FRENCH_CI"))
-// To specify that numbers should sort numerically ("2" < "12")
+// To specify that numbers should sort numerically ("2" < "12")
// and use a comma to represent a decimal point.
-db.CreateIndex("amount", "*", collate.IndexString("FRENCH_NUM"))
+db.CreateIndex("amount", "*", collate.IndexString("FRENCH_NUM"))
```
There's also support for Collation on JSON indexes:
@@ -492,16 +501,35 @@ Items can be automatically evicted by using the `SetOptions` object in the `Set`
```go
db.Update(func(tx *buntdb.Tx) error {
- tx.Set("mykey", "myval", &buntdb.SetOptions{Expires:true, TTL:time.Second})
+ tx.Set("mykey", "myval", &buntdb.SetOptions{Expires:true, TTL:time.Second})
return nil
})
```
Now `mykey` will automatically be deleted after one second. You can remove the TTL by setting the value again with the same key/value, but with the options parameter set to nil.
+## Delete while iterating
+BuntDB does not currently support deleting a key while in the process of iterating.
+As a workaround you'll need to delete keys following the completion of the iterator.
+
+```go
+var delkeys []string
+tx.AscendKeys("object:*", func(k, v string) bool {
+ if someCondition(k) == true {
+ delkeys = append(delkeys, k)
+ }
+ return true // continue
+})
+for _, k := range delkeys {
+ if _, err = tx.Delete(k); err != nil {
+ return err
+ }
+}
+```
+
## Append-only File
-BuntDB uses an AOF (append-only file) which is a log of all database changes that occur from operations like `Set()` and `Delete()`.
+BuntDB uses an AOF (append-only file) which is a log of all database changes that occur from operations like `Set()` and `Delete()`.
The format of this file looks like:
```
@@ -531,7 +559,7 @@ The `Config.SyncPolicy` has the following options:
- `EverySecond` - fsync every second, fast and safer, this is the default
- `Always` - fsync after every write, very durable, slower
-## Config
+## Config
Here are some configuration options that can be use to change various behaviors of the database.
@@ -546,10 +574,10 @@ To update the configuration you should call `ReadConfig` followed by `SetConfig`
var config buntdb.Config
if err := db.ReadConfig(&config); err != nil{
- log.Fatal(err)
+ log.Fatal(err)
}
if err := db.WriteConfig(config); err != nil{
- log.Fatal(err)
+ log.Fatal(err)
}
```
@@ -557,7 +585,7 @@ if err := db.WriteConfig(config); err != nil{
How fast is BuntDB?
-Here are some example [benchmarks](https://github.com/tidwall/raft-buntdb#raftstore-performance-comparison) when using BuntDB in a Raft Store implementation.
+Here are some example [benchmarks](https://github.com/tidwall/raft-buntdb#raftstore-performance-comparison) when using BuntDB in a Raft Store implementation.
You can also run the standard Go benchmark tool from the project root directory:
diff --git a/vendor/github.com/tidwall/buntdb/buntdb.go b/vendor/github.com/tidwall/buntdb/buntdb.go
index 9fcaf31b..35f85200 100644
--- a/vendor/github.com/tidwall/buntdb/buntdb.go
+++ b/vendor/github.com/tidwall/buntdb/buntdb.go
@@ -121,6 +121,12 @@ type Config struct {
// OnExpired is used to custom handle the deletion option when a key
// has been expired.
OnExpired func(keys []string)
+
+ // OnExpiredSync will be called inside the same transaction that is performing
+ // the deletion of expired items. If OnExpired is present then this callback
+ // will not be called. If this callback is present, then the deletion of the
+ // timeed-out item is the explicit responsibility of this callback.
+ OnExpiredSync func(key, value string, tx *Tx) error
}
// exctx is a simple b-tree context for ordering by expiration.
@@ -544,9 +550,13 @@ func (db *DB) backgroundManager() {
// Open a standard view. This will take a full lock of the
// database thus allowing for access to anything we need.
var onExpired func([]string)
- var expired []string
+ var expired []*dbItem
+ var onExpiredSync func(key, value string, tx *Tx) error
err := db.Update(func(tx *Tx) error {
onExpired = db.config.OnExpired
+ if onExpired == nil {
+ onExpiredSync = db.config.OnExpiredSync
+ }
if db.persist && !db.config.AutoShrinkDisabled {
pos, err := db.file.Seek(0, 1)
if err != nil {
@@ -562,12 +572,12 @@ func (db *DB) backgroundManager() {
db.exps.AscendLessThan(&dbItem{
opts: &dbItemOpts{ex: true, exat: time.Now()},
}, func(item btree.Item) bool {
- expired = append(expired, item.(*dbItem).key)
+ expired = append(expired, item.(*dbItem))
return true
})
- if onExpired == nil {
- for _, key := range expired {
- if _, err := tx.Delete(key); err != nil {
+ if onExpired == nil && onExpiredSync == nil {
+ for _, itm := range expired {
+ if _, err := tx.Delete(itm.key); err != nil {
// it's ok to get a "not found" because the
// 'Delete' method reports "not found" for
// expired items.
@@ -576,6 +586,12 @@ func (db *DB) backgroundManager() {
}
}
}
+ } else if onExpiredSync != nil {
+ for _, itm := range expired {
+ if err := onExpiredSync(itm.key, itm.val, tx); err != nil {
+ return err
+ }
+ }
}
return nil
})
@@ -585,7 +601,11 @@ func (db *DB) backgroundManager() {
// send expired event, if needed
if onExpired != nil && len(expired) > 0 {
- onExpired(expired)
+ keys := make([]string, 0, 32)
+ for _, itm := range expired {
+ keys = append(keys, itm.key)
+ }
+ onExpired(keys)
}
// execute a disk sync, if needed
@@ -1399,13 +1419,18 @@ func (tx *Tx) Set(key, value string, opts *SetOptions) (previousValue string,
}
// Get returns a value for a key. If the item does not exist or if the item
-// has expired then ErrNotFound is returned.
-func (tx *Tx) Get(key string) (val string, err error) {
+// has expired then ErrNotFound is returned. If ignoreExpired is true, then
+// the found value will be returned even if it is expired.
+func (tx *Tx) Get(key string, ignoreExpired ...bool) (val string, err error) {
if tx.db == nil {
return "", ErrTxClosed
}
+ var ignore bool
+ if len(ignoreExpired) != 0 {
+ ignore = ignoreExpired[0]
+ }
item := tx.db.get(key)
- if item == nil || item.expired() {
+ if item == nil || (item.expired() && !ignore) {
// The item does not exists or has expired. Let's assume that
// the caller is only interested in items that have not expired.
return "", ErrNotFound
@@ -1775,7 +1800,7 @@ func (tx *Tx) DescendEqual(index, pivot string,
})
}
-// rect is used by Intersects
+// rect is used by Intersects and Nearby
type rect struct {
min, max []float64
}
@@ -1784,6 +1809,48 @@ func (r *rect) Rect(ctx interface{}) (min, max []float64) {
return r.min, r.max
}
+// Nearby searches for rectangle items that are nearby a target rect.
+// All items belonging to the specified index will be returned in order of
+// nearest to farthest.
+// The specified index must have been created by AddIndex() and the target
+// is represented by the rect string. This string will be processed by the
+// same bounds function that was passed to the CreateSpatialIndex() function.
+// An invalid index will return an error.
+// The dist param is the distance of the bounding boxes. In the case of
+// simple 2D points, it's the distance of the two 2D points squared.
+func (tx *Tx) Nearby(index, bounds string,
+ iterator func(key, value string, dist float64) bool) error {
+ if tx.db == nil {
+ return ErrTxClosed
+ }
+ if index == "" {
+ // cannot search on keys tree. just return nil.
+ return nil
+ }
+ // // wrap a rtree specific iterator around the user-defined iterator.
+ iter := func(item rtree.Item, dist float64) bool {
+ dbi := item.(*dbItem)
+ return iterator(dbi.key, dbi.val, dist)
+ }
+ idx := tx.db.idxs[index]
+ if idx == nil {
+ // index was not found. return error
+ return ErrNotFound
+ }
+ if idx.rtr == nil {
+ // not an r-tree index. just return nil
+ return nil
+ }
+ // execute the nearby search
+ var min, max []float64
+ if idx.rect != nil {
+ min, max = idx.rect(bounds)
+ }
+ // set the center param to false, which uses the box dist calc.
+ idx.rtr.KNN(&rect{min, max}, false, iter)
+ return nil
+}
+
// Intersects searches for rectangle items that intersect a target rect.
// The specified index must have been created by AddIndex() and the target
// is represented by the rect string. This string will be processed by the
diff --git a/vendor/github.com/tidwall/buntdb/buntdb_test.go b/vendor/github.com/tidwall/buntdb/buntdb_test.go
index 9668f2a5..01dd712d 100644
--- a/vendor/github.com/tidwall/buntdb/buntdb_test.go
+++ b/vendor/github.com/tidwall/buntdb/buntdb_test.go
@@ -1021,6 +1021,46 @@ func TestVariousTx(t *testing.T) {
}
}
+func TestNearby(t *testing.T) {
+ rand.Seed(time.Now().UnixNano())
+ N := 100000
+ db, _ := Open(":memory:")
+ db.CreateSpatialIndex("points", "*", IndexRect)
+ db.Update(func(tx *Tx) error {
+ for i := 0; i < N; i++ {
+ p := Point(
+ rand.Float64()*100,
+ rand.Float64()*100,
+ rand.Float64()*100,
+ rand.Float64()*100,
+ )
+ tx.Set(fmt.Sprintf("p:%d", i), p, nil)
+ }
+ return nil
+ })
+ var keys, values []string
+ var dists []float64
+ var pdist float64
+ var i int
+ db.View(func(tx *Tx) error {
+ tx.Nearby("points", Point(0, 0, 0, 0), func(key, value string, dist float64) bool {
+ if i != 0 && dist < pdist {
+ t.Fatal("out of order")
+ }
+ keys = append(keys, key)
+ values = append(values, value)
+ dists = append(dists, dist)
+ pdist = dist
+ i++
+ return true
+ })
+ return nil
+ })
+ if len(keys) != N {
+ t.Fatalf("expected '%v', got '%v'", N, len(keys))
+ }
+}
+
func Example_descKeys() {
db, _ := Open(":memory:")
db.CreateIndex("name", "*", IndexString)
@@ -2511,3 +2551,98 @@ func TestJSONIndex(t *testing.T) {
t.Fatalf("expected %v, got %v", expect, strings.Join(keys, ","))
}
}
+
+func TestOnExpiredSync(t *testing.T) {
+ db := testOpen(t)
+ defer testClose(db)
+
+ var config Config
+ if err := db.ReadConfig(&config); err != nil {
+ t.Fatal(err)
+ }
+ hits := make(chan int, 3)
+ config.OnExpiredSync = func(key, value string, tx *Tx) error {
+ n, err := strconv.Atoi(value)
+ if err != nil {
+ return err
+ }
+ defer func() { hits <- n }()
+ if n >= 2 {
+ _, err = tx.Delete(key)
+ if err != ErrNotFound {
+ return err
+ }
+ return nil
+ }
+ n++
+ _, _, err = tx.Set(key, strconv.Itoa(n), &SetOptions{Expires: true, TTL: time.Millisecond * 100})
+ return err
+ }
+ if err := db.SetConfig(config); err != nil {
+ t.Fatal(err)
+ }
+ err := db.Update(func(tx *Tx) error {
+ _, _, err := tx.Set("K", "0", &SetOptions{Expires: true, TTL: time.Millisecond * 100})
+ return err
+ })
+ if err != nil {
+ t.Fail()
+ }
+
+ done := make(chan struct{})
+ go func() {
+ ticks := time.NewTicker(time.Millisecond * 50)
+ defer ticks.Stop()
+ for {
+ select {
+ case <-done:
+ return
+ case <-ticks.C:
+ err := db.View(func(tx *Tx) error {
+ v, err := tx.Get("K", true)
+ if err != nil {
+ return err
+ }
+ n, err := strconv.Atoi(v)
+ if err != nil {
+ return err
+ }
+ if n < 0 || n > 2 {
+ t.Fail()
+ }
+ return nil
+ })
+ if err != nil {
+ t.Fail()
+ }
+ }
+ }
+ }()
+
+OUTER1:
+ for {
+ select {
+ case <-time.After(time.Second * 2):
+ t.Fail()
+ case v := <-hits:
+ if v >= 2 {
+ break OUTER1
+ }
+ }
+ }
+ err = db.View(func(tx *Tx) error {
+ defer close(done)
+ v, err := tx.Get("K")
+ if err != nil {
+ t.Fail()
+ return err
+ }
+ if v != "2" {
+ t.Fail()
+ }
+ return nil
+ })
+ if err != nil {
+ t.Fail()
+ }
+}
diff --git a/vendor/github.com/tidwall/rtree/.travis.yml b/vendor/github.com/tidwall/rtree/.travis.yml
index d5a23ec0..4f2ee4d9 100644
--- a/vendor/github.com/tidwall/rtree/.travis.yml
+++ b/vendor/github.com/tidwall/rtree/.travis.yml
@@ -1,3 +1 @@
language: go
-go:
- - 1.6
diff --git a/vendor/github.com/tidwall/rtree/README.md b/vendor/github.com/tidwall/rtree/README.md
index fa52dc35..53a845d2 100644
--- a/vendor/github.com/tidwall/rtree/README.md
+++ b/vendor/github.com/tidwall/rtree/README.md
@@ -14,6 +14,7 @@ Authors
* 1995 Sphere volume fix for degeneracy problem submitted by Paul Brook
* 2004 Templated C++ port by Greg Douglas
* 2016 Go port by Josh Baker
+* 2018 Added kNN and merged in some of the RBush logic by Vladimir Agafonkin
License
-------
diff --git a/vendor/github.com/tidwall/rtree/base/knn.go b/vendor/github.com/tidwall/rtree/base/knn.go
new file mode 100644
index 00000000..6b26df3f
--- /dev/null
+++ b/vendor/github.com/tidwall/rtree/base/knn.go
@@ -0,0 +1,98 @@
+package base
+
+import (
+ "github.com/tidwall/tinyqueue"
+)
+
+type queueItem struct {
+ node *treeNode
+ isItem bool
+ dist float64
+}
+
+func (item *queueItem) Less(b tinyqueue.Item) bool {
+ return item.dist < b.(*queueItem).dist
+}
+
+// KNN returns items nearest to farthest. The dist param is the "box distance".
+func (tr *RTree) KNN(min, max []float64, center bool, iter func(item interface{}, dist float64) bool) bool {
+ var isBox bool
+ knnPoint := make([]float64, tr.dims)
+
+ bbox := &treeNode{min: min, max: max}
+
+ for i := 0; i < tr.dims; i++ {
+ knnPoint[i] = (bbox.min[i] + bbox.max[i]) / 2
+ if !isBox && bbox.min[i] != bbox.max[i] {
+ isBox = true
+ }
+ }
+ node := tr.data
+ queue := tinyqueue.New(nil)
+ for node != nil {
+ for i := 0; i < node.count; i++ {
+ child := node.children[i]
+ var dist float64
+ if isBox {
+ dist = boxDistRect(bbox, child)
+ } else {
+ dist = boxDistPoint(knnPoint, child)
+ }
+ queue.Push(&queueItem{node: child, isItem: node.leaf, dist: dist})
+ }
+ for queue.Len() > 0 && queue.Peek().(*queueItem).isItem {
+ item := queue.Pop().(*queueItem)
+ if !iter(item.node.unsafeItem().item, item.dist) {
+ return false
+ }
+ }
+ last := queue.Pop()
+ if last != nil {
+ node = (*treeNode)(last.(*queueItem).node)
+ } else {
+ node = nil
+ }
+ }
+ return true
+}
+
+func boxDistRect(a, b *treeNode) float64 {
+ var dist float64
+ for i := 0; i < len(a.min); i++ {
+ var min, max float64
+ if a.min[i] > b.min[i] {
+ min = a.min[i]
+ } else {
+ min = b.min[i]
+ }
+ if a.max[i] < b.max[i] {
+ max = a.max[i]
+ } else {
+ max = b.max[i]
+ }
+ squared := min - max
+ if squared > 0 {
+ dist += squared * squared
+ }
+ }
+ return dist
+}
+
+func boxDistPoint(point []float64, childBox *treeNode) float64 {
+ var dist float64
+ for i := 0; i < len(point); i++ {
+ d := axisDist(point[i], childBox.min[i], childBox.max[i])
+ dist += d * d
+ }
+ return dist
+}
+
+func axisDist(k, min, max float64) float64 {
+ if k < min {
+ return min - k
+ }
+ if k <= max {
+ return 0
+ }
+ return k - max
+}
diff --git a/vendor/github.com/tidwall/rtree/base/load.go b/vendor/github.com/tidwall/rtree/base/load.go
new file mode 100644
index 00000000..bf6954fd
--- /dev/null
+++ b/vendor/github.com/tidwall/rtree/base/load.go
@@ -0,0 +1,97 @@
+package base
+
+import "math"
+
+// Load bulk load items into the R-tree.
+func (tr *RTree) Load(mins, maxs [][]float64, items []interface{}) {
+ if len(items) < tr.minEntries {
+ for i := 0; i < len(items); i++ {
+ tr.Insert(mins[i], maxs[i], items[i])
+ }
+ return
+ }
+
+ // prefill the items
+ fitems := make([]*treeNode, len(items))
+ for i := 0; i < len(items); i++ {
+ item := &treeItem{min: mins[i], max: maxs[i], item: items[i]}
+ fitems[i] = item.unsafeNode()
+ }
+
+ // following equations are defined in the paper describing OMT
+ N := len(fitems)
+ M := tr.maxEntries
+ h := int(math.Ceil(math.Log(float64(N)) / math.Log(float64(M))))
+ Nsubtree := int(math.Pow(float64(M), float64(h-1)))
+ S := int(math.Ceil(math.Sqrt(float64(N) / float64(Nsubtree))))
+
+ // sort by the initial axis
+ axis := 0
+ sortByAxis(fitems, axis)
+
+ // build the root node. it's split differently from the subtrees.
+ children := make([]*treeNode, 0, S)
+ for i := 0; i < S; i++ {
+ var part []*treeNode
+ if i == S-1 {
+ // last split
+ part = fitems[len(fitems)/S*i:]
+ } else {
+ part = fitems[len(fitems)/S*i : len(fitems)/S*(i+1)]
+ }
+ children = append(children, tr.omt(part, h-1, axis+1))
+ }
+
+ node := tr.createNode(children)
+ node.leaf = false
+ node.height = h
+ tr.calcBBox(node)
+
+ if tr.data.count == 0 {
+ // save as is if tree is empty
+ tr.data = node
+ } else if tr.data.height == node.height {
+ // split root if trees have the same height
+ tr.splitRoot(tr.data, node)
+ } else {
+ if tr.data.height < node.height {
+ // swap trees if inserted one is bigger
+ tr.data, node = node, tr.data
+ }
+
+ // insert the small tree into the large tree at appropriate level
+ tr.insert(node, nil, tr.data.height-node.height-1, true)
+ }
+}
+
+func (tr *RTree) omt(fitems []*treeNode, h, axis int) *treeNode {
+ if len(fitems) <= tr.maxEntries {
+ // reached leaf level; return leaf
+ children := make([]*treeNode, len(fitems))
+ copy(children, fitems)
+ node := tr.createNode(children)
+ node.height = h
+ tr.calcBBox(node)
+ return node
+ }
+
+ // sort the items on a different axis than the previous level.
+ sortByAxis(fitems, axis%tr.dims)
+ children := make([]*treeNode, 0, tr.maxEntries)
+ partsz := len(fitems) / tr.maxEntries
+ for i := 0; i < tr.maxEntries; i++ {
+ var part []*treeNode
+ if i == tr.maxEntries-1 {
+ // last part
+ part = fitems[partsz*i:]
+ } else {
+ part = fitems[partsz*i : partsz*(i+1)]
+ }
+ children = append(children, tr.omt(part, h-1, axis+1))
+ }
+ node := tr.createNode(children)
+ node.height = h
+ node.leaf = false
+ tr.calcBBox(node)
+ return node
+}
diff --git a/vendor/github.com/tidwall/rtree/base/rtree.go b/vendor/github.com/tidwall/rtree/base/rtree.go
new file mode 100644
index 00000000..4a66235f
--- /dev/null
+++ b/vendor/github.com/tidwall/rtree/base/rtree.go
@@ -0,0 +1,673 @@
+package base
+
+import (
+ "math"
+ "unsafe"
+)
+
+// precalculate infinity
+var mathInfNeg = math.Inf(-1)
+var mathInfPos = math.Inf(+1)
+
+type treeNode struct {
+ min, max []float64
+ children []*treeNode
+ count int
+ height int
+ leaf bool
+}
+
+func (node *treeNode) unsafeItem() *treeItem {
+ return (*treeItem)(unsafe.Pointer(node))
+}
+
+func (tr *RTree) createNode(children []*treeNode) *treeNode {
+ n := &treeNode{
+ height: 1,
+ leaf: true,
+ children: make([]*treeNode, tr.maxEntries+1),
+ }
+ if len(children) > 0 {
+ n.count = len(children)
+ copy(n.children[:n.count], children)
+ }
+ n.min = make([]float64, tr.dims)
+ n.max = make([]float64, tr.dims)
+ for i := 0; i < tr.dims; i++ {
+ n.min[i] = mathInfPos
+ n.max[i] = mathInfNeg
+ }
+ return n
+}
+
+func (node *treeNode) extend(b *treeNode) {
+ for i := 0; i < len(node.min); i++ {
+ if b.min[i] < node.min[i] {
+ node.min[i] = b.min[i]
+ }
+ if b.max[i] > node.max[i] {
+ node.max[i] = b.max[i]
+ }
+ }
+}
+
+func (node *treeNode) area() float64 {
+ area := node.max[0] - node.min[0]
+ for i := 1; i < len(node.min); i++ {
+ area *= node.max[i] - node.min[i]
+ }
+ return area
+}
+
+func (node *treeNode) enlargedAreaAxis(b *treeNode, axis int) float64 {
+ var max, min float64
+ if b.max[axis] > node.max[axis] {
+ max = b.max[axis]
+ } else {
+ max = node.max[axis]
+ }
+ if b.min[axis] < node.min[axis] {
+ min = b.min[axis]
+ } else {
+ min = node.min[axis]
+ }
+ return max - min
+}
+
+func (node *treeNode) enlargedArea(b *treeNode) float64 {
+ area := node.enlargedAreaAxis(b, 0)
+ for i := 1; i < len(node.min); i++ {
+ area *= node.enlargedAreaAxis(b, i)
+ }
+ return area
+}
+
+func (node *treeNode) intersectionAreaAxis(b *treeNode, axis int) float64 {
+ var max, min float64
+ if node.max[axis] < b.max[axis] {
+ max = node.max[axis]
+ } else {
+ max = b.max[axis]
+ }
+ if node.min[axis] > b.min[axis] {
+ min = node.min[axis]
+ } else {
+ min = b.min[axis]
+ }
+ if max > min {
+ return max - min
+ }
+ return 0
+}
+func (node *treeNode) intersectionArea(b *treeNode) float64 {
+ area := node.intersectionAreaAxis(b, 0)
+ for i := 1; i < len(node.min); i++ {
+ area *= node.intersectionAreaAxis(b, i)
+ }
+ return area
+}
+func (node *treeNode) margin() float64 {
+ margin := node.max[0] - node.min[0]
+ for i := 1; i < len(node.min); i++ {
+ margin += node.max[i] - node.min[i]
+ }
+ return margin
+}
+
+type result int
+
+const (
+ not result = 0
+ intersects result = 1
+ contains result = 2
+)
+
+func (node *treeNode) overlaps(b *treeNode) result {
+ for i := 0; i < len(node.min); i++ {
+ if b.min[i] > node.max[i] || b.max[i] < node.min[i] {
+ return not
+ }
+ if node.min[i] > b.min[i] || b.max[i] > node.max[i] {
+ i++
+ for ; i < len(node.min); i++ {
+ if b.min[i] > node.max[i] || b.max[i] < node.min[i] {
+ return not
+ }
+ }
+ return intersects
+ }
+ }
+ return contains
+}
+
+func (node *treeNode) intersects(b *treeNode) bool {
+ for i := 0; i < len(node.min); i++ {
+ if b.min[i] > node.max[i] || b.max[i] < node.min[i] {
+ return false
+ }
+ }
+ return true
+}
+
+func (node *treeNode) findItem(item interface{}) int {
+ for i := 0; i < node.count; i++ {
+ if node.children[i].unsafeItem().item == item {
+ return i
+ }
+ }
+ return -1
+}
+
+func (node *treeNode) contains(b *treeNode) bool {
+ for i := 0; i < len(node.min); i++ {
+ if node.min[i] > b.min[i] || b.max[i] > node.max[i] {
+ return false
+ }
+ }
+ return true
+}
+
+func (node *treeNode) childCount() int {
+ if node.leaf {
+ return node.count
+ }
+ var n int
+ for i := 0; i < node.count; i++ {
+ n += node.children[i].childCount()
+ }
+ return n
+}
+
+type treeItem struct {
+ min, max []float64
+ item interface{}
+}
+
+func (item *treeItem) unsafeNode() *treeNode {
+ return (*treeNode)(unsafe.Pointer(item))
+}
+
+// RTree is an R-tree
+type RTree struct {
+ dims int
+ maxEntries int
+ minEntries int
+ data *treeNode // root node
+ // resusable fields, these help performance of common mutable operations.
+ reuse struct {
+ path []*treeNode // for reinsertion path
+ indexes []int // for remove function
+ stack []int // for bulk loading
+ }
+}
+
+// New creates a new R-tree
+func New(dims, maxEntries int) *RTree {
+ if dims <= 0 {
+ panic("invalid dimensions")
+ }
+
+ tr := &RTree{}
+ tr.dims = dims
+ tr.maxEntries = int(math.Max(4, float64(maxEntries)))
+ tr.minEntries = int(math.Max(2, math.Ceil(float64(tr.maxEntries)*0.4)))
+ tr.data = tr.createNode(nil)
+ return tr
+}
+
+// Insert inserts an item
+func (tr *RTree) Insert(min, max []float64, item interface{}) {
+ if len(min) != tr.dims || len(max) != tr.dims {
+ panic("invalid dimensions")
+ }
+ if item == nil {
+ panic("nil item")
+ }
+ bbox := treeNode{min: min, max: max}
+ tr.insert(&bbox, item, tr.data.height-1, false)
+}
+
+func (tr *RTree) insert(bbox *treeNode, item interface{}, level int, isNode bool) {
+ tr.reuse.path = tr.reuse.path[:0]
+ node, insertPath := tr.chooseSubtree(bbox, tr.data, level, tr.reuse.path)
+ if item == nil {
+ // item is only nil when bulk loading a node
+ if node.leaf {
+ panic("loading node into leaf")
+ }
+ node.children[node.count] = bbox
+ node.count++
+ } else {
+ ti := &treeItem{min: bbox.min, max: bbox.max, item: item}
+ node.children[node.count] = ti.unsafeNode()
+ node.count++
+ }
+ node.extend(bbox)
+ for level >= 0 {
+ if insertPath[level].count > tr.maxEntries {
+ insertPath = tr.split(insertPath, level)
+ level--
+ } else {
+ break
+ }
+ }
+ tr.adjustParentBBoxes(bbox, insertPath, level)
+ tr.reuse.path = insertPath
+}
+
+func (tr *RTree) adjustParentBBoxes(bbox *treeNode, path []*treeNode, level int) {
+ // adjust bboxes along the given tree path
+ for i := level; i >= 0; i-- {
+ path[i].extend(bbox)
+ }
+}
+
+func (tr *RTree) chooseSubtree(bbox, node *treeNode, level int, path []*treeNode) (*treeNode, []*treeNode) {
+ var targetNode *treeNode
+ var area, enlargement, minArea, minEnlargement float64
+ for {
+ path = append(path, node)
+ if node.leaf || len(path)-1 == level {
+ break
+ }
+ minEnlargement = mathInfPos
+ minArea = minEnlargement
+ for i := 0; i < node.count; i++ {
+ child := node.children[i]
+ area = child.area()
+ enlargement = bbox.enlargedArea(child) - area
+ if enlargement < minEnlargement {
+ minEnlargement = enlargement
+ if area < minArea {
+ minArea = area
+ }
+ targetNode = child
+ } else if enlargement == minEnlargement {
+ if area < minArea {
+ minArea = area
+ targetNode = child
+ }
+ }
+ }
+ if targetNode != nil {
+ node = targetNode
+ } else if node.count > 0 {
+ node = (*treeNode)(node.children[0])
+ } else {
+ node = nil
+ }
+ }
+ return node, path
+}
+func (tr *RTree) split(insertPath []*treeNode, level int) []*treeNode {
+ var node = insertPath[level]
+ var M = node.count
+ var m = tr.minEntries
+
+ tr.chooseSplitAxis(node, m, M)
+ splitIndex := tr.chooseSplitIndex(node, m, M)
+
+ spliced := make([]*treeNode, node.count-splitIndex)
+ copy(spliced, node.children[splitIndex:])
+ node.count = splitIndex
+
+ newNode := tr.createNode(spliced)
+ newNode.height = node.height
+ newNode.leaf = node.leaf
+
+ tr.calcBBox(node)
+ tr.calcBBox(newNode)
+
+ if level != 0 {
+ insertPath[level-1].children[insertPath[level-1].count] = newNode
+ insertPath[level-1].count++
+ } else {
+ tr.splitRoot(node, newNode)
+ }
+ return insertPath
+}
+func (tr *RTree) chooseSplitIndex(node *treeNode, m, M int) int {
+ var i int
+ var bbox1, bbox2 *treeNode
+ var overlap, area, minOverlap, minArea float64
+ var index int
+
+ minArea = mathInfPos
+ minOverlap = minArea
+
+ for i = m; i <= M-m; i++ {
+ bbox1 = tr.distBBox(node, 0, i, nil)
+ bbox2 = tr.distBBox(node, i, M, nil)
+
+ overlap = bbox1.intersectionArea(bbox2)
+ area = bbox1.area() + bbox2.area()
+
+ // choose distribution with minimum overlap
+ if overlap < minOverlap {
+ minOverlap = overlap
+ index = i
+
+ if area < minArea {
+ minArea = area
+ }
+ } else if overlap == minOverlap {
+ // otherwise choose distribution with minimum area
+ if area < minArea {
+ minArea = area
+ index = i
+ }
+ }
+ }
+ return index
+}
+func (tr *RTree) calcBBox(node *treeNode) {
+ tr.distBBox(node, 0, node.count, node)
+}
+func (tr *RTree) chooseSplitAxis(node *treeNode, m, M int) {
+ minMargin := tr.allDistMargin(node, m, M, 0)
+ var minAxis int
+ for axis := 1; axis < tr.dims; axis++ {
+ margin := tr.allDistMargin(node, m, M, axis)
+ if margin < minMargin {
+ minMargin = margin
+ minAxis = axis
+ }
+ }
+ if minAxis < tr.dims {
+ tr.sortNodes(node, minAxis)
+ }
+}
+func (tr *RTree) splitRoot(node, newNode *treeNode) {
+ tr.data = tr.createNode([]*treeNode{node, newNode})
+ tr.data.height = node.height + 1
+ tr.data.leaf = false
+ tr.calcBBox(tr.data)
+}
+func (tr *RTree) distBBox(node *treeNode, k, p int, destNode *treeNode) *treeNode {
+ if destNode == nil {
+ destNode = tr.createNode(nil)
+ } else {
+ for i := 0; i < tr.dims; i++ {
+ destNode.min[i] = mathInfPos
+ destNode.max[i] = mathInfNeg
+ }
+ }
+ for i := k; i < p; i++ {
+ if node.leaf {
+ destNode.extend(node.children[i])
+ } else {
+ destNode.extend((*treeNode)(node.children[i]))
+ }
+ }
+ return destNode
+}
+func (tr *RTree) allDistMargin(node *treeNode, m, M int, axis int) float64 {
+ tr.sortNodes(node, axis)
+
+ var leftBBox = tr.distBBox(node, 0, m, nil)
+ var rightBBox = tr.distBBox(node, M-m, M, nil)
+ var margin = leftBBox.margin() + rightBBox.margin()
+
+ var i int
+
+ if node.leaf {
+ for i = m; i < M-m; i++ {
+ leftBBox.extend(node.children[i])
+ margin += leftBBox.margin()
+ }
+ for i = M - m - 1; i >= m; i-- {
+ leftBBox.extend(node.children[i])
+ margin += rightBBox.margin()
+ }
+ } else {
+ for i = m; i < M-m; i++ {
+ child := (*treeNode)(node.children[i])
+ leftBBox.extend(child)
+ margin += leftBBox.margin()
+ }
+ for i = M - m - 1; i >= m; i-- {
+ child := (*treeNode)(node.children[i])
+ leftBBox.extend(child)
+ margin += rightBBox.margin()
+ }
+ }
+ return margin
+}
+func (tr *RTree) sortNodes(node *treeNode, axis int) {
+ sortByAxis(node.children[:node.count], axis)
+}
+
+func sortByAxis(items []*treeNode, axis int) {
+ if len(items) < 2 {
+ return
+ }
+ left, right := 0, len(items)-1
+ pivotIndex := len(items) / 2
+ items[pivotIndex], items[right] = items[right], items[pivotIndex]
+ for i := range items {
+ if items[i].min[axis] < items[right].min[axis] {
+ items[i], items[left] = items[left], items[i]
+ left++
+ }
+ }
+ items[left], items[right] = items[right], items[left]
+ sortByAxis(items[:left], axis)
+ sortByAxis(items[left+1:], axis)
+}
+
+// Search searches the tree for items in the input rectangle
+func (tr *RTree) Search(min, max []float64, iter func(item interface{}) bool) bool {
+ bbox := &treeNode{min: min, max: max}
+ if !tr.data.intersects(bbox) {
+ return true
+ }
+ return tr.search(tr.data, bbox, iter)
+}
+
+func (tr *RTree) search(node, bbox *treeNode, iter func(item interface{}) bool) bool {
+ if node.leaf {
+ for i := 0; i < node.count; i++ {
+ if bbox.intersects(node.children[i]) {
+ if !iter(node.children[i].unsafeItem().item) {
+ return false
+ }
+ }
+ }
+ } else {
+ for i := 0; i < node.count; i++ {
+ r := bbox.overlaps(node.children[i])
+ if r == intersects {
+ if !tr.search(node.children[i], bbox, iter) {
+ return false
+ }
+ } else if r == contains {
+ if !scan(node.children[i], iter) {
+ return false
+ }
+ }
+ }
+ }
+ return true
+}
+
+func (tr *RTree) IsEmpty() bool {
+ empty := true
+ tr.Scan(func(item interface{}) bool {
+ empty = false
+ return false
+ })
+ return empty
+}
+
+// Remove removes an item from the R-tree.
+func (tr *RTree) Remove(min, max []float64, item interface{}) {
+ bbox := &treeNode{min: min, max: max}
+ tr.remove(bbox, item)
+}
+
+func (tr *RTree) remove(bbox *treeNode, item interface{}) {
+ path := tr.reuse.path[:0]
+ indexes := tr.reuse.indexes[:0]
+
+ var node = tr.data
+ var i int
+ var parent *treeNode
+ var index int
+ var goingUp bool
+
+ for node != nil || len(path) != 0 {
+ if node == nil {
+ node = path[len(path)-1]
+ path = path[:len(path)-1]
+ if len(path) == 0 {
+ parent = nil
+ } else {
+ parent = path[len(path)-1]
+ }
+ i = indexes[len(indexes)-1]
+ indexes = indexes[:len(indexes)-1]
+ goingUp = true
+ }
+
+ if node.leaf {
+ index = node.findItem(item)
+ if index != -1 {
+ // item found, remove the item and condense tree upwards
+ copy(node.children[index:], node.children[index+1:])
+ node.children[node.count-1] = nil
+ node.count--
+ path = append(path, node)
+ tr.condense(path)
+ goto done
+ }
+ }
+ if !goingUp && !node.leaf && node.contains(bbox) { // go down
+ path = append(path, node)
+ indexes = append(indexes, i)
+ i = 0
+ parent = node
+ node = (*treeNode)(node.children[0])
+ } else if parent != nil { // go right
+ i++
+ if i == parent.count {
+ node = nil
+ } else {
+ node = (*treeNode)(parent.children[i])
+ }
+ goingUp = false
+ } else {
+ node = nil
+ }
+ }
+done:
+ tr.reuse.path = path
+ tr.reuse.indexes = indexes
+ return
+}
+func (tr *RTree) condense(path []*treeNode) {
+ // go through the path, removing empty nodes and updating bboxes
+ var siblings []*treeNode
+ for i := len(path) - 1; i >= 0; i-- {
+ if path[i].count == 0 {
+ if i > 0 {
+ siblings = path[i-1].children[:path[i-1].count]
+ index := -1
+ for j := 0; j < len(siblings); j++ {
+ if siblings[j] == path[i] {
+ index = j
+ break
+ }
+ }
+ copy(siblings[index:], siblings[index+1:])
+ siblings[len(siblings)-1] = nil
+ path[i-1].count--
+ //siblings = siblings[:len(siblings)-1]
+ //path[i-1].children = siblings
+ } else {
+ tr.data = tr.createNode(nil) // clear tree
+ }
+ } else {
+ tr.calcBBox(path[i])
+ }
+ }
+}
+
+// Count returns the number of items in the R-tree.
+func (tr *RTree) Count() int {
+ return tr.data.childCount()
+}
+
+// Traverse iterates over the entire R-tree and includes all nodes and items.
+func (tr *RTree) Traverse(iter func(min, max []float64, level int, item interface{}) bool) bool {
+ return tr.traverse(tr.data, iter)
+}
+
+func (tr *RTree) traverse(node *treeNode, iter func(min, max []float64, level int, item interface{}) bool) bool {
+ if !iter(node.min, node.max, int(node.height), nil) {
+ return false
+ }
+ if node.leaf {
+ for i := 0; i < node.count; i++ {
+ child := node.children[i]
+ if !iter(child.min, child.max, 0, child.unsafeItem().item) {
+ return false
+ }
+ }
+ } else {
+ for i := 0; i < node.count; i++ {
+ child := node.children[i]
+ if !tr.traverse(child, iter) {
+ return false
+ }
+ }
+ }
+ return true
+}
+
+// Scan iterates over the entire R-tree
+func (tr *RTree) Scan(iter func(item interface{}) bool) bool {
+ return scan(tr.data, iter)
+}
+
+func scan(node *treeNode, iter func(item interface{}) bool) bool {
+ if node.leaf {
+ for i := 0; i < node.count; i++ {
+ child := node.children[i]
+ if !iter(child.unsafeItem().item) {
+ return false
+ }
+ }
+ } else {
+ for i := 0; i < node.count; i++ {
+ child := node.children[i]
+ if !scan(child, iter) {
+ return false
+ }
+ }
+ }
+ return true
+}
+
+// Bounds returns the bounding box of the entire R-tree
+func (tr *RTree) Bounds() (min, max []float64) {
+ if tr.data.count > 0 {
+ return tr.data.min, tr.data.max
+ }
+ return make([]float64, tr.dims), make([]float64, tr.dims)
+}
+
+// Complexity returns the complexity of the R-tree. The higher the value, the
+// more complex the tree. The value of 1 is the lowest.
+func (tr *RTree) Complexity() float64 {
+ var nodeCount int
+ var itemCount int
+ tr.Traverse(func(_, _ []float64, level int, _ interface{}) bool {
+ if level == 0 {
+ itemCount++
+ } else {
+ nodeCount++
+ }
+ return true
+ })
+ return float64(tr.maxEntries*nodeCount) / float64(itemCount)
+}
diff --git a/vendor/github.com/tidwall/rtree/base/rtree_test.go b/vendor/github.com/tidwall/rtree/base/rtree_test.go
new file mode 100644
index 00000000..f4bc1543
--- /dev/null
+++ b/vendor/github.com/tidwall/rtree/base/rtree_test.go
@@ -0,0 +1,584 @@
+package base
+
+import (
+ "fmt"
+ "log"
+ "math"
+ "math/rand"
+ "reflect"
+ "runtime"
+ "sort"
+ "testing"
+ "time"
+)
+
+const D = 2
+const M = 13
+
+type Rect struct {
+ min, max []float64
+ item interface{}
+}
+
+func (r *Rect) equals(r2 Rect) bool {
+ if len(r.min) != len(r2.min) || len(r.max) != len(r2.max) || r.item != r2.item {
+ return false
+ }
+ for i := 0; i < len(r.min); i++ {
+ if r.min[i] != r2.min[i] {
+ return false
+ }
+ }
+ for i := 0; i < len(r.max); i++ {
+ if r.max[i] != r2.max[i] {
+ return false
+ }
+ }
+ return true
+}
+
+func ptrMakePoint(vals ...float64) *Rect {
+ var r Rect
+ r.min = make([]float64, D)
+ r.max = make([]float64, D)
+ for i := 0; i < D && i < len(vals); i++ {
+ r.min[i] = vals[i]
+ r.max[i] = vals[i]
+ }
+ r.item = &r
+ return &r
+}
+
+func ptrMakeRect(vals ...float64) *Rect {
+ var r Rect
+ r.min = make([]float64, D)
+ r.max = make([]float64, D)
+ for i := 0; i < D && i < len(vals); i++ {
+ r.min[i] = vals[i]
+ r.max[i] = vals[i+D]
+ }
+ r.item = &r
+ return &r
+}
+
+func TestRTree(t *testing.T) {
+ tr := New(D, M)
+ p := ptrMakePoint(10, 10)
+ tr.Insert(p.min, p.max, p.item)
+}
+
+func TestPtrBasic2D(t *testing.T) {
+ if D != 2 {
+ return
+ }
+ tr := New(D, M)
+ p1 := ptrMakePoint(-115, 33)
+ p2 := ptrMakePoint(-113, 35)
+ tr.Insert(p1.min, p1.max, p1.item)
+ tr.Insert(p2.min, p2.max, p2.item)
+ assertEqual(t, 2, tr.Count())
+
+ var points []*Rect
+ bbox := ptrMakeRect(-116, 32, -114, 34)
+ tr.Search(bbox.min, bbox.max, func(item interface{}) bool {
+ points = append(points, item.(*Rect))
+ return true
+ })
+ assertEqual(t, 1, len(points))
+ tr.Remove(p1.min, p1.max, p1.item)
+ assertEqual(t, 1, tr.Count())
+
+ points = nil
+ bbox = ptrMakeRect(-116, 33, -114, 34)
+ tr.Search(bbox.min, bbox.max, func(item interface{}) bool {
+ points = append(points, item.(*Rect))
+ return true
+ })
+ assertEqual(t, 0, len(points))
+ tr.Remove(p2.min, p2.max, p2.item)
+ assertEqual(t, 0, tr.Count())
+}
+
+func getMemStats() runtime.MemStats {
+ runtime.GC()
+ time.Sleep(time.Millisecond)
+ runtime.GC()
+ var ms runtime.MemStats
+ runtime.ReadMemStats(&ms)
+ return ms
+}
+
+func ptrMakeRandom(what string) *Rect {
+ if what == "point" {
+ vals := make([]float64, D)
+ for i := 0; i < D; i++ {
+ if i == 0 {
+ vals[i] = rand.Float64()*360 - 180
+ } else if i == 1 {
+ vals[i] = rand.Float64()*180 - 90
+ } else {
+ vals[i] = rand.Float64()*100 - 50
+ }
+ }
+ return ptrMakePoint(vals...)
+ } else if what == "rect" {
+ vals := make([]float64, D)
+ for i := 0; i < D; i++ {
+ if i == 0 {
+ vals[i] = rand.Float64()*340 - 170
+ } else if i == 1 {
+ vals[i] = rand.Float64()*160 - 80
+ } else {
+ vals[i] = rand.Float64()*80 - 30
+ }
+ }
+ rvals := make([]float64, D*2)
+ for i := 0; i < D; i++ {
+ rvals[i] = vals[i] - rand.Float64()*10
+ rvals[D+i] = vals[i] + rand.Float64()*10
+ }
+ return ptrMakeRect(rvals...)
+ }
+ panic("??")
+}
+
+func TestPtrRandom(t *testing.T) {
+ t.Run(fmt.Sprintf("%dD", D), func(t *testing.T) {
+ t.Run("point", func(t *testing.T) { ptrTestRandom(t, "point", 10000) })
+ t.Run("rect", func(t *testing.T) { ptrTestRandom(t, "rect", 10000) })
+ })
+}
+
+func ptrTestRandom(t *testing.T, which string, n int) {
+ fmt.Println("-------------------------------------------------")
+ fmt.Printf("Testing Random %dD %ss\n", D, which)
+ fmt.Println("-------------------------------------------------")
+ rand.Seed(time.Now().UnixNano())
+ tr := New(D, M)
+ min, max := tr.Bounds()
+ assertEqual(t, make([]float64, D), min[:])
+ assertEqual(t, make([]float64, D), max[:])
+
+ // create random objects
+ m1 := getMemStats()
+ objs := make([]*Rect, n)
+ for i := 0; i < n; i++ {
+ objs[i] = ptrMakeRandom(which)
+ }
+
+ // insert the objects into tree
+ m2 := getMemStats()
+ start := time.Now()
+ for _, r := range objs {
+ tr.Insert(r.min, r.max, r.item)
+ }
+ durInsert := time.Since(start)
+ m3 := getMemStats()
+ assertEqual(t, len(objs), tr.Count())
+ fmt.Printf("Inserted %d random %ss in %dms -- %d ops/sec\n",
+ len(objs), which, int(durInsert.Seconds()*1000),
+ int(float64(len(objs))/durInsert.Seconds()))
+ fmt.Printf(" total cost is %d bytes/%s\n", int(m3.HeapAlloc-m1.HeapAlloc)/len(objs), which)
+ fmt.Printf(" tree cost is %d bytes/%s\n", int(m3.HeapAlloc-m2.HeapAlloc)/len(objs), which)
+ fmt.Printf(" tree overhead %d%%\n", int((float64(m3.HeapAlloc-m2.HeapAlloc)/float64(len(objs)))/(float64(m3.HeapAlloc-m1.HeapAlloc)/float64(len(objs)))*100))
+ fmt.Printf(" complexity %f\n", tr.Complexity())
+
+ start = time.Now()
+ // count all nodes and leaves
+ var nodes int
+ var leaves int
+ var maxLevel int
+ tr.Traverse(func(min, max []float64, level int, item interface{}) bool {
+ if level != 0 {
+ nodes++
+ }
+ if level == 1 {
+ leaves++
+ }
+ if level > maxLevel {
+ maxLevel = level
+ }
+ return true
+ })
+ fmt.Printf(" nodes: %d, leaves: %d, level: %d\n", nodes, leaves, maxLevel)
+
+ // verify mbr
+ for i := 0; i < D; i++ {
+ min[i] = math.Inf(+1)
+ max[i] = math.Inf(-1)
+ }
+ for _, o := range objs {
+ for i := 0; i < D; i++ {
+ if o.min[i] < min[i] {
+ min[i] = o.min[i]
+ }
+ if o.max[i] > max[i] {
+ max[i] = o.max[i]
+ }
+ }
+ }
+ minb, maxb := tr.Bounds()
+ assertEqual(t, min, minb)
+ assertEqual(t, max, maxb)
+
+ // scan
+ var arr []*Rect
+ tr.Scan(func(item interface{}) bool {
+ arr = append(arr, item.(*Rect))
+ return true
+ })
+ assertEqual(t, true, ptrTestHasSameItems(objs, arr))
+
+ // search
+ ptrTestSearch(t, tr, objs, 0.10, true)
+ ptrTestSearch(t, tr, objs, 0.50, true)
+ ptrTestSearch(t, tr, objs, 1.00, true)
+
+ // knn
+ ptrTestKNN(t, tr, objs, int(float64(len(objs))*0.01), true)
+ ptrTestKNN(t, tr, objs, int(float64(len(objs))*0.50), true)
+ ptrTestKNN(t, tr, objs, int(float64(len(objs))*1.00), true)
+
+ // remove all objects
+ indexes := rand.Perm(len(objs))
+ start = time.Now()
+ for _, i := range indexes {
+ tr.Remove(objs[i].min, objs[i].max, objs[i].item)
+ }
+ durRemove := time.Since(start)
+ assertEqual(t, 0, tr.Count())
+ fmt.Printf("Removed %d random %ss in %dms -- %d ops/sec\n",
+ len(objs), which, int(durRemove.Seconds()*1000),
+ int(float64(len(objs))/durRemove.Seconds()))
+
+ min, max = tr.Bounds()
+ assertEqual(t, make([]float64, D), min[:])
+ assertEqual(t, make([]float64, D), max[:])
+}
+
+func ptrTestHasSameItems(a1, a2 []*Rect) bool {
+ if len(a1) != len(a2) {
+ return false
+ }
+ for _, p1 := range a1 {
+ var found bool
+ for _, p2 := range a2 {
+ if p1.equals(*p2) {
+ found = true
+ break
+ }
+ }
+ if !found {
+ return false
+ }
+ }
+ return true
+}
+
+func ptrTestSearch(t *testing.T, tr *RTree, objs []*Rect, percent float64, check bool) {
+ var found int
+ var start time.Time
+ var stop time.Time
+ defer func() {
+ dur := stop.Sub(start)
+ fmt.Printf("Searched %.0f%% (%d/%d items) in %dms -- %d ops/sec\n",
+ percent*100, found, len(objs), int(dur.Seconds()*1000),
+ int(float64(1)/dur.Seconds()),
+ )
+ }()
+ min, max := tr.Bounds()
+ vals := make([]float64, D*2)
+ for i := 0; i < D; i++ {
+ vals[i] = ((max[i]+min[i])/2 - ((max[i]-min[i])*percent)/2)
+ vals[D+i] = ((max[i]+min[i])/2 + ((max[i]-min[i])*percent)/2)
+ }
+ var arr1 []*Rect
+ var box *Rect
+ if percent == 1 {
+ box = ptrMakeRect(append(append([]float64{}, min[:]...), max[:]...)...)
+ } else {
+ box = ptrMakeRect(vals...)
+ }
+ start = time.Now()
+ tr.Search(box.min, box.max, func(item interface{}) bool {
+ if check {
+ arr1 = append(arr1, item.(*Rect))
+ }
+ found++
+ return true
+ })
+ stop = time.Now()
+ if !check {
+ return
+ }
+ var arr2 []*Rect
+ for _, obj := range objs {
+ if ptrTestIntersects(obj, box) {
+ arr2 = append(arr2, obj)
+ }
+ }
+ assertEqual(t, len(arr1), len(arr2))
+ for _, o1 := range arr1 {
+ var found bool
+ for _, o2 := range arr2 {
+ if o2.equals(*o1) {
+ found = true
+ break
+ }
+ }
+ if !found {
+ t.Fatalf("not found")
+ }
+ }
+}
+
+func ptrTestKNN(t *testing.T, tr *RTree, objs []*Rect, n int, check bool) {
+ var start time.Time
+ var stop time.Time
+ defer func() {
+ dur := stop.Sub(start)
+ fmt.Printf("KNN %d items in %dms -- %d ops/sec\n",
+ n, int(dur.Seconds()*1000),
+ int(float64(1)/dur.Seconds()),
+ )
+ }()
+ min, max := tr.Bounds()
+ pvals := make([]float64, D)
+ for i := 0; i < D; i++ {
+ pvals[i] = (max[i] + min[i]) / 2
+ }
+ point := ptrMakePoint(pvals...)
+
+ // gather the results, make sure that is matches exactly
+ var arr1 []Rect
+ var dists1 []float64
+ pdist := math.Inf(-1)
+ start = time.Now()
+ tr.KNN(point.min, point.max, false, func(item interface{}, dist float64) bool {
+ if len(arr1) == n {
+ return false
+ }
+ arr1 = append(arr1, Rect{min: min, max: max, item: item})
+ dists1 = append(dists1, dist)
+ if dist < pdist {
+ panic("dist out of order")
+ }
+ pdist = dist
+ return true
+ })
+ stop = time.Now()
+ assertEqual(t, true, n > len(objs) || n == len(arr1))
+
+ // get the KNN for the original array
+ nobjs := make([]*Rect, len(objs))
+ copy(nobjs, objs)
+ sort.Slice(nobjs, func(i, j int) bool {
+ idist := ptrTestBoxDist(pvals, nobjs[i].min, nobjs[i].max)
+ jdist := ptrTestBoxDist(pvals, nobjs[j].min, nobjs[j].max)
+ return idist < jdist
+ })
+ arr2 := nobjs[:len(arr1)]
+ var dists2 []float64
+ for i := 0; i < len(arr2); i++ {
+ dist := ptrTestBoxDist(pvals, arr2[i].min, arr2[i].max)
+ dists2 = append(dists2, dist)
+ }
+ // only compare the distances, not the objects because rectangles with
+ // a dist of zero will not be ordered.
+ assertEqual(t, dists1, dists2)
+
+}
+
+func ptrTestBoxDist(point []float64, min, max []float64) float64 {
+ var dist float64
+ for i := 0; i < len(point); i++ {
+ d := ptrTestAxisDist(point[i], min[i], max[i])
+ dist += d * d
+ }
+ return dist
+}
+func ptrTestAxisDist(k, min, max float64) float64 {
+ if k < min {
+ return min - k
+ }
+ if k <= max {
+ return 0
+ }
+ return k - max
+}
+func ptrTestIntersects(obj, box *Rect) bool {
+ for i := 0; i < D; i++ {
+ if box.min[i] > obj.max[i] || box.max[i] < obj.min[i] {
+ return false
+ }
+ }
+ return true
+}
+
+// func TestPtrInsertFlatPNG2D(t *testing.T) {
+// fmt.Println("-------------------------------------------------")
+// fmt.Println("Generating Cities PNG 2D (flat-insert-2d.png)")
+// fmt.Println("-------------------------------------------------")
+// tr := New()
+// var items []*Rect
+// c := cities.Cities
+// for i := 0; i < len(c); i++ {
+// x := c[i].Longitude
+// y := c[i].Latitude
+// items = append(items, ptrMakePoint(x, y))
+// }
+// start := time.Now()
+// for _, item := range items {
+// tr.Insert(item.min, item.max, item.item)
+// }
+// dur := time.Since(start)
+// fmt.Printf("wrote %d cities (flat) in %s (%.0f/ops)\n", len(c), dur, float64(len(c))/dur.Seconds())
+// withGIF := os.Getenv("GIFOUTPUT") != ""
+// if err := tr.SavePNG("ptr-flat-insert-2d.png", 1000, 1000, 1.25/360.0, 0, true, withGIF, os.Stdout); err != nil {
+// t.Fatal(err)
+// }
+// if !withGIF {
+// fmt.Println("use GIFOUTPUT=1 for animated gif")
+// }
+// }
+
+// func TestPtrLoadFlatPNG2D(t *testing.T) {
+// fmt.Println("-------------------------------------------------")
+// fmt.Println("Generating Cities 2D PNG (flat-load-2d.png)")
+// fmt.Println("-------------------------------------------------")
+// tr := New()
+// var items []*Rect
+// c := cities.Cities
+// for i := 0; i < len(c); i++ {
+// x := c[i].Longitude
+// y := c[i].Latitude
+// items = append(items, ptrMakePoint(x, y))
+// }
+
+// var mins [][D]float64
+// var maxs [][D]float64
+// var ifs []interface{}
+// for i := 0; i < len(items); i++ {
+// mins = append(mins, items[i].min)
+// maxs = append(maxs, items[i].max)
+// ifs = append(ifs, items[i].item)
+// }
+
+// start := time.Now()
+// tr.Load(mins, maxs, ifs)
+// dur := time.Since(start)
+
+// if true {
+// var all []*Rect
+// tr.Scan(func(min, max [D]float64, item interface{}) bool {
+// all = append(all, &Rect{min: min, max: max, item: item})
+// return true
+// })
+// assertEqual(t, len(all), len(items))
+
+// for len(all) > 0 {
+// item := all[0]
+// var found bool
+// for _, city := range items {
+// if *city == *item {
+// found = true
+// break
+// }
+// }
+// if !found {
+// t.Fatal("item not found")
+// }
+// all = all[1:]
+// }
+// }
+// fmt.Printf("wrote %d cities (flat) in %s (%.0f/ops)\n", len(c), dur, float64(len(c))/dur.Seconds())
+// withGIF := os.Getenv("GIFOUTPUT") != ""
+// if err := tr.SavePNG("ptr-flat-load-2d.png", 1000, 1000, 1.25/360.0, 0, true, withGIF, os.Stdout); err != nil {
+// t.Fatal(err)
+// }
+// if !withGIF {
+// fmt.Println("use GIFOUTPUT=1 for animated gif")
+// }
+// }
+
+func TestBenchmarks(t *testing.T) {
+ var points []*Rect
+ for i := 0; i < 2000000; i++ {
+ x := rand.Float64()*360 - 180
+ y := rand.Float64()*180 - 90
+ points = append(points, ptrMakePoint(x, y))
+ }
+ tr := New(D, M)
+ start := time.Now()
+ for i := len(points) / 2; i < len(points); i++ {
+ tr.Insert(points[i].min, points[i].max, points[i].item)
+ }
+ dur := time.Since(start)
+ log.Printf("insert 1M items one by one: %.3fs", dur.Seconds())
+ ////
+ rarr := rand.Perm(len(points) / 2)
+ start = time.Now()
+ for i := 0; i < len(points)/2; i++ {
+ a := points[rarr[i]+len(points)/2]
+ b := points[rarr[i]]
+ tr.Remove(a.min, a.max, a.item)
+ tr.Insert(b.min, b.max, b.item)
+ }
+ dur = time.Since(start)
+ log.Printf("replaced 1M items one by one: %.3fs", dur.Seconds())
+ points = points[:len(points)/2]
+ ////
+ start = time.Now()
+ for i := 0; i < 1000; i++ {
+ tr.Remove(points[i].min, points[i].max, points[i].item)
+ }
+ dur = time.Since(start)
+ log.Printf("remove 100 items one by one: %.3fs", dur.Seconds())
+ ////
+ bbox := ptrMakeRect(0, 0, 0+(360*0.0001), 0+(180*0.0001))
+ start = time.Now()
+ for i := 0; i < 1000; i++ {
+ tr.Search(bbox.min, bbox.max, func(_ interface{}) bool { return true })
+ }
+ dur = time.Since(start)
+ log.Printf("1000 searches of 0.01%% area: %.3fs", dur.Seconds())
+ ////
+ bbox = ptrMakeRect(0, 0, 0+(360*0.01), 0+(180*0.01))
+ start = time.Now()
+ for i := 0; i < 1000; i++ {
+ tr.Search(bbox.min, bbox.max, func(_ interface{}) bool { return true })
+ }
+ dur = time.Since(start)
+ log.Printf("1000 searches of 1%% area: %.3fs", dur.Seconds())
+ ////
+ bbox = ptrMakeRect(0, 0, 0+(360*0.10), 0+(180*0.10))
+ start = time.Now()
+ for i := 0; i < 1000; i++ {
+ tr.Search(bbox.min, bbox.max, func(_ interface{}) bool { return true })
+ }
+ dur = time.Since(start)
+ log.Printf("1000 searches of 10%% area: %.3fs", dur.Seconds())
+ ///
+
+ var mins [][]float64
+ var maxs [][]float64
+ var items []interface{}
+ for i := 0; i < len(points); i++ {
+ mins = append(mins, points[i].min)
+ maxs = append(maxs, points[i].max)
+ items = append(items, points[i].item)
+ }
+
+ tr = New(D, M)
+ start = time.Now()
+ tr.Load(mins, maxs, items)
+ dur = time.Since(start)
+ log.Printf("bulk-insert 1M items: %.3fs", dur.Seconds())
+}
+
+func assertEqual(t *testing.T, expected, actual interface{}) {
+ t.Helper()
+ if !reflect.DeepEqual(expected, actual) {
+ t.Fatalf("expected '%v', got '%v'", expected, actual)
+ }
+}
diff --git a/vendor/github.com/tidwall/rtree/gen/gen.go b/vendor/github.com/tidwall/rtree/gen/gen.go
deleted file mode 100644
index 2a709928..00000000
--- a/vendor/github.com/tidwall/rtree/gen/gen.go
+++ /dev/null
@@ -1,87 +0,0 @@
-package main
-
-import (
- "flag"
- "io/ioutil"
- "log"
- "os"
- "strconv"
- "strings"
-)
-
-func main() {
- var dims int
- var debug bool
- flag.IntVar(&dims, "dims", 4, "number of dimensions")
- flag.BoolVar(&debug, "debug", false, "turn on debug tracing")
- flag.Parse()
- // process rtree.go
- data, err := ioutil.ReadFile("src/rtree.go")
- if err != nil {
- log.Fatal(err)
- }
- data = []byte(strings.Replace(string(data), "// +build ignore", "// generated; DO NOT EDIT!", -1))
- if debug {
- data = []byte(strings.Replace(string(data), "TDEBUG", "true", -1))
- } else {
- data = []byte(strings.Replace(string(data), "TDEBUG", "false", -1))
- }
- var dimouts = make([]string, dims)
- var output string
- var recording bool
- lines := strings.Split(string(data), "\n")
- for _, line := range lines {
- if strings.HasPrefix(strings.TrimSpace(line), "//") {
- idx := strings.Index(line, "//")
- switch strings.ToUpper(strings.TrimSpace(line[idx+2:])) {
- case "BEGIN":
- recording = true
- for i := 0; i < len(dimouts); i++ {
- dimouts[i] = ""
- }
- continue
- case "END":
- for _, out := range dimouts {
- if out != "" {
- output += out
- }
- }
- recording = false
- continue
- }
- }
- if recording {
- for i := 0; i < len(dimouts); i++ {
- dimouts[i] += strings.Replace(line, "TNUMDIMS", strconv.FormatInt(int64(i+1), 10), -1) + "\n"
- }
- } else {
- output += line + "\n"
- }
- }
- // process rtree_base.go
- if err := os.RemoveAll("../dims"); err != nil {
- log.Fatal(err)
- }
- for i := 0; i < dims; i++ {
- sdim := strconv.FormatInt(int64(i+1), 10)
- data, err := ioutil.ReadFile("src/rtree_base.go")
- if err != nil {
- log.Fatal(err)
- }
- data = []byte(strings.Split(string(data), "// FILE_START")[1])
- if debug {
- data = []byte(strings.Replace(string(data), "TDEBUG", "true", -1))
- } else {
- data = []byte(strings.Replace(string(data), "TDEBUG", "false", -1))
- }
- data = []byte(strings.Replace(string(data), "TNUMDIMS", strconv.FormatInt(int64(i+1), 10), -1))
- data = []byte(strings.Replace(string(data), "DD_", "d"+strconv.FormatInt(int64(i+1), 10), -1))
- if err := os.MkdirAll("../dims/d"+sdim, 0777); err != nil {
- log.Fatal(err)
- }
- output = string(append([]byte(output), data...))
- }
- if err := ioutil.WriteFile("../rtree.go", []byte(output), 0666); err != nil {
- log.Fatal(err)
- }
-}
diff --git a/vendor/github.com/tidwall/rtree/gen/gen.sh b/vendor/github.com/tidwall/rtree/gen/gen.sh
deleted file mode 100755
index edf3189c..00000000
--- a/vendor/github.com/tidwall/rtree/gen/gen.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/bash
-
-set -e
-
-cd $(dirname "${BASH_SOURCE[0]}")
-
-go run gen.go --dims=20 --debug=false
-cd ..
-go fmt
diff --git a/vendor/github.com/tidwall/rtree/gen/src/rtree.go b/vendor/github.com/tidwall/rtree/gen/src/rtree.go
deleted file mode 100644
index 5c1a4383..00000000
--- a/vendor/github.com/tidwall/rtree/gen/src/rtree.go
+++ /dev/null
@@ -1,134 +0,0 @@
-// +build ignore
-
-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{}
- // BEGIN
- trTNUMDIMS *dTNUMDIMSRTree
- // END
-}
-
-func New(ctx interface{}) *RTree {
- return &RTree{
- ctx: ctx,
- // BEGIN
- trTNUMDIMS: dTNUMDIMSNew(),
- // END
- }
-}
-
-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")
- // BEGIN
- case TNUMDIMS:
- var amin, amax [TNUMDIMS]float64
- for i := 0; i < len(min); i++ {
- amin[i], amax[i] = min[i], max[i]
- }
- tr.trTNUMDIMS.Insert(amin, amax, item)
- // END
- }
-}
-
-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")
- // BEGIN
- case TNUMDIMS:
- var amin, amax [TNUMDIMS]float64
- for i := 0; i < len(min); i++ {
- amin[i], amax[i] = min[i], max[i]
- }
- tr.trTNUMDIMS.Remove(amin, amax, item)
- // END
- }
-}
-func (tr *RTree) Reset() {
- // BEGIN
- tr.trTNUMDIMS = dTNUMDIMSNew()
- // END
-}
-func (tr *RTree) Count() int {
- count := 0
- // BEGIN
- count += tr.trTNUMDIMS.Count()
- // END
- 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")
- // BEGIN
- case TNUMDIMS:
- // END
- }
- // BEGIN
- if !tr.searchTNUMDIMS(min, max, iter) {
- return
- }
- // END
-}
-
-// BEGIN
-func (tr *RTree) searchTNUMDIMS(min, max []float64, iter Iterator) bool {
- var amin, amax [TNUMDIMS]float64
- for i := 0; i < TNUMDIMS; 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.trTNUMDIMS.Search(amin, amax, func(dataID interface{}) bool {
- if !iter(dataID.(Item)) {
- ended = true
- return false
- }
- return true
- })
- return !ended
-}
-
-// END
diff --git a/vendor/github.com/tidwall/rtree/gen/src/rtree_base.go b/vendor/github.com/tidwall/rtree/gen/src/rtree_base.go
deleted file mode 100644
index 81d21630..00000000
--- a/vendor/github.com/tidwall/rtree/gen/src/rtree_base.go
+++ /dev/null
@@ -1,687 +0,0 @@
-// +build ignore
-
-/*
-
-TITLE
-
- R-TREES: A DYNAMIC INDEX STRUCTURE FOR SPATIAL SEARCHING
-
-DESCRIPTION
-
- A Go version of the RTree algorithm.
-
-AUTHORS
-
- * 1983 Original algorithm and test code by Antonin Guttman and Michael Stonebraker, UC Berkely
- * 1994 ANCI C ported from original test code by Melinda Green - melinda@superliminal.com
- * 1995 Sphere volume fix for degeneracy problem submitted by Paul Brook
- * 2004 Templated C++ port by Greg Douglas
- * 2016 Go port by Josh Baker
-
-LICENSE:
-
- Entirely free for all uses. Enjoy!
-
-*/
-
-// Implementation of RTree, a multidimensional bounding rectangle tree.
-package rtree
-
-import "math"
-
-// FILE_START
-
-func DD_fmin(a, b float64) float64 {
- if a < b {
- return a
- }
- return b
-}
-func DD_fmax(a, b float64) float64 {
- if a > b {
- return a
- }
- return b
-}
-
-const (
- DD_numDims = TNUMDIMS
- DD_maxNodes = 8
- DD_minNodes = DD_maxNodes / 2
- DD_useSphericalVolume = true // Better split classification, may be slower on some systems
-)
-
-var DD_unitSphereVolume = []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
-}[DD_numDims]
-
-type DD_RTree struct {
- root *DD_nodeT ///< Root of tree
-}
-
-/// Minimal bounding rectangle (n-dimensional)
-type DD_rectT struct {
- min [DD_numDims]float64 ///< Min dimensions of bounding box
- max [DD_numDims]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 DD_branchT struct {
- rect DD_rectT ///< Bounds
- child *DD_nodeT ///< Child node
- data interface{} ///< Data Id or Ptr
-}
-
-/// DD_nodeT for each branch level
-type DD_nodeT struct {
- count int ///< Count
- level int ///< Leaf is zero, others positive
- branch [DD_maxNodes]DD_branchT ///< Branch
-}
-
-func (node *DD_nodeT) isInternalNode() bool {
- return (node.level > 0) // Not a leaf, but a internal node
-}
-func (node *DD_nodeT) isLeaf() bool {
- return (node.level == 0) // A leaf, contains data
-}
-
-/// A link list of nodes for reinsertion after a delete operation
-type DD_listNodeT struct {
- next *DD_listNodeT ///< Next in list
- node *DD_nodeT ///< Node
-}
-
-const DD_notTaken = -1 // indicates that position
-
-/// Variables for finding a split partition
-type DD_partitionVarsT struct {
- partition [DD_maxNodes + 1]int
- total int
- minFill int
- count [2]int
- cover [2]DD_rectT
- area [2]float64
-
- branchBuf [DD_maxNodes + 1]DD_branchT
- branchCount int
- coverSplit DD_rectT
- coverSplitArea float64
-}
-
-func DD_New() *DD_RTree {
- // 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 &DD_RTree{
- root: &DD_nodeT{},
- }
-}
-
-/// 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 *DD_RTree) Insert(min, max [DD_numDims]float64, dataId interface{}) {
- var branch DD_branchT
- branch.data = dataId
- for axis := 0; axis < DD_numDims; axis++ {
- branch.rect.min[axis] = min[axis]
- branch.rect.max[axis] = max[axis]
- }
- DD_insertRect(&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 *DD_RTree) Remove(min, max [DD_numDims]float64, dataId interface{}) {
- var rect DD_rectT
- for axis := 0; axis < DD_numDims; axis++ {
- rect.min[axis] = min[axis]
- rect.max[axis] = max[axis]
- }
- DD_removeRect(&rect, dataId, &tr.root)
-}
-
-/// Find all within DD_search rectangle
-/// \param a_min Min of DD_search bounding rect
-/// \param a_max Max of DD_search bounding rect
-/// \param a_searchResult DD_search 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 *DD_RTree) Search(min, max [DD_numDims]float64, resultCallback func(data interface{}) bool) int {
- var rect DD_rectT
- for axis := 0; axis < DD_numDims; axis++ {
- rect.min[axis] = min[axis]
- rect.max[axis] = max[axis]
- }
- foundCount, _ := DD_search(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 *DD_RTree) Count() int {
- var count int
- DD_countRec(tr.root, &count)
- return count
-}
-
-/// Remove all entries from tree
-func (tr *DD_RTree) RemoveAll() {
- // Delete all existing nodes
- tr.root = &DD_nodeT{}
-}
-
-func DD_countRec(node *DD_nodeT, count *int) {
- if node.isInternalNode() { // not a leaf node
- for index := 0; index < node.count; index++ {
- DD_countRec(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 DD_insertRectRec(branch *DD_branchT, node *DD_nodeT, newNode **DD_nodeT, 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 *DD_nodeT
- //var newBranch DD_branchT
-
- // find the optimal branch for this record
- index := DD_pickBranch(&branch.rect, node)
-
- // recursively insert this record into the picked branch
- childWasSplit := DD_insertRectRec(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 = DD_combineRect(&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 = DD_nodeCover(node.branch[index].child)
- var newBranch DD_branchT
- newBranch.child = otherNode
- newBranch.rect = DD_nodeCover(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 DD_addBranch(&newBranch, node, newNode)
- }
- } else if node.level == level {
- // We have reached level for insertion. Add rect, split if necessary
- return DD_addBranch(branch, node, newNode)
- } else {
- // Should never occur
- return false
- }
-}
-
-// Insert a data rectangle into an index structure.
-// DD_insertRect 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 DD_insertRect(branch *DD_branchT, root **DD_nodeT, level int) bool {
- var newNode *DD_nodeT
-
- if DD_insertRectRec(branch, *root, &newNode, level) { // Root split
-
- // Grow tree taller and new root
- newRoot := &DD_nodeT{}
- newRoot.level = (*root).level + 1
-
- var newBranch DD_branchT
-
- // add old root node as a child of the new root
- newBranch.rect = DD_nodeCover(*root)
- newBranch.child = *root
- DD_addBranch(&newBranch, newRoot, nil)
-
- // add the split node as a child of the new root
- newBranch.rect = DD_nodeCover(newNode)
- newBranch.child = newNode
- DD_addBranch(&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 DD_nodeCover(node *DD_nodeT) DD_rectT {
- rect := node.branch[0].rect
- for index := 1; index < node.count; index++ {
- rect = DD_combineRect(&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 DD_addBranch(branch *DD_branchT, node *DD_nodeT, newNode **DD_nodeT) bool {
- if node.count < DD_maxNodes { // Split won't be necessary
- node.branch[node.count] = *branch
- node.count++
- return false
- } else {
- DD_splitNode(node, branch, newNode)
- return true
- }
-}
-
-// Disconnect a dependent node.
-// Caller must return (or stop using iteration index) after this as count has changed
-func DD_disconnectBranch(node *DD_nodeT, 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 DD_pickBranch(rect *DD_rectT, node *DD_nodeT) int {
- var firstTime bool = true
- var increase float64
- var bestIncr float64 = -1
- var area float64
- var bestArea float64
- var best int
- var tempRect DD_rectT
-
- for index := 0; index < node.count; index++ {
- curRect := &node.branch[index].rect
- area = DD_calcRectVolume(curRect)
- tempRect = DD_combineRect(rect, curRect)
- increase = DD_calcRectVolume(&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 DD_combineRect(rectA, rectB *DD_rectT) DD_rectT {
- var newRect DD_rectT
-
- for index := 0; index < DD_numDims; index++ {
- newRect.min[index] = DD_fmin(rectA.min[index], rectB.min[index])
- newRect.max[index] = DD_fmax(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 DD_splitNode(node *DD_nodeT, branch *DD_branchT, newNode **DD_nodeT) {
- // Could just use local here, but member or external is faster since it is reused
- var localVars DD_partitionVarsT
- parVars := &localVars
-
- // Load all the branches into a buffer, initialize old node
- DD_getBranches(node, branch, parVars)
-
- // Find partition
- DD_choosePartition(parVars, DD_minNodes)
-
- // Create a new node to hold (about) half of the branches
- *newNode = &DD_nodeT{}
- (*newNode).level = node.level
-
- // Put branches from buffer into 2 nodes according to the chosen partition
- node.count = 0
- DD_loadNodes(node, *newNode, parVars)
-}
-
-// Calculate the n-dimensional volume of a rectangle
-func DD_rectVolume(rect *DD_rectT) float64 {
- var volume float64 = 1
- for index := 0; index < DD_numDims; index++ {
- volume *= rect.max[index] - rect.min[index]
- }
- return volume
-}
-
-// The exact volume of the bounding sphere for the given DD_rectT
-func DD_rectSphericalVolume(rect *DD_rectT) float64 {
- var sumOfSquares float64 = 0
- var radius float64
-
- for index := 0; index < DD_numDims; 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 DD_numDims == 5 {
- return (radius * radius * radius * radius * radius * DD_unitSphereVolume)
- } else if DD_numDims == 4 {
- return (radius * radius * radius * radius * DD_unitSphereVolume)
- } else if DD_numDims == 3 {
- return (radius * radius * radius * DD_unitSphereVolume)
- } else if DD_numDims == 2 {
- return (radius * radius * DD_unitSphereVolume)
- } else {
- return (math.Pow(radius, DD_numDims) * DD_unitSphereVolume)
- }
-}
-
-// Use one of the methods to calculate retangle volume
-func DD_calcRectVolume(rect *DD_rectT) float64 {
- if DD_useSphericalVolume {
- return DD_rectSphericalVolume(rect) // Slower but helps certain merge cases
- } else { // RTREE_USE_SPHERICAL_VOLUME
- return DD_rectVolume(rect) // Faster but can cause poor merges
- } // RTREE_USE_SPHERICAL_VOLUME
-}
-
-// Load branch buffer with branches from full node plus the extra branch.
-func DD_getBranches(node *DD_nodeT, branch *DD_branchT, parVars *DD_partitionVarsT) {
- // Load the branch buffer
- for index := 0; index < DD_maxNodes; index++ {
- parVars.branchBuf[index] = node.branch[index]
- }
- parVars.branchBuf[DD_maxNodes] = *branch
- parVars.branchCount = DD_maxNodes + 1
-
- // Calculate rect containing all in the set
- parVars.coverSplit = parVars.branchBuf[0].rect
- for index := 1; index < DD_maxNodes+1; index++ {
- parVars.coverSplit = DD_combineRect(&parVars.coverSplit, &parVars.branchBuf[index].rect)
- }
- parVars.coverSplitArea = DD_calcRectVolume(&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 DD_choosePartition(parVars *DD_partitionVarsT, minFill int) {
- var biggestDiff float64
- var group, chosen, betterGroup int
-
- DD_initParVars(parVars, parVars.branchCount, minFill)
- DD_pickSeeds(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 DD_notTaken == parVars.partition[index] {
- curRect := &parVars.branchBuf[index].rect
- rect0 := DD_combineRect(curRect, &parVars.cover[0])
- rect1 := DD_combineRect(curRect, &parVars.cover[1])
- growth0 := DD_calcRectVolume(&rect0) - parVars.area[0]
- growth1 := DD_calcRectVolume(&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
- }
- }
- }
- DD_classify(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 DD_notTaken == parVars.partition[index] {
- DD_classify(index, group, parVars)
- }
- }
- }
-}
-
-// Copy branches from the buffer into two nodes according to the partition.
-func DD_loadNodes(nodeA, nodeB *DD_nodeT, parVars *DD_partitionVarsT) {
- for index := 0; index < parVars.total; index++ {
- targetNodeIndex := parVars.partition[index]
- targetNodes := []*DD_nodeT{nodeA, nodeB}
-
- // It is assured that DD_addBranch here will not cause a node split.
- DD_addBranch(&parVars.branchBuf[index], targetNodes[targetNodeIndex], nil)
- }
-}
-
-// Initialize a DD_partitionVarsT structure.
-func DD_initParVars(parVars *DD_partitionVarsT, 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] = DD_notTaken
- }
-}
-
-func DD_pickSeeds(parVars *DD_partitionVarsT) {
- var seed0, seed1 int
- var worst, waste float64
- var area [DD_maxNodes + 1]float64
-
- for index := 0; index < parVars.total; index++ {
- area[index] = DD_calcRectVolume(&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 := DD_combineRect(&parVars.branchBuf[indexA].rect, &parVars.branchBuf[indexB].rect)
- waste = DD_calcRectVolume(&oneRect) - area[indexA] - area[indexB]
- if waste > worst {
- worst = waste
- seed0 = indexA
- seed1 = indexB
- }
- }
- }
-
- DD_classify(seed0, 0, parVars)
- DD_classify(seed1, 1, parVars)
-}
-
-// Put a branch in one of the groups.
-func DD_classify(index, group int, parVars *DD_partitionVarsT) {
- parVars.partition[index] = group
-
- // Calculate combined rect
- if parVars.count[group] == 0 {
- parVars.cover[group] = parVars.branchBuf[index].rect
- } else {
- parVars.cover[group] = DD_combineRect(&parVars.branchBuf[index].rect, &parVars.cover[group])
- }
-
- // Calculate volume of combined rect
- parVars.area[group] = DD_calcRectVolume(&parVars.cover[group])
-
- parVars.count[group]++
-}
-
-// Delete a data rectangle from an index structure.
-// Pass in a pointer to a DD_rectT, the tid of the record, ptr to ptr to root node.
-// Returns 1 if record not found, 0 if success.
-// DD_removeRect provides for eliminating the root.
-func DD_removeRect(rect *DD_rectT, id interface{}, root **DD_nodeT) bool {
- var reInsertList *DD_listNodeT
-
- if !DD_removeRectRec(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)?
- DD_insertRect(&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 DD_removeRect. Descends tree recursively,
-// merges branches on the way back up.
-// Returns 1 if record not found, 0 if success.
-func DD_removeRectRec(rect *DD_rectT, id interface{}, node *DD_nodeT, listNode **DD_listNodeT) bool {
- if node.isInternalNode() { // not a leaf node
- for index := 0; index < node.count; index++ {
- if DD_overlap(*rect, node.branch[index].rect) {
- if !DD_removeRectRec(rect, id, node.branch[index].child, listNode) {
- if node.branch[index].child.count >= DD_minNodes {
- // child removed, just resize parent rect
- node.branch[index].rect = DD_nodeCover(node.branch[index].child)
- } else {
- // child removed, not enough entries in node, eliminate node
- DD_reInsert(node.branch[index].child, listNode)
- DD_disconnectBranch(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 {
- DD_disconnectBranch(node, index) // Must return after this call as count has changed
- return false
- }
- }
- return true
- }
-}
-
-// Decide whether two rectangles DD_overlap.
-func DD_overlap(rectA, rectB DD_rectT) bool {
- for index := 0; index < DD_numDims; 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 DD_reInsert(node *DD_nodeT, listNode **DD_listNodeT) {
- newListNode := &DD_listNodeT{}
- newListNode.node = node
- newListNode.next = *listNode
- *listNode = newListNode
-}
-
-// DD_search in an index tree or subtree for all data retangles that DD_overlap the argument rectangle.
-func DD_search(node *DD_nodeT, rect DD_rectT, 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 DD_overlap(rect, node.branch[index].rect) {
- var ok bool
- foundCount, ok = DD_search(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 DD_overlap(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
-}
diff --git a/vendor/github.com/tidwall/rtree/rtree.go b/vendor/github.com/tidwall/rtree/rtree.go
index 330a1f5d..bbbb1ffe 100644
--- a/vendor/github.com/tidwall/rtree/rtree.go
+++ b/vendor/github.com/tidwall/rtree/rtree.go
@@ -1,8 +1,11 @@
-// generated; DO NOT EDIT!
-
package rtree
-import "math"
+import (
+ "math"
+ "sync"
+
+ "github.com/tidwall/rtree/base"
+)
type Iterator func(item Item) bool
type Item interface {
@@ -10,372 +13,94 @@ type Item interface {
}
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
+ dims int
+ maxEntries int
+ ctx interface{}
+ trs []*base.RTree
+ used int
}
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(),
+ tr := &RTree{
+ ctx: ctx,
+ dims: 20,
+ maxEntries: 13,
}
+ tr.trs = make([]*base.RTree, 20)
+ return tr
}
func (tr *RTree) Insert(item Item) {
if item == nil {
- panic("nil item being added to RTree")
+ panic("nil item")
}
min, max := item.Rect(tr.ctx)
if len(min) != len(max) {
return // just return
panic("invalid item rectangle")
}
- switch len(min) {
- default:
+ if len(min) < 1 || len(min) > len(tr.trs) {
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)
}
+ btr := tr.trs[len(min)-1]
+ if btr == nil {
+ btr = base.New(len(min), tr.maxEntries)
+ tr.trs[len(min)-1] = btr
+ tr.used++
+ }
+ amin := make([]float64, len(min))
+ amax := make([]float64, len(max))
+ for i := 0; i < len(min); i++ {
+ amin[i], amax[i] = min[i], max[i]
+ }
+ btr.Insert(amin, amax, item)
}
func (tr *RTree) Remove(item Item) {
if item == nil {
- panic("nil item being added to RTree")
+ panic("nil item")
}
min, max := item.Rect(tr.ctx)
if len(min) != len(max) {
return // just return
panic("invalid item rectangle")
}
- switch len(min) {
- default:
+ if len(min) < 1 || len(min) > len(tr.trs) {
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)
+ }
+ btr := tr.trs[len(min)-1]
+ if btr == nil {
+ return
+ }
+ amin := make([]float64, len(min))
+ amax := make([]float64, len(max))
+ for i := 0; i < len(min); i++ {
+ amin[i], amax[i] = min[i], max[i]
+ }
+ btr.Remove(amin, amax, item)
+ if btr.IsEmpty() {
+ tr.trs[len(min)-1] = nil
+ tr.used--
}
}
func (tr *RTree) Reset() {
- 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()
+ for i := 0; i < len(tr.trs); i++ {
+ tr.trs[i] = nil
+ }
+ tr.used = 0
}
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()
+ var count int
+ for _, btr := range tr.trs {
+ if btr != nil {
+ count += btr.Count()
+ }
+ }
return count
}
+
func (tr *RTree) Search(bounds Item, iter Iterator) {
if bounds == nil {
panic("nil bounds being used for search")
@@ -385,96 +110,27 @@ func (tr *RTree) Search(bounds Item, iter Iterator) {
return // just return
panic("invalid item rectangle")
}
- switch len(min) {
- default:
+ if len(min) < 1 || len(min) > len(tr.trs) {
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
+ used := tr.used
+ for i, btr := range tr.trs {
+ if used == 0 {
+ break
+ }
+ if btr != nil {
+ if !search(btr, min, max, i+1, iter) {
+ return
+ }
+ used--
+ }
}
}
-
-func (tr *RTree) search1(min, max []float64, iter Iterator) bool {
- var amin, amax [1]float64
- for i := 0; i < 1; i++ {
+func search(btr *base.RTree, min, max []float64, dims int, iter Iterator) bool {
+ amin := make([]float64, dims)
+ amax := make([]float64, dims)
+ for i := 0; i < dims; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
@@ -483,9 +139,9 @@ func (tr *RTree) search1(min, max []float64, iter Iterator) bool {
amax[i] = math.Inf(+1)
}
}
- ended := false
- tr.tr1.Search(amin, amax, func(dataID interface{}) bool {
- if !iter(dataID.(Item)) {
+ var ended bool
+ btr.Search(amin, amax, func(item interface{}) bool {
+ if !iter(item.(Item)) {
ended = true
return false
}
@@ -494,9 +150,114 @@ func (tr *RTree) search1(min, max []float64, iter Iterator) bool {
return !ended
}
-func (tr *RTree) search2(min, max []float64, iter Iterator) bool {
- var amin, amax [2]float64
- for i := 0; i < 2; i++ {
+func (tr *RTree) KNN(bounds Item, center bool, iter func(item Item, dist float64) bool) {
+ if bounds == nil {
+ panic("nil bounds being used for search")
+ }
+ min, max := bounds.Rect(tr.ctx)
+ if len(min) != len(max) {
+ return // just return
+ panic("invalid item rectangle")
+ }
+ if len(min) < 1 || len(min) > len(tr.trs) {
+ return // just return
+ panic("invalid dimension")
+ }
+
+ if tr.used == 0 {
+ return
+ }
+ if tr.used == 1 {
+ for i, btr := range tr.trs {
+ if btr != nil {
+ knn(btr, min, max, center, i+1, func(item interface{}, dist float64) bool {
+ return iter(item.(Item), dist)
+ })
+ break
+ }
+ }
+ return
+ }
+
+ type queueT struct {
+ done bool
+ step int
+ item Item
+ dist float64
+ }
+
+ var mu sync.Mutex
+ var ended bool
+ queues := make(map[int][]queueT)
+ cond := sync.NewCond(&mu)
+ for i, btr := range tr.trs {
+ if btr != nil {
+ dims := i + 1
+ mu.Lock()
+ queues[dims] = []queueT{}
+ cond.Signal()
+ mu.Unlock()
+ go func(dims int, btr *base.RTree) {
+ knn(btr, min, max, center, dims, func(item interface{}, dist float64) bool {
+ mu.Lock()
+ if ended {
+ mu.Unlock()
+ return false
+ }
+ queues[dims] = append(queues[dims], queueT{item: item.(Item), dist: dist})
+ cond.Signal()
+ mu.Unlock()
+ return true
+ })
+ mu.Lock()
+ queues[dims] = append(queues[dims], queueT{done: true})
+ cond.Signal()
+ mu.Unlock()
+ }(dims, btr)
+ }
+ }
+ mu.Lock()
+ for {
+ ready := true
+ for i := range queues {
+ if len(queues[i]) == 0 {
+ ready = false
+ break
+ }
+ if queues[i][0].done {
+ delete(queues, i)
+ }
+ }
+ if len(queues) == 0 {
+ break
+ }
+ if ready {
+ var j int
+ var minDist float64
+ var minItem Item
+ var minQueue int
+ for i := range queues {
+ if j == 0 || queues[i][0].dist < minDist {
+ minDist = queues[i][0].dist
+ minItem = queues[i][0].item
+ minQueue = i
+ }
+ }
+ queues[minQueue] = queues[minQueue][1:]
+ if !iter(minItem, minDist) {
+ ended = true
+ break
+ }
+ continue
+ }
+ cond.Wait()
+ }
+ mu.Unlock()
+}
+func knn(btr *base.RTree, min, max []float64, center bool, dims int, iter func(item interface{}, dist float64) bool) bool {
+ amin := make([]float64, dims)
+ amax := make([]float64, dims)
+ for i := 0; i < dims; i++ {
if i < len(min) {
amin[i] = min[i]
amax[i] = max[i]
@@ -505,9 +266,9 @@ func (tr *RTree) search2(min, max []float64, iter Iterator) bool {
amax[i] = math.Inf(+1)
}
}
- ended := false
- tr.tr2.Search(amin, amax, func(dataID interface{}) bool {
- if !iter(dataID.(Item)) {
+ var ended bool
+ btr.KNN(amin, amax, center, func(item interface{}, dist float64) bool {
+ if !iter(item.(Item), dist) {
ended = true
return false
}
@@ -515,13499 +276,3 @@ func (tr *RTree) search2(min, max []float64, iter Iterator) bool {
})
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
-}
diff --git a/vendor/github.com/tidwall/rtree/rtree_test.go b/vendor/github.com/tidwall/rtree/rtree_test.go
index cd79e7a2..4574a162 100644
--- a/vendor/github.com/tidwall/rtree/rtree_test.go
+++ b/vendor/github.com/tidwall/rtree/rtree_test.go
@@ -167,3 +167,59 @@ func BenchmarkInsert(t *testing.B) {
t.StartTimer()
}
+
+func TestKNN(t *testing.T) {
+ n := 25000
+ tr := New(nil)
+ var points []*tPoint
+ rand.Seed(1)
+ for i := 0; i < n; i++ {
+ r := tRandPoint()
+ points = append(points, r)
+ tr.Insert(r)
+ }
+ if tr.Count() != n {
+ t.Fatalf("expecting %v, got %v", n, tr.Count())
+ }
+ var count int
+ tr.Search(&tRect{-100, -100, -100, -100, 100, 100, 100, 100}, func(item Item) bool {
+ count++
+ return true
+ })
+ var pdist float64
+ var i int
+ center := []float64{50, 50}
+ centerRect := &tRect{center[0], center[1], center[0], center[1]}
+ tr.KNN(centerRect, true, func(item Item, dist float64) bool {
+ dist2 := boxDistPoint(center, item)
+ if i > 0 && dist2 < pdist {
+ t.Fatal("out of order")
+ }
+ pdist = dist
+ i++
+ return true
+ })
+ if i != n {
+ t.Fatal("mismatch")
+ }
+}
+
+func boxDistPoint(point []float64, item Item) float64 {
+ var dist float64
+ min, max := item.Rect(nil)
+ for i := 0; i < len(point); i++ {
+ d := axisDist(point[i], min[i], max[i])
+ dist += d * d
+ }
+ return dist
+}
+
+func axisDist(k, min, max float64) float64 {
+ if k < min {
+ return min - k
+ }
+ if k <= max {
+ return 0
+ }
+ return k - max
+}
diff --git a/vendor/github.com/tidwall/tinyqueue/LICENSE b/vendor/github.com/tidwall/tinyqueue/LICENSE
new file mode 100644
index 00000000..2b7cd9d3
--- /dev/null
+++ b/vendor/github.com/tidwall/tinyqueue/LICENSE
@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2017, Vladimir Agafonkin
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.
diff --git a/vendor/github.com/tidwall/tinyqueue/README.md b/vendor/github.com/tidwall/tinyqueue/README.md
new file mode 100644
index 00000000..f4edc916
--- /dev/null
+++ b/vendor/github.com/tidwall/tinyqueue/README.md
@@ -0,0 +1,7 @@
+# tinyqueue
+
+
+tinyqueue is a Go package for binary heap priority queues.
+Ported from the [tinyqueue](https://github.com/mourner/tinyqueue) Javascript library.
+
+
diff --git a/vendor/github.com/tidwall/tinyqueue/tinyqueue.go b/vendor/github.com/tidwall/tinyqueue/tinyqueue.go
new file mode 100644
index 00000000..4a06258a
--- /dev/null
+++ b/vendor/github.com/tidwall/tinyqueue/tinyqueue.go
@@ -0,0 +1,86 @@
+package tinyqueue
+
+type Queue struct {
+ length int
+ data []Item
+}
+
+type Item interface {
+ Less(Item) bool
+}
+
+func New(data []Item) *Queue {
+ q := &Queue{}
+ q.data = data
+ q.length = len(data)
+ if q.length > 0 {
+ i := q.length >> 1
+ for ; i >= 0; i-- {
+ q.down(i)
+ }
+ }
+ return q
+}
+
+func (q *Queue) Push(item Item) {
+ q.data = append(q.data, item)
+ q.length++
+ q.up(q.length - 1)
+}
+func (q *Queue) Pop() Item {
+ if q.length == 0 {
+ return nil
+ }
+ top := q.data[0]
+ q.length--
+ if q.length > 0 {
+ q.data[0] = q.data[q.length]
+ q.down(0)
+ }
+ q.data = q.data[:len(q.data)-1]
+ return top
+}
+func (q *Queue) Peek() Item {
+ if q.length == 0 {
+ return nil
+ }
+ return q.data[0]
+}
+func (q *Queue) Len() int {
+ return q.length
+}
+func (q *Queue) down(pos int) {
+ data := q.data
+ halfLength := q.length >> 1
+ item := data[pos]
+ for pos < halfLength {
+ left := (pos << 1) + 1
+ right := left + 1
+ best := data[left]
+ if right < q.length && data[right].Less(best) {
+ left = right
+ best = data[right]
+ }
+ if !best.Less(item) {
+ break
+ }
+ data[pos] = best
+ pos = left
+ }
+ data[pos] = item
+}
+
+func (q *Queue) up(pos int) {
+ data := q.data
+ item := data[pos]
+ for pos > 0 {
+ parent := (pos - 1) >> 1
+ current := data[parent]
+ if !item.Less(current) {
+ break
+ }
+ data[pos] = current
+ pos = parent
+ }
+ data[pos] = item
+}
diff --git a/vendor/github.com/tidwall/tinyqueue/tinyqueue_test.go b/vendor/github.com/tidwall/tinyqueue/tinyqueue_test.go
new file mode 100644
index 00000000..d3d74187
--- /dev/null
+++ b/vendor/github.com/tidwall/tinyqueue/tinyqueue_test.go
@@ -0,0 +1,65 @@
+package tinyqueue
+
+import (
+ "math/rand"
+ "sort"
+ "testing"
+ "time"
+
+ "github.com/stretchr/testify/assert"
+)
+
+type floatValue float64
+
+func (a floatValue) Less(b Item) bool {
+ return a < b.(floatValue)
+}
+
+var data, sorted = func() ([]Item, []Item) {
+ rand.Seed(time.Now().UnixNano())
+ var data []Item
+ for i := 0; i < 100; i++ {
+ data = append(data, floatValue(rand.Float64()*100))
+ }
+ sorted := make([]Item, len(data))
+ copy(sorted, data)
+ sort.Slice(sorted, func(i, j int) bool {
+ return sorted[i].Less(sorted[j])
+ })
+ return data, sorted
+}()
+
+func TestMaintainsPriorityQueue(t *testing.T) {
+ q := New(nil)
+ for i := 0; i < len(data); i++ {
+ q.Push(data[i])
+ }
+ assert.Equal(t, q.Peek(), sorted[0])
+ var result []Item
+ for q.length > 0 {
+ result = append(result, q.Pop())
+ }
+ assert.Equal(t, result, sorted)
+}
+
+func TestAcceptsDataInConstructor(t *testing.T) {
+ q := New(data)
+ var result []Item
+ for q.length > 0 {
+ result = append(result, q.Pop())
+ }
+ assert.Equal(t, result, sorted)
+}
+func TestHandlesEdgeCasesWithFewElements(t *testing.T) {
+ q := New(nil)
+ q.Push(floatValue(2))
+ q.Push(floatValue(1))
+ q.Pop()
+ q.Pop()
+ q.Pop()
+ q.Push(floatValue(2))
+ q.Push(floatValue(1))
+ assert.Equal(t, float64(q.Pop().(floatValue)), 1.0)
+ assert.Equal(t, float64(q.Pop().(floatValue)), 2.0)
+ assert.Equal(t, q.Pop(), nil)
+}