Ejemplo n.º 1
0
 private void repaint(KDNode n) 
 {
     n.repaint();
     if (n.getLeft() != null) 
     {
         repaint(n.getLeft());
     }
     if (n.getRight() != null)
     {
         repaint(n.getRight());
     }
 }
Ejemplo n.º 2
0
 public void notHighlight(KDNode n)
 {
     if (n == null) return;
     n.highlight = false;
     n.highlightRed = false;
     n.highligthBox = false;
     n.highligthIn = false;
     notHighlight(n.getLeft());
     notHighlight(n.getRight());
 }
Ejemplo n.º 3
0
        // zisti, ci bunka vrchola n susedi s bunkou target.
        // ak ano, hladaju sa susedia deti n, ak nie, 
        // potom ani deti s nim nemozu susedit
        public void findNeighbors(KDNode target, KDNode n) 
        {
            if (n.isLeaf)
            {
                if (!isIn(target, n) && isNeighbor(target, n))
                {
                    neighbors.Add(n);
                }
                return;
            }

            // je sused alebo je vo vnutri neho.
            if (isNeighbor(target, n) || (isIn(target, n)))
            {
                findNeighbors(target,n.getLeft());
                findNeighbors(target, n.getRight());
            }

        }
Ejemplo n.º 4
0
        // zistuje, ci je vrchol n vo vnutri obdlznika from, to 
        public void findInside(KDNode n, Point from, Point to) 
        {
            if (n.isLeaf)
            {
                // je vrchol vnutri obdlznika?
                if (pointInsideRect(n.getPoint(), from, to))
                {
                    inside.Add(n);
                }
                return;
            }

            // ak ma obdlznik s bunkou nejaky prienik vnori sa
            if (intersects(n, from, to)) 
            {
                findInside(n.getLeft(), from, to);
                findInside(n.getRight(), from, to);
            } else {
                return;
            }
        }
Ejemplo n.º 5
0
        // najde numNearest najblizsich vrcholov ku target
        // na konci budu v usporiadanom zozname nearestK
        public void findNearest(KDNode subTree, KDNode target) 
        {
            // ak je to list, zistime, ci je blizsie ako doposial najdene, ak ich je dost
            if (subTree.isLeaf) {
                subTree.dist = distance(target.getPoint(), subTree.getPoint());
                if (nearestK.Count < numNearest)
                { 
                    nearestK.Add(subTree);
                } else {
                    if (nearestK.Last().dist > subTree.dist) 
                    {
                        nearestK.Remove(nearestK.Last());
                        nearestK.Add(subTree);
                    }
                }
                
                return;
            }


            int dim = subTree.getDim();

            // ak je target v lavom podstrome, nearer je lavy a further je pravy, inak opacne
            KDNode nearer;
            KDNode further;
            if (dim == 0)
            {
                if (subTree.getSplit() >= target.getPoint().X)
                {
                    nearer = subTree.getLeft();
                    further = subTree.getRight();
                } else {
                    further = subTree.getLeft();
                    nearer = subTree.getRight();
                }
            } else {
                if (subTree.getSplit() >= target.getPoint().Y)
                {
                    nearer = subTree.getLeft();
                    further = subTree.getRight();
                }else {
                    further = subTree.getLeft();
                    nearer = subTree.getRight();
                }
            }
            // najprv prehladavame blizsi podstrom 
            // (prvy prehladany blok bude ten, v kt. je target)
            // teda si ohranicime v priemere celkom slusne najblizsie vrcholy
            findNearest(nearer, target); 

            // zrata najblizsi bod od target na bunke further
            // ak je dalej ako doposial najdeny k-ty nejmensi, tak vo further
            // nemoze byt blizsi bod => nevnara sa
            Point nearestF = nearestTo(further, target);
            double dist = distance(nearestF, target.getPoint());

            if ((nearestK.Last().dist > dist) || (nearestK.Count < numNearest))
            {
                findNearest(further, target);
            }
        }
