com.wallstop-studios.unity-helpers 1.0.0-rc4

package/Runtime/Core/DataStructure/KDTree.cs

@@ -0,0 +1,186 @@
+namespace UnityHelpers.Core.DataStructure
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using System.Linq;
+    using Extension;
+    using UnityEngine;
+
+    [Serializable]
+    public sealed class KDTree<T> : ISpatialTree<T>
+    {
+        public delegate float Axis<in V>(V element);
+
+        [Serializable]
+        private sealed class KDTreeNode<V>
+        {
+            public readonly Bounds boundary;
+            public readonly KDTreeNode<V> left;
+            public readonly KDTreeNode<V> right;
+            public readonly V[] elements;
+            public readonly bool isTerminal;
+
+            public KDTreeNode(List<V> elements, Func<V, Vector2> elementTransformer, int bucketSize, bool isXAxis, bool balanced)
+            {
+                boundary = elements.Select(elementTransformer).GetBounds() ?? new Bounds();
+                this.elements = elements.ToArray();
+                isTerminal = elements.Count <= bucketSize;
+                if (isTerminal)
+                {
+                    return;
+                }
+
+                if (balanced)
+                {
+                    Axis<V> axisFunction = isXAxis
+                        ? element => elementTransformer(element).x
+                        : element => elementTransformer(element).y;
+
+                    int Comparison(V lhs, V rhs)
+                    {
+                        return axisFunction(lhs).CompareTo(axisFunction(rhs));
+                    }
+                    elements.Sort(Comparison);
+
+                    int cutoff = elements.Count / 2;
+                    left = new KDTreeNode<V>(elements.Take(cutoff).ToList(), elementTransformer, bucketSize, !isXAxis, true);
+                    right = new KDTreeNode<V>(elements.Skip(cutoff).ToList(), elementTransformer, bucketSize, !isXAxis, true);
+                }
+                else
+                {
+                    Vector2 cutoff = boundary.center;
+                    if (isXAxis)
+                    {
+                        left = new KDTreeNode<V>(elements.Where(element => elementTransformer(element).x <= cutoff.x).ToList(), elementTransformer, bucketSize, false, false);
+                        right = new KDTreeNode<V>(elements.Where(element => cutoff.x < elementTransformer(element).x).ToList(), elementTransformer, bucketSize, false, false);
+                    }
+                    else
+                    {
+                        left = new KDTreeNode<V>(elements.Where(element => elementTransformer(element).y <= cutoff.y).ToList(), elementTransformer, bucketSize, true, false);
+                        right = new KDTreeNode<V>(elements.Where(element => cutoff.y < elementTransformer(element).y).ToList(), elementTransformer, bucketSize, true, false);
+                    }
+                }
+            }
+        }
+
+        public const int DefaultBucketSize = 12;
+
+        public readonly ImmutableArray<T> elements;
+        public Bounds Boundary => _bounds;
+        public Func<T, Vector2> ElementTransformer => _elementTransformer;
+
+        private readonly Bounds _bounds;
+        private readonly Func<T, Vector2> _elementTransformer;
+        private readonly KDTreeNode<T> _head;
+
+        public KDTree(IEnumerable<T> points, Func<T, Vector2> elementTransformer, int bucketSize = DefaultBucketSize, bool balanced = true)
+        {
+            _elementTransformer = elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
+            elements = points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
+            _bounds = elements.Select(elementTransformer).GetBounds() ?? new Bounds();
+            _head = new KDTreeNode<T>(elements.ToList(), elementTransformer, bucketSize: bucketSize, isXAxis:true, balanced: balanced);
+        }
+
+        public IEnumerable<T> GetElementsInBounds(Bounds bounds)
+        {
+            if (!bounds.FastIntersects2D(_bounds))
+            {
+                yield break;
+            }
+
+            Stack<KDTreeNode<T>> nodesToVisit = new();
+            nodesToVisit.Push(_head);
+
+            while (nodesToVisit.TryPop(out KDTreeNode<T> currentNode))
+            {
+                if (currentNode.isTerminal)
+                {
+                    foreach (T element in currentNode.elements)
+                    {
+                        if (bounds.FastContains2D(_elementTransformer(element)))
+                        {
+                            yield return element;
+                        }
+                    }
+
+                    continue;
+                }
+
+                if (bounds.Overlaps2D(currentNode.boundary))
+                {
+                    foreach (T element in currentNode.elements)
+                    {
+                        yield return element;
+                    }
+
+                    continue;
+                }
+
+                KDTreeNode<T> leftNode = currentNode.left;
+                if (0 < leftNode.elements.Length && bounds.FastIntersects2D(leftNode.boundary))
+                {
+                    nodesToVisit.Push(leftNode);
+                }
+
+                KDTreeNode<T> rightNode = currentNode.right;
+                if (0 < rightNode.elements.Length && bounds.FastIntersects2D(rightNode.boundary))
+                {
+                    nodesToVisit.Push(rightNode);
+                }
+            }
+        }
+
+        // Heavily adapted http://homepage.divms.uiowa.edu/%7Ekvaradar/sp2012/daa/ann.pdf
+        public void GetApproximateNearestNeighbors(Vector2 position, int count, List<T> nearestNeighbors)
+        {
+            nearestNeighbors.Clear();
+
+            KDTreeNode<T> current = _head;
+            Stack<KDTreeNode<T>> stack = new();
+            stack.Push(_head);
+            HashSet<T> nearestNeighborsSet = new(count);
+
+            while (!current.isTerminal)
+            {
+                KDTreeNode<T> left = current.left;
+                KDTreeNode<T> right = current.right;
+                if (((Vector2)left.boundary.center - position).sqrMagnitude <
+                    ((Vector2)right.boundary.center - position).sqrMagnitude)
+                {
+                    stack.Push(left);
+                    current = left;
+                    if (left.elements.Length <= count)
+                    {
+                        break;
+                    }
+                }
+                else
+                {
+                    stack.Push(right);
+                    current = right;
+                    if (right.elements.Length <= count)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            while (nearestNeighborsSet.Count < count && stack.TryPop(out KDTreeNode<T> selected))
+            {
+                foreach (T element in selected.elements)
+                {
+                    _ = nearestNeighborsSet.Add(element);
+                }
+            }
+
+            nearestNeighbors.AddRange(nearestNeighborsSet);
+            if (count < nearestNeighbors.Count)
+            {
+                int NearestComparison(T lhs, T rhs) => (_elementTransformer(lhs) - position).sqrMagnitude.CompareTo((_elementTransformer(rhs) - position).sqrMagnitude);
+                nearestNeighbors.Sort(NearestComparison);
+                nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
+            }
+        }
+    }
+}

package/Runtime/Core/DataStructure/KDTree.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2ebf309d2de45e944946aa5cccd9754a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/DataStructure/QuadTree.cs

@@ -0,0 +1,184 @@
+namespace UnityHelpers.Core.DataStructure
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using System.Linq;
+    using Extension;
+    using UnityEngine;
+
+    [Serializable]
+    public sealed class QuadTree<T> : ISpatialTree<T>
+    {
+        private const int NumChildren = 4;
+
+        [Serializable]
+        private sealed class QuadTreeNode<V>
+        {
+            private static readonly List<V> Buffer = new();
+
+            public readonly Bounds boundary;
+            public readonly QuadTreeNode<V>[] children;
+            public readonly V[] elements;
+            public readonly bool isTerminal;
+
+            public QuadTreeNode(V[] elements, Func<V, Vector2> elementTransformer, Bounds boundary,
+                int bucketSize)
+            {
+                this.boundary = boundary;
+                this.elements = elements;
+                isTerminal = elements.Length <= bucketSize;
+                if (isTerminal)
+                {
+                    children = Array.Empty<QuadTreeNode<V>>();
+                    return;
+                }
+                children = new QuadTreeNode<V>[NumChildren];
+                
+                Vector3 quadrantSize = boundary.size / 2f;
+                Vector2 halfQuadrantSize = quadrantSize / 2f;
+
+                Bounds[] quadrants =
+                {
+                    new Bounds(new Vector3(boundary.center.x - halfQuadrantSize.x, boundary.center.y + halfQuadrantSize.y, boundary.center.z), quadrantSize),
+                    new Bounds(new Vector3(boundary.center.x + halfQuadrantSize.x, boundary.center.y + halfQuadrantSize.y, boundary.center.z), quadrantSize),
+                    new Bounds(new Vector3(boundary.center.x + halfQuadrantSize.x, boundary.center.y - halfQuadrantSize.y, boundary.center.z), quadrantSize),
+                    new Bounds(new Vector3(boundary.center.x - halfQuadrantSize.x, boundary.center.y - halfQuadrantSize.y, boundary.center.z), quadrantSize),
+                };
+
+                for (int i = 0; i < quadrants.Length; ++i)
+                {
+                    Bounds quadrant = quadrants[i];
+                    Buffer.Clear();
+                    foreach (V element in elements)
+                    {
+                        if (quadrant.FastContains2D(elementTransformer(element)))
+                        {
+                            Buffer.Add(element);
+                        }
+                    }
+
+                    children[i] = new QuadTreeNode<V>(Buffer.ToArray(), elementTransformer, quadrant, bucketSize);
+                }
+            }
+        }
+
+        public const int DefaultBucketSize = 12;
+
+        public readonly ImmutableArray<T> elements;
+        public Bounds Boundary => _bounds;
+        public Func<T, Vector2> ElementTransformer => _elementTransformer;
+
+        private readonly Bounds _bounds;
+        private readonly Func<T, Vector2> _elementTransformer;
+        private readonly QuadTreeNode<T> _head;
+
+        public QuadTree(IEnumerable<T> points, Func<T, Vector2> elementTransformer, Bounds? boundary = null,
+            int bucketSize = DefaultBucketSize)
+        {
+            _elementTransformer = elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
+            elements = points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
+            _bounds = boundary ?? elements.Select(elementTransformer).GetBounds() ?? new Bounds();
+            _head = new QuadTreeNode<T>(elements.ToArray(), elementTransformer, _bounds, bucketSize);
+        }
+
+        public IEnumerable<T> GetElementsInBounds(Bounds bounds)
+        {
+            if (!bounds.FastIntersects2D(_bounds))
+            {
+                yield break;
+            }
+
+            Stack<QuadTreeNode<T>> nodesToVisit = new();
+            nodesToVisit.Push(_head);
+
+            while (nodesToVisit.TryPop(out QuadTreeNode<T> currentNode))
+            {
+                if (currentNode.isTerminal)
+                {
+                    foreach (T element in currentNode.elements)
+                    {
+                        if (bounds.FastContains2D(_elementTransformer(element)))
+                        {
+                            yield return element;
+                        }
+                    }
+
+                    continue;
+                }
+
+                if (bounds.Overlaps2D(currentNode.boundary))
+                {
+                    foreach (T element in currentNode.elements)
+                    {
+                        yield return element;
+                    }
+
+                    continue;
+                }
+
+                foreach (QuadTreeNode<T> child in currentNode.children)
+                {
+                    if (child.elements.Length <= 0)
+                    {
+                        continue;
+                    }
+
+                    if (!bounds.FastIntersects2D(child.boundary))
+                    {
+                        continue;
+                    }
+
+                    nodesToVisit.Push(child);
+                }
+            }
+        }
+
+        // Heavily adapted http://homepage.divms.uiowa.edu/%7Ekvaradar/sp2012/daa/ann.pdf
+        public void GetApproximateNearestNeighbors(Vector2 position, int count, List<T> nearestNeighbors)
+        {
+            nearestNeighbors.Clear();
+
+            QuadTreeNode<T> current = _head;
+            Stack<QuadTreeNode<T>> stack = new();
+            stack.Push(_head);
+            List<QuadTreeNode<T>> childrenCopy = new(NumChildren);
+            HashSet<T> nearestNeighborsSet = new(count);
+
+            int Comparison(QuadTreeNode<T> lhs, QuadTreeNode<T> rhs) => ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(((Vector2)rhs.boundary.center - position).sqrMagnitude);
+            
+            while (!current.isTerminal)
+            {
+                childrenCopy.Clear();
+                childrenCopy.AddRange(current.children);
+                childrenCopy.Sort(Comparison);
+                for (int i = childrenCopy.Count - 1; 0 <= i; --i)
+                {
+                    stack.Push(childrenCopy[i]);
+                }
+
+                current = childrenCopy[0];
+                if (current.elements.Length <= count)
+                {
+                    break;
+                }
+            }
+
+            while (nearestNeighborsSet.Count < count && stack.TryPop(out QuadTreeNode<T> selected))
+            {
+                foreach (T element in selected.elements)
+                {
+                    _ = nearestNeighborsSet.Add(element);
+                }
+            }
+
+            nearestNeighbors.AddRange(nearestNeighborsSet);
+            if (count < nearestNeighbors.Count)
+            {
+                int NearestComparison(T lhs, T rhs) => (_elementTransformer(lhs) - position).sqrMagnitude.CompareTo((_elementTransformer(rhs) - position).sqrMagnitude);
+                nearestNeighbors.Sort(NearestComparison);
+                nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
+            }
+        }
+    }
+}

