cQuadtree.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cQuadtree_H
#define _INC_cQuadtree_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cPoint2.h"
#include "cRectT.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cObject.h"
 
namespace GrayLib
{
        UNITTEST2_PREDEF(cQuadtree);
 
        struct cQuadCommon      // static
        {
 
                typedef double DVALUE_t;
                typedef cVecT2<DVALUE_t> POINTQ_t;
                typedef cRectFT<DVALUE_t> RECTQ_t;
        };
 
        interface IQuadObject : public cQuadCommon
        {
 
                virtual const RECTQ_t& get_QuadRect() const = 0;
                // virtual HASHCODE_t get_HashCodeX() const; // ???
        };
 
        interface IQuadVisit : public cQuadCommon
        {
                virtual bool ObjectIntersect(IQuadObject* pObj, const RECTQ_t& rect) = 0;
        };
 
        class cQuadResultArray
                : public cArrayPtr< IQuadObject >
                , public IQuadVisit
        {
        public:
                virtual bool ObjectIntersect(IQuadObject* pObj, const RECTQ_t& rect) override
                {
                        UNREFERENCED_REFERENCE(rect);
                        ITERATE_t i = this->AddTail(pObj);
                        return(i >= 0);
                }
        };
 
        class GRAYLIB_LINK cQuadtree : public cQuadCommon
        {
 
        public:
                typedef cArrayPtr<IQuadObject> ARRAYOBJ_t;      // HASHCODE_t?
 
        private:
                static const size_t k_CAPACITY = 4;     
                RECTQ_t m_rcBoundary;
                ARRAYOBJ_t m_aObjects;
                cQuadtree* m_qc[4];                             
 
        protected:
                RECTQ_t GetRect(size_t i, const POINTQ_t& ptCenter) const;
                bool CollapseCheck(size_t i);
 
        public:
                cQuadtree(RECTQ_t boundary);
                ~cQuadtree();
 
                bool isEmptyQuad() const;
                void RemoveAll();
 
                const RECTQ_t& get_Boundary() const
                {
                        return m_rcBoundary;
                }
                bool SetBoundary(const RECTQ_t& rect, OUT ARRAYOBJ_t& aBumped);
 
                bool AddObject(const RECTQ_t& rect, IQuadObject* pObj);
                bool AddObject(IQuadObject* pObj)
                {
                        if (pObj == nullptr)
                                return false;
                        return AddObject(pObj->get_QuadRect(), pObj);
                }
 
                void AddObjectGrow(IQuadObject* pObj);
 
                bool RemoveObject(const RECTQ_t& rect, IQuadObject* pObj);
                bool RemoveObject(IQuadObject* pObj)
                {
                        if (pObj == nullptr)
                                return true;
                        return RemoveObject(pObj->get_QuadRect(), pObj);
                }
 
                bool VisitObjectsOverlap(const RECTQ_t& rect, IQuadVisit* pVisit) const;
 
                UNITTEST_FRIEND(cQuadtree);     
        };
}
 
#endif