Ejemplo n.º 6
0
        private KDNode findIn(KDNode click, KDNode n, int dim)
        {
            if (n.isLeaf)
            {
                return n;
            }

            if (dim == 0)
            {
                if (n.getSplit() >= click.getPoint().X)
                {
                    return findIn(click, n.getLeft(), 1 - dim);
                } else {
                    return findIn(click, n.getRight(), 1 - dim);
                }
            } else {
                if (n.getSplit() >= click.getPoint().Y)
                {
                    return findIn(click, n.getLeft(), 1 - dim);
                } else {
                    return findIn(click, n.getRight(), 1 - dim);
                }
            }
        }
Ejemplo n.º 7
0
        // pre kazdy vrchol v podstrome n updatne jeho bunku
        public void updateFromTo(KDNode n) 
        {
            if (n == null)
            {
                return;
            }
            n.setFromTo();
            updateFromTo(n.getRight());
            updateFromTo(n.getLeft());

        }
Ejemplo n.º 8
0
        // pre kazdeho predchodcu n updatne pocet listov,
        // ktore su nad nim
        public void updateNumLeafsUp(KDNode n) 
        {
            n.setNumLeafs(n.getLeft().getNumLeafs() + n.getRight().getNumLeafs());
            Console.WriteLine("update to root " + n.getSplit() + " numLeafs = " + n.getNumLeafs());
            Console.WriteLine("update to root right " + n.getRight().getNumLeafs() + " left " + n.getLeft().getNumLeafs());
            if (n.Equals(root)) 
            {
                return;
            }

            updateNumLeafsUp(n.getParent());

        }
Ejemplo n.º 9
0
 // pre kazdy vrchol podstromu n updatne pocet listov,
 // ktore su pod nim
 public int updateNumLeafsDown(KDNode n)
 {
     if (n.isLeaf) {
         n.setNumLeafs(1);
         Console.WriteLine("update " + n.getPoint() + " numLeafs = 1");
         return 1;
     }
     int r = updateNumLeafsDown(n.getRight());
     int l = updateNumLeafsDown(n.getLeft());
     n.setNumLeafs(r + l);
     Console.WriteLine("update " + n.getSplit() + " numLeafs = " + n.getNumLeafs());
     return r + l;
 }
Ejemplo n.º 10
0
        // prebudovanie stromu
        // na vstupe je zoznam vsetkych buducich listov podstromu.
        public KDNode rebuilt(List<KDNode> l1, int dim1, KDNode newParent, Boolean isLeft) 
        {
            List<KDNode> l = l1;
            
            // ak je v zozname iba 1 vrchol, vrati sa ako list
            if (l.Count == 1)
            {   
                return l.ElementAt(0);
            }

            int newSplit;
            int dimension;
            if (newParent == null)
            {
                // root ma nastavenu deliacu suradnicu na x.
                dimension = 0;
            } else {
                dimension = 1 - newParent.getDim();
            }
            // vrati split noveho vrchola
            newSplit = findSplit(l, dimension);
            //Console.WriteLine(newSplit);

            List<KDNode> newLeft = new List<KDNode>();
            List<KDNode> newRight = new List<KDNode>();
            Boolean equal = true;
            //rozdelenie na 2 podstromy podla split a dim
            if (dimension == 0) //split cez x-ovu os
            {
                foreach (KDNode n in l) 
                {
                    // zoznam listov v lavom a pravom podstrome podla split
                    if (n.getPoint().X < newSplit)
                    {
                        newLeft.Add(n);
                    }
                    if (n.getPoint().X > newSplit)
                    {
                        newRight.Add(n);
                    }
                    // ak by mali rovnaku suradnicu, aby sa nepridavali len do jedneho podstromu
                    if (n.getPoint().X == newSplit)
                    {
                        if (equal){
                            newLeft.Add(n);
                            equal = false;
                        } else {
                            newRight.Add(n);
                            equal = true;
                        }
                    }
                }

            } else { //split cez y-ovu os
                foreach (KDNode n in l)
                {
                    // zoznam listov v lavom a pravom podstrome podla split
                    if (n.getPoint().Y < newSplit)
                    {
                        newLeft.Add(n);
                    }
                    if (n.getPoint().Y > newSplit)
                    {
                        newRight.Add(n);
                    }
                    // ak by mali rovnaku suradnicu, aby sa nepridavali len do jedneho podstromu
                    if (n.getPoint().Y == newSplit)
                    {
                        if (equal)
                        {
                            newLeft.Add(n);
                            equal = false;
                        } else {
                            newRight.Add(n);
                            equal = true;
                        }
                    }
                }
            }

            // vytvori sa koren noveho podstromu
            KDNode subroot = new KDNode(true, newSplit, dimension, null, this.g);
            if (newParent != null)
            {
                if (isLeft)
                {
                    newParent.setLeft(subroot);
                } else {
                    newParent.setRight(subroot);
                }
            }
            subroot.setParent(newParent);
            subroot.setLeft(rebuilt(newLeft, 1 - dimension, subroot, true));
            subroot.getLeft().setParent(subroot);
            subroot.setRight(rebuilt(newRight, 1 - dimension, subroot, false));
            subroot.getRight().setParent(subroot);

            return subroot;
        }