package/Runtime/Core/DataStructure/QuadTree.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bd888839de97c284e9a7153ab84c74df
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/DataStructure/RTree.cs

@@ -0,0 +1,247 @@
+namespace UnityHelpers.Core.DataStructure
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Immutable;
+    using System.Linq;
+    using Extension;
+    using UnityEngine;
+
+    [Serializable]
+    public sealed class RTree<T>
+    {
+        [Serializable]
+        private sealed class RTreeNode<V>
+        {
+            public readonly Bounds boundary;
+            public readonly RTreeNode<V>[] children;
+            public readonly V[] elements;
+            public readonly bool isTerminal;
+
+            public RTreeNode(List<V> elements, Func<V, Bounds> elementTransformer, int bucketSize, int branchFactor)
+            {
+                float minX = float.MaxValue;
+                float minY = float.MaxValue;
+                float maxX = float.MinValue;
+                float maxY = float.MinValue;
+                foreach (V element in elements)
+                {
+                    Bounds rectangle = elementTransformer(element);
+                    Vector3 min = rectangle.min;
+                    Vector3 max = rectangle.max;
+                    minX = Math.Min(minX, min.x);
+                    maxX = Math.Max(maxX, max.x);
+                    minY = Math.Min(minY, min.y);
+                    maxY = Math.Max(maxY, max.y);
+                }
+
+                boundary = elements.Count <= 0 ? new Bounds() : new Bounds(new Vector3(minX + (maxX - minX) / 2, minY + (maxY - minY) / 2), new Vector3(maxX - minX, maxY - minY));
+                this.elements = elements.ToArray();
+                isTerminal = elements.Count <= bucketSize;
+                if (isTerminal)
+                {
+                    children = Array.Empty<RTreeNode<V>>();
+                    return;
+                }
+
+                /*
+                    http://www.dtic.mil/get-tr-doc/pdf?AD=ADA324493
+                    var targetSize = rectangles.Count / (double) branchFactor;
+                    P = branchFactor;
+                    S = Math.sqrt(P);
+                    N = targetSize;
+
+                    Ugh.
+                */
+                double targetSize = elements.Count / (double)branchFactor;
+                int intTargetSize = (int)Math.Ceiling(targetSize);
+
+                List<RTreeNode<V>> tempChildren = new(intTargetSize);
+
+                double slicesPerAxis = Math.Sqrt(branchFactor);
+                int rectanglesPerPagePerAxis = (int)(slicesPerAxis * targetSize);
+
+                int XAxis(V lhs, V rhs)
+                {
+                    return elementTransformer(lhs).center.x.CompareTo(elementTransformer(rhs).center.x);
+                }
+
+                int YAxis(V lhs, V rhs)
+                {
+                    return elementTransformer(lhs).center.y.CompareTo(elementTransformer(rhs).center.y);
+                }
+
+                elements.Sort(XAxis);
+                foreach (List<V> xSlice in elements.Partition(rectanglesPerPagePerAxis).Select(enumerable => enumerable as List<V> ?? enumerable.ToList()))
+                {
+                    xSlice.Sort(YAxis);
+                    foreach (List<V> ySlice in xSlice.Partition(intTargetSize).Select(enumerable => enumerable as List<V> ?? enumerable.ToList()))
+                    {
+                        RTreeNode<V> node = new(ySlice, elementTransformer, bucketSize, branchFactor);
+                        tempChildren.Add(node);
+                    }
+                }
+
+                children = tempChildren.ToArray();
+            }
+        }
+
+        public const int DefaultBucketSize = 10;
+        public const int DefaultBranchFactor = 4;
+
+        public readonly ImmutableArray<T> elements;
+        public Bounds Boundary => _bounds;
+
+        private readonly Bounds _bounds;
+        private readonly Func<T, Bounds> _elementTransformer;
+        private readonly RTreeNode<T> _head;
+
+        public RTree(
+            IEnumerable<T> points, Func<T, Bounds> elementTransformer, int bucketSize = DefaultBucketSize,
+            int branchFactor = DefaultBranchFactor)
+        {
+            _elementTransformer = elementTransformer ?? throw new ArgumentNullException(nameof(elementTransformer));
+            elements = points?.ToImmutableArray() ?? throw new ArgumentNullException(nameof(points));
+            _bounds = elements.Select(elementTransformer).GetBounds() ?? new Bounds();
+            _head = new RTreeNode<T>(elements.ToList(), elementTransformer, bucketSize, branchFactor);
+        }
+
+        public IEnumerable<T> GetElementsInRange(Vector2 position, float range, float minimumRange = 0f)
+        {
+            Circle area = new(position, range);
+            if (0 < minimumRange)
+            {
+                Circle minimumArea = new(position, minimumRange);
+                return GetElementsInBounds(
+                        new Bounds(
+                            new Vector3(position.x, position.y, 0f),
+                            new Vector3(range * 2f, range * 2f, 1f)))
+                    .Where(
+                        element =>
+                        {
+                            Bounds elementBoundary = _elementTransformer(element);
+                            if (!area.Intersects(elementBoundary))
+                            {
+                                return false;
+                            }
+
+                            return !minimumArea.Intersects(elementBoundary);
+                        });
+            }
+            return GetElementsInBounds(
+                    new Bounds(
+                        new Vector3(position.x, position.y, 0f),
+                        new Vector3(range * 2f, range * 2f, 1f)))
+                .Where(
+                    element =>
+                    {
+                        Bounds elementBoundary = _elementTransformer(element);
+                        if (!area.Intersects(elementBoundary))
+                        {
+                            return false;
+                        }
+
+                        return true;
+                    });
+        }
+
+        public IEnumerable<T> GetElementsInBounds(Bounds bounds)
+        {
+            if (!bounds.FastIntersects2D(_bounds))
+            {
+                yield break;
+            }
+
+            Stack<RTreeNode<T>> nodesToVisit = new();
+            nodesToVisit.Push(_head);
+
+            while (nodesToVisit.TryPop(out RTreeNode<T> currentNode))
+            {
+                if (currentNode.isTerminal)
+                {
+                    foreach (T element in currentNode.elements)
+                    {
+                        if (bounds.FastIntersects2D(_elementTransformer(element)))
+                        {
+                            yield return element;
+                        }
+                    }
+
+                    continue;
+                }
+
+                if (bounds.Overlaps2D(currentNode.boundary))
+                {
+                    foreach (T element in currentNode.elements)
+                    {
+                        yield return element;
+                    }
+
+                    continue;
+                }
+
+                foreach (RTreeNode<T> child in currentNode.children)
+                {
+                    if (child.elements.Length <= 0)
+                    {
+                        continue;
+                    }
+
+                    if (!bounds.FastIntersects2D(child.boundary))
+                    {
+                        continue;
+                    }
+
+                    nodesToVisit.Push(child);
+                }
+            }
+        }
+
+        // Heavily adapted http://homepage.divms.uiowa.edu/%7Ekvaradar/sp2012/daa/ann.pdf
+        public void GetApproximateNearestNeighbors(Vector2 position, int count, List<T> nearestNeighbors)
+        {
+            nearestNeighbors.Clear();
+
+            RTreeNode<T> current = _head;
+            Stack<RTreeNode<T>> stack = new();
+            stack.Push(_head);
+            List<RTreeNode<T>> childrenCopy = new();
+            HashSet<T> nearestNeighborsSet = new(count);
+
+            int Comparison(RTreeNode<T> lhs, RTreeNode<T> rhs) => ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(((Vector2)rhs.boundary.center - position).sqrMagnitude);
+
+            while (!current.isTerminal)
+            {
+                childrenCopy.Clear();
+                childrenCopy.AddRange(current.children);
+                childrenCopy.Sort(Comparison);
+                for (int i = childrenCopy.Count - 1; 0 <= i; --i)
+                {
+                    stack.Push(childrenCopy[i]);
+                }
+
+                current = childrenCopy[0];
+                if (current.elements.Length <= count)
+                {
+                    break;
+                }
+            }
+
+            while (nearestNeighborsSet.Count < count && stack.TryPop(out RTreeNode<T> selected))
+            {
+                foreach (T element in selected.elements)
+                {
+                    _ = nearestNeighborsSet.Add(element);
+                }
+            }
+
+            nearestNeighbors.AddRange(nearestNeighborsSet);
+            if (count < nearestNeighbors.Count)
+            {
+                int NearestComparison(T lhs, T rhs) => ((Vector2)_elementTransformer(lhs).center - position).sqrMagnitude.CompareTo(((Vector2)_elementTransformer(rhs).center - position).sqrMagnitude);
+                nearestNeighbors.Sort(NearestComparison);
+                nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
+            }
+        }
+    }
+}

package/Runtime/Core/DataStructure/RTree.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6c6e3230b807b894cbccf3dc0281058b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: