예제 #1
0
        public Node2List(Node2List L)
        {
            m_nodes          = new List <Node2>();
            m_sort           = NodeListSort.none;
            m_nodes.Capacity = L.m_nodes.Count;
            m_sort           = L.m_sort;
            int num = L.m_nodes.Count - 1;

            for (int i = 0; i <= num; i++)
            {
                if (L.m_nodes[i] == null)
                {
                    m_nodes.Add(null);
                }
                else
                {
                    m_nodes.Add(new Node2(L.m_nodes[i]));
                }
            }
        }
예제 #2
0
 public Node2Tree(Node2List owner)
 {
     this.m_list = owner;
 }
예제 #3
0
        /// <summary>Builds a subtree from a Node list.</summary>
        /// <param name="nodes">All the nodes that are supposed to be included in this tree.</param>
        /// <param name="index_subset">A subset of nodes on which to perform the subdivision. Pass a null-pointer to use ALL nodes.
        /// If the list is not null, used indices will be extracted from the list, in order to reduce the number of pointless inclusion tests.</param>
        /// <param name="group_limit">The number of allowed Nodes per Leaf. If a Leaf contains more than N nodes, it will subdivide.</param>
        public void SubDivide(Node2List nodes, List <int> index_subset, int group_limit)
        {
            this.m_nodes = new List <int>(nodes.Count);
            this.m_A     = (Node2Leaf)null;
            this.m_B     = (Node2Leaf)null;
            this.m_C     = (Node2Leaf)null;
            this.m_D     = (Node2Leaf)null;
            if (index_subset == null)
            {
                int num = nodes.Count - 1;
                for (int index = 0; index <= num; ++index)
                {
                    this.m_nodes.Add(index);
                }
            }
            else
            {
                int num1   = index_subset.Count - 1;
                int index1 = 0;
                int num2   = num1;
                for (int index2 = 0; index2 <= num2; ++index2)
                {
                    int   index3 = index_subset[index2];
                    Node2 node   = nodes[index3];
                    if (node != null)
                    {
                        if (this.Contains(node.x, node.y))
                        {
                            this.m_nodes.Add(index3);
                        }
                        else
                        {
                            index_subset[index1] = index3;
                            ++index1;
                        }
                    }
                }
                if (index1 < index_subset.Count)
                {
                    if (index1 == 0)
                    {
                        index_subset.Clear();
                    }
                    else
                    {
                        index_subset.RemoveRange(index1, index_subset.Count - index1);
                    }
                }
            }
            double num3 = (this.m_x1 - this.m_x0) * (this.m_x1 - this.m_x0) + (this.m_y1 - this.m_y0) * (this.m_y1 - this.m_y0);

            if (this.m_nodes.Count > group_limit && num3 > 1E-08)
            {
                this.CreateSubLeafs();
                this.m_A.SubDivide(nodes, this.m_nodes, group_limit);
                this.m_B.SubDivide(nodes, this.m_nodes, group_limit);
                this.m_C.SubDivide(nodes, this.m_nodes, group_limit);
                this.m_D.SubDivide(nodes, this.m_nodes, group_limit);
                this.TrimSubLeafs();
                this.m_nodes = (List <int>)null;
            }
            else if (this.m_nodes.Count == 0)
            {
                this.m_nodes = (List <int>)null;
            }
            else
            {
                this.m_nodes.TrimExcess();
            }
        }
예제 #4
0
        /// <summary>Recursive method that solves a proximity search.</summary>
        /// <param name="nodes">Node set to search</param>
        /// <param name="prox">Proximity object to search with</param>
        public void SolveProximity(Node2List nodes, Node2Proximity prox)
        {
            double d0 = default(double);
            double d1 = default(double);

            prox.DistanceRange(ref d0, ref d1);
            double num1 = this.MinimumDistanceSquared(prox.Start.x, prox.Start.y);

            if (num1 >= d1 || num1 > prox.MaxSearchRadiusSquared || this.MaximumDistanceSquared(prox.Start.x, prox.Start.y) <= prox.MinSearchRadiusSquared)
            {
                return;
            }
            if (this.m_nodes == null)
            {
                Node2Leaf[] node2LeafArray;
                if (prox.Start.x < this.x_mid)
                {
                    if (prox.Start.y < this.y_mid)
                    {
                        node2LeafArray = new Node2Leaf[4]
                        {
                            this.m_A,
                            this.m_B,
                            this.m_D,
                            this.m_C
                        }
                    }
                    ;
                    else
                    {
                        node2LeafArray = new Node2Leaf[4]
                        {
                            this.m_D,
                            this.m_A,
                            this.m_C,
                            this.m_B
                        }
                    };
                }
                else if (prox.Start.y < this.y_mid)
                {
                    node2LeafArray = new Node2Leaf[4]
                    {
                        this.m_B,
                        this.m_A,
                        this.m_C,
                        this.m_D
                    }
                }
                ;
                else
                {
                    node2LeafArray = new Node2Leaf[4]
                    {
                        this.m_C,
                        this.m_D,
                        this.m_B,
                        this.m_A
                    }
                };
                int num2 = node2LeafArray.Length - 1;
                for (int index = 0; index <= num2; ++index)
                {
                    if (node2LeafArray[index] != null)
                    {
                        node2LeafArray[index].SolveProximity(nodes, prox);
                    }
                }
            }
            else
            {
                if (this.m_nodes == null)
                {
                    return;
                }
                int num2 = this.m_nodes.Count - 1;
                for (int index = 0; index <= num2; ++index)
                {
                    prox.RegisterNode(nodes[this.m_nodes[index]], this.m_nodes[index]);
                }
            }
        }