Ejemplo n.º 11
0
 //vrati podstrom, do ktoreho syna ma ist novy vrchol a bola by v nom narusena rovnovaha
 public KDNode findPlace(KDNode n, KDNode leaf) 
 {
     // ak n je list, potom sa rovnovaha nenarusi a iba sa novy vrchol vlozi.
     // z listu spravime otca dvoch listov v procedure rebuilt
     if(n.isLeaf)
     {
         //Console.Write(n.getPoint());
         //Console.WriteLine(" numLeafs " + n.getNumLeafs());
         return n;
     }
     //Console.Write(n.getSplit());
     //Console.WriteLine(" numLeafs right" + n.getRight().getNumLeafs());
     //Console.WriteLine(" numLeafs left" + n.getLeft().getNumLeafs());
     // ak to nie je list, potom hladame podstrom, ktoremu sa narusi rovnovaha.
     if (n.getDim() == 0) // split je v x-ovej suradnici
     {
         if (n.getSplit() >= leaf.getPoint().X) // ak ma ist do laveho podstromu
         {
             // a uz teraz je vlavo viac listov ako vpravo, narusi sa rovnovaha n
             if (n.getLeft().getNumLeafs() > n.getRight().getNumLeafs())
             {
                 return n;
             } else { // inak sa vrati podstrom z laveho podstromu, v ktorom je narusena rovnovaha
                 return findPlace(n.getLeft(), leaf);
             }
         } else { // ak ma ist do praveho podstromu
             // a uz teraz je vpravo viac listov ako vlavo, narusi sa rovnovaha n
             if (n.getLeft().getNumLeafs() < n.getRight().getNumLeafs()) 
             {
                 return n;
             } else { // inak sa vrati podstrom z praveho podstromu, v ktorom je narusena rovnovaha
                 return findPlace(n.getRight(), leaf);
             }
         }
     } else { // split je v y-ovej suradnici
         if (n.getSplit() >= leaf.getPoint().Y) // ak ma ist do laveho podstromu (= patri hore, nad split)
         {
             // a uz teraz je vlavo viac listov ako vpravo, narusi sa rovnovaha n
             if (n.getLeft().getNumLeafs() > n.getRight().getNumLeafs())
             {
                 return n;
             }
             else
             { // inak sa vrati podstrom z laveho podstromu, v ktorom je narusena rovnovaha
                 return findPlace(n.getLeft(), leaf);
             }
         }
         else
         { // ak ma ist do praveho podstromu (= patri dole, pod split)
             // a uz teraz je vpravo viac listov ako vlavo, narusi sa rovnovaha n
             if (n.getLeft().getNumLeafs() < n.getRight().getNumLeafs())
             {
                 return n;
             }
             else
             { // inak sa vrati podstrom z praveho podstromu, v ktorom je narusena rovnovaha
                 return findPlace(n.getRight(), leaf);
             }
         }
     }
 }